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