home *** CD-ROM | disk | FTP | other *** search
/ Mac Easy 2010 May / Mac Life Ubuntu.iso / casper / filesystem.squashfs / usr / lib / python2.6 / lib2to3 / pgen2 / driver.pyc (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2009-04-20  |  4.9 KB  |  169 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.6)
  3.  
  4. '''Parser driver.
  5.  
  6. This provides a high-level interface to parse a file into a syntax tree.
  7.  
  8. '''
  9. __author__ = 'Guido van Rossum <guido@python.org>'
  10. __all__ = [
  11.     'Driver',
  12.     'load_grammar']
  13. import os
  14. import logging
  15. import sys
  16. from  import grammar, parse, token, tokenize, pgen
  17.  
  18. class Driver(object):
  19.     
  20.     def __init__(self, grammar, convert = None, logger = None):
  21.         self.grammar = grammar
  22.         if logger is None:
  23.             logger = logging.getLogger()
  24.         
  25.         self.logger = logger
  26.         self.convert = convert
  27.  
  28.     
  29.     def parse_tokens(self, tokens, debug = False):
  30.         '''Parse a series of tokens and return the syntax tree.'''
  31.         p = parse.Parser(self.grammar, self.convert)
  32.         p.setup()
  33.         lineno = 1
  34.         column = 0
  35.         type = None
  36.         value = None
  37.         start = None
  38.         end = None
  39.         line_text = None
  40.         prefix = ''
  41.         for quintuple in tokens:
  42.             (type, value, start, end, line_text) = quintuple
  43.             if start != (lineno, column):
  44.                 if not (lineno, column) <= start:
  45.                     raise AssertionError, ((lineno, column), start)
  46.                 (s_lineno, s_column) = start
  47.                 if lineno < s_lineno:
  48.                     prefix += '\n' * (s_lineno - lineno)
  49.                     lineno = s_lineno
  50.                     column = 0
  51.                 
  52.                 if column < s_column:
  53.                     prefix += line_text[column:s_column]
  54.                     column = s_column
  55.                 
  56.             
  57.             if type in (tokenize.COMMENT, tokenize.NL):
  58.                 prefix += value
  59.                 (lineno, column) = end
  60.                 if value.endswith('\n'):
  61.                     lineno += 1
  62.                     column = 0
  63.                     continue
  64.                 continue
  65.             
  66.             if type == token.OP:
  67.                 type = grammar.opmap[value]
  68.             
  69.             if debug:
  70.                 self.logger.debug('%s %r (prefix=%r)', token.tok_name[type], value, prefix)
  71.             
  72.             if p.addtoken(type, value, (prefix, start)):
  73.                 if debug:
  74.                     self.logger.debug('Stop.')
  75.                 
  76.                 break
  77.             
  78.             prefix = ''
  79.             (lineno, column) = end
  80.             if value.endswith('\n'):
  81.                 lineno += 1
  82.                 column = 0
  83.                 continue
  84.         else:
  85.             raise parse.ParseError('incomplete input', type, value, (prefix, start))
  86.         return None.rootnode
  87.  
  88.     
  89.     def parse_stream_raw(self, stream, debug = False):
  90.         '''Parse a stream and return the syntax tree.'''
  91.         tokens = tokenize.generate_tokens(stream.readline)
  92.         return self.parse_tokens(tokens, debug)
  93.  
  94.     
  95.     def parse_stream(self, stream, debug = False):
  96.         '''Parse a stream and return the syntax tree.'''
  97.         return self.parse_stream_raw(stream, debug)
  98.  
  99.     
  100.     def parse_file(self, filename, debug = False):
  101.         '''Parse a file and return the syntax tree.'''
  102.         stream = open(filename)
  103.         
  104.         try:
  105.             return self.parse_stream(stream, debug)
  106.         finally:
  107.             stream.close()
  108.  
  109.  
  110.     
  111.     def parse_string(self, text, debug = False):
  112.         '''Parse a string and return the syntax tree.'''
  113.         tokens = tokenize.generate_tokens(generate_lines(text).next)
  114.         return self.parse_tokens(tokens, debug)
  115.  
  116.  
  117.  
  118. def generate_lines(text):
  119.     '''Generator that behaves like readline without using StringIO.'''
  120.     for line in text.splitlines(True):
  121.         yield line
  122.     
  123.     while True:
  124.         yield ''
  125.  
  126.  
  127. def load_grammar(gt = 'Grammar.txt', gp = None, save = True, force = False, logger = None):
  128.     '''Load the grammar (maybe from a pickle).'''
  129.     if logger is None:
  130.         logger = logging.getLogger()
  131.     
  132.     if gp is None:
  133.         (head, tail) = os.path.splitext(gt)
  134.         if tail == '.txt':
  135.             tail = ''
  136.         
  137.         gp = head + tail + '.'.join(map(str, sys.version_info)) + '.pickle'
  138.     
  139.     if force or not _newer(gp, gt):
  140.         logger.info('Generating grammar tables from %s', gt)
  141.         g = pgen.generate_grammar(gt)
  142.         if save:
  143.             logger.info('Writing grammar tables to %s', gp)
  144.             
  145.             try:
  146.                 g.dump(gp)
  147.             except IOError:
  148.                 e = None
  149.                 logger.info('Writing failed:' + str(e))
  150.             except:
  151.                 None<EXCEPTION MATCH>IOError
  152.             
  153.  
  154.         None<EXCEPTION MATCH>IOError
  155.     else:
  156.         g = grammar.Grammar()
  157.         g.load(gp)
  158.     return g
  159.  
  160.  
  161. def _newer(a, b):
  162.     '''Inquire whether file a was written since file b.'''
  163.     if not os.path.exists(a):
  164.         return False
  165.     if not os.path.exists(b):
  166.         return True
  167.     return os.path.getmtime(a) >= os.path.getmtime(b)
  168.  
  169.