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

824 lines
31KB
Raw Blame History 

  1. /*

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

  3. 

  4.    This file is part of the JUCE library.

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

  6. 

  7.    JUCE is an open source library subject to commercial or open-source

  8.    licensing.

  9. 

  10.    By using JUCE, you agree to the terms of both the JUCE 6 End-User License

  11.    Agreement and JUCE Privacy Policy (both effective as of the 16th June 2020).

  12. 

  13.    End User License Agreement: www.juce.com/juce-6-licence

  14.    Privacy Policy: www.juce.com/juce-privacy-policy

  15. 

  16.    Or: You may also use this code under the terms of the GPL v3 (see

  17.    www.gnu.org/licenses).

  18. 

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

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

  21.    DISCLAIMED.

  22. 

  23.   ==============================================================================

  24. */

  25. 

  26. #pragma once

  27. 

  28. #include "jucer_ProjectExport_MSVC.h"

  29. 

  30. //==============================================================================

  31. class CodeBlocksProjectExporter  : public ProjectExporter

  32. {

  33. public:

  34.     enum CodeBlocksOS

  35.     {

  36.         windowsTarget,

  37.         linuxTarget

  38.     };

  39. 

  40.     //==============================================================================

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

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

  43. 

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

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

  46. 

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

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

  49. 

  50.     //==============================================================================

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

  52.     {

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

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

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

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

  57. 

  58.         if (settingsToUse.hasType (getValueTreeTypeNameLinux()))

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

  60. 

  61.         return nullptr;

  62.     }

  63. 

  64.     //==============================================================================

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

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

  67.     {

  68.         if (isWindows())

  69.         {

  70.             name = getDisplayNameWindows();

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

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

  73.         }

  74.         else

  75.         {

  76.             name = getDisplayNameLinux();

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

  78.         }

  79.     }

  80. 

  81.     //==============================================================================

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

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

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

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

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

  87. 

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

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

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

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

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

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

  94. 

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

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

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

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

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

  100. 

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

  102. 

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

  104.     {

  105.         switch (type)

  106.         {

  107.             case build_tools::ProjectType::Target::StandalonePlugIn:

  108.             case build_tools::ProjectType::Target::GUIApp:

  109.             case build_tools::ProjectType::Target::ConsoleApp:

  110.             case build_tools::ProjectType::Target::StaticLibrary:

  111.             case build_tools::ProjectType::Target::SharedCodeTarget:

  112.             case build_tools::ProjectType::Target::AggregateTarget:

  113.             case build_tools::ProjectType::Target::VSTPlugIn:

  114.             case build_tools::ProjectType::Target::DynamicLibrary:

  115.                 return true;

  116.             case build_tools::ProjectType::Target::AAXPlugIn:

  117.             case build_tools::ProjectType::Target::RTASPlugIn:

  118.             case build_tools::ProjectType::Target::UnityPlugIn:

  119.             case build_tools::ProjectType::Target::VST3PlugIn:

  120.             case build_tools::ProjectType::Target::AudioUnitPlugIn:

  121.             case build_tools::ProjectType::Target::AudioUnitv3PlugIn:

  122.             case build_tools::ProjectType::Target::unspecified:

  123.             default:

  124.                 break;

  125.         }

  126. 

  127.         return false;

  128.     }

  129. 

  130.     void createExporterProperties (PropertyListBuilder& props) override

  131.     {

  132.         if (isWindows())

  133.         {

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

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

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

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

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

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

  140.         }

  141.     }

  142. 

  143.     //==============================================================================

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

  145.     {

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

  147.                                         .withFileExtension (".cbp");

  148. 

  149.         XmlElement xml ("CodeBlocks_project_file");

  150.         addVersion (xml);

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

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

  153.     }

  154. 

  155.     //==============================================================================

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

  157.     {

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

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

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

  161. 

  162.         //resource::ProjectType::Target::SharedCodeTarget

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

  164.                                     {

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

  166.                                             return;

  167. 

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

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

  170.                                     });

  171. 

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

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

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

  175.     }

  176. 

  177.     void initialiseDependencyPathValues() override

  178.     {

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

  180. 

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

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

  183.     }

  184. 

  185. private:

  186.     ValueWithDefault targetPlatformValue;

  187. 

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

  189. 

  190.     //==============================================================================

  191.     class CodeBlocksBuildConfiguration  : public BuildConfiguration

  192.     {

  193.     public:

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

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

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

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

  198.         {

  199.             linkTimeOptimisationValue.setDefault (false);

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

  201.         }

  202. 

  203.         void createConfigProperties (PropertyListBuilder& props) override

  204.         {

  205.             addRecommendedLinuxCompilerWarningsProperty (props);

  206.             addGCCOptimisationProperty (props);

  207. 

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

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

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

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

  212.         }

  213. 

  214.         String getModuleLibraryArchName() const override

  215.         {

  216.             auto archFlag = getArchitectureTypeString();

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

  218. 

  219.             if (archFlag.startsWith (prefix))

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

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

  222.                 return "x86_64";

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

  224.                 return "i386";

  225. 

  226.             jassertfalse;

  227.             return {};

  228.         }

  229. 

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

  231. 

  232.         //==============================================================================

  233.         ValueWithDefault architectureTypeValue;

  234.     };

  235. 

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

  237.     {

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

  239.     }

  240. 

  241.     //==============================================================================

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

  243.     {

  244.     public:

  245.         CodeBlocksTarget (const CodeBlocksProjectExporter& e,

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

  247.             : Target (typeToUse),

  248.               exporter (e)

  249.         {}

  250. 

  251.         String getTargetNameForConfiguration (const BuildConfiguration& config) const

  252.         {

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

  254.                 return config.getName();

  255. 

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

  257.         }

  258. 

  259.         String getTargetSuffix() const

  260.         {

  261.             auto fileType = getTargetFileType();

  262. 

  263.             if (exporter.isWindows())

  264.             {

  265.                 switch (fileType)

  266.                 {

  267.                     case executable:            return ".exe";

  268.                     case staticLibrary:         return ".lib";

  269.                     case sharedLibraryOrDLL:

  270.                     case pluginBundle:          return ".dll";

  271.                     case macOSAppex:

  272.                     case unknown:

  273.                     default:

  274.                         break;

  275.                 }

  276.             }

  277.             else

  278.             {

  279.                 switch (fileType)

  280.                 {

  281.                     case executable:            return {};

  282.                     case staticLibrary:         return ".a";

  283.                     case pluginBundle:

  284.                     case sharedLibraryOrDLL:    return ".so";

  285.                     case macOSAppex:

  286.                     case unknown:

  287.                     default:

  288.                         break;

  289.                 }

  290.             }

  291. 

  292.             return {};

  293.         }

  294. 

  295.         bool isDynamicLibrary() const

  296.         {

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

  298.         }

  299. 

  300.         const CodeBlocksProjectExporter& exporter;

  301.     };

  302. 

  303.     //==============================================================================

  304.     void addVersion (XmlElement& xml) const

  305.     {

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

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

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

  309.     }

  310. 

  311.     void addOptions (XmlElement& xml) const

  312.     {

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

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

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

  316.     }

  317. 

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

  319.     {

  320.         StringPairArray defines;

  321. 

  322.         if (isWindows())

  323.         {

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

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

  326. 

  327.             auto targetPlatform = getTargetPlatformString();

  328. 

  329.             if (targetPlatform.isNotEmpty())

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

  331.         }

  332.         else

  333.         {

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

  335.         }

  336. 

  337.         if (config.isDebug())

  338.         {

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

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

  341.         }

  342.         else

  343.         {

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

  345.         }

  346. 

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

  348. 

  349.         StringArray defs;

  350.         auto keys = defines.getAllKeys();

  351.         auto values = defines.getAllValues();

  352. 

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

  354. 

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

  356.         {

  357.             auto result = keys[i];

  358. 

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

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

  361. 

  362.             defs.add (result);

  363.         }

  364. 

  365.         return getCleanedStringArray (defs);

  366.     }

  367. 

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

  369.     {

  370.         StringArray flags;

  371. 

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

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

  374. 

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

  376.             flags.add (recommended);

  377. 

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

  379. 

  380.         if (config.isLinkTimeOptimisationEnabled())

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

  382. 

  383.         {

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

  385. 

  386.             if (cppStandard == "latest")

  387.                 cppStandard = "17";

  388. 

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

  390. 

  391.             flags.add (cppStandard);

  392.         }

  393. 

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

  395. 

  396.         if (config.isDebug())

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

  398. 

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

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

  401. 

  402.         if (config.exporter.isLinux())

  403.         {

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

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

  406. 

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

  408. 

  409.             if (! packages.isEmpty())

  410.             {

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

  412. 

  413.                 for (auto& p : packages)

  414.                     pkgconfigFlags << " " << p;

  415. 

  416.                 pkgconfigFlags << "`";

  417.                 flags.add (pkgconfigFlags);

  418.             }

  419. 

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

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

  422.         }

  423. 

  424.         return getCleanedStringArray (flags);

  425.     }

  426. 

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

  428.     {

  429.         auto flags = makefileExtraLinkerFlags;

  430. 

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

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

  433. 

  434.         if (! config.isDebug())

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

  436. 

  437.         if (config.isLinkTimeOptimisationEnabled())

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

  439. 

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

  441. 

  442.         if (config.exporter.isLinux())

  443.         {

  444.             if (target.isDynamicLibrary())

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

  446. 

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

  448. 

  449.             if (! packages.isEmpty())

  450.             {

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

  452. 

  453.                 for (auto& p : packages)

  454.                     pkgconfigLibs << " " << p;

  455. 

  456.                 pkgconfigLibs << "`";

  457.                 flags.add (pkgconfigLibs);

  458.             }

  459.         }

  460. 

  461.         return getCleanedStringArray (flags);

  462.     }

  463. 

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

  465.     {

  466.         auto librarySearchPaths = config.getLibrarySearchPaths();

  467. 

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

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

  470. 

  471.         return librarySearchPaths;

  472.     }

  473. 

  474.     StringArray getIncludePaths (const BuildConfiguration& config) const

  475.     {

  476.         StringArray paths;

  477. 

  478.         paths.add (".");

  479.         paths.addArray (extraSearchPaths);

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

  481. 

  482.         if (! isWindows())

  483.         {

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

  485. 

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

  487.             for (auto& path : paths)

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

  489.         }

  490. 

  491.         return getCleanedStringArray (paths);

  492.     }

  493. 

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

  495.     {

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

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

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

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

  500. 

  501.         return 0;

  502.     }

  503. 

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

  505.     {

  506.         String outputPath;

  507.         if (config.getTargetBinaryRelativePathString().isNotEmpty())

  508.         {

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

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

  511.             outputPath = config.getTargetBinaryRelativePathString();

  512.         }

  513.         else

  514.         {

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

  516.         }

  517. 

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

  519.     }

  520. 

  521.     String getSharedCodePath (const BuildConfiguration& config) const

  522.     {

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

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

  525.         auto filename = path.getFileName();

  526. 

  527.         if (isLinux())

  528.             filename = "lib" + filename;

  529. 

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

  531.     }

  532. 

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

  534.     {

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

  536. 

  537.         {

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

  539. 

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

  541. 

  542.             if (isLinux())

  543.             {

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

  545. 

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

  547.             }

  548.             else

  549.             {

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

  551.             }

  552. 

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

  554.         }

  555. 

  556.         xml.createNewChildElement ("Option")

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

  558. 

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

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

  561. 

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

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

  564. 

  565.         {

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

  567. 

  568.             {

  569.                 StringArray flags;

  570. 

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

  572.                 {

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

  574.                         def << '=';

  575. 

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

  577.                 }

  578. 

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

  580. 

  581.                 for (auto flag : flags)

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

  583.             }

  584. 

  585.             {

  586.                 auto includePaths = getIncludePaths (config);

  587. 

  588.                 for (auto path : includePaths)

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

  590.             }

  591.         }

  592. 

  593.         {

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

  595. 

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

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

  598. 

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

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

  601. 

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

  603. 

  604.             for (auto lib : libs)

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

  606. 

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

  608.                 setAddOption (*linker, "directory",

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

  610.         }

  611.     }

  612. 

  613.     void addBuild (XmlElement& xml) const

  614.     {

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

  616. 

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

  618.             for (auto target : targets)

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

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

  621.     }

  622. 

  623.     void addVirtualTargets (XmlElement& xml) const

  624.     {

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

  626. 

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

  628.         {

  629.             StringArray allTargets;

  630. 

  631.             for (auto target : targets)

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

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

  634. 

  635.             for (auto target : targets)

  636.             {

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

  638.                 {

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

  640. 

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

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

  643.                 }

  644.             }

  645.         }

  646.     }

  647. 

  648.     StringArray getProjectCompilerOptions() const

  649.     {

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

  651.     }

  652. 

  653.     void addProjectCompilerOptions (XmlElement& xml) const

  654.     {

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

  656. 

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

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

  659.     }

  660. 

  661.     StringArray getProjectLinkerLibs() const

  662.     {

  663.         StringArray result;

  664. 

  665.         if (isWindows())

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

  667. 

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

  669. 

  670.         result = getCleanedStringArray (result);

  671. 

  672.         for (auto& option : result)

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

  674. 

  675.         return result;

  676.     }

  677. 

  678.     void addProjectLinkerOptions (XmlElement& xml) const

  679.     {

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

  681. 

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

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

  684.     }

  685. 

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

  687.     {

  688.         CodeBlocksTarget* nonAggregrateTarget = nullptr;

  689. 

  690.         for (auto* target : targets)

  691.         {

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

  693.                 return *target;

  694. 

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

  696.                 nonAggregrateTarget = target;

  697.         }

  698. 

  699.         // this project has no valid targets

  700.         jassert (nonAggregrateTarget != nullptr);

  701. 

  702.         return *nonAggregrateTarget;

  703.     }

  704. 

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

  706.     // the single target

  707.     CodeBlocksTarget& getMainTarget() const

  708.     {

  709.         if (getProject().isAudioPluginProject())

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

  711. 

  712.         for (auto* target : targets)

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

  714.                 return *target;

  715. 

  716.         jassertfalse;

  717. 

  718.         return *targets[0];

  719.     }

  720. 

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

  722.     {

  723.         if (getProject().isAudioPluginProject())

  724.         {

  725.             if (! projectItem.shouldBeCompiled())

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

  727. 

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

  729.         }

  730. 

  731.         return getMainTarget();

  732.     }

  733. 

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

  735.     {

  736.         if (projectItem.isGroup())

  737.         {

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

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

  740.         }

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

  742.         {

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

  744. 

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

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

  747. 

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

  749.             {

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

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

  752.             }

  753. 

  754.             if (projectItem.shouldBeCompiled())

  755.             {

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

  757. 

  758.                 if (extraCompilerFlags.isNotEmpty())

  759.                 {

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

  761. 

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

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

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

  765.                 }

  766.             }

  767.             else

  768.             {

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

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

  771.             }

  772.         }

  773.     }

  774. 

  775.     bool hasResourceFile() const

  776.     {

  777.         return ! projectType.isStaticLibrary();

  778.     }

  779. 

  780.     void addCompileUnits (XmlElement& xml) const

  781.     {

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

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

  784. 

  785.         if (hasResourceFile())

  786.         {

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

  788. 

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

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

  791. 

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

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

  794. 

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

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

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

  798.         }

  799.     }

  800. 

  801.     void createProject (XmlElement& xml) const

  802.     {

  803.         addOptions (xml);

  804.         addBuild (xml);

  805.         addVirtualTargets (xml);

  806.         addProjectCompilerOptions (xml);

  807.         addProjectLinkerOptions (xml);

  808.         addCompileUnits (xml);

  809.     }

  810. 

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

  812.     {

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

  814.     }

  815. 

  816.     CodeBlocksOS os;

  817. 

  818.     OwnedArray<CodeBlocksTarget> targets;

  819. 

  820.     friend class CLionProjectExporter;

  821. 

  822.     JUCE_DECLARE_NON_COPYABLE (CodeBlocksProjectExporter)

  823. };