diff --git a/lib/core.nom b/lib/core.nom index c46d4bf..3a5872a 100644 --- a/lib/core.nom +++ b/lib/core.nom @@ -167,22 +167,27 @@ lua block ".." | compiler:error("Assignment operation has the wrong type for the right hand side. " | .."Expected Thunk, but got: "..vars.rhs.type.."\\nMaybe you used '=' instead of '=:'?") | end - | local ret = "do\\n local ret" - | ret = ret .. "\\n "..compiler:tree_to_lua(vars.rhs.value, "Statement") - | ret = ret .. "\\n "..callback(compiler:tree_to_lua(vars.var, "Expression")) - | return (ret.."\\nend"), true + | if #vars.rhs.value.value == 1 then + | return callback(compiler:tree_to_lua(vars.var, "Expression"), + | compiler:tree_to_lua(vars.rhs.value.value[1].value, "Expression")), true + | else + | local ret = "do\\n local ret" + | ret = ret .. "\\n "..compiler:tree_to_lua(vars.rhs.value, "Statement") + | ret = ret .. "\\n "..callback(compiler:tree_to_lua(vars.var, "Expression"), "ret") + | return (ret.."\\nend"), true + | end | end |end - |compiler:defmacro("%var = %rhs", helper(function(var) return var.." = ret" end)) - |compiler:defmacro("%var += %rhs", helper(function(var) return var.." = "..var.." + ret" end)) - |compiler:defmacro("%var -= %rhs", helper(function(var) return var.." = "..var.." - ret" end)) - |compiler:defmacro("%var *= %rhs", helper(function(var) return var.." = "..var.." * ret" end)) - |compiler:defmacro("%var /= %rhs", helper(function(var) return var.." = "..var.." / ret" end)) - |compiler:defmacro("%var ^= %rhs", helper(function(var) return var.." = "..var.." ^ ret" end)) - |compiler:defmacro("%var and= %rhs", helper(function(var) return var.." = "..var.." and ret" end)) - |compiler:defmacro("%var or= %rhs", helper(function(var) return var.." = "..var.." or ret" end)) - |compiler:defmacro("%var concat= %rhs", helper(function(var) return var.." = "..var.." .. ret" end)) - |compiler:defmacro("%var mod= %rhs", helper(function(var) return var.." = "..var.." % ret" end)) + |compiler:defmacro("%var = %rhs", helper(function(var,result) return var.." = "..result end)) + |compiler:defmacro("%var += %rhs", helper(function(var,result) return var.." = "..var.." + "..result end)) + |compiler:defmacro("%var -= %rhs", helper(function(var,result) return var.." = "..var.." - "..result end)) + |compiler:defmacro("%var *= %rhs", helper(function(var,result) return var.." = "..var.." * "..result end)) + |compiler:defmacro("%var /= %rhs", helper(function(var,result) return var.." = "..var.." / "..result end)) + |compiler:defmacro("%var ^= %rhs", helper(function(var,result) return var.." = "..var.." ^ "..result end)) + |compiler:defmacro("%var and= %rhs", helper(function(var,result) return var.." = "..var.." and "..result end)) + |compiler:defmacro("%var or= %rhs", helper(function(var,result) return var.." = "..var.." or "..result end)) + |compiler:defmacro("%var concat= %rhs", helper(function(var,result) return var.." = "..var.." .. "..result end)) + |compiler:defmacro("%var mod= %rhs", helper(function(var,result) return var.." = "..var.." % "..result end)) # Operators macro [true, yes] =: "true" @@ -279,11 +284,6 @@ macro [%if_expr if %condition else %else_expr] =: | end |end)(compiler, vars) -# Switch statement/multi-branch if -macro block [when %body] =: - %result =: "" - %result - # Loop control flow macro block [break] =: "break" @@ -350,6 +350,45 @@ macro block [for all %iterable %body] =: |end |vars.it = old_loopval +# Switch statement/multi-branch if +macro block [when %body] =: + %result =: "" + for %statement in (lua expr "vars.body.value.value"): + %func-call =: lua expr "vars.statement.value" + if ((lua expr "vars['func-call'].type") != "FunctionCall"): + error "Invalid format for 'when' statement" + %tokens =: lua expr "vars['func-call'].value" + %star =: lua expr "vars.tokens[1]" + if (((lua expr "vars.star.type") != "Word") or ((lua expr "vars.star.value") != "*")): + error "Invalid format for 'when' statement" + %thunk =: lua expr "vars.tokens[#vars.tokens]" + if ((lua expr "vars.thunk.type") != "Thunk"): + error "Invalid format for 'when' statement" + %condition-bits =: [] + for %i in (2 up to (lua expr "#vars.tokens")): + lua block "table.insert(vars['condition-bits'], vars.tokens[vars.i])" + %condition =: dict [..] + ["type",lua expr "vars['func-call'].type"] + ["src",lua expr "vars['func-call'].src"] + ["value", %condition-bits] + if ((lua expr "#vars.condition.value") == 0): + %result concat=: ".." + | + |do + | local ret + | \(lua expr "vars.thunk.value") as lua block\ + | return ret + |end + ..else: + %result concat=: ".." + | + |if \%condition as lua expr\ then + | local ret + | \(lua expr "vars.thunk.value") as lua block\ + | return ret + |end + %result + # List Comprehension # TODO: maybe make this lazy, or a lazy version? macro [%expression for %var in %iterable] =: @@ -452,6 +491,17 @@ macro [..] %index th in %list, %index in %list, %list -> %index ..=: ".."|\%list as lua expr\[\%index as lua expr\] + ".."|\%list as lua expr\[\%index as lua expr\] +macro [first in %list] =: + ".."|\%list as lua expr\[1] + +macro [..] + %index st to last in %list, %index nd to last in %list, %index rd to last in %list + %index th to last in %list +..=: + ".."|compiler.utils.nth_to_last(\%list as lua expr\, \%index as lua expr\) +macro [last in %list] =: + ".."|compiler.utils.nth_to_last(\%list as lua expr\, 1) macro block [..] %list's %index = %new_value, %index st in %list = %new_value, %index nd in %list = %new_value diff --git a/nomsu.lua b/nomsu.lua index 7ddfd97..24c1484 100644 --- a/nomsu.lua +++ b/nomsu.lua @@ -5,133 +5,6 @@ local INDENT = " " lpeg.setmaxstack(10000) local P, V, S, Cg, C, Cp, B, Cmt P, V, S, Cg, C, Cp, B, Cmt = lpeg.P, lpeg.V, lpeg.S, lpeg.Cg, lpeg.C, lpeg.Cp, lpeg.B, lpeg.Cmt -local get_line_indentation -get_line_indentation = function(line) - local indent_amounts = { - [" "] = 1, - ["\t"] = 4 - } - do - local sum = 0 - local leading_space = line:match("[\t ]*") - for c in leading_space:gmatch("[\t ]") do - sum = sum + indent_amounts[c] - end - return sum - end -end -local make_parser -make_parser = function(lingo, extra_definitions) - local indent_stack = { - 0 - } - local push - push = function(n) - return table.insert(indent_stack, n) - end - local pop - pop = function() - return table.remove(indent_stack) - end - local check_indent - check_indent = function(subject, end_pos, spaces) - local num_spaces = get_line_indentation(spaces) - if num_spaces <= indent_stack[#indent_stack] then - return nil - end - push(num_spaces) - return end_pos - end - local check_dedent - check_dedent = function(subject, end_pos, spaces) - local num_spaces = get_line_indentation(spaces) - if num_spaces >= indent_stack[#indent_stack] then - return nil - end - pop() - return end_pos - end - local check_nodent - check_nodent = function(subject, end_pos, spaces) - local num_spaces = get_line_indentation(spaces) - if num_spaces ~= indent_stack[#indent_stack] then - return nil - end - return end_pos - end - local wordchar = P(1) - S(' \t\n\r%#:;,.{}[]()"\\') - local nl = P("\n") - local whitespace = S(" \t") ^ 1 - local blank_line = whitespace ^ -1 * nl - local line_comment = re.compile([=[ "#" [^%nl]* ]=], { - nl = nl - }) - local block_comment = re.compile([=[ "#.." (!%nl .)* (%indent (!%dedent %nl [^%nl]*)*) - ]=], { - nl = nl, - whitespace = whitespace, - indent = #(nl * blank_line ^ 0 * Cmt(S(" \t") ^ 0, check_indent)), - dedent = #(nl * blank_line ^ 0 * Cmt(S(" \t") ^ 0, check_dedent)), - new_line = nl * blank_line ^ 0 * Cmt(S(" \t") ^ 0, check_nodent) - }) - blank_line = ((Cmt(whitespace ^ -1, check_nodent) * (block_comment + line_comment)) ^ -1 + whitespace ^ -1) * nl - local defs = { - wordchar = wordchar, - nl = nl, - ws = whitespace, - blank_line = blank_line, - block_comment = block_comment, - line_comment = line_comment, - eol = #nl + (P("") - P(1)), - word_boundary = whitespace ^ -1 + B(P("..")) + B(S("\";)]")) + #S("\":([") + #((whitespace + nl) ^ 0 * P("..")), - indent = #(nl * blank_line ^ 0 * Cmt(whitespace ^ -1, check_indent)), - dedent = #(nl * blank_line ^ 0 * Cmt(whitespace ^ -1, check_dedent)), - new_line = nl * blank_line ^ 0 * Cmt(whitespace ^ -1, check_nodent), - error_handler = function(src, pos, errors) - local line_no = 1 - for _ in src:sub(1, -#errors):gmatch("\n") do - line_no = line_no + 1 - end - local err_pos = #src - #errors + 1 - if errors:sub(1, 1) == "\n" then - err_pos = err_pos + #errors:match("[ \t]*", 2) - end - local start_of_err_line = err_pos - while src:sub(start_of_err_line, start_of_err_line) ~= "\n" do - start_of_err_line = start_of_err_line - 1 - end - local start_of_prev_line = start_of_err_line - 1 - while src:sub(start_of_prev_line, start_of_prev_line) ~= "\n" do - start_of_prev_line = start_of_prev_line - 1 - end - local prev_line, err_line, next_line = src:match("([^\n]*)\n([^\n]*)\n([^\n]*)", start_of_prev_line + 1) - local pointer = ("-"):rep(err_pos - start_of_err_line + 0) .. "^" - return error("\nParse error on line " .. tostring(line_no) .. ":\n\n" .. tostring(prev_line) .. "\n" .. tostring(err_line) .. "\n" .. tostring(pointer) .. "\n" .. tostring(next_line) .. "\n") - end - } - if extra_definitions then - for k, v in pairs(extra_definitions) do - defs[k] = v - end - end - setmetatable(defs, { - __index = function(t, key) - local fn - fn = function(src, value, errors) - local token = { - type = key, - src = src, - value = value, - errors = errors - } - return token - end - t[key] = fn - return fn - end - }) - return re.compile(lingo, defs) -end local NomsuCompiler do local _class_0 @@ -204,32 +77,45 @@ do end end, get_invocations_from_definition = function(self, def, vars) - if def.type == "String" or def.type == "List" then + if def.type == "String" then return self:tree_to_value(def, vars) end - if def.type ~= "Thunk" then - self:error("Trying to get invocations from " .. tostring(def.type) .. ", but expected Thunk.") + if def.type ~= "List" then + error("DEF IS: " .. tostring(utils.repr(def))) + self:error("Trying to get invocations from " .. tostring(def.type) .. ", but expected List or String.") end local invocations = { } - local _list_0 = def.value.value + local _list_0 = def.value for _index_0 = 1, #_list_0 do - local statement = _list_0[_index_0] - if statement.value.type ~= "FunctionCall" then - self:error("Invalid statement type: " .. tostring(statement.value.type) .. ", expected FunctionCall") - end - local name_bits = { } - local _list_1 = statement.value.value - for _index_1 = 1, #_list_1 do - local token = _list_1[_index_1] - if token.type == "Word" then - table.insert(name_bits, token.value) - elseif token.value.type == "Var" then - table.insert(name_bits, token.value.src) - else - self:error("Unexpected token type in definition: " .. tostring(token.value.type) .. " (expected Word or Var)") + local _continue_0 = false + repeat + local item = _list_0[_index_0] + if item.type == "String" then + table.insert(invocations, self:tree_to_value(item, vars)) + _continue_0 = true + break end + if item.type ~= "FunctionCall" then + self:error("Invalid list item: " .. tostring(item.type) .. ", expected FunctionCall or String") + end + local name_bits = { } + local _list_1 = item.value + for _index_1 = 1, #_list_1 do + local token = _list_1[_index_1] + if token.type == "Word" then + table.insert(name_bits, token.value) + elseif token.type == "Var" then + table.insert(name_bits, token.src) + else + self:error("Unexpected token type in definition: " .. tostring(token.type) .. " (expected Word or Var)") + end + end + table.insert(invocations, table.concat(name_bits, " ")) + _continue_0 = true + until true + if not _continue_0 then + break end - table.insert(invocations, table.concat(name_bits, " ")) end return invocations end, @@ -290,11 +176,11 @@ do self.defs[invocation] = fn_info end end, - run = function(self, text) + run = function(self, text, filename) if self.debug then self:writeln("RUNNING TEXT:\n" .. tostring(text)) end - local code, retval = self:compile(text) + local code, retval = self:compile(text, filename) if self.debug then self:writeln("\nGENERATED LUA CODE:\n" .. tostring(code)) self:writeln("\nPRODUCED RETURN VALUE:\n" .. tostring(retval)) @@ -344,69 +230,173 @@ do end return (lua_thunk())(self, { }) end, - parse = function(self, str) + parse = function(self, str, filename) if self.debug then self:writeln("PARSING:\n" .. tostring(str)) end - local lingo = [=[ file <- ({ {| %blank_line* {:body: block :} %blank_line* (errors)? |} }) -> File - errors <- (({.+}) => error_handler) - block <- ({ {| statement (%new_line statement)* |} }) -> Block - statement <- ({ (functioncall / expression) }) -> Statement - one_liner <- ({ {| - (({ - (({ {| - (expression (%word_boundary fn_bit)+) / (word (%word_boundary fn_bit)*) - |} }) -> FunctionCall) - / (expression) - }) -> Statement) - |} }) -> Block + local get_line_indentation + get_line_indentation = function(line) + local indent_amounts = { + [" "] = 1, + ["\t"] = 4 + } + do + local sum = 0 + local leading_space = line:match("[\t ]*") + for c in leading_space:gmatch("[\t ]") do + sum = sum + indent_amounts[c] + end + return sum + end + end + local indent_stack = { + 0 + } + local check_indent + check_indent = function(subject, end_pos, spaces) + local num_spaces = get_line_indentation(spaces) + if num_spaces > indent_stack[#indent_stack] then + table.insert(indent_stack, num_spaces) + return end_pos + end + end + local check_dedent + check_dedent = function(subject, end_pos, spaces) + local num_spaces = get_line_indentation(spaces) + if num_spaces < indent_stack[#indent_stack] then + table.remove(indent_stack) + return end_pos + end + end + local check_nodent + check_nodent = function(subject, end_pos, spaces) + local num_spaces = get_line_indentation(spaces) + if num_spaces == indent_stack[#indent_stack] then + return end_pos + end + end + local lingo = [=[ file <- ({ {| shebang? {:body: block :} %nl* (({.+} ("" -> "Unexpected end of file")) => error)? |} }) -> File - functioncall <- ({ {| (expression %word_boundary fn_bits) / (word (%word_boundary fn_bits)?) |} }) -> FunctionCall - fn_bit <- (expression / word) - fn_bits <- - ((".." %ws? %line_comment? (%indent %new_line indented_fn_bits %dedent) (%new_line ".." %ws? fn_bits)?) - / (%new_line ".." fn_bit (%word_boundary fn_bits)?) - / (fn_bit (%word_boundary fn_bits)?)) - indented_fn_bits <- - fn_bit ((%new_line / %word_boundary) indented_fn_bits)? - - thunk <- - ({ ":" %ws? %line_comment? - ((%indent %new_line block ((%dedent (%new_line "..")?) / errors)) - / (one_liner (%ws? (%new_line? ".."))?)) }) -> Thunk + shebang <- "#!" [^%nl]* %nl + + block <- ({ {| + (ignored_line %nl)* + line_of_statements (nodent line_of_statements)* + (%nl ignored_line)* |} }) -> Block + inline_block <- ({ {| inline_line_of_statements |} }) -> Block + + line_of_statements <- statement (%ws? ";" %ws? statement)* + inline_line_of_statements <- inline_statement (%ws? ";" %ws? inline_statement)* + + statement <- ({ functioncall / expression }) -> Statement + inline_statement <- ({ inline_functioncall / expression }) -> Statement + + expression <- ( + longstring / string / number / variable / list / thunk / block_functioncall + / ("(" %ws? (inline_thunk / inline_functioncall) %ws? ")")) + + -- Function calls need at least one word in them + functioncall <- ({ {| + (expression (dotdot / tok_gap))* word ((dotdot / tok_gap) (expression / word))* + |} }) -> FunctionCall + inline_functioncall <- ({ {| + (expression tok_gap)* word (tok_gap (expression / word))* + |} }) -> FunctionCall + block_functioncall <- "(..)" indent functioncall (dedent / (({.+} ("" -> "Error while parsing block function call")) => error)) word <- ({ !number {%wordchar (!"'" %wordchar)*} }) -> Word - expression <- ({ (longstring / string / number / variable / list / thunk / subexpression) }) -> Expression + + thunk <- ({ ":" ((indent block (dedent / (({.+} ("" -> "Error while parsing thunk")) => error))) + / (%ws? inline_block)) }) -> Thunk + inline_thunk <- ({ ":" %ws? inline_block }) -> Thunk string <- ({ (!longstring) '"' {(("\" [^%nl]) / [^"%nl])*} '"' }) -> String + longstring <- ({ '".."' %ws? - {| - (("|" {| ({("\\" / (!string_interpolation [^%nl]))+} / string_interpolation)* |}) - / %line_comment)? - (%indent - (%new_line "|" {| - ({("\\" / (!string_interpolation [^%nl]))+} / string_interpolation)* - |})+ - ((%dedent (%new_line '..')?) / errors))? - |}}) -> Longstring - string_interpolation <- "\" %ws? (functioncall / expression) %ws? "\" - number <- ({ {'-'? [0-9]+ ("." [0-9]+)?} }) -> Number + {| (longstring_line (indent + longstring_line (nodent longstring_line)* + (dedent / longstring_error))?) + /(indent + longstring_line (nodent longstring_line)* + (dedent / longstring_error)) |} }) -> Longstring + longstring_line <- "|" {| ({("\\" / (!string_interpolation [^%nl]))+} / string_interpolation)* |} + longstring_error <- (({.+} ("" -> "Error while parsing Longstring")) => error) + string_interpolation <- "\" %ws? (inline_functioncall / expression) %ws? "\" + + number <- ({ {"-"? (([0-9]+ "." [0-9]+) / ("." [0-9]+) / ([0-9]+)) } }) -> Number + + -- Hack to allow %foo's to parse as "%foo" and "'s" separately variable <- ({ ("%" {%wordchar (!"'" %wordchar)*}) }) -> Var - subexpression <- - ("(" %ws? (functioncall / expression) %ws? ")") - / ("(..)" %ws? %line_comment? %indent %new_line ((({ {| indented_fn_bits |} }) -> FunctionCall) / expression) %dedent (%new_line "..")?) - list <- ({ {| - ("[..]" %ws? %line_comment? %indent %new_line indented_list ","? ((%dedent (%new_line "..")?) / errors)) - / ("[" %ws? (list_items ","?)? %ws?"]") + ("[..]" indent + list_line (nodent list_line)* + (dedent / (({.+} ("" -> "Error while parsing list")) => error))) + /("[" %ws? (list_line %ws?)? "]") |} }) -> List - list_items <- ((functioncall / expression) (list_sep list_items)?) - list_sep <- %ws? "," %ws? - indented_list <- - (functioncall / expression) (((list_sep (%line_comment? %new_line)?) / (%line_comment? %new_line)) indented_list)? + list_line <- list_bit (%ws? "," tok_gap list_bit)* (%ws? ",")? + list_bit <- inline_functioncall / expression + + block_comment <- "#.." [^%nl]* indent [^%nl]* (%nl ((%ws? (!. / &%nl)) / (!%dedented [^%nl]*)))* + line_comment <- "#" [^%nl]* + + eol <- %ws? line_comment? (!. / &%nl) + ignored_line <- (%nodented (block_comment / line_comment)) / (%ws? (!. / &%nl)) + indent <- eol (%nl ignored_line)* %nl %indented + nodent <- eol (%nl ignored_line)* %nl %nodented + dedent <- eol (%nl ignored_line)* (((!.) &%dedented) / (&(%nl %dedented))) + tok_gap <- %ws / %prev_edge / &("[" / [.,:;{("#%']) + dotdot <- nodent ".." %ws? ]=] - lingo = make_parser(lingo) + local whitespace = S(" \t") ^ 1 + local defs = { + ws = whitespace, + nl = P("\n"), + wordchar = P(1) - S(' \t\n\r%#:;,.{}[]()"\\'), + 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), + prev_edge = B(S(" \t\n.,:;}])\"")), + error = function(src, pos, errors, err_msg) + local line_no = 1 + for _ in src:sub(1, -#errors):gmatch("\n") do + line_no = line_no + 1 + end + local err_pos = #src - #errors + 1 + if errors:sub(1, 1) == "\n" then + err_pos = err_pos + #errors:match("[ \t]*", 2) + end + local start_of_err_line = err_pos + while src:sub(start_of_err_line, start_of_err_line) ~= "\n" and start_of_err_line > 1 do + start_of_err_line = start_of_err_line - 1 + end + local start_of_prev_line = start_of_err_line - 1 + while src:sub(start_of_prev_line, start_of_prev_line) ~= "\n" and start_of_prev_line > 1 do + start_of_prev_line = start_of_prev_line - 1 + end + local prev_line, err_line, next_line + prev_line, err_line, next_line = src:match("([^\n]*)\n([^\n]*)\n([^\n]*)", start_of_prev_line + 1) + local pointer = ("-"):rep(err_pos - start_of_err_line + 0) .. "^" + return error("\n" .. tostring(err_msg or "Parse error") .. " in " .. tostring(filename) .. " on line " .. tostring(line_no) .. ":\n\n" .. tostring(prev_line) .. "\n" .. tostring(err_line) .. "\n" .. tostring(pointer) .. "\n" .. tostring(next_line) .. "\n") + end + } + setmetatable(defs, { + __index = function(t, key) + local fn + fn = function(src, value, errors) + local token = { + type = key, + src = src, + value = value, + errors = errors + } + return token + end + t[key] = fn + return fn + end + }) + lingo = re.compile(lingo, defs) local tree = lingo:match(str:gsub("\r", "") .. "\n") if self.debug then self:writeln("\nPARSE TREE:") @@ -428,6 +418,9 @@ do kind = "Expression" end assert(tree, "No tree provided.") + if not tree.type then + self:error("Invalid tree: " .. tostring(utils.repr(tree))) + end local indent = "" local buffer = { } local return_value = nil @@ -485,8 +478,6 @@ do else add("ret = " .. (to_lua(tree.value):match("%s*(.*)"))) end - elseif "Expression" == _exp_0 then - add(to_lua(tree.value)) elseif "FunctionCall" == _exp_0 then local name = self:fn_name_from_tree(tree) if self.defs[name] and self.defs[name].is_macro then @@ -670,8 +661,6 @@ do self:_yield_tree(tree.value, indent_level + 1) elseif "Statement" == _exp_0 then self:_yield_tree(tree.value, indent_level) - elseif "Expression" == _exp_0 then - self:_yield_tree(tree.value, indent_level) elseif "FunctionCall" == _exp_0 then local name = self:fn_name_from_tree(tree) local args @@ -737,14 +726,14 @@ do end return table.concat(result, "\n") end, - compile = function(self, src, output_file) + compile = function(self, src, filename, output_file) if output_file == nil then output_file = nil end if self.debug then self:writeln("COMPILING:\n" .. tostring(src)) end - local tree = self:parse(src) + local tree = self:parse(src, filename) assert(tree, "Tree failed to compile: " .. tostring(src)) local code, retval = self:tree_to_lua(tree) if output_file then @@ -764,7 +753,7 @@ do self.callstack = { } return error() end, - test = function(self, src, expected) + test = function(self, src, filename, expected) local i = 1 while i ~= nil do local start, stop = src:find("\n\n", i) @@ -777,7 +766,7 @@ do local test_src test_src, expected = test:sub(1, start - 1), test:sub(stop + 1, -1) expected = expected:match('[\n]*(.*[^\n])') - local tree = self:parse(test_src) + local tree = self:parse(test_src, filename) local got = self:stringify_tree(tree.value.body) if got ~= expected then self:error("TEST FAILED!\nSource:\n" .. tostring(test_src) .. "\nExpected:\n" .. tostring(expected) .. "\n\nGot:\n" .. tostring(got)) @@ -819,28 +808,34 @@ do self:def("require %filename", function(self, vars) if not self.loaded_files[vars.filename] then local file = io.open(vars.filename) - self.loaded_files[vars.filename] = self:run(file:read('*a')) + if not file then + self:error("File does not exist: " .. tostring(vars.filename)) + end + self.loaded_files[vars.filename] = self:run(file:read('*a'), vars.filename) end return self.loaded_files[vars.filename] end) return self:def("run file %filename", function(self, vars) local file = io.open(vars.filename) - return self:run(file:read('*a')) + if not file then + self:error("File does not exist: " .. tostring(vars.filename)) + end + return self:run(file:read('*a'), vars.filename) end) end } _base_0.__index = _base_0 _class_0 = setmetatable({ __init = function(self, parent) + self.write = function(self, ...) + return io.write(...) + end self.defs = setmetatable({ }, { __index = parent and parent.defs }) self.callstack = { } self.debug = false self:initialize_core() - self.write = function(self, ...) - return io.write(...) - end self.utils = utils self.loaded_files = { } end, @@ -886,7 +881,7 @@ if arg and arg[1] then if arg[2] == "-" then c.write = function() end end - local code, retval = c:compile(input) + local code, retval = c:compile(input, arg[1]) c.write = _write if arg[2] then local output @@ -907,7 +902,7 @@ if arg and arg[1] then end elseif arg then local c = NomsuCompiler() - c:run('run file "core.nom"') + c:run('require "lib/core.nom"') while true do local buff = "" while true do diff --git a/utils.moon b/utils.moon index c439e8f..b46bf44 100644 --- a/utils.moon +++ b/utils.moon @@ -51,13 +51,27 @@ utils = { start,stop,step = 1,start,1 elseif step == nil step = 1 + elseif step == 0 + error("Range step cannot be zero.") return setmetatable({:start,:stop,:step}, { __ipairs: => iter = (i)=> if i <= (@stop-@start)/@step return i+1, @start+i*@step return iter, @, 0 + __index: (i)=> + if type(i) != "Number" then return nil + if i % 1 != 0 then return nil + if i <= 0 or i-1 > (@stop-@start)/@step then return nil + return @start + (i-1)*@step + __len: => + len = (@stop-@start)/@step + if len < 0 then len = 0 + return len + }) + + nth_to_last: (list, n) -> list[#list-n+1] keys: (t)-> [k for k in pairs(t)] values: (t)-> [v for _,v in pairs(t)]