Lichen

Annotated encoders.py

934:2989aab1b4f7
6 months ago Paul Boddie Renamed the utf8string class to unicode, eliminating the unicode function. This means that the simple case of merely returning an object if it is already a Unicode object no longer occurs when using the unicode callable, but such behaviour might be better supported with more general customised instantiation functionality.
paul@0 1
#!/usr/bin/env python
paul@0 2
paul@0 3
"""
paul@0 4
Encoder functions, producing representations of program objects.
paul@0 5
paul@833 6
Copyright (C) 2016, 2017, 2018 Paul Boddie <paul@boddie.org.uk>
paul@0 7
paul@0 8
This program is free software; you can redistribute it and/or modify it under
paul@0 9
the terms of the GNU General Public License as published by the Free Software
paul@0 10
Foundation; either version 3 of the License, or (at your option) any later
paul@0 11
version.
paul@0 12
paul@0 13
This program is distributed in the hope that it will be useful, but WITHOUT
paul@0 14
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
paul@0 15
FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
paul@0 16
details.
paul@0 17
paul@0 18
You should have received a copy of the GNU General Public License along with
paul@0 19
this program.  If not, see <http://www.gnu.org/licenses/>.
paul@0 20
"""
paul@0 21
paul@498 22
from common import first, InstructionSequence
paul@56 23
paul@609 24
paul@609 25
paul@609 26
# Value digest computation.
paul@609 27
paul@609 28
from base64 import b64encode
paul@609 29
from hashlib import sha1
paul@609 30
paul@609 31
def digest(values):
paul@609 32
    m = sha1()
paul@609 33
    for value in values:
paul@609 34
        m.update(str(value))
paul@609 35
    return b64encode(m.digest()).replace("+", "__").replace("/", "_").rstrip("=")
paul@609 36
paul@609 37
paul@609 38
paul@0 39
# Output encoding and decoding for the summary files.
paul@0 40
paul@0 41
def encode_attrnames(attrnames):
paul@0 42
paul@0 43
    "Encode the 'attrnames' representing usage."
paul@0 44
paul@0 45
    return ", ".join(attrnames) or "{}"
paul@0 46
paul@0 47
def encode_constrained(constrained):
paul@0 48
paul@0 49
    "Encode the 'constrained' status for program summaries."
paul@0 50
paul@0 51
    return constrained and "constrained" or "deduced"
paul@0 52
paul@0 53
def encode_usage(usage):
paul@0 54
paul@0 55
    "Encode attribute details from 'usage'."
paul@0 56
paul@0 57
    all_attrnames = []
paul@0 58
    for t in usage:
paul@107 59
        attrname, invocation, assignment = t
paul@107 60
        all_attrnames.append("%s%s" % (attrname, invocation and "!" or assignment and "=" or ""))
paul@0 61
    return ", ".join(all_attrnames) or "{}"
paul@0 62
paul@88 63
def decode_usage(s):
paul@88 64
paul@88 65
    "Decode attribute details from 's'."
paul@88 66
paul@88 67
    all_attrnames = set()
paul@88 68
    for attrname_str in s.split(", "):
paul@107 69
        all_attrnames.add((attrname_str.rstrip("!="), attrname_str.endswith("!"), attrname_str.endswith("=")))
paul@88 70
paul@88 71
    all_attrnames = list(all_attrnames)
paul@88 72
    all_attrnames.sort()
paul@88 73
    return tuple(all_attrnames)
paul@88 74
paul@0 75
def encode_access_location(t):
paul@0 76
paul@0 77
    "Encode the access location 't'."
paul@0 78
paul@791 79
    return "%s:%s:%s:%d" % (t.path, t.name or "{}", t.attrnames or "{}", t.access_number)
paul@0 80
paul@841 81
def decode_access_location(s):
paul@841 82
paul@841 83
    "Decode the access location 's'."
paul@841 84
paul@841 85
    path, name, attrnames, access_number = s.split(":")
paul@841 86
    return path, name, attrnames, access_number
paul@841 87
paul@789 88
def encode_alias_location(t, invocation=False):
paul@789 89
paul@789 90
    "Encode the alias location 't'."
paul@789 91
paul@791 92
    return "%s:%s:%s%s%s%s" % (t.path, t.name or "{}", t.attrnames or "{}",
paul@791 93
        t.version is not None and ":=%d" % t.version or "",
paul@791 94
        t.access_number is not None and ":#%d" % t.access_number or "",
paul@791 95
        invocation and "!" or "")
paul@789 96
paul@833 97
def decode_alias_location(s):
paul@833 98
paul@833 99
    "Decode the alias location 's'."
paul@833 100
paul@833 101
    path, name, rest = s.split(":", 2)
paul@833 102
    attrnames = version = access_number = None
paul@833 103
    invocation = rest.endswith("!")
paul@833 104
paul@833 105
    t = rest.rstrip("!").split(":#")
paul@833 106
    if len(t) > 1:
paul@833 107
        rest = t[0]; access_number = int(t[1])
paul@833 108
paul@833 109
    t = rest.split(":=")
paul@833 110
    if len(t) > 1:
paul@833 111
        attrnames = t[0]; version = int(t[1])
paul@833 112
    else:
paul@833 113
        attrnames = rest
paul@833 114
paul@833 115
    return path, name, attrnames, version, access_number, invocation
paul@833 116
paul@0 117
def encode_location(t):
paul@0 118
paul@0 119
    "Encode the general location 't' in a concise form."
paul@0 120
paul@791 121
    if t.name is not None and t.version is not None:
paul@791 122
        return "%s:%s:%d" % (t.path, t.name, t.version)
paul@791 123
    elif t.name is not None:
paul@791 124
        return "%s:%s" % (t.path, t.name)
paul@0 125
    else:
paul@791 126
        return "%s::%s" % (t.path, t.attrnames)
paul@0 127
paul@0 128
def encode_modifiers(modifiers):
paul@0 129
paul@553 130
    "Encode assignment and invocation details from 'modifiers'."
paul@0 131
paul@0 132
    all_modifiers = []
paul@0 133
    for t in modifiers:
paul@0 134
        all_modifiers.append(encode_modifier_term(t))
paul@0 135
    return "".join(all_modifiers)
paul@0 136
paul@0 137
def encode_modifier_term(t):
paul@0 138
paul@553 139
    "Encode modifier 't' representing an assignment or an invocation."
paul@0 140
paul@117 141
    assignment, invocation = t
paul@553 142
    if assignment:
paul@553 143
        return "="
paul@553 144
    elif invocation is not None:
paul@557 145
        arguments, keywords = invocation
paul@557 146
        return "(%d;%s)" % (arguments, ",".join(keywords))
paul@553 147
    else:
paul@553 148
        return "_"
paul@0 149
paul@553 150
def decode_modifiers(s):
paul@553 151
paul@553 152
    "Decode 's' containing modifiers."
paul@553 153
paul@553 154
    i = 0
paul@553 155
    end = len(s)
paul@0 156
paul@553 157
    modifiers = []
paul@0 158
paul@553 159
    while i < end:
paul@553 160
        if s[i] == "=":
paul@553 161
            modifiers.append((True, None))
paul@553 162
            i += 1
paul@553 163
        elif s[i] == "(":
paul@557 164
            j = s.index(";", i)
paul@557 165
            arguments = int(s[i+1:j])
paul@557 166
            i = j
paul@553 167
            j = s.index(")", i)
paul@557 168
            keywords = s[i+1:j]
paul@557 169
            keywords = keywords and keywords.split(",") or []
paul@557 170
            modifiers.append((False, (arguments, keywords)))
paul@553 171
            i = j + 1
paul@553 172
        else:
paul@553 173
            modifiers.append((False, None))
paul@553 174
            i += 1
paul@553 175
paul@553 176
    return modifiers
paul@0 177
paul@56 178
paul@56 179
paul@56 180
# Test generation functions.
paul@56 181
paul@56 182
def get_kinds(all_types):
paul@56 183
paul@56 184
    """ 
paul@56 185
    Return object kind details for 'all_types', being a collection of
paul@56 186
    references for program types.
paul@56 187
    """
paul@56 188
paul@56 189
    return map(lambda ref: ref.get_kind(), all_types)
paul@56 190
paul@237 191
def test_label_for_kind(kind):
paul@56 192
paul@237 193
    "Return the label used for 'kind' in test details."
paul@56 194
paul@237 195
    return kind == "<instance>" and "instance" or "type"
paul@56 196
paul@237 197
def test_label_for_type(ref):
paul@56 198
paul@237 199
    "Return the label used for 'ref' in test details."
paul@56 200
paul@237 201
    return test_label_for_kind(ref.get_kind())
paul@56 202
paul@56 203
paul@56 204
paul@94 205
# Instruction representation encoding.
paul@94 206
paul@94 207
def encode_instruction(instruction):
paul@94 208
paul@94 209
    """
paul@94 210
    Encode the 'instruction' - a sequence starting with an operation and
paul@94 211
    followed by arguments, each of which may be an instruction sequence or a
paul@94 212
    plain value - to produce a function call string representation.
paul@94 213
    """
paul@94 214
paul@94 215
    op = instruction[0]
paul@94 216
    args = instruction[1:]
paul@94 217
paul@94 218
    if args:
paul@94 219
        a = []
paul@113 220
        for arg in args:
paul@113 221
            if isinstance(arg, tuple):
paul@113 222
                a.append(encode_instruction(arg))
paul@94 223
            else:
paul@113 224
                a.append(arg or "{}")
paul@94 225
        argstr = "(%s)" % ", ".join(a)
paul@94 226
        return "%s%s" % (op, argstr)
paul@94 227
    else:
paul@94 228
        return op
paul@94 229
paul@94 230
paul@94 231
paul@0 232
# Output program encoding.
paul@0 233
paul@153 234
attribute_loading_ops = (
paul@153 235
    "__load_via_class", "__load_via_object", "__get_class_and_load",
paul@153 236
    )
paul@153 237
paul@153 238
attribute_ops = attribute_loading_ops + (
paul@815 239
    "__store_via_class", "__store_via_object",
paul@113 240
    )
paul@113 241
paul@153 242
checked_loading_ops = (
paul@113 243
    "__check_and_load_via_class", "__check_and_load_via_object", "__check_and_load_via_any",
paul@153 244
    )
paul@153 245
paul@153 246
checked_ops = checked_loading_ops + (
paul@113 247
    "__check_and_store_via_class", "__check_and_store_via_object", "__check_and_store_via_any",
paul@113 248
    )
paul@113 249
paul@113 250
typename_ops = (
paul@144 251
    "__test_common_instance", "__test_common_object", "__test_common_type",
paul@113 252
    )
paul@113 253
paul@385 254
type_ops = (
paul@385 255
    "__test_specific_instance", "__test_specific_object", "__test_specific_type",
paul@385 256
    )
paul@385 257
paul@141 258
static_ops = (
paul@595 259
    "__load_static_ignore", "__load_static_replace", "__load_static_test", "<test_context_static>",
paul@141 260
    )
paul@141 261
paul@858 262
accessor_values = (
paul@858 263
    "<accessor>",
paul@858 264
    )
paul@858 265
paul@858 266
accessor_ops = (
paul@858 267
    "<accessor>", "<set_accessor>",
paul@858 268
    )
paul@858 269
paul@591 270
context_values = (
paul@591 271
    "<context>",
paul@591 272
    )
paul@591 273
paul@591 274
context_ops = (
paul@601 275
    "<context>", "<set_context>", "<test_context_revert>", "<test_context_static>",
paul@591 276
    )
paul@591 277
paul@602 278
context_op_functions = (
paul@602 279
    "<test_context_revert>", "<test_context_static>",
paul@602 280
    )
paul@602 281
paul@757 282
reference_acting_ops = attribute_ops + checked_ops + type_ops + typename_ops
paul@153 283
attribute_producing_ops = attribute_loading_ops + checked_loading_ops
paul@153 284
paul@757 285
attribute_producing_variables = (
paul@757 286
    "<accessor>", "<context>", "<name>", "<private_context>", "<target_accessor>"
paul@757 287
    )
paul@757 288
paul@858 289
def encode_access_instruction(instruction, subs, accessor_index, context_index):
paul@113 290
paul@113 291
    """
paul@113 292
    Encode the 'instruction' - a sequence starting with an operation and
paul@113 293
    followed by arguments, each of which may be an instruction sequence or a
paul@113 294
    plain value - to produce a function call string representation.
paul@113 295
paul@113 296
    The 'subs' parameter defines a mapping of substitutions for special values
paul@113 297
    used in instructions.
paul@482 298
paul@858 299
    The 'accessor_index' parameter defines the position in local accessor
paul@858 300
    storage for the referenced accessor or affected by an accessor operation.
paul@858 301
paul@591 302
    The 'context_index' parameter defines the position in local context storage
paul@591 303
    for the referenced context or affected by a context operation.
paul@591 304
paul@482 305
    Return both the encoded instruction and a collection of substituted names.
paul@113 306
    """
paul@113 307
paul@113 308
    op = instruction[0]
paul@113 309
    args = instruction[1:]
paul@482 310
    substituted = set()
paul@113 311
paul@591 312
    # Encode the arguments.
paul@113 313
paul@591 314
    a = []
paul@591 315
    if args:
paul@153 316
        converting_op = op
paul@113 317
        for arg in args:
paul@858 318
            s, _substituted = encode_access_instruction_arg(arg, subs, converting_op, accessor_index, context_index)
paul@482 319
            substituted.update(_substituted)
paul@482 320
            a.append(s)
paul@153 321
            converting_op = None
paul@113 322
paul@591 323
    # Modify certain arguments.
paul@113 324
paul@624 325
    # Convert type name arguments.
paul@113 326
paul@624 327
    if op in typename_ops:
paul@624 328
        a[1] = encode_path(encode_type_attribute(args[1]))
paul@113 329
paul@591 330
    # Obtain addresses of type arguments.
paul@591 331
paul@591 332
    elif op in type_ops:
paul@591 333
        a[1] = "&%s" % a[1]
paul@113 334
paul@591 335
    # Obtain addresses of static objects.
paul@591 336
paul@591 337
    elif op in static_ops:
paul@591 338
        a[-1] = "&%s" % a[-1]
paul@385 339
paul@858 340
    # Add accessor storage information to certain operations.
paul@858 341
paul@858 342
    if op in accessor_ops:
paul@858 343
        a.insert(0, accessor_index)
paul@858 344
paul@591 345
    # Add context storage information to certain operations.
paul@385 346
paul@595 347
    if op in context_ops:
paul@591 348
        a.insert(0, context_index)
paul@141 349
paul@602 350
    # Add the local context array to certain operations.
paul@602 351
paul@602 352
    if op in context_op_functions:
paul@602 353
        a.append("__tmp_contexts")
paul@602 354
paul@591 355
    # Define any argument string.
paul@141 356
paul@591 357
    if a:
paul@491 358
        argstr = "(%s)" % ", ".join(map(str, a))
paul@591 359
    else:
paul@591 360
        argstr = ""
paul@113 361
paul@113 362
    # Substitute the first element of the instruction, which may not be an
paul@113 363
    # operation at all.
paul@113 364
paul@144 365
    if subs.has_key(op):
paul@482 366
        substituted.add(op)
paul@498 367
paul@498 368
        # Break accessor initialisation into initialisation and value-yielding
paul@498 369
        # parts:
paul@498 370
paul@498 371
        if op == "<set_accessor>" and isinstance(a[0], InstructionSequence):
paul@498 372
            ops = []
paul@498 373
            ops += a[0].get_init_instructions()
paul@498 374
            ops.append("%s(%s)" % (subs[op], a[0].get_value_instruction()))
paul@498 375
            return ", ".join(map(str, ops)), substituted
paul@498 376
paul@144 377
        op = subs[op]
paul@498 378
paul@144 379
    elif not args:
paul@144 380
        op = "&%s" % encode_path(op)
paul@144 381
paul@482 382
    return "%s%s" % (op, argstr), substituted
paul@113 383
paul@858 384
def encode_access_instruction_arg(arg, subs, op, accessor_index, context_index):
paul@113 385
paul@482 386
    """
paul@591 387
    Encode 'arg' using 'subs' to define substitutions, 'op' to indicate the
paul@858 388
    operation to which the argument belongs, and with 'accessor_index' and
paul@858 389
    'context_index' indicating any affected accessor and context storage.
paul@591 390
paul@591 391
    Return a tuple containing the encoded form of 'arg' along with a collection
paul@591 392
    of any substituted values.
paul@482 393
    """
paul@113 394
paul@113 395
    if isinstance(arg, tuple):
paul@858 396
        encoded, substituted = encode_access_instruction(arg, subs, accessor_index, context_index)
paul@757 397
        return attribute_to_reference(op, arg[0], encoded, substituted)
paul@113 398
paul@113 399
    # Special values only need replacing, not encoding.
paul@113 400
paul@113 401
    elif subs.has_key(arg):
paul@591 402
paul@591 403
        # Handle values modified by storage details.
paul@591 404
paul@858 405
        if arg in accessor_values or arg in context_values:
paul@757 406
            encoded = "%s(%s)" % (subs.get(arg), context_index)
paul@591 407
        else:
paul@757 408
            encoded = subs.get(arg)
paul@757 409
paul@757 410
        substituted = set([arg])
paul@757 411
        return attribute_to_reference(op, arg, encoded, substituted)
paul@113 412
paul@258 413
    # Convert static references to the appropriate type.
paul@258 414
paul@757 415
    elif op and op in reference_acting_ops and \
paul@757 416
         arg not in attribute_producing_variables:
paul@757 417
paul@482 418
        return "&%s" % encode_path(arg), set()
paul@258 419
paul@113 420
    # Other values may need encoding.
paul@113 421
paul@113 422
    else:
paul@482 423
        return encode_path(arg), set()
paul@113 424
paul@757 425
def attribute_to_reference(op, arg, encoded, substituted):
paul@757 426
paul@757 427
    # Convert attribute results to references where required.
paul@757 428
paul@757 429
    if op and op in reference_acting_ops and (
paul@757 430
       arg in attribute_producing_ops or
paul@757 431
       arg in attribute_producing_variables):
paul@757 432
paul@757 433
        return "__VALUE(%s)" % encoded, substituted
paul@757 434
    else:
paul@757 435
        return encoded, substituted
paul@757 436
paul@0 437
def encode_function_pointer(path):
paul@0 438
paul@0 439
    "Encode 'path' as a reference to an output program function."
paul@0 440
paul@0 441
    return "__fn_%s" % encode_path(path)
paul@0 442
paul@0 443
def encode_instantiator_pointer(path):
paul@0 444
paul@0 445
    "Encode 'path' as a reference to an output program instantiator."
paul@0 446
paul@0 447
    return "__new_%s" % encode_path(path)
paul@0 448
paul@491 449
def encode_instructions(instructions):
paul@491 450
paul@491 451
    "Encode 'instructions' as a sequence."
paul@491 452
paul@491 453
    if len(instructions) == 1:
paul@491 454
        return instructions[0]
paul@491 455
    else:
paul@491 456
        return "(\n%s\n)" % ",\n".join(instructions)
paul@491 457
paul@136 458
def encode_literal_constant(n):
paul@136 459
paul@136 460
    "Encode a name for the literal constant with the number 'n'."
paul@136 461
paul@609 462
    return "__const%s" % n
paul@136 463
paul@378 464
def encode_literal_constant_size(value):
paul@378 465
paul@378 466
    "Encode a size for the literal constant with the given 'value'."
paul@378 467
paul@378 468
    if isinstance(value, basestring):
paul@378 469
        return len(value)
paul@378 470
    else:
paul@378 471
        return 0
paul@378 472
paul@136 473
def encode_literal_constant_member(value):
paul@136 474
paul@136 475
    "Encode the member name for the 'value' in the final program."
paul@136 476
paul@136 477
    return "%svalue" % value.__class__.__name__
paul@136 478
paul@136 479
def encode_literal_constant_value(value):
paul@136 480
paul@136 481
    "Encode the given 'value' in the final program."
paul@136 482
paul@136 483
    if isinstance(value, (int, float)):
paul@136 484
        return str(value)
paul@136 485
    else:
paul@451 486
        l = []
paul@451 487
paul@451 488
        # Encode characters including non-ASCII ones.
paul@451 489
paul@451 490
        for c in str(value):
paul@451 491
            if c == '"': l.append('\\"')
paul@451 492
            elif c == '\n': l.append('\\n')
paul@451 493
            elif c == '\t': l.append('\\t')
paul@451 494
            elif c == '\r': l.append('\\r')
paul@512 495
            elif c == '\\': l.append('\\\\')
paul@451 496
            elif 0x20 <= ord(c) < 0x80: l.append(c)
paul@451 497
            else: l.append("\\x%02x" % ord(c))
paul@451 498
paul@451 499
        return '"%s"' % "".join(l)
paul@136 500
paul@283 501
def encode_literal_data_initialiser(style):
paul@283 502
paul@283 503
    """
paul@283 504
    Encode a reference to a function populating the data for a literal having
paul@283 505
    the given 'style' ("mapping" or "sequence").
paul@283 506
    """
paul@283 507
paul@283 508
    return "__newdata_%s" % style
paul@283 509
paul@159 510
def encode_literal_instantiator(path):
paul@159 511
paul@159 512
    """
paul@159 513
    Encode a reference to an instantiator for a literal having the given 'path'.
paul@159 514
    """
paul@159 515
paul@159 516
    return "__newliteral_%s" % encode_path(path)
paul@159 517
paul@136 518
def encode_literal_reference(n):
paul@136 519
paul@136 520
    "Encode a reference to a literal constant with the number 'n'."
paul@136 521
paul@609 522
    return "__constvalue%s" % n
paul@136 523
paul@512 524
paul@512 525
paul@340 526
# Track all encoded paths, detecting and avoiding conflicts.
paul@340 527
paul@340 528
all_encoded_paths = {}
paul@340 529
paul@0 530
def encode_path(path):
paul@0 531
paul@0 532
    "Encode 'path' as an output program object, translating special symbols."
paul@0 533
paul@0 534
    if path in reserved_words:
paul@0 535
        return "__%s" % path
paul@0 536
    else:
paul@340 537
        part_encoded = path.replace("#", "__").replace("$", "__")
paul@349 538
paul@349 539
        if "." not in path:
paul@349 540
            return part_encoded
paul@349 541
paul@340 542
        encoded = part_encoded.replace(".", "_")
paul@340 543
paul@340 544
        # Test for a conflict with the encoding of a different path, re-encoding
paul@340 545
        # if necessary.
paul@340 546
paul@340 547
        previous = all_encoded_paths.get(encoded)
paul@340 548
        replacement = "_"
paul@340 549
paul@340 550
        while previous:
paul@340 551
            if path == previous:
paul@340 552
                return encoded
paul@340 553
            replacement += "_"
paul@340 554
            encoded = part_encoded.replace(".", replacement)
paul@340 555
            previous = all_encoded_paths.get(encoded)
paul@340 556
paul@340 557
        # Store any new or re-encoded path.
paul@340 558
paul@340 559
        all_encoded_paths[encoded] = path
paul@340 560
        return encoded
paul@0 561
paul@623 562
def encode_code(name):
paul@623 563
paul@623 564
    "Encode 'name' as an attribute code indicator."
paul@623 565
paul@623 566
    return "__ATTRCODE(%s)" % encode_path(name)
paul@623 567
paul@623 568
def encode_pcode(name):
paul@623 569
paul@623 570
    "Encode 'name' as an parameter code indicator."
paul@623 571
paul@623 572
    return "__PARAMCODE(%s)" % encode_path(name)
paul@623 573
paul@623 574
def encode_pos(name):
paul@623 575
paul@623 576
    "Encode 'name' as an attribute position indicator."
paul@623 577
paul@623 578
    return "__ATTRPOS(%s)" % encode_path(name)
paul@623 579
paul@623 580
def encode_ppos(name):
paul@623 581
paul@623 582
    "Encode 'name' as an parameter position indicator."
paul@623 583
paul@623 584
    return "__PARAMPOS(%s)" % encode_path(name)
paul@623 585
paul@136 586
def encode_predefined_reference(path):
paul@136 587
paul@136 588
    "Encode a reference to a predefined constant value for 'path'."
paul@136 589
paul@136 590
    return "__predefined_%s" % encode_path(path)
paul@136 591
paul@150 592
def encode_size(kind, path=None):
paul@150 593
paul@150 594
    """
paul@150 595
    Encode a structure size reference for the given 'kind' of structure, with
paul@150 596
    'path' indicating a specific structure name.
paul@150 597
    """
paul@150 598
paul@150 599
    return "__%ssize%s" % (structure_size_prefixes.get(kind, kind), path and "_%s" % encode_path(path) or "")
paul@150 600
paul@0 601
def encode_symbol(symbol_type, path=None):
paul@0 602
paul@0 603
    "Encode a symbol with the given 'symbol_type' and optional 'path'."
paul@0 604
paul@0 605
    return "__%s%s" % (symbol_type, path and "_%s" % encode_path(path) or "")
paul@0 606
paul@150 607
def encode_tablename(kind, path):
paul@150 608
paul@150 609
    """
paul@150 610
    Encode a table reference for the given 'kind' of table structure, indicating
paul@150 611
    a 'path' for the specific object concerned.
paul@150 612
    """
paul@150 613
paul@150 614
    return "__%sTable_%s" % (table_name_prefixes[kind], encode_path(path))
paul@150 615
paul@131 616
def encode_type_attribute(path):
paul@131 617
paul@131 618
    "Encode the special type attribute for 'path'."
paul@131 619
paul@131 620
    return "#%s" % path
paul@131 621
paul@318 622
def decode_type_attribute(s):
paul@318 623
paul@318 624
    "Decode the special type attribute 's'."
paul@318 625
paul@318 626
    return s[1:]
paul@318 627
paul@318 628
def is_type_attribute(s):
paul@318 629
paul@318 630
    "Return whether 's' is a type attribute name."
paul@318 631
paul@318 632
    return s.startswith("#")
paul@318 633
paul@56 634
paul@56 635
paul@150 636
# A mapping from kinds to structure size reference prefixes.
paul@150 637
paul@150 638
structure_size_prefixes = {
paul@150 639
    "<class>" : "c",
paul@150 640
    "<module>" : "m",
paul@150 641
    "<instance>" : "i"
paul@150 642
    }
paul@150 643
paul@150 644
# A mapping from kinds to table name prefixes.
paul@150 645
paul@150 646
table_name_prefixes = {
paul@150 647
    "<class>" : "Class",
paul@150 648
    "<function>" : "Function",
paul@150 649
    "<module>" : "Module",
paul@150 650
    "<instance>" : "Instance"
paul@150 651
    }
paul@150 652
paul@150 653
paul@150 654
paul@0 655
# Output language reserved words.
paul@0 656
paul@0 657
reserved_words = [
paul@0 658
    "break", "char", "const", "continue",
paul@0 659
    "default", "double", "else",
paul@0 660
    "float", "for",
paul@0 661
    "if", "int", "long",
paul@0 662
    "NULL",
paul@0 663
    "return", "struct",
paul@0 664
    "typedef",
paul@0 665
    "void", "while",
paul@0 666
    ]
paul@0 667
paul@0 668
# vim: tabstop=4 expandtab shiftwidth=4