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