Merge pull request #3237 from xmake-io/masm32

Add masm32 toolchain

5 files changed, 152 insertions, 49 deletions

diff --git a/xmake/modules/core/tools/link.lua b/xmake/modules/core/tools/link.lua
index b5ee775af..38ce20a83 100644
--- a/xmake/modules/core/tools/link.lua
+++ b/xmake/modules/core/tools/link.lua
@@ -140,9 +140,14 @@ function link(self, objectfiles, targetkind, targetfile, flags, opt)
     {
         function ()
 
-            -- use vstool to link and enable vs_unicode_output @see https://github.com/xmake-io/xmake/issues/528
+            local toolchain = self:toolchain()
             local program, argv = linkargv(self, objectfiles, targetkind, targetfile, flags, opt)
-            vstool.runv(program, argv, {envs = self:runenvs()})
+            if toolchain and toolchain:name() == "masm32" then
+                os.iorunv(program, argv, {envs = self:runenvs()})
+            else
+                -- use vstool to link and enable vs_unicode_output @see https://github.com/xmake-io/xmake/issues/528
+                vstool.runv(program, argv, {envs = self:runenvs()})
+            end
         end,
         catch
         {
diff --git a/xmake/modules/core/tools/rc.lua b/xmake/modules/core/tools/rc.lua
index 662a7b618..c3e5f5c12 100644
--- a/xmake/modules/core/tools/rc.lua
+++ b/xmake/modules/core/tools/rc.lua
@@ -122,35 +122,37 @@ function compile(self, sourcefile, objectfile, dependinfo, flags)
         }
     }
 
-    -- try to use cl.exe to parse includes
+    -- try to use cl.exe to parse includes, but cl.exe maybe not exists in masm32 sdk
     -- @see https://github.com/xmake-io/xmake/issues/2562
-    local outfile = os.tmpfile() .. ".rc.out"
-    local errfile = os.tmpfile() .. ".rc.err"
-    local cl = assert(self:toolchain():tool("cxx"), "cl.exe not found!")
-    local ok = try {function () os.execv(cl, {"-E", sourcefile}, {stdout = outfile, stderr = errfile, envs = self:runenvs()}); return true end}
-    if ok and os.isfile(outfile) then
-        local depfiles_rc
-        local includeset = hashset.new()
-        local file = io.open(outfile)
-        local projectdir = os.projectdir()
-        for line in file:lines() do
-            local includefile = _parse_includefile(line)
-            if includefile then
-                includefile = _normailize_dep(includefile, projectdir)
-                if includefile and not includeset:has(includefile)
-                    and path.absolute(includefile) ~= path.absolute(sourcefile)
-                    and os.isfile(includefile) then
-                    depfiles_rc = (depfiles_rc or "") .. "\n" .. includefile
-                    includeset:insert(includefile)
+    local cl = self:toolchain():tool("cxx")
+    if cl then
+        local outfile = os.tmpfile() .. ".rc.out"
+        local errfile = os.tmpfile() .. ".rc.err"
+        local ok = try {function () os.execv(cl, {"-E", sourcefile}, {stdout = outfile, stderr = errfile, envs = self:runenvs()}); return true end}
+        if ok and os.isfile(outfile) then
+            local depfiles_rc
+            local includeset = hashset.new()
+            local file = io.open(outfile)
+            local projectdir = os.projectdir()
+            for line in file:lines() do
+                local includefile = _parse_includefile(line)
+                if includefile then
+                    includefile = _normailize_dep(includefile, projectdir)
+                    if includefile and not includeset:has(includefile)
+                        and path.absolute(includefile) ~= path.absolute(sourcefile)
+                        and os.isfile(includefile) then
+                        depfiles_rc = (depfiles_rc or "") .. "\n" .. includefile
+                        includeset:insert(includefile)
+                    end
                 end
             end
+            file:close()
+            if dependinfo then
+                dependinfo.depfiles_rc = depfiles_rc
+            end
         end
-        file:close()
-        if dependinfo then
-            dependinfo.depfiles_rc = depfiles_rc
-        end
+        os.tryrm(outfile)
+        os.tryrm(errfile)
     end
-    os.tryrm(outfile)
-    os.tryrm(errfile)
 end
 
diff --git a/xmake/modules/detect/sdks/find_masm32.lua b/xmake/modules/detect/sdks/find_masm32.lua
new file mode 100644
index 000000000..3b43e341c
--- /dev/null
+++ b/xmake/modules/detect/sdks/find_masm32.lua
@@ -0,0 +1,94 @@
+--!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, TBOOX Open Source Group.
+--
+-- @author      ruki
+-- @file        find_masm32.lua
+--
+
+-- imports
+import("lib.detect.find_path")
+import("core.base.option")
+import("core.project.config")
+import("core.cache.detectcache")
+
+-- find masm32 directory
+function _find_sdkdir(sdkdir)
+    local paths = {}
+    if sdkdir then
+        table.insert(paths, path.join(sdkdir, "bin"))
+    else
+        for _, logical_drive in ipairs(winos.logical_drives()) do
+            table.insert(paths, path.join(logical_drive, "masm32", "bin"))
+        end
+    end
+    local bindir = find_path("ml.exe", paths)
+    if bindir then
+        return path.directory(bindir)
+    end
+end
+
+-- find masm32 toolchains
+function _find_masm32(sdkdir)
+    sdkdir = _find_sdkdir(sdkdir)
+    if not sdkdir or not os.isdir(sdkdir) then
+        return
+    end
+    return {sdkdir = sdkdir, bindir = path.join(sdkdir, "bin"), includedir = path.join(sdkdir, "include"), libdir = path.join(sdkdir, "lib")}
+end
+
+-- find masm32 toolchains
+--
+-- @param sdkdir    the masm32 directory
+-- @param opt       the argument options, e.g. {verbose = true, force = false}
+--
+-- @return          the masm32 toolchains. e.g. {sdkver = ..., sdkdir, sdkdir_armcc, sdkdir_armclang}
+--
+-- @code
+--
+-- local toolchains = find_masm32("~/masm32")
+--
+-- @endcode
+--
+function main(sdkdir, opt)
+
+    -- init arguments
+    opt = opt or {}
+
+    -- attempt to load cache first
+    local key = "detect.sdks.find_masm32"
+    local cacheinfo = detectcache:get(key) or {}
+    if not opt.force and cacheinfo.masm32 and cacheinfo.masm32.sdkdir and os.isdir(cacheinfo.masm32.sdkdir) then
+        return cacheinfo.masm32
+    end
+
+    -- find masm32
+    local masm32 = _find_masm32(sdkdir or config.get("sdk"))
+    if masm32 then
+        if opt.verbose or option.get("verbose") then
+            cprint("checking for masm32 directory ... ${color.success}%s", masm32.sdkdir)
+        end
+    else
+        if opt.verbose or option.get("verbose") then
+            cprint("checking for masm32 directory ... ${color.nothing}${text.nothing}")
+        end
+    end
+
+    -- save to cache
+    cacheinfo.masm32 = masm32 or false
+    detectcache:set(key, cacheinfo)
+    detectcache:save()
+    return masm32
+end
diff --git a/xmake/modules/detect/tools/find_link.lua b/xmake/modules/detect/tools/find_link.lua
index 0fcff08f0..fedea7b6d 100644
--- a/xmake/modules/detect/tools/find_link.lua
+++ b/xmake/modules/detect/tools/find_link.lua
@@ -39,44 +39,48 @@ function main(opt)
 
     -- init version info first
     local version = nil
+    local verinfo = nil
 
     -- init options
-    opt       = opt or {}
+    opt = opt or {}
     opt.check = opt.check or function (program)
+        local toolchain = opt.toolchain
+        if toolchain and toolchain:name() == "masm32" then
+            -- if this link.exe is from masm32 sdk, we just pass it fastly
+            -- because it does not contain cl.exe
+            --
+            -- TODO maybe we can use ml to improve it
+        else
+            local cl = assert(find_tool("cl", {envs = opt.envs}))
 
-        -- find cl
-        local cl = assert(find_tool("cl", {envs = opt.envs}))
-
-        -- make an stub source file
-        local binaryfile = os.tmpfile() .. ".exe"
-        local objectfile = os.tmpfile() .. ".obj"
-        local sourcefile = os.tmpfile() .. ".c"
+            -- make an stub source file
+            local binaryfile = os.tmpfile() .. ".exe"
+            local objectfile = os.tmpfile() .. ".obj"
+            local sourcefile = os.tmpfile() .. ".c"
 
-        -- compile sourcefile first
-        io.writefile(sourcefile, "int main(int argc, char** argv)\n{return 0;}")
-        os.runv(cl.program, {"-c", "-Fo" .. objectfile, sourcefile}, {envs = opt.envs})
+            -- compile sourcefile first
+            io.writefile(sourcefile, "int main(int argc, char** argv)\n{return 0;}")
+            os.runv(cl.program, {"-c", "-Fo" .. objectfile, sourcefile}, {envs = opt.envs})
 
-        -- do link
-        verinfo = os.iorunv(program, {"-lib", "-out:" .. binaryfile, objectfile}, {envs = opt.envs})
+            -- do link
+            verinfo = os.iorunv(program, {"-lib", "-out:" .. binaryfile, objectfile}, {envs = opt.envs})
 
-        -- remove files
-        os.rm(objectfile)
-        os.rm(sourcefile)
-        os.rm(binaryfile)
+            -- remove files
+            os.rm(objectfile)
+            os.rm(sourcefile)
+            os.rm(binaryfile)
+        end
     end
     opt.command = opt.command or function () return verinfo end
     opt.parse   = opt.parse or function (output) return output:match("Version (%d+%.?%d*%.?%d*.-)%s") end
 
     -- find program
-    local verinfo = nil
     local program = find_program(opt.program or "link.exe", opt)
 
     -- find program version
     if program and opt and opt.version then
         version = find_programver(program, opt)
     end
-
-    -- ok?
     return program, version
 end
 
diff --git a/xmake/modules/detect/tools/find_ml.lua b/xmake/modules/detect/tools/find_ml.lua
index beeab79d7..75999f45a 100644
--- a/xmake/modules/detect/tools/find_ml.lua
+++ b/xmake/modules/detect/tools/find_ml.lua
@@ -50,8 +50,6 @@ function main(opt)
         opt.parse   = opt.parse or function (output) return output:match("Version (%d+%.?%d*%.?%d*.-)%s") end
         version = find_programver(program, opt)
     end
-
-    -- ok?
     return program, version
 end