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.
10942 Commits
9 Branches
4.5GB
Tree: cf93f79cc8
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'cf93f79cc8'
${ noResults }
JUCE/extras/Projucer/Source/ProjectSaving/jucer_ProjectExport_CodeBlo...

841 lines
32KB
Raw Blame History 

  1. /*

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

  3. 

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

  5.    Copyright (c) 2017 - ROLI Ltd.

  6. 

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

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

  9. 

  10.    For this technical preview, this file is not subject to commercial licensing.

  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 const char* getNameWindows() noexcept    { return "Code::Blocks (Windows)"; }

  35.     static const char* getNameLinux() noexcept      { return "Code::Blocks (Linux)"; }

  36. 

  37.     static const char* getName (CodeBlocksOS os) noexcept

  38.     {

  39.         if (os == windowsTarget) return getNameWindows();

  40.         if (os == linuxTarget)   return getNameLinux();

  41. 

  42.         // currently no other OSes supported by Codeblocks exporter!

  43.         jassertfalse;

  44.         return "Code::Blocks (Unknown OS)";

  45.     }

  46. 

  47.     //==============================================================================

  48.     static const char* getValueTreeTypeName (CodeBlocksOS os)

  49.     {

  50.         if (os == windowsTarget)  return "CODEBLOCKS_WINDOWS";

  51.         if (os == linuxTarget)    return "CODEBLOCKS_LINUX";

  52. 

  53.         // currently no other OSes supported by Codeblocks exporter!

  54.         jassertfalse;

  55.         return "CODEBLOCKS_UNKNOWN_OS";

  56.     }

  57. 

  58.     //==============================================================================

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

  60.     {

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

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

  63.         if (settingsToUse.hasType (getValueTreeTypeName (windowsTarget)) || settingsToUse.hasType ("CODEBLOCKS"))

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

  65. 

  66.         if (settingsToUse.hasType (getValueTreeTypeName (linuxTarget)))

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

  68. 

  69.         return nullptr;

  70.     }

  71. 

  72.     //==============================================================================

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

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

  75.     {

  76.         name = getName (os);

  77. 

  78.         targetLocationValue.setDefault (getDefaultBuildsRootFolder() + getTargetFolderForExporter (getValueTreeTypeName (os)));

  79. 

  80.         if (isWindows())

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

  82.     }

  83. 

  84.     //==============================================================================

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

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

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

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

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

  90. 

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

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

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

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

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

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

  97. 

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

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

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

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

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

  103. 

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

  105.     {

  106.         switch (type)

  107.         {

  108.             case build_tools::ProjectType::Target::StandalonePlugIn:

  109.             case build_tools::ProjectType::Target::GUIApp:

  110.             case build_tools::ProjectType::Target::ConsoleApp:

  111.             case build_tools::ProjectType::Target::StaticLibrary:

  112.             case build_tools::ProjectType::Target::SharedCodeTarget:

  113.             case build_tools::ProjectType::Target::AggregateTarget:

  114.             case build_tools::ProjectType::Target::VSTPlugIn:

  115.             case build_tools::ProjectType::Target::DynamicLibrary:

  116.                 return true;

  117.             case build_tools::ProjectType::Target::AAXPlugIn:

  118.             case build_tools::ProjectType::Target::RTASPlugIn:

  119.             case build_tools::ProjectType::Target::UnityPlugIn:

  120.             case build_tools::ProjectType::Target::VST3PlugIn:

  121.             case build_tools::ProjectType::Target::AudioUnitPlugIn:

  122.             case build_tools::ProjectType::Target::AudioUnitv3PlugIn:

  123.             case build_tools::ProjectType::Target::unspecified:

  124.             default:

  125.                 break;

  126.         }

  127. 

  128.         return false;

  129.     }

  130. 

  131.     void createExporterProperties (PropertyListBuilder& props) override

  132.     {

  133.         if (isWindows())

  134.         {

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

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

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

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

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

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

  141.         }

  142.     }

  143. 

  144.     //==============================================================================

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

  146.     {

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

  148.                                         .withFileExtension (".cbp");

  149. 

  150.         XmlElement xml ("CodeBlocks_project_file");

  151.         addVersion (xml);

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

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

  154.     }

  155. 

  156.     //==============================================================================

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

  158.     {

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

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

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

  162. 

  163.         //resource::ProjectType::Target::SharedCodeTarget

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

  165.                                     {

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

  167.                                             return;

  168. 

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

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

  171.                                     });

  172. 

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

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

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

  176.     }

  177. 

  178.     void initialiseDependencyPathValues() override

  179.     {

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

  181. 

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

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

  184.     }

  185. 

  186. private:

  187.     ValueWithDefault targetPlatformValue;

  188. 

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

  190. 

  191.     //==============================================================================

  192.     class CodeBlocksBuildConfiguration  : public BuildConfiguration

  193.     {

  194.     public:

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

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

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

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

  199.         {

  200.             linkTimeOptimisationValue.setDefault (false);

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

  202.         }

  203. 

  204.         void createConfigProperties (PropertyListBuilder& props) override

  205.         {

  206.             addRecommendedLinuxCompilerWarningsProperty (props);

  207.             addGCCOptimisationProperty (props);

  208. 

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

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

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

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

  213.         }

  214. 

  215.         String getModuleLibraryArchName() const override

  216.         {

  217.             auto archFlag = getArchitectureTypeString();

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

  219. 

  220.             if (archFlag.startsWith (prefix))

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

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

  223.                 return "x86_64";

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

  225.                 return "i386";

  226. 

  227.             jassertfalse;

  228.             return {};

  229.         }

  230. 

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

  232. 

  233.         //==============================================================================

  234.         ValueWithDefault architectureTypeValue;

  235.     };

  236. 

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

  238.     {

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

  240.     }

  241. 

  242.     //==============================================================================

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

  244.     {

  245.     public:

  246.         CodeBlocksTarget (const CodeBlocksProjectExporter& e,

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

  248.             : Target (typeToUse),

  249.               exporter (e)

  250.         {}

  251. 

  252.         String getTargetNameForConfiguration (const BuildConfiguration& config) const

  253.         {

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

  255.                 return config.getName();

  256. 

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

  258.         }

  259. 

  260.         String getTargetSuffix() const

  261.         {

  262.             auto fileType = getTargetFileType();

  263. 

  264.             if (exporter.isWindows())

  265.             {

  266.                 switch (fileType)

  267.                 {

  268.                     case executable:            return ".exe";

  269.                     case staticLibrary:         return ".lib";

  270.                     case sharedLibraryOrDLL:

  271.                     case pluginBundle:          return ".dll";

  272.                     case macOSAppex:

  273.                     case unknown:

  274.                     default:

  275.                         break;

  276.                 }

  277.             }

  278.             else

  279.             {

  280.                 switch (fileType)

  281.                 {

  282.                     case executable:            return {};

  283.                     case staticLibrary:         return ".a";

  284.                     case pluginBundle:

  285.                     case sharedLibraryOrDLL:    return ".so";

  286.                     case macOSAppex:

  287.                     case unknown:

  288.                     default:

  289.                         break;

  290.                 }

  291.             }

  292. 

  293.             return {};

  294.         }

  295. 

  296.         bool isDynamicLibrary() const

  297.         {

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

  299.         }

  300. 

  301.         const CodeBlocksProjectExporter& exporter;

  302.     };

  303. 

  304.     //==============================================================================

  305. 

  306.     StringArray getPackages() const

  307.     {

  308.         auto result = linuxPackages;

  309. 

  310.         if (project.getEnabledModules().isModuleEnabled ("juce_gui_extra")

  311.             && project.isConfigFlagEnabled ("JUCE_WEB_BROWSER", true))

  312.         {

  313.             result.add ("webkit2gtk-4.0");

  314.             result.add ("gtk+-x11-3.0");

  315.         }

  316. 

  317.         if (project.getEnabledModules().isModuleEnabled ("juce_core")

  318.             && project.isConfigFlagEnabled ("JUCE_USE_CURL", true)

  319.             && ! project.isConfigFlagEnabled ("JUCE_LOAD_CURL_SYMBOLS_LAZILY", false))

  320.             result.add ("libcurl");

  321. 

  322.         result.removeDuplicates (false);

  323. 

  324.         return result;

  325.     }

  326. 

  327.     void addVersion (XmlElement& xml) const

  328.     {

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

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

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

  332.     }

  333. 

  334.     void addOptions (XmlElement& xml) const

  335.     {

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

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

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

  339.     }

  340. 

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

  342.     {

  343.         StringPairArray defines;

  344. 

  345.         if (isWindows())

  346.         {

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

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

  349. 

  350.             auto targetPlatform = getTargetPlatformString();

  351. 

  352.             if (targetPlatform.isNotEmpty())

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

  354.         }

  355.         else

  356.         {

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

  358.         }

  359. 

  360.         if (config.isDebug())

  361.         {

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

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

  364.         }

  365.         else

  366.         {

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

  368.         }

  369. 

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

  371. 

  372.         StringArray defs;

  373.         auto keys = defines.getAllKeys();

  374.         auto values = defines.getAllValues();

  375. 

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

  377.         {

  378.             auto result = keys[i];

  379. 

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

  381.                 result += "=" + values[i];

  382. 

  383.             defs.add (result);

  384.         }

  385. 

  386.         return getCleanedStringArray (defs);

  387.     }

  388. 

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

  390.     {

  391.         StringArray flags;

  392. 

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

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

  395. 

  396.         for (auto& recommended : config.getRecommendedCompilerWarningFlags())

  397.             flags.add (recommended);

  398. 

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

  400. 

  401.         if (config.isLinkTimeOptimisationEnabled())

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

  403. 

  404.         {

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

  406. 

  407.             if (cppStandard == "latest")

  408.                 cppStandard = "17";

  409. 

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

  411. 

  412.             flags.add (cppStandard);

  413.         }

  414. 

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

  416. 

  417.         if (config.isDebug())

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

  419. 

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

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

  422. 

  423.         if (config.exporter.isLinux())

  424.         {

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

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

  427. 

  428.             auto packages = getPackages();

  429. 

  430.             if (packages.size() > 0)

  431.             {

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

  433.                 for (auto p : packages)

  434.                     pkgconfigFlags << " " << p;

  435. 

  436.                 pkgconfigFlags << "`";

  437.                 flags.add (pkgconfigFlags);

  438.             }

  439. 

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

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

  442.         }

  443. 

  444.         return getCleanedStringArray (flags);

  445.     }

  446. 

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

  448.     {

  449.         auto flags = makefileExtraLinkerFlags;

  450. 

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

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

  453. 

  454.         if (! config.isDebug())

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

  456. 

  457.         if (config.isLinkTimeOptimisationEnabled())

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

  459. 

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

  461. 

  462.         auto packages = getPackages();

  463. 

  464.         if (config.exporter.isLinux())

  465.         {

  466.             if (target.isDynamicLibrary())

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

  468. 

  469.             if (packages.size() > 0)

  470.             {

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

  472. 

  473.                 for (auto& p : packages)

  474.                     pkgconfigLibs << " " << p;

  475. 

  476.                 pkgconfigLibs << "`";

  477.                 flags.add (pkgconfigLibs);

  478.             }

  479.         }

  480. 

  481.         return getCleanedStringArray (flags);

  482.     }

  483. 

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

  485.     {

  486.         auto librarySearchPaths = config.getLibrarySearchPaths();

  487. 

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

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

  490. 

  491.         return librarySearchPaths;

  492.     }

  493. 

  494.     StringArray getIncludePaths (const BuildConfiguration& config) const

  495.     {

  496.         StringArray paths;

  497. 

  498.         paths.add (".");

  499.         paths.addArray (extraSearchPaths);

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

  501. 

  502.         if (! isWindows())

  503.         {

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

  505. 

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

  507.             for (auto& path : paths)

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

  509.         }

  510. 

  511.         return getCleanedStringArray (paths);

  512.     }

  513. 

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

  515.     {

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

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

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

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

  520. 

  521.         return 0;

  522.     }

  523. 

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

  525.     {

  526.         String outputPath;

  527.         if (config.getTargetBinaryRelativePathString().isNotEmpty())

  528.         {

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

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

  531.             outputPath = config.getTargetBinaryRelativePathString();

  532.         }

  533.         else

  534.         {

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

  536.         }

  537. 

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

  539.     }

  540. 

  541.     String getSharedCodePath (const BuildConfiguration& config) const

  542.     {

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

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

  545.         auto filename = path.getFileName();

  546. 

  547.         if (isLinux())

  548.             filename = "lib" + filename;

  549. 

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

  551.     }

  552. 

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

  554.     {

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

  556. 

  557.         {

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

  559. 

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

  561. 

  562.             if (isLinux())

  563.             {

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

  565. 

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

  567.             }

  568.             else

  569.             {

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

  571.             }

  572. 

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

  574.         }

  575. 

  576.         xml.createNewChildElement ("Option")

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

  578. 

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

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

  581. 

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

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

  584. 

  585.         {

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

  587. 

  588.             {

  589.                 StringArray flags;

  590. 

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

  592.                 {

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

  594.                             def << '=';

  595. 

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

  597.                 }

  598. 

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

  600. 

  601.                 for (auto flag : flags)

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

  603.             }

  604. 

  605.             {

  606.                 auto includePaths = getIncludePaths (config);

  607. 

  608.                 for (auto path : includePaths)

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

  610.             }

  611.         }

  612. 

  613.         {

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

  615. 

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

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

  618. 

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

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

  621. 

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

  623. 

  624.             for (auto lib : libs)

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

  626. 

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

  628.                 setAddOption (*linker, "directory",

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

  630.         }

  631.     }

  632. 

  633.     void addBuild (XmlElement& xml) const

  634.     {

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

  636. 

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

  638.             for (auto target : targets)

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

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

  641.     }

  642. 

  643.     void addVirtualTargets (XmlElement& xml) const

  644.     {

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

  646. 

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

  648.         {

  649.             StringArray allTargets;

  650. 

  651.             for (auto target : targets)

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

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

  654. 

  655.             for (auto target : targets)

  656.             {

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

  658.                 {

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

  660. 

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

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

  663.                 }

  664.             }

  665.         }

  666.     }

  667. 

  668.     StringArray getProjectCompilerOptions() const

  669.     {

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

  671.     }

  672. 

  673.     void addProjectCompilerOptions (XmlElement& xml) const

  674.     {

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

  676. 

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

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

  679.     }

  680. 

  681.     StringArray getProjectLinkerLibs() const

  682.     {

  683.         StringArray result;

  684. 

  685.         if (isWindows())

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

  687. 

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

  689. 

  690.         result = getCleanedStringArray (result);

  691. 

  692.         for (auto& option : result)

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

  694. 

  695.         return result;

  696.     }

  697. 

  698.     void addProjectLinkerOptions (XmlElement& xml) const

  699.     {

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

  701. 

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

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

  704.     }

  705. 

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

  707.     {

  708.         CodeBlocksTarget* nonAggregrateTarget = nullptr;

  709. 

  710.         for (auto* target : targets)

  711.         {

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

  713.                 return *target;

  714. 

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

  716.                 nonAggregrateTarget = target;

  717.         }

  718. 

  719.         // this project has no valid targets

  720.         jassert (nonAggregrateTarget != nullptr);

  721. 

  722.         return *nonAggregrateTarget;

  723.     }

  724. 

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

  726.     // the single target

  727.     CodeBlocksTarget& getMainTarget() const

  728.     {

  729.         if (getProject().isAudioPluginProject())

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

  731. 

  732.         for (auto* target : targets)

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

  734.                 return *target;

  735. 

  736.         jassertfalse;

  737. 

  738.         return *targets[0];

  739.     }

  740. 

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

  742.     {

  743.         if (getProject().isAudioPluginProject())

  744.         {

  745.             if (! projectItem.shouldBeCompiled())

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

  747. 

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

  749.         }

  750. 

  751.         return getMainTarget();

  752.     }

  753. 

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

  755.     {

  756.         if (projectItem.isGroup())

  757.         {

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

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

  760.         }

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

  762.         {

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

  764. 

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

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

  767. 

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

  769.             {

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

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

  772.             }

  773. 

  774.             if (projectItem.shouldBeCompiled())

  775.             {

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

  777. 

  778.                 if (extraCompilerFlags.isNotEmpty())

  779.                 {

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

  781. 

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

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

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

  785.                 }

  786.             }

  787.             else

  788.             {

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

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

  791.             }

  792.         }

  793.     }

  794. 

  795.     bool hasResourceFile() const

  796.     {

  797.         return ! projectType.isStaticLibrary();

  798.     }

  799. 

  800.     void addCompileUnits (XmlElement& xml) const

  801.     {

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

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

  804. 

  805.         if (hasResourceFile())

  806.         {

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

  808.             build_tools::writeMacIcon (getIcons(), iconFile);

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

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

  811. 

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

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

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

  815.         }

  816.     }

  817. 

  818.     void createProject (XmlElement& xml) const

  819.     {

  820.         addOptions (xml);

  821.         addBuild (xml);

  822.         addVirtualTargets (xml);

  823.         addProjectCompilerOptions (xml);

  824.         addProjectLinkerOptions (xml);

  825.         addCompileUnits (xml);

  826.     }

  827. 

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

  829.     {

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

  831.     }

  832. 

  833.     CodeBlocksOS os;

  834. 

  835.     OwnedArray<CodeBlocksTarget> targets;

  836. 

  837.     friend class CLionProjectExporter;

  838. 

  839.     JUCE_DECLARE_NON_COPYABLE (CodeBlocksProjectExporter)

  840. };