Fixed: Archiver now putting object files correctly

Author: MrcSnm

source/redub/building/compile.d

@@ -126,13 +126,13 @@ CompilationResult execCompilation(immutable ThreadBuildData data, shared Project
             if(!pack.isCopyEnough)
                 ret = cast(ExecutionResult)execCompiler(cfg, compiler.binOrPath, getCompilationFlags(cfg, info, hash.rootHash, data.extra.isRoot), res.compilationCommand, compiler, inDir);
 
-            if(!isDCompiler(compiler) && !ret.status) //Always requires link.
+            if(!isDCompiler(compiler) && !ret.status && isStaticLibrary(data.cfg.targetType)) //Must call archiver when
             {
                 string cmd ;
                 auto archiverRes = executeArchiver(data, info, cmd);
                 ret.status = archiverRes.status;
                 ret.output~= archiverRes.output;
-                res.compilationCommand~= cmd;
+                res.compilationCommand~= "\n\nArchiving: \n\t"~cmd;
             }
 
             copyDir(inDir, dirName(outDir));

source/redub/building/utils.d

@@ -60,6 +60,13 @@ auto linkBase(const ThreadBuildData data, CompilingSession session, string rootH
     );
 }
 
+/**
+ * Generates a static library using archiver. FIXME: BuildRequirements should know its files.
+ * Params:
+ *   data = The data containing project information
+ *   s = Compiling Session
+ *   command = Command for being able to print it later
+ */
 auto executeArchiver(const ThreadBuildData data, CompilingSession s, out string command)
 {
     import std.process;
@@ -72,17 +79,25 @@ auto executeArchiver(const ThreadBuildData data, CompilingSession s, out string
     string[] cmd = [a.bin];
     final switch(a.type) with(AcceptedArchiver)
     {
-        case ar, llvmAr: cmd~= "rcs"; break;
+        case ar, llvmAr: cmd~= ["rcs"]; break;
         case libtool: cmd~= ["-static", "-o"]; break;
         case none: break;
     }
 
-    cmd~= getOutputName(data.cfg, s.os, s.isa);
-
-    string objExt = getObjectExtension(s.os);
-    cmd = mapAppend(cmd, data.cfg.sourceFiles, (string src) => stripExtension(src)~ objExt);
+    cmd~= buildNormalizedPath(data.cfg.outputDirectory, getOutputName(data.cfg, s.os, s.isa));
 
+    putObjectFiles(cmd, data.cfg, s.os, s.compiler.compiler.gcc ? cExt : cppExt);
     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/command_generators/automatic.d

@@ -23,12 +23,13 @@ string escapeCompilationCommands(string compilerBin, string[] flags)
  */
 string[] getCompilationFlags(const BuildConfiguration cfg, CompilingSession s, string mainPackHash, bool isRoot)
 {
+    import redub.command_generators.commons;
     switch(s.compiler.compiler) with(AcceptedCompiler)
     {
         case gxx:
-            return redub.command_generators.gnu_based.parseBuildConfiguration(cfg, s, mainPackHash, isRoot, ".c", ".cpp", ".cc", ".i", ".cxx", ".c++");
+            return redub.command_generators.gnu_based.parseBuildConfiguration(cfg, s, mainPackHash, isRoot, cppExt);
         case gcc:
-            return redub.command_generators.gnu_based.parseBuildConfiguration(cfg, s, mainPackHash, isRoot, ".c", ".i");
+            return redub.command_generators.gnu_based.parseBuildConfiguration(cfg, s, mainPackHash, isRoot, cExt);
         case dmd:
             return redub.command_generators.dmd.parseBuildConfiguration(cfg, s, mainPackHash, isRoot);
         case ldc2:

source/redub/command_generators/commons.d

@@ -7,6 +7,13 @@ public import redub.compiler_identification;
 import redub.buildapi;
 public import std.file:DirEntry;
 
+///Valid d extensions
+immutable string[] dExt   = [".d"];
+///Valid c extensions
+immutable string[] cExt   = [".c", ".i"];
+///Valid c++ extensions
+immutable string[] cppExt = [".c", ".cpp", ".cc", ".i", ".cxx", ".c++"];
+
 
 OS osFromArch(string arch)
 {

source/redub/command_generators/gnu_based.d

@@ -4,6 +4,7 @@ public import redub.buildapi;
 public import std.system;
 import redub.command_generators.commons;
 import redub.logging;
+import redub.building.cache;
 
 /// Parse G++ configuration
 string[] parseBuildConfiguration(const BuildConfiguration b, CompilingSession s, string requirementCache, bool isRoot, const string[] extensions...)
@@ -16,6 +17,7 @@ string[] parseBuildConfiguration(const BuildConfiguration b, CompilingSession s,
     with(b)
     {
         if(isDebug) commands~= "-g";
+        if(targetType.isLinkedSeparately) commands~= "-c";
 
         commands = mapAppendPrefix(commands, versions, "-D", false);
         commands~= dFlags;
@@ -29,10 +31,9 @@ string[] parseBuildConfiguration(const BuildConfiguration b, CompilingSession s,
         if(targetType.isLinkedSeparately)
         {
             commands~= "-o";
-            commands ~= buildNormalizedPath(outputDirectory, getOutputName(targetType, name, os));
+            string cacheDir = getCacheOutputDir(requirementCache, b, s, isRoot);
+            commands ~= buildNormalizedPath(cacheDir, getConfigurationOutputName(b, s.os)).escapePath;
         }
-
-
     }
 
     return commands;

source/redub/command_generators/linkers.d

@@ -10,30 +10,38 @@ string[] parseLinkConfiguration(const ThreadBuildData data, CompilingSession s,
     import redub.misc.path;
     import redub.building.cache;
     string[] commands;
-    AcceptedLinker linker = s.compiler.linker.type;
+    AcceptedLinker linker = s.compiler.linker;
     bool emitStartGroup = s.isa != ISA.webAssembly && linker != AcceptedLinker.ld64;
 
 
     const BuildConfiguration b = data.cfg;
     with(b)
     {
-        if(s.compiler.isDCompiler)
         {
             import redub.command_generators.d_compilers;
 
             if (targetType.isLinkedSeparately)
             {
                 string cacheDir = getCacheOutputDir(requirementCache, b, s, data.extra.isRoot);
                 string objExtension = getObjectExtension(s.os);
-                commands~= "-of"~buildNormalizedPath(cacheDir, getOutputName(b, s.os)).escapePath;
+                if(s.compiler.isDCompiler)
+                    commands~= "-of"~buildNormalizedPath(cacheDir, getOutputName(b, s.os)).escapePath;
+                else
+                {
+                    commands~= "-o";
+                    commands~= buildNormalizedPath(cacheDir, getOutputName(b, s.os)).escapePath;
+                }
                 if(b.outputsDeps)
                     putSourceFiles(commands, null, [getObjectDir(cacheDir)], null, null, objExtension);
                 else
                     commands~= buildNormalizedPath(outputDirectory, targetName~objExtension).escapePath;
             }
-            string arch = mapArch(s.compiler.compiler, b.arch);
-            if(arch)
-                commands~= arch;
+            if(s.compiler.isDCompiler)
+            {
+                string arch = mapArch(s.compiler.compiler, b.arch);
+                if(arch)
+                    commands~= arch;
+            }
             commands~= filterLinkFlags(b.dFlags);
         }
         if(targetType == TargetType.dynamicLibrary)
@@ -57,13 +65,6 @@ string[] parseLinkConfiguration(const ThreadBuildData data, CompilingSession s,
             commands = mapAppend(commands, libraries, (string l) => "-L-l"~stripLibraryExtension(l));
 
         }
-        else if(!s.compiler.isDCompiler) //Generates a static library using archiver. FIXME: BuildRequirements should know its files.
-        {
-            commands~= "--format=default";
-            commands~= "rcs";
-            commands~= buildNormalizedPath(outputDirectory, getOutputName(b, s.os));
-            putObjectFiles(commands, b, s.os, ".c", ".cpp", ".cc", ".i", ".cxx", ".c++");
-        }
     }
 
     return commands;
@@ -133,11 +134,3 @@ string getTargetTypeFlag(TargetType o, Compiler compiler)
 }
 
 
-private void putObjectFiles(ref string[] target, const BuildConfiguration b, OS os, scope const string[] extensions...)
-{
-    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/compiler_identification.d

@@ -44,11 +44,6 @@ struct Archiver
     AcceptedArchiver type;
     string bin;
 }
-struct Linker
-{
-    AcceptedLinker type;
-    string bin;
-}
 
 AcceptedCompiler acceptedCompilerfromString(string str)
 {
@@ -91,14 +86,6 @@ AcceptedArchiver acceptedArchiverFromString(string str)
     }
 }
 
-private Linker acceptedLinker(JSONValue v)
-{
-    JSONValue* acc = "defaultLinker" in v;
-    if(!acc)
-        return Linker(AcceptedLinker.unknown);
-    return Linker(acceptedLinkerfromString(acc.object["type"].str), acc.object["bin"].str);
-}
-
 private Archiver acceptedArchiver(JSONValue v)
 {
     JSONValue* acc = "defaultArchiver" in v;
@@ -141,7 +128,7 @@ struct Compiler
 
     ///Currently unused. Was used before for checking whether --start-group should be emitted or not. Since it is emitted
     ///by default, only on webAssembly which is not, it lost its usage for now.
-    Linker linker = Linker(AcceptedLinker.unknown);
+    AcceptedLinker linker = AcceptedLinker.unknown;
 
 
     string getCompilerString() const
@@ -298,7 +285,7 @@ Compiler getCompiler(string compilerOrPath = "dmd", string compilerAssumption =
     if(ret == Compiler.init)
         ret = inferCompiler(compilerOrPath, compilerAssumption, compilersInfo, isDefault, isGlobal);
 
-    ret.linker = acceptedLinker(compilersInfo);
+    ret.linker = acceptedLinkerfromString(compilersInfo["defaultLinker"].str);
     ret.archiver = acceptedArchiver(compilersInfo);
 
     //Checks for ldc.conf switches to see if it is using gnu linker by default
@@ -436,7 +423,7 @@ private Compiler getCompilerFromCache(JSONValue allCompilersInfo, string compile
                     SemVer(arr[VERSION_].str),
                     SemVer(arr[FRONTEND_VERSION].str),
                     arr[VERSION_STRING].str,
-                    key, acceptedArchiver(allCompilersInfo), false, acceptedLinker(allCompilersInfo)
+                    key, acceptedArchiver(allCompilersInfo), false, acceptedLinkerfromString(allCompilersInfo["defaultLinker"].str)
                 );
             }
         }
@@ -487,14 +474,8 @@ private void saveCompilerInfo(JSONValue allCompilersInfo, ref Compiler compiler,
     }
 
     if(!("defaultLinker" in allCompilersInfo))
-    {
-        JSONValue defaultLinker = JSONValue.emptyObject;
-        auto def = getDefaultLinker();
-        defaultLinker["type"] = def.type.to!string;
-        defaultLinker["bin"] = def.bin;
-        allCompilersInfo["defaultLinker"] = defaultLinker;
-    }
-    compiler.linker = acceptedLinker(allCompilersInfo);
+        allCompilersInfo["defaultLinker"] = getDefaultLinker.to!string;
+    compiler.linker = acceptedLinkerfromString(allCompilersInfo["defaultLinker"].str);
 
     if(!("compilers" in allCompilersInfo))
         allCompilersInfo["compilers"] = JSONValue.emptyObject;
@@ -548,7 +529,7 @@ private Compiler assumeCompiler(string compilerOrPath, string compilerAssumption
 }
 
 
-Linker getDefaultLinker()
+AcceptedLinker getDefaultLinker()
 {
     with(AcceptedLinker)
     {
@@ -560,12 +541,12 @@ Linker getDefaultLinker()
             if(res.status == 0)
             {
                 if(res.output.startsWith("GNU ld"))
-                    return Linker(gnuld, "ld");
+                    return gnuld;
                 else if(res.output.startsWith("@(#)PROGRAM:ld"))
-                    return Linker(ld64, "ld");
+                    return ld64;
             }
         }
-        return Linker(unknown);
+        return unknown;
     }
 }