Translate expressions properly, with parentheses depending on precedence, translate...

diff --git a/ansi_c.l b/ansi_c.l
index 2b121ac..49900bf 100644 (file)
--- a/ansi_c.l
+++ b/ansi_c.l
@@ -39,7 +39,7 @@ import y_tab
 "case"                                 return y_tab.CASE
 "char"                                 return y_tab.CHAR
 "const"                                        return y_tab.CONST
-
+"continue"                             return y_tab.CONTINUE
 "default"                              return y_tab.DEFAULT
 "do"                                   return y_tab.DO
 "double"                               return y_tab.DOUBLE
@@ -92,7 +92,7 @@ import y_tab
 (?E{ast.AST.ExpressionIntLiteral}{HP}{H}+{IS}?) |
 (?E{ast.AST.ExpressionIntLiteral}{NZ}{D}*{IS}?) |
 (?E{ast.AST.ExpressionIntLiteral}"0"{O}*{IS}?) |
-(?E{ast.AST.ExpressionCharConstant}{CP}?"'"([^'\\\n]|{ES})+"'") {
+(?E{ast.AST.ExpressionCharConstant}{CP}?"'"(?E{ast.AST.Text}([^'\\\n]|{ES})+)"'") {
   return y_tab.I_CONSTANT
 }
 

diff --git a/ansi_c.y b/ansi_c.y
index 215e832..9ef78a0 100644 (file)
--- a/ansi_c.y
+++ b/ansi_c.y
@@ -72,8 +72,8 @@ postfix_expression
        | (?E{ast.AST.ExpressionCall}postfix_expression '(' (?E{ast.AST.ArgumentExpressionList}argument_expression_list_opt) ')')
        | (?E{ast.AST.ExpressionField}postfix_expression '.' IDENTIFIER)
        | (?E{ast.AST.ExpressionFieldDereference}postfix_expression PTR_OP IDENTIFIER)
-       | (?E{ast.AST.ExpressionPostIncrement}postfix_expression INC_OP)
-       | (?E{ast.AST.ExpressionPostDecrement}postfix_expression DEC_OP)
+       | (?E{ast.AST.ExpressionPostIncrement, unary_operator = '++', postfix = True}postfix_expression INC_OP)
+       | (?E{ast.AST.ExpressionPostDecrement, unary_operator = '--', postfix = True}postfix_expression DEC_OP)
        | (?E{ast.AST.ExpressionArray}'(' type_name ')' '{' (?E{ast.AST.DesignatorInitializerList}designator_initializer_list_comma_opt) '}')
        ;
 
@@ -89,17 +89,17 @@ argument_expression_list
 
 unary_expression
        : postfix_expression
-       | (?E{ast.AST.ExpressionPreIncrement}INC_OP unary_expression)
-       | (?E{ast.AST.ExpressionPreDecrement}DEC_OP unary_expression)
-       | (?E{ast.AST.ExpressionAddressOf}'&' cast_expression)
-       | (?E{ast.AST.ExpressionDereference}'*' cast_expression)
-       | (?E{ast.AST.ExpressionPlus}'+' cast_expression)
-       | (?E{ast.AST.ExpressionMinus}'-' cast_expression)
-       | (?E{ast.AST.ExpressionBitwiseNot}'~' cast_expression)
-       | (?E{ast.AST.ExpressionLogicalNot}'!' cast_expression)
-       | (?E{ast.AST.ExpressionSizeOfExpression}SIZEOF unary_expression)
-       | (?E{ast.AST.ExpressionSizeOfType}SIZEOF '(' type_name ')')
-       | (?E{ast.AST.ExpressionAlignOfType}ALIGNOF '(' type_name ')')
+       | (?E{ast.AST.ExpressionPreIncrement, unary_operator = '++'}INC_OP unary_expression)
+       | (?E{ast.AST.ExpressionPreDecrement, unary_operator = '--'}DEC_OP unary_expression)
+       | (?E{ast.AST.ExpressionAddressOf, unary_operator = '&'}'&' cast_expression)
+       | (?E{ast.AST.ExpressionDereference, unary_operator = '*'}'*' cast_expression)
+       | (?E{ast.AST.ExpressionPlus, unary_operator = '+'}'+' cast_expression)
+       | (?E{ast.AST.ExpressionMinus, unary_operator = '-'}'-' cast_expression)
+       | (?E{ast.AST.ExpressionBitwiseNot, unary_operator = '~'}'~' cast_expression)
+       | (?E{ast.AST.ExpressionLogicalNot, unary_operator = 'not '}'!' cast_expression)
+       | (?E{ast.AST.ExpressionSizeOfExpression, unary_operator = 'sizeof '}SIZEOF unary_expression)
+       | (?E{ast.AST.ExpressionSizeOfType, unary_operator = 'sizeof '}SIZEOF '(' type_name ')')
+       | (?E{ast.AST.ExpressionAlignOfType, unary_operator = 'alignof '}ALIGNOF '(' type_name ')')
        ;
 
 cast_expression
@@ -109,60 +109,60 @@ cast_expression
 
 multiplicative_expression
        : cast_expression
-       | (?E{ast.AST.ExpressionMultiply}multiplicative_expression '*' cast_expression)
-       | (?E{ast.AST.ExpressionDivide}multiplicative_expression '/' cast_expression)
-       | (?E{ast.AST.ExpressionModulo}multiplicative_expression '%' cast_expression)
+       | (?E{ast.AST.ExpressionMultiply, binary_operator = ' * ', precedence = 12}multiplicative_expression '*' cast_expression)
+       | (?E{ast.AST.ExpressionDivide, binary_operator = ' / ', precedence = 12}multiplicative_expression '/' cast_expression)
+       | (?E{ast.AST.ExpressionModulo, binary_operator = ' % ', precedence = 12}multiplicative_expression '%' cast_expression)
        ;
 
 additive_expression
        : multiplicative_expression
-       | (?E{ast.AST.ExpressionAdd}additive_expression '+' multiplicative_expression)
-       | (?E{ast.AST.ExpressionSubtract}additive_expression '-' multiplicative_expression)
+       | (?E{ast.AST.ExpressionAdd, binary_operator = ' + ', precedence = 11}additive_expression '+' multiplicative_expression)
+       | (?E{ast.AST.ExpressionSubtract, binary_operator = ' - ', precedence = 11}additive_expression '-' multiplicative_expression)
        ;
 
 shift_expression
        : additive_expression
-       | (?E{ast.AST.ExpressionShiftLeft}shift_expression LEFT_OP additive_expression)
-       | (?E{ast.AST.ExpressionShiftRight}shift_expression RIGHT_OP additive_expression)
+       | (?E{ast.AST.ExpressionShiftLeft, binary_operator = ' << ', precedence = 10}shift_expression LEFT_OP additive_expression)
+       | (?E{ast.AST.ExpressionShiftRight, binary_operator = ' >> ', precedence = 10}shift_expression RIGHT_OP additive_expression)
        ;
 
 relational_expression
        : shift_expression
-       | (?E{ast.AST.ExpressionLessThan}relational_expression '<' shift_expression)
-       | (?E{ast.AST.ExpressionGreaterThan}relational_expression '>' shift_expression)
-       | (?E{ast.AST.ExpressionLessThanOrEqual}relational_expression LE_OP shift_expression)
-       | (?E{ast.AST.ExpressionGreaterThanOrEqual}relational_expression GE_OP shift_expression)
+       | (?E{ast.AST.ExpressionLessThan, binary_operator = ' < ', precedence = 9}relational_expression '<' shift_expression)
+       | (?E{ast.AST.ExpressionGreaterThan, binary_operator = ' > ', precedence = 9}relational_expression '>' shift_expression)
+       | (?E{ast.AST.ExpressionLessThanOrEqual, binary_operator = ' <= ', precedence = 9}relational_expression LE_OP shift_expression)
+       | (?E{ast.AST.ExpressionGreaterThanOrEqual, binary_operator = ' >= ', precedence = 9}relational_expression GE_OP shift_expression)
        ;
 
 equality_expression
        : relational_expression
-       | (?E{ast.AST.ExpressionEqual}equality_expression EQ_OP relational_expression)
-       | (?E{ast.AST.ExpressionNotEqual}equality_expression NE_OP relational_expression)
+       | (?E{ast.AST.ExpressionEqual, binary_operator = ' == ', precedence = 8}equality_expression EQ_OP relational_expression)
+       | (?E{ast.AST.ExpressionNotEqual, binary_operator = ' != ', precedence = 8}equality_expression NE_OP relational_expression)
        ;
 
 and_expression
        : equality_expression
-       | (?E{ast.AST.ExpressionBitwiseAnd}and_expression '&' equality_expression)
+       | (?E{ast.AST.ExpressionBitwiseAnd, binary_operator = ' & ', precedence = 7}and_expression '&' equality_expression)
        ;
 
 exclusive_or_expression
        : and_expression
-       | (?E{ast.AST.ExpressionExclusiveOr}exclusive_or_expression '^' and_expression)
+       | (?E{ast.AST.ExpressionExclusiveOr, binary_operator = ' ^ ', precedence = 6}exclusive_or_expression '^' and_expression)
        ;
 
 inclusive_or_expression
        : exclusive_or_expression
-       | (?E{ast.AST.ExpressionBitwiseOr}inclusive_or_expression '|' exclusive_or_expression)
+       | (?E{ast.AST.ExpressionBitwiseOr, binary_operator = ' | ', precedence = 5}inclusive_or_expression '|' exclusive_or_expression)
        ;
 
 logical_and_expression
        : inclusive_or_expression
-       | (?E{ast.AST.ExpressionLogicalAnd}logical_and_expression AND_OP inclusive_or_expression)
+       | (?E{ast.AST.ExpressionLogicalAnd, binary_operator = ' and ', precedence = 4}logical_and_expression AND_OP inclusive_or_expression)
        ;
 
 logical_or_expression
        : logical_and_expression
-       | (?E{ast.AST.ExpressionLogicalOr}logical_or_expression OR_OP logical_and_expression)
+       | (?E{ast.AST.ExpressionLogicalOr, binary_operator = ' or ', precedence = 3}logical_or_expression OR_OP logical_and_expression)
        ;
 
 conditional_expression
@@ -178,17 +178,17 @@ assignment_expression_or_asterisk_opt
 
 assignment_expression
        : conditional_expression
-       | (?E{ast.AST.ExpressionAssignment}unary_expression '=' assignment_expression)
-       | (?E{ast.AST.ExpressionMultiplyAssignment}unary_expression MUL_ASSIGN assignment_expression)
-       | (?E{ast.AST.ExpressionDivideAssignment}unary_expression DIV_ASSIGN assignment_expression)
-       | (?E{ast.AST.ExpressionModuloAssignment}unary_expression MOD_ASSIGN assignment_expression)
-       | (?E{ast.AST.ExpressionAddAssignment}unary_expression ADD_ASSIGN assignment_expression)
-       | (?E{ast.AST.ExpressionSubtractAssignment}unary_expression SUB_ASSIGN assignment_expression)
-       | (?E{ast.AST.ExpressionLeftShiftAssignment}unary_expression LEFT_ASSIGN assignment_expression)
-       | (?E{ast.AST.ExpressionRightShiftAssignment}unary_expression RIGHT_ASSIGN assignment_expression)
-       | (?E{ast.AST.ExpressionBitwiseAndAssignment}unary_expression AND_ASSIGN assignment_expression)
-       | (?E{ast.AST.ExpressionExclusiveOrAssignment}unary_expression XOR_ASSIGN assignment_expression)
-       | (?E{ast.AST.ExpressionBitwiseOrAssignment}unary_expression OR_ASSIGN assignment_expression)
+       | (?E{ast.AST.ExpressionAssignment, binary_operator = ' = ', precedence = 1, right_to_left = True}unary_expression '=' assignment_expression)
+       | (?E{ast.AST.ExpressionMultiplyAssignment, binary_operator = ' *= ', precedence = 1, right_to_left = True}unary_expression MUL_ASSIGN assignment_expression)
+       | (?E{ast.AST.ExpressionDivideAssignment, binary_operator = ' /= ', precedence = 1, right_to_left = True}unary_expression DIV_ASSIGN assignment_expression)
+       | (?E{ast.AST.ExpressionModuloAssignment, binary_operator = ' %= ', precedence = 1, right_to_left = True}unary_expression MOD_ASSIGN assignment_expression)
+       | (?E{ast.AST.ExpressionAddAssignment, binary_operator = ' += ', precedence = 1, right_to_left = True}unary_expression ADD_ASSIGN assignment_expression)
+       | (?E{ast.AST.ExpressionSubtractAssignment, binary_operator = ' -= ', precedence = 1, right_to_left = True}unary_expression SUB_ASSIGN assignment_expression)
+       | (?E{ast.AST.ExpressionLeftShiftAssignment, binary_operator = ' <<= ', precedence = 1, right_to_left = True}unary_expression LEFT_ASSIGN assignment_expression)
+       | (?E{ast.AST.ExpressionRightShiftAssignment, binary_operator = ' >>= ', precedence = 1, right_to_left = True}unary_expression RIGHT_ASSIGN assignment_expression)
+       | (?E{ast.AST.ExpressionBitwiseAndAssignment, binary_operator = ' &= ', precedence = 1, right_to_left = True}unary_expression AND_ASSIGN assignment_expression)
+       | (?E{ast.AST.ExpressionExclusiveOrAssignment, binary_operator = ' ^= ', precedence = 1, right_to_left = True}unary_expression XOR_ASSIGN assignment_expression)
+       | (?E{ast.AST.ExpressionBitwiseOrAssignment, binary_operator = ' |= ', precedence = 1, right_to_left = True}unary_expression OR_ASSIGN assignment_expression)
        ;
 
 expression_opt
@@ -198,7 +198,7 @@ expression_opt
 
 expression
        : assignment_expression
-       | (?E{ast.AST.ExpressionComma}expression ',' assignment_expression)
+       | (?E{ast.AST.ExpressionComma, binary_operator = ', ', precedence = 0}expression ',' assignment_expression)
        ;
 
 equals_constant_expression_opt

diff --git a/ast.py b/ast.py
index 9de1ef0..cf878e1 100644 (file)
--- a/ast.py
+++ b/ast.py
@@ -51,11 +51,11 @@ class AST(element.Element):
       return 'ast.AST.Text({0:s})'.format(', '.join(params))
     # GENERATE END
 
-  class Element(element.Element):
+  class DeclarationOrStatement(element.Element):
     # GENERATE ELEMENT() BEGIN
     def __init__(
       self,
-      tag = 'AST_Element',
+      tag = 'AST_DeclarationOrStatement',
       attrib = {},
       text = '',
       children = []
@@ -70,54 +70,33 @@ class AST(element.Element):
     def copy(self, factory = None):
       result = element.Element.copy(
         self,
-        Element if factory is None else factory
+        DeclarationOrStatement if factory is None else factory
       )
       return result
     def __repr__(self):
       params = []
       self.repr_serialize(params)
-      return 'ast.AST.Element({0:s})'.format(', '.join(params))
+      return 'ast.AST.DeclarationOrStatement({0:s})'.format(', '.join(params))
     # GENERATE END
-    def translate(self, context):
-      for i in self:
-        i.translate(context)
-      prev_empty = True
-      for i in range(len(self) + 1):
-        text = element.get_text(self, i).strip()
-        next_empty = (
-          i >= len(self) or
-          (len(self[i]) == 0 and len(element.get_text(self[i], 0)) == 0)
-        )
-        if len(text) == 0:
-          if prev_empty:
-            text = ''
-            prev_empty = next_empty
-          elif next_empty:
-            text = ''
-            prev_empty = False
-          else:
-            text = ' '
-        else:
-          if prev_empty:
-            prev_empty = False
-          elif text[0] not in ',;)}]':
-            text = ' ' + text
-          if next_empty:
-            prev_empty = text[-1] in '({['
-          elif text[0] not in '({[':
-            text = text + ' '
-        element.set_text(self, i, text)
-
-  class DeclarationOrStatement(Element):
+    def translate_declaration_or_statement(self, context):
+      #text = element.to_text(self).strip()
+      #assert text[-1] == ';'
+      #context.lines.append(
+      #  '{0:s}{1:s}\n'.format(context.indent, text[:-1])
+      #)
+      print(self)
+      raise NotImplementedError
+
+  class Statement(DeclarationOrStatement):
     # GENERATE ELEMENT() BEGIN
     def __init__(
       self,
-      tag = 'AST_DeclarationOrStatement',
+      tag = 'AST_Statement',
       attrib = {},
       text = '',
       children = []
     ):
-      AST.Element.__init__(
+      AST.DeclarationOrStatement.__init__(
         self,
         tag,
         attrib,
@@ -125,33 +104,27 @@ class AST(element.Element):
         children
       )
     def copy(self, factory = None):
-      result = AST.Element.copy(
+      result = AST.DeclarationOrStatement.copy(
         self,
-        DeclarationOrStatement if factory is None else factory
+        Statement if factory is None else factory
       )
       return result
     def __repr__(self):
       params = []
       self.repr_serialize(params)
-      return 'ast.AST.DeclarationOrStatement({0:s})'.format(', '.join(params))
+      return 'ast.AST.Statement({0:s})'.format(', '.join(params))
     # GENERATE END
-    def translate_declaration_or_statement(self, context):
-      text = element.to_text(self).strip()
-      assert text[-1] == ';'
-      context.lines.append(
-        '{0:s}{1:s}\n'.format(context.indent, text[:-1])
-      )
 
-  class Statement(DeclarationOrStatement):
+  class Declarator(element.Element):
     # GENERATE ELEMENT() BEGIN
     def __init__(
       self,
-      tag = 'AST_Statement',
+      tag = 'AST_Declarator',
       attrib = {},
       text = '',
       children = []
     ):
-      AST.DeclarationOrStatement.__init__(
+      element.Element.__init__(
         self,
         tag,
         attrib,
@@ -159,27 +132,30 @@ class AST(element.Element):
         children
       )
     def copy(self, factory = None):
-      result = AST.DeclarationOrStatement.copy(
+      result = element.Element.copy(
         self,
-        Statement if factory is None else factory
+        Declarator if factory is None else factory
       )
       return result
     def __repr__(self):
       params = []
       self.repr_serialize(params)
-      return 'ast.AST.Statement({0:s})'.format(', '.join(params))
+      return 'ast.AST.Declarator({0:s})'.format(', '.join(params))
     # GENERATE END
+    def get_type_and_name(self, base_type):
+      print(self)
+      raise NotImplementedError
 
-  class Declarator(Element):
+  class Expression(element.Element):
     # GENERATE ELEMENT() BEGIN
     def __init__(
       self,
-      tag = 'AST_Declarator',
+      tag = 'AST_Expression',
       attrib = {},
       text = '',
       children = []
     ):
-      AST.Element.__init__(
+      element.Element.__init__(
         self,
         tag,
         attrib,
@@ -187,48 +163,178 @@ class AST(element.Element):
         children
       )
     def copy(self, factory = None):
-      result = AST.Element.copy(
+      result = element.Element.copy(
         self,
-        Declarator if factory is None else factory
+        Expression if factory is None else factory
       )
       return result
     def __repr__(self):
       params = []
       self.repr_serialize(params)
-      return 'ast.AST.Declarator({0:s})'.format(', '.join(params))
+      return 'ast.AST.Expression({0:s})'.format(', '.join(params))
     # GENERATE END
-    def get_type_and_name(self, base_type):
+    def translate_expression(self, context, precedence):
+      #return element.to_text(self).strip()
+      print(self)
       raise NotImplementedError
+    def translate_statement_expression(self, context):
+      return self.translate_expression(context, 0)
 
-  class Expression(Element):
-    # GENERATE ELEMENT() BEGIN
+  class ExpressionUnary(Expression):
+    # GENERATE ELEMENT(str unary_operator, bool postfix) BEGIN
     def __init__(
       self,
-      tag = 'AST_Expression',
+      tag = 'AST_ExpressionUnary',
       attrib = {},
       text = '',
-      children = []
+      children = [],
+      unary_operator = '',
+      postfix = False
     ):
-      AST.Element.__init__(
+      AST.Expression.__init__(
         self,
         tag,
         attrib,
         text,
         children
       )
+      self.unary_operator = unary_operator
+      self.postfix = (
+        element.deserialize_bool(postfix)
+      if isinstance(postfix, str) else
+        postfix
+      )
+    def serialize(self, ref_list):
+      AST.Expression.serialize(self, ref_list)
+      self.set('unary_operator', element.serialize_str(self.unary_operator))
+      self.set('postfix', element.serialize_bool(self.postfix))
+    def deserialize(self, ref_list):
+      AST.Expression.deserialize(self, ref_list)
+      self.unary_operator = element.deserialize_str(self.get('unary_operator', ''))
+      self.postfix = element.deserialize_bool(self.get('postfix', 'false'))
     def copy(self, factory = None):
-      result = AST.Element.copy(
+      result = AST.Expression.copy(
         self,
-        Expression if factory is None else factory
+        ExpressionUnary if factory is None else factory
       )
+      result.unary_operator = self.unary_operator
+      result.postfix = self.postfix
       return result
+    def repr_serialize(self, params):
+      AST.Expression.repr_serialize(self, params)
+      if self.unary_operator != '':
+        params.append(
+          'unary_operator = {0:s}'.format(repr(self.unary_operator))
+        )
+      if self.postfix != False:
+        params.append(
+          'postfix = {0:s}'.format(repr(self.postfix))
+        )
     def __repr__(self):
       params = []
       self.repr_serialize(params)
-      return 'ast.AST.Expression({0:s})'.format(', '.join(params))
+      return 'ast.AST.ExpressionUnary({0:s})'.format(', '.join(params))
     # GENERATE END
-    def translate_expression(self, context):
-      return element.to_text(self).strip()
+    def translate_expression(self, context, precedence):
+      if self.postfix:
+        text = '{0:s}{1:s}'.format(
+          self[0].translate_expression(context, 14),
+          self.unary_operator
+        )
+        if 14 < precedence:
+          text = '({0:s})'.format(text)
+      else:
+        text = '{0:s}{1:s}'.format(
+          self.unary_operator,
+          self[0].translate_expression(context, 13)
+        )
+        if 13 < precedence:
+          text = '({0:s})'.format(text)
+      return text
+
+  class ExpressionBinary(Expression):
+    # GENERATE ELEMENT(str binary_operator, int precedence, bool right_to_left) BEGIN
+    def __init__(
+      self,
+      tag = 'AST_ExpressionBinary',
+      attrib = {},
+      text = '',
+      children = [],
+      binary_operator = '',
+      precedence = -1,
+      right_to_left = False
+    ):
+      AST.Expression.__init__(
+        self,
+        tag,
+        attrib,
+        text,
+        children
+      )
+      self.binary_operator = binary_operator
+      self.precedence = (
+        element.deserialize_int(precedence)
+      if isinstance(precedence, str) else
+        precedence
+      )
+      self.right_to_left = (
+        element.deserialize_bool(right_to_left)
+      if isinstance(right_to_left, str) else
+        right_to_left
+      )
+    def serialize(self, ref_list):
+      AST.Expression.serialize(self, ref_list)
+      self.set('binary_operator', element.serialize_str(self.binary_operator))
+      self.set('precedence', element.serialize_int(self.precedence))
+      self.set('right_to_left', element.serialize_bool(self.right_to_left))
+    def deserialize(self, ref_list):
+      AST.Expression.deserialize(self, ref_list)
+      self.binary_operator = element.deserialize_str(self.get('binary_operator', ''))
+      self.precedence = element.deserialize_int(self.get('precedence', '-1'))
+      self.right_to_left = element.deserialize_bool(self.get('right_to_left', 'false'))
+    def copy(self, factory = None):
+      result = AST.Expression.copy(
+        self,
+        ExpressionBinary if factory is None else factory
+      )
+      result.binary_operator = self.binary_operator
+      result.precedence = self.precedence
+      result.right_to_left = self.right_to_left
+      return result
+    def repr_serialize(self, params):
+      AST.Expression.repr_serialize(self, params)
+      if self.binary_operator != '':
+        params.append(
+          'binary_operator = {0:s}'.format(repr(self.binary_operator))
+        )
+      if self.precedence != -1:
+        params.append(
+          'precedence = {0:s}'.format(repr(self.precedence))
+        )
+      if self.right_to_left != False:
+        params.append(
+          'right_to_left = {0:s}'.format(repr(self.right_to_left))
+        )
+    def __repr__(self):
+      params = []
+      self.repr_serialize(params)
+      return 'ast.AST.ExpressionBinary({0:s})'.format(', '.join(params))
+    # GENERATE END
+    def translate_expression(self, context, precedence):
+      text = '{0:s}{1:s}{2:s}'.format(
+        self[0].translate_expression(
+          context,
+          self.precedence + int(self.right_to_left)
+        ),
+        self.binary_operator,
+        self[1].translate_expression(
+          context,
+          self.precedence + int(not self.right_to_left)
+        )
+      )
+      if self.precedence < precedence:
+        text = '({0:s})'.format(text)
+      return text
 
   # type analysis
   class Type(element.Element):
@@ -259,6 +365,7 @@ class AST(element.Element):
       return 'ast.AST.Type({0:s})'.format(', '.join(params))
     # GENERATE END
     def translate_zero(self, context):
+      print(self)
       raise NotImplementedError
 
   class TypeVoid(Type):
@@ -700,7 +807,7 @@ class AST(element.Element):
       )
 
   # syntax classes
-  class AlignAsExpression(Element):
+  class AlignAsExpression(element.Element):
     # GENERATE ELEMENT() BEGIN
     def __init__(
       self,
@@ -709,7 +816,7 @@ class AST(element.Element):
       text = '',
       children = []
     ):
-      AST.Element.__init__(
+      element.Element.__init__(
         self,
         tag,
         attrib,
@@ -717,7 +824,7 @@ class AST(element.Element):
         children
       )
     def copy(self, factory = None):
-      result = AST.Element.copy(
+      result = element.Element.copy(
         self,
         AlignAsExpression if factory is None else factory
       )
@@ -728,7 +835,7 @@ class AST(element.Element):
       return 'ast.AST.AlignAsExpression({0:s})'.format(', '.join(params))
     # GENERATE END
 
-  class AlignAsType(Element):
+  class AlignAsType(element.Element):
     # GENERATE ELEMENT() BEGIN
     def __init__(
       self,
@@ -737,7 +844,7 @@ class AST(element.Element):
       text = '',
       children = []
     ):
-      AST.Element.__init__(
+      element.Element.__init__(
         self,
         tag,
         attrib,
@@ -745,7 +852,7 @@ class AST(element.Element):
         children
       )
     def copy(self, factory = None):
-      result = AST.Element.copy(
+      result = element.Element.copy(
         self,
         AlignAsType if factory is None else factory
       )
@@ -756,7 +863,7 @@ class AST(element.Element):
       return 'ast.AST.AlignAsType({0:s})'.format(', '.join(params))
     # GENERATE END
 
-  class ArgumentExpressionList(Element):
+  class ArgumentExpressionList(element.Element):
     # GENERATE ELEMENT() BEGIN
     def __init__(
       self,
@@ -765,7 +872,7 @@ class AST(element.Element):
       text = '',
       children = []
     ):
-      AST.Element.__init__(
+      element.Element.__init__(
         self,
         tag,
         attrib,
@@ -773,7 +880,7 @@ class AST(element.Element):
         children
       )
     def copy(self, factory = None):
-      result = AST.Element.copy(
+      result = element.Element.copy(
         self,
         ArgumentExpressionList if factory is None else factory
       )
@@ -784,7 +891,7 @@ class AST(element.Element):
       return 'ast.AST.ArgumentExpressionList({0:s})'.format(', '.join(params))
     # GENERATE END
 
-  class BlockItemList(Element):
+  class BlockItemList(element.Element):
     # GENERATE ELEMENT() BEGIN
     def __init__(
       self,
@@ -793,7 +900,7 @@ class AST(element.Element):
       text = '',
       children = []
     ):
-      AST.Element.__init__(
+      element.Element.__init__(
         self,
         tag,
         attrib,
@@ -801,7 +908,7 @@ class AST(element.Element):
         children
       )
     def copy(self, factory = None):
-      result = AST.Element.copy(
+      result = element.Element.copy(
         self,
         BlockItemList if factory is None else factory
       )
@@ -853,12 +960,12 @@ class AST(element.Element):
             (
               type.translate_zero(context)
             if isinstance(i[1], AST.EqualsInitializerEmpty) else
-              i[1].translate_expression(context)
+              i[1].translate_expression(context, 0)
             )
           )
         )
 
-  class DeclarationList(Element):
+  class DeclarationList(element.Element):
     # GENERATE ELEMENT() BEGIN
     def __init__(
       self,
@@ -867,7 +974,7 @@ class AST(element.Element):
       text = '',
       children = []
     ):
-      AST.Element.__init__(
+      element.Element.__init__(
         self,
         tag,
         attrib,
@@ -875,7 +982,7 @@ class AST(element.Element):
         children
       )
     def copy(self, factory = None):
-      result = AST.Element.copy(
+      result = element.Element.copy(
         self,
         DeclarationList if factory is None else factory
       )
@@ -1165,7 +1272,7 @@ class AST(element.Element):
         AST.TypePointer(target_type = base_type)
       )
 
-  class DefaultTypeName(Element):
+  class DefaultTypeName(element.Element):
     # GENERATE ELEMENT() BEGIN
     def __init__(
       self,
@@ -1174,7 +1281,7 @@ class AST(element.Element):
       text = '',
       children = []
     ):
-      AST.Element.__init__(
+      element.Element.__init__(
         self,
         tag,
         attrib,
@@ -1182,7 +1289,7 @@ class AST(element.Element):
         children
       )
     def copy(self, factory = None):
-      result = AST.Element.copy(
+      result = element.Element.copy(
         self,
         DefaultTypeName if factory is None else factory
       )
@@ -1193,7 +1300,7 @@ class AST(element.Element):
       return 'ast.AST.DefaultTypeName({0:s})'.format(', '.join(params))
     # GENERATE END
 
-  class DesignatorField(Element):
+  class DesignatorField(element.Element):
     # GENERATE ELEMENT() BEGIN
     def __init__(
       self,
@@ -1202,7 +1309,7 @@ class AST(element.Element):
       text = '',
       children = []
     ):
-      AST.Element.__init__(
+      element.Element.__init__(
         self,
         tag,
         attrib,
@@ -1210,7 +1317,7 @@ class AST(element.Element):
         children
       )
     def copy(self, factory = None):
-      result = AST.Element.copy(
+      result = element.Element.copy(
         self,
         DesignatorField if factory is None else factory
       )
@@ -1221,7 +1328,7 @@ class AST(element.Element):
       return 'ast.AST.DesignatorField({0:s})'.format(', '.join(params))
     # GENERATE END
 
-  class DesignatorIndex(Element):
+  class DesignatorIndex(element.Element):
     # GENERATE ELEMENT() BEGIN
     def __init__(
       self,
@@ -1230,7 +1337,7 @@ class AST(element.Element):
       text = '',
       children = []
     ):
-      AST.Element.__init__(
+      element.Element.__init__(
         self,
         tag,
         attrib,
@@ -1238,7 +1345,7 @@ class AST(element.Element):
         children
       )
     def copy(self, factory = None):
-      result = AST.Element.copy(
+      result = element.Element.copy(
         self,
         DesignatorIndex if factory is None else factory
       )
@@ -1249,7 +1356,7 @@ class AST(element.Element):
       return 'ast.AST.DesignatorIndex({0:s})'.format(', '.join(params))
     # GENERATE END
 
-  class DesignatorInitializer(Element):
+  class DesignatorInitializer(element.Element):
     # GENERATE ELEMENT() BEGIN
     def __init__(
       self,
@@ -1258,7 +1365,7 @@ class AST(element.Element):
       text = '',
       children = []
     ):
-      AST.Element.__init__(
+      element.Element.__init__(
         self,
         tag,
         attrib,
@@ -1266,7 +1373,7 @@ class AST(element.Element):
         children
       )
     def copy(self, factory = None):
-      result = AST.Element.copy(
+      result = element.Element.copy(
         self,
         DesignatorInitializer if factory is None else factory
       )
@@ -1277,7 +1384,7 @@ class AST(element.Element):
       return 'ast.AST.DesignatorInitializer({0:s})'.format(', '.join(params))
     # GENERATE END
 
-  class DesignatorInitializerList(Element):
+  class DesignatorInitializerList(element.Element):
     # GENERATE ELEMENT() BEGIN
     def __init__(
       self,
@@ -1286,7 +1393,7 @@ class AST(element.Element):
       text = '',
       children = []
     ):
-      AST.Element.__init__(
+      element.Element.__init__(
         self,
         tag,
         attrib,
@@ -1294,7 +1401,7 @@ class AST(element.Element):
         children
       )
     def copy(self, factory = None):
-      result = AST.Element.copy(
+      result = element.Element.copy(
         self,
         DesignatorInitializerList if factory is None else factory
       )
@@ -1305,7 +1412,7 @@ class AST(element.Element):
       return 'ast.AST.DesignatorInitializerList({0:s})'.format(', '.join(params))
     # GENERATE END
 
-  class DesignatorList(Element):
+  class DesignatorList(element.Element):
     # GENERATE ELEMENT() BEGIN
     def __init__(
       self,
@@ -1314,7 +1421,7 @@ class AST(element.Element):
       text = '',
       children = []
     ):
-      AST.Element.__init__(
+      element.Element.__init__(
         self,
         tag,
         attrib,
@@ -1322,7 +1429,7 @@ class AST(element.Element):
         children
       )
     def copy(self, factory = None):
-      result = AST.Element.copy(
+      result = element.Element.copy(
         self,
         DesignatorList if factory is None else factory
       )
@@ -1333,7 +1440,7 @@ class AST(element.Element):
       return 'ast.AST.DesignatorList({0:s})'.format(', '.join(params))
     # GENERATE END
 
-  class EnumSpecifier(Element):
+  class EnumSpecifier(element.Element):
     # GENERATE ELEMENT() BEGIN
     def __init__(
       self,
@@ -1342,7 +1449,7 @@ class AST(element.Element):
       text = '',
       children = []
     ):
-      AST.Element.__init__(
+      element.Element.__init__(
         self,
         tag,
         attrib,
@@ -1350,7 +1457,7 @@ class AST(element.Element):
         children
       )
     def copy(self, factory = None):
-      result = AST.Element.copy(
+      result = element.Element.copy(
         self,
         EnumSpecifier if factory is None else factory
       )
@@ -1361,7 +1468,7 @@ class AST(element.Element):
       return 'ast.AST.EnumSpecifier({0:s})'.format(', '.join(params))
     # GENERATE END
 
-  class Enumerator(Element):
+  class Enumerator(element.Element):
     # GENERATE ELEMENT() BEGIN
     def __init__(
       self,
@@ -1370,7 +1477,7 @@ class AST(element.Element):
       text = '',
       children = []
     ):
-      AST.Element.__init__(
+      element.Element.__init__(
         self,
         tag,
         attrib,
@@ -1378,7 +1485,7 @@ class AST(element.Element):
         children
       )
     def copy(self, factory = None):
-      result = AST.Element.copy(
+      result = element.Element.copy(
         self,
         Enumerator if factory is None else factory
       )
@@ -1389,7 +1496,7 @@ class AST(element.Element):
       return 'ast.AST.Enumerator({0:s})'.format(', '.join(params))
     # GENERATE END
 
-  class EnumeratorList(Element):
+  class EnumeratorList(element.Element):
     # GENERATE ELEMENT() BEGIN
     def __init__(
       self,
@@ -1398,7 +1505,7 @@ class AST(element.Element):
       text = '',
       children = []
     ):
-      AST.Element.__init__(
+      element.Element.__init__(
         self,
         tag,
         attrib,
@@ -1406,7 +1513,7 @@ class AST(element.Element):
         children
       )
     def copy(self, factory = None):
-      result = AST.Element.copy(
+      result = element.Element.copy(
         self,
         EnumeratorList if factory is None else factory
       )
@@ -1417,7 +1524,7 @@ class AST(element.Element):
       return 'ast.AST.EnumeratorList({0:s})'.format(', '.join(params))
     # GENERATE END
 
-  class EqualsInitializerEmpty(Element):
+  class EqualsInitializerEmpty(element.Element):
     # GENERATE ELEMENT() BEGIN
     def __init__(
       self,
@@ -1426,7 +1533,7 @@ class AST(element.Element):
       text = '',
       children = []
     ):
-      AST.Element.__init__(
+      element.Element.__init__(
         self,
         tag,
         attrib,
@@ -1434,7 +1541,7 @@ class AST(element.Element):
         children
       )
     def copy(self, factory = None):
-      result = AST.Element.copy(
+      result = element.Element.copy(
         self,
         EqualsInitializerEmpty if factory is None else factory
       )
@@ -1445,24 +1552,30 @@ class AST(element.Element):
       return 'ast.AST.EqualsInitializerEmpty({0:s})'.format(', '.join(params))
     # GENERATE END
 
-  class ExpressionAdd(Expression):
+  class ExpressionAdd(ExpressionBinary):
     # GENERATE ELEMENT() BEGIN
     def __init__(
       self,
       tag = 'AST_ExpressionAdd',
       attrib = {},
       text = '',
-      children = []
+      children = [],
+      binary_operator = '',
+      precedence = -1,
+      right_to_left = False
     ):
-      AST.Expression.__init__(
+      AST.ExpressionBinary.__init__(
         self,
         tag,
         attrib,
         text,
-        children
+        children,
+        binary_operator,
+        precedence,
+        right_to_left
       )
     def copy(self, factory = None):
-      result = AST.Expression.copy(
+      result = AST.ExpressionBinary.copy(
         self,
         ExpressionAdd if factory is None else factory
       )
@@ -1473,24 +1586,30 @@ class AST(element.Element):
       return 'ast.AST.ExpressionAdd({0:s})'.format(', '.join(params))
     # GENERATE END
 
-  class ExpressionAddAssignment(Expression):
+  class ExpressionAddAssignment(ExpressionBinary):
     # GENERATE ELEMENT() BEGIN
     def __init__(
       self,
       tag = 'AST_ExpressionAddAssignment',
       attrib = {},
       text = '',
-      children = []
+      children = [],
+      binary_operator = '',
+      precedence = -1,
+      right_to_left = False
     ):
-      AST.Expression.__init__(
+      AST.ExpressionBinary.__init__(
         self,
         tag,
         attrib,
         text,
-        children
+        children,
+        binary_operator,
+        precedence,
+        right_to_left
       )
     def copy(self, factory = None):
-      result = AST.Expression.copy(
+      result = AST.ExpressionBinary.copy(
         self,
         ExpressionAddAssignment if factory is None else factory
       )
@@ -1501,24 +1620,28 @@ class AST(element.Element):
       return 'ast.AST.ExpressionAddAssignment({0:s})'.format(', '.join(params))
     # GENERATE END
 
-  class ExpressionAddressOf(Expression):
+  class ExpressionAddressOf(ExpressionUnary):
     # GENERATE ELEMENT() BEGIN
     def __init__(
       self,
       tag = 'AST_ExpressionAddressOf',
       attrib = {},
       text = '',
-      children = []
+      children = [],
+      unary_operator = '',
+      postfix = False
     ):
-      AST.Expression.__init__(
+      AST.ExpressionUnary.__init__(
         self,
         tag,
         attrib,
         text,
-        children
+        children,
+        unary_operator,
+        postfix
       )
     def copy(self, factory = None):
-      result = AST.Expression.copy(
+      result = AST.ExpressionUnary.copy(
         self,
         ExpressionAddressOf if factory is None else factory
       )
@@ -1528,30 +1651,29 @@ class AST(element.Element):
       self.repr_serialize(params)
       return 'ast.AST.ExpressionAddressOf({0:s})'.format(', '.join(params))
     # GENERATE END
-    def translate(self, context):
-      assert len(self) == 1
-      self[0].translate(context)
-      element.set_text(self, 0, '&')
-      element.set_text(self, 1, '')
 
-  class ExpressionAlignOfType(Expression):
+  class ExpressionAlignOfType(ExpressionUnary):
     # GENERATE ELEMENT() BEGIN
     def __init__(
       self,
       tag = 'AST_ExpressionAlignOfType',
       attrib = {},
       text = '',
-      children = []
+      children = [],
+      unary_operator = '',
+      postfix = False
     ):
-      AST.Expression.__init__(
+      AST.ExpressionUnary.__init__(
         self,
         tag,
         attrib,
         text,
-        children
+        children,
+        unary_operator,
+        postfix
       )
     def copy(self, factory = None):
-      result = AST.Expression.copy(
+      result = AST.ExpressionUnary.copy(
         self,
         ExpressionAlignOfType if factory is None else factory
       )
@@ -1590,24 +1712,30 @@ class AST(element.Element):
       return 'ast.AST.ExpressionArray({0:s})'.format(', '.join(params))
     # GENERATE END
 
-  class ExpressionAssignment(Expression):
+  class ExpressionAssignment(ExpressionBinary):
     # GENERATE ELEMENT() BEGIN
     def __init__(
       self,
       tag = 'AST_ExpressionAssignment',
       attrib = {},
       text = '',
-      children = []
+      children = [],
+      binary_operator = '',
+      precedence = -1,
+      right_to_left = False
     ):
-      AST.Expression.__init__(
+      AST.ExpressionBinary.__init__(
         self,
         tag,
         attrib,
         text,
-        children
+        children,
+        binary_operator,
+        precedence,
+        right_to_left
       )
     def copy(self, factory = None):
-      result = AST.Expression.copy(
+      result = AST.ExpressionBinary.copy(
         self,
         ExpressionAssignment if factory is None else factory
       )
@@ -1646,24 +1774,30 @@ class AST(element.Element):
       return 'ast.AST.ExpressionAsterisk({0:s})'.format(', '.join(params))
     # GENERATE END
 
-  class ExpressionBitwiseAnd(Expression):
+  class ExpressionBitwiseAnd(ExpressionBinary):
     # GENERATE ELEMENT() BEGIN
     def __init__(
       self,
       tag = 'AST_ExpressionBitwiseAnd',
       attrib = {},
       text = '',
-      children = []
+      children = [],
+      binary_operator = '',
+      precedence = -1,
+      right_to_left = False
     ):
-      AST.Expression.__init__(
+      AST.ExpressionBinary.__init__(
         self,
         tag,
         attrib,
         text,
-        children
+        children,
+        binary_operator,
+        precedence,
+        right_to_left
       )
     def copy(self, factory = None):
-      result = AST.Expression.copy(
+      result = AST.ExpressionBinary.copy(
         self,
         ExpressionBitwiseAnd if factory is None else factory
       )
@@ -1674,24 +1808,30 @@ class AST(element.Element):
       return 'ast.AST.ExpressionBitwiseAnd({0:s})'.format(', '.join(params))
     # GENERATE END
 
-  class ExpressionBitwiseAndAssignment(Expression):
+  class ExpressionBitwiseAndAssignment(ExpressionBinary):
     # GENERATE ELEMENT() BEGIN
     def __init__(
       self,
       tag = 'AST_ExpressionBitwiseAndAssignment',
       attrib = {},
       text = '',
-      children = []
+      children = [],
+      binary_operator = '',
+      precedence = -1,
+      right_to_left = False
     ):
-      AST.Expression.__init__(
+      AST.ExpressionBinary.__init__(
         self,
         tag,
         attrib,
         text,
-        children
+        children,
+        binary_operator,
+        precedence,
+        right_to_left
       )
     def copy(self, factory = None):
-      result = AST.Expression.copy(
+      result = AST.ExpressionBinary.copy(
         self,
         ExpressionBitwiseAndAssignment if factory is None else factory
       )
@@ -1702,24 +1842,28 @@ class AST(element.Element):
       return 'ast.AST.ExpressionBitwiseAndAssignment({0:s})'.format(', '.join(params))
     # GENERATE END
 
-  class ExpressionBitwiseNot(Expression):
+  class ExpressionBitwiseNot(ExpressionUnary):
     # GENERATE ELEMENT() BEGIN
     def __init__(
       self,
       tag = 'AST_ExpressionBitwiseNot',
       attrib = {},
       text = '',
-      children = []
+      children = [],
+      unary_operator = '',
+      postfix = False
     ):
-      AST.Expression.__init__(
+      AST.ExpressionUnary.__init__(
         self,
         tag,
         attrib,
         text,
-        children
+        children,
+        unary_operator,
+        postfix
       )
     def copy(self, factory = None):
-      result = AST.Expression.copy(
+      result = AST.ExpressionUnary.copy(
         self,
         ExpressionBitwiseNot if factory is None else factory
       )
@@ -1729,30 +1873,31 @@ class AST(element.Element):
       self.repr_serialize(params)
       return 'ast.AST.ExpressionBitwiseNot({0:s})'.format(', '.join(params))
     # GENERATE END
-    def translate(self, context):
-      assert len(self) == 1
-      self[0].translate(context)
-      element.set_text(self, 0, '~')
-      element.set_text(self, 1, '')
 
-  class ExpressionBitwiseOr(Expression):
+  class ExpressionBitwiseOr(ExpressionBinary):
     # GENERATE ELEMENT() BEGIN
     def __init__(
       self,
       tag = 'AST_ExpressionBitwiseOr',
       attrib = {},
       text = '',
-      children = []
+      children = [],
+      binary_operator = '',
+      precedence = -1,
+      right_to_left = False
     ):
-      AST.Expression.__init__(
+      AST.ExpressionBinary.__init__(
         self,
         tag,
         attrib,
         text,
-        children
+        children,
+        binary_operator,
+        precedence,
+        right_to_left
       )
     def copy(self, factory = None):
-      result = AST.Expression.copy(
+      result = AST.ExpressionBinary.copy(
         self,
         ExpressionBitwiseOr if factory is None else factory
       )
@@ -1763,24 +1908,30 @@ class AST(element.Element):
       return 'ast.AST.ExpressionBitwiseOr({0:s})'.format(', '.join(params))
     # GENERATE END
 
-  class ExpressionBitwiseOrAssignment(Expression):
+  class ExpressionBitwiseOrAssignment(ExpressionBinary):
     # GENERATE ELEMENT() BEGIN
     def __init__(
       self,
       tag = 'AST_ExpressionBitwiseOrAssignment',
       attrib = {},
       text = '',
-      children = []
+      children = [],
+      binary_operator = '',
+      precedence = -1,
+      right_to_left = False
     ):
-      AST.Expression.__init__(
+      AST.ExpressionBinary.__init__(
         self,
         tag,
         attrib,
         text,
-        children
+        children,
+        binary_operator,
+        precedence,
+        right_to_left
       )
     def copy(self, factory = None):
-      result = AST.Expression.copy(
+      result = AST.ExpressionBinary.copy(
         self,
         ExpressionBitwiseOrAssignment if factory is None else factory
       )
@@ -1818,13 +1969,14 @@ class AST(element.Element):
       self.repr_serialize(params)
       return 'ast.AST.ExpressionCall({0:s})'.format(', '.join(params))
     # GENERATE END
-    def translate(self, context):
-      assert len(self) == 2
-      self[0].translate(context)
-      self[1].translate(context)
-      element.set_text(self, 0, '')
-      element.set_text(self, 1, '(')
-      element.set_text(self, 2, ')')
+    def translate_expression(self, context, precedence):
+      text = '{0:s}({1:s})'.format(
+        self[0].translate_expression(context, 14),
+        ', '.join([i.translate_expression(context, 1) for i in self[1]])
+      )
+      if 14 < precedence:
+        text = '({0:s})'.format(text)
+      return text
 
   class ExpressionCast(Expression):
     # GENERATE ELEMENT() BEGIN
@@ -1853,13 +2005,6 @@ class AST(element.Element):
       self.repr_serialize(params)
       return 'ast.AST.ExpressionCast({0:s})'.format(', '.join(params))
     # GENERATE END
-    def translate(self, context):
-      assert len(self) == 2
-      self[0].translate(context)
-      self[1].translate(context)
-      element.set_text(self, 0, '')
-      element.set_text(self, 1, '(')
-      element.set_text(self, 2, ')')
 
   class ExpressionCharConstant(Expression):
     # GENERATE ELEMENT() BEGIN
@@ -1888,32 +2033,33 @@ class AST(element.Element):
       self.repr_serialize(params)
       return 'ast.AST.ExpressionCharConstant({0:s})'.format(', '.join(params))
     # GENERATE END
-    def translate(self, context):
-      assert len(self) == 0
-      element.set_text(
-        self,
-        0,
-       'ord({0:s})'.format(element.get_text(self, 0).strip())
-      )
+    def translate_expression(self, context, precedence):
+      return 'ord(\'{0:s}\')'.format(element.get_text(self[0], 0))
 
-  class ExpressionComma(Expression):
+  class ExpressionComma(ExpressionBinary):
     # GENERATE ELEMENT() BEGIN
     def __init__(
       self,
       tag = 'AST_ExpressionComma',
       attrib = {},
       text = '',
-      children = []
+      children = [],
+      binary_operator = '',
+      precedence = -1,
+      right_to_left = False
     ):
-      AST.Expression.__init__(
+      AST.ExpressionBinary.__init__(
         self,
         tag,
         attrib,
         text,
-        children
+        children,
+        binary_operator,
+        precedence,
+        right_to_left
       )
     def copy(self, factory = None):
-      result = AST.Expression.copy(
+      result = AST.ExpressionBinary.copy(
         self,
         ExpressionComma if factory is None else factory
       )
@@ -1951,36 +2097,38 @@ class AST(element.Element):
       self.repr_serialize(params)
       return 'ast.AST.ExpressionConditional({0:s})'.format(', '.join(params))
     # GENERATE END
-    def translate(self, context):
-      #xml.etree.ElementTree.dump(self)
-      assert len(self) == 3
-      self[0].translate(context)
-      self[1].translate(context)
-      self[2].translate(context)
-      self[0], self[1] = self[1], self[0]
-      element.set_text(self, 0, '')
-      element.set_text(self, 1, ' if ')
-      element.set_text(self, 2, ' else ')
-      element.set_text(self, 3, '')
-
-  class ExpressionDereference(Expression):
+    def translate_expression(self, context, precedence):
+      text = '{0:s} if {1:s} else {2:s}'.format(
+        self[1].translate_expression(context, 3),
+        self[0].translate_expression(context, 0),
+        self[2].translate_expression(context, 2)
+      )
+      if 2 < precedence:
+        text = '({0:s})'.format(text)
+      return text
+
+  class ExpressionDereference(ExpressionUnary):
     # GENERATE ELEMENT() BEGIN
     def __init__(
       self,
       tag = 'AST_ExpressionDereference',
       attrib = {},
       text = '',
-      children = []
+      children = [],
+      unary_operator = '',
+      postfix = False
     ):
-      AST.Expression.__init__(
+      AST.ExpressionUnary.__init__(
         self,
         tag,
         attrib,
         text,
-        children
+        children,
+        unary_operator,
+        postfix
       )
     def copy(self, factory = None):
-      result = AST.Expression.copy(
+      result = AST.ExpressionUnary.copy(
         self,
         ExpressionDereference if factory is None else factory
       )
@@ -1990,30 +2138,31 @@ class AST(element.Element):
       self.repr_serialize(params)
       return 'ast.AST.ExpressionDereference({0:s})'.format(', '.join(params))
     # GENERATE END
-    def translate(self, context):
-      assert len(self) == 1
-      self[0].translate(context)
-      element.set_text(self, 0, '*')
-      element.set_text(self, 1, '')
 
-  class ExpressionDivide(Expression):
+  class ExpressionDivide(ExpressionBinary):
     # GENERATE ELEMENT() BEGIN
     def __init__(
       self,
       tag = 'AST_ExpressionDivide',
       attrib = {},
       text = '',
-      children = []
+      children = [],
+      binary_operator = '',
+      precedence = -1,
+      right_to_left = False
     ):
-      AST.Expression.__init__(
+      AST.ExpressionBinary.__init__(
         self,
         tag,
         attrib,
         text,
-        children
+        children,
+        binary_operator,
+        precedence,
+        right_to_left
       )
     def copy(self, factory = None):
-      result = AST.Expression.copy(
+      result = AST.ExpressionBinary.copy(
         self,
         ExpressionDivide if factory is None else factory
       )
@@ -2024,24 +2173,30 @@ class AST(element.Element):
       return 'ast.AST.ExpressionDivide({0:s})'.format(', '.join(params))
     # GENERATE END
 
-  class ExpressionDivideAssignment(Expression):
+  class ExpressionDivideAssignment(ExpressionBinary):
     # GENERATE ELEMENT() BEGIN
     def __init__(
       self,
       tag = 'AST_ExpressionDivideAssignment',
       attrib = {},
       text = '',
-      children = []
+      children = [],
+      binary_operator = '',
+      precedence = -1,
+      right_to_left = False
     ):
-      AST.Expression.__init__(
+      AST.ExpressionBinary.__init__(
         self,
         tag,
         attrib,
         text,
-        children
+        children,
+        binary_operator,
+        precedence,
+        right_to_left
       )
     def copy(self, factory = None):
-      result = AST.Expression.copy(
+      result = AST.ExpressionBinary.copy(
         self,
         ExpressionDivideAssignment if factory is None else factory
       )
@@ -2079,25 +2234,35 @@ class AST(element.Element):
       self.repr_serialize(params)
       return 'ast.AST.ExpressionEmpty({0:s})'.format(', '.join(params))
     # GENERATE END
+    def translate_expression(self, context, precedence):
+      return 'True'
+    def translate_statement_expression(self, context):
+      return 'pass'
 
-  class ExpressionEqual(Expression):
+  class ExpressionEqual(ExpressionBinary):
     # GENERATE ELEMENT() BEGIN
     def __init__(
       self,
       tag = 'AST_ExpressionEqual',
       attrib = {},
       text = '',
-      children = []
+      children = [],
+      binary_operator = '',
+      precedence = -1,
+      right_to_left = False
     ):
-      AST.Expression.__init__(
+      AST.ExpressionBinary.__init__(
         self,
         tag,
         attrib,
         text,
-        children
+        children,
+        binary_operator,
+        precedence,
+        right_to_left
       )
     def copy(self, factory = None):
-      result = AST.Expression.copy(
+      result = AST.ExpressionBinary.copy(
         self,
         ExpressionEqual if factory is None else factory
       )
@@ -2108,24 +2273,30 @@ class AST(element.Element):
       return 'ast.AST.ExpressionEqual({0:s})'.format(', '.join(params))
     # GENERATE END
 
-  class ExpressionExclusiveOr(Expression):
+  class ExpressionExclusiveOr(ExpressionBinary):
     # GENERATE ELEMENT() BEGIN
     def __init__(
       self,
       tag = 'AST_ExpressionExclusiveOr',
       attrib = {},
       text = '',
-      children = []
+      children = [],
+      binary_operator = '',
+      precedence = -1,
+      right_to_left = False
     ):
-      AST.Expression.__init__(
+      AST.ExpressionBinary.__init__(
         self,
         tag,
         attrib,
         text,
-        children
+        children,
+        binary_operator,
+        precedence,
+        right_to_left
       )
     def copy(self, factory = None):
-      result = AST.Expression.copy(
+      result = AST.ExpressionBinary.copy(
         self,
         ExpressionExclusiveOr if factory is None else factory
       )
@@ -2136,24 +2307,30 @@ class AST(element.Element):
       return 'ast.AST.ExpressionExclusiveOr({0:s})'.format(', '.join(params))
     # GENERATE END
 
-  class ExpressionExclusiveOrAssignment(Expression):
+  class ExpressionExclusiveOrAssignment(ExpressionBinary):
     # GENERATE ELEMENT() BEGIN
     def __init__(
       self,
       tag = 'AST_ExpressionExclusiveOrAssignment',
       attrib = {},
       text = '',
-      children = []
+      children = [],
+      binary_operator = '',
+      precedence = -1,
+      right_to_left = False
     ):
-      AST.Expression.__init__(
+      AST.ExpressionBinary.__init__(
         self,
         tag,
         attrib,
         text,
-        children
+        children,
+        binary_operator,
+        precedence,
+        right_to_left
       )
     def copy(self, factory = None):
-      result = AST.Expression.copy(
+      result = AST.ExpressionBinary.copy(
         self,
         ExpressionExclusiveOrAssignment if factory is None else factory
       )
@@ -2191,6 +2368,14 @@ class AST(element.Element):
       self.repr_serialize(params)
       return 'ast.AST.ExpressionField({0:s})'.format(', '.join(params))
     # GENERATE END
+    def translate_expression(self, context, precedence):
+      text = '{0:s}.{1:s}'.format(
+        self[0].translate_expression(context, 14),
+        element.get_text(self[1], 0)
+      )
+      if 14 < precedence:
+        text = '({0:s})'.format(text)
+      return text
 
   class ExpressionFieldDereference(Expression):
     # GENERATE ELEMENT() BEGIN
@@ -2219,6 +2404,14 @@ class AST(element.Element):
       self.repr_serialize(params)
       return 'ast.AST.ExpressionFieldDereference({0:s})'.format(', '.join(params))
     # GENERATE END
+    def translate_expression(self, context, precedence):
+      text = '{0:s}->{1:s}'.format(
+        self[0].translate_expression(context, 14),
+        element.get_text(self[1], 0)
+      )
+      if 14 < precedence:
+        text = '({0:s})'.format(text)
+      return text
 
   class ExpressionFloatLiteral(Expression):
     # GENERATE ELEMENT() BEGIN
@@ -2276,24 +2469,30 @@ class AST(element.Element):
       return 'ast.AST.ExpressionFunctionName({0:s})'.format(', '.join(params))
     # GENERATE END
 
-  class ExpressionGreaterThan(Expression):
+  class ExpressionGreaterThan(ExpressionBinary):
     # GENERATE ELEMENT() BEGIN
     def __init__(
       self,
       tag = 'AST_ExpressionGreaterThan',
       attrib = {},
       text = '',
-      children = []
+      children = [],
+      binary_operator = '',
+      precedence = -1,
+      right_to_left = False
     ):
-      AST.Expression.__init__(
+      AST.ExpressionBinary.__init__(
         self,
         tag,
         attrib,
         text,
-        children
+        children,
+        binary_operator,
+        precedence,
+        right_to_left
       )
     def copy(self, factory = None):
-      result = AST.Expression.copy(
+      result = AST.ExpressionBinary.copy(
         self,
         ExpressionGreaterThan if factory is None else factory
       )
@@ -2304,24 +2503,30 @@ class AST(element.Element):
       return 'ast.AST.ExpressionGreaterThan({0:s})'.format(', '.join(params))
     # GENERATE END
 
-  class ExpressionGreaterThanOrEqual(Expression):
+  class ExpressionGreaterThanOrEqual(ExpressionBinary):
     # GENERATE ELEMENT() BEGIN
     def __init__(
       self,
       tag = 'AST_ExpressionGreaterThanOrEqual',
       attrib = {},
       text = '',
-      children = []
+      children = [],
+      binary_operator = '',
+      precedence = -1,
+      right_to_left = False
     ):
-      AST.Expression.__init__(
+      AST.ExpressionBinary.__init__(
         self,
         tag,
         attrib,
         text,
-        children
+        children,
+        binary_operator,
+        precedence,
+        right_to_left
       )
     def copy(self, factory = None):
-      result = AST.Expression.copy(
+      result = AST.ExpressionBinary.copy(
         self,
         ExpressionGreaterThanOrEqual if factory is None else factory
       )
@@ -2359,6 +2564,8 @@ class AST(element.Element):
       self.repr_serialize(params)
       return 'ast.AST.ExpressionIdentifier({0:s})'.format(', '.join(params))
     # GENERATE END
+    def translate_expression(self, context, precedence):
+      return element.get_text(self[0], 0)
 
   class ExpressionIndex(Expression):
     # GENERATE ELEMENT() BEGIN
@@ -2387,13 +2594,14 @@ class AST(element.Element):
       self.repr_serialize(params)
       return 'ast.AST.ExpressionIndex({0:s})'.format(', '.join(params))
     # GENERATE END
-    def translate(self, context):
-      assert len(self) == 2
-      self[0].translate(context)
-      self[1].translate(context)
-      element.set_text(self, 0, '')
-      element.set_text(self, 1, '[')
-      element.set_text(self, 2, ']')
+    def translate_expression(self, context, precedence):
+      text = '{0:s}[{1:s}]'.format(
+        self[0].translate_expression(context, 14),
+        self[1].translate_expression(context, 0)
+      )
+      if 14 < precedence:
+        text = '({0:s})'.format(text)
+      return text
 
   class ExpressionIntLiteral(Expression):
     # GENERATE ELEMENT() BEGIN
@@ -2422,8 +2630,13 @@ class AST(element.Element):
       self.repr_serialize(params)
       return 'ast.AST.ExpressionIntLiteral({0:s})'.format(', '.join(params))
     # GENERATE END
+    def translate_expression(self, context, precedence):
+      text = element.get_text(self, 0)
+      if text[:2] in octal_prefix:
+        text = '0o' + text[1:]
+      return text
 
-  class Identifier(Element):
+  class Identifier(element.Element):
     # GENERATE ELEMENT() BEGIN
     def __init__(
       self,
@@ -2432,7 +2645,7 @@ class AST(element.Element):
       text = '',
       children = []
     ):
-      AST.Element.__init__(
+      element.Element.__init__(
         self,
         tag,
         attrib,
@@ -2440,7 +2653,7 @@ class AST(element.Element):
         children
       )
     def copy(self, factory = None):
-      result = AST.Element.copy(
+      result = element.Element.copy(
         self,
         Identifier if factory is None else factory
       )
@@ -2450,33 +2663,31 @@ class AST(element.Element):
       self.repr_serialize(params)
       return 'ast.AST.Identifier({0:s})'.format(', '.join(params))
     # GENERATE END
-    def translate(self, context):
-      assert len(self) == 0
-      text = element.get_text(self, 0)
-      element.set_text(
-        self,
-        0,
-        context.translate_identifier.get(text, text)
-      )
 
-  class ExpressionLeftShiftAssignment(Expression):
+  class ExpressionLeftShiftAssignment(ExpressionBinary):
     # GENERATE ELEMENT() BEGIN
     def __init__(
       self,
       tag = 'AST_ExpressionLeftShiftAssignment',
       attrib = {},
       text = '',
-      children = []
+      children = [],
+      binary_operator = '',
+      precedence = -1,
+      right_to_left = False
     ):
-      AST.Expression.__init__(
+      AST.ExpressionBinary.__init__(
         self,
         tag,
         attrib,
         text,
-        children
+        children,
+        binary_operator,
+        precedence,
+        right_to_left
       )
     def copy(self, factory = None):
-      result = AST.Expression.copy(
+      result = AST.ExpressionBinary.copy(
         self,
         ExpressionLeftShiftAssignment if factory is None else factory
       )
@@ -2487,24 +2698,30 @@ class AST(element.Element):
       return 'ast.AST.ExpressionLeftShiftAssignment({0:s})'.format(', '.join(params))
     # GENERATE END
 
-  class ExpressionLessThan(Expression):
+  class ExpressionLessThan(ExpressionBinary):
     # GENERATE ELEMENT() BEGIN
     def __init__(
       self,
       tag = 'AST_ExpressionLessThan',
       attrib = {},
       text = '',
-      children = []
+      children = [],
+      binary_operator = '',
+      precedence = -1,
+      right_to_left = False
     ):
-      AST.Expression.__init__(
+      AST.ExpressionBinary.__init__(
         self,
         tag,
         attrib,
         text,
-        children
+        children,
+        binary_operator,
+        precedence,
+        right_to_left
       )
     def copy(self, factory = None):
-      result = AST.Expression.copy(
+      result = AST.ExpressionBinary.copy(
         self,
         ExpressionLessThan if factory is None else factory
       )
@@ -2515,24 +2732,30 @@ class AST(element.Element):
       return 'ast.AST.ExpressionLessThan({0:s})'.format(', '.join(params))
     # GENERATE END
 
-  class ExpressionLessThanOrEqual(Expression):
+  class ExpressionLessThanOrEqual(ExpressionBinary):
     # GENERATE ELEMENT() BEGIN
     def __init__(
       self,
       tag = 'AST_ExpressionLessThanOrEqual',
       attrib = {},
       text = '',
-      children = []
+      children = [],
+      binary_operator = '',
+      precedence = -1,
+      right_to_left = False
     ):
-      AST.Expression.__init__(
+      AST.ExpressionBinary.__init__(
         self,
         tag,
         attrib,
         text,
-        children
+        children,
+        binary_operator,
+        precedence,
+        right_to_left
       )
     def copy(self, factory = None):
-      result = AST.Expression.copy(
+      result = AST.ExpressionBinary.copy(
         self,
         ExpressionLessThanOrEqual if factory is None else factory
       )
@@ -2543,24 +2766,30 @@ class AST(element.Element):
       return 'ast.AST.ExpressionLessThanOrEqual({0:s})'.format(', '.join(params))
     # GENERATE END
 
-  class ExpressionLogicalAnd(Expression):
+  class ExpressionLogicalAnd(ExpressionBinary):
     # GENERATE ELEMENT() BEGIN
     def __init__(
       self,
       tag = 'AST_ExpressionLogicalAnd',
       attrib = {},
       text = '',
-      children = []
+      children = [],
+      binary_operator = '',
+      precedence = -1,
+      right_to_left = False
     ):
-      AST.Expression.__init__(
+      AST.ExpressionBinary.__init__(
         self,
         tag,
         attrib,
         text,
-        children
+        children,
+        binary_operator,
+        precedence,
+        right_to_left
       )
     def copy(self, factory = None):
-      result = AST.Expression.copy(
+      result = AST.ExpressionBinary.copy(
         self,
         ExpressionLogicalAnd if factory is None else factory
       )
@@ -2570,32 +2799,29 @@ class AST(element.Element):
       self.repr_serialize(params)
       return 'ast.AST.ExpressionLogicalAnd({0:s})'.format(', '.join(params))
     # GENERATE END
-    def translate(self, context):
-      assert len(self) == 2
-      self[0].translate(context)
-      self[1].translate(context)
-      element.set_text(self, 0, '')
-      element.set_text(self, 1, ' and ')
-      element.set_text(self, 2, '')
 
-  class ExpressionLogicalNot(Expression):
+  class ExpressionLogicalNot(ExpressionUnary):
     # GENERATE ELEMENT() BEGIN
     def __init__(
       self,
       tag = 'AST_ExpressionLogicalNot',
       attrib = {},
       text = '',
-      children = []
+      children = [],
+      unary_operator = '',
+      postfix = False
     ):
-      AST.Expression.__init__(
+      AST.ExpressionUnary.__init__(
         self,
         tag,
         attrib,
         text,
-        children
+        children,
+        unary_operator,
+        postfix
       )
     def copy(self, factory = None):
-      result = AST.Expression.copy(
+      result = AST.ExpressionUnary.copy(
         self,
         ExpressionLogicalNot if factory is None else factory
       )
@@ -2605,30 +2831,31 @@ class AST(element.Element):
       self.repr_serialize(params)
       return 'ast.AST.ExpressionLogicalNot({0:s})'.format(', '.join(params))
     # GENERATE END
-    def translate(self, context):
-      assert len(self) == 1
-      self[0].translate(context)
-      element.set_text(self, 0, 'not ')
-      element.set_text(self, 1, '')
 
-  class ExpressionLogicalOr(Expression):
+  class ExpressionLogicalOr(ExpressionBinary):
     # GENERATE ELEMENT() BEGIN
     def __init__(
       self,
       tag = 'AST_ExpressionLogicalOr',
       attrib = {},
       text = '',
-      children = []
+      children = [],
+      binary_operator = '',
+      precedence = -1,
+      right_to_left = False
     ):
-      AST.Expression.__init__(
+      AST.ExpressionBinary.__init__(
         self,
         tag,
         attrib,
         text,
-        children
+        children,
+        binary_operator,
+        precedence,
+        right_to_left
       )
     def copy(self, factory = None):
-      result = AST.Expression.copy(
+      result = AST.ExpressionBinary.copy(
         self,
         ExpressionLogicalOr if factory is None else factory
       )
@@ -2638,32 +2865,29 @@ class AST(element.Element):
       self.repr_serialize(params)
       return 'ast.AST.ExpressionLogicalOr({0:s})'.format(', '.join(params))
     # GENERATE END
-    def translate(self, context):
-      assert len(self) == 2
-      self[0].translate(context)
-      self[1].translate(context)
-      element.set_text(self, 0, '')
-      element.set_text(self, 1, ' or ')
-      element.set_text(self, 2, '')
 
-  class ExpressionMinus(Expression):
+  class ExpressionMinus(ExpressionUnary):
     # GENERATE ELEMENT() BEGIN
     def __init__(
       self,
       tag = 'AST_ExpressionMinus',
       attrib = {},
       text = '',
-      children = []
+      children = [],
+      unary_operator = '',
+      postfix = False
     ):
-      AST.Expression.__init__(
+      AST.ExpressionUnary.__init__(
         self,
         tag,
         attrib,
         text,
-        children
+        children,
+        unary_operator,
+        postfix
       )
     def copy(self, factory = None):
-      result = AST.Expression.copy(
+      result = AST.ExpressionUnary.copy(
         self,
         ExpressionMinus if factory is None else factory
       )
@@ -2673,30 +2897,31 @@ class AST(element.Element):
       self.repr_serialize(params)
       return 'ast.AST.ExpressionMinus({0:s})'.format(', '.join(params))
     # GENERATE END
-    def translate(self, context):
-      assert len(self) == 1
-      self[0].translate(context)
-      element.set_text(self, 0, '-')
-      element.set_text(self, 1, '')
 
-  class ExpressionModulo(Expression):
+  class ExpressionModulo(ExpressionBinary):
     # GENERATE ELEMENT() BEGIN
     def __init__(
       self,
       tag = 'AST_ExpressionModulo',
       attrib = {},
       text = '',
-      children = []
+      children = [],
+      binary_operator = '',
+      precedence = -1,
+      right_to_left = False
     ):
-      AST.Expression.__init__(
+      AST.ExpressionBinary.__init__(
         self,
         tag,
         attrib,
         text,
-        children
+        children,
+        binary_operator,
+        precedence,
+        right_to_left
       )
     def copy(self, factory = None):
-      result = AST.Expression.copy(
+      result = AST.ExpressionBinary.copy(
         self,
         ExpressionModulo if factory is None else factory
       )
@@ -2707,24 +2932,30 @@ class AST(element.Element):
       return 'ast.AST.ExpressionModulo({0:s})'.format(', '.join(params))
     # GENERATE END
 
-  class ExpressionModuloAssignment(Expression):
+  class ExpressionModuloAssignment(ExpressionBinary):
     # GENERATE ELEMENT() BEGIN
     def __init__(
       self,
       tag = 'AST_ExpressionModuloAssignment',
       attrib = {},
       text = '',
-      children = []
+      children = [],
+      binary_operator = '',
+      precedence = -1,
+      right_to_left = False
     ):
-      AST.Expression.__init__(
+      AST.ExpressionBinary.__init__(
         self,
         tag,
         attrib,
         text,
-        children
+        children,
+        binary_operator,
+        precedence,
+        right_to_left
       )
     def copy(self, factory = None):
-      result = AST.Expression.copy(
+      result = AST.ExpressionBinary.copy(
         self,
         ExpressionModuloAssignment if factory is None else factory
       )
@@ -2735,24 +2966,30 @@ class AST(element.Element):
       return 'ast.AST.ExpressionModuloAssignment({0:s})'.format(', '.join(params))
     # GENERATE END
 
-  class ExpressionMultiply(Expression):
+  class ExpressionMultiply(ExpressionBinary):
     # GENERATE ELEMENT() BEGIN
     def __init__(
       self,
       tag = 'AST_ExpressionMultiply',
       attrib = {},
       text = '',
-      children = []
+      children = [],
+      binary_operator = '',
+      precedence = -1,
+      right_to_left = False
     ):
-      AST.Expression.__init__(
+      AST.ExpressionBinary.__init__(
         self,
         tag,
         attrib,
         text,
-        children
+        children,
+        binary_operator,
+        precedence,
+        right_to_left
       )
     def copy(self, factory = None):
-      result = AST.Expression.copy(
+      result = AST.ExpressionBinary.copy(
         self,
         ExpressionMultiply if factory is None else factory
       )
@@ -2763,24 +3000,30 @@ class AST(element.Element):
       return 'ast.AST.ExpressionMultiply({0:s})'.format(', '.join(params))
     # GENERATE END
 
-  class ExpressionMultiplyAssignment(Expression):
+  class ExpressionMultiplyAssignment(ExpressionBinary):
     # GENERATE ELEMENT() BEGIN
     def __init__(
       self,
       tag = 'AST_ExpressionMultiplyAssignment',
       attrib = {},
       text = '',
-      children = []
+      children = [],
+      binary_operator = '',
+      precedence = -1,
+      right_to_left = False
     ):
-      AST.Expression.__init__(
+      AST.ExpressionBinary.__init__(
         self,
         tag,
         attrib,
         text,
-        children
+        children,
+        binary_operator,
+        precedence,
+        right_to_left
       )
     def copy(self, factory = None):
-      result = AST.Expression.copy(
+      result = AST.ExpressionBinary.copy(
         self,
         ExpressionMultiplyAssignment if factory is None else factory
       )
@@ -2791,24 +3034,30 @@ class AST(element.Element):
       return 'ast.AST.ExpressionMultiplyAssignment({0:s})'.format(', '.join(params))
     # GENERATE END
 
-  class ExpressionNotEqual(Expression):
+  class ExpressionNotEqual(ExpressionBinary):
     # GENERATE ELEMENT() BEGIN
     def __init__(
       self,
       tag = 'AST_ExpressionNotEqual',
       attrib = {},
       text = '',
-      children = []
+      children = [],
+      binary_operator = '',
+      precedence = -1,
+      right_to_left = False
     ):
-      AST.Expression.__init__(
+      AST.ExpressionBinary.__init__(
         self,
         tag,
         attrib,
         text,
-        children
+        children,
+        binary_operator,
+        precedence,
+        right_to_left
       )
     def copy(self, factory = None):
-      result = AST.Expression.copy(
+      result = AST.ExpressionBinary.copy(
         self,
         ExpressionNotEqual if factory is None else factory
       )
@@ -2819,24 +3068,28 @@ class AST(element.Element):
       return 'ast.AST.ExpressionNotEqual({0:s})'.format(', '.join(params))
     # GENERATE END
 
-  class ExpressionPlus(Expression):
+  class ExpressionPlus(ExpressionUnary):
     # GENERATE ELEMENT() BEGIN
     def __init__(
       self,
       tag = 'AST_ExpressionPlus',
       attrib = {},
       text = '',
-      children = []
+      children = [],
+      unary_operator = '',
+      postfix = False
     ):
-      AST.Expression.__init__(
+      AST.ExpressionUnary.__init__(
         self,
         tag,
         attrib,
         text,
-        children
+        children,
+        unary_operator,
+        postfix
       )
     def copy(self, factory = None):
-      result = AST.Expression.copy(
+      result = AST.ExpressionUnary.copy(
         self,
         ExpressionPlus if factory is None else factory
       )
@@ -2846,30 +3099,29 @@ class AST(element.Element):
       self.repr_serialize(params)
       return 'ast.AST.ExpressionPlus({0:s})'.format(', '.join(params))
     # GENERATE END
-    def translate(self, context):
-      assert len(self) == 1
-      self[0].translate(context)
-      element.set_text(self, 0, '+')
-      element.set_text(self, 1, '')
 
-  class ExpressionPostDecrement(Expression):
+  class ExpressionPostDecrement(ExpressionUnary):
     # GENERATE ELEMENT() BEGIN
     def __init__(
       self,
       tag = 'AST_ExpressionPostDecrement',
       attrib = {},
       text = '',
-      children = []
+      children = [],
+      unary_operator = '',
+      postfix = False
     ):
-      AST.Expression.__init__(
+      AST.ExpressionUnary.__init__(
         self,
         tag,
         attrib,
         text,
-        children
+        children,
+        unary_operator,
+        postfix
       )
     def copy(self, factory = None):
-      result = AST.Expression.copy(
+      result = AST.ExpressionUnary.copy(
         self,
         ExpressionPostDecrement if factory is None else factory
       )
@@ -2879,30 +3131,31 @@ class AST(element.Element):
       self.repr_serialize(params)
       return 'ast.AST.ExpressionPostDecrement({0:s})'.format(', '.join(params))
     # GENERATE END
-    def translate(self, context):
-      assert len(self) == 1
-      self[0].translate(context)
-      element.set_text(self, 0, '')
-      element.set_text(self, 1, ' -= 1')
+    def translate_statement_expression(self, context):
+      return '{0:s} -= 1'.format(self[0].translate_expression(context, 0))
 
-  class ExpressionPostIncrement(Expression):
+  class ExpressionPostIncrement(ExpressionUnary):
     # GENERATE ELEMENT() BEGIN
     def __init__(
       self,
       tag = 'AST_ExpressionPostIncrement',
       attrib = {},
       text = '',
-      children = []
+      children = [],
+      unary_operator = '',
+      postfix = False
     ):
-      AST.Expression.__init__(
+      AST.ExpressionUnary.__init__(
         self,
         tag,
         attrib,
         text,
-        children
+        children,
+        unary_operator,
+        postfix
       )
     def copy(self, factory = None):
-      result = AST.Expression.copy(
+      result = AST.ExpressionUnary.copy(
         self,
         ExpressionPostIncrement if factory is None else factory
       )
@@ -2912,30 +3165,31 @@ class AST(element.Element):
       self.repr_serialize(params)
       return 'ast.AST.ExpressionPostIncrement({0:s})'.format(', '.join(params))
     # GENERATE END
-    def translate(self, context):
-      assert len(self) == 1
-      self[0].translate(context)
-      element.set_text(self, 0, '')
-      element.set_text(self, 1, ' += 1')
+    def translate_statement_expression(self, context):
+      return '{0:s} += 1'.format(self[0].translate_expression(context, 0))
 
-  class ExpressionPreDecrement(Expression):
+  class ExpressionPreDecrement(ExpressionUnary):
     # GENERATE ELEMENT() BEGIN
     def __init__(
       self,
       tag = 'AST_ExpressionPreDecrement',
       attrib = {},
       text = '',
-      children = []
+      children = [],
+      unary_operator = '',
+      postfix = False
     ):
-      AST.Expression.__init__(
+      AST.ExpressionUnary.__init__(
         self,
         tag,
         attrib,
         text,
-        children
+        children,
+        unary_operator,
+        postfix
       )
     def copy(self, factory = None):
-      result = AST.Expression.copy(
+      result = AST.ExpressionUnary.copy(
         self,
         ExpressionPreDecrement if factory is None else factory
       )
@@ -2945,30 +3199,31 @@ class AST(element.Element):
       self.repr_serialize(params)
       return 'ast.AST.ExpressionPreDecrement({0:s})'.format(', '.join(params))
     # GENERATE END
-    def translate(self, context):
-      assert len(self) == 1
-      self[0].translate(context)
-      element.set_text(self, 0, '')
-      element.set_text(self, 1, ' -= 1')
+    def translate_statement_expression(self, context):
+      return '{0:s} -= 1'.format(self[0].translate_expression(context, 0))
 
-  class ExpressionPreIncrement(Expression):
+  class ExpressionPreIncrement(ExpressionUnary):
     # GENERATE ELEMENT() BEGIN
     def __init__(
       self,
       tag = 'AST_ExpressionPreIncrement',
       attrib = {},
       text = '',
-      children = []
+      children = [],
+      unary_operator = '',
+      postfix = False
     ):
-      AST.Expression.__init__(
+      AST.ExpressionUnary.__init__(
         self,
         tag,
         attrib,
         text,
-        children
+        children,
+        unary_operator,
+        postfix
       )
     def copy(self, factory = None):
-      result = AST.Expression.copy(
+      result = AST.ExpressionUnary.copy(
         self,
         ExpressionPreIncrement if factory is None else factory
       )
@@ -2978,30 +3233,33 @@ class AST(element.Element):
       self.repr_serialize(params)
       return 'ast.AST.ExpressionPreIncrement({0:s})'.format(', '.join(params))
     # GENERATE END
-    def translate(self, context):
-      assert len(self) == 1
-      self[0].translate(context)
-      element.set_text(self, 0, '')
-      element.set_text(self, 1, ' += 1')
+    def translate_statement_expression(self, context):
+      return '{0:s} += 1'.format(self[0].translate_expression(context, 0))
 
-  class ExpressionRightShiftAssignment(Expression):
+  class ExpressionRightShiftAssignment(ExpressionBinary):
     # GENERATE ELEMENT() BEGIN
     def __init__(
       self,
       tag = 'AST_ExpressionRightShiftAssignment',
       attrib = {},
       text = '',
-      children = []
+      children = [],
+      binary_operator = '',
+      precedence = -1,
+      right_to_left = False
     ):
-      AST.Expression.__init__(
+      AST.ExpressionBinary.__init__(
         self,
         tag,
         attrib,
         text,
-        children
+        children,
+        binary_operator,
+        precedence,
+        right_to_left
       )
     def copy(self, factory = None):
-      result = AST.Expression.copy(
+      result = AST.ExpressionBinary.copy(
         self,
         ExpressionRightShiftAssignment if factory is None else factory
       )
@@ -3012,24 +3270,30 @@ class AST(element.Element):
       return 'ast.AST.ExpressionRightShiftAssignment({0:s})'.format(', '.join(params))
     # GENERATE END
 
-  class ExpressionShiftLeft(Expression):
+  class ExpressionShiftLeft(ExpressionBinary):
     # GENERATE ELEMENT() BEGIN
     def __init__(
       self,
       tag = 'AST_ExpressionShiftLeft',
       attrib = {},
       text = '',
-      children = []
+      children = [],
+      binary_operator = '',
+      precedence = -1,
+      right_to_left = False
     ):
-      AST.Expression.__init__(
+      AST.ExpressionBinary.__init__(
         self,
         tag,
         attrib,
         text,
-        children
+        children,
+        binary_operator,
+        precedence,
+        right_to_left
       )
     def copy(self, factory = None):
-      result = AST.Expression.copy(
+      result = AST.ExpressionBinary.copy(
         self,
         ExpressionShiftLeft if factory is None else factory
       )
@@ -3040,24 +3304,30 @@ class AST(element.Element):
       return 'ast.AST.ExpressionShiftLeft({0:s})'.format(', '.join(params))
     # GENERATE END
 
-  class ExpressionShiftRight(Expression):
+  class ExpressionShiftRight(ExpressionBinary):
     # GENERATE ELEMENT() BEGIN
     def __init__(
       self,
       tag = 'AST_ExpressionShiftRight',
       attrib = {},
       text = '',
-      children = []
+      children = [],
+      binary_operator = '',
+      precedence = -1,
+      right_to_left = False
     ):
-      AST.Expression.__init__(
+      AST.ExpressionBinary.__init__(
         self,
         tag,
         attrib,
         text,
-        children
+        children,
+        binary_operator,
+        precedence,
+        right_to_left
       )
     def copy(self, factory = None):
-      result = AST.Expression.copy(
+      result = AST.ExpressionBinary.copy(
         self,
         ExpressionShiftRight if factory is None else factory
       )
@@ -3068,24 +3338,28 @@ class AST(element.Element):
       return 'ast.AST.ExpressionShiftRight({0:s})'.format(', '.join(params))
     # GENERATE END
 
-  class ExpressionSizeOfExpression(Expression):
+  class ExpressionSizeOfExpression(ExpressionUnary):
     # GENERATE ELEMENT() BEGIN
     def __init__(
       self,
       tag = 'AST_ExpressionSizeOfExpression',
       attrib = {},
       text = '',
-      children = []
+      children = [],
+      unary_operator = '',
+      postfix = False
     ):
-      AST.Expression.__init__(
+      AST.ExpressionUnary.__init__(
         self,
         tag,
         attrib,
         text,
-        children
+        children,
+        unary_operator,
+        postfix
       )
     def copy(self, factory = None):
-      result = AST.Expression.copy(
+      result = AST.ExpressionUnary.copy(
         self,
         ExpressionSizeOfExpression if factory is None else factory
       )
@@ -3096,24 +3370,28 @@ class AST(element.Element):
       return 'ast.AST.ExpressionSizeOfExpression({0:s})'.format(', '.join(params))
     # GENERATE END
 
-  class ExpressionSizeOfType(Expression):
+  class ExpressionSizeOfType(ExpressionUnary):
     # GENERATE ELEMENT() BEGIN
     def __init__(
       self,
       tag = 'AST_ExpressionSizeOfType',
       attrib = {},
       text = '',
-      children = []
+      children = [],
+      unary_operator = '',
+      postfix = False
     ):
-      AST.Expression.__init__(
+      AST.ExpressionUnary.__init__(
         self,
         tag,
         attrib,
         text,
-        children
+        children,
+        unary_operator,
+        postfix
       )
     def copy(self, factory = None):
-      result = AST.Expression.copy(
+      result = AST.ExpressionUnary.copy(
         self,
         ExpressionSizeOfType if factory is None else factory
       )
@@ -3151,30 +3429,31 @@ class AST(element.Element):
       self.repr_serialize(params)
       return 'ast.AST.ExpressionStringLiteral({0:s})'.format(', '.join(params))
     # GENERATE END
-    def translate(self, context):
-      element.set_text(self, 0, '"')
-      for i in range(1, len(self)):
-        element.set_text(self, i, '')
-      element.set_text(self, len(self), '"')
 
-  class ExpressionSubtract(Expression):
+  class ExpressionSubtract(ExpressionBinary):
     # GENERATE ELEMENT() BEGIN
     def __init__(
       self,
       tag = 'AST_ExpressionSubtract',
       attrib = {},
       text = '',
-      children = []
+      children = [],
+      binary_operator = '',
+      precedence = -1,
+      right_to_left = False
     ):
-      AST.Expression.__init__(
+      AST.ExpressionBinary.__init__(
         self,
         tag,
         attrib,
         text,
-        children
+        children,
+        binary_operator,
+        precedence,
+        right_to_left
       )
     def copy(self, factory = None):
-      result = AST.Expression.copy(
+      result = AST.ExpressionBinary.copy(
         self,
         ExpressionSubtract if factory is None else factory
       )
@@ -3185,24 +3464,30 @@ class AST(element.Element):
       return 'ast.AST.ExpressionSubtract({0:s})'.format(', '.join(params))
     # GENERATE END
 
-  class ExpressionSubtractAssignment(Expression):
+  class ExpressionSubtractAssignment(ExpressionBinary):
     # GENERATE ELEMENT() BEGIN
     def __init__(
       self,
       tag = 'AST_ExpressionSubtractAssignment',
       attrib = {},
       text = '',
-      children = []
+      children = [],
+      binary_operator = '',
+      precedence = -1,
+      right_to_left = False
     ):
-      AST.Expression.__init__(
+      AST.ExpressionBinary.__init__(
         self,
         tag,
         attrib,
         text,
-        children
+        children,
+        binary_operator,
+        precedence,
+        right_to_left
       )
     def copy(self, factory = None):
-      result = AST.Expression.copy(
+      result = AST.ExpressionBinary.copy(
         self,
         ExpressionSubtractAssignment if factory is None else factory
       )
@@ -3258,7 +3543,7 @@ class AST(element.Element):
       context.top_level = True
       context.indent = indent_save
 
-  class FunctionSpecifier(Element):
+  class FunctionSpecifier(element.Element):
     # GENERATE ELEMENT(int n) BEGIN
     def __init__(
       self,
@@ -3268,7 +3553,7 @@ class AST(element.Element):
       children = [],
       n = -1
     ):
-      AST.Element.__init__(
+      element.Element.__init__(
         self,
         tag,
         attrib,
@@ -3281,20 +3566,20 @@ class AST(element.Element):
         n
       )
     def serialize(self, ref_list):
-      AST.Element.serialize(self, ref_list)
+      element.Element.serialize(self, ref_list)
       self.set('n', element.serialize_int(self.n))
     def deserialize(self, ref_list):
-      AST.Element.deserialize(self, ref_list)
+      element.Element.deserialize(self, ref_list)
       self.n = element.deserialize_int(self.get('n', '-1'))
     def copy(self, factory = None):
-      result = AST.Element.copy(
+      result = element.Element.copy(
         self,
         FunctionSpecifier if factory is None else factory
       )
       result.n = self.n
       return result
     def repr_serialize(self, params):
-      AST.Element.repr_serialize(self, params)
+      element.Element.repr_serialize(self, params)
       if self.n != -1:
         params.append(
           'n = {0:s}'.format(repr(self.n))
@@ -3305,7 +3590,7 @@ class AST(element.Element):
       return 'ast.AST.FunctionSpecifier({0:s})'.format(', '.join(params))
     # GENERATE END
 
-  class GenericAssociation(Element):
+  class GenericAssociation(element.Element):
     # GENERATE ELEMENT() BEGIN
     def __init__(
       self,
@@ -3314,7 +3599,7 @@ class AST(element.Element):
       text = '',
       children = []
     ):
-      AST.Element.__init__(
+      element.Element.__init__(
         self,
         tag,
         attrib,
@@ -3322,7 +3607,7 @@ class AST(element.Element):
         children
       )
     def copy(self, factory = None):
-      result = AST.Element.copy(
+      result = element.Element.copy(
         self,
         GenericAssociation if factory is None else factory
       )
@@ -3333,7 +3618,7 @@ class AST(element.Element):
       return 'ast.AST.GenericAssociation({0:s})'.format(', '.join(params))
     # GENERATE END
 
-  class GenericAssociationList(Element):
+  class GenericAssociationList(element.Element):
     # GENERATE ELEMENT() BEGIN
     def __init__(
       self,
@@ -3342,7 +3627,7 @@ class AST(element.Element):
       text = '',
       children = []
     ):
-      AST.Element.__init__(
+      element.Element.__init__(
         self,
         tag,
         attrib,
@@ -3350,7 +3635,7 @@ class AST(element.Element):
         children
       )
     def copy(self, factory = None):
-      result = AST.Element.copy(
+      result = element.Element.copy(
         self,
         GenericAssociationList if factory is None else factory
       )
@@ -3361,7 +3646,7 @@ class AST(element.Element):
       return 'ast.AST.GenericAssociationList({0:s})'.format(', '.join(params))
     # GENERATE END
 
-  class GenericSelection(Element):
+  class GenericSelection(element.Element):
     # GENERATE ELEMENT() BEGIN
     def __init__(
       self,
@@ -3370,7 +3655,7 @@ class AST(element.Element):
       text = '',
       children = []
     ):
-      AST.Element.__init__(
+      element.Element.__init__(
         self,
         tag,
         attrib,
@@ -3378,7 +3663,7 @@ class AST(element.Element):
         children
       )
     def copy(self, factory = None):
-      result = AST.Element.copy(
+      result = element.Element.copy(
         self,
         GenericSelection if factory is None else factory
       )
@@ -3389,7 +3674,7 @@ class AST(element.Element):
       return 'ast.AST.GenericSelection({0:s})'.format(', '.join(params))
     # GENERATE END
 
-  class IdentifierEmpty(Element):
+  class IdentifierEmpty(element.Element):
     # GENERATE ELEMENT() BEGIN
     def __init__(
       self,
@@ -3398,7 +3683,7 @@ class AST(element.Element):
       text = '',
       children = []
     ):
-      AST.Element.__init__(
+      element.Element.__init__(
         self,
         tag,
         attrib,
@@ -3406,7 +3691,7 @@ class AST(element.Element):
         children
       )
     def copy(self, factory = None):
-      result = AST.Element.copy(
+      result = element.Element.copy(
         self,
         IdentifierEmpty if factory is None else factory
       )
@@ -3417,7 +3702,7 @@ class AST(element.Element):
       return 'ast.AST.IdentifierEmpty({0:s})'.format(', '.join(params))
     # GENERATE END
 
-  class IdentifierList(Element):
+  class IdentifierList(element.Element):
     # GENERATE ELEMENT() BEGIN
     def __init__(
       self,
@@ -3426,7 +3711,7 @@ class AST(element.Element):
       text = '',
       children = []
     ):
-      AST.Element.__init__(
+      element.Element.__init__(
         self,
         tag,
         attrib,
@@ -3434,7 +3719,7 @@ class AST(element.Element):
         children
       )
     def copy(self, factory = None):
-      result = AST.Element.copy(
+      result = element.Element.copy(
         self,
         IdentifierList if factory is None else factory
       )
@@ -3445,7 +3730,7 @@ class AST(element.Element):
       return 'ast.AST.IdentifierList({0:s})'.format(', '.join(params))
     # GENERATE END
 
-  class InitDeclarator(Element):
+  class InitDeclarator(element.Element):
     # GENERATE ELEMENT() BEGIN
     def __init__(
       self,
@@ -3454,7 +3739,7 @@ class AST(element.Element):
       text = '',
       children = []
     ):
-      AST.Element.__init__(
+      element.Element.__init__(
         self,
         tag,
         attrib,
@@ -3462,7 +3747,7 @@ class AST(element.Element):
         children
       )
     def copy(self, factory = None):
-      result = AST.Element.copy(
+      result = element.Element.copy(
         self,
         InitDeclarator if factory is None else factory
       )
@@ -3473,7 +3758,7 @@ class AST(element.Element):
       return 'ast.AST.InitDeclarator({0:s})'.format(', '.join(params))
     # GENERATE END
 
-  class InitDeclaratorList(Element):
+  class InitDeclaratorList(element.Element):
     # GENERATE ELEMENT() BEGIN
     def __init__(
       self,
@@ -3482,7 +3767,7 @@ class AST(element.Element):
       text = '',
       children = []
     ):
-      AST.Element.__init__(
+      element.Element.__init__(
         self,
         tag,
         attrib,
@@ -3490,7 +3775,7 @@ class AST(element.Element):
         children
       )
     def copy(self, factory = None):
-      result = AST.Element.copy(
+      result = element.Element.copy(
         self,
         InitDeclaratorList if factory is None else factory
       )
@@ -3501,7 +3786,7 @@ class AST(element.Element):
       return 'ast.AST.InitDeclaratorList({0:s})'.format(', '.join(params))
     # GENERATE END
 
-  class ParameterDeclaration(Element):
+  class ParameterDeclaration(element.Element):
     # GENERATE ELEMENT() BEGIN
     def __init__(
       self,
@@ -3510,7 +3795,7 @@ class AST(element.Element):
       text = '',
       children = []
     ):
-      AST.Element.__init__(
+      element.Element.__init__(
         self,
         tag,
         attrib,
@@ -3518,7 +3803,7 @@ class AST(element.Element):
         children
       )
     def copy(self, factory = None):
-      result = AST.Element.copy(
+      result = element.Element.copy(
         self,
         ParameterDeclaration if factory is None else factory
       )
@@ -3529,7 +3814,7 @@ class AST(element.Element):
       return 'ast.AST.ParameterDeclaration({0:s})'.format(', '.join(params))
     # GENERATE END
 
-  class ParameterDeclarationList(Element):
+  class ParameterDeclarationList(element.Element):
     # GENERATE ELEMENT() BEGIN
     def __init__(
       self,
@@ -3538,7 +3823,7 @@ class AST(element.Element):
       text = '',
       children = []
     ):
-      AST.Element.__init__(
+      element.Element.__init__(
         self,
         tag,
         attrib,
@@ -3546,7 +3831,7 @@ class AST(element.Element):
         children
       )
     def copy(self, factory = None):
-      result = AST.Element.copy(
+      result = element.Element.copy(
         self,
         ParameterDeclarationList if factory is None else factory
       )
@@ -3557,7 +3842,7 @@ class AST(element.Element):
       return 'ast.AST.ParameterDeclarationList({0:s})'.format(', '.join(params))
     # GENERATE END
 
-  class SpecifierQualifierList(Element):
+  class SpecifierQualifierList(element.Element):
     # GENERATE ELEMENT() BEGIN
     def __init__(
       self,
@@ -3566,7 +3851,7 @@ class AST(element.Element):
       text = '',
       children = []
     ):
-      AST.Element.__init__(
+      element.Element.__init__(
         self,
         tag,
         attrib,
@@ -3574,7 +3859,7 @@ class AST(element.Element):
         children
       )
     def copy(self, factory = None):
-      result = AST.Element.copy(
+      result = element.Element.copy(
         self,
         SpecifierQualifierList if factory is None else factory
       )
@@ -3612,14 +3897,11 @@ class AST(element.Element):
       self.repr_serialize(params)
       return 'ast.AST.StatementBlock({0:s})'.format(', '.join(params))
     # GENERATE END
-    def translate(self, context):
-      assert len(self) == 1
-      indent_save = context.indent
-      context.indent += '  '
-      self[0].translate(context)
-      context.indent = indent_save
-      element.set_text(self, 0, '')
-      element.set_text(self, 1, '')
+    def translate_declaration_or_statement(self, context):
+      if len(self[0]):
+        self[0].translate_block_item_list(context)
+      else:
+        context.lines.append('{0:s}pass\n'.format(context.indent))
 
   class StatementBreak(Statement):
     # GENERATE ELEMENT() BEGIN
@@ -3648,7 +3930,9 @@ class AST(element.Element):
       self.repr_serialize(params)
       return 'ast.AST.StatementBreak({0:s})'.format(', '.join(params))
     # GENERATE END
-
+    def translate_declaration_or_statement(self, context):
+      context.lines.append('{0:s}break\n'.format(context.indent))
+ 
   class StatementCase(Statement):
     # GENERATE ELEMENT() BEGIN
     def __init__(
@@ -3704,27 +3988,28 @@ class AST(element.Element):
       self.repr_serialize(params)
       return 'ast.AST.StatementContinue({0:s})'.format(', '.join(params))
     # GENERATE END
-    def translate(self, context):
-      assert len(self) == 0
-      if isinstance(enclosing_loop, StatementDoWhile):
-        self.append(enclosing_loop[1].copy())
-        self[0].translate(context)
-        element.set_text(self, 0, '{0:s}if '.format(context.indent))
-        element.set_text(
-          self,
-          0,
-          ':\n{0:s}  continue\n{1:s}break\n'.format(
+    def translate_declaration_or_statement(self, context):
+      enclosing_loop_save = context.enclosing_loop
+      context.enclosing_loop = None
+      if isinstance(enclosing_loop_save, AST.StatementDoWhile):
+        AST.StatementIfElse(
+          children = [
+            enclosing_loop_save[1],
+            AST.StatementContinue(),
+            AST.StatementBreak()
+          ]
+        ).translate_declaration_or_statement(context)
+      elif isinstance(enclosing_loop_save, AST.StatementFor):
+        context.lines.append(
+          '{0:s}{1:s}\n{2:s}continue\n'.format(
             context.indent,
+            enclosing_loop_save[2].translate_statement_expression(context),
             context.indent
           )
         )
-      elif isinstance(enclosing_loop, StatementFor):
-        self.append(enclosing_loop[2].copy())
-        self[0].translate(context)
-        element.set_text(self, 0, '')
-        element.set_text(self, 1, '{0:s}continue\n'.format(context.indent))
       else:
-        element.set_text(self, 0, '{0:s}continue\n'.format(context.indent))
+        context.lines.append('{0:s}continue\n'.format(context.indent))
+      context.enclosing_loop = enclosing_loop_save
 
   class StatementDefault(Statement):
     # GENERATE ELEMENT() BEGIN
@@ -3781,23 +4066,26 @@ class AST(element.Element):
       self.repr_serialize(params)
       return 'ast.AST.StatementDoWhile({0:s})'.format(', '.join(params))
     # GENERATE END
-    def translate(self, context):
-      assert len(self) == 2
+    def translate_declaration_or_statement(self, context):
+      context.lines.append('{0:s}while True:\n'.format(context.indent))
+      indent_save = context.indent
+      context.indent += '  '
       enclosing_loop_save = context.enclosing_loop
       context.enclosing_loop = self
-      self[0] = AST.StatementBlock(
+      self[0].translate_declaration_or_statement(context)
+      context.enclosing_loop = enclosing_loop_save
+      AST.StatementIf(
         children = [
-          AST.BlockItemList(
-            children = [self[0]]
-          )
+          AST.ExpressionLogicalNot(
+            children = [
+              self[1]
+            ],
+            unary_operator = 'not '
+          ),
+          AST.StatementBreak()
         ]
-      )
-      self[0].translate(context)
-      context.enclosing_loop = enclosing_loop_save
-      self[1].translate(context)
-      element.set_text(self, 0, '{0:s}while True:\n'.format(context.indent))
-      element.set_text(self, 1, '{0:s}  if not ('.format(context.indent))
-      element.set_text(self, 2, '):\n{0:s}    break\n'.format(context.indent))
+      ).translate_declaration_or_statement(context)
+      context.indent = indent_save
 
   class StatementExpression(Statement):
     # GENERATE ELEMENT() BEGIN
@@ -3826,6 +4114,13 @@ class AST(element.Element):
       self.repr_serialize(params)
       return 'ast.AST.StatementExpression({0:s})'.format(', '.join(params))
     # GENERATE END
+    def translate_declaration_or_statement(self, context):
+      context.lines.append(
+        '{0:s}{1:s}\n'.format(
+          context.indent,
+          self[0].translate_statement_expression(context)
+        )
+      )
 
   class StatementFor(Statement):
     # GENERATE ELEMENT() BEGIN
@@ -3854,6 +4149,27 @@ class AST(element.Element):
       self.repr_serialize(params)
       return 'ast.AST.StatementFor({0:s})'.format(', '.join(params))
     # GENERATE END
+    def translate_declaration_or_statement(self, context):
+      self[0].translate_declaration_or_statement(context)
+      context.lines.append(
+        '{0:s}while {1:s}:\n'.format(
+          context.indent,
+          self[1].translate_expression(context, 0)
+        )
+      )
+      indent_save = context.indent
+      context.indent += '  '
+      enclosing_loop_save = context.enclosing_loop
+      context.enclosing_loop = self
+      self[3].translate_declaration_or_statement(context)
+      context.enclosing_loop = enclosing_loop_save
+      context.lines.append(
+        '{0:s}{1:s}\n'.format(
+          context.indent,
+          self[2].translate_statement_expression(context)
+        )
+      )
+      context.indent = indent_save
 
   class StatementGoto(Statement):
     # GENERATE ELEMENT() BEGIN
@@ -3910,20 +4226,17 @@ class AST(element.Element):
       self.repr_serialize(params)
       return 'ast.AST.StatementIf({0:s})'.format(', '.join(params))
     # GENERATE END
-    def translate(self, context):
-      assert len(self) == 2
-      self[0].translate(context)
-      self[1] = AST.StatementBlock(
-        children = [
-          AST.BlockItemList(
-            children = [self[1]]
-          )
-        ]
+    def translate_declaration_or_statement(self, context):
+      context.lines.append(
+        '{0:s}if {1:s}:\n'.format(
+          context.indent,
+          self[0].translate_expression(context, 0)
+        )
       )
-      self[1].translate(context)
-      element.set_text(self, 0, '{0:s}if '.format(context.indent))
-      element.set_text(self, 1, ':\n')
-      element.set_text(self, 2, '')
+      indent_save = context.indent
+      context.indent += '  '
+      self[1].translate_declaration_or_statement(context)
+      context.indent = indent_save
 
   class StatementIfElse(Statement):
     # GENERATE ELEMENT() BEGIN
@@ -3952,29 +4265,19 @@ class AST(element.Element):
       self.repr_serialize(params)
       return 'ast.AST.StatementIfElse({0:s})'.format(', '.join(params))
     # GENERATE END
-    def translate(self, context):
-      assert len(self) == 3
-      self[0].translate(context)
-      self[1] = AST.StatementBlock(
-        children = [
-          AST.BlockItemList(
-            children = [self[1]]
-          )
-        ]
-      )
-      self[1].translate(context)
-      self[2] = AST.StatementBlock(
-        children = [
-          AST.BlockItemList(
-            children = [self[2]]
-          )
-        ]
+    def translate_declaration_or_statement(self, context):
+      context.lines.append(
+        '{0:s}if {1:s}:\n'.format(
+          context.indent,
+          self[0].translate_expression(context, 0)
+        )
       )
-      self[2].translate(context)
-      element.set_text(self, 0, '{0:s}if '.format(context.indent))
-      element.set_text(self, 1, ':\n')
-      element.set_text(self, 2, '{0:s}else:\n'.format(context.indent))
-      element.set_text(self, 3, '')
+      indent_save = context.indent
+      context.indent += '  '
+      self[1].translate_declaration_or_statement(context)
+      context.lines.append('{0:s}else:\n'.format(indent_save))
+      self[2].translate_declaration_or_statement(context)
+      context.indent = indent_save
 
   class StatementLabel(Statement):
     # GENERATE ELEMENT() BEGIN
@@ -4087,25 +4390,22 @@ class AST(element.Element):
       self.repr_serialize(params)
       return 'ast.AST.StatementWhile({0:s})'.format(', '.join(params))
     # GENERATE END
-    def translate(self, context):
-      assert len(self) == 2
-      self[0].translate(context)
+    def translate_declaration_or_statement(self, context):
+      context.lines.append(
+        '{0:s}while {1:s}:\n'.format(
+          context.indent,
+          self[0].translate_expression(context, 0)
+        )
+      )
+      indent_save = context.indent
+      context.indent += '  '
       enclosing_loop_save = context.enclosing_loop
       context.enclosing_loop = self
-      self[1] = AST.StatementBlock(
-        children = [
-          AST.BlockItemList(
-            children = [self[1]]
-          )
-        ]
-      )
-      self[1].translate(context)
+      self[1].translate_declaration_or_statement(context)
       context.enclosing_loop = enclosing_loop_save
-      element.set_text(self, 0, '{0:s}while '.format(context.indent))
-      element.set_text(self, 1, ':\n')
-      element.set_text(self, 2, '')
+      context.indent = indent_save
 
-  class StaticAssertDeclaration(Element):
+  class StaticAssertDeclaration(element.Element):
     # GENERATE ELEMENT() BEGIN
     def __init__(
       self,
@@ -4114,7 +4414,7 @@ class AST(element.Element):
       text = '',
       children = []
     ):
-      AST.Element.__init__(
+      element.Element.__init__(
         self,
         tag,
         attrib,
@@ -4122,7 +4422,7 @@ class AST(element.Element):
         children
       )
     def copy(self, factory = None):
-      result = AST.Element.copy(
+      result = element.Element.copy(
         self,
         StaticAssertDeclaration if factory is None else factory
       )
@@ -4133,7 +4433,7 @@ class AST(element.Element):
       return 'ast.AST.StaticAssertDeclaration({0:s})'.format(', '.join(params))
     # GENERATE END
 
-  class StorageClassSpecifier(Element):
+  class StorageClassSpecifier(element.Element):
     # GENERATE ELEMENT(int n) BEGIN
     def __init__(
       self,
@@ -4143,7 +4443,7 @@ class AST(element.Element):
       children = [],
       n = -1
     ):
-      AST.Element.__init__(
+      element.Element.__init__(
         self,
         tag,
         attrib,
@@ -4156,20 +4456,20 @@ class AST(element.Element):
         n
       )
     def serialize(self, ref_list):
-      AST.Element.serialize(self, ref_list)
+      element.Element.serialize(self, ref_list)
       self.set('n', element.serialize_int(self.n))
     def deserialize(self, ref_list):
-      AST.Element.deserialize(self, ref_list)
+      element.Element.deserialize(self, ref_list)
       self.n = element.deserialize_int(self.get('n', '-1'))
     def copy(self, factory = None):
-      result = AST.Element.copy(
+      result = element.Element.copy(
         self,
         StorageClassSpecifier if factory is None else factory
       )
       result.n = self.n
       return result
     def repr_serialize(self, params):
-      AST.Element.repr_serialize(self, params)
+      element.Element.repr_serialize(self, params)
       if self.n != -1:
         params.append(
           'n = {0:s}'.format(repr(self.n))
@@ -4180,7 +4480,7 @@ class AST(element.Element):
       return 'ast.AST.StorageClassSpecifier({0:s})'.format(', '.join(params))
     # GENERATE END
 
-  class StructDeclaration(Element):
+  class StructDeclaration(element.Element):
     # GENERATE ELEMENT() BEGIN
     def __init__(
       self,
@@ -4189,7 +4489,7 @@ class AST(element.Element):
       text = '',
       children = []
     ):
-      AST.Element.__init__(
+      element.Element.__init__(
         self,
         tag,
         attrib,
@@ -4197,7 +4497,7 @@ class AST(element.Element):
         children
       )
     def copy(self, factory = None):
-      result = AST.Element.copy(
+      result = element.Element.copy(
         self,
         StructDeclaration if factory is None else factory
       )
@@ -4208,7 +4508,7 @@ class AST(element.Element):
       return 'ast.AST.StructDeclaration({0:s})'.format(', '.join(params))
     # GENERATE END
 
-  class StructDeclarationList(Element):
+  class StructDeclarationList(element.Element):
     # GENERATE ELEMENT() BEGIN
     def __init__(
       self,
@@ -4217,7 +4517,7 @@ class AST(element.Element):
       text = '',
       children = []
     ):
-      AST.Element.__init__(
+      element.Element.__init__(
         self,
         tag,
         attrib,
@@ -4225,7 +4525,7 @@ class AST(element.Element):
         children
       )
     def copy(self, factory = None):
-      result = AST.Element.copy(
+      result = element.Element.copy(
         self,
         StructDeclarationList if factory is None else factory
       )
@@ -4236,7 +4536,7 @@ class AST(element.Element):
       return 'ast.AST.StructDeclarationList({0:s})'.format(', '.join(params))
     # GENERATE END
 
-  class StructDeclarator(Element):
+  class StructDeclarator(element.Element):
     # GENERATE ELEMENT() BEGIN
     def __init__(
       self,
@@ -4245,7 +4545,7 @@ class AST(element.Element):
       text = '',
       children = []
     ):
-      AST.Element.__init__(
+      element.Element.__init__(
         self,
         tag,
         attrib,
@@ -4253,7 +4553,7 @@ class AST(element.Element):
         children
       )
     def copy(self, factory = None):
-      result = AST.Element.copy(
+      result = element.Element.copy(
         self,
         StructDeclarator if factory is None else factory
       )
@@ -4264,7 +4564,7 @@ class AST(element.Element):
       return 'ast.AST.StructDeclarator({0:s})'.format(', '.join(params))
     # GENERATE END
 
-  class StructDeclaratorList(Element):
+  class StructDeclaratorList(element.Element):
     # GENERATE ELEMENT() BEGIN
     def __init__(
       self,
@@ -4273,7 +4573,7 @@ class AST(element.Element):
       text = '',
       children = []
     ):
-      AST.Element.__init__(
+      element.Element.__init__(
         self,
         tag,
         attrib,
@@ -4281,7 +4581,7 @@ class AST(element.Element):
         children
       )
     def copy(self, factory = None):
-      result = AST.Element.copy(
+      result = element.Element.copy(
         self,
         StructDeclaratorList if factory is None else factory
       )
@@ -4292,7 +4592,7 @@ class AST(element.Element):
       return 'ast.AST.StructDeclaratorList({0:s})'.format(', '.join(params))
     # GENERATE END
 
-  class StructSpecifier(Element):
+  class StructSpecifier(element.Element):
     # GENERATE ELEMENT() BEGIN
     def __init__(
       self,
@@ -4301,7 +4601,7 @@ class AST(element.Element):
       text = '',
       children = []
     ):
-      AST.Element.__init__(
+      element.Element.__init__(
         self,
         tag,
         attrib,
@@ -4309,7 +4609,7 @@ class AST(element.Element):
         children
       )
     def copy(self, factory = None):
-      result = AST.Element.copy(
+      result = element.Element.copy(
         self,
         StructSpecifier if factory is None else factory
       )
@@ -4320,7 +4620,7 @@ class AST(element.Element):
       return 'ast.AST.StructSpecifier({0:s})'.format(', '.join(params))
     # GENERATE END
 
-  class TypeName(Element):
+  class TypeName(element.Element):
     # GENERATE ELEMENT() BEGIN
     def __init__(
       self,
@@ -4329,7 +4629,7 @@ class AST(element.Element):
       text = '',
       children = []
     ):
-      AST.Element.__init__(
+      element.Element.__init__(
         self,
         tag,
         attrib,
@@ -4337,7 +4637,7 @@ class AST(element.Element):
         children
       )
     def copy(self, factory = None):
-      result = AST.Element.copy(
+      result = element.Element.copy(
         self,
         TypeName if factory is None else factory
       )
@@ -4348,7 +4648,7 @@ class AST(element.Element):
       return 'ast.AST.TypeName({0:s})'.format(', '.join(params))
     # GENERATE END
 
-  class TypeQualifier(Element):
+  class TypeQualifier(element.Element):
     # GENERATE ELEMENT(int n) BEGIN
     def __init__(
       self,
@@ -4358,7 +4658,7 @@ class AST(element.Element):
       children = [],
       n = -1
     ):
-      AST.Element.__init__(
+      element.Element.__init__(
         self,
         tag,
         attrib,
@@ -4371,20 +4671,20 @@ class AST(element.Element):
         n
       )
     def serialize(self, ref_list):
-      AST.Element.serialize(self, ref_list)
+      element.Element.serialize(self, ref_list)
       self.set('n', element.serialize_int(self.n))
     def deserialize(self, ref_list):
-      AST.Element.deserialize(self, ref_list)
+      element.Element.deserialize(self, ref_list)
       self.n = element.deserialize_int(self.get('n', '-1'))
     def copy(self, factory = None):
-      result = AST.Element.copy(
+      result = element.Element.copy(
         self,
         TypeQualifier if factory is None else factory
       )
       result.n = self.n
       return result
     def repr_serialize(self, params):
-      AST.Element.repr_serialize(self, params)
+      element.Element.repr_serialize(self, params)
       if self.n != -1:
         params.append(
           'n = {0:s}'.format(repr(self.n))
@@ -4395,7 +4695,7 @@ class AST(element.Element):
       return 'ast.AST.TypeQualifier({0:s})'.format(', '.join(params))
     # GENERATE END
 
-  class TypeQualifierList(Element):
+  class TypeQualifierList(element.Element):
     # GENERATE ELEMENT() BEGIN
     def __init__(
       self,
@@ -4404,7 +4704,7 @@ class AST(element.Element):
       text = '',
       children = []
     ):
-      AST.Element.__init__(
+      element.Element.__init__(
         self,
         tag,
         attrib,
@@ -4412,7 +4712,7 @@ class AST(element.Element):
         children
       )
     def copy(self, factory = None):
-      result = AST.Element.copy(
+      result = element.Element.copy(
         self,
         TypeQualifierList if factory is None else factory
       )
@@ -4423,7 +4723,7 @@ class AST(element.Element):
       return 'ast.AST.TypeQualifierList({0:s})'.format(', '.join(params))
     # GENERATE END
 
-  class TypeQualifierOrStaticList(Element):
+  class TypeQualifierOrStaticList(element.Element):
     # GENERATE ELEMENT() BEGIN
     def __init__(
       self,
@@ -4432,7 +4732,7 @@ class AST(element.Element):
       text = '',
       children = []
     ):
-      AST.Element.__init__(
+      element.Element.__init__(
         self,
         tag,
         attrib,
@@ -4440,7 +4740,7 @@ class AST(element.Element):
         children
       )
     def copy(self, factory = None):
-      result = AST.Element.copy(
+      result = element.Element.copy(
         self,
         TypeQualifierOrStaticList if factory is None else factory
       )
@@ -4451,7 +4751,7 @@ class AST(element.Element):
       return 'ast.AST.TypeQualifierOrStaticList({0:s})'.format(', '.join(params))
     # GENERATE END
 
-  class TypeSpecifier(Element):
+  class TypeSpecifier(element.Element):
     # GENERATE ELEMENT(int n) BEGIN
     def __init__(
       self,
@@ -4461,7 +4761,7 @@ class AST(element.Element):
       children = [],
       n = -1
     ):
-      AST.Element.__init__(
+      element.Element.__init__(
         self,
         tag,
         attrib,
@@ -4474,20 +4774,20 @@ class AST(element.Element):
         n
       )
     def serialize(self, ref_list):
-      AST.Element.serialize(self, ref_list)
+      element.Element.serialize(self, ref_list)
       self.set('n', element.serialize_int(self.n))
     def deserialize(self, ref_list):
-      AST.Element.deserialize(self, ref_list)
+      element.Element.deserialize(self, ref_list)
       self.n = element.deserialize_int(self.get('n', '-1'))
     def copy(self, factory = None):
-      result = AST.Element.copy(
+      result = element.Element.copy(
         self,
         TypeSpecifier if factory is None else factory
       )
       result.n = self.n
       return result
     def repr_serialize(self, params):
-      AST.Element.repr_serialize(self, params)
+      element.Element.repr_serialize(self, params)
       if self.n != -1:
         params.append(
           'n = {0:s}'.format(repr(self.n))
@@ -4498,7 +4798,7 @@ class AST(element.Element):
       return 'ast.AST.TypeSpecifier({0:s})'.format(', '.join(params))
     # GENERATE END
 
-  class UnionSpecifier(Element):
+  class UnionSpecifier(element.Element):
     # GENERATE ELEMENT() BEGIN
     def __init__(
       self,
@@ -4507,7 +4807,7 @@ class AST(element.Element):
       text = '',
       children = []
     ):
-      AST.Element.__init__(
+      element.Element.__init__(
         self,
         tag,
         attrib,
@@ -4515,7 +4815,7 @@ class AST(element.Element):
         children
       )
     def copy(self, factory = None):
-      result = AST.Element.copy(
+      result = element.Element.copy(
         self,
         UnionSpecifier if factory is None else factory
       )
@@ -4526,7 +4826,7 @@ class AST(element.Element):
       return 'ast.AST.UnionSpecifier({0:s})'.format(', '.join(params))
     # GENERATE END
 
-  class TranslationUnit(Element):
+  class TranslationUnit(element.Element):
     # GENERATE ELEMENT() BEGIN
     def __init__(
       self,
@@ -4535,7 +4835,7 @@ class AST(element.Element):
       text = '',
       children = []
     ):
-      AST.Element.__init__(
+      element.Element.__init__(
         self,
         tag,
         attrib,
@@ -4543,7 +4843,7 @@ class AST(element.Element):
         children
       )
     def copy(self, factory = None):
-      result = AST.Element.copy(
+      result = element.Element.copy(
         self,
         TranslationUnit if factory is None else factory
       )
@@ -4619,11 +4919,12 @@ octal_prefix = set(
 tag_to_class = {
   'AST': AST,
   'AST_Text': AST.Text,
-  'AST_Element': AST.Element,
   'AST_DeclarationOrStatement': AST.DeclarationOrStatement,
   'AST_Statement': AST.Statement,
   'AST_Declarator': AST.Declarator,
   'AST_Expression': AST.Expression,
+  'AST_ExpressionUnary': AST.ExpressionUnary,
+  'AST_ExpressionBinary': AST.ExpressionBinary,
   'AST_Type': AST.Type,
   'AST_TypeVoid': AST.TypeVoid,
   'AST_TypeInt': AST.TypeInt,