add qt_console rule

9 files changed, 263 insertions, 123 deletions

diff --git a/tests/projects/qt_console/src/main.cpp b/tests/projects/qt_console/src/main.cpp
new file mode 100644
index 000000000..de25444ff
--- /dev/null
+++ b/tests/projects/qt_console/src/main.cpp
@@ -0,0 +1,9 @@
+#include <QCoreApplication>
+
+int main(int argc, char *argv[])
+{
+    QCoreApplication a(argc, argv);
+
+    printf("hello xmake\n");
+    return a.exec();
+}
diff --git a/tests/projects/qt_console/xmake.lua b/tests/projects/qt_console/xmake.lua
new file mode 100644
index 000000000..d7151f790
--- /dev/null
+++ b/tests/projects/qt_console/xmake.lua
@@ -0,0 +1,32 @@
+-- the debug mode
+if is_mode("debug") then
+    
+    -- enable the debug symbols
+    set_symbols("debug")
+
+    -- disable optimization
+    set_optimize("none")
+end
+
+-- the release mode
+if is_mode("release") then
+
+    -- set the symbols visibility: hidden
+    set_symbols("hidden")
+
+    -- enable fastest optimization
+    set_optimize("fastest")
+
+    -- strip all symbols
+    set_strip("all")
+end
+
+-- add target
+target("qt_console")
+
+    -- add rules
+    add_rules("qt_console")
+
+    -- add files
+    add_files("src/*.cpp") 
+
diff --git a/xmake/core/base/task.lua b/xmake/core/base/task.lua
index 7288f966f..b8b7d6dc2 100644
--- a/xmake/core/base/task.lua
+++ b/xmake/core/base/task.lua
@@ -372,10 +372,10 @@ function task.tasks()
         if files then
             for _, filepath in ipairs(files) do
 
-                -- load tasks
+                -- load task
                 local results, errors = task._load(filepath)
 
-                -- save tasks
+                -- save task
                 if results then
                     table.join2(tasks, results)
                 else
@@ -389,11 +389,8 @@ function task.tasks()
     local projectasks, errors = project.tasks()
     if projectasks then
 
-        -- the project interpreter
-        local interp = errors
-
         -- bind tasks for menu with an sandbox instance
-        local ok, errors = task._bind(projectasks, interp)
+        local ok, errors = task._bind(projectasks, project.interpreter())
         if not ok then
             return nil, errors
         end
diff --git a/xmake/core/main.lua b/xmake/core/main.lua
index 3455c5f64..c7a5c86b3 100644
--- a/xmake/core/main.lua
+++ b/xmake/core/main.lua
@@ -36,6 +36,7 @@ local deprecated    = require("base/deprecated")
 local privilege     = require("base/privilege")
 local task          = require("base/task")
 local colors        = require("base/colors")
+local rule          = require("project/rule")
 local project       = require("project/project")
 local history       = require("project/history")
 local package       = require("package/package")
@@ -212,8 +213,9 @@ force to build in current directory via run `xmake -P .`]], os.projectdir())
         os.addenv("PATH", os.programdir())
     end
 
-    -- define task and package apis first before loading project's xmake.lua - calling option.init()
+    -- define task, rule and package apis first before loading project's xmake.lua 
     project.define_apis(task.apis())
+    project.define_apis(rule.apis())
     project.define_apis(package.apis())
 end
 
diff --git a/xmake/core/package/package.lua b/xmake/core/package/package.lua
index 6b490e097..efb78c7fb 100644
--- a/xmake/core/package/package.lua
+++ b/xmake/core/package/package.lua
@@ -522,7 +522,7 @@ function package.load_from_project(packagename)
     end
 
     -- get interpreter
-    local interp = errors or package._interpreter()
+    local interp = project.interpreter() or package._interpreter()
 
     -- not found?
     if not packages[packagename] then
diff --git a/xmake/core/project/project.lua b/xmake/core/project/project.lua
index 91aac6760..424471854 100644
--- a/xmake/core/project/project.lua
+++ b/xmake/core/project/project.lua
@@ -35,7 +35,6 @@ local global                = require("base/global")
 local process               = require("base/process")
 local deprecated            = require("base/deprecated")
 local interpreter           = require("base/interpreter")
-local rule                  = require("project/rule")
 local target                = require("project/target")
 local config                = require("project/config")
 local option                = require("project/option")
@@ -198,9 +197,6 @@ function project.interpreter()
     -- set root scope
     interp:rootscope_set("target")
 
-    -- define apis for rule
-    interp:api_define(rule.apis())
-
     -- define apis for target
     interp:api_define(target.apis())
 
@@ -326,12 +322,8 @@ function project.get(name)
     local infos = project._INFOS 
     if not infos then
 
-        -- get interpreter
-        local interp = project.interpreter()
-        assert(interp) 
-
         -- load infos
-        infos = interp:load(project.file(), nil, true, true)
+        infos = project._load_scope(nil, true, true)
         project._INFOS = infos
     end
 
@@ -357,8 +349,8 @@ function project._load_deps(target, targets, deps, orderdeps)
     end
 end
 
--- load rules 
-function project._load_rules()
+-- load scope from the project file
+function project._load_scope(scope_kind, remove_repeat, enable_filter)
 
     -- get interpreter
     local interp = project.interpreter()
@@ -370,8 +362,8 @@ function project._load_rules()
         return nil, errors
     end
 
-    -- load rules
-    local results, errors = interp:load(project.file(), "rule", true, true)
+    -- load targets
+    local results, errors = interp:load(project.file(), scope_kind, remove_repeat, enable_filter)
     if not results then
         return nil, errors
     end
@@ -382,66 +374,37 @@ function project._load_rules()
         return nil, errors
     end
 
-    -- make rules
-    local rules = {}
-    for rulename, ruleinfo in pairs(results) do
-        rules[rulename] = rule.new(rulename, ruleinfo)
-    end
-
     -- ok
-    return rules
+    return results
 end
 
 -- load targets 
 function project._load_targets()
 
-    -- get interpreter
-    local interp = project.interpreter()
-    assert(interp) 
-
-    -- enter the project directory
-    local oldir, errors = os.cd(os.projectdir())
-    if not oldir then
-        return nil, errors
-    end
-
     -- load targets
-    local results, errors = interp:load(project.file(), "target", true, true)
+    local results, errors = project._load_scope("target", true, true)
     if not results then
         return nil, errors
     end
 
-    -- leave the project directory
-    local ok, errors = os.cd(oldir)
-    if not ok then
-        return nil, errors
-    end
-
     -- make targets
     local targets = {}
     for targetname, targetinfo in pairs(results) do
         targets[targetname] = target.new(targetname, targetinfo)
     end
 
-    -- load and attach target deps and rules
+    -- load and attach target deps
     for _, target in pairs(targets) do
-
-        -- load deps
         target._DEPS      = target._DEPS or {}
         target._ORDERDEPS = target._ORDERDEPS or {}
         project._load_deps(target, targets, target._DEPS, target._ORDERDEPS)
-
-        -- load rules
-        target._RULES     = target._RULES or {}
-        for _, rulename in ipairs(table.wrap(target:get("rules"))) do
-            target._RULES[rulename] = project.rule(rulename)
-        end
     end
 
     -- enter toolchains environment
     environment.enter("toolchains")
 
     -- on load for each target
+    local ok = true
     for _, target in pairs(targets) do
         local on_load = target:script("load")
         if on_load then
@@ -467,28 +430,12 @@ end
 -- load options
 function project._load_options(disable_filter)
 
-    -- get interpreter
-    local interp = project.interpreter()
-    assert(interp) 
-
-    -- enter the project directory
-    local oldir, errors = os.cd(os.projectdir())
-    if not oldir then
-        return nil, errors
-    end
-
     -- load the options from the the project file
-    local results, errors = interp:load(project.file(), "option", true, not disable_filter)
+    local results, errors = project._load_scope("option", true, not disable_filter)
     if not results then
         return nil, errors
     end
 
-    -- leave the project directory
-    local ok, errors = os.cd(oldir)
-    if not ok then
-        return nil, errors
-    end
-    
     -- load the options from the project requires
     local requires_extra = project.get("__extra_requires") or {}
     for _, require_str in ipairs(table.wrap(project.get("requires"))) do
@@ -588,12 +535,8 @@ function project.get(name)
     local infos = project._INFOS 
     if not infos then
 
-        -- get interpreter
-        local interp = project.interpreter()
-        assert(interp) 
-
         -- load infos
-        infos = interp:load(project.file(), nil, true, true)
+        infos = project._load_scope(nil, true, true)
         project._INFOS = infos
     end
 
@@ -611,33 +554,11 @@ function project.clear()
         opt:clear()
     end
 
-    -- clear rules, targets and options
-    project._RULES   = nil
+    -- clear targets and options
     project._TARGETS = nil
     project._OPTIONS = nil
 end
 
--- get the given rule
-function project.rule(name)
-    return project.rules()[name]
-end
-
--- get the current configure for rules
-function project.rules()
-
-    -- load rules
-    if not project._RULES then
-        local rules, errors = project._load_rules()
-        if not rules then
-            os.raise(errors)
-        end
-        project._RULES = rules
-    end
-
-    -- ok
-    return project._RULES
-end
-
 -- get the given target
 function project.target(name)
     return project.targets()[name]
@@ -680,26 +601,40 @@ function project.options()
     return project._OPTIONS
 end
 
+-- get rules
+function project.rules()
+
+    -- the project file is not found?
+    if not os.isfile(project.file()) then
+        return {}, nil
+    end
+
+    -- load the rules from the the project file
+    local results, errors = project._load_scope("rule", true, true)
+    if not results then
+        return nil, errors
+    end
+
+    -- ok
+    return results
+end
+
 -- get tasks
 function project.tasks()
 
-    -- get interpreter
-    local interp = project.interpreter()
-    assert(interp) 
-
     -- the project file is not found?
     if not os.isfile(project.file()) then
         return {}, nil
     end
 
     -- load the tasks from the the project file
-    local results, errors = interp:load(project.file(), "task", true, true)
+    local results, errors = project._load_scope("task", true, true)
     if not results then
         return nil, errors
     end
 
     -- ok?
-    return results, interp
+    return results
 end
 
 -- get packages
@@ -707,20 +642,16 @@ function project.packages()
 
     -- get it from cache first
     if project._PACKAGES then
-        return project._PACKAGES, interp
+        return project._PACKAGES
     end
 
-    -- get interpreter
-    local interp = project.interpreter()
-    assert(interp) 
-
     -- the project file is not found?
     if not os.isfile(os.projectfile()) then
         return {}, nil
     end
 
-    -- load the tasks from the the project file and disable filter, we will process filter after a while
-    local results, errors = interp:load(os.projectfile(), "package", true, false)
+    -- load the packages from the the project file and disable filter, we will process filter after a while
+    local results, errors = project._load_scope("package", true, false)
     if not results then
         return nil, errors
     end
@@ -729,7 +660,7 @@ function project.packages()
     project._PACKAGES = results
 
     -- ok?
-    return results, interp
+    return results
 end
 
 -- get the mtimes
diff --git a/xmake/core/project/rule.lua b/xmake/core/project/rule.lua
index d7e1048df..f915ca459 100644
--- a/xmake/core/project/rule.lua
+++ b/xmake/core/project/rule.lua
@@ -30,9 +30,103 @@ local os             = require("base/os")
 local path           = require("base/path")
 local utils          = require("base/utils")
 local table          = require("base/table")
+local project        = require("project/project")
+local global         = require("base/global")
+local interpreter    = require("base/interpreter")
+local config         = require("project/config")
 local sandbox        = require("sandbox/sandbox")
+local sandbox_os     = require("sandbox/modules/os")
 local sandbox_module = require("sandbox/modules/import/core/sandbox/module")
 
+-- the directories of rule
+function rule._directories()
+
+    -- the directories
+    return  {   path.join(config.directory(), "rules")
+            ,   path.join(global.directory(), "rules")
+            ,   path.join(os.programdir(), "rules")
+            }
+end
+
+-- the interpreter
+function rule._interpreter()
+
+    -- the interpreter has been initialized? return it directly
+    if rule._INTERPRETER then
+        return rule._INTERPRETER
+    end
+
+    -- init interpreter
+    local interp = interpreter.new()
+    assert(interp)
+  
+    -- define apis
+    interp:api_define(rule.apis())
+
+    -- set filter
+    interp:filter():register("rule", function (variable)
+
+        -- check
+        assert(variable)
+
+        -- attempt to get it directly from the configure
+        local result = config.get(variable)
+        if not result or type(result) ~= "string" then 
+
+            -- init maps
+            local maps = 
+            {
+                host        = os.host()
+            ,   tmpdir      = function () return os.tmpdir() end
+            ,   curdir      = function () return os.curdir() end
+            ,   scriptdir   = function () return sandbox_os.scriptdir() end
+            ,   globaldir   = global.directory()
+            ,   configdir   = config.directory()
+            ,   projectdir  = os.projectdir()
+            ,   programdir  = os.programdir()
+            }
+
+            -- map it
+            result = maps[variable]
+            if type(result) == "function" then
+                result = result()
+            end
+        end 
+
+        -- ok?
+        return result
+    end)
+
+    -- save interpreter
+    rule._INTERPRETER = interp
+
+    -- ok?
+    return interp
+end
+
+-- load rule
+function rule._load(filepath)
+
+    -- get interpreter
+    local interp = rule._interpreter()
+    assert(interp) 
+
+    -- load rules
+    local results, errors = interp:load(filepath, "rule", true, true)
+    if not results then
+        return nil, errors
+    end
+
+    -- make rules
+    local rules = {}
+    for rulename, ruleinfo in pairs(results) do
+        rules[rulename] = rule.new(rulename, ruleinfo)
+    end
+
+    -- ok
+    return rules
+end
+
 -- get rule apis
 function rule.apis()
 
@@ -254,5 +348,59 @@ function rule:script(name, generic)
     return result
 end
 
+-- get all rules
+function rule.rules()
+ 
+    -- return it directly if exists
+    if rule._RULES then
+        return rule._RULES 
+    end
+
+    -- load rules
+    local rules = {}
+    local dirs = rule._directories()
+    for _, dir in ipairs(dirs) do
+
+        -- get files
+        local files = os.match(path.join(dir, "**/xmake.lua"))
+        if files then
+            for _, filepath in ipairs(files) do
+
+                -- load rule
+                local results, errors = rule._load(filepath)
+
+                -- save rule
+                if results then
+                    table.join2(rules, results)
+                else
+                    return nil, errors
+                end
+            end
+        end
+    end
+
+    -- merge project rules if exists
+    local project_rules, errors = project.rules()
+    if project_rules then
+
+        -- save rules
+        for rulename, ruleinfo in pairs(project_rules) do
+            if rules[rulename] == nil then
+                rules[rulename] = ruleinfo
+            else
+                utils.warning("rule(\"%s\") has been defined!", rulename)
+            end
+        end
+    else
+        return nil, errors
+    end
+
+    -- save it
+    rule._RULES = rules
+
+    -- ok?
+    return rules
+end
+
 -- return module
 return rule
diff --git a/xmake/core/sandbox/modules/import/core/project/project.lua b/xmake/core/sandbox/modules/import/core/project/project.lua
index 5187f8e99..9a48b8cf4 100644
--- a/xmake/core/sandbox/modules/import/core/project/project.lua
+++ b/xmake/core/sandbox/modules/import/core/project/project.lua
@@ -112,16 +112,6 @@ function sandbox_core_project.check()
     end
 end
 
--- get the given rule
-function sandbox_core_project.rule(name)
-    return project.rule(name)
-end
-
--- get the all rules
-function sandbox_core_project.rules()
-    return project.rules()
-end
-
 -- get the given target
 function sandbox_core_project.target(name)
     return project.target(name)
diff --git a/xmake/rules/qt_console/xmake.lua b/xmake/rules/qt_console/xmake.lua
new file mode 100644
index 000000000..521eb784d
--- /dev/null
+++ b/xmake/rules/qt_console/xmake.lua
@@ -0,0 +1,31 @@
+--!A cross-platform build utility based on Lua
+--
+-- Licensed to the Apache Software Foundation (ASF) under one
+-- or more contributor license agreements.  See the NOTICE file
+-- distributed with this work for additional information
+-- regarding copyright ownership.  The ASF licenses this file
+-- to you 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 - 2018, TBOOX Open Source Group.
+--
+-- @author      ruki
+-- @file        xmake.lua
+--
+
+-- define rule
+rule("qt_console")
+    set_kind("binary")
+    on_build(function (target, sourcefile)
+        print("TODO")
+    end)
+