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

820 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.     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.     ValueWithDefault 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.         ValueWithDefault 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.         for (int i = 0; i < defines.size(); ++i)

  352.         {

  353.             auto result = keys[i];

  354. 

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

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

  357. 

  358.             defs.add (result);

  359.         }

  360. 

  361.         return getCleanedStringArray (defs);

  362.     }

  363. 

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

  365.     {

  366.         StringArray flags;

  367. 

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

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

  370. 

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

  372.             flags.add (recommended);

  373. 

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

  375. 

  376.         if (config.isLinkTimeOptimisationEnabled())

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

  378. 

  379.         {

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

  381. 

  382.             if (cppStandard == "latest")

  383.                 cppStandard = "17";

  384. 

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

  386. 

  387.             flags.add (cppStandard);

  388.         }

  389. 

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

  391. 

  392.         if (config.isDebug())

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

  394. 

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

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

  397. 

  398.         if (config.exporter.isLinux())

  399.         {

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

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

  402. 

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

  404. 

  405.             if (! packages.isEmpty())

  406.             {

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

  408. 

  409.                 for (auto& p : packages)

  410.                     pkgconfigFlags << " " << p;

  411. 

  412.                 pkgconfigFlags << "`";

  413.                 flags.add (pkgconfigFlags);

  414.             }

  415. 

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

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

  418.         }

  419. 

  420.         return getCleanedStringArray (flags);

  421.     }

  422. 

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

  424.     {

  425.         auto flags = makefileExtraLinkerFlags;

  426. 

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

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

  429. 

  430.         if (! config.isDebug())

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

  432. 

  433.         if (config.isLinkTimeOptimisationEnabled())

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

  435. 

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

  437. 

  438.         if (config.exporter.isLinux())

  439.         {

  440.             if (target.isDynamicLibrary())

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

  442. 

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

  444. 

  445.             if (! packages.isEmpty())

  446.             {

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

  448. 

  449.                 for (auto& p : packages)

  450.                     pkgconfigLibs << " " << p;

  451. 

  452.                 pkgconfigLibs << "`";

  453.                 flags.add (pkgconfigLibs);

  454.             }

  455.         }

  456. 

  457.         return getCleanedStringArray (flags);

  458.     }

  459. 

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

  461.     {

  462.         auto librarySearchPaths = config.getLibrarySearchPaths();

  463. 

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

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

  466. 

  467.         return librarySearchPaths;

  468.     }

  469. 

  470.     StringArray getIncludePaths (const BuildConfiguration& config) const

  471.     {

  472.         StringArray paths;

  473. 

  474.         paths.add (".");

  475.         paths.addArray (extraSearchPaths);

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

  477. 

  478.         if (! isWindows())

  479.         {

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

  481. 

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

  483.             for (auto& path : paths)

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

  485.         }

  486. 

  487.         return getCleanedStringArray (paths);

  488.     }

  489. 

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

  491.     {

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

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

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

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

  496. 

  497.         return 0;

  498.     }

  499. 

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

  501.     {

  502.         String outputPath;

  503.         if (config.getTargetBinaryRelativePathString().isNotEmpty())

  504.         {

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

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

  507.             outputPath = config.getTargetBinaryRelativePathString();

  508.         }

  509.         else

  510.         {

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

  512.         }

  513. 

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

  515.     }

  516. 

  517.     String getSharedCodePath (const BuildConfiguration& config) const

  518.     {

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

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

  521.         auto filename = path.getFileName();

  522. 

  523.         if (isLinux())

  524.             filename = "lib" + filename;

  525. 

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

  527.     }

  528. 

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

  530.     {

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

  532. 

  533.         {

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

  535. 

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

  537. 

  538.             if (isLinux())

  539.             {

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

  541. 

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

  543.             }

  544.             else

  545.             {

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

  547.             }

  548. 

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

  550.         }

  551. 

  552.         xml.createNewChildElement ("Option")

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

  554. 

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

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

  557. 

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

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

  560. 

  561.         {

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

  563. 

  564.             {

  565.                 StringArray flags;

  566. 

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

  568.                 {

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

  570.                             def << '=';

  571. 

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

  573.                 }

  574. 

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

  576. 

  577.                 for (auto flag : flags)

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

  579.             }

  580. 

  581.             {

  582.                 auto includePaths = getIncludePaths (config);

  583. 

  584.                 for (auto path : includePaths)

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

  586.             }

  587.         }

  588. 

  589.         {

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

  591. 

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

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

  594. 

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

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

  597. 

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

  599. 

  600.             for (auto lib : libs)

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

  602. 

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

  604.                 setAddOption (*linker, "directory",

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

  606.         }

  607.     }

  608. 

  609.     void addBuild (XmlElement& xml) const

  610.     {

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

  612. 

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

  614.             for (auto target : targets)

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

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

  617.     }

  618. 

  619.     void addVirtualTargets (XmlElement& xml) const

  620.     {

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

  622. 

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

  624.         {

  625.             StringArray allTargets;

  626. 

  627.             for (auto target : targets)

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

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

  630. 

  631.             for (auto target : targets)

  632.             {

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

  634.                 {

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

  636. 

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

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

  639.                 }

  640.             }

  641.         }

  642.     }

  643. 

  644.     StringArray getProjectCompilerOptions() const

  645.     {

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

  647.     }

  648. 

  649.     void addProjectCompilerOptions (XmlElement& xml) const

  650.     {

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

  652. 

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

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

  655.     }

  656. 

  657.     StringArray getProjectLinkerLibs() const

  658.     {

  659.         StringArray result;

  660. 

  661.         if (isWindows())

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

  663. 

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

  665. 

  666.         result = getCleanedStringArray (result);

  667. 

  668.         for (auto& option : result)

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

  670. 

  671.         return result;

  672.     }

  673. 

  674.     void addProjectLinkerOptions (XmlElement& xml) const

  675.     {

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

  677. 

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

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

  680.     }

  681. 

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

  683.     {

  684.         CodeBlocksTarget* nonAggregrateTarget = nullptr;

  685. 

  686.         for (auto* target : targets)

  687.         {

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

  689.                 return *target;

  690. 

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

  692.                 nonAggregrateTarget = target;

  693.         }

  694. 

  695.         // this project has no valid targets

  696.         jassert (nonAggregrateTarget != nullptr);

  697. 

  698.         return *nonAggregrateTarget;

  699.     }

  700. 

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

  702.     // the single target

  703.     CodeBlocksTarget& getMainTarget() const

  704.     {

  705.         if (getProject().isAudioPluginProject())

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

  707. 

  708.         for (auto* target : targets)

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

  710.                 return *target;

  711. 

  712.         jassertfalse;

  713. 

  714.         return *targets[0];

  715.     }

  716. 

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

  718.     {

  719.         if (getProject().isAudioPluginProject())

  720.         {

  721.             if (! projectItem.shouldBeCompiled())

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

  723. 

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

  725.         }

  726. 

  727.         return getMainTarget();

  728.     }

  729. 

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

  731.     {

  732.         if (projectItem.isGroup())

  733.         {

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

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

  736.         }

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

  738.         {

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

  740. 

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

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

  743. 

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

  745.             {

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

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

  748.             }

  749. 

  750.             if (projectItem.shouldBeCompiled())

  751.             {

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

  753. 

  754.                 if (extraCompilerFlags.isNotEmpty())

  755.                 {

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

  757. 

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

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

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

  761.                 }

  762.             }

  763.             else

  764.             {

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

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

  767.             }

  768.         }

  769.     }

  770. 

  771.     bool hasResourceFile() const

  772.     {

  773.         return ! projectType.isStaticLibrary();

  774.     }

  775. 

  776.     void addCompileUnits (XmlElement& xml) const

  777.     {

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

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

  780. 

  781.         if (hasResourceFile())

  782.         {

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

  784. 

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

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

  787. 

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

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

  790. 

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

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

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

  794.         }

  795.     }

  796. 

  797.     void createProject (XmlElement& xml) const

  798.     {

  799.         addOptions (xml);

  800.         addBuild (xml);

  801.         addVirtualTargets (xml);

  802.         addProjectCompilerOptions (xml);

  803.         addProjectLinkerOptions (xml);

  804.         addCompileUnits (xml);

  805.     }

  806. 

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

  808.     {

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

  810.     }

  811. 

  812.     CodeBlocksOS os;

  813. 

  814.     OwnedArray<CodeBlocksTarget> targets;

  815. 

  816.     friend class CLionProjectExporter;

  817. 

  818.     JUCE_DECLARE_NON_COPYABLE (CodeBlocksProjectExporter)

  819. };