import element
import nfa
import regex
+import sys
class Item(element.Element):
# GENERATE ELEMENT() BEGIN
# GENERATE END
# syntax classes
+ class String(element.Element):
+ # GENERATE ELEMENT() BEGIN
+ def __init__(
+ self,
+ tag = 'PLex_String',
+ attrib = {},
+ text = '',
+ children = []
+ ):
+ element.Element.__init__(
+ self,
+ tag,
+ attrib,
+ text,
+ children
+ )
+ def copy(self, factory = None):
+ result = element.Element.copy(
+ self,
+ String if factory is None else factory
+ )
+ return result
+ def __repr__(self):
+ params = []
+ self.repr_serialize(params)
+ return 'ast.PLex.String({0:s})'.format(', '.join(params))
+ # GENERATE END
+
class Text(element.Element):
# GENERATE ELEMENT() BEGIN
def __init__(
)
assert not continued_action
- class Section1(Section1Or2):
- class Options(Item):
- class Option(element.Element):
+ class Section1(Section1Or2):
+ class Options(Item):
+ class Option(element.Element):
+ # GENERATE ELEMENT() BEGIN
+ def __init__(
+ self,
+ tag = 'PLex_Section1_Options_Option',
+ attrib = {},
+ text = '',
+ children = []
+ ):
+ element.Element.__init__(
+ self,
+ tag,
+ attrib,
+ text,
+ children
+ )
+ def copy(self, factory = None):
+ result = element.Element.copy(
+ self,
+ Option if factory is None else factory
+ )
+ return result
+ def __repr__(self):
+ params = []
+ self.repr_serialize(params)
+ return 'ast.PLex.Section1.Options.Option({0:s})'.format(', '.join(params))
+ # GENERATE END
+ def post_process(self, section):
+ raise NotImplementedException
+
+ class BoolOption(Option):
+ # GENERATE ELEMENT(bool value) BEGIN
+ def __init__(
+ self,
+ tag = 'PLex_Section1_Options_BoolOption',
+ attrib = {},
+ text = '',
+ children = [],
+ value = False
+ ):
+ PLex.Section1.Options.Option.__init__(
+ self,
+ tag,
+ attrib,
+ text,
+ children
+ )
+ self.value = (
+ element.deserialize_bool(value)
+ if isinstance(value, str) else
+ value
+ )
+ def serialize(self, ref_list):
+ PLex.Section1.Options.Option.serialize(self, ref_list)
+ self.set('value', element.serialize_bool(self.value))
+ def deserialize(self, ref_list):
+ PLex.Section1.Options.Option.deserialize(self, ref_list)
+ self.value = element.deserialize_bool(self.get('value', 'false'))
+ def copy(self, factory = None):
+ result = PLex.Section1.Options.Option.copy(
+ self,
+ BoolOption if factory is None else factory
+ )
+ result.value = self.value
+ return result
+ def repr_serialize(self, params):
+ PLex.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.PLex.Section1.Options.BoolOption({0:s})'.format(', '.join(params))
+ # GENERATE END
+
+ class Align(BoolOption):
+ # GENERATE ELEMENT() BEGIN
+ def __init__(
+ self,
+ tag = 'PLex_Section1_Options_Align',
+ attrib = {},
+ text = '',
+ children = [],
+ value = False
+ ):
+ PLex.Section1.Options.BoolOption.__init__(
+ self,
+ tag,
+ attrib,
+ text,
+ children,
+ value
+ )
+ def copy(self, factory = None):
+ result = PLex.Section1.Options.BoolOption.copy(
+ self,
+ Align if factory is None else factory
+ )
+ return result
+ def __repr__(self):
+ params = []
+ self.repr_serialize(params)
+ return 'ast.PLex.Section1.Options.Align({0:s})'.format(', '.join(params))
+ # GENERATE END
+ def post_process(self, section):
+ section.align = self.value
+
+ class AlwaysInteractive(BoolOption):
+ # GENERATE ELEMENT() BEGIN
+ def __init__(
+ self,
+ tag = 'PLex_Section1_Options_AlwaysInteractive',
+ attrib = {},
+ text = '',
+ children = [],
+ value = False
+ ):
+ PLex.Section1.Options.BoolOption.__init__(
+ self,
+ tag,
+ attrib,
+ text,
+ children,
+ value
+ )
+ def copy(self, factory = None):
+ result = PLex.Section1.Options.BoolOption.copy(
+ self,
+ AlwaysInteractive if factory is None else factory
+ )
+ return result
+ def __repr__(self):
+ params = []
+ self.repr_serialize(params)
+ return 'ast.PLex.Section1.Options.AlwaysInteractive({0:s})'.format(', '.join(params))
+ # GENERATE END
+ def post_process(self, section):
+ section.always_interactive = self.value
+
+ class Array(BoolOption):
+ # GENERATE ELEMENT() BEGIN
+ def __init__(
+ self,
+ tag = 'PLex_Section1_Options_Array',
+ attrib = {},
+ text = '',
+ children = [],
+ value = False
+ ):
+ PLex.Section1.Options.BoolOption.__init__(
+ self,
+ tag,
+ attrib,
+ text,
+ children,
+ value
+ )
+ def copy(self, factory = None):
+ result = PLex.Section1.Options.BoolOption.copy(
+ self,
+ Array if factory is None else factory
+ )
+ return result
+ def __repr__(self):
+ params = []
+ self.repr_serialize(params)
+ return 'ast.PLex.Section1.Options.Array({0:s})'.format(', '.join(params))
+ # GENERATE END
+ def post_process(self, section):
+ section.array = self.value
+
+ class Backup(BoolOption):
+ # GENERATE ELEMENT() BEGIN
+ def __init__(
+ self,
+ tag = 'PLex_Section1_Options_Backup',
+ attrib = {},
+ text = '',
+ children = [],
+ value = False
+ ):
+ PLex.Section1.Options.BoolOption.__init__(
+ self,
+ tag,
+ attrib,
+ text,
+ children,
+ value
+ )
+ def copy(self, factory = None):
+ result = PLex.Section1.Options.BoolOption.copy(
+ self,
+ Backup if factory is None else factory
+ )
+ return result
+ def __repr__(self):
+ params = []
+ self.repr_serialize(params)
+ return 'ast.PLex.Section1.Options.Backup({0:s})'.format(', '.join(params))
+ # GENERATE END
+ def post_process(self, section):
+ section.backup = self.value
+
+ class BisonBridge(BoolOption):
+ # GENERATE ELEMENT() BEGIN
+ def __init__(
+ self,
+ tag = 'PLex_Section1_Options_BisonBridge',
+ attrib = {},
+ text = '',
+ children = [],
+ value = False
+ ):
+ PLex.Section1.Options.BoolOption.__init__(
+ self,
+ tag,
+ attrib,
+ text,
+ children,
+ value
+ )
+ def copy(self, factory = None):
+ result = PLex.Section1.Options.BoolOption.copy(
+ self,
+ BisonBridge if factory is None else factory
+ )
+ return result
+ def __repr__(self):
+ params = []
+ self.repr_serialize(params)
+ return 'ast.PLex.Section1.Options.BisonBridge({0:s})'.format(', '.join(params))
+ # GENERATE END
+ def post_process(self, section):
+ section.bison_bridge = self.value
+
+ class BisonLocations(BoolOption):
+ # GENERATE ELEMENT() BEGIN
+ def __init__(
+ self,
+ tag = 'PLex_Section1_Options_BisonLocations',
+ attrib = {},
+ text = '',
+ children = [],
+ value = False
+ ):
+ PLex.Section1.Options.BoolOption.__init__(
+ self,
+ tag,
+ attrib,
+ text,
+ children,
+ value
+ )
+ def copy(self, factory = None):
+ result = PLex.Section1.Options.BoolOption.copy(
+ self,
+ BisonLocations if factory is None else factory
+ )
+ return result
+ def __repr__(self):
+ params = []
+ self.repr_serialize(params)
+ return 'ast.PLex.Section1.Options.BisonLocations({0:s})'.format(', '.join(params))
+ # GENERATE END
+ def post_process(self, section):
+ section.bison_locations = self.value
+
+ class Caseless(BoolOption):
+ # GENERATE ELEMENT() BEGIN
+ def __init__(
+ self,
+ tag = 'PLex_Section1_Options_Caseless',
+ attrib = {},
+ text = '',
+ children = [],
+ value = False
+ ):
+ PLex.Section1.Options.BoolOption.__init__(
+ self,
+ tag,
+ attrib,
+ text,
+ children,
+ value
+ )
+ def copy(self, factory = None):
+ result = PLex.Section1.Options.BoolOption.copy(
+ self,
+ Caseless if factory is None else factory
+ )
+ return result
+ def __repr__(self):
+ params = []
+ self.repr_serialize(params)
+ return 'ast.PLex.Section1.Options.Caseless({0:s})'.format(', '.join(params))
+ # GENERATE END
+ def post_process(self, section):
+ section.caseless = self.value
+
+ class CPlusPlus(BoolOption):
+ # GENERATE ELEMENT() BEGIN
+ def __init__(
+ self,
+ tag = 'PLex_Section1_Options_CPlusPlus',
+ attrib = {},
+ text = '',
+ children = [],
+ value = False
+ ):
+ PLex.Section1.Options.BoolOption.__init__(
+ self,
+ tag,
+ attrib,
+ text,
+ children,
+ value
+ )
+ def copy(self, factory = None):
+ result = PLex.Section1.Options.BoolOption.copy(
+ self,
+ CPlusPlus if factory is None else factory
+ )
+ return result
+ def __repr__(self):
+ params = []
+ self.repr_serialize(params)
+ return 'ast.PLex.Section1.Options.CPlusPlus({0:s})'.format(', '.join(params))
+ # GENERATE END
+ def post_process(self, section):
+ section.c_plus_plus = self.value
+
+ class Debug(BoolOption):
+ # GENERATE ELEMENT() BEGIN
+ def __init__(
+ self,
+ tag = 'PLex_Section1_Options_Debug',
+ attrib = {},
+ text = '',
+ children = [],
+ value = False
+ ):
+ PLex.Section1.Options.BoolOption.__init__(
+ self,
+ tag,
+ attrib,
+ text,
+ children,
+ value
+ )
+ def copy(self, factory = None):
+ result = PLex.Section1.Options.BoolOption.copy(
+ self,
+ Debug if factory is None else factory
+ )
+ return result
+ def __repr__(self):
+ params = []
+ self.repr_serialize(params)
+ return 'ast.PLex.Section1.Options.Debug({0:s})'.format(', '.join(params))
+ # GENERATE END
+ def post_process(self, section):
+ section.debug = self.value
+
+ class Default(BoolOption):
+ # GENERATE ELEMENT() BEGIN
+ def __init__(
+ self,
+ tag = 'PLex_Section1_Options_Default',
+ attrib = {},
+ text = '',
+ children = [],
+ value = False
+ ):
+ PLex.Section1.Options.BoolOption.__init__(
+ self,
+ tag,
+ attrib,
+ text,
+ children,
+ value
+ )
+ def copy(self, factory = None):
+ result = PLex.Section1.Options.BoolOption.copy(
+ self,
+ Default if factory is None else factory
+ )
+ return result
+ def __repr__(self):
+ params = []
+ self.repr_serialize(params)
+ return 'ast.PLex.Section1.Options.Default({0:s})'.format(', '.join(params))
+ # GENERATE END
+ def post_process(self, section):
+ section.default = self.value
+
+ class ECS(BoolOption):
+ # GENERATE ELEMENT() BEGIN
+ def __init__(
+ self,
+ tag = 'PLex_Section1_Options_ECS',
+ attrib = {},
+ text = '',
+ children = [],
+ value = False
+ ):
+ PLex.Section1.Options.BoolOption.__init__(
+ self,
+ tag,
+ attrib,
+ text,
+ children,
+ value
+ )
+ def copy(self, factory = None):
+ result = PLex.Section1.Options.BoolOption.copy(
+ self,
+ ECS if factory is None else factory
+ )
+ return result
+ def __repr__(self):
+ params = []
+ self.repr_serialize(params)
+ return 'ast.PLex.Section1.Options.ECS({0:s})'.format(', '.join(params))
+ # GENERATE END
+ def post_process(self, section):
+ section.ecs = self.value
+
+ class ExtraType(BoolOption):
+ # GENERATE ELEMENT() BEGIN
+ def __init__(
+ self,
+ tag = 'PLex_Section1_Options_ExtraType',
+ attrib = {},
+ text = '',
+ children = [],
+ value = False
+ ):
+ PLex.Section1.Options.BoolOption.__init__(
+ self,
+ tag,
+ attrib,
+ text,
+ children,
+ value
+ )
+ def copy(self, factory = None):
+ result = PLex.Section1.Options.BoolOption.copy(
+ self,
+ ExtraType if factory is None else factory
+ )
+ return result
+ def __repr__(self):
+ params = []
+ self.repr_serialize(params)
+ return 'ast.PLex.Section1.Options.ExtraType({0:s})'.format(', '.join(params))
+ # GENERATE END
+ def post_process(self, section):
+ section.extra_type = self[0][0].get_text()
+
+ class Fast(BoolOption):
+ # GENERATE ELEMENT() BEGIN
+ def __init__(
+ self,
+ tag = 'PLex_Section1_Options_Fast',
+ attrib = {},
+ text = '',
+ children = [],
+ value = False
+ ):
+ PLex.Section1.Options.BoolOption.__init__(
+ self,
+ tag,
+ attrib,
+ text,
+ children,
+ value
+ )
+ def copy(self, factory = None):
+ result = PLex.Section1.Options.BoolOption.copy(
+ self,
+ Fast if factory is None else factory
+ )
+ return result
+ def __repr__(self):
+ params = []
+ self.repr_serialize(params)
+ return 'ast.PLex.Section1.Options.Fast({0:s})'.format(', '.join(params))
+ # GENERATE END
+ def post_process(self, section):
+ section.fast = self.value
+
+ class Full(BoolOption):
+ # GENERATE ELEMENT() BEGIN
+ def __init__(
+ self,
+ tag = 'PLex_Section1_Options_Full',
+ attrib = {},
+ text = '',
+ children = [],
+ value = False
+ ):
+ PLex.Section1.Options.BoolOption.__init__(
+ self,
+ tag,
+ attrib,
+ text,
+ children,
+ value
+ )
+ def copy(self, factory = None):
+ result = PLex.Section1.Options.BoolOption.copy(
+ self,
+ Full if factory is None else factory
+ )
+ return result
+ def __repr__(self):
+ params = []
+ self.repr_serialize(params)
+ return 'ast.PLex.Section1.Options.Full({0:s})'.format(', '.join(params))
+ # GENERATE END
+ def post_process(self, section):
+ section.full = self.value
+
+ class HeaderFile(BoolOption):
+ # GENERATE ELEMENT() BEGIN
+ def __init__(
+ self,
+ tag = 'PLex_Section1_Options_HeaderFile',
+ attrib = {},
+ text = '',
+ children = [],
+ value = False
+ ):
+ PLex.Section1.Options.BoolOption.__init__(
+ self,
+ tag,
+ attrib,
+ text,
+ children,
+ value
+ )
+ def copy(self, factory = None):
+ result = PLex.Section1.Options.BoolOption.copy(
+ self,
+ HeaderFile if factory is None else factory
+ )
+ return result
+ def __repr__(self):
+ params = []
+ self.repr_serialize(params)
+ return 'ast.PLex.Section1.Options.HeaderFile({0:s})'.format(', '.join(params))
+ # GENERATE END
+ def post_process(self, section):
+ section.header_file = self[0][0].get_text()
+
+ class Input(BoolOption):
+ # GENERATE ELEMENT() BEGIN
+ def __init__(
+ self,
+ tag = 'PLex_Section1_Options_Input',
+ attrib = {},
+ text = '',
+ children = [],
+ value = False
+ ):
+ PLex.Section1.Options.BoolOption.__init__(
+ self,
+ tag,
+ attrib,
+ text,
+ children,
+ value
+ )
+ def copy(self, factory = None):
+ result = PLex.Section1.Options.BoolOption.copy(
+ self,
+ Input if factory is None else factory
+ )
+ return result
+ def __repr__(self):
+ params = []
+ self.repr_serialize(params)
+ return 'ast.PLex.Section1.Options.Input({0:s})'.format(', '.join(params))
+ # GENERATE END
+ def post_process(self, section):
+ section.input = self.value
+
+ class Interactive(BoolOption):
+ # GENERATE ELEMENT() BEGIN
+ def __init__(
+ self,
+ tag = 'PLex_Section1_Options_Interactive',
+ attrib = {},
+ text = '',
+ children = [],
+ value = False
+ ):
+ PLex.Section1.Options.BoolOption.__init__(
+ self,
+ tag,
+ attrib,
+ text,
+ children,
+ value
+ )
+ def copy(self, factory = None):
+ result = PLex.Section1.Options.BoolOption.copy(
+ self,
+ Interactive if factory is None else factory
+ )
+ return result
+ def __repr__(self):
+ params = []
+ self.repr_serialize(params)
+ return 'ast.PLex.Section1.Options.Interactive({0:s})'.format(', '.join(params))
+ # GENERATE END
+ def post_process(self, section):
+ section.interactive = self.value
+
+ class LexCompat(BoolOption):
+ # GENERATE ELEMENT() BEGIN
+ def __init__(
+ self,
+ tag = 'PLex_Section1_Options_LexCompat',
+ attrib = {},
+ text = '',
+ children = [],
+ value = False
+ ):
+ PLex.Section1.Options.BoolOption.__init__(
+ self,
+ tag,
+ attrib,
+ text,
+ children,
+ value
+ )
+ def copy(self, factory = None):
+ result = PLex.Section1.Options.BoolOption.copy(
+ self,
+ LexCompat if factory is None else factory
+ )
+ return result
+ def __repr__(self):
+ params = []
+ self.repr_serialize(params)
+ return 'ast.PLex.Section1.Options.LexCompat({0:s})'.format(', '.join(params))
+ # GENERATE END
+ def post_process(self, section):
+ section.lex_compat = self.value
+
+ class Line(BoolOption):
+ # GENERATE ELEMENT() BEGIN
+ def __init__(
+ self,
+ tag = 'PLex_Section1_Options_Line',
+ attrib = {},
+ text = '',
+ children = [],
+ value = False
+ ):
+ PLex.Section1.Options.BoolOption.__init__(
+ self,
+ tag,
+ attrib,
+ text,
+ children,
+ value
+ )
+ def copy(self, factory = None):
+ result = PLex.Section1.Options.BoolOption.copy(
+ self,
+ Line if factory is None else factory
+ )
+ return result
+ def __repr__(self):
+ params = []
+ self.repr_serialize(params)
+ return 'ast.PLex.Section1.Options.Line({0:s})'.format(', '.join(params))
+ # GENERATE END
+ def post_process(self, section):
+ section.line = self.value
+
+ class Main(BoolOption):
+ # GENERATE ELEMENT() BEGIN
+ def __init__(
+ self,
+ tag = 'PLex_Section1_Options_Main',
+ attrib = {},
+ text = '',
+ children = [],
+ value = False
+ ):
+ PLex.Section1.Options.BoolOption.__init__(
+ self,
+ tag,
+ attrib,
+ text,
+ children,
+ value
+ )
+ def copy(self, factory = None):
+ result = PLex.Section1.Options.BoolOption.copy(
+ self,
+ Main if factory is None else factory
+ )
+ return result
+ def __repr__(self):
+ params = []
+ self.repr_serialize(params)
+ return 'ast.PLex.Section1.Options.Main({0:s})'.format(', '.join(params))
+ # GENERATE END
+ def post_process(self, section):
+ section.main = self.value
+
+ class MetaECS(BoolOption):
+ # GENERATE ELEMENT() BEGIN
+ def __init__(
+ self,
+ tag = 'PLex_Section1_Options_MetaECS',
+ attrib = {},
+ text = '',
+ children = [],
+ value = False
+ ):
+ PLex.Section1.Options.BoolOption.__init__(
+ self,
+ tag,
+ attrib,
+ text,
+ children,
+ value
+ )
+ def copy(self, factory = None):
+ result = PLex.Section1.Options.BoolOption.copy(
+ self,
+ MetaECS if factory is None else factory
+ )
+ return result
+ def __repr__(self):
+ params = []
+ self.repr_serialize(params)
+ return 'ast.PLex.Section1.Options.MetaECS({0:s})'.format(', '.join(params))
+ # GENERATE END
+ def post_process(self, section):
+ section.meta_ecs = self.value
+
+ class NeverInteractive(BoolOption):
+ # GENERATE ELEMENT() BEGIN
+ def __init__(
+ self,
+ tag = 'PLex_Section1_Options_NeverInteractive',
+ attrib = {},
+ text = '',
+ children = [],
+ value = False
+ ):
+ PLex.Section1.Options.BoolOption.__init__(
+ self,
+ tag,
+ attrib,
+ text,
+ children,
+ value
+ )
+ def copy(self, factory = None):
+ result = PLex.Section1.Options.BoolOption.copy(
+ self,
+ NeverInteractive if factory is None else factory
+ )
+ return result
+ def __repr__(self):
+ params = []
+ self.repr_serialize(params)
+ return 'ast.PLex.Section1.Options.NeverInteractive({0:s})'.format(', '.join(params))
+ # GENERATE END
+ def post_process(self, section):
+ section.never_interactive = self.value
+
+ class OutFile(BoolOption):
+ # GENERATE ELEMENT() BEGIN
+ def __init__(
+ self,
+ tag = 'PLex_Section1_Options_OutFile',
+ attrib = {},
+ text = '',
+ children = [],
+ value = False
+ ):
+ PLex.Section1.Options.BoolOption.__init__(
+ self,
+ tag,
+ attrib,
+ text,
+ children,
+ value
+ )
+ def copy(self, factory = None):
+ result = PLex.Section1.Options.BoolOption.copy(
+ self,
+ OutFile if factory is None else factory
+ )
+ return result
+ def __repr__(self):
+ params = []
+ self.repr_serialize(params)
+ return 'ast.PLex.Section1.Options.OutFile({0:s})'.format(', '.join(params))
+ # GENERATE END
+ def post_process(self, section):
+ section.outfile = self[0][0].get_text()
+
+ class PerfReport(BoolOption):
+ # GENERATE ELEMENT() BEGIN
+ def __init__(
+ self,
+ tag = 'PLex_Section1_Options_PerfReport',
+ attrib = {},
+ text = '',
+ children = [],
+ value = False
+ ):
+ PLex.Section1.Options.BoolOption.__init__(
+ self,
+ tag,
+ attrib,
+ text,
+ children,
+ value
+ )
+ def copy(self, factory = None):
+ result = PLex.Section1.Options.BoolOption.copy(
+ self,
+ PerfReport if factory is None else factory
+ )
+ return result
+ def __repr__(self):
+ params = []
+ self.repr_serialize(params)
+ return 'ast.PLex.Section1.Options.PerfReport({0:s})'.format(', '.join(params))
+ # GENERATE END
+ def post_process(self, section):
+ section.perf_report = self.value
+
+ class PosixCompat(BoolOption):
+ # GENERATE ELEMENT() BEGIN
+ def __init__(
+ self,
+ tag = 'PLex_Section1_Options_PosixCompat',
+ attrib = {},
+ text = '',
+ children = [],
+ value = False
+ ):
+ PLex.Section1.Options.BoolOption.__init__(
+ self,
+ tag,
+ attrib,
+ text,
+ children,
+ value
+ )
+ def copy(self, factory = None):
+ result = PLex.Section1.Options.BoolOption.copy(
+ self,
+ PosixCompat if factory is None else factory
+ )
+ return result
+ def __repr__(self):
+ params = []
+ self.repr_serialize(params)
+ return 'ast.PLex.Section1.Options.PosixCompat({0:s})'.format(', '.join(params))
+ # GENERATE END
+ def post_process(self, section):
+ section.posix_compat = self.value
+
+ class Prefix(BoolOption):
+ # GENERATE ELEMENT() BEGIN
+ def __init__(
+ self,
+ tag = 'PLex_Section1_Options_Prefix',
+ attrib = {},
+ text = '',
+ children = [],
+ value = False
+ ):
+ PLex.Section1.Options.BoolOption.__init__(
+ self,
+ tag,
+ attrib,
+ text,
+ children,
+ value
+ )
+ def copy(self, factory = None):
+ result = PLex.Section1.Options.BoolOption.copy(
+ self,
+ Prefix if factory is None else factory
+ )
+ return result
+ def __repr__(self):
+ params = []
+ self.repr_serialize(params)
+ return 'ast.PLex.Section1.Options.Prefix({0:s})'.format(', '.join(params))
+ # GENERATE END
+ def post_process(self, section):
+ section.prefix = self[0][0].get_text()
+
+ class Read(BoolOption):
+ # GENERATE ELEMENT() BEGIN
+ def __init__(
+ self,
+ tag = 'PLex_Section1_Options_Read',
+ attrib = {},
+ text = '',
+ children = [],
+ value = False
+ ):
+ PLex.Section1.Options.BoolOption.__init__(
+ self,
+ tag,
+ attrib,
+ text,
+ children,
+ value
+ )
+ def copy(self, factory = None):
+ result = PLex.Section1.Options.BoolOption.copy(
+ self,
+ Read if factory is None else factory
+ )
+ return result
+ def __repr__(self):
+ params = []
+ self.repr_serialize(params)
+ return 'ast.PLex.Section1.Options.Read({0:s})'.format(', '.join(params))
+ # GENERATE END
+ def post_process(self, section):
+ section.read = self.value
+
+ class Reentrant(BoolOption):
+ # GENERATE ELEMENT() BEGIN
+ def __init__(
+ self,
+ tag = 'PLex_Section1_Options_Reentrant',
+ attrib = {},
+ text = '',
+ children = [],
+ value = False
+ ):
+ PLex.Section1.Options.BoolOption.__init__(
+ self,
+ tag,
+ attrib,
+ text,
+ children,
+ value
+ )
+ def copy(self, factory = None):
+ result = PLex.Section1.Options.BoolOption.copy(
+ self,
+ Reentrant if factory is None else factory
+ )
+ return result
+ def __repr__(self):
+ params = []
+ self.repr_serialize(params)
+ return 'ast.PLex.Section1.Options.Reentrant({0:s})'.format(', '.join(params))
+ # GENERATE END
+ def post_process(self, section):
+ section.reentrant = self.value
+
+ class Reject(BoolOption):
+ # GENERATE ELEMENT() BEGIN
+ def __init__(
+ self,
+ tag = 'PLex_Section1_Options_Reject',
+ attrib = {},
+ text = '',
+ children = [],
+ value = False
+ ):
+ PLex.Section1.Options.BoolOption.__init__(
+ self,
+ tag,
+ attrib,
+ text,
+ children,
+ value
+ )
+ def copy(self, factory = None):
+ result = PLex.Section1.Options.BoolOption.copy(
+ self,
+ Reject if factory is None else factory
+ )
+ return result
+ def __repr__(self):
+ params = []
+ self.repr_serialize(params)
+ return 'ast.PLex.Section1.Options.Reject({0:s})'.format(', '.join(params))
+ # GENERATE END
+ def post_process(self, section):
+ section.reject = self.value
+
+ class SevenBit(BoolOption):
+ # GENERATE ELEMENT() BEGIN
+ def __init__(
+ self,
+ tag = 'PLex_Section1_Options_SevenBit',
+ attrib = {},
+ text = '',
+ children = [],
+ value = False
+ ):
+ PLex.Section1.Options.BoolOption.__init__(
+ self,
+ tag,
+ attrib,
+ text,
+ children,
+ value
+ )
+ def copy(self, factory = None):
+ result = PLex.Section1.Options.BoolOption.copy(
+ self,
+ SevenBit if factory is None else factory
+ )
+ return result
+ def __repr__(self):
+ params = []
+ self.repr_serialize(params)
+ return 'ast.PLex.Section1.Options.SevenBit({0:s})'.format(', '.join(params))
+ # GENERATE END
+ def post_process(self, section):
+ section.seven_bit = self.value
+
+ class Stack(BoolOption):
+ # GENERATE ELEMENT() BEGIN
+ def __init__(
+ self,
+ tag = 'PLex_Section1_Options_Stack',
+ attrib = {},
+ text = '',
+ children = [],
+ value = False
+ ):
+ PLex.Section1.Options.BoolOption.__init__(
+ self,
+ tag,
+ attrib,
+ text,
+ children,
+ value
+ )
+ def copy(self, factory = None):
+ result = PLex.Section1.Options.BoolOption.copy(
+ self,
+ Stack if factory is None else factory
+ )
+ return result
+ def __repr__(self):
+ params = []
+ self.repr_serialize(params)
+ return 'ast.PLex.Section1.Options.Stack({0:s})'.format(', '.join(params))
+ # GENERATE END
+ def post_process(self, section):
+ section.stack = self.value
+
+ class StdInit(BoolOption):
+ # GENERATE ELEMENT() BEGIN
+ def __init__(
+ self,
+ tag = 'PLex_Section1_Options_StdInit',
+ attrib = {},
+ text = '',
+ children = [],
+ value = False
+ ):
+ PLex.Section1.Options.BoolOption.__init__(
+ self,
+ tag,
+ attrib,
+ text,
+ children,
+ value
+ )
+ def copy(self, factory = None):
+ result = PLex.Section1.Options.BoolOption.copy(
+ self,
+ StdInit if factory is None else factory
+ )
+ return result
+ def __repr__(self):
+ params = []
+ self.repr_serialize(params)
+ return 'ast.PLex.Section1.Options.StdInit({0:s})'.format(', '.join(params))
+ # GENERATE END
+ def post_process(self, section):
+ section.stdinit = self.value
+
+ class StdOut(BoolOption):
+ # GENERATE ELEMENT() BEGIN
+ def __init__(
+ self,
+ tag = 'PLex_Section1_Options_StdOut',
+ attrib = {},
+ text = '',
+ children = [],
+ value = False
+ ):
+ PLex.Section1.Options.BoolOption.__init__(
+ self,
+ tag,
+ attrib,
+ text,
+ children,
+ value
+ )
+ def copy(self, factory = None):
+ result = PLex.Section1.Options.BoolOption.copy(
+ self,
+ StdOut if factory is None else factory
+ )
+ return result
+ def __repr__(self):
+ params = []
+ self.repr_serialize(params)
+ return 'ast.PLex.Section1.Options.StdOut({0:s})'.format(', '.join(params))
+ # GENERATE END
+ def post_process(self, section):
+ section.stdout = self.value
+
+ class TablesFile(BoolOption):
+ # GENERATE ELEMENT() BEGIN
+ def __init__(
+ self,
+ tag = 'PLex_Section1_Options_TablesFile',
+ attrib = {},
+ text = '',
+ children = [],
+ value = False
+ ):
+ PLex.Section1.Options.BoolOption.__init__(
+ self,
+ tag,
+ attrib,
+ text,
+ children,
+ value
+ )
+ def copy(self, factory = None):
+ result = PLex.Section1.Options.BoolOption.copy(
+ self,
+ TablesFile if factory is None else factory
+ )
+ return result
+ def __repr__(self):
+ params = []
+ self.repr_serialize(params)
+ return 'ast.PLex.Section1.Options.TablesFile({0:s})'.format(', '.join(params))
+ # GENERATE END
+ def post_process(self, section):
+ section.tables_file = self[0][0].get_text()
+
+ class TablesVerify(BoolOption):
+ # GENERATE ELEMENT() BEGIN
+ def __init__(
+ self,
+ tag = 'PLex_Section1_Options_TablesVerify',
+ attrib = {},
+ text = '',
+ children = [],
+ value = False
+ ):
+ PLex.Section1.Options.BoolOption.__init__(
+ self,
+ tag,
+ attrib,
+ text,
+ children,
+ value
+ )
+ def copy(self, factory = None):
+ result = PLex.Section1.Options.BoolOption.copy(
+ self,
+ TablesVerify if factory is None else factory
+ )
+ return result
+ def __repr__(self):
+ params = []
+ self.repr_serialize(params)
+ return 'ast.PLex.Section1.Options.TablesVerify({0:s})'.format(', '.join(params))
+ # GENERATE END
+ def post_process(self, section):
+ section.tables_verify = self.value
+
+ class UniStd(BoolOption):
+ # GENERATE ELEMENT() BEGIN
+ def __init__(
+ self,
+ tag = 'PLex_Section1_Options_UniStd',
+ attrib = {},
+ text = '',
+ children = [],
+ value = False
+ ):
+ PLex.Section1.Options.BoolOption.__init__(
+ self,
+ tag,
+ attrib,
+ text,
+ children,
+ value
+ )
+ def copy(self, factory = None):
+ result = PLex.Section1.Options.BoolOption.copy(
+ self,
+ UniStd if factory is None else factory
+ )
+ return result
+ def __repr__(self):
+ params = []
+ self.repr_serialize(params)
+ return 'ast.PLex.Section1.Options.UniStd({0:s})'.format(', '.join(params))
+ # GENERATE END
+ def post_process(self, section):
+ section.unistd = self.value
+
+ class Unput(BoolOption):
+ # GENERATE ELEMENT() BEGIN
+ def __init__(
+ self,
+ tag = 'PLex_Section1_Options_Unput',
+ attrib = {},
+ text = '',
+ children = [],
+ value = False
+ ):
+ PLex.Section1.Options.BoolOption.__init__(
+ self,
+ tag,
+ attrib,
+ text,
+ children,
+ value
+ )
+ def copy(self, factory = None):
+ result = PLex.Section1.Options.BoolOption.copy(
+ self,
+ Unput if factory is None else factory
+ )
+ return result
+ def __repr__(self):
+ params = []
+ self.repr_serialize(params)
+ return 'ast.PLex.Section1.Options.Unput({0:s})'.format(', '.join(params))
+ # GENERATE END
+ def post_process(self, section):
+ section.unput = self.value
+
+ class Verbose(BoolOption):
+ # GENERATE ELEMENT() BEGIN
+ def __init__(
+ self,
+ tag = 'PLex_Section1_Options_Verbose',
+ attrib = {},
+ text = '',
+ children = [],
+ value = False
+ ):
+ PLex.Section1.Options.BoolOption.__init__(
+ self,
+ tag,
+ attrib,
+ text,
+ children,
+ value
+ )
+ def copy(self, factory = None):
+ result = PLex.Section1.Options.BoolOption.copy(
+ self,
+ Verbose if factory is None else factory
+ )
+ return result
+ def __repr__(self):
+ params = []
+ self.repr_serialize(params)
+ return 'ast.PLex.Section1.Options.Verbose({0:s})'.format(', '.join(params))
+ # GENERATE END
+ def post_process(self, section):
+ section.verbose = self.value
+
+ class Warn(BoolOption):
+ # GENERATE ELEMENT() BEGIN
+ def __init__(
+ self,
+ tag = 'PLex_Section1_Options_Warn',
+ attrib = {},
+ text = '',
+ children = [],
+ value = False
+ ):
+ PLex.Section1.Options.BoolOption.__init__(
+ self,
+ tag,
+ attrib,
+ text,
+ children,
+ value
+ )
+ def copy(self, factory = None):
+ result = PLex.Section1.Options.BoolOption.copy(
+ self,
+ Warn if factory is None else factory
+ )
+ return result
+ def __repr__(self):
+ params = []
+ self.repr_serialize(params)
+ return 'ast.PLex.Section1.Options.Warn({0:s})'.format(', '.join(params))
+ # GENERATE END
+ def post_process(self, section):
+ section.warn = self.value
+
+ class YYAlloc(BoolOption):
+ # GENERATE ELEMENT() BEGIN
+ def __init__(
+ self,
+ tag = 'PLex_Section1_Options_YYAlloc',
+ attrib = {},
+ text = '',
+ children = [],
+ value = False
+ ):
+ PLex.Section1.Options.BoolOption.__init__(
+ self,
+ tag,
+ attrib,
+ text,
+ children,
+ value
+ )
+ def copy(self, factory = None):
+ result = PLex.Section1.Options.BoolOption.copy(
+ self,
+ YYAlloc if factory is None else factory
+ )
+ return result
+ def __repr__(self):
+ params = []
+ self.repr_serialize(params)
+ return 'ast.PLex.Section1.Options.YYAlloc({0:s})'.format(', '.join(params))
+ # GENERATE END
+ def post_process(self, section):
+ section.yyalloc = self.value
+
+ class YYClass(BoolOption):
+ # GENERATE ELEMENT() BEGIN
+ def __init__(
+ self,
+ tag = 'PLex_Section1_Options_YYClass',
+ attrib = {},
+ text = '',
+ children = [],
+ value = False
+ ):
+ PLex.Section1.Options.BoolOption.__init__(
+ self,
+ tag,
+ attrib,
+ text,
+ children,
+ value
+ )
+ def copy(self, factory = None):
+ result = PLex.Section1.Options.BoolOption.copy(
+ self,
+ YYClass if factory is None else factory
+ )
+ return result
+ def __repr__(self):
+ params = []
+ self.repr_serialize(params)
+ return 'ast.PLex.Section1.Options.YYClass({0:s})'.format(', '.join(params))
+ # GENERATE END
+ def post_process(self, section):
+ section.yyclass = self[0][0].get_text()
+
+ class YYFree(BoolOption):
+ # GENERATE ELEMENT() BEGIN
+ def __init__(
+ self,
+ tag = 'PLex_Section1_Options_YYFree',
+ attrib = {},
+ text = '',
+ children = [],
+ value = False
+ ):
+ PLex.Section1.Options.BoolOption.__init__(
+ self,
+ tag,
+ attrib,
+ text,
+ children,
+ value
+ )
+ def copy(self, factory = None):
+ result = PLex.Section1.Options.BoolOption.copy(
+ self,
+ YYFree if factory is None else factory
+ )
+ return result
+ def __repr__(self):
+ params = []
+ self.repr_serialize(params)
+ return 'ast.PLex.Section1.Options.YYFree({0:s})'.format(', '.join(params))
+ # GENERATE END
+ def post_process(self, section):
+ section.yyfree = self.value
+
+ class YYGetDebug(BoolOption):
+ # GENERATE ELEMENT() BEGIN
+ def __init__(
+ self,
+ tag = 'PLex_Section1_Options_YYGetDebug',
+ attrib = {},
+ text = '',
+ children = [],
+ value = False
+ ):
+ PLex.Section1.Options.BoolOption.__init__(
+ self,
+ tag,
+ attrib,
+ text,
+ children,
+ value
+ )
+ def copy(self, factory = None):
+ result = PLex.Section1.Options.BoolOption.copy(
+ self,
+ YYGetDebug if factory is None else factory
+ )
+ return result
+ def __repr__(self):
+ params = []
+ self.repr_serialize(params)
+ return 'ast.PLex.Section1.Options.YYGetDebug({0:s})'.format(', '.join(params))
+ # GENERATE END
+ def post_process(self, section):
+ section.yyget_debug = self.value
+
+ class YYGetExtra(BoolOption):
+ # GENERATE ELEMENT() BEGIN
+ def __init__(
+ self,
+ tag = 'PLex_Section1_Options_YYGetExtra',
+ attrib = {},
+ text = '',
+ children = [],
+ value = False
+ ):
+ PLex.Section1.Options.BoolOption.__init__(
+ self,
+ tag,
+ attrib,
+ text,
+ children,
+ value
+ )
+ def copy(self, factory = None):
+ result = PLex.Section1.Options.BoolOption.copy(
+ self,
+ YYGetExtra if factory is None else factory
+ )
+ return result
+ def __repr__(self):
+ params = []
+ self.repr_serialize(params)
+ return 'ast.PLex.Section1.Options.YYGetExtra({0:s})'.format(', '.join(params))
+ # GENERATE END
+ def post_process(self, section):
+ section.yyget_extra = self.value
+
+ class YYGetIn(BoolOption):
+ # GENERATE ELEMENT() BEGIN
+ def __init__(
+ self,
+ tag = 'PLex_Section1_Options_YYGetIn',
+ attrib = {},
+ text = '',
+ children = [],
+ value = False
+ ):
+ PLex.Section1.Options.BoolOption.__init__(
+ self,
+ tag,
+ attrib,
+ text,
+ children,
+ value
+ )
+ def copy(self, factory = None):
+ result = PLex.Section1.Options.BoolOption.copy(
+ self,
+ YYGetIn if factory is None else factory
+ )
+ return result
+ def __repr__(self):
+ params = []
+ self.repr_serialize(params)
+ return 'ast.PLex.Section1.Options.YYGetIn({0:s})'.format(', '.join(params))
+ # GENERATE END
+ def post_process(self, section):
+ section.yyget_in = self.value
+
+ class YYGetLeng(BoolOption):
+ # GENERATE ELEMENT() BEGIN
+ def __init__(
+ self,
+ tag = 'PLex_Section1_Options_YYGetLeng',
+ attrib = {},
+ text = '',
+ children = [],
+ value = False
+ ):
+ PLex.Section1.Options.BoolOption.__init__(
+ self,
+ tag,
+ attrib,
+ text,
+ children,
+ value
+ )
+ def copy(self, factory = None):
+ result = PLex.Section1.Options.BoolOption.copy(
+ self,
+ YYGetLeng if factory is None else factory
+ )
+ return result
+ def __repr__(self):
+ params = []
+ self.repr_serialize(params)
+ return 'ast.PLex.Section1.Options.YYGetLeng({0:s})'.format(', '.join(params))
+ # GENERATE END
+ def post_process(self, section):
+ section.yyget_leng = self.value
+
+ class YYGetLineNo(BoolOption):
+ # GENERATE ELEMENT() BEGIN
+ def __init__(
+ self,
+ tag = 'PLex_Section1_Options_YYGetLineNo',
+ attrib = {},
+ text = '',
+ children = [],
+ value = False
+ ):
+ PLex.Section1.Options.BoolOption.__init__(
+ self,
+ tag,
+ attrib,
+ text,
+ children,
+ value
+ )
+ def copy(self, factory = None):
+ result = PLex.Section1.Options.BoolOption.copy(
+ self,
+ YYGetLineNo if factory is None else factory
+ )
+ return result
+ def __repr__(self):
+ params = []
+ self.repr_serialize(params)
+ return 'ast.PLex.Section1.Options.YYGetLineNo({0:s})'.format(', '.join(params))
+ # GENERATE END
+ def post_process(self, section):
+ section.yyget_lineno = self.value
+
+ class YYGetLLoc(BoolOption):
+ # GENERATE ELEMENT() BEGIN
+ def __init__(
+ self,
+ tag = 'PLex_Section1_Options_YYGetLLoc',
+ attrib = {},
+ text = '',
+ children = [],
+ value = False
+ ):
+ PLex.Section1.Options.BoolOption.__init__(
+ self,
+ tag,
+ attrib,
+ text,
+ children,
+ value
+ )
+ def copy(self, factory = None):
+ result = PLex.Section1.Options.BoolOption.copy(
+ self,
+ YYGetLLoc if factory is None else factory
+ )
+ return result
+ def __repr__(self):
+ params = []
+ self.repr_serialize(params)
+ return 'ast.PLex.Section1.Options.YYGetLLoc({0:s})'.format(', '.join(params))
+ # GENERATE END
+ def post_process(self, section):
+ section.yyget_lloc = self.value
+
+ class YYGetLVal(BoolOption):
+ # GENERATE ELEMENT() BEGIN
+ def __init__(
+ self,
+ tag = 'PLex_Section1_Options_YYGetLVal',
+ attrib = {},
+ text = '',
+ children = [],
+ value = False
+ ):
+ PLex.Section1.Options.BoolOption.__init__(
+ self,
+ tag,
+ attrib,
+ text,
+ children,
+ value
+ )
+ def copy(self, factory = None):
+ result = PLex.Section1.Options.BoolOption.copy(
+ self,
+ YYGetLVal if factory is None else factory
+ )
+ return result
+ def __repr__(self):
+ params = []
+ self.repr_serialize(params)
+ return 'ast.PLex.Section1.Options.YYGetLVal({0:s})'.format(', '.join(params))
+ # GENERATE END
+ def post_process(self, section):
+ section.yyget_lval = self.value
+
+ class YYGetOut(BoolOption):
+ # GENERATE ELEMENT() BEGIN
+ def __init__(
+ self,
+ tag = 'PLex_Section1_Options_YYGetOut',
+ attrib = {},
+ text = '',
+ children = [],
+ value = False
+ ):
+ PLex.Section1.Options.BoolOption.__init__(
+ self,
+ tag,
+ attrib,
+ text,
+ children,
+ value
+ )
+ def copy(self, factory = None):
+ result = PLex.Section1.Options.BoolOption.copy(
+ self,
+ YYGetOut if factory is None else factory
+ )
+ return result
+ def __repr__(self):
+ params = []
+ self.repr_serialize(params)
+ return 'ast.PLex.Section1.Options.YYGetOut({0:s})'.format(', '.join(params))
+ # GENERATE END
+ def post_process(self, section):
+ section.yyget_out = self.value
+
+ class YYGetText(BoolOption):
+ # GENERATE ELEMENT() BEGIN
+ def __init__(
+ self,
+ tag = 'PLex_Section1_Options_YYGetText',
+ attrib = {},
+ text = '',
+ children = [],
+ value = False
+ ):
+ PLex.Section1.Options.BoolOption.__init__(
+ self,
+ tag,
+ attrib,
+ text,
+ children,
+ value
+ )
+ def copy(self, factory = None):
+ result = PLex.Section1.Options.BoolOption.copy(
+ self,
+ YYGetText if factory is None else factory
+ )
+ return result
+ def __repr__(self):
+ params = []
+ self.repr_serialize(params)
+ return 'ast.PLex.Section1.Options.YYGetText({0:s})'.format(', '.join(params))
+ # GENERATE END
+ def post_process(self, section):
+ section.yyget_text = self.value
+
+ class YYLineNo(BoolOption):
+ # GENERATE ELEMENT() BEGIN
+ def __init__(
+ self,
+ tag = 'PLex_Section1_Options_YYLineNo',
+ attrib = {},
+ text = '',
+ children = [],
+ value = False
+ ):
+ PLex.Section1.Options.BoolOption.__init__(
+ self,
+ tag,
+ attrib,
+ text,
+ children,
+ value
+ )
+ def copy(self, factory = None):
+ result = PLex.Section1.Options.BoolOption.copy(
+ self,
+ YYLineNo if factory is None else factory
+ )
+ return result
+ def __repr__(self):
+ params = []
+ self.repr_serialize(params)
+ return 'ast.PLex.Section1.Options.YYLineNo({0:s})'.format(', '.join(params))
+ # GENERATE END
+ def post_process(self, section):
+ section.yylineno = self.value
+
+ class YYMore(BoolOption):
+ # GENERATE ELEMENT() BEGIN
+ def __init__(
+ self,
+ tag = 'PLex_Section1_Options_YYMore',
+ attrib = {},
+ text = '',
+ children = [],
+ value = False
+ ):
+ PLex.Section1.Options.BoolOption.__init__(
+ self,
+ tag,
+ attrib,
+ text,
+ children,
+ value
+ )
+ def copy(self, factory = None):
+ result = PLex.Section1.Options.BoolOption.copy(
+ self,
+ YYMore if factory is None else factory
+ )
+ return result
+ def __repr__(self):
+ params = []
+ self.repr_serialize(params)
+ return 'ast.PLex.Section1.Options.YYMore({0:s})'.format(', '.join(params))
+ # GENERATE END
+ def post_process(self, section):
+ section.yymore = self.value
+
+ class YYPopState(BoolOption):
+ # GENERATE ELEMENT() BEGIN
+ def __init__(
+ self,
+ tag = 'PLex_Section1_Options_YYPopState',
+ attrib = {},
+ text = '',
+ children = [],
+ value = False
+ ):
+ PLex.Section1.Options.BoolOption.__init__(
+ self,
+ tag,
+ attrib,
+ text,
+ children,
+ value
+ )
+ def copy(self, factory = None):
+ result = PLex.Section1.Options.BoolOption.copy(
+ self,
+ YYPopState if factory is None else factory
+ )
+ return result
+ def __repr__(self):
+ params = []
+ self.repr_serialize(params)
+ return 'ast.PLex.Section1.Options.YYPopState({0:s})'.format(', '.join(params))
+ # GENERATE END
+ def post_process(self, section):
+ section.yy_pop_state = self.value
+
+ class YYPushState(BoolOption):
+ # GENERATE ELEMENT() BEGIN
+ def __init__(
+ self,
+ tag = 'PLex_Section1_Options_YYPushState',
+ attrib = {},
+ text = '',
+ children = [],
+ value = False
+ ):
+ PLex.Section1.Options.BoolOption.__init__(
+ self,
+ tag,
+ attrib,
+ text,
+ children,
+ value
+ )
+ def copy(self, factory = None):
+ result = PLex.Section1.Options.BoolOption.copy(
+ self,
+ YYPushState if factory is None else factory
+ )
+ return result
+ def __repr__(self):
+ params = []
+ self.repr_serialize(params)
+ return 'ast.PLex.Section1.Options.YYPushState({0:s})'.format(', '.join(params))
+ # GENERATE END
+ def post_process(self, section):
+ section.yy_push_state = self.value
+
+ class YYRealloc(BoolOption):
+ # GENERATE ELEMENT() BEGIN
+ def __init__(
+ self,
+ tag = 'PLex_Section1_Options_YYRealloc',
+ attrib = {},
+ text = '',
+ children = [],
+ value = False
+ ):
+ PLex.Section1.Options.BoolOption.__init__(
+ self,
+ tag,
+ attrib,
+ text,
+ children,
+ value
+ )
+ def copy(self, factory = None):
+ result = PLex.Section1.Options.BoolOption.copy(
+ self,
+ YYRealloc if factory is None else factory
+ )
+ return result
+ def __repr__(self):
+ params = []
+ self.repr_serialize(params)
+ return 'ast.PLex.Section1.Options.YYRealloc({0:s})'.format(', '.join(params))
+ # GENERATE END
+ def post_process(self, section):
+ section.yyrealloc = self.value
+
+ class YYScanBuffer(BoolOption):
# GENERATE ELEMENT() BEGIN
def __init__(
self,
- tag = 'PLex_Section1_Options_Option',
+ tag = 'PLex_Section1_Options_YYScanBuffer',
attrib = {},
text = '',
- children = []
+ children = [],
+ value = False
):
- element.Element.__init__(
+ PLex.Section1.Options.BoolOption.__init__(
self,
tag,
attrib,
text,
- children
+ children,
+ value
)
def copy(self, factory = None):
- result = element.Element.copy(
+ result = PLex.Section1.Options.BoolOption.copy(
self,
- Option if factory is None else factory
+ YYScanBuffer if factory is None else factory
)
return result
def __repr__(self):
params = []
self.repr_serialize(params)
- return 'ast.PLex.Section1.Options.Option({0:s})'.format(', '.join(params))
+ return 'ast.PLex.Section1.Options.YYScanBuffer({0:s})'.format(', '.join(params))
# GENERATE END
def post_process(self, section):
- raise NotImplementedException
+ section.yy_scan_buffer = self.value
- class BoolOption(Option):
- # GENERATE ELEMENT(bool value) BEGIN
+ class YYScanBytes(BoolOption):
+ # GENERATE ELEMENT() BEGIN
def __init__(
self,
- tag = 'PLex_Section1_Options_BoolOption',
+ tag = 'PLex_Section1_Options_YYScanBytes',
attrib = {},
text = '',
children = [],
value = False
):
- PLex.Section1.Options.Option.__init__(
+ PLex.Section1.Options.BoolOption.__init__(
self,
tag,
attrib,
text,
- children
- )
- self.value = (
- element.deserialize_bool(value)
- if isinstance(value, str) else
+ children,
value
)
- def serialize(self, ref_list):
- PLex.Section1.Options.Option.serialize(self, ref_list)
- self.set('value', element.serialize_bool(self.value))
- def deserialize(self, ref_list):
- PLex.Section1.Options.Option.deserialize(self, ref_list)
- self.value = element.deserialize_bool(self.get('value', 'false'))
def copy(self, factory = None):
- result = PLex.Section1.Options.Option.copy(
+ result = PLex.Section1.Options.BoolOption.copy(
self,
- BoolOption if factory is None else factory
+ YYScanBytes if factory is None else factory
)
- result.value = self.value
return result
- def repr_serialize(self, params):
- PLex.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.PLex.Section1.Options.BoolOption({0:s})'.format(', '.join(params))
+ return 'ast.PLex.Section1.Options.YYScanBytes({0:s})'.format(', '.join(params))
# GENERATE END
+ def post_process(self, section):
+ section.yy_scan_bytes = self.value
- class Caseless(BoolOption):
+ class YYScanString(BoolOption):
# GENERATE ELEMENT() BEGIN
def __init__(
self,
- tag = 'PLex_Section1_Options_Caseless',
+ tag = 'PLex_Section1_Options_YYScanString',
attrib = {},
text = '',
children = [],
def copy(self, factory = None):
result = PLex.Section1.Options.BoolOption.copy(
self,
- Caseless if factory is None else factory
+ YYScanString if factory is None else factory
)
return result
def __repr__(self):
params = []
self.repr_serialize(params)
- return 'ast.PLex.Section1.Options.Caseless({0:s})'.format(', '.join(params))
+ return 'ast.PLex.Section1.Options.YYScanString({0:s})'.format(', '.join(params))
# GENERATE END
def post_process(self, section):
- section.caseless = self.value
+ section.yy_scan_string = self.value
- class Default(BoolOption):
+ class YYSetDebug(BoolOption):
# GENERATE ELEMENT() BEGIN
def __init__(
self,
- tag = 'PLex_Section1_Options_Default',
+ tag = 'PLex_Section1_Options_YYSetDebug',
attrib = {},
text = '',
children = [],
def copy(self, factory = None):
result = PLex.Section1.Options.BoolOption.copy(
self,
- Default if factory is None else factory
+ YYSetDebug if factory is None else factory
)
return result
def __repr__(self):
params = []
self.repr_serialize(params)
- return 'ast.PLex.Section1.Options.Default({0:s})'.format(', '.join(params))
+ return 'ast.PLex.Section1.Options.YYSetDebug({0:s})'.format(', '.join(params))
# GENERATE END
def post_process(self, section):
- section.default = self.value
+ section.yyset_debug = self.value
- class ECS(BoolOption):
+ class YYSetExtra(BoolOption):
# GENERATE ELEMENT() BEGIN
def __init__(
self,
- tag = 'PLex_Section1_Options_ECS',
+ tag = 'PLex_Section1_Options_YYSetExtra',
attrib = {},
text = '',
children = [],
def copy(self, factory = None):
result = PLex.Section1.Options.BoolOption.copy(
self,
- ECS if factory is None else factory
+ YYSetExtra if factory is None else factory
)
return result
def __repr__(self):
params = []
self.repr_serialize(params)
- return 'ast.PLex.Section1.Options.ECS({0:s})'.format(', '.join(params))
+ return 'ast.PLex.Section1.Options.YYSetExtra({0:s})'.format(', '.join(params))
# GENERATE END
def post_process(self, section):
- section.ecs = self.value
+ section.yyset_extra = self.value
- class MetaECS(BoolOption):
+ class YYSetIn(BoolOption):
# GENERATE ELEMENT() BEGIN
def __init__(
self,
- tag = 'PLex_Section1_Options_MetaECS',
+ tag = 'PLex_Section1_Options_YYSetIn',
attrib = {},
text = '',
children = [],
def copy(self, factory = None):
result = PLex.Section1.Options.BoolOption.copy(
self,
- MetaECS if factory is None else factory
+ YYSetIn if factory is None else factory
)
return result
def __repr__(self):
params = []
self.repr_serialize(params)
- return 'ast.PLex.Section1.Options.MetaECS({0:s})'.format(', '.join(params))
+ return 'ast.PLex.Section1.Options.YYSetIn({0:s})'.format(', '.join(params))
# GENERATE END
def post_process(self, section):
- section.meta_ecs = self.value
+ section.yyset_in = self.value
- class Reject(BoolOption):
+ class YYSetLineNo(BoolOption):
# GENERATE ELEMENT() BEGIN
def __init__(
self,
- tag = 'PLex_Section1_Options_Reject',
+ tag = 'PLex_Section1_Options_YYSetLineNo',
attrib = {},
text = '',
children = [],
def copy(self, factory = None):
result = PLex.Section1.Options.BoolOption.copy(
self,
- Reject if factory is None else factory
+ YYSetLineNo if factory is None else factory
)
return result
def __repr__(self):
params = []
self.repr_serialize(params)
- return 'ast.PLex.Section1.Options.Reject({0:s})'.format(', '.join(params))
+ return 'ast.PLex.Section1.Options.YYSetLineNo({0:s})'.format(', '.join(params))
# GENERATE END
def post_process(self, section):
- section.reject = self.value
+ section.yyset_lineno = self.value
- class Stack(BoolOption):
+ class YYSetLLoc(BoolOption):
# GENERATE ELEMENT() BEGIN
def __init__(
self,
- tag = 'PLex_Section1_Options_Stack',
+ tag = 'PLex_Section1_Options_YYSetLLoc',
attrib = {},
text = '',
children = [],
def copy(self, factory = None):
result = PLex.Section1.Options.BoolOption.copy(
self,
- Stack if factory is None else factory
+ YYSetLLoc if factory is None else factory
)
return result
def __repr__(self):
params = []
self.repr_serialize(params)
- return 'ast.PLex.Section1.Options.Stack({0:s})'.format(', '.join(params))
+ return 'ast.PLex.Section1.Options.YYSetLLoc({0:s})'.format(', '.join(params))
# GENERATE END
def post_process(self, section):
- section.stack = self.value
+ section.yyset_lloc = self.value
- class StdInit(BoolOption):
+ class YYSetLVal(BoolOption):
# GENERATE ELEMENT() BEGIN
def __init__(
self,
- tag = 'PLex_Section1_Options_StdInit',
+ tag = 'PLex_Section1_Options_YYSetLVal',
attrib = {},
text = '',
children = [],
def copy(self, factory = None):
result = PLex.Section1.Options.BoolOption.copy(
self,
- StdInit if factory is None else factory
+ YYSetLVal if factory is None else factory
)
return result
def __repr__(self):
params = []
self.repr_serialize(params)
- return 'ast.PLex.Section1.Options.StdInit({0:s})'.format(', '.join(params))
+ return 'ast.PLex.Section1.Options.YYSetLVal({0:s})'.format(', '.join(params))
# GENERATE END
def post_process(self, section):
- section.std_init = self.value
+ section.yyset_lval = self.value
-
- class YYMore(BoolOption):
+ class YYSetOut(BoolOption):
# GENERATE ELEMENT() BEGIN
def __init__(
self,
- tag = 'PLex_Section1_Options_YYMore',
+ tag = 'PLex_Section1_Options_YYSetOut',
attrib = {},
text = '',
children = [],
def copy(self, factory = None):
result = PLex.Section1.Options.BoolOption.copy(
self,
- YYMore if factory is None else factory
+ YYSetOut if factory is None else factory
)
return result
def __repr__(self):
params = []
self.repr_serialize(params)
- return 'ast.PLex.Section1.Options.YYMore({0:s})'.format(', '.join(params))
+ return 'ast.PLex.Section1.Options.YYSetOut({0:s})'.format(', '.join(params))
# GENERATE END
def post_process(self, section):
- section.yymore = self.value
+ section.yyset_out = self.value
class YYTopState(BoolOption):
# GENERATE ELEMENT() BEGIN
)
return continued_action
- # GENERATE ELEMENT(bool caseless, bool default, bool ecs, bool meta_ecs, bool reject, bool stack, bool std_init, bool yymore, bool yy_top_state, bool yywrap) BEGIN
+ # GENERATE ELEMENT(bool align, bool always_interactive, bool array, bool backup, bool bison_bridge, bool bison_locations, bool caseless, bool c_plus_plus, bool debug, bool default, bool ecs, str extra_type, bool fast, bool full, str header_file, bool input, bool interactive, bool lex_compat, bool line, bool main, bool meta_ecs, bool never_interactive, str outfile, bool perf_report, bool posix_compat, str prefix, bool read, bool reentrant, bool reject, bool seven_bit, bool stack, bool stdinit, bool stdout, str tables_file, bool tables_verify, bool unistd, bool unput, bool verbose, bool warn, bool yyalloc, str yyclass, bool yyfree, bool yyget_debug, bool yyget_extra, bool yyget_in, bool yyget_leng, bool yyget_lineno, bool yyget_lloc, bool yyget_lval, bool yyget_out, bool yyget_text, bool yylineno, bool yymore, bool yy_pop_state, bool yy_push_state, bool yyrealloc, bool yy_scan_buffer, bool yy_scan_bytes, bool yy_scan_string, bool yyset_debug, bool yyset_extra, bool yyset_in, bool yyset_lineno, bool yyset_lloc, bool yyset_lval, bool yyset_out, bool yy_top_state, bool yywrap) BEGIN
def __init__(
self,
tag = 'PLex_Section1',
text = '',
children = [],
code_blocks_text = [],
+ align = False,
+ always_interactive = False,
+ array = False,
+ backup = False,
+ bison_bridge = False,
+ bison_locations = False,
caseless = False,
+ c_plus_plus = False,
+ debug = False,
default = False,
ecs = False,
+ extra_type = '',
+ fast = False,
+ full = False,
+ header_file = '',
+ input = False,
+ interactive = False,
+ lex_compat = False,
+ line = False,
+ main = False,
meta_ecs = False,
+ never_interactive = False,
+ outfile = '',
+ perf_report = False,
+ posix_compat = False,
+ prefix = '',
+ read = False,
+ reentrant = False,
reject = False,
+ seven_bit = False,
stack = False,
- std_init = False,
+ stdinit = False,
+ stdout = False,
+ tables_file = '',
+ tables_verify = False,
+ unistd = False,
+ unput = False,
+ verbose = False,
+ warn = False,
+ yyalloc = False,
+ yyclass = '',
+ yyfree = False,
+ yyget_debug = False,
+ yyget_extra = False,
+ yyget_in = False,
+ yyget_leng = False,
+ yyget_lineno = False,
+ yyget_lloc = False,
+ yyget_lval = False,
+ yyget_out = False,
+ yyget_text = False,
+ yylineno = False,
yymore = False,
+ yy_pop_state = False,
+ yy_push_state = False,
+ yyrealloc = False,
+ yy_scan_buffer = False,
+ yy_scan_bytes = False,
+ yy_scan_string = False,
+ yyset_debug = False,
+ yyset_extra = False,
+ yyset_in = False,
+ yyset_lineno = False,
+ yyset_lloc = False,
+ yyset_lval = False,
+ yyset_out = False,
yy_top_state = False,
yywrap = False
):
children,
code_blocks_text
)
+ self.align = (
+ element.deserialize_bool(align)
+ if isinstance(align, str) else
+ align
+ )
+ self.always_interactive = (
+ element.deserialize_bool(always_interactive)
+ if isinstance(always_interactive, str) else
+ always_interactive
+ )
+ self.array = (
+ element.deserialize_bool(array)
+ if isinstance(array, str) else
+ array
+ )
+ self.backup = (
+ element.deserialize_bool(backup)
+ if isinstance(backup, str) else
+ backup
+ )
+ self.bison_bridge = (
+ element.deserialize_bool(bison_bridge)
+ if isinstance(bison_bridge, str) else
+ bison_bridge
+ )
+ self.bison_locations = (
+ element.deserialize_bool(bison_locations)
+ if isinstance(bison_locations, str) else
+ bison_locations
+ )
self.caseless = (
element.deserialize_bool(caseless)
if isinstance(caseless, str) else
caseless
)
+ self.c_plus_plus = (
+ element.deserialize_bool(c_plus_plus)
+ if isinstance(c_plus_plus, str) else
+ c_plus_plus
+ )
+ self.debug = (
+ element.deserialize_bool(debug)
+ if isinstance(debug, str) else
+ debug
+ )
self.default = (
element.deserialize_bool(default)
if isinstance(default, str) else
if isinstance(ecs, str) else
ecs
)
+ self.extra_type = extra_type
+ self.fast = (
+ element.deserialize_bool(fast)
+ if isinstance(fast, str) else
+ fast
+ )
+ self.full = (
+ element.deserialize_bool(full)
+ if isinstance(full, str) else
+ full
+ )
+ self.header_file = header_file
+ self.input = (
+ element.deserialize_bool(input)
+ if isinstance(input, str) else
+ input
+ )
+ self.interactive = (
+ element.deserialize_bool(interactive)
+ if isinstance(interactive, str) else
+ interactive
+ )
+ self.lex_compat = (
+ element.deserialize_bool(lex_compat)
+ if isinstance(lex_compat, str) else
+ lex_compat
+ )
+ self.line = (
+ element.deserialize_bool(line)
+ if isinstance(line, str) else
+ line
+ )
+ self.main = (
+ element.deserialize_bool(main)
+ if isinstance(main, str) else
+ main
+ )
self.meta_ecs = (
element.deserialize_bool(meta_ecs)
if isinstance(meta_ecs, str) else
meta_ecs
)
+ self.never_interactive = (
+ element.deserialize_bool(never_interactive)
+ if isinstance(never_interactive, str) else
+ never_interactive
+ )
+ self.outfile = outfile
+ self.perf_report = (
+ element.deserialize_bool(perf_report)
+ if isinstance(perf_report, str) else
+ perf_report
+ )
+ self.posix_compat = (
+ element.deserialize_bool(posix_compat)
+ if isinstance(posix_compat, str) else
+ posix_compat
+ )
+ self.prefix = prefix
+ self.read = (
+ element.deserialize_bool(read)
+ if isinstance(read, str) else
+ read
+ )
+ self.reentrant = (
+ element.deserialize_bool(reentrant)
+ if isinstance(reentrant, str) else
+ reentrant
+ )
self.reject = (
element.deserialize_bool(reject)
if isinstance(reject, str) else
reject
)
+ self.seven_bit = (
+ element.deserialize_bool(seven_bit)
+ if isinstance(seven_bit, str) else
+ seven_bit
+ )
self.stack = (
element.deserialize_bool(stack)
if isinstance(stack, str) else
stack
)
- self.std_init = (
- element.deserialize_bool(std_init)
- if isinstance(std_init, str) else
- std_init
+ self.stdinit = (
+ element.deserialize_bool(stdinit)
+ if isinstance(stdinit, str) else
+ stdinit
+ )
+ self.stdout = (
+ element.deserialize_bool(stdout)
+ if isinstance(stdout, str) else
+ stdout
+ )
+ self.tables_file = tables_file
+ self.tables_verify = (
+ element.deserialize_bool(tables_verify)
+ if isinstance(tables_verify, str) else
+ tables_verify
+ )
+ self.unistd = (
+ element.deserialize_bool(unistd)
+ if isinstance(unistd, str) else
+ unistd
+ )
+ self.unput = (
+ element.deserialize_bool(unput)
+ if isinstance(unput, str) else
+ unput
+ )
+ self.verbose = (
+ element.deserialize_bool(verbose)
+ if isinstance(verbose, str) else
+ verbose
+ )
+ self.warn = (
+ element.deserialize_bool(warn)
+ if isinstance(warn, str) else
+ warn
+ )
+ self.yyalloc = (
+ element.deserialize_bool(yyalloc)
+ if isinstance(yyalloc, str) else
+ yyalloc
+ )
+ self.yyclass = yyclass
+ self.yyfree = (
+ element.deserialize_bool(yyfree)
+ if isinstance(yyfree, str) else
+ yyfree
+ )
+ self.yyget_debug = (
+ element.deserialize_bool(yyget_debug)
+ if isinstance(yyget_debug, str) else
+ yyget_debug
+ )
+ self.yyget_extra = (
+ element.deserialize_bool(yyget_extra)
+ if isinstance(yyget_extra, str) else
+ yyget_extra
+ )
+ self.yyget_in = (
+ element.deserialize_bool(yyget_in)
+ if isinstance(yyget_in, str) else
+ yyget_in
+ )
+ self.yyget_leng = (
+ element.deserialize_bool(yyget_leng)
+ if isinstance(yyget_leng, str) else
+ yyget_leng
+ )
+ self.yyget_lineno = (
+ element.deserialize_bool(yyget_lineno)
+ if isinstance(yyget_lineno, str) else
+ yyget_lineno
+ )
+ self.yyget_lloc = (
+ element.deserialize_bool(yyget_lloc)
+ if isinstance(yyget_lloc, str) else
+ yyget_lloc
+ )
+ self.yyget_lval = (
+ element.deserialize_bool(yyget_lval)
+ if isinstance(yyget_lval, str) else
+ yyget_lval
+ )
+ self.yyget_out = (
+ element.deserialize_bool(yyget_out)
+ if isinstance(yyget_out, str) else
+ yyget_out
+ )
+ self.yyget_text = (
+ element.deserialize_bool(yyget_text)
+ if isinstance(yyget_text, str) else
+ yyget_text
+ )
+ self.yylineno = (
+ element.deserialize_bool(yylineno)
+ if isinstance(yylineno, str) else
+ yylineno
)
self.yymore = (
element.deserialize_bool(yymore)
if isinstance(yymore, str) else
yymore
)
+ self.yy_pop_state = (
+ element.deserialize_bool(yy_pop_state)
+ if isinstance(yy_pop_state, str) else
+ yy_pop_state
+ )
+ self.yy_push_state = (
+ element.deserialize_bool(yy_push_state)
+ if isinstance(yy_push_state, str) else
+ yy_push_state
+ )
+ self.yyrealloc = (
+ element.deserialize_bool(yyrealloc)
+ if isinstance(yyrealloc, str) else
+ yyrealloc
+ )
+ self.yy_scan_buffer = (
+ element.deserialize_bool(yy_scan_buffer)
+ if isinstance(yy_scan_buffer, str) else
+ yy_scan_buffer
+ )
+ self.yy_scan_bytes = (
+ element.deserialize_bool(yy_scan_bytes)
+ if isinstance(yy_scan_bytes, str) else
+ yy_scan_bytes
+ )
+ self.yy_scan_string = (
+ element.deserialize_bool(yy_scan_string)
+ if isinstance(yy_scan_string, str) else
+ yy_scan_string
+ )
+ self.yyset_debug = (
+ element.deserialize_bool(yyset_debug)
+ if isinstance(yyset_debug, str) else
+ yyset_debug
+ )
+ self.yyset_extra = (
+ element.deserialize_bool(yyset_extra)
+ if isinstance(yyset_extra, str) else
+ yyset_extra
+ )
+ self.yyset_in = (
+ element.deserialize_bool(yyset_in)
+ if isinstance(yyset_in, str) else
+ yyset_in
+ )
+ self.yyset_lineno = (
+ element.deserialize_bool(yyset_lineno)
+ if isinstance(yyset_lineno, str) else
+ yyset_lineno
+ )
+ self.yyset_lloc = (
+ element.deserialize_bool(yyset_lloc)
+ if isinstance(yyset_lloc, str) else
+ yyset_lloc
+ )
+ self.yyset_lval = (
+ element.deserialize_bool(yyset_lval)
+ if isinstance(yyset_lval, str) else
+ yyset_lval
+ )
+ self.yyset_out = (
+ element.deserialize_bool(yyset_out)
+ if isinstance(yyset_out, str) else
+ yyset_out
+ )
self.yy_top_state = (
element.deserialize_bool(yy_top_state)
if isinstance(yy_top_state, str) else
)
def serialize(self, ref_list):
PLex.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('std_init', element.serialize_bool(self.std_init))
+ 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):
PLex.Section1Or2.deserialize(self, ref_list)
+ self.align = element.deserialize_bool(self.get('align', 'false'))
+ self.always_interactive = element.deserialize_bool(self.get('always_interactive', 'false'))
+ self.array = element.deserialize_bool(self.get('array', 'false'))
+ self.backup = element.deserialize_bool(self.get('backup', 'false'))
+ self.bison_bridge = element.deserialize_bool(self.get('bison_bridge', 'false'))
+ self.bison_locations = element.deserialize_bool(self.get('bison_locations', 'false'))
self.caseless = element.deserialize_bool(self.get('caseless', 'false'))
+ self.c_plus_plus = element.deserialize_bool(self.get('c_plus_plus', 'false'))
+ self.debug = element.deserialize_bool(self.get('debug', 'false'))
self.default = element.deserialize_bool(self.get('default', 'false'))
self.ecs = element.deserialize_bool(self.get('ecs', 'false'))
+ self.extra_type = element.deserialize_str(self.get('extra_type', ''))
+ self.fast = element.deserialize_bool(self.get('fast', 'false'))
+ self.full = element.deserialize_bool(self.get('full', 'false'))
+ self.header_file = element.deserialize_str(self.get('header_file', ''))
+ self.input = element.deserialize_bool(self.get('input', 'false'))
+ self.interactive = element.deserialize_bool(self.get('interactive', 'false'))
+ self.lex_compat = element.deserialize_bool(self.get('lex_compat', 'false'))
+ self.line = element.deserialize_bool(self.get('line', 'false'))
+ self.main = element.deserialize_bool(self.get('main', 'false'))
self.meta_ecs = element.deserialize_bool(self.get('meta_ecs', 'false'))
+ self.never_interactive = element.deserialize_bool(self.get('never_interactive', 'false'))
+ self.outfile = element.deserialize_str(self.get('outfile', ''))
+ self.perf_report = element.deserialize_bool(self.get('perf_report', 'false'))
+ self.posix_compat = element.deserialize_bool(self.get('posix_compat', 'false'))
+ self.prefix = element.deserialize_str(self.get('prefix', ''))
+ self.read = element.deserialize_bool(self.get('read', 'false'))
+ self.reentrant = element.deserialize_bool(self.get('reentrant', 'false'))
self.reject = element.deserialize_bool(self.get('reject', 'false'))
+ self.seven_bit = element.deserialize_bool(self.get('seven_bit', 'false'))
self.stack = element.deserialize_bool(self.get('stack', 'false'))
- self.std_init = element.deserialize_bool(self.get('std_init', 'false'))
+ self.stdinit = element.deserialize_bool(self.get('stdinit', 'false'))
+ self.stdout = element.deserialize_bool(self.get('stdout', 'false'))
+ self.tables_file = element.deserialize_str(self.get('tables_file', ''))
+ self.tables_verify = element.deserialize_bool(self.get('tables_verify', 'false'))
+ self.unistd = element.deserialize_bool(self.get('unistd', 'false'))
+ self.unput = element.deserialize_bool(self.get('unput', 'false'))
+ self.verbose = element.deserialize_bool(self.get('verbose', 'false'))
+ self.warn = element.deserialize_bool(self.get('warn', 'false'))
+ self.yyalloc = element.deserialize_bool(self.get('yyalloc', 'false'))
+ self.yyclass = element.deserialize_str(self.get('yyclass', ''))
+ self.yyfree = element.deserialize_bool(self.get('yyfree', 'false'))
+ self.yyget_debug = element.deserialize_bool(self.get('yyget_debug', 'false'))
+ self.yyget_extra = element.deserialize_bool(self.get('yyget_extra', 'false'))
+ self.yyget_in = element.deserialize_bool(self.get('yyget_in', 'false'))
+ self.yyget_leng = element.deserialize_bool(self.get('yyget_leng', 'false'))
+ self.yyget_lineno = element.deserialize_bool(self.get('yyget_lineno', 'false'))
+ self.yyget_lloc = element.deserialize_bool(self.get('yyget_lloc', 'false'))
+ self.yyget_lval = element.deserialize_bool(self.get('yyget_lval', 'false'))
+ self.yyget_out = element.deserialize_bool(self.get('yyget_out', 'false'))
+ self.yyget_text = element.deserialize_bool(self.get('yyget_text', 'false'))
+ self.yylineno = element.deserialize_bool(self.get('yylineno', 'false'))
self.yymore = element.deserialize_bool(self.get('yymore', 'false'))
+ self.yy_pop_state = element.deserialize_bool(self.get('yy_pop_state', 'false'))
+ self.yy_push_state = element.deserialize_bool(self.get('yy_push_state', 'false'))
+ self.yyrealloc = element.deserialize_bool(self.get('yyrealloc', 'false'))
+ self.yy_scan_buffer = element.deserialize_bool(self.get('yy_scan_buffer', 'false'))
+ self.yy_scan_bytes = element.deserialize_bool(self.get('yy_scan_bytes', 'false'))
+ self.yy_scan_string = element.deserialize_bool(self.get('yy_scan_string', 'false'))
+ self.yyset_debug = element.deserialize_bool(self.get('yyset_debug', 'false'))
+ self.yyset_extra = element.deserialize_bool(self.get('yyset_extra', 'false'))
+ self.yyset_in = element.deserialize_bool(self.get('yyset_in', 'false'))
+ self.yyset_lineno = element.deserialize_bool(self.get('yyset_lineno', 'false'))
+ self.yyset_lloc = element.deserialize_bool(self.get('yyset_lloc', 'false'))
+ self.yyset_lval = element.deserialize_bool(self.get('yyset_lval', 'false'))
+ self.yyset_out = element.deserialize_bool(self.get('yyset_out', 'false'))
self.yy_top_state = element.deserialize_bool(self.get('yy_top_state', 'false'))
self.yywrap = element.deserialize_bool(self.get('yywrap', 'false'))
def copy(self, factory = None):
self,
Section1 if factory is None else factory
)
+ result.align = self.align
+ result.always_interactive = self.always_interactive
+ result.array = self.array
+ result.backup = self.backup
+ result.bison_bridge = self.bison_bridge
+ result.bison_locations = self.bison_locations
result.caseless = self.caseless
+ result.c_plus_plus = self.c_plus_plus
+ result.debug = self.debug
result.default = self.default
result.ecs = self.ecs
+ result.extra_type = self.extra_type
+ result.fast = self.fast
+ result.full = self.full
+ result.header_file = self.header_file
+ result.input = self.input
+ result.interactive = self.interactive
+ result.lex_compat = self.lex_compat
+ result.line = self.line
+ result.main = self.main
result.meta_ecs = self.meta_ecs
+ result.never_interactive = self.never_interactive
+ result.outfile = self.outfile
+ result.perf_report = self.perf_report
+ result.posix_compat = self.posix_compat
+ result.prefix = self.prefix
+ result.read = self.read
+ result.reentrant = self.reentrant
result.reject = self.reject
+ result.seven_bit = self.seven_bit
result.stack = self.stack
- result.std_init = self.std_init
+ result.stdinit = self.stdinit
+ result.stdout = self.stdout
+ result.tables_file = self.tables_file
+ result.tables_verify = self.tables_verify
+ result.unistd = self.unistd
+ result.unput = self.unput
+ result.verbose = self.verbose
+ result.warn = self.warn
+ result.yyalloc = self.yyalloc
+ result.yyclass = self.yyclass
+ result.yyfree = self.yyfree
+ result.yyget_debug = self.yyget_debug
+ result.yyget_extra = self.yyget_extra
+ result.yyget_in = self.yyget_in
+ result.yyget_leng = self.yyget_leng
+ result.yyget_lineno = self.yyget_lineno
+ result.yyget_lloc = self.yyget_lloc
+ result.yyget_lval = self.yyget_lval
+ result.yyget_out = self.yyget_out
+ result.yyget_text = self.yyget_text
+ result.yylineno = self.yylineno
result.yymore = self.yymore
+ result.yy_pop_state = self.yy_pop_state
+ result.yy_push_state = self.yy_push_state
+ result.yyrealloc = self.yyrealloc
+ result.yy_scan_buffer = self.yy_scan_buffer
+ result.yy_scan_bytes = self.yy_scan_bytes
+ result.yy_scan_string = self.yy_scan_string
+ result.yyset_debug = self.yyset_debug
+ result.yyset_extra = self.yyset_extra
+ result.yyset_in = self.yyset_in
+ result.yyset_lineno = self.yyset_lineno
+ result.yyset_lloc = self.yyset_lloc
+ result.yyset_lval = self.yyset_lval
+ result.yyset_out = self.yyset_out
result.yy_top_state = self.yy_top_state
result.yywrap = self.yywrap
return result
def repr_serialize(self, params):
PLex.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))
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.std_init != False:
+ if self.stdinit != False:
+ params.append(
+ 'stdinit = {0:s}'.format(repr(self.stdinit))
+ )
+ if self.stdout != False:
params.append(
- 'std_init = {0:s}'.format(repr(self.std_init))
+ '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))
all_start_conditions,
inclusive_start_conditions
):
+ self.align = False
+ self.always_interactive = True
+ self.array = False
+ self.backup = True
+ self.bison_bridge = False
+ self.bison_locations = False
self.caseless = False
+ self.c_plus_plus = False
+ self.debug = False
self.default = True
self.ecs = False
+ self.extra_type = ''
+ self.fast = False
+ self.full = False
+ self.header_file = ''
+ self.input = True
+ self.interactive = True
+ self.lex_compat = False
+ self.line = True
+ self.main = False
self.meta_ecs = False
+ self.never_interactive = False
+ self.outfile = ''
+ self.perf_report = False
+ self.posix_compat = False
+ self.prefix = ''
+ self.read = False
+ self.reentrant = False
self.reject = True
+ self.seven_bit = False
self.stack = True
- self.std_init = True
+ self.stdinit = True
+ self.stdout = True
+ self.tables_file = ''
+ self.tables_verify = False
+ self.unistd = True
+ self.unput = True
+ self.verbose = False
+ self.warn = True
+ self.yyalloc = True
+ self.yyclass = ''
+ self.yyfree = True
+ self.yyget_debug = True
+ self.yyget_extra = True
+ self.yyget_in = True
+ self.yyget_leng = True
+ self.yyget_lineno = True
+ self.yyget_lloc = True
+ self.yyget_lval = True
+ self.yyget_out = True
+ self.yyget_text = True
+ self.yylineno = True
self.yymore = True
+ self.yy_pop_state = True
+ self.yy_push_state = True
+ self.yyrealloc = True
+ self.yy_scan_buffer = True
+ self.yy_scan_bytes = True
+ self.yy_scan_string = True
+ self.yyset_debug = True
+ self.yyset_extra = True
+ self.yyset_in = True
+ self.yyset_lineno = True
+ self.yyset_lloc = True
+ self.yyset_lval = True
+ self.yyset_out = True
self.yy_top_state = True
self.yywrap = True
PLex.Section1Or2.post_process(
all_start_conditions,
inclusive_start_conditions
)
+ if self.align:
+ sys.stderr.write('warning: ignoring %option align\n')
+ if not self.always_interactive:
+ sys.stderr.write('warning: ignoring %option noalways-interactive\n')
+ if self.array:
+ sys.stderr.write('warning: ignoring %option array\n')
+ if not self.backup:
+ sys.stderr.write('warning: ignoring %option nobackup\n')
+ if self.bison_bridge:
+ sys.stderr.write('warning: ignoring %option bison-bridge\n')
+ if self.bison_locations:
+ sys.stderr.write('warning: ignoring %option bison-locations\n')
+ #if self.caseless:
+ # sys.stderr.write('warning: ignoring %option caseless\n')
+ if self.c_plus_plus:
+ sys.stderr.write('warning: ignoring %option c_plus_plus\n')
+ if self.debug:
+ sys.stderr.write('warning: ignoring %option debug\n')
+ #if not self.default:
+ # sys.stderr.write('warning: ignoring %option nodefault\n')
+ if self.ecs:
+ sys.stderr.write('warning: ignoring %option ecs\n')
+ if len(self.extra_type):
+ sys.stderr.write('warning: ignoring %option extra-type\n')
+ if self.fast:
+ sys.stderr.write('warning: ignoring %option fast\n')
+ if self.full:
+ sys.stderr.write('warning: ignoring %option full\n')
+ if len(self.header_file):
+ sys.stderr.write('warning: ignoring %option header-file\n')
+ if not self.input:
+ sys.stderr.write('warning: ignoring %option noinput\n')
+ if not self.interactive:
+ sys.stderr.write('warning: ignoring %option nointeractive\n')
+ if self.lex_compat:
+ sys.stderr.write('warning: ignoring %option lex-compat\n')
+ if not self.line:
+ sys.stderr.write('warning: ignoring %option noline\n')
+ if self.main:
+ sys.stderr.write('warning: ignoring %option main\n')
+ if self.meta_ecs:
+ sys.stderr.write('warning: ignoring %option meta-ecs\n')
+ if self.never_interactive:
+ sys.stderr.write('warning: ignoring %option never-interactive\n')
+ if len(self.outfile):
+ sys.stderr.write('warning: ignoring %option outfile\n')
+ if self.perf_report:
+ sys.stderr.write('warning: ignoring %option perf-report\n')
+ if self.posix_compat:
+ sys.stderr.write('warning: ignoring %option posix-compat\n')
+ if len(self.prefix):
+ sys.stderr.write('warning: ignoring %option prefix\n')
+ if self.read:
+ sys.stderr.write('warning: ignoring %option read\n')
+ if self.reentrant:
+ sys.stderr.write('warning: ignoring %option reentrant\n')
+ if not self.reject:
+ sys.stderr.write('warning: ignoring %option noreject\n')
+ if self.seven_bit:
+ sys.stderr.write('warning: ignoring %option 7bit\n')
+ if not self.stack:
+ sys.stderr.write('warning: ignoring %option nostack\n')
+ if not self.stdinit:
+ sys.stderr.write('warning: ignoring %option nostdinit\n')
+ if not self.stdout:
+ sys.stderr.write('warning: ignoring %option nostdout\n')
+ if len(self.tables_file):
+ sys.stderr.write('warning: ignoring %option tables-file\n')
+ if self.tables_verify:
+ sys.stderr.write('warning: ignoring %option tables-verify\n')
+ if not self.unistd:
+ sys.stderr.write('warning: ignoring %option nounistd\n')
+ if not self.unput:
+ sys.stderr.write('warning: ignoring %option nounput\n')
+ if self.verbose:
+ sys.stderr.write('warning: ignoring %option verbose\n')
+ if not self.warn:
+ sys.stderr.write('warning: ignoring %option nowarn\n')
+ if not self.yyalloc:
+ sys.stderr.write('warning: ignoring %option noyyalloc\n')
+ if len(self.yyclass):
+ sys.stderr.write('warning: ignoring %option yyclass\n')
+ if not self.yyfree:
+ sys.stderr.write('warning: ignoring %option noyyfree\n')
+ if not self.yyget_debug:
+ sys.stderr.write('warning: ignoring %option noyyget_debug\n')
+ if not self.yyget_extra:
+ sys.stderr.write('warning: ignoring %option noyyget_extra\n')
+ if not self.yyget_in:
+ sys.stderr.write('warning: ignoring %option noyyget_in\n')
+ if not self.yyget_leng:
+ sys.stderr.write('warning: ignoring %option noyyget_leng\n')
+ if not self.yyget_lineno:
+ sys.stderr.write('warning: ignoring %option noyyget_lineno\n')
+ if not self.yyget_lloc:
+ sys.stderr.write('warning: ignoring %option noyyget_lloc\n')
+ if not self.yyget_lval:
+ sys.stderr.write('warning: ignoring %option noyyget_lval\n')
+ if not self.yyget_out:
+ sys.stderr.write('warning: ignoring %option noyyget_out\n')
+ if not self.yyget_text:
+ sys.stderr.write('warning: ignoring %option noyyget_text\n')
+ if not self.yylineno:
+ sys.stderr.write('warning: ignoring %option noyylineno\n')
+ if not self.yymore:
+ sys.stderr.write('warning: ignoring %option noyymore\n')
+ if not self.yy_pop_state:
+ sys.stderr.write('warning: ignoring %option noyy_pop_state\n')
+ if not self.yy_push_state:
+ sys.stderr.write('warning: ignoring %option noyy_push_state\n')
+ if not self.yyrealloc:
+ sys.stderr.write('warning: ignoring %option noyyrealloc\n')
+ if not self.yy_scan_buffer:
+ sys.stderr.write('warning: ignoring %option noyy_scan_buffer\n')
+ if not self.yy_scan_bytes:
+ sys.stderr.write('warning: ignoring %option noyy_scan_bytes\n')
+ if not self.yy_scan_string:
+ sys.stderr.write('warning: ignoring %option noyy_scan_string\n')
+ if not self.yyset_debug:
+ sys.stderr.write('warning: ignoring %option noyyset_debug\n')
+ if not self.yyset_extra:
+ sys.stderr.write('warning: ignoring %option noyyset_extra\n')
+ if not self.yyset_in:
+ sys.stderr.write('warning: ignoring %option noyyset_in\n')
+ if not self.yyset_lineno:
+ sys.stderr.write('warning: ignoring %option noyyset_lineno\n')
+ if not self.yyset_lloc:
+ sys.stderr.write('warning: ignoring %option noyyset_lloc\n')
+ if not self.yyset_lval:
+ sys.stderr.write('warning: ignoring %option noyyset_lval\n')
+ if not self.yyset_out:
+ sys.stderr.write('warning: ignoring %option noyyset_out\n')
+ if not self.yy_top_state:
+ sys.stderr.write('warning: ignoring %option noyy_top_state\n')
+ #if not self.yywrap:
+ # sys.stderr.write('warning: ignoring %option noyywrap\n')
class Section2(Section1Or2):
class CompoundRule(element.Element):
'Item': Item,
'PLex': PLex,
'PLex_StartCondition': PLex.StartCondition,
+ 'PLex_String': PLex.String,
'PLex_Text': PLex.Text,
'PLex_Name': PLex.Name,
'PLex_Section1Or2': PLex.Section1Or2,
'PLex_Section1_Options': PLex.Section1.Options,
'PLex_Section1_Options_Option': PLex.Section1.Options.Option,
'PLex_Section1_Options_BoolOption': PLex.Section1.Options.BoolOption,
+ 'PLex_Section1_Options_Align': PLex.Section1.Options.Align,
+ 'PLex_Section1_Options_AlwaysInteractive': PLex.Section1.Options.AlwaysInteractive,
+ 'PLex_Section1_Options_Array': PLex.Section1.Options.Array,
+ 'PLex_Section1_Options_Backup': PLex.Section1.Options.Backup,
+ 'PLex_Section1_Options_BisonBridge': PLex.Section1.Options.BisonBridge,
+ 'PLex_Section1_Options_BisonLocations': PLex.Section1.Options.BisonLocations,
'PLex_Section1_Options_Caseless': PLex.Section1.Options.Caseless,
+ 'PLex_Section1_Options_CPlusPlus': PLex.Section1.Options.CPlusPlus,
+ 'PLex_Section1_Options_Debug': PLex.Section1.Options.Debug,
'PLex_Section1_Options_Default': PLex.Section1.Options.Default,
'PLex_Section1_Options_ECS': PLex.Section1.Options.ECS,
+ 'PLex_Section1_Options_ExtraType': PLex.Section1.Options.ExtraType,
+ 'PLex_Section1_Options_Fast': PLex.Section1.Options.Fast,
+ 'PLex_Section1_Options_Full': PLex.Section1.Options.Full,
+ 'PLex_Section1_Options_HeaderFile': PLex.Section1.Options.HeaderFile,
+ 'PLex_Section1_Options_Input': PLex.Section1.Options.Input,
+ 'PLex_Section1_Options_Interactive': PLex.Section1.Options.Interactive,
+ 'PLex_Section1_Options_LexCompat': PLex.Section1.Options.LexCompat,
+ 'PLex_Section1_Options_Line': PLex.Section1.Options.Line,
+ 'PLex_Section1_Options_Main': PLex.Section1.Options.Main,
'PLex_Section1_Options_MetaECS': PLex.Section1.Options.MetaECS,
+ 'PLex_Section1_Options_NeverInteractive': PLex.Section1.Options.NeverInteractive,
+ 'PLex_Section1_Options_OutFile': PLex.Section1.Options.OutFile,
+ 'PLex_Section1_Options_PerfReport': PLex.Section1.Options.PerfReport,
+ 'PLex_Section1_Options_PosixCompat': PLex.Section1.Options.PosixCompat,
+ 'PLex_Section1_Options_Prefix': PLex.Section1.Options.Prefix,
+ 'PLex_Section1_Options_Read': PLex.Section1.Options.Read,
+ 'PLex_Section1_Options_Reentrant': PLex.Section1.Options.Reentrant,
'PLex_Section1_Options_Reject': PLex.Section1.Options.Reject,
+ 'PLex_Section1_Options_SevenBit': PLex.Section1.Options.SevenBit,
'PLex_Section1_Options_Stack': PLex.Section1.Options.Stack,
'PLex_Section1_Options_StdInit': PLex.Section1.Options.StdInit,
+ 'PLex_Section1_Options_StdOut': PLex.Section1.Options.StdOut,
+ 'PLex_Section1_Options_TablesFile': PLex.Section1.Options.TablesFile,
+ 'PLex_Section1_Options_TablesVerify': PLex.Section1.Options.TablesVerify,
+ 'PLex_Section1_Options_UniStd': PLex.Section1.Options.UniStd,
+ 'PLex_Section1_Options_Unput': PLex.Section1.Options.Unput,
+ 'PLex_Section1_Options_Verbose': PLex.Section1.Options.Verbose,
+ 'PLex_Section1_Options_Warn': PLex.Section1.Options.Warn,
+ 'PLex_Section1_Options_YYAlloc': PLex.Section1.Options.YYAlloc,
+ 'PLex_Section1_Options_YYClass': PLex.Section1.Options.YYClass,
+ 'PLex_Section1_Options_YYFree': PLex.Section1.Options.YYFree,
+ 'PLex_Section1_Options_YYGetDebug': PLex.Section1.Options.YYGetDebug,
+ 'PLex_Section1_Options_YYGetExtra': PLex.Section1.Options.YYGetExtra,
+ 'PLex_Section1_Options_YYGetIn': PLex.Section1.Options.YYGetIn,
+ 'PLex_Section1_Options_YYGetLeng': PLex.Section1.Options.YYGetLeng,
+ 'PLex_Section1_Options_YYGetLineNo': PLex.Section1.Options.YYGetLineNo,
+ 'PLex_Section1_Options_YYGetLLoc': PLex.Section1.Options.YYGetLLoc,
+ 'PLex_Section1_Options_YYGetLVal': PLex.Section1.Options.YYGetLVal,
+ 'PLex_Section1_Options_YYGetOut': PLex.Section1.Options.YYGetOut,
+ 'PLex_Section1_Options_YYGetText': PLex.Section1.Options.YYGetText,
+ 'PLex_Section1_Options_YYLineNo': PLex.Section1.Options.YYLineNo,
'PLex_Section1_Options_YYMore': PLex.Section1.Options.YYMore,
+ 'PLex_Section1_Options_YYPopState': PLex.Section1.Options.YYPopState,
+ 'PLex_Section1_Options_YYPushState': PLex.Section1.Options.YYPushState,
+ 'PLex_Section1_Options_YYRealloc': PLex.Section1.Options.YYRealloc,
+ 'PLex_Section1_Options_YYScanBuffer': PLex.Section1.Options.YYScanBuffer,
+ 'PLex_Section1_Options_YYScanBytes': PLex.Section1.Options.YYScanBytes,
+ 'PLex_Section1_Options_YYScanString': PLex.Section1.Options.YYScanString,
+ 'PLex_Section1_Options_YYSetDebug': PLex.Section1.Options.YYSetDebug,
+ 'PLex_Section1_Options_YYSetExtra': PLex.Section1.Options.YYSetExtra,
+ 'PLex_Section1_Options_YYSetIn': PLex.Section1.Options.YYSetIn,
+ 'PLex_Section1_Options_YYSetLineNo': PLex.Section1.Options.YYSetLineNo,
+ 'PLex_Section1_Options_YYSetLLoc': PLex.Section1.Options.YYSetLLoc,
+ 'PLex_Section1_Options_YYSetLVal': PLex.Section1.Options.YYSetLVal,
+ 'PLex_Section1_Options_YYSetOut': PLex.Section1.Options.YYSetOut,
'PLex_Section1_Options_YYTopState': PLex.Section1.Options.YYTopState,
'PLex_Section1_Options_YYWrap': PLex.Section1.Options.YYWrap,
'PLex_Section1_StartConditions': PLex.Section1.StartConditions,
public / pilex.git / commitdiff