filters

Object.h
1//========================================================================
2//
3// Object.h
4//
5// Copyright 1996-2002 Glyph & Cog, LLC
6//
7//========================================================================
8
9#ifndef OBJECT_H
10#define OBJECT_H
11
12#include <aconf.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
24class XRef;
25class Array;
26class Dict;
27class Stream;
28
29//------------------------------------------------------------------------
30// Ref
31//------------------------------------------------------------------------
32
33struct Ref {
34 int num; // object number
35 int gen; // generation number
36};
37
38//------------------------------------------------------------------------
39// object types
40//------------------------------------------------------------------------
41
42enum 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) zeroUnion(); ++numAlloc[type = t]
72#else
73#define initObj(t) zeroUnion(); type = t
74#endif
75
76class Object {
77public:
78 // attempt to clear the anonymous union
79 void zeroUnion() { this->name = NULL; }
80 // Default constructor.
81 Object():
82 type(objNone) { zeroUnion(); }
83
84 // Initialize an object.
85 Object *initBool(GBool boolnA)
86 { initObj(objBool); booln = boolnA; return this; }
87 Object *initInt(int intgA)
88 { initObj(objInt); intg = intgA; return this; }
89 Object *initReal(double realA)
90 { initObj(objReal); real = realA; return this; }
91 Object *initString(GString *stringA)
92 { initObj(objString); string = stringA; return this; }
93 Object *initName(const char *nameA)
94 { initObj(objName); name = copyString(nameA); return this; }
95 Object *initNull()
96 { initObj(objNull); return this; }
97 Object *initArray(XRef *xref);
98 Object *initDict(XRef *xref);
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(const 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(const char *nameA)
139 { return type == objName && !strcmp(name, nameA); }
140 GBool isDict(const char *dictType);
141 GBool isStream(const char *dictType);
142 GBool isCmd(const 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 const 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(const char *dictType);
170 Object *dictLookup(const char *key, Object *obj);
171 Object *dictLookupNF(const 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(const 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 const char *getTypeName();
189 void print(FILE *f = stdout);
190
191 // Memory testing.
192 static void memCheck(FILE *f);
193
194private:
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
222inline int Object::arrayGetLength()
223 { if (type != objArray) return 0; return array->getLength(); }
224
225inline void Object::arrayAdd(Object *elem)
226 { if (type == objArray) array->add(elem); }
227
228inline Object *Object::arrayGet(int i, Object *obj)
229 { if (type != objArray) return obj->initNull(); return array->get(i, obj); }
230
231inline Object *Object::arrayGetNF(int i, Object *obj)
232 { if (type != objArray) return obj->initNull(); return array->getNF(i, obj); }
233
234//------------------------------------------------------------------------
235// Dict accessors.
236//------------------------------------------------------------------------
237
238#include "Dict.h"
239
240inline int Object::dictGetLength()
241 { if (type != objDict) return 0; return dict->getLength(); }
242
243inline void Object::dictAdd(char *key, Object *val)
244 { if (type == objDict) dict->add(key, val); }
245
246inline GBool Object::dictIs(const char *dictType)
247 { return (type == objDict) && dict->is(dictType); }
248
249inline GBool Object::isDict(const char *dictType)
250 { return (type == objDict) && dictIs(dictType); }
251
252inline Object *Object::dictLookup(const char *key, Object *obj)
253 { if (type != objDict) return obj->initNull(); return dict->lookup(key, obj); }
254
255inline Object *Object::dictLookupNF(const char *key, Object *obj)
256 { if (type != objDict) return obj->initNull(); return dict->lookupNF(key, obj); }
257
258inline char *Object::dictGetKey(int i)
259 { if (type != objDict) return NULL; return dict->getKey(i); }
260
261inline Object *Object::dictGetVal(int i, Object *obj)
262 { if (type != objDict) return obj->initNull(); return dict->getVal(i, obj); }
263
264inline Object *Object::dictGetValNF(int i, Object *obj)
265 { if (type != objDict) return obj->initNull(); return dict->getValNF(i, obj); }
266
267//------------------------------------------------------------------------
268// Stream accessors.
269//------------------------------------------------------------------------
270
271#include "Stream.h"
272
273inline GBool Object::streamIs(const char *dictType)
274 { return (type == objStream) && stream->getDict()->is(dictType); }
275
276inline GBool Object::isStream(const char *dictType)
277 { return (type == objStream) && streamIs(dictType); }
278
279inline void Object::streamReset()
280 { if (type == objStream) stream->reset(); }
281
282inline void Object::streamClose()
283 { if (type == objStream) stream->close(); }
284
285inline int Object::streamGetChar()
286 { if (type != objStream) return EOF; return stream->getChar(); }
287
288inline int Object::streamLookChar()
289 { if (type != objStream) return EOF; return stream->lookChar(); }
290
291inline char *Object::streamGetLine(char *buf, int size)
292 { if (type != objStream) return NULL; return stream->getLine(buf, size); }
293
294inline Guint Object::streamGetPos()
295 { if (type != objStream) return 0; return stream->getPos(); }
296
297inline void Object::streamSetPos(Guint pos, int dir)
298 { if (type == objStream) stream->setPos(pos, dir); }
299
300inline Dict *Object::streamGetDict()
301 { if (type != objStream) return NULL; return stream->getDict(); }
302
303#endif