From 7790808560d3f9e091168098b9cbf8dbc4a9ccfe Mon Sep 17 00:00:00 2001
From: "yusuke.shinyama.dummy"
 <yusuke.shinyama.dummy@1aa58f4a-7d42-0410-adbc-911cccaed67c>
Date: Sat, 24 Oct 2009 04:41:59 +0000
Subject: [PATCH] to 4-space indentation

git-svn-id: https://pdfminerr.googlecode.com/svn/trunk/pdfminer@142 1aa58f4a-7d42-0410-adbc-911cccaed67c
---
 docs/index.html         |    4 +-
 pdfminer/arcfour.py     |   60 +-
 pdfminer/ascii85.py     |  120 ++--
 pdfminer/cmap.py        |  764 +++++++++++-----------
 pdfminer/converter.py   |  520 +++++++--------
 pdfminer/fontmetrics.py |    4 +-
 pdfminer/layout.py      |  742 ++++++++++-----------
 pdfminer/lzw.py         |  168 ++---
 pdfminer/pdfcolor.py    |   16 +-
 pdfminer/pdfdevice.py   |  186 +++---
 pdfminer/pdffont.py     |  980 ++++++++++++++--------------
 pdfminer/pdfinterp.py   | 1362 +++++++++++++++++++--------------------
 pdfminer/pdfparser.py   | 1188 +++++++++++++++++-----------------
 pdfminer/pdftypes.py    |  360 +++++------
 pdfminer/psparser.py    | 1030 ++++++++++++++---------------
 pdfminer/pycdb.py       |  758 +++++++++++-----------
 pdfminer/rijndael.py    |  642 +++++++++---------
 pdfminer/utils.py       |  130 ++--
 setup.py                |   30 +-
 tools/conv_afm.py       |   66 +-
 tools/dumppdf.py        |  276 ++++----
 tools/pdf2html.cgi      |  292 ++++-----
 tools/pdf2txt.py        |  158 ++---
 tools/prof.py           |   50 +-
 24 files changed, 4953 insertions(+), 4953 deletions(-)

diff --git a/docs/index.html b/docs/index.html
index 98fdb38..9dc43b6 100644
--- a/docs/index.html
+++ b/docs/index.html
@@ -18,7 +18,7 @@ Python PDF parser and analyzer
 
 <div align=right class=lastmod>
 <!-- hhmts start -->
-Last Modified: Sat Oct 24 12:42:25 JST 2009
+Last Modified: Sat Oct 24 13:40:19 JST 2009
 <!-- hhmts end -->
 </div>
 
@@ -352,7 +352,7 @@ no stream header is displayed for the ease of saving it to a file.
 <hr noshade>
 <h2>Changes</h2>
 <ul>
-<li> 2009/10/24: Charspace bug fixed.
+<li> 2009/10/24: Charspace bug fixed. Adjusted for 4-space indentation.
 <li> 2009/10/04: Another matrix operation bug fixed. Thanks to Vitaly Sedelnik.
 <li> 2009/09/12: Fixed rectangle handling. Able to extract image boundaries.
 <li> 2009/08/30: Fixed page rotation handling.
diff --git a/pdfminer/arcfour.py b/pdfminer/arcfour.py
index a8034d6..22c2242 100644
--- a/pdfminer/arcfour.py
+++ b/pdfminer/arcfour.py
@@ -8,37 +8,37 @@
 ##  Arcfour
 ##
 class Arcfour(object):
-  
-  def __init__(self, key):
-    s = range(256)
-    j = 0
-    klen = len(key)
-    for i in xrange(256):
-      j = (j + s[i] + ord(key[i % klen])) % 256
-      (s[i], s[j]) = (s[j], s[i])
-    self.s = s
-    (self.i, self.j) = (0, 0)
-    return
 
-  def process(self, data):
-    (i, j) = (self.i, self.j)
-    s = self.s
-    r = ''
-    for c in data:
-      i = (i+1) % 256
-      j = (j+s[i]) % 256
-      (s[i], s[j]) = (s[j], s[i])
-      k = s[(s[i]+s[j]) % 256]
-      r += chr(ord(c) ^ k)
-    (self.i, self.j) = (i, j)
-    return r
+    def __init__(self, key):
+        s = range(256)
+        j = 0
+        klen = len(key)
+        for i in xrange(256):
+            j = (j + s[i] + ord(key[i % klen])) % 256
+            (s[i], s[j]) = (s[j], s[i])
+        self.s = s
+        (self.i, self.j) = (0, 0)
+        return
+
+    def process(self, data):
+        (i, j) = (self.i, self.j)
+        s = self.s
+        r = ''
+        for c in data:
+            i = (i+1) % 256
+            j = (j+s[i]) % 256
+            (s[i], s[j]) = (s[j], s[i])
+            k = s[(s[i]+s[j]) % 256]
+            r += chr(ord(c) ^ k)
+        (self.i, self.j) = (i, j)
+        return r
 
 # test
 if __name__ == '__main__':
-  def doit(key, data):
-    cipher = Arcfour(key)
-    return ''.join( '%02X' % ord(c) for c in cipher.process(data) )
-  assert doit("Key", "Plaintext") == 'BBF316E8D940AF0AD3'
-  assert doit("Wiki", "pedia") == '1021BF0420'
-  assert doit("Secret", "Attack at dawn") == '45A01F645FC35B383552544B9BF5'
-  print 'test succeeded'
+    def doit(key, data):
+        cipher = Arcfour(key)
+        return ''.join( '%02X' % ord(c) for c in cipher.process(data) )
+    assert doit("Key", "Plaintext") == 'BBF316E8D940AF0AD3'
+    assert doit("Wiki", "pedia") == '1021BF0420'
+    assert doit("Secret", "Attack at dawn") == '45A01F645FC35B383552544B9BF5'
+    print 'test succeeded'
diff --git a/pdfminer/ascii85.py b/pdfminer/ascii85.py
index 16ddb41..441abc7 100644
--- a/pdfminer/ascii85.py
+++ b/pdfminer/ascii85.py
@@ -6,72 +6,72 @@
 
 # ascii85decode(data)
 def ascii85decode(data):
-  import struct
-  n = b = 0
-  out = ''
-  for c in data:
-    if '!' <= c and c <= 'u':
-      n += 1
-      b = b*85+(ord(c)-33)
-      if n == 5:
-        out += struct.pack('>L',b)
-        n = b = 0
-    elif c == 'z':
-      assert n == 0
-      out += '\0\0\0\0'
-    elif c == '~':
-      if n:
-        for _ in range(5-n):
-          b = b*85+84
-        out += struct.pack('>L',b)[:n-1]
-      break
-  return out
+    import struct
+    n = b = 0
+    out = ''
+    for c in data:
+        if '!' <= c and c <= 'u':
+            n += 1
+            b = b*85+(ord(c)-33)
+            if n == 5:
+                out += struct.pack('>L',b)
+                n = b = 0
+        elif c == 'z':
+            assert n == 0
+            out += '\0\0\0\0'
+        elif c == '~':
+            if n:
+                for _ in range(5-n):
+                    b = b*85+84
+                out += struct.pack('>L',b)[:n-1]
+            break
+    return out
 
 # asciihexdecode(data)
 def asciihexdecode(data):
-  """
-  ASCIIHexDecode filter: PDFReference v1.4 section 3.3.1
-  For each pair of ASCII hexadecimal digits (0-9 and A-F or a-f), the
-  ASCIIHexDecode filter produces one byte of binary data. All white-space
-  characters are ignored. A right angle bracket character (>) indicates
-  EOD. Any other characters will cause an error. If the filter encounters
-  the EOD marker after reading an odd number of hexadecimal digits, it
-  will behave as if a 0 followed the last digit.
-  >>> asciihexdecode("61 62 2e6364   65")
-  'ab.cde'
-  >>> asciihexdecode("61 62 2e6364   657>")
-  'ab.cdep'
-  >>> asciihexdecode("7>")
-  'p'
-  """
-  import re
-  hex_re = re.compile(r'([a-f\d]{2})', re.IGNORECASE)
-  trail_re = re.compile(r'^(?:[a-f\d]{2}|\s)*([a-f\d])[\s>]*$', re.IGNORECASE)
-  decode = (lambda hx: chr(int(hx, 16)))
-  out = map(decode, hex_re.findall(data))
-  m = trail_re.search(data)
-  if m:
-    out.append(decode("%c0" % m.group(1)))
-  return ''.join(out)
+    """
+    ASCIIHexDecode filter: PDFReference v1.4 section 3.3.1
+    For each pair of ASCII hexadecimal digits (0-9 and A-F or a-f), the
+    ASCIIHexDecode filter produces one byte of binary data. All white-space
+    characters are ignored. A right angle bracket character (>) indicates
+    EOD. Any other characters will cause an error. If the filter encounters
+    the EOD marker after reading an odd number of hexadecimal digits, it
+    will behave as if a 0 followed the last digit.
+    >>> asciihexdecode("61 62 2e6364   65")
+    'ab.cde'
+    >>> asciihexdecode("61 62 2e6364   657>")
+    'ab.cdep'
+    >>> asciihexdecode("7>")
+    'p'
+    """
+    import re
+    hex_re = re.compile(r'([a-f\d]{2})', re.IGNORECASE)
+    trail_re = re.compile(r'^(?:[a-f\d]{2}|\s)*([a-f\d])[\s>]*$', re.IGNORECASE)
+    decode = (lambda hx: chr(int(hx, 16)))
+    out = map(decode, hex_re.findall(data))
+    m = trail_re.search(data)
+    if m:
+        out.append(decode("%c0" % m.group(1)))
+    return ''.join(out)
 
 
 # test
 # sample taken from: http://en.wikipedia.org/w/index.php?title=Ascii85
 if __name__ == '__main__':
-  orig = r'''
-  9jqo^BlbD-BleB1DJ+*+F(f,q/0JhKF<GL>Cj@.4Gp$d7F!,L7@<6@)/0JDEF<G%<+EV:2F!,
-  O<DJ+*.@<*K0@<6L(Df-\0Ec5e;DffZ(EZee.Bl.9pF"AGXBPCsi+DGm>@3BB/F*&OCAfu2/AKY
-  i(DIb:@FD,*)+C]U=@3BN#EcYf8ATD3s@q?d$AftVqCh[NqF<G:8+EV:.+Cf>-FD5W8ARlolDIa
-  l(DId<j@<?3r@:F%a+D58'ATD4$Bl@l3De:,-DJs`8ARoFb/0JMK@qB4^F!,R<AKZ&-DfTqBG%G
-  >uD.RTpAKYo'+CT/5+Cei#DII?(E,9)oF*2M7/c~>
-  '''
-  data = \
-       'Man is distinguished, not only by his reason, but by this singular passion from '\
-       'other animals, which is a lust of the mind, that by a perseverance of delight in the '\
-       'continued and indefatigable generation of knowledge, exceeds the short vehemence of '\
-       'any carnal pleasure.'
-  assert ascii85decode(orig) == data
-  print 'ascii85decode test succeeded'
+    orig = r'''
+    9jqo^BlbD-BleB1DJ+*+F(f,q/0JhKF<GL>Cj@.4Gp$d7F!,L7@<6@)/0JDEF<G%<+EV:2F!,
+    O<DJ+*.@<*K0@<6L(Df-\0Ec5e;DffZ(EZee.Bl.9pF"AGXBPCsi+DGm>@3BB/F*&OCAfu2/AKY
+    i(DIb:@FD,*)+C]U=@3BN#EcYf8ATD3s@q?d$AftVqCh[NqF<G:8+EV:.+Cf>-FD5W8ARlolDIa
+    l(DId<j@<?3r@:F%a+D58'ATD4$Bl@l3De:,-DJs`8ARoFb/0JMK@qB4^F!,R<AKZ&-DfTqBG%G
+    >uD.RTpAKYo'+CT/5+Cei#DII?(E,9)oF*2M7/c~>
+    '''
+    data = \
+         'Man is distinguished, not only by his reason, but by this singular passion from '\
+         'other animals, which is a lust of the mind, that by a perseverance of delight in the '\
+         'continued and indefatigable generation of knowledge, exceeds the short vehemence of '\
+         'any carnal pleasure.'
+    assert ascii85decode(orig) == data
+    print 'ascii85decode test succeeded'
 
-  import doctest
-  doctest.testmod()
+    import doctest
+    doctest.testmod()
diff --git a/pdfminer/cmap.py b/pdfminer/cmap.py
index 8f0731f..0356247 100644
--- a/pdfminer/cmap.py
+++ b/pdfminer/cmap.py
@@ -10,9 +10,9 @@ from pdfminer.psparser import PSException, PSSyntaxError, PSTypeError, PSEOF, \
      PSLiteral, PSKeyword, literal_name, keyword_name, \
      PSStackParser
 try:
-  import cdb
+    import cdb
 except ImportError:
-  import pdfminer.pycdb as cdb
+    import pdfminer.pycdb as cdb
 
 
 class CMapError(Exception): pass
@@ -21,449 +21,449 @@ class CMapError(Exception): pass
 ##  find_cmap_path
 ##
 def find_cmap_path():
-  try:
-    return os.environ['CMAP_PATH']
-  except KeyError:
-    pass
-  basedir = os.path.dirname(__file__)
-  return os.path.join(basedir, 'CMap')
+    try:
+        return os.environ['CMAP_PATH']
+    except KeyError:
+        pass
+    basedir = os.path.dirname(__file__)
+    return os.path.join(basedir, 'CMap')
 
 
 STRIP_NAME = re.compile(r'[0-9]+')
 def name2unicode(name):
-  if name in charname2unicode:
-    return charname2unicode[name]
-  m = STRIP_NAME.search(name)
-  if not m: raise KeyError(name)
-  return int(m.group(0))
+    if name in charname2unicode:
+        return charname2unicode[name]
+    m = STRIP_NAME.search(name)
+    if not m: raise KeyError(name)
+    return int(m.group(0))
 
 
 ##  CMap
 ##
 class CMap(object):
 
-  debug = 0
-  
-  def __init__(self):
-    self.code2cid = {}
-    self.cid2code = {}
-    self.attrs = {}
-    return
+    debug = 0
 
-  def __repr__(self):
-    return '<CMap: %s>' % self.attrs.get('CMapName')
+    def __init__(self):
+        self.code2cid = {}
+        self.cid2code = {}
+        self.attrs = {}
+        return
 
-  def update(self, code2cid=None, cid2code=None):
-    if code2cid:
-      self.code2cid.update(code2cid)
-    if cid2code:
-      self.cid2code.update(cid2code)
-    return self
-    
-  def copycmap(self, cmap):
-    self.code2cid.update(cmap.getall_code2cid())
-    self.cid2code.update(cmap.getall_cid2code())
-    return self
+    def __repr__(self):
+        return '<CMap: %s>' % self.attrs.get('CMapName')
 
-  def register_code2cid(self, code, cid):
-    if isinstance(code, str) and isinstance(cid, int):
-      self.code2cid[code] = cid
-    return self
+    def update(self, code2cid=None, cid2code=None):
+        if code2cid:
+            self.code2cid.update(code2cid)
+        if cid2code:
+            self.cid2code.update(cid2code)
+        return self
 
-  def register_cid2code(self, cid, code):
-    if isinstance(cid, int):
-      if isinstance(code, PSLiteral):
-        self.cid2code[cid] = pack('>H', name2unicode(code.name))
-      elif isinstance(code, str):
-        self.cid2code[cid] = code
-    return self
+    def copycmap(self, cmap):
+        self.code2cid.update(cmap.getall_code2cid())
+        self.cid2code.update(cmap.getall_cid2code())
+        return self
 
-  def decode(self, bytes):
-    if self.debug:
-      print >>stderr, 'decode: %r, %r' % (self, bytes)
-    x = ''
-    for c in bytes:
-      if x:
-        if x+c in self.code2cid:
-          yield self.code2cid[x+c]
+    def register_code2cid(self, code, cid):
+        if isinstance(code, str) and isinstance(cid, int):
+            self.code2cid[code] = cid
+        return self
+
+    def register_cid2code(self, cid, code):
+        if isinstance(cid, int):
+            if isinstance(code, PSLiteral):
+                self.cid2code[cid] = pack('>H', name2unicode(code.name))
+            elif isinstance(code, str):
+                self.cid2code[cid] = code
+        return self
+
+    def decode(self, bytes):
+        if self.debug:
+            print >>stderr, 'decode: %r, %r' % (self, bytes)
         x = ''
-      elif c in self.code2cid:
-        yield self.code2cid[c]
-      else:
-        x = c
-    return
-  
-  def is_vertical(self):
-    return self.attrs.get('WMode', 0)
+        for c in bytes:
+            if x:
+                if x+c in self.code2cid:
+                    yield self.code2cid[x+c]
+                x = ''
+            elif c in self.code2cid:
+                yield self.code2cid[c]
+            else:
+                x = c
+        return
 
-  def tocid(self, code):
-    return self.code2cid.get(code)
-  def tocode(self, cid):
-    return self.cid2code.get(cid)
+    def is_vertical(self):
+        return self.attrs.get('WMode', 0)
+
+    def tocid(self, code):
+        return self.code2cid.get(code)
+    def tocode(self, cid):
+        return self.cid2code.get(cid)
+
+    def getall_attrs(self):
+        return self.attrs.iteritems()
+    def getall_code2cid(self):
+        return self.code2cid.iteritems()
+    def getall_cid2code(self):
+        return self.cid2code.iteritems()
 
-  def getall_attrs(self):
-    return self.attrs.iteritems()
-  def getall_code2cid(self):
-    return self.code2cid.iteritems()
-  def getall_cid2code(self):
-    return self.cid2code.iteritems()
 
-  
 ##  CDBCMap
 ##
 class CDBCMap(CMap):
-  
-  def __init__(self, cdbname):
-    CMap.__init__(self)
-    self.cdbname = cdbname
-    self.db = cdb.init(cdbname)
-    return
 
-  def __repr__(self):
-    return '<CDBCMap: %s (%r)>' % (self.db['/CMapName'], self.cdbname)
+    def __init__(self, cdbname):
+        CMap.__init__(self)
+        self.cdbname = cdbname
+        self.db = cdb.init(cdbname)
+        return
 
-  def tocid(self, code):
-    k = 'c'+code
-    if not self.db.has_key(k):
-      return None
-    return unpack('>L', self.db[k])
-  def tocode(self, cid):
-    k = 'i'+pack('>L', cid)
-    if not self.db.has_key(k):
-      return None
-    return self.db[k]
-  
-  def is_vertical(self):
-    return (self.db.has_key('/WMode') and
-            self.db['/WMode'] == '1')
+    def __repr__(self):
+        return '<CDBCMap: %s (%r)>' % (self.db['/CMapName'], self.cdbname)
 
-  def getall(self, c):
-    while 1:
-      x = self.db.each()
-      if not x: break
-      (k,v) = x
-      if k.startswith(c):
-        yield (k[1:], unpack('>L', v)[0])
-    return
+    def tocid(self, code):
+        k = 'c'+code
+        if not self.db.has_key(k):
+            return None
+        return unpack('>L', self.db[k])
+    def tocode(self, cid):
+        k = 'i'+pack('>L', cid)
+        if not self.db.has_key(k):
+            return None
+        return self.db[k]
 
-  def getall_attrs(self):
-    while 1:
-      x = self.db.each()
-      if not x: break
-      (k,v) = x
-      if k.startswith('/'):
-        yield (k[1:], eval(v)[0])
-    return
-  
-  def getall_cid2code(self):
-    return self.getall('i')
-  def getall_code2cid(self):
-    return self.getall('c')
+    def is_vertical(self):
+        return (self.db.has_key('/WMode') and
+                self.db['/WMode'] == '1')
 
-  def decode(self, bytes):
-    if self.debug:
-      print >>stderr, 'decode: %r, %r' % (self, bytes)
-    x = ''
-    for c in bytes:
-      if x:
-        if x+c in self.code2cid:
-          yield self.code2cid[x+c]
-        elif self.db.has_key('c'+x+c):
-          (dest,) = unpack('>L', self.db['c'+x+c])
-          self.code2cid[x+c] = dest
-          yield dest
+    def getall(self, c):
+        while 1:
+            x = self.db.each()
+            if not x: break
+            (k,v) = x
+            if k.startswith(c):
+                yield (k[1:], unpack('>L', v)[0])
+        return
+
+    def getall_attrs(self):
+        while 1:
+            x = self.db.each()
+            if not x: break
+            (k,v) = x
+            if k.startswith('/'):
+                yield (k[1:], eval(v)[0])
+        return
+
+    def getall_cid2code(self):
+        return self.getall('i')
+    def getall_code2cid(self):
+        return self.getall('c')
+
+    def decode(self, bytes):
+        if self.debug:
+            print >>stderr, 'decode: %r, %r' % (self, bytes)
         x = ''
-      elif c in self.code2cid:
-        yield self.code2cid[c]
-      elif self.db.has_key('c'+c):
-        (dest,) = unpack('>L', self.db['c'+c])
-        self.code2cid[c] = dest
-        yield dest
-      else:
-        x = c
-    return
+        for c in bytes:
+            if x:
+                if x+c in self.code2cid:
+                    yield self.code2cid[x+c]
+                elif self.db.has_key('c'+x+c):
+                    (dest,) = unpack('>L', self.db['c'+x+c])
+                    self.code2cid[x+c] = dest
+                    yield dest
+                x = ''
+            elif c in self.code2cid:
+                yield self.code2cid[c]
+            elif self.db.has_key('c'+c):
+                (dest,) = unpack('>L', self.db['c'+c])
+                self.code2cid[c] = dest
+                yield dest
+            else:
+                x = c
+        return
 
 
 ##  CMapDB
 ##
 class CMapDB(object):
 
-  class CMapNotFound(CMapError): pass
-  
-  CMAP_ALIAS = {
-    }
-  
-  debug = 0
-  dirname = None
-  cdbdirname = None
-  cmapdb = {}
+    class CMapNotFound(CMapError): pass
 
-  @classmethod
-  def initialize(klass, dirname=None, cdbdirname=None):
-    if not dirname:
-      dirname = find_cmap_path()
-    klass.dirname = dirname
-    klass.cdbdirname = cdbdirname or dirname
-    return
+    CMAP_ALIAS = {
+      }
 
-  @classmethod
-  def get_cmap(klass, cmapname, strict=True):
-    cmapname = klass.CMAP_ALIAS.get(cmapname, cmapname)
-    if cmapname in klass.cmapdb:
-      cmap = klass.cmapdb[cmapname]
-    else:
-      fname = os.path.join(klass.dirname, cmapname)
-      cdbname = os.path.join(klass.cdbdirname, cmapname+'.cmap.cdb')
-      if os.path.exists(cdbname):
-        if 1 <= klass.debug:
-          print >>stderr, 'Opening: CDBCMap %r...' % cdbname
-        cmap = CDBCMap(cdbname)
-      elif os.path.exists(fname):
-        if 1 <= klass.debug:
-          print >>stderr, 'Reading: CMap %r...' % fname
-        cmap = CMap()
-        fp = file(fname, 'rb')
-        CMapParser(cmap, fp).run()
-        fp.close()
-      elif not strict:
-        cmap = CMap() # just create empty cmap
-      else:
-        raise CMapDB.CMapNotFound(cmapname)
-      klass.cmapdb[cmapname] = cmap
-    return cmap
+    debug = 0
+    dirname = None
+    cdbdirname = None
+    cmapdb = {}
+
+    @classmethod
+    def initialize(klass, dirname=None, cdbdirname=None):
+        if not dirname:
+            dirname = find_cmap_path()
+        klass.dirname = dirname
+        klass.cdbdirname = cdbdirname or dirname
+        return
+
+    @classmethod
+    def get_cmap(klass, cmapname, strict=True):
+        cmapname = klass.CMAP_ALIAS.get(cmapname, cmapname)
+        if cmapname in klass.cmapdb:
+            cmap = klass.cmapdb[cmapname]
+        else:
+            fname = os.path.join(klass.dirname, cmapname)
+            cdbname = os.path.join(klass.cdbdirname, cmapname+'.cmap.cdb')
+            if os.path.exists(cdbname):
+                if 1 <= klass.debug:
+                    print >>stderr, 'Opening: CDBCMap %r...' % cdbname
+                cmap = CDBCMap(cdbname)
+            elif os.path.exists(fname):
+                if 1 <= klass.debug:
+                    print >>stderr, 'Reading: CMap %r...' % fname
+                cmap = CMap()
+                fp = file(fname, 'rb')
+                CMapParser(cmap, fp).run()
+                fp.close()
+            elif not strict:
+                cmap = CMap() # just create empty cmap
+            else:
+                raise CMapDB.CMapNotFound(cmapname)
+            klass.cmapdb[cmapname] = cmap
+        return cmap
 
 
 ##  CMapParser
 ##
 class CMapParser(PSStackParser):
 
-  def __init__(self, cmap, fp):
-    PSStackParser.__init__(self, fp)
-    self.cmap = cmap
-    self.in_cmap = False
-    return
+    def __init__(self, cmap, fp):
+        PSStackParser.__init__(self, fp)
+        self.cmap = cmap
+        self.in_cmap = False
+        return
 
-  def run(self):
-    try:
-      self.nextobject()
-    except PSEOF:
-      pass
-    return
+    def run(self):
+        try:
+            self.nextobject()
+        except PSEOF:
+            pass
+        return
 
-  def do_keyword(self, pos, token):
-    name = token.name
-    if name == 'begincmap':
-      self.in_cmap = True
-      self.popall()
-      return
-    elif name == 'endcmap':
-      self.in_cmap = False
-      return
-    if not self.in_cmap: return
-    #
-    if name == 'def':
-      try:
-        ((_,k),(_,v)) = self.pop(2)
-        self.cmap.attrs[literal_name(k)] = v
-      except PSSyntaxError:
-        pass
-      return
-    
-    if name == 'usecmap':
-      try:
-        ((_,cmapname),) = self.pop(1)
-        self.cmap.copycmap(CMapDB.get_cmap(literal_name(cmapname)))
-      except PSSyntaxError:
-        pass
-      return
-      
-    if name == 'begincodespacerange':
-      self.popall()
-      return
-    if name == 'endcodespacerange':
-      self.popall()
-      return
-    
-    if name == 'begincidrange':
-      self.popall()
-      return
-    if name == 'endcidrange':
-      objs = [ obj for (_,obj) in self.popall() ]
-      for (s,e,cid) in choplist(3, objs):
-        if (not isinstance(s, str) or not isinstance(e, str) or
-            not isinstance(cid, int) or len(s) != len(e)): continue
-        sprefix = s[:-4]
-        eprefix = e[:-4]
-        if sprefix != eprefix: continue
-        svar = s[-4:]
-        evar = e[-4:]
-        s1 = nunpack(svar)
-        e1 = nunpack(evar)
-        vlen = len(svar)
-        #assert s1 <= e1
-        for i in xrange(e1-s1+1):
-          x = sprefix+pack('>L',s1+i)[-vlen:]
-          self.cmap.register_code2cid(x, cid+i)
-      return
-    
-    if name == 'begincidchar':
-      self.popall()
-      return
-    if name == 'endcidchar':
-      objs = [ obj for (_,obj) in self.popall() ]
-      for (cid,code) in choplist(2, objs):
-        if isinstance(code, str) and isinstance(cid, str):
-          self.cmap.register_code2cid(code, nunpack(cid))
-      return
-        
-    if name == 'beginbfrange':
-      self.popall()
-      return
-    if name == 'endbfrange':
-      objs = [ obj for (_,obj) in self.popall() ]
-      for (s,e,code) in choplist(3, objs):
-        if (not isinstance(s, str) or not isinstance(e, str) or
-            len(s) != len(e)): continue
-        s1 = nunpack(s)
-        e1 = nunpack(e)
-        #assert s1 <= e1
-        if isinstance(code, list):
-          for i in xrange(e1-s1+1):
-            self.cmap.register_cid2code(s1+i, code[i])
-        else:
-          var = code[-4:]
-          base = nunpack(var)
-          prefix = code[:-4]
-          vlen = len(var)
-          for i in xrange(e1-s1+1):
-            x = prefix+pack('>L',base+i)[-vlen:]
-            self.cmap.register_cid2code(s1+i, x)
-      return
-        
-    if name == 'beginbfchar':
-      self.popall()
-      return
-    if name == 'endbfchar':
-      objs = [ obj for (_,obj) in self.popall() ]
-      for (cid,code) in choplist(2, objs):
-        if isinstance(cid, str) and isinstance(code, str):
-          self.cmap.register_cid2code(nunpack(cid), code)
-      return
-        
-    if name == 'beginnotdefrange':
-      self.popall()
-      return
-    if name == 'endnotdefrange':
-      self.popall()
-      return
+    def do_keyword(self, pos, token):
+        name = token.name
+        if name == 'begincmap':
+            self.in_cmap = True
+            self.popall()
+            return
+        elif name == 'endcmap':
+            self.in_cmap = False
+            return
+        if not self.in_cmap: return
+        #
+        if name == 'def':
+            try:
+                ((_,k),(_,v)) = self.pop(2)
+                self.cmap.attrs[literal_name(k)] = v
+            except PSSyntaxError:
+                pass
+            return
 
-    self.push((pos, token))
-    return
+        if name == 'usecmap':
+            try:
+                ((_,cmapname),) = self.pop(1)
+                self.cmap.copycmap(CMapDB.get_cmap(literal_name(cmapname)))
+            except PSSyntaxError:
+                pass
+            return
+
+        if name == 'begincodespacerange':
+            self.popall()
+            return
+        if name == 'endcodespacerange':
+            self.popall()
+            return
+
+        if name == 'begincidrange':
+            self.popall()
+            return
+        if name == 'endcidrange':
+            objs = [ obj for (_,obj) in self.popall() ]
+            for (s,e,cid) in choplist(3, objs):
+                if (not isinstance(s, str) or not isinstance(e, str) or
+                    not isinstance(cid, int) or len(s) != len(e)): continue
+                sprefix = s[:-4]
+                eprefix = e[:-4]
+                if sprefix != eprefix: continue
+                svar = s[-4:]
+                evar = e[-4:]
+                s1 = nunpack(svar)
+                e1 = nunpack(evar)
+                vlen = len(svar)
+                #assert s1 <= e1
+                for i in xrange(e1-s1+1):
+                    x = sprefix+pack('>L',s1+i)[-vlen:]
+                    self.cmap.register_code2cid(x, cid+i)
+            return
+
+        if name == 'begincidchar':
+            self.popall()
+            return
+        if name == 'endcidchar':
+            objs = [ obj for (_,obj) in self.popall() ]
+            for (cid,code) in choplist(2, objs):
+                if isinstance(code, str) and isinstance(cid, str):
+                    self.cmap.register_code2cid(code, nunpack(cid))
+            return
+
+        if name == 'beginbfrange':
+            self.popall()
+            return
+        if name == 'endbfrange':
+            objs = [ obj for (_,obj) in self.popall() ]
+            for (s,e,code) in choplist(3, objs):
+                if (not isinstance(s, str) or not isinstance(e, str) or
+                    len(s) != len(e)): continue
+                s1 = nunpack(s)
+                e1 = nunpack(e)
+                #assert s1 <= e1
+                if isinstance(code, list):
+                    for i in xrange(e1-s1+1):
+                        self.cmap.register_cid2code(s1+i, code[i])
+                else:
+                    var = code[-4:]
+                    base = nunpack(var)
+                    prefix = code[:-4]
+                    vlen = len(var)
+                    for i in xrange(e1-s1+1):
+                        x = prefix+pack('>L',base+i)[-vlen:]
+                        self.cmap.register_cid2code(s1+i, x)
+            return
+
+        if name == 'beginbfchar':
+            self.popall()
+            return
+        if name == 'endbfchar':
+            objs = [ obj for (_,obj) in self.popall() ]
+            for (cid,code) in choplist(2, objs):
+                if isinstance(cid, str) and isinstance(code, str):
+                    self.cmap.register_cid2code(nunpack(cid), code)
+            return
+
+        if name == 'beginnotdefrange':
+            self.popall()
+            return
+        if name == 'endnotdefrange':
+            self.popall()
+            return
+
+        self.push((pos, token))
+        return
 
 
 ##  FontMetricsDB
 ##
 class FontMetricsDB(object):
-  
-  @classmethod
-  def get_metrics(klass, fontname):
-    return FONT_METRICS[fontname]
+
+    @classmethod
+    def get_metrics(klass, fontname):
+        return FONT_METRICS[fontname]
 
 
 ##  EncodingDB
 ##
 class EncodingDB(object):
-      
-  std2unicode = {}
-  mac2unicode = {}
-  win2unicode = {}
-  pdf2unicode = {}
-  for (name,std,mac,win,pdf) in ENCODING:
-    c = unichr(name2unicode(name))
-    if std: std2unicode[std] = c
-    if mac: mac2unicode[mac] = c
-    if win: win2unicode[win] = c
-    if pdf: pdf2unicode[pdf] = c
-  
-  encodings = {
-    'StandardEncoding': std2unicode,
-    'MacRomanEncoding': mac2unicode,
-    'WinAnsiEncoding': win2unicode,
-    'PDFDocEncoding': pdf2unicode,
-    }
-  
-  @classmethod
-  def get_encoding(klass, name, diff=None):
-    cid2unicode = klass.encodings.get(name, klass.std2unicode)
-    if diff:
-      cid2unicode = cid2unicode.copy()
-      cid = 0
-      for x in diff:
-        if isinstance(x, int):
-          cid = x
-        elif isinstance(x, PSLiteral):
-          try:
-            cid2unicode[cid] = unichr(name2unicode(x.name))
-          except KeyError:
-            pass
-          cid += 1
-    return cid2unicode
+
+    std2unicode = {}
+    mac2unicode = {}
+    win2unicode = {}
+    pdf2unicode = {}
+    for (name,std,mac,win,pdf) in ENCODING:
+        c = unichr(name2unicode(name))
+        if std: std2unicode[std] = c
+        if mac: mac2unicode[mac] = c
+        if win: win2unicode[win] = c
+        if pdf: pdf2unicode[pdf] = c
+
+    encodings = {
+      'StandardEncoding': std2unicode,
+      'MacRomanEncoding': mac2unicode,
+      'WinAnsiEncoding': win2unicode,
+      'PDFDocEncoding': pdf2unicode,
+      }
+
+    @classmethod
+    def get_encoding(klass, name, diff=None):
+        cid2unicode = klass.encodings.get(name, klass.std2unicode)
+        if diff:
+            cid2unicode = cid2unicode.copy()
+            cid = 0
+            for x in diff:
+                if isinstance(x, int):
+                    cid = x
+                elif isinstance(x, PSLiteral):
+                    try:
+                        cid2unicode[cid] = unichr(name2unicode(x.name))
+                    except KeyError:
+                        pass
+                    cid += 1
+        return cid2unicode
 
 
 ##  CMap -> CMapCDB conversion
 ##
 def dumpcdb(cmap, cdbfile, verbose=1):
-  m = cdb.cdbmake(cdbfile, cdbfile+'.tmp')
-  if verbose:
-    print >>stderr, 'Writing: %r...' % cdbfile
-  for (k,v) in cmap.getall_attrs():
-    m.add('/'+k, repr(v))
-  for (code,cid) in cmap.getall_code2cid():
-    m.add('c'+code, pack('>L',cid))
-  for (cid,code) in cmap.getall_cid2code():
-    m.add('i'+pack('>L',cid), code)
-  m.finish()
-  return
+    m = cdb.cdbmake(cdbfile, cdbfile+'.tmp')
+    if verbose:
+        print >>stderr, 'Writing: %r...' % cdbfile
+    for (k,v) in cmap.getall_attrs():
+        m.add('/'+k, repr(v))
+    for (code,cid) in cmap.getall_code2cid():
+        m.add('c'+code, pack('>L',cid))
+    for (cid,code) in cmap.getall_cid2code():
+        m.add('i'+pack('>L',cid), code)
+    m.finish()
+    return
 
 def convert_cmap(cmapdir, outputdir, force=False):
-  CMapDB.initialize(cmapdir)
-  for fname in os.listdir(cmapdir):
-    if '.' in fname: continue
-    cmapname = os.path.basename(fname)
-    cdbname = os.path.join(outputdir, cmapname+'.cmap.cdb')
-    if not force and os.path.exists(cdbname):
-      print >>stderr, 'Skipping: %r' % cmapname
-      continue
-    print >>stderr, 'Reading: %r...' % cmapname
-    cmap = CMapDB.get_cmap(cmapname)
-    dumpcdb(cmap, cdbname)
-  return
+    CMapDB.initialize(cmapdir)
+    for fname in os.listdir(cmapdir):
+        if '.' in fname: continue
+        cmapname = os.path.basename(fname)
+        cdbname = os.path.join(outputdir, cmapname+'.cmap.cdb')
+        if not force and os.path.exists(cdbname):
+            print >>stderr, 'Skipping: %r' % cmapname
+            continue
+        print >>stderr, 'Reading: %r...' % cmapname
+        cmap = CMapDB.get_cmap(cmapname)
+        dumpcdb(cmap, cdbname)
+    return
 
 def main(argv):
-  import getopt
-  def usage():
-    print 'usage: %s [-D outputdir] [-f] cmap_dir' % argv[0]
-    return 100
-  try:
-    (opts, args) = getopt.getopt(argv[1:], 'C:D:f')
-  except getopt.GetoptError:
-    return usage()
-  if args:
-    cmapdir = args.pop(0)
-  else:
-    cmapdir = find_cmap_path()
-  outputdir = cmapdir
-  force = False
-  for (k, v) in opts:
-    if k == '-f': force = True
-    elif k == '-C': cmapdir = v
-    elif k == '-D': outputdir = v
-  if not os.path.isdir(cmapdir):
-    print >>stderr, 'directory does not exist: %r' % cmapdir
-    return 111
-  if not os.path.isdir(outputdir):
-    print >>stderr, 'directory does not exist: %r' % outputdir
-    return 111
-  return convert_cmap(cmapdir, outputdir, force=force)
+    import getopt
+    def usage():
+        print 'usage: %s [-D outputdir] [-f] cmap_dir' % argv[0]
+        return 100
+    try:
+        (opts, args) = getopt.getopt(argv[1:], 'C:D:f')
+    except getopt.GetoptError:
+        return usage()
+    if args:
+        cmapdir = args.pop(0)
+    else:
+        cmapdir = find_cmap_path()
+    outputdir = cmapdir
+    force = False
+    for (k, v) in opts:
+        if k == '-f': force = True
+        elif k == '-C': cmapdir = v
+        elif k == '-D': outputdir = v
+    if not os.path.isdir(cmapdir):
+        print >>stderr, 'directory does not exist: %r' % cmapdir
+        return 111
+    if not os.path.isdir(outputdir):
+        print >>stderr, 'directory does not exist: %r' % outputdir
+        return 111
+    return convert_cmap(cmapdir, outputdir, force=force)
 
 if __name__ == '__main__': sys.exit(main(sys.argv))
diff --git a/pdfminer/converter.py b/pdfminer/converter.py
index 9bd4bef..48799aa 100644
--- a/pdfminer/converter.py
+++ b/pdfminer/converter.py
@@ -10,298 +10,298 @@ from pdfminer.utils import apply_matrix_pt, mult_matrix, enc
 ##
 class TagExtractor(PDFDevice):
 
-  def __init__(self, rsrc, outfp, codec='utf-8'):
-    PDFDevice.__init__(self, rsrc)
-    self.outfp = outfp
-    self.codec = codec
-    self.pageno = 0
-    self.tag = None
-    return
-  
-  def render_string(self, textstate, seq):
-    font = textstate.font
-    text = ''
-    for obj in seq:
-      if not isinstance(obj, str): continue
-      chars = font.decode(obj)
-      for cid in chars:
-        try:
-          char = font.to_unicode(cid)
-          text += char
-        except PDFUnicodeNotDefined:
-          pass
-    self.outfp.write(enc(text, self.codec))
-    return
+    def __init__(self, rsrc, outfp, codec='utf-8'):
+        PDFDevice.__init__(self, rsrc)
+        self.outfp = outfp
+        self.codec = codec
+        self.pageno = 0
+        self.tag = None
+        return
 
-  def begin_page(self, page, ctm):
-    (x0, y0, x1, y1) = page.mediabox
-    bbox = '%.3f,%.3f,%.3f,%.3f' % (x0, y0, x1, y1)
-    self.outfp.write('<page id="%s" bbox="%s" rotate="%d">' %
-                     (self.pageno, bbox, page.rotate))
-    return
-  
-  def end_page(self, page):
-    self.outfp.write('</page>\n')
-    self.pageno += 1
-    return
-  
-  def begin_tag(self, tag, props=None):
-    s = ''
-    if props:
-      s = ''.join( ' %s="%s"' % (enc(k), enc(str(v))) for (k,v)
-                   in sorted(props.iteritems()) )
-    self.outfp.write('<%s%s>' % (enc(tag.name), s))
-    self.tag = tag
-    return
-  
-  def end_tag(self):
-    assert self.tag
-    self.outfp.write('</%s>' % enc(self.tag.name))
-    self.tag = None
-    return
-  
-  def do_tag(self, tag, props=None):
-    self.begin_tag(tag, props)
-    self.tag = None
-    return
+    def render_string(self, textstate, seq):
+        font = textstate.font
+        text = ''
+        for obj in seq:
+            if not isinstance(obj, str): continue
+            chars = font.decode(obj)
+            for cid in chars:
+                try:
+                    char = font.to_unicode(cid)
+                    text += char
+                except PDFUnicodeNotDefined:
+                    pass
+        self.outfp.write(enc(text, self.codec))
+        return
+
+    def begin_page(self, page, ctm):
+        (x0, y0, x1, y1) = page.mediabox
+        bbox = '%.3f,%.3f,%.3f,%.3f' % (x0, y0, x1, y1)
+        self.outfp.write('<page id="%s" bbox="%s" rotate="%d">' %
+                         (self.pageno, bbox, page.rotate))
+        return
+
+    def end_page(self, page):
+        self.outfp.write('</page>\n')
+        self.pageno += 1
+        return
+
+    def begin_tag(self, tag, props=None):
+        s = ''
+        if props:
+            s = ''.join( ' %s="%s"' % (enc(k), enc(str(v))) for (k,v)
+                         in sorted(props.iteritems()) )
+        self.outfp.write('<%s%s>' % (enc(tag.name), s))
+        self.tag = tag
+        return
+
+    def end_tag(self):
+        assert self.tag
+        self.outfp.write('</%s>' % enc(self.tag.name))
+        self.tag = None
+        return
+
+    def do_tag(self, tag, props=None):
+        self.begin_tag(tag, props)
+        self.tag = None
+        return
 
 
 ##  PDFPageAggregator
 ##
 class PDFPageAggregator(PDFTextDevice):
 
-  def __init__(self, rsrc, pageno=1, laparams=None):
-    PDFTextDevice.__init__(self, rsrc)
-    self.laparams = laparams
-    self.pageno = pageno
-    self.stack = []
-    return
+    def __init__(self, rsrc, pageno=1, laparams=None):
+        PDFTextDevice.__init__(self, rsrc)
+        self.laparams = laparams
+        self.pageno = pageno
+        self.stack = []
+        return
 
-  def begin_page(self, page, ctm):
-    (x0,y0,x1,y1) = page.mediabox
-    (x0,y0) = apply_matrix_pt(ctm, (x0,y0))
-    (x1,y1) = apply_matrix_pt(ctm, (x1,y1))
-    mediabox = (0, 0, abs(x0-x1), abs(y0-y1))
-    self.cur_item = LTPage(self.pageno, mediabox)
-    return
-  
-  def end_page(self, _):
-    assert not self.stack
-    assert isinstance(self.cur_item, LTPage)
-    self.cur_item.fixate()
-    if self.laparams:
-      self.cur_item.analyze_layout(self.laparams)
-    self.pageno += 1
-    return self.cur_item
+    def begin_page(self, page, ctm):
+        (x0,y0,x1,y1) = page.mediabox
+        (x0,y0) = apply_matrix_pt(ctm, (x0,y0))
+        (x1,y1) = apply_matrix_pt(ctm, (x1,y1))
+        mediabox = (0, 0, abs(x0-x1), abs(y0-y1))
+        self.cur_item = LTPage(self.pageno, mediabox)
+        return
 
-  def begin_figure(self, name, bbox, matrix):
-    self.stack.append(self.cur_item)
-    self.cur_item = LTFigure(name, bbox, mult_matrix(matrix, self.ctm))
-    return
-  
-  def end_figure(self, _):
-    fig = self.cur_item
-    self.cur_item.fixate()
-    self.cur_item = self.stack.pop()
-    self.cur_item.add(fig)
-    return
+    def end_page(self, _):
+        assert not self.stack
+        assert isinstance(self.cur_item, LTPage)
+        self.cur_item.fixate()
+        if self.laparams:
+            self.cur_item.analyze_layout(self.laparams)
+        self.pageno += 1
+        return self.cur_item
 
-  def paint_path(self, gstate, stroke, fill, evenodd, path):
-    shape = ''.join(x[0] for x in path)
-    if shape == 'ml': # horizontal/vertical line
-      (_,x0,y0) = path[0]
-      (_,x1,y1) = path[1]
-      (x0,y0) = apply_matrix_pt(self.ctm, (x0,y0))
-      (x1,y1) = apply_matrix_pt(self.ctm, (x1,y1))
-      if y0 == y1:
-        # horizontal ruler
-        self.cur_item.add(LTLine(gstate.linewidth, 'H', (x0,y0,x1,y1)))
-      elif x0 == x1:
-        # vertical ruler
-        self.cur_item.add(LTLine(gstate.linewidth, 'V', (x0,y0,x1,y1)))
-    elif shape == 'mlllh':
-      # rectangle
-      (_,x0,y0) = path[0]
-      (_,x1,y1) = path[1]
-      (_,x2,y2) = path[2]
-      (_,x3,y3) = path[3]
-      (x0,y0) = apply_matrix_pt(self.ctm, (x0,y0))
-      (x1,y1) = apply_matrix_pt(self.ctm, (x1,y1))
-      (x2,y2) = apply_matrix_pt(self.ctm, (x2,y2))
-      (x3,y3) = apply_matrix_pt(self.ctm, (x3,y3))
-      if ((x0 == x1 and y1 == y2 and x2 == x3 and y3 == y0) or
-          (y0 == y1 and x1 == x2 and y2 == y3 and x3 == x0)):
-        self.cur_item.add(LTRect(gstate.linewidth, (x0,y0,x2,y2)))
-    return
-  
-  def render_chars(self, matrix, font, fontsize, charspace, scaling, chars):
-    if not chars: return (0, 0)
-    item = LTTextItem(matrix, font, fontsize, charspace, scaling, chars)
-    self.cur_item.add(item)
-    return item.adv
+    def begin_figure(self, name, bbox, matrix):
+        self.stack.append(self.cur_item)
+        self.cur_item = LTFigure(name, bbox, mult_matrix(matrix, self.ctm))
+        return
+
+    def end_figure(self, _):
+        fig = self.cur_item
+        self.cur_item.fixate()
+        self.cur_item = self.stack.pop()
+        self.cur_item.add(fig)
+        return
+
+    def paint_path(self, gstate, stroke, fill, evenodd, path):
+        shape = ''.join(x[0] for x in path)
+        if shape == 'ml': # horizontal/vertical line
+            (_,x0,y0) = path[0]
+            (_,x1,y1) = path[1]
+            (x0,y0) = apply_matrix_pt(self.ctm, (x0,y0))
+            (x1,y1) = apply_matrix_pt(self.ctm, (x1,y1))
+            if y0 == y1:
+                # horizontal ruler
+                self.cur_item.add(LTLine(gstate.linewidth, 'H', (x0,y0,x1,y1)))
+            elif x0 == x1:
+                # vertical ruler
+                self.cur_item.add(LTLine(gstate.linewidth, 'V', (x0,y0,x1,y1)))
+        elif shape == 'mlllh':
+            # rectangle
+            (_,x0,y0) = path[0]
+            (_,x1,y1) = path[1]
+            (_,x2,y2) = path[2]
+            (_,x3,y3) = path[3]
+            (x0,y0) = apply_matrix_pt(self.ctm, (x0,y0))
+            (x1,y1) = apply_matrix_pt(self.ctm, (x1,y1))
+            (x2,y2) = apply_matrix_pt(self.ctm, (x2,y2))
+            (x3,y3) = apply_matrix_pt(self.ctm, (x3,y3))
+            if ((x0 == x1 and y1 == y2 and x2 == x3 and y3 == y0) or
+                (y0 == y1 and x1 == x2 and y2 == y3 and x3 == x0)):
+                self.cur_item.add(LTRect(gstate.linewidth, (x0,y0,x2,y2)))
+        return
+
+    def render_chars(self, matrix, font, fontsize, charspace, scaling, chars):
+        if not chars: return (0, 0)
+        item = LTTextItem(matrix, font, fontsize, charspace, scaling, chars)
+        self.cur_item.add(item)
+        return item.adv
 
 
 ##  PDFConverter
 ##
 class PDFConverter(PDFPageAggregator):
-  
-  def __init__(self, rsrc, outfp, codec='utf-8', pageno=1, laparams=None):
-    PDFPageAggregator.__init__(self, rsrc, pageno=pageno, laparams=laparams)
-    self.outfp = outfp
-    self.codec = codec
-    return
 
-  def write(self, text):
-    self.outfp.write(enc(text, self.codec))
-    return
-  
-  
+    def __init__(self, rsrc, outfp, codec='utf-8', pageno=1, laparams=None):
+        PDFPageAggregator.__init__(self, rsrc, pageno=pageno, laparams=laparams)
+        self.outfp = outfp
+        self.codec = codec
+        return
+
+    def write(self, text):
+        self.outfp.write(enc(text, self.codec))
+        return
+
+
 ##  SGMLConverter
 ##
 class SGMLConverter(PDFConverter):
 
-  def end_page(self, page):
-    def render(item):
-      if isinstance(item, LTPage):
-        self.outfp.write('<page id="%s" bbox="%s" rotate="%d">\n' %
-                         (item.id, item.get_bbox(), item.rotate))
-        for child in item:
-          render(child)
-        self.outfp.write('</page>\n')
-      elif isinstance(item, LTLine):
-        self.outfp.write('<line linewidth="%d" direction="%s" bbox="%s" />' % (item.linewidth, item.direction, item.get_bbox()))
-      elif isinstance(item, LTRect):
-        self.outfp.write('<rect linewidth="%d" bbox="%s" />' % (item.linewidth, item.get_bbox()))
-      elif isinstance(item, LTFigure):
-        self.outfp.write('<figure id="%s" bbox="%s">\n' % (item.id, item.get_bbox()))
-        for child in item:
-          render(child)
-        self.outfp.write('</figure>\n')
-      elif isinstance(item, LTTextLine):
-        self.outfp.write('<textline bbox="%s">\n' % (item.get_bbox()))
-        for child in item:
-          render(child)
-        self.outfp.write('</textline>\n')
-      elif isinstance(item, LTTextBox):
-        self.outfp.write('<textbox id="%s" bbox="%s">\n' % (item.id, item.get_bbox()))
-        for child in item:
-          render(child)
-        self.outfp.write('</textbox>\n')
-      elif isinstance(item, LTTextItem):
-        self.outfp.write('<text font="%s" vertical="%s" bbox="%s" fontsize="%.3f">' %
-                         (enc(item.font.fontname), item.is_vertical(),
-                          item.get_bbox(), item.fontsize))
-        self.write(item.text)
-        self.outfp.write('</text>\n')
-      elif isinstance(item, LTText):
-        self.outfp.write('<text>%s</text>\n' % item.text)
-      else:
-        assert 0, item
-      return
-    page = PDFConverter.end_page(self, page)
-    render(page)
-    return
+    def end_page(self, page):
+        def render(item):
+            if isinstance(item, LTPage):
+                self.outfp.write('<page id="%s" bbox="%s" rotate="%d">\n' %
+                                 (item.id, item.get_bbox(), item.rotate))
+                for child in item:
+                    render(child)
+                self.outfp.write('</page>\n')
+            elif isinstance(item, LTLine):
+                self.outfp.write('<line linewidth="%d" direction="%s" bbox="%s" />' % (item.linewidth, item.direction, item.get_bbox()))
+            elif isinstance(item, LTRect):
+                self.outfp.write('<rect linewidth="%d" bbox="%s" />' % (item.linewidth, item.get_bbox()))
+            elif isinstance(item, LTFigure):
+                self.outfp.write('<figure id="%s" bbox="%s">\n' % (item.id, item.get_bbox()))
+                for child in item:
+                    render(child)
+                self.outfp.write('</figure>\n')
+            elif isinstance(item, LTTextLine):
+                self.outfp.write('<textline bbox="%s">\n' % (item.get_bbox()))
+                for child in item:
+                    render(child)
+                self.outfp.write('</textline>\n')
+            elif isinstance(item, LTTextBox):
+                self.outfp.write('<textbox id="%s" bbox="%s">\n' % (item.id, item.get_bbox()))
+                for child in item:
+                    render(child)
+                self.outfp.write('</textbox>\n')
+            elif isinstance(item, LTTextItem):
+                self.outfp.write('<text font="%s" vertical="%s" bbox="%s" fontsize="%.3f">' %
+                                 (enc(item.font.fontname), item.is_vertical(),
+                                  item.get_bbox(), item.fontsize))
+                self.write(item.text)
+                self.outfp.write('</text>\n')
+            elif isinstance(item, LTText):
+                self.outfp.write('<text>%s</text>\n' % item.text)
+            else:
+                assert 0, item
+            return
+        page = PDFConverter.end_page(self, page)
+        render(page)
+        return
 
 
 ##  HTMLConverter
 ##
 class HTMLConverter(PDFConverter):
 
-  def __init__(self, rsrc, outfp, codec='utf-8', pageno=1, laparams=None,
-               scale=1, showpageno=True, pagepad=50):
-    PDFConverter.__init__(self, rsrc, outfp, codec=codec, pageno=pageno, laparams=laparams)
-    self.showpageno = showpageno
-    self.pagepad = pagepad
-    self.scale = scale
-    self.outfp.write('<html><head>\n')
-    self.outfp.write('<meta http-equiv="Content-Type" content="text/html; charset=%s">\n' %
-                     self.codec)
-    self.outfp.write('</head><body>\n')
-    self.yoffset = self.pagepad
-    return
+    def __init__(self, rsrc, outfp, codec='utf-8', pageno=1, laparams=None,
+                 scale=1, showpageno=True, pagepad=50):
+        PDFConverter.__init__(self, rsrc, outfp, codec=codec, pageno=pageno, laparams=laparams)
+        self.showpageno = showpageno
+        self.pagepad = pagepad
+        self.scale = scale
+        self.outfp.write('<html><head>\n')
+        self.outfp.write('<meta http-equiv="Content-Type" content="text/html; charset=%s">\n' %
+                         self.codec)
+        self.outfp.write('</head><body>\n')
+        self.yoffset = self.pagepad
+        return
 
-  def write_rect(self, color, width, x, y, w, h):
-    self.outfp.write('<span style="position:absolute; border: %s %dpx solid; '
-                     'left:%dpx; top:%dpx; width:%dpx; height:%dpx;"></span>\n' % 
-                     (color, width, x*self.scale, y*self.scale, w*self.scale, h*self.scale))
-    return
+    def write_rect(self, color, width, x, y, w, h):
+        self.outfp.write('<span style="position:absolute; border: %s %dpx solid; '
+                         'left:%dpx; top:%dpx; width:%dpx; height:%dpx;"></span>\n' %
+                         (color, width, x*self.scale, y*self.scale, w*self.scale, h*self.scale))
+        return
 
-  def end_page(self, page):
-    def render(item):
-      if isinstance(item, LTPage):
-        self.yoffset += item.y1
-        self.write_rect('gray', 1, item.x0, self.yoffset-item.y1, item.width, item.height)
-        if self.showpageno:
-          self.outfp.write('<div style="position:absolute; top:%dpx;">' %
-                           ((self.yoffset-item.y1)*self.scale))
-          self.outfp.write('<a name="%s">Page %s</a></div>\n' % (page.id, page.id))
-        for child in item:
-          render(child)
-      elif isinstance(item, LTTextItem):
-        if item.vertical:
-          wmode = 'tb-rl'
-        else:
-          wmode = 'lr-tb'
-        self.outfp.write('<span style="position:absolute; writing-mode:%s;'
-                         ' left:%dpx; top:%dpx; font-size:%dpx;">' %
-                         (wmode, item.x0*self.scale, (self.yoffset-item.y1)*self.scale,
-                          item.fontsize*self.scale))
-        self.write(item.text)
-        self.outfp.write('</span>\n')
-        if self.debug:
-          self.write_rect('red', 1, item.x0, self.yoffset-item.y1, item.width, item.height)
-      elif isinstance(item, LTLine) or isinstance(item, LTRect):
-        self.write_rect('black', 1, item.x0, self.yoffset-item.y1, item.width, item.height)
-      elif isinstance(item, LTTextLine):
-        for child in item:
-          render(child)
-      elif isinstance(item, LTTextBox):
-        self.write_rect('blue', 1, item.x0, self.yoffset-item.y1, item.width, item.height)
-        for child in item:
-          render(child)
-      elif isinstance(item, LTFigure):
-        self.write_rect('green', 1, item.x0, self.yoffset-item.y1, item.width, item.height)
-        for child in item:
-          render(child)
-      return
-    page = PDFConverter.end_page(self, page)
-    render(page)
-    self.yoffset += self.pagepad
-    return
+    def end_page(self, page):
+        def render(item):
+            if isinstance(item, LTPage):
+                self.yoffset += item.y1
+                self.write_rect('gray', 1, item.x0, self.yoffset-item.y1, item.width, item.height)
+                if self.showpageno:
+                    self.outfp.write('<div style="position:absolute; top:%dpx;">' %
+                                     ((self.yoffset-item.y1)*self.scale))
+                    self.outfp.write('<a name="%s">Page %s</a></div>\n' % (page.id, page.id))
+                for child in item:
+                    render(child)
+            elif isinstance(item, LTTextItem):
+                if item.vertical:
+                    wmode = 'tb-rl'
+                else:
+                    wmode = 'lr-tb'
+                self.outfp.write('<span style="position:absolute; writing-mode:%s;'
+                                 ' left:%dpx; top:%dpx; font-size:%dpx;">' %
+                                 (wmode, item.x0*self.scale, (self.yoffset-item.y1)*self.scale,
+                                  item.fontsize*self.scale))
+                self.write(item.text)
+                self.outfp.write('</span>\n')
+                if self.debug:
+                    self.write_rect('red', 1, item.x0, self.yoffset-item.y1, item.width, item.height)
+            elif isinstance(item, LTLine) or isinstance(item, LTRect):
+                self.write_rect('black', 1, item.x0, self.yoffset-item.y1, item.width, item.height)
+            elif isinstance(item, LTTextLine):
+                for child in item:
+                    render(child)
+            elif isinstance(item, LTTextBox):
+                self.write_rect('blue', 1, item.x0, self.yoffset-item.y1, item.width, item.height)
+                for child in item:
+                    render(child)
+            elif isinstance(item, LTFigure):
+                self.write_rect('green', 1, item.x0, self.yoffset-item.y1, item.width, item.height)
+                for child in item:
+                    render(child)
+            return
+        page = PDFConverter.end_page(self, page)
+        render(page)
+        self.yoffset += self.pagepad
+        return
 
-  def close(self):
-    self.outfp.write('<div style="position:absolute; top:0px;">Page: %s</div>\n' % 
-                     ', '.join('<a href="#%s">%s</a>' % (i,i) for i in xrange(1,self.pageno)))
-    self.outfp.write('</body></html>\n')
-    return
+    def close(self):
+        self.outfp.write('<div style="position:absolute; top:0px;">Page: %s</div>\n' %
+                         ', '.join('<a href="#%s">%s</a>' % (i,i) for i in xrange(1,self.pageno)))
+        self.outfp.write('</body></html>\n')
+        return
 
 
 ##  TextConverter
 ##
 class TextConverter(PDFConverter):
 
-  def __init__(self, rsrc, outfp, codec='utf-8', pageno=1, laparams=None,
-               showpageno=False):
-    PDFConverter.__init__(self, rsrc, outfp, codec=codec, pageno=pageno, laparams=laparams)
-    self.showpageno = showpageno
-    return
-  
-  def write(self, text):
-    self.outfp.write(text.encode(self.codec, 'ignore'))
-    return
-  
-  def end_page(self, page):
-    def render(item):
-      if isinstance(item, LTText):
-        self.write(item.text)
-      elif isinstance(item, LayoutContainer):
-        for child in item:
-          render(child)
-      if isinstance(item, LTTextBox):
-        self.write('\n')
-    page = PDFConverter.end_page(self, page)
-    if self.showpageno:
-      self.write('Page %d\n' % page.id)
-    render(page)
-    self.write('\f')
-    return
+    def __init__(self, rsrc, outfp, codec='utf-8', pageno=1, laparams=None,
+                 showpageno=False):
+        PDFConverter.__init__(self, rsrc, outfp, codec=codec, pageno=pageno, laparams=laparams)
+        self.showpageno = showpageno
+        return
+
+    def write(self, text):
+        self.outfp.write(text.encode(self.codec, 'ignore'))
+        return
+
+    def end_page(self, page):
+        def render(item):
+            if isinstance(item, LTText):
+                self.write(item.text)
+            elif isinstance(item, LayoutContainer):
+                for child in item:
+                    render(child)
+            if isinstance(item, LTTextBox):
+                self.write('\n')
+        page = PDFConverter.end_page(self, page)
+        if self.showpageno:
+            self.write('Page %d\n' % page.id)
+        render(page)
+        self.write('\f')
+        return
diff --git a/pdfminer/fontmetrics.py b/pdfminer/fontmetrics.py
index 59f122d..d4b08e0 100644
--- a/pdfminer/fontmetrics.py
+++ b/pdfminer/fontmetrics.py
@@ -8,9 +8,9 @@
 
 ###  BEGIN Verbatim copy of the license part
 
-# 
+#
 # Adobe Core 35 AFM Files with 229 Glyph Entries - ReadMe
-# 
+#
 # This file and the 35 PostScript(R) AFM files it accompanies may be
 # used, copied, and distributed for any purpose and without charge,
 # with or without modification, provided that all copyright notices
diff --git a/pdfminer/layout.py b/pdfminer/layout.py
index 147f981..4001fe8 100644
--- a/pdfminer/layout.py
+++ b/pdfminer/layout.py
@@ -7,23 +7,23 @@ INF = sys.maxint
 ##  LAParams
 ##
 class LAParams(object):
-  
-  def __init__(self,
-               direction=None,
-               line_overlap=0.5,
-               char_margin=1.0,
-               line_margin=0.5,
-               word_margin=0.1):
-    self.direction = direction
-    self.line_overlap = line_overlap
-    self.char_margin = char_margin
-    self.line_margin = line_margin
-    self.word_margin = word_margin
-    return
 
-  def __repr__(self):
-    return ('<LAParams: direction=%r, char_margin=%.1f, line_margin=%.1f, word_margin=%.1f>' %
-            (self.direction, self.char_margin, self.line_margin, self.word_margin))
+    def __init__(self,
+                 direction=None,
+                 line_overlap=0.5,
+                 char_margin=1.0,
+                 line_margin=0.5,
+                 word_margin=0.1):
+        self.direction = direction
+        self.line_overlap = line_overlap
+        self.char_margin = char_margin
+        self.line_margin = line_margin
+        self.word_margin = word_margin
+        return
+
+    def __repr__(self):
+        return ('<LAParams: direction=%r, char_margin=%.1f, line_margin=%.1f, word_margin=%.1f>' %
+                (self.direction, self.char_margin, self.line_margin, self.word_margin))
 
 
 ##  Plane
@@ -35,354 +35,354 @@ class LAParams(object):
 ##
 class Plane(object):
 
-  def __init__(self, objs):
-    self.xobjs = []
-    self.yobjs = []
-    for obj in objs:
-      self.place(obj)
-    self.xobjs.sort()
-    self.yobjs.sort()
-    return
+    def __init__(self, objs):
+        self.xobjs = []
+        self.yobjs = []
+        for obj in objs:
+            self.place(obj)
+        self.xobjs.sort()
+        self.yobjs.sort()
+        return
 
-  # place(obj): place an object in a certain area.
-  def place(self, obj):
-    assert isinstance(obj, LayoutItem)
-    self.xobjs.append((obj.x0, obj))
-    self.xobjs.append((obj.x1, obj))
-    self.yobjs.append((obj.y0, obj))
-    self.yobjs.append((obj.y1, obj))
-    return
+    # place(obj): place an object in a certain area.
+    def place(self, obj):
+        assert isinstance(obj, LayoutItem)
+        self.xobjs.append((obj.x0, obj))
+        self.xobjs.append((obj.x1, obj))
+        self.yobjs.append((obj.y0, obj))
+        self.yobjs.append((obj.y1, obj))
+        return
 
-  # find(): finds objects that are in a certain area.
-  def find(self, (x0,y0,x1,y1)):
-    (i0,_) = bsearch(self.xobjs, x0)
-    (_,i1) = bsearch(self.xobjs, x1)
-    xobjs = set( obj for (_,obj) in self.xobjs[i0:i1] )
-    (i0,_) = bsearch(self.yobjs, y0)
-    (_,i1) = bsearch(self.yobjs, y1)
-    yobjs = set( obj for (_,obj) in self.yobjs[i0:i1] )
-    objs = xobjs.intersection(yobjs)
-    return objs
+    # find(): finds objects that are in a certain area.
+    def find(self, (x0,y0,x1,y1)):
+        (i0,_) = bsearch(self.xobjs, x0)
+        (_,i1) = bsearch(self.xobjs, x1)
+        xobjs = set( obj for (_,obj) in self.xobjs[i0:i1] )
+        (i0,_) = bsearch(self.yobjs, y0)
+        (_,i1) = bsearch(self.yobjs, y1)
+        yobjs = set( obj for (_,obj) in self.yobjs[i0:i1] )
+        objs = xobjs.intersection(yobjs)
+        return objs
 
 
 ##  ClusterSet
 ##
 class ClusterSet(object):
 
-  def __init__(self, klass):
-    self.clusters = {}
-    self.klass = klass
-    self.i = 0
-    return
+    def __init__(self, klass):
+        self.clusters = {}
+        self.klass = klass
+        self.i = 0
+        return
 
-  # add(objs): groups text objects if necessary.
-  def add(self, objs):
-    group = self.klass(self.i, objs)
-    self.i += 1
-    for obj in objs:
-      if obj in self.clusters:
-        group.merge(self.clusters[obj])
-    for obj in group:
-      self.clusters[obj] = group
-    return
+    # add(objs): groups text objects if necessary.
+    def add(self, objs):
+        group = self.klass(self.i, objs)
+        self.i += 1
+        for obj in objs:
+            if obj in self.clusters:
+                group.merge(self.clusters[obj])
+        for obj in group:
+            self.clusters[obj] = group
+        return
 
-  # finish(): returns all the LTTextBoxes in a page.
-  def finish(self):
-    r = set(self.clusters.itervalues())
-    for group in r:
-      group.fixate()
-    return list(r)
+    # finish(): returns all the LTTextBoxes in a page.
+    def finish(self):
+        r = set(self.clusters.itervalues())
+        for group in r:
+            group.fixate()
+        return list(r)
 
-  @classmethod
-  def build(klass, objs, hratio, vratio, objtype, func=None):
-    plane = Plane(objs)
-    cset = ClusterSet(objtype)
-    for obj in objs:
-      margin = obj.get_margin()
-      hmargin = hratio * margin
-      vmargin = vratio * margin
-      neighbors = plane.find((obj.x0-hmargin, obj.y0-vmargin, obj.x1+hmargin, obj.y1+vmargin))
-      assert obj in neighbors, obj
-      if func:
-        neighbors = [ x for x in neighbors if x is obj or func(obj, x) ]
-      cset.add(neighbors)
-    return cset.finish()
+    @classmethod
+    def build(klass, objs, hratio, vratio, objtype, func=None):
+        plane = Plane(objs)
+        cset = ClusterSet(objtype)
+        for obj in objs:
+            margin = obj.get_margin()
+            hmargin = hratio * margin
+            vmargin = vratio * margin
+            neighbors = plane.find((obj.x0-hmargin, obj.y0-vmargin, obj.x1+hmargin, obj.y1+vmargin))
+            assert obj in neighbors, obj
+            if func:
+                neighbors = [ x for x in neighbors if x is obj or func(obj, x) ]
+            cset.add(neighbors)
+        return cset.finish()
 
 
 ##  LayoutItem
 ##
 class LayoutItem(object):
 
-  def __init__(self, bbox):
-    self.set_bbox(bbox)
-    return
+    def __init__(self, bbox):
+        self.set_bbox(bbox)
+        return
 
-  def set_bbox(self, (x0,y0,x1,y1)):
-    if x1 < x0: (x0,x1) = (x1,x0)
-    if y1 < y0: (y0,y1) = (y1,y0)
-    self.x0 = x0
-    self.y0 = y0
-    self.x1 = x1
-    self.y1 = y1
-    self.width = x1-x0
-    self.height = y1-y0
-    return
+    def set_bbox(self, (x0,y0,x1,y1)):
+        if x1 < x0: (x0,x1) = (x1,x0)
+        if y1 < y0: (y0,y1) = (y1,y0)
+        self.x0 = x0
+        self.y0 = y0
+        self.x1 = x1
+        self.y1 = y1
+        self.width = x1-x0
+        self.height = y1-y0
+        return
 
-  def __repr__(self):
-    return ('<item bbox=%s>' % (self.get_bbox()))
-  
-  def hoverlap(self, obj):
-    assert isinstance(obj, LayoutItem)
-    if self.x1 <= obj.x0 or obj.x1 <= self.x0:
-      return 0
-    else:
-      return min(abs(self.x0-obj.x1), abs(self.x1-obj.x0))
+    def __repr__(self):
+        return ('<item bbox=%s>' % (self.get_bbox()))
 
-  def voverlap(self, obj):
-    assert isinstance(obj, LayoutItem)
-    if self.y1 <= obj.y0 or obj.y1 <= self.y0:
-      return 0
-    else:
-      return min(abs(self.y0-obj.y1), abs(self.y1-obj.y0))
+    def hoverlap(self, obj):
+        assert isinstance(obj, LayoutItem)
+        if self.x1 <= obj.x0 or obj.x1 <= self.x0:
+            return 0
+        else:
+            return min(abs(self.x0-obj.x1), abs(self.x1-obj.x0))
 
-  def get_bbox(self):
-    return '%.3f,%.3f,%.3f,%.3f' % (self.x0, self.y0, self.x1, self.y1)
-  
-  def get_margin(self):
-    return 0
+    def voverlap(self, obj):
+        assert isinstance(obj, LayoutItem)
+        if self.y1 <= obj.y0 or obj.y1 <= self.y0:
+            return 0
+        else:
+            return min(abs(self.y0-obj.y1), abs(self.y1-obj.y0))
 
-  def get_weight(self):
-    return 0
-  
-  def get_direction(self):
-    return None
+    def get_bbox(self):
+        return '%.3f,%.3f,%.3f,%.3f' % (self.x0, self.y0, self.x1, self.y1)
+
+    def get_margin(self):
+        return 0
+
+    def get_weight(self):
+        return 0
+
+    def get_direction(self):
+        return None
 
 
 ##  LayoutContainer
 ##
 class LayoutContainer(LayoutItem):
-  
-  def __init__(self, id, bbox, objs=None):
-    LayoutItem.__init__(self, bbox)
-    self.id = id
-    if objs:
-      self.objs = set(objs)
-    else:
-      self.objs = set()
-    self.weight = None
-    return
 
-  def __repr__(self):
-    return ('<group %s>' % (self.get_bbox()))
+    def __init__(self, id, bbox, objs=None):
+        LayoutItem.__init__(self, bbox)
+        self.id = id
+        if objs:
+            self.objs = set(objs)
+        else:
+            self.objs = set()
+        self.weight = None
+        return
 
-  def __iter__(self):
-    return iter(self.objs)
+    def __repr__(self):
+        return ('<group %s>' % (self.get_bbox()))
 
-  def __len__(self):
-    return len(self.objs)
-  
-  def add(self, obj):
-    self.objs.add(obj)
-    return
+    def __iter__(self):
+        return iter(self.objs)
 
-  def merge(self, group):
-    self.objs.update(iter(group))
-    return
+    def __len__(self):
+        return len(self.objs)
 
-  # fixate(): determines its boundery and writing direction.
-  def fixate(self):
-    if not self.width and self.objs:
-      (bx0, by0, bx1, by1) = (INF, INF, -INF, -INF)
-      for obj in self.objs:
-        bx0 = min(bx0, obj.x0)
-        by0 = min(by0, obj.y0)
-        bx1 = max(bx1, obj.x1)
-        by1 = max(by1, obj.y1)
-      self.set_bbox((bx0, by0, bx1, by1))
-    self.weight = sum( obj.get_weight() for obj in self.objs )
-    return
+    def add(self, obj):
+        self.objs.add(obj)
+        return
 
-  def get_weight(self):
-    return self.weight
-  
-  def get_direction(self):
-    return None
+    def merge(self, group):
+        self.objs.update(iter(group))
+        return
+
+    # fixate(): determines its boundery and writing direction.
+    def fixate(self):
+        if not self.width and self.objs:
+            (bx0, by0, bx1, by1) = (INF, INF, -INF, -INF)
+            for obj in self.objs:
+                bx0 = min(bx0, obj.x0)
+                by0 = min(by0, obj.y0)
+                bx1 = max(bx1, obj.x1)
+                by1 = max(by1, obj.y1)
+            self.set_bbox((bx0, by0, bx1, by1))
+        self.weight = sum( obj.get_weight() for obj in self.objs )
+        return
+
+    def get_weight(self):
+        return self.weight
+
+    def get_direction(self):
+        return None
 
 
 ##  LTLine
 ##
 class LTLine(LayoutItem):
 
-  def __init__(self, linewidth, direction, bbox):
-    LayoutItem.__init__(self, bbox)
-    self.linewidth = linewidth
-    self.direction = direction
-    return
+    def __init__(self, linewidth, direction, bbox):
+        LayoutItem.__init__(self, bbox)
+        self.linewidth = linewidth
+        self.direction = direction
+        return
 
 
 ##  LTRect
 ##
 class LTRect(LayoutItem):
 
-  def __init__(self, linewidth, bbox):
-    LayoutItem.__init__(self, bbox)
-    self.linewidth = linewidth
-    return
-  
+    def __init__(self, linewidth, bbox):
+        LayoutItem.__init__(self, bbox)
+        self.linewidth = linewidth
+        return
+
 
 ##  LTText
 ##
 class LTText(object):
 
-  def __init__(self, text):
-    self.text = text
-    return
+    def __init__(self, text):
+        self.text = text
+        return
 
-  def __repr__(self):
-    return '<text %r>' % self.text
+    def __repr__(self):
+        return '<text %r>' % self.text
 
-  def get_weight(self):
-    return len(self.text)
+    def get_weight(self):
+        return len(self.text)
 
-  def is_upright(self):
-    return True
+    def is_upright(self):
+        return True
 
 
 ##  LTAnon
 ##
 class LTAnon(LTText):
 
-  def get_weight(self):
-    return 0
+    def get_weight(self):
+        return 0
 
 
 ##  LTTextItem
 ##
 class LTTextItem(LayoutItem, LTText):
 
-  debug = 1
-  
-  def __init__(self, matrix, font, fontsize, charspace, scaling, chars):
-    assert chars
-    self.matrix = matrix
-    self.font = font
-    self.vertical = font.is_vertical()
-    self.text = ''.join( char for (char,_) in chars )
-    adv = sum( font.char_width(cid) for (_,cid) in chars )
-    adv = (adv * fontsize + (len(chars)-1)*charspace) * scaling
-    #size = (font.get_ascent() - font.get_descent()) * fontsize
-    size = font.get_size() * fontsize
-    (_,_,_,_,tx,ty) = self.matrix
-    if not self.vertical:
-      # horizontal text
-      self.adv = (adv, 0)
-      (dx,dy) = apply_matrix_norm(self.matrix, (adv,size))
-      (_,descent) = apply_matrix_norm(self.matrix, (0,font.get_descent() * fontsize))
-      ty += descent
-      bbox = (tx, ty, tx+dx, ty+dy)
-    else:
-      # vertical text
-      self.adv = (0, adv)
-      (_,cid) = chars[0]
-      (_,disp) = apply_matrix_norm(self.matrix, (0, (1000-font.char_disp(cid))*fontsize*.001))
-      (dx,dy) = apply_matrix_norm(self.matrix, (size,adv))
-      tx -= dx/2
-      ty += disp
-      bbox = (tx, ty+dy, tx+dx, ty)
-    self.fontsize = max(apply_matrix_norm(self.matrix, (size,size)))
-    LayoutItem.__init__(self, bbox)
-    return
+    debug = 1
 
-  def __repr__(self):
-    if self.debug:
-      return ('<text matrix=%s font=%r fontsize=%.1f bbox=%s adv=%s text=%r>' %
-              ('[%.1f, %.1f, %.1f, %.1f, (%.1f, %.1f)]' % self.matrix,
-               self.font, self.fontsize, self.get_bbox(),
-               '(%.1f, %.1f)' % self.adv,
-               self.text))
-    else:
-      return '<text %r>' % self.text
+    def __init__(self, matrix, font, fontsize, charspace, scaling, chars):
+        assert chars
+        self.matrix = matrix
+        self.font = font
+        self.vertical = font.is_vertical()
+        self.text = ''.join( char for (char,_) in chars )
+        adv = sum( font.char_width(cid) for (_,cid) in chars )
+        adv = (adv * fontsize + (len(chars)-1)*charspace) * scaling
+        #size = (font.get_ascent() - font.get_descent()) * fontsize
+        size = font.get_size() * fontsize
+        (_,_,_,_,tx,ty) = self.matrix
+        if not self.vertical:
+            # horizontal text
+            self.adv = (adv, 0)
+            (dx,dy) = apply_matrix_norm(self.matrix, (adv,size))
+            (_,descent) = apply_matrix_norm(self.matrix, (0,font.get_descent() * fontsize))
+            ty += descent
+            bbox = (tx, ty, tx+dx, ty+dy)
+        else:
+            # vertical text
+            self.adv = (0, adv)
+            (_,cid) = chars[0]
+            (_,disp) = apply_matrix_norm(self.matrix, (0, (1000-font.char_disp(cid))*fontsize*.001))
+            (dx,dy) = apply_matrix_norm(self.matrix, (size,adv))
+            tx -= dx/2
+            ty += disp
+            bbox = (tx, ty+dy, tx+dx, ty)
+        self.fontsize = max(apply_matrix_norm(self.matrix, (size,size)))
+        LayoutItem.__init__(self, bbox)
+        return
 
-  def get_margin(self):
-    return abs(self.fontsize)
+    def __repr__(self):
+        if self.debug:
+            return ('<text matrix=%s font=%r fontsize=%.1f bbox=%s adv=%s text=%r>' %
+                    ('[%.1f, %.1f, %.1f, %.1f, (%.1f, %.1f)]' % self.matrix,
+                     self.font, self.fontsize, self.get_bbox(),
+                     '(%.1f, %.1f)' % self.adv,
+                     self.text))
+        else:
+            return '<text %r>' % self.text
 
-  def is_vertical(self):
-    return self.vertical
+    def get_margin(self):
+        return abs(self.fontsize)
 
-  def is_upright(self):
-    (a,b,c,d,e,f) = self.matrix
-    return 0 < a*d and b*c <= 0
+    def is_vertical(self):
+        return self.vertical
+
+    def is_upright(self):
+        (a,b,c,d,e,f) = self.matrix
+        return 0 < a*d and b*c <= 0
 
 
 ##  LTFigure
 ##
 class LTFigure(LayoutContainer):
-  
-  def __init__(self, id, bbox, matrix):
-    (x,y,w,h) = bbox
-    x0 = y0 = INF
-    x1 = y1 = -INF
-    for (p,q) in ((x,y),(x+w,y),(x,y+h),(x+w,y+h)):
-      (p,q) = apply_matrix_pt(matrix, (p,q))
-      x0 = min(x0, p)
-      x1 = max(x1, p)
-      y0 = min(y0, q)
-      y1 = max(y1, q)
-    bbox = (x0,y0,x1,y1)
-    self.matrix = matrix
-    LayoutContainer.__init__(self, id, bbox)
-    return
 
-  def __repr__(self):
-    return ('<figure id=%r bbox=%s matrix=%r>' % (self.id, self.get_bbox(), self.matrix))
+    def __init__(self, id, bbox, matrix):
+        (x,y,w,h) = bbox
+        x0 = y0 = INF
+        x1 = y1 = -INF
+        for (p,q) in ((x,y),(x+w,y),(x,y+h),(x+w,y+h)):
+            (p,q) = apply_matrix_pt(matrix, (p,q))
+            x0 = min(x0, p)
+            x1 = max(x1, p)
+            y0 = min(y0, q)
+            y1 = max(y1, q)
+        bbox = (x0,y0,x1,y1)
+        self.matrix = matrix
+        LayoutContainer.__init__(self, id, bbox)
+        return
+
+    def __repr__(self):
+        return ('<figure id=%r bbox=%s matrix=%r>' % (self.id, self.get_bbox(), self.matrix))
 
 
 ##  LTTextLine
 ##
 class LTTextLine(LayoutContainer):
 
-  def __init__(self, id, objs, direction, word_margin):
-    LayoutContainer.__init__(self, id, (0,0,0,0), objs)
-    self.direction = direction
-    self.word_margin = word_margin
-    return
+    def __init__(self, id, objs, direction, word_margin):
+        LayoutContainer.__init__(self, id, (0,0,0,0), objs)
+        self.direction = direction
+        self.word_margin = word_margin
+        return
 
-  def __repr__(self):
-    return ('<line %s(%s)>' % (self.get_bbox(), self.direction))
+    def __repr__(self):
+        return ('<line %s(%s)>' % (self.get_bbox(), self.direction))
 
-  def get_margin(self):
-    return min(self.width, self.height)
+    def get_margin(self):
+        return min(self.width, self.height)
 
-  def get_direction(self):
-    return self.direction
+    def get_direction(self):
+        return self.direction
 
-  def get_text(self):
-    return ''.join( obj.text for obj in self.objs if isinstance(obj, LTText) )
+    def get_text(self):
+        return ''.join( obj.text for obj in self.objs if isinstance(obj, LTText) )
 
-  def fixate(self):
-    LayoutContainer.fixate(self)
-    objs = []
-    if self.direction == 'V':
-      y0 = -INF
-      for obj in sorted(self.objs, key=lambda obj: -obj.y1):
-        if isinstance(obj, LTTextItem) and self.word_margin:
-          margin = self.word_margin * obj.get_margin()
-          if obj.y1+margin < y0:
-            objs.append(LTAnon(' '))
-        objs.append(obj)
-        y0 = obj.y0
-    else:
-      x1 = INF
-      for obj in sorted(self.objs, key=lambda obj: obj.x0):
-        if isinstance(obj, LTTextItem) and self.word_margin:
-          margin = self.word_margin * obj.get_margin()
-          if x1 < obj.x0-margin:
-            objs.append(LTAnon(' '))
-        objs.append(obj)
-        x1 = obj.x1
-    objs.append(LTAnon('\n'))
-    self.objs = objs
-    return
+    def fixate(self):
+        LayoutContainer.fixate(self)
+        objs = []
+        if self.direction == 'V':
+            y0 = -INF
+            for obj in sorted(self.objs, key=lambda obj: -obj.y1):
+                if isinstance(obj, LTTextItem) and self.word_margin:
+                    margin = self.word_margin * obj.get_margin()
+                    if obj.y1+margin < y0:
+                        objs.append(LTAnon(' '))
+                objs.append(obj)
+                y0 = obj.y0
+        else:
+            x1 = INF
+            for obj in sorted(self.objs, key=lambda obj: obj.x0):
+                if isinstance(obj, LTTextItem) and self.word_margin:
+                    margin = self.word_margin * obj.get_margin()
+                    if x1 < obj.x0-margin:
+                        objs.append(LTAnon(' '))
+                objs.append(obj)
+                x1 = obj.x1
+        objs.append(LTAnon('\n'))
+        self.objs = objs
+        return
 
 
 ##  LTTextBox
@@ -392,109 +392,109 @@ class LTTextLine(LayoutContainer):
 ##
 class LTTextBox(LayoutContainer):
 
-  def __init__(self, id, objs, direction):
-    LayoutContainer.__init__(self, id, (0,0,0,0), objs)
-    self.direction = direction
-    return
+    def __init__(self, id, objs, direction):
+        LayoutContainer.__init__(self, id, (0,0,0,0), objs)
+        self.direction = direction
+        return
 
-  def __repr__(self):
-    return ('<textbox %s(%s) %r...>' % (self.get_bbox(), self.direction, self.get_text()[:20]))
+    def __repr__(self):
+        return ('<textbox %s(%s) %r...>' % (self.get_bbox(), self.direction, self.get_text()[:20]))
 
-  def get_text(self):
-    return ''.join( obj.get_text() for obj in self.objs if isinstance(obj, LTTextLine) )
-  
-  def fixate(self):
-    LayoutContainer.fixate(self)
-    if self.direction == 'V':
-      self.objs = sorted(self.objs, key=lambda obj: -obj.x1)
-    else:
-      self.objs = sorted(self.objs, key=lambda obj: -obj.y1)
-    return
+    def get_text(self):
+        return ''.join( obj.get_text() for obj in self.objs if isinstance(obj, LTTextLine) )
 
-  def get_direction(self):
-    return self.direction
+    def fixate(self):
+        LayoutContainer.fixate(self)
+        if self.direction == 'V':
+            self.objs = sorted(self.objs, key=lambda obj: -obj.x1)
+        else:
+            self.objs = sorted(self.objs, key=lambda obj: -obj.y1)
+        return
+
+    def get_direction(self):
+        return self.direction
 
 
 def tsort(objs, f):
-  gi = dict( (obj,[]) for obj in objs )
-  go = dict( (obj,[]) for obj in objs )
-  for obj1 in objs:
-    for obj2 in objs:
-      if obj1 is obj2: continue
-      if f(obj1, obj2): # obj1 -> obj2
-        go[obj1].append(obj2)
-        gi[obj2].append(obj1)
-  r = objs[:]
-  s = []
-  while r:
-    for obj in r:
-      if not go[obj] or gi[obj]: continue
-      for c in go[obj]:
-        gi[c].remove(obj)
-      del gi[obj]
-      del go[obj]
-      r.remove(obj)
-      s.append(obj)
-      break
-    else:
-      obj = r.pop()
-      del gi[obj]
-      del go[obj]
-      s.append(obj)
-  return s
+    gi = dict( (obj,[]) for obj in objs )
+    go = dict( (obj,[]) for obj in objs )
+    for obj1 in objs:
+        for obj2 in objs:
+            if obj1 is obj2: continue
+            if f(obj1, obj2): # obj1 -> obj2
+                go[obj1].append(obj2)
+                gi[obj2].append(obj1)
+    r = objs[:]
+    s = []
+    while r:
+        for obj in r:
+            if not go[obj] or gi[obj]: continue
+            for c in go[obj]:
+                gi[c].remove(obj)
+            del gi[obj]
+            del go[obj]
+            r.remove(obj)
+            s.append(obj)
+            break
+        else:
+            obj = r.pop()
+            del gi[obj]
+            del go[obj]
+            s.append(obj)
+    return s
 
 
 ##  LTPage
 ##
 class LTPage(LayoutContainer):
-  
-  def __init__(self, id, bbox, rotate=0):
-    LayoutContainer.__init__(self, id, bbox)
-    self.rotate = rotate
-    return
-  
-  def __repr__(self):
-    return ('<page id=%r bbox=%s rotate=%r>' % (self.id, self.get_bbox(), self.rotate))
 
-  def analyze_layout(self, laparams):
-    textobjs = []
-    otherobjs = []
-    for obj in self.objs:
-      if isinstance(obj, LTText) and obj.is_upright():
-        textobjs.append(obj)
-      else:
-        otherobjs.append(obj)
-    if laparams.direction == 'V':
-      def vline(obj1, obj2):
-        return obj1.width * laparams.line_overlap < obj1.hoverlap(obj2)
-      def vorder(obj1, obj2):
-        if obj1.voverlap(obj2):
-          return obj2.x1 < obj1.x0
-        elif obj1.hoverlap(obj2):
-          return obj2.y1 < obj1.y0
+    def __init__(self, id, bbox, rotate=0):
+        LayoutContainer.__init__(self, id, bbox)
+        self.rotate = rotate
+        return
+
+    def __repr__(self):
+        return ('<page id=%r bbox=%s rotate=%r>' % (self.id, self.get_bbox(), self.rotate))
+
+    def analyze_layout(self, laparams):
+        textobjs = []
+        otherobjs = []
+        for obj in self.objs:
+            if isinstance(obj, LTText) and obj.is_upright():
+                textobjs.append(obj)
+            else:
+                otherobjs.append(obj)
+        if laparams.direction == 'V':
+            def vline(obj1, obj2):
+                return obj1.width * laparams.line_overlap < obj1.hoverlap(obj2)
+            def vorder(obj1, obj2):
+                if obj1.voverlap(obj2):
+                    return obj2.x1 < obj1.x0
+                elif obj1.hoverlap(obj2):
+                    return obj2.y1 < obj1.y0
+                else:
+                    return obj2.x1 < obj1.x0 and obj2.y1 < obj1.y0
+            lines = ClusterSet.build(textobjs, 0, laparams.char_margin,
+                                     (lambda id,objs: LTTextLine(id, objs, 'V', laparams.word_margin)),
+                                     vline)
+            boxes = ClusterSet.build(lines, laparams.line_margin, 0,
+                                     (lambda id,objs: LTTextBox(id, objs, 'V')))
+            boxes = tsort(boxes, vorder)
         else:
-          return obj2.x1 < obj1.x0 and obj2.y1 < obj1.y0
-      lines = ClusterSet.build(textobjs, 0, laparams.char_margin,
-                               (lambda id,objs: LTTextLine(id, objs, 'V', laparams.word_margin)),
-                               vline)
-      boxes = ClusterSet.build(lines, laparams.line_margin, 0,
-                               (lambda id,objs: LTTextBox(id, objs, 'V')))
-      boxes = tsort(boxes, vorder)
-    else:
-      def hline(obj1, obj2):
-        return obj1.height * laparams.line_overlap < obj1.voverlap(obj2)
-      def horder(obj1, obj2):
-        if obj1.hoverlap(obj2):
-          return obj2.y1 < obj1.y0
-        elif obj1.voverlap(obj2):
-          return obj1.x1 < obj2.x0
-        else:
-          return obj1.x1 < obj2.x0 and obj2.y1 < obj1.y0
-      lines = ClusterSet.build(textobjs, laparams.char_margin, 0,
-                               (lambda id,objs: LTTextLine(id, objs, 'H', laparams.word_margin)),
-                               hline)
-      boxes = ClusterSet.build(lines, 0, laparams.line_margin,
-                               (lambda id,objs: LTTextBox(id, objs, 'H')))
-      boxes = tsort(boxes, horder)
-    self.objs = otherobjs + boxes
-    return
+            def hline(obj1, obj2):
+                return obj1.height * laparams.line_overlap < obj1.voverlap(obj2)
+            def horder(obj1, obj2):
+                if obj1.hoverlap(obj2):
+                    return obj2.y1 < obj1.y0
+                elif obj1.voverlap(obj2):
+                    return obj1.x1 < obj2.x0
+                else:
+                    return obj1.x1 < obj2.x0 and obj2.y1 < obj1.y0
+            lines = ClusterSet.build(textobjs, laparams.char_margin, 0,
+                                     (lambda id,objs: LTTextLine(id, objs, 'H', laparams.word_margin)),
+                                     hline)
+            boxes = ClusterSet.build(lines, 0, laparams.line_margin,
+                                     (lambda id,objs: LTTextBox(id, objs, 'H')))
+            boxes = tsort(boxes, horder)
+        self.objs = otherobjs + boxes
+        return
diff --git a/pdfminer/lzw.py b/pdfminer/lzw.py
index 22f181a..8de8336 100644
--- a/pdfminer/lzw.py
+++ b/pdfminer/lzw.py
@@ -7,93 +7,93 @@ stderr = sys.stderr
 ##
 class LZWDecoder(object):
 
-  debug = 0
-  
-  def __init__(self, fp):
-    self.fp = fp
-    self.buff = 0
-    self.bpos = 8
-    self.nbits = 9
-    self.table = None
-    self.prevbuf = None
-    return
+    debug = 0
 
-  def readbits(self, bits):
-    v = 0
-    while 1:
-      # the number of remaining bits we can get from the current buffer.
-      r = 8-self.bpos
-      if bits <= r:
-        # |-----8-bits-----|
-        # |-bpos-|-bits-|  |
-        # |      |----r----|
-        v = (v<<bits) | ((self.buff>>(r-bits)) & ((1<<bits)-1))
-        self.bpos += bits
-        break
-      else:
-        # |-----8-bits-----|
-        # |-bpos-|---bits----...
-        # |      |----r----|
-        v = (v<<r) | (self.buff & ((1<<r)-1))
-        bits -= r
-        x = self.fp.read(1)
-        if not x: raise EOFError
-        self.buff = ord(x)
-        self.bpos = 0
-    return v
+    def __init__(self, fp):
+        self.fp = fp
+        self.buff = 0
+        self.bpos = 8
+        self.nbits = 9
+        self.table = None
+        self.prevbuf = None
+        return
+
+    def readbits(self, bits):
+        v = 0
+        while 1:
+            # the number of remaining bits we can get from the current buffer.
+            r = 8-self.bpos
+            if bits <= r:
+                # |-----8-bits-----|
+                # |-bpos-|-bits-|  |
+                # |      |----r----|
+                v = (v<<bits) | ((self.buff>>(r-bits)) & ((1<<bits)-1))
+                self.bpos += bits
+                break
+            else:
+                # |-----8-bits-----|
+                # |-bpos-|---bits----...
+                # |      |----r----|
+                v = (v<<r) | (self.buff & ((1<<r)-1))
+                bits -= r
+                x = self.fp.read(1)
+                if not x: raise EOFError
+                self.buff = ord(x)
+                self.bpos = 0
+        return v
+
+    def feed(self, code):
+        x = ''
+        if code == 256:
+            self.table = [ chr(c) for c in xrange(256) ] # 0-255
+            self.table.append(None) # 256
+            self.table.append(None) # 257
+            self.prevbuf = ''
+            self.nbits = 9
+        elif code == 257:
+            pass
+        elif not self.prevbuf:
+            x = self.prevbuf = self.table[code]
+        else:
+            if code < len(self.table):
+                x = self.table[code]
+                self.table.append(self.prevbuf+x[0])
+            else:
+                self.table.append(self.prevbuf+self.prevbuf[0])
+                x = self.table[code]
+            l = len(self.table)
+            if l == 511:
+                self.nbits = 10
+            elif l == 1023:
+                self.nbits = 11
+            elif l == 2047:
+                self.nbits = 12
+            self.prevbuf = x
+        return x
+
+    def run(self):
+        while 1:
+            try:
+                code = self.readbits(self.nbits)
+            except EOFError:
+                break
+            x = self.feed(code)
+            yield x
+            if self.debug:
+                print >>stderr, ('nbits=%d, code=%d, output=%r, table=%r' %
+                                 (self.nbits, code, x, self.table[258:]))
+        return
 
-  def feed(self, code):
-    x = ''
-    if code == 256:
-      self.table = [ chr(c) for c in xrange(256) ] # 0-255
-      self.table.append(None) # 256
-      self.table.append(None) # 257
-      self.prevbuf = ''
-      self.nbits = 9
-    elif code == 257:
-      pass
-    elif not self.prevbuf:
-      x = self.prevbuf = self.table[code]
-    else:
-      if code < len(self.table):
-        x = self.table[code]
-        self.table.append(self.prevbuf+x[0])
-      else:
-        self.table.append(self.prevbuf+self.prevbuf[0])
-        x = self.table[code]
-      l = len(self.table)
-      if l == 511:
-        self.nbits = 10
-      elif l == 1023:
-        self.nbits = 11
-      elif l == 2047:
-        self.nbits = 12
-      self.prevbuf = x
-    return x
-  
-  def run(self):
-    while 1:
-      try:
-        code = self.readbits(self.nbits)
-      except EOFError:
-        break
-      x = self.feed(code)
-      yield x
-      if self.debug:
-        print >>stderr, ('nbits=%d, code=%d, output=%r, table=%r' %
-                         (self.nbits, code, x, self.table[258:]))
-    return
-    
 
 def main(argv):
-  import StringIO
-  data = '\x80\x0b\x60\x50\x22\x0c\x0c\x85\x01'
-  fp = StringIO.StringIO(data)
-  expected = '\x2d\x2d\x2d\x2d\x2d\x41\x2d\x2d\x2d\x42'
-  LZWDecoder.debug = 1
-  output = ''.join(LZWDecoder(fp).run())
-  print (data, expected, output)
-  print output == expected
-  return 0
+    import StringIO
+    data = '\x80\x0b\x60\x50\x22\x0c\x0c\x85\x01'
+    fp = StringIO.StringIO(data)
+    expected = '\x2d\x2d\x2d\x2d\x2d\x41\x2d\x2d\x2d\x42'
+    LZWDecoder.debug = 1
+    output = ''.join(LZWDecoder(fp).run())
+    print (data, expected, output)
+    print output == expected
+    return 0
 
 if __name__ == '__main__': sys.exit(main(sys.argv))
diff --git a/pdfminer/pdfcolor.py b/pdfminer/pdfcolor.py
index 61338d4..20bcd72 100644
--- a/pdfminer/pdfcolor.py
+++ b/pdfminer/pdfcolor.py
@@ -10,14 +10,14 @@ LITERAL_DEVICE_RGB = PSLiteralTable.intern('DeviceRGB')
 LITERAL_DEVICE_CMYK = PSLiteralTable.intern('DeviceCMYK')
 
 class PDFColorSpace(object):
-  
-  def __init__(self, name, ncomponents):
-    self.name = name
-    self.ncomponents = ncomponents
-    return
-  
-  def __repr__(self):
-    return '<PDFColorSpace: %s, ncomponents=%d>' % (self.name, self.ncomponents)
+
+    def __init__(self, name, ncomponents):
+        self.name = name
+        self.ncomponents = ncomponents
+        return
+
+    def __repr__(self):
+        return '<PDFColorSpace: %s, ncomponents=%d>' % (self.name, self.ncomponents)
 
 
 PREDEFINED_COLORSPACE = dict(
diff --git a/pdfminer/pdfdevice.py b/pdfminer/pdfdevice.py
index 2add9c2..fa63357 100644
--- a/pdfminer/pdfdevice.py
+++ b/pdfminer/pdfdevice.py
@@ -9,116 +9,116 @@ from pdfminer.pdffont import PDFUnicodeNotDefined
 ##
 class PDFDevice(object):
 
-  debug = 0
-  
-  def __init__(self, rsrc):
-    self.rsrc = rsrc
-    self.ctm = None
-    return
-  
-  def __repr__(self):
-    return '<PDFDevice>'
+    debug = 0
 
-  def close(self):
-    return
+    def __init__(self, rsrc):
+        self.rsrc = rsrc
+        self.ctm = None
+        return
 
-  def set_ctm(self, ctm):
-    self.ctm = ctm
-    return
+    def __repr__(self):
+        return '<PDFDevice>'
 
-  def begin_tag(self, tag, props=None):
-    return
-  def end_tag(self):
-    return
-  def do_tag(self, tag, props=None):
-    return
+    def close(self):
+        return
 
-  def begin_page(self, page, ctm):
-    return
-  def end_page(self, page):
-    return
-  def begin_figure(self, name, bbox, matrix):
-    return
-  def end_figure(self, name):
-    return
+    def set_ctm(self, ctm):
+        self.ctm = ctm
+        return
 
-  def paint_path(self, graphicstate, stroke, fill, evenodd, path):
-    return
-  def render_image(self, stream, size):
-    return
-  def render_string(self, textstate, seq):
-    return
+    def begin_tag(self, tag, props=None):
+        return
+    def end_tag(self):
+        return
+    def do_tag(self, tag, props=None):
+        return
+
+    def begin_page(self, page, ctm):
+        return
+    def end_page(self, page):
+        return
+    def begin_figure(self, name, bbox, matrix):
+        return
+    def end_figure(self, name):
+        return
+
+    def paint_path(self, graphicstate, stroke, fill, evenodd, path):
+        return
+    def render_image(self, stream, size):
+        return
+    def render_string(self, textstate, seq):
+        return
 
 
 ##  PDFTextDevice
 ##
 class PDFTextDevice(PDFDevice):
 
-  def handle_undefined_char(self, cidcoding, cid):
-    if self.debug:
-      print >>sys.stderr, 'undefined: %r, %r' % (cidcoding, cid)
-    return '?'
+    def handle_undefined_char(self, cidcoding, cid):
+        if self.debug:
+            print >>sys.stderr, 'undefined: %r, %r' % (cidcoding, cid)
+        return '?'
 
-  def render_chars(self, matrix, font, fontsize, charspace, scaling, chars):
-    return (0, 0)
+    def render_chars(self, matrix, font, fontsize, charspace, scaling, chars):
+        return (0, 0)
 
-  def render_string(self, textstate, seq):
-    matrix = mult_matrix(textstate.matrix, self.ctm)
-    font = textstate.font
-    fontsize = textstate.fontsize
-    scaling = textstate.scaling * .01
-    charspace = textstate.charspace * scaling
-    wordspace = textstate.wordspace * scaling
-    dxscale = .001 * fontsize * scaling
-    chars = []
-    needspace = False
-    (x,y) = textstate.linematrix
-    for obj in seq:
-      if isinstance(obj, int) or isinstance(obj, float):
-        (dx,dy) = self.render_chars(translate_matrix(matrix, (x,y)), font,
-                                    fontsize, charspace, scaling, chars)
-        x += dx
-        y += dy
-        d = -obj*dxscale
-        if font.is_vertical():
-          y += d
-        else:
-          x += d
+    def render_string(self, textstate, seq):
+        matrix = mult_matrix(textstate.matrix, self.ctm)
+        font = textstate.font
+        fontsize = textstate.fontsize
+        scaling = textstate.scaling * .01
+        charspace = textstate.charspace * scaling
+        wordspace = textstate.wordspace * scaling
+        dxscale = .001 * fontsize * scaling
         chars = []
         needspace = False
-      else:
-        for cid in font.decode(obj):
-          try:
-            char = font.to_unicode(cid)
-          except PDFUnicodeNotDefined, e:
-            (cidcoding, cid) = e.args
-            char = self.handle_undefined_char(cidcoding, cid)
-          chars.append((char, cid))
-          if cid == 32 and textstate.wordspace and not font.is_multibyte():
+        (x,y) = textstate.linematrix
+        for obj in seq:
+            if isinstance(obj, int) or isinstance(obj, float):
+                (dx,dy) = self.render_chars(translate_matrix(matrix, (x,y)), font,
+                                            fontsize, charspace, scaling, chars)
+                x += dx
+                y += dy
+                d = -obj*dxscale
+                if font.is_vertical():
+                    y += d
+                else:
+                    x += d
+                chars = []
+                needspace = False
+            else:
+                for cid in font.decode(obj):
+                    try:
+                        char = font.to_unicode(cid)
+                    except PDFUnicodeNotDefined, e:
+                        (cidcoding, cid) = e.args
+                        char = self.handle_undefined_char(cidcoding, cid)
+                    chars.append((char, cid))
+                    if cid == 32 and textstate.wordspace and not font.is_multibyte():
+                        if needspace:
+                            if font.is_vertical():
+                                y += charspace
+                            else:
+                                x += charspace
+                        (dx,dy) = self.render_chars(translate_matrix(matrix, (x,y)), font,
+                                                    fontsize, charspace, scaling, chars)
+                        needspace = True
+                        x += dx
+                        y += dy
+                        if font.is_vertical():
+                            y += wordspace
+                        else:
+                            x += wordspace
+                        chars = []
+        if chars:
             if needspace:
-              if font.is_vertical():
-                y += charspace
-              else:
-                x += charspace
+                if font.is_vertical():
+                    y += charspace
+                else:
+                    x += charspace
             (dx,dy) = self.render_chars(translate_matrix(matrix, (x,y)), font,
                                         fontsize, charspace, scaling, chars)
-            needspace = True
             x += dx
             y += dy
-            if font.is_vertical():
-              y += wordspace
-            else:
-              x += wordspace
-            chars = []
-    if chars:
-      if needspace:
-        if font.is_vertical():
-          y += charspace
-        else:
-          x += charspace
-      (dx,dy) = self.render_chars(translate_matrix(matrix, (x,y)), font,
-                                  fontsize, charspace, scaling, chars)
-      x += dx
-      y += dy
-    textstate.linematrix = (x,y)
-    return
+        textstate.linematrix = (x,y)
+        return
diff --git a/pdfminer/pdffont.py b/pdfminer/pdffont.py
index 43e5409..90216c4 100644
--- a/pdfminer/pdffont.py
+++ b/pdfminer/pdffont.py
@@ -2,9 +2,9 @@
 import sys
 from struct import pack, unpack
 try:
-  from cStringIO import StringIO
+    from cStringIO import StringIO
 except ImportError:
-  from StringIO import StringIO
+    from StringIO import StringIO
 from pdfminer.psparser import PSLiteralTable, PSKeywordTable, PSLiteral, \
      literal_name, keyword_name, STRICT
 from pdfminer.pdftypes import PDFException, \
@@ -20,290 +20,290 @@ from pdfminer.utils import apply_matrix_norm, nunpack
 ##
 NIBBLES = ('0','1','2','3','4','5','6','7','8','9','.','e','e-',None,'-')
 def getdict(data):
-  d = {}
-  fp = StringIO(data)
-  stack = []
-  while 1:
-    c = fp.read(1)
-    if not c: break
-    b0 = ord(c)
-    if b0 <= 21:
-      d[b0] = stack
-      stack = []
-      continue
-    if b0 == 30:
-      s = ''
-      loop = True
-      while loop:
-        b = ord(fp.read(1))
-        for n in (b >> 4, b & 15):
-          if n == 15:
-            loop = False
-          else:
-            s += NIBBLES[n]
-      value = float(s)
-    elif 32 <= b0 and b0 <= 246:
-      value = b0-139
-    else:
-      b1 = ord(fp.read(1))
-      if 247 <= b0 and b0 <= 250:
-        value = ((b0-247)<<8)+b1+108
-      elif 251 <= b0 and b0 <= 254:
-        value = -((b0-251)<<8)-b1-108
-      else:
-        b2 = ord(fp.read(1))
-        if 128 <= b1: b1 -= 256
-        if b0 == 28:
-          value = b1<<8 | b2
+    d = {}
+    fp = StringIO(data)
+    stack = []
+    while 1:
+        c = fp.read(1)
+        if not c: break
+        b0 = ord(c)
+        if b0 <= 21:
+            d[b0] = stack
+            stack = []
+            continue
+        if b0 == 30:
+            s = ''
+            loop = True
+            while loop:
+                b = ord(fp.read(1))
+                for n in (b >> 4, b & 15):
+                    if n == 15:
+                        loop = False
+                    else:
+                        s += NIBBLES[n]
+            value = float(s)
+        elif 32 <= b0 and b0 <= 246:
+            value = b0-139
         else:
-          value = b1<<24 | b2<<16 | unpack('>H', fp.read(2))[0]
-    stack.append(value)
-  return d
+            b1 = ord(fp.read(1))
+            if 247 <= b0 and b0 <= 250:
+                value = ((b0-247)<<8)+b1+108
+            elif 251 <= b0 and b0 <= 254:
+                value = -((b0-251)<<8)-b1-108
+            else:
+                b2 = ord(fp.read(1))
+                if 128 <= b1: b1 -= 256
+                if b0 == 28:
+                    value = b1<<8 | b2
+                else:
+                    value = b1<<24 | b2<<16 | unpack('>H', fp.read(2))[0]
+        stack.append(value)
+    return d
 
 class CFFFont(object):
 
-  STANDARD_STRINGS = (
-    '.notdef', 'space', 'exclam', 'quotedbl', 'numbersign',
-    'dollar', 'percent', 'ampersand', 'quoteright', 'parenleft',
-    'parenright', 'asterisk', 'plus', 'comma', 'hyphen', 'period',
-    'slash', 'zero', 'one', 'two', 'three', 'four', 'five', 'six',
-    'seven', 'eight', 'nine', 'colon', 'semicolon', 'less', 'equal',
-    'greater', 'question', 'at', 'A', 'B', 'C', 'D', 'E', 'F', 'G',
-    'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T',
-    'U', 'V', 'W', 'X', 'Y', 'Z', 'bracketleft', 'backslash',
-    'bracketright', 'asciicircum', 'underscore', 'quoteleft', 'a',
-    'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n',
-    'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z',
-    'braceleft', 'bar', 'braceright', 'asciitilde', 'exclamdown',
-    'cent', 'sterling', 'fraction', 'yen', 'florin', 'section',
-    'currency', 'quotesingle', 'quotedblleft', 'guillemotleft',
-    'guilsinglleft', 'guilsinglright', 'fi', 'fl', 'endash',
-    'dagger', 'daggerdbl', 'periodcentered', 'paragraph', 'bullet',
-    'quotesinglbase', 'quotedblbase', 'quotedblright',
-    'guillemotright', 'ellipsis', 'perthousand', 'questiondown',
-    'grave', 'acute', 'circumflex', 'tilde', 'macron', 'breve',
-    'dotaccent', 'dieresis', 'ring', 'cedilla', 'hungarumlaut',
-    'ogonek', 'caron', 'emdash', 'AE', 'ordfeminine', 'Lslash',
-    'Oslash', 'OE', 'ordmasculine', 'ae', 'dotlessi', 'lslash',
-    'oslash', 'oe', 'germandbls', 'onesuperior', 'logicalnot', 'mu',
-    'trademark', 'Eth', 'onehalf', 'plusminus', 'Thorn',
-    'onequarter', 'divide', 'brokenbar', 'degree', 'thorn',
-    'threequarters', 'twosuperior', 'registered', 'minus', 'eth',
-    'multiply', 'threesuperior', 'copyright', 'Aacute',
-    'Acircumflex', 'Adieresis', 'Agrave', 'Aring', 'Atilde',
-    'Ccedilla', 'Eacute', 'Ecircumflex', 'Edieresis', 'Egrave',
-    'Iacute', 'Icircumflex', 'Idieresis', 'Igrave', 'Ntilde',
-    'Oacute', 'Ocircumflex', 'Odieresis', 'Ograve', 'Otilde',
-    'Scaron', 'Uacute', 'Ucircumflex', 'Udieresis', 'Ugrave',
-    'Yacute', 'Ydieresis', 'Zcaron', 'aacute', 'acircumflex',
-    'adieresis', 'agrave', 'aring', 'atilde', 'ccedilla', 'eacute',
-    'ecircumflex', 'edieresis', 'egrave', 'iacute', 'icircumflex',
-    'idieresis', 'igrave', 'ntilde', 'oacute', 'ocircumflex',
-    'odieresis', 'ograve', 'otilde', 'scaron', 'uacute',
-    'ucircumflex', 'udieresis', 'ugrave', 'yacute', 'ydieresis',
-    'zcaron', 'exclamsmall', 'Hungarumlautsmall', 'dollaroldstyle',
-    'dollarsuperior', 'ampersandsmall', 'Acutesmall',
-    'parenleftsuperior', 'parenrightsuperior', 'twodotenleader',
-    'onedotenleader', 'zerooldstyle', 'oneoldstyle', 'twooldstyle',
-    'threeoldstyle', 'fouroldstyle', 'fiveoldstyle', 'sixoldstyle',
-    'sevenoldstyle', 'eightoldstyle', 'nineoldstyle',
-    'commasuperior', 'threequartersemdash', 'periodsuperior',
-    'questionsmall', 'asuperior', 'bsuperior', 'centsuperior',
-    'dsuperior', 'esuperior', 'isuperior', 'lsuperior', 'msuperior',
-    'nsuperior', 'osuperior', 'rsuperior', 'ssuperior', 'tsuperior',
-    'ff', 'ffi', 'ffl', 'parenleftinferior', 'parenrightinferior',
-    'Circumflexsmall', 'hyphensuperior', 'Gravesmall', 'Asmall',
-    'Bsmall', 'Csmall', 'Dsmall', 'Esmall', 'Fsmall', 'Gsmall',
-    'Hsmall', 'Ismall', 'Jsmall', 'Ksmall', 'Lsmall', 'Msmall',
-    'Nsmall', 'Osmall', 'Psmall', 'Qsmall', 'Rsmall', 'Ssmall',
-    'Tsmall', 'Usmall', 'Vsmall', 'Wsmall', 'Xsmall', 'Ysmall',
-    'Zsmall', 'colonmonetary', 'onefitted', 'rupiah', 'Tildesmall',
-    'exclamdownsmall', 'centoldstyle', 'Lslashsmall', 'Scaronsmall',
-    'Zcaronsmall', 'Dieresissmall', 'Brevesmall', 'Caronsmall',
-    'Dotaccentsmall', 'Macronsmall', 'figuredash', 'hypheninferior',
-    'Ogoneksmall', 'Ringsmall', 'Cedillasmall', 'questiondownsmall',
-    'oneeighth', 'threeeighths', 'fiveeighths', 'seveneighths',
-    'onethird', 'twothirds', 'zerosuperior', 'foursuperior',
-    'fivesuperior', 'sixsuperior', 'sevensuperior', 'eightsuperior',
-    'ninesuperior', 'zeroinferior', 'oneinferior', 'twoinferior',
-    'threeinferior', 'fourinferior', 'fiveinferior', 'sixinferior',
-    'seveninferior', 'eightinferior', 'nineinferior',
-    'centinferior', 'dollarinferior', 'periodinferior',
-    'commainferior', 'Agravesmall', 'Aacutesmall',
-    'Acircumflexsmall', 'Atildesmall', 'Adieresissmall',
-    'Aringsmall', 'AEsmall', 'Ccedillasmall', 'Egravesmall',
-    'Eacutesmall', 'Ecircumflexsmall', 'Edieresissmall',
-    'Igravesmall', 'Iacutesmall', 'Icircumflexsmall',
-    'Idieresissmall', 'Ethsmall', 'Ntildesmall', 'Ogravesmall',
-    'Oacutesmall', 'Ocircumflexsmall', 'Otildesmall',
-    'Odieresissmall', 'OEsmall', 'Oslashsmall', 'Ugravesmall',
-    'Uacutesmall', 'Ucircumflexsmall', 'Udieresissmall',
-    'Yacutesmall', 'Thornsmall', 'Ydieresissmall', '001.000',
-    '001.001', '001.002', '001.003', 'Black', 'Bold', 'Book',
-    'Light', 'Medium', 'Regular', 'Roman', 'Semibold',
-    )
+    STANDARD_STRINGS = (
+      '.notdef', 'space', 'exclam', 'quotedbl', 'numbersign',
+      'dollar', 'percent', 'ampersand', 'quoteright', 'parenleft',
+      'parenright', 'asterisk', 'plus', 'comma', 'hyphen', 'period',
+      'slash', 'zero', 'one', 'two', 'three', 'four', 'five', 'six',
+      'seven', 'eight', 'nine', 'colon', 'semicolon', 'less', 'equal',
+      'greater', 'question', 'at', 'A', 'B', 'C', 'D', 'E', 'F', 'G',
+      'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T',
+      'U', 'V', 'W', 'X', 'Y', 'Z', 'bracketleft', 'backslash',
+      'bracketright', 'asciicircum', 'underscore', 'quoteleft', 'a',
+      'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n',
+      'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z',
+      'braceleft', 'bar', 'braceright', 'asciitilde', 'exclamdown',
+      'cent', 'sterling', 'fraction', 'yen', 'florin', 'section',
+      'currency', 'quotesingle', 'quotedblleft', 'guillemotleft',
+      'guilsinglleft', 'guilsinglright', 'fi', 'fl', 'endash',
+      'dagger', 'daggerdbl', 'periodcentered', 'paragraph', 'bullet',
+      'quotesinglbase', 'quotedblbase', 'quotedblright',
+      'guillemotright', 'ellipsis', 'perthousand', 'questiondown',
+      'grave', 'acute', 'circumflex', 'tilde', 'macron', 'breve',
+      'dotaccent', 'dieresis', 'ring', 'cedilla', 'hungarumlaut',
+      'ogonek', 'caron', 'emdash', 'AE', 'ordfeminine', 'Lslash',
+      'Oslash', 'OE', 'ordmasculine', 'ae', 'dotlessi', 'lslash',
+      'oslash', 'oe', 'germandbls', 'onesuperior', 'logicalnot', 'mu',
+      'trademark', 'Eth', 'onehalf', 'plusminus', 'Thorn',
+      'onequarter', 'divide', 'brokenbar', 'degree', 'thorn',
+      'threequarters', 'twosuperior', 'registered', 'minus', 'eth',
+      'multiply', 'threesuperior', 'copyright', 'Aacute',
+      'Acircumflex', 'Adieresis', 'Agrave', 'Aring', 'Atilde',
+      'Ccedilla', 'Eacute', 'Ecircumflex', 'Edieresis', 'Egrave',
+      'Iacute', 'Icircumflex', 'Idieresis', 'Igrave', 'Ntilde',
+      'Oacute', 'Ocircumflex', 'Odieresis', 'Ograve', 'Otilde',
+      'Scaron', 'Uacute', 'Ucircumflex', 'Udieresis', 'Ugrave',
+      'Yacute', 'Ydieresis', 'Zcaron', 'aacute', 'acircumflex',
+      'adieresis', 'agrave', 'aring', 'atilde', 'ccedilla', 'eacute',
+      'ecircumflex', 'edieresis', 'egrave', 'iacute', 'icircumflex',
+      'idieresis', 'igrave', 'ntilde', 'oacute', 'ocircumflex',
+      'odieresis', 'ograve', 'otilde', 'scaron', 'uacute',
+      'ucircumflex', 'udieresis', 'ugrave', 'yacute', 'ydieresis',
+      'zcaron', 'exclamsmall', 'Hungarumlautsmall', 'dollaroldstyle',
+      'dollarsuperior', 'ampersandsmall', 'Acutesmall',
+      'parenleftsuperior', 'parenrightsuperior', 'twodotenleader',
+      'onedotenleader', 'zerooldstyle', 'oneoldstyle', 'twooldstyle',
+      'threeoldstyle', 'fouroldstyle', 'fiveoldstyle', 'sixoldstyle',
+      'sevenoldstyle', 'eightoldstyle', 'nineoldstyle',
+      'commasuperior', 'threequartersemdash', 'periodsuperior',
+      'questionsmall', 'asuperior', 'bsuperior', 'centsuperior',
+      'dsuperior', 'esuperior', 'isuperior', 'lsuperior', 'msuperior',
+      'nsuperior', 'osuperior', 'rsuperior', 'ssuperior', 'tsuperior',
+      'ff', 'ffi', 'ffl', 'parenleftinferior', 'parenrightinferior',
+      'Circumflexsmall', 'hyphensuperior', 'Gravesmall', 'Asmall',
+      'Bsmall', 'Csmall', 'Dsmall', 'Esmall', 'Fsmall', 'Gsmall',
+      'Hsmall', 'Ismall', 'Jsmall', 'Ksmall', 'Lsmall', 'Msmall',
+      'Nsmall', 'Osmall', 'Psmall', 'Qsmall', 'Rsmall', 'Ssmall',
+      'Tsmall', 'Usmall', 'Vsmall', 'Wsmall', 'Xsmall', 'Ysmall',
+      'Zsmall', 'colonmonetary', 'onefitted', 'rupiah', 'Tildesmall',
+      'exclamdownsmall', 'centoldstyle', 'Lslashsmall', 'Scaronsmall',
+      'Zcaronsmall', 'Dieresissmall', 'Brevesmall', 'Caronsmall',
+      'Dotaccentsmall', 'Macronsmall', 'figuredash', 'hypheninferior',
+      'Ogoneksmall', 'Ringsmall', 'Cedillasmall', 'questiondownsmall',
+      'oneeighth', 'threeeighths', 'fiveeighths', 'seveneighths',
+      'onethird', 'twothirds', 'zerosuperior', 'foursuperior',
+      'fivesuperior', 'sixsuperior', 'sevensuperior', 'eightsuperior',
+      'ninesuperior', 'zeroinferior', 'oneinferior', 'twoinferior',
+      'threeinferior', 'fourinferior', 'fiveinferior', 'sixinferior',
+      'seveninferior', 'eightinferior', 'nineinferior',
+      'centinferior', 'dollarinferior', 'periodinferior',
+      'commainferior', 'Agravesmall', 'Aacutesmall',
+      'Acircumflexsmall', 'Atildesmall', 'Adieresissmall',
+      'Aringsmall', 'AEsmall', 'Ccedillasmall', 'Egravesmall',
+      'Eacutesmall', 'Ecircumflexsmall', 'Edieresissmall',
+      'Igravesmall', 'Iacutesmall', 'Icircumflexsmall',
+      'Idieresissmall', 'Ethsmall', 'Ntildesmall', 'Ogravesmall',
+      'Oacutesmall', 'Ocircumflexsmall', 'Otildesmall',
+      'Odieresissmall', 'OEsmall', 'Oslashsmall', 'Ugravesmall',
+      'Uacutesmall', 'Ucircumflexsmall', 'Udieresissmall',
+      'Yacutesmall', 'Thornsmall', 'Ydieresissmall', '001.000',
+      '001.001', '001.002', '001.003', 'Black', 'Bold', 'Book',
+      'Light', 'Medium', 'Regular', 'Roman', 'Semibold',
+      )
 
-  class INDEX(object):
-    
-    def __init__(self, fp):
-      self.fp = fp
-      self.offsets = []
-      (count, offsize) = unpack('>HB', self.fp.read(3))
-      for i in xrange(count+1):
-        self.offsets.append(nunpack(self.fp.read(offsize)))
-      self.base = self.fp.tell()-1
-      self.fp.seek(self.base+self.offsets[-1])
-      return
+    class INDEX(object):
 
-    def __repr__(self):
-      return '<INDEX: size=%d>' % len(self)
+        def __init__(self, fp):
+            self.fp = fp
+            self.offsets = []
+            (count, offsize) = unpack('>HB', self.fp.read(3))
+            for i in xrange(count+1):
+                self.offsets.append(nunpack(self.fp.read(offsize)))
+            self.base = self.fp.tell()-1
+            self.fp.seek(self.base+self.offsets[-1])
+            return
 
-    def __len__(self):
-      return len(self.offsets)-1
+        def __repr__(self):
+            return '<INDEX: size=%d>' % len(self)
 
-    def __getitem__(self, i):
-      self.fp.seek(self.base+self.offsets[i])
-      return self.fp.read(self.offsets[i+1]-self.offsets[i])
+        def __len__(self):
+            return len(self.offsets)-1
 
-    def __iter__(self):
-      return iter( self[i] for i in xrange(len(self)) )
+        def __getitem__(self, i):
+            self.fp.seek(self.base+self.offsets[i])
+            return self.fp.read(self.offsets[i+1]-self.offsets[i])
 
-  def __init__(self, fp0):
-    self.fp = fp0
-    # Header
-    (_major,_minor,hdrsize,self.offsize) = unpack('BBBB', self.fp.read(4))
-    self.fp.read(hdrsize-4)
-    # Name INDEX
-    self.name_index = self.INDEX(self.fp)
-    # Top DICT INDEX
-    self.dict_index = self.INDEX(self.fp)
-    # String INDEX
-    self.string_index = self.INDEX(self.fp)
-    # Global Subr INDEX
-    self.subr_index = self.INDEX(self.fp)
-    # Top DICT DATA
-    self.top_dict = getdict(self.dict_index[0])
-    (charset_pos,) = self.top_dict.get(15, 0)
-    (encoding_pos,) = self.top_dict.get(16, 0)
-    (charstring_pos,) = self.top_dict.get(17, 0)
-    # CharStrings
-    self.fp.seek(charstring_pos)
-    self.charstring = self.INDEX(self.fp)
-    self.nglyphs = len(self.charstring)
-    # Encodings
-    self.code2gid = {}
-    self.gid2code = {}
-    self.fp.seek(encoding_pos)
-    format = self.fp.read(1)
-    if format == '\x00':
-      # Format 0
-      (n,) = unpack('B', self.fp.read(1))
-      for (code,gid) in enumerate(unpack('B'*n, self.fp.read(n))):
-        self.code2gid[code] = gid
-        self.gid2code[gid] = code
-    else:
-      # Format 1
-      assert 0
-    # Charsets
-    self.name2gid = {}
-    self.gid2name = {}
-    self.fp.seek(charset_pos)
-    format = self.fp.read(1)
-    if format == '\x00':
-      # Format 0
-      n = self.nglyphs-1
-      for (gid,sid) in enumerate(unpack('>'+'H'*n, self.fp.read(2*n))):
-        gid += 1
-        name = self.getstr(sid)
-        self.name2gid[name] = gid
-        self.gid2name[gid] = name
-    else:
-      # Format 1
-      assert 0
-    #print self.code2gid
-    #print self.name2gid
-    #assert 0
-    return
+        def __iter__(self):
+            return iter( self[i] for i in xrange(len(self)) )
+
+    def __init__(self, fp0):
+        self.fp = fp0
+        # Header
+        (_major,_minor,hdrsize,self.offsize) = unpack('BBBB', self.fp.read(4))
+        self.fp.read(hdrsize-4)
+        # Name INDEX
+        self.name_index = self.INDEX(self.fp)
+        # Top DICT INDEX
+        self.dict_index = self.INDEX(self.fp)
+        # String INDEX
+        self.string_index = self.INDEX(self.fp)
+        # Global Subr INDEX
+        self.subr_index = self.INDEX(self.fp)
+        # Top DICT DATA
+        self.top_dict = getdict(self.dict_index[0])
+        (charset_pos,) = self.top_dict.get(15, 0)
+        (encoding_pos,) = self.top_dict.get(16, 0)
+        (charstring_pos,) = self.top_dict.get(17, 0)
+        # CharStrings
+        self.fp.seek(charstring_pos)
+        self.charstring = self.INDEX(self.fp)
+        self.nglyphs = len(self.charstring)
+        # Encodings
+        self.code2gid = {}
+        self.gid2code = {}
+        self.fp.seek(encoding_pos)
+        format = self.fp.read(1)
+        if format == '\x00':
+            # Format 0
+            (n,) = unpack('B', self.fp.read(1))
+            for (code,gid) in enumerate(unpack('B'*n, self.fp.read(n))):
+                self.code2gid[code] = gid
+                self.gid2code[gid] = code
+        else:
+            # Format 1
+            assert 0
+        # Charsets
+        self.name2gid = {}
+        self.gid2name = {}
+        self.fp.seek(charset_pos)
+        format = self.fp.read(1)
+        if format == '\x00':
+            # Format 0
+            n = self.nglyphs-1
+            for (gid,sid) in enumerate(unpack('>'+'H'*n, self.fp.read(2*n))):
+                gid += 1
+                name = self.getstr(sid)
+                self.name2gid[name] = gid
+                self.gid2name[gid] = name
+        else:
+            # Format 1
+            assert 0
+        #print self.code2gid
+        #print self.name2gid
+        #assert 0
+        return
+
+    def getstr(self, sid):
+        if sid < len(self.STANDARD_STRINGS):
+            return self.STANDARD_STRINGS[sid]
+        return self.string_index[sid-len(self.STANDARD_STRINGS)]
 
-  def getstr(self, sid):
-    if sid < len(self.STANDARD_STRINGS):
-      return self.STANDARD_STRINGS[sid]
-    return self.string_index[sid-len(self.STANDARD_STRINGS)]
 
-  
 ##  TrueTypeFont
 ##
 class TrueTypeFont(object):
 
-  class CMapNotFound(Exception): pass
-  
-  def __init__(self, name, fp):
-    self.name = name
-    self.fp = fp
-    self.tables = {}
-    fonttype = fp.read(4)
-    (ntables, _1, _2, _3) = unpack('>HHHH', fp.read(8))
-    for _ in xrange(ntables):
-      (name, tsum, offset, length) = unpack('>4sLLL', fp.read(16))
-      self.tables[name] = (offset, length)
-    return
+    class CMapNotFound(Exception): pass
 
-  def create_cmap(self):
-    if 'cmap' not in self.tables:
-      raise TrueTypeFont.CMapNotFound
-    (base_offset, length) = self.tables['cmap']
-    fp = self.fp
-    fp.seek(base_offset)
-    (version, nsubtables) = unpack('>HH', fp.read(4))
-    subtables = []
-    for i in xrange(nsubtables):
-      subtables.append(unpack('>HHL', fp.read(8)))
-    char2gid = {}
-    # Only supports subtable type 0, 2 and 4.
-    for (_1, _2, st_offset) in subtables:
-      fp.seek(base_offset+st_offset)
-      (fmttype, fmtlen, fmtlang) = unpack('>HHH', fp.read(6))
-      if fmttype == 0:
-        char2gid.update(enumerate(unpack('>256B', fp.read(256))))
-      elif fmttype == 2:
-        subheaderkeys = unpack('>256H', fp.read(512))
-        firstbytes = [0]*8192
-        for (i,k) in enumerate(subheaderkeys):
-          firstbytes[k/8] = i
-        nhdrs = max(subheaderkeys)/8 + 1
-        hdrs = []
-        for i in xrange(nhdrs):
-          (firstcode,entcount,delta,offset) = unpack('>HHhH', fp.read(8))
-          hdrs.append((i,firstcode,entcount,delta,fp.tell()-2+offset))
-        for (i,firstcode,entcount,delta,pos) in hdrs:
-          if not entcount: continue
-          first = firstcode + (firstbytes[i] << 8)
-          fp.seek(pos)
-          for c in xrange(entcount):
-            gid = unpack('>H', fp.read(2))
-            if gid:
-              gid += delta
-            char2gid[first+c] = gid
-      elif fmttype == 4:
-        (segcount, _1, _2, _3) = unpack('>HHHH', fp.read(8))
-        segcount /= 2
-        ecs = unpack('>%dH' % segcount, fp.read(2*segcount))
-        fp.read(2)
-        scs = unpack('>%dH' % segcount, fp.read(2*segcount))
-        idds = unpack('>%dh' % segcount, fp.read(2*segcount))
-        pos = fp.tell()
-        idrs = unpack('>%dH' % segcount, fp.read(2*segcount))
-        for (ec,sc,idd,idr) in zip(ecs, scs, idds, idrs):
-          if idr:
-            fp.seek(pos+idr)
-            for c in xrange(sc, ec+1):
-              char2gid[c] = (unpack('>H', fp.read(2))[0] + idd) & 0xffff
-          else:
-            for c in xrange(sc, ec+1):
-              char2gid[c] = (c + idd) & 0xffff
-    gid2char = dict( (gid, pack('>H', char))
-                     for (char,gid) in char2gid.iteritems() )
-    return CMap().update(char2gid, gid2char)
+    def __init__(self, name, fp):
+        self.name = name
+        self.fp = fp
+        self.tables = {}
+        fonttype = fp.read(4)
+        (ntables, _1, _2, _3) = unpack('>HHHH', fp.read(8))
+        for _ in xrange(ntables):
+            (name, tsum, offset, length) = unpack('>4sLLL', fp.read(16))
+            self.tables[name] = (offset, length)
+        return
+
+    def create_cmap(self):
+        if 'cmap' not in self.tables:
+            raise TrueTypeFont.CMapNotFound
+        (base_offset, length) = self.tables['cmap']
+        fp = self.fp
+        fp.seek(base_offset)
+        (version, nsubtables) = unpack('>HH', fp.read(4))
+        subtables = []
+        for i in xrange(nsubtables):
+            subtables.append(unpack('>HHL', fp.read(8)))
+        char2gid = {}
+        # Only supports subtable type 0, 2 and 4.
+        for (_1, _2, st_offset) in subtables:
+            fp.seek(base_offset+st_offset)
+            (fmttype, fmtlen, fmtlang) = unpack('>HHH', fp.read(6))
+            if fmttype == 0:
+                char2gid.update(enumerate(unpack('>256B', fp.read(256))))
+            elif fmttype == 2:
+                subheaderkeys = unpack('>256H', fp.read(512))
+                firstbytes = [0]*8192
+                for (i,k) in enumerate(subheaderkeys):
+                    firstbytes[k/8] = i
+                nhdrs = max(subheaderkeys)/8 + 1
+                hdrs = []
+                for i in xrange(nhdrs):
+                    (firstcode,entcount,delta,offset) = unpack('>HHhH', fp.read(8))
+                    hdrs.append((i,firstcode,entcount,delta,fp.tell()-2+offset))
+                for (i,firstcode,entcount,delta,pos) in hdrs:
+                    if not entcount: continue
+                    first = firstcode + (firstbytes[i] << 8)
+                    fp.seek(pos)
+                    for c in xrange(entcount):
+                        gid = unpack('>H', fp.read(2))
+                        if gid:
+                            gid += delta
+                        char2gid[first+c] = gid
+            elif fmttype == 4:
+                (segcount, _1, _2, _3) = unpack('>HHHH', fp.read(8))
+                segcount /= 2
+                ecs = unpack('>%dH' % segcount, fp.read(2*segcount))
+                fp.read(2)
+                scs = unpack('>%dH' % segcount, fp.read(2*segcount))
+                idds = unpack('>%dh' % segcount, fp.read(2*segcount))
+                pos = fp.tell()
+                idrs = unpack('>%dH' % segcount, fp.read(2*segcount))
+                for (ec,sc,idd,idr) in zip(ecs, scs, idds, idrs):
+                    if idr:
+                        fp.seek(pos+idr)
+                        for c in xrange(sc, ec+1):
+                            char2gid[c] = (unpack('>H', fp.read(2))[0] + idd) & 0xffff
+                    else:
+                        for c in xrange(sc, ec+1):
+                            char2gid[c] = (c + idd) & 0xffff
+        gid2char = dict( (gid, pack('>H', char))
+                         for (char,gid) in char2gid.iteritems() )
+        return CMap().update(char2gid, gid2char)
 
 
 ##  Fonts
@@ -318,260 +318,260 @@ LITERAL_TYPE1C = PSLiteralTable.intern('Type1C')
 
 # PDFFont
 class PDFFont(object):
-  
-  def __init__(self, descriptor, widths, default_width=None):
-    self.descriptor = descriptor
-    self.widths = widths
-    self.fontname = descriptor.get('FontName', 'unknown')
-    if isinstance(self.fontname, PSLiteral):
-      self.fontname = literal_name(self.fontname)
-    self.ascent = num_value(descriptor.get('Ascent', 0))
-    self.descent = num_value(descriptor.get('Descent', 0))
-    self.default_width = default_width or descriptor.get('MissingWidth', 0)
-    self.leading = num_value(descriptor.get('Leading', 0))
-    self.bbox = list_value(descriptor.get('FontBBox', (0,0,0,0)))
-    self.size = self.bbox[3]-self.bbox[1]
-    if self.size == 0:
-      self.size = self.ascent - self.descent
-    self.hscale = self.vscale = .001
-    return
 
-  def __repr__(self):
-    return '<PDFFont>'
+    def __init__(self, descriptor, widths, default_width=None):
+        self.descriptor = descriptor
+        self.widths = widths
+        self.fontname = descriptor.get('FontName', 'unknown')
+        if isinstance(self.fontname, PSLiteral):
+            self.fontname = literal_name(self.fontname)
+        self.ascent = num_value(descriptor.get('Ascent', 0))
+        self.descent = num_value(descriptor.get('Descent', 0))
+        self.default_width = default_width or descriptor.get('MissingWidth', 0)
+        self.leading = num_value(descriptor.get('Leading', 0))
+        self.bbox = list_value(descriptor.get('FontBBox', (0,0,0,0)))
+        self.size = self.bbox[3]-self.bbox[1]
+        if self.size == 0:
+            self.size = self.ascent - self.descent
+        self.hscale = self.vscale = .001
+        return
 
-  def is_vertical(self):
-    return False
-  
-  def is_multibyte(self):
-    return False
-  
-  def decode(self, bytes):
-    return map(ord, bytes)
+    def __repr__(self):
+        return '<PDFFont>'
 
-  def get_ascent(self):
-    return self.ascent * self.vscale
-  def get_descent(self):
-    return self.descent * self.vscale
-  def get_size(self):
-    return self.size * self.vscale
-    
-  def char_width(self, cid):
-    return self.widths.get(cid, self.default_width) * self.hscale
+    def is_vertical(self):
+        return False
 
-  def char_disp(self, cid):
-    return 0
-  
-  def string_width(self, s):
-    return sum( self.char_width(cid) for cid in self.decode(s) )
+    def is_multibyte(self):
+        return False
+
+    def decode(self, bytes):
+        return map(ord, bytes)
+
+    def get_ascent(self):
+        return self.ascent * self.vscale
+    def get_descent(self):
+        return self.descent * self.vscale
+    def get_size(self):
+        return self.size * self.vscale
+
+    def char_width(self, cid):
+        return self.widths.get(cid, self.default_width) * self.hscale
+
+    def char_disp(self, cid):
+        return 0
+
+    def string_width(self, s):
+        return sum( self.char_width(cid) for cid in self.decode(s) )
 
 
 # PDFSimpleFont
 class PDFSimpleFont(PDFFont):
-  
-  def __init__(self, descriptor, widths, spec):
-    # Font encoding is specified either by a name of
-    # built-in encoding or a dictionary that describes
-    # the differences.
-    if 'Encoding' in spec:
-      encoding = resolve1(spec['Encoding'])
-    else:
-      encoding = LITERAL_STANDARD_ENCODING
-    if isinstance(encoding, dict):
-      name = literal_name(encoding.get('BaseEncoding', LITERAL_STANDARD_ENCODING))
-      diff = list_value(encoding.get('Differences', None))
-      self.encoding = EncodingDB.get_encoding(name, diff)
-    else:
-      self.encoding = EncodingDB.get_encoding(literal_name(encoding))
-    self.ucs2_cmap = None
-    if 'ToUnicode' in spec:
-      strm = stream_value(spec['ToUnicode'])
-      self.ucs2_cmap = CMap()
-      CMapParser(self.ucs2_cmap, StringIO(strm.get_data())).run()
-    PDFFont.__init__(self, descriptor, widths)
-    return
 
-  def to_unicode(self, cid):
-    if self.ucs2_cmap:
-      code = self.ucs2_cmap.tocode(cid)
-      if code:
-        chars = unpack('>%dH' % (len(code)/2), code)
-        return ''.join( unichr(c) for c in chars )
-    try:
-      return self.encoding[cid]
-    except KeyError:
-      raise PDFUnicodeNotDefined(None, cid)
+    def __init__(self, descriptor, widths, spec):
+        # Font encoding is specified either by a name of
+        # built-in encoding or a dictionary that describes
+        # the differences.
+        if 'Encoding' in spec:
+            encoding = resolve1(spec['Encoding'])
+        else:
+            encoding = LITERAL_STANDARD_ENCODING
+        if isinstance(encoding, dict):
+            name = literal_name(encoding.get('BaseEncoding', LITERAL_STANDARD_ENCODING))
+            diff = list_value(encoding.get('Differences', None))
+            self.encoding = EncodingDB.get_encoding(name, diff)
+        else:
+            self.encoding = EncodingDB.get_encoding(literal_name(encoding))
+        self.ucs2_cmap = None
+        if 'ToUnicode' in spec:
+            strm = stream_value(spec['ToUnicode'])
+            self.ucs2_cmap = CMap()
+            CMapParser(self.ucs2_cmap, StringIO(strm.get_data())).run()
+        PDFFont.__init__(self, descriptor, widths)
+        return
+
+    def to_unicode(self, cid):
+        if self.ucs2_cmap:
+            code = self.ucs2_cmap.tocode(cid)
+            if code:
+                chars = unpack('>%dH' % (len(code)/2), code)
+                return ''.join( unichr(c) for c in chars )
+        try:
+            return self.encoding[cid]
+        except KeyError:
+            raise PDFUnicodeNotDefined(None, cid)
 
 # PDFType1Font
 class PDFType1Font(PDFSimpleFont):
-  
-  def __init__(self, rsrc, spec):
-    try:
-      self.basefont = literal_name(spec['BaseFont'])
-    except KeyError:
-      if STRICT:
-        raise PDFFontError('BaseFont is missing')
-      self.basefont = 'unknown'
-    try:
-      (descriptor, widths) = FontMetricsDB.get_metrics(self.basefont)
-    except KeyError:
-      descriptor = dict_value(spec.get('FontDescriptor', {}))
-      firstchar = int_value(spec.get('FirstChar', 0))
-      lastchar = int_value(spec.get('LastChar', 255))
-      widths = list_value(spec.get('Widths', [0]*256))
-      widths = dict( (i+firstchar,w) for (i,w) in enumerate(widths) )
-    PDFSimpleFont.__init__(self, descriptor, widths, spec)
-    return
 
-  def __repr__(self):
-    return '<PDFType1Font: basefont=%r>' % self.basefont
+    def __init__(self, rsrc, spec):
+        try:
+            self.basefont = literal_name(spec['BaseFont'])
+        except KeyError:
+            if STRICT:
+                raise PDFFontError('BaseFont is missing')
+            self.basefont = 'unknown'
+        try:
+            (descriptor, widths) = FontMetricsDB.get_metrics(self.basefont)
+        except KeyError:
+            descriptor = dict_value(spec.get('FontDescriptor', {}))
+            firstchar = int_value(spec.get('FirstChar', 0))
+            lastchar = int_value(spec.get('LastChar', 255))
+            widths = list_value(spec.get('Widths', [0]*256))
+            widths = dict( (i+firstchar,w) for (i,w) in enumerate(widths) )
+        PDFSimpleFont.__init__(self, descriptor, widths, spec)
+        return
+
+    def __repr__(self):
+        return '<PDFType1Font: basefont=%r>' % self.basefont
 
 # PDFTrueTypeFont
 class PDFTrueTypeFont(PDFType1Font):
 
-  def __repr__(self):
-    return '<PDFTrueTypeFont: basefont=%r>' % self.basefont
+    def __repr__(self):
+        return '<PDFTrueTypeFont: basefont=%r>' % self.basefont
 
 # PDFType3Font
 class PDFType3Font(PDFSimpleFont):
-  
-  def __init__(self, rsrc, spec):
-    firstchar = int_value(spec.get('FirstChar', 0))
-    lastchar = int_value(spec.get('LastChar', 0))
-    widths = list_value(spec.get('Widths', [0]*256))
-    widths = dict( (i+firstchar,w) for (i,w) in enumerate(widths))
-    if 'FontDescriptor' in spec:
-      descriptor = dict_value(spec['FontDescriptor'])
-    else:
-      descriptor = {'FontName':spec.get('Name'),
-                    'Ascent':0, 'Descent':0,
-                    'FontBBox':spec['FontBBox']}
-    PDFSimpleFont.__init__(self, descriptor, widths, spec)
-    self.matrix = tuple(list_value(spec.get('FontMatrix')))
-    (_,self.descent,_,self.ascent) = self.bbox
-    (self.hscale,self.vscale) = apply_matrix_norm(self.matrix, (1,1))
-    return
 
-  def __repr__(self):
-    return '<PDFType3Font>'
+    def __init__(self, rsrc, spec):
+        firstchar = int_value(spec.get('FirstChar', 0))
+        lastchar = int_value(spec.get('LastChar', 0))
+        widths = list_value(spec.get('Widths', [0]*256))
+        widths = dict( (i+firstchar,w) for (i,w) in enumerate(widths))
+        if 'FontDescriptor' in spec:
+            descriptor = dict_value(spec['FontDescriptor'])
+        else:
+            descriptor = {'FontName':spec.get('Name'),
+                          'Ascent':0, 'Descent':0,
+                          'FontBBox':spec['FontBBox']}
+        PDFSimpleFont.__init__(self, descriptor, widths, spec)
+        self.matrix = tuple(list_value(spec.get('FontMatrix')))
+        (_,self.descent,_,self.ascent) = self.bbox
+        (self.hscale,self.vscale) = apply_matrix_norm(self.matrix, (1,1))
+        return
+
+    def __repr__(self):
+        return '<PDFType3Font>'
 
 
 # PDFCIDFont
 class PDFCIDFont(PDFFont):
-  
-  def __init__(self, rsrc, spec):
-    try:
-      self.basefont = literal_name(spec['BaseFont'])
-    except KeyError:
-      if STRICT:
-        raise PDFFontError('BaseFont is missing')
-      self.basefont = 'unknown'
-    self.cidsysteminfo = dict_value(spec.get('CIDSystemInfo', {}))
-    self.cidcoding = '%s-%s' % (self.cidsysteminfo.get('Registry', 'unknown'),
-                                self.cidsysteminfo.get('Ordering', 'unknown'))
-    try:
-      name = literal_name(spec['Encoding'])
-    except KeyError:
-      if STRICT:
-        raise PDFFontError('Encoding is unspecified')
-      name = 'unknown'
-    try:
-      self.cmap = rsrc.get_cmap(name, strict=STRICT)
-    except CMapDB.CMapNotFound, e:
-      raise PDFFontError(e)
-    try:
-      descriptor = dict_value(spec['FontDescriptor'])
-    except KeyError:
-      if STRICT:
-        raise PDFFontError('FontDescriptor is missing')
-      descriptor = {}
-    ttf = None
-    if 'FontFile2' in descriptor:
-      self.fontfile = stream_value(descriptor.get('FontFile2'))
-      ttf = TrueTypeFont(self.basefont,
-                         StringIO(self.fontfile.get_data()))
-    self.ucs2_cmap = None
-    if 'ToUnicode' in spec:
-      strm = stream_value(spec['ToUnicode'])
-      self.ucs2_cmap = CMap()
-      CMapParser(self.ucs2_cmap, StringIO(strm.get_data())).run()
-    elif self.cidcoding == 'Adobe-Identity':
-      if ttf:
+
+    def __init__(self, rsrc, spec):
         try:
-          self.ucs2_cmap = ttf.create_cmap()
-        except TrueTypeFont.CMapNotFound:
-          pass
-    else:
-      try:
-        self.ucs2_cmap = rsrc.get_cmap('%s-UCS2' % self.cidcoding,
-                                       strict=STRICT)
-      except CMapDB.CMapNotFound, e:
-        raise PDFFontError(e)
-    
-    def get_width(seq):
-      dic = {}
-      char1 = char2 = None
-      for v in seq:
-        if char1 == None:
-          char1 = v
-        elif char2 == None and isinstance(v, int):
-          char2 = v
+            self.basefont = literal_name(spec['BaseFont'])
+        except KeyError:
+            if STRICT:
+                raise PDFFontError('BaseFont is missing')
+            self.basefont = 'unknown'
+        self.cidsysteminfo = dict_value(spec.get('CIDSystemInfo', {}))
+        self.cidcoding = '%s-%s' % (self.cidsysteminfo.get('Registry', 'unknown'),
+                                    self.cidsysteminfo.get('Ordering', 'unknown'))
+        try:
+            name = literal_name(spec['Encoding'])
+        except KeyError:
+            if STRICT:
+                raise PDFFontError('Encoding is unspecified')
+            name = 'unknown'
+        try:
+            self.cmap = rsrc.get_cmap(name, strict=STRICT)
+        except CMapDB.CMapNotFound, e:
+            raise PDFFontError(e)
+        try:
+            descriptor = dict_value(spec['FontDescriptor'])
+        except KeyError:
+            if STRICT:
+                raise PDFFontError('FontDescriptor is missing')
+            descriptor = {}
+        ttf = None
+        if 'FontFile2' in descriptor:
+            self.fontfile = stream_value(descriptor.get('FontFile2'))
+            ttf = TrueTypeFont(self.basefont,
+                               StringIO(self.fontfile.get_data()))
+        self.ucs2_cmap = None
+        if 'ToUnicode' in spec:
+            strm = stream_value(spec['ToUnicode'])
+            self.ucs2_cmap = CMap()
+            CMapParser(self.ucs2_cmap, StringIO(strm.get_data())).run()
+        elif self.cidcoding == 'Adobe-Identity':
+            if ttf:
+                try:
+                    self.ucs2_cmap = ttf.create_cmap()
+                except TrueTypeFont.CMapNotFound:
+                    pass
         else:
-          if char2 == None:
-            for (i,w) in enumerate(v):
-              dic[char1+i] = w
-          else:
-            for i in xrange(char1, char2+1):
-              dic[i] = v
-          char1 = char2 = None
-      return dic
-    self.vertical = self.cmap.is_vertical()
-    if self.vertical:
-      # writing mode: vertical
-      dic = get_width(list_value(spec.get('W2', [])))
-      widths = dict( (cid,w) for (cid,(d,w)) in dic.iteritems() )
-      self.disps = dict( (cid,d) for (cid,(d,w)) in dic.iteritems() )
-      (d,w) = spec.get('DW2', [880, -1000])
-      default_width = w
-      self.default_disp = d
-    else:
-      # writing mode: horizontal
-      widths = get_width(list_value(spec.get('W', [])))
-      self.disps = {}
-      default_width = spec.get('DW', 1000)
-      self.default_disp = 0
-    PDFFont.__init__(self, descriptor, widths, default_width=default_width)
-    return
+            try:
+                self.ucs2_cmap = rsrc.get_cmap('%s-UCS2' % self.cidcoding,
+                                               strict=STRICT)
+            except CMapDB.CMapNotFound, e:
+                raise PDFFontError(e)
 
-  def __repr__(self):
-    return '<PDFCIDFont: basefont=%r, cidcoding=%r>' % (self.basefont, self.cidcoding)
-  
-  def is_vertical(self):
-    return self.vertical
+        def get_width(seq):
+            dic = {}
+            char1 = char2 = None
+            for v in seq:
+                if char1 == None:
+                    char1 = v
+                elif char2 == None and isinstance(v, int):
+                    char2 = v
+                else:
+                    if char2 == None:
+                        for (i,w) in enumerate(v):
+                            dic[char1+i] = w
+                    else:
+                        for i in xrange(char1, char2+1):
+                            dic[i] = v
+                    char1 = char2 = None
+            return dic
+        self.vertical = self.cmap.is_vertical()
+        if self.vertical:
+            # writing mode: vertical
+            dic = get_width(list_value(spec.get('W2', [])))
+            widths = dict( (cid,w) for (cid,(d,w)) in dic.iteritems() )
+            self.disps = dict( (cid,d) for (cid,(d,w)) in dic.iteritems() )
+            (d,w) = spec.get('DW2', [880, -1000])
+            default_width = w
+            self.default_disp = d
+        else:
+            # writing mode: horizontal
+            widths = get_width(list_value(spec.get('W', [])))
+            self.disps = {}
+            default_width = spec.get('DW', 1000)
+            self.default_disp = 0
+        PDFFont.__init__(self, descriptor, widths, default_width=default_width)
+        return
 
-  def is_multibyte(self):
-    return True
-  
-  def decode(self, bytes):
-    return self.cmap.decode(bytes)
+    def __repr__(self):
+        return '<PDFCIDFont: basefont=%r, cidcoding=%r>' % (self.basefont, self.cidcoding)
 
-  def char_disp(self, cid):
-    return self.disps.get(cid, self.default_disp)
+    def is_vertical(self):
+        return self.vertical
 
-  def to_unicode(self, cid):
-    if not self.ucs2_cmap:
-      raise PDFUnicodeNotDefined(self.cidcoding, cid)
-    code = self.ucs2_cmap.tocode(cid)
-    if not code:
-      raise PDFUnicodeNotDefined(self.cidcoding, cid)
-    chars = unpack('>%dH' % (len(code)/2), code)
-    return ''.join( unichr(c) for c in chars )
+    def is_multibyte(self):
+        return True
+
+    def decode(self, bytes):
+        return self.cmap.decode(bytes)
+
+    def char_disp(self, cid):
+        return self.disps.get(cid, self.default_disp)
+
+    def to_unicode(self, cid):
+        if not self.ucs2_cmap:
+            raise PDFUnicodeNotDefined(self.cidcoding, cid)
+        code = self.ucs2_cmap.tocode(cid)
+        if not code:
+            raise PDFUnicodeNotDefined(self.cidcoding, cid)
+        chars = unpack('>%dH' % (len(code)/2), code)
+        return ''.join( unichr(c) for c in chars )
 
 
 # main
 def main(argv):
-  for fname in argv[1:]:
-    fp = file(fname, 'rb')
-    CFFFont(fp)
-    fp.close()
-  return
+    for fname in argv[1:]:
+        fp = file(fname, 'rb')
+        CFFFont(fp)
+        fp.close()
+    return
 if __name__ == '__main__': sys.exit(main(sys.argv))
diff --git a/pdfminer/pdfinterp.py b/pdfminer/pdfinterp.py
index 7982c62..4966ecc 100644
--- a/pdfminer/pdfinterp.py
+++ b/pdfminer/pdfinterp.py
@@ -3,9 +3,9 @@ import sys, re
 stderr = sys.stderr
 from struct import pack, unpack
 try:
-  from cStringIO import StringIO
+    from cStringIO import StringIO
 except ImportError:
-  from StringIO import StringIO
+    from StringIO import StringIO
 from pdfminer.psparser import PSException, PSTypeError, PSEOF, \
      PSLiteralTable, PSKeywordTable, literal_name, keyword_name, \
      PSStackParser, PSKeyword, STRICT
@@ -39,712 +39,712 @@ LITERAL_IMAGE = PSLiteralTable.intern('Image')
 ##
 class PDFTextState(object):
 
-  def __init__(self):
-    self.font = None
-    self.fontsize = 0
-    self.charspace = 0
-    self.wordspace = 0
-    self.scaling = 100
-    self.leading = 0
-    self.render = 0
-    self.rise = 0
-    self.reset()
-    # self.matrix is set
-    # self.linematrix is set
-    return
+    def __init__(self):
+        self.font = None
+        self.fontsize = 0
+        self.charspace = 0
+        self.wordspace = 0
+        self.scaling = 100
+        self.leading = 0
+        self.render = 0
+        self.rise = 0
+        self.reset()
+        # self.matrix is set
+        # self.linematrix is set
+        return
 
-  def __repr__(self):
-    return ('<PDFTextState: font=%r, fontsize=%r, charspace=%r, wordspace=%r, '
-            ' scaling=%r, leading=%r, render=%r, rise=%r, '
-            ' matrix=%r, linematrix=%r>' %
-            (self.font, self.fontsize, self.charspace, self.wordspace, 
-             self.scaling, self.leading, self.render, self.rise,
-             self.matrix, self.linematrix))
+    def __repr__(self):
+        return ('<PDFTextState: font=%r, fontsize=%r, charspace=%r, wordspace=%r, '
+                ' scaling=%r, leading=%r, render=%r, rise=%r, '
+                ' matrix=%r, linematrix=%r>' %
+                (self.font, self.fontsize, self.charspace, self.wordspace,
+                 self.scaling, self.leading, self.render, self.rise,
+                 self.matrix, self.linematrix))
 
-  def reset(self):
-    self.matrix = MATRIX_IDENTITY
-    self.linematrix = (0, 0)
-    return
+    def reset(self):
+        self.matrix = MATRIX_IDENTITY
+        self.linematrix = (0, 0)
+        return
 
 
 ##  PDFGraphicState
 ##
 class PDFGraphicState(object):
 
-  def __init__(self):
-    self.linewidth = 0
-    self.linecap = None
-    self.linejoin = None
-    self.miterlimit = None
-    self.dash = None
-    self.intent = None
-    self.flatness = None
-    return
+    def __init__(self):
+        self.linewidth = 0
+        self.linecap = None
+        self.linejoin = None
+        self.miterlimit = None
+        self.dash = None
+        self.intent = None
+        self.flatness = None
+        return
 
-  def __repr__(self):
-    return ('<PDFGraphicState: linewidth=%r, linecap=%r, linejoin=%r, '
-            ' miterlimit=%r, dash=%r, intent=%r, flatness=%r>' %
-            (self.linewidth, self.linecap, self.linejoin,
-             self.miterlimit, self.dash, self.intent, self.flatness))
+    def __repr__(self):
+        return ('<PDFGraphicState: linewidth=%r, linecap=%r, linejoin=%r, '
+                ' miterlimit=%r, dash=%r, intent=%r, flatness=%r>' %
+                (self.linewidth, self.linecap, self.linejoin,
+                 self.miterlimit, self.dash, self.intent, self.flatness))
 
 ##  Resource Manager
 ##
 class PDFResourceManager(object):
 
-  '''
-  ResourceManager facilitates reuse of shared resources
-  such as fonts and images so that large objects are not
-  allocated multiple times.
-  '''
-  debug = 0
-  
-  def __init__(self):
-    self.fonts = {}
-    return
+    '''
+    ResourceManager facilitates reuse of shared resources
+    such as fonts and images so that large objects are not
+    allocated multiple times.
+    '''
+    debug = 0
 
-  def get_procset(self, procs):
-    for proc in procs:
-      if proc is LITERAL_PDF:
-        pass
-      elif proc is LITERAL_TEXT:
-        pass
-      else:
-        #raise PDFResourceError('ProcSet %r is not supported.' % proc)
-        pass
-    return
+    def __init__(self):
+        self.fonts = {}
+        return
 
-  def get_cmap(self, cmapname, strict=False):
-    return CMapDB.get_cmap(cmapname, strict=strict)
-  
-  def get_font(self, objid, spec):
-    if objid and objid in self.fonts:
-      font = self.fonts[objid]
-    else:
-      if STRICT:
-        if spec['Type'] is not LITERAL_FONT:
-          raise PDFFontError('Type is not /Font')
-      # Create a Font object.
-      if 'Subtype' in spec:
-        subtype = literal_name(spec['Subtype'])
-      else:
-        if STRICT:
-          raise PDFFontError('Font Subtype is not specified.')
-        subtype = 'Type1'
-      if subtype in ('Type1', 'MMType1'):
-        # Type1 Font
-        font = PDFType1Font(self, spec)
-      elif subtype == 'TrueType':
-        # TrueType Font
-        font = PDFTrueTypeFont(self, spec)
-      elif subtype == 'Type3':
-        # Type3 Font
-        font = PDFType3Font(self, spec)
-      elif subtype in ('CIDFontType0', 'CIDFontType2'):
-        # CID Font
-        font = PDFCIDFont(self, spec)
-      elif subtype == 'Type0':
-        # Type0 Font
-        dfonts = list_value(spec['DescendantFonts'])
-        assert dfonts
-        subspec = dict_value(dfonts[0]).copy()
-        for k in ('Encoding', 'ToUnicode'):
-          if k in spec:
-            subspec[k] = resolve1(spec[k])
-        font = self.get_font(None, subspec)
-      else:
-        if STRICT:
-          raise PDFFontError('Invalid Font spec: %r' % spec)
-        font = PDFType1Font(self, spec) # this is so wrong!
-      if objid:
-        self.fonts[objid] = font
-    return font
+    def get_procset(self, procs):
+        for proc in procs:
+            if proc is LITERAL_PDF:
+                pass
+            elif proc is LITERAL_TEXT:
+                pass
+            else:
+                #raise PDFResourceError('ProcSet %r is not supported.' % proc)
+                pass
+        return
+
+    def get_cmap(self, cmapname, strict=False):
+        return CMapDB.get_cmap(cmapname, strict=strict)
+
+    def get_font(self, objid, spec):
+        if objid and objid in self.fonts:
+            font = self.fonts[objid]
+        else:
+            if STRICT:
+                if spec['Type'] is not LITERAL_FONT:
+                    raise PDFFontError('Type is not /Font')
+            # Create a Font object.
+            if 'Subtype' in spec:
+                subtype = literal_name(spec['Subtype'])
+            else:
+                if STRICT:
+                    raise PDFFontError('Font Subtype is not specified.')
+                subtype = 'Type1'
+            if subtype in ('Type1', 'MMType1'):
+                # Type1 Font
+                font = PDFType1Font(self, spec)
+            elif subtype == 'TrueType':
+                # TrueType Font
+                font = PDFTrueTypeFont(self, spec)
+            elif subtype == 'Type3':
+                # Type3 Font
+                font = PDFType3Font(self, spec)
+            elif subtype in ('CIDFontType0', 'CIDFontType2'):
+                # CID Font
+                font = PDFCIDFont(self, spec)
+            elif subtype == 'Type0':
+                # Type0 Font
+                dfonts = list_value(spec['DescendantFonts'])
+                assert dfonts
+                subspec = dict_value(dfonts[0]).copy()
+                for k in ('Encoding', 'ToUnicode'):
+                    if k in spec:
+                        subspec[k] = resolve1(spec[k])
+                font = self.get_font(None, subspec)
+            else:
+                if STRICT:
+                    raise PDFFontError('Invalid Font spec: %r' % spec)
+                font = PDFType1Font(self, spec) # this is so wrong!
+            if objid:
+                self.fonts[objid] = font
+        return font
 
 
 ##  PDFContentParser
 ##
 class PDFContentParser(PSStackParser):
 
-  def __init__(self, streams):
-    self.streams = streams
-    self.istream = 0
-    PSStackParser.__init__(self, None)
-    return
+    def __init__(self, streams):
+        self.streams = streams
+        self.istream = 0
+        PSStackParser.__init__(self, None)
+        return
 
-  def fillfp(self):
-    if not self.fp:
-      if self.istream < len(self.streams):
-        strm = stream_value(self.streams[self.istream])
-        self.istream += 1
-      else:
-        raise PSEOF('Unexpected EOF, file truncated?')
-      self.fp = StringIO(strm.get_data())
-    return
+    def fillfp(self):
+        if not self.fp:
+            if self.istream < len(self.streams):
+                strm = stream_value(self.streams[self.istream])
+                self.istream += 1
+            else:
+                raise PSEOF('Unexpected EOF, file truncated?')
+            self.fp = StringIO(strm.get_data())
+        return
 
-  def seek(self, pos):
-    self.fillfp()
-    PSStackParser.seek(self, pos)
-    return
+    def seek(self, pos):
+        self.fillfp()
+        PSStackParser.seek(self, pos)
+        return
 
-  def fillbuf(self):
-    if self.charpos < len(self.buf): return
-    while 1:
-      self.fillfp()
-      self.bufpos = self.fp.tell()
-      self.buf = self.fp.read(self.BUFSIZ)
-      if self.buf: break
-      self.fp = None
-    self.charpos = 0
-    return
+    def fillbuf(self):
+        if self.charpos < len(self.buf): return
+        while 1:
+            self.fillfp()
+            self.bufpos = self.fp.tell()
+            self.buf = self.fp.read(self.BUFSIZ)
+            if self.buf: break
+            self.fp = None
+        self.charpos = 0
+        return
 
-  def get_inline_data(self, pos, target='EI'):
-    self.seek(pos)
-    i = 0
-    data = ''
-    while i <= len(target):
-      self.fillbuf()
-      if i:
-        c = self.buf[self.charpos]
-        data += c
-        self.charpos += 1
-        if len(target) <= i and c.isspace():
-          i += 1
-        elif i < len(target) and c == target[i]:
-          i += 1
+    def get_inline_data(self, pos, target='EI'):
+        self.seek(pos)
+        i = 0
+        data = ''
+        while i <= len(target):
+            self.fillbuf()
+            if i:
+                c = self.buf[self.charpos]
+                data += c
+                self.charpos += 1
+                if len(target) <= i and c.isspace():
+                    i += 1
+                elif i < len(target) and c == target[i]:
+                    i += 1
+                else:
+                    i = 0
+            else:
+                try:
+                    j = self.buf.index(target[0], self.charpos)
+                    #print 'found', (0, self.buf[j:j+10])
+                    data += self.buf[self.charpos:j+1]
+                    self.charpos = j+1
+                    i = 1
+                except ValueError:
+                    data += self.buf[self.charpos:]
+                    self.charpos = len(self.buf)
+        data = data[:-(len(target)+1)] # strip the last part
+        data = re.sub(r'(\x0d\x0a|[\x0d\x0a])', '', data)
+        return (pos, data)
+
+    def flush(self):
+        self.add_results(*self.popall())
+        return
+
+    KEYWORD_BI = PSKeywordTable.intern('BI')
+    KEYWORD_ID = PSKeywordTable.intern('ID')
+    KEYWORD_EI = PSKeywordTable.intern('EI')
+    def do_keyword(self, pos, token):
+        if token is self.KEYWORD_BI:
+            # inline image within a content stream
+            self.start_type(pos, 'inline')
+        elif token is self.KEYWORD_ID:
+            try:
+                (_, objs) = self.end_type('inline')
+                if len(objs) % 2 != 0:
+                    raise PSTypeError('Invalid dictionary construct: %r' % objs)
+                d = dict( (literal_name(k), v) for (k,v) in choplist(2, objs) )
+                (pos, data) = self.get_inline_data(pos+len('ID '))
+                obj = PDFStream(d, data)
+                self.push((pos, obj))
+                self.push((pos, self.KEYWORD_EI))
+            except PSTypeError:
+                if STRICT: raise
         else:
-          i = 0
-      else:
-        try:
-          j = self.buf.index(target[0], self.charpos)
-          #print 'found', (0, self.buf[j:j+10])
-          data += self.buf[self.charpos:j+1]
-          self.charpos = j+1
-          i = 1
-        except ValueError:
-          data += self.buf[self.charpos:]
-          self.charpos = len(self.buf)
-    data = data[:-(len(target)+1)] # strip the last part
-    data = re.sub(r'(\x0d\x0a|[\x0d\x0a])', '', data)
-    return (pos, data)
-
-  def flush(self):
-    self.add_results(*self.popall())
-    return
-
-  KEYWORD_BI = PSKeywordTable.intern('BI')
-  KEYWORD_ID = PSKeywordTable.intern('ID')
-  KEYWORD_EI = PSKeywordTable.intern('EI')
-  def do_keyword(self, pos, token):
-    if token is self.KEYWORD_BI:
-      # inline image within a content stream
-      self.start_type(pos, 'inline')
-    elif token is self.KEYWORD_ID:
-      try:
-        (_, objs) = self.end_type('inline')
-        if len(objs) % 2 != 0:
-          raise PSTypeError('Invalid dictionary construct: %r' % objs)
-        d = dict( (literal_name(k), v) for (k,v) in choplist(2, objs) )
-        (pos, data) = self.get_inline_data(pos+len('ID '))
-        obj = PDFStream(d, data)
-        self.push((pos, obj))
-        self.push((pos, self.KEYWORD_EI))
-      except PSTypeError:
-        if STRICT: raise
-    else:
-      self.push((pos, token))
-    return
+            self.push((pos, token))
+        return
 
 
 ##  Interpreter
 ##
 class PDFPageInterpreter(object):
 
-  debug = 0
-  
-  def __init__(self, rsrc, device):
-    self.rsrc = rsrc
-    self.device = device
-    return
+    debug = 0
 
-  def dup(self):
-    return PDFPageInterpreter(self.rsrc, self.device)
+    def __init__(self, rsrc, device):
+        self.rsrc = rsrc
+        self.device = device
+        return
 
-  # init_resources(resources):
-  #   Prepare the fonts and XObjects listed in the Resource attribute.
-  def init_resources(self, resources):
-    self.fontmap = {}
-    self.xobjmap = {}
-    self.csmap = PREDEFINED_COLORSPACE.copy()
-    if not resources: return
-    def get_colorspace(spec):
-      if isinstance(spec, list):
-        name = literal_name(spec[0])
-      else:
-        name = literal_name(spec)
-      if name == 'ICCBased' and isinstance(spec, list) and 2 <= len(spec):
-        return PDFColorSpace(name, stream_value(spec[1]).dic['N'])
-      elif name == 'DeviceN' and isinstance(spec, list) and 2 <= len(spec):
-        return PDFColorSpace(name, len(list_value(spec[1])))
-      else:
-        return PREDEFINED_COLORSPACE[name]
-    for (k,v) in dict_value(resources).iteritems():
-      if 1 <= self.debug:
-        print >>stderr, 'Resource: %r: %r' % (k,v)
-      if k == 'Font':
-        for (fontid,spec) in dict_value(v).iteritems():
-          objid = None
-          if isinstance(spec, PDFObjRef):
-            objid = spec.objid
-          spec = dict_value(spec)
-          self.fontmap[fontid] = self.rsrc.get_font(objid, spec)
-      elif k == 'ColorSpace':
-        for (csid,spec) in dict_value(v).iteritems():
-          self.csmap[csid] = get_colorspace(resolve1(spec))
-      elif k == 'ProcSet':
-        self.rsrc.get_procset(list_value(v))
-      elif k == 'XObject':
-        for (xobjid,xobjstrm) in dict_value(v).iteritems():
-          self.xobjmap[xobjid] = xobjstrm
-    return
+    def dup(self):
+        return PDFPageInterpreter(self.rsrc, self.device)
 
-  # init_state(ctm)
-  #   Initialize the text and graphic states for rendering a page.
-  def init_state(self, ctm):
-    # gstack: stack for graphical states.
-    self.gstack = []
-    self.ctm = ctm
-    self.device.set_ctm(self.ctm)
-    self.textstate = PDFTextState()
-    self.graphicstate = PDFGraphicState()
-    self.curpath = []
-    # argstack: stack for command arguments.
-    self.argstack = []
-    # set some global states.
-    self.scs = self.ncs = None
-    if self.csmap:
-      self.scs = self.ncs = self.csmap.values()[0]
-    return
-
-  def push(self, obj):
-    self.argstack.append(obj)
-    return
-
-  def pop(self, n):
-    if n == 0: return []
-    x = self.argstack[-n:]
-    self.argstack = self.argstack[:-n]
-    return x
-
-  def get_current_state(self):
-    return (self.ctm, self.textstate, self.graphicstate)
-  
-  def set_current_state(self, state):
-    (self.ctm, self.textstate, self.graphicstate) = state
-    self.device.set_ctm(self.ctm)
-    return
-
-  # gsave
-  def do_q(self):
-    self.gstack.append(self.get_current_state())
-    return
-  # grestore
-  def do_Q(self):
-    if self.gstack:
-      self.set_current_state(self.gstack.pop())
-    return
-  
-  # concat-matrix
-  def do_cm(self, a1, b1, c1, d1, e1, f1):
-    self.ctm = mult_matrix((a1,b1,c1,d1,e1,f1), self.ctm)
-    self.device.set_ctm(self.ctm)
-    return
-  
-  # setlinewidth
-  def do_w(self, linewidth):
-    self.graphicstate.linewidth = linewidth
-    return
-  # setlinecap
-  def do_J(self, linecap):
-    self.graphicstate.linecap = linecap
-    return
-  # setlinejoin
-  def do_j(self, linejoin):
-    self.graphicstate.linejoin = linejoin
-    return
-  # setmiterlimit
-  def do_M(self, miterlimit):
-    self.graphicstate.miterlimit = miterlimit
-    return
-  # setdash
-  def do_d(self, dash, phase):
-    self.graphicstate.dash = (dash, phase)
-    return
-  # setintent
-  def do_ri(self, intent):
-    self.graphicstate.intent = intent
-    return
-  # setflatness
-  def do_i(self, flatness):
-    self.graphicstate.flatness = flatness
-    return
-  # load-gstate
-  def do_gs(self, name):
-    #XXX
-    return
-  
-  # moveto
-  def do_m(self, x, y):
-    self.curpath.append(('m',x,y))
-    return
-  # lineto
-  def do_l(self, x, y):
-    self.curpath.append(('l',x,y))
-    return
-  # curveto
-  def do_c(self, x1, y1, x2, y2, x3, y3):
-    self.curpath.append(('c',x1,y1,x2,y2,x3,y3))
-    return
-  # urveto
-  def do_v(self, x2, y2, x3, y3):
-    self.curpath.append(('v',x2,y2,x3,y3))
-    return
-  # rveto
-  def do_y(self, x1, y1, x3, y3):
-    self.curpath.append(('y',x1,y1,x3,y3))
-    return
-  # closepath
-  def do_h(self):
-    self.curpath.append(('h',))
-    return
-  # rectangle
-  def do_re(self, x, y, w, h):
-    self.curpath.append(('m',x,y))
-    self.curpath.append(('l',x+w,y))
-    self.curpath.append(('l',x+w,y+h))
-    self.curpath.append(('l',x,y+h))
-    self.curpath.append(('h',))
-    return
-  
-  # stroke
-  def do_S(self):
-    self.device.paint_path(self.graphicstate, True, False, False, self.curpath)
-    self.curpath = []
-    return
-  # close-and-stroke
-  def do_s(self):
-    self.do_h()
-    self.do_S()
-    return
-  # fill
-  def do_f(self):
-    self.device.paint_path(self.graphicstate, False, True, False, self.curpath)
-    self.curpath = []
-    return
-  # fill (obsolete)
-  do_F = do_f
-  # fill-even-odd
-  def do_f_a(self):
-    self.device.paint_path(self.graphicstate, False, True, True, self.curpath)
-    self.curpath = []
-    return
-  # fill-and-stroke
-  def do_B(self):
-    self.device.paint_path(self.graphicstate, True, True, False, self.curpath)
-    self.curpath = []
-    return
-  # fill-and-stroke-even-odd
-  def do_B_a(self):
-    self.device.paint_path(self.graphicstate, True, True, True, self.curpath)
-    self.curpath = []
-    return
-  # close-fill-and-stroke
-  def do_b(self):
-    self.do_h()
-    self.do_B()
-    return
-  # close-fill-and-stroke-even-odd
-  def do_b_a(self):
-    self.do_h()
-    self.do_B_a()
-    return
-  # close-only
-  def do_n(self):
-    self.curpath = []
-    return
-  # clip
-  def do_W(self): return
-  # clip-even-odd
-  def do_W_a(self): return
-  
-  # setcolorspace-stroking
-  def do_CS(self, name):
-    self.scs = self.csmap[literal_name(name)]
-    return
-  # setcolorspace-non-strokine
-  def do_cs(self, name):
-    self.ncs = self.csmap[literal_name(name)]
-    return
-  # setgray-stroking
-  def do_G(self, gray):
-    #self.do_CS(LITERAL_DEVICE_GRAY)
-    return
-  # setgray-non-stroking
-  def do_g(self, gray):
-    #self.do_cs(LITERAL_DEVICE_GRAY)
-    return
-  # setrgb-stroking
-  def do_RG(self, r, g, b):
-    #self.do_CS(LITERAL_DEVICE_RGB)
-    return
-  # setrgb-non-stroking
-  def do_rg(self, r, g, b):
-    #self.do_cs(LITERAL_DEVICE_RGB)
-    return
-  # setcmyk-stroking
-  def do_K(self, c, m, y, k):
-    #self.do_CS(LITERAL_DEVICE_CMYK)
-    return
-  # setcmyk-non-stroking
-  def do_k(self, c, m, y, k):
-    #self.do_cs(LITERAL_DEVICE_CMYK)
-    return
-
-  # setcolor
-  def do_SCN(self):
-    if self.scs:
-      n = self.scs.ncomponents
-    else:
-      if STRICT:
-        raise PDFInterpreterError('No colorspace specified!')
-      n = 1
-    self.pop(n)
-    return
-  def do_scn(self):
-    if self.ncs:
-      n = self.ncs.ncomponents
-    else:
-      if STRICT:
-        raise PDFInterpreterError('No colorspace specified!')
-      n = 1
-    self.pop(n)
-    return
-  def do_SC(self):
-    self.do_SCN()
-    return
-  def do_sc(self):
-    self.do_scn()
-    return
-    
-  # sharing-name
-  def do_sh(self, name): return
-  
-  # begin-text
-  def do_BT(self):
-    self.textstate.reset()
-    return
-  # end-text
-  def do_ET(self):
-    return
-
-  # begin-compat
-  def do_BX(self): return
-  # end-compat
-  def do_EX(self): return
-
-  # marked content operators
-  def do_MP(self, tag):
-    self.device.do_tag(tag)
-    return
-  def do_DP(self, tag, props):
-    self.device.do_tag(tag, props)
-    return
-  def do_BMC(self, tag):
-    self.device.begin_tag(tag)
-    return
-  def do_BDC(self, tag, props):
-    self.device.begin_tag(tag, props)
-    return
-  def do_EMC(self):
-    self.device.end_tag()
-    return
-
-  # setcharspace
-  def do_Tc(self, space):
-    self.textstate.charspace = space
-    return
-  # setwordspace
-  def do_Tw(self, space):
-    self.textstate.wordspace = space
-    return
-  # textscale
-  def do_Tz(self, scale):
-    self.textstate.scaling = scale
-    return
-  # setleading
-  def do_TL(self, leading):
-    self.textstate.leading = -leading
-    return
-  # selectfont
-  def do_Tf(self, fontid, fontsize):
-    try:
-      self.textstate.font = self.fontmap[literal_name(fontid)]
-    except KeyError:
-      if STRICT:
-        raise PDFInterpreterError('Undefined Font id: %r' % fontid)
-      return
-    self.textstate.fontsize = fontsize
-    return
-  # setrendering
-  def do_Tr(self, render):
-    self.textstate.render = render
-    return
-  # settextrise
-  def do_Ts(self, rise):
-    self.textstate.rise = rise
-    return
-
-  # text-move
-  def do_Td(self, tx, ty):
-    (a,b,c,d,e,f) = self.textstate.matrix
-    self.textstate.matrix = (a,b,c,d,tx*a+ty*c+e,tx*b+ty*d+f)
-    self.textstate.linematrix = (0, 0)
-    #print >>stderr, 'Td(%r,%r): %r' % (tx,ty,self.textstate)
-    return
-  # text-move
-  def do_TD(self, tx, ty):
-    (a,b,c,d,e,f) = self.textstate.matrix
-    self.textstate.matrix = (a,b,c,d,tx*a+ty*c+e,tx*b+ty*d+f)
-    self.textstate.leading = ty
-    self.textstate.linematrix = (0, 0)
-    #print >>stderr, 'TD(%r,%r): %r' % (tx,ty,self.textstate)
-    return
-  # textmatrix
-  def do_Tm(self, a,b,c,d,e,f):
-    self.textstate.matrix = (a,b,c,d,e,f)
-    self.textstate.linematrix = (0, 0)
-    return
-  # nextline
-  def do_T_a(self):
-    (a,b,c,d,e,f) = self.textstate.matrix
-    self.textstate.matrix = (a,b,c,d,self.textstate.leading*c+e,self.textstate.leading*d+f)
-    self.textstate.linematrix = (0, 0)
-    return
-  
-  # show-pos
-  def do_TJ(self, seq):
-    #print >>stderr, 'TJ(%r): %r' % (seq,self.textstate)
-    self.device.render_string(self.textstate, seq)
-    return
-  # show
-  def do_Tj(self, s):
-    self.do_TJ([s])
-    return
-  # quote
-  def do__q(self, s):
-    self.do_T_a()
-    self.do_TJ([s])
-    return
-  # doublequote
-  def do__w(self, aw, ac, s):
-    self.do_Tw(aw)
-    self.do_Tc(ac)
-    self.do_TJ([s])
-    return
-
-  # inline image
-  def do_BI(self): # never called
-    return
-  def do_ID(self): # never called
-    return
-  def do_EI(self, obj):
-    return
-
-  # invoke an XObject
-  def do_Do(self, xobjid):
-    xobjid = literal_name(xobjid)
-    try:
-      xobj = stream_value(self.xobjmap[xobjid])
-    except KeyError:
-      if STRICT:
-        raise PDFInterpreterError('Undefined xobject id: %r' % xobjid)
-      return
-    if 1 <= self.debug:
-      print >>stderr, 'Processing xobj: %r' % xobj
-    subtype = xobj.dic.get('Subtype')
-    if subtype is LITERAL_FORM and 'BBox' in xobj.dic:
-      interpreter = self.dup()
-      bbox = list_value(xobj.dic['BBox'])
-      matrix = list_value(xobj.dic.get('Matrix', MATRIX_IDENTITY))
-      self.device.begin_figure(xobjid, bbox, matrix)
-      interpreter.render_contents(dict_value(xobj.dic.get('Resources')), [xobj], ctm=mult_matrix(matrix, self.ctm))
-      self.device.end_figure(xobjid)
-    elif subtype is LITERAL_IMAGE and 'Width' in xobj.dic and 'Height' in xobj.dic:
-      self.device.begin_figure(xobjid, (0,0,1,1), MATRIX_IDENTITY)
-      (w,h) = (xobj.dic['Width'], xobj.dic['Height'])
-      self.device.render_image(xobj, (w,h))
-      self.device.end_figure(xobjid)
-    else:
-      # unsupported xobject type.
-      pass
-    return
-
-  def process_page(self, page):
-    if 1 <= self.debug:
-      print >>stderr, 'Processing page: %r' % page
-    (x0,y0,x1,y1) = page.mediabox
-    if page.rotate == 90:
-      ctm = (0,-1,1,0, -y0,x1)
-    elif page.rotate == 180:
-      ctm = (-1,0,0,-1, x1,y1)
-    elif page.rotate == 270:
-      ctm = (0,1,-1,0, x0,-y1)
-    else:
-      ctm = (1,0,0,1, -x0,-y0)
-    self.device.begin_page(page, ctm)
-    self.render_contents(page.resources, page.contents, ctm=ctm)
-    self.device.end_page(page)
-    return
-
-  # render_contents(resources, streams, ctm)
-  #   Render the content streams.
-  #   This method may be called recursively.
-  def render_contents(self, resources, streams, ctm=MATRIX_IDENTITY):
-    self.init_resources(resources)
-    self.init_state(ctm)
-    self.execute(list_value(streams))
-    return
-  
-  def execute(self, streams):
-    try:
-      parser = PDFContentParser(streams)
-    except PSEOF:
-      # empty page
-      return
-    while 1:
-      try:
-        (_,obj) = parser.nextobject()
-      except PSEOF:
-        break
-      if isinstance(obj, PSKeyword):
-        name = 'do_%s' % obj.name.replace('*','_a').replace('"','_w').replace("'",'_q')
-        if hasattr(self, name):
-          func = getattr(self, name)
-          nargs = func.func_code.co_argcount-1
-          if nargs:
-            args = self.pop(nargs)
+    # init_resources(resources):
+    #   Prepare the fonts and XObjects listed in the Resource attribute.
+    def init_resources(self, resources):
+        self.fontmap = {}
+        self.xobjmap = {}
+        self.csmap = PREDEFINED_COLORSPACE.copy()
+        if not resources: return
+        def get_colorspace(spec):
+            if isinstance(spec, list):
+                name = literal_name(spec[0])
+            else:
+                name = literal_name(spec)
+            if name == 'ICCBased' and isinstance(spec, list) and 2 <= len(spec):
+                return PDFColorSpace(name, stream_value(spec[1]).dic['N'])
+            elif name == 'DeviceN' and isinstance(spec, list) and 2 <= len(spec):
+                return PDFColorSpace(name, len(list_value(spec[1])))
+            else:
+                return PREDEFINED_COLORSPACE[name]
+        for (k,v) in dict_value(resources).iteritems():
             if 1 <= self.debug:
-              print >>stderr, 'exec: %s %r' % (obj.name, args)
-            if len(args) == nargs:
-              func(*args)
-          else:
-            if 1 <= self.debug:
-              print >>stderr, 'exec: %s' % (obj.name)
-            func()
+                print >>stderr, 'Resource: %r: %r' % (k,v)
+            if k == 'Font':
+                for (fontid,spec) in dict_value(v).iteritems():
+                    objid = None
+                    if isinstance(spec, PDFObjRef):
+                        objid = spec.objid
+                    spec = dict_value(spec)
+                    self.fontmap[fontid] = self.rsrc.get_font(objid, spec)
+            elif k == 'ColorSpace':
+                for (csid,spec) in dict_value(v).iteritems():
+                    self.csmap[csid] = get_colorspace(resolve1(spec))
+            elif k == 'ProcSet':
+                self.rsrc.get_procset(list_value(v))
+            elif k == 'XObject':
+                for (xobjid,xobjstrm) in dict_value(v).iteritems():
+                    self.xobjmap[xobjid] = xobjstrm
+        return
+
+    # init_state(ctm)
+    #   Initialize the text and graphic states for rendering a page.
+    def init_state(self, ctm):
+        # gstack: stack for graphical states.
+        self.gstack = []
+        self.ctm = ctm
+        self.device.set_ctm(self.ctm)
+        self.textstate = PDFTextState()
+        self.graphicstate = PDFGraphicState()
+        self.curpath = []
+        # argstack: stack for command arguments.
+        self.argstack = []
+        # set some global states.
+        self.scs = self.ncs = None
+        if self.csmap:
+            self.scs = self.ncs = self.csmap.values()[0]
+        return
+
+    def push(self, obj):
+        self.argstack.append(obj)
+        return
+
+    def pop(self, n):
+        if n == 0: return []
+        x = self.argstack[-n:]
+        self.argstack = self.argstack[:-n]
+        return x
+
+    def get_current_state(self):
+        return (self.ctm, self.textstate, self.graphicstate)
+
+    def set_current_state(self, state):
+        (self.ctm, self.textstate, self.graphicstate) = state
+        self.device.set_ctm(self.ctm)
+        return
+
+    # gsave
+    def do_q(self):
+        self.gstack.append(self.get_current_state())
+        return
+    # grestore
+    def do_Q(self):
+        if self.gstack:
+            self.set_current_state(self.gstack.pop())
+        return
+
+    # concat-matrix
+    def do_cm(self, a1, b1, c1, d1, e1, f1):
+        self.ctm = mult_matrix((a1,b1,c1,d1,e1,f1), self.ctm)
+        self.device.set_ctm(self.ctm)
+        return
+
+    # setlinewidth
+    def do_w(self, linewidth):
+        self.graphicstate.linewidth = linewidth
+        return
+    # setlinecap
+    def do_J(self, linecap):
+        self.graphicstate.linecap = linecap
+        return
+    # setlinejoin
+    def do_j(self, linejoin):
+        self.graphicstate.linejoin = linejoin
+        return
+    # setmiterlimit
+    def do_M(self, miterlimit):
+        self.graphicstate.miterlimit = miterlimit
+        return
+    # setdash
+    def do_d(self, dash, phase):
+        self.graphicstate.dash = (dash, phase)
+        return
+    # setintent
+    def do_ri(self, intent):
+        self.graphicstate.intent = intent
+        return
+    # setflatness
+    def do_i(self, flatness):
+        self.graphicstate.flatness = flatness
+        return
+    # load-gstate
+    def do_gs(self, name):
+        #XXX
+        return
+
+    # moveto
+    def do_m(self, x, y):
+        self.curpath.append(('m',x,y))
+        return
+    # lineto
+    def do_l(self, x, y):
+        self.curpath.append(('l',x,y))
+        return
+    # curveto
+    def do_c(self, x1, y1, x2, y2, x3, y3):
+        self.curpath.append(('c',x1,y1,x2,y2,x3,y3))
+        return
+    # urveto
+    def do_v(self, x2, y2, x3, y3):
+        self.curpath.append(('v',x2,y2,x3,y3))
+        return
+    # rveto
+    def do_y(self, x1, y1, x3, y3):
+        self.curpath.append(('y',x1,y1,x3,y3))
+        return
+    # closepath
+    def do_h(self):
+        self.curpath.append(('h',))
+        return
+    # rectangle
+    def do_re(self, x, y, w, h):
+        self.curpath.append(('m',x,y))
+        self.curpath.append(('l',x+w,y))
+        self.curpath.append(('l',x+w,y+h))
+        self.curpath.append(('l',x,y+h))
+        self.curpath.append(('h',))
+        return
+
+    # stroke
+    def do_S(self):
+        self.device.paint_path(self.graphicstate, True, False, False, self.curpath)
+        self.curpath = []
+        return
+    # close-and-stroke
+    def do_s(self):
+        self.do_h()
+        self.do_S()
+        return
+    # fill
+    def do_f(self):
+        self.device.paint_path(self.graphicstate, False, True, False, self.curpath)
+        self.curpath = []
+        return
+    # fill (obsolete)
+    do_F = do_f
+    # fill-even-odd
+    def do_f_a(self):
+        self.device.paint_path(self.graphicstate, False, True, True, self.curpath)
+        self.curpath = []
+        return
+    # fill-and-stroke
+    def do_B(self):
+        self.device.paint_path(self.graphicstate, True, True, False, self.curpath)
+        self.curpath = []
+        return
+    # fill-and-stroke-even-odd
+    def do_B_a(self):
+        self.device.paint_path(self.graphicstate, True, True, True, self.curpath)
+        self.curpath = []
+        return
+    # close-fill-and-stroke
+    def do_b(self):
+        self.do_h()
+        self.do_B()
+        return
+    # close-fill-and-stroke-even-odd
+    def do_b_a(self):
+        self.do_h()
+        self.do_B_a()
+        return
+    # close-only
+    def do_n(self):
+        self.curpath = []
+        return
+    # clip
+    def do_W(self): return
+    # clip-even-odd
+    def do_W_a(self): return
+
+    # setcolorspace-stroking
+    def do_CS(self, name):
+        self.scs = self.csmap[literal_name(name)]
+        return
+    # setcolorspace-non-strokine
+    def do_cs(self, name):
+        self.ncs = self.csmap[literal_name(name)]
+        return
+    # setgray-stroking
+    def do_G(self, gray):
+        #self.do_CS(LITERAL_DEVICE_GRAY)
+        return
+    # setgray-non-stroking
+    def do_g(self, gray):
+        #self.do_cs(LITERAL_DEVICE_GRAY)
+        return
+    # setrgb-stroking
+    def do_RG(self, r, g, b):
+        #self.do_CS(LITERAL_DEVICE_RGB)
+        return
+    # setrgb-non-stroking
+    def do_rg(self, r, g, b):
+        #self.do_cs(LITERAL_DEVICE_RGB)
+        return
+    # setcmyk-stroking
+    def do_K(self, c, m, y, k):
+        #self.do_CS(LITERAL_DEVICE_CMYK)
+        return
+    # setcmyk-non-stroking
+    def do_k(self, c, m, y, k):
+        #self.do_cs(LITERAL_DEVICE_CMYK)
+        return
+
+    # setcolor
+    def do_SCN(self):
+        if self.scs:
+            n = self.scs.ncomponents
         else:
-          if STRICT:
-            raise PDFInterpreterError('Unknown operator: %r' % obj.name)
-      else:
-        self.push(obj)
-    return
+            if STRICT:
+                raise PDFInterpreterError('No colorspace specified!')
+            n = 1
+        self.pop(n)
+        return
+    def do_scn(self):
+        if self.ncs:
+            n = self.ncs.ncomponents
+        else:
+            if STRICT:
+                raise PDFInterpreterError('No colorspace specified!')
+            n = 1
+        self.pop(n)
+        return
+    def do_SC(self):
+        self.do_SCN()
+        return
+    def do_sc(self):
+        self.do_scn()
+        return
+
+    # sharing-name
+    def do_sh(self, name): return
+
+    # begin-text
+    def do_BT(self):
+        self.textstate.reset()
+        return
+    # end-text
+    def do_ET(self):
+        return
+
+    # begin-compat
+    def do_BX(self): return
+    # end-compat
+    def do_EX(self): return
+
+    # marked content operators
+    def do_MP(self, tag):
+        self.device.do_tag(tag)
+        return
+    def do_DP(self, tag, props):
+        self.device.do_tag(tag, props)
+        return
+    def do_BMC(self, tag):
+        self.device.begin_tag(tag)
+        return
+    def do_BDC(self, tag, props):
+        self.device.begin_tag(tag, props)
+        return
+    def do_EMC(self):
+        self.device.end_tag()
+        return
+
+    # setcharspace
+    def do_Tc(self, space):
+        self.textstate.charspace = space
+        return
+    # setwordspace
+    def do_Tw(self, space):
+        self.textstate.wordspace = space
+        return
+    # textscale
+    def do_Tz(self, scale):
+        self.textstate.scaling = scale
+        return
+    # setleading
+    def do_TL(self, leading):
+        self.textstate.leading = -leading
+        return
+    # selectfont
+    def do_Tf(self, fontid, fontsize):
+        try:
+            self.textstate.font = self.fontmap[literal_name(fontid)]
+        except KeyError:
+            if STRICT:
+                raise PDFInterpreterError('Undefined Font id: %r' % fontid)
+            return
+        self.textstate.fontsize = fontsize
+        return
+    # setrendering
+    def do_Tr(self, render):
+        self.textstate.render = render
+        return
+    # settextrise
+    def do_Ts(self, rise):
+        self.textstate.rise = rise
+        return
+
+    # text-move
+    def do_Td(self, tx, ty):
+        (a,b,c,d,e,f) = self.textstate.matrix
+        self.textstate.matrix = (a,b,c,d,tx*a+ty*c+e,tx*b+ty*d+f)
+        self.textstate.linematrix = (0, 0)
+        #print >>stderr, 'Td(%r,%r): %r' % (tx,ty,self.textstate)
+        return
+    # text-move
+    def do_TD(self, tx, ty):
+        (a,b,c,d,e,f) = self.textstate.matrix
+        self.textstate.matrix = (a,b,c,d,tx*a+ty*c+e,tx*b+ty*d+f)
+        self.textstate.leading = ty
+        self.textstate.linematrix = (0, 0)
+        #print >>stderr, 'TD(%r,%r): %r' % (tx,ty,self.textstate)
+        return
+    # textmatrix
+    def do_Tm(self, a,b,c,d,e,f):
+        self.textstate.matrix = (a,b,c,d,e,f)
+        self.textstate.linematrix = (0, 0)
+        return
+    # nextline
+    def do_T_a(self):
+        (a,b,c,d,e,f) = self.textstate.matrix
+        self.textstate.matrix = (a,b,c,d,self.textstate.leading*c+e,self.textstate.leading*d+f)
+        self.textstate.linematrix = (0, 0)
+        return
+
+    # show-pos
+    def do_TJ(self, seq):
+        #print >>stderr, 'TJ(%r): %r' % (seq,self.textstate)
+        self.device.render_string(self.textstate, seq)
+        return
+    # show
+    def do_Tj(self, s):
+        self.do_TJ([s])
+        return
+    # quote
+    def do__q(self, s):
+        self.do_T_a()
+        self.do_TJ([s])
+        return
+    # doublequote
+    def do__w(self, aw, ac, s):
+        self.do_Tw(aw)
+        self.do_Tc(ac)
+        self.do_TJ([s])
+        return
+
+    # inline image
+    def do_BI(self): # never called
+        return
+    def do_ID(self): # never called
+        return
+    def do_EI(self, obj):
+        return
+
+    # invoke an XObject
+    def do_Do(self, xobjid):
+        xobjid = literal_name(xobjid)
+        try:
+            xobj = stream_value(self.xobjmap[xobjid])
+        except KeyError:
+            if STRICT:
+                raise PDFInterpreterError('Undefined xobject id: %r' % xobjid)
+            return
+        if 1 <= self.debug:
+            print >>stderr, 'Processing xobj: %r' % xobj
+        subtype = xobj.dic.get('Subtype')
+        if subtype is LITERAL_FORM and 'BBox' in xobj.dic:
+            interpreter = self.dup()
+            bbox = list_value(xobj.dic['BBox'])
+            matrix = list_value(xobj.dic.get('Matrix', MATRIX_IDENTITY))
+            self.device.begin_figure(xobjid, bbox, matrix)
+            interpreter.render_contents(dict_value(xobj.dic.get('Resources')), [xobj], ctm=mult_matrix(matrix, self.ctm))
+            self.device.end_figure(xobjid)
+        elif subtype is LITERAL_IMAGE and 'Width' in xobj.dic and 'Height' in xobj.dic:
+            self.device.begin_figure(xobjid, (0,0,1,1), MATRIX_IDENTITY)
+            (w,h) = (xobj.dic['Width'], xobj.dic['Height'])
+            self.device.render_image(xobj, (w,h))
+            self.device.end_figure(xobjid)
+        else:
+            # unsupported xobject type.
+            pass
+        return
+
+    def process_page(self, page):
+        if 1 <= self.debug:
+            print >>stderr, 'Processing page: %r' % page
+        (x0,y0,x1,y1) = page.mediabox
+        if page.rotate == 90:
+            ctm = (0,-1,1,0, -y0,x1)
+        elif page.rotate == 180:
+            ctm = (-1,0,0,-1, x1,y1)
+        elif page.rotate == 270:
+            ctm = (0,1,-1,0, x0,-y1)
+        else:
+            ctm = (1,0,0,1, -x0,-y0)
+        self.device.begin_page(page, ctm)
+        self.render_contents(page.resources, page.contents, ctm=ctm)
+        self.device.end_page(page)
+        return
+
+    # render_contents(resources, streams, ctm)
+    #   Render the content streams.
+    #   This method may be called recursively.
+    def render_contents(self, resources, streams, ctm=MATRIX_IDENTITY):
+        self.init_resources(resources)
+        self.init_state(ctm)
+        self.execute(list_value(streams))
+        return
+
+    def execute(self, streams):
+        try:
+            parser = PDFContentParser(streams)
+        except PSEOF:
+            # empty page
+            return
+        while 1:
+            try:
+                (_,obj) = parser.nextobject()
+            except PSEOF:
+                break
+            if isinstance(obj, PSKeyword):
+                name = 'do_%s' % obj.name.replace('*','_a').replace('"','_w').replace("'",'_q')
+                if hasattr(self, name):
+                    func = getattr(self, name)
+                    nargs = func.func_code.co_argcount-1
+                    if nargs:
+                        args = self.pop(nargs)
+                        if 1 <= self.debug:
+                            print >>stderr, 'exec: %s %r' % (obj.name, args)
+                        if len(args) == nargs:
+                            func(*args)
+                    else:
+                        if 1 <= self.debug:
+                            print >>stderr, 'exec: %s' % (obj.name)
+                        func()
+                else:
+                    if STRICT:
+                        raise PDFInterpreterError('Unknown operator: %r' % obj.name)
+            else:
+                self.push(obj)
+        return
 
 
 ##  process_pdf
@@ -752,14 +752,14 @@ class PDFPageInterpreter(object):
 class PDFTextExtractionNotAllowed(PDFInterpreterError): pass
 
 def process_pdf(rsrc, device, fp, pagenos=None, maxpages=0, password=''):
-  doc = PDFDocument()
-  parser = PDFParser(doc, fp)
-  doc.initialize(password)
-  if not doc.is_extractable:
-    raise PDFTextExtractionNotAllowed('Text extraction is not allowed: %r' % fp)
-  interpreter = PDFPageInterpreter(rsrc, device)
-  for (pageno,page) in enumerate(doc.get_pages()):
-    if pagenos and (pageno not in pagenos): continue
-    interpreter.process_page(page)
-    if maxpages and maxpages <= pageno+1: break
-  return
+    doc = PDFDocument()
+    parser = PDFParser(doc, fp)
+    doc.initialize(password)
+    if not doc.is_extractable:
+        raise PDFTextExtractionNotAllowed('Text extraction is not allowed: %r' % fp)
+    interpreter = PDFPageInterpreter(rsrc, device)
+    for (pageno,page) in enumerate(doc.get_pages()):
+        if pagenos and (pageno not in pagenos): continue
+        interpreter.process_page(page)
+        if maxpages and maxpages <= pageno+1: break
+    return
diff --git a/pdfminer/pdfparser.py b/pdfminer/pdfparser.py
index 559e4fd..01de92e 100644
--- a/pdfminer/pdfparser.py
+++ b/pdfminer/pdfparser.py
@@ -34,169 +34,169 @@ LITERAL_CATALOG = PSLiteralTable.intern('Catalog')
 ##  XRefs
 ##
 class XRefObjRange(object):
-  def __init__(self, start, nobjs):
-    self.start = start
-    self.nobjs = nobjs
-    return
+    def __init__(self, start, nobjs):
+        self.start = start
+        self.nobjs = nobjs
+        return
 
-  def __repr__(self):
-    return '<XRefObjRange: %d-%d>' % (self.get_start_id(), self.get_end_id())
+    def __repr__(self):
+        return '<XRefObjRange: %d-%d>' % (self.get_start_id(), self.get_end_id())
 
-  def get_start_id(self):
-    return self.start
+    def get_start_id(self):
+        return self.start
 
-  def get_end_id(self):
-    return self.start + self.nobjs - 1
+    def get_end_id(self):
+        return self.start + self.nobjs - 1
 
-  def get_nobjs(self):
-    return self.nobjs
+    def get_nobjs(self):
+        return self.nobjs
 
 class PDFBaseXRef(object):
-  def __init__(self):
-    self.objid_ranges = None
-    return
+    def __init__(self):
+        self.objid_ranges = None
+        return
 
-  def objids(self):
-    if self.objid_ranges:
-      for objid_range in self.objid_ranges:
-        for objid in xrange(objid_range.get_start_id(), objid_range.get_end_id() + 1):
-          yield objid
-    return
+    def objids(self):
+        if self.objid_ranges:
+            for objid_range in self.objid_ranges:
+                for objid in xrange(objid_range.get_start_id(), objid_range.get_end_id() + 1):
+                    yield objid
+        return
 
 
 ##  PDFXRef
 ##
 class PDFXRef(PDFBaseXRef):
-  def __init__(self):
-    PDFBaseXRef.__init__(self)
-    self.offsets = None
-    self.trailer = {}
-    return
+    def __init__(self):
+        PDFBaseXRef.__init__(self)
+        self.offsets = None
+        self.trailer = {}
+        return
 
-  def __repr__(self):
-    return '<PDFXRef: objs=%d>' % len(self.offsets)
+    def __repr__(self):
+        return '<PDFXRef: objs=%d>' % len(self.offsets)
 
-  def load(self, parser, debug=0):
-    self.offsets = {}
-    self.objid_ranges = []
-    while 1:
-      try:
-        (pos, line) = parser.nextline()
-        if not line.strip():
-            continue
-      except PSEOF:
-        raise PDFNoValidXRef('Unexpected EOF - file corrupted?')
-      if not line:
-        raise PDFNoValidXRef('Premature eof: %r' % parser)
-      if line.startswith('trailer'):
-        parser.seek(pos)
-        break
-      f = line.strip().split(' ')
-      if len(f) != 2:
-        raise PDFNoValidXRef('Trailer not found: %r: line=%r' % (parser, line))
-      try:
-        (start, nobjs) = map(long, f)
-      except ValueError:
-        raise PDFNoValidXRef('Invalid line: %r: line=%r' % (parser, line))
-      self.newoffsets = {}
-      self.objid_ranges.append(XRefObjRange(start, nobjs))
-      for objid in xrange(start, start+nobjs):
+    def load(self, parser, debug=0):
+        self.offsets = {}
+        self.objid_ranges = []
+        while 1:
+            try:
+                (pos, line) = parser.nextline()
+                if not line.strip():
+                    continue
+            except PSEOF:
+                raise PDFNoValidXRef('Unexpected EOF - file corrupted?')
+            if not line:
+                raise PDFNoValidXRef('Premature eof: %r' % parser)
+            if line.startswith('trailer'):
+                parser.seek(pos)
+                break
+            f = line.strip().split(' ')
+            if len(f) != 2:
+                raise PDFNoValidXRef('Trailer not found: %r: line=%r' % (parser, line))
+            try:
+                (start, nobjs) = map(long, f)
+            except ValueError:
+                raise PDFNoValidXRef('Invalid line: %r: line=%r' % (parser, line))
+            self.newoffsets = {}
+            self.objid_ranges.append(XRefObjRange(start, nobjs))
+            for objid in xrange(start, start+nobjs):
+                try:
+                    (_, line) = parser.nextline()
+                except PSEOF:
+                    raise PDFNoValidXRef('Unexpected EOF - file corrupted?')
+                f = line.strip().split(' ')
+                if len(f) != 3:
+                    raise PDFNoValidXRef('Invalid XRef format: %r, line=%r' % (parser, line))
+                (pos, genno, use) = f
+                if use != 'n': continue
+                self.offsets[objid] = (int(genno), long(pos))
+        if debug:
+            print >>stderr, 'xref objects:', self.offsets
+        self.load_trailer(parser)
+        return
+
+    KEYWORD_TRAILER = PSKeywordTable.intern('trailer')
+    def load_trailer(self, parser):
         try:
-          (_, line) = parser.nextline()
+            (_,kwd) = parser.nexttoken()
+            assert kwd is self.KEYWORD_TRAILER
+            (_,dic) = parser.nextobject()
         except PSEOF:
-          raise PDFNoValidXRef('Unexpected EOF - file corrupted?')
-        f = line.strip().split(' ')
-        if len(f) != 3:
-          raise PDFNoValidXRef('Invalid XRef format: %r, line=%r' % (parser, line))
-        (pos, genno, use) = f
-        if use != 'n': continue
-        self.offsets[objid] = (int(genno), long(pos))
-    if debug:
-      print >>stderr, 'xref objects:', self.offsets
-    self.load_trailer(parser)
-    return
+            x = parser.pop(1)
+            if not x:
+                raise PDFNoValidXRef('Unexpected EOF - file corrupted')
+            (_,dic) = x[0]
+        self.trailer.update( dict_value(dic))
+        return
 
-  KEYWORD_TRAILER = PSKeywordTable.intern('trailer')
-  def load_trailer(self, parser):
-    try:
-      (_,kwd) = parser.nexttoken()
-      assert kwd is self.KEYWORD_TRAILER
-      (_,dic) = parser.nextobject()
-    except PSEOF:
-      x = parser.pop(1)
-      if not x:
-        raise PDFNoValidXRef('Unexpected EOF - file corrupted')
-      (_,dic) = x[0]
-    self.trailer.update( dict_value(dic))
-    return
-
-  def getpos(self, objid):
-    try:
-      (genno, pos) = self.offsets[objid]
-    except KeyError:
-      raise
-    return (None, pos)
+    def getpos(self, objid):
+        try:
+            (genno, pos) = self.offsets[objid]
+        except KeyError:
+            raise
+        return (None, pos)
 
 
 ##  PDFXRefStream
 ##
 class PDFXRefStream(PDFBaseXRef):
 
-  def __init__(self):
-    PDFBaseXRef.__init__(self)
-    self.data = None
-    self.entlen = None
-    self.fl1 = self.fl2 = self.fl3 = None
-    return
+    def __init__(self):
+        PDFBaseXRef.__init__(self)
+        self.data = None
+        self.entlen = None
+        self.fl1 = self.fl2 = self.fl3 = None
+        return
 
-  def __repr__(self):
-    return '<PDFXRefStream: fields=%d,%d,%d>' % (self.fl1, self.fl2, self.fl3)
+    def __repr__(self):
+        return '<PDFXRefStream: fields=%d,%d,%d>' % (self.fl1, self.fl2, self.fl3)
 
-  def load(self, parser, debug=0):
-    (_,objid) = parser.nexttoken() # ignored
-    (_,genno) = parser.nexttoken() # ignored
-    (_,kwd) = parser.nexttoken()
-    (_,stream) = parser.nextobject()
-    if not isinstance(stream, PDFStream) or stream.dic['Type'] is not LITERAL_XREF:
-      raise PDFNoValidXRef('Invalid PDF stream spec.')
-    size = stream.dic['Size']
-    index_array = stream.dic.get('Index', (0,size))
-    if len(index_array) % 2 != 0:
-      raise PDFSyntaxError('Invalid index number')
-    self.objid_ranges = [ XRefObjRange(start,nobjs) for (start,nobjs) in choplist(2, index_array) ]
-    (self.fl1, self.fl2, self.fl3) = stream.dic['W']
-    self.data = stream.get_data()
-    self.entlen = self.fl1+self.fl2+self.fl3
-    self.trailer = stream.dic
-    if debug:
-      print >>stderr, ('xref stream: objid=%s, fields=%d,%d,%d' %
-                       (', '.join(map(repr, self.objid_ranges), self.fl1, self.fl2, self.fl3)))
-    return
+    def load(self, parser, debug=0):
+        (_,objid) = parser.nexttoken() # ignored
+        (_,genno) = parser.nexttoken() # ignored
+        (_,kwd) = parser.nexttoken()
+        (_,stream) = parser.nextobject()
+        if not isinstance(stream, PDFStream) or stream.dic['Type'] is not LITERAL_XREF:
+            raise PDFNoValidXRef('Invalid PDF stream spec.')
+        size = stream.dic['Size']
+        index_array = stream.dic.get('Index', (0,size))
+        if len(index_array) % 2 != 0:
+            raise PDFSyntaxError('Invalid index number')
+        self.objid_ranges = [ XRefObjRange(start,nobjs) for (start,nobjs) in choplist(2, index_array) ]
+        (self.fl1, self.fl2, self.fl3) = stream.dic['W']
+        self.data = stream.get_data()
+        self.entlen = self.fl1+self.fl2+self.fl3
+        self.trailer = stream.dic
+        if debug:
+            print >>stderr, ('xref stream: objid=%s, fields=%d,%d,%d' %
+                             (', '.join(map(repr, self.objid_ranges), self.fl1, self.fl2, self.fl3)))
+        return
 
-  def getpos(self, objid):
-    offset = 0
-    found = False
-    for objid_range in self.objid_ranges:
-      if objid >= objid_range.get_start_id() and objid <= objid_range.get_end_id():
-        offset += objid - objid_range.get_start_id()
-        found = True
-        break
-      else:
-        offset += objid_range.get_nobjs()
-    if not found: raise KeyError(objid)
-    i = self.entlen * offset
-    ent = self.data[i:i+self.entlen]
-    f1 = nunpack(ent[:self.fl1], 1)
-    if f1 == 1:
-      pos = nunpack(ent[self.fl1:self.fl1+self.fl2])
-      genno = nunpack(ent[self.fl1+self.fl2:])
-      return (None, pos)
-    elif f1 == 2:
-      objid = nunpack(ent[self.fl1:self.fl1+self.fl2])
-      index = nunpack(ent[self.fl1+self.fl2:])
-      return (objid, index)
-    # this is a free object
-    raise KeyError(objid)
+    def getpos(self, objid):
+        offset = 0
+        found = False
+        for objid_range in self.objid_ranges:
+            if objid >= objid_range.get_start_id() and objid <= objid_range.get_end_id():
+                offset += objid - objid_range.get_start_id()
+                found = True
+                break
+            else:
+                offset += objid_range.get_nobjs()
+        if not found: raise KeyError(objid)
+        i = self.entlen * offset
+        ent = self.data[i:i+self.entlen]
+        f1 = nunpack(ent[:self.fl1], 1)
+        if f1 == 1:
+            pos = nunpack(ent[self.fl1:self.fl1+self.fl2])
+            genno = nunpack(ent[self.fl1+self.fl2:])
+            return (None, pos)
+        elif f1 == 2:
+            objid = nunpack(ent[self.fl1:self.fl1+self.fl2])
+            index = nunpack(ent[self.fl1+self.fl2:])
+            return (objid, index)
+        # this is a free object
+        raise KeyError(objid)
 
 
 ##  PDFPage
@@ -208,31 +208,31 @@ class PDFXRefStream(PDFBaseXRef):
 ##
 class PDFPage(object):
 
-  def __init__(self, doc, pageid, attrs):
-    self.doc = doc
-    self.pageid = pageid
-    self.attrs = dict_value(attrs)
-    self.lastmod = resolve1(self.attrs.get('LastModified'))
-    self.resources = resolve1(self.attrs['Resources'])
-    self.mediabox = resolve1(self.attrs['MediaBox'])
-    if 'CropBox' in self.attrs:
-      self.cropbox = resolve1(self.attrs['CropBox'])
-    else:
-      self.cropbox = self.mediabox
-    self.rotate = self.attrs.get('Rotate', 0)
-    self.annots = self.attrs.get('Annots')
-    self.beads = self.attrs.get('B')
-    if 'Contents' in self.attrs:
-      contents = resolve1(self.attrs['Contents'])
-    else:
-      contents = []
-    if not isinstance(contents, list):
-      contents = [ contents ]
-    self.contents = contents
-    return
+    def __init__(self, doc, pageid, attrs):
+        self.doc = doc
+        self.pageid = pageid
+        self.attrs = dict_value(attrs)
+        self.lastmod = resolve1(self.attrs.get('LastModified'))
+        self.resources = resolve1(self.attrs['Resources'])
+        self.mediabox = resolve1(self.attrs['MediaBox'])
+        if 'CropBox' in self.attrs:
+            self.cropbox = resolve1(self.attrs['CropBox'])
+        else:
+            self.cropbox = self.mediabox
+        self.rotate = self.attrs.get('Rotate', 0)
+        self.annots = self.attrs.get('Annots')
+        self.beads = self.attrs.get('B')
+        if 'Contents' in self.attrs:
+            contents = resolve1(self.attrs['Contents'])
+        else:
+            contents = []
+        if not isinstance(contents, list):
+            contents = [ contents ]
+        self.contents = contents
+        return
 
-  def __repr__(self):
-    return '<PDFPage: Resources=%r, MediaBox=%r>' % (self.resources, self.mediabox)
+    def __repr__(self):
+        return '<PDFPage: Resources=%r, MediaBox=%r>' % (self.resources, self.mediabox)
 
 
 ##  PDFDocument
@@ -244,461 +244,461 @@ class PDFPage(object):
 ##
 class PDFDocument(object):
 
-  debug = 0
+    debug = 0
 
-  def __init__(self):
-    self.xrefs = []
-    self.objs = {}
-    self.parsed_objs = {}
-    self.root = None
-    self.catalog = None
-    self.parser = None
-    self.encryption = None
-    self.decipher = None
-    self.ready = False
-    return
+    def __init__(self):
+        self.xrefs = []
+        self.objs = {}
+        self.parsed_objs = {}
+        self.root = None
+        self.catalog = None
+        self.parser = None
+        self.encryption = None
+        self.decipher = None
+        self.ready = False
+        return
 
-  # set_parser(parser)
-  #   Associates the document with an (already initialized) parser object.
-  def set_parser(self, parser):
-    if self.parser: return
-    self.parser = parser
-    # The document is set to be temporarily ready during collecting
-    # all the basic information about the document, e.g.
-    # the header, the encryption information, and the access rights
-    # for the document.
-    self.ready = True
-    # Retrieve the information of each header that was appended
-    # (maybe multiple times) at the end of the document.
-    self.xrefs = parser.read_xref()
-    for xref in self.xrefs:
-      trailer = xref.trailer
-      if not trailer: continue
-      # If there's an encryption info, remember it.
-      if 'Encrypt' in trailer:
-        #assert not self.encryption
-        self.encryption = (list_value(trailer['ID']),
-                           dict_value(trailer['Encrypt']))
-      if 'Root' in trailer:
-        self.set_root(dict_value(trailer['Root']))
-        break
-    else:
-      raise PDFSyntaxError('No /Root object! - Is this really a PDF?')
-    # The document is set to be non-ready again, until all the
-    # proper initialization (asking the password key and
-    # verifying the access permission, so on) is finished.
-    self.ready = False
-    return
-
-  # set_root(root)
-  #   Set the Root dictionary of the document.
-  #   Each PDF file must have exactly one /Root dictionary.
-  def set_root(self, root):
-    self.root = root
-    self.catalog = dict_value(self.root)
-    if self.catalog.get('Type') is not LITERAL_CATALOG:
-      if STRICT:
-        raise PDFSyntaxError('Catalog not found!')
-    return
-
-  # initialize(password='')
-  #   Perform the initialization with a given password.
-  #   This step is mandatory even if there's no password associated
-  #   with the document.
-  PASSWORD_PADDING = '(\xbfN^Nu\x8aAd\x00NV\xff\xfa\x01\x08..\x00\xb6\xd0h>\x80/\x0c\xa9\xfedSiz'
-  def initialize(self, password=''):
-    if not self.encryption:
-      self.is_printable = self.is_modifiable = self.is_extractable = True
-      self.ready = True
-      return
-    (docid, param) = self.encryption
-    if literal_name(param['Filter']) != 'Standard':
-      raise PDFEncryptionError('Unknown filter: param=%r' % param)
-    V = int_value(param.get('V', 0))
-    if not (V == 1 or V == 2):
-      raise PDFEncryptionError('Unknown algorithm: param=%r' % param)
-    length = int_value(param.get('Length', 40)) # Key length (bits)
-    O = str_value(param['O'])
-    R = int_value(param['R']) # Revision
-    if 5 <= R:
-      raise PDFEncryptionError('Unknown revision: %r' % R)
-    U = str_value(param['U'])
-    P = int_value(param['P'])
-    self.is_printable = bool(P & 4)
-    self.is_modifiable = bool(P & 8)
-    self.is_extractable = bool(P & 16)
-    # Algorithm 3.2
-    password = (password+self.PASSWORD_PADDING)[:32] # 1
-    hash = md5.md5(password) # 2
-    hash.update(O) # 3
-    hash.update(struct.pack('<l', P)) # 4
-    hash.update(docid[0]) # 5
-    if 4 <= R:
-      # 6
-      raise PDFNotImplementedError('Revision 4 encryption is currently unsupported')
-    if 3 <= R:
-      # 8
-      for _ in xrange(50):
-        hash = md5.md5(hash.digest()[:length/8])
-    key = hash.digest()[:length/8]
-    if R == 2:
-      # Algorithm 3.4
-      u1 = Arcfour(key).process(password)
-    elif R == 3:
-      # Algorithm 3.5
-      hash = md5.md5(self.PASSWORD_PADDING) # 2
-      hash.update(docid[0]) # 3
-      x = Arcfour(key).process(hash.digest()[:16]) # 4
-      for i in xrange(1,19+1):
-        k = ''.join( chr(ord(c) ^ i) for c in key )
-        x = Arcfour(k).process(x)
-      u1 = x+x # 32bytes total
-    if R == 2:
-      is_authenticated = (u1 == U)
-    else:
-      is_authenticated = (u1[:16] == U[:16])
-    if not is_authenticated:
-      raise PDFPasswordIncorrect
-    self.decrypt_key = key
-    self.decipher = self.decrypt_rc4  # XXX may be AES
-    self.ready = True
-    return
-
-  def decrypt_rc4(self, objid, genno, data):
-    key = self.decrypt_key + struct.pack('<L',objid)[:3]+struct.pack('<L',genno)[:2]
-    hash = md5.md5(key)
-    key = hash.digest()[:min(len(key),16)]
-    return Arcfour(key).process(data)
-
-  KEYWORD_OBJ = PSKeywordTable.intern('obj')
-  def getobj(self, objid):
-    if not self.ready:
-      raise PDFException('PDFDocument not initialized')
-    #assert self.xrefs
-    if 2 <= self.debug:
-      print >>stderr, 'getobj: objid=%r' % (objid)
-    if objid in self.objs:
-      genno = 0
-      obj = self.objs[objid]
-    else:
-      for xref in self.xrefs:
-        try:
-          (strmid, index) = xref.getpos(objid)
-          break
-        except KeyError:
-          pass
-      else:
-        if STRICT:
-          raise PDFSyntaxError('Cannot locate objid=%r' % objid)
-        return None
-      if strmid:
-        stream = stream_value(self.getobj(strmid))
-        if stream.dic.get('Type') is not LITERAL_OBJSTM:
-          if STRICT:
-            raise PDFSyntaxError('Not a stream object: %r' % stream)
-        try:
-          n = stream.dic['N']
-        except KeyError:
-          if STRICT:
-            raise PDFSyntaxError('N is not defined: %r' % stream)
-          n = 0
-        if strmid in self.parsed_objs:
-          objs = self.parsed_objs[strmid]
+    # set_parser(parser)
+    #   Associates the document with an (already initialized) parser object.
+    def set_parser(self, parser):
+        if self.parser: return
+        self.parser = parser
+        # The document is set to be temporarily ready during collecting
+        # all the basic information about the document, e.g.
+        # the header, the encryption information, and the access rights
+        # for the document.
+        self.ready = True
+        # Retrieve the information of each header that was appended
+        # (maybe multiple times) at the end of the document.
+        self.xrefs = parser.read_xref()
+        for xref in self.xrefs:
+            trailer = xref.trailer
+            if not trailer: continue
+            # If there's an encryption info, remember it.
+            if 'Encrypt' in trailer:
+                #assert not self.encryption
+                self.encryption = (list_value(trailer['ID']),
+                                   dict_value(trailer['Encrypt']))
+            if 'Root' in trailer:
+                self.set_root(dict_value(trailer['Root']))
+                break
         else:
-          parser = PDFObjStrmParser(self, stream.get_data())
-          objs = []
-          try:
-            while 1:
-              (_,obj) = parser.nextobject()
-              objs.append(obj)
-          except PSEOF:
-            pass
-          self.parsed_objs[strmid] = objs
-        genno = 0
-        i = n*2+index
-        try:
-          obj = objs[i]
-        except IndexError:
-          raise PDFSyntaxError('Invalid object number: objid=%r' % (objid))
-        if isinstance(obj, PDFStream):
-          obj.set_objid(objid, 0)
-      else:
-        self.parser.seek(index)
-        (_,objid1) = self.parser.nexttoken() # objid
-        (_,genno) = self.parser.nexttoken() # genno
-        (_,kwd) = self.parser.nexttoken()
+            raise PDFSyntaxError('No /Root object! - Is this really a PDF?')
+        # The document is set to be non-ready again, until all the
+        # proper initialization (asking the password key and
+        # verifying the access permission, so on) is finished.
+        self.ready = False
+        return
+
+    # set_root(root)
+    #   Set the Root dictionary of the document.
+    #   Each PDF file must have exactly one /Root dictionary.
+    def set_root(self, root):
+        self.root = root
+        self.catalog = dict_value(self.root)
+        if self.catalog.get('Type') is not LITERAL_CATALOG:
+            if STRICT:
+                raise PDFSyntaxError('Catalog not found!')
+        return
+
+    # initialize(password='')
+    #   Perform the initialization with a given password.
+    #   This step is mandatory even if there's no password associated
+    #   with the document.
+    PASSWORD_PADDING = '(\xbfN^Nu\x8aAd\x00NV\xff\xfa\x01\x08..\x00\xb6\xd0h>\x80/\x0c\xa9\xfedSiz'
+    def initialize(self, password=''):
+        if not self.encryption:
+            self.is_printable = self.is_modifiable = self.is_extractable = True
+            self.ready = True
+            return
+        (docid, param) = self.encryption
+        if literal_name(param['Filter']) != 'Standard':
+            raise PDFEncryptionError('Unknown filter: param=%r' % param)
+        V = int_value(param.get('V', 0))
+        if not (V == 1 or V == 2):
+            raise PDFEncryptionError('Unknown algorithm: param=%r' % param)
+        length = int_value(param.get('Length', 40)) # Key length (bits)
+        O = str_value(param['O'])
+        R = int_value(param['R']) # Revision
+        if 5 <= R:
+            raise PDFEncryptionError('Unknown revision: %r' % R)
+        U = str_value(param['U'])
+        P = int_value(param['P'])
+        self.is_printable = bool(P & 4)
+        self.is_modifiable = bool(P & 8)
+        self.is_extractable = bool(P & 16)
+        # Algorithm 3.2
+        password = (password+self.PASSWORD_PADDING)[:32] # 1
+        hash = md5.md5(password) # 2
+        hash.update(O) # 3
+        hash.update(struct.pack('<l', P)) # 4
+        hash.update(docid[0]) # 5
+        if 4 <= R:
+            # 6
+            raise PDFNotImplementedError('Revision 4 encryption is currently unsupported')
+        if 3 <= R:
+            # 8
+            for _ in xrange(50):
+                hash = md5.md5(hash.digest()[:length/8])
+        key = hash.digest()[:length/8]
+        if R == 2:
+            # Algorithm 3.4
+            u1 = Arcfour(key).process(password)
+        elif R == 3:
+            # Algorithm 3.5
+            hash = md5.md5(self.PASSWORD_PADDING) # 2
+            hash.update(docid[0]) # 3
+            x = Arcfour(key).process(hash.digest()[:16]) # 4
+            for i in xrange(1,19+1):
+                k = ''.join( chr(ord(c) ^ i) for c in key )
+                x = Arcfour(k).process(x)
+            u1 = x+x # 32bytes total
+        if R == 2:
+            is_authenticated = (u1 == U)
+        else:
+            is_authenticated = (u1[:16] == U[:16])
+        if not is_authenticated:
+            raise PDFPasswordIncorrect
+        self.decrypt_key = key
+        self.decipher = self.decrypt_rc4  # XXX may be AES
+        self.ready = True
+        return
+
+    def decrypt_rc4(self, objid, genno, data):
+        key = self.decrypt_key + struct.pack('<L',objid)[:3]+struct.pack('<L',genno)[:2]
+        hash = md5.md5(key)
+        key = hash.digest()[:min(len(key),16)]
+        return Arcfour(key).process(data)
+
+    KEYWORD_OBJ = PSKeywordTable.intern('obj')
+    def getobj(self, objid):
+        if not self.ready:
+            raise PDFException('PDFDocument not initialized')
+        #assert self.xrefs
+        if 2 <= self.debug:
+            print >>stderr, 'getobj: objid=%r' % (objid)
+        if objid in self.objs:
+            genno = 0
+            obj = self.objs[objid]
+        else:
+            for xref in self.xrefs:
+                try:
+                    (strmid, index) = xref.getpos(objid)
+                    break
+                except KeyError:
+                    pass
+            else:
+                if STRICT:
+                    raise PDFSyntaxError('Cannot locate objid=%r' % objid)
+                return None
+            if strmid:
+                stream = stream_value(self.getobj(strmid))
+                if stream.dic.get('Type') is not LITERAL_OBJSTM:
+                    if STRICT:
+                        raise PDFSyntaxError('Not a stream object: %r' % stream)
+                try:
+                    n = stream.dic['N']
+                except KeyError:
+                    if STRICT:
+                        raise PDFSyntaxError('N is not defined: %r' % stream)
+                    n = 0
+                if strmid in self.parsed_objs:
+                    objs = self.parsed_objs[strmid]
+                else:
+                    parser = PDFObjStrmParser(self, stream.get_data())
+                    objs = []
+                    try:
+                        while 1:
+                            (_,obj) = parser.nextobject()
+                            objs.append(obj)
+                    except PSEOF:
+                        pass
+                    self.parsed_objs[strmid] = objs
+                genno = 0
+                i = n*2+index
+                try:
+                    obj = objs[i]
+                except IndexError:
+                    raise PDFSyntaxError('Invalid object number: objid=%r' % (objid))
+                if isinstance(obj, PDFStream):
+                    obj.set_objid(objid, 0)
+            else:
+                self.parser.seek(index)
+                (_,objid1) = self.parser.nexttoken() # objid
+                (_,genno) = self.parser.nexttoken() # genno
+                (_,kwd) = self.parser.nexttoken()
 # #### hack around malformed pdf files
 #        assert objid1 == objid, (objid, objid1)
-        if objid1 != objid:
-            x = []
-            while kwd is not self.KEYWORD_OBJ:
-                (_,kwd) = self.parser.nexttoken()
-                x.append(kwd)
-            if x:
-                objid1 = x[-2]
-                genno = x[-1]
+                if objid1 != objid:
+                    x = []
+                    while kwd is not self.KEYWORD_OBJ:
+                        (_,kwd) = self.parser.nexttoken()
+                        x.append(kwd)
+                    if x:
+                        objid1 = x[-2]
+                        genno = x[-1]
 # #### end hack around malformed pdf files
-        if kwd is not self.KEYWORD_OBJ:
-          raise PDFSyntaxError('Invalid object spec: offset=%r' % index)
-        (_,obj) = self.parser.nextobject()
-        if isinstance(obj, PDFStream):
-          obj.set_objid(objid, genno)
-      if 2 <= self.debug:
-        print >>stderr, 'register: objid=%r: %r' % (objid, obj)
-      self.objs[objid] = obj
-    if self.decipher:
-      obj = decipher_all(self.decipher, objid, genno, obj)
-    return obj
+                if kwd is not self.KEYWORD_OBJ:
+                    raise PDFSyntaxError('Invalid object spec: offset=%r' % index)
+                (_,obj) = self.parser.nextobject()
+                if isinstance(obj, PDFStream):
+                    obj.set_objid(objid, genno)
+            if 2 <= self.debug:
+                print >>stderr, 'register: objid=%r: %r' % (objid, obj)
+            self.objs[objid] = obj
+        if self.decipher:
+            obj = decipher_all(self.decipher, objid, genno, obj)
+        return obj
 
-  INHERITABLE_ATTRS = set(['Resources', 'MediaBox', 'CropBox', 'Rotate'])
-  def get_pages(self):
-    if not self.ready:
-      raise PDFException('PDFDocument is not initialized')
-    #assert self.xrefs
-    def search(obj, parent):
-      tree = dict_value(obj).copy()
-      for (k,v) in parent.iteritems():
-        if k in self.INHERITABLE_ATTRS and k not in tree:
-          tree[k] = v
-      if tree.get('Type') is LITERAL_PAGES and 'Kids' in tree:
-        if 1 <= self.debug:
-          print >>stderr, 'Pages: Kids=%r' % tree['Kids']
-        for c in list_value(tree['Kids']):
-          for x in search(c, tree):
-            yield x
-      elif tree.get('Type') is LITERAL_PAGE:
-        if 1 <= self.debug:
-          print >>stderr, 'Page: %r' % tree
-        yield (obj.objid, tree)
-    if 'Pages' not in self.catalog: return
-    for (pageid,tree) in search(self.catalog['Pages'], self.catalog):
-      yield PDFPage(self, pageid, tree)
-    return
+    INHERITABLE_ATTRS = set(['Resources', 'MediaBox', 'CropBox', 'Rotate'])
+    def get_pages(self):
+        if not self.ready:
+            raise PDFException('PDFDocument is not initialized')
+        #assert self.xrefs
+        def search(obj, parent):
+            tree = dict_value(obj).copy()
+            for (k,v) in parent.iteritems():
+                if k in self.INHERITABLE_ATTRS and k not in tree:
+                    tree[k] = v
+            if tree.get('Type') is LITERAL_PAGES and 'Kids' in tree:
+                if 1 <= self.debug:
+                    print >>stderr, 'Pages: Kids=%r' % tree['Kids']
+                for c in list_value(tree['Kids']):
+                    for x in search(c, tree):
+                        yield x
+            elif tree.get('Type') is LITERAL_PAGE:
+                if 1 <= self.debug:
+                    print >>stderr, 'Page: %r' % tree
+                yield (obj.objid, tree)
+        if 'Pages' not in self.catalog: return
+        for (pageid,tree) in search(self.catalog['Pages'], self.catalog):
+            yield PDFPage(self, pageid, tree)
+        return
 
-  def get_outlines(self):
-    if 'Outlines' not in self.catalog:
-      raise PDFException('No /Outlines defined!')
-    def search(entry, level):
-      entry = dict_value(entry)
-      if 'Title' in entry:
-        if 'A' in entry or 'Dest' in entry:
-          title = decode_text(str_value(entry['Title']))
-          dest = entry.get('Dest')
-          action = entry.get('A')
-          se = entry.get('SE')
-          yield (level, title, dest, action, se)
-      if 'First' in entry and 'Last' in entry:
-        for x in search(entry['First'], level+1):
-          yield x
-      if 'Next' in entry:
-        for x in search(entry['Next'], level):
-          yield x
-      return
-    return search(self.catalog['Outlines'], 0)
+    def get_outlines(self):
+        if 'Outlines' not in self.catalog:
+            raise PDFException('No /Outlines defined!')
+        def search(entry, level):
+            entry = dict_value(entry)
+            if 'Title' in entry:
+                if 'A' in entry or 'Dest' in entry:
+                    title = decode_text(str_value(entry['Title']))
+                    dest = entry.get('Dest')
+                    action = entry.get('A')
+                    se = entry.get('SE')
+                    yield (level, title, dest, action, se)
+            if 'First' in entry and 'Last' in entry:
+                for x in search(entry['First'], level+1):
+                    yield x
+            if 'Next' in entry:
+                for x in search(entry['Next'], level):
+                    yield x
+            return
+        return search(self.catalog['Outlines'], 0)
 
-  def lookup_name(self, cat, key):
-    try:
-      names = dict_value(self.catalog['Names'])
-    except (PDFTypeError, KeyError):
-      raise KeyError((cat,key))
-    # may raise KeyError
-    d0 = dict_value(names[cat])
-    def lookup(d):
-      if 'Limits' in d:
-        (k1,k2) = list_value(d['Limits'])
-        if key < k1 or k2 < key: return None
-        if 'Names' in d:
-          objs = list_value(d['Names'])
-          names = dict(choplist(2, objs))
-          return names[key]
-      if 'Kids' in d:
-        for c in list_value(d['Kids']):
-          v = lookup(dict_value(c))
-          if v: return v
-      raise KeyError((cat,key))
-    return lookup(d0)
+    def lookup_name(self, cat, key):
+        try:
+            names = dict_value(self.catalog['Names'])
+        except (PDFTypeError, KeyError):
+            raise KeyError((cat,key))
+        # may raise KeyError
+        d0 = dict_value(names[cat])
+        def lookup(d):
+            if 'Limits' in d:
+                (k1,k2) = list_value(d['Limits'])
+                if key < k1 or k2 < key: return None
+                if 'Names' in d:
+                    objs = list_value(d['Names'])
+                    names = dict(choplist(2, objs))
+                    return names[key]
+            if 'Kids' in d:
+                for c in list_value(d['Kids']):
+                    v = lookup(dict_value(c))
+                    if v: return v
+            raise KeyError((cat,key))
+        return lookup(d0)
 
 
 ##  PDFParser
 ##
 class PDFParser(PSStackParser):
 
-  def __init__(self, doc, fp):
-    PSStackParser.__init__(self, fp)
-    self.doc = doc
-    self.doc.set_parser(self)
-    return
-
-  def __repr__(self):
-    return '<PDFParser>'
-
-  KEYWORD_R = PSKeywordTable.intern('R')
-  KEYWORD_ENDOBJ = PSKeywordTable.intern('endobj')
-  KEYWORD_STREAM = PSKeywordTable.intern('stream')
-  KEYWORD_XREF = PSKeywordTable.intern('xref')
-  KEYWORD_STARTXREF = PSKeywordTable.intern('startxref')
-  def do_keyword(self, pos, token):
-    if token in (self.KEYWORD_XREF, self.KEYWORD_STARTXREF):
-      self.add_results(*self.pop(1))
-      return
-    if token is self.KEYWORD_ENDOBJ:
-      self.add_results(*self.pop(4))
-      return
-
-    if token is self.KEYWORD_R:
-      # reference to indirect object
-      try:
-        ((_,objid), (_,genno)) = self.pop(2)
-        (objid, genno) = (int(objid), int(genno))
-        obj = PDFObjRef(self.doc, objid, genno)
-        self.push((pos, obj))
-      except PSSyntaxError:
-        pass
-      return
-
-    if token is self.KEYWORD_STREAM:
-      # stream object
-      ((_,dic),) = self.pop(1)
-      dic = dict_value(dic)
-      try:
-        objlen = int_value(dic['Length'])
-      except KeyError:
-        if STRICT:
-          raise PDFSyntaxError('/Length is undefined: %r' % dic)
-        objlen = 0
-      self.seek(pos)
-      try:
-        (_, line) = self.nextline()  # 'stream'
-      except PSEOF:
-        if STRICT:
-          raise PDFSyntaxError('Unexpected EOF')
+    def __init__(self, doc, fp):
+        PSStackParser.__init__(self, fp)
+        self.doc = doc
+        self.doc.set_parser(self)
         return
-      pos += len(line)
-      self.fp.seek(pos)
-      data = self.fp.read(objlen)
-      self.seek(pos+objlen)
-      while 1:
+
+    def __repr__(self):
+        return '<PDFParser>'
+
+    KEYWORD_R = PSKeywordTable.intern('R')
+    KEYWORD_ENDOBJ = PSKeywordTable.intern('endobj')
+    KEYWORD_STREAM = PSKeywordTable.intern('stream')
+    KEYWORD_XREF = PSKeywordTable.intern('xref')
+    KEYWORD_STARTXREF = PSKeywordTable.intern('startxref')
+    def do_keyword(self, pos, token):
+        if token in (self.KEYWORD_XREF, self.KEYWORD_STARTXREF):
+            self.add_results(*self.pop(1))
+            return
+        if token is self.KEYWORD_ENDOBJ:
+            self.add_results(*self.pop(4))
+            return
+
+        if token is self.KEYWORD_R:
+            # reference to indirect object
+            try:
+                ((_,objid), (_,genno)) = self.pop(2)
+                (objid, genno) = (int(objid), int(genno))
+                obj = PDFObjRef(self.doc, objid, genno)
+                self.push((pos, obj))
+            except PSSyntaxError:
+                pass
+            return
+
+        if token is self.KEYWORD_STREAM:
+            # stream object
+            ((_,dic),) = self.pop(1)
+            dic = dict_value(dic)
+            try:
+                objlen = int_value(dic['Length'])
+            except KeyError:
+                if STRICT:
+                    raise PDFSyntaxError('/Length is undefined: %r' % dic)
+                objlen = 0
+            self.seek(pos)
+            try:
+                (_, line) = self.nextline()  # 'stream'
+            except PSEOF:
+                if STRICT:
+                    raise PDFSyntaxError('Unexpected EOF')
+                return
+            pos += len(line)
+            self.fp.seek(pos)
+            data = self.fp.read(objlen)
+            self.seek(pos+objlen)
+            while 1:
+                try:
+                    (linepos, line) = self.nextline()
+                except PSEOF:
+                    if STRICT:
+                        raise PDFSyntaxError('Unexpected EOF')
+                    break
+                if 'endstream' in line:
+                    i = line.index('endstream')
+                    objlen += i
+                    data += line[:i]
+                    break
+                objlen += len(line)
+                data += line
+            self.seek(pos+objlen)
+            if 1 <= self.debug:
+                print >>stderr, 'Stream: pos=%d, objlen=%d, dic=%r, data=%r...' % \
+                      (pos, objlen, dic, data[:10])
+            obj = PDFStream(dic, data, self.doc.decipher)
+            self.push((pos, obj))
+            return
+
+        # others
+        self.push((pos, token))
+        return
+
+    def find_xref(self):
+        # search the last xref table by scanning the file backwards.
+        prev = None
+        for line in self.revreadlines():
+            line = line.strip()
+            if 2 <= self.debug:
+                print >>stderr, 'find_xref: %r' % line
+            if line == 'startxref': break
+            if line:
+                prev = line
+        else:
+            raise PDFNoValidXRef('Unexpected EOF')
+        if 1 <= self.debug:
+            print >>stderr, 'xref found: pos=%r' % prev
+        return long(prev)
+
+    # read xref table
+    def read_xref_from(self, start, xrefs):
+        self.seek(start)
+        self.reset()
         try:
-          (linepos, line) = self.nextline()
+            (pos, token) = self.nexttoken()
         except PSEOF:
-          if STRICT:
-            raise PDFSyntaxError('Unexpected EOF')
-          break
-        if 'endstream' in line:
-          i = line.index('endstream')
-          objlen += i
-          data += line[:i]
-          break
-        objlen += len(line)
-        data += line
-      self.seek(pos+objlen)
-      if 1 <= self.debug:
-        print >>stderr, 'Stream: pos=%d, objlen=%d, dic=%r, data=%r...' % \
-              (pos, objlen, dic, data[:10])
-      obj = PDFStream(dic, data, self.doc.decipher)
-      self.push((pos, obj))
-      return
+            raise PDFNoValidXRef('Unexpected EOF')
+        if 2 <= self.debug:
+            print >>stderr, 'read_xref_from: start=%d, token=%r' % (start, token)
+        if isinstance(token, int):
+            # XRefStream: PDF-1.5
+            self.seek(pos)
+            self.reset()
+            xref = PDFXRefStream()
+            xref.load(self, debug=self.debug)
+        else:
+            if token is self.KEYWORD_XREF:
+                self.nextline()
+            xref = PDFXRef()
+            xref.load(self, debug=self.debug)
+        xrefs.append(xref)
+        trailer = xref.trailer
+        if 1 <= self.debug:
+            print >>stderr, 'trailer: %r' % trailer
+        if 'XRefStm' in trailer:
+            pos = int_value(trailer['XRefStm'])
+            self.read_xref_from(pos, xrefs)
+        if 'Prev' in trailer:
+            # find previous xref
+            pos = int_value(trailer['Prev'])
+            self.read_xref_from(pos, xrefs)
+        return
 
-    # others
-    self.push((pos, token))
-    return
-
-  def find_xref(self):
-    # search the last xref table by scanning the file backwards.
-    prev = None
-    for line in self.revreadlines():
-      line = line.strip()
-      if 2 <= self.debug:
-        print >>stderr, 'find_xref: %r' % line
-      if line == 'startxref': break
-      if line:
-        prev = line
-    else:
-      raise PDFNoValidXRef('Unexpected EOF')
-    if 1 <= self.debug:
-      print >>stderr, 'xref found: pos=%r' % prev
-    return long(prev)
-
-  # read xref table
-  def read_xref_from(self, start, xrefs):
-    self.seek(start)
-    self.reset()
-    try:
-      (pos, token) = self.nexttoken()
-    except PSEOF:
-      raise PDFNoValidXRef('Unexpected EOF')
-    if 2 <= self.debug:
-      print >>stderr, 'read_xref_from: start=%d, token=%r' % (start, token)
-    if isinstance(token, int):
-      # XRefStream: PDF-1.5
-      self.seek(pos)
-      self.reset()
-      xref = PDFXRefStream()
-      xref.load(self, debug=self.debug)
-    else:
-      if token is self.KEYWORD_XREF:
-        self.nextline()
-      xref = PDFXRef()
-      xref.load(self, debug=self.debug)
-    xrefs.append(xref)
-    trailer = xref.trailer
-    if 1 <= self.debug:
-      print >>stderr, 'trailer: %r' % trailer
-    if 'XRefStm' in trailer:
-      pos = int_value(trailer['XRefStm'])
-      self.read_xref_from(pos, xrefs)
-    if 'Prev' in trailer:
-      # find previous xref
-      pos = int_value(trailer['Prev'])
-      self.read_xref_from(pos, xrefs)
-    return
-
-  # read xref tables and trailers
-  def read_xref(self):
-    xrefs = []
-    try:
-      pos = self.find_xref()
-      self.read_xref_from(pos, xrefs)
-    except PDFNoValidXRef:
-      # fallback
-      if 1 <= self.debug:
-        print >>stderr, 'no xref, fallback'
-      self.seek(0)
-      pat = re.compile(r'^(\d+)\s+(\d+)\s+obj\b')
-      offsets = {}
-      xref = PDFXRef()
-      while 1:
+    # read xref tables and trailers
+    def read_xref(self):
+        xrefs = []
         try:
-          (pos, line) = self.nextline()
-        except PSEOF:
-          break
-        if line.startswith('trailer'):
-          xref.offsets = offsets
-          self.seek(pos)
-          xref.load_trailer(self)
-          if 1 <= self.debug:
-            print >>stderr, 'trailer: %r' % xref.trailer
-          continue
-        m = pat.match(line)
-        if not m: continue
-        (objid, genno) = m.groups()
-        offsets[int(objid)] = (0, pos)
-      xrefs.append(xref)
-    return xrefs
+            pos = self.find_xref()
+            self.read_xref_from(pos, xrefs)
+        except PDFNoValidXRef:
+            # fallback
+            if 1 <= self.debug:
+                print >>stderr, 'no xref, fallback'
+            self.seek(0)
+            pat = re.compile(r'^(\d+)\s+(\d+)\s+obj\b')
+            offsets = {}
+            xref = PDFXRef()
+            while 1:
+                try:
+                    (pos, line) = self.nextline()
+                except PSEOF:
+                    break
+                if line.startswith('trailer'):
+                    xref.offsets = offsets
+                    self.seek(pos)
+                    xref.load_trailer(self)
+                    if 1 <= self.debug:
+                        print >>stderr, 'trailer: %r' % xref.trailer
+                    continue
+                m = pat.match(line)
+                if not m: continue
+                (objid, genno) = m.groups()
+                offsets[int(objid)] = (0, pos)
+            xrefs.append(xref)
+        return xrefs
 
 
 ##  PDFObjStrmParser
 ##
 class PDFObjStrmParser(PDFParser):
-  
-  def __init__(self, doc, data):
-    try:
-      from cStringIO import StringIO
-    except ImportError:
-      from StringIO import StringIO
-    PDFParser.__init__(self, doc, StringIO(data))
-    return
-  
-  def flush(self):
-    self.add_results(*self.popall())
-    return
+
+    def __init__(self, doc, data):
+        try:
+            from cStringIO import StringIO
+        except ImportError:
+            from StringIO import StringIO
+        PDFParser.__init__(self, doc, StringIO(data))
+        return
+
+    def flush(self):
+        self.add_results(*self.popall())
+        return
diff --git a/pdfminer/pdftypes.py b/pdfminer/pdftypes.py
index e265d70..5ec737a 100644
--- a/pdfminer/pdftypes.py
+++ b/pdfminer/pdftypes.py
@@ -25,218 +25,218 @@ class PDFNotImplementedError(PSException): pass
 ##  PDFObjRef
 ##
 class PDFObjRef(PDFObject):
-  
-  def __init__(self, doc, objid, _):
-    if objid == 0:
-      if STRICT:
-        raise PDFValueError('PDF object id cannot be 0.')
-    self.doc = doc
-    self.objid = objid
-    #self.genno = genno  # Never used.
-    return
 
-  def __repr__(self):
-    return '<PDFObjRef:%d>' % (self.objid)
+    def __init__(self, doc, objid, _):
+        if objid == 0:
+            if STRICT:
+                raise PDFValueError('PDF object id cannot be 0.')
+        self.doc = doc
+        self.objid = objid
+        #self.genno = genno  # Never used.
+        return
 
-  def resolve(self):
-    return self.doc.getobj(self.objid)
+    def __repr__(self):
+        return '<PDFObjRef:%d>' % (self.objid)
+
+    def resolve(self):
+        return self.doc.getobj(self.objid)
 
 
 # resolve
 def resolve1(x):
-  '''
-  Resolve an object. If this is an array or dictionary,
-  it may still contains some indirect objects inside.
-  '''
-  while isinstance(x, PDFObjRef):
-    x = x.resolve()
-  return x
+    '''
+    Resolve an object. If this is an array or dictionary,
+    it may still contains some indirect objects inside.
+    '''
+    while isinstance(x, PDFObjRef):
+        x = x.resolve()
+    return x
 
 def resolve_all(x):
-  '''
-  Recursively resolve X and all the internals.
-  Make sure there is no indirect reference within the nested object.
-  This procedure might be slow.
-  '''
-  while isinstance(x, PDFObjRef):
-    x = x.resolve()
-  if isinstance(x, list):
-    x = [ resolve_all(v) for v in x ]
-  elif isinstance(x, dict):
-    for (k,v) in x.iteritems():
-      x[k] = resolve_all(v)
-  return x
+    '''
+    Recursively resolve X and all the internals.
+    Make sure there is no indirect reference within the nested object.
+    This procedure might be slow.
+    '''
+    while isinstance(x, PDFObjRef):
+        x = x.resolve()
+    if isinstance(x, list):
+        x = [ resolve_all(v) for v in x ]
+    elif isinstance(x, dict):
+        for (k,v) in x.iteritems():
+            x[k] = resolve_all(v)
+    return x
 
 def decipher_all(decipher, objid, genno, x):
-  '''
-  Recursively decipher X.
-  '''
-  if isinstance(x, str):
-    return decipher(objid, genno, x)
-  if isinstance(x, list):
-    x = [ decipher_all(decipher, objid, genno, v) for v in x ]
-  elif isinstance(x, dict):
-    for (k,v) in x.iteritems():
-      x[k] = decipher_all(decipher, objid, genno, v)
-  return x
+    '''
+    Recursively decipher X.
+    '''
+    if isinstance(x, str):
+        return decipher(objid, genno, x)
+    if isinstance(x, list):
+        x = [ decipher_all(decipher, objid, genno, v) for v in x ]
+    elif isinstance(x, dict):
+        for (k,v) in x.iteritems():
+            x[k] = decipher_all(decipher, objid, genno, v)
+    return x
 
 # Type cheking
 def int_value(x):
-  x = resolve1(x)
-  if not isinstance(x, int):
-    if STRICT:
-      raise PDFTypeError('Integer required: %r' % x)
-    return 0
-  return x
+    x = resolve1(x)
+    if not isinstance(x, int):
+        if STRICT:
+            raise PDFTypeError('Integer required: %r' % x)
+        return 0
+    return x
 
 def float_value(x):
-  x = resolve1(x)
-  if not isinstance(x, float):
-    if STRICT:
-      raise PDFTypeError('Float required: %r' % x)
-    return 0.0
-  return x
+    x = resolve1(x)
+    if not isinstance(x, float):
+        if STRICT:
+            raise PDFTypeError('Float required: %r' % x)
+        return 0.0
+    return x
 
 def num_value(x):
-  x = resolve1(x)
-  if not (isinstance(x, int) or isinstance(x, float)):
-    if STRICT:
-      raise PDFTypeError('Int or Float required: %r' % x)
-    return 0
-  return x
+    x = resolve1(x)
+    if not (isinstance(x, int) or isinstance(x, float)):
+        if STRICT:
+            raise PDFTypeError('Int or Float required: %r' % x)
+        return 0
+    return x
 
 def str_value(x):
-  x = resolve1(x)
-  if not isinstance(x, str):
-    if STRICT:
-      raise PDFTypeError('String required: %r' % x)
-    return ''
-  return x
+    x = resolve1(x)
+    if not isinstance(x, str):
+        if STRICT:
+            raise PDFTypeError('String required: %r' % x)
+        return ''
+    return x
 
 def list_value(x):
-  x = resolve1(x)
-  if not (isinstance(x, list) or isinstance(x, tuple)):
-    if STRICT:
-      raise PDFTypeError('List required: %r' % x)
-    return []
-  return x
+    x = resolve1(x)
+    if not (isinstance(x, list) or isinstance(x, tuple)):
+        if STRICT:
+            raise PDFTypeError('List required: %r' % x)
+        return []
+    return x
 
 def dict_value(x):
-  x = resolve1(x)
-  if not isinstance(x, dict):
-    if STRICT:
-      raise PDFTypeError('Dict required: %r' % x)
-    return {}
-  return x
+    x = resolve1(x)
+    if not isinstance(x, dict):
+        if STRICT:
+            raise PDFTypeError('Dict required: %r' % x)
+        return {}
+    return x
 
 def stream_value(x):
-  x = resolve1(x)
-  if not isinstance(x, PDFStream):
-    if STRICT:
-      raise PDFTypeError('PDFStream required: %r' % x)
-    return PDFStream({}, '')
-  return x
+    x = resolve1(x)
+    if not isinstance(x, PDFStream):
+        if STRICT:
+            raise PDFTypeError('PDFStream required: %r' % x)
+        return PDFStream({}, '')
+    return x
 
 
 ##  PDFStream type
 ##
 class PDFStream(PDFObject):
-  
-  def __init__(self, dic, rawdata, decipher=None):
-    self.dic = dic
-    self.rawdata = rawdata
-    self.decipher = decipher
-    self.data = None
-    self.objid = None
-    self.genno = None
-    return
 
-  def set_objid(self, objid, genno):
-    self.objid = objid
-    self.genno = genno
-    return
-  
-  def __repr__(self):
-    return '<PDFStream(%r): raw=%d, %r>' % (self.objid, len(self.rawdata), self.dic)
+    def __init__(self, dic, rawdata, decipher=None):
+        self.dic = dic
+        self.rawdata = rawdata
+        self.decipher = decipher
+        self.data = None
+        self.objid = None
+        self.genno = None
+        return
 
-  def decomp(self,data):
-    import zlib
-    buf = data
-    # some FlateDecode streams have garbage (newlines, etc) appended to the
-    # end.  remove chars from the end to try and decompress the buffer
-    while 8 <= len(buf):
-      try:
-        # will get errors if the document is encrypted.
-        dco = zlib.decompressobj()
-        return dco.decompress(buf)
-      except zlib.error:
-        buf = buf[:-1]
-    raise Exception, "zlib.error while decompressing data"
+    def set_objid(self, objid, genno):
+        self.objid = objid
+        self.genno = genno
+        return
 
-  def decode(self):
-    assert self.data == None and self.rawdata != None
-    data = self.rawdata
-    if self.decipher:
-      # Handle encryption
-      data = self.decipher(self.objid, self.genno, data)
-    if 'Filter' not in self.dic:
-      self.data = data
-      self.rawdata = None
-      return
-    filters = self.dic['Filter']
-    if not isinstance(filters, list):
-      filters = [ filters ]
-    for f in filters:
-      if f in LITERALS_FLATE_DECODE:
-        # will get errors if the document is encrypted.
-        data = self.decomp(data)
-      elif f in LITERALS_LZW_DECODE:
-        try:
-          from cStringIO import StringIO
-        except ImportError:
-          from StringIO import StringIO
-        data = ''.join(LZWDecoder(StringIO(data)).run())
-      elif f in LITERALS_ASCII85_DECODE:
-        import ascii85
-        data = ascii85.ascii85decode(data)
-      elif f in LITERALS_ASCIIHEX_DECODE:
-        import ascii85
-        data = ascii85.asciihexdecode(data)
-      elif f == LITERAL_CRYPT:
-        raise PDFNotImplementedError('/Crypt filter is unsupported')
-      else:
-        raise PDFNotImplementedError('Unsupported filter: %r' % f)
-      # apply predictors
-      if 'DP' in self.dic:
-        params = self.dic['DP']
-      else:
-        params = self.dic.get('DecodeParms', {})
-      if 'Predictor' in params:
-        pred = int_value(params['Predictor'])
-        if pred:
-          if pred != 12:
-            raise PDFNotImplementedError('Unsupported predictor: %r' % pred)
-          if 'Columns' not in params:
-            raise PDFValueError('Columns undefined for predictor=12')
-          columns = int_value(params['Columns'])
-          buf = ''
-          ent0 = '\x00' * columns
-          for i in xrange(0, len(data), columns+1):
-            pred = data[i]
-            ent1 = data[i+1:i+1+columns]
-            if pred == '\x02':
-              ent1 = ''.join( chr((ord(a)+ord(b)) & 255) for (a,b) in zip(ent0,ent1) )
-            buf += ent1
-            ent0 = ent1
-          data = buf
-    self.data = data
-    self.rawdata = None
-    return
+    def __repr__(self):
+        return '<PDFStream(%r): raw=%d, %r>' % (self.objid, len(self.rawdata), self.dic)
 
-  def get_data(self):
-    if self.data == None:
-      self.decode()
-    return self.data
+    def decomp(self,data):
+        import zlib
+        buf = data
+        # some FlateDecode streams have garbage (newlines, etc) appended to the
+        # end.  remove chars from the end to try and decompress the buffer
+        while 8 <= len(buf):
+            try:
+                # will get errors if the document is encrypted.
+                dco = zlib.decompressobj()
+                return dco.decompress(buf)
+            except zlib.error:
+                buf = buf[:-1]
+        raise Exception, "zlib.error while decompressing data"
 
-  def get_rawdata(self):
-    return self.rawdata
+    def decode(self):
+        assert self.data == None and self.rawdata != None
+        data = self.rawdata
+        if self.decipher:
+            # Handle encryption
+            data = self.decipher(self.objid, self.genno, data)
+        if 'Filter' not in self.dic:
+            self.data = data
+            self.rawdata = None
+            return
+        filters = self.dic['Filter']
+        if not isinstance(filters, list):
+            filters = [ filters ]
+        for f in filters:
+            if f in LITERALS_FLATE_DECODE:
+                # will get errors if the document is encrypted.
+                data = self.decomp(data)
+            elif f in LITERALS_LZW_DECODE:
+                try:
+                    from cStringIO import StringIO
+                except ImportError:
+                    from StringIO import StringIO
+                data = ''.join(LZWDecoder(StringIO(data)).run())
+            elif f in LITERALS_ASCII85_DECODE:
+                import ascii85
+                data = ascii85.ascii85decode(data)
+            elif f in LITERALS_ASCIIHEX_DECODE:
+                import ascii85
+                data = ascii85.asciihexdecode(data)
+            elif f == LITERAL_CRYPT:
+                raise PDFNotImplementedError('/Crypt filter is unsupported')
+            else:
+                raise PDFNotImplementedError('Unsupported filter: %r' % f)
+            # apply predictors
+            if 'DP' in self.dic:
+                params = self.dic['DP']
+            else:
+                params = self.dic.get('DecodeParms', {})
+            if 'Predictor' in params:
+                pred = int_value(params['Predictor'])
+                if pred:
+                    if pred != 12:
+                        raise PDFNotImplementedError('Unsupported predictor: %r' % pred)
+                    if 'Columns' not in params:
+                        raise PDFValueError('Columns undefined for predictor=12')
+                    columns = int_value(params['Columns'])
+                    buf = ''
+                    ent0 = '\x00' * columns
+                    for i in xrange(0, len(data), columns+1):
+                        pred = data[i]
+                        ent1 = data[i+1:i+1+columns]
+                        if pred == '\x02':
+                            ent1 = ''.join( chr((ord(a)+ord(b)) & 255) for (a,b) in zip(ent0,ent1) )
+                        buf += ent1
+                        ent0 = ent1
+                    data = buf
+        self.data = data
+        self.rawdata = None
+        return
+
+    def get_data(self):
+        if self.data == None:
+            self.decode()
+        return self.data
+
+    def get_rawdata(self):
+        return self.rawdata
diff --git a/pdfminer/psparser.py b/pdfminer/psparser.py
index 4114072..85198ea 100644
--- a/pdfminer/psparser.py
+++ b/pdfminer/psparser.py
@@ -36,13 +36,13 @@ class PSObject(object): pass
 ##  Always use PSLiteralTable.intern().
 ##
 class PSLiteral(PSObject):
-  
-  def __init__(self, name):
-    self.name = name
-    return
-  
-  def __repr__(self):
-    return '/%s' % self.name
+
+    def __init__(self, name):
+        self.name = name
+        return
+
+    def __repr__(self):
+        return '/%s' % self.name
 
 
 ##  PSKeyword
@@ -51,13 +51,13 @@ class PSLiteral(PSObject):
 ##  Always use PSKeywordTable.intern().
 ##
 class PSKeyword(PSObject):
-  
-  def __init__(self, name):
-    self.name = name
-    return
-  
-  def __repr__(self):
-    return self.name
+
+    def __init__(self, name):
+        self.name = name
+        return
+
+    def __repr__(self):
+        return self.name
 
 
 ##  PSSymbolTable
@@ -69,19 +69,19 @@ class PSKeyword(PSObject):
 ##  referred to as the same PSLiteral/PSKeyword object.
 ##
 class PSSymbolTable(object):
-  
-  def __init__(self, klass):
-    self.dic = {}
-    self.klass = klass
-    return
-  
-  def intern(self, name):
-    if name in self.dic:
-      lit = self.dic[name]
-    else:
-      lit = self.klass(name)
-      self.dic[name] = lit
-    return lit
+
+    def __init__(self, klass):
+        self.dic = {}
+        self.klass = klass
+        return
+
+    def intern(self, name):
+        if name in self.dic:
+            lit = self.dic[name]
+        else:
+            lit = self.klass(name)
+            self.dic[name] = lit
+        return lit
 
 PSLiteralTable = PSSymbolTable(PSLiteral)
 PSKeywordTable = PSSymbolTable(PSKeyword)
@@ -96,20 +96,20 @@ KEYWORD_DICT_END = KWD('>>')
 
 
 def literal_name(x):
-  if not isinstance(x, PSLiteral):
-    if STRICT:
-      raise PSTypeError('Literal required: %r' % x)
-    else:
-      return str(x)
-  return x.name
+    if not isinstance(x, PSLiteral):
+        if STRICT:
+            raise PSTypeError('Literal required: %r' % x)
+        else:
+            return str(x)
+    return x.name
 
 def keyword_name(x):
-  if not isinstance(x, PSKeyword):
-    if STRICT:
-      raise PSTypeError('Keyword required: %r' % x)
-    else:
-      return str(x)
-  return x.name
+    if not isinstance(x, PSKeyword):
+        if STRICT:
+            raise PSTypeError('Keyword required: %r' % x)
+        else:
+            return str(x)
+    return x.name
 
 
 ##  PSBaseParser
@@ -128,419 +128,419 @@ OCT_STRING = re.compile(r'[0-7]')
 ESC_STRING = { 'b':8, 't':9, 'n':10, 'f':12, 'r':13, '(':40, ')':41, '\\':92 }
 class PSBaseParser(object):
 
-  '''
-  Most basic PostScript parser that performs only tokenization.
-  '''
-  BUFSIZ = 4096
-
-  debug = 0
-  
-  def __init__(self, fp):
-    self.fp = fp
-    self.seek(0)
-    return
-
-  def __repr__(self):
-    return '<PSBaseParser: %r, bufpos=%d>' % (self.fp, self.bufpos)
-
-  def flush(self):
-    return
-  
-  def close(self):
-    self.flush()
-    return
-  
-  def tell(self):
-    return self.bufpos+self.charpos
-
-  def poll(self, pos=None, n=80):
-    pos0 = self.fp.tell()
-    if not pos:
-      pos = self.bufpos+self.charpos
-    self.fp.seek(pos)
-    print >>stderr, 'poll(%d): %r' % (pos, self.fp.read(n))
-    self.fp.seek(pos0)
-    return
-
-  def seek(self, pos):
     '''
-    Seeks the parser to the given position.
+    Most basic PostScript parser that performs only tokenization.
     '''
-    if 2 <= self.debug:
-      print >>stderr, 'seek: %r' % pos
-    self.fp.seek(pos)
-    # reset the status for nextline()
-    self.bufpos = pos
-    self.buf = ''
-    self.charpos = 0
-    # reset the status for nexttoken()
-    self._parse1 = self._parse_main
-    self._curtoken = ''
-    self._curtokenpos = 0
-    self._tokens = []
-    return
+    BUFSIZ = 4096
 
-  def fillbuf(self):
-    if self.charpos < len(self.buf): return
-    # fetch next chunk.
-    self.bufpos = self.fp.tell()
-    self.buf = self.fp.read(self.BUFSIZ)
-    if not self.buf:
-      raise PSEOF('Unexpected EOF')
-    self.charpos = 0
-    return
-  
-  def nextline(self):
-    '''
-    Fetches a next line that ends either with \\r or \\n.
-    '''
-    linebuf = ''
-    linepos = self.bufpos + self.charpos
-    eol = False
-    while 1:
-      self.fillbuf()
-      if eol:
-        c = self.buf[self.charpos]
-        # handle '\r\n'
-        if c == '\n':
-          linebuf += c
-          self.charpos += 1
-        break
-      m = EOL.search(self.buf, self.charpos)
-      if m:
-        linebuf += self.buf[self.charpos:m.end(0)]
-        self.charpos = m.end(0)
-        if linebuf[-1] == '\r':
-          eol = True
-        else:
-          break
-      else:
-        linebuf += self.buf[self.charpos:]
-        self.charpos = len(self.buf)
-    if 2 <= self.debug:
-      print >>stderr, 'nextline: %r' % ((linepos, linebuf),)
-    return (linepos, linebuf)
+    debug = 0
 
-  def revreadlines(self):
-    '''
-    Fetches a next line backword. This is used to locate
-    the trailers at the end of a file.
-    '''
-    self.fp.seek(0, 2)
-    pos = self.fp.tell()
-    buf = ''
-    while 0 < pos:
-      pos = max(0, pos-self.BUFSIZ)
-      self.fp.seek(pos)
-      s = self.fp.read(self.BUFSIZ)
-      if not s: break
-      while 1:
-        n = max(s.rfind('\r'), s.rfind('\n'))
-        if n == -1:
-          buf = s + buf
-          break
-        yield buf+s[n:]
-        s = s[:n]
+    def __init__(self, fp):
+        self.fp = fp
+        self.seek(0)
+        return
+
+    def __repr__(self):
+        return '<PSBaseParser: %r, bufpos=%d>' % (self.fp, self.bufpos)
+
+    def flush(self):
+        return
+
+    def close(self):
+        self.flush()
+        return
+
+    def tell(self):
+        return self.bufpos+self.charpos
+
+    def poll(self, pos=None, n=80):
+        pos0 = self.fp.tell()
+        if not pos:
+            pos = self.bufpos+self.charpos
+        self.fp.seek(pos)
+        print >>stderr, 'poll(%d): %r' % (pos, self.fp.read(n))
+        self.fp.seek(pos0)
+        return
+
+    def seek(self, pos):
+        '''
+        Seeks the parser to the given position.
+        '''
+        if 2 <= self.debug:
+            print >>stderr, 'seek: %r' % pos
+        self.fp.seek(pos)
+        # reset the status for nextline()
+        self.bufpos = pos
+        self.buf = ''
+        self.charpos = 0
+        # reset the status for nexttoken()
+        self._parse1 = self._parse_main
+        self._curtoken = ''
+        self._curtokenpos = 0
+        self._tokens = []
+        return
+
+    def fillbuf(self):
+        if self.charpos < len(self.buf): return
+        # fetch next chunk.
+        self.bufpos = self.fp.tell()
+        self.buf = self.fp.read(self.BUFSIZ)
+        if not self.buf:
+            raise PSEOF('Unexpected EOF')
+        self.charpos = 0
+        return
+
+    def nextline(self):
+        '''
+        Fetches a next line that ends either with \\r or \\n.
+        '''
+        linebuf = ''
+        linepos = self.bufpos + self.charpos
+        eol = False
+        while 1:
+            self.fillbuf()
+            if eol:
+                c = self.buf[self.charpos]
+                # handle '\r\n'
+                if c == '\n':
+                    linebuf += c
+                    self.charpos += 1
+                break
+            m = EOL.search(self.buf, self.charpos)
+            if m:
+                linebuf += self.buf[self.charpos:m.end(0)]
+                self.charpos = m.end(0)
+                if linebuf[-1] == '\r':
+                    eol = True
+                else:
+                    break
+            else:
+                linebuf += self.buf[self.charpos:]
+                self.charpos = len(self.buf)
+        if 2 <= self.debug:
+            print >>stderr, 'nextline: %r' % ((linepos, linebuf),)
+        return (linepos, linebuf)
+
+    def revreadlines(self):
+        '''
+        Fetches a next line backword. This is used to locate
+        the trailers at the end of a file.
+        '''
+        self.fp.seek(0, 2)
+        pos = self.fp.tell()
         buf = ''
-    return
+        while 0 < pos:
+            pos = max(0, pos-self.BUFSIZ)
+            self.fp.seek(pos)
+            s = self.fp.read(self.BUFSIZ)
+            if not s: break
+            while 1:
+                n = max(s.rfind('\r'), s.rfind('\n'))
+                if n == -1:
+                    buf = s + buf
+                    break
+                yield buf+s[n:]
+                s = s[:n]
+                buf = ''
+        return
 
-  def _parse_main(self, s, i):
-    m = NONSPC.search(s, i)
-    if not m:
-      return (self._parse_main, len(s))
-    j = m.start(0)
-    c = s[j]
-    self._curtokenpos = self.bufpos+j
-    if c == '%':
-      self._curtoken = '%'
-      return (self._parse_comment, j+1)
-    elif c == '/':
-      self._curtoken = ''
-      return (self._parse_literal, j+1)
-    elif c in '-+' or c.isdigit():
-      self._curtoken = c
-      return (self._parse_number, j+1)
-    elif c == '.':
-      self._curtoken = c
-      return (self._parse_float, j+1)
-    elif c.isalpha():
-      self._curtoken = c
-      return (self._parse_keyword, j+1)
-    elif c == '(':
-      self._curtoken = ''
-      self.paren = 1
-      return (self._parse_string, j+1)
-    elif c == '<':
-      self._curtoken = ''
-      return (self._parse_wopen, j+1)
-    elif c == '>':
-      self._curtoken = ''
-      return (self._parse_wclose, j+1)
-    else:
-      self._add_token(KWD(c))
-      return (self._parse_main, j+1)
-              
-  def _add_token(self, obj):
-    self._tokens.append((self._curtokenpos, obj))
-    return
-  
-  def _parse_comment(self, s, i):
-    m = EOL.search(s, i)
-    if not m:
-      self._curtoken += s[i:]
-      return (self._parse_comment, len(s))
-    j = m.start(0)
-    self._curtoken += s[i:j]
-    # We ignore comments.
-    #self._tokens.append(self._curtoken)
-    return (self._parse_main, j)
-  
-  def _parse_literal(self, s, i):
-    m = END_LITERAL.search(s, i)
-    if not m:
-      self._curtoken += s[i:]
-      return (self._parse_literal, len(s))
-    j = m.start(0)
-    self._curtoken += s[i:j]
-    c = s[j]
-    if c == '#':
-      self.hex = ''
-      return (self._parse_literal_hex, j+1)
-    self._add_token(LIT(self._curtoken))
-    return (self._parse_main, j)
-  
-  def _parse_literal_hex(self, s, i):
-    c = s[i]
-    if HEX.match(c) and len(self.hex) < 2:
-      self.hex += c
-      return (self._parse_literal_hex, i+1)
-    if self.hex:
-      self._curtoken += chr(int(self.hex, 16))
-    return (self._parse_literal, i)
+    def _parse_main(self, s, i):
+        m = NONSPC.search(s, i)
+        if not m:
+            return (self._parse_main, len(s))
+        j = m.start(0)
+        c = s[j]
+        self._curtokenpos = self.bufpos+j
+        if c == '%':
+            self._curtoken = '%'
+            return (self._parse_comment, j+1)
+        elif c == '/':
+            self._curtoken = ''
+            return (self._parse_literal, j+1)
+        elif c in '-+' or c.isdigit():
+            self._curtoken = c
+            return (self._parse_number, j+1)
+        elif c == '.':
+            self._curtoken = c
+            return (self._parse_float, j+1)
+        elif c.isalpha():
+            self._curtoken = c
+            return (self._parse_keyword, j+1)
+        elif c == '(':
+            self._curtoken = ''
+            self.paren = 1
+            return (self._parse_string, j+1)
+        elif c == '<':
+            self._curtoken = ''
+            return (self._parse_wopen, j+1)
+        elif c == '>':
+            self._curtoken = ''
+            return (self._parse_wclose, j+1)
+        else:
+            self._add_token(KWD(c))
+            return (self._parse_main, j+1)
 
-  def _parse_number(self, s, i):
-    m = END_NUMBER.search(s, i)
-    if not m:
-      self._curtoken += s[i:]
-      return (self._parse_number, len(s))
-    j = m.start(0)
-    self._curtoken += s[i:j]
-    c = s[j]
-    if c == '.':
-      self._curtoken += c
-      return (self._parse_float, j+1)
-    try:
-      self._add_token(int(self._curtoken))
-    except ValueError:
-      pass
-    return (self._parse_main, j)
-  
-  def _parse_float(self, s, i):
-    m = END_NUMBER.search(s, i)
-    if not m:
-      self._curtoken += s[i:]
-      return (self._parse_float, len(s))
-    j = m.start(0)
-    self._curtoken += s[i:j]
-    self._add_token(float(self._curtoken))
-    return (self._parse_main, j)
-  
-  def _parse_keyword(self, s, i):
-    m = END_KEYWORD.search(s, i)
-    if not m:
-      self._curtoken += s[i:]
-      return (self._parse_keyword, len(s))
-    j = m.start(0)
-    self._curtoken += s[i:j]
-    if self._curtoken == 'true':
-      token = True
-    elif self._curtoken == 'false':
-      token = False
-    else:
-      token = KWD(self._curtoken)
-    self._add_token(token)
-    return (self._parse_main, j)
+    def _add_token(self, obj):
+        self._tokens.append((self._curtokenpos, obj))
+        return
 
-  def _parse_string(self, s, i):
-    m = END_STRING.search(s, i)
-    if not m:
-      self._curtoken += s[i:]
-      return (self._parse_string, len(s))
-    j = m.start(0)
-    self._curtoken += s[i:j]
-    c = s[j]
-    if c == '\\':
-      self.oct = ''
-      return (self._parse_string_1, j+1)
-    if c == '(':
-      self.paren += 1
-      self._curtoken += c
-      return (self._parse_string, j+1)
-    if c == ')':
-      self.paren -= 1
-      if self.paren: # WTF, they said balanced parens need no special treatment.
-        self._curtoken += c
-        return (self._parse_string, j+1)
-    self._add_token(self._curtoken)
-    return (self._parse_main, j+1)
-  
-  def _parse_string_1(self, s, i):
-    c = s[i]
-    if OCT_STRING.match(c) and len(self.oct) < 3:
-      self.oct += c
-      return (self._parse_string_1, i+1)
-    if self.oct:
-      self._curtoken += chr(int(self.oct, 8))
-      return (self._parse_string, i)
-    if c in ESC_STRING:
-      self._curtoken += chr(ESC_STRING[c])
-    return (self._parse_string, i+1)
+    def _parse_comment(self, s, i):
+        m = EOL.search(s, i)
+        if not m:
+            self._curtoken += s[i:]
+            return (self._parse_comment, len(s))
+        j = m.start(0)
+        self._curtoken += s[i:j]
+        # We ignore comments.
+        #self._tokens.append(self._curtoken)
+        return (self._parse_main, j)
 
-  def _parse_wopen(self, s, i):
-    c = s[i]
-    if c.isspace() or HEX.match(c):
-      return (self._parse_hexstring, i)
-    if c == '<':
-      self._add_token(KEYWORD_DICT_BEGIN)
-      i += 1
-    return (self._parse_main, i)
+    def _parse_literal(self, s, i):
+        m = END_LITERAL.search(s, i)
+        if not m:
+            self._curtoken += s[i:]
+            return (self._parse_literal, len(s))
+        j = m.start(0)
+        self._curtoken += s[i:j]
+        c = s[j]
+        if c == '#':
+            self.hex = ''
+            return (self._parse_literal_hex, j+1)
+        self._add_token(LIT(self._curtoken))
+        return (self._parse_main, j)
 
-  def _parse_wclose(self, s, i):
-    c = s[i]
-    if c == '>':
-      self._add_token(KEYWORD_DICT_END)
-      i += 1
-    return (self._parse_main, i)
+    def _parse_literal_hex(self, s, i):
+        c = s[i]
+        if HEX.match(c) and len(self.hex) < 2:
+            self.hex += c
+            return (self._parse_literal_hex, i+1)
+        if self.hex:
+            self._curtoken += chr(int(self.hex, 16))
+        return (self._parse_literal, i)
 
-  def _parse_hexstring(self, s, i):
-    m = END_HEX_STRING.search(s, i)
-    if not m:
-      self._curtoken += s[i:]
-      return (self._parse_hexstring, len(s))
-    j = m.start(0)
-    self._curtoken += s[i:j]
-    token = HEX_PAIR.sub(lambda m: chr(int(m.group(0), 16)),
-                         SPC.sub('', self._curtoken))
-    self._add_token(token)
-    return (self._parse_main, j)
+    def _parse_number(self, s, i):
+        m = END_NUMBER.search(s, i)
+        if not m:
+            self._curtoken += s[i:]
+            return (self._parse_number, len(s))
+        j = m.start(0)
+        self._curtoken += s[i:j]
+        c = s[j]
+        if c == '.':
+            self._curtoken += c
+            return (self._parse_float, j+1)
+        try:
+            self._add_token(int(self._curtoken))
+        except ValueError:
+            pass
+        return (self._parse_main, j)
 
-  def nexttoken(self):
-    while not self._tokens:
-      self.fillbuf()
-      (self._parse1, self.charpos) = self._parse1(self.buf, self.charpos)
-    token = self._tokens.pop(0)
-    if 2 <= self.debug:
-      print >>stderr, 'nexttoken: %r' % (token,)
-    return token
+    def _parse_float(self, s, i):
+        m = END_NUMBER.search(s, i)
+        if not m:
+            self._curtoken += s[i:]
+            return (self._parse_float, len(s))
+        j = m.start(0)
+        self._curtoken += s[i:j]
+        self._add_token(float(self._curtoken))
+        return (self._parse_main, j)
+
+    def _parse_keyword(self, s, i):
+        m = END_KEYWORD.search(s, i)
+        if not m:
+            self._curtoken += s[i:]
+            return (self._parse_keyword, len(s))
+        j = m.start(0)
+        self._curtoken += s[i:j]
+        if self._curtoken == 'true':
+            token = True
+        elif self._curtoken == 'false':
+            token = False
+        else:
+            token = KWD(self._curtoken)
+        self._add_token(token)
+        return (self._parse_main, j)
+
+    def _parse_string(self, s, i):
+        m = END_STRING.search(s, i)
+        if not m:
+            self._curtoken += s[i:]
+            return (self._parse_string, len(s))
+        j = m.start(0)
+        self._curtoken += s[i:j]
+        c = s[j]
+        if c == '\\':
+            self.oct = ''
+            return (self._parse_string_1, j+1)
+        if c == '(':
+            self.paren += 1
+            self._curtoken += c
+            return (self._parse_string, j+1)
+        if c == ')':
+            self.paren -= 1
+            if self.paren: # WTF, they said balanced parens need no special treatment.
+                self._curtoken += c
+                return (self._parse_string, j+1)
+        self._add_token(self._curtoken)
+        return (self._parse_main, j+1)
+
+    def _parse_string_1(self, s, i):
+        c = s[i]
+        if OCT_STRING.match(c) and len(self.oct) < 3:
+            self.oct += c
+            return (self._parse_string_1, i+1)
+        if self.oct:
+            self._curtoken += chr(int(self.oct, 8))
+            return (self._parse_string, i)
+        if c in ESC_STRING:
+            self._curtoken += chr(ESC_STRING[c])
+        return (self._parse_string, i+1)
+
+    def _parse_wopen(self, s, i):
+        c = s[i]
+        if c.isspace() or HEX.match(c):
+            return (self._parse_hexstring, i)
+        if c == '<':
+            self._add_token(KEYWORD_DICT_BEGIN)
+            i += 1
+        return (self._parse_main, i)
+
+    def _parse_wclose(self, s, i):
+        c = s[i]
+        if c == '>':
+            self._add_token(KEYWORD_DICT_END)
+            i += 1
+        return (self._parse_main, i)
+
+    def _parse_hexstring(self, s, i):
+        m = END_HEX_STRING.search(s, i)
+        if not m:
+            self._curtoken += s[i:]
+            return (self._parse_hexstring, len(s))
+        j = m.start(0)
+        self._curtoken += s[i:j]
+        token = HEX_PAIR.sub(lambda m: chr(int(m.group(0), 16)),
+                             SPC.sub('', self._curtoken))
+        self._add_token(token)
+        return (self._parse_main, j)
+
+    def nexttoken(self):
+        while not self._tokens:
+            self.fillbuf()
+            (self._parse1, self.charpos) = self._parse1(self.buf, self.charpos)
+        token = self._tokens.pop(0)
+        if 2 <= self.debug:
+            print >>stderr, 'nexttoken: %r' % (token,)
+        return token
 
 
 ##  PSStackParser
 ##
 class PSStackParser(PSBaseParser):
 
-  def __init__(self, fp):
-    PSBaseParser.__init__(self, fp)
-    self.reset()
-    return
-  
-  def reset(self):
-    self.context = []
-    self.curtype = None
-    self.curstack = []
-    self.results = []
-    return
+    def __init__(self, fp):
+        PSBaseParser.__init__(self, fp)
+        self.reset()
+        return
 
-  def seek(self, pos):
-    PSBaseParser.seek(self, pos)
-    self.reset()
-    return
+    def reset(self):
+        self.context = []
+        self.curtype = None
+        self.curstack = []
+        self.results = []
+        return
 
-  def push(self, *objs):
-    self.curstack.extend(objs)
-    return
-  def pop(self, n):
-    objs = self.curstack[-n:]
-    self.curstack[-n:] = []
-    return objs
-  def popall(self):
-    objs = self.curstack
-    self.curstack = []
-    return objs
-  def add_results(self, *objs):
-    if 2 <= self.debug:
-      print >>stderr, 'add_results: %r' % (objs,)
-    self.results.extend(objs)
-    return
+    def seek(self, pos):
+        PSBaseParser.seek(self, pos)
+        self.reset()
+        return
 
-  def start_type(self, pos, type):
-    self.context.append((pos, self.curtype, self.curstack))
-    (self.curtype, self.curstack) = (type, [])
-    if 2 <= self.debug:
-      print >>stderr, 'start_type: pos=%r, type=%r' % (pos, type)
-    return
-  def end_type(self, type):
-    if self.curtype != type:
-      raise PSTypeError('Type mismatch: %r != %r' % (self.curtype, type))
-    objs = [ obj for (_,obj) in self.curstack ]
-    (pos, self.curtype, self.curstack) = self.context.pop()
-    if 2 <= self.debug:
-      print >>stderr, 'end_type: pos=%r, type=%r, objs=%r' % (pos, type, objs)
-    return (pos, objs)
-
-  def do_keyword(self, pos, token):
-    return
-  
-  def nextobject(self):
-    '''
-    Yields a list of objects: keywords, literals, strings, 
-    numbers, arrays and dictionaries. Arrays and dictionaries
-    are represented as Python sequence and dictionaries.
-    '''
-    while not self.results:
-      (pos, token) = self.nexttoken()
-      #print (pos,token), (self.curtype, self.curstack)
-      if (isinstance(token, int) or
-          isinstance(token, float) or
-          isinstance(token, bool) or
-          isinstance(token, str) or
-          isinstance(token, PSLiteral)):
-        # normal token
-        self.push((pos, token))
-      elif token == KEYWORD_ARRAY_BEGIN:
-        # begin array
-        self.start_type(pos, 'a')
-      elif token == KEYWORD_ARRAY_END:
-        # end array
-        try:
-          self.push(self.end_type('a'))
-        except PSTypeError:
-          if STRICT: raise
-      elif token == KEYWORD_DICT_BEGIN:
-        # begin dictionary
-        self.start_type(pos, 'd')
-      elif token == KEYWORD_DICT_END:
-        # end dictionary
-        try:
-          (pos, objs) = self.end_type('d')
-          if len(objs) % 2 != 0:
-            raise PSSyntaxError('Invalid dictionary construct: %r' % objs)
-          d = dict( (literal_name(k), v) for (k,v) in choplist(2, objs))
-          self.push((pos, d))
-        except PSTypeError:
-          if STRICT: raise
-      else:
+    def push(self, *objs):
+        self.curstack.extend(objs)
+        return
+    def pop(self, n):
+        objs = self.curstack[-n:]
+        self.curstack[-n:] = []
+        return objs
+    def popall(self):
+        objs = self.curstack
+        self.curstack = []
+        return objs
+    def add_results(self, *objs):
         if 2 <= self.debug:
-          print >>stderr, 'do_keyword: pos=%r, token=%r, stack=%r' % \
-                (pos, token, self.curstack)
-        self.do_keyword(pos, token)
-      if self.context:
-        continue
-      else:
-        self.flush()
-    obj = self.results.pop(0)
-    if 2 <= self.debug:
-      print >>stderr, 'nextobject: %r' % (obj,)
-    return obj
+            print >>stderr, 'add_results: %r' % (objs,)
+        self.results.extend(objs)
+        return
+
+    def start_type(self, pos, type):
+        self.context.append((pos, self.curtype, self.curstack))
+        (self.curtype, self.curstack) = (type, [])
+        if 2 <= self.debug:
+            print >>stderr, 'start_type: pos=%r, type=%r' % (pos, type)
+        return
+    def end_type(self, type):
+        if self.curtype != type:
+            raise PSTypeError('Type mismatch: %r != %r' % (self.curtype, type))
+        objs = [ obj for (_,obj) in self.curstack ]
+        (pos, self.curtype, self.curstack) = self.context.pop()
+        if 2 <= self.debug:
+            print >>stderr, 'end_type: pos=%r, type=%r, objs=%r' % (pos, type, objs)
+        return (pos, objs)
+
+    def do_keyword(self, pos, token):
+        return
+
+    def nextobject(self):
+        '''
+        Yields a list of objects: keywords, literals, strings,
+        numbers, arrays and dictionaries. Arrays and dictionaries
+        are represented as Python sequence and dictionaries.
+        '''
+        while not self.results:
+            (pos, token) = self.nexttoken()
+            #print (pos,token), (self.curtype, self.curstack)
+            if (isinstance(token, int) or
+                isinstance(token, float) or
+                isinstance(token, bool) or
+                isinstance(token, str) or
+                isinstance(token, PSLiteral)):
+                # normal token
+                self.push((pos, token))
+            elif token == KEYWORD_ARRAY_BEGIN:
+                # begin array
+                self.start_type(pos, 'a')
+            elif token == KEYWORD_ARRAY_END:
+                # end array
+                try:
+                    self.push(self.end_type('a'))
+                except PSTypeError:
+                    if STRICT: raise
+            elif token == KEYWORD_DICT_BEGIN:
+                # begin dictionary
+                self.start_type(pos, 'd')
+            elif token == KEYWORD_DICT_END:
+                # end dictionary
+                try:
+                    (pos, objs) = self.end_type('d')
+                    if len(objs) % 2 != 0:
+                        raise PSSyntaxError('Invalid dictionary construct: %r' % objs)
+                    d = dict( (literal_name(k), v) for (k,v) in choplist(2, objs))
+                    self.push((pos, d))
+                except PSTypeError:
+                    if STRICT: raise
+            else:
+                if 2 <= self.debug:
+                    print >>stderr, 'do_keyword: pos=%r, token=%r, stack=%r' % \
+                          (pos, token, self.curstack)
+                self.do_keyword(pos, token)
+            if self.context:
+                continue
+            else:
+                self.flush()
+        obj = self.results.pop(0)
+        if 2 <= self.debug:
+            print >>stderr, 'nextobject: %r' % (obj,)
+        return obj
 
 
 ##  Simplistic Test cases
@@ -548,90 +548,90 @@ class PSStackParser(PSBaseParser):
 import unittest
 class TestPSBaseParser(unittest.TestCase):
 
-  TESTDATA = r'''%!PS
-begin end
- "  @ #
-/a/BCD /Some_Name /foo#5f#xbaa
-0 +1 -2 .5 1.234
-(abc) () (abc ( def ) ghi)
-(def\040\0\0404ghi) (bach\\slask) (foo\nbaa)
-(this % is not a comment.)
-(foo
-baa)
-(foo\
-baa)
-<20> < 40 4020 >
-<abcd00
-12345>
-func/a/b{(c)do*}def
-[ 1 (z) ! ]
-<< /foo (bar) >>
-'''
-  
-  TOKENS = [
-    (5, KWD('begin')), (11, KWD('end')), (16, KWD('"')), (19, KWD('@')),
-    (21, KWD('#')), (23, LIT('a')), (25, LIT('BCD')), (30, LIT('Some_Name')),
-    (41, LIT('foo_xbaa')), (54, 0), (56, 1), (59, -2), (62, 0.5),
-    (65, 1.234), (71, 'abc'), (77, ''), (80, 'abc ( def ) ghi'),
-    (98, 'def \x00 4ghi'), (118, 'bach\\slask'), (132, 'foo\nbaa'),
-    (143, 'this % is not a comment.'), (170, 'foo\nbaa'), (180, 'foobaa'),
-    (191, ' '), (196, '@@ '), (208, '\xab\xcd\x00\x124\x05'),
-    (223, KWD('func')), (227, LIT('a')), (229, LIT('b')),
-    (231, KWD('{')), (232, 'c'), (235, KWD('do*')), (238, KWD('}')),
-    (239, KWD('def')), (243, KWD('[')), (245, 1), (247, 'z'), (251, KWD('!')),
-    (253, KWD(']')), (255, KWD('<<')), (258, LIT('foo')), (263, 'bar'),
-    (269, KWD('>>'))
-    ]
-  
-  OBJS = [
-    (23, LIT('a')), (25, LIT('BCD')), (30, LIT('Some_Name')),
-    (41, LIT('foo_xbaa')), (54, 0), (56, 1), (59, -2), (62, 0.5),
-    (65, 1.234), (71, 'abc'), (77, ''), (80, 'abc ( def ) ghi'),
-    (98, 'def \x00 4ghi'), (118, 'bach\\slask'), (132, 'foo\nbaa'),
-    (143, 'this % is not a comment.'), (170, 'foo\nbaa'), (180, 'foobaa'),
-    (191, ' '), (196, '@@ '), (208, '\xab\xcd\x00\x124\x05'),
-    (227, LIT('a')), (229, LIT('b')), (232, 'c'), (243, [1, 'z']),
-    (255, {'foo': 'bar'}),
-    ]
-  
-  def get_tokens(self, s):
-    import StringIO
-    class MyParser(PSBaseParser):
-      def flush(self):
-        self.add_results(*self.popall())
-    parser = MyParser(StringIO.StringIO(s))
-    r = []
-    try:
-      while 1:
-        r.append(parser.nexttoken())
-    except PSEOF:
-      pass
-    return r
-  
-  def get_objects(self, s):
-    import StringIO
-    class MyParser(PSStackParser):
-      def flush(self):
-        self.add_results(*self.popall())
-    parser = MyParser(StringIO.StringIO(s))
-    r = []
-    try:
-      while 1:
-        r.append(parser.nextobject())
-    except PSEOF:
-      pass
-    return r
-  
-  def test_1(self):
-    tokens = self.get_tokens(self.TESTDATA)
-    print tokens
-    self.assertEqual(tokens, self.TOKENS)
-    return
+    TESTDATA = r'''%!PS
+  begin end
+   "  @ #
+  /a/BCD /Some_Name /foo#5f#xbaa
+  0 +1 -2 .5 1.234
+  (abc) () (abc ( def ) ghi)
+  (def\040\0\0404ghi) (bach\\slask) (foo\nbaa)
+  (this % is not a comment.)
+  (foo
+  baa)
+  (foo\
+  baa)
+  <20> < 40 4020 >
+  <abcd00
+  12345>
+  func/a/b{(c)do*}def
+  [ 1 (z) ! ]
+  << /foo (bar) >>
+  '''
+
+    TOKENS = [
+      (5, KWD('begin')), (11, KWD('end')), (16, KWD('"')), (19, KWD('@')),
+      (21, KWD('#')), (23, LIT('a')), (25, LIT('BCD')), (30, LIT('Some_Name')),
+      (41, LIT('foo_xbaa')), (54, 0), (56, 1), (59, -2), (62, 0.5),
+      (65, 1.234), (71, 'abc'), (77, ''), (80, 'abc ( def ) ghi'),
+      (98, 'def \x00 4ghi'), (118, 'bach\\slask'), (132, 'foo\nbaa'),
+      (143, 'this % is not a comment.'), (170, 'foo\nbaa'), (180, 'foobaa'),
+      (191, ' '), (196, '@@ '), (208, '\xab\xcd\x00\x124\x05'),
+      (223, KWD('func')), (227, LIT('a')), (229, LIT('b')),
+      (231, KWD('{')), (232, 'c'), (235, KWD('do*')), (238, KWD('}')),
+      (239, KWD('def')), (243, KWD('[')), (245, 1), (247, 'z'), (251, KWD('!')),
+      (253, KWD(']')), (255, KWD('<<')), (258, LIT('foo')), (263, 'bar'),
+      (269, KWD('>>'))
+      ]
+
+    OBJS = [
+      (23, LIT('a')), (25, LIT('BCD')), (30, LIT('Some_Name')),
+      (41, LIT('foo_xbaa')), (54, 0), (56, 1), (59, -2), (62, 0.5),
+      (65, 1.234), (71, 'abc'), (77, ''), (80, 'abc ( def ) ghi'),
+      (98, 'def \x00 4ghi'), (118, 'bach\\slask'), (132, 'foo\nbaa'),
+      (143, 'this % is not a comment.'), (170, 'foo\nbaa'), (180, 'foobaa'),
+      (191, ' '), (196, '@@ '), (208, '\xab\xcd\x00\x124\x05'),
+      (227, LIT('a')), (229, LIT('b')), (232, 'c'), (243, [1, 'z']),
+      (255, {'foo': 'bar'}),
+      ]
+
+    def get_tokens(self, s):
+        import StringIO
+        class MyParser(PSBaseParser):
+            def flush(self):
+                self.add_results(*self.popall())
+        parser = MyParser(StringIO.StringIO(s))
+        r = []
+        try:
+            while 1:
+                r.append(parser.nexttoken())
+        except PSEOF:
+            pass
+        return r
+
+    def get_objects(self, s):
+        import StringIO
+        class MyParser(PSStackParser):
+            def flush(self):
+                self.add_results(*self.popall())
+        parser = MyParser(StringIO.StringIO(s))
+        r = []
+        try:
+            while 1:
+                r.append(parser.nextobject())
+        except PSEOF:
+            pass
+        return r
+
+    def test_1(self):
+        tokens = self.get_tokens(self.TESTDATA)
+        print tokens
+        self.assertEqual(tokens, self.TOKENS)
+        return
+
+    def test_2(self):
+        objs = self.get_objects(self.TESTDATA)
+        print objs
+        self.assertEqual(objs, self.OBJS)
+        return
 
-  def test_2(self):
-    objs = self.get_objects(self.TESTDATA)
-    print objs
-    self.assertEqual(objs, self.OBJS)
-    return
-    
 if __name__ == '__main__': unittest.main()
diff --git a/pdfminer/pycdb.py b/pdfminer/pycdb.py
index 71bf664..eec4dbf 100755
--- a/pdfminer/pycdb.py
+++ b/pdfminer/pycdb.py
@@ -4,7 +4,7 @@
 #
 #   by Yusuke Shinyama
 #   * public domain *
-# 
+#
 
 import sys, os
 from struct import pack, unpack
@@ -13,24 +13,24 @@ from array import array
 
 # calc hash value with a given key
 def cdbhash(s, n=5381L):
-  return reduce(lambda h,c: ((h*33) ^ ord(c)) & 0xffffffffL, s, n)
+    return reduce(lambda h,c: ((h*33) ^ ord(c)) & 0xffffffffL, s, n)
 
 if pack('=i',1) == pack('>i',1):
-  # big endian
-  def decode(x):
-    a = array('I', x)
-    a.byteswap()
-    return a
-  def encode(a):
-    a.byteswap()
-    return a.tostring()
+    # big endian
+    def decode(x):
+        a = array('I', x)
+        a.byteswap()
+        return a
+    def encode(a):
+        a.byteswap()
+        return a.tostring()
 else:
-  # little endian
-  def decode(x):
-    a = array('I', x)
-    return a
-  def encode(a):
-    return a.tostring()
+    # little endian
+    def decode(x):
+        a = array('I', x)
+        return a
+    def encode(a):
+        return a.tostring()
 
 
 ##  CDB
@@ -38,234 +38,234 @@ else:
 
 # cdbiter
 def cdbiter(fp, eod):
-  kloc = 2048
-  while kloc < eod:
-    fp.seek(kloc)
-    (klen, vlen) = unpack('<II', fp.read(8))
-    k = fp.read(klen)
-    v = fp.read(vlen)
-    kloc += 8+klen+vlen
-    yield (k,v)
-  fp.close()
-  return
+    kloc = 2048
+    while kloc < eod:
+        fp.seek(kloc)
+        (klen, vlen) = unpack('<II', fp.read(8))
+        k = fp.read(klen)
+        v = fp.read(vlen)
+        kloc += 8+klen+vlen
+        yield (k,v)
+    fp.close()
+    return
 
 
 # CDBReader
 class CDBReader(object):
-  
-  def __init__(self, cdbname, docache=1):
-    self.name = cdbname
-    self._fp = file(cdbname, 'rb')
-    hash0 = decode(self._fp.read(2048))
-    self._hash0 = [ (hash0[i], hash0[i+1]) for i in xrange(0, 512, 2) ]
-    self._hash1 = [ None ] * 256
-    self._eod = hash0[0]
-    self._docache = docache
-    self._cache = {}
-    self._keyiter = None
-    self._eachiter = None
-    return
 
-  def __repr__(self):
-    return '<CDBReader: %r>' % self.name
+    def __init__(self, cdbname, docache=1):
+        self.name = cdbname
+        self._fp = file(cdbname, 'rb')
+        hash0 = decode(self._fp.read(2048))
+        self._hash0 = [ (hash0[i], hash0[i+1]) for i in xrange(0, 512, 2) ]
+        self._hash1 = [ None ] * 256
+        self._eod = hash0[0]
+        self._docache = docache
+        self._cache = {}
+        self._keyiter = None
+        self._eachiter = None
+        return
 
-  def __getstate__(self):
-    raise TypeError
+    def __repr__(self):
+        return '<CDBReader: %r>' % self.name
 
-  def __setstate__(self, dict):
-    raise TypeError
+    def __getstate__(self):
+        raise TypeError
 
-  def __getitem__(self, k):
-    k = str(k)
-    if k in self._cache: return self._cache[k]
-    h = cdbhash(k)
-    h1 = h & 0xff
-    (pos_bucket, ncells) = self._hash0[h1]
-    if ncells == 0: raise KeyError(k)
-    hs = self._hash1[h1]
-    if hs == None:
-      self._fp.seek(pos_bucket)
-      hs = decode(self._fp.read(ncells * 8))
-      self._hash1[h1] = hs
-    i = ((h >> 8) % ncells) * 2
-    n = ncells*2
-    for _ in xrange(ncells):
-      p1 = hs[i+1]
-      if p1 == 0: raise KeyError(k)
-      if hs[i] == h:
-        self._fp.seek(p1)
-        (klen, vlen) = unpack('<II', self._fp.read(8))
-        k1 = self._fp.read(klen)
-        if k1 == k:
-          v1 = self._fp.read(vlen)
-          if self._docache:
-            self._cache[k] = v1
-          return v1
-      i = (i+2) % n
-    raise KeyError(k)
+    def __setstate__(self, dict):
+        raise TypeError
 
-  def get(self, k, failed=None):
-    try:
-      return self.__getitem__(k)
-    except KeyError:
-      return failed
+    def __getitem__(self, k):
+        k = str(k)
+        if k in self._cache: return self._cache[k]
+        h = cdbhash(k)
+        h1 = h & 0xff
+        (pos_bucket, ncells) = self._hash0[h1]
+        if ncells == 0: raise KeyError(k)
+        hs = self._hash1[h1]
+        if hs == None:
+            self._fp.seek(pos_bucket)
+            hs = decode(self._fp.read(ncells * 8))
+            self._hash1[h1] = hs
+        i = ((h >> 8) % ncells) * 2
+        n = ncells*2
+        for _ in xrange(ncells):
+            p1 = hs[i+1]
+            if p1 == 0: raise KeyError(k)
+            if hs[i] == h:
+                self._fp.seek(p1)
+                (klen, vlen) = unpack('<II', self._fp.read(8))
+                k1 = self._fp.read(klen)
+                if k1 == k:
+                    v1 = self._fp.read(vlen)
+                    if self._docache:
+                        self._cache[k] = v1
+                    return v1
+            i = (i+2) % n
+        raise KeyError(k)
 
-  def has_key(self, k):
-    try:
-      self.__getitem__(k)
-      return True
-    except KeyError:
-      return False
+    def get(self, k, failed=None):
+        try:
+            return self.__getitem__(k)
+        except KeyError:
+            return failed
 
-  def __contains__(self, k):
-    return self.has_key(k)
+    def has_key(self, k):
+        try:
+            self.__getitem__(k)
+            return True
+        except KeyError:
+            return False
 
-  def firstkey(self):
-    self._keyiter = None
-    return self.nextkey()
-  
-  def nextkey(self):
-    if not self._keyiter:
-      self._keyiter = ( k for (k,v) in cdbiter(self._fp, self._eod) )
-    try:
-      return self._keyiter.next()
-    except StopIteration:
-      return None
+    def __contains__(self, k):
+        return self.has_key(k)
 
-  def each(self):
-    if not self._eachiter:
-      self._eachiter = cdbiter(self._fp, self._eod)
-    try:
-      return self._eachiter.next()
-    except StopIteration:
-      return None
-  
-  def iterkeys(self):
-    return ( k for (k,v) in cdbiter(self._fp, self._eod) )
-  def itervalues(self):
-    return ( v for (k,v) in cdbiter(self._fp, self._eod) )
-  def iteritems(self):
-    return cdbiter(self._fp, self._eod)
+    def firstkey(self):
+        self._keyiter = None
+        return self.nextkey()
+
+    def nextkey(self):
+        if not self._keyiter:
+            self._keyiter = ( k for (k,v) in cdbiter(self._fp, self._eod) )
+        try:
+            return self._keyiter.next()
+        except StopIteration:
+            return None
+
+    def each(self):
+        if not self._eachiter:
+            self._eachiter = cdbiter(self._fp, self._eod)
+        try:
+            return self._eachiter.next()
+        except StopIteration:
+            return None
+
+    def iterkeys(self):
+        return ( k for (k,v) in cdbiter(self._fp, self._eod) )
+    def itervalues(self):
+        return ( v for (k,v) in cdbiter(self._fp, self._eod) )
+    def iteritems(self):
+        return cdbiter(self._fp, self._eod)
 
 
 # CDBMaker
 class CDBMaker(object):
 
-  def __init__(self, cdbname, tmpname):
-    self.fn = cdbname
-    self.fntmp = tmpname
-    self.numentries = 0
-    self._fp = file(tmpname, 'wb')
-    self._pos = 2048                    # sizeof((h,p))*256
-    self._bucket = [ array('I') for _ in xrange(256) ]
-    return
+    def __init__(self, cdbname, tmpname):
+        self.fn = cdbname
+        self.fntmp = tmpname
+        self.numentries = 0
+        self._fp = file(tmpname, 'wb')
+        self._pos = 2048                    # sizeof((h,p))*256
+        self._bucket = [ array('I') for _ in xrange(256) ]
+        return
 
-  def __repr__(self):
-    return '<CDBMaker: %r, %r, %d ents>' % (self.fn, self.fntmp, self.numentries)
+    def __repr__(self):
+        return '<CDBMaker: %r, %r, %d ents>' % (self.fn, self.fntmp, self.numentries)
 
-  def __len__(self):
-    return self.numentries
+    def __len__(self):
+        return self.numentries
 
-  def __getstate__(self):
-    raise TypeError
+    def __getstate__(self):
+        raise TypeError
 
-  def __setstate__(self, dict):
-    raise TypeError
+    def __setstate__(self, dict):
+        raise TypeError
 
-  def add(self, k, v):
-    (k, v) = (str(k), str(v))
-    (klen, vlen) = (len(k), len(v))
-    self._fp.seek(self._pos)
-    self._fp.write(pack('<II', klen, vlen))
-    self._fp.write(k)
-    self._fp.write(v)
-    h = cdbhash(k)
-    b = self._bucket[h % 256]
-    b.append(h)
-    b.append(self._pos)
-    # sizeof(keylen)+sizeof(datalen)+sizeof(key)+sizeof(data)
-    self._pos += 8+klen+vlen
-    self.numentries += 1
-    return self
-  
-  def finish(self):
-    self._fp.seek(self._pos)
-    pos_hash = self._pos
-    # write hashes
-    for b1 in self._bucket:
-      if not b1: continue
-      blen = len(b1)
-      a = array('I', [0]*blen*2)
-      for j in xrange(0, blen, 2):
-        (h,p) = (b1[j],b1[j+1])
-        i = ((h >> 8) % blen)*2
-        while a[i+1]:             # is cell[i] already occupied?
-          i = (i+2) % len(a)
-        a[i] = h
-        a[i+1] = p
-      self._fp.write(encode(a))
-    # write header
-    self._fp.seek(0)
-    a = array('I')
-    for b1 in self._bucket:
-      a.append(pos_hash)
-      a.append(len(b1))
-      pos_hash += len(b1)*8
-    self._fp.write(encode(a))
-    # close
-    self._fp.close()
-    os.rename(self.fntmp, self.fn)
-    return
+    def add(self, k, v):
+        (k, v) = (str(k), str(v))
+        (klen, vlen) = (len(k), len(v))
+        self._fp.seek(self._pos)
+        self._fp.write(pack('<II', klen, vlen))
+        self._fp.write(k)
+        self._fp.write(v)
+        h = cdbhash(k)
+        b = self._bucket[h % 256]
+        b.append(h)
+        b.append(self._pos)
+        # sizeof(keylen)+sizeof(datalen)+sizeof(key)+sizeof(data)
+        self._pos += 8+klen+vlen
+        self.numentries += 1
+        return self
 
-  # txt2cdb
-  def txt2cdb(self, lines):
-    import re
-    HEAD = re.compile(r'^\+(\d+),(\d+):')
-    for line in lines:
-      m = HEAD.match(line)
-      if not m: break
-      (klen, vlen) = (int(m.group(1)), int(m.group(2)))
-      i = len(m.group(0))
-      k = line[i:i+klen]
-      i += klen
-      if line[i:i+2] != '->': raise ValueError('invalid separator: %r' % line)
-      i += 2
-      v = line[i:i+vlen]
-      self.add(k, v)
-    return self
+    def finish(self):
+        self._fp.seek(self._pos)
+        pos_hash = self._pos
+        # write hashes
+        for b1 in self._bucket:
+            if not b1: continue
+            blen = len(b1)
+            a = array('I', [0]*blen*2)
+            for j in xrange(0, blen, 2):
+                (h,p) = (b1[j],b1[j+1])
+                i = ((h >> 8) % blen)*2
+                while a[i+1]:             # is cell[i] already occupied?
+                    i = (i+2) % len(a)
+                a[i] = h
+                a[i+1] = p
+            self._fp.write(encode(a))
+        # write header
+        self._fp.seek(0)
+        a = array('I')
+        for b1 in self._bucket:
+            a.append(pos_hash)
+            a.append(len(b1))
+            pos_hash += len(b1)*8
+        self._fp.write(encode(a))
+        # close
+        self._fp.close()
+        os.rename(self.fntmp, self.fn)
+        return
+
+    # txt2cdb
+    def txt2cdb(self, lines):
+        import re
+        HEAD = re.compile(r'^\+(\d+),(\d+):')
+        for line in lines:
+            m = HEAD.match(line)
+            if not m: break
+            (klen, vlen) = (int(m.group(1)), int(m.group(2)))
+            i = len(m.group(0))
+            k = line[i:i+klen]
+            i += klen
+            if line[i:i+2] != '->': raise ValueError('invalid separator: %r' % line)
+            i += 2
+            v = line[i:i+vlen]
+            self.add(k, v)
+        return self
 
 
 # cdbdump
 def cdbdump(cdbname):
-  fp = file(cdbname, 'rb')
-  (eor,) = unpack('<I', fp.read(4))
-  return cdbiter(fp, eor)
+    fp = file(cdbname, 'rb')
+    (eor,) = unpack('<I', fp.read(4))
+    return cdbiter(fp, eor)
 
 
 # cdbmerge
 def cdbmerge(iters):
-  q = []
-  for it in iters:
-    try:
-      q.append((it.next(),it))
-    except StopIteration:
-      pass
-  k0 = None
-  vs = None
-  while q:
-    q.sort()
-    ((k,v),it) = q.pop(0)
-    if k0 != k:
-      if vs: yield (k0,vs)
-      vs = []
-    vs.append(v)
-    k0 = k
-    try:
-      q.append((it.next(),it))
-    except StopIteration:
-      continue
-  if vs: yield (k0,vs)
-  return
+    q = []
+    for it in iters:
+        try:
+            q.append((it.next(),it))
+        except StopIteration:
+            pass
+    k0 = None
+    vs = None
+    while q:
+        q.sort()
+        ((k,v),it) = q.pop(0)
+        if k0 != k:
+            if vs: yield (k0,vs)
+            vs = []
+        vs.append(v)
+        k0 = k
+        try:
+            q.append((it.next(),it))
+        except StopIteration:
+            continue
+    if vs: yield (k0,vs)
+    return
 
 
 # aliases
@@ -278,132 +278,132 @@ init = CDBReader
 
 # tcdbiter
 def tcdbiter(fp, eor):
-  locs = {}
-  fp.seek(eor)
-  while 1:
-    x = fp.read(8)
-    if not x: break
-    (h, pos) = unpack('<II', x)
-    if pos: locs[pos] = h
-  pos = 2048
-  fp.seek(pos)
-  key = ()
-  parents = [0]
-  while pos < eor:
-    (klen, vlen) = unpack('<II', fp.read(8))
-    k = fp.read(klen)
-    v = fp.read(vlen)
-    h = locs[pos]
-    for (i,p) in enumerate(parents):
-      if cdbhash(k, p+5381L) == h:
-        parents = parents[:i+1]
-        key = key[:i]
-        break
-    key += (k,)
-    yield (key, v)
-    parents.append(pos)
-    pos += 8+klen+vlen
-  fp.close()
-  return
+    locs = {}
+    fp.seek(eor)
+    while 1:
+        x = fp.read(8)
+        if not x: break
+        (h, pos) = unpack('<II', x)
+        if pos: locs[pos] = h
+    pos = 2048
+    fp.seek(pos)
+    key = ()
+    parents = [0]
+    while pos < eor:
+        (klen, vlen) = unpack('<II', fp.read(8))
+        k = fp.read(klen)
+        v = fp.read(vlen)
+        h = locs[pos]
+        for (i,p) in enumerate(parents):
+            if cdbhash(k, p+5381L) == h:
+                parents = parents[:i+1]
+                key = key[:i]
+                break
+        key += (k,)
+        yield (key, v)
+        parents.append(pos)
+        pos += 8+klen+vlen
+    fp.close()
+    return
 
 
 # TCDBMaker
 class TCDBMaker(CDBMaker):
 
-  def __init__(self, cdbname, tmpname):
-    CDBMaker.__init__(self, cdbname, tmpname)
-    self._parent = 0
-    self._stack = [self._parent]
-    return
+    def __init__(self, cdbname, tmpname):
+        CDBMaker.__init__(self, cdbname, tmpname)
+        self._parent = 0
+        self._stack = [self._parent]
+        return
 
-  def put(self, depth, k, v):
-    if depth == len(self._stack)+1:
-      self._stack.append(self._parent)
-    elif depth < len(self._stack):
-      self._stack = self._stack[:depth]
-    elif depth != len(self._stack):
-      raise ValueError('invalid depth: %d' % depth)
-    #
-    (k, v) = (str(k), str(v))
-    (klen, vlen) = (len(k), len(v))
-    self._parent = self._pos
-    # sizeof(keylen)+sizeof(datalen)+sizeof(key)+sizeof(data)
-    self._fp.seek(self._pos)
-    self._fp.write(pack('<II', klen, vlen))
-    self._fp.write(k)
-    self._fp.write(v)
-    self._pos += 4+4+klen+vlen
-    h = cdbhash(k, self._stack[-1]+5381L)
-    b = self._bucket[h % 256]
-    b.append(h)
-    b.append(self._parent)
-    self.numentries += 1
-    return self
+    def put(self, depth, k, v):
+        if depth == len(self._stack)+1:
+            self._stack.append(self._parent)
+        elif depth < len(self._stack):
+            self._stack = self._stack[:depth]
+        elif depth != len(self._stack):
+            raise ValueError('invalid depth: %d' % depth)
+        #
+        (k, v) = (str(k), str(v))
+        (klen, vlen) = (len(k), len(v))
+        self._parent = self._pos
+        # sizeof(keylen)+sizeof(datalen)+sizeof(key)+sizeof(data)
+        self._fp.seek(self._pos)
+        self._fp.write(pack('<II', klen, vlen))
+        self._fp.write(k)
+        self._fp.write(v)
+        self._pos += 4+4+klen+vlen
+        h = cdbhash(k, self._stack[-1]+5381L)
+        b = self._bucket[h % 256]
+        b.append(h)
+        b.append(self._parent)
+        self.numentries += 1
+        return self
 
-  def txt2tcdb(self, lines):
-    import re
-    HEAD = re.compile(r'^(\++)(\d+),(\d+):')
-    for line in lines:
-      m = HEAD.match(line)
-      if not m: break
-      (depth, klen, vlen) = (len(m.group(1)), int(m.group(2)), int(m.group(3)))
-      i = len(m.group(0))
-      k = line[i:i+klen]
-      i += klen
-      if line[i:i+2] != '->': raise ValueError('invalid separator: %r' % line)
-      i += 2
-      v = line[i:i+vlen]
-      self.put(depth, k, v)
-    return self
+    def txt2tcdb(self, lines):
+        import re
+        HEAD = re.compile(r'^(\++)(\d+),(\d+):')
+        for line in lines:
+            m = HEAD.match(line)
+            if not m: break
+            (depth, klen, vlen) = (len(m.group(1)), int(m.group(2)), int(m.group(3)))
+            i = len(m.group(0))
+            k = line[i:i+klen]
+            i += klen
+            if line[i:i+2] != '->': raise ValueError('invalid separator: %r' % line)
+            i += 2
+            v = line[i:i+vlen]
+            self.put(depth, k, v)
+        return self
 
 
 # TCDBReader
 class TCDBReader(CDBReader):
 
-  def lookup(self, seq, parent=0L):
-    r = []
-    for k in seq:
-      (v, parent) = self.lookup1(k, parent)
-      r.append(v)
-    return r
+    def lookup(self, seq, parent=0L):
+        r = []
+        for k in seq:
+            (v, parent) = self.lookup1(k, parent)
+            r.append(v)
+        return r
 
-  def lookup1(self, k, parent=0L):
-    k = str(k)
-    if self._docache and (parent,k) in self._cache:
-      return self._cache[(parent,k)]
-    h = cdbhash(k, parent+5381L)
-    self._fp.seek((h % 256) << 3)
-    (pos_bucket, ncells) = unpack('<II', self._fp.read(8))
-    if ncells == 0: raise KeyError(k)
-    start = (h >> 8) % ncells
-    for i in xrange(ncells):
-      self._fp.seek(pos_bucket + ((start+i) % ncells << 3))
-      (h1, p1) = unpack('<II', self._fp.read(8))
-      if p1 == 0: raise KeyError(k)
-      if h1 == h:
-        self._fp.seek(p1)
-        (klen, vlen) = unpack('<II', self._fp.read(8))
-        k1 = self._fp.read(klen)
-        if k1 == k:
-          v1 = self._fp.read(vlen)
-          if self._docache:
-            self._cache[(parent,k)] = (v1,p1)
-          return (v1,p1)
-    raise KeyError(k)
+    def lookup1(self, k, parent=0L):
+        k = str(k)
+        if self._docache and (parent,k) in self._cache:
+            return self._cache[(parent,k)]
+        h = cdbhash(k, parent+5381L)
+        self._fp.seek((h % 256) << 3)
+        (pos_bucket, ncells) = unpack('<II', self._fp.read(8))
+        if ncells == 0: raise KeyError(k)
+        start = (h >> 8) % ncells
+        for i in xrange(ncells):
+            self._fp.seek(pos_bucket + ((start+i) % ncells << 3))
+            (h1, p1) = unpack('<II', self._fp.read(8))
+            if p1 == 0: raise KeyError(k)
+            if h1 == h:
+                self._fp.seek(p1)
+                (klen, vlen) = unpack('<II', self._fp.read(8))
+                k1 = self._fp.read(klen)
+                if k1 == k:
+                    v1 = self._fp.read(vlen)
+                    if self._docache:
+                        self._cache[(parent,k)] = (v1,p1)
+                    return (v1,p1)
+        raise KeyError(k)
 
-  def iterkeys(self):
-    return ( k for (k,v) in tcdbiter(self._fp, self._eod) )
-  def itervalues(self):
-    return ( v for (k,v) in tcdbiter(self._fp, self._eod) )
-  def iteritems(self):
-    return tcdbiter(self._fp, self._eod)
+    def iterkeys(self):
+        return ( k for (k,v) in tcdbiter(self._fp, self._eod) )
+    def itervalues(self):
+        return ( v for (k,v) in tcdbiter(self._fp, self._eod) )
+    def iteritems(self):
+        return tcdbiter(self._fp, self._eod)
 
 
 # tcdbdump
 def tcdbdump(cdbname):
-  fp = file(cdbname, 'rb')
-  (eor,) = unpack('<I', fp.read(4))
-  return tcdbiter(fp, eor)
+    fp = file(cdbname, 'rb')
+    (eor,) = unpack('<I', fp.read(4))
+    return tcdbiter(fp, eor)
 
 
 # aliases
@@ -414,64 +414,64 @@ tcdbmerge = cdbmerge
 
 # main
 def main(argv):
-  import getopt, fileinput
-  def usage():
-    print 'usage: %s {cmake,cget,cdump,cmerge} [options] cdbname [args ...]' % argv[0]
-    print 'usage: %s {tmake,tget,tdump,tmerge} [options] tcdbname [args ...]' % argv[0]
-    return 100
-  args = argv[1:]
-  if not args: return usage()
-  cmd = args.pop(0)
-  try:
-    (opts, args) = getopt.getopt(args, 'kv2')
-  except getopt.GetoptError:
-    return usage()
-  if not args: return usage()
-  dbname = args.pop(0)
-  
-  # cdb
-  if cmd == 'cmake':
-    CDBMaker(dbname, dbname+'.tmp').txt2cdb(fileinput.input(args)).finish()
-  elif cmd == 'cget':
-    print repr(CDBReader(dbname).get(args[0]))
-  elif cmd == 'cdump':
-    f = (lambda k,v: '+%d,%d:%s->%s' % (len(k), len(v), k, v))
-    for (k, v) in opts:
-      if k == '-k': f = (lambda k,_: k)
-      elif k == '-v': f = (lambda _,v: v)
-      elif k == '-2': f = (lambda k,v: k+'\t'+v)
-    for (k,v) in cdbdump(dbname):
-      print f(k,v)
-    print
-  elif cmd == 'cmerge':
-    dbs = [ cdbdump(fname) for fname in args ]
-    m = CDBMaker(dbname, dbname+'.tmp')
-    for (k,vs) in tcdbmerge(dbs):
-      m.add(k, ' '.join(vs))
-    m.finish()
-  # tcdb
-  elif cmd == 'tmake':
-    TCDBMaker(dbname, dbname+'.tmp').txt2tcdb(fileinput.input(args)).finish()
-  elif cmd == 'tget':
-    print repr(TCDBReader(dbname).lookup(args))
-  elif cmd == 'tdump':
-    f = (lambda k,v: '%s%d,%d:%s->%s' % ('+'*len(k), len(k[-1]), len(v), k[-1], v))
-    for (k, v) in opts:
-      if k == '-k': f = (lambda k,_: '/'.join(k))
-      elif k == '-v': f = (lambda _,v: v)
-      elif k == '-2': f = (lambda k,v: '/'.join(k)+'\t'+v)
-    for (k,v) in tcdbdump(dbname):
-      print f(k,v)
-    print
-  elif cmd == 'tmerge':
-    dbs = [ tcdbdump(fname) for fname in args ]
-    m = TCDBMaker(dbname, dbname+'.tmp')
-    for (k,vs) in tcdbmerge(dbs):
-      m.put(len(k), k[-1], ' '.join(vs))
-    m.finish()
-    
-  else:
-    return usage()
-  return
+    import getopt, fileinput
+    def usage():
+        print 'usage: %s {cmake,cget,cdump,cmerge} [options] cdbname [args ...]' % argv[0]
+        print 'usage: %s {tmake,tget,tdump,tmerge} [options] tcdbname [args ...]' % argv[0]
+        return 100
+    args = argv[1:]
+    if not args: return usage()
+    cmd = args.pop(0)
+    try:
+        (opts, args) = getopt.getopt(args, 'kv2')
+    except getopt.GetoptError:
+        return usage()
+    if not args: return usage()
+    dbname = args.pop(0)
+
+    # cdb
+    if cmd == 'cmake':
+        CDBMaker(dbname, dbname+'.tmp').txt2cdb(fileinput.input(args)).finish()
+    elif cmd == 'cget':
+        print repr(CDBReader(dbname).get(args[0]))
+    elif cmd == 'cdump':
+        f = (lambda k,v: '+%d,%d:%s->%s' % (len(k), len(v), k, v))
+        for (k, v) in opts:
+            if k == '-k': f = (lambda k,_: k)
+            elif k == '-v': f = (lambda _,v: v)
+            elif k == '-2': f = (lambda k,v: k+'\t'+v)
+        for (k,v) in cdbdump(dbname):
+            print f(k,v)
+        print
+    elif cmd == 'cmerge':
+        dbs = [ cdbdump(fname) for fname in args ]
+        m = CDBMaker(dbname, dbname+'.tmp')
+        for (k,vs) in tcdbmerge(dbs):
+            m.add(k, ' '.join(vs))
+        m.finish()
+    # tcdb
+    elif cmd == 'tmake':
+        TCDBMaker(dbname, dbname+'.tmp').txt2tcdb(fileinput.input(args)).finish()
+    elif cmd == 'tget':
+        print repr(TCDBReader(dbname).lookup(args))
+    elif cmd == 'tdump':
+        f = (lambda k,v: '%s%d,%d:%s->%s' % ('+'*len(k), len(k[-1]), len(v), k[-1], v))
+        for (k, v) in opts:
+            if k == '-k': f = (lambda k,_: '/'.join(k))
+            elif k == '-v': f = (lambda _,v: v)
+            elif k == '-2': f = (lambda k,v: '/'.join(k)+'\t'+v)
+        for (k,v) in tcdbdump(dbname):
+            print f(k,v)
+        print
+    elif cmd == 'tmerge':
+        dbs = [ tcdbdump(fname) for fname in args ]
+        m = TCDBMaker(dbname, dbname+'.tmp')
+        for (k,vs) in tcdbmerge(dbs):
+            m.put(len(k), k[-1], ' '.join(vs))
+        m.finish()
+
+    else:
+        return usage()
+    return
 
 if __name__ == '__main__': sys.exit(main(sys.argv))
diff --git a/pdfminer/rijndael.py b/pdfminer/rijndael.py
index 630342a..0d53334 100644
--- a/pdfminer/rijndael.py
+++ b/pdfminer/rijndael.py
@@ -691,88 +691,88 @@ rcon = [
   ]
 
 if len(pack('L',0)) == 4:
-  # 32bit
-  def GETU32(x): return unpack('>L', x)[0]
-  def PUTU32(x): return pack('>L', x)
+    # 32bit
+    def GETU32(x): return unpack('>L', x)[0]
+    def PUTU32(x): return pack('>L', x)
 else:
-  # 64bit
-  def GETU32(x): return unpack('>I', x)[0]
-  def PUTU32(x): return pack('>I', x)
+    # 64bit
+    def GETU32(x): return unpack('>I', x)[0]
+    def PUTU32(x): return pack('>I', x)
 
 # Expand the cipher key into the encryption key schedule.
 #
 # @return the number of rounds for the given cipher key size.
 def rijndaelSetupEncrypt(key, keybits):
-  i = p = 0
-  rk = [0]*RKLENGTH(keybits)
-  rk[0] = GETU32(key[0:4])
-  rk[1] = GETU32(key[4:8])
-  rk[2] = GETU32(key[8:12])
-  rk[3] = GETU32(key[12:16])
-  if keybits == 128:
-    while 1:
-      temp = rk[p+3]
-      rk[p+4] = (rk[p+0] ^
-                 (Te4[(temp >> 16) & 0xff] & 0xff000000) ^
-                 (Te4[(temp >>  8) & 0xff] & 0x00ff0000) ^
-                 (Te4[(temp      ) & 0xff] & 0x0000ff00) ^
-                 (Te4[(temp >> 24)       ] & 0x000000ff) ^
-                 rcon[i])
-      rk[p+5] = rk[p+1] ^ rk[p+4]
-      rk[p+6] = rk[p+2] ^ rk[p+5]
-      rk[p+7] = rk[p+3] ^ rk[p+6]
-      i += 1
-      if i == 10: return (rk, 10)
-      p += 4
+    i = p = 0
+    rk = [0]*RKLENGTH(keybits)
+    rk[0] = GETU32(key[0:4])
+    rk[1] = GETU32(key[4:8])
+    rk[2] = GETU32(key[8:12])
+    rk[3] = GETU32(key[12:16])
+    if keybits == 128:
+        while 1:
+            temp = rk[p+3]
+            rk[p+4] = (rk[p+0] ^
+                       (Te4[(temp >> 16) & 0xff] & 0xff000000) ^
+                       (Te4[(temp >>  8) & 0xff] & 0x00ff0000) ^
+                       (Te4[(temp      ) & 0xff] & 0x0000ff00) ^
+                       (Te4[(temp >> 24)       ] & 0x000000ff) ^
+                       rcon[i])
+            rk[p+5] = rk[p+1] ^ rk[p+4]
+            rk[p+6] = rk[p+2] ^ rk[p+5]
+            rk[p+7] = rk[p+3] ^ rk[p+6]
+            i += 1
+            if i == 10: return (rk, 10)
+            p += 4
 
-  rk[4] = GETU32(key[16:20])
-  rk[5] = GETU32(key[20:24])
-  if keybits == 192:
-    while 1:
-      temp = rk[p+5]
-      rk[p+6] = (rk[p+0] ^
-                 (Te4[(temp >> 16) & 0xff] & 0xff000000) ^
-                 (Te4[(temp >>  8) & 0xff] & 0x00ff0000) ^
-                 (Te4[(temp      ) & 0xff] & 0x0000ff00) ^
-                 (Te4[(temp >> 24)       ] & 0x000000ff) ^
-                 rcon[i])
-      rk[p+7] = rk[p+1] ^ rk[p+6]
-      rk[p+8] = rk[p+2] ^ rk[p+7]
-      rk[p+9] = rk[p+3] ^ rk[p+8]
-      i += 1
-      if i == 8: return (rk, 12)
-      rk[p+10] = rk[p+4] ^ rk[p+9]
-      rk[p+11] = rk[p+5] ^ rk[p+10]
-      p += 6
+    rk[4] = GETU32(key[16:20])
+    rk[5] = GETU32(key[20:24])
+    if keybits == 192:
+        while 1:
+            temp = rk[p+5]
+            rk[p+6] = (rk[p+0] ^
+                       (Te4[(temp >> 16) & 0xff] & 0xff000000) ^
+                       (Te4[(temp >>  8) & 0xff] & 0x00ff0000) ^
+                       (Te4[(temp      ) & 0xff] & 0x0000ff00) ^
+                       (Te4[(temp >> 24)       ] & 0x000000ff) ^
+                       rcon[i])
+            rk[p+7] = rk[p+1] ^ rk[p+6]
+            rk[p+8] = rk[p+2] ^ rk[p+7]
+            rk[p+9] = rk[p+3] ^ rk[p+8]
+            i += 1
+            if i == 8: return (rk, 12)
+            rk[p+10] = rk[p+4] ^ rk[p+9]
+            rk[p+11] = rk[p+5] ^ rk[p+10]
+            p += 6
 
-  rk[6] = GETU32(key[24:28])
-  rk[7] = GETU32(key[28:32])
-  if keybits == 256:
-    while 1:
-      temp = rk[p+7]
-      rk[p+8] = (rk[p+0] ^
-                 (Te4[(temp >> 16) & 0xff] & 0xff000000) ^
-                 (Te4[(temp >>  8) & 0xff] & 0x00ff0000) ^
-                 (Te4[(temp      ) & 0xff] & 0x0000ff00) ^
-                 (Te4[(temp >> 24)       ] & 0x000000ff) ^
-                 rcon[i])
-      rk[p+9] = rk[p+1] ^ rk[p+8]
-      rk[p+10] = rk[p+2] ^ rk[p+9]
-      rk[p+11] = rk[p+3] ^ rk[p+10]
-      i += 1
-      if i == 7: return (rk, 14)
-      temp = rk[p+11]
-      rk[p+12] = (rk[p+4] ^
-                  (Te4[(temp >> 24)       ] & 0xff000000) ^
-                  (Te4[(temp >> 16) & 0xff] & 0x00ff0000) ^
-                  (Te4[(temp >>  8) & 0xff] & 0x0000ff00) ^
-                  (Te4[(temp      ) & 0xff] & 0x000000ff))
-      rk[p+13] = rk[p+5] ^ rk[p+12]
-      rk[p+14] = rk[p+6] ^ rk[p+13]
-      rk[p+15] = rk[p+7] ^ rk[p+14]
-      p += 8
+    rk[6] = GETU32(key[24:28])
+    rk[7] = GETU32(key[28:32])
+    if keybits == 256:
+        while 1:
+            temp = rk[p+7]
+            rk[p+8] = (rk[p+0] ^
+                       (Te4[(temp >> 16) & 0xff] & 0xff000000) ^
+                       (Te4[(temp >>  8) & 0xff] & 0x00ff0000) ^
+                       (Te4[(temp      ) & 0xff] & 0x0000ff00) ^
+                       (Te4[(temp >> 24)       ] & 0x000000ff) ^
+                       rcon[i])
+            rk[p+9] = rk[p+1] ^ rk[p+8]
+            rk[p+10] = rk[p+2] ^ rk[p+9]
+            rk[p+11] = rk[p+3] ^ rk[p+10]
+            i += 1
+            if i == 7: return (rk, 14)
+            temp = rk[p+11]
+            rk[p+12] = (rk[p+4] ^
+                        (Te4[(temp >> 24)       ] & 0xff000000) ^
+                        (Te4[(temp >> 16) & 0xff] & 0x00ff0000) ^
+                        (Te4[(temp >>  8) & 0xff] & 0x0000ff00) ^
+                        (Te4[(temp      ) & 0xff] & 0x000000ff))
+            rk[p+13] = rk[p+5] ^ rk[p+12]
+            rk[p+14] = rk[p+6] ^ rk[p+13]
+            rk[p+15] = rk[p+7] ^ rk[p+14]
+            p += 8
 
-  raise ValueError(keybits)
+    raise ValueError(keybits)
 
 
 # Expand the cipher key into the decryption key schedule.
@@ -780,291 +780,291 @@ def rijndaelSetupEncrypt(key, keybits):
 # @return the number of rounds for the given cipher key size.
 def rijndaelSetupDecrypt(key, keybits):
 
-  # expand the cipher key:
-  (rk, nrounds) = rijndaelSetupEncrypt(key, keybits)
-  # invert the order of the round keys:
-  i = 0
-  j = 4*nrounds
-  while i < j:
-    temp = rk[i    ]; rk[i    ] = rk[j    ]; rk[j    ] = temp
-    temp = rk[i + 1]; rk[i + 1] = rk[j + 1]; rk[j + 1] = temp
-    temp = rk[i + 2]; rk[i + 2] = rk[j + 2]; rk[j + 2] = temp
-    temp = rk[i + 3]; rk[i + 3] = rk[j + 3]; rk[j + 3] = temp
-    i += 4
-    j -= 4
-  # apply the inverse MixColumn transform to all round keys but the first and the last:
-  p = 0
-  for i in xrange(1, nrounds):
-    p += 4
-    rk[p+0] = (
-      Td0[Te4[(rk[p+0] >> 24)       ] & 0xff] ^
-      Td1[Te4[(rk[p+0] >> 16) & 0xff] & 0xff] ^
-      Td2[Te4[(rk[p+0] >>  8) & 0xff] & 0xff] ^
-      Td3[Te4[(rk[p+0]      ) & 0xff] & 0xff])
-    rk[p+1] = (
-      Td0[Te4[(rk[p+1] >> 24)       ] & 0xff] ^
-      Td1[Te4[(rk[p+1] >> 16) & 0xff] & 0xff] ^
-      Td2[Te4[(rk[p+1] >>  8) & 0xff] & 0xff] ^
-      Td3[Te4[(rk[p+1]      ) & 0xff] & 0xff])
-    rk[p+2] = (
-      Td0[Te4[(rk[p+2] >> 24)       ] & 0xff] ^
-      Td1[Te4[(rk[p+2] >> 16) & 0xff] & 0xff] ^
-      Td2[Te4[(rk[p+2] >>  8) & 0xff] & 0xff] ^
-      Td3[Te4[(rk[p+2]      ) & 0xff] & 0xff])
-    rk[p+3] = (
-      Td0[Te4[(rk[p+3] >> 24)       ] & 0xff] ^
-      Td1[Te4[(rk[p+3] >> 16) & 0xff] & 0xff] ^
-      Td2[Te4[(rk[p+3] >>  8) & 0xff] & 0xff] ^
-      Td3[Te4[(rk[p+3]      ) & 0xff] & 0xff])
+    # expand the cipher key:
+    (rk, nrounds) = rijndaelSetupEncrypt(key, keybits)
+    # invert the order of the round keys:
+    i = 0
+    j = 4*nrounds
+    while i < j:
+        temp = rk[i    ]; rk[i    ] = rk[j    ]; rk[j    ] = temp
+        temp = rk[i + 1]; rk[i + 1] = rk[j + 1]; rk[j + 1] = temp
+        temp = rk[i + 2]; rk[i + 2] = rk[j + 2]; rk[j + 2] = temp
+        temp = rk[i + 3]; rk[i + 3] = rk[j + 3]; rk[j + 3] = temp
+        i += 4
+        j -= 4
+    # apply the inverse MixColumn transform to all round keys but the first and the last:
+    p = 0
+    for i in xrange(1, nrounds):
+        p += 4
+        rk[p+0] = (
+          Td0[Te4[(rk[p+0] >> 24)       ] & 0xff] ^
+          Td1[Te4[(rk[p+0] >> 16) & 0xff] & 0xff] ^
+          Td2[Te4[(rk[p+0] >>  8) & 0xff] & 0xff] ^
+          Td3[Te4[(rk[p+0]      ) & 0xff] & 0xff])
+        rk[p+1] = (
+          Td0[Te4[(rk[p+1] >> 24)       ] & 0xff] ^
+          Td1[Te4[(rk[p+1] >> 16) & 0xff] & 0xff] ^
+          Td2[Te4[(rk[p+1] >>  8) & 0xff] & 0xff] ^
+          Td3[Te4[(rk[p+1]      ) & 0xff] & 0xff])
+        rk[p+2] = (
+          Td0[Te4[(rk[p+2] >> 24)       ] & 0xff] ^
+          Td1[Te4[(rk[p+2] >> 16) & 0xff] & 0xff] ^
+          Td2[Te4[(rk[p+2] >>  8) & 0xff] & 0xff] ^
+          Td3[Te4[(rk[p+2]      ) & 0xff] & 0xff])
+        rk[p+3] = (
+          Td0[Te4[(rk[p+3] >> 24)       ] & 0xff] ^
+          Td1[Te4[(rk[p+3] >> 16) & 0xff] & 0xff] ^
+          Td2[Te4[(rk[p+3] >>  8) & 0xff] & 0xff] ^
+          Td3[Te4[(rk[p+3]      ) & 0xff] & 0xff])
 
-  return (rk, nrounds)
+    return (rk, nrounds)
 
 
 def rijndaelEncrypt(rk, nrounds, plaintext):
-  assert len(plaintext) == 16
+    assert len(plaintext) == 16
 
-  # map byte array block to cipher state
-  # and add initial round key:
-  s0 = GETU32(plaintext[0:4]) ^ rk[0]
-  s1 = GETU32(plaintext[4:8]) ^ rk[1]
-  s2 = GETU32(plaintext[8:12]) ^ rk[2]
-  s3 = GETU32(plaintext[12:16]) ^ rk[3]
-  
-  # nrounds - 1 full rounds:
-  r = nrounds >> 1
-  p = 0
-  while 1:
-    t0 = (
-      Te0[(s0 >> 24)       ] ^
-      Te1[(s1 >> 16) & 0xff] ^
-      Te2[(s2 >>  8) & 0xff] ^
-      Te3[(s3      ) & 0xff] ^
-      rk[p+4])
-    t1 = (
-      Te0[(s1 >> 24)       ] ^
-      Te1[(s2 >> 16) & 0xff] ^
-      Te2[(s3 >>  8) & 0xff] ^
-      Te3[(s0      ) & 0xff] ^
-      rk[p+5])
-    t2 = (
-      Te0[(s2 >> 24)       ] ^
-      Te1[(s3 >> 16) & 0xff] ^
-      Te2[(s0 >>  8) & 0xff] ^
-      Te3[(s1      ) & 0xff] ^
-      rk[p+6])
-    t3 = (
-      Te0[(s3 >> 24)       ] ^
-      Te1[(s0 >> 16) & 0xff] ^
-      Te2[(s1 >>  8) & 0xff] ^
-      Te3[(s2      ) & 0xff] ^
-      rk[p+7])
-    p += 8
-    r -= 1
-    if r == 0: break
+    # map byte array block to cipher state
+    # and add initial round key:
+    s0 = GETU32(plaintext[0:4]) ^ rk[0]
+    s1 = GETU32(plaintext[4:8]) ^ rk[1]
+    s2 = GETU32(plaintext[8:12]) ^ rk[2]
+    s3 = GETU32(plaintext[12:16]) ^ rk[3]
+
+    # nrounds - 1 full rounds:
+    r = nrounds >> 1
+    p = 0
+    while 1:
+        t0 = (
+          Te0[(s0 >> 24)       ] ^
+          Te1[(s1 >> 16) & 0xff] ^
+          Te2[(s2 >>  8) & 0xff] ^
+          Te3[(s3      ) & 0xff] ^
+          rk[p+4])
+        t1 = (
+          Te0[(s1 >> 24)       ] ^
+          Te1[(s2 >> 16) & 0xff] ^
+          Te2[(s3 >>  8) & 0xff] ^
+          Te3[(s0      ) & 0xff] ^
+          rk[p+5])
+        t2 = (
+          Te0[(s2 >> 24)       ] ^
+          Te1[(s3 >> 16) & 0xff] ^
+          Te2[(s0 >>  8) & 0xff] ^
+          Te3[(s1      ) & 0xff] ^
+          rk[p+6])
+        t3 = (
+          Te0[(s3 >> 24)       ] ^
+          Te1[(s0 >> 16) & 0xff] ^
+          Te2[(s1 >>  8) & 0xff] ^
+          Te3[(s2      ) & 0xff] ^
+          rk[p+7])
+        p += 8
+        r -= 1
+        if r == 0: break
+        s0 = (
+          Te0[(t0 >> 24)       ] ^
+          Te1[(t1 >> 16) & 0xff] ^
+          Te2[(t2 >>  8) & 0xff] ^
+          Te3[(t3      ) & 0xff] ^
+          rk[p+0])
+        s1 = (
+          Te0[(t1 >> 24)       ] ^
+          Te1[(t2 >> 16) & 0xff] ^
+          Te2[(t3 >>  8) & 0xff] ^
+          Te3[(t0      ) & 0xff] ^
+          rk[p+1])
+        s2 = (
+          Te0[(t2 >> 24)       ] ^
+          Te1[(t3 >> 16) & 0xff] ^
+          Te2[(t0 >>  8) & 0xff] ^
+          Te3[(t1      ) & 0xff] ^
+          rk[p+2])
+        s3 = (
+          Te0[(t3 >> 24)       ] ^
+          Te1[(t0 >> 16) & 0xff] ^
+          Te2[(t1 >>  8) & 0xff] ^
+          Te3[(t2      ) & 0xff] ^
+          rk[p+3])
+
+    ciphertext = ''
+
+    # apply last round and
+    # map cipher state to byte array block:
     s0 = (
-      Te0[(t0 >> 24)       ] ^
-      Te1[(t1 >> 16) & 0xff] ^
-      Te2[(t2 >>  8) & 0xff] ^
-      Te3[(t3      ) & 0xff] ^
+      (Te4[(t0 >> 24)       ] & 0xff000000) ^
+      (Te4[(t1 >> 16) & 0xff] & 0x00ff0000) ^
+      (Te4[(t2 >>  8) & 0xff] & 0x0000ff00) ^
+      (Te4[(t3      ) & 0xff] & 0x000000ff) ^
       rk[p+0])
+    ciphertext += PUTU32(s0)
     s1 = (
-      Te0[(t1 >> 24)       ] ^
-      Te1[(t2 >> 16) & 0xff] ^
-      Te2[(t3 >>  8) & 0xff] ^
-      Te3[(t0      ) & 0xff] ^
+      (Te4[(t1 >> 24)       ] & 0xff000000) ^
+      (Te4[(t2 >> 16) & 0xff] & 0x00ff0000) ^
+      (Te4[(t3 >>  8) & 0xff] & 0x0000ff00) ^
+      (Te4[(t0      ) & 0xff] & 0x000000ff) ^
       rk[p+1])
+    ciphertext += PUTU32(s1)
     s2 = (
-      Te0[(t2 >> 24)       ] ^
-      Te1[(t3 >> 16) & 0xff] ^
-      Te2[(t0 >>  8) & 0xff] ^
-      Te3[(t1      ) & 0xff] ^
+      (Te4[(t2 >> 24)       ] & 0xff000000) ^
+      (Te4[(t3 >> 16) & 0xff] & 0x00ff0000) ^
+      (Te4[(t0 >>  8) & 0xff] & 0x0000ff00) ^
+      (Te4[(t1      ) & 0xff] & 0x000000ff) ^
       rk[p+2])
+    ciphertext += PUTU32(s2)
     s3 = (
-      Te0[(t3 >> 24)       ] ^
-      Te1[(t0 >> 16) & 0xff] ^
-      Te2[(t1 >>  8) & 0xff] ^
-      Te3[(t2      ) & 0xff] ^
+      (Te4[(t3 >> 24)       ] & 0xff000000) ^
+      (Te4[(t0 >> 16) & 0xff] & 0x00ff0000) ^
+      (Te4[(t1 >>  8) & 0xff] & 0x0000ff00) ^
+      (Te4[(t2      ) & 0xff] & 0x000000ff) ^
       rk[p+3])
+    ciphertext += PUTU32(s3)
 
-  ciphertext = ''
-  
-  # apply last round and
-  # map cipher state to byte array block:
-  s0 = (
-    (Te4[(t0 >> 24)       ] & 0xff000000) ^
-    (Te4[(t1 >> 16) & 0xff] & 0x00ff0000) ^
-    (Te4[(t2 >>  8) & 0xff] & 0x0000ff00) ^
-    (Te4[(t3      ) & 0xff] & 0x000000ff) ^
-    rk[p+0])
-  ciphertext += PUTU32(s0)
-  s1 = (
-    (Te4[(t1 >> 24)       ] & 0xff000000) ^
-    (Te4[(t2 >> 16) & 0xff] & 0x00ff0000) ^
-    (Te4[(t3 >>  8) & 0xff] & 0x0000ff00) ^
-    (Te4[(t0      ) & 0xff] & 0x000000ff) ^
-    rk[p+1])
-  ciphertext += PUTU32(s1)
-  s2 = (
-    (Te4[(t2 >> 24)       ] & 0xff000000) ^
-    (Te4[(t3 >> 16) & 0xff] & 0x00ff0000) ^
-    (Te4[(t0 >>  8) & 0xff] & 0x0000ff00) ^
-    (Te4[(t1      ) & 0xff] & 0x000000ff) ^
-    rk[p+2])
-  ciphertext += PUTU32(s2)
-  s3 = (
-    (Te4[(t3 >> 24)       ] & 0xff000000) ^
-    (Te4[(t0 >> 16) & 0xff] & 0x00ff0000) ^
-    (Te4[(t1 >>  8) & 0xff] & 0x0000ff00) ^
-    (Te4[(t2      ) & 0xff] & 0x000000ff) ^
-    rk[p+3])
-  ciphertext += PUTU32(s3)
-  
-  assert len(ciphertext) == 16
-  return ciphertext
+    assert len(ciphertext) == 16
+    return ciphertext
 
 
 def rijndaelDecrypt(rk, nrounds, ciphertext):
-  assert len(ciphertext) == 16
-  
-  # map byte array block to cipher state
-  # and add initial round key:
-  s0 = GETU32(ciphertext[0:4]) ^ rk[0]
-  s1 = GETU32(ciphertext[4:8]) ^ rk[1]
-  s2 = GETU32(ciphertext[8:12]) ^ rk[2]
-  s3 = GETU32(ciphertext[12:16]) ^ rk[3]
-  
-  # nrounds - 1 full rounds:
-  r = nrounds >> 1
-  p = 0
-  while 1:
-    t0 = (
-      Td0[(s0 >> 24)       ] ^
-      Td1[(s3 >> 16) & 0xff] ^
-      Td2[(s2 >>  8) & 0xff] ^
-      Td3[(s1      ) & 0xff] ^
-      rk[p+4])
-    t1 = (
-      Td0[(s1 >> 24)       ] ^
-      Td1[(s0 >> 16) & 0xff] ^
-      Td2[(s3 >>  8) & 0xff] ^
-      Td3[(s2      ) & 0xff] ^
-      rk[p+5])
-    t2 = (
-      Td0[(s2 >> 24)       ] ^
-      Td1[(s1 >> 16) & 0xff] ^
-      Td2[(s0 >>  8) & 0xff] ^
-      Td3[(s3      ) & 0xff] ^
-      rk[p+6])
-    t3 = (
-      Td0[(s3 >> 24)       ] ^
-      Td1[(s2 >> 16) & 0xff] ^
-      Td2[(s1 >>  8) & 0xff] ^
-      Td3[(s0      ) & 0xff] ^
-      rk[p+7])
-    p += 8
-    r -= 1
-    if r == 0: break
+    assert len(ciphertext) == 16
+
+    # map byte array block to cipher state
+    # and add initial round key:
+    s0 = GETU32(ciphertext[0:4]) ^ rk[0]
+    s1 = GETU32(ciphertext[4:8]) ^ rk[1]
+    s2 = GETU32(ciphertext[8:12]) ^ rk[2]
+    s3 = GETU32(ciphertext[12:16]) ^ rk[3]
+
+    # nrounds - 1 full rounds:
+    r = nrounds >> 1
+    p = 0
+    while 1:
+        t0 = (
+          Td0[(s0 >> 24)       ] ^
+          Td1[(s3 >> 16) & 0xff] ^
+          Td2[(s2 >>  8) & 0xff] ^
+          Td3[(s1      ) & 0xff] ^
+          rk[p+4])
+        t1 = (
+          Td0[(s1 >> 24)       ] ^
+          Td1[(s0 >> 16) & 0xff] ^
+          Td2[(s3 >>  8) & 0xff] ^
+          Td3[(s2      ) & 0xff] ^
+          rk[p+5])
+        t2 = (
+          Td0[(s2 >> 24)       ] ^
+          Td1[(s1 >> 16) & 0xff] ^
+          Td2[(s0 >>  8) & 0xff] ^
+          Td3[(s3      ) & 0xff] ^
+          rk[p+6])
+        t3 = (
+          Td0[(s3 >> 24)       ] ^
+          Td1[(s2 >> 16) & 0xff] ^
+          Td2[(s1 >>  8) & 0xff] ^
+          Td3[(s0      ) & 0xff] ^
+          rk[p+7])
+        p += 8
+        r -= 1
+        if r == 0: break
+        s0 = (
+          Td0[(t0 >> 24)       ] ^
+          Td1[(t3 >> 16) & 0xff] ^
+          Td2[(t2 >>  8) & 0xff] ^
+          Td3[(t1      ) & 0xff] ^
+          rk[p+0])
+        s1 = (
+          Td0[(t1 >> 24)       ] ^
+          Td1[(t0 >> 16) & 0xff] ^
+          Td2[(t3 >>  8) & 0xff] ^
+          Td3[(t2      ) & 0xff] ^
+          rk[p+1])
+        s2 = (
+          Td0[(t2 >> 24)       ] ^
+          Td1[(t1 >> 16) & 0xff] ^
+          Td2[(t0 >>  8) & 0xff] ^
+          Td3[(t3      ) & 0xff] ^
+          rk[p+2])
+        s3 = (
+          Td0[(t3 >> 24)       ] ^
+          Td1[(t2 >> 16) & 0xff] ^
+          Td2[(t1 >>  8) & 0xff] ^
+          Td3[(t0      ) & 0xff] ^
+          rk[p+3])
+
+    plaintext = ''
+
+    # apply last round and
+    # map cipher state to byte array block:
     s0 = (
-      Td0[(t0 >> 24)       ] ^
-      Td1[(t3 >> 16) & 0xff] ^
-      Td2[(t2 >>  8) & 0xff] ^
-      Td3[(t1      ) & 0xff] ^
+      (Td4[(t0 >> 24)       ] & 0xff000000) ^
+      (Td4[(t3 >> 16) & 0xff] & 0x00ff0000) ^
+      (Td4[(t2 >>  8) & 0xff] & 0x0000ff00) ^
+      (Td4[(t1      ) & 0xff] & 0x000000ff) ^
       rk[p+0])
+    plaintext += PUTU32(s0)
     s1 = (
-      Td0[(t1 >> 24)       ] ^
-      Td1[(t0 >> 16) & 0xff] ^
-      Td2[(t3 >>  8) & 0xff] ^
-      Td3[(t2      ) & 0xff] ^
+      (Td4[(t1 >> 24)       ] & 0xff000000) ^
+      (Td4[(t0 >> 16) & 0xff] & 0x00ff0000) ^
+      (Td4[(t3 >>  8) & 0xff] & 0x0000ff00) ^
+      (Td4[(t2      ) & 0xff] & 0x000000ff) ^
       rk[p+1])
+    plaintext += PUTU32(s1)
     s2 = (
-      Td0[(t2 >> 24)       ] ^
-      Td1[(t1 >> 16) & 0xff] ^
-      Td2[(t0 >>  8) & 0xff] ^
-      Td3[(t3      ) & 0xff] ^
+      (Td4[(t2 >> 24)       ] & 0xff000000) ^
+      (Td4[(t1 >> 16) & 0xff] & 0x00ff0000) ^
+      (Td4[(t0 >>  8) & 0xff] & 0x0000ff00) ^
+      (Td4[(t3      ) & 0xff] & 0x000000ff) ^
       rk[p+2])
+    plaintext += PUTU32(s2)
     s3 = (
-      Td0[(t3 >> 24)       ] ^
-      Td1[(t2 >> 16) & 0xff] ^
-      Td2[(t1 >>  8) & 0xff] ^
-      Td3[(t0      ) & 0xff] ^
+      (Td4[(t3 >> 24)       ] & 0xff000000) ^
+      (Td4[(t2 >> 16) & 0xff] & 0x00ff0000) ^
+      (Td4[(t1 >>  8) & 0xff] & 0x0000ff00) ^
+      (Td4[(t0      ) & 0xff] & 0x000000ff) ^
       rk[p+3])
+    plaintext += PUTU32(s3)
 
-  plaintext = ''
-
-  # apply last round and
-  # map cipher state to byte array block:
-  s0 = (
-    (Td4[(t0 >> 24)       ] & 0xff000000) ^
-    (Td4[(t3 >> 16) & 0xff] & 0x00ff0000) ^
-    (Td4[(t2 >>  8) & 0xff] & 0x0000ff00) ^
-    (Td4[(t1      ) & 0xff] & 0x000000ff) ^
-    rk[p+0])
-  plaintext += PUTU32(s0)
-  s1 = (
-    (Td4[(t1 >> 24)       ] & 0xff000000) ^
-    (Td4[(t0 >> 16) & 0xff] & 0x00ff0000) ^
-    (Td4[(t3 >>  8) & 0xff] & 0x0000ff00) ^
-    (Td4[(t2      ) & 0xff] & 0x000000ff) ^
-    rk[p+1])
-  plaintext += PUTU32(s1)
-  s2 = (
-    (Td4[(t2 >> 24)       ] & 0xff000000) ^
-    (Td4[(t1 >> 16) & 0xff] & 0x00ff0000) ^
-    (Td4[(t0 >>  8) & 0xff] & 0x0000ff00) ^
-    (Td4[(t3      ) & 0xff] & 0x000000ff) ^
-    rk[p+2])
-  plaintext += PUTU32(s2)
-  s3 = (
-    (Td4[(t3 >> 24)       ] & 0xff000000) ^
-    (Td4[(t2 >> 16) & 0xff] & 0x00ff0000) ^
-    (Td4[(t1 >>  8) & 0xff] & 0x0000ff00) ^
-    (Td4[(t0      ) & 0xff] & 0x000000ff) ^
-    rk[p+3])
-  plaintext += PUTU32(s3)
-  
-  assert len(plaintext) == 16
-  return plaintext
+    assert len(plaintext) == 16
+    return plaintext
 
 
 # decrypt(key, fin, fout, keybits=256)
 class RijndaelDecryptor(object):
-  
-  def __init__(self, key, keybits=256):
-    assert len(key) == KEYLENGTH(keybits)
-    (self.rk, self.nrounds) = rijndaelSetupDecrypt(key, keybits)
-    assert len(self.rk) == RKLENGTH(keybits)
-    assert self.nrounds == NROUNDS(keybits)
-    return
 
-  def decrypt(self, ciphertext):
-    assert len(ciphertext) == 16
-    return rijndaelDecrypt(self.rk, self.nrounds, ciphertext)
+    def __init__(self, key, keybits=256):
+        assert len(key) == KEYLENGTH(keybits)
+        (self.rk, self.nrounds) = rijndaelSetupDecrypt(key, keybits)
+        assert len(self.rk) == RKLENGTH(keybits)
+        assert self.nrounds == NROUNDS(keybits)
+        return
+
+    def decrypt(self, ciphertext):
+        assert len(ciphertext) == 16
+        return rijndaelDecrypt(self.rk, self.nrounds, ciphertext)
 
 # encrypt(key, fin, fout, keybits=256)
 class RijndaelEncryptor(object):
 
-  def __init__(self, key, keybits=256):
-    assert len(key) == KEYLENGTH(keybits)
-    (self.rk, self.nrounds) = rijndaelSetupEncrypt(key, keybits)
-    assert len(self.rk) == RKLENGTH(keybits)
-    assert self.nrounds == NROUNDS(keybits)
-    return
+    def __init__(self, key, keybits=256):
+        assert len(key) == KEYLENGTH(keybits)
+        (self.rk, self.nrounds) = rijndaelSetupEncrypt(key, keybits)
+        assert len(self.rk) == RKLENGTH(keybits)
+        assert self.nrounds == NROUNDS(keybits)
+        return
 
-  def encrypt(self, plaintext):
-    assert len(plaintext) == 16
-    return rijndaelEncrypt(self.rk, self.nrounds, plaintext)
+    def encrypt(self, plaintext):
+        assert len(plaintext) == 16
+        return rijndaelEncrypt(self.rk, self.nrounds, plaintext)
 
 def main(argv):
-  # test
-  key = '00010203050607080A0B0C0D0F101112'.decode('hex')
-  plaintext = '506812A45F08C889B97F5980038B8359'.decode('hex')
-  ciphertext = 'D8F532538289EF7D06B506A4FD5BE9C9'.decode('hex')
-  e = RijndaelEncryptor(key, 128)
-  text = e.encrypt(plaintext)
-  assert text == ciphertext
-  d = RijndaelDecryptor(key, 128)
-  text = d.decrypt(ciphertext)
-  assert text == plaintext
-  return 0
+    # test
+    key = '00010203050607080A0B0C0D0F101112'.decode('hex')
+    plaintext = '506812A45F08C889B97F5980038B8359'.decode('hex')
+    ciphertext = 'D8F532538289EF7D06B506A4FD5BE9C9'.decode('hex')
+    e = RijndaelEncryptor(key, 128)
+    text = e.encrypt(plaintext)
+    assert text == ciphertext
+    d = RijndaelDecryptor(key, 128)
+    text = d.decrypt(ciphertext)
+    assert text == plaintext
+    return 0
 
 if __name__ == '__main__': sys.exit(main(sys.argv))
diff --git a/pdfminer/utils.py b/pdfminer/utils.py
index 42aeef5..c743885 100644
--- a/pdfminer/utils.py
+++ b/pdfminer/utils.py
@@ -7,21 +7,21 @@ from struct import unpack
 MATRIX_IDENTITY = (1, 0, 0, 1, 0, 0)
 
 def mult_matrix((a1,b1,c1,d1,e1,f1), (a0,b0,c0,d0,e0,f0)):
-  '''Multiplies two matrices.'''
-  return (a0*a1+c0*b1,    b0*a1+d0*b1,
-          a0*c1+c0*d1,    b0*c1+d0*d1,
-          a0*e1+c0*f1+e0, b0*e1+d0*f1+f0)
+    '''Multiplies two matrices.'''
+    return (a0*a1+c0*b1,    b0*a1+d0*b1,
+            a0*c1+c0*d1,    b0*c1+d0*d1,
+            a0*e1+c0*f1+e0, b0*e1+d0*f1+f0)
 
 def translate_matrix((a,b,c,d,e,f), (x,y)):
-  return (a,b,c,d,x*a+y*c+e,x*b+y*d+f)
-  
+    return (a,b,c,d,x*a+y*c+e,x*b+y*d+f)
+
 def apply_matrix_pt((a,b,c,d,e,f), (x,y)):
-  '''Applies a matrix to a point.'''
-  return (a*x+c*y+e, b*x+d*y+f)
+    '''Applies a matrix to a point.'''
+    return (a*x+c*y+e, b*x+d*y+f)
 
 def apply_matrix_norm((a,b,c,d,e,f), (p,q)):
-  '''Equivalent to apply_matrix_pt(M, (p,q)) - apply_matrix_pt(M, (0,0))'''
-  return (a*p+c*q, b*p+d*q)
+    '''Equivalent to apply_matrix_pt(M, (p,q)) - apply_matrix_pt(M, (0,0))'''
+    return (a*p+c*q, b*p+d*q)
 
 
 ##  Utility functions
@@ -29,62 +29,62 @@ def apply_matrix_norm((a,b,c,d,e,f), (p,q)):
 
 # pick
 def pick(seq, func, maxobj=None):
-  '''Picks the object that has the highest value of func(obj).'''
-  maxscore = None
-  for obj in seq:
-    score = func(obj)
-    if maxscore == None or maxscore < score:
-      (maxscore,maxobj) = (score,obj)
-  return maxobj
+    '''Picks the object that has the highest value of func(obj).'''
+    maxscore = None
+    for obj in seq:
+        score = func(obj)
+        if maxscore == None or maxscore < score:
+            (maxscore,maxobj) = (score,obj)
+    return maxobj
 
 # bsearch
 def bsearch(objs, v0):
-  '''Tries to find the closest value to v0.'''
-  i0 = 0
-  i1 = len(objs)
-  while i0 < i1:
-    i = (i0+i1)/2
-    (v, obj) = objs[i]
-    if v0 == v:
-      (i0,i1) = (i,i+1)
-      while 0 < i0 and objs[i0-1][0] == v0:
-        i0 -= 1
-      while i1 < len(objs)-1 and objs[i1][0] == v0:
-        i1 += 1
-      break
-    elif v0 < v:
-      i1 = i
-    else:
-      i0 = i+1
-  return (i0,i1)
+    '''Tries to find the closest value to v0.'''
+    i0 = 0
+    i1 = len(objs)
+    while i0 < i1:
+        i = (i0+i1)/2
+        (v, obj) = objs[i]
+        if v0 == v:
+            (i0,i1) = (i,i+1)
+            while 0 < i0 and objs[i0-1][0] == v0:
+                i0 -= 1
+            while i1 < len(objs)-1 and objs[i1][0] == v0:
+                i1 += 1
+            break
+        elif v0 < v:
+            i1 = i
+        else:
+            i0 = i+1
+    return (i0,i1)
 
 # choplist
 def choplist(n, seq):
-  '''Groups every n elements of the list.'''
-  r = []
-  for x in seq:
-    r.append(x)
-    if len(r) == n:
-      yield tuple(r)
-      r = []
-  return
+    '''Groups every n elements of the list.'''
+    r = []
+    for x in seq:
+        r.append(x)
+        if len(r) == n:
+            yield tuple(r)
+            r = []
+    return
 
 # nunpack
 def nunpack(s, default=0):
-  '''Unpacks up to 4 bytes big endian.'''
-  l = len(s)
-  if not l:
-    return default
-  elif l == 1:
-    return ord(s)
-  elif l == 2:
-    return unpack('>H', s)[0]
-  elif l == 3:
-    return unpack('>L', '\x00'+s)[0]
-  elif l == 4:
-    return unpack('>L', s)[0]
-  else:
-    return TypeError('invalid length: %d' % l)
+    '''Unpacks up to 4 bytes big endian.'''
+    l = len(s)
+    if not l:
+        return default
+    elif l == 1:
+        return ord(s)
+    elif l == 2:
+        return unpack('>H', s)[0]
+    elif l == 3:
+        return unpack('>L', '\x00'+s)[0]
+    elif l == 4:
+        return unpack('>L', s)[0]
+    else:
+        return TypeError('invalid length: %d' % l)
 
 # decode_text
 PDFDocEncoding = ''.join( unichr(x) for x in (
@@ -122,14 +122,14 @@ PDFDocEncoding = ''.join( unichr(x) for x in (
   0x00f8, 0x00f9, 0x00fa, 0x00fb, 0x00fc, 0x00fd, 0x00fe, 0x00ff,
 ))
 def decode_text(s):
-  '''Decodes a PDFDocEncoding string to Unicode.'''
-  if s.startswith('\xfe\xff'):
-    return unicode(s[2:], 'utf-16be', 'ignore')
-  else:
-    return ''.join( PDFDocEncoding[ord(c)] for c in s )
+    '''Decodes a PDFDocEncoding string to Unicode.'''
+    if s.startswith('\xfe\xff'):
+        return unicode(s[2:], 'utf-16be', 'ignore')
+    else:
+        return ''.join( PDFDocEncoding[ord(c)] for c in s )
 
 # enc
 def enc(x, codec='ascii'):
-  '''Encodes a string for SGML/XML/HTML'''
-  x = x.replace('&','&amp;').replace('>','&gt;').replace('<','&lt;').replace('"','&quot;')
-  return x.encode(codec, 'xmlcharrefreplace')
+    '''Encodes a string for SGML/XML/HTML'''
+    x = x.replace('&','&amp;').replace('>','&gt;').replace('<','&lt;').replace('"','&quot;')
+    return x.encode(codec, 'xmlcharrefreplace')
diff --git a/setup.py b/setup.py
index dbda6a6..5a7b2ab 100644
--- a/setup.py
+++ b/setup.py
@@ -3,10 +3,10 @@ from distutils.core import setup
 from pdfminer import __version__
 
 setup(
-  name='pdfminer',
-  version=__version__,
-  description='PDF parser and analyzer',
-  long_description='''PDFMiner is a suite of programs that help
+    name='pdfminer',
+    version=__version__,
+    description='PDF parser and analyzer',
+    long_description='''PDFMiner is a suite of programs that help
 extracting and analyzing text data of PDF documents.
 Unlike other PDF-related tools, it allows to obtain
 the exact location of texts in a page, as well as 
@@ -14,23 +14,23 @@ other extra information such as font information or ruled lines.
 It includes a PDF converter that can transform PDF files
 into other text formats (such as HTML). It has an extensible
 PDF parser that can be used for other purposes instead of text analysis.''',
-  license='MIT/X',
-  author='Yusuke Shinyama',
-  author_email='yusuke at cs dot nyu dot edu',
-  url='http://www.unixuser.org/~euske/python/pdfminer/index.html',
-  packages=[
+    license='MIT/X',
+    author='Yusuke Shinyama',
+    author_email='yusuke at cs dot nyu dot edu',
+    url='http://www.unixuser.org/~euske/python/pdfminer/index.html',
+    packages=[
     'pdfminer'
-  ],
-  scripts=[
+    ],
+    scripts=[
     'tools/pdf2txt.py',
     'tools/dumppdf.py'
     ],
-  keywords=['pdf parser', 'pdf converter', 'text mining'],
-  classifiers=[
+    keywords=['pdf parser', 'pdf converter', 'text mining'],
+    classifiers=[
     'Development Status :: 4 - Beta',
     'Environment :: Console',
     'Intended Audience :: Developers',
     'Intended Audience :: Science/Research',
     'License :: OSI Approved :: MIT License',
-  ],
-  )
+    ],
+    )
diff --git a/tools/conv_afm.py b/tools/conv_afm.py
index de76015..efc63ad 100755
--- a/tools/conv_afm.py
+++ b/tools/conv_afm.py
@@ -5,38 +5,38 @@ stdout = sys.stdout
 stderr = sys.stderr
 
 def main(argv):
-  fonts = {}
-  for line in fileinput.input():
-    f = line.strip().split(' ')
-    if not f: continue
-    k = f[0]
-    if k == 'FontName':
-      fontname = f[1]
-      props = {'FontName': fontname, 'Flags': 0}
-      chars = {}
-      fonts[fontname] = (props, chars)
-    elif k == 'C':
-      cid = int(f[1])
-      if 0 <= cid and cid <= 255:
-        width = int(f[4])
-        chars[cid] = width
-    elif k in ('CapHeight', 'XHeight', 'ItalicAngle',
-               'Ascender', 'Descender'):
-      k = {'Ascender':'Ascent', 'Descender':'Descent'}.get(k,k)
-      props[k] = float(f[1])
-    elif k in ('FontName', 'FamilyName', 'Weight'):
-      k = {'FamilyName':'FontFamily', 'Weight':'FontWeight'}.get(k,k)
-      props[k] = f[1]
-    elif k == 'IsFixedPitch':
-      if f[1].lower() == 'true':
-        props['Flags'] = 64
-    elif k == 'FontBBox':
-      props[k] = tuple(map(float, f[1:5]))
-  print '# -*- python -*-'
-  print 'FONT_METRICS = {'
-  for (fontname,(props,chars)) in fonts.iteritems():
-    print ' %r: %r,' % (fontname, (props,chars))
-  print '}'
-  return 0
+    fonts = {}
+    for line in fileinput.input():
+        f = line.strip().split(' ')
+        if not f: continue
+        k = f[0]
+        if k == 'FontName':
+            fontname = f[1]
+            props = {'FontName': fontname, 'Flags': 0}
+            chars = {}
+            fonts[fontname] = (props, chars)
+        elif k == 'C':
+            cid = int(f[1])
+            if 0 <= cid and cid <= 255:
+                width = int(f[4])
+                chars[cid] = width
+        elif k in ('CapHeight', 'XHeight', 'ItalicAngle',
+                   'Ascender', 'Descender'):
+            k = {'Ascender':'Ascent', 'Descender':'Descent'}.get(k,k)
+            props[k] = float(f[1])
+        elif k in ('FontName', 'FamilyName', 'Weight'):
+            k = {'FamilyName':'FontFamily', 'Weight':'FontWeight'}.get(k,k)
+            props[k] = f[1]
+        elif k == 'IsFixedPitch':
+            if f[1].lower() == 'true':
+                props['Flags'] = 64
+        elif k == 'FontBBox':
+            props[k] = tuple(map(float, f[1:5]))
+    print '# -*- python -*-'
+    print 'FONT_METRICS = {'
+    for (fontname,(props,chars)) in fonts.iteritems():
+        print ' %r: %r,' % (fontname, (props,chars))
+    print '}'
+    return 0
 
 if __name__ == '__main__': sys.exit(main(sys.argv))
diff --git a/tools/dumppdf.py b/tools/dumppdf.py
index 3003555..b8fbbbf 100755
--- a/tools/dumppdf.py
+++ b/tools/dumppdf.py
@@ -13,173 +13,173 @@ from pdfminer.pdftypes import PDFStream, PDFObjRef, PSKeyword, PSLiteral, resolv
 
 ESC_PAT = re.compile(r'[\000-\037&<>()\042\047\134\177-\377]')
 def esc(s):
-  return ESC_PAT.sub(lambda m:'&#%d;' % ord(m.group(0)), s)
+    return ESC_PAT.sub(lambda m:'&#%d;' % ord(m.group(0)), s)
 
 
 # dumpxml
 def dumpxml(out, obj, codec=None):
-  if isinstance(obj, dict):
-    out.write('<dict size="%d">\n' % len(obj))
-    for (k,v) in obj.iteritems():
-      out.write('<key>%s</key>\n' % k)
-      out.write('<value>')
-      dumpxml(out, v)
-      out.write('</value>\n')
-    out.write('</dict>')
-    return
+    if isinstance(obj, dict):
+        out.write('<dict size="%d">\n' % len(obj))
+        for (k,v) in obj.iteritems():
+            out.write('<key>%s</key>\n' % k)
+            out.write('<value>')
+            dumpxml(out, v)
+            out.write('</value>\n')
+        out.write('</dict>')
+        return
 
-  if isinstance(obj, list):
-    out.write('<list size="%d">\n' % len(obj))
-    for v in obj:
-      dumpxml(out, v)
-      out.write('\n')
-    out.write('</list>')
-    return
+    if isinstance(obj, list):
+        out.write('<list size="%d">\n' % len(obj))
+        for v in obj:
+            dumpxml(out, v)
+            out.write('\n')
+        out.write('</list>')
+        return
 
-  if isinstance(obj, str):
-    out.write('<string size="%d">%s</string>' % (len(obj), esc(obj)))
-    return
+    if isinstance(obj, str):
+        out.write('<string size="%d">%s</string>' % (len(obj), esc(obj)))
+        return
 
-  if isinstance(obj, PDFStream):
-    out.write('<stream>\n<props>\n')
-    dumpxml(out, obj.dic)
-    out.write('\n</props>\n')
-    if codec == 'text':
-      data = obj.get_data()
-      out.write('<data size="%d">%s</data>\n' % (len(data), esc(data)))
-    out.write('</stream>')
-    return
+    if isinstance(obj, PDFStream):
+        out.write('<stream>\n<props>\n')
+        dumpxml(out, obj.dic)
+        out.write('\n</props>\n')
+        if codec == 'text':
+            data = obj.get_data()
+            out.write('<data size="%d">%s</data>\n' % (len(data), esc(data)))
+        out.write('</stream>')
+        return
 
-  if isinstance(obj, PDFObjRef):
-    out.write('<ref id="%d"/>' % obj.objid)
-    return
+    if isinstance(obj, PDFObjRef):
+        out.write('<ref id="%d"/>' % obj.objid)
+        return
 
-  if isinstance(obj, PSKeyword):
-    out.write('<keyword>%s</keyword>' % obj.name)
-    return
+    if isinstance(obj, PSKeyword):
+        out.write('<keyword>%s</keyword>' % obj.name)
+        return
 
-  if isinstance(obj, PSLiteral):
-    out.write('<literal>%s</literal>' % obj.name)
-    return
+    if isinstance(obj, PSLiteral):
+        out.write('<literal>%s</literal>' % obj.name)
+        return
 
-  if isinstance(obj, int) or isinstance(obj, float):
-    out.write('<number>%s</number>' % obj)
-    return
+    if isinstance(obj, int) or isinstance(obj, float):
+        out.write('<number>%s</number>' % obj)
+        return
 
-  raise TypeError(obj)
+    raise TypeError(obj)
 
 # dumptrailers
 def dumptrailers(out, doc):
-  for xref in doc.xrefs:
-    out.write('<trailer>\n')
-    dumpxml(out, xref.trailer)
-    out.write('\n</trailer>\n\n')
-  return
+    for xref in doc.xrefs:
+        out.write('<trailer>\n')
+        dumpxml(out, xref.trailer)
+        out.write('\n</trailer>\n\n')
+    return
 
 # dumpallobjs
 def dumpallobjs(out, doc, codec=None):
-  out.write('<pdf>')
-  for xref in doc.xrefs:
-    for objid in xref.objids():
-      try:
-        obj = doc.getobj(objid)
-        if obj == None: continue
-        out.write('<object id="%d">\n' % objid)
-        dumpxml(out, obj, codec=codec)
-        out.write('\n</object>\n\n')
-      except:
-        raise
-  dumptrailers(out, doc)
-  out.write('</pdf>')
-  return
+    out.write('<pdf>')
+    for xref in doc.xrefs:
+        for objid in xref.objids():
+            try:
+                obj = doc.getobj(objid)
+                if obj == None: continue
+                out.write('<object id="%d">\n' % objid)
+                dumpxml(out, obj, codec=codec)
+                out.write('\n</object>\n\n')
+            except:
+                raise
+    dumptrailers(out, doc)
+    out.write('</pdf>')
+    return
 
 # dumpoutline
 def dumpoutline(outfp, fname, objids, pagenos, password='',
                 dumpall=False, codec=None):
-  doc = PDFDocument()
-  fp = file(fname, 'rb')
-  parser = PDFParser(doc, fp)
-  doc.initialize(password)
-  pages = dict( (page.pageid, pageno) for (pageno,page) in enumerate(doc.get_pages()) )
-  for (level,title,dest,a,se) in doc.get_outlines():
-    pageno = None
-    if dest:
-      dest = resolve1( doc.lookup_name('Dests', dest) )
-      if isinstance(dest, dict):
-        dest = dest['D']
-      pageno = pages[dest[0].objid]
-    outfp.write(repr((level,title,dest,pageno))+'\n')
-  parser.close()
-  fp.close()
-  return
+    doc = PDFDocument()
+    fp = file(fname, 'rb')
+    parser = PDFParser(doc, fp)
+    doc.initialize(password)
+    pages = dict( (page.pageid, pageno) for (pageno,page) in enumerate(doc.get_pages()) )
+    for (level,title,dest,a,se) in doc.get_outlines():
+        pageno = None
+        if dest:
+            dest = resolve1( doc.lookup_name('Dests', dest) )
+            if isinstance(dest, dict):
+                dest = dest['D']
+            pageno = pages[dest[0].objid]
+        outfp.write(repr((level,title,dest,pageno))+'\n')
+    parser.close()
+    fp.close()
+    return
 
 # dumppdf
 def dumppdf(outfp, fname, objids, pagenos, password='',
             dumpall=False, codec=None):
-  doc = PDFDocument()
-  fp = file(fname, 'rb')
-  parser = PDFParser(doc, fp)
-  doc.initialize(password)
-  if objids:
-    for objid in objids:
-      obj = doc.getobj(objid)
-      if isinstance(obj, PDFStream) and codec == 'raw':
-        outfp.write(obj.get_rawdata())
-      elif isinstance(obj, PDFStream) and codec == 'binary':
-        outfp.write(obj.get_data())
-      else:
-        dumpxml(outfp, obj, codec=codec)
-  if pagenos:
-    for (pageno,page) in enumerate(doc.get_pages()):
-      if pageno in pagenos:
-        dumpxml(outfp, page.attrs)
-  if dumpall:
-    dumpallobjs(outfp, doc, codec=codec)
-  if (not objids) and (not pagenos) and (not dumpall):
-    dumptrailers(outfp, doc)
-  fp.close()
-  if codec not in ('raw','binary'):
-    outfp.write('\n')
-  return
+    doc = PDFDocument()
+    fp = file(fname, 'rb')
+    parser = PDFParser(doc, fp)
+    doc.initialize(password)
+    if objids:
+        for objid in objids:
+            obj = doc.getobj(objid)
+            if isinstance(obj, PDFStream) and codec == 'raw':
+                outfp.write(obj.get_rawdata())
+            elif isinstance(obj, PDFStream) and codec == 'binary':
+                outfp.write(obj.get_data())
+            else:
+                dumpxml(outfp, obj, codec=codec)
+    if pagenos:
+        for (pageno,page) in enumerate(doc.get_pages()):
+            if pageno in pagenos:
+                dumpxml(outfp, page.attrs)
+    if dumpall:
+        dumpallobjs(outfp, doc, codec=codec)
+    if (not objids) and (not pagenos) and (not dumpall):
+        dumptrailers(outfp, doc)
+    fp.close()
+    if codec not in ('raw','binary'):
+        outfp.write('\n')
+    return
 
 
 # main
 def main(argv):
-  import getopt
-  def usage():
-    print 'usage: %s [-d] [-a] [-p pageid] [-P password] [-r|-b|-t] [-T] [-i objid] file ...' % argv[0]
-    return 100
-  try:
-    (opts, args) = getopt.getopt(argv[1:], 'dap:P:rbtTi:')
-  except getopt.GetoptError:
-    return usage()
-  if not args: return usage()
-  debug = 0
-  objids = []
-  pagenos = set()
-  codec = None
-  password = ''
-  dumpall = False
-  proc = dumppdf
-  outfp = sys.stdout
-  for (k, v) in opts:
-    if k == '-d': debug += 1
-    elif k == '-i': objids.extend( int(x) for x in v.split(',') )
-    elif k == '-p': pagenos.update( int(x)-1 for x in v.split(',') )
-    elif k == '-P': password = v
-    elif k == '-a': dumpall = True
-    elif k == '-r': codec = 'raw'
-    elif k == '-b': codec = 'binary'
-    elif k == '-t': codec = 'text'
-    elif k == '-T': proc = dumpoutline
-    elif k == '-o': outfp = file(v, 'wb')
-  #
-  PDFDocument.debug = debug
-  PDFParser.debug = debug
-  #
-  for fname in args:
-    proc(outfp, fname, objids, pagenos, password=password,
-         dumpall=dumpall, codec=codec)
-  return
+    import getopt
+    def usage():
+        print 'usage: %s [-d] [-a] [-p pageid] [-P password] [-r|-b|-t] [-T] [-i objid] file ...' % argv[0]
+        return 100
+    try:
+        (opts, args) = getopt.getopt(argv[1:], 'dap:P:rbtTi:')
+    except getopt.GetoptError:
+        return usage()
+    if not args: return usage()
+    debug = 0
+    objids = []
+    pagenos = set()
+    codec = None
+    password = ''
+    dumpall = False
+    proc = dumppdf
+    outfp = sys.stdout
+    for (k, v) in opts:
+        if k == '-d': debug += 1
+        elif k == '-i': objids.extend( int(x) for x in v.split(',') )
+        elif k == '-p': pagenos.update( int(x)-1 for x in v.split(',') )
+        elif k == '-P': password = v
+        elif k == '-a': dumpall = True
+        elif k == '-r': codec = 'raw'
+        elif k == '-b': codec = 'binary'
+        elif k == '-t': codec = 'text'
+        elif k == '-T': proc = dumpoutline
+        elif k == '-o': outfp = file(v, 'wb')
+    #
+    PDFDocument.debug = debug
+    PDFParser.debug = debug
+    #
+    for fname in args:
+        proc(outfp, fname, objids, pagenos, password=password,
+             dumpall=dumpall, codec=codec)
+    return
 
 if __name__ == '__main__': sys.exit(main(sys.argv))
diff --git a/tools/pdf2html.cgi b/tools/pdf2html.cgi
index 15f9ecc..68de31c 100755
--- a/tools/pdf2html.cgi
+++ b/tools/pdf2html.cgi
@@ -12,7 +12,7 @@
 #   $ mkdir CGIDIR
 #   $ mkdir CGIDIR/var
 #   $ cp -a pdfminer/pdflib CGIDIR
-#   $ PYTHONPATH=CGIDIR pdfminer/tools/pdf2html.cgi 
+#   $ PYTHONPATH=CGIDIR pdfminer/tools/pdf2html.cgi
 #
 
 import sys
@@ -27,16 +27,16 @@ from pdfminer.cmap import CMapDB
 
 # quote HTML metacharacters
 def q(x):
-  return x.replace('&','&amp;').replace('>','&gt;').replace('<','&lt;').replace('"','&quot;')
+    return x.replace('&','&amp;').replace('>','&gt;').replace('<','&lt;').replace('"','&quot;')
 
 # encode parameters as a URL
 Q = re.compile(r'[^a-zA-Z0-9_.-=]')
 def url(base, **kw):
-  r = []
-  for (k,v) in kw.iteritems():
-    v = Q.sub(lambda m: '%%%02X' % ord(m.group(0)), encoder(q(v), 'replace')[0])
-    r.append('%s=%s' % (k, v))
-  return base+'&'.join(r)
+    r = []
+    for (k,v) in kw.iteritems():
+        v = Q.sub(lambda m: '%%%02X' % ord(m.group(0)), encoder(q(v), 'replace')[0])
+        r.append('%s=%s' % (k, v))
+    return base+'&'.join(r)
 
 
 ##  convert
@@ -44,156 +44,156 @@ def url(base, **kw):
 class FileSizeExceeded(ValueError): pass
 def convert(outfp, infp, path, codec='utf-8', maxpages=10,
             maxfilesize=5000000, pagenos=None, html=True):
-  # save the input file.
-  src = file(path, 'wb')
-  nbytes = 0
-  while 1:
-    data = infp.read(4096)
-    nbytes += len(data)
-    if maxfilesize and maxfilesize < nbytes:
-      raise FileSizeExceeded(maxfilesize)
-    if not data: break
-    src.write(data)
-  src.close()
-  infp.close()
-  # perform conversion and
-  # send the results over the network.
-  CMapDB.initialize()
-  rsrc = PDFResourceManager()
-  laparams = LAParams()
-  if html:
-    device = HTMLConverter(rsrc, outfp, codec=codec, laparams=laparams)
-  else:
-    device = TextConverter(rsrc, outfp, codec=codec, laparams=laparams)
-  fp = file(path, 'rb')
-  process_pdf(rsrc, device, fp, pagenos, maxpages=maxpages)
-  fp.close()
-  return
+    # save the input file.
+    src = file(path, 'wb')
+    nbytes = 0
+    while 1:
+        data = infp.read(4096)
+        nbytes += len(data)
+        if maxfilesize and maxfilesize < nbytes:
+            raise FileSizeExceeded(maxfilesize)
+        if not data: break
+        src.write(data)
+    src.close()
+    infp.close()
+    # perform conversion and
+    # send the results over the network.
+    CMapDB.initialize()
+    rsrc = PDFResourceManager()
+    laparams = LAParams()
+    if html:
+        device = HTMLConverter(rsrc, outfp, codec=codec, laparams=laparams)
+    else:
+        device = TextConverter(rsrc, outfp, codec=codec, laparams=laparams)
+    fp = file(path, 'rb')
+    process_pdf(rsrc, device, fp, pagenos, maxpages=maxpages)
+    fp.close()
+    return
 
 
 ##  PDF2HTMLApp
 ##
 class PDF2HTMLApp(object):
 
-  APPURL = '/convert'
-  TMPDIR = './var/'
-  LOGPATH = './var/log'
-  MAXFILESIZE = 5000000
-  MAXPAGES = 10
-  
-  def __init__(self, outfp, logpath=LOGPATH, loglevel=logging.DEBUG, codec='utf-8'):
-    self.outfp = outfp
-    self.codec = codec
-    logging.basicConfig(format='%(asctime)s %(levelname)s %(message)s', 
-                        level=loglevel, filename=logpath, filemode='a')
-    self.remote_addr = os.environ.get('REMOTE_ADDR')
-    self.path_info = os.environ.get('PATH_INFO')
-    self.method = os.environ.get('REQUEST_METHOD', 'GET')
-    self.server = os.environ.get('SERVER_SOFTWARE', '')
-    self.content_type = 'text/html; charset=%s' % codec
-    self.cur_time = time.time()
-    self.form = cgi.FieldStorage()
-    return
+    APPURL = '/convert'
+    TMPDIR = './var/'
+    LOGPATH = './var/log'
+    MAXFILESIZE = 5000000
+    MAXPAGES = 10
 
-  def put(self, *args):
-    for x in args:
-      if isinstance(x, str):
-        self.outfp.write(x)
-      elif isinstance(x, unicode):
-        self.outfp.write(x.encode(self.codec, 'xmlcharrefreplace'))
-    return
+    def __init__(self, outfp, logpath=LOGPATH, loglevel=logging.DEBUG, codec='utf-8'):
+        self.outfp = outfp
+        self.codec = codec
+        logging.basicConfig(format='%(asctime)s %(levelname)s %(message)s',
+                            level=loglevel, filename=logpath, filemode='a')
+        self.remote_addr = os.environ.get('REMOTE_ADDR')
+        self.path_info = os.environ.get('PATH_INFO')
+        self.method = os.environ.get('REQUEST_METHOD', 'GET')
+        self.server = os.environ.get('SERVER_SOFTWARE', '')
+        self.content_type = 'text/html; charset=%s' % codec
+        self.cur_time = time.time()
+        self.form = cgi.FieldStorage()
+        return
 
-  def http_200(self):
-    if self.server.startswith('cgi-httpd'):
-      # required for cgi-httpd
-      self.outfp.write('HTTP/1.0 200 OK\r\n')
-    self.outfp.write('Content-type: %s\r\n' % self.content_type)
-    self.outfp.write('Connection: close\r\n\r\n')
-    return
-  
-  def http_404(self):
-    if self.server.startswith('cgi-httpd'):
-      # required for cgi-httpd
-      self.outfp.write('HTTP/1.0 404 Not Found\r\n')
-    self.outfp.write('Content-type: text/html\r\n')
-    self.outfp.write('Connection: close\r\n\r\n')
-    self.outfp.write('<html><body>page does not exist</body></body>\n')
-    return
-  
-  def http_301(self, url):
-    if self.server.startswith('cgi-httpd'):
-      # required for cgi-httpd
-      self.outfp.write('HTTP/1.0 301 Moved\r\n')
-    self.outfp.write('Location: %s\r\n\r\n' % url)
-    return
+    def put(self, *args):
+        for x in args:
+            if isinstance(x, str):
+                self.outfp.write(x)
+            elif isinstance(x, unicode):
+                self.outfp.write(x.encode(self.codec, 'xmlcharrefreplace'))
+        return
 
-  def coverpage(self):
-    self.put(
-      '<html><head><title>pdf2html demo</title></head><body>\n',
-      '<h1>pdf2html demo</h1><hr>\n',
-      '<form method="POST" action="%s" enctype="multipart/form-data">\n' % q(self.APPURL),
-      '<p>Upload PDF File: <input name="f" type="file" value="">\n',
-      '&nbsp; Page numbers (comma-separated): <input name="p" type="text" size="10" value="">\n',
-      '<p>(Text extraction is limited to maximum %d pages.\n' % self.MAXPAGES,
-      'Maximum file size for input is %d bytes.)\n' % self.MAXFILESIZE,
-      '<p><input type="submit" name="c" value="Convert to HTML">\n',
-      '<input type="submit" name="c" value="Convert to TEXT">\n',
-      '<input type="reset" value="Reset">\n',
-      '</form><hr>\n',
-      '<p>Powered by <a href="http://www.unixuser.org/~euske/python/pdfminer/">PDFMiner</a>\n',
-      '</body></html>\n',
-      )
-    return
+    def http_200(self):
+        if self.server.startswith('cgi-httpd'):
+            # required for cgi-httpd
+            self.outfp.write('HTTP/1.0 200 OK\r\n')
+        self.outfp.write('Content-type: %s\r\n' % self.content_type)
+        self.outfp.write('Connection: close\r\n\r\n')
+        return
 
-  def run(self, argv):
-    if self.path_info == '/':
-      self.http_200()
-      self.coverpage()
-      return
-    if self.path_info != self.APPURL:
-      self.http_404()
-      return
-    if not os.path.isdir(self.TMPDIR):
-      self.bummer('error')
-      return
-    if 'f' not in self.form:
-      self.http_301('/')
-      return
-    if 'c' not in self.form:
-      self.http_301('/')
-      return
-    item = self.form['f']
-    if not (item.file and item.filename):
-      self.http_301('/')
-      return
-    cmd = self.form.getvalue('c')
-    html = (cmd == 'Convert to HTML')
-    pagenos = []
-    if 'p' in self.form:
-      for m in re.finditer(r'\d+', self.form.getvalue('p')):
+    def http_404(self):
+        if self.server.startswith('cgi-httpd'):
+            # required for cgi-httpd
+            self.outfp.write('HTTP/1.0 404 Not Found\r\n')
+        self.outfp.write('Content-type: text/html\r\n')
+        self.outfp.write('Connection: close\r\n\r\n')
+        self.outfp.write('<html><body>page does not exist</body></body>\n')
+        return
+
+    def http_301(self, url):
+        if self.server.startswith('cgi-httpd'):
+            # required for cgi-httpd
+            self.outfp.write('HTTP/1.0 301 Moved\r\n')
+        self.outfp.write('Location: %s\r\n\r\n' % url)
+        return
+
+    def coverpage(self):
+        self.put(
+          '<html><head><title>pdf2html demo</title></head><body>\n',
+          '<h1>pdf2html demo</h1><hr>\n',
+          '<form method="POST" action="%s" enctype="multipart/form-data">\n' % q(self.APPURL),
+          '<p>Upload PDF File: <input name="f" type="file" value="">\n',
+          '&nbsp; Page numbers (comma-separated): <input name="p" type="text" size="10" value="">\n',
+          '<p>(Text extraction is limited to maximum %d pages.\n' % self.MAXPAGES,
+          'Maximum file size for input is %d bytes.)\n' % self.MAXFILESIZE,
+          '<p><input type="submit" name="c" value="Convert to HTML">\n',
+          '<input type="submit" name="c" value="Convert to TEXT">\n',
+          '<input type="reset" value="Reset">\n',
+          '</form><hr>\n',
+          '<p>Powered by <a href="http://www.unixuser.org/~euske/python/pdfminer/">PDFMiner</a>\n',
+          '</body></html>\n',
+          )
+        return
+
+    def run(self, argv):
+        if self.path_info == '/':
+            self.http_200()
+            self.coverpage()
+            return
+        if self.path_info != self.APPURL:
+            self.http_404()
+            return
+        if not os.path.isdir(self.TMPDIR):
+            self.bummer('error')
+            return
+        if 'f' not in self.form:
+            self.http_301('/')
+            return
+        if 'c' not in self.form:
+            self.http_301('/')
+            return
+        item = self.form['f']
+        if not (item.file and item.filename):
+            self.http_301('/')
+            return
+        cmd = self.form.getvalue('c')
+        html = (cmd == 'Convert to HTML')
+        pagenos = []
+        if 'p' in self.form:
+            for m in re.finditer(r'\d+', self.form.getvalue('p')):
+                try:
+                    pagenos.append(int(m.group(0)))
+                except ValueError:
+                    pass
+        logging.info('process: host=%s, name=%r, pagenos=%r' % (self.remote_addr, item.filename, pagenos))
+        h = abs(hash((random.random(), self.remote_addr, item.filename)))
+        tmppath = os.path.join(self.TMPDIR, '%08x%08x.pdf' % (self.cur_time, h))
         try:
-          pagenos.append(int(m.group(0)))
-        except ValueError:
-          pass
-    logging.info('process: host=%s, name=%r, pagenos=%r' % (self.remote_addr, item.filename, pagenos))
-    h = abs(hash((random.random(), self.remote_addr, item.filename)))
-    tmppath = os.path.join(self.TMPDIR, '%08x%08x.pdf' % (self.cur_time, h))
-    try:
-      try:
-        if not html:
-          self.content_type = 'text/plain; charset=%s' % self.codec
-        self.http_200()
-        convert(sys.stdout, item.file, tmppath, pagenos=pagenos, codec=self.codec,
-                maxpages=self.MAXPAGES, maxfilesize=self.MAXFILESIZE, html=html)
-      except Exception, e:
-        self.put('<p>Sorry, an error has occured: %s' % q(repr(e)))
-        logging.error('error: %r: path=%r: %s' % (e, tmppath, traceback.format_exc()))
-    finally:
-      try:
-        os.remove(tmppath)
-      except:
-        pass
-    return
+            try:
+                if not html:
+                    self.content_type = 'text/plain; charset=%s' % self.codec
+                self.http_200()
+                convert(sys.stdout, item.file, tmppath, pagenos=pagenos, codec=self.codec,
+                        maxpages=self.MAXPAGES, maxfilesize=self.MAXFILESIZE, html=html)
+            except Exception, e:
+                self.put('<p>Sorry, an error has occured: %s' % q(repr(e)))
+                logging.error('error: %r: path=%r: %s' % (e, tmppath, traceback.format_exc()))
+        finally:
+            try:
+                os.remove(tmppath)
+            except:
+                pass
+        return
 
 
 # main
diff --git a/tools/pdf2txt.py b/tools/pdf2txt.py
index 006e8ce..d61676f 100755
--- a/tools/pdf2txt.py
+++ b/tools/pdf2txt.py
@@ -9,85 +9,85 @@ from pdfminer.layout import LAParams
 
 # main
 def main(argv):
-  import getopt
-  def usage():
-    print ('usage: %s [-d] [-p pagenos] [-P password] [-c codec] '
-           '[-D direction] [-M char_margin] [-L line_margin] [-W word_margin] '
-           '[-t text|html|sgml|tag] [-o output] file ...' % argv[0])
-    return 100
-  try:
-    (opts, args) = getopt.getopt(argv[1:], 'dp:P:c:D:M:L:W:t:o:C:D:m:')
-  except getopt.GetoptError:
-    return usage()
-  if not args: return usage()
-  # debug option
-  debug = 0
-  # path option
-  cmapdir = find_cmap_path()
-  # input option
-  password = ''
-  pagenos = set()
-  maxpages = 0
-  # output option
-  outfile = None
-  outtype = None
-  codec = 'utf-8'
-  pageno = 1
-  scale = 1
-  showpageno = True
-  laparams = LAParams()
-  for (k, v) in opts:
-    if k == '-d': debug += 1
-    elif k == '-C': cmapdir = v
-    elif k == '-P': password = v
-    elif k == '-p': pagenos.update( int(x)-1 for x in v.split(',') )
-    elif k == '-m': maxpages = int(v)
-    elif k == '-t': outtype = v
-    elif k == '-c': codec = v
-    elif k == '-o': outfile = v
-    elif k == '-s': scale = float(v)
-    elif k == '-D': laparams.direction = v
-    elif k == '-M': laparams.char_margin = float(v)
-    elif k == '-L': laparams.line_margin = float(v)
-    elif k == '-W': laparams.word_margin = float(v)
-  #
-  CMapDB.debug = debug
-  PDFResourceManager.debug = debug
-  PDFDocument.debug = debug
-  PDFParser.debug = debug
-  PDFPageInterpreter.debug = debug
-  PDFDevice.debug = debug
-  #
-  CMapDB.initialize(cmapdir)
-  rsrc = PDFResourceManager()
-  if not outtype:
-    outtype = 'text'
+    import getopt
+    def usage():
+        print ('usage: %s [-d] [-p pagenos] [-P password] [-c codec] '
+               '[-D direction] [-M char_margin] [-L line_margin] [-W word_margin] '
+               '[-t text|html|sgml|tag] [-o output] file ...' % argv[0])
+        return 100
+    try:
+        (opts, args) = getopt.getopt(argv[1:], 'dp:P:c:D:M:L:W:t:o:C:D:m:')
+    except getopt.GetoptError:
+        return usage()
+    if not args: return usage()
+    # debug option
+    debug = 0
+    # path option
+    cmapdir = find_cmap_path()
+    # input option
+    password = ''
+    pagenos = set()
+    maxpages = 0
+    # output option
+    outfile = None
+    outtype = None
+    codec = 'utf-8'
+    pageno = 1
+    scale = 1
+    showpageno = True
+    laparams = LAParams()
+    for (k, v) in opts:
+        if k == '-d': debug += 1
+        elif k == '-C': cmapdir = v
+        elif k == '-P': password = v
+        elif k == '-p': pagenos.update( int(x)-1 for x in v.split(',') )
+        elif k == '-m': maxpages = int(v)
+        elif k == '-t': outtype = v
+        elif k == '-c': codec = v
+        elif k == '-o': outfile = v
+        elif k == '-s': scale = float(v)
+        elif k == '-D': laparams.direction = v
+        elif k == '-M': laparams.char_margin = float(v)
+        elif k == '-L': laparams.line_margin = float(v)
+        elif k == '-W': laparams.word_margin = float(v)
+    #
+    CMapDB.debug = debug
+    PDFResourceManager.debug = debug
+    PDFDocument.debug = debug
+    PDFParser.debug = debug
+    PDFPageInterpreter.debug = debug
+    PDFDevice.debug = debug
+    #
+    CMapDB.initialize(cmapdir)
+    rsrc = PDFResourceManager()
+    if not outtype:
+        outtype = 'text'
+        if outfile:
+            if outfile.endswith('.htm') or outfile.endswith('.html'):
+                outtype = 'html'
+            elif outfile.endswith('.sgml'):
+                outtype = 'sgml'
+            elif outfile.endswith('.tag'):
+                outtype = 'tag'
     if outfile:
-      if outfile.endswith('.htm') or outfile.endswith('.html'):
-        outtype = 'html'
-      elif outfile.endswith('.sgml'):
-        outtype = 'sgml'
-      elif outfile.endswith('.tag'):
-        outtype = 'tag'
-  if outfile:
-    outfp = file(outfile, 'w')
-  else:
-    outfp = sys.stdout
-  if outtype == 'text':
-    device = TextConverter(rsrc, outfp, codec=codec, laparams=laparams)
-  elif outtype == 'sgml':
-    device = SGMLConverter(rsrc, outfp, codec=codec, laparams=laparams)
-  elif outtype == 'html':
-    device = HTMLConverter(rsrc, outfp, codec=codec, scale=scale, laparams=laparams)
-  elif outtype == 'tag':
-    device = TagExtractor(rsrc, outfp, codec=codec)
-  else:
-    return usage()
-  for fname in args:
-    fp = file(fname, 'rb')
-    process_pdf(rsrc, device, fp, pagenos, maxpages=maxpages, password=password)
-    fp.close()
-  device.close()
-  return
+        outfp = file(outfile, 'w')
+    else:
+        outfp = sys.stdout
+    if outtype == 'text':
+        device = TextConverter(rsrc, outfp, codec=codec, laparams=laparams)
+    elif outtype == 'sgml':
+        device = SGMLConverter(rsrc, outfp, codec=codec, laparams=laparams)
+    elif outtype == 'html':
+        device = HTMLConverter(rsrc, outfp, codec=codec, scale=scale, laparams=laparams)
+    elif outtype == 'tag':
+        device = TagExtractor(rsrc, outfp, codec=codec)
+    else:
+        return usage()
+    for fname in args:
+        fp = file(fname, 'rb')
+        process_pdf(rsrc, device, fp, pagenos, maxpages=maxpages, password=password)
+        fp.close()
+    device.close()
+    return
 
 if __name__ == '__main__': sys.exit(main(sys.argv))
diff --git a/tools/prof.py b/tools/prof.py
index 4041228..ae5d596 100644
--- a/tools/prof.py
+++ b/tools/prof.py
@@ -2,29 +2,29 @@
 import sys
 
 def prof_main(argv):
-  import getopt
-  import hotshot, hotshot.stats
-  def usage():
-    print 'usage: %s module.function [args ...]' % argv[0]
-    return 100
-  args = argv[1:]
-  if len(args) < 1: return usage()
-  name = args.pop(0)
-  prof = name+'.prof'
-  i = name.rindex('.')
-  (modname, funcname) = (name[:i], name[i+1:])
-  module = __import__(modname, fromlist=1)
-  func = getattr(module, funcname)
-  if args:
-    args.insert(0, argv[0])
-    prof = hotshot.Profile(prof)
-    prof.runcall(lambda : func(args))
-    prof.close()
-  else:
-    stats = hotshot.stats.load(prof)
-    stats.strip_dirs()
-    stats.sort_stats('time', 'calls')
-    stats.print_stats(1000)
-  return
-  
+    import getopt
+    import hotshot, hotshot.stats
+    def usage():
+        print 'usage: %s module.function [args ...]' % argv[0]
+        return 100
+    args = argv[1:]
+    if len(args) < 1: return usage()
+    name = args.pop(0)
+    prof = name+'.prof'
+    i = name.rindex('.')
+    (modname, funcname) = (name[:i], name[i+1:])
+    module = __import__(modname, fromlist=1)
+    func = getattr(module, funcname)
+    if args:
+        args.insert(0, argv[0])
+        prof = hotshot.Profile(prof)
+        prof.runcall(lambda : func(args))
+        prof.close()
+    else:
+        stats = hotshot.stats.load(prof)
+        stats.strip_dirs()
+        stats.sort_stats('time', 'calls')
+        stats.print_stats(1000)
+    return
+
 if __name__ == '__main__': sys.exit(prof_main(sys.argv))