Adding cross platform defines

Author: Neko-Box-Coder

CMakeLists.txt

@@ -84,6 +84,7 @@ add_executable(runcpp2
                         "${CMAKE_CURRENT_LIST_DIR}/Src/runcpp2/Data/ProfilesCompilesFiles.cpp"
                         "${CMAKE_CURRENT_LIST_DIR}/Src/runcpp2/Data/FilesTypesInfo.cpp"
                         "${CMAKE_CURRENT_LIST_DIR}/Src/runcpp2/Data/StageInfo.cpp"
+                        "${CMAKE_CURRENT_LIST_DIR}/Src/runcpp2/Data/ProfilesDefines.cpp"
                         "${CMAKE_CURRENT_LIST_DIR}/Src/runcpp2/ProfileHelper.cpp"
                         "${CMAKE_CURRENT_LIST_DIR}/Src/runcpp2/CompilingLinking.cpp"
                         "${CMAKE_CURRENT_LIST_DIR}/Src/runcpp2/ConfigParsing.cpp"

DefaultYAMLs/DefaultScriptInfo.yaml

@@ -1,3 +1,6 @@
+# NOTE: All command substitutions are passed directly to the shell. 
+#       Be cautious when using user-provided input in your build commands to avoid potential security risks.
+
 # NOTE: All the options here are defaulted to empty. 
 #       You can uncomment different sections to set what you want.
 
@@ -52,6 +55,16 @@
 #         All:
 #             - "./AnotherSourceFile.cpp"
 
+# # (Optional) Define cross-compiler defines for each platform and profile.
+# # Defines can be specified as just a name or as a name-value pair.
+# Defines:
+#     # Target Platform (All, Windows, Linux, MacOS, or Unix)
+#     All:
+#         # Profile name (e.g., "g++", "clang++", "msvc", or "All" for any profile)
+#         "All":
+#             - "EXAMPLE_DEFINE"              # Define without a value
+#             - "VERSION_MAJOR=1"             # Define with a value
+
 # # (Optional) The list of dependencies needed by the script
 # Dependencies:
 #     # Dependency name

DefaultYAMLs/DefaultUserConfig.yaml

@@ -6,6 +6,10 @@ Templates:
     "g++_CompileRunParts": &g++_CompileRunParts
     -   Type: Once
         CommandPart: "{Executable} -c {CompileFlags}"
+    -   Type: Repeats
+        CommandPart: " -D{DefineNameOnly}="
+    -   Type: Repeats
+        CommandPart: " \"-D{DefineName}={DefineValue}\""
     -   Type: Repeats
         CommandPart: " -I\"{IncludeDirectoryPath}\""
     -   Type: Once
@@ -20,6 +24,10 @@ Templates:
     "vs2022_v17+_CompileRunParts": &vs2022_v17+_CompileRunParts
     -   Type: Once
         CommandPart: "{Executable} /c {CompileFlags}"
+    -   Type: Repeats
+        CommandPart: " /D{DefineNameOnly}="
+    -   Type: Repeats
+        CommandPart: " \"/D{DefineName}={DefineValue}\""
     -   Type: Repeats
         CommandPart: " /I\"{IncludeDirectoryPath}\""
     -   Type: Once
@@ -91,6 +99,10 @@ Templates:
                 Windows: ""
                 Unix: ""
 
+# WARNING: All command substitutions in this file are passed directly to the shell.
+#          Exercise caution when using variables or user-provided input in your build commands
+#          to prevent potential security vulnerabilities.
+
 # A profile to be used if not specified while running the build script
 PreferredProfile: "g++"
 
@@ -136,6 +148,9 @@ Profiles:
         # {Executable}:             Compiler executable
         # {CompileFlags}:           Compile flags from config and override
         # {IncludeDirectoryPath}:   Path to include directories for both the script and dependencies
+        # {DefineNameOnly}:         Name of a macro to be defined without a value (equivalent to #define X)
+        # {DefineName}:             Name of a macro to be defined with a value
+        # {DefineValue}:            Value of a macro to be defined (used with {DefineName})
 
         # {InputFileName}:          Name of the input file (without directory path and extension)
         # {InputFileExtension}:     Extension of the input file

Examples/test.cpp

@@ -14,6 +14,11 @@
         -   "./AnotherSourceFile.cpp"
         -   "./AnotherSourceFile2.cpp"
 
+Defines:
+    All:
+        # Turns into `TEST_DEF=\"Test Define Working\"` in shell
+        "All": ["TEST_DEF=\\\"Test Define Working\\\""]
+
 Dependencies:
 -   Name: ssLogger
     Platforms: [Windows, Linux, MacOS]
@@ -52,6 +57,7 @@
 int main(int argc, char* argv[])
 {
     std::cout << "Hello World" << std::endl;
+    std::cout << TEST_DEF << std::endl;
 
     for(int i = 0; i < argc; ++i)
         std::cout << "Arg" << i << ": " << argv[i] << std::endl;

Include/runcpp2/Data/ProfilesDefines.hpp

@@ -0,0 +1,32 @@
+#ifndef RUNCPP2_DATA_PROFILES_DEFINES_HPP
+#define RUNCPP2_DATA_PROFILES_DEFINES_HPP
+
+#include "runcpp2/Data/ParseCommon.hpp"
+#include "ryml.hpp"
+#include <unordered_map>
+#include <vector>
+#include <string>
+
+namespace runcpp2
+{
+    namespace Data
+    {
+        struct Define
+        {
+            std::string Name;
+            std::string Value;
+            bool HasValue;
+        };
+
+        class ProfilesDefines
+        {
+            public:
+                std::unordered_map<ProfileName, std::vector<Define>> Defines;
+
+                bool ParseYAML_Node(ryml::ConstNodeRef& node);
+                std::string ToString(std::string indentation) const;
+        };
+    }
+}
+
+#endif

Include/runcpp2/Data/ScriptInfo.hpp

@@ -5,6 +5,7 @@
 #include "runcpp2/Data/ProfilesFlagsOverride.hpp"
 #include "runcpp2/Data/ParseCommon.hpp"
 #include "runcpp2/Data/ProfilesCompilesFiles.hpp"
+#include "runcpp2/Data/ProfilesDefines.hpp"
 
 #include <string>
 #include <vector>
@@ -27,6 +28,7 @@ namespace runcpp2
 
                 std::vector<DependencyInfo> Dependencies;
 
+                std::unordered_map<PlatformName, ProfilesDefines> Defines;
 
                 bool Populated = false;
 

README.md

@@ -71,6 +71,9 @@ Everything is documented as comment in the template but here's a quick summary.
 - `OtherFilesToBeCompiled`: Other source files you wish to be compiled.
 - `Dependencies`: Any external libraries you wish to use. See next section.
 
+> [!NOTE]
+> Settings in the script info are passed directly to the shell. Be cautious when using user-provided input in your build commands.
+
 #### 4. Using External Libraries
 
 To use any external libraries, you need to specify them in the Dependencies section.

Src/runcpp2/CompilingLinking.cpp

@@ -126,6 +126,44 @@ namespace
             }
         }
 
+        // Add defines
+        if(runcpp2::HasValueFromPlatformMap(scriptInfo.Defines))
+        {
+            const runcpp2::Data::ProfilesDefines& platformDefines = 
+                *runcpp2::GetValueFromPlatformMap(scriptInfo.Defines);
+            
+            std::vector<std::string> profileNames;
+            profile.GetNames(profileNames);
+            
+            std::string validProfileName;
+            for(int i = 0; i < profileNames.size(); ++i)
+            {
+                if(platformDefines.Defines.count(profileNames[i]) > 0)
+                {
+                    validProfileName = profileNames.at(i);
+                    break;
+                }
+            }
+            
+            if(!validProfileName.empty())
+            {
+                const std::vector<runcpp2::Data::Define>& profileDefines = 
+                    platformDefines.Defines.at(validProfileName);
+                
+                for(int i = 0; i < profileDefines.size(); ++i)
+                {
+                    const runcpp2::Data::Define& define = profileDefines.at(i);
+                    if(define.HasValue)
+                    {
+                        substitutionMapTemplate["{DefineName}"].push_back(define.Name);
+                        substitutionMapTemplate["{DefineValue}"].push_back(define.Value);
+                    }
+                    else
+                        substitutionMapTemplate["{DefineNameOnly}"].push_back(define.Name);
+                }
+            }
+        }
+        
         std::unordered_map<std::string, std::vector<std::string>> substitutionMap;
         substitutionMap = substitutionMapTemplate;
 
@@ -717,6 +755,7 @@ bool runcpp2::CompileAndLinkScript( const ghc::filesystem::path& buildDir,
                 availableDependencies.at(i)->LinkProperties.end())
             {
                 targetProfileName = currentProfileNames.at(j);
+                break;
             }
         }
 

Src/runcpp2/Data/ProfilesDefines.cpp

@@ -0,0 +1,75 @@
+#include "runcpp2/Data/ProfilesDefines.hpp"
+#include "runcpp2/ParseUtil.hpp"
+#include "ssLogger/ssLog.hpp"
+#include <string>
+
+bool runcpp2::Data::ProfilesDefines::ParseYAML_Node(ryml::ConstNodeRef& node)
+{
+    ssLOG_FUNC_DEBUG();
+
+    INTERNAL_RUNCPP2_SAFE_START();
+    
+    if(!node.is_map())
+    {
+        ssLOG_ERROR("ProfilesDefines: Not a map type");
+        return false;
+    }
+    
+    for(int i = 0; i < node.num_children(); ++i)
+    {
+        if(!INTERNAL_RUNCPP2_BIT_CONTANTS(node[i].type().type, ryml::NodeType_e::SEQ))
+        {
+            ssLOG_ERROR("ProfilesDefines: Defines type requires a list");
+            return false;
+        }
+        
+        ryml::ConstNodeRef currentProfileDefinesNode = node[i];
+        ProfileName profile = GetKey(currentProfileDefinesNode);
+
+        for(int j = 0; j < currentProfileDefinesNode.num_children(); ++j)
+        {
+            std::string defineStr = GetValue(currentProfileDefinesNode[j]);
+            Define define;
+            
+            size_t equalPos = defineStr.find('=');
+            if(equalPos != std::string::npos)
+            {
+                define.Name = defineStr.substr(0, equalPos);
+                define.Value = defineStr.substr(equalPos + 1);
+                define.HasValue = true;
+            }
+            else
+            {
+                define.Name = defineStr;
+                define.Value = "";
+                define.HasValue = false;
+            }
+            
+            Defines[profile].push_back(define);
+        }
+    }
+    
+    return true;
+    
+    INTERNAL_RUNCPP2_SAFE_CATCH_RETURN(false);
+}
+
+std::string runcpp2::Data::ProfilesDefines::ToString(std::string indentation) const
+{
+    std::string result;
+    
+    for(const auto& profileDefines : Defines)
+    {
+        result += indentation + profileDefines.first + ":\n";
+        for(const auto& define : profileDefines.second)
+        {
+            result += indentation + "-   ";
+            if(define.Value.empty())
+                result += define.Name + "\n";
+            else
+                result += define.Name + "=" + define.Value + "\n";
+        }
+    }
+    
+    return result;
+}

Src/runcpp2/Data/ScriptInfo.cpp

@@ -17,6 +17,7 @@ bool runcpp2::Data::ScriptInfo::ParseYAML_Node(ryml::ConstNodeRef& node)
         NodeRequirement("OverrideLinkFlags", ryml::NodeType_e::MAP, false, true),
         NodeRequirement("OtherFilesToBeCompiled", ryml::NodeType_e::MAP, false, true),
         NodeRequirement("Dependencies", ryml::NodeType_e::SEQ, false, true),
+        NodeRequirement("Defines", ryml::NodeType_e::MAP, false, true)
     };
 
     if(!CheckNodeRequirements(node, requirements))
@@ -120,6 +121,25 @@ bool runcpp2::Data::ScriptInfo::ParseYAML_Node(ryml::ConstNodeRef& node)
         }
     }
 
+    if(ExistAndHasChild(node, "Defines"))
+    {
+        ryml::ConstNodeRef definesNode = node["Defines"];
+        
+        for(int i = 0; i < definesNode.num_children(); ++i)
+        {
+            PlatformName platform = GetKey(definesNode[i]);
+            ProfilesDefines profilesDefines;
+            ryml::ConstNodeRef currentDefinesNode = definesNode[i];
+            
+            if(!profilesDefines.ParseYAML_Node(currentDefinesNode))
+            {
+                ssLOG_ERROR("ScriptInfo: Failed to parse Defines.");
+                return false;
+            }
+            Defines[platform] = profilesDefines;
+        }
+    }
+    
     return true;
 
     INTERNAL_RUNCPP2_SAFE_CATCH_RETURN(false);
@@ -166,5 +186,12 @@ std::string runcpp2::Data::ScriptInfo::ToString(std::string indentation) const
     for(int i = 0; i < Dependencies.size(); ++i)
         out += Dependencies[i].ToString(indentation + "    ");
 
+    out += indentation + "    Defines:\n";
+    for(auto it = Defines.begin(); it != Defines.end(); ++it)
+    {
+        out += indentation + "        " + it->first + ":\n";
+        out += it->second.ToString(indentation + "            ");
+    }
+    
     return out;
 }