]>
Commit | Line | Data |
---|---|---|
ef416fc2 | 1 | //======================================================================== |
2 | // | |
3 | // Object.h | |
4 | // | |
5 | // Copyright 1996-2003 Glyph & Cog, LLC | |
6 | // | |
7 | //======================================================================== | |
8 | ||
9 | #ifndef OBJECT_H | |
10 | #define OBJECT_H | |
11 | ||
12 | #include <config.h> | |
13 | ||
14 | #ifdef USE_GCC_PRAGMAS | |
15 | #pragma interface | |
16 | #endif | |
17 | ||
18 | #include <stdio.h> | |
19 | #include <string.h> | |
20 | #include "gtypes.h" | |
21 | #include "gmem.h" | |
22 | #include "GString.h" | |
23 | ||
24 | class XRef; | |
25 | class Array; | |
26 | class Dict; | |
27 | class Stream; | |
28 | ||
29 | //------------------------------------------------------------------------ | |
30 | // Ref | |
31 | //------------------------------------------------------------------------ | |
32 | ||
33 | struct Ref { | |
34 | int num; // object number | |
35 | int gen; // generation number | |
36 | }; | |
37 | ||
38 | //------------------------------------------------------------------------ | |
39 | // object types | |
40 | //------------------------------------------------------------------------ | |
41 | ||
42 | enum ObjType { | |
43 | // simple objects | |
44 | objBool, // boolean | |
45 | objInt, // integer | |
46 | objReal, // real | |
47 | objString, // string | |
48 | objName, // name | |
49 | objNull, // null | |
50 | ||
51 | // complex objects | |
52 | objArray, // array | |
53 | objDict, // dictionary | |
54 | objStream, // stream | |
55 | objRef, // indirect reference | |
56 | ||
57 | // special objects | |
58 | objCmd, // command name | |
59 | objError, // error return from Lexer | |
60 | objEOF, // end of file return from Lexer | |
61 | objNone // uninitialized object | |
62 | }; | |
63 | ||
64 | #define numObjTypes 14 // total number of object types | |
65 | ||
66 | //------------------------------------------------------------------------ | |
67 | // Object | |
68 | //------------------------------------------------------------------------ | |
69 | ||
70 | #ifdef DEBUG_MEM | |
71 | #define initObj(t) ++numAlloc[type = t] | |
72 | #else | |
73 | #define initObj(t) type = t | |
74 | #endif | |
75 | ||
76 | class Object { | |
77 | public: | |
78 | ||
79 | // Default constructor. | |
80 | Object(): | |
81 | type(objNone) {} | |
82 | ||
83 | // Initialize an object. | |
84 | Object *initBool(GBool boolnA) | |
85 | { initObj(objBool); booln = boolnA; return this; } | |
86 | Object *initInt(int intgA) | |
87 | { initObj(objInt); intg = intgA; return this; } | |
88 | Object *initReal(double realA) | |
89 | { initObj(objReal); real = realA; return this; } | |
90 | Object *initString(GString *stringA) | |
91 | { initObj(objString); string = stringA; return this; } | |
92 | Object *initName(char *nameA) | |
93 | { initObj(objName); name = copyString(nameA); return this; } | |
94 | Object *initNull() | |
95 | { initObj(objNull); return this; } | |
96 | Object *initArray(XRef *xref); | |
97 | Object *initDict(XRef *xref); | |
98 | Object *initDict(Dict *dictA); | |
99 | Object *initStream(Stream *streamA); | |
100 | Object *initRef(int numA, int genA) | |
101 | { initObj(objRef); ref.num = numA; ref.gen = genA; return this; } | |
102 | Object *initCmd(char *cmdA) | |
103 | { initObj(objCmd); cmd = copyString(cmdA); return this; } | |
104 | Object *initError() | |
105 | { initObj(objError); return this; } | |
106 | Object *initEOF() | |
107 | { initObj(objEOF); return this; } | |
108 | ||
109 | // Copy an object. | |
110 | Object *copy(Object *obj); | |
111 | ||
112 | // If object is a Ref, fetch and return the referenced object. | |
113 | // Otherwise, return a copy of the object. | |
114 | Object *fetch(XRef *xref, Object *obj); | |
115 | ||
116 | // Free object contents. | |
117 | void free(); | |
118 | ||
119 | // Type checking. | |
120 | ObjType getType() { return type; } | |
121 | GBool isBool() { return type == objBool; } | |
122 | GBool isInt() { return type == objInt; } | |
123 | GBool isReal() { return type == objReal; } | |
124 | GBool isNum() { return type == objInt || type == objReal; } | |
125 | GBool isString() { return type == objString; } | |
126 | GBool isName() { return type == objName; } | |
127 | GBool isNull() { return type == objNull; } | |
128 | GBool isArray() { return type == objArray; } | |
129 | GBool isDict() { return type == objDict; } | |
130 | GBool isStream() { return type == objStream; } | |
131 | GBool isRef() { return type == objRef; } | |
132 | GBool isCmd() { return type == objCmd; } | |
133 | GBool isError() { return type == objError; } | |
134 | GBool isEOF() { return type == objEOF; } | |
135 | GBool isNone() { return type == objNone; } | |
136 | ||
137 | // Special type checking. | |
138 | GBool isName(char *nameA) | |
139 | { return type == objName && !strcmp(name, nameA); } | |
140 | GBool isDict(char *dictType); | |
141 | GBool isStream(char *dictType); | |
142 | GBool isCmd(char *cmdA) | |
143 | { return type == objCmd && !strcmp(cmd, cmdA); } | |
144 | ||
145 | // Accessors. NB: these assume object is of correct type. | |
146 | GBool getBool() { return booln; } | |
147 | int getInt() { return intg; } | |
148 | double getReal() { return real; } | |
149 | double getNum() { return type == objInt ? (double)intg : real; } | |
150 | GString *getString() { return string; } | |
151 | char *getName() { return name; } | |
152 | Array *getArray() { return array; } | |
153 | Dict *getDict() { return dict; } | |
154 | Stream *getStream() { return stream; } | |
155 | Ref getRef() { return ref; } | |
156 | int getRefNum() { return ref.num; } | |
157 | int getRefGen() { return ref.gen; } | |
158 | char *getCmd() { return cmd; } | |
159 | ||
160 | // Array accessors. | |
161 | int arrayGetLength(); | |
162 | void arrayAdd(Object *elem); | |
163 | Object *arrayGet(int i, Object *obj); | |
164 | Object *arrayGetNF(int i, Object *obj); | |
165 | ||
166 | // Dict accessors. | |
167 | int dictGetLength(); | |
168 | void dictAdd(char *key, Object *val); | |
169 | GBool dictIs(char *dictType); | |
170 | Object *dictLookup(char *key, Object *obj); | |
171 | Object *dictLookupNF(char *key, Object *obj); | |
172 | char *dictGetKey(int i); | |
173 | Object *dictGetVal(int i, Object *obj); | |
174 | Object *dictGetValNF(int i, Object *obj); | |
175 | ||
176 | // Stream accessors. | |
177 | GBool streamIs(char *dictType); | |
178 | void streamReset(); | |
179 | void streamClose(); | |
180 | int streamGetChar(); | |
181 | int streamLookChar(); | |
182 | char *streamGetLine(char *buf, int size); | |
183 | Guint streamGetPos(); | |
184 | void streamSetPos(Guint pos, int dir = 0); | |
185 | Dict *streamGetDict(); | |
186 | ||
187 | // Output. | |
188 | char *getTypeName(); | |
189 | void print(FILE *f = stdout); | |
190 | ||
191 | // Memory testing. | |
192 | static void memCheck(FILE *f); | |
193 | ||
194 | private: | |
195 | ||
196 | ObjType type; // object type | |
197 | union { // value for each type: | |
198 | GBool booln; // boolean | |
199 | int intg; // integer | |
200 | double real; // real | |
201 | GString *string; // string | |
202 | char *name; // name | |
203 | Array *array; // array | |
204 | Dict *dict; // dictionary | |
205 | Stream *stream; // stream | |
206 | Ref ref; // indirect reference | |
207 | char *cmd; // command | |
208 | }; | |
209 | ||
210 | #ifdef DEBUG_MEM | |
211 | static int // number of each type of object | |
212 | numAlloc[numObjTypes]; // currently allocated | |
213 | #endif | |
214 | }; | |
215 | ||
216 | //------------------------------------------------------------------------ | |
217 | // Array accessors. | |
218 | //------------------------------------------------------------------------ | |
219 | ||
220 | #include "Array.h" | |
221 | ||
222 | inline int Object::arrayGetLength() | |
223 | { return array->getLength(); } | |
224 | ||
225 | inline void Object::arrayAdd(Object *elem) | |
226 | { array->add(elem); } | |
227 | ||
228 | inline Object *Object::arrayGet(int i, Object *obj) | |
229 | { return array->get(i, obj); } | |
230 | ||
231 | inline Object *Object::arrayGetNF(int i, Object *obj) | |
232 | { return array->getNF(i, obj); } | |
233 | ||
234 | //------------------------------------------------------------------------ | |
235 | // Dict accessors. | |
236 | //------------------------------------------------------------------------ | |
237 | ||
238 | #include "Dict.h" | |
239 | ||
240 | inline int Object::dictGetLength() | |
241 | { return dict->getLength(); } | |
242 | ||
243 | inline void Object::dictAdd(char *key, Object *val) | |
244 | { dict->add(key, val); } | |
245 | ||
246 | inline GBool Object::dictIs(char *dictType) | |
247 | { return dict->is(dictType); } | |
248 | ||
249 | inline GBool Object::isDict(char *dictType) | |
250 | { return type == objDict && dictIs(dictType); } | |
251 | ||
252 | inline Object *Object::dictLookup(char *key, Object *obj) | |
253 | { return dict->lookup(key, obj); } | |
254 | ||
255 | inline Object *Object::dictLookupNF(char *key, Object *obj) | |
256 | { return dict->lookupNF(key, obj); } | |
257 | ||
258 | inline char *Object::dictGetKey(int i) | |
259 | { return dict->getKey(i); } | |
260 | ||
261 | inline Object *Object::dictGetVal(int i, Object *obj) | |
262 | { return dict->getVal(i, obj); } | |
263 | ||
264 | inline Object *Object::dictGetValNF(int i, Object *obj) | |
265 | { return dict->getValNF(i, obj); } | |
266 | ||
267 | //------------------------------------------------------------------------ | |
268 | // Stream accessors. | |
269 | //------------------------------------------------------------------------ | |
270 | ||
271 | #include "Stream.h" | |
272 | ||
273 | inline GBool Object::streamIs(char *dictType) | |
274 | { return stream->getDict()->is(dictType); } | |
275 | ||
276 | inline GBool Object::isStream(char *dictType) | |
277 | { return type == objStream && streamIs(dictType); } | |
278 | ||
279 | inline void Object::streamReset() | |
280 | { stream->reset(); } | |
281 | ||
282 | inline void Object::streamClose() | |
283 | { stream->close(); } | |
284 | ||
285 | inline int Object::streamGetChar() | |
286 | { return stream->getChar(); } | |
287 | ||
288 | inline int Object::streamLookChar() | |
289 | { return stream->lookChar(); } | |
290 | ||
291 | inline char *Object::streamGetLine(char *buf, int size) | |
292 | { return stream->getLine(buf, size); } | |
293 | ||
294 | inline Guint Object::streamGetPos() | |
295 | { return stream->getPos(); } | |
296 | ||
297 | inline void Object::streamSetPos(Guint pos, int dir) | |
298 | { stream->setPos(pos, dir); } | |
299 | ||
300 | inline Dict *Object::streamGetDict() | |
301 | { return stream->getDict(); } | |
302 | ||
303 | #endif |