Skip to content
Merged
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
8 changes: 8 additions & 0 deletions lib/lua/compiler/codegen.ex
Original file line number Diff line number Diff line change
Expand Up @@ -43,6 +43,10 @@ defmodule Lua.Compiler.Codegen do
# Reverse to maintain order
prototypes: Enum.reverse(ctx.prototypes),
upvalue_descriptors: [],
# The chunk's implicit `_ENV` is its sole upvalue (Lua 5.3 §3.3.1). It has
# no descriptor (it is bound as register 0, not captured from a parent),
# so name it explicitly here for `debug.getupvalue`/`setupvalue`.
upvalue_names: ["_ENV"],
param_count: 0,
is_vararg: func_scope.is_vararg,
max_registers: Enum.max([func_scope.max_register, ctx.next_reg, Map.get(ctx, :peak_reg, 0)]),
Expand Down Expand Up @@ -1524,6 +1528,10 @@ defmodule Lua.Compiler.Codegen do
instructions: body_instructions,
prototypes: Enum.reverse(body_ctx.prototypes),
upvalue_descriptors: func_scope.upvalue_descriptors,
# Each descriptor carries its source name as the third element
# ({:parent_local, reg, name} | {:parent_upvalue, idx, name}); surface
# them in declaration order for the debug library.
upvalue_names: Enum.map(func_scope.upvalue_descriptors, &elem(&1, 2)),
param_count: func_scope.param_count,
is_vararg: func_scope.is_vararg,
max_registers: Enum.max([func_scope.max_register, body_ctx.next_reg, Map.get(body_ctx, :peak_reg, 0)]),
Expand Down
2 changes: 2 additions & 0 deletions lib/lua/compiler/prototype.ex
Original file line number Diff line number Diff line change
Expand Up @@ -16,6 +16,7 @@ defmodule Lua.Compiler.Prototype do
instructions: [instruction()],
prototypes: [t()],
upvalue_descriptors: [upvalue_descriptor()],
upvalue_names: [String.t()],
param_count: non_neg_integer(),
is_vararg: boolean(),
max_registers: non_neg_integer(),
Expand All @@ -33,6 +34,7 @@ defmodule Lua.Compiler.Prototype do
defstruct instructions: [],
prototypes: [],
upvalue_descriptors: [],
upvalue_names: [],
param_count: 0,
is_vararg: false,
max_registers: 0,
Expand Down
9 changes: 8 additions & 1 deletion lib/lua/vm/dispatcher.ex
Original file line number Diff line number Diff line change
Expand Up @@ -200,7 +200,14 @@ defmodule Lua.VM.Dispatcher do
dispatch(code, pc + 1, regs, upvalues, proto, state, cont, frames)

{@op_load_env, dest} ->
regs = :erlang.setelement(dest + 1, regs, State.g_ref(state))
env =
if tuple_size(upvalues) > 0 do
Map.get(state.upvalue_cells, :erlang.element(1, upvalues))
else
State.g_ref(state)
end

regs = :erlang.setelement(dest + 1, regs, env)
dispatch(code, pc + 1, regs, upvalues, proto, state, cont, frames)

{@op_get_upvalue, dest, index} ->
Expand Down
1 change: 1 addition & 0 deletions lib/lua/vm/display.ex
Original file line number Diff line number Diff line change
Expand Up @@ -129,6 +129,7 @@ defmodule Lua.VM.Display do
line: first_line,
arity: proto.param_count,
vararg?: proto.is_vararg,
upvalue_names: proto.upvalue_names,
ref: ref
}
end
Expand Down
12 changes: 11 additions & 1 deletion lib/lua/vm/display/closure.ex
Original file line number Diff line number Diff line change
Expand Up @@ -17,6 +17,8 @@ defmodule Lua.VM.Display.Closure do
have `:arity` equal to the fixed-parameter count; the variadic
flag is reflected by appending `+...` in the inspect output.
- `:vararg?` — true when the closure accepts varargs (`...`).
- `:upvalue_names` — the closure's upvalue names in declaration order
(for example `["_ENV"]` for a loaded chunk).
- `:ref` — the original `{:lua_closure, proto, upvalues}` tuple
so callers can still reach the live closure (for example via
`Lua.call_function/3`).
Expand All @@ -31,10 +33,11 @@ defmodule Lua.VM.Display.Closure do
line: non_neg_integer(),
arity: non_neg_integer(),
vararg?: boolean(),
upvalue_names: [String.t()],
ref: tuple()
}

defstruct [:source, :line, :arity, :vararg?, :ref]
defstruct [:source, :line, :arity, :vararg?, :ref, upvalue_names: []]

defimpl Inspect do
import Inspect.Algebra
Expand All @@ -43,13 +46,20 @@ defmodule Lua.VM.Display.Closure do
arity = Integer.to_string(c.arity || 0)
arity = if c.vararg?, do: arity <> "+...", else: arity

upvalues =
case c.upvalue_names || [] do
[] -> empty()
names -> concat([", upvalues: [", Enum.join(names, ", "), "]"])
end

concat([
"#Lua.Closure<source: ",
to_doc(c.source, opts),
", line: ",
Integer.to_string(c.line || 0),
", arity: ",
arity,
upvalues,
">"
])
end
Expand Down
17 changes: 14 additions & 3 deletions lib/lua/vm/executor.ex
Original file line number Diff line number Diff line change
Expand Up @@ -650,12 +650,14 @@ defmodule Lua.VM.Executor do
end

# ── load_env ───────────────────────────────────────────────────────────────
# Loads the runtime `_G` table reference into `dest`. Plan A16 emits this
# Loads the chunk's `_ENV` table reference into `dest`. Plan A16 emits this
# at the start of every chunk so `_ENV` (a chunk-level local at register 0)
# is initialised before user code runs.
# is initialised before user code runs. A chunk loaded with a custom
# environment carries it in upvalue slot 0 (see `Stdlib.compile_loaded_chunk`);
# otherwise `_ENV` defaults to the global table `_G`.

defp do_execute([{:load_env, dest} | rest], regs, upvalues, proto, state, cont, frames, line) do
regs = put_elem(regs, dest, State.g_ref(state))
regs = put_elem(regs, dest, load_env_value(upvalues, state))
do_execute(rest, regs, upvalues, proto, state, cont, frames, line)
end

Expand Down Expand Up @@ -2838,6 +2840,15 @@ defmodule Lua.VM.Executor do
%{state | open_upvalues: Map.reject(ou, fn {reg, _} -> reg >= threshold end)}
end

# Resolve the `_ENV` value for a chunk's `load_env` instruction: a custom
# environment lives in upvalue slot 0 when present (a chunk loaded via
# `load(..., env)`), otherwise default to the global table `_G`.
defp load_env_value(upvalues, state) when tuple_size(upvalues) > 0 do
Map.get(state.upvalue_cells, elem(upvalues, 0))
end

defp load_env_value(_upvalues, state), do: State.g_ref(state)

# ── Call helpers: copy args without allocating an intermediate list ────────
#
# `copy_args_to_regs` moves `count` values from `src_regs[src_off..]` into
Expand Down
39 changes: 26 additions & 13 deletions lib/lua/vm/stdlib.ex
Original file line number Diff line number Diff line change
Expand Up @@ -414,20 +414,20 @@ defmodule Lua.VM.Stdlib do
# is called repeatedly; each call must return a string piece, and the
# chunk ends when it returns nil, an empty string, or no value.
# Returns the compiled function, or (nil, error message) on failure.
defp lua_load([chunk | _rest], state) when is_binary(chunk) do
compile_loaded_chunk(chunk, state)
defp lua_load([chunk | rest], state) when is_binary(chunk) do
compile_loaded_chunk(chunk, load_env_arg(rest, state), state)
end

defp lua_load([{:lua_closure, _, _} = reader | _rest], state) do
load_from_reader(reader, state)
defp lua_load([{:lua_closure, _, _} = reader | rest], state) do
load_from_reader(reader, load_env_arg(rest, state), state)
end

defp lua_load([{:compiled_closure, _, _} = reader | _rest], state) do
load_from_reader(reader, state)
defp lua_load([{:compiled_closure, _, _} = reader | rest], state) do
load_from_reader(reader, load_env_arg(rest, state), state)
end

defp lua_load([{:native_func, _} = reader | _rest], state) do
load_from_reader(reader, state)
defp lua_load([{:native_func, _} = reader | rest], state) do
load_from_reader(reader, load_env_arg(rest, state), state)
end

defp lua_load([_other | _], state) do
Expand All @@ -444,16 +444,22 @@ defmodule Lua.VM.Stdlib do
# it signals end-of-chunk (nil or ""). Bails out with `(nil, error_msg)`
# if the reader ever returns a non-string non-nil value, mirroring the
# behavior of Lua 5.3's reference implementation.
defp load_from_reader(reader, state) do
defp load_from_reader(reader, env, state) do
case collect_reader_chunks(reader, state, []) do
{:ok, source, state} ->
compile_loaded_chunk(source, state)
compile_loaded_chunk(source, env, state)

{:error, msg, state} ->
{[nil, msg], state}
end
end

# The optional 4th argument to `load(chunk, chunkname, mode, env)` is the
# environment the loaded chunk sees as `_ENV`. When absent or nil it defaults
# to the current global table `_G` (Lua 5.3 §6.1).
defp load_env_arg([_chunkname, _mode, env | _], _state) when env != nil, do: env
defp load_env_arg(_rest, state), do: State.g_ref(state)

defp collect_reader_chunks(reader, state, acc) do
{results, state} = Executor.call_function(reader, [], state)

Expand All @@ -475,20 +481,27 @@ defmodule Lua.VM.Stdlib do
end
end

defp compile_loaded_chunk(source, state) do
defp compile_loaded_chunk(source, env, state) do
case Lua.Parser.parse(source) do
{:ok, ast} ->
# Compiler currently never returns errors, always succeeds — see
# `Lua.Compiler.compile!/2` for the matching note.
{:ok, prototype} = Lua.Compiler.compile(ast)

# A loaded chunk's sole upvalue is `_ENV`. Back it with a real cell
# holding `env` so `load_env` sources it (instead of `_G`), the chunk's
# global writes route through `env`, and `debug.getupvalue`/`setupvalue`
# can read and mutate it.
env_cell = make_ref()
state = %{state | upvalue_cells: Map.put(state.upvalue_cells, env_cell, env)}

# When the bytecode compiler accepts the loaded chunk, surface
# it as a `:compiled_closure` so the dispatcher takes over.
# Otherwise fall back to the standard interpreted closure.
closure =
case prototype.bytecode do
nil -> {:lua_closure, prototype, {}}
_ -> {:compiled_closure, prototype, {}}
nil -> {:lua_closure, prototype, {env_cell}}
_ -> {:compiled_closure, prototype, {env_cell}}
end

{[closure], state}
Expand Down
50 changes: 46 additions & 4 deletions lib/lua/vm/stdlib/debug.ex
Original file line number Diff line number Diff line change
Expand Up @@ -16,8 +16,8 @@ defmodule Lua.VM.Stdlib.Debug do
- `debug.setlocal(level, local, value)` - Stub returning nil
- `debug.sethook([hook, mask [, count]])` - Stub no-op
- `debug.gethook([thread])` - Stub returning nil
- `debug.getupvalue(f, up)` - Stub returning nil
- `debug.setupvalue(f, up, value)` - Stub returning nil
- `debug.getupvalue(f, up)` - Returns the name and value of an upvalue
- `debug.setupvalue(f, up, value)` - Sets an upvalue, returning its name
- `debug.upvalueid(f, n)` - Stub returning nil
"""

Expand Down Expand Up @@ -211,12 +211,54 @@ defmodule Lua.VM.Stdlib.Debug do
defp debug_setmetatable([obj | _], state), do: {[obj], state}
defp debug_setmetatable([], state), do: {[nil], state}

# debug.getupvalue(f, up) — returns the name and value of the up-th upvalue of
# function `f`, or nil when `up` is out of range or `f` is not a Lua closure.
defp debug_getupvalue([closure, n | _], state) when is_number(n) do
case upvalue_slot(closure, n) do
{:ok, name, cell} -> {[name, Map.get(state.upvalue_cells, cell)], state}
:error -> {[nil], state}
end
end

defp debug_getupvalue(_args, state), do: {[nil], state}

# debug.setupvalue(f, up, value) — assigns `value` to the up-th upvalue of
# function `f`, returning its name (or nil when out of range / not a closure).
defp debug_setupvalue([closure, n | rest], state) when is_number(n) do
value = List.first(rest)

case upvalue_slot(closure, n) do
{:ok, name, cell} ->
{[name], %{state | upvalue_cells: Map.put(state.upvalue_cells, cell, value)}}

:error ->
{[nil], state}
end
end

defp debug_setupvalue(_args, state), do: {[nil], state}

# Resolve the up-th (1-based) upvalue of a closure to {name, cell_ref}. Every
# element of a closure's upvalue tuple is a cell ref keyed in
# `state.upvalue_cells`; the name comes from the prototype's `upvalue_names`,
# which is built alongside the upvalue tuple and is the same length by
# construction.
defp upvalue_slot({tag, proto, upvalues}, n) when tag in [:lua_closure, :compiled_closure] do
index = trunc(n) - 1

if index >= 0 and index < tuple_size(upvalues) do
{:ok, Enum.at(proto.upvalue_names, index), elem(upvalues, index)}
else
:error
end
end

defp upvalue_slot(_closure, _n), do: :error

# Stubs
defp debug_getlocal(_args, state), do: {[nil], state}
defp debug_setlocal(_args, state), do: {[nil], state}
defp debug_sethook(_args, state), do: {[], state}
defp debug_gethook(_args, state), do: {[nil, "", 0], state}
defp debug_getupvalue(_args, state), do: {[nil], state}
defp debug_setupvalue(_args, state), do: {[nil], state}
defp debug_upvalueid(_args, state), do: {[nil], state}
end
21 changes: 17 additions & 4 deletions tasks/suite_runner.ex
Original file line number Diff line number Diff line change
Expand Up @@ -139,18 +139,31 @@ defmodule Lua.SuiteRunner do
end

defp install_load(lua) do
Lua.set!(lua, ["load"], fn args, state ->
Lua.set!(lua, ["load"], fn args, lua ->
code = List.first(args)
chunk_name = Enum.at(args, 1, "<load>")
vm = lua.state

# A loaded chunk's sole upvalue is `_ENV`. Back it with a real cell
# holding the requested environment (the optional 4th arg, defaulting to
# `_G`) so `debug.getupvalue`/`setupvalue` and custom-env writes work —
# mirroring `Lua.VM.Stdlib.compile_loaded_chunk/3`.
env =
case Enum.at(args, 3) do
nil -> Lua.VM.State.g_ref(vm)
env -> env
end

case Lua.Parser.parse(code) do
{:ok, ast} ->
proto = Lua.Compiler.compile!(ast, source: chunk_name)
closure = {:lua_closure, proto, {}}
{[closure], state}
env_cell = make_ref()
vm = %{vm | upvalue_cells: Map.put(vm.upvalue_cells, env_cell, env)}
closure = {:lua_closure, proto, {env_cell}}
{[closure], %{lua | state: vm}}

{:error, error} ->
{[nil, "parse error: #{inspect(error)}"], state}
{[nil, "parse error: #{inspect(error)}"], lua}
end
end)
end
Expand Down
56 changes: 56 additions & 0 deletions test/language/stdlib/debug_test.exs
Original file line number Diff line number Diff line change
Expand Up @@ -65,4 +65,60 @@ defmodule Lua.Language.Stdlib.DebugTest do

assert {[nil, nil], _} = Lua.eval!(lua, code)
end

test "debug.getupvalue reads the _ENV upvalue of a loaded chunk", %{lua: lua} do
code = """
local name, val = debug.getupvalue(load"a=3", 1)
return name, val == _G
"""

assert {["_ENV", true], _} = Lua.eval!(lua, code)
end

test "load honors a custom environment, exposed as _ENV", %{lua: lua} do
code = """
local c = {}
local f = load("a = 3", nil, nil, c)
local name, val = debug.getupvalue(f, 1)
local before = c.a
f()
return name, val == c, before, c.a
"""

assert {["_ENV", true, nil, 3], _} = Lua.eval!(lua, code)
end

test "debug.getupvalue names captured upvalues and bounds-checks", %{lua: lua} do
# Every nested function captures `_ENV` as upvalue 1; explicit captures
# follow in declaration order. `debug.getupvalue(_, 3)` is out of range.
code = """
local x = 10
local function outer() return function() return x end end
local inner = outer()
local env_name = debug.getupvalue(inner, 1)
local name, val = debug.getupvalue(inner, 2)
return env_name, name, val, debug.getupvalue(inner, 3)
"""

assert {["_ENV", "x", 10, nil], _} = Lua.eval!(lua, code)
end

test "debug.setupvalue mutates an upvalue and returns its name", %{lua: lua} do
code = """
local x = 1
local function getx() return x end
local name = debug.setupvalue(getx, 2, 99)
return name, getx()
"""

assert {["x", 99], _} = Lua.eval!(lua, code)
end

test "debug.getupvalue returns nil for non-closures", %{lua: lua} do
code = """
return debug.getupvalue(print, 1), debug.getupvalue(42, 1)
"""

assert {[nil, nil], _} = Lua.eval!(lua, code)
end
end
3 changes: 2 additions & 1 deletion test/lua/vm/display_test.exs
Original file line number Diff line number Diff line change
Expand Up @@ -71,7 +71,8 @@ defmodule Lua.VM.DisplayTest do
assert %Closure{source: "<eval>", line: 1, arity: 2, vararg?: false, ref: ref} = c
assert match?({:lua_closure, _, _}, ref) or match?({:compiled_closure, _, _}, ref)

assert inspect(c) == "#Lua.Closure<source: \"<eval>\", line: 1, arity: 2>"
# The closure captures `_ENV` as an upvalue, surfaced in the inspect output.
assert inspect(c) == "#Lua.Closure<source: \"<eval>\", line: 1, arity: 2, upvalues: [_ENV]>"
end

test "wraps Lua closures returned in decode: false mode" do
Expand Down
Loading
Loading