add archs interfaces

1 files changed, 0 insertions, 279 deletions

diff --git a/xmake/scripts/base/preprocessor.lua b/xmake/scripts/base/preprocessor.lua
deleted file mode 100644
index a8fd9fa39..000000000
--- a/xmake/scripts/base/preprocessor.lua
+++ /dev/null
@@ -1,279 +0,0 @@
---!The Automatic Cross-platform Build Tool
--- 
--- XMake is free software; you can redistribute it and/or modify
--- it under the terms of the GNU Lesser General Public License as published by
--- the Free Software Foundation; either version 2.1 of the License, or
--- (at your option) any later version.
--- 
--- XMake is distributed in the hope that it will be useful,
--- but WITHOUT ANY WARRANTY; without even the implied warranty of
--- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
--- GNU Lesser General Public License for more details.
--- 
--- You should have received a copy of the GNU Lesser General Public License
--- along with XMake; 
--- If not, see <a href="http://www.gnu.org/licenses/"> http://www.gnu.org/licenses/</a>
--- 
--- Copyright (C) 2009 - 2015, ruki All rights reserved.
---
--- @author      ruki
--- @file        preprocessor.lua
---
-
--- define module: preprocessor
-local preprocessor = preprocessor or {}
-
--- load modules
-local utils = require("base/utils")
-
--- filter value
-function preprocessor._filter(env, value, filter)
-
-    -- the value is string?
-    if type(value) == "string" then
-
-        -- init
-        local _v = nil
-        local _n = 0
-
-        -- replace it for filter
-        if filter then
-            -- replace $(variable)
-            _v, _n = value:gsub("%$%((.*)%)", function (v) return filter(env, v) end)
-        end
-
-        -- replace it for script
-        if _n == 0 then
-            _v, _n = value:gsub("%[(.*)%]",     function (v) 
-
-                                                    -- load the script
-                                                    local script = assert(loadstring("return " .. v))
-
-                                                    -- bind the envirnoment
-                                                    setfenv(script, env)
-
-                                                    -- done it
-                                                    local ok, result = pcall(script)
-                                                    if not ok then return end
-
-                                                    -- ok?
-                                                    return result or ""
-                                                end)
-        end
-
-        -- update value
-        value = _v
-    end
-
-    -- ok
-    return value
-end
-
--- register configures
-function preprocessor._register(env, names, filter)
-
-    -- check
-    assert(env and names and type(names) == "table")
-    assert(not filter or type(filter) == "function")
-
-    -- register all configures
-    for _, name in ipairs(names) do
-
-        -- register the configure 
-        env[name] = env[name] or function(...)
-
-            -- check
-            local _current = env._current
-            assert(_current)
-
-            -- init the configure entry
-            _current[name] = _current[name] or {}
-
-            -- get arguments
-            local arg = arg or {...}
-            if table.getn(arg) == 0 then
-                -- no argument
-                _current[name] = nil
-            else
-                -- save all arguments
-                for _, v in ipairs(arg) do
-                    v = preprocessor._filter(env, v, filter)
-                    if v and type(v) == "string" and #v ~= 0 then
-                        table.insert(_current[name], v)
-                    end
-                end
-            end
-        end
-    end
-end
-
--- init configures
-function preprocessor._init(root, configures, scopes, filter, import)
-
-    -- check
-    assert(root and configures)
-
-    -- enter new environment 
-    local newenv = {}
-    local oldenv = getfenv()
-    setmetatable(newenv, {  __index =   function(tbl, key)
-                                            -- private configure entry? we can get it directly and need not register it
-                                            if key and type(key) == "string" and key:startswith("__") then
-
-                                                return function(...)
-
-                                                    -- check
-                                                    local _current = newenv._current
-                                                    assert(_current)
-
-                                                    -- init the configure entry
-                                                    _current[key] = _current[key] or {}
-
-                                                    -- get arguments
-                                                    local arg = arg or {...}
-                                                    if table.getn(arg) == 0 then
-                                                        -- no argument
-                                                        _current[key] = nil
-                                                    elseif table.getn(arg) == 1 then
-                                                        -- save only one argument
-                                                        _current[key] = arg[1]
-                                                    else
-                                                        -- save all arguments
-                                                        for i, v in ipairs(arg) do
-                                                            _current[key][i] = v
-                                                        end
-                                                    end
-                                                end
-                                            end
-
-                                            -- get it from the global table
-                                            return rawget(_G, key)
-                                        end})  
-    setfenv(1, newenv)
-
-    -- register all configures
-    preprocessor._register(newenv, configures, filter)
-
-    -- configure import
-    if import then
-        newenv["import"] = import
-    end
-
-    -- configure scope end
-    newenv["_end"] = function ()
-
-        -- check
-        assert(_current)
-
-        -- leave the current scope
-        _current = _current._PARENT
-    end
-
-    -- configure scopes
-    if scopes then
-        for _, scope_name in ipairs(scopes) do
-                
-            newenv[scope_name] = function (...)
-
-                -- check
-                assert(_current)
-
-                -- init config name
-                local config_name = "_" .. scope_name:upper()
-
-                -- init scope config
-                _current[config_name] = _current[config_name] or {}
-                local scope_config = _current[config_name]
-
-                -- init scope
-                local scope = {}
-
-                -- configure all 
-                local arg = arg or {...}
-                for _, name in ipairs(arg) do
-
-                    -- check
-                    if scope_config[name] then
-                        -- error
-                        utils.error("the %s: %s has been defined repeatly!", config_name, name)
-                        assert(false) 
-                    end
-
-                    -- init the scope
-                    scope_config[name] = scope
-
-                end
-
-                -- enter scope
-                local parent = _current
-                _current = scope
-                _current._PARENT = parent
-            end
-        end
-    end
-
-    -- the root configure 
-    newenv[root] = function ()
-
-        -- init the root scope, must be only one configs
-        if not newenv._CONFIGS then
-            newenv._CONFIGS = {}
-        else
-            -- error
-            utils.error("exists double %s!", root)
-            return
-        end
-
-        -- init the current scope
-        _current = newenv._CONFIGS
-        _current._PARENT = nil
-    end
-
-    -- enter old environment 
-    setfenv(1, oldenv)
-    return newenv
-end
- 
---!load the configure file
---
--- supports:
---     xmake.xproj
---     xmake.xconf
---
--- @code
--- local configs, errors = preprocessor.loadfile("xmake.xconf", "config", {"plat", "host", "arch", ...}, {"target"})
--- local configs, errors = preprocessor.loadfile("xmake.xproj", "project", {"links", "files", "ldflags", ...}, {"target", "platforms"}, filter, import)
--- @endcode
-function preprocessor.loadfile(path, root, configures, scopes, filter, import)
-
-    -- check
-    assert(path and root and configures)
-
-    -- load and execute the configure file
-    local script = preprocessor.loadx(path)
-    if script then
-
-        -- init a new envirnoment
-        local newenv = preprocessor._init(root, configures, scopes, filter, import)
-        assert(newenv)
-
-        -- bind this envirnoment
-        setfenv(script, newenv)
-
-        -- execute it
-        local ok, err = pcall(script)
-        if not ok then
-            -- error
-            return nil, err
-        end
-
-        -- ok?
-        return newenv
-    else
-        -- error
-        return nil, string.format("load %s failed!", path)
-    end
-end
-
--- return module: preprocessor
-return preprocessor