Updating examples to the new semantics

12 files changed, 278 insertions, 269 deletions

diff --git a/examples/exp.lua b/examples/exp.lua
new file mode 100644
index 0000000..4afe83e
--- /dev/null
+++ b/examples/exp.lua
@@ -0,0 +1,100 @@
+-- Matthew's recovery example 
+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 = lpeg.T
+
+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 errors = {}
+
+local function expect(patt, labname)
+  function recorderror(input, pos)
+    table.insert(errors, {labname, pos})
+    return true
+  end
+  return patt + Cmt("", recorderror) * T(labname)
+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 + V"Group";
+  Group = "(" * V"InnerExp" * expect(")", "MisClose");
+  InnerExp = expect(V"Exp", "ExpExp");
+  ExpTerm = Cc(0);
+  MisClose = P"";
+  ExpExp = (P(1) - ")")^0 * Cc(0);
+}
+
+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]]
+      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
+
+local e, msg = eval "(1+1-1*2/2"
+assert(e == nil and msg == "syntax error: missing a closing ')' after the expression (at index 11)")
+
+e, msg = eval "(1+)-1*(2/2)"
+assert(e == nil and msg == "syntax error: expected a term after the operator (at index 4)")
+
+e, msg = eval "(1+1)-1*(/2)"
+assert(e == nil and msg == "syntax error: expected an expression after the parenthesis (at index 10)")
+
+e, msg = eval "1+(1-(1*2))/2x"
+assert(e == nil and msg == "syntax error: extra characters found after the expression (at index 14)")
+
+e, msg = eval "-1+(1-(1*2))/2"
+assert(e == nil and msg == "syntax error: no expression found (at index 1)")
+
+e, msg = eval "(1+1-1*(2/2+)-():"
+assert(e == nil and msg == "syntax error: expected a term after the operator (at index 13)\n" ..
+                           "syntax error: expected an expression after the parenthesis (at index 16)\n" ..
+                           "syntax error: missing a closing ')' after the expression (at index 17)\n" ..
+                           "syntax error: extra characters found after the expression (at index 17)")
+
diff --git a/examples/expRec.lua b/examples/expRec.lua
index 52bd40a..d111ab0 100644
--- a/examples/expRec.lua
+++ b/examples/expRec.lua
@@ -2,28 +2,17 @@ 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"},
+  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)
+local function expect(patt, lab)
+  return patt + m.T(lab)
 end
 
-
 local num = m.R("09")^1 / tonumber
 local op = m.S("+-")
 
@@ -41,22 +30,13 @@ local function compute(tokens)
   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] })
+        table.insert(errors, { line = line, col = col, msg = labels[lab] })
 end
 
-function record (labname)
-        return (m.Cp() * m.Cc(labelindex(labname))) / recorderror
+function record (lab)
+        return (m.Cp() * m.Cc(lab)) / recorderror
 end
 
 function sync (p)
@@ -67,21 +47,23 @@ 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 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"),
+        ExpTermFirst  = record("ExpTermFirst") * sync(op + ")") * defaultValue(),
+        ExpTermOp     = record("ExpTermOp") * sync(op + ")") * defaultValue(),
+        MisClose      = 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)
+  local result, label, suffix = g:match(input)
   io.write("Syntactic errors found: " .. #errors, "\n")
         if #errors > 0 then
     local out = {}
diff --git a/examples/expRecAut.lua b/examples/expRecAut.lua
index b8280a7..18d7606 100644
--- a/examples/expRecAut.lua
+++ b/examples/expRecAut.lua
@@ -5,13 +5,11 @@ 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 }
+        labels[lab] = { msg = msg, psync = psync, pcap = pcap }
 end
 
 newError("ExpTermFirst", "expected an expression", op + ")", m.Cc(1000)) 
@@ -21,9 +19,8 @@ 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)
+local function expect(patt, lab)
+  return patt + m.T(lab)
 end
 
 local function compute(tokens)
@@ -40,15 +37,6 @@ local function compute(tokens)
   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 })
@@ -66,16 +54,29 @@ function defaultValue (p)
         return p or m.Cc(1000) 
 end
 
-local grec = g * expect(m.P(-1), "Extra")
+local g = {
+        "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"),
+}
+
+-- set first rule
+g[1] = "S"
+g["S"] = g["Exp"] * 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)
+  g[k] = record(k) * sync(v.psync) * v.pcap 
 end
 
+g = m.P(g)
+
 local function eval(input)
         errors = {}
         io.write("Input: ", input, "\n")
         subject = input
-  local result, label, suffix = grec:match(input)
+  local result, label, suffix = g:match(input)
   io.write("Syntactic errors found: " .. #errors, "\n")
         if #errors > 0 then
     local out = {}
diff --git a/examples/farthest.lua b/examples/farthest.lua
index 9cbe03d..0dc8262 100644
--- a/examples/farthest.lua
+++ b/examples/farthest.lua
@@ -15,13 +15,13 @@ function matchPrint2(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
 
 
-matchPrint2(p, "abc")  --> r:   3       lab:    nil     sfail:  nil
-matchPrint2(p, "c")    --> r:   2       lab:    nil     sfail:  nil
-matchPrint2(p, "aac")  --> r:   nil     lab:    0       sfail:  c
-matchPrint2(p, "xxc")  --> r:   nil     lab:    0       sfail:  xxc
+matchPrint2(p, "abc")  --> r: 3    lab: nil   sfail: nil
+matchPrint2(p, "c")    --> r: 2    lab: nil   sfail: nil
+matchPrint2(p, "aac")  --> r: nil        lab: fail  sfail: c
+matchPrint2(p, "xxc")  --> r: nil        lab: fail  sfail: xxc
diff --git a/examples/listId1.lua b/examples/listId1.lua
index 9bba783..e045ac1 100644
--- a/examples/listId1.lua
+++ b/examples/listId1.lua
@@ -7,8 +7,8 @@ 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(1),
-  Comma = m.V"Sp" * "," + m.T(2),
+  Id = m.V"Sp" * id + m.T'ErrId',
+  Comma = m.V"Sp" * "," + m.T'ErrComma',
   Sp = m.S" \n\t"^0,
 }
 
@@ -17,9 +17,9 @@ function mymatch (g, s)
   if not r then
     local line, col = re.calcline(s, pos)
     local msg = "Error at line " .. line .. " (col " .. col .. ")"
-    if e == 1 then
+    if e == 'ErrId' then
       return r, msg .. ": expecting an identifier before '" .. s:sub(pos) .. "'"
-    elseif e == 2 then
+    elseif e == 'ErrComma' then
       return r, msg .. ": expecting ',' before '" .. s:sub(pos) .. "'"
     else
       return r, msg
diff --git a/examples/listId2.lua b/examples/listId2.lua
index 592dae3..322d432 100644
--- a/examples/listId2.lua
+++ b/examples/listId2.lua
@@ -1,16 +1,11 @@
 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 terror = {
+  ErrId =    "expecting an identifier",
+  ErrComma = "expecting ','",
+  fail = "undefined"
+}
 
 local id = m.R'az'^1
 
@@ -18,8 +13,8 @@ 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),
+  Id = m.V"Sp" * id + m.T'ErrId',
+  Comma = m.V"Sp" * "," + m.T'ErrComma',
   Sp = m.S" \n\t"^0,
 }
 
diff --git a/examples/listId2Rec2.lua b/examples/listId2Rec2.lua
index 3506095..09db5a6 100644
--- a/examples/listId2Rec2.lua
+++ b/examples/listId2Rec2.lua
@@ -1,51 +1,39 @@
 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" * 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 ','"
 }
 
 local subject, errors
 
-function recorderror(pos, lab)
+local 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)
+local function record (lab)
         return (m.Cp() * m.Cc(lab)) / recorderror
 end
 
-function sync (p)
+local function sync (p)
         return (-p * m.P(1))^0
 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",")
+  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,
+  ErrId = record('ErrId') * sync(m.P","),
+  ErrComma = record('ErrComma') * sync(id),
 }
 
-
 function mymatch (g, s)
         errors = {}
         subject = s     
@@ -61,7 +49,7 @@ function mymatch (g, s)
   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,"))
+print(mymatch(g, "one,two"))
+print(mymatch(g, "one two three"))
+print(mymatch(g, "1,\n two, \n3,"))
+print(mymatch(g, "one\n two123, \nthree,"))
diff --git a/examples/listId2Rec2Cap.lua b/examples/listId2Rec2Cap.lua
index 32a4113..7fbe700 100644
--- a/examples/listId2Rec2Cap.lua
+++ b/examples/listId2Rec2Cap.lua
@@ -1,26 +1,9 @@
 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 ','"
 }
 
 local subject, errors
@@ -42,11 +25,17 @@ 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"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,
+  ErrId = record('ErrId') * sync(m.P",") * defaultValue(), 
+  ErrComma = record('ErrComma') * sync(id),
 }
 
 
@@ -73,7 +62,7 @@ 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,")
diff --git a/examples/listIdRe1.lua b/examples/listIdRe1.lua
index d60706a..ef38cfb 100644
--- a/examples/listIdRe1.lua
+++ b/examples/listIdRe1.lua
@@ -3,8 +3,8 @@ local re = require 'relabel'
 local g = re.compile[[
   S      <- Id List
   List   <- !.  /  Comma Id List
-  Id     <- Sp [a-z]+ / %{2}
-  Comma  <- Sp ',' / %{3}
+  Id     <- Sp [a-z]+ / %{ErrId}
+  Comma  <- Sp ',' / %{ErrComma}
   Sp     <- %s*
 ]]
 
@@ -13,9 +13,9 @@ function mymatch (g, s)
   if not r then
     local line, col = re.calcline(s, pos)
     local msg = "Error at line " .. line .. " (col " .. col .. ")"
-    if e == 1 then
+    if e == 'ErrId' then
       return r, msg .. ": expecting an identifier before '" .. s:sub(pos) .. "'"
-    elseif e == 2 then
+    elseif e == 'ErrComma' then
       return r, msg .. ": expecting ',' before '" .. s:sub(pos) .. "'"
     else
       return r, msg
diff --git a/examples/listIdRe2.lua b/examples/listIdRe2.lua
index 58ddedd..0ea7352 100644
--- a/examples/listIdRe2.lua
+++ b/examples/listIdRe2.lua
@@ -1,46 +1,33 @@
 local re = require 'relabel' 
 
 local errinfo = {
-  {"errUndef",  "undefined"},
-  {"errId",     "expecting an identifier"},
-  {"errComma",  "expecting ','"},
+  ErrId     =  "expecting an identifier",
+  ErrComma  =  "expecting ','",
+  fail      =  "undefined",
 }
 
-local errmsgs = {}
-local labels = {}
-
-for i, err in ipairs(errinfo) do
-  errmsgs[i] = err[2]
-  labels[err[1]] = i
+local function sync (p)
+        return '( !(' .. p .. ') .)*'
 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 function recorderror (subject, pos, label)
         local line, col = re.calcline(subject, pos)
-        table.insert(errors, { line = line, col = col, msg = errmsgs[labels[label]] })
+        table.insert(errors, { line = line, col = col, msg = errinfo[label] })
         return true 
 end
 
-function sync (p)
-        return '( !(' .. p .. ') .)*'
-end
+local g = re.compile([[
+  S         <- Id List
+  List      <- !.  /  Comma Id List
+  Id        <- (Sp {[a-z]+})^ErrId
+  Comma     <- (Sp ',')^ErrComma
+  Sp        <- %s*]] ..
+  "ErrId    <- ('' -> 'ErrId' => recorderror) " .. sync('","') .. "-> default\n" ..
+  "ErrComma <-  ('' -> 'ErrComma' => recorderror) " .. sync('[a-z]+'),
+  {default = "NONE", recorderror = recorderror})
 
-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 = {}
@@ -65,7 +52,7 @@ 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,")
diff --git a/examples/tiny.lua b/examples/tiny.lua
index cc718e7..fe0bced 100644
--- a/examples/tiny.lua
+++ b/examples/tiny.lua
@@ -1,92 +1,63 @@
 local re = require 'relabel'
 
-local terror = {}
-
-local function newError(l, msg)
-        table.insert(terror, { l = l, msg = msg} )
-end
-
-newError("errSemi", "Error: missing ';'")  
-newError("errExpIf", "Error: expected expression after 'if'") 
-newError("errThen", "Error: expected 'then' keyword") 
-newError("errCmdSeq1", "Error: expected at least a command after 'then'") 
-newError("errCmdSeq2", "Error: expected at least a command after 'else'") 
-newError("errEnd", "Error: expected 'end' keyword") 
-newError("errCmdSeqRep", "Error: expected at least a command after 'repeat'") 
-newError("errUntil", "Error: expected 'until' keyword") 
-newError("errExpRep", "Error: expected expression after 'until'") 
-newError("errAssignOp", "Error: expected ':=' in assigment") 
-newError("errExpAssign", "Error: expected expression after ':='") 
-newError("errReadName", "Error: expected an identifier after 'read'") 
-newError("errWriteExp", "Error: expected expression after 'write'") 
-newError("errSimpExp", "Error: expected '(', ID, or number after '<' or '='")
-newError("errTerm", "Error: expected '(', ID, or number after '+' or '-'")
-newError("errFactor", "Error: expected '(', ID, or number after '*' or '/'")
-newError("errExpFac", "Error: expected expression after '('")
-newError("errClosePar", "Error: expected ')' after expression")
-
-
-local labelCode = {}
-for k, v in ipairs(terror) do 
-        labelCode[v.l] = k
-end
-
-re.setlabels(labelCode)
-
-local g = re.compile[[
-  Tiny         <- CmdSeq  
-  CmdSeq       <- (Cmd (SEMICOLON / ErrSemi)) (Cmd (SEMICOLON / ErrSemi))*
-  Cmd          <- IfCmd / RepeatCmd / ReadCmd / WriteCmd  / AssignCmd 
-  IfCmd        <- IF (Exp / ErrExpIf)  (THEN / ErrThen)  (CmdSeq / ErrCmdSeq1)  (ELSE (CmdSeq / ErrCmdSeq2)  / '') (END / ErrEnd)
-  RepeatCmd    <- REPEAT  (CmdSeq / ErrCmdSeqRep)  (UNTIL / ErrUntil)  (Exp / ErrExpRep)
-  AssignCmd    <- NAME  (ASSIGNMENT / ErrAssignOp)  (Exp / ErrExpAssign)
-  ReadCmd      <- READ  (NAME / ErrReadName)
-  WriteCmd     <- WRITE  (Exp / ErrWriteExp)
-  Exp          <- SimpleExp  ((LESS / EQUAL) (SimpleExp / ErrSimpExp) / '')
-  SimpleExp    <- Term  ((ADD / SUB)  (Term / ErrTerm))*
-  Term         <- Factor  ((MUL / DIV)  (Factor / ErrFactor))*
-  Factor       <- OPENPAR  (Exp / ErrExpFac)  (CLOSEPAR / ErrClosePar)  / NUMBER  / NAME
-  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 ')'
-  DIV          <- Sp '/'
-  IF           <- Sp 'if'
-  ELSE         <- Sp 'else'
-  END          <- Sp 'end'
-  EQUAL        <- Sp '='
-  LESS         <- Sp '<'
-  MUL          <- Sp '*'
-  NAME         <- Sp !RESERVED [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*   
-]]
+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 ')'",
+  undefined     =  "Undefined Error"
+}
+
+g = re.compile([[
+  Tiny       <- CmdSeq^undefined 
+  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)
@@ -94,7 +65,7 @@ local function mymatch(g, 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].msg
+                return r, msg .. terror[e]
         end 
         return r
 end
diff --git a/lpvm.c b/lpvm.c
index f56f1d5..1eb7944 100644
--- a/lpvm.c
+++ b/lpvm.c
@@ -351,10 +351,6 @@ const char *match (lua_State *L, const char *o, const char *s, const char *e,
           while (!(stack-1)->predchoice) {
             --stack;
           } 
-          /*if ((stack-1)->labenv == ANDPRED) {
-            printf("ANDPRED: stack - 1\n");
-            stack--;
-          }*/
           *labelf = LFAIL;
         }
         goto fail;