Update: Added archiver and linker information for redub

Author: MrcSnm

source/redub/buildapi.d

@@ -8,7 +8,7 @@ import redub.package_searching.api;
 
 
 ///vX.X.X
-enum RedubVersionOnly = "v1.21.12";
+enum RedubVersionOnly = "v1.21.13";
 ///Redub vX.X.X
 enum RedubVersionShort = "Redub "~RedubVersionOnly;
 ///Redub vX.X.X - Description

source/redub/building/compile.d

@@ -128,10 +128,11 @@ CompilationResult execCompilation(immutable ThreadBuildData data, shared Project
 
             if(!isDCompiler(compiler) && !ret.status) //Always requires link.
             {
-                CompilationResult linkRes = link(cast()pack, hash.requirementHash, data, info, env);
-                ret.status = linkRes.status;
-                ret.output~= linkRes.message;
-                res.compilationCommand~= linkRes.compilationCommand;
+                string cmd ;
+                auto archiverRes = executeArchiver(data, info, cmd);
+                ret.status = archiverRes.status;
+                ret.output~= archiverRes.output;
+                res.compilationCommand~= cmd;
             }
 
             copyDir(inDir, dirName(outDir));

source/redub/building/utils.d

@@ -58,4 +58,27 @@ auto linkBase(const ThreadBuildData data, CompilingSession session, string rootH
         compilationCommand,
         session.compiler.isDCompiler,
     );
+}
+
+auto executeArchiver(const ThreadBuildData data, CompilingSession s, out string command)
+{
+    import std.process;
+    import std.array;
+    import redub.command_generators.commons;
+    import redub.compiler_identification;
+    Archiver a = s.compiler.archiver;
+
+    string cmd = a.bin;
+    final switch(a.type) with(AcceptedArchiver)
+    {
+        case ar, llvmAr: cmd~= " rcs "; break;
+        case libtool: cmd~= " -static -o "; break;
+        case none: break;
+    }
+
+    cmd~= getOutputName(data.cfg, s.os, s.isa);
+
+    command = join([cmd] ~ data.cfg.sourceFiles, " ");
+
+    return executeShell(command);
 }

source/redub/command_generators/automatic.d

@@ -51,7 +51,7 @@ string getLinkerBin(Compiler compiler)
 {
     if(compiler.isDCompiler)
         return compiler.binOrPath;
-    return compiler.archiver;
+    return compiler.linker.bin;
 }
 
 
@@ -64,7 +64,7 @@ string getLinkCommands(const ThreadBuildData data, CompilingSession s, string ma
 
     if(s.compiler.isDCompiler)
         return escapeShellCommand(s.compiler.binOrPath) ~ " "~ processFlags(flags);
-    return escapeShellCommand(s.compiler.archiver) ~ " " ~ processFlags(flags);
+    return escapeShellCommand(s.compiler.linker.bin) ~ " " ~ processFlags(flags);
 }
 
 

source/redub/command_generators/d_compilers.d

@@ -143,11 +143,11 @@ string function(ValidDFlags) getFlagMapper(AcceptedCompiler comp)
     {
         case AcceptedCompiler.dmd: return &dmdFlags;
         case AcceptedCompiler.ldc2: return &ldcFlags;
+        case AcceptedCompiler.gcc, AcceptedCompiler.gxx: return &gccFlags;
         default: throw new Exception("Compiler sent is not a D compiler.");
     }
 }
 
-
 string dmdFlags(ValidDFlags flag)
 {
     final switch(flag) with (ValidDFlags)
@@ -222,6 +222,43 @@ string ldcFlags(ValidDFlags flag)
     }
 }
 
+string gccFlags(ValidDFlags flag)
+{
+    final switch(flag) with (ValidDFlags)
+    {
+        case debugMode: return null;
+        case debugInfo: return "-g";
+        case releaseMode: return "-O3";
+        case optimize: return "-O3";
+        case inline: return "-finline";
+        case noBoundsCheck: return null;
+        case unittests: return null;
+        case syntaxOnly: return "-S";
+        case profile: return null;
+        case profileGC: return null;
+        case coverage: return null;
+        case coverageCTFE: return null;
+        case mixinFile: return null;
+        case verbose: return "-v";
+        case verboseCodeGen: return null;
+        case timeTrace: return null;
+        case timeTraceFile: return null;
+        case enableColor: return null;
+        case stringImportPaths: return "-I";
+        case versions: return "-D";
+        case debugVersions: return "-D";
+        case importPaths: return "-I";
+        case objectDir: return null;
+        case outputFile: return "-o";
+        case buildAsLibrary: return null;
+        case buildAsShared: return "-shared";
+        case compileOnly: return "-c";
+        case arch: return null;
+        case preserveNames: return null;
+        case deps: return null;
+    }
+}
+
 // Determines whether the specified process is running under WOW64 or an Intel64 of x64 processor.
 version (Windows)
 private bool isWow64() {

source/redub/command_generators/linkers.d

@@ -10,7 +10,7 @@ string[] parseLinkConfiguration(const ThreadBuildData data, CompilingSession s,
     import redub.misc.path;
     import redub.building.cache;
     string[] commands;
-    AcceptedLinker linker = s.compiler.linker;
+    AcceptedLinker linker = s.compiler.linker.type;
     bool emitStartGroup = s.isa != ISA.webAssembly && linker != AcceptedLinker.ld64;
 
 

source/redub/compiler_identification.d

@@ -3,7 +3,7 @@ public import redub.libs.semver;
 import hipjson;
 
 
-enum AcceptedCompiler
+enum AcceptedCompiler : ubyte
 {
     invalid,
     dmd,
@@ -12,21 +12,44 @@ enum AcceptedCompiler
     gxx
 }
 
-enum AcceptedLinker
+enum AcceptedLinker : ubyte
 {
     unknown,
     gnuld,
     ld64,
     ///I know there a plenty more, but still..
 }
 
+enum AcceptedArchiver : ubyte
+{
+    ar,
+    llvmAr,
+    libtool,
+    /**
+     * D compiler will be used for creating the library
+     */
+    none
+}
+
 enum UsesGnuLinker
 {
     unknown,
     yes,
     no
 }
 
+
+struct Archiver
+{
+    AcceptedArchiver type;
+    string bin;
+}
+struct Linker
+{
+    AcceptedLinker type;
+    string bin;
+}
+
 AcceptedCompiler acceptedCompilerfromString(string str)
 {
     switch(str)
@@ -54,6 +77,35 @@ AcceptedLinker acceptedLinkerfromString(string str)
     }
 }
 
+AcceptedArchiver acceptedArchiverFromString(string str)
+{
+    switch(str)
+    {
+        static foreach(mem; __traits(allMembers, AcceptedArchiver))
+        {
+            case mem:
+                return __traits(getMember, AcceptedArchiver, mem);
+        }
+        default:
+            return AcceptedArchiver.none;
+    }
+}
+
+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;
+    if(!acc)
+        return Archiver(AcceptedArchiver.none);
+    return Archiver(acceptedArchiverFromString(acc.object["type"].str), acc.object["bin"].str);
+}
 
 
 /** 
@@ -75,14 +127,21 @@ struct Compiler
     ///Accepts both a complete path to an executable or a global environment search path name
     string binOrPath;
 
-    ///Librarian tool
-    string archiver = "llvm-ar";
+    /**
+     * For generating libraries, redub might use dmd/ldc2 by default since that simplifies the logic.
+     * Although it is slightly slower, this is also a compromise one takes by using integration with C
+     */
+    Archiver archiver = Archiver(AcceptedArchiver.none);
 
+    /**
+     * Currently a flag that only affects Windows. Usually it is turned off since depending on the case, it might
+     * make compilation slower
+     */
     bool usesIncremental = false;
 
     ///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.
-    AcceptedLinker linker = AcceptedLinker.unknown;
+    Linker linker = Linker(AcceptedLinker.unknown);
 
 
     string getCompilerString() const
@@ -239,7 +298,8 @@ Compiler getCompiler(string compilerOrPath = "dmd", string compilerAssumption =
     if(ret == Compiler.init)
         ret = inferCompiler(compilerOrPath, compilerAssumption, compilersInfo, isDefault, isGlobal);
 
-    ret.linker = acceptedLinkerfromString(compilersInfo["defaultLinker"].str);
+    ret.linker = acceptedLinker(compilersInfo);
+    ret.archiver = acceptedArchiver(compilersInfo);
 
     //Checks for ldc.conf switches to see if it is using gnu linker by default
     ///TODO: Might be reactivated if that issue shows again.
@@ -376,7 +436,7 @@ private Compiler getCompilerFromCache(JSONValue allCompilersInfo, string compile
                     SemVer(arr[VERSION_].str),
                     SemVer(arr[FRONTEND_VERSION].str),
                     arr[VERSION_STRING].str,
-                    key, null, false, acceptedLinkerfromString(allCompilersInfo["defaultLinker"].str)
+                    key, acceptedArchiver(allCompilersInfo), false, acceptedLinker(allCompilersInfo)
                 );
             }
         }
@@ -417,11 +477,24 @@ private void saveCompilerInfo(JSONValue allCompilersInfo, ref Compiler compiler,
     }
     if(!("version" in allCompilersInfo))
         allCompilersInfo["version"] = JSONValue(RedubVersionOnly);
+    if(!("defaultArchiver" in allCompilersInfo))
+    {
+        JSONValue defaultArchiver = JSONValue.emptyObject;
+        auto def = getDefaultArchiver();
+        defaultArchiver["type"] = def.type.to!string;
+        defaultArchiver["bin"] = def.bin;
+        allCompilersInfo["defaultArchiver"] = defaultArchiver;
+    }
 
     if(!("defaultLinker" in allCompilersInfo))
-        allCompilersInfo["defaultLinker"] = JSONValue(getDefaultLinker().to!string);
-
-    compiler.linker = acceptedLinkerfromString(allCompilersInfo["defaultLinker"].str);
+    {
+        JSONValue defaultLinker = JSONValue.emptyObject;
+        auto def = getDefaultLinker();
+        defaultLinker["type"] = def.type.to!string;
+        defaultLinker["bin"] = def.bin;
+        allCompilersInfo["defaultLinker"] = defaultLinker;
+    }
+    compiler.linker = acceptedLinker(allCompilersInfo);
 
     if(!("compilers" in allCompilersInfo))
         allCompilersInfo["compilers"] = JSONValue.emptyObject;
@@ -475,23 +548,42 @@ private Compiler assumeCompiler(string compilerOrPath, string compilerAssumption
 }
 
 
-AcceptedLinker getDefaultLinker()
+Linker getDefaultLinker()
 {
-    version(Posix)
+    with(AcceptedLinker)
     {
-        import std.process;
-        import std.string;
-        auto res = executeShell("ld -v");
-        if(res.status != 0)
-            return AcceptedLinker.unknown;
-
-        if(res.output.startsWith("GNU ld"))
-            return AcceptedLinker.gnuld;
-        else if(res.output.startsWith("@(#)PROGRAM:ld"))
-            return AcceptedLinker.ld64;
+        version(Posix)
+        {
+            import std.process;
+            import std.string;
+            auto res = executeShell("ld -v");
+            if(res.status == 0)
+            {
+                if(res.output.startsWith("GNU ld"))
+                    return Linker(gnuld, "ld");
+                else if(res.output.startsWith("@(#)PROGRAM:ld"))
+                    return Linker(ld64, "ld");
+            }
+        }
+        return Linker(unknown);
     }
+}
 
-    return AcceptedLinker.unknown;
+
+Archiver getDefaultArchiver()
+{
+    import std.array:staticArray;
+    import std.process;
+    with(AcceptedArchiver)
+    {
+        foreach(Archiver v; [Archiver(ar, "ar"), Archiver(llvmAr, "llvm-ar"), Archiver(libtool, "libtool")].staticArray)
+        {
+            auto res = executeShell(v.bin~" --help");
+            if(res.status == 0)
+                return v;
+        }
+        return Archiver(none);
+    }
 }
 
 private bool tryInferLdc(string compilerOrPath, string vString, out Compiler comp)