Lichen

Annotated inspector.py

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