Attachment 6796 Details for Bug 8111 – Speedup as described in the bug

[patch] Speedup as described in the bug

speedup.txt (text/plain), 66.13 KB, created by Krzysztof Kowalczyk on 2006-09-02 17:05:46 UTC

(hide)

Description:

Filename:

MIME Type:

Creator: Krzysztof Kowalczyk

Created: 2006-09-02 17:05:46 UTC

Size: 66.13 KB

patch

obsolete

>Index: poppler/Object.cc
>===================================================================
>--- poppler/Object.cc	(revision 52)
>+++ poppler/Object.cc	(working copy)
>@@ -175,7 +175,7 @@
>     fprintf(f, "[");
>     for (i = 0; i < arrayGetLength(); ++i) {
>       if (i > 0)
>-	fprintf(f, " ");
>+        fprintf(f, " ");
>       arrayGetNF(i, &obj);
>       obj.print(f);
>       obj.free();
>@@ -225,7 +225,7 @@
>     fprintf(f, "Allocated objects:\n");
>     for (i = 0; i < numObjTypes; ++i) {
>       if (numAlloc[i] > 0)
>-	fprintf(f, "  %-20s: %6d\n", objTypeNames[i], numAlloc[i]);
>+        fprintf(f, "  %-20s: %6d\n", objTypeNames[i], numAlloc[i]);
>     }
>   }
> #endif
>Index: poppler/UGooString.h
>===================================================================
>--- poppler/UGooString.h	(revision 52)
>+++ poppler/UGooString.h	(working copy)
>@@ -47,6 +47,7 @@
>   // Compare two strings:  -1:<  0:=  +1:>
>   int cmp(const UGooString *str) const;
>   int cmp(const UGooString &str) const;
>+  int cmp(const char *str, int strLen = CALC_STRING_LEN) const;
> 
>   // get the unicode
>   Unicode *unicode() const { return s; }
>@@ -55,15 +56,16 @@
>   // ascii (non-Unicode) format. Caller has to delete [] the result
>   char *getCString() const;
> 
>+  // a special value telling that the length of the string is not given
>+  // so it must be calculated from the strings
>+  static const int CALC_STRING_LEN = -1;
>+
> private:
>   // you can tweak this number for a different speed/memory usage tradeoffs.
>   // In libc malloc() rounding is 16 so it's best to choose a value that
>   // results in sizeof(UGooString) be a multiple of 16.
>   // 20 makes sizeof(UGooString) to be 48.
>   static const int STR_STATIC_SIZE = 20;
>-  // a special value telling that the length of the string is not given
>-  // so it must be calculated from the strings
>-  static const int CALC_STRING_LEN = -1;
> 
>   int  roundedSize(int len);
>   void initChar(const char *str, int strLen);
>Index: poppler/XRef.h
>===================================================================
>--- poppler/XRef.h	(revision 52)
>+++ poppler/XRef.h	(working copy)
>@@ -54,8 +54,8 @@
> 
>   // Set the encryption parameters.
>   void setEncryption(int permFlagsA, GBool ownerPasswordOkA,
>-		     Guchar *fileKeyA, int keyLengthA,
>-		     int encVersionA, int encRevisionA);
>+                     Guchar *fileKeyA, int keyLengthA,
>+                     int encVersionA, int encRevisionA);
> 
>   // Is the file encrypted?
>   GBool isEncrypted() { return encrypted; }
>@@ -106,7 +106,7 @@
> 
>   BaseStream *str;		// input stream
>   Guint start;			// offset in file (to allow for garbage
>-				//   at beginning of file)
>+                                //   at beginning of file)
>   XRefEntry *entries;		// xref entries
>   int size;			// size of <entries> array
>   int rootNum, rootGen;		// catalog dict
>@@ -115,7 +115,7 @@
>   Object trailerDict;		// trailer dictionary
>   Guint lastXRefPos;		// offset of last xref table
>   Guint *streamEnds;		// 'endstream' positions - only used in
>-				//   damaged files
>+                                //   damaged files
>   int streamEndsLen;		// number of valid entries in streamEnds
>   ObjectStream *objStr;		// cached object stream
>   GBool encrypted;		// true if file is encrypted
>Index: poppler/Object.h
>===================================================================
>--- poppler/Object.h	(revision 52)
>+++ poppler/Object.h	(working copy)
>@@ -18,12 +18,12 @@
> #include "goo/gtypes.h"
> #include "goo/gmem.h"
> #include "goo/GooString.h"
>+#include "UGooString.h"
> 
> class XRef;
> class Array;
> class Dict;
> class Stream;
>-class UGooString;
> 
> //------------------------------------------------------------------------
> // Ref
>@@ -168,6 +168,13 @@
>   GBool dictIs(char *dictType);
>   Object *dictLookup(const UGooString &key, Object *obj);
>   Object *dictLookupNF(const UGooString &key, Object *obj);
>+  Object *dictLookupRefNoFetch(const UGooString &key);
>+  Object *dictLookup(const char *key, Object *obj, int keyLen=UGooString::CALC_STRING_LEN);
>+  Object *dictLookupNF(const char *key, Object *obj, int keyLen=UGooString::CALC_STRING_LEN);
>+  Object *dictLookupRefNoFetch(const char *key, int keyLen=UGooString::CALC_STRING_LEN);
>+  GBool dictLookupBool(const char *key, const char *alt_key, GBool *value);
>+  GBool dictLookupInt(const char *key, const char *alt_key, int *value);
>+
>   UGooString *dictGetKey(int i);
>   Object *dictGetVal(int i, Object *obj);
>   Object *dictGetValNF(int i, Object *obj);
>@@ -251,9 +258,27 @@
> inline Object *Object::dictLookup(const UGooString &key, Object *obj)
>   { return dict->lookup(key, obj); }
> 
>+inline Object *Object::dictLookup(const char *key, Object *obj, int keyLen)
>+  { return dict->lookup(key, obj, keyLen); }
>+
> inline Object *Object::dictLookupNF(const UGooString &key, Object *obj)
>   { return dict->lookupNF(key, obj); }
> 
>+inline Object *Object::dictLookupNF(const char *key, Object *obj, int keyLen)
>+  { return dict->lookupNF(key, obj, keyLen); }
>+
>+inline Object *Object::dictLookupRefNoFetch(const UGooString &key)
>+  { return dict->lookupRefNoFetch(key); }
>+
>+inline Object *Object::dictLookupRefNoFetch(const char *key, int keyLen)
>+  { return dict->lookupRefNoFetch(key, keyLen); }
>+
>+inline GBool Object::dictLookupBool(const char *key, const char *alt_key, GBool *value)
>+  { return dict->lookupBool(key, alt_key, value); }
>+
>+inline GBool Object::dictLookupInt(const char *key, const char *alt_key, int *value)
>+  { return dict->lookupInt(key, alt_key, value); }
>+
> inline UGooString *Object::dictGetKey(int i)
>   { return dict->getKey(i); }
> 
>Index: poppler/Stream.cc
>===================================================================
>--- poppler/Stream.cc	(revision 52)
>+++ poppler/Stream.cc	(working copy)
>@@ -86,7 +86,7 @@
>       break;
>     if (c == '\r') {
>       if ((c = lookChar()) == '\n')
>-	getChar();
>+        getChar();
>       break;
>     }
>     buf[i] = c;
>@@ -122,14 +122,14 @@
>     for (i = 0; i < obj.arrayGetLength(); ++i) {
>       obj.arrayGet(i, &obj2);
>       if (params.isArray())
>-	params.arrayGet(i, &params2);
>+        params.arrayGet(i, &params2);
>       else
>-	params2.initNull();
>+        params2.initNull();
>       if (obj2.isName()) {
>-	str = makeFilter(obj2.getName(), str, &params2);
>+        str = makeFilter(obj2.getName(), str, &params2);
>       } else {
>-	error(getPos(), "Bad filter name");
>-	str = new EOFStream(str);
>+        error(getPos(), "Bad filter name");
>+        str = new EOFStream(str);
>       }
>       obj2.free();
>       params2.free();
>@@ -164,26 +164,11 @@
>     bits = 8;
>     early = 1;
>     if (params->isDict()) {
>-      params->dictLookup("Predictor", &obj);
>-      if (obj.isInt())
>-	pred = obj.getInt();
>-      obj.free();
>-      params->dictLookup("Columns", &obj);
>-      if (obj.isInt())
>-	columns = obj.getInt();
>-      obj.free();
>-      params->dictLookup("Colors", &obj);
>-      if (obj.isInt())
>-	colors = obj.getInt();
>-      obj.free();
>-      params->dictLookup("BitsPerComponent", &obj);
>-      if (obj.isInt())
>-	bits = obj.getInt();
>-      obj.free();
>-      params->dictLookup("EarlyChange", &obj);
>-      if (obj.isInt())
>-	early = obj.getInt();
>-      obj.free();
>+      params->dictLookupInt("Predictor", NULL, &pred);
>+      params->dictLookupInt("Columns", NULL, &columns);
>+      params->dictLookupInt("Colors", NULL, &colors);
>+      params->dictLookupInt("BitsPerComponent", NULL, &bits);
>+      params->dictLookupInt("EarlyChange", NULL, &early);
>     }
>     str = new LZWStream(str, pred, columns, colors, bits, early);
>   } else if (!strcmp(name, "RunLengthDecode") || !strcmp(name, "RL")) {
>@@ -197,44 +182,16 @@
>     endOfBlock = gTrue;
>     black = gFalse;
>     if (params->isDict()) {
>-      params->dictLookup("K", &obj);
>-      if (obj.isInt()) {
>-	encoding = obj.getInt();
>-      }
>-      obj.free();
>-      params->dictLookup("EndOfLine", &obj);
>-      if (obj.isBool()) {
>-	endOfLine = obj.getBool();
>-      }
>-      obj.free();
>-      params->dictLookup("EncodedByteAlign", &obj);
>-      if (obj.isBool()) {
>-	byteAlign = obj.getBool();
>-      }
>-      obj.free();
>-      params->dictLookup("Columns", &obj);
>-      if (obj.isInt()) {
>-	columns = obj.getInt();
>-      }
>-      obj.free();
>-      params->dictLookup("Rows", &obj);
>-      if (obj.isInt()) {
>-	rows = obj.getInt();
>-      }
>-      obj.free();
>-      params->dictLookup("EndOfBlock", &obj);
>-      if (obj.isBool()) {
>-	endOfBlock = obj.getBool();
>-      }
>-      obj.free();
>-      params->dictLookup("BlackIs1", &obj);
>-      if (obj.isBool()) {
>-	black = obj.getBool();
>-      }
>-      obj.free();
>+      params->dictLookupInt("K", NULL, &encoding);
>+      params->dictLookupBool("EndOfLine", NULL, &endOfLine);
>+      params->dictLookupBool("EncodedByteAlign", NULL, &byteAlign);
>+      params->dictLookupInt("Columns", NULL, &columns);
>+      params->dictLookupInt("Rows", NULL, &rows);
>+      params->dictLookupBool("EndOfBlock", NULL, &endOfBlock);
>+      params->dictLookupBool("BlackIs1", NULL, &black);
>     }
>     str = new CCITTFaxStream(str, encoding, endOfLine, byteAlign,
>-			     columns, rows, endOfBlock, black);
>+                             columns, rows, endOfBlock, black);
>   } else if (!strcmp(name, "DCTDecode") || !strcmp(name, "DCT")) {
>     str = new DCTStream(str);
>   } else if (!strcmp(name, "FlateDecode") || !strcmp(name, "Fl")) {
>@@ -243,22 +200,10 @@
>     colors = 1;
>     bits = 8;
>     if (params->isDict()) {
>-      params->dictLookup("Predictor", &obj);
>-      if (obj.isInt())
>-	pred = obj.getInt();
>-      obj.free();
>-      params->dictLookup("Columns", &obj);
>-      if (obj.isInt())
>-	columns = obj.getInt();
>-      obj.free();
>-      params->dictLookup("Colors", &obj);
>-      if (obj.isInt())
>-	colors = obj.getInt();
>-      obj.free();
>-      params->dictLookup("BitsPerComponent", &obj);
>-      if (obj.isInt())
>-	bits = obj.getInt();
>-      obj.free();
>+      params->dictLookupInt("Predictor", NULL, &pred);
>+      params->dictLookupInt("Columns", NULL, &columns);
>+      params->dictLookupInt("Colors", NULL, &colors);
>+      params->dictLookupInt("BitsPerComponent", NULL, &bits);
>     }
>     str = new FlateStream(str, pred, columns, colors, bits);
>   } else if (!strcmp(name, "JBIG2Decode")) {
>@@ -292,7 +237,7 @@
> }
> 
> void BaseStream::doDecryption(Guchar *fileKey, int keyLength,
>-			      int objNum, int objGen) {
>+                              int objNum, int objGen) {
>   decrypt = new Decrypt(fileKey, keyLength, objNum, objGen);
> }
> 
>@@ -386,8 +331,8 @@
>     bits = 0;
>     for (i = 0; i < nVals; ++i) {
>       if (bits < nBits) {
>-	buf = (buf << 8) | (str->getChar() & 0xff);
>-	bits += 8;
>+        buf = (buf << 8) | (str->getChar() & 0xff);
>+        bits += 8;
>       }
>       imgLine[i] = (Guchar)((buf >> (bits - nBits)) & bitMask);
>       bits -= nBits;
>@@ -410,7 +355,7 @@
> //------------------------------------------------------------------------
> 
> StreamPredictor::StreamPredictor(Stream *strA, int predictorA,
>-				 int widthA, int nCompsA, int nBitsA) {
>+                                 int widthA, int nCompsA, int nBitsA) {
>   int totalBits;
> 
>   str = strA;
>@@ -496,10 +441,10 @@
>     upLeftBuf[0] = predLine[i];
>     if ((c = str->getRawChar()) == EOF) {
>       if (i > pixBytes) {
>-	// this ought to return false, but some (broken) PDF files
>-	// contain truncated image data, and Adobe apparently reads the
>-	// last partial line
>-	break;
>+        // this ought to return false, but some (broken) PDF files
>+        // contain truncated image data, and Adobe apparently reads the
>+        // last partial line
>+        break;
>       }
>       return gFalse;
>     }
>@@ -512,7 +457,7 @@
>       break;
>     case 13:			// PNG average
>       predLine[i] = ((predLine[i - pixBytes] + predLine[i]) >> 1) +
>-	            (Guchar)c;
>+                    (Guchar)c;
>       break;
>     case 14:			// PNG Paeth
>       left = predLine[i - pixBytes];
>@@ -520,17 +465,17 @@
>       upLeft = upLeftBuf[pixBytes];
>       p = left + up - upLeft;
>       if ((pa = p - left) < 0)
>-	pa = -pa;
>+        pa = -pa;
>       if ((pb = p - up) < 0)
>-	pb = -pb;
>+        pb = -pb;
>       if ((pc = p - upLeft) < 0)
>-	pc = -pc;
>+        pc = -pc;
>       if (pa <= pb && pa <= pc)
>-	predLine[i] = left + (Guchar)c;
>+        predLine[i] = left + (Guchar)c;
>       else if (pb <= pc)
>-	predLine[i] = up + (Guchar)c;
>+        predLine[i] = up + (Guchar)c;
>       else
>-	predLine[i] = upLeft + (Guchar)c;
>+        predLine[i] = upLeft + (Guchar)c;
>       break;
>     case 10:			// PNG none
>     default:			// no predictor or TIFF predictor
>@@ -544,13 +489,13 @@
>     if (nBits == 1) {
>       inBuf = predLine[pixBytes - 1];
>       for (i = pixBytes; i < rowBytes; i += 8) {
>-	// 1-bit add is just xor
>-	inBuf = (inBuf << 8) | predLine[i];
>-	predLine[i] ^= inBuf >> nComps;
>+        // 1-bit add is just xor
>+        inBuf = (inBuf << 8) | predLine[i];
>+        predLine[i] ^= inBuf >> nComps;
>       }
>     } else if (nBits == 8) {
>       for (i = pixBytes; i < rowBytes; ++i) {
>-	predLine[i] += predLine[i - nComps];
>+        predLine[i] += predLine[i - nComps];
>       }
>     } else {
>       memset(upLeftBuf, 0, nComps + 1);
>@@ -559,25 +504,25 @@
>       inBits = outBits = 0;
>       j = k = pixBytes;
>       for (i = 0; i < width; ++i) {
>-	for (kk = 0; kk < nComps; ++kk) {
>-	if (inBits < nBits) {
>-	  inBuf = (inBuf << 8) | (predLine[j++] & 0xff);
>-	  inBits += 8;
>-	}
>-	  upLeftBuf[kk] = (upLeftBuf[kk] +
>-			(inBuf >> (inBits - nBits))) & bitMask;
>-	inBits -= nBits;
>-	  outBuf = (outBuf << nBits) | upLeftBuf[kk];
>-	outBits += nBits;
>-	  if (outBits >= 8) {
>-	  predLine[k++] = (Guchar)(outBuf >> (outBits - 8));
>-	    outBits -= 8;
>-	  }
>-	}
>+        for (kk = 0; kk < nComps; ++kk) {
>+        if (inBits < nBits) {
>+          inBuf = (inBuf << 8) | (predLine[j++] & 0xff);
>+          inBits += 8;
>+        }
>+          upLeftBuf[kk] = (upLeftBuf[kk] +
>+                        (inBuf >> (inBits - nBits))) & bitMask;
>+        inBits -= nBits;
>+          outBuf = (outBuf << nBits) | upLeftBuf[kk];
>+        outBits += nBits;
>+          if (outBits >= 8) {
>+          predLine[k++] = (Guchar)(outBuf >> (outBits - 8));
>+            outBits -= 8;
>+          }
>+        }
>       }
>       if (outBits > 0) {
>-	predLine[k++] = (Guchar)((outBuf << (8 - outBits)) +
>-				 (inBuf & ((1 << (8 - outBits)) - 1)));
>+        predLine[k++] = (Guchar)((outBuf << (8 - outBits)) +
>+                                 (inBuf & ((1 << (8 - outBits)) - 1)));
>       }
>     }
>   }
>@@ -593,7 +538,7 @@
> //------------------------------------------------------------------------
> 
> FileStream::FileStream(FILE *fA, Guint startA, GBool limitedA,
>-		       Guint lengthA, Object *dictA):
>+                       Guint lengthA, Object *dictA):
>     BaseStream(dictA) {
>   f = fA;
>   start = startA;
>@@ -610,7 +555,7 @@
> }
> 
> Stream *FileStream::makeSubStream(Guint startA, GBool limitedA,
>-				  Guint lengthA, Object *dictA) {
>+                                  Guint lengthA, Object *dictA) {
>   return new FileStream(f, startA, limitedA, lengthA, dictA);
> }
> 
>@@ -742,7 +687,7 @@
> }
> 
> Stream *MemStream::makeSubStream(Guint startA, GBool limited,
>-				 Guint lengthA, Object *dictA) {
>+                                 Guint lengthA, Object *dictA) {
>   MemStream *subStr;
>   Guint newLength;
> 
>@@ -788,7 +733,7 @@
> }
> 
> void MemStream::doDecryption(Guchar *fileKey, int keyLength,
>-			     int objNum, int objGen) {
>+                             int objNum, int objGen) {
>   char *newBuf;
>   char *p, *q;
> 
>@@ -811,7 +756,7 @@
> //------------------------------------------------------------------------
> 
> EmbedStream::EmbedStream(Stream *strA, Object *dictA,
>-			 GBool limitedA, Guint lengthA):
>+                         GBool limitedA, Guint lengthA):
>     BaseStream(dictA) {
>   str = strA;
>   limited = limitedA;
>@@ -822,7 +767,7 @@
> }
> 
> Stream *EmbedStream::makeSubStream(Guint start, GBool limitedA,
>-				   Guint lengthA, Object *dictA) {
>+                                   Guint lengthA, Object *dictA) {
>   error(-1, "Internal: called makeSubStream() on EmbedStream");
>   return NULL;
> }
>@@ -985,24 +930,24 @@
>       n = 4;
>     } else {
>       for (k = 1; k < 5; ++k) {
>-	do {
>-	  c[k] = str->getChar();
>-	} while (Lexer::isSpace(c[k]));
>-	if (c[k] == '~' || c[k] == EOF)
>-	  break;
>+        do {
>+          c[k] = str->getChar();
>+        } while (Lexer::isSpace(c[k]));
>+        if (c[k] == '~' || c[k] == EOF)
>+          break;
>       }
>       n = k - 1;
>       if (k < 5 && (c[k] == '~' || c[k] == EOF)) {
>-	for (++k; k < 5; ++k)
>-	  c[k] = 0x21 + 84;
>-	eof = gTrue;
>+        for (++k; k < 5; ++k)
>+          c[k] = 0x21 + 84;
>+        eof = gTrue;
>       }
>       t = 0;
>       for (k = 0; k < 5; ++k)
>-	t = t * 85 + (c[k] - 0x21);
>+        t = t * 85 + (c[k] - 0x21);
>       for (k = 3; k >= 0; --k) {
>-	b[k] = (int)(t & 0xff);
>-	t >>= 8;
>+        b[k] = (int)(t & 0xff);
>+        t >>= 8;
>       }
>     }
>   }
>@@ -1031,7 +976,7 @@
> //------------------------------------------------------------------------
> 
> LZWStream::LZWStream(Stream *strA, int predictor, int columns, int colors,
>-		     int bits, int earlyA):
>+                     int bits, int earlyA):
>     FilterStream(strA) {
>   if (predictor != 1) {
>     pred = new StreamPredictor(this, predictor, columns, colors, bits);
>@@ -1284,8 +1229,8 @@
> //------------------------------------------------------------------------
> 
> CCITTFaxStream::CCITTFaxStream(Stream *strA, int encodingA, GBool endOfLineA,
>-			       GBool byteAlignA, int columnsA, int rowsA,
>-			       GBool endOfBlockA, GBool blackA):
>+                               GBool byteAlignA, int columnsA, int rowsA,
>+                               GBool endOfBlockA, GBool blackA):
>     FilterStream(strA) {
>   encoding = encodingA;
>   endOfLine = endOfLineA;
>@@ -1363,133 +1308,133 @@
>     // 2-D encoding
>     if (nextLine2D) {
>       for (i = 0; codingLine[i] < columns; ++i)
>-	refLine[i] = codingLine[i];
>+        refLine[i] = codingLine[i];
>       refLine[i] = refLine[i + 1] = columns;
>       b1 = 1;
>       a0New = codingLine[a0 = 0] = 0;
>       do {
>-	code1 = getTwoDimCode();
>-	switch (code1) {
>-	case twoDimPass:
>-	  if (refLine[b1] < columns) {
>-	    a0New = refLine[b1 + 1];
>-	    b1 += 2;
>-	  }
>-	  break;
>-	case twoDimHoriz:
>-	  if ((a0 & 1) == 0) {
>-	    code1 = code2 = 0;
>-	    do {
>-	      code1 += code3 = getWhiteCode();
>-	    } while (code3 >= 64);
>-	    do {
>-	      code2 += code3 = getBlackCode();
>-	    } while (code3 >= 64);
>-	  } else {
>-	    code1 = code2 = 0;
>-	    do {
>-	      code1 += code3 = getBlackCode();
>-	    } while (code3 >= 64);
>-	    do {
>-	      code2 += code3 = getWhiteCode();
>-	    } while (code3 >= 64);
>-	  }
>-	  if (code1 > 0 || code2 > 0) {
>-	    codingLine[a0 + 1] = a0New + code1;
>-	    ++a0;
>-	    a0New = codingLine[a0 + 1] = codingLine[a0] + code2;
>-	    ++a0;
>-	    while (refLine[b1] <= codingLine[a0] && refLine[b1] < columns)
>-	      b1 += 2;
>-	  }
>-	  break;
>-	case twoDimVert0:
>-	  a0New = codingLine[++a0] = refLine[b1];
>-	  if (refLine[b1] < columns) {
>-	    ++b1;
>-	    while (refLine[b1] <= codingLine[a0] && refLine[b1] < columns)
>-	      b1 += 2;
>-	  }
>-	  break;
>-	case twoDimVertR1:
>-	  a0New = codingLine[++a0] = refLine[b1] + 1;
>-	  if (refLine[b1] < columns) {
>-	    ++b1;
>-	    while (refLine[b1] <= codingLine[a0] && refLine[b1] < columns)
>-	      b1 += 2;
>-	  }
>-	  break;
>-	case twoDimVertL1:
>-	  if (a0 == 0 || refLine[b1] - 1 > a0New) {
>-	  a0New = codingLine[++a0] = refLine[b1] - 1;
>-	  --b1;
>-	  while (refLine[b1] <= codingLine[a0] && refLine[b1] < columns)
>-	    b1 += 2;
>-	  }
>-	  break;
>-	case twoDimVertR2:
>-	  a0New = codingLine[++a0] = refLine[b1] + 2;
>-	  if (refLine[b1] < columns) {
>-	    ++b1;
>-	    while (refLine[b1] <= codingLine[a0] && refLine[b1] < columns)
>-	      b1 += 2;
>-	  }
>-	  break;
>-	case twoDimVertL2:
>-	  if (a0 == 0 || refLine[b1] - 2 > a0New) {
>-	  a0New = codingLine[++a0] = refLine[b1] - 2;
>-	  --b1;
>-	  while (refLine[b1] <= codingLine[a0] && refLine[b1] < columns)
>-	    b1 += 2;
>-	  }
>-	  break;
>-	case twoDimVertR3:
>-	  a0New = codingLine[++a0] = refLine[b1] + 3;
>-	  if (refLine[b1] < columns) {
>-	    ++b1;
>-	    while (refLine[b1] <= codingLine[a0] && refLine[b1] < columns)
>-	      b1 += 2;
>-	  }
>-	  break;
>-	case twoDimVertL3:
>-	  if (a0 == 0 || refLine[b1] - 3 > a0New) {
>-	  a0New = codingLine[++a0] = refLine[b1] - 3;
>-	  --b1;
>-	  while (refLine[b1] <= codingLine[a0] && refLine[b1] < columns)
>-	    b1 += 2;
>-	  }
>-	  break;
>-	case EOF:
>-	  eof = gTrue;
>-	  codingLine[a0 = 0] = columns;
>-	  return EOF;
>-	default:
>-	  error(getPos(), "Bad 2D code %04x in CCITTFax stream", code1);
>-	  err = gTrue;
>-	  break;
>-	}
>+        code1 = getTwoDimCode();
>+        switch (code1) {
>+        case twoDimPass:
>+          if (refLine[b1] < columns) {
>+            a0New = refLine[b1 + 1];
>+            b1 += 2;
>+          }
>+          break;
>+        case twoDimHoriz:
>+          if ((a0 & 1) == 0) {
>+            code1 = code2 = 0;
>+            do {
>+              code1 += code3 = getWhiteCode();
>+            } while (code3 >= 64);
>+            do {
>+              code2 += code3 = getBlackCode();
>+            } while (code3 >= 64);
>+          } else {
>+            code1 = code2 = 0;
>+            do {
>+              code1 += code3 = getBlackCode();
>+            } while (code3 >= 64);
>+            do {
>+              code2 += code3 = getWhiteCode();
>+            } while (code3 >= 64);
>+          }
>+          if (code1 > 0 || code2 > 0) {
>+            codingLine[a0 + 1] = a0New + code1;
>+            ++a0;
>+            a0New = codingLine[a0 + 1] = codingLine[a0] + code2;
>+            ++a0;
>+            while (refLine[b1] <= codingLine[a0] && refLine[b1] < columns)
>+              b1 += 2;
>+          }
>+          break;
>+        case twoDimVert0:
>+          a0New = codingLine[++a0] = refLine[b1];
>+          if (refLine[b1] < columns) {
>+            ++b1;
>+            while (refLine[b1] <= codingLine[a0] && refLine[b1] < columns)
>+              b1 += 2;
>+          }
>+          break;
>+        case twoDimVertR1:
>+          a0New = codingLine[++a0] = refLine[b1] + 1;
>+          if (refLine[b1] < columns) {
>+            ++b1;
>+            while (refLine[b1] <= codingLine[a0] && refLine[b1] < columns)
>+              b1 += 2;
>+          }
>+          break;
>+        case twoDimVertL1:
>+          if (a0 == 0 || refLine[b1] - 1 > a0New) {
>+          a0New = codingLine[++a0] = refLine[b1] - 1;
>+          --b1;
>+          while (refLine[b1] <= codingLine[a0] && refLine[b1] < columns)
>+            b1 += 2;
>+          }
>+          break;
>+        case twoDimVertR2:
>+          a0New = codingLine[++a0] = refLine[b1] + 2;
>+          if (refLine[b1] < columns) {
>+            ++b1;
>+            while (refLine[b1] <= codingLine[a0] && refLine[b1] < columns)
>+              b1 += 2;
>+          }
>+          break;
>+        case twoDimVertL2:
>+          if (a0 == 0 || refLine[b1] - 2 > a0New) {
>+          a0New = codingLine[++a0] = refLine[b1] - 2;
>+          --b1;
>+          while (refLine[b1] <= codingLine[a0] && refLine[b1] < columns)
>+            b1 += 2;
>+          }
>+          break;
>+        case twoDimVertR3:
>+          a0New = codingLine[++a0] = refLine[b1] + 3;
>+          if (refLine[b1] < columns) {
>+            ++b1;
>+            while (refLine[b1] <= codingLine[a0] && refLine[b1] < columns)
>+              b1 += 2;
>+          }
>+          break;
>+        case twoDimVertL3:
>+          if (a0 == 0 || refLine[b1] - 3 > a0New) {
>+          a0New = codingLine[++a0] = refLine[b1] - 3;
>+          --b1;
>+          while (refLine[b1] <= codingLine[a0] && refLine[b1] < columns)
>+            b1 += 2;
>+          }
>+          break;
>+        case EOF:
>+          eof = gTrue;
>+          codingLine[a0 = 0] = columns;
>+          return EOF;
>+        default:
>+          error(getPos(), "Bad 2D code %04x in CCITTFax stream", code1);
>+          err = gTrue;
>+          break;
>+        }
>       } while (codingLine[a0] < columns);
> 
>     // 1-D encoding
>     } else {
>       codingLine[a0 = 0] = 0;
>       while (1) {
>-	code1 = 0;
>-	do {
>-	  code1 += code3 = getWhiteCode();
>-	} while (code3 >= 64);
>-	codingLine[a0+1] = codingLine[a0] + code1;
>-	++a0;
>-	if (codingLine[a0] >= columns)
>-	  break;
>-	code2 = 0;
>-	do {
>-	  code2 += code3 = getBlackCode();
>-	} while (code3 >= 64);
>-	codingLine[a0+1] = codingLine[a0] + code2;
>-	++a0;
>-	if (codingLine[a0] >= columns)
>-	  break;
>+        code1 = 0;
>+        do {
>+          code1 += code3 = getWhiteCode();
>+        } while (code3 >= 64);
>+        codingLine[a0+1] = codingLine[a0] + code1;
>+        ++a0;
>+        if (codingLine[a0] >= columns)
>+          break;
>+        code2 = 0;
>+        do {
>+          code2 += code3 = getBlackCode();
>+        } while (code3 >= 64);
>+        codingLine[a0+1] = codingLine[a0] + code2;
>+        ++a0;
>+        if (codingLine[a0] >= columns)
>+          break;
>       }
>     }
> 
>@@ -1497,7 +1442,7 @@
>       error(getPos(), "CCITTFax row is wrong length (%d)", codingLine[a0]);
>       // force the row to be the correct length
>       while (codingLine[a0] > columns) {
>-	--a0;
>+        --a0;
>       }
>       codingLine[++a0] = columns;
>       err = gTrue;
>@@ -1515,14 +1460,14 @@
>     } else {
>       code1 = lookBits(12);
>       while (code1 == 0) {
>-	eatBits(1);
>-	code1 = lookBits(12);
>+        eatBits(1);
>+        code1 = lookBits(12);
>       }
>       if (code1 == 0x001) {
>-	eatBits(12);
>-	gotEOL = gTrue;
>+        eatBits(12);
>+        gotEOL = gTrue;
>       } else if (code1 == EOF) {
>-	eof = gTrue;
>+        eof = gTrue;
>       }
>     }
> 
>@@ -1536,25 +1481,25 @@
>     if (endOfBlock && gotEOL) {
>       code1 = lookBits(12);
>       if (code1 == 0x001) {
>-	eatBits(12);
>-	if (encoding > 0) {
>-	  lookBits(1);
>-	  eatBits(1);
>-	}
>-	if (encoding >= 0) {
>-	  for (i = 0; i < 4; ++i) {
>-	    code1 = lookBits(12);
>-	    if (code1 != 0x001) {
>-	      error(getPos(), "Bad RTC code in CCITTFax stream");
>-	    }
>-	    eatBits(12);
>-	    if (encoding > 0) {
>-	      lookBits(1);
>-	      eatBits(1);
>-	    }
>-	  }
>-	}
>-	eof = gTrue;
>+        eatBits(12);
>+        if (encoding > 0) {
>+          lookBits(1);
>+          eatBits(1);
>+        }
>+        if (encoding >= 0) {
>+          for (i = 0; i < 4; ++i) {
>+            code1 = lookBits(12);
>+            if (code1 != 0x001) {
>+              error(getPos(), "Bad RTC code in CCITTFax stream");
>+            }
>+            eatBits(12);
>+            if (encoding > 0) {
>+              lookBits(1);
>+              eatBits(1);
>+            }
>+          }
>+        }
>+        eof = gTrue;
>       }
> 
>     // look for an end-of-line marker after an error -- we only do
>@@ -1562,17 +1507,17 @@
>     // the "just plow on" technique tends to work better otherwise
>     } else if (err && endOfLine) {
>       do {
>-	if (code1 == EOF) {
>-	  eof = gTrue;
>-	  return EOF;
>-	}
>-	eatBits(1);
>-	code1 = lookBits(13);
>+        if (code1 == EOF) {
>+          eof = gTrue;
>+          return EOF;
>+        }
>+        eatBits(1);
>+        code1 = lookBits(13);
>       } while ((code1 >> 1) != 0x001);
>       eatBits(12); 
>       if (encoding > 0) {
>-	eatBits(1);
>-	nextLine2D = !(code1 & 1);
>+        eatBits(1);
>+        nextLine2D = !(code1 & 1);
>       }
>     }
> 
>@@ -1592,7 +1537,7 @@
>     if ((outputBits -= 8) == 0) {
>       ++a0;
>       if (codingLine[a0] < columns) {
>-	outputBits = codingLine[a0 + 1] - codingLine[a0];
>+        outputBits = codingLine[a0 + 1] - codingLine[a0];
>       }
>     }
>   } else {
>@@ -1600,23 +1545,23 @@
>     ret = 0;
>     do {
>       if (outputBits > bits) {
>-	i = bits;
>-	bits = 0;
>-	if ((a0 & 1) == 0) {
>-	  ret |= 0xff >> (8 - i);
>-	}
>-	outputBits -= i;
>+        i = bits;
>+        bits = 0;
>+        if ((a0 & 1) == 0) {
>+          ret |= 0xff >> (8 - i);
>+        }
>+        outputBits -= i;
>       } else {
>-	i = outputBits;
>-	bits -= outputBits;
>-	if ((a0 & 1) == 0) {
>-	  ret |= (0xff >> (8 - i)) << bits;
>-	}
>-	outputBits = 0;
>-	++a0;
>-	if (codingLine[a0] < columns) {
>-	  outputBits = codingLine[a0 + 1] - codingLine[a0];
>-	}
>+        i = outputBits;
>+        bits -= outputBits;
>+        if ((a0 & 1) == 0) {
>+          ret |= (0xff >> (8 - i)) << bits;
>+        }
>+        outputBits = 0;
>+        ++a0;
>+        if (codingLine[a0] < columns) {
>+          outputBits = codingLine[a0 + 1] - codingLine[a0];
>+        }
>       }
>     } while (bits > 0 && codingLine[a0] < columns);
>   }
>@@ -1641,12 +1586,12 @@
>     for (n = 1; n <= 7; ++n) {
>       code = lookBits(n);
>       if (n < 7) {
>-	code <<= 7 - n;
>+        code <<= 7 - n;
>       }
>       p = &twoDimTab1[code];
>       if (p->bits == n) {
>-	eatBits(n);
>-	return p->n;
>+        eatBits(n);
>+        return p->n;
>       }
>     }
>   }
>@@ -1675,23 +1620,23 @@
>     for (n = 1; n <= 9; ++n) {
>       code = lookBits(n);
>       if (n < 9) {
>-	code <<= 9 - n;
>+        code <<= 9 - n;
>       }
>       p = &whiteTab2[code];
>       if (p->bits == n) {
>-	eatBits(n);
>-	return p->n;
>+        eatBits(n);
>+        return p->n;
>       }
>     }
>     for (n = 11; n <= 12; ++n) {
>       code = lookBits(n);
>       if (n < 12) {
>-	code <<= 12 - n;
>+        code <<= 12 - n;
>       }
>       p = &whiteTab1[code];
>       if (p->bits == n) {
>-	eatBits(n);
>-	return p->n;
>+        eatBits(n);
>+        return p->n;
>       }
>     }
>   }
>@@ -1725,36 +1670,36 @@
>     for (n = 2; n <= 6; ++n) {
>       code = lookBits(n);
>       if (n < 6) {
>-	code <<= 6 - n;
>+        code <<= 6 - n;
>       }
>       p = &blackTab3[code];
>       if (p->bits == n) {
>-	eatBits(n);
>-	return p->n;
>+        eatBits(n);
>+        return p->n;
>       }
>     }
>     for (n = 7; n <= 12; ++n) {
>       code = lookBits(n);
>       if (n < 12) {
>-	code <<= 12 - n;
>+        code <<= 12 - n;
>       }
>       if (code >= 64) {
>-	p = &blackTab2[code - 64];
>-	if (p->bits == n) {
>-	  eatBits(n);
>-	  return p->n;
>-	}
>+        p = &blackTab2[code - 64];
>+        if (p->bits == n) {
>+          eatBits(n);
>+          return p->n;
>+        }
>       }
>     }
>     for (n = 10; n <= 13; ++n) {
>       code = lookBits(n);
>       if (n < 13) {
>-	code <<= 13 - n;
>+        code <<= 13 - n;
>       }
>       p = &blackTab1[code];
>       if (p->bits == n) {
>-	eatBits(n);
>-	return p->n;
>+        eatBits(n);
>+        return p->n;
>       }
>     }
>   }
>@@ -1771,7 +1716,7 @@
>   while (inputBits < n) {
>     if ((c = str->getChar()) == EOF) {
>       if (inputBits == 0) {
>-	return EOF;
>+        return EOF;
>       }
>       // near the end of the stream, the caller may ask for more bits
>       // than are available, but there may still be a valid code in
>@@ -2362,8 +2307,8 @@
> 
> // Read one data unit from a sequential JPEG stream.
> GBool DCTStream::readProgressiveDataUnit(DCTHuffTable *dcHuffTable,
>-					 DCTHuffTable *acHuffTable,
>-					 int *prevDC, int data[64]) {
>+                                         DCTHuffTable *acHuffTable,
>+                                         int *prevDC, int data[64]) {
>   int run, size, amp, bit, c;
>   int i, j, k;
> 
>@@ -2631,7 +2576,7 @@
> // The stage numbers mentioned in the comments refer to Figure 1 in this
> // paper.
> void DCTStream::transformDataUnit(Gushort *quantTable,
>-				  int dataIn[64], Guchar dataOut[64]) {
>+                                  int dataIn[64], Guchar dataOut[64]) {
>   int v0, v1, v2, v3, v4, v5, v6, v7, t;
>   int *p;
>   int i;
>@@ -3874,7 +3819,7 @@
> };
> 
> FlateStream::FlateStream(Stream *strA, int predictor, int columns,
>-			 int colors, int bits):
>+                         int colors, int bits):
>     FilterStream(strA) {
>   if (predictor != 1) {
>     pred = new StreamPredictor(this, predictor, columns, colors, bits);
>@@ -4025,20 +3970,20 @@
>       code1 -= 257;
>       code2 = lengthDecode[code1].bits;
>       if (code2 > 0 && (code2 = getCodeWord(code2)) == EOF)
>-	goto err;
>+        goto err;
>       len = lengthDecode[code1].first + code2;
>       if ((code1 = getHuffmanCodeWord(&distCodeTab)) == EOF)
>-	goto err;
>+        goto err;
>       code2 = distDecode[code1].bits;
>       if (code2 > 0 && (code2 = getCodeWord(code2)) == EOF)
>-	goto err;
>+        goto err;
>       dist = distDecode[code1].first + code2;
>       i = index;
>       j = (index - dist) & flateMask;
>       for (k = 0; k < len; ++k) {
>-	buf[i] = buf[j];
>-	i = (i + 1) & flateMask;
>-	j = (j + 1) & flateMask;
>+        buf[i] = buf[j];
>+        i = (i + 1) & flateMask;
>+        j = (j + 1) & flateMask;
>       }
>       remain = len;
>     }
>@@ -4047,8 +3992,8 @@
>     len = (blockLen < flateWindow) ? blockLen : flateWindow;
>     for (i = 0, j = index; i < len; ++i, j = (j + 1) & flateMask) {
>       if ((c = str->getChar()) == EOF) {
>-	endOfBlock = eof = gTrue;
>-	break;
>+        endOfBlock = eof = gTrue;
>+        break;
>       }
>       buf[j] = c & 0xff;
>     }
>@@ -4191,38 +4136,38 @@
>     }
>     if (code == 16) {
>       if ((repeat = getCodeWord(2)) == EOF) {
>-	goto err;
>+        goto err;
>       }
>       repeat += 3;
>       if (i + repeat > numLitCodes + numDistCodes) {
>-	goto err;
>+        goto err;
>       }
>       for (; repeat > 0; --repeat) {
>-	codeLengths[i++] = len;
>+        codeLengths[i++] = len;
>       }
>     } else if (code == 17) {
>       if ((repeat = getCodeWord(3)) == EOF) {
>-	goto err;
>+        goto err;
>       }
>       repeat += 3;
>       if (i + repeat > numLitCodes + numDistCodes) {
>-	goto err;
>+        goto err;
>       }
>       len = 0;
>       for (; repeat > 0; --repeat) {
>-	codeLengths[i++] = 0;
>+        codeLengths[i++] = 0;
>       }
>     } else if (code == 18) {
>       if ((repeat = getCodeWord(7)) == EOF) {
>-	goto err;
>+        goto err;
>       }
>       repeat += 11;
>       if (i + repeat > numLitCodes + numDistCodes) {
>-	goto err;
>+        goto err;
>       }
>       len = 0;
>       for (; repeat > 0; --repeat) {
>-	codeLengths[i++] = 0;
>+        codeLengths[i++] = 0;
>       }
>     } else {
>       codeLengths[i++] = len = code;
>@@ -4270,21 +4215,21 @@
>     for (val = 0; val < n; ++val) {
>       if (lengths[val] == len) {
> 
>-	// bit-reverse the code
>-	code2 = 0;
>-	t = code;
>-	for (i = 0; i < len; ++i) {
>-	  code2 = (code2 << 1) | (t & 1);
>-	  t >>= 1;
>-	}
>+        // bit-reverse the code
>+        code2 = 0;
>+        t = code;
>+        for (i = 0; i < len; ++i) {
>+          code2 = (code2 << 1) | (t & 1);
>+          t >>= 1;
>+        }
> 
>-	// fill in the table entries
>-	for (i = code2; i < tabSize; i += skip) {
>-	  tab->codes[i].len = (Gushort)len;
>-	  tab->codes[i].val = (Gushort)val;
>-	}
>+        // fill in the table entries
>+        for (i = code2; i < tabSize; i += skip) {
>+          tab->codes[i].len = (Gushort)len;
>+          tab->codes[i].val = (Gushort)val;
>+        }
> 
>-	++code;
>+        ++code;
>       }
>     }
>   }
>@@ -4464,22 +4409,22 @@
>     if (n == 4 && t == 0) {
>       *bufEnd++ = 'z';
>       if (++lineLen == 65) {
>-	*bufEnd++ = '\n';
>-	lineLen = 0;
>+        *bufEnd++ = '\n';
>+        lineLen = 0;
>       }
>     } else {
>       if (n < 4)
>-	t <<= 8 * (4 - n);
>+        t <<= 8 * (4 - n);
>       for (i = 4; i >= 0; --i) {
>-	buf1[i] = (char)(t % 85 + 0x21);
>-	t /= 85;
>+        buf1[i] = (char)(t % 85 + 0x21);
>+        t /= 85;
>       }
>       for (i = 0; i <= n; ++i) {
>-	*bufEnd++ = buf1[i];
>-	if (++lineLen == 65) {
>-	  *bufEnd++ = '\n';
>-	  lineLen = 0;
>-	}
>+        *bufEnd++ = buf1[i];
>+        if (++lineLen == 65) {
>+          *bufEnd++ = '\n';
>+          lineLen = 0;
>+        }
>       }
>     }
>   }
>@@ -4575,13 +4520,13 @@
>     n = 2;
>     while (n < 128) {
>       if ((c = str->getChar()) == EOF) {
>-	eof = gTrue;
>-	break;
>+        eof = gTrue;
>+        break;
>       }
>       ++n;
>       buf[n] = c;
>       if (buf[n] == buf[n-1])
>-	break;
>+        break;
>     }
>     if (buf[n] == buf[n-1]) {
>       buf[0] = (char)(n-2-1);
>Index: poppler/Stream.h
>===================================================================
>--- poppler/Stream.h	(revision 52)
>+++ poppler/Stream.h	(working copy)
>@@ -107,7 +107,7 @@
> 
>   // Get image parameters which are defined by the stream contents.
>   virtual void getImageParams(int * /*bitsPerComponent*/,
>-			      StreamColorSpaceMode * /*csMode*/) {}
>+                              StreamColorSpaceMode * /*csMode*/) {}
> 
>   // Add filters to this stream according to the parameters in <dict>.
>   // Returns the new stream.
>@@ -132,7 +132,7 @@
>   BaseStream(Object *dictA);
>   virtual ~BaseStream();
>   virtual Stream *makeSubStream(Guint start, GBool limited,
>-				Guint length, Object *dict) = 0;
>+                                Guint length, Object *dict) = 0;
>   virtual void setPos(Guint pos, int dir = 0) = 0;
>   virtual GBool isBinary(GBool last = gTrue) { return last; }
>   virtual BaseStream *getBaseStream() { return this; }
>@@ -144,7 +144,7 @@
> 
>   // Set decryption for this stream.
>   virtual void doDecryption(Guchar *fileKey, int keyLength,
>-			    int objNum, int objGen);
>+                            int objNum, int objGen);
> 
> protected:
> 
>@@ -226,7 +226,7 @@
>   // Create a predictor object.  Note that the parameters are for the
>   // predictor, and may not match the actual image parameters.
>   StreamPredictor(Stream *strA, int predictorA,
>-		  int widthA, int nCompsA, int nBitsA);
>+                  int widthA, int nCompsA, int nBitsA);
> 
>   ~StreamPredictor();
> 
>@@ -262,10 +262,10 @@
> public:
> 
>   FileStream(FILE *fA, Guint startA, GBool limitedA,
>-	     Guint lengthA, Object *dictA);
>+             Guint lengthA, Object *dictA);
>   virtual ~FileStream();
>   virtual Stream *makeSubStream(Guint startA, GBool limitedA,
>-				Guint lengthA, Object *dictA);
>+                                Guint lengthA, Object *dictA);
>   virtual StreamKind getKind() { return strFile; }
>   virtual void reset();
>   virtual void close();
>@@ -304,7 +304,7 @@
>   MemStream(char *bufA, Guint startA, Guint lengthA, Object *dictA);
>   virtual ~MemStream();
>   virtual Stream *makeSubStream(Guint start, GBool limited,
>-				Guint lengthA, Object *dictA);
>+                                Guint lengthA, Object *dictA);
>   virtual StreamKind getKind() { return strWeird; }
>   virtual void reset();
>   virtual void close();
>@@ -317,7 +317,7 @@
>   virtual Guint getStart() { return start; }
>   virtual void moveStart(int delta);
>   virtual void doDecryption(Guchar *fileKey, int keyLength,
>-			    int objNum, int objGen);
>+                            int objNum, int objGen);
> 
> private:
> 
>@@ -345,7 +345,7 @@
>   EmbedStream(Stream *strA, Object *dictA, GBool limitedA, Guint lengthA);
>   virtual ~EmbedStream();
>   virtual Stream *makeSubStream(Guint start, GBool limitedA,
>-				Guint lengthA, Object *dictA);
>+                                Guint lengthA, Object *dictA);
>   virtual StreamKind getKind() { return str->getKind(); }
>   virtual void reset() {}
>   virtual int getChar();
>@@ -418,7 +418,7 @@
> public:
> 
>   LZWStream(Stream *strA, int predictor, int columns, int colors,
>-	    int bits, int earlyA);
>+            int bits, int earlyA);
>   virtual ~LZWStream();
>   virtual StreamKind getKind() { return strLZW; }
>   virtual void reset();
>@@ -492,8 +492,8 @@
> public:
> 
>   CCITTFaxStream(Stream *strA, int encodingA, GBool endOfLineA,
>-		 GBool byteAlignA, int columnsA, int rowsA,
>-		 GBool endOfBlockA, GBool blackA);
>+                 GBool byteAlignA, int columnsA, int rowsA,
>+                 GBool endOfBlockA, GBool blackA);
>   virtual ~CCITTFaxStream();
>   virtual StreamKind getKind() { return strCCITTFax; }
>   virtual void reset();
>@@ -546,7 +546,7 @@
> 
> struct DCTScanInfo {
>   GBool comp[4];		// comp[i] is set if component i is
>-				//   included in this scan
>+                                //   included in this scan
>   int numComps;			// number of components in the scan
>   int dcHuffTable[4];		// DC Huffman table numbers
>   int acHuffTable[4];		// AC Huffman table numbers
>@@ -608,14 +608,14 @@
>   GBool readMCURow();
>   void readScan();
>   GBool readDataUnit(DCTHuffTable *dcHuffTable,
>-		     DCTHuffTable *acHuffTable,
>-		     int *prevDC, int data[64]);
>+                     DCTHuffTable *acHuffTable,
>+                     int *prevDC, int data[64]);
>   GBool readProgressiveDataUnit(DCTHuffTable *dcHuffTable,
>-				DCTHuffTable *acHuffTable,
>-				int *prevDC, int data[64]);
>+                                DCTHuffTable *acHuffTable,
>+                                int *prevDC, int data[64]);
>   void decodeImage();
>   void transformDataUnit(Gushort *quantTable,
>-			 int dataIn[64], Guchar dataOut[64]);
>+                         int dataIn[64], Guchar dataOut[64]);
>   int readHuffSym(DCTHuffTable *table);
>   int readAmp(int size);
>   int readBit();
>@@ -667,7 +667,7 @@
> public:
> 
>   FlateStream(Stream *strA, int predictor, int columns,
>-	      int colors, int bits);
>+              int colors, int bits);
>   virtual ~FlateStream();
>   virtual StreamKind getKind() { return strFlate; }
>   virtual void reset();
>Index: poppler/UGooString.cc
>===================================================================
>--- poppler/UGooString.cc	(revision 52)
>+++ poppler/UGooString.cc	(working copy)
>@@ -9,6 +9,7 @@
> //========================================================================
> 
> #include <string.h>
>+#include <assert.h>
> 
> #include "goo/gmem.h"
> #include "goo/GooString.h"
>@@ -157,8 +158,37 @@
>   return n1 - n2;
> }
> 
>+int UGooString::cmp(const char *str, int strLen) const
>+{
>+  int n1, n2, i, x;
>+  Unicode u;
>+  Unicode *p1, *p2;
>+
>+  assert(str);
>+  if (strLen == CALC_STRING_LEN) {
>+    n2 = 0;
>+    if (str)
>+      n2 = strlen(str);
>+  } else {
>+    n2 = strLen;
>+  }
>+
>+  p2 = &u;
>+  n1 = length;
>+  for (i = 0, p1 = s; i < n1 && i < n2; ++i, ++p1) {
>+    u = pdfDocEncoding[str[i] & 0xff];
>+    if (!u)
>+      u = (unsigned char)str[i];
>+    x = *p1 - *p2;
>+    if (x != 0) {
>+      return x;
>+    }
>+  }
>+  return n1 - n2;
>+}
>+
> // FIXME: 
>-// a) this is confusing because GooString::getCSTring() returns a pointer
>+// a) this is confusing because GooString::getCString() returns a pointer
> //    but UGooString returns a newly allocated copy. Should give this
> //    a different name, like copyAsAscii() or copyAsGooString()
> // b) this interface requires copying. It should be changed to take a
>Index: poppler/XRef.cc
>===================================================================
>--- poppler/XRef.cc	(revision 52)
>+++ poppler/XRef.cc	(working copy)
>@@ -30,7 +30,7 @@
> //------------------------------------------------------------------------
> 
> #define xrefSearchSize 1024	// read this many bytes at end of file
>-				//   to look for 'startxref'
>+                                //   to look for 'startxref'
> 
> //------------------------------------------------------------------------
> // Permission bits
>@@ -140,7 +140,7 @@
>     obj1.free();
>     obj2.free();
>     if (objNums[i] < 0 || offsets[i] < 0 ||
>-	(i > 0 && offsets[i] < offsets[i-1])) {
>+        (i > 0 && offsets[i] < offsets[i-1])) {
>       delete parser;
>       gfree(offsets);
>       goto err1;
>@@ -163,7 +163,7 @@
>       str = new EmbedStream(objStr.getStream(), &obj1, gFalse, 0);
>     } else {
>       str = new EmbedStream(objStr.getStream(), &obj1, gTrue,
>-			    offsets[i+1] - offsets[i]);
>+                            offsets[i+1] - offsets[i]);
>     }
>     parser = new Parser(xref, new Lexer(xref, str));
>     parser->getObj(&objs[i]);
>@@ -238,8 +238,8 @@
>     // try to reconstruct it
>     if (!ok) {
>       if (!(ok = constructXRef())) {
>-	errCode = errDamaged;
>-	return;
>+        errCode = errDamaged;
>+        return;
>       }
>     }
>   }
>@@ -315,8 +315,8 @@
>   // start up a parser, parse one token
>   obj.initNull();
>   parser = new Parser(NULL,
>-	     new Lexer(NULL,
>-	       str->makeSubStream(start + *pos, gFalse, 0, &obj)));
>+             new Lexer(NULL,
>+               str->makeSubStream(start + *pos, gFalse, 0, &obj)));
>   parser->getObj(&obj);
> 
>   // parse an old-style xref table
>@@ -383,10 +383,10 @@
>     }
>     if (first + n > size) {
>       for (newSize = size ? 2 * size : 1024;
>-	   first + n > newSize && newSize > 0;
>-	   newSize <<= 1) ;
>+           first + n > newSize && newSize > 0;
>+           newSize <<= 1) ;
>       if (newSize < 0) {
>-	goto err1;
>+        goto err1;
>       }
>       if (newSize*(int)sizeof(XRefEntry)/sizeof(XRefEntry) != newSize) {
>         error(-1, "Invalid 'obj' parameters'");
>@@ -395,43 +395,43 @@
>  
>       entries = (XRefEntry *)greallocn(entries, newSize, sizeof(XRefEntry));
>       for (i = size; i < newSize; ++i) {
>-	entries[i].offset = 0xffffffff;
>-	entries[i].type = xrefEntryFree;
>+        entries[i].offset = 0xffffffff;
>+        entries[i].type = xrefEntryFree;
>       }
>       size = newSize;
>     }
>     for (i = first; i < first + n; ++i) {
>       if (!parser->getObj(&obj)->isInt()) {
>-	goto err1;
>+        goto err1;
>       }
>       entry.offset = (Guint)obj.getInt();
>       obj.free();
>       if (!parser->getObj(&obj)->isInt()) {
>-	goto err1;
>+        goto err1;
>       }
>       entry.gen = obj.getInt();
>       obj.free();
>       parser->getObj(&obj);
>       if (obj.isCmd("n")) {
>-	entry.type = xrefEntryUncompressed;
>+        entry.type = xrefEntryUncompressed;
>       } else if (obj.isCmd("f")) {
>-	entry.type = xrefEntryFree;
>+        entry.type = xrefEntryFree;
>       } else {
>-	goto err1;
>+        goto err1;
>       }
>       obj.free();
>       if (entries[i].offset == 0xffffffff) {
>-	entries[i] = entry;
>-	// PDF files of patents from the IBM Intellectual Property
>-	// Network have a bug: the xref table claims to start at 1
>-	// instead of 0.
>-	if (i == 1 && first == 1 &&
>-	    entries[1].offset == 0 && entries[1].gen == 65535 &&
>-	    entries[1].type == xrefEntryFree) {
>-	  i = first = 0;
>-	  entries[0] = entries[1];
>-	  entries[1].offset = 0xffffffff;
>-	}
>+        entries[i] = entry;
>+        // PDF files of patents from the IBM Intellectual Property
>+        // Network have a bug: the xref table claims to start at 1
>+        // instead of 0.
>+        if (i == 1 && first == 1 &&
>+            entries[1].offset == 0 && entries[1].gen == 65535 &&
>+            entries[1].type == xrefEntryFree) {
>+          i = first = 0;
>+          entries[0] = entries[1];
>+          entries[1].offset = 0xffffffff;
>+        }
>       }
>     }
>   }
>@@ -533,21 +533,21 @@
>   if (idx.isArray()) {
>     for (i = 0; i+1 < idx.arrayGetLength(); i += 2) {
>       if (!idx.arrayGet(i, &obj)->isInt()) {
>-	idx.free();
>-	goto err1;
>+        idx.free();
>+        goto err1;
>       }
>       first = obj.getInt();
>       obj.free();
>       if (!idx.arrayGet(i+1, &obj)->isInt()) {
>-	idx.free();
>-	goto err1;
>+        idx.free();
>+        goto err1;
>       }
>       n = obj.getInt();
>       obj.free();
>       if (first < 0 || n < 0 ||
>-	  !readXRefStreamSection(xrefStr, w, first, n)) {
>-	idx.free();
>-	goto err0;
>+          !readXRefStreamSection(xrefStr, w, first, n)) {
>+        idx.free();
>+        goto err0;
>       }
>     }
>   } else {
>@@ -588,8 +588,8 @@
>   }
>   if (first + n > size) {
>     for (newSize = size ? 2 * size : 1024;
>-	 first + n > newSize && newSize > 0;
>-	 newSize <<= 1) ;
>+         first + n > newSize && newSize > 0;
>+         newSize <<= 1) ;
>     if (newSize < 0) {
>       return gFalse;
>     }
>@@ -609,43 +609,43 @@
>       type = 1;
>     } else {
>       for (type = 0, j = 0; j < w[0]; ++j) {
>-	if ((c = xrefStr->getChar()) == EOF) {
>-	  return gFalse;
>-	}
>-	type = (type << 8) + c;
>+        if ((c = xrefStr->getChar()) == EOF) {
>+          return gFalse;
>+        }
>+        type = (type << 8) + c;
>       }
>     }
>     for (offset = 0, j = 0; j < w[1]; ++j) {
>       if ((c = xrefStr->getChar()) == EOF) {
>-	return gFalse;
>+        return gFalse;
>       }
>       offset = (offset << 8) + c;
>     }
>     for (gen = 0, j = 0; j < w[2]; ++j) {
>       if ((c = xrefStr->getChar()) == EOF) {
>-	return gFalse;
>+        return gFalse;
>       }
>       gen = (gen << 8) + c;
>     }
>     if (entries[i].offset == 0xffffffff) {
>       switch (type) {
>       case 0:
>-	entries[i].offset = offset;
>-	entries[i].gen = gen;
>-	entries[i].type = xrefEntryFree;
>-	break;
>+        entries[i].offset = offset;
>+        entries[i].gen = gen;
>+        entries[i].type = xrefEntryFree;
>+        break;
>       case 1:
>-	entries[i].offset = offset;
>-	entries[i].gen = gen;
>-	entries[i].type = xrefEntryUncompressed;
>-	break;
>+        entries[i].offset = offset;
>+        entries[i].gen = gen;
>+        entries[i].type = xrefEntryUncompressed;
>+        break;
>       case 2:
>-	entries[i].offset = offset;
>-	entries[i].gen = gen;
>-	entries[i].type = xrefEntryCompressed;
>-	break;
>+        entries[i].offset = offset;
>+        entries[i].gen = gen;
>+        entries[i].type = xrefEntryCompressed;
>+        break;
>       default:
>-	return gFalse;
>+        return gFalse;
>       }
>     }
>   }
>@@ -686,21 +686,21 @@
>     if (!strncmp(p, "trailer", 7)) {
>       obj.initNull();
>       parser = new Parser(NULL,
>-		 new Lexer(NULL,
>-		   str->makeSubStream(pos + 7, gFalse, 0, &obj)));
>+                 new Lexer(NULL,
>+                   str->makeSubStream(pos + 7, gFalse, 0, &obj)));
>       parser->getObj(&newTrailerDict);
>       if (newTrailerDict.isDict()) {
>-	newTrailerDict.dictLookupNF("Root", &obj);
>-	if (obj.isRef()) {
>-	  rootNum = obj.getRefNum();
>-	  rootGen = obj.getRefGen();
>-	  if (!trailerDict.isNone()) {
>-	    trailerDict.free();
>-	  }
>-	  newTrailerDict.copy(&trailerDict);
>-	  gotRoot = gTrue;
>-	}
>-	obj.free();
>+        newTrailerDict.dictLookupNF("Root", &obj);
>+        if (obj.isRef()) {
>+          rootNum = obj.getRefNum();
>+          rootGen = obj.getRefGen();
>+          if (!trailerDict.isNone()) {
>+            trailerDict.free();
>+          }
>+          newTrailerDict.copy(&trailerDict);
>+          gotRoot = gTrue;
>+        }
>+        obj.free();
>       }
>       newTrailerDict.free();
>       delete parser;
>@@ -709,62 +709,62 @@
>     } else if (isdigit(*p)) {
>       num = atoi(p);
>       if (num > 0) {
>-	do {
>-	  ++p;
>-	} while (*p && isdigit(*p));
>-	if (isspace(*p)) {
>-	  do {
>-	    ++p;
>-	  } while (*p && isspace(*p));
>-	  if (isdigit(*p)) {
>-	    gen = atoi(p);
>-	    do {
>-	      ++p;
>-	    } while (*p && isdigit(*p));
>-	    if (isspace(*p)) {
>-	      do {
>-		++p;
>-	      } while (*p && isspace(*p));
>-	      if (!strncmp(p, "obj", 3)) {
>-		if (num >= size) {
>-		  newSize = (num + 1 + 255) & ~255;
>-		  if (newSize < 0) {
>-		    error(-1, "Bad object number");
>-		    return gFalse;
>-		  }
>+        do {
>+          ++p;
>+        } while (*p && isdigit(*p));
>+        if (isspace(*p)) {
>+          do {
>+            ++p;
>+          } while (*p && isspace(*p));
>+          if (isdigit(*p)) {
>+            gen = atoi(p);
>+            do {
>+              ++p;
>+            } while (*p && isdigit(*p));
>+            if (isspace(*p)) {
>+              do {
>+                ++p;
>+              } while (*p && isspace(*p));
>+              if (!strncmp(p, "obj", 3)) {
>+                if (num >= size) {
>+                  newSize = (num + 1 + 255) & ~255;
>+                  if (newSize < 0) {
>+                    error(-1, "Bad object number");
>+                    return gFalse;
>+                  }
>                   if (newSize*(int)sizeof(XRefEntry)/sizeof(XRefEntry) != newSize) {
>                     error(-1, "Invalid 'obj' parameters.");
>                     return gFalse;
>                   }
>-		  entries = (XRefEntry *)
>-		      greallocn(entries, newSize, sizeof(XRefEntry));
>-		  for (i = size; i < newSize; ++i) {
>-		    entries[i].offset = 0xffffffff;
>-		    entries[i].type = xrefEntryFree;
>-		  }
>-		  size = newSize;
>-		}
>-		if (entries[num].type == xrefEntryFree ||
>-		    gen >= entries[num].gen) {
>-		  entries[num].offset = pos - start;
>-		  entries[num].gen = gen;
>-		  entries[num].type = xrefEntryUncompressed;
>-		}
>-	      }
>-	    }
>-	  }
>-	}
>+                  entries = (XRefEntry *)
>+                      greallocn(entries, newSize, sizeof(XRefEntry));
>+                  for (i = size; i < newSize; ++i) {
>+                    entries[i].offset = 0xffffffff;
>+                    entries[i].type = xrefEntryFree;
>+                  }
>+                  size = newSize;
>+                }
>+                if (entries[num].type == xrefEntryFree ||
>+                    gen >= entries[num].gen) {
>+                  entries[num].offset = pos - start;
>+                  entries[num].gen = gen;
>+                  entries[num].type = xrefEntryUncompressed;
>+                }
>+              }
>+            }
>+          }
>+        }
>       }
> 
>     } else if (!strncmp(p, "endstream", 9)) {
>       if (streamEndsLen == streamEndsSize) {
>-	streamEndsSize += 64;
>+        streamEndsSize += 64;
>         if (streamEndsSize*(int)sizeof(int)/sizeof(int) != streamEndsSize) {
>           error(-1, "Invalid 'endstream' parameter.");
>           return gFalse;
>         }
>-	streamEnds = (Guint *)greallocn(streamEnds,
>-					streamEndsSize, sizeof(int));
>+        streamEnds = (Guint *)greallocn(streamEnds,
>+                                        streamEndsSize, sizeof(int));
>       }
>       streamEnds[streamEndsLen++] = pos;
>     }
>@@ -778,8 +778,8 @@
> }
> 
> void XRef::setEncryption(int permFlagsA, GBool ownerPasswordOkA,
>-			 Guchar *fileKeyA, int keyLengthA,
>-			 int encVersionA, int encRevisionA) {
>+                         Guchar *fileKeyA, int keyLengthA,
>+                         int encVersionA, int encRevisionA) {
>   int i;
> 
>   encrypted = gTrue;
>@@ -858,14 +858,14 @@
>     }
>     obj1.initNull();
>     parser = new Parser(this,
>-	       new Lexer(this,
>-		 str->makeSubStream(start + e->offset, gFalse, 0, &obj1)));
>+               new Lexer(this,
>+                 str->makeSubStream(start + e->offset, gFalse, 0, &obj1)));
>     parser->getObj(&obj1);
>     parser->getObj(&obj2);
>     parser->getObj(&obj3);
>     if (!obj1.isInt() || obj1.getInt() != num ||
>-	!obj2.isInt() || obj2.getInt() != gen ||
>-	!obj3.isCmd("obj")) {
>+        !obj2.isInt() || obj2.getInt() != gen ||
>+        !obj3.isCmd("obj")) {
>       obj1.free();
>       obj2.free();
>       obj3.free();
>@@ -873,7 +873,7 @@
>       goto err;
>     }
>     parser->getObj(obj, encrypted ? fileKey : (Guchar *)NULL, keyLength,
>-		   num, gen);
>+                   num, gen);
>     obj1.free();
>     obj2.free();
>     obj3.free();
>@@ -886,7 +886,7 @@
>     }
>     if (!objStr || objStr->getObjStrNum() != (int)e->offset) {
>       if (objStr) {
>-	delete objStr;
>+        delete objStr;
>       }
>       objStr = new ObjectStream(this, e->offset);
>     }
>Index: poppler/Gfx.cc
>===================================================================
>--- poppler/Gfx.cc	(revision 52)
>+++ poppler/Gfx.cc	(working copy)
>@@ -3510,38 +3510,43 @@
> Stream *Gfx::buildImageStream() {
>   Object dict;
>   Object obj;
>+  Object dictObj;
>   char *key;
>   Stream *str;
>+  GBool isEOF = gFalse;
> 
>-  // build dictionary
>   dict.initDict(xref);
>-  parser->getObj(&obj);
>-  while (!obj.isCmd("ID") && !obj.isEOF()) {
>+  while (1) {
>+    parser->getObj(&obj);
>+    isEOF = obj.isEOF();
>+    if (isEOF || obj.isCmd("ID"))
>+        break;
>     if (!obj.isName()) {
>       error(getPos(), "Inline image dictionary key must be a name object");
>-      obj.free();
>     } else {
>-      key = copyString(obj.getName());
>-      obj.free();
>-      parser->getObj(&obj);
>-      if (obj.isEOF() || obj.isError()) {
>-	gfree(key);
>-	break;
>+      parser->getObj(&dictObj);
>+      isEOF = dictObj.isEOF();
>+      if (isEOF)
>+        break;
>+      if (dictObj.isError()) {
>+        // FIXME: we probably should not build a stream in this case either
>+        // but this behaviour was in poppler for a while so maybe it's ok
>+        dictObj.free();
>+        break;
>       }
>-      dict.dictAdd(key, &obj);
>-      gfree(key);
>+      key = obj.getName();
>+      dict.dictAdd(key, &dictObj);
>     }
>-    parser->getObj(&obj);
>+    obj.free();
>   }
>-  if (obj.isEOF()) {
>+
>+  obj.free();
>+  if (isEOF) {
>     error(getPos(), "End of file in inline image");
>-    obj.free();
>     dict.free();
>     return NULL;
>   }
>-  obj.free();
> 
>-  // make stream
>   str = new EmbedStream(parser->getStream(), &dict, gFalse, 0);
>   str = str->addFilters(&dict);
> 
>Index: poppler/Dict.cc
>===================================================================
>--- poppler/Dict.cc	(revision 52)
>+++ poppler/Dict.cc	(working copy)
>@@ -1,116 +1,203 @@
>-//========================================================================
>-//
>-// Dict.cc
>-//
>-// Copyright 1996-2003 Glyph & Cog, LLC
>-//
>-//========================================================================
>-
>-#include <config.h>
>-
>-#ifdef USE_GCC_PRAGMAS
>-#pragma implementation
>-#endif
>-
>-#include <stddef.h>
>-#include <string.h>
>-#include "goo/gmem.h"
>-#include "Object.h"
>-#include "UGooString.h"
>-#include "XRef.h"
>-#include "Dict.h"
>-
>-//------------------------------------------------------------------------
>-// Dict
>-//------------------------------------------------------------------------
>-
>-Dict::Dict(XRef *xrefA) {
>-  xref = xrefA;
>-  entries = NULL;
>-  size = length = 0;
>-  ref = 1;
>-}
>-
>-Dict::~Dict() {
>-  int i;
>-
>-  for (i = 0; i < length; ++i) {
>-    delete entries[i].key;
>-    entries[i].val.free();
>-  }
>-  gfree(entries);
>-}
>-
>-void Dict::add(const UGooString &key, Object *val) {
>-  if (length == size) {
>-    if (length == 0) {
>-      size = 8;
>-    } else {
>-      size *= 2;
>-    }
>-    entries = (DictEntry *)greallocn(entries, size, sizeof(DictEntry));
>-  }
>-  entries[length].key = new UGooString(key);
>-  entries[length].val = *val;
>-  ++length;
>-}
>-
>-inline DictEntry *Dict::find(const UGooString &key) {
>-  int i;
>-
>-  for (i = 0; i < length; ++i) {
>-    if (!key.cmp(entries[i].key))
>-      return &entries[i];
>-  }
>-  return NULL;
>-}
>-
>-GBool Dict::is(char *type) {
>-  DictEntry *e;
>-
>-  return (e = find("Type")) && e->val.isName(type);
>-}
>-
>-Object *Dict::lookup(const UGooString &key, Object *obj) {
>-  DictEntry *e;
>-
>-  return (e = find(key)) ? e->val.fetch(xref, obj) : obj->initNull();
>-}
>-
>-Object *Dict::lookupNF(const UGooString &key, Object *obj) {
>-  DictEntry *e;
>-
>-  return (e = find(key)) ? e->val.copy(obj) : obj->initNull();
>-}
>-
>-GBool Dict::lookupInt(const char *key, const char *alt_key, int *value)
>-{
>-  Object obj1;
>-  GBool success = gFalse;
>-  
>-  lookup ((char *) key, &obj1);
>-  if (obj1.isNull () && alt_key != NULL) {
>-    obj1.free ();
>-    lookup ((char *) alt_key, &obj1);
>-  }
>-  if (obj1.isInt ()) {
>-    *value = obj1.getInt ();
>-    success = gTrue;
>-  }
>-
>-  obj1.free ();
>-
>-  return success;
>-}
>-
>-UGooString *Dict::getKey(int i) {
>-  return entries[i].key;
>-}
>-
>-Object *Dict::getVal(int i, Object *obj) {
>-  return entries[i].val.fetch(xref, obj);
>-}
>-
>-Object *Dict::getValNF(int i, Object *obj) {
>-  return entries[i].val.copy(obj);
>-}
>+//========================================================================
>+//
>+// Dict.cc
>+//
>+// Copyright 1996-2003 Glyph & Cog, LLC
>+//
>+//========================================================================
>+
>+#include <config.h>
>+
>+#ifdef USE_GCC_PRAGMAS
>+#pragma implementation
>+#endif
>+
>+#include <stddef.h>
>+#include <string.h>
>+#include <assert.h>
>+#include "goo/gmem.h"
>+#include "Error.h"
>+#include "Object.h"
>+#include "UGooString.h"
>+#include "XRef.h"
>+#include "Dict.h"
>+
>+//------------------------------------------------------------------------
>+// Dict
>+//------------------------------------------------------------------------
>+
>+Dict::Dict(XRef *xrefA) {
>+  xref = xrefA;
>+  entries = NULL;
>+  size = length = 0;
>+  ref = 1;
>+}
>+
>+Dict::~Dict() {
>+  int i;
>+
>+  for (i = 0; i < length; ++i) {
>+    delete entries[i].key;
>+    entries[i].val.free();
>+  }
>+  gfree(entries);
>+}
>+
>+void Dict::add(const UGooString &key, Object *val) {
>+  if (length == size) {
>+    if (length == 0) {
>+      size = 8;
>+    } else {
>+      size *= 2;
>+    }
>+    entries = (DictEntry *)greallocn(entries, size, sizeof(DictEntry));
>+  }
>+  entries[length].key = new UGooString(key);
>+  entries[length].val = *val;
>+  ++length;
>+}
>+
>+inline DictEntry *Dict::find(const UGooString &key) const {
>+  int i;
>+
>+  for (i = 0; i < length; ++i) {
>+    if (!key.cmp(entries[i].key))
>+      return &entries[i];
>+  }
>+  return NULL;
>+}
>+
>+inline DictEntry *Dict::find(const char *key, int keyLen) const {
>+  int i;
>+
>+  for (i = 0; i < length; ++i) {
>+    if (0 == entries[i].key->cmp(key, keyLen))
>+      return &entries[i];
>+  }
>+  return NULL;
>+}
>+
>+// length of string "Type"
>+#define TYPE_STR_LEN 4
>+
>+GBool Dict::is(char *type) const {
>+  DictEntry *e = find("Type", TYPE_STR_LEN);
>+  if (!e)
>+    return gFalse;
>+  return e->val.isName(type);
>+}
>+
>+Object *Dict::lookup(const char *key, Object *obj, int keyLen) const {
>+  DictEntry *e = find(key, keyLen);
>+  if (!e)
>+    return obj->initNull();
>+  return e->val.fetch(xref, obj);
>+}
>+
>+Object *Dict::lookupNF(const char *key, Object *obj, int keyLen) const {
>+  DictEntry *e = find(key, keyLen);
>+  if (!e)
>+    return obj->initNull();
>+  return e->val.copy(obj);
>+}
>+
>+Object *Dict::lookup(const UGooString &key, Object *obj) const {
>+  DictEntry *e = find(key);
>+  if (!e)
>+    return obj->initNull();
>+  return e->val.fetch(xref, obj);
>+}
>+
>+Object *Dict::lookupNF(const UGooString &key, Object *obj) const {
>+  DictEntry *e = find(key);
>+  if (!e)
>+    return obj->initNull();
>+  return e->val.copy(obj);
>+}
>+
>+Object *Dict::lookupRefNoFetch(const char *key, int keyLen) const {
>+  DictEntry *e;
>+  e = find(key);
>+  if (!e)
>+    return NULL;
>+  return &(e->val);
>+}
>+
>+Object *Dict::lookupRefNoFetch(const UGooString &key) const {
>+  DictEntry *e;
>+  e = find(key);
>+  if (!e)
>+    return NULL;
>+  return &(e->val);
>+
>+}
>+
>+GBool Dict::lookupBool(const char *key, const char *alt_key, GBool *value) const {
>+  Object *obj;
>+
>+  // FIXME: handle ref objects as well
>+  obj = lookupRefNoFetch(key);
>+  if (obj && obj->isRef()) {
>+    error(-1, "ref object in Dict::lookupBool for %s", key);
>+    assert(0);
>+  }
>+  if (obj && obj->isBool()) {
>+    *value = obj->getBool();
>+    return gTrue;
>+  }
>+
>+  if (!alt_key)
>+    return gFalse;
>+  obj = lookupRefNoFetch(alt_key);
>+  if (obj && obj->isRef()) {
>+    error(-1, "ref object in Dict::lookupBool for %s", alt_key);
>+    assert(0);
>+  }
>+  if (obj && obj->isBool()) {
>+    *value = obj->getBool();
>+    return gTrue;
>+  }
>+
>+  return gFalse;
>+}
>+
>+GBool Dict::lookupInt(const char *key, const char *alt_key, int *value) const {
>+  Object *obj;
>+
>+  // FIXME: handle ref objects as well
>+  obj = lookupRefNoFetch(key);
>+  if (obj && obj->isRef()) {
>+    error(-1, "ref object in Dict::lookupInt for %s", key);
>+    assert(0);
>+  }
>+  if (obj && obj->isInt()) {
>+    *value = obj->getInt();
>+    return gTrue;
>+  }
>+
>+  if (!alt_key)
>+    return gFalse;
>+  obj = lookupRefNoFetch(alt_key);
>+  if (obj && obj->isRef()) {
>+    error(-1, "ref object in Dict::lookupInt for %s", alt_key);
>+    assert(0);
>+  }
>+  if (obj && obj->isInt()) {
>+    *value = obj->getInt();
>+    return gTrue;
>+  }
>+
>+  return gFalse;
>+}
>+
>+UGooString *Dict::getKey(int i) const {
>+  return entries[i].key;
>+}
>+
>+Object *Dict::getVal(int i, Object *obj) const {
>+  return entries[i].val.fetch(xref, obj);
>+}
>+
>+Object *Dict::getValNF(int i, Object *obj) const {
>+  return entries[i].val.copy(obj);
>+}
>Index: poppler/Dict.h
>===================================================================
>--- poppler/Dict.h	(revision 52)
>+++ poppler/Dict.h	(working copy)
>@@ -14,8 +14,8 @@
> #endif
> 
> #include "Object.h"
>+#include "UGooString.h"
> 
>-class UGooString;
> //------------------------------------------------------------------------
> // Dict
> //------------------------------------------------------------------------
>@@ -28,10 +28,8 @@
> class Dict {
> public:
> 
>-  // Constructor.
>   Dict(XRef *xrefA);
> 
>-  // Destructor.
>   ~Dict();
> 
>   // Reference counting.
>@@ -39,24 +37,30 @@
>   int decRef() { return --ref; }
> 
>   // Get number of entries.
>-  int getLength() { return length; }
>+  int getLength() const { return length; }
> 
>   // Add an entry
>   void add(const UGooString &key, Object *val);
> 
>   // Check if dictionary is of specified type.
>-  GBool is(char *type);
>+  GBool is(char *type) const;
> 
>   // Look up an entry and return the value.  Returns a null object
>   // if <key> is not in the dictionary.
>-  Object *lookup(const UGooString &key, Object *obj);
>-  Object *lookupNF(const UGooString &key, Object *obj);
>-  GBool lookupInt(const char *key, const char *alt_key, int *value);
>+  Object *lookup(const UGooString &key, Object *obj) const;
>+  Object *lookupNF(const UGooString &key, Object *obj) const;
>+  Object *lookupRefNoFetch(const UGooString &key) const;
>+  Object *lookup(const char *key, Object *obj, int keyLen=UGooString::CALC_STRING_LEN) const;
>+  Object *lookupNF(const char *key, Object *obj, int keyLen=UGooString::CALC_STRING_LEN) const;
>+  Object *lookupRefNoFetch(const char *key, int keyLen=UGooString::CALC_STRING_LEN) const;
> 
>+  GBool lookupBool(const char *key, const char *alt_key, GBool *value) const;
>+  GBool lookupInt(const char *key, const char *alt_key, int *value) const;
>+
>   // Iterative accessors.
>-  UGooString *getKey(int i);
>-  Object *getVal(int i, Object *obj);
>-  Object *getValNF(int i, Object *obj);
>+  UGooString *getKey(int i) const;
>+  Object *getVal(int i, Object *obj) const;
>+  Object *getValNF(int i, Object *obj) const;
> 
>   // Set the xref pointer.  This is only used in one special case: the
>   // trailer dictionary, which is read before the xref table is
>@@ -71,7 +75,8 @@
>   int length;			// number of entries in dictionary
>   int ref;			// reference count
> 
>-  DictEntry *find(const UGooString &key);
>+  DictEntry *find(const UGooString &key) const;
>+  DictEntry *find(const char *key, int keyLen) const;
> };
> 
> #endif

Actions: View | Splinter Review

Attachments on bug 8111: 6796

Use of freedesktop.org services, including Bugzilla, is subject to our Code of Conduct. How we collect and use information is described in our Privacy Policy.