home *** CD-ROM | disk | FTP | other *** search
/ GameStar 2006 January / Gamestar_80_2006-01_dvd.iso / Dema / Civilization4 / data1.cab / Civ4DemoComponent / Assets / Python / System / tokenize.pyc (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2005-11-09  |  10.0 KB  |  299 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.4)
  3.  
  4. '''Tokenization help for Python programs.
  5.  
  6. generate_tokens(readline) is a generator that breaks a stream of
  7. text into Python tokens.  It accepts a readline-like method which is called
  8. repeatedly to get the next line of input (or "" for EOF).  It generates
  9. 5-tuples with these members:
  10.  
  11.     the token type (see token.py)
  12.     the token (a string)
  13.     the starting (row, column) indices of the token (a 2-tuple of ints)
  14.     the ending (row, column) indices of the token (a 2-tuple of ints)
  15.     the original line (string)
  16.  
  17. It is designed to match the working of the Python tokenizer exactly, except
  18. that it produces COMMENT tokens for comments and gives type OP for all
  19. operators
  20.  
  21. Older entry points
  22.     tokenize_loop(readline, tokeneater)
  23.     tokenize(readline, tokeneater=printtoken)
  24. are the same, except instead of generating tokens, tokeneater is a callback
  25. function to which the 5 fields described above are passed as 5 arguments,
  26. each time a new token is found.'''
  27. __author__ = 'Ka-Ping Yee <ping@lfw.org>'
  28. __credits__ = 'GvR, ESR, Tim Peters, Thomas Wouters, Fred Drake, Skip Montanaro'
  29. import string
  30. import re
  31. from token import *
  32. import token
  33. __all__ = _[1] + [
  34.     'COMMENT',
  35.     'tokenize',
  36.     'generate_tokens',
  37.     'NL']
  38. del x
  39. del token
  40. COMMENT = N_TOKENS
  41. tok_name[COMMENT] = 'COMMENT'
  42. NL = N_TOKENS + 1
  43. tok_name[NL] = 'NL'
  44. N_TOKENS += 2
  45.  
  46. def group(*choices):
  47.     return '(' + '|'.join(choices) + ')'
  48.  
  49.  
  50. def any(*choices):
  51.     return group(*choices) + '*'
  52.  
  53.  
  54. def maybe(*choices):
  55.     return group(*choices) + '?'
  56.  
  57. Whitespace = '[ \\f\\t]*'
  58. Comment = '#[^\\r\\n]*'
  59. Ignore = Whitespace + any('\\\\\\r?\\n' + Whitespace) + maybe(Comment)
  60. Name = '[a-zA-Z_]\\w*'
  61. Hexnumber = '0[xX][\\da-fA-F]*[lL]?'
  62. Octnumber = '0[0-7]*[lL]?'
  63. Decnumber = '[1-9]\\d*[lL]?'
  64. Intnumber = group(Hexnumber, Octnumber, Decnumber)
  65. Exponent = '[eE][-+]?\\d+'
  66. Pointfloat = group('\\d+\\.\\d*', '\\.\\d+') + maybe(Exponent)
  67. Expfloat = '\\d+' + Exponent
  68. Floatnumber = group(Pointfloat, Expfloat)
  69. Imagnumber = group('\\d+[jJ]', Floatnumber + '[jJ]')
  70. Number = group(Imagnumber, Floatnumber, Intnumber)
  71. Single = "[^'\\\\]*(?:\\\\.[^'\\\\]*)*'"
  72. Double = '[^"\\\\]*(?:\\\\.[^"\\\\]*)*"'
  73. Single3 = "[^'\\\\]*(?:(?:\\\\.|'(?!''))[^'\\\\]*)*'''"
  74. Double3 = '[^"\\\\]*(?:(?:\\\\.|"(?!""))[^"\\\\]*)*"""'
  75. Triple = group("[uU]?[rR]?'''", '[uU]?[rR]?"""')
  76. String = group("[uU]?[rR]?'[^\\n'\\\\]*(?:\\\\.[^\\n'\\\\]*)*'", '[uU]?[rR]?"[^\\n"\\\\]*(?:\\\\.[^\\n"\\\\]*)*"')
  77. Operator = group('\\*\\*=?', '>>=?', '<<=?', '<>', '!=', '//=?', '[+\\-*/%&|^=<>]=?', '~')
  78. Bracket = '[][(){}]'
  79. Special = group('\\r?\\n', '[:;.,`@]')
  80. Funny = group(Operator, Bracket, Special)
  81. PlainToken = group(Number, Funny, String, Name)
  82. Token = Ignore + PlainToken
  83. ContStr = group("[uU]?[rR]?'[^\\n'\\\\]*(?:\\\\.[^\\n'\\\\]*)*" + group("'", '\\\\\\r?\\n'), '[uU]?[rR]?"[^\\n"\\\\]*(?:\\\\.[^\\n"\\\\]*)*' + group('"', '\\\\\\r?\\n'))
  84. PseudoExtras = group('\\\\\\r?\\n', Comment, Triple)
  85. PseudoToken = Whitespace + group(PseudoExtras, Number, Funny, ContStr, Name)
  86. (tokenprog, pseudoprog, single3prog, double3prog) = map(re.compile, (Token, PseudoToken, Single3, Double3))
  87. endprogs = {
  88.     "'": re.compile(Single),
  89.     '"': re.compile(Double),
  90.     "'''": single3prog,
  91.     '"""': double3prog,
  92.     "r'''": single3prog,
  93.     'r"""': double3prog,
  94.     "u'''": single3prog,
  95.     'u"""': double3prog,
  96.     "ur'''": single3prog,
  97.     'ur"""': double3prog,
  98.     "R'''": single3prog,
  99.     'R"""': double3prog,
  100.     "U'''": single3prog,
  101.     'U"""': double3prog,
  102.     "uR'''": single3prog,
  103.     'uR"""': double3prog,
  104.     "Ur'''": single3prog,
  105.     'Ur"""': double3prog,
  106.     "UR'''": single3prog,
  107.     'UR"""': double3prog,
  108.     'r': None,
  109.     'R': None,
  110.     'u': None,
  111.     'U': None }
  112. triple_quoted = { }
  113. for t in ("'''", '"""', "r'''", 'r"""', "R'''", 'R"""', "u'''", 'u"""', "U'''", 'U"""', "ur'''", 'ur"""', "Ur'''", 'Ur"""', "uR'''", 'uR"""', "UR'''", 'UR"""'):
  114.     triple_quoted[t] = t
  115.  
  116. single_quoted = { }
  117. for t in ("'", '"', "r'", 'r"', "R'", 'R"', "u'", 'u"', "U'", 'U"', "ur'", 'ur"', "Ur'", 'Ur"', "uR'", 'uR"', "UR'", 'UR"'):
  118.     single_quoted[t] = t
  119.  
  120. tabsize = 8
  121.  
  122. class TokenError(Exception):
  123.     pass
  124.  
  125.  
  126. class StopTokenizing(Exception):
  127.     pass
  128.  
  129.  
  130. def printtoken(type, token, .4, .6, line):
  131.     (srow, scol) = .4
  132.     (erow, ecol) = .6
  133.     print '%d,%d-%d,%d:\t%s\t%s' % (srow, scol, erow, ecol, tok_name[type], repr(token))
  134.  
  135.  
  136. def tokenize(readline, tokeneater = printtoken):
  137.     '''
  138.     The tokenize() function accepts two parameters: one representing the
  139.     input stream, and one providing an output mechanism for tokenize().
  140.  
  141.     The first parameter, readline, must be a callable object which provides
  142.     the same interface as the readline() method of built-in file objects.
  143.     Each call to the function should return one line of input as a string.
  144.  
  145.     The second parameter, tokeneater, must also be a callable object. It is
  146.     called once for each token, with five arguments, corresponding to the
  147.     tuples generated by generate_tokens().
  148.     '''
  149.     
  150.     try:
  151.         tokenize_loop(readline, tokeneater)
  152.     except StopTokenizing:
  153.         pass
  154.  
  155.  
  156.  
  157. def tokenize_loop(readline, tokeneater):
  158.     for token_info in generate_tokens(readline):
  159.         tokeneater(*token_info)
  160.     
  161.  
  162.  
  163. def generate_tokens(readline):
  164.     '''
  165.     The generate_tokens() generator requires one argment, readline, which
  166.     must be a callable object which provides the same interface as the
  167.     readline() method of built-in file objects. Each call to the function
  168.     should return one line of input as a string.
  169.  
  170.     The generator produces 5-tuples with these members: the token type; the
  171.     token string; a 2-tuple (srow, scol) of ints specifying the row and
  172.     column where the token begins in the source; a 2-tuple (erow, ecol) of
  173.     ints specifying the row and column where the token ends in the source;
  174.     and the line on which the token was found. The line passed is the
  175.     logical line; continuation lines are included.
  176.     '''
  177.     lnum = parenlev = continued = 0
  178.     namechars = string.ascii_letters + '_'
  179.     numchars = '0123456789'
  180.     (contstr, needcont) = ('', 0)
  181.     contline = None
  182.     indents = [
  183.         0]
  184.     while None:
  185.         line = readline()
  186.         lnum = lnum + 1
  187.         pos = 0
  188.         max = len(line)
  189.         if contstr:
  190.             if not line:
  191.                 raise TokenError, ('EOF in multi-line string', strstart)
  192.             
  193.             endmatch = endprog.match(line)
  194.             if endmatch:
  195.                 pos = end = endmatch.end(0)
  196.                 yield (STRING, contstr + line[:end], strstart, (lnum, end), contline + line)
  197.                 (contstr, needcont) = ('', 0)
  198.                 contline = None
  199.             elif needcont and line[-2:] != '\\\n' and line[-3:] != '\\\r\n':
  200.                 yield (ERRORTOKEN, contstr + line, strstart, (lnum, len(line)), contline)
  201.                 contstr = ''
  202.                 contline = None
  203.                 continue
  204.             else:
  205.                 contstr = contstr + line
  206.                 contline = contline + line
  207.         elif parenlev == 0 and not continued:
  208.             if not line:
  209.                 break
  210.             
  211.             column = 0
  212.             while pos < max:
  213.                 if line[pos] == ' ':
  214.                     column = column + 1
  215.                 elif line[pos] == '\t':
  216.                     column = (column / tabsize + 1) * tabsize
  217.                 elif line[pos] == '\x0c':
  218.                     column = 0
  219.                 else:
  220.                     break
  221.                 pos = pos + 1
  222.             if pos == max:
  223.                 break
  224.             
  225.             if line[pos] in '#\r\n':
  226.                 yield ((NL, COMMENT)[line[pos] == '#'], line[pos:], (lnum, pos), (lnum, len(line)), line)
  227.                 continue
  228.             
  229.             if column > indents[-1]:
  230.                 indents.append(column)
  231.                 yield (INDENT, line[:pos], (lnum, 0), (lnum, pos), line)
  232.             
  233.             while column < indents[-1]:
  234.                 indents = indents[:-1]
  235.                 yield (DEDENT, '', (lnum, pos), (lnum, pos), line)
  236.         elif not line:
  237.             raise TokenError, ('EOF in multi-line statement', (lnum, 0))
  238.         
  239.         continued = 0
  240.         while pos < max:
  241.             pseudomatch = pseudoprog.match(line, pos)
  242.             if pseudomatch:
  243.                 (start, end) = pseudomatch.span(1)
  244.                 spos = (lnum, start)
  245.                 epos = (lnum, end)
  246.                 pos = end
  247.                 token = line[start:end]
  248.                 initial = line[start]
  249.                 if (initial in numchars or initial == '.') and token != '.':
  250.                     yield (NUMBER, token, spos, epos, line)
  251.                 elif initial in '\r\n':
  252.                     if not parenlev > 0 or NL:
  253.                         pass
  254.                     yield (NEWLINE, token, spos, epos, line)
  255.                 elif initial == '#':
  256.                     yield (COMMENT, token, spos, epos, line)
  257.                 elif token in triple_quoted:
  258.                     endprog = endprogs[token]
  259.                     endmatch = endprog.match(line, pos)
  260.                     if endmatch:
  261.                         pos = endmatch.end(0)
  262.                         token = line[start:pos]
  263.                         yield (STRING, token, spos, (lnum, pos), line)
  264.                     else:
  265.                         strstart = (lnum, start)
  266.                         contstr = line[start:]
  267.                         contline = line
  268.                         break
  269.                 elif initial in single_quoted and token[:2] in single_quoted or token[:3] in single_quoted:
  270.                     if token[-1] == '\n':
  271.                         strstart = (lnum, start)
  272.                         if not endprogs[initial] and endprogs[token[1]]:
  273.                             pass
  274.                         endprog = endprogs[token[2]]
  275.                         contstr = line[start:]
  276.                         needcont = 1
  277.                         contline = line
  278.                         break
  279.                     else:
  280.                         yield (STRING, token, spos, epos, line)
  281.                 elif initial in namechars:
  282.                     yield (NAME, token, spos, epos, line)
  283.                 elif initial == '\\':
  284.                     continued = 1
  285.                 elif initial in '([{':
  286.                     parenlev = parenlev + 1
  287.                 elif initial in ')]}':
  288.                     parenlev = parenlev - 1
  289.                 
  290.                 yield (OP, token, spos, epos, line)
  291.                 continue
  292.             yield (ERRORTOKEN, line[pos], (lnum, pos), (lnum, pos + 1), line)
  293.             pos = pos + 1
  294.     for indent in indents[1:]:
  295.         yield (DEDENT, '', (lnum, 0), (lnum, 0), '')
  296.     
  297.     yield (ENDMARKER, '', (lnum, 0), (lnum, 0), '')
  298.  
  299.