pdf2json 0.1.0

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

@@ -0,0 +1,32 @@
+//========================================================================
+//
+// gmempp.cc
+//
+// Use gmalloc/gfree for C++ new/delete operators.
+//
+// Copyright 1996-2003 Glyph & Cog, LLC
+//
+//========================================================================
+
+#include <aconf.h>
+#include "gmem.h"
+
+#ifdef DEBUG_MEM
+
+void *operator new(size_t size) {
+  return gmalloc((int)size);
+}
+
+void *operator new[](size_t size) {
+  return gmalloc((int)size);
+}
+
+void operator delete(void *p) {
+  gfree(p);
+}
+
+void operator delete[](void *p) {
+  gfree(p);
+}
+
+#endif

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

@@ -0,0 +1,29 @@
+/*
+ * gtypes.h
+ *
+ * Some useful simple types.
+ *
+ * Copyright 1996-2003 Glyph & Cog, LLC
+ */
+
+#ifndef GTYPES_H
+#define GTYPES_H
+
+/*
+ * These have stupid names to avoid conflicts with some (but not all)
+ * C++ compilers which define them.
+ */
+typedef int GBool;
+#define gTrue 1
+#define gFalse 0
+
+/*
+ * These have stupid names to avoid conflicts with <sys/types.h>,
+ * which on various systems defines some random subset of these.
+ */
+typedef unsigned char Guchar;
+typedef unsigned short Gushort;
+typedef unsigned int Guint;
+typedef unsigned long Gulong;
+
+#endif

data/pdf2json-0.52-source/goo/parseargs.c

@@ -0,0 +1,190 @@
+/*
+ * parseargs.h
+ *
+ * Command line argument parser.
+ *
+ * Copyright 1996-2003 Glyph & Cog, LLC
+ */
+
+#include <stdio.h>
+#include <stddef.h>
+#include <string.h>
+#include <stdlib.h>
+#include <ctype.h>
+#include "parseargs.h"
+
+static ArgDesc *findArg(ArgDesc *args, char *arg);
+static GBool grabArg(ArgDesc *arg, int i, int *argc, char *argv[]);
+
+GBool parseArgs(ArgDesc *args, int *argc, char *argv[]) {
+  ArgDesc *arg;
+  int i, j;
+  GBool ok;
+
+  ok = gTrue;
+  i = 1;
+  while (i < *argc) {
+    if (!strcmp(argv[i], "--")) {
+      --*argc;
+      for (j = i; j < *argc; ++j)
+	argv[j] = argv[j+1];
+      break;
+    } else if ((arg = findArg(args, argv[i]))) {
+      if (!grabArg(arg, i, argc, argv))
+	ok = gFalse;
+    } else {
+      ++i;
+    }
+  }
+  return ok;
+}
+
+void printUsage(char *program, char *otherArgs, ArgDesc *args) {
+  ArgDesc *arg;
+  char *typ;
+  int w, w1;
+
+  w = 0;
+  for (arg = args; arg->arg; ++arg) {
+    if ((w1 = strlen(arg->arg)) > w)
+      w = w1;
+  }
+
+  fprintf(stderr, "Usage: %s [options]", program);
+  if (otherArgs)
+    fprintf(stderr, " %s", otherArgs);
+  fprintf(stderr, "\n");
+
+  for (arg = args; arg->arg; ++arg) {
+    fprintf(stderr, "  %s", arg->arg);
+    w1 = 9 + w - strlen(arg->arg);
+    switch (arg->kind) {
+    case argInt:
+    case argIntDummy:
+      typ = " <int>";
+      break;
+    case argFP:
+    case argFPDummy:
+      typ = " <fp>";
+      break;
+    case argString:
+    case argStringDummy:
+      typ = " <string>";
+      break;
+    case argFlag:
+    case argFlagDummy:
+    default:
+      typ = "";
+      break;
+    }
+    fprintf(stderr, "%-*s", w1, typ);
+    if (arg->usage)
+      fprintf(stderr, ": %s", arg->usage);
+    fprintf(stderr, "\n");
+  }
+}
+
+static ArgDesc *findArg(ArgDesc *args, char *arg) {
+  ArgDesc *p;
+
+  for (p = args; p->arg; ++p) {
+    if (p->kind < argFlagDummy && !strcmp(p->arg, arg))
+      return p;
+  }
+  return NULL;
+}
+
+static GBool grabArg(ArgDesc *arg, int i, int *argc, char *argv[]) {
+  int n;
+  int j;
+  GBool ok;
+
+  ok = gTrue;
+  n = 0;
+  switch (arg->kind) {
+  case argFlag:
+    *(GBool *)arg->val = gTrue;
+    n = 1;
+    break;
+  case argInt:
+    if (i + 1 < *argc && isInt(argv[i+1])) {
+      *(int *)arg->val = atoi(argv[i+1]);
+      n = 2;
+    } else {
+      ok = gFalse;
+      n = 1;
+    }
+    break;
+  case argFP:
+    if (i + 1 < *argc && isFP(argv[i+1])) {
+      *(double *)arg->val = atof(argv[i+1]);
+      n = 2;
+    } else {
+      ok = gFalse;
+      n = 1;
+    }
+    break;
+  case argString:
+    if (i + 1 < *argc) {
+      strncpy((char *)arg->val, argv[i+1], arg->size - 1);
+      ((char *)arg->val)[arg->size - 1] = '\0';
+      n = 2;
+    } else {
+      ok = gFalse;
+      n = 1;
+    }
+    break;
+  default:
+    fprintf(stderr, "Internal error in arg table\n");
+    n = 1;
+    break;
+  }
+  if (n > 0) {
+    *argc -= n;
+    for (j = i; j < *argc; ++j)
+      argv[j] = argv[j+n];
+  }
+  return ok;
+}
+
+GBool isInt(char *s) {
+  if (*s == '-' || *s == '+')
+    ++s;
+  while (isdigit(*s & 0xff))
+    ++s;
+  if (*s)
+    return gFalse;
+  return gTrue;
+}
+
+GBool isFP(char *s) {
+  int n;
+
+  if (*s == '-' || *s == '+')
+    ++s;
+  n = 0;
+  while (isdigit(*s & 0xff)) {
+    ++s;
+    ++n;
+  }
+  if (*s == '.')
+    ++s;
+  while (isdigit(*s & 0xff)) {
+    ++s;
+    ++n;
+  }
+  if (n > 0 && (*s == 'e' || *s == 'E')) {
+    ++s;
+    if (*s == '-' || *s == '+')
+      ++s;
+    n = 0;
+    if (!isdigit(*s & 0xff))
+      return gFalse;
+    do {
+      ++s;
+    } while (isdigit(*s & 0xff));
+  }
+  if (*s)
+    return gFalse;
+  return gTrue;
+}

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

@@ -0,0 +1,71 @@
+/*
+ * parseargs.h
+ *
+ * Command line argument parser.
+ *
+ * Copyright 1996-2003 Glyph & Cog, LLC
+ */
+
+#ifndef PARSEARGS_H
+#define PARSEARGS_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "gtypes.h"
+
+/*
+ * Argument kinds.
+ */
+typedef enum {
+  argFlag,			/* flag (present / not-present) */
+				/*   [val: GBool *]             */
+  argInt,			/* integer arg    */
+				/*   [val: int *] */
+  argFP,			/* floating point arg */
+				/*   [val: double *]  */
+  argString,			/* string arg      */
+				/*   [val: char *] */
+  /* dummy entries -- these show up in the usage listing only; */
+  /* useful for X args, for example                            */
+  argFlagDummy,
+  argIntDummy,
+  argFPDummy,
+  argStringDummy
+} ArgKind;
+
+/*
+ * Argument descriptor.
+ */
+typedef struct {
+  char *arg;			/* the command line switch */
+  ArgKind kind;			/* kind of arg */
+  void *val;			/* place to store value */
+  int size;			/* for argString: size of string */
+  char *usage;			/* usage string */
+} ArgDesc;
+
+/*
+ * Parse command line.  Removes all args which are found in the arg
+ * descriptor list <args>.  Stops parsing if "--" is found (and removes
+ * it).  Returns gFalse if there was an error.
+ */
+extern GBool parseArgs(ArgDesc *args, int *argc, char *argv[]);
+
+/*
+ * Print usage message, based on arg descriptor list.
+ */
+extern void printUsage(char *program, char *otherArgs, ArgDesc *args);
+
+/*
+ * Check if a string is a valid integer or floating point number.
+ */
+extern GBool isInt(char *s);
+extern GBool isFP(char *s);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

data/pdf2json-0.52-source/goo/vms_directory.c

@@ -0,0 +1,214 @@
+/*
+ *	DIRECTORY.C - VMS emulation routines for UNIX Directory
+ *	              callable routines
+ *
+ *	Author:		Patrick L. Mahan
+ *	Location:	TGV, Inc
+ *	Date:		19-November-1991
+ *
+ *	Purpose:	Provides emulation of the BSD directory routines
+ *			which are used by some of the X11 R4 release
+ *			software.
+ *
+ *	Side effects:	This is only a partial emulation.  Not all of
+ *			the required information is passed to the user.
+ *
+ *	Modification History
+ *
+ *	Date        | Who	| Version	| History
+ *	------------+-----------+---------------+----------------------------
+ *	19-Nov-1991 | PLM	| 1.0		| First Write
+ *	20-Apr-1992 | PLM	| 1.1		| Added validation check for
+ *	            |		|		| for the directory
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <rmsdef.h>
+#include <descrip.h>
+#include <lib$routines.h>
+#include "vms_dirent.h"
+
+#define	NOWILD		0x00000001
+#define MULTIPLE	0x00000002
+
+static unsigned long context = 0;
+
+static struct dsc$descriptor_s *create_descriptor ( name )
+char *name;
+{
+   struct dsc$descriptor_s *retdescrip;
+
+   retdescrip = (struct dsc$descriptor_s *)calloc(1, sizeof(struct dsc$descriptor_s));
+
+   if (retdescrip == NULL) return ((struct dsc$descriptor_s *)NULL);
+
+   retdescrip->dsc$b_dtype	= DSC$K_DTYPE_T;
+   retdescrip->dsc$b_class	= DSC$K_CLASS_S;
+   retdescrip->dsc$w_length	= strlen(name);
+   retdescrip->dsc$a_pointer	= name;
+
+   return (retdescrip);
+}
+
+static int Check_Directory( dirname )
+char *dirname;
+{
+	static char *tmpdir, *cp;
+	FILE *tfp;
+	int status;
+
+	status = 1;
+
+	tmpdir = calloc(strlen(dirname)+15,sizeof(char));
+
+	strcpy(tmpdir, dirname);
+
+	cp = strrchr(tmpdir, '.');
+
+	if (cp != NULL) {
+		*cp = ']';
+		cp = strrchr(tmpdir, ']');
+		*cp = '.';
+		strcat(tmpdir, "dir");
+	}
+	else {
+		char *tmp1;
+		tmp1 = calloc(strlen(dirname)+1,sizeof(char));
+		cp = strchr(tmpdir, '[');
+		cp++;
+		strcpy(tmp1, cp);
+		cp = strrchr(tmp1, ']');
+		*cp = '\0';
+		cp = strchr(tmpdir, '[');
+		cp++;
+		*cp = '\0';
+		strcat(tmpdir, "000000]");
+		strcat(tmpdir, tmp1);
+		strcat(tmpdir, ".dir");
+	}
+
+	tfp = fopen(tmpdir, "r");
+
+	if (tfp == NULL) status = 0;
+
+	fclose(tfp);
+
+	return (status);
+}
+
+DIR *opendir( dirname )
+char *dirname;
+{
+   DIR *retdir;
+   struct dsc$descriptor_s filedescriptor;
+   char *filepathname;
+
+   retdir = (DIR *) calloc(1, sizeof(DIR));
+
+   if (retdir == NULL) return ((DIR *)NULL);
+
+   if (!Check_Directory(dirname)) return ((DIR *)NULL);
+
+   filepathname = (char *)calloc(256, sizeof(char));
+
+   strcpy(filepathname, dirname);
+   strcat(filepathname, "*.*.*");
+
+   retdir->dd_fd = (unsigned long) create_descriptor(filepathname);
+   retdir->dd_loc = 0;
+   retdir->dd_size = strlen(filepathname);
+   retdir->dd_bsize = 0;
+   retdir->dd_off = 0;
+   retdir->dd_buf = filepathname;
+
+   return (retdir);
+}
+
+struct dirent *readdir( dirp )
+DIR *dirp;
+{
+   static struct dirent *retdirent;
+   struct dsc$descriptor_s retfilenamedesc;
+   struct dsc$descriptor_s searchpathdesc = *((struct dsc$descriptor_s *)dirp->dd_fd);
+   char retfilename[256];
+   char *sp;
+   unsigned long istatus;
+   unsigned long rms_status;
+   unsigned long flags;
+
+   retdirent = (struct dirent *)NULL;
+
+   flags = MULTIPLE;
+
+   retfilenamedesc.dsc$b_dtype	= DSC$K_DTYPE_T;
+   retfilenamedesc.dsc$b_class	= DSC$K_CLASS_S;
+   retfilenamedesc.dsc$w_length	= 255;
+   retfilenamedesc.dsc$a_pointer= retfilename;
+
+   istatus = lib$find_file (&searchpathdesc,
+                            &retfilenamedesc,
+                            &dirp->dd_loc,
+                            0, 0,
+                            &rms_status,
+                            &flags);
+
+   if (!(istatus & 1) && (istatus != RMS$_NMF) && (istatus != RMS$_FNF))
+   {
+      lib$signal (istatus);
+      return (retdirent);
+   }
+   else if ((istatus == RMS$_NMF) || (istatus == RMS$_FNF))
+      return (retdirent);
+
+   retfilename[retfilenamedesc.dsc$w_length] = '\0';
+
+   sp = strchr(retfilename, ' ');
+   if (sp != NULL) *sp = '\0';
+
+   sp = strrchr(retfilename, ']');
+   if (sp != NULL)
+      sp++;
+   else
+      sp = retfilename;
+
+   retdirent = (struct dirent *)calloc(1, sizeof(struct dirent));
+
+   strcpy(retdirent->d_name, sp);
+   retdirent->d_namlen = strlen(sp);
+   retdirent->d_fileno = 0;
+   retdirent->d_off = 0;
+   retdirent->d_reclen = DIRSIZ(retdirent);
+
+   return (retdirent);
+}
+
+long telldir( dirp )
+DIR *dirp;
+{
+   return(0);
+}
+
+void seekdir( dirp, loc )
+DIR *dirp;
+int loc;
+{
+   return;
+}
+
+void rewinddir( dirp )
+DIR *dirp;
+{
+   lib$find_file_end (&dirp->dd_loc);
+}
+
+void closedir( dirp )
+DIR *dirp;
+{
+   lib$find_file_end (&dirp->dd_loc);
+
+   cfree ((void *) dirp->dd_fd);
+   cfree (dirp->dd_buf);
+   cfree (dirp);
+}