#ifndef OBJECT_H
#define OBJECT_H
#include <config.h>
#ifdef USE_GCC_PRAGMAS
#pragma interface
#endif
#include <stdio.h>
#include <string.h>
#include "gtypes.h"
#include "gmem.h"
#include "GString.h"
class XRef;
class Array;
class Dict;
class Stream;
struct Ref {
int num; int gen; };
enum ObjType {
objBool, objInt, objReal, objString, objName, objNull,
objArray, objDict, objStream, objRef,
objCmd, objError, objEOF, objNone };
#define numObjTypes 14 // total number of object types
#ifdef DEBUG_MEM
#define initObj(t) ++numAlloc[type = t]
#else
#define initObj(t) type = t
#endif
class Object {
public:
Object():
type(objNone) {}
Object *initBool(GBool boolnA)
{ initObj(objBool); booln = boolnA; return this; }
Object *initInt(int intgA)
{ initObj(objInt); intg = intgA; return this; }
Object *initReal(double realA)
{ initObj(objReal); real = realA; return this; }
Object *initString(GString *stringA)
{ initObj(objString); string = stringA; return this; }
Object *initName(char *nameA)
{ initObj(objName); name = copyString(nameA); return this; }
Object *initNull()
{ initObj(objNull); return this; }
Object *initArray(XRef *xref);
Object *initDict(XRef *xref);
Object *initDict(Dict *dictA);
Object *initStream(Stream *streamA);
Object *initRef(int numA, int genA)
{ initObj(objRef); ref.num = numA; ref.gen = genA; return this; }
Object *initCmd(char *cmdA)
{ initObj(objCmd); cmd = copyString(cmdA); return this; }
Object *initError()
{ initObj(objError); return this; }
Object *initEOF()
{ initObj(objEOF); return this; }
Object *copy(Object *obj);
Object *fetch(XRef *xref, Object *obj);
void free();
ObjType getType() { return type; }
GBool isBool() { return type == objBool; }
GBool isInt() { return type == objInt; }
GBool isReal() { return type == objReal; }
GBool isNum() { return type == objInt || type == objReal; }
GBool isString() { return type == objString; }
GBool isName() { return type == objName; }
GBool isNull() { return type == objNull; }
GBool isArray() { return type == objArray; }
GBool isDict() { return type == objDict; }
GBool isStream() { return type == objStream; }
GBool isRef() { return type == objRef; }
GBool isCmd() { return type == objCmd; }
GBool isError() { return type == objError; }
GBool isEOF() { return type == objEOF; }
GBool isNone() { return type == objNone; }
GBool isName(char *nameA)
{ return type == objName && !strcmp(name, nameA); }
GBool isDict(char *dictType);
GBool isStream(char *dictType);
GBool isCmd(char *cmdA)
{ return type == objCmd && !strcmp(cmd, cmdA); }
GBool getBool() { return booln; }
int getInt() { return intg; }
double getReal() { return real; }
double getNum() { return type == objInt ? (double)intg : real; }
GString *getString() { return string; }
char *getName() { return name; }
Array *getArray() { return array; }
Dict *getDict() { return dict; }
Stream *getStream() { return stream; }
Ref getRef() { return ref; }
int getRefNum() { return ref.num; }
int getRefGen() { return ref.gen; }
char *getCmd() { return cmd; }
int arrayGetLength();
void arrayAdd(Object *elem);
Object *arrayGet(int i, Object *obj);
Object *arrayGetNF(int i, Object *obj);
int dictGetLength();
void dictAdd(char *key, Object *val);
GBool dictIs(char *dictType);
Object *dictLookup(char *key, Object *obj);
Object *dictLookupNF(char *key, Object *obj);
char *dictGetKey(int i);
Object *dictGetVal(int i, Object *obj);
Object *dictGetValNF(int i, Object *obj);
GBool streamIs(char *dictType);
void streamReset();
void streamClose();
int streamGetChar();
int streamLookChar();
char *streamGetLine(char *buf, int size);
Guint streamGetPos();
void streamSetPos(Guint pos, int dir = 0);
Dict *streamGetDict();
char *getTypeName();
void print(FILE *f = stdout);
static void memCheck(FILE *f);
private:
ObjType type; union { GBool booln; int intg; double real; GString *string; char *name; Array *array; Dict *dict; Stream *stream; Ref ref; char *cmd; };
#ifdef DEBUG_MEM
static int numAlloc[numObjTypes]; #endif
};
#include "Array.h"
inline int Object::arrayGetLength()
{ return array->getLength(); }
inline void Object::arrayAdd(Object *elem)
{ array->add(elem); }
inline Object *Object::arrayGet(int i, Object *obj)
{ return array->get(i, obj); }
inline Object *Object::arrayGetNF(int i, Object *obj)
{ return array->getNF(i, obj); }
#include "Dict.h"
inline int Object::dictGetLength()
{ return dict->getLength(); }
inline void Object::dictAdd(char *key, Object *val)
{ dict->add(key, val); }
inline GBool Object::dictIs(char *dictType)
{ return dict->is(dictType); }
inline GBool Object::isDict(char *dictType)
{ return type == objDict && dictIs(dictType); }
inline Object *Object::dictLookup(char *key, Object *obj)
{ return dict->lookup(key, obj); }
inline Object *Object::dictLookupNF(char *key, Object *obj)
{ return dict->lookupNF(key, obj); }
inline char *Object::dictGetKey(int i)
{ return dict->getKey(i); }
inline Object *Object::dictGetVal(int i, Object *obj)
{ return dict->getVal(i, obj); }
inline Object *Object::dictGetValNF(int i, Object *obj)
{ return dict->getValNF(i, obj); }
#include "Stream.h"
inline GBool Object::streamIs(char *dictType)
{ return stream->getDict()->is(dictType); }
inline GBool Object::isStream(char *dictType)
{ return type == objStream && streamIs(dictType); }
inline void Object::streamReset()
{ stream->reset(); }
inline void Object::streamClose()
{ stream->close(); }
inline int Object::streamGetChar()
{ return stream->getChar(); }
inline int Object::streamLookChar()
{ return stream->lookChar(); }
inline char *Object::streamGetLine(char *buf, int size)
{ return stream->getLine(buf, size); }
inline Guint Object::streamGetPos()
{ return stream->getPos(); }
inline void Object::streamSetPos(Guint pos, int dir)
{ stream->setPos(pos, dir); }
inline Dict *Object::streamGetDict()
{ return stream->getDict(); }
#endif