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

838 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.     bool supportsTargetType (build_tools::ProjectType::Target::Type type) const override

  102.     {

  103.         switch (type)

  104.         {

  105.             case build_tools::ProjectType::Target::StandalonePlugIn:

  106.             case build_tools::ProjectType::Target::GUIApp:

  107.             case build_tools::ProjectType::Target::ConsoleApp:

  108.             case build_tools::ProjectType::Target::StaticLibrary:

  109.             case build_tools::ProjectType::Target::SharedCodeTarget:

  110.             case build_tools::ProjectType::Target::AggregateTarget:

  111.             case build_tools::ProjectType::Target::VSTPlugIn:

  112.             case build_tools::ProjectType::Target::DynamicLibrary:

  113.                 return true;

  114.             case build_tools::ProjectType::Target::AAXPlugIn:

  115.             case build_tools::ProjectType::Target::RTASPlugIn:

  116.             case build_tools::ProjectType::Target::UnityPlugIn:

  117.             case build_tools::ProjectType::Target::VST3PlugIn:

  118.             case build_tools::ProjectType::Target::AudioUnitPlugIn:

  119.             case build_tools::ProjectType::Target::AudioUnitv3PlugIn:

  120.             case build_tools::ProjectType::Target::unspecified:

  121.             default:

  122.                 break;

  123.         }

  124. 

  125.         return false;

  126.     }

  127. 

  128.     void createExporterProperties (PropertyListBuilder& props) override

  129.     {

  130.         if (isWindows())

  131.         {

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

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

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

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

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

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

  138.         }

  139.     }

  140. 

  141.     //==============================================================================

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

  143.     {

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

  145.                                         .withFileExtension (".cbp");

  146. 

  147.         XmlElement xml ("CodeBlocks_project_file");

  148.         addVersion (xml);

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

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

  151.     }

  152. 

  153.     //==============================================================================

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

  155.     {

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

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

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

  159. 

  160.         //resource::ProjectType::Target::SharedCodeTarget

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

  162.                                     {

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

  164.                                             return;

  165. 

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

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

  168.                                     });

  169. 

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

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

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

  173.     }

  174. 

  175.     void initialiseDependencyPathValues() override

  176.     {

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

  178. 

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

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

  181.     }

  182. 

  183. private:

  184.     ValueWithDefault targetPlatformValue;

  185. 

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

  187. 

  188.     //==============================================================================

  189.     class CodeBlocksBuildConfiguration  : public BuildConfiguration

  190.     {

  191.     public:

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

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

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

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

  196.         {

  197.             linkTimeOptimisationValue.setDefault (false);

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

  199.         }

  200. 

  201.         void createConfigProperties (PropertyListBuilder& props) override

  202.         {

  203.             addRecommendedLinuxCompilerWarningsProperty (props);

  204.             addGCCOptimisationProperty (props);

  205. 

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

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

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

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

  210.         }

  211. 

  212.         String getModuleLibraryArchName() const override

  213.         {

  214.             auto archFlag = getArchitectureTypeString();

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

  216. 

  217.             if (archFlag.startsWith (prefix))

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

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

  220.                 return "x86_64";

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

  222.                 return "i386";

  223. 

  224.             jassertfalse;

  225.             return {};

  226.         }

  227. 

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

  229. 

  230.         //==============================================================================

  231.         ValueWithDefault architectureTypeValue;

  232.     };

  233. 

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

  235.     {

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

  237.     }

  238. 

  239.     //==============================================================================

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

  241.     {

  242.     public:

  243.         CodeBlocksTarget (const CodeBlocksProjectExporter& e,

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

  245.             : Target (typeToUse),

  246.               exporter (e)

  247.         {}

  248. 

  249.         String getTargetNameForConfiguration (const BuildConfiguration& config) const

  250.         {

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

  252.                 return config.getName();

  253. 

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

  255.         }

  256. 

  257.         String getTargetSuffix() const

  258.         {

  259.             auto fileType = getTargetFileType();

  260. 

  261.             if (exporter.isWindows())

  262.             {

  263.                 switch (fileType)

  264.                 {

  265.                     case executable:            return ".exe";

  266.                     case staticLibrary:         return ".lib";

  267.                     case sharedLibraryOrDLL:

  268.                     case pluginBundle:          return ".dll";

  269.                     case macOSAppex:

  270.                     case unknown:

  271.                     default:

  272.                         break;

  273.                 }

  274.             }

  275.             else

  276.             {

  277.                 switch (fileType)

  278.                 {

  279.                     case executable:            return {};

  280.                     case staticLibrary:         return ".a";

  281.                     case pluginBundle:

  282.                     case sharedLibraryOrDLL:    return ".so";

  283.                     case macOSAppex:

  284.                     case unknown:

  285.                     default:

  286.                         break;

  287.                 }

  288.             }

  289. 

  290.             return {};

  291.         }

  292. 

  293.         bool isDynamicLibrary() const

  294.         {

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

  296.         }

  297. 

  298.         const CodeBlocksProjectExporter& exporter;

  299.     };

  300. 

  301.     //==============================================================================

  302. 

  303.     StringArray getPackages() const

  304.     {

  305.         auto result = linuxPackages;

  306. 

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

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

  309.         {

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

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

  312.         }

  313. 

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

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

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

  317.             result.add ("libcurl");

  318. 

  319.         result.removeDuplicates (false);

  320. 

  321.         return result;

  322.     }

  323. 

  324.     void addVersion (XmlElement& xml) const

  325.     {

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

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

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

  329.     }

  330. 

  331.     void addOptions (XmlElement& xml) const

  332.     {

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

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

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

  336.     }

  337. 

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

  339.     {

  340.         StringPairArray defines;

  341. 

  342.         if (isWindows())

  343.         {

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

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

  346. 

  347.             auto targetPlatform = getTargetPlatformString();

  348. 

  349.             if (targetPlatform.isNotEmpty())

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

  351.         }

  352.         else

  353.         {

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

  355.         }

  356. 

  357.         if (config.isDebug())

  358.         {

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

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

  361.         }

  362.         else

  363.         {

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

  365.         }

  366. 

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

  368. 

  369.         StringArray defs;

  370.         auto keys = defines.getAllKeys();

  371.         auto values = defines.getAllValues();

  372. 

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

  374.         {

  375.             auto result = keys[i];

  376. 

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

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

  379. 

  380.             defs.add (result);

  381.         }

  382. 

  383.         return getCleanedStringArray (defs);

  384.     }

  385. 

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

  387.     {

  388.         StringArray flags;

  389. 

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

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

  392. 

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

  394.             flags.add (recommended);

  395. 

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

  397. 

  398.         if (config.isLinkTimeOptimisationEnabled())

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

  400. 

  401.         {

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

  403. 

  404.             if (cppStandard == "latest")

  405.                 cppStandard = "17";

  406. 

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

  408. 

  409.             flags.add (cppStandard);

  410.         }

  411. 

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

  413. 

  414.         if (config.isDebug())

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

  416. 

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

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

  419. 

  420.         if (config.exporter.isLinux())

  421.         {

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

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

  424. 

  425.             auto packages = getPackages();

  426. 

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

  428.             {

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

  430.                 for (auto p : packages)

  431.                     pkgconfigFlags << " " << p;

  432. 

  433.                 pkgconfigFlags << "`";

  434.                 flags.add (pkgconfigFlags);

  435.             }

  436. 

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

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

  439.         }

  440. 

  441.         return getCleanedStringArray (flags);

  442.     }

  443. 

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

  445.     {

  446.         auto flags = makefileExtraLinkerFlags;

  447. 

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

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

  450. 

  451.         if (! config.isDebug())

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

  453. 

  454.         if (config.isLinkTimeOptimisationEnabled())

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

  456. 

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

  458. 

  459.         auto packages = getPackages();

  460. 

  461.         if (config.exporter.isLinux())

  462.         {

  463.             if (target.isDynamicLibrary())

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

  465. 

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

  467.             {

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

  469. 

  470.                 for (auto& p : packages)

  471.                     pkgconfigLibs << " " << p;

  472. 

  473.                 pkgconfigLibs << "`";

  474.                 flags.add (pkgconfigLibs);

  475.             }

  476.         }

  477. 

  478.         return getCleanedStringArray (flags);

  479.     }

  480. 

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

  482.     {

  483.         auto librarySearchPaths = config.getLibrarySearchPaths();

  484. 

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

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

  487. 

  488.         return librarySearchPaths;

  489.     }

  490. 

  491.     StringArray getIncludePaths (const BuildConfiguration& config) const

  492.     {

  493.         StringArray paths;

  494. 

  495.         paths.add (".");

  496.         paths.addArray (extraSearchPaths);

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

  498. 

  499.         if (! isWindows())

  500.         {

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

  502. 

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

  504.             for (auto& path : paths)

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

  506.         }

  507. 

  508.         return getCleanedStringArray (paths);

  509.     }

  510. 

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

  512.     {

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

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

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

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

  517. 

  518.         return 0;

  519.     }

  520. 

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

  522.     {

  523.         String outputPath;

  524.         if (config.getTargetBinaryRelativePathString().isNotEmpty())

  525.         {

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

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

  528.             outputPath = config.getTargetBinaryRelativePathString();

  529.         }

  530.         else

  531.         {

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

  533.         }

  534. 

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

  536.     }

  537. 

  538.     String getSharedCodePath (const BuildConfiguration& config) const

  539.     {

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

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

  542.         auto filename = path.getFileName();

  543. 

  544.         if (isLinux())

  545.             filename = "lib" + filename;

  546. 

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

  548.     }

  549. 

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

  551.     {

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

  553. 

  554.         {

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

  556. 

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

  558. 

  559.             if (isLinux())

  560.             {

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

  562. 

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

  564.             }

  565.             else

  566.             {

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

  568.             }

  569. 

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

  571.         }

  572. 

  573.         xml.createNewChildElement ("Option")

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

  575. 

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

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

  578. 

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

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

  581. 

  582.         {

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

  584. 

  585.             {

  586.                 StringArray flags;

  587. 

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

  589.                 {

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

  591.                             def << '=';

  592. 

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

  594.                 }

  595. 

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

  597. 

  598.                 for (auto flag : flags)

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

  600.             }

  601. 

  602.             {

  603.                 auto includePaths = getIncludePaths (config);

  604. 

  605.                 for (auto path : includePaths)

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

  607.             }

  608.         }

  609. 

  610.         {

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

  612. 

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

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

  615. 

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

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

  618. 

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

  620. 

  621.             for (auto lib : libs)

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

  623. 

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

  625.                 setAddOption (*linker, "directory",

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

  627.         }

  628.     }

  629. 

  630.     void addBuild (XmlElement& xml) const

  631.     {

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

  633. 

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

  635.             for (auto target : targets)

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

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

  638.     }

  639. 

  640.     void addVirtualTargets (XmlElement& xml) const

  641.     {

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

  643. 

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

  645.         {

  646.             StringArray allTargets;

  647. 

  648.             for (auto target : targets)

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

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

  651. 

  652.             for (auto target : targets)

  653.             {

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

  655.                 {

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

  657. 

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

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

  660.                 }

  661.             }

  662.         }

  663.     }

  664. 

  665.     StringArray getProjectCompilerOptions() const

  666.     {

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

  668.     }

  669. 

  670.     void addProjectCompilerOptions (XmlElement& xml) const

  671.     {

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

  673. 

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

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

  676.     }

  677. 

  678.     StringArray getProjectLinkerLibs() const

  679.     {

  680.         StringArray result;

  681. 

  682.         if (isWindows())

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

  684. 

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

  686. 

  687.         result = getCleanedStringArray (result);

  688. 

  689.         for (auto& option : result)

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

  691. 

  692.         return result;

  693.     }

  694. 

  695.     void addProjectLinkerOptions (XmlElement& xml) const

  696.     {

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

  698. 

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

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

  701.     }

  702. 

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

  704.     {

  705.         CodeBlocksTarget* nonAggregrateTarget = nullptr;

  706. 

  707.         for (auto* target : targets)

  708.         {

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

  710.                 return *target;

  711. 

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

  713.                 nonAggregrateTarget = target;

  714.         }

  715. 

  716.         // this project has no valid targets

  717.         jassert (nonAggregrateTarget != nullptr);

  718. 

  719.         return *nonAggregrateTarget;

  720.     }

  721. 

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

  723.     // the single target

  724.     CodeBlocksTarget& getMainTarget() const

  725.     {

  726.         if (getProject().isAudioPluginProject())

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

  728. 

  729.         for (auto* target : targets)

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

  731.                 return *target;

  732. 

  733.         jassertfalse;

  734. 

  735.         return *targets[0];

  736.     }

  737. 

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

  739.     {

  740.         if (getProject().isAudioPluginProject())

  741.         {

  742.             if (! projectItem.shouldBeCompiled())

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

  744. 

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

  746.         }

  747. 

  748.         return getMainTarget();

  749.     }

  750. 

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

  752.     {

  753.         if (projectItem.isGroup())

  754.         {

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

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

  757.         }

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

  759.         {

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

  761. 

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

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

  764. 

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

  766.             {

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

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

  769.             }

  770. 

  771.             if (projectItem.shouldBeCompiled())

  772.             {

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

  774. 

  775.                 if (extraCompilerFlags.isNotEmpty())

  776.                 {

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

  778. 

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

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

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

  782.                 }

  783.             }

  784.             else

  785.             {

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

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

  788.             }

  789.         }

  790.     }

  791. 

  792.     bool hasResourceFile() const

  793.     {

  794.         return ! projectType.isStaticLibrary();

  795.     }

  796. 

  797.     void addCompileUnits (XmlElement& xml) const

  798.     {

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

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

  801. 

  802.         if (hasResourceFile())

  803.         {

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

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

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

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

  808. 

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

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

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

  812.         }

  813.     }

  814. 

  815.     void createProject (XmlElement& xml) const

  816.     {

  817.         addOptions (xml);

  818.         addBuild (xml);

  819.         addVirtualTargets (xml);

  820.         addProjectCompilerOptions (xml);

  821.         addProjectLinkerOptions (xml);

  822.         addCompileUnits (xml);

  823.     }

  824. 

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

  826.     {

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

  828.     }

  829. 

  830.     CodeBlocksOS os;

  831. 

  832.     OwnedArray<CodeBlocksTarget> targets;

  833. 

  834.     friend class CLionProjectExporter;

  835. 

  836.     JUCE_DECLARE_NON_COPYABLE (CodeBlocksProjectExporter)

  837. };