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

Got it working.

Browse Source
This commit is contained in:
Bruce Hill 2017-12-13 16:29:15 -08:00
parent 0c1c406ce0
commit 536a3ba649
9 changed files with 377 additions and 369 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

62
lib/collections.nom
View File

@ -20,12 +20,12 @@ 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): ...
compile [for %key = %value in %dict %body] to code: ".."
|do;
| for k, v in pairs(\(%dict as lua)) do;
| \(%key as lua), \(%value as lua) = k, v;
| \(%body as lua statements)
| end;
|end;
do
for k, v in pairs(\(%dict as lua)) do
\(%key as lua), \(%value as lua) = k, v;
\(%body as lua statements)
end
end
# Membership testing
rule [%item is in %list, %list contains %item, %list has %item] =:
@ -43,7 +43,7 @@ rule [..]
return (yes)
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 [..]
%list doesn't have key %index, %list does not have key %index
@ -56,7 +56,7 @@ compile [length of %list, size of %list, size %list, number of %list, len %list]
# Chained lookup
compile [%list ->* %indices] to:
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)"
for %index in (%indices's "value"):
%ret join= "[\(%index as lua)]"
@ -98,20 +98,20 @@ compile [dict %items, d %items] to:
%item_codes = []
for %func_call in (%items's "value"):
assert ((%func_call's "type") == "FunctionCall") ".."
|Invalid format for 'dict' expression. Only literals are allowed.
Invalid format for 'dict' expression. Only literals are allowed.
%tokens = (%func_call's "value")
%equals = (%tokens -> 2)
assert (=lua "#\(%tokens) == 3 and \(%equals) and \(%equals).type == 'Word' and \(%equals).value == '='") ".."
|Invalid format for 'dict' expression. Lines must only have the "% = %" format, not \(%func_call's "src")
Invalid format for 'dict' expression. Lines must only have the "% = %" format, not \(%func_call's "src")
%key = (%tokens -> 1)
lua> ".."
|if \(%key).type == "Word" and \(%key).value:match("^[a-zA-Z_][a-zA-Z0-9_]*$") then
| \(%key_code) = \(%key).value;
|elseif \(%key).type == "Word" then
| \(%key_code) = "["..nomsu:repr(\(%key).value).."]";
|else
| \(\{%key_code = "[\((%key as lua))]"} as lua statements)
|end
if \(%key).type == "Word" and \(%key).value:match("^[a-zA-Z_][a-zA-Z0-9_]*$") then
\(%key_code) = \(%key).value;
elseif \(%key).type == "Word" then
\(%key_code) = "["..nomsu:repr(\(%key).value).."]";
else
\(\{%key_code = "[\((%key as lua))]"} as lua statements)
end
add "\(%key_code) = \((%tokens -> 3) as lua)" to %item_codes
return "{\(join %item_codes with glue ",\n")}"
..else:
@ -139,16 +139,16 @@ rule [values in %dict] =:
# List Comprehension
compile [%expression for %var in %iterable] to:
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);
| local comprehension = {};
| for i,value in ipairs(\(%iterable as lua)) do;
| \(%var as lua) = value;
| comprehension[i] = \(%expression as lua);
| end;
| return comprehension;
|end)(game, setmetatable({}, {__index=vars}))
(function(game, vars);
local comprehension = {};
for i,value in ipairs(\(%iterable as lua)) do;
\(%var as lua) = value;
comprehension[i] = \(%expression as lua);
end;
return comprehension;
end)(game, setmetatable({}, {__index=vars}))
parse [%expression for all %iterable] as: %expression for % in %iterable
rule [%items sorted] =:
@ -165,11 +165,11 @@ rule [unique %items] =:
# Metatable stuff
compile [counter] to: "setmetatable({}, {__index=function() return 0; end})"
compile [default dict] to: ".."
|setmetatable({}, {__index=function(self, key)
| t = {};
| self[key] = t;
| return t;
|end})"
setmetatable({}, {__index=function(self, key)
t = {};
self[key] = t;
return t;
end})"
rule [chain %dict to %fallback] =:
when (type of %fallback) == ?:
* "table":

196
lib/control_flow.nom
View File

@ -4,20 +4,20 @@ require "lib/utils.nom"
# Conditionals
compile [if %condition %if_body] to code: ".."
|if \(%condition as lua) then
|\(%if_body as lua statements)
|end --end if
if \(%condition as lua) then
\(%if_body as lua statements)
end --end if
compile [unless %condition %body] to code: ".."
|if not (\(%condition as lua)) then
|\(%body as lua statements)
|end --end if
if not (\(%condition as lua)) then
\(%body as lua statements)
end --end if
compile [if %condition %if_body else %else_body, unless %condition %else_body else %if_body] to code: ".."
|if \(%condition as lua) then
|\(%if_body as lua statements)
|else
|\(%else_body as lua statements)
|end --end if
if \(%condition as lua) then
\(%if_body as lua statements)
else
\(%else_body as lua statements)
end --end if
# Return
compile [return] to code: "do return; end"
@ -25,20 +25,20 @@ compile [return %return_value] to code: "do return \(%return_value as lua); end"
# GOTOs
compile [-> %label] to code: ".."
|::label_\(nomsu "var_to_lua_identifier" [%label])::;
::label_\(nomsu "var_to_lua_identifier" [%label])::;
compile [go to %label] to code: ".."
|goto label_\(nomsu "var_to_lua_identifier" [%label]);
goto label_\(nomsu "var_to_lua_identifier" [%label]);
rule [tree %tree has function call %call] =:
lua> ".."
|local target = (\(%call)).value;
|for subtree,_ in coroutine.wrap(function() nomsu:walk_tree(\(%tree)); end) do
| if type(subtree) == 'table' and subtree.type == "FunctionCall"
| and nomsu.utils.equivalent(subtree.value, target, 2) then
| return true;
| end
|end
|do return false; end
local target = (\(%call)).value;
for subtree,_ in coroutine.wrap(function() nomsu:walk_tree(\(%tree)); end) do
if type(subtree) == 'table' and subtree.type == "FunctionCall"
and nomsu.utils.equivalent(subtree.value, target, 2) then
return true;
end
end
do return false; end
# While loops
compile [do next repeat-loop] to code: "goto continue_repeat;"
@ -47,15 +47,15 @@ compile [repeat while %condition %body] to code:
%continue_labels = (..)
"\n::continue_repeat::;" if (tree %body has function call \(do next repeat-loop)) else ""
%code = ".."
|while \(%condition as lua) do
|\(%body as lua statements)\(%continue_labels)
|end --while-loop
while \(%condition as lua) do
\(%body as lua statements)\(%continue_labels)
end --while-loop
if (tree %body has function call \(stop repeat-loop)):
return ".."
|do --while-loop label scope
|\(%code)
|::stop_repeat::;
|end --while-loop label scope
do --while-loop label scope
\(%code)
::stop_repeat::;
end --while-loop label scope
return %code
parse [repeat %body] as: repeat while (true) %body
parse [repeat until %condition %body] as: repeat while (not %condition) %body
@ -63,10 +63,10 @@ parse [repeat until %condition %body] as: repeat while (not %condition) %body
# For loop control flow:
compile [stop for-loop] to code: "goto stop_for;"
compile [stop %var] to code: ".."
|goto stop_\(nomsu "var_to_lua_identifier" [%var]);
goto stop_\(nomsu "var_to_lua_identifier" [%var]);
compile [do next for-loop] to code: "goto continue_for;"
compile [do next %var] to code: ".."
|goto continue_\(nomsu "var_to_lua_identifier" [%var]);
goto continue_\(nomsu "var_to_lua_identifier" [%var]);
# Numeric range for loops
compile [..]
@ -78,21 +78,21 @@ compile [..]
%continue_labels join= "\n::continue_for::;"
if (tree %body has function call (nomsu "replaced_vars" [\(do next %), =lua "{['']=\(%var)}"])):
%continue_labels join= "\n::continue_\(nomsu "var_to_lua_identifier" [%var])::;"
# This trashes the loop variables, just like in Python.
%code = ".."
|for i=\(%start as lua),\(%stop as lua),\(%step as lua) do
# This trashes the loop variables, just like in Python.
|\(%var as lua) = i;
|\(%body as lua statements)\(%continue_labels)
|end --numeric for-loop
for i=\(%start as lua),\(%stop as lua),\(%step as lua) do
\(%var as lua) = i;
\(%body as lua statements)\(%continue_labels)
end --numeric for-loop
%stop_labels = ""
if (tree %body has function call \(stop for-loop)):
%stop_labels join= "\n::stop_for::;"
if (tree %body has function call (nomsu "replaced_vars" [\(stop %), =lua "{['']=\(%var)}"])):
%stop_labels join= "\n::stop_\(nomsu "var_to_lua_identifier" [%var])::;"
if (%stop_labels != ""): ".."
|do --for-loop label scope
|\(%code)\(%stop_labels)
|end --for-loop label scope
do --for-loop label scope
\(%code)\(%stop_labels)
end --for-loop label scope
..else: %code
parse [for %var from %start to %stop %body] as: for %var from %start to %stop via 1 %body
parse [..]
@ -107,21 +107,21 @@ compile [for %var in %iterable %body] to code:
%continue_labels join= "\n::continue_for::;"
if (tree %body has function call (nomsu "replaced_vars" [\(do next %), =lua "{['']=\(%var)}"])):
%continue_labels join= "\n::continue_\(nomsu "var_to_lua_identifier" [%var])::;"
# This trashes the loop variables, just like in Python.
%code = ".."
|for i,value in ipairs(\(%iterable as lua)) do
# This trashes the loop variables, just like in Python.
|\(%var as lua) = value;
|\(%body as lua statements)\(%continue_labels)
|end --foreach-loop
for i,value in ipairs(\(%iterable as lua)) do
\(%var as lua) = value;
\(%body as lua statements)\(%continue_labels)
end --foreach-loop
%stop_labels = ""
if (tree %body has function call \(stop for-loop)):
%stop_labels join= "\n::stop_for::;"
if (tree %body has function call (nomsu "replaced_vars" [\(stop %), =lua "{['']=\(%var)}"])):
%stop_labels join= "\n::stop_\(nomsu "var_to_lua_identifier" [%var])::;"
if (%stop_labels != ""): ".."
|do --for-loop label scope
|\(%code)\(%stop_labels)
|end --for-loop label scope
do --for-loop label scope
\(%code)\(%stop_labels)
end --for-loop label scope
..else: %code
parse [for all %iterable %body] as: for % in %iterable %body
@ -133,15 +133,15 @@ compile [when %body] to code:
%first = (yes)
for %func_call in (%body's "value"):
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")
%star = (%tokens -> 1)
assert (=lua "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)
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)
if (%action == (nil)):
@ -150,18 +150,18 @@ compile [when %body] to code:
if (=lua "vars.condition.type == 'Word' and vars.condition.value == 'else'"):
%result join= ".."
|
|else
|\(%action as lua statements)
else
\(%action as lua statements)
stop for-loop
..else:
%condition = (%condition as lua)
for all %fallthroughs:
%condition join= " or \(% as lua)"
%result join= ".."
|
|\("if" if %first else "elseif") \(%condition) then
|\(%action as lua statements)
\("if" if %first else "elseif") \(%condition) then
\(%action as lua statements)
%fallthroughs = []
%first = (no)
@ -177,15 +177,15 @@ compile [when %branch_value == ? %body] to code:
%first = (yes)
for %func_call in (%body's "value"):
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")
%star = (%tokens -> 1)
assert (=lua "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)
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)
if (%action == (nil)):
@ -194,28 +194,28 @@ compile [when %branch_value == ? %body] to code:
if (=lua "vars.condition.type == 'Word' and vars.condition.value == 'else'"):
%result join= ".."
|
|else
|\(%action as lua statements)
else
\(%action as lua statements)
stop for-loop
..else:
%condition = "branch_value == (\(%condition as lua))"
for all %fallthroughs:
%condition join= " or (branch_value == \(% as lua))"
%result join= ".."
|
|\("if" if %first else "elseif") \(%condition) then
|\(%action as lua statements)
\("if" if %first else "elseif") \(%condition) then
\(%action as lua statements)
%fallthroughs = []
%first = (no)
if (%result != ""):
%result = ".."
|do --when == ?
|local branch_value = \(%branch_value as lua);\(%result)
|end
|end --when == ?
do --when == ?
local branch_value = \(%branch_value as lua);\(%result)
end
end --when == ?
%result
# Try/except
@ -223,21 +223,21 @@ compile [..]
try %action and if it succeeds %success or if it fails %fallback
try %action and if it fails %fallback or if it succeeds %success
..to code: ".."
|do
| local fell_through = false;
| local ok, ret1, ret2 = pcall(function(nomsu, vars)
| \(%action as lua statements)
| fell_through = true;
| end, nomsu, vars);
| if ok then
| \(%success as lua statements)
| end
| if not ok then
| \(%fallback as lua statements)
| elseif not fell_through then
| return ret1, ret2;
| end
|end
do
local fell_through = false;
local ok, ret1, ret2 = pcall(function(nomsu, vars)
\(%action as lua statements)
fell_through = true;
end, nomsu, vars);
if ok then
\(%success as lua statements)
end
if not ok then
\(%fallback as lua statements)
elseif not fell_through then
return ret1, ret2;
end
end
parse [try %action] as:
try %action and if it succeeds {pass} or if it fails {pass}
parse [try %action and if it fails %fallback] as:
@ -247,19 +247,19 @@ parse [try %action and if it succeeds %success] as:
# Do/finally:
compile [do %action then always %final_action] to code: ".."
|do
| local fell_through = false;
| local ok, ret1, ret2 = pcall(function(nomsu, vars)
| \(%action as lua statements)
| fell_through = true;
| end, nomsu, vars);
| local ok2, _ = pcall(function(nomsu, vars)
| \(%final_action as lua statements)
| end, nomsu, vars);
| if not ok then nomsu:error(ret1); end
| if not ok2 then nomsu:error(ret2); end
| if not fell_through then
| return ret1, ret2;
| end
|end
do
local fell_through = false;
local ok, ret1, ret2 = pcall(function(nomsu, vars)
\(%action as lua statements)
fell_through = true;
end, nomsu, vars);
local ok2, _ = pcall(function(nomsu, vars)
\(%final_action as lua statements)
end, nomsu, vars);
if not ok then nomsu:error(ret1); end
if not ok2 then nomsu:error(ret2); end
if not fell_through then
return ret1, ret2;
end
end

145
lib/metaprogramming.nom
View File

@ -4,66 +4,67 @@
# Rule to make rules:
lua> ".."
|nomsu:defmacro("rule %signature = %body", (function(nomsu, vars)
| local signature = {};
| for i, alias in ipairs(nomsu:typecheck(vars, "signature", "List").value) do
| signature[i] = alias.src;
| end
| local body = nomsu:typecheck(vars, "body", "Thunk");
| local src = nomsu:source_code(0);
| return nil, ([[
|nomsu:def(%s, %s, %s)
|]]):format(nomsu:repr(signature), nomsu:tree_to_lua(body), nomsu:repr(nomsu:dedent(src)));
|end), \(__src__ 1));
nomsu:defmacro("rule %signature = %body", (function(nomsu, vars)
local signature = {};
for i, alias in ipairs(nomsu:typecheck(vars, "signature", "List").value) do
signature[i] = alias.src;
end
local body = nomsu:typecheck(vars, "body", "Thunk");
local src = nomsu:source_code(0);
return nil, ([[
nomsu:def(%s, %s, %s)
]]):format(nomsu:repr(signature), nomsu:tree_to_lua(body), nomsu:repr(nomsu:dedent(src)));
end), \(__src__ 1));
# Rule to make lua macros:
rule [compile \%macro_def to \%body] =:
lua> ".."
|local signature = {};
|for i, alias in ipairs(nomsu:typecheck(vars, "macro_def", "List").value) do
| signature[i] = alias.src;
|end
|local body = nomsu:typecheck(vars, "body", "Thunk");
|local thunk = nomsu:tree_to_value(body);
|nomsu:defmacro(signature, thunk, ("compile %s\\n..to %s"):format(vars.macro_def.src, body.src));
local signature = {};
for i, alias in ipairs(nomsu:typecheck(vars, "macro_def", "List").value) do
signature[i] = alias.src;
end
local body = nomsu:typecheck(vars, "body", "Thunk");
local thunk = nomsu:tree_to_value(body);
nomsu:defmacro(signature, thunk, ("compile %s\\n..to %s"):format(vars.macro_def.src, body.src));
rule [compile \%macro_def to code \%body] =:
lua> ".."
|local signature = {};
|for i, alias in ipairs(nomsu:typecheck(vars, "macro_def", "List").value) do
| signature[i] = alias.src;
|end
|local body = nomsu:typecheck(vars, "body", "Thunk");
|local thunk = nomsu:tree_to_value(body);
|local thunk_wrapper = function(nomsu, vars) return nil, thunk(nomsu, vars); end
|nomsu:defmacro(signature, thunk_wrapper, ("compile %s\\n..to code %s"):format(vars.macro_def.src, body.src));
local signature = {};
for i, alias in ipairs(nomsu:typecheck(vars, "macro_def", "List").value) do
signature[i] = alias.src;
end
local body = nomsu:typecheck(vars, "body", "Thunk");
local thunk = nomsu:tree_to_value(body);
local thunk_wrapper = function(nomsu, vars) return nil, thunk(nomsu, vars); end
nomsu:defmacro(signature, thunk_wrapper, ("compile %s\\n..to code %s"):format(vars.macro_def.src, body.src));
# Rule to make nomsu macros:
lua> ".."
|nomsu:defmacro("parse %shorthand as %longhand", (function(nomsu, vars)
| local signature = {};
| for i, alias in ipairs(nomsu:typecheck(vars, "shorthand", "List").value) do
| signature[i] = alias.src;
| end
| local template = {};
| for i, line in ipairs(nomsu:typecheck(vars, "longhand", "Thunk").value) do
| template[i] = nomsu:dedent(line.src);
| end
| signature, template = nomsu:repr(signature), nomsu:repr(table.concat(template, "\\n"));
| return nil, ([[
|nomsu:defmacro(%s, (function(nomsu, vars)
| local template = nomsu:parse(%s, %s);
| if #template.value == 1 then template = template.value[1]; end
| local replacement = nomsu:replaced_vars(template, vars);
| return nomsu:tree_to_lua(replacement);
|end), %s)]]):format(signature, template, nomsu:repr(vars.shorthand.line_no), nomsu:repr(nomsu:source_code(0)));
|end), \(__src__ 1));
nomsu:defmacro("parse %shorthand as %longhand", (function(nomsu, vars)
local signature = {};
for i, alias in ipairs(nomsu:typecheck(vars, "shorthand", "List").value) do
signature[i] = alias.src;
end
local template = {};
for i, line in ipairs(nomsu:typecheck(vars, "longhand", "Thunk").value) do
template[i] = nomsu:dedent(line.src);
end
signature, template = nomsu:repr(signature), nomsu:repr(table.concat(template, "\\n"));
return nil, ([[
nomsu:defmacro(%s, (function(nomsu, vars)
local template = nomsu:parse(%s, %s);
if #template.value == 1 then template = template.value[1]; end
local replacement = nomsu:replaced_vars(template, vars);
return nomsu:tree_to_lua(replacement);
end), %s)]]):format(signature, template, nomsu:repr(vars.shorthand.line_no), nomsu:repr(nomsu:source_code(0)));
end), \(__src__ 1));
rule [remove rule %stub] =:
lua> ".."
|local def = nomsu.defs[\(%stub)];
|for _, alias in ipairs(def.aliases) do
| nomsu.defs[alias] = false;
|end
local def = nomsu.defs[\(%stub)];
for _, alias in ipairs(def.aliases) do
nomsu.defs[alias] = false;
end
rule [%tree as lua] =:
=lua "nomsu:tree_to_lua(\(%tree))"
@ -81,18 +82,18 @@ parse [lua do> %block] as:
rule [%tree as lua statement] =:
lua do> ".."
|local _,statement = nomsu:tree_to_lua(\(%tree));
|return statement;
local _,statement = nomsu:tree_to_lua(\(%tree));
return statement;
rule [%tree as lua statements] =:
lua do> ".."
|local lua_bits = {};
|local statements = nomsu:typecheck(vars, "tree", "Thunk").value;
|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");
local lua_bits = {};
local statements = nomsu:typecheck(vars, "tree", "Thunk").value;
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's %key] to: "nomsu[\(%key as lua)]"
@ -104,25 +105,25 @@ parse [rule %signature] as:
# Get the source code for a function
rule [help %rule] =:
lua do> ".."
|local fn_def = nomsu.defs[nomsu:get_stub(vars.rule)]
|if not fn_def then
| nomsu:writeln("Rule not found: "..nomsu:repr(vars.rule));
|else
| nomsu:writeln(fn_def.src or "<unknown source code>");
|end
local fn_def = nomsu.defs[nomsu:get_stub(vars.rule)]
if not fn_def then
nomsu:writeln("Rule not found: "..nomsu:repr(vars.rule));
else
nomsu:writeln(fn_def.src or "<unknown source code>");
end
# Compiler tools
parse [eval %code, run %code] as: nomsu "run" [%code]
rule [source code from tree %tree] =:
lua do> ".."
|local _,_,leading_space = vars.tree.src:find("\\n(%s*)%S");
|if leading_space then
| local chunk1, chunk2 = vars.tree.src:match(":%s*([^\\n]*)(\\n.*)");
| chunk2 = chunk2:gsub("\\n"..leading_space, "\\n");
| return chunk1..chunk2.."\\n";
|else
| return vars.tree.src:match(":%s*(%S.*)").."\\n";
|end
local _,_,leading_space = vars.tree.src:find("\\n(%s*)%S");
if leading_space then
local chunk1, chunk2 = vars.tree.src:match(":%s*([^\\n]*)(\\n.*)");
chunk2 = chunk2:gsub("\\n"..leading_space, "\\n");
return chunk1..chunk2.."\\n";
else
return vars.tree.src:match(":%s*(%S.*)").."\\n";
end
parse [source code %body] as: source code from tree \%body
parse [parse tree %code] as: nomsu "tree_to_str" [\%code]

133
lib/operators.nom
View File

@ -12,21 +12,21 @@ compile [phi, PHI, golden ratio] to: "((1+math.sqrt(5))/2)"
compile [nop, pass] to code: ""
# Ternary operator
#.. Note: this uses a function instead of (condition and if_expr or else_expr)
because that breaks if %if_expr is falsey.
compile [..]
%when_true_expr if %condition else %when_false_expr
%when_true_expr if %condition otherwise %when_false_expr
%when_false_expr unless %condition else %when_true_expr
%when_false_expr unless %condition then %when_true_expr
..to: ".."
#.. Note: this uses a function instead of (condition and if_expr or else_expr)
because that breaks if %if_expr is falsey.
|(function(nomsu, vars)
| if \(%condition as lua) then
| return \(%when_true_expr as lua);
| else
| return \(%when_false_expr as lua);
| end
|end)(nomsu, vars)
(function(nomsu, vars)
if \(%condition as lua) then
return \(%when_true_expr as lua);
else
return \(%when_false_expr as lua);
end
end)(nomsu, vars)
# Indexing:
compile [%obj'%key, %obj's %key, %obj -> %key] to: "(\(%obj as lua))[\(%key as lua)]"
@ -45,16 +45,17 @@ compile [%var mod= %val] to code: "\(%var as lua) = \(%var as lua) % \(%val as l
# Binary Operators
lua do> ".."
|local binops = {"-","/","<","<=",">",">=","^",{"===","=="},{"!==","~="},{"mod","%"}};
|for _,op in ipairs(binops) do
| local nomsu_alias = op;
| if type(op) == 'table' then;
| nomsu_alias, op = unpack(op);
| end
| nomsu:defmacro("%a "..nomsu_alias.." %b", (function(nomsu, vars)
| return "("..nomsu:tree_to_lua(vars.a).." "..op.." "..nomsu:tree_to_lua(vars.b)..")";
| end), [["(\\(%a) ]]..op..[[ \\(%b))"]]);
|end
local binops = {"-","/","<","<=",">",">=","^",{"===","=="},{"!==","~="},{"mod","%"}};
for _,op in ipairs(binops) do
local nomsu_alias = op;
if type(op) == 'table' then;
nomsu_alias, op = unpack(op);
end
nomsu:defmacro("%a "..nomsu_alias.." %b", (function(nomsu, vars)
return "("..nomsu:tree_to_lua(vars.a).." "..op.." "..nomsu:tree_to_lua(vars.b)..")";
end), [["(\\(%a) ]]..op..[[ \\(%b))"]]);
end
# 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 XOR %b] to: "bit32.bxor(\(%a as lua), \(%b as lua))"
@ -70,56 +71,56 @@ compile [%a != %b] to: "(not nomsu.utils.equivalent(\(%a as lua), \(%b as lua)))
# Commutative Operators defined for up to 8 operands
# TODO: work out solution for commutative operators using more clever macros
lua do> ".."
|local max_operands = 8;
|local comops = {"+","*","and","or"};
|for _,_op in ipairs(comops) do
| local op = _op;
| local spec = "%1 ";
| for n=2,max_operands do
| spec = spec .." "..op.." %"..tostring(n);
| nomsu:defmacro(spec, (function(nomsu, vars)
| local bits = {};
| for i=1,n do
| table.insert(bits, (nomsu:tree_to_lua(vars[tostring(i)])));
| end
| return "("..table.concat(bits, " "..op.." ")..")";
| end));
| end
|end
local max_operands = 8;
local comops = {"+","*","and","or"};
for _,_op in ipairs(comops) do
local op = _op;
local spec = "%1 ";
for n=2,max_operands do
spec = spec .." "..op.." %"..tostring(n);
nomsu:defmacro(spec, (function(nomsu, vars)
local bits = {};
for i=1,n do
table.insert(bits, (nomsu:tree_to_lua(vars[tostring(i)])));
end
return "("..table.concat(bits, " "..op.." ")..")";
end));
end
end
# Chained compairsions (e.g. x < y <= z) are defined up to 3 operands
lua do> ".."
|local max_operands = 3;
|for _,chainers in ipairs({{"<","<="},{">",">="}}) do
| local function recurse(chainers, chain)
# The 1-op versions are already more efficiently defined, and a 0-op version doesnt make sense
| if #chain >= 2 then;
| local spec = "%1";
| for i,op in ipairs(chain) do
| spec = spec .. " "..op.." %"..tostring(i+1);
| end
# Chained comparisons need to be functions to avoid re-evaluating their arguments :\
| nomsu:def(spec, function(nomsu, vars)
| for i,op in ipairs(chain) do
| local a, b, result = vars[i], vars[i+1];
| if op == "<" then; result = a < b;
| elseif op == "<=" then; result = a <= b;
| elseif op == ">" then; result = a > b;
| elseif op == ">=" then; result = a >= b; end
# Short circuit
| if not result then; return false; end
| end
| end);
| end
| if #chain + 1 >= max_operands then; return; end
| for _,c in ipairs(chainers) do
| table.insert(chain, c);
| recurse(chainers, chain);
| table.remove(chain);
| end
| end
| recurse(chainers, {});
|end
local max_operands = 3;
for _,chainers in ipairs({{"<","<="},{">",">="}}) do
local function recurse(chainers, chain)
-- The 1-op versions are already more efficiently defined, and a 0-op version doesnt make sense
if #chain >= 2 then;
local spec = "%1";
for i,op in ipairs(chain) do
spec = spec .. " "..op.." %"..tostring(i+1);
end
-- Chained comparisons need to be functions to avoid re-evaluating their arguments :
nomsu:def(spec, function(nomsu, vars)
for i,op in ipairs(chain) do
local a, b, result = vars[i], vars[i+1];
if op == "<" then; result = a < b;
elseif op == "<=" then; result = a <= b;
elseif op == ">" then; result = a > b;
elseif op == ">=" then; result = a >= b; end
-- Short circuit
if not result then; return false; end
end
end);
end
if #chain + 1 >= max_operands then; return; end
for _,c in ipairs(chainers) do
table.insert(chain, c);
recurse(chainers, chain);
table.remove(chain);
end
end
recurse(chainers, {});
end
# Unary operators
compile [- %] to: "-(\(% as lua))"

6
lib/scopes.nom
View File

@ -3,7 +3,7 @@ require "lib/operators.nom"
require "lib/control_flow.nom"
compile [<%var> = %value] to code: ".."
|nomsu.defs['#vars'][\(repr (%var's "value"))] = \(%value as lua);
nomsu.defs['#vars'][\(repr (%var's "value"))] = \(%value as lua);
compile [<%var>] to: "nomsu.defs['#vars'][\(repr (%var's "value"))]"
@ -17,8 +17,8 @@ parse [using %scoped do %actions] as:
with (nomsu's "defs") = %scope:
do %scoped
lua> ".."
|getmetatable(nomsu.defs).__newindex = getmetatable(nomsu.defs).__index;
|getmetatable(nomsu.defs["#vars"]).__newindex = getmetatable(nomsu.defs["#vars"]).__index;
getmetatable(nomsu.defs).__newindex = getmetatable(nomsu.defs).__index;
getmetatable(nomsu.defs["#vars"]).__newindex = getmetatable(nomsu.defs["#vars"]).__index;
do %actions
parse [scoped %actions] as: using %actions do {pass}

95
lib/utils.nom
View File

@ -6,17 +6,18 @@ rule [error!, panic!, fail!, abort!] =:
rule [error %msg] =:
nomsu "error"[%msg]
compile [assert %condition %msg] to code: ".."
|if not (\(%condition as lua)) then
| nomsu:error(\(%msg as lua))
|end
if not (\(%condition as lua)) then
nomsu:error(\(%msg as lua))
end
parse [assert %condition] as: assert %condition (nil)
# String functions
rule [join %strs with glue %glue] =:
lua do> ".."
|local str_bits = {}
|for i,bit in ipairs(vars.strs) do str_bits[i] = nomsu:stringify(bit) end
|return table.concat(str_bits, vars.glue)
local str_bits = {}
for i,bit in ipairs(vars.strs) do str_bits[i] = nomsu:stringify(bit) end
return table.concat(str_bits, vars.glue)
parse [join %strs] as: join %strs with glue ""
compile [capitalize %str, %str capitalized] to:
@ -29,13 +30,14 @@ compile [%str with %patt replaced with %sub %n times, %str s/%patt/%sub/%n] to:
# Number ranges
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
# Random functions
lua> ".." # Seed
|math.randomseed(os.time());
|for i=1,20 do; math.random(); end;
math.randomseed(os.time());
for i=1,20 do; math.random(); end;
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 from %low to %high, random number from %low to %high, rand %low %high] to:
@ -81,52 +83,43 @@ compile [min of %items, smallest of %items, lowest of %items] to:
"nomsu.utils.min(\(%items as lua))"
compile [max of %items, biggest of %items, largest of %items, highest of %items] to:
"nomsu.utils.max(\(%items as lua))"
compile [min of %items by %value_expr] to:
".."
|nomsu.utils.min(\(%items as lua), function(item)
| local vars = setmetatable({['']=item}, {__index=vars})
| return \(%value_expr as lua)
|end)
compile [max of %items by %value_expr] to:
".."
|nomsu.utils.max(\(%items as lua), function(item)
| local vars = setmetatable({['']=item}, {__index=vars})
| return \(%value_expr as lua)
|end)
compile [min of %items by %value_expr] to: ".."
nomsu.utils.min(\(%items as lua), function(item)
local vars = setmetatable({['']=item}, {__index=vars})
return \(%value_expr as lua)
end)
compile [max of %items by %value_expr] to: ".."
nomsu.utils.max(\(%items as lua), function(item)
local vars = setmetatable({['']=item}, {__index=vars})
return \(%value_expr as lua)
end)
compile [sort %items] to: "table.sort(\(%items as lua))"
rule [sort %items by %key] =: =lua ".."
|nomsu.utils.sort(\(%items), function(x)
| return (\(%key))(nomsu, {['']=x});
|end)
nomsu.utils.sort(\(%items), function(x)
return (\(%key))(nomsu, {['']=x});
end)
# String utilities
compile [nl, newline, line feed, linefeed, lf] to: ".."
|"\n"
compile [tab] to: ".."
|"\t"
compile [bell] to: ".."
|"\a"
compile [cr, carriage return] to: ".."
|"\r"
compile [backspace] to: ".."
|"\b"
compile [form feed, formfeed] to: ".."
|"\f"
compile [vertical tab] to: ".."
|"\v"
compile [nl, newline, line feed, linefeed, lf] to: "'\\n'"
compile [tab] to: "'\\t'"
compile [bell] to: "'\\a'"
compile [cr, carriage return] to: "'\\r'"
compile [backspace] to: "'\\b'"
compile [form feed, formfeed] to: "'\\f'"
compile [vertical tab] to: "'\\v'"
lua> ".."
|do;
| local colors = {
| ["reset color"] = 0, bright = 1, dim = 2, underscore = 4, blink = 5,
| inverse = 7, hidden = 8, black = 30, red = 31, green = 32, yellow = 33,
| blue = 34, magenta = 35, cyan = 36, white = 37, ["on black"] = 40,
| ["on red"] = 41, ["on green"] = 42, ["on yellow"] = 43, ["on blue"] = 44,
| ["on magenta"] = 45, ["on cyan"] = 46, ["on white"] = 47,
| };
| for name,code in pairs(colors) do;
| local escape = "\\"\\\\27["..tostring(code).."m\\""
| nomsu:defmacro(name, function() return escape end, "");
| end;
|end;
do
local colors = {
["reset color"] = 0, bright = 1, dim = 2, underscore = 4, blink = 5,
inverse = 7, hidden = 8, black = 30, red = 31, green = 32, yellow = 33,
blue = 34, magenta = 35, cyan = 36, white = 37, ["on black"] = 40,
["on red"] = 41, ["on green"] = 42, ["on yellow"] = 43, ["on blue"] = 44,
["on magenta"] = 45, ["on cyan"] = 46, ["on white"] = 47,
};
for name,code in pairs(colors) do
local escape = "\\"\\\\27["..tostring(code).."m\\""
nomsu:defmacro(name, function() return escape end, "");
end
end

28
lib/utils2.nom
View File

@ -25,7 +25,7 @@ compile [with %assignments %action] to code:
%var = (%tokens -> 1)
%eq = (%tokens -> 2)
assert (=lua "vars.eq and vars.eq.type == 'Word' and vars.eq.value == '='") ".."
|Invalid format for 'with' statement. List entries must have the form %var = (value)
Invalid format for 'with' statement. List entries must have the form %var = (value)
%value = (%tokens -> 3)
add (d{i=%i; var=%var; value=%value}) to %data
%foo = (..)
@ -34,18 +34,18 @@ compile [with %assignments %action] to code:
..for all %data
..with glue "\n "
".."
|do
| \(%foo)
| local fell_through = false;
| local ok, ret1, ret2 = pcall(function(nomsu, vars)
| \(%action as lua statements);
| fell_through = true;
| end, nomsu, vars);
| \(join ("\((%->"var") as lua) = old_value\(%->"i");" for all %data) with glue "\n ")
| if not ok then nomsu:error(ret1); end
| if not fell_through then
| return ret1, ret2;
| end
|end
do
\(%foo)
local fell_through = false;
local ok, ret1, ret2 = pcall(function(nomsu, vars)
\(%action as lua statements);
fell_through = true;
end, nomsu, vars);
\(join ("\((%->"var") as lua) = old_value\(%->"i");" for all %data) with glue "\n ")
if not ok then nomsu:error(ret1); end
if not fell_through then
return ret1, ret2;
end
end
parse [with %thing = %value %action] as: with [%thing = %value] %action

47
nomsu.lua
View File

@ -47,26 +47,32 @@ local STRING_ESCAPES = {
local indent_stack = {
0
}
local check_indent
check_indent = function(subject, end_pos, spaces)
local indent_patt = P(function(self, start)
local spaces = self:match("[ \t]*", start)
if #spaces > indent_stack[#indent_stack] then
insert(indent_stack, #spaces)
return end_pos
return start + #spaces
end
end
local check_dedent
check_dedent = function(subject, end_pos, spaces)
end)
local dedent_patt = P(function(self, start)
local spaces = self:match("[ \t]*", start)
if #spaces < indent_stack[#indent_stack] then
remove(indent_stack)
return end_pos
return start
end
end
local check_nodent
check_nodent = function(subject, end_pos, spaces)
end)
local nodent_patt = P(function(self, start)
local spaces = self:match("[ \t]*", start)
if #spaces == indent_stack[#indent_stack] then
return end_pos
return start + #spaces
end
end
end)
local gt_nodent_patt = P(function(self, start)
local spaces = self:match("[ \t]*", start)
if #spaces >= indent_stack[#indent_stack] + 4 then
return start + indent_stack[#indent_stack] + 4
end
end)
local nomsu = [=[ file <- ({{| shebang?
(ignored_line %nl)*
statements (nodent statements)*
@ -120,12 +126,12 @@ local nomsu = [=[ file <- ({{| shebang?
({~ (("\\" -> "\") / ('\"' -> '"') / ("\n" -> "
") / (!string_interpolation [^%nl"]))+ ~}
/ string_interpolation)* |} '"' }) -> String
indented_string <- ({ '".."' indent {|
indented_string_line (nodent {~ "" -> "
" ~} indented_string_line)*
|} (dedent / (({.+} ("" -> "Error while parsing String")) => error))
indented_string <- ({ '".."' %ws? line_comment? %nl %gt_nodented? {|
({~ (("\\" -> "\") / (%nl+ {~ %gt_nodented -> "" ~}) / [^%nl\]) ~} / string_interpolation)*
|} ((!.) / (&(%nl+ !%gt_nodented)) / (({.+} ("" -> "Error while parsing String")) => error))
}) -> String
indented_string_line <- "|" ({~ (("\\" -> "\") / (!string_interpolation [^%nl]))+ ~} / string_interpolation)*
string_interpolation <- "\" ((noeol_expression dotdot?) / dotdot)
number <- ({ (("-"? (([0-9]+ "." [0-9]+) / ("." [0-9]+) / ([0-9]+)))-> tonumber) }) -> Number
@ -169,9 +175,10 @@ local defs = {
tonumber = tonumber,
operator = operator,
plain_word = plain_word,
indented = Cmt(S(" \t") ^ 0 * (#(P(1) - S(" \t\n") + (-P(1)))), check_indent),
nodented = Cmt(S(" \t") ^ 0 * (#(P(1) - S(" \t\n") + (-P(1)))), check_nodent),
dedented = Cmt(S(" \t") ^ 0 * (#(P(1) - S(" \t\n") + (-P(1)))), check_dedent),
indented = indent_patt,
nodented = nodent_patt,
dedented = dedent_patt,
gt_nodented = gt_nodent_patt,
line_no = function(src, pos)
local line_no = 1
for _ in src:sub(1, pos):gmatch("\n") do

34
nomsu.moon
View File

@ -46,17 +46,25 @@ STRING_ESCAPES = n:"\n", t:"\t", b:"\b", a:"\a", v:"\v", f:"\f", r:"\r"
-- NOTE: this treats tabs as equivalent to 1 space
indent_stack = {0}
check_indent = (subject,end_pos,spaces)->
indent_patt = P (start)=>
spaces = @match("[ \t]*", start)
if #spaces > indent_stack[#indent_stack]
insert(indent_stack, #spaces)
return end_pos
check_dedent = (subject,end_pos,spaces)->
return start + #spaces
dedent_patt = P (start)=>
spaces = @match("[ \t]*", start)
if #spaces < indent_stack[#indent_stack]
remove(indent_stack)
return end_pos
check_nodent = (subject,end_pos,spaces)->
return start
nodent_patt = P (start)=>
spaces = @match("[ \t]*", start)
if #spaces == indent_stack[#indent_stack]
return end_pos
return start + #spaces
gt_nodent_patt = P (start)=>
-- Note! This assumes indent is 4 spaces!!!
spaces = @match("[ \t]*", start)
if #spaces >= indent_stack[#indent_stack] + 4
return start + indent_stack[#indent_stack] + 4
-- TYPES:
-- Number 1, "String", %Var, [List], (expression), {Thunk}, \Nomsu, FunctionCall, File
@ -115,12 +123,12 @@ nomsu = [=[
({~ (("\\" -> "\") / ('\"' -> '"') / ("\n" -> "
") / (!string_interpolation [^%nl"]))+ ~}
/ string_interpolation)* |} '"' }) -> String
indented_string <- ({ '".."' indent {|
indented_string_line (nodent {~ "" -> "
" ~} indented_string_line)*
|} (dedent / (({.+} ("" -> "Error while parsing String")) => error))
indented_string <- ({ '".."' %ws? line_comment? %nl %gt_nodented? {|
({~ (("\\" -> "\") / (%nl+ {~ %gt_nodented -> "" ~}) / [^%nl\]) ~} / string_interpolation)*
|} ((!.) / (&(%nl+ !%gt_nodented)) / (({.+} ("" -> "Error while parsing String")) => error))
}) -> String
indented_string_line <- "|" ({~ (("\\" -> "\") / (!string_interpolation [^%nl]))+ ~} / string_interpolation)*
string_interpolation <- "\" ((noeol_expression dotdot?) / dotdot)
number <- ({ (("-"? (([0-9]+ "." [0-9]+) / ("." [0-9]+) / ([0-9]+)))-> tonumber) }) -> Number
@ -164,9 +172,7 @@ utf8_char = (
plain_word = (R('az','AZ','09') + S("_") + utf8_char)^1
defs =
ws:whitespace, nl: P("\n"), :tonumber, :operator, :plain_word
indented: Cmt(S(" \t")^0 * (#(P(1)-S(" \t\n") + (-P(1)))), check_indent)
nodented: Cmt(S(" \t")^0 * (#(P(1)-S(" \t\n") + (-P(1)))), check_nodent)
dedented: Cmt(S(" \t")^0 * (#(P(1)-S(" \t\n") + (-P(1)))), check_dedent)
indented: indent_patt, nodented: nodent_patt, dedented: dedent_patt, gt_nodented: gt_nodent_patt
line_no: (src, pos)->
line_no = 1
for _ in src\sub(1,pos)\gmatch("\n") do line_no += 1