Return to vector.h CVS log

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

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

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