bee_python 0.0.3 → 0.0.4

data/tools/pychecker/CodeChecks.py

@@ -1,1969 +0,0 @@
-#!/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