releasing moonplus as a lib.

11 files changed, 896 insertions, 23 deletions

diff --git a/.gitignore b/.gitignore
index 5f6a200..d3acf45 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,3 +1,4 @@
 moonp
 build
+build.luarocks
 spec/outputs
diff --git a/CMakeLists.txt b/CMakeLists.txt
new file mode 100644
index 0000000..195895c
--- /dev/null
+++ b/CMakeLists.txt
@@ -0,0 +1,36 @@
+project ( moonp CXX )
+cmake_minimum_required ( VERSION 3.1 )
+
+MESSAGE(STATUS "Lua: using information from luarocks")
+
+MESSAGE(STATUS "LUA_LIBDIR: " ${LUA_INCDIR}/../../lib)
+MESSAGE(STATUS "LUA_INCDIR: " ${LUA_INCDIR})
+MESSAGE(STATUS "LUA: " ${LUA})
+
+SET(LUA_EXECUTABLE "${LUA}")
+SET(LUA_INCLUDE_DIR "${LUA_INCDIR}")
+
+GET_FILENAME_COMPONENT(LUA_EXEC_NAME ${LUA} NAME_WE)
+IF(LUA_EXEC_NAME STREQUAL "luajit")
+        FIND_LIBRARY(LUA_LIBRARIES
+                NAMES luajit libluajit
+                PATHS ${LUA_INCDIR}/../../lib
+                NO_DEFAULT_PATH)
+ELSEIF(LUA_EXEC_NAME MATCHES "lua.*")
+        FIND_LIBRARY(LUA_LIBRARIES
+                NAMES lua lua53 lua52 lua51 liblua liblua53 liblua52 liblua51
+                PATHS ${LUA_INCDIR}/../../lib
+                NO_DEFAULT_PATH)
+ENDIF()
+MESSAGE(STATUS "Lua library: ${LUA_LIBRARIES}")
+
+enable_language( CXX )
+find_package( Lua REQUIRED )
+include_directories( src ${LUA_INCLUDE_DIR} )
+add_definitions( -std=c++17 -O3 -DLIBMOONP )
+
+add_library( moonp MODULE src/MoonP/ast.cpp src/MoonP/parser.cpp src/MoonP/moon_parser.cpp src/MoonP/moon_compiler.cpp src/moonp.cpp)
+set_target_properties( moonp PROPERTIES PREFIX "")
+target_link_libraries( moonp ${LUA_LIBRARIES} )
+
+install(CODE "")
diff --git a/LICENSE b/LICENSE
index 5b87539..6c2fbc6 100644
--- a/LICENSE
+++ b/LICENSE
@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2017 Li Jin
+Copyright (c) 2020 Li Jin
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/makefile b/makefile
index fd2d718..14a7752 100644
--- a/makefile
+++ b/makefile
@@ -206,7 +206,10 @@ clean:
 .PHONY: test
 test: release
         @echo "Compiling Moonscript codes..."
+        @$(START_TIME)
         @./$(BIN_NAME) $(TEST_INPUT)/*.moon -t $(TEST_OUTPUT)
+        @echo -en "Compile time: "
+        @$(END_TIME)
 
 # Main rule, checks the executable and symlinks to the output
 all: $(BIN_PATH)/$(BIN_NAME)
diff --git a/moonplus-0.1-1.rockspec b/moonplus-0.1-1.rockspec
new file mode 100644
index 0000000..aeebe69
--- /dev/null
+++ b/moonplus-0.1-1.rockspec
@@ -0,0 +1,27 @@
+package = "MoonPlus"
+version = "0.1-1"
+source = {
+        url = "git+https://github.com/pigpigyyy/MoonPlus"
+}
+description = {
+        summary = "MoonPlus is a compiler for Moonscript written in C++.",
+        detailed = [[
+        MoonPlus is a compiler with features from Moonscript language 0.5.0 and more advanced features. could be faster than the original Moonscript compiler. ]],
+        homepage = "https://github.com/pigpigyyy/MoonPlus",
+        license = "MIT"
+}
+dependencies = {
+        "lua >= 5.1",
+}
+build = {
+        type = "cmake",
+        variables = {
+                LUA_INCDIR="$(LUA_INCDIR)",
+                LUA="$(LUA)",
+        },
+        install = {
+                lib = {
+                        "build.luarocks/moonp.so"
+                }
+        }
+}
diff --git a/spec/inputs/plus.moon b/spec/inputs/plus.moon
index 8a91c93..f455845 100644
--- a/spec/inputs/plus.moon
+++ b/spec/inputs/plus.moon
@@ -11,5 +11,9 @@ if fcolor = message\match "<%w*>" then message = message\gsub "<%->", fcolor
 
 message = message\gsub "<%->", fcolor if fcolor = message\match "<%w*>"
 
-func val if val = getvalue!
+valA = func! if func = getfunc!
+
+valB = do
+        func = getfunc!
+        func?!
 
diff --git a/spec/inputs/syntax.moon b/spec/inputs/syntax.moon
index ae3fc0c..5442b61 100644
--- a/spec/inputs/syntax.moon
+++ b/spec/inputs/syntax.moon
@@ -242,7 +242,15 @@ hello "comma",
 another hello, one,
         two, three, four, yeah: man
         okay: yeah
+        fine: alright
 
+another hello, one, two, three, four,
+        yeah: man
+        okay: yeah
+
+another hello, one, two, three, four, yeah: man
+        okay: yeah
+ 
 -- 
 a += 3 - 5
 a *= 3 + 5
diff --git a/src/MoonP/moon_compiler.cpp b/src/MoonP/moon_compiler.cpp
index d3427d3..30adbae 100644
--- a/src/MoonP/moon_compiler.cpp
+++ b/src/MoonP/moon_compiler.cpp
@@ -690,7 +690,7 @@ private:
                                                         break;
                                                 }
                                         }
-                                        throw std::logic_error(_info.errorMessage("Expression list must appear at the end of body block."sv, expList));
+                                        throw std::logic_error(_info.errorMessage("Expression list must appear at the end of body or block."sv, expList));
                                 }
                                 break;
                         }
@@ -1252,26 +1252,31 @@ private:
                                 bool oneLined = defs.size() == expList->exprs.objects().size() &&
                                         traversal::Stop != action->traverse([&](ast_node* n) {
                                         switch (n->getId()) {
-                                                case "Callable"_id: {
-                                                        auto callable = static_cast<Callable_t*>(n);
-                                                        switch (callable->item->getId()) {
-                                                                case "Variable"_id:
-                                                                        for (const auto& def : defs) {
+                                                case "ChainValue"_id: {
+                                                        auto chainValue = static_cast<ChainValue_t*>(n);
+                                                        const auto& items = chainValue->items.objects();
+                                                        BLOCK_START
+                                                        auto callable = ast_cast<Callable_t>(*items.begin());
+                                                        BREAK_IF(!callable);
+                                                        auto next = items.begin(); ++next;
+                                                        BREAK_IF(next == items.end());
+                                                        BREAK_IF((!ast_is<Invoke_t,InvokeArgs_t>(*next)));
+                                                        for (const auto& def : defs) {
+                                                                switch (callable->item->getId()) {
+                                                                        case "Variable"_id:
                                                                                 if (def == _parser.toString(callable->item)) {
                                                                                         return traversal::Stop;
                                                                                 }
-                                                                        }
-                                                                        return traversal::Return;
-                                                                case "SelfName"_id:
-                                                                        for (const auto& def : defs) {
+                                                                                return traversal::Return;
+                                                                        case "SelfName"_id:
                                                                                 if (def == "self"sv) {
                                                                                         return traversal::Stop;
                                                                                 }
-                                                                        }
-                                                                        return traversal::Return;
-                                                                default:
-                                                                        return traversal::Continue;
+                                                                                return traversal::Return;
+                                                                }
                                                         }
+                                                        BLOCK_END
+                                                        return traversal::Continue;
                                                 }
                                                 default:
                                                         return traversal::Continue;
diff --git a/src/MoonPlus.h b/src/MoonPlus.h
new file mode 100644
index 0000000..da5f3ac
--- /dev/null
+++ b/src/MoonPlus.h
@@ -0,0 +1,125 @@
+R"moonscript_codes(
+import "moonp"
+import concat, insert, remove from table
+unpack = unpack or table.unpack
+lua = :loadstring, :load
+
+local *
+
+dirsep = "/"
+
+moonp.moon_compiled = {}
+
+split = (str, delim) ->
+        return {} if str == ""
+        str ..= delim
+        [m for m in str\gmatch("(.-)"..delim)]
+
+get_options = (...) ->
+        count = select "#", ...
+        opts = select count, ...
+        if type(opts) == "table"
+                opts, unpack {...}, nil, count - 1
+        else
+                {}, ...
+
+-- create moon path package from lua package path
+create_moonpath = (package_path) ->
+        moonpaths = for path in *split package_path, ";"
+                prefix = path\match "^(.-)%.lua$"
+                continue unless prefix
+                prefix .. ".moon"
+        concat moonpaths, ";"
+
+moon_loader = (name) ->
+        name_path = name\gsub "%.", dirsep
+
+        local file, file_path
+        for path in package.moonpath\gmatch "[^;]+"
+                file_path = path\gsub "?", name_path
+                file = io.open file_path
+                break if file
+
+        if file
+                text = file\read "*a"
+                file\close!
+                res, err = loadstring text, "@#{file_path}"
+                if not res
+                                error file_path .. ": " .. err
+
+                return res
+
+        return nil, "Could not find moon file"
+
+
+loadstring = (...) ->
+        options, str, chunk_name, mode, env = get_options ...
+        chunk_name or= "=(moonscript.loadstring)"
+
+        code, err = moonp.to_lua str, options
+        unless code
+                return nil, err
+
+        moonp.moon_compiled[chunk_name] = code if chunk_name
+        -- the unpack prevents us from passing nil
+        (lua.loadstring or lua.load) code, chunk_name, unpack { mode, env }
+
+loadfile = (fname, ...) ->
+        file, err = io.open fname
+        return nil, err unless file
+        text = assert file\read "*a"
+        file\close!
+        loadstring text, "@#{fname}", ...
+
+-- throws errros
+dofile = (...) ->
+        f = assert loadfile ...
+        f!
+
+insert_loader = (pos=2) ->
+        if not package.moonpath
+                package.moonpath = create_moonpath package.path
+
+        loaders = package.loaders or package.searchers
+        for loader in *loaders
+                return false if loader == moon_loader
+
+        insert loaders, pos, moon_loader
+        true
+
+remove_loader = ->
+        loaders = package.loaders or package.searchers
+
+        for i, loader in ipairs loaders
+                if loader == moon_loader
+                        remove loaders, i
+                        return true
+
+        false
+
+moon_require = (name)->
+        insert_loader!
+        xpcall (-> require name), (err)->
+                msg = moonp.stp.stacktrace err, 2
+                print msg
+
+setmetatable moonp, {
+        __index: (key)=>
+                return nil unless key == "stp"
+                stp = rawget moonp,"stp"
+                unless stp
+                        stp = with moonp.load_stacktraceplus!
+                                .dump_locals = false
+                                .simplified = true
+                        rawset moonp,"stp",stp
+                        rawset moonp,"load_stacktraceplus",nil
+                stp
+        __call: (name)=> @.require name
+}
+
+moonp[k] = v for k,v in pairs {
+        :insert_loader, :remove_loader, :moon_loader, :dirsep,
+        :dofile, :loadfile, :loadstring, :create_moonpath,
+        require:moon_require
+}
+)moonscript_codes";
diff --git a/src/StackTracePlus.h b/src/StackTracePlus.h
new file mode 100644
index 0000000..1a909fd
--- /dev/null
+++ b/src/StackTracePlus.h
@@ -0,0 +1,550 @@
+R"lua_codes(
+--[[
+The MIT License
+
+Copyright (c) 2010 Ignacio Burgueño
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.]]
+
+-- tables
+local _G = _G
+local string, io, debug, coroutine = string, io, debug, coroutine
+
+-- functions
+local tostring, require = tostring, require
+local next, assert = next, assert
+local pcall, type, pairs, ipairs = pcall, type, pairs, ipairs
+local error = error
+
+assert(debug, "debug table must be available at this point")
+
+local string_gmatch = string.gmatch
+local string_sub = string.sub
+local table_concat = table.concat
+
+local _M = {
+        max_tb_output_len = 70, -- controls the maximum length of the 'stringified' table before cutting with ' (more...)'
+        dump_locals = true,
+        simplified = false
+}
+
+-- this tables should be weak so the elements in them won't become uncollectable
+local m_known_tables = { [_G] = "_G (global table)" }
+local function add_known_module(name, desc)
+        local ok, mod = pcall(require, name)
+        if ok then
+                m_known_tables[mod] = desc
+        end
+end
+
+add_known_module("string", "string module")
+add_known_module("io", "io module")
+add_known_module("os", "os module")
+add_known_module("table", "table module")
+add_known_module("math", "math module")
+add_known_module("package", "package module")
+add_known_module("debug", "debug module")
+add_known_module("coroutine", "coroutine module")
+
+-- lua5.2
+add_known_module("bit32", "bit32 module")
+-- luajit
+add_known_module("bit", "bit module")
+add_known_module("jit", "jit module")
+-- lua5.3
+if _VERSION >= "Lua 5.3" then
+        add_known_module("utf8", "utf8 module")
+end
+
+
+local m_user_known_tables = {}
+
+local m_known_functions = {}
+for _, name in ipairs{
+        -- Lua 5.2, 5.1
+        "assert",
+        "collectgarbage",
+        "dofile",
+        "error",
+        "getmetatable",
+        "ipairs",
+        "load",
+        "loadfile",
+        "next",
+        "pairs",
+        "pcall",
+        "print",
+        "rawequal",
+        "rawget",
+        "rawlen",
+        "rawset",
+        "require",
+        "select",
+        "setmetatable",
+        "tonumber",
+        "tostring",
+        "type",
+        "xpcall",
+
+        -- Lua 5.1
+        "gcinfo",
+        "getfenv",
+        "loadstring",
+        "module",
+        "newproxy",
+        "setfenv",
+        "unpack",
+        -- TODO: add table.* etc functions
+} do
+        if _G[name] then
+                m_known_functions[_G[name]] = name
+        end
+end
+
+local m_user_known_functions = {}
+
+local function safe_tostring (value)
+        local ok, err = pcall(tostring, value)
+        if ok then return err else return ("<failed to get printable value>: '%s'"):format(err) end
+end
+
+-- Private:
+-- Parses a line, looking for possible function definitions (in a very naive way)
+-- Returns '(anonymous)' if no function name was found in the line
+local function ParseLine(line)
+        assert(type(line) == "string")
+        local match = line:match("^%s*function%s+(%w+)")
+        if match then
+                --print("+++++++++++++function", match)
+                return match
+        end
+        match = line:match("^%s*local%s+function%s+(%w+)")
+        if match then
+                --print("++++++++++++local", match)
+                return match
+        end
+        match = line:match("^%s*local%s+(%w+)%s+=%s+function")
+        if match then
+                --print("++++++++++++local func", match)
+                return match
+        end
+        match = line:match("%s*function%s*%(")  -- this is an anonymous function
+        if match then
+                --print("+++++++++++++function2", match)
+                return "(anonymous)"
+        end
+        return "(anonymous)"
+end
+
+-- Private:
+-- Tries to guess a function's name when the debug info structure does not have it.
+-- It parses either the file or the string where the function is defined.
+-- Returns '?' if the line where the function is defined is not found
+local function GuessFunctionName(info)
+        -- print("guessing function name")
+        if type(info.source) == "string" and info.source:sub(1,1) == "@" then
+                local file = io.open(info.source:sub(2))
+                local text
+                if file then
+                        text = file:read("*a")
+                        file:close()
+                end
+                if not text then
+                        -- print("file not found: "..tostring(err))     -- whoops!
+                        return "?"
+                end
+                local line
+                local count = 0
+                for lineText in (text.."\n"):gmatch("(.-)\n") do
+                        line = lineText
+                        count = count + 1
+                        if count == info.linedefined then
+                                break
+                        end
+                end
+                if not line then
+                        --print("line not found")       -- whoops!
+                        return "?"
+                end
+                return ParseLine(line)
+        else
+                local line
+                local lineNumber = 0
+                for l in string_gmatch(info.source, "([^\n]+)\n-") do
+                        lineNumber = lineNumber + 1
+                        if lineNumber == info.linedefined then
+                                line = l
+                                break
+                        end
+                end
+                if not line then
+                        -- print("line not found")      -- whoops!
+                        return "?"
+                end
+                return ParseLine(line)
+        end
+end
+
+---
+-- Dumper instances are used to analyze stacks and collect its information.
+--
+local Dumper = {}
+
+Dumper.new = function(thread)
+        local t = { lines = {} }
+        for k,v in pairs(Dumper) do t[k] = v end
+
+        t.dumping_same_thread = (thread == coroutine.running())
+
+        -- if a thread was supplied, bind it to debug.info and debug.get
+        -- we also need to skip this additional level we are introducing in the callstack (only if we are running
+        -- in the same thread we're inspecting)
+        if type(thread) == "thread" then
+                t.getinfo = function(level, what)
+                        if t.dumping_same_thread and type(level) == "number" then
+                                level = level + 1
+                        end
+                        return debug.getinfo(thread, level, what)
+                end
+                t.getlocal = function(level, loc)
+                        if t.dumping_same_thread then
+                                level = level + 1
+                        end
+                        return debug.getlocal(thread, level, loc)
+                end
+        else
+                t.getinfo = debug.getinfo
+                t.getlocal = debug.getlocal
+        end
+
+        return t
+end
+
+-- helpers for collecting strings to be used when assembling the final trace
+function Dumper:add (text)
+        self.lines[#self.lines + 1] = text
+end
+function Dumper:add_f (fmt, ...)
+        self:add(fmt:format(...))
+end
+function Dumper:concat_lines ()
+        return table_concat(self.lines)
+end
+
+---
+-- Private:
+-- Iterates over the local variables of a given function.
+--
+-- @param level The stack level where the function is.
+--
+function Dumper:DumpLocals (level)
+        if not _M.dump_locals then return end
+
+        local prefix = "\t "
+        local i = 1
+
+        if self.dumping_same_thread then
+                level = level + 1
+        end
+
+        local name, value = self.getlocal(level, i)
+        if not name then
+                return
+        end
+        self:add("\tLocal variables:\r\n")
+        while name do
+                if type(value) == "number" then
+                        self:add_f("%s%s = number: %g\r\n", prefix, name, value)
+                elseif type(value) == "boolean" then
+                        self:add_f("%s%s = boolean: %s\r\n", prefix, name, tostring(value))
+                elseif type(value) == "string" then
+                        self:add_f("%s%s = string: %q\r\n", prefix, name, value)
+                elseif type(value) == "userdata" then
+                        self:add_f("%s%s = %s\r\n", prefix, name, safe_tostring(value))
+                elseif type(value) == "nil" then
+                        self:add_f("%s%s = nil\r\n", prefix, name)
+                elseif type(value) == "table" then
+                        if m_known_tables[value] then
+                                self:add_f("%s%s = %s\r\n", prefix, name, m_known_tables[value])
+                        elseif m_user_known_tables[value] then
+                                self:add_f("%s%s = %s\r\n", prefix, name, m_user_known_tables[value])
+                        else
+                                local txt = "{"
+                                for k,v in pairs(value) do
+                                        txt = txt..safe_tostring(k)..":"..safe_tostring(v)
+                                        if #txt > _M.max_tb_output_len then
+                                                txt = txt.." (more...)"
+                                                break
+                                        end
+                                        if next(value, k) then txt = txt..", " end
+                                end
+                                self:add_f("%s%s = %s  %s\r\n", prefix, name, safe_tostring(value), txt.."}")
+                        end
+                elseif type(value) == "function" then
+                        local info = self.getinfo(value, "nS")
+                        local fun_name = info.name or m_known_functions[value] or m_user_known_functions[value]
+                        if info.what == "C" then
+                                self:add_f("%s%s = C %s\r\n", prefix, name, (fun_name and ("function: " .. fun_name) or tostring(value)))
+                        else
+                                local source = info.short_src
+                                if source:sub(2,7) == "string" then
+                                        source = source:sub(9)
+                                end
+                                --for k,v in pairs(info) do print(k,v) end
+                                fun_name = fun_name or GuessFunctionName(info)
+                                self:add_f("%s%s = Lua function '%s' (defined at line %d of chunk %s)\r\n", prefix, name, fun_name, info.linedefined, source)
+                        end
+                elseif type(value) == "thread" then
+                        self:add_f("%sthread %q = %s\r\n", prefix, name, tostring(value))
+                end
+                i = i + 1
+                name, value = self.getlocal(level, i)
+        end
+end
+
+local function getMoonLineNumber(fname, line)
+        local moonCompiled = require("moonp").moon_compiled
+        local source = moonCompiled["@"..fname]
+        local file = io.open(fname)
+        if not source and file then
+                local codes = file:read("*a")
+                file:close()
+                local moonFile = codes:match("^%s*--%s*%[moon%]:%s*([^\n]*)")
+                if moonFile then
+                        fname = moonFile:gsub("^%s*(.-)%s*$", "%1")
+                        source = codes
+                end
+        end
+        if source then
+                local i, target = 1, tonumber(line)
+                for lineCode in source:gmatch("([^\n]*)\n") do
+                        if i == target then
+                                local num = lineCode:match("--%s*(%d*)%s*$")
+                                if num then
+                                        return fname, num
+                                end
+                                break
+                        end
+                        i = i + 1
+                end
+        end
+        return fname, line
+end
+
+---
+-- Public:
+-- Collects a detailed stack trace, dumping locals, resolving function names when they're not available, etc.
+-- This function is suitable to be used as an error handler with pcall or xpcall
+--
+-- @param thread An optional thread whose stack is to be inspected (defaul is the current thread)
+-- @param message An optional error string or object.
+-- @param level An optional number telling at which level to start the traceback (default is 1)
+--
+-- Returns a string with the stack trace and a string with the original error.
+--
+function _M.stacktrace(thread, message, level)
+        if type(thread) ~= "thread" then
+                -- shift parameters left
+                thread, message, level = nil, thread, message
+        end
+
+        thread = thread or coroutine.running()
+
+        level = level or 1
+
+        local dumper = Dumper.new(thread)
+
+        local original_error
+
+        if type(message) == "table" then
+                dumper:add("an error object {\r\n")
+                local first = true
+                for k,v in pairs(message) do
+                        if first then
+                                dumper:add("  ")
+                                first = false
+                        else
+                                dumper:add(",\r\n  ")
+                        end
+                        dumper:add(safe_tostring(k))
+                        dumper:add(": ")
+                        dumper:add(safe_tostring(v))
+                end
+                dumper:add("\r\n}")
+                original_error = dumper:concat_lines()
+        elseif type(message) == "string" then
+                original_error = message
+                local fname, line, msg = message:match('(.+):(%d+): (.*)$')
+                local nfname, nline, nmsg = fname:match('(.+):(%d+): (.*)$')
+                if nfname then
+                        fname = nmsg
+                end
+                if fname then
+                        fname = fname:gsub("%[string \"", "")
+                        fname = fname:gsub("\"%]", "")
+                        fname = fname:gsub("^%s*(.-)%s*$", "%1")
+                        local extension = fname:match("%.([^%.\\/]*)$")
+                        if not extension then
+                                local fext = fname .. ".lua"
+                                local file = io.open(fext)
+                                if file then
+                                        file:close()
+                                        fname = fext
+                                else
+                                        fext = fname .. ".moon"
+                                        file = io.open(fext)
+                                        if file then
+                                                file:close()
+                                                fname = fext
+                                        end
+                                end
+                        end
+                        fname, line = getMoonLineNumber(fname, line)
+                        if _M.simplified then
+                                message = table.concat({
+                                        "'", fname, "':",
+                                        line, ": ", msg})
+                        else
+                                message = table.concat({
+                                        "[string \"", fname, "\"]:",
+                                        line, ": ", msg})
+                        end
+                end
+                dumper:add(message)
+        end
+
+        dumper:add("\r\n")
+        dumper:add[[
+Stack Traceback
+===============
+]]
+        --print(error_message)
+
+        local level_to_show = 1
+        if dumper.dumping_same_thread then level = level + 1 end
+
+        local info = dumper.getinfo(level, "nSlf")
+        while info do
+                if info.source and info.source:sub(1,1) == "@" then
+                        info.source = info.source:sub(2)
+                elseif info.what == "main" or info.what == "Lua" then
+                        info.source = info.source
+                end
+                local fname = info.source
+                local extension = fname:match("%.([^%.\\/]*)$")
+                if not extension then
+                        local fext = fname .. ".lua"
+                        local file = io.open(fext)
+                        if file then
+                                file:close()
+                                fname = fext
+                        else
+                                fext = fname .. ".moon"
+                                file = io.open(fext)
+                                if file then
+                                        file:close()
+                                        fname = fext
+                                end
+                        end
+                end
+                info.source, info.currentline = getMoonLineNumber(fname, info.currentline)
+                if info.what == "main" then
+                        if _M.simplified then
+                                dumper:add_f("(%d) '%s':%d\r\n", level_to_show, info.source, info.currentline)
+                        else
+                                dumper:add_f("(%d) main chunk of file '%s' at line %d\r\n", level_to_show, info.source, info.currentline)
+                        end
+                elseif info.what == "C" then
+                        --print(info.namewhat, info.name)
+                        --for k,v in pairs(info) do print(k,v, type(v)) end
+                        local function_name = m_user_known_functions[info.func] or m_known_functions[info.func] or info.name or tostring(info.func)
+                        dumper:add_f("(%d) %s C function '%s'\r\n", level_to_show, info.namewhat, function_name)
+                        --dumper:add_f("%s%s = C %s\r\n", prefix, name, (m_known_functions[value] and ("function: " .. m_known_functions[value]) or tostring(value)))
+                elseif info.what == "tail" then
+                        --print("tail")
+                        --for k,v in pairs(info) do print(k,v, type(v)) end--print(info.namewhat, info.name)
+                        dumper:add_f("(%d) tail call\r\n", level_to_show)
+                        dumper:DumpLocals(level)
+                elseif info.what == "Lua" then
+                        local source = info.source
+                        local function_name = m_user_known_functions[info.func] or m_known_functions[info.func] or info.name
+                        if source:sub(2, 7) == "string" then
+                                source = source:sub(10,-3)
+                        end
+                        local was_guessed = false
+                        if not function_name or function_name == "?" then
+                                --for k,v in pairs(info) do print(k,v, type(v)) end
+                                function_name = GuessFunctionName(info)
+                                was_guessed = true
+                        end
+                        -- test if we have a file name
+                        local function_type = (info.namewhat == "") and "function" or info.namewhat
+                        if info.source and info.source:sub(1, 1) == "@" then
+                                if _M.simplified then
+                                        dumper:add_f("(%d) '%s':%d%s\r\n", level_to_show, info.source:sub(2), info.currentline, was_guessed and " (guess)" or "")
+                                else
+                                        dumper:add_f("(%d) Lua %s '%s' at file '%s':%d%s\r\n", level_to_show, function_type, function_name, info.source:sub(2), info.currentline, was_guessed and " (best guess)" or "")
+                                end
+                        elseif info.source and info.source:sub(1,1) == '#' then
+                                if _M.simplified then
+                                        dumper:add_f("(%d) '%s':%d%s\r\n", level_to_show, info.source:sub(2), info.currentline, was_guessed and " (guess)" or "")
+                                else
+                                        dumper:add_f("(%d) Lua %s '%s' at template '%s':%d%s\r\n", level_to_show, function_type, function_name, info.source:sub(2), info.currentline, was_guessed and " (best guess)" or "")
+                                end
+                        else
+                                if _M.simplified then
+                                        dumper:add_f("(%d) '%s':%d\r\n", level_to_show, source, info.currentline)
+                                else
+                                        dumper:add_f("(%d) Lua %s '%s' at chunk '%s':%d\r\n", level_to_show, function_type, function_name, source, info.currentline)
+                                end
+                        end
+                        dumper:DumpLocals(level)
+                else
+                        dumper:add_f("(%d) unknown frame %s\r\n", level_to_show, info.what)
+                end
+
+                level = level + 1
+                level_to_show = level_to_show + 1
+                info = dumper.getinfo(level, "nSlf")
+        end
+
+        return dumper:concat_lines(), original_error
+end
+
+--
+-- Adds a table to the list of known tables
+function _M.add_known_table(tab, description)
+        if m_known_tables[tab] then
+                error("Cannot override an already known table")
+        end
+        m_user_known_tables[tab] = description
+end
+
+--
+-- Adds a function to the list of known functions
+function _M.add_known_function(fun, description)
+        if m_known_functions[fun] then
+                error("Cannot override an already known function")
+        end
+        m_user_known_functions[fun] = description
+end
+
+return _M
+
+)lua_codes";
diff --git a/src/moonc.cpp b/src/moonp.cpp
index d04ce47..a6c99df 100644
--- a/src/moonc.cpp
+++ b/src/moonp.cpp
@@ -13,9 +13,11 @@ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLI
 #include "MoonP/moon_compiler.h"
 #include "MoonP/moon_parser.h"
 
+#ifndef LIBMOONP
+
 int main(int narg, const char** args) {
         const char* help =
-"Usage: moonc [options|files] ...\n\n"
+"Usage: moonp [options|files] ...\n\n"
 "    -h          Print this message\n"
 "    -t path     Specify where to place compiled files\n"
 "    -o file     Write output to file\n"
@@ -82,7 +84,7 @@ int main(int narg, const char** args) {
                 std::cout << "Error: -o can not be used with multiple input files.\n";
                 std::cout << help;
         }
-        if (targetPath.back() != '/' && targetPath.back() != '\\') {
+        if (!targetPath.empty() && targetPath.back() != '/' && targetPath.back() != '\\') {
                 targetPath.append("/");
         }
         std::list<std::future<std::result_of_t<std::decay_t<int()>()>>> results;
@@ -121,14 +123,9 @@ int main(int narg, const char** args) {
                                         } else {
                                                 std::string targetFile;
                                                 if (resultFile.empty()) {
-                                                        std::string ext;
                                                         targetFile = file;
                                                         size_t pos = file.rfind('.');
                                                         if (pos != std::string::npos) {
-                                                                ext = file.substr(pos + 1);
-                                                                for (size_t i = 0; i < ext.length(); i++) {
-                                                                        ext[i] = static_cast<char>(tolower(ext[i]));
-                                                                }
                                                                 targetFile = file.substr(0, pos) + ".lua";
                                                         }
                                                         if (!targetPath.empty()) {
@@ -177,3 +174,120 @@ int main(int narg, const char** args) {
         return ret;
 }
 
+#else
+
+extern "C" {
+
+#include "lua.h"
+#include "lauxlib.h"
+
+static const char moonplusCodes[] =
+#include "MoonPlus.h"
+
+static int init_moonplus(lua_State* L) {
+        MoonP::MoonConfig config;
+        std::string s(moonplusCodes, sizeof(moonplusCodes) / sizeof(moonplusCodes[0]) - 1);
+        std::string codes, err;
+        MoonP::GlobalVars globals;
+        std::tie(codes, err, globals) = MoonP::moonCompile(s, config);
+        if (codes.empty()) {
+                luaL_error(L, "fail to compile moonplus init codes.\n%s", err.c_str());
+        }
+        int top = lua_gettop(L);
+        if (luaL_loadbuffer(L, codes.c_str(), codes.size(), "=(moonplus)") != 0) {
+                luaL_error(L, "fail to init moonplus module.");
+        } else {
+                lua_call(L, 0, 0);
+        }
+        lua_settop(L, top);
+        return 0;
+}
+
+static const char stpCodes[] =
+#include "StackTracePlus.h"
+
+static int init_stacktraceplus(lua_State* L) {
+        if (luaL_loadbuffer(L, stpCodes, sizeof(stpCodes) / sizeof(stpCodes[0]) - 1, "=(stacktraceplus)") != 0) {
+                luaL_error(L, "fail to init stacktraceplus module.");
+        } else {
+                lua_call(L, 0, 1);
+        }
+        return 1;
+}
+
+static int moontolua(lua_State* L) {
+        size_t size = 0;
+        const char* input = luaL_checklstring(L, 1, &size);
+        MoonP::MoonConfig config;
+        if (lua_gettop(L) == 2) {
+                lua_pushstring(L, "lint_global");
+                lua_gettable(L, -2);
+                if (!lua_isnil(L, -1)) {
+                        config.lintGlobalVariable = lua_toboolean(L, -1) != 0;
+                }
+                lua_pop(L, 1);
+                lua_pushstring(L, "implicit_return_root");
+                lua_gettable(L, -2);
+                if (!lua_isnil(L, -1)) {
+                        config.implicitReturnRoot = lua_toboolean(L, -1) != 0;
+                }
+                lua_pop(L, 1);
+                lua_pushstring(L, "reserve_line_number");
+                lua_gettable(L, -2);
+                if (!lua_isnil(L, -1)) {
+                        config.reserveLineNumber = lua_toboolean(L, -1) != 0;
+                }
+                lua_pop(L, 1);
+        }
+        std::string s(input, size);
+        std::string codes, err;
+        MoonP::GlobalVars globals;
+        std::tie(codes, err, globals) = MoonP::moonCompile(s, config);
+        if (codes.empty()) {
+                lua_pushnil(L);
+        } else {
+                lua_pushlstring(L, codes.c_str(), codes.size());
+        }
+        if (err.empty()) {
+                lua_pushnil(L);
+        } else {
+                lua_pushlstring(L, err.c_str(), err.size());
+        }
+        if (globals && !globals->empty()) {
+                lua_createtable(L, static_cast<int>(globals->size()), 0);
+                int i = 1;
+                for (const auto& var : *globals) {
+                        lua_createtable(L, 3, 0);
+                        lua_pushlstring(L, var.name.c_str(), var.name.size());
+                        lua_rawseti(L, -2, 1);
+                        lua_pushinteger(L, var.line);
+                        lua_rawseti(L, -2, 2);
+                        lua_pushinteger(L, var.col);
+                        lua_rawseti(L, -2, 3);
+                        lua_rawseti(L, -2, i);
+                        i++;
+                }
+        } else {
+                lua_pushnil(L);
+        }
+        return 3;
+}
+
+int luaopen_moonp(lua_State* L) {
+        lua_getglobal(L, "package");
+        lua_getfield(L, -1, "loaded");
+        lua_createtable(L, 0, 0);
+        lua_pushcfunction(L, moontolua);
+        lua_setfield(L, -2, "to_lua");
+        lua_pushcfunction(L, init_stacktraceplus);
+        lua_setfield(L, -2, "load_stacktraceplus");
+        lua_setfield(L, -2, "moonp");
+        lua_pop(L, 2);
+        init_moonplus(L);
+        return 0;
+}
+
+} // extern "C"
+
+#endif // LIBMOONP
+