![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to Block.h CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10no / cmd / cfront / ptcfront|
Return to Block.h CVS log | Up to [Research Unix] / researchv10no / cmd / cfront / ptcfront |
1.1 root 1: #ifndef BLOCK_H
2: #define BLOCK_H 1
3: #ifndef GENERICH
4: #include <generic.h>
5: #endif
6:
7: #define Block(T)name2(Block_,T)
8:
9: #define Blockdeclare(T) \
10: \
11: class Block(T) { \
12: public: \
13: unsigned size() { return n; } \
14: unsigned size(unsigned k) { move(new T[k], k); return n; } \
15: Block(T)() { n = 0; p = 0; } \
16: Block(T)(unsigned k) { n = 0; p = 0; size(k); } \
17: Block(T)(const Block(T)& b) { copy(b); } \
18: ~Block(T)() { delete[n] p; } \
19: Block(T)& operator=(const Block(T)& b) { \
20: delete[n] p; \
21: copy(b); \
22: return *this; \
23: } \
24: operator T*() { return p; } \
25: operator const T*() const { return p; } \
26: T* end() { return p + n; } \
27: const T* end() const { return p + n; } \
28: T& operator[](int i) { return p[i]; } \
29: const T& operator[](int i) const { return p[i]; } \
30: int reserve(unsigned k) { return k<n || grow(k); } \
31: void swap(Block(T)& b); \
32: private: \
33: T* p; \
34: unsigned n; \
35: void move(T*, unsigned); \
36: void transfer(T*, unsigned); \
37: void clear(T*, unsigned); \
38: void copy(const Block(T)&); \
39: unsigned grow(unsigned); \
40: }; \
41: \
42:
43: #define Blockimplement(T) \
44: \
45: static T name2(Block(T),_def); \
46: \
47: /* Clear k elements starting at v */ \
48: void \
49: Block(T)::clear(T* v, unsigned k) \
50: { \
51: register T* p = v; \
52: register T* lim = v + k; \
53: while (p < lim) \
54: *p++ = name2(Block(T),_def); \
55: } \
56: \
57: /* This Block was uninitialized, is now a copy of b */ \
58: void \
59: Block(T)::copy(const Block(T)& b) \
60: { \
61: p = new T[b.n]; \
62: if (p) { \
63: n = b.n; \
64: transfer(b.p, n); \
65: } else \
66: n = 0; \
67: } \
68: \
69: /* Grow this Block by 1.5 until it can contain at least k+1 */ \
70: unsigned \
71: Block(T)::grow(unsigned k) \
72: { \
73: unsigned nn = n; \
74: if (nn == 0) \
75: nn++; \
76: while (nn <= k) \
77: nn += (nn >> 1) + 1; \
78: T* np = new T[nn]; \
79: if (!np) { \
80: nn = k+1; \
81: np = new T[nn]; \
82: } \
83: move(np, nn); \
84: return n; \
85: } \
86: \
87: /* Transfer len (or fewer) elements into this Block. */ \
88: void \
89: Block(T)::transfer(T* source, unsigned len) \
90: { \
91: register T* plim; \
92: register T* pp = p; \
93: register T* q = source; \
94: \
95: if (n > len) { \
96: plim = p + len; \
97: clear(plim, n - len); \
98: } else \
99: plim = p + n; \
100: \
101: while (pp < plim) \
102: *pp++ = *q++; \
103: } \
104: \
105: /* \
106: * The contents of this Block now live in memory starting at np \
107: * If np is 0, null out this Block. \
108: */ \
109: void \
110: Block(T)::move(T* np, unsigned nn) \
111: { \
112: T* oldp = p; \
113: unsigned oldn = n; \
114: p = np; \
115: if (np) { \
116: n = nn; \
117: transfer(oldp, oldn); \
118: } else \
119: n = 0; \
120: delete[oldn] oldp; \
121: } \
122: \
123: /* Exchange the contents of this Block with another Block */ \
124: void \
125: Block(T)::swap(Block(T)& b) \
126: { \
127: T* bp = b.p; \
128: unsigned bn = b.n; \
129: b.p = p; \
130: b.n = n; \
131: p = bp; \
132: n = bn; \
133: } \
134: \
135:
136:
137: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.