def reset(self):
self.engine = yacc.yacc(
module=self,
start=self._start,
outputdir=self._tempdir,
write_tables=bool(self._tempdir),
debug=self._debug,
debuglog=log if self._debug else yacc.NullLogger(),
errorlog=log if self._debug else yacc.NullLogger(),
)
def get_parser(debug_mode=False):
lexer = None
parser = None
if debug_mode:
lexer = lex.lex(debug=True)
parser = yacc.yacc(write_tables=True, debug=True)
else:
lexer = lex.lex(debug=False, errorlog=yacc.NullLogger())
parser = yacc.yacc(write_tables=False,
debug=False,
errorlog=yacc.NullLogger())
return parser
def __init__(self,
geometry_factory=values.Geometry,
bbox_factory=values.BBox,
time_factory=values.Time,
duration_factory=values.Duration):
self.lexer = CQLLexer(
# lextab='ecql.lextab',
# outputdir="ecql"
geometry_factory,
bbox_factory,
time_factory,
duration_factory,
optimize=True,
)
self.lexer.build()
self.tokens = self.lexer.tokens
self.parser = yacc.yacc(
module=self,
# start='condition_or_empty',
# debug=True,
optimize=True,
# tabmodule='ecql.yacctab',
# outputdir="ecql"
errorlog=yacc.NullLogger(),
)
def __init__(self, startSym='mibFile', tempdir=''):
if tempdir:
tempdir = os.path.join(tempdir, startSym)
try:
os.makedirs(tempdir)
except OSError:
if sys.exc_info()[1].errno != 17:
raise error.PySmiError(
'Failed to create cache directory %s: %s' %
(tempdir, sys.exc_info()[1]))
self.lexer = self.defaultLexer(tempdir=tempdir)
# tokens are required for parser
self.tokens = self.lexer.tokens
if debug.logger & debug.flagParser:
logger = debug.logger.getCurrentLogger()
else:
logger = yacc.NullLogger()
if debug.logger & debug.flagGrammar:
debuglogger = debug.logger.getCurrentLogger()
else:
debuglogger = None
self.parser = yacc.yacc(module=self,
start=startSym,
write_tables=bool(tempdir),
debug=False,
outputdir=tempdir,
debuglog=debuglogger,
errorlog=logger)
def __init__(self):
self.loglexer = LOGLexer()
self.loglexer.build()
self.tokens = self.loglexer.tokens
self.logparser = yacc.yacc(module=self,
start='File',
errorlog=yacc.NullLogger())
def __init__(self, **kw):
'''
Args:
interface = instance of interface object, with setting set, if nothing passed default instance created.
quit_function = a function defining what to do when quit command issued
help_function = a function defining what to do when help command issued
read_file_function = a function defining what to do when a file is read. Not used currently.
'''
self.debug = kw.get('debug', 0)
self.names = {}
modname = "kodiak_parser"
self.debugfile = modname + ".dbg"
self.tabmodule = modname + "_" + "parsetab"
self._quit_function = kw.get('quit_function', None)
self._help_function = kw.get('help_function', None)
self._read_file_function = kw.get('read_file_function', None)
# Create the _lexer and _parser
self._lexer = lex.lex(module=self, debug=self.debug)
self._parser = yacc.yacc(module=self,
debug=self.debug,
debugfile=self.debugfile,
tabmodule=self.tabmodule,
errorlog=yacc.NullLogger())
def __init__(self, cpu):
self._cpu = cpu
self._labels = {}
self._lexer = lex.lex(module=self)
self._lexpos = 0
self._parser = yacc.yacc(module=self, errorlog=yacc.NullLogger())
self._file_name = None
def __init__(self):
'''Create a new Schedule parser object
Constructor
'''
logger.info('ScheduleParser: new object creation')
self.lexer = ScheduleLexer()
self.tokens = self.lexer.tokens
#self.parser = yacc.yacc(module=self, write_tables=0, debug=True)
self.parser = yacc.yacc(module=self,
write_tables=0,
errorlog=yacc.NullLogger())
logger.debug('ScheduleParser: LEX/YAC ready')
# All _private attributes to store "partial" timeslot information & parser status flag
self._store_month = '' # The latest month discovered by the parser
self._store_dates = []
self._store_timerange = []
self._store_weekdays = []
self._store_exc_weekdays = []
self._store_timeslice = []
self._store_multimonth = None
self._day_mode = False
self._flag_sched_differed = False
self._multimonth = False
self._notam_begin = None
self._notam_end = None
self._ref_month = None
self._store_schedule = []
def main(filename):
logger = yacc.NullLogger()
yacc.yacc()
data = open(filename, 'r').read()
ast = yacc.parse(data, lexer=lex.lex())
graph(ast, filename)
def setup_parser(work_dir):
"""
Setup the parser.
:return: None
"""
global __parser
global __lexer
os.makedirs(work_dir, exist_ok=True)
__lexer = lex.lex(outputdir=work_dir,
optimize=1,
errorlog=yacc.NullLogger())
__parser = yacc.yacc(outputdir=work_dir,
optimize=1,
errorlog=yacc.NullLogger())
def getParser(debug=False):
lexer.getLexer()
if debug:
parser = yacc.yacc()
else:
parser = yacc.yacc(errorlog=yacc.NullLogger())
return parser
def __init__(self, debug=False, text=None):
self.errors = []
self.tokens = VsopLexer.tokens
self.lexer = VsopLexer()
self.parser = yacc.yacc(module=self,
debug=debug,
errorlog=yacc.NullLogger())
def parse_string(input_):
GLOBAL_VARIABLES.clear()
#yacc.yacc(errorlog=yacc.NullLogger())
#there are a bunch of unused tokens right now, I realize this.
lex.lex()
parser = yacc.yacc(errorlog=yacc.NullLogger())
parser.parse(input_)
return True
def generate_tree_from_string(input_):
Tracker().reset()
Tracker()
lexer = lex.lex()
parser = yacc.yacc(debug=False, errorlog=yacc.NullLogger())
program = parser.parse(input_, lexer=lexer)
program.generate_tree()
def __init__(self, lexer, tokens, errors=False):
self.lexer = lexer
self.tokens = tokens
if errors:
self.parser = yacc.yacc(module=self)
else:
self.parser = yacc.yacc(module=self, errorlog=yacc.NullLogger())
self.error = False
def __init__(self, debug=0, skip=False, log=yacc.NullLogger()):
self.skip = skip
self.errors = [] #error list
self.log_tmp = LogTemplate()
self.parser = yacc.yacc(module=self,
tabmodule='pyoracc.atf.parsetab',
debug=debug,
debuglog=log)
def ply_parse(start, data):
"""
Create a parser for the given start symbol and parse the given
byte-string.
"""
lexer = lex.lex()
parser = yacc.yacc(start=start, errorlog=yacc.NullLogger())
return parser.parse(data)
def __init__(self, **kwargs):
if 'tokens' in kwargs.keys(): # MANDATORY
self.tokens = kwargs['tokens']
kwargs.pop('tokens', None)
# debugging and logging http://www.dabeaz.com/ply/ply.html#ply_nn44
#self.parser = yacc.yacc(module=self, start='step', errorlog=yacc.NullLogger(), debug = True, debugfile='debug_file', **kwargs)
self.parser = yacc.yacc(module=self, start='step', errorlog=yacc.NullLogger(), debug = False, **kwargs)
def build(self, **kwargs):
self.parser = yacc.yacc(module=self,
debug=False,
write_tables=False,
errorlog=yacc.NullLogger(),
**kwargs)
self.lexer = HealthLexer().build()
return self.parser
def __init__(self):
self.lexer = BIRLexer()
self.tokens = self.lexer.tokens
self.inst_parser = yacc.yacc(module=self, write_tables=0,
debug=False, start='arith_exp',
errorlog=yacc.NullLogger())
self.cond_parser = yacc.yacc(module=self, write_tables=0,
debug=False, start='bool_exp')
def parse(source: str, debug_mode: bool = False) -> Node:
if debug_mode:
parser = yacc.yacc(debug=True)
else:
parser = yacc.yacc(debug=False, errorlog=yacc.NullLogger())
parse_tree: Node = parser.parse(source, lexer=lexer)
return parse_tree
def __init__(self, **kwargs):
if kwargs.pop('silent', False):
kwargs['errorlog'] = yacc.NullLogger()
kwargs.setdefault('debug', False)
kwargs.setdefault('write_tables', False)
self._parser = yacc.yacc(module=self, **kwargs)
self._lexer = Lexer()
def test_recurse_expansion(self):
"""Verify that stack depth doesn't get exceeded on recursive rules marked for expansion."""
g = Grammar(r"""@start: a | start a ; a : A ; A : 'a' ;""")
# Force PLY to write to the debug log, but prevent writing it to the terminal (uses repr() on the half-built
# STree data structures, which uses recursion).
g._grammar.debug = yacc.NullLogger()
g.parse("a" * (sys.getrecursionlimit() / 4))
def __init__(self, filename, lexer):
# We call the constructor of the parent class
super().__init__(filename, lexer)
# Build the parser
self.parser = yacc.yacc(module=self,
debug=False,
errorlog=yacc.NullLogger(),
tabmodule='parsetabext')
def __init__(self):
self._initialize_rules()
self._parser = yacc.yacc(module=self,
write_tables=False,
debug=False,
errorlog=yacc.NullLogger())
self._lexer = TabLexer(self._construct_lexer())
self._expected_tokens = []
self._token_position = -1
def run_bad_code_from_string(input_):
reset()
lexer = lex.lex()
parser = yacc.yacc(debug=False, errorlog=yacc.NullLogger())
parser.parse(input_, lexer=lexer)
execute_bad_instructions(INSTRUCTIONS)
global OUTPUT
return OUTPUT
def parse():
parser = yacc.yacc(errorlog=yacc.NullLogger())
test_file = open("input.txt", "r")
data = test_file.read()
#print(data);
code_lines = data.split('\n')
test_file.close()
parser.parse(data, tracking=True)
return AST, ERRORS, code_lines
"""
def __init__(self, **kwargs):
if 'tokens' in kwargs.keys(): # MANDATORY
self.tokens = kwargs['tokens']
kwargs.pop('tokens', None)
# self.parser = yacc.yacc(module=self, start='step', errorlog=yacc.NullLogger(), debug = True, debugfile='debug_file', **kwargs)
self.parser = yacc.yacc(module=self,
start='step',
errorlog=yacc.NullLogger(),
debug=False,
**kwargs)
def build(self, dump_pretty=False, dump_lexed=False, **kwargs):
"""Build the parser."""
self.lexer = FunkyLexer()
self.lexer.build()
self.lexer = IndentationLexer(self.lexer, dump_pretty=dump_pretty,
dump_lexed=dump_lexed)
log.debug("Using PLY to build the parser...")
self.parser = yacc.yacc(module=self,
errorlog=yacc.NullLogger(),
**kwargs)
log.debug("Parser built.")
def run(input_, profile_mode=False):
reset()
lexer = lex.lex()
parser = yacc.yacc(debug=False, errorlog=yacc.NullLogger())
parser.parse(input_, lexer=lexer)
cycles = execute_bad_instructions(INSTRUCTIONS)
if profile_mode:
return cycles
global OUTPUT
return OUTPUT
