aboutsummaryrefslogtreecommitdiff
path: root/nomsu.moon
diff options
context:
space:
mode:
Diffstat (limited to 'nomsu.moon')
-rwxr-xr-xnomsu.moon567
1 files changed, 567 insertions, 0 deletions
diff --git a/nomsu.moon b/nomsu.moon
new file mode 100755
index 0000000..243dd64
--- /dev/null
+++ b/nomsu.moon
@@ -0,0 +1,567 @@
+#!/usr/bin/env moon
+re = require 're'
+lpeg = require 'lpeg'
+utils = require 'utils'
+
+-- TODO:
+-- string interpolation
+-- comprehensions?
+-- dicts?
+-- better scoping?
+-- first-class functions
+
+INDENT = " "
+lpeg.setmaxstack 10000 -- whoa
+{:P,:V,:S,:Cg,:C,:Cp,:B,:Cmt} = lpeg
+
+wordchar = P(1)-S(' \t\n\r%:;,.{}[]()"')
+comment = re.compile [[comment <- "(#" (comment / ((! "#)") .))* "#)"]]
+whitespace = (S(" \t") + comment)^1
+nl = P("\n")
+blank_line = whitespace^-1 * nl
+
+get_line_indentation = (line)->
+ indent_amounts = {[" "]:1, ["\t"]:4}
+ with sum = 0
+ leading_space = line\gsub("([\t ]*).*", "%1")
+ for c in leading_space\gmatch "[\t ]"
+ sum += indent_amounts[c]
+
+make_parser = (lingo, extra_definitions)->
+ indent_stack = {0}
+ push = (n)-> table.insert indent_stack, n
+ pop = ()-> table.remove indent_stack
+ check_indent = (subject,end_pos,spaces)->
+ num_spaces = get_line_indentation(spaces)
+ if num_spaces <= indent_stack[#indent_stack] then return nil
+ push num_spaces
+ return end_pos
+ check_dedent = (subject,end_pos,spaces)->
+ num_spaces = get_line_indentation(spaces)
+ if num_spaces >= indent_stack[#indent_stack] then return nil
+ pop!
+ return end_pos
+ check_nodent = (subject,end_pos,spaces)->
+ num_spaces = get_line_indentation(spaces)
+ if num_spaces != indent_stack[#indent_stack] then return nil
+ return end_pos
+
+ defs =
+ :wordchar, :nl, ws:whitespace, :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: (src,pos,errors)->
+ line_no = 1
+ for _ in src\sub(1,-#errors)\gmatch("\n") do line_no += 1
+ err_pos = #src - #errors + 1
+ if errors\sub(1,1) == "\n"
+ -- Indentation error
+ err_pos += #errors\match("[ \t]*", 2)
+ start_of_err_line = err_pos
+ while src\sub(start_of_err_line, start_of_err_line) != "\n" do start_of_err_line -= 1
+ 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 -= 1
+
+ prev_line,err_line,next_line = src\match("([^\n]*)\n([^\n]*)\n([^\n]*)", start_of_prev_line+1)
+
+ pointer = ("-")\rep(err_pos - start_of_err_line + 0) .. "^"
+ error("\nParse error on line #{line_no}:\n\n#{prev_line}\n#{err_line}\n#{pointer}\n#{next_line}\n")
+
+ if extra_definitions
+ for k,v in pairs(extra_definitions) do defs[k] = v
+
+ setmetatable(defs, {
+ __index: (t,key)->
+ fn = (src, value, errors)->
+ token = {type: key, :src, :value, :errors}
+ return token
+ t[key] = fn
+ return fn
+ })
+ return re.compile lingo, defs
+
+class Compiler
+ new:(parent)=>
+ @defs = setmetatable({}, {__index:parent and parent.defs})
+ @callstack = {}
+ @debug = false
+ @initialize_core!
+
+ call: (fn_name,...)=>
+ fn_info = @defs[fn_name]
+ if fn_info == nil
+ @error "Attempt to call undefined function: #{fn_name}"
+ if fn_info.is_macro
+ @error "Attempt to call macro at runtime: #{fn_name}"
+ unless @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.whiteset == nil then return true
+ for caller in *@callstack
+ if fn_info.whiteset[caller]
+ return true
+ return false
+
+ def: (spec, fn)=>
+ if @debug
+ print "Defining rule: #{spec}"
+ invocations,arg_names = @get_invocations spec
+ fn_info = {:fn, :arg_names, :invocations, is_macro:false}
+ for invocation in *invocations
+ @defs[invocation] = fn_info
+
+ get_invocations:(text)=>
+ if type(text) == 'string' then text = {text}
+ invocations = {}
+ local arg_names
+ for _text in *text
+ invocation = _text\gsub("%%%S+","%%")
+ _arg_names = [arg for arg in _text\gmatch("%%(%S+)")]
+ table.insert(invocations, invocation)
+ if arg_names
+ if not utils.equivalent(utils.set(arg_names), utils.set(_arg_names))
+ @error("Conflicting argument names #{utils.repr(arg_names)} and #{utils.repr(_arg_names)} for #{utils.repr(text)}")
+ else arg_names = _arg_names
+ return invocations, arg_names
+
+ defmacro: (spec, lua_gen_fn)=>
+ invocations,arg_names = @get_invocations spec
+ fn_info = {fn:lua_gen_fn, :arg_names, :invocations, is_macro:true}
+ for invocation in *invocations
+ @defs[invocation] = fn_info
+
+ run: (text)=>
+ if @debug
+ print "RUNNING TEXT:\n#{text}"
+ -- This will execute each chunk as it goes along
+ code = @compile(text)
+ if @debug
+ print "\nGENERATED LUA CODE:\n#{code}"
+ return code
+
+ parse: (str)=>
+ if @debug
+ print("PARSING:\n#{str}")
+ 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
+
+ tree = lingo\match(str\gsub("\r","").."\n")
+ if @debug
+ print("\nPARSE TREE:")
+ @print_tree(tree)
+ assert tree, "Failed to parse: #{str}"
+ return tree
+
+ tree_to_value: (tree)=>
+ code = "return (function(compiler, vars)\nreturn #{@tree_to_lua(tree)}\nend)"
+ lua_thunk, err = load(code)
+ if not lua_thunk
+ error("Failed to compile generated code:\n#{code}\n\n#{err}")
+ return (lua_thunk!)(self, {})
+
+ tree_to_lua: (tree, kind="Expression")=>
+ assert tree, "No tree provided."
+ indent = ""
+ buffer = {}
+
+ to_lua = (t,kind)->
+ ret = @tree_to_lua(t,kind)
+ return ret
+
+ add = (code)-> table.insert(buffer, code)
+
+ switch tree.type
+ when "File"
+ add [[return (function(compiler, vars)
+ local ret]]
+ vars = {}
+ for statement in *tree.value.body.value
+ code = to_lua(statement)
+ -- Run the fuckers as we go
+ lua_thunk, err = load("return (function(compiler, vars)\n#{code}\nend)")
+ if not lua_thunk
+ error("Failed to compile generated code:\n#{code}\n\n#{err}")
+ ok,err = pcall(lua_thunk)
+ if not ok then error(err)
+ ok,err = pcall(err, self, vars)
+ if not ok then @error(err)
+ add code
+ add [[
+ return ret
+ end)
+ ]]
+
+ when "Block"
+ for statement in *tree.value
+ add to_lua(statement)
+
+ when "Thunk"
+ 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)
+ ]]
+
+ when "Statement"
+ -- This case here is to prevent "ret =" from getting prepended when the macro might not want it
+ if tree.value.type == "FunctionCall"
+ name = @fn_name_from_tree(tree.value)
+ if @defs[name] and @defs[name].is_macro
+ add @run_macro(tree.value, "Statement")
+ else
+ add "ret = "..(to_lua(tree.value)\match("%s*(.*)"))
+ else
+ add "ret = "..(to_lua(tree.value)\match("%s*(.*)"))
+
+ when "Expression"
+ add to_lua(tree.value)
+
+ when "FunctionCall"
+ name = @fn_name_from_tree(tree)
+ if @defs[name] and @defs[name].is_macro
+ add @run_macro(tree, "Expression")
+ else
+ args = [to_lua(a) for a in *tree.value when a.type != "Word"]
+ table.insert args, 1, utils.repr(name, true)
+ add @@comma_separated_items("compiler:call(", args, ")")
+
+ when "String"
+ escapes = n:"\n", t:"\t", b:"\b", a:"\a", v:"\v", f:"\f", r:"\r"
+ unescaped = tree.value\gsub("\\(.)", ((c)-> escapes[c] or c))
+ add utils.repr(unescaped, true)
+
+ when "Longstring"
+ -- TODO: handle comments here?
+ result = [line for line in tree.value\gmatch("[ \t]*|([^\n]*)")]
+ add utils.repr(table.concat(result, "\n"), true)
+
+ when "Number"
+ add tree.value
+
+ when "List"
+ if #tree.value == 0
+ add "{}"
+ elseif #tree.value == 1
+ add "{#{to_lua(tree.value[1])}}"
+ else
+ add @@comma_separated_items("{", [to_lua(item) for item in *tree.value], "}")
+
+ when "Var"
+ add "vars[#{utils.repr(tree.value,true)}]"
+
+ else
+ error("Unknown/unimplemented thingy: #{tree.type}")
+
+ -- TODO: make indentation clean
+ buffer = table.concat(buffer, "\n")
+ return buffer
+
+ @comma_separated_items: (open, items, close)=>
+ utils.accumulate "\n", ->
+ buffer = open
+ so_far = 0
+ for i,item in ipairs(items)
+ if i < #items then item ..= ", "
+ if so_far + #item >= 80 and #buffer > 0
+ coroutine.yield buffer
+ so_far -= #buffer
+ buffer = item
+ else
+ so_far += #item
+ buffer ..= item
+ buffer ..= close
+ coroutine.yield buffer
+
+ fn_name_from_tree: (tree)=>
+ assert(tree.type == "FunctionCall", "Attempt to get fn name from non-functioncall tree: #{tree.type}")
+ name_bits = {}
+ for token in *tree.value
+ table.insert name_bits, if token.type == "Word" then token.value else "%"
+ table.concat(name_bits, " ")
+
+ run_macro: (tree, kind="Expression")=>
+ name = @fn_name_from_tree(tree)
+ unless @defs[name] and @defs[name].is_macro
+ @error("Macro not found: #{name}")
+ unless @check_permission(name)
+ @error "You do not have the authority to call: #{name}"
+ {:fn, :arg_names} = @defs[name]
+ args = [a for a in *tree.value when a.type != "Word"]
+ args = {name,args[i] for i,name in ipairs(arg_names)}
+ table.insert @callstack, name
+ ret, manual_mode = fn(self, args, kind)
+ table.remove @callstack
+ if not ret
+ @error("No return value for macro: #{name}")
+ if kind == "Statement" and not manual_mode
+ ret = "ret = "..ret
+ return ret
+
+ _yield_tree: (tree, indent_level=0)=>
+ ind = (s) -> INDENT\rep(indent_level)..s
+ switch tree.type
+ when "File"
+ coroutine.yield(ind"File:")
+ @_yield_tree(tree.value.body, indent_level+1)
+
+ when "Errors"
+ coroutine.yield(ind"Error:\n#{tree.value}")
+
+ when "Block"
+ for chunk in *tree.value
+ @_yield_tree(chunk, indent_level)
+
+ when "Thunk"
+ coroutine.yield(ind"Thunk:")
+ @_yield_tree(tree.value, indent_level+1)
+
+ when "Statement"
+ @_yield_tree(tree.value, indent_level)
+
+ when "Expression"
+ @_yield_tree(tree.value, indent_level)
+
+ when "FunctionCall"
+ name = @fn_name_from_tree(tree)
+ args = [a for a in *tree.value when a.type != "Word"]
+ if #args == 0
+ coroutine.yield(ind"Call [#{name}]!")
+ else
+ coroutine.yield(ind"Call [#{name}]:")
+ for a in *args
+ @_yield_tree(a, indent_level+1)
+
+ when "String"
+ -- TODO: Better implement
+ coroutine.yield(ind(utils.repr(tree.value, true)))
+
+ when "Longstring"
+ -- TODO: Better implement
+ coroutine.yield(ind(utils.repr(tree.value, true)))
+
+ when "Number"
+ coroutine.yield(ind(tree.value))
+
+ when "List"
+ if #tree.value == 0
+ coroutine.yield(ind("<Empty List>"))
+ else
+ coroutine.yield(ind"List:")
+ for item in *tree.value
+ @_yield_tree(item, indent_level+1)
+
+ when "Var"
+ coroutine.yield ind"Var[#{utils.repr(tree.value)}]"
+
+ else
+ error("Unknown/unimplemented thingy: #{tree.type}")
+ return nil -- to prevent tail calls
+
+ print_tree:(tree)=>
+ for line in coroutine.wrap(-> @_yield_tree(tree))
+ print(line)
+
+ stringify_tree:(tree)=>
+ result = {}
+ for line in coroutine.wrap(-> @_yield_tree(tree))
+ table.insert(result, line)
+ return table.concat result, "\n"
+
+ compile: (src, output_file=nil)=>
+ if @debug
+ print "COMPILING:\n#{src}"
+ tree = @parse(src)
+ assert tree, "Tree failed to compile: #{src}"
+ code = @tree_to_lua(tree)
+ if output_file
+ output = io.open(output_file, "w")
+ output\write(code)
+ return code
+
+ error: (...)=>
+ print(...)
+ print("Callstack:")
+ for i=#@callstack,1,-1
+ print " #{@callstack[i]}"
+ error!
+
+ test: (src, expected)=>
+ i = 1
+ while i != nil
+ start,stop = src\find("\n\n", i)
+
+ test = src\sub(i,start)
+ i = stop
+ start,stop = test\find"==="
+ if not start or not stop then
+ @error("WHERE'S THE ===? in:\n#{test}")
+ test_src, expected = test\sub(1,start-1), test\sub(stop+1,-1)
+ expected = expected\match'[\n]*(.*[^\n])'
+ tree = @parse(test_src)
+ got = @stringify_tree(tree.value.body)
+ if got != expected
+ @error"TEST FAILED!\nSource:\n#{test_src}\nExpected:\n#{expected}\n\nGot:\n#{got}"
+
+
+ initialize_core: =>
+ -- Sets up some core functionality
+ 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)
+
+ @defmacro [[lua block %lua_code]], (vars, kind)=>
+ if kind == "Expression" then error("Expected to be in statement.")
+ lua_code = vars.lua_code.value
+ 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
+
+ @defmacro [[lua expr %lua_code]], (vars, kind)=>
+ lua_code = vars.lua_code.value
+ switch lua_code.type
+ when "List"
+ -- TODO: handle subexpressions
+ return table.concat([as_lua_code(@, i.value) for i in *lua_code.value])
+ else
+ return as_lua_code(@, lua_code)
+
+ @def "rule %spec %body", (vars)=>
+ @def vars.spec, vars.body
+
+ @defmacro [[macro %spec %body]], (vars, kind)=>
+ if kind == "Expression"
+ error("Macro definitions cannot be used as expressions.")
+ @defmacro @tree_to_value(vars.spec), @tree_to_value(vars.body)
+ return "", true
+
+ @defmacro [[macro block %spec %body]], (vars, kind)=>
+ if kind == "Expression"
+ error("Macro definitions cannot be used as expressions.")
+ invocation = @tree_to_value(vars.spec)
+ fn = @tree_to_value(vars.body)
+ @defmacro invocation, ((vars,kind)=>
+ if kind == "Expression"
+ error("Macro: #{invocation} was defined to be a block, not an expression.")
+ return fn(@,vars,kind), true)
+ return "", true
+
+ @def "run file %filename", (vars)=>
+ file = io.open(vars.filename)
+ return @run(file\read('*a'))
+
+
+-- Run on the command line via "./nomsu.moon input_file.nom" to execute
+-- and "./nomsu.moon input_file.nom output_file.lua" to compile (use "-" to compile to stdout)
+if arg[1]
+ c = Compiler()
+ input = io.open(arg[1])\read("*a")
+ -- Kinda hacky, if run via "./nomsu.moon file.nom -", then silence print and io.write
+ -- during execution and re-enable them to print out the generated source code
+ _print = print
+ _io_write = io.write
+ if arg[2] == "-"
+ export print
+ nop = ->
+ print, io.write = nop, nop
+ code = c\run(input)
+ if arg[2]
+ output = if arg[2] == "-"
+ export print
+ print, io.write = _print, _io_write
+ io.output()
+ else io.open(arg[2], 'w')
+
+ output\write [[
+ local load = function()
+ ]]
+ output\write(code)
+ output\write [[
+
+ end
+ local utils = require('utils')
+ local Compiler = require('nomsu')
+ local c = Compiler(require('core'))
+ load()(c, {})
+ ]]
+
+return Compiler
generated by cgit v1.2.3 (git 2.25.1) at 2026-03-01 14:29:12 +0000