ast.py

   1 import element
   2 #import xml.etree.ElementTree
   3
   4 class Context:
   5   def __init__(
   6     self,
   7     indent = '',
   8     enclosing_loop = None,
   9     initial = False,
  10     translate_identifier = {
  11       'NULL': 'None',
  12       'false': 'False',
  13       'strlen': 'len',
  14       'true': 'True'
  15     }
  16   ):
  17     self.indent = '  '
  18     self.enclosing_loop = enclosing_loop
  19     self.initial = initial # whether to add declared identifiers as 'self.'
  20     self.translate_identifier = translate_identifier
  21
  22 class Element(element.Element):
  23   # GENERATE ELEMENT() BEGIN
  24   def __init__(
  25     self,
  26     tag = 'Element',
  27     attrib = {},
  28     text = '',
  29     children = []
  30   ):
  31     element.Element.__init__(
  32       self,
  33       tag,
  34       attrib,
  35       text,
  36       children
  37     )
  38   def copy(self, factory = None):
  39     result = element.Element.copy(
  40       self,
  41       Element if factory is None else factory
  42     )
  43     return result
  44   def __repr__(self):
  45     params = []
  46     self.repr_serialize(params)
  47     return 'ast.Element({0:s})'.format(', '.join(params))
  48   # GENERATE END
  49   def translate(self, context):
  50     for i in self:
  51       i.translate(context)
  52     prev_empty = True
  53     for i in range(len(self) + 1):
  54       text = element.get_text(self, i).strip()
  55       next_empty = (
  56         i >= len(self) or
  57         (len(self[i]) == 0 and len(element.get_text(self[i], 0)) == 0)
  58       )
  59       if len(text) == 0:
  60         if prev_empty:
  61           text = ''
  62           prev_empty = next_empty
  63         elif next_empty:
  64           text = ''
  65           prev_empty = False
  66         else:
  67           text = ' '
  68       else:
  69         if prev_empty:
  70           prev_empty = False
  71         elif text[0] not in ',;)}]':
  72           text = ' ' + text
  73         if next_empty:
  74           prev_empty = text[-1] in '({['
  75         elif text[0] not in '({[':
  76           text = text + ' '
  77       element.set_text(self, i, text)
  78
  79 class DeclarationOrStatement(Element):
  80   # GENERATE ELEMENT() BEGIN
  81   def __init__(
  82     self,
  83     tag = 'DeclarationOrStatement',
  84     attrib = {},
  85     text = '',
  86     children = []
  87   ):
  88     Element.__init__(
  89       self,
  90       tag,
  91       attrib,
  92       text,
  93       children
  94     )
  95   def copy(self, factory = None):
  96     result = Element.copy(
  97       self,
  98       DeclarationOrStatement if factory is None else factory
  99     )
 100     return result
 101   def __repr__(self):
 102     params = []
 103     self.repr_serialize(params)
 104     return 'ast.DeclarationOrStatement({0:s})'.format(', '.join(params))
 105   # GENERATE END
 106   def translate(self, context):
 107     Element.translate(self, context)
 108     element.set_text(
 109       self,
 110       0,
 111       '{0:s}{1:s}'.format(context.indent, element.get_text(self, 0))
 112     )
 113     text = element.get_text(self, len(self))
 114     if text[-1:] == ';':
 115       text = text[:-1]
 116     element.set_text(self, len(self), '{0:s}\n'.format(text))
 117
 118 class AlignAsExpression(Element):
 119   # GENERATE ELEMENT() BEGIN
 120   def __init__(
 121     self,
 122     tag = 'AlignAsExpression',
 123     attrib = {},
 124     text = '',
 125     children = []
 126   ):
 127     Element.__init__(
 128       self,
 129       tag,
 130       attrib,
 131       text,
 132       children
 133     )
 134   def copy(self, factory = None):
 135     result = Element.copy(
 136       self,
 137       AlignAsExpression if factory is None else factory
 138     )
 139     return result
 140   def __repr__(self):
 141     params = []
 142     self.repr_serialize(params)
 143     return 'ast.AlignAsExpression({0:s})'.format(', '.join(params))
 144   # GENERATE END
 145
 146 class AlignAsType(Element):
 147   # GENERATE ELEMENT() BEGIN
 148   def __init__(
 149     self,
 150     tag = 'AlignAsType',
 151     attrib = {},
 152     text = '',
 153     children = []
 154   ):
 155     Element.__init__(
 156       self,
 157       tag,
 158       attrib,
 159       text,
 160       children
 161     )
 162   def copy(self, factory = None):
 163     result = Element.copy(
 164       self,
 165       AlignAsType if factory is None else factory
 166     )
 167     return result
 168   def __repr__(self):
 169     params = []
 170     self.repr_serialize(params)
 171     return 'ast.AlignAsType({0:s})'.format(', '.join(params))
 172   # GENERATE END
 173
 174 class ArgumentExpressionList(Element):
 175   # GENERATE ELEMENT() BEGIN
 176   def __init__(
 177     self,
 178     tag = 'ArgumentExpressionList',
 179     attrib = {},
 180     text = '',
 181     children = []
 182   ):
 183     Element.__init__(
 184       self,
 185       tag,
 186       attrib,
 187       text,
 188       children
 189     )
 190   def copy(self, factory = None):
 191     result = Element.copy(
 192       self,
 193       ArgumentExpressionList if factory is None else factory
 194     )
 195     return result
 196   def __repr__(self):
 197     params = []
 198     self.repr_serialize(params)
 199     return 'ast.ArgumentExpressionList({0:s})'.format(', '.join(params))
 200   # GENERATE END
 201
 202 class BlockItemList(Element):
 203   # GENERATE ELEMENT() BEGIN
 204   def __init__(
 205     self,
 206     tag = 'BlockItemList',
 207     attrib = {},
 208     text = '',
 209     children = []
 210   ):
 211     Element.__init__(
 212       self,
 213       tag,
 214       attrib,
 215       text,
 216       children
 217     )
 218   def copy(self, factory = None):
 219     result = Element.copy(
 220       self,
 221       BlockItemList if factory is None else factory
 222     )
 223     return result
 224   def __repr__(self):
 225     params = []
 226     self.repr_serialize(params)
 227     return 'ast.BlockItemList({0:s})'.format(', '.join(params))
 228   # GENERATE END
 229   def translate(self, context):
 230     for i in self:
 231       i.translate(context)
 232     for i in range(len(self) + 1):
 233       element.set_text(self, i, '')
 234
 235 class CommaEllipsis(Element):
 236   # GENERATE ELEMENT() BEGIN
 237   def __init__(
 238     self,
 239     tag = 'CommaEllipsis',
 240     attrib = {},
 241     text = '',
 242     children = []
 243   ):
 244     Element.__init__(
 245       self,
 246       tag,
 247       attrib,
 248       text,
 249       children
 250     )
 251   def copy(self, factory = None):
 252     result = Element.copy(
 253       self,
 254       CommaEllipsis if factory is None else factory
 255     )
 256     return result
 257   def __repr__(self):
 258     params = []
 259     self.repr_serialize(params)
 260     return 'ast.CommaEllipsis({0:s})'.format(', '.join(params))
 261   # GENERATE END
 262
 263 class CommaEllipsisEmpty(Element):
 264   # GENERATE ELEMENT() BEGIN
 265   def __init__(
 266     self,
 267     tag = 'CommaEllipsisEmpty',
 268     attrib = {},
 269     text = '',
 270     children = []
 271   ):
 272     Element.__init__(
 273       self,
 274       tag,
 275       attrib,
 276       text,
 277       children
 278     )
 279   def copy(self, factory = None):
 280     result = Element.copy(
 281       self,
 282       CommaEllipsisEmpty if factory is None else factory
 283     )
 284     return result
 285   def __repr__(self):
 286     params = []
 287     self.repr_serialize(params)
 288     return 'ast.CommaEllipsisEmpty({0:s})'.format(', '.join(params))
 289   # GENERATE END
 290
 291 class Declaration(DeclarationOrStatement):
 292   # GENERATE ELEMENT() BEGIN
 293   def __init__(
 294     self,
 295     tag = 'Declaration',
 296     attrib = {},
 297     text = '',
 298     children = []
 299   ):
 300     DeclarationOrStatement.__init__(
 301       self,
 302       tag,
 303       attrib,
 304       text,
 305       children
 306     )
 307   def copy(self, factory = None):
 308     result = DeclarationOrStatement.copy(
 309       self,
 310       Declaration if factory is None else factory
 311     )
 312     return result
 313   def __repr__(self):
 314     params = []
 315     self.repr_serialize(params)
 316     return 'ast.Declaration({0:s})'.format(', '.join(params))
 317   # GENERATE END
 318
 319 class DeclarationList(Element):
 320   # GENERATE ELEMENT() BEGIN
 321   def __init__(
 322     self,
 323     tag = 'DeclarationList',
 324     attrib = {},
 325     text = '',
 326     children = []
 327   ):
 328     Element.__init__(
 329       self,
 330       tag,
 331       attrib,
 332       text,
 333       children
 334     )
 335   def copy(self, factory = None):
 336     result = Element.copy(
 337       self,
 338       DeclarationList if factory is None else factory
 339     )
 340     return result
 341   def __repr__(self):
 342     params = []
 343     self.repr_serialize(params)
 344     return 'ast.DeclarationList({0:s})'.format(', '.join(params))
 345   # GENERATE END
 346
 347 class DeclarationSpecifierList(Element):
 348   # GENERATE ELEMENT() BEGIN
 349   def __init__(
 350     self,
 351     tag = 'DeclarationSpecifierList',
 352     attrib = {},
 353     text = '',
 354     children = []
 355   ):
 356     Element.__init__(
 357       self,
 358       tag,
 359       attrib,
 360       text,
 361       children
 362     )
 363   def copy(self, factory = None):
 364     result = Element.copy(
 365       self,
 366       DeclarationSpecifierList if factory is None else factory
 367     )
 368     return result
 369   def __repr__(self):
 370     params = []
 371     self.repr_serialize(params)
 372     return 'ast.DeclarationSpecifierList({0:s})'.format(', '.join(params))
 373   # GENERATE END
 374
 375 class Declarator(Element):
 376   # GENERATE ELEMENT() BEGIN
 377   def __init__(
 378     self,
 379     tag = 'Declarator',
 380     attrib = {},
 381     text = '',
 382     children = []
 383   ):
 384     Element.__init__(
 385       self,
 386       tag,
 387       attrib,
 388       text,
 389       children
 390     )
 391   def copy(self, factory = None):
 392     result = Element.copy(
 393       self,
 394       Declarator if factory is None else factory
 395     )
 396     return result
 397   def __repr__(self):
 398     params = []
 399     self.repr_serialize(params)
 400     return 'ast.Declarator({0:s})'.format(', '.join(params))
 401   # GENERATE END
 402
 403 class DeclaratorAbstract(Declarator):
 404   # GENERATE ELEMENT() BEGIN
 405   def __init__(
 406     self,
 407     tag = 'DeclaratorAbstract',
 408     attrib = {},
 409     text = '',
 410     children = []
 411   ):
 412     Declarator.__init__(
 413       self,
 414       tag,
 415       attrib,
 416       text,
 417       children
 418     )
 419   def copy(self, factory = None):
 420     result = Declarator.copy(
 421       self,
 422       DeclaratorAbstract if factory is None else factory
 423     )
 424     return result
 425   def __repr__(self):
 426     params = []
 427     self.repr_serialize(params)
 428     return 'ast.DeclaratorAbstract({0:s})'.format(', '.join(params))
 429   # GENERATE END
 430
 431 class DeclaratorArray(Declarator):
 432   # GENERATE ELEMENT() BEGIN
 433   def __init__(
 434     self,
 435     tag = 'DeclaratorArray',
 436     attrib = {},
 437     text = '',
 438     children = []
 439   ):
 440     Declarator.__init__(
 441       self,
 442       tag,
 443       attrib,
 444       text,
 445       children
 446     )
 447   def copy(self, factory = None):
 448     result = Declarator.copy(
 449       self,
 450       DeclaratorArray if factory is None else factory
 451     )
 452     return result
 453   def __repr__(self):
 454     params = []
 455     self.repr_serialize(params)
 456     return 'ast.DeclaratorArray({0:s})'.format(', '.join(params))
 457   # GENERATE END
 458   def translate(self, context):
 459     assert len(self) == 3
 460     self[0].translate(context)
 461     self[1].translate(context)
 462     self[2].translate(context)
 463     element.set_text(self, 0, '')
 464     element.set_text(self, 1, '[')
 465     element.set_text(
 466       self,
 467       2,
 468       ' ' if len(self[1]) or len(element.get_text(self[1], 0)) else ''
 469     )
 470     element.set_text(self, 3, ']')
 471
 472 class DeclaratorEmpty(Declarator):
 473   # GENERATE ELEMENT() BEGIN
 474   def __init__(
 475     self,
 476     tag = 'DeclaratorEmpty',
 477     attrib = {},
 478     text = '',
 479     children = []
 480   ):
 481     Declarator.__init__(
 482       self,
 483       tag,
 484       attrib,
 485       text,
 486       children
 487     )
 488   def copy(self, factory = None):
 489     result = Declarator.copy(
 490       self,
 491       DeclaratorEmpty if factory is None else factory
 492     )
 493     return result
 494   def __repr__(self):
 495     params = []
 496     self.repr_serialize(params)
 497     return 'ast.DeclaratorEmpty({0:s})'.format(', '.join(params))
 498   # GENERATE END
 499
 500 class DeclaratorFunction(Declarator):
 501   # GENERATE ELEMENT() BEGIN
 502   def __init__(
 503     self,
 504     tag = 'DeclaratorFunction',
 505     attrib = {},
 506     text = '',
 507     children = []
 508   ):
 509     Declarator.__init__(
 510       self,
 511       tag,
 512       attrib,
 513       text,
 514       children
 515     )
 516   def copy(self, factory = None):
 517     result = Declarator.copy(
 518       self,
 519       DeclaratorFunction if factory is None else factory
 520     )
 521     return result
 522   def __repr__(self):
 523     params = []
 524     self.repr_serialize(params)
 525     return 'ast.DeclaratorFunction({0:s})'.format(', '.join(params))
 526   # GENERATE END
 527   def translate(self, context):
 528     assert len(self) == 3
 529     self[0].translate(context)
 530     initial_save = context.initial
 531     context.initial = False
 532     self[1].translate(context)
 533     self[2].translate(context)
 534     context.initial = initial_save
 535     element.set_text(self, 0, '')
 536     element.set_text(self, 1, '(')
 537     element.set_text(self, 2, '')
 538     element.set_text(self, 3, ')')
 539
 540 class DeclaratorFunctionOldStyle(Declarator):
 541   # GENERATE ELEMENT() BEGIN
 542   def __init__(
 543     self,
 544     tag = 'DeclaratorFunctionOldStyle',
 545     attrib = {},
 546     text = '',
 547     children = []
 548   ):
 549     Declarator.__init__(
 550       self,
 551       tag,
 552       attrib,
 553       text,
 554       children
 555     )
 556   def copy(self, factory = None):
 557     result = Declarator.copy(
 558       self,
 559       DeclaratorFunctionOldStyle if factory is None else factory
 560     )
 561     return result
 562   def __repr__(self):
 563     params = []
 564     self.repr_serialize(params)
 565     return 'ast.DeclaratorFunctionOldStyle({0:s})'.format(', '.join(params))
 566   # GENERATE END
 567   def translate(self, context):
 568     assert len(self) == 2
 569     self[0].translate(context)
 570     initial_save = context.initial
 571     context.initial = False
 572     self[1].translate(context)
 573     context.initial = initial_save
 574     element.set_text(self, 0, '')
 575     element.set_text(self, 1, '(')
 576     element.set_text(self, 2, ')')
 577
 578 class DeclaratorIdentifier(Declarator):
 579   # GENERATE ELEMENT() BEGIN
 580   def __init__(
 581     self,
 582     tag = 'DeclaratorIdentifier',
 583     attrib = {},
 584     text = '',
 585     children = []
 586   ):
 587     Declarator.__init__(
 588       self,
 589       tag,
 590       attrib,
 591       text,
 592       children
 593     )
 594   def copy(self, factory = None):
 595     result = Declarator.copy(
 596       self,
 597       DeclaratorIdentifier if factory is None else factory
 598     )
 599     return result
 600   def __repr__(self):
 601     params = []
 602     self.repr_serialize(params)
 603     return 'ast.DeclaratorIdentifier({0:s})'.format(', '.join(params))
 604   # GENERATE END
 605   def translate(self, context):
 606     if context.initial:
 607       text = element.get_text(self[0], 0)
 608       assert text not in context.translate_identifier
 609       context.translate_identifier[text] = 'self.{0:s}'.format(text)
 610     Declarator.translate(self, context)
 611
 612 class DeclaratorPointer(Declarator):
 613   # GENERATE ELEMENT() BEGIN
 614   def __init__(
 615     self,
 616     tag = 'DeclaratorPointer',
 617     attrib = {},
 618     text = '',
 619     children = []
 620   ):
 621     Declarator.__init__(
 622       self,
 623       tag,
 624       attrib,
 625       text,
 626       children
 627     )
 628   def copy(self, factory = None):
 629     result = Declarator.copy(
 630       self,
 631       DeclaratorPointer if factory is None else factory
 632     )
 633     return result
 634   def __repr__(self):
 635     params = []
 636     self.repr_serialize(params)
 637     return 'ast.DeclaratorPointer({0:s})'.format(', '.join(params))
 638   # GENERATE END
 639   def translate(self, context):
 640     assert len(self) == 2
 641     self[0].translate(context)
 642     self[1].translate(context)
 643     element.set_text(self, 0, '*')
 644     element.set_text(
 645       self,
 646       1,
 647       ' ' if len(self[0]) or len(element.get_text(self[0], 0)) else ''
 648     )
 649
 650 class DefaultTypeName(Element):
 651   # GENERATE ELEMENT() BEGIN
 652   def __init__(
 653     self,
 654     tag = 'DefaultTypeName',
 655     attrib = {},
 656     text = '',
 657     children = []
 658   ):
 659     Element.__init__(
 660       self,
 661       tag,
 662       attrib,
 663       text,
 664       children
 665     )
 666   def copy(self, factory = None):
 667     result = Element.copy(
 668       self,
 669       DefaultTypeName if factory is None else factory
 670     )
 671     return result
 672   def __repr__(self):
 673     params = []
 674     self.repr_serialize(params)
 675     return 'ast.DefaultTypeName({0:s})'.format(', '.join(params))
 676   # GENERATE END
 677
 678 class DesignatorField(Element):
 679   # GENERATE ELEMENT() BEGIN
 680   def __init__(
 681     self,
 682     tag = 'DesignatorField',
 683     attrib = {},
 684     text = '',
 685     children = []
 686   ):
 687     Element.__init__(
 688       self,
 689       tag,
 690       attrib,
 691       text,
 692       children
 693     )
 694   def copy(self, factory = None):
 695     result = Element.copy(
 696       self,
 697       DesignatorField if factory is None else factory
 698     )
 699     return result
 700   def __repr__(self):
 701     params = []
 702     self.repr_serialize(params)
 703     return 'ast.DesignatorField({0:s})'.format(', '.join(params))
 704   # GENERATE END
 705
 706 class DesignatorIndex(Element):
 707   # GENERATE ELEMENT() BEGIN
 708   def __init__(
 709     self,
 710     tag = 'DesignatorIndex',
 711     attrib = {},
 712     text = '',
 713     children = []
 714   ):
 715     Element.__init__(
 716       self,
 717       tag,
 718       attrib,
 719       text,
 720       children
 721     )
 722   def copy(self, factory = None):
 723     result = Element.copy(
 724       self,
 725       DesignatorIndex if factory is None else factory
 726     )
 727     return result
 728   def __repr__(self):
 729     params = []
 730     self.repr_serialize(params)
 731     return 'ast.DesignatorIndex({0:s})'.format(', '.join(params))
 732   # GENERATE END
 733
 734 class DesignatorInitializer(Element):
 735   # GENERATE ELEMENT() BEGIN
 736   def __init__(
 737     self,
 738     tag = 'DesignatorInitializer',
 739     attrib = {},
 740     text = '',
 741     children = []
 742   ):
 743     Element.__init__(
 744       self,
 745       tag,
 746       attrib,
 747       text,
 748       children
 749     )
 750   def copy(self, factory = None):
 751     result = Element.copy(
 752       self,
 753       DesignatorInitializer if factory is None else factory
 754     )
 755     return result
 756   def __repr__(self):
 757     params = []
 758     self.repr_serialize(params)
 759     return 'ast.DesignatorInitializer({0:s})'.format(', '.join(params))
 760   # GENERATE END
 761
 762 class DesignatorInitializerList(Element):
 763   # GENERATE ELEMENT() BEGIN
 764   def __init__(
 765     self,
 766     tag = 'DesignatorInitializerList',
 767     attrib = {},
 768     text = '',
 769     children = []
 770   ):
 771     Element.__init__(
 772       self,
 773       tag,
 774       attrib,
 775       text,
 776       children
 777     )
 778   def copy(self, factory = None):
 779     result = Element.copy(
 780       self,
 781       DesignatorInitializerList if factory is None else factory
 782     )
 783     return result
 784   def __repr__(self):
 785     params = []
 786     self.repr_serialize(params)
 787     return 'ast.DesignatorInitializerList({0:s})'.format(', '.join(params))
 788   # GENERATE END
 789
 790 class DesignatorList(Element):
 791   # GENERATE ELEMENT() BEGIN
 792   def __init__(
 793     self,
 794     tag = 'DesignatorList',
 795     attrib = {},
 796     text = '',
 797     children = []
 798   ):
 799     Element.__init__(
 800       self,
 801       tag,
 802       attrib,
 803       text,
 804       children
 805     )
 806   def copy(self, factory = None):
 807     result = Element.copy(
 808       self,
 809       DesignatorList if factory is None else factory
 810     )
 811     return result
 812   def __repr__(self):
 813     params = []
 814     self.repr_serialize(params)
 815     return 'ast.DesignatorList({0:s})'.format(', '.join(params))
 816   # GENERATE END
 817
 818 class EnumSpecifier(Element):
 819   # GENERATE ELEMENT() BEGIN
 820   def __init__(
 821     self,
 822     tag = 'EnumSpecifier',
 823     attrib = {},
 824     text = '',
 825     children = []
 826   ):
 827     Element.__init__(
 828       self,
 829       tag,
 830       attrib,
 831       text,
 832       children
 833     )
 834   def copy(self, factory = None):
 835     result = Element.copy(
 836       self,
 837       EnumSpecifier if factory is None else factory
 838     )
 839     return result
 840   def __repr__(self):
 841     params = []
 842     self.repr_serialize(params)
 843     return 'ast.EnumSpecifier({0:s})'.format(', '.join(params))
 844   # GENERATE END
 845
 846 class Enumerator(Element):
 847   # GENERATE ELEMENT() BEGIN
 848   def __init__(
 849     self,
 850     tag = 'Enumerator',
 851     attrib = {},
 852     text = '',
 853     children = []
 854   ):
 855     Element.__init__(
 856       self,
 857       tag,
 858       attrib,
 859       text,
 860       children
 861     )
 862   def copy(self, factory = None):
 863     result = Element.copy(
 864       self,
 865       Enumerator if factory is None else factory
 866     )
 867     return result
 868   def __repr__(self):
 869     params = []
 870     self.repr_serialize(params)
 871     return 'ast.Enumerator({0:s})'.format(', '.join(params))
 872   # GENERATE END
 873
 874 class EnumeratorList(Element):
 875   # GENERATE ELEMENT() BEGIN
 876   def __init__(
 877     self,
 878     tag = 'EnumeratorList',
 879     attrib = {},
 880     text = '',
 881     children = []
 882   ):
 883     Element.__init__(
 884       self,
 885       tag,
 886       attrib,
 887       text,
 888       children
 889     )
 890   def copy(self, factory = None):
 891     result = Element.copy(
 892       self,
 893       EnumeratorList if factory is None else factory
 894     )
 895     return result
 896   def __repr__(self):
 897     params = []
 898     self.repr_serialize(params)
 899     return 'ast.EnumeratorList({0:s})'.format(', '.join(params))
 900   # GENERATE END
 901
 902 class EqualsInitializerEmpty(Element):
 903   # GENERATE ELEMENT() BEGIN
 904   def __init__(
 905     self,
 906     tag = 'EqualsInitializerEmpty',
 907     attrib = {},
 908     text = '',
 909     children = []
 910   ):
 911     Element.__init__(
 912       self,
 913       tag,
 914       attrib,
 915       text,
 916       children
 917     )
 918   def copy(self, factory = None):
 919     result = Element.copy(
 920       self,
 921       EqualsInitializerEmpty if factory is None else factory
 922     )
 923     return result
 924   def __repr__(self):
 925     params = []
 926     self.repr_serialize(params)
 927     return 'ast.EqualsInitializerEmpty({0:s})'.format(', '.join(params))
 928   # GENERATE END
 929
 930 class Expression(Element):
 931   # GENERATE ELEMENT() BEGIN
 932   def __init__(
 933     self,
 934     tag = 'Expression',
 935     attrib = {},
 936     text = '',
 937     children = []
 938   ):
 939     Element.__init__(
 940       self,
 941       tag,
 942       attrib,
 943       text,
 944       children
 945     )
 946   def copy(self, factory = None):
 947     result = Element.copy(
 948       self,
 949       Expression if factory is None else factory
 950     )
 951     return result
 952   def __repr__(self):
 953     params = []
 954     self.repr_serialize(params)
 955     return 'ast.Expression({0:s})'.format(', '.join(params))
 956   # GENERATE END
 957
 958 class ExpressionAdd(Expression):
 959   # GENERATE ELEMENT() BEGIN
 960   def __init__(
 961     self,
 962     tag = 'ExpressionAdd',
 963     attrib = {},
 964     text = '',
 965     children = []
 966   ):
 967     Expression.__init__(
 968       self,
 969       tag,
 970       attrib,
 971       text,
 972       children
 973     )
 974   def copy(self, factory = None):
 975     result = Expression.copy(
 976       self,
 977       ExpressionAdd if factory is None else factory
 978     )
 979     return result
 980   def __repr__(self):
 981     params = []
 982     self.repr_serialize(params)
 983     return 'ast.ExpressionAdd({0:s})'.format(', '.join(params))
 984   # GENERATE END
 985
 986 class ExpressionAddAssignment(Expression):
 987   # GENERATE ELEMENT() BEGIN
 988   def __init__(
 989     self,
 990     tag = 'ExpressionAddAssignment',
 991     attrib = {},
 992     text = '',
 993     children = []
 994   ):
 995     Expression.__init__(
 996       self,
 997       tag,
 998       attrib,
 999       text,
1000       children
1001     )
1002   def copy(self, factory = None):
1003     result = Expression.copy(
1004       self,
1005       ExpressionAddAssignment if factory is None else factory
1006     )
1007     return result
1008   def __repr__(self):
1009     params = []
1010     self.repr_serialize(params)
1011     return 'ast.ExpressionAddAssignment({0:s})'.format(', '.join(params))
1012   # GENERATE END
1013
1014 class ExpressionAddressOf(Expression):
1015   # GENERATE ELEMENT() BEGIN
1016   def __init__(
1017     self,
1018     tag = 'ExpressionAddressOf',
1019     attrib = {},
1020     text = '',
1021     children = []
1022   ):
1023     Expression.__init__(
1024       self,
1025       tag,
1026       attrib,
1027       text,
1028       children
1029     )
1030   def copy(self, factory = None):
1031     result = Expression.copy(
1032       self,
1033       ExpressionAddressOf if factory is None else factory
1034     )
1035     return result
1036   def __repr__(self):
1037     params = []
1038     self.repr_serialize(params)
1039     return 'ast.ExpressionAddressOf({0:s})'.format(', '.join(params))
1040   # GENERATE END
1041   def translate(self, context):
1042     assert len(self) == 1
1043     self[0].translate(context)
1044     element.set_text(self, 0, '&')
1045     element.set_text(self, 1, '')
1046
1047 class ExpressionAlignOfType(Expression):
1048   # GENERATE ELEMENT() BEGIN
1049   def __init__(
1050     self,
1051     tag = 'ExpressionAlignOfType',
1052     attrib = {},
1053     text = '',
1054     children = []
1055   ):
1056     Expression.__init__(
1057       self,
1058       tag,
1059       attrib,
1060       text,
1061       children
1062     )
1063   def copy(self, factory = None):
1064     result = Expression.copy(
1065       self,
1066       ExpressionAlignOfType if factory is None else factory
1067     )
1068     return result
1069   def __repr__(self):
1070     params = []
1071     self.repr_serialize(params)
1072     return 'ast.ExpressionAlignOfType({0:s})'.format(', '.join(params))
1073   # GENERATE END
1074
1075 class ExpressionArray(Expression):
1076   # GENERATE ELEMENT() BEGIN
1077   def __init__(
1078     self,
1079     tag = 'ExpressionArray',
1080     attrib = {},
1081     text = '',
1082     children = []
1083   ):
1084     Expression.__init__(
1085       self,
1086       tag,
1087       attrib,
1088       text,
1089       children
1090     )
1091   def copy(self, factory = None):
1092     result = Expression.copy(
1093       self,
1094       ExpressionArray if factory is None else factory
1095     )
1096     return result
1097   def __repr__(self):
1098     params = []
1099     self.repr_serialize(params)
1100     return 'ast.ExpressionArray({0:s})'.format(', '.join(params))
1101   # GENERATE END
1102
1103 class ExpressionAssignment(Expression):
1104   # GENERATE ELEMENT() BEGIN
1105   def __init__(
1106     self,
1107     tag = 'ExpressionAssignment',
1108     attrib = {},
1109     text = '',
1110     children = []
1111   ):
1112     Expression.__init__(
1113       self,
1114       tag,
1115       attrib,
1116       text,
1117       children
1118     )
1119   def copy(self, factory = None):
1120     result = Expression.copy(
1121       self,
1122       ExpressionAssignment if factory is None else factory
1123     )
1124     return result
1125   def __repr__(self):
1126     params = []
1127     self.repr_serialize(params)
1128     return 'ast.ExpressionAssignment({0:s})'.format(', '.join(params))
1129   # GENERATE END
1130
1131 class ExpressionAsterisk(Expression):
1132   # GENERATE ELEMENT() BEGIN
1133   def __init__(
1134     self,
1135     tag = 'ExpressionAsterisk',
1136     attrib = {},
1137     text = '',
1138     children = []
1139   ):
1140     Expression.__init__(
1141       self,
1142       tag,
1143       attrib,
1144       text,
1145       children
1146     )
1147   def copy(self, factory = None):
1148     result = Expression.copy(
1149       self,
1150       ExpressionAsterisk if factory is None else factory
1151     )
1152     return result
1153   def __repr__(self):
1154     params = []
1155     self.repr_serialize(params)
1156     return 'ast.ExpressionAsterisk({0:s})'.format(', '.join(params))
1157   # GENERATE END
1158
1159 class ExpressionBitwiseAnd(Expression):
1160   # GENERATE ELEMENT() BEGIN
1161   def __init__(
1162     self,
1163     tag = 'ExpressionBitwiseAnd',
1164     attrib = {},
1165     text = '',
1166     children = []
1167   ):
1168     Expression.__init__(
1169       self,
1170       tag,
1171       attrib,
1172       text,
1173       children
1174     )
1175   def copy(self, factory = None):
1176     result = Expression.copy(
1177       self,
1178       ExpressionBitwiseAnd if factory is None else factory
1179     )
1180     return result
1181   def __repr__(self):
1182     params = []
1183     self.repr_serialize(params)
1184     return 'ast.ExpressionBitwiseAnd({0:s})'.format(', '.join(params))
1185   # GENERATE END
1186
1187 class ExpressionBitwiseAndAssignment(Expression):
1188   # GENERATE ELEMENT() BEGIN
1189   def __init__(
1190     self,
1191     tag = 'ExpressionBitwiseAndAssignment',
1192     attrib = {},
1193     text = '',
1194     children = []
1195   ):
1196     Expression.__init__(
1197       self,
1198       tag,
1199       attrib,
1200       text,
1201       children
1202     )
1203   def copy(self, factory = None):
1204     result = Expression.copy(
1205       self,
1206       ExpressionBitwiseAndAssignment if factory is None else factory
1207     )
1208     return result
1209   def __repr__(self):
1210     params = []
1211     self.repr_serialize(params)
1212     return 'ast.ExpressionBitwiseAndAssignment({0:s})'.format(', '.join(params))
1213   # GENERATE END
1214
1215 class ExpressionBitwiseNot(Expression):
1216   # GENERATE ELEMENT() BEGIN
1217   def __init__(
1218     self,
1219     tag = 'ExpressionBitwiseNot',
1220     attrib = {},
1221     text = '',
1222     children = []
1223   ):
1224     Expression.__init__(
1225       self,
1226       tag,
1227       attrib,
1228       text,
1229       children
1230     )
1231   def copy(self, factory = None):
1232     result = Expression.copy(
1233       self,
1234       ExpressionBitwiseNot if factory is None else factory
1235     )
1236     return result
1237   def __repr__(self):
1238     params = []
1239     self.repr_serialize(params)
1240     return 'ast.ExpressionBitwiseNot({0:s})'.format(', '.join(params))
1241   # GENERATE END
1242   def translate(self, context):
1243     assert len(self) == 1
1244     self[0].translate(context)
1245     element.set_text(self, 0, '~')
1246     element.set_text(self, 1, '')
1247
1248 class ExpressionBitwiseOr(Expression):
1249   # GENERATE ELEMENT() BEGIN
1250   def __init__(
1251     self,
1252     tag = 'ExpressionBitwiseOr',
1253     attrib = {},
1254     text = '',
1255     children = []
1256   ):
1257     Expression.__init__(
1258       self,
1259       tag,
1260       attrib,
1261       text,
1262       children
1263     )
1264   def copy(self, factory = None):
1265     result = Expression.copy(
1266       self,
1267       ExpressionBitwiseOr if factory is None else factory
1268     )
1269     return result
1270   def __repr__(self):
1271     params = []
1272     self.repr_serialize(params)
1273     return 'ast.ExpressionBitwiseOr({0:s})'.format(', '.join(params))
1274   # GENERATE END
1275
1276 class ExpressionBitwiseOrAssignment(Expression):
1277   # GENERATE ELEMENT() BEGIN
1278   def __init__(
1279     self,
1280     tag = 'ExpressionBitwiseOrAssignment',
1281     attrib = {},
1282     text = '',
1283     children = []
1284   ):
1285     Expression.__init__(
1286       self,
1287       tag,
1288       attrib,
1289       text,
1290       children
1291     )
1292   def copy(self, factory = None):
1293     result = Expression.copy(
1294       self,
1295       ExpressionBitwiseOrAssignment if factory is None else factory
1296     )
1297     return result
1298   def __repr__(self):
1299     params = []
1300     self.repr_serialize(params)
1301     return 'ast.ExpressionBitwiseOrAssignment({0:s})'.format(', '.join(params))
1302   # GENERATE END
1303
1304 class ExpressionCall(Expression):
1305   # GENERATE ELEMENT() BEGIN
1306   def __init__(
1307     self,
1308     tag = 'ExpressionCall',
1309     attrib = {},
1310     text = '',
1311     children = []
1312   ):
1313     Expression.__init__(
1314       self,
1315       tag,
1316       attrib,
1317       text,
1318       children
1319     )
1320   def copy(self, factory = None):
1321     result = Expression.copy(
1322       self,
1323       ExpressionCall if factory is None else factory
1324     )
1325     return result
1326   def __repr__(self):
1327     params = []
1328     self.repr_serialize(params)
1329     return 'ast.ExpressionCall({0:s})'.format(', '.join(params))
1330   # GENERATE END
1331   def translate(self, context):
1332     assert len(self) == 2
1333     self[0].translate(context)
1334     self[1].translate(context)
1335     element.set_text(self, 0, '')
1336     element.set_text(self, 1, '(')
1337     element.set_text(self, 2, ')')
1338
1339 class ExpressionCast(Expression):
1340   # GENERATE ELEMENT() BEGIN
1341   def __init__(
1342     self,
1343     tag = 'ExpressionCast',
1344     attrib = {},
1345     text = '',
1346     children = []
1347   ):
1348     Expression.__init__(
1349       self,
1350       tag,
1351       attrib,
1352       text,
1353       children
1354     )
1355   def copy(self, factory = None):
1356     result = Expression.copy(
1357       self,
1358       ExpressionCast if factory is None else factory
1359     )
1360     return result
1361   def __repr__(self):
1362     params = []
1363     self.repr_serialize(params)
1364     return 'ast.ExpressionCast({0:s})'.format(', '.join(params))
1365   # GENERATE END
1366   def translate(self, context):
1367     assert len(self) == 2
1368     self[0].translate(context)
1369     self[1].translate(context)
1370     element.set_text(self, 0, '')
1371     element.set_text(self, 1, '(')
1372     element.set_text(self, 2, ')')
1373
1374 class ExpressionCharConstant(Expression):
1375   # GENERATE ELEMENT() BEGIN
1376   def __init__(
1377     self,
1378     tag = 'ExpressionCharConstant',
1379     attrib = {},
1380     text = '',
1381     children = []
1382   ):
1383     Expression.__init__(
1384       self,
1385       tag,
1386       attrib,
1387       text,
1388       children
1389     )
1390   def copy(self, factory = None):
1391     result = Expression.copy(
1392       self,
1393       ExpressionCharConstant if factory is None else factory
1394     )
1395     return result
1396   def __repr__(self):
1397     params = []
1398     self.repr_serialize(params)
1399     return 'ast.ExpressionCharConstant({0:s})'.format(', '.join(params))
1400   # GENERATE END
1401   def translate(self, context):
1402     assert len(self) == 0
1403     element.set_text(
1404       self,
1405       0,
1406      'ord({0:s})'.format(element.get_text(self, 0).strip())
1407     )
1408
1409 class ExpressionComma(Expression):
1410   # GENERATE ELEMENT() BEGIN
1411   def __init__(
1412     self,
1413     tag = 'ExpressionComma',
1414     attrib = {},
1415     text = '',
1416     children = []
1417   ):
1418     Expression.__init__(
1419       self,
1420       tag,
1421       attrib,
1422       text,
1423       children
1424     )
1425   def copy(self, factory = None):
1426     result = Expression.copy(
1427       self,
1428       ExpressionComma if factory is None else factory
1429     )
1430     return result
1431   def __repr__(self):
1432     params = []
1433     self.repr_serialize(params)
1434     return 'ast.ExpressionComma({0:s})'.format(', '.join(params))
1435   # GENERATE END
1436
1437 class ExpressionConditional(Expression):
1438   # GENERATE ELEMENT() BEGIN
1439   def __init__(
1440     self,
1441     tag = 'ExpressionConditional',
1442     attrib = {},
1443     text = '',
1444     children = []
1445   ):
1446     Expression.__init__(
1447       self,
1448       tag,
1449       attrib,
1450       text,
1451       children
1452     )
1453   def copy(self, factory = None):
1454     result = Expression.copy(
1455       self,
1456       ExpressionConditional if factory is None else factory
1457     )
1458     return result
1459   def __repr__(self):
1460     params = []
1461     self.repr_serialize(params)
1462     return 'ast.ExpressionConditional({0:s})'.format(', '.join(params))
1463   # GENERATE END
1464   def translate(self, context):
1465     #xml.etree.ElementTree.dump(self)
1466     assert len(self) == 3
1467     self[0].translate(context)
1468     self[1].translate(context)
1469     self[2].translate(context)
1470     self[0], self[1] = self[1], self[0]
1471     element.set_text(self, 0, '')
1472     element.set_text(self, 1, ' if ')
1473     element.set_text(self, 2, ' else ')
1474     element.set_text(self, 3, '')
1475
1476 class ExpressionDereference(Expression):
1477   # GENERATE ELEMENT() BEGIN
1478   def __init__(
1479     self,
1480     tag = 'ExpressionDereference',
1481     attrib = {},
1482     text = '',
1483     children = []
1484   ):
1485     Expression.__init__(
1486       self,
1487       tag,
1488       attrib,
1489       text,
1490       children
1491     )
1492   def copy(self, factory = None):
1493     result = Expression.copy(
1494       self,
1495       ExpressionDereference if factory is None else factory
1496     )
1497     return result
1498   def __repr__(self):
1499     params = []
1500     self.repr_serialize(params)
1501     return 'ast.ExpressionDereference({0:s})'.format(', '.join(params))
1502   # GENERATE END
1503   def translate(self, context):
1504     assert len(self) == 1
1505     self[0].translate(context)
1506     element.set_text(self, 0, '*')
1507     element.set_text(self, 1, '')
1508
1509 class ExpressionDivide(Expression):
1510   # GENERATE ELEMENT() BEGIN
1511   def __init__(
1512     self,
1513     tag = 'ExpressionDivide',
1514     attrib = {},
1515     text = '',
1516     children = []
1517   ):
1518     Expression.__init__(
1519       self,
1520       tag,
1521       attrib,
1522       text,
1523       children
1524     )
1525   def copy(self, factory = None):
1526     result = Expression.copy(
1527       self,
1528       ExpressionDivide if factory is None else factory
1529     )
1530     return result
1531   def __repr__(self):
1532     params = []
1533     self.repr_serialize(params)
1534     return 'ast.ExpressionDivide({0:s})'.format(', '.join(params))
1535   # GENERATE END
1536
1537 class ExpressionDivideAssignment(Expression):
1538   # GENERATE ELEMENT() BEGIN
1539   def __init__(
1540     self,
1541     tag = 'ExpressionDivideAssignment',
1542     attrib = {},
1543     text = '',
1544     children = []
1545   ):
1546     Expression.__init__(
1547       self,
1548       tag,
1549       attrib,
1550       text,
1551       children
1552     )
1553   def copy(self, factory = None):
1554     result = Expression.copy(
1555       self,
1556       ExpressionDivideAssignment if factory is None else factory
1557     )
1558     return result
1559   def __repr__(self):
1560     params = []
1561     self.repr_serialize(params)
1562     return 'ast.ExpressionDivideAssignment({0:s})'.format(', '.join(params))
1563   # GENERATE END
1564
1565 class ExpressionEmpty(Expression):
1566   # GENERATE ELEMENT() BEGIN
1567   def __init__(
1568     self,
1569     tag = 'ExpressionEmpty',
1570     attrib = {},
1571     text = '',
1572     children = []
1573   ):
1574     Expression.__init__(
1575       self,
1576       tag,
1577       attrib,
1578       text,
1579       children
1580     )
1581   def copy(self, factory = None):
1582     result = Expression.copy(
1583       self,
1584       ExpressionEmpty if factory is None else factory
1585     )
1586     return result
1587   def __repr__(self):
1588     params = []
1589     self.repr_serialize(params)
1590     return 'ast.ExpressionEmpty({0:s})'.format(', '.join(params))
1591   # GENERATE END
1592
1593 class ExpressionEqual(Expression):
1594   # GENERATE ELEMENT() BEGIN
1595   def __init__(
1596     self,
1597     tag = 'ExpressionEqual',
1598     attrib = {},
1599     text = '',
1600     children = []
1601   ):
1602     Expression.__init__(
1603       self,
1604       tag,
1605       attrib,
1606       text,
1607       children
1608     )
1609   def copy(self, factory = None):
1610     result = Expression.copy(
1611       self,
1612       ExpressionEqual if factory is None else factory
1613     )
1614     return result
1615   def __repr__(self):
1616     params = []
1617     self.repr_serialize(params)
1618     return 'ast.ExpressionEqual({0:s})'.format(', '.join(params))
1619   # GENERATE END
1620
1621 class ExpressionExclusiveOr(Expression):
1622   # GENERATE ELEMENT() BEGIN
1623   def __init__(
1624     self,
1625     tag = 'ExpressionExclusiveOr',
1626     attrib = {},
1627     text = '',
1628     children = []
1629   ):
1630     Expression.__init__(
1631       self,
1632       tag,
1633       attrib,
1634       text,
1635       children
1636     )
1637   def copy(self, factory = None):
1638     result = Expression.copy(
1639       self,
1640       ExpressionExclusiveOr if factory is None else factory
1641     )
1642     return result
1643   def __repr__(self):
1644     params = []
1645     self.repr_serialize(params)
1646     return 'ast.ExpressionExclusiveOr({0:s})'.format(', '.join(params))
1647   # GENERATE END
1648
1649 class ExpressionExclusiveOrAssignment(Expression):
1650   # GENERATE ELEMENT() BEGIN
1651   def __init__(
1652     self,
1653     tag = 'ExpressionExclusiveOrAssignment',
1654     attrib = {},
1655     text = '',
1656     children = []
1657   ):
1658     Expression.__init__(
1659       self,
1660       tag,
1661       attrib,
1662       text,
1663       children
1664     )
1665   def copy(self, factory = None):
1666     result = Expression.copy(
1667       self,
1668       ExpressionExclusiveOrAssignment if factory is None else factory
1669     )
1670     return result
1671   def __repr__(self):
1672     params = []
1673     self.repr_serialize(params)
1674     return 'ast.ExpressionExclusiveOrAssignment({0:s})'.format(', '.join(params))
1675   # GENERATE END
1676
1677 class ExpressionField(Expression):
1678   # GENERATE ELEMENT() BEGIN
1679   def __init__(
1680     self,
1681     tag = 'ExpressionField',
1682     attrib = {},
1683     text = '',
1684     children = []
1685   ):
1686     Expression.__init__(
1687       self,
1688       tag,
1689       attrib,
1690       text,
1691       children
1692     )
1693   def copy(self, factory = None):
1694     result = Expression.copy(
1695       self,
1696       ExpressionField if factory is None else factory
1697     )
1698     return result
1699   def __repr__(self):
1700     params = []
1701     self.repr_serialize(params)
1702     return 'ast.ExpressionField({0:s})'.format(', '.join(params))
1703   # GENERATE END
1704
1705 class ExpressionFieldDereference(Expression):
1706   # GENERATE ELEMENT() BEGIN
1707   def __init__(
1708     self,
1709     tag = 'ExpressionFieldDereference',
1710     attrib = {},
1711     text = '',
1712     children = []
1713   ):
1714     Expression.__init__(
1715       self,
1716       tag,
1717       attrib,
1718       text,
1719       children
1720     )
1721   def copy(self, factory = None):
1722     result = Expression.copy(
1723       self,
1724       ExpressionFieldDereference if factory is None else factory
1725     )
1726     return result
1727   def __repr__(self):
1728     params = []
1729     self.repr_serialize(params)
1730     return 'ast.ExpressionFieldDereference({0:s})'.format(', '.join(params))
1731   # GENERATE END
1732
1733 class ExpressionFloatLiteral(Expression):
1734   # GENERATE ELEMENT() BEGIN
1735   def __init__(
1736     self,
1737     tag = 'ExpressionFloatLiteral',
1738     attrib = {},
1739     text = '',
1740     children = []
1741   ):
1742     Expression.__init__(
1743       self,
1744       tag,
1745       attrib,
1746       text,
1747       children
1748     )
1749   def copy(self, factory = None):
1750     result = Expression.copy(
1751       self,
1752       ExpressionFloatLiteral if factory is None else factory
1753     )
1754     return result
1755   def __repr__(self):
1756     params = []
1757     self.repr_serialize(params)
1758     return 'ast.ExpressionFloatLiteral({0:s})'.format(', '.join(params))
1759   # GENERATE END
1760
1761 class ExpressionFunctionName(Expression):
1762   # GENERATE ELEMENT() BEGIN
1763   def __init__(
1764     self,
1765     tag = 'ExpressionFunctionName',
1766     attrib = {},
1767     text = '',
1768     children = []
1769   ):
1770     Expression.__init__(
1771       self,
1772       tag,
1773       attrib,
1774       text,
1775       children
1776     )
1777   def copy(self, factory = None):
1778     result = Expression.copy(
1779       self,
1780       ExpressionFunctionName if factory is None else factory
1781     )
1782     return result
1783   def __repr__(self):
1784     params = []
1785     self.repr_serialize(params)
1786     return 'ast.ExpressionFunctionName({0:s})'.format(', '.join(params))
1787   # GENERATE END
1788
1789 class ExpressionGreaterThan(Expression):
1790   # GENERATE ELEMENT() BEGIN
1791   def __init__(
1792     self,
1793     tag = 'ExpressionGreaterThan',
1794     attrib = {},
1795     text = '',
1796     children = []
1797   ):
1798     Expression.__init__(
1799       self,
1800       tag,
1801       attrib,
1802       text,
1803       children
1804     )
1805   def copy(self, factory = None):
1806     result = Expression.copy(
1807       self,
1808       ExpressionGreaterThan if factory is None else factory
1809     )
1810     return result
1811   def __repr__(self):
1812     params = []
1813     self.repr_serialize(params)
1814     return 'ast.ExpressionGreaterThan({0:s})'.format(', '.join(params))
1815   # GENERATE END
1816
1817 class ExpressionGreaterThanOrEqual(Expression):
1818   # GENERATE ELEMENT() BEGIN
1819   def __init__(
1820     self,
1821     tag = 'ExpressionGreaterThanOrEqual',
1822     attrib = {},
1823     text = '',
1824     children = []
1825   ):
1826     Expression.__init__(
1827       self,
1828       tag,
1829       attrib,
1830       text,
1831       children
1832     )
1833   def copy(self, factory = None):
1834     result = Expression.copy(
1835       self,
1836       ExpressionGreaterThanOrEqual if factory is None else factory
1837     )
1838     return result
1839   def __repr__(self):
1840     params = []
1841     self.repr_serialize(params)
1842     return 'ast.ExpressionGreaterThanOrEqual({0:s})'.format(', '.join(params))
1843   # GENERATE END
1844
1845 class ExpressionIdentifier(Expression):
1846   # GENERATE ELEMENT() BEGIN
1847   def __init__(
1848     self,
1849     tag = 'ExpressionIdentifier',
1850     attrib = {},
1851     text = '',
1852     children = []
1853   ):
1854     Expression.__init__(
1855       self,
1856       tag,
1857       attrib,
1858       text,
1859       children
1860     )
1861   def copy(self, factory = None):
1862     result = Expression.copy(
1863       self,
1864       ExpressionIdentifier if factory is None else factory
1865     )
1866     return result
1867   def __repr__(self):
1868     params = []
1869     self.repr_serialize(params)
1870     return 'ast.ExpressionIdentifier({0:s})'.format(', '.join(params))
1871   # GENERATE END
1872
1873 class ExpressionIndex(Expression):
1874   # GENERATE ELEMENT() BEGIN
1875   def __init__(
1876     self,
1877     tag = 'ExpressionIndex',
1878     attrib = {},
1879     text = '',
1880     children = []
1881   ):
1882     Expression.__init__(
1883       self,
1884       tag,
1885       attrib,
1886       text,
1887       children
1888     )
1889   def copy(self, factory = None):
1890     result = Expression.copy(
1891       self,
1892       ExpressionIndex if factory is None else factory
1893     )
1894     return result
1895   def __repr__(self):
1896     params = []
1897     self.repr_serialize(params)
1898     return 'ast.ExpressionIndex({0:s})'.format(', '.join(params))
1899   # GENERATE END
1900   def translate(self, context):
1901     assert len(self) == 2
1902     self[0].translate(context)
1903     self[1].translate(context)
1904     element.set_text(self, 0, '')
1905     element.set_text(self, 1, '[')
1906     element.set_text(self, 2, ']')
1907
1908 class ExpressionIntLiteral(Expression):
1909   # GENERATE ELEMENT() BEGIN
1910   def __init__(
1911     self,
1912     tag = 'ExpressionIntLiteral',
1913     attrib = {},
1914     text = '',
1915     children = []
1916   ):
1917     Expression.__init__(
1918       self,
1919       tag,
1920       attrib,
1921       text,
1922       children
1923     )
1924   def copy(self, factory = None):
1925     result = Expression.copy(
1926       self,
1927       ExpressionIntLiteral if factory is None else factory
1928     )
1929     return result
1930   def __repr__(self):
1931     params = []
1932     self.repr_serialize(params)
1933     return 'ast.ExpressionIntLiteral({0:s})'.format(', '.join(params))
1934   # GENERATE END
1935
1936 class Identifier(Element):
1937   # GENERATE ELEMENT() BEGIN
1938   def __init__(
1939     self,
1940     tag = 'Identifier',
1941     attrib = {},
1942     text = '',
1943     children = []
1944   ):
1945     Element.__init__(
1946       self,
1947       tag,
1948       attrib,
1949       text,
1950       children
1951     )
1952   def copy(self, factory = None):
1953     result = Element.copy(
1954       self,
1955       Identifier if factory is None else factory
1956     )
1957     return result
1958   def __repr__(self):
1959     params = []
1960     self.repr_serialize(params)
1961     return 'ast.Identifier({0:s})'.format(', '.join(params))
1962   # GENERATE END
1963   def translate(self, context):
1964     assert len(self) == 0
1965     text = element.get_text(self, 0)
1966     element.set_text(
1967       self,
1968       0,
1969       context.translate_identifier.get(text, text)
1970     )
1971
1972 class ExpressionLeftShiftAssignment(Expression):
1973   # GENERATE ELEMENT() BEGIN
1974   def __init__(
1975     self,
1976     tag = 'ExpressionLeftShiftAssignment',
1977     attrib = {},
1978     text = '',
1979     children = []
1980   ):
1981     Expression.__init__(
1982       self,
1983       tag,
1984       attrib,
1985       text,
1986       children
1987     )
1988   def copy(self, factory = None):
1989     result = Expression.copy(
1990       self,
1991       ExpressionLeftShiftAssignment if factory is None else factory
1992     )
1993     return result
1994   def __repr__(self):
1995     params = []
1996     self.repr_serialize(params)
1997     return 'ast.ExpressionLeftShiftAssignment({0:s})'.format(', '.join(params))
1998   # GENERATE END
1999
2000 class ExpressionLessThan(Expression):
2001   # GENERATE ELEMENT() BEGIN
2002   def __init__(
2003     self,
2004     tag = 'ExpressionLessThan',
2005     attrib = {},
2006     text = '',
2007     children = []
2008   ):
2009     Expression.__init__(
2010       self,
2011       tag,
2012       attrib,
2013       text,
2014       children
2015     )
2016   def copy(self, factory = None):
2017     result = Expression.copy(
2018       self,
2019       ExpressionLessThan if factory is None else factory
2020     )
2021     return result
2022   def __repr__(self):
2023     params = []
2024     self.repr_serialize(params)
2025     return 'ast.ExpressionLessThan({0:s})'.format(', '.join(params))
2026   # GENERATE END
2027
2028 class ExpressionLessThanOrEqual(Expression):
2029   # GENERATE ELEMENT() BEGIN
2030   def __init__(
2031     self,
2032     tag = 'ExpressionLessThanOrEqual',
2033     attrib = {},
2034     text = '',
2035     children = []
2036   ):
2037     Expression.__init__(
2038       self,
2039       tag,
2040       attrib,
2041       text,
2042       children
2043     )
2044   def copy(self, factory = None):
2045     result = Expression.copy(
2046       self,
2047       ExpressionLessThanOrEqual if factory is None else factory
2048     )
2049     return result
2050   def __repr__(self):
2051     params = []
2052     self.repr_serialize(params)
2053     return 'ast.ExpressionLessThanOrEqual({0:s})'.format(', '.join(params))
2054   # GENERATE END
2055
2056 class ExpressionLogicalAnd(Expression):
2057   # GENERATE ELEMENT() BEGIN
2058   def __init__(
2059     self,
2060     tag = 'ExpressionLogicalAnd',
2061     attrib = {},
2062     text = '',
2063     children = []
2064   ):
2065     Expression.__init__(
2066       self,
2067       tag,
2068       attrib,
2069       text,
2070       children
2071     )
2072   def copy(self, factory = None):
2073     result = Expression.copy(
2074       self,
2075       ExpressionLogicalAnd if factory is None else factory
2076     )
2077     return result
2078   def __repr__(self):
2079     params = []
2080     self.repr_serialize(params)
2081     return 'ast.ExpressionLogicalAnd({0:s})'.format(', '.join(params))
2082   # GENERATE END
2083   def translate(self, context):
2084     assert len(self) == 2
2085     self[0].translate(context)
2086     self[1].translate(context)
2087     element.set_text(self, 0, '')
2088     element.set_text(self, 1, ' and ')
2089     element.set_text(self, 2, '')
2090
2091 class ExpressionLogicalNot(Expression):
2092   # GENERATE ELEMENT() BEGIN
2093   def __init__(
2094     self,
2095     tag = 'ExpressionLogicalNot',
2096     attrib = {},
2097     text = '',
2098     children = []
2099   ):
2100     Expression.__init__(
2101       self,
2102       tag,
2103       attrib,
2104       text,
2105       children
2106     )
2107   def copy(self, factory = None):
2108     result = Expression.copy(
2109       self,
2110       ExpressionLogicalNot if factory is None else factory
2111     )
2112     return result
2113   def __repr__(self):
2114     params = []
2115     self.repr_serialize(params)
2116     return 'ast.ExpressionLogicalNot({0:s})'.format(', '.join(params))
2117   # GENERATE END
2118   def translate(self, context):
2119     assert len(self) == 1
2120     self[0].translate(context)
2121     element.set_text(self, 0, 'not ')
2122     element.set_text(self, 1, '')
2123
2124 class ExpressionLogicalOr(Expression):
2125   # GENERATE ELEMENT() BEGIN
2126   def __init__(
2127     self,
2128     tag = 'ExpressionLogicalOr',
2129     attrib = {},
2130     text = '',
2131     children = []
2132   ):
2133     Expression.__init__(
2134       self,
2135       tag,
2136       attrib,
2137       text,
2138       children
2139     )
2140   def copy(self, factory = None):
2141     result = Expression.copy(
2142       self,
2143       ExpressionLogicalOr if factory is None else factory
2144     )
2145     return result
2146   def __repr__(self):
2147     params = []
2148     self.repr_serialize(params)
2149     return 'ast.ExpressionLogicalOr({0:s})'.format(', '.join(params))
2150   # GENERATE END
2151   def translate(self, context):
2152     assert len(self) == 2
2153     self[0].translate(context)
2154     self[1].translate(context)
2155     element.set_text(self, 0, '')
2156     element.set_text(self, 1, ' or ')
2157     element.set_text(self, 2, '')
2158
2159 class ExpressionMinus(Expression):
2160   # GENERATE ELEMENT() BEGIN
2161   def __init__(
2162     self,
2163     tag = 'ExpressionMinus',
2164     attrib = {},
2165     text = '',
2166     children = []
2167   ):
2168     Expression.__init__(
2169       self,
2170       tag,
2171       attrib,
2172       text,
2173       children
2174     )
2175   def copy(self, factory = None):
2176     result = Expression.copy(
2177       self,
2178       ExpressionMinus if factory is None else factory
2179     )
2180     return result
2181   def __repr__(self):
2182     params = []
2183     self.repr_serialize(params)
2184     return 'ast.ExpressionMinus({0:s})'.format(', '.join(params))
2185   # GENERATE END
2186   def translate(self, context):
2187     assert len(self) == 1
2188     self[0].translate(context)
2189     element.set_text(self, 0, '-')
2190     element.set_text(self, 1, '')
2191
2192 class ExpressionModulo(Expression):
2193   # GENERATE ELEMENT() BEGIN
2194   def __init__(
2195     self,
2196     tag = 'ExpressionModulo',
2197     attrib = {},
2198     text = '',
2199     children = []
2200   ):
2201     Expression.__init__(
2202       self,
2203       tag,
2204       attrib,
2205       text,
2206       children
2207     )
2208   def copy(self, factory = None):
2209     result = Expression.copy(
2210       self,
2211       ExpressionModulo if factory is None else factory
2212     )
2213     return result
2214   def __repr__(self):
2215     params = []
2216     self.repr_serialize(params)
2217     return 'ast.ExpressionModulo({0:s})'.format(', '.join(params))
2218   # GENERATE END
2219
2220 class ExpressionModuloAssignment(Expression):
2221   # GENERATE ELEMENT() BEGIN
2222   def __init__(
2223     self,
2224     tag = 'ExpressionModuloAssignment',
2225     attrib = {},
2226     text = '',
2227     children = []
2228   ):
2229     Expression.__init__(
2230       self,
2231       tag,
2232       attrib,
2233       text,
2234       children
2235     )
2236   def copy(self, factory = None):
2237     result = Expression.copy(
2238       self,
2239       ExpressionModuloAssignment if factory is None else factory
2240     )
2241     return result
2242   def __repr__(self):
2243     params = []
2244     self.repr_serialize(params)
2245     return 'ast.ExpressionModuloAssignment({0:s})'.format(', '.join(params))
2246   # GENERATE END
2247
2248 class ExpressionMultiply(Expression):
2249   # GENERATE ELEMENT() BEGIN
2250   def __init__(
2251     self,
2252     tag = 'ExpressionMultiply',
2253     attrib = {},
2254     text = '',
2255     children = []
2256   ):
2257     Expression.__init__(
2258       self,
2259       tag,
2260       attrib,
2261       text,
2262       children
2263     )
2264   def copy(self, factory = None):
2265     result = Expression.copy(
2266       self,
2267       ExpressionMultiply if factory is None else factory
2268     )
2269     return result
2270   def __repr__(self):
2271     params = []
2272     self.repr_serialize(params)
2273     return 'ast.ExpressionMultiply({0:s})'.format(', '.join(params))
2274   # GENERATE END
2275
2276 class ExpressionMultiplyAssignment(Expression):
2277   # GENERATE ELEMENT() BEGIN
2278   def __init__(
2279     self,
2280     tag = 'ExpressionMultiplyAssignment',
2281     attrib = {},
2282     text = '',
2283     children = []
2284   ):
2285     Expression.__init__(
2286       self,
2287       tag,
2288       attrib,
2289       text,
2290       children
2291     )
2292   def copy(self, factory = None):
2293     result = Expression.copy(
2294       self,
2295       ExpressionMultiplyAssignment if factory is None else factory
2296     )
2297     return result
2298   def __repr__(self):
2299     params = []
2300     self.repr_serialize(params)
2301     return 'ast.ExpressionMultiplyAssignment({0:s})'.format(', '.join(params))
2302   # GENERATE END
2303
2304 class ExpressionNotEqual(Expression):
2305   # GENERATE ELEMENT() BEGIN
2306   def __init__(
2307     self,
2308     tag = 'ExpressionNotEqual',
2309     attrib = {},
2310     text = '',
2311     children = []
2312   ):
2313     Expression.__init__(
2314       self,
2315       tag,
2316       attrib,
2317       text,
2318       children
2319     )
2320   def copy(self, factory = None):
2321     result = Expression.copy(
2322       self,
2323       ExpressionNotEqual if factory is None else factory
2324     )
2325     return result
2326   def __repr__(self):
2327     params = []
2328     self.repr_serialize(params)
2329     return 'ast.ExpressionNotEqual({0:s})'.format(', '.join(params))
2330   # GENERATE END
2331
2332 class ExpressionPlus(Expression):
2333   # GENERATE ELEMENT() BEGIN
2334   def __init__(
2335     self,
2336     tag = 'ExpressionPlus',
2337     attrib = {},
2338     text = '',
2339     children = []
2340   ):
2341     Expression.__init__(
2342       self,
2343       tag,
2344       attrib,
2345       text,
2346       children
2347     )
2348   def copy(self, factory = None):
2349     result = Expression.copy(
2350       self,
2351       ExpressionPlus if factory is None else factory
2352     )
2353     return result
2354   def __repr__(self):
2355     params = []
2356     self.repr_serialize(params)
2357     return 'ast.ExpressionPlus({0:s})'.format(', '.join(params))
2358   # GENERATE END
2359   def translate(self, context):
2360     assert len(self) == 1
2361     self[0].translate(context)
2362     element.set_text(self, 0, '+')
2363     element.set_text(self, 1, '')
2364
2365 class ExpressionPostDecrement(Expression):
2366   # GENERATE ELEMENT() BEGIN
2367   def __init__(
2368     self,
2369     tag = 'ExpressionPostDecrement',
2370     attrib = {},
2371     text = '',
2372     children = []
2373   ):
2374     Expression.__init__(
2375       self,
2376       tag,
2377       attrib,
2378       text,
2379       children
2380     )
2381   def copy(self, factory = None):
2382     result = Expression.copy(
2383       self,
2384       ExpressionPostDecrement if factory is None else factory
2385     )
2386     return result
2387   def __repr__(self):
2388     params = []
2389     self.repr_serialize(params)
2390     return 'ast.ExpressionPostDecrement({0:s})'.format(', '.join(params))
2391   # GENERATE END
2392   def translate(self, context):
2393     assert len(self) == 1
2394     self[0].translate(context)
2395     element.set_text(self, 0, '')
2396     element.set_text(self, 1, ' -= 1')
2397
2398 class ExpressionPostIncrement(Expression):
2399   # GENERATE ELEMENT() BEGIN
2400   def __init__(
2401     self,
2402     tag = 'ExpressionPostIncrement',
2403     attrib = {},
2404     text = '',
2405     children = []
2406   ):
2407     Expression.__init__(
2408       self,
2409       tag,
2410       attrib,
2411       text,
2412       children
2413     )
2414   def copy(self, factory = None):
2415     result = Expression.copy(
2416       self,
2417       ExpressionPostIncrement if factory is None else factory
2418     )
2419     return result
2420   def __repr__(self):
2421     params = []
2422     self.repr_serialize(params)
2423     return 'ast.ExpressionPostIncrement({0:s})'.format(', '.join(params))
2424   # GENERATE END
2425   def translate(self, context):
2426     assert len(self) == 1
2427     self[0].translate(context)
2428     element.set_text(self, 0, '')
2429     element.set_text(self, 1, ' += 1')
2430
2431 class ExpressionPreDecrement(Expression):
2432   # GENERATE ELEMENT() BEGIN
2433   def __init__(
2434     self,
2435     tag = 'ExpressionPreDecrement',
2436     attrib = {},
2437     text = '',
2438     children = []
2439   ):
2440     Expression.__init__(
2441       self,
2442       tag,
2443       attrib,
2444       text,
2445       children
2446     )
2447   def copy(self, factory = None):
2448     result = Expression.copy(
2449       self,
2450       ExpressionPreDecrement if factory is None else factory
2451     )
2452     return result
2453   def __repr__(self):
2454     params = []
2455     self.repr_serialize(params)
2456     return 'ast.ExpressionPreDecrement({0:s})'.format(', '.join(params))
2457   # GENERATE END
2458   def translate(self, context):
2459     assert len(self) == 1
2460     self[0].translate(context)
2461     element.set_text(self, 0, '')
2462     element.set_text(self, 1, ' -= 1')
2463
2464 class ExpressionPreIncrement(Expression):
2465   # GENERATE ELEMENT() BEGIN
2466   def __init__(
2467     self,
2468     tag = 'ExpressionPreIncrement',
2469     attrib = {},
2470     text = '',
2471     children = []
2472   ):
2473     Expression.__init__(
2474       self,
2475       tag,
2476       attrib,
2477       text,
2478       children
2479     )
2480   def copy(self, factory = None):
2481     result = Expression.copy(
2482       self,
2483       ExpressionPreIncrement if factory is None else factory
2484     )
2485     return result
2486   def __repr__(self):
2487     params = []
2488     self.repr_serialize(params)
2489     return 'ast.ExpressionPreIncrement({0:s})'.format(', '.join(params))
2490   # GENERATE END
2491   def translate(self, context):
2492     assert len(self) == 1
2493     self[0].translate(context)
2494     element.set_text(self, 0, '')
2495     element.set_text(self, 1, ' += 1')
2496
2497 class ExpressionRightShiftAssignment(Expression):
2498   # GENERATE ELEMENT() BEGIN
2499   def __init__(
2500     self,
2501     tag = 'ExpressionRightShiftAssignment',
2502     attrib = {},
2503     text = '',
2504     children = []
2505   ):
2506     Expression.__init__(
2507       self,
2508       tag,
2509       attrib,
2510       text,
2511       children
2512     )
2513   def copy(self, factory = None):
2514     result = Expression.copy(
2515       self,
2516       ExpressionRightShiftAssignment if factory is None else factory
2517     )
2518     return result
2519   def __repr__(self):
2520     params = []
2521     self.repr_serialize(params)
2522     return 'ast.ExpressionRightShiftAssignment({0:s})'.format(', '.join(params))
2523   # GENERATE END
2524
2525 class ExpressionShiftLeft(Expression):
2526   # GENERATE ELEMENT() BEGIN
2527   def __init__(
2528     self,
2529     tag = 'ExpressionShiftLeft',
2530     attrib = {},
2531     text = '',
2532     children = []
2533   ):
2534     Expression.__init__(
2535       self,
2536       tag,
2537       attrib,
2538       text,
2539       children
2540     )
2541   def copy(self, factory = None):
2542     result = Expression.copy(
2543       self,
2544       ExpressionShiftLeft if factory is None else factory
2545     )
2546     return result
2547   def __repr__(self):
2548     params = []
2549     self.repr_serialize(params)
2550     return 'ast.ExpressionShiftLeft({0:s})'.format(', '.join(params))
2551   # GENERATE END
2552
2553 class ExpressionShiftRight(Expression):
2554   # GENERATE ELEMENT() BEGIN
2555   def __init__(
2556     self,
2557     tag = 'ExpressionShiftRight',
2558     attrib = {},
2559     text = '',
2560     children = []
2561   ):
2562     Expression.__init__(
2563       self,
2564       tag,
2565       attrib,
2566       text,
2567       children
2568     )
2569   def copy(self, factory = None):
2570     result = Expression.copy(
2571       self,
2572       ExpressionShiftRight if factory is None else factory
2573     )
2574     return result
2575   def __repr__(self):
2576     params = []
2577     self.repr_serialize(params)
2578     return 'ast.ExpressionShiftRight({0:s})'.format(', '.join(params))
2579   # GENERATE END
2580
2581 class ExpressionSizeOfExpression(Expression):
2582   # GENERATE ELEMENT() BEGIN
2583   def __init__(
2584     self,
2585     tag = 'ExpressionSizeOfExpression',
2586     attrib = {},
2587     text = '',
2588     children = []
2589   ):
2590     Expression.__init__(
2591       self,
2592       tag,
2593       attrib,
2594       text,
2595       children
2596     )
2597   def copy(self, factory = None):
2598     result = Expression.copy(
2599       self,
2600       ExpressionSizeOfExpression if factory is None else factory
2601     )
2602     return result
2603   def __repr__(self):
2604     params = []
2605     self.repr_serialize(params)
2606     return 'ast.ExpressionSizeOfExpression({0:s})'.format(', '.join(params))
2607   # GENERATE END
2608
2609 class ExpressionSizeOfType(Expression):
2610   # GENERATE ELEMENT() BEGIN
2611   def __init__(
2612     self,
2613     tag = 'ExpressionSizeOfType',
2614     attrib = {},
2615     text = '',
2616     children = []
2617   ):
2618     Expression.__init__(
2619       self,
2620       tag,
2621       attrib,
2622       text,
2623       children
2624     )
2625   def copy(self, factory = None):
2626     result = Expression.copy(
2627       self,
2628       ExpressionSizeOfType if factory is None else factory
2629     )
2630     return result
2631   def __repr__(self):
2632     params = []
2633     self.repr_serialize(params)
2634     return 'ast.ExpressionSizeOfType({0:s})'.format(', '.join(params))
2635   # GENERATE END
2636
2637 class ExpressionStringLiteral(Expression):
2638   # GENERATE ELEMENT() BEGIN
2639   def __init__(
2640     self,
2641     tag = 'ExpressionStringLiteral',
2642     attrib = {},
2643     text = '',
2644     children = []
2645   ):
2646     Expression.__init__(
2647       self,
2648       tag,
2649       attrib,
2650       text,
2651       children
2652     )
2653   def copy(self, factory = None):
2654     result = Expression.copy(
2655       self,
2656       ExpressionStringLiteral if factory is None else factory
2657     )
2658     return result
2659   def __repr__(self):
2660     params = []
2661     self.repr_serialize(params)
2662     return 'ast.ExpressionStringLiteral({0:s})'.format(', '.join(params))
2663   # GENERATE END
2664   def translate(self, context):
2665     element.set_text(self, 0, '"')
2666     for i in range(1, len(self)):
2667       element.set_text(self, i, '')
2668     element.set_text(self, len(self), '"')
2669
2670 class ExpressionSubtract(Expression):
2671   # GENERATE ELEMENT() BEGIN
2672   def __init__(
2673     self,
2674     tag = 'ExpressionSubtract',
2675     attrib = {},
2676     text = '',
2677     children = []
2678   ):
2679     Expression.__init__(
2680       self,
2681       tag,
2682       attrib,
2683       text,
2684       children
2685     )
2686   def copy(self, factory = None):
2687     result = Expression.copy(
2688       self,
2689       ExpressionSubtract if factory is None else factory
2690     )
2691     return result
2692   def __repr__(self):
2693     params = []
2694     self.repr_serialize(params)
2695     return 'ast.ExpressionSubtract({0:s})'.format(', '.join(params))
2696   # GENERATE END
2697
2698 class ExpressionSubtractAssignment(Expression):
2699   # GENERATE ELEMENT() BEGIN
2700   def __init__(
2701     self,
2702     tag = 'ExpressionSubtractAssignment',
2703     attrib = {},
2704     text = '',
2705     children = []
2706   ):
2707     Expression.__init__(
2708       self,
2709       tag,
2710       attrib,
2711       text,
2712       children
2713     )
2714   def copy(self, factory = None):
2715     result = Expression.copy(
2716       self,
2717       ExpressionSubtractAssignment if factory is None else factory
2718     )
2719     return result
2720   def __repr__(self):
2721     params = []
2722     self.repr_serialize(params)
2723     return 'ast.ExpressionSubtractAssignment({0:s})'.format(', '.join(params))
2724   # GENERATE END
2725
2726 class FunctionDefinition(Element):
2727   # GENERATE ELEMENT() BEGIN
2728   def __init__(
2729     self,
2730     tag = 'FunctionDefinition',
2731     attrib = {},
2732     text = '',
2733     children = []
2734   ):
2735     Element.__init__(
2736       self,
2737       tag,
2738       attrib,
2739       text,
2740       children
2741     )
2742   def copy(self, factory = None):
2743     result = Element.copy(
2744       self,
2745       FunctionDefinition if factory is None else factory
2746     )
2747     return result
2748   def __repr__(self):
2749     params = []
2750     self.repr_serialize(params)
2751     return 'ast.FunctionDefinition({0:s})'.format(', '.join(params))
2752   # GENERATE END
2753
2754 class FunctionSpecifier(Element):
2755   # GENERATE ELEMENT(int n) BEGIN
2756   def __init__(
2757     self,
2758     tag = 'FunctionSpecifier',
2759     attrib = {},
2760     text = '',
2761     children = [],
2762     n = -1
2763   ):
2764     Element.__init__(
2765       self,
2766       tag,
2767       attrib,
2768       text,
2769       children
2770     )
2771     self.n = (
2772       element.deserialize_int(n)
2773     if isinstance(n, str) else
2774       n
2775     )
2776   def serialize(self, ref_list):
2777     Element.serialize(self, ref_list)
2778     self.set('n', element.serialize_int(self.n))
2779   def deserialize(self, ref_list):
2780     Element.deserialize(self, ref_list)
2781     self.n = element.deserialize_int(self.get('n', '-1'))
2782   def copy(self, factory = None):
2783     result = Element.copy(
2784       self,
2785       FunctionSpecifier if factory is None else factory
2786     )
2787     result.n = self.n
2788     return result
2789   def repr_serialize(self, params):
2790     Element.repr_serialize(self, params)
2791     if self.n != -1:
2792       params.append(
2793         'n = {0:s}'.format(repr(self.n))
2794       )
2795   def __repr__(self):
2796     params = []
2797     self.repr_serialize(params)
2798     return 'ast.FunctionSpecifier({0:s})'.format(', '.join(params))
2799   # GENERATE END
2800
2801 class GenericAssociation(Element):
2802   # GENERATE ELEMENT() BEGIN
2803   def __init__(
2804     self,
2805     tag = 'GenericAssociation',
2806     attrib = {},
2807     text = '',
2808     children = []
2809   ):
2810     Element.__init__(
2811       self,
2812       tag,
2813       attrib,
2814       text,
2815       children
2816     )
2817   def copy(self, factory = None):
2818     result = Element.copy(
2819       self,
2820       GenericAssociation if factory is None else factory
2821     )
2822     return result
2823   def __repr__(self):
2824     params = []
2825     self.repr_serialize(params)
2826     return 'ast.GenericAssociation({0:s})'.format(', '.join(params))
2827   # GENERATE END
2828
2829 class GenericAssociationList(Element):
2830   # GENERATE ELEMENT() BEGIN
2831   def __init__(
2832     self,
2833     tag = 'GenericAssociationList',
2834     attrib = {},
2835     text = '',
2836     children = []
2837   ):
2838     Element.__init__(
2839       self,
2840       tag,
2841       attrib,
2842       text,
2843       children
2844     )
2845   def copy(self, factory = None):
2846     result = Element.copy(
2847       self,
2848       GenericAssociationList if factory is None else factory
2849     )
2850     return result
2851   def __repr__(self):
2852     params = []
2853     self.repr_serialize(params)
2854     return 'ast.GenericAssociationList({0:s})'.format(', '.join(params))
2855   # GENERATE END
2856
2857 class GenericSelection(Element):
2858   # GENERATE ELEMENT() BEGIN
2859   def __init__(
2860     self,
2861     tag = 'GenericSelection',
2862     attrib = {},
2863     text = '',
2864     children = []
2865   ):
2866     Element.__init__(
2867       self,
2868       tag,
2869       attrib,
2870       text,
2871       children
2872     )
2873   def copy(self, factory = None):
2874     result = Element.copy(
2875       self,
2876       GenericSelection if factory is None else factory
2877     )
2878     return result
2879   def __repr__(self):
2880     params = []
2881     self.repr_serialize(params)
2882     return 'ast.GenericSelection({0:s})'.format(', '.join(params))
2883   # GENERATE END
2884
2885 class IdentifierEmpty(Element):
2886   # GENERATE ELEMENT() BEGIN
2887   def __init__(
2888     self,
2889     tag = 'IdentifierEmpty',
2890     attrib = {},
2891     text = '',
2892     children = []
2893   ):
2894     Element.__init__(
2895       self,
2896       tag,
2897       attrib,
2898       text,
2899       children
2900     )
2901   def copy(self, factory = None):
2902     result = Element.copy(
2903       self,
2904       IdentifierEmpty if factory is None else factory
2905     )
2906     return result
2907   def __repr__(self):
2908     params = []
2909     self.repr_serialize(params)
2910     return 'ast.IdentifierEmpty({0:s})'.format(', '.join(params))
2911   # GENERATE END
2912
2913 class IdentifierList(Element):
2914   # GENERATE ELEMENT() BEGIN
2915   def __init__(
2916     self,
2917     tag = 'IdentifierList',
2918     attrib = {},
2919     text = '',
2920     children = []
2921   ):
2922     Element.__init__(
2923       self,
2924       tag,
2925       attrib,
2926       text,
2927       children
2928     )
2929   def copy(self, factory = None):
2930     result = Element.copy(
2931       self,
2932       IdentifierList if factory is None else factory
2933     )
2934     return result
2935   def __repr__(self):
2936     params = []
2937     self.repr_serialize(params)
2938     return 'ast.IdentifierList({0:s})'.format(', '.join(params))
2939   # GENERATE END
2940
2941 class InitDeclarator(Element):
2942   # GENERATE ELEMENT() BEGIN
2943   def __init__(
2944     self,
2945     tag = 'InitDeclarator',
2946     attrib = {},
2947     text = '',
2948     children = []
2949   ):
2950     Element.__init__(
2951       self,
2952       tag,
2953       attrib,
2954       text,
2955       children
2956     )
2957   def copy(self, factory = None):
2958     result = Element.copy(
2959       self,
2960       InitDeclarator if factory is None else factory
2961     )
2962     return result
2963   def __repr__(self):
2964     params = []
2965     self.repr_serialize(params)
2966     return 'ast.InitDeclarator({0:s})'.format(', '.join(params))
2967   # GENERATE END
2968
2969 class InitDeclaratorList(Element):
2970   # GENERATE ELEMENT() BEGIN
2971   def __init__(
2972     self,
2973     tag = 'InitDeclaratorList',
2974     attrib = {},
2975     text = '',
2976     children = []
2977   ):
2978     Element.__init__(
2979       self,
2980       tag,
2981       attrib,
2982       text,
2983       children
2984     )
2985   def copy(self, factory = None):
2986     result = Element.copy(
2987       self,
2988       InitDeclaratorList if factory is None else factory
2989     )
2990     return result
2991   def __repr__(self):
2992     params = []
2993     self.repr_serialize(params)
2994     return 'ast.InitDeclaratorList({0:s})'.format(', '.join(params))
2995   # GENERATE END
2996
2997 class ParameterDeclaration(Element):
2998   # GENERATE ELEMENT() BEGIN
2999   def __init__(
3000     self,
3001     tag = 'ParameterDeclaration',
3002     attrib = {},
3003     text = '',
3004     children = []
3005   ):
3006     Element.__init__(
3007       self,
3008       tag,
3009       attrib,
3010       text,
3011       children
3012     )
3013   def copy(self, factory = None):
3014     result = Element.copy(
3015       self,
3016       ParameterDeclaration if factory is None else factory
3017     )
3018     return result
3019   def __repr__(self):
3020     params = []
3021     self.repr_serialize(params)
3022     return 'ast.ParameterDeclaration({0:s})'.format(', '.join(params))
3023   # GENERATE END
3024
3025 class ParameterDeclarationList(Element):
3026   # GENERATE ELEMENT() BEGIN
3027   def __init__(
3028     self,
3029     tag = 'ParameterDeclarationList',
3030     attrib = {},
3031     text = '',
3032     children = []
3033   ):
3034     Element.__init__(
3035       self,
3036       tag,
3037       attrib,
3038       text,
3039       children
3040     )
3041   def copy(self, factory = None):
3042     result = Element.copy(
3043       self,
3044       ParameterDeclarationList if factory is None else factory
3045     )
3046     return result
3047   def __repr__(self):
3048     params = []
3049     self.repr_serialize(params)
3050     return 'ast.ParameterDeclarationList({0:s})'.format(', '.join(params))
3051   # GENERATE END
3052
3053 class SpecifierQualifierList(Element):
3054   # GENERATE ELEMENT() BEGIN
3055   def __init__(
3056     self,
3057     tag = 'SpecifierQualifierList',
3058     attrib = {},
3059     text = '',
3060     children = []
3061   ):
3062     Element.__init__(
3063       self,
3064       tag,
3065       attrib,
3066       text,
3067       children
3068     )
3069   def copy(self, factory = None):
3070     result = Element.copy(
3071       self,
3072       SpecifierQualifierList if factory is None else factory
3073     )
3074     return result
3075   def __repr__(self):
3076     params = []
3077     self.repr_serialize(params)
3078     return 'ast.SpecifierQualifierList({0:s})'.format(', '.join(params))
3079   # GENERATE END
3080
3081 class Statement(DeclarationOrStatement):
3082   # GENERATE ELEMENT() BEGIN
3083   def __init__(
3084     self,
3085     tag = 'Statement',
3086     attrib = {},
3087     text = '',
3088     children = []
3089   ):
3090     DeclarationOrStatement.__init__(
3091       self,
3092       tag,
3093       attrib,
3094       text,
3095       children
3096     )
3097   def copy(self, factory = None):
3098     result = DeclarationOrStatement.copy(
3099       self,
3100       Statement if factory is None else factory
3101     )
3102     return result
3103   def __repr__(self):
3104     params = []
3105     self.repr_serialize(params)
3106     return 'ast.Statement({0:s})'.format(', '.join(params))
3107   # GENERATE END
3108
3109 class StatementBlock(Statement):
3110   # GENERATE ELEMENT() BEGIN
3111   def __init__(
3112     self,
3113     tag = 'StatementBlock',
3114     attrib = {},
3115     text = '',
3116     children = []
3117   ):
3118     Statement.__init__(
3119       self,
3120       tag,
3121       attrib,
3122       text,
3123       children
3124     )
3125   def copy(self, factory = None):
3126     result = Statement.copy(
3127       self,
3128       StatementBlock if factory is None else factory
3129     )
3130     return result
3131   def __repr__(self):
3132     params = []
3133     self.repr_serialize(params)
3134     return 'ast.StatementBlock({0:s})'.format(', '.join(params))
3135   # GENERATE END
3136   def translate(self, context):
3137     assert len(self) == 1
3138     self[0].translate(context)
3139     element.set_text(self, 0, '')
3140     element.set_text(self, 1, '')
3141
3142 class StatementBreak(Statement):
3143   # GENERATE ELEMENT() BEGIN
3144   def __init__(
3145     self,
3146     tag = 'StatementBreak',
3147     attrib = {},
3148     text = '',
3149     children = []
3150   ):
3151     Statement.__init__(
3152       self,
3153       tag,
3154       attrib,
3155       text,
3156       children
3157     )
3158   def copy(self, factory = None):
3159     result = Statement.copy(
3160       self,
3161       StatementBreak if factory is None else factory
3162     )
3163     return result
3164   def __repr__(self):
3165     params = []
3166     self.repr_serialize(params)
3167     return 'ast.StatementBreak({0:s})'.format(', '.join(params))
3168   # GENERATE END
3169
3170 class StatementCase(Statement):
3171   # GENERATE ELEMENT() BEGIN
3172   def __init__(
3173     self,
3174     tag = 'StatementCase',
3175     attrib = {},
3176     text = '',
3177     children = []
3178   ):
3179     Statement.__init__(
3180       self,
3181       tag,
3182       attrib,
3183       text,
3184       children
3185     )
3186   def copy(self, factory = None):
3187     result = Statement.copy(
3188       self,
3189       StatementCase if factory is None else factory
3190     )
3191     return result
3192   def __repr__(self):
3193     params = []
3194     self.repr_serialize(params)
3195     return 'ast.StatementCase({0:s})'.format(', '.join(params))
3196   # GENERATE END
3197
3198 class StatementContinue(Statement):
3199   # GENERATE ELEMENT() BEGIN
3200   def __init__(
3201     self,
3202     tag = 'StatementContinue',
3203     attrib = {},
3204     text = '',
3205     children = []
3206   ):
3207     Statement.__init__(
3208       self,
3209       tag,
3210       attrib,
3211       text,
3212       children
3213     )
3214   def copy(self, factory = None):
3215     result = Statement.copy(
3216       self,
3217       StatementContinue if factory is None else factory
3218     )
3219     return result
3220   def __repr__(self):
3221     params = []
3222     self.repr_serialize(params)
3223     return 'ast.StatementContinue({0:s})'.format(', '.join(params))
3224   # GENERATE END
3225   def translate(self, context):
3226     assert len(self) == 0
3227     if isinstance(enclosing_loop, StatementDoWhile):
3228       self.append(enclosing_loop[1].copy())
3229       indent_save = context.indent
3230       context.indent += '  '
3231       self[0].translate(context)
3232       context.indent = indent_save
3233       element.set_text(self, 0, '{0:s}if '.format(context.indent))
3234       element.set_text(
3235         self,
3236         0,
3237         ':\n{0:s}  continue\n{1:s}break\n'.format(
3238           context.indent,
3239           context.indent
3240         )
3241       )
3242     elif isinstance(enclosing_loop, StatementFor):
3243       self.append(enclosing_loop[2].copy())
3244       indent_save = context.indent
3245       context.indent += '  '
3246       self[0].translate(context)
3247       context.indent = indent_save
3248       element.set_text(self, 0, '')
3249       element.set_text(self, 1, '{0:s}continue\n'.format(context.indent))
3250     else:
3251       element.set_text(self, 0, '{0:s}continue\n'.format(context.indent))
3252
3253 class StatementDefault(Statement):
3254   # GENERATE ELEMENT() BEGIN
3255   def __init__(
3256     self,
3257     tag = 'StatementDefault',
3258     attrib = {},
3259     text = '',
3260     children = []
3261   ):
3262     Statement.__init__(
3263       self,
3264       tag,
3265       attrib,
3266       text,
3267       children
3268     )
3269   def copy(self, factory = None):
3270     result = Statement.copy(
3271       self,
3272       StatementDefault if factory is None else factory
3273     )
3274     return result
3275   def __repr__(self):
3276     params = []
3277     self.repr_serialize(params)
3278     return 'ast.StatementDefault({0:s})'.format(', '.join(params))
3279   # GENERATE END
3280
3281 class StatementDoWhile(Statement):
3282   # GENERATE ELEMENT() BEGIN
3283   def __init__(
3284     self,
3285     tag = 'StatementDoWhile',
3286     attrib = {},
3287     text = '',
3288     children = []
3289   ):
3290     Statement.__init__(
3291       self,
3292       tag,
3293       attrib,
3294       text,
3295       children
3296     )
3297   def copy(self, factory = None):
3298     result = Statement.copy(
3299       self,
3300       StatementDoWhile if factory is None else factory
3301     )
3302     return result
3303   def __repr__(self):
3304     params = []
3305     self.repr_serialize(params)
3306     return 'ast.StatementDoWhile({0:s})'.format(', '.join(params))
3307   # GENERATE END
3308   def translate(self, context):
3309     assert len(self) == 2
3310     indent_save = context.indent
3311     context.indent += '  '
3312     enclosing_loop_save = context.enclosing_loop
3313     context.enclosing_loop = self
3314     self[0].translate(context)
3315     context.enclosing_loop = enclosing_loop_save
3316     self[1].translate(context)
3317     context.indent = indent_save
3318     element.set_text(self, 0, '{0:s}while True:\n'.format(context.indent))
3319     element.set_text(self, 1, '{0:s}  if not ('.format(context.indent))
3320     element.set_text(self, 2, '):\n{0:s}    break\n'.format(context.indent))
3321
3322 class StatementExpression(Statement):
3323   # GENERATE ELEMENT() BEGIN
3324   def __init__(
3325     self,
3326     tag = 'StatementExpression',
3327     attrib = {},
3328     text = '',
3329     children = []
3330   ):
3331     Statement.__init__(
3332       self,
3333       tag,
3334       attrib,
3335       text,
3336       children
3337     )
3338   def copy(self, factory = None):
3339     result = Statement.copy(
3340       self,
3341       StatementExpression if factory is None else factory
3342     )
3343     return result
3344   def __repr__(self):
3345     params = []
3346     self.repr_serialize(params)
3347     return 'ast.StatementExpression({0:s})'.format(', '.join(params))
3348   # GENERATE END
3349
3350 class StatementFor(Statement):
3351   # GENERATE ELEMENT() BEGIN
3352   def __init__(
3353     self,
3354     tag = 'StatementFor',
3355     attrib = {},
3356     text = '',
3357     children = []
3358   ):
3359     Statement.__init__(
3360       self,
3361       tag,
3362       attrib,
3363       text,
3364       children
3365     )
3366   def copy(self, factory = None):
3367     result = Statement.copy(
3368       self,
3369       StatementFor if factory is None else factory
3370     )
3371     return result
3372   def __repr__(self):
3373     params = []
3374     self.repr_serialize(params)
3375     return 'ast.StatementFor({0:s})'.format(', '.join(params))
3376   # GENERATE END
3377
3378 class StatementGoto(Statement):
3379   # GENERATE ELEMENT() BEGIN
3380   def __init__(
3381     self,
3382     tag = 'StatementGoto',
3383     attrib = {},
3384     text = '',
3385     children = []
3386   ):
3387     Statement.__init__(
3388       self,
3389       tag,
3390       attrib,
3391       text,
3392       children
3393     )
3394   def copy(self, factory = None):
3395     result = Statement.copy(
3396       self,
3397       StatementGoto if factory is None else factory
3398     )
3399     return result
3400   def __repr__(self):
3401     params = []
3402     self.repr_serialize(params)
3403     return 'ast.StatementGoto({0:s})'.format(', '.join(params))
3404   # GENERATE END
3405
3406 class StatementIf(Statement):
3407   # GENERATE ELEMENT() BEGIN
3408   def __init__(
3409     self,
3410     tag = 'StatementIf',
3411     attrib = {},
3412     text = '',
3413     children = []
3414   ):
3415     Statement.__init__(
3416       self,
3417       tag,
3418       attrib,
3419       text,
3420       children
3421     )
3422   def copy(self, factory = None):
3423     result = Statement.copy(
3424       self,
3425       StatementIf if factory is None else factory
3426     )
3427     return result
3428   def __repr__(self):
3429     params = []
3430     self.repr_serialize(params)
3431     return 'ast.StatementIf({0:s})'.format(', '.join(params))
3432   # GENERATE END
3433   def translate(self, context):
3434     assert len(self) == 2
3435     indent_save = context.indent
3436     context.indent += '  '
3437     self[0].translate(context)
3438     self[1].translate(context)
3439     context.indent = indent_save
3440     element.set_text(self, 0, '{0:s}if '.format(context.indent))
3441     element.set_text(self, 1, ':\n')
3442     element.set_text(self, 2, '')
3443
3444 class StatementIfElse(Statement):
3445   # GENERATE ELEMENT() BEGIN
3446   def __init__(
3447     self,
3448     tag = 'StatementIfElse',
3449     attrib = {},
3450     text = '',
3451     children = []
3452   ):
3453     Statement.__init__(
3454       self,
3455       tag,
3456       attrib,
3457       text,
3458       children
3459     )
3460   def copy(self, factory = None):
3461     result = Statement.copy(
3462       self,
3463       StatementIfElse if factory is None else factory
3464     )
3465     return result
3466   def __repr__(self):
3467     params = []
3468     self.repr_serialize(params)
3469     return 'ast.StatementIfElse({0:s})'.format(', '.join(params))
3470   # GENERATE END
3471   def translate(self, context):
3472     assert len(self) == 3
3473     indent_save = context.indent
3474     context.indent += '  '
3475     self[0].translate(context)
3476     self[1].translate(context)
3477     self[2].translate(context)
3478     context.indent = indent_save
3479     element.set_text(self, 0, '{0:s}if '.format(context.indent))
3480     element.set_text(self, 1, ':\n')
3481     element.set_text(self, 2, '{0:s}else:\n'.format(context.indent))
3482     element.set_text(self, 3, '')
3483
3484 class StatementLabel(Statement):
3485   # GENERATE ELEMENT() BEGIN
3486   def __init__(
3487     self,
3488     tag = 'StatementLabel',
3489     attrib = {},
3490     text = '',
3491     children = []
3492   ):
3493     Statement.__init__(
3494       self,
3495       tag,
3496       attrib,
3497       text,
3498       children
3499     )
3500   def copy(self, factory = None):
3501     result = Statement.copy(
3502       self,
3503       StatementLabel if factory is None else factory
3504     )
3505     return result
3506   def __repr__(self):
3507     params = []
3508     self.repr_serialize(params)
3509     return 'ast.StatementLabel({0:s})'.format(', '.join(params))
3510   # GENERATE END
3511
3512 class StatementReturn(Statement):
3513   # GENERATE ELEMENT() BEGIN
3514   def __init__(
3515     self,
3516     tag = 'StatementReturn',
3517     attrib = {},
3518     text = '',
3519     children = []
3520   ):
3521     Statement.__init__(
3522       self,
3523       tag,
3524       attrib,
3525       text,
3526       children
3527     )
3528   def copy(self, factory = None):
3529     result = Statement.copy(
3530       self,
3531       StatementReturn if factory is None else factory
3532     )
3533     return result
3534   def __repr__(self):
3535     params = []
3536     self.repr_serialize(params)
3537     return 'ast.StatementReturn({0:s})'.format(', '.join(params))
3538   # GENERATE END
3539
3540 class StatementSwitch(Statement):
3541   # GENERATE ELEMENT() BEGIN
3542   def __init__(
3543     self,
3544     tag = 'StatementSwitch',
3545     attrib = {},
3546     text = '',
3547     children = []
3548   ):
3549     Statement.__init__(
3550       self,
3551       tag,
3552       attrib,
3553       text,
3554       children
3555     )
3556   def copy(self, factory = None):
3557     result = Statement.copy(
3558       self,
3559       StatementSwitch if factory is None else factory
3560     )
3561     return result
3562   def __repr__(self):
3563     params = []
3564     self.repr_serialize(params)
3565     return 'ast.StatementSwitch({0:s})'.format(', '.join(params))
3566   # GENERATE END
3567
3568 class StatementWhile(Statement):
3569   # GENERATE ELEMENT() BEGIN
3570   def __init__(
3571     self,
3572     tag = 'StatementWhile',
3573     attrib = {},
3574     text = '',
3575     children = []
3576   ):
3577     Statement.__init__(
3578       self,
3579       tag,
3580       attrib,
3581       text,
3582       children
3583     )
3584   def copy(self, factory = None):
3585     result = Statement.copy(
3586       self,
3587       StatementWhile if factory is None else factory
3588     )
3589     return result
3590   def __repr__(self):
3591     params = []
3592     self.repr_serialize(params)
3593     return 'ast.StatementWhile({0:s})'.format(', '.join(params))
3594   # GENERATE END
3595   def translate(self, context):
3596     assert len(self) == 2
3597     indent_save = context.indent
3598     context.indent += '  '
3599     self[0].translate(context)
3600     enclosing_loop_save = context.enclosing_loop
3601     context.enclosing_loop = self
3602     self[1].translate(context)
3603     context.enclosing_loop = enclosing_loop_save
3604     context.indent = indent_save
3605     element.set_text(self, 0, '{0:s}while '.format(context.indent))
3606     element.set_text(self, 1, ':\n')
3607     element.set_text(self, 2, '')
3608
3609 class StaticAssertDeclaration(Element):
3610   # GENERATE ELEMENT() BEGIN
3611   def __init__(
3612     self,
3613     tag = 'StaticAssertDeclaration',
3614     attrib = {},
3615     text = '',
3616     children = []
3617   ):
3618     Element.__init__(
3619       self,
3620       tag,
3621       attrib,
3622       text,
3623       children
3624     )
3625   def copy(self, factory = None):
3626     result = Element.copy(
3627       self,
3628       StaticAssertDeclaration if factory is None else factory
3629     )
3630     return result
3631   def __repr__(self):
3632     params = []
3633     self.repr_serialize(params)
3634     return 'ast.StaticAssertDeclaration({0:s})'.format(', '.join(params))
3635   # GENERATE END
3636
3637 class StorageClassSpecifier(Element):
3638   # GENERATE ELEMENT(int n) BEGIN
3639   def __init__(
3640     self,
3641     tag = 'StorageClassSpecifier',
3642     attrib = {},
3643     text = '',
3644     children = [],
3645     n = -1
3646   ):
3647     Element.__init__(
3648       self,
3649       tag,
3650       attrib,
3651       text,
3652       children
3653     )
3654     self.n = (
3655       element.deserialize_int(n)
3656     if isinstance(n, str) else
3657       n
3658     )
3659   def serialize(self, ref_list):
3660     Element.serialize(self, ref_list)
3661     self.set('n', element.serialize_int(self.n))
3662   def deserialize(self, ref_list):
3663     Element.deserialize(self, ref_list)
3664     self.n = element.deserialize_int(self.get('n', '-1'))
3665   def copy(self, factory = None):
3666     result = Element.copy(
3667       self,
3668       StorageClassSpecifier if factory is None else factory
3669     )
3670     result.n = self.n
3671     return result
3672   def repr_serialize(self, params):
3673     Element.repr_serialize(self, params)
3674     if self.n != -1:
3675       params.append(
3676         'n = {0:s}'.format(repr(self.n))
3677       )
3678   def __repr__(self):
3679     params = []
3680     self.repr_serialize(params)
3681     return 'ast.StorageClassSpecifier({0:s})'.format(', '.join(params))
3682   # GENERATE END
3683
3684 class StructDeclaration(Element):
3685   # GENERATE ELEMENT() BEGIN
3686   def __init__(
3687     self,
3688     tag = 'StructDeclaration',
3689     attrib = {},
3690     text = '',
3691     children = []
3692   ):
3693     Element.__init__(
3694       self,
3695       tag,
3696       attrib,
3697       text,
3698       children
3699     )
3700   def copy(self, factory = None):
3701     result = Element.copy(
3702       self,
3703       StructDeclaration if factory is None else factory
3704     )
3705     return result
3706   def __repr__(self):
3707     params = []
3708     self.repr_serialize(params)
3709     return 'ast.StructDeclaration({0:s})'.format(', '.join(params))
3710   # GENERATE END
3711
3712 class StructDeclarationList(Element):
3713   # GENERATE ELEMENT() BEGIN
3714   def __init__(
3715     self,
3716     tag = 'StructDeclarationList',
3717     attrib = {},
3718     text = '',
3719     children = []
3720   ):
3721     Element.__init__(
3722       self,
3723       tag,
3724       attrib,
3725       text,
3726       children
3727     )
3728   def copy(self, factory = None):
3729     result = Element.copy(
3730       self,
3731       StructDeclarationList if factory is None else factory
3732     )
3733     return result
3734   def __repr__(self):
3735     params = []
3736     self.repr_serialize(params)
3737     return 'ast.StructDeclarationList({0:s})'.format(', '.join(params))
3738   # GENERATE END
3739
3740 class StructDeclarator(Element):
3741   # GENERATE ELEMENT() BEGIN
3742   def __init__(
3743     self,
3744     tag = 'StructDeclarator',
3745     attrib = {},
3746     text = '',
3747     children = []
3748   ):
3749     Element.__init__(
3750       self,
3751       tag,
3752       attrib,
3753       text,
3754       children
3755     )
3756   def copy(self, factory = None):
3757     result = Element.copy(
3758       self,
3759       StructDeclarator if factory is None else factory
3760     )
3761     return result
3762   def __repr__(self):
3763     params = []
3764     self.repr_serialize(params)
3765     return 'ast.StructDeclarator({0:s})'.format(', '.join(params))
3766   # GENERATE END
3767
3768 class StructDeclaratorList(Element):
3769   # GENERATE ELEMENT() BEGIN
3770   def __init__(
3771     self,
3772     tag = 'StructDeclaratorList',
3773     attrib = {},
3774     text = '',
3775     children = []
3776   ):
3777     Element.__init__(
3778       self,
3779       tag,
3780       attrib,
3781       text,
3782       children
3783     )
3784   def copy(self, factory = None):
3785     result = Element.copy(
3786       self,
3787       StructDeclaratorList if factory is None else factory
3788     )
3789     return result
3790   def __repr__(self):
3791     params = []
3792     self.repr_serialize(params)
3793     return 'ast.StructDeclaratorList({0:s})'.format(', '.join(params))
3794   # GENERATE END
3795
3796 class StructSpecifier(Element):
3797   # GENERATE ELEMENT() BEGIN
3798   def __init__(
3799     self,
3800     tag = 'StructSpecifier',
3801     attrib = {},
3802     text = '',
3803     children = []
3804   ):
3805     Element.__init__(
3806       self,
3807       tag,
3808       attrib,
3809       text,
3810       children
3811     )
3812   def copy(self, factory = None):
3813     result = Element.copy(
3814       self,
3815       StructSpecifier if factory is None else factory
3816     )
3817     return result
3818   def __repr__(self):
3819     params = []
3820     self.repr_serialize(params)
3821     return 'ast.StructSpecifier({0:s})'.format(', '.join(params))
3822   # GENERATE END
3823
3824 class TypeName(Element):
3825   # GENERATE ELEMENT() BEGIN
3826   def __init__(
3827     self,
3828     tag = 'TypeName',
3829     attrib = {},
3830     text = '',
3831     children = []
3832   ):
3833     Element.__init__(
3834       self,
3835       tag,
3836       attrib,
3837       text,
3838       children
3839     )
3840   def copy(self, factory = None):
3841     result = Element.copy(
3842       self,
3843       TypeName if factory is None else factory
3844     )
3845     return result
3846   def __repr__(self):
3847     params = []
3848     self.repr_serialize(params)
3849     return 'ast.TypeName({0:s})'.format(', '.join(params))
3850   # GENERATE END
3851
3852 class TypeQualifier(Element):
3853   # GENERATE ELEMENT(int n) BEGIN
3854   def __init__(
3855     self,
3856     tag = 'TypeQualifier',
3857     attrib = {},
3858     text = '',
3859     children = [],
3860     n = -1
3861   ):
3862     Element.__init__(
3863       self,
3864       tag,
3865       attrib,
3866       text,
3867       children
3868     )
3869     self.n = (
3870       element.deserialize_int(n)
3871     if isinstance(n, str) else
3872       n
3873     )
3874   def serialize(self, ref_list):
3875     Element.serialize(self, ref_list)
3876     self.set('n', element.serialize_int(self.n))
3877   def deserialize(self, ref_list):
3878     Element.deserialize(self, ref_list)
3879     self.n = element.deserialize_int(self.get('n', '-1'))
3880   def copy(self, factory = None):
3881     result = Element.copy(
3882       self,
3883       TypeQualifier if factory is None else factory
3884     )
3885     result.n = self.n
3886     return result
3887   def repr_serialize(self, params):
3888     Element.repr_serialize(self, params)
3889     if self.n != -1:
3890       params.append(
3891         'n = {0:s}'.format(repr(self.n))
3892       )
3893   def __repr__(self):
3894     params = []
3895     self.repr_serialize(params)
3896     return 'ast.TypeQualifier({0:s})'.format(', '.join(params))
3897   # GENERATE END
3898
3899 class TypeQualifierList(Element):
3900   # GENERATE ELEMENT() BEGIN
3901   def __init__(
3902     self,
3903     tag = 'TypeQualifierList',
3904     attrib = {},
3905     text = '',
3906     children = []
3907   ):
3908     Element.__init__(
3909       self,
3910       tag,
3911       attrib,
3912       text,
3913       children
3914     )
3915   def copy(self, factory = None):
3916     result = Element.copy(
3917       self,
3918       TypeQualifierList if factory is None else factory
3919     )
3920     return result
3921   def __repr__(self):
3922     params = []
3923     self.repr_serialize(params)
3924     return 'ast.TypeQualifierList({0:s})'.format(', '.join(params))
3925   # GENERATE END
3926
3927 class TypeQualifierOrStaticList(Element):
3928   # GENERATE ELEMENT() BEGIN
3929   def __init__(
3930     self,
3931     tag = 'TypeQualifierOrStaticList',
3932     attrib = {},
3933     text = '',
3934     children = []
3935   ):
3936     Element.__init__(
3937       self,
3938       tag,
3939       attrib,
3940       text,
3941       children
3942     )
3943   def copy(self, factory = None):
3944     result = Element.copy(
3945       self,
3946       TypeQualifierOrStaticList if factory is None else factory
3947     )
3948     return result
3949   def __repr__(self):
3950     params = []
3951     self.repr_serialize(params)
3952     return 'ast.TypeQualifierOrStaticList({0:s})'.format(', '.join(params))
3953   # GENERATE END
3954
3955 class TypeSpecifier(Element):
3956   # GENERATE ELEMENT(int n) BEGIN
3957   def __init__(
3958     self,
3959     tag = 'TypeSpecifier',
3960     attrib = {},
3961     text = '',
3962     children = [],
3963     n = -1
3964   ):
3965     Element.__init__(
3966       self,
3967       tag,
3968       attrib,
3969       text,
3970       children
3971     )
3972     self.n = (
3973       element.deserialize_int(n)
3974     if isinstance(n, str) else
3975       n
3976     )
3977   def serialize(self, ref_list):
3978     Element.serialize(self, ref_list)
3979     self.set('n', element.serialize_int(self.n))
3980   def deserialize(self, ref_list):
3981     Element.deserialize(self, ref_list)
3982     self.n = element.deserialize_int(self.get('n', '-1'))
3983   def copy(self, factory = None):
3984     result = Element.copy(
3985       self,
3986       TypeSpecifier if factory is None else factory
3987     )
3988     result.n = self.n
3989     return result
3990   def repr_serialize(self, params):
3991     Element.repr_serialize(self, params)
3992     if self.n != -1:
3993       params.append(
3994         'n = {0:s}'.format(repr(self.n))
3995       )
3996   def __repr__(self):
3997     params = []
3998     self.repr_serialize(params)
3999     return 'ast.TypeSpecifier({0:s})'.format(', '.join(params))
4000   # GENERATE END
4001
4002 class UnionSpecifier(Element):
4003   # GENERATE ELEMENT() BEGIN
4004   def __init__(
4005     self,
4006     tag = 'UnionSpecifier',
4007     attrib = {},
4008     text = '',
4009     children = []
4010   ):
4011     Element.__init__(
4012       self,
4013       tag,
4014       attrib,
4015       text,
4016       children
4017     )
4018   def copy(self, factory = None):
4019     result = Element.copy(
4020       self,
4021       UnionSpecifier if factory is None else factory
4022     )
4023     return result
4024   def __repr__(self):
4025     params = []
4026     self.repr_serialize(params)
4027     return 'ast.UnionSpecifier({0:s})'.format(', '.join(params))
4028   # GENERATE END
4029
4030 # GENERATE FACTORY(element.Element) BEGIN
4031 tag_to_class = {
4032   'Element': Element,
4033   'DeclarationOrStatement': DeclarationOrStatement,
4034   'AlignAsExpression': AlignAsExpression,
4035   'AlignAsType': AlignAsType,
4036   'ArgumentExpressionList': ArgumentExpressionList,
4037   'BlockItemList': BlockItemList,
4038   'CommaEllipsis': CommaEllipsis,
4039   'CommaEllipsisEmpty': CommaEllipsisEmpty,
4040   'Declaration': Declaration,
4041   'DeclarationList': DeclarationList,
4042   'DeclarationSpecifierList': DeclarationSpecifierList,
4043   'Declarator': Declarator,
4044   'DeclaratorAbstract': DeclaratorAbstract,
4045   'DeclaratorArray': DeclaratorArray,
4046   'DeclaratorEmpty': DeclaratorEmpty,
4047   'DeclaratorFunction': DeclaratorFunction,
4048   'DeclaratorFunctionOldStyle': DeclaratorFunctionOldStyle,
4049   'DeclaratorIdentifier': DeclaratorIdentifier,
4050   'DeclaratorPointer': DeclaratorPointer,
4051   'DefaultTypeName': DefaultTypeName,
4052   'DesignatorField': DesignatorField,
4053   'DesignatorIndex': DesignatorIndex,
4054   'DesignatorInitializer': DesignatorInitializer,
4055   'DesignatorInitializerList': DesignatorInitializerList,
4056   'DesignatorList': DesignatorList,
4057   'EnumSpecifier': EnumSpecifier,
4058   'Enumerator': Enumerator,
4059   'EnumeratorList': EnumeratorList,
4060   'EqualsInitializerEmpty': EqualsInitializerEmpty,
4061   'Expression': Expression,
4062   'ExpressionAdd': ExpressionAdd,
4063   'ExpressionAddAssignment': ExpressionAddAssignment,
4064   'ExpressionAddressOf': ExpressionAddressOf,
4065   'ExpressionAlignOfType': ExpressionAlignOfType,
4066   'ExpressionArray': ExpressionArray,
4067   'ExpressionAssignment': ExpressionAssignment,
4068   'ExpressionAsterisk': ExpressionAsterisk,
4069   'ExpressionBitwiseAnd': ExpressionBitwiseAnd,
4070   'ExpressionBitwiseAndAssignment': ExpressionBitwiseAndAssignment,
4071   'ExpressionBitwiseNot': ExpressionBitwiseNot,
4072   'ExpressionBitwiseOr': ExpressionBitwiseOr,
4073   'ExpressionBitwiseOrAssignment': ExpressionBitwiseOrAssignment,
4074   'ExpressionCall': ExpressionCall,
4075   'ExpressionCast': ExpressionCast,
4076   'ExpressionCharConstant': ExpressionCharConstant,
4077   'ExpressionComma': ExpressionComma,
4078   'ExpressionConditional': ExpressionConditional,
4079   'ExpressionDereference': ExpressionDereference,
4080   'ExpressionDivide': ExpressionDivide,
4081   'ExpressionDivideAssignment': ExpressionDivideAssignment,
4082   'ExpressionEmpty': ExpressionEmpty,
4083   'ExpressionEqual': ExpressionEqual,
4084   'ExpressionExclusiveOr': ExpressionExclusiveOr,
4085   'ExpressionExclusiveOrAssignment': ExpressionExclusiveOrAssignment,
4086   'ExpressionField': ExpressionField,
4087   'ExpressionFieldDereference': ExpressionFieldDereference,
4088   'ExpressionFloatLiteral': ExpressionFloatLiteral,
4089   'ExpressionFunctionName': ExpressionFunctionName,
4090   'ExpressionGreaterThan': ExpressionGreaterThan,
4091   'ExpressionGreaterThanOrEqual': ExpressionGreaterThanOrEqual,
4092   'ExpressionIdentifier': ExpressionIdentifier,
4093   'ExpressionIndex': ExpressionIndex,
4094   'ExpressionIntLiteral': ExpressionIntLiteral,
4095   'Identifier': Identifier,
4096   'ExpressionLeftShiftAssignment': ExpressionLeftShiftAssignment,
4097   'ExpressionLessThan': ExpressionLessThan,
4098   'ExpressionLessThanOrEqual': ExpressionLessThanOrEqual,
4099   'ExpressionLogicalAnd': ExpressionLogicalAnd,
4100   'ExpressionLogicalNot': ExpressionLogicalNot,
4101   'ExpressionLogicalOr': ExpressionLogicalOr,
4102   'ExpressionMinus': ExpressionMinus,
4103   'ExpressionModulo': ExpressionModulo,
4104   'ExpressionModuloAssignment': ExpressionModuloAssignment,
4105   'ExpressionMultiply': ExpressionMultiply,
4106   'ExpressionMultiplyAssignment': ExpressionMultiplyAssignment,
4107   'ExpressionNotEqual': ExpressionNotEqual,
4108   'ExpressionPlus': ExpressionPlus,
4109   'ExpressionPostDecrement': ExpressionPostDecrement,
4110   'ExpressionPostIncrement': ExpressionPostIncrement,
4111   'ExpressionPreDecrement': ExpressionPreDecrement,
4112   'ExpressionPreIncrement': ExpressionPreIncrement,
4113   'ExpressionRightShiftAssignment': ExpressionRightShiftAssignment,
4114   'ExpressionShiftLeft': ExpressionShiftLeft,
4115   'ExpressionShiftRight': ExpressionShiftRight,
4116   'ExpressionSizeOfExpression': ExpressionSizeOfExpression,
4117   'ExpressionSizeOfType': ExpressionSizeOfType,
4118   'ExpressionStringLiteral': ExpressionStringLiteral,
4119   'ExpressionSubtract': ExpressionSubtract,
4120   'ExpressionSubtractAssignment': ExpressionSubtractAssignment,
4121   'FunctionDefinition': FunctionDefinition,
4122   'FunctionSpecifier': FunctionSpecifier,
4123   'GenericAssociation': GenericAssociation,
4124   'GenericAssociationList': GenericAssociationList,
4125   'GenericSelection': GenericSelection,
4126   'IdentifierEmpty': IdentifierEmpty,
4127   'IdentifierList': IdentifierList,
4128   'InitDeclarator': InitDeclarator,
4129   'InitDeclaratorList': InitDeclaratorList,
4130   'ParameterDeclaration': ParameterDeclaration,
4131   'ParameterDeclarationList': ParameterDeclarationList,
4132   'SpecifierQualifierList': SpecifierQualifierList,
4133   'Statement': Statement,
4134   'StatementBlock': StatementBlock,
4135   'StatementBreak': StatementBreak,
4136   'StatementCase': StatementCase,
4137   'StatementContinue': StatementContinue,
4138   'StatementDefault': StatementDefault,
4139   'StatementDoWhile': StatementDoWhile,
4140   'StatementExpression': StatementExpression,
4141   'StatementFor': StatementFor,
4142   'StatementGoto': StatementGoto,
4143   'StatementIf': StatementIf,
4144   'StatementIfElse': StatementIfElse,
4145   'StatementLabel': StatementLabel,
4146   'StatementReturn': StatementReturn,
4147   'StatementSwitch': StatementSwitch,
4148   'StatementWhile': StatementWhile,
4149   'StaticAssertDeclaration': StaticAssertDeclaration,
4150   'StorageClassSpecifier': StorageClassSpecifier,
4151   'StructDeclaration': StructDeclaration,
4152   'StructDeclarationList': StructDeclarationList,
4153   'StructDeclarator': StructDeclarator,
4154   'StructDeclaratorList': StructDeclaratorList,
4155   'StructSpecifier': StructSpecifier,
4156   'TypeName': TypeName,
4157   'TypeQualifier': TypeQualifier,
4158   'TypeQualifierList': TypeQualifierList,
4159   'TypeQualifierOrStaticList': TypeQualifierOrStaticList,
4160   'TypeSpecifier': TypeSpecifier,
4161   'UnionSpecifier': UnionSpecifier
4162 }
4163 def factory(tag, attrib = {}, *args, **kwargs):
4164   return tag_to_class.get(tag, element.Element)(tag, attrib, *args, **kwargs)
4165 # GENERATE END