Lichen

Annotated translator.py

320:0867d8924ed9
318:feefdbfb5934
317:9f7a9aff1ca4
2016-12-05 Paul Boddie file changeset files shortlog Encode type attributes explicitly, avoiding identification issues when classes are defined in locations that are reused for other objects.
paul@113 1 
#!/usr/bin/env python
paul@113 2 
 
 paul@113      3 
"""
 
 paul@113      4 
Translate programs.
 
 paul@113      5 
 
 paul@113      6 
Copyright (C) 2015, 2016 Paul Boddie <paul@boddie.org.uk>
 
 paul@113      7 
 
 paul@113      8 
This program is free software; you can redistribute it and/or modify it under
 
 paul@113      9 
the terms of the GNU General Public License as published by the Free Software
 
 paul@113     10 
Foundation; either version 3 of the License, or (at your option) any later
 
 paul@113     11 
version.
 
 paul@113     12 
 
 paul@113     13 
This program is distributed in the hope that it will be useful, but WITHOUT
 
 paul@113     14 
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
 
 paul@113     15 
FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
 
 paul@113     16 
details.
 
 paul@113     17 
 
 paul@113     18 
You should have received a copy of the GNU General Public License along with
 
 paul@113     19 
this program.  If not, see <http://www.gnu.org/licenses/>.
 
 paul@113     20 
"""
 
 paul@113     21 
 
 paul@113     22 
from common import *
 
 paul@113     23 
from encoders import *
 
 paul@113     24 
from os.path import exists, join
 
 paul@113     25 
from os import makedirs
 
 paul@314     26 
from referencing import Reference
 
 paul@113     27 
import compiler
 
 paul@113     28 
import results
 
 paul@113     29 
 
 paul@113     30 
class Translator(CommonOutput):
 
 paul@113     31 
 
 paul@113     32 
    "A program translator."
 
 paul@113     33 
 
 paul@113     34 
    def __init__(self, importer, deducer, optimiser, output):
 
 paul@113     35 
        self.importer = importer
 
 paul@113     36 
        self.deducer = deducer
 
 paul@113     37 
        self.optimiser = optimiser
 
 paul@113     38 
        self.output = output
 
 paul@113     39 
 
 paul@113     40 
    def to_output(self):
 
 paul@113     41 
        output = join(self.output, "src")
 
 paul@113     42 
 
 paul@113     43 
        if not exists(output):
 
 paul@113     44 
            makedirs(output)
 
 paul@113     45 
 
 paul@113     46 
        self.check_output()
 
 paul@113     47 
 
 paul@113     48 
        for module in self.importer.modules.values():
 
 paul@161     49 
            if module.name != "native":
 
 paul@161     50 
                tm = TranslatedModule(module.name, self.importer, self.deducer, self.optimiser)
 
 paul@161     51 
                tm.translate(module.filename, join(output, "%s.c" % module.name))
 
 paul@113     52 
 
 paul@113     53 
# Classes representing intermediate translation results.
 
 paul@113     54 
 
 paul@113     55 
class TranslationResult:
 
 paul@113     56 
 
 paul@113     57 
    "An abstract translation result mix-in."
 
 paul@113     58 
 
 paul@234     59 
    def get_accessor_kinds(self):
 
 paul@234     60 
        return None
 
 paul@113     61 
 
 paul@144     62 
class ReturnRef(TranslationResult):
 
 paul@144     63 
 
 paul@144     64 
    "Indicates usage of a return statement."
 
 paul@144     65 
 
 paul@144     66 
    pass
 
 paul@144     67 
 
 paul@113     68 
class Expression(results.Result, TranslationResult):
 
 paul@113     69 
 
 paul@113     70 
    "A general expression."
 
 paul@113     71 
 
 paul@113     72 
    def __init__(self, s):
 
 paul@113     73 
        self.s = s
 
 paul@113     74 
    def __str__(self):
 
 paul@113     75 
        return self.s
 
 paul@113     76 
    def __repr__(self):
 
 paul@113     77 
        return "Expression(%r)" % self.s
 
 paul@113     78 
 
 paul@113     79 
class TrResolvedNameRef(results.ResolvedNameRef, TranslationResult):
 
 paul@113     80 
 
 paul@113     81 
    "A reference to a name in the translation."
 
 paul@113     82 
 
 paul@208     83 
    def __init__(self, name, ref, expr=None, parameter=None):
 
 paul@208     84 
        results.ResolvedNameRef.__init__(self, name, ref, expr)
 
 paul@208     85 
        self.parameter = parameter
 
 paul@208     86 
 
 paul@113     87 
    def __str__(self):
 
 paul@113     88 
 
 paul@113     89 
        "Return an output representation of the referenced name."
 
 paul@113     90 
 
 paul@113     91 
        # For sources, any identified static origin will be constant and thus
 
 paul@113     92 
        # usable directly. For targets, no constant should be assigned and thus
 
 paul@113     93 
        # the alias (or any plain name) will be used.
 
 paul@113     94 
 
 paul@137     95 
        ref = self.static()
 
 paul@137     96 
        origin = ref and self.get_origin()
 
 paul@137     97 
        static_name = origin and encode_path(origin)
 
 paul@149     98 
 
 paul@149     99 
        # Determine whether a qualified name is involved.
 
 paul@149    100 
 
 paul@152    101 
        t = (self.get_name() or self.name).rsplit(".", 1)
 
 paul@149    102 
        parent = len(t) > 1 and t[0] or None
 
 paul@149    103 
        attrname = encode_path(t[-1])
 
 paul@113    104 
 
 paul@113    105 
        # Assignments.
 
 paul@113    106 
 
 paul@113    107 
        if self.expr:
 
 paul@113    108 
 
 paul@113    109 
            # Eliminate assignments between constants.
 
 paul@113    110 
 
 paul@196    111 
            if ref and isinstance(self.expr, results.ResolvedNameRef) and self.expr.static():
 
 paul@113    112 
                return ""
 
 paul@149    113 
 
 paul@149    114 
            # Qualified names must be converted into parent-relative assignments.
 
 paul@149    115 
 
 paul@149    116 
            elif parent:
 
 paul@149    117 
                return "__store_via_object(&%s, %s, %s)" % (
 
 paul@149    118 
                    encode_path(parent), encode_symbol("pos", attrname), self.expr)
 
 paul@149    119 
 
 paul@149    120 
            # All other assignments involve the names as they were given.
 
 paul@149    121 
 
 paul@113    122 
            else:
 
 paul@208    123 
                return "(%s%s) = %s" % (self.parameter and "*" or "", attrname, self.expr)
 
 paul@113    124 
 
 paul@113    125 
        # Expressions.
 
 paul@113    126 
 
 paul@137    127 
        elif static_name:
 
 paul@137    128 
            parent = ref.parent()
 
 paul@141    129 
            context = ref.has_kind("<function>") and encode_path(parent) or None
 
 paul@144    130 
            return "((__attr) {%s, &%s})" % (context and "&%s" % context or "0", static_name)
 
 paul@137    131 
 
 paul@152    132 
        # Qualified names must be converted into parent-relative accesses.
 
 paul@152    133 
 
 paul@152    134 
        elif parent:
 
 paul@152    135 
            return "__load_via_object(&%s, %s)" % (
 
 paul@152    136 
                encode_path(parent), encode_symbol("pos", attrname))
 
 paul@152    137 
 
 paul@152    138 
        # All other accesses involve the names as they were given.
 
 paul@152    139 
 
 paul@113    140 
        else:
 
 paul@208    141 
            return "(%s%s)" % (self.parameter and "*" or "", attrname)
 
 paul@113    142 
 
 paul@113    143 
class TrConstantValueRef(results.ConstantValueRef, TranslationResult):
 
 paul@113    144 
 
 paul@113    145 
    "A constant value reference in the translation."
 
 paul@113    146 
 
 paul@113    147 
    def __str__(self):
 
 paul@136    148 
        return encode_literal_constant(self.number)
 
 paul@113    149 
 
 paul@113    150 
class TrLiteralSequenceRef(results.LiteralSequenceRef, TranslationResult):
 
 paul@113    151 
 
 paul@113    152 
    "A reference representing a sequence of values."
 
 paul@113    153 
 
 paul@113    154 
    def __str__(self):
 
 paul@113    155 
        return str(self.node)
 
 paul@113    156 
 
 paul@317    157 
class TrInstanceRef(results.InstanceRef, TranslationResult):
 
 paul@317    158 
 
 paul@317    159 
    "A reference representing instantiation of a class."
 
 paul@317    160 
 
 paul@317    161 
    def __init__(self, ref, expr):
 
 paul@317    162 
 
 paul@317    163 
        """
 
 paul@317    164 
        Initialise the reference with 'ref' indicating the nature of the
 
 paul@317    165 
        reference and 'expr' being an expression used to create the instance.
 
 paul@317    166 
        """
 
 paul@317    167 
 
 paul@317    168 
        results.InstanceRef.__init__(self, ref)
 
 paul@317    169 
        self.expr = expr
 
 paul@317    170 
 
 paul@317    171 
    def __str__(self):
 
 paul@317    172 
        return self.expr
 
 paul@317    173 
 
 paul@317    174 
    def __repr__(self):
 
 paul@317    175 
        return "TrResolvedInstanceRef(%r, %r)" % (self.ref, self.expr)
 
 paul@317    176 
 
 paul@113    177 
class AttrResult(Expression, TranslationResult):
 
 paul@113    178 
 
 paul@113    179 
    "A translation result for an attribute access."
 
 paul@113    180 
 
 paul@234    181 
    def __init__(self, s, refs, accessor_kinds):
 
 paul@113    182 
        Expression.__init__(self, s)
 
 paul@113    183 
        self.refs = refs
 
 paul@234    184 
        self.accessor_kinds = accessor_kinds
 
 paul@113    185 
 
 paul@113    186 
    def get_origin(self):
 
 paul@113    187 
        return self.refs and len(self.refs) == 1 and first(self.refs).get_origin()
 
 paul@113    188 
 
 paul@118    189 
    def has_kind(self, kinds):
 
 paul@118    190 
        if not self.refs:
 
 paul@118    191 
            return False
 
 paul@118    192 
        for ref in self.refs:
 
 paul@118    193 
            if ref.has_kind(kinds):
 
 paul@118    194 
                return True
 
 paul@118    195 
        return False
 
 paul@118    196 
 
 paul@234    197 
    def get_accessor_kinds(self):
 
 paul@234    198 
        return self.accessor_kinds
 
 paul@234    199 
 
 paul@113    200 
    def __repr__(self):
 
 paul@136    201 
        return "AttrResult(%r, %r)" % (self.s, self.get_origin())
 
 paul@113    202 
 
 paul@113    203 
class PredefinedConstantRef(AttrResult):
 
 paul@113    204 
 
 paul@113    205 
    "A predefined constant reference."
 
 paul@113    206 
 
 paul@113    207 
    def __init__(self, value):
 
 paul@113    208 
        self.value = value
 
 paul@113    209 
 
 paul@113    210 
    def __str__(self):
 
 paul@136    211 
        if self.value in ("False", "True"):
 
 paul@158    212 
            return encode_path("__builtins__.boolean.%s" % self.value)
 
 paul@136    213 
        elif self.value == "None":
 
 paul@136    214 
            return encode_path("__builtins__.none.%s" % self.value)
 
 paul@136    215 
        elif self.value == "NotImplemented":
 
 paul@136    216 
            return encode_path("__builtins__.notimplemented.%s" % self.value)
 
 paul@136    217 
        else:
 
 paul@136    218 
            return self.value
 
 paul@113    219 
 
 paul@113    220 
    def __repr__(self):
 
 paul@113    221 
        return "PredefinedConstantRef(%r)" % self.value
 
 paul@113    222 
 
 paul@141    223 
class BooleanResult(Expression, TranslationResult):
 
 paul@141    224 
 
 paul@141    225 
    "A expression producing a boolean result."
 
 paul@141    226 
 
 paul@141    227 
    def __str__(self):
 
 paul@141    228 
        return "__builtins___bool_bool(%s)" % self.s
 
 paul@141    229 
 
 paul@141    230 
    def __repr__(self):
 
 paul@141    231 
        return "BooleanResult(%r)" % self.s
 
 paul@141    232 
 
 paul@113    233 
def make_expression(expr):
 
 paul@113    234 
 
 paul@113    235 
    "Make a new expression from the existing 'expr'."
 
 paul@113    236 
 
 paul@113    237 
    if isinstance(expr, results.Result):
 
 paul@113    238 
        return expr
 
 paul@113    239 
    else:
 
 paul@113    240 
        return Expression(str(expr))
 
 paul@113    241 
 
 paul@113    242 
# The actual translation process itself.
 
 paul@113    243 
 
 paul@113    244 
class TranslatedModule(CommonModule):
 
 paul@113    245 
 
 paul@113    246 
    "A module translator."
 
 paul@113    247 
 
 paul@113    248 
    def __init__(self, name, importer, deducer, optimiser):
 
 paul@113    249 
        CommonModule.__init__(self, name, importer)
 
 paul@113    250 
        self.deducer = deducer
 
 paul@113    251 
        self.optimiser = optimiser
 
 paul@113    252 
 
 paul@113    253 
        # Output stream.
 
 paul@113    254 
 
 paul@113    255 
        self.out = None
 
 paul@113    256 
        self.indent = 0
 
 paul@113    257 
        self.tabstop = "    "
 
 paul@113    258 
 
 paul@113    259 
        # Recorded namespaces.
 
 paul@113    260 
 
 paul@113    261 
        self.namespaces = []
 
 paul@113    262 
        self.in_conditional = False
 
 paul@113    263 
 
 paul@144    264 
        # Exception raising adjustments.
 
 paul@144    265 
 
 paul@144    266 
        self.in_try_finally = False
 
 paul@189    267 
        self.in_try_except = False
 
 paul@144    268 
 
 paul@237    269 
        # Attribute access and accessor counting.
 
 paul@113    270 
 
 paul@113    271 
        self.attr_accesses = {}
 
 paul@237    272 
        self.attr_accessors = {}
 
 paul@113    273 
 
 paul@113    274 
    def __repr__(self):
 
 paul@113    275 
        return "TranslatedModule(%r, %r)" % (self.name, self.importer)
 
 paul@113    276 
 
 paul@113    277 
    def translate(self, filename, output_filename):
 
 paul@113    278 
 
 paul@113    279 
        """
 
 paul@113    280 
        Parse the file having the given 'filename', writing the translation to
 
 paul@113    281 
        the given 'output_filename'.
 
 paul@113    282 
        """
 
 paul@113    283 
 
 paul@113    284 
        self.parse_file(filename)
 
 paul@113    285 
 
 paul@113    286 
        # Collect function namespaces for separate processing.
 
 paul@113    287 
 
 paul@113    288 
        self.record_namespaces(self.astnode)
 
 paul@113    289 
 
 paul@113    290 
        # Reset the lambda naming (in order to obtain the same names again) and
 
 paul@113    291 
        # translate the program.
 
 paul@113    292 
 
 paul@113    293 
        self.reset_lambdas()
 
 paul@113    294 
 
 paul@113    295 
        self.out = open(output_filename, "w")
 
 paul@113    296 
        try:
 
 paul@128    297 
            self.start_output()
 
 paul@128    298 
 
 paul@113    299 
            # Process namespaces, writing the translation.
 
 paul@113    300 
 
 paul@113    301 
            for path, node in self.namespaces:
 
 paul@113    302 
                self.process_namespace(path, node)
 
 paul@113    303 
 
 paul@113    304 
            # Process the module namespace including class namespaces.
 
 paul@113    305 
 
 paul@113    306 
            self.process_namespace([], self.astnode)
 
 paul@113    307 
 
 paul@113    308 
        finally:
 
 paul@113    309 
            self.out.close()
 
 paul@113    310 
 
 paul@113    311 
    def have_object(self):
 
 paul@113    312 
 
 paul@113    313 
        "Return whether a namespace is a recorded object."
 
 paul@113    314 
 
 paul@113    315 
        return self.importer.objects.get(self.get_namespace_path())
 
 paul@113    316 
 
 paul@156    317 
    def get_builtin_class(self, name):
 
 paul@156    318 
 
 paul@156    319 
        "Return a reference to the actual object providing 'name'."
 
 paul@156    320 
 
 paul@156    321 
        # NOTE: This makes assumptions about the __builtins__ structure.
 
 paul@113    322 
 
 paul@158    323 
        return self.importer.get_object("__builtins__.%s.%s" % (name, name))
 
 paul@156    324 
 
 paul@156    325 
    def is_method(self, path):
 
 paul@156    326 
 
 paul@156    327 
        "Return whether 'path' is a method."
 
 paul@156    328 
 
 paul@113    329 
        class_name, method_name = path.rsplit(".", 1)
 
 paul@267    330 
        return self.importer.classes.has_key(class_name) and class_name or None
 
 paul@113    331 
 
 paul@208    332 
    def in_method(self):
 
 paul@208    333 
 
 paul@208    334 
        "Return whether the current namespace provides a method."
 
 paul@208    335 
 
 paul@208    336 
        return self.in_function and self.is_method(self.get_namespace_path())
 
 paul@208    337 
 
 paul@113    338 
    # Namespace recording.
 
 paul@113    339 
 
 paul@113    340 
    def record_namespaces(self, node):
 
 paul@113    341 
 
 paul@113    342 
        "Process the program structure 'node', recording namespaces."
 
 paul@113    343 
 
 paul@113    344 
        for n in node.getChildNodes():
 
 paul@113    345 
            self.record_namespaces_in_node(n)
 
 paul@113    346 
 
 paul@113    347 
    def record_namespaces_in_node(self, node):
 
 paul@113    348 
 
 paul@113    349 
        "Process the program structure 'node', recording namespaces."
 
 paul@113    350 
 
 paul@113    351 
        # Function namespaces within modules, classes and other functions.
 
 paul@113    352 
        # Functions appearing within conditional statements are given arbitrary
 
 paul@113    353 
        # names.
 
 paul@113    354 
 
 paul@113    355 
        if isinstance(node, compiler.ast.Function):
 
 paul@113    356 
            self.record_function_node(node, (self.in_conditional or self.in_function) and self.get_lambda_name() or node.name)
 
 paul@113    357 
 
 paul@113    358 
        elif isinstance(node, compiler.ast.Lambda):
 
 paul@113    359 
            self.record_function_node(node, self.get_lambda_name())
 
 paul@113    360 
 
 paul@113    361 
        # Classes are visited, but may be ignored if inside functions.
 
 paul@113    362 
 
 paul@113    363 
        elif isinstance(node, compiler.ast.Class):
 
 paul@113    364 
            self.enter_namespace(node.name)
 
 paul@113    365 
            if self.have_object():
 
 paul@113    366 
                self.record_namespaces(node)
 
 paul@113    367 
            self.exit_namespace()
 
 paul@113    368 
 
 paul@113    369 
        # Conditional nodes are tracked so that function definitions may be
 
 paul@113    370 
        # handled. Since "for" loops are converted to "while" loops, they are
 
 paul@113    371 
        # included here.
 
 paul@113    372 
 
 paul@113    373 
        elif isinstance(node, (compiler.ast.For, compiler.ast.If, compiler.ast.While)):
 
 paul@113    374 
            in_conditional = self.in_conditional
 
 paul@113    375 
            self.in_conditional = True
 
 paul@113    376 
            self.record_namespaces(node)
 
 paul@113    377 
            self.in_conditional = in_conditional
 
 paul@113    378 
 
 paul@113    379 
        # All other nodes are processed depth-first.
 
 paul@113    380 
 
 paul@113    381 
        else:
 
 paul@113    382 
            self.record_namespaces(node)
 
 paul@113    383 
 
 paul@113    384 
    def record_function_node(self, n, name):
 
 paul@113    385 
 
 paul@113    386 
        """
 
 paul@113    387 
        Record the given function, lambda, if expression or list comprehension
 
 paul@113    388 
        node 'n' with the given 'name'.
 
 paul@113    389 
        """
 
 paul@113    390 
 
 paul@113    391 
        self.in_function = True
 
 paul@113    392 
        self.enter_namespace(name)
 
 paul@113    393 
 
 paul@113    394 
        if self.have_object():
 
 paul@113    395 
 
 paul@113    396 
            # Record the namespace path and the node itself.
 
 paul@113    397 
 
 paul@113    398 
            self.namespaces.append((self.namespace_path[:], n))
 
 paul@113    399 
            self.record_namespaces_in_node(n.code)
 
 paul@113    400 
 
 paul@113    401 
        self.exit_namespace()
 
 paul@113    402 
        self.in_function = False
 
 paul@113    403 
 
 paul@113    404 
    # Constant referencing.
 
 paul@113    405 
 
 paul@113    406 
    def get_literal_instance(self, n, name):
 
 paul@113    407 
 
 paul@113    408 
        """
 
 paul@113    409 
        For node 'n', return a reference for the type of the given 'name'.
 
 paul@113    410 
        """
 
 paul@113    411 
 
 paul@156    412 
        ref = self.get_builtin_class(name)
 
 paul@113    413 
 
 paul@113    414 
        if name in ("dict", "list", "tuple"):
 
 paul@113    415 
            return self.process_literal_sequence_node(n, name, ref, TrLiteralSequenceRef)
 
 paul@113    416 
        else:
 
 paul@113    417 
            path = self.get_namespace_path()
 
 paul@113    418 
            local_number = self.importer.all_constants[path][n.value]
 
 paul@113    419 
            constant_name = "$c%d" % local_number
 
 paul@113    420 
            objpath = self.get_object_path(constant_name)
 
 paul@113    421 
            number = self.optimiser.constant_numbers[objpath]
 
 paul@113    422 
            return TrConstantValueRef(constant_name, ref.instance_of(), n.value, number)
 
 paul@113    423 
 
 paul@113    424 
    # Namespace translation.
 
 paul@113    425 
 
 paul@113    426 
    def process_namespace(self, path, node):
 
 paul@113    427 
 
 paul@113    428 
        """
 
 paul@113    429 
        Process the namespace for the given 'path' defined by the given 'node'.
 
 paul@113    430 
        """
 
 paul@113    431 
 
 paul@113    432 
        self.namespace_path = path
 
 paul@113    433 
 
 paul@113    434 
        if isinstance(node, (compiler.ast.Function, compiler.ast.Lambda)):
 
 paul@113    435 
            self.in_function = True
 
 paul@113    436 
            self.process_function_body_node(node)
 
 paul@113    437 
        else:
 
 paul@113    438 
            self.in_function = False
 
 paul@192    439 
            self.function_target = 0
 
 paul@113    440 
            self.start_module()
 
 paul@113    441 
            self.process_structure(node)
 
 paul@113    442 
            self.end_module()
 
 paul@113    443 
 
 paul@113    444 
    def process_structure(self, node):
 
 paul@113    445 
 
 paul@113    446 
        "Process the given 'node' or result."
 
 paul@113    447 
 
 paul@144    448 
        # Handle processing requests on results.
 
 paul@144    449 
 
 paul@113    450 
        if isinstance(node, results.Result):
 
 paul@113    451 
            return node
 
 paul@144    452 
 
 paul@144    453 
        # Handle processing requests on nodes.
 
 paul@144    454 
 
 paul@113    455 
        else:
 
 paul@144    456 
            l = CommonModule.process_structure(self, node)
 
 paul@144    457 
 
 paul@144    458 
            # Return indications of return statement usage.
 
 paul@144    459 
 
 paul@144    460 
            if l and isinstance(l[-1], ReturnRef):
 
 paul@144    461 
                return l[-1]
 
 paul@144    462 
            else:
 
 paul@144    463 
                return None
 
 paul@113    464 
 
 paul@113    465 
    def process_structure_node(self, n):
 
 paul@113    466 
 
 paul@113    467 
        "Process the individual node 'n'."
 
 paul@113    468 
 
 paul@113    469 
        # Plain statements emit their expressions.
 
 paul@113    470 
 
 paul@113    471 
        if isinstance(n, compiler.ast.Discard):
 
 paul@113    472 
            expr = self.process_structure_node(n.expr)
 
 paul@113    473 
            self.statement(expr)
 
 paul@113    474 
 
 paul@314    475 
        # Module import declarations.
 
 paul@314    476 
 
 paul@314    477 
        elif isinstance(n, compiler.ast.From):
 
 paul@314    478 
            self.process_from_node(n)
 
 paul@314    479 
 
 paul@113    480 
        # Nodes using operator module functions.
 
 paul@113    481 
 
 paul@113    482 
        elif isinstance(n, compiler.ast.Operator):
 
 paul@113    483 
            return self.process_operator_node(n)
 
 paul@113    484 
 
 paul@113    485 
        elif isinstance(n, compiler.ast.AugAssign):
 
 paul@113    486 
            self.process_augassign_node(n)
 
 paul@113    487 
 
 paul@113    488 
        elif isinstance(n, compiler.ast.Compare):
 
 paul@113    489 
            return self.process_compare_node(n)
 
 paul@113    490 
 
 paul@113    491 
        elif isinstance(n, compiler.ast.Slice):
 
 paul@113    492 
            return self.process_slice_node(n)
 
 paul@113    493 
 
 paul@113    494 
        elif isinstance(n, compiler.ast.Sliceobj):
 
 paul@113    495 
            return self.process_sliceobj_node(n)
 
 paul@113    496 
 
 paul@113    497 
        elif isinstance(n, compiler.ast.Subscript):
 
 paul@113    498 
            return self.process_subscript_node(n)
 
 paul@113    499 
 
 paul@113    500 
        # Classes are visited, but may be ignored if inside functions.
 
 paul@113    501 
 
 paul@113    502 
        elif isinstance(n, compiler.ast.Class):
 
 paul@113    503 
            self.process_class_node(n)
 
 paul@113    504 
 
 paul@113    505 
        # Functions within namespaces have any dynamic defaults initialised.
 
 paul@113    506 
 
 paul@113    507 
        elif isinstance(n, compiler.ast.Function):
 
 paul@113    508 
            self.process_function_node(n)
 
 paul@113    509 
 
 paul@113    510 
        # Lambdas are replaced with references to separately-generated
 
 paul@113    511 
        # functions.
 
 paul@113    512 
 
 paul@113    513 
        elif isinstance(n, compiler.ast.Lambda):
 
 paul@113    514 
            return self.process_lambda_node(n)
 
 paul@113    515 
 
 paul@113    516 
        # Assignments.
 
 paul@113    517 
 
 paul@113    518 
        elif isinstance(n, compiler.ast.Assign):
 
 paul@113    519 
 
 paul@113    520 
            # Handle each assignment node.
 
 paul@113    521 
 
 paul@113    522 
            for node in n.nodes:
 
 paul@113    523 
                self.process_assignment_node(node, n.expr)
 
 paul@113    524 
 
 paul@113    525 
        # Accesses.
 
 paul@113    526 
 
 paul@113    527 
        elif isinstance(n, compiler.ast.Getattr):
 
 paul@113    528 
            return self.process_attribute_access(n)
 
 paul@113    529 
 
 paul@113    530 
        # Names.
 
 paul@113    531 
 
 paul@113    532 
        elif isinstance(n, compiler.ast.Name):
 
 paul@113    533 
            return self.process_name_node(n)
 
 paul@113    534 
 
 paul@113    535 
        # Loops and conditionals.
 
 paul@113    536 
 
 paul@113    537 
        elif isinstance(n, compiler.ast.For):
 
 paul@113    538 
            self.process_for_node(n)
 
 paul@113    539 
 
 paul@113    540 
        elif isinstance(n, compiler.ast.While):
 
 paul@113    541 
            self.process_while_node(n)
 
 paul@113    542 
 
 paul@113    543 
        elif isinstance(n, compiler.ast.If):
 
 paul@113    544 
            self.process_if_node(n)
 
 paul@113    545 
 
 paul@113    546 
        elif isinstance(n, (compiler.ast.And, compiler.ast.Or)):
 
 paul@113    547 
            return self.process_logical_node(n)
 
 paul@113    548 
 
 paul@113    549 
        elif isinstance(n, compiler.ast.Not):
 
 paul@113    550 
            return self.process_not_node(n)
 
 paul@113    551 
 
 paul@113    552 
        # Exception control-flow tracking.
 
 paul@113    553 
 
 paul@113    554 
        elif isinstance(n, compiler.ast.TryExcept):
 
 paul@113    555 
            self.process_try_node(n)
 
 paul@113    556 
 
 paul@113    557 
        elif isinstance(n, compiler.ast.TryFinally):
 
 paul@113    558 
            self.process_try_finally_node(n)
 
 paul@113    559 
 
 paul@113    560 
        # Control-flow modification statements.
 
 paul@113    561 
 
 paul@113    562 
        elif isinstance(n, compiler.ast.Break):
 
 paul@128    563 
            self.writestmt("break;")
 
 paul@113    564 
 
 paul@113    565 
        elif isinstance(n, compiler.ast.Continue):
 
 paul@128    566 
            self.writestmt("continue;")
 
 paul@113    567 
 
 paul@144    568 
        elif isinstance(n, compiler.ast.Raise):
 
 paul@144    569 
            self.process_raise_node(n)
 
 paul@144    570 
 
 paul@113    571 
        elif isinstance(n, compiler.ast.Return):
 
 paul@144    572 
            return self.process_return_node(n)
 
 paul@113    573 
 
 paul@173    574 
        # Print statements.
 
 paul@173    575 
 
 paul@173    576 
        elif isinstance(n, (compiler.ast.Print, compiler.ast.Printnl)):
 
 paul@173    577 
            self.statement(self.process_print_node(n))
 
 paul@173    578 
 
 paul@113    579 
        # Invocations.
 
 paul@113    580 
 
 paul@113    581 
        elif isinstance(n, compiler.ast.CallFunc):
 
 paul@113    582 
            return self.process_invocation_node(n)
 
 paul@113    583 
 
 paul@113    584 
        elif isinstance(n, compiler.ast.Keyword):
 
 paul@113    585 
            return self.process_structure_node(n.expr)
 
 paul@113    586 
 
 paul@113    587 
        # Constant usage.
 
 paul@113    588 
 
 paul@113    589 
        elif isinstance(n, compiler.ast.Const):
 
 paul@113    590 
            return self.get_literal_instance(n, n.value.__class__.__name__)
 
 paul@113    591 
 
 paul@113    592 
        elif isinstance(n, compiler.ast.Dict):
 
 paul@113    593 
            return self.get_literal_instance(n, "dict")
 
 paul@113    594 
 
 paul@113    595 
        elif isinstance(n, compiler.ast.List):
 
 paul@113    596 
            return self.get_literal_instance(n, "list")
 
 paul@113    597 
 
 paul@113    598 
        elif isinstance(n, compiler.ast.Tuple):
 
 paul@113    599 
            return self.get_literal_instance(n, "tuple")
 
 paul@113    600 
 
 paul@113    601 
        # All other nodes are processed depth-first.
 
 paul@113    602 
 
 paul@113    603 
        else:
 
 paul@144    604 
            return self.process_structure(n)
 
 paul@113    605 
 
 paul@113    606 
    def process_assignment_node(self, n, expr):
 
 paul@113    607 
 
 paul@113    608 
        "Process the individual node 'n' to be assigned the contents of 'expr'."
 
 paul@113    609 
 
 paul@113    610 
        # Names and attributes are assigned the entire expression.
 
 paul@113    611 
 
 paul@113    612 
        if isinstance(n, compiler.ast.AssName):
 
 paul@113    613 
            name_ref = self.process_name_node(n, self.process_structure_node(expr))
 
 paul@113    614 
            self.statement(name_ref)
 
 paul@113    615 
 
 paul@238    616 
            # Employ guards after assignments if required.
 
 paul@238    617 
 
 paul@238    618 
            if expr and name_ref.is_name():
 
 paul@238    619 
                self.generate_guard(name_ref.name)
 
 paul@238    620 
 
 paul@113    621 
        elif isinstance(n, compiler.ast.AssAttr):
 
 paul@124    622 
            in_assignment = self.in_assignment
 
 paul@124    623 
            self.in_assignment = self.process_structure_node(expr)
 
 paul@124    624 
            self.statement(self.process_attribute_access(n))
 
 paul@124    625 
            self.in_assignment = in_assignment
 
 paul@113    626 
 
 paul@113    627 
        # Lists and tuples are matched against the expression and their
 
 paul@113    628 
        # items assigned to expression items.
 
 paul@113    629 
 
 paul@113    630 
        elif isinstance(n, (compiler.ast.AssList, compiler.ast.AssTuple)):
 
 paul@113    631 
            self.process_assignment_node_items(n, expr)
 
 paul@113    632 
 
 paul@113    633 
        # Slices and subscripts are permitted within assignment nodes.
 
 paul@113    634 
 
 paul@113    635 
        elif isinstance(n, compiler.ast.Slice):
 
 paul@113    636 
            self.statement(self.process_slice_node(n, expr))
 
 paul@113    637 
 
 paul@113    638 
        elif isinstance(n, compiler.ast.Subscript):
 
 paul@113    639 
            self.statement(self.process_subscript_node(n, expr))
 
 paul@113    640 
 
 paul@124    641 
    def process_attribute_access(self, n):
 
 paul@113    642 
 
 paul@113    643 
        """
 
 paul@113    644 
        Process the given attribute access node 'n'.
 
 paul@113    645 
 
 paul@113    646 
        Where a name is provided, a single access should be recorded
 
 paul@113    647 
        involving potentially many attributes, thus providing a path to an
 
 paul@113    648 
        object. The remaining attributes are then accessed dynamically.
 
 paul@113    649 
        The remaining accesses could be deduced and computed, but they would
 
 paul@113    650 
        also need to be tested.
 
 paul@113    651 
 
 paul@113    652 
        Where no name is provided, potentially many accesses should be
 
 paul@113    653 
        recorded, one per attribute name. These could be used to provide
 
 paul@113    654 
        computed accesses, but the accessors would need to be tested in each
 
 paul@113    655 
        case.
 
 paul@113    656 
        """
 
 paul@113    657 
 
 paul@113    658 
        # Obtain any completed chain and return the reference to it.
 
 paul@113    659 
 
 paul@113    660 
        attr_expr = self.process_attribute_chain(n)
 
 paul@113    661 
        if self.have_access_expression(n):
 
 paul@113    662 
            return attr_expr
 
 paul@113    663 
 
 paul@113    664 
        # Where the start of the chain of attributes has been reached, process
 
 paul@113    665 
        # the complete access.
 
 paul@113    666 
 
 paul@113    667 
        name_ref = attr_expr and attr_expr.is_name() and attr_expr
 
 paul@152    668 
        name = name_ref and self.get_name_for_tracking(name_ref.name, name_ref and name_ref.final()) or None
 
 paul@113    669 
 
 paul@113    670 
        location = self.get_access_location(name)
 
 paul@113    671 
        refs = self.get_referenced_attributes(location)
 
 paul@113    672 
 
 paul@113    673 
        # Generate access instructions.
 
 paul@113    674 
 
 paul@113    675 
        subs = {
 
 paul@113    676 
            "<expr>" : str(attr_expr),
 
 paul@124    677 
            "<assexpr>" : str(self.in_assignment),
 
 paul@113    678 
            "<context>" : "__tmp_context",
 
 paul@113    679 
            "<accessor>" : "__tmp_value",
 
 paul@113    680 
            }
 
 paul@113    681 
 
 paul@113    682 
        output = []
 
 paul@113    683 
 
 paul@113    684 
        for instruction in self.optimiser.access_instructions[location]:
 
 paul@113    685 
            output.append(encode_access_instruction(instruction, subs))
 
 paul@113    686 
 
 paul@128    687 
        if len(output) == 1:
 
 paul@128    688 
            out = output[0]
 
 paul@128    689 
        else:
 
 paul@128    690 
            out = "(\n%s\n)" % ",\n".join(output)
 
 paul@113    691 
 
 paul@113    692 
        del self.attrs[0]
 
 paul@234    693 
        return AttrResult(out, refs, self.get_accessor_kinds(location))
 
 paul@113    694 
 
 paul@113    695 
    def get_referenced_attributes(self, location):
 
 paul@113    696 
 
 paul@113    697 
        """
 
 paul@113    698 
        Convert 'location' to the form used by the deducer and retrieve any
 
 paul@113    699 
        identified attribute.
 
 paul@113    700 
        """
 
 paul@113    701 
 
 paul@113    702 
        access_location = self.deducer.const_accesses.get(location)
 
 paul@113    703 
        refs = []
 
 paul@113    704 
        for attrtype, objpath, attr in self.deducer.referenced_attrs[access_location or location]:
 
 paul@113    705 
            refs.append(attr)
 
 paul@113    706 
        return refs
 
 paul@113    707 
 
 paul@234    708 
    def get_accessor_kinds(self, location):
 
 paul@234    709 
 
 paul@234    710 
        "Return the accessor kinds for 'location'."
 
 paul@234    711 
 
 paul@234    712 
        return self.optimiser.accessor_kinds[location]
 
 paul@234    713 
 
 paul@113    714 
    def get_access_location(self, name):
 
 paul@113    715 
 
 paul@113    716 
        """
 
 paul@113    717 
        Using the current namespace and the given 'name', return the access
 
 paul@113    718 
        location.
 
 paul@113    719 
        """
 
 paul@113    720 
 
 paul@113    721 
        path = self.get_path_for_access()
 
 paul@113    722 
 
 paul@113    723 
        # Get the location used by the deducer and optimiser and find any
 
 paul@113    724 
        # recorded access.
 
 paul@113    725 
 
 paul@113    726 
        attrnames = ".".join(self.attrs)
 
 paul@113    727 
        access_number = self.get_access_number(path, name, attrnames)
 
 paul@113    728 
        self.update_access_number(path, name, attrnames)
 
 paul@113    729 
        return (path, name, attrnames, access_number)
 
 paul@113    730 
 
 paul@113    731 
    def get_access_number(self, path, name, attrnames):
 
 paul@113    732 
        access = name, attrnames
 
 paul@113    733 
        if self.attr_accesses.has_key(path) and self.attr_accesses[path].has_key(access):
 
 paul@113    734 
            return self.attr_accesses[path][access]
 
 paul@113    735 
        else:
 
 paul@113    736 
            return 0
 
 paul@113    737 
 
 paul@113    738 
    def update_access_number(self, path, name, attrnames):
 
 paul@113    739 
        access = name, attrnames
 
 paul@113    740 
        if name:
 
 paul@113    741 
            init_item(self.attr_accesses, path, dict)
 
 paul@144    742 
            init_item(self.attr_accesses[path], access, lambda: 0)
 
 paul@144    743 
            self.attr_accesses[path][access] += 1
 
 paul@113    744 
 
 paul@237    745 
    def get_accessor_location(self, name):
 
 paul@237    746 
 
 paul@237    747 
        """
 
 paul@237    748 
        Using the current namespace and the given 'name', return the accessor
 
 paul@237    749 
        location.
 
 paul@237    750 
        """
 
 paul@237    751 
 
 paul@237    752 
        path = self.get_path_for_access()
 
 paul@237    753 
 
 paul@237    754 
        # Get the location used by the deducer and optimiser and find any
 
 paul@237    755 
        # recorded accessor.
 
 paul@237    756 
 
 paul@237    757 
        access_number = self.get_accessor_number(path, name)
 
 paul@237    758 
        self.update_accessor_number(path, name)
 
 paul@237    759 
        return (path, name, None, access_number)
 
 paul@237    760 
 
 paul@237    761 
    def get_accessor_number(self, path, name):
 
 paul@237    762 
        if self.attr_accessors.has_key(path) and self.attr_accessors[path].has_key(name):
 
 paul@237    763 
            return self.attr_accessors[path][name]
 
 paul@237    764 
        else:
 
 paul@237    765 
            return 0
 
 paul@237    766 
 
 paul@237    767 
    def update_accessor_number(self, path, name):
 
 paul@237    768 
        if name:
 
 paul@237    769 
            init_item(self.attr_accessors, path, dict)
 
 paul@237    770 
            init_item(self.attr_accessors[path], name, lambda: 0)
 
 paul@237    771 
            self.attr_accessors[path][name] += 1
 
 paul@237    772 
 
 paul@113    773 
    def process_class_node(self, n):
 
 paul@113    774 
 
 paul@113    775 
        "Process the given class node 'n'."
 
 paul@113    776 
 
 paul@113    777 
        self.enter_namespace(n.name)
 
 paul@113    778 
 
 paul@113    779 
        if self.have_object():
 
 paul@113    780 
            class_name = self.get_namespace_path()
 
 paul@113    781 
            self.write_comment("Class: %s" % class_name)
 
 paul@113    782 
 
 paul@257    783 
            self.initialise_inherited_members(class_name)
 
 paul@257    784 
 
 paul@113    785 
            self.process_structure(n)
 
 paul@257    786 
            self.write_comment("End class: %s" % class_name)
 
 paul@113    787 
 
 paul@113    788 
        self.exit_namespace()
 
 paul@113    789 
 
 paul@257    790 
    def initialise_inherited_members(self, class_name):
 
 paul@257    791 
 
 paul@257    792 
        "Initialise members of 'class_name' inherited from its ancestors."
 
 paul@257    793 
 
 paul@257    794 
        for name, path in self.importer.all_class_attrs[class_name].items():
 
 paul@257    795 
            target = "%s.%s" % (class_name, name)
 
 paul@257    796 
 
 paul@257    797 
            # Ignore attributes with definitions.
 
 paul@257    798 
 
 paul@257    799 
            ref = self.importer.identify(target)
 
 paul@257    800 
            if ref:
 
 paul@257    801 
                continue
 
 paul@257    802 
 
 paul@257    803 
            # Reference inherited attributes.
 
 paul@257    804 
 
 paul@257    805 
            ref = self.importer.identify(path)
 
 paul@257    806 
            if ref and not ref.static():
 
 paul@257    807 
                parent, attrname = path.rsplit(".", 1)
 
 paul@257    808 
 
 paul@257    809 
                self.writestmt("__store_via_object(&%s, %s, __load_via_object(&%s, %s));" % (
 
 paul@257    810 
                    encode_path(class_name), encode_symbol("pos", name),
 
 paul@257    811 
                    encode_path(parent), encode_symbol("pos", attrname)
 
 paul@257    812 
                    ))
 
 paul@257    813 
 
 paul@314    814 
    def process_from_node(self, n):
 
 paul@314    815 
 
 paul@314    816 
        "Process the given node 'n', importing from another module."
 
 paul@314    817 
 
 paul@314    818 
        path = self.get_namespace_path()
 
 paul@314    819 
 
 paul@314    820 
        # Attempt to obtain the referenced objects.
 
 paul@314    821 
 
 paul@314    822 
        for name, alias in n.names:
 
 paul@314    823 
            if name == "*":
 
 paul@314    824 
                raise InspectError("Only explicitly specified names can be imported from modules.", path, n)
 
 paul@314    825 
 
 paul@314    826 
            # Obtain the path of the assigned name.
 
 paul@314    827 
 
 paul@314    828 
            objpath = self.get_object_path(alias or name)
 
 paul@314    829 
 
 paul@314    830 
            # Obtain the identity of the name.
 
 paul@314    831 
 
 paul@314    832 
            ref = self.importer.identify(objpath)
 
 paul@314    833 
 
 paul@314    834 
            # Where the name is not static, assign the value.
 
 paul@314    835 
 
 paul@314    836 
            if ref and not ref.static() and ref.get_name():
 
 paul@314    837 
                self.writestmt("%s;" % 
 
 paul@314    838 
                    TrResolvedNameRef(alias or name, Reference("<var>", None, objpath),
 
 paul@314    839 
                                      expr=TrResolvedNameRef(name, ref)))
 
 paul@314    840 
 
 paul@113    841 
    def process_function_body_node(self, n):
 
 paul@113    842 
 
 paul@113    843 
        """
 
 paul@113    844 
        Process the given function, lambda, if expression or list comprehension
 
 paul@113    845 
        node 'n', generating the body.
 
 paul@113    846 
        """
 
 paul@113    847 
 
 paul@113    848 
        function_name = self.get_namespace_path()
 
 paul@113    849 
        self.start_function(function_name)
 
 paul@113    850 
 
 paul@113    851 
        # Process the function body.
 
 paul@113    852 
 
 paul@113    853 
        in_conditional = self.in_conditional
 
 paul@113    854 
        self.in_conditional = False
 
 paul@192    855 
        self.function_target = 0
 
 paul@113    856 
 
 paul@237    857 
        # Process any guards defined for the parameters.
 
 paul@237    858 
 
 paul@237    859 
        for name in self.importer.function_parameters.get(function_name):
 
 paul@238    860 
            self.generate_guard(name)
 
 paul@237    861 
 
 paul@237    862 
        # Produce the body and any additional return statement.
 
 paul@237    863 
 
 paul@144    864 
        expr = self.process_structure_node(n.code) or PredefinedConstantRef("None")
 
 paul@144    865 
        if not isinstance(expr, ReturnRef):
 
 paul@128    866 
            self.writestmt("return %s;" % expr)
 
 paul@113    867 
 
 paul@113    868 
        self.in_conditional = in_conditional
 
 paul@113    869 
 
 paul@144    870 
        self.end_function(function_name)
 
 paul@113    871 
 
 paul@238    872 
    def generate_guard(self, name):
 
 paul@238    873 
 
 paul@238    874 
        """
 
 paul@238    875 
        Get the accessor details for 'name', found in the current namespace, and
 
 paul@238    876 
        generate any guards defined for it.
 
 paul@238    877 
        """
 
 paul@238    878 
 
 paul@238    879 
        # Obtain the location, keeping track of assignment versions.
 
 paul@238    880 
 
 paul@238    881 
        location = self.get_accessor_location(name)
 
 paul@238    882 
        test = self.deducer.accessor_guard_tests.get(location)
 
 paul@238    883 
 
 paul@238    884 
        # Generate any guard from the deduced information.
 
 paul@238    885 
 
 paul@238    886 
        if test:
 
 paul@238    887 
            guard, guard_type = test
 
 paul@238    888 
 
 paul@238    889 
            if guard == "specific":
 
 paul@238    890 
                ref = first(self.deducer.accessor_all_types[location])
 
 paul@238    891 
                argstr = "&%s" % encode_path(ref.get_origin())
 
 paul@238    892 
            elif guard == "common":
 
 paul@238    893 
                ref = first(self.deducer.accessor_all_general_types[location])
 
 paul@238    894 
                typeattr = encode_type_attribute(ref.get_origin())
 
 paul@238    895 
                argstr = "%s, %s" % (encode_symbol("pos", typeattr), encode_symbol("code", typeattr))
 
 paul@238    896 
            else:
 
 paul@238    897 
                return
 
 paul@238    898 
 
 paul@257    899 
            # Produce an appropriate access to an attribute's value.
 
 paul@257    900 
 
 paul@257    901 
            parameters = self.importer.function_parameters.get(self.get_namespace_path())
 
 paul@257    902 
            if parameters and name in parameters:
 
 paul@257    903 
                name_to_value = "%s->value" % name
 
 paul@257    904 
            else:
 
 paul@257    905 
                name_to_value = "%s.value" % name
 
 paul@257    906 
 
 paul@238    907 
            # Write a test that raises a TypeError upon failure.
 
 paul@238    908 
 
 paul@257    909 
            self.writestmt("if (!__test_%s_%s(%s, %s)) __raise_type_error();" % (
 
 paul@257    910 
                guard, guard_type, name_to_value, argstr))
 
 paul@238    911 
 
 paul@113    912 
    def process_function_node(self, n):
 
 paul@113    913 
 
 paul@113    914 
        """
 
 paul@113    915 
        Process the given function, lambda, if expression or list comprehension
 
 paul@113    916 
        node 'n', generating any initialisation statements.
 
 paul@113    917 
        """
 
 paul@113    918 
 
 paul@113    919 
        # Where a function is declared conditionally, use a separate name for
 
 paul@113    920 
        # the definition, and assign the definition to the stated name.
 
 paul@113    921 
 
 paul@196    922 
        original_name = n.name
 
 paul@196    923 
 
 paul@113    924 
        if self.in_conditional or self.in_function:
 
 paul@113    925 
            name = self.get_lambda_name()
 
 paul@113    926 
        else:
 
 paul@113    927 
            name = n.name
 
 paul@113    928 
 
 paul@196    929 
        objpath = self.get_object_path(name)
 
 paul@196    930 
 
 paul@113    931 
        # Obtain details of the defaults.
 
 paul@113    932 
 
 paul@285    933 
        defaults = self.process_function_defaults(n, name, objpath)
 
 paul@113    934 
        if defaults:
 
 paul@113    935 
            for default in defaults:
 
 paul@113    936 
                self.writeline("%s;" % default)
 
 paul@113    937 
 
 paul@196    938 
        # Where a function is set conditionally or where the name may refer to
 
 paul@196    939 
        # different values, assign the name.
 
 paul@196    940 
 
 paul@196    941 
        ref = self.importer.identify(objpath)
 
 paul@113    942 
 
 paul@196    943 
        if self.in_conditional or self.in_function:
 
 paul@196    944 
            self.process_assignment_for_function(original_name, compiler.ast.Name(name))
 
 paul@196    945 
        elif not ref.static():
 
 paul@267    946 
            context = self.is_method(objpath)
 
 paul@267    947 
 
 paul@196    948 
            self.process_assignment_for_function(original_name,
 
 paul@267    949 
                make_expression("((__attr) {%s, &%s})" % (
 
 paul@267    950 
                    context and "&%s" % encode_path(context) or "0",
 
 paul@267    951 
                    encode_path(objpath))))
 
 paul@113    952 
 
 paul@285    953 
    def process_function_defaults(self, n, name, objpath, instance_name=None):
 
 paul@113    954 
 
 paul@113    955 
        """
 
 paul@113    956 
        Process the given function or lambda node 'n', initialising defaults
 
 paul@113    957 
        that are dynamically set. The given 'name' indicates the name of the
 
 paul@285    958 
        function. The given 'objpath' indicates the origin of the function.
 
 paul@285    959 
        The given 'instance_name' indicates the name of any separate instance
 
 paul@285    960 
        of the function created to hold the defaults.
 
 paul@113    961 
 
 paul@113    962 
        Return a list of operations setting defaults on a function instance.
 
 paul@113    963 
        """
 
 paul@113    964 
 
 paul@113    965 
        function_name = self.get_object_path(name)
 
 paul@113    966 
        function_defaults = self.importer.function_defaults.get(function_name)
 
 paul@113    967 
        if not function_defaults:
 
 paul@113    968 
            return None
 
 paul@113    969 
 
 paul@113    970 
        # Determine whether any unidentified defaults are involved.
 
 paul@113    971 
 
 paul@285    972 
        for argname, default in function_defaults:
 
 paul@285    973 
            if not default.static():
 
 paul@285    974 
                break
 
 paul@285    975 
        else:
 
 paul@113    976 
            return None
 
 paul@113    977 
 
 paul@285    978 
        # Handle bound methods.
 
 paul@285    979 
 
 paul@285    980 
        if not instance_name:
 
 paul@285    981 
            if self.is_method(objpath):
 
 paul@285    982 
                instance_name = "&%s" % encode_bound_reference(objpath)
 
 paul@285    983 
            else:
 
 paul@285    984 
                instance_name = "&%s" % encode_path(objpath)
 
 paul@285    985 
 
 paul@113    986 
        # Where defaults are involved but cannot be identified, obtain a new
 
 paul@113    987 
        # instance of the lambda and populate the defaults.
 
 paul@113    988 
 
 paul@113    989 
        defaults = []
 
 paul@113    990 
 
 paul@113    991 
        # Join the original defaults with the inspected defaults.
 
 paul@113    992 
 
 paul@113    993 
        original_defaults = [(argname, default) for (argname, default) in compiler.ast.get_defaults(n) if default]
 
 paul@113    994 
 
 paul@113    995 
        for i, (original, inspected) in enumerate(map(None, original_defaults, function_defaults)):
 
 paul@113    996 
 
 paul@113    997 
            # Obtain any reference for the default.
 
 paul@113    998 
 
 paul@113    999 
            if original:
 
 paul@113   1000 
                argname, default = original
 
 paul@113   1001 
                name_ref = self.process_structure_node(default)
 
 paul@113   1002 
            elif inspected:
 
 paul@113   1003 
                argname, default = inspected
 
 paul@113   1004 
                name_ref = TrResolvedNameRef(argname, default)
 
 paul@113   1005 
            else:
 
 paul@113   1006 
                continue
 
 paul@113   1007 
 
 paul@113   1008 
            if name_ref:
 
 paul@285   1009 
                defaults.append("__SETDEFAULT(%s, %s, %s)" % (instance_name, i, name_ref))
 
 paul@113   1010 
 
 paul@113   1011 
        return defaults
 
 paul@113   1012 
 
 paul@113   1013 
    def process_if_node(self, n):
 
 paul@113   1014 
 
 paul@113   1015 
        """
 
 paul@113   1016 
        Process the given "if" node 'n'.
 
 paul@113   1017 
        """
 
 paul@113   1018 
 
 paul@113   1019 
        first = True
 
 paul@113   1020 
        for test, body in n.tests:
 
 paul@113   1021 
            test_ref = self.process_structure_node(test)
 
 paul@113   1022 
            self.start_if(first, test_ref)
 
 paul@113   1023 
 
 paul@113   1024 
            in_conditional = self.in_conditional
 
 paul@113   1025 
            self.in_conditional = True
 
 paul@113   1026 
            self.process_structure_node(body)
 
 paul@113   1027 
            self.in_conditional = in_conditional
 
 paul@113   1028 
 
 paul@113   1029 
            self.end_if()
 
 paul@113   1030 
            first = False
 
 paul@113   1031 
 
 paul@113   1032 
        if n.else_:
 
 paul@113   1033 
            self.start_else()
 
 paul@113   1034 
            self.process_structure_node(n.else_)
 
 paul@113   1035 
            self.end_else()
 
 paul@113   1036 
 
 paul@113   1037 
    def process_invocation_node(self, n):
 
 paul@113   1038 
 
 paul@113   1039 
        "Process the given invocation node 'n'."
 
 paul@113   1040 
 
 paul@113   1041 
        expr = self.process_structure_node(n.node)
 
 paul@113   1042 
        objpath = expr.get_origin()
 
 paul@118   1043 
        target = None
 
 paul@242   1044 
        function = None
 
 paul@317   1045 
        instantiation = False
 
 paul@159   1046 
        literal_instantiation = False
 
 paul@312   1047 
        context_required = True
 
 paul@113   1048 
 
 paul@113   1049 
        # Obtain details of the callable.
 
 paul@113   1050 
 
 paul@159   1051 
        # Literals may be instantiated specially.
 
 paul@159   1052 
 
 paul@159   1053 
        if expr.is_name() and expr.name.startswith("$L") and objpath:
 
 paul@317   1054 
            instantiation = literal_instantiation = objpath
 
 paul@159   1055 
            parameters = None
 
 paul@159   1056 
            target = encode_literal_instantiator(objpath)
 
 paul@312   1057 
            context_required = False
 
 paul@159   1058 
 
 paul@159   1059 
        # Identified targets employ function pointers directly.
 
 paul@159   1060 
 
 paul@159   1061 
        elif objpath:
 
 paul@113   1062 
            parameters = self.importer.function_parameters.get(objpath)
 
 paul@234   1063 
 
 paul@234   1064 
            # Class invocation involves instantiators.
 
 paul@234   1065 
 
 paul@118   1066 
            if expr.has_kind("<class>"):
 
 paul@317   1067 
                instantiation = objpath
 
 paul@118   1068 
                target = encode_instantiator_pointer(objpath)
 
 paul@285   1069 
                target_structure = "&%s" % encode_bound_reference("%s.__init__" % objpath)
 
 paul@312   1070 
                context_required = False
 
 paul@234   1071 
 
 paul@234   1072 
            # Only plain functions and bound methods employ function pointers.
 
 paul@234   1073 
 
 paul@118   1074 
            elif expr.has_kind("<function>"):
 
 paul@242   1075 
                function = objpath
 
 paul@234   1076 
 
 paul@234   1077 
                # Test for functions and methods.
 
 paul@234   1078 
 
 paul@312   1079 
                method_class = self.is_method(objpath)
 
 paul@234   1080 
                accessor_kinds = expr.get_accessor_kinds()
 
 paul@312   1081 
                instance_accessor = accessor_kinds and \
 
 paul@312   1082 
                                    len(accessor_kinds) == 1 and \
 
 paul@312   1083 
                                    first(accessor_kinds) == "<instance>"
 
 paul@234   1084 
 
 paul@312   1085 
                if not method_class or instance_accessor:
 
 paul@234   1086 
                    target = encode_function_pointer(objpath)
 
 paul@285   1087 
                    target_structure = self.is_method(objpath) and \
 
 paul@285   1088 
                        encode_bound_reference(objpath) or \
 
 paul@285   1089 
                        "&%s" % encode_path(objpath)
 
 paul@159   1090 
 
 paul@312   1091 
                if not method_class:
 
 paul@312   1092 
                    context_required = False
 
 paul@312   1093 
 
 paul@159   1094 
        # Other targets are retrieved at run-time.
 
 paul@159   1095 
 
 paul@113   1096 
        else:
 
 paul@113   1097 
            parameters = None
 
 paul@113   1098 
 
 paul@122   1099 
        # Arguments are presented in a temporary frame array with any context
 
 paul@312   1100 
        # always being the first argument. Where it would be unused, it may be
 
 paul@312   1101 
        # set to null.
 
 paul@122   1102 
 
 paul@312   1103 
        if context_required:
 
 paul@312   1104 
            args = ["__CONTEXT_AS_VALUE(__tmp_targets[%d])" % self.function_target]
 
 paul@312   1105 
        else:
 
 paul@312   1106 
            args = ["(__attr) {0, 0}"]
 
 paul@312   1107 
 
 paul@122   1108 
        args += [None] * (not parameters and len(n.args) or parameters and len(parameters) or 0)
 
 paul@122   1109 
        kwcodes = []
 
 paul@122   1110 
        kwargs = []
 
 paul@122   1111 
 
 paul@192   1112 
        # Any invocations in the arguments will store target details in a
 
 paul@192   1113 
        # different location.
 
 paul@192   1114 
 
 paul@192   1115 
        self.function_target += 1
 
 paul@192   1116 
 
 paul@122   1117 
        for i, arg in enumerate(n.args):
 
 paul@122   1118 
            argexpr = self.process_structure_node(arg)
 
 paul@122   1119 
 
 paul@122   1120 
            # Store a keyword argument, either in the argument list or
 
 paul@122   1121 
            # in a separate keyword argument list for subsequent lookup.
 
 paul@122   1122 
 
 paul@122   1123 
            if isinstance(arg, compiler.ast.Keyword):
 
 paul@113   1124 
 
 paul@122   1125 
                # With knowledge of the target, store the keyword
 
 paul@122   1126 
                # argument directly.
 
 paul@122   1127 
 
 paul@122   1128 
                if parameters:
 
 paul@122   1129 
                    argnum = parameters.index(arg.name)
 
 paul@122   1130 
                    args[argnum+1] = str(argexpr)
 
 paul@122   1131 
 
 paul@122   1132 
                # Otherwise, store the details in a separate collection.
 
 paul@122   1133 
 
 paul@122   1134 
                else:
 
 paul@122   1135 
                    kwargs.append(str(argexpr))
 
 paul@122   1136 
                    kwcodes.append("{%s, %s}" % (
 
 paul@122   1137 
                        encode_symbol("ppos", arg.name),
 
 paul@122   1138 
                        encode_symbol("pcode", arg.name)))
 
 paul@122   1139 
 
 paul@312   1140 
            # Store non-keyword arguments in the argument list, rejecting
 
 paul@312   1141 
            # superfluous arguments.
 
 paul@312   1142 
 
 paul@122   1143 
            else:
 
 paul@225   1144 
                try:
 
 paul@225   1145 
                    args[i+1] = str(argexpr)
 
 paul@225   1146 
                except IndexError:
 
 paul@225   1147 
                    raise TranslateError("Too many arguments specified.",
 
 paul@225   1148 
                                         self.get_namespace_path(), n)
 
 paul@113   1149 
 
 paul@192   1150 
        # Reference the current target again.
 
 paul@192   1151 
 
 paul@192   1152 
        self.function_target -= 1
 
 paul@192   1153 
 
 paul@113   1154 
        # Defaults are added to the frame where arguments are missing.
 
 paul@113   1155 
 
 paul@122   1156 
        if parameters:
 
 paul@122   1157 
            function_defaults = self.importer.function_defaults.get(objpath)
 
 paul@122   1158 
            if function_defaults:
 
 paul@122   1159 
 
 paul@122   1160 
                # Visit each default and set any missing arguments.
 
 paul@149   1161 
                # Use the target structure to obtain defaults, as opposed to the
 
 paul@149   1162 
                # actual function involved.
 
 paul@122   1163 
 
 paul@122   1164 
                for i, (argname, default) in enumerate(function_defaults):
 
 paul@122   1165 
                    argnum = parameters.index(argname)
 
 paul@122   1166 
                    if not args[argnum+1]:
 
 paul@285   1167 
                        args[argnum+1] = "__GETDEFAULT(%s, %d)" % (target_structure, i)
 
 paul@149   1168 
 
 paul@173   1169 
        # Test for missing arguments.
 
 paul@173   1170 
 
 paul@173   1171 
        if None in args:
 
 paul@173   1172 
            raise TranslateError("Not all arguments supplied.",
 
 paul@173   1173 
                                 self.get_namespace_path(), n)
 
 paul@173   1174 
 
 paul@149   1175 
        # Encode the arguments.
 
 paul@122   1176 
 
 paul@122   1177 
        argstr = "__ARGS(%s)" % ", ".join(args)
 
 paul@122   1178 
        kwargstr = kwargs and ("__ARGS(%s)" % ", ".join(kwargs)) or "0"
 
 paul@122   1179 
        kwcodestr = kwcodes and ("__KWARGS(%s)" % ", ".join(kwcodes)) or "0"
 
 paul@122   1180 
 
 paul@159   1181 
        # Where literal instantiation is occurring, add an argument indicating
 
 paul@159   1182 
        # the number of values.
 
 paul@159   1183 
 
 paul@159   1184 
        if literal_instantiation:
 
 paul@159   1185 
            argstr += ", %d" % (len(args) - 1)
 
 paul@159   1186 
 
 paul@156   1187 
        # First, the invocation expression is presented.
 
 paul@113   1188 
 
 paul@156   1189 
        stages = []
 
 paul@156   1190 
 
 paul@156   1191 
        # Without a known specific callable, the expression provides the target.
 
 paul@118   1192 
 
 paul@312   1193 
        if not target or context_required:
 
 paul@312   1194 
            stages.append("__tmp_targets[%d] = %s" % (self.function_target, expr))
 
 paul@156   1195 
 
 paul@156   1196 
        # Any specific callable is then obtained.
 
 paul@156   1197 
 
 paul@163   1198 
        if target:
 
 paul@156   1199 
            stages.append(target)
 
 paul@242   1200 
        elif function:
 
 paul@244   1201 
            stages.append("__load_via_object(__tmp_targets[%d].value, %s).fn" % (
 
 paul@244   1202 
                self.function_target, encode_symbol("pos", "__fn__")))
 
 paul@122   1203 
 
 paul@122   1204 
        # With a known target, the function is obtained directly and called.
 
 paul@122   1205 
 
 paul@242   1206 
        if target or function:
 
 paul@136   1207 
            output = "(\n%s\n)(%s)" % (",\n".join(stages), argstr)
 
 paul@113   1208 
 
 paul@122   1209 
        # With unknown targets, the generic invocation function is applied to
 
 paul@122   1210 
        # the callable and argument collections.
 
 paul@113   1211 
 
 paul@122   1212 
        else:
 
 paul@192   1213 
            output = "(%s, __invoke(\n__tmp_targets[%d],\n%d, %d, %s, %s,\n%d, %s\n))" % (
 
 paul@122   1214 
                ",\n".join(stages),
 
 paul@192   1215 
                self.function_target,
 
 paul@156   1216 
                self.always_callable and 1 or 0,
 
 paul@122   1217 
                len(kwargs), kwcodestr, kwargstr,
 
 paul@122   1218 
                len(args), argstr)
 
 paul@122   1219 
 
 paul@317   1220 
        if instantiation:
 
 paul@317   1221 
            return TrInstanceRef(instantiation, output)
 
 paul@317   1222 
        else:
 
 paul@317   1223 
            return make_expression(output)
 
 paul@113   1224 
 
 paul@113   1225 
    def always_callable(self, refs):
 
 paul@113   1226 
 
 paul@113   1227 
        "Determine whether all 'refs' are callable."
 
 paul@113   1228 
 
 paul@113   1229 
        for ref in refs:
 
 paul@113   1230 
            if not ref.static():
 
 paul@113   1231 
                return False
 
 paul@113   1232 
            else:
 
 paul@113   1233 
                origin = ref.final()
 
 paul@113   1234 
                if not self.importer.get_attribute(origin, "__fn__"):
 
 paul@113   1235 
                    return False
 
 paul@113   1236 
        return True
 
 paul@113   1237 
 
 paul@113   1238 
    def need_default_arguments(self, objpath, nargs):
 
 paul@113   1239 
 
 paul@113   1240 
        """
 
 paul@113   1241 
        Return whether any default arguments are needed when invoking the object
 
 paul@113   1242 
        given by 'objpath'.
 
 paul@113   1243 
        """
 
 paul@113   1244 
 
 paul@113   1245 
        parameters = self.importer.function_parameters.get(objpath)
 
 paul@113   1246 
        return nargs < len(parameters)
 
 paul@113   1247 
 
 paul@113   1248 
    def process_lambda_node(self, n):
 
 paul@113   1249 
 
 paul@113   1250 
        "Process the given lambda node 'n'."
 
 paul@113   1251 
 
 paul@113   1252 
        name = self.get_lambda_name()
 
 paul@113   1253 
        function_name = self.get_object_path(name)
 
 paul@113   1254 
 
 paul@285   1255 
        defaults = self.process_function_defaults(n, name, function_name, "__tmp_value")
 
 paul@149   1256 
 
 paul@149   1257 
        # Without defaults, produce an attribute referring to the function.
 
 paul@149   1258 
 
 paul@113   1259 
        if not defaults:
 
 paul@149   1260 
            return make_expression("((__attr) {0, &%s})" % encode_path(function_name))
 
 paul@149   1261 
 
 paul@149   1262 
        # With defaults, copy the function structure and set the defaults on the
 
 paul@149   1263 
        # copy.
 
 paul@149   1264 
 
 paul@113   1265 
        else:
 
 paul@155   1266 
            return make_expression("(__tmp_value = __COPY(&%s, sizeof(%s)), %s, (__attr) {0, __tmp_value})" % (
 
 paul@151   1267 
                encode_path(function_name),
 
 paul@151   1268 
                encode_symbol("obj", function_name),
 
 paul@151   1269 
                ", ".join(defaults)))
 
 paul@113   1270 
 
 paul@113   1271 
    def process_logical_node(self, n):
 
 paul@113   1272 
 
 paul@141   1273 
        """
 
 paul@141   1274 
        Process the given operator node 'n'.
 
 paul@141   1275 
 
 paul@141   1276 
        Convert ... to ...
 
 paul@141   1277 
 
 paul@141   1278 
        <a> and <b>
 
 paul@141   1279 
        (__tmp_result = <a>, !__BOOL(__tmp_result)) ? __tmp_result : <b>
 
 paul@141   1280 
 
 paul@141   1281 
        <a> or <b>
 
 paul@141   1282 
        (__tmp_result = <a>, __BOOL(__tmp_result)) ? __tmp_result : <b>
 
 paul@141   1283 
        """
 
 paul@113   1284 
 
 paul@113   1285 
        if isinstance(n, compiler.ast.And):
 
 paul@141   1286 
            op = "!"
 
 paul@113   1287 
        else:
 
 paul@141   1288 
            op = ""
 
 paul@141   1289 
 
 paul@141   1290 
        results = []
 
 paul@113   1291 
 
 paul@141   1292 
        for node in n.nodes[:-1]:
 
 paul@141   1293 
            expr = self.process_structure_node(node)
 
 paul@141   1294 
            results.append("(__tmp_result = %s, %s__BOOL(__tmp_result)) ? __tmp_result : " % (expr, op))
 
 paul@113   1295 
 
 paul@141   1296 
        expr = self.process_structure_node(n.nodes[-1])
 
 paul@141   1297 
        results.append(str(expr))
 
 paul@141   1298 
 
 paul@141   1299 
        return make_expression("(%s)" % "".join(results))
 
 paul@113   1300 
 
 paul@113   1301 
    def process_name_node(self, n, expr=None):
 
 paul@113   1302 
 
 paul@113   1303 
        "Process the given name node 'n' with the optional assignment 'expr'."
 
 paul@113   1304 
 
 paul@113   1305 
        # Determine whether the name refers to a static external entity.
 
 paul@113   1306 
 
 paul@113   1307 
        if n.name in predefined_constants:
 
 paul@113   1308 
            return PredefinedConstantRef(n.name)
 
 paul@113   1309 
 
 paul@173   1310 
        # Convert literal references, operator function names, and print
 
 paul@173   1311 
        # function names to references.
 
 paul@113   1312 
 
 paul@173   1313 
        elif n.name.startswith("$L") or n.name.startswith("$op") or \
 
 paul@173   1314 
             n.name.startswith("$print"):
 
 paul@136   1315 
            ref = self.importer.get_module(self.name).special.get(n.name)
 
 paul@113   1316 
            return TrResolvedNameRef(n.name, ref)
 
 paul@113   1317 
 
 paul@113   1318 
        # Get the appropriate name for the name reference, using the same method
 
 paul@113   1319 
        # as in the inspector.
 
 paul@113   1320 
 
 paul@250   1321 
        path = self.get_namespace_path()
 
 paul@250   1322 
        objpath = self.get_object_path(n.name)
 
 paul@250   1323 
 
 paul@250   1324 
        # Determine any assigned globals.
 
 paul@250   1325 
 
 paul@250   1326 
        globals = self.importer.get_module(self.name).scope_globals.get(path)
 
 paul@250   1327 
        if globals and n.name in globals:
 
 paul@250   1328 
            objpath = self.get_global_path(n.name)
 
 paul@113   1329 
 
 paul@113   1330 
        # Get the static identity of the name.
 
 paul@113   1331 
 
 paul@250   1332 
        ref = self.importer.identify(objpath)
 
 paul@152   1333 
        if ref and not ref.get_name():
 
 paul@250   1334 
            ref = ref.alias(objpath)
 
 paul@113   1335 
 
 paul@113   1336 
        # Obtain any resolved names for non-assignment names.
 
 paul@113   1337 
 
 paul@113   1338 
        if not expr and not ref and self.in_function:
 
 paul@250   1339 
            locals = self.importer.function_locals.get(path)
 
 paul@113   1340 
            ref = locals and locals.get(n.name)
 
 paul@113   1341 
 
 paul@208   1342 
        # Determine whether the name refers to a parameter. The generation of
 
 paul@208   1343 
        # parameter references is different from other names.
 
 paul@208   1344 
 
 paul@250   1345 
        parameters = self.importer.function_parameters.get(path)
 
 paul@208   1346 
        parameter = n.name == "self" and self.in_method() or \
 
 paul@208   1347 
                    parameters and n.name in parameters
 
 paul@208   1348 
 
 paul@113   1349 
        # Qualified names are used for resolved static references or for
 
 paul@113   1350 
        # static namespace members. The reference should be configured to return
 
 paul@113   1351 
        # such names.
 
 paul@113   1352 
 
 paul@208   1353 
        return TrResolvedNameRef(n.name, ref, expr=expr, parameter=parameter)
 
 paul@113   1354 
 
 paul@113   1355 
    def process_not_node(self, n):
 
 paul@113   1356 
 
 paul@113   1357 
        "Process the given operator node 'n'."
 
 paul@113   1358 
 
 paul@144   1359 
        return make_expression("(__BOOL(%s) ? %s : %s)" %
 
 paul@149   1360 
            (self.process_structure_node(n.expr), PredefinedConstantRef("False"),
 
 paul@149   1361 
            PredefinedConstantRef("True")))
 
 paul@144   1362 
 
 paul@144   1363 
    def process_raise_node(self, n):
 
 paul@144   1364 
 
 paul@144   1365 
        "Process the given raise node 'n'."
 
 paul@144   1366 
 
 paul@144   1367 
        # NOTE: Determine which raise statement variants should be permitted.
 
 paul@144   1368 
 
 paul@176   1369 
        if n.expr1:
 
 paul@317   1370 
            exc = self.process_structure_node(n.expr1)
 
 paul@317   1371 
 
 paul@317   1372 
            # Raise instances, testing the kind at run-time if necessary and
 
 paul@317   1373 
            # instantiating any non-instance.
 
 paul@317   1374 
 
 paul@317   1375 
            if isinstance(exc, TrInstanceRef):
 
 paul@317   1376 
                self.writestmt("__Raise(%s);" % exc)
 
 paul@317   1377 
            else:
 
 paul@317   1378 
                self.writestmt("__Raise(__ensure_instance(%s));" % exc)
 
 paul@176   1379 
        else:
 
 paul@176   1380 
            self.writestmt("__Complete;")
 
 paul@144   1381 
 
 paul@144   1382 
    def process_return_node(self, n):
 
 paul@144   1383 
 
 paul@144   1384 
        "Process the given return node 'n'."
 
 paul@144   1385 
 
 paul@144   1386 
        expr = self.process_structure_node(n.value) or PredefinedConstantRef("None")
 
 paul@189   1387 
        if self.in_try_finally or self.in_try_except:
 
 paul@144   1388 
            self.writestmt("__Return(%s);" % expr)
 
 paul@144   1389 
        else:
 
 paul@144   1390 
            self.writestmt("return %s;" % expr)
 
 paul@144   1391 
 
 paul@144   1392 
        return ReturnRef()
 
 paul@113   1393 
 
 paul@113   1394 
    def process_try_node(self, n):
 
 paul@113   1395 
 
 paul@113   1396 
        """
 
 paul@113   1397 
        Process the given "try...except" node 'n'.
 
 paul@113   1398 
        """
 
 paul@113   1399 
 
 paul@189   1400 
        in_try_except = self.in_try_except
 
 paul@189   1401 
        self.in_try_except = True
 
 paul@189   1402 
 
 paul@144   1403 
        # Use macros to implement exception handling.
 
 paul@113   1404 
 
 paul@144   1405 
        self.writestmt("__Try")
 
 paul@113   1406 
        self.writeline("{")
 
 paul@113   1407 
        self.indent += 1
 
 paul@113   1408 
        self.process_structure_node(n.body)
 
 paul@144   1409 
 
 paul@144   1410 
        # Put the else statement in another try block that handles any raised
 
 paul@144   1411 
        # exceptions and converts them to exceptions that will not be handled by
 
 paul@144   1412 
        # the main handling block.
 
 paul@144   1413 
 
 paul@144   1414 
        if n.else_:
 
 paul@144   1415 
            self.writestmt("__Try")
 
 paul@144   1416 
            self.writeline("{")
 
 paul@144   1417 
            self.indent += 1
 
 paul@144   1418 
            self.process_structure_node(n.else_)
 
 paul@144   1419 
            self.indent -= 1
 
 paul@144   1420 
            self.writeline("}")
 
 paul@144   1421 
            self.writeline("__Catch (__tmp_exc)")
 
 paul@144   1422 
            self.writeline("{")
 
 paul@144   1423 
            self.indent += 1
 
 paul@144   1424 
            self.writeline("if (__tmp_exc.raising) __RaiseElse(__tmp_exc.arg);")
 
 paul@191   1425 
            self.writeline("else if (__tmp_exc.completing) __Throw(__tmp_exc);")
 
 paul@144   1426 
            self.indent -= 1
 
 paul@144   1427 
            self.writeline("}")
 
 paul@144   1428 
 
 paul@144   1429 
        # Complete the try block and enter the finally block, if appropriate.
 
 paul@144   1430 
 
 paul@144   1431 
        if self.in_try_finally:
 
 paul@144   1432 
            self.writestmt("__Complete;")
 
 paul@144   1433 
 
 paul@113   1434 
        self.indent -= 1
 
 paul@113   1435 
        self.writeline("}")
 
 paul@113   1436 
 
 paul@189   1437 
        self.in_try_except = in_try_except
 
 paul@189   1438 
 
 paul@144   1439 
        # Handlers are tests within a common handler block.
 
 paul@144   1440 
 
 paul@144   1441 
        self.writeline("__Catch (__tmp_exc)")
 
 paul@144   1442 
        self.writeline("{")
 
 paul@144   1443 
        self.indent += 1
 
 paul@144   1444 
 
 paul@189   1445 
        # Introduce an if statement to handle the completion of a try block.
 
 paul@189   1446 
 
 paul@189   1447 
        self.process_try_completion()
 
 paul@189   1448 
 
 paul@144   1449 
        # Handle exceptions in else blocks converted to __RaiseElse, converting
 
 paul@144   1450 
        # them back to normal exceptions.
 
 paul@144   1451 
 
 paul@144   1452 
        if n.else_:
 
 paul@189   1453 
            self.writeline("else if (__tmp_exc.raising_else) __Raise(__tmp_exc.arg);")
 
 paul@144   1454 
 
 paul@144   1455 
        # Exception handling.
 
 paul@144   1456 
 
 paul@113   1457 
        for name, var, handler in n.handlers:
 
 paul@144   1458 
 
 paul@144   1459 
            # Test for specific exceptions.
 
 paul@144   1460 
 
 paul@113   1461 
            if name is not None:
 
 paul@113   1462 
                name_ref = self.process_structure_node(name)
 
 paul@191   1463 
                self.writeline("else if (__BOOL(__fn_native__isinstance((__attr[]) {{0, 0}, __tmp_exc.arg, %s})))" % name_ref)
 
 paul@144   1464 
            else:
 
 paul@189   1465 
                self.writeline("else if (1)")
 
 paul@113   1466 
 
 paul@113   1467 
            self.writeline("{")
 
 paul@113   1468 
            self.indent += 1
 
 paul@113   1469 
 
 paul@113   1470 
            # Establish the local for the handler.
 
 paul@113   1471 
 
 paul@113   1472 
            if var is not None:
 
 paul@261   1473 
                self.writestmt("%s;" % self.process_name_node(var, make_expression("__tmp_exc.arg")))
 
 paul@113   1474 
 
 paul@113   1475 
            if handler is not None:
 
 paul@113   1476 
                self.process_structure_node(handler)
 
 paul@113   1477 
 
 paul@113   1478 
            self.indent -= 1
 
 paul@113   1479 
            self.writeline("}")
 
 paul@113   1480 
 
 paul@144   1481 
        # Re-raise unhandled exceptions.
 
 paul@144   1482 
 
 paul@189   1483 
        self.writeline("else __Throw(__tmp_exc);")
 
 paul@144   1484 
 
 paul@144   1485 
        # End the handler block.
 
 paul@144   1486 
 
 paul@144   1487 
        self.indent -= 1
 
 paul@144   1488 
        self.writeline("}")
 
 paul@113   1489 
 
 paul@113   1490 
    def process_try_finally_node(self, n):
 
 paul@113   1491 
 
 paul@113   1492 
        """
 
 paul@113   1493 
        Process the given "try...finally" node 'n'.
 
 paul@113   1494 
        """
 
 paul@113   1495 
 
 paul@144   1496 
        in_try_finally = self.in_try_finally
 
 paul@144   1497 
        self.in_try_finally = True
 
 paul@113   1498 
 
 paul@144   1499 
        # Use macros to implement exception handling.
 
 paul@144   1500 
 
 paul@144   1501 
        self.writestmt("__Try")
 
 paul@113   1502 
        self.writeline("{")
 
 paul@113   1503 
        self.indent += 1
 
 paul@113   1504 
        self.process_structure_node(n.body)
 
 paul@113   1505 
        self.indent -= 1
 
 paul@113   1506 
        self.writeline("}")
 
 paul@144   1507 
 
 paul@144   1508 
        self.in_try_finally = in_try_finally
 
 paul@144   1509 
 
 paul@144   1510 
        # Finally clauses handle special exceptions.
 
 paul@144   1511 
 
 paul@144   1512 
        self.writeline("__Catch (__tmp_exc)")
 
 paul@113   1513 
        self.writeline("{")
 
 paul@113   1514 
        self.indent += 1
 
 paul@113   1515 
        self.process_structure_node(n.final)
 
 paul@144   1516 
 
 paul@189   1517 
        # Introduce an if statement to handle the completion of a try block.
 
 paul@189   1518 
 
 paul@189   1519 
        self.process_try_completion()
 
 paul@189   1520 
        self.writeline("else __Throw(__tmp_exc);")
 
 paul@189   1521 
 
 paul@189   1522 
        self.indent -= 1
 
 paul@189   1523 
        self.writeline("}")
 
 paul@189   1524 
 
 paul@189   1525 
    def process_try_completion(self):
 
 paul@189   1526 
 
 paul@189   1527 
        "Generate a test for the completion of a try block."
 
 paul@144   1528 
 
 paul@144   1529 
        self.writestmt("if (__tmp_exc.completing)")
 
 paul@144   1530 
        self.writeline("{")
 
 paul@144   1531 
        self.indent += 1
 
 paul@189   1532 
 
 paul@316   1533 
        # Do not return anything at the module level.
 
 paul@316   1534 
 
 paul@316   1535 
        if self.get_namespace_path() != self.name:
 
 paul@189   1536 
 
 paul@316   1537 
            # Only use the normal return statement if no surrounding try blocks
 
 paul@316   1538 
            # apply.
 
 paul@316   1539 
 
 paul@316   1540 
            if not self.in_try_finally and not self.in_try_except:
 
 paul@316   1541 
                self.writeline("if (!__ISNULL(__tmp_exc.arg)) return __tmp_exc.arg;")
 
 paul@316   1542 
            else:
 
 paul@316   1543 
                self.writeline("if (!__ISNULL(__tmp_exc.arg)) __Throw(__tmp_exc);")
 
 paul@144   1544 
 
 paul@113   1545 
        self.indent -= 1
 
 paul@113   1546 
        self.writeline("}")
 
 paul@113   1547 
 
 paul@113   1548 
    def process_while_node(self, n):
 
 paul@113   1549 
 
 paul@113   1550 
        "Process the given while node 'n'."
 
 paul@113   1551 
 
 paul@113   1552 
        self.writeline("while (1)")
 
 paul@113   1553 
        self.writeline("{")
 
 paul@113   1554 
        self.indent += 1
 
 paul@113   1555 
        test = self.process_structure_node(n.test)
 
 paul@113   1556 
 
 paul@113   1557 
        # Emit the loop termination condition unless "while <true value>" is
 
 paul@113   1558 
        # indicated.
 
 paul@113   1559 
 
 paul@113   1560 
        if not (isinstance(test, PredefinedConstantRef) and test.value):
 
 paul@113   1561 
 
 paul@113   1562 
            # NOTE: This needs to evaluate whether the operand is true or false
 
 paul@113   1563 
            # NOTE: according to Python rules.
 
 paul@113   1564 
 
 paul@144   1565 
            self.writeline("if (!__BOOL(%s))" % test)
 
 paul@113   1566 
            self.writeline("{")
 
 paul@113   1567 
            self.indent += 1
 
 paul@113   1568 
            if n.else_:
 
 paul@113   1569 
                self.process_structure_node(n.else_)
 
 paul@128   1570 
            self.writestmt("break;")
 
 paul@113   1571 
            self.indent -= 1
 
 paul@113   1572 
            self.writeline("}")
 
 paul@113   1573 
 
 paul@113   1574 
        in_conditional = self.in_conditional
 
 paul@113   1575 
        self.in_conditional = True
 
 paul@113   1576 
        self.process_structure_node(n.body)
 
 paul@113   1577 
        self.in_conditional = in_conditional
 
 paul@113   1578 
 
 paul@113   1579 
        self.indent -= 1
 
 paul@113   1580 
        self.writeline("}")
 
 paul@113   1581 
 
 paul@113   1582 
    # Output generation.
 
 paul@113   1583 
 
 paul@128   1584 
    def start_output(self):
 
 paul@159   1585 
 
 paul@159   1586 
        "Write the declarations at the top of each source file."
 
 paul@159   1587 
 
 paul@128   1588 
        print >>self.out, """\
 
 paul@128   1589 
#include "types.h"
 
 paul@144   1590 
#include "exceptions.h"
 
 paul@128   1591 
#include "ops.h"
 
 paul@128   1592 
#include "progconsts.h"
 
 paul@128   1593 
#include "progops.h"
 
 paul@128   1594 
#include "progtypes.h"
 
 paul@137   1595 
#include "main.h"
 
 paul@128   1596 
"""
 
 paul@128   1597 
 
 paul@113   1598 
    def start_module(self):
 
 paul@159   1599 
 
 paul@159   1600 
        "Write the start of each module's main function."
 
 paul@159   1601 
 
 paul@113   1602 
        print >>self.out, "void __main_%s()" % encode_path(self.name)
 
 paul@113   1603 
        print >>self.out, "{"
 
 paul@113   1604 
        self.indent += 1
 
 paul@192   1605 
        self.write_temporaries(self.importer.function_targets.get(self.name))
 
 paul@113   1606 
 
 paul@113   1607 
    def end_module(self):
 
 paul@159   1608 
 
 paul@159   1609 
        "End each module by closing its main function."
 
 paul@159   1610 
 
 paul@113   1611 
        self.indent -= 1
 
 paul@144   1612 
        print >>self.out, "}"
 
 paul@113   1613 
 
 paul@113   1614 
    def start_function(self, name):
 
 paul@159   1615 
 
 paul@159   1616 
        "Start the function having the given 'name'."
 
 paul@159   1617 
 
 paul@113   1618 
        print >>self.out, "__attr %s(__attr __args[])" % encode_function_pointer(name)
 
 paul@113   1619 
        print >>self.out, "{"
 
 paul@113   1620 
        self.indent += 1
 
 paul@192   1621 
        self.write_temporaries(self.importer.function_targets.get(name))
 
 paul@113   1622 
 
 paul@113   1623 
        # Obtain local names from parameters.
 
 paul@113   1624 
 
 paul@113   1625 
        parameters = self.importer.function_parameters[name]
 
 paul@144   1626 
        locals = self.importer.function_locals[name].keys()
 
 paul@113   1627 
        names = []
 
 paul@113   1628 
 
 paul@113   1629 
        for n in locals:
 
 paul@113   1630 
 
 paul@113   1631 
            # Filter out special names and parameters. Note that self is a local
 
 paul@113   1632 
            # regardless of whether it originally appeared in the parameters or
 
 paul@113   1633 
            # not.
 
 paul@113   1634 
 
 paul@113   1635 
            if n.startswith("$l") or n in parameters or n == "self":
 
 paul@113   1636 
                continue
 
 paul@113   1637 
            names.append(encode_path(n))
 
 paul@113   1638 
 
 paul@113   1639 
        # Emit required local names.
 
 paul@113   1640 
 
 paul@113   1641 
        if names:
 
 paul@113   1642 
            names.sort()
 
 paul@113   1643 
            self.writeline("__attr %s;" % ", ".join(names))
 
 paul@113   1644 
 
 paul@208   1645 
        self.write_parameters(name)
 
 paul@144   1646 
 
 paul@144   1647 
    def end_function(self, name):
 
 paul@159   1648 
 
 paul@159   1649 
        "End the function having the given 'name'."
 
 paul@159   1650 
 
 paul@144   1651 
        self.indent -= 1
 
 paul@144   1652 
        print >>self.out, "}"
 
 paul@144   1653 
        print >>self.out
 
 paul@144   1654 
 
 paul@192   1655 
    def write_temporaries(self, targets):
 
 paul@159   1656 
 
 paul@192   1657 
        """
 
 paul@192   1658 
        Write temporary storage employed by functions, providing space for the
 
 paul@192   1659 
        given number of 'targets'.
 
 paul@192   1660 
        """
 
 paul@192   1661 
 
 paul@192   1662 
        targets = targets is not None and "__tmp_targets[%d], " % targets or ""
 
 paul@159   1663 
 
 paul@149   1664 
        self.writeline("__ref __tmp_context, __tmp_value;")
 
 paul@192   1665 
        self.writeline("__attr %s__tmp_result;" % targets)
 
 paul@149   1666 
        self.writeline("__exc __tmp_exc;")
 
 paul@149   1667 
 
 paul@208   1668 
    def write_parameters(self, name):
 
 paul@159   1669 
 
 paul@159   1670 
        """
 
 paul@159   1671 
        For the function having the given 'name', write definitions of
 
 paul@208   1672 
        parameters found in the arguments array.
 
 paul@159   1673 
        """
 
 paul@159   1674 
 
 paul@144   1675 
        parameters = self.importer.function_parameters[name]
 
 paul@144   1676 
 
 paul@113   1677 
        # Generate any self reference.
 
 paul@113   1678 
 
 paul@156   1679 
        if self.is_method(name):
 
 paul@208   1680 
            self.writeline("__attr * const self = &__args[0];")
 
 paul@113   1681 
 
 paul@113   1682 
        # Generate aliases for the parameters.
 
 paul@113   1683 
 
 paul@113   1684 
        for i, parameter in enumerate(parameters):
 
 paul@208   1685 
            self.writeline("__attr * const %s = &__args[%d];" % (encode_path(parameter), i+1))
 
 paul@113   1686 
 
 paul@113   1687 
    def start_if(self, first, test_ref):
 
 paul@144   1688 
        self.writestmt("%sif (__BOOL(%s))" % (not first and "else " or "", test_ref))
 
 paul@113   1689 
        self.writeline("{")
 
 paul@113   1690 
        self.indent += 1
 
 paul@113   1691 
 
 paul@113   1692 
    def end_if(self):
 
 paul@113   1693 
        self.indent -= 1
 
 paul@113   1694 
        self.writeline("}")
 
 paul@113   1695 
 
 paul@113   1696 
    def start_else(self):
 
 paul@113   1697 
        self.writeline("else")
 
 paul@113   1698 
        self.writeline("{")
 
 paul@113   1699 
        self.indent += 1
 
 paul@113   1700 
 
 paul@113   1701 
    def end_else(self):
 
 paul@113   1702 
        self.indent -= 1
 
 paul@113   1703 
        self.writeline("}")
 
 paul@113   1704 
 
 paul@113   1705 
    def statement(self, expr):
 
 paul@113   1706 
        # NOTE: Should never be None.
 
 paul@113   1707 
        if not expr:
 
 paul@128   1708 
            self.writestmt("...;")
 
 paul@113   1709 
        s = str(expr)
 
 paul@113   1710 
        if s:
 
 paul@128   1711 
            self.writestmt("%s;" % s)
 
 paul@113   1712 
 
 paul@113   1713 
    def statements(self, results):
 
 paul@113   1714 
        for result in results:
 
 paul@113   1715 
            self.statement(result)
 
 paul@113   1716 
 
 paul@159   1717 
    def writeline(self, s):
 
 paul@159   1718 
        print >>self.out, "%s%s" % (self.pad(), self.indenttext(s, self.indent + 1))
 
 paul@159   1719 
 
 paul@159   1720 
    def writestmt(self, s):
 
 paul@159   1721 
        print >>self.out
 
 paul@159   1722 
        self.writeline(s)
 
 paul@159   1723 
 
 paul@159   1724 
    def write_comment(self, s):
 
 paul@159   1725 
        self.writestmt("/* %s */" % s)
 
 paul@159   1726 
 
 paul@113   1727 
    def pad(self, extra=0):
 
 paul@113   1728 
        return (self.indent + extra) * self.tabstop
 
 paul@113   1729 
 
 paul@113   1730 
    def indenttext(self, s, levels):
 
 paul@116   1731 
        lines = s.split("\n")
 
 paul@116   1732 
        out = [lines[0]]
 
 paul@116   1733 
        for line in lines[1:]:
 
 paul@116   1734 
            out.append(levels * self.tabstop + line)
 
 paul@116   1735 
            if line.endswith("("):
 
 paul@116   1736 
                levels += 1
 
 paul@122   1737 
            elif line.startswith(")"):
 
 paul@116   1738 
                levels -= 1
 
 paul@116   1739 
        return "\n".join(out)
 
 paul@113   1740 
 
 paul@113   1741 
# vim: tabstop=4 expandtab shiftwidth=4