1 files changed, 241 insertions, 525 deletions

diff --git a/README.md b/README.md
index b8595ad..88b4fc3 100644
--- a/README.md
+++ b/README.md
@@ -17,7 +17,7 @@ patterns of LPeg.
 
 Besides that, LPegLabel also reports the farthest
 failure position in case of an ordinary failure
-(which is represented by label **0**).
+(which is represented by label **fail**).
 
 This document describes the new functions available
 in LpegLabel and presents some examples of usage.
@@ -27,13 +27,13 @@ between an ordinary failure and an error. Usually, an
 ordinary failure is produced when the matching of a
 character fails, and this failure is caught by ordered choice.
 An error (a non-ordinary failure), by its turn, is produced
-by the throw operator and may be caught by the recovery operator. 
+by the throw operator and may be caught by a recovery rule. 
 
 In LPegLabel, the result of an unsuccessful matching
 is a triple **nil, lab, errpos**, where **lab**
-is the label associated with the failure, and
-**errpos** is the input position being matched when
-**lab** was thrown. 
+is the label associated with the failure (a string or
+an integer), and **errpos** is the input position being
+matched when **lab** was thrown. 
 
 When **lab** is an ordinary failure and no error was thrown before,
 **errpos** is the farthest position where an ordinary failure occurred. 
@@ -47,31 +47,15 @@ Below there is a brief summary of the new functions provided by LpegLabel:
 <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 a label <code>l</code> to signal an error</td></tr>
-<tr><td><a href="#f-rec"><code>lpeglabel.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="#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="#re-t"><code>%{l}</code></a></td>
   <td>Syntax of <em>relabel</em> module. Equivalent to <code>lpeglabel.T(l)</code>
       </td></tr>
 <tr><td><a href="#re-pow"><code>p^l</code></a></td>
   <td>Syntax sugar available at <em>relabel</em> for <code>p / %{l}</code>
       </td></tr>
-<tr><td><a href="#re-rec"><code>p1 //{l1 [, l2, ..., ln} p2</code></a></td>
-  <td>Syntax of <em>relabel</em> module. Equivalent to <code>lpeglabel.Rec(p1, p2, l1, ..., ln)</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>
-      </td></tr>
 <tr><td><a href="#re-line"><code>relabel.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>
-  <td>Allows to specicify a table with mnemonic labels. 
-      </td></tr>
 </tbody></table>
 
 
@@ -80,60 +64,39 @@ Below there is a brief summary of the new functions provided by LpegLabel:
 
 #### <a name="f-t"></a><code>lpeglabel.T(l)</code>
 
-Returns a pattern that throws the label `l`.
-A label must be an integer between 1 and 255.
-
-This pattern always causes a failure, whose associated
-position will be used to set **errpos**, no matter
-whether this is the farthest failure position or not. 
-
-
-#### <a name="f-rec"></a><code>lpeglabel.Rec(p1, p2, l1, ..., ln)</code>
-
-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 failure position of `p1`.
-Otherwise, the result of the matching of `p1` is the pattern's result.
-
-
-#### <a name="f-lc"></a><code>lpeglabel.Lc(p1, p2, l1, ..., ln)</code>
-
-Returns a pattern equivalent to a *labeled ordered choice*.
-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.
+Returns a pattern that throws the label `l`, which
+can be an integer or a string.
 
-<!---
-The labeled ordered choice `lpeg.Lc(p1, p2, 0)` is equivalent to the
-regular ordered choice `p1 / p2`.
--->
+When a label is thrown, the current subject position 
+is used to set **errpos**, no matter whether it is the
+fartherst failure position or not.
 
-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.
+In case the PEG grammar has a rule `l`, after a label is thrown
+this rule will be used as a recovery rule, otherwise the whole
+matching fails.
+ 
+The recovery rule will try to match the input from the subject
+position where `l` was thrown. In case the matching of the recovery
+rule succeeds, the regular matching is resumed. Otherwise, the
+result of the recovery rule is the matching result.
+ 
+When we have a predicate such as `-p` or `#p` and a label `l` is thrown
+during the matching of `p`, this causes the failure of `p`, but does
+not propagate `l`, or calls its associated recovery rule.
 
 
 #### <a name="re-t"></a><code>%{l}</code>
 
 Syntax of *relabel* module. Equivalent to `lpeg.T(l)`.
 
+Label `l` must be a valid identifier name.
 
-#### <a name="re-rec"></a><code>p1 //{l1, ..., ln} p2</code>
-
-Syntax of *relabel* module. Equivalent to `lpeglabel.Rec(p1, p2, l1, ..., ln)`.
-
-The `//{}` operator is left-associative. 
-
+#### <a name="re-pow"></a><code>p^l</code>
 
-#### <a name="re-lc"></a><code>p1 /{l1, ..., ln} p2</code>
+Syntax of *relabel* module. The pattern `p^l` is equivalent
+to `p / lpeglabel.T(l)`.
 
-Syntax of *relabel* module. Equivalent to `lpeg.Lc(p1, p2, l1, ..., ln)`.
-
-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`.
+Label `l` must be a valid identifier name.
 
 
 #### <a name="re-line"></a><code>relabel.calcline (subject, i)</code>
@@ -141,12 +104,6 @@ module will not recognize a pattern as `p1 / p2 /{l1} p3`.
 Returns line and column information regarding position <i>i</i> of the subject.
 
 
-#### <a name="re-setl"></a><code>relabel.setlabels (tlabel)</code>
-
-Allows to specicify a table with labels. They keys of
-`tlabel` must be strings and the associated values must
-be integers between 1 and 255.
-
 
 ### Examples
 
@@ -159,9 +116,9 @@ in the *examples* directory.
 
 This example illustrates the new values returned
 by the *match* function in case of an unsuccessful
-matching. As no error is thrown, when the matching
-fails *errpos* represents the farthest suffix where
-an ordinary failure occurred.
+matching. As no error is thrown in this example,
+when the matching fails *errpos* represents the
+farthest suffix where an ordinary failure occurred.
 
 ```lua
 local m = require'lpeglabel'
@@ -172,124 +129,165 @@ function matchPrint(p, s)
 end
 
 local p = m.P"a"^0 * m.P"b" + m.P"c"
-matchPrint(p, "abc")  --> r: 3    lab: nil  errpos: nil
-matchPrint(p, "c")    --> r: 2    lab: nil  errpos: nil
-matchPrint(p, "aac")  --> r: nil        lab: 0    errpos: 3
-matchPrint(p, "xxc")  --> r: nil        lab: 0    errpos: 1
+matchPrint(p, "abc")  --> r: 3    lab: nil   errpos: nil
+matchPrint(p, "c")    --> r: 2    lab: nil   errpos: nil
+matchPrint(p, "aac")  --> r: nil        lab: fail  errpos: 3
+matchPrint(p, "xxc")  --> r: nil        lab: fail  errpos: 1
 ```
 
 
 #### Matching a list of identifiers separated by commas
 
 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.
-
-We use function `newError` to store error messages in a
-table and to return the index associated with each error message.
+a (possibly empty) list of identifiers separated by commas.
+A label is thrown when there is no identifier after a comma,
+or when the whole input is not matched.
 
 
 ```lua
 local m = require'lpeglabel'
 local re = require'relabel'
 
-local terror = {}
-
-local function newError(s)
-  table.insert(terror, s)
-  return #terror
-end
+local terror = {
+  ErrId =    "expecting an identifier",
+  ErrEnd = "expecting EOF",
+  fail = "undefined"
+}
 
-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" * ",",
-  Sp = m.S" \n\t"^0,
+  'S',
+  S = m.V'List' * (-m.P(1) + m.T'ErrEnd'),
+  List = m.V'Id' * (m.V'Comma' * (m.V'Id' + m.T'ErrId'))^0,
+  Id = m.V'Sp' * id,
+  Comma = m.V'Sp' * ',',
+  Sp = m.S' \n\t'^0,
 }
 
+
 function mymatch (g, s)
-  local r, e, sfail = g:match(s)
+  local r, e, pos = g:match(s)
   if not r then
-    local line, col = re.calcline(s, #s - #sfail)
+    local line, col = re.calcline(s, pos)
     local msg = "Error at line " .. line .. " (col " .. col .. "): "
-    return r, msg .. terror[e] .. " before '" .. sfail .. "'"
+    return r, msg .. terror[e] .. " before '" .. s:sub(pos) .. "'"
   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(g, "one,two"))
+print(mymatch(g, "one two"))
+print(mymatch(g, "one,\n two,\nthree,4"))
 ```
 
 In this example we could think about writing rule <em>List</em> as follows:
 ```lua
-List = ((m.V"Comma" + m.T(errComma)) * (m.V"Id" + m.T(errId)))^0,
+List = m.V'Id' * ((m.V'Comma' + m.T'ErrComma') * (m.V'Id' + m.T'ErrId'))^0,
 ```
 
-but when matching this expression against the end of input
+but when matching <code>m.V'Comma' + m.T'ErrComma'</code> 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.
 
+Below we rewrite the previous grammar to indicate an error when there is no
+comma after an identifer. Before tyring to match a comma, we check if
+we have reached the end of input:
+
+```lua
+local m = require'lpeglabel'
+local re = require'relabel'
+
+local terror = {
+  ErrId =    "expecting an identifier",
+  ErrComma = "expecting ','",
+  fail = "undefined"
+}
+
+local id = m.R'az'^1
+
+local g = m.P{
+  'S',
+  S = m.V'List',
+  List = m.V'Id' * (#m.P(1) * m.V'Comma' * (m.V'Id' + m.T'ErrId'))^0,
+  Id = m.V'Sp' * id,
+  Comma = m.V'Sp' * ',' + m.T'ErrComma',
+  Sp = m.S' \n\t'^0,
+}
+
+
+function mymatch (g, s)
+  local r, e, pos = g:match(s)
+  if not r then
+    local line, col = re.calcline(s, pos)
+    local msg = "Error at line " .. line .. " (col " .. col .. "): "
+    return r, msg .. terror[e] .. " before '" .. s:sub(pos) .. "'"
+  end
+  return r
+end
+  
+print(mymatch(g, "one,two"))
+print(mymatch(g, "one two"))
+print(mymatch(g, "one,\n two,\nthree,4"))
+print(mymatch(g, " 1,2"))
+
+```
 
 
 #### 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`:
+We can specify a recovery rule that should
+be matched when a label is thrown. After matching
+the recovery rule, and possibly recording the error,
+the parser will resume the <em>regular</em> matching.
+The recovery rule must have the same name (or number)
+of the label that was thrown. 
+
+
+For example, in the example below we expect to match rule *A*,
+but when a failure occur the label `Err` is thrown and then we
+will try to match rule *Err*:
 ```lua
 local m = require'lpeglabel'
 
 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))
+  'S',
+  S    =  m.V'A' * '.',
+  A    =  m.P't' * (m.P'est' + m.T'Err'),
+  Err  =  m.P'oast'
 }
 
 print(g:match("test."))   --> 6
 print(g:match("toast."))  --> 7
-print(g:match("oast."))   --> nil  0  oast.
-print(g:match("toward."))   --> nil  0  ward.
+print(g:match("oast."))   --> nil  fail  oast.
+print(g:match("toward.")) --> nil  fail  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 trying to match subject 'toast.', in rule *A* the first
+'t' is matched, then the matching of `m.P"est"` fails and label
+`Err` is thrown, with the associated inpux suffix 'oast.'. 
+The recovery rule *Err* successfully matches 'oast', so
+the regular matching continues, and 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>.
+the result of the matching is <b>nil,  fail, 1</b>.
 
-When matching 'toward.', label 42 is thrown after matching 't',
+When matching 'toward.', label `Err` 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>.
+recovery pattern fails, the result is <b>nil, fail, 3</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`.
+to use a recovery strategy, with the help of some auxiliary functions.
 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
+that consumes the input while it is not possible to match a given
 pattern `p`.   
 
 When the matching of an identifier fails, a defaul value ('NONE')
@@ -299,26 +297,11 @@ is provided.
 local m = require'lpeglabel'
 local re = require'relabel'
 
-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 terror = {
+  ErrId     =  "expecting an identifier",
+  ErrComma  =  "expecting ','",
+  ErrList   =  "expecting a list of identifiers",
+  fail      =  "undefined"
 }
 
 local subject, errors
@@ -340,14 +323,20 @@ function defaultValue ()
         return m.Cc"NONE" 
 end
 
-local grec = m.P{
+local id = m.R'az'^1
+
+local g = 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(), 
+  S         =  m.V"List" + (m.P(1) * m.T'ErrList'),
+  List      =  m.V'Id' * (#m.P(1) * m.V'Comma' * (m.V'Id' + m.T'ErrId'))^0,
+  Id        =  m.V'Sp' * m.C(id),
+  Comma     =  m.V'Sp' * ',' + m.T'ErrComma',
+  Sp        =  m.S' \n\t'^0,
+  ErrId     =  record'ErrId' * sync(m.P",") * defaultValue(), 
+  ErrComma  =  record'ErrComma' * sync(id),
+  ErrList   =  record'ErrList' * sync(m.P(-1)) * defaultValue()  
 }
 
-
 function mymatch (g, s)
         errors = {}
         subject = s     
@@ -371,387 +360,114 @@ function mymatch (g, s)
         return r
 end
   
-mymatch(grec, "one,two")
-mymatch(grec, "one two three")
-mymatch(grec, "1,\n two, \n3,")
-mymatch(grec, "one\n two123, \nthree,")
+mymatch(g, "one,two")
+mymatch(g, "one two three")
+mymatch(g, "1,\n two, \n3,")
+mymatch(g, "one\n two123, \nthree,")
 ```
 
 ##### *relabel* syntax
 
-Below we describe again a grammar that matches a list of identifiers,
-now using the syntax supported by *relabel*, where `//{}` is the
-recovery operator, and `%{}` is the throw operator:
+Below we write a grammar for a simple programming language 
+using the syntax supported by *relabel*, where `%{}` is the throw
+operator, and the syntax `p^l` is syntatic sugar for
+`p / %{l}` (given that *l* is a valid identifier name):
 
 ```lua
-local re = require 'relabel' 
-
-local errinfo = {
-  {"errUndef",  "undefined"},
-  {"errId",     "expecting an identifier"},
-  {"errComma",  "expecting ','"},
+local re = require 'relabel'
+
+local terror = {
+  cmdSeq        =  "Missing ';' in CmdSeq",
+  ifExp         =  "Error in expresion of 'if'",
+  ifThen        =  "Error matching 'then' keyword",
+  ifThenCmdSeq  =  "Error matching CmdSeq of 'then' branch",
+  ifElseCmdSeq  =  "Error matching CmdSeq of 'else' branch",
+  ifEnd         =  "Error matching 'end' keyword of 'if'",
+  repeatCmdSeq  =  "Error matching CmdSeq of 'repeat'",
+  repeatUntil   =  "Error matching 'until' keyword",
+  repeatExp     =  "Error matching expression of 'until'",
+  assignOp      =  "Error matching ':='",
+  assignExp     =  "Error matching expression of assignment",
+  readName      =  "Error matching 'NAME' after 'read'",
+  writeExp      =  "Error matching expression after 'write'",
+  simpleExp     =  "Error matching 'SimpleExp'",
+  term          =  "Error matching 'Term'",
+  factor        =  "Error matching 'Factor'",
+  openParExp    =  "Error matching expression after '('",
+  closePar      =  "Error matching ')'",
+  eof           =  "Error, expecting EOF",
+  undefined     =  "Undefined Error"
 }
 
-local errmsgs = {}
-local labels = {}
-
-for i, err in ipairs(errinfo) do
-  errmsgs[i] = err[2]
-  labels[err[1]] = i
-end
-
-re.setlabels(labels)
-
-local g = re.compile[[
-  S      <- Id List
-  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)
-  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(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 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.
-
-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. 
-
-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"lpeglabel"
-local re = require"relabel"
-
-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")), 
-  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  
+g = re.compile([[
+  Tiny       <- CmdSeq (!. / %{eof})
+  CmdSeq     <- (Cmd SEMICOLON^cmdSeq) (Cmd SEMICOLON^cmdSeq)*
+  Cmd        <- IfCmd / RepeatCmd / ReadCmd / WriteCmd  / AssignCmd 
+  IfCmd      <- IF  Exp^ifExp  THEN^ifThen  CmdSeq^ifThenCmdSeq  (ELSE CmdSeq^ifElseCmdSeq / '')  END^ifEnd
+  RepeatCmd  <- REPEAT  CmdSeq^repeatCmdSeq  UNTIL^repeatUntil  Exp^repeatExp
+  AssignCmd  <- NAME  ASSIGNMENT^assignOp  Exp^assignExp
+  ReadCmd    <- READ  NAME^readName
+  WriteCmd   <- WRITE  Exp^writeExp
+  Exp        <- SimpleExp  ((LESS / EQUAL)  SimpleExp^simpleExp / '')
+  SimpleExp  <- Term  ((ADD / SUB)  Term^term)*
+  Term       <- Factor ((MUL / DIV)  Factor^factor)*
+  Factor     <- OPENPAR  Exp^openParExp  CLOSEPAR^closePar  / NUMBER  / NAME
+  ADD        <- Sp '+'
+  ASSIGNMENT <- Sp ':='
+  CLOSEPAR   <- Sp ')'
+  DIV        <- Sp '/'
+  IF         <- Sp 'if'
+  ELSE       <- Sp 'else'
+  END        <- Sp 'end'
+  EQUAL      <- Sp '='
+  LESS       <- Sp '<'
+  MUL        <- Sp '*'
+  NAME       <- !RESERVED Sp [a-z]+
+  NUMBER     <- Sp [0-9]+
+  OPENPAR    <- Sp '('
+  READ       <- Sp 'read'
+  REPEAT     <- Sp 'repeat'
+  SEMICOLON  <- Sp ';'
+  SUB        <- Sp '-'
+  THEN       <- Sp 'then'
+  UNTIL      <- Sp 'until'
+  WRITE      <- Sp 'write'
+  RESERVED   <- (IF / ELSE / END / READ / REPEAT / THEN / UNTIL / WRITE) ![a-z]+
+  Sp         <- (%s / %nl)*  
+]], terror)
+
+
+local function mymatch(g, s)
+        local r, e, pos = g:match(s)
+  if not r then
+    local line, col = re.calcline(s, pos)
+    local msg = "Error at line " .. line .. " (col " .. col .. "): "
+                return r, msg .. terror[e]
+        end 
+        return r
 end
 
-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
+local s = [[
+n := 5;
+f := 1;
+repeat
+  f := f + n;
+  n := n - 1
+until (n < 1);
+write f;]]
+print(mymatch(g, s))
+
+print(mymatch(g, "a : 2"))
+print(mymatch(g, "a := 2; 6"))
 ```
 
-#### Automatically Building the Recovery Grammar 
+### Caveats
 
-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.
+Does not use the number **1** to specify a recovery rule,
+since that this index is used to indicate the first rule
+of a grammar.
 
-```lua
-local m = require"lpeglabel"
-local re = require"relabel"
-
-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")
--- 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
-```
+In case your grammar has many regular and recovery rules,
+you may get an error message such as grammar: <em>has too many rules</em>.
+In this case, we need to change *MAXRULES* in `lptypes.h`.
+