Merge pull request #7 from undecidabot/master

 Introducing error reporting and recovery to re(label)

4 files changed, 946 insertions, 78 deletions

diff --git a/makefile b/makefile
index b019e15..51d3b15 100644
--- a/makefile
+++ b/makefile
@@ -43,6 +43,7 @@ $(FILES): makefile
 test: test.lua relabel.lua lpeglabel.so
         lua test.lua
         lua testlabel.lua
+        lua testerrors.lua
 
 clean:
         rm -f $(FILES) lpeglabel.so
diff --git a/relabel.lua b/relabel.lua
index b66fc2e..6fdbb7c 100644
--- a/relabel.lua
+++ b/relabel.lua
@@ -1,9 +1,11 @@
 -- $Id: re.lua,v 1.44 2013/03/26 20:11:40 roberto Exp $
 
 -- imported functions and modules
-local tonumber, type, print, error = tonumber, type, print, error
+local tonumber, type, print, error, ipairs = tonumber, type, print, error, ipairs
+local pcall = pcall
 local setmetatable = setmetatable
-local unpack = table.unpack or unpack
+local unpack, tinsert, concat = table.unpack or unpack, table.insert, table.concat
+local rep = string.rep
 local m = require"lpeglabel"
 
 -- 'm' will be used to parse expressions, and 'mm' will be used to
@@ -22,6 +24,74 @@ if version == "Lua 5.2" then _ENV = nil end
 
 
 local any = m.P(1)
+local dummy = mm.P(false)
+
+
+local errinfo = {
+  {"NoPatt", "no pattern found"},
+  {"ExtraChars", "unexpected characters after the pattern"},
+
+  {"ExpPatt1", "expected a pattern after '/' or the label(s)"},
+
+  {"ExpPatt2", "expected a pattern after '&'"},
+  {"ExpPatt3", "expected a pattern after '!'"},
+
+  {"ExpPatt4", "expected a pattern after '('"},
+  {"ExpPatt5", "expected a pattern after ':'"},
+  {"ExpPatt6", "expected a pattern after '{~'"},
+  {"ExpPatt7", "expected a pattern after '{|'"},
+
+  {"ExpPatt8", "expected a pattern after '<-'"},
+
+  {"ExpPattOrClose", "expected a pattern or closing '}' after '{'"},
+
+  {"ExpNum", "expected a number after '^', '+' or '-' (no space)"},
+  {"ExpCap", "expected a string, number, '{}' or name after '->'"},
+
+  {"ExpName1", "expected the name of a rule after '=>'"},
+  {"ExpName2", "expected the name of a rule after '=' (no space)"},
+  {"ExpName3", "expected the name of a rule after '<' (no space)"},
+
+  {"ExpLab1", "expected at least one label after '{'"},
+  {"ExpLab2", "expected a label after the comma"},
+
+  {"ExpNameOrLab", "expected a name or label after '%' (no space)"},
+
+  {"ExpItem", "expected at least one item after '[' or '^'"},
+
+  {"MisClose1", "missing closing ')'"},
+  {"MisClose2", "missing closing ':}'"},
+  {"MisClose3", "missing closing '~}'"},
+  {"MisClose4", "missing closing '|}'"},
+  {"MisClose5", "missing closing '}'"},  -- for the captures
+
+  {"MisClose6", "missing closing '>'"},
+  {"MisClose7", "missing closing '}'"},  -- for the labels
+
+  {"MisClose8", "missing closing ']'"},
+
+  {"MisTerm1", "missing terminating single quote"},
+  {"MisTerm2", "missing terminating double quote"},
+}
+
+local errmsgs = {}
+local labels = {}
+
+for i, err in ipairs(errinfo) do
+  errmsgs[i] = err[2]
+  labels[err[1]] = i
+end
+
+local syntaxerrs = {}
+
+local function expect (pattern, labelname)
+  local label = labels[labelname]
+  local record = function (input, pos)
+    tinsert(syntaxerrs, { label = label, pos = pos })
+    return true
+  end
+  return pattern + m.Cmt("", record) * m.T(label)
+end
 
 
 -- Pre-defined names
@@ -75,18 +145,13 @@ local I = m.P(function (s,i) print(i, s:sub(1, i-1)); return i end)
 
 local function getdef (id, defs)
   local c = defs and defs[id]
-  if not c then error("undefined name: " .. id) end
+  if not c then
+    error("undefined name: " .. id)
+  end
   return c
 end
 
 
-local function patt_error (s, i)
-  local msg = (#s < i + 20) and s:sub(i)
-                             or s:sub(i,i+20) .. "..."
-  msg = ("pattern error near '%s'"):format(msg)
-  error(msg, 2)
-end
-
 local function mult (p, n)
   local np = mm.P(true)
   while n >= 1 do
@@ -106,40 +171,37 @@ end
 
 local S = (Predef.space + "--" * (any - Predef.nl)^0)^0
 
-local name = m.R("AZ", "az", "__") * m.R("AZ", "az", "__", "09")^0
+local name = m.C(m.R("AZ", "az", "__") * m.R("AZ", "az", "__", "09")^0)
 
 local arrow = S * "<-"
 
-local seq_follow = m.P"/" + ")" + "}" + ":}" + "~}" + "|}" + (name * arrow) + -1
-
-name = m.C(name)
-
-
 -- a defined name only have meaning in a given environment
 local Def = name * m.Carg(1)
 
 local num = m.C(m.R"09"^1) * S / tonumber
 
-local String = "'" * m.C((any - "'")^0) * "'" +
-               '"' * m.C((any - '"')^0) * '"'
+local String = "'" * m.C((any - "'" - m.P"\n")^0) * expect("'", "MisTerm1")
+             + '"' * m.C((any - '"' - m.P"\n")^0) * expect('"', "MisTerm2")
 
 
 local defined = "%" * Def / function (c,Defs)
   local cat =  Defs and Defs[c] or Predef[c]
-  if not cat then error ("name '" .. c .. "' undefined") end
+  if not cat then
+    error("name '" .. c .. "' undefined")
+  end
   return cat
 end
 
 local Range = m.Cs(any * (m.P"-"/"") * (any - "]")) / mm.R
 
-local item = defined + Range + m.C(any)
+local item = defined + Range + m.C(any - m.P"\n")
 
 local Class =
     "["
   * (m.C(m.P"^"^-1))    -- optional complement symbol
-  * m.Cf(item * (item - "]")^0, mt.__add) /
-                          function (c, p) return c == "^" and any - p or p end
-  * "]"
+  * m.Cf(expect(item, "ExpItem") * (item - "]")^0, mt.__add)
+    / function (c, p) return c == "^" and any - p or p end
+  * expect("]", "MisClose8")
 
 local function adddef (t, k, exp)
   if t[k] then
@@ -161,71 +223,175 @@ local function NT (n, b)
 end
 
 local function labchoice (...)
-        local t = { ... }
-        local n = #t
-        local p = t[1] 
-        local i = 2
-        while i + 1 <= n do
-                p = mm.Lc(p, t[i+1], unpack(t[i]))
-                i = i + 2       
-        end
-
-        return p
+  local t = { ... }
+  local n = #t
+  local p = t[1]
+  local i = 2
+  while i + 1 <= n do
+    -- t[i] == nil when there are no labels
+    p = t[i] and mm.Lc(p, t[i+1], unpack(t[i])) or mt.__add(p, t[i+1])
+    i = i + 2
+  end
+
+  return p
+end
+
+-- error recovery
+local skip = m.P { "Skip",
+  Skip = (-m.P"/" * -m.P(name * arrow) * m.V"Ignored")^0 * m.Cc(dummy);
+  Ignored = m.V"Group" + any;
+  Group = "(" * (-m.P")" * m.V"Ignored")^0 * ")"
+        + "{" * (-m.P"}" * m.V"Ignored")^0 * "}"
+        + "[" * (-m.P"]" * m.V"Ignored")^0 * "]"
+        + "'" * (-m.P"'" * m.V"Ignored")^0 * "'"
+        + '"' * (-m.P'"' * m.V"Ignored")^0 * '"';
+}
+
+local ignore = m.Cmt(any, function (input, pos)
+  return syntaxerrs[#syntaxerrs].pos, dummy
+end)
+
+local pointAtStart = m.Cmt(any, function (input, pos)
+  -- like ignore but makes the last syntax error point at the start
+  local ret = syntaxerrs[#syntaxerrs].pos
+  syntaxerrs[#syntaxerrs].pos = pos-1
+  return ret, dummy
+end)
+
+
+local function labify (labelnames)
+  for i, l in ipairs(labelnames) do
+    labelnames[i] = labels[l]
+  end
+  return labelnames
 end
 
+local labelset1 = labify {
+  "ExpPatt2", "ExpPatt3",
+  "ExpPatt4", "ExpPatt5", "ExpPatt6", "ExpPatt7",
+  "ExpPatt8", "ExpPattOrClose",
+  "ExpNum", "ExpCap",
+  "ExpName1", "ExpName2", "ExpName3",
+  "ExpNameOrLab", "ExpItem",
+  "MisClose6", "MisClose7"
+}
+
+local labelset2 = labify {
+  "MisClose1", "MisClose2", "MisClose3", "MisClose4", "MisClose5"
+}
+
+local labelset3 = labify {
+  "ExpPatt1", "ExpLab1", "ExpLab2", "MisClose7"
+}
 
 local exp = m.P{ "Exp",
   Exp = S * ( m.V"Grammar"
-            + (m.V"Seq") * ("/" * m.V"Labels" * S * m.V"Seq")^1 / labchoice
-            + m.Cf(m.V"Seq" * ("/" * S * m.V"Seq")^0, mt.__add) );
-        Labels = m.Ct(m.P"{" * S * m.V"Label" * (S * "," * S * m.V"Label")^0 * S * "}");
-  Seq = m.Cf(m.Cc(m.P"") * m.V"Prefix"^0 , mt.__mul)
-        * (#seq_follow + patt_error);
-  Prefix = "&" * S * m.V"Prefix" / mt.__len
-         + "!" * S * m.V"Prefix" / mt.__unm
+            + (m.V"RecovSeq" * (S * "/" * m.Lc((m.Ct(m.V"Labels") + m.Cc(nil))
+                                                * expect(S * m.V"RecovSeq",
+                                                    "ExpPatt1"),
+                                               m.Cc(nil) * skip,
+                                               unpack(labelset3))
+                            )^0
+              ) / labchoice);
+  Labels = m.P"{" * expect(S * m.V"Label", "ExpLab1")
+           * (S * "," * expect(S * m.V"Label", "ExpLab2"))^0
+           * expect(S * "}", "MisClose7");
+  RecovSeq = m.Lc(m.V"Seq", skip, unpack(labelset1));
+  Seq = m.Cf(m.Cc(m.P"") * m.V"Prefix" * (S * m.V"Prefix")^0, mt.__mul);
+  Prefix = "&" * expect(S * m.V"Prefix", "ExpPatt2") / mt.__len
+         + "!" * expect(S * m.V"Prefix", "ExpPatt3") / mt.__unm
          + m.V"Suffix";
-  Suffix = m.Cf(m.V"Primary" * S *
-          ( ( m.P"+" * m.Cc(1, mt.__pow)
-            + m.P"*" * m.Cc(0, mt.__pow)
-            + m.P"?" * m.Cc(-1, mt.__pow)
-            + "^" * ( m.Cg(num * m.Cc(mult))
-                    + m.Cg(m.C(m.S"+-" * m.R"09"^1) * m.Cc(mt.__pow))
-                    )
-            + "->" * S * ( m.Cg((String + num) * m.Cc(mt.__div))
-                         + m.P"{}" * m.Cc(nil, m.Ct)
-                         + m.Cg(Def / getdef * m.Cc(mt.__div))
-                         )
-            + "=>" * S * m.Cg(Def / getdef * m.Cc(m.Cmt))
-            ) * S
+  Suffix = m.Cf(m.V"RecovPrimary" *
+          ( S * ( m.P"+" * m.Cc(1, mt.__pow)
+                + m.P"*" * m.Cc(0, mt.__pow)
+                + m.P"?" * m.Cc(-1, mt.__pow)
+                + "^" * expect( m.Cg(num * m.Cc(mult))
+                              + m.Cg(m.C(m.S"+-" * m.R"09"^1) * m.Cc(mt.__pow)
+                              ),
+                          "ExpNum")
+                + "->" * expect(S * ( m.Cg((String + num) * m.Cc(mt.__div))
+                                    + m.P"{}" * m.Cc(nil, m.Ct)
+                                    + m.Cg(Def / getdef * m.Cc(mt.__div))
+                                    ),
+                           "ExpCap")
+                + "=>" * expect(S * m.Cg(Def / getdef * m.Cc(m.Cmt)),
+                           "ExpName1")
+                )
           )^0, function (a,b,f) return f(a,b) end );
-  Primary = "(" * m.V"Exp" * ")"
-            + String / mm.P
-            + Class
-            + defined
-            + "%{" * S * m.V"Label" * (S * "," * S * m.V"Label")^0 * S * "}" / mm.T
-            + "{:" * (name * ":" + m.Cc(nil)) * m.V"Exp" * ":}" /
-                     function (n, p) return mm.Cg(p, n) end
-            + "=" * name / function (n) return mm.Cmt(mm.Cb(n), equalcap) end
-            + m.P"{}" / mm.Cp
-            + "{~" * m.V"Exp" * "~}" / mm.Cs
-            + "{|" * m.V"Exp" * "|}" / mm.Ct
-            + "{" * m.V"Exp" * "}" / mm.C
-            + m.P"." * m.Cc(any)
-            + (name * -arrow + "<" * name * ">") * m.Cb("G") / NT;
-        Label = num + name / function (f) return tlabels[f] end;
-  Definition = name * arrow * m.V"Exp";
-  Grammar = m.Cg(m.Cc(true), "G") *
-            m.Cf(m.V"Definition" / firstdef * m.Cg(m.V"Definition")^0,
-              adddef) / mm.P
+  RecovPrimary = m.Lc(m.V"Primary", ignore, unpack(labelset2));
+  Primary = "(" * expect(m.V"Exp", "ExpPatt4") * expect(S * ")", "MisClose1")
+          + m.Lc(String / mm.P, pointAtStart,
+              labels["MisTerm1"], labels["MisTerm2"])
+          + m.Lc(Class, pointAtStart, labels["MisClose8"])
+          + defined
+          + "%" * expect(m.V"Labels", "ExpNameOrLab") / mm.T
+          + "{:" * (name * ":" + m.Cc(nil)) * expect(m.V"Exp", "ExpPatt5")
+            * expect(S * ":}", "MisClose2")
+            / function (n, p) return mm.Cg(p, n) end
+          + "=" * expect(name, "ExpName2")
+            / function (n) return mm.Cmt(mm.Cb(n), equalcap) end
+          + m.P"{}" / mm.Cp
+          + "{~" * expect(m.V"Exp", "ExpPatt6")
+            * expect(S * "~}", "MisClose3") / mm.Cs
+          + "{|" * expect(m.V"Exp", "ExpPatt7")
+            * expect(S * "|}", "MisClose4") / mm.Ct
+          + "{" * expect(m.V"Exp", "ExpPattOrClose")
+            * expect(S * "}", "MisClose5") / mm.C
+          + m.P"." * m.Cc(any)
+          + (name * -arrow + "<" * expect(name, "ExpName3")
+             * expect(">", "MisClose6")) * m.Cb("G") / NT;
+  Label = num + name / function (f) return tlabels[f] end;
+  Definition = name * arrow * expect(m.V"Exp", "ExpPatt8");
+  Grammar = m.Cg(m.Cc(true), "G")
+            * m.Cf(m.V"Definition" / firstdef * (S * m.Cg(m.V"Definition"))^0,
+                adddef) / mm.P;
 }
 
-local pattern = S * m.Cg(m.Cc(false), "G") * exp / mm.P * (-any + patt_error)
+local pattern = S * m.Cg(m.Cc(false), "G") * expect(exp, "NoPatt") / mm.P
+                * S * expect(-any, "ExtraChars")
 
+local function lineno (s, i)
+  if i == 1 then return 1, 1 end
+  local adjustment = 0
+  -- report the current line if at end of line, not the next
+  if s:sub(i,i) == '\n' then
+    i = i-1
+    adjustment = 1
+  end
+  local rest, num = s:sub(1,i):gsub("[^\n]*\n", "")
+  local r = #rest
+  return 1 + num, (r ~= 0 and r or 1) + adjustment
+end
+
+local function splitlines(str)
+  local t = {}
+  local function helper(line) tinsert(t, line) return "" end
+  helper((str:gsub("(.-)\r?\n", helper)))
+  return t
+end
 
 local function compile (p, defs)
   if mm.type(p) == "pattern" then return p end   -- already compiled
-  local cp = pattern:match(p, 1, defs)
-  if not cp then error("incorrect pattern", 3) end
+  p = p .. " " -- for better reporting of column numbers in errors when at EOF
+  local ok, cp, label, suffix = pcall(function() return pattern:match(p, 1, defs) end)
+  if not ok and #syntaxerrs == 0 then
+    if type(cp) == "string" then
+      cp = cp:gsub("^[^:]+:[^:]+: ", "")
+    end
+    error(cp)
+  end
+  if #syntaxerrs > 0 then
+    local lines = splitlines(p)
+    local errors = {}
+    for i, err in ipairs(syntaxerrs) do
+      local line, col = lineno(p, err.pos)
+      tinsert(errors, "L" .. line .. ":C" .. col .. ": " .. errmsgs[err.label])
+      tinsert(errors, lines[line])
+      tinsert(errors, rep(" ", col-1) .. "^")
+    end
+    syntaxerrs = {}
+    error("syntax error(s) in pattern\n" .. concat(errors, "\n"))
+  end
   return cp
 end
 
@@ -264,7 +430,7 @@ local function gsub (s, p, rep)
 end
 
 local function setlabels (t)
-        tlabels = t
+  tlabels = t
 end
 
 -- exported names
@@ -274,7 +440,7 @@ local re = {
   find = find,
   gsub = gsub,
   updatelocale = updatelocale,
-        setlabels = setlabels
+  setlabels = setlabels
 }
 
 if version == "Lua 5.1" then _G.re = re end
diff --git a/test.lua b/test.lua
index c6049e7..86cda61 100755
--- a/test.lua
+++ b/test.lua
@@ -1420,7 +1420,7 @@ errmsg('aaaa', "rule 'aaaa'")
 errmsg('a', 'outside')
 errmsg('b <- a', 'undefined')
 errmsg("x <- 'a'  x <- 'b'", 'already defined')
-errmsg("'a' -", "near '-'")
+-- errmsg("'a' -", "near '-'")
 
 
 print"OK"
diff --git a/testerrors.lua b/testerrors.lua
new file mode 100644
index 0000000..1c5bb9f
--- /dev/null
+++ b/testerrors.lua
@@ -0,0 +1,701 @@
+local re = require 'relabel'
+
+function testerror(repatt, msg)
+  msg = msg:match("^%s*(.-)%s*$") -- trim
+  local ok, err = pcall(function () re.compile(repatt) end)
+  assert(not ok)
+  if msg:match("^[^\n]*\n(.-)$") then
+    -- expecting a syntax error
+    err = err:match("^[^\n]*\n(.-)$") -- remove first line (filename)
+    err = err:gsub("[ \t]*\n", "\n") -- remove trailing spaces
+    -- if err ~= msg then
+    --   print(#err, #msg)
+    --   print('--')
+    --   print(err)
+    --   print('--')
+    --   print(msg)
+    --   print('--')
+    -- end
+    assert(err == msg)
+  else
+    -- expecting a non-syntax error
+    assert(err:match(msg))
+  end
+end
+
+-- testing NoPatt
+
+testerror([[~]], [[
+L1:C1: no pattern found
+~
+^
+]])
+
+testerror([[???]], [[
+L1:C1: no pattern found
+???
+^
+]])
+
+-- testing ExtraChars
+
+testerror([['p'~]], [[
+L1:C4: unexpected characters after the pattern
+'p'~
+   ^
+]])
+
+testerror([['p'?$?]], [[
+L1:C5: unexpected characters after the pattern
+'p'?$?
+    ^
+]])
+
+-- testing ExpPatt1
+
+testerror([['p' /{1}]], [[
+L1:C9: expected a pattern after '/' or the label(s)
+'p' /{1}
+        ^
+]])
+
+testerror([['p' /{1} /{2} 'q']], [[
+L1:C9: expected a pattern after '/' or the label(s)
+'p' /{1} /{2} 'q'
+        ^
+]])
+
+testerror([['p' /]], [[
+L1:C6: expected a pattern after '/' or the label(s)
+'p' /
+     ^
+]])
+
+testerror([['p' / / 'q']], [[
+L1:C6: expected a pattern after '/' or the label(s)
+'p' / / 'q'
+     ^
+]])
+
+-- testing ExpPatt2
+
+testerror([[&]], [[
+L1:C2: expected a pattern after '&'
+&
+ ^
+]])
+
+testerror([[& / 'p']], [[
+L1:C2: expected a pattern after '&'
+& / 'p'
+ ^
+]])
+
+testerror([['p' &]], [[
+L1:C6: expected a pattern after '&'
+'p' &
+     ^
+]])
+
+testerror([['p' / & / 'q']], [[
+L1:C8: expected a pattern after '&'
+'p' / & / 'q'
+       ^
+]])
+
+testerror([[&&]], [[
+L1:C3: expected a pattern after '&'
+&&
+  ^
+]])
+
+testerror([[!&]], [[
+L1:C3: expected a pattern after '&'
+!&
+  ^
+]])
+
+-- testing ExpPatt3
+
+testerror([[!]], [[
+L1:C2: expected a pattern after '!'
+!
+ ^
+]])
+
+testerror([[! / 'p']], [[
+L1:C2: expected a pattern after '!'
+! / 'p'
+ ^
+]])
+
+testerror([['p' !]], [[
+L1:C6: expected a pattern after '!'
+'p' !
+     ^
+]])
+
+testerror([['p' / ! / 'q']], [[
+L1:C8: expected a pattern after '!'
+'p' / ! / 'q'
+       ^
+]])
+
+testerror([[!!]], [[
+L1:C3: expected a pattern after '!'
+!!
+  ^
+]])
+
+testerror([[&!]], [[
+L1:C3: expected a pattern after '!'
+&!
+  ^
+]])
+
+-- testing ExpPatt4
+
+testerror([[()]], [[
+L1:C2: expected a pattern after '('
+()
+ ^
+]])
+
+testerror([[($$$)]], [[
+L1:C2: expected a pattern after '('
+($$$)
+ ^
+]])
+
+-- testing ExpPatt5
+
+testerror([[{: *** :}]], [[
+L1:C3: expected a pattern after ':'
+{: *** :}
+  ^
+]])
+
+testerror([[{:group: *** :}]], [[
+L1:C9: expected a pattern after ':'
+{:group: *** :}
+        ^
+]])
+
+testerror([[x <- {:x:}]], [[
+L1:C10: expected a pattern after ':'
+x <- {:x:}
+         ^
+]])
+
+-- testing ExpPatt6
+
+testerror([[{~~}]], [[
+L1:C3: expected a pattern after '{~'
+{~~}
+  ^
+]])
+
+testerror([[{ {~ } ~}]], [[
+L1:C5: expected a pattern after '{~'
+{ {~ } ~}
+    ^
+L1:C10: missing closing '}'
+{ {~ } ~}
+         ^
+]])
+
+testerror([[{~ ^_^ ~}]], [[
+L1:C3: expected a pattern after '{~'
+{~ ^_^ ~}
+  ^
+]])
+
+-- testing ExpPatt7
+
+testerror([[{||}]], [[
+L1:C3: expected a pattern after '{|'
+{||}
+  ^
+]])
+
+testerror([[{|@|}]], [[
+L1:C3: expected a pattern after '{|'
+{|@|}
+  ^
+]])
+
+-- testing ExpPatt8
+
+testerror([[S <-]], [[
+L1:C5: expected a pattern after '<-'
+S <-
+    ^
+]])
+
+testerror([[S <- 'p' T <-]], [[
+L1:C14: expected a pattern after '<-'
+S <- 'p' T <-
+             ^
+]])
+
+-- testing ExpPattOrClose
+
+testerror([[{0}]], [[
+L1:C2: expected a pattern or closing '}' after '{'
+{0}
+ ^
+]])
+
+testerror([[{ :'p': }]], [[
+L1:C2: expected a pattern or closing '}' after '{'
+{ :'p': }
+ ^
+]])
+
+-- testing ExpNum
+
+testerror([['p' ^ n]], [[
+L1:C6: expected a number after '^', '+' or '-' (no space)
+'p' ^ n
+     ^
+]])
+
+testerror([['p'^+(+1)]], [[
+L1:C5: expected a number after '^', '+' or '-' (no space)
+'p'^+(+1)
+    ^
+]])
+
+testerror([['p'^-/'q']], [[
+L1:C5: expected a number after '^', '+' or '-' (no space)
+'p'^-/'q'
+    ^
+]])
+
+-- testing ExpCap
+
+testerror([['p' -> {]], [[
+L1:C7: expected a string, number, '{}' or name after '->'
+'p' -> {
+      ^
+]])
+
+testerror([['p' -> {'q'}]], [[
+L1:C7: expected a string, number, '{}' or name after '->'
+'p' -> {'q'}
+      ^
+]])
+
+testerror([['p' -> / 'q']], [[
+L1:C7: expected a string, number, '{}' or name after '->'
+'p' -> / 'q'
+      ^
+]])
+
+testerror([['p' -> [0-9] ]], [[
+L1:C7: expected a string, number, '{}' or name after '->'
+'p' -> [0-9]
+      ^
+]])
+
+-- testing ExpName1
+
+testerror([['p' =>]], [[
+L1:C7: expected the name of a rule after '=>'
+'p' =>
+      ^
+]])
+
+testerror([['p' => 'q']], [[
+L1:C7: expected the name of a rule after '=>'
+'p' => 'q'
+      ^
+]])
+
+-- testing ExpName2
+
+testerror([['<' {:tag: [a-z]+ :} '>' '<' = '>']], [[
+L1:C31: expected the name of a rule after '=' (no space)
+'<' {:tag: [a-z]+ :} '>' '<' = '>'
+                              ^
+]])
+
+testerror([['<' {:tag: [a-z]+ :} '>' '<' = tag '>']], [[
+L1:C31: expected the name of a rule after '=' (no space)
+'<' {:tag: [a-z]+ :} '>' '<' = tag '>'
+                              ^
+]])
+
+-- testing ExpName3
+
+testerror([[<>]], [[
+L1:C2: expected the name of a rule after '<' (no space)
+<>
+ ^
+]])
+
+testerror([[<123>]], [[
+L1:C2: expected the name of a rule after '<' (no space)
+<123>
+ ^
+]])
+
+testerror([[< hello >]], [[
+L1:C2: expected the name of a rule after '<' (no space)
+< hello >
+ ^
+]])
+
+testerror([[<<S>>]], [[
+L1:C2: expected the name of a rule after '<' (no space)
+<<S>>
+ ^
+]])
+
+-- testing ExpLab1
+
+testerror([['p' /{} 'q']], [[
+L1:C7: expected at least one label after '{'
+'p' /{} 'q'
+      ^
+]])
+
+testerror([[%{ 'label' }]], [[
+L1:C3: expected at least one label after '{'
+%{ 'label' }
+  ^
+]])
+
+-- testing ExpLab2
+
+testerror([['p' /{1,2,3,} 'q']], [[
+L1:C13: expected a label after the comma
+'p' /{1,2,3,} 'q'
+            ^
+]])
+
+testerror([[%{ a,,b,,c }]], [[
+L1:C6: expected a label after the comma
+%{ a,,b,,c }
+     ^
+]])
+
+-- testing ExpNameOrLab
+
+testerror([[% s]], [[
+L1:C2: expected a name or label after '%' (no space)
+% s
+ ^
+]])
+
+testerror([[% {1}]], [[
+L1:C2: expected a name or label after '%' (no space)
+% {1}
+ ^
+]])
+
+-- testing ExpItem
+
+testerror([[
+"p" [
+abc
+] "q"  
+]], [[
+L1:C6: expected at least one item after '[' or '^'
+"p" [
+     ^
+]])
+
+-- testing MisClose1
+
+testerror([[('p' ('q' / 'r')]], [[
+L1:C17: missing closing ')'
+('p' ('q' / 'r')
+                ^
+]])
+
+-- testing MisClose2
+
+-- two errors are reported due to the ignore strategy
+testerror([[{: group: 'p' :}]], [[
+L1:C9: missing closing ':}'
+{: group: 'p' :}
+        ^
+L1:C9: unexpected characters after the pattern
+{: group: 'p' :}
+        ^
+]])
+
+testerror([[S <- {: 'p'  T <- 'q']], [[
+L1:C12: missing closing ':}'
+S <- {: 'p'  T <- 'q'
+           ^
+]])
+
+-- testing MisClose3
+
+testerror([['p' {~ ('q' 'r') / 's']], [[
+L1:C23: missing closing '~}'
+'p' {~ ('q' 'r') / 's'
+                      ^
+]])
+
+-- testing MisClose4
+
+-- two errors are reported due to the ignore strategy
+testerror([['p' {| 'q' / 'r' }]], [[
+L1:C17: missing closing '|}'
+'p' {| 'q' / 'r' }
+                ^
+L1:C18: unexpected characters after the pattern
+'p' {| 'q' / 'r' }
+                 ^
+]])
+
+-- testing MisClose5
+
+testerror([[{ 'p' ]], [[
+L1:C6: missing closing '}'
+{ 'p'
+     ^
+]])
+
+-- testing MisClose6
+
+testerror([[<patt]], [[
+L1:C6: missing closing '>'
+<patt
+     ^
+]])
+
+testerror([[<insert your name here>]], [[
+L1:C8: missing closing '>'
+<insert your name here>
+       ^
+]])
+
+-- testing MisClose7
+
+testerror([['{' %{ a, b '}']], [[
+L1:C12: missing closing '}'
+'{' %{ a, b '}'
+           ^
+]])
+
+-- testing MisClose8
+
+testerror([[[]], [[
+L1:C1: missing closing ']'
+[
+^
+]])
+
+testerror([[[^]], [[
+L1:C1: missing closing ']'
+[^
+^
+]])
+
+testerror([[[] ]], [[
+L1:C1: missing closing ']'
+[]
+^
+]])
+
+testerror([[[^]         ]], [[
+L1:C1: missing closing ']'
+[^]
+^
+]])
+
+testerror([[[_-___-_|]], [[
+L1:C1: missing closing ']'
+[_-___-_|
+^
+]])
+
+-- testing MisTerm1
+
+testerror([['That is the question...]], [[
+L1:C1: missing terminating single quote
+'That is the question...
+^
+]])
+
+-- testing MisTerm2
+
+testerror([[Q <- "To be or not to be...]], [[
+L1:C6: missing terminating double quote
+Q <- "To be or not to be...
+     ^
+]])
+
+-- testing error recovery, more complex grammars (multiline),
+-- and pointer positions in error recovery
+
+testerror([[&'p'/&/!/'p'^'q']], [[
+L1:C7: expected a pattern after '&'
+&'p'/&/!/'p'^'q'
+      ^
+L1:C9: expected a pattern after '!'
+&'p'/&/!/'p'^'q'
+        ^
+L1:C14: expected a number after '^', '+' or '-' (no space)
+&'p'/&/!/'p'^'q'
+             ^
+]])
+
+testerror([[
+  A <- 'a' (B 'b'
+  B <- 'x' / !
+  C <- 'c'
+]], [[
+L1:C18: missing closing ')'
+  A <- 'a' (B 'b'
+                 ^
+L2:C15: expected a pattern after '!'
+  B <- 'x' / !
+              ^
+]])
+
+testerror([['a' / &@ ('c' / 'd')]], [[
+L1:C8: expected a pattern after '&'
+'a' / &@ ('c' / 'd')
+       ^
+]])
+
+testerror([['x' / & / 'y']], [[
+L1:C8: expected a pattern after '&'
+'x' / & / 'y'
+       ^
+]])
+
+testerror([[&/'p'/!/'q']], [[
+L1:C2: expected a pattern after '&'
+&/'p'/!/'q'
+ ^
+L1:C8: expected a pattern after '!'
+&/'p'/!/'q'
+       ^
+]])
+
+testerror([['p'//'q']], [[
+L1:C5: expected a pattern after '/' or the label(s)
+'p'//'q'
+    ^
+]])
+
+testerror([[
+  S <- 'forgot to close / T
+  T <- 'T' & / 't'
+]], [[
+L1:C8: missing terminating single quote
+  S <- 'forgot to close / T
+       ^
+L2:C13: expected a pattern after '&'
+  T <- 'T' & / 't'
+            ^
+]])
+
+testerror([[
+  S <- [a-z / T
+  T <- 'x' / & / 'y'
+]], [[
+L1:C8: missing closing ']'
+  S <- [a-z / T
+       ^
+L2:C15: expected a pattern after '&'
+  T <- 'x' / & / 'y'
+              ^
+]])
+
+testerror([[
+  S <- ('p' -- comment
+]], [[
+L1:C12: missing closing ')'
+  S <- ('p' -- comment
+           ^
+]])
+
+-- an unfortunate second error exists because we don't know
+-- what's part of the quotation
+testerror([[
+  X <- ('p / Q (R
+    / S))
+  Q <- 'q'
+  R <- 'r'
+  S <- 's'
+]], [[
+L1:C9: missing terminating single quote
+  X <- ('p / Q (R
+        ^
+L2:C9: unexpected characters after the pattern
+    / S))
+        ^
+]])
+
+testerror([[
+  A <- 'A' /{'lab'} B / !
+
+  B <- %{1, 2 3} 'b' / '6' & / 'B'
+
+  C <- A^B
+]], [[
+L1:C14: expected at least one label after '{'
+  A <- 'A' /{'lab'} B / !
+             ^
+L1:C26: expected a pattern after '!'
+  A <- 'A' /{'lab'} B / !
+                         ^
+L3:C15: missing closing '}'
+  B <- %{1, 2 3} 'b' / '6' & / 'B'
+              ^
+L3:C29: expected a pattern after '&'
+  B <- %{1, 2 3} 'b' / '6' & / 'B'
+                            ^
+L5:C10: expected a number after '^', '+' or '-' (no space)
+  C <- A^B
+         ^
+]])
+
+testerror([['p'/{1/'q'/&]], [[
+L1:C7: missing closing '}'
+'p'/{1/'q'/&
+      ^
+L1:C13: expected a pattern after '&'
+'p'/{1/'q'/&
+            ^
+]])
+
+-- testing non-syntax errors
+
+testerror([[
+  A <- %nosuch %def
+  A <- 'A again'
+  A <- 'and again'
+]], [[
+name 'nosuch' undefined
+]])
+
+testerror([[names not in grammar]], [[
+rule 'names' used outside a grammar
+]])
+
+testerror([[
+  A <- %nosuch %def
+  A <- 'A again'
+  A <- 'and again'
+]], [[
+name 'nosuch' undefined
+]])
+
+-- the non-syntax error should not be reported
+-- since there is a syntax error
+testerror([[ A <- %nosuch ('error' ]], [[
+L1:C23: missing closing ')'
+ A <- %nosuch ('error'
+                      ^
+]])
+
+
+print 'OK'