Lichen

Annotated inspector.py

322:5a7b1c0974a5
309:3a519b510333
274:5be8a7aa0f86
2016-12-03 Paul Boddie file changeset files shortlog Fixed int serialisation to string again. Also added maxint and minint accessors.
paul@0 1 
#!/usr/bin/env python
paul@0 2 
 
 paul@0      3 
"""
 
 paul@0      4 
Inspect and obtain module structure.
 
 paul@0      5 
 
 paul@0      6 
Copyright (C) 2007, 2008, 2009, 2010, 2011, 2012, 2013,
 
 paul@0      7 
              2014, 2015, 2016 Paul Boddie <paul@boddie.org.uk>
 
 paul@0      8 
 
 paul@0      9 
This program is free software; you can redistribute it and/or modify it under
 
 paul@0     10 
the terms of the GNU General Public License as published by the Free Software
 
 paul@0     11 
Foundation; either version 3 of the License, or (at your option) any later
 
 paul@0     12 
version.
 
 paul@0     13 
 
 paul@0     14 
This program is distributed in the hope that it will be useful, but WITHOUT
 
 paul@0     15 
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
 
 paul@0     16 
FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
 
 paul@0     17 
details.
 
 paul@0     18 
 
 paul@0     19 
You should have received a copy of the GNU General Public License along with
 
 paul@0     20 
this program.  If not, see <http://www.gnu.org/licenses/>.
 
 paul@0     21 
"""
 
 paul@0     22 
 
 paul@0     23 
from branching import BranchTracker
 
 paul@110     24 
from common import CommonModule, get_argnames, init_item, predefined_constants
 
 paul@26     25 
from modules import BasicModule, CacheWritingModule, InspectionNaming
 
 paul@3     26 
from errors import InspectError
 
 paul@0     27 
from referencing import Reference
 
 paul@12     28 
from resolving import NameResolving
 
 paul@12     29 
from results import AccessRef, InstanceRef, InvocationRef, LiteralSequenceRef, \
 
 paul@226     30 
                    LocalNameRef, NameRef, ResolvedNameRef, VariableRef
 
 paul@0     31 
import compiler
 
 paul@0     32 
import sys
 
 paul@0     33 
 
 paul@26     34 
class InspectedModule(BasicModule, CacheWritingModule, NameResolving, InspectionNaming):
 
 paul@0     35 
 
 paul@0     36 
    "A module inspector."
 
 paul@0     37 
 
 paul@0     38 
    def __init__(self, name, importer):
 
 paul@13     39 
 
 paul@13     40 
        "Initialise the module with basic details."
 
 paul@13     41 
 
 paul@0     42 
        BasicModule.__init__(self, name, importer)
 
 paul@12     43 
 
 paul@0     44 
        self.in_class = False
 
 paul@0     45 
        self.in_conditional = False
 
 paul@110     46 
 
 paul@110     47 
        # Accesses to global attributes.
 
 paul@110     48 
 
 paul@0     49 
        self.global_attr_accesses = {}
 
 paul@0     50 
 
 paul@0     51 
        # Usage tracking.
 
 paul@0     52 
 
 paul@0     53 
        self.trackers = []
 
 paul@0     54 
        self.attr_accessor_branches = {}
 
 paul@0     55 
 
 paul@0     56 
    def __repr__(self):
 
 paul@0     57 
        return "InspectedModule(%r, %r)" % (self.name, self.importer)
 
 paul@0     58 
 
 paul@27     59 
    # Principal methods.
 
 paul@27     60 
 
 paul@0     61 
    def parse(self, filename):
 
 paul@0     62 
 
 paul@0     63 
        "Parse the file having the given 'filename'."
 
 paul@0     64 
 
 paul@0     65 
        self.parse_file(filename)
 
 paul@0     66 
 
 paul@0     67 
        # Inspect the module.
 
 paul@0     68 
 
 paul@0     69 
        self.start_tracking_in_module()
 
 paul@0     70 
 
 paul@0     71 
        # Detect and record imports and globals declared in the module.
 
 paul@0     72 
 
 paul@0     73 
        self.process_structure(self.astnode)
 
 paul@0     74 
 
 paul@0     75 
        # Set the class of the module after the definition has occurred.
 
 paul@0     76 
 
 paul@269     77 
        ref = self.get_builtin("module")
 
 paul@0     78 
        self.set_name("__class__", ref)
 
 paul@271     79 
        self.set_name("__mname__", self.get_constant("string", self.name).reference())
 
 paul@271     80 
        self.set_name("__file__", self.get_constant("string", filename).reference())
 
 paul@0     81 
 
 paul@0     82 
        # Get module-level attribute usage details.
 
 paul@0     83 
 
 paul@0     84 
        self.stop_tracking_in_module()
 
 paul@0     85 
 
 paul@27     86 
        # Collect external name references.
 
 paul@0     87 
 
 paul@27     88 
        self.collect_names()
 
 paul@0     89 
 
 paul@12     90 
    def complete(self):
 
 paul@0     91 
 
 paul@12     92 
        "Complete the module inspection."
 
 paul@0     93 
 
 paul@12     94 
        # Resolve names not definitively mapped to objects.
 
 paul@0     95 
 
 paul@12     96 
        self.resolve()
 
 paul@0     97 
 
 paul@12     98 
        # Define the invocation requirements in each namespace.
 
 paul@0     99 
 
 paul@12    100 
        self.set_invocation_usage()
 
 paul@0    101 
 
 paul@12    102 
        # Propagate to the importer information needed in subsequent activities.
 
 paul@0    103 
 
 paul@12    104 
        self.propagate()
 
 paul@0    105 
 
 paul@27    106 
    # Accessory methods.
 
 paul@0    107 
 
 paul@27    108 
    def collect_names(self):
 
 paul@0    109 
 
 paul@27    110 
        "Collect the names used by each scope."
 
 paul@0    111 
 
 paul@0    112 
        for path in self.names_used.keys():
 
 paul@27    113 
            self.collect_names_for_path(path)
 
 paul@27    114 
 
 paul@27    115 
    def collect_names_for_path(self, path):
 
 paul@0    116 
 
 paul@33    117 
        """
 
 paul@33    118 
        Collect the names used by the given 'path'. These are propagated to the
 
 paul@33    119 
        importer in advance of any dependency resolution.
 
 paul@33    120 
        """
 
 paul@0    121 
 
 paul@0    122 
        names = self.names_used.get(path)
 
 paul@0    123 
        if not names:
 
 paul@0    124 
            return
 
 paul@0    125 
 
 paul@0    126 
        in_function = self.function_locals.has_key(path)
 
 paul@0    127 
 
 paul@0    128 
        for name in names:
 
 paul@135    129 
            if in_function and name in self.function_locals[path]:
 
 paul@135    130 
                continue
 
 paul@135    131 
 
 paul@135    132 
            key = "%s.%s" % (path, name)
 
 paul@135    133 
 
 paul@135    134 
            # Find predefined constant names before anything else.
 
 paul@135    135 
 
 paul@135    136 
            if name in predefined_constants:
 
 paul@135    137 
                ref = self.get_builtin(name)
 
 paul@135    138 
                self.set_name_reference(key, ref)
 
 paul@0    139 
                continue
 
 paul@0    140 
 
 paul@35    141 
            # Find local definitions (within dynamic namespaces).
 
 paul@0    142 
 
 paul@27    143 
            ref = self.get_resolved_object(key)
 
 paul@0    144 
            if ref:
 
 paul@40    145 
                self.set_name_reference(key, ref)
 
 paul@0    146 
                continue
 
 paul@0    147 
 
 paul@142    148 
            # Find global.
 
 paul@0    149 
 
 paul@142    150 
            ref = self.get_global(name)
 
 paul@27    151 
            if ref:
 
 paul@40    152 
                self.set_name_reference(key, ref)
 
 paul@0    153 
                continue
 
 paul@0    154 
 
 paul@40    155 
            # Find presumed built-in definitions.
 
 paul@0    156 
 
 paul@40    157 
            ref = self.get_builtin(name)
 
 paul@40    158 
            self.set_name_reference(key, ref)
 
 paul@0    159 
 
 paul@40    160 
    def set_name_reference(self, path, ref):
 
 paul@0    161 
 
 paul@40    162 
        "Map the given name 'path' to 'ref'."
 
 paul@0    163 
 
 paul@40    164 
        self.importer.all_name_references[path] = self.name_references[path] = ref
 
 paul@0    165 
 
 paul@0    166 
    # Module structure traversal.
 
 paul@0    167 
 
 paul@0    168 
    def process_structure_node(self, n):
 
 paul@0    169 
 
 paul@0    170 
        "Process the individual node 'n'."
 
 paul@0    171 
 
 paul@205    172 
        path = self.get_namespace_path()
 
 paul@205    173 
 
 paul@0    174 
        # Module global detection.
 
 paul@0    175 
 
 paul@0    176 
        if isinstance(n, compiler.ast.Global):
 
 paul@0    177 
            self.process_global_node(n)
 
 paul@0    178 
 
 paul@0    179 
        # Module import declarations.
 
 paul@0    180 
 
 paul@0    181 
        elif isinstance(n, compiler.ast.From):
 
 paul@0    182 
            self.process_from_node(n)
 
 paul@0    183 
 
 paul@0    184 
        elif isinstance(n, compiler.ast.Import):
 
 paul@0    185 
            self.process_import_node(n)
 
 paul@0    186 
 
 paul@0    187 
        # Nodes using operator module functions.
 
 paul@0    188 
 
 paul@0    189 
        elif isinstance(n, compiler.ast.Operator):
 
 paul@0    190 
            return self.process_operator_node(n)
 
 paul@0    191 
 
 paul@0    192 
        elif isinstance(n, compiler.ast.AugAssign):
 
 paul@0    193 
            self.process_augassign_node(n)
 
 paul@0    194 
 
 paul@0    195 
        elif isinstance(n, compiler.ast.Compare):
 
 paul@0    196 
            return self.process_compare_node(n)
 
 paul@0    197 
 
 paul@0    198 
        elif isinstance(n, compiler.ast.Slice):
 
 paul@0    199 
            return self.process_slice_node(n)
 
 paul@0    200 
 
 paul@0    201 
        elif isinstance(n, compiler.ast.Sliceobj):
 
 paul@0    202 
            return self.process_sliceobj_node(n)
 
 paul@0    203 
 
 paul@0    204 
        elif isinstance(n, compiler.ast.Subscript):
 
 paul@0    205 
            return self.process_subscript_node(n)
 
 paul@0    206 
 
 paul@0    207 
        # Namespaces within modules.
 
 paul@0    208 
 
 paul@0    209 
        elif isinstance(n, compiler.ast.Class):
 
 paul@0    210 
            self.process_class_node(n)
 
 paul@0    211 
 
 paul@0    212 
        elif isinstance(n, compiler.ast.Function):
 
 paul@0    213 
            self.process_function_node(n, n.name)
 
 paul@0    214 
 
 paul@0    215 
        elif isinstance(n, compiler.ast.Lambda):
 
 paul@0    216 
            return self.process_lambda_node(n)
 
 paul@0    217 
 
 paul@0    218 
        # Assignments.
 
 paul@0    219 
 
 paul@0    220 
        elif isinstance(n, compiler.ast.Assign):
 
 paul@0    221 
 
 paul@0    222 
            # Handle each assignment node.
 
 paul@0    223 
 
 paul@0    224 
            for node in n.nodes:
 
 paul@0    225 
                self.process_assignment_node(node, n.expr)
 
 paul@0    226 
 
 paul@0    227 
        # Assignments within non-Assign nodes.
 
 paul@0    228 
 
 paul@0    229 
        elif isinstance(n, compiler.ast.AssName):
 
 paul@205    230 
            raise InspectError("Name assignment appearing outside assignment statement.", path, n)
 
 paul@0    231 
 
 paul@0    232 
        elif isinstance(n, compiler.ast.AssAttr):
 
 paul@205    233 
            raise InspectError("Attribute assignment appearing outside assignment statement.", path, n)
 
 paul@0    234 
 
 paul@0    235 
        # Accesses.
 
 paul@0    236 
 
 paul@0    237 
        elif isinstance(n, compiler.ast.Getattr):
 
 paul@0    238 
            return self.process_attribute_access(n)
 
 paul@0    239 
 
 paul@0    240 
        # Name recording for later testing.
 
 paul@0    241 
 
 paul@0    242 
        elif isinstance(n, compiler.ast.Name):
 
 paul@0    243 
            return self.process_name_node(n)
 
 paul@0    244 
 
 paul@0    245 
        # Conditional statement tracking.
 
 paul@0    246 
 
 paul@0    247 
        elif isinstance(n, compiler.ast.For):
 
 paul@0    248 
            self.process_for_node(n)
 
 paul@0    249 
 
 paul@0    250 
        elif isinstance(n, compiler.ast.While):
 
 paul@0    251 
            self.process_while_node(n)
 
 paul@0    252 
 
 paul@0    253 
        elif isinstance(n, compiler.ast.If):
 
 paul@0    254 
            self.process_if_node(n)
 
 paul@0    255 
 
 paul@0    256 
        elif isinstance(n, (compiler.ast.And, compiler.ast.Or)):
 
 paul@0    257 
            return self.process_logical_node(n)
 
 paul@0    258 
 
 paul@0    259 
        # Exception control-flow tracking.
 
 paul@0    260 
 
 paul@0    261 
        elif isinstance(n, compiler.ast.TryExcept):
 
 paul@0    262 
            self.process_try_node(n)
 
 paul@0    263 
 
 paul@0    264 
        elif isinstance(n, compiler.ast.TryFinally):
 
 paul@0    265 
            self.process_try_finally_node(n)
 
 paul@0    266 
 
 paul@0    267 
        # Control-flow modification statements.
 
 paul@0    268 
 
 paul@0    269 
        elif isinstance(n, compiler.ast.Break):
 
 paul@0    270 
            self.trackers[-1].suspend_broken_branch()
 
 paul@0    271 
 
 paul@0    272 
        elif isinstance(n, compiler.ast.Continue):
 
 paul@0    273 
            self.trackers[-1].suspend_continuing_branch()
 
 paul@0    274 
 
 paul@0    275 
        elif isinstance(n, compiler.ast.Raise):
 
 paul@0    276 
            self.process_structure(n)
 
 paul@0    277 
            self.trackers[-1].abandon_branch()
 
 paul@0    278 
 
 paul@0    279 
        elif isinstance(n, compiler.ast.Return):
 
 paul@0    280 
            self.process_structure(n)
 
 paul@0    281 
            self.trackers[-1].abandon_returning_branch()
 
 paul@0    282 
 
 paul@173    283 
        # Print statements.
 
 paul@173    284 
 
 paul@173    285 
        elif isinstance(n, (compiler.ast.Print, compiler.ast.Printnl)):
 
 paul@173    286 
            self.process_print_node(n)
 
 paul@173    287 
 
 paul@0    288 
        # Invocations.
 
 paul@0    289 
 
 paul@0    290 
        elif isinstance(n, compiler.ast.CallFunc):
 
 paul@0    291 
            return self.process_invocation_node(n)
 
 paul@0    292 
 
 paul@0    293 
        # Constant usage.
 
 paul@0    294 
 
 paul@0    295 
        elif isinstance(n, compiler.ast.Const):
 
 paul@188    296 
            typename = n.value.__class__.__name__
 
 paul@188    297 
            return self.get_literal_instance(n, typename == "str" and "string" or typename)
 
 paul@0    298 
 
 paul@0    299 
        elif isinstance(n, compiler.ast.Dict):
 
 paul@0    300 
            return self.get_literal_instance(n, "dict")
 
 paul@0    301 
 
 paul@0    302 
        elif isinstance(n, compiler.ast.List):
 
 paul@0    303 
            return self.get_literal_instance(n, "list")
 
 paul@0    304 
 
 paul@0    305 
        elif isinstance(n, compiler.ast.Tuple):
 
 paul@0    306 
            return self.get_literal_instance(n, "tuple")
 
 paul@0    307 
 
 paul@3    308 
        # Unsupported nodes.
 
 paul@3    309 
 
 paul@3    310 
        elif isinstance(n, compiler.ast.GenExpr):
 
 paul@205    311 
            raise InspectError("Generator expressions are not supported.", path, n)
 
 paul@3    312 
 
 paul@3    313 
        elif isinstance(n, compiler.ast.IfExp):
 
 paul@205    314 
            raise InspectError("If-else expressions are not supported.", path, n)
 
 paul@0    315 
 
 paul@0    316 
        elif isinstance(n, compiler.ast.ListComp):
 
 paul@205    317 
            raise InspectError("List comprehensions are not supported.", path, n)
 
 paul@0    318 
 
 paul@0    319 
        # All other nodes are processed depth-first.
 
 paul@0    320 
 
 paul@0    321 
        else:
 
 paul@0    322 
            self.process_structure(n)
 
 paul@0    323 
 
 paul@0    324 
        # By default, no expression details are returned.
 
 paul@0    325 
 
 paul@0    326 
        return None
 
 paul@0    327 
 
 paul@0    328 
    # Specific node handling.
 
 paul@0    329 
 
 paul@0    330 
    def process_assignment_node(self, n, expr):
 
 paul@0    331 
 
 paul@0    332 
        "Process the individual node 'n' to be assigned the contents of 'expr'."
 
 paul@0    333 
 
 paul@0    334 
        # Names and attributes are assigned the entire expression.
 
 paul@0    335 
 
 paul@0    336 
        if isinstance(n, compiler.ast.AssName):
 
 paul@61    337 
            if n.name == "self":
 
 paul@61    338 
                raise InspectError("Redefinition of self is not allowed.", self.get_namespace_path(), n)
 
 paul@0    339 
 
 paul@0    340 
            name_ref = expr and self.process_structure_node(expr)
 
 paul@0    341 
 
 paul@0    342 
            # Name assignments populate either function namespaces or the
 
 paul@0    343 
            # general namespace hierarchy.
 
 paul@0    344 
 
 paul@0    345 
            self.assign_general_local(n.name, name_ref)
 
 paul@0    346 
 
 paul@0    347 
            # Record usage of the name.
 
 paul@0    348 
 
 paul@0    349 
            self.record_name(n.name)
 
 paul@0    350 
 
 paul@0    351 
        elif isinstance(n, compiler.ast.AssAttr):
 
 paul@124    352 
            if expr:
 
 paul@124    353 
                expr = self.process_structure_node(expr)
 
 paul@107    354 
 
 paul@107    355 
            in_assignment = self.in_assignment
 
 paul@124    356 
            self.in_assignment = expr
 
 paul@0    357 
            self.process_attribute_access(n)
 
 paul@107    358 
            self.in_assignment = in_assignment
 
 paul@0    359 
 
 paul@0    360 
        # Lists and tuples are matched against the expression and their
 
 paul@0    361 
        # items assigned to expression items.
 
 paul@0    362 
 
 paul@0    363 
        elif isinstance(n, (compiler.ast.AssList, compiler.ast.AssTuple)):
 
 paul@0    364 
            self.process_assignment_node_items(n, expr)
 
 paul@0    365 
 
 paul@0    366 
        # Slices and subscripts are permitted within assignment nodes.
 
 paul@0    367 
 
 paul@0    368 
        elif isinstance(n, compiler.ast.Slice):
 
 paul@0    369 
            self.process_slice_node(n, expr)
 
 paul@0    370 
 
 paul@0    371 
        elif isinstance(n, compiler.ast.Subscript):
 
 paul@0    372 
            self.process_subscript_node(n, expr)
 
 paul@0    373 
 
 paul@0    374 
    def process_attribute_access(self, n):
 
 paul@0    375 
 
 paul@0    376 
        "Process the given attribute access node 'n'."
 
 paul@0    377 
 
 paul@107    378 
        # Obtain any completed chain and return the reference to it.
 
 paul@107    379 
 
 paul@0    380 
        name_ref = self.process_attribute_chain(n)
 
 paul@107    381 
 
 paul@0    382 
        if self.have_access_expression(n):
 
 paul@0    383 
            return name_ref
 
 paul@0    384 
 
 paul@0    385 
        # Where the start of the chain of attributes has been reached, determine
 
 paul@0    386 
        # the complete access.
 
 paul@0    387 
 
 paul@0    388 
        # Given a non-access node, this chain can be handled in its entirety,
 
 paul@0    389 
        # either being name-based and thus an access rooted on a name, or being
 
 paul@0    390 
        # based on some other node and thus an anonymous access of some kind.
 
 paul@0    391 
 
 paul@0    392 
        path = self.get_namespace_path()
 
 paul@0    393 
 
 paul@0    394 
        # Start with the the full attribute chain.
 
 paul@0    395 
 
 paul@0    396 
        remaining = self.attrs
 
 paul@0    397 
        attrnames = ".".join(remaining)
 
 paul@0    398 
 
 paul@0    399 
        # If the accessor cannot be identified, or where attributes
 
 paul@0    400 
        # remain in an attribute chain, record the anonymous accesses.
 
 paul@0    401 
 
 paul@0    402 
        if not isinstance(name_ref, NameRef): # includes ResolvedNameRef
 
 paul@0    403 
 
 paul@0    404 
            init_item(self.attr_accesses, path, set)
 
 paul@0    405 
            self.attr_accesses[path].add(attrnames)
 
 paul@0    406 
 
 paul@117    407 
            self.record_access_details(None, attrnames, self.in_assignment,
 
 paul@117    408 
                self.in_invocation)
 
 paul@0    409 
            del self.attrs[0]
 
 paul@0    410 
            return
 
 paul@0    411 
 
 paul@0    412 
        # Name-based accesses will handle the first attribute in a
 
 paul@0    413 
        # chain.
 
 paul@0    414 
 
 paul@0    415 
        else:
 
 paul@0    416 
            attrname = remaining[0]
 
 paul@0    417 
 
 paul@0    418 
            # Attribute assignments are used to identify instance attributes.
 
 paul@0    419 
 
 paul@0    420 
            if isinstance(n, compiler.ast.AssAttr) and \
 
 paul@0    421 
                self.in_class and self.in_function and n.expr.name == "self":
 
 paul@0    422 
 
 paul@0    423 
                self.set_instance_attr(attrname)
 
 paul@0    424 
 
 paul@0    425 
            # Record attribute usage using any name local to this namespace,
 
 paul@0    426 
            # if assigned in the namespace, or using an external name
 
 paul@0    427 
            # (presently just globals within classes).
 
 paul@0    428 
 
 paul@0    429 
            name = self.get_name_for_tracking(name_ref.name, name_ref.final())
 
 paul@0    430 
            tracker = self.trackers[-1]
 
 paul@0    431 
 
 paul@0    432 
            immediate_access = len(self.attrs) == 1
 
 paul@0    433 
            assignment = immediate_access and isinstance(n, compiler.ast.AssAttr)
 
 paul@0    434 
 
 paul@0    435 
            # Record global-based chains for subsequent resolution.
 
 paul@0    436 
 
 paul@0    437 
            is_global = self.in_function and not self.function_locals[path].has_key(name) or \
 
 paul@0    438 
                        not self.in_function
 
 paul@0    439 
 
 paul@0    440 
            if is_global:
 
 paul@0    441 
                self.record_global_access_details(name, attrnames)
 
 paul@0    442 
 
 paul@0    443 
            # Make sure the name is being tracked: global names will not
 
 paul@0    444 
            # already be initialised in a branch and must be added
 
 paul@0    445 
            # explicitly.
 
 paul@0    446 
 
 paul@0    447 
            if not tracker.have_name(name):
 
 paul@0    448 
                tracker.assign_names([name])
 
 paul@0    449 
                if self.in_function:
 
 paul@0    450 
                    self.scope_globals[path].add(name)
 
 paul@0    451 
 
 paul@0    452 
            # Record attribute usage in the tracker, and record the branch
 
 paul@0    453 
            # information for the access.
 
 paul@0    454 
 
 paul@110    455 
            branches = tracker.use_attribute(name, attrname, self.in_invocation, assignment)
 
 paul@0    456 
 
 paul@0    457 
            if not branches:
 
 paul@84    458 
                raise InspectError("Name %s is accessed using %s before an assignment." % (
 
 paul@84    459 
                    name, attrname), path, n)
 
 paul@0    460 
 
 paul@0    461 
            self.record_branches_for_access(branches, name, attrnames)
 
 paul@117    462 
            access_number = self.record_access_details(name, attrnames,
 
 paul@117    463 
                self.in_assignment, self.in_invocation)
 
 paul@107    464 
 
 paul@107    465 
            del self.attrs[0]
 
 paul@0    466 
            return AccessRef(name, attrnames, access_number)
 
 paul@0    467 
 
 paul@0    468 
    def process_class_node(self, n):
 
 paul@0    469 
 
 paul@0    470 
        "Process the given class node 'n'."
 
 paul@0    471 
 
 paul@0    472 
        path = self.get_namespace_path()
 
 paul@0    473 
 
 paul@0    474 
        # To avoid notions of class "versions" where the same definition
 
 paul@0    475 
        # might be parameterised with different state and be referenced
 
 paul@0    476 
        # elsewhere (as base classes, for example), classes in functions or
 
 paul@0    477 
        # conditions are forbidden.
 
 paul@0    478 
 
 paul@0    479 
        if self.in_function or self.in_conditional:
 
 paul@0    480 
            print >>sys.stderr, "In %s, class %s in function or conditional statement ignored." % (
 
 paul@0    481 
                path, n.name)
 
 paul@0    482 
            return
 
 paul@0    483 
 
 paul@0    484 
        # Resolve base classes.
 
 paul@0    485 
 
 paul@0    486 
        bases = []
 
 paul@0    487 
 
 paul@0    488 
        for base in n.bases:
 
 paul@0    489 
            base_class = self.get_class(base)
 
 paul@0    490 
 
 paul@0    491 
            if not base_class:
 
 paul@12    492 
                print >>sys.stderr, "In %s, class %s has unidentifiable base class: %s" % (
 
 paul@12    493 
                    path, n.name, base)
 
 paul@0    494 
                return
 
 paul@0    495 
            else:
 
 paul@0    496 
                bases.append(base_class)
 
 paul@0    497 
 
 paul@0    498 
        # Record bases for the class and retain the class name.
 
 paul@107    499 
        # Note that the function class does not inherit from the object class.
 
 paul@0    500 
 
 paul@0    501 
        class_name = self.get_object_path(n.name)
 
 paul@0    502 
 
 paul@107    503 
        if not bases and class_name != "__builtins__.core.object" and \
 
 paul@107    504 
                         class_name != "__builtins__.core.function":
 
 paul@107    505 
 
 paul@0    506 
            ref = self.get_object("__builtins__.object")
 
 paul@0    507 
            bases.append(ref)
 
 paul@0    508 
 
 paul@0    509 
        self.importer.classes[class_name] = self.classes[class_name] = bases
 
 paul@0    510 
        self.importer.subclasses[class_name] = set()
 
 paul@0    511 
        self.scope_globals[class_name] = set()
 
 paul@0    512 
 
 paul@0    513 
        # Set the definition before entering the namespace rather than
 
 paul@0    514 
        # afterwards because methods may reference it. In normal Python,
 
 paul@0    515 
        # a class is not accessible until the definition is complete, but
 
 paul@0    516 
        # methods can generally reference it since upon being called the
 
 paul@0    517 
        # class will already exist.
 
 paul@0    518 
 
 paul@0    519 
        self.set_definition(n.name, "<class>")
 
 paul@0    520 
 
 paul@0    521 
        in_class = self.in_class
 
 paul@0    522 
        self.in_class = class_name
 
 paul@0    523 
        self.set_instance_attr("__class__", Reference("<class>", class_name))
 
 paul@0    524 
        self.enter_namespace(n.name)
 
 paul@107    525 
 
 paul@107    526 
        # Do not provide the special instantiator attributes on the function
 
 paul@107    527 
        # class. Function instances provide these attributes.
 
 paul@107    528 
 
 paul@107    529 
        if class_name != "__builtins__.core.function":
 
 paul@107    530 
            self.set_name("__fn__") # special instantiator attribute
 
 paul@107    531 
            self.set_name("__args__") # special instantiator attribute
 
 paul@107    532 
 
 paul@274    533 
        self.set_name("__name__", self.get_constant("string", class_name).reference())
 
 paul@274    534 
 
 paul@0    535 
        self.process_structure_node(n.code)
 
 paul@0    536 
        self.exit_namespace()
 
 paul@0    537 
        self.in_class = in_class
 
 paul@0    538 
 
 paul@0    539 
    def process_from_node(self, n):
 
 paul@0    540 
 
 paul@0    541 
        "Process the given node 'n', importing from another module."
 
 paul@0    542 
 
 paul@0    543 
        path = self.get_namespace_path()
 
 paul@0    544 
 
 paul@12    545 
        module_name, names = self.get_module_name(n)
 
 paul@12    546 
        if module_name == self.name:
 
 paul@12    547 
            raise InspectError("Cannot import from the current module.", path, n)
 
 paul@0    548 
 
 paul@18    549 
        self.queue_module(module_name)
 
 paul@0    550 
 
 paul@0    551 
        # Attempt to obtain the referenced objects.
 
 paul@0    552 
 
 paul@0    553 
        for name, alias in n.names:
 
 paul@0    554 
            if name == "*":
 
 paul@12    555 
                raise InspectError("Only explicitly specified names can be imported from modules.", path, n)
 
 paul@0    556 
 
 paul@0    557 
            # Explicit names.
 
 paul@0    558 
 
 paul@12    559 
            ref = self.import_name_from_module(name, module_name)
 
 paul@0    560 
            value = ResolvedNameRef(alias or name, ref)
 
 paul@0    561 
            self.set_general_local(alias or name, value)
 
 paul@0    562 
 
 paul@0    563 
    def process_function_node(self, n, name):
 
 paul@0    564 
 
 paul@0    565 
        """
 
 paul@0    566 
        Process the given function or lambda node 'n' with the given 'name'.
 
 paul@0    567 
        """
 
 paul@0    568 
 
 paul@0    569 
        is_lambda = isinstance(n, compiler.ast.Lambda)
 
 paul@0    570 
 
 paul@0    571 
        # Where a function is declared conditionally, use a separate name for
 
 paul@0    572 
        # the definition, and assign the definition to the stated name.
 
 paul@0    573 
 
 paul@0    574 
        if (self.in_conditional or self.in_function) and not is_lambda:
 
 paul@0    575 
            original_name = name
 
 paul@0    576 
            name = self.get_lambda_name()
 
 paul@0    577 
        else:
 
 paul@0    578 
            original_name = None
 
 paul@0    579 
 
 paul@0    580 
        # Initialise argument and local records.
 
 paul@0    581 
 
 paul@0    582 
        function_name = self.get_object_path(name)
 
 paul@46    583 
        argnames = get_argnames(n.argnames)
 
 paul@48    584 
        is_method = self.in_class and not self.in_function
 
 paul@0    585 
 
 paul@48    586 
        # Remove explicit "self" from method parameters.
 
 paul@46    587 
 
 paul@48    588 
        if is_method and argnames and argnames[0] == "self":
 
 paul@48    589 
            del argnames[0]
 
 paul@48    590 
 
 paul@48    591 
        # Copy and propagate the parameters.
 
 paul@46    592 
 
 paul@46    593 
        self.importer.function_parameters[function_name] = \
 
 paul@109    594 
            self.function_parameters[function_name] = argnames[:]
 
 paul@46    595 
 
 paul@46    596 
        # Define all arguments/parameters in the local namespace.
 
 paul@46    597 
 
 paul@109    598 
        locals = \
 
 paul@109    599 
            self.importer.function_locals[function_name] = \
 
 paul@109    600 
            self.function_locals[function_name] = {}
 
 paul@0    601 
 
 paul@48    602 
        # Insert "self" into method locals.
 
 paul@48    603 
 
 paul@48    604 
        if is_method:
 
 paul@48    605 
            argnames.insert(0, "self")
 
 paul@48    606 
 
 paul@47    607 
        # Define "self" in terms of the class if in a method.
 
 paul@47    608 
        # This does not diminish the need for type-narrowing in the deducer.
 
 paul@47    609 
 
 paul@47    610 
        if argnames:
 
 paul@48    611 
            if self.in_class and not self.in_function and argnames[0] == "self":
 
 paul@47    612 
                locals[argnames[0]] = Reference("<instance>", self.in_class)
 
 paul@47    613 
            else:
 
 paul@47    614 
                locals[argnames[0]] = Reference("<var>")
 
 paul@47    615 
 
 paul@47    616 
        for argname in argnames[1:]:
 
 paul@0    617 
            locals[argname] = Reference("<var>")
 
 paul@0    618 
 
 paul@0    619 
        globals = self.scope_globals[function_name] = set()
 
 paul@0    620 
 
 paul@0    621 
        # Process the defaults.
 
 paul@0    622 
 
 paul@0    623 
        defaults = self.importer.function_defaults[function_name] = \
 
 paul@0    624 
                   self.function_defaults[function_name] = []
 
 paul@0    625 
 
 paul@0    626 
        for argname, default in compiler.ast.get_defaults(n):
 
 paul@0    627 
            if default:
 
 paul@0    628 
 
 paul@0    629 
                # Obtain any reference for the default.
 
 paul@0    630 
 
 paul@0    631 
                name_ref = self.process_structure_node(default)
 
 paul@0    632 
                defaults.append((argname, name_ref.is_name() and name_ref.reference() or Reference("<var>")))
 
 paul@0    633 
 
 paul@0    634 
        # Reset conditional tracking to focus on the function contents.
 
 paul@0    635 
 
 paul@0    636 
        in_conditional = self.in_conditional
 
 paul@0    637 
        self.in_conditional = False
 
 paul@0    638 
 
 paul@0    639 
        in_function = self.in_function
 
 paul@0    640 
        self.in_function = function_name
 
 paul@0    641 
 
 paul@0    642 
        self.enter_namespace(name)
 
 paul@0    643 
 
 paul@251    644 
        # Define a name attribute value for the function instance.
 
 paul@251    645 
 
 paul@251    646 
        ref = self.get_builtin_class("string")
 
 paul@251    647 
        self.reserve_constant(function_name, function_name, ref.get_origin())
 
 paul@251    648 
 
 paul@0    649 
        # Track attribute usage within the namespace.
 
 paul@0    650 
 
 paul@0    651 
        path = self.get_namespace_path()
 
 paul@0    652 
 
 paul@0    653 
        self.start_tracking(locals)
 
 paul@0    654 
        self.process_structure_node(n.code)
 
 paul@0    655 
        self.stop_tracking()
 
 paul@0    656 
 
 paul@1    657 
        # Exit to the parent.
 
 paul@0    658 
 
 paul@0    659 
        self.exit_namespace()
 
 paul@0    660 
 
 paul@0    661 
        # Update flags.
 
 paul@0    662 
 
 paul@0    663 
        self.in_function = in_function
 
 paul@0    664 
        self.in_conditional = in_conditional
 
 paul@0    665 
 
 paul@0    666 
        # Define the function using the appropriate name.
 
 paul@0    667 
 
 paul@0    668 
        self.set_definition(name, "<function>")
 
 paul@0    669 
 
 paul@0    670 
        # Where a function is set conditionally, assign the name.
 
 paul@0    671 
 
 paul@0    672 
        if original_name:
 
 paul@204    673 
            self.process_assignment_for_function(original_name, compiler.ast.Name(name))
 
 paul@0    674 
 
 paul@0    675 
    def process_global_node(self, n):
 
 paul@0    676 
 
 paul@0    677 
        """
 
 paul@0    678 
        Process the given "global" node 'n'.
 
 paul@0    679 
        """
 
 paul@0    680 
 
 paul@0    681 
        path = self.get_namespace_path()
 
 paul@0    682 
 
 paul@0    683 
        if path != self.name:
 
 paul@0    684 
            self.scope_globals[path].update(n.names)
 
 paul@0    685 
 
 paul@0    686 
    def process_if_node(self, n):
 
 paul@0    687 
 
 paul@0    688 
        """
 
 paul@0    689 
        Process the given "if" node 'n'.
 
 paul@0    690 
        """
 
 paul@0    691 
 
 paul@0    692 
        tracker = self.trackers[-1]
 
 paul@0    693 
        tracker.new_branchpoint()
 
 paul@0    694 
 
 paul@0    695 
        for test, body in n.tests:
 
 paul@0    696 
            self.process_structure_node(test)
 
 paul@0    697 
 
 paul@0    698 
            tracker.new_branch()
 
 paul@0    699 
 
 paul@0    700 
            in_conditional = self.in_conditional
 
 paul@0    701 
            self.in_conditional = True
 
 paul@0    702 
            self.process_structure_node(body)
 
 paul@0    703 
            self.in_conditional = in_conditional
 
 paul@0    704 
 
 paul@0    705 
            tracker.shelve_branch()
 
 paul@0    706 
 
 paul@0    707 
        # Maintain a branch for the else clause.
 
 paul@0    708 
 
 paul@0    709 
        tracker.new_branch()
 
 paul@0    710 
        if n.else_:
 
 paul@0    711 
            self.process_structure_node(n.else_)
 
 paul@0    712 
        tracker.shelve_branch()
 
 paul@0    713 
 
 paul@0    714 
        tracker.merge_branches()
 
 paul@0    715 
 
 paul@0    716 
    def process_import_node(self, n):
 
 paul@0    717 
 
 paul@0    718 
        "Process the given import node 'n'."
 
 paul@0    719 
 
 paul@0    720 
        path = self.get_namespace_path()
 
 paul@0    721 
 
 paul@0    722 
        # Load the mentioned module.
 
 paul@0    723 
 
 paul@0    724 
        for name, alias in n.names:
 
 paul@12    725 
            if name == self.name:
 
 paul@12    726 
                raise InspectError("Cannot import the current module.", path, n)
 
 paul@0    727 
 
 paul@13    728 
            self.set_module(alias or name.split(".")[-1], name)
 
 paul@18    729 
            self.queue_module(name, True)
 
 paul@0    730 
 
 paul@0    731 
    def process_invocation_node(self, n):
 
 paul@0    732 
 
 paul@0    733 
        "Process the given invocation node 'n'."
 
 paul@0    734 
 
 paul@0    735 
        path = self.get_namespace_path()
 
 paul@0    736 
 
 paul@0    737 
        self.allocate_arguments(path, n.args)
 
 paul@0    738 
 
 paul@0    739 
        try:
 
 paul@107    740 
            # Communicate to the invocation target expression that it forms the
 
 paul@107    741 
            # target of an invocation, potentially affecting attribute accesses.
 
 paul@0    742 
 
 paul@88    743 
            in_invocation = self.in_invocation
 
 paul@88    744 
            self.in_invocation = True
 
 paul@107    745 
 
 paul@107    746 
            # Process the expression, obtaining any identified reference.
 
 paul@107    747 
 
 paul@0    748 
            name_ref = self.process_structure_node(n.node)
 
 paul@223    749 
            self.in_invocation = False
 
 paul@0    750 
 
 paul@0    751 
            # Process the arguments.
 
 paul@0    752 
 
 paul@0    753 
            for arg in n.args:
 
 paul@0    754 
                self.process_structure_node(arg)
 
 paul@0    755 
 
 paul@223    756 
            self.in_invocation = in_invocation
 
 paul@223    757 
 
 paul@0    758 
            # Detect class invocations.
 
 paul@0    759 
 
 paul@0    760 
            if isinstance(name_ref, ResolvedNameRef) and name_ref.has_kind("<class>"):
 
 paul@0    761 
                return InstanceRef(name_ref.reference().instance_of())
 
 paul@0    762 
 
 paul@0    763 
            elif isinstance(name_ref, NameRef):
 
 paul@0    764 
                return InvocationRef(name_ref)
 
 paul@0    765 
 
 paul@226    766 
            # Provide a general reference to indicate that something is produced
 
 paul@226    767 
            # by the invocation, useful for retaining assignment expression
 
 paul@226    768 
            # details.
 
 paul@226    769 
 
 paul@226    770 
            return VariableRef()
 
 paul@0    771 
 
 paul@0    772 
        finally:
 
 paul@0    773 
            self.deallocate_arguments(path, n.args)
 
 paul@0    774 
 
 paul@0    775 
    def process_lambda_node(self, n):
 
 paul@0    776 
 
 paul@0    777 
        "Process the given lambda node 'n'."
 
 paul@0    778 
 
 paul@0    779 
        name = self.get_lambda_name()
 
 paul@0    780 
        self.process_function_node(n, name)
 
 paul@0    781 
 
 paul@0    782 
        origin = self.get_object_path(name)
 
 paul@210    783 
 
 paul@210    784 
        if self.function_defaults.get(origin):
 
 paul@210    785 
            return None
 
 paul@210    786 
        else:
 
 paul@210    787 
            return ResolvedNameRef(name, Reference("<function>", origin))
 
 paul@0    788 
 
 paul@0    789 
    def process_logical_node(self, n):
 
 paul@0    790 
 
 paul@0    791 
        "Process the given operator node 'n'."
 
 paul@0    792 
 
 paul@0    793 
        self.process_operator_chain(n.nodes, self.process_structure_node)
 
 paul@0    794 
 
 paul@0    795 
    def process_name_node(self, n):
 
 paul@0    796 
 
 paul@0    797 
        "Process the given name node 'n'."
 
 paul@0    798 
 
 paul@0    799 
        path = self.get_namespace_path()
 
 paul@0    800 
 
 paul@173    801 
        # Special names that have already been identified.
 
 paul@0    802 
 
 paul@0    803 
        if n.name.startswith("$"):
 
 paul@0    804 
            value = self.get_special(n.name)
 
 paul@0    805 
            if value:
 
 paul@0    806 
                return value
 
 paul@0    807 
 
 paul@0    808 
        # Special case for operator functions introduced through code
 
 paul@0    809 
        # transformations.
 
 paul@0    810 
 
 paul@0    811 
        if n.name.startswith("$op"):
 
 paul@0    812 
 
 paul@0    813 
            # Obtain the location of the actual function defined in the operator
 
 paul@0    814 
            # package.
 
 paul@0    815 
 
 paul@0    816 
            op = n.name[len("$op"):]
 
 paul@0    817 
 
 paul@0    818 
            # Attempt to get a reference.
 
 paul@0    819 
 
 paul@12    820 
            ref = self.import_name_from_module(op, "operator")
 
 paul@0    821 
 
 paul@0    822 
            # Record the imported name and provide the resolved name reference.
 
 paul@0    823 
 
 paul@0    824 
            value = ResolvedNameRef(n.name, ref)
 
 paul@0    825 
            self.set_special(n.name, value)
 
 paul@0    826 
            return value
 
 paul@0    827 
 
 paul@173    828 
        # Special case for print operations.
 
 paul@173    829 
 
 paul@173    830 
        elif n.name.startswith("$print"):
 
 paul@173    831 
 
 paul@173    832 
            # Attempt to get a reference.
 
 paul@173    833 
 
 paul@173    834 
            ref = self.get_builtin("print_")
 
 paul@173    835 
 
 paul@173    836 
            # Record the imported name and provide the resolved name reference.
 
 paul@173    837 
 
 paul@173    838 
            value = ResolvedNameRef(n.name, ref)
 
 paul@173    839 
            self.set_special(n.name, value)
 
 paul@173    840 
            return value
 
 paul@173    841 
 
 paul@60    842 
        # Test for self usage, which is only allowed in methods.
 
 paul@60    843 
 
 paul@60    844 
        if n.name == "self" and not (self.in_function and self.in_class):
 
 paul@60    845 
            raise InspectError("Use of self is only allowed in methods.", path, n)
 
 paul@60    846 
 
 paul@0    847 
        # Record usage of the name.
 
 paul@0    848 
 
 paul@0    849 
        self.record_name(n.name)
 
 paul@0    850 
 
 paul@0    851 
        # Search for unknown names in non-function scopes immediately.
 
 paul@0    852 
        # External names in functions are resolved later.
 
 paul@0    853 
 
 paul@0    854 
        ref = self.find_name(n.name)
 
 paul@0    855 
        if ref:
 
 paul@0    856 
            return ResolvedNameRef(n.name, ref)
 
 paul@0    857 
 
 paul@40    858 
        # Explicitly-declared global names.
 
 paul@0    859 
 
 paul@0    860 
        elif self.in_function and n.name in self.scope_globals[path]:
 
 paul@0    861 
            return NameRef(n.name)
 
 paul@0    862 
 
 paul@0    863 
        # Examine other names.
 
 paul@0    864 
 
 paul@0    865 
        else:
 
 paul@0    866 
            tracker = self.trackers[-1]
 
 paul@0    867 
 
 paul@0    868 
            # Check local names.
 
 paul@0    869 
 
 paul@0    870 
            branches = tracker.tracking_name(n.name)
 
 paul@0    871 
 
 paul@1    872 
            # Local name.
 
 paul@0    873 
 
 paul@0    874 
            if branches:
 
 paul@0    875 
                self.record_branches_for_access(branches, n.name, None)
 
 paul@117    876 
                access_number = self.record_access_details(n.name, None, False, False)
 
 paul@0    877 
                return LocalNameRef(n.name, access_number)
 
 paul@0    878 
 
 paul@40    879 
            # Possible global or built-in name.
 
 paul@0    880 
 
 paul@0    881 
            else:
 
 paul@0    882 
                return NameRef(n.name)
 
 paul@0    883 
 
 paul@0    884 
    def process_operator_chain(self, nodes, fn):
 
 paul@0    885 
 
 paul@0    886 
        """
 
 paul@0    887 
        Process the given chain of 'nodes', applying 'fn' to each node or item.
 
 paul@0    888 
        Each node starts a new conditional region, effectively making a deeply-
 
 paul@0    889 
        nested collection of if-like statements.
 
 paul@0    890 
        """
 
 paul@0    891 
 
 paul@0    892 
        tracker = self.trackers[-1]
 
 paul@0    893 
 
 paul@0    894 
        for item in nodes:
 
 paul@0    895 
            tracker.new_branchpoint()
 
 paul@0    896 
            tracker.new_branch()
 
 paul@0    897 
            fn(item)
 
 paul@0    898 
 
 paul@0    899 
        for item in nodes[:-1]:
 
 paul@0    900 
            tracker.shelve_branch()
 
 paul@0    901 
            tracker.new_branch()
 
 paul@0    902 
            tracker.shelve_branch()
 
 paul@0    903 
            tracker.merge_branches()
 
 paul@0    904 
 
 paul@0    905 
        tracker.shelve_branch()
 
 paul@0    906 
        tracker.merge_branches()
 
 paul@0    907 
 
 paul@0    908 
    def process_try_node(self, n):
 
 paul@0    909 
 
 paul@0    910 
        """
 
 paul@0    911 
        Process the given "try...except" node 'n'.
 
 paul@0    912 
        """
 
 paul@0    913 
 
 paul@0    914 
        tracker = self.trackers[-1]
 
 paul@0    915 
        tracker.new_branchpoint()
 
 paul@0    916 
 
 paul@0    917 
        self.process_structure_node(n.body)
 
 paul@0    918 
 
 paul@0    919 
        for name, var, handler in n.handlers:
 
 paul@0    920 
            if name is not None:
 
 paul@0    921 
                self.process_structure_node(name)
 
 paul@0    922 
 
 paul@0    923 
            # Any abandoned branches from the body can now be resumed in a new
 
 paul@0    924 
            # branch.
 
 paul@0    925 
 
 paul@0    926 
            tracker.resume_abandoned_branches()
 
 paul@0    927 
 
 paul@0    928 
            # Establish the local for the handler.
 
 paul@0    929 
 
 paul@0    930 
            if var is not None:
 
 paul@261    931 
                self.process_assignment_node(var, None)
 
 paul@0    932 
            if handler is not None:
 
 paul@0    933 
                self.process_structure_node(handler)
 
 paul@0    934 
 
 paul@0    935 
            tracker.shelve_branch()
 
 paul@0    936 
 
 paul@0    937 
        # The else clause maintains the usage from the body but without the
 
 paul@0    938 
        # abandoned branches since they would never lead to the else clause
 
 paul@0    939 
        # being executed.
 
 paul@0    940 
 
 paul@0    941 
        if n.else_:
 
 paul@0    942 
            tracker.new_branch()
 
 paul@0    943 
            self.process_structure_node(n.else_)
 
 paul@0    944 
            tracker.shelve_branch()
 
 paul@0    945 
 
 paul@0    946 
        # Without an else clause, a null branch propagates the successful
 
 paul@0    947 
        # outcome.
 
 paul@0    948 
 
 paul@0    949 
        else:
 
 paul@0    950 
            tracker.new_branch()
 
 paul@0    951 
            tracker.shelve_branch()
 
 paul@0    952 
 
 paul@0    953 
        tracker.merge_branches()
 
 paul@0    954 
 
 paul@0    955 
    def process_try_finally_node(self, n):
 
 paul@0    956 
 
 paul@0    957 
        """
 
 paul@0    958 
        Process the given "try...finally" node 'n'.
 
 paul@0    959 
        """
 
 paul@0    960 
 
 paul@0    961 
        tracker = self.trackers[-1]
 
 paul@0    962 
        self.process_structure_node(n.body)
 
 paul@0    963 
 
 paul@0    964 
        # Any abandoned branches from the body can now be resumed.
 
 paul@0    965 
 
 paul@0    966 
        branches = tracker.resume_all_abandoned_branches()
 
 paul@0    967 
        self.process_structure_node(n.final)
 
 paul@0    968 
 
 paul@0    969 
        # At the end of the finally clause, abandoned branches are discarded.
 
 paul@0    970 
 
 paul@0    971 
        tracker.restore_active_branches(branches)
 
 paul@0    972 
 
 paul@0    973 
    def process_while_node(self, n):
 
 paul@0    974 
 
 paul@0    975 
        "Process the given while node 'n'."
 
 paul@0    976 
 
 paul@0    977 
        tracker = self.trackers[-1]
 
 paul@0    978 
        tracker.new_branchpoint(loop_node=True)
 
 paul@0    979 
 
 paul@0    980 
        # Evaluate any test or iterator outside the loop.
 
 paul@0    981 
 
 paul@0    982 
        self.process_structure_node(n.test)
 
 paul@0    983 
 
 paul@0    984 
        # Propagate attribute usage to branches.
 
 paul@0    985 
 
 paul@0    986 
        tracker.new_branch(loop_node=True)
 
 paul@0    987 
 
 paul@0    988 
        # Enter the loop.
 
 paul@0    989 
 
 paul@0    990 
        in_conditional = self.in_conditional
 
 paul@0    991 
        self.in_conditional = True
 
 paul@0    992 
        self.process_structure_node(n.body)
 
 paul@0    993 
        self.in_conditional = in_conditional
 
 paul@0    994 
 
 paul@0    995 
        # Continuing branches are resumed before any test.
 
 paul@0    996 
 
 paul@0    997 
        tracker.resume_continuing_branches()
 
 paul@0    998 
 
 paul@0    999 
        # Evaluate any continuation test within the body.
 
 paul@0   1000 
 
 paul@0   1001 
        self.process_structure_node(n.test)
 
 paul@0   1002 
 
 paul@0   1003 
        tracker.shelve_branch(loop_node=True)
 
 paul@0   1004 
 
 paul@0   1005 
        # Support the non-looping condition.
 
 paul@0   1006 
 
 paul@0   1007 
        tracker.new_branch()
 
 paul@0   1008 
        tracker.shelve_branch()
 
 paul@0   1009 
 
 paul@0   1010 
        tracker.merge_branches()
 
 paul@0   1011 
 
 paul@0   1012 
        # Evaluate any else clause outside branches.
 
 paul@0   1013 
 
 paul@0   1014 
        if n.else_:
 
 paul@0   1015 
            self.process_structure_node(n.else_)
 
 paul@0   1016 
 
 paul@0   1017 
        # Connect broken branches to the code after any loop.
 
 paul@0   1018 
 
 paul@0   1019 
        tracker.resume_broken_branches()
 
 paul@0   1020 
 
 paul@0   1021 
    # Branch tracking methods.
 
 paul@0   1022 
 
 paul@0   1023 
    def start_tracking(self, names):
 
 paul@0   1024 
 
 paul@0   1025 
        """
 
 paul@0   1026 
        Start tracking attribute usage for names in the current namespace,
 
 paul@0   1027 
        immediately registering the given 'names'.
 
 paul@0   1028 
        """
 
 paul@0   1029 
 
 paul@0   1030 
        path = self.get_namespace_path()
 
 paul@0   1031 
        parent = self.trackers[-1]
 
 paul@0   1032 
        tracker = BranchTracker()
 
 paul@0   1033 
        self.trackers.append(tracker)
 
 paul@0   1034 
 
 paul@0   1035 
        # Record the given names established as new branches.
 
 paul@0   1036 
 
 paul@0   1037 
        tracker.assign_names(names)
 
 paul@0   1038 
 
 paul@0   1039 
    def assign_name(self, name, name_ref):
 
 paul@0   1040 
 
 paul@0   1041 
        "Assign to 'name' the given 'name_ref' in the current namespace."
 
 paul@0   1042 
 
 paul@0   1043 
        name = self.get_name_for_tracking(name)
 
 paul@0   1044 
        self.trackers[-1].assign_names([name], [name_ref])
 
 paul@0   1045 
 
 paul@0   1046 
    def stop_tracking(self):
 
 paul@0   1047 
 
 paul@0   1048 
        """
 
 paul@0   1049 
        Stop tracking attribute usage, recording computed usage for the current
 
 paul@0   1050 
        namespace.
 
 paul@0   1051 
        """
 
 paul@0   1052 
 
 paul@0   1053 
        path = self.get_namespace_path()
 
 paul@0   1054 
        tracker = self.trackers.pop()
 
 paul@0   1055 
        self.record_assignments_for_access(tracker)
 
 paul@0   1056 
 
 paul@0   1057 
        self.attr_usage[path] = tracker.get_all_usage()
 
 paul@0   1058 
        self.name_initialisers[path] = tracker.get_all_values()
 
 paul@0   1059 
 
 paul@0   1060 
    def start_tracking_in_module(self):
 
 paul@0   1061 
 
 paul@0   1062 
        "Start tracking attribute usage in the module."
 
 paul@0   1063 
 
 paul@0   1064 
        tracker = BranchTracker()
 
 paul@0   1065 
        self.trackers.append(tracker)
 
 paul@0   1066 
 
 paul@0   1067 
    def stop_tracking_in_module(self):
 
 paul@0   1068 
 
 paul@0   1069 
        "Stop tracking attribute usage in the module."
 
 paul@0   1070 
 
 paul@0   1071 
        tracker = self.trackers[0]
 
 paul@0   1072 
        self.record_assignments_for_access(tracker)
 
 paul@0   1073 
        self.attr_usage[self.name] = tracker.get_all_usage()
 
 paul@0   1074 
        self.name_initialisers[self.name] = tracker.get_all_values()
 
 paul@0   1075 
 
 paul@0   1076 
    def record_assignments_for_access(self, tracker):
 
 paul@0   1077 
 
 paul@0   1078 
        """
 
 paul@0   1079 
        For the current path, use the given 'tracker' to record assignment
 
 paul@0   1080 
        version information for attribute accesses.
 
 paul@0   1081 
        """
 
 paul@0   1082 
 
 paul@0   1083 
        path = self.get_path_for_access()
 
 paul@0   1084 
 
 paul@0   1085 
        if not self.attr_accessor_branches.has_key(path):
 
 paul@0   1086 
            return
 
 paul@0   1087 
 
 paul@0   1088 
        init_item(self.attr_accessors, path, dict)
 
 paul@0   1089 
        attr_accessors = self.attr_accessors[path]
 
 paul@0   1090 
 
 paul@0   1091 
        # Obtain the branches applying during each access.
 
 paul@0   1092 
 
 paul@0   1093 
        for access, all_branches in self.attr_accessor_branches[path].items():
 
 paul@0   1094 
            name, attrnames = access
 
 paul@0   1095 
            init_item(attr_accessors, access, list)
 
 paul@0   1096 
 
 paul@0   1097 
            # Obtain the assignments applying to each branch.
 
 paul@0   1098 
 
 paul@0   1099 
            for branches in all_branches:
 
 paul@0   1100 
                positions = tracker.get_assignment_positions_for_branches(name, branches)
 
 paul@0   1101 
 
 paul@0   1102 
                # Detect missing name information.
 
 paul@0   1103 
 
 paul@0   1104 
                if None in positions:
 
 paul@0   1105 
                    globals = self.global_attr_accesses.get(path)
 
 paul@0   1106 
                    accesses = globals and globals.get(name)
 
 paul@0   1107 
                    if not accesses:
 
 paul@0   1108 
                        print >>sys.stderr, "In %s, %s may not be defined when used." % (
 
 paul@0   1109 
                            self.get_namespace_path(), name)
 
 paul@0   1110 
                    positions.remove(None)
 
 paul@0   1111 
 
 paul@0   1112 
                attr_accessors[access].append(positions)
 
 paul@0   1113 
 
 paul@0   1114 
    def record_branches_for_access(self, branches, name, attrnames):
 
 paul@0   1115 
 
 paul@0   1116 
        """
 
 paul@0   1117 
        Record the given 'branches' for an access involving the given 'name' and
 
 paul@0   1118 
        'attrnames'.
 
 paul@0   1119 
        """
 
 paul@0   1120 
 
 paul@0   1121 
        access = name, attrnames
 
 paul@0   1122 
        path = self.get_path_for_access()
 
 paul@0   1123 
 
 paul@0   1124 
        init_item(self.attr_accessor_branches, path, dict)
 
 paul@0   1125 
        attr_accessor_branches = self.attr_accessor_branches[path]
 
 paul@0   1126 
 
 paul@0   1127 
        init_item(attr_accessor_branches, access, list)
 
 paul@0   1128 
        attr_accessor_branches[access].append(branches)
 
 paul@0   1129 
 
 paul@117   1130 
    def record_access_details(self, name, attrnames, assignment, invocation):
 
 paul@0   1131 
 
 paul@0   1132 
        """
 
 paul@0   1133 
        For the given 'name' and 'attrnames', record an access indicating
 
 paul@0   1134 
        whether 'assignment' is occurring.
 
 paul@0   1135 
 
 paul@0   1136 
        These details correspond to accesses otherwise recorded by the attribute
 
 paul@0   1137 
        accessor and attribute access dictionaries.
 
 paul@0   1138 
        """
 
 paul@0   1139 
 
 paul@0   1140 
        access = name, attrnames
 
 paul@0   1141 
        path = self.get_path_for_access()
 
 paul@0   1142 
 
 paul@0   1143 
        init_item(self.attr_access_modifiers, path, dict)
 
 paul@0   1144 
        init_item(self.attr_access_modifiers[path], access, list)
 
 paul@0   1145 
 
 paul@0   1146 
        access_number = len(self.attr_access_modifiers[path][access])
 
 paul@117   1147 
        self.attr_access_modifiers[path][access].append((assignment, invocation))
 
 paul@0   1148 
        return access_number
 
 paul@0   1149 
 
 paul@0   1150 
    def record_global_access_details(self, name, attrnames):
 
 paul@0   1151 
 
 paul@0   1152 
        """
 
 paul@0   1153 
        Record details of a global access via the given 'name' involving the
 
 paul@0   1154 
        indicated 'attrnames'.
 
 paul@0   1155 
        """
 
 paul@0   1156 
 
 paul@0   1157 
        path = self.get_namespace_path()
 
 paul@0   1158 
 
 paul@0   1159 
        init_item(self.global_attr_accesses, path, dict)
 
 paul@0   1160 
        init_item(self.global_attr_accesses[path], name, set)
 
 paul@0   1161 
        self.global_attr_accesses[path][name].add(attrnames)
 
 paul@0   1162 
 
 paul@0   1163 
    # Namespace modification.
 
 paul@0   1164 
 
 paul@0   1165 
    def record_name(self, name):
 
 paul@0   1166 
 
 paul@0   1167 
        "Record the use of 'name' in a namespace."
 
 paul@0   1168 
 
 paul@0   1169 
        path = self.get_namespace_path()
 
 paul@0   1170 
        init_item(self.names_used, path, set)
 
 paul@0   1171 
        self.names_used[path].add(name)
 
 paul@0   1172 
 
 paul@12   1173 
    def set_module(self, name, module_name):
 
 paul@0   1174 
 
 paul@0   1175 
        """
 
 paul@12   1176 
        Set a module in the current namespace using the given 'name' associated
 
 paul@12   1177 
        with the corresponding 'module_name'.
 
 paul@0   1178 
        """
 
 paul@0   1179 
 
 paul@0   1180 
        if name:
 
 paul@12   1181 
            self.set_general_local(name, Reference("<module>", module_name))
 
 paul@0   1182 
 
 paul@0   1183 
    def set_definition(self, name, kind):
 
 paul@0   1184 
 
 paul@0   1185 
        """
 
 paul@0   1186 
        Set the definition having the given 'name' and 'kind'.
 
 paul@0   1187 
 
 paul@0   1188 
        Definitions are set in the static namespace hierarchy, but they can also
 
 paul@0   1189 
        be recorded for function locals.
 
 paul@0   1190 
        """
 
 paul@0   1191 
 
 paul@0   1192 
        if self.is_global(name):
 
 paul@0   1193 
            print >>sys.stderr, "In %s, %s is defined as being global." % (
 
 paul@0   1194 
                self.get_namespace_path(), name)
 
 paul@0   1195 
 
 paul@0   1196 
        path = self.get_object_path(name)
 
 paul@0   1197 
        self.set_object(path, kind)
 
 paul@0   1198 
 
 paul@0   1199 
        ref = self.get_object(path)
 
 paul@0   1200 
        if ref.get_kind() == "<var>":
 
 paul@0   1201 
            print >>sys.stderr, "In %s, %s is defined more than once." % (
 
 paul@0   1202 
                self.get_namespace_path(), name)
 
 paul@0   1203 
 
 paul@0   1204 
        if not self.is_global(name) and self.in_function:
 
 paul@0   1205 
            self.set_function_local(name, ref)
 
 paul@0   1206 
 
 paul@0   1207 
    def set_function_local(self, name, ref=None):
 
 paul@0   1208 
 
 paul@0   1209 
        "Set the local with the given 'name' and optional 'ref'."
 
 paul@0   1210 
 
 paul@0   1211 
        locals = self.function_locals[self.get_namespace_path()]
 
 paul@0   1212 
        multiple = not ref or locals.has_key(name) and locals[name] != ref
 
 paul@0   1213 
        locals[name] = multiple and Reference("<var>") or ref
 
 paul@0   1214 
 
 paul@0   1215 
    def assign_general_local(self, name, name_ref):
 
 paul@0   1216 
 
 paul@0   1217 
        """
 
 paul@0   1218 
        Set for 'name' the given 'name_ref', recording the name for attribute
 
 paul@0   1219 
        usage tracking.
 
 paul@0   1220 
        """
 
 paul@0   1221 
 
 paul@0   1222 
        self.set_general_local(name, name_ref)
 
 paul@0   1223 
        self.assign_name(name, name_ref)
 
 paul@0   1224 
 
 paul@0   1225 
    def set_general_local(self, name, value=None):
 
 paul@0   1226 
 
 paul@0   1227 
        """
 
 paul@0   1228 
        Set the 'name' with optional 'value' in any kind of local namespace,
 
 paul@0   1229 
        where the 'value' should be a reference if specified.
 
 paul@0   1230 
        """
 
 paul@0   1231 
 
 paul@0   1232 
        init_value = self.get_initialising_value(value)
 
 paul@0   1233 
 
 paul@0   1234 
        # Module global names.
 
 paul@0   1235 
 
 paul@0   1236 
        if self.is_global(name):
 
 paul@0   1237 
            path = self.get_global_path(name)
 
 paul@0   1238 
            self.set_object(path, init_value)
 
 paul@0   1239 
 
 paul@0   1240 
        # Function local names.
 
 paul@0   1241 
 
 paul@0   1242 
        elif self.in_function:
 
 paul@0   1243 
            path = self.get_object_path(name)
 
 paul@0   1244 
            self.set_function_local(name, init_value)
 
 paul@0   1245 
 
 paul@0   1246 
        # Other namespaces (classes).
 
 paul@0   1247 
 
 paul@0   1248 
        else:
 
 paul@0   1249 
            path = self.get_object_path(name)
 
 paul@0   1250 
            self.set_name(name, init_value)
 
 paul@0   1251 
 
 paul@0   1252 
    def set_name(self, name, ref=None):
 
 paul@0   1253 
 
 paul@0   1254 
        "Attach the 'name' with optional 'ref' to the current namespace."
 
 paul@0   1255 
 
 paul@0   1256 
        self.set_object(self.get_object_path(name), ref)
 
 paul@0   1257 
 
 paul@0   1258 
    def set_instance_attr(self, name, ref=None):
 
 paul@0   1259 
 
 paul@0   1260 
        """
 
 paul@0   1261 
        Add an instance attribute of the given 'name' to the current class,
 
 paul@0   1262 
        using the optional 'ref'.
 
 paul@0   1263 
        """
 
 paul@0   1264 
 
 paul@251   1265 
        self._set_instance_attr(self.in_class, name, ref)
 
 paul@251   1266 
 
 paul@251   1267 
    def _set_instance_attr(self, path, name, ref=None):
 
 paul@251   1268 
 
 paul@251   1269 
        init_item(self.instance_attrs, path, set)
 
 paul@251   1270 
        self.instance_attrs[path].add(name)
 
 paul@0   1271 
 
 paul@0   1272 
        if ref:
 
 paul@251   1273 
            init_item(self.instance_attr_constants, path, dict)
 
 paul@251   1274 
            self.instance_attr_constants[path][name] = ref
 
 paul@0   1275 
 
 paul@0   1276 
    def get_initialising_value(self, value):
 
 paul@0   1277 
 
 paul@0   1278 
        "Return a suitable initialiser reference for 'value'."
 
 paul@0   1279 
 
 paul@25   1280 
        # Includes LiteralSequenceRef, ResolvedNameRef...
 
 paul@25   1281 
 
 paul@25   1282 
        if isinstance(value, (NameRef, AccessRef, InstanceRef)):
 
 paul@0   1283 
            return value.reference()
 
 paul@0   1284 
 
 paul@0   1285 
        # In general, invocations do not produce known results. However, the
 
 paul@0   1286 
        # name initialisers are resolved once a module has been inspected.
 
 paul@0   1287 
 
 paul@0   1288 
        elif isinstance(value, InvocationRef):
 
 paul@27   1289 
            return value.reference()
 
 paul@0   1290 
 
 paul@229   1291 
        # Variable references are unknown results.
 
 paul@229   1292 
 
 paul@229   1293 
        elif isinstance(value, VariableRef):
 
 paul@229   1294 
            return value.reference()
 
 paul@229   1295 
 
 paul@0   1296 
        else:
 
 paul@0   1297 
            return value
 
 paul@0   1298 
 
 paul@0   1299 
    # Static, program-relative naming.
 
 paul@0   1300 
 
 paul@0   1301 
    def find_name(self, name):
 
 paul@0   1302 
 
 paul@0   1303 
        """
 
 paul@0   1304 
        Return the qualified name for the given 'name' used in the current
 
 paul@0   1305 
        non-function namespace.
 
 paul@0   1306 
        """
 
 paul@0   1307 
 
 paul@0   1308 
        path = self.get_namespace_path()
 
 paul@0   1309 
        ref = None
 
 paul@0   1310 
 
 paul@0   1311 
        if not self.in_function and name not in predefined_constants:
 
 paul@0   1312 
            if self.in_class:
 
 paul@152   1313 
                ref = self.get_object(self.get_object_path(name), False)
 
 paul@0   1314 
            if not ref:
 
 paul@0   1315 
                ref = self.get_global_or_builtin(name)
 
 paul@0   1316 
 
 paul@0   1317 
        return ref
 
 paul@0   1318 
 
 paul@0   1319 
    def get_class(self, node):
 
 paul@0   1320 
 
 paul@0   1321 
        """
 
 paul@0   1322 
        Use the given 'node' to obtain the identity of a class. Return a
 
 paul@0   1323 
        reference for the class. Unresolved dependencies are permitted and must
 
 paul@0   1324 
        be resolved later.
 
 paul@0   1325 
        """
 
 paul@0   1326 
 
 paul@0   1327 
        ref = self._get_class(node)
 
 paul@0   1328 
        return ref.has_kind(["<class>", "<depends>"]) and ref or None
 
 paul@0   1329 
 
 paul@0   1330 
    def _get_class(self, node):
 
 paul@0   1331 
 
 paul@0   1332 
        """
 
 paul@0   1333 
        Use the given 'node' to find a class definition. Return a reference to
 
 paul@0   1334 
        the class.
 
 paul@0   1335 
        """
 
 paul@0   1336 
 
 paul@0   1337 
        if isinstance(node, compiler.ast.Getattr):
 
 paul@0   1338 
 
 paul@0   1339 
            # Obtain the identity of the access target.
 
 paul@0   1340 
 
 paul@0   1341 
            ref = self._get_class(node.expr)
 
 paul@0   1342 
 
 paul@0   1343 
            # Where the target is a class or module, obtain the identity of the
 
 paul@0   1344 
            # attribute.
 
 paul@0   1345 
 
 paul@0   1346 
            if ref.has_kind(["<function>", "<var>"]):
 
 paul@0   1347 
                return None
 
 paul@0   1348 
            else:
 
 paul@0   1349 
                attrname = "%s.%s" % (ref.get_origin(), node.attrname)
 
 paul@0   1350 
                return self.get_object(attrname)
 
 paul@0   1351 
 
 paul@0   1352 
        # Names can be module-level or built-in.
 
 paul@0   1353 
 
 paul@0   1354 
        elif isinstance(node, compiler.ast.Name):
 
 paul@0   1355 
 
 paul@0   1356 
            # Record usage of the name and attempt to identify it.
 
 paul@0   1357 
 
 paul@0   1358 
            self.record_name(node.name)
 
 paul@73   1359 
            return self.find_name(node.name)
 
 paul@0   1360 
        else:
 
 paul@0   1361 
            return None
 
 paul@0   1362 
 
 paul@0   1363 
    def get_constant(self, name, value):
 
 paul@0   1364 
 
 paul@0   1365 
        "Return a constant reference for the given type 'name' and 'value'."
 
 paul@0   1366 
 
 paul@12   1367 
        ref = self.get_builtin_class(name)
 
 paul@0   1368 
        return self.get_constant_reference(ref, value)
 
 paul@0   1369 
 
 paul@0   1370 
    def get_literal_instance(self, n, name):
 
 paul@0   1371 
 
 paul@0   1372 
        "For node 'n', return a reference to an instance of 'name'."
 
 paul@0   1373 
 
 paul@12   1374 
        # Get a reference to the built-in class.
 
 paul@0   1375 
 
 paul@12   1376 
        ref = self.get_builtin_class(name)
 
 paul@0   1377 
 
 paul@0   1378 
        # Obtain the details of the literal itself.
 
 paul@0   1379 
        # An alias to the type is generated for sequences.
 
 paul@0   1380 
 
 paul@0   1381 
        if name in ("dict", "list", "tuple"):
 
 paul@0   1382 
            self.set_special_literal(name, ref)
 
 paul@0   1383 
            return self.process_literal_sequence_node(n, name, ref, LiteralSequenceRef)
 
 paul@0   1384 
 
 paul@0   1385 
        # Constant values are independently recorded.
 
 paul@0   1386 
 
 paul@0   1387 
        else:
 
 paul@0   1388 
            return self.get_constant_reference(ref, n.value)
 
 paul@0   1389 
 
 paul@17   1390 
    # Special names.
 
 paul@0   1391 
 
 paul@17   1392 
    def get_special(self, name):
 
 paul@0   1393 
 
 paul@17   1394 
        "Return any stored value for the given special 'name'."
 
 paul@0   1395 
 
 paul@17   1396 
        return self.special.get(name)
 
 paul@17   1397 
 
 paul@17   1398 
    def set_special(self, name, value):
 
 paul@0   1399 
 
 paul@17   1400 
        """
 
 paul@17   1401 
        Set a special 'name' that merely tracks the use of an implicit object
 
 paul@17   1402 
        'value'.
 
 paul@17   1403 
        """
 
 paul@0   1404 
 
 paul@17   1405 
        self.special[name] = value
 
 paul@17   1406 
 
 paul@17   1407 
    def set_special_literal(self, name, ref):
 
 paul@0   1408 
 
 paul@17   1409 
        """
 
 paul@17   1410 
        Set a special name for the literal type 'name' having type 'ref'. Such
 
 paul@17   1411 
        special names provide a way of referring to literal object types.
 
 paul@17   1412 
        """
 
 paul@0   1413 
 
 paul@17   1414 
        literal_name = "$L%s" % name
 
 paul@17   1415 
        value = ResolvedNameRef(literal_name, ref)
 
 paul@17   1416 
        self.set_special(literal_name, value)
 
 paul@0   1417 
 
 paul@0   1418 
    # Functions and invocations.
 
 paul@0   1419 
 
 paul@36   1420 
    def set_invocation_usage(self):
 
 paul@36   1421 
 
 paul@36   1422 
        """
 
 paul@36   1423 
        Discard the current invocation storage figures, retaining the maximum
 
 paul@36   1424 
        values.
 
 paul@36   1425 
        """
 
 paul@36   1426 
 
 paul@36   1427 
        for path, (current, maximum) in self.function_targets.items():
 
 paul@36   1428 
            self.importer.function_targets[path] = self.function_targets[path] = maximum
 
 paul@36   1429 
 
 paul@36   1430 
        for path, (current, maximum) in self.function_arguments.items():
 
 paul@36   1431 
            self.importer.function_arguments[path] = self.function_arguments[path] = maximum
 
 paul@36   1432 
 
 paul@0   1433 
    def allocate_arguments(self, path, args):
 
 paul@0   1434 
 
 paul@0   1435 
        """
 
 paul@0   1436 
        Allocate temporary argument storage using current and maximum
 
 paul@0   1437 
        requirements for the given 'path' and 'args'.
 
 paul@0   1438 
        """
 
 paul@0   1439 
 
 paul@192   1440 
        # Class and module initialisation is ultimately combined.
 
 paul@192   1441 
 
 paul@192   1442 
        if not self.in_function:
 
 paul@192   1443 
            path = self.name
 
 paul@192   1444 
 
 paul@0   1445 
        init_item(self.function_targets, path, lambda: [0, 0])
 
 paul@0   1446 
        t = self.function_targets[path]
 
 paul@0   1447 
        t[0] += 1
 
 paul@0   1448 
        t[1] = max(t[0], t[1])
 
 paul@0   1449 
 
 paul@0   1450 
        init_item(self.function_arguments, path, lambda: [0, 0])
 
 paul@0   1451 
        t = self.function_arguments[path]
 
 paul@0   1452 
        t[0] += len(args) + 1
 
 paul@0   1453 
        t[1] = max(t[0], t[1])
 
 paul@0   1454 
 
 paul@0   1455 
    def deallocate_arguments(self, path, args):
 
 paul@0   1456 
 
 paul@0   1457 
        "Deallocate temporary argument storage for the given 'path' and 'args'."
 
 paul@0   1458 
 
 paul@192   1459 
        # Class and module initialisation is ultimately combined.
 
 paul@192   1460 
 
 paul@192   1461 
        if not self.in_function:
 
 paul@192   1462 
            path = self.name
 
 paul@192   1463 
 
 paul@0   1464 
        self.function_targets[path][0] -= 1
 
 paul@0   1465 
        self.function_arguments[path][0] -= len(args) + 1
 
 paul@0   1466 
 
 paul@0   1467 
# vim: tabstop=4 expandtab shiftwidth=4