DISTRHO
/
JUCE
mirror of https://github.com/DISTRHO/JUCE
1
0
Fork 0
Code Releases 1 Activity
The JUCE cross-platform C++ framework, with DISTRHO/KXStudio specific changes
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
12894 Commits
11 Branches
347MB
Tree: b720b0f746
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'b720b0f746'
${ noResults }
JUCE/extras/Projucer/Source/ProjectSaving/jucer_ProjectExport_CodeBlo...

823 lines
31KB
Raw Blame History 

  1. /*

  2.   ==============================================================================

  3. 

  4.    This file is part of the JUCE 7 technical preview.

  5.    Copyright (c) 2022 - Raw Material Software Limited

  6. 

  7.    You may use this code under the terms of the GPL v3

  8.    (see www.gnu.org/licenses).

  9. 

  10.    For the technical preview this file cannot be licensed commercially.

  11. 

  12.    JUCE IS PROVIDED "AS IS" WITHOUT ANY WARRANTY, AND ALL WARRANTIES, WHETHER

  13.    EXPRESSED OR IMPLIED, INCLUDING MERCHANTABILITY AND FITNESS FOR PURPOSE, ARE

  14.    DISCLAIMED.

  15. 

  16.   ==============================================================================

  17. */

  18. 

  19. #pragma once

  20. 

  21. #include "jucer_ProjectExport_MSVC.h"

  22. 

  23. //==============================================================================

  24. class CodeBlocksProjectExporter  : public ProjectExporter

  25. {

  26. public:

  27.     enum CodeBlocksOS

  28.     {

  29.         windowsTarget,

  30.         linuxTarget

  31.     };

  32. 

  33.     //==============================================================================

  34.     static String getDisplayNameWindows()        { return "Code::Blocks (Windows)"; }

  35.     static String getDisplayNameLinux()          { return "Code::Blocks (Linux)"; }

  36. 

  37.     static String getValueTreeTypeNameWindows()  { return "CODEBLOCKS_WINDOWS"; }

  38.     static String getValueTreeTypeNameLinux()    { return "CODEBLOCKS_LINUX"; }

  39. 

  40.     static String getTargetFolderNameWindows()   { return "CodeBlocksWindows"; }

  41.     static String getTargetFolderNameLinux()     { return "CodeBlocksLinux"; }

  42. 

  43.     //==============================================================================

  44.     static CodeBlocksProjectExporter* createForSettings (Project& projectToUse, const ValueTree& settingsToUse)

  45.     {

  46.         // this will also import legacy jucer files where CodeBlocks only worked for Windows,

  47.         // had valueTreetTypeName "CODEBLOCKS", and there was no OS distinction

  48.         if (settingsToUse.hasType (getValueTreeTypeNameWindows()) || settingsToUse.hasType ("CODEBLOCKS"))

  49.             return new CodeBlocksProjectExporter (projectToUse, settingsToUse, windowsTarget);

  50. 

  51.         if (settingsToUse.hasType (getValueTreeTypeNameLinux()))

  52.             return new CodeBlocksProjectExporter (projectToUse, settingsToUse, linuxTarget);

  53. 

  54.         return nullptr;

  55.     }

  56. 

  57.     //==============================================================================

  58.     CodeBlocksProjectExporter (Project& p, const ValueTree& t, CodeBlocksOS codeBlocksOs)

  59.         : ProjectExporter (p, t), os (codeBlocksOs)

  60.     {

  61.         if (isWindows())

  62.         {

  63.             name = getDisplayNameWindows();

  64.             targetLocationValue.setDefault (getDefaultBuildsRootFolder() + getTargetFolderNameWindows());

  65.             targetPlatformValue.referTo (settings, Ids::codeBlocksWindowsTarget, getUndoManager());

  66.         }

  67.         else

  68.         {

  69.             name = getDisplayNameLinux();

  70.             targetLocationValue.setDefault (getDefaultBuildsRootFolder() + getTargetFolderNameLinux());

  71.         }

  72.     }

  73. 

  74.     //==============================================================================

  75.     bool canLaunchProject() override                 { return false; }

  76.     bool launchProject() override                    { return false; }

  77.     bool usesMMFiles() const override                { return false; }

  78.     bool canCopeWithDuplicateFiles() override        { return false; }

  79.     bool supportsUserDefinedConfigurations() const override { return true; }

  80. 

  81.     bool isXcode() const override                    { return false; }

  82.     bool isVisualStudio() const override             { return false; }

  83.     bool isCodeBlocks() const override               { return true; }

  84.     bool isMakefile() const override                 { return false; }

  85.     bool isAndroidStudio() const override            { return false; }

  86.     bool isCLion() const override                    { return false; }

  87. 

  88.     bool isAndroid() const override                  { return false; }

  89.     bool isWindows() const override                  { return os == windowsTarget; }

  90.     bool isLinux() const override                    { return os == linuxTarget; }

  91.     bool isOSX() const override                      { return false; }

  92.     bool isiOS() const override                      { return false; }

  93. 

  94.     Identifier getExporterIdentifier() const override

  95.     {

  96.         return isLinux() ? getValueTreeTypeNameLinux() : getValueTreeTypeNameWindows();

  97.     }

  98. 

  99.     String getNewLineString() const override         { return isWindows() ? "\r\n" : "\n"; }

  100. 

  101.     bool supportsTargetType (build_tools::ProjectType::Target::Type type) const override

  102.     {

  103.         switch (type)

  104.         {

  105.             case build_tools::ProjectType::Target::StandalonePlugIn:

  106.             case build_tools::ProjectType::Target::GUIApp:

  107.             case build_tools::ProjectType::Target::ConsoleApp:

  108.             case build_tools::ProjectType::Target::StaticLibrary:

  109.             case build_tools::ProjectType::Target::SharedCodeTarget:

  110.             case build_tools::ProjectType::Target::AggregateTarget:

  111.             case build_tools::ProjectType::Target::VSTPlugIn:

  112.             case build_tools::ProjectType::Target::DynamicLibrary:

  113.                 return true;

  114.             case build_tools::ProjectType::Target::AAXPlugIn:

  115.             case build_tools::ProjectType::Target::RTASPlugIn:

  116.             case build_tools::ProjectType::Target::UnityPlugIn:

  117.             case build_tools::ProjectType::Target::VST3PlugIn:

  118.             case build_tools::ProjectType::Target::AudioUnitPlugIn:

  119.             case build_tools::ProjectType::Target::AudioUnitv3PlugIn:

  120.             case build_tools::ProjectType::Target::unspecified:

  121.             default:

  122.                 break;

  123.         }

  124. 

  125.         return false;

  126.     }

  127. 

  128.     void createExporterProperties (PropertyListBuilder& props) override

  129.     {

  130.         if (isWindows())

  131.         {

  132.             props.add (new ChoicePropertyComponent (targetPlatformValue, "Target platform",

  133.                                                     { "Windows NT 4.0", "Windows 2000", "Windows XP", "Windows Server 2003", "Windows Vista", "Windows Server 2008",

  134.                                                       "Windows 7", "Windows 8", "Windows 8.1", "Windows 10" },

  135.                                                     { "0x0400", "0x0500", "0x0501", "0x0502", "0x0600", "0x0600",

  136.                                                       "0x0601", "0x0602", "0x0603", "0x0A00" }),

  137.                        "This sets the preprocessor macro WINVER to an appropriate value for the corresponding platform.");

  138.         }

  139.     }

  140. 

  141.     //==============================================================================

  142.     void create (const OwnedArray<LibraryModule>&) const override

  143.     {

  144.         auto cbpFile = getTargetFolder().getChildFile (project.getProjectFilenameRootString())

  145.                                         .withFileExtension (".cbp");

  146. 

  147.         XmlElement xml ("CodeBlocks_project_file");

  148.         addVersion (xml);

  149.         createProject (*xml.createNewChildElement ("Project"));

  150.         writeXmlOrThrow (xml, cbpFile, "UTF-8", 10, true);

  151.     }

  152. 

  153.     //==============================================================================

  154.     void addPlatformSpecificSettingsForProjectType (const build_tools::ProjectType&) override

  155.     {

  156.         // add shared code target first as order matters for Codeblocks

  157.         if (shouldBuildTargetType (build_tools::ProjectType::Target::SharedCodeTarget))

  158.             targets.add (new CodeBlocksTarget (*this, build_tools::ProjectType::Target::SharedCodeTarget));

  159. 

  160.         //resource::ProjectType::Target::SharedCodeTarget

  161.         callForAllSupportedTargets ([this] (build_tools::ProjectType::Target::Type targetType)

  162.                                     {

  163.                                         if (targetType == build_tools::ProjectType::Target::SharedCodeTarget)

  164.                                             return;

  165. 

  166.                                         targets.insert (targetType == build_tools::ProjectType::Target::AggregateTarget ? 0 : -1,

  167.                                                         new CodeBlocksTarget (*this, targetType));

  168.                                     });

  169. 

  170.         // If you hit this assert, you tried to generate a project for an exporter

  171.         // that does not support any of your targets!

  172.         jassert (targets.size() > 0);

  173.     }

  174. 

  175.     void initialiseDependencyPathValues() override

  176.     {

  177.         auto targetOS = isWindows() ? TargetOS::windows : TargetOS::linux;

  178. 

  179.         vstLegacyPathValueWrapper.init ({ settings, Ids::vstLegacyFolder, nullptr },

  180.                                         getAppSettings().getStoredPath (Ids::vstLegacyPath, targetOS), targetOS);

  181.     }

  182. 

  183. private:

  184.     ValueTreePropertyWithDefault targetPlatformValue;

  185. 

  186.     String getTargetPlatformString() const    { return targetPlatformValue.get(); }

  187. 

  188.     //==============================================================================

  189.     class CodeBlocksBuildConfiguration  : public BuildConfiguration

  190.     {

  191.     public:

  192.         CodeBlocksBuildConfiguration (Project& p, const ValueTree& settings, const ProjectExporter& e)

  193.             : BuildConfiguration (p, settings, e),

  194.               architectureTypeValue (config, exporter.isWindows() ? Ids::windowsCodeBlocksArchitecture

  195.                                                                   : Ids::linuxCodeBlocksArchitecture, getUndoManager(), "-m64")

  196.         {

  197.             linkTimeOptimisationValue.setDefault (false);

  198.             optimisationLevelValue.setDefault (isDebug() ? gccO0 : gccO3);

  199.         }

  200. 

  201.         void createConfigProperties (PropertyListBuilder& props) override

  202.         {

  203.             addRecommendedLinuxCompilerWarningsProperty (props);

  204.             addGCCOptimisationProperty (props);

  205. 

  206.             props.add (new ChoicePropertyComponent (architectureTypeValue, "Architecture",

  207.                                                     { "32-bit (-m32)", "64-bit (-m64)", "ARM v6",       "ARM v7" },

  208.                                                     { "-m32",          "-m64",          "-march=armv6", "-march=armv7" }),

  209.                        "Specifies the 32/64-bit architecture to use.");

  210.         }

  211. 

  212.         String getModuleLibraryArchName() const override

  213.         {

  214.             auto archFlag = getArchitectureTypeString();

  215.             String prefix ("-march=");

  216. 

  217.             if (archFlag.startsWith (prefix))

  218.                 return archFlag.substring (prefix.length());

  219.             else if (archFlag == "-m64")

  220.                 return "x86_64";

  221.             else if (archFlag == "-m32")

  222.                 return "i386";

  223. 

  224.             jassertfalse;

  225.             return {};

  226.         }

  227. 

  228.         String getArchitectureTypeString() const    { return architectureTypeValue.get(); }

  229. 

  230.         //==============================================================================

  231.         ValueTreePropertyWithDefault architectureTypeValue;

  232.     };

  233. 

  234.     BuildConfiguration::Ptr createBuildConfig (const ValueTree& tree) const override

  235.     {

  236.         return *new CodeBlocksBuildConfiguration (project, tree, *this);

  237.     }

  238. 

  239.     //==============================================================================

  240.     class CodeBlocksTarget : public build_tools::ProjectType::Target

  241.     {

  242.     public:

  243.         CodeBlocksTarget (const CodeBlocksProjectExporter& e,

  244.                           build_tools::ProjectType::Target::Type typeToUse)

  245.             : Target (typeToUse),

  246.               exporter (e)

  247.         {}

  248. 

  249.         String getTargetNameForConfiguration (const BuildConfiguration& config) const

  250.         {

  251.             if (type == build_tools::ProjectType::Target::AggregateTarget)

  252.                 return config.getName();

  253. 

  254.             return getName() + String (" | ") + config.getName();

  255.         }

  256. 

  257.         String getTargetSuffix() const

  258.         {

  259.             auto fileType = getTargetFileType();

  260. 

  261.             if (exporter.isWindows())

  262.             {

  263.                 switch (fileType)

  264.                 {

  265.                     case executable:            return ".exe";

  266.                     case staticLibrary:         return ".lib";

  267.                     case sharedLibraryOrDLL:

  268.                     case pluginBundle:          return ".dll";

  269.                     case macOSAppex:

  270.                     case unknown:

  271.                     default:

  272.                         break;

  273.                 }

  274.             }

  275.             else

  276.             {

  277.                 switch (fileType)

  278.                 {

  279.                     case executable:            return {};

  280.                     case staticLibrary:         return ".a";

  281.                     case pluginBundle:

  282.                     case sharedLibraryOrDLL:    return ".so";

  283.                     case macOSAppex:

  284.                     case unknown:

  285.                     default:

  286.                         break;

  287.                 }

  288.             }

  289. 

  290.             return {};

  291.         }

  292. 

  293.         bool isDynamicLibrary() const

  294.         {

  295.             return (type == DynamicLibrary || type == VSTPlugIn);

  296.         }

  297. 

  298.         const CodeBlocksProjectExporter& exporter;

  299.     };

  300. 

  301.     //==============================================================================

  302.     void addVersion (XmlElement& xml) const

  303.     {

  304.         auto* fileVersion = xml.createNewChildElement ("FileVersion");

  305.         fileVersion->setAttribute ("major", 1);

  306.         fileVersion->setAttribute ("minor", 6);

  307.     }

  308. 

  309.     void addOptions (XmlElement& xml) const

  310.     {

  311.         xml.createNewChildElement ("Option")->setAttribute ("title", project.getProjectNameString());

  312.         xml.createNewChildElement ("Option")->setAttribute ("pch_mode", 2);

  313.         xml.createNewChildElement ("Option")->setAttribute ("compiler", "gcc");

  314.     }

  315. 

  316.     StringArray getDefines (const BuildConfiguration& config, CodeBlocksTarget& target) const

  317.     {

  318.         StringPairArray defines;

  319. 

  320.         if (isWindows())

  321.         {

  322.             defines.set ("__MINGW__", "1");

  323.             defines.set ("__MINGW_EXTENSION", {});

  324. 

  325.             auto targetPlatform = getTargetPlatformString();

  326. 

  327.             if (targetPlatform.isNotEmpty())

  328.                 defines.set ("WINVER", targetPlatform);

  329.         }

  330.         else

  331.         {

  332.             defines.set ("LINUX", "1");

  333.         }

  334. 

  335.         if (config.isDebug())

  336.         {

  337.             defines.set ("DEBUG", "1");

  338.             defines.set ("_DEBUG", "1");

  339.         }

  340.         else

  341.         {

  342.             defines.set ("NDEBUG", "1");

  343.         }

  344. 

  345.         defines = mergePreprocessorDefs (defines, getAllPreprocessorDefs (config, target.type));

  346. 

  347.         StringArray defs;

  348.         auto keys = defines.getAllKeys();

  349.         auto values = defines.getAllValues();

  350. 

  351.         const auto escapedQuote = isWindows() ? "\\\"" : "\\\\\"";

  352. 

  353.         for (int i = 0; i < defines.size(); ++i)

  354.         {

  355.             auto result = keys[i];

  356. 

  357.             if (values[i].isNotEmpty())

  358.                 result += "=\"" + values[i].replace ("\"", escapedQuote) + "\"";

  359. 

  360.             defs.add (result);

  361.         }

  362. 

  363.         return getCleanedStringArray (defs);

  364.     }

  365. 

  366.     StringArray getCompilerFlags (const BuildConfiguration& config, CodeBlocksTarget& target) const

  367.     {

  368.         StringArray flags;

  369. 

  370.         if (auto* codeBlocksConfig = dynamic_cast<const CodeBlocksBuildConfiguration*> (&config))

  371.             flags.add (codeBlocksConfig->getArchitectureTypeString());

  372. 

  373.         auto recommendedFlags = config.getRecommendedCompilerWarningFlags();

  374. 

  375.         for (auto& recommendedFlagsType : { recommendedFlags.common, recommendedFlags.cpp })

  376.             for (auto& recommended : recommendedFlagsType)

  377.                 flags.add (recommended);

  378. 

  379.         flags.add ("-O" + config.getGCCOptimisationFlag());

  380. 

  381.         if (config.isLinkTimeOptimisationEnabled())

  382.             flags.add ("-flto");

  383. 

  384.         {

  385.             auto cppStandard = config.project.getCppStandardString();

  386. 

  387.             if (cppStandard == "latest")

  388.                 cppStandard = project.getLatestNumberedCppStandardString();

  389. 

  390.             flags.add ("-std=" + String (shouldUseGNUExtensions() ? "gnu++" : "c++") + cppStandard);

  391.         }

  392. 

  393.         flags.add ("-mstackrealign");

  394. 

  395.         if (config.isDebug())

  396.             flags.add ("-g");

  397. 

  398.         flags.addTokens (replacePreprocessorTokens (config, getExtraCompilerFlagsString()).trim(),

  399.                          " \n", "\"'");

  400. 

  401.         if (config.exporter.isLinux())

  402.         {

  403.             if (target.isDynamicLibrary() || getProject().isAudioPluginProject())

  404.                 flags.add ("-fPIC");

  405. 

  406.             auto packages = config.exporter.getLinuxPackages (PackageDependencyType::compile);

  407. 

  408.             if (! packages.isEmpty())

  409.             {

  410.                 auto pkgconfigFlags = String ("`pkg-config --cflags");

  411. 

  412.                 for (auto& p : packages)

  413.                     pkgconfigFlags << " " << p;

  414. 

  415.                 pkgconfigFlags << "`";

  416.                 flags.add (pkgconfigFlags);

  417.             }

  418. 

  419.             if (linuxLibs.contains ("pthread"))

  420.                 flags.add ("-pthread");

  421.         }

  422. 

  423.         return getCleanedStringArray (flags);

  424.     }

  425. 

  426.     StringArray getLinkerFlags (const BuildConfiguration& config, CodeBlocksTarget& target) const

  427.     {

  428.         auto flags = makefileExtraLinkerFlags;

  429. 

  430.         if (auto* codeBlocksConfig = dynamic_cast<const CodeBlocksBuildConfiguration*> (&config))

  431.             flags.add (codeBlocksConfig->getArchitectureTypeString());

  432. 

  433.         if (! config.isDebug())

  434.             flags.add ("-s");

  435. 

  436.         if (config.isLinkTimeOptimisationEnabled())

  437.             flags.add ("-flto");

  438. 

  439.         flags.addTokens (replacePreprocessorTokens (config, getExtraLinkerFlagsString()).trim(), " \n", "\"'");

  440. 

  441.         if (config.exporter.isLinux())

  442.         {

  443.             if (target.isDynamicLibrary())

  444.                 flags.add ("-shared");

  445. 

  446.             auto packages = config.exporter.getLinuxPackages (PackageDependencyType::link);

  447. 

  448.             if (! packages.isEmpty())

  449.             {

  450.                 String pkgconfigLibs ("`pkg-config --libs");

  451. 

  452.                 for (auto& p : packages)

  453.                     pkgconfigLibs << " " << p;

  454. 

  455.                 pkgconfigLibs << "`";

  456.                 flags.add (pkgconfigLibs);

  457.             }

  458.         }

  459. 

  460.         return getCleanedStringArray (flags);

  461.     }

  462. 

  463.     StringArray getLinkerSearchPaths (const BuildConfiguration& config, CodeBlocksTarget& target) const

  464.     {

  465.         auto librarySearchPaths = config.getLibrarySearchPaths();

  466. 

  467.         if (getProject().isAudioPluginProject() && target.type != build_tools::ProjectType::Target::SharedCodeTarget)

  468.             librarySearchPaths.add (build_tools::RelativePath (getSharedCodePath (config), build_tools::RelativePath::buildTargetFolder).getParentDirectory().toUnixStyle().quoted());

  469. 

  470.         return librarySearchPaths;

  471.     }

  472. 

  473.     StringArray getIncludePaths (const BuildConfiguration& config) const

  474.     {

  475.         StringArray paths;

  476. 

  477.         paths.add (".");

  478.         paths.addArray (extraSearchPaths);

  479.         paths.addArray (config.getHeaderSearchPaths());

  480. 

  481.         if (! isWindows())

  482.         {

  483.             paths.add ("/usr/include/freetype2");

  484. 

  485.             // Replace ~ character with $(HOME) environment variable

  486.             for (auto& path : paths)

  487.                 path = path.replace ("~", "$(HOME)");

  488.         }

  489. 

  490.         return getCleanedStringArray (paths);

  491.     }

  492. 

  493.     static int getTypeIndex (const build_tools::ProjectType::Target::Type& type)

  494.     {

  495.         if (type == build_tools::ProjectType::Target::GUIApp || type == build_tools::ProjectType::Target::StandalonePlugIn)         return 0;

  496.         if (type == build_tools::ProjectType::Target::ConsoleApp)                                                                   return 1;

  497.         if (type == build_tools::ProjectType::Target::StaticLibrary || type == build_tools::ProjectType::Target::SharedCodeTarget)  return 2;

  498.         if (type == build_tools::ProjectType::Target::DynamicLibrary || type == build_tools::ProjectType::Target::VSTPlugIn)        return 3;

  499. 

  500.         return 0;

  501.     }

  502. 

  503.     String getOutputPathForTarget (CodeBlocksTarget& target, const BuildConfiguration& config) const

  504.     {

  505.         String outputPath;

  506.         if (config.getTargetBinaryRelativePathString().isNotEmpty())

  507.         {

  508.             build_tools::RelativePath binaryPath (config.getTargetBinaryRelativePathString(), build_tools::RelativePath::projectFolder);

  509.             binaryPath = binaryPath.rebased (projectFolder, getTargetFolder(), build_tools::RelativePath::buildTargetFolder);

  510.             outputPath = config.getTargetBinaryRelativePathString();

  511.         }

  512.         else

  513.         {

  514.             outputPath ="bin/" + File::createLegalFileName (config.getName().trim());

  515.         }

  516. 

  517.         return outputPath + "/" + replacePreprocessorTokens (config, config.getTargetBinaryNameString() + target.getTargetSuffix());

  518.     }

  519. 

  520.     String getSharedCodePath (const BuildConfiguration& config) const

  521.     {

  522.         auto outputPath = getOutputPathForTarget (getTargetWithType (build_tools::ProjectType::Target::SharedCodeTarget), config);

  523.         build_tools::RelativePath path (outputPath, build_tools::RelativePath::buildTargetFolder);

  524.         auto filename = path.getFileName();

  525. 

  526.         if (isLinux())

  527.             filename = "lib" + filename;

  528. 

  529.         return path.getParentDirectory().getChildFile (filename).toUnixStyle();

  530.     }

  531. 

  532.     void createBuildTarget (XmlElement& xml, CodeBlocksTarget& target, const BuildConfiguration& config) const

  533.     {

  534.         xml.setAttribute ("title", target.getTargetNameForConfiguration (config));

  535. 

  536.         {

  537.             auto* output = xml.createNewChildElement ("Option");

  538. 

  539.             output->setAttribute ("output", getOutputPathForTarget (target, config));

  540. 

  541.             if (isLinux())

  542.             {

  543.                 bool keepPrefix = (target.type == build_tools::ProjectType::Target::VSTPlugIn);

  544. 

  545.                 output->setAttribute ("prefix_auto", keepPrefix ? 0 : 1);

  546.             }

  547.             else

  548.             {

  549.                 output->setAttribute ("prefix_auto", 0);

  550.             }

  551. 

  552.             output->setAttribute ("extension_auto", 0);

  553.         }

  554. 

  555.         xml.createNewChildElement ("Option")

  556.              ->setAttribute ("object_output", "obj/" + File::createLegalFileName (config.getName().trim()));

  557. 

  558.         xml.createNewChildElement ("Option")->setAttribute ("type", getTypeIndex (target.type));

  559.         xml.createNewChildElement ("Option")->setAttribute ("compiler", "gcc");

  560. 

  561.         if (getProject().isAudioPluginProject() && target.type != build_tools::ProjectType::Target::SharedCodeTarget)

  562.             xml.createNewChildElement ("Option")->setAttribute ("external_deps", getSharedCodePath (config));

  563. 

  564.         {

  565.             auto* compiler = xml.createNewChildElement ("Compiler");

  566. 

  567.             {

  568.                 StringArray flags;

  569. 

  570.                 for (auto& def : getDefines (config, target))

  571.                 {

  572.                     if (! def.containsChar ('='))

  573.                         def << '=';

  574. 

  575.                     flags.add ("-D" + def);

  576.                 }

  577. 

  578.                 flags.addArray (getCompilerFlags (config, target));

  579. 

  580.                 for (auto flag : flags)

  581.                     setAddOption (*compiler, "option", flag);

  582.             }

  583. 

  584.             {

  585.                 auto includePaths = getIncludePaths (config);

  586. 

  587.                 for (auto path : includePaths)

  588.                     setAddOption (*compiler, "directory", path);

  589.             }

  590.         }

  591. 

  592.         {

  593.             auto* linker = xml.createNewChildElement ("Linker");

  594. 

  595.             if (getProject().isAudioPluginProject() && target.type != build_tools::ProjectType::Target::SharedCodeTarget)

  596.                 setAddOption (*linker, "option", getSharedCodePath (config).quoted());

  597. 

  598.             for (auto& flag : getLinkerFlags (config, target))

  599.                 setAddOption (*linker, "option", flag);

  600. 

  601.             const StringArray& libs = isWindows() ? mingwLibs : linuxLibs;

  602. 

  603.             for (auto lib : libs)

  604.                 setAddOption (*linker, "library", lib);

  605. 

  606.             for (auto& path : getLinkerSearchPaths (config, target))

  607.                 setAddOption (*linker, "directory",

  608.                               build_tools::replacePreprocessorDefs (getAllPreprocessorDefs(), path));

  609.         }

  610.     }

  611. 

  612.     void addBuild (XmlElement& xml) const

  613.     {

  614.         auto* build = xml.createNewChildElement ("Build");

  615. 

  616.         for (ConstConfigIterator config (*this); config.next();)

  617.             for (auto target : targets)

  618.                 if (target->type != build_tools::ProjectType::Target::AggregateTarget)

  619.                     createBuildTarget (*build->createNewChildElement ("Target"), *target, *config);

  620.     }

  621. 

  622.     void addVirtualTargets (XmlElement& xml) const

  623.     {

  624.         auto* virtualTargets = xml.createNewChildElement ("VirtualTargets");

  625. 

  626.         for (ConstConfigIterator config (*this); config.next();)

  627.         {

  628.             StringArray allTargets;

  629. 

  630.             for (auto target : targets)

  631.                 if (target->type != build_tools::ProjectType::Target::AggregateTarget)

  632.                     allTargets.add (target->getTargetNameForConfiguration (*config));

  633. 

  634.             for (auto target : targets)

  635.             {

  636.                 if (target->type == build_tools::ProjectType::Target::AggregateTarget)

  637.                 {

  638.                     auto* configTarget = virtualTargets->createNewChildElement ("Add");

  639. 

  640.                     configTarget->setAttribute ("alias", config->getName());

  641.                     configTarget->setAttribute ("targets", allTargets.joinIntoString (";"));

  642.                 }

  643.             }

  644.         }

  645.     }

  646. 

  647.     StringArray getProjectCompilerOptions() const

  648.     {

  649.         return { "-Wall", "-Wno-strict-aliasing", "-Wno-strict-overflow" };

  650.     }

  651. 

  652.     void addProjectCompilerOptions (XmlElement& xml) const

  653.     {

  654.         auto* compiler = xml.createNewChildElement ("Compiler");

  655. 

  656.         for (auto& option : getProjectCompilerOptions())

  657.             setAddOption (*compiler, "option", option);

  658.     }

  659. 

  660.     StringArray getProjectLinkerLibs() const

  661.     {

  662.         StringArray result;

  663. 

  664.         if (isWindows())

  665.             result.addArray ({ "gdi32", "user32", "kernel32", "comctl32" });

  666. 

  667.         result.addTokens (getExternalLibrariesString(), ";\n", "\"'");

  668. 

  669.         result = getCleanedStringArray (result);

  670. 

  671.         for (auto& option : result)

  672.             option = build_tools::replacePreprocessorDefs (getAllPreprocessorDefs(), option);

  673. 

  674.         return result;

  675.     }

  676. 

  677.     void addProjectLinkerOptions (XmlElement& xml) const

  678.     {

  679.         auto* linker = xml.createNewChildElement ("Linker");

  680. 

  681.         for (auto& lib : getProjectLinkerLibs())

  682.             setAddOption (*linker, "library", lib);

  683.     }

  684. 

  685.     CodeBlocksTarget& getTargetWithType (build_tools::ProjectType::Target::Type type) const

  686.     {

  687.         CodeBlocksTarget* nonAggregrateTarget = nullptr;

  688. 

  689.         for (auto* target : targets)

  690.         {

  691.             if (target->type == type)

  692.                 return *target;

  693. 

  694.             if (target->type != build_tools::ProjectType::Target::AggregateTarget)

  695.                 nonAggregrateTarget = target;

  696.         }

  697. 

  698.         // this project has no valid targets

  699.         jassert (nonAggregrateTarget != nullptr);

  700. 

  701.         return *nonAggregrateTarget;

  702.     }

  703. 

  704.     // Returns SharedCode target for multi-target projects, otherwise it returns

  705.     // the single target

  706.     CodeBlocksTarget& getMainTarget() const

  707.     {

  708.         if (getProject().isAudioPluginProject())

  709.             return getTargetWithType (build_tools::ProjectType::Target::SharedCodeTarget);

  710. 

  711.         for (auto* target : targets)

  712.             if (target->type != build_tools::ProjectType::Target::AggregateTarget)

  713.                 return *target;

  714. 

  715.         jassertfalse;

  716. 

  717.         return *targets[0];

  718.     }

  719. 

  720.     CodeBlocksTarget& getTargetForProjectItem (const Project::Item& projectItem) const

  721.     {

  722.         if (getProject().isAudioPluginProject())

  723.         {

  724.             if (! projectItem.shouldBeCompiled())

  725.                 return getTargetWithType (build_tools::ProjectType::Target::SharedCodeTarget);

  726. 

  727.             return getTargetWithType (getProject().getTargetTypeFromFilePath (projectItem.getFile(), true));

  728.         }

  729. 

  730.         return getMainTarget();

  731.     }

  732. 

  733.     void addCompileUnits (const Project::Item& projectItem, XmlElement& xml) const

  734.     {

  735.         if (projectItem.isGroup())

  736.         {

  737.             for (int i = 0; i < projectItem.getNumChildren(); ++i)

  738.                 addCompileUnits (projectItem.getChild(i), xml);

  739.         }

  740.         else if (projectItem.shouldBeAddedToTargetProject() && projectItem.shouldBeAddedToTargetExporter (*this))

  741.         {

  742.             build_tools::RelativePath file (projectItem.getFile(), getTargetFolder(), build_tools::RelativePath::buildTargetFolder);

  743. 

  744.             auto* unit = xml.createNewChildElement ("Unit");

  745.             unit->setAttribute ("filename", file.toUnixStyle());

  746. 

  747.             for (ConstConfigIterator config (*this); config.next();)

  748.             {

  749.                 auto targetName = getTargetForProjectItem (projectItem).getTargetNameForConfiguration (*config);

  750.                 unit->createNewChildElement ("Option")->setAttribute ("target", targetName);

  751.             }

  752. 

  753.             if (projectItem.shouldBeCompiled())

  754.             {

  755.                 auto extraCompilerFlags = compilerFlagSchemesMap[projectItem.getCompilerFlagSchemeString()].get().toString();

  756. 

  757.                 if (extraCompilerFlags.isNotEmpty())

  758.                 {

  759.                     auto* optionElement = unit->createNewChildElement ("Option");

  760. 

  761.                     optionElement->setAttribute ("compiler",     "gcc");

  762.                     optionElement->setAttribute ("use",          1);

  763.                     optionElement->setAttribute ("buildCommand", "$compiler $options " + extraCompilerFlags + " $includes -c $file  -o $object");

  764.                 }

  765.             }

  766.             else

  767.             {

  768.                 unit->createNewChildElement ("Option")->setAttribute ("compile", 0);

  769.                 unit->createNewChildElement ("Option")->setAttribute ("link", 0);

  770.             }

  771.         }

  772.     }

  773. 

  774.     bool hasResourceFile() const

  775.     {

  776.         return ! projectType.isStaticLibrary();

  777.     }

  778. 

  779.     void addCompileUnits (XmlElement& xml) const

  780.     {

  781.         for (int i = 0; i < getAllGroups().size(); ++i)

  782.             addCompileUnits (getAllGroups().getReference(i), xml);

  783. 

  784.         if (hasResourceFile())

  785.         {

  786.             const auto iconFile = getTargetFolder().getChildFile ("icon.ico");

  787. 

  788.             if (! build_tools::asArray (getIcons()).isEmpty())

  789.                 build_tools::writeWinIcon (getIcons(), iconFile);

  790. 

  791.             auto rcFile = getTargetFolder().getChildFile ("resources.rc");

  792.             MSVCProjectExporterBase::createRCFile (project, iconFile, rcFile);

  793. 

  794.             auto* unit = xml.createNewChildElement ("Unit");

  795.             unit->setAttribute ("filename", rcFile.getFileName());

  796.             unit->createNewChildElement ("Option")->setAttribute ("compilerVar", "WINDRES");

  797.         }

  798.     }

  799. 

  800.     void createProject (XmlElement& xml) const

  801.     {

  802.         addOptions (xml);

  803.         addBuild (xml);

  804.         addVirtualTargets (xml);

  805.         addProjectCompilerOptions (xml);

  806.         addProjectLinkerOptions (xml);

  807.         addCompileUnits (xml);

  808.     }

  809. 

  810.     void setAddOption (XmlElement& xml, const String& nm, const String& value) const

  811.     {

  812.         xml.createNewChildElement ("Add")->setAttribute (nm, value);

  813.     }

  814. 

  815.     CodeBlocksOS os;

  816. 

  817.     OwnedArray<CodeBlocksTarget> targets;

  818. 

  819.     friend class CLionProjectExporter;

  820. 

  821.     JUCE_DECLARE_NON_COPYABLE (CodeBlocksProjectExporter)

  822. };