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

831 lines
31KB
Raw Blame History 

  1. /*

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

  3. 

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

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

  6. 

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

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

  9. 

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

  11. 

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

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

  14.    DISCLAIMED.

  15. 

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

  17. */

  18. 

  19. #pragma once

  20. 

  21. #include "jucer_ProjectExport_MSVC.h"

  22. 

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

  24. class CodeBlocksProjectExporter  : public ProjectExporter

  25. {

  26. public:

  27.     enum CodeBlocksOS

  28.     {

  29.         windowsTarget,

  30.         linuxTarget

  31.     };

  32. 

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

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

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

  36. 

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

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

  39. 

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

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

  42. 

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

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

  45.     {

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

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

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

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

  50. 

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

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

  53. 

  54.         return nullptr;

  55.     }

  56. 

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

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

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

  60.     {

  61.         if (isWindows())

  62.         {

  63.             name = getDisplayNameWindows();

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

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

  66.         }

  67.         else

  68.         {

  69.             name = getDisplayNameLinux();

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

  71.         }

  72.     }

  73. 

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

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

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

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

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

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

  80. 

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

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

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

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

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

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

  87. 

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

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

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

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

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

  93. 

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

  95.     {

  96.         switch (type)

  97.         {

  98.             case build_tools::ProjectType::Target::StandalonePlugIn:

  99.             case build_tools::ProjectType::Target::GUIApp:

  100.             case build_tools::ProjectType::Target::ConsoleApp:

  101.             case build_tools::ProjectType::Target::StaticLibrary:

  102.             case build_tools::ProjectType::Target::SharedCodeTarget:

  103.             case build_tools::ProjectType::Target::AggregateTarget:

  104.             case build_tools::ProjectType::Target::VSTPlugIn:

  105.             case build_tools::ProjectType::Target::DynamicLibrary:

  106.                 return true;

  107.             case build_tools::ProjectType::Target::AAXPlugIn:

  108.             case build_tools::ProjectType::Target::RTASPlugIn:

  109.             case build_tools::ProjectType::Target::UnityPlugIn:

  110.             case build_tools::ProjectType::Target::VST3PlugIn:

  111.             case build_tools::ProjectType::Target::AudioUnitPlugIn:

  112.             case build_tools::ProjectType::Target::AudioUnitv3PlugIn:

  113.             case build_tools::ProjectType::Target::unspecified:

  114.             default:

  115.                 break;

  116.         }

  117. 

  118.         return false;

  119.     }

  120. 

  121.     void createExporterProperties (PropertyListBuilder& props) override

  122.     {

  123.         if (isWindows())

  124.         {

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

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

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

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

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

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

  131.         }

  132.     }

  133. 

  134.     //==============================================================================

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

  136.     {

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

  138.                                         .withFileExtension (".cbp");

  139. 

  140.         XmlElement xml ("CodeBlocks_project_file");

  141.         addVersion (xml);

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

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

  144.     }

  145. 

  146.     //==============================================================================

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

  148.     {

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

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

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

  152. 

  153.         //resource::ProjectType::Target::SharedCodeTarget

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

  155.                                     {

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

  157.                                             return;

  158. 

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

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

  161.                                     });

  162. 

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

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

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

  166.     }

  167. 

  168.     void initialiseDependencyPathValues() override

  169.     {

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

  171. 

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

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

  174.     }

  175. 

  176. private:

  177.     ValueWithDefault targetPlatformValue;

  178. 

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

  180. 

  181.     //==============================================================================

  182.     class CodeBlocksBuildConfiguration  : public BuildConfiguration

  183.     {

  184.     public:

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

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

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

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

  189.         {

  190.             linkTimeOptimisationValue.setDefault (false);

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

  192.         }

  193. 

  194.         void createConfigProperties (PropertyListBuilder& props) override

  195.         {

  196.             addRecommendedLinuxCompilerWarningsProperty (props);

  197.             addGCCOptimisationProperty (props);

  198. 

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

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

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

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

  203.         }

  204. 

  205.         String getModuleLibraryArchName() const override

  206.         {

  207.             auto archFlag = getArchitectureTypeString();

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

  209. 

  210.             if (archFlag.startsWith (prefix))

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

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

  213.                 return "x86_64";

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

  215.                 return "i386";

  216. 

  217.             jassertfalse;

  218.             return {};

  219.         }

  220. 

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

  222. 

  223.         //==============================================================================

  224.         ValueWithDefault architectureTypeValue;

  225.     };

  226. 

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

  228.     {

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

  230.     }

  231. 

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

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

  234.     {

  235.     public:

  236.         CodeBlocksTarget (const CodeBlocksProjectExporter& e,

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

  238.             : Target (typeToUse),

  239.               exporter (e)

  240.         {}

  241. 

  242.         String getTargetNameForConfiguration (const BuildConfiguration& config) const

  243.         {

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

  245.                 return config.getName();

  246. 

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

  248.         }

  249. 

  250.         String getTargetSuffix() const

  251.         {

  252.             auto fileType = getTargetFileType();

  253. 

  254.             if (exporter.isWindows())

  255.             {

  256.                 switch (fileType)

  257.                 {

  258.                     case executable:            return ".exe";

  259.                     case staticLibrary:         return ".lib";

  260.                     case sharedLibraryOrDLL:

  261.                     case pluginBundle:          return ".dll";

  262.                     case macOSAppex:

  263.                     case unknown:

  264.                     default:

  265.                         break;

  266.                 }

  267.             }

  268.             else

  269.             {

  270.                 switch (fileType)

  271.                 {

  272.                     case executable:            return {};

  273.                     case staticLibrary:         return ".a";

  274.                     case pluginBundle:

  275.                     case sharedLibraryOrDLL:    return ".so";

  276.                     case macOSAppex:

  277.                     case unknown:

  278.                     default:

  279.                         break;

  280.                 }

  281.             }

  282. 

  283.             return {};

  284.         }

  285. 

  286.         bool isDynamicLibrary() const

  287.         {

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

  289.         }

  290. 

  291.         const CodeBlocksProjectExporter& exporter;

  292.     };

  293. 

  294.     //==============================================================================

  295. 

  296.     StringArray getPackages() const

  297.     {

  298.         auto result = linuxPackages;

  299. 

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

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

  302.         {

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

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

  305.         }

  306. 

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

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

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

  310.             result.add ("libcurl");

  311. 

  312.         result.removeDuplicates (false);

  313. 

  314.         return result;

  315.     }

  316. 

  317.     void addVersion (XmlElement& xml) const

  318.     {

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

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

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

  322.     }

  323. 

  324.     void addOptions (XmlElement& xml) const

  325.     {

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

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

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

  329.     }

  330. 

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

  332.     {

  333.         StringPairArray defines;

  334. 

  335.         if (isWindows())

  336.         {

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

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

  339. 

  340.             auto targetPlatform = getTargetPlatformString();

  341. 

  342.             if (targetPlatform.isNotEmpty())

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

  344.         }

  345.         else

  346.         {

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

  348.         }

  349. 

  350.         if (config.isDebug())

  351.         {

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

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

  354.         }

  355.         else

  356.         {

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

  358.         }

  359. 

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

  361. 

  362.         StringArray defs;

  363.         auto keys = defines.getAllKeys();

  364.         auto values = defines.getAllValues();

  365. 

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

  367.         {

  368.             auto result = keys[i];

  369. 

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

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

  372. 

  373.             defs.add (result);

  374.         }

  375. 

  376.         return getCleanedStringArray (defs);

  377.     }

  378. 

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

  380.     {

  381.         StringArray flags;

  382. 

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

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

  385. 

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

  387.             flags.add (recommended);

  388. 

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

  390. 

  391.         if (config.isLinkTimeOptimisationEnabled())

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

  393. 

  394.         {

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

  396. 

  397.             if (cppStandard == "latest")

  398.                 cppStandard = "17";

  399. 

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

  401. 

  402.             flags.add (cppStandard);

  403.         }

  404. 

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

  406. 

  407.         if (config.isDebug())

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

  409. 

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

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

  412. 

  413.         if (config.exporter.isLinux())

  414.         {

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

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

  417. 

  418.             auto packages = getPackages();

  419. 

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

  421.             {

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

  423.                 for (auto p : packages)

  424.                     pkgconfigFlags << " " << p;

  425. 

  426.                 pkgconfigFlags << "`";

  427.                 flags.add (pkgconfigFlags);

  428.             }

  429. 

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

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

  432.         }

  433. 

  434.         return getCleanedStringArray (flags);

  435.     }

  436. 

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

  438.     {

  439.         auto flags = makefileExtraLinkerFlags;

  440. 

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

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

  443. 

  444.         if (! config.isDebug())

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

  446. 

  447.         if (config.isLinkTimeOptimisationEnabled())

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

  449. 

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

  451. 

  452.         auto packages = getPackages();

  453. 

  454.         if (config.exporter.isLinux())

  455.         {

  456.             if (target.isDynamicLibrary())

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

  458. 

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

  460.             {

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

  462. 

  463.                 for (auto& p : packages)

  464.                     pkgconfigLibs << " " << p;

  465. 

  466.                 pkgconfigLibs << "`";

  467.                 flags.add (pkgconfigLibs);

  468.             }

  469.         }

  470. 

  471.         return getCleanedStringArray (flags);

  472.     }

  473. 

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

  475.     {

  476.         auto librarySearchPaths = config.getLibrarySearchPaths();

  477. 

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

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

  480. 

  481.         return librarySearchPaths;

  482.     }

  483. 

  484.     StringArray getIncludePaths (const BuildConfiguration& config) const

  485.     {

  486.         StringArray paths;

  487. 

  488.         paths.add (".");

  489.         paths.addArray (extraSearchPaths);

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

  491. 

  492.         if (! isWindows())

  493.         {

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

  495. 

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

  497.             for (auto& path : paths)

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

  499.         }

  500. 

  501.         return getCleanedStringArray (paths);

  502.     }

  503. 

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

  505.     {

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

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

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

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

  510. 

  511.         return 0;

  512.     }

  513. 

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

  515.     {

  516.         String outputPath;

  517.         if (config.getTargetBinaryRelativePathString().isNotEmpty())

  518.         {

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

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

  521.             outputPath = config.getTargetBinaryRelativePathString();

  522.         }

  523.         else

  524.         {

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

  526.         }

  527. 

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

  529.     }

  530. 

  531.     String getSharedCodePath (const BuildConfiguration& config) const

  532.     {

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

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

  535.         auto filename = path.getFileName();

  536. 

  537.         if (isLinux())

  538.             filename = "lib" + filename;

  539. 

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

  541.     }

  542. 

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

  544.     {

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

  546. 

  547.         {

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

  549. 

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

  551. 

  552.             if (isLinux())

  553.             {

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

  555. 

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

  557.             }

  558.             else

  559.             {

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

  561.             }

  562. 

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

  564.         }

  565. 

  566.         xml.createNewChildElement ("Option")

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

  568. 

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

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

  571. 

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

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

  574. 

  575.         {

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

  577. 

  578.             {

  579.                 StringArray flags;

  580. 

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

  582.                 {

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

  584.                             def << '=';

  585. 

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

  587.                 }

  588. 

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

  590. 

  591.                 for (auto flag : flags)

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

  593.             }

  594. 

  595.             {

  596.                 auto includePaths = getIncludePaths (config);

  597. 

  598.                 for (auto path : includePaths)

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

  600.             }

  601.         }

  602. 

  603.         {

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

  605. 

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

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

  608. 

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

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

  611. 

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

  613. 

  614.             for (auto lib : libs)

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

  616. 

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

  618.                 setAddOption (*linker, "directory",

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

  620.         }

  621.     }

  622. 

  623.     void addBuild (XmlElement& xml) const

  624.     {

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

  626. 

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

  628.             for (auto target : targets)

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

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

  631.     }

  632. 

  633.     void addVirtualTargets (XmlElement& xml) const

  634.     {

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

  636. 

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

  638.         {

  639.             StringArray allTargets;

  640. 

  641.             for (auto target : targets)

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

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

  644. 

  645.             for (auto target : targets)

  646.             {

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

  648.                 {

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

  650. 

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

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

  653.                 }

  654.             }

  655.         }

  656.     }

  657. 

  658.     StringArray getProjectCompilerOptions() const

  659.     {

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

  661.     }

  662. 

  663.     void addProjectCompilerOptions (XmlElement& xml) const

  664.     {

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

  666. 

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

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

  669.     }

  670. 

  671.     StringArray getProjectLinkerLibs() const

  672.     {

  673.         StringArray result;

  674. 

  675.         if (isWindows())

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

  677. 

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

  679. 

  680.         result = getCleanedStringArray (result);

  681. 

  682.         for (auto& option : result)

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

  684. 

  685.         return result;

  686.     }

  687. 

  688.     void addProjectLinkerOptions (XmlElement& xml) const

  689.     {

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

  691. 

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

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

  694.     }

  695. 

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

  697.     {

  698.         CodeBlocksTarget* nonAggregrateTarget = nullptr;

  699. 

  700.         for (auto* target : targets)

  701.         {

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

  703.                 return *target;

  704. 

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

  706.                 nonAggregrateTarget = target;

  707.         }

  708. 

  709.         // this project has no valid targets

  710.         jassert (nonAggregrateTarget != nullptr);

  711. 

  712.         return *nonAggregrateTarget;

  713.     }

  714. 

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

  716.     // the single target

  717.     CodeBlocksTarget& getMainTarget() const

  718.     {

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

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

  721. 

  722.         for (auto* target : targets)

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

  724.                 return *target;

  725. 

  726.         jassertfalse;

  727. 

  728.         return *targets[0];

  729.     }

  730. 

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

  732.     {

  733.         if (getProject().isAudioPluginProject())

  734.         {

  735.             if (! projectItem.shouldBeCompiled())

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

  737. 

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

  739.         }

  740. 

  741.         return getMainTarget();

  742.     }

  743. 

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

  745.     {

  746.         if (projectItem.isGroup())

  747.         {

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

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

  750.         }

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

  752.         {

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

  754. 

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

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

  757. 

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

  759.             {

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

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

  762.             }

  763. 

  764.             if (projectItem.shouldBeCompiled())

  765.             {

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

  767. 

  768.                 if (extraCompilerFlags.isNotEmpty())

  769.                 {

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

  771. 

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

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

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

  775.                 }

  776.             }

  777.             else

  778.             {

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

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

  781.             }

  782.         }

  783.     }

  784. 

  785.     bool hasResourceFile() const

  786.     {

  787.         return ! projectType.isStaticLibrary();

  788.     }

  789. 

  790.     void addCompileUnits (XmlElement& xml) const

  791.     {

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

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

  794. 

  795.         if (hasResourceFile())

  796.         {

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

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

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

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

  801. 

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

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

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

  805.         }

  806.     }

  807. 

  808.     void createProject (XmlElement& xml) const

  809.     {

  810.         addOptions (xml);

  811.         addBuild (xml);

  812.         addVirtualTargets (xml);

  813.         addProjectCompilerOptions (xml);

  814.         addProjectLinkerOptions (xml);

  815.         addCompileUnits (xml);

  816.     }

  817. 

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

  819.     {

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

  821.     }

  822. 

  823.     CodeBlocksOS os;

  824. 

  825.     OwnedArray<CodeBlocksTarget> targets;

  826. 

  827.     friend class CLionProjectExporter;

  828. 

  829.     JUCE_DECLARE_NON_COPYABLE (CodeBlocksProjectExporter)

  830. };