Return to pa_pool.h CVS log

Up to [parser3project] / parser3 / src / include

Annotation of parser3/src/include/pa_pool.h, revision 1.23

1.1       paf         1: /*
1.23    ! paf         2:   $Id: pa_pool.h,v 1.22 2001/02/20 18:45:51 paf Exp $
1.1       paf         3: */
                      4: 
                      5: #ifndef PA_POOL_H
                      6: #define PA_POOL_H
                      7: 
                      8: #include <stddef.h>
                      9: 
1.23    ! paf        10: //class String;
1.21      paf        11: class Exception;
1.23    ! paf        12: class Local_exception;
1.1       paf        13: 
                     14: class Pool {
1.23    ! paf        15:        friend Local_exception;
1.1       paf        16: public:
1.18      paf        17: 
                     18:        // Exception to report pool errors 
1.23    ! paf        19:        Pool(Exception& aexception) : fexception(&aexception) {}
1.18      paf        20:        ~Pool() {}
                     21: 
1.23    ! paf        22:        Exception& exception() const { return *fexception; }
1.18      paf        23: 
                     24:        void *malloc(size_t size) {
                     25:                return check(real_malloc(size), size);
                     26:        }
                     27:        void *calloc(size_t size) {
                     28:                return check(real_calloc(size), size);
                     29:        }
1.8       paf        30: 
1.23    ! paf        31: private: // implementation defined
1.18      paf        32: 
1.20      paf        33:     void *real_malloc(size_t size);
                     34:     void *real_calloc(size_t size);
1.17      paf        35: 
1.23    ! paf        36: private: 
1.17      paf        37: 
1.23    ! paf        38:        // checks whether mem allocated OK. throws exception otherwise
        !            39:        void *check(void *ptr, size_t size) {
        !            40:                if(ptr)
        !            41:                        return ptr;
        !            42: 
        !            43:                fail(size);
        !            44: 
        !            45:                // never reached
        !            46:                return 0;
        !            47:        }
        !            48:        // raises proper exception
        !            49:        void fail(size_t size) const;
        !            50: 
        !            51: protected: // exception handling
1.17      paf        52: 
1.23    ! paf        53:        // exception replacement mechanism is 'protected' from direct usage
        !            54:        // Local_exception object enforces paired set/restore
        !            55:        Exception *set_exception(Exception *e){
        !            56:                Exception *r=fexception;
        !            57:                fexception=e;
        !            58:                return r;
        !            59:        }
        !            60:        void restore_exception(Exception *e) {
        !            61:                fexception=e;
        !            62:        }
        !            63: 
        !            64: private:
        !            65: 
        !            66:        // current request's exception object
        !            67:        Exception *fexception;
1.17      paf        68: 
1.8       paf        69: private: //disabled
                     70: 
1.18      paf        71:        // Pool(const Pool&) {}
1.16      paf        72:        Pool& operator = (const Pool&) { return *this; }
1.21      paf        73: };
                     74: 
                     75: class Pooled {
1.23    ! paf        76:        // the pool i'm allocated on
        !            77:        Pool& fpool;
1.21      paf        78: public:
1.23    ! paf        79:        
1.21      paf        80:        static void *operator new(size_t size, Pool& apool) { 
                     81:                return apool.malloc(size);
                     82:        }
                     83: 
1.23    ! paf        84:        Pooled(Pool& apool) : fpool(apool) {
        !            85:        }
        !            86: 
1.22      paf        87:        Pool& pool() const { return fpool; }
1.21      paf        88: 
1.23    ! paf        89:        void *malloc(size_t size) const { return fpool.malloc(size); }
        !            90:        void *calloc(size_t size) const { return fpool.calloc(size); }
        !            91:        Exception& exception() const { return fpool.exception(); }
        !            92: };
        !            93: #define NEW new(pool())
        !            94: 
        !            95: class Local_exception {
        !            96:        Pool pool;
        !            97:        Exception *saved_exception;
        !            98: public:
        !            99:        Local_exception(Pool& apool, Exception& exception) : 
        !           100:                pool(apool),
        !           101:                saved_exception(apool.set_exception(&exception)) {
        !           102:        }
        !           103:        ~Local_exception() { 
        !           104:                pool.restore_exception(saved_exception); 
        !           105:        }
1.1       paf       106: };
1.23    ! paf       107: 
        !           108: #define TRY if(setjmp((exception()).mark)==0){
        !           109: #define THROW exception()._throw
        !           110: #define CATCH(e) }else{ Exception& e=exception();
        !           111: #define END_CATCH }
        !           112: // usage:
        !           113: //   TRY { ...; if(?) RAISE(?); ...; } CATCH { catch-code EXCEPTION.comment() }
1.1       paf       114: 
                    115: #endif