Adding ExecutableShared option for profile...

Neko-Box-Coder · Neko-Box-Coder · commit 10183923ca1d · 2025-01-14T23:23:13.000Z
Adding ExecutableShared option for profile,
Fixing ConstructCommand not working for executable type
diff --git a/DefaultYAMLs/DefaultUserConfig.yaml b/DefaultYAMLs/DefaultUserConfig.yaml
@@ -172,6 +172,13 @@ Profiles:
                     # (Optional) The commands to run in **shell** AFTER compiling
                     #            This is run inside the .runcpp2 directory where the build happens.
                     # Cleanup: []
+            ExecutableShared:
+                DefaultPlatform:
+                    Flags: "-std=c++17 -Wall -g -fpic"
+                    Executable: "g++"
+                    RunParts: *g++_CompileRunParts
+                    # Setup: []
+                    # Cleanup: []
             Static:
                 DefaultPlatform:
                     Flags: "-std=c++17 -Wall -g"
@@ -227,14 +234,15 @@ Profiles:
         # {OutputFilePath}:             (Similar to previous)
         LinkTypes:
             Executable:
-                Unix:
+                DefaultPlatform:
                     Flags: "-Wl,-rpath,\\$ORIGIN"
                     Executable: "g++"
                     RunParts: *g++_LinkRunParts
                     # Setup: []
                     # Cleanup: []
-                Windows:
-                    Flags: "-Wl,-rpath,\\$ORIGIN"
+            ExecutableShared:
+                DefaultPlatform:
+                    Flags: "-shared -Wl,-rpath,\\$ORIGIN"
                     Executable: "g++"
                     RunParts: *g++_LinkRunParts
                     # Setup: []
@@ -247,13 +255,7 @@ Profiles:
                     # Setup: []
                     # Cleanup: []
             Shared:
-                Unix:
-                    Flags: "-shared -Wl,-rpath,\\$ORIGIN"
-                    Executable: "g++"
-                    RunParts: *g++_LinkRunParts
-                    # Setup: []
-                    # Cleanup: []
-                Windows:
+                DefaultPlatform:
                     Flags: "-shared -Wl,-rpath,\\$ORIGIN"
                     Executable: "g++"
                     RunParts: *g++_LinkRunParts
@@ -286,6 +288,11 @@ Profiles:
                     <<: *MSVC_CompileFlags
                     Executable: "CL.exe"
                     RunParts: *vs2022_v17+_CompileRunParts
+            ExecutableShared:
+                Windows:
+                    <<: *MSVC_CompileFlags
+                    Executable: "CL.exe"
+                    RunParts: *vs2022_v17+_CompileRunParts
             Static:
                 Windows:
                     <<: *MSVC_CompileFlags
@@ -296,7 +303,6 @@ Profiles:
                     <<: *MSVC_CompileFlags
                     Executable: "CL.exe"
                     RunParts: *vs2022_v17+_CompileRunParts
-    # Specify the linker settings
     Linker:
         PreRun: 
             Windows: ".\\prerun.bat"
@@ -310,12 +316,7 @@ Profiles:
                         oleaut32.lib uuid.lib comdlg32.lib advapi32.lib /manifest:embed /SUBSYSTEM:CONSOLE
                     Executable: "link.exe"
                     RunParts: *vs2022_v17+_LinkRunParts
-            Static:
-                Windows:
-                    Flags: "/NOLOGO"
-                    Executable: "lib.exe"
-                    RunParts: *vs2022_v17+_LinkRunParts
-            Shared:
+            ExecutableShared:
                 Windows:
                     Flags: >-
                         /NOLOGO kernel32.lib user32.lib gdi32.lib winspool.lib shell32.lib ole32.lib
@@ -329,3 +330,17 @@ Profiles:
                         CommandPart: " \"{LinkFilePath}\""
                     Setup: [ "echo EXPORTS > .\\temp.def", "echo.   main @1 >> .\\temp.def" ]
                     Cleanup: [ "del .\\temp.def" ]
+            Static:
+                Windows:
+                    Flags: "/NOLOGO"
+                    Executable: "lib.exe"
+                    RunParts: *vs2022_v17+_LinkRunParts
+            Shared:
+                Windows:
+                    Flags: >-
+                        /NOLOGO kernel32.lib user32.lib gdi32.lib winspool.lib shell32.lib ole32.lib
+                        oleaut32.lib uuid.lib comdlg32.lib advapi32.lib /manifest:embed /SUBSYSTEM:CONSOLE
+                        /DLL
+                    Executable: "link.exe"
+                    RunParts: *vs2022_v17+_LinkRunParts
+
diff --git a/Include/runcpp2/Data/StageInfo.hpp b/Include/runcpp2/Data/StageInfo.hpp
@@ -45,6 +45,7 @@ namespace runcpp2
                 struct 
                 {
                     std::unordered_map<PlatformName, OutputTypeInfo> Executable;
+                    std::unordered_map<PlatformName, OutputTypeInfo> ExecutableShared;
                     std::unordered_map<PlatformName, OutputTypeInfo> Static;
                     std::unordered_map<PlatformName, OutputTypeInfo> Shared;
                 } OutputTypes;
diff --git a/Src/Tests/Data/ProfileTest.cpp b/Src/Tests/Data/ProfileTest.cpp
@@ -69,6 +69,17 @@ int main(int argc, char** argv)
                                 CommandPart: " -I\"{IncludeDirectoryPath}\""
                             -   Type: Once
                                 CommandPart: " \"{InputFilePath}\" -o \"{OutputFilePath}\""
+                    ExecutableShared:
+                        DefaultPlatform:
+                            Flags: "-std=c++17 -Wall -g -fpic"
+                            Executable: "g++"
+                            RunParts:
+                            -   Type: Once
+                                CommandPart: "{Executable} -c {CompileFlags}"
+                            -   Type: Repeats
+                                CommandPart: " -I\"{IncludeDirectoryPath}\""
+                            -   Type: Once
+                                CommandPart: " \"{InputFilePath}\" -o \"{OutputFilePath}\""
                     Static:
                         DefaultPlatform:
                             Flags: "-std=c++17 -Wall -g"
@@ -116,6 +127,13 @@ int main(int argc, char** argv)
                             RunParts:
                             -   Type: Once
                                 CommandPart: "{Executable} {LinkFlags} -o \"{OutputFilePath}\""
+                    ExecutableShared:
+                        Unix:
+                            Flags: "-shared -Wl,-rpath,\\$ORIGIN"
+                            Executable: "g++"
+                            RunParts:
+                            -   Type: Once
+                                CommandPart: "{Executable} {LinkFlags} -o \"{OutputFilePath}\""
         )";
         
         ssTEST_OUTPUT_SETUP
@@ -196,6 +214,22 @@ int main(int argc, char** argv)
         ssTEST_OUTPUT_ASSERT(   "Compiler Executable RunParts size", 
                                 executableCompile.RunParts.size() == 3);
         
+        //Verify Compiler ExecutableShared
+        ssTEST_OUTPUT_SETUP
+        (
+            const auto& executableSharedCompile = 
+                profile.Compiler.OutputTypes.ExecutableShared.at("DefaultPlatform");
+        );
+        ssTEST_OUTPUT_ASSERT(   "Compiler ExecutableShared flags", 
+                                executableSharedCompile.Flags, 
+                                "-std=c++17 -Wall -g -fpic");
+        ssTEST_OUTPUT_ASSERT(   "Compiler ExecutableShared executable", 
+                                executableSharedCompile.Executable, 
+                                "g++");
+        ssTEST_OUTPUT_ASSERT(   "Compiler ExecutableShared RunParts size", 
+                                executableSharedCompile.RunParts.size(), 
+                                3);
+        
         //Verify Linker
         ssTEST_OUTPUT_ASSERT(   "Linker CheckExistence DefaultPlatform", 
                                 profile.Linker.CheckExistence.at("DefaultPlatform") == "g++ -v");
@@ -210,6 +244,22 @@ int main(int argc, char** argv)
         ssTEST_OUTPUT_ASSERT(   "Linker Executable RunParts size", 
                                 executableLink.RunParts.size() == 1);
         
+        //Verify Linker ExecutableShared
+        ssTEST_OUTPUT_SETUP
+        (
+            const auto& executableSharedLink = 
+                profile.Linker.OutputTypes.ExecutableShared.at("Unix");
+        );
+        ssTEST_OUTPUT_ASSERT(   "Linker ExecutableShared flags", 
+                                executableSharedLink.Flags, 
+                                "-shared -Wl,-rpath,\\$ORIGIN");
+        ssTEST_OUTPUT_ASSERT(   "Linker ExecutableShared executable", 
+                                executableSharedLink.Executable, 
+                                "g++");
+        ssTEST_OUTPUT_ASSERT(   "Linker ExecutableShared RunParts size", 
+                                executableSharedLink.RunParts.size(), 
+                                1);
+        
         //Test ToString() and Equals()
         ssTEST_OUTPUT_EXECUTION
         (
diff --git a/Src/Tests/Data/StageInfoTest.cpp b/Src/Tests/Data/StageInfoTest.cpp
@@ -28,6 +28,15 @@ int main(int argc, char** argv)
                             CommandPart: "{Executable} {LinkFlags} -o \"{OutputFilePath}\""
                         -   Type: Repeats
                             CommandPart: " \"{LinkFilePath}\""
+                ExecutableShared:
+                    Unix:
+                        Flags: "-shared -Wl,-rpath,\\$ORIGIN"
+                        Executable: "g++"
+                        RunParts:
+                        -   Type: Once
+                            CommandPart: "{Executable} {LinkFlags} -o \"{OutputFilePath}\""
+                        -   Type: Repeats
+                            CommandPart: " \"{LinkFilePath}\""
                 Static:
                     Unix:
                         Flags: "-Wl,-rpath,\\$ORIGIN"
@@ -72,17 +81,38 @@ int main(int argc, char** argv)
         (
             const auto& unixInfo = stageInfo.OutputTypes.Executable.at("Unix");
         );
-        ssTEST_OUTPUT_ASSERT("Unix flags", unixInfo.Flags == "-Wl,-rpath,\\$ORIGIN");
-        ssTEST_OUTPUT_ASSERT("Unix executable", unixInfo.Executable == "g++");
-        ssTEST_OUTPUT_ASSERT("Unix setup count", unixInfo.Setup.size() == 1);
-        ssTEST_OUTPUT_ASSERT("Unix cleanup count", unixInfo.Cleanup.size() == 1);
-        ssTEST_OUTPUT_ASSERT("Unix run parts count", unixInfo.RunParts.size() == 2);
-        ssTEST_OUTPUT_ASSERT(   "Unix first run type", 
+        ssTEST_OUTPUT_ASSERT("Unix Executable flags", unixInfo.Flags, "-Wl,-rpath,\\$ORIGIN");
+        ssTEST_OUTPUT_ASSERT("Unix Executable executable", unixInfo.Executable, "g++");
+        ssTEST_OUTPUT_ASSERT("Unix Executable setup count", unixInfo.Setup.size(), 1);
+        ssTEST_OUTPUT_ASSERT("Unix Executable cleanup count", unixInfo.Cleanup.size(), 1);
+        ssTEST_OUTPUT_ASSERT("Unix Executable run parts count", unixInfo.RunParts.size(), 2);
+        ssTEST_OUTPUT_ASSERT(   "Unix Executable first run type", 
                                 unixInfo.RunParts.at(0).Type == 
                                 runcpp2::Data::StageInfo::RunPart::RunType::ONCE);
-        ssTEST_OUTPUT_ASSERT(   "Unix second run command", 
+        ssTEST_OUTPUT_ASSERT(   "Unix Executable second run command", 
                                 unixInfo.RunParts.at(1).CommandPart, " \"{LinkFilePath}\"");
         
+        //Verify Unix OutputTypeInfo for ExecutableShared
+        ssTEST_OUTPUT_SETUP
+        (
+            const auto& unixExecSharedInfo = stageInfo.OutputTypes.ExecutableShared.at("Unix");
+        );
+        ssTEST_OUTPUT_ASSERT(   "Unix ExecutableShared flags", 
+                                unixExecSharedInfo.Flags, 
+                                "-shared -Wl,-rpath,\\$ORIGIN");
+        ssTEST_OUTPUT_ASSERT(   "Unix ExecutableShared executable", 
+                                unixExecSharedInfo.Executable, 
+                                "g++");
+        ssTEST_OUTPUT_ASSERT(   "Unix ExecutableShared run parts count", 
+                                unixExecSharedInfo.RunParts.size(), 
+                                2);
+        ssTEST_OUTPUT_ASSERT(   "Unix ExecutableShared first run type", 
+                                unixExecSharedInfo.RunParts.at(0).Type ==
+                                runcpp2::Data::StageInfo::RunPart::RunType::ONCE);
+        ssTEST_OUTPUT_ASSERT(   "Unix ExecutableShared second run command", 
+                                unixExecSharedInfo.RunParts.at(1).CommandPart, 
+                                " \"{LinkFilePath}\"");
+        
         //Test ToString() and Equals()
         ssTEST_OUTPUT_EXECUTION
         (
@@ -97,6 +127,66 @@ int main(int argc, char** argv)
         ssTEST_OUTPUT_ASSERT("Parsed output should equal original", stageInfo.Equals(parsedOutput));
     };
     
+    ssTEST("StageInfo Should Handle Malformed YAML")
+    {
+        const char* malformedYamlStr = R"(
+            LinkTypes:
+                ExecutableShared:  # Missing required fields
+                    Unix:
+                        Flags: "-shared"
+                        # Missing Executable
+                        # Missing RunParts
+        )";
+        
+        ssTEST_OUTPUT_SETUP
+        (
+            ryml::Tree tree = ryml::parse_in_arena(c4::to_csubstr(malformedYamlStr));
+            ryml::ConstNodeRef root = tree.rootref();
+            
+            runcpp2::Data::StageInfo stageInfo;
+        );
+        
+        ssTEST_OUTPUT_EXECUTION
+        (
+            ryml::ConstNodeRef nodeRef = root;
+            bool parseResult = stageInfo.ParseYAML_Node(nodeRef, "LinkTypes");
+        );
+        
+        ssTEST_OUTPUT_ASSERT("ParseYAML_Node should fail for malformed YAML", !parseResult);
+    };
+
+    ssTEST("StageInfo Should Handle Missing ExecutableShared")
+    {
+        const char* yamlStr = R"(
+            LinkTypes:
+                Executable:
+                    Unix:
+                        Flags: "-Wl,-rpath,\\$ORIGIN"
+                        Executable: "g++"
+                        RunParts:
+                        -   Type: Once
+                            CommandPart: "{Executable} {LinkFlags}"
+                # Missing ExecutableShared section
+        )";
+        
+        ssTEST_OUTPUT_SETUP
+        (
+            ryml::Tree tree = ryml::parse_in_arena(c4::to_csubstr(yamlStr));
+            ryml::ConstNodeRef root = tree.rootref();
+            
+            runcpp2::Data::StageInfo stageInfo;
+        );
+        
+        ssTEST_OUTPUT_EXECUTION
+        (
+            ryml::ConstNodeRef nodeRef = root;
+            bool parseResult = stageInfo.ParseYAML_Node(nodeRef, "LinkTypes");
+        );
+        
+        ssTEST_OUTPUT_ASSERT(   "ParseYAML_Node should fail for missing ExecutableShared", 
+                                !parseResult);
+    };
+    
     ssTEST_END_TEST_GROUP();
     return 0;
 }
diff --git a/Src/runcpp2/CompilingLinking.cpp b/Src/runcpp2/CompilingLinking.cpp
@@ -81,10 +81,50 @@ namespace
         
         outObjectsFilesPaths.clear();
         
-        const runcpp2::Data::StageInfo::OutputTypeInfo* currentOutputTypeInfo = 
-            compileAsExecutable ? 
-            runcpp2::GetValueFromPlatformMap(profile.Compiler.OutputTypes.Executable) :
-            runcpp2::GetValueFromPlatformMap(profile.Compiler.OutputTypes.Shared);
+        using OutputTypeInfo = runcpp2::Data::StageInfo::OutputTypeInfo;
+        OutputTypeInfo* tempOutputInfo = nullptr;
+        static_assert(  static_cast<int>(runcpp2::Data::BuildType::COUNT) == 4, 
+                        "Add new type to be processed");
+        switch(scriptInfo.CurrentBuildType)
+        {
+            case runcpp2::Data::BuildType::STATIC:
+                tempOutputInfo = const_cast<OutputTypeInfo*>
+                (
+                    runcpp2::GetValueFromPlatformMap(profile.Compiler.OutputTypes.Static)
+                );
+                break;
+            case runcpp2::Data::BuildType::SHARED:
+                tempOutputInfo = const_cast<OutputTypeInfo*>
+                (
+                    runcpp2::GetValueFromPlatformMap(profile.Compiler.OutputTypes.Shared)
+                );
+                break;
+            case runcpp2::Data::BuildType::EXECUTABLE:
+                if(compileAsExecutable)
+                {
+                    tempOutputInfo = const_cast<OutputTypeInfo*>
+                    (
+                        runcpp2::GetValueFromPlatformMap(profile.Compiler.OutputTypes.Executable)
+                    );
+                }
+                else
+                {
+                    
+                    tempOutputInfo = const_cast<OutputTypeInfo*>
+                    (
+                        runcpp2::GetValueFromPlatformMap(profile.Compiler
+                                                                .OutputTypes
+                                                                .ExecutableShared)
+                    );
+                }
+                break;
+            default:
+                ssLOG_ERROR("Unsupported build type for compiling: " << 
+                            runcpp2::Data::BuildTypeToString(scriptInfo.CurrentBuildType));
+                return false;
+        }
+        
+        const OutputTypeInfo* currentOutputTypeInfo = tempOutputInfo;
         
         if(currentOutputTypeInfo == nullptr)
         {
@@ -336,10 +376,15 @@ namespace
                         runcpp2::GetValueFromPlatformMap(profile.Linker.OutputTypes.Static);
                     break;
                 case runcpp2::Data::BuildType::SHARED:
-                case runcpp2::Data::BuildType::EXECUTABLE:
                     currentOutputTypeInfo = 
                         runcpp2::GetValueFromPlatformMap(profile.Linker.OutputTypes.Shared);
                     break;
+                case runcpp2::Data::BuildType::EXECUTABLE:
+                    currentOutputTypeInfo = 
+                        runcpp2::GetValueFromPlatformMap(profile.Linker
+                                                                .OutputTypes
+                                                                .ExecutableShared);
+                    break;
                 default:
                     ssLOG_ERROR("Unsupported build type for linking: " << 
                                 runcpp2::Data::BuildTypeToString(scriptInfo.CurrentBuildType));
diff --git a/Src/runcpp2/Data/StageInfo.cpp b/Src/runcpp2/Data/StageInfo.cpp

Original file line number	Diff line number	Diff line change
`@@ -45,6 +45,7 @@ namespace runcpp2`
`45`	`45`	`struct`
`46`	`46`	`{`
`47`	`47`	`std::unordered_map<PlatformName, OutputTypeInfo> Executable;`
	`48`	`+ std::unordered_map<PlatformName, OutputTypeInfo> ExecutableShared;`
`48`	`49`	`std::unordered_map<PlatformName, OutputTypeInfo> Static;`
`49`	`50`	`std::unordered_map<PlatformName, OutputTypeInfo> Shared;`
`50`	`51`	`} OutputTypes;`