From 06fe6258ecb93259711ad152b1e702a8276a766f Mon Sep 17 00:00:00 2001 From: Nick Downing Date: Tue, 29 Jan 2019 15:44:42 +1100 Subject: [PATCH] Update to pitree.git commit 350e5a9 --- ansi_c.t | 166 +++++++++++++++++++++++++++---------------------------- 1 file changed, 83 insertions(+), 83 deletions(-) diff --git a/ansi_c.t b/ansi_c.t index 5c0ab28..ceebf1f 100644 --- a/ansi_c.t +++ b/ansi_c.t @@ -283,9 +283,9 @@ def translate_declaration_or_statement(self, context): raise NotImplementedError @method(AST.Declaration) def translate_declaration_or_statement(self, context): - base_type = self[0].get_type() - for i in self[1]: - type, name = i[0].get_type_and_name(base_type) + base_type = self.children[0].get_type() + for i in self.children[1].children: + type, name = i.children[0].get_type_and_name(base_type) if not isinstance(type, AST.TypeFunction): context.lines.append( '{0:s}{1:s} = {2:s}\n'.format( @@ -293,14 +293,14 @@ def translate_declaration_or_statement(self, context): name, ( type.translate_zero(context) - if isinstance(i[1], AST.EqualsInitializerEmpty) else - i[1].translate_initializer_or_expression(context) + if isinstance(i.children[1], AST.EqualsInitializerEmpty) else + i.children[1].translate_initializer_or_expression(context) ) ) ) @method(AST.FunctionDefinition) def translate_declaration_or_statement(self, context): - type, name = self[1].get_type_and_name(self[0].get_type()) + type, name = self.children[1].get_type_and_name(self.children[0].get_type()) assert isinstance(type, AST.TypeFunction) if len(context.lines): context.lines.append('\n') @@ -308,20 +308,20 @@ def translate_declaration_or_statement(self, context): '{0:s}def {1:s}({2:s}):\n'.format( context.indent, name, - ', '.join([i.name for i in type]) + ', '.join([i.name for i in type.children]) ) ) indent_save = context.indent context.indent += ' ' assert context.top_level context.top_level = False - self[3].translate_block_item_list(context) + self.children[3].translate_block_item_list(context) context.top_level = True context.indent = indent_save @method(AST.StatementBlock) def translate_declaration_or_statement(self, context): - if len(self[0]): - self[0].translate_block_item_list(context) + if len(self.children[0].children): + self.children[0].translate_block_item_list(context) else: context.lines.append('{0:s}pass\n'.format(context.indent)) @method(AST.StatementBreak) @@ -334,7 +334,7 @@ def translate_declaration_or_statement(self, context): if isinstance(enclosing_loop_save, AST.StatementDoWhile): AST.StatementIfElse( children = [ - enclosing_loop_save[1], + enclosing_loop_save.children[1], AST.StatementContinue(), AST.StatementBreak() ] @@ -343,7 +343,7 @@ def translate_declaration_or_statement(self, context): context.lines.append( '{0:s}{1:s}\n{2:s}continue\n'.format( context.indent, - enclosing_loop_save[2].translate_statement_expression(context), + enclosing_loop_save.children[2].translate_statement_expression(context), context.indent ) ) @@ -353,23 +353,23 @@ def translate_declaration_or_statement(self, context): @method(AST.StatementDoWhile) def translate_declaration_or_statement(self, context): if ( - isinstance(self[1], AST.ExpressionIntLiteral) and - element.get_text(self[1], 0) == '0' + isinstance(self.children[1], AST.ExpressionIntLiteral) and + element.get_text(self.children[1], 0) == '0' ): - self[0].translate_declaration_or_statement(context) + self.children[0].translate_declaration_or_statement(context) return 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].translate_declaration_or_statement(context) + self.children[0].translate_declaration_or_statement(context) context.enclosing_loop = enclosing_loop_save AST.StatementIf( children = [ AST.ExpressionLogicalNot( children = [ - self[1] + self.children[1] ], unary_operator = 'not ' ), @@ -382,28 +382,28 @@ def translate_declaration_or_statement(self, context): context.lines.append( '{0:s}{1:s}\n'.format( context.indent, - self[0].translate_statement_expression(context) + self.children[0].translate_statement_expression(context) ) ) @method(AST.StatementFor) def translate_declaration_or_statement(self, context): - self[0].translate_declaration_or_statement(context) + self.children[0].translate_declaration_or_statement(context) context.lines.append( '{0:s}while {1:s}:\n'.format( context.indent, - self[1].translate_expression(context, 0) + self.children[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) + self.children[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) + self.children[2].translate_statement_expression(context) ) ) context.indent = indent_save @@ -412,42 +412,42 @@ 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.children[0].translate_expression(context, 0) ) ) indent_save = context.indent context.indent += ' ' - self[1].translate_declaration_or_statement(context) + self.children[1].translate_declaration_or_statement(context) context.indent = indent_save @method(AST.StatementIfElse) 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.children[0].translate_expression(context, 0) ) ) indent_save = context.indent context.indent += ' ' - self[1].translate_declaration_or_statement(context) + self.children[1].translate_declaration_or_statement(context) context.lines.append('{0:s}else:\n'.format(indent_save)) - self[2].translate_declaration_or_statement(context) + self.children[2].translate_declaration_or_statement(context) context.indent = indent_save @method(AST.StatementReturn) def translate_declaration_or_statement(self, context): context.lines.append( '{0:s}return {1:s}\n'.format( context.indent, - self[0].translate_expression(context, 0) + self.children[0].translate_expression(context, 0) ) ) @method(AST.StatementSwitch) def translate_declaration_or_statement(self, context): - assert isinstance(self[1], AST.StatementBlock) + assert isinstance(self.children[1], AST.StatementBlock) indent_save = context.indent context.indent += ' ' if_text = 'if' - for i in self[1][0]: + for i in self.children[1].children[0].children: if ( isinstance(i, AST.StatementCase) or isinstance(i, AST.StatementDefault) @@ -455,16 +455,16 @@ def translate_declaration_or_statement(self, context): if isinstance(i, AST.StatementCase): cond_expr = AST.ExpressionEqual( children = [ - self[0], - i[0] + self.children[0], + i.children[0] ], binary_operator = ' == ', precedence = 8 ) - j = i[1] + j = i.children[1] else: cond_expr = None - j = i[0] + j = i.children[0] if ( isinstance(j, AST.StatementCase) or isinstance(j, AST.StatementDefault) @@ -476,8 +476,8 @@ def translate_declaration_or_statement(self, context): cond_expr, AST.ExpressionEqual( children = [ - self[0], - j[0] + self.children[0], + j.children[0] ], binary_operator = ' == ', precedence = 8 @@ -486,10 +486,10 @@ def translate_declaration_or_statement(self, context): binary_operator = ' or ', precedence = 3 ) - j = j[1] + j = j.children[1] else: cond_expr = None - j = j[0] + j = j.children[0] if cond_expr is not None: assert if_text is not None context.lines.append( @@ -514,14 +514,14 @@ 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) + self.children[0].translate_expression(context, 0) ) ) indent_save = context.indent context.indent += ' ' enclosing_loop_save = context.enclosing_loop context.enclosing_loop = self - self[1].translate_declaration_or_statement(context) + self.children[1].translate_declaration_or_statement(context) context.enclosing_loop = enclosing_loop_save context.indent = indent_save @method(AST.StaticAssertDeclaration) @@ -538,16 +538,16 @@ def get_type_and_name(self, base_type): return base_type, '' @method(AST.DeclaratorArray) def get_type_and_name(self, base_type): - return self[0].get_type_and_name( + return self.children[0].get_type_and_name( AST.TypeArray( element_type = base_type, element_count = ( -1 - if isinstance(self[2], AST.ExpressionEmpty) else + if isinstance(self.children[2], AST.ExpressionEmpty) else # kludgey way, assuming not calculated size int( - element.get_text(self[2], 0), - 8 if element.get_text(self[2], 0)[:2] in octal_prefix else 0 + element.get_text(self.children[2], 0), + 8 if element.get_text(self.children[2], 0)[:2] in octal_prefix else 0 ) ) ) @@ -555,10 +555,10 @@ def get_type_and_name(self, base_type): @method(AST.DeclaratorFunction) def get_type_and_name(self, base_type): children = [] - for i in self[1]: - type, name = i[1].get_type_and_name(i[0].get_type()) + for i in self.children[1].children: + type, name = i.children[1].get_type_and_name(i.children[0].get_type()) children.append(AST.TypeFunction.Argument(type = type, name = name)) - return self[0].get_type_and_name( + return self.children[0].get_type_and_name( AST.TypeFunction( children = children, return_type = base_type, @@ -567,10 +567,10 @@ def get_type_and_name(self, base_type): ) @method(AST.DeclaratorIdentifier) def get_type_and_name(self, base_type): - return base_type, element.get_text(self[0], 0) + return base_type, element.get_text(self.children[0], 0) @method(AST.DeclaratorPointer) def get_type_and_name(self, base_type): - return self[1].get_type_and_name( + return self.children[1].get_type_and_name( AST.TypePointer(target_type = base_type) ) del get_type_and_name @@ -584,15 +584,15 @@ def translate_initializer_or_expression(self, context): return self.translate_expression(context, 0) @method(AST.DesignatorInitializer) def translate_initializer_or_expression(self, context): - assert isinstance(self[0], AST.DesignatorListEqualsEmpty) - return self[1].translate_initializer_or_expression(context) + assert isinstance(self.children[0], AST.DesignatorListEqualsEmpty) + return self.children[1].translate_initializer_or_expression(context) @method(AST.DesignatorInitializerList) def translate_initializer_or_expression(self, context): return '[{0:s}]'.format( ', '.join( [ i.translate_initializer_or_expression(context) - for i in self + for i in self.children ] ) ) @@ -607,7 +607,7 @@ def translate_expression(self, context, precedence): def translate_expression(self, context, precedence): if self.postfix: text = '{0:s}{1:s}'.format( - self[0].translate_expression(context, 14), + self.children[0].translate_expression(context, 14), self.unary_operator ) if 14 < precedence: @@ -615,7 +615,7 @@ def translate_expression(self, context, precedence): else: text = '{0:s}{1:s}'.format( self.unary_operator, - self[0].translate_expression(context, 13) + self.children[0].translate_expression(context, 13) ) if 13 < precedence: text = '({0:s})'.format(text) @@ -623,12 +623,12 @@ def translate_expression(self, context, precedence): @method(AST.ExpressionBinary) def translate_expression(self, context, precedence): text = '{0:s}{1:s}{2:s}'.format( - self[0].translate_expression( + self.children[0].translate_expression( context, self.precedence + int(self.right_to_left) ), self.binary_operator, - self[1].translate_expression( + self.children[1].translate_expression( context, self.precedence + int(not self.right_to_left) ) @@ -639,31 +639,31 @@ def translate_expression(self, context, precedence): @method(AST.ExpressionCall) 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]]) + self.children[0].translate_expression(context, 14), + ', '.join([i.translate_expression(context, 1) for i in self.children[1].children]) ) if 14 < precedence: text = '({0:s})'.format(text) return text @method(AST.ExpressionCast) def translate_expression(self, context, precedence): - type, _ = self[0][1].get_type_and_name(self[0][0].get_type()) + type, _ = self.children[0].children[1].get_type_and_name(self.children[0].children[0].get_type()) text = '{0:s}({1:s})'.format( type.translate_type(context), - self[1].translate_expression(context, 0) + self.children[1].translate_expression(context, 0) ) if 14 < precedence: text = '({0:s})'.format(text) return text @method(AST.ExpressionCharConstant) def translate_expression(self, context, precedence): - return 'ord(\'{0:s}\')'.format(element.get_text(self[0], 0)) + return 'ord(\'{0:s}\')'.format(element.get_text(self.children[0], 0)) @method(AST.ExpressionConditional) 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) + self.children[1].translate_expression(context, 3), + self.children[0].translate_expression(context, 0), + self.children[2].translate_expression(context, 2) ) if 2 < precedence: text = '({0:s})'.format(text) @@ -674,8 +674,8 @@ def translate_expression(self, context, precedence): @method(AST.ExpressionField) def translate_expression(self, context, precedence): text = '{0:s}.{1:s}'.format( - self[0].translate_expression(context, 14), - self[1].translate_identifier(context) + self.children[0].translate_expression(context, 14), + self.children[1].translate_identifier(context) ) if 14 < precedence: text = '({0:s})'.format(text) @@ -683,20 +683,20 @@ def translate_expression(self, context, precedence): @method(AST.ExpressionFieldDereference) def translate_expression(self, context, precedence): text = '{0:s}->{1:s}'.format( - self[0].translate_expression(context, 14), - self[1].translate_identifier(context) + self.children[0].translate_expression(context, 14), + self.children[1].translate_identifier(context) ) if 14 < precedence: text = '({0:s})'.format(text) return text @method(AST.ExpressionIdentifier) def translate_expression(self, context, precedence): - return self[0].translate_identifier(context) + return self.children[0].translate_identifier(context) @method(AST.ExpressionIndex) def translate_expression(self, context, precedence): text = '{0:s}[{1:s}]'.format( - self[0].translate_expression(context, 14), - self[1].translate_expression(context, 0) + self.children[0].translate_expression(context, 14), + self.children[1].translate_expression(context, 0) ) if 14 < precedence: text = '({0:s})'.format(text) @@ -709,7 +709,7 @@ def translate_expression(self, context, precedence): return text @method(AST.ExpressionSizeOfType) def translate_expression(self, context, precedence): - type, _ = self[0][1].get_type_and_name(self[0][0].get_type()) + type, _ = self.children[0].children[1].get_type_and_name(self.children[0].children[0].get_type()) return str(type.translate_size(context)) @method(AST.ExpressionStringLiteral) def translate_expression(self, context, precedence): @@ -720,7 +720,7 @@ def translate_expression(self, context, precedence): replace('\\"', '"'). replace('\'', '\\\'') ) - for i in self + for i in self.children ] ) del translate_expression @@ -733,16 +733,16 @@ def translate_statement_expression(self, context): return 'pass' @method(AST.ExpressionPostDecrement) def translate_statement_expression(self, context): - return '{0:s} -= 1'.format(self[0].translate_expression(context, 0)) + return '{0:s} -= 1'.format(self.children[0].translate_expression(context, 0)) @method(AST.ExpressionPostIncrement) def translate_statement_expression(self, context): - return '{0:s} += 1'.format(self[0].translate_expression(context, 0)) + return '{0:s} += 1'.format(self.children[0].translate_expression(context, 0)) @method(AST.ExpressionPreDecrement) def translate_statement_expression(self, context): - return '{0:s} -= 1'.format(self[0].translate_expression(context, 0)) + return '{0:s} -= 1'.format(self.children[0].translate_expression(context, 0)) @method(AST.ExpressionPreIncrement) def translate_statement_expression(self, context): - return '{0:s} += 1'.format(self[0].translate_expression(context, 0)) + return '{0:s} += 1'.format(self.children[0].translate_expression(context, 0)) del translate_statement_expression @method(AST.Type) @@ -877,9 +877,9 @@ def __str__(self): return 'function<{0:s} -> {1:s}>'.format( ( 'void' - if len(self) == 0 else + if len(self.children) == 0 else ', '.join( - [str(i) for i in self] + (['...'] if self.varargs else []) + [str(i) for i in self.children] + (['...'] if self.varargs else []) ) ), str(self.return_type) @@ -888,21 +888,21 @@ del __str__ @method(AST.BlockItemList) def translate_block_item_list(self, context): - for i in self: + for i in self.children: i.translate_declaration_or_statement(context) del translate_block_item_list @method(AST.DeclarationSpecifierList) def get_type(self): type_specifiers = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] - for i in self: + for i in self.children: if isinstance(i, AST.TypeSpecifier): type_specifiers[i.n] += 1 return type_specifiers_to_type[tuple(type_specifiers)] @method(AST.SpecifierQualifierList) def get_type(self): type_specifiers = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] - for i in self: + for i in self.children: if isinstance(i, AST.TypeSpecifier): type_specifiers[i.n] += 1 return type_specifiers_to_type[tuple(type_specifiers)] @@ -916,6 +916,6 @@ del translate_identifier @method(AST.TranslationUnit) def translate_translation_unit(self, context): - for i in self: + for i in self.children: i.translate_declaration_or_statement(context) del translate_translation_unit -- 2.34.1