130 lines
5.9 KiB
Plaintext
130 lines
5.9 KiB
Plaintext
require "lib/metaprogramming.nom"
|
|
|
|
# Literals
|
|
parse (true; yes) as lua expr "true"
|
|
parse (false; no) as lua expr "false"
|
|
parse (nil; null) as lua expr "nil"
|
|
parse (inf; infinity) as lua expr "math.huge"
|
|
parse (nan; NaN; not a number) as lua expr "(0/0)"
|
|
parse (nop; pass) as lua code ""
|
|
|
|
# Ternary operator
|
|
parse (%if_expr if %condition else %else_expr) as lua expr ".."
|
|
|(function(nomsu, vars)
|
|
# TODO: fix compiler bug that breaks this code if comments immediately follow ".."
|
|
#.. Note: this uses a function instead of (condition and if_expr or else_expr)
|
|
because that breaks if %if_expr is falsey.
|
|
| if \(%condition) then
|
|
| return \(%if_expr)
|
|
| else
|
|
| return \(%else_expr)
|
|
| end
|
|
|end)(nomsu, vars)
|
|
|
|
# Variable assignment operator, and += type versions
|
|
lua block ".."
|
|
|local function assign(callback)
|
|
| return function(nomsu, vars, kind)
|
|
| if kind == "Expression" then
|
|
| nomsu:error("Cannot use an assignment operation as an expression value.")
|
|
| end
|
|
| if vars.var.type ~= "Var" then
|
|
| nomsu:error("Assignment operation has the wrong type for the left hand side. "
|
|
| .."Expected Var, but got: "..vars.var.type.."\\nMaybe you forgot a percent sign on the variable name?")
|
|
| end
|
|
| if vars.rhs.type ~= "Thunk" then
|
|
| nomsu:error("Assignment operation has the wrong type for the right hand side. "
|
|
| .."Expected Thunk, but got: "..vars.rhs.type.."\\nMaybe you used '=' instead of '=:'?")
|
|
| end
|
|
| if #vars.rhs.value.value > 1 then
|
|
| nomsu:error("Assignment operation should not have more than one value on the right hand side.")
|
|
| end
|
|
| return callback(nomsu:tree_to_lua(vars.var),
|
|
| nomsu:tree_to_lua(vars.rhs.value.value[1].value)), true
|
|
| end
|
|
|end
|
|
|nomsu:defmacro("%var = %rhs", assign(function(var,result) return var.." = "..result end))
|
|
|nomsu:defmacro("%var += %rhs", assign(function(var,result) return var.." = "..var.." + "..result end))
|
|
|nomsu:defmacro("%var -= %rhs", assign(function(var,result) return var.." = "..var.." - "..result end))
|
|
|nomsu:defmacro("%var *= %rhs", assign(function(var,result) return var.." = "..var.." * "..result end))
|
|
|nomsu:defmacro("%var /= %rhs", assign(function(var,result) return var.." = "..var.." / "..result end))
|
|
|nomsu:defmacro("%var ^= %rhs", assign(function(var,result) return var.." = "..var.." ^ "..result end))
|
|
|nomsu:defmacro("%var and= %rhs", assign(function(var,result) return var.." = "..var.." and "..result end))
|
|
|nomsu:defmacro("%var or= %rhs", assign(function(var,result) return var.." = "..var.." or "..result end))
|
|
|nomsu:defmacro("%var join= %rhs", assign(function(var,result) return var.." = "..var.." .. "..result end))
|
|
|nomsu:defmacro("%var mod= %rhs", assign(function(var,result) return var.." = "..var.." % "..result end))
|
|
|
|
# Binary Operators
|
|
lua block ".."
|
|
|local binops = {"+","-","*","/","<","<=",">",">=","^",{"===","=="},{"!==","~="},"and","or",{"mod","%"}}
|
|
|for _,op in ipairs(binops) do
|
|
| local nomsu_alias = op
|
|
| if type(op) == 'table' then
|
|
| nomsu_alias, op = unpack(op)
|
|
| end
|
|
| nomsu:defmacro("%a "..nomsu_alias.." %b", (function(nomsu, vars, kind)
|
|
| return "("..nomsu:tree_to_lua(vars.a).." "..op.." "..nomsu:tree_to_lua(vars.b)..")"
|
|
| end), [["(\\(%a) ]]..op..[[ \\(%b))"]])
|
|
|end
|
|
# == and != do equivalence checking, rather than identity checking
|
|
parse (%a == %b) as lua expr "nomsu.utils.equivalent(\(%a), \(%b))"
|
|
parse (%a != %b) as lua expr "(not nomsu.utils.equivalent(\(%a), \(%b)))"
|
|
|
|
# Commutative Operators defined for up to 8 operands
|
|
# TODO: work out solution for commutative operators using more clever macros
|
|
lua block ".."
|
|
|local max_operands = 8
|
|
|local comops = {"+","*","and","or"}
|
|
|for _,_op in ipairs(comops) do
|
|
| local op = _op
|
|
| local spec = "%1 "..op.." %2"
|
|
| for n=3,max_operands do
|
|
| spec = spec .." "..op.." %"..tostring(n)
|
|
| nomsu:defmacro(spec, (function(nomsu, vars, kind)
|
|
| local bits = {}
|
|
| for i=1,n do
|
|
| table.insert(bits, (nomsu:tree_to_lua(vars[tostring(i)])))
|
|
| end
|
|
| return "("..table.concat(bits, " "..op.." ")..")"
|
|
| end))
|
|
| end
|
|
|end
|
|
|
|
# Chained compairsions (e.g. x < y <= z) are defined up to 3 operands
|
|
lua block ".."
|
|
|local max_operands = 3
|
|
|for _,chainers in ipairs({{"<","<="},{">",">="}}) do
|
|
| local function recurse(chainers, chain)
|
|
# The 1-op versions are already more efficiently defined, and a 0-op version doesnt make sense
|
|
| if #chain >= 2 then
|
|
| local spec = "%1"
|
|
| for i,op in ipairs(chain) do
|
|
| spec = spec .. " "..op.." %"..tostring(i+1)
|
|
| end
|
|
# Chained comparisons need to be functions to avoid re-evaluating their arguments :\
|
|
| nomsu:def(spec, function(nomsu, vars)
|
|
| for i,op in ipairs(chain) do
|
|
| local a, b, result = vars[i], vars[i+1]
|
|
| if op == "<" then result = a < b
|
|
| elseif op == "<=" then result = a <= b
|
|
| elseif op == ">" then result = a > b
|
|
| elseif op == ">=" then result = a >= b end
|
|
# Short circuit
|
|
| if not result then return false end
|
|
| end
|
|
| end)
|
|
| end
|
|
| if #chain + 1 >= max_operands then return end
|
|
| for _,c in ipairs(chainers) do
|
|
| table.insert(chain, c)
|
|
| recurse(chainers, chain)
|
|
| table.remove(chain)
|
|
| end
|
|
| end
|
|
| recurse(chainers, {})
|
|
|end
|
|
|
|
# Unary operators
|
|
parse (- %a) as lua expr "-(\(%a))"
|
|
parse (not %a) as lua expr "not (\(%a))"
|