--- /dev/null
+#!/usr/bin/env python
+
+# Copyright (c) 2001-2004, MetaSlash Inc. All rights reserved.
+
+"""
+Copyright notice from pychecker:
+
+Copyright (c) 2000-2001, MetaSlash Inc.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+ - Redistributions of source code must retain the above copyright
+ notice, this list of conditions and the following disclaimer.
+
+ - Redistributions in binary form must reproduce the above copyright
+ notice, this list of conditions and the following disclaimer in the
+ documentation and/or other materials provided with the
+ distribution.
+
+ - Neither name of MetaSlash Inc. nor the names of contributors
+ may be used to endorse or promote products derived
+ from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR
+CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+"""
+
+
+"""
+Check python source code files for possible errors and print warnings
+
+Contact Info:
+ http://pychecker.sourceforge.net/
+ pychecker-list@lists.sourceforge.net
+"""
+
+import string
+import types
+import sys
+import imp
+import os
+import glob
+import traceback
+import re
+import wx
+_ = wx.GetTranslation
+
+# see __init__.py for meaning, this must match the version there
+LOCAL_MAIN_VERSION = 1
+
+
+def setupNamespace(path) :
+ # remove pychecker if it's the first component, it needs to be last
+ if sys.path[0][-9:] == 'pychecker' :
+ del sys.path[0]
+
+ # make sure pychecker is last in path, so we can import
+ checker_path = os.path.dirname(os.path.dirname(path))
+ if checker_path not in sys.path :
+ sys.path.append(checker_path)
+
+if __name__ == '__main__' :
+ setupNamespace(sys.argv[0])
+
+from pychecker import utils
+from pychecker import printer
+from pychecker import warn
+from pychecker import OP
+from pychecker import Config
+from pychecker import function
+from pychecker.Warning import Warning
+
+# Globals for storing a dictionary of info about modules and classes
+_allModules = {}
+_cfg = None
+
+# Constants
+_DEFAULT_MODULE_TOKENS = ('__builtins__', '__doc__', '__file__', '__name__',
+ '__path__')
+_DEFAULT_CLASS_TOKENS = ('__doc__', '__name__', '__module__')
+
+_VERSION_MISMATCH_ERROR = '''
+There seem to be two versions of PyChecker being used.
+One is probably in python/site-packages, the other in a local directory.
+If you want to run the local version, you must remove the version
+from site-packages. Or you can install the current version
+by doing python setup.py install.
+'''
+
+def cfg() :
+ return utils.cfg()
+
+def _flattenList(list) :
+ "Returns a list which contains no lists"
+
+ new_list = []
+ for element in list :
+ if type(element) == types.ListType :
+ new_list.extend(_flattenList(element))
+ else :
+ new_list.append(element)
+
+ return new_list
+
+def getModules(arg_list) :
+ "Returns a list of module names that can be imported"
+
+ global _output
+
+ new_arguments = []
+ for arg in arg_list :
+ # is this a wildcard filespec? (necessary for windows)
+ if '*' in arg or '?' in arg or '[' in arg :
+ arg = glob.glob(arg)
+ new_arguments.append(arg)
+
+ PY_SUFFIXES = ['.py']
+ PY_SUFFIX_LENS = [3]
+ if _cfg.quixote:
+ PY_SUFFIXES.append('.ptl')
+ PY_SUFFIX_LENS.append(4)
+
+ modules = []
+ for arg in _flattenList(new_arguments) :
+ fullpath = arg
+ # is it a .py file?
+ for suf, suflen in zip(PY_SUFFIXES, PY_SUFFIX_LENS):
+ if len(arg) > suflen and arg[-suflen:] == suf:
+ arg_dir = os.path.dirname(arg)
+ if arg_dir and not os.path.exists(arg) :
+ txt = _('File or pathname element does not exist: "%s"') % arg
+ _output.AddLines(txt)
+ continue
+
+ module_name = os.path.basename(arg)[:-suflen]
+ if arg_dir not in sys.path :
+ sys.path.insert(0, arg_dir)
+ arg = module_name
+ modules.append((arg, fullpath))
+
+ return modules
+
+def _q_file(f):
+ # crude hack!!!
+ # imp.load_module requires a real file object, so we can't just
+ # fiddle def lines and yield them
+ import tempfile
+ fd, newfname = tempfile.mkstemp(suffix=".py", text=True)
+ newf = os.fdopen(fd, 'r+')
+ os.unlink(newfname)
+ for line in f:
+ mat = re.match(r'(\s*def\s+\w+\s*)\[(html|plain)\](.*)', line)
+ if mat is None:
+ newf.write(line)
+ else:
+ newf.write(mat.group(1)+mat.group(3)+'\n')
+ newf.seek(0)
+ return newf
+
+def _q_find_module(p, path):
+ if not _cfg.quixote:
+ return imp.find_module(p, path)
+ else:
+ for direc in path:
+ try:
+ return imp.find_module(p, [direc])
+ except ImportError:
+ f = os.path.join(direc, p+".ptl")
+ if os.path.exists(f):
+ return _q_file(file(f)), f, ('.ptl', 'U', 1)
+
+def _findModule(name) :
+ """Returns the result of an imp.find_module(), ie, (file, filename, smt)
+ name can be a module or a package name. It is *not* a filename."""
+
+ path = sys.path[:]
+ packages = string.split(name, '.')
+ for p in packages :
+ # smt = (suffix, mode, type)
+ file, filename, smt = _q_find_module(p, path)
+ if smt[-1] == imp.PKG_DIRECTORY :
+ try :
+ # package found - read path info from init file
+ m = imp.load_module(p, file, filename, smt)
+ finally :
+ if file is not None :
+ file.close()
+
+ # importing xml plays a trick, which replaces itself with _xmlplus
+ # both have subdirs w/same name, but different modules in them
+ # we need to choose the real (replaced) version
+ if m.__name__ != p :
+ try :
+ file, filename, smt = _q_find_module(m.__name__, path)
+ m = imp.load_module(p, file, filename, smt)
+ finally :
+ if file is not None :
+ file.close()
+
+ new_path = m.__path__
+ if type(new_path) == types.ListType :
+ new_path = filename
+ if new_path not in path :
+ path.insert(1, new_path)
+ elif smt[-1] != imp.PY_COMPILED:
+ if p is not packages[-1] :
+ if file is not None :
+ file.close()
+ raise ImportError, "No module named %s" % packages[-1]
+ return file, filename, smt
+
+ # in case we have been given a package to check
+ return file, filename, smt
+
+
+class Variable :
+ "Class to hold all information about a variable"
+
+ def __init__(self, name, type):
+ self.name = name
+ self.type = type
+ self.value = None
+
+ def __str__(self) :
+ return self.name
+
+ __repr__ = utils.std_repr
+
+
+def _filterDir(object, ignoreList) :
+ "Return a list of tokens (attributes) in a class, except for ignoreList"
+
+ tokens = dir(object)
+ for token in ignoreList :
+ if token in tokens :
+ tokens.remove(token)
+ return tokens
+
+def _getClassTokens(c) :
+ return _filterDir(c, _DEFAULT_CLASS_TOKENS)
+
+
+class Class :
+ "Class to hold all information about a class"
+
+ def __init__(self, name, module) :
+ self.name = name
+ self.classObject = getattr(module, name)
+
+ modname = getattr(self.classObject, '__module__', None)
+ if modname is None:
+ # hm, some ExtensionClasses don't have a __module__ attribute
+ # so try parsing the type output
+ typerepr = repr(type(self.classObject))
+ mo = re.match("^<type ['\"](.+)['\"]>$", typerepr)
+ if mo:
+ modname = ".".join(mo.group(1).split(".")[:-1])
+
+ self.module = sys.modules.get(modname)
+ if not self.module:
+ self.module = module
+
+ global _output
+ txt = _("warning: couldn't find real module for class %s (module name: %s)\n") % (self.classObject, modname)
+ _output.AddLines(txt)
+
+ self.ignoreAttrs = 0
+ self.methods = {}
+ self.members = { '__class__': types.ClassType,
+ '__doc__': types.StringType,
+ '__dict__': types.DictType, }
+ self.memberRefs = {}
+ self.statics = {}
+ self.lineNums = {}
+
+ def __str__(self) :
+ return self.name
+
+ __repr__ = utils.std_repr
+
+ def getFirstLine(self) :
+ "Return first line we can find in THIS class, not any base classes"
+
+ lineNums = []
+ classDir = dir(self.classObject)
+ for m in self.methods.values() :
+ if m != None and m.function.func_code.co_name in classDir:
+ lineNums.append(m.function.func_code.co_firstlineno)
+ if lineNums :
+ return min(lineNums)
+ return 0
+
+
+ def allBaseClasses(self, c = None) :
+ "Return a list of all base classes for this class and it's subclasses"
+
+ baseClasses = []
+ if c == None :
+ c = self.classObject
+ for base in c.__bases__ :
+ baseClasses = baseClasses + [ base ] + self.allBaseClasses(base)
+ return baseClasses
+
+ def __getMethodName(self, func_name, className = None) :
+ if func_name[0:2] == '__' and func_name[-2:] != '__' :
+ if className == None :
+ className = self.name
+ if className[0] != '_' :
+ className = '_' + className
+ func_name = className + func_name
+ return func_name
+
+ def addMethod(self, method, methodName = None) :
+ if type(method) == types.StringType :
+ self.methods[method] = None
+ else :
+ assert methodName is not None, "must supply methodName"
+ self.methods[methodName] = function.Function(method, 1)
+
+ def addMethods(self, classObject) :
+ for classToken in _getClassTokens(classObject) :
+ token = getattr(classObject, classToken, None)
+ if token is None:
+ continue
+
+ # Looks like a method. Need to code it this way to
+ # accommodate ExtensionClass and Python 2.2. Yecchh.
+ if (hasattr(token, "func_code") and
+ hasattr(token.func_code, "co_argcount")):
+ self.addMethod(token, token.__name__)
+
+ elif hasattr(token, '__get__') and \
+ not hasattr(token, '__set__') and \
+ type(token) is not types.ClassType :
+ self.addMethod(getattr(token, '__name__', classToken))
+ else :
+ self.members[classToken] = type(token)
+ self.memberRefs[classToken] = None
+
+ self.cleanupMemberRefs()
+ # add standard methods
+ for methodName in ('__class__',) :
+ self.addMethod(methodName, classObject.__name__)
+
+ def addMembers(self, classObject) :
+ if not cfg().onlyCheckInitForMembers :
+ for classToken in _getClassTokens(classObject) :
+ method = getattr(classObject, classToken, None)
+ if type(method) == types.MethodType :
+ self.addMembersFromMethod(method.im_func)
+ else:
+ try:
+ self.addMembersFromMethod(classObject.__init__.im_func)
+ except AttributeError:
+ pass
+
+ def addMembersFromMethod(self, method) :
+ if not hasattr(method, 'func_code') :
+ return
+
+ func_code, code, i, maxCode, extended_arg = OP.initFuncCode(method)
+ stack = []
+ while i < maxCode :
+ op, oparg, i, extended_arg = OP.getInfo(code, i, extended_arg)
+ if op >= OP.HAVE_ARGUMENT :
+ operand = OP.getOperand(op, func_code, oparg)
+ if OP.LOAD_CONST(op) or OP.LOAD_FAST(op) :
+ stack.append(operand)
+ elif OP.STORE_ATTR(op) :
+ if len(stack) > 0 :
+ if stack[-1] == cfg().methodArgName:
+ value = None
+ if len(stack) > 1 :
+ value = type(stack[-2])
+ self.members[operand] = value
+ self.memberRefs[operand] = None
+ stack = []
+
+ self.cleanupMemberRefs()
+
+ def cleanupMemberRefs(self) :
+ try :
+ del self.memberRefs[Config.CHECKER_VAR]
+ except KeyError :
+ pass
+
+ def abstractMethod(self, m):
+ """Return 1 if method is abstract, None if not
+ An abstract method always raises an exception.
+ """
+ if not self.methods.get(m, None):
+ return None
+ func_code, bytes, i, maxCode, extended_arg = \
+ OP.initFuncCode(self.methods[m].function)
+ # abstract if the first conditional is RAISE_VARARGS
+ while i < maxCode:
+ op, oparg, i, extended_arg = OP.getInfo(bytes, i, extended_arg)
+ if OP.RAISE_VARARGS(op):
+ return 1
+ if OP.conditional(op):
+ break
+ return None
+
+ def isAbstract(self):
+ """Return the method names that make a class abstract.
+ An abstract class has at least one abstract method."""
+ result = []
+ for m in self.methods.keys():
+ if self.abstractMethod(m):
+ result.append(m)
+ return result
+
+def _getLineInFile(moduleName, linenum):
+ line = ''
+ file, filename, smt = _findModule(moduleName)
+ try:
+ lines = file.readlines()
+ line = string.rstrip(lines[linenum - 1])
+ except (IOError, IndexError):
+ pass
+ file.close()
+ return line
+
+def importError(moduleName):
+ exc_type, exc_value, tb = sys.exc_info()
+
+ # First, try to get a nice-looking name for this exception type.
+ exc_name = getattr(exc_type, '__name__', None)
+ if not exc_name:
+ # either it's a string exception or a user-defined exception class
+ # show string or fully-qualified class name
+ exc_name = str(exc_type)
+
+ # Print a traceback, unless this is an ImportError. ImportError is
+ # presumably the most common import-time exception, so this saves
+ # the clutter of a traceback most of the time. Also, the locus of
+ # the error is usually irrelevant for ImportError, so the lack of
+ # traceback shouldn't be a problem.
+ if exc_type is SyntaxError:
+ # SyntaxErrors are special, we want to control how we format
+ # the output and make it consistent for all versions of Python
+ e = exc_value
+ msg = '%s (%s, line %d)' % (e.msg, e.filename, e.lineno)
+ line = _getLineInFile(moduleName, e.lineno)
+ offset = e.offset
+ if type(offset) is not types.IntType:
+ offset = 0
+ exc_value = '%s\n %s\n %s^' % (msg, line, ' ' * offset)
+ elif exc_type is not ImportError:
+ global _output
+ txt = _(" Caught exception importing module %s:\n") % moduleName
+ _output.AddLines(txt)
+
+ try:
+ tbinfo = traceback.extract_tb(tb)
+ except:
+ tbinfo = []
+ txt = _(" Unable to format traceback\n")
+ _output.AddLines(txt)
+ for filename, line, func, text in tbinfo[1:]:
+ txt = _(" File \"%s\", line %d") % (filename, line)
+ _output.AddLines(txt)
+ if func != "?":
+ txt = _(", in %s()") % func
+ _output.AddLines(txt)
+ _output.AddLines("\n")
+ if text:
+ txt = _(" %s\n") % text
+ _output.AddLines(txt)
+
+ # And finally print the exception type and value.
+ # Careful formatting exc_value -- can fail for some user exceptions
+ txt = " %s: " % exc_name
+ _output.AddLines(txt)
+ try:
+ txt = str(exc_value) + '\n'
+ _output.AddLines(txt)
+ except:
+ txt = _('**error formatting exception value**\n')
+ _output.AddLines(txt)
+
+
+def _getPyFile(filename):
+ """Return the file and '.py' filename from a filename which could
+ end with .py, .pyc, or .pyo"""
+
+ if filename[-1] in 'oc' and filename[-4:-1] == '.py':
+ return filename[:-1]
+ return filename
+
+class Module :
+ "Class to hold all information for a module"
+
+ def __init__(self, moduleName, check = 1, fullpath = None) :
+ self.moduleName = moduleName
+ self.variables = {}
+ self.functions = {}
+ self.classes = {}
+ self.modules = {}
+ self.moduleLineNums = {}
+ self.attributes = [ '__dict__' ]
+ self.main_code = None
+ self.module = None
+ self.check = check
+ self.fullpath = fullpath
+ _allModules[moduleName] = self
+
+ def __str__(self) :
+ return self.moduleName
+
+ __repr__ = utils.std_repr
+
+ def addVariable(self, var, varType) :
+ self.variables[var] = Variable(var, varType)
+
+ def addFunction(self, func) :
+ self.functions[func.__name__] = function.Function(func)
+
+ def __addAttributes(self, c, classObject) :
+ for base in classObject.__bases__ :
+ self.__addAttributes(c, base)
+ c.addMethods(classObject)
+ c.addMembers(classObject)
+
+ def addClass(self, name) :
+ self.classes[name] = c = Class(name, self.module)
+ try:
+ objName = str(c.classObject)
+ except TypeError:
+ # this can happen if there is a goofy __getattr__
+ c.ignoreAttrs = 1
+ else:
+ packages = string.split(objName, '.')
+ c.ignoreAttrs = packages[0] in cfg().blacklist
+ if not c.ignoreAttrs :
+ self.__addAttributes(c, c.classObject)
+
+ def addModule(self, name) :
+ module = _allModules.get(name, None)
+ if module is None :
+ self.modules[name] = module = Module(name, 0)
+ if imp.is_builtin(name) == 0 :
+ module.load()
+ else :
+ globalModule = globals().get(name)
+ if globalModule :
+ module.attributes.extend(dir(globalModule))
+ else :
+ self.modules[name] = module
+
+ def filename(self) :
+ try :
+ filename = self.module.__file__
+ except AttributeError :
+ filename = self.moduleName
+ return _getPyFile(filename)
+
+ def load(self, warnings = None):
+ try :
+ # there's no need to reload modules we already have
+ global _output, _statusDlg, _count
+ txt = _("Loading Module %s\n") % self.moduleName
+ _output.AddLines(txt)
+ _count += 1
+ if _count == 100:
+ _count = 95
+ _statusDlg.Update(_count, txt)
+
+ module = sys.modules.get(self.moduleName)
+ if module :
+ if not _allModules[self.moduleName].module :
+ return self._initModule(module)
+ return 1
+
+ return self._initModule(self.setupMainCode())
+ except (SystemExit, KeyboardInterrupt) :
+ exc_type, exc_value, exc_tb = sys.exc_info()
+ raise exc_type, exc_value
+ except SyntaxError, (message, (fileName, line, col, text)):
+ # ActiveGrid: added this for better feedback when module couldn't be loaded.
+ w = Warning(self.fullpath, line, _("Syntax Error: %s\n%s\n%s^error near here") % (message, text, ' '*(col-1)))
+ warnings.append(w)
+ return 0
+ except:
+ w = Warning(self.moduleName, 1, sys.exc_info()[0] + " NOT PROCESSED UNABLE TO IMPORT")
+ warnings.append(w)
+ importError(self.moduleName)
+ return 0
+
+ def initModule(self, module) :
+ if not self.module:
+ filename = _getPyFile(module.__file__)
+ if string.lower(filename[-3:]) == '.py':
+ try:
+ file = open(filename)
+ except IOError:
+ pass
+ else:
+ self._setupMainCode(file, filename, module)
+ return self._initModule(module)
+ return 1
+
+ def _initModule(self, module):
+ self.module = module
+ self.attributes = dir(self.module)
+
+ pychecker_attr = getattr(module, Config.CHECKER_VAR, None)
+ if pychecker_attr is not None :
+ utils.pushConfig()
+ utils.updateCheckerArgs(pychecker_attr, 'suppressions', 0, [])
+
+ for tokenName in _filterDir(self.module, _DEFAULT_MODULE_TOKENS) :
+ token = getattr(self.module, tokenName)
+ if isinstance(token, types.ModuleType) :
+ # get the real module name, tokenName could be an alias
+ self.addModule(token.__name__)
+ elif isinstance(token, types.FunctionType) :
+ self.addFunction(token)
+ elif isinstance(token, types.ClassType) or \
+ hasattr(token, '__bases__') :
+ self.addClass(tokenName)
+ else :
+ self.addVariable(tokenName, type(token))
+
+ if pychecker_attr is not None :
+ utils.popConfig()
+ return 1
+
+ def setupMainCode(self) :
+ file, filename, smt = _findModule(self.moduleName)
+ # FIXME: if the smt[-1] == imp.PKG_DIRECTORY : load __all__
+ module = imp.load_module(self.moduleName, file, filename, smt)
+ self._setupMainCode(file, filename, module)
+ return module
+
+ def _setupMainCode(self, file, filename, module):
+ try :
+ self.main_code = function.create_from_file(file, filename, module)
+ finally :
+ if file != None :
+ file.close()
+
+
+def getAllModules() :
+ "Returns a list of all modules that should be checked."
+ modules = []
+ for module in _allModules.values() :
+ if module.check :
+ modules.append(module)
+ return modules
+
+_BUILTIN_MODULE_ATTRS = { 'sys': [ 'ps1', 'ps2', 'tracebacklimit',
+ 'exc_type', 'exc_value', 'exc_traceback',
+ 'last_type', 'last_value', 'last_traceback',
+ ],
+ }
+
+def fixupBuiltinModules(needs_init=0):
+ for moduleName in sys.builtin_module_names :
+ if needs_init:
+ _ = Module(moduleName, 0)
+ module = _allModules.get(moduleName, None)
+ if module is not None :
+ try :
+ m = imp.init_builtin(moduleName)
+ except ImportError :
+ pass
+ else :
+ extra_attrs = _BUILTIN_MODULE_ATTRS.get(moduleName, [])
+ module.attributes = [ '__dict__' ] + dir(m) + extra_attrs
+
+
+def _printWarnings(warnings, stream=None):
+ if stream is None:
+ stream = sys.stdout
+
+ warnings.sort()
+ lastWarning = None
+ for warning in warnings :
+ if lastWarning != None :
+ # ignore duplicate warnings
+ if cmp(lastWarning, warning) == 0 :
+ continue
+ # print blank line between files
+ if lastWarning.file != warning.file :
+ global _output
+ _output.AddLines("\n")
+
+ lastWarning = warning
+ _output.AddLines(warning.format() + "\n")
+
+
+def processFiles(files, cfg = None, pre_process_cb = None) :
+ # insert this here, so we find files in the local dir before std library
+ if sys.path[0] != '' :
+ sys.path.insert(0, '')
+
+ # ensure we have a config object, it's necessary
+ global _cfg
+ if cfg is not None :
+ _cfg = cfg
+ elif _cfg is None :
+ _cfg = Config.Config()
+
+ warnings = []
+ utils.initConfig(_cfg)
+ for moduleName, filename in getModules(files) :
+ if callable(pre_process_cb) :
+ pre_process_cb(moduleName)
+ module = Module(moduleName, fullpath = filename)
+
+ module.load(warnings)
+ utils.popConfig()
+ return warnings
+
+
+def getWarnings(files, cfg = None, suppressions = None):
+ warnings = processFiles(files, cfg)
+ fixupBuiltinModules()
+ return warnings + warn.find(getAllModules(), _cfg, suppressions)
+
+
+def _print_processing(name) :
+ if not _cfg.quiet :
+ global _output, _statusDlg, _count
+ txt = _("Processing %s...\n") % name
+ _output.AddLines(txt)
+ _count += 1
+ _statusDlg.Update(_count, txt)
+
+
+
+def checkSyntax(filename, messageView):
+ """ Massively hacked version of main for ActiveGrid IDE integration """
+ global _cfg
+ _cfg, files, suppressions = Config.setupFromArgs([filename])
+ if not files :
+ return 0
+
+ global _output, _statusDlg, _count
+ _output = messageView
+ # wxBug: Need to show progress dialog box, or message window never gets updated until the method returns
+ _statusDlg = wx.ProgressDialog(_("Check Code"), _("Checking %s") % filename, maximum = 100, style = wx.PD_AUTO_HIDE | wx.PD_APP_MODAL | wx.PD_ELAPSED_TIME)
+ _count = 0
+
+ # insert this here, so we find files in the local dir before std library
+ sys.path.insert(0, '')
+
+ importWarnings = processFiles(files, _cfg, _print_processing)
+ fixupBuiltinModules()
+ if _cfg.printParse :
+ for module in getAllModules() :
+ printer.module(module)
+
+ warnings = warn.find(getAllModules(), _cfg, suppressions)
+
+ _statusDlg.Update(100, _("Done"))
+ _statusDlg.Destroy()
+
+ if not _cfg.quiet :
+ _output.AddLines(_("\nWarnings and Errors...\n"))
+ if warnings or importWarnings :
+ _printWarnings(importWarnings + warnings)
+ return 1
+
+ if not _cfg.quiet :
+ _output.AddLines(_("No Syntax Errors"))
+ return 0
+
+##
+##
+##def main(argv) :
+## __pychecker__ = 'no-miximport'
+## import pychecker
+## if LOCAL_MAIN_VERSION != pychecker.MAIN_MODULE_VERSION :
+## sys.stderr.write(_VERSION_MISMATCH_ERROR)
+## sys.exit(100)
+##
+## # remove empty arguments
+## argv = filter(None, argv)
+##
+## # if the first arg starts with an @, read options from the file
+## # after the @ (this is mostly for windows)
+## if len(argv) >= 2 and argv[1][0] == '@':
+## # read data from the file
+## command_file = argv[1][1:]
+## try:
+## f = open(command_file, 'r')
+## command_line = f.read()
+## f.close()
+## except IOError, err:
+## sys.stderr.write("Unable to read commands from file: %s\n %s\n" % \
+## (command_file, err))
+## sys.exit(101)
+##
+## # convert to an argv list, keeping argv[0] and the files to process
+## argv = argv[:1] + string.split(command_line) + argv[2:]
+##
+## global _cfg
+## _cfg, files, suppressions = Config.setupFromArgs(argv[1:])
+## if not files :
+## return 0
+##
+## # insert this here, so we find files in the local dir before std library
+## sys.path.insert(0, '')
+##
+## importWarnings = processFiles(files, _cfg, _print_processing)
+## fixupBuiltinModules()
+## if _cfg.printParse :
+## for module in getAllModules() :
+## printer.module(module)
+##
+## warnings = warn.find(getAllModules(), _cfg, suppressions)
+## if not _cfg.quiet :
+## print "\nWarnings...\n"
+## if warnings or importWarnings :
+## _printWarnings(importWarnings + warnings)
+## return 1
+##
+## if not _cfg.quiet :
+## print "None"
+## return 0
+##
+##
+##if __name__ == '__main__' :
+## try :
+## sys.exit(main(sys.argv))
+## except Config.UsageError :
+## sys.exit(127)
+##
+##else :
+## _orig__import__ = None
+## _suppressions = None
+## _warnings_cache = {}
+##
+## def _get_unique_warnings(warnings):
+## for i in range(len(warnings)-1, -1, -1):
+## w = warnings[i].format()
+## if _warnings_cache.has_key(w):
+## del warnings[i]
+## else:
+## _warnings_cache[w] = 1
+## return warnings
+##
+## def __import__(name, globals=None, locals=None, fromlist=None):
+## if globals is None:
+## globals = {}
+## if locals is None:
+## locals = {}
+## if fromlist is None:
+## fromlist = []
+##
+## check = not sys.modules.has_key(name) and name[:10] != 'pychecker.'
+## pymodule = _orig__import__(name, globals, locals, fromlist)
+## if check :
+## try :
+## module = Module(pymodule.__name__)
+## if module.initModule(pymodule):
+## warnings = warn.find([module], _cfg, _suppressions)
+## _printWarnings(_get_unique_warnings(warnings))
+## else :
+## print 'Unable to load module', pymodule.__name__
+## except Exception:
+## name = getattr(pymodule, '__name__', str(pymodule))
+## importError(name)
+##
+## return pymodule
+##
+## def _init() :
+## global _cfg, _suppressions, _orig__import__
+##
+## args = string.split(os.environ.get('PYCHECKER', ''))
+## _cfg, files, _suppressions = Config.setupFromArgs(args)
+## utils.initConfig(_cfg)
+## fixupBuiltinModules(1)
+##
+## # keep the orig __import__ around so we can call it
+## import __builtin__
+## _orig__import__ = __builtin__.__import__
+## __builtin__.__import__ = __import__
+##
+## if not os.environ.get('PYCHECKER_DISABLED') :
+## _init()
+##
projects / wxWidgets.git / blobdiff