[GN]: Support for loadable modules

tools/gn/functions_target.cc

 // Copyright (c) 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "tools/gn/functions.h"
 
 #include "tools/gn/config_values_generator.h"
 #include "tools/gn/err.h"
 #include "tools/gn/parse_tree.h"
 #include "tools/gn/scope.h"
 #include "tools/gn/target_generator.h"
 #include "tools/gn/template.h"
 #include "tools/gn/value.h"
 #include "tools/gn/variables.h"
 
 #define DEPENDENT_CONFIG_VARS \
     "  Dependent configs: all_dependent_configs, public_configs\n"
 #define DEPS_VARS \
     "  Deps: data_deps, deps, public_deps\n"
 #define GENERAL_TARGET_VARS \
     "  General: check_includes, configs, data, inputs, output_name,\n" \
-    "           output_extension, public, sources, testonly, visibility\n"
+    "           output_extension, public, sources, testonly, visibility,\n" \
+    "           darwin_bundle\n"
 
 namespace functions {
 
 namespace {
 
 Value ExecuteGenericTarget(const char* target_type,
                            Scope* scope,
                            const FunctionCallNode* function,
                            const std::vector<Value>& args,
                            BlockNode* block,
@@ skipping 315 matching lines @@
 
 Value RunGroup(Scope* scope,
                const FunctionCallNode* function,
                const std::vector<Value>& args,
                BlockNode* block,
                Err* err) {
   return ExecuteGenericTarget(functions::kGroup, scope, function, args,
                               block, err);
 }
 
+// loadable_module -------------------------------------------------------------
+
+const char kLoadableModule[] = "loadable_module";
+const char kLoadableModule_HelpShort[] =
+    "loadable_module: Declare a loadable module target.";
+const char kLoadableModule_Help[] =
+    "loadable_module: Declare a loadable module target.\n"
+    "\n"

[brettw, 2015/10/13 23:13:32]

Can you add a paragraph at the top here about how a loadable module is a dynamic
library loaded explicitly at runtime rather than automatically linked. What you
have below feels like it goes after a general intro.

[Bons, 2015/10/13 23:30:52]

Done.

+    "  A loadable module will be specified on the linker line for targets\n"
+    "  listing the loadable module in its \"deps\". If you don't want this\n"
+    "  (if you don't need to dynamically load the library at runtime), then\n"
+    "  you should use a \"shared_library\" target type instead.\n"
+    "\n"
+    "Variables\n"
+    "\n"
+    CONFIG_VALUES_VARS_HELP
+    DEPS_VARS
+    DEPENDENT_CONFIG_VARS
+    GENERAL_TARGET_VARS;
+
+Value RunLoadableModule(Scope* scope,
+                       const FunctionCallNode* function,
+                       const std::vector<Value>& args,
+                       BlockNode* block,
+                       Err* err) {
+  return ExecuteGenericTarget(functions::kLoadableModule, scope, function, args,
+                              block, err);
+}
+
 // shared_library --------------------------------------------------------------
 
 const char kSharedLibrary[] = "shared_library";
 const char kSharedLibrary_HelpShort[] =
     "shared_library: Declare a shared library target.";
 const char kSharedLibrary_Help[] =
     "shared_library: Declare a shared library target.\n"
     "\n"
     "  A shared library will be specified on the linker line for targets\n"
     "  listing the shared library in its \"deps\". If you don't want this\n"
     "  (say you dynamically load the library at runtime), then you should\n"
-    "  depend on the shared library via \"data_deps\" instead.\n"
+    "  depend on the shared library via \"data_deps\" or, on Darwin\n"

[brettw, 2015/10/13 23:13:33]

I'd remove "on Darwin platforms" since this should work everywhere.

+    "  platforms, use a \"loadable_module\" target type instead.\n"
     "\n"
     "Variables\n"
     "\n"
     CONFIG_VALUES_VARS_HELP
     DEPS_VARS
     DEPENDENT_CONFIG_VARS
     GENERAL_TARGET_VARS;
 
 Value RunSharedLibrary(Scope* scope,
                        const FunctionCallNode* function,
@@ skipping 114 matching lines @@
     "\n"
     "  target(my_type, \"foo\") {\n"
     "    ...\n"
     "  }\n";
 Value RunTarget(Scope* scope,
                 const FunctionCallNode* function,
                 const std::vector<Value>& args,
                 BlockNode* block,
                 Err* err) {
   if (args.size() != 2) {
-    *err = Err(function, "Expected two arguments.",
-               "Dude, try \"gn help target\".");
+    *err = Err(function, "Expected two arguments. Try \"gn help target\".");

[brettw, 2015/10/13 23:13:33]

I think the old one with two string args is better. It should give:

ERROR: Expected two arguments.
target("asdasd") {
^-----
The other info here.

I think this structure makes sense. The initial error on the error line is a
very mechanical description of the error only.

[Bons, 2015/10/13 23:30:52]

Ah that was a mistake. I was just trying to remove the "dude" portion.

     return Value();
   }
 
   // The first argument must be a string (the target type). Don't type-check
   // the second argument since the target-specific function will do that.
   if (!args[0].VerifyTypeIs(Value::STRING, err))
     return Value();
   const std::string& target_type = args[0].string_value();
 
   // The rest of the args are passed to the function.
   std::vector<Value> sub_args(args.begin() + 1, args.end());
 
   // Run a template if it is one.
   const Template* templ = scope->GetTemplate(target_type);
   if (templ)
     return templ->Invoke(scope, function, sub_args, block, err);
 
   // Otherwise, assume the target is a built-in target type.
   return ExecuteGenericTarget(target_type.c_str(), scope, function, sub_args,
                               block, err);
 }
 
 }  // namespace functions