Removed some unnecessary semicolons on keywords.
This commit is contained in:
Bruce Hill
parent
2197da3028
commit
60a85bbd8b
@ -4,24 +4,24 @@ require "lib/utils.nom"
|
||||
|
||||
# Conditionals
|
||||
compile [if %condition %if_body] to code: ".."
|
||||
|if \(%condition as lua) then;
|
||||
|if \(%condition as lua) then
|
||||
|\(%if_body as lua statements)
|
||||
|end;--end if
|
||||
|end --end if
|
||||
compile [unless %condition %body] to code: ".."
|
||||
|if not (\(%condition as lua)) then;
|
||||
|if not (\(%condition as lua)) then
|
||||
|\(%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: ".."
|
||||
|if \(%condition as lua) then;
|
||||
|if \(%condition as lua) then
|
||||
|\(%if_body as lua statements)
|
||||
|else;
|
||||
|else
|
||||
|\(%else_body as lua statements)
|
||||
|end;--end if
|
||||
|end --end if
|
||||
|
||||
# Return
|
||||
compile [return] to code: "do; return; end;"
|
||||
compile [return %return_value] to code: "do; return \(%return_value as lua); end;"
|
||||
compile [return] to code: "do return; end"
|
||||
compile [return %return_value] to code: "do return \(%return_value as lua); end"
|
||||
|
||||
# GOTOs
|
||||
compile [-> %label] to code: ".."
|
||||
@ -32,13 +32,13 @@ compile [go to %label] to code: ".."
|
||||
rule [tree %tree has function call %call] =:
|
||||
lua> ".."
|
||||
|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"
|
||||
| and nomsu.utils.equivalent(subtree.value, target, 2) then;
|
||||
| and nomsu.utils.equivalent(subtree.value, target, 2) then
|
||||
| return true;
|
||||
| end;
|
||||
|end;
|
||||
|do; return false; end;
|
||||
| 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;
|
||||
|while \(%condition as lua) do
|
||||
|\(%body as lua statements)\(%continue_labels)
|
||||
|end;--while-loop
|
||||
|end --while-loop
|
||||
if (tree %body has function call \(stop repeat-loop)):
|
||||
return ".."
|
||||
|do;--while-loop label scope
|
||||
|do --while-loop label scope
|
||||
|\(%code)
|
||||
|::stop_repeat::;
|
||||
|end;--while-loop label scope
|
||||
|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
|
||||
@ -79,20 +79,20 @@ compile [..]
|
||||
if (tree %body has function call (nomsu "replaced_vars" [\(do next %), =lua "{['']=\(%var)}"])):
|
||||
%continue_labels join= "\n::continue_\(nomsu "var_to_lua_identifier" [%var])::;"
|
||||
%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;
|
||||
|\(%body as lua statements)\(%continue_labels)
|
||||
|end;--numeric for-loop
|
||||
|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
|
||||
|do --for-loop label scope
|
||||
|\(%code)\(%stop_labels)
|
||||
|end;--for-loop label scope
|
||||
|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 [..]
|
||||
@ -108,20 +108,20 @@ compile [for %var in %iterable %body] to code:
|
||||
if (tree %body has function call (nomsu "replaced_vars" [\(do next %), =lua "{['']=\(%var)}"])):
|
||||
%continue_labels join= "\n::continue_\(nomsu "var_to_lua_identifier" [%var])::;"
|
||||
%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;
|
||||
|\(%body as lua statements)\(%continue_labels)
|
||||
|end;--foreach-loop
|
||||
|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
|
||||
|do --for-loop label scope
|
||||
|\(%code)\(%stop_labels)
|
||||
|end;--for-loop label scope
|
||||
|end --for-loop label scope
|
||||
..else: %code
|
||||
parse [for all %iterable %body] as: for % in %iterable %body
|
||||
|
||||
@ -151,7 +151,7 @@ compile [when %body] to code:
|
||||
if (=lua "vars.condition.type == 'Word' and vars.condition.value == 'else'"):
|
||||
%result join= ".."
|
||||
|
|
||||
|else;
|
||||
|else
|
||||
|\(%action as lua statements)
|
||||
stop for-loop
|
||||
..else:
|
||||
@ -160,14 +160,14 @@ compile [when %body] to code:
|
||||
%condition join= " or \(% as lua)"
|
||||
%result join= ".."
|
||||
|
|
||||
|\("if" if %first else "elseif") \(%condition) then;
|
||||
|\("if" if %first else "elseif") \(%condition) then
|
||||
|\(%action as lua statements)
|
||||
|
||||
%fallthroughs = []
|
||||
%first = (no)
|
||||
|
||||
if (%result != ""):
|
||||
%result join= "\nend;"
|
||||
%result join= "\nend"
|
||||
%result
|
||||
|
||||
# Switch statement
|
||||
@ -195,7 +195,7 @@ compile [when %branch_value == ? %body] to code:
|
||||
if (=lua "vars.condition.type == 'Word' and vars.condition.value == 'else'"):
|
||||
%result join= ".."
|
||||
|
|
||||
|else;
|
||||
|else
|
||||
|\(%action as lua statements)
|
||||
stop for-loop
|
||||
..else:
|
||||
@ -204,7 +204,7 @@ compile [when %branch_value == ? %body] to code:
|
||||
%condition join= " or (branch_value == \(% as lua))"
|
||||
%result join= ".."
|
||||
|
|
||||
|\("if" if %first else "elseif") \(%condition) then;
|
||||
|\("if" if %first else "elseif") \(%condition) then
|
||||
|\(%action as lua statements)
|
||||
|
||||
%fallthroughs = []
|
||||
@ -212,17 +212,17 @@ compile [when %branch_value == ? %body] to code:
|
||||
|
||||
if (%result != ""):
|
||||
%result = ".."
|
||||
|do;--when == ?
|
||||
|do --when == ?
|
||||
|local branch_value = \(%branch_value as lua);\(%result)
|
||||
|end;
|
||||
|end;--when == ?
|
||||
|end
|
||||
|end --when == ?
|
||||
%result
|
||||
|
||||
# With statement
|
||||
compile [with %thing = %value %action] to code: ".."
|
||||
|do;
|
||||
|do
|
||||
| local old_value = \(%thing as lua);
|
||||
| \(%thing as lua) = \(%value as lua);
|
||||
| \(%action as lua statements);
|
||||
| \(%thing as lua) = old_value;
|
||||
|end;
|
||||
|end
|
||||
|
||||
@ -19,20 +19,20 @@ rule [escaped parse %shorthand as %longhand] =:
|
||||
|local template = nomsu:typecheck(vars, "longhand", "Thunk").value;
|
||||
|local function parsing_as(nomsu, vars)
|
||||
# Single expression/statement
|
||||
| if #template == 1 then;
|
||||
| if #template == 1 then
|
||||
| local replacement = nomsu:replaced_vars(template[1], vars);
|
||||
| return nomsu:tree_to_lua(replacement);
|
||||
| end
|
||||
# Multiple statements
|
||||
| local lua_bits = {};
|
||||
| for _,bit in ipairs(template) do;
|
||||
| for _,bit in ipairs(template) do
|
||||
| bit = nomsu:replaced_vars(bit, vars);
|
||||
| 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;
|
||||
| if statement then table.insert(lua_bits, statement); end
|
||||
| if expr then table.insert(lua_bits, "ret = "..expr..";"); end
|
||||
| end
|
||||
| return nil, table.concat(lua_bits, "\\n");
|
||||
|end;
|
||||
|end
|
||||
|nomsu:defmacro(aliases, parsing_as, template.src);
|
||||
escaped parse \[parse %shorthand as %longhand] as \: escaped parse \%shorthand as \%longhand
|
||||
|
||||
@ -48,7 +48,7 @@ rule [escaped compile %macro_def to code %body] =:
|
||||
|local aliases = nomsu:get_stubs(nomsu:typecheck(vars, "macro_def", "List").value);
|
||||
|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;
|
||||
|local thunk_wrapper = function(nomsu, vars) return nil, thunk(nomsu, vars); end
|
||||
|nomsu:defmacro(aliases, thunk_wrapper, body.src);
|
||||
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
|
||||
@ -66,9 +66,9 @@ compile [type %obj, type of %obj] to:
|
||||
"type(\(%obj as lua))"
|
||||
|
||||
parse [lua do> %block] as:
|
||||
lua> "do;"
|
||||
lua> "do"
|
||||
lua> %block
|
||||
lua> "end;"
|
||||
lua> "end"
|
||||
rule [%tree as lua statement] =:
|
||||
lua do> ".."
|
||||
|local _,statement = nomsu:tree_to_lua(\(%tree));
|
||||
@ -77,11 +77,11 @@ rule [%tree as lua statements] =:
|
||||
lua do> ".."
|
||||
|local lua_bits = {};
|
||||
|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);
|
||||
| if statement then; table.insert(lua_bits, statement); end;
|
||||
| if expr then; table.insert(lua_bits, "ret = "..expr..";"); end;
|
||||
|end;
|
||||
| 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"
|
||||
@ -92,27 +92,27 @@ compile [nomsu %method %args] to: "nomsu[\(%method as lua)](nomsu, unpack(\(%arg
|
||||
rule [help %rule] =:
|
||||
lua do> ".."
|
||||
|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));
|
||||
|else;
|
||||
|else
|
||||
| local template = fn_def.is_macro and "compile %s to%s" or "rule %s =%s";
|
||||
| local src = fn_def.src or ":\\n <unknown source code>";
|
||||
| if src:sub(1,1) ~= ":" and fn_def.is_macro then; template = "parse %s as: %s"; end;
|
||||
| if src:sub(1,1) ~= ":" and fn_def.is_macro then template = "parse %s as: %s"; end
|
||||
| nomsu:writeln(template:format(nomsu:repr(fn_def.stub), src));
|
||||
|end;
|
||||
|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;
|
||||
|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;
|
||||
|else
|
||||
| return vars.tree.src:match(":%s*(%S.*)").."\\n";
|
||||
|end;
|
||||
|end
|
||||
parse [source code %body] as: source code from tree \%body
|
||||
|
||||
parse [parse tree %code] as: nomsu "tree_to_str" [\%code]
|
||||
|
||||
@ -6,13 +6,13 @@ parse [moonscript do> %moonscript_code] as:
|
||||
|local parse, compile = require('moonscript.parse'), require('moonscript.compile');
|
||||
|local moon_code = nomsu:tree_to_value(vars.moonscript_code, vars);
|
||||
|local tree, err = parse.string(moon_code);
|
||||
|if not tree then;
|
||||
|if not tree then
|
||||
| nomsu:error("Failed to parse moonscript: "..err);
|
||||
|end;
|
||||
|end
|
||||
|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));
|
||||
|end;
|
||||
|end
|
||||
|return "do\\n"..lua_code.."\\nend";
|
||||
|
||||
parse [moonscript> %moonscript_code] as:
|
||||
@ -20,11 +20,11 @@ parse [moonscript> %moonscript_code] as:
|
||||
|local parse, compile = require('moonscript.parse'), require('moonscript.compile');
|
||||
|local moon_code = nomsu:tree_to_value(vars.moonscript_code, vars);
|
||||
|local tree, err = parse.string(moon_code);
|
||||
|if not tree then;
|
||||
|if not tree then
|
||||
| nomsu:error("Failed to parse moonscript: "..err);
|
||||
|end;
|
||||
|end
|
||||
|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));
|
||||
|end;
|
||||
|end
|
||||
|return "(function(nomsu, vars)\\n"..lua_code.."\\nend)(nomsu, vars)";
|
||||
|
||||
@ -21,11 +21,11 @@ compile [..]
|
||||
#.. 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;
|
||||
| if \(%condition as lua) then
|
||||
| return \(%when_true_expr as lua);
|
||||
| else;
|
||||
| else
|
||||
| return \(%when_false_expr as lua);
|
||||
| end;
|
||||
| end
|
||||
|end)(nomsu, vars)
|
||||
|
||||
# Indexing:
|
||||
@ -46,15 +46,15 @@ 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;
|
||||
|for _,op in ipairs(binops) do
|
||||
| local nomsu_alias = op;
|
||||
| if type(op) == 'table' then;
|
||||
| nomsu_alias, op = unpack(op);
|
||||
| end;
|
||||
| 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;
|
||||
|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))"
|
||||
@ -72,54 +72,54 @@ compile [%a != %b] to: "(not nomsu.utils.equivalent(\(%a as lua), \(%b as lua)))
|
||||
lua do> ".."
|
||||
|local max_operands = 8;
|
||||
|local comops = {"+","*","and","or"};
|
||||
|for _,_op in ipairs(comops) do;
|
||||
|for _,_op in ipairs(comops) do
|
||||
| local op = _op;
|
||||
| local spec = "%1 ";
|
||||
| for n=2,max_operands do;
|
||||
| for n=2,max_operands do
|
||||
| spec = spec .." "..op.." %"..tostring(n);
|
||||
| nomsu:defmacro(spec, (function(nomsu, vars)
|
||||
| local bits = {};
|
||||
| for i=1,n do;
|
||||
| for i=1,n do
|
||||
| table.insert(bits, (nomsu:tree_to_lua(vars[tostring(i)])));
|
||||
| end;
|
||||
| end
|
||||
| return "("..table.concat(bits, " "..op.." ")..")";
|
||||
| end));
|
||||
| end;
|
||||
|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;
|
||||
|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;
|
||||
| for i,op in ipairs(chain) do
|
||||
| spec = spec .. " "..op.." %"..tostring(i+1);
|
||||
| end;
|
||||
| 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;
|
||||
| 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;
|
||||
| elseif op == ">=" then; result = a >= b; end
|
||||
# Short circuit
|
||||
| if not result then; return false; end;
|
||||
| end;
|
||||
| if not result then; return false; end
|
||||
| end
|
||||
| end);
|
||||
| end;
|
||||
| if #chain + 1 >= max_operands then; return; end;
|
||||
| for _,c in ipairs(chainers) do;
|
||||
| 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;
|
||||
| end
|
||||
| end
|
||||
| recurse(chainers, {});
|
||||
|end;
|
||||
|end
|
||||
|
||||
# Unary operators
|
||||
compile [- %] to: "-(\(% as lua))"
|
||||
|
||||
@ -9,12 +9,12 @@ with secrets:
|
||||
| return key..endings[key:sub(-1)];
|
||||
|end});
|
||||
|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(-1) == "s" then; return key:sub(1,-2); 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
|
||||
| return key;
|
||||
|end});
|
||||
|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;
|
||||
|end});
|
||||
|
||||
|
||||
Loading…
Reference in New Issue
Block a user