renovate error handling slightly. tests pass again.

Author: Allen Short

ometa/interp.py

@@ -67,9 +67,6 @@ def end(self):
             self.callback(*x)
 
 
-    def error(self, typ, val, trail=None):
-        raise ParseError(''.join(self.input.data), typ, val, trail=trail)
-
     ## Implementation note: each method, instead of being a function
     ## returning a value, is a generator that will yield '_feed_me' an
     ## arbitrary number of times, then finally yield the value of the
@@ -127,7 +124,7 @@ def _apply(self, rule, ruleName, args):
 
         elif isinstance(memoRec, LeftRecursion):
             memoRec.detected = True
-            self.error(None, None)
+            raise self.input.nullError()
         self.input = memoRec[1]
         yield memoRec[0]
 
@@ -188,7 +185,7 @@ def parse_Exactly(self, spec):
             if val == c:
                 self.input = self.input.tail()
             else:
-                self.error(''.join(result), expected(None, wanted))
+                raise self.err(p.withMessage(expected(None, wanted)))
         yield ''.join(result), p
 
 
@@ -217,7 +214,7 @@ def parse_Token(self, spec):
             if val == c:
                 self.input = self.input.tail()
             else:
-                self.error(''.join(result), expected(None, wanted))
+                raise self.err(p.withMessage(expected("token", wanted)))
         yield ''.join(result), p
 
 
@@ -254,7 +251,7 @@ def parse_Or(self, expr):
             except ParseError, err:
                 errors.append(err)
                 self.input = i
-        self.error(*joinErrors(errors))
+        raise self.err(joinErrors(errors))
 
 
     def parse_Many(self, expr, ans=None):
@@ -358,7 +355,7 @@ def parse_Not(self, expr):
             self.input = m
             yield True, self.input.nullError()
         else:
-            self.error(*self.input.nullError())
+            raise self.err(self.input.nullError())
 
 
     def parse_Label(self, expr, label_term):
@@ -370,11 +367,11 @@ def parse_Label(self, expr, label_term):
             for x in self._eval(expr):
                 if x is _feed_me:
                     yield x
-            self.currentError = x[1]
-            self.currentError.withMessage([("Custom Exception:", label, None)])
-            yield x
+            print "^^", label
+            self.currentError = x[1].withMessage([("Custom Exception:", label, None)])
+            yield x[0], self.currentError
         except ParseError, e:
-            raise e.withMessage([("Custom Exception:", label, None)])
+            raise self.err(e.withMessage([("Custom Exception:", label, None)]))
 
 
     def parse_Lookahead(self, expr):
@@ -409,7 +406,7 @@ def parse_Predicate(self, expr):
             if x is _feed_me: yield x
         val, err = x
         if not val:
-            self.error(*err)
+            raise self.err(err)
         else:
             yield True, err
 
@@ -458,7 +455,7 @@ def rule_letter(self):
             self.input = self.input.tail()
             yield val, p
         else:
-            self.error(val, expected(None, "a letter"))
+            raise self.err(p.withMessage(expected("letter")))
 
     def rule_digit(self):
         """
@@ -473,8 +470,11 @@ def rule_digit(self):
             self.input = self.input.tail()
             yield val, p
         else:
-            self.error(val, expected(None, "a digit"))
+            raise self.err(p.withMessage(expected("digit")))
 
+    def err(self, e):
+        e.input = ''.join(e.input)
+        raise e
 
 class GrammarInterpreter(object):
 

ometa/runtime.py

@@ -221,7 +221,7 @@ def head(self):
                 data = self.data.__class__('').join(self.data)
             else:
                 data = self.data
-            raise EOFError(data, self.position)
+            raise EOFError(data, self.position + 1)
         return self.data[self.position], self.error
 
     def nullError(self, msg=None):

ometa/test/test_pymeta.py

@@ -828,18 +828,6 @@ def test_label2(self):
         e = self.assertRaises(ParseError, g.xs, "xy")
         self.assertEqual(e, ParseError(0, 1, expected(label)).withMessage([("Custom Exception:", label, None)]))
 
-    def test_caret_position(self):
-        """
-        Custom labels change the 'expected' in the raised exceptions.
-        """
-        g = self.compile("xs = 'x'*")
-        self.assertEqual(g.xs(""), "")
-        self.assertEqual(g.xs("x"), "x")
-        self.assertEqual(g.xs("xxxx"), "xxxx")
-        g.xs('xy')
-        self.assertRaises(ParseError, g.xs, "xy")
-
-    test_caret_position.todo = 'When ran as a trampolined test, the caret is in the wrong spot'
 
     def test_listConsumedBy(self):
         """
@@ -1121,8 +1109,8 @@ def test_brokenGrammar(self):
         """
         e = self.assertRaises(ParseError, OMeta.makeGrammar, grammar,
                               "Foo")
-        self.assertEquals(e.position, 56)
-        self.assertEquals(e.error, [("expected", None, "\r\n"), ("message", "end of input")])
+        self.assertEquals(e.position, 57)
+        self.assertEquals(e.error, [("message", "end of input")])
 
 
     def test_subclassing(self):
@@ -1293,7 +1281,7 @@ def test_failure(self):
             tree, 'foo', callback=lambda x: setattr(self, 'result', x))
         e = self.assertRaises(ParseError, i.receive, 'foobar')
         self.assertEqual(str(e),
-        "\nfoobar\n^\nParse error at line 2, column 0:"
+        "\nfoobar\n^\nParse error at line 1, column 0:"
         " expected the character 'a'. trail: []\n")
 
 
@@ -1559,21 +1547,19 @@ def test_customLabelsFormatting(self):
 
     def test_eof(self):
         """
-        Custom labels replace the 'expected' part of the exception.
+        EOF should raise a nice error.
         """
-        g = self.compile("""
+        import parsley
+        g = parsley.makeGrammar("""
         dig = '1' | '2' | '3'
         bits = <dig>+
-        """)
+        """, {})
 
         input = '123x321'
-
-        e = self.assertRaises(ParseError, g.dig, input)
+        e = self.assertRaises(ParseError, g(input).dig)
         self.assertEqual(e.formatError(),
                          dedent("""
                          123x321
                           ^
-                         Parse error at line 1, column 0: expected EOF. trail: []
+                         Parse error at line 1, column 1: expected EOF. trail: []
                          """))
-
-    test_eof.todo = 'We need to catch EOF and raise a better exception'

parsley.py

@@ -1,5 +1,5 @@
 from ometa.grammar import OMeta
-from ometa.runtime import ParseError, EOFError, OMetaBase
+from ometa.runtime import ParseError, EOFError, OMetaBase, expected
 from terml.parser import parseTerm as term
 from terml.nodes import termMaker
 from terml.quasiterm import quasiterm
@@ -82,6 +82,10 @@ def invokeRule(*args, **kwargs):
                     extra, _ = self._grammar.input.head()
                 except EOFError:
                     return ret
+                else:
+                    # problem is that input remains, so:
+                    err = ParseError(err.input, err.position + 1,
+                                     [["message", "expected EOF"]], err.trail)
             raise err
         return invokeRule