291 lines
9.5 KiB
Plaintext
Executable File
291 lines
9.5 KiB
Plaintext
Executable File
#!/usr/bin/env moon
|
|
Nomic = require 'nomic'
|
|
utils = require 'utils'
|
|
|
|
|
|
class PermissionNomic extends Nomic
|
|
new: (...)=>
|
|
super(...)
|
|
@callstack = {}
|
|
|
|
call: (fn_name,...)=>
|
|
fn_info = @defs[fn_name]
|
|
if fn_info == nil
|
|
error "Attempt to call undefined function: #{fn_name}"
|
|
unless self\check_permission(fn_name)
|
|
error "You do not have the authority to call: #{fn_name}"
|
|
table.insert @callstack, fn_name
|
|
{:fn, :arg_names} = fn_info
|
|
args = {name, select(i,...) for i,name in ipairs(arg_names)}
|
|
if @debug
|
|
print "Calling #{fn_name} with args: #{utils.repr(args)}"
|
|
ret = fn(self, args)
|
|
table.remove @callstack
|
|
return ret
|
|
|
|
check_permission: (fn_name)=>
|
|
fn_info = @defs[fn_name]
|
|
if fn_info == nil
|
|
error "Undefined function: #{fn_name}"
|
|
if fn_info.whitelist == nil then return true
|
|
for caller in *@callstack
|
|
if fn_info.whitelist[caller]
|
|
return true
|
|
return false
|
|
|
|
|
|
g = PermissionNomic()
|
|
|
|
g\defmacro [[lua %lua_code]], (vars, kind)=>
|
|
lua_code = vars.lua_code.value
|
|
as_lua_code = (str)->
|
|
switch str.type
|
|
when "String"
|
|
escapes = n:"\n", t:"\t", b:"\b", a:"\a", v:"\v", f:"\f", r:"\r"
|
|
unescaped = str.value\gsub("\\(.)", ((c)-> escapes[c] or c))
|
|
return unescaped
|
|
|
|
when "Longstring"
|
|
-- TODO: handle comments?
|
|
result = [line for line in str.value\gmatch("[ \t]*|([^\n]*)")]
|
|
return table.concat(result, "\n")
|
|
else
|
|
return @tree_to_lua(str)
|
|
|
|
switch lua_code.type
|
|
when "List"
|
|
-- TODO: handle subexpressions
|
|
return table.concat([as_lua_code(i.value) for i in *lua_code.value]), true
|
|
else
|
|
return as_lua_code(lua_code), true
|
|
|
|
g\def {"restrict %fn to %whitelist"}, (vars)=>
|
|
fns = if type(vars.fn) == 'string' then {vars.fn} else vars.fn
|
|
whitelist = if type(vars.whitelist) == 'string' then {vars.whitelist} else vars.whitelist
|
|
whitelist = {w,true for w in *whitelist}
|
|
for fn in *fns
|
|
fn_info = @defs[fn]
|
|
if fn_info == nil
|
|
print "Undefined function: #{fn}"
|
|
continue
|
|
unless self\check_permission(fn)
|
|
print "You do not have permission to restrict function: #{fn}"
|
|
continue
|
|
@defs[fn] = whitelist
|
|
|
|
g\def {"allow %whitelist to %fn"}, (vars)=>
|
|
fns = if type(vars.fn) == 'string' then {vars.fn} else vars.fn
|
|
whitelist = if type(vars.whitelist) == 'string' then {vars.whitelist} else vars.whitelist
|
|
for fn in *fns
|
|
fn_info = @defs[fn]
|
|
if fn_info == nil
|
|
print "Undefined function: #{fn}"
|
|
continue
|
|
if fn_info.whitelist == nil
|
|
print "Function is already allowed by everyone: #{fn}"
|
|
continue
|
|
unless self\check_permission(fn)
|
|
print "You do not have permission to grant permissions for function: #{fn}"
|
|
continue
|
|
for w in *whitelist do fn_info.whitelist[w] = true
|
|
|
|
g\def {"forbid %blacklist to %fn"}, (vars)=>
|
|
fns = if type(vars.fn) == 'string' then {vars.fn} else vars.fn
|
|
blacklist = if type(vars.blacklist) == 'string' then {vars.blacklist} else vars.blacklist
|
|
for fn in *fns
|
|
fn_info = @defs[fn]
|
|
if fn_info == nil
|
|
print "Undefined function: #{fn}"
|
|
continue
|
|
if fn_info.whitelist == nil
|
|
print "Cannot remove items from a whitelist when there is no whitelist on function: #{fn}"
|
|
continue
|
|
unless self\check_permission(fn)
|
|
print "You do not have permission to restrict function: #{fn}"
|
|
continue
|
|
for b in *blacklist do fn_info.whitelist[b] = nil
|
|
|
|
|
|
g\def {"say %x", "print %x"}, (vars)=>
|
|
print(utils.repr(vars.x))
|
|
|
|
g\def [[printf %str]], (args)=>
|
|
for s in *args.str do io.write(utils.repr(s))
|
|
io.write("\n")
|
|
|
|
g\def [[concat %strs]], (vars)=>
|
|
return table.concat([utils.repr(s) for s in *vars.strs], "")
|
|
|
|
g\def [[quote %str]], (vars)=>
|
|
return utils.repr(vars.str, true)
|
|
|
|
g\defmacro "return %retval", (vars, kind)=>
|
|
if kind == "Expression"
|
|
error("Cannot use a return statement as an expression")
|
|
return "do return "..((@tree_to_lua(vars.retval))\match("%s*(.*)")).." end", true
|
|
|
|
g\defmacro "let %varname = %value", (vars, kind)=>
|
|
if kind == "Expression"
|
|
error("Cannot set a variable in an expression.")
|
|
return "vars[#{@tree_to_lua(vars.varname)}] = #{@tree_to_lua(vars.value)}", true
|
|
|
|
singleton = (aliases, value)->
|
|
g\defmacro aliases, ((vars)=> value)
|
|
|
|
infix = (ops)->
|
|
for op in *ops
|
|
alias = op
|
|
if type(op) == 'table'
|
|
{alias,op} = op
|
|
g\defmacro "%x #{alias} %y", (vars)=>
|
|
return "(#{@tree_to_lua(vars.x)} #{op} #{@tree_to_lua(vars.y)})"
|
|
|
|
unary = (ops)->
|
|
for op in *ops
|
|
g\defmacro "#{op} %x", (vars)=>
|
|
return "#{op}(#{@tree_to_lua(vars.x)})"
|
|
|
|
singleton {"true","yes"}, "true"
|
|
singleton {"false","no"}, "false"
|
|
singleton {"nil","null","nop","pass"}, "nil"
|
|
infix{"+","-","*","/","==",{"!=","~="},"<","<=",">",">=","^","and","or",{"mod","%"}}
|
|
unary{"-","#","not"}
|
|
g\def [[%x == %y]], (args)=> utils.equivalent(args.x, args.y)
|
|
|
|
g\def "rule %spec %body", (vars)=>
|
|
self\def vars.spec, vars.body
|
|
|
|
-- TODO: write help
|
|
|
|
|
|
g\def [[random]], -> math.random()
|
|
|
|
g\def [[sum %items]], (args)=> utils.sum(args.items)
|
|
g\def [[all %items]], (args)=> utils.all(args.items)
|
|
g\def [[any %items]], (args)=> utils.any(args.items)
|
|
g\def {[[average %items]], [[avg %items]]}, (args)=> utils.sum(items)/#items
|
|
g\def {[[min %items]], [[smallest %items]], [[lowest %items]], [[fewest %items]]}, (args)=>
|
|
utils.min(args.items)
|
|
|
|
g\def {[[max %items]], [[largest %items]], [[highest %items]], [[most %items]]}, (args)=>
|
|
utils.max(args.items)
|
|
|
|
g\def {[[argmin %items]]}, (args)=>
|
|
utils.min(args.items, ((i)->i[2]))
|
|
g\def {[[argmax %items]]}, (args)=>
|
|
utils.max(args.items, ((i)->i[2]))
|
|
|
|
g\def {[[min %items with respect to %keys]]}, (args)=>
|
|
utils.min(args.items, args.keys)
|
|
g\def {[[max %items with respect to %keys]]}, (args)=>
|
|
utils.max(args.items, args.keys)
|
|
|
|
g\def {[[%index st in %list]], [[%index nd in %list]], [[%index rd in %list]], [[%index th in %list]]}, (args)=>
|
|
with args
|
|
if type(.list) != 'table'
|
|
print "Not a list: #{.list}"
|
|
return
|
|
.list[.index]
|
|
|
|
g\def {[[index of %item in %list]]}, (args)=>
|
|
with args
|
|
if type(.list) != 'table'
|
|
print "Not a list: #{.list}"
|
|
return
|
|
utils.key_for(args.list, args.item)
|
|
|
|
g\run [=[
|
|
rule ["%item is in %list", "%list contains %item"]: (index of %item in %list) != (nil)
|
|
]=]
|
|
|
|
g\def {[[# %list]], [[length of %list]], [[size of %list]]}, (args)=>
|
|
with args
|
|
if type(.list) != 'table'
|
|
print "Not a list: #{.list}"
|
|
return
|
|
return #(.list)
|
|
|
|
g\defmacro "if %condition %if_body else %else_body", (vars, kind)=>
|
|
if kind == "Expression"
|
|
return ([[(function(game, vars)
|
|
if (%s) then
|
|
%s
|
|
else
|
|
%s
|
|
end
|
|
end)(game, vars)]])\format(@tree_to_lua(vars.condition),
|
|
@tree_to_lua(vars.if_body.value.value),
|
|
@tree_to_lua(vars.else_body.value.value))
|
|
else
|
|
return ([[
|
|
if (%s) then
|
|
%s
|
|
else
|
|
%s
|
|
end
|
|
]])\format(@tree_to_lua(vars.condition),
|
|
@tree_to_lua(vars.if_body.value.value),
|
|
@tree_to_lua(vars.else_body.value.value)), true
|
|
|
|
g\defmacro "for %varname in %iterable %body", (vars, kind)=>
|
|
if kind == "Expression"
|
|
return "
|
|
(function(game, vars)
|
|
local comprehension, old_loopval = {}, vars[#{@tree_to_lua(vars.varname)}]
|
|
for i, value in ipairs(#{@tree_to_lua(vars.iterable)}) do
|
|
local ret
|
|
vars[#{@tree_to_lua(vars.varname)}] = value
|
|
#{@tree_to_lua(vars.body.value.value)}
|
|
table.insert(comprehension, ret)
|
|
end
|
|
vars[#{@tree_to_lua(vars.varname)}] = old_loopval
|
|
return comprehension
|
|
end)(game, vars)"
|
|
else
|
|
return "
|
|
do
|
|
local comprehension, old_loopval = {}, vars[#{@tree_to_lua(vars.varname)}]
|
|
for i, value in ipairs(#{@tree_to_lua(vars.iterable)}) do
|
|
vars[#{@tree_to_lua(vars.varname)}] = value
|
|
#{@tree_to_lua(vars.body.value.value)}
|
|
end
|
|
vars[#{@tree_to_lua(vars.varname)}] = old_loopval
|
|
end", true
|
|
|
|
g\simplemacro "for %varname = %start to %stop %body", [[for %varname in (lua ["utils.range(",%start,",",%stop,")"]) %body]]
|
|
|
|
g\simplemacro "if %condition %body", [[
|
|
if %condition %body
|
|
..else: nil
|
|
]]
|
|
|
|
g\simplemacro "unless %condition %body", [[
|
|
if (not %condition) %body
|
|
..else: nil
|
|
]]
|
|
|
|
g\def [[do %action]], (vars)=> return vars.action(self,vars)
|
|
|
|
|
|
g\defmacro [[macro %spec %body]], (vars, kind)=>
|
|
if kind == "Expression" then error("Cannot use a macro definition in an expression.")
|
|
self\simplemacro vars.spec.value.value, vars.body.src
|
|
return "", true
|
|
|
|
g\defmacro [[test %code yields %tree]], (vars, kind)=>
|
|
if kind == "Expression" then error("Tests must be statements.")
|
|
got = self\stringify_tree(vars.code.value)
|
|
got = got\match("Thunk:\n (.*)")\gsub("\n ","\n")
|
|
got = utils.repr(got,true)
|
|
expected = @tree_to_lua(vars.tree)
|
|
return "
|
|
do
|
|
local got = #{got}
|
|
local expected = #{expected}
|
|
if got ~= expected then
|
|
error('Test failed. Expected:\\n'..expected..'\\n\\nBut got:\\n'..got)
|
|
end
|
|
end", true
|
|
|
|
return g
|