Lichen

Annotated inspector.py

676:b5fd9597bfab
629:c45334be1ad6
604:d11ceeafd2d7
2017-02-27 Paul Boddie file changeset files shortlog Introduced a logical result that simplifies negation expressions when they are used directly by "if" statements.
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@603    415 
            name = self.get_name_for_tracking(name_ref.name, name_ref)
 
 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@603    423 
            if name_ref.is_global_name():
 
 paul@0    424 
                self.record_global_access_details(name, attrnames)
 
 paul@0    425 
 
 paul@0    426 
            # Make sure the name is being tracked: global names will not
 
 paul@0    427 
            # already be initialised in a branch and must be added
 
 paul@0    428 
            # explicitly.
 
 paul@0    429 
 
 paul@0    430 
            if not tracker.have_name(name):
 
 paul@0    431 
                tracker.assign_names([name])
 
 paul@0    432 
                if self.in_function:
 
 paul@0    433 
                    self.scope_globals[path].add(name)
 
 paul@0    434 
 
 paul@0    435 
            # Record attribute usage in the tracker, and record the branch
 
 paul@0    436 
            # information for the access.
 
 paul@0    437 
 
 paul@557    438 
            branches = tracker.use_attribute(name, attrname,
 
 paul@557    439 
                self.in_invocation is not None, assignment)
 
 paul@0    440 
 
 paul@0    441 
            if not branches:
 
 paul@84    442 
                raise InspectError("Name %s is accessed using %s before an assignment." % (
 
 paul@84    443 
                    name, attrname), path, n)
 
 paul@0    444 
 
 paul@0    445 
            self.record_branches_for_access(branches, name, attrnames)
 
 paul@117    446 
            access_number = self.record_access_details(name, attrnames,
 
 paul@117    447 
                self.in_assignment, self.in_invocation)
 
 paul@107    448 
 
 paul@107    449 
            del self.attrs[0]
 
 paul@0    450 
            return AccessRef(name, attrnames, access_number)
 
 paul@0    451 
 
 paul@0    452 
    def process_class_node(self, n):
 
 paul@0    453 
 
 paul@0    454 
        "Process the given class node 'n'."
 
 paul@0    455 
 
 paul@0    456 
        path = self.get_namespace_path()
 
 paul@0    457 
 
 paul@0    458 
        # To avoid notions of class "versions" where the same definition
 
 paul@0    459 
        # might be parameterised with different state and be referenced
 
 paul@0    460 
        # elsewhere (as base classes, for example), classes in functions or
 
 paul@0    461 
        # conditions are forbidden.
 
 paul@0    462 
 
 paul@0    463 
        if self.in_function or self.in_conditional:
 
 paul@0    464 
            print >>sys.stderr, "In %s, class %s in function or conditional statement ignored." % (
 
 paul@0    465 
                path, n.name)
 
 paul@0    466 
            return
 
 paul@0    467 
 
 paul@0    468 
        # Resolve base classes.
 
 paul@0    469 
 
 paul@0    470 
        bases = []
 
 paul@0    471 
 
 paul@0    472 
        for base in n.bases:
 
 paul@0    473 
            base_class = self.get_class(base)
 
 paul@0    474 
 
 paul@0    475 
            if not base_class:
 
 paul@12    476 
                print >>sys.stderr, "In %s, class %s has unidentifiable base class: %s" % (
 
 paul@12    477 
                    path, n.name, base)
 
 paul@0    478 
                return
 
 paul@0    479 
            else:
 
 paul@0    480 
                bases.append(base_class)
 
 paul@0    481 
 
 paul@348    482 
        # Detect conflicting definitions. Such definitions cause conflicts in
 
 paul@348    483 
        # the storage of namespace-related information.
 
 paul@348    484 
 
 paul@348    485 
        class_name = self.get_object_path(n.name)
 
 paul@422    486 
        ref = self.get_object(class_name, defer=False)
 
 paul@348    487 
 
 paul@422    488 
        if ref and ref.static():
 
 paul@348    489 
            raise InspectError("Multiple definitions for the same name are not permitted.", class_name, n)
 
 paul@348    490 
 
 paul@0    491 
        # Record bases for the class and retain the class name.
 
 paul@107    492 
        # Note that the function class does not inherit from the object class.
 
 paul@0    493 
 
 paul@107    494 
        if not bases and class_name != "__builtins__.core.object" and \
 
 paul@107    495 
                         class_name != "__builtins__.core.function":
 
 paul@107    496 
 
 paul@0    497 
            ref = self.get_object("__builtins__.object")
 
 paul@0    498 
            bases.append(ref)
 
 paul@0    499 
 
 paul@0    500 
        self.importer.classes[class_name] = self.classes[class_name] = bases
 
 paul@0    501 
        self.importer.subclasses[class_name] = set()
 
 paul@0    502 
        self.scope_globals[class_name] = set()
 
 paul@0    503 
 
 paul@0    504 
        # Set the definition before entering the namespace rather than
 
 paul@0    505 
        # afterwards because methods may reference it. In normal Python,
 
 paul@0    506 
        # a class is not accessible until the definition is complete, but
 
 paul@0    507 
        # methods can generally reference it since upon being called the
 
 paul@0    508 
        # class will already exist.
 
 paul@0    509 
 
 paul@0    510 
        self.set_definition(n.name, "<class>")
 
 paul@0    511 
 
 paul@0    512 
        in_class = self.in_class
 
 paul@0    513 
        self.in_class = class_name
 
 paul@0    514 
        self.set_instance_attr("__class__", Reference("<class>", class_name))
 
 paul@0    515 
        self.enter_namespace(n.name)
 
 paul@107    516 
 
 paul@107    517 
        # Do not provide the special instantiator attributes on the function
 
 paul@107    518 
        # class. Function instances provide these attributes.
 
 paul@107    519 
 
 paul@107    520 
        if class_name != "__builtins__.core.function":
 
 paul@577    521 
 
 paul@107    522 
            self.set_name("__fn__") # special instantiator attribute
 
 paul@107    523 
            self.set_name("__args__") # special instantiator attribute
 
 paul@107    524 
 
 paul@577    525 
        # Provide leafname, parent and context attributes.
 
 paul@489    526 
 
 paul@499    527 
        parent, leafname = class_name.rsplit(".", 1)
 
 paul@499    528 
        self.set_name("__name__", self.get_constant("string", leafname).reference())
 
 paul@577    529 
 
 paul@577    530 
        if class_name != "__builtins__.core.function":
 
 paul@577    531 
            self.set_name("__parent__")
 
 paul@274    532 
 
 paul@0    533 
        self.process_structure_node(n.code)
 
 paul@0    534 
        self.exit_namespace()
 
 paul@0    535 
        self.in_class = in_class
 
 paul@0    536 
 
 paul@0    537 
    def process_from_node(self, n):
 
 paul@0    538 
 
 paul@0    539 
        "Process the given node 'n', importing from another module."
 
 paul@0    540 
 
 paul@0    541 
        path = self.get_namespace_path()
 
 paul@0    542 
 
 paul@12    543 
        module_name, names = self.get_module_name(n)
 
 paul@12    544 
        if module_name == self.name:
 
 paul@12    545 
            raise InspectError("Cannot import from the current module.", path, n)
 
 paul@0    546 
 
 paul@18    547 
        self.queue_module(module_name)
 
 paul@0    548 
 
 paul@0    549 
        # Attempt to obtain the referenced objects.
 
 paul@0    550 
 
 paul@0    551 
        for name, alias in n.names:
 
 paul@0    552 
            if name == "*":
 
 paul@12    553 
                raise InspectError("Only explicitly specified names can be imported from modules.", path, n)
 
 paul@0    554 
 
 paul@0    555 
            # Explicit names.
 
 paul@0    556 
 
 paul@12    557 
            ref = self.import_name_from_module(name, module_name)
 
 paul@0    558 
            value = ResolvedNameRef(alias or name, ref)
 
 paul@0    559 
            self.set_general_local(alias or name, value)
 
 paul@0    560 
 
 paul@0    561 
    def process_function_node(self, n, name):
 
 paul@0    562 
 
 paul@0    563 
        """
 
 paul@0    564 
        Process the given function or lambda node 'n' with the given 'name'.
 
 paul@0    565 
        """
 
 paul@0    566 
 
 paul@0    567 
        is_lambda = isinstance(n, compiler.ast.Lambda)
 
 paul@0    568 
 
 paul@0    569 
        # Where a function is declared conditionally, use a separate name for
 
 paul@0    570 
        # the definition, and assign the definition to the stated name.
 
 paul@0    571 
 
 paul@0    572 
        if (self.in_conditional or self.in_function) and not is_lambda:
 
 paul@0    573 
            original_name = name
 
 paul@0    574 
            name = self.get_lambda_name()
 
 paul@0    575 
        else:
 
 paul@0    576 
            original_name = None
 
 paul@0    577 
 
 paul@348    578 
        # Detect conflicting definitions. Such definitions cause conflicts in
 
 paul@348    579 
        # the storage of namespace-related information.
 
 paul@348    580 
 
 paul@348    581 
        function_name = self.get_object_path(name)
 
 paul@422    582 
        ref = self.get_object(function_name, defer=False)
 
 paul@348    583 
 
 paul@422    584 
        if ref and ref.static():
 
 paul@348    585 
            raise InspectError("Multiple definitions for the same name are not permitted.", function_name, n)
 
 paul@348    586 
 
 paul@0    587 
        # Initialise argument and local records.
 
 paul@0    588 
 
 paul@46    589 
        argnames = get_argnames(n.argnames)
 
 paul@48    590 
        is_method = self.in_class and not self.in_function
 
 paul@0    591 
 
 paul@48    592 
        # Remove explicit "self" from method parameters.
 
 paul@46    593 
 
 paul@48    594 
        if is_method and argnames and argnames[0] == "self":
 
 paul@48    595 
            del argnames[0]
 
 paul@48    596 
 
 paul@48    597 
        # Copy and propagate the parameters.
 
 paul@46    598 
 
 paul@46    599 
        self.importer.function_parameters[function_name] = \
 
 paul@109    600 
            self.function_parameters[function_name] = argnames[:]
 
 paul@46    601 
 
 paul@46    602 
        # Define all arguments/parameters in the local namespace.
 
 paul@46    603 
 
 paul@109    604 
        locals = \
 
 paul@109    605 
            self.importer.function_locals[function_name] = \
 
 paul@109    606 
            self.function_locals[function_name] = {}
 
 paul@0    607 
 
 paul@48    608 
        # Insert "self" into method locals.
 
 paul@48    609 
 
 paul@48    610 
        if is_method:
 
 paul@48    611 
            argnames.insert(0, "self")
 
 paul@48    612 
 
 paul@47    613 
        # Define "self" in terms of the class if in a method.
 
 paul@47    614 
        # This does not diminish the need for type-narrowing in the deducer.
 
 paul@47    615 
 
 paul@47    616 
        if argnames:
 
 paul@48    617 
            if self.in_class and not self.in_function and argnames[0] == "self":
 
 paul@47    618 
                locals[argnames[0]] = Reference("<instance>", self.in_class)
 
 paul@47    619 
            else:
 
 paul@47    620 
                locals[argnames[0]] = Reference("<var>")
 
 paul@47    621 
 
 paul@47    622 
        for argname in argnames[1:]:
 
 paul@0    623 
            locals[argname] = Reference("<var>")
 
 paul@0    624 
 
 paul@0    625 
        globals = self.scope_globals[function_name] = set()
 
 paul@0    626 
 
 paul@0    627 
        # Process the defaults.
 
 paul@0    628 
 
 paul@0    629 
        defaults = self.importer.function_defaults[function_name] = \
 
 paul@0    630 
                   self.function_defaults[function_name] = []
 
 paul@0    631 
 
 paul@0    632 
        for argname, default in compiler.ast.get_defaults(n):
 
 paul@0    633 
            if default:
 
 paul@0    634 
 
 paul@0    635 
                # Obtain any reference for the default.
 
 paul@0    636 
 
 paul@0    637 
                name_ref = self.process_structure_node(default)
 
 paul@0    638 
                defaults.append((argname, name_ref.is_name() and name_ref.reference() or Reference("<var>")))
 
 paul@0    639 
 
 paul@0    640 
        # Reset conditional tracking to focus on the function contents.
 
 paul@0    641 
 
 paul@0    642 
        in_conditional = self.in_conditional
 
 paul@0    643 
        self.in_conditional = False
 
 paul@0    644 
 
 paul@0    645 
        in_function = self.in_function
 
 paul@0    646 
        self.in_function = function_name
 
 paul@0    647 
 
 paul@0    648 
        self.enter_namespace(name)
 
 paul@0    649 
 
 paul@499    650 
        # Define a leafname attribute value for the function instance.
 
 paul@251    651 
 
 paul@251    652 
        ref = self.get_builtin_class("string")
 
 paul@489    653 
        self.reserve_constant(function_name, name, ref.get_origin())
 
 paul@251    654 
 
 paul@0    655 
        # Track attribute usage within the namespace.
 
 paul@0    656 
 
 paul@0    657 
        path = self.get_namespace_path()
 
 paul@0    658 
 
 paul@0    659 
        self.start_tracking(locals)
 
 paul@0    660 
        self.process_structure_node(n.code)
 
 paul@0    661 
        self.stop_tracking()
 
 paul@0    662 
 
 paul@1    663 
        # Exit to the parent.
 
 paul@0    664 
 
 paul@0    665 
        self.exit_namespace()
 
 paul@0    666 
 
 paul@0    667 
        # Update flags.
 
 paul@0    668 
 
 paul@0    669 
        self.in_function = in_function
 
 paul@0    670 
        self.in_conditional = in_conditional
 
 paul@0    671 
 
 paul@0    672 
        # Define the function using the appropriate name.
 
 paul@0    673 
 
 paul@0    674 
        self.set_definition(name, "<function>")
 
 paul@0    675 
 
 paul@0    676 
        # Where a function is set conditionally, assign the name.
 
 paul@0    677 
 
 paul@0    678 
        if original_name:
 
 paul@322    679 
            self.process_assignment_for_object(original_name, compiler.ast.Name(name))
 
 paul@0    680 
 
 paul@0    681 
    def process_global_node(self, n):
 
 paul@0    682 
 
 paul@0    683 
        """
 
 paul@0    684 
        Process the given "global" node 'n'.
 
 paul@0    685 
        """
 
 paul@0    686 
 
 paul@0    687 
        path = self.get_namespace_path()
 
 paul@0    688 
 
 paul@0    689 
        if path != self.name:
 
 paul@0    690 
            self.scope_globals[path].update(n.names)
 
 paul@0    691 
 
 paul@0    692 
    def process_if_node(self, n):
 
 paul@0    693 
 
 paul@0    694 
        """
 
 paul@0    695 
        Process the given "if" node 'n'.
 
 paul@0    696 
        """
 
 paul@0    697 
 
 paul@0    698 
        tracker = self.trackers[-1]
 
 paul@0    699 
        tracker.new_branchpoint()
 
 paul@0    700 
 
 paul@0    701 
        for test, body in n.tests:
 
 paul@0    702 
            self.process_structure_node(test)
 
 paul@0    703 
 
 paul@0    704 
            tracker.new_branch()
 
 paul@0    705 
 
 paul@0    706 
            in_conditional = self.in_conditional
 
 paul@0    707 
            self.in_conditional = True
 
 paul@0    708 
            self.process_structure_node(body)
 
 paul@0    709 
            self.in_conditional = in_conditional
 
 paul@0    710 
 
 paul@0    711 
            tracker.shelve_branch()
 
 paul@0    712 
 
 paul@0    713 
        # Maintain a branch for the else clause.
 
 paul@0    714 
 
 paul@0    715 
        tracker.new_branch()
 
 paul@0    716 
        if n.else_:
 
 paul@0    717 
            self.process_structure_node(n.else_)
 
 paul@0    718 
        tracker.shelve_branch()
 
 paul@0    719 
 
 paul@0    720 
        tracker.merge_branches()
 
 paul@0    721 
 
 paul@0    722 
    def process_import_node(self, n):
 
 paul@0    723 
 
 paul@0    724 
        "Process the given import node 'n'."
 
 paul@0    725 
 
 paul@0    726 
        path = self.get_namespace_path()
 
 paul@0    727 
 
 paul@0    728 
        # Load the mentioned module.
 
 paul@0    729 
 
 paul@0    730 
        for name, alias in n.names:
 
 paul@12    731 
            if name == self.name:
 
 paul@12    732 
                raise InspectError("Cannot import the current module.", path, n)
 
 paul@0    733 
 
 paul@13    734 
            self.set_module(alias or name.split(".")[-1], name)
 
 paul@18    735 
            self.queue_module(name, True)
 
 paul@0    736 
 
 paul@0    737 
    def process_invocation_node(self, n):
 
 paul@0    738 
 
 paul@0    739 
        "Process the given invocation node 'n'."
 
 paul@0    740 
 
 paul@0    741 
        path = self.get_namespace_path()
 
 paul@0    742 
 
 paul@0    743 
        self.allocate_arguments(path, n.args)
 
 paul@0    744 
 
 paul@0    745 
        try:
 
 paul@557    746 
            in_invocation = self.in_invocation
 
 paul@557    747 
            self.in_invocation = None
 
 paul@557    748 
 
 paul@557    749 
            # Process the arguments.
 
 paul@557    750 
 
 paul@557    751 
            keywords = set()
 
 paul@557    752 
 
 paul@557    753 
            for arg in n.args:
 
 paul@557    754 
                self.process_structure_node(arg)
 
 paul@557    755 
                if isinstance(arg, compiler.ast.Keyword):
 
 paul@557    756 
                    keywords.add(arg.name)
 
 paul@557    757 
 
 paul@557    758 
            keywords = list(keywords)
 
 paul@557    759 
            keywords.sort()
 
 paul@557    760 
 
 paul@107    761 
            # Communicate to the invocation target expression that it forms the
 
 paul@107    762 
            # target of an invocation, potentially affecting attribute accesses.
 
 paul@0    763 
 
 paul@557    764 
            self.in_invocation = len(n.args), keywords
 
 paul@107    765 
 
 paul@107    766 
            # Process the expression, obtaining any identified reference.
 
 paul@107    767 
 
 paul@0    768 
            name_ref = self.process_structure_node(n.node)
 
 paul@223    769 
            self.in_invocation = in_invocation
 
 paul@223    770 
 
 paul@0    771 
            # Detect class invocations.
 
 paul@0    772 
 
 paul@0    773 
            if isinstance(name_ref, ResolvedNameRef) and name_ref.has_kind("<class>"):
 
 paul@0    774 
                return InstanceRef(name_ref.reference().instance_of())
 
 paul@0    775 
 
 paul@0    776 
            elif isinstance(name_ref, NameRef):
 
 paul@0    777 
                return InvocationRef(name_ref)
 
 paul@0    778 
 
 paul@226    779 
            # Provide a general reference to indicate that something is produced
 
 paul@226    780 
            # by the invocation, useful for retaining assignment expression
 
 paul@226    781 
            # details.
 
 paul@226    782 
 
 paul@226    783 
            return VariableRef()
 
 paul@0    784 
 
 paul@0    785 
        finally:
 
 paul@0    786 
            self.deallocate_arguments(path, n.args)
 
 paul@0    787 
 
 paul@0    788 
    def process_lambda_node(self, n):
 
 paul@0    789 
 
 paul@0    790 
        "Process the given lambda node 'n'."
 
 paul@0    791 
 
 paul@0    792 
        name = self.get_lambda_name()
 
 paul@0    793 
        self.process_function_node(n, name)
 
 paul@0    794 
 
 paul@0    795 
        origin = self.get_object_path(name)
 
 paul@210    796 
 
 paul@210    797 
        if self.function_defaults.get(origin):
 
 paul@210    798 
            return None
 
 paul@210    799 
        else:
 
 paul@210    800 
            return ResolvedNameRef(name, Reference("<function>", origin))
 
 paul@0    801 
 
 paul@0    802 
    def process_logical_node(self, n):
 
 paul@0    803 
 
 paul@0    804 
        "Process the given operator node 'n'."
 
 paul@0    805 
 
 paul@0    806 
        self.process_operator_chain(n.nodes, self.process_structure_node)
 
 paul@0    807 
 
 paul@0    808 
    def process_name_node(self, n):
 
 paul@0    809 
 
 paul@0    810 
        "Process the given name node 'n'."
 
 paul@0    811 
 
 paul@0    812 
        path = self.get_namespace_path()
 
 paul@0    813 
 
 paul@420    814 
        # Find predefined constant names before anything else.
 
 paul@420    815 
 
 paul@420    816 
        if n.name in predefined_constants:
 
 paul@420    817 
            ref = self.get_builtin(n.name)
 
 paul@420    818 
            value = ResolvedNameRef(n.name, ref)
 
 paul@420    819 
            return value
 
 paul@420    820 
 
 paul@173    821 
        # Special names that have already been identified.
 
 paul@0    822 
 
 paul@0    823 
        if n.name.startswith("$"):
 
 paul@0    824 
            value = self.get_special(n.name)
 
 paul@0    825 
            if value:
 
 paul@0    826 
                return value
 
 paul@0    827 
 
 paul@0    828 
        # Special case for operator functions introduced through code
 
 paul@0    829 
        # transformations.
 
 paul@0    830 
 
 paul@0    831 
        if n.name.startswith("$op"):
 
 paul@0    832 
 
 paul@0    833 
            # Obtain the location of the actual function defined in the operator
 
 paul@0    834 
            # package.
 
 paul@0    835 
 
 paul@0    836 
            op = n.name[len("$op"):]
 
 paul@0    837 
 
 paul@0    838 
            # Attempt to get a reference.
 
 paul@0    839 
 
 paul@12    840 
            ref = self.import_name_from_module(op, "operator")
 
 paul@0    841 
 
 paul@0    842 
            # Record the imported name and provide the resolved name reference.
 
 paul@0    843 
 
 paul@0    844 
            value = ResolvedNameRef(n.name, ref)
 
 paul@0    845 
            self.set_special(n.name, value)
 
 paul@0    846 
            return value
 
 paul@0    847 
 
 paul@173    848 
        # Special case for print operations.
 
 paul@173    849 
 
 paul@173    850 
        elif n.name.startswith("$print"):
 
 paul@173    851 
 
 paul@173    852 
            # Attempt to get a reference.
 
 paul@173    853 
 
 paul@173    854 
            ref = self.get_builtin("print_")
 
 paul@173    855 
 
 paul@173    856 
            # Record the imported name and provide the resolved name reference.
 
 paul@173    857 
 
 paul@173    858 
            value = ResolvedNameRef(n.name, ref)
 
 paul@173    859 
            self.set_special(n.name, value)
 
 paul@173    860 
            return value
 
 paul@173    861 
 
 paul@60    862 
        # Test for self usage, which is only allowed in methods.
 
 paul@60    863 
 
 paul@60    864 
        if n.name == "self" and not (self.in_function and self.in_class):
 
 paul@60    865 
            raise InspectError("Use of self is only allowed in methods.", path, n)
 
 paul@60    866 
 
 paul@0    867 
        # Record usage of the name.
 
 paul@0    868 
 
 paul@0    869 
        self.record_name(n.name)
 
 paul@0    870 
 
 paul@0    871 
        # Search for unknown names in non-function scopes immediately.
 
 paul@0    872 
        # External names in functions are resolved later.
 
 paul@0    873 
 
 paul@0    874 
        ref = self.find_name(n.name)
 
 paul@0    875 
        if ref:
 
 paul@603    876 
            return ResolvedNameRef(n.name, ref, is_global=True)
 
 paul@0    877 
 
 paul@40    878 
        # Explicitly-declared global names.
 
 paul@0    879 
 
 paul@0    880 
        elif self.in_function and n.name in self.scope_globals[path]:
 
 paul@603    881 
            return NameRef(n.name, is_global=True)
 
 paul@0    882 
 
 paul@0    883 
        # Examine other names.
 
 paul@0    884 
 
 paul@0    885 
        else:
 
 paul@0    886 
            tracker = self.trackers[-1]
 
 paul@0    887 
 
 paul@0    888 
            # Check local names.
 
 paul@0    889 
 
 paul@0    890 
            branches = tracker.tracking_name(n.name)
 
 paul@0    891 
 
 paul@1    892 
            # Local name.
 
 paul@0    893 
 
 paul@0    894 
            if branches:
 
 paul@0    895 
                self.record_branches_for_access(branches, n.name, None)
 
 paul@553    896 
                access_number = self.record_access_details(n.name, None, None, None)
 
 paul@0    897 
                return LocalNameRef(n.name, access_number)
 
 paul@0    898 
 
 paul@40    899 
            # Possible global or built-in name.
 
 paul@0    900 
 
 paul@0    901 
            else:
 
 paul@603    902 
                return NameRef(n.name, is_global=True)
 
 paul@0    903 
 
 paul@0    904 
    def process_operator_chain(self, nodes, fn):
 
 paul@0    905 
 
 paul@0    906 
        """
 
 paul@0    907 
        Process the given chain of 'nodes', applying 'fn' to each node or item.
 
 paul@0    908 
        Each node starts a new conditional region, effectively making a deeply-
 
 paul@0    909 
        nested collection of if-like statements.
 
 paul@0    910 
        """
 
 paul@0    911 
 
 paul@0    912 
        tracker = self.trackers[-1]
 
 paul@0    913 
 
 paul@0    914 
        for item in nodes:
 
 paul@0    915 
            tracker.new_branchpoint()
 
 paul@0    916 
            tracker.new_branch()
 
 paul@0    917 
            fn(item)
 
 paul@0    918 
 
 paul@0    919 
        for item in nodes[:-1]:
 
 paul@0    920 
            tracker.shelve_branch()
 
 paul@0    921 
            tracker.new_branch()
 
 paul@0    922 
            tracker.shelve_branch()
 
 paul@0    923 
            tracker.merge_branches()
 
 paul@0    924 
 
 paul@0    925 
        tracker.shelve_branch()
 
 paul@0    926 
        tracker.merge_branches()
 
 paul@0    927 
 
 paul@0    928 
    def process_try_node(self, n):
 
 paul@0    929 
 
 paul@0    930 
        """
 
 paul@0    931 
        Process the given "try...except" node 'n'.
 
 paul@0    932 
        """
 
 paul@0    933 
 
 paul@479    934 
        self.record_exception_handler()
 
 paul@479    935 
 
 paul@0    936 
        tracker = self.trackers[-1]
 
 paul@0    937 
        tracker.new_branchpoint()
 
 paul@0    938 
 
 paul@0    939 
        self.process_structure_node(n.body)
 
 paul@0    940 
 
 paul@0    941 
        for name, var, handler in n.handlers:
 
 paul@0    942 
            if name is not None:
 
 paul@0    943 
                self.process_structure_node(name)
 
 paul@0    944 
 
 paul@0    945 
            # Any abandoned branches from the body can now be resumed in a new
 
 paul@0    946 
            # branch.
 
 paul@0    947 
 
 paul@0    948 
            tracker.resume_abandoned_branches()
 
 paul@0    949 
 
 paul@0    950 
            # Establish the local for the handler.
 
 paul@0    951 
 
 paul@0    952 
            if var is not None:
 
 paul@261    953 
                self.process_assignment_node(var, None)
 
 paul@0    954 
            if handler is not None:
 
 paul@0    955 
                self.process_structure_node(handler)
 
 paul@0    956 
 
 paul@0    957 
            tracker.shelve_branch()
 
 paul@0    958 
 
 paul@0    959 
        # The else clause maintains the usage from the body but without the
 
 paul@0    960 
        # abandoned branches since they would never lead to the else clause
 
 paul@0    961 
        # being executed.
 
 paul@0    962 
 
 paul@0    963 
        if n.else_:
 
 paul@0    964 
            tracker.new_branch()
 
 paul@0    965 
            self.process_structure_node(n.else_)
 
 paul@0    966 
            tracker.shelve_branch()
 
 paul@0    967 
 
 paul@0    968 
        # Without an else clause, a null branch propagates the successful
 
 paul@0    969 
        # outcome.
 
 paul@0    970 
 
 paul@0    971 
        else:
 
 paul@0    972 
            tracker.new_branch()
 
 paul@0    973 
            tracker.shelve_branch()
 
 paul@0    974 
 
 paul@0    975 
        tracker.merge_branches()
 
 paul@0    976 
 
 paul@0    977 
    def process_try_finally_node(self, n):
 
 paul@0    978 
 
 paul@0    979 
        """
 
 paul@0    980 
        Process the given "try...finally" node 'n'.
 
 paul@0    981 
        """
 
 paul@0    982 
 
 paul@479    983 
        self.record_exception_handler()
 
 paul@479    984 
 
 paul@0    985 
        tracker = self.trackers[-1]
 
 paul@0    986 
        self.process_structure_node(n.body)
 
 paul@0    987 
 
 paul@0    988 
        # Any abandoned branches from the body can now be resumed.
 
 paul@0    989 
 
 paul@0    990 
        branches = tracker.resume_all_abandoned_branches()
 
 paul@0    991 
        self.process_structure_node(n.final)
 
 paul@0    992 
 
 paul@0    993 
        # At the end of the finally clause, abandoned branches are discarded.
 
 paul@0    994 
 
 paul@0    995 
        tracker.restore_active_branches(branches)
 
 paul@0    996 
 
 paul@0    997 
    def process_while_node(self, n):
 
 paul@0    998 
 
 paul@0    999 
        "Process the given while node 'n'."
 
 paul@0   1000 
 
 paul@0   1001 
        tracker = self.trackers[-1]
 
 paul@0   1002 
        tracker.new_branchpoint(loop_node=True)
 
 paul@0   1003 
 
 paul@0   1004 
        # Evaluate any test or iterator outside the loop.
 
 paul@0   1005 
 
 paul@0   1006 
        self.process_structure_node(n.test)
 
 paul@0   1007 
 
 paul@0   1008 
        # Propagate attribute usage to branches.
 
 paul@0   1009 
 
 paul@0   1010 
        tracker.new_branch(loop_node=True)
 
 paul@0   1011 
 
 paul@0   1012 
        # Enter the loop.
 
 paul@0   1013 
 
 paul@0   1014 
        in_conditional = self.in_conditional
 
 paul@0   1015 
        self.in_conditional = True
 
 paul@0   1016 
        self.process_structure_node(n.body)
 
 paul@0   1017 
        self.in_conditional = in_conditional
 
 paul@0   1018 
 
 paul@0   1019 
        # Continuing branches are resumed before any test.
 
 paul@0   1020 
 
 paul@0   1021 
        tracker.resume_continuing_branches()
 
 paul@0   1022 
 
 paul@0   1023 
        # Evaluate any continuation test within the body.
 
 paul@0   1024 
 
 paul@0   1025 
        self.process_structure_node(n.test)
 
 paul@0   1026 
 
 paul@0   1027 
        tracker.shelve_branch(loop_node=True)
 
 paul@0   1028 
 
 paul@0   1029 
        # Support the non-looping condition.
 
 paul@0   1030 
 
 paul@0   1031 
        tracker.new_branch()
 
 paul@0   1032 
        tracker.shelve_branch()
 
 paul@0   1033 
 
 paul@0   1034 
        tracker.merge_branches()
 
 paul@0   1035 
 
 paul@0   1036 
        # Evaluate any else clause outside branches.
 
 paul@0   1037 
 
 paul@0   1038 
        if n.else_:
 
 paul@0   1039 
            self.process_structure_node(n.else_)
 
 paul@0   1040 
 
 paul@0   1041 
        # Connect broken branches to the code after any loop.
 
 paul@0   1042 
 
 paul@0   1043 
        tracker.resume_broken_branches()
 
 paul@0   1044 
 
 paul@0   1045 
    # Branch tracking methods.
 
 paul@0   1046 
 
 paul@0   1047 
    def start_tracking(self, names):
 
 paul@0   1048 
 
 paul@0   1049 
        """
 
 paul@0   1050 
        Start tracking attribute usage for names in the current namespace,
 
 paul@0   1051 
        immediately registering the given 'names'.
 
 paul@0   1052 
        """
 
 paul@0   1053 
 
 paul@0   1054 
        path = self.get_namespace_path()
 
 paul@0   1055 
        parent = self.trackers[-1]
 
 paul@0   1056 
        tracker = BranchTracker()
 
 paul@0   1057 
        self.trackers.append(tracker)
 
 paul@0   1058 
 
 paul@0   1059 
        # Record the given names established as new branches.
 
 paul@0   1060 
 
 paul@0   1061 
        tracker.assign_names(names)
 
 paul@0   1062 
 
 paul@0   1063 
    def assign_name(self, name, name_ref):
 
 paul@0   1064 
 
 paul@0   1065 
        "Assign to 'name' the given 'name_ref' in the current namespace."
 
 paul@0   1066 
 
 paul@0   1067 
        name = self.get_name_for_tracking(name)
 
 paul@0   1068 
        self.trackers[-1].assign_names([name], [name_ref])
 
 paul@0   1069 
 
 paul@0   1070 
    def stop_tracking(self):
 
 paul@0   1071 
 
 paul@0   1072 
        """
 
 paul@0   1073 
        Stop tracking attribute usage, recording computed usage for the current
 
 paul@0   1074 
        namespace.
 
 paul@0   1075 
        """
 
 paul@0   1076 
 
 paul@0   1077 
        path = self.get_namespace_path()
 
 paul@0   1078 
        tracker = self.trackers.pop()
 
 paul@0   1079 
        self.record_assignments_for_access(tracker)
 
 paul@0   1080 
 
 paul@0   1081 
        self.attr_usage[path] = tracker.get_all_usage()
 
 paul@0   1082 
        self.name_initialisers[path] = tracker.get_all_values()
 
 paul@0   1083 
 
 paul@0   1084 
    def start_tracking_in_module(self):
 
 paul@0   1085 
 
 paul@0   1086 
        "Start tracking attribute usage in the module."
 
 paul@0   1087 
 
 paul@0   1088 
        tracker = BranchTracker()
 
 paul@0   1089 
        self.trackers.append(tracker)
 
 paul@0   1090 
 
 paul@0   1091 
    def stop_tracking_in_module(self):
 
 paul@0   1092 
 
 paul@0   1093 
        "Stop tracking attribute usage in the module."
 
 paul@0   1094 
 
 paul@0   1095 
        tracker = self.trackers[0]
 
 paul@0   1096 
        self.record_assignments_for_access(tracker)
 
 paul@0   1097 
        self.attr_usage[self.name] = tracker.get_all_usage()
 
 paul@0   1098 
        self.name_initialisers[self.name] = tracker.get_all_values()
 
 paul@0   1099 
 
 paul@0   1100 
    def record_assignments_for_access(self, tracker):
 
 paul@0   1101 
 
 paul@0   1102 
        """
 
 paul@0   1103 
        For the current path, use the given 'tracker' to record assignment
 
 paul@0   1104 
        version information for attribute accesses.
 
 paul@0   1105 
        """
 
 paul@0   1106 
 
 paul@0   1107 
        path = self.get_path_for_access()
 
 paul@0   1108 
 
 paul@0   1109 
        if not self.attr_accessor_branches.has_key(path):
 
 paul@0   1110 
            return
 
 paul@0   1111 
 
 paul@0   1112 
        init_item(self.attr_accessors, path, dict)
 
 paul@0   1113 
        attr_accessors = self.attr_accessors[path]
 
 paul@0   1114 
 
 paul@0   1115 
        # Obtain the branches applying during each access.
 
 paul@0   1116 
 
 paul@0   1117 
        for access, all_branches in self.attr_accessor_branches[path].items():
 
 paul@0   1118 
            name, attrnames = access
 
 paul@0   1119 
            init_item(attr_accessors, access, list)
 
 paul@0   1120 
 
 paul@0   1121 
            # Obtain the assignments applying to each branch.
 
 paul@0   1122 
 
 paul@0   1123 
            for branches in all_branches:
 
 paul@0   1124 
                positions = tracker.get_assignment_positions_for_branches(name, branches)
 
 paul@0   1125 
 
 paul@0   1126 
                # Detect missing name information.
 
 paul@0   1127 
 
 paul@0   1128 
                if None in positions:
 
 paul@0   1129 
                    globals = self.global_attr_accesses.get(path)
 
 paul@0   1130 
                    accesses = globals and globals.get(name)
 
 paul@0   1131 
                    if not accesses:
 
 paul@0   1132 
                        print >>sys.stderr, "In %s, %s may not be defined when used." % (
 
 paul@0   1133 
                            self.get_namespace_path(), name)
 
 paul@0   1134 
                    positions.remove(None)
 
 paul@0   1135 
 
 paul@0   1136 
                attr_accessors[access].append(positions)
 
 paul@0   1137 
 
 paul@0   1138 
    def record_branches_for_access(self, branches, name, attrnames):
 
 paul@0   1139 
 
 paul@0   1140 
        """
 
 paul@0   1141 
        Record the given 'branches' for an access involving the given 'name' and
 
 paul@0   1142 
        'attrnames'.
 
 paul@0   1143 
        """
 
 paul@0   1144 
 
 paul@0   1145 
        access = name, attrnames
 
 paul@0   1146 
        path = self.get_path_for_access()
 
 paul@0   1147 
 
 paul@0   1148 
        init_item(self.attr_accessor_branches, path, dict)
 
 paul@0   1149 
        attr_accessor_branches = self.attr_accessor_branches[path]
 
 paul@0   1150 
 
 paul@0   1151 
        init_item(attr_accessor_branches, access, list)
 
 paul@0   1152 
        attr_accessor_branches[access].append(branches)
 
 paul@0   1153 
 
 paul@117   1154 
    def record_access_details(self, name, attrnames, assignment, invocation):
 
 paul@0   1155 
 
 paul@0   1156 
        """
 
 paul@0   1157 
        For the given 'name' and 'attrnames', record an access indicating
 
 paul@553   1158 
        whether an 'assignment' or an 'invocation' is occurring.
 
 paul@0   1159 
 
 paul@0   1160 
        These details correspond to accesses otherwise recorded by the attribute
 
 paul@0   1161 
        accessor and attribute access dictionaries.
 
 paul@0   1162 
        """
 
 paul@0   1163 
 
 paul@0   1164 
        access = name, attrnames
 
 paul@0   1165 
        path = self.get_path_for_access()
 
 paul@0   1166 
 
 paul@0   1167 
        init_item(self.attr_access_modifiers, path, dict)
 
 paul@0   1168 
        init_item(self.attr_access_modifiers[path], access, list)
 
 paul@0   1169 
 
 paul@0   1170 
        access_number = len(self.attr_access_modifiers[path][access])
 
 paul@117   1171 
        self.attr_access_modifiers[path][access].append((assignment, invocation))
 
 paul@0   1172 
        return access_number
 
 paul@0   1173 
 
 paul@0   1174 
    def record_global_access_details(self, name, attrnames):
 
 paul@0   1175 
 
 paul@0   1176 
        """
 
 paul@0   1177 
        Record details of a global access via the given 'name' involving the
 
 paul@0   1178 
        indicated 'attrnames'.
 
 paul@0   1179 
        """
 
 paul@0   1180 
 
 paul@0   1181 
        path = self.get_namespace_path()
 
 paul@0   1182 
 
 paul@0   1183 
        init_item(self.global_attr_accesses, path, dict)
 
 paul@0   1184 
        init_item(self.global_attr_accesses[path], name, set)
 
 paul@0   1185 
        self.global_attr_accesses[path][name].add(attrnames)
 
 paul@0   1186 
 
 paul@0   1187 
    # Namespace modification.
 
 paul@0   1188 
 
 paul@0   1189 
    def record_name(self, name):
 
 paul@0   1190 
 
 paul@0   1191 
        "Record the use of 'name' in a namespace."
 
 paul@0   1192 
 
 paul@0   1193 
        path = self.get_namespace_path()
 
 paul@0   1194 
        init_item(self.names_used, path, set)
 
 paul@0   1195 
        self.names_used[path].add(name)
 
 paul@0   1196 
 
 paul@12   1197 
    def set_module(self, name, module_name):
 
 paul@0   1198 
 
 paul@0   1199 
        """
 
 paul@12   1200 
        Set a module in the current namespace using the given 'name' associated
 
 paul@12   1201 
        with the corresponding 'module_name'.
 
 paul@0   1202 
        """
 
 paul@0   1203 
 
 paul@0   1204 
        if name:
 
 paul@12   1205 
            self.set_general_local(name, Reference("<module>", module_name))
 
 paul@0   1206 
 
 paul@0   1207 
    def set_definition(self, name, kind):
 
 paul@0   1208 
 
 paul@0   1209 
        """
 
 paul@0   1210 
        Set the definition having the given 'name' and 'kind'.
 
 paul@0   1211 
 
 paul@0   1212 
        Definitions are set in the static namespace hierarchy, but they can also
 
 paul@0   1213 
        be recorded for function locals.
 
 paul@0   1214 
        """
 
 paul@0   1215 
 
 paul@0   1216 
        if self.is_global(name):
 
 paul@0   1217 
            print >>sys.stderr, "In %s, %s is defined as being global." % (
 
 paul@0   1218 
                self.get_namespace_path(), name)
 
 paul@0   1219 
 
 paul@0   1220 
        path = self.get_object_path(name)
 
 paul@0   1221 
        self.set_object(path, kind)
 
 paul@0   1222 
 
 paul@0   1223 
        ref = self.get_object(path)
 
 paul@0   1224 
        if ref.get_kind() == "<var>":
 
 paul@0   1225 
            print >>sys.stderr, "In %s, %s is defined more than once." % (
 
 paul@0   1226 
                self.get_namespace_path(), name)
 
 paul@0   1227 
 
 paul@0   1228 
        if not self.is_global(name) and self.in_function:
 
 paul@0   1229 
            self.set_function_local(name, ref)
 
 paul@0   1230 
 
 paul@0   1231 
    def set_function_local(self, name, ref=None):
 
 paul@0   1232 
 
 paul@0   1233 
        "Set the local with the given 'name' and optional 'ref'."
 
 paul@0   1234 
 
 paul@0   1235 
        locals = self.function_locals[self.get_namespace_path()]
 
 paul@0   1236 
        multiple = not ref or locals.has_key(name) and locals[name] != ref
 
 paul@0   1237 
        locals[name] = multiple and Reference("<var>") or ref
 
 paul@0   1238 
 
 paul@0   1239 
    def assign_general_local(self, name, name_ref):
 
 paul@0   1240 
 
 paul@0   1241 
        """
 
 paul@0   1242 
        Set for 'name' the given 'name_ref', recording the name for attribute
 
 paul@0   1243 
        usage tracking.
 
 paul@0   1244 
        """
 
 paul@0   1245 
 
 paul@0   1246 
        self.set_general_local(name, name_ref)
 
 paul@0   1247 
        self.assign_name(name, name_ref)
 
 paul@0   1248 
 
 paul@0   1249 
    def set_general_local(self, name, value=None):
 
 paul@0   1250 
 
 paul@0   1251 
        """
 
 paul@0   1252 
        Set the 'name' with optional 'value' in any kind of local namespace,
 
 paul@0   1253 
        where the 'value' should be a reference if specified.
 
 paul@0   1254 
        """
 
 paul@0   1255 
 
 paul@0   1256 
        init_value = self.get_initialising_value(value)
 
 paul@0   1257 
 
 paul@0   1258 
        # Module global names.
 
 paul@0   1259 
 
 paul@0   1260 
        if self.is_global(name):
 
 paul@0   1261 
            path = self.get_global_path(name)
 
 paul@0   1262 
            self.set_object(path, init_value)
 
 paul@0   1263 
 
 paul@0   1264 
        # Function local names.
 
 paul@0   1265 
 
 paul@0   1266 
        elif self.in_function:
 
 paul@0   1267 
            path = self.get_object_path(name)
 
 paul@0   1268 
            self.set_function_local(name, init_value)
 
 paul@0   1269 
 
 paul@0   1270 
        # Other namespaces (classes).
 
 paul@0   1271 
 
 paul@0   1272 
        else:
 
 paul@0   1273 
            path = self.get_object_path(name)
 
 paul@0   1274 
            self.set_name(name, init_value)
 
 paul@0   1275 
 
 paul@0   1276 
    def set_name(self, name, ref=None):
 
 paul@0   1277 
 
 paul@0   1278 
        "Attach the 'name' with optional 'ref' to the current namespace."
 
 paul@0   1279 
 
 paul@0   1280 
        self.set_object(self.get_object_path(name), ref)
 
 paul@0   1281 
 
 paul@0   1282 
    def set_instance_attr(self, name, ref=None):
 
 paul@0   1283 
 
 paul@0   1284 
        """
 
 paul@0   1285 
        Add an instance attribute of the given 'name' to the current class,
 
 paul@0   1286 
        using the optional 'ref'.
 
 paul@0   1287 
        """
 
 paul@0   1288 
 
 paul@251   1289 
        self._set_instance_attr(self.in_class, name, ref)
 
 paul@251   1290 
 
 paul@251   1291 
    def _set_instance_attr(self, path, name, ref=None):
 
 paul@251   1292 
 
 paul@251   1293 
        init_item(self.instance_attrs, path, set)
 
 paul@251   1294 
        self.instance_attrs[path].add(name)
 
 paul@0   1295 
 
 paul@0   1296 
        if ref:
 
 paul@251   1297 
            init_item(self.instance_attr_constants, path, dict)
 
 paul@251   1298 
            self.instance_attr_constants[path][name] = ref
 
 paul@0   1299 
 
 paul@0   1300 
    def get_initialising_value(self, value):
 
 paul@0   1301 
 
 paul@0   1302 
        "Return a suitable initialiser reference for 'value'."
 
 paul@0   1303 
 
 paul@25   1304 
        # Includes LiteralSequenceRef, ResolvedNameRef...
 
 paul@25   1305 
 
 paul@25   1306 
        if isinstance(value, (NameRef, AccessRef, InstanceRef)):
 
 paul@0   1307 
            return value.reference()
 
 paul@0   1308 
 
 paul@0   1309 
        # In general, invocations do not produce known results. However, the
 
 paul@0   1310 
        # name initialisers are resolved once a module has been inspected.
 
 paul@0   1311 
 
 paul@0   1312 
        elif isinstance(value, InvocationRef):
 
 paul@27   1313 
            return value.reference()
 
 paul@0   1314 
 
 paul@229   1315 
        # Variable references are unknown results.
 
 paul@229   1316 
 
 paul@229   1317 
        elif isinstance(value, VariableRef):
 
 paul@229   1318 
            return value.reference()
 
 paul@229   1319 
 
 paul@0   1320 
        else:
 
 paul@0   1321 
            return value
 
 paul@0   1322 
 
 paul@0   1323 
    # Static, program-relative naming.
 
 paul@0   1324 
 
 paul@0   1325 
    def find_name(self, name):
 
 paul@0   1326 
 
 paul@0   1327 
        """
 
 paul@0   1328 
        Return the qualified name for the given 'name' used in the current
 
 paul@0   1329 
        non-function namespace.
 
 paul@0   1330 
        """
 
 paul@0   1331 
 
 paul@0   1332 
        path = self.get_namespace_path()
 
 paul@0   1333 
        ref = None
 
 paul@0   1334 
 
 paul@0   1335 
        if not self.in_function and name not in predefined_constants:
 
 paul@0   1336 
            if self.in_class:
 
 paul@152   1337 
                ref = self.get_object(self.get_object_path(name), False)
 
 paul@0   1338 
            if not ref:
 
 paul@0   1339 
                ref = self.get_global_or_builtin(name)
 
 paul@0   1340 
 
 paul@0   1341 
        return ref
 
 paul@0   1342 
 
 paul@0   1343 
    def get_class(self, node):
 
 paul@0   1344 
 
 paul@0   1345 
        """
 
 paul@0   1346 
        Use the given 'node' to obtain the identity of a class. Return a
 
 paul@0   1347 
        reference for the class. Unresolved dependencies are permitted and must
 
 paul@0   1348 
        be resolved later.
 
 paul@0   1349 
        """
 
 paul@0   1350 
 
 paul@0   1351 
        ref = self._get_class(node)
 
 paul@0   1352 
        return ref.has_kind(["<class>", "<depends>"]) and ref or None
 
 paul@0   1353 
 
 paul@0   1354 
    def _get_class(self, node):
 
 paul@0   1355 
 
 paul@0   1356 
        """
 
 paul@0   1357 
        Use the given 'node' to find a class definition. Return a reference to
 
 paul@0   1358 
        the class.
 
 paul@0   1359 
        """
 
 paul@0   1360 
 
 paul@0   1361 
        if isinstance(node, compiler.ast.Getattr):
 
 paul@0   1362 
 
 paul@0   1363 
            # Obtain the identity of the access target.
 
 paul@0   1364 
 
 paul@0   1365 
            ref = self._get_class(node.expr)
 
 paul@0   1366 
 
 paul@0   1367 
            # Where the target is a class or module, obtain the identity of the
 
 paul@0   1368 
            # attribute.
 
 paul@0   1369 
 
 paul@0   1370 
            if ref.has_kind(["<function>", "<var>"]):
 
 paul@0   1371 
                return None
 
 paul@0   1372 
            else:
 
 paul@0   1373 
                attrname = "%s.%s" % (ref.get_origin(), node.attrname)
 
 paul@0   1374 
                return self.get_object(attrname)
 
 paul@0   1375 
 
 paul@0   1376 
        # Names can be module-level or built-in.
 
 paul@0   1377 
 
 paul@0   1378 
        elif isinstance(node, compiler.ast.Name):
 
 paul@0   1379 
 
 paul@0   1380 
            # Record usage of the name and attempt to identify it.
 
 paul@0   1381 
 
 paul@0   1382 
            self.record_name(node.name)
 
 paul@73   1383 
            return self.find_name(node.name)
 
 paul@0   1384 
        else:
 
 paul@0   1385 
            return None
 
 paul@0   1386 
 
 paul@0   1387 
    def get_constant(self, name, value):
 
 paul@0   1388 
 
 paul@0   1389 
        "Return a constant reference for the given type 'name' and 'value'."
 
 paul@0   1390 
 
 paul@12   1391 
        ref = self.get_builtin_class(name)
 
 paul@0   1392 
        return self.get_constant_reference(ref, value)
 
 paul@0   1393 
 
 paul@405   1394 
    def get_literal_instance(self, n, name=None):
 
 paul@0   1395 
 
 paul@405   1396 
        """
 
 paul@405   1397 
        For node 'n', return a reference to an instance of 'name', or if 'name'
 
 paul@405   1398 
        is not specified, deduce the type from the value.
 
 paul@405   1399 
        """
 
 paul@0   1400 
 
 paul@366   1401 
        # Handle stray None constants (Sliceobj seems to produce them).
 
 paul@366   1402 
 
 paul@366   1403 
        if name == "NoneType":
 
 paul@366   1404 
            return self.process_name_node(compiler.ast.Name("None"))
 
 paul@366   1405 
 
 paul@0   1406 
        # Obtain the details of the literal itself.
 
 paul@0   1407 
        # An alias to the type is generated for sequences.
 
 paul@0   1408 
 
 paul@0   1409 
        if name in ("dict", "list", "tuple"):
 
 paul@405   1410 
            ref = self.get_builtin_class(name)
 
 paul@0   1411 
            self.set_special_literal(name, ref)
 
 paul@0   1412 
            return self.process_literal_sequence_node(n, name, ref, LiteralSequenceRef)
 
 paul@0   1413 
 
 paul@0   1414 
        # Constant values are independently recorded.
 
 paul@0   1415 
 
 paul@0   1416 
        else:
 
 paul@537   1417 
            value, typename, encoding = self.get_constant_value(n.value, n.literals)
 
 paul@538   1418 
            ref = self.get_builtin_class(typename)
 
 paul@406   1419 
            return self.get_constant_reference(ref, value, encoding)
 
 paul@0   1420 
 
 paul@17   1421 
    # Special names.
 
 paul@0   1422 
 
 paul@17   1423 
    def get_special(self, name):
 
 paul@0   1424 
 
 paul@17   1425 
        "Return any stored value for the given special 'name'."
 
 paul@0   1426 
 
 paul@423   1427 
        value = self.special.get(name)
 
 paul@423   1428 
        if value:
 
 paul@423   1429 
            ref, paths = value
 
 paul@423   1430 
        else:
 
 paul@423   1431 
            ref = None
 
 paul@423   1432 
        return ref
 
 paul@17   1433 
 
 paul@17   1434 
    def set_special(self, name, value):
 
 paul@0   1435 
 
 paul@17   1436 
        """
 
 paul@17   1437 
        Set a special 'name' that merely tracks the use of an implicit object
 
 paul@17   1438 
        'value'.
 
 paul@17   1439 
        """
 
 paul@0   1440 
 
 paul@423   1441 
        if not self.special.has_key(name):
 
 paul@423   1442 
            paths = set()
 
 paul@423   1443 
            self.special[name] = value, paths
 
 paul@423   1444 
        else:
 
 paul@423   1445 
            _ref, paths = self.special[name]
 
 paul@423   1446 
 
 paul@423   1447 
        paths.add(self.get_namespace_path())
 
 paul@17   1448 
 
 paul@17   1449 
    def set_special_literal(self, name, ref):
 
 paul@0   1450 
 
 paul@17   1451 
        """
 
 paul@17   1452 
        Set a special name for the literal type 'name' having type 'ref'. Such
 
 paul@17   1453 
        special names provide a way of referring to literal object types.
 
 paul@17   1454 
        """
 
 paul@0   1455 
 
 paul@17   1456 
        literal_name = "$L%s" % name
 
 paul@17   1457 
        value = ResolvedNameRef(literal_name, ref)
 
 paul@17   1458 
        self.set_special(literal_name, value)
 
 paul@0   1459 
 
 paul@0   1460 
    # Functions and invocations.
 
 paul@0   1461 
 
 paul@36   1462 
    def set_invocation_usage(self):
 
 paul@36   1463 
 
 paul@36   1464 
        """
 
 paul@36   1465 
        Discard the current invocation storage figures, retaining the maximum
 
 paul@36   1466 
        values.
 
 paul@36   1467 
        """
 
 paul@36   1468 
 
 paul@36   1469 
        for path, (current, maximum) in self.function_targets.items():
 
 paul@36   1470 
            self.importer.function_targets[path] = self.function_targets[path] = maximum
 
 paul@36   1471 
 
 paul@36   1472 
        for path, (current, maximum) in self.function_arguments.items():
 
 paul@36   1473 
            self.importer.function_arguments[path] = self.function_arguments[path] = maximum
 
 paul@36   1474 
 
 paul@0   1475 
    def allocate_arguments(self, path, args):
 
 paul@0   1476 
 
 paul@0   1477 
        """
 
 paul@0   1478 
        Allocate temporary argument storage using current and maximum
 
 paul@0   1479 
        requirements for the given 'path' and 'args'.
 
 paul@0   1480 
        """
 
 paul@0   1481 
 
 paul@192   1482 
        # Class and module initialisation is ultimately combined.
 
 paul@192   1483 
 
 paul@192   1484 
        if not self.in_function:
 
 paul@192   1485 
            path = self.name
 
 paul@192   1486 
 
 paul@0   1487 
        init_item(self.function_targets, path, lambda: [0, 0])
 
 paul@0   1488 
        t = self.function_targets[path]
 
 paul@0   1489 
        t[0] += 1
 
 paul@0   1490 
        t[1] = max(t[0], t[1])
 
 paul@0   1491 
 
 paul@0   1492 
        init_item(self.function_arguments, path, lambda: [0, 0])
 
 paul@0   1493 
        t = self.function_arguments[path]
 
 paul@0   1494 
        t[0] += len(args) + 1
 
 paul@0   1495 
        t[1] = max(t[0], t[1])
 
 paul@0   1496 
 
 paul@0   1497 
    def deallocate_arguments(self, path, args):
 
 paul@0   1498 
 
 paul@0   1499 
        "Deallocate temporary argument storage for the given 'path' and 'args'."
 
 paul@0   1500 
 
 paul@192   1501 
        # Class and module initialisation is ultimately combined.
 
 paul@192   1502 
 
 paul@192   1503 
        if not self.in_function:
 
 paul@192   1504 
            path = self.name
 
 paul@192   1505 
 
 paul@0   1506 
        self.function_targets[path][0] -= 1
 
 paul@0   1507 
        self.function_arguments[path][0] -= len(args) + 1
 
 paul@0   1508 
 
 paul@479   1509 
    # Exceptions.
 
 paul@479   1510 
 
 paul@479   1511 
    def record_exception_handler(self):
 
 paul@479   1512 
 
 paul@479   1513 
        "Record the current namespace as employing an exception handler."
 
 paul@479   1514 
 
 paul@479   1515 
        self.exception_namespaces.add(self.get_namespace_path())
 
 paul@479   1516 
 
 paul@0   1517 
# vim: tabstop=4 expandtab shiftwidth=4