Lichen

Annotated translator.py

116:0fcb1351544e
114:a818b7ef8f7b
113:4ad5dbbc7cc8
2016-10-20 Paul Boddie file changeset files shortlog Added some more test cases including one featuring a "broken" attribute chain.
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@113     26 
import compiler
 
 paul@113     27 
import results
 
 paul@113     28 
 
 paul@113     29 
class Translator(CommonOutput):
 
 paul@113     30 
 
 paul@113     31 
    "A program translator."
 
 paul@113     32 
 
 paul@113     33 
    def __init__(self, importer, deducer, optimiser, output):
 
 paul@113     34 
        self.importer = importer
 
 paul@113     35 
        self.deducer = deducer
 
 paul@113     36 
        self.optimiser = optimiser
 
 paul@113     37 
        self.output = output
 
 paul@113     38 
 
 paul@113     39 
    def to_output(self):
 
 paul@113     40 
        output = join(self.output, "src")
 
 paul@113     41 
 
 paul@113     42 
        if not exists(output):
 
 paul@113     43 
            makedirs(output)
 
 paul@113     44 
 
 paul@113     45 
        self.check_output()
 
 paul@113     46 
 
 paul@113     47 
        for module in self.importer.modules.values():
 
 paul@113     48 
            tm = TranslatedModule(module.name, self.importer, self.deducer, self.optimiser)
 
 paul@113     49 
            tm.translate(module.filename, join(output, "%s.c" % module.name))
 
 paul@113     50 
 
 paul@113     51 
# Classes representing intermediate translation results.
 
 paul@113     52 
 
 paul@113     53 
class TranslationResult:
 
 paul@113     54 
 
 paul@113     55 
    "An abstract translation result mix-in."
 
 paul@113     56 
 
 paul@113     57 
    pass
 
 paul@113     58 
 
 paul@113     59 
class Expression(results.Result, TranslationResult):
 
 paul@113     60 
 
 paul@113     61 
    "A general expression."
 
 paul@113     62 
 
 paul@113     63 
    def __init__(self, s):
 
 paul@113     64 
        self.s = s
 
 paul@113     65 
    def __str__(self):
 
 paul@113     66 
        return self.s
 
 paul@113     67 
    def __repr__(self):
 
 paul@113     68 
        return "Expression(%r)" % self.s
 
 paul@113     69 
 
 paul@113     70 
class TrResolvedNameRef(results.ResolvedNameRef, TranslationResult):
 
 paul@113     71 
 
 paul@113     72 
    "A reference to a name in the translation."
 
 paul@113     73 
 
 paul@113     74 
    def __str__(self):
 
 paul@113     75 
 
 paul@113     76 
        "Return an output representation of the referenced name."
 
 paul@113     77 
 
 paul@113     78 
        # Use any alias in preference to the origin of the name.
 
 paul@113     79 
 
 paul@113     80 
        name = self.get_name()
 
 paul@113     81 
 
 paul@113     82 
        # Use any static origin in preference to any alias.
 
 paul@113     83 
        # For sources, any identified static origin will be constant and thus
 
 paul@113     84 
        # usable directly. For targets, no constant should be assigned and thus
 
 paul@113     85 
        # the alias (or any plain name) will be used.
 
 paul@113     86 
 
 paul@113     87 
        origin = self.static() and self.get_origin()
 
 paul@113     88 
        name = origin and encode_path(origin) or name and encode_path(name) or encode_path(self.name)
 
 paul@113     89 
 
 paul@113     90 
        # Assignments.
 
 paul@113     91 
 
 paul@113     92 
        if self.expr:
 
 paul@113     93 
 
 paul@113     94 
            # Eliminate assignments between constants.
 
 paul@113     95 
 
 paul@113     96 
            if self.static() and isinstance(self.expr, results.ResolvedNameRef) and self.expr.static():
 
 paul@113     97 
                return ""
 
 paul@113     98 
            else:
 
 paul@113     99 
                return "%s = %s" % (name, self.expr)
 
 paul@113    100 
 
 paul@113    101 
        # Expressions.
 
 paul@113    102 
 
 paul@113    103 
        else:
 
 paul@113    104 
            return name
 
 paul@113    105 
 
 paul@113    106 
class TrConstantValueRef(results.ConstantValueRef, TranslationResult):
 
 paul@113    107 
 
 paul@113    108 
    "A constant value reference in the translation."
 
 paul@113    109 
 
 paul@113    110 
    def __str__(self):
 
 paul@113    111 
        return "const%d" % self.number
 
 paul@113    112 
 
 paul@113    113 
class TrLiteralSequenceRef(results.LiteralSequenceRef, TranslationResult):
 
 paul@113    114 
 
 paul@113    115 
    "A reference representing a sequence of values."
 
 paul@113    116 
 
 paul@113    117 
    def __str__(self):
 
 paul@113    118 
        return str(self.node)
 
 paul@113    119 
 
 paul@113    120 
class AttrResult(Expression, TranslationResult):
 
 paul@113    121 
 
 paul@113    122 
    "A translation result for an attribute access."
 
 paul@113    123 
 
 paul@113    124 
    def __init__(self, s, refs):
 
 paul@113    125 
        Expression.__init__(self, s)
 
 paul@113    126 
        self.refs = refs
 
 paul@113    127 
 
 paul@113    128 
    def get_origin(self):
 
 paul@113    129 
        return self.refs and len(self.refs) == 1 and first(self.refs).get_origin()
 
 paul@113    130 
 
 paul@113    131 
    def __repr__(self):
 
 paul@113    132 
        return "AttrResult(%r, %r)" % (self.s, self.origin)
 
 paul@113    133 
 
 paul@113    134 
class PredefinedConstantRef(AttrResult):
 
 paul@113    135 
 
 paul@113    136 
    "A predefined constant reference."
 
 paul@113    137 
 
 paul@113    138 
    def __init__(self, value):
 
 paul@113    139 
        self.value = value
 
 paul@113    140 
        self.only_function_attrs = False
 
 paul@113    141 
 
 paul@113    142 
    def __str__(self):
 
 paul@113    143 
        return self.value
 
 paul@113    144 
 
 paul@113    145 
    def __repr__(self):
 
 paul@113    146 
        return "PredefinedConstantRef(%r)" % self.value
 
 paul@113    147 
 
 paul@113    148 
def make_expression(expr):
 
 paul@113    149 
 
 paul@113    150 
    "Make a new expression from the existing 'expr'."
 
 paul@113    151 
 
 paul@113    152 
    if isinstance(expr, results.Result):
 
 paul@113    153 
        return expr
 
 paul@113    154 
    else:
 
 paul@113    155 
        return Expression(str(expr))
 
 paul@113    156 
 
 paul@113    157 
# The actual translation process itself.
 
 paul@113    158 
 
 paul@113    159 
class TranslatedModule(CommonModule):
 
 paul@113    160 
 
 paul@113    161 
    "A module translator."
 
 paul@113    162 
 
 paul@113    163 
    def __init__(self, name, importer, deducer, optimiser):
 
 paul@113    164 
        CommonModule.__init__(self, name, importer)
 
 paul@113    165 
        self.deducer = deducer
 
 paul@113    166 
        self.optimiser = optimiser
 
 paul@113    167 
 
 paul@113    168 
        # Output stream.
 
 paul@113    169 
 
 paul@113    170 
        self.out = None
 
 paul@113    171 
        self.indent = 0
 
 paul@113    172 
        self.tabstop = "    "
 
 paul@113    173 
 
 paul@113    174 
        # Recorded namespaces.
 
 paul@113    175 
 
 paul@113    176 
        self.namespaces = []
 
 paul@113    177 
        self.in_conditional = False
 
 paul@113    178 
 
 paul@113    179 
        # Attribute access counting.
 
 paul@113    180 
 
 paul@113    181 
        self.attr_accesses = {}
 
 paul@113    182 
 
 paul@113    183 
    def __repr__(self):
 
 paul@113    184 
        return "TranslatedModule(%r, %r)" % (self.name, self.importer)
 
 paul@113    185 
 
 paul@113    186 
    def translate(self, filename, output_filename):
 
 paul@113    187 
 
 paul@113    188 
        """
 
 paul@113    189 
        Parse the file having the given 'filename', writing the translation to
 
 paul@113    190 
        the given 'output_filename'.
 
 paul@113    191 
        """
 
 paul@113    192 
 
 paul@113    193 
        self.parse_file(filename)
 
 paul@113    194 
 
 paul@113    195 
        # Collect function namespaces for separate processing.
 
 paul@113    196 
 
 paul@113    197 
        self.record_namespaces(self.astnode)
 
 paul@113    198 
 
 paul@113    199 
        # Reset the lambda naming (in order to obtain the same names again) and
 
 paul@113    200 
        # translate the program.
 
 paul@113    201 
 
 paul@113    202 
        self.reset_lambdas()
 
 paul@113    203 
 
 paul@113    204 
        self.out = open(output_filename, "w")
 
 paul@113    205 
        try:
 
 paul@113    206 
            # Process namespaces, writing the translation.
 
 paul@113    207 
 
 paul@113    208 
            for path, node in self.namespaces:
 
 paul@113    209 
                self.process_namespace(path, node)
 
 paul@113    210 
 
 paul@113    211 
            # Process the module namespace including class namespaces.
 
 paul@113    212 
 
 paul@113    213 
            self.process_namespace([], self.astnode)
 
 paul@113    214 
 
 paul@113    215 
        finally:
 
 paul@113    216 
            self.out.close()
 
 paul@113    217 
 
 paul@113    218 
    def have_object(self):
 
 paul@113    219 
 
 paul@113    220 
        "Return whether a namespace is a recorded object."
 
 paul@113    221 
 
 paul@113    222 
        return self.importer.objects.get(self.get_namespace_path())
 
 paul@113    223 
 
 paul@113    224 
    def get_builtin(self, name):
 
 paul@113    225 
        return self.importer.get_object("__builtins__.%s" % name)
 
 paul@113    226 
 
 paul@113    227 
    def in_method(self, path):
 
 paul@113    228 
        class_name, method_name = path.rsplit(".", 1)
 
 paul@113    229 
        return self.importer.classes.has_key(class_name) and class_name
 
 paul@113    230 
 
 paul@113    231 
    # Namespace recording.
 
 paul@113    232 
 
 paul@113    233 
    def record_namespaces(self, node):
 
 paul@113    234 
 
 paul@113    235 
        "Process the program structure 'node', recording namespaces."
 
 paul@113    236 
 
 paul@113    237 
        for n in node.getChildNodes():
 
 paul@113    238 
            self.record_namespaces_in_node(n)
 
 paul@113    239 
 
 paul@113    240 
    def record_namespaces_in_node(self, node):
 
 paul@113    241 
 
 paul@113    242 
        "Process the program structure 'node', recording namespaces."
 
 paul@113    243 
 
 paul@113    244 
        # Function namespaces within modules, classes and other functions.
 
 paul@113    245 
        # Functions appearing within conditional statements are given arbitrary
 
 paul@113    246 
        # names.
 
 paul@113    247 
 
 paul@113    248 
        if isinstance(node, compiler.ast.Function):
 
 paul@113    249 
            self.record_function_node(node, (self.in_conditional or self.in_function) and self.get_lambda_name() or node.name)
 
 paul@113    250 
 
 paul@113    251 
        elif isinstance(node, compiler.ast.Lambda):
 
 paul@113    252 
            self.record_function_node(node, self.get_lambda_name())
 
 paul@113    253 
 
 paul@113    254 
        # Classes are visited, but may be ignored if inside functions.
 
 paul@113    255 
 
 paul@113    256 
        elif isinstance(node, compiler.ast.Class):
 
 paul@113    257 
            self.enter_namespace(node.name)
 
 paul@113    258 
            if self.have_object():
 
 paul@113    259 
                self.record_namespaces(node)
 
 paul@113    260 
            self.exit_namespace()
 
 paul@113    261 
 
 paul@113    262 
        # Conditional nodes are tracked so that function definitions may be
 
 paul@113    263 
        # handled. Since "for" loops are converted to "while" loops, they are
 
 paul@113    264 
        # included here.
 
 paul@113    265 
 
 paul@113    266 
        elif isinstance(node, (compiler.ast.For, compiler.ast.If, compiler.ast.While)):
 
 paul@113    267 
            in_conditional = self.in_conditional
 
 paul@113    268 
            self.in_conditional = True
 
 paul@113    269 
            self.record_namespaces(node)
 
 paul@113    270 
            self.in_conditional = in_conditional
 
 paul@113    271 
 
 paul@113    272 
        # All other nodes are processed depth-first.
 
 paul@113    273 
 
 paul@113    274 
        else:
 
 paul@113    275 
            self.record_namespaces(node)
 
 paul@113    276 
 
 paul@113    277 
    def record_function_node(self, n, name):
 
 paul@113    278 
 
 paul@113    279 
        """
 
 paul@113    280 
        Record the given function, lambda, if expression or list comprehension
 
 paul@113    281 
        node 'n' with the given 'name'.
 
 paul@113    282 
        """
 
 paul@113    283 
 
 paul@113    284 
        self.in_function = True
 
 paul@113    285 
        self.enter_namespace(name)
 
 paul@113    286 
 
 paul@113    287 
        if self.have_object():
 
 paul@113    288 
 
 paul@113    289 
            # Record the namespace path and the node itself.
 
 paul@113    290 
 
 paul@113    291 
            self.namespaces.append((self.namespace_path[:], n))
 
 paul@113    292 
            self.record_namespaces_in_node(n.code)
 
 paul@113    293 
 
 paul@113    294 
        self.exit_namespace()
 
 paul@113    295 
        self.in_function = False
 
 paul@113    296 
 
 paul@113    297 
    # Constant referencing.
 
 paul@113    298 
 
 paul@113    299 
    def get_literal_instance(self, n, name):
 
 paul@113    300 
 
 paul@113    301 
        """
 
 paul@113    302 
        For node 'n', return a reference for the type of the given 'name'.
 
 paul@113    303 
        """
 
 paul@113    304 
 
 paul@113    305 
        ref = self.get_builtin(name)
 
 paul@113    306 
 
 paul@113    307 
        if name in ("dict", "list", "tuple"):
 
 paul@113    308 
            return self.process_literal_sequence_node(n, name, ref, TrLiteralSequenceRef)
 
 paul@113    309 
        else:
 
 paul@113    310 
            path = self.get_namespace_path()
 
 paul@113    311 
            local_number = self.importer.all_constants[path][n.value]
 
 paul@113    312 
            constant_name = "$c%d" % local_number
 
 paul@113    313 
            objpath = self.get_object_path(constant_name)
 
 paul@113    314 
            number = self.optimiser.constant_numbers[objpath]
 
 paul@113    315 
            return TrConstantValueRef(constant_name, ref.instance_of(), n.value, number)
 
 paul@113    316 
 
 paul@113    317 
    # Namespace translation.
 
 paul@113    318 
 
 paul@113    319 
    def process_namespace(self, path, node):
 
 paul@113    320 
 
 paul@113    321 
        """
 
 paul@113    322 
        Process the namespace for the given 'path' defined by the given 'node'.
 
 paul@113    323 
        """
 
 paul@113    324 
 
 paul@113    325 
        self.namespace_path = path
 
 paul@113    326 
 
 paul@113    327 
        if isinstance(node, (compiler.ast.Function, compiler.ast.Lambda)):
 
 paul@113    328 
            self.in_function = True
 
 paul@113    329 
            self.process_function_body_node(node)
 
 paul@113    330 
        else:
 
 paul@113    331 
            self.in_function = False
 
 paul@113    332 
            self.invocation_depth = 0
 
 paul@113    333 
            self.invocation_argument_depth = 0
 
 paul@113    334 
            self.invocation_kw_argument_depth = 0
 
 paul@113    335 
            self.start_module()
 
 paul@113    336 
            self.process_structure(node)
 
 paul@113    337 
            self.end_module()
 
 paul@113    338 
 
 paul@113    339 
    def process_structure(self, node):
 
 paul@113    340 
 
 paul@113    341 
        "Process the given 'node' or result."
 
 paul@113    342 
 
 paul@113    343 
        if isinstance(node, results.Result):
 
 paul@113    344 
            return node
 
 paul@113    345 
        else:
 
 paul@113    346 
            return CommonModule.process_structure(self, node)
 
 paul@113    347 
 
 paul@113    348 
    def process_structure_node(self, n):
 
 paul@113    349 
 
 paul@113    350 
        "Process the individual node 'n'."
 
 paul@113    351 
 
 paul@113    352 
        # Plain statements emit their expressions.
 
 paul@113    353 
 
 paul@113    354 
        if isinstance(n, compiler.ast.Discard):
 
 paul@113    355 
            expr = self.process_structure_node(n.expr)
 
 paul@113    356 
            self.statement(expr)
 
 paul@113    357 
 
 paul@113    358 
        # Nodes using operator module functions.
 
 paul@113    359 
 
 paul@113    360 
        elif isinstance(n, compiler.ast.Operator):
 
 paul@113    361 
            return self.process_operator_node(n)
 
 paul@113    362 
 
 paul@113    363 
        elif isinstance(n, compiler.ast.AugAssign):
 
 paul@113    364 
            self.process_augassign_node(n)
 
 paul@113    365 
 
 paul@113    366 
        elif isinstance(n, compiler.ast.Compare):
 
 paul@113    367 
            return self.process_compare_node(n)
 
 paul@113    368 
 
 paul@113    369 
        elif isinstance(n, compiler.ast.Slice):
 
 paul@113    370 
            return self.process_slice_node(n)
 
 paul@113    371 
 
 paul@113    372 
        elif isinstance(n, compiler.ast.Sliceobj):
 
 paul@113    373 
            return self.process_sliceobj_node(n)
 
 paul@113    374 
 
 paul@113    375 
        elif isinstance(n, compiler.ast.Subscript):
 
 paul@113    376 
            return self.process_subscript_node(n)
 
 paul@113    377 
 
 paul@113    378 
        # Classes are visited, but may be ignored if inside functions.
 
 paul@113    379 
 
 paul@113    380 
        elif isinstance(n, compiler.ast.Class):
 
 paul@113    381 
            self.process_class_node(n)
 
 paul@113    382 
 
 paul@113    383 
        # Functions within namespaces have any dynamic defaults initialised.
 
 paul@113    384 
 
 paul@113    385 
        elif isinstance(n, compiler.ast.Function):
 
 paul@113    386 
            self.process_function_node(n)
 
 paul@113    387 
 
 paul@113    388 
        # Lambdas are replaced with references to separately-generated
 
 paul@113    389 
        # functions.
 
 paul@113    390 
 
 paul@113    391 
        elif isinstance(n, compiler.ast.Lambda):
 
 paul@113    392 
            return self.process_lambda_node(n)
 
 paul@113    393 
 
 paul@113    394 
        # Assignments.
 
 paul@113    395 
 
 paul@113    396 
        elif isinstance(n, compiler.ast.Assign):
 
 paul@113    397 
 
 paul@113    398 
            # Handle each assignment node.
 
 paul@113    399 
 
 paul@113    400 
            for node in n.nodes:
 
 paul@113    401 
                self.process_assignment_node(node, n.expr)
 
 paul@113    402 
 
 paul@113    403 
        # Assignments within non-Assign nodes.
 
 paul@113    404 
        # NOTE: Cover all possible nodes employing these.
 
 paul@113    405 
 
 paul@113    406 
        elif isinstance(n, compiler.ast.AssName):
 
 paul@113    407 
            self.process_assignment_node(n, compiler.ast.Name("$temp"))
 
 paul@113    408 
 
 paul@113    409 
        elif isinstance(n, compiler.ast.AssAttr):
 
 paul@113    410 
            self.process_attribute_access(n)
 
 paul@113    411 
 
 paul@113    412 
        # Accesses.
 
 paul@113    413 
 
 paul@113    414 
        elif isinstance(n, compiler.ast.Getattr):
 
 paul@113    415 
            return self.process_attribute_access(n)
 
 paul@113    416 
 
 paul@113    417 
        # Names.
 
 paul@113    418 
 
 paul@113    419 
        elif isinstance(n, compiler.ast.Name):
 
 paul@113    420 
            return self.process_name_node(n)
 
 paul@113    421 
 
 paul@113    422 
        # Loops and conditionals.
 
 paul@113    423 
 
 paul@113    424 
        elif isinstance(n, compiler.ast.For):
 
 paul@113    425 
            self.process_for_node(n)
 
 paul@113    426 
 
 paul@113    427 
        elif isinstance(n, compiler.ast.While):
 
 paul@113    428 
            self.process_while_node(n)
 
 paul@113    429 
 
 paul@113    430 
        elif isinstance(n, compiler.ast.If):
 
 paul@113    431 
            self.process_if_node(n)
 
 paul@113    432 
 
 paul@113    433 
        elif isinstance(n, (compiler.ast.And, compiler.ast.Or)):
 
 paul@113    434 
            return self.process_logical_node(n)
 
 paul@113    435 
 
 paul@113    436 
        elif isinstance(n, compiler.ast.Not):
 
 paul@113    437 
            return self.process_not_node(n)
 
 paul@113    438 
 
 paul@113    439 
        # Exception control-flow tracking.
 
 paul@113    440 
 
 paul@113    441 
        elif isinstance(n, compiler.ast.TryExcept):
 
 paul@113    442 
            self.process_try_node(n)
 
 paul@113    443 
 
 paul@113    444 
        elif isinstance(n, compiler.ast.TryFinally):
 
 paul@113    445 
            self.process_try_finally_node(n)
 
 paul@113    446 
 
 paul@113    447 
        # Control-flow modification statements.
 
 paul@113    448 
 
 paul@113    449 
        elif isinstance(n, compiler.ast.Break):
 
 paul@113    450 
            self.writeline("break;")
 
 paul@113    451 
 
 paul@113    452 
        elif isinstance(n, compiler.ast.Continue):
 
 paul@113    453 
            self.writeline("continue;")
 
 paul@113    454 
 
 paul@113    455 
        elif isinstance(n, compiler.ast.Return):
 
 paul@113    456 
            expr = self.process_structure_node(n.value)
 
 paul@113    457 
            if expr:
 
 paul@113    458 
                self.writeline("return %s;" % expr)
 
 paul@113    459 
            else:
 
 paul@113    460 
                self.writeline("return;")
 
 paul@113    461 
 
 paul@113    462 
        # Invocations.
 
 paul@113    463 
 
 paul@113    464 
        elif isinstance(n, compiler.ast.CallFunc):
 
 paul@113    465 
            return self.process_invocation_node(n)
 
 paul@113    466 
 
 paul@113    467 
        elif isinstance(n, compiler.ast.Keyword):
 
 paul@113    468 
            return self.process_structure_node(n.expr)
 
 paul@113    469 
 
 paul@113    470 
        # Constant usage.
 
 paul@113    471 
 
 paul@113    472 
        elif isinstance(n, compiler.ast.Const):
 
 paul@113    473 
            return self.get_literal_instance(n, n.value.__class__.__name__)
 
 paul@113    474 
 
 paul@113    475 
        elif isinstance(n, compiler.ast.Dict):
 
 paul@113    476 
            return self.get_literal_instance(n, "dict")
 
 paul@113    477 
 
 paul@113    478 
        elif isinstance(n, compiler.ast.List):
 
 paul@113    479 
            return self.get_literal_instance(n, "list")
 
 paul@113    480 
 
 paul@113    481 
        elif isinstance(n, compiler.ast.Tuple):
 
 paul@113    482 
            return self.get_literal_instance(n, "tuple")
 
 paul@113    483 
 
 paul@113    484 
        # All other nodes are processed depth-first.
 
 paul@113    485 
 
 paul@113    486 
        else:
 
 paul@113    487 
            self.process_structure(n)
 
 paul@113    488 
 
 paul@113    489 
    def process_assignment_node(self, n, expr):
 
 paul@113    490 
 
 paul@113    491 
        "Process the individual node 'n' to be assigned the contents of 'expr'."
 
 paul@113    492 
 
 paul@113    493 
        # Names and attributes are assigned the entire expression.
 
 paul@113    494 
 
 paul@113    495 
        if isinstance(n, compiler.ast.AssName):
 
 paul@113    496 
            name_ref = self.process_name_node(n, self.process_structure_node(expr))
 
 paul@113    497 
            self.statement(name_ref)
 
 paul@113    498 
 
 paul@113    499 
        elif isinstance(n, compiler.ast.AssAttr):
 
 paul@113    500 
            self.statement(self.process_attribute_access(n, self.process_structure_node(expr)))
 
 paul@113    501 
 
 paul@113    502 
        # Lists and tuples are matched against the expression and their
 
 paul@113    503 
        # items assigned to expression items.
 
 paul@113    504 
 
 paul@113    505 
        elif isinstance(n, (compiler.ast.AssList, compiler.ast.AssTuple)):
 
 paul@113    506 
            self.process_assignment_node_items(n, expr)
 
 paul@113    507 
 
 paul@113    508 
        # Slices and subscripts are permitted within assignment nodes.
 
 paul@113    509 
 
 paul@113    510 
        elif isinstance(n, compiler.ast.Slice):
 
 paul@113    511 
            self.statement(self.process_slice_node(n, expr))
 
 paul@113    512 
 
 paul@113    513 
        elif isinstance(n, compiler.ast.Subscript):
 
 paul@113    514 
            self.statement(self.process_subscript_node(n, expr))
 
 paul@113    515 
 
 paul@113    516 
    def process_attribute_access(self, n, expr=None):
 
 paul@113    517 
 
 paul@113    518 
        """
 
 paul@113    519 
        Process the given attribute access node 'n'.
 
 paul@113    520 
 
 paul@113    521 
        Where a name is provided, a single access should be recorded
 
 paul@113    522 
        involving potentially many attributes, thus providing a path to an
 
 paul@113    523 
        object. The remaining attributes are then accessed dynamically.
 
 paul@113    524 
        The remaining accesses could be deduced and computed, but they would
 
 paul@113    525 
        also need to be tested.
 
 paul@113    526 
 
 paul@113    527 
        Where no name is provided, potentially many accesses should be
 
 paul@113    528 
        recorded, one per attribute name. These could be used to provide
 
 paul@113    529 
        computed accesses, but the accessors would need to be tested in each
 
 paul@113    530 
        case.
 
 paul@113    531 
        """
 
 paul@113    532 
 
 paul@113    533 
        # Obtain any completed chain and return the reference to it.
 
 paul@113    534 
 
 paul@113    535 
        attr_expr = self.process_attribute_chain(n)
 
 paul@113    536 
        if self.have_access_expression(n):
 
 paul@113    537 
            return attr_expr
 
 paul@113    538 
 
 paul@113    539 
        # Where the start of the chain of attributes has been reached, process
 
 paul@113    540 
        # the complete access.
 
 paul@113    541 
 
 paul@113    542 
        name_ref = attr_expr and attr_expr.is_name() and attr_expr
 
 paul@113    543 
        name = name_ref and name_ref.name or None
 
 paul@113    544 
 
 paul@113    545 
        location = self.get_access_location(name)
 
 paul@113    546 
        refs = self.get_referenced_attributes(location)
 
 paul@113    547 
 
 paul@113    548 
        # Generate access instructions.
 
 paul@113    549 
 
 paul@113    550 
        subs = {
 
 paul@113    551 
            "<expr>" : str(attr_expr),
 
 paul@113    552 
            "<assexpr>" : str(expr),
 
 paul@113    553 
            "<context>" : "__tmp_context",
 
 paul@113    554 
            "<accessor>" : "__tmp_value",
 
 paul@113    555 
            }
 
 paul@113    556 
 
 paul@113    557 
        output = []
 
 paul@113    558 
 
 paul@113    559 
        for instruction in self.optimiser.access_instructions[location]:
 
 paul@113    560 
            output.append(encode_access_instruction(instruction, subs))
 
 paul@113    561 
 
 paul@113    562 
        out = "(\n%s\n)" % ",\n".join(output)
 
 paul@113    563 
 
 paul@113    564 
        del self.attrs[0]
 
 paul@113    565 
        return AttrResult(out, refs)
 
 paul@113    566 
 
 paul@113    567 
    def get_referenced_attributes(self, location):
 
 paul@113    568 
 
 paul@113    569 
        """
 
 paul@113    570 
        Convert 'location' to the form used by the deducer and retrieve any
 
 paul@113    571 
        identified attribute.
 
 paul@113    572 
        """
 
 paul@113    573 
 
 paul@113    574 
        access_location = self.deducer.const_accesses.get(location)
 
 paul@113    575 
        refs = []
 
 paul@113    576 
        for attrtype, objpath, attr in self.deducer.referenced_attrs[access_location or location]:
 
 paul@113    577 
            refs.append(attr)
 
 paul@113    578 
        return refs
 
 paul@113    579 
 
 paul@113    580 
    def get_access_location(self, name):
 
 paul@113    581 
 
 paul@113    582 
        """
 
 paul@113    583 
        Using the current namespace and the given 'name', return the access
 
 paul@113    584 
        location.
 
 paul@113    585 
        """
 
 paul@113    586 
 
 paul@113    587 
        path = self.get_path_for_access()
 
 paul@113    588 
 
 paul@113    589 
        # Get the location used by the deducer and optimiser and find any
 
 paul@113    590 
        # recorded access.
 
 paul@113    591 
 
 paul@113    592 
        attrnames = ".".join(self.attrs)
 
 paul@113    593 
        access_number = self.get_access_number(path, name, attrnames)
 
 paul@113    594 
        self.update_access_number(path, name, attrnames)
 
 paul@113    595 
        return (path, name, attrnames, access_number)
 
 paul@113    596 
 
 paul@113    597 
    def get_access_number(self, path, name, attrnames):
 
 paul@113    598 
        access = name, attrnames
 
 paul@113    599 
        if self.attr_accesses.has_key(path) and self.attr_accesses[path].has_key(access):
 
 paul@113    600 
            return self.attr_accesses[path][access]
 
 paul@113    601 
        else:
 
 paul@113    602 
            return 0
 
 paul@113    603 
 
 paul@113    604 
    def update_access_number(self, path, name, attrnames):
 
 paul@113    605 
        access = name, attrnames
 
 paul@113    606 
        if name:
 
 paul@113    607 
            init_item(self.attr_accesses, path, dict)
 
 paul@113    608 
            init_item(self.attr_accesses[path], access, lambda: 1)
 
 paul@113    609 
 
 paul@113    610 
    def process_class_node(self, n):
 
 paul@113    611 
 
 paul@113    612 
        "Process the given class node 'n'."
 
 paul@113    613 
 
 paul@113    614 
        self.enter_namespace(n.name)
 
 paul@113    615 
 
 paul@113    616 
        if self.have_object():
 
 paul@113    617 
            class_name = self.get_namespace_path()
 
 paul@113    618 
            self.write_comment("Class: %s" % class_name)
 
 paul@113    619 
 
 paul@113    620 
            self.process_structure(n)
 
 paul@113    621 
 
 paul@113    622 
        self.exit_namespace()
 
 paul@113    623 
 
 paul@113    624 
    def process_function_body_node(self, n):
 
 paul@113    625 
 
 paul@113    626 
        """
 
 paul@113    627 
        Process the given function, lambda, if expression or list comprehension
 
 paul@113    628 
        node 'n', generating the body.
 
 paul@113    629 
        """
 
 paul@113    630 
 
 paul@113    631 
        function_name = self.get_namespace_path()
 
 paul@113    632 
        self.start_function(function_name)
 
 paul@113    633 
 
 paul@113    634 
        # Process the function body.
 
 paul@113    635 
 
 paul@113    636 
        self.invocation_depth = 0
 
 paul@113    637 
        self.invocation_argument_depth = 0
 
 paul@113    638 
        self.invocation_kw_argument_depth = 0
 
 paul@113    639 
 
 paul@113    640 
        in_conditional = self.in_conditional
 
 paul@113    641 
        self.in_conditional = False
 
 paul@113    642 
 
 paul@113    643 
        expr = self.process_structure_node(n.code)
 
 paul@113    644 
        if expr:
 
 paul@113    645 
            self.writeline("return %s;" % expr)
 
 paul@113    646 
 
 paul@113    647 
        self.in_conditional = in_conditional
 
 paul@113    648 
 
 paul@113    649 
        self.end_function()
 
 paul@113    650 
 
 paul@113    651 
    def process_function_node(self, n):
 
 paul@113    652 
 
 paul@113    653 
        """
 
 paul@113    654 
        Process the given function, lambda, if expression or list comprehension
 
 paul@113    655 
        node 'n', generating any initialisation statements.
 
 paul@113    656 
        """
 
 paul@113    657 
 
 paul@113    658 
        # Where a function is declared conditionally, use a separate name for
 
 paul@113    659 
        # the definition, and assign the definition to the stated name.
 
 paul@113    660 
 
 paul@113    661 
        if self.in_conditional or self.in_function:
 
 paul@113    662 
            original_name = n.name
 
 paul@113    663 
            name = self.get_lambda_name()
 
 paul@113    664 
        else:
 
 paul@113    665 
            original_name = None
 
 paul@113    666 
            name = n.name
 
 paul@113    667 
 
 paul@113    668 
        # Obtain details of the defaults.
 
 paul@113    669 
 
 paul@113    670 
        defaults = self.process_function_defaults(n, name, self.get_object_path(name))
 
 paul@113    671 
        if defaults:
 
 paul@113    672 
            for default in defaults:
 
 paul@113    673 
                self.writeline("%s;" % default)
 
 paul@113    674 
 
 paul@113    675 
        # Where a function is set conditionally, assign the name.
 
 paul@113    676 
 
 paul@113    677 
        if original_name:
 
 paul@113    678 
            self.process_assignment_for_function(original_name, name)
 
 paul@113    679 
 
 paul@113    680 
    def process_function_defaults(self, n, name, instance_name):
 
 paul@113    681 
 
 paul@113    682 
        """
 
 paul@113    683 
        Process the given function or lambda node 'n', initialising defaults
 
 paul@113    684 
        that are dynamically set. The given 'name' indicates the name of the
 
 paul@113    685 
        function. The given 'instance_name' indicates the name of any separate
 
 paul@113    686 
        instance of the function created to hold the defaults.
 
 paul@113    687 
 
 paul@113    688 
        Return a list of operations setting defaults on a function instance.
 
 paul@113    689 
        """
 
 paul@113    690 
 
 paul@113    691 
        function_name = self.get_object_path(name)
 
 paul@113    692 
        function_defaults = self.importer.function_defaults.get(function_name)
 
 paul@113    693 
        if not function_defaults:
 
 paul@113    694 
            return None
 
 paul@113    695 
 
 paul@113    696 
        # Determine whether any unidentified defaults are involved.
 
 paul@113    697 
 
 paul@113    698 
        need_defaults = [argname for argname, default in function_defaults if default.has_kind("<var>")]
 
 paul@113    699 
        if not need_defaults:
 
 paul@113    700 
            return None
 
 paul@113    701 
 
 paul@113    702 
        # Where defaults are involved but cannot be identified, obtain a new
 
 paul@113    703 
        # instance of the lambda and populate the defaults.
 
 paul@113    704 
 
 paul@113    705 
        defaults = []
 
 paul@113    706 
 
 paul@113    707 
        # Join the original defaults with the inspected defaults.
 
 paul@113    708 
 
 paul@113    709 
        original_defaults = [(argname, default) for (argname, default) in compiler.ast.get_defaults(n) if default]
 
 paul@113    710 
 
 paul@113    711 
        for i, (original, inspected) in enumerate(map(None, original_defaults, function_defaults)):
 
 paul@113    712 
 
 paul@113    713 
            # Obtain any reference for the default.
 
 paul@113    714 
 
 paul@113    715 
            if original:
 
 paul@113    716 
                argname, default = original
 
 paul@113    717 
                name_ref = self.process_structure_node(default)
 
 paul@113    718 
            elif inspected:
 
 paul@113    719 
                argname, default = inspected
 
 paul@113    720 
                name_ref = TrResolvedNameRef(argname, default)
 
 paul@113    721 
            else:
 
 paul@113    722 
                continue
 
 paul@113    723 
 
 paul@113    724 
            if name_ref:
 
 paul@113    725 
                defaults.append("__SETDEFAULT(%s, %s, %s)" % (encode_path(instance_name), i, name_ref))
 
 paul@113    726 
 
 paul@113    727 
        return defaults
 
 paul@113    728 
 
 paul@113    729 
    def process_if_node(self, n):
 
 paul@113    730 
 
 paul@113    731 
        """
 
 paul@113    732 
        Process the given "if" node 'n'.
 
 paul@113    733 
        """
 
 paul@113    734 
 
 paul@113    735 
        first = True
 
 paul@113    736 
        for test, body in n.tests:
 
 paul@113    737 
            test_ref = self.process_structure_node(test)
 
 paul@113    738 
            self.start_if(first, test_ref)
 
 paul@113    739 
 
 paul@113    740 
            in_conditional = self.in_conditional
 
 paul@113    741 
            self.in_conditional = True
 
 paul@113    742 
            self.process_structure_node(body)
 
 paul@113    743 
            self.in_conditional = in_conditional
 
 paul@113    744 
 
 paul@113    745 
            self.end_if()
 
 paul@113    746 
            first = False
 
 paul@113    747 
 
 paul@113    748 
        if n.else_:
 
 paul@113    749 
            self.start_else()
 
 paul@113    750 
            self.process_structure_node(n.else_)
 
 paul@113    751 
            self.end_else()
 
 paul@113    752 
 
 paul@113    753 
    def process_invocation_node(self, n):
 
 paul@113    754 
 
 paul@113    755 
        "Process the given invocation node 'n'."
 
 paul@113    756 
 
 paul@113    757 
        expr = self.process_structure_node(n.node)
 
 paul@113    758 
        objpath = expr.get_origin()
 
 paul@113    759 
 
 paul@113    760 
        # Obtain details of the callable.
 
 paul@113    761 
 
 paul@113    762 
        if objpath:
 
 paul@113    763 
            parameters = self.importer.function_parameters.get(objpath)
 
 paul@113    764 
        else:
 
 paul@113    765 
            parameters = None
 
 paul@113    766 
 
 paul@113    767 
        stages = []
 
 paul@113    768 
 
 paul@113    769 
        # Arguments are presented in a temporary frame array at the current
 
 paul@113    770 
        # position with any context always being the first argument (although it
 
 paul@113    771 
        # may be omitted for invocations where it would be unused).
 
 paul@113    772 
 
 paul@113    773 
        stages.append("__tmp_target = %s" % expr)
 
 paul@113    774 
        stages.append("__tmp_args[...] = __tmp_target.context")
 
 paul@113    775 
 
 paul@113    776 
        # Keyword arguments are positioned within the frame.
 
 paul@113    777 
 
 paul@113    778 
        # Defaults are added to the frame where arguments are missing.
 
 paul@113    779 
 
 paul@113    780 
        # The callable member of the callable is then obtained.
 
 paul@113    781 
 
 paul@113    782 
        if self.always_callable:
 
 paul@113    783 
            get_fn = "__load_via_object(__tmp_target, %s).fn" % \
 
 paul@113    784 
                     encode_symbol("pos", "__fn__")
 
 paul@113    785 
        else:
 
 paul@113    786 
            get_fn = "__check_and_load_via_object(__tmp_target, %s, %s).fn" % (
 
 paul@113    787 
                     encode_symbol("pos", "__fn__"), encode_symbol("code", "__fn__"))
 
 paul@113    788 
 
 paul@113    789 
        stages.append(get_fn)
 
 paul@113    790 
 
 paul@113    791 
        output = "(\n%s\n)(__tmp_frame)" % ",\n".join(stages)
 
 paul@113    792 
 
 paul@113    793 
        return make_expression("".join(output))
 
 paul@113    794 
 
 paul@113    795 
    def always_callable(self, refs):
 
 paul@113    796 
 
 paul@113    797 
        "Determine whether all 'refs' are callable."
 
 paul@113    798 
 
 paul@113    799 
        for ref in refs:
 
 paul@113    800 
            if not ref.static():
 
 paul@113    801 
                return False
 
 paul@113    802 
            else:
 
 paul@113    803 
                origin = ref.final()
 
 paul@113    804 
                if not self.importer.get_attribute(origin, "__fn__"):
 
 paul@113    805 
                    return False
 
 paul@113    806 
        return True
 
 paul@113    807 
 
 paul@113    808 
    def need_default_arguments(self, objpath, nargs):
 
 paul@113    809 
 
 paul@113    810 
        """
 
 paul@113    811 
        Return whether any default arguments are needed when invoking the object
 
 paul@113    812 
        given by 'objpath'.
 
 paul@113    813 
        """
 
 paul@113    814 
 
 paul@113    815 
        parameters = self.importer.function_parameters.get(objpath)
 
 paul@113    816 
        return nargs < len(parameters)
 
 paul@113    817 
 
 paul@113    818 
    def process_lambda_node(self, n):
 
 paul@113    819 
 
 paul@113    820 
        "Process the given lambda node 'n'."
 
 paul@113    821 
 
 paul@113    822 
        name = self.get_lambda_name()
 
 paul@113    823 
        function_name = self.get_object_path(name)
 
 paul@113    824 
 
 paul@113    825 
        defaults = self.process_function_defaults(n, name, "__tmp")
 
 paul@113    826 
        if not defaults:
 
 paul@113    827 
            return make_expression(encode_path(function_name))
 
 paul@113    828 
        else:
 
 paul@113    829 
            return make_expression("(__COPY(%s, __tmp), %s)" % (encode_path(function_name), ", ".join(defaults)))
 
 paul@113    830 
 
 paul@113    831 
    def process_logical_node(self, n):
 
 paul@113    832 
 
 paul@113    833 
        "Process the given operator node 'n'."
 
 paul@113    834 
 
 paul@113    835 
        if isinstance(n, compiler.ast.And):
 
 paul@113    836 
            op = " && "
 
 paul@113    837 
        else:
 
 paul@113    838 
            op = " || "
 
 paul@113    839 
 
 paul@113    840 
        # NOTE: This needs to evaluate whether the operands are true or false
 
 paul@113    841 
        # NOTE: according to Python rules.
 
 paul@113    842 
 
 paul@113    843 
        results = [("(%s)" % self.process_structure_node(node)) for node in n.nodes]
 
 paul@113    844 
        return make_expression("(%s)" % op.join(results))
 
 paul@113    845 
 
 paul@113    846 
    def process_name_node(self, n, expr=None):
 
 paul@113    847 
 
 paul@113    848 
        "Process the given name node 'n' with the optional assignment 'expr'."
 
 paul@113    849 
 
 paul@113    850 
        # Determine whether the name refers to a static external entity.
 
 paul@113    851 
 
 paul@113    852 
        if n.name in predefined_constants:
 
 paul@113    853 
            return PredefinedConstantRef(n.name)
 
 paul@113    854 
 
 paul@113    855 
        # Convert literal references.
 
 paul@113    856 
 
 paul@113    857 
        elif n.name.startswith("$L"):
 
 paul@113    858 
            literal_name = n.name[len("$L"):]
 
 paul@113    859 
            ref = self.importer.get_object("__builtins__.%s" % literal_name)
 
 paul@113    860 
            return TrResolvedNameRef(n.name, ref)
 
 paul@113    861 
 
 paul@113    862 
        # Convert operator function names to references.
 
 paul@113    863 
 
 paul@113    864 
        elif n.name.startswith("$op"):
 
 paul@113    865 
            opname = n.name[len("$op"):]
 
 paul@113    866 
            ref = self.importer.get_object("operator.%s" % opname)
 
 paul@113    867 
            return TrResolvedNameRef(n.name, ref)
 
 paul@113    868 
 
 paul@113    869 
        # Get the appropriate name for the name reference, using the same method
 
 paul@113    870 
        # as in the inspector.
 
 paul@113    871 
 
 paul@113    872 
        path = self.get_object_path(n.name)
 
 paul@113    873 
        ref = self.importer.get_object(path)
 
 paul@113    874 
        name = self.get_name_for_tracking(n.name, ref and ref.final())
 
 paul@113    875 
 
 paul@113    876 
        # Get the static identity of the name.
 
 paul@113    877 
 
 paul@113    878 
        ref = self.importer.identify(path)
 
 paul@113    879 
 
 paul@113    880 
        # Obtain any resolved names for non-assignment names.
 
 paul@113    881 
 
 paul@113    882 
        if not expr and not ref and self.in_function:
 
 paul@113    883 
            locals = self.importer.function_locals.get(self.get_namespace_path())
 
 paul@113    884 
            ref = locals and locals.get(n.name)
 
 paul@113    885 
 
 paul@113    886 
        # Qualified names are used for resolved static references or for
 
 paul@113    887 
        # static namespace members. The reference should be configured to return
 
 paul@113    888 
        # such names.
 
 paul@113    889 
 
 paul@113    890 
        return TrResolvedNameRef(name, ref, expr=expr)
 
 paul@113    891 
 
 paul@113    892 
    def process_not_node(self, n):
 
 paul@113    893 
 
 paul@113    894 
        "Process the given operator node 'n'."
 
 paul@113    895 
 
 paul@113    896 
        # NOTE: This needs to evaluate whether the operand is true or false
 
 paul@113    897 
        # NOTE: according to Python rules.
 
 paul@113    898 
 
 paul@113    899 
        return make_expression("(!(%s))" % n.expr)
 
 paul@113    900 
 
 paul@113    901 
    def process_try_node(self, n):
 
 paul@113    902 
 
 paul@113    903 
        """
 
 paul@113    904 
        Process the given "try...except" node 'n'.
 
 paul@113    905 
        """
 
 paul@113    906 
 
 paul@113    907 
        # NOTE: Placeholders/macros.
 
 paul@113    908 
 
 paul@113    909 
        self.writeline("TRY")
 
 paul@113    910 
        self.writeline("{")
 
 paul@113    911 
        self.indent += 1
 
 paul@113    912 
        self.process_structure_node(n.body)
 
 paul@113    913 
        self.indent -= 1
 
 paul@113    914 
        self.writeline("}")
 
 paul@113    915 
 
 paul@113    916 
        for name, var, handler in n.handlers:
 
 paul@113    917 
            if name is not None:
 
 paul@113    918 
                name_ref = self.process_structure_node(name)
 
 paul@113    919 
                self.writeline("EXCEPT(%s)" % name_ref)
 
 paul@113    920 
 
 paul@113    921 
            self.writeline("{")
 
 paul@113    922 
            self.indent += 1
 
 paul@113    923 
 
 paul@113    924 
            # Establish the local for the handler.
 
 paul@113    925 
            # NOTE: Need to provide the exception value.
 
 paul@113    926 
 
 paul@113    927 
            if var is not None:
 
 paul@113    928 
                var_ref = self.process_structure_node(var)
 
 paul@113    929 
 
 paul@113    930 
            if handler is not None:
 
 paul@113    931 
                self.process_structure_node(handler)
 
 paul@113    932 
 
 paul@113    933 
            self.indent -= 1
 
 paul@113    934 
            self.writeline("}")
 
 paul@113    935 
 
 paul@113    936 
        if n.else_:
 
 paul@113    937 
            self.process_structure_node(n.else_)
 
 paul@113    938 
 
 paul@113    939 
    def process_try_finally_node(self, n):
 
 paul@113    940 
 
 paul@113    941 
        """
 
 paul@113    942 
        Process the given "try...finally" node 'n'.
 
 paul@113    943 
        """
 
 paul@113    944 
 
 paul@113    945 
        # NOTE: Placeholders/macros.
 
 paul@113    946 
 
 paul@113    947 
        self.writeline("TRY")
 
 paul@113    948 
        self.writeline("{")
 
 paul@113    949 
        self.indent += 1
 
 paul@113    950 
        self.process_structure_node(n.body)
 
 paul@113    951 
        self.indent -= 1
 
 paul@113    952 
        self.writeline("}")
 
 paul@113    953 
        self.writeline("FINALLY")
 
 paul@113    954 
        self.writeline("{")
 
 paul@113    955 
        self.indent += 1
 
 paul@113    956 
        self.process_structure_node(n.final)
 
 paul@113    957 
        self.indent -= 1
 
 paul@113    958 
        self.writeline("}")
 
 paul@113    959 
 
 paul@113    960 
    def process_while_node(self, n):
 
 paul@113    961 
 
 paul@113    962 
        "Process the given while node 'n'."
 
 paul@113    963 
 
 paul@113    964 
        self.writeline("while (1)")
 
 paul@113    965 
        self.writeline("{")
 
 paul@113    966 
        self.indent += 1
 
 paul@113    967 
        test = self.process_structure_node(n.test)
 
 paul@113    968 
 
 paul@113    969 
        # Emit the loop termination condition unless "while <true value>" is
 
 paul@113    970 
        # indicated.
 
 paul@113    971 
 
 paul@113    972 
        if not (isinstance(test, PredefinedConstantRef) and test.value):
 
 paul@113    973 
 
 paul@113    974 
            # NOTE: This needs to evaluate whether the operand is true or false
 
 paul@113    975 
            # NOTE: according to Python rules.
 
 paul@113    976 
 
 paul@113    977 
            self.writeline("if (!(%s))" % test)
 
 paul@113    978 
            self.writeline("{")
 
 paul@113    979 
            self.indent += 1
 
 paul@113    980 
            if n.else_:
 
 paul@113    981 
                self.process_structure_node(n.else_)
 
 paul@113    982 
            self.writeline("break;")
 
 paul@113    983 
            self.indent -= 1
 
 paul@113    984 
            self.writeline("}")
 
 paul@113    985 
 
 paul@113    986 
        in_conditional = self.in_conditional
 
 paul@113    987 
        self.in_conditional = True
 
 paul@113    988 
        self.process_structure_node(n.body)
 
 paul@113    989 
        self.in_conditional = in_conditional
 
 paul@113    990 
 
 paul@113    991 
        self.indent -= 1
 
 paul@113    992 
        self.writeline("}")
 
 paul@113    993 
 
 paul@113    994 
    # Output generation.
 
 paul@113    995 
 
 paul@113    996 
    def start_module(self):
 
 paul@113    997 
        print >>self.out, "void __main_%s()" % encode_path(self.name)
 
 paul@113    998 
        print >>self.out, "{"
 
 paul@113    999 
        self.indent += 1
 
 paul@113   1000 
        self.emit_invocation_storage(self.name)
 
 paul@113   1001 
 
 paul@113   1002 
    def end_module(self):
 
 paul@113   1003 
        self.indent -= 1
 
 paul@113   1004 
        self.end_function()
 
 paul@113   1005 
 
 paul@113   1006 
    def start_function(self, name):
 
 paul@113   1007 
        print >>self.out, "__attr %s(__attr __args[])" % encode_function_pointer(name)
 
 paul@113   1008 
        print >>self.out, "{"
 
 paul@113   1009 
        self.indent += 1
 
 paul@113   1010 
 
 paul@113   1011 
        # Obtain local names from parameters.
 
 paul@113   1012 
 
 paul@113   1013 
        parameters = self.importer.function_parameters[name]
 
 paul@113   1014 
        names = []
 
 paul@113   1015 
        locals = self.importer.function_locals[name].keys()
 
 paul@113   1016 
 
 paul@113   1017 
        for n in locals:
 
 paul@113   1018 
 
 paul@113   1019 
            # Filter out special names and parameters. Note that self is a local
 
 paul@113   1020 
            # regardless of whether it originally appeared in the parameters or
 
 paul@113   1021 
            # not.
 
 paul@113   1022 
 
 paul@113   1023 
            if n.startswith("$l") or n in parameters or n == "self":
 
 paul@113   1024 
                continue
 
 paul@113   1025 
            names.append(encode_path(n))
 
 paul@113   1026 
 
 paul@113   1027 
        # Emit required local names.
 
 paul@113   1028 
 
 paul@113   1029 
        if names:
 
 paul@113   1030 
            names.sort()
 
 paul@113   1031 
            self.writeline("__attr %s;" % ", ".join(names))
 
 paul@113   1032 
 
 paul@113   1033 
        self.emit_invocation_storage(name)
 
 paul@113   1034 
 
 paul@113   1035 
        # Generate any self reference.
 
 paul@113   1036 
 
 paul@113   1037 
        if self.in_method(name):
 
 paul@113   1038 
            self.writeline("#define self (__args[0])")
 
 paul@113   1039 
 
 paul@113   1040 
        # Generate aliases for the parameters.
 
 paul@113   1041 
 
 paul@113   1042 
        for i, parameter in enumerate(parameters):
 
 paul@113   1043 
            self.writeline("#define %s (__args[%d])" % (encode_path(parameter), i+1))
 
 paul@113   1044 
 
 paul@113   1045 
    def end_function(self):
 
 paul@113   1046 
        self.indent -= 1
 
 paul@113   1047 
        print >>self.out, "}"
 
 paul@113   1048 
 
 paul@113   1049 
    def start_if(self, first, test_ref):
 
 paul@113   1050 
 
 paul@113   1051 
        # NOTE: This needs to evaluate whether the operand is true or false
 
 paul@113   1052 
        # NOTE: according to Python rules.
 
 paul@113   1053 
 
 paul@113   1054 
        self.writeline("%sif (%s)" % (not first and "else " or "", test_ref))
 
 paul@113   1055 
        self.writeline("{")
 
 paul@113   1056 
        self.indent += 1
 
 paul@113   1057 
 
 paul@113   1058 
    def end_if(self):
 
 paul@113   1059 
        self.indent -= 1
 
 paul@113   1060 
        self.writeline("}")
 
 paul@113   1061 
 
 paul@113   1062 
    def start_else(self):
 
 paul@113   1063 
        self.writeline("else")
 
 paul@113   1064 
        self.writeline("{")
 
 paul@113   1065 
        self.indent += 1
 
 paul@113   1066 
 
 paul@113   1067 
    def end_else(self):
 
 paul@113   1068 
        self.indent -= 1
 
 paul@113   1069 
        self.writeline("}")
 
 paul@113   1070 
 
 paul@113   1071 
    def emit_invocation_storage(self, name):
 
 paul@113   1072 
 
 paul@113   1073 
        "Emit invocation temporary storage."
 
 paul@113   1074 
 
 paul@113   1075 
        if self.importer.function_targets.has_key(name):
 
 paul@113   1076 
            self.writeline("__attr __tmp_targets[%d];" % self.importer.function_targets[name])
 
 paul@113   1077 
 
 paul@113   1078 
        if self.importer.function_arguments.has_key(name):
 
 paul@113   1079 
            self.writeline("__attr __tmp_args[%d];" % self.importer.function_arguments[name])
 
 paul@113   1080 
 
 paul@113   1081 
    def statement(self, expr):
 
 paul@113   1082 
        # NOTE: Should never be None.
 
 paul@113   1083 
        if not expr:
 
 paul@113   1084 
            self.writeline("...;")
 
 paul@113   1085 
        s = str(expr)
 
 paul@113   1086 
        if s:
 
 paul@113   1087 
            self.writeline("%s;" % s)
 
 paul@113   1088 
 
 paul@113   1089 
    def statements(self, results):
 
 paul@113   1090 
        for result in results:
 
 paul@113   1091 
            self.statement(result)
 
 paul@113   1092 
 
 paul@113   1093 
    def pad(self, extra=0):
 
 paul@113   1094 
        return (self.indent + extra) * self.tabstop
 
 paul@113   1095 
 
 paul@113   1096 
    def indenttext(self, s, levels):
 
 paul@113   1097 
        return s.replace("\n", "\n%s" % (levels * self.tabstop))
 
 paul@113   1098 
 
 paul@113   1099 
    def writeline(self, s):
 
 paul@113   1100 
        print >>self.out, "%s%s" % (self.pad(), self.indenttext(s, self.indent + 1))
 
 paul@113   1101 
 
 paul@113   1102 
    def write_comment(self, s):
 
 paul@113   1103 
        self.writeline("/* %s */" % s)
 
 paul@113   1104 
 
 paul@113   1105 
# vim: tabstop=4 expandtab shiftwidth=4