279 lines
12 KiB
Plaintext
279 lines
12 KiB
Plaintext
#!/usr/bin/env nomsu -V4.8.10
|
|
# This file contains the code to convert syntax trees to Lua code
|
|
use "nomnom/code_obj.nom"
|
|
use "nomnom/parser.nom"
|
|
use "nomnom/pretty_errors.nom"
|
|
|
|
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
|
|
externally (report compile error at %tree %err) means:
|
|
barf (pretty "Compile Error" error at %tree %err)
|
|
|
|
externally (report compile error at %pos %err hint %hint) means:
|
|
barf (pretty "Compile Error" error at %tree %err hint %hint)
|
|
|
|
externally (barf any errors in %t) means:
|
|
assume (%t is a "Syntax Tree")
|
|
%errs = []
|
|
for % in recursive %t:
|
|
if (%.type == "Error"): %errs::add %
|
|
for %k = %v in %:
|
|
if (%v is a "Syntax Tree"): recurse % on %v
|
|
|
|
sort %errs by % -> %.source
|
|
%errs = ((% as a pretty error) for % in %errs)
|
|
if ((size of %errs) > 0):
|
|
if ((size of %errs) > 3):
|
|
%n = ((size of %errs) - 3)
|
|
for %i in 4 to (size of %errs): %errs.%i = (nil)
|
|
%errs::add "\027[31;1m +\%n additional errors...\027[0m\n"
|
|
barf (%errs::joined with "\n\n")
|
|
|
|
externally (%tree compiled with %compile_actions) means:
|
|
assume (%tree is a "Syntax Tree")
|
|
if all of [..]
|
|
%tree.version, ((Nomsu version)'s meaning) != (nil), %tree.version != (Nomsu version)
|
|
((1 upgraded from 2 to 3)'s meaning) != (nil)
|
|
..then:
|
|
%tree = (upgrade %tree from %tree.version to (Nomsu version))
|
|
|
|
if %tree.type is:
|
|
"Action":
|
|
%stub = %tree.stub
|
|
%compile_action = %compile_actions.%stub
|
|
|
|
# Don't apply compiler actions to methods
|
|
if (%compile_action and (not %tree.target)):
|
|
# TODO: restore this:
|
|
#%args = [%tree, %compile_actions]
|
|
%args = [%nomsu, %tree]
|
|
for % in (%tree::arguments): %args::add %
|
|
%result = (call %compile_action with %args)
|
|
if (%result == (nil)):
|
|
report compile error at %tree "\
|
|
..The compile-time action here (\(%tree.stub)) failed to return any value."
|
|
..hint "\
|
|
..Look at the implementation of (\(%tree.stub)) and make sure it's returning something."
|
|
|
|
if (%result is a "Syntax Tree"):
|
|
if (%result == %tree):
|
|
report compile error at %tree "\
|
|
..The compile-time action here (\(%tree.stub)) is producing an endless loop."
|
|
..hint "\
|
|
..Look at the implementation of (\(%tree.stub)) and make sure it's not just returning the original tree."
|
|
|
|
return (%result compiled with %compile_actions)
|
|
|
|
return %result
|
|
|
|
%lua = (a Lua Buffer with {source:%tree})
|
|
if %tree.target:
|
|
# Method call
|
|
%target_lua = (%tree.target compiled with %compile_actions)
|
|
if (..)
|
|
((%target_lua::text)::matches "^%(.*%)$") or (..)
|
|
(%target_lua::text)::matches "^[_a-zA-Z][_a-zA-Z0-9]*$"
|
|
..:
|
|
%lua::add [%target_lua, ":"]
|
|
..else:
|
|
%lua::add ["(", %target_lua, "):"]
|
|
|
|
%lua::add [%stub as lua id, "("]
|
|
%args = []
|
|
for %tok in %tree at %i:
|
|
if (%tok is text): do next %tok
|
|
|
|
# TODO: maybe don't translate Lua comments
|
|
#if (%tok.type == "Comment"): do next %tok
|
|
if (%tok.type == "Block"):
|
|
%values = []
|
|
for %line in %tok:
|
|
#unless (%line.type == "Comment"):
|
|
%values::add (%line compiled with %compile_actions)
|
|
|
|
if all of (%.is_value for % in %values):
|
|
if ((size of %values) == 1):
|
|
%arg_lua = %values.1
|
|
..else:
|
|
%arg_lua = (a Lua Buffer with {source:%tok, is_value:yes, bits:["("]})
|
|
%arg_lua::add %values joined with " and nil or "
|
|
%arg_lua::add ")"
|
|
..else:
|
|
%arg_lua = (a Lua Buffer with {source:%tok, is_value:yes, bits:["((function()"]})
|
|
for %v in %values at %i:
|
|
if %v.is_value:
|
|
%v = (%v::as statements with ("return " if (%i == (size of %values) else "")))
|
|
%arg_lua::add ["\n ", %v]
|
|
|
|
%arg_lua::add "\nend)())"
|
|
..else:
|
|
%arg_lua = (%tok compiled with %compile_actions)
|
|
unless %arg_lua.is_value:
|
|
if (%tok.type == "Action"):
|
|
report compile error at %tok "\
|
|
..Can't use this as an argument to (\%stub), since it's not an expression, it produces: \%arg_lua"
|
|
..hint "\
|
|
..Check the implementation of (\(%tok.stub)) to see if it is actually meant to produce an expression."
|
|
..else:
|
|
report compile error at %tok "\
|
|
..Can't use this as an argument to (\%stub), since it's not an expression, it produces: \%arg_lua"
|
|
|
|
assume (%arg_lua != %lua) or barf "Huh? \%tree .\%i = \%tok -> \%arg_lua"
|
|
%args::add %arg_lua
|
|
|
|
%lua::add %args joined with ", "
|
|
%lua::add ")"
|
|
return %lua
|
|
|
|
"EscapedNomsu":
|
|
%lua = (a Lua Buffer with {source:%tree, is_value:yes, bits:["a_Syntax_Tree_with{type=", quote %tree.(1).type]})
|
|
set {%needs_comma:no, %i:1}
|
|
(% as shmua) means:
|
|
if (% is a "Lua number"): return "\%"
|
|
if (% is a "Syntax Tree"):
|
|
return (% compiled with %compile_actions)
|
|
if (% is text): return (quote %)
|
|
return (%::as lua)
|
|
|
|
for %k = %v in (((%tree.(1).type == "EscapedNomsu") and %tree) or %tree.1):
|
|
%lua::add ", "
|
|
if:
|
|
(%k == %i): %i += 1
|
|
((%k is text) and (%k::is a lua identifier)):
|
|
%lua::add [%k, "= "]
|
|
else:
|
|
%lua::add ["[", % as shmua, "]= "]
|
|
|
|
if (%k == "source"):
|
|
%lua::add (quote "\%v")
|
|
..else:
|
|
%lua::add (%v as shmua)
|
|
|
|
%lua::add "}"
|
|
return %lua
|
|
|
|
"Block":
|
|
%lua = (a Lua Buffer with {source:%tree})
|
|
%lua::add (..)
|
|
((%line compiled with %compile_actions)::as statements) for %line in %tree
|
|
..joined with "\n"
|
|
|
|
return %lua
|
|
|
|
"Text":
|
|
%lua = (a Lua Buffer with {source:%tree})
|
|
%lua_bits = []
|
|
%string_buffer = ""
|
|
for % in %tree:
|
|
if (% is text):
|
|
%string_buffer = "\%string_buffer\%"
|
|
do next %
|
|
|
|
if (%string_buffer != ""):
|
|
%lua_bits::add (%string_buffer::as lua)
|
|
%string_buffer = ""
|
|
|
|
%bit_lua = (% compiled with %compile_actions)
|
|
unless %bit_lua.is_value:
|
|
report compile error at % "\
|
|
..Can't use this as a string interpolation value, since it doesn't have a value."
|
|
|
|
if (%.type != "Text"):
|
|
%bit_lua = (a Lua Buffer with {source:%, is_value:yes, bits:["tostring(", %bit_lua, ")"]})
|
|
%lua_bits::add %bit_lua
|
|
|
|
if ((%string_buffer != "") or ((size of %lua_bits) == 0)):
|
|
%lua_bits::add (%string_buffer::as lua)
|
|
%lua::add %lua_bits joined with ".."
|
|
if ((size of %lua_bits) > 1): %lua::parenthesize
|
|
return %lua
|
|
|
|
"List":
|
|
%lua = (a Lua Buffer with {source:%tree, is_value:yes, bits:["List{"]})
|
|
%lua::add ((% compiled with %compile_actions) for % in %tree) joined with ", " or ",\n "
|
|
%lua::add "}"
|
|
return %lua
|
|
|
|
"Dict":
|
|
%lua = (a Lua Buffer with {source:%tree, is_value:yes, bits:["Dict{"]})
|
|
%lua::add ((% compiled with %compile_actions) for % in %tree) joined with ", " or ",\n "
|
|
%lua::add "}"
|
|
return %lua
|
|
|
|
"DictEntry":
|
|
set {%key:%tree.1, %value:%tree.2}
|
|
%key_lua = (%key compiled with %compile_actions)
|
|
unless %key_lua.is_value:
|
|
report compile error at %tree.1 "\
|
|
..Can't use this as a dict key, since it's not an expression."
|
|
|
|
%value_lua = (..)
|
|
(%value compiled with %compile_actions) if %value else (..)
|
|
a Lua Buffer with {source:%key, is_value:yes, bits:["true"]}
|
|
|
|
unless %value_lua.is_value:
|
|
report compile error at %tree.2 "\
|
|
..Can't use this as a dict value, since it's not an expression."
|
|
|
|
%key_str = ((%key_lua::text)::matching "^[\"']([a-zA-Z_][a-zA-Z0-9_]*)['\"]$")
|
|
if:
|
|
%key_str:
|
|
return (a Lua Buffer with {source:%tree, bits:[%key_str, "=", %value_lua]})
|
|
((%key_lua::text).1 == "["):
|
|
# NOTE: this *must* use a space after the [ to avoid freaking out
|
|
Lua's parser if the inner expression is a long string. Lua
|
|
parses x[[[y]]] as x("[y]"), not as x["y"]
|
|
return (a Lua Buffer with {source:%tree, bits:["[ ", %key_lua, "]=", %value_lua]})
|
|
|
|
else:
|
|
return (a Lua Buffer with {source:%tree, bits:["[", %key_lua, "]=", %value_lua]})
|
|
|
|
"IndexChain":
|
|
%lua = (%tree.1 compiled with %compile_actions)
|
|
unless %lua.is_value:
|
|
report compile error at %tree.1 "\
|
|
..Can't index into this, since it's not an expression."
|
|
|
|
%first_char = (%lua::text).1
|
|
if (any of [%first_char == "{", %first_char == "\"", %first_char == "["]):
|
|
%lua::parenthesize
|
|
for %i in 2 to (size of %tree):
|
|
%key = %tree.%i
|
|
%key_lua = (%key compiled with %compile_actions)
|
|
unless %key_lua.is_value:
|
|
report compile error at %key "\
|
|
..Can't use this as an index, since it's not an expression."
|
|
|
|
%key_lua_str = (%key_lua::text)
|
|
%lua_id = (%key_lua_str::matching "^['\"]([a-zA-Z_][a-zA-Z0-9_]*)['\"]$")
|
|
if:
|
|
%lua_id:
|
|
%lua::add [".", %lua_id]
|
|
(%key_lua_str.1 == "["):
|
|
# NOTE: this *must* use a space after the [ to avoid freaking out
|
|
Lua's parser if the inner expression is a long string. Lua
|
|
parses x[[[y]]] as x("[y]"), not as x["y"]
|
|
%lua::add ["[ ", %key_lua, " ]"]
|
|
|
|
else:
|
|
%lua::add ["[", %key_lua, "]"]
|
|
|
|
return %lua
|
|
|
|
"Number":
|
|
return (a Lua Buffer with {source:%tree, is_value:yes, bits:["\(%tree.1)"]})
|
|
"Var":
|
|
return (a Lua Buffer with {source:%tree, is_value:yes, is_variable:yes, bits:[%tree.1::as lua id]})
|
|
"FileChunks":
|
|
barf "\
|
|
..Can't convert FileChunks to a single block of lua, since each chunk's compilation depends on the earlier chunks"
|
|
|
|
"Comment":
|
|
# TODO: de-implement?
|
|
return (a Lua Buffer with {source:%tree, bits:["-- \(%tree.1::with "\n" -> "\n-- ")"]})
|
|
|
|
"Error":
|
|
barf (%tree as a pretty error)
|
|
else:
|
|
barf "Unknown type: \(%tree.type)"
|