Lib/compiler/ast.py

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