improve configs

7 files changed, 76 insertions, 32 deletions

diff --git a/tests/apis/add_allowedxxx/xmake.lua b/tests/apis/add_allowedxxx/xmake.lua
index eae1eddc2..8db790ffa 100644
--- a/tests/apis/add_allowedxxx/xmake.lua
+++ b/tests/apis/add_allowedxxx/xmake.lua
@@ -1,9 +1,9 @@
 add_rules("mode.debug", "mode.release")
 
 add_allowedmodes("releasedbg", "debug", {default = "releasedbg"})
-add_allowedplats("windows", "linux", "macosx")
+add_allowedplats("windows", "linux", "macosx", {default = "linux"})
 add_allowedarchs("arm64", "x86_64", {plat = "macosx", default = "x86_64"})
-add_allowedarchs("i386", {plat = "linux"})
+add_allowedarchs("i386", {plat = "linux", default = "i386"})
 
 target("test")
     set_kind("binary")
diff --git a/xmake/actions/config/main.lua b/xmake/actions/config/main.lua
index 9e67eec57..b0cfb6fd6 100644
--- a/xmake/actions/config/main.lua
+++ b/xmake/actions/config/main.lua
@@ -217,6 +217,16 @@ function _check_configs()
         end
     end
 
+    -- check allowed plats
+    local plat = config.plat()
+    local allowed_plats = project.allowed_plats()
+    if allowed_plats then
+        if not allowed_plats:has(plat) then
+            local allowed_plats_str = table.concat(allowed_plats:to_array(), ", ")
+            raise("`%s` is not a valid platform for this project, please use one of %s", plat, allowed_plats_str)
+        end
+    end
+
     -- check allowed archs
     local arch = config.arch()
     local allowed_archs = project.allowed_archs(config.plat())
diff --git a/xmake/actions/config/menuconf.lua b/xmake/actions/config/menuconf.lua
index 5657b30db..7ab6f46dd 100644
--- a/xmake/actions/config/menuconf.lua
+++ b/xmake/actions/config/menuconf.lua
@@ -235,18 +235,23 @@ function app:_basic_configs(cache)
         local default = opt[4]
         local kind    = (opt[3] == "k" or type(default) == "boolean") and "boolean" or "string"
 
-        -- get default platform
+        -- get default values
         if name == "plat" then
             default = find_platform()
         elseif name == "arch" then
             _, default = find_platform()
+        elseif name == "mode" then
+            _, default = project.allowed_modes()
+            if not default then
+                default = "release"
+            end
         end
 
         -- choice option?
         local values = opt.values
         if values then
             if type(values) == "function" then
-                values = values()
+                values = values(false, {menuconf = true})
             end
             for idx, value in ipairs(values) do
                 if default == value then
diff --git a/xmake/actions/config/xmake.lua b/xmake/actions/config/xmake.lua
index c34f68708..4ec09380f 100644
--- a/xmake/actions/config/xmake.lua
+++ b/xmake/actions/config/xmake.lua
@@ -56,8 +56,13 @@ task("config")
                                                                 -- imports
                                                                 import("core.platform.platform")
                                                                 import("core.base.hashset")
+                                                                import("core.project.project")
 
                                                                 if not complete or not opt.arch then
+                                                                    local plats = try {function () return project.allowed_plats() end}
+                                                                    if plats then
+                                                                        return plats:to_array()
+                                                                    end
                                                                     return platform.plats()
                                                                 end
 
@@ -76,32 +81,50 @@ task("config")
                                                             function ()
 
                                                                 -- imports
+                                                                import("core.project.project")
                                                                 import("core.platform.platform")
 
                                                                 -- get all architectures
                                                                 local description = {}
                                                                 for i, plat in ipairs(platform.plats()) do
-                                                                    local archs = platform.archs(plat)
+                                                                    local archs = try {function () return project.allowed_archs(plat) end}
                                                                     if archs then
-                                                                        description[i] = "    - " .. plat .. ":"
+                                                                        archs = archs:to_array()
+                                                                    end
+                                                                    if not archs then
+                                                                        archs = platform.archs(plat)
+                                                                    end
+                                                                    if archs and #archs > 0 then
+                                                                        local desc = "    - " .. plat .. ":"
                                                                         for _, arch in ipairs(archs) do
-                                                                            description[i] = description[i] .. " " .. arch
+                                                                            desc = desc .. " " .. arch
                                                                         end
+                                                                        table.insert(description, desc)
                                                                     end
                                                                 end
                                                                 return description
                                                             end
                                                         ,   values = function (complete, opt)
-                                                                if not complete then return end
+                                                                opt = opt or {}
+                                                                if opt.helpmenu then
+                                                                    return
+                                                                end
 
                                                                 -- imports
+                                                                import("core.project.project")
                                                                 import("core.platform.platform")
                                                                 import("core.base.hashset")
 
                                                                 -- get all architectures
                                                                 local archset = hashset.new()
                                                                 for _, plat in ipairs(opt.plat and { opt.plat } or platform.plats()) do
-                                                                    local archs = platform.archs(plat)
+                                                                    local archs = try {function () return project.allowed_archs(plat) end}
+                                                                    if archs then
+                                                                        archs = archs:to_array()
+                                                                    end
+                                                                    if not archs then
+                                                                        archs = platform.archs(plat)
+                                                                    end
                                                                     if archs then
                                                                         for _, arch in ipairs(archs) do
                                                                             archset:insert(arch)
@@ -112,12 +135,12 @@ task("config")
                                                             end                                                             }
                 ,   {'m', "mode",       "kv", "auto" ,      "Compile for the given mode."
                                                         ,   values = function (complete)
-                                                                if complete then
-                                                                    local modes = (try { function()
-                                                                        return import("core.project.project").modes()
-                                                                    end }) or {"debug", "release"}
-                                                                    return modes
+                                                                import("core.project.project")
+                                                                local modes = try {function() return project.modes() end}
+                                                                if not modes then
+                                                                    modes = {"debug", "release"}
                                                                 end
+                                                                return modes
                                                             end                                                             }
                 ,   {'k', "kind",       "kv", "static"  ,   "Compile for the given target kind."
                                                         ,   values = {"static", "shared", "binary"}                         }
diff --git a/xmake/core/base/option.lua b/xmake/core/base/option.lua
index 539f3f637..6289cf05e 100644
--- a/xmake/core/base/option.lua
+++ b/xmake/core/base/option.lua
@@ -805,7 +805,7 @@ function option.show_options(options, taskname)
             -- append values
             local values = opt.values
             if type(values) == "function" then
-                values = values()
+                values = values(false, {helpmenu = true})
             end
             if values then
                 for _, value in ipairs(table.wrap(values)) do
diff --git a/xmake/core/project/project.lua b/xmake/core/project/project.lua
index a15e71c98..9d253b829 100644
--- a/xmake/core/project/project.lua
+++ b/xmake/core/project/project.lua
@@ -1203,7 +1203,7 @@ end
 
 -- get all modes
 function project.modes()
-    local modes = project.get("allowed_modes") or {}
+    local modes = table.copy(table.wrap(project.get("allowedmodes")))
     for _, target in pairs(table.wrap(project.targets())) do
         for _, rule in ipairs(target:orderules()) do
             local name = rule:name()
@@ -1220,15 +1220,15 @@ end
 -- add_allowedmodes("releasedbg", "debug", {default = "releasedbg"})
 --
 function project.allowed_modes()
-    local allowed_modes_set = project._ALLOWED_MODES
+    local allowed_modes_set = project._memcache():get("allowedmodes")
     if not allowed_modes_set then
         local allowed_modes = table.wrap(project.get("allowedmodes"))
         if #allowed_modes > 0 then
             allowed_modes_set = hashset.from(allowed_modes)
         end
-        project._ALLOWED_MODES = allowed_modes_set or false
+        project._memcache():set("allowedmodes", allowed_modes_set or false)
     end
-    local default_mode = project._DEFAULT_MODE
+    local default_mode = project._memcache():get("allowedmodes.default")
     if not default_mode then
         local allowed_modes = table.wrap(project.get("allowedmodes"))
         for _, allowed_mode in ipairs(allowed_modes) do
@@ -1237,7 +1237,7 @@ function project.allowed_modes()
                 break
             end
         end
-        project._DEFAULT_MODE = default_mode
+        project._memcache():set("allowedmodes.default", default_mode or false)
     end
     return allowed_modes_set or nil, default_mode or nil
 end
@@ -1248,15 +1248,15 @@ end
 -- add_allowedplats("windows", "mingw", "linux", "macosx")
 --
 function project.allowed_plats()
-    local allowed_plats_set = project._ALLOWED_PLATS
+    local allowed_plats_set = project._memcache():get("allowedplats")
     if not allowed_plats_set then
         local allowed_plats = table.wrap(project.get("allowedplats"))
         if #allowed_plats > 0 then
             allowed_plats_set = hashset.from(allowed_plats)
         end
-        project._ALLOWED_PLATS = allowed_plats_set or false
+        project._memcache():set("allowedplats", allowed_plats_set or false)
     end
-    local default_plat = project._DEFAULT_PLAT
+    local default_plat = project._memcache():get("allowedplats.default")
     if not default_plat then
         local allowed_plats = table.wrap(project.get("allowedplats"))
         for _, allowed_plat in ipairs(allowed_plats) do
@@ -1265,7 +1265,7 @@ function project.allowed_plats()
                 break
             end
         end
-        project._DEFAULT_PLAT = default_plat
+        project._memcache():set("allowedplats.default", default_plat or false)
     end
     return allowed_plats_set or nil, default_plat or nil
 end
@@ -1276,20 +1276,22 @@ end
 -- add_allowedarchs("i386", {plat = "linux"})
 --
 function project.allowed_archs(plat)
-    local allowed_archs_set = project._ALLOWED_ARCHS
+    local allowed_archs_set = project._memcache():get2("allowedarchs", plat or "")
     if not allowed_archs_set then
         local allowed_archs = table.wrap(project.get("allowedarchs"))
         if #allowed_archs > 0 then
-            allowed_archs_set = hashset.new()
             for _, allowed_arch in ipairs(allowed_archs) do
                 if not plat or project.extraconf("allowedarchs", allowed_arch, "plat") == plat then
+                    if not allowed_archs_set then
+                        allowed_archs_set = hashset.new()
+                    end
                     allowed_archs_set:insert(allowed_arch)
                 end
             end
         end
-        project._ALLOWED_ARCHS = allowed_archs_set or false
+        project._memcache():set2("allowedarchs", plat or "", allowed_archs_set or false)
     end
-    local default_arch = project._DEFAULT_ARCH
+    local default_arch = project._memcache():get2("allowedarchs.default", plat or "")
     if not default_arch then
         if allowed_archs_set then
             for _, allowed_arch in allowed_archs_set:keys() do
@@ -1299,7 +1301,7 @@ function project.allowed_archs(plat)
                 end
             end
         end
-        project._DEFAULT_ARCH = default_arch
+        project._memcache():set2("allowedarchs.default", plat or "", default_arch or false)
     end
     return allowed_archs_set or nil, default_arch or nil
 end
diff --git a/xmake/modules/private/detect/find_platform.lua b/xmake/modules/private/detect/find_platform.lua
index ebbee55b6..e5a6de09f 100644
--- a/xmake/modules/private/detect/find_platform.lua
+++ b/xmake/modules/private/detect/find_platform.lua
@@ -27,7 +27,12 @@ import("detect.sdks.find_cross_toolchain")
 function _find_plat(plat)
     plat = plat or config.get("plat")
     if not plat then
-        plat = os.subhost()
+        if not plat then
+            _, plat = project.allowed_plats()
+        end
+        if not plat then
+            plat = os.subhost()
+        end
         if plat == "msys" then
             local msystem = os.getenv("MSYSTEM")
             if msystem and msystem:lower():find("mingw", 1, true) then
@@ -83,8 +88,7 @@ function _find_arch(plat, arch)
     arch = arch or config.get("arch")
     if not arch then
         if not arch then
-            local _, default_arch = project.allowed_archs(plat)
-            arch = default_arch
+            _, arch = project.allowed_archs(plat)
         end
         if not arch then
             if plat == "android" then