Return to Bits.h CVS log

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

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

1.1     ! root        1: /*ident        "@(#)ctrans:src/Bits.h  1.2" */
        !             2: 
        !             3: #ifndef _BITS_H
        !             4: #define _BITS_H
        !             5: 
        !             6: #include "Block.h"
        !             7: 
        !             8: typedef unsigned long Bits_chunk;
        !             9: static const int Bits_shift_ATTLC = 5;
        !            10: static const int Bits_len_ATTLC = 1 << Bits_shift_ATTLC;
        !            11: static const int Bits_mask_ATTLC = Bits_len_ATTLC - 1;
        !            12: 
        !            13: Blockdeclare(Bits_chunk)
        !            14: 
        !            15: class Bits {
        !            16: private:
        !            17:        Block(Bits_chunk) b;
        !            18:        unsigned n;
        !            19: 
        !            20:        // the chunk number that contains bit n
        !            21:        unsigned chunk(unsigned n) const {
        !            22:                return n >> Bits_shift_ATTLC;
        !            23:        }
        !            24: 
        !            25:        // the number of chunks needed to contain an n-bit string
        !            26:        unsigned bound(unsigned n) const {
        !            27:                return (n + Bits_len_ATTLC - 1) >> Bits_shift_ATTLC;
        !            28:        }
        !            29: 
        !            30:        // a pointer to the (non-existent) chunk immediately
        !            31:        // after the last one in this Bits
        !            32:        Bits_chunk* limit() {
        !            33:                return b + bound(n);
        !            34:        }
        !            35:        const Bits_chunk* limit() const {
        !            36:                return b + bound(n);
        !            37:        }
        !            38: 
        !            39:        // turn off unused high-order bits in the high-order chunk
        !            40:        void normalize() {
        !            41:                register int ct = n & Bits_mask_ATTLC;
        !            42:                if (ct)
        !            43:                        b[chunk(n)] &= ~(~Bits_chunk(0) << ct);
        !            44:        }
        !            45: 
        !            46:        int compare(const Bits&) const;
        !            47:        int equal(const Bits&) const;
        !            48: 
        !            49: public:
        !            50:        Bits() { n = 0; }
        !            51:        Bits(Bits_chunk, unsigned = 1);
        !            52:        unsigned size() const { return n; }
        !            53:        unsigned size(unsigned);
        !            54:        friend Bits operator& (const Bits&, const Bits&);
        !            55:        friend Bits operator| (const Bits&, const Bits&);
        !            56:        friend Bits operator^ (const Bits&, const Bits&);
        !            57:        friend Bits operator~ (const Bits&);
        !            58:        friend Bits operator<< (const Bits&, int);
        !            59:        friend Bits operator>> (const Bits&, int);
        !            60:        friend int operator< (const Bits&, const Bits&);
        !            61:        friend int operator> (const Bits&, const Bits&);
        !            62:        friend int operator<= (const Bits&, const Bits&);
        !            63:        friend int operator>= (const Bits&, const Bits&);
        !            64:        friend int operator== (const Bits&, const Bits&);
        !            65:        friend int operator!= (const Bits&, const Bits&);
        !            66:        Bits& operator&= (const Bits&);
        !            67:        Bits& operator|= (const Bits&);
        !            68:        Bits& operator^= (const Bits&);
        !            69:        Bits& operator<<= (int);
        !            70:        Bits& operator>>= (int);
        !            71:        Bits& compl();
        !            72:        Bits& concat(const Bits&);
        !            73:        Bits& set(unsigned i) {
        !            74:                if (i < n)
        !            75:                        b[chunk(i)] |= Bits_chunk(1) << (i&Bits_mask_ATTLC);
        !            76:                return *this;
        !            77:        }
        !            78:        Bits& set(unsigned i, unsigned long x) {
        !            79:                if (i < n) {
        !            80:                        register Bits_chunk* p = &b[chunk(i)];
        !            81:                        register Bits_chunk mask = Bits_chunk(1) << (i&Bits_mask_ATTLC);
        !            82:                        if (x)
        !            83:                                *p |= mask;
        !            84:                        else
        !            85:                                *p &= ~mask;
        !            86:                }
        !            87:                return *this;
        !            88:        }
        !            89:        Bits& reset(unsigned i) {
        !            90:                if (i < n)
        !            91:                        b[chunk(i)] &= ~(Bits_chunk(1) << (i&Bits_mask_ATTLC));
        !            92:                return *this;
        !            93:        }
        !            94:        Bits& compl(unsigned i) {
        !            95:                if (i < n)
        !            96:                        b[chunk(i)] ^= Bits_chunk(1) << (i&Bits_mask_ATTLC);
        !            97:                return *this;
        !            98:        }
        !            99:        unsigned count() const;
        !           100:        operator Bits_chunk() const;
        !           101:        int operator[] (unsigned i) const {
        !           102:                if (i >= n)
        !           103:                        return 0;
        !           104:                else
        !           105:                        return (b[chunk(i)] >> (i&Bits_mask_ATTLC)) & 1;
        !           106:        }
        !           107:        unsigned signif() const;
        !           108:        unsigned trim() { return size(signif()); }
        !           109: };
        !           110: 
        !           111: inline int
        !           112: operator< (const Bits& a, const Bits& b)
        !           113: {
        !           114:        return a.compare(b) < 0;
        !           115: }
        !           116: 
        !           117: inline int
        !           118: operator> (const Bits& a, const Bits& b)
        !           119: {
        !           120:        return a.compare(b) > 0;
        !           121: }
        !           122: 
        !           123: inline int
        !           124: operator<= (const Bits& a, const Bits& b)
        !           125: {
        !           126:        return a.compare(b) <= 0;
        !           127: }
        !           128: 
        !           129: inline int
        !           130: operator>= (const Bits& a, const Bits& b)
        !           131: {
        !           132:        return a.compare(b) >= 0;
        !           133: }
        !           134: 
        !           135: inline int
        !           136: operator== (const Bits& a, const Bits& b)
        !           137: {
        !           138:        return a.equal(b);
        !           139: }
        !           140: 
        !           141: inline int
        !           142: operator!= (const Bits& a, const Bits& b)
        !           143: {
        !           144:        return !a.equal(b);
        !           145: }
        !           146: 
        !           147: Bits concat(const Bits&, const Bits&);
        !           148: 
        !           149: #endif

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