Return to xBlock.h CVS log

Up to [Research Unix] / researchv10no / cmd / cfront / ptcfront

Annotation of researchv10no/cmd/cfront/ptcfront/xBlock.h, revision 1.1

1.1     ! root        1: /*ident        "@(#)ctrans:src/Block.h 1.2" */
        !             2: 
        !             3: #ifndef BLOCK_H
        !             4: #define BLOCK_H
        !             5: #include <new.h>
        !             6: 
        !             7: PT_names
        !             8:        Block(T)        Block_ T
        !             9: PT_end
        !            10: 
        !            11: PT_define Blockdeclare(T)
        !            12: 
        !            13: class Block(T) {
        !            14: public:
        !            15:        unsigned size() const { return n; }
        !            16:        unsigned size(unsigned);
        !            17:        Block(T)() { n = 0; p = 0; }
        !            18:        Block(T)(unsigned k) { n = 0; p = 0; size(k); }
        !            19:        Block(T)(const Block(T)& b) { copy(b); }
        !            20:        ~Block(T)();
        !            21:        Block(T)& operator=(const Block(T)&);
        !            22:        operator T*() { return p; }
        !            23:        operator const T*() const { return p; }
        !            24:        T* end() { return p + n; }
        !            25:        const T* end() const { return p + n; }
        !            26:        T& operator[](int i) { return p[i]; }
        !            27:        const T& operator[](int i) const { return p[i]; }
        !            28:        int reserve(unsigned k) { return k<n || grow(k); }
        !            29:        void swap(Block(T)& b);
        !            30: private:
        !            31:        T* p;
        !            32:        unsigned n;
        !            33:        void move(T*, unsigned);
        !            34:        void transfer(T*, unsigned);
        !            35:        void clear(T*, unsigned);
        !            36:        void copy(const Block(T)&);
        !            37:        unsigned grow(unsigned);
        !            38:        static T* default_value();
        !            39: };
        !            40: 
        !            41: PT_end
        !            42: 
        !            43: PT_define Blockimplement(T)
        !            44: 
        !            45: unsigned Block(T)::size(unsigned k)
        !            46: {
        !            47:        if (k != n)
        !            48:                move(new T[k], k);
        !            49:        return n;
        !            50: }
        !            51: Block(T)::~Block(T)()
        !            52: {
        !            53:        delete[] p;
        !            54: }
        !            55: Block(T)& Block(T)::operator=(const Block(T)& b)
        !            56: {
        !            57:        delete[] p;
        !            58:        copy(b);
        !            59:        return *this;
        !            60: }
        !            61: 
        !            62: /* Clear k elements starting at v */
        !            63: void
        !            64: Block(T)::clear(T* v, unsigned k)
        !            65: {
        !            66:        register T* p = v;
        !            67:        register T* lim = v + k;
        !            68:        T* valptr = default_value();
        !            69:        while (p < lim) {
        !            70:                *p++ = *valptr;
        !            71:        }
        !            72: }
        !            73: 
        !            74: /* Make this a copy of b */
        !            75: void
        !            76: Block(T)::copy(const Block(T)& b)
        !            77: {
        !            78:        // assert (p is 0 or garbage)
        !            79:        p = new T[b.n];
        !            80:        if (p) {
        !            81:                n = b.n;
        !            82:                transfer(b.p, n);
        !            83:        } else
        !            84:                n = 0;
        !            85: }
        !            86: 
        !            87: /* Grow this Block by 1.5 until it can contain at least k+1 */
        !            88: unsigned
        !            89: Block(T)::grow(unsigned k)
        !            90: {
        !            91:        unsigned nn = n;
        !            92:        if (nn == 0)
        !            93:                nn++;
        !            94:        while (nn <= k)
        !            95:                nn += (nn >> 1) + 1;
        !            96:        T* np = new T[nn];
        !            97:        if (!np) {
        !            98:                nn = k+1;
        !            99:                np = new T[nn];
        !           100:        }
        !           101:        move(np, nn);
        !           102:        return n;
        !           103: }
        !           104: 
        !           105: /* Transfer len (or fewer) elements into this Block. */
        !           106: void
        !           107: Block(T)::transfer(T* source, unsigned len)
        !           108: {
        !           109:        register T* plim;
        !           110:        register T* pp = p;
        !           111:        register T* q = source;
        !           112: 
        !           113:        if (n > len) {
        !           114:                plim = p + len;
        !           115:                clear(plim, n - len);
        !           116:        } else
        !           117:                plim = p + n;
        !           118: 
        !           119:        while (pp < plim)
        !           120:                *pp++ = *q++;
        !           121: }
        !           122: 
        !           123: /*
        !           124:  * The contents of this Block now live in memory starting at np
        !           125:  * If np is 0, null out this Block.
        !           126:  */
        !           127: void
        !           128: Block(T)::move(T* np, unsigned nn)
        !           129: {
        !           130:        T* oldp = p;
        !           131:        unsigned oldn = n;
        !           132:        p = np;
        !           133:        if (np) {
        !           134:                n = nn;
        !           135:                transfer(oldp, oldn);
        !           136:        } else
        !           137:                n = 0;
        !           138:        delete[] oldp;
        !           139: }
        !           140: 
        !           141: /* Exchange the contents of this Block with another Block */
        !           142: void
        !           143: Block(T)::swap(Block(T)& b)
        !           144: {
        !           145:        T* bp = b.p;
        !           146:        unsigned bn = b.n;
        !           147:        b.p = p;
        !           148:        b.n = n;
        !           149:        p = bp;
        !           150:        n = bn;
        !           151: }
        !           152: 
        !           153: T*
        !           154: Block(T)::default_value() {
        !           155:        static T default_item;
        !           156:        return(&default_item);
        !           157: }
        !           158: 
        !           159: PT_end
        !           160: 
        !           161: 
        !           162: #endif

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