#!/usr/bin/env python
# Copyright (c) 2001-2006, MetaSlash Inc. All rights reserved.
# Portions Copyright (c) 2005, Google, Inc. All rights reserved.
"""
Find warnings in byte code from Python source files.
"""
import string
import types
from pychecker import msgs
from pychecker import utils
from pychecker import Warning
from pychecker import OP
from pychecker import Stack
from pychecker import python
__pychecker__ = 'no-argsused'
def cfg() :
return utils.cfg()
def getFunctionArgErr(func_name, argCount, minArgs, maxArgs):
err = None
if maxArgs == None:
if argCount < minArgs :
err = msgs.INVALID_ARG_COUNT2 % (func_name, argCount, minArgs)
elif argCount < minArgs or argCount > maxArgs:
if minArgs == maxArgs:
err = msgs.INVALID_ARG_COUNT1 % (func_name, argCount, minArgs)
else:
err = msgs.INVALID_ARG_COUNT3 % (func_name, argCount, minArgs, maxArgs)
return err
def _checkFunctionArgCount(code, func_name, argCount, minArgs, maxArgs,
objectReference = 0) :
# there is an implied argument for object creation and self.xxx()
if objectReference :
minArgs = minArgs - 1
if maxArgs is not None :
maxArgs = maxArgs - 1
err = getFunctionArgErr(func_name, argCount, minArgs, maxArgs)
if err :
code.addWarning(err)
def _checkFunctionArgs(code, func, objectReference, argCount, kwArgs,
check_arg_count = 1) :
func_name = func.function.func_code.co_name
if kwArgs :
args_len = func.function.func_code.co_argcount
arg_names = func.function.func_code.co_varnames[argCount:args_len]
if argCount < args_len and kwArgs[0] in arg_names:
if cfg().namedArgs :
code.addWarning(msgs.FUNC_USES_NAMED_ARGS % func_name)
# convert the named args into regular params, and really check
while argCount < args_len and kwArgs and kwArgs[0] in arg_names:
argCount = argCount + 1
kwArgs = kwArgs[1:]
_checkFunctionArgs(code, func, objectReference, argCount, kwArgs,
check_arg_count)
return
if not func.supportsKW :
code.addWarning(msgs.FUNC_DOESNT_SUPPORT_KW % func_name)
if check_arg_count :
_checkFunctionArgCount(code, func_name, argCount,
func.minArgs, func.maxArgs, objectReference)
def _getReferenceFromModule(module, identifier) :
func = module.functions.get(identifier, None)
if func is not None :
return func, None, 0
create = 0
c = module.classes.get(identifier, None)
if c is not None :
func = c.methods.get(utils.INIT, None)
create = 1
return func, c, create
def _getFunction(module, stackValue) :
'Return (function, class) from the stack value'
identifier = stackValue.data
if type(identifier) == types.StringType :
return _getReferenceFromModule(module, identifier)
# find the module this references
i, maxLen = 0, len(identifier)
while i < maxLen :
id = utils.safestr(identifier[i])
if module.classes.has_key(id) or module.functions.has_key(id) :
break
refModule = module.modules.get(id, None)
if refModule is not None :
module = refModule
else :
return None, None, 0
i = i + 1
# if we got to the end, there is only modules, nothing we can do
# we also can't handle if there is more than 2 items left
if i >= maxLen or (i+2) < maxLen :
return None, None, 0
if (i+1) == maxLen :
return _getReferenceFromModule(module, identifier[-1])
# we can't handle self.x.y
if (i+2) == maxLen and identifier[0] == cfg().methodArgName:
return None, None, 0
c = module.classes.get(identifier[-2], None)
if c is None :
return None, None, 0
return c.methods.get(identifier[-1], None), c, 0
def _validateKwArgs(code, info, func_name, kwArgs):
if len(info) < 4:
code.addWarning(msgs.FUNC_DOESNT_SUPPORT_KW % func_name)
elif not info[3]:
return
try:
# info could be from a builtin method which means that
# info[3] is not a list.
dummy = info[3][0]
except IndexError:
return
for arg in kwArgs:
if arg not in info[3]:
code.addWarning(msgs.FUNC_DOESNT_SUPPORT_KW_ARG % (func_name, arg))
def _checkBuiltin(code, loadValue, argCount, kwArgs, check_arg_count = 1) :
returnValue = Stack.makeFuncReturnValue(loadValue, argCount)
func_name = loadValue.data
if loadValue.type == Stack.TYPE_GLOBAL :
info = python.GLOBAL_FUNC_INFO.get(func_name, None)
if info is not None :
if func_name == 'input' and cfg().usesInput:
code.addWarning(msgs.USES_INPUT)
if cfg().constAttr and \
((func_name == 'setattr' and argCount >= 2) or
(func_name == 'getattr' and argCount == 2)):
arg2 = code.stack[-argCount + 1]
if arg2.const:
# lambda with setattr and const is a common way of setting
# attributes, so allow it
if code.func.function.func_name != '<lambda>':
code.addWarning(msgs.USES_CONST_ATTR % func_name)
if kwArgs:
_validateKwArgs(code, info, func_name, kwArgs)
elif check_arg_count :
_checkFunctionArgCount(code, func_name, argCount,
info[1], info[2])
returnValue = Stack.Item(returnValue.data, info[0])
returnValue.setStringType(info[0])
elif type(func_name) == types.TupleType and len(func_name) <= 2 :
objType = code.typeMap.get(utils.safestr(func_name[0]), [])
if types.ListType in objType :
try :
if func_name[1] == 'append' and argCount > 1 :
code.addWarning(msgs.LIST_APPEND_ARGS % func_name[0])
check_arg_count = 0
except AttributeError :
# FIXME: why do we need to catch AttributeError???
pass
if len(objType) == 1 :
# if it's a builtin, check method
builtinType = python.BUILTIN_METHODS.get(objType[0])
if builtinType is not None :
methodInfo = builtinType.get(func_name[1])
# set func properly
if kwArgs :
_validateKwArgs(code, methodInfo, func_name[1], kwArgs)
elif methodInfo :
returnValue = Stack.Item(func_name[1], methodInfo[0])
returnValue.setStringType(methodInfo[0])
if check_arg_count and methodInfo is not None :
_checkFunctionArgCount(code, func_name[1], argCount,
methodInfo[1], methodInfo[2])
return returnValue
_IMMUTABLE_LIST_METHODS = ('count', 'index',)
_IMMUTABLE_DICT_METHODS = ('copy', 'get', 'has_key',
'items', 'keys', 'values',
'iteritems', 'iterkeys', 'itervalues')
def _checkModifyDefaultArg(code, objectName, methodName=None) :
try :
value = code.func.defaultValue(objectName)
objectType = type(value)
if objectType in python.MUTABLE_TYPES :
if objectType == types.DictType and \
methodName in _IMMUTABLE_DICT_METHODS :
return
if objectType == types.ListType and \
methodName in _IMMUTABLE_LIST_METHODS :
return
code.addWarning(msgs.MODIFYING_DEFAULT_ARG % objectName)
except ValueError :
pass
def _isexception(object) :
# FIXME: i have no idea why this function is necessary
# it seems that the issubclass() should work, but it doesn't always
if hasattr(object, 'type'):
if object.type == types.TupleType:
# if we have a tuple, we can't check the contents (not enough info)
## for item in object.value:
## if not _isexception(item):
## return 0
return 1
try:
# try/except is necessary for globals like NotImplemented
if issubclass(object, Exception) :
return 1
# Python 2.5 added a BaseException to the hierarchy. That's
# really what we need to check if it exists.
if utils.pythonVersion() >= utils.PYTHON_2_5:
if issubclass(object, BaseException):
return 1
except TypeError:
return 0
for c in object.__bases__ :
if utils.startswith(utils.safestr(c), 'exceptions.') :
return 1
if len(c.__bases__) > 0 and _isexception(c) :
return 1
return 0
def _checkStringFind(code, loadValue):
if len(loadValue.data) == 2 and loadValue.data[1] == 'find':
try:
if types.StringType in code.typeMap.get(loadValue.data[0], []):
op = code.nextOpInfo()[0]
if OP.IS_CONDITIONAL_JUMP(op) or OP.IS_NOT(op):
code.addWarning(msgs.BAD_STRING_FIND)
except TypeError:
# we don't care if loadValue.data[0] is not hashable
pass
def _checkAbstract(refClass, code, name):
name_list = refClass.isAbstract()
if name_list:
name_list.sort()
names = string.join(name_list, ", ")
code.addWarning(msgs.METHODS_NEED_OVERRIDE % (names, name))
_SEQUENCE_TYPES = (types.TupleType, types.ListType, types.StringType)
try: _SEQUENCE_TYPES = _SEQUENCE_TYPES + (types.UnicodeType,)
except AttributeError: pass
# FIXME: this is not complete. errors will be caught only sometimes,
# depending on the order the functions/methods are processed
# in the dict. Need to be able to run through all functions
# twice, but because the code sucks, this is not possible.
def _checkReturnValueUse(code, func):
if func.returnValues is None:
return
err = None
opInfo = code.nextOpInfo()
if func.returnsNoValue():
# make sure we really know how to check for all the return types
for rv in func.returnValues:
if rv[1].type in _UNCHECKABLE_STACK_TYPES:
return
if not OP.POP_TOP(opInfo[0]):
err = msgs.USING_NONE_RETURN_VALUE % utils.safestr(func)
elif OP.UNPACK_SEQUENCE(opInfo[0]):
# verify unpacking into proper # of vars
varCount = opInfo[1]
stackRV = func.returnValues[0][1]
returnType = stackRV.getType({})
funcCount = stackRV.length
if returnType in _SEQUENCE_TYPES:
if varCount != funcCount and funcCount > 0:
err = msgs.WRONG_UNPACK_FUNCTION % (utils.safestr(func), funcCount, varCount)
elif returnType not in _UNCHECKABLE_STACK_TYPES:
err = msgs.UNPACK_NON_SEQUENCE % (utils.safestr(func), _getTypeStr(returnType))
if err:
code.addWarning(err)
def _handleFunctionCall(codeSource, code, argCount, indexOffset = 0,
check_arg_count = 1) :
'Checks for warnings, returns function called (may be None)'
if not code.stack :
return
kwArgCount = argCount >> utils.VAR_ARGS_BITS
argCount = argCount & utils.MAX_ARGS_MASK
# function call on stack is before the args, and keyword args
funcIndex = argCount + 2 * kwArgCount + 1 + indexOffset
if funcIndex > len(code.stack) :
funcIndex = 0
# to find on stack, we have to look backwards from top of stack (end)
funcIndex = -funcIndex
# store the keyword names/keys to check if using named arguments
kwArgs = []
if kwArgCount > 0 :
# loop backwards by 2 (keyword, value) in stack to find keyword args
for i in range(-2 - indexOffset, (-2 * kwArgCount - 1), -2) :
kwArgs.append(code.stack[i].data)
kwArgs.reverse()
loadValue = code.stack[funcIndex]
funcName = loadValue.getName()
returnValue = Stack.makeFuncReturnValue(loadValue, argCount)
if loadValue.isMethodCall(codeSource.classObject, cfg().methodArgName):
methodName = loadValue.data[1]
try :
m = codeSource.classObject.methods[methodName]
if m != None :
objRef = not m.isStaticMethod()
_checkFunctionArgs(code, m, objRef, argCount, kwArgs,
check_arg_count)
except KeyError :
sattr = codeSource.classObject.statics.get(methodName)
if sattr is not None :
funcName = sattr.getName()
if sattr is None and cfg().callingAttribute :
code.addWarning(msgs.INVALID_METHOD % methodName)
elif loadValue.type in (Stack.TYPE_ATTRIBUTE, Stack.TYPE_GLOBAL) and \
type(loadValue.data) in (types.StringType, types.TupleType) :
# apply(func, (args)), can't check # of args, so just return func
if loadValue.data == 'apply' :
loadValue = code.stack[funcIndex+1]
funcName = loadValue.getName()
else :
if cfg().modifyDefaultValue and \
type(loadValue.data) == types.TupleType :
_checkModifyDefaultArg(code, loadValue.data[0],
loadValue.data[1])
func, refClass, method = _getFunction(codeSource.module, loadValue)
if func == None and type(loadValue.data) == types.TupleType and \
len(loadValue.data) == 2 :
# looks like we are making a method call
data = loadValue.data
if type(data[0]) == types.StringType :
# do we know the type of the local variable?
varType = code.typeMap.get(data[0])
if varType is not None and len(varType) == 1 :
if hasattr(varType[0], 'methods') :
# it's a class & we know the type, get the method
func = varType[0].methods.get(data[1])
if func is not None :
method = 1
if cfg().abstractClasses and refClass and method:
_checkAbstract(refClass, code, funcName)
if cfg().stringFind:
_checkStringFind(code, loadValue)
if func != None :
if refClass and func.isClassMethod():
argCount = argCount + 1
_checkFunctionArgs(code, func, method, argCount, kwArgs,
check_arg_count)
# if this isn't a c'tor, we should check
if not (refClass and method) and cfg().checkReturnValues:
_checkReturnValueUse(code, func)
if refClass :
if method :
# c'tor, return the class as the type
returnValue = Stack.Item(loadValue, refClass)
elif func.isClassMethod():
# FIXME: do anything here?
pass
elif argCount > 0 and cfg().methodArgName and \
not func.isStaticMethod() and \
code.stack[funcIndex].type == Stack.TYPE_ATTRIBUTE and \
code.stack[funcIndex+1].data != cfg().methodArgName:
e = msgs.SELF_NOT_FIRST_ARG % (cfg().methodArgName, '')
code.addWarning(e)
elif refClass and method :
returnValue = Stack.Item(loadValue, refClass)
if (argCount > 0 or len(kwArgs) > 0) and \
not refClass.ignoreAttrs and \
not refClass.methods.has_key(utils.INIT) and \
not _isexception(refClass.classObject) :
code.addWarning(msgs.NO_CTOR_ARGS)
else :
returnValue = _checkBuiltin(code, loadValue, argCount, kwArgs,
check_arg_count)
if returnValue.type is types.NoneType and \
not OP.POP_TOP(code.nextOpInfo()[0]) :
name = utils.safestr(loadValue.data)
if type(loadValue.data) == types.TupleType :
name = string.join(loadValue.data, '.')
# lambda with setattr is a common way of setting
# attributes, so allow it
if name != 'setattr' \
or code.func.function.func_name != '<lambda>':
code.addWarning(msgs.USING_NONE_RETURN_VALUE % name)
code.stack = code.stack[:funcIndex] + [ returnValue ]
code.functionsCalled[funcName] = loadValue
def _classHasAttribute(c, attr) :
return (c.methods.has_key(attr) or c.members.has_key(attr) or
hasattr(c.classObject, attr))
def _checkClassAttribute(attr, c, code) :
if _classHasAttribute(c, attr) :
try :
del c.memberRefs[attr]
except KeyError :
pass
elif cfg().classAttrExists :
if attr not in cfg().missingAttrs:
code.addWarning(msgs.INVALID_CLASS_ATTR % attr)
def _checkModuleAttribute(attr, module, code, ref) :
try:
if attr not in module.modules[ref].attributes and \
not utils.endswith(ref, '.' + attr) :
code.addWarning(msgs.INVALID_MODULE_ATTR % attr)
except (KeyError, TypeError):
# if ref isn't found, or ref isn't even hashable, we don't care
# we may not know, or ref could be something funky [e for e].method()
pass
try:
_checkClassAttribute(attr, module.classes[ref], code)
except (KeyError, TypeError):
# if ref isn't found, or ref isn't even hashable, we don't care
# we may not know, or ref could be something funky [e for e].method()
pass
def _getGlobalName(name, func) :
# get the right name of global refs (for from XXX import YYY)
opModule = func.function.func_globals.get(name)
try :
if opModule and isinstance(opModule, types.ModuleType) :
name = opModule.__name__
except :
# we have to do this in case the class raises an access exception
# due to overriding __special__() methods
pass
return name
def _checkNoEffect(code, ignoreStmtWithNoEffect=0):
if (not ignoreStmtWithNoEffect and
OP.POP_TOP(code.nextOpInfo()[0]) and cfg().noEffect):
code.addWarning(msgs.POSSIBLE_STMT_WITH_NO_EFFECT)
def _makeConstant(code, index, factoryFunction) :
"Build a constant on the stack ((), [], or {})"
if index > 0 :
code.stack[-index:] = [ factoryFunction(code.stack[-index:]) ]
_checkNoEffect(code)
else :
code.pushStack(factoryFunction())
def _hasGlobal(operand, module, func, main) :
return (func.function.func_globals.has_key(operand) or
main or module.moduleLineNums.has_key(operand) or
__builtins__.has_key(operand))
def _checkGlobal(operand, module, func, code, err, main = 0) :
if not _hasGlobal(operand, module, func, main) :
code.addWarning(err % operand)
if not cfg().reportAllGlobals :
func.function.func_globals[operand] = operand
def _handleComparison(stack, operand) :
num_ops = 2
if operand == 'exception match':
num_ops = 1
si = min(len(stack), num_ops)
compareValues = stack[-si:]
for _ in range(si, 2) :
compareValues.append(Stack.Item(None, None))
stack[-si:] = [ Stack.makeComparison(compareValues, operand) ]
return compareValues
def _handleImport(code, operand, module, main, fromName) :
# FIXME: this function should be refactored/cleaned up
key = operand
tmpOperand = tmpFromName = operand
if fromName is not None :
tmpOperand = tmpFromName = fromName
key = (fromName, operand)
if cfg().deprecated:
try:
undeprecated = python.DEPRECATED_MODULES[tmpFromName]
except KeyError:
pass
else:
msg = msgs.USING_DEPRECATED_MODULE % tmpFromName
if undeprecated:
msg.data = msg.data + msgs.USE_INSTEAD % undeprecated
code.addWarning(msg)
if cfg().reimportSelf and tmpOperand == module.module.__name__ :
code.addWarning(msgs.IMPORT_SELF % tmpOperand)
modline1 = module.moduleLineNums.get(tmpOperand, None)
modline2 = module.moduleLineNums.get((tmpFromName, '*'), None)
key2 = (tmpFromName,)
if fromName is not None and operand != '*' :
key2 = (tmpFromName, operand)
modline3 = module.moduleLineNums.get(key2, None)
if modline1 is not None or modline2 is not None or modline3 is not None :
err = None
if fromName is None :
if modline1 is not None :
err = msgs.MODULE_IMPORTED_AGAIN % operand
elif cfg().mixImport :
err = msgs.MIX_IMPORT_AND_FROM_IMPORT % tmpFromName
else :
if modline3 is not None and operand != '*' :
err = 'from %s import %s' % (tmpFromName, operand)
err = msgs.MODULE_MEMBER_IMPORTED_AGAIN % err
elif modline1 is not None :
if cfg().mixImport and code.getLineNum() != modline1[1] :
err = msgs.MIX_IMPORT_AND_FROM_IMPORT % tmpFromName
else :
err = msgs.MODULE_MEMBER_ALSO_STAR_IMPORTED % fromName
# filter out warnings when files are different (ie, from X import ...)
if err is not None and cfg().moduleImportErrors :
bytes = module.main_code
if bytes is None or \
bytes.function.func_code.co_filename == code.func_code.co_filename :
code.addWarning(err)
if main :
fileline = (code.func_code.co_filename, code.getLineNum())
module.moduleLineNums[key] = fileline
if fromName is not None :
module.moduleLineNums[(fromName,)] = fileline
def _handleImportFrom(code, operand, module, main) :
fromName = code.stack[-1].data
if utils.pythonVersion() < utils.PYTHON_2_0 and \
OP.POP_TOP(code.nextOpInfo()[0]):
code.popNextOp()
code.pushStack(Stack.Item(operand, types.ModuleType))
_handleImport(code, operand, module, main, fromName)
# http://www.python.org/doc/current/lib/typesseq-strings.html
_FORMAT_CONVERTERS = 'diouxXeEfFgGcrs'
# NOTE: lLh are legal in the flags, but are ignored by python, we warn
_FORMAT_FLAGS = '*#- +.' + string.digits
def _getFormatInfo(format, code) :
vars = []
# first get rid of all the instances of %% in the string, they don't count
format = string.replace(format, "%%", "")
sections = string.split(format, '%')
percentFormatCount = formatCount = string.count(format, '%')
mappingFormatCount = 0
# skip the first item in the list, it's always empty
for section in sections[1:] :
orig_section = section
if not section:
w = msgs.INVALID_FORMAT % orig_section
w.data = w.data + ' (end of format string)'
code.addWarning(w)
continue
# handle dictionary formats
if section[0] == '(' :
mappingFormatCount = mappingFormatCount + 1
varname = string.split(section, ')')
if varname[1] == '' :
code.addWarning(msgs.INVALID_FORMAT % section)
vars.append(varname[0][1:])
section = varname[1]
if not section :
# no format data to check
continue
# FIXME: we ought to just define a regular expression to check
# formatRE = '[ #+-]*([0-9]*|*)(|.(|*|[0-9]*)[diouxXeEfFgGcrs].*'
stars = 0
for i in range(0, len(section)) :
if section[i] in _FORMAT_CONVERTERS :
break
if section[i] in _FORMAT_FLAGS :
if section[i] == '*' :
stars = stars + 1
if mappingFormatCount > 0 :
code.addWarning(msgs.USING_STAR_IN_FORMAT_MAPPING % section)
if stars > 2 :
code.addWarning(msgs.TOO_MANY_STARS_IN_FORMAT)
formatCount = formatCount + stars
if section[i] not in _FORMAT_CONVERTERS :
code.addWarning(msgs.INVALID_FORMAT % orig_section)
if mappingFormatCount > 0 and mappingFormatCount != percentFormatCount :
code.addWarning(msgs.CANT_MIX_MAPPING_IN_FORMATS)
return formatCount, vars
def _getConstant(code, module, data) :
data = utils.safestr(data.data)
format = code.constants.get(data)
if format is not None :
return format
format = module.variables.get(data)
if format is not None and format.value is not None :
return format.value
return None
_UNCHECKABLE_FORMAT_STACK_TYPES = \
(Stack.TYPE_UNKNOWN, Stack.TYPE_FUNC_RETURN, Stack.TYPE_ATTRIBUTE,
Stack.TYPE_GLOBAL, Stack.TYPE_EXCEPT)
_UNCHECKABLE_STACK_TYPES = _UNCHECKABLE_FORMAT_STACK_TYPES + (types.NoneType,)
def _getFormatString(code, codeSource) :
if len(code.stack) <= 1 :
return ''
format = code.stack[-2]
if format.type != types.StringType or not format.const :
format = _getConstant(code, codeSource.module, format)
if format is None or type(format) != types.StringType :
return ''
return format
return format.data
def _getFormatWarnings(code, codeSource) :
format = _getFormatString(code, codeSource)
if not format :
return
args = 0
count, vars = _getFormatInfo(format, code)
topOfStack = code.stack[-1]
if topOfStack.isLocals() :
for varname in vars :
if not code.unusedLocals.has_key(varname) :
code.addWarning(msgs.NO_LOCAL_VAR % varname)
else :
code.unusedLocals[varname] = None
else :
stackItemType = topOfStack.getType(code.typeMap)
if ((stackItemType == types.DictType and len(vars) > 0) or
codeSource.func.isParam(topOfStack.data) or
stackItemType in _UNCHECKABLE_FORMAT_STACK_TYPES) :
return
if topOfStack.type == types.TupleType :
args = topOfStack.length
elif stackItemType == types.TupleType :
args = len(code.constants.get(topOfStack.data, (0,)))
else :
args = 1
if args and count != args :
code.addWarning(msgs.INVALID_FORMAT_COUNT % (count, args))
def _checkAttributeType(code, stackValue, attr) :
if not cfg().checkObjectAttrs :
return
varTypes = code.typeMap.get(utils.safestr(stackValue.data), None)
if not varTypes :
return
# the value may have been converted on stack (`v`)
other_types = []
if stackValue.type not in varTypes :
other_types = [stackValue.type]
for varType in varTypes + other_types :
# ignore built-in types that have no attributes
if python.METHODLESS_OBJECTS.has_key(varType) :
continue
attrs = python.BUILTIN_ATTRS.get(varType, None)
if attrs is not None :
if attr in attrs :
return
continue
if hasattr(varType, 'ignoreAttrs') :
if varType.ignoreAttrs or _classHasAttribute(varType, attr) :
return
elif not hasattr(varType, 'attributes') or attr in varType.attributes :
return
code.addWarning(msgs.OBJECT_HAS_NO_ATTR % (stackValue.data, attr))
def _getTypeStr(t):
returnStr = utils.safestr(t)
strs = string.split(returnStr, "'")
try:
if len(strs) == 3:
returnStr = strs[-2]
except IndexError:
pass
return returnStr
def _getLineNum(co, instr_index):
co_lnotab = co.co_lnotab
lineno = co.co_firstlineno
addr = 0
for lnotab_index in range(0, len(co_lnotab), 2):
addr = addr + ord(co_lnotab[lnotab_index])
if addr > instr_index:
return lineno
lineno = lineno + ord(co_lnotab[lnotab_index+1])
return lineno
class Code :
'Hold all the code state information necessary to find warnings'
def __init__(self) :
self.bytes = None
self.func = None
self.func_code = None
self.index = 0
self.indexList = []
self.extended_arg = 0
self.lastLineNum = 0
self.maxCode = 0
self.has_except = 0
self.try_finally_first = 0
self.starts_and_ends_with_finally = 0
self.returnValues = []
self.raiseValues = []
self.stack = []
self.unpackCount = 0
self.loops = 0
self.branches = {}
self.warnings = []
self.globalRefs = {}
self.unusedLocals = {}
self.deletedLocals = {}
self.functionsCalled = {}
self.typeMap = {}
self.constants = {}
self.codeObjects = {}
def init(self, func) :
self.func = func
self.func_code, self.bytes, self.index, self.maxCode, self.extended_arg = \
OP.initFuncCode(func.function)
self.lastLineNum = self.func_code.co_firstlineno
self.returnValues = []
# initialize the arguments to unused
for arg in func.arguments() :
self.unusedLocals[arg] = 0
self.typeMap[arg] = [ Stack.TYPE_UNKNOWN ]
def getLineNum(self):
line = self.lastLineNum
# if we don't have linenum info, calc it from co_lntab & index
if line == self.func_code.co_firstlineno:
# FIXME: this could be optimized, if we kept last line info
line = _getLineNum(self.func_code, self.index - 1)
return line
def getWarning(self, err, line = None) :
if line is None :
line = self.getLineNum()
return Warning.Warning(self.func_code, line, err)
def addWarning(self, err, line = None) :
w = err
if not isinstance(w, Warning.Warning):
w = self.getWarning(err, line)
self.warnings.append(w)
def popNextOp(self) :
self.indexList.append(self.index)
info = OP.getInfo(self.bytes, self.index, self.extended_arg)
op, oparg, self.index, self.extended_arg = info
if op < OP.HAVE_ARGUMENT :
utils.debug(" %d %s" % (self.indexList[-1], OP.name[op]))
operand = None
else :
operand = OP.getOperand(op, self.func_code, oparg)
self.label = label = OP.getLabel(op, oparg, self.index)
utils.debug(" %d %s" % (self.indexList[-1], OP.name[op]), oparg, operand)
if label != None :
self.addBranch(label)
return op, oparg, operand
def nextOpInfo(self, offset = 0) :
try :
return OP.getInfo(self.bytes, self.index + offset, 0)[0:3]
except IndexError :
return -1, 0, -1
def getFirstOp(self) :
# find the first real op, maybe we should not check if params are used
i = extended_arg = 0
while i < self.maxCode :
op, oparg, i, extended_arg = OP.getInfo(self.bytes, i, extended_arg)
if not OP.LINE_NUM(op) :
if not (OP.LOAD_CONST(op) or OP.LOAD_GLOBAL(op)) :
return op
raise RuntimeError('Could not find first opcode in function')
def pushStack(self, item, ignoreStmtWithNoEffect=0):
self.stack.append(item)
_checkNoEffect(self, ignoreStmtWithNoEffect)
def popStack(self) :
if self.stack :
del self.stack[-1]
def popStackItems(self, count) :
stackLen = len(self.stack)
if stackLen > 0 :
count = min(count, stackLen)
del self.stack[-count:]
def unpack(self) :
if self.unpackCount :
self.unpackCount = self.unpackCount - 1
else :
self.popStack()
def __getStringStackType(self, data) :
try :
return data.getType({})
except AttributeError :
return Stack.TYPE_UNKNOWN
def __getStackType(self) :
if not self.stack :
return Stack.TYPE_UNKNOWN
if not self.unpackCount :
return self.__getStringStackType(self.stack[-1])
data = self.stack[-1].data
if type(data) == types.TupleType :
try :
return self.__getStringStackType(data[len(data)-self.unpackCount])
except IndexError :
# happens when unpacking a var for which we don't know the size
pass
return Stack.TYPE_UNKNOWN
def setType(self, name) :
valueList = self.typeMap.get(name, [])
newType = self.__getStackType()
# longs are being merged with ints, assume they are the same
# comparisons are really ints anyways
if newType in (types.LongType, Stack.TYPE_COMPARISON):
newType = types.IntType
if newType not in valueList :
valueList.append(newType)
# need to ignore various types (Unknown, Func return values, etc)
# also ignore None, don't care if they use it and a real type
if valueList and newType not in _UNCHECKABLE_STACK_TYPES and \
cfg().inconsistentTypes:
oldTypes = []
# only add types to the value list that are "interesting"
for typeToAdd in valueList:
if typeToAdd not in _UNCHECKABLE_STACK_TYPES and \
typeToAdd != newType:
oldTypes.append(_getTypeStr(typeToAdd))
# do we have any "interesting" old types? if so, warn
if oldTypes:
self.addWarning(msgs.INCONSISTENT_TYPE % \
(name, oldTypes, _getTypeStr(newType)))
self.typeMap[name] = valueList
def addReturn(self) :
if len(self.stack) > 0 :
value = (self.getLineNum(), self.stack[-1], self.nextOpInfo()[2])
self.returnValues.append(value)
self.popStack()
def addRaise(self) :
self.raiseValues.append((self.getLineNum(), None, self.nextOpInfo()[2]))
def addBranch(self, label) :
if label is not None :
self.branches[label] = self.branches.get(label, 0) + 1
def removeBranch(self, label) :
branch = self.branches.get(label, None)
if branch is not None :
if branch == 1 :
del self.branches[label]
else :
self.branches[label] = branch - 1
def remove_unreachable_code(self, label) :
if len(self.indexList) >= 2 :
index = self.indexList[-2]
if index >= 0 and OP.POP_BLOCK(ord(self.bytes[index])) :
index = self.indexList[-3]
if index >= 0 :
op = ord(self.bytes[index])
if OP.RETURN_VALUE(op) or OP.RAISE_VARARGS(op) or \
OP.END_FINALLY(ord(self.bytes[label-1])) :
self.removeBranch(label)
def updateCheckerArgs(self, operand) :
rc = utils.shouldUpdateArgs(operand)
if rc :
utils.updateCheckerArgs(self.stack[-1].data, self.func_code,
self.getLineNum(), self.warnings)
return rc
def updateModuleLineNums(self, module, operand) :
filelist = (self.func_code.co_filename, self.getLineNum())
module.moduleLineNums[operand] = filelist
class CodeSource :
'Holds source information about a code block (module, class, func, etc)'
def __init__(self, module, func, c, main, in_class, code) :
self.module = module
self.func = func
self.classObject = c
self.main = main
self.in_class = in_class
self.code = code
self.calling_code = []
def _checkException(code, name) :
if code.stack and code.stack[-1].type == Stack.TYPE_EXCEPT :
if __builtins__.has_key(name) :
code.addWarning(msgs.SET_EXCEPT_TO_BUILTIN % name)
def _checkAssign(code, name):
if name in _BAD_ASSIGN_NAMES:
code.addWarning(msgs.SHOULDNT_ASSIGN_BUILTIN % name)
else:
cap = string.capitalize(name)
if cap in _BAD_ASSIGN_NAMES:
code.addWarning(msgs.SHOULDNT_ASSIGN_NAME % (name, cap))
def _checkVariableOperationOnItself(code, lname, msg):
if code.stack and code.stack[-1].getName() == lname:
code.addWarning(msg % lname)
def _checkFutureKeywords(code, varname) :
kw = python.FUTURE_KEYWORDS.get(varname)
if kw is not None :
code.addWarning(msgs.USING_KEYWORD % (varname, kw))
def _STORE_NAME(oparg, operand, codeSource, code) :
if not code.updateCheckerArgs(operand) :
_checkFutureKeywords(code, operand)
module = codeSource.module
if not codeSource.in_class :
_checkShadowBuiltin(code, operand)
if not codeSource.calling_code :
_checkGlobal(operand, module, codeSource.func, code,
msgs.GLOBAL_DEFINED_NOT_DECLARED, codeSource.main)
else :
if code.stack :
codeSource.classObject.statics[operand] = code.stack[-1]
codeSource.classObject.lineNums[operand] = code.getLineNum()
var = module.variables.get(operand)
if var is not None and code.stack and code.stack[-1].const :
var.value = code.stack[-1].data
if code.unpackCount :
code.unpackCount = code.unpackCount - 1
else:
_checkAssign(code, operand)
_checkException(code, operand)
code.popStack()
if not module.moduleLineNums.has_key(operand) and codeSource.main :
code.updateModuleLineNums(module, operand)
_STORE_GLOBAL = _STORE_NAME
def _checkLoadGlobal(codeSource, code, varname) :
_checkFutureKeywords(code, varname)
should_check = 1
if code.func_code.co_name == utils.LAMBDA :
# this could really be a local reference, check first
if not codeSource.main and codeSource.calling_code:
func = getattr(codeSource.calling_code[-1], 'function', None)
if func is not None and varname in func.func_code.co_varnames :
_handleLoadLocal(code, codeSource, varname)
should_check = 0
if should_check :
# if a global var starts w/__ and the global is referenced in a class
# we have to strip off the _class-name, to get the original name
if codeSource.classObject and \
utils.startswith(varname, '_' + codeSource.classObject.name + '__'):
varname = varname[len(codeSource.classObject.name)+1:]
# make sure we remember each global ref to check for unused
code.globalRefs[_getGlobalName(varname, codeSource.func)] = varname
if not codeSource.in_class :
_checkGlobal(varname, codeSource.module, codeSource.func,
code, msgs.INVALID_GLOBAL)
def _LOAD_NAME(oparg, operand, codeSource, code) :
_checkLoadGlobal(codeSource, code, operand)
# if there was from XXX import *, _* names aren't imported
if codeSource.module.modules.has_key(operand) and \
hasattr(codeSource.module.module, operand) :
operand = getattr(codeSource.module.module, operand).__name__
opType, const = Stack.TYPE_GLOBAL, 0
if operand == 'None' :
opType, const = types.NoneType, 0
elif operand == 'Ellipsis' :
opType, const = types.EllipsisType, 1
code.pushStack(Stack.Item(operand, opType, const))
_LOAD_GLOBAL = _LOAD_NAME
def _LOAD_DEREF(oparg, operand, codeSource, code) :
if type(oparg) == types.IntType :
func_code = code.func_code
try:
argname = func_code.co_cellvars[oparg]
except IndexError:
argname = func_code.co_freevars[oparg - len(func_code.co_cellvars)]
code.pushStack(Stack.Item(argname, types.StringType))
if code.func_code.co_name != utils.LAMBDA :
code.unusedLocals[argname] = None
else :
_LOAD_GLOBAL(oparg, operand, codeSource, code)
_LOAD_CLOSURE = _LOAD_DEREF
def _DELETE_NAME(oparg, operand, codeSource, code) :
_checkLoadGlobal(codeSource, code, operand)
# FIXME: handle deleting global multiple times
_DELETE_GLOBAL = _DELETE_NAME
def _make_const(value):
if type(value) == types.TupleType:
return Stack.makeTuple(map(_make_const, value))
return Stack.Item(value, type(value), 1)
def _LOAD_CONST(oparg, operand, codeSource, code) :
code.pushStack(_make_const(operand))
if type(operand) == types.CodeType :
name = operand.co_name
obj = code.codeObjects.get(name, None)
if name == utils.LAMBDA :
# use a unique key, so we can have multiple lambdas
code.codeObjects[code.index] = operand
elif obj is None :
code.codeObjects[name] = operand
elif cfg().redefiningFunction :
code.addWarning(msgs.REDEFINING_ATTR % (name, obj.co_firstlineno))
def _checkLocalShadow(code, module, varname) :
if module.variables.has_key(varname) and cfg().shadows :
line = module.moduleLineNums.get(varname, ('<unknown>', 0))
w = code.getWarning(msgs.LOCAL_SHADOWS_GLOBAL % (varname, line[1]))
if line[0] != w.file:
w.err = '%s in file %s' % (w.err, line[0])
code.addWarning(w)
def _checkShadowBuiltin(code, varname) :
if __builtins__.has_key(varname) and varname[0] != '_' and \
cfg().shadowBuiltins:
code.addWarning(msgs.VARIABLE_SHADOWS_BUILTIN % varname)
def _checkLoadLocal(code, codeSource, varname, deletedWarn, usedBeforeSetWarn) :
_checkFutureKeywords(code, varname)
deletedLine = code.deletedLocals.get(varname)
if deletedLine :
code.addWarning(deletedWarn % (varname, deletedLine))
elif not code.unusedLocals.has_key(varname) and \
not codeSource.func.isParam(varname) :
code.addWarning(usedBeforeSetWarn % varname)
code.unusedLocals[varname] = None
_checkLocalShadow(code, codeSource.module, varname)
def _handleLoadLocal(code, codeSource, varname) :
_checkLoadLocal(code, codeSource, varname,
msgs.LOCAL_DELETED, msgs.VAR_USED_BEFORE_SET)
def _LOAD_FAST(oparg, operand, codeSource, code) :
code.pushStack(Stack.Item(operand, type(operand)))
_handleLoadLocal(code, codeSource, operand)
def _STORE_FAST(oparg, operand, codeSource, code) :
if not code.updateCheckerArgs(operand) :
_checkFutureKeywords(code, operand)
if code.stack and code.stack[-1].type == types.StringType and \
not code.stack[-1].const:
_checkVariableOperationOnItself(code, operand,
msgs.SET_VAR_TO_ITSELF)
code.setType(operand)
if not code.unpackCount and code.stack and \
(code.stack[-1].const or code.stack[-1].type == types.TupleType) :
if code.constants.has_key(operand) :
del code.constants[operand]
else :
code.constants[operand] = code.stack[-1].data
_checkLocalShadow(code, codeSource.module, operand)
_checkShadowBuiltin(code, operand)
_checkAssign(code, operand)
_checkException(code, operand)
if code.deletedLocals.has_key(operand) :
del code.deletedLocals[operand]
if not code.unusedLocals.has_key(operand) :
errLine = code.getLineNum()
if code.unpackCount and not cfg().unusedLocalTuple :
errLine = -errLine
code.unusedLocals[operand] = errLine
code.unpack()
def _DELETE_FAST(oparg, operand, codeSource, code) :
_checkLoadLocal(code, codeSource, operand,
msgs.LOCAL_ALREADY_DELETED, msgs.VAR_DELETED_BEFORE_SET)
code.deletedLocals[operand] = code.getLineNum()
def _checkAttribute(top, operand, codeSource, code) :
if top.data == cfg().methodArgName and codeSource.classObject != None :
_checkClassAttribute(operand, codeSource.classObject, code)
elif type(top.type) == types.StringType or top.type == types.ModuleType :
_checkModuleAttribute(operand, codeSource.module, code, top.data)
else :
_checkAttributeType(code, top, operand)
def _checkExcessiveReferences(code, top, extraAttr = None) :
if cfg().maxReferences <= 0 :
return
try :
data = top.data
if extraAttr is not None :
data = data + (extraAttr,)
maxReferences = cfg().maxReferences
if data[0] == cfg().methodArgName:
maxReferences = maxReferences + 1
if len(data) > maxReferences :
name = string.join(top.data, '.')
code.addWarning(msgs.TOO_MANY_REFERENCES % (maxReferences, name))
except TypeError :
pass
def _checkDeprecated(code, identifierTuple):
# check deprecated module.function
try:
name = string.join(identifierTuple, '.')
undeprecated = python.DEPRECATED_ATTRS[name]
except (KeyError, TypeError):
pass
else:
msg = msgs.USING_DEPRECATED_ATTR % name
if undeprecated:
msg.data = msg.data + msgs.USE_INSTEAD % undeprecated
code.addWarning(msg)
def _LOAD_ATTR(oparg, operand, codeSource, code) :
if len(code.stack) > 0 :
top = code.stack[-1]
_checkAttribute(top, operand, codeSource, code)
top.addAttribute(operand)
if len(top.data) == 2:
if cfg().deprecated:
_checkDeprecated(code, top.data)
try:
insecure = python.SECURITY_FUNCS.get(top.data[0])
except TypeError:
pass
else:
if insecure and insecure.has_key(operand):
func = string.join(top.data, '.')
code.addWarning(msgs.USING_INSECURE_FUNC % func)
nextOp = code.nextOpInfo()[0]
if not OP.LOAD_ATTR(nextOp) :
if OP.POP_TOP(nextOp) and cfg().noEffect:
code.addWarning(msgs.POSSIBLE_STMT_WITH_NO_EFFECT)
else :
_checkExcessiveReferences(code, top)
def _ok_to_set_attr(classObject, basename, attr) :
return (cfg().onlyCheckInitForMembers and classObject != None and
basename == cfg().methodArgName and
not _classHasAttribute(classObject, attr))
def _STORE_ATTR(oparg, operand, codeSource, code) :
if code.stack :
top = code.stack.pop()
top_name = '%s.%s' % (top.getName(), operand)
try:
# FIXME: this is a hack to handle code like:
# a.a = [x for x in range(2) if x > 1]
previous = code.stack[-1]
except IndexError:
previous = None
if top.type in (types.StringType, Stack.TYPE_ATTRIBUTE) and \
previous and previous.type == Stack.TYPE_ATTRIBUTE:
_checkVariableOperationOnItself(code, top_name,
msgs.SET_VAR_TO_ITSELF)
_checkExcessiveReferences(code, top, operand)
if _ok_to_set_attr(codeSource.classObject, top.data, operand) :
code.addWarning(msgs.INVALID_SET_CLASS_ATTR % operand)
code.unpack()
def _DELETE_ATTR(oparg, operand, codeSource, code) :
if len(code.stack) > 0 :
_checkAttribute(code.stack[-1], operand, codeSource, code)
def _getExceptionInfo(codeSource, item):
# FIXME: probably ought to try to handle raise module.Error
if item.type is types.StringType and item.const == 1:
return item.data, 1
e = None
if item.type is Stack.TYPE_GLOBAL:
try:
e = eval(item.data)
except NameError:
pass
if not e:
try:
c = codeSource.module.classes.get(item.data)
except TypeError: # item.data may not be hashable (e.g., list)
return e, 0
if c is not None:
e = c.classObject
else:
v = codeSource.module.variables.get(item.data)
if v is not None:
return v, (v.type == types.StringType)
return e, 0
_UNCHECKABLE_CATCH_TYPES = (Stack.TYPE_UNKNOWN, Stack.TYPE_ATTRIBUTE)
def _checkCatchException(codeSource, code, item):
if not cfg().badExceptions:
return
if item.data is None or item.type in _UNCHECKABLE_CATCH_TYPES:
return
e, is_str = _getExceptionInfo(codeSource, item)
if is_str:
code.addWarning(msgs.CATCH_STR_EXCEPTION % item.data)
elif e is not None and not _isexception(e):
code.addWarning(msgs.CATCH_BAD_EXCEPTION % item.data)
def _handleExceptionChecks(codeSource, code, checks):
for item in checks:
if item is not None:
if item.type is not types.TupleType:
_checkCatchException(codeSource, code, item)
else:
for ti in item.data:
if isinstance(ti, Stack.Item):
_checkCatchException(codeSource, code, ti)
_BOOL_NAMES = ('True', 'False')
_BAD_ASSIGN_NAMES = _BOOL_NAMES + ('None',)
def _checkBoolean(code, checks):
for item in checks:
try:
data = string.capitalize(item.data)
if item.type is Stack.TYPE_GLOBAL and data in _BOOL_NAMES:
code.addWarning(msgs.BOOL_COMPARE % item.data)
except (AttributeError, TypeError):
# TypeError is necessary for Python 1.5.2
pass # ignore items that are not a StackItem or a string
def _COMPARE_OP(oparg, operand, codeSource, code) :
compareValues = _handleComparison(code.stack, operand)
if oparg == OP.EXCEPT_COMPARISON:
_handleExceptionChecks(codeSource, code, compareValues)
elif oparg < OP.IN_COMPARISON: # '<', '<=', '==', '!=', '>', '>='
_checkBoolean(code, compareValues)
elif oparg < OP.IS_COMPARISON: # 'in', 'not in'
# TODO: any checks that should be done here?
pass
elif cfg().isLiteral:
# X is Y or X is not Y comparison
second_arg = code.stack[-1].data[2]
# FIXME: how should booleans be handled, need to think about it
## if second_arg.const or (second_arg.type == Stack.TYPE_GLOBAL and
## second_arg.data in ['True', 'False']):
if second_arg.const and second_arg.data is not None:
data = second_arg.data
if second_arg.type is types.DictType:
data = {}
not_str = ''
if oparg != OP.IS_COMPARISON:
not_str = ' not'
code.addWarning(msgs.IS_LITERAL % (not_str, data))
_checkNoEffect(code)
def _IMPORT_NAME(oparg, operand, codeSource, code) :
code.pushStack(Stack.Item(operand, types.ModuleType))
nextOp = code.nextOpInfo()[0]
if not OP.IMPORT_FROM(nextOp) and not OP.IMPORT_STAR(nextOp) :
_handleImport(code, operand, codeSource.module, codeSource.main, None)
def _IMPORT_FROM(oparg, operand, codeSource, code) :
_handleImportFrom(code, operand, codeSource.module, codeSource.main)
# this is necessary for python 1.5 (see STORE_GLOBAL/NAME)
if utils.pythonVersion() < utils.PYTHON_2_0 :
code.popStack()
if not codeSource.main :
code.unusedLocals[operand] = None
elif not codeSource.module.moduleLineNums.has_key(operand) :
code.updateModuleLineNums(codeSource.module, operand)
def _IMPORT_STAR(oparg, operand, codeSource, code) :
_handleImportFrom(code, '*', codeSource.module, codeSource.main)
# Python 2.3 introduced some optimizations that create problems
# this is a utility for ignoring these cases
def _shouldIgnoreCodeOptimizations(code, bytecodes, offset, length=None):
if utils.pythonVersion() < utils.PYTHON_2_3:
return 0
if length is None:
length = offset - 1
try:
start = code.index - offset
return bytecodes == code.bytes[start:start+length]
except IndexError:
return 0
# In Python 2.3, a, b = 1,2 generates this code:
# ...
# ROT_TWO
# JUMP_FORWARD 2
# DUP_TOP
# POP_TOP
#
# which generates a Possible stmt w/no effect
# ROT_TWO = 2; JUMP_FORWARD = 110; 2, 0 is the offset (2)
_IGNORE_SEQ = '%c%c%c%c' % (2, 110, 2, 0)
def _shouldIgnoreNoEffectWarning(code):
return _shouldIgnoreCodeOptimizations(code, _IGNORE_SEQ, 5)
def _DUP_TOP(oparg, operand, codeSource, code) :
if len(code.stack) > 0 :
code.pushStack(code.stack[-1], _shouldIgnoreNoEffectWarning(code))
def _popn(code, n) :
if len(code.stack) >= 2 :
loadValue = code.stack[-2]
if cfg().modifyDefaultValue and loadValue.type == types.StringType :
_checkModifyDefaultArg(code, loadValue.data)
code.popStackItems(n)
def _DELETE_SUBSCR(oparg, operand, codeSource, code) :
_popn(code, 2)
def _STORE_SUBSCR(oparg, operand, codeSource, code) :
_popn(code, 3)
def _CALL_FUNCTION(oparg, operand, codeSource, code) :
_handleFunctionCall(codeSource, code, oparg)
def _CALL_FUNCTION_VAR(oparg, operand, codeSource, code) :
_handleFunctionCall(codeSource, code, oparg, 1, 0)
def _CALL_FUNCTION_KW(oparg, operand, codeSource, code) :
_handleFunctionCall(codeSource, code, oparg, 1)
def _CALL_FUNCTION_VAR_KW(oparg, operand, codeSource, code) :
_handleFunctionCall(codeSource, code, oparg, 2, 0)
def _MAKE_FUNCTION(oparg, operand, codeSource, code) :
newValue = Stack.makeFuncReturnValue(code.stack[-1], oparg)
code.popStackItems(oparg+1)
code.pushStack(newValue)
def _MAKE_CLOSURE(oparg, operand, codeSource, code) :
_MAKE_FUNCTION(max(0, oparg - 1), operand, codeSource, code)
def _BUILD_MAP(oparg, operand, codeSource, code) :
_makeConstant(code, oparg, Stack.makeDict)
def _BUILD_TUPLE(oparg, operand, codeSource, code) :
_makeConstant(code, oparg, Stack.makeTuple)
def _BUILD_LIST(oparg, operand, codeSource, code) :
_makeConstant(code, oparg, Stack.makeList)
def _BUILD_CLASS(oparg, operand, codeSource, code) :
newValue = Stack.makeFuncReturnValue(code.stack[-1], types.ClassType)
code.popStackItems(3)
code.pushStack(newValue)
def _LIST_APPEND(oparg, operand, codeSource, code):
code.popStackItems(2)
def _modifyStackName(code, suffix):
if code.stack:
tos = code.stack[-1]
tos_type = type(tos.data)
if tos_type == types.StringType:
tos.data = tos.data + suffix
elif tos_type == types.TupleType and \
type(tos.data[-1]) == types.StringType:
tos.data = tos.data[:-1] + (tos.data[-1] + suffix,)
def _UNARY_CONVERT(oparg, operand, codeSource, code) :
if code.stack:
stackValue = code.stack[-1]
if stackValue.data == cfg().methodArgName and \
stackValue.const == 0 and codeSource.classObject is not None and \
codeSource.func.function.func_name == '__repr__' :
code.addWarning(msgs.USING_SELF_IN_REPR)
stackValue.data = utils.safestr(stackValue.data)
stackValue.type = types.StringType
_modifyStackName(code, '-repr')
def _UNARY_POSITIVE(oparg, operand, codeSource, code) :
if OP.UNARY_POSITIVE(code.nextOpInfo()[0]) :
code.addWarning(msgs.STMT_WITH_NO_EFFECT % '++')
code.popNextOp()
elif cfg().unaryPositive and code.stack and not code.stack[-1].const :
code.addWarning(msgs.UNARY_POSITIVE_HAS_NO_EFFECT)
_modifyStackName(code, '-pos')
def _UNARY_NEGATIVE(oparg, operand, codeSource, code) :
if OP.UNARY_NEGATIVE(code.nextOpInfo()[0]) :
code.addWarning(msgs.STMT_WITH_NO_EFFECT % '--')
_modifyStackName(code, '-neg')
def _UNARY_NOT(oparg, operand, codeSource, code) :
_modifyStackName(code, '-not')
def _UNARY_INVERT(oparg, operand, codeSource, code) :
if OP.UNARY_INVERT(code.nextOpInfo()[0]) :
code.addWarning(msgs.STMT_WITH_NO_EFFECT % '~~')
_modifyStackName(code, '-invert')
def _popStackRef(code, operand, count = 2) :
code.popStackItems(count)
code.pushStack(Stack.Item(operand, Stack.TYPE_UNKNOWN))
def _popModifiedStack(code, suffix=' '):
code.popStack()
_modifyStackName(code, suffix)
def _pop(oparg, operand, codeSource, code) :
code.popStack()
_POP_TOP = _PRINT_ITEM = _pop
def _popModified(oparg, operand, codeSource, code):
_popModifiedStack(code)
def _BINARY_RSHIFT(oparg, operand, codeSource, code):
_coerce_type(code)
_popModified(oparg, operand, codeSource, code)
_BINARY_LSHIFT = _BINARY_RSHIFT
def _checkModifyNoOp(code, op, msg=msgs.MODIFY_VAR_NOOP, modifyStack=1):
stack = code.stack
if len(stack) >= 2:
if (stack[-1].type != Stack.TYPE_UNKNOWN and
stack[-2].type != Stack.TYPE_UNKNOWN):
name = stack[-1].getName()
if name != Stack.TYPE_UNKNOWN and name == stack[-2].getName():
code.addWarning(msg % (name, op, name))
if modifyStack:
code.popStack()
stack[-1].const = 0
_modifyStackName(code, op)
def _BINARY_AND(oparg, operand, codeSource, code):
# Don't modify the stack, since _coerce_type() will do it.
_checkModifyNoOp(code, '&', modifyStack=0)
_coerce_type(code)
def _BINARY_OR(oparg, operand, codeSource, code):
# Don't modify the stack, since _coerce_type() will do it.
_checkModifyNoOp(code, '|', modifyStack=0)
_coerce_type(code)
def _BINARY_XOR(oparg, operand, codeSource, code):
# Don't modify the stack, since _coerce_type() will do it.
_checkModifyNoOp(code, '^', msgs.XOR_VAR_WITH_ITSELF, modifyStack=0)
_coerce_type(code)
def _PRINT_ITEM_TO(oparg, operand, codeSource, code) :
code.popStackItems(2)
try:
ComplexType = types.ComplexType
except NameError:
ComplexType = types.FloatType # need some numeric type here
_NUMERIC_TYPES = (types.IntType, types.FloatType, ComplexType)
# FIXME: This is pathetically weak, need to handle more types
def _coerce_type(code) :
_checkNoEffect(code)
newItem = Stack.Item('<stack>', Stack.TYPE_UNKNOWN)
if len(code.stack) >= 2 :
s1, s2 = code.stack[-2:]
s1type = s1.getType(code.typeMap)
s2type = s2.getType(code.typeMap)
if s1type != s2type :
if s1type in _NUMERIC_TYPES and s2type in _NUMERIC_TYPES :
newType = types.FloatType
if s1type == ComplexType or s2type == ComplexType:
newType = ComplexType
newItem.type = newType
code.popStackItems(2)
code.pushStack(newItem)
def _BINARY_ADD(oparg, operand, codeSource, code) :
stack = code.stack
if len(stack) >= 2 and (stack[-1].const and stack[-2].const and
stack[-1].type == stack[-2].type) :
value = stack[-2].data + stack[-1].data
code.popStackItems(2)
code.pushStack(Stack.Item(value, type(value), 1))
else :
_coerce_type(code)
def _BINARY_SUBTRACT(oparg, operand, codeSource, code) :
_coerce_type(code)
_BINARY_POWER = _BINARY_SUBTRACT
def _BINARY_SUBSCR(oparg, operand, codeSource, code) :
_checkNoEffect(code)
if len(code.stack) >= 2 :
stack = code.stack
varType = code.typeMap.get(utils.safestr(stack[-2].data), [])
if types.ListType in varType and stack[-1].type == types.TupleType :
code.addWarning(msgs.USING_TUPLE_ACCESS_TO_LIST % stack[-2].data)
_popStackRef(code, operand)
def _isint(stackItem, code) :
if type(stackItem.data) == types.IntType :
return 1
stackTypes = code.typeMap.get(stackItem.data, [])
if len(stackTypes) != 1 :
return 0
return types.IntType in stackTypes
def _BINARY_DIVIDE(oparg, operand, codeSource, code) :
_checkNoEffect(code)
_checkModifyNoOp(code, '/', msgs.DIVIDE_VAR_BY_ITSELF, 0)
if cfg().intDivide and len(code.stack) >= 2 :
if _isint(code.stack[-1], code) and _isint(code.stack[-2], code) :
# don't warn if we are going to convert the result to an int
if not (len(code.stack) >= 3 and
code.stack[-3].data == 'int' and
OP.CALL_FUNCTION(code.nextOpInfo()[0])):
code.addWarning(msgs.INTEGER_DIVISION % tuple(code.stack[-2:]))
_popModifiedStack(code, '/')
def _BINARY_TRUE_DIVIDE(oparg, operand, codeSource, code) :
_checkNoEffect(code)
_checkVariableOperationOnItself(code, operand, msgs.DIVIDE_VAR_BY_ITSELF)
_popModifiedStack(code, '/')
_BINARY_FLOOR_DIVIDE = _BINARY_TRUE_DIVIDE
def _BINARY_MULTIPLY(oparg, operand, codeSource, code) :
if len(code.stack) >= 2 :
format = _getFormatString(code, codeSource)
if format and type(code.stack[-1].data) == types.IntType :
code.stack[-2].data = format * code.stack[-1].data
code.popStack()
else:
_coerce_type(code)
else:
_popModifiedStack(code, '*')
def _BINARY_MODULO(oparg, operand, codeSource, code) :
_checkNoEffect(code)
if cfg().modulo1 and code.stack and code.stack[-1].data == 1:
if len(code.stack) < 2 or \
code.stack[-2].getType(code.typeMap) != types.FloatType:
code.addWarning(msgs.MODULO_1)
_getFormatWarnings(code, codeSource)
_popModifiedStack(code, '%')
if code.stack:
code.stack[-1].const = 0
def _ROT_TWO(oparg, operand, codeSource, code) :
if len(code.stack) >= 2 :
tmp = code.stack[-2]
code.stack[-2] = code.stack[-1]
code.stack[-1] = tmp
def _ROT_THREE(oparg, operand, codeSource, code) :
"""Lifts second and third stack item one position up,
moves top down to position three."""
if len(code.stack) >= 3 :
second = code.stack[-2]
third = code.stack[-3]
code.stack[-3] = code.stack[-1]
code.stack[-2] = third
code.stack[-1] = second
def _ROT_FOUR(oparg, operand, codeSource, code) :
"""Lifts second, third and forth stack item one position up,
moves top down to position four."""
if len(code.stack) >= 4 :
second = code.stack[-2]
third = code.stack[-3]
fourth = code.stack[-4]
code.stack[-4] = code.stack[-1]
code.stack[-3] = fourth
code.stack[-2] = third
code.stack[-1] = second
def _SETUP_EXCEPT(oparg, operand, codeSource, code) :
code.has_except = 1
code.pushStack(Stack.Item(None, Stack.TYPE_EXCEPT))
code.pushStack(Stack.Item(None, Stack.TYPE_EXCEPT))
def _SETUP_FINALLY(oparg, operand, codeSource, code) :
if not code.has_except :
code.try_finally_first = 1
def _END_FINALLY(oparg, operand, codeSource, code) :
if code.try_finally_first and code.index == (len(code.bytes) - 4) :
code.starts_and_ends_with_finally = 1
def _LINE_NUM(oparg, operand, codeSource, code) :
code.lastLineNum = oparg
def _UNPACK_SEQUENCE(oparg, operand, codeSource, code) :
code.unpackCount = oparg
if code.stack:
top = code.stack[-1]
# if we know we have a tuple, make sure we unpack it into the
# right # of variables
topType = top.getType(code.typeMap)
if topType in _SEQUENCE_TYPES:
length = top.length
# we don't know the length, maybe it's constant and we can find out
if length == 0:
value = code.constants.get(utils.safestr(top.data))
if type(value) in _SEQUENCE_TYPES:
length = len(value)
if length > 0 and length != oparg:
if cfg().unpackLength:
code.addWarning(msgs.WRONG_UNPACK_SIZE % (length, oparg))
elif topType not in _UNCHECKABLE_STACK_TYPES:
if cfg().unpackNonSequence:
code.addWarning(msgs.UNPACK_NON_SEQUENCE %
(top.data, _getTypeStr(topType)))
_modifyStackName(code, '-unpack')
def _SLICE_1_ARG(oparg, operand, codeSource, code) :
_popStackRef(code, operand)
_SLICE1 = _SLICE2 = _SLICE_1_ARG
def _SLICE3(oparg, operand, codeSource, code) :
_popStackRef(code, operand, 3)
def _check_string_iteration(code, index):
try:
item = code.stack[index]
except IndexError:
return
if item.getType(code.typeMap) == types.StringType and \
cfg().stringIteration:
code.addWarning(msgs.STRING_ITERATION % item.data)
def _FOR_LOOP(oparg, operand, codeSource, code) :
code.loops = code.loops + 1
_check_string_iteration(code, -2)
_popStackRef(code, '<for_loop>', 2)
def _GET_ITER(oparg, operand, codeSource, code) :
_check_string_iteration(code, -1)
def _FOR_ITER(oparg, operand, codeSource, code) :
code.loops = code.loops + 1
_popStackRef(code, '<for_iter>', 1)
def _jump(oparg, operand, codeSource, code) :
if len(code.stack) > 0 :
topOfStack = code.stack[-1]
if topOfStack.isMethodCall(codeSource.classObject, cfg().methodArgName):
name = topOfStack.data[-1]
if codeSource.classObject.methods.has_key(name) :
code.addWarning(msgs.USING_METHOD_AS_ATTR % name)
_JUMP_ABSOLUTE = _jump
def _skip_loops(bytes, i, lastLineNum, max) :
extended_arg = 0
blockCount = 1
while i < max :
op, oparg, i, extended_arg = OP.getInfo(bytes, i, extended_arg)
if OP.LINE_NUM(op) :
lastLineNum = oparg
elif OP.FOR_LOOP(op) or OP.FOR_ITER(op) or OP.SETUP_LOOP(op) :
blockCount = blockCount + 1
elif OP.POP_BLOCK(op) :
blockCount = blockCount - 1
if blockCount <= 0 :
break
return lastLineNum, i
def _is_unreachable(code, topOfStack, branch, if_false) :
# Are we are checking exceptions, but we not catching all exceptions?
if (topOfStack.type == Stack.TYPE_COMPARISON and
topOfStack.data[1] == 'exception match' and
topOfStack.data[2] is not Exception) :
return 1
# do we possibly have while 1: ?
if not (topOfStack.const and topOfStack.data == 1 and if_false) :
return 0
# get the op just before the branch (ie, -3)
op, oparg, i, extended_arg = OP.getInfo(code.bytes, branch - 3, 0)
# are we are jumping to before the while 1: (LOAD_CONST, JUMP_IF_FALSE)
if not (OP.JUMP_ABSOLUTE(op) and oparg == (code.index - 3*3)) :
return 0
# check if we break out of the loop
i = code.index
lastLineNum = code.getLineNum()
while i < branch :
op, oparg, i, extended_arg = OP.getInfo(code.bytes, i, extended_arg)
if OP.LINE_NUM(op) :
lastLineNum = oparg
elif OP.BREAK_LOOP(op) :
return 0
elif OP.FOR_LOOP(op) or OP.FOR_ITER(op) or OP.SETUP_LOOP(op) :
lastLineNum, i = _skip_loops(code.bytes, i, lastLineNum, branch)
i = code.index - 3*4
op, oparg, i, extended_arg = OP.getInfo(code.bytes, i, 0)
if OP.SETUP_LOOP(op) :
# a little lie to pretend we have a raise after a while 1:
code.removeBranch(i + oparg)
code.raiseValues.append((lastLineNum, None, i + oparg))
return 1
# In Python 2.3, while/if 1: gets optimized to
# ...
# JUMP_FORWARD 4
# JUMP_IF_FALSE ?
# POP_TOP
#
# which generates a Using a conditional statement with a constant value
# JUMP_FORWARD = 110; 4, 0 is the offset (4)
_IGNORE_BOGUS_JUMP = '%c%c%c' % (110, 4, 0)
def _shouldIgnoreBogusJumps(code):
return _shouldIgnoreCodeOptimizations(code, _IGNORE_BOGUS_JUMP, 6, 3)
def _checkConstantCondition(code, topOfStack, if_false):
# don't warn when doing (test and 'true' or 'false')
# still warn when doing (test and None or 'false')
if if_false or not OP.LOAD_CONST(code.nextOpInfo(1)[0]) or \
not topOfStack.data or topOfStack.type is types.NoneType:
if not _shouldIgnoreBogusJumps(code):
code.addWarning(msgs.CONSTANT_CONDITION % utils.safestr(topOfStack))
def _jump_conditional(oparg, operand, codeSource, code, if_false) :
# FIXME: this doesn't work in 2.3+ since constant conditions
# are optimized away by the compiler.
if code.stack :
topOfStack = code.stack[-1]
if (topOfStack.const or topOfStack.type is types.NoneType) and \
cfg().constantConditions and \
(topOfStack.data != 1 or cfg().constant1):
_checkConstantCondition(code, topOfStack, if_false)
if _is_unreachable(code, topOfStack, code.label, if_false) :
code.removeBranch(code.label)
_jump(oparg, operand, codeSource, code)
def _JUMP_IF_FALSE(oparg, operand, codeSource, code) :
_jump_conditional(oparg, operand, codeSource, code, 1)
def _JUMP_IF_TRUE(oparg, operand, codeSource, code) :
_jump_conditional(oparg, operand, codeSource, code, 0)
def _JUMP_FORWARD(oparg, operand, codeSource, code) :
_jump(oparg, operand, codeSource, code)
code.remove_unreachable_code(code.label)
def _RETURN_VALUE(oparg, operand, codeSource, code) :
if not codeSource.calling_code :
code.addReturn()
def _EXEC_STMT(oparg, operand, codeSource, code) :
if cfg().usesExec :
if code.stack and code.stack[-1].isNone() :
code.addWarning(msgs.USES_GLOBAL_EXEC)
else :
code.addWarning(msgs.USES_EXEC)
def _checkStrException(code, varType, item):
if varType is types.StringType:
code.addWarning(msgs.RAISE_STR_EXCEPTION % item.data)
def _RAISE_VARARGS(oparg, operand, codeSource, code) :
code.addRaise()
if not cfg().badExceptions:
return
if oparg > 0 and len(code.stack) >= oparg:
item = code.stack[-oparg]
if item.type not in (Stack.TYPE_FUNC_RETURN, Stack.TYPE_UNKNOWN):
if item.type is Stack.TYPE_GLOBAL:
e, is_str = _getExceptionInfo(codeSource, item)
if is_str:
_checkStrException(code, e.type, item)
elif e is not None and not _isexception(e):
code.addWarning(msgs.RAISE_BAD_EXCEPTION % item.data)
else:
_checkStrException(code, item.getType(code.typeMap), item)
DISPATCH = [ None ] * 256
DISPATCH[ 1] = _POP_TOP
DISPATCH[ 2] = _ROT_TWO
DISPATCH[ 3] = _ROT_THREE
DISPATCH[ 4] = _DUP_TOP
DISPATCH[ 5] = _ROT_FOUR
DISPATCH[ 10] = _UNARY_POSITIVE
DISPATCH[ 11] = _UNARY_NEGATIVE
DISPATCH[ 12] = _UNARY_NOT
DISPATCH[ 13] = _UNARY_CONVERT
DISPATCH[ 15] = _UNARY_INVERT
DISPATCH[ 18] = _LIST_APPEND
DISPATCH[ 19] = _BINARY_POWER
DISPATCH[ 20] = _BINARY_MULTIPLY
DISPATCH[ 21] = _BINARY_DIVIDE
DISPATCH[ 22] = _BINARY_MODULO
DISPATCH[ 23] = _BINARY_ADD
DISPATCH[ 24] = _BINARY_SUBTRACT
DISPATCH[ 25] = _BINARY_SUBSCR
DISPATCH[ 26] = _BINARY_FLOOR_DIVIDE
DISPATCH[ 27] = _BINARY_TRUE_DIVIDE
# FIXME: add INPLACE FLOOR/TRUE DIVIDE: 28/29
DISPATCH[ 31] = _SLICE1
DISPATCH[ 32] = _SLICE2
DISPATCH[ 33] = _SLICE3
DISPATCH[ 55] = _BINARY_ADD # INPLACE
DISPATCH[ 56] = _BINARY_SUBTRACT # INPLACE
DISPATCH[ 57] = _BINARY_MULTIPLY # INPLACE
DISPATCH[ 58] = _BINARY_DIVIDE # INPLACE
DISPATCH[ 59] = _BINARY_MODULO # INPLACE
DISPATCH[ 60] = _STORE_SUBSCR
DISPATCH[ 61] = _DELETE_SUBSCR
DISPATCH[ 62] = _BINARY_LSHIFT
DISPATCH[ 63] = _BINARY_RSHIFT
DISPATCH[ 64] = _BINARY_AND
DISPATCH[ 65] = _BINARY_XOR
DISPATCH[ 66] = _BINARY_OR
DISPATCH[ 67] = _BINARY_POWER # INPLACE
DISPATCH[ 68] = _GET_ITER
DISPATCH[ 71] = _PRINT_ITEM
DISPATCH[ 73] = _PRINT_ITEM_TO
DISPATCH[ 75] = _BINARY_LSHIFT # INPLACE
DISPATCH[ 76] = _BINARY_RSHIFT # INPLACE
DISPATCH[ 77] = _BINARY_AND # INPLACE
DISPATCH[ 78] = _BINARY_XOR # INPLACE
DISPATCH[ 79] = _BINARY_OR # INPLACE
DISPATCH[ 83] = _RETURN_VALUE
DISPATCH[ 84] = _IMPORT_STAR
DISPATCH[ 85] = _EXEC_STMT
DISPATCH[ 88] = _END_FINALLY
DISPATCH[ 89] = _BUILD_CLASS
DISPATCH[ 90] = _STORE_NAME
DISPATCH[ 91] = _DELETE_NAME
DISPATCH[ 92] = _UNPACK_SEQUENCE
DISPATCH[ 93] = _FOR_ITER
DISPATCH[ 95] = _STORE_ATTR
DISPATCH[ 96] = _DELETE_ATTR
DISPATCH[ 97] = _STORE_GLOBAL
DISPATCH[ 98] = _DELETE_GLOBAL
DISPATCH[100] = _LOAD_CONST
DISPATCH[101] = _LOAD_NAME
DISPATCH[102] = _BUILD_TUPLE
DISPATCH[103] = _BUILD_LIST
DISPATCH[104] = _BUILD_MAP
DISPATCH[105] = _LOAD_ATTR
DISPATCH[106] = _COMPARE_OP
DISPATCH[107] = _IMPORT_NAME
DISPATCH[108] = _IMPORT_FROM
DISPATCH[110] = _JUMP_FORWARD
DISPATCH[111] = _JUMP_IF_FALSE
DISPATCH[112] = _JUMP_IF_TRUE
DISPATCH[113] = _JUMP_ABSOLUTE
DISPATCH[114] = _FOR_LOOP
DISPATCH[116] = _LOAD_GLOBAL
DISPATCH[121] = _SETUP_EXCEPT
DISPATCH[122] = _SETUP_FINALLY
DISPATCH[124] = _LOAD_FAST
DISPATCH[125] = _STORE_FAST
DISPATCH[126] = _DELETE_FAST
DISPATCH[127] = _LINE_NUM
DISPATCH[130] = _RAISE_VARARGS
DISPATCH[131] = _CALL_FUNCTION
DISPATCH[132] = _MAKE_FUNCTION
DISPATCH[134] = _MAKE_CLOSURE
DISPATCH[135] = _LOAD_CLOSURE
DISPATCH[136] = _LOAD_DEREF
DISPATCH[140] = _CALL_FUNCTION_VAR
DISPATCH[141] = _CALL_FUNCTION_KW
DISPATCH[142] = _CALL_FUNCTION_VAR_KW
|