home *** CD-ROM | disk | FTP | other *** search
/ Freelog 116 / FreelogNo116-JuilletSeptembre2013.iso / Bureautique / gImageReader / gimagereader_0.9-1_win32.exe / bin / distutils / text_file.pyc (.txt) < prev    next >
Python Compiled Bytecode  |  2011-03-24  |  9KB  |  238 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.7)
  3.  
  4. '''text_file
  5.  
  6. provides the TextFile class, which gives an interface to text files
  7. that (optionally) takes care of stripping comments, ignoring blank
  8. lines, and joining lines with backslashes.'''
  9. __revision__ = '$Id: text_file.py 76956 2009-12-21 01:22:46Z tarek.ziade $'
  10. import sys
  11.  
  12. class TextFile:
  13.     '''Provides a file-like object that takes care of all the things you
  14.        commonly want to do when processing a text file that has some
  15.        line-by-line syntax: strip comments (as long as "#" is your
  16.        comment character), skip blank lines, join adjacent lines by
  17.        escaping the newline (ie. backslash at end of line), strip
  18.        leading and/or trailing whitespace.  All of these are optional
  19.        and independently controllable.
  20.  
  21.        Provides a \'warn()\' method so you can generate warning messages that
  22.        report physical line number, even if the logical line in question
  23.        spans multiple physical lines.  Also provides \'unreadline()\' for
  24.        implementing line-at-a-time lookahead.
  25.  
  26.        Constructor is called as:
  27.  
  28.            TextFile (filename=None, file=None, **options)
  29.  
  30.        It bombs (RuntimeError) if both \'filename\' and \'file\' are None;
  31.        \'filename\' should be a string, and \'file\' a file object (or
  32.        something that provides \'readline()\' and \'close()\' methods).  It is
  33.        recommended that you supply at least \'filename\', so that TextFile
  34.        can include it in warning messages.  If \'file\' is not supplied,
  35.        TextFile creates its own using the \'open()\' builtin.
  36.  
  37.        The options are all boolean, and affect the value returned by
  38.        \'readline()\':
  39.          strip_comments [default: true]
  40.            strip from "#" to end-of-line, as well as any whitespace
  41.            leading up to the "#" -- unless it is escaped by a backslash
  42.          lstrip_ws [default: false]
  43.            strip leading whitespace from each line before returning it
  44.          rstrip_ws [default: true]
  45.            strip trailing whitespace (including line terminator!) from
  46.            each line before returning it
  47.          skip_blanks [default: true}
  48.            skip lines that are empty *after* stripping comments and
  49.            whitespace.  (If both lstrip_ws and rstrip_ws are false,
  50.            then some lines may consist of solely whitespace: these will
  51.            *not* be skipped, even if \'skip_blanks\' is true.)
  52.          join_lines [default: false]
  53.            if a backslash is the last non-newline character on a line
  54.            after stripping comments and whitespace, join the following line
  55.            to it to form one "logical line"; if N consecutive lines end
  56.            with a backslash, then N+1 physical lines will be joined to
  57.            form one logical line.
  58.          collapse_join [default: false]
  59.            strip leading whitespace from lines that are joined to their
  60.            predecessor; only matters if (join_lines and not lstrip_ws)
  61.  
  62.        Note that since \'rstrip_ws\' can strip the trailing newline, the
  63.        semantics of \'readline()\' must differ from those of the builtin file
  64.        object\'s \'readline()\' method!  In particular, \'readline()\' returns
  65.        None for end-of-file: an empty string might just be a blank line (or
  66.        an all-whitespace line), if \'rstrip_ws\' is true but \'skip_blanks\' is
  67.        not.'''
  68.     default_options = {
  69.         'strip_comments': 1,
  70.         'skip_blanks': 1,
  71.         'lstrip_ws': 0,
  72.         'rstrip_ws': 1,
  73.         'join_lines': 0,
  74.         'collapse_join': 0 }
  75.     
  76.     def __init__(self, filename = None, file = None, **options):
  77.         """Construct a new TextFile object.  At least one of 'filename'
  78.            (a string) and 'file' (a file-like object) must be supplied.
  79.            They keyword argument options are described above and affect
  80.            the values returned by 'readline()'."""
  81.         if filename is None and file is None:
  82.             raise RuntimeError, "you must supply either or both of 'filename' and 'file'"
  83.         for opt in self.default_options.keys():
  84.             if opt in options:
  85.                 setattr(self, opt, options[opt])
  86.                 continue
  87.             setattr(self, opt, self.default_options[opt])
  88.         
  89.         for opt in options.keys():
  90.             if opt not in self.default_options:
  91.                 raise KeyError, "invalid TextFile option '%s'" % opt
  92.         
  93.         if file is None:
  94.             self.open(filename)
  95.         else:
  96.             self.filename = filename
  97.             self.file = file
  98.             self.current_line = 0
  99.         self.linebuf = []
  100.  
  101.     
  102.     def open(self, filename):
  103.         """Open a new file named 'filename'.  This overrides both the
  104.            'filename' and 'file' arguments to the constructor."""
  105.         self.filename = filename
  106.         self.file = open(self.filename, 'r')
  107.         self.current_line = 0
  108.  
  109.     
  110.     def close(self):
  111.         '''Close the current file and forget everything we know about it
  112.            (filename, current line number).'''
  113.         self.file.close()
  114.         self.file = None
  115.         self.filename = None
  116.         self.current_line = None
  117.  
  118.     
  119.     def gen_error(self, msg, line = None):
  120.         outmsg = []
  121.         if line is None:
  122.             line = self.current_line
  123.         outmsg.append(self.filename + ', ')
  124.         if isinstance(line, (list, tuple)):
  125.             outmsg.append('lines %d-%d: ' % tuple(line))
  126.         else:
  127.             outmsg.append('line %d: ' % line)
  128.         outmsg.append(str(msg))
  129.         return ''.join(outmsg)
  130.  
  131.     
  132.     def error(self, msg, line = None):
  133.         raise ValueError, 'error: ' + self.gen_error(msg, line)
  134.  
  135.     
  136.     def warn(self, msg, line = None):
  137.         '''Print (to stderr) a warning message tied to the current logical
  138.            line in the current file.  If the current logical line in the
  139.            file spans multiple physical lines, the warning refers to the
  140.            whole range, eg. "lines 3-5".  If \'line\' supplied, it overrides
  141.            the current line number; it may be a list or tuple to indicate a
  142.            range of physical lines, or an integer for a single physical
  143.            line.'''
  144.         sys.stderr.write('warning: ' + self.gen_error(msg, line) + '\n')
  145.  
  146.     
  147.     def readline(self):
  148.         '''Read and return a single logical line from the current file (or
  149.            from an internal buffer if lines have previously been "unread"
  150.            with \'unreadline()\').  If the \'join_lines\' option is true, this
  151.            may involve reading multiple physical lines concatenated into a
  152.            single string.  Updates the current line number, so calling
  153.            \'warn()\' after \'readline()\' emits a warning about the physical
  154.            line(s) just read.  Returns None on end-of-file, since the empty
  155.            string can occur if \'rstrip_ws\' is true but \'strip_blanks\' is
  156.            not.'''
  157.         if self.linebuf:
  158.             line = self.linebuf[-1]
  159.             del self.linebuf[-1]
  160.             return line
  161.         buildup_line = None
  162.         while None:
  163.             line = self.file.readline()
  164.             if line == '':
  165.                 line = None
  166.             if self.strip_comments and line:
  167.                 pos = line.find('#')
  168.                 if pos == -1:
  169.                     pass
  170.                 elif pos == 0 or line[pos - 1] != '\\':
  171.                     if not line[-1] == '\n' or '\n':
  172.                         pass
  173.                     eol = ''
  174.                     line = line[0:pos] + eol
  175.                     if line.strip() == '':
  176.                         continue
  177.                     
  178.                 else:
  179.                     line = line.replace('\\#', '#')
  180.             if self.join_lines and buildup_line:
  181.                 if line is None:
  182.                     self.warn('continuation line immediately precedes end-of-file')
  183.                     return buildup_line
  184.                 if None.collapse_join:
  185.                     line = line.lstrip()
  186.                 line = buildup_line + line
  187.                 if isinstance(self.current_line, list):
  188.                     self.current_line[1] = self.current_line[1] + 1
  189.                 else:
  190.                     self.current_line = [
  191.                         self.current_line,
  192.                         self.current_line + 1]
  193.             elif line is None:
  194.                 return None
  195.             if isinstance(self.current_line, list):
  196.                 self.current_line = self.current_line[1] + 1
  197.             else:
  198.                 self.current_line = self.current_line + 1
  199.             if self.lstrip_ws and self.rstrip_ws:
  200.                 line = line.strip()
  201.             elif self.lstrip_ws:
  202.                 line = line.lstrip()
  203.             elif self.rstrip_ws:
  204.                 line = line.rstrip()
  205.             if (line == '' or line == '\n') and self.skip_blanks:
  206.                 continue
  207.             if self.join_lines:
  208.                 if line[-1] == '\\':
  209.                     buildup_line = line[:-1]
  210.                     continue
  211.                 if line[-2:] == '\\\n':
  212.                     buildup_line = line[0:-2] + '\n'
  213.                     continue
  214.                 
  215.             return line
  216.             return None
  217.  
  218.     
  219.     def readlines(self):
  220.         '''Read and return the list of all logical lines remaining in the
  221.            current file.'''
  222.         lines = []
  223.         while None:
  224.             line = self.readline()
  225.             if line is None:
  226.                 return lines
  227.             continue
  228.             return None
  229.  
  230.     
  231.     def unreadline(self, line):
  232.         """Push 'line' (a string) onto an internal buffer that will be
  233.            checked by future 'readline()' calls.  Handy for implementing
  234.            a parser with line-at-a-time lookahead."""
  235.         self.linebuf.append(line)
  236.  
  237.  
  238.