29 files changed, 1407 insertions, 995 deletions

diff --git a/README.md b/README.md
index 1f1bdff..9484b3d 100644
--- a/README.md
+++ b/README.md
@@ -10,47 +10,46 @@ LPegLabel is a conservative extension of the
 [LPeg](http://www.inf.puc-rio.br/~roberto/lpeg)
 library that provides an implementation of Parsing
 Expression Grammars (PEGs) with labeled failures. 
-Labels can be used to signal different kinds of erros
-and to specify which alternative in a labeled ordered
-choice should handle a given label. Labels can also be
-combined with the standard patterns of LPeg.
+Labels can be used to signal different kinds of errors
+and to specify which recovery pattern should handle a
+given label. Labels can also be combined with the standard
+patterns of LPeg.
 
 This document describes the new functions available
 in LpegLabel and presents some examples of usage.
-For a more detailed discussion about PEGs with labeled failures
-please see [A Parsing Machine for Parsing Expression
-Grammars with Labeled Failures](https://docs.google.com/viewer?a=v&pid=sites&srcid=ZGVmYXVsdGRvbWFpbnxzcW1lZGVpcm9zfGd4OjMzZmE3YzM0Y2E2MGM5Y2M).
-
 
 In LPegLabel, the result of an unsuccessful matching
 is a triple **nil, lab, sfail**, where **lab**
 is the label associated with the failure, and
 **sfail** is the suffix input being matched when
-**lab** was thrown. Below there is a brief summary
-of the new functions provided by LpegLabel: 
+**lab** was thrown. 
+
+With labeled failures it is possible to distinguish
+between a regular failure and an error. Usually, a
+regular failure is produced when the matching of a
+character fails, and it is caught by an ordered choice.
+An error, by its turn, is produced by the throw operator
+and may be caught by the recovery operator. 
+ 
+Below there is a brief summary of the new functions provided by LpegLabel: 
 
 <table border="1">
 <tbody><tr><td><b>Function</b></td><td><b>Description</b></td></tr>
-<tr><td><a href="#f-t"><code>lpeglabel.T (l)</code></a></td>
-  <td>Throws label <code>l</code></td></tr>
-<tr><td><a href="#f-lc"><code>lpeglabel.Lc (p1, p2, l1, ..., ln)</code></a></td>
-  <td>Matches <code>p1</code> and tries to match <code>p2</code>
-      if the matching of <code>p1</code> gives one of l<sub>1</sub>, ..., l<sub>n</sub> 
-      </td></tr>
-<tr><td><a href="#f-rec"><code>lpeglabel.Rec (p1, p2 [, l1, ..., ln])</code></a></td>
-  <td>Like <code>Lc</code> but does not reset the position of the parser
-      when trying <code>p2</code>. By default, it catches regular PEG failures
-      </td></tr>
+<tr><td><a href="#f-t"><code>lpeglabelrec.T (l)</code></a></td>
+  <td>Throws a label <code>l</code> to signal an error</td></tr>
+<tr><td><a href="#f-rec"><code>lpeglabelrec.Rec (p1, p2, l1 [, l2, ..., ln])</code></a></td>
+  <td>Specifies a recovery pattern <code>p2</code> for <code>p1</code>,
+ when the matching of <code>p1</code> gives one of the labels l1, ..., ln.</td></tr>
 <tr><td><a href="#re-t"><code>%{l}</code></a></td>
-  <td>Syntax of <em>relabel</em> module. Equivalent to <code>lpeg.T(l)</code>
+  <td>Syntax of <em>relabelrec</em> module. Equivalent to <code>lpeglabelrec.T(l)</code>
       </td></tr>
-<tr><td><a href="#re-lc"><code>p1 /{l1, ..., ln} p2</code></a></td>
-  <td>Syntax of <em>relabel</em> module. Equivalent to <code>lpeg.Lc(p1, p2, l1, ..., ln)</code>
+<tr><td><a href="#re-rec"><code>p1 //{l1 [, l2, ..., ln} p2</code></a></td>
+  <td>Syntax of <em>relabelrec</em> module. Equivalent to <code>lpeglabelrec.Rec(p1, p2, l1, ..., ln)</code>
       </td></tr>
-<tr><td><a href="#re-line"><code>relabel.calcline(subject, i)</code></a></td>
+<tr><td><a href="#re-line"><code>relabelrec.calcline(subject, i)</code></a></td>
   <td>Calculates line and column information regarding position <i>i</i> of the subject</code>
       </td></tr>
-<tr><td><a href="#re-setl"><code>relabel.setlabels (tlabel)</code></a></td>
+<tr><td><a href="#re-setl"><code>relabelrec.setlabels (tlabel)</code></a></td>
   <td>Allows to specicify a table with mnemonic labels. 
       </td></tr>
 </tbody></table>
@@ -59,28 +58,20 @@ of the new functions provided by LpegLabel:
 ### Functions
 
 
-#### <a name="f-t"></a><code>lpeglabel.T(l)</code>
+#### <a name="f-t"></a><code>lpeglabelrec.T(l)</code>
 
 
 Returns a pattern that throws the label `l`.
-A label must be an integer between 0 and 255.
+A label must be an integer between 1 and 255.
 
-The label 0 is equivalent to the regular failure of PEGs.
 
+#### <a name="f-rec"></a><code>lpeglabelrec.Rec(p1, p2, l1, ..., ln)</code>
 
-#### <a name="f-lc"></a><code>lpeglabel.Lc(p1, p2, l1, ..., ln)</code>
-
-Returns a pattern equivalent to a *labeled ordered choice*.
+Returns a *recovery pattern*.
 If the matching of `p1` gives one of the labels `l1, ..., ln`,
-then the matching of `p2` is tried from the same position. Otherwise,
-the result of the matching of `p1` is the pattern's result.
-
-The labeled ordered choice `lpeg.Lc(p1, p2, 0)` is equivalent to the
-regular ordered choice `p1 / p2`.
+then the matching of `p2` is tried from the failure position of `p1`.
+Otherwise, the result of the matching of `p1` is the pattern's result.
 
-Although PEG's ordered choice is associative, the labeled ordered choice is not.
-When using this function, the user should take care to build a left-associative
-labeled ordered choice pattern.
 
 
 #### <a name="f-rec"></a><code>lpeglabel.Rec(p1, p2 [, l1, ..., ln])</code>
@@ -94,29 +85,26 @@ i.e. `lpeg.Rec(p1, p2)` is equivalent to `lpeg.Rec(p1, p2, 0)`.
 
 #### <a name="re-t"></a><code>%{l}</code>
 
-Syntax of *relabel* module. Equivalent to `lpeg.T(l)`.
+Syntax of *relabelrec* module. Equivalent to `lpeg.T(l)`.
 
 
-#### <a name="re-lc"></a><code>p1 /{l1, ..., ln} p2</code>
+#### <a name="re-lc"></a><code>p1 //{l1, ..., ln} p2</code>
 
-Syntax of *relabel* module. Equivalent to `lpeg.Lc(p1, p2, l1, ..., ln)`.
+Syntax of *relabelrec* module. Equivalent to `lpeglabelrec.Rec(p1, p2, l1, ..., ln)`.
 
-The `/{}` operator is left-associative. 
+The `//{}` operator is left-associative. 
 
-A grammar can use both choice operators (`/` and `/{}`),
-but a single choice can not mix them. That is, the parser of `relabel`
-module will not recognize a pattern as `p1 / p2 /{l1} p3`.
 
 
-#### <a name="re-line"></a><code>relabel.calcline (subject, i)</code>
+#### <a name="re-line"></a><code>relabelrec.calcline (subject, i)</code>
 
 Returns line and column information regarding position <i>i</i> of the subject.
 
 
-#### <a name="re-setl"></a><code>relabel.setlabels (tlabel)</code>
+#### <a name="re-setl"></a><code>relabelrec.setlabels (tlabel)</code>
 
 Allows to specicify a table with labels. They keys of
-`tlabel` must be integers between 0 and 255,
+`tlabel` must be integers between 1 and 255,
 and the associated values should be strings.
 
 
@@ -132,16 +120,31 @@ in the *examples* directory.
 The following example defines a grammar that matches
 a list of identifiers separated by commas. A label
 is thrown when there is an error matching an identifier
-or a comma: 
+or a comma.
+
+We use function `newError` to store error messages in a
+table and to return the index associated with each error message.
+
 
 ```lua
-local m = require'lpeglabel'
-local re = require'relabel'
+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 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",
+  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,
@@ -151,18 +154,12 @@ 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 .. ")"
-    if e == 1 then
-      return r, msg .. ": expecting an identifier before '" .. sfail .. "'"
-    elseif e == 2 then
-      return r, msg .. ": expecting ',' before '" .. sfail .. "'"
-    else
-      return r, msg
-    end
+    local msg = "Error at line " .. line .. " (col " .. col .. "): "
+    return r, msg .. terror[e] .. " before '" .. sfail .. "'"
   end
   return r
 end
- 
+  
 print(mymatch(g, "one,two"))              --> 8
 print(mymatch(g, "one two"))              --> nil Error at line 1 (col 3): expecting ',' before ' two'
 print(mymatch(g, "one,\n two,\nthree,"))  --> nil Error at line 3 (col 6): expecting an identifier before ''
@@ -170,23 +167,73 @@ print(mymatch(g, "one,\n two,\nthree,"))  --> nil Error at line 3 (col 6): expec
 
 In this example we could think about writing rule <em>List</em> as follows:
 ```lua
-List = ((m.V"Comma" + m.T(2)) * (m.V"Id" + m.T(1)))^0,
+List = ((m.V"Comma" + m.T(errComma)) * (m.V"Id" + m.T(errId)))^0,
 ```
 
-but when matching this expression agains the end of input
-we would get a failure whose associated label would be **2**,
+but when matching this expression against the end of input
+we would get a failure whose associated label would be **errComma**,
 and this would cause the failure of the *whole* repetition.
- 
 
-##### Mnemonics instead of numbers
 
-In the previous example we could have created a table
-with the error messages to improve the readbility of the PEG.
-Below we rewrite the previous grammar following this approach: 
 
+#### Error Recovery
+
+By using the `Rec` function we can specify a recovery pattern that
+should be matched when a label is thrown. After matching the recovery
+pattern, and possibly recording the error, the parser will resume
+the <em>regular</em> matching. For example, in the example below
+we expect to match rule `A`, but when a failure occur the label 42
+is thrown and then we will try to match the recovery pattern `recp`:
 ```lua
-local m = require'lpeglabel'
-local re = require'relabel'
+local m = require'lpeglabelrec'
+
+local recp = m.P"oast"
+
+local g = m.P{
+  "S",
+  S = m.Rec(m.V"A", recp, 42) * ".",
+  A = m.P"t" * (m.P"est" + m.T(42))
+}
+
+print(g:match("test."))   --> 6
+print(g:match("toast."))  --> 7
+print(g:match("oast."))   --> nil  0  oast.
+print(g:match("toward."))   --> nil  0  ward.
+```
+When trying to match subject 'toast.', in rule `A` the first
+'t' is matched, then the matching of `m.P"est"` fails and label 42
+is thrown, with the associated inpux suffix 'oast.'. In rule
+`S` label 42 is caught and the recovery pattern matches 'oast',
+so pattern `'.'` matches the rest of the input.
+
+When matching subject 'oast.', pattern `m.P"t"` fails, and
+the result of the matching is <b>nil,  0, oast.</b>.
+
+When matching 'toward.', label 42 is thrown after matching 't',
+with the associated input suffix 'oward.'. As the matching of the
+recovery pattern fails, the result is <b>nil, 0, ward.</b>.
+
+Usually, the recovery pattern is an expression that does not fail.
+In the previous example, we could have used `(m.P(1) - m.P".")^0`
+as the recovery pattern.
+
+Below we rewrite the grammar that describes a list of identifiers
+to use a recovery strategy. Grammar `g` remains the same, but we add a
+recovery grammar `grec` that handles the labels thrown by `g`.
+
+In grammar `grec` we use functions `record` and `sync`.
+Function `record`, plus function `recorderror`, will help
+us to save the input position where a label was thrown,
+while function `sync` will give us a synchronization pattern,
+that consumes the input while is not possible to match a given
+pattern `p`.   
+
+When the matching of an identifier fails, a defaul value ('NONE')
+is provided.
+
+```lua
+local m = require'lpeglabelrec'
+local re = require'relabelrec'
 
 local terror = {}
 
@@ -199,73 +246,88 @@ 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
-    local line, col = re.calcline(s, #s - #sfail)
-    local msg = "Error at line " .. line .. " (col " .. col .. "): "
-    return r, msg .. terror[e] .. " before '" .. sfail .. "'"
-  end
-  return r
-end
-  
-print(mymatch(g, "one,two"))              --> 8
-print(mymatch(g, "one two"))              --> nil Error at line 1 (col 3): expecting ',' before ' two'
-print(mymatch(g, "one,\n two,\nthree,"))  --> nil Error at line 3 (col 6): expecting an identifier before ''
-```
+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
 
-##### *relabel* syntax
+function record (lab)
+  return (m.Cp() * m.Cc(lab)) / recorderror
+end
 
-Now we rewrite the previous example using the syntax
-supported by *relabel*:
+function sync (p)
+  return (-p * m.P(1))^0
+end
 
-```lua
-local re = require 'relabel' 
+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",")
+}
 
-local g = re.compile[[
-  S      <- Id List
-  List   <- !.  /  (',' /  %{2}) (Id / %{1}) List
-  Id     <- Sp [a-z]+
-  Comma  <- Sp ','
-  Sp     <- %s*
-]]
 
 function mymatch (g, s)
+  errors = {}
+  subject = 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 .. ")"
-    if e == 1 then
-      return r, msg .. ": expecting an identifier before '" .. sfail .. "'"
-    elseif e == 2 then
-      return r, msg .. ": expecting ',' before '" .. sfail .. "'"
-    else
-      return r, msg
+  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(g, "one,two"))              --> 8
-print(mymatch(g, "one two"))              --> nil Error at line 1 (col 3): expecting ',' before ' two'
-print(mymatch(g, "one,\n two,\nthree,"))  --> nil Error at line 3 (col 6): expecting an identifier before ''
+  
+print(mymatch(grec, "one,two"))
+-- Captures (separated by ';'): one; two; 
+-- Syntactic errors found: 0
+
+print(mymatch(grec, "one two three"))
+-- Captures (separated by ';'): one; two; three; 
+-- Syntactic errors found: 2
+-- Error at line 1 (col 4): expecting ','
+-- Error at line 1 (col 8): expecting ','
+
+print(mymatch(grec, "1,\n two, \n3,"))
+-- Captures (separated by ';'): NONE; two; NONE; NONE; 
+-- Syntactic errors found: 3
+-- Error at line 1 (col 1): expecting an identifier
+-- Error at line 2 (col 6): expecting an identifier
+-- Error at line 3 (col 2): expecting an identifier
+
+print(mymatch(grec, "one\n two123, \nthree,"))
+-- Captures (separated by ';'): one; two; three; NONE; 
+-- Syntactic errors found: 3
+-- Error at line 2 (col 1): expecting ','
+-- Error at line 2 (col 5): expecting ','
+-- Error at line 3 (col 6): expecting an identifier
 ```
 
-With the help of function *setlabels* we can also rewrite the previous example to use
-mnemonic labels instead of plain numbers:
+##### *relabelrec* syntax
+
+Below we describe again a grammar that matches a list of identifiers,
+now using the syntax supported by *relabelrec*, where `//{}` is the
+recovery operator, and `%{}` is the throw operator:
 
 ```lua
-local re = require 'relabel' 
+local re = require 'relabelrec' 
 
 local errinfo = {
   {"errUndef",  "undefined"},
@@ -285,59 +347,124 @@ 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*
 ]]
 
+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
+
+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)
-  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 .. "'"
+  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
 
-print(mymatch(g, "one,two"))              --> 8
-print(mymatch(g, "one two"))              --> nil Error at line 1 (col 3): expecting ',' before ' two'
-print(mymatch(g, "one,\n two,\nthree,"))  --> nil Error at line 3 (col 6): expecting an identifier before ''
+print(mymatch(grec, "one,two"))
+-- Captures (separated by ';'): one; two; 
+-- Syntactic errors found: 0
+
+print(mymatch(grec, "one two three"))
+-- Captures (separated by ';'): one; two; three; 
+-- Syntactic errors found: 2
+-- Error at line 1 (col 4): expecting ','
+-- Error at line 1 (col 8): expecting ','
+
+print(mymatch(grec, "1,\n two, \n3,"))
+-- Captures (separated by ';'): NONE; two; NONE; NONE; 
+-- Syntactic errors found: 3
+-- Error at line 1 (col 1): expecting an identifier
+-- Error at line 2 (col 6): expecting an identifier
+-- Error at line 3 (col 2): expecting an identifier
+
+print(mymatch(grec, "one\n two123, \nthree,"))
+-- Captures (separated by ';'): one; two; three; NONE; 
+-- Syntactic errors found: 3
+-- Error at line 2 (col 1): expecting ','
+-- Error at line 2 (col 5): expecting ','
+-- Error at line 3 (col 6): expecting an identifier
 ```
 
+
 #### Arithmetic Expressions
 
-Here's an example of an LPegLabel grammar that make its own function called
-'expect', which takes a pattern and a label as parameters and throws the label
-if the pattern fails to be matched. This function can be extended later on to
-record all errors encountered once error recovery is implemented.
+Here's an example of an LPegLabel grammar that matches an expression.
+We have used a function `expect`, that takes a pattern `patt` and a label as
+parameters and builds a new pattern that throws this label when `patt`
+fails.
 
-```lua
-local lpeg = require"lpeglabel"
+When a subexpression is syntactically invalid, a default value of 1000
+is provided by the recovery pattern, so the evaluation of an expression
+should always produce a numeric value. 
 
-local R, S, P, V, C, Ct, T = lpeg.R, lpeg.S, lpeg.P, lpeg.V, lpeg.C, lpeg.Ct, lpeg.T
+In this example, we can see that it may be a tedious and error prone
+task to build manually the recovery grammar `grec`. In the next example
+we will show how to build the recovery grammar in a more automatic way. 
+
+```lua
+local m = require"lpeglabelrec"
+local re = require"relabelrec"
 
 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"},
+  {"ExpTermFirst",  "expected an expression"},
+  {"ExpTermOp",   "expected a term after the operator"},
   {"MisClose",  "missing a closing ')' after the expression"},
 }
 
-local function expect(patt, labname)
+local function labelindex(labname)
   for i, elem in ipairs(labels) do
     if elem[1] == labname then
-      return patt + T(i)
+      return i
     end
   end
-
   error("could not find label: " .. labname)
 end
 
-local num = R("09")^1 / tonumber
-local op = S("+-*/")
+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]
@@ -346,10 +473,6 @@ local function compute(tokens)
       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
@@ -357,81 +480,223 @@ local function compute(tokens)
   return result
 end
 
-local g = P {
+local g = m.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");
+  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"),
 }
 
-g = expect(g, "NoExp") * expect(-P(1), "Extra")
+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")), 
+  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)
-  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 .. ")"
+  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 "98-76*(54/32)")
---> 37.125
+print(eval "90-70-(5)+3")
+-- Syntactic errors found: 0
+-- Result = 18
+
+print(eval "15+")
+-- Syntactic errors found: 1
+-- syntax error: expected a term after the operator (at index 3)
+-- Result = 1015
+
+print(eval "-2")
+-- Syntactic errors found: 1
+-- syntax error: expected an expression (at index 1)
+-- Result = 998
+
+print(eval "1+()+")
+-- Syntactic errors found: 2
+-- syntax error: expected an expression (at index 4)
+-- syntax error: expected a term after the operator (at index 5)
+-- Result = 2001
+
+print(eval "1+(")
+-- Syntactic errors found: 2
+-- syntax error: expected an expression (at index 3)
+-- syntax error: missing a closing ')' after the expression (at index 3)
+-- Result = 1001
+
+print(eval "3)")
+-- Syntactic errors found: 0
+-- Result = 3
+```
 
-print(eval "(1+1-1*2/2")
---> syntax error: missing a closing ')' after the expression (at index 11)
+#### Automatically Building the Recovery Grammar 
 
-print(eval "(1+)-1*(2/2)")
---> syntax error: expected a term after the operator (at index 4)
+Below we rewrite the previous example to automatically
+build the recovery grammar based on information provided
+by the user for each label (error message, recovery pattern, etc). 
+In the example below we also throw an error when the grammar
+does not match the whole subject.
 
-print(eval "(1+1)-1*(/2)")
---> syntax error: expected an expression after the parenthesis (at index 10)
+```lua
+local m = require"lpeglabelrec"
+local re = require"relabelrec"
 
-print(eval "1+(1-(1*2))/2x")
---> syntax error: extra chracters found after the expression (at index 14)
+local num = m.R("09")^1 / tonumber
+local op = m.S("+-")
 
-print(eval "-1+(1-(1*2))/2")
---> syntax error: no expression found (at index 1)
-```
+local labels = {}
+local nlabels = 0
 
-#### Catching labels
+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
 
-When a label is thrown, the grammar itself can handle this label
-by using the labeled ordered choice. Below we rewrite the example
-of the list of identifiers to show this feature:
+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
 
-```lua
-local m = require'lpeglabel'
+local function expect(patt, labname)
+  local i = labels[labname].id
+  return patt + m.T(i)
+end
 
-local terror = {}
+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 function newError(s)
-  table.insert(terror, s)
-  return #terror
+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
 
-local errUndef = newError("undefined")
-local errId = newError("expecting an identifier")
-local errComma = newError("expecting ','")
+function record (labname)
+  return (m.Cp() * m.Cc(labname)) / recorderror
+end
 
-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
-}
+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(m.match(g, "one,two"))  --> 8
-print(m.match(g, "one two"))  --> expecting ','
-print(m.match(g, "one,\n two,\nthree,"))  --> expecting an identifier
+print(eval "90-70-(5)+3")
+-- Syntactic errors found: 0
+-- Result = 18
+
+print(eval "15+")
+-- Syntactic errors found: 1
+-- syntax error: expected a term after the operator (at index 3)
+-- Result = 1015
+
+print(eval "-2")
+-- Syntactic errors found: 1
+-- syntax error: expected an expression (at index 1)
+-- Result = 998
+
+print(eval "1+()+")
+-- Syntactic errors found: 2
+-- syntax error: expected an expression (at index 4)
+-- syntax error: expected a term after the operator (at index 5)
+-- Result = 2001
+
+print(eval "1+(")
+-- Syntactic errors found: 2
+-- syntax error: expected an expression (at index 3)
+-- syntax error: missing a closing ')' after the expression (at index 3)
+-- Result = 1001
+
+print(eval "3)")
+-- Syntactic errors found: 1
+-- syntax error: extra characters found after the expression (at index 2)
+-- Result = 3
 ```
 
 #### Error Recovery
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"
diff --git a/lpcode.c b/lpcode.c
index 2987cfc..b2dbba2 100644
--- a/lpcode.c
+++ b/lpcode.c
@@ -196,7 +196,7 @@ int checkaux (TTree *tree, int pred) {
       if (checkaux(sib2(tree), pred)) return 1;
       /* else return checkaux(sib1(tree), pred); */
       tree = sib1(tree); goto tailcall;
-                case TLabChoice: case TRecov: /* labeled failure */
+                case TRecov: /* labeled failure */
      /* we do not know whether sib2 will be evaluated */
      tree = sib1(tree); goto tailcall;
     case TCapture: case TGrammar: case TRule:
@@ -218,10 +218,10 @@ int fixedlenx (TTree *tree, int count, int len) {
   switch (tree->tag) {
     case TChar: case TSet: case TAny:
       return len + 1;
-    case TFalse: case TTrue: case TNot: case TAnd: case TBehind:
-    case TThrow: /* labeled failure */
+    case TFalse: case TTrue: case TNot: case TAnd: case TBehind: 
       return len;
     case TRep: case TRunTime: case TOpenCall:
+    case TThrow: /* labeled failure */
       return -1;
     case TCapture: case TRule: case TGrammar:
       /* return fixedlenx(sib1(tree), count); */
@@ -237,7 +237,7 @@ int fixedlenx (TTree *tree, int count, int len) {
       /* else return fixedlenx(sib2(tree), count, len); */
       tree = sib2(tree); goto tailcall;
     }
-    case TChoice: case TLabChoice: {  /* labeled failure */
+    case TChoice: {  
       int n1, n2;
       n1 = fixedlenx(sib1(tree), count, len);
       if (n1 < 0) return -1;
@@ -287,7 +287,7 @@ static int getfirst (TTree *tree, const Charset *follow, Charset *firstset) {
       loopset(i, firstset->cs[i] = follow->cs[i]); /* follow = fullset(?) */
       return 1;
     } 
-    case TChoice: case TLabChoice: {  /*(?) labeled failure */
+    case TChoice: {  
       Charset csaux;
       int e1 = getfirst(sib1(tree), follow, firstset);
       int e2 = getfirst(sib2(tree), follow, &csaux);
@@ -378,7 +378,7 @@ static int headfail (TTree *tree) {
       if (!nofail(sib2(tree))) return 0;
       /* else return headfail(sib1(tree)); */
       tree = sib1(tree); goto tailcall;
-    case TChoice: case TLabChoice: case TRecov: /* labeled failure */
+    case TChoice:  case TRecov: /* labeled failure */
       if (!headfail(sib1(tree))) return 0;
       /* else return headfail(sib2(tree)); */
       tree = sib2(tree); goto tailcall;
@@ -398,7 +398,7 @@ static int needfollow (TTree *tree) {
     case TChar: case TSet: case TAny:
     case TFalse: case TTrue: case TAnd: case TNot:
     case TRunTime: case TGrammar: case TCall: case TBehind:
-    case TThrow: case TLabChoice: case TRecov: /* (?)labeled failure */
+    case TThrow: case TRecov: /* (?)labeled failure */
       return 0;
     case TChoice: case TRep:
       return 1;
@@ -433,7 +433,7 @@ int sizei (const Instruction *i) {
       return 2;
     case IThrow:  /* labeled failure */ 
                         return 1;
-    case ILabChoice: case IRecov: 
+   case IRecov: 
       return (CHARSETINSTSIZE - 1) + 2; /* labeled failure */
     default: return 1;
   }
@@ -499,7 +499,7 @@ static int addoffsetinst (CompileState *compst, Opcode op) {
   int i = addinstruction(compst, op, 0);  /* instruction */
   addinstruction(compst, (Opcode)0, 0);  /* open space for offset */
   assert(op == ITestSet || sizei(&getinstr(compst, i)) == 2 || 
-        op == IRecov || op == ILabChoice); /* labeled failure */
+        op == IRecov); /* labeled failure */
   return i;
 }
 
@@ -707,21 +707,6 @@ static void codechoice (CompileState *compst, TTree *p1, TTree *p2, int opt,
 
 
 /* labeled failure begin */
-static void codelabchoice (CompileState *compst, TTree *p1, TTree *p2, int opt,
-                        const Charset *fl, const byte *cs) {
-        int emptyp2 = (p2->tag == TTrue);
-                int pcommit;
-    int test = NOINST;
-                int pchoice = addoffsetinst(compst, ILabChoice);
-                addcharset(compst, cs);
-    codegen(compst, p1, emptyp2, test, fullset);
-    pcommit = addoffsetinst(compst, ICommit);
-    jumptohere(compst, pchoice);
-    jumptohere(compst, test);
-    codegen(compst, p2, opt, NOINST, fl);
-    jumptohere(compst, pcommit);
-}
-
 static void coderecovery (CompileState *compst, TTree *p1, TTree *p2, int opt,
                         const Charset *fl, const byte *cs) {
         int emptyp2 = (p2->tag == TTrue);
@@ -734,6 +719,7 @@ static void coderecovery (CompileState *compst, TTree *p1, TTree *p2, int opt,
     jumptohere(compst, precovery);
     jumptohere(compst, test);
     codegen(compst, p2, opt, NOINST, fl);
+    addinstruction(compst, IRet, 0);
     jumptohere(compst, pcommit);
 }
 /* labeled failure end */
@@ -969,10 +955,6 @@ static void codegen (CompileState *compst, TTree *tree, int opt, int tt,
       addinstruction(compst, IThrow, (byte) tree->u.label);
                         break;
                 }
-                case TLabChoice: { /* labeled failure */
-                        codelabchoice(compst, sib1(tree), sib2(tree), opt, fl, treelabelset(tree)); 
-                        break;
-                }
                 case TRecov: { /* labeled failure */
                         coderecovery(compst, sib1(tree), sib2(tree), opt, fl, treelabelset(tree)); 
                         break;
@@ -999,7 +981,7 @@ static void peephole (CompileState *compst) {
     switch (code[i].i.code) {
       case IChoice: case ICall: case ICommit: case IPartialCommit:
       case IBackCommit: case ITestChar: case ITestSet:
-      case ILabChoice: case IRecov: /* labeled failure */
+      case IRecov: /* labeled failure */
       case ITestAny: {  /* instructions with labels */
         jumptothere(compst, i, finallabel(code, i));  /* optimize label */
         break;
diff --git a/lpprint.c b/lpprint.c
index 122d2e5..8c488ea 100644
--- a/lpprint.c
+++ b/lpprint.c
@@ -61,7 +61,7 @@ void printinst (const Instruction *op, const Instruction *p) {
     "choice", "jmp", "call", "open_call",
     "commit", "partial_commit", "back_commit", "failtwice", "fail", "giveup",
      "fullcapture", "opencapture", "closecapture", "closeruntime",
-    "throw", "labeled_choice", "recovery" /* labeled failure */
+    "throw", "recovery" /* labeled failure */
   };
   printf("%02ld: %s ", (long)(p - op), names[p->i.code]);
   switch ((Opcode)p->i.code) {
@@ -112,7 +112,7 @@ void printinst (const Instruction *op, const Instruction *p) {
       printf("%d", p->i.aux);
       break;
     }
-                case ILabChoice: case IRecov: { /* labeled failure */
+                case IRecov: { /* labeled failure */
       printjmp(op, p);
       printcharset((p+2)->buff);
       break;
@@ -223,7 +223,7 @@ void printtree (TTree *tree, int ident) {
     default: {
       int sibs = numsiblings[tree->tag];
       printf("\n");
-      if (tree->tag == TLabChoice || tree->tag == TRecov) { /* labeled failure */
+      if (tree->tag == TRecov) { /* labeled failure */
         printcharset(treelabelset(tree));
         printf("\n");
                         }
diff --git a/lptree.c b/lptree.c
index 2044a5c..e15198e 100644
--- a/lptree.c
+++ b/lptree.c
@@ -28,7 +28,7 @@ const byte numsiblings[] = {
   0, 0, 2, 1,  /* call, opencall, rule, grammar */
   1,  /* behind */
   1, 1,  /* capture, runtime capture */
-  0, 2, 2  /* labeled failure throw, labeled choice, recovery */
+  0, 2  /* labeled failure throw, recovery */
 };
 
 
@@ -723,37 +723,25 @@ static int lp_behind (lua_State *L) {
 */
 static int lp_throw (lua_State *L) {
         int label = luaL_checkinteger(L, -1);
-        luaL_argcheck(L, label >= 0 && label < MAXLABELS, -1, "the number of a label must be between 0 and 255");
+        luaL_argcheck(L, label >= 1 && label < MAXLABELS, -1, "the number of a label must be between 1 and 255");
         newthrowleaf(L, label);
         return 1;
 }
 
 /*
-** labeled choice function
+** labeled recovery function
 */
-static int lp_labchoice (lua_State *L) {
-        int n = lua_gettop(L);
-        TTree *tree = newrootlab2sib(L, TLabChoice);
-        int i;
-        for (i = 3; i <= n; i++) {
-                int d = luaL_checkinteger(L, i);
-                luaL_argcheck(L, d >= 0 && d < MAXLABELS, i, "the number of a label must be between 0 and 255");
-    setlabel(treelabelset(tree), (byte)d);
-        }
-  return 1;
-}
-
-
 static int lp_recovery (lua_State *L) {
         int n = lua_gettop(L);
         TTree *tree = newrootlab2sib(L, TRecov);
+  luaL_argcheck(L, n >= 3, 3, "non-nil value expected");
   if (n == 2) {  /* catches fail as default */
-                setlabel(treelabelset(tree), LFAIL);
+                /*setlabel(treelabelset(tree), LFAIL);  recovery does not catch regular fail */
   } else {
                 int i;
                 for (i = 3; i <= n; i++) {
                         int d = luaL_checkinteger(L, i);
-                        luaL_argcheck(L, d >= 0 && d < MAXLABELS, i, "the number of a label must be between 0 and 255");
+                        luaL_argcheck(L, d >= 1 && d < MAXLABELS, i, "the number of a label must be between 1 and 255");
         setlabel(treelabelset(tree), (byte)d);
                 }
         }
@@ -1089,7 +1077,7 @@ static int verifyrule (lua_State *L, TTree *tree, int *passed, int npassed,
         return nb;
       /* else return verifyrule(L, sib2(tree), passed, npassed, nb); */
       tree = sib2(tree); goto tailcall;
-    case TChoice: case TLabChoice: case TRecov: /* must check both children */  /* labeled failure */
+    case TChoice:  case TRecov: /* must check both children */  /* labeled failure */
       nb = verifyrule(L, sib1(tree), passed, npassed, nb);
       /* return verifyrule(L, sib2(tree), passed, npassed, nb); */
       tree = sib2(tree); goto tailcall;
@@ -1342,7 +1330,6 @@ static struct luaL_Reg pattreg[] = {
   {"setmaxstack", lp_setmax},
   {"type", lp_type},
   {"T", lp_throw}, /* labeled failure throw */
-  {"Lc", lp_labchoice}, /* labeled failure choice */
   {"Rec", lp_recovery}, /* labeled failure choice */
   {NULL, NULL}
 };
@@ -1361,8 +1348,8 @@ static struct luaL_Reg metareg[] = {
 };
 
 
-int luaopen_lpeglabel (lua_State *L);  /* labeled failure */
-int luaopen_lpeglabel (lua_State *L) { /* labeled failure */
+int luaopen_lpeglabelrec (lua_State *L);  /* labeled failure */
+int luaopen_lpeglabelrec (lua_State *L) { /* labeled failure */
   luaL_newmetatable(L, PATTERN_T);
   lua_pushnumber(L, MAXBACK);  /* initialize maximum backtracking */
   lua_setfield(L, LUA_REGISTRYINDEX, MAXSTACKIDX);
diff --git a/lptree.h b/lptree.h
index cca346e..b75f323 100644
--- a/lptree.h
+++ b/lptree.h
@@ -25,7 +25,7 @@ typedef enum TTag {
   TBehind,  /* match behind */
   TCapture,  /* regular capture */
   TRunTime,  /* run-time capture */
-  TThrow, TLabChoice, TRecov     /* labeled failure */
+  TThrow, TRecov     /* labeled failure */
 } TTag;
 
 /* number of siblings for each tree */
diff --git a/lpvm.c b/lpvm.c
index 277acf7..a934478 100644
--- a/lpvm.c
+++ b/lpvm.c
@@ -162,15 +162,16 @@ const char *match (lua_State *L, const char *o, const char *s, const char *e,
   int captop = 0;  /* point to first empty slot in captures */
   int ndyncap = 0;  /* number of dynamic captures (in Lua stack) */
   const Instruction *p = op;  /* current instruction */
+  const Instruction *pk = NULL;  /* resume instruction */
         Labelset lsfail;
         setlabelfail(&lsfail);
   stack->p = &giveup; stack->s = s; stack->ls = &lsfail; stack->caplevel = 0; stack++;  /* labeled failure */
   lua_pushlightuserdata(L, stackbase);
   for (;;) {
 #if defined(DEBUG)
+        printinst(op, p);
       printf("s: |%s| stck:%d, dyncaps:%d, caps:%d  ",
              s, stack - getstackbase(L, ptop), ndyncap, captop);
-      printinst(op, p);
       printcaplist(capture, capture + captop);
 #endif
     assert(stackidx(ptop) + ndyncap == lua_gettop(L) && ndyncap <= captop);
@@ -194,6 +195,7 @@ const char *match (lua_State *L, const char *o, const char *s, const char *e,
         if (s < e) { p++; s++; }
         else {
           *labelf = LFAIL; /* labeled failure */
+          pk = p + 1;
                                         *sfail = s;
           goto fail;
         }
@@ -208,6 +210,7 @@ const char *match (lua_State *L, const char *o, const char *s, const char *e,
         if ((byte)*s == p->i.aux && s < e) { p++; s++; }
         else {
           *labelf = LFAIL; /* labeled failure */
+          pk = p + 1;
                                         *sfail = s;
           goto fail;
         }
@@ -224,6 +227,7 @@ const char *match (lua_State *L, const char *o, const char *s, const char *e,
           { p += CHARSETINSTSIZE; s++; }
         else {
           *labelf = LFAIL; /* labeled failure */
+          pk = p + CHARSETINSTSIZE;
                                         *sfail = s;
           goto fail;
         }
@@ -240,6 +244,7 @@ const char *match (lua_State *L, const char *o, const char *s, const char *e,
         int n = p->i.aux;
         if (n > s - o) {
           *labelf = LFAIL; /* labeled failure */
+                                        pk = p + 1;
                                         *sfail = s;
           goto fail;
         }
@@ -269,17 +274,6 @@ const char *match (lua_State *L, const char *o, const char *s, const char *e,
         p += 2;
         continue;
       }
-      case ILabChoice: { /* labeled failure */
-        if (stack == stacklimit)
-          stack = doublestack(L, &stacklimit, ptop);
-        stack->p = p + getoffset(p);
-        stack->s = s;
-        stack->ls = (const Labelset *) ((p + 2)->buff);
-        stack->caplevel = captop;
-        stack++;
-        p += (CHARSETINSTSIZE - 1) + 2;
-        continue;
-      }
                         case IRecov: { /* labeled failure */
         if (stack == stacklimit)
           stack = doublestack(L, &stacklimit, ptop);
@@ -291,7 +285,6 @@ const char *match (lua_State *L, const char *o, const char *s, const char *e,
         p += (CHARSETINSTSIZE - 1) + 2;
         continue;
       }
-
       case ICall: {
         if (stack == stacklimit)
           stack = doublestack(L, &stacklimit, ptop);
@@ -304,7 +297,7 @@ const char *match (lua_State *L, const char *o, const char *s, const char *e,
       }
       case ICommit: {
         assert(stack > getstackbase(L, ptop) && (stack - 1)->ls != NULL); /* labeled failure */
-        /* assert((stack - 1)->s != NULL); labeled failure: IRecov does not push s onto the stack */
+        /*assert((stack - 1)->s != NULL); labeled failure: IRecov does not push s onto the stack */
         stack--;
         p += getoffset(p);
         continue;
@@ -325,6 +318,7 @@ const char *match (lua_State *L, const char *o, const char *s, const char *e,
       }
       case IThrow: { /* labeled failure */
         *labelf = p->i.aux;
+        pk = p + 1;
                                 *sfail = s;
         goto fail;
       }
@@ -334,20 +328,31 @@ const char *match (lua_State *L, const char *o, const char *s, const char *e,
         /* go through */
       case IFail:
       *labelf = LFAIL; /* labeled failure */
+      pk = NULL;
                         *sfail = s;
       fail: { /* pattern failed: try to backtrack */
         const Labelset *auxlab = NULL;
+                                Stack *pstack = stack;
         do {  /* remove pending calls */
-          assert(stack > getstackbase(L, ptop));
-          auxlab = (--stack)->ls;
-        } while (auxlab == NULL || (stack->p != &giveup && !testlabel(stack->ls->cs, *labelf)));
-        if (stack->p == &giveup || stack->s != NULL) { /* labeled failure */
+          assert(pstack > getstackbase(L, ptop));
+          auxlab = (--pstack)->ls;
+        } while (auxlab == NULL || !(pstack->p == &giveup || testlabel(pstack->ls->cs, *labelf)));
+        if (pstack->s != NULL) { /* labeled failure: giveup or backtrack frame */
+                                        stack = pstack;
                                         s = stack->s;
+                if (ndyncap > 0)  /* is there matchtime captures? */
+                        ndyncap -= removedyncap(L, capture, stack->caplevel, captop);
+                captop = stack->caplevel;
+                                } else { /* labeled failure: recovery frame */
+                                        if (stack == stacklimit)
+                stack = doublestack(L, &stacklimit, ptop);
+                                        stack->s = NULL;
+                stack->p = pk;  /* save return address */
+                stack->ls = NULL;
+                stack->caplevel = captop; /* TODO: really necessary?? */
+                                        stack++;
                                 }
-        if (ndyncap > 0)  /* is there matchtime captures? */
-          ndyncap -= removedyncap(L, capture, stack->caplevel, captop);
-        captop = stack->caplevel;
-        p = stack->p;
+        p = pstack->p;
         continue;
       }
       case ICloseRunTime: {
@@ -361,7 +366,8 @@ const char *match (lua_State *L, const char *o, const char *s, const char *e,
         res = resdyncaptures(L, fr, s - o, e - o);  /* get result */
         if (res == -1) { /* fail? */
                 *labelf = LFAIL;  /* labeled failure */
-                                        *sfail = (const char *) s; /* TODO: ??? */
+                                        *sfail = (const char *) s; 
+                                        pk = NULL;
           goto fail;
         }
         s = o + res;  /* else update current position */
diff --git a/lpvm.h b/lpvm.h
index 3c27027..bcfc22f 100644
--- a/lpvm.h
+++ b/lpvm.h
@@ -35,7 +35,6 @@ typedef enum Opcode {
   ICloseCapture,
   ICloseRunTime,
   IThrow,   /* "fails" with a specific label labeled failure */
-  ILabChoice,   /* labeled choice */
   IRecov    /* stack a recovery; next fail with label 'f' will jump to 'offset'  */
 } Opcode;
 
diff --git a/makefile b/makefile
index 5728b38..414651e 100644
--- a/makefile
+++ b/makefile
@@ -1,4 +1,4 @@
-LIBNAME = lpeglabel
+LIBNAME = lpeglabelrec
 LUADIR = ../lua/
 
 COPT = -O2
@@ -29,24 +29,24 @@ FILES = lpvm.o lpcap.o lptree.o lpcode.o lpprint.o
 
 # For Linux
 linux:
-        make lpeglabel.so "DLLFLAGS = -shared -fPIC"
+        make lpeglabelrec.so "DLLFLAGS = -shared -fPIC"
 
 # For Mac OS
 macosx:
-        make lpeglabel.so "DLLFLAGS = -bundle -undefined dynamic_lookup"
+        make lpeglabelrec.so "DLLFLAGS = -bundle -undefined dynamic_lookup"
 
-lpeglabel.so: $(FILES)
-        env $(CC) $(DLLFLAGS) $(FILES) -o lpeglabel.so
+lpeglabelrec.so: $(FILES)
+        env $(CC) $(DLLFLAGS) $(FILES) -o lpeglabelrec.so
 
 $(FILES): makefile
 
-test: test.lua testlabel.lua testerrors.lua relabel.lua lpeglabel.so
+test: test.lua testlabel.lua testerrors.lua relabel.lua lpeglabelrec.so
         lua test.lua
         lua testlabel.lua
         lua testerrors.lua
 
 clean:
-        rm -f $(FILES) lpeglabel.so
+        rm -f $(FILES) lpeglabelrec.so
 
 
 lpcap.o: lpcap.c lpcap.h lptypes.h
diff --git a/relabel.lua b/relabelrec.lua
index b541dec..16ca7f0 100644
--- a/relabel.lua
+++ b/relabelrec.lua
@@ -6,7 +6,7 @@ local pcall = pcall
 local setmetatable = setmetatable
 local unpack, tinsert, concat = table.unpack or unpack, table.insert, table.concat
 local rep = string.rep
-local m = require"lpeglabel"
+local m = require"lpeglabelrec"
 
 -- 'm' will be used to parse expressions, and 'mm' will be used to
 -- create expressions; that is, 're' runs on 'm', creating patterns
@@ -216,14 +216,14 @@ local function NT (n, b)
   end
 end
 
-local function labchoice (...)
+local function choicerec (...)
   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])
+    p = t[i] and mm.Rec(p, t[i+1], unpack(t[i])) or mt.__add(p, t[i+1])
     i = i + 2
   end
 
@@ -232,10 +232,10 @@ end
 
 local exp = m.P{ "Exp",
   Exp = S * ( m.V"Grammar"
-            + (m.V"Seq" * (S * "/" * (m.Ct(m.V"Labels") + m.Cc(nil))
+            + (m.V"Seq" * (S * (("//" * m.Ct(m.V"Labels")) + ("/" * m.Cc(nil)))
                                    * expect(S * m.V"Seq", "ExpPatt1")
                             )^0
-              ) / labchoice);
+              ) / choicerec);
   Labels = m.P"{" * expect(S * m.V"Label", "ExpLab1")
            * (S * "," * expect(S * m.V"Label", "ExpLab2"))^0
            * expect(S * "}", "MisClose7");
diff --git a/test.lua b/test.lua
index d5922ac..18ab20f 100755
--- a/test.lua
+++ b/test.lua
@@ -4,7 +4,7 @@
 
 -- require"strict"    -- just to be pedantic
 
-local m = require"lpeglabel"
+local m = require"lpeglabelrec"
 
 
 -- for general use
@@ -1110,7 +1110,7 @@ checkeq(t, {'a', 'aa', 20, 'a', 'aaa', 'aaa'})
 -- Tests for 're' module
 -------------------------------------------------------------------
 
-local re = require "relabel"
+local re = require "relabelrec"
 
 local match, compile = re.match, re.compile
 
diff --git a/testlabel.lua b/testlabel.lua
index db16354..d9bac64 100644
--- a/testlabel.lua
+++ b/testlabel.lua
@@ -1,4 +1,4 @@
-local m = require 'lpeglabel'
+local m = require 'lpeglabelrec'
 
 local p, r, l, s, serror
 
@@ -11,6 +11,15 @@ local function checkeqlab (x, ...)
   end
 end
 
+local function checkeq (x, y, p)
+if p then print(x,y) end
+  if type(x) ~= "table" then assert(x == y)
+  else
+    for k,v in pairs(x) do checkeq(v, y[k], p) end
+    for k,v in pairs(y) do checkeq(v, x[k], p) end
+  end
+end
+
 -- throws a label 
 p = m.T(1)
 s = "abc"
@@ -32,47 +41,97 @@ local g = m.P{
 r, l, serror = g:match(s)
 assert(r == nil and l == 1 and serror == "abc")
 
--- throws a label that is not caught by labeled choice
-p = m.Lc(m.T(2), m.P"a", 1, 3)
+
+-- throws a label that is not caught by the recovery operator
+p = m.Rec(m.T(2), m.P"a", 1, 3)
 r, l, serror = p:match(s)
 assert(r == nil and l == 2 and serror == "abc")
 
--- modifies previous pattern
--- adds another labeled choice to catch label "2"
-p = m.Lc(p, m.P"a", 2)
+-- wraps the previous pattern with a recovery that catches label "2"
+p = m.Rec(p, m.P"a", 2)
 assert(p:match(s) == 2)
 
--- throws a label that is caught by labeled choice
-p = m.Lc(m.T(25), m.P"a", 25)
+-- throws a label that is caught by recovery 
+p = m.Rec(m.T(25), m.P"a", 25)
 assert(p:match(s) == 2)
 
 -- "fail" is label "0"
--- throws the "fail" label that is not caught by the labeled choice
+-- throws the "fail" label after the recovery
 s = "bola"
 r, l, serror = p:match("bola")
 assert(r == nil and l == 0 and serror == "bola")
 
--- labeled choice does not catch "fail" by default
-p = m.Lc(m.P"b", m.P"a", 1)
+-- Recovery does not catch "fail" by default
+p = m.Rec(m.P"b", m.P"a", 1)
 
 r, l, serror = p:match("abc") 
 assert(r == nil and l == 0 and serror == "abc")
 
 assert(p:match("bola") == 2)
 
--- labeled choice can catch "fail"
-p = m.Lc(m.P"b", m.P"a", 0)
+
+-- recovery operator catches "1" or "3"
+p = m.Rec((m.P"a" + m.T(1)) * m.T(3), (m.P"a" + m.P"b"), 1, 3)
+assert(p:match("aac") == 3)
+assert(p:match("abc") == 3)
+r, l, serror = p:match("acc")
+assert(r == nil and l == 0 and serror == "cc")
+
+--throws 1, recovery pattern matches 'b', throw 3, and rec pat mathces 'a'
+assert(p:match("bac") == 3)
+
+r, l, serror = p:match("cab")
+assert(r == nil and l == 0 and serror == "cab")
+
+
+-- associativity
+-- (p1 / %1) //{1} (p2 / %2) //{2} p3
+-- left-associativity
+-- ("a" //{1}  "b") //{2} "c"
+p = m.Rec(m.Rec(m.P"a" + m.T(1), m.P"b" + m.T(2), 1), m.P"c", 2)
 assert(p:match("abc") == 2)
-assert(p:match("bola") == 2)
+assert(p:match("bac") == 2)
+assert(p:match("cab") == 2)
+r, l, serror = p:match("dab")
+assert(r == nil and l == 0 and serror == "dab")
 
--- "fail" is label "0"
--- labeled choice catches "fail" or "3"
-p = m.Lc(m.P"a" * m.T(3), (m.P"a" + m.P"b"), 0, 3)
+
+-- righ-associativity
+-- "a" //{1}  ("b" //{2} "c")
+p = m.Rec(m.P"a" + m.T(1), m.Rec(m.P"b" + m.T(2), m.P"c", 2), 1)
 assert(p:match("abc") == 2)
 assert(p:match("bac") == 2)
+assert(p:match("cab") == 2)
+r, l, serror = p:match("dab")
+assert(r == nil and l == 0 and serror == "dab")
+
+
+-- associativity -> in this case the error thrown by p1 is only
+--                  recovered when we have a left-associative operator
+-- (p1 / %2) //{1} (p2 / %2) //{2} p3
+-- left-associativity
+-- ("a" //{1}  "b") //{2} "c"
+p = m.Rec(m.Rec(m.P"a" + m.T(2), m.P"b" + m.T(2), 1), m.P"c", 2)
+assert(p:match("abc") == 2)
+r, l, serror = p:match("bac")
+assert(r == nil and l == 0 and serror == "bac")
+assert(p:match("cab") == 2)
+r, l, serror = p:match("dab")
+assert(r == nil and l == 0 and serror == "dab")
 
+
+-- righ-associativity
+-- "a" //{1}  ("b" //{2} "c")
+p = m.Rec(m.P"a" + m.T(2), m.Rec(m.P"b" + m.T(2), m.P"c", 2), 1)
+assert(p:match("abc") == 2)
+r, l, serror = p:match("bac")
+assert(r == nil and l == 2 and serror == "bac")
 r, l, serror = p:match("cab")
-assert(r == nil and l == 0 and serror == "cab")
+assert(r == nil and l == 2 and serror == "cab")
+r, l, serror = p:match("dab")
+assert(r == nil and l == 2 and serror == "dab")
+
+
 
 -- tests related to predicates
 p = #m.T(1) + m.P"a"
@@ -83,74 +142,75 @@ p = ##m.T(1) + m.P"a"
 r, l, serror = p:match("abc")
 assert(r == nil and l == 1 and serror == "abc")
 
-p = #m.T(0) * m.P"a"
-assert(p:match("abc") == fail)
-
-p = #m.T(0) + m.P"a"
-assert(p:match("abc") == 2)
-
 p = -m.T(1) * m.P"a"
 r, l, serror = p:match("abc")
 assert(r == nil and l == 1 and serror == "abc")
 
+p = -m.T(1) * m.P"a"
+r, l, serror = p:match("bbc")
+assert(r == nil and l == 1 and serror == "bbc")
+
 p = -(-m.T(1)) * m.P"a"
 r, l, serror = p:match("abc")
 assert(r == nil and l == 1 and serror == "abc")
 
-p = -m.T(0) * m.P"a"
-assert(p:match("abc") == 2)
+p = m.Rec(-m.T(22), m.P"a", 22)
+r, l, serror = p:match("abc")
+assert(r == nil and l == 0 and serror == "bc")
 
-p = -m.T(0) + m.P"a"
-assert(p:match("abc") == 1)
+assert(p:match("bbc") == 1)
 
-p = -(-m.T(0)) + m.P"a"
-assert(p:match("abc") == 2)
+p = m.Rec(#m.T(22), m.P"a", 22)
+assert(p:match("abc") == 1)
 
-p = m.Lc(-m.T(22), m.P"a", 22)
-assert(p:match("abc") == 2)
+p = #m.Rec(m.T(22), m.P"a", 22)
+assert(p:match("abc") == 1)
 
-p = m.Lc(-m.T(0), m.P"a", 0)
+p = m.Rec(m.T(22), #m.P"a", 22)
 assert(p:match("abc") == 1)
 
-p = m.Lc(#m.T(22), m.P"a", 22)
-assert(p:match("abc") == 2)
+p = m.Rec(#m.T(22), m.P"a", 22)
+r, l, serror = p:match("bbc")
+assert(r == nil and l == 0 and serror == "bbc")
+
+p = m.Rec(#m.P("a") * m.T(22), m.T(15), 22)
+r, l, serror = p:match("abc")
+assert(r == nil and l == 15 and serror == "abc")
+
+p = m.Rec(#(m.P("a") * m.T(22)), m.T(15), 22)
+r, l, serror = p:match("abc")
+assert(r == nil and l == 15 and serror == "bc")
+
 
-p = m.Lc(#m.T(0), m.P"a", 0)
-assert(p:match("abc") == 2)
 
 -- tests related to repetition
 p = m.T(1)^0
 r, l, serror = p:match("ab")
 assert(r == nil and l == 1 and serror == "ab")
 
-p = m.T(0)^0
-assert(p:match("ab") == 1)
-
 p = (m.P"a" + m.T(1))^0
 r, l, serror = p:match("aa")
 assert(r == nil and l == 1 and serror == "")
 
-p = (m.P"a" + m.T(0))^0
-assert(p:match("aa") == 3)
 
 -- Bug reported by Matthew Allen
 -- some optmizations performed by LPeg should not be
 -- applied in case of labeled choices
-p = m.Lc(m.P"A", m.P(true), 1) + m.P("B")
+p = m.Rec(m.P"A", m.P(true), 1) + m.P("B")
 assert(p:match("B") == 2)
 
-p = m.Lc(m.P"A", m.P(false), 1) + m.P("B")
+p = m.Rec(m.P"A", m.P(false), 1) + m.P("B")
 assert(p:match("B") == 2)
 
 
 --[[
-S -> A /{1} 'a'
+S -> A //{1} 'a'
 A -> B
 B -> %1
 ]]
 g = m.P{
         "S",
-        S = m.Lc(m.V"A", m.P"a", 1),
+        S = m.Rec(m.V"A", m.P"a", 1),
         A = m.V"B",
         B = m.T(1),
 }
@@ -176,64 +236,96 @@ r, l, serror = g:match("a;a")
 assert(r == nil and l == 1 and serror == "")
 
 
--- %1 /{1,3} %2 /{2} 'a'
-p = m.Lc(m.Lc(m.T(1), m.T(2), 1, 3), m.P"a", 2)
+-- %1 //{1,3} %2 //{2} 'a'
+p = m.Rec(m.Rec(m.T(1), m.T(2), 1, 3), m.P"a", 2)
 assert(p:match("abc") == 2)
 
 r, l, serror = p:match("")
 assert(r == nil and l == 0 and serror == "")
 
-p = m.Lc(m.T(1), m.Lc(m.T(2), m.P"a", 2), 1, 3)
+p = m.Rec(m.T(1), m.Rec(m.T(2), m.P"a", 2), 1, 3)
 assert(p:match("abc") == 2)
 
 r, l, serror = p:match("")
 assert(r == nil and l == 0 and serror == "")
 
+
+-- Infinte Loop TODO: check the semantics
+-- %1 //{1} %1 
+p = m.Rec(m.T(1), m.T(1), 1)
+--r, l, serror = p:match("ab")
+--assert(r == nil and l == 1 and serror == "ab")
+
+-- %1 //{1} 'a' (!. / %1) 
+p = m.Rec(m.T(1), m.P"a" * (-m.P(1) + m.T(1)), 1)
+r, l, serror = p:match("ab")
+assert(r == nil and l == 0 and serror == "b")
+
+r, l, serror = p:match("cd")
+assert(r == nil and l == 0 and serror == "cd")
+
+-- %1 //{1} . (!. / %1) 
+p = m.Rec(m.T(1), m.P(1) * (-m.P(1) + m.T(1)), 1)
+assert(p:match("abc") == 4)
+
+
 -- testing the limit of labels
-p = m.T(0)
-s = "abc"
-r, l, serror = p:match(s) 
-assert(r == nil and l == 0 and serror == "abc")
+-- can only throw labels between 1 and 255
+local r = pcall(m.Rec, m.P"b", m.P"a", 0)
+assert(r == false)
 
-p = m.T(255)
-s = "abc"
-r, l, serror = p:match(s) 
-assert(r == nil and l == 255 and serror == "abc")
+local r = pcall(m.Rec, m.P"b", m.P"a", 256)
+assert(r == false)
 
-local r = pcall(m.T, -1)
+local r = pcall(m.Rec, m.P"b", m.P"a", -1)
+assert(r == false)
+
+local r = pcall(m.T, 0)
 assert(r == false)
 
 local r = pcall(m.T, 256)
 assert(r == false)
 
+local r = pcall(m.T, -1)
+assert(r == false)
+
+
+local r = m.Rec(m.P"b", m.P"a", 255)
+assert(p:match("a") == 2)
+
+p = m.T(255)
+s = "abc"
+r, l, serror = p:match(s) 
+assert(r == nil and l == 255 and serror == "abc")
+
+
 
 print("+")
 
 --[[ grammar based on Figure 8 of paper submitted to SCP
-S  -> S0 /{1} ID /{2} ID '=' Exp /{3} 'unsigned'* 'int' ID /{4} 'unsigned'* ID ID / %error
-S0 -> ID S1 / 'unsigned' S2 / 'int' %3
-S1 -> '=' %2  /  !. %1  /  ID %4
-S2 -> 'unsigned' S2  /  ID %4  /  'int' %3 
+S  -> S0 //{1} ID //{2} ID '=' Exp //{3} 'unsigned'* 'int' ID //{4} 'unsigned'* ID ID / %error
+S0 -> S1 / S2 / &'int' %3
+S1 -> &(ID '=') %2  /  &(ID !.) %1  /  &ID %4
+S2 -> &('unsigned'+ ID) %4  /  & ('unsigned'+ 'int') %3 
 ]]
-
 local sp = m.S" \t\n"^0
 local eq = sp * m.P"="
 
 g = m.P{
         "S",
-        S = m.Lc(
-         m.Lc(
-            m.Lc(
-               m.Lc(m.V"S0", m.V"ID" * (m.P(1) + ""), 1),
+        S = m.Rec(
+         m.Rec(
+            m.Rec(
+               m.Rec(m.V"S0", m.V"ID", 1),
                m.V"ID" * eq * m.V"Exp", 2
                ),
             m.V"U"^0 * m.V"I" * m.V"ID", 3
             ),
          m.V"U"^0 * m.V"ID" * m.V"ID", 4) 
        + m.T(5), -- error
-        S0 = m.V"ID" * m.V"S1"  +  m.V"U" * m.V"S2"  +  m.V"I" * m.T(3),
-        S1 = eq * m.T(2) + sp * -m.P(1) * m.T(1) + m.V"ID" * m.T(4),
-        S2 = m.V"U" * m.V"S2"  +   m.V"ID" * m.T(4)  +   m.V"I" * m.T(3),
+        S0 = m.V"S1"  +  m.V"S2"  +  #m.V"I" * m.T(3),
+        S1 = #(m.V"ID" * eq) * m.T(2) + sp * #(m.V"ID" * -m.P(1)) * m.T(1) + #m.V"ID" * m.T(4),
+        S2 = #(m.V"U"^1 * m.V"ID") * m.T(4)  +  #(m.V"U"^1 * m.V"I") * m.T(3),
         ID = sp * m.P"a",
         U = sp * m.P"unsigned",
         I = sp * m.P"int",
@@ -270,53 +362,59 @@ assert(r == nil and l == 5 and serror == s)
 
 print("+")
 
-local re = require 'relabel'
 
-g = re.compile[['a' /{4,9} [a-z]
+local re = require 'relabelrec'
+
+g = re.compile[['a' //{4,9} [a-z]
 ]]
 assert(g:match("a") == 2)
 r, l, serror = g:match("b")
 assert(r == nil and l == 0 and serror == "b")
 
-g = re.compile[['a' /{4,9} [a-f] /{5, 7} [a-z]
+g = re.compile[['a' //{4,9} [a-f] //{5, 7} [a-z]
 ]]
 assert(g:match("a") == 2)
 r, l, serror = g:match("b")
 assert(r == nil and l == 0 and serror == "b")
 
-g = re.compile[[%{1} /{4,9} [a-z]
+g = re.compile[[%{1} //{4,9} [a-z]
 ]]
 r, l, serror = g:match("a")
 assert(r == nil and l == 1 and serror == "a")
 
 
-g = re.compile[[%{1} /{4,1} [a-f]
+g = re.compile[[%{1} //{4,1} [a-f]
 ]]
 assert(g:match("a") == 2)
 r, l, serror = g:match("h")
 assert(r == nil and l == 0 and serror == "h")
 
-g = re.compile[[[a-f]%{9} /{4,9} [a-c]%{7} /{5, 7} [a-z] ]]
-assert(g:match("a") == 2)
-assert(g:match("c") == 2)
-r, l, serror = g:match("d")
+g = re.compile[[[a-f]%{9} //{4,9} [a-c]%{7} //{5, 7} [a-z] ]]
+r, l, serror = g:match("a")
+assert(r == nil and l == 0 and serror == "")
+r, l, serror = g:match("aa")
+assert(r == nil and l == 0 and serror == "")
+assert(g:match("aaa") == 4)
+
+r, l, serror = g:match("ad")
 assert(r == nil and l == 0 and serror == "d")
+
 r, l, serror = g:match("g")
 assert(r == nil and l == 0 and serror == "g")
 
+
 --[[ grammar based on Figure 8 of paper submitted to SCP
-S  -> S0 /{1} ID /{2} ID '=' Exp /{3} 'unsigned'* 'int' ID /{4} 'unsigned'* ID ID / %error
-S0 -> ID S1 / 'unsigned' S2 / 'int' %3
-S1 -> '=' %2  /  !. %1  /  ID %4
-S2 -> 'unsigned' S2  /  ID %4  /  'int' %3 
+S  -> S0 //{1} ID //{2} ID '=' Exp //{3} 'unsigned'* 'int' ID //{4} 'unsigned'* ID ID / %error
+S0 -> S1 / S2 / &'int' %3
+S1 -> &(ID '=') %2  /  &(ID !.) %1  /  &ID %4
+S2 -> &('unsigned'+ ID) %4  /  & ('unsigned'+ 'int') %3 
 ]]
 
-
 g = re.compile([[
-        S <- S0 /{1} ID /{2} ID %s* '=' Exp /{3} U* Int ID /{4} U ID ID /{0} %{5}
-  S0 <- ID S1 / U S2 / Int %{3}
-  S1 <- %s* '=' %{2} / !. %{1} / ID %{4}
-  S2 <- U S2 / ID %{4} / Int %{3}
+        S <- S0 //{1} ID //{2} ID %s* '=' Exp //{3} U* Int ID //{4} U ID ID / %{5}
+  S0 <- S1 / S2 / &Int %{3}
+  S1 <- &(ID %s* '=') %{2} / &(ID !.) %{1} / &ID %{4}
+  S2 <- &(U+ ID) %{4} / &(U+ Int) %{3}
   ID <- %s* 'a' 
   U <- %s* 'unsigned'
   Int <- %s* 'int'
@@ -346,6 +444,8 @@ s = "unsigned int"
 r, l, serror = g:match(s)
 assert(r == nil and l == 5 and serror == s)
 
+
+
 local terror = { ['cmdSeq'] = "Missing ';' in CmdSeq",
                  ['ifExp'] = "Error in expresion of 'if'",
                  ['ifThen'] = "Error matching 'then' keyword",
@@ -367,12 +467,12 @@ local terror = { ['cmdSeq'] = "Missing ';' in CmdSeq",
                  ['undefined'] = "Undefined Error"}
 
 g = re.compile([[
-  Tiny       <- CmdSeq /{1} '' -> cmdSeq /{2} '' -> ifExp /{3} '' -> ifThen /{4} '' -> ifThenCmdSeq
-                       /{5} '' -> ifElseCmdSeq  /{6}  '' -> ifEnd  /{7} '' -> repeatCmdSeq
-                       /{8} '' -> repeatUntil  /{9} '' -> repeatExp  /{10} '' -> assignOp
-                       /{11} '' -> assignExp  /{12} '' -> readName  /{13}  '' -> writeExp
-                       /{14} '' -> simpleExp  /{15} '' -> term  /{16} '' -> factor
-                       /{17} '' -> openParExp  /{18} '' -> closePar /{0} '' -> undefined
+  Tiny       <- CmdSeq //{1} '' -> cmdSeq //{2} '' -> ifExp //{3} '' -> ifThen //{4} '' -> ifThenCmdSeq
+                       //{5} '' -> ifElseCmdSeq  //{6}  '' -> ifEnd  //{7} '' -> repeatCmdSeq
+                       //{8} '' -> repeatUntil  //{9} '' -> repeatExp  //{10} '' -> assignOp
+                       //{11} '' -> assignExp  //{12} '' -> readName  //{13}  '' -> writeExp
+                       //{14} '' -> simpleExp  //{15} '' -> term  //{16} '' -> factor
+                       //{17} '' -> openParExp  //{18} '' -> closePar / '' -> undefined
   CmdSeq     <- (Cmd (SEMICOLON / %{1})) (Cmd (SEMICOLON / %{1}))*
   Cmd        <- IfCmd / RepeatCmd / ReadCmd / WriteCmd  / AssignCmd 
   IfCmd      <- IF  (Exp / %{2})  (THEN / %{3})  (CmdSeq / %{4})  (ELSE (CmdSeq / %{5}) / '') (END / %{6})
@@ -550,18 +650,12 @@ assert(g:match(s) == terror['undefined'])
 print("+")
 
 
--- test recovery operator
-p = m.Rec("a", "b") 
-assert(p:match("a") == 2)
-assert(p:match("b") == 2)
-checkeqlab({nil, 0, "c"}, p:match("c"))
-
 p = m.Rec("a", "b", 3) 
 assert(p:match("a") == 2)
 checkeqlab({nil, 0, "b"}, p:match("b"))
 checkeqlab({nil, 0, "c"}, p:match("c"))
 
-p = m.Rec(m.T(3), "b") 
+p = m.Rec(m.T(3), "b", 1) 
 checkeqlab({nil, 3, "a"}, p:match("a"))
 checkeqlab({nil, 3, "b"}, p:match("b"))
 
@@ -570,27 +664,28 @@ checkeqlab({nil, 0, "a"}, p:match("a"))
 assert(p:match("b") == 2)
 
 --[[
-S -> (A //{fail} (!c .)*) C
-A -> a*b 
+S -> (A //{128} (!c .)*) C
+A -> a*b / %128
 C -> c+
 ]]
 g = m.P{
         "S",
-        S = m.Rec(m.V"A", (-m.P"c" * m.P(1))^0) * m.V"C",
-        A = m.P"a"^0 * "b",
+        S = m.Rec(m.V"A", (-m.P"c" * m.P(1))^0, 128) * m.V"C",
+        A = m.P"a"^0 * "b" + m.T(128),
         C = m.P"c"^1,
 }
 
 assert(g:match("abc") == 4)
 assert(g:match("aabc") == 5)
-assert(g:match("aadc") == 5)
-assert(g:match("bc") == 3)
+assert(g:match("aadc") == 5)  
+assert(g:match("dc") == 3)
 checkeqlab({nil, 0, "bc"}, g:match("bbc"))
-assert(g:match("xxc") == 4)
+assert(g:match("xxc") == 4) 
 assert(g:match("c") == 2)
 checkeqlab({nil, 0, ""}, g:match("fail"))
 checkeqlab({nil, 0, ""}, g:match("aaxx"))
 
+
 --[[
 S -> (A //{99} (!c .)*) C
 A -> a+ (b / ^99) 
@@ -726,7 +821,169 @@ print(eval "(1+1-1*(2/2+)-():")
 --> syntax error: extra characters found after the expression (at index 
 
 
+print("+")
+
+local g = m.P{
+        "S",
+        S = V"End" + V'A' * V'S',
+        A = P'a' + T(1),
+        End = P"." * (-P(1) + T(2)),
+}
 
+assert(g:match("a.") == 3)
+assert(g:match("aa.") == 4)
+assert(g:match(".") == 2)
+checkeqlab({nil, 1, "ba."}, g:match("ba."))
+checkeqlab({nil, 1, "ba."}, g:match("aba."))
+checkeqlab({nil, 1, "cba."}, g:match("cba."))
+checkeqlab({nil, 2, "a"}, g:match("a.a"))
 
-print("OK")
 
+local g2 = m.P{
+        "S",
+        S = m.Rec(g, V"B", 1),
+        B = P'b'^1 + T(3)
+}
+
+assert(g2:match("a.") == 3)
+assert(g2:match("aa.") == 4)
+assert(g2:match(".") == 2)
+assert(g2:match("ba.") == 4)
+assert(g2:match("aba.") == 5)
+checkeqlab({nil, 3, "cba."}, g2:match("cba."))
+checkeqlab({nil, 2, "a"}, g2:match("a.a"))
+
+local g3 = m.P{
+        "S",
+        S = m.Rec(g2, V"C", 2, 3),
+        C = P'c'^1 + T(4)
+}
+
+assert(g3:match("a.") == 3)
+assert(g3:match("aa.") == 4)
+assert(g3:match(".") == 2)
+assert(g3:match("ba.") == 4)
+assert(g3:match("aba.") == 5)
+assert(g3:match("cba.") == 5)
+checkeqlab({nil, 4, "a"}, g3:match("a.a"))
+checkeqlab({nil, 4, "dc"}, g3:match("dc"))
+checkeqlab({nil, 4, "d"}, g3:match(".d"))
+
+
+-- testing more captures
+local g = re.compile[[
+        S <- ( %s* &. {A} )* 
+  A <- [0-9]+ / %{5}
+]]
+
+checkeq({"523", "624", "346", "888"} , {g:match("523 624  346\n888")}) 
+checkeq({nil, 5, "a 123"}, {g:match("44 a 123")})
+
+local g2 = m.Rec(g, ((-m.R("09") * m.P(1))^0) / "58", 5)
+
+checkeq({"523", "624", "346", "888"} , {g2:match("523 624  346\n888")}) 
+checkeq({"44", "a ", "58", "123"}, {g2:match("44 a 123")})
+
+
+local g = re.compile[[
+        S <- ( %s* &. A )* 
+  A <- {[0-9]+} / %{5}
+]]
+
+checkeq({"523", "624", "346", "888"} , {g:match("523 624  346\n888")}) 
+checkeq({nil, 5, "a 123"}, {g:match("44 a 123")})
+
+local g2 = m.Rec(g, ((-m.R("09") * m.P(1))^0) / "58", 5)
+
+checkeq({"523", "624", "346", "888"} , {g2:match("523 624  346\n888")}) 
+checkeq({"44", "58", "123"}, {g2:match("44 a 123")})
+
+
+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, recpatt)
+  local i = labelindex(labname)
+  function recorderror(input, pos)
+    table.insert(errors, {i, pos})
+    return true
+  end
+        if not recpatt then recpatt = P"" end
+  --return Rec(patt, Cmt("", recorderror) * recpatt)
+  return patt + 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"Operand")^0) / compute,
+Operand = expect(V"Term", "ExpTerm"),
+Term = num,
+}
+local rg = Rec(g, Cc(3), labelindex("ExpTerm"))
+                 
+local function eval(input)
+  local result, label, suffix = rg: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
+
+assert(eval("98-76*54/32") == 37.125)
+--> 37.125
+
+assert(eval("1+") == 4)
+--> syntax error: expected a term after the operator (at index 3)
+
+
+print("OK")