Lib/compiler/ast.py

   1 import types
   2 from consts import CO_VARARGS, CO_VARKEYWORDS
   3
   4 nodes = {}
   5
   6 def flatten(list):
   7   l = []
   8   for elt in list:
   9     if type(elt) is types.TupleType:
  10       for elt2 in flatten(elt):
  11         l.append(elt2)
  12     elif type(elt) is types.ListType:
  13       for elt2 in flatten(elt):
  14         l.append(elt2)
  15     else:
  16       l.append(elt)
  17   return l
  18
  19 def asList(nodes):
  20   l = []
  21   for item in nodes:
  22     if hasattr(item, "asList"):
  23       l.append(item.asList())
  24     else:
  25       if type(item) is types.TupleType:
  26         l.append(tuple(asList(item)))
  27       elif type(item) is types.ListType:
  28         l.append(asList(item))
  29       else:
  30         l.append(item)
  31   return l
  32
  33 class Node:
  34   def __init__(self, *args):
  35     self._children = args
  36     self.lineno = None
  37   def __getitem__(self, index):
  38     return self._children[index]
  39   def __repr__(self):
  40     return "<Node %s>" % self._children[0]
  41   def __len__(self):
  42     return len(self._children)
  43   def __getslice__(self, low, high):
  44     return self._children[low:high]
  45   def getChildren(self):
  46     return tuple(flatten(self._children[1:]))
  47   def getType(self):
  48     return self._children[0]
  49   def asList(self):
  50     return tuple(asList(self._children))
  51
  52 class EmptyNode(Node):
  53   def __init__(self):
  54     self.lineno = None
  55
  56 class Module(Node):
  57   nodes['module'] = 'Module'
  58
  59   def __init__(self, doc, node):
  60     self.doc = doc
  61     self.node = node
  62     self._children = ('module', doc, node)
  63
  64   def __repr__(self):
  65     return "Module(%s,%s)" % self._children[1:]
  66
  67 class Stmt(Node):
  68   nodes['stmt'] = 'Stmt'
  69
  70   def __init__(self, nodes):
  71     self.nodes = nodes
  72     self._children = ('stmt', nodes)
  73
  74   def __repr__(self):
  75     return "Stmt(%s)" % self._children[1:]
  76
  77 class Function(Node):
  78   nodes['function'] = 'Function'
  79
  80   def __init__(self, name, argnames, defaults, flags, doc, code):
  81     self.name = name
  82     self.argnames = argnames
  83     self.defaults = defaults
  84     self.flags = flags
  85     self.doc = doc
  86     self.code = code
  87     self._children = ('function',
  88                        name, argnames, defaults, flags, doc, code)
  89     self.varargs = self.kwargs = None
  90     if flags & CO_VARARGS:
  91       self.varargs = 1
  92     if flags & CO_VARKEYWORDS:
  93       self.kwargs = 1
  94
  95
  96   def __repr__(self):
  97     return "Function(%s,%s,%s,%s,%s,%s)" % self._children[1:]
  98
  99 class Lambda(Node):
 100   nodes['lambda'] = 'Lambda'
 101
 102   def __init__(self, argnames, defaults, flags, code):
 103     self.argnames = argnames
 104     self.defaults = defaults
 105     self.flags = flags
 106     self.code = code
 107     self._children = ('lambda', argnames, defaults, flags, code)
 108
 109   def __repr__(self):
 110     return "Lambda(%s,%s,%s,%s)" % self._children[1:]
 111
 112 class Classdef(Node):
 113   nodes['classdef'] = 'Classdef'
 114
 115   def __init__(self, name, bases, doc, code):
 116     self.name = name
 117     self.bases = bases
 118     self.doc = doc
 119     self.code = code
 120     self._children = ('classdef', name, bases, doc, code)
 121
 122   def __repr__(self):
 123     return "Classdef(%s,%s,%s,%s)" % self._children[1:]
 124
 125 class Pass(EmptyNode):
 126   nodes['pass'] = 'Pass'
 127   _children = ('pass',)
 128   def __repr__(self):
 129     return "Pass()"
 130
 131 class Break(EmptyNode):
 132   nodes['break'] = 'Break'
 133   _children = ('break',)
 134   def __repr__(self):
 135     return "Break()"
 136
 137 class Continue(EmptyNode):
 138   nodes['continue'] = 'Continue'
 139   _children = ('continue',)
 140   def __repr__(self):
 141     return "Continue()"
 142
 143 class For(Node):
 144   nodes['for'] = 'For'
 145
 146   def __init__(self, assign, list, body, else_):
 147     self.assign = assign
 148     self.list = list
 149     self.body = body
 150     self.else_ = else_
 151     self._children = ('for', assign, list, body, else_)
 152
 153   def __repr__(self):
 154     return "For(%s,%s,%s,%s)" % self._children[1:]
 155
 156 class While(Node):
 157   nodes['while'] = 'While'
 158
 159   def __init__(self, test, body, else_):
 160     self.test = test
 161     self.body = body
 162     self.else_ = else_
 163     self._children = ('while', test, body, else_)
 164
 165   def __repr__(self):
 166     return "While(%s,%s,%s)" % self._children[1:]
 167
 168 class If(Node):
 169   """if: [ (testNode, suiteNode), ...], elseNode"""
 170   nodes['if'] = 'If'
 171
 172   def __init__(self, tests, else_):
 173     self.tests = tests
 174     self.else_ = else_
 175     self._children = ('if', tests, else_)
 176
 177   def __repr__(self):
 178     return "If(%s,%s)" % self._children[1:]
 179
 180 class Exec(Node):
 181   nodes['exec'] = 'Exec'
 182
 183   def __init__(self, expr, locals, globals):
 184     self.expr = expr
 185     self.locals = locals
 186     self.globals = globals
 187     self._children = ('exec', expr, locals, globals)
 188
 189   def __repr__(self):
 190     return "Exec(%s,%s,%s)" % self._children[1:]
 191
 192 class From(Node):
 193   nodes['from'] = 'From'
 194
 195   def __init__(self, modname, names):
 196     self.modname = modname
 197     self.names = names
 198     self._children = ('from', modname, names)
 199
 200   def __repr__(self):
 201     return "From(%s,%s)" % self._children[1:]
 202
 203 class Import(Node):
 204   nodes['import'] = 'Import'
 205
 206   def __init__(self, names):
 207     self.names = names
 208     self._children = ('import', names)
 209
 210   def __repr__(self):
 211     return "Import(%s)" % self._children[1:]
 212
 213 class Raise(Node):
 214   nodes['raise'] = 'Raise'
 215
 216   def __init__(self, expr1, expr2, expr3):
 217     self.expr1 = expr1
 218     self.expr2 = expr2
 219     self.expr3 = expr3
 220     self._children = ('raise', expr1, expr2, expr3)
 221
 222   def __repr__(self):
 223     return "Raise(%s,%s,%s)" % self._children[1:]
 224
 225 class TryFinally(Node):
 226   nodes['tryfinally'] = 'TryFinally'
 227
 228   def __init__(self, body, final):
 229     self.body = body
 230     self.final = final
 231     self._children = ('tryfinally', body, final)
 232
 233   def __repr__(self):
 234     return "TryFinally(%s,%s)" % self._children[1:]
 235
 236 class TryExcept(Node):
 237   """Try/Except body and handlers
 238
 239   The handlers attribute is a sequence of tuples.  The elements of the
 240   tuple are the exception name, the name to bind the exception to, and
 241   the body of the except clause.
 242   """
 243   nodes['tryexcept'] = 'TryExcept'
 244
 245   def __init__(self, body, handlers, else_):
 246     self.body = body
 247     self.handlers = handlers
 248     self.else_ = else_
 249     self._children = ('tryexcept', body, handlers, else_)
 250
 251   def __repr__(self):
 252     return "TryExcept(%s,%s,%s)" % self._children[1:]
 253
 254 class Return(Node):
 255   nodes['return'] = 'Return'
 256
 257   def __init__(self, value):
 258     self.value = value
 259     self._children = ('return', value)
 260
 261   def __repr__(self):
 262     return "Return(%s)" % self._children[1:]
 263
 264 class Const(Node):
 265   nodes['const'] = 'Const'
 266
 267   def __init__(self, value):
 268     self.value = value
 269     self._children = ('const', value)
 270
 271   def __repr__(self):
 272     return "Const(%s)" % self._children[1:]
 273
 274 class Print(Node):
 275   nodes['print'] = 'Print'
 276
 277   def __init__(self, nodes):
 278     self.nodes = nodes
 279     self._children = ('print', nodes)
 280
 281   def __repr__(self):
 282     return "Print(%s)" % self._children[1:]
 283
 284 class Printnl(Node):
 285   nodes['printnl'] = 'Printnl'
 286
 287   def __init__(self, nodes):
 288     self.nodes = nodes
 289     self._children = ('printnl', nodes)
 290
 291   def __repr__(self):
 292     return "Printnl(%s)" % self._children[1:]
 293
 294 class Discard(Node):
 295   nodes['discard'] = 'Discard'
 296
 297   def __init__(self, expr):
 298     self.expr = expr
 299     self._children = ('discard', expr)
 300
 301   def __repr__(self):
 302     return "Discard(%s)" % self._children[1:]
 303
 304 class Assign(Node):
 305   nodes['assign'] = 'Assign'
 306
 307   def __init__(self, nodes, expr):
 308     self.nodes = nodes
 309     self.expr = expr
 310     self._children = ('assign', nodes, expr)
 311
 312   def __repr__(self):
 313     return "Assign(%s,%s)" % self._children[1:]
 314
 315 class AssTuple(Node):
 316   nodes['ass_tuple'] = 'AssTuple'
 317
 318   def __init__(self, nodes):
 319     self.nodes = nodes
 320     self._children = ('ass_tuple', nodes)
 321
 322   def __repr__(self):
 323     return "AssTuple(%s)" % self._children[1:]
 324
 325 class AssList(Node):
 326   nodes['ass_list'] = 'AssList'
 327
 328   def __init__(self, nodes):
 329     self.nodes = nodes
 330     self._children = ('ass_list', nodes)
 331
 332   def __repr__(self):
 333     return "AssList(%s)" % self._children[1:]
 334
 335 class AssName(Node):
 336   nodes['ass_name'] = 'AssName'
 337
 338   def __init__(self, name, flags):
 339     self.name = name
 340     self.flags = flags
 341     self._children = ('ass_name', name, flags)
 342
 343   def __repr__(self):
 344     return "AssName(%s,%s)" % self._children[1:]
 345
 346 class AssAttr(Node):
 347   nodes['ass_attr'] = 'AssAttr'
 348
 349   def __init__(self, expr, attrname, flags):
 350     self.expr = expr
 351     self.attrname = attrname
 352     self.flags = flags
 353     self._children = ('ass_attr', expr, attrname, flags)
 354
 355   def __repr__(self):
 356     return "AssAttr(%s,%s,%s)" % self._children[1:]
 357
 358 class List(Node):
 359   nodes['list'] = 'List'
 360
 361   def __init__(self, nodes):
 362     self.nodes = nodes
 363     self._children = ('list', nodes)
 364
 365   def __repr__(self):
 366     return "List(%s)" % self._children[1:]
 367
 368 class Dict(Node):
 369   nodes['dict'] = 'Dict'
 370
 371   def __init__(self, items):
 372     self.items = items
 373     self._children = ('dict', items)
 374
 375   def __repr__(self):
 376     return "Dict(%s)" % self._children[1:]
 377
 378 class Not(Node):
 379   nodes['not'] = 'Not'
 380
 381   def __init__(self, expr):
 382     self.expr = expr
 383     self._children = ('not', expr)
 384
 385   def __repr__(self):
 386     return "Not(%s)" % self._children[1:]
 387
 388 class Compare(Node):
 389   nodes['compare'] = 'Compare'
 390
 391   def __init__(self, expr, ops):
 392     self.expr = expr
 393     self.ops = ops
 394     self._children = ('compare', expr, ops)
 395
 396   def __repr__(self):
 397     return "Compare(%s,%s)" % self._children[1:]
 398
 399 class Name(Node):
 400   nodes['name'] = 'Name'
 401
 402   def __init__(self, name):
 403     self.name = name
 404     self._children = ('name', name)
 405
 406   def __repr__(self):
 407     return "Name(%s)" % self._children[1:]
 408
 409 class Global(Node):
 410   nodes['global'] = 'Global'
 411
 412   def __init__(self, names):
 413     self.names = names
 414     self._children = ('global', names)
 415
 416   def __repr__(self):
 417     return "Global(%s)" % self._children[1:]
 418
 419 class Backquote(Node):
 420   nodes['backquote'] = 'Backquote'
 421
 422   def __init__(self, node):
 423     self.expr = node
 424     self._children = ('backquote', node)
 425
 426   def __repr__(self):
 427     return "Backquote(%s)" % self._children[1:]
 428
 429 class Getattr(Node):
 430   nodes['getattr'] = 'Getattr'
 431
 432   def __init__(self, expr, attrname):
 433     self.expr = expr
 434     self.attrname = attrname
 435     self._children = ('getattr', expr, attrname)
 436
 437   def __repr__(self):
 438     return "Getattr(%s,%s)" % self._children[1:]
 439
 440 class CallFunc(Node):
 441   nodes['call_func'] = 'CallFunc'
 442
 443   def __init__(self, node, args):
 444     self.node = node
 445     self.args = args
 446     self._children = ('call_func', node, args)
 447
 448   def __repr__(self):
 449     return "CallFunc(%s,%s)" % self._children[1:]
 450
 451 class Keyword(Node):
 452   nodes['keyword'] = 'Keyword'
 453
 454   def __init__(self, name, expr):
 455     self.name = name
 456     self.expr = expr
 457     self._children = ('keyword', name, expr)
 458
 459   def __repr__(self):
 460     return "Keyword(%s,%s)" % self._children[1:]
 461
 462 class Subscript(Node):
 463   nodes['subscript'] = 'Subscript'
 464
 465   def __init__(self, expr, flags, subs):
 466     self.expr = expr
 467     self.flags = flags
 468     self.subs = subs
 469     self._children = ('subscript', expr, flags, subs)
 470
 471   def __repr__(self):
 472     return "Subscript(%s,%s,%s)" % self._children[1:]
 473
 474 class Ellipsis(EmptyNode):
 475   nodes['ellipsis'] = 'Ellipsis'
 476   _children = ('ellipsis',)
 477   def __repr__(self):
 478     return "Ellipsis()"
 479
 480 class Sliceobj(Node):
 481   nodes['sliceobj'] = 'Sliceobj'
 482
 483   def __init__(self, nodes):
 484     self.nodes = nodes
 485     self._children = ('sliceobj', nodes)
 486
 487   def __repr__(self):
 488     return "Sliceobj(%s)" % self._children[1:]
 489
 490 class Slice(Node):
 491   nodes['slice'] = 'Slice'
 492
 493   def __init__(self, expr, flags, lower, upper):
 494     self.expr = expr
 495     self.flags = flags
 496     self.lower = lower
 497     self.upper = upper
 498     self._children = ('slice', expr, flags, lower, upper)
 499
 500   def __repr__(self):
 501     return "Slice(%s,%s,%s,%s)" % self._children[1:]
 502
 503 class Assert(Node):
 504   nodes['assert'] = 'Assert'
 505
 506   def __init__(self, test, fail):
 507     self.test = test
 508     self.fail = fail
 509     self._children = ('assert', test, fail)
 510
 511   def __repr__(self):
 512     return "Assert(%s,%s)" % self._children[1:]
 513
 514 class Tuple(Node):
 515   nodes['tuple'] = 'Tuple'
 516
 517   def __init__(self, nodes):
 518     self.nodes = nodes
 519     self._children = ('tuple', nodes)
 520
 521   def __repr__(self):
 522     return "Tuple(%s)" % self._children[1:]
 523
 524 class Or(Node):
 525   nodes['or'] = 'Or'
 526
 527   def __init__(self, nodes):
 528     self.nodes = nodes
 529     self._children = ('or', nodes)
 530
 531   def __repr__(self):
 532     return "Or(%s)" % self._children[1:]
 533
 534 class And(Node):
 535   nodes['and'] = 'And'
 536
 537   def __init__(self, nodes):
 538     self.nodes = nodes
 539     self._children = ('and', nodes)
 540
 541   def __repr__(self):
 542     return "And(%s)" % self._children[1:]
 543
 544 class Bitor(Node):
 545   nodes['bitor'] = 'Bitor'
 546
 547   def __init__(self, nodes):
 548     self.nodes = nodes
 549     self._children = ('bitor', nodes)
 550
 551   def __repr__(self):
 552     return "Bitor(%s)" % self._children[1:]
 553
 554 class Bitxor(Node):
 555   nodes['bitxor'] = 'Bitxor'
 556
 557   def __init__(self, nodes):
 558     self.nodes = nodes
 559     self._children = ('bitxor', nodes)
 560
 561   def __repr__(self):
 562     return "Bitxor(%s)" % self._children[1:]
 563
 564 class Bitand(Node):
 565   nodes['bitand'] = 'Bitand'
 566
 567   def __init__(self, nodes):
 568     self.nodes = nodes
 569     self._children = ('bitand', nodes)
 570
 571   def __repr__(self):
 572     return "Bitand(%s)" % self._children[1:]
 573
 574 class LeftShift(Node):
 575   nodes['<<'] = 'LeftShift'
 576
 577   def __init__(self, (left, right)):
 578     self.left = left
 579     self.right = right
 580     self._children = ('<<', (left, right))
 581
 582   def __repr__(self):
 583     return "LeftShift(%s)" % self._children[1:]
 584
 585 class RightShift(Node):
 586   nodes['>>'] = 'RightShift'
 587
 588   def __init__(self, (left, right)):
 589     self.left = left
 590     self.right = right
 591     self._children = ('>>', (left, right))
 592
 593   def __repr__(self):
 594     return "RightShift(%s)" % self._children[1:]
 595
 596 class Add(Node):
 597   nodes['+'] = 'Add'
 598
 599   def __init__(self, (left, right)):
 600     self.left = left
 601     self.right = right
 602     self._children = ('+', (left, right))
 603
 604   def __repr__(self):
 605     return "Add(%s)" % self._children[1:]
 606
 607 class Sub(Node):
 608   nodes['-'] = 'Sub'
 609
 610   def __init__(self, (left, right)):
 611     self.left = left
 612     self.right = right
 613     self._children = ('-', (left, right))
 614
 615   def __repr__(self):
 616     return "Sub(%s)" % self._children[1:]
 617
 618 class Mul(Node):
 619   nodes['*'] = 'Mul'
 620
 621   def __init__(self, (left, right)):
 622     self.left = left
 623     self.right = right
 624     self._children = ('*', (left, right))
 625
 626   def __repr__(self):
 627     return "Mul(%s)" % self._children[1:]
 628
 629 class Div(Node):
 630   nodes['/'] = 'Div'
 631
 632   def __init__(self, (left, right)):
 633     self.left = left
 634     self.right = right
 635     self._children = ('/', (left, right))
 636
 637   def __repr__(self):
 638     return "Div(%s)" % self._children[1:]
 639
 640 class Mod(Node):
 641   nodes['%'] = 'Mod'
 642
 643   def __init__(self, (left, right)):
 644     self.left = left
 645     self.right = right
 646     self._children = ('%', (left, right))
 647
 648   def __repr__(self):
 649     return "Mod(%s)" % self._children[1:]
 650
 651 class Power(Node):
 652   nodes['power'] = 'Power'
 653
 654   def __init__(self, (left, right)):
 655     self.left = left
 656     self.right = right
 657     self._children = ('power', (left, right))
 658
 659   def __repr__(self):
 660     return "Power(%s)" % self._children[1:]
 661
 662 class UnaryAdd(Node):
 663   nodes['unary+'] = 'UnaryAdd'
 664
 665   def __init__(self, node):
 666     self.expr = node
 667     self._children = ('unary+', node)
 668
 669   def __repr__(self):
 670     return "UnaryAdd(%s)" % self._children[1:]
 671
 672 class UnarySub(Node):
 673   nodes['unary-'] = 'UnarySub'
 674
 675   def __init__(self, node):
 676     self.expr = node
 677     self._children = ('unary-', node)
 678
 679   def __repr__(self):
 680     return "UnarySub(%s)" % self._children[1:]
 681
 682 class Invert(Node):
 683   nodes['invert'] = 'Invert'
 684
 685   def __init__(self, node):
 686     self.expr = node
 687     self._children = ('invert', node)
 688
 689   def __repr__(self):
 690     return "Invert(%s)" % self._children[1:]
 691
 692 # now clean up the nodes dictionary
 693 klasses = globals()
 694 for k in nodes.keys():
 695   nodes[k] = klasses[nodes[k]]
 696
 697 # Local Variables:
 698 # mode:python
 699 # indent-tabs-mode: nil
 700 # py-indent-offset: 2
 701 # py-smart-indentation: nil
 702 # End: