KeylessUniversal
ERC by cl1f0nkid
Cl1f0nkid 1 year ago 3.6K viewsRun it
Copy the script and paste it into your executor.
ERC by cl1f0nkid.lua · 5,637 lines
ERC = .()
Main = .()
Bottom = .()
ImageLabel = .()
RightMain = .()
LeftMain = .()
R6 = .()
Re = .()
Field = .()
Execute = .()
Name1 = .()
Clear = .()
Hide = .()
Frame = .()
Frame_2 = .()
Name2 = .()
ERC.Name =
ERC.Parent = .Players.LocalPlayer:()
ERC.ZIndexBehavior = .ZIndexBehavior.Sibling
ERC.ResetOnSpawn =
Main.Name =
Main.Parent = ERC
Main.BackgroundColor3 = .(, , )
Main.BorderColor3 = .(, , )
Main.Position = .(, , , )
Main.Size = .(, , , )
Bottom.Name =
Bottom.Parent = Main
Bottom.BackgroundColor3 = .(, , )
Bottom.BorderColor3 = .(, , )
Bottom.Position = .(-, , , )
Bottom.Size = .(, , , )
ImageLabel.Parent = Main
ImageLabel.BackgroundColor3 = .(, , )
ImageLabel.BackgroundTransparency =
ImageLabel.BorderColor3 = .(, , )
ImageLabel.Size = .(, , , )
ImageLabel.Image =
RightMain.Name =
RightMain.Parent = Main
RightMain.BackgroundColor3 = .(, , )
RightMain.BorderColor3 = .(, , )
RightMain.BorderSizePixel =
RightMain.Position = .(-, , , )
RightMain.Size = .(, , , )
LeftMain.Name =
LeftMain.Parent = Main
LeftMain.BackgroundColor3 = .(, , )
LeftMain.BorderColor3 = .(, , )
LeftMain.BorderSizePixel =
LeftMain.Position = .(, , , )
LeftMain.Size = .(, , , )
R6.Name =
R6.Parent = LeftMain
R6.BackgroundColor3 = .(, , )
R6.BorderColor3 = .(, , )
R6.BorderSizePixel =
R6.Position = .(, , , )
R6.Size = .(, , , )
R6.Font = .Font.SourceSans
R6.Text =
R6.TextColor3 = .(, , )
R6.TextSize =
Re.Name =
Re.Parent = LeftMain
Re.BackgroundColor3 = .(, , )
Re.BorderColor3 = .(, , )
Re.BorderSizePixel =
Re.Position = .(, , , )
Re.Size = .(, , , )
Re.Font = .Font.SourceSans
Re.Text =
Re.TextColor3 = .(, , )
Re.TextSize =
Field.Name =
Field.Parent = Main
Field.BackgroundColor3 = .(, , )
Field.BorderColor3 = .(, , )
Field.BorderSizePixel =
Field.Position = .(, , , )
Field.Size = .(, , , )
Field.ClearTextOnFocus =
Field.Font = .Font.Cartoon
Field.MultiLine =
Field.Text =
Field.TextColor3 = .(, , )
Field.TextSize =
Field.TextStrokeTransparency =
Field.TextWrapped =
Execute.Name =
Execute.Parent = Main
Execute.BackgroundColor3 = .(, , )
Execute.BorderColor3 = .(, , )
Execute.BorderSizePixel =
Execute.Position = .(, , , )
Execute.Size = .(, , , )
Execute.Font = .Font.SourceSans
Execute.Text =
Execute.TextColor3 = .(, , )
Execute.TextSize =
Name1.Name =
Name1.Parent = Main
Name1.BackgroundColor3 = .(, , )
Name1.BackgroundTransparency =
Name1.BorderColor3 = .(, , )
Name1.BorderSizePixel =
Name1.Position = .(, , , )
Name1.Size = .(, , , )
Name1.Font = .Font.Code
Name1.Text =
Name1.TextColor3 = .(, , )
Name1.TextSize =
Clear.Name =
Clear.Parent = Main
Clear.BackgroundColor3 = .(, , )
Clear.BorderColor3 = .(, , )
Clear.BorderSizePixel =
Clear.Position = .(, , , )
Clear.Size = .(, , , )
Clear.Font = .Font.SourceSans
Clear.Text =
Clear.TextColor3 = .(, , )
Clear.TextSize =
Hide.Name =
Hide.Parent = Main
Hide.BackgroundColor3 = .(, , )
Hide.BorderColor3 = .(, , )
Hide.BorderSizePixel =
Hide.Position = .(, , , )
Hide.Size = .(, , , )
Hide.Font = .Font.SourceSans
Hide.Text =
Hide.TextColor3 = .(, , )
Hide.TextSize =
Frame.Parent = Main
Frame.BackgroundColor3 = .(, , )
Frame.BorderColor3 = .(, , )
Frame.BorderSizePixel =
Frame.Position = .(-, , -, )
Frame.Size = .(, , , )
Frame_2.Parent = Main
Frame_2.BackgroundColor3 = .(, , )
Frame_2.BorderColor3 = .(, , )
Frame_2.BorderSizePixel =
Frame_2.Position = .(-, , , )
Frame_2.Size = .(, , , )
Name2.Name =
Name2.Parent = Main
Name2.BackgroundColor3 = .(, , )
Name2.BackgroundTransparency =
Name2.BorderColor3 = .(, , )
Name2.BorderSizePixel =
Name2.Position = .(, , , )
Name2.Size = .(, , , )
Name2.Font = .Font.Code
Name2.Text =
Name2.TextColor3 = .(, , )
Name2.TextSize =
fake_module_scripts = {}
= .(, R6)
.Name =
()
R6Converter = {}
R6Converter.(Plr)
Plr = .Players:(Plr)
FalseChar = :():()
PlayersCharacter = .Players:(Plr.UserId):()
FaceID = (Plr.Character:():() {Texture = }).Texture
Accessories = {}
FalseChar:():().Texture = FaceID
FalseChar:(Plr.Character:().CFrame)
_,Prt (PlayersCharacter:())
Prt:() Prt:() Prt:() Prt:() Prt:() Prt:() Prt:() Prt:()
.(Accessories,Prt:())
_,Prt (Plr.Character:())
Prt:()
_,Prt (FalseChar:())
Prt.Parent = Plr.Character
_,Prt (Accessories)
Prt.Parent = Plr.Character
R6Converter
fake_module_scripts[] = module_script
= .(, )
.Name =
()
compile = (:())
createExecutable = (:())
().script =
(source, env)
executable
env = env ()
name = (env.script env.script:())
ran, failureReason = (()
compiledBytecode = (source, name)
executable = (compiledBytecode, env)
)
ran
(executable, env)
, failureReason
fake_module_scripts[] = module_script
= .(, )
.Name =
()
bit = bit bit32 ()
.create .(_) {}
.unpack .unpack =
.pack .(...) {n = (, ...), ...}
.move
.(src, first, last, offset, dst)
i = , last - first dst[offset + i] = src[first + i]
lua_bc_to_state
lua_wrap_state
stm_lua_func
FIELDS_PER_FLUSH =
OPCODE_RM = {
[] = ,
[] = ,
[] = ,
[] = ,
[] = ,
[] = ,
[] = ,
[] = ,
[] = ,
[] = ,
[] = ,
[] = ,
[] = ,
[] = ,
[] = ,
[] = ,
[] = ,
[] = ,
[] = ,
[] = ,
[] = ,
[] = ,
[] = ,
[] = ,
[] = ,
[] = ,
[] = ,
[] = ,
[] = ,
[] = ,
[] = ,
[] = ,
[] = ,
[] = ,
[] = ,
[] = ,
[] = ,
[] = ,
}
OPCODE_T = {
[] = ,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
}
OPCODE_M = {
[] = {b = , c = },
{b = , c = },
{b = , c = },
{b = , c = },
{b = , c = },
{b = , c = },
{b = , c = },
{b = , c = },
{b = , c = },
{b = , c = },
{b = , c = },
{b = , c = },
{b = , c = },
{b = , c = },
{b = , c = },
{b = , c = },
{b = , c = },
{b = , c = },
{b = , c = },
{b = , c = },
{b = , c = },
{b = , c = },
{b = , c = },
{b = , c = },
{b = , c = },
{b = , c = },
{b = , c = },
{b = , c = },
{b = , c = },
{b = , c = },
{b = , c = },
{b = , c = },
{b = , c = },
{b = , c = },
{b = , c = },
{b = , c = },
{b = , c = },
{b = , c = },
}
(src, s, e, d)
num =
i = s, e, d
mul = ^ .(i - s)
num = num + mul * .(src, i, i)
num
(f1, f2, f3, f4)
sign = (-) ^ bit.(f4, )
exp = bit.(f3, ) + bit.(bit.(f4, ), )
frac = f1 + bit.(f2, ) + bit.(bit.(f3, ), )
normal =
exp ==
frac ==
sign *
normal =
exp =
exp ==
frac ==
sign * ( / )
sign * ( / )
sign * ^ (exp - ) * ( + normal / ^ )
(f1, f2, f3, f4, f5, f6, f7, f8)
sign = (-) ^ bit.(f8, )
exp = bit.(bit.(f8, ), ) + bit.(f7, )
frac = bit.(f7, ) * ^
normal =
frac = frac + (f6 * ^ ) + (f5 * ^ ) + (f4 * ^ ) + (f3 * ^ ) + (f2 * ^ ) + f1
exp ==
frac ==
sign *
normal =
exp =
exp ==
frac ==
sign * ( / )
sign * ( / )
sign * ^ (exp - ) * (normal + frac / ^ )
(src, s, e) (src, s, e - , )
(src, s, e) (src, e - , s, -)
(src, s) (.(src, s, s + ))
(src, s)
f1, f2, f3, f4 = .(src, s, s + )
(f4, f3, f2, f1)
(src, s) (.(src, s, s + ))
(src, s)
f1, f2, f3, f4, f5, f6, f7, f8 = .(src, s, s + )
(f8, f7, f6, f5, f4, f3, f2, f1)
float_types = {
[] = {little = rd_flt_le, big = rd_flt_be},
[] = {little = rd_dbl_le, big = rd_dbl_be},
}
(S)
idx = S.index
bt = .(S.source, idx, idx)
S.index = idx +
bt
(S, len)
pos = S.index + len
str = .(S.source, S.index, pos - )
S.index = pos
str
(S)
len = S:()
str
len ~= str = .((S, len), , -)
str
(len, func)
(S)
pos = S.index + len
int = (S.source, S.index, pos)
S.index = pos
int
(len, func)
(S)
flt = (S.source, S.index)
S.index = S.index + len
flt
(S)
len = S:()
list = .(len)
i = , len
ins = S:()
op = bit.(ins, )
args = OPCODE_T[op]
mode = OPCODE_M[op]
data = {value = ins, op = OPCODE_RM[op], A = bit.(bit.(ins, ), )}
args ==
data.B = bit.(bit.(ins, ), )
data.C = bit.(bit.(ins, ), )
data.is_KB = mode.b == data.B >
data.is_KC = mode.c == data.C >
args ==
data.Bx = bit.(bit.(ins, ), )
data.is_K = mode.b ==
args ==
data.sBx = bit.(bit.(ins, ), ) -
list[i] = data
list
(S)
len = S:()
list = .(len)
i = , len
tt = (S)
k
tt ==
k = (S) ~=
tt ==
k = S:()
tt ==
k = (S)
list[i] = k
list
(S, src)
len = S:()
list = .(len)
i = , len
list[i] = (S, src)
list
(S)
len = S:()
list = .(len)
i = , len list[i] = S:()
list
(S)
len = S:()
list = .(len)
i = , len list[i] = {varname = (S), startpc = S:(), endpc = S:()}
list
(S)
len = S:()
list = .(len)
i = , len list[i] = (S)
list
(S, psrc)
proto = {}
src = (S) psrc
proto.source = src
S:()
S:()
proto.num_upval = (S)
proto.num_param = (S)
(S)
proto.max_stack = (S)
proto.code = (S)
proto.const = (S)
proto.subs = (S, src)
proto.lines = (S)
(S)
(S)
_, v (proto.code)
v.is_K
v.const = proto.const[v.Bx + ]
v.is_KB v.const_B = proto.const[v.B - ]
v.is_KC v.const_C = proto.const[v.C - ]
proto
(src)
rdr_func
little
size_int
size_szt
size_ins
size_num
flag_int
stream = {
index = ,
source = src,
}
((stream, ) == , )
((stream) == , )
((stream) == , )
little = (stream) ~=
size_int = (stream)
size_szt = (stream)
size_ins = (stream)
size_num = (stream)
flag_int = (stream) ~=
rdr_func = little rd_int_le rd_int_be
stream.s_int = (size_int, rdr_func)
stream.s_szt = (size_szt, rdr_func)
stream.s_ins = (size_ins, rdr_func)
flag_int
stream.s_num = (size_num, rdr_func)
float_types[size_num]
stream.s_num = (size_num, float_types[size_num][little ])
()
(stream, )
(list, index)
i, uv (list)
uv.index >= index
uv.value = uv.store[uv.index]
uv.store = uv
uv.index =
list[i] =
(list, index, memory)
prev = list[index]
prev
prev = {index = index, store = memory}
list[index] = prev
prev
(failed, err)
src = failed.source
line = failed.lines[failed.pc - ]
(.(, src, line, err), )
(state, env, upvals)
code = state.code
subs = state.subs
vararg = state.vararg
top_index = -
open_list = {}
memory = state.memory
pc = state.pc
inst = code[pc]
op = inst.op
pc = pc +
op <
op <
op <
op <
i = inst.A, inst.B memory[i] =
op >
uv = upvals[inst.B]
memory[inst.A] = uv.store[uv.index]
lhs, rhs
inst.is_KB
lhs = inst.const_B
lhs = memory[inst.B]
inst.is_KC
rhs = inst.const_C
rhs = memory[inst.C]
memory[inst.A] = lhs + rhs
op >
op <
op >
A = inst.A
B = inst.B
index
inst.is_KC
index = inst.const_C
index = memory[inst.C]
memory[A + ] = memory[B]
memory[A] = memory[B][index]
memory[inst.A] = env[inst.const]
op >
index
inst.is_KC
index = inst.const_C
index = memory[inst.C]
memory[inst.A] = memory[inst.B][index]
lhs, rhs
inst.is_KB
lhs = inst.const_B
lhs = memory[inst.B]
inst.is_KC
rhs = inst.const_C
rhs = memory[inst.C]
memory[inst.A] = lhs - rhs
memory[inst.A] = memory[inst.B]
op >
op <
op <
env[inst.const] = memory[inst.A]
op >
op <
A = inst.A
B = inst.B
C = inst.C
params
B ==
params = top_index - A
params = B -
ret_list = .(memory[A](.(memory, A + , A + params)))
ret_num = ret_list.n
C ==
top_index = A + ret_num -
ret_num = C -
.(ret_list, , ret_num, A, memory)
uv = upvals[inst.B]
uv.store[uv.index] = memory[inst.A]
lhs, rhs
inst.is_KB
lhs = inst.const_B
lhs = memory[inst.B]
inst.is_KC
rhs = inst.const_C
rhs = memory[inst.C]
memory[inst.A] = lhs * rhs
op >
op <
op >
A = inst.A
B = inst.B
params
B ==
params = top_index - A
params = B -
(open_list, )
memory[A](.(memory, A + , A + params))
index, value
inst.is_KB
index = inst.const_B
index = memory[inst.B]
inst.is_KC
value = inst.const_C
value = memory[inst.C]
memory[inst.A][index] = value
op >
memory[inst.A] = {}
lhs, rhs
inst.is_KB
lhs = inst.const_B
lhs = memory[inst.B]
inst.is_KC
rhs = inst.const_C
rhs = memory[inst.C]
memory[inst.A] = lhs / rhs
memory[inst.A] = inst.const
A = inst.A
step = memory[A + ]
index = memory[A] + step
limit = memory[A + ]
loops
step == .(step)
loops = index <= limit
loops = index >= limit
loops
memory[A] = index
memory[A + ] = index
pc = pc + inst.sBx
op >
op <
op <
op <
memory[inst.A] = #memory[inst.B]
op >
op <
A = inst.A
B = inst.B
len
B ==
len = top_index - A +
len = B -
(open_list, )
.(memory, A, A + len - )
B = inst.B
str = memory[B]
i = B + , inst.C str = str .. memory[i]
memory[inst.A] = str
lhs, rhs
inst.is_KB
lhs = inst.const_B
lhs = memory[inst.B]
inst.is_KC
rhs = inst.const_C
rhs = memory[inst.C]
memory[inst.A] = lhs % rhs
op >
op <
op >
(open_list, inst.A)
lhs, rhs
inst.is_KB
lhs = inst.const_B
lhs = memory[inst.B]
inst.is_KC
rhs = inst.const_C
rhs = memory[inst.C]
(lhs == rhs) == (inst.A ~= ) pc = pc + code[pc].sBx
pc = pc +
op >
lhs, rhs
inst.is_KB
lhs = inst.const_B
lhs = memory[inst.B]
inst.is_KC
rhs = inst.const_C
rhs = memory[inst.C]
(lhs < rhs) == (inst.A ~= ) pc = pc + code[pc].sBx
pc = pc +
lhs, rhs
inst.is_KB
lhs = inst.const_B
lhs = memory[inst.B]
inst.is_KC
rhs = inst.const_C
rhs = memory[inst.C]
memory[inst.A] = lhs ^ rhs
memory[inst.A] = inst.B ~=
inst.C ~= pc = pc +
op >
op <
op <
lhs, rhs
inst.is_KB
lhs = inst.const_B
lhs = memory[inst.B]
inst.is_KC
rhs = inst.const_C
rhs = memory[inst.C]
(lhs <= rhs) == (inst.A ~= ) pc = pc + code[pc].sBx
pc = pc +
op >
op <
sub = subs[inst.Bx + ]
nups = sub.num_upval
uvlist
nups ~=
uvlist = {}
i = , nups
pseudo = code[pc + i - ]
pseudo.op == OPCODE_RM[]
uvlist[i - ] = (open_list, pseudo.B, memory)
pseudo.op == OPCODE_RM[]
uvlist[i - ] = upvals[pseudo.B]
pc = pc + nups
memory[inst.A] = (sub, env, uvlist)
A = inst.A
B = inst.B
( memory[B]) ~= (inst.C ~= )
memory[A] = memory[B]
pc = pc + code[pc].sBx
pc = pc +
memory[inst.A] = -memory[inst.B]
op >
op <
op >
A = inst.A
len = inst.B
len ==
len = vararg.len
top_index = A + len -
.(vararg.list, , len, A, memory)
A = inst.A
init, limit, step
init = ((memory[A]), )
limit = ((memory[A + ]), )
step = ((memory[A + ]), )
memory[A] = init - step
memory[A + ] = limit
memory[A + ] = step
pc = pc + inst.sBx
op >
A = inst.A
C = inst.C
len = inst.B
tab = memory[A]
offset
len == len = top_index - A
C ==
C = inst[pc].value
pc = pc +
offset = (C - ) * FIELDS_PER_FLUSH
.(memory, A + , A + len, offset + , tab)
memory[inst.A] = memory[inst.B]
( memory[inst.A]) ~= (inst.C ~= ) pc = pc + code[pc].sBx
pc = pc +
A = inst.A
base = A +
vals = {memory[A](memory[A + ], memory[A + ])}
.(vals, , inst.C, base, memory)
memory[base] ~=
memory[A + ] = memory[base]
pc = pc + code[pc].sBx
pc = pc +
pc = pc + inst.sBx
state.pc = pc
(proto, env, upval)
(...)
passed = .(...)
memory = .(proto.max_stack)
vararg = {len = , list = {}}
.(passed, , proto.num_param, , memory)
proto.num_param < passed.n
start = proto.num_param +
len = passed.n - proto.num_param
vararg.len = len
.(passed, start, start + len - , , vararg.list)
state = {vararg = vararg, memory = memory, code = proto.code, subs = proto.subs, pc = }
result = .((run_lua_func, state, env, upval))
result[]
.(result, , result.n)
failed = {pc = state.pc, source = proto.source, lines = proto.lines}
(failed, result[])
wrapped
(bCode, env)
((bCode), env ())
fake_module_scripts[] = module_script
= .(, )
.Name =
()
luaZ = {}
luaY = {}
luaX = {}
luaP = {}
luaU = {}
luaK = {}
size_size_t =
(test)
test ()
luaZ:(buff)
b = buff
()
b
data = b
b =
data
luaZ:(source)
LUAL_BUFFERSIZE =
pos =
()
buff = source:(pos, pos + LUAL_BUFFERSIZE - )
pos = .(#source + , pos + LUAL_BUFFERSIZE)
buff
luaZ:(reader, data)
reader
z = {}
z.reader = reader
z.data = data
z.name = name
data data == z.n = z.n = #data
z.p =
z
luaZ:(z)
buff = z.()
z.data = buff
buff buff ==
z.n, z.p = #buff - ,
.(buff, , )
luaZ:(z)
n, p = z.n, z.p +
n >
z.n, z.p = n - , p
.(z.data, p, p)
self:(z)
luaX.RESERVED =
luaX.MAXSRC =
luaX.MAX_INT =
luaX.LUA_QS =
luaX.LUA_COMPAT_LSTR =
luaX:()
tokens, enums = {}, {}
v .(self.RESERVED, )
_, _, tok, str = .(v, )
tokens[tok] = str
enums[str] = tok
self.tokens = tokens
self.enums = enums
luaX:(source, bufflen)
out
first = .(source, , )
first ==
out = .(source, , bufflen)
first ==
source = .(source, )
bufflen = bufflen - #
l = #source
out =
l > bufflen
source = .(source, + l - bufflen)
out = out..
out = out..source
len = .(source, )
len = len (len - ) #source
bufflen = bufflen - #()
len > bufflen len = bufflen
out =
len < #source
out = out..string.(source, , len)..
out = out..source
out = out..
out
luaX:(ls, token)
.(token, , ) ~=
.(token, )
.(, .(token))
token
self.tokens[token]
luaX:(ls, msg, token)
(ls, token)
token ==
token ==
token ==
ls.buff
self:(ls, token)
buff = self:(ls.source, self.MAXSRC)
msg = .(, buff, ls.linenumber, msg)
token
msg = .(..self.LUA_QS, msg, (ls, token))
(msg)
luaX:(ls, msg)
self:(ls, msg, ls.t.token)
luaX:(ls)
ls.current == ls.current ==
luaX:(ls)
old = ls.current
self:(ls)
self:(ls) ls.current ~= old
self:(ls)
ls.linenumber = ls.linenumber +
ls.linenumber >= self.MAX_INT
self:(ls, )
luaX:(L, ls, z, source)
ls ls = {}
ls.lookahead ls.lookahead = {}
ls.t ls.t = {}
ls.decpoint =
ls.L = L
ls.lookahead.token =
ls.z = z
ls.fs =
ls.linenumber =
ls.lastline =
ls.source = source
self:(ls)
luaX:(ls, set)
.(set, ls.current, , )
self:(ls)
luaX:(ls)
ls.lastline = ls.linenumber
ls.lookahead.token ~=
ls.t.seminfo = ls.lookahead.seminfo
ls.t.token = ls.lookahead.token
ls.lookahead.token =
ls.t.token = self:(ls, ls.t)
luaX:(ls)
ls.lookahead.token = self:(ls, ls.lookahead)
luaX:(ls)
c = luaZ:(ls.z)
ls.current = c
c
luaX:(ls, c)
buff = ls.buff
ls.buff = buff..c
luaX:(ls)
self:(ls, ls.current)
self:(ls)
luaX:(s)
result = (s)
result result
.(.(s, , )) ==
result = (s, )
result result
luaX:(ls, from, to)
result, buff = , ls.buff
p = , #buff
c = .(buff, p, p)
c == from c = to
result = result..c
ls.buff = result
luaX:(ls, Token)
old = ls.decpoint
self:(ls, old, ls.decpoint)
seminfo = self:(ls.buff)
Token.seminfo = seminfo
seminfo
self:(ls, ls.decpoint, )
self:(ls, , )
luaX:(ls, Token)
self:(ls)
.(ls.current, ) ls.current ~=
self:(ls, )
self:(ls, )
.(ls.current, ) ls.current ==
self:(ls)
self:(ls, , ls.decpoint)
seminfo = self:(ls.buff)
Token.seminfo = seminfo
seminfo
self:(ls, Token)
luaX:(ls)
count =
s = ls.current
self:(ls)
ls.current ==
self:(ls)
count = count +
(ls.current == s) count (-count) -
luaX:(ls, Token, sep)
cont =
self:(ls)
self:(ls)
self:(ls)
c = ls.current
c ==
self:(ls, Token
, )
c ==
self.LUA_COMPAT_LSTR
self:(ls) == sep
self:(ls)
cont = cont +
self.LUA_COMPAT_LSTR ==
sep ==
self:(ls, , )
c ==
self:(ls) == sep
self:(ls)
self.LUA_COMPAT_LSTR self.LUA_COMPAT_LSTR ==
cont = cont -
sep == cont >=
self:(ls)
self:(ls, )
self:(ls)
Token ls.buff =
Token
self:(ls)
self:(ls)
Token
p = + sep
Token.seminfo = .(ls.buff, p, -p)
luaX:(ls, del, Token)
self:(ls)
ls.current ~= del
c = ls.current
c ==
self:(ls, , )
self:(ls)
self:(ls, , )
c ==
c = self:(ls)
self:(ls)
self:(ls, )
self:(ls)
c ~=
i = .(, c, , )
i
self:(ls, .(, i, i))
self:(ls)
.(c, )
self:(ls)
c, i = ,
c = * c + ls.current
self:(ls)
i = i +
i >= .(ls.current, )
c >
self:(ls, , )
self:(ls, .(c))
self:(ls)
self:(ls)
Token.seminfo = .(ls.buff, , -)
luaX:(ls, Token)
ls.buff =
c = ls.current
self:(ls)
self:(ls)
c ==
c = self:(ls)
c ~=
sep = -
self:(ls) ==
sep = self:(ls)
ls.buff =
sep >=
self:(ls, , sep)
ls.buff =
self:(ls) ls.current ~=
self:(ls)
c ==
sep = self:(ls)
sep >=
self:(ls, Token, sep)
sep == -
self:(ls, , )
---------------------------------
elseif c == "=" then
c = self:nextc(ls)
if c ~= "=" then return "="
else self:nextc(ls); return "TK_EQ" end
----------------------------------------------------------------
elseif c == "<" then
c = self:nextc(ls)
if c ~= "=" then return "<"
else self:nextc(ls); return "TK_LE" end
----------------------------------------------------------------
elseif c == ">" then
c = self:nextc(ls)
if c ~= "=" then return ">"
else self:nextc(ls); return "TK_GE" end
----------------------------------------------------------------
elseif c == "~" then
c = self:nextc(ls)
if c ~= "=" then return "~"
else self:nextc(ls); return "TK_NE" end
----------------------------------------------------------------
elseif c == "\"" or c == "'" then
self:read_string(ls, c, Token)
return "TK_STRING"
----------------------------------------------------------------
elseif c == "." then
c = self:save_and_next(ls)
if self:check_next(ls, ".") then
if self:check_next(ls, ".") then
return "TK_DOTS" -- ...
else return "TK_CONCAT" -- ..
end
elseif not string.find(c, "%d") then
return "."
else
self:read_numeral(ls, Token)
return "TK_NUMBER"
end
----------------------------------------------------------------
elseif c == "EOZ" then
return "TK_EOS"
----------------------------------------------------------------
else -- default
if string.find(c, "%s") then
-- lua_assert(self:currIsNewline(ls))
self:nextc(ls)
elseif string.find(c, "%d") then
self:read_numeral(ls, Token)
return "TK_NUMBER"
elseif string.find(c, "[_%a]") then
-- identifier or reserved word
repeat
c = self:save_and_next(ls)
until c == "EOZ" or not string.find(c, "[_%w]")
local ts = ls.buff
local tok = self.enums[ts]
if tok then return tok end -- reserved word?
Token.seminfo = ts
return "TK_NAME"
else
self:nextc(ls)
return c -- single-char tokens (+ - / ...)
end
----------------------------------------------------------------
end--if c
end--while
end
--dofile("lopcodes.lua")
--[[
===========================================================================
We assume that instructions are unsigned numbers.
All instructions have an opcode in the first 6 bits.
Instructions can have the following fields:
'A' : 8 bits
'B' : 9 bits
'C' : 9 bits
'Bx' : 18 bits ('B' and 'C' together)
'sBx' : signed Bx
A signed argument is represented in excess K; that is, the number
value is the unsigned value minus K. K is exactly the maximum value
for that argument (so that -max is represented by 0, and +max is
represented by 2*max), which is half the maximum for the corresponding
unsigned argument.
===========================================================================
--]]
luaP.OpMode = { iABC = 0, iABx = 1, iAsBx = 2 } -- basic instruction format
------------------------------------------------------------------------
-- size and position of opcode arguments.
-- * WARNING size and position is hard-coded elsewhere in this script
------------------------------------------------------------------------
luaP.SIZE_C = 9
luaP.SIZE_B = 9
luaP.SIZE_Bx = luaP.SIZE_C + luaP.SIZE_B
luaP.SIZE_A = 8
luaP.SIZE_OP = 6
luaP.POS_OP = 0
luaP.POS_A = luaP.POS_OP + luaP.SIZE_OP
luaP.POS_C = luaP.POS_A + luaP.SIZE_A
luaP.POS_B = luaP.POS_C + luaP.SIZE_C
luaP.POS_Bx = luaP.POS_C
------------------------------------------------------------------------
-- limits for opcode arguments.
-- we use (signed) int to manipulate most arguments,
-- so they must fit in LUAI_BITSINT-1 bits (-1 for sign)
------------------------------------------------------------------------
-- removed "#if SIZE_Bx < BITS_INT-1" test, assume this script is
-- running on a Lua VM with double or int as LUA_NUMBER
luaP.MAXARG_Bx = math.ldexp(1, luaP.SIZE_Bx) - 1
luaP.MAXARG_sBx = math.floor(luaP.MAXARG_Bx / 2) -- 'sBx' is signed
luaP.MAXARG_A = math.ldexp(1, luaP.SIZE_A) - 1
luaP.MAXARG_B = math.ldexp(1, luaP.SIZE_B) - 1
luaP.MAXARG_C = math.ldexp(1, luaP.SIZE_C) - 1
-- creates a mask with 'n' 1 bits at position 'p'
-- MASK1(n,p) deleted, not required
-- creates a mask with 'n' 0 bits at position 'p'
-- MASK0(n,p) deleted, not required
--[[--------------------------------------------------------------------
Visual representation for reference:
31 | | | 0 bit position
+-----+-----+-----+----------+
| B | C | A | Opcode | iABC format
+-----+-----+-----+----------+
- 9 - 9 - 8 - 6 - field sizes
+-----+-----+-----+----------+
| [s]Bx | A | Opcode | iABx | iAsBx format
+-----+-----+-----+----------+
----------------------------------------------------------------------]]
------------------------------------------------------------------------
-- the following macros help to manipulate instructions
-- * changed to a table object representation, very clean compared to
-- the [nightmare] alternatives of using a number or a string
-- * Bx is a separate element from B and C, since there is never a need
-- to split Bx in the parser or code generator
------------------------------------------------------------------------
-- these accept or return opcodes in the form of string names
function luaP:GET_OPCODE(i) return self.ROpCode[i.OP] end
function luaP:SET_OPCODE(i, o) i.OP = self.OpCode[o] end
function luaP:GETARG_A(i) return i.A end
function luaP:SETARG_A(i, u) i.A = u end
function luaP:GETARG_B(i) return i.B end
function luaP:SETARG_B(i, b) i.B = b end
function luaP:GETARG_C(i) return i.C end
function luaP:SETARG_C(i, b) i.C = b end
function luaP:GETARG_Bx(i) return i.Bx end
function luaP:SETARG_Bx(i, b) i.Bx = b end
function luaP:GETARG_sBx(i) return i.Bx - self.MAXARG_sBx end
function luaP:SETARG_sBx(i, b) i.Bx = b + self.MAXARG_sBx end
function luaP:CREATE_ABC(o,a,b,c)
return {OP = self.OpCode[o], A = a, B = b, C = c}
end
function luaP:CREATE_ABx(o,a,bc)
return {OP = self.OpCode[o], A = a, Bx = bc}
end
------------------------------------------------------------------------
-- create an instruction from a number (for OP_SETLIST)
------------------------------------------------------------------------
function luaP:CREATE_Inst(c)
local o = c % 64
c = (c - o) / 64
local a = c % 256
c = (c - a) / 256
return self:CREATE_ABx(o, a, c)
end
------------------------------------------------------------------------
-- returns a 4-char string little-endian encoded form of an instruction
------------------------------------------------------------------------
function luaP:Instruction(i)
if i.Bx then
-- change to OP/A/B/C format
i.C = i.Bx % 512
i.B = (i.Bx - i.C) / 512
end
local I = i.A * 64 + i.OP
local c0 = I % 256
I = i.C * 64 + (I - c0) / 256 -- 6 bits of A left
local c1 = I % 256
I = i.B * 128 + (I - c1) / 256 -- 7 bits of C left
local c2 = I % 256
local c3 = (I - c2) / 256
return string.char(c0, c1, c2, c3)
end
------------------------------------------------------------------------
-- decodes a 4-char little-endian string into an instruction struct
------------------------------------------------------------------------
function luaP:DecodeInst(x)
local byte = string.byte
local i = {}
local I = byte(x, 1)
local op = I % 64
i.OP = op
I = byte(x, 2) * 4 + (I - op) / 64 -- 2 bits of c0 left
local a = I % 256
i.A = a
I = byte(x, 3) * 4 + (I - a) / 256 -- 2 bits of c1 left
local c = I % 512
i.C = c
i.B = byte(x, 4) * 2 + (I - c) / 512 -- 1 bits of c2 left
local opmode = self.OpMode[tonumber(string.sub(self.opmodes[op + 1], 7, 7))]
if opmode ~= "iABC" then
i.Bx = i.B * 512 + i.C
end
return i
end
------------------------------------------------------------------------
-- Macros to operate RK indices
-- * these use arithmetic instead of bit ops
------------------------------------------------------------------------
-- this bit 1 means constant (0 means register)
luaP.BITRK = math.ldexp(1, luaP.SIZE_B - 1)
-- test whether value is a constant
function luaP:ISK(x) return x >= self.BITRK end
-- gets the index of the constant
function luaP:INDEXK(r) return x - self.BITRK end
luaP.MAXINDEXRK = luaP.BITRK - 1
-- code a constant index as a RK value
function luaP:RKASK(x) return x + self.BITRK end
------------------------------------------------------------------------
-- invalid register that fits in 8 bits
------------------------------------------------------------------------
luaP.NO_REG = luaP.MAXARG_A
------------------------------------------------------------------------
-- R(x) - register
-- Kst(x) - constant (in constant table)
-- RK(x) == if ISK(x) then Kst(INDEXK(x)) else R(x)
------------------------------------------------------------------------
------------------------------------------------------------------------
-- grep "ORDER OP" if you change these enums
------------------------------------------------------------------------
--[[--------------------------------------------------------------------
Lua virtual machine opcodes (enum OpCode):
------------------------------------------------------------------------
name args description
------------------------------------------------------------------------
OP_MOVE A B R(A) := R(B)
OP_LOADK A Bx R(A) := Kst(Bx)
OP_LOADBOOL A B C R(A) := (Bool)B; if (C) pc++
OP_LOADNIL A B R(A) := ... := R(B) := nil
OP_GETUPVAL A B R(A) := UpValue[B]
OP_GETGLOBAL A Bx R(A) := Gbl[Kst(Bx)]
OP_GETTABLE A B C R(A) := R(B)[RK(C)]
OP_SETGLOBAL A Bx Gbl[Kst(Bx)] := R(A)
OP_SETUPVAL A B UpValue[B] := R(A)
OP_SETTABLE A B C R(A)[RK(B)] := RK(C)
OP_NEWTABLE A B C R(A) := {} (size = B,C)
OP_SELF A B C R(A+1) := R(B); R(A) := R(B)[RK(C)]
OP_ADD A B C R(A) := RK(B) + RK(C)
OP_SUB A B C R(A) := RK(B) - RK(C)
OP_MUL A B C R(A) := RK(B) * RK(C)
OP_DIV A B C R(A) := RK(B) / RK(C)
OP_MOD A B C R(A) := RK(B) % RK(C)
OP_POW A B C R(A) := RK(B) ^ RK(C)
OP_UNM A B R(A) := -R(B)
OP_NOT A B R(A) := not R(B)
OP_LEN A B R(A) := length of R(B)
OP_CONCAT A B C R(A) := R(B).. ... ..R(C)
OP_JMP sBx pc+=sBx
OP_EQ A B C if ((RK(B) == RK(C)) ~= A) then pc++
OP_LT A B C if ((RK(B) < RK(C)) ~= A) then pc++
OP_LE A B C if ((RK(B) <= RK(C)) ~= A) then pc++
OP_TEST A C if not (R(A) <=> C) then pc++
OP_TESTSET A B C if (R(B) <=> C) then R(A) := R(B) else pc++
OP_CALL A B C R(A), ... ,R(A+C-2) := R(A)(R(A+1), ... ,R(A+B-1))
OP_TAILCALL A B C return R(A)(R(A+1), ... ,R(A+B-1))
OP_RETURN A B return R(A), ... ,R(A+B-2) (see note)
OP_FORLOOP A sBx R(A)+=R(A+2);
if R(A) <?= R(A+1) then { pc+=sBx; R(A+3)=R(A) }
OP_FORPREP A sBx R(A)-=R(A+2); pc+=sBx
OP_TFORLOOP A C R(A+3), ... ,R(A+2+C) := R(A)(R(A+1), R(A+2));
if R(A+3) ~= nil then R(A+2)=R(A+3) else pc++
OP_SETLIST A B C R(A)[(C-1)*FPF+i] := R(A+i), 1 <= i <= B
OP_CLOSE A close all variables in the stack up to (>=) R(A)
OP_CLOSURE A Bx R(A) := closure(KPROTO[Bx], R(A), ... ,R(A+n))
OP_VARARG A B R(A), R(A+1), ..., R(A+B-1) = vararg
----------------------------------------------------------------------]]
luaP.opnames = {} -- opcode names
luaP.OpCode = {} -- lookup name -> number
luaP.ROpCode = {} -- lookup number -> name
------------------------------------------------------------------------
-- ORDER OP
------------------------------------------------------------------------
local i = 0
for v in string.gmatch([[
MOVE LOADK LOADBOOL LOADNIL GETUPVAL
GETGLOBAL GETTABLE SETGLOBAL SETUPVAL SETTABLE
NEWTABLE SELF ADD SUB MUL
DIV MOD POW UNM NOT
LEN CONCAT JMP EQ LT
LE TEST TESTSET CALL TAILCALL
RETURN FORLOOP FORPREP TFORLOOP SETLIST
CLOSE CLOSURE VARARG
]], "%S+") do
local n = "OP_"..v
luaP.opnames[i] = v
luaP.OpCode[n] = i
luaP.ROpCode[i] = n
i = i + 1
end
luaP.NUM_OPCODES = i
--[[
===========================================================================
Notes:
(*) In OP_CALL, if (B == 0) then B = top. C is the number of returns - 1,
and can be 0: OP_CALL then sets 'top' to last_result+1, so
next open instruction (OP_CALL, OP_RETURN, OP_SETLIST) may use 'top'.
(*) In OP_VARARG, if (B == 0) then use actual number of varargs and
set top (like in OP_CALL with C == 0).
(*) In OP_RETURN, if (B == 0) then return up to 'top'
(*) In OP_SETLIST, if (B == 0) then B = 'top';
if (C == 0) then next 'instruction' is real C
(*) For comparisons, A specifies what condition the test should accept
(true or false).
(*) All 'skips' (pc++) assume that next instruction is a jump
===========================================================================
--]]
--[[--------------------------------------------------------------------
masks for instruction properties. The format is:
bits 0-1: op mode
bits 2-3: C arg mode
bits 4-5: B arg mode
bit 6: instruction set register A
bit 7: operator is a test
for OpArgMask:
OpArgN - argument is not used
OpArgU - argument is used
OpArgR - argument is a register or a jump offset
OpArgK - argument is a constant or register/constant
----------------------------------------------------------------------]]
-- was enum OpArgMask
luaP.OpArgMask = { OpArgN = 0, OpArgU = 1, OpArgR = 2, OpArgK = 3 }
------------------------------------------------------------------------
-- e.g. to compare with symbols, luaP:getOpMode(...) == luaP.OpCode.iABC
-- * accepts opcode parameter as strings, e.g. "OP_MOVE"
------------------------------------------------------------------------
function luaP:getOpMode(m)
return self.opmodes[self.OpCode[m]] % 4
end
function luaP:getBMode(m)
return math.floor(self.opmodes[self.OpCode[m]] / 16) % 4
end
function luaP:getCMode(m)
return math.floor(self.opmodes[self.OpCode[m]] / 4) % 4
end
function luaP:testAMode(m)
return math.floor(self.opmodes[self.OpCode[m]] / 64) % 2
end
function luaP:testTMode(m)
return math.floor(self.opmodes[self.OpCode[m]] / 128)
end
-- luaP_opnames[] is set above, as the luaP.opnames table
-- number of list items to accumulate before a SETLIST instruction
luaP.LFIELDS_PER_FLUSH = 50
------------------------------------------------------------------------
-- build instruction properties array
-- * deliberately coded to look like the C equivalent
------------------------------------------------------------------------
local function opmode(t, a, b, c, m)
local luaP = luaP
return t * 128 + a * 64 +
luaP.OpArgMask[b] * 16 + luaP.OpArgMask[c] * 4 + luaP.OpMode[m]
end
-- ORDER OP
luaP.opmodes = {
-- T A B C mode opcode
opmode(0, 1, "OpArgK", "OpArgN", "iABx"), -- OP_LOADK
opmode(0, 1, "OpArgU", "OpArgU", "iABC"), -- OP_LOADBOOL
opmode(0, 1, "OpArgR", "OpArgN", "iABC"), -- OP_LOADNIL
opmode(0, 1, "OpArgU", "OpArgN", "iABC"), -- OP_GETUPVAL
opmode(0, 1, "OpArgK", "OpArgN", "iABx"), -- OP_GETGLOBAL
opmode(0, 1, "OpArgR", "OpArgK", "iABC"), -- OP_GETTABLE
opmode(0, 0, "OpArgK", "OpArgN", "iABx"), -- OP_SETGLOBAL
opmode(0, 0, "OpArgU", "OpArgN", "iABC"), -- OP_SETUPVAL
opmode(0, 0, "OpArgK", "OpArgK", "iABC"), -- OP_SETTABLE
opmode(0, 1, "OpArgU", "OpArgU", "iABC"), -- OP_NEWTABLE
opmode(0, 1, "OpArgR", "OpArgK", "iABC"), -- OP_SELF
opmode(0, 1, "OpArgK", "OpArgK", "iABC"), -- OP_ADD
opmode(0, 1, "OpArgK", "OpArgK", "iABC"), -- OP_SUB
opmode(0, 1, "OpArgK", "OpArgK", "iABC"), -- OP_MUL
opmode(0, 1, "OpArgK", "OpArgK", "iABC"), -- OP_DIV
opmode(0, 1, "OpArgK", "OpArgK", "iABC"), -- OP_MOD
opmode(0, 1, "OpArgK", "OpArgK", "iABC"), -- OP_POW
opmode(0, 1, "OpArgR", "OpArgN", "iABC"), -- OP_UNM
opmode(0, 1, "OpArgR", "OpArgN", "iABC"), -- OP_NOT
opmode(0, 1, "OpArgR", "OpArgN", "iABC"), -- OP_LEN
opmode(0, 1, "OpArgR", "OpArgR", "iABC"), -- OP_CONCAT
opmode(0, 0, "OpArgR", "OpArgN", "iAsBx"), -- OP_JMP
opmode(1, 0, "OpArgK", "OpArgK", "iABC"), -- OP_EQ
opmode(1, 0, "OpArgK", "OpArgK", "iABC"), -- OP_LT
opmode(1, 0, "OpArgK", "OpArgK", "iABC"), -- OP_LE
opmode(1, 1, "OpArgR", "OpArgU", "iABC"), -- OP_TEST
opmode(1, 1, "OpArgR", "OpArgU", "iABC"), -- OP_TESTSET
opmode(0, 1, "OpArgU", "OpArgU", "iABC"), -- OP_CALL
opmode(0, 1, "OpArgU", "OpArgU", "iABC"), -- OP_TAILCALL
opmode(0, 0, "OpArgU", "OpArgN", "iABC"), -- OP_RETURN
opmode(0, 1, "OpArgR", "OpArgN", "iAsBx"), -- OP_FORLOOP
opmode(0, 1, "OpArgR", "OpArgN", "iAsBx"), -- OP_FORPREP
opmode(1, 0, "OpArgN", "OpArgU", "iABC"), -- OP_TFORLOOP
opmode(0, 0, "OpArgU", "OpArgU", "iABC"), -- OP_SETLIST
opmode(0, 0, "OpArgN", "OpArgN", "iABC"), -- OP_CLOSE
opmode(0, 1, "OpArgU", "OpArgN", "iABx"), -- OP_CLOSURE
opmode(0, 1, "OpArgU", "OpArgN", "iABC"), -- OP_VARARG
}
-- an awkward way to set a zero-indexed table...
luaP.opmodes[0] =
opmode(0, 1, "OpArgR", "OpArgN", "iABC") -- OP_MOVE
--dofile("ldump.lua")
--requires luaP
-- mark for precompiled code ('<esc>Lua') (from lua.h)
luaU.LUA_SIGNATURE = "\27Lua"
-- constants used by dumper (from lua.h)
luaU.LUA_TNUMBER = 3
luaU.LUA_TSTRING = 4
luaU.LUA_TNIL = 0
luaU.LUA_TBOOLEAN = 1
luaU.LUA_TNONE = -1
-- constants for header of binary files (from lundump.h)
luaU.LUAC_VERSION = 0x51 -- this is Lua 5.1
luaU.LUAC_FORMAT = 0 -- this is the official format
luaU.LUAC_HEADERSIZE = 12 -- size of header of binary files
--[[--------------------------------------------------------------------
-- Additional functions to handle chunk writing
-- * to use make_setS and make_setF, see test_ldump.lua elsewhere
----------------------------------------------------------------------]]
------------------------------------------------------------------------
-- create a chunk writer that writes to a string
-- * returns the writer function and a table containing the string
-- * to get the final result, look in buff.data
------------------------------------------------------------------------
function luaU:make_setS()
local buff = {}
buff.data = ""
local writer =
function(s, buff) -- chunk writer
if not s then return 0 end
buff.data = buff.data..s
-- print (#buff.data, #s, string.byte(s,1,1), s)
return 0
end
return writer, buff
end
------------------------------------------------------------------------
-- create a chunk writer that writes to a file
-- * returns the writer function and a table containing the file handle
-- * if a nil is passed, then writer should close the open file
------------------------------------------------------------------------
function luaU:make_setF(filename)
local buff = {}
buff.h = io.open(filename, "wb")
if not buff.h then return nil end
local writer =
function(s, buff) -- chunk writer
if not buff.h then return 0 end
if not s then
if buff.h:close() then return 0 end
else
if buff.h:write(s) then return 0 end
end
return 1
end
return writer, buff
end
------------------------------------------------------------------------
-- works like the lobject.h version except that TObject used in these
-- scripts only has a 'value' field, no 'tt' field (native types used)
------------------------------------------------------------------------
function luaU:ttype(o)
local tt = type(o.value)
if tt == "number" then return self.LUA_TNUMBER
elseif tt == "string" then return self.LUA_TSTRING
elseif tt == "nil" then return self.LUA_TNIL
elseif tt == "boolean" then return self.LUA_TBOOLEAN
else
return self.LUA_TNONE -- the rest should not appear
end
end
-----------------------------------------------------------------------
-- converts a IEEE754 double number to an 8-byte little-endian string
-- * luaU:from_double() and luaU:from_int() are adapted from ChunkBake
-- * supports +/- Infinity, but not denormals or NaNs
-----------------------------------------------------------------------
function luaU:from_double(x)
local function grab_byte(v)
local c = v % 256
return (v - c) / 256, string.char(c)
end
local sign = 0
if x < 0 then sign = 1; x = -x end
local mantissa, exponent = math.frexp(x)
if x == 0 then -- zero
mantissa, exponent = 0, 0
elseif x == 1/0 then
mantissa, exponent = 0, 2047
else
mantissa = (mantissa * 2 - 1) * math.ldexp(0.5, 53)
exponent = exponent + 1022
end
local v, byte = "" -- convert to bytes
x = math.floor(mantissa)
for i = 1,6 do
x, byte = grab_byte(x); v = v..byte -- 47:0
end
x, byte = grab_byte(exponent * 16 + x); v = v..byte -- 55:48
x, byte = grab_byte(sign * 128 + x); v = v..byte -- 63:56
return v
end
-----------------------------------------------------------------------
-- converts a number to a little-endian 32-bit integer string
-- * input value assumed to not overflow, can be signed/unsigned
-----------------------------------------------------------------------
function luaU:from_int(x)
local v = ""
x = math.floor(x)
if x < 0 then x = 4294967296 + x end -- ULONG_MAX+1
for i = 1, 4 do
local c = x % 256
v = v..string.char(c); x = math.floor(x / 256)
end
return v
end
--[[--------------------------------------------------------------------
-- Functions to make a binary chunk
-- * many functions have the size parameter removed, since output is
-- in the form of a string and some sizes are implicit or hard-coded
----------------------------------------------------------------------]]
--[[--------------------------------------------------------------------
-- struct DumpState:
-- L -- lua_State (not used in this script)
-- writer -- lua_Writer (chunk writer function)
-- data -- void* (chunk writer context or data already written)
-- strip -- if true, don't write any debug information
-- status -- if non-zero, an error has occured
----------------------------------------------------------------------]]
------------------------------------------------------------------------
-- dumps a block of bytes
-- * lua_unlock(D.L), lua_lock(D.L) unused
------------------------------------------------------------------------
function luaU:DumpBlock(b, D)
if D.status == 0 then
-- lua_unlock(D->L);
D.status = D.write(b, D.data)
-- lua_lock(D->L);
end
end
------------------------------------------------------------------------
-- dumps a char
------------------------------------------------------------------------
function luaU:DumpChar(y, D)
self:DumpBlock(string.char(y), D)
end
------------------------------------------------------------------------
-- dumps a 32-bit signed or unsigned integer (for int) (hard-coded)
------------------------------------------------------------------------
function luaU:DumpInt(x, D)
self:DumpBlock(self:from_int(x), D)
end
------------------------------------------------------------------------
-- dumps a 32-bit signed or unsigned integer (for int) (hard-coded)
------------------------------------------------------------------------
function luaU:DumpSizeT(x, D)
self:DumpBlock(self:from_int(x), D)
if size_size_t == 8 then
self:DumpBlock(self:from_int(0), D)
end
end
------------------------------------------------------------------------
-- dumps a lua_Number (hard-coded as a double)
------------------------------------------------------------------------
function luaU:DumpNumber(x, D)
self:DumpBlock(self:from_double(x), D)
end
------------------------------------------------------------------------
-- dumps a Lua string (size type is hard-coded)
------------------------------------------------------------------------
function luaU:DumpString(s, D)
if s == nil then
self:DumpSizeT(0, D)
else
s = s.."\0" -- include trailing '\0'
self:DumpSizeT(#s, D)
self:DumpBlock(s, D)
end
end
------------------------------------------------------------------------
-- dumps instruction block from function prototype
------------------------------------------------------------------------
function luaU:DumpCode(f, D)
local n = f.sizecode
--was DumpVector
self:DumpInt(n, D)
for i = 0, n - 1 do
self:DumpBlock(luaP:Instruction(f.code[i]), D)
end
end
------------------------------------------------------------------------
-- dump constant pool from function prototype
-- * bvalue(o), nvalue(o) and rawtsvalue(o) macros removed
------------------------------------------------------------------------
function luaU:DumpConstants(f, D)
local n = f.sizek
self:DumpInt(n, D)
for i = 0, n - 1 do
local o = f.k[i] -- TValue
local tt = self:ttype(o)
self:DumpChar(tt, D)
if tt == self.LUA_TNIL then
elseif tt == self.LUA_TBOOLEAN then
self:DumpChar(o.value and 1 or 0, D)
elseif tt == self.LUA_TNUMBER then
self:DumpNumber(o.value, D)
elseif tt == self.LUA_TSTRING then
self:DumpString(o.value, D)
else
--lua_assert(0) -- cannot happen
end
end
n = f.sizep
self:DumpInt(n, D)
for i = 0, n - 1 do
self:DumpFunction(f.p[i], f.source, D)
end
end
------------------------------------------------------------------------
-- dump debug information
------------------------------------------------------------------------
function luaU:DumpDebug(f, D)
local n
n = D.strip and 0 or f.sizelineinfo -- dump line information
--was DumpVector
self:DumpInt(n, D)
for i = 0, n - 1 do
self:DumpInt(f.lineinfo[i], D)
end
n = D.strip and 0 or f.sizelocvars -- dump local information
self:DumpInt(n, D)
for i = 0, n - 1 do
self:DumpString(f.locvars[i].varname, D)
self:DumpInt(f.locvars[i].startpc, D)
self:DumpInt(f.locvars[i].endpc, D)
end
n = D.strip and 0 or f.sizeupvalues -- dump upvalue information
self:DumpInt(n, D)
for i = 0, n - 1 do
self:DumpString(f.upvalues[i], D)
end
end
------------------------------------------------------------------------
-- dump child function prototypes from function prototype
------------------------------------------------------------------------
function luaU:DumpFunction(f, p, D)
local source = f.source
if source == p or D.strip then source = nil end
self:DumpString(source, D)
self:DumpInt(f.lineDefined, D)
self:DumpInt(f.lastlinedefined, D)
self:DumpChar(f.nups, D)
self:DumpChar(f.numparams, D)
self:DumpChar(f.is_vararg, D)
self:DumpChar(f.maxstacksize, D)
self:DumpCode(f, D)
self:DumpConstants(f, D)
self:DumpDebug(f, D)
end
------------------------------------------------------------------------
-- dump Lua header section (some sizes hard-coded)
------------------------------------------------------------------------
function luaU:DumpHeader(D)
local h = self:header()
assert(#h == self.LUAC_HEADERSIZE) -- fixed buffer now an assert
self:DumpBlock(h, D)
end
------------------------------------------------------------------------
-- make header (from lundump.c)
-- returns the header string
------------------------------------------------------------------------
function luaU:header()
local x = 1
return self.LUA_SIGNATURE..
string.char(
self.LUAC_VERSION,
self.LUAC_FORMAT,
x, -- endianness (1=little)
4, -- sizeof(int)
size_size_t, -- sizeof(size_t)
4, -- sizeof(Instruction)
8, -- sizeof(lua_Number)
0) -- is lua_Number integral?
end
------------------------------------------------------------------------
-- dump Lua function as precompiled chunk
-- (lua_State* L, const Proto* f, lua_Writer w, void* data, int strip)
-- * w, data are created from make_setS, make_setF
------------------------------------------------------------------------
function luaU:dump(L, f, w, data, strip)
local D = {} -- DumpState
D.L = L
D.write = w
D.data = data
D.strip = strip
D.status = 0
self:DumpHeader(D)
self:DumpFunction(f, nil, D)
-- added: for a chunk writer writing to a file, this final call with
-- nil data is to indicate to the writer to close the file
D.write(nil, D.data)
return D.status
end
--dofile("lcode.lua")
------------------------------------------------------------------------
-- constants used by code generator
------------------------------------------------------------------------
-- maximum stack for a Lua function
luaK.MAXSTACK = 250 -- (from llimits.h)
--[[--------------------------------------------------------------------
-- other functions
----------------------------------------------------------------------]]
------------------------------------------------------------------------
-- emulation of TValue macros (these are from lobject.h)
-- * TValue is a table since lcode passes references around
-- * tt member field removed, using Lua's type() instead
-- * for setsvalue, sethvalue, parameter L (deleted here) in lobject.h
-- is used in an assert for testing, see checkliveness(g,obj)
------------------------------------------------------------------------
function luaK:ttisnumber(o)
if o then return type(o.value) == "number" else return false end
end
function luaK:nvalue(o) return o.value end
function luaK:setnilvalue(o) o.value = nil end
function luaK:setsvalue(o, x) o.value = x end
luaK.setnvalue = luaK.setsvalue
luaK.sethvalue = luaK.setsvalue
luaK.setbvalue = luaK.setsvalue
------------------------------------------------------------------------
-- The luai_num* macros define the primitive operations over numbers.
-- * this is not the entire set of primitive operations from luaconf.h
-- * used in luaK:constfolding()
------------------------------------------------------------------------
function luaK:numadd(a, b) return a + b end
function luaK:numsub(a, b) return a - b end
function luaK:nummul(a, b) return a * b end
function luaK:numdiv(a, b) return a / b end
function luaK:nummod(a, b) return a % b end
-- ((a) - floor((a)/(b))*(b)) /* actual, for reference */
function luaK:numpow(a, b) return a ^ b end
function luaK:numunm(a) return -a end
function luaK:numisnan(a) return not a == a end
-- a NaN cannot equal another NaN
--[[--------------------------------------------------------------------
-- code generator functions
----------------------------------------------------------------------]]
------------------------------------------------------------------------
-- Marks the end of a patch list. It is an invalid value both as an absolute
-- address, and as a list link (would link an element to itself).
------------------------------------------------------------------------
luaK.NO_JUMP = -1
------------------------------------------------------------------------
-- grep "ORDER OPR" if you change these enums
------------------------------------------------------------------------
luaK.BinOpr = {
OPR_ADD = 0, OPR_SUB = 1, OPR_MUL = 2, OPR_DIV = 3, OPR_MOD = 4, OPR_POW = 5,
OPR_CONCAT = 6,
OPR_NE = 7, OPR_EQ = 8,
OPR_LT = 9, OPR_LE = 10, OPR_GT = 11, OPR_GE = 12,
OPR_AND = 13, OPR_OR = 14,
OPR_NOBINOPR = 15,
}
-- * UnOpr is used by luaK:prefix's op argument, but not directly used
-- because the function receives the symbols as strings, e.g. "OPR_NOT"
luaK.UnOpr = {
OPR_MINUS = 0, OPR_NOT = 1, OPR_LEN = 2, OPR_NOUNOPR = 3
}
------------------------------------------------------------------------
-- returns the instruction object for given e (expdesc), was a macro
------------------------------------------------------------------------
function luaK:getcode(fs, e)
return fs.f.code[e.info]
end
------------------------------------------------------------------------
-- codes an instruction with a signed Bx (sBx) field, was a macro
-- * used in luaK:jump(), (lparser) luaY:forbody()
------------------------------------------------------------------------
function luaK:codeAsBx(fs, o, A, sBx)
return self:codeABx(fs, o, A, sBx + luaP.MAXARG_sBx)
end
------------------------------------------------------------------------
-- set the expdesc e instruction for multiple returns, was a macro
------------------------------------------------------------------------
function luaK:setmultret(fs, e)
self:setreturns(fs, e, luaY.LUA_MULTRET)
end
------------------------------------------------------------------------
-- there is a jump if patch lists are not identical, was a macro
-- * used in luaK:exp2reg(), luaK:exp2anyreg(), luaK:exp2val()
------------------------------------------------------------------------
function luaK:hasjumps(e)
return e.t ~= e.f
end
------------------------------------------------------------------------
-- true if the expression is a constant number (for constant folding)
-- * used in constfolding(), infix()
------------------------------------------------------------------------
function luaK:isnumeral(e)
return e.k == "VKNUM" and e.t == self.NO_JUMP and e.f == self.NO_JUMP
end
------------------------------------------------------------------------
-- codes loading of nil, optimization done if consecutive locations
-- * used in luaK:discharge2reg(), (lparser) luaY:adjust_assign()
------------------------------------------------------------------------
function luaK:_nil(fs, from, n)
if fs.pc > fs.lasttarget then -- no jumps to current position?
if fs.pc == 0 then -- function start?
if from >= fs.nactvar then
return -- positions are already clean
end
else
local previous = fs.f.code[fs.pc - 1]
if luaP:GET_OPCODE(previous) == "OP_LOADNIL" then
local pfrom = luaP:GETARG_A(previous)
local pto = luaP:GETARG_B(previous)
if pfrom <= from and from <= pto + 1 then -- can connect both?
if from + n - 1 > pto then
luaP:SETARG_B(previous, from + n - 1)
end
return
end
end
end
end
self:codeABC(fs, "OP_LOADNIL", from, from + n - 1, 0) -- else no optimization
end
------------------------------------------------------------------------
--
-- * used in multiple locations
------------------------------------------------------------------------
function luaK:jump(fs)
local jpc = fs.jpc -- save list of jumps to here
fs.jpc = self.NO_JUMP
local j = self:codeAsBx(fs, "OP_JMP", 0, self.NO_JUMP)
j = self:concat(fs, j, jpc) -- keep them on hold
return j
end
------------------------------------------------------------------------
-- codes a RETURN instruction
-- * used in luaY:close_func(), luaY:retstat()
------------------------------------------------------------------------
function luaK:ret(fs, first, nret)
self:codeABC(fs, "OP_RETURN", first, nret + 1, 0)
end
------------------------------------------------------------------------
--
-- * used in luaK:jumponcond(), luaK:codecomp()
------------------------------------------------------------------------
function luaK:condjump(fs, op, A, B, C)
self:codeABC(fs, op, A, B, C)
return self:jump(fs)
end
------------------------------------------------------------------------
--
-- * used in luaK:patchlistaux(), luaK:concat()
------------------------------------------------------------------------
function luaK:fixjump(fs, pc, dest)
local jmp = fs.f.code[pc]
local offset = dest - (pc + 1)
lua_assert(dest ~= self.NO_JUMP)
if math.abs(offset) > luaP.MAXARG_sBx then
luaX:syntaxerror(fs.ls, "control structure too long")
end
luaP:SETARG_sBx(jmp, offset)
end
------------------------------------------------------------------------
-- returns current 'pc' and marks it as a jump target (to avoid wrong
-- optimizations with consecutive instructions not in the same basic block).
-- * used in multiple locations
-- * fs.lasttarget tested only by luaK:_nil() when optimizing OP_LOADNIL
------------------------------------------------------------------------
function luaK:getlabel(fs)
fs.lasttarget = fs.pc
return fs.pc
end
------------------------------------------------------------------------
--
-- * used in luaK:need_value(), luaK:removevalues(), luaK:patchlistaux(),
-- luaK:concat()
------------------------------------------------------------------------
function luaK:getjump(fs, pc)
local offset = luaP:GETARG_sBx(fs.f.code[pc])
if offset == self.NO_JUMP then -- point to itself represents end of list
return self.NO_JUMP -- end of list
else
return (pc + 1) + offset -- turn offset into absolute position
end
end
------------------------------------------------------------------------
--
-- * used in luaK:need_value(), luaK:patchtestreg(), luaK:invertjump()
------------------------------------------------------------------------
function luaK:getjumpcontrol(fs, pc)
local pi = fs.f.code[pc]
local ppi = fs.f.code[pc - 1]
if pc >= 1 and luaP:testTMode(luaP:GET_OPCODE(ppi)) ~= 0 then
return ppi
else
return pi
end
end
------------------------------------------------------------------------
-- check whether list has any jump that do not produce a value
-- (or produce an inverted value)
-- * return value changed to boolean
-- * used only in luaK:exp2reg()
------------------------------------------------------------------------
function luaK:need_value(fs, list)
while list ~= self.NO_JUMP do
local i = self:getjumpcontrol(fs, list)
if luaP:GET_OPCODE(i) ~= "OP_TESTSET" then return true end
list = self:getjump(fs, list)
end
return false -- not found
end
------------------------------------------------------------------------
--
-- * used in luaK:removevalues(), luaK:patchlistaux()
------------------------------------------------------------------------
function luaK:patchtestreg(fs, node, reg)
local i = self:getjumpcontrol(fs, node)
if luaP:GET_OPCODE(i) ~= "OP_TESTSET" then
return false -- cannot patch other instructions
end
if reg ~= luaP.NO_REG and reg ~= luaP:GETARG_B(i) then
luaP:SETARG_A(i, reg)
else -- no register to put value or register already has the value
-- due to use of a table as i, i cannot be replaced by another table
-- so the following is required; there is no change to ARG_C
luaP:SET_OPCODE(i, "OP_TEST")
local b = luaP:GETARG_B(i)
luaP:SETARG_A(i, b)
luaP:SETARG_B(i, 0)
-- *i = CREATE_ABC(OP_TEST, GETARG_B(*i), 0, GETARG_C(*i)); /* C */
end
return true
end
------------------------------------------------------------------------
--
-- * used only in luaK:codenot()
------------------------------------------------------------------------
function luaK:removevalues(fs, list)
while list ~= self.NO_JUMP do
self:patchtestreg(fs, list, luaP.NO_REG)
list = self:getjump(fs, list)
end
end
------------------------------------------------------------------------
--
-- * used in luaK:dischargejpc(), luaK:patchlist(), luaK:exp2reg()
------------------------------------------------------------------------
function luaK:patchlistaux(fs, list, vtarget, reg, dtarget)
while list ~= self.NO_JUMP do
local _next = self:getjump(fs, list)
if self:patchtestreg(fs, list, reg) then
self:fixjump(fs, list, vtarget)
else
self:fixjump(fs, list, dtarget) -- jump to default target
end
list = _next
end
end
------------------------------------------------------------------------
--
-- * used only in luaK:code()
------------------------------------------------------------------------
function luaK:dischargejpc(fs)
self:patchlistaux(fs, fs.jpc, fs.pc, luaP.NO_REG, fs.pc)
fs.jpc = self.NO_JUMP
end
------------------------------------------------------------------------
--
-- * used in (lparser) luaY:whilestat(), luaY:repeatstat(), luaY:forbody()
------------------------------------------------------------------------
function luaK:patchlist(fs, list, target)
if target == fs.pc then
self:patchtohere(fs, list)
else
lua_assert(target < fs.pc)
self:patchlistaux(fs, list, target, luaP.NO_REG, target)
end
end
------------------------------------------------------------------------
--
-- * used in multiple locations
------------------------------------------------------------------------
function luaK:patchtohere(fs, list)
self:getlabel(fs)
fs.jpc = self:concat(fs, fs.jpc, list)
end
------------------------------------------------------------------------
-- * l1 was a pointer, now l1 is returned and callee assigns the value
-- * used in multiple locations
------------------------------------------------------------------------
function luaK:concat(fs, l1, l2)
if l2 == self.NO_JUMP then return l1
elseif l1 == self.NO_JUMP then
return l2
else
local list = l1
local _next = self:getjump(fs, list)
while _next ~= self.NO_JUMP do -- find last element
list = _next
_next = self:getjump(fs, list)
end
self:fixjump(fs, list, l2)
end
return l1
end
------------------------------------------------------------------------
--
-- * used in luaK:reserveregs(), (lparser) luaY:forlist()
------------------------------------------------------------------------
function luaK:checkstack(fs, n)
local newstack = fs.freereg + n
if newstack > fs.f.maxstacksize then
if newstack >= self.MAXSTACK then
luaX:syntaxerror(fs.ls, "function or expression too complex")
end
fs.f.maxstacksize = newstack
end
end
------------------------------------------------------------------------
--
-- * used in multiple locations
------------------------------------------------------------------------
function luaK:reserveregs(fs, n)
self:checkstack(fs, n)
fs.freereg = fs.freereg + n
end
------------------------------------------------------------------------
--
-- * used in luaK:freeexp(), luaK:dischargevars()
------------------------------------------------------------------------
function luaK:freereg(fs, reg)
if not luaP:ISK(reg) and reg >= fs.nactvar then
fs.freereg = fs.freereg - 1
lua_assert(reg == fs.freereg)
end
end
------------------------------------------------------------------------
--
-- * used in multiple locations
------------------------------------------------------------------------
function luaK:freeexp(fs, e)
if e.k == "VNONRELOC" then
self:freereg(fs, e.info)
end
end
------------------------------------------------------------------------
-- * TODO NOTE implementation is not 100% correct, since the assert fails
-- * luaH_set, setobj deleted; direct table access used instead
-- * used in luaK:stringK(), luaK:numberK(), luaK:boolK(), luaK:nilK()
------------------------------------------------------------------------
function luaK:addk(fs, k, v)
local L = fs.L
local idx = fs.h[k.value]
--TValue *idx = luaH_set(L, fs->h, k); /* C */
local f = fs.f
if self:ttisnumber(idx) then
--TODO this assert currently FAILS (last tested for 5.0.2)
--lua_assert(fs.f.k[self:nvalue(idx)] == v)
--lua_assert(luaO_rawequalObj(&fs->f->k[cast_int(nvalue(idx))], v)); /* C */
return self:nvalue(idx)
else -- constant not found; create a new entry
idx = {}
self:setnvalue(idx, fs.nk)
fs.h[k.value] = idx
-- setnvalue(idx, cast_num(fs->nk)); /* C */
luaY:growvector(L, f.k, fs.nk, f.sizek, nil,
luaP.MAXARG_Bx, "constant table overflow")
-- loop to initialize empty f.k positions not required
f.k[fs.nk] = v
-- setobj(L, &f->k[fs->nk], v); /* C */
-- luaC_barrier(L, f, v); /* GC */
local nk = fs.nk
fs.nk = fs.nk + 1
return nk
end
end
------------------------------------------------------------------------
-- creates and sets a string object
-- * used in (lparser) luaY:codestring(), luaY:singlevar()
------------------------------------------------------------------------
function luaK:stringK(fs, s)
local o = {} -- TValue
self:setsvalue(o, s)
return self:addk(fs, o, o)
end
------------------------------------------------------------------------
-- creates and sets a number object
-- * used in luaK:prefix() for negative (or negation of) numbers
-- * used in (lparser) luaY:simpleexp(), luaY:fornum()
------------------------------------------------------------------------
function luaK:numberK(fs, r)
local o = {} -- TValue
self:setnvalue(o, r)
return self:addk(fs, o, o)
end
------------------------------------------------------------------------
-- creates and sets a boolean object
-- * used only in luaK:exp2RK()
------------------------------------------------------------------------
function luaK:boolK(fs, b)
local o = {} -- TValue
self:setbvalue(o, b)
return self:addk(fs, o, o)
end
------------------------------------------------------------------------
-- creates and sets a nil object
-- * used only in luaK:exp2RK()
------------------------------------------------------------------------
function luaK:nilK(fs)
local k, v = {}, {} -- TValue
self:setnilvalue(v)
-- cannot use nil as key; instead use table itself to represent nil
self:sethvalue(k, fs.h)
return self:addk(fs, k, v)
end
------------------------------------------------------------------------
--
-- * used in luaK:setmultret(), (lparser) luaY:adjust_assign()
------------------------------------------------------------------------
function luaK:setreturns(fs, e, nresults)
if e.k == "VCALL" then -- expression is an open function call?
luaP:SETARG_C(self:getcode(fs, e), nresults + 1)
elseif e.k == "VVARARG" then
luaP:SETARG_B(self:getcode(fs, e), nresults + 1);
luaP:SETARG_A(self:getcode(fs, e), fs.freereg);
luaK:reserveregs(fs, 1)
end
end
------------------------------------------------------------------------
--
-- * used in luaK:dischargevars(), (lparser) luaY:assignment()
------------------------------------------------------------------------
function luaK:setoneret(fs, e)
if e.k == "VCALL" then -- expression is an open function call?
e.k = "VNONRELOC"
e.info = luaP:GETARG_A(self:getcode(fs, e))
elseif e.k == "VVARARG" then
luaP:SETARG_B(self:getcode(fs, e), 2)
e.k = "VRELOCABLE" -- can relocate its simple result
end
end
------------------------------------------------------------------------
--
-- * used in multiple locations
------------------------------------------------------------------------
function luaK:dischargevars(fs, e)
local k = e.k
if k == "VLOCAL" then
e.k = "VNONRELOC"
elseif k == "VUPVAL" then
e.info = self:codeABC(fs, "OP_GETUPVAL", 0, e.info, 0)
e.k = "VRELOCABLE"
elseif k == "VGLOBAL" then
e.info = self:codeABx(fs, "OP_GETGLOBAL", 0, e.info)
e.k = "VRELOCABLE"
elseif k == "VINDEXED" then
self:freereg(fs, e.aux)
self:freereg(fs, e.info)
e.info = self:codeABC(fs, "OP_GETTABLE", 0, e.info, e.aux)
e.k = "VRELOCABLE"
elseif k == "VVARARG" or k == "VCALL" then
self:setoneret(fs, e)
else
-- there is one value available (somewhere)
end
end
------------------------------------------------------------------------
--
-- * used only in luaK:exp2reg()
------------------------------------------------------------------------
function luaK:code_label(fs, A, b, jump)
self:getlabel(fs) -- those instructions may be jump targets
return self:codeABC(fs, "OP_LOADBOOL", A, b, jump)
end
------------------------------------------------------------------------
--
-- * used in luaK:discharge2anyreg(), luaK:exp2reg()
------------------------------------------------------------------------
function luaK:discharge2reg(fs, e, reg)
self:dischargevars(fs, e)
local k = e.k
if k == "VNIL" then
self:_nil(fs, reg, 1)
elseif k == "VFALSE" or k == "VTRUE" then
self:codeABC(fs, "OP_LOADBOOL", reg, (e.k == "VTRUE") and 1 or 0, 0)
elseif k == "VK" then
self:codeABx(fs, "OP_LOADK", reg, e.info)
elseif k == "VKNUM" then
self:codeABx(fs, "OP_LOADK", reg, self:numberK(fs, e.nval))
elseif k == "VRELOCABLE" then
local pc = self:getcode(fs, e)
luaP:SETARG_A(pc, reg)
elseif k == "VNONRELOC" then
if reg ~= e.info then
self:codeABC(fs, "OP_MOVE", reg, e.info, 0)
end
else
lua_assert(e.k == "VVOID" or e.k == "VJMP")
return -- nothing to do...
end
e.info = reg
e.k = "VNONRELOC"
end
------------------------------------------------------------------------
--
-- * used in luaK:jumponcond(), luaK:codenot()
------------------------------------------------------------------------
function luaK:discharge2anyreg(fs, e)
if e.k ~= "VNONRELOC" then
self:reserveregs(fs, 1)
self:discharge2reg(fs, e, fs.freereg - 1)
end
end
------------------------------------------------------------------------
--
-- * used in luaK:exp2nextreg(), luaK:exp2anyreg(), luaK:storevar()
------------------------------------------------------------------------
function luaK:exp2reg(fs, e, reg)
self:discharge2reg(fs, e, reg)
if e.k == "VJMP" then
e.t = self:concat(fs, e.t, e.info) -- put this jump in 't' list
end
if self:hasjumps(e) then
local final -- position after whole expression
local p_f = self.NO_JUMP -- position of an eventual LOAD false
local p_t = self.NO_JUMP -- position of an eventual LOAD true
if self:need_value(fs, e.t) or self:need_value(fs, e.f) then
local fj = (e.k == "VJMP") and self.NO_JUMP or self:jump(fs)
p_f = self:code_label(fs, reg, 0, 1)
p_t = self:code_label(fs, reg, 1, 0)
self:patchtohere(fs, fj)
end
final = self:getlabel(fs)
self:patchlistaux(fs, e.f, final, reg, p_f)
self:patchlistaux(fs, e.t, final, reg, p_t)
end
e.f, e.t = self.NO_JUMP, self.NO_JUMP
e.info = reg
e.k = "VNONRELOC"
end
------------------------------------------------------------------------
--
-- * used in multiple locations
------------------------------------------------------------------------
function luaK:exp2nextreg(fs, e)
self:dischargevars(fs, e)
self:freeexp(fs, e)
self:reserveregs(fs, 1)
self:exp2reg(fs, e, fs.freereg - 1)
end
------------------------------------------------------------------------
--
-- * used in multiple locations
------------------------------------------------------------------------
function luaK:exp2anyreg(fs, e)
self:dischargevars(fs, e)
if e.k == "VNONRELOC" then
if not self:hasjumps(e) then -- exp is already in a register
return e.info
end
if e.info >= fs.nactvar then -- reg. is not a local?
self:exp2reg(fs, e, e.info) -- put value on it
return e.info
end
end
self:exp2nextreg(fs, e) -- default
return e.info
end
------------------------------------------------------------------------
--
-- * used in luaK:exp2RK(), luaK:prefix(), luaK:posfix()
-- * used in (lparser) luaY:yindex()
------------------------------------------------------------------------
function luaK:exp2val(fs, e)
if self:hasjumps(e) then
self:exp2anyreg(fs, e)
else
self:dischargevars(fs, e)
end
end
------------------------------------------------------------------------
--
-- * used in multiple locations
------------------------------------------------------------------------
function luaK:exp2RK(fs, e)
self:exp2val(fs, e)
local k = e.k
if k == "VKNUM" or k == "VTRUE" or k == "VFALSE" or k == "VNIL" then
if fs.nk <= luaP.MAXINDEXRK then -- constant fit in RK operand?
-- converted from a 2-deep ternary operator expression
if e.k == "VNIL" then
e.info = self:nilK(fs)
else
e.info = (e.k == "VKNUM") and self:numberK(fs, e.nval)
or self:boolK(fs, e.k == "VTRUE")
end
e.k = "VK"
return luaP:RKASK(e.info)
end
elseif k == "VK" then
if e.info <= luaP.MAXINDEXRK then -- constant fit in argC?
return luaP:RKASK(e.info)
end
else
-- default
end
-- not a constant in the right range: put it in a register
return self:exp2anyreg(fs, e)
end
------------------------------------------------------------------------
--
-- * used in (lparser) luaY:assignment(), luaY:localfunc(), luaY:funcstat()
------------------------------------------------------------------------
function luaK:storevar(fs, var, ex)
local k = var.k
if k == "VLOCAL" then
self:freeexp(fs, ex)
self:exp2reg(fs, ex, var.info)
return
elseif k == "VUPVAL" then
local e = self:exp2anyreg(fs, ex)
self:codeABC(fs, "OP_SETUPVAL", e, var.info, 0)
elseif k == "VGLOBAL" then
local e = self:exp2anyreg(fs, ex)
self:codeABx(fs, "OP_SETGLOBAL", e, var.info)
elseif k == "VINDEXED" then
local e = self:exp2RK(fs, ex)
self:codeABC(fs, "OP_SETTABLE", var.info, var.aux, e)
else
lua_assert(0) -- invalid var kind to store
end
self:freeexp(fs, ex)
end
------------------------------------------------------------------------
--
-- * used only in (lparser) luaY:primaryexp()
------------------------------------------------------------------------
function luaK:_self(fs, e, key)
self:exp2anyreg(fs, e)
self:freeexp(fs, e)
local func = fs.freereg
self:reserveregs(fs, 2)
self:codeABC(fs, "OP_SELF", func, e.info, self:exp2RK(fs, key))
self:freeexp(fs, key)
e.info = func
e.k = "VNONRELOC"
end
------------------------------------------------------------------------
--
-- * used in luaK:goiftrue(), luaK:codenot()
------------------------------------------------------------------------
function luaK:invertjump(fs, e)
local pc = self:getjumpcontrol(fs, e.info)
lua_assert(luaP:testTMode(luaP:GET_OPCODE(pc)) ~= 0 and
luaP:GET_OPCODE(pc) ~= "OP_TESTSET" and
luaP:GET_OPCODE(pc) ~= "OP_TEST")
luaP:SETARG_A(pc, (luaP:GETARG_A(pc) == 0) and 1 or 0)
end
------------------------------------------------------------------------
--
-- * used in luaK:goiftrue(), luaK:goiffalse()
------------------------------------------------------------------------
function luaK:jumponcond(fs, e, cond)
if e.k == "VRELOCABLE" then
local ie = self:getcode(fs, e)
if luaP:GET_OPCODE(ie) == "OP_NOT" then
fs.pc = fs.pc - 1 -- remove previous OP_NOT
return self:condjump(fs, "OP_TEST", luaP:GETARG_B(ie), 0, cond and 0 or 1)
end
-- else go through
end
self:discharge2anyreg(fs, e)
self:freeexp(fs, e)
return self:condjump(fs, "OP_TESTSET", luaP.NO_REG, e.info, cond and 1 or 0)
end
------------------------------------------------------------------------
--
-- * used in luaK:infix(), (lparser) luaY:cond()
------------------------------------------------------------------------
function luaK:goiftrue(fs, e)
local pc -- pc of last jump
self:dischargevars(fs, e)
local k = e.k
if k == "VK" or k == "VKNUM" or k == "VTRUE" then
pc = self.NO_JUMP -- always true; do nothing
elseif k == "VFALSE" then
pc = self:jump(fs) -- always jump
elseif k == "VJMP" then
self:invertjump(fs, e)
pc = e.info
else
pc = self:jumponcond(fs, e, false)
end
e.f = self:concat(fs, e.f, pc) -- insert last jump in `f' list
self:patchtohere(fs, e.t)
e.t = self.NO_JUMP
end
------------------------------------------------------------------------
--
-- * used in luaK:infix()
------------------------------------------------------------------------
function luaK:goiffalse(fs, e)
local pc -- pc of last jump
self:dischargevars(fs, e)
local k = e.k
if k == "VNIL" or k == "VFALSE"then
pc = self.NO_JUMP -- always false; do nothing
elseif k == "VTRUE" then
pc = self:jump(fs) -- always jump
elseif k == "VJMP" then
pc = e.info
else
pc = self:jumponcond(fs, e, true)
end
e.t = self:concat(fs, e.t, pc) -- insert last jump in `t' list
self:patchtohere(fs, e.f)
e.f = self.NO_JUMP
end
------------------------------------------------------------------------
--
-- * used only in luaK:prefix()
------------------------------------------------------------------------
function luaK:codenot(fs, e)
self:dischargevars(fs, e)
local k = e.k
if k == "VNIL" or k == "VFALSE" then
e.k = "VTRUE"
elseif k == "VK" or k == "VKNUM" or k == "VTRUE" then
e.k = "VFALSE"
elseif k == "VJMP" then
self:invertjump(fs, e)
elseif k == "VRELOCABLE" or k == "VNONRELOC" then
self:discharge2anyreg(fs, e)
self:freeexp(fs, e)
e.info = self:codeABC(fs, "OP_NOT", 0, e.info, 0)
e.k = "VRELOCABLE"
else
lua_assert(0) -- cannot happen
end
-- interchange true and false lists
e.f, e.t = e.t, e.f
self:removevalues(fs, e.f)
self:removevalues(fs, e.t)
end
------------------------------------------------------------------------
--
-- * used in (lparser) luaY:field(), luaY:primaryexp()
------------------------------------------------------------------------
function luaK:indexed(fs, t, k)
t.aux = self:exp2RK(fs, k)
t.k = "VINDEXED"
end
------------------------------------------------------------------------
--
-- * used only in luaK:codearith()
------------------------------------------------------------------------
function luaK:constfolding(op, e1, e2)
local r
if not self:isnumeral(e1) or not self:isnumeral(e2) then return false end
local v1 = e1.nval
local v2 = e2.nval
if op == "OP_ADD" then
r = self:numadd(v1, v2)
elseif op == "OP_SUB" then
r = self:numsub(v1, v2)
elseif op == "OP_MUL" then
r = self:nummul(v1, v2)
elseif op == "OP_DIV" then
if v2 == 0 then return false end -- do not attempt to divide by 0
r = self:numdiv(v1, v2)
elseif op == "OP_MOD" then
if v2 == 0 then return false end -- do not attempt to divide by 0
r = self:nummod(v1, v2)
elseif op == "OP_POW" then
r = self:numpow(v1, v2)
elseif op == "OP_UNM" then
r = self:numunm(v1)
elseif op == "OP_LEN" then
return false -- no constant folding for 'len'
else
lua_assert(0)
r = 0
end
if self:numisnan(r) then return false end -- do not attempt to produce NaN
e1.nval = r
return true
end
------------------------------------------------------------------------
--
-- * used in luaK:prefix(), luaK:posfix()
------------------------------------------------------------------------
function luaK:codearith(fs, op, e1, e2)
if self:constfolding(op, e1, e2) then
return
else
local o2 = (op ~= "OP_UNM" and op ~= "OP_LEN") and self:exp2RK(fs, e2) or 0
local o1 = self:exp2RK(fs, e1)
if o1 > o2 then
self:freeexp(fs, e1)
self:freeexp(fs, e2)
else
self:freeexp(fs, e2)
self:freeexp(fs, e1)
end
e1.info = self:codeABC(fs, op, 0, o1, o2)
e1.k = "VRELOCABLE"
end
end
------------------------------------------------------------------------
--
-- * used only in luaK:posfix()
------------------------------------------------------------------------
function luaK:codecomp(fs, op, cond, e1, e2)
local o1 = self:exp2RK(fs, e1)
local o2 = self:exp2RK(fs, e2)
self:freeexp(fs, e2)
self:freeexp(fs, e1)
if cond == 0 and op ~= "OP_EQ" then
-- exchange args to replace by `<' or `<='
o1, o2 = o2, o1 -- o1 <==> o2
cond = 1
end
e1.info = self:condjump(fs, op, cond, o1, o2)
e1.k = "VJMP"
end
------------------------------------------------------------------------
--
-- * used only in (lparser) luaY:subexpr()
------------------------------------------------------------------------
function luaK:prefix(fs, op, e)
local e2 = {} -- expdesc
e2.t, e2.f = self.NO_JUMP, self.NO_JUMP
e2.k = "VKNUM"
e2.nval = 0
if op == "OPR_MINUS" then
if not self:isnumeral(e) then
self:exp2anyreg(fs, e) -- cannot operate on non-numeric constants
end
self:codearith(fs, "OP_UNM", e, e2)
elseif op == "OPR_NOT" then
self:codenot(fs, e)
elseif op == "OPR_LEN" then
self:exp2anyreg(fs, e) -- cannot operate on constants
self:codearith(fs, "OP_LEN", e, e2)
else
lua_assert(0)
end
end
------------------------------------------------------------------------
--
-- * used only in (lparser) luaY:subexpr()
------------------------------------------------------------------------
function luaK:infix(fs, op, v)
if op == "OPR_AND" then
self:goiftrue(fs, v)
elseif op == "OPR_OR" then
self:goiffalse(fs, v)
elseif op == "OPR_CONCAT" then
self:exp2nextreg(fs, v) -- operand must be on the 'stack'
elseif op == "OPR_ADD" or op == "OPR_SUB" or
op == "OPR_MUL" or op == "OPR_DIV" or
op == "OPR_MOD" or op == "OPR_POW" then
if not self:isnumeral(v) then self:exp2RK(fs, v) end
else
self:exp2RK(fs, v)
end
end
------------------------------------------------------------------------
--
-- * used only in (lparser) luaY:subexpr()
------------------------------------------------------------------------
-- table lookups to simplify testing
luaK.arith_op = {
OPR_ADD = "OP_ADD", OPR_SUB = "OP_SUB", OPR_MUL = "OP_MUL",
OPR_DIV = "OP_DIV", OPR_MOD = "OP_MOD", OPR_POW = "OP_POW",
}
luaK.comp_op = {
OPR_EQ = "OP_EQ", OPR_NE = "OP_EQ", OPR_LT = "OP_LT",
OPR_LE = "OP_LE", OPR_GT = "OP_LT", OPR_GE = "OP_LE",
}
luaK.comp_cond = {
OPR_EQ = 1, OPR_NE = 0, OPR_LT = 1,
OPR_LE = 1, OPR_GT = 0, OPR_GE = 0,
}
function luaK:posfix(fs, op, e1, e2)
-- needed because e1 = e2 doesn't copy values...
-- * in 5.0.x, only k/info/aux/t/f copied, t for AND, f for OR
-- but here, all elements are copied for completeness' sake
local function copyexp(e1, e2)
e1.k = e2.k
e1.info = e2.info; e1.aux = e2.aux
e1.nval = e2.nval
e1.t = e2.t; e1.f = e2.f
end
if op == "OPR_AND" then
lua_assert(e1.t == self.NO_JUMP) -- list must be closed
self:dischargevars(fs, e2)
e2.f = self:concat(fs, e2.f, e1.f)
copyexp(e1, e2)
elseif op == "OPR_OR" then
lua_assert(e1.f == self.NO_JUMP) -- list must be closed
self:dischargevars(fs, e2)
e2.t = self:concat(fs, e2.t, e1.t)
copyexp(e1, e2)
elseif op == "OPR_CONCAT" then
self:exp2val(fs, e2)
if e2.k == "VRELOCABLE" and luaP:GET_OPCODE(self:getcode(fs, e2)) == "OP_CONCAT" then
lua_assert(e1.info == luaP:GETARG_B(self:getcode(fs, e2)) - 1)
self:freeexp(fs, e1)
luaP:SETARG_B(self:getcode(fs, e2), e1.info)
e1.k = "VRELOCABLE"
e1.info = e2.info
else
self:exp2nextreg(fs, e2) -- operand must be on the 'stack'
self:codearith(fs, "OP_CONCAT", e1, e2)
end
else
-- the following uses a table lookup in place of conditionals
local arith = self.arith_op[op]
if arith then
self:codearith(fs, arith, e1, e2)
else
local comp = self.comp_op[op]
if comp then
self:codecomp(fs, comp, self.comp_cond[op], e1, e2)
else
lua_assert(0)
end
end--if arith
end--if op
end
------------------------------------------------------------------------
-- adjusts debug information for last instruction written, in order to
-- change the line where item comes into existence
-- * used in (lparser) luaY:funcargs(), luaY:forbody(), luaY:funcstat()
------------------------------------------------------------------------
function luaK:fixline(fs, line)
fs.f.lineinfo[fs.pc - 1] = line
end
------------------------------------------------------------------------
-- general function to write an instruction into the instruction buffer,
-- sets debug information too
-- * used in luaK:codeABC(), luaK:codeABx()
-- * called directly by (lparser) luaY:whilestat()
------------------------------------------------------------------------
function luaK:code(fs, i, line)
local f = fs.f
self:dischargejpc(fs) -- 'pc' will change
-- put new instruction in code array
luaY:growvector(fs.L, f.code, fs.pc, f.sizecode, nil,
luaY.MAX_INT, "code size overflow")
f.code[fs.pc] = i
-- save corresponding line information
luaY:growvector(fs.L, f.lineinfo, fs.pc, f.sizelineinfo, nil,
luaY.MAX_INT, "code size overflow")
f.lineinfo[fs.pc] = line
local pc = fs.pc
fs.pc = fs.pc + 1
return pc
end
------------------------------------------------------------------------
-- writes an instruction of type ABC
-- * calls luaK:code()
------------------------------------------------------------------------
function luaK:codeABC(fs, o, a, b, c)
lua_assert(luaP:getOpMode(o) == luaP.OpMode.iABC)
lua_assert(luaP:getBMode(o) ~= luaP.OpArgMask.OpArgN or b == 0)
lua_assert(luaP:getCMode(o) ~= luaP.OpArgMask.OpArgN or c == 0)
return self:code(fs, luaP:CREATE_ABC(o, a, b, c), fs.ls.lastline)
end
------------------------------------------------------------------------
-- writes an instruction of type ABx
-- * calls luaK:code(), called by luaK:codeAsBx()
------------------------------------------------------------------------
function luaK:codeABx(fs, o, a, bc)
lua_assert(luaP:getOpMode(o) == luaP.OpMode.iABx or
luaP:getOpMode(o) == luaP.OpMode.iAsBx)
lua_assert(luaP:getCMode(o) == luaP.OpArgMask.OpArgN)
return self:code(fs, luaP:CREATE_ABx(o, a, bc), fs.ls.lastline)
end
------------------------------------------------------------------------
--
-- * used in (lparser) luaY:closelistfield(), luaY:lastlistfield()
------------------------------------------------------------------------
function luaK:setlist(fs, base, nelems, tostore)
local c = math.floor((nelems - 1)/luaP.LFIELDS_PER_FLUSH) + 1
local b = (tostore == luaY.LUA_MULTRET) and 0 or tostore
lua_assert(tostore ~= 0)
if c <= luaP.MAXARG_C then
self:codeABC(fs, "OP_SETLIST", base, b, c)
else
self:codeABC(fs, "OP_SETLIST", base, b, 0)
self:code(fs, luaP:CREATE_Inst(c), fs.ls.lastline)
end
fs.freereg = base + 1 -- free registers with list values
end
--dofile("lparser.lua")
--[[--------------------------------------------------------------------
-- Expression descriptor
-- * expkind changed to string constants; luaY:assignment was the only
-- function to use a relational operator with this enumeration
-- VVOID -- no value
-- VNIL -- no value
-- VTRUE -- no value
-- VFALSE -- no value
-- VK -- info = index of constant in 'k'
-- VKNUM -- nval = numerical value
-- VLOCAL -- info = local register
-- VUPVAL, -- info = index of upvalue in 'upvalues'
-- VGLOBAL -- info = index of table; aux = index of global name in 'k'
-- VINDEXED -- info = table register; aux = index register (or 'k')
-- VJMP -- info = instruction pc
-- VRELOCABLE -- info = instruction pc
-- VNONRELOC -- info = result register
-- VCALL -- info = instruction pc
-- VVARARG -- info = instruction pc
} ----------------------------------------------------------------------]]
--[[--------------------------------------------------------------------
-- * expdesc in Lua 5.1.x has a union u and another struct s; this Lua
-- implementation ignores all instances of u and s usage
-- struct expdesc:
-- k -- (enum: expkind)
-- info, aux -- (int, int)
-- nval -- (lua_Number)
-- t -- patch list of 'exit when true'
-- f -- patch list of 'exit when false'
----------------------------------------------------------------------]]
--[[--------------------------------------------------------------------
-- struct upvaldesc:
-- k -- (lu_byte)
-- info -- (lu_byte)
----------------------------------------------------------------------]]
--[[--------------------------------------------------------------------
-- state needed to generate code for a given function
-- struct FuncState:
-- f -- current function header (table: Proto)
-- h -- table to find (and reuse) elements in 'k' (table: Table)
-- prev -- enclosing function (table: FuncState)
-- ls -- lexical state (table: LexState)
-- L -- copy of the Lua state (table: lua_State)
-- bl -- chain of current blocks (table: BlockCnt)
-- pc -- next position to code (equivalent to 'ncode')
-- lasttarget -- 'pc' of last 'jump target'
-- jpc -- list of pending jumps to 'pc'
-- freereg -- first free register
-- nk -- number of elements in 'k'
-- np -- number of elements in 'p'
-- nlocvars -- number of elements in 'locvars'
-- nactvar -- number of active local variables
-- upvalues[LUAI_MAXUPVALUES] -- upvalues (table: upvaldesc)
-- actvar[LUAI_MAXVARS] -- declared-variable stack
----------------------------------------------------------------------]]
------------------------------------------------------------------------
-- constants used by parser
-- * picks up duplicate values from luaX if required
------------------------------------------------------------------------
luaY.LUA_QS = luaX.LUA_QS or "'%s'" -- (from luaconf.h)
luaY.SHRT_MAX = 32767 -- (from <limits.h>)
luaY.LUAI_MAXVARS = 200 -- (luaconf.h)
luaY.LUAI_MAXUPVALUES = 60 -- (luaconf.h)
luaY.MAX_INT = luaX.MAX_INT or 2147483645 -- (from llimits.h)
-- * INT_MAX-2 for 32-bit systems
luaY.LUAI_MAXCCALLS = 200 -- (from luaconf.h)
luaY.VARARG_HASARG = 1 -- (from lobject.h)
-- NOTE: HASARG_MASK is value-specific
luaY.HASARG_MASK = 2 -- this was added for a bitop in parlist()
luaY.VARARG_ISVARARG = 2
-- NOTE: there is some value-specific code that involves VARARG_NEEDSARG
luaY.VARARG_NEEDSARG = 4
luaY.LUA_MULTRET = -1 -- (lua.h)
--[[--------------------------------------------------------------------
-- other functions
----------------------------------------------------------------------]]
------------------------------------------------------------------------
-- LUA_QL describes how error messages quote program elements.
-- CHANGE it if you want a different appearance. (from luaconf.h)
------------------------------------------------------------------------
function luaY:LUA_QL(x)
return "'"..x.."'"
end
------------------------------------------------------------------------
-- this is a stripped-down luaM_growvector (from lmem.h) which is a
-- macro based on luaM_growaux (in lmem.c); all the following does is
-- reproduce the size limit checking logic of the original function
-- so that error behaviour is identical; all arguments preserved for
-- convenience, even those which are unused
-- * set the t field to nil, since this originally does a sizeof(t)
-- * size (originally a pointer) is never updated, their final values
-- are set by luaY:close_func(), so overall things should still work
------------------------------------------------------------------------
function luaY:growvector(L, v, nelems, size, t, limit, e)
if nelems >= limit then
error(e) -- was luaG_runerror
end
end
------------------------------------------------------------------------
-- initialize a new function prototype structure (from lfunc.c)
-- * used only in open_func()
------------------------------------------------------------------------
function luaY:newproto(L)
local f = {} -- Proto
-- luaC_link(L, obj2gco(f), LUA_TPROTO); /* GC */
f.k = {}
f.sizek = 0
f.p = {}
f.sizep = 0
f.code = {}
f.sizecode = 0
f.sizelineinfo = 0
f.sizeupvalues = 0
f.nups = 0
f.upvalues = {}
f.numparams = 0
f.is_vararg = 0
f.maxstacksize = 0
f.lineinfo = {}
f.sizelocvars = 0
f.locvars = {}
f.lineDefined = 0
f.lastlinedefined = 0
f.source = nil
return f
end
------------------------------------------------------------------------
-- converts an integer to a "floating point byte", represented as
-- (eeeeexxx), where the real value is (1xxx) * 2^(eeeee - 1) if
-- eeeee != 0 and (xxx) otherwise.
------------------------------------------------------------------------
function luaY:int2fb(x)
local e = 0 -- exponent
while x >= 16 do
x = math.floor((x + 1) / 2)
e = e + 1
end
if x < 8 then
return x
else
return ((e + 1) * 8) + (x - 8)
end
end
--[[--------------------------------------------------------------------
-- parser functions
----------------------------------------------------------------------]]
------------------------------------------------------------------------
-- true of the kind of expression produces multiple return values
------------------------------------------------------------------------
function luaY:hasmultret(k)
return k == "VCALL" or k == "VVARARG"
end
------------------------------------------------------------------------
-- convenience function to access active local i, returns entry
------------------------------------------------------------------------
function luaY:getlocvar(fs, i)
return fs.f.locvars[ fs.actvar[i] ]
end
------------------------------------------------------------------------
-- check a limit, string m provided as an error message
------------------------------------------------------------------------
function luaY:checklimit(fs, v, l, m)
if v > l then self:errorlimit(fs, l, m) end
end
--[[--------------------------------------------------------------------
-- nodes for block list (list of active blocks)
-- struct BlockCnt:
-- previous -- chain (table: BlockCnt)
-- breaklist -- list of jumps out of this loop
-- nactvar -- # active local variables outside the breakable structure
-- upval -- true if some variable in the block is an upvalue (boolean)
-- isbreakable -- true if 'block' is a loop (boolean)
----------------------------------------------------------------------]]
------------------------------------------------------------------------
-- prototypes for recursive non-terminal functions
------------------------------------------------------------------------
-- prototypes deleted; not required in Lua
------------------------------------------------------------------------
-- reanchor if last token is has a constant string, see close_func()
-- * used only in close_func()
------------------------------------------------------------------------
function luaY:anchor_token(ls)
if ls.t.token == "TK_NAME" or ls.t.token == "TK_STRING" then
-- not relevant to Lua implementation of parser
-- local ts = ls.t.seminfo
-- luaX_newstring(ls, getstr(ts), ts->tsv.len); /* C */
end
end
------------------------------------------------------------------------
-- throws a syntax error if token expected is not there
------------------------------------------------------------------------
function luaY:error_expected(ls, token)
luaX:syntaxerror(ls,
string.format(self.LUA_QS.." expected", luaX:token2str(ls, token)))
end
------------------------------------------------------------------------
-- prepares error message for display, for limits exceeded
-- * used only in checklimit()
------------------------------------------------------------------------
function luaY:errorlimit(fs, limit, what)
local msg = (fs.f.linedefined == 0) and
string.format("main function has more than %d %s", limit, what) or
string.format("function at line %d has more than %d %s",
fs.f.linedefined, limit, what)
luaX:lexerror(fs.ls, msg, 0)
end
------------------------------------------------------------------------
-- tests for a token, returns outcome
-- * return value changed to boolean
------------------------------------------------------------------------
function luaY:testnext(ls, c)
if ls.t.token == c then
luaX:next(ls)
return true
else
return false
end
end
------------------------------------------------------------------------
-- check for existence of a token, throws error if not found
------------------------------------------------------------------------
function luaY:check(ls, c)
if ls.t.token ~= c then
self:error_expected(ls, c)
end
end
------------------------------------------------------------------------
-- verify existence of a token, then skip it
------------------------------------------------------------------------
function luaY:checknext(ls, c)
self:check(ls, c)
luaX:next(ls)
end
------------------------------------------------------------------------
-- throws error if condition not matched
------------------------------------------------------------------------
function luaY:check_condition(ls, c, msg)
if not c then luaX:syntaxerror(ls, msg) end
end
------------------------------------------------------------------------
-- verifies token conditions are met or else throw error
------------------------------------------------------------------------
function luaY:check_match(ls, what, who, where)
if not self:testnext(ls, what) then
if where == ls.linenumber then
self:error_expected(ls, what)
else
luaX:syntaxerror(ls, string.format(
self.LUA_QS.." expected (to close "..self.LUA_QS.." at line %d)",
luaX:token2str(ls, what), luaX:token2str(ls, who), where))
end
end
end
------------------------------------------------------------------------
-- expect that token is a name, return the name
------------------------------------------------------------------------
function luaY:str_checkname(ls)
self:check(ls, "TK_NAME")
local ts = ls.t.seminfo
luaX:next(ls)
return ts
end
------------------------------------------------------------------------
-- initialize a struct expdesc, expression description data structure
------------------------------------------------------------------------
function luaY:init_exp(e, k, i)
e.f, e.t = luaK.NO_JUMP, luaK.NO_JUMP
e.k = k
e.info = i
end
------------------------------------------------------------------------
-- adds given string s in string pool, sets e as VK
------------------------------------------------------------------------
function luaY:codestring(ls, e, s)
self:init_exp(e, "VK", luaK:stringK(ls.fs, s))
end
------------------------------------------------------------------------
-- consume a name token, adds it to string pool, sets e as VK
------------------------------------------------------------------------
function luaY:checkname(ls, e)
self:codestring(ls, e, self:str_checkname(ls))
end
------------------------------------------------------------------------
-- creates struct entry for a local variable
-- * used only in new_localvar()
------------------------------------------------------------------------
function luaY:registerlocalvar(ls, varname)
local fs = ls.fs
local f = fs.f
self:growvector(ls.L, f.locvars, fs.nlocvars, f.sizelocvars,
nil, self.SHRT_MAX, "too many local variables")
-- loop to initialize empty f.locvar positions not required
f.locvars[fs.nlocvars] = {} -- LocVar
f.locvars[fs.nlocvars].varname = varname
-- luaC_objbarrier(ls.L, f, varname) /* GC */
local nlocvars = fs.nlocvars
fs.nlocvars = fs.nlocvars + 1
return nlocvars
end
------------------------------------------------------------------------
-- creates a new local variable given a name and an offset from nactvar
-- * used in fornum(), forlist(), parlist(), body()
------------------------------------------------------------------------
function luaY:new_localvarliteral(ls, v, n)
self:new_localvar(ls, v, n)
end
------------------------------------------------------------------------
-- register a local variable, set in active variable list
------------------------------------------------------------------------
function luaY:new_localvar(ls, name, n)
local fs = ls.fs
self:checklimit(fs, fs.nactvar + n + 1, self.LUAI_MAXVARS, "local variables")
fs.actvar[fs.nactvar + n] = self:registerlocalvar(ls, name)
end
------------------------------------------------------------------------
-- adds nvars number of new local variables, set debug information
------------------------------------------------------------------------
function luaY:adjustlocalvars(ls, nvars)
local fs = ls.fs
fs.nactvar = fs.nactvar + nvars
for i = nvars, 1, -1 do
self:getlocvar(fs, fs.nactvar - i).startpc = fs.pc
end
end
------------------------------------------------------------------------
-- removes a number of locals, set debug information
------------------------------------------------------------------------
function luaY:removevars(ls, tolevel)
local fs = ls.fs
while fs.nactvar > tolevel do
fs.nactvar = fs.nactvar - 1
self:getlocvar(fs, fs.nactvar).endpc = fs.pc
end
end
------------------------------------------------------------------------
-- returns an existing upvalue index based on the given name, or
-- creates a new upvalue struct entry and returns the new index
-- * used only in singlevaraux()
------------------------------------------------------------------------
function luaY:indexupvalue(fs, name, v)
local f = fs.f
for i = 0, f.nups - 1 do
if fs.upvalues[i].k == v.k and fs.upvalues[i].info == v.info then
lua_assert(f.upvalues[i] == name)
return i
end
end
-- new one
self:checklimit(fs, f.nups + 1, self.LUAI_MAXUPVALUES, "upvalues")
self:growvector(fs.L, f.upvalues, f.nups, f.sizeupvalues,
nil, self.MAX_INT, "")
-- loop to initialize empty f.upvalues positions not required
f.upvalues[f.nups] = name
-- luaC_objbarrier(fs->L, f, name); /* GC */
lua_assert(v.k == "VLOCAL" or v.k == "VUPVAL")
-- this is a partial copy; only k & info fields used
fs.upvalues[f.nups] = { k = v.k, info = v.info }
local nups = f.nups
f.nups = f.nups + 1
return nups
end
------------------------------------------------------------------------
-- search the local variable namespace of the given fs for a match
-- * used only in singlevaraux()
------------------------------------------------------------------------
function luaY:searchvar(fs, n)
for i = fs.nactvar - 1, 0, -1 do
if n == self:getlocvar(fs, i).varname then
return i
end
end
return -1 -- not found
end
------------------------------------------------------------------------
-- * mark upvalue flags in function states up to a given level
-- * used only in singlevaraux()
------------------------------------------------------------------------
function luaY:markupval(fs, level)
local bl = fs.bl
while bl and bl.nactvar > level do bl = bl.previous end
if bl then bl.upval = true end
end
------------------------------------------------------------------------
-- handle locals, globals and upvalues and related processing
-- * search mechanism is recursive, calls itself to search parents
-- * used only in singlevar()
------------------------------------------------------------------------
function luaY:singlevaraux(fs, n, var, base)
if fs == nil then -- no more levels?
self:init_exp(var, "VGLOBAL", luaP.NO_REG) -- default is global variable
return "VGLOBAL"
else
local v = self:searchvar(fs, n) -- look up at current level
if v >= 0 then
self:init_exp(var, "VLOCAL", v)
if base == 0 then
self:markupval(fs, v) -- local will be used as an upval
end
return "VLOCAL"
else -- not found at current level; try upper one
if self:singlevaraux(fs.prev, n, var, 0) == "VGLOBAL" then
return "VGLOBAL"
end
var.info = self:indexupvalue(fs, n, var) -- else was LOCAL or UPVAL
var.k = "VUPVAL" -- upvalue in this level
return "VUPVAL"
end--if v
end--if fs
end
------------------------------------------------------------------------
-- consume a name token, creates a variable (global|local|upvalue)
-- * used in prefixexp(), funcname()
------------------------------------------------------------------------
function luaY:singlevar(ls, var)
local varname = self:str_checkname(ls)
local fs = ls.fs
if self:singlevaraux(fs, varname, var, 1) == "VGLOBAL" then
var.info = luaK:stringK(fs, varname) -- info points to global name
end
end
------------------------------------------------------------------------
-- adjust RHS to match LHS in an assignment
-- * used in assignment(), forlist(), localstat()
------------------------------------------------------------------------
function luaY:adjust_assign(ls, nvars, nexps, e)
local fs = ls.fs
local extra = nvars - nexps
if self:hasmultret(e.k) then
extra = extra + 1 -- includes call itself
if extra <= 0 then extra = 0 end
luaK:setreturns(fs, e, extra) -- last exp. provides the difference
if extra > 1 then luaK:reserveregs(fs, extra - 1) end
else
if e.k ~= "VVOID" then luaK:exp2nextreg(fs, e) end -- close last expression
if extra > 0 then
local reg = fs.freereg
luaK:reserveregs(fs, extra)
luaK:_nil(fs, reg, extra)
end
end
end
------------------------------------------------------------------------
-- tracks and limits parsing depth, assert check at end of parsing
------------------------------------------------------------------------
function luaY:enterlevel(ls)
ls.L.nCcalls = ls.L.nCcalls + 1
if ls.L.nCcalls > self.LUAI_MAXCCALLS then
luaX:lexerror(ls, "chunk has too many syntax levels", 0)
end
end
------------------------------------------------------------------------
-- tracks parsing depth, a pair with luaY:enterlevel()
------------------------------------------------------------------------
function luaY:leavelevel(ls)
ls.L.nCcalls = ls.L.nCcalls - 1
end
------------------------------------------------------------------------
-- enters a code unit, initializes elements
------------------------------------------------------------------------
function luaY:enterblock(fs, bl, isbreakable)
bl.breaklist = luaK.NO_JUMP
bl.isbreakable = isbreakable
bl.nactvar = fs.nactvar
bl.upval = false
bl.previous = fs.bl
fs.bl = bl
lua_assert(fs.freereg == fs.nactvar)
end
------------------------------------------------------------------------
-- leaves a code unit, close any upvalues
------------------------------------------------------------------------
function luaY:leaveblock(fs)
local bl = fs.bl
fs.bl = bl.previous
self:removevars(fs.ls, bl.nactvar)
if bl.upval then
luaK:codeABC(fs, "OP_CLOSE", bl.nactvar, 0, 0)
end
-- a block either controls scope or breaks (never both)
lua_assert(not bl.isbreakable or not bl.upval)
lua_assert(bl.nactvar == fs.nactvar)
fs.freereg = fs.nactvar -- free registers
luaK:patchtohere(fs, bl.breaklist)
end
------------------------------------------------------------------------
-- implement the instantiation of a function prototype, append list of
-- upvalues after the instantiation instruction
-- * used only in body()
------------------------------------------------------------------------
function luaY:pushclosure(ls, func, v)
local fs = ls.fs
local f = fs.f
self:growvector(ls.L, f.p, fs.np, f.sizep, nil,
luaP.MAXARG_Bx, "constant table overflow")
-- loop to initialize empty f.p positions not required
f.p[fs.np] = func.f
fs.np = fs.np + 1
-- luaC_objbarrier(ls->L, f, func->f); /* C */
self:init_exp(v, "VRELOCABLE", luaK:codeABx(fs, "OP_CLOSURE", 0, fs.np - 1))
for i = 0, func.f.nups - 1 do
local o = (func.upvalues[i].k == "VLOCAL") and "OP_MOVE" or "OP_GETUPVAL"
luaK:codeABC(fs, o, 0, func.upvalues[i].info, 0)
end
end
------------------------------------------------------------------------
-- opening of a function
------------------------------------------------------------------------
function luaY:open_func(ls, fs)
local L = ls.L
local f = self:newproto(ls.L)
fs.f = f
fs.prev = ls.fs -- linked list of funcstates
fs.ls = ls
fs.L = L
ls.fs = fs
fs.pc = 0
fs.lasttarget = -1
fs.jpc = luaK.NO_JUMP
fs.freereg = 0
fs.nk = 0
fs.np = 0
fs.nlocvars = 0
fs.nactvar = 0
fs.bl = nil
f.source = ls.source
f.maxstacksize = 2 -- registers 0/1 are always valid
fs.h = {} -- constant table; was luaH_new call
-- anchor table of constants and prototype (to avoid being collected)
-- sethvalue2s(L, L->top, fs->h); incr_top(L); /* C */
-- setptvalue2s(L, L->top, f); incr_top(L);
end
------------------------------------------------------------------------
-- closing of a function
------------------------------------------------------------------------
function luaY:close_func(ls)
local L = ls.L
local fs = ls.fs
local f = fs.f
self:removevars(ls, 0)
luaK:ret(fs, 0, 0) -- final return
-- luaM_reallocvector deleted for f->code, f->lineinfo, f->k, f->p,
-- f->locvars, f->upvalues; not required for Lua table arrays
f.sizecode = fs.pc
f.sizelineinfo = fs.pc
f.sizek = fs.nk
f.sizep = fs.np
f.sizelocvars = fs.nlocvars
f.sizeupvalues = f.nups
--lua_assert(luaG_checkcode(f)) -- currently not implemented
lua_assert(fs.bl == nil)
ls.fs = fs.prev
-- the following is not required for this implementation; kept here
-- for completeness
-- L->top -= 2; /* remove table and prototype from the stack */
-- last token read was anchored in defunct function; must reanchor it
if fs then self:anchor_token(ls) end
end
------------------------------------------------------------------------
-- parser initialization function
-- * note additional sub-tables needed for LexState, FuncState
------------------------------------------------------------------------
function luaY:parser(L, z, buff, name)
local lexstate = {} -- LexState
lexstate.t = {}
lexstate.lookahead = {}
local funcstate = {} -- FuncState
funcstate.upvalues = {}
funcstate.actvar = {}
-- the following nCcalls initialization added for convenience
L.nCcalls = 0
lexstate.buff = buff
luaX:setinput(L, lexstate, z, name)
self:open_func(lexstate, funcstate)
funcstate.f.is_vararg = self.VARARG_ISVARARG -- main func. is always vararg
luaX:next(lexstate) -- read first token
self:chunk(lexstate)
self:check(lexstate, "TK_EOS")
self:close_func(lexstate)
lua_assert(funcstate.prev == nil)
lua_assert(funcstate.f.nups == 0)
lua_assert(lexstate.fs == nil)
return funcstate.f
end
--[[--------------------------------------------------------------------
-- GRAMMAR RULES
----------------------------------------------------------------------]]
------------------------------------------------------------------------
-- parse a function name suffix, for function call specifications
-- * used in primaryexp(), funcname()
------------------------------------------------------------------------
function luaY:field(ls, v)
-- field -> ['.' | ':'] NAME
local fs = ls.fs
local key = {} -- expdesc
luaK:exp2anyreg(fs, v)
luaX:next(ls) -- skip the dot or colon
self:checkname(ls, key)
luaK:indexed(fs, v, key)
end
------------------------------------------------------------------------
-- parse a table indexing suffix, for constructors, expressions
-- * used in recfield(), primaryexp()
------------------------------------------------------------------------
function luaY:yindex(ls, v)
-- index -> '[' expr ']'
luaX:next(ls) -- skip the '['
self:expr(ls, v)
luaK:exp2val(ls.fs, v)
self:checknext(ls, "]")
end
--[[--------------------------------------------------------------------
-- Rules for Constructors
----------------------------------------------------------------------]]
--[[--------------------------------------------------------------------
-- struct ConsControl:
-- v -- last list item read (table: struct expdesc)
-- t -- table descriptor (table: struct expdesc)
-- nh -- total number of 'record' elements
-- na -- total number of array elements
-- tostore -- number of array elements pending to be stored
----------------------------------------------------------------------]]
------------------------------------------------------------------------
-- parse a table record (hash) field
-- * used in constructor()
------------------------------------------------------------------------
function luaY:recfield(ls, cc)
-- recfield -> (NAME | '['exp1']') = exp1
local fs = ls.fs
local reg = ls.fs.freereg
local key, val = {}, {} -- expdesc
if ls.t.token == "TK_NAME" then
self:checklimit(fs, cc.nh, self.MAX_INT, "items in a constructor")
self:checkname(ls, key)
else -- ls->t.token == '['
self:yindex(ls, key)
end
cc.nh = cc.nh + 1
self:checknext(ls, "=")
local rkkey = luaK:exp2RK(fs, key)
self:expr(ls, val)
luaK:codeABC(fs, "OP_SETTABLE", cc.t.info, rkkey, luaK:exp2RK(fs, val))
fs.freereg = reg -- free registers
end
------------------------------------------------------------------------
-- emit a set list instruction if enough elements (LFIELDS_PER_FLUSH)
-- * used in constructor()
------------------------------------------------------------------------
function luaY:closelistfield(fs, cc)
if cc.v.k == "VVOID" then return end -- there is no list item
luaK:exp2nextreg(fs, cc.v)
cc.v.k = "VVOID"
if cc.tostore == luaP.LFIELDS_PER_FLUSH then
luaK:setlist(fs, cc.t.info, cc.na, cc.tostore) -- flush
cc.tostore = 0 -- no more items pending
end
end
------------------------------------------------------------------------
-- emit a set list instruction at the end of parsing list constructor
-- * used in constructor()
------------------------------------------------------------------------
function luaY:lastlistfield(fs, cc)
if cc.tostore == 0 then return end
if self:hasmultret(cc.v.k) then
luaK:setmultret(fs, cc.v)
luaK:setlist(fs, cc.t.info, cc.na, self.LUA_MULTRET)
cc.na = cc.na - 1 -- do not count last expression (unknown number of elements)
else
if cc.v.k ~= "VVOID" then
luaK:exp2nextreg(fs, cc.v)
end
luaK:setlist(fs, cc.t.info, cc.na, cc.tostore)
end
end
------------------------------------------------------------------------
-- parse a table list (array) field
-- * used in constructor()
------------------------------------------------------------------------
function luaY:listfield(ls, cc)
self:expr(ls, cc.v)
self:checklimit(ls.fs, cc.na, self.MAX_INT, "items in a constructor")
cc.na = cc.na + 1
cc.tostore = cc.tostore + 1
end
------------------------------------------------------------------------
-- parse a table constructor
-- * used in funcargs(), simpleexp()
------------------------------------------------------------------------
function luaY:constructor(ls, t)
-- constructor -> '{' [ field { fieldsep field } [ fieldsep ] ] '}'
-- field -> recfield | listfield
-- fieldsep -> ',' | ';'
local fs = ls.fs
local line = ls.linenumber
local pc = luaK:codeABC(fs, "OP_NEWTABLE", 0, 0, 0)
local cc = {} -- ConsControl
cc.v = {}
cc.na, cc.nh, cc.tostore = 0, 0, 0
cc.t = t
self:init_exp(t, "VRELOCABLE", pc)
self:init_exp(cc.v, "VVOID", 0) -- no value (yet)
luaK:exp2nextreg(ls.fs, t) -- fix it at stack top (for gc)
self:checknext(ls, "{")
repeat
lua_assert(cc.v.k == "VVOID" or cc.tostore > 0)
if ls.t.token == "}" then break end
self:closelistfield(fs, cc)
local c = ls.t.token
if c == "TK_NAME" then -- may be listfields or recfields
luaX:lookahead(ls)
if ls.lookahead.token ~= "=" then -- expression?
self:listfield(ls, cc)
else
self:recfield(ls, cc)
end
elseif c == "[" then -- constructor_item -> recfield
self:recfield(ls, cc)
else -- constructor_part -> listfield
self:listfield(ls, cc)
end
until not self:testnext(ls, ",") and not self:testnext(ls, ";")
self:check_match(ls, "}", "{", line)
self:lastlistfield(fs, cc)
luaP:SETARG_B(fs.f.code[pc], self:int2fb(cc.na)) -- set initial array size
luaP:SETARG_C(fs.f.code[pc], self:int2fb(cc.nh)) -- set initial table size
end
-- }======================================================================
------------------------------------------------------------------------
-- parse the arguments (parameters) of a function declaration
-- * used in body()
------------------------------------------------------------------------
function luaY:parlist(ls)
-- parlist -> [ param { ',' param } ]
local fs = ls.fs
local f = fs.f
local nparams = 0
f.is_vararg = 0
if ls.t.token ~= ")" then -- is 'parlist' not empty?
repeat
local c = ls.t.token
if c == "TK_NAME" then -- param -> NAME
self:new_localvar(ls, self:str_checkname(ls), nparams)
nparams = nparams + 1
elseif c == "TK_DOTS" then -- param -> `...'
luaX:next(ls)
-- [[
-- #if defined(LUA_COMPAT_VARARG)
-- use `arg' as default name
self:new_localvarliteral(ls, "arg", nparams)
nparams = nparams + 1
f.is_vararg = self.VARARG_HASARG + self.VARARG_NEEDSARG
-- #endif
--]]
f.is_vararg = f.is_vararg + self.VARARG_ISVARARG
else
luaX:syntaxerror(ls, "<name> or "..self:LUA_QL("...").." expected")
end
until f.is_vararg ~= 0 or not self:testnext(ls, ",")
end--if
self:adjustlocalvars(ls, nparams)
-- NOTE: the following works only when HASARG_MASK is 2!
f.numparams = fs.nactvar - (f.is_vararg % self.HASARG_MASK)
luaK:reserveregs(fs, fs.nactvar) -- reserve register for parameters
end
------------------------------------------------------------------------
-- parse function declaration body
-- * used in simpleexp(), localfunc(), funcstat()
------------------------------------------------------------------------
function luaY:body(ls, e, needself, line)
-- body -> '(' parlist ')' chunk END
local new_fs = {} -- FuncState
new_fs.upvalues = {}
new_fs.actvar = {}
self:open_func(ls, new_fs)
new_fs.f.lineDefined = line
self:checknext(ls, "(")
if needself then
self:new_localvarliteral(ls, "self", 0)
self:adjustlocalvars(ls, 1)
end
self:parlist(ls)
self:checknext(ls, ")")
self:chunk(ls)
new_fs.f.lastlinedefined = ls.linenumber
self:check_match(ls, "TK_END", "TK_FUNCTION", line)
self:close_func(ls)
self:pushclosure(ls, new_fs, e)
end
------------------------------------------------------------------------
-- parse a list of comma-separated expressions
-- * used is multiple locations
------------------------------------------------------------------------
function luaY:explist1(ls, v)
-- explist1 -> expr { ',' expr }
local n = 1 -- at least one expression
self:expr(ls, v)
while self:testnext(ls, ",") do
luaK:exp2nextreg(ls.fs, v)
self:expr(ls, v)
n = n + 1
end
return n
end
------------------------------------------------------------------------
-- parse the parameters of a function call
-- * contrast with parlist(), used in function declarations
-- * used in primaryexp()
------------------------------------------------------------------------
function luaY:funcargs(ls, f)
local fs = ls.fs
local args = {} -- expdesc
local nparams
local line = ls.linenumber
local c = ls.t.token
if c == "(" then -- funcargs -> '(' [ explist1 ] ')'
if line ~= ls.lastline then
luaX:syntaxerror(ls, "ambiguous syntax (function call x new statement)")
end
luaX:next(ls)
if ls.t.token == ")" then -- arg list is empty?
args.k = "VVOID"
else
self:explist1(ls, args)
luaK:setmultret(fs, args)
end
self:check_match(ls, ")", "(", line)
elseif c == "{" then -- funcargs -> constructor
self:constructor(ls, args)
elseif c == "TK_STRING" then -- funcargs -> STRING
self:codestring(ls, args, ls.t.seminfo)
luaX:next(ls) -- must use 'seminfo' before 'next'
else
luaX:syntaxerror(ls, "function arguments expected")
return
end
lua_assert(f.k == "VNONRELOC")
local base = f.info -- base register for call
if self:hasmultret(args.k) then
nparams = self.LUA_MULTRET -- open call
else
if args.k ~= "VVOID" then
luaK:exp2nextreg(fs, args) -- close last argument
end
nparams = fs.freereg - (base + 1)
end
self:init_exp(f, "VCALL", luaK:codeABC(fs, "OP_CALL", base, nparams + 1, 2))
luaK:fixline(fs, line)
fs.freereg = base + 1 -- call remove function and arguments and leaves
-- (unless changed) one result
end
--[[--------------------------------------------------------------------
-- Expression parsing
----------------------------------------------------------------------]]
------------------------------------------------------------------------
-- parses an expression in parentheses or a single variable
-- * used in primaryexp()
------------------------------------------------------------------------
function luaY:prefixexp(ls, v)
-- prefixexp -> NAME | '(' expr ')'
local c = ls.t.token
if c == "(" then
local line = ls.linenumber
luaX:next(ls)
self:expr(ls, v)
self:check_match(ls, ")", "(", line)
luaK:dischargevars(ls.fs, v)
elseif c == "TK_NAME" then
self:singlevar(ls, v)
else
luaX:syntaxerror(ls, "unexpected symbol")
end--if c
return
end
------------------------------------------------------------------------
-- parses a prefixexp (an expression in parentheses or a single variable)
-- or a function call specification
-- * used in simpleexp(), assignment(), exprstat()
------------------------------------------------------------------------
function luaY:primaryexp(ls, v)
-- primaryexp ->
-- prefixexp { '.' NAME | '[' exp ']' | ':' NAME funcargs | funcargs }
local fs = ls.fs
self:prefixexp(ls, v)
while true do
local c = ls.t.token
if c == "." then -- field
self:field(ls, v)
elseif c == "[" then -- '[' exp1 ']'
local key = {} -- expdesc
luaK:exp2anyreg(fs, v)
self:yindex(ls, key)
luaK:indexed(fs, v, key)
elseif c == ":" then -- ':' NAME funcargs
local key = {} -- expdesc
luaX:next(ls)
self:checkname(ls, key)
luaK:_self(fs, v, key)
self:funcargs(ls, v)
elseif c == "(" or c == "TK_STRING" or c == "{" then -- funcargs
luaK:exp2nextreg(fs, v)
self:funcargs(ls, v)
else
return
end--if c
end--while
end
------------------------------------------------------------------------
-- parses general expression types, constants handled here
-- * used in subexpr()
------------------------------------------------------------------------
function luaY:simpleexp(ls, v)
-- simpleexp -> NUMBER | STRING | NIL | TRUE | FALSE | ... |
-- constructor | FUNCTION body | primaryexp
local c = ls.t.token
if c == "TK_NUMBER" then
self:init_exp(v, "VKNUM", 0)
v.nval = ls.t.seminfo
elseif c == "TK_STRING" then
self:codestring(ls, v, ls.t.seminfo)
elseif c == "TK_NIL" then
self:init_exp(v, "VNIL", 0)
elseif c == "TK_TRUE" then
self:init_exp(v, "VTRUE", 0)
elseif c == "TK_FALSE" then
self:init_exp(v, "VFALSE", 0)
elseif c == "TK_DOTS" then -- vararg
local fs = ls.fs
self:check_condition(ls, fs.f.is_vararg ~= 0,
"cannot use "..self:LUA_QL("...").." outside a vararg function");
-- NOTE: the following substitutes for a bitop, but is value-specific
local is_vararg = fs.f.is_vararg
if is_vararg >= self.VARARG_NEEDSARG then
fs.f.is_vararg = is_vararg - self.VARARG_NEEDSARG -- don't need 'arg'
end
self:init_exp(v, "VVARARG", luaK:codeABC(fs, "OP_VARARG", 0, 1, 0))
elseif c == "{" then -- constructor
self:constructor(ls, v)
return
elseif c == "TK_FUNCTION" then
luaX:next(ls)
self:body(ls, v, false, ls.linenumber)
return
else
self:primaryexp(ls, v)
return
end--if c
luaX:next(ls)
end
------------------------------------------------------------------------
-- Translates unary operators tokens if found, otherwise returns
-- OPR_NOUNOPR. getunopr() and getbinopr() are used in subexpr().
-- * used in subexpr()
------------------------------------------------------------------------
function luaY:getunopr(op)
if op == "TK_NOT" then
return "OPR_NOT"
elseif op == "-" then
return "OPR_MINUS"
elseif op == "#" then
return "OPR_LEN"
else
return "OPR_NOUNOPR"
end
end
------------------------------------------------------------------------
-- Translates binary operator tokens if found, otherwise returns
-- OPR_NOBINOPR. Code generation uses OPR_* style tokens.
-- * used in subexpr()
------------------------------------------------------------------------
luaY.getbinopr_table = {
["+"] = "OPR_ADD",
["-"] = "OPR_SUB",
["*"] = "OPR_MUL",
["/"] = "OPR_DIV",
["%"] = "OPR_MOD",
["^"] = "OPR_POW",
["TK_CONCAT"] = "OPR_CONCAT",
["TK_NE"] = "OPR_NE",
["TK_EQ"] = "OPR_EQ",
["<"] = "OPR_LT",
["TK_LE"] = "OPR_LE",
[">"] = "OPR_GT",
["TK_GE"] = "OPR_GE",
["TK_AND"] = "OPR_AND",
["TK_OR"] = "OPR_OR",
}
function luaY:getbinopr(op)
local opr = self.getbinopr_table[op]
if opr then return opr else return "OPR_NOBINOPR" end
end
------------------------------------------------------------------------
-- the following priority table consists of pairs of left/right values
-- for binary operators (was a static const struct); grep for ORDER OPR
-- * the following struct is replaced:
-- static const struct {
-- lu_byte left; /* left priority for each binary operator */
-- lu_byte right; /* right priority */
-- } priority[] = { /* ORDER OPR */
------------------------------------------------------------------------
luaY.priority = {
{6, 6}, {6, 6}, {7, 7}, {7, 7}, {7, 7}, -- `+' `-' `/' `%'
{10, 9}, {5, 4}, -- power and concat (right associative)
{3, 3}, {3, 3}, -- equality
{3, 3}, {3, 3}, {3, 3}, {3, 3}, -- order
{2, 2}, {1, 1} -- logical (and/or)
}
luaY.UNARY_PRIORITY = 8 -- priority for unary operators
------------------------------------------------------------------------
-- Parse subexpressions. Includes handling of unary operators and binary
-- operators. A subexpr is given the rhs priority level of the operator
-- immediately left of it, if any (limit is -1 if none,) and if a binop
-- is found, limit is compared with the lhs priority level of the binop
-- in order to determine which executes first.
------------------------------------------------------------------------
------------------------------------------------------------------------
-- subexpr -> (simpleexp | unop subexpr) { binop subexpr }
-- where 'binop' is any binary operator with a priority higher than 'limit'
-- * for priority lookups with self.priority[], 1=left and 2=right
-- * recursively called
-- * used in expr()
------------------------------------------------------------------------
function luaY:subexpr(ls, v, limit)
self:enterlevel(ls)
local uop = self:getunopr(ls.t.token)
if uop ~= "OPR_NOUNOPR" then
luaX:next(ls)
self:subexpr(ls, v, self.UNARY_PRIORITY)
luaK:prefix(ls.fs, uop, v)
else
self:simpleexp(ls, v)
end
-- expand while operators have priorities higher than 'limit'
local op = self:getbinopr(ls.t.token)
while op ~= "OPR_NOBINOPR" and self.priority[luaK.BinOpr[op] + 1][1] > limit do
local v2 = {} -- expdesc
luaX:next(ls)
luaK:infix(ls.fs, op, v)
-- read sub-expression with higher priority
local nextop = self:subexpr(ls, v2, self.priority[luaK.BinOpr[op] + 1][2])
luaK:posfix(ls.fs, op, v, v2)
op = nextop
end
self:leavelevel(ls)
return op -- return first untreated operator
end
------------------------------------------------------------------------
-- Expression parsing starts here. Function subexpr is entered with the
-- left operator (which is non-existent) priority of -1, which is lower
-- than all actual operators. Expr information is returned in parm v.
-- * used in multiple locations
------------------------------------------------------------------------
function luaY:expr(ls, v)
self:subexpr(ls, v, 0)
end
-- }====================================================================
--[[--------------------------------------------------------------------
-- Rules for Statements
----------------------------------------------------------------------]]
------------------------------------------------------------------------
-- checks next token, used as a look-ahead
-- * returns boolean instead of 0|1
-- * used in retstat(), chunk()
------------------------------------------------------------------------
function luaY:block_follow(token)
if token == "TK_ELSE" or token == "TK_ELSEIF" or token == "TK_END"
or token == "TK_UNTIL" or token == "TK_EOS" then
return true
else
return false
end
end
------------------------------------------------------------------------
-- parse a code block or unit
-- * used in multiple functions
------------------------------------------------------------------------
function luaY:block(ls)
-- block -> chunk
local fs = ls.fs
local bl = {} -- BlockCnt
self:enterblock(fs, bl, false)
self:chunk(ls)
lua_assert(bl.breaklist == luaK.NO_JUMP)
self:leaveblock(fs)
end
------------------------------------------------------------------------
-- structure to chain all variables in the left-hand side of an
-- assignment
-- struct LHS_assign:
-- prev -- (table: struct LHS_assign)
-- v -- variable (global, local, upvalue, or indexed) (table: expdesc)
------------------------------------------------------------------------
------------------------------------------------------------------------
-- check whether, in an assignment to a local variable, the local variable
-- is needed in a previous assignment (to a table). If so, save original
-- local value in a safe place and use this safe copy in the previous
-- assignment.
-- * used in assignment()
------------------------------------------------------------------------
function luaY:check_conflict(ls, lh, v)
local fs = ls.fs
local extra = fs.freereg -- eventual position to save local variable
local conflict = false
while lh do
if lh.v.k == "VINDEXED" then
if lh.v.info == v.info then -- conflict?
conflict = true
lh.v.info = extra -- previous assignment will use safe copy
end
if lh.v.aux == v.info then -- conflict?
conflict = true
lh.v.aux = extra -- previous assignment will use safe copy
end
end
lh = lh.prev
end
if conflict then
luaK:codeABC(fs, "OP_MOVE", fs.freereg, v.info, 0) -- make copy
luaK:reserveregs(fs, 1)
end
end
------------------------------------------------------------------------
-- parse a variable assignment sequence
-- * recursively called
-- * used in exprstat()
------------------------------------------------------------------------
function luaY:assignment(ls, lh, nvars)
local e = {} -- expdesc
-- test was: VLOCAL <= lh->v.k && lh->v.k <= VINDEXED
local c = lh.v.k
self:check_condition(ls, c == "VLOCAL" or c == "VUPVAL" or c == "VGLOBAL"
or c == "VINDEXED", "syntax error")
if self:testnext(ls, ",") then -- assignment -> ',' primaryexp assignment
local nv = {} -- LHS_assign
nv.v = {}
nv.prev = lh
self:primaryexp(ls, nv.v)
if nv.v.k == "VLOCAL" then
self:check_conflict(ls, lh, nv.v)
end
self:checklimit(ls.fs, nvars, self.LUAI_MAXCCALLS - ls.L.nCcalls,
"variables in assignment")
self:assignment(ls, nv, nvars + 1)
else -- assignment -> '=' explist1
self:checknext(ls, "=")
local nexps = self:explist1(ls, e)
if nexps ~= nvars then
self:adjust_assign(ls, nvars, nexps, e)
if nexps > nvars then
ls.fs.freereg = ls.fs.freereg - (nexps - nvars) -- remove extra values
end
else
luaK:setoneret(ls.fs, e) -- close last expression
luaK:storevar(ls.fs, lh.v, e)
return -- avoid default
end
end
self:init_exp(e, "VNONRELOC", ls.fs.freereg - 1) -- default assignment
luaK:storevar(ls.fs, lh.v, e)
end
------------------------------------------------------------------------
-- parse condition in a repeat statement or an if control structure
-- * used in repeatstat(), test_then_block()
------------------------------------------------------------------------
function luaY:cond(ls)
-- cond -> exp
local v = {} -- expdesc
self:expr(ls, v) -- read condition
if v.k == "VNIL" then v.k = "VFALSE" end -- 'falses' are all equal here
luaK:goiftrue(ls.fs, v)
return v.f
end
------------------------------------------------------------------------
-- parse a break statement
-- * used in statements()
------------------------------------------------------------------------
function luaY:breakstat(ls)
-- stat -> BREAK
local fs = ls.fs
local bl = fs.bl
local upval = false
while bl and not bl.isbreakable do
if bl.upval then upval = true end
bl = bl.previous
end
if not bl then
luaX:syntaxerror(ls, "no loop to break")
end
if upval then
luaK:codeABC(fs, "OP_CLOSE", bl.nactvar, 0, 0)
end
bl.breaklist = luaK:concat(fs, bl.breaklist, luaK:jump(fs))
end
------------------------------------------------------------------------
-- parse a while-do control structure, body processed by block()
-- * with dynamic array sizes, MAXEXPWHILE + EXTRAEXP limits imposed by
-- the function's implementation can be removed
-- * used in statements()
------------------------------------------------------------------------
function luaY:whilestat(ls, line)
-- whilestat -> WHILE cond DO block END
local fs = ls.fs
local bl = {} -- BlockCnt
luaX:next(ls) -- skip WHILE
local whileinit = luaK:getlabel(fs)
local condexit = self:cond(ls)
self:enterblock(fs, bl, true)
self:checknext(ls, "TK_DO")
self:block(ls)
luaK:patchlist(fs, luaK:jump(fs), whileinit)
self:check_match(ls, "TK_END", "TK_WHILE", line)
self:leaveblock(fs)
luaK:patchtohere(fs, condexit) -- false conditions finish the loop
end
------------------------------------------------------------------------
-- parse a repeat-until control structure, body parsed by chunk()
-- * used in statements()
------------------------------------------------------------------------
function luaY:repeatstat(ls, line)
-- repeatstat -> REPEAT block UNTIL cond
local fs = ls.fs
local repeat_init = luaK:getlabel(fs)
local bl1, bl2 = {}, {} -- BlockCnt
self:enterblock(fs, bl1, true) -- loop block
self:enterblock(fs, bl2, false) -- scope block
luaX:next(ls) -- skip REPEAT
self:chunk(ls)
self:check_match(ls, "TK_UNTIL", "TK_REPEAT", line)
local condexit = self:cond(ls) -- read condition (inside scope block)
if not bl2.upval then -- no upvalues?
self:leaveblock(fs) -- finish scope
luaK:patchlist(ls.fs, condexit, repeat_init) -- close the loop
else -- complete semantics when there are upvalues
self:breakstat(ls) -- if condition then break
luaK:patchtohere(ls.fs, condexit) -- else...
self:leaveblock(fs) -- finish scope...
luaK:patchlist(ls.fs, luaK:jump(fs), repeat_init) -- and repeat
end
self:leaveblock(fs) -- finish loop
end
------------------------------------------------------------------------
-- parse the single expressions needed in numerical for loops
-- * used in fornum()
------------------------------------------------------------------------
function luaY:exp1(ls)
local e = {} -- expdesc
self:expr(ls, e)
local k = e.k
luaK:exp2nextreg(ls.fs, e)
return k
end
------------------------------------------------------------------------
-- parse a for loop body for both versions of the for loop
-- * used in fornum(), forlist()
------------------------------------------------------------------------
function luaY:forbody(ls, base, line, nvars, isnum)
-- forbody -> DO block
local bl = {} -- BlockCnt
local fs = ls.fs
self:adjustlocalvars(ls, 3) -- control variables
self:checknext(ls, "TK_DO")
local prep = isnum and luaK:codeAsBx(fs, "OP_FORPREP", base, luaK.NO_JUMP)
or luaK:jump(fs)
self:enterblock(fs, bl, false) -- scope for declared variables
self:adjustlocalvars(ls, nvars)
luaK:reserveregs(fs, nvars)
self:block(ls)
self:leaveblock(fs) -- end of scope for declared variables
luaK:patchtohere(fs, prep)
local endfor = isnum and luaK:codeAsBx(fs, "OP_FORLOOP", base, luaK.NO_JUMP)
or luaK:codeABC(fs, "OP_TFORLOOP", base, 0, nvars)
luaK:fixline(fs, line) -- pretend that `OP_FOR' starts the loop
luaK:patchlist(fs, isnum and endfor or luaK:jump(fs), prep + 1)
end
------------------------------------------------------------------------
-- parse a numerical for loop, calls forbody()
-- * used in forstat()
------------------------------------------------------------------------
function luaY:fornum(ls, varname, line)
-- fornum -> NAME = exp1,exp1[,exp1] forbody
local fs = ls.fs
local base = fs.freereg
self:new_localvarliteral(ls, "(for index)", 0)
self:new_localvarliteral(ls, "(for limit)", 1)
self:new_localvarliteral(ls, "(for step)", 2)
self:new_localvar(ls, varname, 3)
self:checknext(ls, '=')
self:exp1(ls) -- initial value
self:checknext(ls, ",")
self:exp1(ls) -- limit
if self:testnext(ls, ",") then
self:exp1(ls) -- optional step
else -- default step = 1
luaK:codeABx(fs, "OP_LOADK", fs.freereg, luaK:numberK(fs, 1))
luaK:reserveregs(fs, 1)
end
self:forbody(ls, base, line, 1, true)
end
------------------------------------------------------------------------
-- parse a generic for loop, calls forbody()
-- * used in forstat()
------------------------------------------------------------------------
function luaY:forlist(ls, indexname)
-- forlist -> NAME {,NAME} IN explist1 forbody
local fs = ls.fs
local e = {} -- expdesc
local nvars = 0
local base = fs.freereg
-- create control variables
self:new_localvarliteral(ls, "(for generator)", nvars)
nvars = nvars + 1
self:new_localvarliteral(ls, "(for state)", nvars)
nvars = nvars + 1
self:new_localvarliteral(ls, "(for control)", nvars)
nvars = nvars + 1
-- create declared variables
self:new_localvar(ls, indexname, nvars)
nvars = nvars + 1
while self:testnext(ls, ",") do
self:new_localvar(ls, self:str_checkname(ls), nvars)
nvars = nvars + 1
end
self:checknext(ls, "TK_IN")
local line = ls.linenumber
self:adjust_assign(ls, 3, self:explist1(ls, e), e)
luaK:checkstack(fs, 3) -- extra space to call generator
self:forbody(ls, base, line, nvars - 3, false)
end
------------------------------------------------------------------------
-- initial parsing for a for loop, calls fornum() or forlist()
-- * used in statements()
------------------------------------------------------------------------
function luaY:forstat(ls, line)
-- forstat -> FOR (fornum | forlist) END
local fs = ls.fs
local bl = {} -- BlockCnt
self:enterblock(fs, bl, true) -- scope for loop and control variables
luaX:next(ls) -- skip `for'
local varname = self:str_checkname(ls) -- first variable name
local c = ls.t.token
if c == "=" then
self:fornum(ls, varname, line)
elseif c == "," or c == "TK_IN" then
self:forlist(ls, varname)
else
luaX:syntaxerror(ls, self:LUA_QL("=").." or "..self:LUA_QL("in").." expected")
end
self:check_match(ls, "TK_END", "TK_FOR", line)
self:leaveblock(fs) -- loop scope (`break' jumps to this point)
end
------------------------------------------------------------------------
-- parse part of an if control structure, including the condition
-- * used in ifstat()
------------------------------------------------------------------------
function luaY:test_then_block(ls)
-- test_then_block -> [IF | ELSEIF] cond THEN block
luaX:next(ls) -- skip IF or ELSEIF
local condexit = self:cond(ls)
self:checknext(ls, "TK_THEN")
self:block(ls) -- `then' part
return condexit
end
------------------------------------------------------------------------
-- parse an if control structure
-- * used in statements()
------------------------------------------------------------------------
function luaY:ifstat(ls, line)
-- ifstat -> IF cond THEN block {ELSEIF cond THEN block} [ELSE block] END
local fs = ls.fs
local escapelist = luaK.NO_JUMP
local flist = self:test_then_block(ls) -- IF cond THEN block
while ls.t.token == "TK_ELSEIF" do
escapelist = luaK:concat(fs, escapelist, luaK:jump(fs))
luaK:patchtohere(fs, flist)
flist = self:test_then_block(ls) -- ELSEIF cond THEN block
end
if ls.t.token == "TK_ELSE" then
escapelist = luaK:concat(fs, escapelist, luaK:jump(fs))
luaK:patchtohere(fs, flist)
luaX:next(ls) -- skip ELSE (after patch, for correct line info)
self:block(ls) -- 'else' part
else
escapelist = luaK:concat(fs, escapelist, flist)
end
luaK:patchtohere(fs, escapelist)
self:check_match(ls, "TK_END", "TK_IF", line)
end
------------------------------------------------------------------------
-- parse a local function statement
-- * used in statements()
------------------------------------------------------------------------
function luaY:localfunc(ls)
local v, b = {}, {} -- expdesc
local fs = ls.fs
self:new_localvar(ls, self:str_checkname(ls), 0)
self:init_exp(v, "VLOCAL", fs.freereg)
luaK:reserveregs(fs, 1)
self:adjustlocalvars(ls, 1)
self:body(ls, b, false, ls.linenumber)
luaK:storevar(fs, v, b)
-- debug information will only see the variable after this point!
self:getlocvar(fs, fs.nactvar - 1).startpc = fs.pc
end
------------------------------------------------------------------------
-- parse a local variable declaration statement
-- * used in statements()
------------------------------------------------------------------------
function luaY:localstat(ls)
-- stat -> LOCAL NAME {',' NAME} ['=' explist1]
local nvars = 0
local nexps
local e = {} -- expdesc
repeat
self:new_localvar(ls, self:str_checkname(ls), nvars)
nvars = nvars + 1
until not self:testnext(ls, ",")
if self:testnext(ls, "=") then
nexps = self:explist1(ls, e)
else
e.k = "VVOID"
nexps = 0
end
self:adjust_assign(ls, nvars, nexps, e)
self:adjustlocalvars(ls, nvars)
end
------------------------------------------------------------------------
-- parse a function name specification
-- * used in funcstat()
------------------------------------------------------------------------
function luaY:funcname(ls, v)
-- funcname -> NAME {field} [':' NAME]
local needself = false
self:singlevar(ls, v)
while ls.t.token == "." do
self:field(ls, v)
end
if ls.t.token == ":" then
needself = true
self:field(ls, v)
end
return needself
end
------------------------------------------------------------------------
-- parse a function statement
-- * used in statements()
------------------------------------------------------------------------
function luaY:funcstat(ls, line)
-- funcstat -> FUNCTION funcname body
local v, b = {}, {} -- expdesc
luaX:next(ls) -- skip FUNCTION
local needself = self:funcname(ls, v)
self:body(ls, b, needself, line)
luaK:storevar(ls.fs, v, b)
luaK:fixline(ls.fs, line) -- definition 'happens' in the first line
end
------------------------------------------------------------------------
-- parse a function call with no returns or an assignment statement
-- * used in statements()
------------------------------------------------------------------------
function luaY:exprstat(ls)
-- stat -> func | assignment
local fs = ls.fs
local v = {} -- LHS_assign
v.v = {}
self:primaryexp(ls, v.v)
if v.v.k == "VCALL" then -- stat -> func
luaP:SETARG_C(luaK:getcode(fs, v.v), 1) -- call statement uses no results
else -- stat -> assignment
v.prev = nil
self:assignment(ls, v, 1)
end
end
------------------------------------------------------------------------
-- parse a return statement
-- * used in statements()
------------------------------------------------------------------------
function luaY:retstat(ls)
-- stat -> RETURN explist
local fs = ls.fs
local e = {} -- expdesc
local first, nret -- registers with returned values
luaX:next(ls) -- skip RETURN
if self:block_follow(ls.t.token) or ls.t.token == ";" then
first, nret = 0, 0 -- return no values
else
nret = self:explist1(ls, e) -- optional return values
if self:hasmultret(e.k) then
luaK:setmultret(fs, e)
if e.k == "VCALL" and nret == 1 then -- tail call?
luaP:SET_OPCODE(luaK:getcode(fs, e), "OP_TAILCALL")
lua_assert(luaP:GETARG_A(luaK:getcode(fs, e)) == fs.nactvar)
end
first = fs.nactvar
nret = self.LUA_MULTRET -- return all values
else
if nret == 1 then -- only one single value?
first = luaK:exp2anyreg(fs, e)
else
luaK:exp2nextreg(fs, e) -- values must go to the 'stack'
first = fs.nactvar -- return all 'active' values
lua_assert(nret == fs.freereg - first)
end
end--if
end--if
luaK:ret(fs, first, nret)
end
------------------------------------------------------------------------
-- initial parsing for statements, calls a lot of functions
-- * returns boolean instead of 0|1
-- * used in chunk()
------------------------------------------------------------------------
function luaY:statement(ls)
local line = ls.linenumber -- may be needed for error messages
local c = ls.t.token
if c == "TK_IF" then -- stat -> ifstat
self:ifstat(ls, line)
return false
elseif c == "TK_WHILE" then -- stat -> whilestat
self:whilestat(ls, line)
return false
elseif c == "TK_DO" then -- stat -> DO block END
luaX:next(ls) -- skip DO
self:block(ls)
self:check_match(ls, "TK_END", "TK_DO", line)
return false
elseif c == "TK_FOR" then -- stat -> forstat
self:forstat(ls, line)
return false
elseif c == "TK_REPEAT" then -- stat -> repeatstat
self:repeatstat(ls, line)
return false
elseif c == "TK_FUNCTION" then -- stat -> funcstat
self:funcstat(ls, line)
return false
elseif c == "TK_LOCAL" then -- stat -> localstat
luaX:next(ls) -- skip LOCAL
if self:testnext(ls, "TK_FUNCTION") then -- local function?
self:localfunc(ls)
else
self:localstat(ls)
end
return false
elseif c == "TK_RETURN" then -- stat -> retstat
self:retstat(ls)
return true -- must be last statement
elseif c == "TK_BREAK" then -- stat -> breakstat
luaX:next(ls) -- skip BREAK
self:breakstat(ls)
return true -- must be last statement
else
self:exprstat(ls)
return false -- to avoid warnings
end--if c
end
------------------------------------------------------------------------
-- parse a chunk, which consists of a bunch of statements
-- * used in parser(), body(), block(), repeatstat()
------------------------------------------------------------------------
function luaY:chunk(ls)
-- chunk -> { stat [';'] }
local islast = false
self:enterlevel(ls)
while not islast and not self:block_follow(ls.t.token) do
islast = self:statement(ls)
self:testnext(ls, ";")
lua_assert(ls.fs.f.maxstacksize >= ls.fs.freereg and
ls.fs.freereg >= ls.fs.nactvar)
ls.fs.freereg = ls.fs.nactvar -- free registers
end
self:leavelevel(ls)
end
-- }======================================================================
luaX:init() -- required by llex
local LuaState = {} -- dummy, not actually used, but retained since
-- the intention is to complete a straight port
------------------------------------------------------------------------
-- interfacing to yueliang
------------------------------------------------------------------------
return function (source, name)
name = name or 'compiled-lua'
-- luaZ:make_getF returns a file chunk reader
-- luaZ:init returns a zio input stream
local zio = luaZ:init(luaZ:make_getF(source), nil)
if not zio then return end
-- luaY:parser parses the input stream
-- func is the function prototype in tabular form; in C, func can
-- now be used directly by the VM, this can't be done in Lua
local func = luaY:parser(LuaState, zio, nil, "@"..name)
-- luaU:make_setS returns a string chunk writer
local writer, buff = luaU:make_setS()
-- luaU:dump builds a binary chunk
luaU:dump(LuaState, func, writer, buff)
-- a string.dump equivalent in returned
return buff.data
end
end
fake_module_scripts[script] = module_script
end
About this script
SS execute its gui to lua so it might not work
