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

855 lines
31KB
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& props) override

  141.     {

  142.         if (isWindows())

  143.         {

  144.             StringArray toolsetNames = { "(default)", "Windows NT 4.0", "Windows 2000", "Windows XP", "Windows Server 2003", "Windows Vista", "Windows Server 2008", "Windows 7", "Windows 8", "Windows 8.1", "Windows 10" };

  145.             Array<var> toolsets      = { var(),       "0x0400",         "0x0500",       "0x0501",     "0x0502",              "0x0600",         "0x0600",             "0x0601",    "0x0602",    "0x0603",      "0x0A00" };

  146.             props.add (new ChoicePropertyComponent (getTargetPlatformValue(), "Target platform", toolsetNames, toolsets),

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

  148.         }

  149.     }

  150. 

  151.     //==============================================================================

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

  153.     {

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

  155.                                              .withFileExtension (".cbp"));

  156. 

  157.         XmlElement xml ("CodeBlocks_project_file");

  158.         addVersion (xml);

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

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

  161.     }

  162. 

  163.     //==============================================================================

  164.     void addPlatformSpecificSettingsForProjectType (const ProjectType&) override

  165.     {

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

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

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

  169. 

  170.         //ProjectType::Target::SharedCodeTarget

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

  172.                                     {

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

  174.                                             return;

  175. 

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

  177.                                         {

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

  179.                                                 targets.insert (0, target);

  180.                                             else

  181.                                                 targets.add (target);

  182.                                         }

  183.                                     });

  184. 

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

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

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

  188.     }

  189. 

  190.     //==============================================================================

  191.     void initialiseDependencyPathValues() override

  192.     {

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

  194.                                             : TargetOS::windows;

  195. 

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

  197. 

  198.         if (! isLinux())

  199.         {

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

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

  202.         }

  203.     }

  204. 

  205. private:

  206.     Value getTargetPlatformValue()                { return getSetting (Ids::codeBlocksWindowsTarget); }

  207.     String getTargetPlatform() const              { return settings [Ids::codeBlocksWindowsTarget].toString(); }

  208. 

  209.     //==============================================================================

  210.     class CodeBlocksBuildConfiguration  : public BuildConfiguration

  211.     {

  212.     public:

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

  214.             : BuildConfiguration (p, settings, e)

  215.         {

  216.             if (getArchitectureType().toString().isEmpty())

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

  218.         }

  219. 

  220.         Value getArchitectureType()

  221.         {

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

  223.                                                      : Ids::linuxCodeBlocksArchitecture;

  224.             return getValue (archID);

  225.         }

  226. 

  227.         var getArchitectureTypeVar() const

  228.         {

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

  230.                                                      : Ids::linuxCodeBlocksArchitecture;

  231.             return config [archID];

  232.         }

  233. 

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

  235. 

  236.         void createConfigProperties (PropertyListBuilder& props) override

  237.         {

  238.             addGCCOptimisationProperty (props);

  239. 

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

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

  242. 

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

  244.                                                     StringArray (archNames, numElementsInArray (archNames)),

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

  246.         }

  247. 

  248.         String getModuleLibraryArchName() const override

  249.         {

  250.             const String archFlag = getArchitectureTypeVar();

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

  252. 

  253.             if (archFlag.startsWith (prefix))

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

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

  256.                 return "x86_64";

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

  258.                 return "i386";

  259. 

  260.             jassertfalse;

  261.             return {};

  262.         }

  263.     };

  264. 

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

  266.     {

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

  268.     }

  269. 

  270.     //==============================================================================

  271.     class CodeBlocksTarget : public ProjectType::Target

  272.     {

  273.     public:

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

  275.             : ProjectType::Target (typeToUse),

  276.               exporter (e)

  277.         {}

  278. 

  279.         String getTargetNameForConfiguration (const BuildConfiguration& config) const

  280.         {

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

  282.                 return config.getName();

  283. 

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

  285.         }

  286. 

  287.         String getTargetSuffix() const

  288.         {

  289.             auto fileType = getTargetFileType();

  290. 

  291.             if (exporter.isWindows())

  292.             {

  293.                 switch (fileType)

  294.                 {

  295.                     case executable:            return ".exe";

  296.                     case staticLibrary:         return ".lib";

  297.                     case sharedLibraryOrDLL:

  298.                     case pluginBundle:          return ".dll";

  299.                     default:

  300.                         break;

  301.                 }

  302.             }

  303.             else

  304.             {

  305.                 switch (fileType)

  306.                 {

  307.                     case executable:            return {};

  308.                     case staticLibrary:         return ".a";

  309.                     case sharedLibraryOrDLL:    return ".so";

  310. 

  311.                     case pluginBundle:

  312.                         switch (type)

  313.                         {

  314.                             case VST3PlugIn:    return ".vst3";

  315.                             case VSTPlugIn:     return ".so";

  316.                             default:            break;

  317.                         }

  318. 

  319.                         return ".so";

  320. 

  321.                     default:

  322.                         break;

  323.                 }

  324.             }

  325. 

  326.             return {};

  327.         }

  328. 

  329.         bool isDynamicLibrary() const

  330.         {

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

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

  333.         }

  334. 

  335.         const CodeBlocksProjectExporter& exporter;

  336.     };

  337. 

  338.     //==============================================================================

  339. 

  340.     StringArray getPackages() const

  341.     {

  342.         StringArray result (linuxPackages);

  343. 

  344.         static String guiExtrasModule ("juce_gui_extra");

  345. 

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

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

  348.         {

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

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

  351.         }

  352. 

  353.         result.removeDuplicates (false);

  354. 

  355.         return result;

  356.     }

  357. 

  358.     void addVersion (XmlElement& xml) const

  359.     {

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

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

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

  363.     }

  364. 

  365.     void addOptions (XmlElement& xml) const

  366.     {

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

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

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

  370.     }

  371. 

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

  373.     {

  374.         StringPairArray defines;

  375. 

  376.         if (isWindows())

  377.         {

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

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

  380. 

  381.             auto targetPlatform = getTargetPlatform();

  382. 

  383.             if (targetPlatform.isNotEmpty())

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

  385.         }

  386.         else

  387.         {

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

  389.         }

  390. 

  391.         if (config.isDebug())

  392.         {

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

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

  395.         }

  396.         else

  397.         {

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

  399.         }

  400. 

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

  402. 

  403.         StringArray defs;

  404.         const auto keys = defines.getAllKeys();

  405.         const auto values = defines.getAllValues();

  406. 

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

  408.         {

  409.             auto result = keys[i];

  410. 

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

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

  413. 

  414.             defs.add (result);

  415.         }

  416. 

  417.         return getCleanedStringArray (defs);

  418.     }

  419. 

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

  421.     {

  422.         StringArray flags;

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

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

  425. 

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

  427. 

  428.         if (config.isLinkTimeOptimisationEnabled())

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

  430. 

  431.         {

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

  433. 

  434.             if (cppStandard == "latest")

  435.                 cppStandard = "1z";

  436. 

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

  438. 

  439.             flags.add (cppStandard);

  440.         }

  441. 

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

  443. 

  444.         if (config.isDebug())

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

  446. 

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

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

  449. 

  450.         if (config.exporter.isLinux())

  451.         {

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

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

  454. 

  455.             const auto packages = getPackages();

  456. 

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

  458.             {

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

  460.                 for (auto p : packages)

  461.                     pkgconfigFlags << " " << p;

  462. 

  463.                 pkgconfigFlags << "`";

  464.                 flags.add (pkgconfigFlags);

  465.             }

  466. 

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

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

  469.         }

  470. 

  471.         return getCleanedStringArray (flags);

  472.     }

  473. 

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

  475.     {

  476.         StringArray flags (makefileExtraLinkerFlags);

  477. 

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

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

  480. 

  481.         if (! config.isDebug())

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

  483. 

  484.         if (config.isLinkTimeOptimisationEnabled())

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

  486. 

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

  488. 

  489.         const auto packages = getPackages();

  490. 

  491.         if (config.exporter.isLinux())

  492.         {

  493.             if (target.isDynamicLibrary())

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

  495. 

  496.             if (target.type == ProjectType::Target::StandalonePlugIn

  497.              || target.type == ProjectType::Target::GUIApp)

  498.                 flags.add ("-no-pie");

  499. 

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

  501.             {

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

  503. 

  504.                 for (auto p : packages)

  505.                     pkgconfigLibs << " " << p;

  506. 

  507.                 pkgconfigLibs << "`";

  508.                 flags.add (pkgconfigLibs);

  509.             }

  510.         }

  511. 

  512.         return getCleanedStringArray (flags);

  513.     }

  514. 

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

  516.     {

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

  518. 

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

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

  521. 

  522.         return librarySearchPaths;

  523.     }

  524. 

  525.     StringArray getIncludePaths (const BuildConfiguration& config) const

  526.     {

  527.         StringArray paths;

  528. 

  529.         paths.add (".");

  530.         paths.addArray (extraSearchPaths);

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

  532. 

  533.         if (! isWindows())

  534.         {

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

  536. 

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

  538.             for (auto& path : paths)

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

  540.         }

  541. 

  542.         return getCleanedStringArray (paths);

  543.     }

  544. 

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

  546.     {

  547.         switch (type)

  548.         {

  549.             case ProjectType::Target::GUIApp:

  550.             case ProjectType::Target::StandalonePlugIn:

  551.                 return 0;

  552.             case ProjectType::Target::ConsoleApp:

  553.                 return 1;

  554.             case ProjectType::Target::StaticLibrary:

  555.             case ProjectType::Target::SharedCodeTarget:

  556.                 return 2;

  557.             case ProjectType::Target::DynamicLibrary:

  558.             case ProjectType::Target::VSTPlugIn:

  559.             case ProjectType::Target::VST3PlugIn:

  560.                 return 3;

  561.             default:

  562.                 break;

  563.         }

  564. 

  565.         return 0;

  566.     }

  567. 

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

  569.     {

  570.         String outputPath;

  571.         if (config.getTargetBinaryRelativePathString().isNotEmpty())

  572.         {

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

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

  575.             outputPath = config.getTargetBinaryRelativePathString();

  576.         }

  577.         else

  578.         {

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

  580.         }

  581. 

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

  583.     }

  584. 

  585.     String getSharedCodePath (const BuildConfiguration& config) const

  586.     {

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

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

  589.         auto filename = path.getFileName();

  590. 

  591.         if (isLinux())

  592.             filename = "lib" + filename;

  593. 

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

  595.     }

  596. 

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

  598.     {

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

  600. 

  601.         {

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

  603. 

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

  605. 

  606.             if (isLinux())

  607.             {

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

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

  610. 

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

  612.             }

  613.             else

  614.             {

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

  616.             }

  617. 

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

  619.         }

  620. 

  621.         xml.createNewChildElement ("Option")

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

  623. 

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

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

  626. 

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

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

  629. 

  630.         {

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

  632. 

  633.             {

  634.                 StringArray flags;

  635. 

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

  637.                 {

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

  639.                             def << '=';

  640. 

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

  642.                 }

  643. 

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

  645. 

  646.                 for (auto flag : flags)

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

  648.             }

  649. 

  650.             {

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

  652. 

  653.                 for (auto path : includePaths)

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

  655.             }

  656.         }

  657. 

  658.         {

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

  660. 

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

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

  663. 

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

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

  666. 

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

  668. 

  669.             for (auto lib : libs)

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

  671. 

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

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

  674.         }

  675.     }

  676. 

  677.     void addBuild (XmlElement& xml) const

  678.     {

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

  680. 

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

  682.             for (auto target : targets)

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

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

  685.     }

  686. 

  687.     void addVirtualTargets (XmlElement& xml) const

  688.     {

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

  690. 

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

  692.         {

  693.             StringArray allTargets;

  694. 

  695.             for (auto target : targets)

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

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

  698. 

  699.             for (auto target : targets)

  700.             {

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

  702.                 {

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

  704. 

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

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

  707.                 }

  708.             }

  709.         }

  710.     }

  711. 

  712.     StringArray getProjectCompilerOptions() const

  713.     {

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

  715.     }

  716. 

  717.     void addProjectCompilerOptions (XmlElement& xml) const

  718.     {

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

  720. 

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

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

  723.     }

  724. 

  725.     StringArray getProjectLinkerLibs() const

  726.     {

  727.         StringArray result;

  728. 

  729.         if (isWindows())

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

  731. 

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

  733. 

  734.         result = getCleanedStringArray (result);

  735. 

  736.         for (auto& option : result)

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

  738. 

  739.         return result;

  740.     }

  741. 

  742.     void addProjectLinkerOptions (XmlElement& xml) const

  743.     {

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

  745. 

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

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

  748.     }

  749. 

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

  751.     {

  752.         CodeBlocksTarget* nonAggregrateTarget = nullptr;

  753. 

  754.         for (auto* target : targets)

  755.         {

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

  757.                 return *target;

  758. 

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

  760.                 nonAggregrateTarget = target;

  761.         }

  762. 

  763.         // this project has no valid targets

  764.         jassert (nonAggregrateTarget != nullptr);

  765. 

  766.         return *nonAggregrateTarget;

  767.     }

  768. 

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

  770.     // the single target

  771.     CodeBlocksTarget& getMainTarget() const

  772.     {

  773.         if (getProject().getProjectType().isAudioPlugin())

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

  775. 

  776.         for (auto* target : targets)

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

  778.                 return *target;

  779. 

  780.         jassertfalse;

  781. 

  782.         return *targets[0];

  783.     }

  784. 

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

  786.     {

  787.         if (getProject().getProjectType().isAudioPlugin())

  788.         {

  789.             if (! projectItem.shouldBeCompiled())

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

  791. 

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

  793.         }

  794. 

  795.         return getMainTarget();

  796.     }

  797. 

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

  799.     {

  800.         if (projectItem.isGroup())

  801.         {

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

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

  804.         }

  805.         else if (projectItem.shouldBeAddedToTargetProject())

  806.         {

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

  808. 

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

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

  811. 

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

  813.             {

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

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

  816.             }

  817. 

  818.             if (! projectItem.shouldBeCompiled())

  819.             {

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

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

  822.             }

  823.         }

  824.     }

  825. 

  826.     void addCompileUnits (XmlElement& xml) const

  827.     {

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

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

  830.     }

  831. 

  832.     void createProject (XmlElement& xml) const

  833.     {

  834.         addOptions (xml);

  835.         addBuild (xml);

  836.         addVirtualTargets (xml);

  837.         addProjectCompilerOptions (xml);

  838.         addProjectLinkerOptions (xml);

  839.         addCompileUnits (xml);

  840.     }

  841. 

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

  843.     {

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

  845.     }

  846. 

  847.     CodeBlocksOS os;

  848. 

  849.     OwnedArray<CodeBlocksTarget> targets;

  850. 

  851.     friend class CLionProjectExporter;

  852. 

  853.     JUCE_DECLARE_NON_COPYABLE (CodeBlocksProjectExporter)

  854. };