NonTerminal inherits list now.

arpeggio/__init__.py

@@ -603,7 +603,7 @@ class Terminal(ParseTreeNode):
         return str(self) == str(other)
 
 
-class NonTerminal(ParseTreeNode):
+class NonTerminal(ParseTreeNode, list):
     """
     Non-leaf node of the Parse Tree. Represents language syntax construction.
 
@@ -613,7 +613,7 @@ class NonTerminal(ParseTreeNode):
     """
     def __init__(self, type, position, nodes, error=False):
         super(NonTerminal, self).__init__(type, position, error)
-        self.nodes = flatten([nodes])
+        self.extend(flatten([nodes]))
 
         # Child nodes cache. Used for lookup by rule name.
         self._child_cache = {}
@@ -622,14 +622,14 @@ class NonTerminal(ParseTreeNode):
     def desc(self):
         return self.name
 
-    def __iter__(self):
-        return iter(self.nodes)
+    # def __iter__(self):
+    #     return self
 
     def __str__(self):
-        return "".join([str(x) for x in self.nodes])
+        return "".join([str(x) for x in self])
 
     def __repr__(self):
-        return "[ %s ]" % ", ".join([repr(x) for x in self.nodes])
+        return "[ %s ]" % ", ".join([repr(x) for x in self])
 
     def __getattr__(self, item):
         """
@@ -644,7 +644,7 @@ class NonTerminal(ParseTreeNode):
 
         # If not found in the cache find it and store it in the
         # cache for later.
-        for n in self.nodes:
+        for n in self:
             if n.type == item:
                 self._child_cache[item] = n
                 return n
@@ -743,7 +743,7 @@ class Parser(object):
             """
             nodes = []
             if isinstance(node, NonTerminal):
-                for n in node.nodes:
+                for n in node:
                     nodes.append(tree_walk(n))
 
             if node.type in sem_actions:

arpeggio/peg.py

@@ -23,7 +23,7 @@ def expression():       return [regex,(identifier, Not(LEFT_ARROW)),
                                 (OPEN, ordered_choice, CLOSE),
                                 literal]
 
-def regex():            return "r", "'", _(r"(\\\'|[^\'])*"),"'"
+def regex():            return "r'", _(r"(\\\'|[^\'])*"),"'"
 def identifier():       return _(r"[a-zA-Z_]([a-zA-Z_]|[0-9])*")
 #def literal():          return [_(r"\'(\\\'|[^\'])*\'"),_(r'"[^"]*"')]
 def literal():          return _(r'(\'(\\\'|[^\'])*\')|("[^"]*")')
@@ -148,8 +148,8 @@ class SemIdentifier(SemanticAction):
 class SemRegEx(SemanticAction):
     def first_pass(self, parser, node, nodes):
         if parser.debug:
-            print "RegEx %s." % nodes[2].value
-        return RegExMatch(nodes[2].value)
+            print "RegEx %s." % nodes[1].value
+        return RegExMatch(nodes[1].value)
 
 class SemLiteral(SemanticAction):
     def first_pass(self, parser, node, nodes):

tests/test_decorator_combine.py

@@ -38,7 +38,7 @@ class TestDecoratorCombine(TestCase):
         self.assertRaises(NoMatch, fail_nm)
 
         self.assertIsInstance(ptree1, NonTerminal)
-        self.assertIsInstance(ptree1.nodes[0], Terminal)
-        self.assertEqual(ptree1.nodes[0].value, "abbb")
+        self.assertIsInstance(ptree1[0], Terminal)
+        self.assertEqual(ptree1[0].value, "abbb")