Return to pa_pool.h CVS log

Up to [parser3project] / parser3 / src / include

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

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.33    ! paf         6:        $Id: pa_pool.h,v 1.32 2001/03/13 16:38:22 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.31      paf        21:        Pool() : fexception(0) {}
1.18      paf        22:        ~Pool() {}
                     23: 
1.31      paf        24:        Exception& exception() const { return *fexception; }
1.18      paf        25: 
                     26:        void *malloc(size_t size) {
                     27:                return check(real_malloc(size), size);
                     28:        }
                     29:        void *calloc(size_t size) {
                     30:                return check(real_calloc(size), size);
                     31:        }
1.8       paf        32: 
1.23      paf        33: private: // implementation defined
1.18      paf        34: 
1.20      paf        35:     void *real_malloc(size_t size);
                     36:     void *real_calloc(size_t size);
1.17      paf        37: 
1.23      paf        38: private: 
1.17      paf        39: 
1.23      paf        40:        // checks whether mem allocated OK. throws exception otherwise
                     41:        void *check(void *ptr, size_t size) {
                     42:                if(ptr)
                     43:                        return ptr;
                     44: 
                     45:                fail(size);
                     46: 
                     47:                // never reached
                     48:                return 0;
                     49:        }
1.24      paf        50:        // throws proper exception
1.23      paf        51:        void fail(size_t size) const;
                     52: 
                     53: protected: // exception handling
1.17      paf        54: 
1.23      paf        55:        // exception replacement mechanism is 'protected' from direct usage
1.24      paf        56:        // Temp_exception_change object enforces paired set/restore
1.23      paf        57:        Exception *set_exception(Exception *e){
1.31      paf        58:                Exception *r=fexception;
                     59:                fexception=e;
1.23      paf        60:                return r;
                     61:        }
                     62:        void restore_exception(Exception *e) {
1.31      paf        63:                fexception=e;
1.23      paf        64:        }
                     65: 
                     66: private:
                     67: 
                     68:        // current request's exception object
1.31      paf        69:        Exception *fexception;
1.17      paf        70: 
1.8       paf        71: private: //disabled
                     72: 
1.18      paf        73:        // Pool(const Pool&) {}
1.16      paf        74:        Pool& operator = (const Pool&) { return *this; }
1.21      paf        75: };
                     76: 
                     77: class Pooled {
1.23      paf        78:        // the pool i'm allocated on
                     79:        Pool& fpool;
1.21      paf        80: public:
1.23      paf        81:        
1.21      paf        82:        static void *operator new(size_t size, Pool& apool) { 
                     83:                return apool.malloc(size);
                     84:        }
                     85: 
1.23      paf        86:        Pooled(Pool& apool) : fpool(apool) {
                     87:        }
                     88: 
1.22      paf        89:        Pool& pool() const { return fpool; }
1.21      paf        90: 
1.23      paf        91:        void *malloc(size_t size) const { return fpool.malloc(size); }
                     92:        void *calloc(size_t size) const { return fpool.calloc(size); }
1.31      paf        93:        Exception& exception() const { return fpool.exception(); }
1.23      paf        94: };
                     95: #define NEW new(pool())
                     96: 
1.25      paf        97: class Temp_exception {
1.29      paf        98:        Pool& fpool;
1.23      paf        99:        Exception *saved_exception;
                    100: public:
1.25      paf       101:        Temp_exception(Pool& apool, Exception& exception) : 
1.29      paf       102:                fpool(apool),
1.23      paf       103:                saved_exception(apool.set_exception(&exception)) {
                    104:        }
1.25      paf       105:        ~Temp_exception() { 
1.29      paf       106:                fpool.restore_exception(saved_exception); 
1.23      paf       107:        }
1.1       paf       108: };
1.23      paf       109: 
1.33    ! paf       110: #define XTRY(pool) \
1.24      paf       111:        { \
                    112:                Exception temp_exception; \
1.33    ! paf       113:                Temp_exception le(pool, temp_exception); \
1.24      paf       114:                if(setjmp(temp_exception.mark)==0)
1.31      paf       115: 
1.33    ! paf       116: #define XTHROW(exception) exception._throw
        !           117: #define XCATCH(e) \
1.24      paf       118:                else{ \
                    119:                        Exception& e=temp_exception;
1.31      paf       120: 
1.33    ! paf       121: #define XEND_CATCH \
1.24      paf       122:                } \
                    123:        }
1.23      paf       124: // usage:
1.31      paf       125: //   TRY { ...; if(?) RAISE(?); ...; } CATCH(e) { catch-code e.comment() } END_CATCH
1.33    ! paf       126: 
        !           127: #define TRY XTRY(pool())
        !           128: #define THROW XTHROW(exception())
        !           129: #define CATCH(e) XCATCH(e)
        !           130: #define END_CATCH XEND_CATCH 
        !           131: 
        !           132: #define PTRY XTRY(pool)
        !           133: #define PTHROW XTHROW(pool.exception())
        !           134: #define PCATCH(e) XCATCH(e)
        !           135: #define PEND_CATCH XEND_CATCH 
        !           136: 
        !           137: #define RTHROW XTHROW(r.pool().exception())
1.1       paf       138: 
                    139: #endif