pdf2json 0.1.0

data/pdf2json-0.52-source/xpdf/XRef.h

@@ -0,0 +1,133 @@
+//========================================================================
+//
+// XRef.h
+//
+// Copyright 1996-2003 Glyph & Cog, LLC
+//
+//========================================================================
+
+#ifndef XREF_H
+#define XREF_H
+
+#include <aconf.h>
+
+#ifdef USE_GCC_PRAGMAS
+#pragma interface
+#endif
+
+#include "gtypes.h"
+#include "Object.h"
+
+class Dict;
+class Stream;
+class Parser;
+class ObjectStream;
+
+//------------------------------------------------------------------------
+// XRef
+//------------------------------------------------------------------------
+
+enum XRefEntryType {
+  xrefEntryFree,
+  xrefEntryUncompressed,
+  xrefEntryCompressed
+};
+
+struct XRefEntry {
+  Guint offset;
+  int gen;
+  XRefEntryType type;
+};
+
+class XRef {
+public:
+
+  // Constructor.  Read xref table from stream.
+  XRef(BaseStream *strA);
+
+  // Destructor.
+  ~XRef();
+
+  // Is xref table valid?
+  GBool isOk() { return ok; }
+
+  // Get the error code (if isOk() returns false).
+  int getErrorCode() { return errCode; }
+
+  // Set the encryption parameters.
+  void setEncryption(int permFlagsA, GBool ownerPasswordOkA,
+		     Guchar *fileKeyA, int keyLengthA, int encVersionA,
+		     CryptAlgorithm encAlgorithmA);
+
+  // Is the file encrypted?
+  GBool isEncrypted() { return encrypted; }
+
+  // Check various permissions.
+  GBool okToPrint(GBool ignoreOwnerPW = gFalse);
+  GBool okToChange(GBool ignoreOwnerPW = gFalse);
+  GBool okToCopy(GBool ignoreOwnerPW = gFalse);
+  GBool okToAddNotes(GBool ignoreOwnerPW = gFalse);
+
+  // Get catalog object.
+  Object *getCatalog(Object *obj) { return fetch(rootNum, rootGen, obj); }
+
+  // Fetch an indirect reference.
+  Object *fetch(int num, int gen, Object *obj);
+
+  // Return the document's Info dictionary (if any).
+  Object *getDocInfo(Object *obj);
+  Object *getDocInfoNF(Object *obj);
+
+  // Return the number of objects in the xref table.
+  int getNumObjects() { return size; }
+
+  // Return the offset of the last xref table.
+  Guint getLastXRefPos() { return lastXRefPos; }
+
+  // Return the catalog object reference.
+  int getRootNum() { return rootNum; }
+  int getRootGen() { return rootGen; }
+
+  // Get end position for a stream in a damaged file.
+  // Returns false if unknown or file is not damaged.
+  GBool getStreamEnd(Guint streamStart, Guint *streamEnd);
+
+  // Direct access.
+  int getSize() { return size; }
+  XRefEntry *getEntry(int i) { return &entries[i]; }
+  Object *getTrailerDict() { return &trailerDict; }
+
+private:
+
+  BaseStream *str;		// input stream
+  Guint start;			// offset in file (to allow for garbage
+				//   at beginning of file)
+  XRefEntry *entries;		// xref entries
+  int size;			// size of <entries> array
+  int rootNum, rootGen;		// catalog dict
+  GBool ok;			// true if xref table is valid
+  int errCode;			// error code (if <ok> is false)
+  Object trailerDict;		// trailer dictionary
+  Guint lastXRefPos;		// offset of last xref table
+  Guint *streamEnds;		// 'endstream' positions - only used in
+				//   damaged files
+  int streamEndsLen;		// number of valid entries in streamEnds
+  ObjectStream *objStr;		// cached object stream
+  GBool encrypted;		// true if file is encrypted
+  int permFlags;		// permission bits
+  GBool ownerPasswordOk;	// true if owner password is correct
+  Guchar fileKey[16];		// file decryption key
+  int keyLength;		// length of key, in bytes
+  int encVersion;		// encryption version
+  CryptAlgorithm encAlgorithm;	// encryption algorithm
+
+  Guint getStartXref();
+  GBool readXRef(Guint *pos);
+  GBool readXRefTable(Parser *parser, Guint *pos);
+  GBool readXRefStreamSection(Stream *xrefStr, int *w, int first, int n);
+  GBool readXRefStream(Stream *xrefStr, Guint *pos);
+  GBool constructXRef();
+  Guint strToUnsigned(char *s);
+};
+
+#endif

data/pdf2json-0.52-source/xpdf/XpdfPluginAPI.cc

@@ -0,0 +1,262 @@
+//========================================================================
+//
+// XpdfPluginAPI.cc
+//
+// Copyright 2004 Glyph & Cog, LLC
+//
+//========================================================================
+
+#include "aconf.h"
+
+#ifdef ENABLE_PLUGINS
+
+#include "gmem.h"
+#include "GlobalParams.h"
+#include "Object.h"
+#include "PDFDoc.h"
+#ifdef WIN32
+#include "WinPDFCore.h"
+#else
+#include "XPDFCore.h"
+#endif
+#include "XpdfPluginAPI.h"
+
+//------------------------------------------------------------------------
+
+//~ This should use a pool of Objects; change xpdfFreeObj to match.
+static Object *allocObj() {
+  return (Object *)gmalloc(sizeof(Object));
+}
+
+//------------------------------------------------------------------------
+// Document access functions
+//------------------------------------------------------------------------
+
+XpdfObject _xpdfGetInfoDict(XpdfDoc doc) {
+  Object *obj;
+
+  obj = allocObj();
+  return (XpdfObject)((PDFDoc *)doc)->getDocInfo(obj);
+}
+
+XpdfObject _xpdfGetCatalog(XpdfDoc doc) {
+  Object *obj;
+
+  obj = allocObj();
+  return (XpdfObject)((PDFDoc *)doc)->getXRef()->getCatalog(obj);
+}
+
+#ifdef _WIN32
+
+HWND _xpdfWin32GetWindow(XpdfDoc doc) {
+  WinPDFCore *core;
+
+  if (!(core = (WinPDFCore *)((PDFDoc *)doc)->getGUIData())) {
+    return NULL;
+  }
+  return core->getDrawFrame();
+}
+
+#else
+
+Widget _xpdfXGetWindow(XpdfDoc doc) {
+  XPDFCore *core;
+
+  if (!(core = (XPDFCore *)((PDFDoc *)doc)->getGUIData())) {
+    return NULL;
+  }
+  return core->getWidget();
+}
+
+#endif
+
+//------------------------------------------------------------------------
+// Object access functions.
+//------------------------------------------------------------------------
+
+XpdfBool _xpdfObjIsBool(XpdfObject obj) {
+  return (XpdfBool)((Object *)obj)->isBool();
+}
+
+XpdfBool _xpdfObjIsInt(XpdfObject obj) {
+  return (XpdfBool)((Object *)obj)->isInt();
+}
+
+XpdfBool _xpdfObjIsReal(XpdfObject obj) {
+  return (XpdfBool)((Object *)obj)->isReal();
+}
+
+XpdfBool _xpdfObjIsNumber(XpdfObject obj) {
+  return (XpdfBool)((Object *)obj)->isNum();
+}
+
+XpdfBool _xpdfObjIsString(XpdfObject obj) {
+  return (XpdfBool)((Object *)obj)->isString();
+}
+
+XpdfBool _xpdfObjIsName(XpdfObject obj) {
+  return (XpdfBool)((Object *)obj)->isName();
+}
+
+XpdfBool _xpdfObjIsNull(XpdfObject obj) {
+  return (XpdfBool)((Object *)obj)->isNull();
+}
+
+XpdfBool _xpdfObjIsArray(XpdfObject obj) {
+  return (XpdfBool)((Object *)obj)->isArray();
+}
+
+XpdfBool _xpdfObjIsDict(XpdfObject obj) {
+  return (XpdfBool)((Object *)obj)->isDict();
+}
+
+XpdfBool _xpdfObjIsStream(XpdfObject obj) {
+  return (XpdfBool)((Object *)obj)->isStream();
+}
+
+XpdfBool _xpdfObjIsRef(XpdfObject obj) {
+  return (XpdfBool)((Object *)obj)->isRef();
+}
+
+XpdfBool _xpdfBoolValue(XpdfObject obj) {
+  return (XpdfBool)((Object *)obj)->getBool();
+}
+
+int _xpdfIntValue(XpdfObject obj) {
+  if (!((Object *)obj)->isInt()) {
+    return 0;
+  }
+  return ((Object *)obj)->getInt();
+}
+
+double _xpdfRealValue(XpdfObject obj) {
+  if (!((Object *)obj)->isReal()) {
+    return 0;
+  }
+  return ((Object *)obj)->getReal();
+}
+
+double _xpdfNumberValue(XpdfObject obj) {
+  if (!((Object *)obj)->isNum()) {
+    return 0;
+  }
+  return ((Object *)obj)->getNum();
+}
+
+int _xpdfStringLength(XpdfObject obj) {
+  if (!((Object *)obj)->isString()) {
+    return 0;
+  }
+  return ((Object *)obj)->getString()->getLength();
+}
+
+char *_xpdfStringValue(XpdfObject obj) {
+  if (!((Object *)obj)->isString()) {
+    return 0;
+  }
+  return ((Object *)obj)->getString()->getCString();
+}
+
+char *_xpdfNameValue(XpdfObject obj) {
+  if (!((Object *)obj)->isName()) {
+    return NULL;
+  }
+  return ((Object *)obj)->getName();
+}
+
+int _xpdfArrayLength(XpdfObject obj) {
+  if (!((Object *)obj)->isArray()) {
+    return 0;
+  }
+  return ((Object *)obj)->arrayGetLength();
+}
+
+XpdfObject _xpdfArrayGet(XpdfObject obj, int idx) {
+  Object *elem;
+
+  elem = allocObj();
+  if (!((Object *)obj)->isArray()) {
+    return (XpdfObject)elem->initNull();
+  }
+  return (XpdfObject)((Object *)obj)->arrayGet(idx, elem);
+}
+
+XpdfObject _xpdfDictGet(XpdfObject obj, char *key) {
+  Object *elem;
+
+  elem = allocObj();
+  if (!((Object *)obj)->isDict()) {
+    return (XpdfObject)elem->initNull();
+  }
+  return (XpdfObject)((Object *)obj)->dictLookup(key, elem);
+}
+
+void _xpdfFreeObj(XpdfObject obj) {
+  ((Object *)obj)->free();
+  gfree(obj);
+}
+
+//------------------------------------------------------------------------
+// Memory allocation functions
+//------------------------------------------------------------------------
+
+void *_xpdfMalloc(int size) {
+  return gmalloc(size);
+}
+
+void *_xpdfRealloc(void *p, int size) {
+  return grealloc(p, size);
+}
+
+void _xpdfFree(void *p) {
+  gfree(p);
+}
+
+//------------------------------------------------------------------------
+// Security handlers
+//------------------------------------------------------------------------
+
+void _xpdfRegisterSecurityHandler(XpdfSecurityHandler *handler) {
+  if (handler->version <= xpdfPluginAPIVersion) {
+    globalParams->addSecurityHandler(handler);
+  }
+}
+
+//------------------------------------------------------------------------
+
+XpdfPluginVecTable xpdfPluginVecTable = {
+  xpdfPluginAPIVersion,
+  &_xpdfGetInfoDict,
+  &_xpdfGetCatalog,
+#ifdef _WIN32
+  &_xpdfWin32GetWindow,
+#else
+  &_xpdfXGetWindow,
+#endif
+  &_xpdfObjIsBool,
+  &_xpdfObjIsInt,
+  &_xpdfObjIsReal,
+  &_xpdfObjIsString,
+  &_xpdfObjIsName,
+  &_xpdfObjIsNull,
+  &_xpdfObjIsArray,
+  &_xpdfObjIsDict,
+  &_xpdfObjIsStream,
+  &_xpdfObjIsRef,
+  &_xpdfBoolValue,
+  &_xpdfIntValue,
+  &_xpdfRealValue,
+  &_xpdfStringLength,
+  &_xpdfStringValue,
+  &_xpdfNameValue,
+  &_xpdfArrayLength,
+  &_xpdfArrayGet,
+  &_xpdfDictGet,
+  &_xpdfFreeObj,
+  &_xpdfMalloc,
+  &_xpdfRealloc,
+  &_xpdfFree,
+  &_xpdfRegisterSecurityHandler,
+};
+
+#endif // ENABLE_PLUGINS

data/pdf2json-0.52-source/xpdf/XpdfPluginAPI.h

@@ -0,0 +1,341 @@
+/*
+ * XpdfPluginAPI.h
+ *
+ * Copyright 2004 Glyph & Cog, LLC
+ */
+
+#ifndef XPDFPLUGINAPI_H
+#define XPDFPLUGINAPI_H
+
+#ifdef _WIN32
+#include <windows.h>
+#else
+#define Object XtObject
+#include <X11/Intrinsic.h>
+#undef Object
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*------------------------------------------------------------------------
+ * Macros
+ *------------------------------------------------------------------------*/
+
+/*
+ * The current API version.
+ */
+#define xpdfPluginAPIVersion 1
+
+#ifdef _WIN32
+#  ifdef __cplusplus
+#    define PLUGINFUNC(retType) extern "C" __declspec(dllexport) retType
+#  else
+#    define PLUGINFUNC(retType) extern __declspec(dllexport) retType
+#  endif
+#else
+#  ifdef __cplusplus
+#    define PLUGINFUNC(retType) extern "C" retType
+#  else
+#    define PLUGINFUNC(retType) extern retType
+#  endif
+#endif
+
+/*------------------------------------------------------------------------
+ * Plugin setup/cleanup
+ *------------------------------------------------------------------------*/
+
+/*
+ * All plugins are required to implement two functions:
+ *
+ * -- Initialize the plugin.  Returns non-zero if successful.
+ * PLUGINFUNC(XpdfBool) xpdfInitPlugin(void);
+ *
+ * -- Free the plugin.
+ * PLUGINFUNC(void) xpdfFreePlugin(void);
+ */
+
+/*------------------------------------------------------------------------
+ * Types
+ *------------------------------------------------------------------------*/
+
+/*
+ * Standard C boolean -- zero = false, non-zero = true.
+ */
+typedef int XpdfBool;
+#define xpdfTrue  1
+#define xpdfFalse 0
+
+/*
+ * PDF document handle.
+ */
+typedef struct _XpdfDoc *XpdfDoc;
+
+/*
+ * PDF object handle.
+ */
+typedef struct _XpdfObject *XpdfObject;
+
+/*
+ * Document access permissions.  Any of these can be bitwise 'or'ed
+ * together.  If xpdfPermissionOpen is not included, the document
+ * cannot be opened at all, and the other bits are ignored.
+ */
+typedef unsigned int XpdfPermission;
+#define xpdfPermissionOpen     (1 << 0)
+#define xpdfPermissionPrint    (1 << 2)
+#define xpdfPermissionChange   (1 << 3)
+#define xpdfPermissionCopy     (1 << 4)
+#define xpdfPermissionNotes    (1 << 5)
+
+/*------------------------------------------------------------------------
+ * Security handler
+ *------------------------------------------------------------------------*/
+
+/*
+ * XpdfSecurityHandler - a security handler plugin should create one
+ * of these and pass it to xpdfRegisterSecurityHandler.
+ */
+#ifdef __cplusplus
+struct XpdfSecurityHandler {
+#else
+typedef struct {
+#endif
+
+  /*
+   * Version of the security handler spec (this document) -- use
+   * xpdfPluginAPIVersion.
+   */
+  int version;
+
+  /*
+   * Security handler name.
+   */
+  char *name;
+
+  /*
+   * Any global data the security handler needs.  XpdfViewer will pass
+   * this pointer to all handler functions as the <handlerData>
+   * argument.
+   */
+  void *handlerData;
+
+  /*
+   * Allocate and initialize data for a new document.  XpdfViewer will
+   * pass the returned pointer to all other handler functions as the
+   * <docData> argument.  Returns non-zero if successful.
+   */
+  XpdfBool (*newDoc)(void *handlerData, XpdfDoc doc,
+		     XpdfObject encryptDict, void **docData);
+
+  /*
+   * Free the data allocated by newDoc.
+   */
+  void (*freeDoc)(void *handlerData, void *docData);
+
+  /*
+   * Construct authorization data based on the supplied owner and user
+   * passwords (either or both of which may be NULL).  This function
+   * is called in "batch" mode, i.e., if the password was supplied on
+   * the command line or via an Xpdf library API.  It should not
+   * generate any user interaction (e.g., a password dialog).  It is
+   * not required to support this function: the makeAuthData function
+   * pointer can be set to NULL.  Returns non-zero if successful.
+   */
+  XpdfBool (*makeAuthData)(void *handlerData, void *docData,
+			   char *ownerPassword, char *userPassword,
+			   void **authData);
+
+  /*
+   * Request any needed information (e.g., a password) from the user,
+   * and construct an authorization data object.  Returns non-zero if
+   * successful.
+   */
+  XpdfBool (*getAuthData)(void *handlerData, void *docData,
+			  void **authData);
+
+  /*
+   * Free the data allocated by getAuthData.
+   */
+  void (*freeAuthData)(void *handlerData, void *docData,
+		       void *authData);
+
+  /*
+   * Request permission to access the document.  This returns all
+   * permissions granted by authData.
+   */
+  XpdfPermission (*authorize)(void *handlerData, void *docData,
+			      void *authData);
+
+  /*
+   * Get the decryption key and algorithm version associated with the
+   * document.  Returns non-zero if successful.
+   */
+  XpdfBool (*getKey)(void *handlerData, void *docData,
+		     char **key, int *keyLen, int *cryptVersion);
+
+  /*
+   * Free the data allocated by getKey.
+   */
+  void (*freeKey)(void *handlerData, void *docData,
+		  char *key, int keyLen);
+
+#ifdef __cplusplus
+};
+#else
+} XpdfSecurityHandler;
+#endif
+
+/*------------------------------------------------------------------------*/
+
+typedef struct {
+  int version;
+
+/*------------------------------------------------------------------------
+ * Document access functions
+ *------------------------------------------------------------------------*/
+
+/*
+ * Get a document's info dictionary.  (The returned object must be
+ * freed with xpdfFreeObj.)
+ */
+XpdfObject (*_xpdfGetInfoDict)(XpdfDoc doc);
+
+/*
+ * Get a document's catalog ("root") dictionary.  (The returned object
+ * must be freed with xpdfFreeObj.)
+ */
+XpdfObject (*_xpdfGetCatalog)(XpdfDoc doc);
+
+#ifdef _WIN32
+
+/*
+ * Get the handle for the viewer window associated with the specified
+ * document.  [Win32 only]
+ */
+HWND (*_xpdfWin32GetWindow)(XpdfDoc doc);
+
+#else
+
+/*
+ * Get the Motif widget for the viewer window associated with the
+ * specified document.  [X only]
+ */
+Widget (*_xpdfXGetWindow)(XpdfDoc doc);
+
+#endif
+
+/*------------------------------------------------------------------------
+ * Object access functions
+ *------------------------------------------------------------------------*/
+
+/*
+ * Check an object's type.
+ */
+XpdfBool (*_xpdfObjIsBool)(XpdfObject obj);
+XpdfBool (*_xpdfObjIsInt)(XpdfObject obj);
+XpdfBool (*_xpdfObjIsReal)(XpdfObject obj);
+XpdfBool (*_xpdfObjIsString)(XpdfObject obj);
+XpdfBool (*_xpdfObjIsName)(XpdfObject obj);
+XpdfBool (*_xpdfObjIsNull)(XpdfObject obj);
+XpdfBool (*_xpdfObjIsArray)(XpdfObject obj);
+XpdfBool (*_xpdfObjIsDict)(XpdfObject obj);
+XpdfBool (*_xpdfObjIsStream)(XpdfObject obj);
+XpdfBool (*_xpdfObjIsRef)(XpdfObject obj);
+
+/*
+ * Value access.
+ * (Objects returned by xpdfArrayGet and xpdfDictGet must be freed
+ * with xpdfFreeObj.)
+ */
+XpdfBool (*_xpdfBoolValue)(XpdfObject obj);
+int (*_xpdfIntValue)(XpdfObject obj);
+double (*_xpdfRealValue)(XpdfObject obj);
+int (*_xpdfStringLength)(XpdfObject obj);
+char *(*_xpdfStringValue)(XpdfObject obj);
+char *(*_xpdfNameValue)(XpdfObject obj);
+int (*_xpdfArrayLength)(XpdfObject obj);
+XpdfObject (*_xpdfArrayGet)(XpdfObject obj, int idx);
+XpdfObject (*_xpdfDictGet)(XpdfObject obj, char *key);
+
+/*
+ * Object destruction.  NB: *all* objects must be freed after use.
+ */
+void (*_xpdfFreeObj)(XpdfObject obj);
+
+/*------------------------------------------------------------------------
+ * Memory allocation functions
+ *------------------------------------------------------------------------*/
+
+void *(*_xpdfMalloc)(int size);
+void *(*_xpdfRealloc)(void *p, int size);
+void (*_xpdfFree)(void *p);
+
+/*------------------------------------------------------------------------
+ * Security handler functions
+ *------------------------------------------------------------------------*/
+
+/*
+ * Register a new security handler.
+ */
+void (*_xpdfRegisterSecurityHandler)(XpdfSecurityHandler *handler);
+
+/*------------------------------------------------------------------------*/
+
+} XpdfPluginVecTable;
+
+#ifdef _WIN32
+
+extern __declspec(dllexport) XpdfPluginVecTable xpdfPluginVecTable;
+
+#define xpdfPluginSetup \
+  extern __declspec(dllexport) \
+  XpdfPluginVecTable xpdfPluginVecTable = {xpdfPluginAPIVersion};
+
+#else
+
+extern XpdfPluginVecTable xpdfPluginVecTable;
+
+#define xpdfPluginSetup \
+  XpdfPluginVecTable xpdfPluginVecTable = {xpdfPluginAPIVersion};
+
+#endif
+
+#define xpdfGetInfoDict (*xpdfPluginVecTable._xpdfGetInfoDict)
+#define xpdfGetCatalog (*xpdfPluginVecTable._xpdfGetCatalog)
+#ifdef _WIN32
+#define xpdfWin32GetWindow (*xpdfPluginVecTable._xpdfWin32GetWindow)
+#else
+#define xpdfXGetWindow (*xpdfPluginVecTable._xpdfXGetWindow)
+#endif
+#define xpdfObjIsBool (*xpdfPluginVecTable._xpdfObjIsBool)
+#define xpdfObjIsInt (*xpdfPluginVecTable._xpdfObjIsInt)
+#define xpdfObjIsReal (*xpdfPluginVecTable._xpdfObjIsReal)
+#define xpdfObjIsString (*xpdfPluginVecTable._xpdfObjIsString)
+#define xpdfObjIsName (*xpdfPluginVecTable._xpdfObjIsName)
+#define xpdfObjIsNull (*xpdfPluginVecTable._xpdfObjIsNull)
+#define xpdfObjIsArray (*xpdfPluginVecTable._xpdfObjIsArray)
+#define xpdfObjIsDict (*xpdfPluginVecTable._xpdfObjIsDict)
+#define xpdfObjIsStream (*xpdfPluginVecTable._xpdfObjIsStream)
+#define xpdfObjIsRef (*xpdfPluginVecTable._xpdfObjIsRef)
+#define xpdfBoolValue (*xpdfPluginVecTable._xpdfBoolValue)
+#define xpdfIntValue (*xpdfPluginVecTable._xpdfIntValue)
+#define xpdfRealValue (*xpdfPluginVecTable._xpdfRealValue)
+#define xpdfStringLength (*xpdfPluginVecTable._xpdfStringLength)
+#define xpdfStringValue (*xpdfPluginVecTable._xpdfStringValue)
+#define xpdfNameValue (*xpdfPluginVecTable._xpdfNameValue)
+#define xpdfArrayLength (*xpdfPluginVecTable._xpdfArrayLength)
+#define xpdfArrayGet (*xpdfPluginVecTable._xpdfArrayGet)
+#define xpdfDictGet (*xpdfPluginVecTable._xpdfDictGet)
+#define xpdfFreeObj (*xpdfPluginVecTable._xpdfFreeObj)
+#define xpdfMalloc (*xpdfPluginVecTable._xpdfMalloc)
+#define xpdfRealloc (*xpdfPluginVecTable._xpdfRealloc)
+#define xpdfFree (*xpdfPluginVecTable._xpdfFree)
+#define xpdfRegisterSecurityHandler (*xpdfPluginVecTable._xpdfRegisterSecurityHandler)
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif