Merge branch 'recoveryresume'

18 files changed, 509 insertions, 593 deletions

diff --git a/examples/expRec.lua b/examples/expRec.lua
new file mode 100644
index 0000000..5c5fd7d
--- /dev/null
+++ b/examples/expRec.lua
@@ -0,0 +1,128 @@
+local m = require"lpeglabelrec"
+local re = require"relabelrec"
+
+local labels = {
+  {"ExpTermFirst",  "expected an expression"},
+  {"ExpTermOp",   "expected a term after the operator"},
+  {"MisClose",  "missing a closing ')' after the expression"},
+}
+
+local function labelindex(labname)
+  for i, elem in ipairs(labels) do
+    if elem[1] == labname then
+      return i
+    end
+  end
+  error("could not find label: " .. labname)
+end
+
+local errors, subject
+
+local function expect(patt, labname)
+  local i = labelindex(labname)
+  return patt + m.T(i)
+end
+
+
+local num = m.R("09")^1 / tonumber
+local op = m.S("+-")
+
+local function compute(tokens)
+  local result = tokens[1]
+  for i = 2, #tokens, 2 do
+    if tokens[i] == '+' then
+      result = result + tokens[i+1]
+    elseif tokens[i] == '-' then
+      result = result - tokens[i+1]
+    else
+      error('unknown operation: ' .. tokens[i])
+    end
+  end
+  return result
+end
+
+local g = m.P {
+        "Exp",
+        Exp = m.Ct(m.V"OperandFirst" * (m.C(op) * m.V"Operand")^0) / compute,
+        OperandFirst = expect(m.V"Term", "ExpTermFirst"),
+        Operand = expect(m.V"Term", "ExpTermOp"),
+        Term = num + m.V"Group",
+        Group = "(" * m.V"Exp" * expect(")", "MisClose"),
+}
+
+function recorderror(pos, lab)
+        local line, col = re.calcline(subject, pos)
+        table.insert(errors, { line = line, col = col, msg = labels[lab][2] })
+end
+
+function record (labname)
+        return (m.Cp() * m.Cc(labelindex(labname))) / recorderror
+end
+
+function sync (p)
+        return (-p * m.P(1))^0
+end
+
+function defaultValue (p)
+        return p or m.Cc(1000) 
+end
+
+local grec = m.P {
+        "S",
+        S = m.Rec(m.V"A", m.V"ErrExpTermFirst", labelindex("ExpTermFirst")), -- default value is 0
+        A = m.Rec(m.V"Sg", m.V"ErrExpTermOp", labelindex("ExpTermOp")),
+        Sg = m.Rec(g, m.V"ErrMisClose", labelindex("MisClose")),
+        ErrExpTermFirst = record("ExpTermFirst") * sync(op + ")") * defaultValue(),
+        ErrExpTermOp = record("ExpTermOp") * sync(op + ")") * defaultValue(),
+        ErrMisClose = record("MisClose") * sync(m.P")") * defaultValue(m.P""),
+}
+               
+local function eval(input)
+        errors = {}
+        io.write("Input: ", input, "\n")
+        subject = input
+  local result, label, suffix = grec:match(input)
+  io.write("Syntactic errors found: " .. #errors, "\n")
+        if #errors > 0 then
+    local out = {}
+    for i, err in ipairs(errors) do
+      local pos = err.col
+      local msg = err.msg
+      table.insert(out, "syntax error: " .. msg .. " (at index " .. pos .. ")")
+    end
+    print(table.concat(out, "\n"))
+  end
+        io.write("Result = ")
+        return result   
+end
+
+print(eval "90-70-(5)+3")
+--> 20
+
+print(eval "15+")
+--> 2 + 0
+
+print(eval "-2")
+--> 0 - 2 
+
+print(eval "1+3+-9")
+--> 1 + 3 + [0] - 9
+
+print(eval "1+()3+")
+--> 1 + ([0]) [3 +] [0]
+
+print(eval "8-(2+)-5")
+--> 8 - (2 + [0]) - 5 
+
+print(eval "()")
+
+print(eval "")
+
+print(eval "1+()+")
+
+print(eval "1+(")
+
+print(eval "3)")
+
+print(eval "11+())3")
+
diff --git a/examples/expRecAut.lua b/examples/expRecAut.lua
new file mode 100644
index 0000000..f870d73
--- /dev/null
+++ b/examples/expRecAut.lua
@@ -0,0 +1,122 @@
+local m = require"lpeglabelrec"
+local re = require"relabelrec"
+
+local num = m.R("09")^1 / tonumber
+local op = m.S("+-")
+
+local labels = {}
+local nlabels = 0
+
+local function newError(lab, msg, psync, pcap)
+        nlabels = nlabels + 1
+        psync = psync or m.P(-1)
+        pcap = pcap or m.P""
+        labels[lab] = { id = nlabels, msg = msg, psync = psync, pcap = pcap }
+end
+
+newError("ExpTermFirst", "expected an expression", op + ")", m.Cc(1000)) 
+newError("ExpTermOp", "expected a term after the operator", op + ")", m.Cc(1000))
+newError("MisClose",  "missing a closing ')' after the expression",  m.P")")
+newError("Extra", "extra characters found after the expression") 
+
+local errors, subject
+
+local function expect(patt, labname)
+  local i = labels[labname].id
+  return patt + m.T(i)
+end
+
+local function compute(tokens)
+  local result = tokens[1]
+  for i = 2, #tokens, 2 do
+    if tokens[i] == '+' then
+      result = result + tokens[i+1]
+    elseif tokens[i] == '-' then
+      result = result - tokens[i+1]
+    else
+      error('unknown operation: ' .. tokens[i])
+    end
+  end
+  return result
+end
+
+local g = m.P {
+        "Exp",
+        Exp = m.Ct(m.V"OperandFirst" * (m.C(op) * m.V"Operand")^0) / compute,
+        OperandFirst = expect(m.V"Term", "ExpTermFirst"),
+        Operand = expect(m.V"Term", "ExpTermOp"),
+        Term = num + m.V"Group",
+        Group = "(" * m.V"Exp" * expect(")", "MisClose"),
+}
+
+function recorderror(pos, lab)
+        local line, col = re.calcline(subject, pos)
+        table.insert(errors, { line = line, col = col, msg = labels[lab].msg })
+end
+
+function record (labname)
+        return (m.Cp() * m.Cc(labname)) / recorderror
+end
+
+function sync (p)
+        return (-p * m.P(1))^0
+end
+
+function defaultValue (p)
+        return p or m.Cc(1000) 
+end
+
+local grec = g * expect(m.P(-1), "Extra")
+for k, v in pairs(labels) do
+        grec = m.Rec(grec, record(k) * sync(v.psync) * v.pcap, v.id)
+end
+
+local function eval(input)
+        errors = {}
+        io.write("Input: ", input, "\n")
+        subject = input
+  local result, label, suffix = grec:match(input)
+  io.write("Syntactic errors found: " .. #errors, "\n")
+        if #errors > 0 then
+    local out = {}
+    for i, err in ipairs(errors) do
+      local pos = err.col
+      local msg = err.msg
+      table.insert(out, "syntax error: " .. msg .. " (at index " .. pos .. ")")
+    end
+    print(table.concat(out, "\n"))
+  end
+        io.write("Result = ")
+        return result   
+end
+
+print(eval "90-70-(5)+3")
+--> 18
+
+print(eval "15+")
+--> 2 + 0
+
+print(eval "-2")
+--> 0 - 2 
+
+print(eval "1+3+-9")
+--> 1 + 3 + [0] - 9
+
+print(eval "1+()3+")
+--> 1 + ([0]) [+] 3 + [0]
+
+print(eval "8-(2+)-5")
+--> 8 - (2 + [0]) - 5 
+
+print(eval "()")
+
+print(eval "")
+
+print(eval "1+()+")
+
+print(eval "1+(")
+
+print(eval "3)")
+
+print(eval "11+()3")
+--> 1 + ([0]) [+] 3 + [0]
diff --git a/examples/expect.lua b/examples/expect.lua
deleted file mode 100644
index cb68d38..0000000
--- a/examples/expect.lua
+++ /dev/null
@@ -1,98 +0,0 @@
-local lpeg = require"lpeglabel"
-
-local R, S, P, V, C, Ct, T = lpeg.R, lpeg.S, lpeg.P, lpeg.V, lpeg.C, lpeg.Ct, lpeg.T
-
--- The `labels` table contains the list of labels that we will be using
--- as well as the corresponding error message for each label, which will
--- be used in our error reporting later on.
-local labels = {
-  {"NoExp",     "no expression found"},
-  {"Extra",     "extra characters found after the expression"},
-  {"ExpTerm",   "expected a term after the operator"},
-  {"ExpExp",    "expected an expression after the parenthesis"},
-  {"MisClose",  "missing a closing ')' after the expression"},
-}
-
--- The `expect` function takes a pattern and a label defined in
--- the `labels` table and returns a pattern that throws the specified
--- label if the original pattern fails to match.
--- Note: LPegLabel requires us to use integers for the labels, so we
--- use the index of the label in the `labels` table to represent it.
-local function expect(patt, labname)
-  for i, elem in ipairs(labels) do
-    if elem[1] == labname then
-      return patt + T(i)
-    end
-  end
-
-  error("could not find label: " .. labname)
-end
-
-local num = R("09")^1 / tonumber
-local op = S("+-*/")
-
--- The `compute` function takes an alternating list of numbers and
--- operators and computes the result of applying the operations
--- to the numbers in a left to right order (no operator precedence).
-local function compute(tokens)
-  local result = tokens[1]
-  for i = 2, #tokens, 2 do
-    if tokens[i] == '+' then
-      result = result + tokens[i+1]
-    elseif tokens[i] == '-' then
-      result = result - tokens[i+1]
-    elseif tokens[i] == '*' then
-      result = result * tokens[i+1]
-    elseif tokens[i] == '/' then
-      result = result / tokens[i+1]
-    else
-      error('unknown operation: ' .. tokens[i])
-    end
-  end
-  return result
-end
-
--- Our grammar is a simple arithmetic expression of integers that
--- does not take operator precedence into account but allows grouping
--- via parenthesis.
-local g = P {
-  "Exp",
-  Exp = Ct(V"Term" * (C(op) * expect(V"Term", "ExpTerm"))^0) / compute;
-  Term = num + V"Group";
-  Group = "(" * expect(V"Exp", "ExpExp") * expect(")", "MisClose");
-}
-
-g = expect(g, "NoExp") * expect(-P(1), "Extra")
-
--- The `eval` function takes an input string to match against the grammar
--- we've just defined. If the input string matches, then the result of the
--- computation is returned, otherwise we return the error message and
--- position of the first failure encountered.
-local function eval(input)
-  local result, label, suffix = g:match(input)
-  if result ~= nil then
-    return result
-  else
-    local pos = input:len() - suffix:len() + 1
-    local msg = labels[label][2]
-    return nil, "syntax error: " .. msg .. " (at index " .. pos .. ")"
-  end
-end
-
-print(eval "98-76*(54/32)")
---> 37.125
-
-print(eval "(1+1-1*2/2")
---> syntax error: missing a closing ')' after the expression (at index 11)
-
-print(eval "(1+)-1*(2/2)")
---> syntax error: expected a term after the operator (at index 4)
-
-print(eval "(1+1)-1*(/2)")
---> syntax error: expected an expression after the parenthesis (at index 10)
-
-print(eval "1+(1-(1*2))/2x")
---> syntax error: extra chracters found after the expression (at index 14)
-
-print(eval "-1+(1-(1*2))/2")
---> syntax error: no expression found (at index 1)
diff --git a/examples/listId1.lua b/examples/listId1.lua
index 8976f5f..dee46e9 100644
--- a/examples/listId1.lua
+++ b/examples/listId1.lua
@@ -1,12 +1,14 @@
-local m = require'lpeglabel'
-local re = require'relabel'
+local m = require'lpeglabelrec'
+local re = require'relabelrec'
+
+local id = m.R'az'^1
 
 local g = m.P{
   "S",
   S = m.V"Id" * m.V"List",
-  List = -m.P(1) + (m.V"Comma" + m.T(2)) * (m.V"Id" + m.T(1)) * m.V"List",
-  Id = m.V"Sp" * m.R'az'^1,
-  Comma = m.V"Sp" * ",",
+  List = -m.P(1) + m.V"Comma" * m.V"Id" * m.V"List",
+  Id = m.V"Sp" * id + m.T(1),
+  Comma = m.V"Sp" * "," + m.T(2),
   Sp = m.S" \n\t"^0,
 }
 
diff --git a/examples/listId2.lua b/examples/listId2.lua
index 509fda4..46f0063 100644
--- a/examples/listId2.lua
+++ b/examples/listId2.lua
@@ -1,5 +1,5 @@
-local m = require'lpeglabel'
-local re = require'relabel'
+local m = require'lpeglabelrec'
+local re = require'relabelrec'
 
 local terror = {}
 
@@ -12,15 +12,18 @@ local errUndef = newError("undefined")
 local errId = newError("expecting an identifier")
 local errComma = newError("expecting ','")
 
+local id = m.R'az'^1
+
 local g = m.P{
   "S",
   S = m.V"Id" * m.V"List",
-  List = -m.P(1) + (m.V"Comma" + m.T(errComma)) * (m.V"Id" + m.T(errId)) * m.V"List",
-  Id = m.V"Sp" * m.R'az'^1,
-  Comma = m.V"Sp" * ",",
+  List = -m.P(1) + m.V"Comma" * m.V"Id" * m.V"List",
+  Id = m.V"Sp" * id + m.T(errId),
+  Comma = m.V"Sp" * "," + m.T(errComma),
   Sp = m.S" \n\t"^0,
 }
 
+
 function mymatch (g, s)
   local r, e, sfail = g:match(s)
   if not r then
diff --git a/examples/listId2Rec2.lua b/examples/listId2Rec2.lua
new file mode 100644
index 0000000..c6705dd
--- /dev/null
+++ b/examples/listId2Rec2.lua
@@ -0,0 +1,67 @@
+local m = require'lpeglabelrec'
+local re = require'relabelrec'
+
+local terror = {}
+
+local function newError(s)
+  table.insert(terror, s)
+  return #terror
+end
+
+local errUndef = newError("undefined")
+local errId = newError("expecting an identifier")
+local errComma = newError("expecting ','")
+
+local id = m.R'az'^1
+
+local g = m.P{
+  "S",
+  S = m.V"Id" * m.V"List",
+  List = -m.P(1) + m.V"Comma" * m.V"Id" * m.V"List",
+  Id = m.V"Sp" * id + m.T(errId),
+  Comma = m.V"Sp" * "," + m.T(errComma),
+  Sp = m.S" \n\t"^0,
+}
+
+local subject, errors
+
+function recorderror(pos, lab)
+        local line, col = re.calcline(subject, pos)
+        table.insert(errors, { line = line, col = col, msg = terror[lab] })
+end
+
+function record (lab)
+        return (m.Cp() * m.Cc(lab)) / recorderror
+end
+
+function sync (p)
+        return (-p * m.P(1))^0
+end
+
+local grec = m.P{
+  "S",
+  S = m.Rec(m.Rec(g, m.V"ErrComma", errComma), m.V"ErrId", errId),
+  ErrComma = record(errComma) * sync(id),
+        ErrId = record(errId) * sync(m.P",")
+}
+
+
+function mymatch (g, s)
+        errors = {}
+        subject = s     
+        local r, e, sfail = g:match(s)
+        if #errors > 0 then
+                local out = {}
+    for i, err in ipairs(errors) do
+        local msg = "Error at line " .. err.line .. " (col " .. err.col .. "): " .. err.msg
+      table.insert(out,  msg)
+    end
+    return nil, table.concat(out, "\n") .. "\n"
+  end
+  return r
+end
+  
+print(mymatch(grec, "one,two"))
+print(mymatch(grec, "one two three"))
+print(mymatch(grec, "1,\n two, \n3,"))
+print(mymatch(grec, "one\n two123, \nthree,"))
diff --git a/examples/listId2Rec2Cap.lua b/examples/listId2Rec2Cap.lua
new file mode 100644
index 0000000..1c22c88
--- /dev/null
+++ b/examples/listId2Rec2Cap.lua
@@ -0,0 +1,79 @@
+local m = require'lpeglabelrec'
+local re = require'relabelrec'
+
+local terror = {}
+
+local function newError(s)
+  table.insert(terror, s)
+  return #terror
+end
+
+local errUndef = newError("undefined")
+local errId = newError("expecting an identifier")
+local errComma = newError("expecting ','")
+
+local id = m.R'az'^1
+
+local g = m.P{
+  "S",
+  S = m.V"Id" * m.V"List",
+  List = -m.P(1) + m.V"Comma" * m.V"Id" * m.V"List",
+  Id = m.V"Sp" * m.C(id) + m.T(errId),
+  Comma = m.V"Sp" * "," + m.T(errComma),
+  Sp = m.S" \n\t"^0,
+}
+
+local subject, errors
+
+function recorderror(pos, lab)
+        local line, col = re.calcline(subject, pos)
+        table.insert(errors, { line = line, col = col, msg = terror[lab] })
+end
+
+function record (lab)
+        return (m.Cp() * m.Cc(lab)) / recorderror
+end
+
+function sync (p)
+        return (-p * m.P(1))^0
+end
+
+function defaultValue ()
+        return m.Cc"NONE" 
+end
+
+local grec = m.P{
+  "S",
+  S = m.Rec(m.Rec(g, m.V"ErrComma", errComma), m.V"ErrId", errId),
+  ErrComma = record(errComma) * sync(id),
+        ErrId = record(errId) * sync(m.P",") * defaultValue(), 
+}
+
+
+function mymatch (g, s)
+        errors = {}
+        subject = s     
+        io.write("Input: ", s, "\n")
+        local r = { g:match(s) }
+        io.write("Captures (separated by ';'): ")
+        for k, v in pairs(r) do
+                io.write(v .. "; ")
+        end
+        io.write("\nSyntactic errors found: " .. #errors)
+        if #errors > 0 then
+                io.write("\n")
+                local out = {}
+    for i, err in ipairs(errors) do
+        local msg = "Error at line " .. err.line .. " (col " .. err.col .. "): " .. err.msg
+      table.insert(out,  msg)
+    end
+    io.write(table.concat(out, "\n"))
+  end
+        print("\n")
+        return r
+end
+  
+mymatch(grec, "one,two")
+mymatch(grec, "one two three")
+mymatch(grec, "1,\n two, \n3,")
+mymatch(grec, "one\n two123, \nthree,")
diff --git a/examples/listIdCatch.lua b/examples/listIdCatch.lua
deleted file mode 100644
index 5ad6f2d..0000000
--- a/examples/listIdCatch.lua
+++ /dev/null
@@ -1,28 +0,0 @@
-local m = require'lpeglabel'
-
-local terror = {}
-
-local function newError(s)
-  table.insert(terror, s)
-  return #terror
-end
-
-local errUndef = newError("undefined")
-local errId = newError("expecting an identifier")
-local errComma = newError("expecting ','")
-
-local g = m.P{
-  "S",
-  S = m.Lc(m.Lc(m.V"Id" * m.V"List", m.V"ErrId", errId),
-           m.V"ErrComma", errComma),
-  List = -m.P(1) + (m.V"Comma" + m.T(errComma)) * (m.V"Id" + m.T(errId)) * m.V"List",
-  Id = m.V"Sp" * m.R'az'^1,
-  Comma = m.V"Sp" * ",",
-  Sp = m.S" \n\t"^0,
-  ErrId = m.Cc(errId) / terror,
-  ErrComma = m.Cc(errComma) / terror
-}
-
-print(m.match(g, "one,two"))
-print(m.match(g, "one two"))
-print(m.match(g, "one,\n two,\nthree,"))
diff --git a/examples/listIdCatchRe.lua b/examples/listIdCatchRe.lua
deleted file mode 100644
index 8971191..0000000
--- a/examples/listIdCatchRe.lua
+++ /dev/null
@@ -1,34 +0,0 @@
-local re = require'relabel'
-
-local terror = {} 
-
-local function newError(l, msg) 
-  table.insert(terror, { l = l, msg = msg } )
-end
-
-newError("errId", "Error: expecting an identifier")
-newError("errComma", "Error: expecting ','")
-
-local labelCode = {}
-local labelMsg = {}
-for k, v in ipairs(terror) do 
-  labelCode[v.l] = k
-  labelMsg[v.l] = v.msg
-end
-
-re.setlabels(labelCode)
-
-local p = re.compile([[
-  S        <- Id List  /{errId}  ErrId  /{errComma}  ErrComma
-  List     <- !.  /  Comma Id List
-  Id       <- [a-z]+  /  %{errId}
-  Comma    <- ','  /  %{errComma}
-  ErrId    <- '' -> errId
-  ErrComma <- '' ->  errComma
-]], labelMsg)
-
-print(p:match("a,b"))
-print(p:match("a b"))
-print(p:match(",b"))
-
-
diff --git a/examples/listIdRe1.lua b/examples/listIdRe1.lua
index d092566..3988a3b 100644
--- a/examples/listIdRe1.lua
+++ b/examples/listIdRe1.lua
@@ -1,10 +1,10 @@
-local re = require 'relabel' 
+local re = require 'relabelrec' 
 
 local g = re.compile[[
   S      <- Id List
-  List   <- !.  /  (',' /  %{2}) (Id / %{1}) List
-  Id     <- Sp [a-z]+
-  Comma  <- Sp ','
+  List   <- !.  /  Comma Id List
+  Id     <- Sp [a-z]+ / %{2}
+  Comma  <- Sp ',' / %{3}
   Sp     <- %s*
 ]]
 
diff --git a/examples/listIdRe2.lua b/examples/listIdRe2.lua
index fe30535..6bab6ba 100644
--- a/examples/listIdRe2.lua
+++ b/examples/listIdRe2.lua
@@ -1,4 +1,4 @@
-local re = require 'relabel' 
+local re = require 'relabelrec' 
 
 local errinfo = {
   {"errUndef",  "undefined"},
@@ -18,23 +18,54 @@ re.setlabels(labels)
 
 local g = re.compile[[
   S      <- Id List
-  List   <- !.  /  (',' /  %{errComma}) (Id / %{errId}) List
-  Id     <- Sp [a-z]+
-  Comma  <- Sp ','
+  List   <- !.  /  Comma Id List
+  Id     <- Sp {[a-z]+} / %{errId}
+  Comma  <- Sp ',' / %{errComma}
   Sp     <- %s*
 ]]
 
-function mymatch (g, s)
-  local r, e, sfail = g:match(s)
-  if not r then
-    local line, col = re.calcline(s, #s - #sfail)
-    local msg = "Error at line " .. line .. " (col " .. col .. "): "
-    return r, msg .. errmsgs[e] .. " before '" .. sfail .. "'"
-  end
-  return r
+local errors
+
+function recorderror (subject, pos, label)
+        local line, col = re.calcline(subject, pos)
+        table.insert(errors, { line = line, col = col, msg = errmsgs[labels[label]] })
+        return true 
+end
+
+function sync (p)
+        return '( !(' .. p .. ') .)*'
 end
 
-print(mymatch(g, "one,two"))
-print(mymatch(g, "one two"))
-print(mymatch(g, "one,\n two,\nthree,"))
+local grec = re.compile(
+  "S         <- %g //{errComma} ErrComma //{errId} ErrId" .. "\n" ..
+  "ErrComma  <-  ('' -> 'errComma' => recorderror) " .. sync('[a-z]+') .. "\n" ..
+        "ErrId     <-  ('' -> 'errId' => recorderror) " .. sync('","') .. "-> default" 
+        , {g = g, recorderror  = recorderror, default = "NONE"})
 
+function mymatch (g, s)
+        errors = {}
+        subject = s     
+        io.write("Input: ", s, "\n")
+        local r = { g:match(s) }
+        io.write("Captures (separated by ';'): ")
+        for k, v in pairs(r) do
+                io.write(v .. "; ")
+        end
+        io.write("\nSyntactic errors found: " .. #errors)
+        if #errors > 0 then
+                io.write("\n")
+                local out = {}
+    for i, err in ipairs(errors) do
+        local msg = "Error at line " .. err.line .. " (col " .. err.col .. "): " .. err.msg
+      table.insert(out,  msg)
+    end
+    io.write(table.concat(out, "\n"))
+  end
+        print("\n")
+        return r
+end
+  
+mymatch(grec, "one,two")
+mymatch(grec, "one two three")
+mymatch(grec, "1,\n two, \n3,")
+mymatch(grec, "one\n two123, \nthree,")
diff --git a/examples/recovery.lua b/examples/recovery.lua
deleted file mode 100644
index 3272ae7..0000000
--- a/examples/recovery.lua
+++ /dev/null
@@ -1,134 +0,0 @@
-local lpeg = require"lpeglabel"
-
-local R, S, P, V = lpeg.R, lpeg.S, lpeg.P, lpeg.V
-local C, Cc, Ct, Cmt = lpeg.C, lpeg.Cc, lpeg.Ct, lpeg.Cmt
-local T, Lc = lpeg.T, lpeg.Lc
-
--- The `labels` table contains the list of labels that we will be using
--- as well as the corresponding error message for each label, which will
--- be used in our error reporting later on.
-local labels = {
-  {"NoExp",     "no expression found"},
-  {"Extra",     "extra characters found after the expression"},
-  {"ExpTerm",   "expected a term after the operator"},
-  {"ExpExp",    "expected an expression after the parenthesis"},
-  {"MisClose",  "missing a closing ')' after the expression"},
-}
-
--- The `labelindex` function gives us the index of a label in the
--- `labels` table, which serves as the integer representation of the label.
--- We need this because LPegLabel requires us to use integers for the labels.
-local function labelindex(labname)
-  for i, elem in ipairs(labels) do
-    if elem[1] == labname then
-      return i
-    end
-  end
-  error("could not find label: " .. labname)
-end
-
--- The `errors` table will hold the list of errors recorded during parsing
-local errors = {}
-
--- The `expect` function takes a pattern and a label and returns a pattern
--- that throws the specified label if the original pattern fails to match.
--- Before throwing the label, it records the label to be thrown along with
--- the position of the failure (index in input string) into the `errors` table.
-local function expect(patt, labname)
-  local i = labelindex(labname)
-  function recorderror(input, pos)
-    table.insert(errors, {i, pos})
-    return true
-  end
-  return patt + Cmt("", recorderror) * T(i)
-end
-
-local num = R("09")^1 / tonumber
-local op = S("+-*/")
-
--- The `compute` function takes an alternating list of numbers and
--- operators and computes the result of applying the operations
--- to the numbers in a left to right order (no operator precedence).
-local function compute(tokens)
-  local result = tokens[1]
-  for i = 2, #tokens, 2 do
-    if tokens[i] == '+' then
-      result = result + tokens[i+1]
-    elseif tokens[i] == '-' then
-      result = result - tokens[i+1]
-    elseif tokens[i] == '*' then
-      result = result * tokens[i+1]
-    elseif tokens[i] == '/' then
-      result = result / tokens[i+1]
-    else
-      error('unknown operation: ' .. tokens[i])
-    end
-  end
-  return result
-end
-
--- Our grammar is a simple arithmetic expression of integers that
--- does not take operator precedence into account but allows grouping
--- via parenthesis. We have incorporated some error recovery startegies
--- to our grammar so that it may resume parsing even after encountering
--- an error, which allows us to report more errors.
-local g = P {
-  "Exp",
-  Exp = Ct(V"Term" * (C(op) * V"OpRecov")^0) / compute;
-  -- `OpRecov` handles missing terms/operands by returning a dummy (zero).
-  OpRecov = Lc(V"Operand", Cc(0), labelindex("ExpTerm"));
-  Operand = expect(V"Term", "ExpTerm");
-  Term = num + V"Group";
-  -- `Group` handles missing closing parenthesis by simply ignoring it.
-  -- Like all the others, the error is still recorded of course.
-  Group = "(" * V"InnerExp" * Lc(expect(")", "MisClose"), P"", labelindex("MisClose"));
-  -- `InnerExp` handles missing expressions by skipping to the next closing
-  -- parenthesis. A dummy (zero) is returned in place of the expression.
-  InnerExp = Lc(expect(V"Exp", "ExpExp"), (P(1) - ")")^0 * Cc(0), labelindex("ExpExp"));
-}
-
-g = expect(g, "NoExp") * expect(-P(1), "Extra")
-
--- The `eval` function takes an input string to match against the grammar
--- we've just defined. If the input string matches, then the result of the
--- computation is returned, otherwise we return the error messages and
--- positions of all the failures encountered.
-local function eval(input)
-  local result, label, suffix = g:match(input)
-  if #errors == 0 then
-    return result
-  else
-    local out = {}
-    for i, err in ipairs(errors) do
-      local pos = err[2]
-      local msg = labels[err[1]][2]
-      table.insert(out, "syntax error: " .. msg .. " (at index " .. pos .. ")")
-    end
-    errors = {}
-    return nil, table.concat(out, "\n")
-  end
-end
-
-print(eval "98-76*(54/32)")
---> 37.125
-
-print(eval "(1+1-1*2/2")
---> syntax error: missing a closing ')' after the expression (at index 11)
-
-print(eval "(1+)-1*(2/2)")
---> syntax error: expected a term after the operator (at index 4)
-
-print(eval "(1+1)-1*(/2)")
---> syntax error: expected an expression after the parenthesis (at index 10)
-
-print(eval "1+(1-(1*2))/2x")
---> syntax error: extra chracters found after the expression (at index 14)
-
-print(eval "-1+(1-(1*2))/2")
---> syntax error: no expression found (at index 1)
-
-print(eval "(1+1-1*(2/2+)-():")
---> syntax error: expected a term after the operator (at index 13)
---> syntax error: expected an expression after the parenthesis (at index 16)
---> syntax error: missing a closing ')' after the expression (at index 17)
---> syntax error: extra characters found after the expression (at index 17)
diff --git a/examples/recoveryOpFail.lua b/examples/recoveryOpFail.lua
deleted file mode 100644
index 6ddc6a2..0000000
--- a/examples/recoveryOpFail.lua
+++ /dev/null
@@ -1,105 +0,0 @@
-local lpeg = require"lpeglabel"
-
-local R, S, P, V = lpeg.R, lpeg.S, lpeg.P, lpeg.V
-local C, Cc, Ct, Cmt, Carg = lpeg.C, lpeg.Cc, lpeg.Ct, lpeg.Cmt, lpeg.Carg
-local T, Lc, Rec = lpeg.T, lpeg.Lc, lpeg.Rec
-
-local labels = {
-  {"NoExp",     "no expression found"},
-  {"Extra",     "extra characters found after the expression"},
-  {"ExpTerm",   "expected a term after the operator"},
-  {"ExpExp",    "expected an expression after the parenthesis"},
-  {"MisClose",  "missing a closing ')' after the expression"},
-}
-
-local function labelindex(labname)
-  for i, elem in ipairs(labels) do
-    if elem[1] == labname then
-      return i
-    end
-  end
-  error("could not find label: " .. labname)
-end
-
-local function expect(patt, labname, recpatt)
-  local i = labelindex(labname)
-  local function recorderror(input, pos, errors)
-    table.insert(errors, {i, pos})
-    return true
-  end
-  if not recpatt then recpatt = P"" end
-  return Rec(patt, Cmt(Carg(1), recorderror) * recpatt)
-end
-
-local num = R("09")^1 / tonumber
-local op = S("+-*/")
-
-local function compute(tokens)
-  local result = tokens[1]
-  for i = 2, #tokens, 2 do
-    if tokens[i] == '+' then
-      result = result + tokens[i+1]
-    elseif tokens[i] == '-' then
-      result = result - tokens[i+1]
-    elseif tokens[i] == '*' then
-      result = result * tokens[i+1]
-    elseif tokens[i] == '/' then
-      result = result / tokens[i+1]
-    else
-      error('unknown operation: ' .. tokens[i])
-    end
-  end
-  return result
-end
-
-
-local g = P {
-  "Exp",
-  Exp = Ct(V"Term" * (C(op) * V"Operand")^0) / compute;
-  Operand = expect(V"Term", "ExpTerm", Cc(0));
-  Term = num + V"Group";
-  Group = "(" *  V"InnerExp" * expect(")", "MisClose");
-  InnerExp = expect(V"Exp", "ExpExp", (P(1) - ")")^0 * Cc(0));
-}
-
-g = expect(g, "NoExp", P(1)^0) * expect(-P(1), "Extra")
-
-local function eval(input)
-  local errors = {}
-  local result, label, suffix = g:match(input, 1, errors)
-  if #errors == 0 then
-    return result
-  else
-    local out = {}
-    for i, err in ipairs(errors) do
-      local pos = err[2]
-      local msg = labels[err[1]][2]
-      table.insert(out, "syntax error: " .. msg .. " (at index " .. pos .. ")")
-    end
-    return nil, table.concat(out, "\n")
-  end
-end
-
-print(eval "98-76*(54/32)")
---> 37.125
-
-print(eval "(1+1-1*2/2")
---> syntax error: missing a closing ')' after the expression (at index 11)
-
-print(eval "(1+)-1*(2/2)")
---> syntax error: expected a term after the operator (at index 4)
-
-print(eval "(1+1)-1*(/2)")
---> syntax error: expected an expression after the parenthesis (at index 10)
-
-print(eval "1+(1-(1*2))/2x")
---> syntax error: extra chracters found after the expression (at index 14)
-
-print(eval "-1+(1-(1*2))/2")
---> syntax error: no expression found (at index 1)
-
-print(eval "(1+1-1*(2/2+)-():")
---> syntax error: expected a term after the operator (at index 13)
---> syntax error: expected an expression after the parenthesis (at index 16)
---> syntax error: missing a closing ')' after the expression (at index 17)
---> syntax error: extra characters found after the expression (at index 17)
diff --git a/examples/recoveryOpLab.lua b/examples/recoveryOpLab.lua
deleted file mode 100644
index 6697f8b..0000000
--- a/examples/recoveryOpLab.lua
+++ /dev/null
@@ -1,107 +0,0 @@
-local lpeg = require"lpeglabel"
-
-local R, S, P, V = lpeg.R, lpeg.S, lpeg.P, lpeg.V
-local C, Cc, Ct, Cmt = lpeg.C, lpeg.Cc, lpeg.Ct, lpeg.Cmt
-local T, Lc, Rec = lpeg.T, lpeg.Lc, lpeg.Rec
-
-local labels = {
-  {"NoExp",     "no expression found"},
-  {"Extra",     "extra characters found after the expression"},
-  {"ExpTerm",   "expected a term after the operator"},
-  {"ExpExp",    "expected an expression after the parenthesis"},
-  {"MisClose",  "missing a closing ')' after the expression"},
-}
-
-local function labelindex(labname)
-  for i, elem in ipairs(labels) do
-    if elem[1] == labname then
-      return i
-    end
-  end
-  error("could not find label: " .. labname)
-end
-
-local errors = {}
-
-local function expect(patt, labname)
-  local i = labelindex(labname)
-  function recorderror(input, pos)
-    table.insert(errors, {i, pos})
-    return true
-  end
-  return patt + Cmt("", recorderror) * T(i)
-end
-
-local num = R("09")^1 / tonumber
-local op = S("+-*/")
-
-local function compute(tokens)
-  local result = tokens[1]
-  for i = 2, #tokens, 2 do
-    if tokens[i] == '+' then
-      result = result + tokens[i+1]
-    elseif tokens[i] == '-' then
-      result = result - tokens[i+1]
-    elseif tokens[i] == '*' then
-      result = result * tokens[i+1]
-    elseif tokens[i] == '/' then
-      result = result / tokens[i+1]
-    else
-      error('unknown operation: ' .. tokens[i])
-    end
-  end
-  return result
-end
-
-
-local g = P {
-  "Exp",
-  Exp = Ct(V"Term" * (C(op) * V"OpRecov")^0) / compute;
-  OpRecov = Rec(V"Operand", Cc(0), labelindex("ExpTerm"));
-  Operand = expect(V"Term", "ExpTerm");
-  Term = num + Rec(V"Group", P"", labelindex("MisClose"));
-  Group = "(" * Rec(V"InnerExp", (P(1) - ")")^0 * Cc(0), labelindex("ExpExp")) * expect(")", "MisClose");
-  InnerExp = expect(V"Exp", "ExpExp");
-}
-
-g = expect(g, "NoExp") * expect(-P(1), "Extra")
-
-local function eval(input)
-  local result, label, suffix = g:match(input)
-  if #errors == 0 then
-    return result
-  else
-    local out = {}
-    for i, err in ipairs(errors) do
-      local pos = err[2]
-      local msg = labels[err[1]][2]
-      table.insert(out, "syntax error: " .. msg .. " (at index " .. pos .. ")")
-    end
-    errors = {}
-    return nil, table.concat(out, "\n")
-  end
-end
-
-print(eval "98-76*(54/32)")
---> 37.125
-
-print(eval "(1+1-1*2/2")
---> syntax error: missing a closing ')' after the expression (at index 11)
-
-print(eval "(1+)-1*(2/2)")
---> syntax error: expected a term after the operator (at index 4)
-
-print(eval "(1+1)-1*(/2)")
---> syntax error: expected an expression after the parenthesis (at index 10)
-
-print(eval "1+(1-(1*2))/2x")
---> syntax error: extra chracters found after the expression (at index 14)
-
-print(eval "-1+(1-(1*2))/2")
---> syntax error: no expression found (at index 1)
-
-print(eval "(1+1-1*(2/2+)-():")
---> syntax error: expected a term after the operator (at index 13)
---> syntax error: expected an expression after the parenthesis (at index 16)
---> syntax error: missing a closing ')' after the expression (at index 17)
---> syntax error: extra characters found after the expression (at index 17)
diff --git a/examples/tiny.lua b/examples/tiny.lua
index 99c3144..784e031 100644
--- a/examples/tiny.lua
+++ b/examples/tiny.lua
@@ -1,4 +1,4 @@
-local re = require 'relabel'
+local re = require 'relabelrec'
 
 local terror = {}
 
@@ -25,21 +25,6 @@ newError("errFactor", "Error: expected '(', ID, or number after '*' or '/'")
 newError("errExpFac", "Error: expected expression after '('")
 newError("errClosePar", "Error: expected ')' after expression")
 
-local line
-
-local function incLine()
-        line = line + 1
-        return true
-end
-
-local function countLine(s, i)
-        line = 1
-        local p = re.compile([[
-                S <- (%nl -> incLine  / .)*
-        ]], { incLine = incLine}) 
-        p:match(s:sub(1, i))
-        return true
-end
 
 local labelCode = {}
 for k, v in ipairs(terror) do 
@@ -48,7 +33,7 @@ end
 
 re.setlabels(labelCode)
 
-local g = re.compile([[
+local g = re.compile[[
   Tiny         <- CmdSeq  
   CmdSeq       <- (Cmd (SEMICOLON / ErrSemi)) (Cmd (SEMICOLON / ErrSemi))*
   Cmd          <- IfCmd / RepeatCmd / ReadCmd / WriteCmd  / AssignCmd 
@@ -61,25 +46,24 @@ local g = re.compile([[
   SimpleExp    <- Term  ((ADD / SUB)  (Term / ErrTerm))*
   Term         <- Factor  ((MUL / DIV)  (Factor / ErrFactor))*
   Factor       <- OPENPAR  (Exp / ErrExpFac)  (CLOSEPAR / ErrClosePar)  / NUMBER  / NAME
-  ErrSemi      <- ErrCount %{errSemi}
-        ErrExpIf     <- ErrCount %{errExpIf}
-        ErrThen      <- ErrCount %{errThen}
-        ErrCmdSeq1   <- ErrCount %{errCmdSeq1}
-        ErrCmdSeq2   <- ErrCount %{errCmdSeq2}
-        ErrEnd       <- ErrCount %{errEnd}
-        ErrCmdSeqRep <- ErrCount %{errCmdSeqRep}
-        ErrUntil     <- ErrCount %{errUntil}
-        ErrExpRep    <- ErrCount %{errExpRep}
-        ErrAssignOp  <- ErrCount %{errAssignOp}
-        ErrExpAssign <- ErrCount %{errExpAssign}
-        ErrReadName  <- ErrCount %{errReadName}
-        ErrWriteExp  <- ErrCount %{errWriteExp}
-        ErrSimpExp   <- ErrCount %{errSimpExp}
-        ErrTerm      <- ErrCount %{errTerm}
-        ErrFactor    <- ErrCount %{errFactor}
-        ErrExpFac    <- ErrCount %{errExpFac}
-        ErrClosePar  <- ErrCount %{errClosePar}
-        ErrCount     <- '' => countLine 
+  ErrSemi      <- %{errSemi}
+        ErrExpIf     <- %{errExpIf}
+        ErrThen      <- %{errThen}
+        ErrCmdSeq1   <- %{errCmdSeq1}
+        ErrCmdSeq2   <- %{errCmdSeq2}
+        ErrEnd       <- %{errEnd}
+        ErrCmdSeqRep <- %{errCmdSeqRep}
+        ErrUntil     <- %{errUntil}
+        ErrExpRep    <- %{errExpRep}
+        ErrAssignOp  <- %{errAssignOp}
+        ErrExpAssign <- %{errExpAssign}
+        ErrReadName  <- %{errReadName}
+        ErrWriteExp  <- %{errWriteExp}
+        ErrSimpExp   <- %{errSimpExp}
+        ErrTerm      <- %{errTerm}
+        ErrFactor    <- %{errFactor}
+        ErrExpFac    <- %{errExpFac}
+        ErrClosePar  <- %{errClosePar}
   ADD          <- Sp '+'
   ASSIGNMENT   <- Sp ':='
   CLOSEPAR     <- Sp ')'
@@ -102,12 +86,17 @@ local g = re.compile([[
   WRITE        <- Sp 'write'
         RESERVED     <- (IF / ELSE / END / READ / REPEAT / THEN / UNTIL / WRITE) ![a-z]+
   Sp           <- %s*   
-]], { countLine = countLine })
+]]
 
 
-local function printError(n, e)
-        assert(n == nil)
-        print("Line " .. line .. ": " .. terror[e].msg)
+local function mymatch(g, s)
+        local r, e, sfail = g:match(s)
+  if not r then
+    local line, col = re.calcline(s, #s - #sfail)
+    local msg = "Error at line " .. line .. " (col " .. col .. "): "
+                return r, msg .. terror[e].msg
+        end 
+        return r
 end
 
 local s = [[
@@ -118,7 +107,7 @@ repeat
   n := n - 1
 until (n < 1);
 write f;]]
-printError(g:match(s))
+print(mymatch(g, s))
 
 s = [[
 n := 5;
@@ -128,14 +117,14 @@ repeat
   n := n - 1;
 until (n < 1);
 read ;]]
-printError(g:match(s))
+print(mymatch(g, s))
 
 s = [[
 if a < 1 then
   b := 2;
 else
   b := 3;]]
-printError(g:match(s))
+print(mymatch(g, s))
 
 s = [[
 n := 5;
@@ -145,7 +134,7 @@ repeat
   n := n - 1;
 untill (n < 1);
 ]]
-printError(g:match(s))
+print(mymatch(g, s))
 
 s = [[
 n := 5;
@@ -155,9 +144,8 @@ repeat
   n := n - 1;
 3 (n < 1);
 ]]
-printError(g:match(s))
-
-printError(g:match("a : 2"))
-printError(g:match("a := (2"))
+print(mymatch(g, s))
 
+print(mymatch(g, "a : 2"))
+print(mymatch(g, "a := (2"))
 
diff --git a/examples/typedlua/test.lua b/examples/typedlua/test.lua
index ed4e7a1..95474ba 100755
--- a/examples/typedlua/test.lua
+++ b/examples/typedlua/test.lua
@@ -401,15 +401,18 @@ assert(m == e)
 -- unfinished comments
 
 s = [=[
---[[ testing
+--[[ 
+
+testing
 unfinished
+
 comment
-]=]
+      ]=]
 --[=[
 test.lua:3:1: syntax error, unexpected 'comment', expecting '=', ',', 'String', '{', '(', ':', '[', '.'
 ]=]
 e = [=[
-test.lua:1:1: unfinished long comment
+test.lua:1:2: unfinished long comment
 ]=]
 
 r, m = parse(s)
diff --git a/examples/typedlua/tllexer.lua b/examples/typedlua/tllexer.lua
index 6517ba5..d6033ec 100644
--- a/examples/typedlua/tllexer.lua
+++ b/examples/typedlua/tllexer.lua
@@ -1,6 +1,6 @@
 local tllexer = {}
 
-local lpeg = require "lpeglabel"
+local lpeg = require "lpeglabelrec"
 lpeg.locale(lpeg)
 
 local tlerror = require "tlerror"
@@ -9,10 +9,6 @@ function tllexer.try (pat, label)
   return pat + lpeg.T(tlerror.labels[label])
 end
 
-function tllexer.catch (pat, label)
-  return lpeg.Lc(pat, lpeg.P(false), tlerror.labels[label])
-end
-
 local function setffp (s, i, t, n)
   if not t.ffp or i > t.ffp then
     t.ffp = i
@@ -45,7 +41,10 @@ local CloseEQ = lpeg.Cmt(Close * lpeg.Cb("init"),
 local LongString = Open * (lpeg.P(1) - CloseEQ)^0 * tllexer.try(Close, "LongString") /
                    function (s, o) return s end
 
-local Comment = lpeg.Lc(lpeg.P("--") * LongString / function () return end,
+local LongStringCm1 = Open * (lpeg.P(1) - CloseEQ)^0 * Close /
+                   function (s, o) return s end
+
+local Comment = lpeg.Rec(lpeg.P"--" * #Open * (LongStringCm1 / function() return end + lpeg.T(tlerror.labels["LongString"])),
                 lpeg.T(tlerror.labels["LongComment"]), tlerror.labels["LongString"]) +
                 lpeg.P("--") * (lpeg.P(1) - lpeg.P("\n"))^0
 
diff --git a/examples/typedlua/tlparser.lua b/examples/typedlua/tlparser.lua
index a301fa6..fe4fd5e 100644
--- a/examples/typedlua/tlparser.lua
+++ b/examples/typedlua/tlparser.lua
@@ -1,6 +1,6 @@
 local tlparser = {}
 
-local lpeg = require "lpeglabel"
+local lpeg = require "lpeglabelrec"
 lpeg.locale(lpeg)
 
 local tllexer = require "tllexer"