def main(debug=False):
# Program code
input = '''
begin
up
up
left
down
right
end
'''
# First we will make a parser - an instance of the robot parser model.
# Parser model is given in the form of PEG specification therefore we
# are using ParserPEG class.
parser = ParserPEG(robot_grammar, 'robot', debug=debug)
# We create a parse tree out of textual input
parse_tree = parser.parse(input)
# getASG will start semantic analysis.
# In this case semantic analysis will evaluate expression and
# returned value will be the final position of the robot.
return parser.getASG(sem_actions=semantic_actions)
def main(debug=False):
# Grammar is defined using textual specification based on PEG language.
# Load grammar form file.
calc_grammar = open(os.path.join(os.path.dirname(__file__), 'calc.peg'),
'r').read()
# First we will make a parser - an instance of the calc parser model.
# Parser model is given in the form of PEG notation therefore we
# are using ParserPEG class. Root rule name (parsing expression) is "calc".
parser = ParserPEG(calc_grammar, "calc", debug=debug)
# An expression we want to evaluate
input_expr = "-(4-1)*5+(2+4.67)+5.89/(.2+7)"
# Then parse tree is created out of the input_expr expression.
parse_tree = parser.parse(input_expr)
# The result is obtained by semantic evaluation using visitor class.
# visit_parse_tree will start semantic analysis.
# In this case semantic analysis will evaluate expression and
# returned value will be evaluated result of the input_expr expression.
result = visit_parse_tree(parse_tree, CalcVisitor(debug=debug))
# Check that result is valid
assert (result - -7.51194444444) < 0.0001
print("{} = {}".format(input_expr, result))
def main(debug=False):
# ParserPEG will use ParserPython to parse peg_grammar definition and
# create parser_model for parsing PEG based grammars
# In debug mode dot (graphviz) files for parser model
# and parse tree will be created for visualization.
# Checkout current folder for .dot files.
parser = ParserPEG(peg_grammar, 'peggrammar', debug=debug)
# Now we will use created parser to parse the same peg_grammar used for
# parser initialization. We can parse peg_grammar because it is specified
# using PEG itself.
parse_tree = parser.parse(peg_grammar)
# ASG should be the same as parser.parser_model because semantic
# actions will create PEG parser (tree of ParsingExpressions).
parser_model, comment_model = visit_parse_tree(
parse_tree, PEGVisitor(root_rule_name='peggrammar',
comment_rule_name='comment',
ignore_case=False,
debug=debug))
if debug:
# This graph should be the same as peg_peg_parser_model.dot because
# they define the same parser.
PMDOTExporter().exportFile(parser_model,
"peg_peg_new_parser_model.dot")
# If we replace parser_mode with ASG constructed parser it will still
# parse PEG grammars
parser.parser_model = parser_model
parser.parse(peg_grammar)
def test_parse_input():
parser = ParserPEG(grammar, 'calc')
input = "4+5*7/3.45*-45*(2.56+32)/-56*(2-1.34)"
result = parser.parse(input)
assert isinstance(result, NonTerminal)
assert str(result) == "4 | + | 5 | * | 7 | / | 3.45 | * | - | 45 | * | ( | 2.56 | + | 32 | ) | / | - | 56 | * | ( | 2 | - | 1.34 | ) | "
assert repr(result) == "[ [ [ [ number '4' [0] ] ], '+' [1], [ [ number '5' [2] ], '*' [3], [ number '7' [4] ], '/' [5], [ number '3.45' [6] ], '*' [10], [ '-' [11], number '45' [12] ], '*' [14], [ '(' [15], [ [ [ number '2.56' [16] ] ], '+' [20], [ [ number '32' [21] ] ] ], ')' [23] ], '/' [24], [ '-' [25], number '56' [26] ], '*' [28], [ '(' [29], [ [ [ number '2' [30] ] ], '-' [31], [ [ number '1.34' [32] ] ] ], ')' [36] ] ] ], EOF [37] ]"
def convert_function_to_medusa(arch, func, var):
isabelle_grammar = open(
os.path.join(os.path.dirname(__file__), 'isabelle.peg'), 'r').read()
parser = ParserPEG(isabelle_grammar, 'code', debug=False)
parse_tree = parser.parse(func)
prm = {
'cpu_info': 'rCpuInfo',
}
return visit_parse_tree(
parse_tree, IsabelleVisitor(arch, None, var, prm, debug=False)) + "\n"
def convert_semantic_to_medusa(arch, insn):
isabelle_grammar = open(
os.path.join(os.path.dirname(__file__), 'isabelle.peg'), 'r').read()
parser = ParserPEG(isabelle_grammar, 'code', debug=False)
parse_tree = parser.parse(insn['semantic'])
prm = {
'cpu_info': 'm_CpuInfo',
}
return visit_parse_tree(
parse_tree, IsabelleVisitor(arch, insn, None, prm, debug=False)) + "\n"
def test_parse_input():
parser = ParserPEG(grammar, 'calc')
input = "4+5*7/3.45*-45*(2.56+32)/-56*(2-1.34)"
result = parser.parse(input)
assert isinstance(result, NonTerminal)
assert str(
result
) == "4 | + | 5 | * | 7 | / | 3.45 | * | - | 45 | * | ( | 2.56 | + | 32 | ) | / | - | 56 | * | ( | 2 | - | 1.34 | ) | "
assert repr(
result
) == "[ [ [ [ number '4' [0] ] ], '+' [1], [ [ number '5' [2] ], '*' [3], [ number '7' [4] ], '/' [5], [ number '3.45' [6] ], '*' [10], [ '-' [11], number '45' [12] ], '*' [14], [ '(' [15], [ [ [ number '2.56' [16] ] ], '+' [20], [ [ number '32' [21] ] ] ], ')' [23] ], '/' [24], [ '-' [25], number '56' [26] ], '*' [28], [ '(' [29], [ [ [ number '2' [30] ] ], '-' [31], [ [ number '1.34' [32] ] ] ], ')' [36] ] ] ], EOF [37] ]"
def get_parser(debug=False, root='query_specification'):
"""returns a PEG parser for the local ADQL grammar.
This patches the grammar literal a bit to make it palatable to
Arpeggio.
NOTE: This is *not* a general PEG-to-arpeggio translator; it
just happens to work on the ADQL grammar (and might do the
trick of other simple cases).
"""
with open("adql2.1.peg") as f:
peg_rules = f.read()
# insert semicolons between rules
peg_rules = re.sub(
r"(?m)^[^#](?!(=\<\-)).+\s+"
r"((?!=(\<\-|)(?=\#)).+\n)+",
lambda match: match.group().strip() + ";\n", peg_rules)
# replace comments (TODO: make sure the # isn't in a literal)
peg_rules = re.sub('#', '// ', peg_rules)
# adapt character range syntax
peg_rules = re.sub("'\\[", "r'[", peg_rules)
return ParserPEG(peg_rules,
root,
ignore_case=True,
skipws=False,
debug=False,
reduce_tree=True,
memoization=True)
def test_unordered_group():
grammar = """
g <- (("a" "b") "c" )#;
"""
parser = ParserPEG(grammar, 'g', reduce_tree=True)
r = parser.parse("c a b")
assert isinstance(r, NonTerminal)
r = parser.parse("a b c")
assert isinstance(r, NonTerminal)
with pytest.raises(NoMatch):
parser.parse("a c b")
def test_construct_parser():
parser = ParserPEG(grammar, 'calc')
assert parser.parser_model.rule_name == 'calc'
assert isinstance(parser.parser_model, Sequence)
assert parser.parser_model.nodes[0].name == 'OneOrMore'
def main(debug=False):
# First we will make a parser - an instance of the calc parser model.
# Parser model is given in the form of PEG notation therefore we
# are using ParserPEG class. Root rule name (parsing expression) is "calc".
parser = ParserPEG(calc_grammar, "calc", debug=debug)
# An expression we want to evaluate
input_expr = "-(4-1)*5+(2+4.67)+5.89/(.2+7)"
# Then parse tree is created out of the input_expr expression.
parse_tree = parser.parse(input_expr)
result = parser.getASG(sem_actions)
if debug:
# getASG will start semantic analysis.
# In this case semantic analysis will evaluate expression and
# returned value will be evaluated result of the input_expr expression.
# Semantic actions are supplied to the getASG function.
print("{} = {}".format(input_expr, result))
def main(debug=False):
# First we will make a parser - an instance of the calc parser model.
# Parser model is given in the form of PEG notation therefore we
# are using ParserPEG class. Root rule name (parsing expression) is "calc".
parser = ParserPEG(calc_grammar, "calc", debug=debug)
# An expression we want to evaluate
input_expr = "-(4-1)*5+(2+4.67)+5.89/(.2+7)"
# Then parse tree is created out of the input_expr expression.
parse_tree = parser.parse(input_expr)
result = parser.getASG(sem_actions)
if debug:
# getASG will start semantic analysis.
# In this case semantic analysis will evaluate expression and
# returned value will be evaluated result of the input_expr expression.
# Semantic actions are supplied to the getASG function.
print("{} = {}".format(input_expr, result))
def main(debug=False):
current_dir = os.path.dirname(__file__)
peg_grammar = open(os.path.join(current_dir, 'peg.peg')).read()
# ParserPEG will use ParserPython to parse peg_grammar definition and
# create parser_model for parsing PEG based grammars
# In debug mode dot (graphviz) files for parser model
# and parse tree will be created for visualization.
# Checkout current folder for .dot files.
parser = ParserPEG(peg_grammar, 'peggrammar', debug=debug)
# Now we will use created parser to parse the same peg_grammar used for
# parser initialization. We can parse peg_grammar because it is specified
# using PEG itself.
print("PARSING")
parse_tree = parser.parse(peg_grammar)
# ASG should be the same as parser.parser_model because semantic
# actions will create PEG parser (tree of ParsingExpressions).
parser_model, comment_model = visit_parse_tree(
parse_tree, PEGVisitor(root_rule_name='peggrammar',
comment_rule_name='comment',
ignore_case=False,
debug=debug))
if debug:
# This graph should be the same as peg_peg_parser_model.dot because
# they define the same parser.
PMDOTExporter().exportFile(parser_model,
"peg_peg_new_parser_model.dot")
# If we replace parser_mode with ASG constructed parser it will still
# parse PEG grammars
parser.parser_model = parser_model
parser.parse(peg_grammar)
def check_parser(grammar, text):
"""Test that the PEG parsers correctly parse a grammar and match the given
text. Test both the peg and cleanpeg parsers. Raise an exception if the
grammar parse failed, and returns False if the match fails. Otherwise,
return True.
Parameters:
grammar -- Not the full grammar, but just the PEG expression for a string
literal or regex match, e.g. "'x'" to match an x.
text -- The text to test against the grammar for a match.
"""
# test the peg parser
parser = ParserPEG('top <- ' + grammar + ' EOF;', 'top', skipws=False)
if parser.parse(text) is None:
return False
# test the cleanpeg parser
parser = ParserCleanPEG('top = ' + grammar + ' EOF', 'top', skipws=False)
if parser.parse(text) is None:
return False
return True
def __call__(self):
self.MakeTest(ParserPEG(self.Case1(), "S"), 1)
self.MakeTest(ParserPEG(self.Case2(), "S"), 2)
#self.MakeTest(ParserPEG(self.Case3(), "S"), 3)
self.MakeTest(ParserPEG(self.Case4(), "S"), 4)
self.MakeTest(ParserPEG(self.Case5(), "S"), 5)
self.MakeTest(ParserPEG(self.Case6(), "S"), 6)
self.MakeTest(ParserPEG(self.Case7(), "S"), 7)
def main(debug=False):
# Program code
input = '''
begin
up
up
left
down
right
end
'''
# First we will make a parser - an instance of the robot parser model.
# Parser model is given in the form of PEG specification therefore we
# are using ParserPEG class.
parser = ParserPEG(robot_grammar, 'robot', debug=debug)
# We create a parse tree out of textual input
parse_tree = parser.parse(input)
# visit_parse_tree will start semantic analysis.
# In this case semantic analysis will evaluate expression and
# returned value will be the final position of the robot.
return visit_parse_tree(parse_tree, RobotVisitor(debug=debug))
def main(debug=False, all=False):
peg_grammar = open('liberty.peg').read()
parser = ParserPEG(peg_grammar, 'liberty', 'comment')
def parse_file(file):
print(f"Parsing '{file}'")
test = open(file).read()
tree = parser.parse(test)
# print(tree.tree_str())
return visit_parse_tree(tree, LibertyNodeVisitor(debug=debug))
if all:
tests = glob('tests/*.lib')
with concurrent.futures.ThreadPoolExecutor() as executor:
results = executor.map(parse_file, tests)
print(results)
return results
else:
result = parse_file('tests/sky130_fd_sc_hvl__ff_085C_5v50_lv1v95.lib')
print(result)
def test_unordered_group():
grammar = """
g <- (("a" "b") "c" )#;
"""
parser = ParserPEG(grammar, 'g', reduce_tree=True)
r = parser.parse("c a b")
assert isinstance(r, NonTerminal)
r = parser.parse("a b c")
assert isinstance(r, NonTerminal)
with pytest.raises(NoMatch):
parser.parse("a c b")
def convert_function_to_medusa(arch, func, var):
isabelle_grammar = open(os.path.join(os.path.dirname(__file__), 'isabelle.peg'), 'r').read()
parser = ParserPEG(isabelle_grammar, 'code', debug = False)
parse_tree = parser.parse(func)
prm = { 'cpu_info':'rCpuInfo', }
return visit_parse_tree(parse_tree, IsabelleVisitor(arch, None, var, prm, debug = False)) + "\n"
from arpeggio.peg import ParserPEG
from arpeggio import visit_parse_tree
from .grammar import grammar
from .visitor import IthkuilVisitor
wordParser = ParserPEG(grammar, "word", debug=False)
def parseWord(word):
return visit_parse_tree(wordParser.parse(word),
IthkuilVisitor(debug=False))
# Program code
input = '''
begin
up
up
left
down
right
end
'''
# First we will make a parser - an instance of the robot parser model.
# Parser model is given in the form of PEG specification therefore we
# are using ParserPEG class.
parser = ParserPEG(robot_grammar, 'program')
# Then we export it to a dot file in order to visualize it. This is
# particularly handy for debugging purposes.
# We can make a jpg out of it using dot (part of graphviz) like this
# dot -O -Tjpg robot_peg_parse_tree_model.dot
PMDOTExport().exportFile(parser.parser_model,
"robot_peg_parse_tree_model.dot")
# We create a parse tree out of textual input
parse_tree = parser.parse(input)
# Then we export it to a dot file in order to visualize it.
# dot -O -Tjpg robot_peg_parse_tree.dot
PTDOTExport().exportFile(parse_tree,
"robot_peg_parse_tree.dot")
QUESTION <- '?';
STAR <- '*';
PLUS <- '+';
OPEN <- '(';
CLOSE <- ')';
DOT <- '.';
comment <- '//' r'.*\n';
"""
try:
logging.basicConfig(level=logging.DEBUG)
# ParserPEG will use ParserPython to parse peg_grammar definition and
# create parser_model for parsing PEG based grammars
parser = ParserPEG(peg_grammar, 'grammar')
# Exporting parser model to dot file in order to visualise.
PMDOTExport().exportFile(parser.parser_model,
"peg_peg_parser_model.dot")
# Now we will use created parser to parse the same peg_grammar used for parser
# initialization. We can parse peg_grammar because it is specified using
# PEG itself.
parser.parse(peg_grammar)
PTDOTExport().exportFile(parser.parse_tree,
"peg_peg_parse_tree.dot")
# ASG should be the same as parser.parser_model because semantic
# actions will create PEG parser (tree of ParsingExpressions).
def convert_semantic_to_medusa(arch, insn):
isabelle_grammar = open(os.path.join(os.path.dirname(__file__), 'isabelle.peg'), 'r').read()
parser = ParserPEG(isabelle_grammar, 'code', debug = False)
parse_tree = parser.parse(insn['semantic'])
prm = { 'cpu_info':'m_CpuInfo', }
return visit_parse_tree(parse_tree, IsabelleVisitor(arch, insn, None, prm, debug = False)) + "\n"
def get_parser(root, debug=False):
if not root in _PARSER:
_PARSER[root] = ParserPEG(kusto_peg, root, debug=debug)
return _PARSER[root]
from arpeggio.peg import ParserPEG # pylint: disable=import-error
from arpeggio import PTNodeVisitor, visit_parse_tree # pylint: disable=import-error
lang = ""
with open("lang.txt", 'r') as f:
lang = f.read()
parser = ParserPEG(lang, 'program', debug=False)
def get(state, name):
if name in state:
return state[name]
else:
return 0
def cint(state, val, name):
s = dict(state)
s[name] = val
return s
def cname(state, n1, n2):
s = dict(state)
s[n1] = get(s, n2)
return s
def inc(state, name):
s = dict(state)
s[name] = get(s, name) +1
return s
def dec(state, name):
def main(debug=False):
isabelle_grammar = open(
os.path.join(os.path.dirname(__file__), 'isabelle.peg'), 'r').read()
parser = ParserPEG(isabelle_grammar, 'code', debug=False)
def parser() -> ParserPEG:
path = os.path.dirname(__file__)
filename = os.path.join(path, 'peg.peg')
with open(filename, 'r') as file:
grammar = file.read()
return ParserPEG(grammar, 'peggrammar', 'comment')
# Rules are mapped to semantic actions
sem_actions = {
"number" : ToFloat(),
"factor" : Factor(),
"term" : Term(),
"expression" : Expr(),
"calc" : Calc()
}
try:
logging.basicConfig(level=logging.DEBUG)
# First we will make a parser - an instance of the calc parser model.
# Parser model is given in the form of PEG notation therefore we
# are using ParserPEG class. Root rule name (parsing expression) is "calc".
parser = ParserPEG(calc_grammar, "calc")
# Then we export it to a dot file.
PMDOTExport().exportFile(parser.parser_model,
"calc_peg_parser_model.dot")
# An expression we want to evaluate
input = "-(4-1)*5+(2+4.67)+5.89/(.2+7)"
# Then parse tree is created out of the input expression.
parse_tree = parser.parse(input)
# We save it to dot file in order to visualise it.
PTDOTExport().exportFile(parse_tree,
"calc_peg_parse_tree.dot")
number <- r'\d*\.\d*|\d+';
factor <- ("+" / "-")?
(number / "(" expression ")");
// This is another comment
term <- factor (( "*" / "/") factor)*;
expression <- term (("+" / "-") term)*;
calc <- expression+ EOF;
// And final comment at the end of file
'''
clean_grammar = grammar.replace('<-', '=').replace(';', '')
@pytest.mark.parametrize(
'parser',
[ParserPEG(grammar, 'calc'),
ParserPEGClean(clean_grammar, 'calc')])
def test_construct_parser(parser):
assert parser.parser_model.rule_name == 'calc'
assert isinstance(parser.parser_model, Sequence)
assert parser.parser_model.nodes[0].name == 'OneOrMore'
@pytest.mark.parametrize(
'parser',
[ParserPEG(grammar, 'calc'),
ParserPEGClean(clean_grammar, 'calc')])
def test_parse_input(parser):
input = "4+5*7/3.45*-45*(2.56+32)/-56*(2-1.34)"
result = parser.parse(input)
