X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/ec873c943d71f0d5f13e3398557071448cda6c23..a4027e74873007e3430af3bd77019bcab76f6c04:/wxPython/samples/ide/activegrid/tool/checker.py diff --git a/wxPython/samples/ide/activegrid/tool/checker.py b/wxPython/samples/ide/activegrid/tool/checker.py deleted file mode 100644 index 23b4372727..0000000000 --- a/wxPython/samples/ide/activegrid/tool/checker.py +++ /dev/null @@ -1,906 +0,0 @@ -#!/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("^$", 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: - exc_type, exc_value, exc_tb = sys.exc_info() - w = Warning(self.moduleName, 1, "%s: %s.\nUnable to import module %s." % (exc_type, exc_value, self.moduleName)) - 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) - - # reload the given module, otherwise won't get new syntax errors. - sysModule = sys.modules.get(moduleName) - if sysModule: - try: - reload(sysModule) - except: - pass - - 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 - if sys.path[0] != '' : - 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() -##