Merge pull request #6765 from xmake-io/thread

Improve bin2c to use native thread

11 files changed, 328 insertions, 305 deletions

diff --git a/tests/projects/package/toolchain_muslcc/xmake-requires.lock b/tests/projects/package/toolchain_muslcc/xmake-requires.lock
deleted file mode 100644
index 00f23d026..000000000
--- a/tests/projects/package/toolchain_muslcc/xmake-requires.lock
+++ /dev/null
@@ -1,145 +0,0 @@
-{
-    __meta__ = {
-        version = "1.0"
-    },
-    ["macosx|x86_64"] = {
-        ["autoconf#31fecfc4"] = {
-            repo = {
-                branch = "master",
-                commit = "8d4f0875fe9a3c63be4948cefca9f232954e3e87",
-                url = "https://github.com/xmake-io/xmake-repo.git"
-            },
-            version = "2.71"
-        },
-        ["automake#31fecfc4"] = {
-            repo = {
-                branch = "master",
-                commit = "8d4f0875fe9a3c63be4948cefca9f232954e3e87",
-                url = "https://github.com/xmake-io/xmake-repo.git"
-            },
-            version = "1.16.4"
-        },
-        ["cmake#31fecfc4"] = {
-            repo = {
-                branch = "master",
-                commit = "d3260ca0867f8b26aa2a72818bca3e6113a4fc42",
-                url = "https://github.com/xmake-io/xmake-repo.git"
-            },
-            version = "3.22.1"
-        },
-        ["gmp#31fecfc4"] = {
-            repo = {
-                branch = "master",
-                commit = "8d4f0875fe9a3c63be4948cefca9f232954e3e87",
-                url = "https://github.com/xmake-io/xmake-repo.git"
-            },
-            version = "6.2.1"
-        },
-        ["libisl 0.22#67114504"] = {
-            repo = {
-                branch = "master",
-                commit = "8d4f0875fe9a3c63be4948cefca9f232954e3e87",
-                url = "https://github.com/xmake-io/xmake-repo.git"
-            },
-            version = "0.22"
-        },
-        ["libogg#31fecfc4"] = {
-            repo = {
-                branch = "master",
-                commit = "8d4f0875fe9a3c63be4948cefca9f232954e3e87",
-                url = "https://github.com/xmake-io/xmake-repo.git"
-            },
-            version = "v1.3.4"
-        },
-        ["libplist#31fecfc4"] = {
-            repo = {
-                branch = "master",
-                commit = "8d4f0875fe9a3c63be4948cefca9f232954e3e87",
-                url = "https://github.com/xmake-io/xmake-repo.git"
-            },
-            version = "2.2.0"
-        },
-        ["libtool#31fecfc4"] = {
-            repo = {
-                branch = "master",
-                commit = "dd4abbd658b9897c9e1dcacf2e4bdeeb02d05860",
-                url = "https://github.com/xmake-io/xmake-repo.git"
-            },
-            version = "2.4.6"
-        },
-        ["m4#31fecfc4"] = {
-            repo = {
-                branch = "master",
-                commit = "8d4f0875fe9a3c63be4948cefca9f232954e3e87",
-                url = "https://github.com/xmake-io/xmake-repo.git"
-            },
-            version = "1.4.19"
-        },
-        ["muslcc#31fecfc4"] = {
-            repo = {
-                branch = "master",
-                commit = "8d4f0875fe9a3c63be4948cefca9f232954e3e87",
-                url = "https://github.com/xmake-io/xmake-repo.git"
-            },
-            version = "20210202"
-        },
-        ["pkg-config#31fecfc4"] = {
-            repo = {
-                branch = "master",
-                commit = "8d4f0875fe9a3c63be4948cefca9f232954e3e87",
-                url = "https://github.com/xmake-io/xmake-repo.git"
-            },
-            version = "0.29.2"
-        },
-        ["zlib#31fecfc4"] = {
-            repo = {
-                branch = "master",
-                commit = "8d4f0875fe9a3c63be4948cefca9f232954e3e87",
-                url = "https://github.com/xmake-io/xmake-repo.git"
-            },
-            version = "v1.2.11"
-        }
-    },
-    ["windows|x64"] = {
-        ["cmake#31fecfc4"] = {
-            repo = {
-                branch = "master",
-                commit = "8d4f0875fe9a3c63be4948cefca9f232954e3e87",
-                url = "https://github.com/xmake-io/xmake-repo.git"
-            },
-            version = "3.22.1"
-        },
-        ["libogg#31fecfc4"] = {
-            repo = {
-                branch = "master",
-                commit = "2b1cb74b289ae3221241985db4401a495c42fde3",
-                url = "https://github.com/xmake-io/xmake-repo.git"
-            },
-            version = "v1.3.4"
-        },
-        ["make#31fecfc4"] = {
-            repo = {
-                branch = "master",
-                commit = "8d4f0875fe9a3c63be4948cefca9f232954e3e87",
-                url = "https://github.com/xmake-io/xmake-repo.git"
-            },
-            version = "4.3"
-        },
-        ["muslcc#31fecfc4"] = {
-            repo = {
-                branch = "master",
-                commit = "8d4f0875fe9a3c63be4948cefca9f232954e3e87",
-                url = "https://github.com/xmake-io/xmake-repo.git"
-            },
-            version = "20210202"
-        },
-        ["zlib#31fecfc4"] = {
-            repo = {
-                branch = "master",
-                commit = "8d4f0875fe9a3c63be4948cefca9f232954e3e87",
-                url = "https://github.com/xmake-io/xmake-repo.git"
-            },
-            version = "v1.2.11"
-        }
-    }
-}
diff --git a/xmake/core/base/libc.lua b/xmake/core/base/libc.lua
index 141bd4f64..f9a12931e 100644
--- a/xmake/core/base/libc.lua
+++ b/xmake/core/base/libc.lua
@@ -121,8 +121,9 @@ function libc.setbyte(data, offset, value)
 end
 
 function libc.dataptr(data, opt)
-    if ffi then
-        if opt and opt.gc then
+    opt = opt or {}
+    if ffi and opt.ffi ~= false then
+        if opt.gc then
             return ffi.gc(ffi.cast("unsigned char*", data), ffi.C.free)
         else
             return ffi.cast("unsigned char*", data)
@@ -132,8 +133,9 @@ function libc.dataptr(data, opt)
     end
 end
 
-function libc.ptraddr(data)
-    if ffi then
+function libc.ptraddr(data, opt)
+    opt = opt or {}
+    if ffi and opt.ffi ~= false then
         return tonumber(ffi.cast('unsigned long long', data))
     else
         return data
diff --git a/xmake/core/base/thread.lua b/xmake/core/base/thread.lua
index a53e7bc82..3856feb81 100644
--- a/xmake/core/base/thread.lua
+++ b/xmake/core/base/thread.lua
@@ -105,19 +105,19 @@ function _thread:start()
             -- is mutex? we can only pass cdata address
             if arg._MUTEX and arg.cdata then
                 thread.mutex_incref(arg:cdata())
-                arg = {mutex = true, name = arg:name(), caddr = libc.dataptr(arg:cdata())}
+                arg = {mutex = true, name = arg:name(), caddr = libc.dataptr(arg:cdata(), {ffi = false})}
             -- is event? we can only pass cdata address
             elseif arg._EVENT and arg.cdata then
                 thread.event_incref(arg:cdata())
-                arg = {event = true, name = arg:name(), caddr = libc.dataptr(arg:cdata())}
+                arg = {event = true, name = arg:name(), caddr = libc.dataptr(arg:cdata(), {ffi = false})}
             -- is semaphore? we can only pass cdata address
             elseif arg._SEMAPHORE and arg.cdata then
                 thread.semaphore_incref(arg:cdata())
-                arg = {semaphore = true, name = arg:name(), caddr = libc.dataptr(arg:cdata())}
+                arg = {semaphore = true, name = arg:name(), caddr = libc.dataptr(arg:cdata(), {ffi = false})}
             -- is queue? we can only pass cdata address
             elseif arg._QUEUE and arg.cdata then
                 thread.queue_incref(arg:cdata())
-                arg = {queue = true, name = arg:name(), caddr = libc.dataptr(arg:cdata())}
+                arg = {queue = true, name = arg:name(), caddr = libc.dataptr(arg:cdata(), {ffi = false})}
             -- is sharedata? we can only pass cdata address
             elseif arg._SHAREDATA and arg.cdata then
                 thread.sharedata_incref(arg:cdata())
@@ -132,9 +132,9 @@ function _thread:start()
     local callinfo = {name = self:name(), argv = argv}
 
     -- we need a pipe pair to wait and listen thread exit event
-    local rpipe, wpipe = pipe.openpair("BA") -- rpipe (block)
+    local rpipe, wpipe = pipe.openpair("AA")
     self._RPIPE = rpipe
-    callinfo.wpipe = libc.dataptr(wpipe:cdata())
+    callinfo.wpipe = libc.dataptr(wpipe:cdata(), {ffi = false})
     -- we need to suppress gc to free it, because it has been transfer to thread in another lua state instance
     wpipe._PIPE = nil
 
@@ -198,7 +198,14 @@ function _thread:wait(timeout)
     local ok, errors
     local rpipe = self._RPIPE
     if rpipe and scheduler:co_running() then
-        ok, errors = rpipe:wait(pipe.EV_READ, timeout)
+        local buff = bytes(16)
+        local read, data_or_errors = rpipe:read(buff, 1, {block = true, timeout = timeout})
+        if read > 0 then
+            ok = 1
+        else
+            ok = read
+            errors = data_or_errors
+        end
     else
         ok, errors = thread.thread_wait(self:cdata(), timeout)
     end
@@ -206,6 +213,11 @@ function _thread:wait(timeout)
         return -1, errors or string.format("%s: failed to resume thread!", self)
     end
 
+    if rpipe then
+        rpipe:close()
+        self._RPIPE = nil
+    end
+
     if ok > 0 then
         self._STATUS = thread.STATUS_DEAD
     end
@@ -232,6 +244,10 @@ function _thread:__gc()
     if self:cdata() and self:is_dead() and thread.thread_exit(self:cdata()) then
         self._HANLDE = nil
     end
+    if self._RPIPE then
+        self._RPIPE:close()
+        self._RPIPE = nil
+    end
 end
 
 -- new an mutex
@@ -801,7 +817,7 @@ function thread._run_thread(callback_str, callinfo_str)
         if callinfo then
             argv = callinfo.argv
             threadname = callinfo.name
-            wpipe = pipe.new(libc.ptraddr(callinfo.wpipe))
+            wpipe = pipe.new(libc.ptraddr(callinfo.wpipe, {ffi = false}))
         end
     end
 
@@ -842,15 +858,15 @@ function thread._run_thread(callback_str, callinfo_str)
         local newargv = {}
         for _, arg in ipairs(argv) do
             if type(arg) == "table" and arg.mutex and arg.caddr then
-                arg = _mutex.new(arg.name, libc.ptraddr(arg.caddr))
+                arg = _mutex.new(arg.name, libc.ptraddr(arg.caddr, {ffi = false}))
             elseif type(arg) == "table" and arg.event and arg.caddr then
-                arg = _event.new(arg.name, libc.ptraddr(arg.caddr))
+                arg = _event.new(arg.name, libc.ptraddr(arg.caddr, {ffi = false}))
             elseif type(arg) == "table" and arg.semaphore and arg.caddr then
-                arg = _semaphore.new(arg.name, libc.ptraddr(arg.caddr))
+                arg = _semaphore.new(arg.name, libc.ptraddr(arg.caddr, {ffi = false}))
             elseif type(arg) == "table" and arg.queue and arg.caddr then
-                arg = _queue.new(arg.name, libc.ptraddr(arg.caddr))
+                arg = _queue.new(arg.name, libc.ptraddr(arg.caddr, {ffi = false}))
             elseif type(arg) == "table" and arg.sharedata and arg.caddr then
-                arg = _sharedata.new(arg.name, libc.ptraddr(arg.caddr))
+                arg = _sharedata.new(arg.name, libc.ptraddr(arg.caddr, {ffi = false}))
             end
             table.insert(newargv, arg)
         end
@@ -862,10 +878,11 @@ function thread._run_thread(callback_str, callinfo_str)
 
     -- thread is finished, we need to notify the waited thread
     if wpipe then
-        local ok, errors = wpipe:write("exited")
-        if ok == nil then
+        local ok, errors = wpipe:write("1", {block = true})
+        if ok < 0 then
             return false, errors
         end
+        wpipe:close()
     end
     return ok, errors
 end
diff --git a/xmake/modules/private/utils/batchcmds.lua b/xmake/modules/private/utils/batchcmds.lua
index 944507397..268f34154 100644
--- a/xmake/modules/private/utils/batchcmds.lua
+++ b/xmake/modules/private/utils/batchcmds.lua
@@ -28,6 +28,7 @@ import("core.theme.theme")
 import("core.tool.linker")
 import("core.tool.compiler")
 import("core.language.language")
+import("utils.run_script")
 import("utils.progress", {alias = "progress_utils"})
 import("utils.binary.rpath", {alias = "rpath_utils"})
 
@@ -102,9 +103,7 @@ end
 -- run command: os.execv
 function _runcmd_execv(cmd, opt)
     if cmd.program then
-        if opt.dryrun then
-            print(os.args(table.join(cmd.program, cmd.argv)))
-        else
+        if not opt.dryrun then
             os.execv(cmd.program, cmd.argv, cmd.opt)
         end
     end
@@ -114,13 +113,47 @@ end
 function _runcmd_vexecv(cmd, opt)
     if cmd.program then
         if opt.dryrun then
-            print(os.args(table.join(cmd.program, cmd.argv)))
+            vprint(os.args(table.join(cmd.program, cmd.argv)))
         else
             os.vexecv(cmd.program, cmd.argv, cmd.opt)
         end
     end
 end
 
+-- run command: lua
+function _runcmd_lua(cmd, opt)
+    if cmd.script then
+        if not opt.dryrun then
+            local runopt = table.clone(cmd.opt) or {}
+            runopt.arguments = cmd.argv
+            runopt.quiet = true
+            -- it will run in a separate native thread, which will not block other coroutine jobs
+            runopt.thread = true
+            run_script(cmd.script, runopt)
+        end
+    end
+end
+
+-- run command: vlua
+function _runcmd_vlua(cmd, opt)
+    if cmd.script then
+        vprint(os.args(table.join("xmake", "lua", cmd.script, cmd.argv)))
+        if not opt.dryrun then
+            local runopt = table.clone(cmd.opt) or {}
+            runopt.arguments = cmd.argv
+            if option.get("diagnosis") then
+                runopt.verbose = true
+                runopt.diagnosis = true
+            else
+                runopt.quiet = not option.get("verbose")
+            end
+            -- it will run in a separate native thread, which will not block other coroutine jobs
+            runopt.thread = true
+            run_script(cmd.script, runopt)
+        end
+    end
+end
+
 -- run command: os.mkdir
 function _runcmd_mkdir(cmd, opt)
     local dir = cmd.dir
@@ -214,6 +247,8 @@ function _runcmd(cmd, opt)
             vrunv        = _runcmd_vrunv,
             execv        = _runcmd_execv,
             vexecv       = _runcmd_vexecv,
+            lua          = _runcmd_lua,
+            vlua         = _runcmd_vlua,
             mkdir        = _runcmd_mkdir,
             rmdir        = _runcmd_rmdir,
             cd           = _runcmd_cd,
@@ -271,6 +306,16 @@ function batchcmds:vexecv(program, argv, opt)
     table.insert(self:cmds(), {kind = "vexecv", program = program, argv = argv, opt = opt})
 end
 
+-- add command: run lua script file, command or module
+function batchcmds:lua(script, argv, opt)
+    table.insert(self:cmds(), {kind = "lua", script = script, argv = argv, opt = opt})
+end
+
+-- add command: run lua script file, command or module
+function batchcmds:vlua(script, argv, opt)
+    table.insert(self:cmds(), {kind = "vlua", script = script, argv = argv, opt = opt})
+end
+
 -- add command: compiler.compile
 function batchcmds:compile(sourcefiles, objectfile, opt)
 
diff --git a/xmake/modules/utils/run_script.lua b/xmake/modules/utils/run_script.lua
new file mode 100644
index 000000000..de625119f
--- /dev/null
+++ b/xmake/modules/utils/run_script.lua
@@ -0,0 +1,209 @@
+--!A cross-platform build utility based on Lua
+--
+-- Licensed under the Apache License, Version 2.0 (the "License");
+-- you may not use this file except in compliance with the License.
+-- You may obtain a copy of the License at
+--
+--     http://www.apache.org/licenses/LICENSE-2.0
+--
+-- Unless required by applicable law or agreed to in writing, software
+-- distributed under the License is distributed on an "AS IS" BASIS,
+-- WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+-- See the License for the specific language governing permissions and
+-- limitations under the License.
+--
+-- Copyright (C) 2015-present, Xmake Open Source Community.
+--
+-- @author      ruki
+-- @file        run.lua
+--
+
+-- imports
+import("core.base.option")
+import("core.base.thread")
+import("core.sandbox.module")
+
+-- print verbose log
+function _print_vlog(script_type, script_name, args, opt)
+    if not opt.verbose then
+        return
+    end
+    cprintf("running %s ${underline}%s${reset}", script_type, script_name)
+    if args.n > 0 then
+        print(" with args:")
+        if not opt.diagnosis then
+            for i = 1, args.n do
+                print("  - " .. todisplay(args[i]))
+            end
+        else
+            utils.dump(table.unpack(args, 1, args.n))
+        end
+    else
+        print(".")
+    end
+end
+
+function _is_callable(func)
+    if type(func) == "function" then
+        return true
+    elseif type(func) == "table" then
+        local meta = debug.getmetatable(func)
+        if meta and meta.__call then
+            return true
+        end
+    end
+end
+
+function _run_script(script, args, opt)
+
+    local func
+    local printresult = false
+    local script_type, script_name
+
+    -- import and run script
+    if path.extension(script) == ".lua" and os.isfile(script) then
+
+        -- run the given lua script file (xmake lua /tmp/script.lua)
+        script_type, script_name = "given lua script file", path.relative(script)
+        func = import(path.basename(script), {rootdir = path.directory(script), anonymous = true})
+    elseif os.isfile(path.join(os.scriptdir(), "scripts", script .. ".lua")) then
+
+        -- run builtin lua script (xmake lua echo "hello xmake")
+        script_type, script_name = "builtin lua script", script
+        func = import("scripts." .. script, {anonymous = true})
+    else
+
+        -- attempt to find the builtin module
+        local object = nil
+        for _, name in ipairs(script:split("%.")) do
+            object = object and object[name] or module.get(name)
+            if not object then
+                break
+            end
+        end
+        if object then
+            -- run builtin modules (xmake lua core.xxx.xxx)
+            script_type, script_name = "builtin module", script
+            func = object
+        else
+            -- run imported modules (xmake lua core.xxx.xxx)
+            script_type, script_name = "imported module", script
+            func = import(script, {anonymous = true})
+        end
+        printresult = true
+    end
+
+    -- print verbose log
+    _print_vlog(script_type or "script", script_name or "", args, opt)
+
+    -- dump func() result
+    if _is_callable(func) then
+        local result = table.pack(func(table.unpack(args, 1, args.n)))
+        if printresult and result and result.n ~= 0 then
+            utils.dump(table.unpack(result, 1, result.n))
+        end
+    else
+        -- dump variables directly
+        utils.dump(func)
+    end
+end
+
+function _run_commanad(command, args, opt)
+    local tmpfile = os.tmpfile() .. ".lua"
+    io.writefile(tmpfile, "function main(...)\n" .. command .. "\nend")
+    _run_script(tmpfile, args, opt)
+end
+
+function _get_args(opt)
+    opt = opt or {}
+
+    -- get arguments
+    local args = opt.arguments or {}
+    args.n = #args
+
+    -- get deserialize tag
+    local deserialize = opt.deserialize
+    if not deserialize then
+        return args
+    end
+    deserialize = tostring(deserialize)
+
+    -- deserialize prefixed arguments
+    for i, value in ipairs(args) do
+        if value:startswith(deserialize) then
+            local v, err = string.deserialize(value:sub(#deserialize + 1))
+            if err then
+                raise(err)
+            else
+                args[i] = v
+            end
+        end
+    end
+    return args
+end
+
+function _run(script, opt)
+    opt = opt or {}
+
+    if opt.quiet then
+        option.save()
+        option.set("quiet", true, {force = true})
+    end
+
+    local curdir = opt.curdir or os.workingdir()
+    local oldir = os.cd(curdir)
+    if opt.command then
+        _run_commanad(script, _get_args(opt), opt)
+    else
+        _run_script(script, _get_args(opt), opt)
+    end
+    os.cd(oldir)
+
+    if opt.quiet then
+        option.restore()
+    end
+end
+
+function _run_in_thread(script, opt)
+    import("utils.run_script", {anonymous = true})(script, opt)
+end
+
+-- run lua script
+--
+-- @param script      the script file or string or module name
+--                    e.g. /tmp/test.lua, "print("hello")", "utils.bin2c"
+-- @param opt         the options
+--                     - curdir      the currect directory
+--                     - command     run script as command
+--                     - deserialize deserialize arguments starts with given prefix
+--                     - arguments   the script arguments
+--                     - thread      run script in a new native thread
+--                     - quiet       enable quiet output
+--                     - verbose     enable verbose output
+--                     - diagnosis   enable diagnosis output
+function main(script, opt)
+    opt = opt or {}
+    if opt.thread then
+        local argv
+        for _, arg in ipairs(opt.arguments) do
+            argv = argv or {}
+            if path.instance_of(arg) then
+                arg = tostring(arg)
+            end
+            table.insert(argv, arg)
+        end
+        local thread_opt = {
+            curdir = curdir,
+            command = opt.command,
+            deserialize = opt.deserialize,
+            arguments = argv,
+            quiet = opt.quiet,
+            verbose = opt.verbose,
+            diagnosis = opt.diagnosis
+        }
+        local t = thread.start_named("utils.run_script", _run_in_thread, script, thread_opt)
+        t:wait(-1)
+    else
+        _run(script, opt)
+    end
+end
diff --git a/xmake/plugins/lua/main.lua b/xmake/plugins/lua/main.lua
index e3cabc19c..2b0a9efe2 100644
--- a/xmake/plugins/lua/main.lua
+++ b/xmake/plugins/lua/main.lua
@@ -23,14 +23,17 @@ import("core.base.option")
 import("core.sandbox.module")
 import("core.sandbox.sandbox")
 import("core.project.project")
+import("utils.run_script")
 
 -- get all lua scripts
 function scripts()
     local names = {}
+    local oldir = os.cd(os.workingdir())
     local files = os.files(path.join(os.scriptdir(), "scripts/*.lua"))
     for _, file in ipairs(files) do
         table.insert(names, path.basename(file))
     end
+    os.cd(oldir)
     return names
 end
 
@@ -42,143 +45,25 @@ function _list()
     end
 end
 
--- print verbose log
-function _print_vlog(script_type, script_name, args)
-    if not option.get("verbose") then return end
-    cprintf("running %s ${underline}%s${reset}", script_type, script_name)
-    if args.n > 0 then
-        print(" with args:")
-        if not option.get("diagnosis") then
-            for i = 1, args.n do
-                print("  - " .. todisplay(args[i]))
-            end
-        else
-            utils.dump(table.unpack(args, 1, args.n))
-        end
-    else
-        print(".")
-    end
-end
-
-function _run_commanad(command, args)
-    local tmpfile = os.tmpfile() .. ".lua"
-    io.writefile(tmpfile, "function main(...)\n" .. command .. "\nend")
-    return _run_script(tmpfile, args)
-end
-
-function _is_callable(func)
-    if type(func) == "function" then
-        return true
-    elseif type(func) == "table" then
-        local meta = debug.getmetatable(func)
-        if meta and meta.__call then
-            return true
-        end
-    end
-end
-
-function _run_script(script, args)
-
-    local func
-    local printresult = false
-    local script_type, script_name
-
-    -- import and run script
-    if path.extension(script) == ".lua" and os.isfile(script) then
-
-        -- run the given lua script file (xmake lua /tmp/script.lua)
-        script_type, script_name = "given lua script file", path.relative(script)
-        func = import(path.basename(script), {rootdir = path.directory(script), anonymous = true})
-    elseif os.isfile(path.join(os.scriptdir(), "scripts", script .. ".lua")) then
-
-        -- run builtin lua script (xmake lua echo "hello xmake")
-        script_type, script_name = "builtin lua script", script
-        func = import("scripts." .. script, {anonymous = true})
-    else
-
-        -- attempt to find the builtin module
-        local object = nil
-        for _, name in ipairs(script:split("%.")) do
-            object = object and object[name] or module.get(name)
-            if not object then
-                break
-            end
-        end
-        if object then
-            -- run builtin modules (xmake lua core.xxx.xxx)
-            script_type, script_name = "builtin module", script
-            func = object
-        else
-            -- run imported modules (xmake lua core.xxx.xxx)
-            script_type, script_name = "imported module", script
-            func = import(script, {anonymous = true})
-        end
-        printresult = true
-    end
-
-    -- print verbose log
-    _print_vlog(script_type or "script", script_name or "", args)
-
-    -- dump func() result
-    if _is_callable(func) then
-        local result = table.pack(func(table.unpack(args, 1, args.n)))
-        if printresult and result and result.n ~= 0 then
-            utils.dump(table.unpack(result, 1, result.n))
-        end
-    else
-        -- dump variables directly
-        utils.dump(func)
-    end
-end
-
-function _get_args()
-
-    -- get arguments
-    local args = option.get("arguments") or {}
-    args.n = #args
-
-    -- get deserialize tag
-    local deserialize = option.get("deserialize")
-    if not deserialize then
-        return args
-    end
-    deserialize = tostring(deserialize)
-
-    -- deserialize prefixed arguments
-    for i, value in ipairs(args) do
-        if value:startswith(deserialize) then
-            local v, err = string.deserialize(value:sub(#deserialize + 1))
-            if err then
-                raise(err)
-            else
-                args[i] = v
-            end
-        end
-    end
-    return args
-end
-
 function main()
 
-    -- restore to the current working directory
-    os.cd(os.workingdir())
-
     -- list builtin scripts
     if option.get("list") then
         return _list()
     end
 
-    -- run command?
+    -- run script
     local script = option.get("script")
-    if option.get("command") and script then
-        return _run_commanad(script, _get_args())
-    end
-
-    -- get script
     if script then
-        return _run_script(script, _get_args())
+        run_script(script, {
+            curdir = os.workingdir(),
+            verbose = option.get("verbose"),
+            diagnosis = option.get("diagnosis"),
+            command = option.get("command"),
+            arguments = option.get("arguments"),
+            deserialize = option.get("deserialize")})
+    else
+        -- enter interactive mode
+        sandbox.interactive()
     end
-
-    -- enter interactive mode
-    sandbox.interactive()
 end
diff --git a/xmake/plugins/project/utils/target_cmds.lua b/xmake/plugins/project/utils/target_cmds.lua
index ab1f8b42a..25413912a 100644
--- a/xmake/plugins/project/utils/target_cmds.lua
+++ b/xmake/plugins/project/utils/target_cmds.lua
@@ -79,6 +79,16 @@ function get_target_buildcmds(target, opt)
             end
         end
     end
+    -- translate batchcmds:lua to batchcmds:runv, we need to generate executable commmand
+    for _, cmd in ipairs(buildcmds:cmds()) do
+        local kind = cmd.kind
+        if cmd.script and (kind == "lua" or kind == "vlua") then
+            cmd.kind = (kind == "vlua") and "vrunv" or "runv"
+            cmd.program = os.programfile()
+            cmd.argv = table.join("lua", cmd.script, cmd.argv)
+            cmd.script = nil
+        end
+    end
     return buildcmds:cmds()
 end
 
diff --git a/xmake/rules/utils/bin2c/xmake.lua b/xmake/rules/utils/bin2c/xmake.lua
index 9bed0f658..082e8fb5b 100644
--- a/xmake/rules/utils/bin2c/xmake.lua
+++ b/xmake/rules/utils/bin2c/xmake.lua
@@ -38,7 +38,7 @@ rule("utils.bin2c")
         -- add commands
         batchcmds:show_progress(opt.progress, "${color.build.object}generating.bin2c %s", sourcefile_bin)
         batchcmds:mkdir(headerdir)
-        local argv = {"lua", "private.utils.bin2c", "-i", path(sourcefile_bin), "-o", path(headerfile)}
+        local argv = {"-i", path(sourcefile_bin), "-o", path(headerfile)}
         local linewidth = target:extraconf("rules", "utils.bin2c", "linewidth")
         if linewidth then
             table.insert(argv, "-w")
@@ -48,7 +48,7 @@ rule("utils.bin2c")
         if nozeroend then
             table.insert(argv, "--nozeroend")
         end
-        batchcmds:vrunv(os.programfile(), argv, {envs = {XMAKE_SKIP_HISTORY = "y"}})
+        batchcmds:vlua("private.utils.bin2c", argv)
 
         -- add deps
         batchcmds:add_depfiles(sourcefile_bin)
diff --git a/xmake/rules/utils/glsl2spv/xmake.lua b/xmake/rules/utils/glsl2spv/xmake.lua
index 83988287e..dfd1779fe 100644
--- a/xmake/rules/utils/glsl2spv/xmake.lua
+++ b/xmake/rules/utils/glsl2spv/xmake.lua
@@ -85,8 +85,8 @@ rule("utils.glsl2spv")
             outputfile = headerfile
 
             -- add commands
-            local argv = {"lua", "private.utils.bin2c", "--nozeroend", "-i", path(spvfilepath), "-o", path(headerfile)}
-            batchcmds:vrunv(os.programfile(), argv, {envs = {XMAKE_SKIP_HISTORY = "y"}})
+            local argv = {"--nozeroend", "-i", path(spvfilepath), "-o", path(headerfile)}
+            batchcmds:vlua("private.utils.bin2c", argv)
         end
 
         -- add deps
diff --git a/xmake/rules/utils/hlsl2spv/xmake.lua b/xmake/rules/utils/hlsl2spv/xmake.lua
index 7815290fb..2b285d893 100644
--- a/xmake/rules/utils/hlsl2spv/xmake.lua
+++ b/xmake/rules/utils/hlsl2spv/xmake.lua
@@ -85,8 +85,8 @@ rule("utils.hlsl2spv")
             outputfile = headerfile
 
             -- add commands
-            local argv = {"lua", "private.utils.bin2c", "--nozeroend", "-i", path(spvfilepath), "-o", path(headerfile)}
-            batchcmds:vrunv(os.programfile(), argv, {envs = {XMAKE_SKIP_HISTORY = "y"}})
+            local argv = {"--nozeroend", "-i", path(spvfilepath), "-o", path(headerfile)}
+            batchcmds:vlua("private.utils.bin2c", argv)
         end
 
         batchcmds:add_depfiles(sourcefile_hlsl)
diff --git a/xmake/rules/xmake_cli/xmake.lua b/xmake/rules/xmake_cli/xmake.lua
index 6f599f9bd..d3a4b6f26 100644
--- a/xmake/rules/xmake_cli/xmake.lua
+++ b/xmake/rules/xmake_cli/xmake.lua
@@ -54,8 +54,8 @@ rule("xmake.cli")
         local headerdir = path.join(target:autogendir(), "rules", "xmake.cli", "include")
         local headerfile = path.join(headerdir, "luafiles.xmz.h")
         target:add("includedirs", headerdir)
-        argv = {"lua", "private.utils.bin2c", "--nozeroend", "-i", path(archivefile), "-o", path(headerfile)}
-        batchcmds:vrunv(os.programfile(), argv, {envs = {XMAKE_SKIP_HISTORY = "y"}})
+        argv = {"--nozeroend", "-i", path(archivefile), "-o", path(headerfile)}
+        batchcmds:vlua("private.utils.bin2c", argv)
 
         batchcmds:add_depfiles(sourcefiles)
         batchcmds:set_depmtime(os.mtime(dependfile))