Text if factory is None else factory
)
return result
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST.Text({0:s})'.format(', '.join(params))
# GENERATE END
class DeclarationOrStatement(element.Element):
DeclarationOrStatement 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))
# GENERATE END
def translate_declaration_or_statement(self, context):
#text = element.to_text(self).strip()
Statement 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))
# GENERATE END
class Declarator(element.Element):
Declarator 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))
# GENERATE END
def get_type_and_name(self, base_type):
print(self)
InitializerOrExpression if factory is None else factory
)
return result
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST.InitializerOrExpression({0:s})'.format(', '.join(params))
# GENERATE END
def translate_initializer_or_expression(self, context):
print(self)
Expression if factory is None else factory
)
return result
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST.Expression({0:s})'.format(', '.join(params))
# GENERATE END
def translate_expression(self, context, precedence):
#return element.to_text(self).strip()
self.postfix = 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))
+ 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', ''))
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.ExpressionUnary({0:s})'.format(', '.join(params))
# GENERATE END
def translate_expression(self, context, precedence):
if self.postfix:
self.right_to_left = 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))
+ 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', ''))
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(
Type if factory is None else factory
)
return result
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST.Type({0:s})'.format(', '.join(params))
# GENERATE END
def translate_size(self, context):
print(self)
TypeVoid if factory is None else factory
)
return result
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST.TypeVoid({0:s})'.format(', '.join(params))
# GENERATE END
def __str__(self):
return 'void'
self.bits = bits
def serialize(self, ref_list):
AST.Type.serialize(self, ref_list)
- self.set('signed', element.serialize_bool(self.signed))
- self.set('bits', element.serialize_int(self.bits))
+ self.set(
+ 'signed',
+ element.serialize_bool(self.signed)
+ )
+ self.set(
+ 'bits',
+ element.serialize_int(self.bits)
+ )
def deserialize(self, ref_list):
AST.Type.deserialize(self, ref_list)
self.signed = element.deserialize_bool(self.get('signed', 'false'))
result.signed = self.signed
result.bits = self.bits
return result
- def repr_serialize(self, params):
- AST.Type.repr_serialize(self, params)
- if self.signed != False:
- params.append(
- 'signed = {0:s}'.format(repr(self.signed))
- )
- if self.bits != -1:
- params.append(
- 'bits = {0:s}'.format(repr(self.bits))
- )
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST.TypeInt({0:s})'.format(', '.join(params))
# GENERATE END
def __str__(self):
return '{0:s}int{1:d}'.format(['u', ''][int(self.signed)], self.bits)
self.bits = bits
def serialize(self, ref_list):
AST.Type.serialize(self, ref_list)
- self.set('complex', element.serialize_int(self.complex))
- self.set('bits', element.serialize_int(self.bits))
+ self.set(
+ 'complex',
+ element.serialize_int(self.complex)
+ )
+ self.set(
+ 'bits',
+ element.serialize_int(self.bits)
+ )
def deserialize(self, ref_list):
AST.Type.deserialize(self, ref_list)
self.complex = element.deserialize_int(self.get('complex', '-1'))
result.complex = self.complex
result.bits = self.bits
return result
- def repr_serialize(self, params):
- AST.Type.repr_serialize(self, params)
- if self.complex != -1:
- params.append(
- 'complex = {0:s}'.format(repr(self.complex))
- )
- if self.bits != -1:
- params.append(
- 'bits = {0:s}'.format(repr(self.bits))
- )
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST.TypeFloat({0:s})'.format(', '.join(params))
# GENERATE END
def __str__(self):
return '{0:s}float{0:d}'.format(
TypeBool if factory is None else factory
)
return result
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST.TypeBool({0:s})'.format(', '.join(params))
# GENERATE END
def __str__(self):
return 'bool'
self.target_type = target_type
def serialize(self, ref_list):
AST.Type.serialize(self, ref_list)
- self.set('target_type', element.serialize_ref(self.target_type, ref_list))
+ self.set(
+ 'target_type',
+ element.serialize_ref(self.target_type, ref_list)
+ )
def deserialize(self, ref_list):
AST.Type.deserialize(self, ref_list)
self.target_type = element.deserialize_ref(self.get('target_type', '-1'), ref_list)
)
result.target_type = self.target_type
return result
- def repr_serialize(self, params):
- AST.Type.repr_serialize(self, params)
- if self.target_type != None:
- params.append(
- 'target_type = {0:s}'.format(repr(self.target_type))
- )
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST.TypePointer({0:s})'.format(', '.join(params))
# GENERATE END
def __str__(self):
return 'pointer<{0:s}>'.format(str(self.target_type))
self.element_count = element_count
def serialize(self, ref_list):
AST.Type.serialize(self, ref_list)
- self.set('element_type', element.serialize_ref(self.element_type, ref_list))
- self.set('element_count', element.serialize_int(self.element_count))
+ self.set(
+ 'element_type',
+ element.serialize_ref(self.element_type, ref_list)
+ )
+ self.set(
+ 'element_count',
+ element.serialize_int(self.element_count)
+ )
def deserialize(self, ref_list):
AST.Type.deserialize(self, ref_list)
self.element_type = element.deserialize_ref(self.get('element_type', '-1'), ref_list)
result.element_type = self.element_type
result.element_count = self.element_count
return result
- def repr_serialize(self, params):
- AST.Type.repr_serialize(self, params)
- if self.element_type != None:
- params.append(
- 'element_type = {0:s}'.format(repr(self.element_type))
- )
- if self.element_count != -1:
- params.append(
- 'element_count = {0:s}'.format(repr(self.element_count))
- )
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST.TypeArray({0:s})'.format(', '.join(params))
# GENERATE END
def __str__(self):
return 'array<{0:s}: {1:s}>'.format(
self.name = name
def serialize(self, ref_list):
element.Element.serialize(self, ref_list)
- self.set('type', element.serialize_ref(self.type, ref_list))
- self.set('name', element.serialize_str(self.name))
+ self.set(
+ 'type',
+ element.serialize_ref(self.type, ref_list)
+ )
+ self.set(
+ 'name',
+ element.serialize_str(self.name)
+ )
def deserialize(self, ref_list):
element.Element.deserialize(self, ref_list)
self.type = element.deserialize_ref(self.get('type', '-1'), ref_list)
result.type = self.type
result.name = self.name
return result
- def repr_serialize(self, params):
- element.Element.repr_serialize(self, params)
- if self.type != None:
- params.append(
- 'type = {0:s}'.format(repr(self.type))
- )
- if self.name != '':
- params.append(
- 'name = {0:s}'.format(repr(self.name))
- )
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST.TypeFunction.Argument({0:s})'.format(', '.join(params))
# GENERATE END
def __str__(self):
return '{0:s} {1:s}'.format(
self.varargs = varargs
def serialize(self, ref_list):
AST.Type.serialize(self, ref_list)
- self.set('return_type', element.serialize_ref(self.return_type, ref_list))
- self.set('varargs', element.serialize_bool(self.varargs))
+ self.set(
+ 'return_type',
+ element.serialize_ref(self.return_type, ref_list)
+ )
+ self.set(
+ 'varargs',
+ element.serialize_bool(self.varargs)
+ )
def deserialize(self, ref_list):
AST.Type.deserialize(self, ref_list)
self.return_type = element.deserialize_ref(self.get('return_type', '-1'), ref_list)
result.return_type = self.return_type
result.varargs = self.varargs
return result
- def repr_serialize(self, params):
- AST.Type.repr_serialize(self, params)
- if self.return_type != None:
- params.append(
- 'return_type = {0:s}'.format(repr(self.return_type))
- )
- if self.varargs != False:
- params.append(
- 'varargs = {0:s}'.format(repr(self.varargs))
- )
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST.TypeFunction({0:s})'.format(', '.join(params))
# GENERATE END
def __str__(self):
return 'function<{0:s} -> {1:s}>'.format(
AlignAsExpression if factory is None else factory
)
return result
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST.AlignAsExpression({0:s})'.format(', '.join(params))
# GENERATE END
class AlignAsType(element.Element):
AlignAsType if factory is None else factory
)
return result
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST.AlignAsType({0:s})'.format(', '.join(params))
# GENERATE END
class ArgumentExpressionList(element.Element):
ArgumentExpressionList if factory is None else factory
)
return result
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST.ArgumentExpressionList({0:s})'.format(', '.join(params))
# GENERATE END
class BlockItemList(element.Element):
BlockItemList if factory is None else factory
)
return result
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST.BlockItemList({0:s})'.format(', '.join(params))
# GENERATE END
def translate_block_item_list(self, context):
for i in self:
Declaration if factory is None else factory
)
return result
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST.Declaration({0:s})'.format(', '.join(params))
# GENERATE END
def translate_declaration_or_statement(self, context):
base_type = self[0].get_type()
DeclarationList if factory is None else factory
)
return result
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST.DeclarationList({0:s})'.format(', '.join(params))
# GENERATE END
class DeclarationSpecifierList(element.Element):
DeclarationSpecifierList if factory is None else factory
)
return result
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST.DeclarationSpecifierList({0:s})'.format(', '.join(params))
# GENERATE END
def get_type(self):
type_specifiers = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
DeclaratorAbstract if factory is None else factory
)
return result
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST.DeclaratorAbstract({0:s})'.format(', '.join(params))
# GENERATE END
def get_type_and_name(self, base_type):
return base_type, ''
DeclaratorArray if factory is None else factory
)
return result
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST.DeclaratorArray({0:s})'.format(', '.join(params))
# GENERATE END
def get_type_and_name(self, base_type):
return self[0].get_type_and_name(
DeclaratorEmpty if factory is None else factory
)
return result
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST.DeclaratorEmpty({0:s})'.format(', '.join(params))
# GENERATE END
class DeclaratorFunction(Declarator):
self.varargs = varargs
def serialize(self, ref_list):
AST.Declarator.serialize(self, ref_list)
- self.set('varargs', element.serialize_bool(self.varargs))
+ self.set(
+ 'varargs',
+ element.serialize_bool(self.varargs)
+ )
def deserialize(self, ref_list):
AST.Declarator.deserialize(self, ref_list)
self.varargs = element.deserialize_bool(self.get('varargs', 'false'))
)
result.varargs = self.varargs
return result
- def repr_serialize(self, params):
- AST.Declarator.repr_serialize(self, params)
- if self.varargs != False:
- params.append(
- 'varargs = {0:s}'.format(repr(self.varargs))
- )
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST.DeclaratorFunction({0:s})'.format(', '.join(params))
# GENERATE END
def get_type_and_name(self, base_type):
children = []
DeclaratorFunctionOldStyle if factory is None else factory
)
return result
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST.DeclaratorFunctionOldStyle({0:s})'.format(', '.join(params))
# GENERATE END
class DeclaratorIdentifier(Declarator):
DeclaratorIdentifier if factory is None else factory
)
return result
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST.DeclaratorIdentifier({0:s})'.format(', '.join(params))
# GENERATE END
def get_type_and_name(self, base_type):
return base_type, element.get_text(self[0], 0)
DeclaratorPointer if factory is None else factory
)
return result
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST.DeclaratorPointer({0:s})'.format(', '.join(params))
# GENERATE END
def get_type_and_name(self, base_type):
return self[1].get_type_and_name(
DefaultTypeName if factory is None else factory
)
return result
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST.DefaultTypeName({0:s})'.format(', '.join(params))
# GENERATE END
class DesignatorField(element.Element):
DesignatorField if factory is None else factory
)
return result
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST.DesignatorField({0:s})'.format(', '.join(params))
# GENERATE END
class DesignatorIndex(element.Element):
DesignatorIndex if factory is None else factory
)
return result
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST.DesignatorIndex({0:s})'.format(', '.join(params))
# GENERATE END
class DesignatorInitializer(InitializerOrExpression):
DesignatorInitializer if factory is None else factory
)
return result
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST.DesignatorInitializer({0:s})'.format(', '.join(params))
# GENERATE END
def translate_initializer_or_expression(self, context):
assert isinstance(self[0], AST.DesignatorListEqualsEmpty)
DesignatorInitializerList if factory is None else factory
)
return result
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST.DesignatorInitializerList({0:s})'.format(', '.join(params))
# GENERATE END
def translate_initializer_or_expression(self, context):
return '[{0:s}]'.format(
DesignatorListEqualsEmpty if factory is None else factory
)
return result
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST.DesignatorListEqualsEmpty({0:s})'.format(', '.join(params))
# GENERATE END
class DesignatorList(element.Element):
DesignatorList if factory is None else factory
)
return result
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST.DesignatorList({0:s})'.format(', '.join(params))
# GENERATE END
class EnumSpecifier(element.Element):
EnumSpecifier if factory is None else factory
)
return result
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST.EnumSpecifier({0:s})'.format(', '.join(params))
# GENERATE END
class Enumerator(element.Element):
Enumerator if factory is None else factory
)
return result
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST.Enumerator({0:s})'.format(', '.join(params))
# GENERATE END
class EnumeratorList(element.Element):
EnumeratorList if factory is None else factory
)
return result
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST.EnumeratorList({0:s})'.format(', '.join(params))
# GENERATE END
class EqualsInitializerEmpty(element.Element):
EqualsInitializerEmpty if factory is None else factory
)
return result
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST.EqualsInitializerEmpty({0:s})'.format(', '.join(params))
# GENERATE END
class ExpressionAdd(ExpressionBinary):
ExpressionAdd if factory is None else factory
)
return result
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST.ExpressionAdd({0:s})'.format(', '.join(params))
# GENERATE END
class ExpressionAddAssignment(ExpressionBinary):
ExpressionAddAssignment if factory is None else factory
)
return result
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST.ExpressionAddAssignment({0:s})'.format(', '.join(params))
# GENERATE END
class ExpressionAddressOf(ExpressionUnary):
ExpressionAddressOf if factory is None else factory
)
return result
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST.ExpressionAddressOf({0:s})'.format(', '.join(params))
# GENERATE END
class ExpressionAlignOfType(ExpressionUnary):
ExpressionAlignOfType if factory is None else factory
)
return result
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST.ExpressionAlignOfType({0:s})'.format(', '.join(params))
# GENERATE END
class ExpressionArray(Expression):
ExpressionArray if factory is None else factory
)
return result
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST.ExpressionArray({0:s})'.format(', '.join(params))
# GENERATE END
class ExpressionAssignment(ExpressionBinary):
ExpressionAssignment if factory is None else factory
)
return result
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST.ExpressionAssignment({0:s})'.format(', '.join(params))
# GENERATE END
class ExpressionAsterisk(Expression):
ExpressionAsterisk if factory is None else factory
)
return result
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST.ExpressionAsterisk({0:s})'.format(', '.join(params))
# GENERATE END
class ExpressionBitwiseAnd(ExpressionBinary):
ExpressionBitwiseAnd if factory is None else factory
)
return result
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST.ExpressionBitwiseAnd({0:s})'.format(', '.join(params))
# GENERATE END
class ExpressionBitwiseAndAssignment(ExpressionBinary):
ExpressionBitwiseAndAssignment if factory is None else factory
)
return result
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST.ExpressionBitwiseAndAssignment({0:s})'.format(', '.join(params))
# GENERATE END
class ExpressionBitwiseNot(ExpressionUnary):
ExpressionBitwiseNot if factory is None else factory
)
return result
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST.ExpressionBitwiseNot({0:s})'.format(', '.join(params))
# GENERATE END
class ExpressionBitwiseOr(ExpressionBinary):
ExpressionBitwiseOr if factory is None else factory
)
return result
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST.ExpressionBitwiseOr({0:s})'.format(', '.join(params))
# GENERATE END
class ExpressionBitwiseOrAssignment(ExpressionBinary):
ExpressionBitwiseOrAssignment if factory is None else factory
)
return result
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST.ExpressionBitwiseOrAssignment({0:s})'.format(', '.join(params))
# GENERATE END
class ExpressionCall(Expression):
ExpressionCall if factory is None else factory
)
return result
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST.ExpressionCall({0:s})'.format(', '.join(params))
# GENERATE END
def translate_expression(self, context, precedence):
text = '{0:s}({1:s})'.format(
ExpressionCast if factory is None else factory
)
return result
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST.ExpressionCast({0:s})'.format(', '.join(params))
# GENERATE END
def translate_expression(self, context, precedence):
type, _ = self[0][1].get_type_and_name(self[0][0].get_type())
ExpressionCharConstant if factory is None else factory
)
return result
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST.ExpressionCharConstant({0:s})'.format(', '.join(params))
# GENERATE END
def translate_expression(self, context, precedence):
return 'ord(\'{0:s}\')'.format(element.get_text(self[0], 0))
ExpressionComma if factory is None else factory
)
return result
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST.ExpressionComma({0:s})'.format(', '.join(params))
# GENERATE END
class ExpressionConditional(Expression):
ExpressionConditional if factory is None else factory
)
return result
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST.ExpressionConditional({0:s})'.format(', '.join(params))
# GENERATE END
def translate_expression(self, context, precedence):
text = '{0:s} if {1:s} else {2:s}'.format(
ExpressionDereference if factory is None else factory
)
return result
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST.ExpressionDereference({0:s})'.format(', '.join(params))
# GENERATE END
class ExpressionDivide(ExpressionBinary):
ExpressionDivide if factory is None else factory
)
return result
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST.ExpressionDivide({0:s})'.format(', '.join(params))
# GENERATE END
class ExpressionDivideAssignment(ExpressionBinary):
ExpressionDivideAssignment if factory is None else factory
)
return result
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST.ExpressionDivideAssignment({0:s})'.format(', '.join(params))
# GENERATE END
class ExpressionEmpty(Expression):
ExpressionEmpty if factory is None else factory
)
return result
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST.ExpressionEmpty({0:s})'.format(', '.join(params))
# GENERATE END
def translate_expression(self, context, precedence):
return 'True'
ExpressionEqual if factory is None else factory
)
return result
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST.ExpressionEqual({0:s})'.format(', '.join(params))
# GENERATE END
class ExpressionExclusiveOr(ExpressionBinary):
ExpressionExclusiveOr if factory is None else factory
)
return result
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST.ExpressionExclusiveOr({0:s})'.format(', '.join(params))
# GENERATE END
class ExpressionExclusiveOrAssignment(ExpressionBinary):
ExpressionExclusiveOrAssignment if factory is None else factory
)
return result
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST.ExpressionExclusiveOrAssignment({0:s})'.format(', '.join(params))
# GENERATE END
class ExpressionField(Expression):
ExpressionField if factory is None else factory
)
return result
- def __repr__(self):
- params = []
- 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(
ExpressionFieldDereference if factory is None else factory
)
return result
- def __repr__(self):
- params = []
- 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(
ExpressionFloatLiteral if factory is None else factory
)
return result
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST.ExpressionFloatLiteral({0:s})'.format(', '.join(params))
# GENERATE END
class ExpressionFunctionName(Expression):
ExpressionFunctionName if factory is None else factory
)
return result
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST.ExpressionFunctionName({0:s})'.format(', '.join(params))
# GENERATE END
class ExpressionGreaterThan(ExpressionBinary):
ExpressionGreaterThan if factory is None else factory
)
return result
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST.ExpressionGreaterThan({0:s})'.format(', '.join(params))
# GENERATE END
class ExpressionGreaterThanOrEqual(ExpressionBinary):
ExpressionGreaterThanOrEqual if factory is None else factory
)
return result
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST.ExpressionGreaterThanOrEqual({0:s})'.format(', '.join(params))
# GENERATE END
class ExpressionIdentifier(Expression):
ExpressionIdentifier if factory is None else factory
)
return result
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST.ExpressionIdentifier({0:s})'.format(', '.join(params))
# GENERATE END
def translate_expression(self, context, precedence):
return self[0].translate_identifier(context)
ExpressionIndex if factory is None else factory
)
return result
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST.ExpressionIndex({0:s})'.format(', '.join(params))
# GENERATE END
def translate_expression(self, context, precedence):
text = '{0:s}[{1:s}]'.format(
ExpressionIntLiteral if factory is None else factory
)
return result
- def __repr__(self):
- params = []
- 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)
ExpressionLeftShiftAssignment if factory is None else factory
)
return result
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST.ExpressionLeftShiftAssignment({0:s})'.format(', '.join(params))
# GENERATE END
class ExpressionLessThan(ExpressionBinary):
ExpressionLessThan if factory is None else factory
)
return result
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST.ExpressionLessThan({0:s})'.format(', '.join(params))
# GENERATE END
class ExpressionLessThanOrEqual(ExpressionBinary):
ExpressionLessThanOrEqual if factory is None else factory
)
return result
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST.ExpressionLessThanOrEqual({0:s})'.format(', '.join(params))
# GENERATE END
class ExpressionLogicalAnd(ExpressionBinary):
ExpressionLogicalAnd if factory is None else factory
)
return result
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST.ExpressionLogicalAnd({0:s})'.format(', '.join(params))
# GENERATE END
class ExpressionLogicalNot(ExpressionUnary):
ExpressionLogicalNot if factory is None else factory
)
return result
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST.ExpressionLogicalNot({0:s})'.format(', '.join(params))
# GENERATE END
class ExpressionLogicalOr(ExpressionBinary):
ExpressionLogicalOr if factory is None else factory
)
return result
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST.ExpressionLogicalOr({0:s})'.format(', '.join(params))
# GENERATE END
class ExpressionMinus(ExpressionUnary):
ExpressionMinus if factory is None else factory
)
return result
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST.ExpressionMinus({0:s})'.format(', '.join(params))
# GENERATE END
class ExpressionModulo(ExpressionBinary):
ExpressionModulo if factory is None else factory
)
return result
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST.ExpressionModulo({0:s})'.format(', '.join(params))
# GENERATE END
class ExpressionModuloAssignment(ExpressionBinary):
ExpressionModuloAssignment if factory is None else factory
)
return result
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST.ExpressionModuloAssignment({0:s})'.format(', '.join(params))
# GENERATE END
class ExpressionMultiply(ExpressionBinary):
ExpressionMultiply if factory is None else factory
)
return result
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST.ExpressionMultiply({0:s})'.format(', '.join(params))
# GENERATE END
class ExpressionMultiplyAssignment(ExpressionBinary):
ExpressionMultiplyAssignment if factory is None else factory
)
return result
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST.ExpressionMultiplyAssignment({0:s})'.format(', '.join(params))
# GENERATE END
class ExpressionNotEqual(ExpressionBinary):
ExpressionNotEqual if factory is None else factory
)
return result
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST.ExpressionNotEqual({0:s})'.format(', '.join(params))
# GENERATE END
class ExpressionPlus(ExpressionUnary):
ExpressionPlus if factory is None else factory
)
return result
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST.ExpressionPlus({0:s})'.format(', '.join(params))
# GENERATE END
class ExpressionPostDecrement(ExpressionUnary):
ExpressionPostDecrement if factory is None else factory
)
return result
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST.ExpressionPostDecrement({0:s})'.format(', '.join(params))
# GENERATE END
def translate_statement_expression(self, context):
return '{0:s} -= 1'.format(self[0].translate_expression(context, 0))
ExpressionPostIncrement if factory is None else factory
)
return result
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST.ExpressionPostIncrement({0:s})'.format(', '.join(params))
# GENERATE END
def translate_statement_expression(self, context):
return '{0:s} += 1'.format(self[0].translate_expression(context, 0))
ExpressionPreDecrement if factory is None else factory
)
return result
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST.ExpressionPreDecrement({0:s})'.format(', '.join(params))
# GENERATE END
def translate_statement_expression(self, context):
return '{0:s} -= 1'.format(self[0].translate_expression(context, 0))
ExpressionPreIncrement if factory is None else factory
)
return result
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST.ExpressionPreIncrement({0:s})'.format(', '.join(params))
# GENERATE END
def translate_statement_expression(self, context):
return '{0:s} += 1'.format(self[0].translate_expression(context, 0))
ExpressionRightShiftAssignment if factory is None else factory
)
return result
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST.ExpressionRightShiftAssignment({0:s})'.format(', '.join(params))
# GENERATE END
class ExpressionShiftLeft(ExpressionBinary):
ExpressionShiftLeft if factory is None else factory
)
return result
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST.ExpressionShiftLeft({0:s})'.format(', '.join(params))
# GENERATE END
class ExpressionShiftRight(ExpressionBinary):
ExpressionShiftRight if factory is None else factory
)
return result
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST.ExpressionShiftRight({0:s})'.format(', '.join(params))
# GENERATE END
class ExpressionSizeOfExpression(ExpressionUnary):
ExpressionSizeOfExpression if factory is None else factory
)
return result
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST.ExpressionSizeOfExpression({0:s})'.format(', '.join(params))
# GENERATE END
class ExpressionSizeOfType(ExpressionUnary):
ExpressionSizeOfType if factory is None else factory
)
return result
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST.ExpressionSizeOfType({0:s})'.format(', '.join(params))
# GENERATE END
def translate_expression(self, context, precedence):
type, _ = self[0][1].get_type_and_name(self[0][0].get_type())
ExpressionStringLiteral if factory is None else factory
)
return result
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST.ExpressionStringLiteral({0:s})'.format(', '.join(params))
# GENERATE END
def translate_expression(self, context, precedence):
return ' '.join(
ExpressionSubtract if factory is None else factory
)
return result
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST.ExpressionSubtract({0:s})'.format(', '.join(params))
# GENERATE END
class ExpressionSubtractAssignment(ExpressionBinary):
ExpressionSubtractAssignment if factory is None else factory
)
return result
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST.ExpressionSubtractAssignment({0:s})'.format(', '.join(params))
# GENERATE END
class FunctionDefinition(DeclarationOrStatement):
FunctionDefinition if factory is None else factory
)
return result
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST.FunctionDefinition({0:s})'.format(', '.join(params))
# GENERATE END
def translate_declaration_or_statement(self, context):
type, name = self[1].get_type_and_name(self[0].get_type())
self.n = n
def serialize(self, ref_list):
element.Element.serialize(self, ref_list)
- self.set('n', element.serialize_int(self.n))
+ self.set(
+ 'n',
+ element.serialize_int(self.n)
+ )
def deserialize(self, ref_list):
element.Element.deserialize(self, ref_list)
self.n = element.deserialize_int(self.get('n', '-1'))
)
result.n = self.n
return result
- def repr_serialize(self, params):
- element.Element.repr_serialize(self, params)
- if self.n != -1:
- params.append(
- 'n = {0:s}'.format(repr(self.n))
- )
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST.FunctionSpecifier({0:s})'.format(', '.join(params))
# GENERATE END
class GenericAssociation(element.Element):
GenericAssociation if factory is None else factory
)
return result
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST.GenericAssociation({0:s})'.format(', '.join(params))
# GENERATE END
class GenericAssociationList(element.Element):
GenericAssociationList if factory is None else factory
)
return result
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST.GenericAssociationList({0:s})'.format(', '.join(params))
# GENERATE END
class GenericSelection(element.Element):
GenericSelection if factory is None else factory
)
return result
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST.GenericSelection({0:s})'.format(', '.join(params))
# GENERATE END
class Identifier(element.Element):
Identifier if factory is None else factory
)
return result
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST.Identifier({0:s})'.format(', '.join(params))
# GENERATE END
def translate_identifier(self, context):
text = element.get_text(self, 0)
IdentifierEmpty if factory is None else factory
)
return result
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST.IdentifierEmpty({0:s})'.format(', '.join(params))
# GENERATE END
class IdentifierList(element.Element):
IdentifierList if factory is None else factory
)
return result
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST.IdentifierList({0:s})'.format(', '.join(params))
# GENERATE END
class InitDeclarator(element.Element):
InitDeclarator if factory is None else factory
)
return result
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST.InitDeclarator({0:s})'.format(', '.join(params))
# GENERATE END
class InitDeclaratorList(element.Element):
InitDeclaratorList if factory is None else factory
)
return result
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST.InitDeclaratorList({0:s})'.format(', '.join(params))
# GENERATE END
class ParameterDeclaration(element.Element):
ParameterDeclaration if factory is None else factory
)
return result
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST.ParameterDeclaration({0:s})'.format(', '.join(params))
# GENERATE END
class ParameterDeclarationList(element.Element):
ParameterDeclarationList if factory is None else factory
)
return result
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST.ParameterDeclarationList({0:s})'.format(', '.join(params))
# GENERATE END
class SpecifierQualifierList(element.Element):
SpecifierQualifierList if factory is None else factory
)
return result
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST.SpecifierQualifierList({0:s})'.format(', '.join(params))
# GENERATE END
def get_type(self):
type_specifiers = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
StatementBlock if factory is None else factory
)
return result
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST.StatementBlock({0:s})'.format(', '.join(params))
# GENERATE END
def translate_declaration_or_statement(self, context):
if len(self[0]):
StatementBreak if factory is None else factory
)
return result
- def __repr__(self):
- params = []
- 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))
StatementCase if factory is None else factory
)
return result
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST.StatementCase({0:s})'.format(', '.join(params))
# GENERATE END
class StatementContinue(Statement):
StatementContinue if factory is None else factory
)
return result
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST.StatementContinue({0:s})'.format(', '.join(params))
# GENERATE END
def translate_declaration_or_statement(self, context):
enclosing_loop_save = context.enclosing_loop
StatementDefault if factory is None else factory
)
return result
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST.StatementDefault({0:s})'.format(', '.join(params))
# GENERATE END
class StatementDoWhile(Statement):
StatementDoWhile if factory is None else factory
)
return result
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST.StatementDoWhile({0:s})'.format(', '.join(params))
# GENERATE END
def translate_declaration_or_statement(self, context):
if (
StatementExpression if factory is None else factory
)
return result
- def __repr__(self):
- params = []
- 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(
StatementFor if factory is None else factory
)
return result
- def __repr__(self):
- params = []
- 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)
StatementGoto if factory is None else factory
)
return result
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST.StatementGoto({0:s})'.format(', '.join(params))
# GENERATE END
class StatementIf(Statement):
StatementIf if factory is None else factory
)
return result
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST.StatementIf({0:s})'.format(', '.join(params))
# GENERATE END
def translate_declaration_or_statement(self, context):
context.lines.append(
StatementIfElse if factory is None else factory
)
return result
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST.StatementIfElse({0:s})'.format(', '.join(params))
# GENERATE END
def translate_declaration_or_statement(self, context):
context.lines.append(
StatementLabel if factory is None else factory
)
return result
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST.StatementLabel({0:s})'.format(', '.join(params))
# GENERATE END
class StatementReturn(Statement):
StatementReturn if factory is None else factory
)
return result
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST.StatementReturn({0:s})'.format(', '.join(params))
# GENERATE END
def translate_declaration_or_statement(self, context):
context.lines.append(
StatementSwitch if factory is None else factory
)
return result
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST.StatementSwitch({0:s})'.format(', '.join(params))
# GENERATE END
def translate_declaration_or_statement(self, context):
assert isinstance(self[1], AST.StatementBlock)
StatementWhile if factory is None else factory
)
return result
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST.StatementWhile({0:s})'.format(', '.join(params))
# GENERATE END
def translate_declaration_or_statement(self, context):
context.lines.append(
StaticAssertDeclaration if factory is None else factory
)
return result
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST.StaticAssertDeclaration({0:s})'.format(', '.join(params))
# GENERATE END
def translate_declaration_or_statement(self, context):
pass
self.n = n
def serialize(self, ref_list):
element.Element.serialize(self, ref_list)
- self.set('n', element.serialize_int(self.n))
+ self.set(
+ 'n',
+ element.serialize_int(self.n)
+ )
def deserialize(self, ref_list):
element.Element.deserialize(self, ref_list)
self.n = element.deserialize_int(self.get('n', '-1'))
)
result.n = self.n
return result
- def repr_serialize(self, params):
- element.Element.repr_serialize(self, params)
- if self.n != -1:
- params.append(
- 'n = {0:s}'.format(repr(self.n))
- )
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST.StorageClassSpecifier({0:s})'.format(', '.join(params))
# GENERATE END
class StructDeclaration(element.Element):
StructDeclaration if factory is None else factory
)
return result
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST.StructDeclaration({0:s})'.format(', '.join(params))
# GENERATE END
class StructDeclarationList(element.Element):
StructDeclarationList if factory is None else factory
)
return result
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST.StructDeclarationList({0:s})'.format(', '.join(params))
# GENERATE END
class StructDeclarator(element.Element):
StructDeclarator if factory is None else factory
)
return result
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST.StructDeclarator({0:s})'.format(', '.join(params))
# GENERATE END
class StructDeclaratorList(element.Element):
StructDeclaratorList if factory is None else factory
)
return result
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST.StructDeclaratorList({0:s})'.format(', '.join(params))
# GENERATE END
class StructSpecifier(element.Element):
StructSpecifier if factory is None else factory
)
return result
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST.StructSpecifier({0:s})'.format(', '.join(params))
# GENERATE END
class TypeName(element.Element):
TypeName if factory is None else factory
)
return result
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST.TypeName({0:s})'.format(', '.join(params))
# GENERATE END
class TypeQualifier(element.Element):
self.n = n
def serialize(self, ref_list):
element.Element.serialize(self, ref_list)
- self.set('n', element.serialize_int(self.n))
+ self.set(
+ 'n',
+ element.serialize_int(self.n)
+ )
def deserialize(self, ref_list):
element.Element.deserialize(self, ref_list)
self.n = element.deserialize_int(self.get('n', '-1'))
)
result.n = self.n
return result
- def repr_serialize(self, params):
- element.Element.repr_serialize(self, params)
- if self.n != -1:
- params.append(
- 'n = {0:s}'.format(repr(self.n))
- )
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST.TypeQualifier({0:s})'.format(', '.join(params))
# GENERATE END
class TypeQualifierList(element.Element):
TypeQualifierList if factory is None else factory
)
return result
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST.TypeQualifierList({0:s})'.format(', '.join(params))
# GENERATE END
class TypeQualifierOrStaticList(element.Element):
TypeQualifierOrStaticList if factory is None else factory
)
return result
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST.TypeQualifierOrStaticList({0:s})'.format(', '.join(params))
# GENERATE END
class TypeSpecifier(element.Element):
self.n = n
def serialize(self, ref_list):
element.Element.serialize(self, ref_list)
- self.set('n', element.serialize_int(self.n))
+ self.set(
+ 'n',
+ element.serialize_int(self.n)
+ )
def deserialize(self, ref_list):
element.Element.deserialize(self, ref_list)
self.n = element.deserialize_int(self.get('n', '-1'))
)
result.n = self.n
return result
- def repr_serialize(self, params):
- element.Element.repr_serialize(self, params)
- if self.n != -1:
- params.append(
- 'n = {0:s}'.format(repr(self.n))
- )
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST.TypeSpecifier({0:s})'.format(', '.join(params))
# GENERATE END
class UnionSpecifier(element.Element):
UnionSpecifier if factory is None else factory
)
return result
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST.UnionSpecifier({0:s})'.format(', '.join(params))
# GENERATE END
class TranslationUnit(element.Element):
TranslationUnit if factory is None else factory
)
return result
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST.TranslationUnit({0:s})'.format(', '.join(params))
# GENERATE END
def translate_translation_unit(self, context):
for i in self:
AST if factory is None else factory
)
return result
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST({0:s})'.format(', '.join(params))
# GENERATE END
# void char short int long float double signed unsigned bool complex imaginary