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

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.