def _get_parser(strict): """Ensure the module-level peg parser is created and return it.""" global _strict_parser, _permissive_parser # Each branch below only acquires the lock if the global is unset. if strict: if _strict_parser is None: with _parser_create_lock: if _strict_parser is None: _strict_parser = ParserPEG( canonical, root_rule_name='version', skipws=False ) return _strict_parser else: if _permissive_parser is None: with _parser_create_lock: if _permissive_parser is None: _permissive_parser = ParserPEG( permissive, root_rule_name='version', skipws=False, ignore_case=True, ) return _permissive_parser
def solve(file, verbose): simple_parser = ParserPEG(simple_grammar, root_rule_name='expr') advanced_parser = ParserPEG(advanced_grammar, root_rule_name='expr') simple_sum = 0 advanced_sum = 0 for line in file: parse_tree = simple_parser.parse(line) simple_sum += visit_parse_tree(parse_tree, SimpleVisitor()) parse_tree = advanced_parser.parse(line) advanced_sum += visit_parse_tree(parse_tree, AdvancedVisitor()) print('Part 1:', simple_sum) print('Part 2:', advanced_sum)
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, "document", debug=debug) filename = sys.argv[1] with open(filename) as file: contents = file.read() # An expression we want to evaluate input_expr = "<tag>dgdg</tag>" input_expr = contents # Then parse tree is created out of the input_expr expression. parse_tree = parser.parse(input_expr) #result = parser.getASG(sem_actions) #print( result ) print(parse_tree) 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 parse(filename, debug=False): with open(filename) as file: contents = file.read() parser = ParserPEG(calc_grammar, "start", True) parse_tree = parser.parse(contents) visitor = Visitor(debug=debug) result = visit_parse_tree(parse_tree, visitor ) #Try to get if we found anything or not if ( visitor.functions or visitor.classes): print (visitor.namespace ) return visitor print ("Empty") return None
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 construct( arpeg_node ) : with open( "apl_grammar.txt", "rt", encoding='utf8' ) as f_in : funpy_grammar = f_in.read() parser = ParserPEG(funpy_grammar, "program", reduce_tree=True, debug=1) parser.debug = 1 #def test( parser ) : #parser.parse("R") #result = parser.parse("⌽A") OK #result = parser.parse("⌽[1]A") # OK result = parser.parse("⊖⌽A") # OK #result = parser.parse("") #result = parser.parse("") #result = parser.parse("") #result = parser.parse("") #result = parser.parse("") #result = parser.parse("") #result = parser.parse("") #result = parser.parse("") #result = parser.parse("") result
def interactive_testing(): # %% parser = ParserPEG(peg_grammar, root_rule_name='search_expr') # %% parser.parse('fld:4 AND fld1:5') # %% parser.parse('fld:1 TO 2') # %% parser.parse('NOT fld:true') # %% parser.parse('price < 10 AND (category:Book OR NOT category:Ebook)') # %% parser.parse('country:Colombia OR country:USA') # %% d = parser.parse('country:Colombia OR country:USA') # %% parser.parse('NOT country:venezuela') # %% parser.parse( '(category:Book OR category:Ebook) AND NOT author:"JK Rowling"') # %% parser.parse("f1:v1 OR f2:v2") # %% parser.parse("NOT(f1:v1 OR f2:v2)") # %% parser.parse('x AND y OR z AND a OR b') # %% parser.parse('x OR y AND z OR a AND b') # %% parser.parse('(x OR y) AND (z OR a) AND b')
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", True) analyseASG( parser, input, Visitor(), True, False ) # filename = sys.argv[1] # with open(filename) as file: # contents = file.read() # # # An expression we want to evaluate input_expr = """public function __construct( $rtt = hh ) { }""" # input_expr = contents input_expr = input # Then parse tree is created out of the input_expr expression. #parse_tree = parser.parse(input_expr) #result = parser.getASG(sem_actions) #print( parse_tree ) #print( result ) 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 __init__(self, grammarPath = None, root: str = 'volpiano', strict: bool = False, **kwargs) -> None: """Initialize a Cantus Volpiano parser. Parameters ---------- grammarPath : str, optional Path to the PEG grammar file, defaults to ``grammars/cantus_volpiano.peg`` root : str, optional Root element of the parser, by default 'volpiano' strict : bool, optional Whether to parse in strict mode or not. In strict mode, exceptions are raised whenever volpiano strings deviate from the standard syntax. In non-strict mode, some deviations will be automatically corrected. See :meth:`ParserCantusVolpiano.preprocess` for details. By default True **kwargs Other keywords are passed to :class:`ParserPeg`. """ if grammarPath == None: grammarPath = GRAMMAR_PATH if not os.path.exists(grammarPath): raise Exception(f'Grammar file ({ grammarPath }) does not exist') with open(grammarPath, 'r') as handle: grammar = handle.read() self.strict = strict self.parser = ParserPEG(grammar, root, skipws=False, **kwargs)
def get_rule_parser(): grammar = ''' rule = int ':' (str / seq ('|' seq)*) seq = int+ str = '"' r'[^"]+' '"' int = r'[0-9]+' ''' return ParserPEG(grammar, root_rule_name='rule')
def parse(input_expr, context, debug=False): with open(os.path.join(os.path.dirname(__file__), 'matrip.peg'), 'r') as f: grammar = f.read() parser = ParserPEG(grammar, "matrip", debug=debug) parse_tree = parser.parse(input_expr) visitor = MatripVisitor(debug=debug) visit_parse_tree(parse_tree, visitor) return generate_base_table(visitor.measures, visitor.expressions, context)
def runSmurf(program): parser = ParserPEG(grammar, "program", "comment", debug=False) parse_tree = parser.parse(program) ast = visit_parse_tree(parse_tree, NodeVisitor(debug=False)) ast.accept(Interpreter()) # runSmurf(""" # let a = 5, b = 4 print(a+b) # """)
def test_regex_with_empty_successful_match_in_repetition(): grammar = \ """ rule = (subexpression)+ subexpression = r'^.*$' """ parser = ParserPEG(grammar, "rule") parsed = parser.parse("something simple") assert parsed.rule_name == "rule" assert parsed.subexpression.rule_name == "subexpression"
def runGrammar(program): parser = ParserPEG(grammar, "program", "comment", debug=False) tree = parser.parse(program) ast = visit_parse_tree(tree, VisitorClass(debug=False)) ast.accept(Interpreter()) # runGrammar(""" # let f = fn (a) { a + 1 } # print(f(3)) # """)
def test_issue_16(): parser = ParserPEG(grammar, "calc", skipws=False) input_expr = """public function __construct( )""" parse_tree = parser.parse(input_expr) # Do semantic analysis. Do not use default actions. asg = parser.getASG(sem_actions=sem_actions, defaults=False) assert asg
def solve(file, verbose): parser = ParserPEG(grammar, root_rule_name='rules') parse_tree = parser.parse(file.read()) rules = visit_parse_tree(parse_tree, BagVisitor()) graph = nx.DiGraph() for rule in rules: for bag in rule.contains: graph.add_edge(rule.bag.name, bag.name, quantity=bag.quantity) print('Part 1:', len(nx.ancestors(graph, 'shiny gold'))) print('Part 2:', count_bags(graph, 'shiny gold'))
def main(debug=False): filename = sys.argv[1] #debug = bool(sys.argv[2]) with open(filename) as file: contents = file.read() #print (contents) # # An expression we want to evaluate input_expr = """class Application extends Container implements HttpKernelInterface, TerminableInterface, ResponsePreparerInterface { """ # input_expr = input input_expr = contents if not input_expr: return None # 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, "start", True) # Then parse tree is created out of the input_expr expression. parse_tree = parser.parse(input_expr) visitor = Visitor(debug=debug) result = visit_parse_tree(parse_tree, visitor ) print (visitor.namespace ) #print (visitor.classes ) #print (visitor.functions ) # analyseASG( parser, input, Visitor(), True, False ) # Then parse tree is created out of the input_expr expression. #parse_tree = parser.parse(input_expr) #result = parser.getASG(sem_actions) #print( parse_tree ) #print( result ) 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 parse(input_expr): """ @param input_expr type str @return calcVisitor type CalcVisitor """ parser = ParserPEG(calc_grammar, "calc") parse_tree = parser.parse(input_expr) calcVisitor = CalcVisitor() visit_parse_tree(parse_tree, calcVisitor) return calcVisitor
def solve(file, verbose): parser = ParserPEG(grammar, root_rule_name='passports', skipws=False) parse_tree = parser.parse(file.read()) required = {'byr', 'iyr', 'eyr', 'hgt', 'hcl', 'ecl', 'pid'} valid_keys = 0 valid_strict = 0 schema = PassportSchema() for passport in visit_parse_tree(parse_tree, PassportVisitor()): if required <= passport.keys(): valid_keys += 1 if not schema.validate(passport): valid_strict += 1 print('Part 1:', valid_keys) print('Part 2:', valid_strict)
def main(debug=False): # First we will make a parser - an instance of the CVS parser model. # Parser model is given in the form of clean PEG description therefore we # are using ParserPEG class from arpeggio.clenapeg. Grammar is loaded from # csv.peg file Skipping of whitespace will be done only for tabs and # spaces. Newlines have semantics in csv files. They are used to separate # records. current_dir = os.path.dirname(__file__) csv_grammar = open(os.path.join(current_dir, 'csv.peg'), 'r').read() parser = ParserPEG(csv_grammar, 'csvfile', ws='\t ', debug=debug) # Creating parse tree out of textual input test_data = open(os.path.join(current_dir, 'test_data.csv'), 'r').read() parse_tree = parser.parse(test_data) # Create list of lists using visitor csv_content = visit_parse_tree(parse_tree, CSVVisitor()) print("This is a list of lists with the data from CSV file.") pp = pprint.PrettyPrinter(indent=4) pp.pprint(csv_content)
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", True) # 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 __init__(self, grammarPath: str = GRAMMAR_PATH, root: str = 'text', **kwargs) -> None: """Initialize a Cantus Text parser. Parameters ---------- grammarPath : str, optional Path to the PEG grammar file, defaults to ``cantus/cantus_text.peg`` root : str, optional Root element of the parser, by default 'text' **kwargs Other keywords are passed to :class:`ParserPeg`. """ if not os.path.exists(grammarPath): raise Exception(f'Grammar file ({ grammarPath }) does not exist') with open(grammarPath, 'r') as handle: grammar = handle.read() self.parser = ParserPEG(grammar, root, skipws=False, **kwargs)
def main(debug=False): current_dir = os.path.dirname(__file__) # Load grammar robot_grammar = open(os.path.join(current_dir, 'robot.peg')).read() # 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) # Load program code robot_program = open(os.path.join(current_dir, 'program.rbt')).read() # We create a parse tree out of textual input parse_tree = parser.parse(robot_program) # 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 __init__(self, grammarPath: str = GRAMMAR_PATH, root: str = 'file', **kwargs) -> None: """ Args: grammar_path (:obj:`str`, optional): path to the grammar file (default is gabc/gabc.peg) root (:obj:`str`, optional): the root element of the parser (default is 'file') """ if not os.path.exists(grammarPath): raise Exception(f'Grammar file ({ grammarPath }) does not exist') with open(grammarPath, 'r') as handle: grammar = handle.read() self.parser = ParserPEG(grammar, root, skipws=False, memoization=True, **kwargs)
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 python constructs therefore we # are using ParserPython class. with open('calc.peg', 'r') as file: data = file.read() parser = ParserPEG(data, "calc") # An expression we want to evaluate input_expr = "-(4-1)*5+(2+4.67)+5.89/(.2+7)" # We create a parse tree out of textual input_expr 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(): with open('java2.peg', 'r') as file: data = file.read() parser = ParserPEG(data, "java") # ok_samples = [ # "class Baz extends Korv implements Runnable, Comparable {}", # "class Bar implements Runnable, Comparable {}", # "class Korv extends Fisk {}", # "class Knas {}", # "class Foo implements Runnable {}", # "class HejA { int foo() {} }", #"class HejB { int foo(String apaB) {} }", #"class HejC { int foo(String apaC, int korvC) {} }", #"class HejD { int foo(String apaD, int korvD, Object raketD) {} }", #"class HejE { int foo() {} void bar(){} }", #"class HejF extends Knas { int foo() {} void bar(){} }", #"class HejG extends Knas implements Runnable { int foo() {} void bar(){} }", # ] # fail_samples = [ # "class {}", # "class Knas extends implements Runnable {}", # "class Foo implements {}", # ] ok_samples = [ "sampleinputs/SampleD.java", "sampleinputs/SampleB.java", "sampleinputs/SampleC.java", "sampleinputs/SampleA.java", ] for input_file in ok_samples: with open(input_file, 'r') as file: input_expr = file.read() parse_tree = parser.parse(input_expr) result = visit_parse_tree(parse_tree, CalcVisitor(debug=False)) print(str(result[0]))
relop = '==' / '!=' / '>=' / '>' / '<=' / '<' primary = integer / function_call / variable_reference / "(" arithmetic_expression ")" function_call = variable_reference "(" call_arguments ")" / "print" "(" call_arguments ")" call_arguments = (expr ("," expr)*)? function_definition = param_list brace_block param_list = "(" identifier ("," identifier)* ")" / "(" ")" brace_block = "{" code "}" """ with open(argv[1]) as file: filePath = file.read() #PARSERPG WENT ALONG BEST WITH MY SYTAX FOR THE GRAMMER #PARSERS THROUGHT THE WHOLE SYTAX parser = ParserPEG(grammer, "program", "comment") #THIS IS THE PARSING FOR THE FILE parse_tree = parser.parse(filePath) #THIS IS THE BUILDING OF ASTTREE ast = visit_parse_tree(parse_tree, Visitor()) #CALLS INTERPRETER ast.accept(Interpreter())
release = int (dot int)* pre = sep? pre_tag pre_post_num? pre_tag = "c" / "rc" / "alpha" / "a" / "beta" / "b" / "preview" / "pre" post = sep? post_tag pre_post_num? post_implicit = "-" int post_tag = "post" / "rev" / "r" pre_post_num = sep? int dev = sep? "dev" int? local = "+" r'([a-zA-Z0-9]+([-_\.][a-zA-Z0-9]+)*)' sep = dot / "-" / "_" dot = "." int = r'[0-9]+' alpha = r'[a-zA-Z0-9]' ''' _strict_parser = ParserPEG(canonical, root_rule_name='version', skipws=False) _permissive_parser = ParserPEG( permissive, root_rule_name='version', skipws=False, ignore_case=True) def unwrap_token(value): if isinstance(value, Token): return value.value return value @attr.s class Token(object): value = attr.ib()
from arpeggio import visit_parse_tree from arpeggio.cleanpeg import ParserPEG from nose.tools import assert_equal from calculette_impots_m_language_parser.scripts import m_to_ast script_dir_path = os.path.dirname(os.path.abspath(__file__)) distribution_dir_path = pkg_resources.get_distribution( 'calculette_impots_m_language_parser').location m_grammar_file_path = os.path.join(distribution_dir_path, 'm_language.cleanpeg') with open(m_grammar_file_path) as m_grammar_file: m_grammar = m_grammar_file.read() m_parser = m_to_ast.m_parser = ParserPEG(m_grammar, 'm_source_file', reduce_tree=False) class args(object): debug = False no_order = False m_to_ast.args = args def test_smoke(): smoke_m_file_path = os.path.join(script_dir_path, 'valid_formulas.m') with open(smoke_m_file_path) as smoke_m_file:
import os import sys from simulator import Simulator from exceptions import SimulationError MAX_REG = 15 if len(sys.argv) == 2: MAX_REG = int(sys.argv[1]) # Load the parser with the correct grammar from arpeggio.cleanpeg import ParserPEG, NoMatch, PTNodeVisitor, visit_parse_tree grammar = open(os.path.join(os.path.dirname(__file__), 'grammar.peg'), 'r').read() parser = ParserPEG(grammar, "program", "comment", debug=False) # A little visitor to insert instructions and lines informations in the tree class SetInstructionVisitor(PTNodeVisitor): instruction = -1 line = -1 def __init__(self, instruction, line): self.instruction = instruction self.line = line super().__init__(self) def visit__default__(self, node, children): node.instruction = self.instruction node.line = self.line