Return to vector.h CVS log

Up to [Research Unix] / researchv9 / cmd / cfront / libC / generic

Annotation of researchv9/cmd/cfront/libC/generic/vector.h, revision 1.1

1.1     ! root        1: 
        !             2: #ifndef GENERICH
        !             3: #include <generic.h>
        !             4: #endif
        !             5: 
        !             6: #define vector(type) name2(type,vector)
        !             7: #define vectordeclare(type)                                                    \
        !             8: extern GPT errorhandler(vector,type);                                          \
        !             9: extern GPT set_handler(vector,type,GPT);                                       \
        !            10: class vector(type) {                                                           \
        !            11:        type* v;                                                                \
        !            12:        int sz;                                                                 \
        !            13: public:                                                                                \
        !            14:        vector(type)(int s)                                                     \
        !            15:        {       if (s<=0) callerror(vector,type,1,"bad vector size");           \
        !            16:                v = new type[sz=s];                                             \
        !            17:        }                                                                       \
        !            18:        ~vector(type)() { delete[sz] v; }                                       \
        !            19:        vector(type)(vector(type)&);                                            \
        !            20:        vector(type)& operator=(vector(type)&);                                 \
        !            21:        int size() { return sz; }                                               \
        !            22:        void set_size(int);                                                     \
        !            23:        type& elem(int i) { return v[i]; }                                      \
        !            24:        type& operator[](int i)                                                 \
        !            25:        {       if (i<0 || sz<=i)                                               \
        !            26:                        callerror(vector,type,2,"vector index out of range");   \
        !            27:                return v[i];                                                    \
        !            28:        }                                                                       \
        !            29: };
        !            30: 
        !            31: #define vectorimplement(type)                                                  \
        !            32: GPT errorhandler(vector,type) = genericerror;                                  \
        !            33: vector(type)::vector(type)(vector(type)& a)                                    \
        !            34: {                                                                              \
        !            35:        register i = a.sz;                                                      \
        !            36:        sz = i;                                                                 \
        !            37:        v = new type[i];                                                        \
        !            38:        register type* vv = &v[i];                                              \
        !            39:        register type* av = &a.v[i];                                            \
        !            40:        while (i--) *--vv = *--av;                                              \
        !            41: }                                                                              \
        !            42:                                                                                \
        !            43: vector(type)& vector(type)::operator=(vector(type)& a)                         \
        !            44: {                                                                              \
        !            45:        register i = a.sz;                                                      \
        !            46:        if (i != sz)                                                            \
        !            47:                callerror(vector,type,3,"different vector sizes in assignment");\
        !            48:        register type* vv = &v[i];                                              \
        !            49:        register type* av = &a.v[i];                                            \
        !            50:        while (i--) *--vv = *--av;                                              \
        !            51:        delete[i] v;                                                            \
        !            52:        return *this;                                                           \
        !            53: }                                                                              \
        !            54:                                                                                \
        !            55: void vector(type)::set_size(int s)                                             \
        !            56: {                                                                              \
        !            57:        if (s<=0) callerror(vector,type,4,"bad new vector size");               \
        !            58:        type* nv = new type[s];                                                 \
        !            59:        register i = (s<=sz)?s:sz;                                              \
        !            60:        register type* vv = &v[i];                                              \
        !            61:        register type* av = &nv[i];                                             \
        !            62:        while (i--) *--vv = *--av;                                              \
        !            63:        delete[sz] v;                                                           \
        !            64:        v = nv;                                                                 \
        !            65:        sz = s;                                                                 \
        !            66: }                                                                              \
        !            67:                                                                                \
        !            68: GPT set_handler(vector,type, GPT a)                                            \
        !            69: {                                                                              \
        !            70:        GPT oo = errorhandler(vector,type);                                     \
        !            71:        errorhandler(vector,type) = a;                                          \
        !            72:        return oo;                                                              \
        !            73: }
        !            74:        
        !            75:        
        !            76: 
        !            77: #define stack(type) name2(type,stack)
        !            78: 
        !            79: #define stackdeclare(type)                                                     \
        !            80: extern GPT errorhandler(stack,type);                                           \
        !            81: extern GPT set_handler(stack,type,GPT);                                                \
        !            82: class stack(type) : vector(type) {                                             \
        !            83:        int t;                                                                  \
        !            84: public:                                                                                \
        !            85:        stack(type)(int s) : (s) { t = 0; }                                     \
        !            86:        stack(type)(stack(type)& a) : ((vector(type)&)a) { t = a.t; }           \
        !            87:        void push(type& a)                                                      \
        !            88:        {       if (t==size()-1) callerror(stack,type,1,"stack overflow");      \
        !            89:                elem(++t) = a;                                                  \
        !            90:        }                                                                       \
        !            91:        type pop()                                                              \
        !            92:        {       if (t==0) callerror(stack,type,2,"stack underflow");            \
        !            93:                return elem(t--);                                               \
        !            94:        }                                                                       \
        !            95:        type& top()                                                             \
        !            96:        {       if (t==0) callerror(stack,type,3,"stack empty");                \
        !            97:                return elem(t);                                                 \
        !            98:        }                                                                       \
        !            99: };
        !           100: 
        !           101: #define stackimplement(type)                                                   \
        !           102: GPT errorhandler(stack,type);                                                  \
        !           103: GPT set_handler(stack,type, GPT a)                                             \
        !           104: {                                                                              \
        !           105:        GPT oo = errorhandler(stack,type);                                      \
        !           106:        errorhandler(stack,type) = a;                                           \
        !           107:        return oo;                                                              \
        !           108: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.