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

830 lines
32KB
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.     Identifier getExporterIdentifier() const override

  102.     {

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

  104.     }

  105. 

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

  107. 

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

  109.     {

  110.         switch (type)

  111.         {

  112.             case build_tools::ProjectType::Target::StandalonePlugIn:

  113.             case build_tools::ProjectType::Target::GUIApp:

  114.             case build_tools::ProjectType::Target::ConsoleApp:

  115.             case build_tools::ProjectType::Target::StaticLibrary:

  116.             case build_tools::ProjectType::Target::SharedCodeTarget:

  117.             case build_tools::ProjectType::Target::AggregateTarget:

  118.             case build_tools::ProjectType::Target::VSTPlugIn:

  119.             case build_tools::ProjectType::Target::DynamicLibrary:

  120.                 return true;

  121.             case build_tools::ProjectType::Target::AAXPlugIn:

  122.             case build_tools::ProjectType::Target::RTASPlugIn:

  123.             case build_tools::ProjectType::Target::UnityPlugIn:

  124.             case build_tools::ProjectType::Target::VST3PlugIn:

  125.             case build_tools::ProjectType::Target::AudioUnitPlugIn:

  126.             case build_tools::ProjectType::Target::AudioUnitv3PlugIn:

  127.             case build_tools::ProjectType::Target::unspecified:

  128.             default:

  129.                 break;

  130.         }

  131. 

  132.         return false;

  133.     }

  134. 

  135.     void createExporterProperties (PropertyListBuilder& props) override

  136.     {

  137.         if (isWindows())

  138.         {

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

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

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

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

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

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

  145.         }

  146.     }

  147. 

  148.     //==============================================================================

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

  150.     {

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

  152.                                         .withFileExtension (".cbp");

  153. 

  154.         XmlElement xml ("CodeBlocks_project_file");

  155.         addVersion (xml);

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

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

  158.     }

  159. 

  160.     //==============================================================================

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

  162.     {

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

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

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

  166. 

  167.         //resource::ProjectType::Target::SharedCodeTarget

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

  169.                                     {

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

  171.                                             return;

  172. 

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

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

  175.                                     });

  176. 

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

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

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

  180.     }

  181. 

  182.     void initialiseDependencyPathValues() override

  183.     {

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

  185. 

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

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

  188.     }

  189. 

  190. private:

  191.     ValueTreePropertyWithDefault targetPlatformValue;

  192. 

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

  194. 

  195.     //==============================================================================

  196.     class CodeBlocksBuildConfiguration  : public BuildConfiguration

  197.     {

  198.     public:

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

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

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

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

  203.         {

  204.             linkTimeOptimisationValue.setDefault (false);

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

  206.         }

  207. 

  208.         void createConfigProperties (PropertyListBuilder& props) override

  209.         {

  210.             addRecommendedLinuxCompilerWarningsProperty (props);

  211.             addGCCOptimisationProperty (props);

  212. 

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

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

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

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

  217.         }

  218. 

  219.         String getModuleLibraryArchName() const override

  220.         {

  221.             auto archFlag = getArchitectureTypeString();

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

  223. 

  224.             if (archFlag.startsWith (prefix))

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

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

  227.                 return "x86_64";

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

  229.                 return "i386";

  230. 

  231.             jassertfalse;

  232.             return {};

  233.         }

  234. 

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

  236. 

  237.         //==============================================================================

  238.         ValueTreePropertyWithDefault architectureTypeValue;

  239.     };

  240. 

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

  242.     {

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

  244.     }

  245. 

  246.     //==============================================================================

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

  248.     {

  249.     public:

  250.         CodeBlocksTarget (const CodeBlocksProjectExporter& e,

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

  252.             : Target (typeToUse),

  253.               exporter (e)

  254.         {}

  255. 

  256.         String getTargetNameForConfiguration (const BuildConfiguration& config) const

  257.         {

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

  259.                 return config.getName();

  260. 

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

  262.         }

  263. 

  264.         String getTargetSuffix() const

  265.         {

  266.             auto fileType = getTargetFileType();

  267. 

  268.             if (exporter.isWindows())

  269.             {

  270.                 switch (fileType)

  271.                 {

  272.                     case executable:            return ".exe";

  273.                     case staticLibrary:         return ".lib";

  274.                     case sharedLibraryOrDLL:

  275.                     case pluginBundle:          return ".dll";

  276.                     case macOSAppex:

  277.                     case unknown:

  278.                     default:

  279.                         break;

  280.                 }

  281.             }

  282.             else

  283.             {

  284.                 switch (fileType)

  285.                 {

  286.                     case executable:            return {};

  287.                     case staticLibrary:         return ".a";

  288.                     case pluginBundle:

  289.                     case sharedLibraryOrDLL:    return ".so";

  290.                     case macOSAppex:

  291.                     case unknown:

  292.                     default:

  293.                         break;

  294.                 }

  295.             }

  296. 

  297.             return {};

  298.         }

  299. 

  300.         bool isDynamicLibrary() const

  301.         {

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

  303.         }

  304. 

  305.         const CodeBlocksProjectExporter& exporter;

  306.     };

  307. 

  308.     //==============================================================================

  309.     void addVersion (XmlElement& xml) const

  310.     {

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

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

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

  314.     }

  315. 

  316.     void addOptions (XmlElement& xml) const

  317.     {

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

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

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

  321.     }

  322. 

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

  324.     {

  325.         StringPairArray defines;

  326. 

  327.         if (isWindows())

  328.         {

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

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

  331. 

  332.             auto targetPlatform = getTargetPlatformString();

  333. 

  334.             if (targetPlatform.isNotEmpty())

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

  336.         }

  337.         else

  338.         {

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

  340.         }

  341. 

  342.         if (config.isDebug())

  343.         {

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

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

  346.         }

  347.         else

  348.         {

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

  350.         }

  351. 

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

  353. 

  354.         StringArray defs;

  355.         auto keys = defines.getAllKeys();

  356.         auto values = defines.getAllValues();

  357. 

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

  359. 

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

  361.         {

  362.             auto result = keys[i];

  363. 

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

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

  366. 

  367.             defs.add (result);

  368.         }

  369. 

  370.         return getCleanedStringArray (defs);

  371.     }

  372. 

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

  374.     {

  375.         StringArray flags;

  376. 

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

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

  379. 

  380.         auto recommendedFlags = config.getRecommendedCompilerWarningFlags();

  381. 

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

  383.             for (auto& recommended : recommendedFlagsType)

  384.                 flags.add (recommended);

  385. 

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

  387. 

  388.         if (config.isLinkTimeOptimisationEnabled())

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

  390. 

  391.         {

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

  393. 

  394.             if (cppStandard == "latest")

  395.                 cppStandard = project.getLatestNumberedCppStandardString();

  396. 

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

  398.         }

  399. 

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

  401. 

  402.         if (config.isDebug())

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

  404. 

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

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

  407. 

  408.         if (config.exporter.isLinux())

  409.         {

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

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

  412. 

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

  414. 

  415.             if (! packages.isEmpty())

  416.             {

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

  418. 

  419.                 for (auto& p : packages)

  420.                     pkgconfigFlags << " " << p;

  421. 

  422.                 pkgconfigFlags << "`";

  423.                 flags.add (pkgconfigFlags);

  424.             }

  425. 

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

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

  428.         }

  429. 

  430.         return getCleanedStringArray (flags);

  431.     }

  432. 

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

  434.     {

  435.         auto flags = makefileExtraLinkerFlags;

  436. 

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

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

  439. 

  440.         if (! config.isDebug())

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

  442. 

  443.         if (config.isLinkTimeOptimisationEnabled())

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

  445. 

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

  447. 

  448.         if (config.exporter.isLinux())

  449.         {

  450.             if (target.isDynamicLibrary())

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

  452. 

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

  454. 

  455.             if (! packages.isEmpty())

  456.             {

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

  458. 

  459.                 for (auto& p : packages)

  460.                     pkgconfigLibs << " " << p;

  461. 

  462.                 pkgconfigLibs << "`";

  463.                 flags.add (pkgconfigLibs);

  464.             }

  465.         }

  466. 

  467.         return getCleanedStringArray (flags);

  468.     }

  469. 

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

  471.     {

  472.         auto librarySearchPaths = config.getLibrarySearchPaths();

  473. 

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

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

  476. 

  477.         return librarySearchPaths;

  478.     }

  479. 

  480.     StringArray getIncludePaths (const BuildConfiguration& config) const

  481.     {

  482.         StringArray paths;

  483. 

  484.         paths.add (".");

  485.         paths.addArray (extraSearchPaths);

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

  487. 

  488.         if (! isWindows())

  489.         {

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

  491. 

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

  493.             for (auto& path : paths)

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

  495.         }

  496. 

  497.         return getCleanedStringArray (paths);

  498.     }

  499. 

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

  501.     {

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

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

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

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

  506. 

  507.         return 0;

  508.     }

  509. 

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

  511.     {

  512.         String outputPath;

  513.         if (config.getTargetBinaryRelativePathString().isNotEmpty())

  514.         {

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

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

  517.             outputPath = config.getTargetBinaryRelativePathString();

  518.         }

  519.         else

  520.         {

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

  522.         }

  523. 

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

  525.     }

  526. 

  527.     String getSharedCodePath (const BuildConfiguration& config) const

  528.     {

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

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

  531.         auto filename = path.getFileName();

  532. 

  533.         if (isLinux())

  534.             filename = "lib" + filename;

  535. 

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

  537.     }

  538. 

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

  540.     {

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

  542. 

  543.         {

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

  545. 

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

  547. 

  548.             if (isLinux())

  549.             {

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

  551. 

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

  553.             }

  554.             else

  555.             {

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

  557.             }

  558. 

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

  560.         }

  561. 

  562.         xml.createNewChildElement ("Option")

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

  564. 

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

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

  567. 

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

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

  570. 

  571.         {

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

  573. 

  574.             {

  575.                 StringArray flags;

  576. 

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

  578.                 {

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

  580.                         def << '=';

  581. 

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

  583.                 }

  584. 

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

  586. 

  587.                 for (auto flag : flags)

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

  589.             }

  590. 

  591.             {

  592.                 auto includePaths = getIncludePaths (config);

  593. 

  594.                 for (auto path : includePaths)

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

  596.             }

  597.         }

  598. 

  599.         {

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

  601. 

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

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

  604. 

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

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

  607. 

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

  609. 

  610.             for (auto lib : libs)

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

  612. 

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

  614.                 setAddOption (*linker, "directory",

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

  616.         }

  617.     }

  618. 

  619.     void addBuild (XmlElement& xml) const

  620.     {

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

  622. 

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

  624.             for (auto target : targets)

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

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

  627.     }

  628. 

  629.     void addVirtualTargets (XmlElement& xml) const

  630.     {

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

  632. 

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

  634.         {

  635.             StringArray allTargets;

  636. 

  637.             for (auto target : targets)

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

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

  640. 

  641.             for (auto target : targets)

  642.             {

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

  644.                 {

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

  646. 

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

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

  649.                 }

  650.             }

  651.         }

  652.     }

  653. 

  654.     StringArray getProjectCompilerOptions() const

  655.     {

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

  657.     }

  658. 

  659.     void addProjectCompilerOptions (XmlElement& xml) const

  660.     {

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

  662. 

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

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

  665.     }

  666. 

  667.     StringArray getProjectLinkerLibs() const

  668.     {

  669.         StringArray result;

  670. 

  671.         if (isWindows())

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

  673. 

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

  675. 

  676.         result = getCleanedStringArray (result);

  677. 

  678.         for (auto& option : result)

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

  680. 

  681.         return result;

  682.     }

  683. 

  684.     void addProjectLinkerOptions (XmlElement& xml) const

  685.     {

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

  687. 

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

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

  690.     }

  691. 

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

  693.     {

  694.         CodeBlocksTarget* nonAggregrateTarget = nullptr;

  695. 

  696.         for (auto* target : targets)

  697.         {

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

  699.                 return *target;

  700. 

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

  702.                 nonAggregrateTarget = target;

  703.         }

  704. 

  705.         // this project has no valid targets

  706.         jassert (nonAggregrateTarget != nullptr);

  707. 

  708.         return *nonAggregrateTarget;

  709.     }

  710. 

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

  712.     // the single target

  713.     CodeBlocksTarget& getMainTarget() const

  714.     {

  715.         if (getProject().isAudioPluginProject())

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

  717. 

  718.         for (auto* target : targets)

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

  720.                 return *target;

  721. 

  722.         jassertfalse;

  723. 

  724.         return *targets[0];

  725.     }

  726. 

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

  728.     {

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

  730.         {

  731.             if (! projectItem.shouldBeCompiled())

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

  733. 

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

  735.         }

  736. 

  737.         return getMainTarget();

  738.     }

  739. 

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

  741.     {

  742.         if (projectItem.isGroup())

  743.         {

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

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

  746.         }

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

  748.         {

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

  750. 

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

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

  753. 

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

  755.             {

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

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

  758.             }

  759. 

  760.             if (projectItem.shouldBeCompiled())

  761.             {

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

  763. 

  764.                 if (extraCompilerFlags.isNotEmpty())

  765.                 {

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

  767. 

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

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

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

  771.                 }

  772.             }

  773.             else

  774.             {

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

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

  777.             }

  778.         }

  779.     }

  780. 

  781.     bool hasResourceFile() const

  782.     {

  783.         return ! projectType.isStaticLibrary();

  784.     }

  785. 

  786.     void addCompileUnits (XmlElement& xml) const

  787.     {

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

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

  790. 

  791.         if (hasResourceFile())

  792.         {

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

  794. 

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

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

  797. 

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

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

  800. 

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

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

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

  804.         }

  805.     }

  806. 

  807.     void createProject (XmlElement& xml) const

  808.     {

  809.         addOptions (xml);

  810.         addBuild (xml);

  811.         addVirtualTargets (xml);

  812.         addProjectCompilerOptions (xml);

  813.         addProjectLinkerOptions (xml);

  814.         addCompileUnits (xml);

  815.     }

  816. 

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

  818.     {

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

  820.     }

  821. 

  822.     CodeBlocksOS os;

  823. 

  824.     OwnedArray<CodeBlocksTarget> targets;

  825. 

  826.     friend class CLionProjectExporter;

  827. 

  828.     JUCE_DECLARE_NON_COPYABLE (CodeBlocksProjectExporter)

  829. };