1 files changed, 105 insertions, 4 deletions

diff --git a/libbuild2/c/init.cxx b/libbuild2/c/init.cxx
index be001a8..42ade68 100644
--- a/libbuild2/c/init.cxx
+++ b/libbuild2/c/init.cxx
@@ -27,6 +27,7 @@ namespace build2
   namespace c
   {
     using cc::compiler_id;
+    using cc::compiler_type;
     using cc::compiler_class;
     using cc::compiler_info;
 
@@ -77,7 +78,12 @@ namespace build2
           // C17/18 is a bug-fix version of C11 so here we assume it is the
           // same as C11.
           //
-          // And it's still early days for C2X.
+          // And it's still early days for C2X. Specifically, there is not
+          // much about C2X in MSVC in the official places and the following
+          // page shows that it's pretty much unimplement at the time of the
+          // MSVC 17.6 release:
+          //
+          // https://en.cppreference.com/w/c/compiler_support/23
           //
           // From version 16.8 VC now supports /std:c11 and /std:c17 options
           // which enable C11/17 conformance. However, as of version 16.10,
@@ -154,15 +160,20 @@ namespace build2
 
       // Enter all the variables and initialize the module data.
       //
-      auto& vp (rs.var_pool ());
+      // All the variables we enter are qualified so go straight for the
+      // public variable pool.
+      //
+      auto& vp (rs.var_pool (true /* public */));
 
       cc::config_data d {
         cc::lang::c,
 
         "c",
         "c",
+        "obj-c",
         BUILD2_DEFAULT_C,
         ".i",
+        ".mi",
 
         hinters,
 
@@ -225,6 +236,9 @@ namespace build2
         vp["cc.export.libs"],
         vp["cc.export.impl_libs"],
 
+        vp["cc.pkconfig.include"],
+        vp["cc.pkconfig.lib"],
+
         vp.insert_alias (vp["cc.stdlib"], "c.stdlib"), // Same as cc.stdlib.
 
         vp["cc.runtime"],
@@ -276,6 +290,9 @@ namespace build2
       vp.insert_alias (d.c_runtime,    "c.runtime");
       vp.insert_alias (d.c_importable, "c.importable");
 
+      vp.insert_alias (d.c_pkgconfig_include, "c.pkgconfig.include");
+      vp.insert_alias (d.c_pkgconfig_lib,     "c.pkgconfig.lib");
+
       auto& m (extra.set_module (new config_module (move (d))));
       m.guess (rs, loc, extra.hints);
 
@@ -312,10 +329,15 @@ namespace build2
       nullptr
     };
 
+    // Note that we include S{} here because .S files can include each other.
+    // (And maybe from inline assember instrcutions?)
+    //
     static const target_type* const inc[] =
     {
       &h::static_type,
       &c::static_type,
+      &m::static_type,
+      &S::static_type,
       nullptr
     };
 
@@ -346,7 +368,6 @@ namespace build2
         "c.compile",
         "c.link",
         "c.install",
-        "c.uninstall",
 
         cm.x_info->id.type,
         cm.x_info->id.variant,
@@ -386,12 +407,90 @@ namespace build2
         inc
       };
 
-      auto& m (extra.set_module (new module (move (d))));
+      auto& m (extra.set_module (new module (move (d), rs)));
       m.init (rs, loc, extra.hints, *cm.x_info);
 
       return true;
     }
 
+    bool
+    objc_init (scope& rs,
+               scope& bs,
+               const location& loc,
+               bool,
+               bool,
+               module_init_extra&)
+    {
+      tracer trace ("c::objc_init");
+      l5 ([&]{trace << "for " << bs;});
+
+      // We only support root loading (which means there can only be one).
+      //
+      if (rs != bs)
+        fail (loc) << "c.objc module must be loaded in project root";
+
+      module* mod (rs.find_module<module> ("c"));
+
+      if (mod == nullptr)
+        fail (loc) << "c.objc module must be loaded after c module";
+
+      // Register the target type and "enable" it in the module.
+      //
+      // Note that we must register the target type regardless of whether the
+      // C compiler is capable of compiling Objective-C. But we enable only
+      // if it is.
+      //
+      // Note: see similar code in the cxx module.
+      //
+      rs.insert_target_type<m> ();
+
+      // Note that while Objective-C is supported by MinGW GCC, it's unlikely
+      // Clang supports it when targeting MSVC or Emscripten. But let's keep
+      // the check simple for now.
+      //
+      if (mod->ctype == compiler_type::gcc ||
+          mod->ctype == compiler_type::clang)
+        mod->x_obj = &m::static_type;
+
+      return true;
+    }
+
+    bool
+    as_cpp_init (scope& rs,
+                scope& bs,
+                const location& loc,
+                bool,
+                bool,
+                module_init_extra&)
+    {
+      tracer trace ("c::as_cpp_init");
+      l5 ([&]{trace << "for " << bs;});
+
+      // We only support root loading (which means there can only be one).
+      //
+      if (rs != bs)
+        fail (loc) << "c.as-cpp module must be loaded in project root";
+
+      module* mod (rs.find_module<module> ("c"));
+
+      if (mod == nullptr)
+        fail (loc) << "c.as-cpp module must be loaded after c module";
+
+      // Register the target type and "enable" it in the module.
+      //
+      // Note that we must register the target type regardless of whether the
+      // C compiler is capable of compiling Assember with C preprocessor. But
+      // we enable only if it is.
+      //
+      rs.insert_target_type<S> ();
+
+      if (mod->ctype == compiler_type::gcc ||
+          mod->ctype == compiler_type::clang)
+        mod->x_asp = &S::static_type;
+
+      return true;
+    }
+
     static const module_functions mod_functions[] =
     {
       // NOTE: don't forget to also update the documentation in init.hxx if
@@ -399,6 +498,8 @@ namespace build2
 
       {"c.guess",  nullptr, guess_init},
       {"c.config", nullptr, config_init},
+      {"c.objc",   nullptr, objc_init},
+      {"c.as-cpp", nullptr, as_cpp_init},
       {"c",        nullptr, init},
       {nullptr,    nullptr, nullptr}
     };