path: root/lib/pdf/xpdf-changes.patch

--- xpdf/Catalog.cc.orig	2010-08-16 14:02:38.000000000 -0700
+++ xpdf/Catalog.cc	2010-08-16 14:02:38.000000000 -0700
@@ -193,7 +193,7 @@
   if (!kids.isArray()) {
     error(-1, "Kids object (page %d) is wrong type (%s)",
 	  start+1, kids.getTypeName());
-    goto err1;
+    return start;
   }
   for (i = 0; i < kids.arrayGetLength(); ++i) {
     kids.arrayGetNF(i, &kidRef);
--- xpdf/CharCodeToUnicode.cc.orig	2010-08-16 14:02:38.000000000 -0700
+++ xpdf/CharCodeToUnicode.cc	2010-08-16 14:02:38.000000000 -0700
@@ -208,13 +208,13 @@
 				   int nBits) {
   PSTokenizer *pst;
   char tok1[256], tok2[256], tok3[256];
-  int nDigits, n1, n2, n3;
+  int maxCode, n1, n2, n3;
   CharCode i;
   CharCode code1, code2;
   GString *name;
   FILE *f;
 
-  nDigits = nBits / 4;
+  maxCode = (nBits == 8) ? 0xff : (nBits == 16) ? 0xffff : 0xffffffff;
   pst = new PSTokenizer(getCharFunc, data);
   pst->getToken(tok1, sizeof(tok1), &n1);
   while (pst->getToken(tok2, sizeof(tok2), &n2)) {
@@ -241,9 +241,9 @@
 	  error(-1, "Illegal entry in bfchar block in ToUnicode CMap");
 	  break;
 	}
-	if (!(n1 == 2 + nDigits && tok1[0] == '<' && tok1[n1 - 1] == '>' &&
+	if (!(tok1[0] == '<' && tok1[n1 - 1] == '>' &&
 	      tok2[0] == '<' && tok2[n2 - 1] == '>')) {
-	  error(-1, "Illegal entry in bfchar block in ToUnicode CMap");
+	  error(-1, "Illegal entry in bfchar block in ToUnicode CMap.");
 	  continue;
 	}
 	tok1[n1 - 1] = tok2[n2 - 1] = '\0';
@@ -251,6 +251,9 @@
 	  error(-1, "Illegal entry in bfchar block in ToUnicode CMap");
 	  continue;
 	}
+        if (code1 > maxCode) {
+          error(-1, "Invalid entry in bfchar block in ToUnicode CMap");
+        }
 	addMapping(code1, tok2 + 1, n2 - 2, 0);
       }
       pst->getToken(tok1, sizeof(tok1), &n1);
@@ -266,8 +269,8 @@
 	  error(-1, "Illegal entry in bfrange block in ToUnicode CMap");
 	  break;
 	}
-	if (!(n1 == 2 + nDigits && tok1[0] == '<' && tok1[n1 - 1] == '>' &&
-	      n2 == 2 + nDigits && tok2[0] == '<' && tok2[n2 - 1] == '>')) {
+	if (!(tok1[0] == '<' && tok1[n1 - 1] == '>' &&
+	      tok2[0] == '<' && tok2[n2 - 1] == '>')) {
 	  error(-1, "Illegal entry in bfrange block in ToUnicode CMap");
 	  continue;
 	}
@@ -277,6 +280,10 @@
 	  error(-1, "Illegal entry in bfrange block in ToUnicode CMap");
 	  continue;
 	}
+        if (code1 > maxCode || code2 > maxCode) {
+	    error(-1, "Invalid entry in bfrange block in ToUnicode CMap");
+	}
+
 	if (!strcmp(tok3, "[")) {
 	  i = 0;
 	  while (pst->getToken(tok1, sizeof(tok1), &n1) &&
@@ -320,7 +327,13 @@
   if (code >= mapLen) {
     oldLen = mapLen;
     mapLen = (code + 256) & ~255;
+    Unicode *oldmap;
     map = (Unicode *)greallocn(map, mapLen, sizeof(Unicode));
+    if(!map) {
+       /* we sometimes get overflows for files trying to use 0xffffffff as charcode */
+       map = oldmap;
+       return;
+    }
     for (i = oldLen; i < mapLen; ++i) {
       map[i] = 0;
     }
--- xpdf/Decrypt.cc.orig	2010-08-16 14:02:38.000000000 -0700
+++ xpdf/Decrypt.cc	2010-10-19 12:21:16.000000000 -0700
@@ -596,6 +596,7 @@
   s->bufIdx = 0;
   if (last) {
     n = s->buf[15];
+    if(!n || n>16) n=16;
     for (i = 15; i >= n; --i) {
       s->buf[i] = s->buf[i-n];
     }
--- xpdf/Function.cc.orig	2010-08-16 14:02:38.000000000 -0700
+++ xpdf/Function.cc	2010-10-19 12:21:32.000000000 -0700
@@ -401,7 +401,7 @@
       for (k = 0, t = j; k < m; ++k, t >>= 1) {
 	idx += idxMul[k] * (e[k][t & 1]);
       }
-      sBuf[j] = samples[idx];
+      sBuf[j] = (idx>=0&&idx<nSamples)? samples[idx] : 0;
     }
 
     // do m sets of interpolations
--- xpdf/Gfx.cc.orig	2010-08-16 14:02:38.000000000 -0700
+++ xpdf/Gfx.cc	2010-10-19 12:20:23.000000000 -0700
@@ -444,6 +444,7 @@
   xref = xrefA;
   subPage = gFalse;
   printCommands = globalParams->getPrintCommands();
+  parser = NULL;
 
   // start the resource stack
   res = new GfxResources(xref, resDict, NULL);
@@ -465,6 +466,7 @@
   abortCheckCbkData = abortCheckCbkDataA;
 
   // set crop box
+#ifdef XPDFEXE
   if (cropBox) {
     state->moveTo(cropBox->x1, cropBox->y1);
     state->lineTo(cropBox->x2, cropBox->y1);
@@ -475,6 +477,7 @@
     out->clip(state);
     state->clearPath();
   }
+#endif
 }
 
 Gfx::Gfx(XRef *xrefA, OutputDev *outA, Dict *resDict,
@@ -3182,8 +3185,11 @@
 			    u, (int)(sizeof(u) / sizeof(Unicode)), &uLen,
 			    &dx, &dy, &originX, &originY);
       dx = dx * state->getFontSize() + state->getCharSpace();
-      if (n == 1 && *p == ' ') {
-	dx += state->getWordSpace();
+      if (n == 1 && (*p == ' ' || *p == 0)) {
+        double w=state->getWordSpace();
+        if (w==0 && dx==0)
+          w=state->getFontSize()/3; // workaround for zero word space
+        dx += w;
       }
       dx *= state->getHorizScaling();
       dy *= state->getFontSize();
@@ -3476,11 +3482,13 @@
       }
     }
     if (!obj1.isNull()) {
-      colorSpace = GfxColorSpace::parse(&obj1);
+      colorSpace = GfxColorSpace::parse(&obj1, csMode);
     } else if (csMode == streamCSDeviceGray) {
       colorSpace = new GfxDeviceGrayColorSpace();
     } else if (csMode == streamCSDeviceRGB) {
       colorSpace = new GfxDeviceRGBColorSpace();
+    } else if (csMode == streamCSDeviceRGBX) {
+      colorSpace = new GfxDeviceRGBXColorSpace();
     } else if (csMode == streamCSDeviceCMYK) {
       colorSpace = new GfxDeviceCMYKColorSpace();
     } else {
@@ -3824,6 +3832,7 @@
     out->beginTransparencyGroup(state, bbox, blendingColorSpace,
 				isolated, knockout, softMask);
   }
+  GfxState*old_state = state;
 
   // set new base matrix
   for (i = 0; i < 6; ++i) {
@@ -3835,6 +3844,9 @@
   display(str, gFalse);
 
   if (softMask || transpGroup) {
+    // restore graphics state
+    while(state != old_state)
+	restoreState();
     out->endTransparencyGroup(state);
   }
 
@@ -3921,6 +3933,10 @@
   obj.free();
 
   // make stream
+  if(!parser->getStream()) {
+      error(getPos(), "Couldn't get stream");
+      return NULL;
+  }
   str = new EmbedStream(parser->getStream(), &dict, gFalse, 0);
   str = str->addFilters(&dict);
 
--- xpdf/GfxFont.cc.orig	2010-08-16 14:02:38.000000000 -0700
+++ xpdf/GfxFont.cc	2010-08-16 14:02:38.000000000 -0700
@@ -194,7 +194,7 @@
       embFontID = obj2.getRef();
       if (type != fontType1) {
 	error(-1, "Mismatch between font type and embedded font file");
-	type = fontType1;
+	type = isCIDFont() ? fontCIDType0 : fontType1;
       }
     }
     obj2.free();
@@ -919,6 +919,10 @@
   return 1;
 }
 
+CharCodeToUnicode* Gfx8BitFont::getCTU() {
+    return ctu;
+}
+
 CharCodeToUnicode *Gfx8BitFont::getToUnicode() {
   ctu->incRefCnt();
   return ctu;
@@ -1411,6 +1415,10 @@
   }
 }
 
+CharCodeToUnicode* GfxCIDFont::getCTU() {
+    return ctu;
+}
+
 int GfxCIDFont::getNextChar(char *s, int len, CharCode *code,
 			    Unicode *u, int uSize, int *uLen,
 			    double *dx, double *dy, double *ox, double *oy) {
--- xpdf/GfxFont.h.orig	2010-08-16 14:02:38.000000000 -0700
+++ xpdf/GfxFont.h	2010-08-16 14:02:38.000000000 -0700
@@ -164,6 +164,7 @@
   virtual int getNextChar(char *s, int len, CharCode *code,
 			  Unicode *u, int uSize, int *uLen,
 			  double *dx, double *dy, double *ox, double *oy) = 0;
+  virtual CharCodeToUnicode* getCTU() = 0;
 
 protected:
 
@@ -204,6 +205,7 @@
   virtual int getNextChar(char *s, int len, CharCode *code,
 			  Unicode *u, int uSize, int *uLen,
 			  double *dx, double *dy, double *ox, double *oy);
+  virtual CharCodeToUnicode* getCTU();
 
   // Return the encoding.
   char **getEncoding() { return enc; }
@@ -212,7 +214,7 @@
   CharCodeToUnicode *getToUnicode();
 
   // Return the character name associated with <code>.
-  char *getCharName(int code) { return enc[code]; }
+  char *getCharName(int code) { return code>=256?0:enc[code]; }
 
   // Returns true if the PDF font specified an encoding.
   GBool getHasEncoding() { return hasEncoding; }
@@ -266,6 +268,7 @@
   virtual int getNextChar(char *s, int len, CharCode *code,
 			  Unicode *u, int uSize, int *uLen,
 			  double *dx, double *dy, double *ox, double *oy);
+  virtual CharCodeToUnicode* getCTU();
 
   // Return the writing mode (0=horizontal, 1=vertical).
   virtual int getWMode();
--- xpdf/GfxState.cc.orig	2010-08-16 14:02:38.000000000 -0700
+++ xpdf/GfxState.cc	2010-08-16 14:02:38.000000000 -0700
@@ -21,6 +21,7 @@
 #include "Array.h"
 #include "Page.h"
 #include "GfxState.h"
+#include "cmyk.h"
 
 //------------------------------------------------------------------------
 
@@ -92,7 +93,7 @@
 GfxColorSpace::~GfxColorSpace() {
 }
 
-GfxColorSpace *GfxColorSpace::parse(Object *csObj) {
+GfxColorSpace *GfxColorSpace::parse(Object *csObj, StreamColorSpaceMode csMode) {
   GfxColorSpace *cs;
   Object obj1;
 
@@ -101,7 +102,10 @@
     if (csObj->isName("DeviceGray") || csObj->isName("G")) {
       cs = new GfxDeviceGrayColorSpace();
     } else if (csObj->isName("DeviceRGB") || csObj->isName("RGB")) {
-      cs = new GfxDeviceRGBColorSpace();
+      if(csMode == streamCSDeviceRGBX)
+	cs = new GfxDeviceRGBXColorSpace();
+      else
+	cs = new GfxDeviceRGBColorSpace();
     } else if (csObj->isName("DeviceCMYK") || csObj->isName("CMYK")) {
       cs = new GfxDeviceCMYKColorSpace();
     } else if (csObj->isName("Pattern")) {
@@ -114,7 +118,10 @@
     if (obj1.isName("DeviceGray") || obj1.isName("G")) {
       cs = new GfxDeviceGrayColorSpace();
     } else if (obj1.isName("DeviceRGB") || obj1.isName("RGB")) {
-      cs = new GfxDeviceRGBColorSpace();
+      if(csMode == streamCSDeviceRGBX)
+        cs = new GfxDeviceRGBColorSpace();
+      else
+	cs = new GfxDeviceRGBColorSpace();
     } else if (obj1.isName("DeviceCMYK") || obj1.isName("CMYK")) {
       cs = new GfxDeviceCMYKColorSpace();
     } else if (obj1.isName("CalGray")) {
@@ -333,6 +340,17 @@
 }
 
 //------------------------------------------------------------------------
+// GfxDeviceRGBXColorSpace
+//------------------------------------------------------------------------
+
+GfxDeviceRGBXColorSpace::GfxDeviceRGBXColorSpace() {
+}
+
+GfxColorSpace *GfxDeviceRGBXColorSpace::copy() {
+  return new GfxDeviceRGBXColorSpace();
+}
+
+//------------------------------------------------------------------------
 // GfxCalRGBColorSpace
 //------------------------------------------------------------------------
 
@@ -490,6 +508,18 @@
 				- 0.11 * color->c[2] + 0.5));
 }
 
+/*void GfxDeviceCMYKColorSpace::getRGB(GfxColor *color, GfxRGB *rgb) {
+    unsigned char r,g,b;
+    float c = color->c[0];
+    float m = color->c[1];
+    float y = color->c[2];
+    float k = color->c[3];
+    convert_cmyk2rgb(c,m,y,k, &r,&g,&b);
+    rgb->r = r/255.0;
+    rgb->g = g/255.0;
+    rgb->b = b/255.0;
+}*/
+
 void GfxDeviceCMYKColorSpace::getRGB(GfxColor *color, GfxRGB *rgb) {
   double c, m, y, k, c1, m1, y1, k1, r, g, b, x;
 
@@ -3187,6 +3217,7 @@
   GfxIndexedColorSpace *indexedCS;
   GfxSeparationColorSpace *sepCS;
   int maxPixel, indexHigh;
+  int maxPixelForAlloc;
   Guchar *lookup2;
   Function *sepFunc;
   Object obj;
@@ -3199,6 +3230,7 @@
   // bits per component and color space
   bits = bitsA;
   maxPixel = (1 << bits) - 1;
+  maxPixelForAlloc = (1 << (bits>8?bits:8));
   colorSpace = colorSpaceA;
 
   // initialize
@@ -3253,7 +3285,7 @@
     lookup2 = indexedCS->getLookup();
     colorSpace2->getDefaultRanges(x, y, indexHigh);
     for (k = 0; k < nComps2; ++k) {
-      lookup[k] = (GfxColorComp *)gmallocn(maxPixel + 1,
+      lookup[k] = (GfxColorComp *)gmallocn(maxPixelForAlloc + 1,
 					   sizeof(GfxColorComp));
       for (i = 0; i <= maxPixel; ++i) {
 	j = (int)(decodeLow[0] + (i * decodeRange[0]) / maxPixel + 0.5);
@@ -3272,7 +3304,7 @@
     nComps2 = colorSpace2->getNComps();
     sepFunc = sepCS->getFunc();
     for (k = 0; k < nComps2; ++k) {
-      lookup[k] = (GfxColorComp *)gmallocn(maxPixel + 1,
+      lookup[k] = (GfxColorComp *)gmallocn(maxPixelForAlloc + 1,
 					   sizeof(GfxColorComp));
       for (i = 0; i <= maxPixel; ++i) {
 	x[0] = decodeLow[0] + (i * decodeRange[0]) / maxPixel;
@@ -3282,7 +3314,7 @@
     }
   } else {
     for (k = 0; k < nComps; ++k) {
-      lookup[k] = (GfxColorComp *)gmallocn(maxPixel + 1,
+      lookup[k] = (GfxColorComp *)gmallocn(maxPixelForAlloc + 1,
 					   sizeof(GfxColorComp));
       for (i = 0; i <= maxPixel; ++i) {
 	lookup[k][i] = dblToCol(decodeLow[k] +
@@ -3754,7 +3786,10 @@
 }
 
 void GfxState::setPath(GfxPath *pathA) {
+  if(pathA) {
+      if(path)
   delete path;
+  }
   path = pathA;
 }
 
--- xpdf/GfxState.h.orig	2010-08-16 14:02:38.000000000 -0700
+++ xpdf/GfxState.h	2010-08-16 14:02:38.000000000 -0700
@@ -138,7 +138,7 @@
   virtual GfxColorSpaceMode getMode() = 0;
 
   // Construct a color space.  Returns NULL if unsuccessful.
-  static GfxColorSpace *parse(Object *csObj);
+  static GfxColorSpace *parse(Object *csObj, StreamColorSpaceMode csMode = streamCSNone);
 
   // Convert to gray, RGB, or CMYK.
   virtual void getGray(GfxColor *color, GfxGray *gray) = 0;
@@ -251,6 +251,19 @@
 private:
 };
 
+//------------------------------------------------------------------------
+// GfxDeviceRGBXColorSpace
+//------------------------------------------------------------------------
+
+class GfxDeviceRGBXColorSpace: public GfxDeviceRGBColorSpace {
+public:
+
+  GfxDeviceRGBXColorSpace();
+  virtual GfxColorSpace *copy();
+  virtual int getNComps() { return 4; }
+private:
+};
+
 //------------------------------------------------------------------------
 // GfxCalRGBColorSpace
 //------------------------------------------------------------------------
--- xpdf/GlobalParams.cc.orig	2010-08-16 14:02:38.000000000 -0700
+++ xpdf/GlobalParams.cc	2010-08-16 14:02:38.000000000 -0700
@@ -914,6 +914,29 @@
   int line;
   char buf[512];
 
+  /* extract path */
+  if(fileName) {
+    char* cfgFileName = fileName->getCString();
+    char* pos1 = strrchr(cfgFileName, '/');
+    char* pos2 = strrchr(cfgFileName, '\\');
+    char* p = pos1>pos2?pos1:pos2;
+    int pos = p ? p-cfgFileName : -1;
+    GString*path = new GString(new GString(cfgFileName), 0, (pos < 0 ? strlen(cfgFileName): pos));
+    if(pos1>=0)
+	path->append('/');
+    else if(pos2>=0)
+	path->append('\\');
+    else
+#ifdef WIN32
+	path->append('\\');
+#else
+	path->append('/');
+#endif
+    this->path = path;
+  } else {
+    this->path = new GString();
+  }
+  
   line = 1;
   while (getLine(buf, sizeof(buf) - 1, f)) {
     parseLine(buf, fileName, line);
@@ -1114,6 +1137,42 @@
   deleteGList(tokens, GString);
 }
 
+static char is_absolute(char*filename)
+{
+    int l = strlen(filename);
+    if(filename[0] == '/' || filename[0] == '\\') 
+	return 1;
+    if(l>2 && filename[1]==':' && (filename[2]=='\\' || filename[2]=='/'))
+	return 1;
+    return 0;
+}
+
+static GString* qualify_filename(GString*path, GString*filename)
+{
+  GString*fullpath = 0;
+  char*prefix = "/usr/local/share/xpdf/";
+
+  if (!is_absolute(filename->getCString())) {
+    /* relative path */
+    fullpath = path->copy();
+    fullpath->append(filename);
+  } else if (!strncmp(filename->getCString(), prefix, strlen(prefix))) {
+    /* xpdf default path */
+    char*s = strchr(filename->getCString()+strlen(prefix), '/');
+    if(s) {
+	fullpath = path->copy();
+	fullpath->append(s+1);
+    } else {
+	fullpath = filename->copy();
+    }
+  } else {
+    /* absolute path */
+    fullpath = filename->copy();
+  }
+  //printf("%s -%s-> %s\n", filename->getCString(), path->getCString(), fullpath->getCString());
+  return fullpath;
+}
+
 void GlobalParams::parseNameToUnicode(GList *tokens, GString *fileName,
 					 int line) {
   GString *name;
@@ -1128,10 +1187,10 @@
 	  fileName->getCString(), line);
     return;
   }
-  name = (GString *)tokens->get(1);
+  name = qualify_filename(this->path, (GString *)tokens->get(1));
   if (!(f = fopen(name->getCString(), "r"))) {
-    error(-1, "Couldn't open 'nameToUnicode' file '%s'",
-	  name->getCString());
+    error(-1, "Couldn't open 'nameToUnicode' file '%s' using path '%s'",
+	  name->getCString(), path->getCString());
     return;
   }
   line2 = 1;
@@ -1160,10 +1219,12 @@
   }
   collection = (GString *)tokens->get(1);
   name = (GString *)tokens->get(2);
+
   if ((old = (GString *)cidToUnicodes->remove(collection))) {
     delete old;
   }
-  cidToUnicodes->add(collection->copy(), name->copy());
+
+  cidToUnicodes->add(collection->copy(), qualify_filename(this->path, name));
 }
 
 void GlobalParams::parseUnicodeToUnicode(GList *tokens, GString *fileName,
@@ -1180,7 +1241,8 @@
   if ((old = (GString *)unicodeToUnicodes->remove(font))) {
     delete old;
   }
-  unicodeToUnicodes->add(font->copy(), file->copy());
+
+  unicodeToUnicodes->add(font->copy(), qualify_filename(this->path, file));
 }
 
 void GlobalParams::parseUnicodeMap(GList *tokens, GString *fileName,
@@ -1197,7 +1259,8 @@
   if ((old = (GString *)unicodeMaps->remove(encodingName))) {
     delete old;
   }
-  unicodeMaps->add(encodingName->copy(), name->copy());
+
+  unicodeMaps->add(encodingName->copy(), qualify_filename(this->path, name));
 }
 
 void GlobalParams::parseCMapDir(GList *tokens, GString *fileName, int line) {
@@ -1215,23 +1278,30 @@
     list = new GList();
     cMapDirs->add(collection->copy(), list);
   }
-  list->append(dir->copy());
+
+  list->append(qualify_filename(this->path, dir));
 }
 
 void GlobalParams::parseToUnicodeDir(GList *tokens, GString *fileName,
 				     int line) {
+  GString *dir;
+
   if (tokens->getLength() != 2) {
     error(-1, "Bad 'toUnicodeDir' config file command (%s:%d)",
 	  fileName->getCString(), line);
     return;
   }
-  toUnicodeDirs->append(((GString *)tokens->get(1))->copy());
+
+  dir = (GString *)tokens->get(1);
+
+  toUnicodeDirs->append(qualify_filename(this->path, dir));
 }
 
 void GlobalParams::parseDisplayFont(GList *tokens, GHash *fontHash,
 				    DisplayFontParamKind kind,
 				    GString *fileName, int line) {
   DisplayFontParam *param, *old;
+  GString *file;
 
   if (tokens->getLength() < 2) {
     goto err1;
@@ -1243,13 +1313,15 @@
     if (tokens->getLength() != 3) {
       goto err2;
     }
-    param->t1.fileName = ((GString *)tokens->get(2))->copy();
+    file = (GString *)tokens->get(2);
+    param->t1.fileName = qualify_filename(this->path, file);
     break;
   case displayFontTT:
     if (tokens->getLength() != 3) {
       goto err2;
     }
-    param->tt.fileName = ((GString *)tokens->get(2))->copy();
+    file = (GString *)tokens->get(2);
+    param->tt.fileName = qualify_filename(this->path, file);
     break;
   }
 
--- xpdf/GlobalParams.h.orig	2010-08-16 14:02:38.000000000 -0700
+++ xpdf/GlobalParams.h	2010-08-16 14:02:38.000000000 -0700
@@ -196,7 +196,7 @@
   // file.
   GlobalParams(char *cfgFileName);
 
-  ~GlobalParams();
+  virtual ~GlobalParams();
 
   void setBaseDir(char *dir);
   void setupBaseFonts(char *dir);
@@ -213,8 +213,8 @@
   FILE *getUnicodeMapFile(GString *encodingName);
   FILE *findCMapFile(GString *collection, GString *cMapName);
   FILE *findToUnicodeFile(GString *name);
-  DisplayFontParam *getDisplayFont(GString *fontName);
-  DisplayFontParam *getDisplayCIDFont(GString *fontName, GString *collection);
+  virtual DisplayFontParam *getDisplayFont(GString *fontName);
+  virtual DisplayFontParam *getDisplayCIDFont(GString *fontName, GString *collection);
   GString *getPSFile();
   int getPSPaperWidth();
   int getPSPaperHeight();
@@ -316,7 +316,7 @@
 private:
 
   void createDefaultKeyBindings();
-  void parseFile(GString *fileName, FILE *f);
+public: void parseFile(GString *fileName, FILE *f); private:
   void parseNameToUnicode(GList *tokens, GString *fileName, int line);
   void parseCIDToUnicode(GList *tokens, GString *fileName, int line);
   void parseUnicodeToUnicode(GList *tokens, GString *fileName, int line);
@@ -358,6 +358,10 @@
   GBool loadPlugin(char *type, char *name);
 #endif
 
+  //----- config file base path
+
+  GString*path;
+
   //----- static tables
 
   NameToCharCode *		// mapping from char name to
--- xpdf/JBIG2Stream.cc.orig	2010-08-16 14:02:38.000000000 -0700
+++ xpdf/JBIG2Stream.cc	2010-08-16 14:02:38.000000000 -0700
@@ -6,7 +6,24 @@
 //
 //========================================================================
 
-#include <aconf.h>
+//========================================================================
+//
+// Modified under the Poppler project - http://poppler.freedesktop.org
+//
+// All changes made under the Poppler project to this file are licensed
+// under GPL version 2 or later
+//
+// Copyright (C) 2006 Raj Kumar <rkumar@archive.org>
+// Copyright (C) 2006 Paul Walmsley <paul@booyaka.com>
+// Copyright (C) 2006-2009 Albert Astals Cid <aacid@kde.org>
+// Copyright (C) 2009 David Benjamin <davidben@mit.edu>
+//
+// To see a description of the changes please see the Changelog file that
+// came with your tarball or type make ChangeLog if you are building from git
+//
+//========================================================================
+
+#include <config.h>
 
 #ifdef USE_GCC_PRAGMAS
 #pragma implementation
@@ -24,8 +41,8 @@
 
 //------------------------------------------------------------------------
 
-static int contextSize[4] = { 16, 13, 10, 10 };
-static int refContextSize[2] = { 13, 10 };
+static const int contextSize[4] = { 16, 13, 10, 10 };
+static const int refContextSize[2] = { 13, 10 };
 
 //------------------------------------------------------------------------
 // JBIG2HuffmanTable
@@ -42,7 +59,7 @@
   Guint prefix;
 };
 
-JBIG2HuffmanTable huffTableA[] = {
+static JBIG2HuffmanTable huffTableA[] = {
   {     0, 1,  4,              0x000 },
   {    16, 2,  8,              0x002 },
   {   272, 3, 16,              0x006 },
@@ -50,7 +67,7 @@
   {     0, 0, jbig2HuffmanEOT, 0     }
 };
 
-JBIG2HuffmanTable huffTableB[] = {
+static JBIG2HuffmanTable huffTableB[] = {
   {     0, 1,  0,              0x000 },
   {     1, 2,  0,              0x002 },
   {     2, 3,  0,              0x006 },
@@ -61,7 +78,7 @@
   {     0, 0, jbig2HuffmanEOT, 0     }
 };
 
-JBIG2HuffmanTable huffTableC[] = {
+static JBIG2HuffmanTable huffTableC[] = {
   {     0, 1,  0,              0x000 },
   {     1, 2,  0,              0x002 },
   {     2, 3,  0,              0x006 },
@@ -74,7 +91,7 @@
   {     0, 0, jbig2HuffmanEOT, 0     }
 };
 
-JBIG2HuffmanTable huffTableD[] = {
+static JBIG2HuffmanTable huffTableD[] = {
   {     1, 1,  0,              0x000 },
   {     2, 2,  0,              0x002 },
   {     3, 3,  0,              0x006 },
@@ -84,7 +101,7 @@
   {     0, 0, jbig2HuffmanEOT, 0     }
 };
 
-JBIG2HuffmanTable huffTableE[] = {
+static JBIG2HuffmanTable huffTableE[] = {
   {     1, 1,  0,              0x000 },
   {     2, 2,  0,              0x002 },
   {     3, 3,  0,              0x006 },
@@ -96,7 +113,7 @@
   {     0, 0, jbig2HuffmanEOT, 0     }
 };
 
-JBIG2HuffmanTable huffTableF[] = {
+static JBIG2HuffmanTable huffTableF[] = {
   {     0, 2,  7,              0x000 },
   {   128, 3,  7,              0x002 },
   {   256, 3,  8,              0x003 },
@@ -114,7 +131,7 @@
   {     0, 0, jbig2HuffmanEOT, 0     }
 };
 
-JBIG2HuffmanTable huffTableG[] = {
+static JBIG2HuffmanTable huffTableG[] = {
   {  -512, 3,  8,              0x000 },
   {   256, 3,  8,              0x001 },
   {   512, 3,  9,              0x002 },
@@ -133,7 +150,7 @@
   {     0, 0, jbig2HuffmanEOT, 0     }
 };
 
-JBIG2HuffmanTable huffTableH[] = {
+static JBIG2HuffmanTable huffTableH[] = {
   {     0, 2,  1,              0x000 },
   {     0, 2, jbig2HuffmanOOB, 0x001 },
   {     4, 3,  4,              0x004 },
@@ -158,7 +175,7 @@
   {     0, 0, jbig2HuffmanEOT, 0     }
 };
 
-JBIG2HuffmanTable huffTableI[] = {
+static JBIG2HuffmanTable huffTableI[] = {
   {     0, 2, jbig2HuffmanOOB, 0x000 },
   {    -1, 3,  1,              0x002 },
   {     1, 3,  1,              0x003 },
@@ -184,7 +201,7 @@
   {     0, 0, jbig2HuffmanEOT, 0     }
 };
 
-JBIG2HuffmanTable huffTableJ[] = {
+static JBIG2HuffmanTable huffTableJ[] = {
   {    -2, 2,  2,              0x000 },
   {     6, 2,  6,              0x001 },
   {     0, 2, jbig2HuffmanOOB, 0x002 },
@@ -209,7 +226,7 @@
   {     0, 0, jbig2HuffmanEOT, 0     }
 };
 
-JBIG2HuffmanTable huffTableK[] = {
+static JBIG2HuffmanTable huffTableK[] = {
   {     1, 1,  0,              0x000 },
   {     2, 2,  1,              0x002 },
   {     4, 4,  0,              0x00c },
@@ -226,7 +243,7 @@
   {     0, 0, jbig2HuffmanEOT, 0     }
 };
 
-JBIG2HuffmanTable huffTableL[] = {
+static JBIG2HuffmanTable huffTableL[] = {
   {     1, 1,  0,              0x000 },
   {     2, 2,  0,              0x002 },
   {     3, 3,  1,              0x006 },
@@ -243,7 +260,7 @@
   {     0, 0, jbig2HuffmanEOT, 0     }
 };
 
-JBIG2HuffmanTable huffTableM[] = {
+static JBIG2HuffmanTable huffTableM[] = {
   {     1, 1,  0,              0x000 },
   {     2, 3,  0,              0x004 },
   {     7, 3,  3,              0x005 },
@@ -260,7 +277,7 @@
   {     0, 0, jbig2HuffmanEOT, 0     }
 };
 
-JBIG2HuffmanTable huffTableN[] = {
+static JBIG2HuffmanTable huffTableN[] = {
   {     0, 1,  0,              0x000 },
   {    -2, 3,  0,              0x004 },
   {    -1, 3,  0,              0x005 },
@@ -269,7 +286,7 @@
   {     0, 0, jbig2HuffmanEOT, 0     }
 };
 
-JBIG2HuffmanTable huffTableO[] = {
+static JBIG2HuffmanTable huffTableO[] = {
   {     0, 1,  0,              0x000 },
   {    -1, 3,  0,              0x004 },
   {     1, 3,  0,              0x005 },
@@ -473,7 +490,7 @@
 }
 
 int JBIG2MMRDecoder::get2DCode() {
-  CCITTCode *p;
+  const CCITTCode *p;
 
   if (bufLen == 0) {
     buf = str->getChar() & 0xff;
@@ -500,7 +517,7 @@
 }
 
 int JBIG2MMRDecoder::getWhiteCode() {
-  CCITTCode *p;
+  const CCITTCode *p;
   Guint code;
 
   if (bufLen == 0) {
@@ -543,7 +560,7 @@
 }
 
 int JBIG2MMRDecoder::getBlackCode() {
-  CCITTCode *p;
+  const CCITTCode *p;
   Guint code;
 
   if (bufLen == 0) {
@@ -670,6 +687,7 @@
   void combine(JBIG2Bitmap *bitmap, int x, int y, Guint combOp);
   Guchar *getDataPtr() { return data; }
   int getDataSize() { return h * line; }
+  GBool isOk() { return data != NULL; }
 
 private:
 
@@ -685,10 +703,11 @@
   w = wA;
   h = hA;
   line = (wA + 7) >> 3;
+
   if (w <= 0 || h <= 0 || line <= 0 || h >= (INT_MAX - 1) / line) {
-    // force a call to gmalloc(-1), which will throw an exception
-    h = -1;
-    line = 2;
+    error(-1, "invalid width/height");
+    data = NULL;
+    return;
   }
   // need to allocate one extra guard byte for use in combine()
   data = (Guchar *)gmalloc(h * line + 1);
@@ -701,10 +720,11 @@
   w = bitmap->w;
   h = bitmap->h;
   line = bitmap->line;
+
   if (w <= 0 || h <= 0 || line <= 0 || h >= (INT_MAX - 1) / line) {
-    // force a call to gmalloc(-1), which will throw an exception
-    h = -1;
-    line = 2;
+    error(-1, "invalid width/height");
+    data = NULL;
+    return;
   }
   // need to allocate one extra guard byte for use in combine()
   data = (Guchar *)gmalloc(h * line + 1);
@@ -735,6 +755,9 @@
 
 void JBIG2Bitmap::expand(int newH, Guint pixel) {
   if (newH <= h || line <= 0 || newH >= (INT_MAX - 1) / line) {
+    error(-1, "invalid width/height");
+    gfree(data);
+    data = NULL;
     return;
   }
   // need to allocate one extra guard byte for use in combine()
@@ -1002,6 +1025,7 @@
   Guint getSize() { return size; }
   void setBitmap(Guint idx, JBIG2Bitmap *bitmap) { bitmaps[idx] = bitmap; }
   JBIG2Bitmap *getBitmap(Guint idx) { return bitmaps[idx]; }
+  GBool isOk() { return bitmaps != NULL; }
   void setGenericRegionStats(JArithmeticDecoderStats *stats)
     { genericRegionStats = stats; }
   void setRefinementRegionStats(JArithmeticDecoderStats *stats)
@@ -1022,13 +1046,9 @@
 JBIG2SymbolDict::JBIG2SymbolDict(Guint segNumA, Guint sizeA):
   JBIG2Segment(segNumA)
 {
-  Guint i;
-
   size = sizeA;
   bitmaps = (JBIG2Bitmap **)gmallocn(size, sizeof(JBIG2Bitmap *));
-  for (i = 0; i < size; ++i) {
-    bitmaps[i] = NULL;
-  }
+  if (!bitmaps) size = 0;
   genericRegionStats = NULL;
   refinementRegionStats = NULL;
 }
@@ -1037,9 +1057,7 @@
   Guint i;
 
   for (i = 0; i < size; ++i) {
-    if (bitmaps[i]) {
-      delete bitmaps[i];
-    }
+    delete bitmaps[i];
   }
   gfree(bitmaps);
   if (genericRegionStats) {
@@ -1247,6 +1265,7 @@
   Guint segNum, segFlags, segType, page, segLength;
   Guint refFlags, nRefSegs;
   Guint *refSegs;
+  int segDataPos;
   int c1, c2, c3;
   Guint i;
 
@@ -1314,6 +1333,9 @@
       goto eofError2;
     }
 
+    // keep track of the start of the segment data 
+    segDataPos = getPos();
+
     // check for missing page information segment
     if (!pageBitmap && ((segType >= 4 && segType <= 7) ||
 			(segType >= 20 && segType <= 43))) {
@@ -1398,6 +1420,45 @@
       break;
     }
 
+    // Make sure the segment handler read all of the bytes in the 
+    // segment data, unless this segment is marked as having an
+    // unknown length (section 7.2.7 of the JBIG2 Final Committee Draft)
+
+    if (segLength != 0xffffffff) {
+
+      int segExtraBytes = segDataPos + segLength - getPos();
+      if (segExtraBytes > 0) {
+
+	// If we didn't read all of the bytes in the segment data,
+	// indicate an error, and throw away the rest of the data.
+	
+	// v.3.1.01.13 of the LuraTech PDF Compressor Server will
+	// sometimes generate an extraneous NULL byte at the end of
+	// arithmetic-coded symbol dictionary segments when numNewSyms
+	// == 0.  Segments like this often occur for blank pages.
+	
+	error(getPos(), "%d extraneous byte%s after segment",
+	      segExtraBytes, (segExtraBytes > 1) ? "s" : "");
+	
+	// Burn through the remaining bytes -- inefficient, but
+	// hopefully we're not doing this much
+	
+	int trash;
+	for (int i = segExtraBytes; i > 0; i--) {
+	  readByte(&trash);
+	}
+	
+      } else if (segExtraBytes < 0) {
+	
+	// If we read more bytes than we should have, according to the 
+	// segment length field, note an error.
+	
+	error(getPos(), "Previous segment handler read too many bytes");
+	
+      }
+
+    }
+    
     gfree(refSegs);
   }
 
@@ -1493,6 +1554,9 @@
   codeTables = new GList();
   numInputSyms = 0;
   for (i = 0; i < nRefSegs; ++i) {
+    // This is need by bug 12014, returning gFalse makes it not crash
+    // but we end up with a empty page while acroread is able to render
+    // part of it
     if ((seg = findSegment(refSegs[i]))) {
       if (seg->getType() == jbig2SegSymbolDict) {
 	j = ((JBIG2SymbolDict *)seg)->getSize();
@@ -1503,8 +1567,11 @@
 	}
 	numInputSyms += j;
       } else if (seg->getType() == jbig2SegCodeTable) {
-	codeTables->append(seg);
+        codeTables->append(seg);
       }
+    } else {
+      delete codeTables;
+      return gFalse;
     }
   }
   if (numInputSyms > UINT_MAX - numNewSyms) {
@@ -1514,11 +1581,14 @@
   }
 
   // compute symbol code length
-  symCodeLen = 1;
-  i = (numInputSyms + numNewSyms) >> 1;
-  while (i) {
-    ++symCodeLen;
-    i >>= 1;
+  symCodeLen = 0;
+  i = 1;
+  while (i < numInputSyms + numNewSyms) {
+   ++symCodeLen;
+   i <<= 1;
+  }
+  if (huff && symCodeLen == 0) {
+   symCodeLen = 1;
   }
 
   // get the input symbol bitmaps
@@ -1530,12 +1600,11 @@
   k = 0;
   inputSymbolDict = NULL;
   for (i = 0; i < nRefSegs; ++i) {
-    if ((seg = findSegment(refSegs[i]))) {
-      if (seg->getType() == jbig2SegSymbolDict) {
-	inputSymbolDict = (JBIG2SymbolDict *)seg;
-	for (j = 0; j < inputSymbolDict->getSize(); ++j) {
-	  bitmaps[k++] = inputSymbolDict->getBitmap(j);
-	}
+    seg = findSegment(refSegs[i]);
+    if (seg != NULL && seg->getType() == jbig2SegSymbolDict) {
+      inputSymbolDict = (JBIG2SymbolDict *)seg;
+      for (j = 0; j < inputSymbolDict->getSize(); ++j) {
+	bitmaps[k++] = inputSymbolDict->getBitmap(j);
       }
     }
   }
@@ -1753,6 +1822,10 @@
 
   // create the symbol dict object
   symbolDict = new JBIG2SymbolDict(segNum, numExSyms);
+  if (!symbolDict->isOk()) {
+    delete symbolDict;
+    goto syntaxError;
+  }
 
   // exported symbol list
   i = j = 0;
@@ -1766,6 +1839,7 @@
     if (i + run > numInputSyms + numNewSyms ||
 	(ex && j + run > numExSyms)) {
       error(getPos(), "Too many exported symbols in JBIG2 symbol dictionary");
+      for ( ; j < numExSyms; ++j) symbolDict->setBitmap(j, NULL);
       delete symbolDict;
       goto syntaxError;
     }
@@ -1780,6 +1854,7 @@
   }
   if (j != numExSyms) {
     error(getPos(), "Too few symbols in JBIG2 symbol dictionary");
+    for ( ; j < numExSyms; ++j) symbolDict->setBitmap(j, NULL);
     delete symbolDict;
     goto syntaxError;
   }
@@ -1921,6 +1996,9 @@
     ++symCodeLen;
     i <<= 1;
   }
+  if (huff && symCodeLen == 0) {
+    symCodeLen = 1;
+  }
 
   // get the symbol bitmaps
   syms = (JBIG2Bitmap **)gmallocn(numSyms, sizeof(JBIG2Bitmap *));
@@ -2095,18 +2173,20 @@
 
   gfree(syms);
 
-  // combine the region bitmap into the page bitmap
-  if (imm) {
-    if (pageH == 0xffffffff && y + h > curPageH) {
-      pageBitmap->expand(y + h, pageDefPixel);
-    }
-    pageBitmap->combine(bitmap, x, y, extCombOp);
-    delete bitmap;
+  if (bitmap) {
+    // combine the region bitmap into the page bitmap
+    if (imm) {
+      if (pageH == 0xffffffff && y + h > curPageH) {
+        pageBitmap->expand(y + h, pageDefPixel);
+      }
+      pageBitmap->combine(bitmap, x, y, extCombOp);
+      delete bitmap;
 
-  // store the region bitmap
-  } else {
-    bitmap->setSegNum(segNum);
-    segments->append(bitmap);
+    // store the region bitmap
+    } else {
+      bitmap->setSegNum(segNum);
+      segments->append(bitmap);
+    }
   }
 
   // clean up the Huffman decoder
@@ -2159,6 +2239,10 @@
 
   // allocate the bitmap
   bitmap = new JBIG2Bitmap(0, w, h);
+  if (!bitmap->isOk()) {
+    delete bitmap;
+    return NULL;
+  }
   if (defPixel) {
     bitmap->clearToOne();
   } else {
@@ -2235,73 +2319,84 @@
 	  ri = 0;
 	}
 	if (ri) {
+	  GBool decodeSuccess;
 	  if (huff) {
-	    huffDecoder->decodeInt(&rdw, huffRDWTable);
-	    huffDecoder->decodeInt(&rdh, huffRDHTable);
-	    huffDecoder->decodeInt(&rdx, huffRDXTable);
-	    huffDecoder->decodeInt(&rdy, huffRDYTable);
-	    huffDecoder->decodeInt(&bmSize, huffRSizeTable);
+	    decodeSuccess = huffDecoder->decodeInt(&rdw, huffRDWTable);
+	    decodeSuccess = decodeSuccess && huffDecoder->decodeInt(&rdh, huffRDHTable);
+	    decodeSuccess = decodeSuccess && huffDecoder->decodeInt(&rdx, huffRDXTable);
+	    decodeSuccess = decodeSuccess && huffDecoder->decodeInt(&rdy, huffRDYTable);
+	    decodeSuccess = decodeSuccess && huffDecoder->decodeInt(&bmSize, huffRSizeTable);
 	    huffDecoder->reset();
 	    arithDecoder->start();
 	  } else {
-	    arithDecoder->decodeInt(&rdw, iardwStats);
-	    arithDecoder->decodeInt(&rdh, iardhStats);
-	    arithDecoder->decodeInt(&rdx, iardxStats);
-	    arithDecoder->decodeInt(&rdy, iardyStats);
+	    decodeSuccess = arithDecoder->decodeInt(&rdw, iardwStats);
+	    decodeSuccess = decodeSuccess && arithDecoder->decodeInt(&rdh, iardhStats);
+	    decodeSuccess = decodeSuccess && arithDecoder->decodeInt(&rdx, iardxStats);
+	    decodeSuccess = decodeSuccess && arithDecoder->decodeInt(&rdy, iardyStats);
+	  }
+	  
+	  if (decodeSuccess && syms[symID])
+	  {
+	    refDX = ((rdw >= 0) ? rdw : rdw - 1) / 2 + rdx;
+	    refDY = ((rdh >= 0) ? rdh : rdh - 1) / 2 + rdy;
+
+	    symbolBitmap =
+	      readGenericRefinementRegion(rdw + syms[symID]->getWidth(),
+					  rdh + syms[symID]->getHeight(),
+					  templ, gFalse, syms[symID],
+					  refDX, refDY, atx, aty);
 	  }
-	  refDX = ((rdw >= 0) ? rdw : rdw - 1) / 2 + rdx;
-	  refDY = ((rdh >= 0) ? rdh : rdh - 1) / 2 + rdy;
-
-	  symbolBitmap =
-	    readGenericRefinementRegion(rdw + syms[symID]->getWidth(),
-					rdh + syms[symID]->getHeight(),
-					templ, gFalse, syms[symID],
-					refDX, refDY, atx, aty);
 	  //~ do we need to use the bmSize value here (in Huffman mode)?
 	} else {
 	  symbolBitmap = syms[symID];
 	}
 
-	// combine the symbol bitmap into the region bitmap
-	//~ something is wrong here - refCorner shouldn't degenerate into
-	//~   two cases
-	bw = symbolBitmap->getWidth() - 1;
-	bh = symbolBitmap->getHeight() - 1;
-	if (transposed) {
-	  switch (refCorner) {
-	  case 0: // bottom left
-	    bitmap->combine(symbolBitmap, tt, s, combOp);
-	    break;
-	  case 1: // top left
-	    bitmap->combine(symbolBitmap, tt, s, combOp);
-	    break;
-	  case 2: // bottom right
-	    bitmap->combine(symbolBitmap, tt - bw, s, combOp);
-	    break;
-	  case 3: // top right
-	    bitmap->combine(symbolBitmap, tt - bw, s, combOp);
-	    break;
+	if (symbolBitmap) {
+	  // combine the symbol bitmap into the region bitmap
+	  //~ something is wrong here - refCorner shouldn't degenerate into
+	  //~   two cases
+	  bw = symbolBitmap->getWidth() - 1;
+	  bh = symbolBitmap->getHeight() - 1;
+	  if (transposed) {
+	    switch (refCorner) {
+	    case 0: // bottom left
+	      bitmap->combine(symbolBitmap, tt, s, combOp);
+	      break;
+	    case 1: // top left
+	      bitmap->combine(symbolBitmap, tt, s, combOp);
+	      break;
+	    case 2: // bottom right
+	      bitmap->combine(symbolBitmap, tt - bw, s, combOp);
+	      break;
+	    case 3: // top right
+	      bitmap->combine(symbolBitmap, tt - bw, s, combOp);
+	      break;
+	    }
+	    s += bh;
+	  } else {
+	    switch (refCorner) {
+	    case 0: // bottom left
+	      bitmap->combine(symbolBitmap, s, tt - bh, combOp);
+	      break;
+	    case 1: // top left
+	      bitmap->combine(symbolBitmap, s, tt, combOp);
+	      break;
+	    case 2: // bottom right
+	      bitmap->combine(symbolBitmap, s, tt - bh, combOp);
+	      break;
+	    case 3: // top right
+	      bitmap->combine(symbolBitmap, s, tt, combOp);
+	      break;
+	    }
+	    s += bw;
 	  }
-	  s += bh;
-	} else {
-	  switch (refCorner) {
-	  case 0: // bottom left
-	    bitmap->combine(symbolBitmap, s, tt - bh, combOp);
-	    break;
-	  case 1: // top left
-	    bitmap->combine(symbolBitmap, s, tt, combOp);
-	    break;
-	  case 2: // bottom right
-	    bitmap->combine(symbolBitmap, s, tt - bh, combOp);
-	    break;
-	  case 3: // top right
-	    bitmap->combine(symbolBitmap, s, tt, combOp);
-	    break;
+	  if (ri) {
+	    delete symbolBitmap;
 	  }
-	  s += bw;
-	}
-	if (ri) {
-	  delete symbolBitmap;
+	} else {
+	  // NULL symbolBitmap only happens on error
+	  delete bitmap;
+	  return NULL;
 	}
       }
 
@@ -2431,11 +2526,12 @@
     error(getPos(), "Bad symbol dictionary reference in JBIG2 halftone segment");
     return;
   }
-  if (!(seg = findSegment(refSegs[0])) ||
-      seg->getType() != jbig2SegPatternDict) {
+  seg = findSegment(refSegs[0]);
+  if (seg == NULL || seg->getType() != jbig2SegPatternDict) {
     error(getPos(), "Bad symbol dictionary reference in JBIG2 halftone segment");
     return;
   }
+
   patternDict = (JBIG2PatternDict *)seg;
   bpp = 0;
   i = 1;
@@ -2591,6 +2687,8 @@
   // read the bitmap
   bitmap = readGenericBitmap(mmr, w, h, templ, tpgdOn, gFalse,
 			     NULL, atx, aty, mmr ? length - 18 : 0);
+  if (!bitmap)
+    return;
 
   // combine the region bitmap into the page bitmap
   if (imm) {
@@ -2616,7 +2714,7 @@
 				      int *codingLine, int *a0i, int w) {
   if (a1 > codingLine[*a0i]) {
     if (a1 > w) {
-      error(getPos(), "JBIG2 MMR row is wrong length ({0:d})", a1);
+      error(getPos(), "JBIG2 MMR row is wrong length (%d)", a1);
       a1 = w;
     }
     if ((*a0i & 1) ^ blackPixels) {
@@ -2630,7 +2728,7 @@
 					 int *codingLine, int *a0i, int w) {
   if (a1 > codingLine[*a0i]) {
     if (a1 > w) {
-      error(getPos(), "JBIG2 MMR row is wrong length ({0:d})", a1);
+      error(getPos(), "JBIG2 MMR row is wrong length (%d)", a1);
       a1 = w;
     }
     if ((*a0i & 1) ^ blackPixels) {
@@ -2657,13 +2755,17 @@
   JBIG2Bitmap *bitmap;
   GBool ltp;
   Guint ltpCX, cx, cx0, cx1, cx2;
-  JBIG2BitmapPtr cxPtr0, cxPtr1;
-  JBIG2BitmapPtr atPtr0, atPtr1, atPtr2, atPtr3;
+  JBIG2BitmapPtr cxPtr0 = {0}, cxPtr1 = {0};
+  JBIG2BitmapPtr atPtr0 = {0}, atPtr1 = {0}, atPtr2 = {0}, atPtr3 = {0};
   int *refLine, *codingLine;
   int code1, code2, code3;
   int x, y, a0i, b1i, blackPixels, pix, i;
 
   bitmap = new JBIG2Bitmap(0, w, h);
+  if (!bitmap->isOk()) {
+    delete bitmap;
+    return NULL;
+  }
   bitmap->clearToZero();
 
   //----- MMR decode
@@ -2682,7 +2784,7 @@
     // ---> max refLine size = w + 2
     codingLine = (int *)gmallocn(w + 1, sizeof(int));
     refLine = (int *)gmallocn(w + 2, sizeof(int));
-    codingLine[0] = w;
+    for (i = 0; i < w + 1; ++i) codingLine[i] = w;
 
     for (y = 0; y < h; ++y) {
 
@@ -3093,8 +3195,8 @@
     return;
   }
   if (nRefSegs == 1) {
-    if (!(seg = findSegment(refSegs[0])) ||
-	seg->getType() != jbig2SegBitmap) {
+    seg = findSegment(refSegs[0]);
+    if (seg == NULL || seg->getType() != jbig2SegBitmap) {
       error(getPos(), "Bad bitmap reference in JBIG2 generic refinement segment");
       return;
     }
@@ -3143,11 +3245,24 @@
   JBIG2Bitmap *bitmap;
   GBool ltp;
   Guint ltpCX, cx, cx0, cx2, cx3, cx4, tpgrCX0, tpgrCX1, tpgrCX2;
-  JBIG2BitmapPtr cxPtr0, cxPtr1, cxPtr2, cxPtr3, cxPtr4, cxPtr5, cxPtr6;
-  JBIG2BitmapPtr tpgrCXPtr0, tpgrCXPtr1, tpgrCXPtr2;
+  JBIG2BitmapPtr cxPtr0 = {0};
+  JBIG2BitmapPtr cxPtr1 = {0};
+  JBIG2BitmapPtr cxPtr2 = {0};
+  JBIG2BitmapPtr cxPtr3 = {0};
+  JBIG2BitmapPtr cxPtr4 = {0};
+  JBIG2BitmapPtr cxPtr5 = {0};
+  JBIG2BitmapPtr cxPtr6 = {0};
+  JBIG2BitmapPtr tpgrCXPtr0 = {0};
+  JBIG2BitmapPtr tpgrCXPtr1 = {0};
+  JBIG2BitmapPtr tpgrCXPtr2 = {0};
   int x, y, pix;
 
   bitmap = new JBIG2Bitmap(0, w, h);
+  if (!bitmap->isOk())
+  {
+    delete bitmap;
+    return NULL;
+  }
   bitmap->clearToZero();
 
   // set up the typical row context
@@ -3332,6 +3447,12 @@
   }
   pageBitmap = new JBIG2Bitmap(0, pageW, curPageH);
 
+  if (!pageBitmap->isOk()) {
+    delete pageBitmap;
+    pageBitmap = NULL;
+    return;
+  }
+  
   // default pixel value
   if (pageDefPixel) {
     pageBitmap->clearToOne();
--- xpdf/JPXStream.cc.orig	2010-08-16 14:02:38.000000000 -0700
+++ xpdf/JPXStream.cc	2010-08-16 14:02:38.000000000 -0700
@@ -241,6 +241,12 @@
   haveCompMap = gFalse;
   haveChannelDefn = gFalse;
 
+  img.xSize = 0;
+  img.ySize = 0;
+  img.xOffset = 0;
+  img.yOffset = 0;
+  curX = 0;
+  curY = 0;
   img.tiles = NULL;
   bitBuf = 0;
   bitBufLen = 0;
@@ -450,6 +456,7 @@
   GBool haveBPC, haveCSMode;
 
   csPrec = 0; // make gcc happy
+  Guint num_components = 0;
   haveBPC = haveCSMode = gFalse;
   str->reset();
   if (str->lookChar() == 0xff) {
@@ -463,7 +470,7 @@
 	cover(1);
 	if (readULong(&dummy) &&
 	    readULong(&dummy) &&
-	    readUWord(&dummy) &&
+	    readUWord(&num_components) &&
 	    readUByte(&bpc1) &&
 	    readUByte(&dummy) &&
 	    readUByte(&dummy) &&
@@ -519,6 +526,9 @@
       }
     }
   }
+  if(*csMode == streamCSDeviceRGB && num_components == 4) {
+    *csMode = streamCSDeviceRGBX;
+  }
   str->close();
 }
 
--- xpdf/Lexer.cc.orig	2010-08-16 14:02:38.000000000 -0700
+++ xpdf/Lexer.cc	2010-08-16 14:02:38.000000000 -0700
@@ -74,6 +74,7 @@
     curStr.streamReset();
   }
 }
+static int illegalChars = 0;
 
 Lexer::~Lexer() {
   if (!curStr.isNone()) {
@@ -83,6 +84,9 @@
   if (freeArray) {
     delete streams;
   }
+  if(illegalChars)
+      error(0, "Illegal characters in hex string (%d)", illegalChars);
+  illegalChars = 0;
 }
 
 int Lexer::getChar() {
@@ -330,7 +334,8 @@
 	} else if (c2 >= 'a' && c2 <= 'f') {
 	  c += c2 - 'a' + 10;
 	} else {
-	  error(getPos(), "Illegal digit in hex char in name");
+	  illegalChars++;
+	  //error(getPos(), "Illegal digit in hex char in name");
 	}
       }
      notEscChar:
@@ -384,8 +389,10 @@
 	    c2 += c - 'A' + 10;
 	  else if (c >= 'a' && c <= 'f')
 	    c2 += c - 'a' + 10;
-	  else
-	    error(getPos(), "Illegal character <%02x> in hex string", c);
+	  else {
+	    illegalChars++;
+	    //error(getPos(), "Illegal character <%02x> in hex string", c);
+	  }
 	  if (++m == 2) {
 	    if (n == tokBufSize) {
 	      if (!s)
@@ -421,7 +428,8 @@
       tokBuf[2] = '\0';
       obj->initCmd(tokBuf);
     } else {
-      error(getPos(), "Illegal character '>'");
+      illegalChars++;
+      //error(getPos(), "Illegal character '>'");
       obj->initError();
     }
     break;
@@ -430,7 +438,8 @@
   case ')':
   case '{':
   case '}':
-    error(getPos(), "Illegal character '%c'", c);
+    //error(getPos(), "Illegal character '%c'", c);
+    illegalChars++;
     obj->initError();
     break;
 
@@ -459,7 +468,6 @@
     }
     break;
   }
-
   return obj;
 }
 
--- xpdf/Link.cc.orig	2010-08-16 14:02:38.000000000 -0700
+++ xpdf/Link.cc	2010-08-16 14:02:38.000000000 -0700
@@ -430,10 +430,9 @@
       delete dest;
       dest = NULL;
     }
-
   // error
   } else {
-    error(-1, "Illegal annotation destination");
+    error(-1, "Illegal annotation destination %d", destObj->getType());
   }
 }
 
@@ -468,10 +467,9 @@
       delete dest;
       dest = NULL;
     }
-
   // error
   } else {
-    error(-1, "Illegal annotation destination");
+    error(-1, "Illegal annotation destination %d", destObj->getType());
   }
 }
 
--- xpdf/OutputDev.h.orig	2010-08-16 14:02:38.000000000 -0700
+++ xpdf/OutputDev.h	2010-08-16 14:02:38.000000000 -0700
@@ -17,6 +17,7 @@
 
 #include "gtypes.h"
 #include "CharTypes.h"
+#include "Object.h"
 
 class GString;
 class GfxState;
--- xpdf/SplashFTFont.cc.orig	2010-08-16 14:02:38.000000000 -0700
+++ xpdf/SplashFTFont.cc	2010-08-16 14:02:38.000000000 -0700
@@ -46,6 +46,7 @@
   int x, y;
 
   face = fontFileA->face;
+  
   if (FT_New_Size(face, &sizeObj)) {
     return;
   }
@@ -54,6 +55,10 @@
   if (FT_Set_Pixel_Sizes(face, 0, (int)size)) {
     return;
   }
+ 
+  this->ascender = face->ascender;
+  this->descender = face->descender;
+
   // if the textMat values are too small, FreeType's fixed point
   // arithmetic doesn't work so well
   textScale = splashSqrt(textMat[2]*textMat[2] + textMat[3]*textMat[3]) / size;
@@ -228,6 +233,12 @@
   GBool needClose;
 };
 
+int SplashFTFont::getNumChars()
+{
+  SplashFTFontFile* ff = (SplashFTFontFile *)fontFile;
+  return ff->face->num_glyphs;
+}
+
 SplashPath *SplashFTFont::getGlyphPath(int c) {
   static FT_Outline_Funcs outlineFuncs = {
 #if FREETYPE_MINOR <= 1
@@ -249,6 +260,8 @@
   FT_UInt gid;
   FT_Glyph glyph;
 
+  this->last_advance = -1;
+
   ff = (SplashFTFontFile *)fontFile;
   ff->face->size = sizeObj;
   FT_Set_Transform(ff->face, &textMatrix, NULL);
@@ -262,17 +275,24 @@
     // skip the TrueType notdef glyph
     return NULL;
   }
-  if (FT_Load_Glyph(ff->face, gid, FT_LOAD_NO_BITMAP)) {
+  int error = 0;
+  if ((error=FT_Load_Glyph(ff->face, gid, FT_LOAD_NO_BITMAP|FT_LOAD_NO_HINTING))) {
+      fprintf(stderr, "Truetype wasn't able to load glyph %d, error %d\n", gid, error);
     return NULL;
   }
   if (FT_Get_Glyph(slot, &glyph)) {
     return NULL;
   }
+  this->last_advance = glyph->advance.x/65536.0;
+
   path.path = new SplashPath();
   path.textScale = textScale;
   path.needClose = gFalse;
-  FT_Outline_Decompose(&((FT_OutlineGlyph)glyph)->outline,
+  error = FT_Outline_Decompose(&((FT_OutlineGlyph)glyph)->outline,
 		       &outlineFuncs, &path);
+  if(error) {
+      fprintf(stderr, "Truetype wasn't able to read glyph %d, error %d\n", gid, error);
+  }
   if (path.needClose) {
     path.path->close();
   }
--- xpdf/SplashFTFont.h.orig	2010-08-16 14:02:38.000000000 -0700
+++ xpdf/SplashFTFont.h	2010-08-16 14:02:38.000000000 -0700
@@ -42,6 +42,9 @@
   virtual GBool makeGlyph(int c, int xFrac, int yFrac,
 			  SplashGlyphBitmap *bitmap);
 
+  // return the number of characters in this font
+  virtual int getNumChars();
+
   // Return the path for a glyph.
   virtual SplashPath *getGlyphPath(int c);
 
--- xpdf/SplashFTFontEngine.cc.orig	2010-08-16 14:02:38.000000000 -0700
+++ xpdf/SplashFTFontEngine.cc	2010-08-16 14:02:38.000000000 -0700
@@ -13,9 +13,7 @@
 #endif
 
 #include <stdio.h>
-#ifndef WIN32
 #  include <unistd.h>
-#endif
 #include "gmem.h"
 #include "GString.h"
 #include "gfile.h"
--- xpdf/SplashFont.cc.orig	2010-08-16 14:02:38.000000000 -0700
+++ xpdf/SplashFont.cc	2010-08-16 14:02:38.000000000 -0700
@@ -48,6 +48,10 @@
   cacheTags = NULL;
 
   xMin = yMin = xMax = yMax = 0;
+
+  last_advance = -1;
+  ascender = -1;
+  descender = -1;
 }
 
 void SplashFont::initCache() {
--- xpdf/SplashFont.h.orig	2010-08-16 14:02:38.000000000 -0700
+++ xpdf/SplashFont.h	2010-08-16 14:02:38.000000000 -0700
@@ -73,6 +73,9 @@
   virtual GBool makeGlyph(int c, int xFrac, int yFrac,
 			  SplashGlyphBitmap *bitmap) = 0;
 
+  // return the number of characters in this font
+  virtual int getNumChars() = 0;
+
   // Return the path for a glyph.
   virtual SplashPath *getGlyphPath(int c) = 0;
 
@@ -83,6 +86,9 @@
   void getBBox(int *xMinA, int *yMinA, int *xMaxA, int *yMaxA)
     { *xMinA = xMin; *yMinA = yMin; *xMaxA = xMax; *yMaxA = yMax; }
 
+  double ascender;
+  double descender;
+  double last_advance; //set after getGlyphPath()
 protected:
 
   SplashFontFile *fontFile;
--- xpdf/SplashFontFile.cc.orig	2010-08-16 14:02:38.000000000 -0700
+++ xpdf/SplashFontFile.cc	2010-08-16 14:02:38.000000000 -0700
@@ -11,9 +11,7 @@
 #endif
 
 #include <stdio.h>
-#ifndef WIN32
-#  include <unistd.h>
-#endif
+#include <unistd.h>
 #include "GString.h"
 #include "SplashFontFile.h"
 #include "SplashFontFileID.h"
--- xpdf/SplashOutputDev.cc.orig	2010-08-16 14:02:38.000000000 -0700
+++ xpdf/SplashOutputDev.cc	2010-08-16 14:02:38.000000000 -0700
@@ -13,6 +13,7 @@
 #endif
 
 #include <string.h>
+#include <unistd.h>
 #include <math.h>
 #include "gfile.h"
 #include "GlobalParams.h"
@@ -2646,9 +2647,9 @@
 
   softMask = new SplashBitmap(bitmap->getWidth(), bitmap->getHeight(),
 			      1, splashModeMono8, gFalse);
-  memset(softMask->getDataPtr(), 0,
-	 softMask->getRowSize() * softMask->getHeight());
+  memset(softMask->getDataPtr(), 0x00, softMask->getRowSize()*softMask->getHeight());
   p = softMask->getDataPtr() + ty * softMask->getRowSize() + tx;
+  if (tx<softMask->getWidth() && ty<softMask->getHeight())
   for (y = 0; y < tBitmap->getHeight(); ++y) {
     for (x = 0; x < tBitmap->getWidth(); ++x) {
       tBitmap->getPixel(x, y, color);
--- xpdf/SplashOutputDev.h.orig	2010-08-16 14:02:38.000000000 -0700
+++ xpdf/SplashOutputDev.h	2010-08-16 14:02:38.000000000 -0700
@@ -196,6 +196,9 @@
   virtual void setVectorAntialias(GBool vaa);
 #endif
 
+  void doUpdateFont(GfxState *state);
+  
+  SplashPath *convertPath(GfxState *state, GfxPath *path);
 private:
 
   void setupScreenParams(double hDPI, double vDPI);
@@ -204,8 +207,6 @@
 #else
   SplashPattern *getColor(GfxGray gray, GfxRGB *rgb);
 #endif
-  SplashPath *convertPath(GfxState *state, GfxPath *path);
-  void doUpdateFont(GfxState *state);
   void drawType3Glyph(T3FontCache *t3Font,
 		      T3FontCacheTag *tag, Guchar *data);
   static GBool imageMaskSrc(void *data, SplashColorPtr line);
--- xpdf/SplashScreen.cc.orig	2010-08-16 14:02:38.000000000 -0700
+++ xpdf/SplashScreen.cc	2010-08-16 14:02:38.000000000 -0700
@@ -363,6 +363,8 @@
 int SplashScreen::test(int x, int y, Guchar value) {
   int xx, yy;
 
+  return 1;
+
   if (value < minVal) {
     return 0;
   }
--- xpdf/SplashXPathScanner.cc.orig	2010-08-16 14:02:38.000000000 -0700
+++ xpdf/SplashXPathScanner.cc	2010-08-16 14:02:38.000000000 -0700
@@ -394,10 +394,10 @@
 	  *p++ &= mask;
 	  xx = (xx & ~7) + 8;
 	}
-	for (; xx + 7 <= xx0; xx += 8) {
+	for (; xx + 7 < xx0; xx += 8) {
 	  *p++ = 0x00;
 	}
-	if (xx <= xx0) {
+	if (xx < xx0) {
 	  *p &= 0xff >> (xx0 & 7);
 	}
       }
@@ -417,10 +417,10 @@
 	*p++ &= mask;
 	xx = (xx & ~7) + 8;
       }
-      for (; xx + 7 <= xx0; xx += 8) {
+      for (; xx + 7 < xx0; xx += 8) {
 	*p++ = 0x00;
       }
-      if (xx <= xx0) {
+      if (xx < xx0) {
 	*p &= 0xff >> (xx0 & 7);
       }
     }
--- xpdf/Stream.cc.orig	2010-08-16 14:02:38.000000000 -0700
+++ xpdf/Stream.cc	2010-08-16 14:02:38.000000000 -0700
@@ -18,6 +18,8 @@
 #include <limits.h>
 #ifndef WIN32
 #include <unistd.h>
+#else
+extern "C" int unlink(char *filename);
 #endif
 #include <string.h>
 #include <ctype.h>
@@ -2456,6 +2458,9 @@
   // check for an EOB run
   if (eobRun > 0) {
     while (i <= scanInfo.lastCoeff) {
+      if(i>=64) {
+	  return gFalse;
+      }
       j = dctZigZag[i++];
       if (data[j] != 0) {
 	if ((bit = readBit()) == EOF) {
@@ -2480,6 +2485,9 @@
     if (c == 0xf0) {
       k = 0;
       while (k < 16) {
+        if(i>=64) {
+	  return gFalse;
+	}
 	j = dctZigZag[i++];
 	if (data[j] == 0) {
 	  ++k;
@@ -2505,6 +2513,9 @@
       }
       eobRun += 1 << j;
       while (i <= scanInfo.lastCoeff) {
+	if(i>=64) {
+	  return gFalse;
+	}
 	j = dctZigZag[i++];
 	if (data[j] != 0) {
 	  if ((bit = readBit()) == EOF) {
@@ -2527,6 +2538,9 @@
       }
       k = 0;
       do {
+	if(i>=64) {
+	  return gFalse;
+	}
 	j = dctZigZag[i++];
 	while (data[j] != 0) {
 	  if ((bit = readBit()) == EOF) {
@@ -2535,6 +2549,9 @@
 	  if (bit) {
 	    data[j] += 1 << scanInfo.al;
 	  }
+	  if(i>=64) {
+	    return gFalse;
+	  }
 	  j = dctZigZag[i++];
 	}
 	++k;
--- xpdf/Stream.h.orig	2010-08-16 14:02:38.000000000 -0700
+++ xpdf/Stream.h	2010-08-16 14:02:38.000000000 -0700
@@ -41,7 +41,8 @@
   streamCSNone,
   streamCSDeviceGray,
   streamCSDeviceRGB,
-  streamCSDeviceCMYK
+  streamCSDeviceCMYK,
+  streamCSDeviceRGBX
 };
 
 //------------------------------------------------------------------------
--- xpdf/TextOutputDev.h.orig	2010-08-16 14:02:38.000000000 -0700
+++ xpdf/TextOutputDev.h	2010-08-16 14:02:38.000000000 -0700
@@ -170,6 +170,7 @@
   friend class TextFlow;
   friend class TextWordList;
   friend class TextPage;
+  friend class XMLOutputDev;
 };
 
 //------------------------------------------------------------------------
--- xpdf/gfile.cc.orig	2010-08-16 14:02:38.000000000 -0700
+++ xpdf/gfile.cc	2010-08-16 14:02:38.000000000 -0700
@@ -439,6 +439,52 @@
 #endif
 }
 
+static char* getTempDir()
+{
+#ifdef WIN32
+    char*dir = getenv("TMP");
+    if(!dir) dir = getenv("TEMP");
+    if(!dir) dir = getenv("tmp");
+    if(!dir) dir = getenv("temp");
+    if(!dir) dir = "C:\\";
+#else
+    char* dir = "/tmp/";
+#endif
+    return dir;
+}
+
+char* mktmpname(char*ptr) {
+    static char tmpbuf[128];
+    char*dir = getTempDir();
+    int l = strlen(dir);
+    char*sep = "";
+    if(!ptr)
+	ptr = tmpbuf;
+    if(l && dir[l-1]!='/' && dir[l-1]!='\\') {
+#ifdef WIN32
+	sep = "\\";
+#else
+	sep = "/";
+#endif
+    }
+
+ //   used to be mktemp. This does remove the warnings, but
+ //   It's not exactly an improvement.
+#ifdef HAVE_LRAND48
+    sprintf(ptr, "%s%s%08x%08x",dir,sep,(unsigned int)lrand48(),(unsigned int)lrand48());
+#else
+#   ifdef HAVE_RAND
+	sprintf(ptr, "%s%s%08x%08x",dir,sep,rand(),rand());
+#   else
+	static int count = 1;
+	sprintf(ptr, "%s%s%08x%04x%04x",dir,sep,time(0),(unsigned int)tmpbuf^((unsigned int)tmpbuf)>>16,count);
+	count ++;
+#   endif
+#endif
+     return ptr;
+}
+
+
 GBool openTempFile(GString **name, FILE **f, char *mode, char *ext) {
 #if defined(WIN32)
   //---------- Win32 ----------
@@ -460,7 +506,7 @@
   s->append("x");
   t = (int)time(NULL);
   for (i = 0; i < 1000; ++i) {
-    sprintf(buf, "%d", t + i);
+    sprintf(buf, "%08x-%08x", t + i, GetCurrentThreadId());
     s2 = s->copy()->append(buf);
     if (ext) {
       s2->append(ext);
@@ -468,8 +514,7 @@
     if (!(f2 = fopen(s2->getCString(), "r"))) {
       if (!(f2 = fopen(s2->getCString(), mode))) {
 	delete s2;
-	delete s;
-	return gFalse;
+        continue;
       }
       *name = s2;
       *f = f2;
@@ -479,6 +524,7 @@
     fclose(f2);
     delete s2;
   }
+  fprintf(stderr, "Couldn't create temporary file\n");
   delete s;
   return gFalse;
 #elif defined(VMS) || defined(__EMX__) || defined(ACORN) || defined(MACOS)
@@ -489,7 +535,7 @@
   // with this file name after the tmpnam call and before the fopen
   // call.  I will happily accept fixes to this function for non-Unix
   // OSs.
-  if (!(s = tmpnam(NULL))) {
+  if (!(s = mktmpname(NULL))) {
     return gFalse;
   }
   *name = new GString(s);
@@ -516,7 +562,7 @@
     (*name)->append("/XXXXXX")->append(ext);
     fd = mkstemps((*name)->getCString(), strlen(ext));
 #else
-    if (!(s = tmpnam(NULL))) {
+    if (!(s = mktmpname(NULL))) {
       return gFalse;
     }
     *name = new GString(s);
@@ -533,7 +579,7 @@
     (*name)->append("/XXXXXX");
     fd = mkstemp((*name)->getCString());
 #else // HAVE_MKSTEMP
-    if (!(s = tmpnam(NULL))) {
+    if (!(s = mktmpname(NULL))) {
       return gFalse;
     }
     *name = new GString(s);
--- xpdf/gfile.h.orig	2010-08-16 14:02:38.000000000 -0700
+++ xpdf/gfile.h	2010-08-16 14:02:38.000000000 -0700
@@ -58,6 +58,9 @@
 // Get current directory.
 extern GString *getCurrentDir();
 
+/* create a temporary filename */
+char* mktmpname(char*ptr);
+
 // 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);