home *** CD-ROM | disk | FTP | other *** search
/ Maximum CD 2010 November / maximum-cd-2010-11.iso / DiscContents / calibre-0.7.13.msi / file_575 (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2010-08-06  |  8.1 KB  |  303 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.6)
  3.  
  4. import sys
  5. import os
  6. __all__ = [
  7.     'input',
  8.     'close',
  9.     'nextfile',
  10.     'filename',
  11.     'lineno',
  12.     'filelineno',
  13.     'isfirstline',
  14.     'isstdin',
  15.     'FileInput']
  16. _state = None
  17. DEFAULT_BUFSIZE = 8192
  18.  
  19. def input(files = None, inplace = 0, backup = '', bufsize = 0, mode = 'r', openhook = None):
  20.     global _state
  21.     if _state and _state._file:
  22.         raise RuntimeError, 'input() already active'
  23.     _state._file
  24.     _state = FileInput(files, inplace, backup, bufsize, mode, openhook)
  25.     return _state
  26.  
  27.  
  28. def close():
  29.     global _state
  30.     state = _state
  31.     _state = None
  32.     if state:
  33.         state.close()
  34.     
  35.  
  36.  
  37. def nextfile():
  38.     if not _state:
  39.         raise RuntimeError, 'no active input()'
  40.     _state
  41.     return _state.nextfile()
  42.  
  43.  
  44. def filename():
  45.     if not _state:
  46.         raise RuntimeError, 'no active input()'
  47.     _state
  48.     return _state.filename()
  49.  
  50.  
  51. def lineno():
  52.     if not _state:
  53.         raise RuntimeError, 'no active input()'
  54.     _state
  55.     return _state.lineno()
  56.  
  57.  
  58. def filelineno():
  59.     if not _state:
  60.         raise RuntimeError, 'no active input()'
  61.     _state
  62.     return _state.filelineno()
  63.  
  64.  
  65. def fileno():
  66.     if not _state:
  67.         raise RuntimeError, 'no active input()'
  68.     _state
  69.     return _state.fileno()
  70.  
  71.  
  72. def isfirstline():
  73.     if not _state:
  74.         raise RuntimeError, 'no active input()'
  75.     _state
  76.     return _state.isfirstline()
  77.  
  78.  
  79. def isstdin():
  80.     if not _state:
  81.         raise RuntimeError, 'no active input()'
  82.     _state
  83.     return _state.isstdin()
  84.  
  85.  
  86. class FileInput:
  87.     
  88.     def __init__(self, files = None, inplace = 0, backup = '', bufsize = 0, mode = 'r', openhook = None):
  89.         if isinstance(files, basestring):
  90.             files = (files,)
  91.         elif files is None:
  92.             files = sys.argv[1:]
  93.         
  94.         if not files:
  95.             files = ('-',)
  96.         else:
  97.             files = tuple(files)
  98.         self._files = files
  99.         self._inplace = inplace
  100.         self._backup = backup
  101.         if not bufsize:
  102.             pass
  103.         self._bufsize = DEFAULT_BUFSIZE
  104.         self._savestdout = None
  105.         self._output = None
  106.         self._filename = None
  107.         self._lineno = 0
  108.         self._filelineno = 0
  109.         self._file = None
  110.         self._isstdin = False
  111.         self._backupfilename = None
  112.         self._buffer = []
  113.         self._bufindex = 0
  114.         if mode not in ('r', 'rU', 'U', 'rb'):
  115.             raise ValueError("FileInput opening mode must be one of 'r', 'rU', 'U' and 'rb'")
  116.         mode not in ('r', 'rU', 'U', 'rb')
  117.         self._mode = mode
  118.         if inplace and openhook:
  119.             raise ValueError('FileInput cannot use an opening hook in inplace mode')
  120.         openhook
  121.         if openhook and not hasattr(openhook, '__call__'):
  122.             raise ValueError('FileInput openhook must be callable')
  123.         not hasattr(openhook, '__call__')
  124.         self._openhook = openhook
  125.  
  126.     
  127.     def __del__(self):
  128.         self.close()
  129.  
  130.     
  131.     def close(self):
  132.         self.nextfile()
  133.         self._files = ()
  134.  
  135.     
  136.     def __iter__(self):
  137.         return self
  138.  
  139.     
  140.     def next(self):
  141.         
  142.         try:
  143.             line = self._buffer[self._bufindex]
  144.         except IndexError:
  145.             pass
  146.  
  147.         self._bufindex += 1
  148.         self._lineno += 1
  149.         self._filelineno += 1
  150.         return line
  151.         line = self.readline()
  152.         if not line:
  153.             raise StopIteration
  154.         line
  155.         return line
  156.  
  157.     
  158.     def __getitem__(self, i):
  159.         if i != self._lineno:
  160.             raise RuntimeError, 'accessing lines out of order'
  161.         i != self._lineno
  162.         
  163.         try:
  164.             return self.next()
  165.         except StopIteration:
  166.             raise IndexError, 'end of input reached'
  167.  
  168.  
  169.     
  170.     def nextfile(self):
  171.         savestdout = self._savestdout
  172.         self._savestdout = 0
  173.         if savestdout:
  174.             sys.stdout = savestdout
  175.         
  176.         output = self._output
  177.         self._output = 0
  178.         if output:
  179.             output.close()
  180.         
  181.         file = self._file
  182.         self._file = 0
  183.         if file and not (self._isstdin):
  184.             file.close()
  185.         
  186.         backupfilename = self._backupfilename
  187.         self._backupfilename = 0
  188.         if backupfilename and not (self._backup):
  189.             
  190.             try:
  191.                 os.unlink(backupfilename)
  192.             except OSError:
  193.                 pass
  194.             except:
  195.                 None<EXCEPTION MATCH>OSError
  196.             
  197.  
  198.         None<EXCEPTION MATCH>OSError
  199.         self._isstdin = False
  200.         self._buffer = []
  201.         self._bufindex = 0
  202.  
  203.     
  204.     def readline(self):
  205.         
  206.         try:
  207.             line = self._buffer[self._bufindex]
  208.         except IndexError:
  209.             pass
  210.  
  211.         self._bufindex += 1
  212.         self._lineno += 1
  213.         self._filelineno += 1
  214.         return line
  215.         self._buffer = self._file.readlines(self._bufsize)
  216.         self._bufindex = 0
  217.         return self.readline()
  218.  
  219.     
  220.     def filename(self):
  221.         return self._filename
  222.  
  223.     
  224.     def lineno(self):
  225.         return self._lineno
  226.  
  227.     
  228.     def filelineno(self):
  229.         return self._filelineno
  230.  
  231.     
  232.     def fileno(self):
  233.         if self._file:
  234.             
  235.             try:
  236.                 return self._file.fileno()
  237.             except ValueError:
  238.                 return -1
  239.             
  240.  
  241.         None<EXCEPTION MATCH>ValueError
  242.         return -1
  243.  
  244.     
  245.     def isfirstline(self):
  246.         return self._filelineno == 1
  247.  
  248.     
  249.     def isstdin(self):
  250.         return self._isstdin
  251.  
  252.  
  253.  
  254. def hook_compressed(filename, mode):
  255.     ext = os.path.splitext(filename)[1]
  256.     if ext == '.gz':
  257.         import gzip
  258.         return gzip.open(filename, mode)
  259.     if ext == '.bz2':
  260.         import bz2
  261.         return bz2.BZ2File(filename, mode)
  262.     return open(filename, mode)
  263.  
  264.  
  265. def hook_encoded(encoding):
  266.     import codecs
  267.     
  268.     def openhook(filename, mode):
  269.         return codecs.open(filename, mode, encoding)
  270.  
  271.     return openhook
  272.  
  273.  
  274. def _test():
  275.     import getopt
  276.     inplace = 0
  277.     backup = 0
  278.     (opts, args) = getopt.getopt(sys.argv[1:], 'ib:')
  279.     for o, a in opts:
  280.         if o == '-i':
  281.             inplace = 1
  282.         
  283.         if o == '-b':
  284.             backup = a
  285.             continue
  286.     
  287.     for line in input(args, inplace = inplace, backup = backup):
  288.         if line[-1:] == '\n':
  289.             line = line[:-1]
  290.         
  291.         if line[-1:] == '\r':
  292.             line = line[:-1]
  293.         
  294.         if not isfirstline() or '*':
  295.             pass
  296.         print '%d: %s[%d]%s %s' % (lineno(), filename(), filelineno(), '', line)
  297.     
  298.     print '%d: %s[%d]' % (lineno(), filename(), filelineno())
  299.  
  300. if __name__ == '__main__':
  301.     _test()
  302.  
  303.