239 lines
9.2 KiB
Plaintext
239 lines
9.2 KiB
Plaintext
#
|
|
This File contains actions for making actions and compile-time actions and some helper
|
|
functions to make that easier.
|
|
|
|
# Compile-time action to make compile-time actions:
|
|
immediately
|
|
lua> ".."
|
|
A_give_1_nickname_2 = compile_time(function(tree, \%action, \%nickname, is_compile_time)
|
|
local function arg_to_string(a) return tostring(nomsu:tree_to_lua(a)) end
|
|
local action_args = table.map(\%action:get_args(), arg_to_string)
|
|
local nickname_args = table.map(\%nickname:get_args(), arg_to_string)
|
|
if utils.equivalent(action_args, nickname_args) then
|
|
return Lua(tree.source, "A", string.as_lua_id(\%nickname.stub), " = A", string.as_lua_id(\%action.stub))
|
|
end
|
|
local lua = Lua(tree.source, "A", string.as_lua_id(\%nickname.stub), " = ")
|
|
if is_compile_time or COMPILE_TIME[_ENV["A"..string.as_lua_id(\%action.stub)]] then
|
|
lua:append("compile_time")
|
|
table.insert(action_args, 1, "tree")
|
|
table.insert(nickname_args, 1, "tree")
|
|
end
|
|
lua:append("(function(")
|
|
lua:concat_append(nickname_args, ", ")
|
|
lua:append(")\n return A", string.as_lua_id(\%action.stub), "(")
|
|
lua:concat_append(action_args, ", ")
|
|
lua:append(")\nend)")
|
|
return lua
|
|
end)
|
|
|
|
__MANGLE_INDEX = 0
|
|
A_parse_1_as_2 = compile_time(function(tree, \%actions, \%body)
|
|
local replacements = {}
|
|
for i,arg in ipairs(\%actions[1]:get_args()) do
|
|
replacements[arg[1]] = tostring(nomsu:tree_to_lua(arg))
|
|
end
|
|
local function make_tree(t)
|
|
if not AST.is_syntax_tree(t) then
|
|
return repr(t)
|
|
elseif t.type ~= 'Var' then
|
|
local args = table.map(t, make_tree)
|
|
table.insert(args, 1, repr(tostring(t.source)))
|
|
return t.type.."("..table.concat(args, ", ")..")"
|
|
elseif replacements[t[1]] then
|
|
return replacements[t[1]]
|
|
else
|
|
return t.type.."("..repr(tostring(t.source))..", "..repr(t[1].." \\0").."..('%X'):format(__MANGLE_INDEX))"
|
|
end
|
|
end
|
|
local lua = Lua(tree.source, "A", string.as_lua_id(\%actions[1].stub), " = compile_time(function(tree")
|
|
for _,arg in ipairs(\%actions[1]:get_args()) do
|
|
lua:append(", ", nomsu:tree_to_lua(arg))
|
|
end
|
|
lua:append(")\n __MANGLE_INDEX = __MANGLE_INDEX + 1",
|
|
"\n local tree = ", make_tree(\%body),
|
|
"\n local lua = nomsu:tree_to_lua(tree)",
|
|
"\n lua:remove_free_vars({")
|
|
local vars = table.map(\%actions[1]:get_args(), function(a)
|
|
return "Var("..repr(tostring(a.source))..", "..repr(a[1])..")"
|
|
end)
|
|
lua:concat_append(vars, ", ")
|
|
lua:append("})\n return lua\nend)")
|
|
|
|
for i=2,#\%actions do
|
|
lua:append("\n", A_give_1_nickname_2(\%actions[i], \%actions[1], \%actions[i], true))
|
|
end
|
|
return lua
|
|
end)
|
|
|
|
A_action_1_2 = compile_time(function(tree, \%actions, \%body, is_compile_time)
|
|
local lua = Lua(tree.source, "A", string.as_lua_id(\%actions[1].stub), " = ")
|
|
if is_compile_time then lua:append("compile_time") end
|
|
lua:append("(function(")
|
|
local args = \%actions[1]:get_args()
|
|
local lua_args = table.map(args, function(a) return nomsu:tree_to_lua(a) end)
|
|
if is_compile_time then table.insert(lua_args, 1, "tree") end
|
|
lua:concat_append(lua_args, ", ")
|
|
local body_lua = nomsu:tree_to_lua(\%body):as_statements("return ")
|
|
body_lua:remove_free_vars(args)
|
|
body_lua:declare_locals()
|
|
lua:append(")\n ", body_lua, "\nend)")
|
|
for i=2,#\%actions do
|
|
lua:append("\n", A_give_1_nickname_2(\%actions[i], \%actions[1], \%actions[i], is_compile_time))
|
|
end
|
|
return lua
|
|
end)
|
|
|
|
A_compile_1_to_2 = compile_time(function(tree, \%actions, \%body)
|
|
return A_action_1_2(tree, \%actions, \%body, true)
|
|
end)
|
|
|
|
compile [remove action %action] to
|
|
Lua ".."
|
|
A\(=lua "string.as_lua_id(\(%action.stub))") = nil
|
|
ARG_ORDERS[fn] = nil
|
|
COMPILE_TIME[fn] = nil
|
|
|
|
immediately
|
|
action [read file %filename]
|
|
lua> ".."
|
|
local file = io.open(\%filename)
|
|
local contents = file:read("*a")
|
|
file:close()
|
|
return contents
|
|
|
|
action [sh> %cmd]
|
|
lua> ".."
|
|
local result = io.popen(\%cmd)
|
|
local contents = result:read("*a")
|
|
result:close()
|
|
return contents
|
|
|
|
action [%tree as nomsu]
|
|
=lua "nomsu:tree_to_nomsu(\%tree)"
|
|
|
|
action [%tree as inline nomsu]
|
|
=lua "nomsu:tree_to_nomsu(\%tree, true)"
|
|
|
|
action [%tree as lua]
|
|
=lua "nomsu:tree_to_lua(\%tree)"
|
|
|
|
action [%tree as lua expr]
|
|
lua> ".."
|
|
local lua = nomsu:tree_to_lua(\%tree)
|
|
if not lua.is_value then
|
|
compile_error(\%tree, "Invalid thing to convert to lua expr:\n%s")
|
|
end
|
|
return lua
|
|
|
|
action [%tree as lua statements]
|
|
=lua "nomsu:tree_to_lua(\%tree):as_statements()"
|
|
|
|
action [%tree as lua return]
|
|
=lua "nomsu:tree_to_lua(\%tree):as_statements('return ')"
|
|
|
|
action [%var as lua identifier]
|
|
=lua "type(\%var) == 'string' and string.as_lua_id(\%var) or nomsu:tree_to_lua(\%var)"
|
|
|
|
immediately
|
|
compile [parse %text] to
|
|
Lua value ".."
|
|
nomsu:parse(Nomsu("\("\(%text.source)")", \(%text as lua expr)))
|
|
|
|
immediately
|
|
compile [%tree with %t -> %replacement] to
|
|
Lua value ".."
|
|
\(%tree as lua expr):map(function(\(%t as lua expr))
|
|
\(%replacement as lua return)
|
|
end)
|
|
|
|
compile [declare locals in %code] to
|
|
Lua value "\(%code as lua expr):declare_locals()"
|
|
|
|
compile [declare locals %locals in %code] to
|
|
Lua value "\(%code as lua expr):declare_locals(\(%locals as lua expr))"
|
|
|
|
compile [remove free vars %vars from %code] to
|
|
Lua "\(%code as lua expr):remove_free_vars(\(%vars as lua expr));"
|
|
|
|
action [%tree as value]
|
|
lua> ".."
|
|
if \%tree.type == 'Text' and #\%tree == 1 and type(\%tree[1]) == 'string' then
|
|
return \%tree[1]
|
|
end
|
|
local lua = Lua(\%tree.source, "return ",nomsu:tree_to_lua(\%tree))
|
|
return nomsu:run_lua(lua)
|
|
|
|
immediately
|
|
parse [%lua <-write %code, to %lua write %code] as: lua> "\%lua:append(\%code);"
|
|
|
|
immediately
|
|
compile [quote %s] to
|
|
Lua value ".."
|
|
('"'..\(%s as lua expr):gsub("\\\\", "\\\\\\\\"):gsub("\n","\\\\n"):gsub('"', '\\\\"')..'"')
|
|
compile [type of %obj] to: Lua value "type(\(%obj as lua expr))"
|
|
|
|
immediately
|
|
compile [nomsu] to: Lua value "nomsu"
|
|
|
|
# Compiler tools
|
|
immediately
|
|
compile [run %code] to
|
|
Lua value "nomsu:run(Nomsu(\(quote "\(%code.source)"), \(%code as lua expr)))"
|
|
|
|
immediately
|
|
compile [show lua %block] to
|
|
lua> ".."
|
|
local \%lua = nomsu:tree_to_lua(\%block);
|
|
return Lua(tree.source, "print(", repr(tostring(\%lua)), ");");
|
|
|
|
immediately
|
|
compile [say %message] to
|
|
lua> ".."
|
|
if \%message.type == "Text" then
|
|
return Lua(tree.source, "io.write(", \(%message as lua expr), ", '\\\\n');");
|
|
else
|
|
return Lua(tree.source, "io.write(tostring(", \(%message as lua expr), "), '\\\\n');");
|
|
end
|
|
|
|
compile [ask %prompt] to
|
|
lua> ".."
|
|
if \%prompt.type == "Text" then
|
|
return Lua.Value(tree.source, "(io.write(", \(%prompt as lua expr), ") and io.read())");
|
|
else
|
|
return Lua.Value(tree.source, "(io.write(tostring(", \(%prompt as lua expr), ")) and io.read())");
|
|
end
|
|
|
|
# Return
|
|
immediately
|
|
# Return statement is wrapped in a do..end block because Lua is unhappy if you
|
|
put code after a return statement, unless you wrap it in a block.
|
|
compile [return] to: Lua "do return; end"
|
|
compile [return %return_value] to: Lua "do return \(%return_value as lua expr); end"
|
|
|
|
# Error functions
|
|
immediately
|
|
compile [traceback] to: Lua value "debug.traceback()"
|
|
compile [traceback %] to: Lua value "debug.traceback('', \(% as lua expr))"
|
|
compile [barf] to: Lua "error(nil, 0);"
|
|
compile [barf %msg] to: Lua "error(\(%msg as lua expr), 0);"
|
|
compile [assume %condition] to
|
|
lua> "local \%assumption = 'Assumption failed: '..tostring(nomsu:tree_to_nomsu(\%condition));"
|
|
return
|
|
Lua ".."
|
|
if not \(%condition as lua expr) then
|
|
error(\(quote "\%assumption"), 0);
|
|
end
|
|
|
|
compile [assume %condition or barf %message] to
|
|
Lua ".."
|
|
if not \(%condition as lua expr) then
|
|
error(\(%message as lua expr), 0);
|
|
end
|
|
|
|
# Literals
|
|
immediately
|
|
compile [yes] to: Lua value "true"
|
|
compile [no] to: Lua value "false"
|
|
compile [nothing, nil, null] to: Lua value "nil"
|
|
|