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

1.1       paf         1: /*
1.27      paf         2:        Parser
                      3:        Copyright (c) 2001 ArtLebedev Group (http://www.artlebedev.com)
1.28      paf         4:        Author: Alexander Petrosyan <paf@design.ru> (http://design.ru/paf)
1.27      paf         5: 
1.30    ! paf         6:        $Id: pa_pool.h,v 1.29 2001/03/11 12:04:43 paf Exp $
1.1       paf         7: */
                      8: 
                      9: #ifndef PA_POOL_H
                     10: #define PA_POOL_H
                     11: 
                     12: #include <stddef.h>
                     13: 
1.21      paf        14: class Exception;
1.25      paf        15: class Temp_exception;
1.1       paf        16: 
                     17: class Pool {
1.25      paf        18:        friend Temp_exception;
1.1       paf        19: public:
1.18      paf        20: 
1.30    ! paf        21:        Pool() : 
        !            22:                fexception_to_trhow(0),
        !            23:                fpending_exception(0) {
        !            24:        }
1.18      paf        25:        ~Pool() {}
                     26: 
1.30    ! paf        27:        Exception& exception_to_throw() const { return *fexception_to_throw; }
        !            28:        //Exception *pending_exception() const { return fpending_exception; }
1.18      paf        29: 
                     30:        void *malloc(size_t size) {
                     31:                return check(real_malloc(size), size);
                     32:        }
                     33:        void *calloc(size_t size) {
                     34:                return check(real_calloc(size), size);
                     35:        }
1.8       paf        36: 
1.30    ! paf        37:        void maybe_rethrow_pending_exception() {
        !            38:                if(fpending_exception)
        !            39:                        fexception_to_throw._throw(
        !            40:                                fpending_exception.type(),
        !            41:                                fpending_exception.code(),
        !            42:                                fpending_exception.problem_source(),
        !            43:                                fpending_exception.comment()
        !            44:                        );
        !            45:        }
        !            46: 
1.23      paf        47: private: // implementation defined
1.18      paf        48: 
1.20      paf        49:     void *real_malloc(size_t size);
                     50:     void *real_calloc(size_t size);
1.17      paf        51: 
1.23      paf        52: private: 
1.17      paf        53: 
1.23      paf        54:        // checks whether mem allocated OK. throws exception otherwise
                     55:        void *check(void *ptr, size_t size) {
                     56:                if(ptr)
                     57:                        return ptr;
                     58: 
                     59:                fail(size);
                     60: 
                     61:                // never reached
                     62:                return 0;
                     63:        }
1.24      paf        64:        // throws proper exception
1.23      paf        65:        void fail(size_t size) const;
                     66: 
                     67: protected: // exception handling
1.17      paf        68: 
1.23      paf        69:        // exception replacement mechanism is 'protected' from direct usage
1.24      paf        70:        // Temp_exception_change object enforces paired set/restore
1.23      paf        71:        Exception *set_exception(Exception *e){
1.30    ! paf        72:                Exception *r=fexception_to_throw;
        !            73:                fexception_to_throw=e;
1.23      paf        74:                return r;
                     75:        }
                     76:        void restore_exception(Exception *e) {
1.30    ! paf        77:                fpending_exception=fexception_to_throw.is_handled()?0:fexception_to_throw;
        !            78:                fexception_to_throw=e;
1.23      paf        79:        }
                     80: 
                     81: private:
                     82: 
                     83:        // current request's exception object
1.30    ! paf        84:        Exception *fexception_to_throw;
        !            85: 
        !            86:        // just catched request's exception object
        !            87:        Exception *fpending_exception;
1.17      paf        88: 
1.8       paf        89: private: //disabled
                     90: 
1.18      paf        91:        // Pool(const Pool&) {}
1.16      paf        92:        Pool& operator = (const Pool&) { return *this; }
1.21      paf        93: };
                     94: 
                     95: class Pooled {
1.23      paf        96:        // the pool i'm allocated on
                     97:        Pool& fpool;
1.21      paf        98: public:
1.23      paf        99:        
1.21      paf       100:        static void *operator new(size_t size, Pool& apool) { 
                    101:                return apool.malloc(size);
                    102:        }
                    103: 
1.23      paf       104:        Pooled(Pool& apool) : fpool(apool) {
                    105:        }
                    106: 
1.22      paf       107:        Pool& pool() const { return fpool; }
1.21      paf       108: 
1.23      paf       109:        void *malloc(size_t size) const { return fpool.malloc(size); }
                    110:        void *calloc(size_t size) const { return fpool.calloc(size); }
                    111: };
                    112: #define NEW new(pool())
                    113: 
1.25      paf       114: class Temp_exception {
1.29      paf       115:        Pool& fpool;
1.23      paf       116:        Exception *saved_exception;
                    117: public:
1.25      paf       118:        Temp_exception(Pool& apool, Exception& exception) : 
1.29      paf       119:                fpool(apool),
1.23      paf       120:                saved_exception(apool.set_exception(&exception)) {
                    121:        }
1.25      paf       122:        ~Temp_exception() { 
1.29      paf       123:                fpool.restore_exception(saved_exception); 
1.23      paf       124:        }
1.30    ! paf       125: public:
        !           126:        bool triggered;
1.1       paf       127: };
1.23      paf       128: 
1.30    ! paf       129: #define XTRY(p) \
1.24      paf       130:        { \
                    131:                Exception temp_exception; \
1.30    ! paf       132:                Temp_exception le(p, temp_exception); \
1.24      paf       133:                if(setjmp(temp_exception.mark)==0)
1.30    ! paf       134: #define XTHROW(p) p.exception_to_throw()._throw
        !           135: #define XCATCH(e) \
1.24      paf       136:                else{ \
                    137:                        Exception& e=temp_exception;
1.30    ! paf       138: #define XFINALLY(p) \
1.24      paf       139:                } \
1.30    ! paf       140:                p.maybe_rethrow_pending_exception();
        !           141: #define XEND_TRY \
1.24      paf       142:        }
1.30    ! paf       143: 
1.23      paf       144: // usage:
1.30    ! paf       145: //   TRY { ...; if(?) RAISE(?); ...; } CATCH(e) { catch-code e.comment() } END_TRY
        !           146: 
        !           147: #define TRY XTRY(pool())
        !           148: #define THROW XTHROW(pool())
        !           149: #define CATCH(e) XCATCH(e)
        !           150: #define FINALLY(p) XFINALLY(pool())
        !           151: #define END_TRY XEND_TRY
        !           152: 
        !           153: #define PTRY XTRY(pool)
        !           154: #define PTHROW XTHROW(pool)
        !           155: #define PCATCH(e) XCATCH(e)
        !           156: #define PINALLY(p) XFINALLY(pool)
        !           157: #define PEND_TRY XEND_TRY
        !           158: 
        !           159: #define RTRY XTRY(r.pool())
        !           160: #define RTHROW XTHROW(r.pool())
        !           161: #define RCATCH(e) XCATCH(e)
        !           162: #define RFINALLY(p) XFINALLY(r.pool())
        !           163: #define REND_TRY XEND_TRY
1.1       paf       164: 
                    165: #endif

E-mail: