← Back to branch summary

~ubuntu-branches/ubuntu/precise/ipe/precise

« back to all changes in this revision

Viewing changes to src/xpdflib/object.h

  • Committer: Bazaar Package Importer
  • Author(s): Steve M. Robbins
  • Date: 2004-06-08 00:44:02 UTC
  • Revision ID: james.westby@ubuntu.com-20040608004402-72yu51xlh7vt6p9m
Tags: upstream-6.0pre16
Import upstream version 6.0pre16

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/xpdflib/object.h
 
1
// -*- C++ -*-
 
2
//========================================================================
 
3
//
 
4
// Object.h
 
5
//
 
6
// Copyright 1996-2002 Glyph & Cog, LLC
 
7
//
 
8
//========================================================================
 
9
 
 
10
#ifndef OBJECT_H
 
11
#define OBJECT_H
 
12
 
 
13
#include "aconf.h"
 
14
 
 
15
#ifdef USE_GCC_PRAGMAS
 
16
#pragma interface
 
17
#endif
 
18
 
 
19
#include <stdio.h>
 
20
#include <string.h>
 
21
#include "gtypes.h"
 
22
#include "gmem.h"
 
23
#include "gstring.h"
 
24
 
 
25
class XRef;
 
26
class Array;
 
27
class Dict;
 
28
class Stream;
 
29
 
 
30
//------------------------------------------------------------------------
 
31
// Ref
 
32
//------------------------------------------------------------------------
 
33
 
 
34
struct Ref {
 
35
  int num;                      // object number
 
36
  int gen;                      // generation number
 
37
};
 
38
 
 
39
//------------------------------------------------------------------------
 
40
// object types
 
41
//------------------------------------------------------------------------
 
42
 
 
43
enum ObjType {
 
44
  // simple objects
 
45
  objBool,                      // boolean
 
46
  objInt,                       // integer
 
47
  objReal,                      // real
 
48
  objString,                    // string
 
49
  objName,                      // name
 
50
  objNull,                      // null
 
51
 
 
52
  // complex objects
 
53
  objArray,                     // array
 
54
  objDict,                      // dictionary
 
55
  objStream,                    // stream
 
56
  objRef,                       // indirect reference
 
57
 
 
58
  // special objects
 
59
  objCmd,                       // command name
 
60
  objError,                     // error return from Lexer
 
61
  objEOF,                       // end of file return from Lexer
 
62
  objNone                       // uninitialized object
 
63
};
 
64
 
 
65
#define numObjTypes 14          // total number of object types
 
66
 
 
67
//------------------------------------------------------------------------
 
68
// Object
 
69
//------------------------------------------------------------------------
 
70
 
 
71
#ifdef DEBUG_MEM
 
72
#define initObj(t) ++numAlloc[type = t]
 
73
#else
 
74
#define initObj(t) type = t
 
75
#endif
 
76
 
 
77
class Object {
 
78
public:
 
79
 
 
80
  // Default constructor.
 
81
  Object():
 
82
    type(objNone) {}
 
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(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(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