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

817 lines
30KB
Raw Blame History 

  1. /*

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

  3. 

  4.    This file is part of the JUCE library.

  5.    Copyright (c) 2017 - ROLI Ltd.

  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 5 End-User License

  11.    Agreement and JUCE 5 Privacy Policy (both updated and effective as of the

  12.    27th April 2017).

  13. 

  14.    End User License Agreement: www.juce.com/juce-5-licence

  15.    Privacy Policy: www.juce.com/juce-5-privacy-policy

  16. 

  17.    Or: You may also use this code under the terms of the GPL v3 (see

  18.    www.gnu.org/licenses).

  19. 

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

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

  22.    DISCLAIMED.

  23. 

  24.   ==============================================================================

  25. */

  26. 

  27. #pragma once

  28. 

  29. 

  30. //==============================================================================

  31. class CodeBlocksProjectExporter  : public ProjectExporter

  32. {

  33. public:

  34.     enum CodeBlocksOS

  35.     {

  36.         windowsTarget,

  37.         linuxTarget

  38.     };

  39. 

  40.     //==============================================================================

  41.     static const char* getNameWindows() noexcept    { return "Code::Blocks (Windows)"; }

  42.     static const char* getNameLinux() noexcept      { return "Code::Blocks (Linux)"; }

  43. 

  44.     static const char* getName (CodeBlocksOS os) noexcept

  45.     {

  46.         if (os == windowsTarget) return getNameWindows();

  47.         if (os == linuxTarget)   return getNameLinux();

  48. 

  49.         // currently no other OSes supported by Codeblocks exporter!

  50.         jassertfalse;

  51.         return "Code::Blocks (Unknown OS)";

  52.     }

  53. 

  54.     //==============================================================================

  55.     static const char* getValueTreeTypeName (CodeBlocksOS os)

  56.     {

  57.         if (os == windowsTarget)  return "CODEBLOCKS_WINDOWS";

  58.         if (os == linuxTarget)    return "CODEBLOCKS_LINUX";

  59. 

  60.         // currently no other OSes supported by Codeblocks exporter!

  61.         jassertfalse;

  62.         return "CODEBLOCKS_UNKNOWN_OS";

  63.     }

  64. 

  65.     //==============================================================================

  66.     static String getTargetFolderName (CodeBlocksOS os)

  67.     {

  68.         if (os == windowsTarget)  return "CodeBlocksWindows";

  69.         if (os == linuxTarget)    return "CodeBlocksLinux";

  70. 

  71.         // currently no other OSes supported by Codeblocks exporter!

  72.         jassertfalse;

  73.         return "CodeBlocksUnknownOS";

  74.     }

  75. 

  76.     //==============================================================================

  77.     static CodeBlocksProjectExporter* createForSettings (Project& project, const ValueTree& settings)

  78.     {

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

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

  81.         if (settings.hasType (getValueTreeTypeName (windowsTarget)) || settings.hasType ("CODEBLOCKS"))

  82.             return new CodeBlocksProjectExporter (project, settings, windowsTarget);

  83. 

  84.         if (settings.hasType (getValueTreeTypeName (linuxTarget)))

  85.             return new CodeBlocksProjectExporter (project, settings, linuxTarget);

  86. 

  87.         return nullptr;

  88.     }

  89. 

  90.     //==============================================================================

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

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

  93.     {

  94.         name = getName (os);

  95. 

  96.         if (getTargetLocationString().isEmpty())

  97.             getTargetLocationValue() = getDefaultBuildsRootFolder() + getTargetFolderName (os);

  98.     }

  99. 

  100.     //==============================================================================

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

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

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

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

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

  106. 

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

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

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

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

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

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

  113. 

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

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

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

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

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

  119. 

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

  121.     {

  122.         switch (type)

  123.         {

  124.             case ProjectType::Target::StandalonePlugIn:

  125.             case ProjectType::Target::GUIApp:

  126.             case ProjectType::Target::ConsoleApp:

  127.             case ProjectType::Target::StaticLibrary:

  128.             case ProjectType::Target::SharedCodeTarget:

  129.             case ProjectType::Target::AggregateTarget:

  130.             case ProjectType::Target::VSTPlugIn:

  131.             case ProjectType::Target::DynamicLibrary:

  132.                 return true;

  133.             default:

  134.                 break;

  135.         }

  136. 

  137.         return false;

  138.     }

  139. 

  140.     void createExporterProperties (PropertyListBuilder&) override

  141.     {

  142.     }

  143. 

  144.     //==============================================================================

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

  146.     {

  147.         const File cbpFile (getTargetFolder().getChildFile (project.getProjectFilenameRoot())

  148.                                              .withFileExtension (".cbp"));

  149. 

  150.         XmlElement xml ("CodeBlocks_project_file");

  151.         addVersion (xml);

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

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

  154.     }

  155. 

  156.     //==============================================================================

  157.     void addPlatformSpecificSettingsForProjectType (const ProjectType&) override

  158.     {

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

  160.         if (shouldBuildTargetType (ProjectType::Target::SharedCodeTarget))

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

  162. 

  163.         //ProjectType::Target::SharedCodeTarget

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

  165.                                     {

  166.                                         if (targetType == ProjectType::Target::SharedCodeTarget)

  167.                                             return;

  168. 

  169.                                         if (auto* target = new CodeBlocksTarget (*this, targetType))

  170.                                         {

  171.                                             if (targetType == ProjectType::Target::AggregateTarget)

  172.                                                 targets.insert (0, target);

  173.                                             else

  174.                                                 targets.add (target);

  175.                                         }

  176.                                     });

  177. 

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

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

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

  181.     }

  182. 

  183.     //==============================================================================

  184.     void initialiseDependencyPathValues() override

  185.     {

  186.         DependencyPathOS pathOS = isLinux() ? TargetOS::linux

  187.                                             : TargetOS::windows;

  188. 

  189.         vst3Path.referTo (Value (new DependencyPathValueSource (getSetting (Ids::vst3Folder), Ids::vst3Path, pathOS)));

  190. 

  191.         if (! isLinux())

  192.         {

  193.             aaxPath.referTo  (Value (new DependencyPathValueSource (getSetting (Ids::aaxFolder), Ids::aaxPath, pathOS)));

  194.             rtasPath.referTo (Value (new DependencyPathValueSource (getSetting (Ids::rtasFolder), Ids::rtasPath, pathOS)));

  195.         }

  196.     }

  197. 

  198. private:

  199.     //==============================================================================

  200.     class CodeBlocksBuildConfiguration  : public BuildConfiguration

  201.     {

  202.     public:

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

  204.             : BuildConfiguration (p, settings, e)

  205.         {

  206.             if (getArchitectureType().toString().isEmpty())

  207.                 getArchitectureType() = static_cast<const char* const> ("-m64");

  208.         }

  209. 

  210.         Value getArchitectureType()

  211.         {

  212.             const auto archID = exporter.isWindows() ? Ids::windowsCodeBlocksArchitecture

  213.                                                      : Ids::linuxCodeBlocksArchitecture;

  214.             return getValue (archID);

  215.         }

  216. 

  217.         var getArchitectureTypeVar() const

  218.         {

  219.             const auto archID = exporter.isWindows() ? Ids::windowsCodeBlocksArchitecture

  220.                                                      : Ids::linuxCodeBlocksArchitecture;

  221.             return config [archID];

  222.         }

  223. 

  224.         var getDefaultOptimisationLevel() const override    { return var ((int) (isDebug() ? gccO0 : gccO3)); }

  225. 

  226.         void createConfigProperties (PropertyListBuilder& props) override

  227.         {

  228.             addGCCOptimisationProperty (props);

  229. 

  230.             static const char* const archNames[] = { "32-bit (-m32)", "64-bit (-m64)", "ARM v6",       "ARM v7" };

  231.             const var archFlags[]                = { "-m32",          "-m64",          "-march=armv6", "-march=armv7" };

  232. 

  233.             props.add (new ChoicePropertyComponent (getArchitectureType(), "Architecture",

  234.                                                     StringArray (archNames, numElementsInArray (archNames)),

  235.                                                     Array<var> (archFlags, numElementsInArray (archFlags))));

  236.         }

  237. 

  238.         String getModuleLibraryArchName() const override

  239.         {

  240.             const String archFlag = getArchitectureTypeVar();

  241. 

  242.             const auto prefix = String ("-march=");

  243.             if (archFlag.startsWith (prefix))

  244.                 return String ("/") + archFlag.substring (prefix.length());

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

  246.                 return "/x86_64";

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

  248.                 return "/i386";

  249. 

  250.             jassertfalse;

  251.             return {};

  252.         }

  253.     };

  254. 

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

  256.     {

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

  258.     }

  259. 

  260.     //==============================================================================

  261.     class CodeBlocksTarget : public ProjectType::Target

  262.     {

  263.     public:

  264.         CodeBlocksTarget (const CodeBlocksProjectExporter& e, ProjectType::Target::Type typeToUse)

  265.             : ProjectType::Target (typeToUse),

  266.               exporter (e)

  267.         {}

  268. 

  269.         String getTargetNameForConfiguration (const BuildConfiguration& config) const

  270.         {

  271.             if (type == ProjectType::Target::AggregateTarget)

  272.                 return config.getName();

  273. 

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

  275.         }

  276. 

  277.         String getTargetSuffix() const

  278.         {

  279.             auto fileType = getTargetFileType();

  280. 

  281.             if (exporter.isWindows())

  282.             {

  283.                 switch (fileType)

  284.                 {

  285.                     case executable:            return ".exe";

  286.                     case staticLibrary:         return ".lib";

  287.                     case sharedLibraryOrDLL:

  288.                     case pluginBundle:          return ".dll";

  289.                     default:

  290.                         break;

  291.                 }

  292.             }

  293.             else

  294.             {

  295.                 switch (fileType)

  296.                 {

  297.                     case executable:            return {};

  298.                     case staticLibrary:         return ".a";

  299.                     case sharedLibraryOrDLL:    return ".so";

  300. 

  301.                     case pluginBundle:

  302.                         switch (type)

  303.                         {

  304.                             case VST3PlugIn:    return ".vst3";

  305.                             case VSTPlugIn:     return ".so";

  306.                             default:            break;

  307.                         }

  308. 

  309.                         return ".so";

  310. 

  311.                     default:

  312.                         break;

  313.                 }

  314.             }

  315. 

  316.             return {};

  317.         }

  318. 

  319.         bool isDynamicLibrary() const

  320.         {

  321.             return (type == DynamicLibrary || type == VST3PlugIn

  322.                      || type == VSTPlugIn || type == AAXPlugIn);

  323.         }

  324. 

  325.         const CodeBlocksProjectExporter& exporter;

  326.     };

  327. 

  328.     //==============================================================================

  329. 

  330.     StringArray getPackages() const

  331.     {

  332.         StringArray result (linuxPackages);

  333. 

  334.         static String guiExtrasModule ("juce_gui_extra");

  335. 

  336.         if (project.getModules().isModuleEnabled (guiExtrasModule)

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

  338.         {

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

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

  341.         }

  342. 

  343.         result.removeDuplicates (false);

  344. 

  345.         return result;

  346.     }

  347. 

  348.     void addVersion (XmlElement& xml) const

  349.     {

  350.         XmlElement* fileVersion = xml.createNewChildElement ("FileVersion");

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

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

  353.     }

  354. 

  355.     void addOptions (XmlElement& xml) const

  356.     {

  357.         xml.createNewChildElement ("Option")->setAttribute ("title", project.getTitle());

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

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

  360.     }

  361. 

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

  363.     {

  364.         StringPairArray defines;

  365. 

  366.         if (isWindows())

  367.         {

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

  369.             defines.set ("__MINGW_EXTENSION", String());

  370.         }

  371.         else

  372.         {

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

  374.         }

  375. 

  376.         if (config.isDebug())

  377.         {

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

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

  380.         }

  381.         else

  382.         {

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

  384.         }

  385. 

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

  387. 

  388.         StringArray defs;

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

  390.             defs.add (defines.getAllKeys()[i] + "=" + defines.getAllValues()[i]);

  391. 

  392.         return getCleanedStringArray (defs);

  393.     }

  394. 

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

  396.     {

  397.         StringArray flags;

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

  399.             flags.add (codeBlocksConfig->getArchitectureTypeVar());

  400. 

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

  402. 

  403.         if (config.isLinkTimeOptimisationEnabled())

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

  405. 

  406.         {

  407.             auto cppStandard = config.project.getCppStandardValue().toString();

  408. 

  409.             if (cppStandard == "latest")

  410.                 cppStandard = "1z";

  411. 

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

  413. 

  414.             flags.add (cppStandard);

  415.         }

  416. 

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

  418. 

  419.         if (config.isDebug())

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

  421. 

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

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

  424. 

  425.         if (config.exporter.isLinux())

  426.         {

  427.             if (target.isDynamicLibrary() || getProject().getProjectType().isAudioPlugin())

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

  429. 

  430.             const auto packages = getPackages();

  431. 

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

  433.             {

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

  435.                 for (auto p : packages)

  436.                     pkgconfigFlags << " " << p;

  437. 

  438.                 pkgconfigFlags << "`";

  439.                 flags.add (pkgconfigFlags);

  440.             }

  441. 

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

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

  444.         }

  445. 

  446.         return getCleanedStringArray (flags);

  447.     }

  448. 

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

  450.     {

  451.         StringArray flags (makefileExtraLinkerFlags);

  452. 

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

  454.             flags.add (codeBlocksConfig->getArchitectureTypeVar());

  455. 

  456.         if (! config.isDebug())

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

  458. 

  459.         flags.addTokens (replacePreprocessorTokens (config, getExtraLinkerFlagsString()).trim(),

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

  461. 

  462.         const auto packages = getPackages();

  463. 

  464.         if (config.exporter.isLinux() && packages.size() > 0)

  465.         {

  466.             if (target.isDynamicLibrary())

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

  468. 

  469.             auto pkgconfigLibs = String ("`pkg-config --libs");

  470.             for (auto p : packages)

  471.                 pkgconfigLibs << " " << p;

  472. 

  473.             pkgconfigLibs << "`";

  474.             flags.add (pkgconfigLibs);

  475.         }

  476. 

  477.         return getCleanedStringArray (flags);

  478.     }

  479. 

  480.     StringArray getIncludePaths (const BuildConfiguration& config) const

  481.     {

  482.         StringArray paths;

  483. 

  484.         paths.add (".");

  485.         paths.addArray (extraSearchPaths);

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

  487. 

  488.         if (! isWindows())

  489.         {

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

  491. 

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

  493.             for (auto& path : paths)

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

  495.         }

  496. 

  497.         return getCleanedStringArray (paths);

  498.     }

  499. 

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

  501.     {

  502.         switch (type)

  503.         {

  504.             case ProjectType::Target::GUIApp:

  505.             case ProjectType::Target::StandalonePlugIn:

  506.                 return 0;

  507.             case ProjectType::Target::ConsoleApp:

  508.                 return 1;

  509.             case ProjectType::Target::StaticLibrary:

  510.             case ProjectType::Target::SharedCodeTarget:

  511.                 return 2;

  512.             case ProjectType::Target::DynamicLibrary:

  513.             case ProjectType::Target::VSTPlugIn:

  514.             case ProjectType::Target::VST3PlugIn:

  515.                 return 3;

  516.             default:

  517.                 break;

  518.         }

  519. 

  520.         return 0;

  521.     }

  522. 

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

  524.     {

  525.         String outputPath;

  526.         if (config.getTargetBinaryRelativePathString().isNotEmpty())

  527.         {

  528.             RelativePath binaryPath (config.getTargetBinaryRelativePathString(), RelativePath::projectFolder);

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

  530.             outputPath = config.getTargetBinaryRelativePathString();

  531.         }

  532.         else

  533.         {

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

  535.         }

  536. 

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

  538.     }

  539. 

  540.     String getSharedCodePath (const BuildConfiguration& config) const

  541.     {

  542.         const String outputPath = getOutputPathForTarget (getTargetWithType (ProjectType::Target::SharedCodeTarget), config);

  543.         RelativePath path (outputPath, RelativePath::buildTargetFolder);

  544.         auto filename = path.getFileName();

  545. 

  546.         if (isLinux())

  547.             filename = "lib" + filename;

  548. 

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

  550.     }

  551. 

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

  553.     {

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

  555. 

  556.         {

  557.             XmlElement* output = xml.createNewChildElement ("Option");

  558. 

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

  560. 

  561.             if (isLinux())

  562.             {

  563.                 const bool keepPrefix = (target.type == ProjectType::Target::VSTPlugIn || target.type == ProjectType::Target::VST3PlugIn

  564.                                       || target.type == ProjectType::Target::AAXPlugIn || target.type == ProjectType::Target::RTASPlugIn);

  565. 

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

  567.             }

  568.             else

  569.             {

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

  571.             }

  572. 

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

  574.         }

  575. 

  576.         xml.createNewChildElement ("Option")

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

  578. 

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

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

  581. 

  582.         if (getProject().getProjectType().isAudioPlugin() && target.type != ProjectType::Target::SharedCodeTarget)

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

  584. 

  585.         {

  586.             XmlElement* const compiler = xml.createNewChildElement ("Compiler");

  587. 

  588.             {

  589.                 StringArray flags;

  590. 

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

  592.                 {

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

  594.                             def << '=';

  595. 

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

  597.                 }

  598. 

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

  600. 

  601.                 for (auto flag : flags)

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

  603.             }

  604. 

  605.             {

  606.                 const StringArray includePaths (getIncludePaths (config));

  607. 

  608.                 for (auto path : includePaths)

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

  610.             }

  611.         }

  612. 

  613.         {

  614.             XmlElement* const linker = xml.createNewChildElement ("Linker");

  615. 

  616.             if (getProject().getProjectType().isAudioPlugin() && target.type != ProjectType::Target::SharedCodeTarget)

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

  618. 

  619.             const StringArray linkerFlags (getLinkerFlags (config, target));

  620. 

  621.             for (auto flag : linkerFlags)

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

  623. 

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

  625. 

  626.             for (auto lib : libs)

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

  628. 

  629.             StringArray librarySearchPaths (config.getLibrarySearchPaths());

  630. 

  631.             if (getProject().getProjectType().isAudioPlugin() && target.type != ProjectType::Target::SharedCodeTarget)

  632.                 librarySearchPaths.add (RelativePath (getSharedCodePath (config), RelativePath::buildTargetFolder).getParentDirectory().toUnixStyle());

  633. 

  634.             for (auto path : librarySearchPaths)

  635.                 setAddOption (*linker, "directory", replacePreprocessorDefs (getAllPreprocessorDefs(), path));

  636.         }

  637.     }

  638. 

  639.     void addBuild (XmlElement& xml) const

  640.     {

  641.         XmlElement* const build = xml.createNewChildElement ("Build");

  642. 

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

  644.             for (auto target : targets)

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

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

  647.     }

  648. 

  649.     void addVirtualTargets (XmlElement& xml) const

  650.     {

  651.         XmlElement* const virtualTargets = xml.createNewChildElement ("VirtualTargets");

  652. 

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

  654.         {

  655.             StringArray allTargets;

  656. 

  657.             for (auto target : targets)

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

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

  660. 

  661.             for (auto target : targets)

  662.             {

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

  664.                 {

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

  666. 

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

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

  669.                 }

  670.             }

  671.         }

  672.     }

  673. 

  674.     StringArray getProjectCompilerOptions() const

  675.     {

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

  677.     }

  678. 

  679.     void addProjectCompilerOptions (XmlElement& xml) const

  680.     {

  681.         XmlElement* const compiler = xml.createNewChildElement ("Compiler");

  682. 

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

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

  685.     }

  686. 

  687.     StringArray getProjectLinkerLibs() const

  688.     {

  689.         StringArray result;

  690. 

  691.         if (isWindows())

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

  693. 

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

  695. 

  696.         result = getCleanedStringArray (result);

  697. 

  698.         for (auto& option : result)

  699.             option = replacePreprocessorDefs (getAllPreprocessorDefs(), option);

  700. 

  701.         return result;

  702.     }

  703. 

  704.     void addProjectLinkerOptions (XmlElement& xml) const

  705.     {

  706.         XmlElement* const linker = xml.createNewChildElement ("Linker");

  707. 

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

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

  710.     }

  711. 

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

  713.     {

  714.         CodeBlocksTarget* nonAggregrateTarget = nullptr;

  715. 

  716.         for (auto* target : targets)

  717.         {

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

  719.                 return *target;

  720. 

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

  722.                 nonAggregrateTarget = target;

  723.         }

  724. 

  725.         // this project has no valid targets

  726.         jassert (nonAggregrateTarget != nullptr);

  727. 

  728.         return *nonAggregrateTarget;

  729.     }

  730. 

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

  732.     // the single target

  733.     CodeBlocksTarget& getMainTarget() const

  734.     {

  735.         if (getProject().getProjectType().isAudioPlugin())

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

  737. 

  738.         for (auto* target : targets)

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

  740.                 return *target;

  741. 

  742.         jassertfalse;

  743. 

  744.         return *targets[0];

  745.     }

  746. 

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

  748.     {

  749.         if (getProject().getProjectType().isAudioPlugin())

  750.         {

  751.             if (! projectItem.shouldBeCompiled())

  752.                 return getTargetWithType (ProjectType::Target::SharedCodeTarget);

  753. 

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

  755.         }

  756. 

  757.         return getMainTarget();

  758.     }

  759. 

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

  761.     {

  762.         if (projectItem.isGroup())

  763.         {

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

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

  766.         }

  767.         else if (projectItem.shouldBeAddedToTargetProject())

  768.         {

  769.             const RelativePath file (projectItem.getFile(), getTargetFolder(), RelativePath::buildTargetFolder);

  770. 

  771.             XmlElement* unit = xml.createNewChildElement ("Unit");

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

  773. 

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

  775.             {

  776.                 const String& targetName = getTargetForProjectItem (projectItem).getTargetNameForConfiguration (*config);

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

  778.             }

  779. 

  780.             if (! projectItem.shouldBeCompiled())

  781.             {

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

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

  784.             }

  785.         }

  786.     }

  787. 

  788.     void addCompileUnits (XmlElement& xml) const

  789.     {

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

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

  792.     }

  793. 

  794.     void createProject (XmlElement& xml) const

  795.     {

  796.         addOptions (xml);

  797.         addBuild (xml);

  798.         addVirtualTargets (xml);

  799.         addProjectCompilerOptions (xml);

  800.         addProjectLinkerOptions (xml);

  801.         addCompileUnits (xml);

  802.     }

  803. 

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

  805.     {

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

  807.     }

  808. 

  809.     CodeBlocksOS os;

  810. 

  811.     OwnedArray<CodeBlocksTarget> targets;

  812. 

  813.     friend class CLionProjectExporter;

  814. 

  815.     JUCE_DECLARE_NON_COPYABLE (CodeBlocksProjectExporter)

  816. };