pdf2json 0.1.0

data/pdf2json-0.52-source/goo/gfile.h

@@ -0,0 +1,138 @@
+//========================================================================
+//
+// gfile.h
+//
+// Miscellaneous file and directory name manipulation.
+//
+// Copyright 1996-2003 Glyph & Cog, LLC
+//
+//========================================================================
+
+#ifndef GFILE_H
+#define GFILE_H
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <stddef.h>
+#if defined(WIN32)
+#  include <sys/stat.h>
+#  ifdef FPTEX
+#    include <win32lib.h>
+#  else
+#    include <windows.h>
+#  endif
+#elif defined(ACORN)
+#elif defined(MACOS)
+#  include <ctime.h>
+#else
+#  include <unistd.h>
+#  include <sys/types.h>
+#  ifdef VMS
+#    include "vms_dirent.h"
+#  elif HAVE_DIRENT_H
+#    include <dirent.h>
+#    define NAMLEN(d) strlen((d)->d_name)
+#  else
+#    define dirent direct
+#    define NAMLEN(d) (d)->d_namlen
+#    if HAVE_SYS_NDIR_H
+#      include <sys/ndir.h>
+#    endif
+#    if HAVE_SYS_DIR_H
+#      include <sys/dir.h>
+#    endif
+#    if HAVE_NDIR_H
+#      include <ndir.h>
+#    endif
+#  endif
+#endif
+#include "gtypes.h"
+
+class GString;
+
+//------------------------------------------------------------------------
+
+// Get home directory path.
+extern GString *getHomeDir();
+
+// Get current directory.
+extern GString *getCurrentDir();
+
+// Append a file name to a path string.  <path> may be an empty
+// string, denoting the current directory).  Returns <path>.
+extern GString *appendToPath(GString *path, char *fileName);
+
+// Grab the path from the front of the file name.  If there is no
+// directory component in <fileName>, returns an empty string.
+extern GString *grabPath(char *fileName);
+
+// Is this an absolute path or file name?
+extern GBool isAbsolutePath(char *path);
+
+// Make this path absolute by prepending current directory (if path is
+// relative) or prepending user's directory (if path starts with '~').
+extern GString *makePathAbsolute(GString *path);
+
+// Get the modification time for <fileName>.  Returns 0 if there is an
+// error.
+extern time_t getModTime(char *fileName);
+
+// Create a temporary file and open it for writing.  If <ext> is not
+// NULL, it will be used as the file name extension.  Returns both the
+// name and the file pointer.  For security reasons, all writing
+// should be done to the returned file pointer; the file may be
+// reopened later for reading, but not for writing.  The <mode> string
+// should be "w" or "wb".  Returns true on success.
+extern GBool openTempFile(GString **name, FILE **f, char *mode, char *ext);
+
+// Execute <command>.  Returns true on success.
+extern GBool executeCommand(char *cmd);
+
+// Just like fgets, but handles Unix, Mac, and/or DOS end-of-line
+// conventions.
+extern char *getLine(char *buf, int size, FILE *f);
+
+//------------------------------------------------------------------------
+// GDir and GDirEntry
+//------------------------------------------------------------------------
+
+class GDirEntry {
+public:
+
+  GDirEntry(char *dirPath, char *nameA, GBool doStat);
+  ~GDirEntry();
+  GString *getName() { return name; }
+  GBool isDir() { return dir; }
+
+private:
+
+  GString *name;		// dir/file name
+  GBool dir;			// is it a directory?
+};
+
+class GDir {
+public:
+
+  GDir(char *name, GBool doStatA = gTrue);
+  ~GDir();
+  GDirEntry *getNextEntry();
+  void rewind();
+
+private:
+
+  GString *path;		// directory path
+  GBool doStat;			// call stat() for each entry?
+#if defined(WIN32)
+  WIN32_FIND_DATA ffd;
+  HANDLE hnd;
+#elif defined(ACORN)
+#elif defined(MACOS)
+#else
+  DIR *dir;			// the DIR structure from opendir()
+#ifdef VMS
+  GBool needParent;		// need to return an entry for [-]
+#endif
+#endif
+};
+
+#endif

data/pdf2json-0.52-source/goo/gmem.cc

@@ -0,0 +1,264 @@
+/*
+ * gmem.c
+ *
+ * Memory routines with out-of-memory checking.
+ *
+ * Copyright 1996-2003 Glyph & Cog, LLC
+ */
+
+#include <aconf.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <stddef.h>
+#include <string.h>
+#include <limits.h>
+#include "gmem.h"
+
+#ifdef DEBUG_MEM
+
+typedef struct _GMemHdr {
+  unsigned int magic;
+  int size;
+  int index;
+  struct _GMemHdr *next, *prev;
+} GMemHdr;
+
+#define gMemHdrSize ((sizeof(GMemHdr) + 7) & ~7)
+#define gMemTrlSize (sizeof(long))
+
+#define gMemMagic 0xabcd9999
+
+#if gmemTrlSize==8
+#define gMemDeadVal 0xdeadbeefdeadbeefUL
+#else
+#define gMemDeadVal 0xdeadbeefUL
+#endif
+
+/* round data size so trailer will be aligned */
+#define gMemDataSize(size) \
+  ((((size) + gMemTrlSize - 1) / gMemTrlSize) * gMemTrlSize)
+
+static GMemHdr *gMemHead = NULL;
+static GMemHdr *gMemTail = NULL;
+
+static int gMemIndex = 0;
+static int gMemAlloc = 0;
+static int gMemInUse = 0;
+
+#endif /* DEBUG_MEM */
+
+void *gmalloc(int size) GMEM_EXCEP {
+#ifdef DEBUG_MEM
+  int size1;
+  char *mem;
+  GMemHdr *hdr;
+  void *data;
+  unsigned long *trl, *p;
+
+  if (size <= 0) {
+    return NULL;
+  }
+  size1 = gMemDataSize(size);
+  if (!(mem = (char *)malloc(size1 + gMemHdrSize + gMemTrlSize))) {
+#if USE_EXCEPTIONS
+    throw GMemException();
+#else
+    fprintf(stderr, "Out of memory\n");
+    exit(1);
+#endif
+  }
+  hdr = (GMemHdr *)mem;
+  data = (void *)(mem + gMemHdrSize);
+  trl = (unsigned long *)(mem + gMemHdrSize + size1);
+  hdr->magic = gMemMagic;
+  hdr->size = size;
+  hdr->index = gMemIndex++;
+  if (gMemTail) {
+    gMemTail->next = hdr;
+    hdr->prev = gMemTail;
+    gMemTail = hdr;
+  } else {
+    hdr->prev = NULL;
+    gMemHead = gMemTail = hdr;
+  }
+  hdr->next = NULL;
+  ++gMemAlloc;
+  gMemInUse += size;
+  for (p = (unsigned long *)data; p <= trl; ++p) {
+    *p = gMemDeadVal;
+  }
+  return data;
+#else
+  void *p;
+
+  if (size <= 0) {
+    return NULL;
+  }
+  if (!(p = malloc(size))) {
+#if USE_EXCEPTIONS
+    throw GMemException();
+#else
+    fprintf(stderr, "Out of memory\n");
+    exit(1);
+#endif
+  }
+  return p;
+#endif
+}
+
+void *grealloc(void *p, int size) GMEM_EXCEP {
+#ifdef DEBUG_MEM
+  GMemHdr *hdr;
+  void *q;
+  int oldSize;
+
+  if (size <= 0) {
+    if (p) {
+      gfree(p);
+    }
+    return NULL;
+  }
+  if (p) {
+    hdr = (GMemHdr *)((char *)p - gMemHdrSize);
+    oldSize = hdr->size;
+    q = gmalloc(size);
+    memcpy(q, p, size < oldSize ? size : oldSize);
+    gfree(p);
+  } else {
+    q = gmalloc(size);
+  }
+  return q;
+#else
+  void *q;
+
+  if (size <= 0) {
+    if (p) {
+      free(p);
+    }
+    return NULL;
+  }
+  if (p) {
+    q = realloc(p, size);
+  } else {
+    q = malloc(size);
+  }
+  if (!q) {
+#if USE_EXCEPTIONS
+    throw GMemException();
+#else
+    fprintf(stderr, "Out of memory\n");
+    exit(1);
+#endif
+  }
+  return q;
+#endif
+}
+
+void *gmallocn(int nObjs, int objSize) GMEM_EXCEP {
+  int n;
+
+  if (nObjs == 0) {
+    return NULL;
+  }
+  n = nObjs * objSize;
+  if (objSize <= 0 || nObjs < 0 || nObjs >= INT_MAX / objSize) {
+#if USE_EXCEPTIONS
+    throw GMemException();
+#else
+    fprintf(stderr, "Bogus memory allocation size\n");
+    exit(1);
+#endif
+  }
+  return gmalloc(n);
+}
+
+void *greallocn(void *p, int nObjs, int objSize) GMEM_EXCEP {
+  int n;
+
+  if (nObjs == 0) {
+    if (p) {
+      gfree(p);
+    }
+    return NULL;
+  }
+  n = nObjs * objSize;
+  if (objSize <= 0 || nObjs < 0 || nObjs >= INT_MAX / objSize) {
+#if USE_EXCEPTIONS
+    throw GMemException();
+#else
+    fprintf(stderr, "Bogus memory allocation size\n");
+    exit(1);
+#endif
+  }
+  return grealloc(p, n);
+}
+
+void gfree(void *p) {
+#ifdef DEBUG_MEM
+  int size;
+  GMemHdr *hdr;
+  unsigned long *trl, *clr;
+
+  if (p) {
+    hdr = (GMemHdr *)((char *)p - gMemHdrSize);
+    if (hdr->magic == gMemMagic &&
+	((hdr->prev == NULL) == (hdr == gMemHead)) &&
+	((hdr->next == NULL) == (hdr == gMemTail))) {
+      if (hdr->prev) {
+	hdr->prev->next = hdr->next;
+      } else {
+	gMemHead = hdr->next;
+      }
+      if (hdr->next) {
+	hdr->next->prev = hdr->prev;
+      } else {
+	gMemTail = hdr->prev;
+      }
+      --gMemAlloc;
+      gMemInUse -= hdr->size;
+      size = gMemDataSize(hdr->size);
+      trl = (unsigned long *)((char *)hdr + gMemHdrSize + size);
+      if (*trl != gMemDeadVal) {
+	fprintf(stderr, "Overwrite past end of block %d at address %p\n",
+		hdr->index, p);
+      }
+      for (clr = (unsigned long *)hdr; clr <= trl; ++clr) {
+	*clr = gMemDeadVal;
+      }
+      free(hdr);
+    } else {
+      fprintf(stderr, "Attempted to free bad address %p\n", p);
+    }
+  }
+#else
+  if (p) {
+    free(p);
+  }
+#endif
+}
+
+#ifdef DEBUG_MEM
+void gMemReport(FILE *f) {
+  GMemHdr *p;
+
+  fprintf(f, "%d memory allocations in all\n", gMemIndex);
+  if (gMemAlloc > 0) {
+    fprintf(f, "%d memory blocks left allocated:\n", gMemAlloc);
+    fprintf(f, " index     size\n");
+    fprintf(f, "-------- --------\n");
+    for (p = gMemHead; p; p = p->next) {
+      fprintf(f, "%8d %8d\n", p->index, p->size);
+    }
+  } else {
+    fprintf(f, "No memory blocks left allocated\n");
+  }
+}
+#endif
+
+char *copyString(char *s) {
+  char *s1;
+
+  s1 = (char *)gmalloc(strlen(s) + 1);
+  strcpy(s1, s);
+  return s1;
+}

data/pdf2json-0.52-source/goo/gmem.h

@@ -0,0 +1,79 @@
+/*
+ * gmem.h
+ *
+ * Memory routines with out-of-memory checking.
+ *
+ * Copyright 1996-2003 Glyph & Cog, LLC
+ */
+
+#ifndef GMEM_H
+#define GMEM_H
+
+#include <stdio.h>
+#include <aconf.h>
+
+#if USE_EXCEPTIONS
+
+class GMemException {
+public:
+  GMemException() {}
+  ~GMemException() {}
+};
+
+#define GMEM_EXCEP throw(GMemException)
+
+#else // USE_EXCEPTIONS
+
+#define GMEM_EXCEP
+
+#endif // USE_EXCEPTIONS
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+ * Same as malloc, but prints error message and exits if malloc()
+ * returns NULL.
+ */
+extern void *gmalloc(int size) GMEM_EXCEP;
+
+/*
+ * Same as realloc, but prints error message and exits if realloc()
+ * returns NULL.  If <p> is NULL, calls malloc instead of realloc().
+ */
+extern void *grealloc(void *p, int size) GMEM_EXCEP;
+
+/*
+ * These are similar to gmalloc and grealloc, but take an object count
+ * and size.  The result is similar to allocating nObjs * objSize
+ * bytes, but there is an additional error check that the total size
+ * doesn't overflow an int.
+ */
+extern void *gmallocn(int nObjs, int objSize) GMEM_EXCEP;
+extern void *greallocn(void *p, int nObjs, int objSize) GMEM_EXCEP;
+
+/*
+ * Same as free, but checks for and ignores NULL pointers.
+ */
+extern void gfree(void *p);
+
+#ifdef DEBUG_MEM
+/*
+ * Report on unfreed memory.
+ */
+extern void gMemReport(FILE *f);
+#else
+#define gMemReport(f)
+#endif
+
+/*
+ * Allocate memory and copy a string into it.
+ */
+extern char *copyString(char *s);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif