dawids/lang-bootstrap
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
lang-bootstrap/06/lpeglabel/testlabel.lua

1055 lines
27 KiB
Lua
Raw Normal View History

Add stage 06: Lua bootstrap The goal of stage 06 is to try parse zig synax in lua. I pulled in lpeglable 1.2.0 and parser-gen off github to get started. All of this needs to be cleaned up rather soon. Lua boostraps using tcc and musl from the previous stage. Since musl 0.6.0 doesn't support dynamic linking this build of lua doesn't support shared libraries. I couldn't easily patch musl with dlopen and friends so instead I link statically and call deps with c api.
2023-07-06 11:48:59 +01:00
local m = require 'lpeglabel'
local p, r, l, s, serror
local function checklabeq (x, ...)
y = { ... }
assert(type(x) == "table")
assert(#x == #y)
for i = 1, 3 do
assert(x[i] == y[i])
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
-- tests related to reporting the farthest failure position
-- when a label is not thrown
p = m.P"a"^0 * m.P"b" + m.P"c"
checklabeq({4, nil, nil}, p:match("aabk"))
checklabeq({2, nil, nil}, p:match("ck"))
checklabeq({nil, 0, "dk"}, p:match("dk"))
checklabeq({nil, 0, "k"}, p:match("aak"))
p = (m.P"a" + m.P"c")^0 * m.P"b" + m.P"c"
checklabeq({4, nil, nil}, p:match("aabk"))
checklabeq({2, nil, nil}, p:match("ck"))
checklabeq({nil, 0, "dk"}, p:match("dk"))
checklabeq({nil, 0, "k"}, p:match("aak"))
p = m.P"a"^0 * m.P"b" + m.P(1)^0 * m.P(1)
checklabeq({4, nil, nil}, p:match("aabk"))
checklabeq({nil, 0, ""}, p:match("ck"))
checklabeq({nil, 0, ""}, p:match("aak"))
p = m.P(1) * m.P"a" + m.P"c"
checklabeq({3, nil, nil}, p:match("bac"))
checklabeq({2, nil, nil}, p:match("c"))
checklabeq({nil, 0, ""}, p:match("x"))
checklabeq({nil, 0, "x"}, p:match("kx"))
p = m.P"a"^0 * m.P(1) * m.P(1) + m.P"a"^0 * m.P"c"
checklabeq({5, nil, nil}, p:match("aabc"))
checklabeq({4, nil, nil}, p:match("aac"))
checklabeq({nil, 0, ""}, p:match("aak"))
checklabeq({nil, 0, ""}, p:match("x"))
p = m.P"a"^0 * m.P(1) * m.P(1) + m.P"a"^0 * m.P"c"
checklabeq({5, nil, nil}, p:match("aabc"))
checklabeq({4, nil, nil}, p:match("aac"))
checklabeq({nil, 0, ""}, p:match("aak"))
checklabeq({nil, 0, ""}, p:match("x"))
p = m.Cmt(m.P"a"^0, function() return nil end) + m.P"x"
checklabeq({2, nil, nil}, p:match("xabc"))
checklabeq({nil, 0, "c"}, p:match("aac"))
checklabeq({nil, 0, "kx"}, p:match("kx"))
p = m.P"b" * -m.P"a" + m.P"c"
checklabeq({nil, 0, "a"}, p:match("ba"))
checklabeq({nil, 0, "kx"}, p:match("kx"))
p = (m.P"c" + m.P"a") * m.P("b" + m.P"d") + m.P"xxx"
checklabeq({nil, 0, "kk"}, p:match("kk"))
checklabeq({nil, 0, "k"}, p:match("ak"))
checklabeq({nil, 0, "y"}, p:match("xxy"))
checklabeq({nil, 0, "yz"}, p:match("xyz"))
print"+"
-- throws a label
p = m.T(1)
s = "abc"
r, l, serror = p:match(s)
assert(r == nil and l == 1 and serror == "abc")
-- throws a label, choice does not catch labels
p = m.T(1) + m.P"a"
r, l, serror = p:match(s)
assert(r == nil and l == 1 and serror == "abc")
-- again throws a label that is not caught by choice
local g = m.P{
"S",
S = m.V"A" + m.V"B",
A = m.T(1),
B = m.P"a"
}
r, l, serror = g:match(s)
assert(r == nil and l == 1 and serror == "abc")
-- throws a label in a position that is not the farthest one
-- but it is the position that should be reported
p = m.P(1) * m.P"a" + m.T(11)
checklabeq({3, nil, nil}, p:match("bac"))
checklabeq({nil, 11, "c"}, p:match("c"))
checklabeq({nil, 11, "x"}, p:match("x"))
checklabeq({nil, 11, "kx"}, p:match("kx"))
-- 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")
-- 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 recovery
p = m.Rec(m.T(25), m.P"a", 25)
assert(p:match(s) == 2)
-- "fail" is label "0"
-- throws the "fail" label after the recovery
s = "bola"
r, l, serror = p:match("bola")
assert(r == nil and l == 0 and serror == "bola")
-- 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)
-- 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("bac") == 2)
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(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 == 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"
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("abc")
assert(r == nil and l == 1 and serror == "abc")
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.Rec(-m.T(22), m.P"a", 22)
r, l, serror = p:match("abc")
assert(r == nil and l == 0 and serror == "bc")
assert(p:match("bbc") == 1)
p = m.Rec(#m.T(22), m.P"a", 22)
assert(p:match("abc") == 1)
p = #m.Rec(m.T(22), m.P"a", 22)
assert(p:match("abc") == 1)
p = m.Rec(m.T(22), #m.P"a", 22)
assert(p:match("abc") == 1)
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")
-- 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.P"a" + m.T(1))^0
r, l, serror = p:match("aa")
assert(r == nil and l == 1 and serror == "")
-- Bug reported by Matthew Allen
-- some optmizations performed by LPeg should not be
-- applied in case of labeled choices
p = m.Rec(m.P"A", m.P(true), 1) + m.P("B")
assert(p:match("B") == 2)
p = m.Rec(m.P"A", m.P(false), 1) + m.P("B")
assert(p:match("B") == 2)
--[[
S -> A //{1} 'a'
A -> B
B -> %1
]]
g = m.P{
"S",
S = m.Rec(m.V"A", m.P"a", 1),
A = m.V"B",
B = m.T(1),
}
assert(g:match("ab") == 2)
r, l, serror = g:match("bc")
assert(r == nil and l == 0 and serror == "bc")
--[[
S -> A
A -> (B (';' / %{1}))*
B -> 'a'
]]
g = m.P{
"S",
S = m.V"A",
A = m.P(m.V"B" * (";" + m.T(1)))^0,
B = m.P'a',
}
assert(g:match("a;a;") == 5)
r, l, serror = g:match("a;a")
assert(r == nil and l == 1 and serror == "")
-- %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.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
-- can only throw labels between 1 and 255
local r = pcall(m.Rec, m.P"b", m.P"a", 0)
assert(r == false)
local r = pcall(m.Rec, m.P"b", m.P"a", 256)
assert(r == false)
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 -> 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.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"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",
Exp = sp * m.P"E",
}
local s = "a"
assert(g:match(s) == #s + 1) --1
s = "a = E"
assert(g:match(s) == #s + 1) --2
s = "int a"
assert(g:match(s) == #s + 1) --3
s = "unsigned int a"
assert(g:match(s) == #s + 1) --3
s = "unsigned a a"
assert(g:match(s) == #s + 1) --4
s = "b"
r, l, serror = g:match(s)
assert(r == nil and l == 5 and serror == "b")
s = "unsigned"
r, l, serror = g:match(s)
assert(r == nil and l == 5 and serror == s)
s = "unsigned a"
r, l, serror = g:match(s)
assert(r == nil and l == 5 and serror == s)
s = "unsigned int"
r, l, serror = g:match(s)
assert(r == nil and l == 5 and serror == s)
print("+")
local re = require 'relabel'
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]
]]
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]
]]
r, l, serror = g:match("a")
assert(r == nil and l == 1 and serror == "a")
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] ]]
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 -> 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 / %{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'
Exp <- %s* 'E'
]])
local s = "a"
assert(g:match(s) == #s + 1) --1
s = "a = E"
assert(g:match(s) == #s + 1) --2
s = "int a"
assert(g:match(s) == #s + 1) --3
s = "unsigned int a"
assert(g:match(s) == #s + 1) --3
s = "unsigned a a"
assert(g:match(s) == #s + 1) --4
s = "b"
r, l, serror = g:match(s)
assert(r == nil and l == 5 and serror == s)
s = "unsigned"
r, l, serror = g:match(s)
assert(r == nil and l == 5 and serror == s)
s = "unsigned a"
r, l, serror = g:match(s)
assert(r == nil and l == 5 and serror == s)
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",
['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 //{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})
RepeatCmd <- REPEAT (CmdSeq / %{7}) (UNTIL / %{8}) (Exp / %{9})
AssignCmd <- NAME (ASSIGNMENT / %{10}) (Exp / %{11})
ReadCmd <- READ (NAME / %{12})
WriteCmd <- WRITE (Exp / %{13})
Exp <- SimpleExp ((LESS / EQUAL) (SimpleExp / %{14}) / '')
SimpleExp <- Term ((ADD / SUB) (Term / %{15}))*
Term <- Factor ((MUL / DIV) (Factor / %{16}))*
Factor <- OPENPAR (Exp / %{17}) (CLOSEPAR / %{18}) / 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)
s = [[
n := 5;]]
assert(g:match(s) == #s + 1)
s = [[
n := 5;
f := 1;
repeat
f := f * n;
n := n - 1;
until (n < 1);
write f;]]
assert(g:match(s) == #s + 1)
-- a ';' is missing in 'read a'
s = [[
read a]]
assert(g:match(s) == terror['cmdSeq'])
-- a ';' is missing in 'n := n - 1'
s = [[
n := 5;
f := 1;
repeat
f := f * n;
n := n - 1
until (n < 1);
write f;]]
assert(g:match(s) == terror['cmdSeq'])
-- IF expression
s = [[
if a then a := a + 1; end;]]
assert(g:match(s) == #s + 1)
-- IF expression
s = [[
if a then a := a + 1; else write 2; end;]]
assert(g:match(s) == #s + 1)
-- Error in expression of 'if'. 'A' is not a valida name
s = [[
if A then a := a + 1; else write 2; end;]]
assert(g:match(s) == terror['ifExp'])
-- Error matching the 'then' keyword
s = [[
if a a := a + 1; else write 2; end;]]
assert(g:match(s) == terror['ifThen'])
-- Error matching the CmdSeq inside of 'then' branch
s = [[
if a then 3 := 2; else write 2; end;]]
assert(g:match(s) == terror['ifThenCmdSeq'])
-- Error matching the CmdSeq inside of 'else' branch
s = [[
if a then b := 2; else A := 2; end;]]
assert(g:match(s) == terror['ifElseCmdSeq'])
-- Error matching 'end' of 'if'
s = [[
if a then b := 2; else a := 2; 77;]]
assert(g:match(s) == terror['ifEnd'])
-- Error matching the CmdSeq of 'repeat'
s = [[repeat
F := f * n;
n := n - 1;
until (n < 1);]]
assert(g:match(s) == terror['repeatCmdSeq'])
-- Error matching 'until'
s = [[repeat
f := f * n;
n := n - 1;
88 (n < 1);]]
assert(g:match(s) == terror['repeatUntil'])
-- Error matching expression of 'until'
s = [[repeat
f := f * n;
n := n - 1;
until ; (n < 1);]]
assert(g:match(s) == terror['repeatExp'])
-- Error matching ':='
s = [[
f = f * n;]]
assert(g:match(s) == terror['assignOp'])
-- Error matching expression of assignment
s = [[
f := A * n;]]
assert(g:match(s) == terror['assignExp'])
-- Error matching 'name'
s = [[
read 2;]]
assert(g:match(s) == terror['readName'])
-- Error matching expression after 'write'
s = [[
write [a] := 2;]]
assert(g:match(s) == terror['writeExp'])
-- Error matching 'SimpleExp'
s = [[
a := a < A;]]
assert(g:match(s) == terror['simpleExp'])
-- Error matching 'Term'
s = [[
a := a + A;]]
assert(g:match(s) == terror['term'])
-- Error matching 'Factor'
s = [[
a := a * A;]]
assert(g:match(s) == terror['factor'])
-- Error matching expression after '('
s = [[
a := (A);]]
assert(g:match(s) == terror['openParExp'])
-- Error matching ')'
s = [[
a := (a];]]
assert(g:match(s) == terror['closePar'])
-- Error undefined
s = [[
A := a;]]
assert(g:match(s) == terror['undefined'])
print("+")
p = m.Rec("a", "b", 3)
assert(p:match("a") == 2)
checklabeq({nil, 0, "b"}, p:match("b"))
checklabeq({nil, 0, "c"}, p:match("c"))
p = m.Rec(m.T(3), "b", 1)
checklabeq({nil, 3, "a"}, p:match("a"))
checklabeq({nil, 3, "b"}, p:match("b"))
p = m.Rec(m.T(3), "b", 3)
checklabeq({nil, 0, "a"}, p:match("a"))
assert(p:match("b") == 2)
--[[
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, 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("dc") == 3)
checklabeq({nil, 0, "bc"}, g:match("bbc"))
assert(g:match("xxc") == 4)
assert(g:match("c") == 2)
checklabeq({nil, 0, ""}, g:match("fail"))
checklabeq({nil, 0, ""}, g:match("aaxx"))
--[[
S -> (A //{99} (!c .)*) C
A -> a+ (b / ^99)
C -> c+
]]
g = m.P{
"S",
S = m.Rec(m.V"A", (-m.P"c" * m.P(1))^0, 99) * m.V"C",
A = m.P"a"^1 * ("b" + m.T(99)),
C = m.P"c"^1,
}
assert(g:match("abc") == 4)
assert(g:match("aabc") == 5)
assert(g:match("aadc") == 5)
checklabeq({nil, 0, "bc"}, g:match("bc"))
checklabeq({nil, 0, "bbc"}, g:match("bbc"))
checklabeq({nil, 0, "b"}, g:match("abb"))
checklabeq({nil, 0, ""}, g:match("axx"))
assert(g:match("accc") == 5)
assert(g:match("axxc") == 5)
checklabeq({nil, 0, "c"}, g:match("c"))
checklabeq({nil, 0, "fail"}, g:match("fail"))
-- Matthew's recovery example
lpeg = m
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
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 = m.Rec(V"Operand", Cc(0), labelindex("ExpTerm"));
Operand = expect(V"Term", "ExpTerm");
Term = num + V"Group";
Group = "(" * V"InnerExp" * m.Rec(expect(")", "MisClose"), P"", labelindex("MisClose"));
InnerExp = m.Rec(expect(V"Exp", "ExpExp"), (P(1) - ")")^0 * Cc(0), labelindex("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
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)
checklabeq({nil, 1, "ba."}, g:match("ba."))
checklabeq({nil, 1, "ba."}, g:match("aba."))
checklabeq({nil, 1, "cba."}, g:match("cba."))
checklabeq({nil, 2, "a"}, g:match("a.a"))
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)
checklabeq({nil, 3, "cba."}, g2:match("cba."))
checklabeq({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)
checklabeq({nil, 4, "a"}, g3:match("a.a"))
checklabeq({nil, 4, "dc"}, g3:match("dc"))
checklabeq({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")
Reference in a new issue Copy permalink