Item if factory is None else factory
)
return result
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.Item({0:s})'.format(', '.join(params))
# GENERATE END
def post_process(
self,
self.eof_action = eof_action
def serialize(self, ref_list):
element.Element.serialize(self, ref_list)
- self.set('name', element.serialize_str(self.name))
- self.set('exclusive', element.serialize_bool(self.exclusive))
+ self.set(
+ 'name',
+ element.serialize_str(self.name)
+ )
+ self.set(
+ 'exclusive',
+ element.serialize_bool(self.exclusive)
+ )
self.set(
'rules',
- ' '.join([element.serialize_ref(i, ref_list) for i in self.rules])
+ ' '.join(
+ [
+ element.serialize_ref(i, ref_list)
+ for i in self.rules
+ ]
+ )
)
self.set(
'bol_rules',
- ' '.join([element.serialize_ref(i, ref_list) for i in self.bol_rules])
+ ' '.join(
+ [
+ element.serialize_ref(i, ref_list)
+ for i in self.bol_rules
+ ]
+ )
+ )
+ self.set(
+ 'eof_action',
+ element.serialize_int(self.eof_action)
)
- self.set('eof_action', element.serialize_int(self.eof_action))
def deserialize(self, ref_list):
element.Element.deserialize(self, ref_list)
self.name = element.deserialize_str(self.get('name', ''))
result.bol_rules = self.bol_rules
result.eof_action = self.eof_action
return result
- def repr_serialize(self, params):
- element.Element.repr_serialize(self, params)
- if self.name != '':
- params.append(
- 'name = {0:s}'.format(repr(self.name))
- )
- if self.exclusive != False:
- params.append(
- 'exclusive = {0:s}'.format(repr(self.exclusive))
- )
- if len(self.rules):
- params.append(
- 'rules = [{0:s}]'.format(
- ', '.join([repr(i) for i in self.rules])
- )
- )
- if len(self.bol_rules):
- params.append(
- 'bol_rules = [{0:s}]'.format(
- ', '.join([repr(i) for i in self.bol_rules])
- )
- )
- if self.eof_action != -1:
- params.append(
- 'eof_action = {0:s}'.format(repr(self.eof_action))
- )
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST.StartCondition({0:s})'.format(', '.join(params))
# GENERATE END
# syntax classes
String if factory is None else factory
)
return result
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST.String({0:s})'.format(', '.join(params))
# GENERATE END
class Text(element.Element):
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
def get_text(self):
return element.get_text(self, 0)
Name if factory is None else factory
)
return result
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST.Name({0:s})'.format(', '.join(params))
# GENERATE END
class Section1Or2(element.Element):
CodeBlock if factory is None else factory
)
return result
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST.Section1Or2.CodeBlock({0:s})'.format(', '.join(params))
# GENERATE END
def post_process(
self,
element.Element.serialize(self, ref_list)
self.set(
'code_blocks_text',
- ' '.join([element.serialize_ref(i, ref_list) for i in self.code_blocks_text])
+ ' '.join(
+ [
+ element.serialize_ref(i, ref_list)
+ for i in self.code_blocks_text
+ ]
+ )
)
def deserialize(self, ref_list):
element.Element.deserialize(self, ref_list)
)
result.code_blocks_text = self.code_blocks_text
return result
- def repr_serialize(self, params):
- element.Element.repr_serialize(self, params)
- if len(self.code_blocks_text):
- params.append(
- 'code_blocks_text = [{0:s}]'.format(
- ', '.join([repr(i) for i in self.code_blocks_text])
- )
- )
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST.Section1Or2({0:s})'.format(', '.join(params))
# GENERATE END
def post_process(
self,
Option if factory is None else factory
)
return result
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST.Section1.Options.Option({0:s})'.format(', '.join(params))
# GENERATE END
def post_process(self, section):
raise NotImplementedError
self.value = value
def serialize(self, ref_list):
AST.Section1.Options.Option.serialize(self, ref_list)
- self.set('value', element.serialize_bool(self.value))
+ self.set(
+ 'value',
+ element.serialize_bool(self.value)
+ )
def deserialize(self, ref_list):
AST.Section1.Options.Option.deserialize(self, ref_list)
self.value = element.deserialize_bool(self.get('value', 'false'))
)
result.value = self.value
return result
- def repr_serialize(self, params):
- AST.Section1.Options.Option.repr_serialize(self, params)
- if self.value != False:
- params.append(
- 'value = {0:s}'.format(repr(self.value))
- )
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST.Section1.Options.BoolOption({0:s})'.format(', '.join(params))
# GENERATE END
class Align(BoolOption):
Align if factory is None else factory
)
return result
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST.Section1.Options.Align({0:s})'.format(', '.join(params))
# GENERATE END
def post_process(self, section):
section.align = self.value
AlwaysInteractive if factory is None else factory
)
return result
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST.Section1.Options.AlwaysInteractive({0:s})'.format(', '.join(params))
# GENERATE END
def post_process(self, section):
section.always_interactive = self.value
Array if factory is None else factory
)
return result
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST.Section1.Options.Array({0:s})'.format(', '.join(params))
# GENERATE END
def post_process(self, section):
section.array = self.value
Backup if factory is None else factory
)
return result
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST.Section1.Options.Backup({0:s})'.format(', '.join(params))
# GENERATE END
def post_process(self, section):
section.backup = self.value
BisonBridge if factory is None else factory
)
return result
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST.Section1.Options.BisonBridge({0:s})'.format(', '.join(params))
# GENERATE END
def post_process(self, section):
section.bison_bridge = self.value
BisonLocations if factory is None else factory
)
return result
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST.Section1.Options.BisonLocations({0:s})'.format(', '.join(params))
# GENERATE END
def post_process(self, section):
section.bison_locations = self.value
Caseless if factory is None else factory
)
return result
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST.Section1.Options.Caseless({0:s})'.format(', '.join(params))
# GENERATE END
def post_process(self, section):
section.caseless = self.value
CPlusPlus if factory is None else factory
)
return result
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST.Section1.Options.CPlusPlus({0:s})'.format(', '.join(params))
# GENERATE END
def post_process(self, section):
section.c_plus_plus = self.value
Debug if factory is None else factory
)
return result
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST.Section1.Options.Debug({0:s})'.format(', '.join(params))
# GENERATE END
def post_process(self, section):
section.debug = self.value
Default if factory is None else factory
)
return result
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST.Section1.Options.Default({0:s})'.format(', '.join(params))
# GENERATE END
def post_process(self, section):
section.default = self.value
ECS if factory is None else factory
)
return result
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST.Section1.Options.ECS({0:s})'.format(', '.join(params))
# GENERATE END
def post_process(self, section):
section.ecs = self.value
ExtraType if factory is None else factory
)
return result
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST.Section1.Options.ExtraType({0:s})'.format(', '.join(params))
# GENERATE END
def post_process(self, section):
section.extra_type = self[0][0].get_text()
Fast if factory is None else factory
)
return result
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST.Section1.Options.Fast({0:s})'.format(', '.join(params))
# GENERATE END
def post_process(self, section):
section.fast = self.value
Full if factory is None else factory
)
return result
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST.Section1.Options.Full({0:s})'.format(', '.join(params))
# GENERATE END
def post_process(self, section):
section.full = self.value
HeaderFile if factory is None else factory
)
return result
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST.Section1.Options.HeaderFile({0:s})'.format(', '.join(params))
# GENERATE END
def post_process(self, section):
section.header_file = self[0][0].get_text()
Input if factory is None else factory
)
return result
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST.Section1.Options.Input({0:s})'.format(', '.join(params))
# GENERATE END
def post_process(self, section):
section.input = self.value
Interactive if factory is None else factory
)
return result
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST.Section1.Options.Interactive({0:s})'.format(', '.join(params))
# GENERATE END
def post_process(self, section):
section.interactive = self.value
LexCompat if factory is None else factory
)
return result
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST.Section1.Options.LexCompat({0:s})'.format(', '.join(params))
# GENERATE END
def post_process(self, section):
section.lex_compat = self.value
Line if factory is None else factory
)
return result
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST.Section1.Options.Line({0:s})'.format(', '.join(params))
# GENERATE END
def post_process(self, section):
section.line = self.value
Main if factory is None else factory
)
return result
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST.Section1.Options.Main({0:s})'.format(', '.join(params))
# GENERATE END
def post_process(self, section):
section.main = self.value
MetaECS if factory is None else factory
)
return result
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST.Section1.Options.MetaECS({0:s})'.format(', '.join(params))
# GENERATE END
def post_process(self, section):
section.meta_ecs = self.value
NeverInteractive if factory is None else factory
)
return result
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST.Section1.Options.NeverInteractive({0:s})'.format(', '.join(params))
# GENERATE END
def post_process(self, section):
section.never_interactive = self.value
OutFile if factory is None else factory
)
return result
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST.Section1.Options.OutFile({0:s})'.format(', '.join(params))
# GENERATE END
def post_process(self, section):
section.outfile = self[0][0].get_text()
PerfReport if factory is None else factory
)
return result
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST.Section1.Options.PerfReport({0:s})'.format(', '.join(params))
# GENERATE END
def post_process(self, section):
section.perf_report = self.value
PosixCompat if factory is None else factory
)
return result
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST.Section1.Options.PosixCompat({0:s})'.format(', '.join(params))
# GENERATE END
def post_process(self, section):
section.posix_compat = self.value
Prefix if factory is None else factory
)
return result
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST.Section1.Options.Prefix({0:s})'.format(', '.join(params))
# GENERATE END
def post_process(self, section):
section.prefix = self[0][0].get_text()
Read if factory is None else factory
)
return result
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST.Section1.Options.Read({0:s})'.format(', '.join(params))
# GENERATE END
def post_process(self, section):
section.read = self.value
Reentrant if factory is None else factory
)
return result
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST.Section1.Options.Reentrant({0:s})'.format(', '.join(params))
# GENERATE END
def post_process(self, section):
section.reentrant = self.value
Reject if factory is None else factory
)
return result
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST.Section1.Options.Reject({0:s})'.format(', '.join(params))
# GENERATE END
def post_process(self, section):
section.reject = self.value
SevenBit if factory is None else factory
)
return result
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST.Section1.Options.SevenBit({0:s})'.format(', '.join(params))
# GENERATE END
def post_process(self, section):
section.seven_bit = self.value
Stack if factory is None else factory
)
return result
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST.Section1.Options.Stack({0:s})'.format(', '.join(params))
# GENERATE END
def post_process(self, section):
section.stack = self.value
StdInit if factory is None else factory
)
return result
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST.Section1.Options.StdInit({0:s})'.format(', '.join(params))
# GENERATE END
def post_process(self, section):
section.stdinit = self.value
StdOut if factory is None else factory
)
return result
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST.Section1.Options.StdOut({0:s})'.format(', '.join(params))
# GENERATE END
def post_process(self, section):
section.stdout = self.value
TablesFile if factory is None else factory
)
return result
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST.Section1.Options.TablesFile({0:s})'.format(', '.join(params))
# GENERATE END
def post_process(self, section):
section.tables_file = self[0][0].get_text()
TablesVerify if factory is None else factory
)
return result
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST.Section1.Options.TablesVerify({0:s})'.format(', '.join(params))
# GENERATE END
def post_process(self, section):
section.tables_verify = self.value
UniStd if factory is None else factory
)
return result
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST.Section1.Options.UniStd({0:s})'.format(', '.join(params))
# GENERATE END
def post_process(self, section):
section.unistd = self.value
Unput if factory is None else factory
)
return result
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST.Section1.Options.Unput({0:s})'.format(', '.join(params))
# GENERATE END
def post_process(self, section):
section.unput = self.value
Verbose if factory is None else factory
)
return result
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST.Section1.Options.Verbose({0:s})'.format(', '.join(params))
# GENERATE END
def post_process(self, section):
section.verbose = self.value
Warn if factory is None else factory
)
return result
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST.Section1.Options.Warn({0:s})'.format(', '.join(params))
# GENERATE END
def post_process(self, section):
section.warn = self.value
YYAlloc if factory is None else factory
)
return result
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST.Section1.Options.YYAlloc({0:s})'.format(', '.join(params))
# GENERATE END
def post_process(self, section):
section.yyalloc = self.value
YYClass if factory is None else factory
)
return result
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST.Section1.Options.YYClass({0:s})'.format(', '.join(params))
# GENERATE END
def post_process(self, section):
section.yyclass = self[0][0].get_text()
YYFree if factory is None else factory
)
return result
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST.Section1.Options.YYFree({0:s})'.format(', '.join(params))
# GENERATE END
def post_process(self, section):
section.yyfree = self.value
YYGetDebug if factory is None else factory
)
return result
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST.Section1.Options.YYGetDebug({0:s})'.format(', '.join(params))
# GENERATE END
def post_process(self, section):
section.yyget_debug = self.value
YYGetExtra if factory is None else factory
)
return result
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST.Section1.Options.YYGetExtra({0:s})'.format(', '.join(params))
# GENERATE END
def post_process(self, section):
section.yyget_extra = self.value
YYGetIn if factory is None else factory
)
return result
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST.Section1.Options.YYGetIn({0:s})'.format(', '.join(params))
# GENERATE END
def post_process(self, section):
section.yyget_in = self.value
YYGetLeng if factory is None else factory
)
return result
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST.Section1.Options.YYGetLeng({0:s})'.format(', '.join(params))
# GENERATE END
def post_process(self, section):
section.yyget_leng = self.value
YYGetLineNo if factory is None else factory
)
return result
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST.Section1.Options.YYGetLineNo({0:s})'.format(', '.join(params))
# GENERATE END
def post_process(self, section):
section.yyget_lineno = self.value
YYGetLLoc if factory is None else factory
)
return result
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST.Section1.Options.YYGetLLoc({0:s})'.format(', '.join(params))
# GENERATE END
def post_process(self, section):
section.yyget_lloc = self.value
YYGetLVal if factory is None else factory
)
return result
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST.Section1.Options.YYGetLVal({0:s})'.format(', '.join(params))
# GENERATE END
def post_process(self, section):
section.yyget_lval = self.value
YYGetOut if factory is None else factory
)
return result
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST.Section1.Options.YYGetOut({0:s})'.format(', '.join(params))
# GENERATE END
def post_process(self, section):
section.yyget_out = self.value
YYGetText if factory is None else factory
)
return result
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST.Section1.Options.YYGetText({0:s})'.format(', '.join(params))
# GENERATE END
def post_process(self, section):
section.yyget_text = self.value
YYLineNo if factory is None else factory
)
return result
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST.Section1.Options.YYLineNo({0:s})'.format(', '.join(params))
# GENERATE END
def post_process(self, section):
section.yylineno = self.value
YYMore if factory is None else factory
)
return result
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST.Section1.Options.YYMore({0:s})'.format(', '.join(params))
# GENERATE END
def post_process(self, section):
section.yymore = self.value
YYPopState if factory is None else factory
)
return result
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST.Section1.Options.YYPopState({0:s})'.format(', '.join(params))
# GENERATE END
def post_process(self, section):
section.yy_pop_state = self.value
YYPushState if factory is None else factory
)
return result
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST.Section1.Options.YYPushState({0:s})'.format(', '.join(params))
# GENERATE END
def post_process(self, section):
section.yy_push_state = self.value
YYRealloc if factory is None else factory
)
return result
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST.Section1.Options.YYRealloc({0:s})'.format(', '.join(params))
# GENERATE END
def post_process(self, section):
section.yyrealloc = self.value
YYScanBuffer if factory is None else factory
)
return result
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST.Section1.Options.YYScanBuffer({0:s})'.format(', '.join(params))
# GENERATE END
def post_process(self, section):
section.yy_scan_buffer = self.value
YYScanBytes if factory is None else factory
)
return result
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST.Section1.Options.YYScanBytes({0:s})'.format(', '.join(params))
# GENERATE END
def post_process(self, section):
section.yy_scan_bytes = self.value
YYScanString if factory is None else factory
)
return result
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST.Section1.Options.YYScanString({0:s})'.format(', '.join(params))
# GENERATE END
def post_process(self, section):
section.yy_scan_string = self.value
YYSetDebug if factory is None else factory
)
return result
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST.Section1.Options.YYSetDebug({0:s})'.format(', '.join(params))
# GENERATE END
def post_process(self, section):
section.yyset_debug = self.value
YYSetExtra if factory is None else factory
)
return result
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST.Section1.Options.YYSetExtra({0:s})'.format(', '.join(params))
# GENERATE END
def post_process(self, section):
section.yyset_extra = self.value
YYSetIn if factory is None else factory
)
return result
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST.Section1.Options.YYSetIn({0:s})'.format(', '.join(params))
# GENERATE END
def post_process(self, section):
section.yyset_in = self.value
YYSetLineNo if factory is None else factory
)
return result
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST.Section1.Options.YYSetLineNo({0:s})'.format(', '.join(params))
# GENERATE END
def post_process(self, section):
section.yyset_lineno = self.value
YYSetLLoc if factory is None else factory
)
return result
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST.Section1.Options.YYSetLLoc({0:s})'.format(', '.join(params))
# GENERATE END
def post_process(self, section):
section.yyset_lloc = self.value
YYSetLVal if factory is None else factory
)
return result
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST.Section1.Options.YYSetLVal({0:s})'.format(', '.join(params))
# GENERATE END
def post_process(self, section):
section.yyset_lval = self.value
YYSetOut if factory is None else factory
)
return result
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST.Section1.Options.YYSetOut({0:s})'.format(', '.join(params))
# GENERATE END
def post_process(self, section):
section.yyset_out = self.value
YYTopState if factory is None else factory
)
return result
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST.Section1.Options.YYTopState({0:s})'.format(', '.join(params))
# GENERATE END
def post_process(self, section):
section.yy_top_state = self.value
YYWrap if factory is None else factory
)
return result
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST.Section1.Options.YYWrap({0:s})'.format(', '.join(params))
# GENERATE END
def post_process(self, section):
section.yywrap = self.value
Options if factory is None else factory
)
return result
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST.Section1.Options({0:s})'.format(', '.join(params))
# GENERATE END
def post_process(
self,
self.exclusive = exclusive
def serialize(self, ref_list):
Item.serialize(self, ref_list)
- self.set('exclusive', element.serialize_bool(self.exclusive))
+ self.set(
+ 'exclusive',
+ element.serialize_bool(self.exclusive)
+ )
def deserialize(self, ref_list):
Item.deserialize(self, ref_list)
self.exclusive = element.deserialize_bool(self.get('exclusive', 'false'))
)
result.exclusive = self.exclusive
return result
- def repr_serialize(self, params):
- Item.repr_serialize(self, params)
- if self.exclusive != False:
- params.append(
- 'exclusive = {0:s}'.format(repr(self.exclusive))
- )
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST.Section1.StartConditions({0:s})'.format(', '.join(params))
# GENERATE END
def post_process(
self,
self.yywrap = yywrap
def serialize(self, ref_list):
AST.Section1Or2.serialize(self, ref_list)
- self.set('align', element.serialize_bool(self.align))
- self.set('always_interactive', element.serialize_bool(self.always_interactive))
- self.set('array', element.serialize_bool(self.array))
- self.set('backup', element.serialize_bool(self.backup))
- self.set('bison_bridge', element.serialize_bool(self.bison_bridge))
- self.set('bison_locations', element.serialize_bool(self.bison_locations))
- self.set('caseless', element.serialize_bool(self.caseless))
- self.set('c_plus_plus', element.serialize_bool(self.c_plus_plus))
- self.set('debug', element.serialize_bool(self.debug))
- self.set('default', element.serialize_bool(self.default))
- self.set('ecs', element.serialize_bool(self.ecs))
- self.set('extra_type', element.serialize_str(self.extra_type))
- self.set('fast', element.serialize_bool(self.fast))
- self.set('full', element.serialize_bool(self.full))
- self.set('header_file', element.serialize_str(self.header_file))
- self.set('input', element.serialize_bool(self.input))
- self.set('interactive', element.serialize_bool(self.interactive))
- self.set('lex_compat', element.serialize_bool(self.lex_compat))
- self.set('line', element.serialize_bool(self.line))
- self.set('main', element.serialize_bool(self.main))
- self.set('meta_ecs', element.serialize_bool(self.meta_ecs))
- self.set('never_interactive', element.serialize_bool(self.never_interactive))
- self.set('outfile', element.serialize_str(self.outfile))
- self.set('perf_report', element.serialize_bool(self.perf_report))
- self.set('posix_compat', element.serialize_bool(self.posix_compat))
- self.set('prefix', element.serialize_str(self.prefix))
- self.set('read', element.serialize_bool(self.read))
- self.set('reentrant', element.serialize_bool(self.reentrant))
- self.set('reject', element.serialize_bool(self.reject))
- self.set('seven_bit', element.serialize_bool(self.seven_bit))
- self.set('stack', element.serialize_bool(self.stack))
- self.set('stdinit', element.serialize_bool(self.stdinit))
- self.set('stdout', element.serialize_bool(self.stdout))
- self.set('tables_file', element.serialize_str(self.tables_file))
- self.set('tables_verify', element.serialize_bool(self.tables_verify))
- self.set('unistd', element.serialize_bool(self.unistd))
- self.set('unput', element.serialize_bool(self.unput))
- self.set('verbose', element.serialize_bool(self.verbose))
- self.set('warn', element.serialize_bool(self.warn))
- self.set('yyalloc', element.serialize_bool(self.yyalloc))
- self.set('yyclass', element.serialize_str(self.yyclass))
- self.set('yyfree', element.serialize_bool(self.yyfree))
- self.set('yyget_debug', element.serialize_bool(self.yyget_debug))
- self.set('yyget_extra', element.serialize_bool(self.yyget_extra))
- self.set('yyget_in', element.serialize_bool(self.yyget_in))
- self.set('yyget_leng', element.serialize_bool(self.yyget_leng))
- self.set('yyget_lineno', element.serialize_bool(self.yyget_lineno))
- self.set('yyget_lloc', element.serialize_bool(self.yyget_lloc))
- self.set('yyget_lval', element.serialize_bool(self.yyget_lval))
- self.set('yyget_out', element.serialize_bool(self.yyget_out))
- self.set('yyget_text', element.serialize_bool(self.yyget_text))
- self.set('yylineno', element.serialize_bool(self.yylineno))
- self.set('yymore', element.serialize_bool(self.yymore))
- self.set('yy_pop_state', element.serialize_bool(self.yy_pop_state))
- self.set('yy_push_state', element.serialize_bool(self.yy_push_state))
- self.set('yyrealloc', element.serialize_bool(self.yyrealloc))
- self.set('yy_scan_buffer', element.serialize_bool(self.yy_scan_buffer))
- self.set('yy_scan_bytes', element.serialize_bool(self.yy_scan_bytes))
- self.set('yy_scan_string', element.serialize_bool(self.yy_scan_string))
- self.set('yyset_debug', element.serialize_bool(self.yyset_debug))
- self.set('yyset_extra', element.serialize_bool(self.yyset_extra))
- self.set('yyset_in', element.serialize_bool(self.yyset_in))
- self.set('yyset_lineno', element.serialize_bool(self.yyset_lineno))
- self.set('yyset_lloc', element.serialize_bool(self.yyset_lloc))
- self.set('yyset_lval', element.serialize_bool(self.yyset_lval))
- self.set('yyset_out', element.serialize_bool(self.yyset_out))
- self.set('yy_top_state', element.serialize_bool(self.yy_top_state))
- self.set('yywrap', element.serialize_bool(self.yywrap))
+ self.set(
+ 'align',
+ element.serialize_bool(self.align)
+ )
+ self.set(
+ 'always_interactive',
+ element.serialize_bool(self.always_interactive)
+ )
+ self.set(
+ 'array',
+ element.serialize_bool(self.array)
+ )
+ self.set(
+ 'backup',
+ element.serialize_bool(self.backup)
+ )
+ self.set(
+ 'bison_bridge',
+ element.serialize_bool(self.bison_bridge)
+ )
+ self.set(
+ 'bison_locations',
+ element.serialize_bool(self.bison_locations)
+ )
+ self.set(
+ 'caseless',
+ element.serialize_bool(self.caseless)
+ )
+ self.set(
+ 'c_plus_plus',
+ element.serialize_bool(self.c_plus_plus)
+ )
+ self.set(
+ 'debug',
+ element.serialize_bool(self.debug)
+ )
+ self.set(
+ 'default',
+ element.serialize_bool(self.default)
+ )
+ self.set(
+ 'ecs',
+ element.serialize_bool(self.ecs)
+ )
+ self.set(
+ 'extra_type',
+ element.serialize_str(self.extra_type)
+ )
+ self.set(
+ 'fast',
+ element.serialize_bool(self.fast)
+ )
+ self.set(
+ 'full',
+ element.serialize_bool(self.full)
+ )
+ self.set(
+ 'header_file',
+ element.serialize_str(self.header_file)
+ )
+ self.set(
+ 'input',
+ element.serialize_bool(self.input)
+ )
+ self.set(
+ 'interactive',
+ element.serialize_bool(self.interactive)
+ )
+ self.set(
+ 'lex_compat',
+ element.serialize_bool(self.lex_compat)
+ )
+ self.set(
+ 'line',
+ element.serialize_bool(self.line)
+ )
+ self.set(
+ 'main',
+ element.serialize_bool(self.main)
+ )
+ self.set(
+ 'meta_ecs',
+ element.serialize_bool(self.meta_ecs)
+ )
+ self.set(
+ 'never_interactive',
+ element.serialize_bool(self.never_interactive)
+ )
+ self.set(
+ 'outfile',
+ element.serialize_str(self.outfile)
+ )
+ self.set(
+ 'perf_report',
+ element.serialize_bool(self.perf_report)
+ )
+ self.set(
+ 'posix_compat',
+ element.serialize_bool(self.posix_compat)
+ )
+ self.set(
+ 'prefix',
+ element.serialize_str(self.prefix)
+ )
+ self.set(
+ 'read',
+ element.serialize_bool(self.read)
+ )
+ self.set(
+ 'reentrant',
+ element.serialize_bool(self.reentrant)
+ )
+ self.set(
+ 'reject',
+ element.serialize_bool(self.reject)
+ )
+ self.set(
+ 'seven_bit',
+ element.serialize_bool(self.seven_bit)
+ )
+ self.set(
+ 'stack',
+ element.serialize_bool(self.stack)
+ )
+ self.set(
+ 'stdinit',
+ element.serialize_bool(self.stdinit)
+ )
+ self.set(
+ 'stdout',
+ element.serialize_bool(self.stdout)
+ )
+ self.set(
+ 'tables_file',
+ element.serialize_str(self.tables_file)
+ )
+ self.set(
+ 'tables_verify',
+ element.serialize_bool(self.tables_verify)
+ )
+ self.set(
+ 'unistd',
+ element.serialize_bool(self.unistd)
+ )
+ self.set(
+ 'unput',
+ element.serialize_bool(self.unput)
+ )
+ self.set(
+ 'verbose',
+ element.serialize_bool(self.verbose)
+ )
+ self.set(
+ 'warn',
+ element.serialize_bool(self.warn)
+ )
+ self.set(
+ 'yyalloc',
+ element.serialize_bool(self.yyalloc)
+ )
+ self.set(
+ 'yyclass',
+ element.serialize_str(self.yyclass)
+ )
+ self.set(
+ 'yyfree',
+ element.serialize_bool(self.yyfree)
+ )
+ self.set(
+ 'yyget_debug',
+ element.serialize_bool(self.yyget_debug)
+ )
+ self.set(
+ 'yyget_extra',
+ element.serialize_bool(self.yyget_extra)
+ )
+ self.set(
+ 'yyget_in',
+ element.serialize_bool(self.yyget_in)
+ )
+ self.set(
+ 'yyget_leng',
+ element.serialize_bool(self.yyget_leng)
+ )
+ self.set(
+ 'yyget_lineno',
+ element.serialize_bool(self.yyget_lineno)
+ )
+ self.set(
+ 'yyget_lloc',
+ element.serialize_bool(self.yyget_lloc)
+ )
+ self.set(
+ 'yyget_lval',
+ element.serialize_bool(self.yyget_lval)
+ )
+ self.set(
+ 'yyget_out',
+ element.serialize_bool(self.yyget_out)
+ )
+ self.set(
+ 'yyget_text',
+ element.serialize_bool(self.yyget_text)
+ )
+ self.set(
+ 'yylineno',
+ element.serialize_bool(self.yylineno)
+ )
+ self.set(
+ 'yymore',
+ element.serialize_bool(self.yymore)
+ )
+ self.set(
+ 'yy_pop_state',
+ element.serialize_bool(self.yy_pop_state)
+ )
+ self.set(
+ 'yy_push_state',
+ element.serialize_bool(self.yy_push_state)
+ )
+ self.set(
+ 'yyrealloc',
+ element.serialize_bool(self.yyrealloc)
+ )
+ self.set(
+ 'yy_scan_buffer',
+ element.serialize_bool(self.yy_scan_buffer)
+ )
+ self.set(
+ 'yy_scan_bytes',
+ element.serialize_bool(self.yy_scan_bytes)
+ )
+ self.set(
+ 'yy_scan_string',
+ element.serialize_bool(self.yy_scan_string)
+ )
+ self.set(
+ 'yyset_debug',
+ element.serialize_bool(self.yyset_debug)
+ )
+ self.set(
+ 'yyset_extra',
+ element.serialize_bool(self.yyset_extra)
+ )
+ self.set(
+ 'yyset_in',
+ element.serialize_bool(self.yyset_in)
+ )
+ self.set(
+ 'yyset_lineno',
+ element.serialize_bool(self.yyset_lineno)
+ )
+ self.set(
+ 'yyset_lloc',
+ element.serialize_bool(self.yyset_lloc)
+ )
+ self.set(
+ 'yyset_lval',
+ element.serialize_bool(self.yyset_lval)
+ )
+ self.set(
+ 'yyset_out',
+ element.serialize_bool(self.yyset_out)
+ )
+ self.set(
+ 'yy_top_state',
+ element.serialize_bool(self.yy_top_state)
+ )
+ self.set(
+ 'yywrap',
+ element.serialize_bool(self.yywrap)
+ )
def deserialize(self, ref_list):
AST.Section1Or2.deserialize(self, ref_list)
self.align = element.deserialize_bool(self.get('align', 'false'))
result.yy_top_state = self.yy_top_state
result.yywrap = self.yywrap
return result
- def repr_serialize(self, params):
- AST.Section1Or2.repr_serialize(self, params)
- if self.align != False:
- params.append(
- 'align = {0:s}'.format(repr(self.align))
- )
- if self.always_interactive != False:
- params.append(
- 'always_interactive = {0:s}'.format(repr(self.always_interactive))
- )
- if self.array != False:
- params.append(
- 'array = {0:s}'.format(repr(self.array))
- )
- if self.backup != False:
- params.append(
- 'backup = {0:s}'.format(repr(self.backup))
- )
- if self.bison_bridge != False:
- params.append(
- 'bison_bridge = {0:s}'.format(repr(self.bison_bridge))
- )
- if self.bison_locations != False:
- params.append(
- 'bison_locations = {0:s}'.format(repr(self.bison_locations))
- )
- if self.caseless != False:
- params.append(
- 'caseless = {0:s}'.format(repr(self.caseless))
- )
- if self.c_plus_plus != False:
- params.append(
- 'c_plus_plus = {0:s}'.format(repr(self.c_plus_plus))
- )
- if self.debug != False:
- params.append(
- 'debug = {0:s}'.format(repr(self.debug))
- )
- if self.default != False:
- params.append(
- 'default = {0:s}'.format(repr(self.default))
- )
- if self.ecs != False:
- params.append(
- 'ecs = {0:s}'.format(repr(self.ecs))
- )
- if self.extra_type != '':
- params.append(
- 'extra_type = {0:s}'.format(repr(self.extra_type))
- )
- if self.fast != False:
- params.append(
- 'fast = {0:s}'.format(repr(self.fast))
- )
- if self.full != False:
- params.append(
- 'full = {0:s}'.format(repr(self.full))
- )
- if self.header_file != '':
- params.append(
- 'header_file = {0:s}'.format(repr(self.header_file))
- )
- if self.input != False:
- params.append(
- 'input = {0:s}'.format(repr(self.input))
- )
- if self.interactive != False:
- params.append(
- 'interactive = {0:s}'.format(repr(self.interactive))
- )
- if self.lex_compat != False:
- params.append(
- 'lex_compat = {0:s}'.format(repr(self.lex_compat))
- )
- if self.line != False:
- params.append(
- 'line = {0:s}'.format(repr(self.line))
- )
- if self.main != False:
- params.append(
- 'main = {0:s}'.format(repr(self.main))
- )
- if self.meta_ecs != False:
- params.append(
- 'meta_ecs = {0:s}'.format(repr(self.meta_ecs))
- )
- if self.never_interactive != False:
- params.append(
- 'never_interactive = {0:s}'.format(repr(self.never_interactive))
- )
- if self.outfile != '':
- params.append(
- 'outfile = {0:s}'.format(repr(self.outfile))
- )
- if self.perf_report != False:
- params.append(
- 'perf_report = {0:s}'.format(repr(self.perf_report))
- )
- if self.posix_compat != False:
- params.append(
- 'posix_compat = {0:s}'.format(repr(self.posix_compat))
- )
- if self.prefix != '':
- params.append(
- 'prefix = {0:s}'.format(repr(self.prefix))
- )
- if self.read != False:
- params.append(
- 'read = {0:s}'.format(repr(self.read))
- )
- if self.reentrant != False:
- params.append(
- 'reentrant = {0:s}'.format(repr(self.reentrant))
- )
- if self.reject != False:
- params.append(
- 'reject = {0:s}'.format(repr(self.reject))
- )
- if self.seven_bit != False:
- params.append(
- 'seven_bit = {0:s}'.format(repr(self.seven_bit))
- )
- if self.stack != False:
- params.append(
- 'stack = {0:s}'.format(repr(self.stack))
- )
- if self.stdinit != False:
- params.append(
- 'stdinit = {0:s}'.format(repr(self.stdinit))
- )
- if self.stdout != False:
- params.append(
- 'stdout = {0:s}'.format(repr(self.stdout))
- )
- if self.tables_file != '':
- params.append(
- 'tables_file = {0:s}'.format(repr(self.tables_file))
- )
- if self.tables_verify != False:
- params.append(
- 'tables_verify = {0:s}'.format(repr(self.tables_verify))
- )
- if self.unistd != False:
- params.append(
- 'unistd = {0:s}'.format(repr(self.unistd))
- )
- if self.unput != False:
- params.append(
- 'unput = {0:s}'.format(repr(self.unput))
- )
- if self.verbose != False:
- params.append(
- 'verbose = {0:s}'.format(repr(self.verbose))
- )
- if self.warn != False:
- params.append(
- 'warn = {0:s}'.format(repr(self.warn))
- )
- if self.yyalloc != False:
- params.append(
- 'yyalloc = {0:s}'.format(repr(self.yyalloc))
- )
- if self.yyclass != '':
- params.append(
- 'yyclass = {0:s}'.format(repr(self.yyclass))
- )
- if self.yyfree != False:
- params.append(
- 'yyfree = {0:s}'.format(repr(self.yyfree))
- )
- if self.yyget_debug != False:
- params.append(
- 'yyget_debug = {0:s}'.format(repr(self.yyget_debug))
- )
- if self.yyget_extra != False:
- params.append(
- 'yyget_extra = {0:s}'.format(repr(self.yyget_extra))
- )
- if self.yyget_in != False:
- params.append(
- 'yyget_in = {0:s}'.format(repr(self.yyget_in))
- )
- if self.yyget_leng != False:
- params.append(
- 'yyget_leng = {0:s}'.format(repr(self.yyget_leng))
- )
- if self.yyget_lineno != False:
- params.append(
- 'yyget_lineno = {0:s}'.format(repr(self.yyget_lineno))
- )
- if self.yyget_lloc != False:
- params.append(
- 'yyget_lloc = {0:s}'.format(repr(self.yyget_lloc))
- )
- if self.yyget_lval != False:
- params.append(
- 'yyget_lval = {0:s}'.format(repr(self.yyget_lval))
- )
- if self.yyget_out != False:
- params.append(
- 'yyget_out = {0:s}'.format(repr(self.yyget_out))
- )
- if self.yyget_text != False:
- params.append(
- 'yyget_text = {0:s}'.format(repr(self.yyget_text))
- )
- if self.yylineno != False:
- params.append(
- 'yylineno = {0:s}'.format(repr(self.yylineno))
- )
- if self.yymore != False:
- params.append(
- 'yymore = {0:s}'.format(repr(self.yymore))
- )
- if self.yy_pop_state != False:
- params.append(
- 'yy_pop_state = {0:s}'.format(repr(self.yy_pop_state))
- )
- if self.yy_push_state != False:
- params.append(
- 'yy_push_state = {0:s}'.format(repr(self.yy_push_state))
- )
- if self.yyrealloc != False:
- params.append(
- 'yyrealloc = {0:s}'.format(repr(self.yyrealloc))
- )
- if self.yy_scan_buffer != False:
- params.append(
- 'yy_scan_buffer = {0:s}'.format(repr(self.yy_scan_buffer))
- )
- if self.yy_scan_bytes != False:
- params.append(
- 'yy_scan_bytes = {0:s}'.format(repr(self.yy_scan_bytes))
- )
- if self.yy_scan_string != False:
- params.append(
- 'yy_scan_string = {0:s}'.format(repr(self.yy_scan_string))
- )
- if self.yyset_debug != False:
- params.append(
- 'yyset_debug = {0:s}'.format(repr(self.yyset_debug))
- )
- if self.yyset_extra != False:
- params.append(
- 'yyset_extra = {0:s}'.format(repr(self.yyset_extra))
- )
- if self.yyset_in != False:
- params.append(
- 'yyset_in = {0:s}'.format(repr(self.yyset_in))
- )
- if self.yyset_lineno != False:
- params.append(
- 'yyset_lineno = {0:s}'.format(repr(self.yyset_lineno))
- )
- if self.yyset_lloc != False:
- params.append(
- 'yyset_lloc = {0:s}'.format(repr(self.yyset_lloc))
- )
- if self.yyset_lval != False:
- params.append(
- 'yyset_lval = {0:s}'.format(repr(self.yyset_lval))
- )
- if self.yyset_out != False:
- params.append(
- 'yyset_out = {0:s}'.format(repr(self.yyset_out))
- )
- if self.yy_top_state != False:
- params.append(
- 'yy_top_state = {0:s}'.format(repr(self.yy_top_state))
- )
- if self.yywrap != False:
- params.append(
- 'yywrap = {0:s}'.format(repr(self.yywrap))
- )
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST.Section1({0:s})'.format(', '.join(params))
# GENERATE END
def post_process(
self,
CompoundRule if factory is None else factory
)
return result
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST.Section2.CompoundRule({0:s})'.format(', '.join(params))
# GENERATE END
def post_process(
self,
self.continued = continued
def serialize(self, ref_list):
element.Element.serialize(self, ref_list)
- self.set('continued', element.serialize_bool(self.continued))
+ self.set(
+ 'continued',
+ element.serialize_bool(self.continued)
+ )
def deserialize(self, ref_list):
element.Element.deserialize(self, ref_list)
self.continued = element.deserialize_bool(self.get('continued', 'false'))
)
result.continued = self.continued
return result
- def repr_serialize(self, params):
- element.Element.repr_serialize(self, params)
- if self.continued != False:
- params.append(
- 'continued = {0:s}'.format(repr(self.continued))
- )
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST.Section2.Rule.Action({0:s})'.format(', '.join(params))
# GENERATE END
class EOFRule(element.Element):
EOFRule if factory is None else factory
)
return result
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST.Section2.Rule.EOFRule({0:s})'.format(', '.join(params))
# GENERATE END
def post_process(
self,
self.action = action
def serialize(self, ref_list):
element.Element.serialize(self, ref_list)
- self.set('bol', element.serialize_bool(self.bol))
- self.set('group_index', element.serialize_int(self.group_index))
+ self.set(
+ 'bol',
+ element.serialize_bool(self.bol)
+ )
+ self.set(
+ 'group_index',
+ element.serialize_int(self.group_index)
+ )
self.set(
'groups0',
- ' '.join([element.serialize_ref(i, ref_list) for i in self.groups0])
+ ' '.join(
+ [
+ element.serialize_ref(i, ref_list)
+ for i in self.groups0
+ ]
+ )
)
self.set(
'groups1',
- ' '.join([element.serialize_ref(i, ref_list) for i in self.groups1])
+ ' '.join(
+ [
+ element.serialize_ref(i, ref_list)
+ for i in self.groups1
+ ]
+ )
+ )
+ self.set(
+ 'action',
+ element.serialize_int(self.action)
)
- self.set('action', element.serialize_int(self.action))
def deserialize(self, ref_list):
element.Element.deserialize(self, ref_list)
self.bol = element.deserialize_bool(self.get('bol', 'false'))
result.groups1 = self.groups1
result.action = self.action
return result
- def repr_serialize(self, params):
- element.Element.repr_serialize(self, params)
- if self.bol != False:
- params.append(
- 'bol = {0:s}'.format(repr(self.bol))
- )
- if self.group_index != -1:
- params.append(
- 'group_index = {0:s}'.format(repr(self.group_index))
- )
- if len(self.groups0):
- params.append(
- 'groups0 = [{0:s}]'.format(
- ', '.join([repr(i) for i in self.groups0])
- )
- )
- if len(self.groups1):
- params.append(
- 'groups1 = [{0:s}]'.format(
- ', '.join([repr(i) for i in self.groups1])
- )
- )
- if self.action != -1:
- params.append(
- 'action = {0:s}'.format(repr(self.action))
- )
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST.Section2.Rule.FLexRule({0:s})'.format(', '.join(params))
# GENERATE END
def post_process(
self,
Rule if factory is None else factory
)
return result
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST.Section2.Rule({0:s})'.format(', '.join(params))
# GENERATE END
def post_process(
self,
self.wildcard = wildcard
def serialize(self, ref_list):
element.Element.serialize(self, ref_list)
- self.set('wildcard', element.serialize_bool(self.wildcard))
+ self.set(
+ 'wildcard',
+ element.serialize_bool(self.wildcard)
+ )
def deserialize(self, ref_list):
element.Element.deserialize(self, ref_list)
self.wildcard = element.deserialize_bool(self.get('wildcard', 'false'))
)
result.wildcard = self.wildcard
return result
- def repr_serialize(self, params):
- element.Element.repr_serialize(self, params)
- if self.wildcard != False:
- params.append(
- 'wildcard = {0:s}'.format(repr(self.wildcard))
- )
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST.Section2.StartConditions({0:s})'.format(', '.join(params))
# GENERATE END
# GENERATE ELEMENT() BEGIN
Section2 if factory is None else factory
)
return result
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST.Section2({0:s})'.format(', '.join(params))
# GENERATE END
class Section3(Text):
Section3 if factory is None else factory
)
return result
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST.Section3({0:s})'.format(', '.join(params))
# GENERATE END
# GENERATE ELEMENT(list(ref) start_conditions, list(ref) actions_text, list(ref) eof_actions_text, int default_action, list(ref) flex_rules, int n_groups) BEGIN
element.Element.serialize(self, ref_list)
self.set(
'start_conditions',
- ' '.join([element.serialize_ref(i, ref_list) for i in self.start_conditions])
+ ' '.join(
+ [
+ element.serialize_ref(i, ref_list)
+ for i in self.start_conditions
+ ]
+ )
)
self.set(
'actions_text',
- ' '.join([element.serialize_ref(i, ref_list) for i in self.actions_text])
+ ' '.join(
+ [
+ element.serialize_ref(i, ref_list)
+ for i in self.actions_text
+ ]
+ )
)
self.set(
'eof_actions_text',
- ' '.join([element.serialize_ref(i, ref_list) for i in self.eof_actions_text])
+ ' '.join(
+ [
+ element.serialize_ref(i, ref_list)
+ for i in self.eof_actions_text
+ ]
+ )
+ )
+ self.set(
+ 'default_action',
+ element.serialize_int(self.default_action)
)
- self.set('default_action', element.serialize_int(self.default_action))
self.set(
'flex_rules',
- ' '.join([element.serialize_ref(i, ref_list) for i in self.flex_rules])
+ ' '.join(
+ [
+ element.serialize_ref(i, ref_list)
+ for i in self.flex_rules
+ ]
+ )
+ )
+ self.set(
+ 'n_groups',
+ element.serialize_int(self.n_groups)
)
- self.set('n_groups', element.serialize_int(self.n_groups))
def deserialize(self, ref_list):
element.Element.deserialize(self, ref_list)
self.start_conditions = [
result.flex_rules = self.flex_rules
result.n_groups = self.n_groups
return result
- def repr_serialize(self, params):
- element.Element.repr_serialize(self, params)
- if len(self.start_conditions):
- params.append(
- 'start_conditions = [{0:s}]'.format(
- ', '.join([repr(i) for i in self.start_conditions])
- )
- )
- if len(self.actions_text):
- params.append(
- 'actions_text = [{0:s}]'.format(
- ', '.join([repr(i) for i in self.actions_text])
- )
- )
- if len(self.eof_actions_text):
- params.append(
- 'eof_actions_text = [{0:s}]'.format(
- ', '.join([repr(i) for i in self.eof_actions_text])
- )
- )
- if self.default_action != -1:
- params.append(
- 'default_action = {0:s}'.format(repr(self.default_action))
- )
- if len(self.flex_rules):
- params.append(
- 'flex_rules = [{0:s}]'.format(
- ', '.join([repr(i) for i in self.flex_rules])
- )
- )
- if self.n_groups != -1:
- params.append(
- 'n_groups = {0:s}'.format(repr(self.n_groups))
- )
- def __repr__(self):
- params = []
- self.repr_serialize(params)
- return 'ast.AST({0:s})'.format(', '.join(params))
# GENERATE END
def post_process(self):
public / pilex.git / commitdiff