Lichen

Annotated translator.py

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