EmbeddedPkg: Extend NvVarStoreFormattedLib LIBRARY_CLASS

[mirror_edk2.git] / AppPkg / Applications / Python / Python-2.7.2 / Lib / compiler / symbols.py

"""Module symbol-table generator"""\r
\r
from compiler import ast\r
from compiler.consts import SC_LOCAL, SC_GLOBAL_IMPLICIT, SC_GLOBAL_EXPLICT, \\r
    SC_FREE, SC_CELL, SC_UNKNOWN\r
from compiler.misc import mangle\r
import types\r
\r
\r
import sys\r
\r
MANGLE_LEN = 256\r
\r
class Scope:\r
    # XXX how much information do I need about each name?\r
    def __init__(self, name, module, klass=None):\r
        self.name = name\r
        self.module = module\r
        self.defs = {}\r
        self.uses = {}\r
        self.globals = {}\r
        self.params = {}\r
        self.frees = {}\r
        self.cells = {}\r
        self.children = []\r
        # nested is true if the class could contain free variables,\r
        # i.e. if it is nested within another function.\r
        self.nested = None\r
        self.generator = None\r
        self.klass = None\r
        if klass is not None:\r
            for i in range(len(klass)):\r
                if klass[i] != '_':\r
                    self.klass = klass[i:]\r
                    break\r
\r
    def __repr__(self):\r
        return "<%s: %s>" % (self.__class__.__name__, self.name)\r
\r
    def mangle(self, name):\r
        if self.klass is None:\r
            return name\r
        return mangle(name, self.klass)\r
\r
    def add_def(self, name):\r
        self.defs[self.mangle(name)] = 1\r
\r
    def add_use(self, name):\r
        self.uses[self.mangle(name)] = 1\r
\r
    def add_global(self, name):\r
        name = self.mangle(name)\r
        if name in self.uses or name in self.defs:\r
            pass # XXX warn about global following def/use\r
        if name in self.params:\r
            raise SyntaxError, "%s in %s is global and parameter" % \\r
                  (name, self.name)\r
        self.globals[name] = 1\r
        self.module.add_def(name)\r
\r
    def add_param(self, name):\r
        name = self.mangle(name)\r
        self.defs[name] = 1\r
        self.params[name] = 1\r
\r
    def get_names(self):\r
        d = {}\r
        d.update(self.defs)\r
        d.update(self.uses)\r
        d.update(self.globals)\r
        return d.keys()\r
\r
    def add_child(self, child):\r
        self.children.append(child)\r
\r
    def get_children(self):\r
        return self.children\r
\r
    def DEBUG(self):\r
        print >> sys.stderr, self.name, self.nested and "nested" or ""\r
        print >> sys.stderr, "\tglobals: ", self.globals\r
        print >> sys.stderr, "\tcells: ", self.cells\r
        print >> sys.stderr, "\tdefs: ", self.defs\r
        print >> sys.stderr, "\tuses: ", self.uses\r
        print >> sys.stderr, "\tfrees:", self.frees\r
\r
    def check_name(self, name):\r
        """Return scope of name.\r
\r
        The scope of a name could be LOCAL, GLOBAL, FREE, or CELL.\r
        """\r
        if name in self.globals:\r
            return SC_GLOBAL_EXPLICT\r
        if name in self.cells:\r
            return SC_CELL\r
        if name in self.defs:\r
            return SC_LOCAL\r
        if self.nested and (name in self.frees or name in self.uses):\r
            return SC_FREE\r
        if self.nested:\r
            return SC_UNKNOWN\r
        else:\r
            return SC_GLOBAL_IMPLICIT\r
\r
    def get_free_vars(self):\r
        if not self.nested:\r
            return ()\r
        free = {}\r
        free.update(self.frees)\r
        for name in self.uses.keys():\r
            if name not in self.defs and name not in self.globals:\r
                free[name] = 1\r
        return free.keys()\r
\r
    def handle_children(self):\r
        for child in self.children:\r
            frees = child.get_free_vars()\r
            globals = self.add_frees(frees)\r
            for name in globals:\r
                child.force_global(name)\r
\r
    def force_global(self, name):\r
        """Force name to be global in scope.\r
\r
        Some child of the current node had a free reference to name.\r
        When the child was processed, it was labelled a free\r
        variable.  Now that all its enclosing scope have been\r
        processed, the name is known to be a global or builtin.  So\r
        walk back down the child chain and set the name to be global\r
        rather than free.\r
\r
        Be careful to stop if a child does not think the name is\r
        free.\r
        """\r
        self.globals[name] = 1\r
        if name in self.frees:\r
            del self.frees[name]\r
        for child in self.children:\r
            if child.check_name(name) == SC_FREE:\r
                child.force_global(name)\r
\r
    def add_frees(self, names):\r
        """Process list of free vars from nested scope.\r
\r
        Returns a list of names that are either 1) declared global in the\r
        parent or 2) undefined in a top-level parent.  In either case,\r
        the nested scope should treat them as globals.\r
        """\r
        child_globals = []\r
        for name in names:\r
            sc = self.check_name(name)\r
            if self.nested:\r
                if sc == SC_UNKNOWN or sc == SC_FREE \\r
                   or isinstance(self, ClassScope):\r
                    self.frees[name] = 1\r
                elif sc == SC_GLOBAL_IMPLICIT:\r
                    child_globals.append(name)\r
                elif isinstance(self, FunctionScope) and sc == SC_LOCAL:\r
                    self.cells[name] = 1\r
                elif sc != SC_CELL:\r
                    child_globals.append(name)\r
            else:\r
                if sc == SC_LOCAL:\r
                    self.cells[name] = 1\r
                elif sc != SC_CELL:\r
                    child_globals.append(name)\r
        return child_globals\r
\r
    def get_cell_vars(self):\r
        return self.cells.keys()\r
\r
class ModuleScope(Scope):\r
    __super_init = Scope.__init__\r
\r
    def __init__(self):\r
        self.__super_init("global", self)\r
\r
class FunctionScope(Scope):\r
    pass\r
\r
class GenExprScope(Scope):\r
    __super_init = Scope.__init__\r
\r
    __counter = 1\r
\r
    def __init__(self, module, klass=None):\r
        i = self.__counter\r
        self.__counter += 1\r
        self.__super_init("generator expression<%d>"%i, module, klass)\r
        self.add_param('.0')\r
\r
    def get_names(self):\r
        keys = Scope.get_names(self)\r
        return keys\r
\r
class LambdaScope(FunctionScope):\r
    __super_init = Scope.__init__\r
\r
    __counter = 1\r
\r
    def __init__(self, module, klass=None):\r
        i = self.__counter\r
        self.__counter += 1\r
        self.__super_init("lambda.%d" % i, module, klass)\r
\r
class ClassScope(Scope):\r
    __super_init = Scope.__init__\r
\r
    def __init__(self, name, module):\r
        self.__super_init(name, module, name)\r
\r
class SymbolVisitor:\r
    def __init__(self):\r
        self.scopes = {}\r
        self.klass = None\r
\r
    # node that define new scopes\r
\r
    def visitModule(self, node):\r
        scope = self.module = self.scopes[node] = ModuleScope()\r
        self.visit(node.node, scope)\r
\r
    visitExpression = visitModule\r
\r
    def visitFunction(self, node, parent):\r
        if node.decorators:\r
            self.visit(node.decorators, parent)\r
        parent.add_def(node.name)\r
        for n in node.defaults:\r
            self.visit(n, parent)\r
        scope = FunctionScope(node.name, self.module, self.klass)\r
        if parent.nested or isinstance(parent, FunctionScope):\r
            scope.nested = 1\r
        self.scopes[node] = scope\r
        self._do_args(scope, node.argnames)\r
        self.visit(node.code, scope)\r
        self.handle_free_vars(scope, parent)\r
\r
    def visitGenExpr(self, node, parent):\r
        scope = GenExprScope(self.module, self.klass);\r
        if parent.nested or isinstance(parent, FunctionScope) \\r
                or isinstance(parent, GenExprScope):\r
            scope.nested = 1\r
\r
        self.scopes[node] = scope\r
        self.visit(node.code, scope)\r
\r
        self.handle_free_vars(scope, parent)\r
\r
    def visitGenExprInner(self, node, scope):\r
        for genfor in node.quals:\r
            self.visit(genfor, scope)\r
\r
        self.visit(node.expr, scope)\r
\r
    def visitGenExprFor(self, node, scope):\r
        self.visit(node.assign, scope, 1)\r
        self.visit(node.iter, scope)\r
        for if_ in node.ifs:\r
            self.visit(if_, scope)\r
\r
    def visitGenExprIf(self, node, scope):\r
        self.visit(node.test, scope)\r
\r
    def visitLambda(self, node, parent, assign=0):\r
        # Lambda is an expression, so it could appear in an expression\r
        # context where assign is passed.  The transformer should catch\r
        # any code that has a lambda on the left-hand side.\r
        assert not assign\r
\r
        for n in node.defaults:\r
            self.visit(n, parent)\r
        scope = LambdaScope(self.module, self.klass)\r
        if parent.nested or isinstance(parent, FunctionScope):\r
            scope.nested = 1\r
        self.scopes[node] = scope\r
        self._do_args(scope, node.argnames)\r
        self.visit(node.code, scope)\r
        self.handle_free_vars(scope, parent)\r
\r
    def _do_args(self, scope, args):\r
        for name in args:\r
            if type(name) == types.TupleType:\r
                self._do_args(scope, name)\r
            else:\r
                scope.add_param(name)\r
\r
    def handle_free_vars(self, scope, parent):\r
        parent.add_child(scope)\r
        scope.handle_children()\r
\r
    def visitClass(self, node, parent):\r
        parent.add_def(node.name)\r
        for n in node.bases:\r
            self.visit(n, parent)\r
        scope = ClassScope(node.name, self.module)\r
        if parent.nested or isinstance(parent, FunctionScope):\r
            scope.nested = 1\r
        if node.doc is not None:\r
            scope.add_def('__doc__')\r
        scope.add_def('__module__')\r
        self.scopes[node] = scope\r
        prev = self.klass\r
        self.klass = node.name\r
        self.visit(node.code, scope)\r
        self.klass = prev\r
        self.handle_free_vars(scope, parent)\r
\r
    # name can be a def or a use\r
\r
    # XXX a few calls and nodes expect a third "assign" arg that is\r
    # true if the name is being used as an assignment.  only\r
    # expressions contained within statements may have the assign arg.\r
\r
    def visitName(self, node, scope, assign=0):\r
        if assign:\r
            scope.add_def(node.name)\r
        else:\r
            scope.add_use(node.name)\r
\r
    # operations that bind new names\r
\r
    def visitFor(self, node, scope):\r
        self.visit(node.assign, scope, 1)\r
        self.visit(node.list, scope)\r
        self.visit(node.body, scope)\r
        if node.else_:\r
            self.visit(node.else_, scope)\r
\r
    def visitFrom(self, node, scope):\r
        for name, asname in node.names:\r
            if name == "*":\r
                continue\r
            scope.add_def(asname or name)\r
\r
    def visitImport(self, node, scope):\r
        for name, asname in node.names:\r
            i = name.find(".")\r
            if i > -1:\r
                name = name[:i]\r
            scope.add_def(asname or name)\r
\r
    def visitGlobal(self, node, scope):\r
        for name in node.names:\r
            scope.add_global(name)\r
\r
    def visitAssign(self, node, scope):\r
        """Propagate assignment flag down to child nodes.\r
\r
        The Assign node doesn't itself contains the variables being\r
        assigned to.  Instead, the children in node.nodes are visited\r
        with the assign flag set to true.  When the names occur in\r
        those nodes, they are marked as defs.\r
\r
        Some names that occur in an assignment target are not bound by\r
        the assignment, e.g. a name occurring inside a slice.  The\r
        visitor handles these nodes specially; they do not propagate\r
        the assign flag to their children.\r
        """\r
        for n in node.nodes:\r
            self.visit(n, scope, 1)\r
        self.visit(node.expr, scope)\r
\r
    def visitAssName(self, node, scope, assign=1):\r
        scope.add_def(node.name)\r
\r
    def visitAssAttr(self, node, scope, assign=0):\r
        self.visit(node.expr, scope, 0)\r
\r
    def visitSubscript(self, node, scope, assign=0):\r
        self.visit(node.expr, scope, 0)\r
        for n in node.subs:\r
            self.visit(n, scope, 0)\r
\r
    def visitSlice(self, node, scope, assign=0):\r
        self.visit(node.expr, scope, 0)\r
        if node.lower:\r
            self.visit(node.lower, scope, 0)\r
        if node.upper:\r
            self.visit(node.upper, scope, 0)\r
\r
    def visitAugAssign(self, node, scope):\r
        # If the LHS is a name, then this counts as assignment.\r
        # Otherwise, it's just use.\r
        self.visit(node.node, scope)\r
        if isinstance(node.node, ast.Name):\r
            self.visit(node.node, scope, 1) # XXX worry about this\r
        self.visit(node.expr, scope)\r
\r
    # prune if statements if tests are false\r
\r
    _const_types = types.StringType, types.IntType, types.FloatType\r
\r
    def visitIf(self, node, scope):\r
        for test, body in node.tests:\r
            if isinstance(test, ast.Const):\r
                if type(test.value) in self._const_types:\r
                    if not test.value:\r
                        continue\r
            self.visit(test, scope)\r
            self.visit(body, scope)\r
        if node.else_:\r
            self.visit(node.else_, scope)\r
\r
    # a yield statement signals a generator\r
\r
    def visitYield(self, node, scope):\r
        scope.generator = 1\r
        self.visit(node.value, scope)\r
\r
def list_eq(l1, l2):\r
    return sorted(l1) == sorted(l2)\r
\r
if __name__ == "__main__":\r
    import sys\r
    from compiler import parseFile, walk\r
    import symtable\r
\r
    def get_names(syms):\r
        return [s for s in [s.get_name() for s in syms.get_symbols()]\r
                if not (s.startswith('_[') or s.startswith('.'))]\r
\r
    for file in sys.argv[1:]:\r
        print file\r
        f = open(file)\r
        buf = f.read()\r
        f.close()\r
        syms = symtable.symtable(buf, file, "exec")\r
        mod_names = get_names(syms)\r
        tree = parseFile(file)\r
        s = SymbolVisitor()\r
        walk(tree, s)\r
\r
        # compare module-level symbols\r
        names2 = s.scopes[tree].get_names()\r
\r
        if not list_eq(mod_names, names2):\r
            print\r
            print "oops", file\r
            print sorted(mod_names)\r
            print sorted(names2)\r
            sys.exit(-1)\r
\r
        d = {}\r
        d.update(s.scopes)\r
        del d[tree]\r
        scopes = d.values()\r
        del d\r
\r
        for s in syms.get_symbols():\r
            if s.is_namespace():\r
                l = [sc for sc in scopes\r
                     if sc.name == s.get_name()]\r
                if len(l) > 1:\r
                    print "skipping", s.get_name()\r
                else:\r
                    if not list_eq(get_names(s.get_namespace()),\r
                                   l[0].get_names()):\r
                        print s.get_name()\r
                        print sorted(get_names(s.get_namespace()))\r
                        print sorted(l[0].get_names())\r
                        sys.exit(-1)\r