From 0b2cbb74009c73b2132937e7a8e80197933ffcf1 Mon Sep 17 00:00:00 2001 From: m Date: Tue, 11 Sep 2018 15:05:15 +0200 Subject: [PATCH 1/6] Move all configuration handling to a new CPP unit --- src/CMakeLists.txt | 2 + src/cache.cpp | 64 ++---------- src/cache.hpp | 12 --- src/configuration.cpp | 237 ++++++++++++++++++++++++++++++++++++++++++ src/configuration.hpp | 69 ++++++++++++ src/debug_utils.cpp | 30 ++---- src/main.cpp | 159 +++++++++++++++------------- src/perf_utils.cpp | 13 +-- src/perf_utils.hpp | 19 ++-- src/sys_utils.cpp | 9 +- 10 files changed, 429 insertions(+), 185 deletions(-) create mode 100644 src/configuration.cpp create mode 100644 src/configuration.hpp diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt index acbfccf..c28a5c6 100644 --- a/src/CMakeLists.txt +++ b/src/CMakeLists.txt @@ -34,6 +34,8 @@ add_subdirectory(third_party) add_executable(buildcache cache.cpp cache.hpp + configuration.cpp + configuration.hpp debug_utils.cpp debug_utils.hpp file_utils.cpp diff --git a/src/cache.cpp b/src/cache.cpp index e3cf292..2c021a1 100644 --- a/src/cache.cpp +++ b/src/cache.cpp @@ -46,6 +46,7 @@ #include "cache.hpp" +#include "configuration.hpp" #include "debug_utils.hpp" #include "file_utils.hpp" #include "serializer_utils.hpp" @@ -58,40 +59,13 @@ namespace bcache { namespace { -const int64_t DEFAULT_MAX_CACHE_SIZE_IN_BYTES = 5368709120L; // 5 GB - -const std::string ROOT_FOLDER_NAME = ".buildcache"; const std::string TEMP_FOLDER_NAME = "tmp"; const std::string CACHE_FILES_FOLDER_NAME = "c"; - -const std::string CONFIGURATION_FILE_NAME = "buildcache.conf"; const std::string CACHE_ENTRY_FILE_NAME = ".entry"; // The version of the entry file serialization data format. const int32_t ENTRY_DATA_FORMAT_VERSION = 1; -std::string find_root_folder() { - // Is the environment variable BUILDCACHE_DIR defined? - { - const auto* buildcache_dir_env = std::getenv("BUILDCACHE_DIR"); - if (buildcache_dir_env != nullptr) { - return std::string(buildcache_dir_env); - } - } - - // Use the user home directory if possible. - { - auto home = file::get_user_home_dir(); - if (!home.empty()) { - // TODO(m): Should use ".cache/buildcache". - return file::append_path(home, ROOT_FOLDER_NAME); - } - } - - // We failed. - throw std::runtime_error("Unable to determine a home directory for BuildCache."); -} - bool is_cache_entry_dir_path(const std::string& path) { const auto entry_dir_name = file::get_file_part(path); const auto hash_prefix_dir_name = file::get_file_part(file::get_dir_part(path)); @@ -179,22 +153,17 @@ cache_t::entry_t deserialize_entry(const std::string& data) { } // namespace cache_t::cache_t() { - // Find the cache root folder. - m_root_folder = find_root_folder(); - // Can we use the cache? - if (!file::dir_exists(m_root_folder)) { - file::create_dir(m_root_folder); + if (!file::dir_exists(config::dir())) { + file::create_dir(config::dir()); } - - load_config(); } cache_t::~cache_t() { } const std::string cache_t::get_tmp_folder() const { - const auto tmp_path = file::append_path(m_root_folder, TEMP_FOLDER_NAME); + const auto tmp_path = file::append_path(config::dir(), TEMP_FOLDER_NAME); if (!file::dir_exists(tmp_path)) { file::create_dir(tmp_path); } @@ -202,7 +171,7 @@ const std::string cache_t::get_tmp_folder() const { } const std::string cache_t::get_cache_files_folder() const { - const auto cache_files_path = file::append_path(m_root_folder, CACHE_FILES_FOLDER_NAME); + const auto cache_files_path = file::append_path(config::dir(), CACHE_FILES_FOLDER_NAME); if (!file::dir_exists(cache_files_path)) { file::create_dir(cache_files_path); } @@ -217,7 +186,7 @@ const std::string cache_t::hash_to_cache_entry_path(const hasher_t::hash_t& hash void cache_t::clear() { // Remove all cached files. - const auto cache_files_path = file::append_path(m_root_folder, CACHE_FILES_FOLDER_NAME); + const auto cache_files_path = file::append_path(config::dir(), CACHE_FILES_FOLDER_NAME); try { file::remove_dir(cache_files_path, true); std::cout << "Cleared the cache.\n"; @@ -228,7 +197,7 @@ void cache_t::clear() { void cache_t::show_stats() { // Calculate the total cache size. - const auto dirs = get_cache_entry_dirs(m_root_folder); + const auto dirs = get_cache_entry_dirs(config::dir()); int num_entries = 0; int64_t total_size = 0; for (const auto& dir : dirs) { @@ -236,9 +205,9 @@ void cache_t::show_stats() { total_size += dir.size(); } const double total_size_mb = static_cast(total_size) / (1024.0 * 1024.0); - const double max_size_mb = static_cast(m_max_size) / (1024.0 * 1024.0); + const double max_size_mb = static_cast(config::max_cache_size()) / (1024.0 * 1024.0); - std::cout << "cache directory: " << m_root_folder << "\n"; + std::cout << "cache directory: " << config::dir() << "\n"; // std::cout << "primary config: " << get_configuration_file_name() << "\n"; std::cout << "entries in cache: " << num_entries << "\n"; std::cout << "cache size: " << total_size_mb << " MB\n"; @@ -303,24 +272,13 @@ cache_t::entry_t cache_t::lookup(const hasher_t::hash_t& hash) { } } -void cache_t::load_config() { - // Set default values. - m_max_size = DEFAULT_MAX_CACHE_SIZE_IN_BYTES; - - // TODO(m): Load settings from a config file! -} - -void cache_t::save_config() { - // TODO(m): Save settings to a config file! -} - void cache_t::perform_housekeeping() { const auto start_t = std::chrono::high_resolution_clock::now(); debug::log(debug::INFO) << "Performing housekeeping."; // Get all the cache entry directories. - auto dirs = get_cache_entry_dirs(m_root_folder); + auto dirs = get_cache_entry_dirs(config::dir()); // Sort the entries according to their access time (newest first). std::sort( @@ -335,7 +293,7 @@ void cache_t::perform_housekeeping() { for (const auto& dir : dirs) { num_entries++; total_size += dir.size(); - if (total_size > m_max_size) { + if (total_size > config::max_cache_size()) { try { debug::log(debug::DEBUG) << "Purging " << dir.path() << " (last accessed " << dir.access_time() << ", " << dir.size() << " bytes)"; diff --git a/src/cache.hpp b/src/cache.hpp index 10a4cdd..be525bb 100644 --- a/src/cache.hpp +++ b/src/cache.hpp @@ -51,12 +51,6 @@ public: /// @brief De-initialzie the cache object. ~cache_t(); - /// @brief Get the root folder of the cache. - /// @returns the path to the root folder. - const std::string& root_folder() const { - return m_root_folder; - } - /// @brief Clear all entries in the cache. void clear(); @@ -82,13 +76,7 @@ private: const std::string get_tmp_folder() const; const std::string get_cache_files_folder() const; - void load_config(); - void save_config(); - void perform_housekeeping(); - - std::string m_root_folder; - int64_t m_max_size; }; } // namespace bcache diff --git a/src/configuration.cpp b/src/configuration.cpp new file mode 100644 index 0000000..581b44e --- /dev/null +++ b/src/configuration.cpp @@ -0,0 +1,237 @@ +//-------------------------------------------------------------------------------------------------- +// Copyright (c) 2018 Marcus Geelnard +// +// This software is provided 'as-is', without any express or implied warranty. In no event will the +// authors be held liable for any damages arising from the use of this software. +// +// Permission is granted to anyone to use this software for any purpose, including commercial +// applications, and to alter it and redistribute it freely, subject to the following restrictions: +// +// 1. The origin of this software must not be misrepresented; you must not claim that you wrote +// the original software. If you use this software in a product, an acknowledgment in the +// product documentation would be appreciated but is not required. +// +// 2. Altered source versions must be plainly marked as such, and must not be misrepresented as +// being the original software. +// +// 3. This notice may not be removed or altered from any source distribution. +//-------------------------------------------------------------------------------------------------- + +#include "configuration.hpp" + +#include "file_utils.hpp" + +#include +#include + +namespace bcache { +namespace { +// Various constants. +const std::string ROOT_FOLDER_NAME = ".buildcache"; +const std::string CONFIGURATION_FILE_NAME = "buildcache.conf"; +const int64_t DEFAULT_MAX_CACHE_SIZE = 5368709120L; // 5 GB + +// Configuration options. +std::string s_dir; +string_list_t s_lua_paths; +std::string s_prefix; +int64_t s_max_cache_size = DEFAULT_MAX_CACHE_SIZE; +int32_t s_debug = -1; +bool s_perf = false; +bool s_disable = false; + +std::string to_lower(const std::string& str) { + std::string str_lower(str.size(), ' '); + std::transform(str.begin(), str.end(), str_lower.begin(), ::tolower); + return str_lower; +} + +/// @brief A helper class for reading and parsing environment variables. +class env_var_t { +public: + env_var_t(const std::string& name) : m_defined(false) { + const auto* env_var = std::getenv(name.c_str()); + if (env_var != nullptr) { + m_value = std::string(env_var); + m_defined = true; + } + } + + operator bool() const { + return m_defined; + } + + const std::string& as_string() const { + return m_value; + } + + const int64_t as_int64() const { + return std::stoll(m_value); + } + + const bool as_bool() const { + const auto value_lower = to_lower(m_value); + return m_defined && (!m_value.empty()) && (value_lower != "false") && (value_lower != "no") && + (value_lower != "off") && (value_lower != "0"); + } + +private: + std::string m_value; + bool m_defined; +}; + +std::string get_dir() { + // Is the environment variable BUILDCACHE_DIR defined? + { + const env_var_t dir_env("BUILDCACHE_DIR"); + if (dir_env) { + return dir_env.as_string(); + } + } + + // Use the user home directory if possible. + { + auto home = file::get_user_home_dir(); + if (!home.empty()) { + // TODO(m): Should use ".cache/buildcache". + return file::append_path(home, ROOT_FOLDER_NAME); + } + } + + // We failed. + throw std::runtime_error("Unable to determine a home directory for BuildCache."); +} + +string_list_t get_lua_paths(const std::string& dir) { + string_list_t paths; + + // The BUILDCACHE_LUA_PATH env variable can contain a colon-separated list of paths. + { + const env_var_t lua_path_env("BUILDCACHE_LUA_PATH"); + if (lua_path_env) { +#ifdef _WIN32 + paths += string_list_t(lua_path_env.as_string(), ";"); +#else + paths += string_list_t(lua_path_env.as_string(), ":"); +#endif + } + } + + // We also look for Lua files in the cache root dir (e.g. ${BUILDCACHE_DIR}/lua). + paths += file::append_path(dir, "lua"); + + return paths; +} + +} // namespace + +namespace config { +void init() { + // Guard: Only initialize once. + static bool s_initialized = false; + if (s_initialized) { + return; + } + s_initialized = true; + + try { + // Get the BuildCache home directory. + s_dir = get_dir(); + + // Get the Lua paths. + s_lua_paths = get_lua_paths(s_dir); + + // Get the command prefix from the environment. + { + const env_var_t prefix_env("BUILDCACHE_PREFIX"); + if (prefix_env) { + s_prefix = prefix_env.as_string(); + } + } + + // Get the max cache size from the environment. + { + const env_var_t max_cache_size_env("BUILDCACHE_MAX_CACHE_SIZE"); + if (max_cache_size_env) { + try { + s_max_cache_size = max_cache_size_env.as_int64(); + } catch (...) { + // Ignore... + } + } + } + + // Get the debug level from the environment. + { + const env_var_t debug_env("BUILDCACHE_DEBUG"); + if (debug_env) { + try { + s_debug = static_cast(debug_env.as_int64()); + } catch (...) { + // Ignore... + } + } + } + + // Get the perf flag from the environment. + { + const env_var_t perf_env("BUILDCACHE_PERF"); + if (perf_env) { + s_perf = perf_env.as_bool(); + } + } + + // Get the disabled flag from the environment. + { + const env_var_t disable_env("BUILDCACHE_DISABLE"); + if (disable_env) { + s_disable = disable_env.as_bool(); + } + } + } catch (...) { + // If we could not initialize the configuration, we can't proceed. We need to disable the cache. + s_disable = true; + } +} + +void update(const std::string& file_name) { + // TODO(m): Implement me! +} + +void update(const std::map& options) { + // TODO(m): Implement me! +} + +void save_to_file(const std::string& file_name) { + // TODO(m): Implement me! +} + +const std::string& dir() { + return s_dir; +} + +const string_list_t& lua_paths() { + return s_lua_paths; +} + +const std::string& prefix() { + return s_prefix; +} + +const int64_t max_cache_size() { + return s_max_cache_size; +} + +const int32_t debug() { + return s_debug; +} + +const bool perf() { + return s_perf; +} + +const bool disable() { + return s_disable; +} +} // namespace config +} // namespace bcache diff --git a/src/configuration.hpp b/src/configuration.hpp new file mode 100644 index 0000000..a81410f --- /dev/null +++ b/src/configuration.hpp @@ -0,0 +1,69 @@ +//-------------------------------------------------------------------------------------------------- +// Copyright (c) 2018 Marcus Geelnard +// +// This software is provided 'as-is', without any express or implied warranty. In no event will the +// authors be held liable for any damages arising from the use of this software. +// +// Permission is granted to anyone to use this software for any purpose, including commercial +// applications, and to alter it and redistribute it freely, subject to the following restrictions: +// +// 1. The origin of this software must not be misrepresented; you must not claim that you wrote +// the original software. If you use this software in a product, an acknowledgment in the +// product documentation would be appreciated but is not required. +// +// 2. Altered source versions must be plainly marked as such, and must not be misrepresented as +// being the original software. +// +// 3. This notice may not be removed or altered from any source distribution. +//-------------------------------------------------------------------------------------------------- + +#ifndef BUILDCACHE_CONFIGURATION_HPP_ +#define BUILDCACHE_CONFIGURATION_HPP_ + +#include +#include +#include + +#include "string_list.hpp" + +namespace bcache { +namespace config { +/// @brief Initialize the configuration based on environment variables etc. +void init(); + +/// @brief Update configuration options from the given file. +/// @param file_name The name of the file to load the options from. +void update(const std::string& file_name); + +/// @brief Update configuration options from a key-value options map. +/// @param options A key-value map containing the options. +void update(const std::map& options); + +/// @brief Save the configuration options object to a file. +void save_to_file(const std::string& file_name); + +/// @returns the BuildCache home directory. +const std::string& dir(); + +/// @returns the Lua search paths. +const string_list_t& lua_paths(); + +/// @returns the compiler exectution prefix command. +const std::string& prefix(); + +/// @returns the maximum cache size (in bytes). +const int64_t max_cache_size(); + +/// @returns the debug level (-1 for no debugging). +const int32_t debug(); + +/// @returns true if performance profiling output is enabled. +const bool perf(); + +/// @returns true if BuildCache is disabled. +const bool disable(); + +} // namespace config +} // namespace bcache + +#endif // BUILDCACHE_CONFIGURATION_HPP_ diff --git a/src/debug_utils.cpp b/src/debug_utils.cpp index bce7f76..6454d50 100644 --- a/src/debug_utils.cpp +++ b/src/debug_utils.cpp @@ -19,8 +19,8 @@ #include "debug_utils.hpp" -#include -#include +#include "configuration.hpp" + #include #include @@ -43,8 +43,6 @@ namespace bcache { namespace debug { namespace { -std::atomic_int s_log_level(-1); - std::string get_level_string(const log_level_t level) { switch (level) { case DEBUG: @@ -61,27 +59,11 @@ std::string get_level_string(const log_level_t level) { } log_level_t get_log_level() { - int log_level = s_log_level; + int log_level = config::debug(); - // The first time get_log_level() is called, s_log_level is undefined (negative). - if (log_level < 0) { - // Get the log level from the environment variable BUILDCACHE_DEBUG. - const auto* log_level_env = std::getenv("BUILDCACHE_DEBUG"); - if (log_level_env != nullptr) { - try { - log_level = std::stoi(std::string(log_level_env)); - } catch (...) { - } - if ((log_level < static_cast(DEBUG)) || (log_level > static_cast(FATAL))) { - log_level = -1; - } - } - - // If we did not get a valid log level, fall back to NONE (higher than the highest level). - if (log_level < 0) { - log_level = static_cast(NONE); - } - s_log_level = log_level; + // If we did not get a valid log level, fall back to NONE (higher than the highest level). + if ((log_level < static_cast(DEBUG)) || (log_level > static_cast(FATAL))) { + log_level = static_cast(NONE); } return static_cast(log_level); diff --git a/src/main.cpp b/src/main.cpp index 9db2763..f790224 100644 --- a/src/main.cpp +++ b/src/main.cpp @@ -18,6 +18,7 @@ //-------------------------------------------------------------------------------------------------- #include "cache.hpp" +#include "configuration.hpp" #include "debug_utils.hpp" #include "gcc_wrapper.hpp" #include "ghs_wrapper.hpp" @@ -38,27 +39,6 @@ namespace { // The name of the BuildCache executable (excluding the file extension). const std::string BUILDCACHE_EXE_NAME = "buildcache"; -bcache::string_list_t get_lua_paths(const bcache::cache_t& cache) { - bcache::string_list_t paths; - - // The BUILDCACHE_LUA_PATH env variable can contain a colon-separated list of paths. - { - const auto* lua_path_env = std::getenv("BUILDCACHE_LUA_PATH"); - if (lua_path_env != nullptr) { -#ifdef _WIN32 - paths += bcache::string_list_t(std::string(lua_path_env), ";"); -#else - paths += bcache::string_list_t(std::string(lua_path_env), ":"); -#endif - } - } - - // We also look for Lua files in the cache root dir (e.g. ${BUILDCACHE_DIR}/lua). - paths += bcache::file::append_path(cache.root_folder(), "lua"); - - return paths; -} - bool is_lua_script(const std::string& script_path) { return (bcache::lower_case(bcache::file::get_extension(script_path)) == ".lua"); } @@ -71,7 +51,7 @@ std::unique_ptr find_suitable_wrapper(const bcache::s // Try Lua wrappers first (so you can override internal wrappers). // Iterate over the existing Lua paths. - for (const auto& lua_root_dir : get_lua_paths(cache)) { + for (const auto& lua_root_dir : bcache::config::lua_paths()) { if (bcache::file::dir_exists(lua_root_dir)) { // Find all .lua files in the given directory. const auto lua_files = bcache::file::walk_directory(lua_root_dir); @@ -81,13 +61,12 @@ std::unique_ptr find_suitable_wrapper(const bcache::s // Check if the given wrapper can handle this command (first match wins). wrapper.reset(new bcache::lua_wrapper_t(args, cache, script_path)); if (wrapper->can_handle_command()) { - bcache::debug::log(bcache::debug::DEBUG) - << "Found matching Lua wrapper for " << true_exe_path << ": " << script_path; + bcache::debug::log(bcache::debug::DEBUG) << "Found matching Lua wrapper for " + << true_exe_path << ": " << script_path; break; } else { wrapper = nullptr; } - } } } @@ -132,7 +111,31 @@ std::unique_ptr find_suitable_wrapper(const bcache::s int return_code = 0; try { bcache::cache_t cache; + + // Print the cache stats. + std::cout << "Cache status:\n"; cache.show_stats(); + + { +// Print the configuration. +#ifdef _WIN32 + const std::string PATH_SEP = ";"; +#else + const std::string PATH_SEP = ":"; +#endif + + std::cout << "\nConfiguration:\n"; + std::cout << " BUILDCACHE_DIR: " << bcache::config::dir() << "\n"; + std::cout << " BUILDCACHE_LUA_PATH: " + << bcache::config::lua_paths().join(PATH_SEP, false) << "\n"; + std::cout << " BUILDCACHE_PREFIX: " << bcache::config::prefix() << "\n"; + std::cout << " BUILDCACHE_MAX_CACHE_SIZE: " << bcache::config::max_cache_size() << "\n"; + std::cout << " BUILDCACHE_DEBUG: " << bcache::config::debug() << "\n"; + std::cout << " BUILDCACHE_PERF: " << (bcache::config::perf() ? "true" : "false") + << "\n"; + std::cout << " BUILDCACHE_DISABLE: " << (bcache::config::disable() ? "true" : "false") + << "\n"; + } } catch (const std::exception& e) { std::cerr << "*** Unexpected error: " << e.what() << "\n"; return_code = 1; @@ -144,7 +147,7 @@ std::unique_ptr find_suitable_wrapper(const bcache::s } [[noreturn]] void print_version_and_exit() { - std::cout << "BuildCache version 0.2-dev\n"; + std::cout << "BuildCache version 0.3-dev\n"; std::exit(0); } @@ -175,52 +178,59 @@ std::unique_ptr find_suitable_wrapper(const bcache::s throw std::runtime_error("Missing arguments."); } - // Find the true path to the executable file. This affects things like if we can match the - // compiler name or not, and what version string we get. We also want to avoid incorrectly - // identifying other compiler accelerators (e.g. ccache) as actual compilers. - // TODO(m): This call may throw an excepption, which currently means that we will not even try - // to run the original command. At the same time this is a protection against endless symlink - // recursion. Figure something out! - PERF_START(FIND_EXECUTABLE); - const auto true_exe_path = bcache::file::find_executable(args[0], BUILDCACHE_EXE_NAME); - PERF_STOP(FIND_EXECUTABLE); - - // Replace the command with the true exe path. Most of the following operations rely on having - // a correct executable path. Also, this is important to avoid recursions when we are invoked - // from a symlink, for instance. - args[0] = true_exe_path; - - try { - return_code = 1; - - // Initialize a cache object. - bcache::cache_t cache; - - // Select a matching compiler wrapper. - PERF_START(FIND_WRAPPER); - auto wrapper = find_suitable_wrapper(args, cache); - PERF_STOP(FIND_WRAPPER); - - // Run the wrapper, if any. - if (wrapper) { - was_wrapped = wrapper->handle_command(return_code); - } else { - bcache::debug::log(bcache::debug::INFO) << "No suitable wrapper for " << true_exe_path; - } - } catch (const std::exception& e) { - bcache::debug::log(bcache::debug::ERROR) << "Unexpected error: " << e.what(); - return_code = 1; - } catch (...) { - bcache::debug::log(bcache::debug::ERROR) << "Unexpected error."; - return_code = 1; - } - - // Fall back to running the command as is. - if (!was_wrapped) { - PERF_START(RUN_FOR_FALLBACK); - auto result = bcache::sys::run_with_prefix(args, false); - PERF_STOP(RUN_FOR_FALLBACK); + // Is the caching mechanism disabled? + if (bcache::config::disable()) { + // Bypass all the cache logic and call the intended command directly. + auto result = bcache::sys::run(args, false); return_code = result.return_code; + } else { + // Find the true path to the executable file. This affects things like if we can match the + // compiler name or not, and what version string we get. We also want to avoid incorrectly + // identifying other compiler accelerators (e.g. ccache) as actual compilers. + // TODO(m): This call may throw an exception, which currently means that we will not even try + // to run the original command. At the same time this is a protection against endless symlink + // recursion. Figure something out! + PERF_START(FIND_EXECUTABLE); + const auto true_exe_path = bcache::file::find_executable(args[0], BUILDCACHE_EXE_NAME); + PERF_STOP(FIND_EXECUTABLE); + + // Replace the command with the true exe path. Most of the following operations rely on having + // a correct executable path. Also, this is important to avoid recursions when we are invoked + // from a symlink, for instance. + args[0] = true_exe_path; + + try { + return_code = 1; + + // Initialize a cache object. + bcache::cache_t cache; + + // Select a matching compiler wrapper. + PERF_START(FIND_WRAPPER); + auto wrapper = find_suitable_wrapper(args, cache); + PERF_STOP(FIND_WRAPPER); + + // Run the wrapper, if any. + if (wrapper) { + was_wrapped = wrapper->handle_command(return_code); + } else { + bcache::debug::log(bcache::debug::INFO) << "No suitable wrapper for " << true_exe_path; + } + } catch (const std::exception& e) { + bcache::debug::log(bcache::debug::ERROR) << "Unexpected error: " << e.what(); + return_code = 1; + } catch (...) { + bcache::debug::log(bcache::debug::ERROR) << "Unexpected error."; + return_code = 1; + } + + // Fall back to running the command as is. + if (!was_wrapped) { + PERF_START(RUN_FOR_FALLBACK); + auto result = bcache::sys::run_with_prefix(args, false); + PERF_STOP(RUN_FOR_FALLBACK); + return_code = result.return_code; + } } } catch (const std::exception& e) { bcache::debug::log(bcache::debug::FATAL) << "Unexpected error: " << e.what(); @@ -231,7 +241,9 @@ std::unique_ptr find_suitable_wrapper(const bcache::s } // Report performance timings. - bcache::perf::report(); + if (!bcache::config::disable()) { + bcache::perf::report(); + } std::exit(return_code); } @@ -260,6 +272,9 @@ void print_help(const char* program_name) { } // namespace int main(int argc, const char** argv) { + // Initialize the configuration. + bcache::config::init(); + // Handle symlink invokation. if (bcache::file::get_file_part(std::string(argv[0]), false) != BUILDCACHE_EXE_NAME) { bcache::debug::log(bcache::debug::DEBUG) << "Invoked as symlink: " << argv[0]; diff --git a/src/perf_utils.cpp b/src/perf_utils.cpp index 44b93e1..2c523c3 100644 --- a/src/perf_utils.cpp +++ b/src/perf_utils.cpp @@ -19,6 +19,7 @@ #include "perf_utils.hpp" +#include "configuration.hpp" #include "unicode_utils.hpp" #include @@ -36,15 +37,6 @@ int64_t get_time_in_us() { .count(); return t; } - -bool is_perf_enabled() { - const auto* perf_env = std::getenv("BUILDCACHE_PERF"); - if (perf_env == nullptr) { - return false; - } - const auto perf = lower_case(std::string(perf_env)); - return (perf != "no") && (perf != "off") && (perf != "false"); -} } // namespace int64_t start() { @@ -57,12 +49,13 @@ void stop(const int64_t start_time, const id_t id) { } void report() { - if (is_perf_enabled()) { + if (config::perf()) { std::cerr << "Find exectuable: " << s_perf_log[ID_FIND_EXECUTABLE] << " us\n"; std::cerr << "Find wrapper: " << s_perf_log[ID_FIND_WRAPPER] << " us\n"; std::cerr << "Lua - Init: " << s_perf_log[ID_LUA_INIT] << " us\n"; std::cerr << "Lua - Load script: " << s_perf_log[ID_LUA_LOAD_SCRIPT] << " us\n"; std::cerr << "Lua - Run: " << s_perf_log[ID_LUA_RUN] << " us\n"; + std::cerr << "Get wrapper config: " << s_perf_log[ID_GET_WRAPPER_CONFIG] << " us\n"; std::cerr << "Resolve args: " << s_perf_log[ID_RESOLVE_ARGS] << " us\n"; std::cerr << "Preprocess: " << s_perf_log[ID_PREPROCESS] << " us\n"; std::cerr << "Filter arguments: " << s_perf_log[ID_FILTER_ARGS] << " us\n"; diff --git a/src/perf_utils.hpp b/src/perf_utils.hpp index 22e1edd..e0d3068 100644 --- a/src/perf_utils.hpp +++ b/src/perf_utils.hpp @@ -30,15 +30,16 @@ enum id_t { ID_LUA_INIT = 2, ID_LUA_LOAD_SCRIPT = 3, ID_LUA_RUN = 4, - ID_RESOLVE_ARGS = 5, - ID_PREPROCESS = 6, - ID_FILTER_ARGS = 7, - ID_GET_PRG_ID = 8, - ID_CACHE_LOOKUP = 9, - ID_GET_BUILD_FILES = 10, - ID_RUN_FOR_MISS = 11, - ID_ADD_TO_CACHE = 12, - ID_RUN_FOR_FALLBACK = 13, + ID_GET_WRAPPER_CONFIG = 5, + ID_RESOLVE_ARGS = 6, + ID_PREPROCESS = 7, + ID_FILTER_ARGS = 8, + ID_GET_PRG_ID = 9, + ID_CACHE_LOOKUP = 10, + ID_GET_BUILD_FILES = 11, + ID_RUN_FOR_MISS = 12, + ID_ADD_TO_CACHE = 13, + ID_RUN_FOR_FALLBACK = 14, NUM_PERF_IDS }; diff --git a/src/sys_utils.cpp b/src/sys_utils.cpp index 611cf1e..b2c75e8 100644 --- a/src/sys_utils.cpp +++ b/src/sys_utils.cpp @@ -19,6 +19,7 @@ #include "sys_utils.hpp" +#include "configuration.hpp" #include "debug_utils.hpp" #include "file_utils.hpp" #include "unicode_utils.hpp" @@ -266,13 +267,11 @@ run_result_t run_with_prefix(const string_list_t& args, const bool quiet) { // Prepend the argument list with a prefix, if any. bool is_icecc_prefix = false; string_list_t prefixed_args; - const auto* prefix_env = std::getenv("BUILDCACHE_PREFIX"); - if (prefix_env != nullptr) { - const auto prefix_str = std::string(prefix_env); - prefixed_args += prefix_str; + if (!config::prefix().empty()) { + prefixed_args += config::prefix(); // Are we prefixed by ICECC? - is_icecc_prefix = (file::get_file_part(prefix_str, false) == "icecc"); + is_icecc_prefix = (file::get_file_part(config::prefix(), false) == "icecc"); } prefixed_args += args; From fb0da3a8ef939ee6eba0e9bce871f6073587c917 Mon Sep 17 00:00:00 2001 From: m Date: Tue, 11 Sep 2018 17:20:45 +0200 Subject: [PATCH 2/6] Add cJSON for reading/writing JSON files --- src/CMakeLists.txt | 2 +- src/third_party/CMakeLists.txt | 5 + src/third_party/cjson/LICENSE | 20 + src/third_party/cjson/cJSON.c | 2932 ++++++++++++++++++++++++++++++++ src/third_party/cjson/cJSON.h | 277 +++ 5 files changed, 3235 insertions(+), 1 deletion(-) create mode 100644 src/third_party/cjson/LICENSE create mode 100644 src/third_party/cjson/cJSON.c create mode 100644 src/third_party/cjson/cJSON.h diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt index c28a5c6..9748caf 100644 --- a/src/CMakeLists.txt +++ b/src/CMakeLists.txt @@ -63,7 +63,7 @@ add_executable(buildcache unicode_utils.cpp unicode_utils.hpp ) -target_link_libraries(buildcache md4 lua) +target_link_libraries(buildcache cjson md4 lua) if(WIN32 OR MINGW) target_link_libraries(buildcache userenv) diff --git a/src/third_party/CMakeLists.txt b/src/third_party/CMakeLists.txt index 2c806bf..1b1671a 100644 --- a/src/third_party/CMakeLists.txt +++ b/src/third_party/CMakeLists.txt @@ -22,6 +22,11 @@ if("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU" OR "${CMAKE_CXX_COMPILER_ID}" MATCH set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -w") endif() +add_library(cjson + cjson/cJSON.c + ) +target_include_directories(cjson INTERFACE .) + add_library(md4 md4/md4.c ) diff --git a/src/third_party/cjson/LICENSE b/src/third_party/cjson/LICENSE new file mode 100644 index 0000000..78deb04 --- /dev/null +++ b/src/third_party/cjson/LICENSE @@ -0,0 +1,20 @@ +Copyright (c) 2009-2017 Dave Gamble and cJSON contributors + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +THE SOFTWARE. + diff --git a/src/third_party/cjson/cJSON.c b/src/third_party/cjson/cJSON.c new file mode 100644 index 0000000..cbdec41 --- /dev/null +++ b/src/third_party/cjson/cJSON.c @@ -0,0 +1,2932 @@ +/* + Copyright (c) 2009-2017 Dave Gamble and cJSON contributors + + Permission is hereby granted, free of charge, to any person obtaining a copy + of this software and associated documentation files (the "Software"), to deal + in the Software without restriction, including without limitation the rights + to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + copies of the Software, and to permit persons to whom the Software is + furnished to do so, subject to the following conditions: + + The above copyright notice and this permission notice shall be included in + all copies or substantial portions of the Software. + + THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + THE SOFTWARE. +*/ + +/* cJSON */ +/* JSON parser in C. */ + +/* disable warnings about old C89 functions in MSVC */ +#if !defined(_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) +#define _CRT_SECURE_NO_DEPRECATE +#endif + +#ifdef __GNUC__ +#pragma GCC visibility push(default) +#endif +#if defined(_MSC_VER) +#pragma warning (push) +/* disable warning about single line comments in system headers */ +#pragma warning (disable : 4001) +#endif + +#include +#include +#include +#include +#include +#include + +#ifdef ENABLE_LOCALES +#include +#endif + +#if defined(_MSC_VER) +#pragma warning (pop) +#endif +#ifdef __GNUC__ +#pragma GCC visibility pop +#endif + +#include "cJSON.h" + +/* define our own boolean type */ +#define true ((cJSON_bool)1) +#define false ((cJSON_bool)0) + +typedef struct { + const unsigned char *json; + size_t position; +} error; +static error global_error = { NULL, 0 }; + +CJSON_PUBLIC(const char *) cJSON_GetErrorPtr(void) +{ + return (const char*) (global_error.json + global_error.position); +} + +CJSON_PUBLIC(char *) cJSON_GetStringValue(cJSON *item) { + if (!cJSON_IsString(item)) { + return NULL; + } + + return item->valuestring; +} + +/* This is a safeguard to prevent copy-pasters from using incompatible C and header files */ +#if (CJSON_VERSION_MAJOR != 1) || (CJSON_VERSION_MINOR != 7) || (CJSON_VERSION_PATCH != 7) + #error cJSON.h and cJSON.c have different versions. Make sure that both have the same. +#endif + +CJSON_PUBLIC(const char*) cJSON_Version(void) +{ + static char version[15]; + sprintf(version, "%i.%i.%i", CJSON_VERSION_MAJOR, CJSON_VERSION_MINOR, CJSON_VERSION_PATCH); + + return version; +} + +/* Case insensitive string comparison, doesn't consider two NULL pointers equal though */ +static int case_insensitive_strcmp(const unsigned char *string1, const unsigned char *string2) +{ + if ((string1 == NULL) || (string2 == NULL)) + { + return 1; + } + + if (string1 == string2) + { + return 0; + } + + for(; tolower(*string1) == tolower(*string2); (void)string1++, string2++) + { + if (*string1 == '\0') + { + return 0; + } + } + + return tolower(*string1) - tolower(*string2); +} + +typedef struct internal_hooks +{ + void *(*allocate)(size_t size); + void (*deallocate)(void *pointer); + void *(*reallocate)(void *pointer, size_t size); +} internal_hooks; + +#if defined(_MSC_VER) +/* work around MSVC error C2322: '...' address of dillimport '...' is not static */ +static void *internal_malloc(size_t size) +{ + return malloc(size); +} +static void internal_free(void *pointer) +{ + free(pointer); +} +static void *internal_realloc(void *pointer, size_t size) +{ + return realloc(pointer, size); +} +#else +#define internal_malloc malloc +#define internal_free free +#define internal_realloc realloc +#endif + +static internal_hooks global_hooks = { internal_malloc, internal_free, internal_realloc }; + +static unsigned char* cJSON_strdup(const unsigned char* string, const internal_hooks * const hooks) +{ + size_t length = 0; + unsigned char *copy = NULL; + + if (string == NULL) + { + return NULL; + } + + length = strlen((const char*)string) + sizeof(""); + copy = (unsigned char*)hooks->allocate(length); + if (copy == NULL) + { + return NULL; + } + memcpy(copy, string, length); + + return copy; +} + +CJSON_PUBLIC(void) cJSON_InitHooks(cJSON_Hooks* hooks) +{ + if (hooks == NULL) + { + /* Reset hooks */ + global_hooks.allocate = malloc; + global_hooks.deallocate = free; + global_hooks.reallocate = realloc; + return; + } + + global_hooks.allocate = malloc; + if (hooks->malloc_fn != NULL) + { + global_hooks.allocate = hooks->malloc_fn; + } + + global_hooks.deallocate = free; + if (hooks->free_fn != NULL) + { + global_hooks.deallocate = hooks->free_fn; + } + + /* use realloc only if both free and malloc are used */ + global_hooks.reallocate = NULL; + if ((global_hooks.allocate == malloc) && (global_hooks.deallocate == free)) + { + global_hooks.reallocate = realloc; + } +} + +/* Internal constructor. */ +static cJSON *cJSON_New_Item(const internal_hooks * const hooks) +{ + cJSON* node = (cJSON*)hooks->allocate(sizeof(cJSON)); + if (node) + { + memset(node, '\0', sizeof(cJSON)); + } + + return node; +} + +/* Delete a cJSON structure. */ +CJSON_PUBLIC(void) cJSON_Delete(cJSON *item) +{ + cJSON *next = NULL; + while (item != NULL) + { + next = item->next; + if (!(item->type & cJSON_IsReference) && (item->child != NULL)) + { + cJSON_Delete(item->child); + } + if (!(item->type & cJSON_IsReference) && (item->valuestring != NULL)) + { + global_hooks.deallocate(item->valuestring); + } + if (!(item->type & cJSON_StringIsConst) && (item->string != NULL)) + { + global_hooks.deallocate(item->string); + } + global_hooks.deallocate(item); + item = next; + } +} + +/* get the decimal point character of the current locale */ +static unsigned char get_decimal_point(void) +{ +#ifdef ENABLE_LOCALES + struct lconv *lconv = localeconv(); + return (unsigned char) lconv->decimal_point[0]; +#else + return '.'; +#endif +} + +typedef struct +{ + const unsigned char *content; + size_t length; + size_t offset; + size_t depth; /* How deeply nested (in arrays/objects) is the input at the current offset. */ + internal_hooks hooks; +} parse_buffer; + +/* check if the given size is left to read in a given parse buffer (starting with 1) */ +#define can_read(buffer, size) ((buffer != NULL) && (((buffer)->offset + size) <= (buffer)->length)) +/* check if the buffer can be accessed at the given index (starting with 0) */ +#define can_access_at_index(buffer, index) ((buffer != NULL) && (((buffer)->offset + index) < (buffer)->length)) +#define cannot_access_at_index(buffer, index) (!can_access_at_index(buffer, index)) +/* get a pointer to the buffer at the position */ +#define buffer_at_offset(buffer) ((buffer)->content + (buffer)->offset) + +/* Parse the input text to generate a number, and populate the result into item. */ +static cJSON_bool parse_number(cJSON * const item, parse_buffer * const input_buffer) +{ + double number = 0; + unsigned char *after_end = NULL; + unsigned char number_c_string[64]; + unsigned char decimal_point = get_decimal_point(); + size_t i = 0; + + if ((input_buffer == NULL) || (input_buffer->content == NULL)) + { + return false; + } + + /* copy the number into a temporary buffer and replace '.' with the decimal point + * of the current locale (for strtod) + * This also takes care of '\0' not necessarily being available for marking the end of the input */ + for (i = 0; (i < (sizeof(number_c_string) - 1)) && can_access_at_index(input_buffer, i); i++) + { + switch (buffer_at_offset(input_buffer)[i]) + { + case '0': + case '1': + case '2': + case '3': + case '4': + case '5': + case '6': + case '7': + case '8': + case '9': + case '+': + case '-': + case 'e': + case 'E': + number_c_string[i] = buffer_at_offset(input_buffer)[i]; + break; + + case '.': + number_c_string[i] = decimal_point; + break; + + default: + goto loop_end; + } + } +loop_end: + number_c_string[i] = '\0'; + + number = strtod((const char*)number_c_string, (char**)&after_end); + if (number_c_string == after_end) + { + return false; /* parse_error */ + } + + item->valuedouble = number; + + /* use saturation in case of overflow */ + if (number >= INT_MAX) + { + item->valueint = INT_MAX; + } + else if (number <= INT_MIN) + { + item->valueint = INT_MIN; + } + else + { + item->valueint = (int)number; + } + + item->type = cJSON_Number; + + input_buffer->offset += (size_t)(after_end - number_c_string); + return true; +} + +/* don't ask me, but the original cJSON_SetNumberValue returns an integer or double */ +CJSON_PUBLIC(double) cJSON_SetNumberHelper(cJSON *object, double number) +{ + if (number >= INT_MAX) + { + object->valueint = INT_MAX; + } + else if (number <= INT_MIN) + { + object->valueint = INT_MIN; + } + else + { + object->valueint = (int)number; + } + + return object->valuedouble = number; +} + +typedef struct +{ + unsigned char *buffer; + size_t length; + size_t offset; + size_t depth; /* current nesting depth (for formatted printing) */ + cJSON_bool noalloc; + cJSON_bool format; /* is this print a formatted print */ + internal_hooks hooks; +} printbuffer; + +/* realloc printbuffer if necessary to have at least "needed" bytes more */ +static unsigned char* ensure(printbuffer * const p, size_t needed) +{ + unsigned char *newbuffer = NULL; + size_t newsize = 0; + + if ((p == NULL) || (p->buffer == NULL)) + { + return NULL; + } + + if ((p->length > 0) && (p->offset >= p->length)) + { + /* make sure that offset is valid */ + return NULL; + } + + if (needed > INT_MAX) + { + /* sizes bigger than INT_MAX are currently not supported */ + return NULL; + } + + needed += p->offset + 1; + if (needed <= p->length) + { + return p->buffer + p->offset; + } + + if (p->noalloc) { + return NULL; + } + + /* calculate new buffer size */ + if (needed > (INT_MAX / 2)) + { + /* overflow of int, use INT_MAX if possible */ + if (needed <= INT_MAX) + { + newsize = INT_MAX; + } + else + { + return NULL; + } + } + else + { + newsize = needed * 2; + } + + if (p->hooks.reallocate != NULL) + { + /* reallocate with realloc if available */ + newbuffer = (unsigned char*)p->hooks.reallocate(p->buffer, newsize); + if (newbuffer == NULL) + { + p->hooks.deallocate(p->buffer); + p->length = 0; + p->buffer = NULL; + + return NULL; + } + } + else + { + /* otherwise reallocate manually */ + newbuffer = (unsigned char*)p->hooks.allocate(newsize); + if (!newbuffer) + { + p->hooks.deallocate(p->buffer); + p->length = 0; + p->buffer = NULL; + + return NULL; + } + if (newbuffer) + { + memcpy(newbuffer, p->buffer, p->offset + 1); + } + p->hooks.deallocate(p->buffer); + } + p->length = newsize; + p->buffer = newbuffer; + + return newbuffer + p->offset; +} + +/* calculate the new length of the string in a printbuffer and update the offset */ +static void update_offset(printbuffer * const buffer) +{ + const unsigned char *buffer_pointer = NULL; + if ((buffer == NULL) || (buffer->buffer == NULL)) + { + return; + } + buffer_pointer = buffer->buffer + buffer->offset; + + buffer->offset += strlen((const char*)buffer_pointer); +} + +/* Render the number nicely from the given item into a string. */ +static cJSON_bool print_number(const cJSON * const item, printbuffer * const output_buffer) +{ + unsigned char *output_pointer = NULL; + double d = item->valuedouble; + int length = 0; + size_t i = 0; + unsigned char number_buffer[26]; /* temporary buffer to print the number into */ + unsigned char decimal_point = get_decimal_point(); + double test; + + if (output_buffer == NULL) + { + return false; + } + + /* This checks for NaN and Infinity */ + if ((d * 0) != 0) + { + length = sprintf((char*)number_buffer, "null"); + } + else + { + /* Try 15 decimal places of precision to avoid nonsignificant nonzero digits */ + length = sprintf((char*)number_buffer, "%1.15g", d); + + /* Check whether the original double can be recovered */ + if ((sscanf((char*)number_buffer, "%lg", &test) != 1) || ((double)test != d)) + { + /* If not, print with 17 decimal places of precision */ + length = sprintf((char*)number_buffer, "%1.17g", d); + } + } + + /* sprintf failed or buffer overrun occured */ + if ((length < 0) || (length > (int)(sizeof(number_buffer) - 1))) + { + return false; + } + + /* reserve appropriate space in the output */ + output_pointer = ensure(output_buffer, (size_t)length + sizeof("")); + if (output_pointer == NULL) + { + return false; + } + + /* copy the printed number to the output and replace locale + * dependent decimal point with '.' */ + for (i = 0; i < ((size_t)length); i++) + { + if (number_buffer[i] == decimal_point) + { + output_pointer[i] = '.'; + continue; + } + + output_pointer[i] = number_buffer[i]; + } + output_pointer[i] = '\0'; + + output_buffer->offset += (size_t)length; + + return true; +} + +/* parse 4 digit hexadecimal number */ +static unsigned parse_hex4(const unsigned char * const input) +{ + unsigned int h = 0; + size_t i = 0; + + for (i = 0; i < 4; i++) + { + /* parse digit */ + if ((input[i] >= '0') && (input[i] <= '9')) + { + h += (unsigned int) input[i] - '0'; + } + else if ((input[i] >= 'A') && (input[i] <= 'F')) + { + h += (unsigned int) 10 + input[i] - 'A'; + } + else if ((input[i] >= 'a') && (input[i] <= 'f')) + { + h += (unsigned int) 10 + input[i] - 'a'; + } + else /* invalid */ + { + return 0; + } + + if (i < 3) + { + /* shift left to make place for the next nibble */ + h = h << 4; + } + } + + return h; +} + +/* converts a UTF-16 literal to UTF-8 + * A literal can be one or two sequences of the form \uXXXX */ +static unsigned char utf16_literal_to_utf8(const unsigned char * const input_pointer, const unsigned char * const input_end, unsigned char **output_pointer) +{ + long unsigned int codepoint = 0; + unsigned int first_code = 0; + const unsigned char *first_sequence = input_pointer; + unsigned char utf8_length = 0; + unsigned char utf8_position = 0; + unsigned char sequence_length = 0; + unsigned char first_byte_mark = 0; + + if ((input_end - first_sequence) < 6) + { + /* input ends unexpectedly */ + goto fail; + } + + /* get the first utf16 sequence */ + first_code = parse_hex4(first_sequence + 2); + + /* check that the code is valid */ + if (((first_code >= 0xDC00) && (first_code <= 0xDFFF))) + { + goto fail; + } + + /* UTF16 surrogate pair */ + if ((first_code >= 0xD800) && (first_code <= 0xDBFF)) + { + const unsigned char *second_sequence = first_sequence + 6; + unsigned int second_code = 0; + sequence_length = 12; /* \uXXXX\uXXXX */ + + if ((input_end - second_sequence) < 6) + { + /* input ends unexpectedly */ + goto fail; + } + + if ((second_sequence[0] != '\\') || (second_sequence[1] != 'u')) + { + /* missing second half of the surrogate pair */ + goto fail; + } + + /* get the second utf16 sequence */ + second_code = parse_hex4(second_sequence + 2); + /* check that the code is valid */ + if ((second_code < 0xDC00) || (second_code > 0xDFFF)) + { + /* invalid second half of the surrogate pair */ + goto fail; + } + + + /* calculate the unicode codepoint from the surrogate pair */ + codepoint = 0x10000 + (((first_code & 0x3FF) << 10) | (second_code & 0x3FF)); + } + else + { + sequence_length = 6; /* \uXXXX */ + codepoint = first_code; + } + + /* encode as UTF-8 + * takes at maximum 4 bytes to encode: + * 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx */ + if (codepoint < 0x80) + { + /* normal ascii, encoding 0xxxxxxx */ + utf8_length = 1; + } + else if (codepoint < 0x800) + { + /* two bytes, encoding 110xxxxx 10xxxxxx */ + utf8_length = 2; + first_byte_mark = 0xC0; /* 11000000 */ + } + else if (codepoint < 0x10000) + { + /* three bytes, encoding 1110xxxx 10xxxxxx 10xxxxxx */ + utf8_length = 3; + first_byte_mark = 0xE0; /* 11100000 */ + } + else if (codepoint <= 0x10FFFF) + { + /* four bytes, encoding 1110xxxx 10xxxxxx 10xxxxxx 10xxxxxx */ + utf8_length = 4; + first_byte_mark = 0xF0; /* 11110000 */ + } + else + { + /* invalid unicode codepoint */ + goto fail; + } + + /* encode as utf8 */ + for (utf8_position = (unsigned char)(utf8_length - 1); utf8_position > 0; utf8_position--) + { + /* 10xxxxxx */ + (*output_pointer)[utf8_position] = (unsigned char)((codepoint | 0x80) & 0xBF); + codepoint >>= 6; + } + /* encode first byte */ + if (utf8_length > 1) + { + (*output_pointer)[0] = (unsigned char)((codepoint | first_byte_mark) & 0xFF); + } + else + { + (*output_pointer)[0] = (unsigned char)(codepoint & 0x7F); + } + + *output_pointer += utf8_length; + + return sequence_length; + +fail: + return 0; +} + +/* Parse the input text into an unescaped cinput, and populate item. */ +static cJSON_bool parse_string(cJSON * const item, parse_buffer * const input_buffer) +{ + const unsigned char *input_pointer = buffer_at_offset(input_buffer) + 1; + const unsigned char *input_end = buffer_at_offset(input_buffer) + 1; + unsigned char *output_pointer = NULL; + unsigned char *output = NULL; + + /* not a string */ + if (buffer_at_offset(input_buffer)[0] != '\"') + { + goto fail; + } + + { + /* calculate approximate size of the output (overestimate) */ + size_t allocation_length = 0; + size_t skipped_bytes = 0; + while (((size_t)(input_end - input_buffer->content) < input_buffer->length) && (*input_end != '\"')) + { + /* is escape sequence */ + if (input_end[0] == '\\') + { + if ((size_t)(input_end + 1 - input_buffer->content) >= input_buffer->length) + { + /* prevent buffer overflow when last input character is a backslash */ + goto fail; + } + skipped_bytes++; + input_end++; + } + input_end++; + } + if (((size_t)(input_end - input_buffer->content) >= input_buffer->length) || (*input_end != '\"')) + { + goto fail; /* string ended unexpectedly */ + } + + /* This is at most how much we need for the output */ + allocation_length = (size_t) (input_end - buffer_at_offset(input_buffer)) - skipped_bytes; + output = (unsigned char*)input_buffer->hooks.allocate(allocation_length + sizeof("")); + if (output == NULL) + { + goto fail; /* allocation failure */ + } + } + + output_pointer = output; + /* loop through the string literal */ + while (input_pointer < input_end) + { + if (*input_pointer != '\\') + { + *output_pointer++ = *input_pointer++; + } + /* escape sequence */ + else + { + unsigned char sequence_length = 2; + if ((input_end - input_pointer) < 1) + { + goto fail; + } + + switch (input_pointer[1]) + { + case 'b': + *output_pointer++ = '\b'; + break; + case 'f': + *output_pointer++ = '\f'; + break; + case 'n': + *output_pointer++ = '\n'; + break; + case 'r': + *output_pointer++ = '\r'; + break; + case 't': + *output_pointer++ = '\t'; + break; + case '\"': + case '\\': + case '/': + *output_pointer++ = input_pointer[1]; + break; + + /* UTF-16 literal */ + case 'u': + sequence_length = utf16_literal_to_utf8(input_pointer, input_end, &output_pointer); + if (sequence_length == 0) + { + /* failed to convert UTF16-literal to UTF-8 */ + goto fail; + } + break; + + default: + goto fail; + } + input_pointer += sequence_length; + } + } + + /* zero terminate the output */ + *output_pointer = '\0'; + + item->type = cJSON_String; + item->valuestring = (char*)output; + + input_buffer->offset = (size_t) (input_end - input_buffer->content); + input_buffer->offset++; + + return true; + +fail: + if (output != NULL) + { + input_buffer->hooks.deallocate(output); + } + + if (input_pointer != NULL) + { + input_buffer->offset = (size_t)(input_pointer - input_buffer->content); + } + + return false; +} + +/* Render the cstring provided to an escaped version that can be printed. */ +static cJSON_bool print_string_ptr(const unsigned char * const input, printbuffer * const output_buffer) +{ + const unsigned char *input_pointer = NULL; + unsigned char *output = NULL; + unsigned char *output_pointer = NULL; + size_t output_length = 0; + /* numbers of additional characters needed for escaping */ + size_t escape_characters = 0; + + if (output_buffer == NULL) + { + return false; + } + + /* empty string */ + if (input == NULL) + { + output = ensure(output_buffer, sizeof("\"\"")); + if (output == NULL) + { + return false; + } + strcpy((char*)output, "\"\""); + + return true; + } + + /* set "flag" to 1 if something needs to be escaped */ + for (input_pointer = input; *input_pointer; input_pointer++) + { + switch (*input_pointer) + { + case '\"': + case '\\': + case '\b': + case '\f': + case '\n': + case '\r': + case '\t': + /* one character escape sequence */ + escape_characters++; + break; + default: + if (*input_pointer < 32) + { + /* UTF-16 escape sequence uXXXX */ + escape_characters += 5; + } + break; + } + } + output_length = (size_t)(input_pointer - input) + escape_characters; + + output = ensure(output_buffer, output_length + sizeof("\"\"")); + if (output == NULL) + { + return false; + } + + /* no characters have to be escaped */ + if (escape_characters == 0) + { + output[0] = '\"'; + memcpy(output + 1, input, output_length); + output[output_length + 1] = '\"'; + output[output_length + 2] = '\0'; + + return true; + } + + output[0] = '\"'; + output_pointer = output + 1; + /* copy the string */ + for (input_pointer = input; *input_pointer != '\0'; (void)input_pointer++, output_pointer++) + { + if ((*input_pointer > 31) && (*input_pointer != '\"') && (*input_pointer != '\\')) + { + /* normal character, copy */ + *output_pointer = *input_pointer; + } + else + { + /* character needs to be escaped */ + *output_pointer++ = '\\'; + switch (*input_pointer) + { + case '\\': + *output_pointer = '\\'; + break; + case '\"': + *output_pointer = '\"'; + break; + case '\b': + *output_pointer = 'b'; + break; + case '\f': + *output_pointer = 'f'; + break; + case '\n': + *output_pointer = 'n'; + break; + case '\r': + *output_pointer = 'r'; + break; + case '\t': + *output_pointer = 't'; + break; + default: + /* escape and print as unicode codepoint */ + sprintf((char*)output_pointer, "u%04x", *input_pointer); + output_pointer += 4; + break; + } + } + } + output[output_length + 1] = '\"'; + output[output_length + 2] = '\0'; + + return true; +} + +/* Invoke print_string_ptr (which is useful) on an item. */ +static cJSON_bool print_string(const cJSON * const item, printbuffer * const p) +{ + return print_string_ptr((unsigned char*)item->valuestring, p); +} + +/* Predeclare these prototypes. */ +static cJSON_bool parse_value(cJSON * const item, parse_buffer * const input_buffer); +static cJSON_bool print_value(const cJSON * const item, printbuffer * const output_buffer); +static cJSON_bool parse_array(cJSON * const item, parse_buffer * const input_buffer); +static cJSON_bool print_array(const cJSON * const item, printbuffer * const output_buffer); +static cJSON_bool parse_object(cJSON * const item, parse_buffer * const input_buffer); +static cJSON_bool print_object(const cJSON * const item, printbuffer * const output_buffer); + +/* Utility to jump whitespace and cr/lf */ +static parse_buffer *buffer_skip_whitespace(parse_buffer * const buffer) +{ + if ((buffer == NULL) || (buffer->content == NULL)) + { + return NULL; + } + + while (can_access_at_index(buffer, 0) && (buffer_at_offset(buffer)[0] <= 32)) + { + buffer->offset++; + } + + if (buffer->offset == buffer->length) + { + buffer->offset--; + } + + return buffer; +} + +/* skip the UTF-8 BOM (byte order mark) if it is at the beginning of a buffer */ +static parse_buffer *skip_utf8_bom(parse_buffer * const buffer) +{ + if ((buffer == NULL) || (buffer->content == NULL) || (buffer->offset != 0)) + { + return NULL; + } + + if (can_access_at_index(buffer, 4) && (strncmp((const char*)buffer_at_offset(buffer), "\xEF\xBB\xBF", 3) == 0)) + { + buffer->offset += 3; + } + + return buffer; +} + +/* Parse an object - create a new root, and populate. */ +CJSON_PUBLIC(cJSON *) cJSON_ParseWithOpts(const char *value, const char **return_parse_end, cJSON_bool require_null_terminated) +{ + parse_buffer buffer = { 0, 0, 0, 0, { 0, 0, 0 } }; + cJSON *item = NULL; + + /* reset error position */ + global_error.json = NULL; + global_error.position = 0; + + if (value == NULL) + { + goto fail; + } + + buffer.content = (const unsigned char*)value; + buffer.length = strlen((const char*)value) + sizeof(""); + buffer.offset = 0; + buffer.hooks = global_hooks; + + item = cJSON_New_Item(&global_hooks); + if (item == NULL) /* memory fail */ + { + goto fail; + } + + if (!parse_value(item, buffer_skip_whitespace(skip_utf8_bom(&buffer)))) + { + /* parse failure. ep is set. */ + goto fail; + } + + /* if we require null-terminated JSON without appended garbage, skip and then check for a null terminator */ + if (require_null_terminated) + { + buffer_skip_whitespace(&buffer); + if ((buffer.offset >= buffer.length) || buffer_at_offset(&buffer)[0] != '\0') + { + goto fail; + } + } + if (return_parse_end) + { + *return_parse_end = (const char*)buffer_at_offset(&buffer); + } + + return item; + +fail: + if (item != NULL) + { + cJSON_Delete(item); + } + + if (value != NULL) + { + error local_error; + local_error.json = (const unsigned char*)value; + local_error.position = 0; + + if (buffer.offset < buffer.length) + { + local_error.position = buffer.offset; + } + else if (buffer.length > 0) + { + local_error.position = buffer.length - 1; + } + + if (return_parse_end != NULL) + { + *return_parse_end = (const char*)local_error.json + local_error.position; + } + + global_error = local_error; + } + + return NULL; +} + +/* Default options for cJSON_Parse */ +CJSON_PUBLIC(cJSON *) cJSON_Parse(const char *value) +{ + return cJSON_ParseWithOpts(value, 0, 0); +} + +#define cjson_min(a, b) ((a < b) ? a : b) + +static unsigned char *print(const cJSON * const item, cJSON_bool format, const internal_hooks * const hooks) +{ + static const size_t default_buffer_size = 256; + printbuffer buffer[1]; + unsigned char *printed = NULL; + + memset(buffer, 0, sizeof(buffer)); + + /* create buffer */ + buffer->buffer = (unsigned char*) hooks->allocate(default_buffer_size); + buffer->length = default_buffer_size; + buffer->format = format; + buffer->hooks = *hooks; + if (buffer->buffer == NULL) + { + goto fail; + } + + /* print the value */ + if (!print_value(item, buffer)) + { + goto fail; + } + update_offset(buffer); + + /* check if reallocate is available */ + if (hooks->reallocate != NULL) + { + printed = (unsigned char*) hooks->reallocate(buffer->buffer, buffer->offset + 1); + if (printed == NULL) { + goto fail; + } + buffer->buffer = NULL; + } + else /* otherwise copy the JSON over to a new buffer */ + { + printed = (unsigned char*) hooks->allocate(buffer->offset + 1); + if (printed == NULL) + { + goto fail; + } + memcpy(printed, buffer->buffer, cjson_min(buffer->length, buffer->offset + 1)); + printed[buffer->offset] = '\0'; /* just to be sure */ + + /* free the buffer */ + hooks->deallocate(buffer->buffer); + } + + return printed; + +fail: + if (buffer->buffer != NULL) + { + hooks->deallocate(buffer->buffer); + } + + if (printed != NULL) + { + hooks->deallocate(printed); + } + + return NULL; +} + +/* Render a cJSON item/entity/structure to text. */ +CJSON_PUBLIC(char *) cJSON_Print(const cJSON *item) +{ + return (char*)print(item, true, &global_hooks); +} + +CJSON_PUBLIC(char *) cJSON_PrintUnformatted(const cJSON *item) +{ + return (char*)print(item, false, &global_hooks); +} + +CJSON_PUBLIC(char *) cJSON_PrintBuffered(const cJSON *item, int prebuffer, cJSON_bool fmt) +{ + printbuffer p = { 0, 0, 0, 0, 0, 0, { 0, 0, 0 } }; + + if (prebuffer < 0) + { + return NULL; + } + + p.buffer = (unsigned char*)global_hooks.allocate((size_t)prebuffer); + if (!p.buffer) + { + return NULL; + } + + p.length = (size_t)prebuffer; + p.offset = 0; + p.noalloc = false; + p.format = fmt; + p.hooks = global_hooks; + + if (!print_value(item, &p)) + { + global_hooks.deallocate(p.buffer); + return NULL; + } + + return (char*)p.buffer; +} + +CJSON_PUBLIC(cJSON_bool) cJSON_PrintPreallocated(cJSON *item, char *buf, const int len, const cJSON_bool fmt) +{ + printbuffer p = { 0, 0, 0, 0, 0, 0, { 0, 0, 0 } }; + + if ((len < 0) || (buf == NULL)) + { + return false; + } + + p.buffer = (unsigned char*)buf; + p.length = (size_t)len; + p.offset = 0; + p.noalloc = true; + p.format = fmt; + p.hooks = global_hooks; + + return print_value(item, &p); +} + +/* Parser core - when encountering text, process appropriately. */ +static cJSON_bool parse_value(cJSON * const item, parse_buffer * const input_buffer) +{ + if ((input_buffer == NULL) || (input_buffer->content == NULL)) + { + return false; /* no input */ + } + + /* parse the different types of values */ + /* null */ + if (can_read(input_buffer, 4) && (strncmp((const char*)buffer_at_offset(input_buffer), "null", 4) == 0)) + { + item->type = cJSON_NULL; + input_buffer->offset += 4; + return true; + } + /* false */ + if (can_read(input_buffer, 5) && (strncmp((const char*)buffer_at_offset(input_buffer), "false", 5) == 0)) + { + item->type = cJSON_False; + input_buffer->offset += 5; + return true; + } + /* true */ + if (can_read(input_buffer, 4) && (strncmp((const char*)buffer_at_offset(input_buffer), "true", 4) == 0)) + { + item->type = cJSON_True; + item->valueint = 1; + input_buffer->offset += 4; + return true; + } + /* string */ + if (can_access_at_index(input_buffer, 0) && (buffer_at_offset(input_buffer)[0] == '\"')) + { + return parse_string(item, input_buffer); + } + /* number */ + if (can_access_at_index(input_buffer, 0) && ((buffer_at_offset(input_buffer)[0] == '-') || ((buffer_at_offset(input_buffer)[0] >= '0') && (buffer_at_offset(input_buffer)[0] <= '9')))) + { + return parse_number(item, input_buffer); + } + /* array */ + if (can_access_at_index(input_buffer, 0) && (buffer_at_offset(input_buffer)[0] == '[')) + { + return parse_array(item, input_buffer); + } + /* object */ + if (can_access_at_index(input_buffer, 0) && (buffer_at_offset(input_buffer)[0] == '{')) + { + return parse_object(item, input_buffer); + } + + return false; +} + +/* Render a value to text. */ +static cJSON_bool print_value(const cJSON * const item, printbuffer * const output_buffer) +{ + unsigned char *output = NULL; + + if ((item == NULL) || (output_buffer == NULL)) + { + return false; + } + + switch ((item->type) & 0xFF) + { + case cJSON_NULL: + output = ensure(output_buffer, 5); + if (output == NULL) + { + return false; + } + strcpy((char*)output, "null"); + return true; + + case cJSON_False: + output = ensure(output_buffer, 6); + if (output == NULL) + { + return false; + } + strcpy((char*)output, "false"); + return true; + + case cJSON_True: + output = ensure(output_buffer, 5); + if (output == NULL) + { + return false; + } + strcpy((char*)output, "true"); + return true; + + case cJSON_Number: + return print_number(item, output_buffer); + + case cJSON_Raw: + { + size_t raw_length = 0; + if (item->valuestring == NULL) + { + return false; + } + + raw_length = strlen(item->valuestring) + sizeof(""); + output = ensure(output_buffer, raw_length); + if (output == NULL) + { + return false; + } + memcpy(output, item->valuestring, raw_length); + return true; + } + + case cJSON_String: + return print_string(item, output_buffer); + + case cJSON_Array: + return print_array(item, output_buffer); + + case cJSON_Object: + return print_object(item, output_buffer); + + default: + return false; + } +} + +/* Build an array from input text. */ +static cJSON_bool parse_array(cJSON * const item, parse_buffer * const input_buffer) +{ + cJSON *head = NULL; /* head of the linked list */ + cJSON *current_item = NULL; + + if (input_buffer->depth >= CJSON_NESTING_LIMIT) + { + return false; /* to deeply nested */ + } + input_buffer->depth++; + + if (buffer_at_offset(input_buffer)[0] != '[') + { + /* not an array */ + goto fail; + } + + input_buffer->offset++; + buffer_skip_whitespace(input_buffer); + if (can_access_at_index(input_buffer, 0) && (buffer_at_offset(input_buffer)[0] == ']')) + { + /* empty array */ + goto success; + } + + /* check if we skipped to the end of the buffer */ + if (cannot_access_at_index(input_buffer, 0)) + { + input_buffer->offset--; + goto fail; + } + + /* step back to character in front of the first element */ + input_buffer->offset--; + /* loop through the comma separated array elements */ + do + { + /* allocate next item */ + cJSON *new_item = cJSON_New_Item(&(input_buffer->hooks)); + if (new_item == NULL) + { + goto fail; /* allocation failure */ + } + + /* attach next item to list */ + if (head == NULL) + { + /* start the linked list */ + current_item = head = new_item; + } + else + { + /* add to the end and advance */ + current_item->next = new_item; + new_item->prev = current_item; + current_item = new_item; + } + + /* parse next value */ + input_buffer->offset++; + buffer_skip_whitespace(input_buffer); + if (!parse_value(current_item, input_buffer)) + { + goto fail; /* failed to parse value */ + } + buffer_skip_whitespace(input_buffer); + } + while (can_access_at_index(input_buffer, 0) && (buffer_at_offset(input_buffer)[0] == ',')); + + if (cannot_access_at_index(input_buffer, 0) || buffer_at_offset(input_buffer)[0] != ']') + { + goto fail; /* expected end of array */ + } + +success: + input_buffer->depth--; + + item->type = cJSON_Array; + item->child = head; + + input_buffer->offset++; + + return true; + +fail: + if (head != NULL) + { + cJSON_Delete(head); + } + + return false; +} + +/* Render an array to text */ +static cJSON_bool print_array(const cJSON * const item, printbuffer * const output_buffer) +{ + unsigned char *output_pointer = NULL; + size_t length = 0; + cJSON *current_element = item->child; + + if (output_buffer == NULL) + { + return false; + } + + /* Compose the output array. */ + /* opening square bracket */ + output_pointer = ensure(output_buffer, 1); + if (output_pointer == NULL) + { + return false; + } + + *output_pointer = '['; + output_buffer->offset++; + output_buffer->depth++; + + while (current_element != NULL) + { + if (!print_value(current_element, output_buffer)) + { + return false; + } + update_offset(output_buffer); + if (current_element->next) + { + length = (size_t) (output_buffer->format ? 2 : 1); + output_pointer = ensure(output_buffer, length + 1); + if (output_pointer == NULL) + { + return false; + } + *output_pointer++ = ','; + if(output_buffer->format) + { + *output_pointer++ = ' '; + } + *output_pointer = '\0'; + output_buffer->offset += length; + } + current_element = current_element->next; + } + + output_pointer = ensure(output_buffer, 2); + if (output_pointer == NULL) + { + return false; + } + *output_pointer++ = ']'; + *output_pointer = '\0'; + output_buffer->depth--; + + return true; +} + +/* Build an object from the text. */ +static cJSON_bool parse_object(cJSON * const item, parse_buffer * const input_buffer) +{ + cJSON *head = NULL; /* linked list head */ + cJSON *current_item = NULL; + + if (input_buffer->depth >= CJSON_NESTING_LIMIT) + { + return false; /* to deeply nested */ + } + input_buffer->depth++; + + if (cannot_access_at_index(input_buffer, 0) || (buffer_at_offset(input_buffer)[0] != '{')) + { + goto fail; /* not an object */ + } + + input_buffer->offset++; + buffer_skip_whitespace(input_buffer); + if (can_access_at_index(input_buffer, 0) && (buffer_at_offset(input_buffer)[0] == '}')) + { + goto success; /* empty object */ + } + + /* check if we skipped to the end of the buffer */ + if (cannot_access_at_index(input_buffer, 0)) + { + input_buffer->offset--; + goto fail; + } + + /* step back to character in front of the first element */ + input_buffer->offset--; + /* loop through the comma separated array elements */ + do + { + /* allocate next item */ + cJSON *new_item = cJSON_New_Item(&(input_buffer->hooks)); + if (new_item == NULL) + { + goto fail; /* allocation failure */ + } + + /* attach next item to list */ + if (head == NULL) + { + /* start the linked list */ + current_item = head = new_item; + } + else + { + /* add to the end and advance */ + current_item->next = new_item; + new_item->prev = current_item; + current_item = new_item; + } + + /* parse the name of the child */ + input_buffer->offset++; + buffer_skip_whitespace(input_buffer); + if (!parse_string(current_item, input_buffer)) + { + goto fail; /* faile to parse name */ + } + buffer_skip_whitespace(input_buffer); + + /* swap valuestring and string, because we parsed the name */ + current_item->string = current_item->valuestring; + current_item->valuestring = NULL; + + if (cannot_access_at_index(input_buffer, 0) || (buffer_at_offset(input_buffer)[0] != ':')) + { + goto fail; /* invalid object */ + } + + /* parse the value */ + input_buffer->offset++; + buffer_skip_whitespace(input_buffer); + if (!parse_value(current_item, input_buffer)) + { + goto fail; /* failed to parse value */ + } + buffer_skip_whitespace(input_buffer); + } + while (can_access_at_index(input_buffer, 0) && (buffer_at_offset(input_buffer)[0] == ',')); + + if (cannot_access_at_index(input_buffer, 0) || (buffer_at_offset(input_buffer)[0] != '}')) + { + goto fail; /* expected end of object */ + } + +success: + input_buffer->depth--; + + item->type = cJSON_Object; + item->child = head; + + input_buffer->offset++; + return true; + +fail: + if (head != NULL) + { + cJSON_Delete(head); + } + + return false; +} + +/* Render an object to text. */ +static cJSON_bool print_object(const cJSON * const item, printbuffer * const output_buffer) +{ + unsigned char *output_pointer = NULL; + size_t length = 0; + cJSON *current_item = item->child; + + if (output_buffer == NULL) + { + return false; + } + + /* Compose the output: */ + length = (size_t) (output_buffer->format ? 2 : 1); /* fmt: {\n */ + output_pointer = ensure(output_buffer, length + 1); + if (output_pointer == NULL) + { + return false; + } + + *output_pointer++ = '{'; + output_buffer->depth++; + if (output_buffer->format) + { + *output_pointer++ = '\n'; + } + output_buffer->offset += length; + + while (current_item) + { + if (output_buffer->format) + { + size_t i; + output_pointer = ensure(output_buffer, output_buffer->depth); + if (output_pointer == NULL) + { + return false; + } + for (i = 0; i < output_buffer->depth; i++) + { + *output_pointer++ = '\t'; + } + output_buffer->offset += output_buffer->depth; + } + + /* print key */ + if (!print_string_ptr((unsigned char*)current_item->string, output_buffer)) + { + return false; + } + update_offset(output_buffer); + + length = (size_t) (output_buffer->format ? 2 : 1); + output_pointer = ensure(output_buffer, length); + if (output_pointer == NULL) + { + return false; + } + *output_pointer++ = ':'; + if (output_buffer->format) + { + *output_pointer++ = '\t'; + } + output_buffer->offset += length; + + /* print value */ + if (!print_value(current_item, output_buffer)) + { + return false; + } + update_offset(output_buffer); + + /* print comma if not last */ + length = (size_t) ((output_buffer->format ? 1 : 0) + (current_item->next ? 1 : 0)); + output_pointer = ensure(output_buffer, length + 1); + if (output_pointer == NULL) + { + return false; + } + if (current_item->next) + { + *output_pointer++ = ','; + } + + if (output_buffer->format) + { + *output_pointer++ = '\n'; + } + *output_pointer = '\0'; + output_buffer->offset += length; + + current_item = current_item->next; + } + + output_pointer = ensure(output_buffer, output_buffer->format ? (output_buffer->depth + 1) : 2); + if (output_pointer == NULL) + { + return false; + } + if (output_buffer->format) + { + size_t i; + for (i = 0; i < (output_buffer->depth - 1); i++) + { + *output_pointer++ = '\t'; + } + } + *output_pointer++ = '}'; + *output_pointer = '\0'; + output_buffer->depth--; + + return true; +} + +/* Get Array size/item / object item. */ +CJSON_PUBLIC(int) cJSON_GetArraySize(const cJSON *array) +{ + cJSON *child = NULL; + size_t size = 0; + + if (array == NULL) + { + return 0; + } + + child = array->child; + + while(child != NULL) + { + size++; + child = child->next; + } + + /* FIXME: Can overflow here. Cannot be fixed without breaking the API */ + + return (int)size; +} + +static cJSON* get_array_item(const cJSON *array, size_t index) +{ + cJSON *current_child = NULL; + + if (array == NULL) + { + return NULL; + } + + current_child = array->child; + while ((current_child != NULL) && (index > 0)) + { + index--; + current_child = current_child->next; + } + + return current_child; +} + +CJSON_PUBLIC(cJSON *) cJSON_GetArrayItem(const cJSON *array, int index) +{ + if (index < 0) + { + return NULL; + } + + return get_array_item(array, (size_t)index); +} + +static cJSON *get_object_item(const cJSON * const object, const char * const name, const cJSON_bool case_sensitive) +{ + cJSON *current_element = NULL; + + if ((object == NULL) || (name == NULL)) + { + return NULL; + } + + current_element = object->child; + if (case_sensitive) + { + while ((current_element != NULL) && (strcmp(name, current_element->string) != 0)) + { + current_element = current_element->next; + } + } + else + { + while ((current_element != NULL) && (case_insensitive_strcmp((const unsigned char*)name, (const unsigned char*)(current_element->string)) != 0)) + { + current_element = current_element->next; + } + } + + return current_element; +} + +CJSON_PUBLIC(cJSON *) cJSON_GetObjectItem(const cJSON * const object, const char * const string) +{ + return get_object_item(object, string, false); +} + +CJSON_PUBLIC(cJSON *) cJSON_GetObjectItemCaseSensitive(const cJSON * const object, const char * const string) +{ + return get_object_item(object, string, true); +} + +CJSON_PUBLIC(cJSON_bool) cJSON_HasObjectItem(const cJSON *object, const char *string) +{ + return cJSON_GetObjectItem(object, string) ? 1 : 0; +} + +/* Utility for array list handling. */ +static void suffix_object(cJSON *prev, cJSON *item) +{ + prev->next = item; + item->prev = prev; +} + +/* Utility for handling references. */ +static cJSON *create_reference(const cJSON *item, const internal_hooks * const hooks) +{ + cJSON *reference = NULL; + if (item == NULL) + { + return NULL; + } + + reference = cJSON_New_Item(hooks); + if (reference == NULL) + { + return NULL; + } + + memcpy(reference, item, sizeof(cJSON)); + reference->string = NULL; + reference->type |= cJSON_IsReference; + reference->next = reference->prev = NULL; + return reference; +} + +static cJSON_bool add_item_to_array(cJSON *array, cJSON *item) +{ + cJSON *child = NULL; + + if ((item == NULL) || (array == NULL)) + { + return false; + } + + child = array->child; + + if (child == NULL) + { + /* list is empty, start new one */ + array->child = item; + } + else + { + /* append to the end */ + while (child->next) + { + child = child->next; + } + suffix_object(child, item); + } + + return true; +} + +/* Add item to array/object. */ +CJSON_PUBLIC(void) cJSON_AddItemToArray(cJSON *array, cJSON *item) +{ + add_item_to_array(array, item); +} + +#if defined(__clang__) || (defined(__GNUC__) && ((__GNUC__ > 4) || ((__GNUC__ == 4) && (__GNUC_MINOR__ > 5)))) + #pragma GCC diagnostic push +#endif +#ifdef __GNUC__ +#pragma GCC diagnostic ignored "-Wcast-qual" +#endif +/* helper function to cast away const */ +static void* cast_away_const(const void* string) +{ + return (void*)string; +} +#if defined(__clang__) || (defined(__GNUC__) && ((__GNUC__ > 4) || ((__GNUC__ == 4) && (__GNUC_MINOR__ > 5)))) + #pragma GCC diagnostic pop +#endif + + +static cJSON_bool add_item_to_object(cJSON * const object, const char * const string, cJSON * const item, const internal_hooks * const hooks, const cJSON_bool constant_key) +{ + char *new_key = NULL; + int new_type = cJSON_Invalid; + + if ((object == NULL) || (string == NULL) || (item == NULL)) + { + return false; + } + + if (constant_key) + { + new_key = (char*)cast_away_const(string); + new_type = item->type | cJSON_StringIsConst; + } + else + { + new_key = (char*)cJSON_strdup((const unsigned char*)string, hooks); + if (new_key == NULL) + { + return false; + } + + new_type = item->type & ~cJSON_StringIsConst; + } + + if (!(item->type & cJSON_StringIsConst) && (item->string != NULL)) + { + hooks->deallocate(item->string); + } + + item->string = new_key; + item->type = new_type; + + return add_item_to_array(object, item); +} + +CJSON_PUBLIC(void) cJSON_AddItemToObject(cJSON *object, const char *string, cJSON *item) +{ + add_item_to_object(object, string, item, &global_hooks, false); +} + +/* Add an item to an object with constant string as key */ +CJSON_PUBLIC(void) cJSON_AddItemToObjectCS(cJSON *object, const char *string, cJSON *item) +{ + add_item_to_object(object, string, item, &global_hooks, true); +} + +CJSON_PUBLIC(void) cJSON_AddItemReferenceToArray(cJSON *array, cJSON *item) +{ + if (array == NULL) + { + return; + } + + add_item_to_array(array, create_reference(item, &global_hooks)); +} + +CJSON_PUBLIC(void) cJSON_AddItemReferenceToObject(cJSON *object, const char *string, cJSON *item) +{ + if ((object == NULL) || (string == NULL)) + { + return; + } + + add_item_to_object(object, string, create_reference(item, &global_hooks), &global_hooks, false); +} + +CJSON_PUBLIC(cJSON*) cJSON_AddNullToObject(cJSON * const object, const char * const name) +{ + cJSON *null = cJSON_CreateNull(); + if (add_item_to_object(object, name, null, &global_hooks, false)) + { + return null; + } + + cJSON_Delete(null); + return NULL; +} + +CJSON_PUBLIC(cJSON*) cJSON_AddTrueToObject(cJSON * const object, const char * const name) +{ + cJSON *true_item = cJSON_CreateTrue(); + if (add_item_to_object(object, name, true_item, &global_hooks, false)) + { + return true_item; + } + + cJSON_Delete(true_item); + return NULL; +} + +CJSON_PUBLIC(cJSON*) cJSON_AddFalseToObject(cJSON * const object, const char * const name) +{ + cJSON *false_item = cJSON_CreateFalse(); + if (add_item_to_object(object, name, false_item, &global_hooks, false)) + { + return false_item; + } + + cJSON_Delete(false_item); + return NULL; +} + +CJSON_PUBLIC(cJSON*) cJSON_AddBoolToObject(cJSON * const object, const char * const name, const cJSON_bool boolean) +{ + cJSON *bool_item = cJSON_CreateBool(boolean); + if (add_item_to_object(object, name, bool_item, &global_hooks, false)) + { + return bool_item; + } + + cJSON_Delete(bool_item); + return NULL; +} + +CJSON_PUBLIC(cJSON*) cJSON_AddNumberToObject(cJSON * const object, const char * const name, const double number) +{ + cJSON *number_item = cJSON_CreateNumber(number); + if (add_item_to_object(object, name, number_item, &global_hooks, false)) + { + return number_item; + } + + cJSON_Delete(number_item); + return NULL; +} + +CJSON_PUBLIC(cJSON*) cJSON_AddStringToObject(cJSON * const object, const char * const name, const char * const string) +{ + cJSON *string_item = cJSON_CreateString(string); + if (add_item_to_object(object, name, string_item, &global_hooks, false)) + { + return string_item; + } + + cJSON_Delete(string_item); + return NULL; +} + +CJSON_PUBLIC(cJSON*) cJSON_AddRawToObject(cJSON * const object, const char * const name, const char * const raw) +{ + cJSON *raw_item = cJSON_CreateRaw(raw); + if (add_item_to_object(object, name, raw_item, &global_hooks, false)) + { + return raw_item; + } + + cJSON_Delete(raw_item); + return NULL; +} + +CJSON_PUBLIC(cJSON*) cJSON_AddObjectToObject(cJSON * const object, const char * const name) +{ + cJSON *object_item = cJSON_CreateObject(); + if (add_item_to_object(object, name, object_item, &global_hooks, false)) + { + return object_item; + } + + cJSON_Delete(object_item); + return NULL; +} + +CJSON_PUBLIC(cJSON*) cJSON_AddArrayToObject(cJSON * const object, const char * const name) +{ + cJSON *array = cJSON_CreateArray(); + if (add_item_to_object(object, name, array, &global_hooks, false)) + { + return array; + } + + cJSON_Delete(array); + return NULL; +} + +CJSON_PUBLIC(cJSON *) cJSON_DetachItemViaPointer(cJSON *parent, cJSON * const item) +{ + if ((parent == NULL) || (item == NULL)) + { + return NULL; + } + + if (item->prev != NULL) + { + /* not the first element */ + item->prev->next = item->next; + } + if (item->next != NULL) + { + /* not the last element */ + item->next->prev = item->prev; + } + + if (item == parent->child) + { + /* first element */ + parent->child = item->next; + } + /* make sure the detached item doesn't point anywhere anymore */ + item->prev = NULL; + item->next = NULL; + + return item; +} + +CJSON_PUBLIC(cJSON *) cJSON_DetachItemFromArray(cJSON *array, int which) +{ + if (which < 0) + { + return NULL; + } + + return cJSON_DetachItemViaPointer(array, get_array_item(array, (size_t)which)); +} + +CJSON_PUBLIC(void) cJSON_DeleteItemFromArray(cJSON *array, int which) +{ + cJSON_Delete(cJSON_DetachItemFromArray(array, which)); +} + +CJSON_PUBLIC(cJSON *) cJSON_DetachItemFromObject(cJSON *object, const char *string) +{ + cJSON *to_detach = cJSON_GetObjectItem(object, string); + + return cJSON_DetachItemViaPointer(object, to_detach); +} + +CJSON_PUBLIC(cJSON *) cJSON_DetachItemFromObjectCaseSensitive(cJSON *object, const char *string) +{ + cJSON *to_detach = cJSON_GetObjectItemCaseSensitive(object, string); + + return cJSON_DetachItemViaPointer(object, to_detach); +} + +CJSON_PUBLIC(void) cJSON_DeleteItemFromObject(cJSON *object, const char *string) +{ + cJSON_Delete(cJSON_DetachItemFromObject(object, string)); +} + +CJSON_PUBLIC(void) cJSON_DeleteItemFromObjectCaseSensitive(cJSON *object, const char *string) +{ + cJSON_Delete(cJSON_DetachItemFromObjectCaseSensitive(object, string)); +} + +/* Replace array/object items with new ones. */ +CJSON_PUBLIC(void) cJSON_InsertItemInArray(cJSON *array, int which, cJSON *newitem) +{ + cJSON *after_inserted = NULL; + + if (which < 0) + { + return; + } + + after_inserted = get_array_item(array, (size_t)which); + if (after_inserted == NULL) + { + add_item_to_array(array, newitem); + return; + } + + newitem->next = after_inserted; + newitem->prev = after_inserted->prev; + after_inserted->prev = newitem; + if (after_inserted == array->child) + { + array->child = newitem; + } + else + { + newitem->prev->next = newitem; + } +} + +CJSON_PUBLIC(cJSON_bool) cJSON_ReplaceItemViaPointer(cJSON * const parent, cJSON * const item, cJSON * replacement) +{ + if ((parent == NULL) || (replacement == NULL) || (item == NULL)) + { + return false; + } + + if (replacement == item) + { + return true; + } + + replacement->next = item->next; + replacement->prev = item->prev; + + if (replacement->next != NULL) + { + replacement->next->prev = replacement; + } + if (replacement->prev != NULL) + { + replacement->prev->next = replacement; + } + if (parent->child == item) + { + parent->child = replacement; + } + + item->next = NULL; + item->prev = NULL; + cJSON_Delete(item); + + return true; +} + +CJSON_PUBLIC(void) cJSON_ReplaceItemInArray(cJSON *array, int which, cJSON *newitem) +{ + if (which < 0) + { + return; + } + + cJSON_ReplaceItemViaPointer(array, get_array_item(array, (size_t)which), newitem); +} + +static cJSON_bool replace_item_in_object(cJSON *object, const char *string, cJSON *replacement, cJSON_bool case_sensitive) +{ + if ((replacement == NULL) || (string == NULL)) + { + return false; + } + + /* replace the name in the replacement */ + if (!(replacement->type & cJSON_StringIsConst) && (replacement->string != NULL)) + { + cJSON_free(replacement->string); + } + replacement->string = (char*)cJSON_strdup((const unsigned char*)string, &global_hooks); + replacement->type &= ~cJSON_StringIsConst; + + cJSON_ReplaceItemViaPointer(object, get_object_item(object, string, case_sensitive), replacement); + + return true; +} + +CJSON_PUBLIC(void) cJSON_ReplaceItemInObject(cJSON *object, const char *string, cJSON *newitem) +{ + replace_item_in_object(object, string, newitem, false); +} + +CJSON_PUBLIC(void) cJSON_ReplaceItemInObjectCaseSensitive(cJSON *object, const char *string, cJSON *newitem) +{ + replace_item_in_object(object, string, newitem, true); +} + +/* Create basic types: */ +CJSON_PUBLIC(cJSON *) cJSON_CreateNull(void) +{ + cJSON *item = cJSON_New_Item(&global_hooks); + if(item) + { + item->type = cJSON_NULL; + } + + return item; +} + +CJSON_PUBLIC(cJSON *) cJSON_CreateTrue(void) +{ + cJSON *item = cJSON_New_Item(&global_hooks); + if(item) + { + item->type = cJSON_True; + } + + return item; +} + +CJSON_PUBLIC(cJSON *) cJSON_CreateFalse(void) +{ + cJSON *item = cJSON_New_Item(&global_hooks); + if(item) + { + item->type = cJSON_False; + } + + return item; +} + +CJSON_PUBLIC(cJSON *) cJSON_CreateBool(cJSON_bool b) +{ + cJSON *item = cJSON_New_Item(&global_hooks); + if(item) + { + item->type = b ? cJSON_True : cJSON_False; + } + + return item; +} + +CJSON_PUBLIC(cJSON *) cJSON_CreateNumber(double num) +{ + cJSON *item = cJSON_New_Item(&global_hooks); + if(item) + { + item->type = cJSON_Number; + item->valuedouble = num; + + /* use saturation in case of overflow */ + if (num >= INT_MAX) + { + item->valueint = INT_MAX; + } + else if (num <= INT_MIN) + { + item->valueint = INT_MIN; + } + else + { + item->valueint = (int)num; + } + } + + return item; +} + +CJSON_PUBLIC(cJSON *) cJSON_CreateString(const char *string) +{ + cJSON *item = cJSON_New_Item(&global_hooks); + if(item) + { + item->type = cJSON_String; + item->valuestring = (char*)cJSON_strdup((const unsigned char*)string, &global_hooks); + if(!item->valuestring) + { + cJSON_Delete(item); + return NULL; + } + } + + return item; +} + +CJSON_PUBLIC(cJSON *) cJSON_CreateStringReference(const char *string) +{ + cJSON *item = cJSON_New_Item(&global_hooks); + if (item != NULL) + { + item->type = cJSON_String | cJSON_IsReference; + item->valuestring = (char*)cast_away_const(string); + } + + return item; +} + +CJSON_PUBLIC(cJSON *) cJSON_CreateObjectReference(const cJSON *child) +{ + cJSON *item = cJSON_New_Item(&global_hooks); + if (item != NULL) { + item->type = cJSON_Object | cJSON_IsReference; + item->child = (cJSON*)cast_away_const(child); + } + + return item; +} + +CJSON_PUBLIC(cJSON *) cJSON_CreateArrayReference(const cJSON *child) { + cJSON *item = cJSON_New_Item(&global_hooks); + if (item != NULL) { + item->type = cJSON_Array | cJSON_IsReference; + item->child = (cJSON*)cast_away_const(child); + } + + return item; +} + +CJSON_PUBLIC(cJSON *) cJSON_CreateRaw(const char *raw) +{ + cJSON *item = cJSON_New_Item(&global_hooks); + if(item) + { + item->type = cJSON_Raw; + item->valuestring = (char*)cJSON_strdup((const unsigned char*)raw, &global_hooks); + if(!item->valuestring) + { + cJSON_Delete(item); + return NULL; + } + } + + return item; +} + +CJSON_PUBLIC(cJSON *) cJSON_CreateArray(void) +{ + cJSON *item = cJSON_New_Item(&global_hooks); + if(item) + { + item->type=cJSON_Array; + } + + return item; +} + +CJSON_PUBLIC(cJSON *) cJSON_CreateObject(void) +{ + cJSON *item = cJSON_New_Item(&global_hooks); + if (item) + { + item->type = cJSON_Object; + } + + return item; +} + +/* Create Arrays: */ +CJSON_PUBLIC(cJSON *) cJSON_CreateIntArray(const int *numbers, int count) +{ + size_t i = 0; + cJSON *n = NULL; + cJSON *p = NULL; + cJSON *a = NULL; + + if ((count < 0) || (numbers == NULL)) + { + return NULL; + } + + a = cJSON_CreateArray(); + for(i = 0; a && (i < (size_t)count); i++) + { + n = cJSON_CreateNumber(numbers[i]); + if (!n) + { + cJSON_Delete(a); + return NULL; + } + if(!i) + { + a->child = n; + } + else + { + suffix_object(p, n); + } + p = n; + } + + return a; +} + +CJSON_PUBLIC(cJSON *) cJSON_CreateFloatArray(const float *numbers, int count) +{ + size_t i = 0; + cJSON *n = NULL; + cJSON *p = NULL; + cJSON *a = NULL; + + if ((count < 0) || (numbers == NULL)) + { + return NULL; + } + + a = cJSON_CreateArray(); + + for(i = 0; a && (i < (size_t)count); i++) + { + n = cJSON_CreateNumber((double)numbers[i]); + if(!n) + { + cJSON_Delete(a); + return NULL; + } + if(!i) + { + a->child = n; + } + else + { + suffix_object(p, n); + } + p = n; + } + + return a; +} + +CJSON_PUBLIC(cJSON *) cJSON_CreateDoubleArray(const double *numbers, int count) +{ + size_t i = 0; + cJSON *n = NULL; + cJSON *p = NULL; + cJSON *a = NULL; + + if ((count < 0) || (numbers == NULL)) + { + return NULL; + } + + a = cJSON_CreateArray(); + + for(i = 0;a && (i < (size_t)count); i++) + { + n = cJSON_CreateNumber(numbers[i]); + if(!n) + { + cJSON_Delete(a); + return NULL; + } + if(!i) + { + a->child = n; + } + else + { + suffix_object(p, n); + } + p = n; + } + + return a; +} + +CJSON_PUBLIC(cJSON *) cJSON_CreateStringArray(const char **strings, int count) +{ + size_t i = 0; + cJSON *n = NULL; + cJSON *p = NULL; + cJSON *a = NULL; + + if ((count < 0) || (strings == NULL)) + { + return NULL; + } + + a = cJSON_CreateArray(); + + for (i = 0; a && (i < (size_t)count); i++) + { + n = cJSON_CreateString(strings[i]); + if(!n) + { + cJSON_Delete(a); + return NULL; + } + if(!i) + { + a->child = n; + } + else + { + suffix_object(p,n); + } + p = n; + } + + return a; +} + +/* Duplication */ +CJSON_PUBLIC(cJSON *) cJSON_Duplicate(const cJSON *item, cJSON_bool recurse) +{ + cJSON *newitem = NULL; + cJSON *child = NULL; + cJSON *next = NULL; + cJSON *newchild = NULL; + + /* Bail on bad ptr */ + if (!item) + { + goto fail; + } + /* Create new item */ + newitem = cJSON_New_Item(&global_hooks); + if (!newitem) + { + goto fail; + } + /* Copy over all vars */ + newitem->type = item->type & (~cJSON_IsReference); + newitem->valueint = item->valueint; + newitem->valuedouble = item->valuedouble; + if (item->valuestring) + { + newitem->valuestring = (char*)cJSON_strdup((unsigned char*)item->valuestring, &global_hooks); + if (!newitem->valuestring) + { + goto fail; + } + } + if (item->string) + { + newitem->string = (item->type&cJSON_StringIsConst) ? item->string : (char*)cJSON_strdup((unsigned char*)item->string, &global_hooks); + if (!newitem->string) + { + goto fail; + } + } + /* If non-recursive, then we're done! */ + if (!recurse) + { + return newitem; + } + /* Walk the ->next chain for the child. */ + child = item->child; + while (child != NULL) + { + newchild = cJSON_Duplicate(child, true); /* Duplicate (with recurse) each item in the ->next chain */ + if (!newchild) + { + goto fail; + } + if (next != NULL) + { + /* If newitem->child already set, then crosswire ->prev and ->next and move on */ + next->next = newchild; + newchild->prev = next; + next = newchild; + } + else + { + /* Set newitem->child and move to it */ + newitem->child = newchild; + next = newchild; + } + child = child->next; + } + + return newitem; + +fail: + if (newitem != NULL) + { + cJSON_Delete(newitem); + } + + return NULL; +} + +CJSON_PUBLIC(void) cJSON_Minify(char *json) +{ + unsigned char *into = (unsigned char*)json; + + if (json == NULL) + { + return; + } + + while (*json) + { + if (*json == ' ') + { + json++; + } + else if (*json == '\t') + { + /* Whitespace characters. */ + json++; + } + else if (*json == '\r') + { + json++; + } + else if (*json=='\n') + { + json++; + } + else if ((*json == '/') && (json[1] == '/')) + { + /* double-slash comments, to end of line. */ + while (*json && (*json != '\n')) + { + json++; + } + } + else if ((*json == '/') && (json[1] == '*')) + { + /* multiline comments. */ + while (*json && !((*json == '*') && (json[1] == '/'))) + { + json++; + } + json += 2; + } + else if (*json == '\"') + { + /* string literals, which are \" sensitive. */ + *into++ = (unsigned char)*json++; + while (*json && (*json != '\"')) + { + if (*json == '\\') + { + *into++ = (unsigned char)*json++; + } + *into++ = (unsigned char)*json++; + } + *into++ = (unsigned char)*json++; + } + else + { + /* All other characters. */ + *into++ = (unsigned char)*json++; + } + } + + /* and null-terminate. */ + *into = '\0'; +} + +CJSON_PUBLIC(cJSON_bool) cJSON_IsInvalid(const cJSON * const item) +{ + if (item == NULL) + { + return false; + } + + return (item->type & 0xFF) == cJSON_Invalid; +} + +CJSON_PUBLIC(cJSON_bool) cJSON_IsFalse(const cJSON * const item) +{ + if (item == NULL) + { + return false; + } + + return (item->type & 0xFF) == cJSON_False; +} + +CJSON_PUBLIC(cJSON_bool) cJSON_IsTrue(const cJSON * const item) +{ + if (item == NULL) + { + return false; + } + + return (item->type & 0xff) == cJSON_True; +} + + +CJSON_PUBLIC(cJSON_bool) cJSON_IsBool(const cJSON * const item) +{ + if (item == NULL) + { + return false; + } + + return (item->type & (cJSON_True | cJSON_False)) != 0; +} +CJSON_PUBLIC(cJSON_bool) cJSON_IsNull(const cJSON * const item) +{ + if (item == NULL) + { + return false; + } + + return (item->type & 0xFF) == cJSON_NULL; +} + +CJSON_PUBLIC(cJSON_bool) cJSON_IsNumber(const cJSON * const item) +{ + if (item == NULL) + { + return false; + } + + return (item->type & 0xFF) == cJSON_Number; +} + +CJSON_PUBLIC(cJSON_bool) cJSON_IsString(const cJSON * const item) +{ + if (item == NULL) + { + return false; + } + + return (item->type & 0xFF) == cJSON_String; +} + +CJSON_PUBLIC(cJSON_bool) cJSON_IsArray(const cJSON * const item) +{ + if (item == NULL) + { + return false; + } + + return (item->type & 0xFF) == cJSON_Array; +} + +CJSON_PUBLIC(cJSON_bool) cJSON_IsObject(const cJSON * const item) +{ + if (item == NULL) + { + return false; + } + + return (item->type & 0xFF) == cJSON_Object; +} + +CJSON_PUBLIC(cJSON_bool) cJSON_IsRaw(const cJSON * const item) +{ + if (item == NULL) + { + return false; + } + + return (item->type & 0xFF) == cJSON_Raw; +} + +CJSON_PUBLIC(cJSON_bool) cJSON_Compare(const cJSON * const a, const cJSON * const b, const cJSON_bool case_sensitive) +{ + if ((a == NULL) || (b == NULL) || ((a->type & 0xFF) != (b->type & 0xFF)) || cJSON_IsInvalid(a)) + { + return false; + } + + /* check if type is valid */ + switch (a->type & 0xFF) + { + case cJSON_False: + case cJSON_True: + case cJSON_NULL: + case cJSON_Number: + case cJSON_String: + case cJSON_Raw: + case cJSON_Array: + case cJSON_Object: + break; + + default: + return false; + } + + /* identical objects are equal */ + if (a == b) + { + return true; + } + + switch (a->type & 0xFF) + { + /* in these cases and equal type is enough */ + case cJSON_False: + case cJSON_True: + case cJSON_NULL: + return true; + + case cJSON_Number: + if (a->valuedouble == b->valuedouble) + { + return true; + } + return false; + + case cJSON_String: + case cJSON_Raw: + if ((a->valuestring == NULL) || (b->valuestring == NULL)) + { + return false; + } + if (strcmp(a->valuestring, b->valuestring) == 0) + { + return true; + } + + return false; + + case cJSON_Array: + { + cJSON *a_element = a->child; + cJSON *b_element = b->child; + + for (; (a_element != NULL) && (b_element != NULL);) + { + if (!cJSON_Compare(a_element, b_element, case_sensitive)) + { + return false; + } + + a_element = a_element->next; + b_element = b_element->next; + } + + /* one of the arrays is longer than the other */ + if (a_element != b_element) { + return false; + } + + return true; + } + + case cJSON_Object: + { + cJSON *a_element = NULL; + cJSON *b_element = NULL; + cJSON_ArrayForEach(a_element, a) + { + /* TODO This has O(n^2) runtime, which is horrible! */ + b_element = get_object_item(b, a_element->string, case_sensitive); + if (b_element == NULL) + { + return false; + } + + if (!cJSON_Compare(a_element, b_element, case_sensitive)) + { + return false; + } + } + + /* doing this twice, once on a and b to prevent true comparison if a subset of b + * TODO: Do this the proper way, this is just a fix for now */ + cJSON_ArrayForEach(b_element, b) + { + a_element = get_object_item(a, b_element->string, case_sensitive); + if (a_element == NULL) + { + return false; + } + + if (!cJSON_Compare(b_element, a_element, case_sensitive)) + { + return false; + } + } + + return true; + } + + default: + return false; + } +} + +CJSON_PUBLIC(void *) cJSON_malloc(size_t size) +{ + return global_hooks.allocate(size); +} + +CJSON_PUBLIC(void) cJSON_free(void *object) +{ + global_hooks.deallocate(object); +} diff --git a/src/third_party/cjson/cJSON.h b/src/third_party/cjson/cJSON.h new file mode 100644 index 0000000..6e0bde9 --- /dev/null +++ b/src/third_party/cjson/cJSON.h @@ -0,0 +1,277 @@ +/* + Copyright (c) 2009-2017 Dave Gamble and cJSON contributors + + Permission is hereby granted, free of charge, to any person obtaining a copy + of this software and associated documentation files (the "Software"), to deal + in the Software without restriction, including without limitation the rights + to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + copies of the Software, and to permit persons to whom the Software is + furnished to do so, subject to the following conditions: + + The above copyright notice and this permission notice shall be included in + all copies or substantial portions of the Software. + + THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + THE SOFTWARE. +*/ + +#ifndef cJSON__h +#define cJSON__h + +#ifdef __cplusplus +extern "C" +{ +#endif + +/* project version */ +#define CJSON_VERSION_MAJOR 1 +#define CJSON_VERSION_MINOR 7 +#define CJSON_VERSION_PATCH 7 + +#include + +/* cJSON Types: */ +#define cJSON_Invalid (0) +#define cJSON_False (1 << 0) +#define cJSON_True (1 << 1) +#define cJSON_NULL (1 << 2) +#define cJSON_Number (1 << 3) +#define cJSON_String (1 << 4) +#define cJSON_Array (1 << 5) +#define cJSON_Object (1 << 6) +#define cJSON_Raw (1 << 7) /* raw json */ + +#define cJSON_IsReference 256 +#define cJSON_StringIsConst 512 + +/* The cJSON structure: */ +typedef struct cJSON +{ + /* next/prev allow you to walk array/object chains. Alternatively, use GetArraySize/GetArrayItem/GetObjectItem */ + struct cJSON *next; + struct cJSON *prev; + /* An array or object item will have a child pointer pointing to a chain of the items in the array/object. */ + struct cJSON *child; + + /* The type of the item, as above. */ + int type; + + /* The item's string, if type==cJSON_String and type == cJSON_Raw */ + char *valuestring; + /* writing to valueint is DEPRECATED, use cJSON_SetNumberValue instead */ + int valueint; + /* The item's number, if type==cJSON_Number */ + double valuedouble; + + /* The item's name string, if this item is the child of, or is in the list of subitems of an object. */ + char *string; +} cJSON; + +typedef struct cJSON_Hooks +{ + void *(*malloc_fn)(size_t sz); + void (*free_fn)(void *ptr); +} cJSON_Hooks; + +typedef int cJSON_bool; + +#if !defined(__WINDOWS__) && (defined(WIN32) || defined(WIN64) || defined(_MSC_VER) || defined(_WIN32)) +#define __WINDOWS__ +#endif +#ifdef __WINDOWS__ + +/* When compiling for windows, we specify a specific calling convention to avoid issues where we are being called from a project with a different default calling convention. For windows you have 2 define options: + +CJSON_HIDE_SYMBOLS - Define this in the case where you don't want to ever dllexport symbols +CJSON_EXPORT_SYMBOLS - Define this on library build when you want to dllexport symbols (default) +CJSON_IMPORT_SYMBOLS - Define this if you want to dllimport symbol + +For *nix builds that support visibility attribute, you can define similar behavior by + +setting default visibility to hidden by adding +-fvisibility=hidden (for gcc) +or +-xldscope=hidden (for sun cc) +to CFLAGS + +then using the CJSON_API_VISIBILITY flag to "export" the same symbols the way CJSON_EXPORT_SYMBOLS does + +*/ + +/* export symbols by default, this is necessary for copy pasting the C and header file */ +#if !defined(CJSON_HIDE_SYMBOLS) && !defined(CJSON_IMPORT_SYMBOLS) && !defined(CJSON_EXPORT_SYMBOLS) +#define CJSON_EXPORT_SYMBOLS +#endif + +#if defined(CJSON_HIDE_SYMBOLS) +#define CJSON_PUBLIC(type) type __stdcall +#elif defined(CJSON_EXPORT_SYMBOLS) +#define CJSON_PUBLIC(type) __declspec(dllexport) type __stdcall +#elif defined(CJSON_IMPORT_SYMBOLS) +#define CJSON_PUBLIC(type) __declspec(dllimport) type __stdcall +#endif +#else /* !WIN32 */ +#if (defined(__GNUC__) || defined(__SUNPRO_CC) || defined (__SUNPRO_C)) && defined(CJSON_API_VISIBILITY) +#define CJSON_PUBLIC(type) __attribute__((visibility("default"))) type +#else +#define CJSON_PUBLIC(type) type +#endif +#endif + +/* Limits how deeply nested arrays/objects can be before cJSON rejects to parse them. + * This is to prevent stack overflows. */ +#ifndef CJSON_NESTING_LIMIT +#define CJSON_NESTING_LIMIT 1000 +#endif + +/* returns the version of cJSON as a string */ +CJSON_PUBLIC(const char*) cJSON_Version(void); + +/* Supply malloc, realloc and free functions to cJSON */ +CJSON_PUBLIC(void) cJSON_InitHooks(cJSON_Hooks* hooks); + +/* Memory Management: the caller is always responsible to free the results from all variants of cJSON_Parse (with cJSON_Delete) and cJSON_Print (with stdlib free, cJSON_Hooks.free_fn, or cJSON_free as appropriate). The exception is cJSON_PrintPreallocated, where the caller has full responsibility of the buffer. */ +/* Supply a block of JSON, and this returns a cJSON object you can interrogate. */ +CJSON_PUBLIC(cJSON *) cJSON_Parse(const char *value); +/* ParseWithOpts allows you to require (and check) that the JSON is null terminated, and to retrieve the pointer to the final byte parsed. */ +/* If you supply a ptr in return_parse_end and parsing fails, then return_parse_end will contain a pointer to the error so will match cJSON_GetErrorPtr(). */ +CJSON_PUBLIC(cJSON *) cJSON_ParseWithOpts(const char *value, const char **return_parse_end, cJSON_bool require_null_terminated); + +/* Render a cJSON entity to text for transfer/storage. */ +CJSON_PUBLIC(char *) cJSON_Print(const cJSON *item); +/* Render a cJSON entity to text for transfer/storage without any formatting. */ +CJSON_PUBLIC(char *) cJSON_PrintUnformatted(const cJSON *item); +/* Render a cJSON entity to text using a buffered strategy. prebuffer is a guess at the final size. guessing well reduces reallocation. fmt=0 gives unformatted, =1 gives formatted */ +CJSON_PUBLIC(char *) cJSON_PrintBuffered(const cJSON *item, int prebuffer, cJSON_bool fmt); +/* Render a cJSON entity to text using a buffer already allocated in memory with given length. Returns 1 on success and 0 on failure. */ +/* NOTE: cJSON is not always 100% accurate in estimating how much memory it will use, so to be safe allocate 5 bytes more than you actually need */ +CJSON_PUBLIC(cJSON_bool) cJSON_PrintPreallocated(cJSON *item, char *buffer, const int length, const cJSON_bool format); +/* Delete a cJSON entity and all subentities. */ +CJSON_PUBLIC(void) cJSON_Delete(cJSON *c); + +/* Returns the number of items in an array (or object). */ +CJSON_PUBLIC(int) cJSON_GetArraySize(const cJSON *array); +/* Retrieve item number "index" from array "array". Returns NULL if unsuccessful. */ +CJSON_PUBLIC(cJSON *) cJSON_GetArrayItem(const cJSON *array, int index); +/* Get item "string" from object. Case insensitive. */ +CJSON_PUBLIC(cJSON *) cJSON_GetObjectItem(const cJSON * const object, const char * const string); +CJSON_PUBLIC(cJSON *) cJSON_GetObjectItemCaseSensitive(const cJSON * const object, const char * const string); +CJSON_PUBLIC(cJSON_bool) cJSON_HasObjectItem(const cJSON *object, const char *string); +/* For analysing failed parses. This returns a pointer to the parse error. You'll probably need to look a few chars back to make sense of it. Defined when cJSON_Parse() returns 0. 0 when cJSON_Parse() succeeds. */ +CJSON_PUBLIC(const char *) cJSON_GetErrorPtr(void); + +/* Check if the item is a string and return its valuestring */ +CJSON_PUBLIC(char *) cJSON_GetStringValue(cJSON *item); + +/* These functions check the type of an item */ +CJSON_PUBLIC(cJSON_bool) cJSON_IsInvalid(const cJSON * const item); +CJSON_PUBLIC(cJSON_bool) cJSON_IsFalse(const cJSON * const item); +CJSON_PUBLIC(cJSON_bool) cJSON_IsTrue(const cJSON * const item); +CJSON_PUBLIC(cJSON_bool) cJSON_IsBool(const cJSON * const item); +CJSON_PUBLIC(cJSON_bool) cJSON_IsNull(const cJSON * const item); +CJSON_PUBLIC(cJSON_bool) cJSON_IsNumber(const cJSON * const item); +CJSON_PUBLIC(cJSON_bool) cJSON_IsString(const cJSON * const item); +CJSON_PUBLIC(cJSON_bool) cJSON_IsArray(const cJSON * const item); +CJSON_PUBLIC(cJSON_bool) cJSON_IsObject(const cJSON * const item); +CJSON_PUBLIC(cJSON_bool) cJSON_IsRaw(const cJSON * const item); + +/* These calls create a cJSON item of the appropriate type. */ +CJSON_PUBLIC(cJSON *) cJSON_CreateNull(void); +CJSON_PUBLIC(cJSON *) cJSON_CreateTrue(void); +CJSON_PUBLIC(cJSON *) cJSON_CreateFalse(void); +CJSON_PUBLIC(cJSON *) cJSON_CreateBool(cJSON_bool boolean); +CJSON_PUBLIC(cJSON *) cJSON_CreateNumber(double num); +CJSON_PUBLIC(cJSON *) cJSON_CreateString(const char *string); +/* raw json */ +CJSON_PUBLIC(cJSON *) cJSON_CreateRaw(const char *raw); +CJSON_PUBLIC(cJSON *) cJSON_CreateArray(void); +CJSON_PUBLIC(cJSON *) cJSON_CreateObject(void); + +/* Create a string where valuestring references a string so + * it will not be freed by cJSON_Delete */ +CJSON_PUBLIC(cJSON *) cJSON_CreateStringReference(const char *string); +/* Create an object/arrray that only references it's elements so + * they will not be freed by cJSON_Delete */ +CJSON_PUBLIC(cJSON *) cJSON_CreateObjectReference(const cJSON *child); +CJSON_PUBLIC(cJSON *) cJSON_CreateArrayReference(const cJSON *child); + +/* These utilities create an Array of count items. */ +CJSON_PUBLIC(cJSON *) cJSON_CreateIntArray(const int *numbers, int count); +CJSON_PUBLIC(cJSON *) cJSON_CreateFloatArray(const float *numbers, int count); +CJSON_PUBLIC(cJSON *) cJSON_CreateDoubleArray(const double *numbers, int count); +CJSON_PUBLIC(cJSON *) cJSON_CreateStringArray(const char **strings, int count); + +/* Append item to the specified array/object. */ +CJSON_PUBLIC(void) cJSON_AddItemToArray(cJSON *array, cJSON *item); +CJSON_PUBLIC(void) cJSON_AddItemToObject(cJSON *object, const char *string, cJSON *item); +/* Use this when string is definitely const (i.e. a literal, or as good as), and will definitely survive the cJSON object. + * WARNING: When this function was used, make sure to always check that (item->type & cJSON_StringIsConst) is zero before + * writing to `item->string` */ +CJSON_PUBLIC(void) cJSON_AddItemToObjectCS(cJSON *object, const char *string, cJSON *item); +/* Append reference to item to the specified array/object. Use this when you want to add an existing cJSON to a new cJSON, but don't want to corrupt your existing cJSON. */ +CJSON_PUBLIC(void) cJSON_AddItemReferenceToArray(cJSON *array, cJSON *item); +CJSON_PUBLIC(void) cJSON_AddItemReferenceToObject(cJSON *object, const char *string, cJSON *item); + +/* Remove/Detatch items from Arrays/Objects. */ +CJSON_PUBLIC(cJSON *) cJSON_DetachItemViaPointer(cJSON *parent, cJSON * const item); +CJSON_PUBLIC(cJSON *) cJSON_DetachItemFromArray(cJSON *array, int which); +CJSON_PUBLIC(void) cJSON_DeleteItemFromArray(cJSON *array, int which); +CJSON_PUBLIC(cJSON *) cJSON_DetachItemFromObject(cJSON *object, const char *string); +CJSON_PUBLIC(cJSON *) cJSON_DetachItemFromObjectCaseSensitive(cJSON *object, const char *string); +CJSON_PUBLIC(void) cJSON_DeleteItemFromObject(cJSON *object, const char *string); +CJSON_PUBLIC(void) cJSON_DeleteItemFromObjectCaseSensitive(cJSON *object, const char *string); + +/* Update array items. */ +CJSON_PUBLIC(void) cJSON_InsertItemInArray(cJSON *array, int which, cJSON *newitem); /* Shifts pre-existing items to the right. */ +CJSON_PUBLIC(cJSON_bool) cJSON_ReplaceItemViaPointer(cJSON * const parent, cJSON * const item, cJSON * replacement); +CJSON_PUBLIC(void) cJSON_ReplaceItemInArray(cJSON *array, int which, cJSON *newitem); +CJSON_PUBLIC(void) cJSON_ReplaceItemInObject(cJSON *object,const char *string,cJSON *newitem); +CJSON_PUBLIC(void) cJSON_ReplaceItemInObjectCaseSensitive(cJSON *object,const char *string,cJSON *newitem); + +/* Duplicate a cJSON item */ +CJSON_PUBLIC(cJSON *) cJSON_Duplicate(const cJSON *item, cJSON_bool recurse); +/* Duplicate will create a new, identical cJSON item to the one you pass, in new memory that will +need to be released. With recurse!=0, it will duplicate any children connected to the item. +The item->next and ->prev pointers are always zero on return from Duplicate. */ +/* Recursively compare two cJSON items for equality. If either a or b is NULL or invalid, they will be considered unequal. + * case_sensitive determines if object keys are treated case sensitive (1) or case insensitive (0) */ +CJSON_PUBLIC(cJSON_bool) cJSON_Compare(const cJSON * const a, const cJSON * const b, const cJSON_bool case_sensitive); + + +CJSON_PUBLIC(void) cJSON_Minify(char *json); + +/* Helper functions for creating and adding items to an object at the same time. + * They return the added item or NULL on failure. */ +CJSON_PUBLIC(cJSON*) cJSON_AddNullToObject(cJSON * const object, const char * const name); +CJSON_PUBLIC(cJSON*) cJSON_AddTrueToObject(cJSON * const object, const char * const name); +CJSON_PUBLIC(cJSON*) cJSON_AddFalseToObject(cJSON * const object, const char * const name); +CJSON_PUBLIC(cJSON*) cJSON_AddBoolToObject(cJSON * const object, const char * const name, const cJSON_bool boolean); +CJSON_PUBLIC(cJSON*) cJSON_AddNumberToObject(cJSON * const object, const char * const name, const double number); +CJSON_PUBLIC(cJSON*) cJSON_AddStringToObject(cJSON * const object, const char * const name, const char * const string); +CJSON_PUBLIC(cJSON*) cJSON_AddRawToObject(cJSON * const object, const char * const name, const char * const raw); +CJSON_PUBLIC(cJSON*) cJSON_AddObjectToObject(cJSON * const object, const char * const name); +CJSON_PUBLIC(cJSON*) cJSON_AddArrayToObject(cJSON * const object, const char * const name); + +/* When assigning an integer value, it needs to be propagated to valuedouble too. */ +#define cJSON_SetIntValue(object, number) ((object) ? (object)->valueint = (object)->valuedouble = (number) : (number)) +/* helper for the cJSON_SetNumberValue macro */ +CJSON_PUBLIC(double) cJSON_SetNumberHelper(cJSON *object, double number); +#define cJSON_SetNumberValue(object, number) ((object != NULL) ? cJSON_SetNumberHelper(object, (double)number) : (number)) + +/* Macro for iterating over an array or object */ +#define cJSON_ArrayForEach(element, array) for(element = (array != NULL) ? (array)->child : NULL; element != NULL; element = element->next) + +/* malloc/free objects using the malloc/free functions that have been set with cJSON_InitHooks */ +CJSON_PUBLIC(void *) cJSON_malloc(size_t size); +CJSON_PUBLIC(void) cJSON_free(void *object); + +#ifdef __cplusplus +} +#endif + +#endif From d603212765967623632a8f6b782eba8680f1bd9e Mon Sep 17 00:00:00 2001 From: m Date: Tue, 11 Sep 2018 17:24:11 +0200 Subject: [PATCH 3/6] Add support for JSON configuration files --- src/configuration.cpp | 140 +++++++++++++++++++++++++++++++----------- src/configuration.hpp | 19 ++---- src/main.cpp | 8 ++- 3 files changed, 116 insertions(+), 51 deletions(-) diff --git a/src/configuration.cpp b/src/configuration.cpp index 581b44e..2ce78b9 100644 --- a/src/configuration.cpp +++ b/src/configuration.cpp @@ -21,14 +21,17 @@ #include "file_utils.hpp" +#include + #include +#include #include namespace bcache { namespace { // Various constants. const std::string ROOT_FOLDER_NAME = ".buildcache"; -const std::string CONFIGURATION_FILE_NAME = "buildcache.conf"; +const std::string CONFIGURATION_FILE_NAME = "config.json"; const int64_t DEFAULT_MAX_CACHE_SIZE = 5368709120L; // 5 GB // Configuration options. @@ -65,11 +68,11 @@ public: return m_value; } - const int64_t as_int64() const { + int64_t as_int64() const { return std::stoll(m_value); } - const bool as_bool() const { + bool as_bool() const { const auto value_lower = to_lower(m_value); return m_defined && (!m_value.empty()) && (value_lower != "false") && (value_lower != "no") && (value_lower != "off") && (value_lower != "0"); @@ -102,27 +105,80 @@ std::string get_dir() { throw std::runtime_error("Unable to determine a home directory for BuildCache."); } -string_list_t get_lua_paths(const std::string& dir) { - string_list_t paths; +void load_from_file(const std::string& file_name) { + // Load the configuration file. + if (!file::file_exists(file_name)) { + // Nothing to do. + return; + } + const auto data = file::read(file_name); - // The BUILDCACHE_LUA_PATH env variable can contain a colon-separated list of paths. + // Parse the JSON data. + auto* root = cJSON_Parse(data.data()); + if (root == nullptr) { + std::ostringstream ss; + ss << "Configuration file JSON parse error before:\n"; + const auto* json_error = cJSON_GetErrorPtr(); + if (json_error != nullptr) { + ss << json_error; + } else { + ss << "(N/A)"; + } + throw std::runtime_error(ss.str()); + } + + // Get "lua_paths". { - const env_var_t lua_path_env("BUILDCACHE_LUA_PATH"); - if (lua_path_env) { -#ifdef _WIN32 - paths += string_list_t(lua_path_env.as_string(), ";"); -#else - paths += string_list_t(lua_path_env.as_string(), ":"); -#endif + const auto* node = cJSON_GetObjectItemCaseSensitive(root, "lua_paths"); + cJSON* child_node; + cJSON_ArrayForEach(child_node, node) { + const auto str = std::string(child_node->valuestring); + s_lua_paths += str; } } - // We also look for Lua files in the cache root dir (e.g. ${BUILDCACHE_DIR}/lua). - paths += file::append_path(dir, "lua"); + // Get "prefix". + { + const auto* node = cJSON_GetObjectItemCaseSensitive(root, "prefix"); + if (cJSON_IsString(node) && node->valuestring != nullptr) { + s_prefix = std::string(node->valuestring); + } + } - return paths; + // Get "max_cache_size". + { + const auto* node = cJSON_GetObjectItemCaseSensitive(root, "max_cache_size"); + if (cJSON_IsNumber(node)) { + s_max_cache_size = static_cast(node->valuedouble); + } + } + + // Get "debug". + { + const auto* node = cJSON_GetObjectItemCaseSensitive(root, "debug"); + if (cJSON_IsNumber(node)) { + s_debug = static_cast(node->valueint); + } + } + + // Get "perf". + { + const auto* node = cJSON_GetObjectItemCaseSensitive(root, "perf"); + if (cJSON_IsBool(node)) { + s_perf = cJSON_IsTrue(node); + } + } + + // Get "disable". + { + const auto* node = cJSON_GetObjectItemCaseSensitive(root, "disable"); + if (cJSON_IsBool(node)) { + s_disable = cJSON_IsTrue(node); + } + } + + cJSON_Delete(root); } - } // namespace namespace config { @@ -134,12 +190,37 @@ void init() { } s_initialized = true; + // TODO(m): If we get an exception during get_dir() or load_from_file() for instance, those error + // messages will never be printed, *even* when BUILDCACHE_DEBUG=1 is passed in the environment. + // We need to untie this catch-22. try { // Get the BuildCache home directory. s_dir = get_dir(); - // Get the Lua paths. - s_lua_paths = get_lua_paths(s_dir); + // Get the Lua paths from the environment. + // Note: We need do this before loading the configuration file, in order for the environment to + // have priority over the JSON file. + { + const env_var_t lua_path_env("BUILDCACHE_LUA_PATH"); + if (lua_path_env) { + #ifdef _WIN32 + s_lua_paths += string_list_t(lua_path_env.as_string(), ";"); + #else + s_lua_paths += string_list_t(lua_path_env.as_string(), ":"); + #endif + } + } + + // Load any paramaters from the user configuration file. + // Note: We do this before reading the configuration from the environment, so that the + // environment overrides the configuration file. + const auto config_file = file::append_path(s_dir, CONFIGURATION_FILE_NAME); + load_from_file(config_file); + + // We also look for Lua files in the cache root dir (e.g. ${BUILDCACHE_DIR}/lua). + // Note: We need do this after loading the configuration file, to give the default Lua path the + // lowest priority. + s_lua_paths += file::append_path(s_dir, "lua"); // Get the command prefix from the environment. { @@ -191,21 +272,10 @@ void init() { } catch (...) { // If we could not initialize the configuration, we can't proceed. We need to disable the cache. s_disable = true; + throw; } } -void update(const std::string& file_name) { - // TODO(m): Implement me! -} - -void update(const std::map& options) { - // TODO(m): Implement me! -} - -void save_to_file(const std::string& file_name) { - // TODO(m): Implement me! -} - const std::string& dir() { return s_dir; } @@ -218,19 +288,19 @@ const std::string& prefix() { return s_prefix; } -const int64_t max_cache_size() { +int64_t max_cache_size() { return s_max_cache_size; } -const int32_t debug() { +int32_t debug() { return s_debug; } -const bool perf() { +bool perf() { return s_perf; } -const bool disable() { +bool disable() { return s_disable; } } // namespace config diff --git a/src/configuration.hpp b/src/configuration.hpp index a81410f..68e3d96 100644 --- a/src/configuration.hpp +++ b/src/configuration.hpp @@ -31,17 +31,6 @@ namespace config { /// @brief Initialize the configuration based on environment variables etc. void init(); -/// @brief Update configuration options from the given file. -/// @param file_name The name of the file to load the options from. -void update(const std::string& file_name); - -/// @brief Update configuration options from a key-value options map. -/// @param options A key-value map containing the options. -void update(const std::map& options); - -/// @brief Save the configuration options object to a file. -void save_to_file(const std::string& file_name); - /// @returns the BuildCache home directory. const std::string& dir(); @@ -52,16 +41,16 @@ const string_list_t& lua_paths(); const std::string& prefix(); /// @returns the maximum cache size (in bytes). -const int64_t max_cache_size(); +int64_t max_cache_size(); /// @returns the debug level (-1 for no debugging). -const int32_t debug(); +int32_t debug(); /// @returns true if performance profiling output is enabled. -const bool perf(); +bool perf(); /// @returns true if BuildCache is disabled. -const bool disable(); +bool disable(); } // namespace config } // namespace bcache diff --git a/src/main.cpp b/src/main.cpp index f790224..6e80e6d 100644 --- a/src/main.cpp +++ b/src/main.cpp @@ -273,7 +273,13 @@ void print_help(const char* program_name) { int main(int argc, const char** argv) { // Initialize the configuration. - bcache::config::init(); + try { + bcache::config::init(); + } catch (const std::exception& e) { + bcache::debug::log(bcache::debug::ERROR) << "Warning: " << e.what(); + } catch (...) { + bcache::debug::log(bcache::debug::ERROR) << "An exception occurred."; + } // Handle symlink invokation. if (bcache::file::get_file_part(std::string(argv[0]), false) != BUILDCACHE_EXE_NAME) { From 60b58c71e1f7ef1af7af6aeca8567de8f99af214 Mon Sep 17 00:00:00 2001 From: m Date: Wed, 12 Sep 2018 09:26:05 +0200 Subject: [PATCH 4/6] More consistent cache stats printout --- src/cache.cpp | 21 ++++++++++++--------- 1 file changed, 12 insertions(+), 9 deletions(-) diff --git a/src/cache.cpp b/src/cache.cpp index 2c021a1..f1dbc7e 100644 --- a/src/cache.cpp +++ b/src/cache.cpp @@ -54,6 +54,7 @@ #include #include #include +#include #include #include @@ -204,16 +205,18 @@ void cache_t::show_stats() { num_entries++; total_size += dir.size(); } - const double total_size_mb = static_cast(total_size) / (1024.0 * 1024.0); - const double max_size_mb = static_cast(config::max_cache_size()) / (1024.0 * 1024.0); + const auto total_size_mib = static_cast(total_size) / (1024.0 * 1024.0); + const auto max_size_mib = static_cast(config::max_cache_size()) / (1024.0 * 1024.0); + const auto full_percentage = 100.0 * total_size_mib / max_size_mib; - std::cout << "cache directory: " << config::dir() << "\n"; - // std::cout << "primary config: " << get_configuration_file_name() << "\n"; - std::cout << "entries in cache: " << num_entries << "\n"; - std::cout << "cache size: " << total_size_mb << " MB\n"; - std::cout << "max cache size: " << max_size_mb << " MB\n"; - - // TODO(m): Implement more stats. + // Print stats. + std::ios old_fmt(nullptr); + old_fmt.copyfmt(std::cout); + std::cout << std::setiosflags(std::ios::fixed) << std::setprecision(1); + std::cout << " Entries in cache: " << num_entries << "\n"; + std::cout << " Cache size: " << total_size_mib << " MiB (" << full_percentage + << "%)\n"; + std::cout.copyfmt(old_fmt); } void cache_t::add(const hasher_t::hash_t& hash, const cache_t::entry_t& entry) { From 5f204cb4f9ba9359cbd3b131e8f01a1f9014b3f9 Mon Sep 17 00:00:00 2001 From: m Date: Wed, 12 Sep 2018 09:35:23 +0200 Subject: [PATCH 5/6] Add an option for disabling hard links --- src/cache.cpp | 10 ++++++++-- src/cache.hpp | 3 ++- src/configuration.cpp | 27 ++++++++++++++++++++++++--- src/configuration.hpp | 3 +++ src/main.cpp | 2 ++ src/program_wrapper.cpp | 13 +++++++++++-- 6 files changed, 50 insertions(+), 8 deletions(-) diff --git a/src/cache.cpp b/src/cache.cpp index f1dbc7e..7ab0b95 100644 --- a/src/cache.cpp +++ b/src/cache.cpp @@ -219,7 +219,9 @@ void cache_t::show_stats() { std::cout.copyfmt(old_fmt); } -void cache_t::add(const hasher_t::hash_t& hash, const cache_t::entry_t& entry) { +void cache_t::add(const hasher_t::hash_t& hash, + const cache_t::entry_t& entry, + const bool allow_hard_links) { // Create the required directories in the cache. const auto cache_entry_path = hash_to_cache_entry_path(hash); const auto cache_entry_parent_path = file::get_dir_part(cache_entry_path); @@ -233,7 +235,11 @@ void cache_t::add(const hasher_t::hash_t& hash, const cache_t::entry_t& entry) { // Copy the files into the cache. for (const auto& file : entry.files) { const auto target_path = file::append_path(cache_entry_path, file.first); - file::link_or_copy(file.second, target_path); + if (allow_hard_links) { + file::link_or_copy(file.second, target_path); + } else { + file::copy(file.second, target_path); + } } // Create a cache entry file. diff --git a/src/cache.hpp b/src/cache.hpp index be525bb..0331ec1 100644 --- a/src/cache.hpp +++ b/src/cache.hpp @@ -60,7 +60,8 @@ public: /// @brief Adds a set of files to the cache /// @param hash The cache entry identifier. /// @param entry The cache entry data (files, stdout, etc). - void add(const hasher_t::hash_t& hash, const entry_t& entry); + /// @param allow_hard_links Whether or not to allow hard links to be used when caching files. + void add(const hasher_t::hash_t& hash, const entry_t& entry, const bool allow_hard_links); /// @brief Check if an entry exists in the cache. /// @returns A cache hit struct. diff --git a/src/configuration.cpp b/src/configuration.cpp index 2ce78b9..7000e59 100644 --- a/src/configuration.cpp +++ b/src/configuration.cpp @@ -40,6 +40,7 @@ string_list_t s_lua_paths; std::string s_prefix; int64_t s_max_cache_size = DEFAULT_MAX_CACHE_SIZE; int32_t s_debug = -1; +bool s_hard_links = true; bool s_perf = false; bool s_disable = false; @@ -161,6 +162,14 @@ void load_from_file(const std::string& file_name) { } } + // Get "hard_links". + { + const auto* node = cJSON_GetObjectItemCaseSensitive(root, "hard_links"); + if (cJSON_IsBool(node)) { + s_hard_links = cJSON_IsTrue(node); + } + } + // Get "perf". { const auto* node = cJSON_GetObjectItemCaseSensitive(root, "perf"); @@ -203,11 +212,11 @@ void init() { { const env_var_t lua_path_env("BUILDCACHE_LUA_PATH"); if (lua_path_env) { - #ifdef _WIN32 +#ifdef _WIN32 s_lua_paths += string_list_t(lua_path_env.as_string(), ";"); - #else +#else s_lua_paths += string_list_t(lua_path_env.as_string(), ":"); - #endif +#endif } } @@ -254,6 +263,14 @@ void init() { } } + // Get the hard_links flag from the environment. + { + const env_var_t hard_links_env("BUILDCACHE_HARD_LINKS"); + if (hard_links_env) { + s_hard_links = hard_links_env.as_bool(); + } + } + // Get the perf flag from the environment. { const env_var_t perf_env("BUILDCACHE_PERF"); @@ -296,6 +313,10 @@ int32_t debug() { return s_debug; } +bool hard_links() { + return s_hard_links; +} + bool perf() { return s_perf; } diff --git a/src/configuration.hpp b/src/configuration.hpp index 68e3d96..4081dd6 100644 --- a/src/configuration.hpp +++ b/src/configuration.hpp @@ -46,6 +46,9 @@ int64_t max_cache_size(); /// @returns the debug level (-1 for no debugging). int32_t debug(); +/// @returns true if BuildCache should use hard links when possible. +bool hard_links(); + /// @returns true if performance profiling output is enabled. bool perf(); diff --git a/src/main.cpp b/src/main.cpp index 6e80e6d..b6d401f 100644 --- a/src/main.cpp +++ b/src/main.cpp @@ -131,6 +131,8 @@ std::unique_ptr find_suitable_wrapper(const bcache::s std::cout << " BUILDCACHE_PREFIX: " << bcache::config::prefix() << "\n"; std::cout << " BUILDCACHE_MAX_CACHE_SIZE: " << bcache::config::max_cache_size() << "\n"; std::cout << " BUILDCACHE_DEBUG: " << bcache::config::debug() << "\n"; + std::cout << " BUILDCACHE_HARD_LINKS: " + << (bcache::config::hard_links() ? "true" : "false") << "\n"; std::cout << " BUILDCACHE_PERF: " << (bcache::config::perf() ? "true" : "false") << "\n"; std::cout << " BUILDCACHE_DISABLE: " << (bcache::config::disable() ? "true" : "false") diff --git a/src/program_wrapper.cpp b/src/program_wrapper.cpp index a5aa092..b8ad140 100644 --- a/src/program_wrapper.cpp +++ b/src/program_wrapper.cpp @@ -19,6 +19,7 @@ #include "program_wrapper.hpp" +#include "configuration.hpp" #include "debug_utils.hpp" #include "hasher.hpp" #include "perf_utils.hpp" @@ -66,6 +67,10 @@ bool program_wrapper_t::handle_command(int& return_code) { // Finalize the hash. const auto hash = hasher.final(); + // Check if we can use hard links. + // TODO(m): Add support for disabling hard links on a per wrapper basis. + auto allow_hard_links = config::hard_links(); + // Look up the entry in the cache. PERF_START(CACHE_LOOKUP); const auto cached_entry = m_cache.lookup(hash); @@ -84,7 +89,11 @@ bool program_wrapper_t::handle_command(int& return_code) { const auto& source_file = file.second; debug::log(debug::INFO) << "Cache hit (" << hash.as_string() << "): " << source_file << " => " << target_file; - file::link_or_copy(source_file, target_file); + if (allow_hard_links) { + file::link_or_copy(source_file, target_file); + } else { + file::copy(source_file, target_file); + } } // Return/print the cached program results. @@ -122,7 +131,7 @@ bool program_wrapper_t::handle_command(int& return_code) { new_entry.std_err = result.std_err; new_entry.return_code = result.return_code; PERF_START(ADD_TO_CACHE); - m_cache.add(hash, new_entry); + m_cache.add(hash, new_entry, allow_hard_links); PERF_STOP(ADD_TO_CACHE); } From 028b9ab49533a4e81cf6a929a42f201203bd62c5 Mon Sep 17 00:00:00 2001 From: m Date: Wed, 12 Sep 2018 09:53:46 +0200 Subject: [PATCH 6/6] Document configuration options in README.md --- README.md | 44 ++++++++++++++++++++++++++++++++++++-------- 1 file changed, 36 insertions(+), 8 deletions(-) diff --git a/README.md b/README.md index bbad609..4d939c8 100644 --- a/README.md +++ b/README.md @@ -119,15 +119,43 @@ $ BUILDCACHE_DEBUG=2 buildcache g++ -c -O2 hello.cpp -o hello.o ## Configuration options -The following environment variables control the behavior of BuildCache: +BuildCache can be configured via environment variables and a per-cache JSON +configuration file. The optinal configuration file is located in the cache +root directory, and is called `config.json` (e.g. +`$HOME/.buildcache/config.json`). -| Option | Description | Default | -| --- | --- | --- | -| `BUILDCACHE_DIR` | The cache root directory | `$HOME/.buildcache` | -| `BUILDCACHE_PREFIX` | Prefix command for cache misses | None | -| `BUILDCACHE_LUA_PATH` | Path(s) to Lua wrappers | None | -| `BUILDCACHE_DEBUG` | Debug level | None | -| `BUILDCACHE_PERF` | Enable performance logging | Disabled | +The following options control the behavior of BuildCache: + +| Env | JSON | Description | Default | +| --- | --- | --- | --- | +| `BUILDCACHE_DIR` | - | The cache root directory | `$HOME/.buildcache` | +| `BUILDCACHE_PREFIX` | `prefix` | Prefix command for cache misses | None | +| `BUILDCACHE_LUA_PATH` | `lua_paths` | Extra path(s) to Lua wrappers | None | +| `BUILDCACHE_DEBUG` | `debug` | Debug level | None | +| `BUILDCACHE_MAX_CACHE_SIZE` | `max_cache_size` | Cache size limit in bytes | 5368709120 | +| `BUILDCACHE_HARD_LINKS` | `hard_links` | Allow the use of hard links when caching | true | +| `BUILDCACHE_PERF` | `perf` | Enable performance logging | false | +| `BUILDCACHE_DISABLE` | `disable` | Disable caching (bypass BuildCache) | false | + +An example configuration file: + +```json +{ + "max_cache_size": 10000000000, + "prefix": "icecc", + "debug": 3, + "lua_paths": [ + "/home/myname/buildcache-lua", + "/opt/buildcache-lua" + ] +} +``` + +To see the configuration options that are in effect, run: + +```bash +$ buildcache -s +``` ## Status