Bruce/nomsu
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Updated to undo some of the block/thunk stuff. Thunks are thunks, and

Browse Source 
expressions can be grouped with parens, and they have a clear
distinction.
This commit is contained in:
Bruce Hill 2017-10-02 17:21:22 -07:00
parent e2bbbfe161
commit dcd3391b36
12 changed files with 538 additions and 613 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

78
examples/parser_tests.nom
View File

@ -3,28 +3,35 @@ require "lib/testing.nom"
test: say "foo" test: say "foo"
..yields ".." ..yields ".."
|Call [say %]: |FunctionCall:
| "foo" | Word:
| "say"
| String:
| "foo"
test: say (foo) test: say (foo)
..yields ".." ..yields ".."
|Call [say %]: |FunctionCall:
| Call [foo]! | Word:
| "say"
| FunctionCall:
| Word:
| "foo"
test: test:
rule [fart] =: say "poot" rule (fart) =: say "poot"
..yields ".." ..yields ".."
|Call [rule % = %]: |Call [rule % = %]:
| List: | List:
| Call [fart]! | Call [fart]:
| Thunk: | Block:
| Call [say %]: | Call [say %]:
| "poot" | "poot"
test: say (subexpressions work) test: say (subexpressions work)
..yields ".." ..yields ".."
|Call [say %]: |Call [say %]:
| Call [subexpressions work]! | Call [subexpressions work]:
test: say ["lists", "work"] test: say ["lists", "work"]
..yields ".." ..yields ".."
@ -33,9 +40,9 @@ test: say ["lists", "work"]
| "lists" | "lists"
| "work" | "work"
test (: say []) yields ".." test (say []) yields ".."
|Call [say %]: |Call [say %]:
| <Empty List> | List:
test: test:
say [..] say [..]
@ -69,50 +76,50 @@ test:
..yields ".." ..yields ".."
|Call [if % % else %]: |Call [if % % else %]:
| 1 | 1
| Thunk: | Block:
| Call [yes]! | Call [yes]:
| Thunk: | Block:
| Call [no]! | Call [no]:
test: test:
if 1 (: yes) else: no if 1 (yes) else: no
..yields ".." ..yields ".."
|Call [if % % else %]: |Call [if % % else %]:
| 1 | 1
| Thunk: | Block:
| Call [yes]! | Call [yes]:
| Thunk: | Block:
| Call [no]! | Call [no]:
test: say (do: return 5) test: say (do (return 5))
..yields ".." ..yields ".."
|Call [say %]: |Call [say %]:
| Call [do %]: | Call [do %]:
| Thunk: | Block:
| Call [return %]: | Call [return %]:
| 5 | 5
test: test:
say (..) say:
fn call fn call
..yields ".." ..yields ".."
|Call [say %]: |Call [say %]:
| Call [fn call]! | Call [fn call]:
test: test:
do: say "one liner" do: say "one liner"
..also: say "another one liner" ..also: say "another one liner"
..yields ".." ..yields ".."
|Call [do % also %]: |Call [do % also %]:
| Thunk: | Block:
| Call [say %]: | Call [say %]:
| "one liner" | "one liner"
| Thunk: | Block:
| Call [say %]: | Call [say %]:
| "another one liner" | "another one liner"
test: test:
say (..) say:
do: do:
say "hi" say "hi"
return 5 return 5
@ -120,7 +127,7 @@ test:
..yields ".." ..yields ".."
|Call [say %]: |Call [say %]:
| Call [do %]: | Call [do %]:
| Thunk: | Block:
| Call [say %]: | Call [say %]:
| "hi" | "hi"
| Call [return %]: | Call [return %]:
@ -150,21 +157,21 @@ test:
..yields ".." ..yields ".."
|Call [if % % else %]: |Call [if % % else %]:
| Var["x"] | Var["x"]
| Thunk: | Block:
| Call [x]! | Call [x]:
| Thunk: | Block:
| Call [if % % else %]: | Call [if % % else %]:
| Var["y"] | Var["y"]
| Thunk: | Block:
| Call [y]! | Call [y]:
| Thunk: | Block:
| Call [z]! | Call [z]:
test: test:
don't fuck this up don't fuck this up
..yields ".." ..yields ".."
|Call [don 't fuck this up]! |Call [don 't fuck this up]:
test: test:
%Brian's hat %Brian's hat
@ -173,3 +180,4 @@ test:
| Var["Brian"] | Var["Brian"]
say "All tests passed!" say "All tests passed!"

114
lib/collections.nom
View File

@ -5,122 +5,116 @@ require "lib/operators.nom"
# List/dict functions: # List/dict functions:
# Indexing # Indexing
parse: parse [..]
%index st in %list; %index nd in %list; %index rd in %list %index st in %list, %index nd in %list, %index rd in %list
%index th in %list; %index in %list %index th in %list, %index in %list
..as: %list -> %index ..as: %list -> %index
compile: compile [..]
%index st to last in %list; %index nd to last in %list; %index rd to last in %list %index st to last in %list, %index nd to last in %list, %index rd to last in %list
%index th to last in %list %index th to last in %list
..to: "nomsu.utils.nth_to_last(\(%list as lua), \(%index as lua))" ..to: "nomsu.utils.nth_to_last(\(%list as lua), \(%index as lua))"
parse (first in %list; first %list) as: 1 st in %list parse [first in %list, first %list] as: 1 st in %list
parse (last in %list; last %list) as: 1 st to last in %list parse [last in %list, last %list] as: 1 st to last in %list
# Dict iteration convenience function. This could also be accomplished with: for all (entries in %dict): ... # Dict iteration convenience function. This could also be accomplished with: for all (entries in %dict): ...
compile (for %key -> %value in %dict %body) to block: ".." compile [for %key -> %value in %dict %body] to code: ".."
|for k, v in pairs(\(%dict as lua)) do |do;
| \(%key as lua), \(%value as lua) = k, v | for k, v in pairs(\(%dict as lua)) do;
| \(%body as lua statements) | \(%key as lua), \(%value as lua) = k, v;
|end | \(%body as lua statements)
| end;
|end;
# Membership testing # Membership testing
rule (%item is in %list; %list contains %item; %list has %item) =: rule [%item is in %list, %list contains %item, %list has %item] =:
for %key -> %value in %list: for %key -> %value in %list:
if (%key == %item): return (yes) if (%key == %item): return (yes)
return (no) return (no)
rule: rule [..]
%item isn't in %list; %item is not in %list %item isn't in %list, %item is not in %list
%list doesn't contain %item; %list does not contain %item %list doesn't contain %item, %list does not contain %item
%list doesn't have %item; %list does not have %item %list doesn't have %item, %list does not have %item
..=: ..=:
for %key -> %value in %list: for %key -> %value in %list:
if (%key == %item): return (no) if (%key == %item): return (no)
return (yes) return (yes)
compile (%list has key %index; %list has index %index) to: ".." compile [%list has key %index, %list has index %index] to: ".."
|(\(%list as lua)[\(%index as lua)] ~= nil) |((\(%list as lua))[\(%index as lua)] ~= nil)
compile: compile [..]
%list doesn't have key %index; %list does not have key %index %list doesn't have key %index, %list does not have key %index
%list doesn't have index %index; %list does not have index %index %list doesn't have index %index, %list does not have index %index
..to: "(\(%list as lua)[\(%index as lua)] ~= nil)" ..to: "((\(%list as lua))[\(%index as lua)] ~= nil)"
compile (length of %list; size of %list; size %list; number of %list; len %list) to: compile [length of %list, size of %list, size %list, number of %list, len %list] to:
"nomsu.utils.size(\(%list as lua))" "nomsu.utils.size(\(%list as lua))"
# Chained lookup # Chained lookup
compile (%list ->* %indices) to: compile [%list ->* %indices] to:
assert ((%indices's "type") == "List") ".." assert ((%indices's "type") == "List") ".."
|Expected List for chained lookup, not \(%indices's "type") |Expected List for chained lookup, not \(%indices's "type")
%ret =: "\(%list as lua)" %ret = "\(%list as lua)"
for %index in (%indices's "value"): for %index in (%indices's "value"):
%ret join=: "[\(%index as lua)]" %ret join= "[\(%index as lua)]"
"\(%ret)" "\(%ret)"
# Assignment # Assignment
compile: compile [..]
%list's %index = %new_value; %index st in %list = %new_value; %index nd in %list = %new_value %list's %index = %new_value, %index st in %list = %new_value, %index nd in %list = %new_value
%index rd in %list = %new_value; %index th in %list = %new_value; %index in %list = %new_value %index rd in %list = %new_value, %index th in %list = %new_value, %index in %list = %new_value
%list -> %index = %new_value %list -> %index = %new_value
..to code: ..to code:
assert ((%new_value's "type") == "Block") ".." "(\(%list as lua))[\(%index as lua)] = \(%new_value as lua)"
|Dict assignment operation has the wrong type for the right hand side.
|Expected Block, but got \(%new_value's "type").
|Maybe you used "=" instead of "=:"?
assert ((size of (%new_value's "value")) == 1) ".."
|Dict assignment operation has the wrong number of values on the right hand side.
|Expected 1 value, but got \(repr %new_value)
%new_value =: %new_value ->* ["value",1]
"\(%list as lua)[\(%index as lua)] = \(%new_value as lua)"
compile (append %item to %list; add %item to %list) to: compile [append %item to %list, add %item to %list] to:
"table.insert(\(%list as lua), \(%item as lua))" "table.insert(\(%list as lua), \(%item as lua))"
rule (flatten %lists) =: rule [flatten %lists] =:
%flat =: [] %flat = []
for %list in %lists: for %list in %lists:
for %item in %list: for %item in %list:
add %item to %flat add %item to %flat
%flat %flat
rule (dict %items) =: rule [dict %items] =:
%dict =: [] %dict = []
for %pair in %items: for %pair in %items:
%dict -> (first in %pair) =: last in %pair %dict -> (%pair -> 1) = (%pair -> 2)
%dict %dict
rule (entries in %dict) =: rule [entries in %dict] =:
%entries =: [] %entries = []
for %k -> %v in %dict: for %k -> %v in %dict:
add (dict [["key",%k],["value",%v]]) to %entries add (dict [["key",%k],["value",%v]]) to %entries
%entries %entries
rule (keys in %dict) =: rule [keys in %dict] =:
%keys =: [] %keys = []
for %k -> %v in %dict: add %k to %keys for %k -> %v in %dict: add %k to %keys
%keys %keys
rule (values in %dict) =: rule [values in %dict] =:
%values =: [] %values = []
for %k -> %v in %dict: add %v to %values for %k -> %v in %dict: add %v to %values
%values %values
# List Comprehension # List Comprehension
compile (%expression for %var in %iterable) to: compile [%expression for %var in %iterable] to:
assert ((%var's "type") == "Var") ".." assert ((%var's "type") == "Var") ".."
|List comprehension has the wrong type for the loop variable. Expected Var, but got: \(%var's "type") |List comprehension has the wrong type for the loop variable. Expected Var, but got: \(%var's "type")
".." ".."
|(function(game, vars) |(function(game, vars);
| local comprehension = {} | local comprehension = {};
| for i,value in ipairs(\(%iterable as lua)) do | for i,value in ipairs(\(%iterable as lua)) do;
| \(%var as lua) = value | \(%var as lua) = value;
| comprehension[i] = \(%expression as lua) | comprehension[i] = \(%expression as lua);
| end | end;
| return comprehension | return comprehension;
|end)(game, setmetatable({}, {__index=vars})) |end)(game, setmetatable({}, {__index=vars}))
parse (%expression for all %iterable) as: %expression for % in %iterable parse [%expression for all %iterable] as: %expression for % in %iterable
# TODO: maybe make a generator/coroutine? # TODO: maybe make a generator/coroutine?

186
lib/control_flow.nom
View File

@ -3,168 +3,174 @@ require "lib/operators.nom"
require "lib/utils.nom" require "lib/utils.nom"
# Conditionals # Conditionals
compile (if %condition %if_body) to code: ".." compile [if %condition %if_body] to code: ".."
|if \(%condition as lua) then |if \(%condition as lua) then;
| \(%if_body as lua statements) | \(%if_body as lua statements)
|end |end;
compile (if %condition %if_body else %else_body) to code: ".." compile [if %condition %if_body else %else_body] to code: ".."
|if \(%condition as lua) then |if \(%condition as lua) then;
| \(%if_body as lua statements) | \(%if_body as lua statements)
|else |else;
| \(%else_body as lua statements) | \(%else_body as lua statements)
|end |end;
# Return # Return
compile (return) to code: "do return end" compile [return] to code: "do; return; end;"
compile (return %return-value) to code: "do return \(%return-value as lua) end" compile [return %return-value] to code: "do; return \(%return-value as lua); end;"
# GOTOs # GOTOs
compile (-> %label) to code: ".." compile [-> %label] to code: ".."
|::label_\(nomsu "var_to_lua_identifier" [%label]):: |::label_\(nomsu "var_to_lua_identifier" [%label])::;
compile (go to %label) to code: ".." compile [go to %label] to code: ".."
|goto label_\(nomsu "var_to_lua_identifier" [%label]) |goto label_\(nomsu "var_to_lua_identifier" [%label]);
# Loop control flow # Loop control flow
compile (stop; stop loop; break) to code: "break" compile [stop, stop loop, break] to code: "break"
compile (stop for; stop for-loop; break for) to code: "goto break_for" compile [stop for, stop for-loop, break for] to code: "goto break_for"
compile (stop repeat; stop repeat-loop; break repeat) to code: "goto break_repeat" compile [stop repeat, stop repeat-loop, break repeat] to code: "goto break_repeat"
compile (stop %var; break %var) to code: ".." compile [stop %var, break %var] to code: ".."
|goto break_\(nomsu "var_to_lua_identifier" [%var]) |goto break_\(nomsu "var_to_lua_identifier" [%var]);
compile (continue; continue loop) to code: "continue" compile [continue, continue loop] to code: "continue"
compile (continue for; continue for-loop) to code: "goto continue_for" compile [continue for, continue for-loop] to code: "goto continue_for"
compile (continue repeat; continue repeat-loop) to code: "goto continue_repeat" compile [continue repeat, continue repeat-loop] to code: "goto continue_repeat"
compile (continue %var; go to next %var; on to the next %var) to code: ".." compile [continue %var, go to next %var, on to the next %var] to code: ".."
|goto continue_\(nomsu "var_to_lua_identifier" [%var]) |goto continue_\(nomsu "var_to_lua_identifier" [%var]);
# While loops # While loops
compile (repeat while %condition %body) to block: ".." compile [repeat while %condition %body] to code: ".."
|while \(%condition as lua) do |do;
| \(%body as lua statements) | while \(%condition as lua) do;
| ::continue_repeat:: | \(%body as lua statements)
|end | ::continue_repeat::;
|::break_repeat:: | end;
parse (repeat %body) as: repeat while (true) %body | ::break_repeat::;
parse (repeat until %condition %body) as: repeat while (not %condition) %body |end;
parse [repeat %body] as: repeat while (true) %body
parse [repeat until %condition %body] as: repeat while (not %condition) %body
# Numeric range for loops # Numeric range for loops
compile: compile [..]
for %var from %start to %stop by %step %body for %var from %start to %stop by %step %body
for %var from %start to %stop via %step %body for %var from %start to %stop via %step %body
..to block: ".." ..to code: ".."
|for i=\(%start as lua),\(%stop as lua),\(%step as lua) do |do;
| for i=\(%start as lua),\(%stop as lua),\(%step as lua) do;
# This trashes the loop variables, just like in Python. # This trashes the loop variables, just like in Python.
| \(%var as lua) = i | \(%var as lua) = i;
| \(%body as lua statements) | \(%body as lua statements)
| ::continue_for:: | ::continue_for::;
| ::continue_\(nomsu "var_to_lua_identifier" [%var]):: | ::continue_\(nomsu "var_to_lua_identifier" [%var])::;
|end | end;
|::break_for:: | ::break_for::;
|::break_\(nomsu "var_to_lua_identifier" [%var]):: | ::break_\(nomsu "var_to_lua_identifier" [%var])::;
parse (for %var from %start to %stop %body) as: for %var from %start to %stop via 1 %body |end;
parse: parse [for %var from %start to %stop %body] as: for %var from %start to %stop via 1 %body
parse [..]
for all %start to %stop by %step %body for all %start to %stop by %step %body
for all %start to %stop via %step %body for all %start to %stop via %step %body
..as: for % from %start to %stop via %step %body ..as: for % from %start to %stop via %step %body
parse (for all %start to %stop %body) as: for all %start to %stop via 1 %body parse [for all %start to %stop %body] as: for all %start to %stop via 1 %body
compile (for %var in %iterable %body) to block: compile [for %var in %iterable %body] to code:
".." ".."
|for i,value in ipairs(\(%iterable as lua)) do |do;
| for i,value in ipairs(\(%iterable as lua)) do;
# This trashes the loop variables, just like in Python. # This trashes the loop variables, just like in Python.
| \(%var as lua) = value | \(%var as lua) = value;
| \(%body as lua statements) | \(%body as lua statements)
| ::continue_for:: | ::continue_for::;
| ::continue_\(nomsu "var_to_lua_identifier" [%var]):: | ::continue_\(nomsu "var_to_lua_identifier" [%var])::;
|end | end;
|::break_for:: | ::break_for::;
|::break_\(nomsu "var_to_lua_identifier" [%var]):: | ::break_\(nomsu "var_to_lua_identifier" [%var])::;
parse (for all %iterable %body) as: for % in %iterable %body |end;
parse [for all %iterable %body] as: for % in %iterable %body
# Switch statement/multi-branch if # Switch statement/multi-branch if
compile (when %body) to block: compile [when %body] to code:
%result =: "" %result = "do;\n"
%fallthroughs =: [] %fallthroughs = []
for %func-call in (%body's "value"): for %func-call in (%body's "value"):
assert ((%func-call's "type") == "FunctionCall") ".." assert ((%func-call's "type") == "FunctionCall") ".."
|Invalid format for 'when' statement. Only '*' blocks are allowed. |Invalid format for 'when' statement. Only '*' blocks are allowed.
%tokens =: %func-call's "value" %tokens = (%func-call's "value")
%star =: %tokens -> 1 %star = (%tokens -> 1)
assert (lua expr "vars.star and vars.star.type == 'Word' and vars.star.value == '*'") ".." assert (lua expr "vars.star and vars.star.type == 'Word' and vars.star.value == '*'") ".."
|Invalid format for 'when' statement. Lines must begin with '*' |Invalid format for 'when' statement. Lines must begin with '*'
%condition =: %tokens -> 2 %condition = (%tokens -> 2)
assert %condition ".." assert %condition ".."
|Invalid format for 'when' statement. Lines must begin with '*' and have a condition or the word "else" |Invalid format for 'when' statement. Lines must begin with '*' and have a condition or the word "else"
%action =: %tokens -> 3 %action = (%tokens -> 3)
if (%action == (nil)): if (%action == (nil)):
lua block "table.insert(vars.fallthroughs, vars.condition)" lua block "table.insert(vars.fallthroughs, vars.condition)"
go to next %func-call go to next %func-call
if (lua expr "vars.condition.type == 'Word' and vars.condition.value == 'else'"): if (lua expr "vars.condition.type == 'Word' and vars.condition.value == 'else'"):
%result join=: ".." %result join= ".."
| |
|do |do;
..else: ..else:
%condition =: %condition as lua %condition = (%condition as lua)
for all %fallthroughs: for all %fallthroughs:
%condition join=: " or \(% as lua)" %condition join= " or \(% as lua)"
%result join=: ".." %result join= ".."
| |
|if \(%condition) then |if \(%condition) then;
%result join=: ".." %result join= ".."
| |
| \(%action as lua statements) | \(%action as lua statements)
| goto finished_when | goto finished_when;
|end |end;
%fallthroughs =: [] %fallthroughs = []
%result join=: "\n::finished_when::" %result join= "\n::finished_when::;\nend;"
%result %result
# Switch statement # Switch statement
compile (when %branch-value == ? %body) to block: compile [when %branch-value == ? %body] to code:
%result =: "local branch_value = \(%branch-value as lua)" %result = "do;\nlocal branch_value = \(%branch-value as lua)"
%fallthroughs =: [] %fallthroughs = []
for %func-call in (%body's "value"): for %func-call in (%body's "value"):
assert ((%func-call's "type") == "FunctionCall") ".." assert ((%func-call's "type") == "FunctionCall") ".."
|Invalid format for 'when' statement. Only '*' blocks are allowed. |Invalid format for 'when' statement. Only '*' blocks are allowed.
%tokens =: %func-call's "value" %tokens = (%func-call's "value")
%star =: %tokens -> 1 %star = (%tokens -> 1)
assert (lua expr "vars.star and vars.star.type == 'Word' and vars.star.value == '*'") ".." assert (lua expr "vars.star and vars.star.type == 'Word' and vars.star.value == '*'") ".."
|Invalid format for 'when' statement. Lines must begin with '*' |Invalid format for 'when' statement. Lines must begin with '*'
%condition =: %tokens -> 2 %condition = (%tokens -> 2)
assert %condition ".." assert %condition ".."
|Invalid format for 'when' statement. Lines must begin with '*' and have a condition or the word "else" |Invalid format for 'when' statement. Lines must begin with '*' and have a condition or the word "else"
%action =: %tokens -> 3 %action = (%tokens -> 3)
if (%action == (nil)): if (%action == (nil)):
lua block "table.insert(vars.fallthroughs, vars.condition)" lua block "table.insert(vars.fallthroughs, vars.condition)"
go to next %func-call go to next %func-call
if (lua expr "vars.condition.type == 'Word' and vars.condition.value == 'else'"): if (lua expr "vars.condition.type == 'Word' and vars.condition.value == 'else'"):
%result join=: ".." %result join= ".."
| |
|do |do;
..else: ..else:
%condition =: "branch_value == (\(%condition as lua))" %condition = "branch_value == (\(%condition as lua))"
for all %fallthroughs: for all %fallthroughs:
%condition join=: " or (branch_value == \(% as lua))" %condition join= " or (branch_value == \(% as lua))"
%result join=: ".." %result join= ".."
| |
|if \(%condition) then |if \(%condition) then;
%result join=: ".." %result join= ".."
| |
| \(%action as lua statements) | \(%action as lua statements)
| goto finished_when | goto finished_when;
|end |end;
%fallthroughs =: [] %fallthroughs = []
%result join=: "\n::finished_when::" %result join= "\n::finished_when::;\nend;"
%result %result

170
lib/metaprogramming.nom
View File

@ -4,127 +4,105 @@
# Rule to make rules: # Rule to make rules:
lua code ".." lua code ".."
|nomsu:defmacro("rule %rule_def = %body", function(nomsu, vars) |nomsu:defmacro("rule %signature = %body", (function(nomsu, vars)
| local aliases = nomsu:typecheck(vars, "rule_def", "Block").value | local signature = nomsu:typecheck(vars, "signature", "List").value;
| local canonical = aliases[1] | local body = nomsu:typecheck(vars, "body", "Thunk");
| local body = nomsu:typecheck(vars, "body", "Block") | return ([[
| local thunk = nomsu:tree_to_lua({type="Thunk", value={type="Statements", value=body.value, src=body.src}, src=body.src})
| local lua = ([[
|nomsu:def(%s, %s, %s) |nomsu:def(%s, %s, %s)
|]]):format(nomsu:repr(canonical.src), thunk, nomsu:repr(body.src)) |]]):format(nomsu:repr(signature), nomsu:tree_to_lua(body), nomsu:repr(body.src)), nil;
| if #aliases > 1 then |end), "<source can be found in lib/metaprogramming.nom>");
| lua = lua .. "\n" .. ([[
|do
| local aliased = %s
| local src = %s
| local function dealiaser(nomsu, vars)
| return nomsu:tree_to_lua(nomsu:replaced_vars(aliased, vars))
| end
|]]):format(nomsu:repr(canonical), nomsu:repr(canonical.src))
| for i=2,#aliases do
| lua = lua .. ([[
| nomsu:defmacro(%s, dealiaser, %s)
|]]):format(nomsu:repr(aliases[i].src), nomsu:repr(canonical.src))
| end
| lua = lua .. [[
|end]]
| end
| return nil, lua
|end, "<source can be found in lib/metaprogramming.nom>")
# Rule to make nomsu macros: # Rule to make nomsu macros:
rule (escaped parse %shorthand as %longhand) =: rule [escaped parse %shorthand as %longhand] =:
lua code ".." lua code ".."
|local aliases = nomsu:typecheck(vars, "shorthand", "Block").value |local aliases = nomsu:typecheck(vars, "shorthand", "List").value;
|local template = nomsu:typecheck(vars, "longhand", "Block") |if #vars.longhand.value ~= 1 then;
| nomsu:error("Expected only 1 line to parse to, but got "..tostring(#vars.longhand.value));
|end;
|local template = nomsu:typecheck(vars, "longhand", "Thunk").value[1];
|local function parsing_as(nomsu, vars) |local function parsing_as(nomsu, vars)
| local replacement = nomsu:replaced_vars(template, vars) | local replacement = nomsu:replaced_vars(template, vars);
| return nomsu:tree_to_lua(replacement) | return nomsu:tree_to_lua(replacement);
|end |end;
|for _,call in ipairs(aliases) do |nomsu:defmacro(aliases, parsing_as, template.src);
| nomsu:defmacro(call, parsing_as, template.src) escaped parse \[parse %shorthand as %longhand] as \: escaped parse \%shorthand as \%longhand
|end
escaped parse \(parse %shorthand as %longhand) as \: escaped parse \%shorthand as \%longhand
# Rule to make lua macros: # Rule to make lua macros:
rule (escaped compile %macro_def to %body) =: rule [escaped compile %macro_def to %body] =:
lua code ".." lua code ".."
|local aliases = nomsu:typecheck(vars, "macro_def", "Block").value |local aliases = nomsu:typecheck(vars, "macro_def", "List").value;
|local body = nomsu:typecheck(vars, "body", "Block") |local body = nomsu:typecheck(vars, "body", "Thunk");
|local thunk = nomsu:tree_to_value({type="Thunk", value={type="Statements", value=body.value, src=body.src}, src=body.src}) |local thunk = nomsu:tree_to_value(body);
|for _,alias in ipairs(aliases) do |nomsu:defmacro(aliases, thunk, body.src);
| nomsu:defmacro(alias, thunk, body.src) rule [escaped compile %macro_def to code %body] =:
|end
rule (escaped compile %macro_def to code %body) =:
lua code ".." lua code ".."
|local aliases = nomsu:typecheck(vars, "macro_def", "Block").value |local aliases = nomsu:typecheck(vars, "macro_def", "List").value;
|local body = nomsu:typecheck(vars, "body", "Block") |local body = nomsu:typecheck(vars, "body", "Thunk");
|local thunk = nomsu:tree_to_value({type="Thunk", value={type="Statements", value=body.value, src=body.src}, src=body.src}) |local thunk = nomsu:tree_to_value(body);
|local thunk2 = function(nomsu, vars) return nil, thunk(nomsu, vars) end |local thunk_wrapper = function(nomsu, vars) return nil, thunk(nomsu, vars); end;
|for _,alias in ipairs(aliases) do |nomsu:defmacro(aliases, thunk_wrapper, body.src);
| nomsu:defmacro(alias, thunk2) parse [compile %macro_def to %body] as: escaped compile \%macro_def to \%body
|end parse [compile %macro_def to code %body] as: escaped compile \%macro_def to code \%body
parse (compile %macro_def to %body) as: escaped compile \%macro_def to \%body
parse (compile %macro_def to code %body) as: escaped compile \%macro_def to code \%body
parse (compile %macro_def to block %body) as: escaped compile \%macro_def to code\: ".."
|do
| \(%body)
|end
rule (do %) =: % rule [do %] =: %
rule (%tree as lua) =: rule [%tree as lua] =:
lua expr "nomsu:tree_to_lua(\(%tree))" lua expr "nomsu:tree_to_lua(\(%tree))"
rule (%tree as value) =: rule [%tree as value] =:
lua expr "nomsu:tree_to_value(\(%tree), vars)" lua expr "nomsu:tree_to_value(\(%tree), vars)"
compile (repr %obj) to: compile [repr %obj] to:
"nomsu:repr(\(%obj as lua))" "nomsu:repr(\(%obj as lua))"
parse (lua block %block) as: lua code ".." parse [lua block %block] as: lua code ".."
|do |do;
| \(%block) | \(%block)
|end |end;
rule (%tree as lua statement) =: rule [%tree as lua statement] =:
lua block ".." lua block ".."
|local _,statement = nomsu:tree_to_lua(\(%tree)) |local _,statement = nomsu:tree_to_lua(\(%tree));
|return statement |return statement;
rule (%tree as lua statements) =: rule [%tree as lua statements] =:
lua block ".." lua block ".."
|local statements_tree = {type='Statements', value=\(%tree).value, src=\(%tree).src} |local lua_bits = {};
|local _,statements = nomsu:tree_to_lua(statements_tree) |local statements = nomsu:typecheck(vars, "tree", "Thunk").value;
|return statements |for _,bit in ipairs(statements) do;
| local expr, statement = nomsu:tree_to_lua(bit);
| if statement then; table.insert(lua_bits, statement); end;
| if expr then; table.insert(lua_bits, "ret = "..expr..";"); end;
|end;
|return table.concat(lua_bits, "\\n");
compile (nomsu) to: "nomsu" compile [nomsu] to: "nomsu"
compile (nomsu's %key) to: "nomsu[\(%key as lua)]" compile [nomsu's %key] to: "nomsu[\(%key as lua)]"
compile (nomsu %method %args) to: "nomsu[\(%method as lua)](nomsu, unpack(\(%args as lua)))" compile [nomsu %method %args] to: "nomsu[\(%method as lua)](nomsu, unpack(\(%args as lua)))"
# Get the source code for a function # Get the source code for a function
rule (help %rule) =: rule [help %rule] =:
lua block ".." lua block ".."
|local fn_def = nomsu:get_fn_def(vars.rule) |local fn_def = nomsu:get_fn_def(vars.rule);
|if not fn_def then |if not fn_def then;
| nomsu:writeln("Rule not found: "..nomsu:repr(vars.rule)) | nomsu:writeln("Rule not found: "..nomsu:repr(vars.rule));
|else |else;
| nomsu:writeln("rule "..nomsu:repr(nomsu.utils.keys(fn_def.invocation)) | nomsu:writeln("rule "..nomsu:repr(nomsu.utils.keys(fn_def.stub))
| .." ="..(fn_def.src or ":\\n <unknown source code>")) | .." ="..(fn_def.src or ":\\n <unknown source code>"));
|end |end;
# Compiler tools # Compiler tools
parse (eval %code; run %code) as: nomsu "run" [%code] parse [eval %code, run %code] as: nomsu "run" [%code]
rule (source code from tree %tree) =: rule [source code from tree %tree] =:
lua block ".." lua block ".."
|local _,_,leading_space = vars.tree.src:find("\\n(%s*)%S") |local _,_,leading_space = vars.tree.src:find("\\n(%s*)%S");
|if leading_space then |if leading_space then;
| local chunk1, chunk2 = vars.tree.src:match(":%s*([^\\n]*)(\\n.*)") | local chunk1, chunk2 = vars.tree.src:match(":%s*([^\\n]*)(\\n.*)");
| chunk2 = chunk2:gsub("\\n"..leading_space, "\\n") | chunk2 = chunk2:gsub("\\n"..leading_space, "\\n");
| return chunk1..chunk2.."\\n" | return chunk1..chunk2.."\\n";
|else |else;
| return vars.tree.src:match(":%s*(%S.*)").."\\n" | return vars.tree.src:match(":%s*(%S.*)").."\\n";
|end |end;
parse (source code %body) as: source code from tree \%body parse [source code %body] as: source code from tree \%body
parse (parse tree %code) as: nomsu "tree_to_str" [\%code] parse [parse tree %code] as: nomsu "tree_to_str" [\%code]
parse (enable debugging) as: lua code "nomsu.debug = true" parse [enable debugging] as: lua code "nomsu.debug = true"
parse (disable debugging) as: lua code "nomsu.debug = false" parse [disable debugging] as: lua code "nomsu.debug = false"

48
lib/moonscript.nom
View File

@ -1,30 +1,30 @@
require "lib/metaprogramming.nom" require "lib/metaprogramming.nom"
# Moonscript! # Moonscript!
macro block [moonscript block %moonscript_code] =: parse [moonscript block %moonscript_code] as:
lua block ".." lua block ".."
|local parse, compile = require('moonscript.parse'), require('moonscript.compile') |local parse, compile = require('moonscript.parse'), require('moonscript.compile');
|local moon_code = nomsu:tree_to_value(vars.moonscript_code, vars) |local moon_code = nomsu:tree_to_value(vars.moonscript_code, vars);
|local tree, err = parse.string(moon_code) |local tree, err = parse.string(moon_code);
|if not tree then |if not tree then;
| nomsu:error("Failed to parse moonscript: "..err) | nomsu:error("Failed to parse moonscript: "..err);
|end |end;
|local lua_code, err, pos = compile.tree(tree) |local lua_code, err, pos = compile.tree(tree);
|if not lua_code then |if not lua_code then;
| nomsu:error(compile.format_error(err, pos, moon_code)) | nomsu:error(compile.format_error(err, pos, moon_code));
|end |end;
|return "do\\n"..lua_code.."\\nend" |return "do\\n"..lua_code.."\\nend";
macro [moonscript %moonscript_code] =: parse [moonscript %moonscript_code] as:
lua block ".." lua block ".."
|local parse, compile = require('moonscript.parse'), require('moonscript.compile') |local parse, compile = require('moonscript.parse'), require('moonscript.compile');
|local moon_code = nomsu:tree_to_value(vars.moonscript_code, vars) |local moon_code = nomsu:tree_to_value(vars.moonscript_code, vars);
|local tree, err = parse.string(moon_code) |local tree, err = parse.string(moon_code);
|if not tree then |if not tree then;
| nomsu:error("Failed to parse moonscript: "..err) | nomsu:error("Failed to parse moonscript: "..err);
|end |end;
|local lua_code, err, pos = compile.tree(tree) |local lua_code, err, pos = compile.tree(tree);
|if not lua_code then |if not lua_code then;
| nomsu:error(compile.format_error(err, pos, moon_code)) | nomsu:error(compile.format_error(err, pos, moon_code));
|end |end;
|return "(function(nomsu, vars)\\n"..lua_code.."\\nend)(nomsu, vars)" |return "(function(nomsu, vars)\\n"..lua_code.."\\nend)(nomsu, vars)";

176
lib/operators.nom
View File

@ -1,124 +1,122 @@
require "lib/metaprogramming.nom" require "lib/metaprogramming.nom"
# Literals # Literals
compile (true; yes) to: "true" compile [true, yes] to: "true"
compile (false; no) to: "false" compile [false, no] to: "false"
compile (nil; null) to: "nil" compile [nil, null] to: "nil"
compile (inf; infinity) to: "math.huge" compile [inf, infinity] to: "math.huge"
compile (nan; NaN; not a number) to: "(0/0)" compile [nan, NaN, not a number] to: "(0/0)"
compile (pi; PI) to: "math.pi" compile [pi, PI] to: "math.pi"
compile (tau; TAU) to: "(2*math.pi)" compile [tau, TAU] to: "(2*math.pi)"
compile (phi; PHI; golden ratio) to: "((1+math.sqrt(5))/2)" compile [phi, PHI, golden ratio] to: "((1+math.sqrt(5))/2)"
compile (nop; pass) to code: "" compile [nop, pass] to code: ""
# Ternary operator # Ternary operator
compile (%if_expr if %condition else %else_expr) to: ".." compile [%if_expr if %condition else %else_expr] to: ".."
|(function(nomsu, vars) |(function(nomsu, vars)
# TODO: fix compiler bug that breaks this code if comments immediately follow ".." # 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) #.. Note: this uses a function instead of (condition and if_expr or else_expr)
because that breaks if %if_expr is falsey. because that breaks if %if_expr is falsey.
| if \(%condition) then | if \(%condition) then;
| return \(%if_expr) | return \(%if_expr);
| else | else;
| return \(%else_expr) | return \(%else_expr);
| end | end;
|end)(nomsu, vars) |end)(nomsu, vars)
# Indexing: # Indexing:
compile (%obj's %key; %obj -> %key) to: "\(%obj as lua)[\(%key as lua)]" compile [%obj's %key, %obj -> %key] to: "(\(%obj as lua))[\(%key as lua)]"
# Variable assignment operator, and += type versions # Variable assignment operator, and += type versions
compile (%var = %val) to code: "\(%var as lua) = \(%val as lua)" compile [%var = %val] to code: "\(%var as lua) = \(%val as lua);"
compile (%var += %val) to code: "\(%var as lua) = \(%var as lua) + \(%val as lua)" compile [%var += %val] to code: "\(%var as lua) = \(%var as lua) + \(%val as lua);"
compile (%var -= %val) to code: "\(%var as lua) = \(%var as lua) - \(%val as lua)" compile [%var -= %val] to code: "\(%var as lua) = \(%var as lua) - \(%val as lua);"
compile (%var *= %val) to code: "\(%var as lua) = \(%var as lua) * \(%val as lua)" compile [%var *= %val] to code: "\(%var as lua) = \(%var as lua) * \(%val as lua);"
compile (%var /= %val) to code: "\(%var as lua) = \(%var as lua) / \(%val as lua)" compile [%var /= %val] to code: "\(%var as lua) = \(%var as lua) / \(%val as lua);"
compile (%var ^= %val) to code: "\(%var as lua) = \(%var as lua) ^ \(%val as lua)" compile [%var ^= %val] to code: "\(%var as lua) = \(%var as lua) ^ \(%val as lua);"
compile (%var and= %val) to code: "\(%var as lua) = \(%var as lua) and\(%val as lua)" compile [%var and= %val] to code: "\(%var as lua) = \(%var as lua) and\(%val as lua);"
compile (%var or= %val) to code: "\(%var as lua) = \(%var as lua) or \(%val as lua)" compile [%var or= %val] to code: "\(%var as lua) = \(%var as lua) or \(%val as lua);"
compile (%var join= %val) to code: "\(%var as lua) = \(%var as lua) .. \(%val as lua)" compile [%var join= %val] to code: "\(%var as lua) = \(%var as lua) .. \(%val as lua);"
compile (%var mod= %val) to code: "\(%var as lua) = \(%var as lua) % \(%val as lua)" compile [%var mod= %val] to code: "\(%var as lua) = \(%var as lua) % \(%val as lua);"
%x =: 5
# Binary Operators # Binary Operators
lua block ".." lua block ".."
|local binops = {"-","/","<","<=",">",">=","^",{"===","=="},{"!==","~="},{"mod","%"}} |local binops = {"-","/","<","<=",">",">=","^",{"===","=="},{"!==","~="},{"mod","%"}};
|for _,op in ipairs(binops) do |for _,op in ipairs(binops) do;
| local nomsu_alias = op | local nomsu_alias = op;
| if type(op) == 'table' then | if type(op) == 'table' then;
| nomsu_alias, op = unpack(op) | nomsu_alias, op = unpack(op);
| end | end;
| nomsu:defmacro("%a "..nomsu_alias.." %b", (function(nomsu, vars) | nomsu:defmacro("%a "..nomsu_alias.." %b", (function(nomsu, vars)
| return "("..nomsu:tree_to_lua(vars.a).." "..op.." "..nomsu:tree_to_lua(vars.b)..")" | return "("..nomsu:tree_to_lua(vars.a).." "..op.." "..nomsu:tree_to_lua(vars.b)..")";
| end), [["(\\(%a) ]]..op..[[ \\(%b))"]]) | end), [["(\\(%a) ]]..op..[[ \\(%b))"]]);
|end |end;
# TODO: implement OR, XOR, AND for multiple operands # TODO: implement OR, XOR, AND for multiple operands
compile (%a OR %b; %a | %b) to: "bit32.bor(\(%a as lua), \(%b as lua))" compile [%a OR %b, %a | %b] to: "bit32.bor(\(%a as lua), \(%b as lua))"
compile (%a XOR %b) to: "bit32.bxor(\(%a as lua), \(%b as lua))" compile [%a XOR %b] to: "bit32.bxor(\(%a as lua), \(%b as lua))"
compile (%a AND %b; %a & %b) to: "bit32.band(\(%a as lua), \(%b as lua))" compile [%a AND %b, %a & %b] to: "bit32.band(\(%a as lua), \(%b as lua))"
compile (NOT %; ~ %) to: "bit32.bnot(\(% as lua))" compile [NOT %, ~ %] to: "bit32.bnot(\(% as lua))"
compile (%x LSHIFT %shift; %x << %shift) to: "bit32.lshift(\(%x as lua), \(%shift as lua))" compile [%x LSHIFT %shift, %x << %shift] to: "bit32.lshift(\(%x as lua), \(%shift as lua))"
compile (%x RSHIFT %shift) to: "bit32.rshift(\(%x as lua), \(%shift as lua))" compile [%x RSHIFT %shift] to: "bit32.rshift(\(%x as lua), \(%shift as lua))"
compile (%x ARSHIFT %shift; %x >> %shift) to: "bit32.arshift(\(%x as lua), \(%shift as lua))" compile [%x ARSHIFT %shift, %x >> %shift] to: "bit32.arshift(\(%x as lua), \(%shift as lua))"
# == and != do equivalence checking, rather than identity checking # == and != do equivalence checking, rather than identity checking
compile (%a == %b) to: "nomsu.utils.equivalent(\(%a as lua), \(%b as lua))" compile [%a == %b] to: "nomsu.utils.equivalent(\(%a as lua), \(%b as lua))"
compile (%a != %b) to: "(not nomsu.utils.equivalent(\(%a as lua), \(%b as lua)))" compile [%a != %b] to: "(not nomsu.utils.equivalent(\(%a as lua), \(%b as lua)))"
# Commutative Operators defined for up to 8 operands # Commutative Operators defined for up to 8 operands
# TODO: work out solution for commutative operators using more clever macros # TODO: work out solution for commutative operators using more clever macros
lua block ".." lua block ".."
|local max_operands = 8 |local max_operands = 8;
|local comops = {"+","*","and","or"} |local comops = {"+","*","and","or"};
|for _,_op in ipairs(comops) do |for _,_op in ipairs(comops) do;
| local op = _op | local op = _op;
| local spec = "%1 " | local spec = "%1 ";
| for n=2,max_operands do | for n=2,max_operands do;
| spec = spec .." "..op.." %"..tostring(n) | spec = spec .." "..op.." %"..tostring(n);
| nomsu:defmacro(spec, (function(nomsu, vars) | nomsu:defmacro(spec, (function(nomsu, vars)
| local bits = {} | local bits = {};
| for i=1,n do | for i=1,n do;
| table.insert(bits, (nomsu:tree_to_lua(vars[tostring(i)]))) | table.insert(bits, (nomsu:tree_to_lua(vars[tostring(i)])));
| end | end;
| return "("..table.concat(bits, " "..op.." ")..")" | return "("..table.concat(bits, " "..op.." ")..")";
| end)) | end));
| end | end;
|end |end;
# Chained compairsions (e.g. x < y <= z) are defined up to 3 operands # Chained compairsions (e.g. x < y <= z) are defined up to 3 operands
lua block ".." lua block ".."
|local max_operands = 3 |local max_operands = 3;
|for _,chainers in ipairs({{"<","<="},{">",">="}}) do |for _,chainers in ipairs({{"<","<="},{">",">="}}) do;
| local function recurse(chainers, chain) | local function recurse(chainers, chain)
# The 1-op versions are already more efficiently defined, and a 0-op version doesnt make sense # The 1-op versions are already more efficiently defined, and a 0-op version doesnt make sense
| if #chain >= 2 then | if #chain >= 2 then;
| local spec = "%1" | local spec = "%1";
| for i,op in ipairs(chain) do | for i,op in ipairs(chain) do;
| spec = spec .. " "..op.." %"..tostring(i+1) | spec = spec .. " "..op.." %"..tostring(i+1);
| end | end;
# Chained comparisons need to be functions to avoid re-evaluating their arguments :\ # Chained comparisons need to be functions to avoid re-evaluating their arguments :\
| nomsu:def(spec, function(nomsu, vars) | nomsu:def(spec, function(nomsu, vars)
| for i,op in ipairs(chain) do | for i,op in ipairs(chain) do;
| local a, b, result = vars[i], vars[i+1] | local a, b, result = vars[i], vars[i+1];
| if op == "<" then result = a < b | if op == "<" then; result = a < b;
| elseif op == "<=" then result = a <= b | elseif op == "<=" then; result = a <= b;
| elseif op == ">" then result = a > b | elseif op == ">" then; result = a > b;
| elseif op == ">=" then result = a >= b end | elseif op == ">=" then; result = a >= b; end;
# Short circuit # Short circuit
| if not result then return false end | if not result then; return false; end;
| end | end;
| end) | end);
| end | end;
| if #chain + 1 >= max_operands then return end | if #chain + 1 >= max_operands then; return; end;
| for _,c in ipairs(chainers) do | for _,c in ipairs(chainers) do;
| table.insert(chain, c) | table.insert(chain, c);
| recurse(chainers, chain) | recurse(chainers, chain);
| table.remove(chain) | table.remove(chain);
| end | end;
| end | end;
| recurse(chainers, {}) | recurse(chainers, {});
|end |end;
# Unary operators # Unary operators
compile (- %) to: "-(\(% as lua))" compile [- %] to: "-(\(% as lua))"
compile (not %) to: "not (\(% as lua))" compile [not %] to: "not (\(% as lua))"

26
lib/permissions.nom
View File

@ -4,44 +4,44 @@ require "lib/operators.nom"
require "lib/collections.nom" require "lib/collections.nom"
# Permission functions # Permission functions
rule (standardize rules %rules) =: rule [standardize rules %rules] =:
if (lua expr "type(vars.rules) == 'string'"): %rules = [%rules] if (lua expr "type(vars.rules) == 'string'"): %rules = [%rules]
(nomsu "get_stub" [%]) for all %rules (nomsu "get_stub" [%]) for all %rules
rule (restrict %rules to within %elite-rules) =: rule [restrict %rules to within %elite-rules] =:
%rules =: standardize rules %rules %rules = (standardize rules %rules)
%elite-rules =: standardize rules %elite-rules %elite-rules = (standardize rules %elite-rules)
say "Restricting \(%rules) to within \(%elite-rules)" say "Restricting \(%rules) to within \(%elite-rules)"
for all (flatten [%elite-rules, %rules]): for all (flatten [%elite-rules, %rules]):
assert ((nomsu's "defs") has key %) "Undefined function: \(%)" assert ((nomsu's "defs") has key %) "Undefined function: \(%)"
for %rule in %rules: for %rule in %rules:
assert (nomsu "check_permission" [%]) ".." assert (nomsu "check_permission" [%]) ".."
|You do not have permission to restrict permissions for function: \(%) |You do not have permission to restrict permissions for function: \(%)
((nomsu) ->* ["defs",%rule,"whiteset"]) =: ((nomsu) ->* ["defs",%rule,"whiteset"]) = (..)
dict: [%, yes] for all %elite-rules dict: [%, yes] for all %elite-rules
rule (allow %elite-rules to use %rules) =: rule [allow %elite-rules to use %rules] =:
%rules =: standardize rules %rules %rules = (standardize rules %rules)
%elite-rules =: standardize rules %elite-rules %elite-rules = (standardize rules %elite-rules)
say "Allowing \(%elite-rules) to use \(%rules)" say "Allowing \(%elite-rules) to use \(%rules)"
for all (flatten [%elite-rules, %rules]): for all (flatten [%elite-rules, %rules]):
assert ((nomsu's "defs") has key %) "Undefined function: \(%)" assert ((nomsu's "defs") has key %) "Undefined function: \(%)"
for %rule in %rules: for %rule in %rules:
assert (nomsu "check_permission" [%rule]) ".." assert (nomsu "check_permission" [%rule]) ".."
|You do not have permission to grant permissions for function: \(%rule) |You do not have permission to grant permissions for function: \(%rule)
%whiteset =: (nomsu) ->* ["defs",%rule,"whiteset"] %whiteset = ((nomsu) ->* ["defs",%rule,"whiteset"])
if (not %whiteset): go to next %rule if (not %whiteset): go to next %rule
for all %elite-rules: %whiteset -> % = (yes) for all %elite-rules: %whiteset -> % = (yes)
rule (forbid %pleb-rules to use %rules) =: rule [forbid %pleb-rules to use %rules] =:
%rules =: standardize rules %rules %rules = (standardize rules %rules)
%pleb-rules =: standardize rules %pleb-rules %pleb-rules = (standardize rules %pleb-rules)
say "Forbidding \(%pleb-rules) to use \(%rules)" say "Forbidding \(%pleb-rules) to use \(%rules)"
for all (flatten [%pleb-rules, %used]): for all (flatten [%pleb-rules, %used]):
assert ((nomsu's "defs") has key %) "Undefined function: \(%)" assert ((nomsu's "defs") has key %) "Undefined function: \(%)"
for all %rules: for all %rules:
assert (nomsu "check_permission" [%]) ".." assert (nomsu "check_permission" [%]) ".."
|You do not have permission to grant permissions for function: \(%) |You do not have permission to grant permissions for function: \(%)
%whiteset =: (nomsu) ->* ["defs",%,"whiteset"] %whiteset = ((nomsu) ->* ["defs",%,"whiteset"])
assert %whiteset ".." assert %whiteset ".."
|Cannot individually restrict permissions for \(%) because it is currently |Cannot individually restrict permissions for \(%) because it is currently
|available to everyone. Perhaps you meant to use "restrict % to within %" instead? |available to everyone. Perhaps you meant to use "restrict % to within %" instead?

36
lib/plurals.nom
View File

@ -4,32 +4,32 @@ require "lib/secrets.nom"
# Plurals # Plurals
with secrets: with secrets:
lua block ".." lua block ".."
|local endings = setmetatable({x="es",c="es",s="es"}, {__index=function() return "s" end}) |local endings = setmetatable({x="es",c="es",s="es"}, {__index=function() return "s"; end});
|secrets.plurals = setmetatable({}, {__index=function(self,key) |secrets.plurals = setmetatable({}, {__index=function(self,key)
| return key..endings[key:sub(-1)] | return key..endings[key:sub(-1)];
|end}) |end});
|secrets.singulars = setmetatable({}, {__index=function(self,key) |secrets.singulars = setmetatable({}, {__index=function(self,key)
| if key:sub(-2) == "es" and rawget(endings, key:sub(-3,-3)) then return key:sub(1,-3) end | if key:sub(-2) == "es" and rawget(endings, key:sub(-3,-3)) then; return key:sub(1,-3); end;
| if key:sub(-1) == "s" then return key:sub(1,-2) end | if key:sub(-1) == "s" then; return key:sub(1,-2); end;
| return key | return key;
|end}) |end});
|secrets.canonicals = setmetatable({}, {__index=function(self,key) |secrets.canonicals = setmetatable({}, {__index=function(self,key)
| if key:sub(-1) == "s" then return secrets.singulars[key] end | if key:sub(-1) == "s" then; return secrets.singulars[key]; end;
| return key | return key;
|end}) |end});
rule (the plural of %singular is %plural) =: rule [the plural of %singular is %plural] =:
(secret %plurals)->%singular =: %plural (secret %plurals)->%singular = %plural
(secret %singulars)->%plural =: %singular (secret %singulars)->%plural = %singular
(secret %canonicals)->%plural =: %singular (secret %canonicals)->%plural = %singular
rule (singular %plural) =: rule [singular %plural] =:
%plural in (secret %singulars) %plural in (secret %singulars)
rule (plural %singular) =: rule [plural %singular] =:
%singular in (secret %plurals) %singular in (secret %plurals)
rule (canonicalize %item-name) =: rule [canonicalize %item-name] =:
%item-name in (secret %canonicals) %item-name in (secret %canonicals)
rule (rules that change plurals) =: ["the plural of % is %"] rule [rules that change plurals] =: ["the plural of % is %"]

16
lib/secrets.nom
View File

@ -1,20 +1,22 @@
require "lib/core.nom" require "lib/core.nom"
compile (with secrets %block) to block: ".." compile [with secrets %block] to code: ".."
|local secrets = {} |do;
|\(%block as lua statements) | local secrets = {}
| \(%block as lua statements)
|end;
# Access the lua variable that should be within scope # Access the lua variable that should be within scope
compile (secrets) to: "secrets" compile [secrets] to: "secrets"
compile (secret %key; secret value of %key; secret value for %key) to: compile [secret %key; secret value of %key; secret value for %key] to:
assert ((%key's "type") == "Var") ".." assert ((%key's "type") == "Var") ".."
|Wrong type, expected Var, but got: \(%key's "type") |Wrong type, expected Var, but got: \(%key's "type")
"secrets[\(repr (%key's "value"))]" "secrets[\(repr (%key's "value"))]"
compile (secret %key = %new_value) to code: compile [secret %key = %new_value] to code:
assert ((%key's "type") == "Var") ".." assert ((%key's "type") == "Var") ".."
|Wrong type, expected Var, but got: \(%key's "type") |Wrong type, expected Var, but got: \(%key's "type")
"secrets[\(repr (%key's "value"))] = \(%new_value as lua)" "secrets[\(repr (%key's "value"))] = \(%new_value as lua)"
rule (rules about secrecy) =: ["with secrets %"] rule [rules about secrecy] =: ["with secrets %"]

88
lib/testing.nom
View File

@ -1,83 +1,13 @@
require "lib/metaprogramming.nom" require "lib/metaprogramming.nom"
# For unit testing # For unit testing
macro block [test %code yields %expected] =: rule [test tree %generated == %expected] =:
_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" then 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" then @_yield_tree(tree.value, indent_level)
when "FunctionCall"
alias = @get_alias tree
args = [a for a in *tree.value when a.type != "Word"]
if #args == 0
coroutine.yield(ind"Call [#{alias}]!")
else
coroutine.yield(ind"Call [#{alias}]:")
for a in *args
@_yield_tree(a, indent_level+1)
when "String" then coroutine.yield(ind(repr(tree.value)))
when "Longstring" then coroutine.yield(ind(repr(tree.value)))
when "Number" then coroutine.yield(ind(tree.value))
when "Var" then coroutine.yield ind"Var[#{repr(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)
else error("Unknown/unimplemented thingy: #{tree.type}")
print_tree:(tree)=>
for line in coroutine.wrap(-> @_yield_tree(tree))
@writeln(line)
stringify_tree:(tree)=>
result = {}
for line in coroutine.wrap(-> @_yield_tree(tree))
insert(result, line)
return concat result, "\n"
test: (src, filename, 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, filename)
got = @stringify_tree(tree.value.body)
if got != expected
@error"TEST FAILED!\nSource:\n#{test_src}\nExpected:\n#{expected}\n\nGot:\n#{got}"
%generated =: repr (nomsu "stringify_tree" [%code's "value"])
%expected =: %expected as lua
if (%generated != %expected): if (%generated != %expected):
say "Test failed!" error ".."
say "Expected:" |Test Failed!
say %expected |Expected:
say "But got:" |\(%expected)
say %generated |But got:
error! |\(%generated)
return "" parse [test %code yields %expected] as:
test tree (nomsu "tree_to_str" [\%code]) == %expected

84
lib/utils.nom
View File

@ -1,83 +1,83 @@
require "lib/metaprogramming.nom" require "lib/metaprogramming.nom"
# Error functions # Error functions
rule (error!; panic!; fail!; abort!) =: rule [error!, panic!, fail!, abort!] =:
nomsu "error" [] nomsu "error" []
rule (error %msg) =: rule [error %msg] =:
nomsu "error"[%msg] nomsu "error"[%msg]
compile (assert %condition %msg) to code: ".." compile [assert %condition %msg] to code: ".."
|if not (\(%condition as lua)) then |if not (\(%condition as lua)) then
| nomsu:error(\(%msg as lua)) | nomsu:error(\(%msg as lua))
|end |end
parse (assert %condition) as: assert %condition (nil) parse [assert %condition] as: assert %condition (nil)
# String functions # String functions
rule (join %strs with glue %glue) =: rule [join %strs with glue %glue] =:
lua block ".." lua block ".."
|local str_bits = {} |local str_bits = {}
|for i,bit in ipairs(vars.strs) do str_bits[i] = nomsu.utils.repr_if_not_string(bit) end |for i,bit in ipairs(vars.strs) do str_bits[i] = nomsu.utils.repr_if_not_string(bit) end
|return table.concat(str_bits, vars.glue) |return table.concat(str_bits, vars.glue)
parse (join %strs) as: join %strs with glue "" parse [join %strs] as: join %strs with glue ""
compile (capitalize %str; %str capitalized) to: compile [capitalize %str, %str capitalized] to:
"(\(%str as lua)):gsub('%l', string.upper, 1)" "(\(%str as lua)):gsub('%l', string.upper, 1)"
compile (say %str) to: ".." compile [say %str] to: ".."
|nomsu:writeln(\(%str as lua)) |nomsu:writeln(\(%str as lua))
# Number ranges # Number ranges
compile (%start to %stop by %step; %start to %stop via %step) to: ".." compile [%start to %stop by %step, %start to %stop via %step] to: ".."
|nomsu.utils.range(\(%start as lua), \(%stop as lua), \(%step as lua)) |nomsu.utils.range(\(%start as lua), \(%stop as lua), \(%step as lua))
parse (%start to %stop) as: %start to %stop by 1 parse [%start to %stop] as: %start to %stop by 1
# Random functions # Random functions
compile (random number; random; rand) to: "math.random()" compile [random number, random, rand] to: "math.random()"
compile (random int %n; random integer %n; randint %n) to: "math.random(\(%n as lua))" compile [random int %n, random integer %n, randint %n] to: "math.random(\(%n as lua))"
compile (random from %low to %high; random number from %low to %high; rand %low %high) to: compile [random from %low to %high, random number from %low to %high, rand %low %high] to:
"math.random(\(%low as lua), \(%high as lua))" "math.random(\(%low as lua), \(%high as lua))"
rule (random choice from %elements; random choice %elements; random %elements) =: rule [random choice from %elements, random choice %elements, random %elements] =:
lua expr "\(%elements)[math.random(#\(%elements))]" lua expr "\(%elements)[math.random(#\(%elements))]"
# Math functions # Math functions
compile (abs %; absolute value of %; | % |) to: "math.abs(\(% as lua))" compile [abs %, absolute value of %, | % |] to: "math.abs(\(% as lua))"
compile (sqrt %; square root of %) to: "math.sqrt(\(% as lua))" compile [sqrt %, square root of %] to: "math.sqrt(\(% as lua))"
compile (sin %; sine %) to: "math.sin(\(% as lua))" compile [sin %, sine %] to: "math.sin(\(% as lua))"
compile (cos %; cosine %) to: "math.cos(\(% as lua))" compile [cos %, cosine %] to: "math.cos(\(% as lua))"
compile (tan %; tangent %) to: "math.tan(\(% as lua))" compile [tan %, tangent %] to: "math.tan(\(% as lua))"
compile (asin %; arc sine %) to: "math.asin(\(% as lua))" compile [asin %, arc sine %] to: "math.asin(\(% as lua))"
compile (acos %; arc cosine %) to: "math.acos(\(% as lua))" compile [acos %, arc cosine %] to: "math.acos(\(% as lua))"
compile (atan %; arc tangent %) to: "math.atan(\(% as lua))" compile [atan %, arc tangent %] to: "math.atan(\(% as lua))"
compile (atan2 %y %x) to: "math.atan2(\(%y as lua), \(%x as lua))" compile [atan2 %y %x] to: "math.atan2(\(%y as lua), \(%x as lua))"
compile (sinh %; hyperbolic sine %) to: "math.sinh(\(% as lua))" compile [sinh %, hyperbolic sine %] to: "math.sinh(\(% as lua))"
compile (cosh %; hyperbolic cosine %) to: "math.cosh(\(% as lua))" compile [cosh %, hyperbolic cosine %] to: "math.cosh(\(% as lua))"
compile (tanh %; hyperbolic tangent %) to: "math.tanh(\(% as lua))" compile [tanh %, hyperbolic tangent %] to: "math.tanh(\(% as lua))"
compile (ceil %; ceiling %) to: "math.ceil(\(% as lua))" compile [ceil %, ceiling %] to: "math.ceil(\(% as lua))"
compile (exp %; e^ %) to: "math.exp(\(% as lua))" compile [exp %, e^ %] to: "math.exp(\(% as lua))"
compile (log %; ln %; natural log %) to: "math.log(\(% as lua))" compile [log %, ln %, natural log %] to: "math.log(\(% as lua))"
compile (log % base %base) to: "math.log(\(% as lua), \(%base as lua))" compile [log % base %base] to: "math.log(\(% as lua), \(%base as lua))"
compile (floor %) to: "math.floor(\(% as lua))" compile [floor %] to: "math.floor(\(% as lua))"
compile (round %; % rounded) to: "math.floor(\(% as lua) + .5)" compile [round %, % rounded] to: "math.floor(\(% as lua) + .5)"
rule (%n rounded to the nearest %rounder) =: rule [%n rounded to the nearest %rounder] =:
lua expr "(\(%rounder))*math.floor(\(%n)/\(%rounder) + .5)" lua expr "(\(%rounder))*math.floor(\(%n)/\(%rounder) + .5)"
# Common utility functions # Common utility functions
compile (sum of %items; sum %items) to: "nomsu.utils.sum(\(%items as lua))" compile [sum of %items, sum %items] to: "nomsu.utils.sum(\(%items as lua))"
compile (product of %items; product %items) to: "nomsu.utils.product(\(%items as lua))" compile [product of %items, product %items] to: "nomsu.utils.product(\(%items as lua))"
compile (all of %items) to: "nomsu.utils.all(\(%items as lua))" compile [all of %items] to: "nomsu.utils.all(\(%items as lua))"
compile (any of %items) to: "nomsu.utils.any(\(%items as lua))" compile [any of %items] to: "nomsu.utils.any(\(%items as lua))"
rule (avg of %items; average of %items) =: rule [avg of %items, average of %items] =:
lua expr "(nomsu.utils.sum(\(%items))/#\(%items))" lua expr "(nomsu.utils.sum(\(%items))/#\(%items))"
compile (min of %items; smallest of %items; lowest of %items) to: compile [min of %items, smallest of %items, lowest of %items] to:
"nomsu.utils.min(\(%items as lua))" "nomsu.utils.min(\(%items as lua))"
compile (max of %items; biggest of %items; largest of %items; highest of %items) to: compile [max of %items, biggest of %items, largest of %items, highest of %items] to:
"nomsu.utils.max(\(%items as lua))" "nomsu.utils.max(\(%items as lua))"
compile (min of %items by %value_expr) to: compile [min of %items by %value_expr] to:
".." ".."
|nomsu.utils.min(\(%items as lua), function(item) |nomsu.utils.min(\(%items as lua), function(item)
| local vars = setmetatable({['']=item}, {__index=vars}) | local vars = setmetatable({['']=item}, {__index=vars})
| return \(%value_expr as lua) | return \(%value_expr as lua)
|end) |end)
compile (max of %items by %value_expr) to: compile [max of %items by %value_expr] to:
".." ".."
|nomsu.utils.max(\(%items as lua), function(item) |nomsu.utils.max(\(%items as lua), function(item)
| local vars = setmetatable({['']=item}, {__index=vars}) | local vars = setmetatable({['']=item}, {__index=vars})

129
nomsu.moon
View File

@ -50,7 +50,7 @@ check_nodent = (subject,end_pos,spaces)->
return end_pos return end_pos
-- TYPES: -- TYPES:
-- Number 1, "String", %Var, [List], (Block), \(Nomsu), FunctionCall, File -- Number 1, "String", %Var, [List], (expression), {Thunk}, \Nomsu, FunctionCall, File
nomsu = [=[ nomsu = [=[
file <- ({ {| shebang? file <- ({ {| shebang?
@ -69,20 +69,25 @@ nomsu = [=[
noeol_statement <- noeol_functioncall / noeol_expression noeol_statement <- noeol_functioncall / noeol_expression
inline_statement <- inline_functioncall / inline_expression inline_statement <- inline_functioncall / inline_expression
inline_block <- ({ {| "(" inline_statements ")" |} }) -> Block inline_thunk <- ({ {| "{" inline_statements "}" |} }) -> Thunk
eol_block <- ({ {| ":" %ws? noeol_statements eol |} }) -> Block eol_thunk <- ({ {| ":" %ws? noeol_statements eol |} }) -> Thunk
indented_block <- ({ {| (":" / "(..)") indent indented_thunk <- ({ {| (":" / "{..}") indent
statements (nodent statements)* statements (nodent statements)*
(dedent / (({.+} ("" -> "Error while parsing block")) => error)) (dedent / (({.+} ("" -> "Error while parsing thunk")) => error))
|} }) -> Block |} }) -> Thunk
inline_nomsu <- ({ ("\" inline_expression) }) -> Nomsu inline_nomsu <- ({ ("\" inline_expression) }) -> Nomsu
eol_nomsu <- ({ ("\" noeol_expression) }) -> Nomsu eol_nomsu <- ({ ("\" noeol_expression) }) -> Nomsu
indented_nomsu <- ({ ("\" expression) }) -> Nomsu indented_nomsu <- ({ ("\" expression) }) -> Nomsu
inline_expression <- number / variable / inline_string / inline_list / inline_block / inline_nomsu inline_expression <- number / variable / inline_string / inline_list / inline_nomsu
noeol_expression <- indented_string / indented_block / indented_nomsu / indented_list / inline_expression / inline_thunk / ("(" inline_statement ")")
expression <- eol_block / eol_nomsu / noeol_expression noeol_expression <- indented_string / indented_nomsu / indented_list / indented_thunk
/ ("(..)" indent
statement
(dedent / (({.+} ("" -> "Error while parsing indented expression"))))
) / inline_expression
expression <- eol_thunk / eol_nomsu / noeol_expression
-- Function calls need at least one word in them -- Function calls need at least one word in them
inline_functioncall <- ({ {| inline_functioncall <- ({ {|
@ -107,7 +112,7 @@ nomsu = [=[
|} (dedent / (({.+} ("" -> "Error while parsing String")) => error)) |} (dedent / (({.+} ("" -> "Error while parsing String")) => error))
}) -> String }) -> String
indented_string_line <- "|" ({~ (("\\" -> "\") / (!string_interpolation [^%nl]))+ ~} / string_interpolation)* indented_string_line <- "|" ({~ (("\\" -> "\") / (!string_interpolation [^%nl]))+ ~} / string_interpolation)*
string_interpolation <- "\" (inline_block / indented_block / dotdot) string_interpolation <- "\" ((noeol_expression dotdot?) / dotdot)
number <- ({ (("-"? (([0-9]+ "." [0-9]+) / ("." [0-9]+) / ([0-9]+)))-> tonumber) }) -> Number number <- ({ (("-"? (([0-9]+ "." [0-9]+) / ("." [0-9]+) / ([0-9]+)))-> tonumber) }) -> Number
@ -189,16 +194,21 @@ class NomsuCompiler
@write(...) @write(...)
@write("\n") @write("\n")
def: (invocation, thunk, src)=> def: (signature, thunk, src, is_macro=false)=>
stub, arg_names = @get_stub invocation assert type(thunk) == 'function', "Bad thunk: #{repr thunk}"
assert stub, "NO STUB FOUND: #{repr invocation}" canonical_args = nil
if @debug then @writeln "#{colored.bright "DEFINING RULE:"} #{colored.underscore colored.magenta repr(stub)} #{colored.bright "WITH ARGS"} #{colored.dim repr(arg_names)}" for {stub, arg_names} in *@get_stubs(signature)
for i=1,#arg_names-1 do for j=i+1,#arg_names assert stub, "NO STUB FOUND: #{repr signature}"
if arg_names[i] == arg_names[j] then @error "Duplicate argument in function #{stub}: '#{arg_names[i]}'" if @debug then @writeln "#{colored.bright "DEFINING RULE:"} #{colored.underscore colored.magenta repr(stub)} #{colored.bright "WITH ARGS"} #{colored.dim repr(arg_names)}"
with @defs[stub] = {:thunk, :invocation, :arg_names, :src, is_macro:false} do nil for i=1,#arg_names-1 do for j=i+1,#arg_names
if arg_names[i] == arg_names[j] then @error "Duplicate argument in function #{stub}: '#{arg_names[i]}'"
if canonical_args
assert utils.equivalent(utils.set(arg_names), canonical_args), "Mismatched args"
else canonical_args = utils.set(arg_names)
@defs[stub] = {:thunk, :stub, :arg_names, :src, :is_macro}
defmacro: (invocation, thunk, src)=> defmacro: (signature, thunk, src)=>
with @def(invocation, thunk, src) do .is_macro = true @def(signature, thunk, src, true)
call: (stub,...)=> call: (stub,...)=>
def = @defs[stub] def = @defs[stub]
@ -279,31 +289,37 @@ class NomsuCompiler
code_for_statement = ([[ code_for_statement = ([[
return (function(nomsu, vars) return (function(nomsu, vars)
%s %s
return %s return %s;
end)]])\format(statements or "", expr or "") end);]])\format(statements or "", expr or "ret")
if @debug if @debug
@writeln "#{colored.bright "RUNNING LUA:"}\n#{colored.blue colored.bright(code_for_statement)}" @writeln "#{colored.bright "RUNNING LUA:"}\n#{colored.blue colored.bright(code_for_statement)}"
lua_thunk, err = load(code_for_statement) lua_thunk, err = load(code_for_statement)
if not lua_thunk if not lua_thunk
error("Failed to compile generated code:\n#{colored.bright colored.blue code_for_statement}\n\n#{err}\n\nProduced by statement:\n#{colored.bright colored.yellow statement.src}") n = 1
fn = ->
n = n + 1
("\n%-3d|")\format(n)
code = "1 |"..code_for_statement\gsub("\n", fn)
error("Failed to compile generated code:\n#{colored.bright colored.blue code}\n\n#{err}\n\nProduced by statement:\n#{colored.bright colored.yellow statement.src}")
run_statement = lua_thunk! run_statement = lua_thunk!
ok,ret = pcall(run_statement, self, vars) ok,ret = pcall(run_statement, self, vars)
if expr then return_value = ret if expr then return_value = ret
if not ok if not ok
@writeln "#{colored.red "Error occurred in statement:"}\n#{colored.yellow statement.src}" @writeln "#{colored.red "Error occurred in statement:"}\n#{colored.yellow statement.src}"
@error(repr return_value) @writeln debug.traceback!
@error(ret)
insert buffer, "#{statements or ''}\n#{expr and "ret = #{expr}" or ''}" insert buffer, "#{statements or ''}\n#{expr and "ret = #{expr}" or ''}"
lua_code = ([[ lua_code = ([[
return function(nomsu, vars) return (function(nomsu, vars)
local ret local ret;
%s %s
return ret return ret;
end]])\format(concat(buffer, "\n")) end);]])\format(concat(buffer, "\n"))
return return_value, lua_code return return_value, lua_code
tree_to_value: (tree, vars)=> tree_to_value: (tree, vars)=>
code = "return (function(nomsu, vars)\nreturn #{@tree_to_lua(tree)}\nend)" code = "return (function(nomsu, vars)\nreturn #{@tree_to_lua(tree)};\nend);"
if @debug if @debug
@writeln "#{colored.bright "RUNNING LUA TO GET VALUE:"}\n#{colored.blue colored.bright(code)}" @writeln "#{colored.bright "RUNNING LUA TO GET VALUE:"}\n#{colored.blue colored.bright(code)}"
lua_thunk, err = load(code) lua_thunk, err = load(code)
@ -324,32 +340,18 @@ class NomsuCompiler
when "Nomsu" when "Nomsu"
return repr(tree.value), nil return repr(tree.value), nil
when "Thunk" -- This is not created by the parser, it's just a helper when "Thunk"
_,body = @tree_to_lua tree.value
return ([[
(function(nomsu, vars)
local ret
%s
return ret
end)]])\format(body), nil
when "Block"
if #tree.value == 0
return "nil",nil
if #tree.value == 1
expr,statement = @tree_to_lua tree.value[1]
if not statement
return expr, nil
thunk_lua = @tree_to_lua {type:"Thunk", value:{type:"Statements", value:tree.value, src:tree.src}, src:tree.src}
return ("%s(nomsu, vars)")\format(thunk_lua), nil
when "Statements"
lua_bits = {} lua_bits = {}
for arg in *tree.value for arg in *tree.value
expr,statement = @tree_to_lua arg expr,statement = @tree_to_lua arg
if statement then insert lua_bits, statement if statement then insert lua_bits, statement
if expr then insert lua_bits, "ret = #{expr}" if expr then insert lua_bits, "ret = #{expr};"
return nil, concat(lua_bits, "\n") return ([[
(function(nomsu, vars)
local ret;
%s
return ret;
end)]])\format(concat(lua_bits, "\n"))
when "FunctionCall" when "FunctionCall"
stub = @get_stub(tree) stub = @get_stub(tree)
@ -418,7 +420,7 @@ class NomsuCompiler
if type(tree) != 'table' or not tree.type if type(tree) != 'table' or not tree.type
return return
switch tree.type switch tree.type
when "List", "File", "Block", "FunctionCall", "String" when "List", "File", "Thunk", "FunctionCall", "String"
for v in *tree.value for v in *tree.value
@walk_tree(v, depth+1) @walk_tree(v, depth+1)
else @walk_tree(tree.value, depth+1) else @walk_tree(tree.value, depth+1)
@ -465,7 +467,7 @@ class NomsuCompiler
when "Var" when "Var"
if vars[tree.value] ~= nil if vars[tree.value] ~= nil
tree = vars[tree.value] tree = vars[tree.value]
when "File", "Nomsu", "Thunk", "Block", "List", "FunctionCall", "String" when "File", "Nomsu", "Thunk", "List", "FunctionCall", "String"
new_value = @replaced_vars tree.value, vars new_value = @replaced_vars tree.value, vars
if new_value != tree.value if new_value != tree.value
tree = {k,v for k,v in pairs(tree)} tree = {k,v for k,v in pairs(tree)}
@ -506,9 +508,16 @@ class NomsuCompiler
arg_names = nil arg_names = nil
insert args, token insert args, token
return concat(stub," "), arg_names, args return concat(stub," "), arg_names, args
when "Block" else @error "Unsupported get stub type: #{x.type}"
@writeln debug.traceback!
@error "Please pass in a single line from a block, not the whole thing:\n#{@tree_to_str x}" get_stubs: (x)=>
if type(x) != 'table' then return {{@get_stub(x)}}
switch x.type
when nil
return [{@get_stub(i)} for i in *x]
when "List"
return [{@get_stub(i)} for i in *x.value]
return {{@get_stub(x)}}
var_to_lua_identifier: (var)=> var_to_lua_identifier: (var)=>
-- Converts arbitrary nomsu vars to valid lua identifiers by replacing illegal -- Converts arbitrary nomsu vars to valid lua identifiers by replacing illegal
@ -584,12 +593,12 @@ if arg and arg[1]
io.output() io.output()
else io.open(arg[2], 'w') else io.open(arg[2], 'w')
output\write ([[ output\write ([[
local NomsuCompiler = require('nomsu') local NomsuCompiler = require('nomsu');
local c = NomsuCompiler() local c = NomsuCompiler();
local run = function(nomsu, vars) local run = (function(nomsu, vars)
%s %s
end end);
return run(c, {}) return run(c, {});
]])\format(code) ]])\format(code)
--ProFi\stop() --ProFi\stop()
--ProFi\writeReport( 'MyProfilingReport.txt' ) --ProFi\writeReport( 'MyProfilingReport.txt' )