#!/usr/bin/env python
# Copyright (c) 2001-2002, MetaSlash Inc. All rights reserved.
# Portions Copyright (c) 2005, Google, Inc. All rights reserved.
"""
Print out warnings from Python source files.
"""
import os.path
import sys
import string
import types
import traceback
import imp
import re
from pychecker import OP
from pychecker import Stack
from pychecker import function
from pychecker import python
from pychecker import pcmodules
from pychecker import msgs
from pychecker import utils
from pychecker import CodeChecks
from pychecker.Warning import Warning
def cfg() :
return utils.cfg()
def _checkSelfArg(method, warnings) :
"""Return a Warning if there is no self parameter or
the first parameter to a method is not self."""
if not cfg().methodArgName:
return
code = method.function.func_code
err = None
if method.isStaticMethod():
if code.co_argcount > 0 and cfg().methodArgName == code.co_varnames[0]:
err = msgs.SELF_IS_ARG % 'staticmethod'
elif code.co_argcount < 1:
err = msgs.NO_METHOD_ARGS % cfg().methodArgName
else:
if method.isClassMethod():
if code.co_varnames[0] not in cfg().classmethodArgNames:
err = msgs.SELF_NOT_FIRST_ARG % \
(cfg().classmethodArgNames, 'class')
elif code.co_varnames[0] != cfg().methodArgName:
err = msgs.SELF_NOT_FIRST_ARG % (cfg().methodArgName, '')
if err is not None :
warnings.append(Warning(code, code, err))
def _checkNoSelfArg(func, warnings) :
"Return a Warning if there is a self parameter to a function."
code = func.function.func_code
if code.co_argcount > 0 and cfg().methodArgName in code.co_varnames:
warnings.append(Warning(code, code, msgs.SELF_IS_ARG % 'function'))
def _checkSubclass(c1, c2):
try:
return issubclass(c1.classObject, c2.classObject)
except (TypeError, AttributeError):
return 0
_IGNORE_RETURN_TYPES = ( Stack.TYPE_FUNC_RETURN, Stack.TYPE_ATTRIBUTE,
Stack.TYPE_GLOBAL, Stack.TYPE_COMPARISON,
Stack.TYPE_UNKNOWN)
def _checkReturnWarnings(code) :
is_getattr = code.func_code.co_name in ('__getattr__', '__getattribute__')
if is_getattr :
for line, retval, dummy in code.returnValues :
if retval.isNone() :
err = msgs.DONT_RETURN_NONE % code.func_code.co_name
code.addWarning(err, line+1)
# there must be at least 2 real return values to check for consistency
returnValuesLen = len(code.returnValues)
if returnValuesLen < 2 :
return
# if the last return is implicit, check if there are non None returns
lastReturn = code.returnValues[-1]
# Python 2.4 optimizes the dead implicit return out, so we can't
# distinguish implicit and explicit "return None"
if utils.pythonVersion() < utils.PYTHON_2_4 and \
not code.starts_and_ends_with_finally and \
cfg().checkImplicitReturns and lastReturn[1].isImplicitNone():
for line, retval, dummy in code.returnValues[:-1] :
if not retval.isNone() :
code.addWarning(msgs.IMPLICIT_AND_EXPLICIT_RETURNS,
lastReturn[0]+1)
break
# __get*__ funcs can return different types, don't warn about inconsistency
if utils.startswith(code.func_code.co_name, '__get') and \
utils.endswith(code.func_code.co_name, '__') :
return
returnType, returnData = None, None
for line, value, dummy in code.returnValues :
if not value.isNone() :
valueType = value.getType(code.typeMap)
if returnType is None and valueType not in _IGNORE_RETURN_TYPES :
returnData = value
returnType = valueType
continue
# always ignore None, None can be returned w/any other type
# FIXME: if we stored func return values, we could do better
if returnType is not None and not value.isNone() and \
valueType not in _IGNORE_RETURN_TYPES and \
returnData.type not in _IGNORE_RETURN_TYPES :
ok = returnType in (type(value.data), valueType)
if ok :
if returnType == types.TupleType :
# FIXME: this isn't perfect, if len == 0
# the length can really be 0 OR unknown
# we shouldn't check the lengths for equality
# ONLY IF one of the lengths is truly unknown
if returnData.length > 0 and value.length > 0:
ok = returnData.length == value.length
else :
ok = _checkSubclass(returnType, valueType) or \
_checkSubclass(valueType, returnType)
if not ok :
code.addWarning(msgs.INCONSISTENT_RETURN_TYPE, line)
def _checkComplex(code, maxValue, value, func, err) :
if maxValue and value > maxValue :
line = func.function.func_code.co_firstlineno
code.addWarning(err % (func.function.__name__, value), line)
def _checkCode(code, codeSource) :
while code.index < code.maxCode :
op, oparg, operand = code.popNextOp()
dispatch_func = CodeChecks.DISPATCH[op]
if dispatch_func is not None :
dispatch_func(oparg, operand, codeSource, code)
def _name_unused(var) :
if var in cfg().unusedNames :
return 0
for name in cfg().unusedNames :
if name != '_' and utils.startswith(var, name) :
return 0
return 1
def _checkUnusedParam(var, line, func, code) :
if line is not None and line == 0 and _name_unused(var) :
if ((cfg().ignoreSelfUnused or var != cfg().methodArgName) and
(cfg().varArgumentsUsed or func.varArgName() != var)) :
code.addWarning(msgs.UNUSED_PARAMETER % var, code.func_code)
def _handleNestedCode(func_code, code, codeSource):
nested = not (codeSource.main or codeSource.in_class)
if func_code.co_name == utils.LAMBDA or nested:
utils.debug(' handling nested code')
varnames = None
if nested and func_code.co_name != utils.LAMBDA:
varnames = func_code.co_varnames + \
codeSource.calling_code[-1].function.func_code.co_varnames
# save the original return value and restore after checking
returnValues = code.returnValues
code.init(function.create_fake(func_code.co_name, func_code, {},
varnames))
_checkCode(code, codeSource)
code.returnValues = returnValues
def _findUnreachableCode(code) :
# code after RETURN or RAISE is unreachable unless there's a branch to it
unreachable = {}
terminals = code.returnValues[:-1] + code.raiseValues
terminals.sort(lambda a, b: cmp(a[2], b[2]))
for line, dummy, i in terminals :
if not code.branches.has_key(i) :
unreachable[i] = line
# find the index of the last return
lastLine = lastItem = lastIndex = None
if code.returnValues:
lastLine, lastItem, lastIndex = code.returnValues[-1]
if len(code.returnValues) >= 2 :
lastIndex = code.returnValues[-2][2]
if code.raiseValues :
lastIndex = max(lastIndex, code.raiseValues[-1][2])
# remove last return if it's unreachable AND implicit
if unreachable.get(lastIndex) == lastLine and lastItem and \
lastItem.isImplicitNone():
del code.returnValues[-1]
del unreachable[lastIndex]
if cfg().unreachableCode :
for index in unreachable.keys() :
try :
if not OP.JUMP_FORWARD(ord(code.bytes[index])) :
code.addWarning(msgs.CODE_UNREACHABLE, unreachable[index])
except IndexError :
pass
def _checkFunction(module, func, c = None, main = 0, in_class = 0) :
"Return a list of Warnings found in a function/method."
# always push a new config object, so we can pop at end of function
utils.pushConfig()
code = CodeChecks.Code()
code.init(func)
if main:
for key in func.function.func_globals.keys():
code.unusedLocals[key] = -1
codeSource = CodeChecks.CodeSource(module, func, c, main, in_class, code)
try :
_checkCode(code, codeSource)
if not in_class :
_findUnreachableCode(code)
# handle lambdas and nested functions
codeSource.calling_code.append(func)
for func_code in code.codeObjects.values() :
_handleNestedCode(func_code, code, codeSource)
del codeSource.calling_code[-1]
except (SystemExit, KeyboardInterrupt) :
exc_type, exc_value, exc_tb = sys.exc_info()
raise exc_type, exc_value
except :
exc_type, exc_value, exc_tb = sys.exc_info()
exc_list = traceback.format_exception(exc_type, exc_value, exc_tb)
for index in range(0, len(exc_list)) :
exc_list[index] = string.replace(exc_list[index], "\n", "\n\t")
code.addWarning(msgs.CHECKER_BROKEN % string.join(exc_list, ""))
if cfg().checkReturnValues :
_checkReturnWarnings(code)
if cfg().localVariablesUsed :
for var, line in code.unusedLocals.items() :
if line is not None and line > 0 and _name_unused(var) :
code.addWarning(msgs.UNUSED_LOCAL % var, line)
if cfg().argumentsUsed :
op = code.getFirstOp()
if not (OP.RAISE_VARARGS(op) or OP.RETURN_VALUE(op)) :
for var, line in code.unusedLocals.items() :
_checkUnusedParam(var, line, func, code)
# Check code complexity:
# loops should be counted as one branch, but there are typically 3
# branches in byte code to setup a loop, so subtract off 2/3's of them
# / 2 to approximate real branches
branches = (len(code.branches.keys()) - (2 * code.loops)) / 2
lines = (code.getLineNum() - code.func_code.co_firstlineno)
returns = len(code.returnValues)
if not main and not in_class :
args = code.func_code.co_argcount
locals = len(code.func_code.co_varnames) - args
_checkComplex(code, cfg().maxArgs, args, func, msgs.TOO_MANY_ARGS)
_checkComplex(code, cfg().maxLocals, locals, func, msgs.TOO_MANY_LOCALS)
_checkComplex(code, cfg().maxLines, lines, func, msgs.FUNC_TOO_LONG)
_checkComplex(code, cfg().maxReturns, returns, func, msgs.TOO_MANY_RETURNS)
_checkComplex(code, cfg().maxBranches, branches, func, msgs.TOO_MANY_BRANCHES)
if not (main or in_class) :
utils.popConfig()
func.returnValues = code.returnValues
return (code.warnings, code.globalRefs, code.functionsCalled,
code.codeObjects.values(), code.returnValues)
def _getUnused(module, globalRefs, dict, msg, filterPrefix = None) :
"Return a list of warnings for unused globals"
warnings = []
for ref in dict.keys() :
check = not filterPrefix or utils.startswith(ref, filterPrefix)
if check and globalRefs.get(ref) == None :
lineInfo = module.moduleLineNums.get(ref)
if lineInfo:
warnings.append(Warning(lineInfo[0], lineInfo[1], msg % ref))
return warnings
def _get_func_info(method) :
try:
fc = getattr(method.im_func, 'func_code', None)
if fc is not None :
return fc.co_filename, fc.co_firstlineno
except AttributeError:
# if the object derives from any object in 2.2,
# the builtin methods are wrapper_descriptors and
# have no im_func attr
pass
return None, None
_DOT_INIT = '.' + utils.INIT
def _baseInitCalled(classInitInfo, base, functionsCalled) :
baseInit = getattr(base, utils.INIT, None)
if baseInit is None or _get_func_info(baseInit) == classInitInfo :
return 1
initName = utils.safestr(base) + _DOT_INIT
if functionsCalled.has_key(initName) :
return 1
# ok, do this the hard way, there may be aliases, so check here
names = string.split(initName, '.')
# first look in our list of PyCheckerModules
moduleName = names[0]
moduleDir = os.path.dirname(classInitInfo[0])
pcmodule = pcmodules.getPCModule(moduleName, moduleDir)
if pcmodule:
obj = pcmodule.module
else:
# fall back to looking in sys.modules
try:
# i think this can raise an exception if the module is a library
# (.so)
obj = sys.modules[names[0]]
except KeyError:
return 1
for i in range(1, len(names)) :
obj = getattr(obj, names[i], None)
if obj is None:
return 0
if functionsCalled.has_key(string.join(names[i:], '.')) :
return 1
return 0
def _checkBaseClassInit(moduleFilename, c, func_code, funcInfo) :
"""Return a list of warnings that occur
for each base class whose __init__() is not called"""
warnings = []
functionsCalled, _, returnValues = funcInfo
for line, stackItem, dummy in returnValues :
if stackItem.data != None :
if not stackItem.isNone() or cfg().returnNoneFromInit :
warn = Warning(func_code, line, msgs.RETURN_FROM_INIT)
warnings.append(warn)
classInit = getattr(c.classObject, utils.INIT, None)
if cfg().baseClassInitted and classInit is not None :
classInitInfo = _get_func_info(classInit)
for base in getattr(c.classObject, '__bases__', None) or ():
if not _baseInitCalled(classInitInfo, base, functionsCalled):
warn = Warning(moduleFilename, func_code,
msgs.BASE_CLASS_NOT_INIT % utils.safestr(base))
warnings.append(warn)
return warnings
def _checkOverridenMethods(func, baseClasses, warnings) :
for baseClass in baseClasses :
if func.func_name != utils.INIT and \
not function.same_signature(func, baseClass) :
err = msgs.METHOD_SIGNATURE_MISMATCH % (func.func_name, utils.safestr(baseClass))
warnings.append(Warning(func.func_code, func.func_code, err))
break
def _updateFunctionWarnings(module, func, c, warnings, globalRefs,
main = 0, in_class = 0) :
"Update function warnings and global references"
newWarnings, newGlobalRefs, funcs, codeObjects, returnValues = \
_checkFunction(module, func, c, main, in_class)
warnings.extend(newWarnings)
globalRefs.update(newGlobalRefs)
return funcs, codeObjects, returnValues
def getBlackList(moduleList) :
blacklist = []
for badBoy in moduleList :
if badBoy[-3:] == ".py":
badBoy = badBoy[0:-3]
try :
file, path, flags = imp.find_module(badBoy)
if file :
file.close()
# apparently, imp.find_module can return None, path, (triple)
# This happened to me with twisted 2.2.0 in a separate path
if path:
blacklist.append(normalize_path(path))
except ImportError :
pass
return blacklist
def getStandardLibraries() :
"""
Return a list of standard libraries.
@rtype: list of str or None
"""
if cfg().ignoreStandardLibrary :
try :
from distutils import sysconfig
std_libs = [
sysconfig.get_python_lib(plat_specific=0),
sysconfig.get_python_lib(plat_specific=1)
]
ret = []
for std_lib in std_libs:
path = os.path.split(std_lib)
if path[1] == 'site-packages' :
ret.append(path[0])
return ret
except ImportError :
return None
def normalize_path(path):
return os.path.normpath(os.path.normcase(path))
def removeWarnings(warnings, blacklist, std_lib, cfg):
"""
@param blacklist: list of absolute paths not to warn for
@type blacklist: str
@param std_lib: list of standard library directories
@type std_lib: list of str or None
"""
if std_lib is not None:
std_lib = [normalize_path(p) for p in std_lib]
for index in range(len(warnings)-1, -1, -1) :
filename = normalize_path(warnings[index].file)
# the blacklist contains paths to packages and modules we do not
# want warnings for
# when we find a match, make sure we continue the warnings for loop
found = False
for path in blacklist:
if not found and filename.startswith(path):
found = True
del warnings[index]
if found:
continue
if std_lib:
found = False
for path in std_lib:
if not found and utils.startswith(filename, path) :
found = True
del warnings[index]
if found:
continue
elif cfg.only:
# ignore files not specified on the cmd line if requested
if os.path.abspath(filename) not in cfg.files:
del warnings[index]
continue
# filter by warning/error level if requested
if cfg.level and warnings[index].level < cfg.level:
del warnings[index]
if cfg.limit:
# sort by severity first, then normal sort (by file/line)
warnings.sort(lambda a, b: cmp(a.level, b.level) or cmp(a, b))
# strip duplicates
lastWarning = None
for index in range(len(warnings)-1, -1, -1):
warning = warnings[index]
# remove duplicate warnings
if lastWarning is not None and cmp(lastWarning, warning) == 0:
del warnings[index]
else:
lastWarning = warning
num_ignored = len(warnings) - cfg.limit
if num_ignored > 0:
del warnings[:-cfg.limit]
msg = msgs.TOO_MANY_WARNINGS % num_ignored
warnings.append(Warning('', 0, msg))
return warnings
class _SuppressionError(Exception) :
pass
def _updateSuppressions(suppress, warnings) :
if not utils.updateCheckerArgs(suppress, 'suppressions', 0, warnings) :
utils.popConfig()
raise _SuppressionError
_CLASS_NAME_RE = re.compile("<class '([A-Za-z0-9.]+)'>(\\..+)?")
def getSuppression(name, suppressions, warnings) :
try :
utils.pushConfig()
# cheesy hack to deal with new-style classes. i don't see a
# better way to get the name, '<' is an invalid identifier, so
# we can reliably check it and extract name from:
# <class 'class-name'>[.identifier[.identifier]...]
matches = _CLASS_NAME_RE.match(name)
if matches:
# pull out the names and make a complete identifier (ignore None)
name = string.join(filter(None, matches.groups()), '')
suppress = suppressions[0].get(name, None)
if suppress is not None :
_updateSuppressions(suppress, warnings)
regexList = suppressions[1].keys()
regexList.sort()
for regex in regexList :
match = regex.match(name)
if match and match.group() == name :
suppress = 1
_updateSuppressions(suppressions[1][regex], warnings)
if not suppress :
utils.popConfig()
return suppress
except _SuppressionError :
return None
def _findFunctionWarnings(module, globalRefs, warnings, suppressions) :
for func in module.functions.values() :
func_code = func.function.func_code
utils.debug("function:", func_code)
name = '%s.%s' % (module.moduleName, func.function.__name__)
suppress = getSuppression(name, suppressions, warnings)
if cfg().noDocFunc and func.function.__doc__ == None :
err = msgs.NO_FUNC_DOC % func.function.__name__
warnings.append(Warning(module.filename(), func_code, err))
_checkNoSelfArg(func, warnings)
_updateFunctionWarnings(module, func, None, warnings, globalRefs)
if suppress is not None :
utils.popConfig()
def _getModuleFromFilename(module, filename):
if module.filename() != filename:
for m in module.modules.values():
if m.filename() == filename:
return m
return module
# Create object for non-2.2 interpreters, any class object will do
try:
if object: pass
except NameError:
object = _SuppressionError
# Create property for pre-2.2 interpreters
try :
if property: pass
except NameError:
property = None
def _findClassWarnings(module, c, class_code,
globalRefs, warnings, suppressions) :
try:
className = utils.safestr(c.classObject)
except TypeError:
# goofy __getattr__
return
classSuppress = getSuppression(className, suppressions, warnings)
baseClasses = c.allBaseClasses()
for base in baseClasses :
baseModule = utils.safestr(base)
if '.' in baseModule :
# make sure we handle import x.y.z
packages = string.split(baseModule, '.')
baseModuleDir = string.join(packages[:-1], '.')
globalRefs[baseModuleDir] = baseModule
# handle class variables
if class_code is not None :
func = function.create_fake(c.name, class_code)
_updateFunctionWarnings(module, func, c, warnings, globalRefs, 0, 1)
filename = module.filename()
func_code = None
for method in c.methods.values() :
if method == None :
continue
func_code = method.function.func_code
utils.debug("method:", func_code)
try:
name = utils.safestr(c.classObject) + '.' + method.function.func_name
except AttributeError:
# func_name may not exist
continue
methodSuppress = getSuppression(name, suppressions, warnings)
if cfg().checkSpecialMethods:
funcname = method.function.func_name
if funcname[:2] == '__' == funcname[-2:] and \
funcname != '__init__':
err = None
argCount = python.SPECIAL_METHODS.get(funcname, -1)
if argCount != -1:
# if the args are None, it can be any # of args
if argCount is not None:
minArgs = maxArgs = argCount
err = CodeChecks.getFunctionArgErr(funcname,
func_code.co_argcount, minArgs, maxArgs)
else:
err = msgs.NOT_SPECIAL_METHOD % funcname
if err is not None:
warnings.append(Warning(filename, func_code, err))
if cfg().checkOverridenMethods :
_checkOverridenMethods(method.function, baseClasses, warnings)
if cfg().noDocFunc and method.function.__doc__ == None :
err = msgs.NO_FUNC_DOC % method.function.__name__
warnings.append(Warning(filename, func_code, err))
_checkSelfArg(method, warnings)
tmpModule = _getModuleFromFilename(module, func_code.co_filename)
funcInfo = _updateFunctionWarnings(tmpModule, method, c, warnings, globalRefs)
if func_code.co_name == utils.INIT :
if utils.INIT in dir(c.classObject) :
warns = _checkBaseClassInit(filename, c, func_code, funcInfo)
warnings.extend(warns)
elif cfg().initDefinedInSubclass :
err = msgs.NO_INIT_IN_SUBCLASS % c.name
warnings.append(Warning(filename, c.getFirstLine(), err))
if methodSuppress is not None :
utils.popConfig()
if c.memberRefs and cfg().membersUsed :
memberList = c.memberRefs.keys()
memberList.sort()
err = msgs.UNUSED_MEMBERS % (string.join(memberList, ', '), c.name)
warnings.append(Warning(filename, c.getFirstLine(), err))
try:
newStyleClass = issubclass(c.classObject, object)
except TypeError:
# FIXME: perhaps this should warn b/c it may be a class???
newStyleClass = 0
slots = c.statics.get('__slots__')
if slots is not None and cfg().slots:
lineNum = c.lineNums['__slots__']
if not newStyleClass:
err = msgs.USING_SLOTS_IN_CLASSIC_CLASS % c.name
warnings.append(Warning(filename, lineNum, err))
elif cfg().emptySlots:
try:
if len(slots.data) == 0:
err = msgs.EMPTY_SLOTS % c.name
warnings.append(Warning(filename, lineNum, err))
except AttributeError:
# happens when slots is an instance of a class w/o __len__
pass
if not newStyleClass and property is not None and cfg().classicProperties:
for static in c.statics.keys():
if type(getattr(c.classObject, static, None)) == property:
err = msgs.USING_PROPERTIES_IN_CLASSIC_CLASS % (static, c.name)
warnings.append(Warning(filename, c.lineNums[static], err))
coerceMethod = c.methods.get('__coerce__')
if newStyleClass and coerceMethod:
lineNum = coerceMethod.function.func_code.co_firstlineno
err = msgs.USING_COERCE_IN_NEW_CLASS % c.name
warnings.append(Warning(filename, lineNum, err))
for newClassMethodName in python.NEW_STYLE_CLASS_METHODS:
newClassMethod = c.methods.get(newClassMethodName)
if not newStyleClass and newClassMethod:
lineNum = newClassMethod.function.func_code.co_firstlineno
err = msgs.USING_NEW_STYLE_METHOD_IN_OLD_CLASS % (newClassMethodName, c.name)
warnings.append(Warning(filename, lineNum, err))
if cfg().noDocClass and c.classObject.__doc__ == None :
method = c.methods.get(utils.INIT, None)
if method != None :
func_code = method.function.func_code
# FIXME: check to make sure this is in our file,
# not a base class file???
err = msgs.NO_CLASS_DOC % c.classObject.__name__
warnings.append(Warning(filename, func_code, err))
# we have to do this here, b/c checkFunction doesn't popConfig for classes
# this allows us to have __pychecker__ apply to all methods
# when defined at class scope
if class_code is not None :
utils.popConfig()
if classSuppress is not None :
utils.popConfig()
def find(moduleList, initialCfg, suppressions = None) :
"Return a list of warnings found in the module list"
if suppressions is None :
suppressions = {}, {}
utils.initConfig(initialCfg)
warnings = []
for module in moduleList :
if module.moduleName in cfg().blacklist :
continue
modSuppress = getSuppression(module.moduleName, suppressions, warnings)
globalRefs, classCodes = {}, {}
# main_code can be null if there was a syntax error
if module.main_code != None :
funcInfo = _updateFunctionWarnings(module, module.main_code,
None, warnings, globalRefs, 1)
for code in funcInfo[1] :
classCodes[code.co_name] = code
_findFunctionWarnings(module, globalRefs, warnings, suppressions)
for c in module.classes.values() :
_findClassWarnings(module, c, classCodes.get(c.name),
globalRefs, warnings, suppressions)
if cfg().noDocModule and \
module.module != None and module.module.__doc__ == None :
warnings.append(Warning(module.filename(), 1, msgs.NO_MODULE_DOC))
if cfg().allVariablesUsed or cfg().privateVariableUsed :
prefix = None
if not cfg().allVariablesUsed :
prefix = "_"
for ignoreVar in cfg().variablesToIgnore + cfg().unusedNames :
globalRefs[ignoreVar] = ignoreVar
warnings.extend(_getUnused(module, globalRefs, module.variables,
msgs.VAR_NOT_USED, prefix))
if cfg().importUsed :
if module.moduleName != utils.INIT or cfg().packageImportUsed :
# always ignore readline module, if [raw_]input() is used
if globalRefs.has_key('input') or \
globalRefs.has_key('raw_input'):
globalRefs['readline'] = 0
warnings.extend(_getUnused(module, globalRefs, module.modules,
msgs.IMPORT_NOT_USED))
if module.main_code != None :
utils.popConfig()
if modSuppress is not None :
utils.popConfig()
std_lib = None
if cfg().ignoreStandardLibrary :
std_lib = getStandardLibraries()
return removeWarnings(warnings, getBlackList(cfg().blacklist), std_lib,
cfg())
if 0:
# if you want to test w/psyco, include this
import psyco
psyco.bind(_checkCode)
|