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