Python _ast 模块，Call() 实例源码

def visit_For(self, node):
        if isinstance(node.target, _ast.Name):
            target = node.target.id
            if isinstance(node.iter, _ast.Call) and isinstance(node.iter.func, _ast.Name):
                if node.iter.func.id == "range":
                    return self.for_range(node, target)
                else:
                    raise SyntaxError("GPUMAP: Only for ... in range(...) is supported!")

            elif isinstance(node.iter, _ast.Name):
                if node.iter.id in self.local_vars:
                    var_type = self.local_vars[node.iter.id]
                    if isinstance(var_type, str) and var_type.startswith("List<"):
                        list_type = var_type[var_type.find("<") + 1: var_type.rfind(">")]
                        return self.for_list(node, list_type, target)
                    elif isinstance(var_type, str) and var_type.startswith("List_Ptr<"):
                        list_type = var_type[var_type.find("<") + 1: var_type.rfind(">")]
                        return self.for_list(node, list_type, target, ptr=True)
                    else:
                        raise SyntaxError("GPUMAP: cannot iterate over a non-list type")
                else:
                    raise SyntaxError("GPUMAP: no such variable found: " + node.iter.id)
        else:
            raise SyntaxError("GPUMAP: Only one variable can be assigned in a for loop!")

def __repr__(self):
        '''Generate representation of object for printing / interactive use

        Most likely only interested in non-default properties, so we return
        the string version of _context.

        Example string returned:
        <Context {'node': <_ast.Call object at 0x110252510>, 'function': None,
        'name': 'socket', 'imports': set(['socket']), 'module': None,
        'filename': 'examples/binding.py',
        'call': <_ast.Call object at 0x110252510>, 'lineno': 3,
        'import_aliases': {}, 'qualname': 'socket.socket'}>

        :return: A string representation of the object
        '''
        return "<Context %s>" % self._context

def NAME(self, node):
        """
        Handle occurrence of Name (which can be a load/store/delete access.)
        """
        # Locate the name in locals / function / globals scopes.
        if isinstance(node.ctx, (ast.Load, ast.AugLoad)):
            self.handleNodeLoad(node)
            if (node.id == 'locals' and isinstance(self.scope, FunctionScope)
                    and isinstance(node.parent, ast.Call)):
                # we are doing locals() call in current scope
                self.scope.usesLocals = True
        elif isinstance(node.ctx, (ast.Store, ast.AugStore)):
            self.handleNodeStore(node)
        elif isinstance(node.ctx, ast.Del):
            self.handleNodeDelete(node)
        else:
            # must be a Param context -- this only happens for names in function
            # arguments, but these aren't dispatched through here
            raise RuntimeError("Got impossible expression context: %r" % (node.ctx,))

def NAME(self, node):
        """
        Handle occurrence of Name (which can be a load/store/delete access.)
        """
        # Locate the name in locals / function / globals scopes.
        if isinstance(node.ctx, (ast.Load, ast.AugLoad)):
            self.handleNodeLoad(node)
            if (node.id == 'locals' and isinstance(self.scope, FunctionScope)
                    and isinstance(node.parent, ast.Call)):
                # we are doing locals() call in current scope
                self.scope.usesLocals = True
        elif isinstance(node.ctx, (ast.Store, ast.AugStore)):
            self.handleNodeStore(node)
        elif isinstance(node.ctx, ast.Del):
            self.handleNodeDelete(node)
        else:
            # must be a Param context -- this only happens for names in function
            # arguments, but these aren't dispatched through here
            raise RuntimeError("Got impossible expression context: %r" % (node.ctx,))

def NAME(self, node):
        """
        Handle occurrence of Name (which can be a load/store/delete access.)
        """
        # Locate the name in locals / function / globals scopes.
        if isinstance(node.ctx, (ast.Load, ast.AugLoad)):
            self.handleNodeLoad(node)
            if (node.id == 'locals' and isinstance(self.scope, FunctionScope)
                    and isinstance(node.parent, ast.Call)):
                # we are doing locals() call in current scope
                self.scope.usesLocals = True
        elif isinstance(node.ctx, (ast.Store, ast.AugStore)):
            self.handleNodeStore(node)
        elif isinstance(node.ctx, ast.Del):
            self.handleNodeDelete(node)
        else:
            # must be a Param context -- this only happens for names in function
            # arguments, but these aren't dispatched through here
            raise RuntimeError("Got impossible expression context: %r" % (node.ctx,))

def parse_grpexpr(grp_ctx, tree, row_ctx, maker):
    if isinstance(tree, _ast.Call) and tree.func.id in FUNC_MAP:
        if tree.keywords:
            raise Exception('Keyword arguments are not supported in %r' % (tree.func.id,))
        return FUNC_MAP[tree.func.id](
            maker, list(parse_expr(row_ctx, arg) for arg in tree.args)
        )
    else:
        return parse_expr(grp_ctx, tree, partial(parse_grpexpr, maker=maker, row_ctx=row_ctx))

def BUILD_CLASS(self, instr):

        call_func = self.ast_stack.pop()

        assert isinstance(call_func, _ast.Call)

        func = call_func.func

        assert isinstance(func, _ast.FunctionDef)

        code = func.body
        pop_assignment(code, '__module__')
        doc = pop_doc(code)

        ret = code.pop()

        assert isinstance(ret, _ast.Return) and ret.value == 'LOAD_LOCALS'

        bases = self.ast_stack.pop()

        assert isinstance(bases, _ast.Tuple)
        bases = bases.elts
        name = self.ast_stack.pop()

        class_ = _ast.ClassDef(name=name, bases=bases, body=code, decorator_list=[],
                               lineno=instr.lineno, col_offset=0)

        self.ast_stack.append(class_)

def CALL_FUNCTION(self, instr):
        nkwargs = instr.oparg >> 8
        nargs = (~(nkwargs << 8)) & instr.oparg


        args = []
        keywords = []

        for _ in range(nkwargs):
            expr = self.ast_stack.pop()
            name = self.ast_stack.pop()

            keyword = _ast.keyword(arg=name.s, value=expr, lineno=instr.lineno)
            keywords.insert(0, keyword)

        for _ in range(nargs):
            arg = self.ast_stack.pop()
            args.insert(0, arg)


        if len(args) == 1 and isinstance(args[0], (_ast.FunctionDef, _ast.ClassDef)):
            function = args[0]

            if function.decorator_list is None:
                function.decorator_list = []

            node = self.ast_stack.pop()
            function.decorator_list.insert(0, node)

            self.ast_stack.append(function)
            return


        node = self.ast_stack.pop()
        callfunc = _ast.Call(func=node, args=args, keywords=keywords, starargs=None, kwargs=None,
                             lineno=instr.lineno, col_offset=0)

        self.ast_stack.append(callfunc)

def _(tree, **kwargs):
    options = ''
    if isinstance(tree[0], _ast.Expr) and isinstance(tree[0].value, _ast.Call):
        # test for Settings()
        func = tree[0].value.func.id
        if func == 'Settings':
            keywords = (parse(kwarg) for kwarg in tree[0].value.keywords)
            for key, value in keywords:
                if value[0] == '"':
                    options += '[{}:{}]\n'.format(key, value[1:-1])
                else:
                    options += '[{}:{}]\n'.format(key, value)
            tree = tree[1:]
    return options + '\n'.join(parse(expr) for expr in transform(tree))

def _(item, body=None, top=False):
    if top and len(item.args) != 0:
        if isinstance(item.args[0], _ast.Call):
            _transform(item.args[0], body=body, top=top)
        if not isinstance(item.args[0], (_ast.Name, _ast.Num)):
            syntax = ast.parse('tmpcall{} = b'.format(randint(0, 2**32))).body[0]
            syntax.value = item.args[0]
            item.args[0] = syntax.targets[0]
            body.extend((syntax, item))
            return True
    return False