Update: Now it is possible to build D and C together

Author: MrcSnm

source/redub/building/compile.d

@@ -130,7 +130,7 @@ CompilationResult execCompilation(immutable ThreadBuildData data, shared Project
             if(!isDCompiler(c) && !ret.status && isStaticLibrary(data.cfg.targetType)) //Must call archiver when
             {
                 string cmd ;
-                auto archiverRes = executeArchiver(data, info, cmd);
+                auto archiverRes = executeArchiver(data, info, hash.rootHash, cmd);
                 ret.status = archiverRes.status;
                 ret.output~= archiverRes.output;
                 res.compilationCommand~= "\n\nArchiving: \n\t"~cmd;

source/redub/building/utils.d

@@ -68,13 +68,14 @@ auto linkBase(const ThreadBuildData data, CompilingSession session, string rootH
  *   s = Compiling Session
  *   command = Command for being able to print it later
  */
-auto executeArchiver(const ThreadBuildData data, CompilingSession s, out string command)
+auto executeArchiver(const ThreadBuildData data, CompilingSession s, string mainPackHash, out string command)
 {
     import std.process;
     import std.array;
     import redub.command_generators.commons;
     import redub.compiler_identification;
     import std.path;
+    import redub.building.cache;
     Archiver a = s.compiler.archiver;
 
     string[] cmd = [a.bin];
@@ -87,18 +88,10 @@ auto executeArchiver(const ThreadBuildData data, CompilingSession s, out string
 
     cmd~= buildNormalizedPath(data.cfg.outputDirectory, getOutputName(data.cfg, s.os, s.isa));
 
-    putObjectFiles(cmd, data.cfg, s.os, data.cfg.getCompiler(s.compiler).compiler == AcceptedCompiler.gcc ? cExt : cppExt);
+    string cacheDir = getCacheOutputDir(mainPackHash, data.cfg, s, data.extra.isRoot);
+
+    putSourceFiles(cmd, null, [cacheDir], data.cfg.sourceFiles, data.cfg.excludeSourceFiles, ".o", ".obj");
     command = cmd.join(" ");
 
     return executeShell(command);
-}
-
-private void putObjectFiles(ref string[] target, const BuildConfiguration b, OS os, scope const string[] extensions...)
-{
-    import redub.command_generators.commons;
-    import std.file;
-    import std.path;
-    string[] objectFiles;
-    putSourceFiles(objectFiles, b.workingDir, b.sourcePaths, b.sourceFiles, b.excludeSourceFiles, extensions);
-    target = mapAppend(target, objectFiles, (string src) => setExtension(src, getObjectExtension(os)));
 }

source/redub/cli/dub.d

@@ -141,14 +141,14 @@ struct DubArguments
         "Arbitrary pre- and suffixes to the identifiers below are recognized (e.g. ldc2 or dmd-2.063) and matched to the proper compiler type:\n" ~
         "dmd, ldc (For the C Compilers, use -C or --cCompiler) gcc, g++ "
     )
-    @("compiler|D")
+    @("dc|compiler")
     string compiler;
 
     @(
         "Specifies which C compiler binary to use "~
         "The current supported C compilers are gcc and g++"
     )
-    @("cCompiler|C")
+    @("cc|c-compiler")
     string cCompiler;
 
 

source/redub/command_generators/commons.d

@@ -110,14 +110,21 @@ string getLibraryPath(string libName, string outputDir, OS os)
  */
 string getConfigurationOutputName(const BuildConfiguration conf, OS os)
 {
-    import redub.building.cache;
     with(conf)
     {
         if(targetType.isStaticLibrary)
             return getOutputName(targetType, targetName, os);
-        return targetName~getObjectExtension(os);
+        return getObjectOutputName(conf, os);
     }
 }
+/**
+ *
+ * Params:
+ *   conf = The configuration
+ *   os = OS in which is being built for
+ * Returns: A name with an extension that should be used for compiling
+ */
+string getObjectOutputName(const BuildConfiguration conf, OS os){ return conf.targetName~getObjectExtension(os);}
 
 string getDepsFilePath(ProjectNode root, CompilingSession s)
 {

source/redub/command_generators/gnu_based.d

@@ -7,8 +7,9 @@ import redub.logging;
 import redub.building.cache;
 
 /// Parse G++ configuration
-string[] parseBuildConfiguration(const BuildConfiguration b, CompilingSession s, string requirementCache, bool isRoot, const string[] extensions...)
+string[] parseBuildConfiguration(const BuildConfiguration b, CompilingSession s, string mainPackHash, bool isRoot, const string[] extensions...)
 {
+    import std.file;
     import std.algorithm.iteration:map;
     import redub.misc.path;
 
@@ -17,7 +18,7 @@ string[] parseBuildConfiguration(const BuildConfiguration b, CompilingSession s,
     with(b)
     {
         if(isDebug) commands~= "-g";
-        if(targetType.isLinkedSeparately) commands~= "-c";
+        commands~= "-c";
 
         commands = mapAppendPrefix(commands, versions, "-D", false);
         commands~= dFlags;
@@ -26,14 +27,15 @@ string[] parseBuildConfiguration(const BuildConfiguration b, CompilingSession s,
 
 
         string outFlag = getTargetTypeFlag(targetType);
-        if(outFlag) commands~= outFlag;
-
-        if(targetType.isLinkedSeparately)
-        {
-            commands~= "-o";
-            string cacheDir = getCacheOutputDir(requirementCache, b, s, isRoot);
+        string cacheDir = getCacheOutputDir(mainPackHash, b, s, isRoot);
+        mkdirRecurse(cacheDir);
+        if(outFlag)
+            commands~= outFlag;
+        commands~= "-o";
+        if(outFlag)
             commands ~= buildNormalizedPath(cacheDir, getConfigurationOutputName(b, s.os)).escapePath;
-        }
+        else
+            commands ~= buildNormalizedPath(cacheDir, getObjectOutputName(b, os)).escapePath;
     }
 
     return commands;
@@ -44,8 +46,7 @@ string getTargetTypeFlag(TargetType o)
     final switch(o) with(TargetType)
     {
         case invalid, none: throw new Exception("Invalid targetType");
-        case autodetect, executable, sourceLibrary: return null;
+        case autodetect, executable, sourceLibrary, staticLibrary, library: return null;
         case dynamicLibrary: return "-shared";
-        case staticLibrary, library: return "-c";
     }
 }

source/redub/meta.d

@@ -19,11 +19,16 @@ private string getRedubMetaFileName()
 
 void saveRedubMeta(JSONValue content)
 {
+    import redub.buildapi;
     import std.file;
     import std.path;
     string dir = dirName(getRedubMetaFileName);
     if(!std.file.exists(dir))
         mkdirRecurse(dir);
+
+    if(!("version" in content))
+        content["version"] = JSONValue(RedubVersionOnly);
+
     std.file.write(getRedubMetaFileName, content.toString);
 }