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

829 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.     ValueWithDefault 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.         ValueWithDefault 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.         for (auto& recommended : config.getRecommendedCompilerWarningFlags())

  381.             flags.add (recommended);

  382. 

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

  384. 

  385.         if (config.isLinkTimeOptimisationEnabled())

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

  387. 

  388.         {

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

  390. 

  391.             if (cppStandard == "latest")

  392.                 cppStandard = "17";

  393. 

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

  395. 

  396.             flags.add (cppStandard);

  397.         }

  398. 

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

  400. 

  401.         if (config.isDebug())

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

  403. 

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

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

  406. 

  407.         if (config.exporter.isLinux())

  408.         {

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

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

  411. 

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

  413. 

  414.             if (! packages.isEmpty())

  415.             {

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

  417. 

  418.                 for (auto& p : packages)

  419.                     pkgconfigFlags << " " << p;

  420. 

  421.                 pkgconfigFlags << "`";

  422.                 flags.add (pkgconfigFlags);

  423.             }

  424. 

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

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

  427.         }

  428. 

  429.         return getCleanedStringArray (flags);

  430.     }

  431. 

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

  433.     {

  434.         auto flags = makefileExtraLinkerFlags;

  435. 

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

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

  438. 

  439.         if (! config.isDebug())

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

  441. 

  442.         if (config.isLinkTimeOptimisationEnabled())

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

  444. 

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

  446. 

  447.         if (config.exporter.isLinux())

  448.         {

  449.             if (target.isDynamicLibrary())

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

  451. 

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

  453. 

  454.             if (! packages.isEmpty())

  455.             {

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

  457. 

  458.                 for (auto& p : packages)

  459.                     pkgconfigLibs << " " << p;

  460. 

  461.                 pkgconfigLibs << "`";

  462.                 flags.add (pkgconfigLibs);

  463.             }

  464.         }

  465. 

  466.         return getCleanedStringArray (flags);

  467.     }

  468. 

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

  470.     {

  471.         auto librarySearchPaths = config.getLibrarySearchPaths();

  472. 

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

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

  475. 

  476.         return librarySearchPaths;

  477.     }

  478. 

  479.     StringArray getIncludePaths (const BuildConfiguration& config) const

  480.     {

  481.         StringArray paths;

  482. 

  483.         paths.add (".");

  484.         paths.addArray (extraSearchPaths);

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

  486. 

  487.         if (! isWindows())

  488.         {

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

  490. 

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

  492.             for (auto& path : paths)

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

  494.         }

  495. 

  496.         return getCleanedStringArray (paths);

  497.     }

  498. 

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

  500.     {

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

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

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

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

  505. 

  506.         return 0;

  507.     }

  508. 

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

  510.     {

  511.         String outputPath;

  512.         if (config.getTargetBinaryRelativePathString().isNotEmpty())

  513.         {

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

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

  516.             outputPath = config.getTargetBinaryRelativePathString();

  517.         }

  518.         else

  519.         {

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

  521.         }

  522. 

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

  524.     }

  525. 

  526.     String getSharedCodePath (const BuildConfiguration& config) const

  527.     {

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

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

  530.         auto filename = path.getFileName();

  531. 

  532.         if (isLinux())

  533.             filename = "lib" + filename;

  534. 

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

  536.     }

  537. 

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

  539.     {

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

  541. 

  542.         {

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

  544. 

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

  546. 

  547.             if (isLinux())

  548.             {

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

  550. 

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

  552.             }

  553.             else

  554.             {

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

  556.             }

  557. 

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

  559.         }

  560. 

  561.         xml.createNewChildElement ("Option")

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

  563. 

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

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

  566. 

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

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

  569. 

  570.         {

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

  572. 

  573.             {

  574.                 StringArray flags;

  575. 

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

  577.                 {

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

  579.                         def << '=';

  580. 

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

  582.                 }

  583. 

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

  585. 

  586.                 for (auto flag : flags)

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

  588.             }

  589. 

  590.             {

  591.                 auto includePaths = getIncludePaths (config);

  592. 

  593.                 for (auto path : includePaths)

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

  595.             }

  596.         }

  597. 

  598.         {

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

  600. 

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

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

  603. 

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

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

  606. 

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

  608. 

  609.             for (auto lib : libs)

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

  611. 

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

  613.                 setAddOption (*linker, "directory",

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

  615.         }

  616.     }

  617. 

  618.     void addBuild (XmlElement& xml) const

  619.     {

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

  621. 

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

  623.             for (auto target : targets)

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

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

  626.     }

  627. 

  628.     void addVirtualTargets (XmlElement& xml) const

  629.     {

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

  631. 

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

  633.         {

  634.             StringArray allTargets;

  635. 

  636.             for (auto target : targets)

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

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

  639. 

  640.             for (auto target : targets)

  641.             {

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

  643.                 {

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

  645. 

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

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

  648.                 }

  649.             }

  650.         }

  651.     }

  652. 

  653.     StringArray getProjectCompilerOptions() const

  654.     {

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

  656.     }

  657. 

  658.     void addProjectCompilerOptions (XmlElement& xml) const

  659.     {

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

  661. 

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

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

  664.     }

  665. 

  666.     StringArray getProjectLinkerLibs() const

  667.     {

  668.         StringArray result;

  669. 

  670.         if (isWindows())

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

  672. 

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

  674. 

  675.         result = getCleanedStringArray (result);

  676. 

  677.         for (auto& option : result)

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

  679. 

  680.         return result;

  681.     }

  682. 

  683.     void addProjectLinkerOptions (XmlElement& xml) const

  684.     {

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

  686. 

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

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

  689.     }

  690. 

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

  692.     {

  693.         CodeBlocksTarget* nonAggregrateTarget = nullptr;

  694. 

  695.         for (auto* target : targets)

  696.         {

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

  698.                 return *target;

  699. 

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

  701.                 nonAggregrateTarget = target;

  702.         }

  703. 

  704.         // this project has no valid targets

  705.         jassert (nonAggregrateTarget != nullptr);

  706. 

  707.         return *nonAggregrateTarget;

  708.     }

  709. 

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

  711.     // the single target

  712.     CodeBlocksTarget& getMainTarget() const

  713.     {

  714.         if (getProject().isAudioPluginProject())

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

  716. 

  717.         for (auto* target : targets)

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

  719.                 return *target;

  720. 

  721.         jassertfalse;

  722. 

  723.         return *targets[0];

  724.     }

  725. 

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

  727.     {

  728.         if (getProject().isAudioPluginProject())

  729.         {

  730.             if (! projectItem.shouldBeCompiled())

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

  732. 

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

  734.         }

  735. 

  736.         return getMainTarget();

  737.     }

  738. 

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

  740.     {

  741.         if (projectItem.isGroup())

  742.         {

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

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

  745.         }

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

  747.         {

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

  749. 

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

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

  752. 

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

  754.             {

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

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

  757.             }

  758. 

  759.             if (projectItem.shouldBeCompiled())

  760.             {

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

  762. 

  763.                 if (extraCompilerFlags.isNotEmpty())

  764.                 {

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

  766. 

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

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

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

  770.                 }

  771.             }

  772.             else

  773.             {

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

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

  776.             }

  777.         }

  778.     }

  779. 

  780.     bool hasResourceFile() const

  781.     {

  782.         return ! projectType.isStaticLibrary();

  783.     }

  784. 

  785.     void addCompileUnits (XmlElement& xml) const

  786.     {

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

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

  789. 

  790.         if (hasResourceFile())

  791.         {

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

  793. 

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

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

  796. 

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

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

  799. 

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

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

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

  803.         }

  804.     }

  805. 

  806.     void createProject (XmlElement& xml) const

  807.     {

  808.         addOptions (xml);

  809.         addBuild (xml);

  810.         addVirtualTargets (xml);

  811.         addProjectCompilerOptions (xml);

  812.         addProjectLinkerOptions (xml);

  813.         addCompileUnits (xml);

  814.     }

  815. 

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

  817.     {

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

  819.     }

  820. 

  821.     CodeBlocksOS os;

  822. 

  823.     OwnedArray<CodeBlocksTarget> targets;

  824. 

  825.     friend class CLionProjectExporter;

  826. 

  827.     JUCE_DECLARE_NON_COPYABLE (CodeBlocksProjectExporter)

  828. };