@@ 1,28 1,39 @@
#!/usr/bin/env lua
+-- SPDX-License-Identifier: MIT
+-- SPDX-FileCopyrightText: Calvin Rose and contributors
package.preload["fennel.binary"] = package.preload["fennel.binary"] or function(...)
local fennel = require("fennel")
- local _767_ = require("fennel.utils")
- local copy = _767_["copy"]
- local warn = _767_["warn"]
+ local _787_ = require("fennel.utils")
+ local copy = _787_["copy"]
+ local warn = _787_["warn"]
local function shellout(command)
local f = io.popen(command)
local stdout = f:read("*all")
return (f:close() and stdout)
end
local function execute(cmd)
- local _768_0 = os.execute(cmd)
- if (_768_0 == 0) then
+ local _788_0 = os.execute(cmd)
+ if (_788_0 == 0) then
return true
- elseif (_768_0 == true) then
+ elseif (_788_0 == true) then
return true
end
end
local function string__3ec_hex_literal(characters)
- local hex = {}
- for character in characters:gmatch(".") do
- table.insert(hex, ("0x%02x"):format(string.byte(character)))
+ local _790_
+ do
+ local tbl_17_ = {}
+ local i_18_ = #tbl_17_
+ for character in characters:gmatch(".") do
+ local val_19_ = ("0x%02x"):format(string.byte(character))
+ if (nil ~= val_19_) then
+ i_18_ = (i_18_ + 1)
+ tbl_17_[i_18_] = val_19_
+ end
+ end
+ _790_ = tbl_17_
end
- return table.concat(hex, ", ")
+ return table.concat(_790_, ", ")
end
local c_shim = "#ifdef __cplusplus\nextern \"C\" {\n#endif\n#include <lauxlib.h>\n#include <lua.h>\n#include <lualib.h>\n#ifdef __cplusplus\n}\n#endif\n#include <signal.h>\n#include <stdio.h>\n#include <stdlib.h>\n#include <string.h>\n\n#if LUA_VERSION_NUM == 501\n #define LUA_OK 0\n#endif\n\n/* Copied from lua.c */\n\nstatic lua_State *globalL = NULL;\n\nstatic void lstop (lua_State *L, lua_Debug *ar) {\n (void)ar; /* unused arg. */\n lua_sethook(L, NULL, 0, 0); /* reset hook */\n luaL_error(L, \"interrupted!\");\n}\n\nstatic void laction (int i) {\n signal(i, SIG_DFL); /* if another SIGINT happens, terminate process */\n lua_sethook(globalL, lstop, LUA_MASKCALL | LUA_MASKRET | LUA_MASKCOUNT, 1);\n}\n\nstatic void createargtable (lua_State *L, char **argv, int argc, int script) {\n int i, narg;\n if (script == argc) script = 0; /* no script name? */\n narg = argc - (script + 1); /* number of positive indices */\n lua_createtable(L, narg, script + 1);\n for (i = 0; i < argc; i++) {\n lua_pushstring(L, argv[i]);\n lua_rawseti(L, -2, i - script);\n }\n lua_setglobal(L, \"arg\");\n}\n\nstatic int msghandler (lua_State *L) {\n const char *msg = lua_tostring(L, 1);\n if (msg == NULL) { /* is error object not a string? */\n if (luaL_callmeta(L, 1, \"__tostring\") && /* does it have a metamethod */\n lua_type(L, -1) == LUA_TSTRING) /* that produces a string? */\n return 1; /* that is the message */\n else\n msg = lua_pushfstring(L, \"(error object is a %%s value)\",\n luaL_typename(L, 1));\n }\n /* Call debug.traceback() instead of luaL_traceback() for Lua 5.1 compat. */\n lua_getglobal(L, \"debug\");\n lua_getfield(L, -1, \"traceback\");\n /* debug */\n lua_remove(L, -2);\n lua_pushstring(L, msg);\n /* original msg */\n lua_remove(L, -3);\n lua_pushinteger(L, 2); /* skip this function and traceback */\n lua_call(L, 2, 1); /* call debug.traceback */\n return 1; /* return the traceback */\n}\n\nstatic int docall (lua_State *L, int narg, int nres) {\n int status;\n int base = lua_gettop(L) - narg; /* function index */\n lua_pushcfunction(L, msghandler); /* push message handler */\n lua_insert(L, base); /* put it under function and args */\n globalL = L; /* to be available to 'laction' */\n signal(SIGINT, laction); /* set C-signal handler */\n status = lua_pcall(L, narg, nres, base);\n signal(SIGINT, SIG_DFL); /* reset C-signal handler */\n lua_remove(L, base); /* remove message handler from the stack */\n return status;\n}\n\nint main(int argc, char *argv[]) {\n lua_State *L = luaL_newstate();\n luaL_openlibs(L);\n createargtable(L, argv, argc, 0);\n\n static const unsigned char lua_loader_program[] = {\n%s\n};\n if(luaL_loadbuffer(L, (const char*)lua_loader_program,\n sizeof(lua_loader_program), \"%s\") != LUA_OK) {\n fprintf(stderr, \"luaL_loadbuffer: %%s\\n\", lua_tostring(L, -1));\n lua_close(L);\n return 1;\n }\n\n /* lua_bundle */\n lua_newtable(L);\n static const unsigned char lua_require_1[] = {\n %s\n };\n lua_pushlstring(L, (const char*)lua_require_1, sizeof(lua_require_1));\n lua_setfield(L, -2, \"%s\");\n\n%s\n\n if (docall(L, 1, LUA_MULTRET)) {\n const char *errmsg = lua_tostring(L, 1);\n if (errmsg) {\n fprintf(stderr, \"%%s\\n\", errmsg);\n }\n lua_close(L);\n return 1;\n }\n lua_close(L);\n return 0;\n}"
local function compile_fennel(filename, options)
@@ 39,13 50,13 @@ package.preload["fennel.binary"] = package.preload["fennel.binary"] or function(
local function module_name(open, rename, used_renames)
local require_name = nil
do
- local _771_0 = rename[open]
- if (nil ~= _771_0) then
- local renamed = _771_0
+ local _793_0 = rename[open]
+ if (nil ~= _793_0) then
+ local renamed = _793_0
used_renames[open] = true
require_name = renamed
else
- local _ = _771_0
+ local _ = _793_0
require_name = open
end
end
@@ 84,14 95,14 @@ package.preload["fennel.binary"] = package.preload["fennel.binary"] or function(
local dotpath = filename:gsub("^%.%/", ""):gsub("[\\/]", ".")
local dotpath_noextension = (dotpath:match("(.+)%.") or dotpath)
local fennel_loader = nil
- local _775_
+ local _797_
do
- _775_ = "(do (local bundle_2_ ...) (fn loader_3_ [name_4_] (match (or (. bundle_2_ name_4_) (. bundle_2_ (.. name_4_ \".init\"))) (mod_5_ ? (= \"function\" (type mod_5_))) mod_5_ (mod_5_ ? (= \"string\" (type mod_5_))) (assert (if (= _VERSION \"Lua 5.1\") (loadstring mod_5_ name_4_) (load mod_5_ name_4_))) nil (values nil (: \"\n\\tmodule '%%s' not found in fennel bundle\" \"format\" name_4_)))) (table.insert (or package.loaders package.searchers) 2 loader_3_) ((assert (loader_3_ \"%s\")) ((or unpack table.unpack) arg)))"
+ _797_ = "(do (local bundle_2_ ...) (fn loader_3_ [name_4_] (match (or (. bundle_2_ name_4_) (. bundle_2_ (.. name_4_ \".init\"))) (mod_5_ ? (= \"function\" (type mod_5_))) mod_5_ (mod_5_ ? (= \"string\" (type mod_5_))) (assert (if (= _VERSION \"Lua 5.1\") (loadstring mod_5_ name_4_) (load mod_5_ name_4_))) nil (values nil (: \"\n\\tmodule '%%s' not found in fennel bundle\" \"format\" name_4_)))) (table.insert (or package.loaders package.searchers) 2 loader_3_) ((assert (loader_3_ \"%s\")) ((or unpack table.unpack) arg)))"
end
- fennel_loader = _775_:format(dotpath_noextension)
+ fennel_loader = _797_:format(dotpath_noextension)
local lua_loader = fennel["compile-string"](fennel_loader)
- local _776_ = options
- local rename_modules = _776_["rename-modules"]
+ local _798_ = options
+ local rename_modules = _798_["rename-modules"]
return c_shim:format(string__3ec_hex_literal(lua_loader), basename_noextension, string__3ec_hex_literal(compile_fennel(filename, options)), dotpath_noextension, native_loader(native, {["rename-modules"] = rename_modules}))
end
local function write_c(filename, native, options)
@@ 104,28 115,28 @@ package.preload["fennel.binary"] = package.preload["fennel.binary"] or function(
local function compile_binary(lua_c_path, executable_name, static_lua, lua_include_dir, native)
local cc = (os.getenv("CC") or "cc")
local rdynamic, bin_extension, ldl_3f = nil, nil, nil
- local _778_
+ local _800_
do
- local _777_0 = shellout((cc .. " -dumpmachine"))
- if (nil ~= _777_0) then
- _778_ = _777_0:match("mingw")
+ local _799_0 = shellout((cc .. " -dumpmachine"))
+ if (nil ~= _799_0) then
+ _800_ = _799_0:match("mingw")
else
- _778_ = _777_0
+ _800_ = _799_0
end
end
- if _778_ then
+ if _800_ then
rdynamic, bin_extension, ldl_3f = "", ".exe", false
else
rdynamic, bin_extension, ldl_3f = "-rdynamic", "", true
end
local compile_command = nil
- local _781_
+ local _803_
if ldl_3f then
- _781_ = "-ldl"
+ _803_ = "-ldl"
else
- _781_ = ""
+ _803_ = ""
end
- compile_command = {cc, "-Os", lua_c_path, table.concat(native, " "), static_lua, rdynamic, "-lm", _781_, "-o", (executable_name .. bin_extension), "-I", lua_include_dir, os.getenv("CC_OPTS")}
+ compile_command = {cc, "-Os", lua_c_path, table.concat(native, " "), static_lua, rdynamic, "-lm", _803_, "-o", (executable_name .. bin_extension), "-I", lua_include_dir, os.getenv("CC_OPTS")}
if os.getenv("FENNEL_DEBUG") then
print("Compiling with", table.concat(compile_command, " "))
end
@@ 143,17 154,17 @@ package.preload["fennel.binary"] = package.preload["fennel.binary"] or function(
if (version_extension and (version_extension ~= "") and not version_extension:match("%.%d+")) then
return false
else
- local _786_0 = extension
- if (_786_0 == "a") then
+ local _808_0 = extension
+ if (_808_0 == "a") then
return path
- elseif (_786_0 == "o") then
+ elseif (_808_0 == "o") then
return path
- elseif (_786_0 == "so") then
+ elseif (_808_0 == "so") then
return path
- elseif (_786_0 == "dylib") then
+ elseif (_808_0 == "dylib") then
return path
else
- local _ = _786_0
+ local _ = _808_0
return false
end
end
@@ 178,17 189,17 @@ package.preload["fennel.binary"] = package.preload["fennel.binary"] or function(
table.remove(args, i)
end
end
- if (0 < #args) then
+ if next(args) then
print(table.concat(args, " "))
error(("Unknown args: " .. table.concat(args, " ")))
end
return native
end
local function compile(filename, executable_name, static_lua, lua_include_dir, options, args)
- local _793_ = extract_native_args(args)
- local libraries = _793_["libraries"]
- local modules = _793_["modules"]
- local rename_modules = _793_["rename-modules"]
+ local _815_ = extract_native_args(args)
+ local libraries = _815_["libraries"]
+ local modules = _815_["modules"]
+ local rename_modules = _815_["rename-modules"]
local opts = {["rename-modules"] = rename_modules}
copy(options, opts)
return compile_binary(write_c(filename, modules, opts), executable_name, static_lua, lua_include_dir, libraries)
@@ 203,16 214,16 @@ package.preload["fennel.repl"] = package.preload["fennel.repl"] or function(...)
local compiler = require("fennel.compiler")
local specials = require("fennel.specials")
local view = require("fennel.view")
- local unpack = (table.unpack or _G.unpack)
- local function default_read_chunk(parser_state)
- local function _604_()
- if (0 < parser_state["stack-size"]) then
- return ".."
- else
- return ">> "
- end
+ local depth = 0
+ local function prompt_for(top_3f)
+ if top_3f then
+ return (string.rep(">", (depth + 1)) .. " ")
+ else
+ return (string.rep(".", (depth + 1)) .. " ")
end
- io.write(_604_())
+ end
+ local function default_read_chunk(parser_state)
+ io.write(prompt_for((0 == parser_state["stack-size"])))
io.flush()
local input = io.read()
return (input and (input .. "\n"))
@@ 222,18 233,18 @@ package.preload["fennel.repl"] = package.preload["fennel.repl"] or function(...)
return io.write("\n")
end
local function default_on_error(errtype, err, lua_source)
- local function _606_()
- local _605_0 = errtype
- if (_605_0 == "Lua Compile") then
+ local function _616_()
+ local _615_0 = errtype
+ if (_615_0 == "Lua Compile") then
return ("Bad code generated - likely a bug with the compiler:\n" .. "--- Generated Lua Start ---\n" .. lua_source .. "--- Generated Lua End ---\n")
- elseif (_605_0 == "Runtime") then
+ elseif (_615_0 == "Runtime") then
return (compiler.traceback(tostring(err), 4) .. "\n")
else
- local _ = _605_0
+ local _ = _615_0
return ("%s error: %s\n"):format(errtype, tostring(err))
end
end
- return io.write(_606_())
+ return io.write(_616_())
end
local function splice_save_locals(env, lua_source, scope)
local saves = nil
@@ 241,7 252,7 @@ package.preload["fennel.repl"] = package.preload["fennel.repl"] or function(...)
local tbl_17_ = {}
local i_18_ = #tbl_17_
for name in pairs(env.___replLocals___) do
- local val_19_ = ("local %s = ___replLocals___['%s']"):format((scope.manglings[name] or name), name)
+ local val_19_ = ("local %s = ___replLocals___[%q]"):format((scope.manglings[name] or name), name)
if (nil ~= val_19_) then
i_18_ = (i_18_ + 1)
tbl_17_[i_18_] = val_19_
@@ 256,7 267,7 @@ package.preload["fennel.repl"] = package.preload["fennel.repl"] or function(...)
for raw, name in pairs(scope.manglings) do
local val_19_ = nil
if not scope.gensyms[name] then
- val_19_ = ("___replLocals___['%s'] = %s"):format(raw, name)
+ val_19_ = ("___replLocals___[%q] = %s"):format(raw, name)
else
val_19_ = nil
end
@@ 273,25 284,25 @@ package.preload["fennel.repl"] = package.preload["fennel.repl"] or function(...)
else
gap = " "
end
- local function _612_()
+ local function _622_()
if next(saves) then
return (table.concat(saves, " ") .. gap)
else
return ""
end
end
- local function _615_()
- local _613_0, _614_0 = lua_source:match("^(.*)[\n ](return .*)$")
- if ((nil ~= _613_0) and (nil ~= _614_0)) then
- local body = _613_0
- local _return = _614_0
+ local function _625_()
+ local _623_0, _624_0 = lua_source:match("^(.*)[\n ](return .*)$")
+ if ((nil ~= _623_0) and (nil ~= _624_0)) then
+ local body = _623_0
+ local _return = _624_0
return (body .. gap .. table.concat(binds, " ") .. gap .. _return)
else
- local _ = _613_0
+ local _ = _623_0
return lua_source
end
end
- return (_612_() .. _615_())
+ return (_622_() .. _625_())
end
local function completer(env, scope, text)
local max_items = 2000
@@ 303,14 314,14 @@ package.preload["fennel.repl"] = package.preload["fennel.repl"] or function(...)
local scope_first_3f = ((tbl == env) or (tbl == env.___replLocals___))
local tbl_17_ = matches
local i_18_ = #tbl_17_
- local function _617_()
+ local function _627_()
if scope_first_3f then
return scope.manglings
else
return tbl
end
end
- for k, is_mangled in utils.allpairs(_617_()) do
+ for k, is_mangled in utils.allpairs(_627_()) do
if (max_items <= #matches) then break end
local val_19_ = nil
do
@@ 378,7 389,7 @@ package.preload["fennel.repl"] = package.preload["fennel.repl"] or function(...)
return input:match("^%s*,")
end
local function command_docs()
- local _626_
+ local _636_
do
local tbl_17_ = {}
local i_18_ = #tbl_17_
@@ 389,18 400,18 @@ package.preload["fennel.repl"] = package.preload["fennel.repl"] or function(...)
tbl_17_[i_18_] = val_19_
end
end
- _626_ = tbl_17_
+ _636_ = tbl_17_
end
- return table.concat(_626_, "\n")
+ return table.concat(_636_, "\n")
end
commands.help = function(_, _0, on_values)
- return on_values({("Welcome to Fennel.\nThis is the REPL where you can enter code to be evaluated.\nYou can also run these repl commands:\n\n" .. command_docs() .. "\n ,exit - Leave the repl.\n\nUse ,doc something to see descriptions for individual macros and special forms.\n\nFor more information about the language, see https://fennel-lang.org/reference")})
+ return on_values({("Welcome to Fennel.\nThis is the REPL where you can enter code to be evaluated.\nYou can also run these repl commands:\n\n" .. command_docs() .. "\n ,return FORM - Evaluate FORM and return its value to the REPL's caller.\n ,exit - Leave the repl.\n\nUse ,doc something to see descriptions for individual macros and special forms.\nValues from previous inputs are kept in *1, *2, and *3.\n\nFor more information about the language, see https://fennel-lang.org/reference")})
end
do end (compiler.metadata):set(commands.help, "fnl/docstring", "Show this message.")
local function reload(module_name, env, on_values, on_error)
- local _628_0, _629_0 = pcall(specials["load-code"]("return require(...)", env), module_name)
- if ((_628_0 == true) and (nil ~= _629_0)) then
- local old = _629_0
+ local _638_0, _639_0 = pcall(specials["load-code"]("return require(...)", env), module_name)
+ if ((_638_0 == true) and (nil ~= _639_0)) then
+ local old = _639_0
local _ = nil
package.loaded[module_name] = nil
_ = nil
@@ 425,8 436,8 @@ package.preload["fennel.repl"] = package.preload["fennel.repl"] or function(...)
package.loaded[module_name] = old
end
return on_values({"ok"})
- elseif ((_628_0 == false) and (nil ~= _629_0)) then
- local msg = _629_0
+ elseif ((_638_0 == false) and (nil ~= _639_0)) then
+ local msg = _639_0
if msg:match("loop or previous error loading module") then
package.loaded[module_name] = nil
return reload(module_name, env, on_values, on_error)
@@ 434,32 445,32 @@ package.preload["fennel.repl"] = package.preload["fennel.repl"] or function(...)
specials["macro-loaded"][module_name] = nil
return nil
else
- local function _634_()
- local _633_0 = msg:gsub("\n.*", "")
- return _633_0
+ local function _644_()
+ local _643_0 = msg:gsub("\n.*", "")
+ return _643_0
end
- return on_error("Runtime", _634_())
+ return on_error("Runtime", _644_())
end
end
end
local function run_command(read, on_error, f)
- local _637_0, _638_0, _639_0 = pcall(read)
- if ((_637_0 == true) and (_638_0 == true) and (nil ~= _639_0)) then
- local val = _639_0
- local _640_0, _641_0 = pcall(f, val)
- if ((_640_0 == false) and (nil ~= _641_0)) then
- local msg = _641_0
+ local _647_0, _648_0, _649_0 = pcall(read)
+ if ((_647_0 == true) and (_648_0 == true) and (nil ~= _649_0)) then
+ local val = _649_0
+ local _650_0, _651_0 = pcall(f, val)
+ if ((_650_0 == false) and (nil ~= _651_0)) then
+ local msg = _651_0
return on_error("Runtime", msg)
end
- elseif (_637_0 == false) then
+ elseif (_647_0 == false) then
return on_error("Parse", "Couldn't parse input.")
end
end
commands.reload = function(env, read, on_values, on_error)
- local function _644_(_241)
+ local function _654_(_241)
return reload(tostring(_241), env, on_values, on_error)
end
- return run_command(read, on_error, _644_)
+ return run_command(read, on_error, _654_)
end
do end (compiler.metadata):set(commands.reload, "fnl/docstring", "Reload the specified module.")
commands.reset = function(env, _, on_values)
@@ 468,28 479,28 @@ package.preload["fennel.repl"] = package.preload["fennel.repl"] or function(...)
end
do end (compiler.metadata):set(commands.reset, "fnl/docstring", "Erase all repl-local scope.")
commands.complete = function(env, read, on_values, on_error, scope, chars)
- local function _645_()
+ local function _655_()
return on_values(completer(env, scope, table.concat(chars):gsub(",complete +", ""):sub(1, -2)))
end
- return run_command(read, on_error, _645_)
+ return run_command(read, on_error, _655_)
end
do end (compiler.metadata):set(commands.complete, "fnl/docstring", "Print all possible completions for a given input symbol.")
local function apropos_2a(pattern, tbl, prefix, seen, names)
for name, subtbl in pairs(tbl) do
if (("string" == type(name)) and (package ~= subtbl)) then
- local _646_0 = type(subtbl)
- if (_646_0 == "function") then
+ local _656_0 = type(subtbl)
+ if (_656_0 == "function") then
if ((prefix .. name)):match(pattern) then
table.insert(names, (prefix .. name))
end
- elseif (_646_0 == "table") then
+ elseif (_656_0 == "table") then
if not seen[subtbl] then
- local _648_
+ local _658_
do
seen[subtbl] = true
- _648_ = seen
+ _658_ = seen
end
- apropos_2a(pattern, subtbl, (prefix .. name:gsub("%.", "/") .. "."), _648_, names)
+ apropos_2a(pattern, subtbl, (prefix .. name:gsub("%.", "/") .. "."), _658_, names)
end
end
end
@@ 510,10 521,10 @@ package.preload["fennel.repl"] = package.preload["fennel.repl"] or function(...)
return tbl_17_
end
commands.apropos = function(_env, read, on_values, on_error, _scope)
- local function _653_(_241)
+ local function _663_(_241)
return on_values(apropos(tostring(_241)))
end
- return run_command(read, on_error, _653_)
+ return run_command(read, on_error, _663_)
end
do end (compiler.metadata):set(commands.apropos, "fnl/docstring", "Print all functions matching a pattern in all loaded modules.")
local function apropos_follow_path(path)
@@ 533,12 544,12 @@ package.preload["fennel.repl"] = package.preload["fennel.repl"] or function(...)
local tgt = package.loaded
for _, path0 in ipairs(paths) do
if (nil == tgt) then break end
- local _656_
+ local _666_
do
- local _655_0 = path0:gsub("%/", ".")
- _656_ = _655_0
+ local _665_0 = path0:gsub("%/", ".")
+ _666_ = _665_0
end
- tgt = tgt[_656_]
+ tgt = tgt[_666_]
end
return tgt
end
@@ 550,9 561,9 @@ package.preload["fennel.repl"] = package.preload["fennel.repl"] or function(...)
do
local tgt = apropos_follow_path(path)
if ("function" == type(tgt)) then
- local _657_0 = (compiler.metadata):get(tgt, "fnl/docstring")
- if (nil ~= _657_0) then
- local docstr = _657_0
+ local _667_0 = (compiler.metadata):get(tgt, "fnl/docstring")
+ if (nil ~= _667_0) then
+ local docstr = _667_0
val_19_ = (docstr:match(pattern) and path)
else
val_19_ = nil
@@ 569,125 580,125 @@ package.preload["fennel.repl"] = package.preload["fennel.repl"] or function(...)
return tbl_17_
end
commands["apropos-doc"] = function(_env, read, on_values, on_error, _scope)
- local function _661_(_241)
+ local function _671_(_241)
return on_values(apropos_doc(tostring(_241)))
end
- return run_command(read, on_error, _661_)
+ return run_command(read, on_error, _671_)
end
do end (compiler.metadata):set(commands["apropos-doc"], "fnl/docstring", "Print all functions that match the pattern in their docs")
local function apropos_show_docs(on_values, pattern)
for _, path in ipairs(apropos(pattern)) do
local tgt = apropos_follow_path(path)
if (("function" == type(tgt)) and (compiler.metadata):get(tgt, "fnl/docstring")) then
- on_values(specials.doc(tgt, path))
- on_values()
+ on_values({specials.doc(tgt, path)})
+ on_values({})
end
end
return nil
end
commands["apropos-show-docs"] = function(_env, read, on_values, on_error)
- local function _663_(_241)
+ local function _673_(_241)
return apropos_show_docs(on_values, tostring(_241))
end
- return run_command(read, on_error, _663_)
+ return run_command(read, on_error, _673_)
end
do end (compiler.metadata):set(commands["apropos-show-docs"], "fnl/docstring", "Print all documentations matching a pattern in function name")
- local function resolve(identifier, _664_0, scope)
- local _665_ = _664_0
- local env = _665_
- local ___replLocals___ = _665_["___replLocals___"]
+ local function resolve(identifier, _674_0, scope)
+ local _675_ = _674_0
+ local env = _675_
+ local ___replLocals___ = _675_["___replLocals___"]
local e = nil
- local function _666_(_241, _242)
+ local function _676_(_241, _242)
return (___replLocals___[scope.unmanglings[_242]] or env[_242])
end
- e = setmetatable({}, {__index = _666_})
- local function _667_(...)
- local _668_0, _669_0 = ...
- if ((_668_0 == true) and (nil ~= _669_0)) then
- local code = _669_0
- local function _670_(...)
- local _671_0, _672_0 = ...
- if ((_671_0 == true) and (nil ~= _672_0)) then
- local val = _672_0
+ e = setmetatable({}, {__index = _676_})
+ local function _677_(...)
+ local _678_0, _679_0 = ...
+ if ((_678_0 == true) and (nil ~= _679_0)) then
+ local code = _679_0
+ local function _680_(...)
+ local _681_0, _682_0 = ...
+ if ((_681_0 == true) and (nil ~= _682_0)) then
+ local val = _682_0
return val
else
- local _ = _671_0
+ local _ = _681_0
return nil
end
end
- return _670_(pcall(specials["load-code"](code, e)))
+ return _680_(pcall(specials["load-code"](code, e)))
else
- local _ = _668_0
+ local _ = _678_0
return nil
end
end
- return _667_(pcall(compiler["compile-string"], tostring(identifier), {scope = scope}))
+ return _677_(pcall(compiler["compile-string"], tostring(identifier), {scope = scope}))
end
commands.find = function(env, read, on_values, on_error, scope)
- local function _675_(_241)
- local _676_0 = nil
+ local function _685_(_241)
+ local _686_0 = nil
do
- local _677_0 = utils["sym?"](_241)
- if (nil ~= _677_0) then
- local _678_0 = resolve(_677_0, env, scope)
- if (nil ~= _678_0) then
- _676_0 = debug.getinfo(_678_0)
+ local _687_0 = utils["sym?"](_241)
+ if (nil ~= _687_0) then
+ local _688_0 = resolve(_687_0, env, scope)
+ if (nil ~= _688_0) then
+ _686_0 = debug.getinfo(_688_0)
else
- _676_0 = _678_0
+ _686_0 = _688_0
end
else
- _676_0 = _677_0
+ _686_0 = _687_0
end
end
- if ((_G.type(_676_0) == "table") and (nil ~= _676_0.linedefined) and (nil ~= _676_0.short_src) and (nil ~= _676_0.source) and (_676_0.what == "Lua")) then
- local line = _676_0.linedefined
- local src = _676_0.short_src
- local source = _676_0.source
+ if ((_G.type(_686_0) == "table") and (nil ~= _686_0.linedefined) and (nil ~= _686_0.short_src) and (nil ~= _686_0.source) and (_686_0.what == "Lua")) then
+ local line = _686_0.linedefined
+ local src = _686_0.short_src
+ local source = _686_0.source
local fnlsrc = nil
do
- local _681_0 = compiler.sourcemap
- if (nil ~= _681_0) then
- _681_0 = _681_0[source]
+ local _691_0 = compiler.sourcemap
+ if (nil ~= _691_0) then
+ _691_0 = _691_0[source]
end
- if (nil ~= _681_0) then
- _681_0 = _681_0[line]
+ if (nil ~= _691_0) then
+ _691_0 = _691_0[line]
end
- if (nil ~= _681_0) then
- _681_0 = _681_0[2]
+ if (nil ~= _691_0) then
+ _691_0 = _691_0[2]
end
- fnlsrc = _681_0
+ fnlsrc = _691_0
end
return on_values({string.format("%s:%s", src, (fnlsrc or line))})
- elseif (_676_0 == nil) then
+ elseif (_686_0 == nil) then
return on_error("Repl", "Unknown value")
else
- local _ = _676_0
+ local _ = _686_0
return on_error("Repl", "No source info")
end
end
- return run_command(read, on_error, _675_)
+ return run_command(read, on_error, _685_)
end
do end (compiler.metadata):set(commands.find, "fnl/docstring", "Print the filename and line number for a given function")
commands.doc = function(env, read, on_values, on_error, scope)
- local function _686_(_241)
+ local function _696_(_241)
local name = tostring(_241)
local path = (utils["multi-sym?"](name) or {name})
local ok_3f, target = nil, nil
- local function _687_()
+ local function _697_()
return (utils["get-in"](scope.specials, path) or utils["get-in"](scope.macros, path) or resolve(name, env, scope))
end
- ok_3f, target = pcall(_687_)
+ ok_3f, target = pcall(_697_)
if ok_3f then
return on_values({specials.doc(target, name)})
else
return on_error("Repl", ("Could not find " .. name .. " for docs."))
end
end
- return run_command(read, on_error, _686_)
+ return run_command(read, on_error, _696_)
end
do end (compiler.metadata):set(commands.doc, "fnl/docstring", "Print the docstring and arglist for a function, macro, or special form.")
commands.compile = function(env, read, on_values, on_error, scope)
- local function _689_(_241)
+ local function _699_(_241)
local allowedGlobals = specials["current-global-names"](env)
local ok_3f, result = pcall(compiler.compile, _241, {allowedGlobals = allowedGlobals, env = env, scope = scope})
if ok_3f then
@@ 696,16 707,16 @@ package.preload["fennel.repl"] = package.preload["fennel.repl"] or function(...)
return on_error("Repl", ("Error compiling expression: " .. result))
end
end
- return run_command(read, on_error, _689_)
+ return run_command(read, on_error, _699_)
end
do end (compiler.metadata):set(commands.compile, "fnl/docstring", "compiles the expression into lua and prints the result.")
local function load_plugin_commands(plugins)
- for _, plugin in ipairs((plugins or {})) do
- for name, f in pairs(plugin) do
- local _691_0 = name:match("^repl%-command%-(.*)")
- if (nil ~= _691_0) then
- local cmd_name = _691_0
- commands[cmd_name] = (commands[cmd_name] or f)
+ for i = #(plugins or {}), 1, -1 do
+ for name, f in pairs(plugins[i]) do
+ local _701_0 = name:match("^repl%-command%-(.*)")
+ if (nil ~= _701_0) then
+ local cmd_name = _701_0
+ commands[cmd_name] = f
end
end
end
@@ 714,19 725,19 @@ package.preload["fennel.repl"] = package.preload["fennel.repl"] or function(...)
local function run_command_loop(input, read, loop, env, on_values, on_error, scope, chars)
local command_name = input:match(",([^%s/]+)")
do
- local _693_0 = commands[command_name]
- if (nil ~= _693_0) then
- local command = _693_0
+ local _703_0 = commands[command_name]
+ if (nil ~= _703_0) then
+ local command = _703_0
command(env, read, on_values, on_error, scope, chars)
else
- local _ = _693_0
- if ("exit" ~= command_name) then
+ local _ = _703_0
+ if ((command_name ~= "exit") and (command_name ~= "return")) then
on_values({"Unknown command", command_name})
end
end
end
if ("exit" ~= command_name) then
- return loop()
+ return loop((command_name == "return"))
end
end
local function try_readline_21(opts, ok, readline)
@@ 769,9 780,9 @@ package.preload["fennel.repl"] = package.preload["fennel.repl"] or function(...)
end
local function repl(_3foptions)
local old_root_options = utils.root.options
- local _702_ = utils.copy(_3foptions)
- local opts = _702_
- local _3ffennelrc = _702_["fennelrc"]
+ local _712_ = utils.copy(_3foptions)
+ local opts = _712_
+ local _3ffennelrc = _712_["fennelrc"]
local _ = nil
opts.fennelrc = nil
_ = nil
@@ 786,35 797,42 @@ package.preload["fennel.repl"] = package.preload["fennel.repl"] or function(...)
local callbacks = {env = env, onError = (opts.onError or default_on_error), onValues = (opts.onValues or default_on_values), pp = (opts.pp or view), readChunk = (opts.readChunk or default_read_chunk)}
local save_locals_3f = (opts.saveLocals ~= false)
local byte_stream, clear_stream = nil, nil
- local function _704_(_241)
+ local function _714_(_241)
return callbacks.readChunk(_241)
end
- byte_stream, clear_stream = parser.granulate(_704_)
+ byte_stream, clear_stream = parser.granulate(_714_)
local chars = {}
local read, reset = nil, nil
- local function _705_(parser_state)
+ local function _715_(parser_state)
local b = byte_stream(parser_state)
if b then
table.insert(chars, string.char(b))
end
return b
end
- read, reset = parser.parser(_705_)
+ read, reset = parser.parser(_715_)
+ depth = (depth + 1)
+ if opts.message then
+ callbacks.onValues({opts.message})
+ end
env.___repl___ = callbacks
opts.env, opts.scope = env, compiler["make-scope"]()
opts.useMetadata = (opts.useMetadata ~= false)
if (opts.allowedGlobals == nil) then
opts.allowedGlobals = specials["current-global-names"](env)
end
+ if opts.init then
+ opts.init(opts, depth)
+ end
if opts.registerCompleter then
- local function _709_()
- local _708_0 = opts.scope
- local function _710_(...)
- return completer(env, _708_0, ...)
+ local function _721_()
+ local _720_0 = opts.scope
+ local function _722_(...)
+ return completer(env, _720_0, ...)
end
- return _710_
+ return _722_
end
- opts.registerCompleter(_709_())
+ opts.registerCompleter(_721_())
end
load_plugin_commands(opts.plugins)
if save_locals_3f then
@@ 835,12 853,21 @@ package.preload["fennel.repl"] = package.preload["fennel.repl"] or function(...)
end
return callbacks.onValues(out)
end
- local function loop()
+ local function save_value(...)
+ env.___replLocals___["*3"] = env.___replLocals___["*2"]
+ env.___replLocals___["*2"] = env.___replLocals___["*1"]
+ env.___replLocals___["*1"] = ...
+ return ...
+ end
+ opts.scope.manglings["*1"], opts.scope.unmanglings._1 = "_1", "*1"
+ opts.scope.manglings["*2"], opts.scope.unmanglings._2 = "_2", "*2"
+ opts.scope.manglings["*3"], opts.scope.unmanglings._3 = "_3", "*3"
+ local function loop(exit_next_3f)
for k in pairs(chars) do
chars[k] = nil
end
reset()
- local ok, parser_not_eof_3f, x = pcall(read)
+ local ok, parser_not_eof_3f, form = pcall(read)
local src_string = table.concat(chars)
local readline_not_eof_3f = (not readline or (src_string ~= "(null)"))
local not_eof_3f = (readline_not_eof_3f and parser_not_eof_3f)
@@ 852,54 879,71 @@ package.preload["fennel.repl"] = package.preload["fennel.repl"] or function(...)
return run_command_loop(src_string, read, loop, env, callbacks.onValues, callbacks.onError, opts.scope, chars)
else
if not_eof_3f then
- do
- local _714_0, _715_0 = nil, nil
- local function _716_()
- opts["source"] = src_string
- return opts
- end
- _714_0, _715_0 = pcall(compiler.compile, x, _716_())
- if ((_714_0 == false) and (nil ~= _715_0)) then
- local msg = _715_0
- clear_stream()
- callbacks.onError("Compile", msg)
- elseif ((_714_0 == true) and (nil ~= _715_0)) then
- local src = _715_0
- local src0 = nil
- if save_locals_3f then
- src0 = splice_save_locals(env, src, opts.scope)
- else
- src0 = src
- end
- local _718_0, _719_0 = pcall(specials["load-code"], src0, env)
- if ((_718_0 == false) and (nil ~= _719_0)) then
- local msg = _719_0
- clear_stream()
- callbacks.onError("Lua Compile", msg, src0)
- elseif (true and (nil ~= _719_0)) then
- local _1 = _718_0
- local chunk = _719_0
- local function _720_()
- return print_values(chunk())
+ local function _726_(...)
+ local _727_0, _728_0 = ...
+ if ((_727_0 == true) and (nil ~= _728_0)) then
+ local src = _728_0
+ local function _729_(...)
+ local _730_0, _731_0 = ...
+ if ((_730_0 == true) and (nil ~= _731_0)) then
+ local chunk = _731_0
+ local function _732_()
+ return print_values(save_value(chunk()))
+ end
+ local function _733_(...)
+ return callbacks.onError("Runtime", ...)
+ end
+ return xpcall(_732_, _733_)
+ elseif ((_730_0 == false) and (nil ~= _731_0)) then
+ local msg = _731_0
+ clear_stream()
+ return callbacks.onError("Compile", msg)
end
- local function _721_(...)
- return callbacks.onError("Runtime", ...)
+ end
+ local function _736_(...)
+ local src0 = nil
+ if save_locals_3f then
+ src0 = splice_save_locals(env, src, opts.scope)
+ else
+ src0 = src
end
- xpcall(_720_, _721_)
+ return pcall(specials["load-code"], src0, env)
end
+ return _729_(_736_(...))
+ elseif ((_727_0 == false) and (nil ~= _728_0)) then
+ local msg = _728_0
+ clear_stream()
+ return callbacks.onError("Compile", msg)
end
end
+ local function _738_()
+ opts["source"] = src_string
+ return opts
+ end
+ _726_(pcall(compiler.compile, form, _738_()))
utils.root.options = old_root_options
- return loop()
+ if exit_next_3f then
+ return env.___replLocals___["*1"]
+ else
+ return loop()
+ end
end
end
end
- loop()
+ local value = loop()
+ depth = (depth - 1)
if readline then
- return readline.save_history()
+ readline.save_history()
+ end
+ if opts.exit then
+ opts.exit(opts, depth)
end
+ return value
end
- return repl
+ local function _744_(overrides, _3fopts)
+ return repl(utils.copy(_3fopts, utils.copy(overrides)))
+ end
+ return setmetatable({}, {__call = _744_, __index = {repl = repl}})
end
package.preload["fennel.specials"] = package.preload["fennel.specials"] or function(...)
local utils = require("fennel.utils")
@@ 909,14 953,14 @@ package.preload["fennel.specials"] = package.preload["fennel.specials"] or funct
local unpack = (table.unpack or _G.unpack)
local SPECIALS = compiler.scopes.global.specials
local function wrap_env(env)
- local function _415_(_, key)
+ local function _420_(_, key)
if utils["string?"](key) then
return env[compiler["global-unmangling"](key)]
else
return env[key]
end
end
- local function _417_(_, key, value)
+ local function _422_(_, key, value)
if utils["string?"](key) then
env[compiler["global-unmangling"](key)] = value
return nil
@@ 925,26 969,29 @@ package.preload["fennel.specials"] = package.preload["fennel.specials"] or funct
return nil
end
end
- local function _419_()
+ local function _424_()
local function putenv(k, v)
- local _420_
+ local _425_
if utils["string?"](k) then
- _420_ = compiler["global-unmangling"](k)
+ _425_ = compiler["global-unmangling"](k)
else
- _420_ = k
+ _425_ = k
end
- return _420_, v
+ return _425_, v
end
return next, utils.kvmap(env, putenv), nil
end
- return setmetatable({}, {__index = _415_, __newindex = _417_, __pairs = _419_})
+ return setmetatable({}, {__index = _420_, __newindex = _422_, __pairs = _424_})
+ end
+ local function fennel_module_name()
+ return (utils.root.options.moduleName or "fennel")
end
local function current_global_names(_3fenv)
local mt = nil
do
- local _422_0 = getmetatable(_3fenv)
- if ((_G.type(_422_0) == "table") and (nil ~= _422_0.__pairs)) then
- local mtpairs = _422_0.__pairs
+ local _427_0 = getmetatable(_3fenv)
+ if ((_G.type(_427_0) == "table") and (nil ~= _427_0.__pairs)) then
+ local mtpairs = _427_0.__pairs
local tbl_14_ = {}
for k, v in mtpairs(_3fenv) do
local k_15_, v_16_ = k, v
@@ 953,7 1000,7 @@ package.preload["fennel.specials"] = package.preload["fennel.specials"] or funct
end
end
mt = tbl_14_
- elseif (_422_0 == nil) then
+ elseif (_427_0 == nil) then
mt = (_3fenv or _G)
else
mt = nil
@@ 963,15 1010,15 @@ package.preload["fennel.specials"] = package.preload["fennel.specials"] or funct
end
local function load_code(code, _3fenv, _3ffilename)
local env = (_3fenv or rawget(_G, "_ENV") or _G)
- local _425_0, _426_0 = rawget(_G, "setfenv"), rawget(_G, "loadstring")
- if ((nil ~= _425_0) and (nil ~= _426_0)) then
- local setfenv = _425_0
- local loadstring = _426_0
+ local _430_0, _431_0 = rawget(_G, "setfenv"), rawget(_G, "loadstring")
+ if ((nil ~= _430_0) and (nil ~= _431_0)) then
+ local setfenv = _430_0
+ local loadstring = _431_0
local f = assert(loadstring(code, _3ffilename))
setfenv(f, env)
return f
else
- local _ = _425_0
+ local _ = _430_0
return assert(load(code, _3ffilename, "t", env))
end
end
@@ 983,13 1030,13 @@ package.preload["fennel.specials"] = package.preload["fennel.specials"] or funct
local mt = getmetatable(tgt)
if ((type(tgt) == "function") or ((type(mt) == "table") and (type(mt.__call) == "function"))) then
local arglist = table.concat(((compiler.metadata):get(tgt, "fnl/arglist") or {"#<unknown-arguments>"}), " ")
- local _428_
+ local _433_
if (0 < #arglist) then
- _428_ = " "
+ _433_ = " "
else
- _428_ = ""
+ _433_ = ""
end
- return string.format("(%s%s%s)\n %s", name, _428_, arglist, docstring)
+ return string.format("(%s%s%s)\n %s", name, _433_, arglist, docstring)
else
return string.format("%s\n %s", name, docstring)
end
@@ 1014,17 1061,14 @@ package.preload["fennel.specials"] = package.preload["fennel.specials"] or funct
local chunk = (_3fchunk or {})
local len = #ast
local retexprs = {returned = true}
+ utils.hook("pre-do", ast, sub_scope)
local function compile_body(outer_target, outer_tail, outer_retexprs)
- if (len < start) then
- compiler.compile1(nil, sub_scope, chunk, {tail = outer_tail, target = outer_target})
- else
- for i = start, len do
- local subopts = {nval = (((i ~= len) and 0) or opts.nval), tail = (((i == len) and outer_tail) or nil), target = (((i == len) and outer_target) or nil)}
- local _ = utils["propagate-options"](opts, subopts)
- local subexprs = compiler.compile1(ast[i], sub_scope, chunk, subopts)
- if (i ~= len) then
- compiler["keep-side-effects"](subexprs, parent, nil, ast[i])
- end
+ for i = start, len do
+ local subopts = {nval = (((i ~= len) and 0) or opts.nval), tail = (((i == len) and outer_tail) or nil), target = (((i == len) and outer_target) or nil)}
+ local _ = utils["propagate-options"](opts, subopts)
+ local subexprs = compiler.compile1(ast[i], sub_scope, chunk, subopts)
+ if (i ~= len) then
+ compiler["keep-side-effects"](subexprs, parent, nil, ast[i])
end
end
compiler.emit(parent, chunk, ast)
@@ 1102,9 1146,9 @@ package.preload["fennel.specials"] = package.preload["fennel.specials"] or funct
local opts = {nval = 1, tail = false}
local scope = compiler["make-scope"]()
local chunk = {}
- local _439_ = compiler.compile1(v, scope, chunk, opts)
- local _440_ = _439_[1]
- local v0 = _440_[1]
+ local _443_ = compiler.compile1(v, scope, chunk, opts)
+ local _444_ = _443_[1]
+ local v0 = _444_[1]
return v0
end
local function insert_meta(meta, k, v)
@@ 1112,23 1156,23 @@ package.preload["fennel.specials"] = package.preload["fennel.specials"] or funct
compiler.assert((type(k) == "string"), ("expected string keys in metadata table, got: %s"):format(view(k, view_opts)))
compiler.assert(literal_3f(v), ("expected literal value in metadata table, got: %s %s"):format(view(k, view_opts), view(v, view_opts)))
table.insert(meta, view(k))
- local function _441_()
+ local function _445_()
if ("string" == type(v)) then
return view(v, view_opts)
else
return compile_value(v)
end
end
- table.insert(meta, _441_())
+ table.insert(meta, _445_())
return meta
end
local function insert_arglist(meta, arg_list)
local view_opts = {["escape-newlines?"] = true, ["line-length"] = math.huge, ["one-line?"] = true}
table.insert(meta, "\"fnl/arglist\"")
- local function _442_(_241)
+ local function _446_(_241)
return view(view(_241, view_opts))
end
- table.insert(meta, ("{" .. table.concat(utils.map(arg_list, _442_), ", ") .. "}"))
+ table.insert(meta, ("{" .. table.concat(utils.map(arg_list, _446_), ", ") .. "}"))
return meta
end
local function set_fn_metadata(f_metadata, parent, fn_name)
@@ 1141,34 1185,35 @@ package.preload["fennel.specials"] = package.preload["fennel.specials"] or funct
insert_meta(meta_fields, k, v)
end
end
- local meta_str = ("require(\"%s\").metadata"):format((utils.root.options.moduleName or "fennel"))
+ local meta_str = ("require(\"%s\").metadata"):format(fennel_module_name())
return compiler.emit(parent, ("pcall(function() %s:setall(%s, %s) end)"):format(meta_str, fn_name, table.concat(meta_fields, ", ")))
end
end
local function get_fn_name(ast, scope, fn_name, multi)
if (fn_name and (fn_name[1] ~= "nil")) then
- local _445_
+ local _449_
if not multi then
- _445_ = compiler["declare-local"](fn_name, {}, scope, ast)
+ _449_ = compiler["declare-local"](fn_name, {}, scope, ast)
else
- _445_ = compiler["symbol-to-expression"](fn_name, scope)[1]
+ _449_ = compiler["symbol-to-expression"](fn_name, scope)[1]
end
- return _445_, not multi, 3
+ return _449_, not multi, 3
else
return nil, true, 2
end
end
local function compile_named_fn(ast, f_scope, f_chunk, parent, index, fn_name, local_3f, arg_name_list, f_metadata)
+ utils.hook("pre-fn", ast, f_scope)
for i = (index + 1), #ast do
compiler.compile1(ast[i], f_scope, f_chunk, {nval = (((i ~= #ast) and 0) or nil), tail = (i == #ast)})
end
- local _448_
+ local _452_
if local_3f then
- _448_ = "local function %s(%s)"
+ _452_ = "local function %s(%s)"
else
- _448_ = "%s = function(%s)"
+ _452_ = "%s = function(%s)"
end
- compiler.emit(parent, string.format(_448_, fn_name, table.concat(arg_name_list, ", ")), ast)
+ compiler.emit(parent, string.format(_452_, fn_name, table.concat(arg_name_list, ", ")), ast)
compiler.emit(parent, f_chunk, ast)
compiler.emit(parent, "end", ast)
set_fn_metadata(f_metadata, parent, fn_name)
@@ 1190,7 1235,7 @@ package.preload["fennel.specials"] = package.preload["fennel.specials"] or funct
end
end
local function get_function_metadata(ast, arg_list, index)
- local function _451_(_241, _242)
+ local function _455_(_241, _242)
local tbl_14_ = _241
for k, v in pairs(_242) do
local k_15_, v_16_ = k, v
@@ 1200,18 1245,18 @@ package.preload["fennel.specials"] = package.preload["fennel.specials"] or funct
end
return tbl_14_
end
- local function _453_(_241, _242)
+ local function _457_(_241, _242)
_241["fnl/docstring"] = _242
return _241
end
- return maybe_metadata(ast, utils["kv-table?"], _451_, maybe_metadata(ast, utils["string?"], _453_, {["fnl/arglist"] = arg_list}, index))
+ return maybe_metadata(ast, utils["kv-table?"], _455_, maybe_metadata(ast, utils["string?"], _457_, {["fnl/arglist"] = arg_list}, index))
end
SPECIALS.fn = function(ast, scope, parent)
local f_scope = nil
do
- local _454_0 = compiler["make-scope"](scope)
- _454_0["vararg"] = false
- f_scope = _454_0
+ local _458_0 = compiler["make-scope"](scope)
+ _458_0["vararg"] = false
+ f_scope = _458_0
end
local f_chunk = {}
local fn_sym = utils["sym?"](ast[2])
@@ 1271,36 1316,37 @@ package.preload["fennel.specials"] = package.preload["fennel.specials"] or funct
doc_special("fn", {"name?", "args", "docstring?", "..."}, "Function syntax. May optionally include a name and docstring or a metadata table.\nIf a name is provided, the function will be bound in the current scope.\nWhen called with the wrong number of args, excess args will be discarded\nand lacking args will be nil, use lambda for arity-checked functions.", true)
SPECIALS.lua = function(ast, _, parent)
compiler.assert(((#ast == 2) or (#ast == 3)), "expected 1 or 2 arguments", ast)
- local _459_
+ local _463_
do
- local _458_0 = utils["sym?"](ast[2])
- if (nil ~= _458_0) then
- _459_ = tostring(_458_0)
+ local _462_0 = utils["sym?"](ast[2])
+ if (nil ~= _462_0) then
+ _463_ = tostring(_462_0)
else
- _459_ = _458_0
+ _463_ = _462_0
end
end
- if ("nil" ~= _459_) then
+ if ("nil" ~= _463_) then
table.insert(parent, {ast = ast, leaf = tostring(ast[2])})
end
- local _463_
+ local _467_
do
- local _462_0 = utils["sym?"](ast[3])
- if (nil ~= _462_0) then
- _463_ = tostring(_462_0)
+ local _466_0 = utils["sym?"](ast[3])
+ if (nil ~= _466_0) then
+ _467_ = tostring(_466_0)
else
- _463_ = _462_0
+ _467_ = _466_0
end
end
- if ("nil" ~= _463_) then
+ if ("nil" ~= _467_) then
return tostring(ast[3])
end
end
local function dot(ast, scope, parent)
compiler.assert((1 < #ast), "expected table argument", ast)
local len = #ast
- local _466_ = compiler.compile1(ast[2], scope, parent, {nval = 1})
- local lhs = _466_[1]
+ local lhs_node = compiler.macroexpand(ast[2], scope)
+ local _470_ = compiler.compile1(lhs_node, scope, parent, {nval = 1})
+ local lhs = _470_[1]
if (len == 2) then
return tostring(lhs)
else
@@ 1310,12 1356,12 @@ package.preload["fennel.specials"] = package.preload["fennel.specials"] or funct
if (utils["string?"](index) and utils["valid-lua-identifier?"](index)) then
table.insert(indices, ("." .. index))
else
- local _467_ = compiler.compile1(index, scope, parent, {nval = 1})
- local index0 = _467_[1]
+ local _471_ = compiler.compile1(index, scope, parent, {nval = 1})
+ local index0 = _471_[1]
table.insert(indices, ("[" .. tostring(index0) .. "]"))
end
end
- if (tostring(lhs):find("[{\"0-9]") or ("nil" == tostring(lhs))) then
+ if (not (utils["sym?"](lhs_node) or utils["list?"](lhs_node)) or ("nil" == tostring(lhs_node))) then
return ("(" .. tostring(lhs) .. ")" .. table.concat(indices))
else
return (tostring(lhs) .. table.concat(indices))
@@ 1356,7 1402,7 @@ package.preload["fennel.specials"] = package.preload["fennel.specials"] or funct
end
doc_special("var", {"name", "val"}, "Introduce new mutable local.")
local function kv_3f(t)
- local _471_
+ local _475_
do
local tbl_17_ = {}
local i_18_ = #tbl_17_
@@ 1372,9 1418,9 @@ package.preload["fennel.specials"] = package.preload["fennel.specials"] or funct
tbl_17_[i_18_] = val_19_
end
end
- _471_ = tbl_17_
+ _475_ = tbl_17_
end
- return _471_[1]
+ return _475_[1]
end
SPECIALS.let = function(ast, scope, parent, opts)
local bindings = ast[2]
@@ 1401,22 1447,22 @@ package.preload["fennel.specials"] = package.preload["fennel.specials"] or funct
end
end
local function disambiguate_3f(rootstr, parent)
- local function _476_()
- local _475_0 = get_prev_line(parent)
- if (nil ~= _475_0) then
- local prev_line = _475_0
+ local function _480_()
+ local _479_0 = get_prev_line(parent)
+ if (nil ~= _479_0) then
+ local prev_line = _479_0
return prev_line:match("%)$")
end
end
- return (rootstr:match("^{") or rootstr:match("^%(") or _476_())
+ return (rootstr:match("^{") or rootstr:match("^%(") or _480_())
end
SPECIALS.tset = function(ast, scope, parent)
compiler.assert((3 < #ast), "expected table, key, and value arguments", ast)
local root = compiler.compile1(ast[2], scope, parent, {nval = 1})[1]
local keys = {}
for i = 3, (#ast - 1) do
- local _478_ = compiler.compile1(ast[i], scope, parent, {nval = 1})
- local key = _478_[1]
+ local _482_ = compiler.compile1(ast[i], scope, parent, {nval = 1})
+ local key = _482_[1]
table.insert(keys, tostring(key))
end
local value = compiler.compile1(ast[#ast], scope, parent, {nval = 1})[1]
@@ 1430,7 1476,7 @@ package.preload["fennel.specials"] = package.preload["fennel.specials"] or funct
return compiler.emit(parent, fmtstr:format(rootstr, table.concat(keys, "]["), tostring(value)), ast)
end
doc_special("tset", {"tbl", "key1", "...", "keyN", "val"}, "Set the value of a table field. Can take additional keys to set\nnested values, but all parents must contain an existing table.")
- local function calculate_target(scope, opts)
+ local function calculate_if_target(scope, opts)
if not (opts.tail or opts.target or opts.nval) then
return "iife", true, nil
elseif (opts.nval and (opts.nval ~= 0) and not opts.target) then
@@ 1448,111 1494,142 @@ package.preload["fennel.specials"] = package.preload["fennel.specials"] or funct
end
local function if_2a(ast, scope, parent, opts)
compiler.assert((2 < #ast), "expected condition and body", ast)
- local do_scope = compiler["make-scope"](scope)
- local branches = {}
- local wrapper, inner_tail, inner_target, target_exprs = calculate_target(scope, opts)
- local body_opts = {nval = opts.nval, tail = inner_tail, target = inner_target}
- local function compile_body(i)
- local chunk = {}
- local cscope = compiler["make-scope"](do_scope)
- compiler["keep-side-effects"](compiler.compile1(ast[i], cscope, chunk, body_opts), chunk, nil, ast[i])
- return {chunk = chunk, scope = cscope}
+ if ((1 == (#ast % 2)) and (ast[(#ast - 1)] == true)) then
+ table.remove(ast, (#ast - 1))
end
if (1 == (#ast % 2)) then
table.insert(ast, utils.sym("nil"))
end
- for i = 2, (#ast - 1), 2 do
- local condchunk = {}
- local res = compiler.compile1(ast[i], do_scope, condchunk, {nval = 1})
- local cond = res[1]
- local branch = compile_body((i + 1))
- branch.cond = cond
- branch.condchunk = condchunk
- branch.nested = ((i ~= 2) and (next(condchunk, nil) == nil))
- table.insert(branches, branch)
- end
- local else_branch = compile_body(#ast)
- local s = compiler.gensym(scope)
- local buffer = {}
- local last_buffer = buffer
- for i = 1, #branches do
- local branch = branches[i]
- local fstr = nil
- if not branch.nested then
- fstr = "if %s then"
- else
- fstr = "elseif %s then"
- end
- local cond = tostring(branch.cond)
- local cond_line = fstr:format(cond)
- if branch.nested then
- compiler.emit(last_buffer, branch.condchunk, ast)
- else
- for _, v in ipairs(branch.condchunk) do
- compiler.emit(last_buffer, v, ast)
- end
- end
- compiler.emit(last_buffer, cond_line, ast)
- compiler.emit(last_buffer, branch.chunk, ast)
- if (i == #branches) then
- compiler.emit(last_buffer, "else", ast)
- compiler.emit(last_buffer, else_branch.chunk, ast)
- compiler.emit(last_buffer, "end", ast)
- elseif not branches[(i + 1)].nested then
- local next_buffer = {}
- compiler.emit(last_buffer, "else", ast)
- compiler.emit(last_buffer, next_buffer, ast)
- compiler.emit(last_buffer, "end", ast)
- last_buffer = next_buffer
- end
- end
- if (wrapper == "iife") then
- local iifeargs = ((scope.vararg and "...") or "")
- compiler.emit(parent, ("local function %s(%s)"):format(tostring(s), iifeargs), ast)
- compiler.emit(parent, buffer, ast)
- compiler.emit(parent, "end", ast)
- return utils.expr(("%s(%s)"):format(tostring(s), iifeargs), "statement")
- elseif (wrapper == "none") then
- for i = 1, #buffer do
- compiler.emit(parent, buffer[i], ast)
- end
- return {returned = true}
+ if (#ast == 2) then
+ return SPECIALS["do"](utils.list(utils.sym("do"), ast[2]), scope, parent, opts)
else
- compiler.emit(parent, ("local %s"):format(inner_target), ast)
- for i = 1, #buffer do
- compiler.emit(parent, buffer[i], ast)
+ local do_scope = compiler["make-scope"](scope)
+ local branches = {}
+ local wrapper, inner_tail, inner_target, target_exprs = calculate_if_target(scope, opts)
+ local body_opts = {nval = opts.nval, tail = inner_tail, target = inner_target}
+ local function compile_body(i)
+ local chunk = {}
+ local cscope = compiler["make-scope"](do_scope)
+ compiler["keep-side-effects"](compiler.compile1(ast[i], cscope, chunk, body_opts), chunk, nil, ast[i])
+ return {chunk = chunk, scope = cscope}
+ end
+ for i = 2, (#ast - 1), 2 do
+ local condchunk = {}
+ local res = compiler.compile1(ast[i], do_scope, condchunk, {nval = 1})
+ local cond = res[1]
+ local branch = compile_body((i + 1))
+ branch.cond = cond
+ branch.condchunk = condchunk
+ branch.nested = ((i ~= 2) and (next(condchunk, nil) == nil))
+ table.insert(branches, branch)
+ end
+ local else_branch = compile_body(#ast)
+ local s = compiler.gensym(scope)
+ local buffer = {}
+ local last_buffer = buffer
+ for i = 1, #branches do
+ local branch = branches[i]
+ local fstr = nil
+ if not branch.nested then
+ fstr = "if %s then"
+ else
+ fstr = "elseif %s then"
+ end
+ local cond = tostring(branch.cond)
+ local cond_line = fstr:format(cond)
+ if branch.nested then
+ compiler.emit(last_buffer, branch.condchunk, ast)
+ else
+ for _, v in ipairs(branch.condchunk) do
+ compiler.emit(last_buffer, v, ast)
+ end
+ end
+ compiler.emit(last_buffer, cond_line, ast)
+ compiler.emit(last_buffer, branch.chunk, ast)
+ if (i == #branches) then
+ compiler.emit(last_buffer, "else", ast)
+ compiler.emit(last_buffer, else_branch.chunk, ast)
+ compiler.emit(last_buffer, "end", ast)
+ elseif not branches[(i + 1)].nested then
+ local next_buffer = {}
+ compiler.emit(last_buffer, "else", ast)
+ compiler.emit(last_buffer, next_buffer, ast)
+ compiler.emit(last_buffer, "end", ast)
+ last_buffer = next_buffer
+ end
+ end
+ if (wrapper == "iife") then
+ local iifeargs = ((scope.vararg and "...") or "")
+ compiler.emit(parent, ("local function %s(%s)"):format(tostring(s), iifeargs), ast)
+ compiler.emit(parent, buffer, ast)
+ compiler.emit(parent, "end", ast)
+ return utils.expr(("%s(%s)"):format(tostring(s), iifeargs), "statement")
+ elseif (wrapper == "none") then
+ for i = 1, #buffer do
+ compiler.emit(parent, buffer[i], ast)
+ end
+ return {returned = true}
+ else
+ compiler.emit(parent, ("local %s"):format(inner_target), ast)
+ for i = 1, #buffer do
+ compiler.emit(parent, buffer[i], ast)
+ end
+ return target_exprs
end
- return target_exprs
end
end
SPECIALS["if"] = if_2a
doc_special("if", {"cond1", "body1", "...", "condN", "bodyN"}, "Conditional form.\nTakes any number of condition/body pairs and evaluates the first body where\nthe condition evaluates to truthy. Similar to cond in other lisps.")
- local function remove_until_condition(bindings)
- local last_item = bindings[(#bindings - 1)]
- if ((utils["sym?"](last_item) and (tostring(last_item) == "&until")) or ("until" == last_item)) then
- table.remove(bindings, (#bindings - 1))
- return table.remove(bindings)
- end
- end
- local function compile_until(condition, scope, chunk)
- if condition then
- local _487_ = compiler.compile1(condition, scope, chunk, {nval = 1})
- local condition_lua = _487_[1]
- return compiler.emit(chunk, ("if %s then break end"):format(tostring(condition_lua)), utils.expr(condition, "expression"))
+ local function clause_3f(v)
+ return (utils["string?"](v) or (utils["sym?"](v) and not utils["multi-sym?"](v) and tostring(v):match("^&(.+)")))
+ end
+ local function remove_until_condition(bindings, ast)
+ local _until = nil
+ for i = (#bindings - 1), 3, -1 do
+ local _492_0 = clause_3f(bindings[i])
+ if ((_492_0 == false) or (_492_0 == nil)) then
+ elseif (nil ~= _492_0) then
+ local clause = _492_0
+ compiler.assert(((clause == "until") and not _until), ("unexpected iterator clause: " .. clause), ast)
+ table.remove(bindings, i)
+ _until = table.remove(bindings, i)
+ end
+ end
+ return _until
+ end
+ local function compile_until(_3fcondition, scope, chunk)
+ if _3fcondition then
+ local _494_ = compiler.compile1(_3fcondition, scope, chunk, {nval = 1})
+ local condition_lua = _494_[1]
+ return compiler.emit(chunk, ("if %s then break end"):format(tostring(condition_lua)), utils.expr(_3fcondition, "expression"))
+ end
+ end
+ local function iterator_bindings(ast)
+ local bindings = utils.copy(ast)
+ local _3funtil = remove_until_condition(bindings, ast)
+ local iter = table.remove(bindings)
+ local bindings0 = nil
+ if (1 == #bindings) then
+ bindings0 = (utils["list?"](bindings[1]) or bindings)
+ else
+ for _, b in ipairs(bindings) do
+ if utils["list?"](b) then
+ utils.warn("unexpected parens in iterator", b)
+ end
+ end
+ bindings0 = bindings
end
+ return bindings0, iter, _3funtil
end
SPECIALS.each = function(ast, scope, parent)
compiler.assert((3 <= #ast), "expected body expression", ast[1])
compiler.assert(utils["table?"](ast[2]), "expected binding table", ast)
- compiler.assert((2 <= #ast[2]), "expected binding and iterator", ast)
- local binding = setmetatable(utils.copy(ast[2]), getmetatable(ast[2]))
- local until_condition = remove_until_condition(binding)
- local iter = table.remove(binding, #binding)
+ local sub_scope = compiler["make-scope"](scope)
+ local binding, iter, _3funtil_condition = iterator_bindings(ast[2])
local destructures = {}
local new_manglings = {}
- local sub_scope = compiler["make-scope"](scope)
+ utils.hook("pre-each", ast, sub_scope, binding, iter, _3funtil_condition)
local function destructure_binding(v)
- compiler.assert(not utils["string?"](v), ("unexpected iterator clause " .. tostring(v)), binding)
if utils["sym?"](v) then
return compiler["declare-local"](v, {}, sub_scope, ast, new_manglings)
else
@@ 1565,12 1642,13 @@ package.preload["fennel.specials"] = package.preload["fennel.specials"] or funct
local vals = compiler.compile1(iter, scope, parent)
local val_names = utils.map(vals, tostring)
local chunk = {}
+ compiler.assert(bind_vars[1], "expected binding and iterator", ast)
compiler.emit(parent, ("for %s in %s do"):format(table.concat(bind_vars, ", "), table.concat(val_names, ", ")), ast)
for raw, args in utils.stablepairs(destructures) do
compiler.destructure(args, raw, ast, sub_scope, chunk, {declaration = true, nomulti = true, symtype = "each"})
end
compiler["apply-manglings"](sub_scope, new_manglings, ast)
- compile_until(until_condition, sub_scope, chunk)
+ compile_until(_3funtil_condition, sub_scope, chunk)
compile_do(ast, sub_scope, chunk, 3)
compiler.emit(parent, chunk, ast)
return compiler.emit(parent, "end", ast)
@@ 1600,7 1678,7 @@ package.preload["fennel.specials"] = package.preload["fennel.specials"] or funct
local function for_2a(ast, scope, parent)
compiler.assert(utils["table?"](ast[2]), "expected binding table", ast)
local ranges = setmetatable(utils.copy(ast[2]), getmetatable(ast[2]))
- local until_condition = remove_until_condition(ranges)
+ local until_condition = remove_until_condition(ranges, ast)
local binding_sym = table.remove(ranges, 1)
local sub_scope = compiler["make-scope"](scope)
local range_args = {}
@@ 1609,6 1687,7 @@ package.preload["fennel.specials"] = package.preload["fennel.specials"] or funct
compiler.assert((3 <= #ast), "expected body expression", ast[1])
compiler.assert((#ranges <= 3), "unexpected arguments", ranges)
compiler.assert((1 < #ranges), "expected range to include start and stop", ranges)
+ utils.hook("pre-for", ast, sub_scope, binding_sym)
for i = 1, math.min(#ranges, 3) do
range_args[i] = tostring(compiler.compile1(ranges[i], scope, parent, {nval = 1})[1])
end
@@ 1621,10 1700,10 @@ package.preload["fennel.specials"] = package.preload["fennel.specials"] or funct
SPECIALS["for"] = for_2a
doc_special("for", {"[index start stop step?]", "..."}, "Numeric loop construct.\nEvaluates body once for each value between start and stop (inclusive).", true)
local function native_method_call(ast, _scope, _parent, target, args)
- local _491_ = ast
- local _ = _491_[1]
- local _0 = _491_[2]
- local method_string = _491_[3]
+ local _500_ = ast
+ local _ = _500_[1]
+ local _0 = _500_[2]
+ local method_string = _500_[3]
local call_string = nil
if ((target.type == "literal") or (target.type == "varg") or (target.type == "expression")) then
call_string = "(%s):%s(%s)"
@@ 1646,18 1725,18 @@ package.preload["fennel.specials"] = package.preload["fennel.specials"] or funct
end
local function method_call(ast, scope, parent)
compiler.assert((2 < #ast), "expected at least 2 arguments", ast)
- local _493_ = compiler.compile1(ast[2], scope, parent, {nval = 1})
- local target = _493_[1]
+ local _502_ = compiler.compile1(ast[2], scope, parent, {nval = 1})
+ local target = _502_[1]
local args = {}
for i = 4, #ast do
local subexprs = nil
- local _494_
+ local _503_
if (i ~= #ast) then
- _494_ = 1
+ _503_ = 1
else
- _494_ = nil
+ _503_ = nil
end
- subexprs = compiler.compile1(ast[i], scope, parent, {nval = _494_})
+ subexprs = compiler.compile1(ast[i], scope, parent, {nval = _503_})
utils.map(subexprs, tostring, args)
end
if (utils["string?"](ast[3]) and utils["valid-lua-identifier?"](ast[3])) then
@@ 1672,14 1751,14 @@ package.preload["fennel.specials"] = package.preload["fennel.specials"] or funct
doc_special(":", {"tbl", "method-name", "..."}, "Call the named method on tbl with the provided args.\nMethod name doesn't have to be known at compile-time; if it is, use\n(tbl:method-name ...) instead.")
SPECIALS.comment = function(ast, _, parent)
local c = nil
- local _497_
+ local _506_
do
local tbl_17_ = {}
local i_18_ = #tbl_17_
for i, elt in ipairs(ast) do
local val_19_ = nil
if (i ~= 1) then
- val_19_ = view(ast[i], {["one-line?"] = true})
+ val_19_ = view(elt, {["one-line?"] = true})
else
val_19_ = nil
end
@@ 1688,9 1767,9 @@ package.preload["fennel.specials"] = package.preload["fennel.specials"] or funct
tbl_17_[i_18_] = val_19_
end
end
- _497_ = tbl_17_
+ _506_ = tbl_17_
end
- c = table.concat(_497_, " "):gsub("%]%]", "]\\]")
+ c = table.concat(_506_, " "):gsub("%]%]", "]\\]")
return compiler.emit(parent, ("--[[ " .. c .. " ]]"), ast)
end
doc_special("comment", {"..."}, "Comment which will be emitted in Lua output.", true)
@@ 1711,10 1790,10 @@ package.preload["fennel.specials"] = package.preload["fennel.specials"] or funct
compiler.assert((#ast == 2), "expected one argument", ast)
local f_scope = nil
do
- local _502_0 = compiler["make-scope"](scope)
- _502_0["vararg"] = false
- _502_0["hashfn"] = true
- f_scope = _502_0
+ local _511_0 = compiler["make-scope"](scope)
+ _511_0["vararg"] = false
+ _511_0["hashfn"] = true
+ f_scope = _511_0
end
local f_chunk = {}
local name = compiler.gensym(scope)
@@ 1755,17 1834,17 @@ package.preload["fennel.specials"] = package.preload["fennel.specials"] or funct
return utils.expr(name, "sym")
end
doc_special("hashfn", {"..."}, "Function literal shorthand; args are either $... OR $1, $2, etc.")
- local function maybe_short_circuit_protect(ast, i, name, _507_0)
- local _508_ = _507_0
- local mac = _508_["macros"]
+ local function maybe_short_circuit_protect(ast, i, name, _516_0)
+ local _517_ = _516_0
+ local mac = _517_["macros"]
local call = (utils["list?"](ast) and tostring(ast[1]))
if ((("or" == name) or ("and" == name)) and (1 < i) and (mac[call] or ("set" == call) or ("tset" == call) or ("global" == call))) then
- return utils.list(utils.sym("do"), ast)
+ return utils.list(utils.list(utils.sym("fn"), utils.sequence(utils.varg()), ast))
else
return ast
end
end
- local function arithmetic_special(name, zero_arity, unary_prefix, ast, scope, parent)
+ local function operator_special(name, zero_arity, unary_prefix, ast, scope, parent)
local len = #ast
local operands = {}
local padded_op = (" " .. name .. " ")
@@ 1778,15 1857,15 @@ package.preload["fennel.specials"] = package.preload["fennel.specials"] or funct
table.insert(operands, tostring(subexprs[1]))
end
end
- local _511_0 = #operands
- if (_511_0 == 0) then
- local _512_
+ local _520_0 = #operands
+ if (_520_0 == 0) then
+ local _521_
do
compiler.assert(zero_arity, "Expected more than 0 arguments", ast)
- _512_ = zero_arity
+ _521_ = zero_arity
end
- return utils.expr(_512_, "literal")
- elseif (_511_0 == 1) then
+ return utils.expr(_521_, "literal")
+ elseif (_520_0 == 1) then
if utils["varg?"](ast[2]) then
return compiler.assert(false, "tried to use vararg with operator", ast)
elseif unary_prefix then
@@ 1795,20 1874,20 @@ package.preload["fennel.specials"] = package.preload["fennel.specials"] or funct
return operands[1]
end
else
- local _ = _511_0
+ local _ = _520_0
return ("(" .. table.concat(operands, padded_op) .. ")")
end
end
local function define_arithmetic_special(name, zero_arity, unary_prefix, _3flua_name)
- local _516_
+ local _525_
do
- local _515_0 = (_3flua_name or name)
- local function _517_(...)
- return arithmetic_special(_515_0, zero_arity, unary_prefix, ...)
+ local _524_0 = (_3flua_name or name)
+ local function _526_(...)
+ return operator_special(_524_0, zero_arity, unary_prefix, ...)
end
- _516_ = _517_
+ _525_ = _526_
end
- SPECIALS[name] = _516_
+ SPECIALS[name] = _525_
return doc_special(name, {"a", "b", "..."}, "Arithmetic operator; works the same as Lua but accepts more arguments.")
end
define_arithmetic_special("+", "0")
@@ 1820,10 1899,10 @@ package.preload["fennel.specials"] = package.preload["fennel.specials"] or funct
define_arithmetic_special("/", nil, "1")
define_arithmetic_special("//", nil, "1")
SPECIALS["or"] = function(ast, scope, parent)
- return arithmetic_special("or", "false", nil, ast, scope, parent)
+ return operator_special("or", "false", nil, ast, scope, parent)
end
SPECIALS["and"] = function(ast, scope, parent)
- return arithmetic_special("and", "true", nil, ast, scope, parent)
+ return operator_special("and", "true", nil, ast, scope, parent)
end
doc_special("and", {"a", "b", "..."}, "Boolean operator; works the same as Lua but accepts more arguments.")
doc_special("or", {"a", "b", "..."}, "Boolean operator; works the same as Lua but accepts more arguments.")
@@ 1837,13 1916,13 @@ package.preload["fennel.specials"] = package.preload["fennel.specials"] or funct
local prefixed_lib_name = ("bit." .. lib_name)
for i = 2, len do
local subexprs = nil
- local _518_
+ local _527_
if (i ~= len) then
- _518_ = 1
+ _527_ = 1
else
- _518_ = nil
+ _527_ = nil
end
- subexprs = compiler.compile1(ast[i], scope, parent, {nval = _518_})
+ subexprs = compiler.compile1(ast[i], scope, parent, {nval = _527_})
utils.map(subexprs, tostring, operands)
end
if (#operands == 1) then
@@ 1862,15 1941,15 @@ package.preload["fennel.specials"] = package.preload["fennel.specials"] or funct
end
end
local function define_bitop_special(name, zero_arity, unary_prefix, native)
- local function _524_(...)
+ local function _533_(...)
return bitop_special(native, name, zero_arity, unary_prefix, ...)
end
- SPECIALS[name] = _524_
+ SPECIALS[name] = _533_
return nil
end
define_bitop_special("lshift", nil, "1", "<<")
define_bitop_special("rshift", nil, "1", ">>")
- define_bitop_special("band", "0", "0", "&")
+ define_bitop_special("band", "-1", "-1", "&")
define_bitop_special("bor", "0", "0", "|")
define_bitop_special("bxor", "0", "0", "~")
doc_special("lshift", {"x", "n"}, "Bitwise logical left shift of x by n bits.\nOnly works in Lua 5.3+ or LuaJIT with the --use-bit-lib flag.")
@@ 1880,8 1959,8 @@ package.preload["fennel.specials"] = package.preload["fennel.specials"] or funct
doc_special("bxor", {"x1", "x2", "..."}, "Bitwise XOR of any number of arguments.\nOnly works in Lua 5.3+ or LuaJIT with the --use-bit-lib flag.")
SPECIALS.bnot = function(ast, scope, parent)
compiler.assert((#ast == 2), "expected one argument", ast)
- local _525_ = compiler.compile1(ast[2], scope, parent, {nval = 1})
- local value = _525_[1]
+ local _534_ = compiler.compile1(ast[2], scope, parent, {nval = 1})
+ local value = _534_[1]
if utils.root.options.useBitLib then
return ("bit.bnot(" .. tostring(value) .. ")")
else
@@ 1890,15 1969,15 @@ package.preload["fennel.specials"] = package.preload["fennel.specials"] or funct
end
doc_special("bnot", {"x"}, "Bitwise negation; only works in Lua 5.3+ or LuaJIT with the --use-bit-lib flag.")
doc_special("..", {"a", "b", "..."}, "String concatenation operator; works the same as Lua but accepts more arguments.")
- local function native_comparator(op, _527_0, scope, parent)
- local _528_ = _527_0
- local _ = _528_[1]
- local lhs_ast = _528_[2]
- local rhs_ast = _528_[3]
- local _529_ = compiler.compile1(lhs_ast, scope, parent, {nval = 1})
- local lhs = _529_[1]
- local _530_ = compiler.compile1(rhs_ast, scope, parent, {nval = 1})
- local rhs = _530_[1]
+ local function native_comparator(op, _536_0, scope, parent)
+ local _537_ = _536_0
+ local _ = _537_[1]
+ local lhs_ast = _537_[2]
+ local rhs_ast = _537_[3]
+ local _538_ = compiler.compile1(lhs_ast, scope, parent, {nval = 1})
+ local lhs = _538_[1]
+ local _539_ = compiler.compile1(rhs_ast, scope, parent, {nval = 1})
+ local rhs = _539_[1]
return string.format("(%s %s %s)", tostring(lhs), op, tostring(rhs))
end
local function idempotent_comparator(op, chain_op, ast, scope, parent)
@@ 2011,21 2090,21 @@ package.preload["fennel.specials"] = package.preload["fennel.specials"] or funct
end
local safe_require = nil
local function safe_compiler_env()
- local _537_
+ local _546_
do
- local _536_0 = rawget(_G, "utf8")
- if (nil ~= _536_0) then
- _537_ = utils.copy(_536_0)
+ local _545_0 = rawget(_G, "utf8")
+ if (nil ~= _545_0) then
+ _546_ = utils.copy(_545_0)
else
- _537_ = _536_0
+ _546_ = _545_0
end
end
- return {_VERSION = _VERSION, assert = assert, bit = rawget(_G, "bit"), error = error, getmetatable = safe_getmetatable, ipairs = ipairs, math = utils.copy(math), next = next, pairs = utils.stablepairs, pcall = pcall, print = print, rawequal = rawequal, rawget = rawget, rawlen = rawget(_G, "rawlen"), rawset = rawset, require = safe_require, select = select, setmetatable = setmetatable, string = utils.copy(string), table = utils.copy(table), tonumber = tonumber, tostring = tostring, type = type, utf8 = _537_, xpcall = xpcall}
+ return {_VERSION = _VERSION, assert = assert, bit = rawget(_G, "bit"), error = error, getmetatable = safe_getmetatable, ipairs = ipairs, math = utils.copy(math), next = next, pairs = utils.stablepairs, pcall = pcall, print = print, rawequal = rawequal, rawget = rawget, rawlen = rawget(_G, "rawlen"), rawset = rawset, require = safe_require, select = select, setmetatable = setmetatable, string = utils.copy(string), table = utils.copy(table), tonumber = tonumber, tostring = tostring, type = type, utf8 = _546_, xpcall = xpcall}
end
local function combined_mt_pairs(env)
local combined = {}
- local _539_ = getmetatable(env)
- local __index = _539_["__index"]
+ local _548_ = getmetatable(env)
+ local __index = _548_["__index"]
if ("table" == type(__index)) then
for k, v in pairs(__index) do
combined[k] = v
@@ 2039,40 2118,40 @@ package.preload["fennel.specials"] = package.preload["fennel.specials"] or funct
local function make_compiler_env(ast, scope, parent, _3fopts)
local provided = nil
do
- local _541_0 = (_3fopts or utils.root.options)
- if ((_G.type(_541_0) == "table") and (_541_0["compiler-env"] == "strict")) then
+ local _550_0 = (_3fopts or utils.root.options)
+ if ((_G.type(_550_0) == "table") and (_550_0["compiler-env"] == "strict")) then
provided = safe_compiler_env()
- elseif ((_G.type(_541_0) == "table") and (nil ~= _541_0.compilerEnv)) then
- local compilerEnv = _541_0.compilerEnv
+ elseif ((_G.type(_550_0) == "table") and (nil ~= _550_0.compilerEnv)) then
+ local compilerEnv = _550_0.compilerEnv
provided = compilerEnv
- elseif ((_G.type(_541_0) == "table") and (nil ~= _541_0["compiler-env"])) then
- local compiler_env = _541_0["compiler-env"]
+ elseif ((_G.type(_550_0) == "table") and (nil ~= _550_0["compiler-env"])) then
+ local compiler_env = _550_0["compiler-env"]
provided = compiler_env
else
- local _ = _541_0
- provided = safe_compiler_env(false)
+ local _ = _550_0
+ provided = safe_compiler_env()
end
end
local env = nil
- local function _543_()
+ local function _552_()
return compiler.scopes.macro
end
- local function _544_(symbol)
+ local function _553_(symbol)
compiler.assert(compiler.scopes.macro, "must call from macro", ast)
return compiler.scopes.macro.manglings[tostring(symbol)]
end
- local function _545_(base)
+ local function _554_(base)
return utils.sym(compiler.gensym((compiler.scopes.macro or scope), base))
end
- local function _546_(form)
+ local function _555_(form)
compiler.assert(compiler.scopes.macro, "must call from macro", ast)
return compiler.macroexpand(form, compiler.scopes.macro)
end
- env = {["assert-compile"] = compiler.assert, ["ast-source"] = utils["ast-source"], ["comment?"] = utils["comment?"], ["get-scope"] = _543_, ["in-scope?"] = _544_, ["list?"] = utils["list?"], ["macro-loaded"] = macro_loaded, ["multi-sym?"] = utils["multi-sym?"], ["sequence?"] = utils["sequence?"], ["sym?"] = utils["sym?"], ["table?"] = utils["table?"], ["varg?"] = utils["varg?"], _AST = ast, _CHUNK = parent, _IS_COMPILER = true, _SCOPE = scope, _SPECIALS = compiler.scopes.global.specials, _VARARG = utils.varg(), comment = utils.comment, gensym = _545_, list = utils.list, macroexpand = _546_, metadata = compiler.metadata, sequence = utils.sequence, sym = utils.sym, unpack = unpack, version = utils.version, view = view}
+ env = {["assert-compile"] = compiler.assert, ["ast-source"] = utils["ast-source"], ["comment?"] = utils["comment?"], ["fennel-module-name"] = fennel_module_name, ["get-scope"] = _552_, ["in-scope?"] = _553_, ["list?"] = utils["list?"], ["macro-loaded"] = macro_loaded, ["multi-sym?"] = utils["multi-sym?"], ["sequence?"] = utils["sequence?"], ["sym?"] = utils["sym?"], ["table?"] = utils["table?"], ["varg?"] = utils["varg?"], _AST = ast, _CHUNK = parent, _IS_COMPILER = true, _SCOPE = scope, _SPECIALS = compiler.scopes.global.specials, _VARARG = utils.varg(), comment = utils.comment, gensym = _554_, list = utils.list, macroexpand = _555_, sequence = utils.sequence, sym = utils.sym, unpack = unpack, version = utils.version, view = view}
env._G = env
return setmetatable(env, {__index = provided, __newindex = provided, __pairs = combined_mt_pairs})
end
- local function _547_(...)
+ local function _556_(...)
local tbl_17_ = {}
local i_18_ = #tbl_17_
for c in string.gmatch((package.config or ""), "([^\n]+)") do
@@ 2084,10 2163,10 @@ package.preload["fennel.specials"] = package.preload["fennel.specials"] or funct
end
return tbl_17_
end
- local _549_ = _547_(...)
- local dirsep = _549_[1]
- local pathsep = _549_[2]
- local pathmark = _549_[3]
+ local _558_ = _556_(...)
+ local dirsep = _558_[1]
+ local pathsep = _558_[2]
+ local pathmark = _558_[3]
local pkg_config = {dirsep = (dirsep or "/"), pathmark = (pathmark or "?"), pathsep = (pathsep or ";")}
local function escapepat(str)
return string.gsub(str, "[^%w]", "%%%1")
@@ 2100,36 2179,36 @@ package.preload["fennel.specials"] = package.preload["fennel.specials"] or funct
local function try_path(path)
local filename = path:gsub(escapepat(pkg_config.pathmark), no_dot_module)
local filename2 = path:gsub(escapepat(pkg_config.pathmark), modulename)
- local _550_0 = (io.open(filename) or io.open(filename2))
- if (nil ~= _550_0) then
- local file = _550_0
+ local _559_0 = (io.open(filename) or io.open(filename2))
+ if (nil ~= _559_0) then
+ local file = _559_0
file:close()
return filename
else
- local _ = _550_0
+ local _ = _559_0
return nil, ("no file '" .. filename .. "'")
end
end
local function find_in_path(start, _3ftried_paths)
- local _552_0 = fullpath:match(pattern, start)
- if (nil ~= _552_0) then
- local path = _552_0
- local _553_0, _554_0 = try_path(path)
- if (nil ~= _553_0) then
- local filename = _553_0
+ local _561_0 = fullpath:match(pattern, start)
+ if (nil ~= _561_0) then
+ local path = _561_0
+ local _562_0, _563_0 = try_path(path)
+ if (nil ~= _562_0) then
+ local filename = _562_0
return filename
- elseif ((_553_0 == nil) and (nil ~= _554_0)) then
- local error = _554_0
- local function _556_()
- local _555_0 = (_3ftried_paths or {})
- table.insert(_555_0, error)
- return _555_0
+ elseif ((_562_0 == nil) and (nil ~= _563_0)) then
+ local error = _563_0
+ local function _565_()
+ local _564_0 = (_3ftried_paths or {})
+ table.insert(_564_0, error)
+ return _564_0
end
- return find_in_path((start + #path + 1), _556_())
+ return find_in_path((start + #path + 1), _565_())
end
else
- local _ = _552_0
- local function _558_()
+ local _ = _561_0
+ local function _567_()
local tried_paths = table.concat((_3ftried_paths or {}), "\n\9")
if (_VERSION < "Lua 5.4") then
return ("\n\9" .. tried_paths)
@@ 2137,31 2216,31 @@ package.preload["fennel.specials"] = package.preload["fennel.specials"] or funct
return tried_paths
end
end
- return nil, _558_()
+ return nil, _567_()
end
end
return find_in_path(1)
end
local function make_searcher(_3foptions)
- local function _561_(module_name)
+ local function _570_(module_name)
local opts = utils.copy(utils.root.options)
for k, v in pairs((_3foptions or {})) do
opts[k] = v
end
opts["module-name"] = module_name
- local _562_0, _563_0 = search_module(module_name)
- if (nil ~= _562_0) then
- local filename = _562_0
- local function _564_(...)
+ local _571_0, _572_0 = search_module(module_name)
+ if (nil ~= _571_0) then
+ local filename = _571_0
+ local function _573_(...)
return utils["fennel-module"].dofile(filename, opts, ...)
end
- return _564_, filename
- elseif ((_562_0 == nil) and (nil ~= _563_0)) then
- local error = _563_0
+ return _573_, filename
+ elseif ((_571_0 == nil) and (nil ~= _572_0)) then
+ local error = _572_0
return error
end
end
- return _561_
+ return _570_
end
local function dofile_with_searcher(fennel_macro_searcher, filename, opts, ...)
local searchers = (package.loaders or package.searchers or {})
@@ 2173,35 2252,35 @@ package.preload["fennel.specials"] = package.preload["fennel.specials"] or funct
local function fennel_macro_searcher(module_name)
local opts = nil
do
- local _566_0 = utils.copy(utils.root.options)
- _566_0["module-name"] = module_name
- _566_0["env"] = "_COMPILER"
- _566_0["requireAsInclude"] = false
- _566_0["allowedGlobals"] = nil
- opts = _566_0
- end
- local _567_0 = search_module(module_name, utils["fennel-module"]["macro-path"])
- if (nil ~= _567_0) then
- local filename = _567_0
- local _568_
+ local _575_0 = utils.copy(utils.root.options)
+ _575_0["module-name"] = module_name
+ _575_0["env"] = "_COMPILER"
+ _575_0["requireAsInclude"] = false
+ _575_0["allowedGlobals"] = nil
+ opts = _575_0
+ end
+ local _576_0 = search_module(module_name, utils["fennel-module"]["macro-path"])
+ if (nil ~= _576_0) then
+ local filename = _576_0
+ local _577_
if (opts["compiler-env"] == _G) then
- local function _569_(...)
+ local function _578_(...)
return dofile_with_searcher(fennel_macro_searcher, filename, opts, ...)
end
- _568_ = _569_
+ _577_ = _578_
else
- local function _570_(...)
+ local function _579_(...)
return utils["fennel-module"].dofile(filename, opts, ...)
end
- _568_ = _570_
+ _577_ = _579_
end
- return _568_, filename
+ return _577_, filename
end
end
local function lua_macro_searcher(module_name)
- local _573_0 = search_module(module_name, package.path)
- if (nil ~= _573_0) then
- local filename = _573_0
+ local _582_0 = search_module(module_name, package.path)
+ if (nil ~= _582_0) then
+ local filename = _582_0
local code = nil
do
local f = io.open(filename)
@@ 2213,10 2292,10 @@ package.preload["fennel.specials"] = package.preload["fennel.specials"] or funct
return error(..., 0)
end
end
- local function _575_()
+ local function _584_()
return assert(f:read("*a"))
end
- code = close_handlers_10_(_G.xpcall(_575_, (package.loaded.fennel or debug).traceback))
+ code = close_handlers_10_(_G.xpcall(_584_, (package.loaded.fennel or debug).traceback))
end
local chunk = load_code(code, make_compiler_env(), filename)
return chunk, filename
@@ 2224,35 2303,38 @@ package.preload["fennel.specials"] = package.preload["fennel.specials"] or funct
end
local macro_searchers = {fennel_macro_searcher, lua_macro_searcher}
local function search_macro_module(modname, n)
- local _577_0 = macro_searchers[n]
- if (nil ~= _577_0) then
- local f = _577_0
- local _578_0, _579_0 = f(modname)
- if ((nil ~= _578_0) and true) then
- local loader = _578_0
- local _3ffilename = _579_0
+ local _586_0 = macro_searchers[n]
+ if (nil ~= _586_0) then
+ local f = _586_0
+ local _587_0, _588_0 = f(modname)
+ if ((nil ~= _587_0) and true) then
+ local loader = _587_0
+ local _3ffilename = _588_0
return loader, _3ffilename
else
- local _ = _578_0
+ local _ = _587_0
return search_macro_module(modname, (n + 1))
end
end
end
local function sandbox_fennel_module(modname)
if ((modname == "fennel.macros") or (package and package.loaded and ("table" == type(package.loaded[modname])) and (package.loaded[modname].metadata == compiler.metadata))) then
- return {metadata = compiler.metadata, view = view}
+ local function _591_(_, ...)
+ return (compiler.metadata):setall(...)
+ end
+ return {metadata = {setall = _591_}, view = view}
end
end
- local function _583_(modname)
- local function _584_()
+ local function _593_(modname)
+ local function _594_()
local loader, filename = search_macro_module(modname, 1)
compiler.assert(loader, (modname .. " module not found."))
macro_loaded[modname] = loader(modname, filename)
return macro_loaded[modname]
end
- return (macro_loaded[modname] or sandbox_fennel_module(modname) or _584_())
+ return (macro_loaded[modname] or sandbox_fennel_module(modname) or _594_())
end
- safe_require = _583_
+ safe_require = _593_
local function add_macros(macros_2a, ast, scope)
compiler.assert(utils["table?"](macros_2a), "expected macros to be table", ast)
for k, v in pairs(macros_2a) do
@@ 2262,10 2344,10 @@ package.preload["fennel.specials"] = package.preload["fennel.specials"] or funct
end
return nil
end
- local function resolve_module_name(_585_0, _scope, _parent, opts)
- local _586_ = _585_0
- local second = _586_[2]
- local filename = _586_["filename"]
+ local function resolve_module_name(_595_0, _scope, _parent, opts)
+ local _596_ = _595_0
+ local second = _596_[2]
+ local filename = _596_["filename"]
local filename0 = (filename or (utils["table?"](second) and second.filename))
local module_name = utils.root.options["module-name"]
local modexpr = compiler.compile(second, opts)
@@ 2284,7 2366,7 @@ package.preload["fennel.specials"] = package.preload["fennel.specials"] or funct
if ("import-macros" == tostring(ast[1])) then
return macro_loaded[modname]
else
- return add_macros(macro_loaded[modname], ast, scope, parent)
+ return add_macros(macro_loaded[modname], ast, scope)
end
end
doc_special("require-macros", {"macro-module-name"}, "Load given module and use its contents as macro definitions in current scope.\nMacro module should return a table of macro functions with string keys.\nConsider using import-macros instead as it is more flexible.")
@@ 2322,10 2404,10 @@ package.preload["fennel.specials"] = package.preload["fennel.specials"] or funct
return error(..., 0)
end
end
- local function _592_()
+ local function _602_()
return assert(f:read("*all")):gsub("[\13\n]*$", "")
end
- src = close_handlers_10_(_G.xpcall(_592_, (package.loaded.fennel or debug).traceback))
+ src = close_handlers_10_(_G.xpcall(_602_, (package.loaded.fennel or debug).traceback))
end
local ret = utils.expr(("require(\"" .. mod .. "\")"), "statement")
local target = ("package.preload[%q]"):format(mod)
@@ 2355,12 2437,12 @@ package.preload["fennel.specials"] = package.preload["fennel.specials"] or funct
compiler.assert((#ast == 2), "expected one argument", ast)
local modexpr = nil
do
- local _595_0, _596_0 = pcall(resolve_module_name, ast, scope, parent, opts)
- if ((_595_0 == true) and (nil ~= _596_0)) then
- local modname = _596_0
+ local _605_0, _606_0 = pcall(resolve_module_name, ast, scope, parent, opts)
+ if ((_605_0 == true) and (nil ~= _606_0)) then
+ local modname = _606_0
modexpr = utils.expr(string.format("%q", modname), "literal")
else
- local _ = _595_0
+ local _ = _605_0
modexpr = compiler.compile1(ast[2], scope, parent, {nval = 1})[1]
end
end
@@ 2377,13 2459,13 @@ package.preload["fennel.specials"] = package.preload["fennel.specials"] or funct
utils.root.options["module-name"] = mod
_ = nil
local res = nil
- local function _600_()
- local _599_0 = search_module(mod)
- if (nil ~= _599_0) then
- local fennel_path = _599_0
+ local function _610_()
+ local _609_0 = search_module(mod)
+ if (nil ~= _609_0) then
+ local fennel_path = _609_0
return include_path(ast, opts, fennel_path, mod, true)
else
- local _0 = _599_0
+ local _0 = _609_0
local lua_path = search_module(mod, package.path)
if lua_path then
return include_path(ast, opts, lua_path, mod, false)
@@ 2394,7 2476,7 @@ package.preload["fennel.specials"] = package.preload["fennel.specials"] or funct
end
end
end
- res = ((utils["member?"](mod, (utils.root.options.skipInclude or {})) and opts.fallback(modexpr, true)) or include_circular_fallback(mod, modexpr, opts.fallback, ast) or utils.root.scope.includes[mod] or _600_())
+ res = ((utils["member?"](mod, (utils.root.options.skipInclude or {})) and opts.fallback(modexpr, true)) or include_circular_fallback(mod, modexpr, opts.fallback, ast) or utils.root.scope.includes[mod] or _610_())
utils.root.options["module-name"] = oldmod
return res
end
@@ 2411,9 2493,18 @@ package.preload["fennel.specials"] = package.preload["fennel.specials"] or funct
compiler.assert((#ast == 2), "Expected one table argument", ast)
local macro_tbl = eval_compiler_2a(ast[2], scope, parent)
compiler.assert(utils["table?"](macro_tbl), "Expected one table argument", ast)
- return add_macros(macro_tbl, ast, scope, parent)
+ return add_macros(macro_tbl, ast, scope)
end
doc_special("macros", {"{:macro-name-1 (fn [...] ...) ... :macro-name-N macro-body-N}"}, "Define all functions in the given table as macros local to the current scope.")
+ SPECIALS["tail!"] = function(ast, scope, parent, opts)
+ compiler.assert((#ast == 2), "Expected one argument", ast)
+ local call = utils["list?"](compiler.macroexpand(ast[2], scope))
+ local callee = tostring((call and utils["sym?"](call[1])))
+ compiler.assert((call and not scope.specials[callee]), "Expected a function call as argument", ast)
+ compiler.assert(opts.tail, "Must be in tail position", ast)
+ return compiler.compile1(call, scope, parent, opts)
+ end
+ doc_special("tail!", {"body"}, "Assert that the body being called is in tail position.")
SPECIALS["eval-compiler"] = function(ast, scope, parent)
local old_first = ast[1]
ast[1] = utils.sym("do")
@@ 2426,23 2517,23 @@ package.preload["fennel.specials"] = package.preload["fennel.specials"] or funct
return compiler.assert(false, "tried to use unquote outside quote", ast)
end
doc_special("unquote", {"..."}, "Evaluate the argument even if it's in a quoted form.")
- return {["current-global-names"] = current_global_names, ["load-code"] = load_code, ["macro-loaded"] = macro_loaded, ["macro-searchers"] = macro_searchers, ["make-compiler-env"] = make_compiler_env, ["make-searcher"] = make_searcher, ["search-module"] = search_module, ["wrap-env"] = wrap_env, doc = doc_2a}
+ return {["current-global-names"] = current_global_names, ["get-function-metadata"] = get_function_metadata, ["load-code"] = load_code, ["macro-loaded"] = macro_loaded, ["macro-searchers"] = macro_searchers, ["make-compiler-env"] = make_compiler_env, ["make-searcher"] = make_searcher, ["search-module"] = search_module, ["wrap-env"] = wrap_env, doc = doc_2a}
end
package.preload["fennel.compiler"] = package.preload["fennel.compiler"] or function(...)
local utils = require("fennel.utils")
local parser = require("fennel.parser")
local friend = require("fennel.friend")
local unpack = (table.unpack or _G.unpack)
- local scopes = {}
+ local scopes = {compiler = nil, global = nil, macro = nil}
local function make_scope(_3fparent)
local parent = (_3fparent or scopes.global)
- local _260_
+ local _264_
if parent then
- _260_ = ((parent.depth or 0) + 1)
+ _264_ = ((parent.depth or 0) + 1)
else
- _260_ = 0
+ _264_ = 0
end
- return {["gensym-base"] = setmetatable({}, {__index = (parent and parent["gensym-base"])}), autogensyms = setmetatable({}, {__index = (parent and parent.autogensyms)}), depth = _260_, gensyms = setmetatable({}, {__index = (parent and parent.gensyms)}), hashfn = (parent and parent.hashfn), includes = setmetatable({}, {__index = (parent and parent.includes)}), macros = setmetatable({}, {__index = (parent and parent.macros)}), manglings = setmetatable({}, {__index = (parent and parent.manglings)}), parent = parent, refedglobals = {}, specials = setmetatable({}, {__index = (parent and parent.specials)}), symmeta = setmetatable({}, {__index = (parent and parent.symmeta)}), unmanglings = setmetatable({}, {__index = (parent and parent.unmanglings)}), vararg = (parent and parent.vararg)}
+ return {["gensym-base"] = setmetatable({}, {__index = (parent and parent["gensym-base"])}), autogensyms = setmetatable({}, {__index = (parent and parent.autogensyms)}), depth = _264_, gensyms = setmetatable({}, {__index = (parent and parent.gensyms)}), hashfn = (parent and parent.hashfn), includes = setmetatable({}, {__index = (parent and parent.includes)}), macros = setmetatable({}, {__index = (parent and parent.macros)}), manglings = setmetatable({}, {__index = (parent and parent.manglings)}), parent = parent, refedglobals = {}, specials = setmetatable({}, {__index = (parent and parent.specials)}), symmeta = setmetatable({}, {__index = (parent and parent.symmeta)}), unmanglings = setmetatable({}, {__index = (parent and parent.unmanglings)}), vararg = (parent and parent.vararg)}
end
local function assert_msg(ast, msg)
local ast_tbl = nil
@@ 2456,14 2547,14 @@ package.preload["fennel.compiler"] = package.preload["fennel.compiler"] or funct
local line = ((m and m.line) or ast_tbl.line or "?")
local col = ((m and m.col) or ast_tbl.col or "?")
local target = tostring((utils["sym?"](ast_tbl[1]) or ast_tbl[1] or "()"))
- return string.format("%s:%s:%s Compile error in '%s': %s", filename, line, col, target, msg)
+ return string.format("%s:%s:%s: Compile error in '%s': %s", filename, line, col, target, msg)
end
local function assert_compile(condition, msg, ast, _3ffallback_ast)
if not condition then
- local _263_ = (utils.root.options or {})
- local error_pinpoint = _263_["error-pinpoint"]
- local source = _263_["source"]
- local unfriendly = _263_["unfriendly"]
+ local _267_ = (utils.root.options or {})
+ local error_pinpoint = _267_["error-pinpoint"]
+ local source = _267_["source"]
+ local unfriendly = _267_["unfriendly"]
local ast0 = nil
if next(utils["ast-source"](ast)) then
ast0 = ast
@@ 2487,33 2578,33 @@ package.preload["fennel.compiler"] = package.preload["fennel.compiler"] or funct
scopes.macro = scopes.global
local serialize_subst = {["\11"] = "\\v", ["\12"] = "\\f", ["\7"] = "\\a", ["\8"] = "\\b", ["\9"] = "\\t", ["\n"] = "n"}
local function serialize_string(str)
- local function _268_(_241)
+ local function _272_(_241)
return ("\\" .. _241:byte())
end
- return string.gsub(string.gsub(string.format("%q", str), ".", serialize_subst), "[\128-\255]", _268_)
+ return string.gsub(string.gsub(string.format("%q", str), ".", serialize_subst), "[\128-\255]", _272_)
end
local function global_mangling(str)
if utils["valid-lua-identifier?"](str) then
return str
else
- local function _269_(_241)
+ local function _273_(_241)
return string.format("_%02x", _241:byte())
end
- return ("__fnl_global__" .. str:gsub("[^%w]", _269_))
+ return ("__fnl_global__" .. str:gsub("[^%w]", _273_))
end
end
local function global_unmangling(identifier)
- local _271_0 = string.match(identifier, "^__fnl_global__(.*)$")
- if (nil ~= _271_0) then
- local rest = _271_0
- local _272_0 = nil
- local function _273_(_241)
+ local _275_0 = string.match(identifier, "^__fnl_global__(.*)$")
+ if (nil ~= _275_0) then
+ local rest = _275_0
+ local _276_0 = nil
+ local function _277_(_241)
return string.char(tonumber(_241:sub(2), 16))
end
- _272_0 = string.gsub(rest, "_[%da-f][%da-f]", _273_)
- return _272_0
+ _276_0 = string.gsub(rest, "_[%da-f][%da-f]", _277_)
+ return _276_0
else
- local _ = _271_0
+ local _ = _275_0
return identifier
end
end
@@ 2537,10 2628,10 @@ package.preload["fennel.compiler"] = package.preload["fennel.compiler"] or funct
raw = str
end
local mangling = nil
- local function _277_(_241)
+ local function _281_(_241)
return string.format("_%02x", _241:byte())
end
- mangling = string.gsub(string.gsub(raw, "-", "_"), "[^%w_]", _277_)
+ mangling = string.gsub(string.gsub(raw, "-", "_"), "[^%w_]", _281_)
local unique = unique_mangling(mangling, mangling, scope, 0)
scope.unmanglings[unique] = (scope["gensym-base"][str] or str)
do
@@ 2595,31 2686,31 @@ package.preload["fennel.compiler"] = package.preload["fennel.compiler"] or funct
return table.concat(parts, ".")
end
local function autogensym(base, scope)
- local _281_0 = utils["multi-sym?"](base)
- if (nil ~= _281_0) then
- local parts = _281_0
+ local _285_0 = utils["multi-sym?"](base)
+ if (nil ~= _285_0) then
+ local parts = _285_0
return combine_auto_gensym(parts, autogensym(parts[1], scope))
else
- local _ = _281_0
- local function _282_()
- local mangling = gensym(scope, base:sub(1, ( - 2)), "auto")
+ local _ = _285_0
+ local function _286_()
+ local mangling = gensym(scope, base:sub(1, -2), "auto")
scope.autogensyms[base] = mangling
return mangling
end
- return (scope.autogensyms[base] or _282_())
+ return (scope.autogensyms[base] or _286_())
end
end
local function check_binding_valid(symbol, scope, ast, _3fopts)
local name = tostring(symbol)
local macro_3f = nil
do
- local _284_0 = _3fopts
- if (nil ~= _284_0) then
- _284_0 = _284_0["macro?"]
+ local _288_0 = _3fopts
+ if (nil ~= _288_0) then
+ _288_0 = _288_0["macro?"]
end
- macro_3f = _284_0
+ macro_3f = _288_0
end
- assert_compile(not name:find("&"), "invalid character: &", symbol)
+ assert_compile(("&" ~= name:match("[&.:]")), "invalid character: &", symbol)
assert_compile(not name:find("^%."), "invalid character: .", symbol)
assert_compile(not (scope.specials[name] or (not macro_3f and scope.macros[name])), ("local %s was overshadowed by a special form or macro"):format(name), ast)
return assert_compile(not utils["quoted?"](symbol), string.format("macro tried to bind %s without gensym", name), symbol)
@@ 2693,7 2784,7 @@ package.preload["fennel.compiler"] = package.preload["fennel.compiler"] or funct
out[last_line0] = ((out[last_line0] or "") .. " " .. chunk.leaf)
else
for _, subchunk in ipairs(chunk) do
- if (subchunk.leaf or (0 < #subchunk)) then
+ if (subchunk.leaf or next(subchunk)) then
local source = utils["ast-source"](subchunk.ast)
if (file == source.filename) then
last_line0 = math.max(last_line0, (source.line or 0))
@@ 2715,29 2806,29 @@ package.preload["fennel.compiler"] = package.preload["fennel.compiler"] or funct
end
local function flatten_chunk(file_sourcemap, chunk, tab, depth)
if chunk.leaf then
- local _296_ = utils["ast-source"](chunk.ast)
- local filename = _296_["filename"]
- local line = _296_["line"]
+ local _300_ = utils["ast-source"](chunk.ast)
+ local filename = _300_["filename"]
+ local line = _300_["line"]
table.insert(file_sourcemap, {filename, line})
return chunk.leaf
else
local tab0 = nil
do
- local _297_0 = tab
- if (_297_0 == true) then
+ local _301_0 = tab
+ if (_301_0 == true) then
tab0 = " "
- elseif (_297_0 == false) then
+ elseif (_301_0 == false) then
tab0 = ""
- elseif (_297_0 == tab) then
+ elseif (_301_0 == tab) then
tab0 = tab
- elseif (_297_0 == nil) then
+ elseif (_301_0 == nil) then
tab0 = ""
else
tab0 = nil
end
end
local function parter(c)
- if (c.leaf or (0 < #c)) then
+ if (c.leaf or next(c)) then
local sub = flatten_chunk(file_sourcemap, c, tab0, (depth + 1))
if (0 < depth) then
return (tab0 .. sub:gsub("\n", ("\n" .. tab0)))
@@ 2776,7 2867,7 @@ package.preload["fennel.compiler"] = package.preload["fennel.compiler"] or funct
end
end
local function make_metadata()
- local function _305_(self, tgt, _3fkey)
+ local function _309_(self, tgt, _3fkey)
if self[tgt] then
if (nil ~= _3fkey) then
return self[tgt][_3fkey]
@@ 2785,12 2876,12 @@ package.preload["fennel.compiler"] = package.preload["fennel.compiler"] or funct
end
end
end
- local function _308_(self, tgt, key, value)
+ local function _312_(self, tgt, key, value)
self[tgt] = (self[tgt] or {})
self[tgt][key] = value
return tgt
end
- local function _309_(self, tgt, ...)
+ local function _313_(self, tgt, ...)
local kv_len = select("#", ...)
local kvs = {...}
if ((kv_len % 2) ~= 0) then
@@ 2802,7 2893,7 @@ package.preload["fennel.compiler"] = package.preload["fennel.compiler"] or funct
end
return tgt
end
- return setmetatable({}, {__index = {get = _305_, set = _308_, setall = _309_}, __mode = "k"})
+ return setmetatable({}, {__index = {get = _309_, set = _312_, setall = _313_}, __mode = "k"})
end
local function exprs1(exprs)
return table.concat(utils.map(exprs, tostring), ", ")
@@ 2848,14 2939,14 @@ package.preload["fennel.compiler"] = package.preload["fennel.compiler"] or funct
end
if opts.target then
local result = exprs1(exprs)
- local function _317_()
+ local function _321_()
if (result == "") then
return "nil"
else
return result
end
end
- emit(parent, string.format("%s = %s", opts.target, _317_()), ast)
+ emit(parent, string.format("%s = %s", opts.target, _321_()), ast)
end
if (opts.tail or opts.target) then
return {returned = true}
@@ 2867,16 2958,16 @@ package.preload["fennel.compiler"] = package.preload["fennel.compiler"] or funct
local function find_macro(ast, scope)
local macro_2a = nil
do
- local _320_0 = utils["sym?"](ast[1])
- if (_320_0 ~= nil) then
- local _321_0 = tostring(_320_0)
- if (_321_0 ~= nil) then
- macro_2a = scope.macros[_321_0]
+ local _324_0 = utils["sym?"](ast[1])
+ if (_324_0 ~= nil) then
+ local _325_0 = tostring(_324_0)
+ if (_325_0 ~= nil) then
+ macro_2a = scope.macros[_325_0]
else
- macro_2a = _321_0
+ macro_2a = _325_0
end
else
- macro_2a = _320_0
+ macro_2a = _324_0
end
end
local multi_sym_parts = utils["multi-sym?"](ast[1])
@@ 2888,12 2979,12 @@ package.preload["fennel.compiler"] = package.preload["fennel.compiler"] or funct
return macro_2a
end
end
- local function propagate_trace_info(_325_0, _index, node)
- local _326_ = _325_0
- local byteend = _326_["byteend"]
- local bytestart = _326_["bytestart"]
- local filename = _326_["filename"]
- local line = _326_["line"]
+ local function propagate_trace_info(_329_0, _index, node)
+ local _330_ = _329_0
+ local byteend = _330_["byteend"]
+ local bytestart = _330_["bytestart"]
+ local filename = _330_["filename"]
+ local line = _330_["line"]
do
local src = utils["ast-source"](node)
if (("table" == type(node)) and (filename ~= src.filename)) then
@@ 2906,8 2997,8 @@ package.preload["fennel.compiler"] = package.preload["fennel.compiler"] or funct
local function quote_literal_nils(index, node, parent)
if (parent and utils["list?"](parent)) then
for i = 1, utils.maxn(parent) do
- local _328_0 = parent[i]
- if (_328_0 == nil) then
+ local _332_0 = parent[i]
+ if (_332_0 == nil) then
parent[i] = utils.sym("nil")
end
end
@@ 2915,10 3006,10 @@ package.preload["fennel.compiler"] = package.preload["fennel.compiler"] or funct
return index, node, parent
end
local function comp(f, g)
- local function _331_(...)
+ local function _335_(...)
return f(g(...))
end
- return _331_
+ return _335_
end
local function built_in_3f(m)
local found_3f = false
@@ 2929,45 3020,46 @@ package.preload["fennel.compiler"] = package.preload["fennel.compiler"] or funct
return found_3f
end
local function macroexpand_2a(ast, scope, _3fonce)
- local _332_0 = nil
+ local _336_0 = nil
if utils["list?"](ast) then
- _332_0 = find_macro(ast, scope)
+ _336_0 = find_macro(ast, scope)
else
- _332_0 = nil
+ _336_0 = nil
end
- if (_332_0 == false) then
+ if (_336_0 == false) then
return ast
- elseif (nil ~= _332_0) then
- local macro_2a = _332_0
+ elseif (nil ~= _336_0) then
+ local macro_2a = _336_0
local old_scope = scopes.macro
local _ = nil
scopes.macro = scope
_ = nil
local ok, transformed = nil, nil
- local function _334_()
+ local function _338_()
return macro_2a(unpack(ast, 2))
end
- local function _335_()
+ local function _339_()
if built_in_3f(macro_2a) then
return tostring
else
return debug.traceback
end
end
- ok, transformed = xpcall(_334_, _335_())
- local function _336_(...)
+ ok, transformed = xpcall(_338_, _339_())
+ local function _340_(...)
return propagate_trace_info(ast, ...)
end
- utils["walk-tree"](transformed, comp(_336_, quote_literal_nils))
+ utils["walk-tree"](transformed, comp(_340_, quote_literal_nils))
scopes.macro = old_scope
assert_compile(ok, transformed, ast)
+ utils.hook("macroexpand", ast, transformed, scope)
if (_3fonce or not transformed) then
return transformed
else
return macroexpand_2a(transformed, scope)
end
else
- local _ = _332_0
+ local _ = _336_0
return ast
end
end
@@ 2999,13 3091,13 @@ package.preload["fennel.compiler"] = package.preload["fennel.compiler"] or funct
assert_compile((utils["sym?"](ast[1]) or utils["list?"](ast[1]) or ("string" == type(ast[1]))), ("cannot call literal value " .. tostring(ast[1])), ast)
for i = 2, len do
local subexprs = nil
- local _342_
+ local _346_
if (i ~= len) then
- _342_ = 1
+ _346_ = 1
else
- _342_ = nil
+ _346_ = nil
end
- subexprs = compile1(ast[i], scope, parent, {nval = _342_})
+ subexprs = compile1(ast[i], scope, parent, {nval = _346_})
table.insert(fargs, subexprs[1])
if (i == len) then
for j = 2, #subexprs do
@@ 3043,13 3135,13 @@ package.preload["fennel.compiler"] = package.preload["fennel.compiler"] or funct
end
end
local function compile_varg(ast, scope, parent, opts)
- local _347_
+ local _351_
if scope.hashfn then
- _347_ = "use $... in hashfn"
+ _351_ = "use $... in hashfn"
else
- _347_ = "unexpected vararg"
+ _351_ = "unexpected vararg"
end
- assert_compile(scope.vararg, _347_, ast)
+ assert_compile(scope.vararg, _351_, ast)
return handle_compile_opts({utils.expr("...", "varg")}, parent, opts, ast)
end
local function compile_sym(ast, scope, parent, opts)
@@ 3064,20 3156,20 @@ package.preload["fennel.compiler"] = package.preload["fennel.compiler"] or funct
return handle_compile_opts({e}, parent, opts, ast)
end
local function serialize_number(n)
- local _350_0 = string.gsub(tostring(n), ",", ".")
- return _350_0
+ local _354_0 = string.gsub(tostring(n), ",", ".")
+ return _354_0
end
local function compile_scalar(ast, _scope, parent, opts)
local serialize = nil
do
- local _351_0 = type(ast)
- if (_351_0 == "nil") then
+ local _355_0 = type(ast)
+ if (_355_0 == "nil") then
serialize = tostring
- elseif (_351_0 == "boolean") then
+ elseif (_355_0 == "boolean") then
serialize = tostring
- elseif (_351_0 == "string") then
+ elseif (_355_0 == "string") then
serialize = serialize_string
- elseif (_351_0 == "number") then
+ elseif (_355_0 == "number") then
serialize = serialize_number
else
serialize = nil
@@ 3090,8 3182,8 @@ package.preload["fennel.compiler"] = package.preload["fennel.compiler"] or funct
if ((type(k) == "string") and utils["valid-lua-identifier?"](k)) then
return k
else
- local _353_ = compile1(k, scope, parent, {nval = 1})
- local compiled = _353_[1]
+ local _357_ = compile1(k, scope, parent, {nval = 1})
+ local compiled = _357_[1]
return ("[" .. tostring(compiled) .. "]")
end
end
@@ 3117,12 3209,12 @@ package.preload["fennel.compiler"] = package.preload["fennel.compiler"] or funct
do
local tbl_17_ = buffer
local i_18_ = #tbl_17_
- for k, v in utils.stablepairs(ast) do
+ for k in utils.stablepairs(ast) do
local val_19_ = nil
if not keys[k] then
- local _356_ = compile1(ast[k], scope, parent, {nval = 1})
- local v0 = _356_[1]
- val_19_ = string.format("%s = %s", escape_key(k), tostring(v0))
+ local _360_ = compile1(ast[k], scope, parent, {nval = 1})
+ local v = _360_[1]
+ val_19_ = string.format("%s = %s", escape_key(k), tostring(v))
else
val_19_ = nil
end
@@ 3153,12 3245,12 @@ package.preload["fennel.compiler"] = package.preload["fennel.compiler"] or funct
end
local function destructure(to, from, ast, scope, parent, opts)
local opts0 = (opts or {})
- local _360_ = opts0
- local declaration = _360_["declaration"]
- local forceglobal = _360_["forceglobal"]
- local forceset = _360_["forceset"]
- local isvar = _360_["isvar"]
- local symtype = _360_["symtype"]
+ local _364_ = opts0
+ local declaration = _364_["declaration"]
+ local forceglobal = _364_["forceglobal"]
+ local forceset = _364_["forceset"]
+ local isvar = _364_["isvar"]
+ local symtype = _364_["symtype"]
local symtype0 = ("_" .. (symtype or "dst"))
local setter = nil
if declaration then
@@ 3174,8 3266,8 @@ package.preload["fennel.compiler"] = package.preload["fennel.compiler"] or funct
return declare_local(symbol, nil, scope, symbol, new_manglings)
else
local parts = (utils["multi-sym?"](raw) or {raw})
- local _362_ = parts
- local first = _362_[1]
+ local _366_ = parts
+ local first = _366_[1]
local meta = scope.symmeta[first]
assert_compile(not raw:find(":"), "cannot set method sym", symbol)
if ((#parts == 1) and not forceset) then
@@ 3196,14 3288,14 @@ package.preload["fennel.compiler"] = package.preload["fennel.compiler"] or funct
end
local function compile_top_target(lvalues)
local inits = nil
- local function _367_(_241)
+ local function _371_(_241)
if scope.manglings[_241] then
return _241
else
return "nil"
end
end
- inits = utils.map(lvalues, _367_)
+ inits = utils.map(lvalues, _371_)
local init = table.concat(inits, ", ")
local lvalue = table.concat(lvalues, ", ")
local plast = parent[#parent]
@@ 3241,7 3333,7 @@ package.preload["fennel.compiler"] = package.preload["fennel.compiler"] or funct
local unpack_fn = "function (t, k, e)\n local mt = getmetatable(t)\n if 'table' == type(mt) and mt.__fennelrest then\n return mt.__fennelrest(t, k)\n elseif e then\n local rest = {}\n for k, v in pairs(t) do\n if not e[k] then rest[k] = v end\n end\n return rest\n else\n return {(table.unpack or unpack)(t, k)}\n end\n end"
local function destructure_kv_rest(s, v, left, excluded_keys, destructure1)
local exclude_str = nil
- local _374_
+ local _378_
do
local tbl_17_ = {}
local i_18_ = #tbl_17_
@@ 3252,9 3344,9 @@ package.preload["fennel.compiler"] = package.preload["fennel.compiler"] or funct
tbl_17_[i_18_] = val_19_
end
end
- _374_ = tbl_17_
+ _378_ = tbl_17_
end
- exclude_str = table.concat(_374_, ", ")
+ exclude_str = table.concat(_378_, ", ")
local subexpr = utils.expr(string.format(string.gsub(("(" .. unpack_fn .. ")(%s, %s, {%s})"), "\n%s*", " "), s, tostring(v), exclude_str), "expression")
return destructure1(v, {subexpr}, left)
end
@@ 3269,16 3361,16 @@ package.preload["fennel.compiler"] = package.preload["fennel.compiler"] or funct
local s = gensym(scope, symtype0)
local right = nil
do
- local _376_0 = nil
+ local _380_0 = nil
if top_3f then
- _376_0 = exprs1(compile1(from, scope, parent))
+ _380_0 = exprs1(compile1(from, scope, parent))
else
- _376_0 = exprs1(rightexprs)
+ _380_0 = exprs1(rightexprs)
end
- if (_376_0 == "") then
+ if (_380_0 == "") then
right = "nil"
- elseif (nil ~= _376_0) then
- local right0 = _376_0
+ elseif (nil ~= _380_0) then
+ local right0 = _380_0
right = right0
else
right = nil
@@ 3363,7 3455,7 @@ package.preload["fennel.compiler"] = package.preload["fennel.compiler"] or funct
local function require_include(ast, scope, parent, opts)
opts.fallback = function(e, no_warn)
if (not no_warn and ("literal" == e.type)) then
- utils.warn(("include module not found, falling back to require: %s"):format(tostring(e)))
+ utils.warn(("include module not found, falling back to require: %s"):format(tostring(e)), ast)
end
return utils.expr(string.format("require(%s)", tostring(e)), "statement")
end
@@ 3383,8 3475,11 @@ package.preload["fennel.compiler"] = package.preload["fennel.compiler"] or funct
if opts.requireAsInclude then
scope.specials.require = require_include
end
- local _390_ = utils.root
- _390_["set-reset"](_390_)
+ if opts.assertAsRepl then
+ scope.macros.assert = scope.macros["assert-repl"]
+ end
+ local _395_ = utils.root
+ _395_["set-reset"](_395_)
utils.root.chunk, utils.root.scope, utils.root.options = chunk, scope, opts
for i = 1, #asts do
local exprs = compile1(asts[i], scope, chunk, {nval = (((i < #asts) and 0) or nil), tail = (i == #asts)})
@@ 3397,7 3492,8 @@ package.preload["fennel.compiler"] = package.preload["fennel.compiler"] or funct
utils.root.reset()
return flatten(chunk, opts)
end
- local function compile_stream(stream, opts)
+ local function compile_stream(stream, _3fopts)
+ local opts = (_3fopts or {})
local asts = nil
do
local tbl_17_ = {}
@@ 3414,16 3510,16 @@ package.preload["fennel.compiler"] = package.preload["fennel.compiler"] or funct
return compile_asts(asts, opts)
end
local function compile_string(str, _3fopts)
- return compile_stream(parser["string-stream"](str, (_3fopts or {})), (_3fopts or {}))
+ return compile_stream(parser["string-stream"](str, _3fopts), _3fopts)
end
local function compile(ast, _3fopts)
return compile_asts({ast}, _3fopts)
end
local function traceback_frame(info)
if ((info.what == "C") and info.name) then
- return string.format(" [C]: in function '%s'", info.name)
+ return string.format("\9[C]: in function '%s'", info.name)
elseif (info.what == "C") then
- return " [C]: in ?"
+ return "\9[C]: in ?"
else
local remap = sourcemap[info.source]
if (remap and remap[info.currentline]) then
@@ 3435,18 3531,18 @@ package.preload["fennel.compiler"] = package.preload["fennel.compiler"] or funct
info.currentline = (remap[info.currentline][2] or -1)
end
if (info.what == "Lua") then
- local function _395_()
+ local function _400_()
if info.name then
return ("'" .. info.name .. "'")
else
return "?"
end
end
- return string.format(" %s:%d: in function %s", info.short_src, info.currentline, _395_())
+ return string.format("\9%s:%d: in function %s", info.short_src, info.currentline, _400_())
elseif (info.short_src == "(tail call)") then
return " (tail call)"
else
- return string.format(" %s:%d: in main chunk", info.short_src, info.currentline)
+ return string.format("\9%s:%d: in main chunk", info.short_src, info.currentline)
end
end
end
@@ 3466,11 3562,11 @@ package.preload["fennel.compiler"] = package.preload["fennel.compiler"] or funct
local done_3f, level = false, (_3fstart or 2)
while not done_3f do
do
- local _399_0 = debug.getinfo(level, "Sln")
- if (_399_0 == nil) then
+ local _404_0 = debug.getinfo(level, "Sln")
+ if (_404_0 == nil) then
done_3f = true
- elseif (nil ~= _399_0) then
- local info = _399_0
+ elseif (nil ~= _404_0) then
+ local info = _404_0
table.insert(lines, traceback_frame(info))
end
end
@@ 3480,14 3576,14 @@ package.preload["fennel.compiler"] = package.preload["fennel.compiler"] or funct
end
end
local function entry_transform(fk, fv)
- local function _402_(k, v)
+ local function _407_(k, v)
if (type(k) == "number") then
return k, fv(v)
else
return fk(k), fv(v)
end
end
- return _402_
+ return _407_
end
local function mixed_concat(t, joiner)
local seen = {}
@@ 3532,10 3628,10 @@ package.preload["fennel.compiler"] = package.preload["fennel.compiler"] or funct
return res[1]
elseif utils["list?"](form) then
local mapped = nil
- local function _407_()
+ local function _412_()
return nil
end
- mapped = utils.kvmap(form, entry_transform(_407_, q))
+ mapped = utils.kvmap(form, entry_transform(_412_, q))
local filename = nil
if form.filename then
filename = string.format("%q", form.filename)
@@ 3553,13 3649,13 @@ package.preload["fennel.compiler"] = package.preload["fennel.compiler"] or funct
else
filename = "nil"
end
- local _410_
+ local _415_
if source then
- _410_ = source.line
+ _415_ = source.line
else
- _410_ = "nil"
+ _415_ = "nil"
end
- return string.format("setmetatable({%s}, {filename=%s, line=%s, sequence=%s})", mixed_concat(mapped, ", "), filename, _410_, "(getmetatable(sequence()))['sequence']")
+ return string.format("setmetatable({%s}, {filename=%s, line=%s, sequence=%s})", mixed_concat(mapped, ", "), filename, _415_, "(getmetatable(sequence()))['sequence']")
elseif (type(form) == "table") then
local mapped = utils.kvmap(form, entry_transform(q, q))
local source = getmetatable(form)
@@ 3569,14 3665,14 @@ package.preload["fennel.compiler"] = package.preload["fennel.compiler"] or funct
else
filename = "nil"
end
- local function _413_()
+ local function _418_()
if source then
return source.line
else
return "nil"
end
end
- return string.format("setmetatable({%s}, {filename=%s, line=%s})", mixed_concat(mapped, ", "), filename, _413_())
+ return string.format("setmetatable({%s}, {filename=%s, line=%s})", mixed_concat(mapped, ", "), filename, _418_())
elseif (type(form) == "string") then
return serialize_string(form)
else
@@ 3595,7 3691,7 @@ package.preload["fennel.friend"] = package.preload["fennel.friend"] or function(
for pat, sug in pairs(suggestions) do
if s then break end
local matches = {msg:match(pat)}
- if (0 < #matches) then
+ if next(matches) then
local tbl_17_ = {}
local i_18_ = #tbl_17_
for _, s0 in ipairs(sug) do
@@ 3629,13 3725,13 @@ package.preload["fennel.friend"] = package.preload["fennel.friend"] or function(
return error(..., 0)
end
end
- local function _184_()
+ local function _187_()
for _ = 2, line do
f:read()
end
return f:read()
end
- return close_handlers_10_(_G.xpcall(_184_, (package.loaded.fennel or debug).traceback))
+ return close_handlers_10_(_G.xpcall(_187_, (package.loaded.fennel or debug).traceback))
end
end
local function sub(str, start, _end)
@@ 3651,8 3747,8 @@ package.preload["fennel.friend"] = package.preload["fennel.friend"] or function(
if ((opts and (false == opts["error-pinpoint"])) or (os and os.getenv and os.getenv("NO_COLOR"))) then
return codeline
else
- local _187_ = (opts or {})
- local error_pinpoint = _187_["error-pinpoint"]
+ local _190_ = (opts or {})
+ local error_pinpoint = _190_["error-pinpoint"]
local endcol = (_3fendcol or col)
local eol = nil
if utf8_ok_3f then
@@ 3660,19 3756,19 @@ package.preload["fennel.friend"] = package.preload["fennel.friend"] or function(
else
eol = string.len(codeline)
end
- local _189_ = (error_pinpoint or {"\27[7m", "\27[0m"})
- local open = _189_[1]
- local close = _189_[2]
+ local _192_ = (error_pinpoint or {"\27[7m", "\27[0m"})
+ local open = _192_[1]
+ local close = _192_[2]
return (sub(codeline, 1, col) .. open .. sub(codeline, (col + 1), (endcol + 1)) .. close .. sub(codeline, (endcol + 2), eol))
end
end
- local function friendly_msg(msg, _191_0, source, opts)
- local _192_ = _191_0
- local col = _192_["col"]
- local endcol = _192_["endcol"]
- local endline = _192_["endline"]
- local filename = _192_["filename"]
- local line = _192_["line"]
+ local function friendly_msg(msg, _194_0, source, opts)
+ local _195_ = _194_0
+ local col = _195_["col"]
+ local endcol = _195_["endcol"]
+ local endline = _195_["endline"]
+ local filename = _195_["filename"]
+ local line = _195_["line"]
local ok, codeline = pcall(read_line, filename, line, source)
local endcol0 = nil
if (ok and codeline and (line ~= endline)) then
@@ 3695,16 3791,16 @@ package.preload["fennel.friend"] = package.preload["fennel.friend"] or function(
end
local function assert_compile(condition, msg, ast, source, opts)
if not condition then
- local _196_ = utils["ast-source"](ast)
- local col = _196_["col"]
- local filename = _196_["filename"]
- local line = _196_["line"]
- error(friendly_msg(("%s:%s:%s Compile error: %s"):format((filename or "unknown"), (line or "?"), (col or "?"), msg), utils["ast-source"](ast), source, opts), 0)
+ local _199_ = utils["ast-source"](ast)
+ local col = _199_["col"]
+ local filename = _199_["filename"]
+ local line = _199_["line"]
+ error(friendly_msg(("%s:%s:%s: Compile error: %s"):format((filename or "unknown"), (line or "?"), (col or "?"), msg), utils["ast-source"](ast), source, opts), 0)
end
return condition
end
local function parse_error(msg, filename, line, col, source, opts)
- return error(friendly_msg(("%s:%s:%s Parse error: %s"):format(filename, line, col, msg), {col = col, filename = filename, line = line}, source, opts), 0)
+ return error(friendly_msg(("%s:%s:%s: Parse error: %s"):format(filename, line, col, msg), {col = col, filename = filename, line = line}, source, opts), 0)
end
return {["assert-compile"] = assert_compile, ["parse-error"] = parse_error}
end
@@ 3714,36 3810,36 @@ package.preload["fennel.parser"] = package.preload["fennel.parser"] or function(
local unpack = (table.unpack or _G.unpack)
local function granulate(getchunk)
local c, index, done_3f = "", 1, false
- local function _198_(parser_state)
+ local function _201_(parser_state)
if not done_3f then
if (index <= #c) then
local b = c:byte(index)
index = (index + 1)
return b
else
- local _199_0 = getchunk(parser_state)
- local function _200_()
- local char = _199_0
+ local _202_0 = getchunk(parser_state)
+ local function _203_()
+ local char = _202_0
return (char ~= "")
end
- if ((nil ~= _199_0) and _200_()) then
- local char = _199_0
+ if ((nil ~= _202_0) and _203_()) then
+ local char = _202_0
c = char
index = 2
return c:byte()
else
- local _ = _199_0
+ local _ = _202_0
done_3f = true
return nil
end
end
end
end
- local function _204_()
+ local function _207_()
c = ""
return nil
end
- return _198_, _204_
+ return _201_, _207_
end
local function string_stream(str, _3foptions)
local str0 = str:gsub("^#!", ";;")
@@ 3751,12 3847,12 @@ package.preload["fennel.parser"] = package.preload["fennel.parser"] or function(
_3foptions.source = str0
end
local index = 1
- local function _206_()
+ local function _209_()
local r = str0:byte(index)
index = (index + 1)
return r
end
- return _206_
+ return _209_
end
local delims = {[123] = 125, [125] = true, [40] = 41, [41] = true, [91] = 93, [93] = true}
local function sym_char_3f(b)
@@ 3772,12 3868,12 @@ package.preload["fennel.parser"] = package.preload["fennel.parser"] or function(
local function char_starter_3f(b)
return (((1 < b) and (b < 127)) or ((192 < b) and (b < 247)))
end
- local function parser_fn(getbyte, filename, _208_0)
- local _209_ = _208_0
- local options = _209_
- local comments = _209_["comments"]
- local source = _209_["source"]
- local unfriendly = _209_["unfriendly"]
+ local function parser_fn(getbyte, filename, _211_0)
+ local _212_ = _211_0
+ local options = _212_
+ local comments = _212_["comments"]
+ local source = _212_["source"]
+ local unfriendly = _212_["unfriendly"]
local stack = {}
local line, byteindex, col, prev_col, lastb = 1, 0, 0, 0, nil
local function ungetb(ub)
@@ 3798,7 3894,9 @@ package.preload["fennel.parser"] = package.preload["fennel.parser"] or function(
else
r = getbyte({["stack-size"] = #stack})
end
- byteindex = (byteindex + 1)
+ if r then
+ byteindex = (byteindex + 1)
+ end
if (r and char_starter_3f(r)) then
col = (col + 1)
end
@@ 3808,21 3906,21 @@ package.preload["fennel.parser"] = package.preload["fennel.parser"] or function(
return r
end
local function whitespace_3f(b)
- local function _216_()
- local _215_0 = options.whitespace
- if (nil ~= _215_0) then
- _215_0 = _215_0[b]
+ local function _220_()
+ local _219_0 = options.whitespace
+ if (nil ~= _219_0) then
+ _219_0 = _219_0[b]
end
- return _215_0
+ return _219_0
end
- return ((b == 32) or ((9 <= b) and (b <= 13)) or _216_())
+ return ((b == 32) or ((9 <= b) and (b <= 13)) or _220_())
end
local function parse_error(msg, _3fcol_adjust)
local col0 = (col + (_3fcol_adjust or -1))
if (nil == utils["hook-opts"]("parse-error", options, msg, filename, (line or "?"), col0, source, utils.root.reset)) then
utils.root.reset()
if unfriendly then
- return error(string.format("%s:%s:%s Parse error: %s", filename, (line or "?"), col0, msg), 0)
+ return error(string.format("%s:%s:%s: Parse error: %s", filename, (line or "?"), col0, msg), 0)
else
return friend["parse-error"](msg, filename, (line or "?"), col0, source, options)
end
@@ 3835,56 3933,60 @@ package.preload["fennel.parser"] = package.preload["fennel.parser"] or function(
return nil
end
local function dispatch(v)
- local _220_0 = stack[#stack]
- if (_220_0 == nil) then
+ local _224_0 = stack[#stack]
+ if (_224_0 == nil) then
retval, done_3f, whitespace_since_dispatch = v, true, false
return nil
- elseif ((_G.type(_220_0) == "table") and (nil ~= _220_0.prefix)) then
- local prefix = _220_0.prefix
+ elseif ((_G.type(_224_0) == "table") and (nil ~= _224_0.prefix)) then
+ local prefix = _224_0.prefix
local source0 = nil
do
- local _221_0 = table.remove(stack)
- set_source_fields(_221_0)
- source0 = _221_0
+ local _225_0 = table.remove(stack)
+ set_source_fields(_225_0)
+ source0 = _225_0
end
local list = utils.list(utils.sym(prefix, source0), v)
for k, v0 in pairs(source0) do
list[k] = v0
end
return dispatch(list)
- elseif (nil ~= _220_0) then
- local top = _220_0
+ elseif (nil ~= _224_0) then
+ local top = _224_0
whitespace_since_dispatch = false
return table.insert(top, v)
end
end
local function badend()
local accum = utils.map(stack, "closer")
- local _223_
+ local _227_
if (#stack == 1) then
- _223_ = ""
+ _227_ = ""
else
- _223_ = "s"
+ _227_ = "s"
end
- return parse_error(string.format("expected closing delimiter%s %s", _223_, string.char(unpack(accum))))
+ return parse_error(string.format("expected closing delimiter%s %s", _227_, string.char(unpack(accum))))
end
- local function skip_whitespace(b)
+ local function skip_whitespace(b, close_table)
if (b and whitespace_3f(b)) then
whitespace_since_dispatch = true
- return skip_whitespace(getb())
- elseif (not b and (0 < #stack)) then
- return badend()
+ return skip_whitespace(getb(), close_table)
+ elseif (not b and next(stack)) then
+ badend()
+ for i = #stack, 2, -1 do
+ close_table(stack[i].closer)
+ end
+ return stack[1].closer
else
return b
end
end
local function parse_comment(b, contents)
if (b and (10 ~= b)) then
- local function _226_()
+ local function _230_()
table.insert(contents, string.char(b))
return contents
end
- return parse_comment(getb(), _226_())
+ return parse_comment(getb(), _230_())
elseif comments then
ungetb(10)
return dispatch(utils.comment(table.concat(contents), {filename = filename, line = line}))
@@ 3910,12 4012,12 @@ package.preload["fennel.parser"] = package.preload["fennel.parser"] or function(
return dispatch(setmetatable(tbl, mt))
end
local function add_comment_at(comments0, index, node)
- local _230_0 = comments0[index]
- if (nil ~= _230_0) then
- local existing = _230_0
+ local _234_0 = comments0[index]
+ if (nil ~= _234_0) then
+ local existing = _234_0
return table.insert(existing, node)
else
- local _ = _230_0
+ local _ = _234_0
comments0[index] = {node}
return nil
end
@@ 3994,16 4096,16 @@ package.preload["fennel.parser"] = package.preload["fennel.parser"] or function(
end
local state0 = nil
do
- local _241_0 = {state, b}
- if ((_G.type(_241_0) == "table") and (_241_0[1] == "base") and (_241_0[2] == 92)) then
+ local _245_0 = {state, b}
+ if ((_G.type(_245_0) == "table") and (_245_0[1] == "base") and (_245_0[2] == 92)) then
state0 = "backslash"
- elseif ((_G.type(_241_0) == "table") and (_241_0[1] == "base") and (_241_0[2] == 34)) then
+ elseif ((_G.type(_245_0) == "table") and (_245_0[1] == "base") and (_245_0[2] == 34)) then
state0 = "done"
- elseif ((_G.type(_241_0) == "table") and (_241_0[1] == "backslash") and (_241_0[2] == 10)) then
+ elseif ((_G.type(_245_0) == "table") and (_245_0[1] == "backslash") and (_245_0[2] == 10)) then
table.remove(chars, (#chars - 1))
state0 = "base"
else
- local _ = _241_0
+ local _ = _245_0
state0 = "base"
end
end
@@ 4025,11 4127,11 @@ package.preload["fennel.parser"] = package.preload["fennel.parser"] or function(
table.remove(stack)
local raw = table.concat(chars)
local formatted = raw:gsub("[\7-\13]", escape_char)
- local _245_0 = (rawget(_G, "loadstring") or load)(("return " .. formatted))
- if (nil ~= _245_0) then
- local load_fn = _245_0
+ local _249_0 = (rawget(_G, "loadstring") or load)(("return " .. formatted))
+ if (nil ~= _249_0) then
+ local load_fn = _249_0
return dispatch(load_fn())
- elseif (_245_0 == nil) then
+ elseif (_249_0 == nil) then
return parse_error(("Invalid string: " .. raw))
end
end
@@ 4062,13 4164,13 @@ package.preload["fennel.parser"] = package.preload["fennel.parser"] or function(
dispatch((tonumber(number_with_stripped_underscores) or parse_error(("could not read number \"" .. rawstr .. "\""))))
return true
else
- local _251_0 = tonumber(number_with_stripped_underscores)
- if (nil ~= _251_0) then
- local x = _251_0
+ local _255_0 = tonumber(number_with_stripped_underscores)
+ if (nil ~= _255_0) then
+ local x = _255_0
dispatch(x)
return true
else
- local _ = _251_0
+ local _ = _255_0
return false
end
end
@@ 4078,18 4180,15 @@ package.preload["fennel.parser"] = package.preload["fennel.parser"] or function(
return (rawstr:find(pat) - utils.len(rawstr) - 1)
end
if (rawstr:match("^~") and (rawstr ~= "~=")) then
- return parse_error("invalid character: ~")
- elseif rawstr:match("%.[0-9]") then
- return parse_error(("can't start multisym segment with a digit: " .. rawstr), col_adjust("%.[0-9]"))
+ parse_error("invalid character: ~")
elseif (rawstr:match("[%.:][%.:]") and (rawstr ~= "..") and (rawstr ~= "$...")) then
- return parse_error(("malformed multisym: " .. rawstr), col_adjust("[%.:][%.:]"))
+ parse_error(("malformed multisym: " .. rawstr), col_adjust("[%.:][%.:]"))
elseif ((rawstr ~= ":") and rawstr:match(":$")) then
- return parse_error(("malformed multisym: " .. rawstr), col_adjust(":$"))
+ parse_error(("malformed multisym: " .. rawstr), col_adjust(":$"))
elseif rawstr:match(":.+[%.:]") then
- return parse_error(("method must be last component of multisym: " .. rawstr), col_adjust(":.+[%.:]"))
- else
- return rawstr
+ parse_error(("method must be last component of multisym: " .. rawstr), col_adjust(":.+[%.:]"))
end
+ return rawstr
end
local function parse_sym(b)
local source0 = {bytestart = byteindex, col = (col - 1), filename = filename, line = line}
@@ 4116,7 4215,7 @@ package.preload["fennel.parser"] = package.preload["fennel.parser"] or function(
elseif delims[b] then
close_table(b)
elseif (b == 34) then
- parse_string(b)
+ parse_string()
elseif prefixes[b] then
parse_prefix(b)
elseif (sym_char_3f(b) or (b == string.byte("~"))) then
@@ 4129,16 4228,16 @@ package.preload["fennel.parser"] = package.preload["fennel.parser"] or function(
elseif done_3f then
return true, retval
else
- return parse_loop(skip_whitespace(getb()))
+ return parse_loop(skip_whitespace(getb(), close_table))
end
end
- return parse_loop(skip_whitespace(getb()))
+ return parse_loop(skip_whitespace(getb(), close_table))
end
- local function _258_()
- stack, line, byteindex, col, lastb = {}, 1, 0, 0, nil
+ local function _262_()
+ stack, line, byteindex, col, lastb = {}, 1, 0, 0, ((lastb ~= 10) and lastb)
return nil
end
- return parse_stream, _258_
+ return parse_stream, _262_
end
local function parser(stream_or_string, _3ffilename, _3foptions)
local filename = (_3ffilename or "unknown")
@@ 4763,14 4862,14 @@ package.preload["fennel.view"] = package.preload["fennel.view"] or function(...)
end
end
pp = _93_
- local function view(x, _3foptions)
+ local function _view(x, _3foptions)
return pp(x, make_options(x, _3foptions), 0)
end
- return view
+ return _view
end
package.preload["fennel.utils"] = package.preload["fennel.utils"] or function(...)
local view = require("fennel.view")
- local version = "1.3.1-dev"
+ local version = "1.4.2"
local function luajit_vm_3f()
return ((nil ~= _G.jit) and (type(_G.jit) == "table") and (nil ~= _G.jit.on) and (nil ~= _G.jit.off) and (type(_G.jit.version_num) == "number"))
end
@@ 4805,39 4904,34 @@ package.preload["fennel.utils"] = package.preload["fennel.utils"] or function(..
return ("Fennel " .. version .. " on " .. lua_vm_version())
end
end
- local function warn(message)
- if (_G.io and _G.io.stderr) then
- return (_G.io.stderr):write(("--WARNING: %s\n"):format(tostring(message)))
- end
- end
local len = nil
do
- local _104_0, _105_0 = pcall(require, "utf8")
- if ((_104_0 == true) and (nil ~= _105_0)) then
- local utf8 = _105_0
+ local _103_0, _104_0 = pcall(require, "utf8")
+ if ((_103_0 == true) and (nil ~= _104_0)) then
+ local utf8 = _104_0
len = utf8.len
else
- local _ = _104_0
+ local _ = _103_0
len = string.len
end
end
local kv_order = {boolean = 2, number = 1, string = 3, table = 4}
local function kv_compare(a, b)
- local _107_0, _108_0 = type(a), type(b)
- if (((_107_0 == "number") and (_108_0 == "number")) or ((_107_0 == "string") and (_108_0 == "string"))) then
+ local _106_0, _107_0 = type(a), type(b)
+ if (((_106_0 == "number") and (_107_0 == "number")) or ((_106_0 == "string") and (_107_0 == "string"))) then
return (a < b)
else
- local function _109_()
- local a_t = _107_0
- local b_t = _108_0
+ local function _108_()
+ local a_t = _106_0
+ local b_t = _107_0
return (a_t ~= b_t)
end
- if (((nil ~= _107_0) and (nil ~= _108_0)) and _109_()) then
- local a_t = _107_0
- local b_t = _108_0
+ if (((nil ~= _106_0) and (nil ~= _107_0)) and _108_()) then
+ local a_t = _106_0
+ local b_t = _107_0
return ((kv_order[a_t] or 5) < (kv_order[b_t] or 5))
else
- local _ = _107_0
+ local _ = _106_0
return (tostring(a) < tostring(b))
end
end
@@ 4869,20 4963,20 @@ package.preload["fennel.utils"] = package.preload["fennel.utils"] or function(..
local function stablepairs(t)
local mt_keys = nil
do
- local _113_0 = getmetatable(t)
- if (nil ~= _113_0) then
- _113_0 = _113_0.keys
+ local _112_0 = getmetatable(t)
+ if (nil ~= _112_0) then
+ _112_0 = _112_0.keys
end
- mt_keys = _113_0
+ mt_keys = _112_0
end
local succ, prev, first_mt = nil, nil, nil
- local function _115_(_241)
+ local function _114_(_241)
return t[_241]
end
- succ, prev, first_mt = add_stable_keys({}, nil, (mt_keys or {}), _115_)
+ succ, prev, first_mt = add_stable_keys({}, nil, (mt_keys or {}), _114_)
local pairs_keys = nil
do
- local _116_0 = nil
+ local _115_0 = nil
do
local tbl_17_ = {}
local i_18_ = #tbl_17_
@@ 4893,10 4987,10 @@ package.preload["fennel.utils"] = package.preload["fennel.utils"] or function(..
tbl_17_[i_18_] = val_19_
end
end
- _116_0 = tbl_17_
+ _115_0 = tbl_17_
end
- table.sort(_116_0, kv_compare)
- pairs_keys = _116_0
+ table.sort(_115_0, kv_compare)
+ pairs_keys = _115_0
end
local succ0, _, first_after_mt = add_stable_keys(succ, prev, pairs_keys)
local first = nil
@@ 4906,19 5000,19 @@ package.preload["fennel.utils"] = package.preload["fennel.utils"] or function(..
first = first_mt
end
local function stablenext(tbl, key)
- local _119_0 = nil
+ local _118_0 = nil
if (key == nil) then
- _119_0 = first
+ _118_0 = first
else
- _119_0 = succ0[key]
+ _118_0 = succ0[key]
end
- if (nil ~= _119_0) then
- local next_key = _119_0
- local _121_0 = tbl[next_key]
- if (_121_0 ~= nil) then
- return next_key, _121_0
+ if (nil ~= _118_0) then
+ local next_key = _118_0
+ local _120_0 = tbl[next_key]
+ if (_120_0 ~= nil) then
+ return next_key, _120_0
else
- return _121_0
+ return _120_0
end
end
end
@@ 4929,25 5023,25 @@ package.preload["fennel.utils"] = package.preload["fennel.utils"] or function(..
if (0 == #path) then
return _3ffallback
else
- local _124_0 = nil
+ local _123_0 = nil
do
local t = tbl
for _, k in ipairs(path) do
if (nil == t) then break end
- local _125_0 = type(t)
- if (_125_0 == "table") then
+ local _124_0 = type(t)
+ if (_124_0 == "table") then
t = t[k]
else
t = nil
end
end
- _124_0 = t
+ _123_0 = t
end
- if (nil ~= _124_0) then
- local res = _124_0
+ if (nil ~= _123_0) then
+ local res = _123_0
return res
else
- local _ = _124_0
+ local _ = _123_0
return _3ffallback
end
end
@@ 4958,15 5052,15 @@ package.preload["fennel.utils"] = package.preload["fennel.utils"] or function(..
if (type(f) == "function") then
f0 = f
else
- local function _129_(_241)
+ local function _128_(_241)
return _241[f]
end
- f0 = _129_
+ f0 = _128_
end
for _, x in ipairs(t) do
- local _131_0 = f0(x)
- if (nil ~= _131_0) then
- local v = _131_0
+ local _130_0 = f0(x)
+ if (nil ~= _130_0) then
+ local v = _130_0
table.insert(out, v)
end
end
@@ 4978,19 5072,19 @@ package.preload["fennel.utils"] = package.preload["fennel.utils"] or function(..
if (type(f) == "function") then
f0 = f
else
- local function _133_(_241)
+ local function _132_(_241)
return _241[f]
end
- f0 = _133_
+ f0 = _132_
end
for k, x in stablepairs(t) do
- local _135_0, _136_0 = f0(k, x)
- if ((nil ~= _135_0) and (nil ~= _136_0)) then
- local key = _135_0
- local value = _136_0
- out[key] = value
- elseif (nil ~= _135_0) then
+ local _134_0, _135_0 = f0(k, x)
+ if ((nil ~= _134_0) and (nil ~= _135_0)) then
+ local key = _134_0
local value = _135_0
+ out[key] = value
+ elseif (nil ~= _134_0) then
+ local value = _134_0
table.insert(out, value)
end
end
@@ 5007,13 5101,13 @@ package.preload["fennel.utils"] = package.preload["fennel.utils"] or function(..
return tbl_14_
end
local function member_3f(x, tbl, _3fn)
- local _139_0 = tbl[(_3fn or 1)]
- if (_139_0 == x) then
+ local _138_0 = tbl[(_3fn or 1)]
+ if (_138_0 == x) then
return true
- elseif (_139_0 == nil) then
+ elseif (_138_0 == nil) then
return nil
else
- local _ = _139_0
+ local _ = _138_0
return member_3f(x, tbl, ((_3fn or 1) + 1))
end
end
@@ 5048,9 5142,9 @@ package.preload["fennel.utils"] = package.preload["fennel.utils"] or function(..
seen[next_state] = true
return next_state, value
else
- local _142_0 = getmetatable(t)
- if ((_G.type(_142_0) == "table") and true) then
- local __index = _142_0.__index
+ local _141_0 = getmetatable(t)
+ if ((_G.type(_141_0) == "table") and true) then
+ local __index = _141_0.__index
if ("table" == type(__index)) then
t = __index
return allpairs_next(t)
@@ 5068,10 5162,10 @@ package.preload["fennel.utils"] = package.preload["fennel.utils"] or function(..
local safe = {}
local view0 = nil
if _3fview then
- local function _146_(_241)
+ local function _145_(_241)
return _3fview(_241, _3foptions, _3findent)
end
- view0 = _146_
+ view0 = _145_
else
view0 = view
end
@@ 5092,19 5186,19 @@ package.preload["fennel.utils"] = package.preload["fennel.utils"] or function(..
end
local symbol_mt = {"SYMBOL", __eq = sym_3d, __fennelview = deref, __lt = sym_3c, __tostring = deref}
local expr_mt = nil
- local function _148_(x)
+ local function _147_(x)
return tostring(deref(x))
end
- expr_mt = {"EXPR", __tostring = _148_}
+ expr_mt = {"EXPR", __tostring = _147_}
local list_mt = {"LIST", __fennelview = list__3estring, __tostring = list__3estring}
local comment_mt = {"COMMENT", __eq = sym_3d, __fennelview = comment_view, __lt = sym_3c, __tostring = deref}
local sequence_marker = {"SEQUENCE"}
local varg_mt = {"VARARG", __fennelview = deref, __tostring = deref}
local getenv = nil
- local function _149_()
+ local function _148_()
return nil
end
- getenv = ((os and os.getenv) or _149_)
+ getenv = ((os and os.getenv) or _148_)
local function debug_on_3f(flag)
local level = (getenv("FENNEL_DEBUG") or "")
return ((level == "all") or level:find(flag))
@@ 5113,7 5207,7 @@ package.preload["fennel.utils"] = package.preload["fennel.utils"] or function(..
return setmetatable({...}, list_mt)
end
local function sym(str, _3fsource)
- local _150_
+ local _149_
do
local tbl_14_ = {str}
for k, v in pairs((_3fsource or {})) do
@@ 5127,13 5221,13 @@ package.preload["fennel.utils"] = package.preload["fennel.utils"] or function(..
tbl_14_[k_15_] = v_16_
end
end
- _150_ = tbl_14_
+ _149_ = tbl_14_
end
- return setmetatable(_150_, symbol_mt)
+ return setmetatable(_149_, symbol_mt)
end
nil_sym = sym("nil")
local function sequence(...)
- local function _153_(seq, view0, inspector, indent)
+ local function _152_(seq, view0, inspector, indent)
local opts = nil
do
inspector["empty-as-sequence?"] = {after = inspector["empty-as-sequence?"], once = true}
@@ 5142,19 5236,19 @@ package.preload["fennel.utils"] = package.preload["fennel.utils"] or function(..
end
return view0(seq, opts, indent)
end
- return setmetatable({...}, {__fennelview = _153_, sequence = sequence_marker})
+ return setmetatable({...}, {__fennelview = _152_, sequence = sequence_marker})
end
local function expr(strcode, etype)
return setmetatable({strcode, type = etype}, expr_mt)
end
local function comment_2a(contents, _3fsource)
- local _154_ = (_3fsource or {})
- local filename = _154_["filename"]
- local line = _154_["line"]
+ local _153_ = (_3fsource or {})
+ local filename = _153_["filename"]
+ local line = _153_["line"]
return setmetatable({contents, filename = filename, line = line}, comment_mt)
end
local function varg(_3fsource)
- local _155_
+ local _154_
do
local tbl_14_ = {"..."}
for k, v in pairs((_3fsource or {})) do
@@ 5168,9 5262,9 @@ package.preload["fennel.utils"] = package.preload["fennel.utils"] or function(..
tbl_14_[k_15_] = v_16_
end
end
- _155_ = tbl_14_
+ _154_ = tbl_14_
end
- return setmetatable(_155_, varg_mt)
+ return setmetatable(_154_, varg_mt)
end
local function expr_3f(x)
return ((type(x) == "table") and (getmetatable(x) == expr_mt) and x)
@@ 5208,7 5302,11 @@ package.preload["fennel.utils"] = package.preload["fennel.utils"] or function(..
end
end
local function string_3f(x)
- return (type(x) == "string")
+ if (type(x) == "string") then
+ return x
+ else
+ return false
+ end
end
local function multi_sym_3f(str)
if sym_3f(str) then
@@ 5219,35 5317,27 @@ package.preload["fennel.utils"] = package.preload["fennel.utils"] or function(..
local function _160_()
local parts = {}
for part in str:gmatch("[^%.%:]+[%.%:]?") do
- local last_char = part:sub(( - 1))
+ local last_char = part:sub(-1)
if (last_char == ":") then
parts["multi-sym-method-call"] = true
end
if ((last_char == ":") or (last_char == ".")) then
- parts[(#parts + 1)] = part:sub(1, ( - 2))
+ parts[(#parts + 1)] = part:sub(1, -2)
else
parts[(#parts + 1)] = part
end
end
- return ((0 < #parts) and parts)
+ return (next(parts) and parts)
end
- return ((str:match("%.") or str:match(":")) and not str:match("%.%.") and (str:byte() ~= string.byte(".")) and (str:byte(( - 1)) ~= string.byte(".")) and _160_())
+ return ((str:match("%.") or str:match(":")) and not str:match("%.%.") and (str:byte() ~= string.byte(".")) and (str:byte() ~= string.byte(":")) and (str:byte(-1) ~= string.byte(".")) and (str:byte(-1) ~= string.byte(":")) and _160_())
end
end
local function quoted_3f(symbol)
return symbol.quoted
end
local function idempotent_expr_3f(x)
- return ((type(x) == "string") or (type(x) == "integer") or (type(x) == "number") or (sym_3f(x) and not multi_sym_3f(x)))
- end
- local function ast_source(ast)
- if (table_3f(ast) or sequence_3f(ast)) then
- return (getmetatable(ast) or {})
- elseif ("table" == type(ast)) then
- return ast
- else
- return {}
- end
+ local t = type(x)
+ return ((t == "string") or (t == "integer") or (t == "number") or (t == "boolean") or (sym_3f(x) and not multi_sym_3f(x)))
end
local function walk_tree(root, f, _3fcustom_iterator)
local function walk(iterfn, parent, idx, node)
@@ 5273,27 5363,53 @@ package.preload["fennel.utils"] = package.preload["fennel.utils"] or function(..
return subopts
end
local root = nil
- local function _166_()
- end
- root = {chunk = nil, options = nil, reset = _166_, scope = nil}
- root["set-reset"] = function(_167_0)
- local _168_ = _167_0
- local chunk = _168_["chunk"]
- local options = _168_["options"]
- local reset = _168_["reset"]
- local scope = _168_["scope"]
+ local function _165_()
+ end
+ root = {chunk = nil, options = nil, reset = _165_, scope = nil}
+ root["set-reset"] = function(_166_0)
+ local _167_ = _166_0
+ local chunk = _167_["chunk"]
+ local options = _167_["options"]
+ local reset = _167_["reset"]
+ local scope = _167_["scope"]
root.reset = function()
root.chunk, root.scope, root.options, root.reset = chunk, scope, options, reset
return nil
end
return root.reset
end
+ local function ast_source(ast)
+ if (table_3f(ast) or sequence_3f(ast)) then
+ return (getmetatable(ast) or {})
+ elseif ("table" == type(ast)) then
+ return ast
+ else
+ return {}
+ end
+ end
+ local function warn(msg, _3fast)
+ if (_G.io and _G.io.stderr) then
+ local loc = nil
+ do
+ local _169_0 = ast_source(_3fast)
+ if ((_G.type(_169_0) == "table") and (nil ~= _169_0.filename) and (nil ~= _169_0.line)) then
+ local filename = _169_0.filename
+ local line = _169_0.line
+ loc = (filename .. ":" .. line .. ": ")
+ else
+ local _ = _169_0
+ loc = ""
+ end
+ end
+ return (_G.io.stderr):write(("--WARNING: %s%s\n"):format(loc, tostring(msg)))
+ end
+ end
local warned = {}
- local function check_plugin_version(_169_0)
- local _170_ = _169_0
- local plugin = _170_
- local name = _170_["name"]
- local versions = _170_["versions"]
+ local function check_plugin_version(_172_0)
+ local _173_ = _172_0
+ local plugin = _173_
+ local name = _173_["name"]
+ local versions = _173_["versions"]
if (not member_3f(version:gsub("-dev", ""), (versions or {})) and not warned[plugin]) then
warned[plugin] = true
return warn(string.format("plugin %s does not support Fennel version %s", (name or "unknown"), version))
@@ 5301,29 5417,29 @@ package.preload["fennel.utils"] = package.preload["fennel.utils"] or function(..
end
local function hook_opts(event, _3foptions, ...)
local plugins = nil
- local function _173_(...)
- local _172_0 = _3foptions
- if (nil ~= _172_0) then
- _172_0 = _172_0.plugins
- end
- return _172_0
- end
local function _176_(...)
- local _175_0 = root.options
+ local _175_0 = _3foptions
if (nil ~= _175_0) then
_175_0 = _175_0.plugins
end
return _175_0
end
- plugins = (_173_(...) or _176_(...))
+ local function _179_(...)
+ local _178_0 = root.options
+ if (nil ~= _178_0) then
+ _178_0 = _178_0.plugins
+ end
+ return _178_0
+ end
+ plugins = (_176_(...) or _179_(...))
if plugins then
local result = nil
for _, plugin in ipairs(plugins) do
if result then break end
check_plugin_version(plugin)
- local _178_0 = plugin[event]
- if (nil ~= _178_0) then
- local f = _178_0
+ local _181_0 = plugin[event]
+ if (nil ~= _181_0) then
+ local f = _181_0
result = f(...)
else
result = nil
@@ 5335,7 5451,7 @@ package.preload["fennel.utils"] = package.preload["fennel.utils"] or function(..
local function hook(event, ...)
return hook_opts(event, root.options, ...)
end
- return {["ast-source"] = ast_source, ["comment?"] = comment_3f, ["debug-on?"] = debug_on_3f, ["every?"] = every_3f, ["expr?"] = expr_3f, ["get-in"] = get_in, ["hook-opts"] = hook_opts, ["idempotent-expr?"] = idempotent_expr_3f, ["kv-table?"] = kv_table_3f, ["list?"] = list_3f, ["lua-keywords"] = lua_keywords, ["macro-path"] = table.concat({"./?.fnl", "./?/init-macros.fnl", "./?/init.fnl", getenv("FENNEL_MACRO_PATH")}, ";"), ["member?"] = member_3f, ["multi-sym?"] = multi_sym_3f, ["propagate-options"] = propagate_options, ["quoted?"] = quoted_3f, ["runtime-version"] = runtime_version, ["sequence?"] = sequence_3f, ["string?"] = string_3f, ["sym?"] = sym_3f, ["table?"] = table_3f, ["valid-lua-identifier?"] = valid_lua_identifier_3f, ["varg?"] = varg_3f, ["walk-tree"] = walk_tree, allpairs = allpairs, comment = comment_2a, copy = copy, expr = expr, hook = hook, kvmap = kvmap, len = len, list = list, map = map, maxn = maxn, path = table.concat({"./?.fnl", "./?/init.fnl", getenv("FENNEL_PATH")}, ";"), root = root, sequence = sequence, stablepairs = stablepairs, sym = sym, varg = varg, version = version, warn = warn}
+ return {["ast-source"] = ast_source, ["comment?"] = comment_3f, ["debug-on?"] = debug_on_3f, ["every?"] = every_3f, ["expr?"] = expr_3f, ["fennel-module"] = nil, ["get-in"] = get_in, ["hook-opts"] = hook_opts, ["idempotent-expr?"] = idempotent_expr_3f, ["kv-table?"] = kv_table_3f, ["list?"] = list_3f, ["lua-keywords"] = lua_keywords, ["macro-path"] = table.concat({"./?.fnl", "./?/init-macros.fnl", "./?/init.fnl", getenv("FENNEL_MACRO_PATH")}, ";"), ["member?"] = member_3f, ["multi-sym?"] = multi_sym_3f, ["propagate-options"] = propagate_options, ["quoted?"] = quoted_3f, ["runtime-version"] = runtime_version, ["sequence?"] = sequence_3f, ["string?"] = string_3f, ["sym?"] = sym_3f, ["table?"] = table_3f, ["valid-lua-identifier?"] = valid_lua_identifier_3f, ["varg?"] = varg_3f, ["walk-tree"] = walk_tree, allpairs = allpairs, comment = comment_2a, copy = copy, expr = expr, hook = hook, kvmap = kvmap, len = len, list = list, map = map, maxn = maxn, path = table.concat({"./?.fnl", "./?/init.fnl", getenv("FENNEL_PATH")}, ";"), root = root, sequence = sequence, stablepairs = stablepairs, sym = sym, varg = varg, version = version, warn = warn}
end
package.preload["fennel"] = package.preload["fennel"] or function(...)
local utils = require("fennel.utils")
@@ 5373,14 5489,14 @@ package.preload["fennel"] = package.preload["fennel"] or function(...)
local env = eval_env(opts.env, opts)
local lua_source = compiler["compile-string"](str, opts)
local loader = nil
- local function _732_(...)
+ local function _750_(...)
if opts.filename then
return ("@" .. opts.filename)
else
return str
end
end
- loader = specials["load-code"](lua_source, env, _732_(...))
+ loader = specials["load-code"](lua_source, env, _750_(...))
opts.filename = nil
return loader(...)
end
@@ 5396,25 5512,28 @@ package.preload["fennel"] = package.preload["fennel"] or function(...)
local body_3f = {"when", "with-open", "collect", "icollect", "fcollect", "lambda", "\206\187", "macro", "match", "match-try", "case", "case-try", "accumulate", "faccumulate", "doto"}
local binding_3f = {"collect", "icollect", "fcollect", "each", "for", "let", "with-open", "accumulate", "faccumulate"}
local define_3f = {"fn", "lambda", "\206\187", "var", "local", "macro", "macros", "global"}
+ local deprecated = {"~=", "#", "global", "require-macros", "pick-args"}
local out = {}
for k, v in pairs(compiler.scopes.global.specials) do
local metadata = (compiler.metadata[v] or {})
- out[k] = {["binding-form?"] = utils["member?"](k, binding_3f), ["body-form?"] = metadata["fnl/body-form?"], ["define?"] = utils["member?"](k, define_3f), ["special?"] = true}
+ out[k] = {["binding-form?"] = utils["member?"](k, binding_3f), ["body-form?"] = metadata["fnl/body-form?"], ["define?"] = utils["member?"](k, define_3f), ["deprecated?"] = utils["member?"](k, deprecated), ["special?"] = true}
end
- for k, v in pairs(compiler.scopes.global.macros) do
+ for k in pairs(compiler.scopes.global.macros) do
out[k] = {["binding-form?"] = utils["member?"](k, binding_3f), ["body-form?"] = utils["member?"](k, body_3f), ["define?"] = utils["member?"](k, define_3f), ["macro?"] = true}
end
for k, v in pairs(_G) do
- local _733_0 = type(v)
- if (_733_0 == "function") then
+ local _751_0 = type(v)
+ if (_751_0 == "function") then
out[k] = {["function?"] = true, ["global?"] = true}
- elseif (_733_0 == "table") then
- for k2, v2 in pairs(v) do
- if (("function" == type(v2)) and (k ~= "_G")) then
- out[(k .. "." .. k2)] = {["function?"] = true, ["global?"] = true}
+ elseif (_751_0 == "table") then
+ if not k:find("^_") then
+ for k2, v2 in pairs(v) do
+ if ("function" == type(v2)) then
+ out[(k .. "." .. k2)] = {["function?"] = true, ["global?"] = true}
+ end
end
+ out[k] = {["global?"] = true}
end
- out[k] = {["global?"] = true}
end
end
return out
@@ 5428,19 5547,22 @@ package.preload["fennel"] = package.preload["fennel"] or function(...)
do
local module_name = "fennel.macros"
local _ = nil
- local function _736_()
+ local function _755_()
return mod
end
- package.preload[module_name] = _736_
+ package.preload[module_name] = _755_
_ = nil
local env = nil
do
- local _737_0 = specials["make-compiler-env"](nil, compiler.scopes.compiler, {})
- _737_0["utils"] = utils
- _737_0["fennel"] = mod
- env = _737_0
+ local _756_0 = specials["make-compiler-env"](nil, compiler.scopes.compiler, {})
+ _756_0["utils"] = utils
+ _756_0["fennel"] = mod
+ _756_0["get-function-metadata"] = specials["get-function-metadata"]
+ env = _756_0
end
- local built_ins = eval([===[;; These macros are awkward because their definition cannot rely on the any
+ local built_ins = eval([===[;; fennel-ls: macro-file
+
+ ;; These macros are awkward because their definition cannot rely on the any
;; built-in macros, only special forms. (no when, no icollect, etc)
(fn copy [t]
@@ 5541,7 5663,8 @@ package.preload["fennel"] = package.preload["fennel"] or function(...)
,...)
closer `(fn close-handlers# [ok# ...]
(if ok# ... (error ... 0)))
- traceback `(. (or package.loaded.fennel debug) :traceback)]
+ traceback `(. (or (. package.loaded ,(fennel-module-name)) debug)
+ :traceback)]
(for [i 1 (length closable-bindings) 2]
(assert (sym? (. closable-bindings i))
"with-open only allows symbols in bindings")
@@ 5563,7 5686,7 @@ package.preload["fennel"] = package.preload["fennel"] or function(...)
(table.remove iter-out i)))))
(assert (or (not found?) (sym? into) (table? into) (list? into))
"expected table, function call, or symbol in &into clause")
- (values into iter-out))
+ (values into iter-out found?))
(fn collect* [iter-tbl key-expr value-expr ...]
"Return a table made by running an iterator and evaluating an expression that
@@ 5601,17 5724,23 @@ package.preload["fennel"] = package.preload["fennel"] or function(...)
(assert (not= nil value-expr) "expected table value expression")
(assert (= nil ...)
"expected exactly one body expression. Wrap multiple expressions in do")
- (let [(into iter) (extract-into iter-tbl)]
- `(let [tbl# ,into]
- ;; believe it or not, using a var here has a pretty good performance
- ;; boost: https://p.hagelb.org/icollect-performance.html
- (var i# (length tbl#))
- (,how ,iter
- (let [val# ,value-expr]
- (when (not= nil val#)
- (set i# (+ i# 1))
- (tset tbl# i# val#))))
- tbl#)))
+ (let [(into iter has-into?) (extract-into iter-tbl)]
+ (if has-into?
+ `(let [tbl# ,into]
+ (,how ,iter (let [val# ,value-expr]
+ (table.insert tbl# val#)))
+ tbl#)
+ ;; believe it or not, using a var here has a pretty good performance
+ ;; boost: https://p.hagelb.org/icollect-performance.html
+ ;; but it doesn't always work with &into clauses, so skip if that's used
+ `(let [tbl# []]
+ (var i# 0)
+ (,how ,iter
+ (let [val# ,value-expr]
+ (when (not= nil val#)
+ (set i# (+ i# 1))
+ (tset tbl# i# val#))))
+ tbl#))))
(fn icollect* [iter-tbl value-expr ...]
"Return a sequential table made by running an iterator and evaluating an
@@ 5745,7 5874,7 @@ package.preload["fennel"] = package.preload["fennel"] or function(...)
(.. "Expected n to be an integer >= 0, got " (tostring n)))
(let [let-syms (list)
let-values (if (= 1 (select "#" ...)) ... `(values ,...))]
- (for [i 1 n]
+ (for [_ 1 n]
(table.insert let-syms (gensym)))
(if (= n 0) `(values)
`(let [,let-syms ,let-values]
@@ 5760,19 5889,16 @@ package.preload["fennel"] = package.preload["fennel"] or function(...)
has-internal-name? (sym? (. args 1))
arglist (if has-internal-name? (. args 2) (. args 1))
metadata-position (if has-internal-name? 3 2)
- has-metadata? (and (< metadata-position args-len)
- (or (= :string (type (. args metadata-position)))
- (utils.kv-table? (. args metadata-position))))
- arity-check-position (- 4 (if has-internal-name? 0 1)
- (if has-metadata? 0 1))
- empty-body? (< args-len arity-check-position)]
+ (f-metadata check-position) (get-function-metadata [:lambda ...] arglist
+ metadata-position)
+ empty-body? (< args-len check-position)]
(fn check! [a]
(if (table? a)
(each [_ a (pairs a)] (check! a))
(let [as (tostring a)]
(and (not (as:match "^?")) (not= as "&") (not= as "_")
(not= as "...") (not= as "&as")))
- (table.insert args arity-check-position
+ (table.insert args check-position
`(_G.assert (not= nil ,a)
,(: "Missing argument %s on %s:%s" :format
(tostring a)
@@ 5781,8 5907,7 @@ package.preload["fennel"] = package.preload["fennel"] or function(...)
(assert (= :table (type arglist)) "expected arg list")
(each [_ a (ipairs arglist)] (check! a))
- (if empty-body?
- (table.insert args (sym :nil)))
+ (if empty-body? (table.insert args (sym :nil)))
`(fn ,(unpack args))))
(fn macro* [name ...]
@@ 5830,6 5955,32 @@ package.preload["fennel"] = package.preload["fennel"] or function(...)
(tset scope.macros import-key (. macros* macro-name))))))
nil)
+ (fn assert-repl* [condition ...]
+ "Enter into a debug REPL and print the message when condition is false/nil.
+ Works as a drop-in replacement for Lua's `assert`.
+ REPL `,return` command returns values to assert in place to continue execution."
+ {:fnl/arglist [condition ?message ...]}
+ (fn add-locals [{: symmeta : parent} locals]
+ (each [name (pairs symmeta)]
+ (tset locals name (sym name)))
+ (if parent (add-locals parent locals) locals))
+ `(let [unpack# (or table.unpack _G.unpack)
+ pack# (or table.pack #(doto [$...] (tset :n (select :# $...))))
+ ;; need to pack/unpack input args to account for (assert (foo)),
+ ;; because assert returns *all* arguments upon success
+ vals# (pack# ,condition ,...)
+ condition# (. vals# 1)
+ message# (or (. vals# 2) "assertion failed, entering repl.")]
+ (if (not condition#)
+ (let [opts# {:assert-repl? true}
+ fennel# (require ,(fennel-module-name))
+ locals# ,(add-locals (get-scope) [])]
+ (set opts#.message (fennel#.traceback message#))
+ (set opts#.env (collect [k# v# (pairs _G) &into locals#]
+ (if (= nil (. locals# k#)) (values k# v#))))
+ (_G.assert (fennel#.repl opts#)))
+ (values (unpack# vals# 1 vals#.n)))))
+
{:-> ->*
:->> ->>*
:-?> -?>*
@@ 5850,14 6001,17 @@ package.preload["fennel"] = package.preload["fennel"] or function(...)
:pick-values pick-values*
:macro macro*
:macrodebug macrodebug*
- :import-macros import-macros*}
+ :import-macros import-macros*
+ :assert-repl assert-repl*}
]===], {env = env, filename = "src/fennel/macros.fnl", moduleName = module_name, scope = compiler.scopes.compiler, useMetadata = true})
local _0 = nil
for k, v in pairs(built_ins) do
compiler.scopes.global.macros[k] = v
end
_0 = nil
- local match_macros = eval([===[;;; Pattern matching
+ local match_macros = eval([===[;; fennel-ls: macro-file
+
+ ;;; Pattern matching
;; This is separated out so we can use the "core" macros during the
;; implementation of pattern matching.
@@ 5960,7 6114,7 @@ package.preload["fennel"] = package.preload["fennel"] or function(...)
(let [in-pattern (symbols-in-pattern pattern)]
(if ?symbols
(do
- (each [name symbol (pairs ?symbols)]
+ (each [name (pairs ?symbols)]
(when (not (. in-pattern name))
(tset ?symbols name nil)))
?symbols)
@@ 5972,13 6126,12 @@ package.preload["fennel"] = package.preload["fennel"] or function(...)
(fn case-or [vals pattern guards unifications case-pattern opts]
(let [pattern [(unpack pattern 2)]
- bindings (symbols-in-every-pattern pattern opts.infer-unification?)] ;; TODO opts.infer-unification instead of opts.unification?
+ bindings (symbols-in-every-pattern pattern opts.infer-unification?)]
(if (= 0 (length bindings))
;; no bindings special case generates simple code
(let [condition
- (icollect [i subpattern (ipairs pattern) &into `(or)]
- (let [(subcondition subbindings) (case-pattern vals subpattern unifications opts)]
- subcondition))]
+ (icollect [_ subpattern (ipairs pattern) &into `(or)]
+ (case-pattern vals subpattern unifications opts))]
(values
(if (= 0 (length guards))
condition
@@ 5989,7 6142,7 @@ package.preload["fennel"] = package.preload["fennel"] or function(...)
bindings-mangled (icollect [_ binding (ipairs bindings)]
(gensym (tostring binding)))
pre-bindings `(if)]
- (each [i subpattern (ipairs pattern)]
+ (each [_ subpattern (ipairs pattern)]
(let [(subcondition subbindings) (case-guard vals subpattern guards {} case-pattern opts)]
(table.insert pre-bindings subcondition)
(table.insert pre-bindings `(let ,subbindings
@@ 6155,7 6308,7 @@ package.preload["fennel"] = package.preload["fennel"] or function(...)
(case-condition (list val) clauses match?)
;; protect against multiple evaluation of the value, bind against as
;; many values as we ever match against in the clauses.
- (let [vals (fcollect [i 1 vals-count &into (list)] (gensym))]
+ (let [vals (fcollect [_ 1 vals-count &into (list)] (gensym))]
(list `let [vals val] (case-condition vals clauses match?))))))
(fn case* [val ...]
@@ 6251,20 6404,20 @@ package.preload["fennel"] = package.preload["fennel"] or function(...)
end
fennel = require("fennel")
local unpack = (table.unpack or _G.unpack)
-local help = "\nUsage: fennel [FLAG] [FILE]\n\nRun fennel, a lisp programming language for the Lua runtime.\n\n --repl : Command to launch an interactive repl session\n --compile FILES (-c) : Command to AOT compile files, writing Lua to stdout\n --eval SOURCE (-e) : Command to evaluate source code and print result\n\n --no-searcher : Skip installing package.searchers entry\n --indent VAL : Indent compiler output with VAL\n --add-package-path PATH : Add PATH to package.path for finding Lua modules\n --add-package-cpath PATH : Add PATH to package.cpath for finding Lua modules\n --add-fennel-path PATH : Add PATH to fennel.path for finding Fennel modules\n --add-macro-path PATH : Add PATH to fennel.macro-path for macro modules\n --globals G1[,G2...] : Allow these globals in addition to standard ones\n --globals-only G1[,G2] : Same as above, but exclude standard ones\n --require-as-include : Inline required modules in the output\n --skip-include M1[,M2] : Omit certain modules from output when included\n --use-bit-lib : Use LuaJITs bit library instead of operators\n --metadata : Enable function metadata, even in compiled output\n --no-metadata : Disable function metadata, even in REPL\n --correlate : Make Lua output line numbers match Fennel input\n --load FILE (-l) : Load the specified FILE before executing command\n --lua LUA_EXE : Run in a child process with LUA_EXE\n --no-fennelrc : Skip loading ~/.fennelrc when launching repl\n --raw-errors : Disable friendly compile error reporting\n --plugin FILE : Activate the compiler plugin in FILE\n --compile-binary FILE\n OUT LUA_LIB LUA_DIR : Compile FILE to standalone binary OUT\n --compile-binary --help : Display further help for compiling binaries\n --no-compiler-sandbox : Don't limit compiler environment to minimal sandbox\n\n --help (-h) : Display this text\n --version (-v) : Show version\n\nGlobals are not checked when doing AOT (ahead-of-time) compilation unless\nthe --globals-only or --globals flag is provided. Use --globals \"*\" to disable\nstrict globals checking in other contexts.\n\nMetadata is typically considered a development feature and is not recommended\nfor production. It is used for docstrings and enabled by default in the REPL.\n\nWhen not given a command, runs the file given as the first argument.\nWhen given neither command nor file, launches a repl.\n\nUse the NO_COLOR environment variable to disable escape codes in error messages.\n\nIf ~/.fennelrc exists, it will be loaded before launching a repl."
+local help = "Usage: fennel [FLAG] [FILE]\n\nRun fennel, a lisp programming language for the Lua runtime.\n\n --repl : Command to launch an interactive repl session\n --compile FILES (-c) : Command to AOT compile files, writing Lua to stdout\n --eval SOURCE (-e) : Command to evaluate source code and print result\n\n --correlate : Make Lua output line numbers match Fennel input\n --load FILE (-l) : Load the specified FILE before executing command\n --no-compiler-sandbox : Don't limit compiler environment to minimal sandbox\n --compile-binary FILE\n OUT LUA_LIB LUA_DIR : Compile FILE to standalone binary OUT\n --compile-binary --help : Display further help for compiling binaries\n --add-package-path PATH : Add PATH to package.path for finding Lua modules\n --add-package-cpath PATH : Add PATH to package.cpath for finding Lua modules\n --add-fennel-path PATH : Add PATH to fennel.path for finding Fennel modules\n --add-macro-path PATH : Add PATH to fennel.macro-path for macro modules\n --globals G1[,G2...] : Allow these globals in addition to standard ones\n --globals-only G1[,G2] : Same as above, but exclude standard ones\n --assert-as-repl : Replace assert calls with assert-repl\n --require-as-include : Inline required modules in the output\n --skip-include M1[,M2] : Omit certain modules from output when included\n --use-bit-lib : Use LuaJITs bit library instead of operators\n --metadata : Enable function metadata, even in compiled output\n --no-metadata : Disable function metadata, even in REPL\n --lua LUA_EXE : Run in a child process with LUA_EXE\n --plugin FILE : Activate the compiler plugin in FILE\n --raw-errors : Disable friendly compile error reporting\n --no-searcher : Skip installing package.searchers entry\n --no-fennelrc : Skip loading ~/.fennelrc when launching repl\n\n --help (-h) : Display this text\n --version (-v) : Show version\n\nGlobals are not checked when doing AOT (ahead-of-time) compilation unless\nthe --globals-only or --globals flag is provided. Use --globals \"*\" to disable\nstrict globals checking in other contexts.\n\nMetadata is typically considered a development feature and is not recommended\nfor production. It is used for docstrings and enabled by default in the REPL.\n\nWhen not given a command, runs the file given as the first argument.\nWhen given neither command nor file, launches a repl.\n\nUse the NO_COLOR environment variable to disable escape codes in error messages.\n\nIf ~/.fennelrc exists, it will be loaded before launching a repl."
local options = {plugins = {}}
local function pack(...)
- local _738_0 = {...}
- _738_0["n"] = select("#", ...)
- return _738_0
+ local _757_0 = {...}
+ _757_0["n"] = select("#", ...)
+ return _757_0
end
local function dosafely(f, ...)
local args = {...}
local result = nil
- local function _739_()
+ local function _758_()
return f(unpack(args))
end
- result = pack(xpcall(_739_, fennel.traceback))
+ result = pack(xpcall(_758_, fennel.traceback))
if not result[1] then
do end (io.stderr):write((result[2] .. "\n"))
os.exit(1)
@@ 6309,19 6462,18 @@ local function handle_lua(i)
if (nil == arg[-1]) then
do end (io.stderr):write("WARNING: --lua argument only works from script, not binary.\n")
end
- local ok = os.execute(table.concat(cmd, " "))
- local _744_
- if ok then
- _744_ = 0
+ local _763_0, _764_0 = os.execute(table.concat(cmd, " "))
+ if (((_763_0 == true) and (_764_0 == "exit")) or (_763_0 == 0)) then
+ return os.exit(0, true)
else
- _744_ = 1
+ local _ = _763_0
+ return os.exit(1, true)
end
- return os.exit(_744_, true)
end
assert(arg, "Using the launcher from non-CLI context; use fennel.lua instead.")
for i = #arg, 1, -1 do
- local _746_0 = arg[i]
- if (_746_0 == "--lua") then
+ local _766_0 = arg[i]
+ if (_766_0 == "--lua") then
handle_lua(i)
end
end
@@ 6329,55 6481,58 @@ do
local commands = {["-"] = true, ["--compile"] = true, ["--compile-binary"] = true, ["--eval"] = true, ["--help"] = true, ["--repl"] = true, ["--version"] = true, ["-c"] = true, ["-e"] = true, ["-h"] = true, ["-v"] = true}
local i = 1
while (arg[i] and not options["ignore-options"]) do
- local _748_0 = arg[i]
- if (_748_0 == "--no-searcher") then
+ local _768_0 = arg[i]
+ if (_768_0 == "--no-searcher") then
options["no-searcher"] = true
table.remove(arg, i)
- elseif (_748_0 == "--indent") then
+ elseif (_768_0 == "--indent") then
options.indent = table.remove(arg, (i + 1))
if (options.indent == "false") then
options.indent = false
end
table.remove(arg, i)
- elseif (_748_0 == "--add-package-path") then
+ elseif (_768_0 == "--add-package-path") then
local entry = table.remove(arg, (i + 1))
package.path = (entry .. ";" .. package.path)
table.remove(arg, i)
- elseif (_748_0 == "--add-package-cpath") then
+ elseif (_768_0 == "--add-package-cpath") then
local entry = table.remove(arg, (i + 1))
package.cpath = (entry .. ";" .. package.cpath)
table.remove(arg, i)
- elseif (_748_0 == "--add-fennel-path") then
+ elseif (_768_0 == "--add-fennel-path") then
local entry = table.remove(arg, (i + 1))
fennel.path = (entry .. ";" .. fennel.path)
table.remove(arg, i)
- elseif (_748_0 == "--add-macro-path") then
+ elseif (_768_0 == "--add-macro-path") then
local entry = table.remove(arg, (i + 1))
fennel["macro-path"] = (entry .. ";" .. fennel["macro-path"])
table.remove(arg, i)
- elseif (_748_0 == "--load") then
+ elseif (_768_0 == "--load") then
handle_load(i)
- elseif (_748_0 == "-l") then
+ elseif (_768_0 == "-l") then
handle_load(i)
- elseif (_748_0 == "--no-fennelrc") then
+ elseif (_768_0 == "--no-fennelrc") then
options.fennelrc = false
table.remove(arg, i)
- elseif (_748_0 == "--correlate") then
+ elseif (_768_0 == "--correlate") then
options.correlate = true
table.remove(arg, i)
- elseif (_748_0 == "--check-unused-locals") then
+ elseif (_768_0 == "--check-unused-locals") then
options.checkUnusedLocals = true
table.remove(arg, i)
- elseif (_748_0 == "--globals") then
+ elseif (_768_0 == "--globals") then
allow_globals(table.remove(arg, (i + 1)), _G)
table.remove(arg, i)
- elseif (_748_0 == "--globals-only") then
+ elseif (_768_0 == "--globals-only") then
allow_globals(table.remove(arg, (i + 1)), {})
table.remove(arg, i)
- elseif (_748_0 == "--require-as-include") then
+ elseif (_768_0 == "--require-as-include") then
options.requireAsInclude = true
table.remove(arg, i)
- elseif (_748_0 == "--skip-include") then
+ elseif (_768_0 == "--assert-as-repl") then
+ options.assertAsRepl = true
+ table.remove(arg, i)
+ elseif (_768_0 == "--skip-include") then
local skip_names = table.remove(arg, (i + 1))
local skip = nil
do
@@ 6394,28 6549,28 @@ do
end
options.skipInclude = skip
table.remove(arg, i)
- elseif (_748_0 == "--use-bit-lib") then
+ elseif (_768_0 == "--use-bit-lib") then
options.useBitLib = true
table.remove(arg, i)
- elseif (_748_0 == "--metadata") then
+ elseif (_768_0 == "--metadata") then
options.useMetadata = true
table.remove(arg, i)
- elseif (_748_0 == "--no-metadata") then
+ elseif (_768_0 == "--no-metadata") then
options.useMetadata = false
table.remove(arg, i)
- elseif (_748_0 == "--no-compiler-sandbox") then
+ elseif (_768_0 == "--no-compiler-sandbox") then
options["compiler-env"] = _G
table.remove(arg, i)
- elseif (_748_0 == "--raw-errors") then
+ elseif (_768_0 == "--raw-errors") then
options.unfriendly = true
table.remove(arg, i)
- elseif (_748_0 == "--plugin") then
+ elseif (_768_0 == "--plugin") then
local opts = {["compiler-env"] = _G, env = "_COMPILER", useMetadata = true}
local plugin = fennel.dofile(table.remove(arg, (i + 1)), opts)
table.insert(options.plugins, 1, plugin)
table.remove(arg, i)
else
- local _ = _748_0
+ local _ = _768_0
if not commands[arg[i]] then
options["ignore-options"] = true
i = (i + 1)
@@ 6451,25 6606,25 @@ local function load_initfile()
end
local function repl()
local readline_3f = (("dumb" ~= os.getenv("TERM")) and pcall(require, "readline"))
+ local welcome = {("Welcome to " .. fennel["runtime-version"]() .. "!"), "Use ,help to see available commands."}
searcher_opts.useMetadata = (false ~= options.useMetadata)
if (false ~= options.fennelrc) then
options["fennelrc"] = load_initfile
end
- print(("Welcome to " .. fennel["runtime-version"]() .. "!"))
- print("Use ,help to see available commands.")
if (not readline_3f and ("dumb" ~= os.getenv("TERM"))) then
- print("Try installing readline via luarocks for a better repl experience.")
+ table.insert(welcome, ("Try installing readline via luarocks for a " .. "better repl experience."))
end
+ options.message = table.concat(welcome, "\n")
return fennel.repl(options)
end
local function eval(form)
- local _758_
+ local _778_
if (form == "-") then
- _758_ = (io.stdin):read("*a")
+ _778_ = (io.stdin):read("*a")
else
- _758_ = form
+ _778_ = form
end
- return print(dosafely(fennel.eval, _758_, options))
+ return print(dosafely(fennel.eval, _778_, options))
end
local function compile(files)
for _, filename in ipairs(files) do
@@ 6481,17 6636,17 @@ local function compile(files)
f = assert(io.open(filename, "rb"))
end
do
- local _761_0, _762_0 = nil, nil
- local function _763_()
+ local _781_0, _782_0 = nil, nil
+ local function _783_()
return fennel["compile-string"](f:read("*a"), options)
end
- _761_0, _762_0 = xpcall(_763_, fennel.traceback)
- if ((_761_0 == true) and (nil ~= _762_0)) then
- local val = _762_0
+ _781_0, _782_0 = xpcall(_783_, fennel.traceback)
+ if ((_781_0 == true) and (nil ~= _782_0)) then
+ local val = _782_0
print(val)
- elseif (true and (nil ~= _762_0)) then
- local _0 = _761_0
- local msg = _762_0
+ elseif (true and (nil ~= _782_0)) then
+ local _0 = _781_0
+ local msg = _782_0
do end (io.stderr):write((msg .. "\n"))
os.exit(1)
end
@@ 6500,57 6655,56 @@ local function compile(files)
end
return nil
end
-local _765_0 = arg
-local function _766_(...)
+local _785_0 = arg
+local function _786_(...)
return (0 == #arg)
end
-if ((_G.type(_765_0) == "table") and _766_(...)) then
+if ((_G.type(_785_0) == "table") and _786_(...)) then
return repl()
-elseif ((_G.type(_765_0) == "table") and (_765_0[1] == "--repl")) then
+elseif ((_G.type(_785_0) == "table") and (_785_0[1] == "--repl")) then
return repl()
-elseif ((_G.type(_765_0) == "table") and (_765_0[1] == "--compile")) then
- local files = {select(2, (table.unpack or _G.unpack)(_765_0))}
+elseif ((_G.type(_785_0) == "table") and (_785_0[1] == "--compile")) then
+ local files = {select(2, (table.unpack or _G.unpack)(_785_0))}
return compile(files)
-elseif ((_G.type(_765_0) == "table") and (_765_0[1] == "-c")) then
- local files = {select(2, (table.unpack or _G.unpack)(_765_0))}
+elseif ((_G.type(_785_0) == "table") and (_785_0[1] == "-c")) then
+ local files = {select(2, (table.unpack or _G.unpack)(_785_0))}
return compile(files)
-elseif ((_G.type(_765_0) == "table") and (_765_0[1] == "--compile-binary") and (nil ~= _765_0[2]) and (nil ~= _765_0[3]) and (nil ~= _765_0[4]) and (nil ~= _765_0[5])) then
- local filename = _765_0[2]
- local out = _765_0[3]
- local static_lua = _765_0[4]
- local lua_include_dir = _765_0[5]
- local args = {select(6, (table.unpack or _G.unpack)(_765_0))}
+elseif ((_G.type(_785_0) == "table") and (_785_0[1] == "--compile-binary") and (nil ~= _785_0[2]) and (nil ~= _785_0[3]) and (nil ~= _785_0[4]) and (nil ~= _785_0[5])) then
+ local filename = _785_0[2]
+ local out = _785_0[3]
+ local static_lua = _785_0[4]
+ local lua_include_dir = _785_0[5]
+ local args = {select(6, (table.unpack or _G.unpack)(_785_0))}
local bin = require("fennel.binary")
options.filename = filename
options.requireAsInclude = true
return bin.compile(filename, out, static_lua, lua_include_dir, options, args)
-elseif ((_G.type(_765_0) == "table") and (_765_0[1] == "--compile-binary")) then
+elseif ((_G.type(_785_0) == "table") and (_785_0[1] == "--compile-binary")) then
local cmd = (arg[0] or "fennel")
return print((require("fennel.binary").help):format(cmd, cmd, cmd))
-elseif ((_G.type(_765_0) == "table") and (_765_0[1] == "--eval") and (nil ~= _765_0[2])) then
- local form = _765_0[2]
+elseif ((_G.type(_785_0) == "table") and (_785_0[1] == "--eval") and (nil ~= _785_0[2])) then
+ local form = _785_0[2]
return eval(form)
-elseif ((_G.type(_765_0) == "table") and (_765_0[1] == "-e") and (nil ~= _765_0[2])) then
- local form = _765_0[2]
+elseif ((_G.type(_785_0) == "table") and (_785_0[1] == "-e") and (nil ~= _785_0[2])) then
+ local form = _785_0[2]
return eval(form)
else
- local function _794_(...)
- local a = _765_0[1]
+ local function _816_(...)
+ local a = _785_0[1]
return ((a == "-v") or (a == "--version"))
end
- if (((_G.type(_765_0) == "table") and (nil ~= _765_0[1])) and _794_(...)) then
- local a = _765_0[1]
+ if (((_G.type(_785_0) == "table") and (nil ~= _785_0[1])) and _816_(...)) then
+ local a = _785_0[1]
return print(fennel["runtime-version"]())
- elseif ((_G.type(_765_0) == "table") and (_765_0[1] == "--help")) then
+ elseif ((_G.type(_785_0) == "table") and (_785_0[1] == "--help")) then
return print(help)
- elseif ((_G.type(_765_0) == "table") and (_765_0[1] == "-h")) then
+ elseif ((_G.type(_785_0) == "table") and (_785_0[1] == "-h")) then
return print(help)
- elseif ((_G.type(_765_0) == "table") and (_765_0[1] == "-")) then
- local args = {select(2, (table.unpack or _G.unpack)(_765_0))}
+ elseif ((_G.type(_785_0) == "table") and (_785_0[1] == "-")) then
return dosafely(fennel.eval, (io.stdin):read("*a"))
- elseif ((_G.type(_765_0) == "table") and (nil ~= _765_0[1])) then
- local filename = _765_0[1]
- local args = {select(2, (table.unpack or _G.unpack)(_765_0))}
+ elseif ((_G.type(_785_0) == "table") and (nil ~= _785_0[1])) then
+ local filename = _785_0[1]
+ local args = {select(2, (table.unpack or _G.unpack)(_785_0))}
arg[-2] = arg[-1]
arg[-1] = arg[0]
arg[0] = table.remove(arg, 1)