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): ... # Dict iteration convenience function. This could also be accomplished with: for all (entries in %dict): ...
compile [for %key = %value in %dict %body] to code: ".." compile [for %key = %value in %dict %body] to code: ".."
|do; do
| for k, v in pairs(\(%dict as lua)) do; for k, v in pairs(\(%dict as lua)) do
| \(%key as lua), \(%value as lua) = k, v; \(%key as lua), \(%value as lua) = k, v;
| \(%body as lua statements) \(%body as lua statements)
| end; end
|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] =:
@ -43,7 +43,7 @@ rule [..]
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
@ -56,7 +56,7 @@ compile [length of %list, size of %list, size %list, number of %list, len %list]
# 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)]"
@ -98,20 +98,20 @@ compile [dict %items, d %items] to:
%item_codes = [] %item_codes = []
for %func_call in (%items's "value"): for %func_call in (%items's "value"):
assert ((%func_call's "type") == "FunctionCall") ".." 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") %tokens = (%func_call's "value")
%equals = (%tokens -> 2) %equals = (%tokens -> 2)
assert (=lua "#\(%tokens) == 3 and \(%equals) and \(%equals).type == 'Word' and \(%equals).value == '='") ".." 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) %key = (%tokens -> 1)
lua> ".." lua> ".."
|if \(%key).type == "Word" and \(%key).value:match("^[a-zA-Z_][a-zA-Z0-9_]*$") then if \(%key).type == "Word" and \(%key).value:match("^[a-zA-Z_][a-zA-Z0-9_]*$") then
| \(%key_code) = \(%key).value; \(%key_code) = \(%key).value;
|elseif \(%key).type == "Word" then elseif \(%key).type == "Word" then
| \(%key_code) = "["..nomsu:repr(\(%key).value).."]"; \(%key_code) = "["..nomsu:repr(\(%key).value).."]";
|else else
| \(\{%key_code = "[\((%key as lua))]"} as lua statements) \(\{%key_code = "[\((%key as lua))]"} as lua statements)
|end end
add "\(%key_code) = \((%tokens -> 3) as lua)" to %item_codes add "\(%key_code) = \((%tokens -> 3) as lua)" to %item_codes
return "{\(join %item_codes with glue ",\n")}" return "{\(join %item_codes with glue ",\n")}"
..else: ..else:
@ -139,16 +139,16 @@ rule [values in %dict] =:
# 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
rule [%items sorted] =: rule [%items sorted] =:
@ -165,11 +165,11 @@ rule [unique %items] =:
# Metatable stuff # Metatable stuff
compile [counter] to: "setmetatable({}, {__index=function() return 0; end})" compile [counter] to: "setmetatable({}, {__index=function() return 0; end})"
compile [default dict] to: ".." compile [default dict] to: ".."
|setmetatable({}, {__index=function(self, key) setmetatable({}, {__index=function(self, key)
| t = {}; t = {};
| self[key] = t; self[key] = t;
| return t; return t;
|end})" end})"
rule [chain %dict to %fallback] =: rule [chain %dict to %fallback] =:
when (type of %fallback) == ?: when (type of %fallback) == ?:
* "table": * "table":

196
lib/control_flow.nom
View File

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

145
lib/metaprogramming.nom
View File

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

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: "" compile [nop, pass] to code: ""
# Ternary operator # 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 [..] compile [..]
%when_true_expr if %condition else %when_false_expr %when_true_expr if %condition else %when_false_expr
%when_true_expr if %condition otherwise %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 else %when_true_expr
%when_false_expr unless %condition then %when_true_expr %when_false_expr unless %condition then %when_true_expr
..to: ".." ..to: ".."
#.. Note: this uses a function instead of (condition and if_expr or else_expr) (function(nomsu, vars)
because that breaks if %if_expr is falsey. if \(%condition as lua) then
|(function(nomsu, vars) return \(%when_true_expr as lua);
| if \(%condition as lua) then else
| return \(%when_true_expr as lua); return \(%when_false_expr as lua);
| else end
| return \(%when_false_expr as lua); end)(nomsu, vars)
| end
|end)(nomsu, vars)
# Indexing: # Indexing:
compile [%obj'%key, %obj's %key, %obj -> %key] to: "(\(%obj as lua))[\(%key as lua)]" 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 # Binary Operators
lua do> ".." lua do> ".."
|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))"
@ -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 # 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 do> ".." lua do> ".."
|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 do> ".." lua do> ".."
|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))"

6
lib/scopes.nom
View File

@ -3,7 +3,7 @@ require "lib/operators.nom"
require "lib/control_flow.nom" require "lib/control_flow.nom"
compile [<%var> = %value] to code: ".." 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"))]" 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: with (nomsu's "defs") = %scope:
do %scoped do %scoped
lua> ".." lua> ".."
|getmetatable(nomsu.defs).__newindex = getmetatable(nomsu.defs).__index; getmetatable(nomsu.defs).__newindex = getmetatable(nomsu.defs).__index;
|getmetatable(nomsu.defs["#vars"]).__newindex = getmetatable(nomsu.defs["#vars"]).__index; getmetatable(nomsu.defs["#vars"]).__newindex = getmetatable(nomsu.defs["#vars"]).__index;
do %actions do %actions
parse [scoped %actions] as: using %actions do {pass} 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] =: 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 do> ".." lua do> ".."
|local str_bits = {} local str_bits = {}
|for i,bit in ipairs(vars.strs) do str_bits[i] = nomsu:stringify(bit) end for i,bit in ipairs(vars.strs) do str_bits[i] = nomsu:stringify(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:
@ -29,13 +30,14 @@ compile [%str with %patt replaced with %sub %n times, %str s/%patt/%sub/%n] to:
# 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
lua> ".." # Seed lua> ".." # Seed
|math.randomseed(os.time()); math.randomseed(os.time());
|for i=1,20 do; math.random(); end; for i=1,20 do; math.random(); end;
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:
@ -81,52 +83,43 @@ 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)
".." local vars = setmetatable({['']=item}, {__index=vars})
|nomsu.utils.max(\(%items as lua), function(item) return \(%value_expr as lua)
| local vars = setmetatable({['']=item}, {__index=vars}) end)
| return \(%value_expr as lua)
|end)
compile [sort %items] to: "table.sort(\(%items as lua))" compile [sort %items] to: "table.sort(\(%items as lua))"
rule [sort %items by %key] =: =lua ".." rule [sort %items by %key] =: =lua ".."
|nomsu.utils.sort(\(%items), function(x) nomsu.utils.sort(\(%items), function(x)
| return (\(%key))(nomsu, {['']=x}); return (\(%key))(nomsu, {['']=x});
|end) end)
# String utilities # String utilities
compile [nl, newline, line feed, linefeed, lf] to: ".." compile [nl, newline, line feed, linefeed, lf] to: "'\\n'"
|"\n" compile [tab] to: "'\\t'"
compile [tab] to: ".." compile [bell] to: "'\\a'"
|"\t" compile [cr, carriage return] to: "'\\r'"
compile [bell] to: ".." compile [backspace] to: "'\\b'"
|"\a" compile [form feed, formfeed] to: "'\\f'"
compile [cr, carriage return] to: ".." compile [vertical tab] to: "'\\v'"
|"\r"
compile [backspace] to: ".."
|"\b"
compile [form feed, formfeed] to: ".."
|"\f"
compile [vertical tab] to: ".."
|"\v"
lua> ".." lua> ".."
|do; do
| local colors = { local colors = {
| ["reset color"] = 0, bright = 1, dim = 2, underscore = 4, blink = 5, ["reset color"] = 0, bright = 1, dim = 2, underscore = 4, blink = 5,
| inverse = 7, hidden = 8, black = 30, red = 31, green = 32, yellow = 33, inverse = 7, hidden = 8, black = 30, red = 31, green = 32, yellow = 33,
| blue = 34, magenta = 35, cyan = 36, white = 37, ["on black"] = 40, blue = 34, magenta = 35, cyan = 36, white = 37, ["on black"] = 40,
| ["on red"] = 41, ["on green"] = 42, ["on yellow"] = 43, ["on blue"] = 44, ["on red"] = 41, ["on green"] = 42, ["on yellow"] = 43, ["on blue"] = 44,
| ["on magenta"] = 45, ["on cyan"] = 46, ["on white"] = 47, ["on magenta"] = 45, ["on cyan"] = 46, ["on white"] = 47,
| }; };
| for name,code in pairs(colors) do; for name,code in pairs(colors) do
| local escape = "\\"\\\\27["..tostring(code).."m\\"" local escape = "\\"\\\\27["..tostring(code).."m\\""
| nomsu:defmacro(name, function() return escape end, ""); nomsu:defmacro(name, function() return escape end, "");
| end; end
|end; end

28
lib/utils2.nom
View File

@ -25,7 +25,7 @@ compile [with %assignments %action] to code:
%var = (%tokens -> 1) %var = (%tokens -> 1)
%eq = (%tokens -> 2) %eq = (%tokens -> 2)
assert (=lua "vars.eq and vars.eq.type == 'Word' and vars.eq.value == '='") ".." 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) %value = (%tokens -> 3)
add (d{i=%i; var=%var; value=%value}) to %data add (d{i=%i; var=%var; value=%value}) to %data
%foo = (..) %foo = (..)
@ -34,18 +34,18 @@ compile [with %assignments %action] to code:
..for all %data ..for all %data
..with glue "\n " ..with glue "\n "
".." ".."
|do do
| \(%foo) \(%foo)
| local fell_through = false; local fell_through = false;
| local ok, ret1, ret2 = pcall(function(nomsu, vars) local ok, ret1, ret2 = pcall(function(nomsu, vars)
| \(%action as lua statements); \(%action as lua statements);
| fell_through = true; fell_through = true;
| end, nomsu, vars); end, nomsu, vars);
| \(join ("\((%->"var") as lua) = old_value\(%->"i");" for all %data) with glue "\n ") \(join ("\((%->"var") as lua) = old_value\(%->"i");" for all %data) with glue "\n ")
| if not ok then nomsu:error(ret1); end if not ok then nomsu:error(ret1); end
| if not fell_through then if not fell_through then
| return ret1, ret2; return ret1, ret2;
| end end
|end end
parse [with %thing = %value %action] as: with [%thing = %value] %action 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 = { local indent_stack = {
0 0
} }
local check_indent local indent_patt = P(function(self, start)
check_indent = function(subject, end_pos, spaces) local spaces = self:match("[ \t]*", start)
if #spaces > indent_stack[#indent_stack] then if #spaces > indent_stack[#indent_stack] then
insert(indent_stack, #spaces) insert(indent_stack, #spaces)
return end_pos return start + #spaces
end end
end end)
local check_dedent local dedent_patt = P(function(self, start)
check_dedent = function(subject, end_pos, spaces) local spaces = self:match("[ \t]*", start)
if #spaces < indent_stack[#indent_stack] then if #spaces < indent_stack[#indent_stack] then
remove(indent_stack) remove(indent_stack)
return end_pos return start
end end
end end)
local check_nodent local nodent_patt = P(function(self, start)
check_nodent = function(subject, end_pos, spaces) local spaces = self:match("[ \t]*", start)
if #spaces == indent_stack[#indent_stack] then if #spaces == indent_stack[#indent_stack] then
return end_pos return start + #spaces
end 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? local nomsu = [=[ file <- ({{| shebang?
(ignored_line %nl)* (ignored_line %nl)*
statements (nodent statements)* statements (nodent statements)*
@ -120,12 +126,12 @@ local nomsu = [=[ file <- ({{| shebang?
({~ (("\\" -> "\") / ('\"' -> '"') / ("\n" -> " ({~ (("\\" -> "\") / ('\"' -> '"') / ("\n" -> "
") / (!string_interpolation [^%nl"]))+ ~} ") / (!string_interpolation [^%nl"]))+ ~}
/ string_interpolation)* |} '"' }) -> String / string_interpolation)* |} '"' }) -> String
indented_string <- ({ '".."' indent {|
indented_string_line (nodent {~ "" -> " indented_string <- ({ '".."' %ws? line_comment? %nl %gt_nodented? {|
" ~} indented_string_line)* ({~ (("\\" -> "\") / (%nl+ {~ %gt_nodented -> "" ~}) / [^%nl\]) ~} / string_interpolation)*
|} (dedent / (({.+} ("" -> "Error while parsing String")) => error)) |} ((!.) / (&(%nl+ !%gt_nodented)) / (({.+} ("" -> "Error while parsing String")) => error))
}) -> String }) -> String
indented_string_line <- "|" ({~ (("\\" -> "\") / (!string_interpolation [^%nl]))+ ~} / string_interpolation)*
string_interpolation <- "\" ((noeol_expression dotdot?) / 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
@ -169,9 +175,10 @@ local defs = {
tonumber = tonumber, tonumber = tonumber,
operator = operator, operator = operator,
plain_word = plain_word, plain_word = plain_word,
indented = Cmt(S(" \t") ^ 0 * (#(P(1) - S(" \t\n") + (-P(1)))), check_indent), indented = indent_patt,
nodented = Cmt(S(" \t") ^ 0 * (#(P(1) - S(" \t\n") + (-P(1)))), check_nodent), nodented = nodent_patt,
dedented = Cmt(S(" \t") ^ 0 * (#(P(1) - S(" \t\n") + (-P(1)))), check_dedent), dedented = dedent_patt,
gt_nodented = gt_nodent_patt,
line_no = function(src, pos) line_no = function(src, pos)
local line_no = 1 local line_no = 1
for _ in src:sub(1, pos):gmatch("\n") do 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 -- NOTE: this treats tabs as equivalent to 1 space
indent_stack = {0} indent_stack = {0}
check_indent = (subject,end_pos,spaces)-> indent_patt = P (start)=>
spaces = @match("[ \t]*", start)
if #spaces > indent_stack[#indent_stack] if #spaces > indent_stack[#indent_stack]
insert(indent_stack, #spaces) insert(indent_stack, #spaces)
return end_pos return start + #spaces
check_dedent = (subject,end_pos,spaces)-> dedent_patt = P (start)=>
spaces = @match("[ \t]*", start)
if #spaces < indent_stack[#indent_stack] if #spaces < indent_stack[#indent_stack]
remove(indent_stack) remove(indent_stack)
return end_pos return start
check_nodent = (subject,end_pos,spaces)-> nodent_patt = P (start)=>
spaces = @match("[ \t]*", start)
if #spaces == indent_stack[#indent_stack] 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: -- TYPES:
-- Number 1, "String", %Var, [List], (expression), {Thunk}, \Nomsu, FunctionCall, File -- Number 1, "String", %Var, [List], (expression), {Thunk}, \Nomsu, FunctionCall, File
@ -115,12 +123,12 @@ nomsu = [=[
({~ (("\\" -> "\") / ('\"' -> '"') / ("\n" -> " ({~ (("\\" -> "\") / ('\"' -> '"') / ("\n" -> "
") / (!string_interpolation [^%nl"]))+ ~} ") / (!string_interpolation [^%nl"]))+ ~}
/ string_interpolation)* |} '"' }) -> String / string_interpolation)* |} '"' }) -> String
indented_string <- ({ '".."' indent {|
indented_string_line (nodent {~ "" -> " indented_string <- ({ '".."' %ws? line_comment? %nl %gt_nodented? {|
" ~} indented_string_line)* ({~ (("\\" -> "\") / (%nl+ {~ %gt_nodented -> "" ~}) / [^%nl\]) ~} / string_interpolation)*
|} (dedent / (({.+} ("" -> "Error while parsing String")) => error)) |} ((!.) / (&(%nl+ !%gt_nodented)) / (({.+} ("" -> "Error while parsing String")) => error))
}) -> String }) -> String
indented_string_line <- "|" ({~ (("\\" -> "\") / (!string_interpolation [^%nl]))+ ~} / string_interpolation)*
string_interpolation <- "\" ((noeol_expression dotdot?) / 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
@ -164,9 +172,7 @@ utf8_char = (
plain_word = (R('az','AZ','09') + S("_") + utf8_char)^1 plain_word = (R('az','AZ','09') + S("_") + utf8_char)^1
defs = defs =
ws:whitespace, nl: P("\n"), :tonumber, :operator, :plain_word ws:whitespace, nl: P("\n"), :tonumber, :operator, :plain_word
indented: Cmt(S(" \t")^0 * (#(P(1)-S(" \t\n") + (-P(1)))), check_indent) indented: indent_patt, nodented: nodent_patt, dedented: dedent_patt, gt_nodented: gt_nodent_patt
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)
line_no: (src, pos)-> line_no: (src, pos)->
line_no = 1 line_no = 1
for _ in src\sub(1,pos)\gmatch("\n") do line_no += 1 for _ in src\sub(1,pos)\gmatch("\n") do line_no += 1