home *** CD-ROM | disk | FTP | other *** search
/ GameStar 2006 January / Gamestar_80_2006-01_dvd.iso / Dema / Civilization4 / data1.cab / Civ4DemoComponent / Assets / Python / System / tabnanny.pyc (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2005-11-09  |  7.9 KB  |  290 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.4)
  3.  
  4. '''The Tab Nanny despises ambiguous indentation.  She knows no mercy.
  5.  
  6. tabnanny -- Detection of ambiguous indentation
  7.  
  8. For the time being this module is intended to be called as a script.
  9. However it is possible to import it into an IDE and use the function
  10. check() described below.
  11.  
  12. Warning: The API provided by this module is likely to change in future
  13. releases; such changes may not be backward compatible.
  14. '''
  15. __version__ = '6'
  16. import os
  17. import sys
  18. import getopt
  19. import tokenize
  20. if not hasattr(tokenize, 'NL'):
  21.     raise ValueError("tokenize.NL doesn't exist -- tokenize module too old")
  22.  
  23. __all__ = [
  24.     'check',
  25.     'NannyNag',
  26.     'process_tokens']
  27. verbose = 0
  28. filename_only = 0
  29.  
  30. def errprint(*args):
  31.     sep = ''
  32.     for arg in args:
  33.         sys.stderr.write(sep + str(arg))
  34.         sep = ' '
  35.     
  36.     sys.stderr.write('\n')
  37.  
  38.  
  39. def main():
  40.     global filename_only, verbose
  41.     
  42.     try:
  43.         (opts, args) = getopt.getopt(sys.argv[1:], 'qv')
  44.     except getopt.error:
  45.         msg = None
  46.         errprint(msg)
  47.         return None
  48.  
  49.     for o, a in opts:
  50.         if o == '-q':
  51.             filename_only = filename_only + 1
  52.         
  53.         if o == '-v':
  54.             verbose = verbose + 1
  55.             continue
  56.     
  57.     if not args:
  58.         errprint('Usage:', sys.argv[0], '[-v] file_or_directory ...')
  59.         return None
  60.     
  61.     for arg in args:
  62.         check(arg)
  63.     
  64.  
  65.  
  66. class NannyNag(Exception):
  67.     '''
  68.     Raised by tokeneater() if detecting an ambiguous indent.
  69.     Captured and handled in check().
  70.     '''
  71.     
  72.     def __init__(self, lineno, msg, line):
  73.         self.lineno = lineno
  74.         self.msg = msg
  75.         self.line = line
  76.  
  77.     
  78.     def get_lineno(self):
  79.         return self.lineno
  80.  
  81.     
  82.     def get_msg(self):
  83.         return self.msg
  84.  
  85.     
  86.     def get_line(self):
  87.         return self.line
  88.  
  89.  
  90.  
  91. def check(file):
  92.     '''check(file_or_dir)
  93.  
  94.     If file_or_dir is a directory and not a symbolic link, then recursively
  95.     descend the directory tree named by file_or_dir, checking all .py files
  96.     along the way. If file_or_dir is an ordinary Python source file, it is
  97.     checked for whitespace related problems. The diagnostic messages are
  98.     written to standard output using the print statement.
  99.     '''
  100.     if os.path.isdir(file) and not os.path.islink(file):
  101.         if verbose:
  102.             print '%r: listing directory' % (file,)
  103.         
  104.         names = os.listdir(file)
  105.         for name in names:
  106.             fullname = os.path.join(file, name)
  107.             if os.path.isdir(fullname) or not os.path.islink(fullname) or os.path.normcase(name[-3:]) == '.py':
  108.                 check(fullname)
  109.                 continue
  110.         
  111.         return None
  112.     
  113.     
  114.     try:
  115.         f = open(file)
  116.     except IOError:
  117.         msg = None
  118.         errprint('%r: I/O Error: %s' % (file, msg))
  119.         return None
  120.  
  121.     if verbose > 1:
  122.         print 'checking %r ...' % file
  123.     
  124.     
  125.     try:
  126.         process_tokens(tokenize.generate_tokens(f.readline))
  127.     except tokenize.TokenError:
  128.         msg = None
  129.         errprint('%r: Token Error: %s' % (file, msg))
  130.         return None
  131.     except NannyNag:
  132.         nag = None
  133.         badline = nag.get_lineno()
  134.         line = nag.get_line()
  135.         if verbose:
  136.             print '%r: *** Line %d: trouble in tab city! ***' % (file, badline)
  137.             print 'offending line: %r' % (line,)
  138.             print nag.get_msg()
  139.         elif ' ' in file:
  140.             file = '"' + file + '"'
  141.         
  142.         if filename_only:
  143.             print file
  144.         else:
  145.             print file, badline, repr(line)
  146.         return None
  147.  
  148.     if verbose:
  149.         print '%r: Clean bill of health.' % (file,)
  150.     
  151.  
  152.  
  153. class Whitespace:
  154.     (S, T) = ' \t'
  155.     
  156.     def __init__(self, ws):
  157.         self.raw = ws
  158.         S = Whitespace.S
  159.         T = Whitespace.T
  160.         count = []
  161.         b = n = nt = 0
  162.         for ch in self.raw:
  163.             if ch == S:
  164.                 n = n + 1
  165.                 b = b + 1
  166.                 continue
  167.             if ch == T:
  168.                 n = n + 1
  169.                 nt = nt + 1
  170.                 if b >= len(count):
  171.                     count = count + [
  172.                         0] * ((b - len(count)) + 1)
  173.                 
  174.                 count[b] = count[b] + 1
  175.                 b = 0
  176.                 continue
  177.         
  178.         self.n = n
  179.         self.nt = nt
  180.         self.norm = (tuple(count), b)
  181.         self.is_simple = len(count) <= 1
  182.  
  183.     
  184.     def longest_run_of_spaces(self):
  185.         (count, trailing) = self.norm
  186.         return max(len(count) - 1, trailing)
  187.  
  188.     
  189.     def indent_level(self, tabsize):
  190.         (count, trailing) = self.norm
  191.         il = 0
  192.         for i in range(tabsize, len(count)):
  193.             il = il + (i / tabsize) * count[i]
  194.         
  195.         return trailing + tabsize * (il + self.nt)
  196.  
  197.     
  198.     def equal(self, other):
  199.         return self.norm == other.norm
  200.  
  201.     
  202.     def not_equal_witness(self, other):
  203.         n = max(self.longest_run_of_spaces(), other.longest_run_of_spaces()) + 1
  204.         a = []
  205.         for ts in range(1, n + 1):
  206.             if self.indent_level(ts) != other.indent_level(ts):
  207.                 a.append((ts, self.indent_level(ts), other.indent_level(ts)))
  208.                 continue
  209.         
  210.         return a
  211.  
  212.     
  213.     def less(self, other):
  214.         if self.n >= other.n:
  215.             return False
  216.         
  217.         if self.is_simple and other.is_simple:
  218.             return self.nt <= other.nt
  219.         
  220.         n = max(self.longest_run_of_spaces(), other.longest_run_of_spaces()) + 1
  221.         for ts in range(2, n + 1):
  222.             if self.indent_level(ts) >= other.indent_level(ts):
  223.                 return False
  224.                 continue
  225.         
  226.         return True
  227.  
  228.     
  229.     def not_less_witness(self, other):
  230.         n = max(self.longest_run_of_spaces(), other.longest_run_of_spaces()) + 1
  231.         a = []
  232.         for ts in range(1, n + 1):
  233.             if self.indent_level(ts) >= other.indent_level(ts):
  234.                 a.append((ts, self.indent_level(ts), other.indent_level(ts)))
  235.                 continue
  236.         
  237.         return a
  238.  
  239.  
  240.  
  241. def format_witnesses(w):
  242.     firsts = map((lambda tup: str(tup[0])), w)
  243.     prefix = 'at tab size'
  244.     if len(w) > 1:
  245.         prefix = prefix + 's'
  246.     
  247.     return prefix + ' ' + ', '.join(firsts)
  248.  
  249.  
  250. def process_tokens(tokens):
  251.     INDENT = tokenize.INDENT
  252.     DEDENT = tokenize.DEDENT
  253.     NEWLINE = tokenize.NEWLINE
  254.     JUNK = (tokenize.COMMENT, tokenize.NL)
  255.     indents = [
  256.         Whitespace('')]
  257.     check_equal = 0
  258.     for type, token, start, end, line in tokens:
  259.         if type == NEWLINE:
  260.             check_equal = 1
  261.             continue
  262.         if type == INDENT:
  263.             check_equal = 0
  264.             thisguy = Whitespace(token)
  265.             if not indents[-1].less(thisguy):
  266.                 witness = indents[-1].not_less_witness(thisguy)
  267.                 msg = 'indent not greater e.g. ' + format_witnesses(witness)
  268.                 raise NannyNag(start[0], msg, line)
  269.             
  270.             indents.append(thisguy)
  271.             continue
  272.         if type == DEDENT:
  273.             check_equal = 1
  274.             del indents[-1]
  275.             continue
  276.         if check_equal and type not in JUNK:
  277.             check_equal = 0
  278.             thisguy = Whitespace(line)
  279.             if not indents[-1].equal(thisguy):
  280.                 witness = indents[-1].not_equal_witness(thisguy)
  281.                 msg = 'indent not equal e.g. ' + format_witnesses(witness)
  282.                 raise NannyNag(start[0], msg, line)
  283.             
  284.         indents[-1].equal(thisguy)
  285.     
  286.  
  287. if __name__ == '__main__':
  288.     main()
  289.  
  290.