Added support for the Meson Build System

Author: eidheim

CMakeLists.txt

@@ -1,7 +1,7 @@
 cmake_minimum_required (VERSION 2.8.8)
 
 project(juci)
-set(JUCI_VERSION "1.2.2")
+set(JUCI_VERSION "1.2.2.1")
 
 set(CPACK_PACKAGE_NAME "jucipp")
 set(CPACK_PACKAGE_CONTACT "Ole Christian Eidheim <[email protected]>")

README.md

@@ -14,7 +14,9 @@ towards libclang with speed, stability, and ease of use in mind.
 * C++ warnings and errors on the fly
 * C++ Fix-its
 * Debug integration, both local and remote, through lldb
-* Automated CMake processing, including support for external libraries
+* Supports the following build systems:
+  * CMake
+  * Meson
 * Git support through libgit2
 * Fast C++ autocompletion
 * Keyword and buffer autocompletion for other file types

src/CMakeLists.txt

@@ -22,10 +22,12 @@ set(project_files
 #Files used both in ../src and ../tests
 set(project_shared_files
     cmake.cc
+    compile_commands.cc
     ctags.cc
     dispatcher.cc
     filesystem.cc
     git.cc
+    meson.cc
     project_build.cc
     source.cc
     source_clang.cc

src/cmake.cc

@@ -55,7 +55,7 @@ bool CMake::update_default_build(const boost::filesystem::path &default_build_pa
 
   auto compile_commands_path=default_build_path/"compile_commands.json";
   Dialog::Message message("Creating/updating default build");
-  auto exit_status=Terminal::get().process(Config::get().project.cmake_command+" "+
+  auto exit_status=Terminal::get().process(Config::get().project.cmake.command+' '+
                                            filesystem::escape_argument(project_path)+" -DCMAKE_EXPORT_COMPILE_COMMANDS=ON", default_build_path);
   message.hide();
   if(exit_status==EXIT_SUCCESS) {
@@ -102,7 +102,7 @@ bool CMake::update_debug_build(const boost::filesystem::path &debug_build_path,
     return true;
 
   Dialog::Message message("Creating/updating debug build");
-  auto exit_status=Terminal::get().process(Config::get().project.cmake_command+" "+
+  auto exit_status=Terminal::get().process(Config::get().project.cmake.command+' '+
                                            filesystem::escape_argument(project_path)+" -DCMAKE_BUILD_TYPE=Debug", debug_build_path);
   message.hide();
   if(exit_status==EXIT_SUCCESS)

src/cmake.h

@@ -9,15 +9,13 @@ class CMake {
 public:
   CMake(const boost::filesystem::path &path);
   boost::filesystem::path project_path;
-  std::vector<boost::filesystem::path> paths;
 
   bool update_default_build(const boost::filesystem::path &default_build_path, bool force=false);
   bool update_debug_build(const boost::filesystem::path &debug_build_path, bool force=false);
 
   boost::filesystem::path get_executable(const boost::filesystem::path &file_path);
-  
-  std::vector<std::pair<boost::filesystem::path, std::vector<std::string> > > get_functions_parameters(const std::string &name);
 private:
+  std::vector<boost::filesystem::path> paths;
   std::vector<std::string> files;
   std::unordered_map<std::string, std::string> variables;
   void read_files();
@@ -28,6 +26,7 @@ class CMake {
   void parse_variable_parameters(std::string &data);
   void parse();
   std::vector<std::string> get_function_parameters(std::string &data);
+  std::vector<std::pair<boost::filesystem::path, std::vector<std::string> > > get_functions_parameters(const std::string &name);
   bool parsed=false;
 };
 #endif //JUCI_CMAKE_H_

src/compile_commands.cc

@@ -0,0 +1,79 @@
+#include "compile_commands.h"
+#include <boost/property_tree/json_parser.hpp>
+
+std::vector<std::string> CompileCommands::Command::paramter_values(const std::string &paramter_name) const {
+  std::vector<std::string> parameter_values;
+  
+  bool found_argument=false;
+  for(auto &parameter: parameters) {
+    if(found_argument) {
+      parameter_values.emplace_back(parameter);
+      found_argument=false;
+    }
+    else if(parameter==paramter_name)
+      found_argument=true;
+  }
+  
+  return parameter_values;
+}
+
+CompileCommands::CompileCommands(const boost::filesystem::path &build_path) {
+  try {
+    boost::property_tree::ptree root_pt;
+    boost::property_tree::json_parser::read_json((build_path/"compile_commands.json").string(), root_pt);
+    
+    auto commands_pt=root_pt.get_child("");
+    for(auto &command: commands_pt) {
+      boost::filesystem::path directory=command.second.get<std::string>("directory");
+      auto parameters_str=command.second.get<std::string>("command");
+      boost::filesystem::path file=command.second.get<std::string>("file");
+      
+      std::vector<std::string> parameters;
+      bool backslash=false;
+      bool single_quote=false;
+      bool double_quote=false;
+      size_t parameter_start_pos=-1;
+      size_t parameter_size=0;
+      auto add_parameter=[&parameters, &parameters_str, &parameter_start_pos, &parameter_size] {
+        auto parameter=parameters_str.substr(parameter_start_pos, parameter_size);
+        // Remove escaping
+        for(size_t c=0;c<parameter.size()-1;++c) {
+          if(parameter[c]=='\\')
+            parameter.replace(c, 2, std::string()+parameter[c+1]);
+        }
+        parameters.emplace_back(parameter);
+      };
+      for(size_t c=0;c<parameters_str.size();++c) {
+        if(backslash)
+          backslash=false;
+        else if(parameters_str[c]=='\\')
+          backslash=true;
+        else if((parameters_str[c]==' ' || parameters_str[c]=='\t') && !backslash && !single_quote && !double_quote) {
+          if(parameter_start_pos!=static_cast<size_t>(-1)) {
+            add_parameter();
+            parameter_start_pos=-1;
+            parameter_size=0;
+          }
+          continue;
+        }
+        else if(parameters_str[c]=='\'' && !backslash && !double_quote) {
+          single_quote=!single_quote;
+          continue;
+        }
+        else if(parameters_str[c]=='\"' && !backslash && !single_quote) {
+          double_quote=!double_quote;
+          continue;
+        }
+        
+        if(parameter_start_pos==static_cast<size_t>(-1))
+          parameter_start_pos=c;
+        ++parameter_size;
+      }
+      if(parameter_start_pos!=static_cast<size_t>(-1))
+        add_parameter();
+      
+      commands.emplace_back(Command{directory, parameters, boost::filesystem::absolute(file, build_path)});
+    }
+  }
+  catch(...) {}
+}

src/compile_commands.h

@@ -0,0 +1,23 @@
+#ifndef JUCI_COMPILE_COMMANDS_H_
+#define JUCI_COMPILE_COMMANDS_H_
+
+#include <boost/filesystem.hpp>
+#include <vector>
+#include <string>
+
+class CompileCommands {
+public:
+  class Command {
+  public:
+    boost::filesystem::path directory;
+    std::vector<std::string> parameters;
+    boost::filesystem::path file;
+    
+    std::vector<std::string> paramter_values(const std::string &parameter_name) const;
+  };
+  
+  CompileCommands(const boost::filesystem::path &build_path);
+  std::vector<Command> commands;
+};
+
+#endif // JUCI_COMPILE_COMMANDS_H_

src/config.cc

@@ -90,8 +90,10 @@ void Config::retrieve_config() {
 
   project.default_build_path=cfg.get<std::string>("project.default_build_path");
   project.debug_build_path=cfg.get<std::string>("project.debug_build_path");
-  project.make_command=cfg.get<std::string>("project.make_command");
-  project.cmake_command=cfg.get<std::string>("project.cmake_command");
+  project.cmake.command=cfg.get<std::string>("project.cmake.command");
+  project.cmake.compile_command=cfg.get<std::string>("project.cmake.compile_command");
+  project.meson.command=cfg.get<std::string>("project.meson.command");
+  project.meson.compile_command=cfg.get<std::string>("project.meson.compile_command");
   project.save_on_compile_or_run=cfg.get<bool>("project.save_on_compile_or_run");
   project.clear_terminal_on_compile=cfg.get<bool>("project.clear_terminal_on_compile");
   project.ctags_command=cfg.get<std::string>("project.ctags_command");

src/config.h

@@ -36,10 +36,21 @@ class Config {
 
   class Project {
   public:
+    class CMake {
+    public:
+      std::string command;
+      std::string compile_command;
+    };
+    class Meson {
+    public:
+      std::string command;
+      std::string compile_command;
+    };
+    
     std::string default_build_path;
     std::string debug_build_path;
-    std::string cmake_command;
-    std::string make_command;
+    CMake cmake;
+    Meson meson;
     bool save_on_compile_or_run;
     bool clear_terminal_on_compile;
     std::string ctags_command;

src/files.h

@@ -156,16 +156,29 @@ R"RAW(
         "default_build_path_comment": "Use <project_directory_name> to insert the project top level directory name",
         "default_build_path": "./build",
         "debug_build_path_comment": "Use <project_directory_name> to insert the project top level directory name, and <default_build_path> to insert your default_build_path setting.",
-        "debug_build_path": "<default_build_path>/debug",)RAW"
+        "debug_build_path": "<default_build_path>/debug",
+        "cmake": {)RAW"
 #ifdef _WIN32
 R"RAW(
-        "cmake_command": "cmake -G\"MSYS Makefiles\"",)RAW"
+            "command": "cmake -G\"MSYS Makefiles\"",)RAW"
 #else
 R"RAW(
-        "cmake_command": "cmake",)RAW"
+            "command": "cmake",)RAW"
 #endif
 R"RAW(
-        "make_command": "cmake --build .",
+            "compile_command": "cmake --build ."
+        },
+        "meson": {)RAW"
+#ifdef __APPLE__
+R"RAW(
+            "command": "meson.py",)RAW"
+#else
+R"RAW(
+            "command": "meson",)RAW"
+#endif
+R"RAW(
+            "compile_command": "ninja"
+        },
         "save_on_compile_or_run": true,
         "clear_terminal_on_compile": true,
         "ctags_command": "ctags"