From 039a2679b99e0cc6f3f98e88bfa8c321b9caa9e5 Mon Sep 17 00:00:00 2001 From: Nick Downing Date: Sun, 13 Jan 2019 18:02:44 +1100 Subject: [PATCH] Translate expressions properly, with parentheses depending on precedence, translate if/else, for, while, do/while, continue, break statements in emulated way --- ansi_c.l | 4 +- ansi_c.y | 86 +-- ast.py | 1551 ++++++++++++++++++++++++++++++++---------------------- 3 files changed, 971 insertions(+), 670 deletions(-) diff --git a/ansi_c.l b/ansi_c.l index 2b121ac..49900bf 100644 --- 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 --- 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 --- 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, -- 2.34.1