Lichen

Annotated translator.py

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