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     ! 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.