Examples update.

examples/bibtex.py

@@ -42,12 +42,12 @@ class BibFileSem(SemanticAction):
     """
     Just returns list of child nodes (bibentries).
     """
-    def first_pass(self, parser, node, nodes):
+    def first_pass(self, parser, node, children):
         if parser.debug:
             print "Processing Bibfile"
 
         # Return only dict nodes
-        return [x for x in nodes if type(x) is dict]
+        return [x for x in children if type(x) is dict]
 
 
 class BibEntrySem(SemanticAction):
@@ -55,14 +55,14 @@ class BibEntrySem(SemanticAction):
     Constructs a map where key is bibentry field name.
     Key is returned under 'bibkey' key. Type is returned under 'bibtype'.
     """
-    def first_pass(self, parser, node, nodes):
+    def first_pass(self, parser, node, children):
         if parser.debug:
-            print "  Processing bibentry %s" % nodes[2]
+            print "  Processing bibentry %s" % children[2]
         bib_entry_map = {
-            'bibtype': nodes[0].value,
-            'bibkey': nodes[2].value
+            'bibtype': children[0].value,
+            'bibkey': children[2].value
         }
-        for field in nodes[3:]:
+        for field in children[3:]:
             if isinstance(field, tuple):
                 bib_entry_map[field[0]] = field[1]
         return bib_entry_map
@@ -72,10 +72,10 @@ class FieldSem(SemanticAction):
     """
     Constructs a tuple (fieldname, fieldvalue).
     """
-    def first_pass(self, parser, node, nodes):
+    def first_pass(self, parser, node, children):
         if parser.debug:
-            print "    Processing field %s" % nodes[0]
-        field = (nodes[0].value, nodes[2])
+            print "    Processing field %s" % children[0]
+        field = (children[0].value, children[2])
         return field
 
 
@@ -84,8 +84,8 @@ class FieldValueSem(SemanticAction):
     Serbian Serbian letters form latex encoding to Unicode.
     Remove braces. Remove newlines.
     """
-    def first_pass(self, parser, node, nodes):
-        value = nodes[1].value
+    def first_pass(self, parser, node, children):
+        value = children[1].value
         value = value.replace(r"\'{c}", u"ć")\
                     .replace(r"\'{C}", u"Ć")\
                     .replace(r"\v{c}", u"č")\
@@ -114,8 +114,7 @@ if __name__ == "__main__":
     # particulary handy for debugging purposes.
     # We can make a jpg out of it using dot (part of graphviz) like this
     # dot -O -Tjpg calc_parse_tree_model.dot
-    PMDOTExporter().exportFile(parser.parser_model,
-                    "bib_parse_tree_model.dot")
+    PMDOTExporter().exportFile(parser.parser_model, "bib_parse_tree_model.dot")
 
     # First parameter is bibtex file
     if len(sys.argv) > 1:
@@ -127,8 +126,7 @@ if __name__ == "__main__":
             parse_tree = parser.parse(bibtexfile_content)
 
             # Then we export it to a dot file in order to visualise it.
-            PTDOTExporter().exportFile(parse_tree,
-                            "bib_parse_tree.dot")
+            PTDOTExporter().exportFile(parse_tree, "bib_parse_tree.dot")
 
             # getASG will start semantic analysis.
             # In this case semantic analysis will list of bibentry maps.

examples/calc.py

@@ -27,7 +27,7 @@ class ToFloat(SemanticAction):
     """
     Converts node value to float.
     """
-    def first_pass(self, parser, node, nodes):
+    def first_pass(self, parser, node, children):
         print "Converting %s." % node.value
         return float(node.value)
 
@@ -35,32 +35,32 @@ class Factor(SemanticAction):
     """
     Removes parenthesis if exists and returns what was contained inside.
     """
-    def first_pass(self, parser, node, nodes):
-        print "Factor %s" % nodes
-        if len(nodes) == 1:
-            return nodes[0]
-        sign = -1 if nodes[0] == '-' else 1
+    def first_pass(self, parser, node, children):
+        print "Factor %s" % children
+        if len(children) == 1:
+            return children[0]
+        sign = -1 if children[0] == '-' else 1
         next = 0
-        if nodes[0] in ['+', '-']:
+        if children[0] in ['+', '-']:
             next = 1
-        if nodes[next] == '(':
-            return sign * nodes[next+1]
+        if children[next] == '(':
+            return sign * children[next+1]
         else:
-            return sign * nodes[next]
+            return sign * children[next]
 
 class Term(SemanticAction):
     """
     Divides or multiplies factors.
     Factor nodes will be already evaluated.
     """
-    def first_pass(self, parser, node, nodes):
-        print "Term %s" % nodes
-        term = nodes[0]
-        for i in range(2, len(nodes), 2):
-            if nodes[i-1]=="*":
-                term *= nodes[i]
+    def first_pass(self, parser, node, children):
+        print "Term %s" % children
+        term = children[0]
+        for i in range(2, len(children), 2):
+            if children[i-1]=="*":
+                term *= children[i]
             else:
-                term /= nodes[i]
+                term /= children[i]
         print "Term = %f" % term
         return term
 
@@ -69,26 +69,26 @@ class Expr(SemanticAction):
     Adds or substracts terms.
     Term nodes will be already evaluated.
     """
-    def first_pass(self, parser, node, nodes):
-        print "Expression %s" % nodes
+    def first_pass(self, parser, node, children):
+        print "Expression %s" % children
         expr = 0
         start = 0
         # Check for unary + or - operator
-        if str(nodes[0]) in "+-":
+        if str(children[0]) in "+-":
             start = 1
 
-        for i in range(start, len(nodes), 2):
-            if i and nodes[i-1]=="-":
-                expr -= nodes[i]
+        for i in range(start, len(children), 2):
+            if i and children[i-1]=="-":
+                expr -= children[i]
             else:
-                expr += nodes[i]
+                expr += children[i]
 
         print "Expression = %f" % expr
         return expr
 
 class Calc(SemanticAction):
-    def first_pass(self, parser, node, nodes):
-        return nodes[0]
+    def first_pass(self, parser, node, children):
+        return children[0]
 
 # Connecting rules with semantic actions
 number.sem = ToFloat()
@@ -98,7 +98,7 @@ expression.sem = Expr()
 calc.sem = Calc()
 
 if __name__ == "__main__":
-    try:
+
     # 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.
@@ -108,8 +108,7 @@ if __name__ == "__main__":
     # This step is optional but it is handy for debugging purposes.
     # We can make a png out of it using dot (part of graphviz) like this
     # dot -O -Tpng calc_parse_tree_model.dot
-        PMDOTExporter().exportFile(parser.parser_model,
-                        "calc_parse_tree_model.dot")
+    PMDOTExporter().exportFile(parser.parser_model, "calc_parse_tree_model.dot")
 
     # An expression we want to evaluate
     input = "-(4-1)*5+(2+4.67)+5.89/(.2+7)"
@@ -119,13 +118,10 @@ if __name__ == "__main__":
 
     # Then we export it to a dot file in order to visualise it.
     # This is also optional.
-        PTDOTExporter().exportFile(parse_tree,
-                        "calc_parse_tree.dot")
+    PTDOTExporter().exportFile(parse_tree, "calc_parse_tree.dot")
 
     # getASG will start semantic analysis.
     # In this case semantic analysis will evaluate expression and
     # returned value will be the result of the input expression.
     print "%s = %f" % (input, parser.getASG())
 
-    except NoMatch, e:
-        print "Expected %s at position %s." % (e.value, str(e.parser.pos_to_linecol(e.position)))

examples/calc_peg.py

@@ -39,33 +39,28 @@ sem_actions = {
     "calc"   : Calc()
 }
 
-try:
 
-    # 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=True)
+# 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=True)
 
 
-    # Then we export it to a dot file.
-    PMDOTExporter().exportFile(parser.parser_model,
-                "calc_peg_parser_model.dot")
+# Then we export it to a dot file.
+PMDOTExporter().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)"
+# 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)
+# 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.
-    PTDOTExporter().exportFile(parse_tree,
-                    "calc_peg_parse_tree.dot")
+# We save it to dot file in order to visualise it.
+PTDOTExporter().exportFile(parse_tree, "calc_peg_parse_tree.dot")
 
-    # getASG will start semantic analysis.
-    # In this case semantic analysis will evaluate expression and
-    # returned value will be evaluated result of the input expression.
-    # Semantic actions are supplied to the getASG function.
-    print "%s = %f" % (input, parser.getASG(sem_actions))
+# getASG will start semantic analysis.
+# In this case semantic analysis will evaluate expression and
+# returned value will be evaluated result of the input expression.
+# Semantic actions are supplied to the getASG function.
+print "%s = %f" % (input, parser.getASG(sem_actions))
 
-except NoMatch, e:
-    print "Expected %s at position %s." % (e.value, str(e.parser.pos_to_linecol(e.position)))

examples/csv.py

@@ -26,7 +26,6 @@ Unquoted test 2, "Quoted test with ""inner"" quotes", 23234, One Two Three, "343
 Unquoted test 3, "Quoted test 3", 23234, One Two Three, "343456.45"
     '''
 
-    try:
     # First we will make a parser - an instance of the CVS parser model.
     # Parser model is given in the form of python constructs therefore we
     # are using ParserPython class.
@@ -38,8 +37,7 @@ Unquoted test 3, "Quoted test 3", 23234, One Two Three, "343456.45"
     # This step is optional but it is handy for debugging purposes.
     # We can make a png out of it using dot (part of graphviz) like this:
     # dot -O -Tpng calc_parse_tree_model.dot
-        PMDOTExporter().exportFile(parser.parser_model,
-                                 "csv_parse_tree_model.dot")
+    PMDOTExporter().exportFile(parser.parser_model, "csv_parse_tree_model.dot")
 
     # Creating parse tree out of textual input
     parse_tree = parser.parse(test_data)
@@ -47,8 +45,5 @@ Unquoted test 3, "Quoted test 3", 23234, One Two Three, "343456.45"
     # Then we export it to a dot file in order to visualise it.
     # This is also optional.
     # dot -O -Tpng calc_parse_tree.dot
-        PTDOTExporter().exportFile(parse_tree,
-                                 "csv_parse_tree.dot")
+    PTDOTExporter().exportFile(parse_tree, "csv_parse_tree.dot")
 
-    except NoMatch, e:
-        print "Expected %s at position %s." % (e.value, str(e.parser.pos_to_linecol(e.position)))

examples/json.py

@@ -81,19 +81,16 @@ if __name__ == "__main__":
         }
     }
     """
-    try:
     # Creating parser from parser model.
     parser = ParserPython(jsonFile, debug=True)
 
     # Exporting parser model to dot file in order to visualise it.
-        PMDOTExporter().exportFile(parser.parser_model,
-                "json_parser_model.dot")
+    PMDOTExporter().exportFile(parser.parser_model, "json_parser_model.dot")
 
+    # Parse json string
     parse_tree = parser.parse(testdata)
 
-        PTDOTExporter().exportFile(parser.parse_tree,
-                "json_parse_tree.dot")
+    # Export parse tree for visualization
+    PTDOTExporter().exportFile(parser.parse_tree, "json_parse_tree.dot")
 
-    except NoMatch, e:
-        print "Expected %s at position %s." % (e.value, str(e.parser.pos_to_linecol(e.position)))
 

examples/peg_peg.py

@@ -49,7 +49,7 @@ peg_grammar = r"""
                 / ("(" ordered_choice ")") / literal;
 
  identifier <- r'[a-zA-Z_]([a-zA-Z_]|[0-9])*';
- regex <- 'r' '\'' r'(\\\'|[^\'])*' '\'';
+ regex <- 'r\'' r'(\\\'|[^\'])*' '\'';
  literal <- r'\'(\\\'|[^\'])*\'|"[^"]*"';
  LEFT_ARROW <- '<-';
  SLASH <- '/';
@@ -65,39 +65,34 @@ peg_grammar = r"""
 """
 
 
-try:
+# ParserPEG will use ParserPython to parse peg_grammar definition and
+# create parser_model for parsing PEG based grammars
+parser = ParserPEG(peg_grammar, 'grammar', debug=True)
 
-    # ParserPEG will use ParserPython to parse peg_grammar definition and
-    # create parser_model for parsing PEG based grammars
-    parser = ParserPEG(peg_grammar, 'grammar', debug=True)
-
-    # Exporting parser model to dot file for visualization.
-    PMDOTExporter().exportFile(parser.parser_model,
+# Exporting parser model to dot file for visualization.
+PMDOTExporter().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)
+# 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)
 
-    # Again we export parse tree in dot file for vizualization.
-    PTDOTExporter().exportFile(parser.parse_tree,
+# Again we export parse tree in dot file for vizualization.
+PTDOTExporter().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).
-    asg = parser.getASG(sem_actions)
+# ASG should be the same as parser.parser_model because semantic
+# actions will create PEG parser (tree of ParsingExpressions).
+asg = parser.getASG(sem_actions)
 
-    # This graph should be the same as peg_peg_parser_model.dot because
-    # they define the same parser.
-    PMDOTExporter().exportFile(asg,
+# This graph should be the same as peg_peg_parser_model.dot because
+# they define the same parser.
+PMDOTExporter().exportFile(asg,
                          "peg_peg_asg.dot")
 
-    # If we replace parser_mode with ASG constructed parser it will still
-    # parse PEG grammars
-    parser.parser_model = asg
-    parser.parse(peg_grammar)
+# If we replace parser_mode with ASG constructed parser it will still
+# parse PEG grammars
+parser.parser_model = asg
+parser.parse(peg_grammar)
 
-except NoMatch, e:
-    print "Expected %s at position %s." % \
-          (e.value, str(e.parser.pos_to_linecol(e.position)))

examples/robot.py

@@ -33,35 +33,35 @@ def right():        return 'right'
 
 # Semantic actions
 class Up(SemanticAction):
-    def first_pass(self, parser, node, nodes):
+    def first_pass(self, parser, node, children):
         print "Going up"
         return (0, 1)
 
 class Down(SemanticAction):
-    def first_pass(self, parser, node, nodes):
+    def first_pass(self, parser, node, children):
         print "Going down"
         return (0, -1)
 
 class Left(SemanticAction):
-    def first_pass(self, parser, node, nodes):
+    def first_pass(self, parser, node, children):
         print "Going left"
         return (-1, 0)
 
 class Right(SemanticAction):
-    def first_pass(self, parser, node, nodes):
+    def first_pass(self, parser, node, children):
         print "Going right"
         return (1, 0)
 
 class Command(SemanticAction):
-    def first_pass(self, parser, node, nodes):
+    def first_pass(self, parser, node, children):
         print "Command"
         return nodes[0]
 
 
 class Program(SemanticAction):
-    def first_pass(self, parser, node, nodes):
+    def first_pass(self, parser, node, children):
         print "Evaluating position"
-        return reduce(lambda x, y: (x[0]+y[0], x[1]+y[1]), nodes[1:-2])
+        return reduce(lambda x, y: (x[0]+y[0], x[1]+y[1]), children[1:-2])
 
 # Connecting rules with semantic actions
 program.sem = Program()
@@ -72,7 +72,6 @@ left.sem = Left()
 right.sem = Right()
 
 if __name__ == "__main__":
-    try:
 
     # Program code
     input = '''
@@ -111,5 +110,3 @@ if __name__ == "__main__":
     # returned value will be the final position of the robot.
     print "position = ", parser.getASG()
 
-    except NoMatch, e:
-        print "Expected %s at position %s." % (e.value, str(e.parser.pos_to_linecol(e.position)))

examples/robot_peg.py

@@ -46,7 +46,6 @@ semantic_actions = {
 
 
 if __name__ == "__main__":
-    try:
 
     # Program code
     input = '''
@@ -85,5 +84,3 @@ if __name__ == "__main__":
     # returned value will be the final position of the robot.
     print "position = ", parser.getASG(sem_actions=semantic_actions)
 
-    except NoMatch, e:
-        print "Expected %s at position %s." % (e.value, str(e.parser.pos_to_linecol(e.position)))

examples/simple.py

@@ -13,6 +13,7 @@ from arpeggio import *
 from arpeggio.export import PMDOTExporter, PTDOTExporter
 from arpeggio import RegExMatch as _
 
+# Grammar
 def comment():          return [_("//.*"), _("/\*.*\*/")]
 def literal():          return _(r'\d*\.\d*|\d+|".*?"')
 def symbol():           return _(r"\w+")
@@ -29,23 +30,20 @@ def functioncall():     return symbol, "(", expressionlist, ")"
 def function():         return Kwd("function"), symbol, parameterlist, block
 def simpleLanguage():   return function
 
-try:
 
-    # Parser instantiation. simpleLanguage is the definition of the root rule
-    # and comment is a grammar rule for comments.
-    parser = ParserPython(simpleLanguage, comment, debug=True)
+# Parser instantiation. simpleLanguage is the definition of the root rule
+# and comment is a grammar rule for comments.
+parser = ParserPython(simpleLanguage, comment, debug=True)
 
-    # We save parser model to dot file in order to visualise it.
-    # We can make a png out of it using dot (part of graphviz) like this
-    # dot -Tpng -O simple_parser.dot
-    PMDOTExporter().exportFile(parser.parser_model,
-            "simple_parser_model.dot")
+# We save parser model to dot file in order to visualise it.
+# We can make a png out of it using dot (part of graphviz) like this
+# dot -Tpng -O simple_parser.dot
+PMDOTExporter().exportFile(parser.parser_model, "simple_parser_model.dot")
 
-    # Parser model for comments is handled as separate model
-    PMDOTExporter().exportFile(parser.comments_model,
-            "simple_parser_comments.dot")
+# Parser model for comments is handled as separate model
+PMDOTExporter().exportFile(parser.comments_model, "simple_parser_comments.dot")
 
-    input = """
+input = """
     function fak(n) {
         if (n==0) {
             // For 0! result is 0
@@ -54,11 +52,9 @@ try:
             return n * fak(n - 1);
         };
     }
-    """
-    parse_tree = parser.parse(input)
+"""
+parse_tree = parser.parse(input)
 
-    PTDOTExporter().exportFile(parse_tree,
-            "simple_parse_tree.dot")
+# Export parse tree for visualization
+PTDOTExporter().exportFile(parse_tree, "simple_parse_tree.dot")
 
-except NoMatch, e:
-    print "Expected %s at position %s." % (e.value, str(e.parser.pos_to_linecol(e.position)))