Tools/scripts/checkappend.py

   1 #! /usr/bin/env python
   2
   3 # Released to the public domain, by Tim Peters, 28 February 2000.
   4
   5 """checkappend.py -- search for multi-argument .append() calls.
   6
   7 Usage:  specify one or more file or directory paths:
   8     checkappend [-v] file_or_dir [file_or_dir] ...
   9
  10 Each file_or_dir is checked for multi-argument .append() calls.  When
  11 a directory, all .py files in the directory, and recursively in its
  12 subdirectories, are checked.
  13
  14 Use -v for status msgs.  Use -vv for more status msgs.
  15
  16 In the absence of -v, the only output is pairs of the form
  17
  18     filename(linenumber):
  19     line containing the suspicious append
  20
  21 Note that this finds multi-argument append calls regardless of whether
  22 they're attached to list objects.  If a module defines a class with an
  23 append method that takes more than one argument, calls to that method
  24 will be listed.
  25
  26 Note that this will not find multi-argument list.append calls made via a
  27 bound method object.  For example, this is not caught:
  28
  29     somelist = []
  30     push = somelist.append
  31     push(1, 2, 3)
  32 """
  33
  34 __version__ = 1, 0, 0
  35
  36 import os
  37 import sys
  38 import getopt
  39 import tokenize
  40
  41 verbose = 0
  42
  43 def errprint(*args):
  44     msg = ' '.join(args)
  45     sys.stderr.write(msg)
  46     sys.stderr.write("\n")
  47
  48 def main():
  49     args = sys.argv[1:]
  50     global verbose
  51     try:
  52         opts, args = getopt.getopt(sys.argv[1:], "v")
  53     except getopt.error, msg:
  54         errprint(str(msg) + "\n\n" + __doc__)
  55         return
  56     for opt, optarg in opts:
  57         if opt == '-v':
  58             verbose = verbose + 1
  59     if not args:
  60         errprint(__doc__)
  61         return
  62     for arg in args:
  63         check(arg)
  64
  65 def check(file):
  66     if os.path.isdir(file) and not os.path.islink(file):
  67         if verbose:
  68             print "%s: listing directory" % `file`
  69         names = os.listdir(file)
  70         for name in names:
  71             fullname = os.path.join(file, name)
  72             if ((os.path.isdir(fullname) and
  73                  not os.path.islink(fullname))
  74                 or os.path.normcase(name[-3:]) == ".py"):
  75                 check(fullname)
  76         return
  77
  78     try:
  79         f = open(file)
  80     except IOError, msg:
  81         errprint("%s: I/O Error: %s" % (`file`, str(msg)))
  82         return
  83
  84     if verbose > 1:
  85         print "checking", `file`, "..."
  86
  87     ok = AppendChecker(file, f).run()
  88     if verbose and ok:
  89         print "%s: Clean bill of health." % `file`
  90
  91 [FIND_DOT,
  92  FIND_APPEND,
  93  FIND_LPAREN,
  94  FIND_COMMA,
  95  FIND_STMT]   = range(5)
  96
  97 class AppendChecker:
  98     def __init__(self, fname, file):
  99         self.fname = fname
 100         self.file = file
 101         self.state = FIND_DOT
 102         self.nerrors = 0
 103
 104     def run(self):
 105         try:
 106             tokenize.tokenize(self.file.readline, self.tokeneater)
 107         except tokenize.TokenError, msg:
 108             errprint("%s: Token Error: %s" % (`self.fname`, str(msg)))
 109             self.nerrors = self.nerrors + 1
 110         return self.nerrors == 0
 111
 112     def tokeneater(self, type, token, start, end, line,
 113                 NEWLINE=tokenize.NEWLINE,
 114                 JUNK=(tokenize.COMMENT, tokenize.NL),
 115                 OP=tokenize.OP,
 116                 NAME=tokenize.NAME):
 117
 118         state = self.state
 119
 120         if type in JUNK:
 121             pass
 122
 123         elif state is FIND_DOT:
 124             if type is OP and token == ".":
 125                 state = FIND_APPEND
 126
 127         elif state is FIND_APPEND:
 128             if type is NAME and token == "append":
 129                 self.line = line
 130                 self.lineno = start[0]
 131                 state = FIND_LPAREN
 132             else:
 133                 state = FIND_DOT
 134
 135         elif state is FIND_LPAREN:
 136             if type is OP and token == "(":
 137                 self.level = 1
 138                 state = FIND_COMMA
 139             else:
 140                 state = FIND_DOT
 141
 142         elif state is FIND_COMMA:
 143             if type is OP:
 144                 if token in ("(", "{", "["):
 145                     self.level = self.level + 1
 146                 elif token in (")", "}", "]"):
 147                     self.level = self.level - 1
 148                     if self.level == 0:
 149                         state = FIND_DOT
 150                 elif token == "," and self.level == 1:
 151                     self.nerrors = self.nerrors + 1
 152                     print "%s(%d):\n%s" % (self.fname, self.lineno,
 153                                            self.line)
 154                     # don't gripe about this stmt again
 155                     state = FIND_STMT
 156
 157         elif state is FIND_STMT:
 158             if type is NEWLINE:
 159                 state = FIND_DOT
 160
 161         else:
 162             raise SystemError("unknown internal state '%s'" % `state`)
 163
 164         self.state = state
 165
 166 if __name__ == '__main__':
 167     main()