Added moonc compiled versions of files.
This commit is contained in:
Bruce Hill
parent
7bcdfdbc1f
commit
0615d127b5
847
nomic.lua
Normal file
847
nomic.lua
Normal file
@ -0,0 +1,847 @@
|
||||
local re = require('re')
|
||||
local lpeg = require('lpeg')
|
||||
local utils = require('utils')
|
||||
local INDENT = " "
|
||||
lpeg.setmaxstack(10000)
|
||||
local P, V, S, Cg, C, Cp, B, Cmt
|
||||
P, V, S, Cg, C, Cp, B, Cmt = lpeg.P, lpeg.V, lpeg.S, lpeg.Cg, lpeg.C, lpeg.Cp, lpeg.B, lpeg.Cmt
|
||||
local wordchar = P(1) - S(' \t\n\r%:;,.{}[]()"')
|
||||
local comment = re.compile([[comment <- "(#" (comment / ((! "#)") .))* "#)"]])
|
||||
local whitespace = (S(" \t") + comment) ^ 1
|
||||
local nl = P("\n")
|
||||
local blank_line = whitespace ^ -1 * nl
|
||||
local get_line_indentation
|
||||
get_line_indentation = function(line)
|
||||
local indent_amounts = {
|
||||
[" "] = 1,
|
||||
["\t"] = 4
|
||||
}
|
||||
do
|
||||
local sum = 0
|
||||
local leading_space = line:gsub("([\t ]*).*", "%1")
|
||||
for c in leading_space:gmatch("[\t ]") do
|
||||
sum = sum + indent_amounts[c]
|
||||
end
|
||||
return sum
|
||||
end
|
||||
end
|
||||
local make_parser
|
||||
make_parser = function(lingo, extra_definitions)
|
||||
local indent_stack = {
|
||||
0
|
||||
}
|
||||
local push
|
||||
push = function(n)
|
||||
return table.insert(indent_stack, n)
|
||||
end
|
||||
local pop
|
||||
pop = function()
|
||||
return table.remove(indent_stack)
|
||||
end
|
||||
local check_indent
|
||||
check_indent = function(subject, end_pos, spaces)
|
||||
local num_spaces = get_line_indentation(spaces)
|
||||
if num_spaces <= indent_stack[#indent_stack] then
|
||||
return nil
|
||||
end
|
||||
push(num_spaces)
|
||||
return end_pos
|
||||
end
|
||||
local check_dedent
|
||||
check_dedent = function(subject, end_pos, spaces)
|
||||
local num_spaces = get_line_indentation(spaces)
|
||||
if num_spaces >= indent_stack[#indent_stack] then
|
||||
return nil
|
||||
end
|
||||
pop()
|
||||
return end_pos
|
||||
end
|
||||
local check_nodent
|
||||
check_nodent = function(subject, end_pos, spaces)
|
||||
local num_spaces = get_line_indentation(spaces)
|
||||
if num_spaces ~= indent_stack[#indent_stack] then
|
||||
return nil
|
||||
end
|
||||
return end_pos
|
||||
end
|
||||
local defs = {
|
||||
wordchar = wordchar,
|
||||
nl = nl,
|
||||
ws = whitespace,
|
||||
comment = comment,
|
||||
eol = #nl + (P("") - P(1)),
|
||||
word_boundary = whitespace + B(P("..")) + B(S("\";)]")) + #S("\":([") + #((whitespace + nl) ^ 0 * P("..")),
|
||||
indent = #(nl * blank_line ^ 0 * Cmt(whitespace ^ -1, check_indent)),
|
||||
dedent = #(nl * blank_line ^ 0 * Cmt(whitespace ^ -1, check_dedent)),
|
||||
new_line = nl * blank_line ^ 0 * Cmt(whitespace ^ -1, check_nodent),
|
||||
error_handler = function(src, pos, errors)
|
||||
local line_no = 1
|
||||
for _ in src:sub(1, -#errors):gmatch("\n") do
|
||||
line_no = line_no + 1
|
||||
end
|
||||
local err_pos = #src - #errors + 1
|
||||
if errors:sub(1, 1) == "\n" then
|
||||
err_pos = err_pos + #errors:match("[ \t]*", 2)
|
||||
end
|
||||
local start_of_err_line = err_pos
|
||||
while src:sub(start_of_err_line, start_of_err_line) ~= "\n" do
|
||||
start_of_err_line = start_of_err_line - 1
|
||||
end
|
||||
local start_of_prev_line = start_of_err_line - 1
|
||||
while src:sub(start_of_prev_line, start_of_prev_line) ~= "\n" do
|
||||
start_of_prev_line = start_of_prev_line - 1
|
||||
end
|
||||
local prev_line, err_line, next_line = src:match("([^\n]*)\n([^\n]*)\n([^\n]*)", start_of_prev_line + 1)
|
||||
local pointer = ("-"):rep(err_pos - start_of_err_line + 0) .. "^"
|
||||
return error("\nParse error on line " .. tostring(line_no) .. ":\n\n" .. tostring(prev_line) .. "\n" .. tostring(err_line) .. "\n" .. tostring(pointer) .. "\n" .. tostring(next_line) .. "\n")
|
||||
end
|
||||
}
|
||||
if extra_definitions then
|
||||
for k, v in pairs(extra_definitions) do
|
||||
defs[k] = v
|
||||
end
|
||||
end
|
||||
setmetatable(defs, {
|
||||
__index = function(t, key)
|
||||
local fn
|
||||
fn = function(src, value, errors)
|
||||
local token = {
|
||||
type = key,
|
||||
src = src,
|
||||
value = value,
|
||||
errors = errors
|
||||
}
|
||||
return token
|
||||
end
|
||||
t[key] = fn
|
||||
return fn
|
||||
end
|
||||
})
|
||||
return re.compile(lingo, defs)
|
||||
end
|
||||
local Compiler
|
||||
do
|
||||
local _class_0
|
||||
local _base_0 = {
|
||||
call = function(self, fn_name, ...)
|
||||
local fn_info = self.defs[fn_name]
|
||||
if fn_info == nil then
|
||||
self:error("Attempt to call undefined function: " .. tostring(fn_name))
|
||||
end
|
||||
if fn_info.is_macro then
|
||||
self:error("Attempt to call macro at runtime: " .. tostring(fn_name))
|
||||
end
|
||||
if not (self:check_permission(fn_name)) then
|
||||
self:error("You do not have the authority to call: " .. tostring(fn_name))
|
||||
end
|
||||
table.insert(self.callstack, fn_name)
|
||||
local fn, arg_names
|
||||
fn, arg_names = fn_info.fn, fn_info.arg_names
|
||||
local args
|
||||
do
|
||||
local _tbl_0 = { }
|
||||
for i, name in ipairs(arg_names) do
|
||||
_tbl_0[name] = select(i, ...)
|
||||
end
|
||||
args = _tbl_0
|
||||
end
|
||||
if self.debug then
|
||||
print("Calling " .. tostring(fn_name) .. " with args: " .. tostring(utils.repr(args)))
|
||||
end
|
||||
local ret = fn(self, args)
|
||||
table.remove(self.callstack)
|
||||
return ret
|
||||
end,
|
||||
check_permission = function(self, fn_name)
|
||||
local fn_info = self.defs[fn_name]
|
||||
if fn_info == nil then
|
||||
self:error("Undefined function: " .. tostring(fn_name))
|
||||
end
|
||||
if fn_info.whiteset == nil then
|
||||
return true
|
||||
end
|
||||
local _list_0 = self.callstack
|
||||
for _index_0 = 1, #_list_0 do
|
||||
local caller = _list_0[_index_0]
|
||||
if fn_info.whiteset[caller] then
|
||||
return true
|
||||
end
|
||||
end
|
||||
return false
|
||||
end,
|
||||
def = function(self, spec, fn)
|
||||
if self.debug then
|
||||
print("Defining rule: " .. tostring(spec))
|
||||
end
|
||||
local invocations, arg_names = self:get_invocations(spec)
|
||||
local fn_info = {
|
||||
fn = fn,
|
||||
arg_names = arg_names,
|
||||
invocations = invocations,
|
||||
is_macro = false
|
||||
}
|
||||
for _index_0 = 1, #invocations do
|
||||
local invocation = invocations[_index_0]
|
||||
self.defs[invocation] = fn_info
|
||||
end
|
||||
end,
|
||||
get_invocations = function(self, text)
|
||||
if type(text) == 'string' then
|
||||
text = {
|
||||
text
|
||||
}
|
||||
end
|
||||
local invocations = { }
|
||||
local arg_names
|
||||
for _index_0 = 1, #text do
|
||||
local _text = text[_index_0]
|
||||
local invocation = _text:gsub("%%%S+", "%%")
|
||||
local _arg_names
|
||||
do
|
||||
local _accum_0 = { }
|
||||
local _len_0 = 1
|
||||
for arg in _text:gmatch("%%(%S+)") do
|
||||
_accum_0[_len_0] = arg
|
||||
_len_0 = _len_0 + 1
|
||||
end
|
||||
_arg_names = _accum_0
|
||||
end
|
||||
table.insert(invocations, invocation)
|
||||
if arg_names then
|
||||
if not utils.equivalent(utils.set(arg_names), utils.set(_arg_names)) then
|
||||
self:error("Conflicting argument names " .. tostring(utils.repr(arg_names)) .. " and " .. tostring(utils.repr(_arg_names)) .. " for " .. tostring(utils.repr(text)))
|
||||
end
|
||||
else
|
||||
arg_names = _arg_names
|
||||
end
|
||||
end
|
||||
return invocations, arg_names
|
||||
end,
|
||||
defmacro = function(self, spec, lua_gen_fn)
|
||||
local invocations, arg_names = self:get_invocations(spec)
|
||||
local fn_info = {
|
||||
fn = lua_gen_fn,
|
||||
arg_names = arg_names,
|
||||
invocations = invocations,
|
||||
is_macro = true
|
||||
}
|
||||
for _index_0 = 1, #invocations do
|
||||
local invocation = invocations[_index_0]
|
||||
self.defs[invocation] = fn_info
|
||||
end
|
||||
end,
|
||||
run = function(self, text)
|
||||
if self.debug then
|
||||
print("RUNNING TEXT:\n" .. tostring(text))
|
||||
end
|
||||
local code = self:compile(text)
|
||||
if self.debug then
|
||||
print("\nGENERATED LUA CODE:\n" .. tostring(code))
|
||||
end
|
||||
local _ = [==[ lua_thunk, err = loadstring(code)
|
||||
if not lua_thunk
|
||||
error("Failed to compile generated code:\n#{code}\n\n#{err}")
|
||||
action = lua_thunk!
|
||||
if @debug
|
||||
print("Running...")
|
||||
return action(self, {})
|
||||
]==]
|
||||
return code
|
||||
end,
|
||||
parse = function(self, str)
|
||||
if self.debug then
|
||||
print("PARSING:\n" .. tostring(str))
|
||||
end
|
||||
local lingo = [=[ file <- ({ {| %ws? %new_line? {:body: block :} %new_line? %ws? (errors)? |} }) -> File
|
||||
errors <- (({.+}) => error_handler)
|
||||
block <- ({ {| statement (%new_line statement)* |} }) -> Block
|
||||
statement <- ({ (functioncall / expression) }) -> Statement
|
||||
one_liner <- ({ {|
|
||||
(({
|
||||
(({ {|
|
||||
(expression (%word_boundary fn_bit)+) / (word (%word_boundary fn_bit)*)
|
||||
|} }) -> FunctionCall)
|
||||
/ (expression)
|
||||
}) -> Statement)
|
||||
|} }) -> Block
|
||||
|
||||
functioncall <- ({ {| (expression %word_boundary fn_bits) / (word (%word_boundary fn_bits)?) |} }) -> FunctionCall
|
||||
fn_bit <- (expression / word)
|
||||
fn_bits <-
|
||||
((".." %ws? (%indent %new_line indented_fn_bits %dedent) (%new_line ".." %ws? fn_bits)?)
|
||||
/ (%new_line ".." fn_bit (%word_boundary fn_bits)?)
|
||||
/ (fn_bit (%word_boundary fn_bits)?))
|
||||
indented_fn_bits <-
|
||||
fn_bit ((%new_line / %word_boundary) indented_fn_bits)?
|
||||
|
||||
thunk <-
|
||||
({ ":" %ws?
|
||||
((%indent %new_line block ((%dedent (%new_line "..")?) / errors))
|
||||
/ (one_liner (%ws? (%new_line? ".."))?)) }) -> Thunk
|
||||
|
||||
word <- ({ !number {%wordchar+} }) -> Word
|
||||
expression <- ({ (longstring / string / number / variable / list / thunk / subexpression) }) -> Expression
|
||||
|
||||
string <- ({ (!longstring) '"' {(("\" .) / [^"])*} '"' }) -> String
|
||||
longstring <- ({ '".."' %ws? %indent {(%new_line "|" [^%nl]*)+} ((%dedent (%new_line '..')?) / errors) }) -> Longstring
|
||||
number <- ({ {'-'? [0-9]+ ("." [0-9]+)?} }) -> Number
|
||||
variable <- ({ ("%" {%wordchar+}) }) -> Var
|
||||
|
||||
subexpression <-
|
||||
(!%comment "(" %ws? (functioncall / expression) %ws? ")")
|
||||
/ ("(..)" %ws? %indent %new_line ((({ {| indented_fn_bits |} }) -> FunctionCall) / expression) %dedent (%new_line "..")?)
|
||||
|
||||
list <- ({ {|
|
||||
("[..]" %ws? %indent %new_line indented_list ","? ((%dedent (%new_line "..")?) / errors))
|
||||
/ ("[" %ws? (list_items ","?)? %ws?"]")
|
||||
|} }) -> List
|
||||
list_items <- ((functioncall / expression) (list_sep list_items)?)
|
||||
list_sep <- %ws? "," %ws?
|
||||
indented_list <-
|
||||
(functioncall / expression) (((list_sep %new_line?) / %new_line) indented_list)?
|
||||
]=]
|
||||
lingo = make_parser(lingo)
|
||||
local tree = lingo:match(str:gsub("\r", "") .. "\n")
|
||||
if self.debug then
|
||||
print("\nPARSE TREE:")
|
||||
self:print_tree(tree)
|
||||
end
|
||||
assert(tree, "Failed to parse: " .. tostring(str))
|
||||
return tree
|
||||
end,
|
||||
tree_to_value = function(self, tree)
|
||||
local code = "return (function(compiler, vars)\nreturn " .. tostring(self:tree_to_lua(tree)) .. "\nend)"
|
||||
local lua_thunk, err = load(code)
|
||||
if not lua_thunk then
|
||||
error("Failed to compile generated code:\n" .. tostring(code) .. "\n\n" .. tostring(err))
|
||||
end
|
||||
return (lua_thunk())(self, { })
|
||||
end,
|
||||
tree_to_lua = function(self, tree, kind)
|
||||
if kind == nil then
|
||||
kind = "Expression"
|
||||
end
|
||||
assert(tree, "No tree provided.")
|
||||
local indent = ""
|
||||
local buffer = { }
|
||||
local to_lua
|
||||
to_lua = function(t, kind)
|
||||
local ret = self:tree_to_lua(t, kind)
|
||||
return ret
|
||||
end
|
||||
local add
|
||||
add = function(code)
|
||||
return table.insert(buffer, code)
|
||||
end
|
||||
local _exp_0 = tree.type
|
||||
if "File" == _exp_0 then
|
||||
add([[return (function(compiler, vars)
|
||||
local ret]])
|
||||
local vars = { }
|
||||
local _list_0 = tree.value.body.value
|
||||
for _index_0 = 1, #_list_0 do
|
||||
local statement = _list_0[_index_0]
|
||||
local code = to_lua(statement)
|
||||
local lua_thunk, err = load("return (function(compiler, vars)\n" .. tostring(code) .. "\nend)")
|
||||
if not lua_thunk then
|
||||
error("Failed to compile generated code:\n" .. tostring(code) .. "\n\n" .. tostring(err))
|
||||
end
|
||||
local ok
|
||||
ok, err = pcall(lua_thunk)
|
||||
if not ok then
|
||||
error(err)
|
||||
end
|
||||
ok, err = pcall(err, self, vars)
|
||||
if not ok then
|
||||
self:error(err)
|
||||
end
|
||||
add(code)
|
||||
end
|
||||
add([[ return ret
|
||||
end)
|
||||
]])
|
||||
elseif "Block" == _exp_0 then
|
||||
local _list_0 = tree.value
|
||||
for _index_0 = 1, #_list_0 do
|
||||
local statement = _list_0[_index_0]
|
||||
add(to_lua(statement))
|
||||
end
|
||||
elseif "Thunk" == _exp_0 then
|
||||
assert(tree.value.type == "Block", "Non-block value in Thunk")
|
||||
add([[ (function(compiler, vars)
|
||||
local ret]])
|
||||
add(to_lua(tree.value))
|
||||
add([[ return ret
|
||||
end)
|
||||
]])
|
||||
elseif "Statement" == _exp_0 then
|
||||
if tree.value.type == "FunctionCall" then
|
||||
local name = self:fn_name_from_tree(tree.value)
|
||||
if self.defs[name] and self.defs[name].is_macro then
|
||||
add(self:run_macro(tree.value, "Statement"))
|
||||
else
|
||||
add("ret = " .. (to_lua(tree.value):match("%s*(.*)")))
|
||||
end
|
||||
else
|
||||
add("ret = " .. (to_lua(tree.value):match("%s*(.*)")))
|
||||
end
|
||||
elseif "Expression" == _exp_0 then
|
||||
add(to_lua(tree.value))
|
||||
elseif "FunctionCall" == _exp_0 then
|
||||
local name = self:fn_name_from_tree(tree)
|
||||
if self.defs[name] and self.defs[name].is_macro then
|
||||
add(self:run_macro(tree, "Expression"))
|
||||
else
|
||||
local args
|
||||
do
|
||||
local _accum_0 = { }
|
||||
local _len_0 = 1
|
||||
local _list_0 = tree.value
|
||||
for _index_0 = 1, #_list_0 do
|
||||
local a = _list_0[_index_0]
|
||||
if a.type ~= "Word" then
|
||||
_accum_0[_len_0] = to_lua(a)
|
||||
_len_0 = _len_0 + 1
|
||||
end
|
||||
end
|
||||
args = _accum_0
|
||||
end
|
||||
table.insert(args, 1, utils.repr(name, true))
|
||||
add(self.__class:comma_separated_items("compiler:call(", args, ")"))
|
||||
end
|
||||
elseif "String" == _exp_0 then
|
||||
local escapes = {
|
||||
n = "\n",
|
||||
t = "\t",
|
||||
b = "\b",
|
||||
a = "\a",
|
||||
v = "\v",
|
||||
f = "\f",
|
||||
r = "\r"
|
||||
}
|
||||
local unescaped = tree.value:gsub("\\(.)", (function(c)
|
||||
return escapes[c] or c
|
||||
end))
|
||||
add(utils.repr(unescaped, true))
|
||||
elseif "Longstring" == _exp_0 then
|
||||
local result
|
||||
do
|
||||
local _accum_0 = { }
|
||||
local _len_0 = 1
|
||||
for line in tree.value:gmatch("[ \t]*|([^\n]*)") do
|
||||
_accum_0[_len_0] = line
|
||||
_len_0 = _len_0 + 1
|
||||
end
|
||||
result = _accum_0
|
||||
end
|
||||
add(utils.repr(table.concat(result, "\n"), true))
|
||||
elseif "Number" == _exp_0 then
|
||||
add(tree.value)
|
||||
elseif "List" == _exp_0 then
|
||||
if #tree.value == 0 then
|
||||
add("{}")
|
||||
elseif #tree.value == 1 then
|
||||
add("{" .. tostring(to_lua(tree.value[1])) .. "}")
|
||||
else
|
||||
add(self.__class:comma_separated_items("{", (function()
|
||||
local _accum_0 = { }
|
||||
local _len_0 = 1
|
||||
local _list_0 = tree.value
|
||||
for _index_0 = 1, #_list_0 do
|
||||
local item = _list_0[_index_0]
|
||||
_accum_0[_len_0] = to_lua(item)
|
||||
_len_0 = _len_0 + 1
|
||||
end
|
||||
return _accum_0
|
||||
end)(), "}"))
|
||||
end
|
||||
elseif "Var" == _exp_0 then
|
||||
add("vars[" .. tostring(utils.repr(tree.value, true)) .. "]")
|
||||
else
|
||||
error("Unknown/unimplemented thingy: " .. tostring(tree.type))
|
||||
end
|
||||
buffer = table.concat(buffer, "\n")
|
||||
return buffer
|
||||
end,
|
||||
fn_name_from_tree = function(self, tree)
|
||||
assert(tree.type == "FunctionCall", "Attempt to get fn name from non-functioncall tree: " .. tostring(tree.type))
|
||||
local name_bits = { }
|
||||
local _list_0 = tree.value
|
||||
for _index_0 = 1, #_list_0 do
|
||||
local token = _list_0[_index_0]
|
||||
table.insert(name_bits, (function()
|
||||
if token.type == "Word" then
|
||||
return token.value
|
||||
else
|
||||
return "%"
|
||||
end
|
||||
end)())
|
||||
end
|
||||
return table.concat(name_bits, " ")
|
||||
end,
|
||||
run_macro = function(self, tree, kind)
|
||||
if kind == nil then
|
||||
kind = "Expression"
|
||||
end
|
||||
local name = self:fn_name_from_tree(tree)
|
||||
if not (self.defs[name] and self.defs[name].is_macro) then
|
||||
self:error("Macro not found: " .. tostring(name))
|
||||
end
|
||||
if not (self:check_permission(name)) then
|
||||
self:error("You do not have the authority to call: " .. tostring(name))
|
||||
end
|
||||
local fn, arg_names
|
||||
do
|
||||
local _obj_0 = self.defs[name]
|
||||
fn, arg_names = _obj_0.fn, _obj_0.arg_names
|
||||
end
|
||||
local args
|
||||
do
|
||||
local _accum_0 = { }
|
||||
local _len_0 = 1
|
||||
local _list_0 = tree.value
|
||||
for _index_0 = 1, #_list_0 do
|
||||
local a = _list_0[_index_0]
|
||||
if a.type ~= "Word" then
|
||||
_accum_0[_len_0] = a
|
||||
_len_0 = _len_0 + 1
|
||||
end
|
||||
end
|
||||
args = _accum_0
|
||||
end
|
||||
do
|
||||
local _tbl_0 = { }
|
||||
for i, name in ipairs(arg_names) do
|
||||
_tbl_0[name] = args[i]
|
||||
end
|
||||
args = _tbl_0
|
||||
end
|
||||
table.insert(self.callstack, name)
|
||||
local ret, manual_mode = fn(self, args, kind)
|
||||
table.remove(self.callstack)
|
||||
if not ret then
|
||||
self:error("No return value for macro: " .. tostring(name))
|
||||
end
|
||||
if kind == "Statement" and not manual_mode then
|
||||
ret = "ret = " .. ret
|
||||
end
|
||||
return ret
|
||||
end,
|
||||
_yield_tree = function(self, tree, indent_level)
|
||||
if indent_level == nil then
|
||||
indent_level = 0
|
||||
end
|
||||
local ind
|
||||
ind = function(s)
|
||||
return INDENT:rep(indent_level) .. s
|
||||
end
|
||||
local _exp_0 = tree.type
|
||||
if "File" == _exp_0 then
|
||||
coroutine.yield(ind("File:"))
|
||||
self:_yield_tree(tree.value.body, indent_level + 1)
|
||||
elseif "Errors" == _exp_0 then
|
||||
coroutine.yield(ind("Error:\n" .. tostring(tree.value)))
|
||||
elseif "Block" == _exp_0 then
|
||||
local _list_0 = tree.value
|
||||
for _index_0 = 1, #_list_0 do
|
||||
local chunk = _list_0[_index_0]
|
||||
self:_yield_tree(chunk, indent_level)
|
||||
end
|
||||
elseif "Thunk" == _exp_0 then
|
||||
coroutine.yield(ind("Thunk:"))
|
||||
self:_yield_tree(tree.value, indent_level + 1)
|
||||
elseif "Statement" == _exp_0 then
|
||||
self:_yield_tree(tree.value, indent_level)
|
||||
elseif "Expression" == _exp_0 then
|
||||
self:_yield_tree(tree.value, indent_level)
|
||||
elseif "FunctionCall" == _exp_0 then
|
||||
local name = self:fn_name_from_tree(tree)
|
||||
local args
|
||||
do
|
||||
local _accum_0 = { }
|
||||
local _len_0 = 1
|
||||
local _list_0 = tree.value
|
||||
for _index_0 = 1, #_list_0 do
|
||||
local a = _list_0[_index_0]
|
||||
if a.type ~= "Word" then
|
||||
_accum_0[_len_0] = a
|
||||
_len_0 = _len_0 + 1
|
||||
end
|
||||
end
|
||||
args = _accum_0
|
||||
end
|
||||
if #args == 0 then
|
||||
coroutine.yield(ind("Call [" .. tostring(name) .. "]!"))
|
||||
else
|
||||
coroutine.yield(ind("Call [" .. tostring(name) .. "]:"))
|
||||
for _index_0 = 1, #args do
|
||||
local a = args[_index_0]
|
||||
self:_yield_tree(a, indent_level + 1)
|
||||
end
|
||||
end
|
||||
elseif "String" == _exp_0 then
|
||||
coroutine.yield(ind(utils.repr(tree.value, true)))
|
||||
elseif "Longstring" == _exp_0 then
|
||||
coroutine.yield(ind(utils.repr(tree.value, true)))
|
||||
elseif "Number" == _exp_0 then
|
||||
coroutine.yield(ind(tree.value))
|
||||
elseif "List" == _exp_0 then
|
||||
if #tree.value == 0 then
|
||||
coroutine.yield(ind("<Empty List>"))
|
||||
else
|
||||
coroutine.yield(ind("List:"))
|
||||
local _list_0 = tree.value
|
||||
for _index_0 = 1, #_list_0 do
|
||||
local item = _list_0[_index_0]
|
||||
self:_yield_tree(item, indent_level + 1)
|
||||
end
|
||||
end
|
||||
elseif "Var" == _exp_0 then
|
||||
coroutine.yield(ind("Var[" .. tostring(utils.repr(tree.value)) .. "]"))
|
||||
else
|
||||
error("Unknown/unimplemented thingy: " .. tostring(tree.type))
|
||||
end
|
||||
return nil
|
||||
end,
|
||||
print_tree = function(self, tree)
|
||||
for line in coroutine.wrap(function()
|
||||
return self:_yield_tree(tree)
|
||||
end) do
|
||||
print(line)
|
||||
end
|
||||
end,
|
||||
stringify_tree = function(self, tree)
|
||||
local result = { }
|
||||
for line in coroutine.wrap(function()
|
||||
return self:_yield_tree(tree)
|
||||
end) do
|
||||
table.insert(result, line)
|
||||
end
|
||||
return table.concat(result, "\n")
|
||||
end,
|
||||
compile = function(self, src, output_file)
|
||||
if output_file == nil then
|
||||
output_file = nil
|
||||
end
|
||||
if self.debug then
|
||||
print("COMPILING:\n" .. tostring(src))
|
||||
end
|
||||
local tree = self:parse(src)
|
||||
assert(tree, "Tree failed to compile: " .. tostring(src))
|
||||
local code = self:tree_to_lua(tree)
|
||||
if output_file then
|
||||
local output = io.open(output_file, "w")
|
||||
output:write(code)
|
||||
end
|
||||
return code
|
||||
end,
|
||||
error = function(self, ...)
|
||||
print(...)
|
||||
print("Callstack:")
|
||||
for i = #self.callstack, 1, -1 do
|
||||
print(" " .. tostring(self.callstack[i]))
|
||||
end
|
||||
return error()
|
||||
end,
|
||||
test = function(self, src, expected)
|
||||
local i = 1
|
||||
while i ~= nil do
|
||||
local start, stop = src:find("\n\n", i)
|
||||
local test = src:sub(i, start)
|
||||
i = stop
|
||||
start, stop = test:find("===")
|
||||
if not start or not stop then
|
||||
self:error("WHERE'S THE ===? in:\n" .. tostring(test))
|
||||
end
|
||||
local test_src
|
||||
test_src, expected = test:sub(1, start - 1), test:sub(stop + 1, -1)
|
||||
expected = expected:match('[\n]*(.*[^\n])')
|
||||
local tree = self:parse(test_src)
|
||||
local got = self:stringify_tree(tree.value.body)
|
||||
if got ~= expected then
|
||||
self:error("TEST FAILED!\nSource:\n" .. tostring(test_src) .. "\nExpected:\n" .. tostring(expected) .. "\n\nGot:\n" .. tostring(got))
|
||||
end
|
||||
end
|
||||
end,
|
||||
initialize_core = function(self)
|
||||
local as_lua_code
|
||||
as_lua_code = function(self, str)
|
||||
local _exp_0 = str.type
|
||||
if "String" == _exp_0 then
|
||||
local escapes = {
|
||||
n = "\n",
|
||||
t = "\t",
|
||||
b = "\b",
|
||||
a = "\a",
|
||||
v = "\v",
|
||||
f = "\f",
|
||||
r = "\r"
|
||||
}
|
||||
local unescaped = str.value:gsub("\\(.)", (function(c)
|
||||
return escapes[c] or c
|
||||
end))
|
||||
return unescaped
|
||||
elseif "Longstring" == _exp_0 then
|
||||
local result
|
||||
do
|
||||
local _accum_0 = { }
|
||||
local _len_0 = 1
|
||||
for line in str.value:gmatch("[ \t]*|([^\n]*)") do
|
||||
_accum_0[_len_0] = line
|
||||
_len_0 = _len_0 + 1
|
||||
end
|
||||
result = _accum_0
|
||||
end
|
||||
return table.concat(result, "\n")
|
||||
else
|
||||
return self:tree_to_lua(str)
|
||||
end
|
||||
end
|
||||
self:defmacro([[lua block %lua_code]], function(self, vars, kind)
|
||||
if kind == "Expression" then
|
||||
error("Expected to be in statement.")
|
||||
end
|
||||
local lua_code = vars.lua_code.value
|
||||
local _exp_0 = lua_code.type
|
||||
if "List" == _exp_0 then
|
||||
return table.concat((function()
|
||||
local _accum_0 = { }
|
||||
local _len_0 = 1
|
||||
local _list_0 = lua_code.value
|
||||
for _index_0 = 1, #_list_0 do
|
||||
local i = _list_0[_index_0]
|
||||
_accum_0[_len_0] = as_lua_code(self, i.value)
|
||||
_len_0 = _len_0 + 1
|
||||
end
|
||||
return _accum_0
|
||||
end)()), true
|
||||
else
|
||||
return as_lua_code(self, lua_code), true
|
||||
end
|
||||
end)
|
||||
self:defmacro([[lua expr %lua_code]], function(self, vars, kind)
|
||||
local lua_code = vars.lua_code.value
|
||||
local _exp_0 = lua_code.type
|
||||
if "List" == _exp_0 then
|
||||
return table.concat((function()
|
||||
local _accum_0 = { }
|
||||
local _len_0 = 1
|
||||
local _list_0 = lua_code.value
|
||||
for _index_0 = 1, #_list_0 do
|
||||
local i = _list_0[_index_0]
|
||||
_accum_0[_len_0] = as_lua_code(self, i.value)
|
||||
_len_0 = _len_0 + 1
|
||||
end
|
||||
return _accum_0
|
||||
end)())
|
||||
else
|
||||
return as_lua_code(self, lua_code)
|
||||
end
|
||||
end)
|
||||
self:def("rule %spec %body", function(self, vars)
|
||||
return self:def(vars.spec, vars.body)
|
||||
end)
|
||||
self:defmacro([[macro %spec %body]], function(self, vars, kind)
|
||||
if kind == "Expression" then
|
||||
error("Macro definitions cannot be used as expressions.")
|
||||
end
|
||||
self:defmacro(self:tree_to_value(vars.spec), self:tree_to_value(vars.body))
|
||||
return "", true
|
||||
end)
|
||||
self:defmacro([[macro block %spec %body]], function(self, vars, kind)
|
||||
if kind == "Expression" then
|
||||
error("Macro definitions cannot be used as expressions.")
|
||||
end
|
||||
local invocation = self:tree_to_value(vars.spec)
|
||||
local fn = self:tree_to_value(vars.body)
|
||||
self:defmacro(invocation, (function(self, vars, kind)
|
||||
if kind == "Expression" then
|
||||
error("Macro: " .. tostring(invocation) .. " was defined to be a block, not an expression.")
|
||||
end
|
||||
return fn(self, vars, kind), true
|
||||
end))
|
||||
return "", true
|
||||
end)
|
||||
return self:def("run file %filename", function(self, vars)
|
||||
local file = io.open(vars.filename)
|
||||
return self:run(file:read('*a'))
|
||||
end)
|
||||
end
|
||||
}
|
||||
_base_0.__index = _base_0
|
||||
_class_0 = setmetatable({
|
||||
__init = function(self, parent)
|
||||
self.defs = setmetatable({ }, {
|
||||
__index = parent and parent.defs
|
||||
})
|
||||
self.callstack = { }
|
||||
self.debug = false
|
||||
return self:initialize_core()
|
||||
end,
|
||||
__base = _base_0,
|
||||
__name = "Compiler"
|
||||
}, {
|
||||
__index = _base_0,
|
||||
__call = function(cls, ...)
|
||||
local _self_0 = setmetatable({}, _base_0)
|
||||
cls.__init(_self_0, ...)
|
||||
return _self_0
|
||||
end
|
||||
})
|
||||
_base_0.__class = _class_0
|
||||
local self = _class_0
|
||||
self.comma_separated_items = function(self, open, items, close)
|
||||
return utils.accumulate("\n", function()
|
||||
local buffer = open
|
||||
local so_far = 0
|
||||
for i, item in ipairs(items) do
|
||||
if i < #items then
|
||||
item = item .. ", "
|
||||
end
|
||||
if so_far + #item >= 80 and #buffer > 0 then
|
||||
coroutine.yield(buffer)
|
||||
so_far = so_far - #buffer
|
||||
buffer = item
|
||||
else
|
||||
so_far = so_far + #item
|
||||
buffer = buffer .. item
|
||||
end
|
||||
end
|
||||
buffer = buffer .. close
|
||||
return coroutine.yield(buffer)
|
||||
end)
|
||||
end
|
||||
Compiler = _class_0
|
||||
end
|
||||
if arg[1] then
|
||||
local c = Compiler()
|
||||
local input = io.open(arg[1]):read("*a")
|
||||
local _print = print
|
||||
local _io_write = io.write
|
||||
if arg[2] == "-" then
|
||||
local nop
|
||||
nop = function() end
|
||||
print, io.write = nop, nop
|
||||
end
|
||||
local code = c:run(input)
|
||||
if arg[2] then
|
||||
local output
|
||||
if arg[2] == "-" then
|
||||
print, io.write = _print, _io_write
|
||||
output = io.output()
|
||||
else
|
||||
output = io.open(arg[2], 'w')
|
||||
end
|
||||
output:write([[ local load = function()
|
||||
]])
|
||||
output:write(code)
|
||||
output:write([[
|
||||
end
|
||||
local utils = require('utils')
|
||||
local Compiler = require('nomic')
|
||||
local c = Compiler(require('core'))
|
||||
load()(c, {})
|
||||
]])
|
||||
end
|
||||
end
|
||||
return Compiler
|
||||
304
utils.lua
Normal file
304
utils.lua
Normal file
@ -0,0 +1,304 @@
|
||||
local utils
|
||||
utils = {
|
||||
is_list = function(t)
|
||||
local i = 1
|
||||
for _ in pairs(t) do
|
||||
if t[i] == nil then
|
||||
return false
|
||||
end
|
||||
i = i + 1
|
||||
end
|
||||
return true
|
||||
end,
|
||||
repr = function(x, add_quotes)
|
||||
if add_quotes == nil then
|
||||
add_quotes = false
|
||||
end
|
||||
local _exp_0 = type(x)
|
||||
if 'table' == _exp_0 then
|
||||
if utils.is_list(x) then
|
||||
return "{" .. tostring(table.concat((function()
|
||||
local _accum_0 = { }
|
||||
local _len_0 = 1
|
||||
for _index_0 = 1, #x do
|
||||
local i = x[_index_0]
|
||||
_accum_0[_len_0] = utils.repr(i, true)
|
||||
_len_0 = _len_0 + 1
|
||||
end
|
||||
return _accum_0
|
||||
end)(), ", ")) .. "}"
|
||||
else
|
||||
return "{" .. tostring(table.concat((function()
|
||||
local _accum_0 = { }
|
||||
local _len_0 = 1
|
||||
for k, v in pairs(x) do
|
||||
_accum_0[_len_0] = "[" .. tostring(utils.repr(k, true)) .. "]= " .. tostring(utils.repr(v, true))
|
||||
_len_0 = _len_0 + 1
|
||||
end
|
||||
return _accum_0
|
||||
end)(), ", ")) .. "}"
|
||||
end
|
||||
elseif 'string' == _exp_0 then
|
||||
if not add_quotes then
|
||||
return x
|
||||
elseif not x:find([["]]) and not x:find("\n") then
|
||||
return "\"" .. x .. "\""
|
||||
elseif not x:find([[']]) and not x:find("\n") then
|
||||
return "\'" .. x .. "\'"
|
||||
else
|
||||
for i = 0, math.huge do
|
||||
local eq = ("="):rep(i)
|
||||
if not x:find("%[" .. tostring(eq) .. "%[") and not x:find("%]" .. tostring(eq) .. "%]") then
|
||||
if x:sub(1, 1) == "\n" then
|
||||
return "[" .. tostring(eq) .. "[\n" .. x .. "]" .. tostring(eq) .. "]"
|
||||
else
|
||||
return "[" .. tostring(eq) .. "[" .. x .. "]" .. tostring(eq) .. "]"
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
else
|
||||
return tostring(x)
|
||||
end
|
||||
end,
|
||||
split = function(str, sep)
|
||||
if sep == nil then
|
||||
sep = "%s"
|
||||
end
|
||||
local _accum_0 = { }
|
||||
local _len_0 = 1
|
||||
for chunk in str:gmatch("[^" .. tostring(sep) .. "]+") do
|
||||
_accum_0[_len_0] = chunk
|
||||
_len_0 = _len_0 + 1
|
||||
end
|
||||
return _accum_0
|
||||
end,
|
||||
accumulate = function(glue, co)
|
||||
if co == nil then
|
||||
glue, co = "", glue
|
||||
end
|
||||
local bits = { }
|
||||
for bit in coroutine.wrap(co) do
|
||||
table.insert(bits, bit)
|
||||
end
|
||||
return table.concat(bits, glue)
|
||||
end,
|
||||
range = function(start, stop, step)
|
||||
if stop == nil then
|
||||
start, stop, step = 1, start, 1
|
||||
elseif step == nil then
|
||||
step = 1
|
||||
end
|
||||
return setmetatable({
|
||||
start = start,
|
||||
stop = stop,
|
||||
step = step
|
||||
}, {
|
||||
__ipairs = function(self)
|
||||
local iter
|
||||
iter = function(self, i)
|
||||
if i <= (self.stop - self.start) / self.step then
|
||||
return i + 1, self.start + i * self.step
|
||||
end
|
||||
end
|
||||
return iter, self, 0
|
||||
end
|
||||
})
|
||||
end,
|
||||
keys = function(t)
|
||||
local _accum_0 = { }
|
||||
local _len_0 = 1
|
||||
for k in pairs(t) do
|
||||
_accum_0[_len_0] = k
|
||||
_len_0 = _len_0 + 1
|
||||
end
|
||||
return _accum_0
|
||||
end,
|
||||
values = function(t)
|
||||
local _accum_0 = { }
|
||||
local _len_0 = 1
|
||||
for _, v in pairs(t) do
|
||||
_accum_0[_len_0] = v
|
||||
_len_0 = _len_0 + 1
|
||||
end
|
||||
return _accum_0
|
||||
end,
|
||||
set = function(list)
|
||||
local _tbl_0 = { }
|
||||
for _index_0 = 1, #list do
|
||||
local i = list[_index_0]
|
||||
_tbl_0[i] = true
|
||||
end
|
||||
return _tbl_0
|
||||
end,
|
||||
sum = function(t)
|
||||
do
|
||||
local tot = 0
|
||||
for _, x in pairs(t) do
|
||||
tot = tot + x
|
||||
end
|
||||
return tot
|
||||
end
|
||||
end,
|
||||
product = function(t)
|
||||
do
|
||||
local prod = 1
|
||||
for _, x in pairs(t) do
|
||||
prod = prod * x
|
||||
end
|
||||
return prod
|
||||
end
|
||||
end,
|
||||
all = function(t)
|
||||
for _, x in pairs(t) do
|
||||
if not x then
|
||||
return false
|
||||
end
|
||||
end
|
||||
return true
|
||||
end,
|
||||
any = function(t)
|
||||
for _, x in pairs(t) do
|
||||
if x then
|
||||
return true
|
||||
end
|
||||
end
|
||||
return false
|
||||
end,
|
||||
min = function(list, keyFn)
|
||||
if keyFn == nil then
|
||||
keyFn = (function(x)
|
||||
return x
|
||||
end)
|
||||
end
|
||||
assert(utils.is_list(list), "min() expects to be operating on a list")
|
||||
do
|
||||
local best = list[1]
|
||||
if type(keyFn) == 'table' then
|
||||
local keyTable = keyFn
|
||||
keyFn = function(k)
|
||||
return keyTable[k]
|
||||
end
|
||||
end
|
||||
for i = 2, #list do
|
||||
if keyFn(list[i]) < keyFn(best) then
|
||||
best = list[i]
|
||||
end
|
||||
end
|
||||
return best
|
||||
end
|
||||
end,
|
||||
max = function(list, keyFn)
|
||||
if keyFn == nil then
|
||||
keyFn = (function(x)
|
||||
return x
|
||||
end)
|
||||
end
|
||||
assert(utils.is_list(list), "min() expects to be operating on a list")
|
||||
do
|
||||
local best = list[1]
|
||||
if type(keyFn) == 'table' then
|
||||
local keyTable = keyFn
|
||||
keyFn = function(k)
|
||||
return keyTable[k]
|
||||
end
|
||||
end
|
||||
for i = 2, #list do
|
||||
if keyFn(list[i]) > keyFn(best) then
|
||||
best = list[i]
|
||||
end
|
||||
end
|
||||
return best
|
||||
end
|
||||
end,
|
||||
sort = function(list, keyFn, reverse)
|
||||
if keyFn == nil then
|
||||
keyFn = (function(x)
|
||||
return x
|
||||
end)
|
||||
end
|
||||
if reverse == nil then
|
||||
reverse = false
|
||||
end
|
||||
assert(utils.is_list(list), "min() expects to be operating on a list")
|
||||
if type(keyFn) == 'table' then
|
||||
local keyTable = keyFn
|
||||
keyFn = function(k)
|
||||
return keyTable[k]
|
||||
end
|
||||
end
|
||||
local comparison
|
||||
if reverse then
|
||||
comparison = (function(x, y)
|
||||
return (keyFn(x) > keyFn(y))
|
||||
end)
|
||||
else
|
||||
comparison = (function(x, y)
|
||||
return (keyFn(x) < keyFn(y))
|
||||
end)
|
||||
end
|
||||
return table.sort(list, comparison)
|
||||
end,
|
||||
equivalent = function(x, y)
|
||||
if x == y then
|
||||
return true
|
||||
end
|
||||
if type(x) ~= type(y) then
|
||||
return false
|
||||
end
|
||||
if type(x) ~= 'table' then
|
||||
return false
|
||||
end
|
||||
for k, v in pairs(x) do
|
||||
if y[k] ~= v then
|
||||
return false
|
||||
end
|
||||
end
|
||||
for k, v in pairs(y) do
|
||||
if x[k] ~= v then
|
||||
return false
|
||||
end
|
||||
end
|
||||
return true
|
||||
end,
|
||||
key_for = function(t, value)
|
||||
for k, v in pairs(t) do
|
||||
if v == value then
|
||||
return k
|
||||
end
|
||||
end
|
||||
return nil
|
||||
end,
|
||||
clamp = function(x, min, max)
|
||||
if x < min then
|
||||
return min
|
||||
elseif x > max then
|
||||
return max
|
||||
else
|
||||
return x
|
||||
end
|
||||
end,
|
||||
mix = function(min, max, amount)
|
||||
return (1 - amount) * min + amount * max
|
||||
end,
|
||||
sign = function(x)
|
||||
if x == 0 then
|
||||
return 0
|
||||
elseif x < 0 then
|
||||
return -1
|
||||
else
|
||||
return 1
|
||||
end
|
||||
end,
|
||||
round = function(x, increment)
|
||||
if increment == nil then
|
||||
increment = 1
|
||||
end
|
||||
if x >= 0 then
|
||||
return math.floor(x / increment + .5) * increment
|
||||
else
|
||||
return math.ceil(x / increment - .5) * increment
|
||||
end
|
||||
end
|
||||
}
|
||||
return utils
|
||||
Loading…
Reference in New Issue
Block a user