Merge branch 'devel' into master

rizsotto · rizsotto · commit cdc70573fbd0 · 2020-11-22T19:10:07.000+11:00
diff --git a/CMakeLists.txt b/CMakeLists.txt
@@ -2,7 +2,7 @@ cmake_minimum_required(VERSION 3.12 FATAL_ERROR)
 cmake_policy(VERSION 3.12)
 
 project(Bear
-        VERSION 3.0.2
+        VERSION 3.0.3
         DESCRIPTION "Bear is a tool to generate compilation database for clang tooling."
         LANGUAGES C CXX
         )
diff --git a/source/CMakeLists.txt b/source/CMakeLists.txt
@@ -65,11 +65,10 @@ include(GNUInstallDirs) # The directory names are used in the config file
 configure_file(config.h.in ${CMAKE_CURRENT_BINARY_DIR}/config.h)
 include_directories(${CMAKE_CURRENT_BINARY_DIR})
 
-add_subdirectory(bear)
-add_subdirectory(citnames)
 add_subdirectory(libresult)
 add_subdirectory(libflags)
-add_subdirectory(libreport)
 add_subdirectory(libshell)
 add_subdirectory(libsys)
 add_subdirectory(intercept)
+add_subdirectory(citnames)
+add_subdirectory(bear)
diff --git a/source/citnames/source/Application.cc b/source/citnames/source/Application.cc
@@ -21,8 +21,7 @@
 #include "Configuration.h"
 #include "Output.h"
 #include "semantic/Tool.h"
-
-#include "libreport/Report.h"
+#include "intercept/output/Report.h"
 
 #include <filesystem>
 
diff --git a/source/citnames/source/Output.cc b/source/citnames/source/Output.cc
@@ -23,6 +23,7 @@
 #include <algorithm>
 #include <iomanip>
 #include <fstream>
+#include <set>
 
 #include <fmt/format.h>
 #include <nlohmann/json.hpp>
@@ -63,29 +64,27 @@ namespace {
         };
     }
 
-    using Comparator = std::function<bool(const cs::Entry &lhs, const cs::Entry &rhs)>;
+    using Hash = std::function<std::string(const cs::Entry &entry)>;
 
-    bool compare_by_output(const cs::Entry &lhs, const cs::Entry &rhs) {
-        // compare entries by the source and the output attribute only.
-        return (lhs.file == rhs.file) && (lhs.output == rhs.output);
+    std::string hash_by_output(const cs::Entry &entry) {
+        return fmt::format("{}<->{}",
+                           entry.file.string(),
+                           entry.output.value_or(fs::path()).string());
     }
 
-    bool compare_by_all(const cs::Entry &lhs, const cs::Entry &rhs) {
-        // compare entries by all possible attributes except the output field.
-        return (lhs.file == rhs.file)
-               && (lhs.directory == rhs.directory)
-               && (std::equal(
-                std::next(lhs.arguments.begin()),
-                lhs.arguments.end(),
-                std::next(rhs.arguments.begin())));
+    std::string hash_by_all(const cs::Entry &entry) {
+        return fmt::format("{}<->{}<->{}",
+                           entry.file.string(),
+                           entry.directory.string(),
+                           fmt::join(std::next(entry.arguments.begin()), entry.arguments.end(), ","));
     }
 
-    Comparator select_comparator(const cs::Entries &lhs, const cs::Entries &rhs) {
-        // Select comparator based on the input values.
+    Hash select_hash(const cs::Entries &lhs, const cs::Entries &rhs) {
+        // Select hash function based on the input values.
         const bool lhs_outputs = std::all_of(lhs.begin(), lhs.end(), [](auto entry) { return entry.output; });
         const bool rhs_outputs = std::all_of(rhs.begin(), rhs.end(), [](auto entry) { return entry.output; });
         // if all entries have the output field, it can compare by the output field.
-        return (lhs_outputs && rhs_outputs) ? compare_by_output : compare_by_all;
+        return (lhs_outputs && rhs_outputs) ? hash_by_output : hash_by_all;
     }
 }
 
@@ -239,14 +238,24 @@ namespace cs {
     Entries merge(const Entries &lhs, const Entries &rhs) {
         Entries result;
         // create a predicate which decides if the entry is already in the result.
-        auto comparator = select_comparator(lhs, rhs);
-        auto not_in_result = [&result, &comparator](const auto &it) {
-            return std::none_of(result.begin(), result.end(),
-                                [&comparator, &it](const auto &already_in) { return comparator(already_in, it); });
-        };
-        // apply the predicate.
-        std::copy_if(lhs.begin(), lhs.end(), std::back_inserter(result), not_in_result);
-        std::copy_if(rhs.begin(), rhs.end(), std::back_inserter(result), not_in_result);
+        auto hasher = select_hash(lhs, rhs);
+        std::set<std::string> in_results_hashes;
+        // copy the elements into the result list depending if it already there.
+        for (const auto &entry : lhs) {
+            auto hash = hasher(entry);
+            if (in_results_hashes.find(hash) == in_results_hashes.end()) {
+                in_results_hashes.insert(hash);
+                result.push_back(entry);
+            }
+        }
+        for (const auto &entry : rhs) {
+            auto hash = hasher(entry);
+            if (in_results_hashes.find(hash) == in_results_hashes.end()) {
+                in_results_hashes.insert(hash);
+                result.push_back(entry);
+            }
+        }
+
         return result;
     }
 
diff --git a/source/citnames/source/semantic/Parsers.h b/source/citnames/source/semantic/Parsers.h
@@ -19,7 +19,7 @@
 
 #pragma once
 
-#include "libreport/Report.h"
+#include "intercept/output/Report.h"
 #include "libresult/Result.h"
 
 #include <cstdint>
diff --git a/source/citnames/source/semantic/Semantic.h b/source/citnames/source/semantic/Semantic.h
@@ -20,7 +20,7 @@
 #pragma once
 
 #include "Output.h"
-#include "libreport/Report.h"
+#include "intercept/output/Report.h"
 
 #include <filesystem>
 #include <list>
diff --git a/source/citnames/source/semantic/Tool.h b/source/citnames/source/semantic/Tool.h
@@ -23,7 +23,7 @@
 #include "Output.h"
 #include "semantic/Semantic.h"
 #include "libresult/Result.h"
-#include "libreport/Report.h"
+#include "intercept/output/Report.h"
 
 #include <filesystem>
 #include <list>
diff --git a/source/intercept/CMakeLists.txt b/source/intercept/CMakeLists.txt
@@ -2,6 +2,16 @@ add_subdirectory(proto)
 
 include(GNUInstallDirs)
 
+add_library(report_a OBJECT
+        source/collect/Report.cc
+        )
+
+target_include_directories(report_a PUBLIC include)
+target_link_libraries(report_a PUBLIC result_a)
+target_link_libraries(report_a PRIVATE fmt::fmt)
+target_link_libraries(report_a PRIVATE nlohmann_json::nlohmann_json)
+target_compile_options(report_a PRIVATE -fexceptions)
+
 # Create a static library, which is used for unit tests and the final shared library.
 add_library(intercept_a OBJECT
         source/collect/Application.cc
@@ -54,6 +64,7 @@ install(FILES man/intercept.1
 # Create unit test
 if (ENABLE_UNIT_TESTS)
     add_executable(intercept_unit_test
+            test/ReportTest.cc
             test/ReporterTest.cc
             test/SessionTest.cc
             )
diff --git a/source/intercept/include/intercept/output/Report.h b/source/intercept/include/intercept/output/Report.h
diff --git a/source/intercept/source/collect/Report.cc b/source/intercept/source/collect/Report.cc
@@ -17,7 +17,7 @@
     along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-#include "libreport/Report.h"
+#include "intercept/output/Report.h"
 
 #include <iomanip>
 #include <fstream>
diff --git a/source/intercept/source/collect/Reporter.h b/source/intercept/source/collect/Reporter.h
@@ -21,7 +21,7 @@
 
 #include "collect/Session.h"
 #include "libflags/Flags.h"
-#include "libreport/Report.h"
+#include "intercept/output/Report.h"
 #include "libresult/Result.h"
 #include "supervise.pb.h"
 
diff --git a/source/intercept/source/collect/Session.cc b/source/intercept/source/collect/Session.cc
@@ -41,7 +41,7 @@ namespace ic {
     }
 #else
     {
-        return WrapperSession::from(args, std::move(environment));
+        return WrapperSession::from(args, envp);
     }
 #endif
 
diff --git a/source/intercept/source/report/libexec/Logger.cc b/source/intercept/source/report/libexec/Logger.cc
@@ -30,14 +30,14 @@ namespace {
     void verbose_message(char const* name, char const* message, char const* variable)
     {
         struct timespec ts { 0, 0 };
-        if (clock_gettime(CLOCK_REALTIME, &ts) == -1) {
+        if (::clock_gettime(CLOCK_REALTIME, &ts) == -1) {
             // ignore failure, default values will be good
         }
         struct tm local_time {};
-        localtime_r(&ts.tv_sec, &local_time);
+        ::localtime_r(&ts.tv_sec, &local_time);
         const unsigned long micros = ts.tv_nsec / 1000;
-        const pid_t pid = getpid();
-        dprintf(STDERR_FILENO, "[%02d:%02d:%02d.%06ld, el, %d] %s; %s%s\n",
+        const pid_t pid = ::getpid();
+        ::dprintf(STDERR_FILENO, "[%02d:%02d:%02d.%06ld, el, %d] %s; %s%s\n",
             local_time.tm_hour, local_time.tm_min, local_time.tm_sec, micros, pid, name, message, variable);
     }
 }
diff --git a/source/intercept/source/report/libexec/Resolver.cc b/source/intercept/source/report/libexec/Resolver.cc
@@ -46,16 +46,16 @@ namespace el {
 
     rust::Result<const char*, int> Resolver::from_current_directory(std::string_view const &file) {
         // create absolute path to the given file.
-        if (nullptr == realpath(file.begin(), result_)) {
+        if (nullptr == ::realpath(file.begin(), result_)) {
             return rust::Err(ENOENT);
         }
         // check if it's okay to execute.
-        if (0 == access(result_, X_OK)) {
+        if (0 == ::access(result_, X_OK)) {
             const char *ptr = result_;
             return rust::Ok(ptr);
         }
         // try to set a meaningful error value.
-        if (0 == access(result_, F_OK)) {
+        if (0 == ::access(result_, F_OK)) {
             return rust::Err(EACCES);
         }
         return rust::Err(ENOENT);
@@ -75,7 +75,7 @@ namespace el {
             const size_t search_path_length = confstr(_CS_PATH, nullptr, 0);
             if (search_path_length != 0) {
                 char search_path[search_path_length];
-                if (confstr(_CS_PATH, search_path, search_path_length) != 0) {
+                if (::confstr(_CS_PATH, search_path, search_path_length) != 0) {
                     return from_search_path(file, search_path);
                 }
             }
diff --git a/source/intercept/source/report/supervisor/Application.cc b/source/intercept/source/report/supervisor/Application.cc
@@ -91,7 +91,11 @@ namespace er {
                 return sys::Process::Builder(execution.command)
                     .add_arguments(execution.arguments.begin(), execution.arguments.end())
                     .set_environment(execution.environment)
+#ifdef SUPPORT_PRELOAD
                     .spawn_with_preload()
+#else
+                    .spawn()
+#endif
                     .on_success([&client, &event_factory, &execution](auto& child) {
                         auto event = event_factory.start(child.get_pid(), getppid(), execution);
                         client.report(std::move(event));
diff --git a/source/intercept/test/ReportTest.cc b/source/intercept/test/ReportTest.cc
@@ -19,7 +19,7 @@
 
 #include "gtest/gtest.h"
 
-#include "libreport/Report.h"
+#include "intercept/output/Report.h"
 
 #include <iostream>
 #include <sstream>
diff --git a/source/libreport/CMakeLists.txt b/source/libreport/CMakeLists.txt
diff --git a/source/libsys/source/Errors.cc b/source/libsys/source/Errors.cc
@@ -34,11 +34,11 @@ namespace sys {
 #ifdef HAVE_STRERROR_R
 #if defined(__GLIBC__) && defined(_GNU_SOURCE)
         char buffer[256];
-        char* result = strerror_r(error, buffer, 255);
+        char* result = ::strerror_r(error, buffer, 255);
         return std::string(result);
 #else
         char buffer[256];
-        strerror_r(error, buffer, 255);
+        ::strerror_r(error, buffer, 255);
         return std::string(buffer);
 #endif
 #else
diff --git a/source/libsys/source/Os.cc b/source/libsys/source/Os.cc
@@ -41,9 +41,9 @@ namespace sys::os {
     {
 #ifdef HAVE_CONFSTR
         errno = 0;
-        if (const size_t buffer_size = confstr(key, nullptr, 0); buffer_size != 0) {
+        if (const size_t buffer_size = ::confstr(key, nullptr, 0); buffer_size != 0) {
             char buffer[buffer_size];
-            if (const size_t size = confstr(key, buffer, buffer_size); size != 0) {
+            if (const size_t size = ::confstr(key, buffer, buffer_size); size != 0) {
                 return rust::Ok(std::string(buffer));
             }
         }
@@ -61,7 +61,7 @@ namespace sys::os {
         std::map<std::string, std::string> result;
 #ifdef HAVE_UNAME
         auto name = utsname {};
-        if (const int status = uname(&name); status >= 0) {
+        if (const int status = ::uname(&name); status >= 0) {
             result.insert({ "sysname", std::string(name.sysname) });
             result.insert({ "release", std::string(name.release) });
             result.insert({ "version", std::string(name.version) });
@@ -88,4 +88,4 @@ namespace sys::os {
         return rust::Err(std::runtime_error("Could not find PATH in environment."));
 #endif
     }
-}
+}
diff --git a/source/libsys/source/Process.cc b/source/libsys/source/Process.cc
diff --git a/source/libsys/source/Signal.cc b/source/libsys/source/Signal.cc
diff --git a/third_party/fmt/CMakeLists.txt b/third_party/fmt/CMakeLists.txt
diff --git a/third_party/grpc/CMakeLists.txt b/third_party/grpc/CMakeLists.txt

Original file line number	Diff line number	Diff line change
`@@ -2,7 +2,7 @@ cmake_minimum_required(VERSION 3.12 FATAL_ERROR)`
`2`	`2`	`cmake_policy(VERSION 3.12)`
`3`	`3`
`4`	`4`	`project(Bear`
`5`		`- VERSION 3.0.2`
	`5`	`+ VERSION 3.0.3`
`6`	`6`	`DESCRIPTION "Bear is a tool to generate compilation database for clang tooling."`
`7`	`7`	`LANGUAGES C CXX`
`8`	`8`	`)`