From 1dd83cf7e527ff29d734f6a2c8f9b61d39b41d94 Mon Sep 17 00:00:00 2001 From: Muhammad Moinur Rahman Date: Wed, 7 Jan 2026 19:19:44 +0100 Subject: Import libucl 0.9.3 --- .clang-format | 67 + .github/workflows/cmake-multi-platform.yml | 2 +- CMakeLists.txt | 37 +- ChangeLog.md | 10 + configure.ac | 11 +- include/lua_ucl.h | 18 +- include/ucl++.h | 568 ++++---- include/ucl.h | 681 +++++----- lua/lua_ucl.c | 8 +- m4/gcov.m4 | 2 +- src/mum.h | 365 ++--- src/tree.h | 314 +++-- src/ucl_chartable.h | 463 ++++--- src/ucl_emitter.c | 459 +++---- src/ucl_emitter_streamline.c | 68 +- src/ucl_emitter_utils.c | 279 ++-- src/ucl_hash.c | 314 ++--- src/ucl_hash.h | 32 +- src/ucl_internal.h | 211 +-- src/ucl_msgpack.c | 1188 ++++++++-------- src/ucl_parser.c | 1466 ++++++++++---------- src/ucl_schema.c | 697 +++++----- src/ucl_sexp.c | 123 +- src/ucl_util.c | 2011 ++++++++++++++-------------- tests/CMakeLists.txt | 31 + tests/Makefile.am | 8 +- tests/basic/23-json-with-braces.inc | 1 + tests/basic/23-json-without-braces.inc | 2 + tests/basic/23-ucl-with-braces.inc | 1 + tests/basic/23-ucl-without-braces.inc | 1 + tests/basic/23.in | 8 + tests/basic/23.res | 9 + tests/basic/comments.in | 4 + tests/basic/issue319.in | 3 + tests/basic/issue319.res | 2 + tests/test_generate.c | 16 +- tests/test_schema.c | 7 +- tests/test_speed.c | 15 +- utils/CMakeLists.txt | 4 + utils/ucl-tool.c | 293 ++-- 40 files changed, 5003 insertions(+), 4796 deletions(-) create mode 100644 .clang-format create mode 100644 tests/CMakeLists.txt create mode 100644 tests/basic/23-json-with-braces.inc create mode 100644 tests/basic/23-json-without-braces.inc create mode 100644 tests/basic/23-ucl-with-braces.inc create mode 100644 tests/basic/23-ucl-without-braces.inc create mode 100644 tests/basic/23.in create mode 100644 tests/basic/23.res create mode 100644 tests/basic/issue319.in create mode 100644 tests/basic/issue319.res diff --git a/.clang-format b/.clang-format new file mode 100644 index 000000000000..89beadc23900 --- /dev/null +++ b/.clang-format @@ -0,0 +1,67 @@ +# Generated from CLion C/C++ Code Style settings +BasedOnStyle: LLVM +AccessModifierOffset: -4 +AlignAfterOpenBracket: Align +AlignConsecutiveAssignments: None +AlignOperands: Align +AllowAllArgumentsOnNextLine: false +AllowAllConstructorInitializersOnNextLine: false +AllowAllParametersOfDeclarationOnNextLine: false +AllowShortBlocksOnASingleLine: Always +AllowShortCaseLabelsOnASingleLine: false +AllowShortFunctionsOnASingleLine: None +AllowShortIfStatementsOnASingleLine: Always +AllowShortLambdasOnASingleLine: All +AllowShortLoopsOnASingleLine: true +AlwaysBreakAfterReturnType: None +AlwaysBreakTemplateDeclarations: Yes +BreakBeforeBraces: Custom +BraceWrapping: + AfterCaseLabel: false + AfterClass: false + AfterControlStatement: Never + AfterEnum: false + AfterFunction: true + AfterNamespace: false + AfterUnion: false + BeforeCatch: false + BeforeElse: true + IndentBraces: false + SplitEmptyFunction: true + SplitEmptyRecord: true +BreakBeforeBinaryOperators: None +BreakBeforeTernaryOperators: true +BreakConstructorInitializers: BeforeColon +BreakInheritanceList: BeforeColon +ColumnLimit: 0 +CompactNamespaces: false +ContinuationIndentWidth: 4 +IndentCaseLabels: false +IndentPPDirectives: None +IndentWidth: 4 +KeepEmptyLinesAtTheStartOfBlocks: true +MaxEmptyLinesToKeep: 2 +NamespaceIndentation: None +ObjCSpaceAfterProperty: false +ObjCSpaceBeforeProtocolList: true +PointerAlignment: Right +ReflowComments: false +SortIncludes: Never +SpaceAfterCStyleCast: true +SpaceAfterLogicalNot: false +SpaceAfterTemplateKeyword: false +SpaceBeforeAssignmentOperators: true +SpaceBeforeCpp11BracedList: false +SpaceBeforeCtorInitializerColon: true +SpaceBeforeInheritanceColon: true +SpaceBeforeParens: ControlStatements +SpaceBeforeRangeBasedForLoopColon: false +SpaceInEmptyParentheses: false +SpacesBeforeTrailingComments: 0 +SpacesInAngles: false +SpacesInCStyleCastParentheses: false +SpacesInContainerLiterals: false +SpacesInParentheses: false +SpacesInSquareBrackets: false +TabWidth: 4 +UseTab: ForContinuationAndIndentation diff --git a/.github/workflows/cmake-multi-platform.yml b/.github/workflows/cmake-multi-platform.yml index 9ec0432eeb03..bcc24a602870 100644 --- a/.github/workflows/cmake-multi-platform.yml +++ b/.github/workflows/cmake-multi-platform.yml @@ -72,4 +72,4 @@ jobs: working-directory: ${{ steps.strings.outputs.build-output-dir }} # Execute tests defined by the CMake configuration. Note that --build-config is needed because the default Windows generator is a multi-config generator (Visual Studio generator). # See https://cmake.org/cmake/help/latest/manual/ctest.1.html for more detail - run: ctest --build-config ${{ matrix.build_type }} + run: ctest --progress --output-on-failure --build-config ${{ matrix.build_type }} diff --git a/CMakeLists.txt b/CMakeLists.txt index 3d73910c887a..6bb2622a8622 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -1,9 +1,9 @@ -CMAKE_MINIMUM_REQUIRED(VERSION 3.1.0 FATAL_ERROR) +CMAKE_MINIMUM_REQUIRED(VERSION 3.5.0 FATAL_ERROR) PROJECT(libucl C) SET(LIBUCL_VERSION_MAJOR 0) SET(LIBUCL_VERSION_MINOR 9) -SET(LIBUCL_VERSION_PATCH 2) +SET(LIBUCL_VERSION_PATCH 3) SET(LIBUCL_VERSION "${LIBUCL_VERSION_MAJOR}.${LIBUCL_VERSION_MINOR}.${LIBUCL_VERSION_PATCH}") @@ -19,6 +19,9 @@ OPTION(BUILD_SHARED_LIBS "Build Shared Libraries [default: OFF]" OFF) OPTION(ENABLE_LUA "Enable lua support [default: OFF]" OFF) OPTION(ENABLE_LUAJIT "Enable luajit support [default: OFF]" OFF) OPTION(ENABLE_UTILS "Enable building utility binaries [default: OFF]" OFF) +OPTION(ENABLE_SANITIZERS "Enable sanitizers (address, undefined, etc.) [default: OFF]" OFF) +SET(SANITIZE_TYPE "address" CACHE STRING "Type of sanitizer to use (address, thread, undefined, memory, leak)") +SET_PROPERTY(CACHE SANITIZE_TYPE PROPERTY STRINGS address thread undefined memory leak) # Find lua installation MACRO(FindLua) @@ -195,6 +198,23 @@ ENDIF(SUPPORT_WUNUSED_PARAMETER) SET( CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${CMAKE_C_WARN_FLAGS}" ) +IF(ENABLE_SANITIZERS MATCHES "ON") + SET(SANITIZE_FLAGS "-fsanitize=${SANITIZE_TYPE} -fno-omit-frame-pointer -fno-optimize-sibling-calls") + SET(CMAKE_REQUIRED_FLAGS "${SANITIZE_FLAGS}") + SET(CMAKE_REQUIRED_LIBRARIES "${SANITIZE_FLAGS}") + CHECK_C_SOURCE_COMPILES("int main() { return 0; }" COMPILER_SUPPORTS_SANITIZE) + UNSET(CMAKE_REQUIRED_FLAGS) + UNSET(CMAKE_REQUIRED_LIBRARIES) + IF(COMPILER_SUPPORTS_SANITIZE) + MESSAGE(STATUS "Enabling sanitizer: ${SANITIZE_TYPE}") + SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${SANITIZE_FLAGS}") + SET(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} ${SANITIZE_FLAGS}") + SET(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} ${SANITIZE_FLAGS}") + ELSE() + MESSAGE(WARNING "Compiler does not support -fsanitize=${SANITIZE_TYPE}") + ENDIF() +ENDIF() + IF(ENABLE_URL_SIGN MATCHES "ON") IF(OPENSSL_FOUND) SET(HAVE_OPENSSL 1) @@ -258,10 +278,12 @@ IF(ENABLE_LUA MATCHES "ON") INCLUDE_DIRECTORIES("${LUA_INCLUDE_DIR}") ENDIF(NOT LUA_FOUND) ELSE(ENABLE_LUAJIT MATCHES "ON") - FindLua(VERSION_MAJOR "5" VERSION_MINOR "2" ROOT "${LUA_ROOT}") - IF(NOT LUA_FOUND) - FindLua(VERSION_MAJOR "5" VERSION_MINOR "1" ROOT "${LUA_ROOT}") - ENDIF(NOT LUA_FOUND) + FOREACH(LUA_MINOR RANGE 4 1 -1) + FindLua(VERSION_MAJOR "5" VERSION_MINOR ${LUA_MINOR} ROOT "${LUA_ROOT}") + IF(LUA_FOUND) + BREAK() + ENDIF(LUA_FOUND) + ENDFOREACH(LUA_MINOR RANGE 4 1 -1) IF(NOT LUA_FOUND) MESSAGE(FATAL_ERROR "Lua not found, lua support is required") ELSE(NOT LUA_FOUND) @@ -309,6 +331,9 @@ SET_TARGET_PROPERTIES(ucl PROPERTIES INSTALL(TARGETS ucl EXPORT uclConfig DESTINATION ${CMAKE_INSTALL_LIBDIR} PUBLIC_HEADER DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}) +ENABLE_TESTING() +ADD_SUBDIRECTORY(tests) + IF(ENABLE_UTILS MATCHES "ON") ADD_SUBDIRECTORY(utils) ENDIF() diff --git a/ChangeLog.md b/ChangeLog.md index b32b9e08d019..bf76b8e517e9 100644 --- a/ChangeLog.md +++ b/ChangeLog.md @@ -1,5 +1,15 @@ # Version history +## Libucl 0.9.3 + +- Fix invalid JSON emission when merging objects (Fixes #312) +- Fix heap-buffer-overflow in ucl_maybe_parse_number (Fixes #344, #328) +- Fix Use-After-Free in ucl_hash_insert by ignoring duplicates in different containers (Fixes #347) +- Fix heap-buffer-overflow in ucl_parse_multiline_string +- Add support of sanitizers to cmake +- Fix allocator mismatches in libucl +- Various other fixes and improvements + ## Libucl 0.9.0 * 803b588 Breaking: Try to fix streamline embedding diff --git a/configure.ac b/configure.ac index 2e8cbabded3b..93d200505b5d 100644 --- a/configure.ac +++ b/configure.ac @@ -1,12 +1,14 @@ m4_define([maj_ver], [0]) m4_define([med_ver], [9]) -m4_define([min_ver], [2]) -m4_define([so_version], [9:0:2]) +m4_define([min_ver], [3]) +m4_define([so_version], [9:0:3]) m4_define([ucl_version], [maj_ver.med_ver.min_ver]) +AC_PREREQ([2.70]) + AC_INIT([libucl],[ucl_version],[https://github.com/vstakhov/libucl],[libucl]) AC_CONFIG_SRCDIR([configure.ac]) -AM_INIT_AUTOMAKE([1.11 foreign -Wall -Wportability no-dist-gzip dist-xz]) +AM_INIT_AUTOMAKE([foreign -Wall -Wportability no-dist-gzip dist-xz 1.14]) m4_ifdef([AM_SILENT_RULES], [AM_SILENT_RULES([yes])]) UCL_VERSION=ucl_version @@ -15,8 +17,7 @@ SO_VERSION=so_version AC_SUBST(UCL_VERSION) AC_SUBST(SO_VERSION) -AC_PROG_CC_C99 -AM_PROG_CC_C_O +AC_PROG_CC AM_PROG_AR LT_INIT AC_CONFIG_MACRO_DIR([m4]) diff --git a/include/lua_ucl.h b/include/lua_ucl.h index 5b7f88e031e1..30dd87f7520d 100644 --- a/include/lua_ucl.h +++ b/include/lua_ucl.h @@ -44,7 +44,7 @@ struct ucl_lua_funcdata { /** * Initialize lua UCL API */ -UCL_EXTERN int luaopen_ucl (lua_State *L); +UCL_EXTERN int luaopen_ucl(lua_State *L); /** * Import UCL object from lua state @@ -52,7 +52,7 @@ UCL_EXTERN int luaopen_ucl (lua_State *L); * @param idx index of object at the lua stack to convert to UCL * @return new UCL object or NULL, the caller should unref object after using */ -UCL_EXTERN ucl_object_t* ucl_object_lua_import (lua_State *L, int idx); +UCL_EXTERN ucl_object_t *ucl_object_lua_import(lua_State *L, int idx); /** * Import UCL object from lua state, escaping JSON strings @@ -60,7 +60,7 @@ UCL_EXTERN ucl_object_t* ucl_object_lua_import (lua_State *L, int idx); * @param idx index of object at the lua stack to convert to UCL * @return new UCL object or NULL, the caller should unref object after using */ -UCL_EXTERN ucl_object_t* ucl_object_lua_import_escape (lua_State *L, int idx); +UCL_EXTERN ucl_object_t *ucl_object_lua_import_escape(lua_State *L, int idx); /** * Push an object to lua @@ -68,18 +68,18 @@ UCL_EXTERN ucl_object_t* ucl_object_lua_import_escape (lua_State *L, int idx); * @param obj object to push * @param allow_array traverse over implicit arrays */ -UCL_EXTERN int ucl_object_push_lua (lua_State *L, - const ucl_object_t *obj, bool allow_array); +UCL_EXTERN int ucl_object_push_lua(lua_State *L, + const ucl_object_t *obj, bool allow_array); /** * Push an object to lua replacing all ucl.null with `false` * @param L lua state * @param obj object to push * @param allow_array traverse over implicit arrays */ -UCL_EXTERN int ucl_object_push_lua_filter_nil (lua_State *L, - const ucl_object_t *obj, - bool allow_array); +UCL_EXTERN int ucl_object_push_lua_filter_nil(lua_State *L, + const ucl_object_t *obj, + bool allow_array); -UCL_EXTERN struct ucl_lua_funcdata* ucl_object_toclosure (const ucl_object_t *obj); +UCL_EXTERN struct ucl_lua_funcdata *ucl_object_toclosure(const ucl_object_t *obj); #endif /* LUA_UCL_H_ */ diff --git a/include/ucl++.h b/include/ucl++.h index fb63430d400d..215e61b3807e 100644 --- a/include/ucl++.h +++ b/include/ucl++.h @@ -37,57 +37,57 @@ namespace ucl { -struct ucl_map_construct_t { }; +struct ucl_map_construct_t {}; constexpr ucl_map_construct_t ucl_map_construct = ucl_map_construct_t(); -struct ucl_array_construct_t { }; +struct ucl_array_construct_t {}; constexpr ucl_array_construct_t ucl_array_construct = ucl_array_construct_t(); class Ucl final { private: - struct ucl_deleter { - void operator() (ucl_object_t *obj) { - ucl_object_unref (obj); + void operator()(ucl_object_t *obj) + { + ucl_object_unref(obj); } }; static int - append_char (unsigned char c, size_t nchars, void *ud) + append_char(unsigned char c, size_t nchars, void *ud) { std::string *out = reinterpret_cast(ud); - out->append (nchars, (char)c); + out->append(nchars, (char) c); return nchars; } static int - append_len (unsigned const char *str, size_t len, void *ud) + append_len(unsigned const char *str, size_t len, void *ud) { std::string *out = reinterpret_cast(ud); - out->append ((const char *)str, len); + out->append((const char *) str, len); return len; } static int - append_int (int64_t elt, void *ud) + append_int(int64_t elt, void *ud) { std::string *out = reinterpret_cast(ud); - auto nstr = std::to_string (elt); + auto nstr = std::to_string(elt); - out->append (nstr); + out->append(nstr); - return nstr.size (); + return nstr.size(); } static int - append_double (double elt, void *ud) + append_double(double elt, void *ud) { std::string *out = reinterpret_cast(ud); - auto nstr = std::to_string (elt); + auto nstr = std::to_string(elt); - out->append (nstr); + out->append(nstr); - return nstr.size (); + return nstr.size(); } static struct ucl_emitter_functions default_emit_funcs() @@ -98,26 +98,25 @@ private: Ucl::append_int, Ucl::append_double, nullptr, - nullptr - }; + nullptr}; return func; }; static bool ucl_variable_getter(const unsigned char *data, size_t len, - unsigned char ** /*replace*/, size_t * /*replace_len*/, bool *need_free, void* ud) + unsigned char ** /*replace*/, size_t * /*replace_len*/, bool *need_free, void *ud) { *need_free = false; auto vars = reinterpret_cast *>(ud); if (vars && data && len != 0) { - vars->emplace (data, data + len); + vars->emplace(data, data + len); } return false; } - static bool ucl_variable_replacer (const unsigned char *data, size_t len, - unsigned char **replace, size_t *replace_len, bool *need_free, void* ud) + static bool ucl_variable_replacer(const unsigned char *data, size_t len, + unsigned char **replace, size_t *replace_len, bool *need_free, void *ud) { *need_free = false; @@ -126,89 +125,96 @@ private: return false; } - std::string var_name (data, data + len); - if (!replacer->is_variable (var_name)) { + std::string var_name(data, data + len); + if (!replacer->is_variable(var_name)) { return false; } - std::string var_value = replacer->replace (var_name); - if (var_value.empty ()) { + std::string var_value = replacer->replace(var_name); + if (var_value.empty()) { return false; - } + } - *replace = (unsigned char *)UCL_ALLOC (var_value.size ()); - memcpy (*replace, var_value.data (), var_value.size ()); + *replace = (unsigned char *) UCL_ALLOC(var_value.size()); + memcpy(*replace, var_value.data(), var_value.size()); - *replace_len = var_value.size (); + *replace_len = var_value.size(); *need_free = true; return true; } - template - static Ucl parse_with_strategy_function (C config_func, P parse_func, std::string &err) + template + static Ucl parse_with_strategy_function(C config_func, P parse_func, std::string &err) { - auto parser = ucl_parser_new (UCL_PARSER_DEFAULT); + auto parser = ucl_parser_new(UCL_PARSER_DEFAULT); - config_func (parser); + config_func(parser); - if (!parse_func (parser)) { - const char *error = ucl_parser_get_error (parser); //Assigning here without checking result first causes a - if( error != NULL ) err.assign(error); // crash if ucl_parser_get_error returns NULL - ucl_parser_free (parser); + if (!parse_func(parser)) { + const char *error = ucl_parser_get_error(parser);//Assigning here without checking result first causes a + if (error != NULL) err.assign(error); // crash if ucl_parser_get_error returns NULL + ucl_parser_free(parser); return nullptr; } - auto obj = ucl_parser_get_object (parser); - ucl_parser_free (parser); + auto obj = ucl_parser_get_object(parser); + ucl_parser_free(parser); // Obj will handle ownership - return Ucl (obj); + return Ucl(obj); } std::unique_ptr obj; public: struct macro_handler_s { - ucl_macro_handler handler; + ucl_macro_handler handler; ucl_context_macro_handler ctx_handler; }; struct macro_userdata_s { - ucl_parser *parser; - void *userdata; + ucl_parser *parser; + void *userdata; }; class const_iterator { private: struct ucl_iter_deleter { - void operator() (ucl_object_iter_t it) { - ucl_object_iterate_free (it); + void operator()(ucl_object_iter_t it) + { + ucl_object_iterate_free(it); } }; std::shared_ptr it; std::unique_ptr cur; + public: typedef std::forward_iterator_tag iterator_category; - const_iterator(const Ucl &obj) { - it = std::shared_ptr(ucl_object_iterate_new (obj.obj.get()), - ucl_iter_deleter()); - cur.reset (new Ucl(ucl_object_iterate_safe (it.get(), true))); + const_iterator(const Ucl &obj) + { + it = std::shared_ptr(ucl_object_iterate_new(obj.obj.get()), + ucl_iter_deleter()); + cur.reset(new Ucl(ucl_object_iterate_safe(it.get(), true))); if (!cur->obj) { - it.reset (); - cur.reset (); + it.reset(); + cur.reset(); } } - const_iterator() {} + const_iterator() + { + } const_iterator(const const_iterator &other) = delete; const_iterator(const_iterator &&other) = default; - ~const_iterator() {} + ~const_iterator() + { + } - const_iterator& operator=(const const_iterator &other) = delete; - const_iterator& operator=(const_iterator &&other) = default; + const_iterator &operator=(const const_iterator &other) = delete; + const_iterator &operator=(const_iterator &&other) = default; bool operator==(const const_iterator &other) const { @@ -224,135 +230,154 @@ public: return !(*this == other); } - const_iterator& operator++() + const_iterator &operator++() { if (it) { - cur.reset (new Ucl(ucl_object_iterate_safe (it.get(), true))); + cur.reset(new Ucl(ucl_object_iterate_safe(it.get(), true))); } if (cur && !cur->obj) { - it.reset (); - cur.reset (); + it.reset(); + cur.reset(); } return *this; } - const Ucl& operator*() const + const Ucl &operator*() const { return *cur; } - const Ucl* operator->() const + const Ucl *operator->() const { return cur.get(); } }; struct variable_replacer { - virtual ~variable_replacer() {} + virtual ~variable_replacer() + { + } - virtual bool is_variable (const std::string &str) const + virtual bool is_variable(const std::string &str) const { - return !str.empty (); + return !str.empty(); } - virtual std::string replace (const std::string &var) const = 0; + virtual std::string replace(const std::string &var) const = 0; }; // We grab ownership if get non-const ucl_object_t - Ucl(ucl_object_t *other) { - obj.reset (other); + Ucl(ucl_object_t *other) + { + obj.reset(other); } // Shared ownership - Ucl(const ucl_object_t *other) { - obj.reset (ucl_object_ref (other)); + Ucl(const ucl_object_t *other) + { + obj.reset(ucl_object_ref(other)); } - Ucl(const Ucl &other) { - obj.reset (ucl_object_ref (other.obj.get())); + Ucl(const Ucl &other) + { + obj.reset(ucl_object_ref(other.obj.get())); } - Ucl(Ucl &&other) { - obj.swap (other.obj); + Ucl(Ucl &&other) + { + obj.swap(other.obj); } - Ucl() noexcept { - obj.reset (ucl_object_typed_new (UCL_NULL)); + Ucl() noexcept + { + obj.reset(ucl_object_typed_new(UCL_NULL)); } - Ucl(std::nullptr_t) noexcept { - obj.reset (ucl_object_typed_new (UCL_NULL)); + Ucl(std::nullptr_t) noexcept + { + obj.reset(ucl_object_typed_new(UCL_NULL)); } - Ucl(double value) { - obj.reset (ucl_object_typed_new (UCL_FLOAT)); + Ucl(double value) + { + obj.reset(ucl_object_typed_new(UCL_FLOAT)); obj->value.dv = value; } - Ucl(int64_t value) { - obj.reset (ucl_object_typed_new (UCL_INT)); + Ucl(int64_t value) + { + obj.reset(ucl_object_typed_new(UCL_INT)); obj->value.iv = value; } - Ucl(bool value) { - obj.reset (ucl_object_typed_new (UCL_BOOLEAN)); + Ucl(bool value) + { + obj.reset(ucl_object_typed_new(UCL_BOOLEAN)); obj->value.iv = static_cast(value); } - Ucl(const std::string &value) { - obj.reset (ucl_object_fromstring_common (value.data (), value.size (), - UCL_STRING_RAW)); + Ucl(const std::string &value) + { + obj.reset(ucl_object_fromstring_common(value.data(), value.size(), + UCL_STRING_RAW)); } - Ucl(const char *value) { - obj.reset (ucl_object_fromstring_common (value, 0, UCL_STRING_RAW)); + Ucl(const char *value) + { + obj.reset(ucl_object_fromstring_common(value, 0, UCL_STRING_RAW)); } // Implicit constructor: anything with a to_json() function. - template - Ucl(const T &t) : Ucl(t.to_ucl()) {} + template + Ucl(const T &t) + : Ucl(t.to_ucl()) + { + } // Implicit constructor: map-like objects (std::map, std::unordered_map, etc) - template ::value - && std::is_constructible::value, - int>::type = 0> - Ucl(const M &m) { - obj.reset (ucl_object_typed_new (UCL_OBJECT)); - auto cobj = obj.get (); + template::value && std::is_constructible::value, + int>::type = 0> + Ucl(const M &m) + { + obj.reset(ucl_object_typed_new(UCL_OBJECT)); + auto cobj = obj.get(); - for (const auto &e : m) { - ucl_object_insert_key (cobj, ucl_object_ref (e.second.obj.get()), - e.first.data (), e.first.size (), true); + for (const auto &e: m) { + ucl_object_insert_key(cobj, ucl_object_ref(e.second.obj.get()), + e.first.data(), e.first.size(), true); } } // Implicit constructor: vector-like objects (std::list, std::vector, std::set, etc) - template ::value, - int>::type = 0> - Ucl(const V &v) { - obj.reset (ucl_object_typed_new (UCL_ARRAY)); - auto cobj = obj.get (); + template::value, + int>::type = 0> + Ucl(const V &v) + { + obj.reset(ucl_object_typed_new(UCL_ARRAY)); + auto cobj = obj.get(); - for (const auto &e : v) { - ucl_array_append (cobj, ucl_object_ref (e.obj.get())); + for (const auto &e: v) { + ucl_array_append(cobj, ucl_object_ref(e.obj.get())); } } - ucl_type_t type () const { + ucl_type_t type() const + { if (obj) { - return ucl_object_type (obj.get ()); + return ucl_object_type(obj.get()); } return UCL_NULL; } - std::string key () const { + std::string key() const + { std::string res; if (obj->key) { - res.assign (obj->key, obj->keylen); + res.assign(obj->key, obj->keylen); } return res; } - double number_value (const double default_val = 0.0) const + double number_value(const double default_val = 0.0) const { double res; @@ -363,7 +388,7 @@ public: return default_val; } - int64_t int_value (const int64_t default_val = 0) const + int64_t int_value(const int64_t default_val = 0) const { int64_t res; @@ -374,7 +399,7 @@ public: return default_val; } - bool bool_value (const bool default_val = false) const + bool bool_value(const bool default_val = false) const { bool res; @@ -385,9 +410,9 @@ public: return default_val; } - std::string string_value (const std::string& default_val = "") const + std::string string_value(const std::string &default_val = "") const { - const char* res = nullptr; + const char *res = nullptr; if (ucl_object_tostring_safe(obj.get(), &res)) { return res; @@ -396,35 +421,40 @@ public: return default_val; } - size_t size () const + std::string forced_string_value() const + { + return ucl_object_tostring_forced(obj.get()); + } + + size_t size() const { - if (type () == UCL_ARRAY) { - return ucl_array_size (obj.get()); + if (type() == UCL_ARRAY) { + return ucl_array_size(obj.get()); } return 0; } - Ucl at (size_t i) const + Ucl at(size_t i) const { - if (type () == UCL_ARRAY) { - return Ucl (ucl_array_find_index (obj.get(), i)); + if (type() == UCL_ARRAY) { + return Ucl(ucl_array_find_index(obj.get(), i)); } - return Ucl (nullptr); + return Ucl(nullptr); } - Ucl lookup (const std::string &key) const + Ucl lookup(const std::string &key) const { - if (type () == UCL_OBJECT) { - return Ucl (ucl_object_lookup_len (obj.get(), - key.data (), key.size ())); + if (type() == UCL_OBJECT) { + return Ucl(ucl_object_lookup_len(obj.get(), + key.data(), key.size())); } - return Ucl (nullptr); + return Ucl(nullptr); } - inline Ucl operator[] (size_t i) const + inline Ucl operator[](size_t i) const { return at(i); } @@ -434,285 +464,297 @@ public: return lookup(key); } // Serialize. - void dump (std::string &out, ucl_emitter_t type = UCL_EMIT_JSON) const + void dump(std::string &out, ucl_emitter_t type = UCL_EMIT_JSON) const { struct ucl_emitter_functions cbdata; cbdata = Ucl::default_emit_funcs(); cbdata.ud = reinterpret_cast(&out); - ucl_object_emit_full (obj.get(), type, &cbdata, nullptr); + ucl_object_emit_full(obj.get(), type, &cbdata, nullptr); } - std::string dump (ucl_emitter_t type = UCL_EMIT_JSON) const + std::string dump(ucl_emitter_t type = UCL_EMIT_JSON) const { std::string out; - dump (out, type); + dump(out, type); return out; } - static Ucl parse (const std::string &in, std::string &err, enum ucl_duplicate_strategy duplicate_strategy = UCL_DUPLICATE_APPEND) + static Ucl parse(const std::string &in, std::string &err, enum ucl_duplicate_strategy duplicate_strategy = UCL_DUPLICATE_APPEND) { - return parse (in, std::map(), err, duplicate_strategy); + return parse(in, std::map(), err, duplicate_strategy); } - static Ucl parse (const std::string &in, const std::map &vars, - std::string &err, enum ucl_duplicate_strategy duplicate_strategy = UCL_DUPLICATE_APPEND) + static Ucl parse(const std::string &in, const std::map &vars, + std::string &err, enum ucl_duplicate_strategy duplicate_strategy = UCL_DUPLICATE_APPEND) { - std::vector< std::tuple< std::string, macro_handler_s, void * > > emptyVector; - return parse ( in, vars, emptyVector, err, duplicate_strategy ); + std::vector> emptyVector; + return parse(in, vars, emptyVector, err, duplicate_strategy); } //Macro handler will receive a macro_userdata_s as void *ud - static Ucl parse (const std::string &in, - std::vector< std::tuple< std::string /*name*/, macro_handler_s, void * /*userdata*/ > > ¯os, - std::string &err, enum ucl_duplicate_strategy duplicate_strategy = UCL_DUPLICATE_APPEND) + static Ucl parse(const std::string &in, + std::vector> ¯os, + std::string &err, enum ucl_duplicate_strategy duplicate_strategy = UCL_DUPLICATE_APPEND) { - return parse (in, std::map(), macros, err, duplicate_strategy); + return parse(in, std::map(), macros, err, duplicate_strategy); } //Macro handler will receive a macro_userdata_s as void *ud - static Ucl parse (const std::string &in, const std::map &vars, - std::vector< std::tuple< std::string /*name*/, macro_handler_s, void * /*userdata*/ > > ¯os, - std::string &err, enum ucl_duplicate_strategy duplicate_strategy = UCL_DUPLICATE_APPEND) + static Ucl parse(const std::string &in, const std::map &vars, + std::vector> ¯os, + std::string &err, enum ucl_duplicate_strategy duplicate_strategy = UCL_DUPLICATE_APPEND) { //Preserve macro_userdata_s memory for later use in parse_with_strategy_function() std::vector userdata_list; - userdata_list.reserve (macros.size()); - auto config_func = [&userdata_list, &vars, ¯os] (ucl_parser *parser) { - for (const auto & item : vars) { - ucl_parser_register_variable (parser, item.first.c_str (), item.second.c_str ()); + userdata_list.reserve(macros.size()); + auto config_func = [&userdata_list, &vars, ¯os](ucl_parser *parser) { + for (const auto &item: vars) { + ucl_parser_register_variable(parser, item.first.c_str(), item.second.c_str()); } - for (auto & macro : macros) { - userdata_list.push_back ({parser, std::get<2>(macro)}); + for (auto ¯o: macros) { + userdata_list.push_back({parser, std::get<2>(macro)}); if (std::get<1>(macro).handler != NULL) { - ucl_parser_register_macro (parser, - std::get<0>(macro).c_str(), - std::get<1>(macro).handler, - reinterpret_cast(&userdata_list.back())); + ucl_parser_register_macro(parser, + std::get<0>(macro).c_str(), + std::get<1>(macro).handler, + reinterpret_cast(&userdata_list.back())); } else if (std::get<1>(macro).ctx_handler != NULL) { - ucl_parser_register_context_macro (parser, - std::get<0>(macro).c_str(), - std::get<1>(macro).ctx_handler, - reinterpret_cast(&userdata_list.back())); + ucl_parser_register_context_macro(parser, + std::get<0>(macro).c_str(), + std::get<1>(macro).ctx_handler, + reinterpret_cast(&userdata_list.back())); } } }; - auto parse_func = [&in, &duplicate_strategy] (struct ucl_parser *parser) -> bool { - return ucl_parser_add_chunk_full (parser, - (unsigned char *) in.data (), - in.size (), - (unsigned int)ucl_parser_get_default_priority (parser), - duplicate_strategy, - UCL_PARSE_UCL); + auto parse_func = [&in, &duplicate_strategy](struct ucl_parser *parser) -> bool { + return ucl_parser_add_chunk_full(parser, + (unsigned char *) in.data(), + in.size(), + (unsigned int) ucl_parser_get_default_priority(parser), + duplicate_strategy, + UCL_PARSE_UCL); }; - return parse_with_strategy_function (config_func, parse_func, err); + return parse_with_strategy_function(config_func, parse_func, err); } - static Ucl parse (const std::string &in, const variable_replacer &replacer, - std::string &err, enum ucl_duplicate_strategy duplicate_strategy = UCL_DUPLICATE_APPEND) + static Ucl parse(const std::string &in, const variable_replacer &replacer, + std::string &err, enum ucl_duplicate_strategy duplicate_strategy = UCL_DUPLICATE_APPEND) { - std::vector< std::tuple< std::string, macro_handler_s, void * > > emptyVector; - return parse ( in, replacer, emptyVector, err, duplicate_strategy ); + std::vector> emptyVector; + return parse(in, replacer, emptyVector, err, duplicate_strategy); } //Macro handler will receive a macro_userdata_s as void *ud - static Ucl parse (const std::string &in, const variable_replacer &replacer, - std::vector< std::tuple< std::string /*name*/, macro_handler_s, void * /*userdata*/ > > ¯os, - std::string &err, enum ucl_duplicate_strategy duplicate_strategy = UCL_DUPLICATE_APPEND) + static Ucl parse(const std::string &in, const variable_replacer &replacer, + std::vector> ¯os, + std::string &err, enum ucl_duplicate_strategy duplicate_strategy = UCL_DUPLICATE_APPEND) { //Preserve macro_userdata_s memory for later use in parse_with_strategy_function() std::vector userdata_list; - userdata_list.reserve (macros.size()); - auto config_func = [&userdata_list, &replacer, ¯os] (ucl_parser *parser) { - ucl_parser_set_variables_handler (parser, ucl_variable_replacer, &const_cast(replacer)); - for (auto & macro : macros) { - userdata_list.push_back ({parser, std::get<2>(macro)}); + userdata_list.reserve(macros.size()); + auto config_func = [&userdata_list, &replacer, ¯os](ucl_parser *parser) { + ucl_parser_set_variables_handler(parser, ucl_variable_replacer, &const_cast(replacer)); + for (auto ¯o: macros) { + userdata_list.push_back({parser, std::get<2>(macro)}); if (std::get<1>(macro).handler != NULL) { - ucl_parser_register_macro (parser, - std::get<0>(macro).c_str(), - std::get<1>(macro).handler, - reinterpret_cast(&userdata_list.back())); + ucl_parser_register_macro(parser, + std::get<0>(macro).c_str(), + std::get<1>(macro).handler, + reinterpret_cast(&userdata_list.back())); } else if (std::get<1>(macro).ctx_handler != NULL) { - ucl_parser_register_context_macro (parser, - std::get<0>(macro).c_str(), - std::get<1>(macro).ctx_handler, - reinterpret_cast(&userdata_list.back())); + ucl_parser_register_context_macro(parser, + std::get<0>(macro).c_str(), + std::get<1>(macro).ctx_handler, + reinterpret_cast(&userdata_list.back())); } } }; - auto parse_func = [&in, &duplicate_strategy] (struct ucl_parser *parser) -> bool { - return ucl_parser_add_chunk_full (parser, - (unsigned char *) in.data (), - in.size (), - (unsigned int)ucl_parser_get_default_priority (parser), - duplicate_strategy, - UCL_PARSE_UCL); + auto parse_func = [&in, &duplicate_strategy](struct ucl_parser *parser) -> bool { + return ucl_parser_add_chunk_full(parser, + (unsigned char *) in.data(), + in.size(), + (unsigned int) ucl_parser_get_default_priority(parser), + duplicate_strategy, + UCL_PARSE_UCL); }; - return parse_with_strategy_function (config_func, parse_func, err); + return parse_with_strategy_function(config_func, parse_func, err); } - static Ucl parse (const char *in, std::string &err, enum ucl_duplicate_strategy duplicate_strategy = UCL_DUPLICATE_APPEND) + static Ucl parse(const char *in, std::string &err, enum ucl_duplicate_strategy duplicate_strategy = UCL_DUPLICATE_APPEND) { - return parse (in, std::map(), err, duplicate_strategy); + return parse(in, std::map(), err, duplicate_strategy); } - static Ucl parse (const char *in, const std::map &vars, std::string &err) + static Ucl parse(const char *in, const std::map &vars, std::string &err) { if (!in) { err = "null input"; return nullptr; } - return parse (std::string (in), vars, err); + return parse(std::string(in), vars, err); } //Macro handler will receive a macro_userdata_s as void *ud - static Ucl parse (const char *in, - std::vector< std::tuple< std::string /*name*/, macro_handler_s, void * /*userdata*/ > > ¯os, - std::string &err, enum ucl_duplicate_strategy duplicate_strategy = UCL_DUPLICATE_APPEND) + static Ucl parse(const char *in, + std::vector> ¯os, + std::string &err, enum ucl_duplicate_strategy duplicate_strategy = UCL_DUPLICATE_APPEND) { - return parse (in, std::map(), macros, err, duplicate_strategy); + return parse(in, std::map(), macros, err, duplicate_strategy); } //Macro handler will receive a macro_userdata_s as void *ud - static Ucl parse (const char *in, const std::map &vars, - std::vector< std::tuple< std::string /*name*/, macro_handler_s, void * /*userdata*/ > > ¯os, - std::string &err, enum ucl_duplicate_strategy duplicate_strategy = UCL_DUPLICATE_APPEND) + static Ucl parse(const char *in, const std::map &vars, + std::vector> ¯os, + std::string &err, enum ucl_duplicate_strategy duplicate_strategy = UCL_DUPLICATE_APPEND) { if (!in) { err = "null input"; return nullptr; } - return parse (std::string (in), vars, macros, err, duplicate_strategy); + return parse(std::string(in), vars, macros, err, duplicate_strategy); } - static Ucl parse (const char *in, const variable_replacer &replacer, - std::string &err, enum ucl_duplicate_strategy duplicate_strategy = UCL_DUPLICATE_APPEND) + static Ucl parse(const char *in, const variable_replacer &replacer, + std::string &err, enum ucl_duplicate_strategy duplicate_strategy = UCL_DUPLICATE_APPEND) { if (!in) { err = "null input"; return nullptr; } - return parse (std::string(in), replacer, err, duplicate_strategy); + return parse(std::string(in), replacer, err, duplicate_strategy); } //Macro handler will receive a macro_userdata_s as void *ud - static Ucl parse (const char *in, const variable_replacer &replacer, - std::vector< std::tuple< std::string /*name*/, macro_handler_s, void * /*userdata*/ > > ¯os, - std::string &err, enum ucl_duplicate_strategy duplicate_strategy = UCL_DUPLICATE_APPEND) + static Ucl parse(const char *in, const variable_replacer &replacer, + std::vector> ¯os, + std::string &err, enum ucl_duplicate_strategy duplicate_strategy = UCL_DUPLICATE_APPEND) { if (!in) { err = "null input"; return nullptr; } - return parse (std::string (in), replacer, macros, err, duplicate_strategy); + return parse(std::string(in), replacer, macros, err, duplicate_strategy); } - static Ucl parse_from_file (const std::string &filename, std::string &err) + static Ucl parse_from_file(const std::string &filename, std::string &err) { - return parse_from_file (filename, std::map(), err); + return parse_from_file(filename, std::map(), err); } - static Ucl parse_from_file (const std::string &filename, const std::map &vars, std::string &err) + static Ucl parse_from_file(const std::string &filename, const std::map &vars, std::string &err) { - auto config_func = [&vars] (ucl_parser *parser) { - for (const auto & item : vars) { - ucl_parser_register_variable (parser, item.first.c_str (), item.second.c_str ()); - } + auto config_func = [&vars](ucl_parser *parser) { + for (const auto &item: vars) { + ucl_parser_register_variable(parser, item.first.c_str(), item.second.c_str()); + } }; - auto parse_func = [&filename] (ucl_parser *parser) { - return ucl_parser_add_file (parser, filename.c_str ()); + auto parse_func = [&filename](ucl_parser *parser) { + return ucl_parser_add_file(parser, filename.c_str()); }; - return parse_with_strategy_function (config_func, parse_func, err); + return parse_with_strategy_function(config_func, parse_func, err); } - static Ucl parse_from_file (const std::string &filename, const variable_replacer &replacer, std::string &err) + static Ucl parse_from_file(const std::string &filename, const variable_replacer &replacer, std::string &err) { - auto config_func = [&replacer] (ucl_parser *parser) { - ucl_parser_set_variables_handler (parser, ucl_variable_replacer, - &const_cast(replacer)); + auto config_func = [&replacer](ucl_parser *parser) { + ucl_parser_set_variables_handler(parser, ucl_variable_replacer, + &const_cast(replacer)); }; - auto parse_func = [&filename] (ucl_parser *parser) { - return ucl_parser_add_file (parser, filename.c_str ()); + auto parse_func = [&filename](ucl_parser *parser) { + return ucl_parser_add_file(parser, filename.c_str()); }; - return parse_with_strategy_function (config_func, parse_func, err); + return parse_with_strategy_function(config_func, parse_func, err); } - static std::vector find_variable (const std::string &in) + static std::vector find_variable(const std::string &in) { - auto parser = ucl_parser_new (UCL_PARSER_DEFAULT); + auto parser = ucl_parser_new(UCL_PARSER_DEFAULT); std::set vars; - ucl_parser_set_variables_handler (parser, ucl_variable_getter, &vars); - ucl_parser_add_chunk (parser, (const unsigned char *)in.data (), in.size ()); - ucl_parser_free (parser); + ucl_parser_set_variables_handler(parser, ucl_variable_getter, &vars); + ucl_parser_add_chunk(parser, (const unsigned char *) in.data(), in.size()); + ucl_parser_free(parser); std::vector result; - std::move (vars.begin (), vars.end (), std::back_inserter (result)); + std::move(vars.begin(), vars.end(), std::back_inserter(result)); return result; } - static std::vector find_variable (const char *in) + static std::vector find_variable(const char *in) { if (!in) { return std::vector(); } - return find_variable (std::string (in)); + return find_variable(std::string(in)); } - static std::vector find_variable_from_file (const std::string &filename) + static std::vector find_variable_from_file(const std::string &filename) { - auto parser = ucl_parser_new (UCL_PARSER_DEFAULT); + auto parser = ucl_parser_new(UCL_PARSER_DEFAULT); std::set vars; - ucl_parser_set_variables_handler (parser, ucl_variable_getter, &vars); - ucl_parser_add_file (parser, filename.c_str ()); - ucl_parser_free (parser); + ucl_parser_set_variables_handler(parser, ucl_variable_getter, &vars); + ucl_parser_add_file(parser, filename.c_str()); + ucl_parser_free(parser); std::vector result; - std::move (vars.begin (), vars.end (), std::back_inserter (result)); + std::move(vars.begin(), vars.end(), std::back_inserter(result)); return result; } - Ucl& operator= (Ucl rhs) + Ucl &operator=(Ucl rhs) { - obj.swap (rhs.obj); + obj.swap(rhs.obj); return *this; } - bool operator== (const Ucl &rhs) const + bool operator==(const Ucl &rhs) const + { + return ucl_object_compare(obj.get(), rhs.obj.get()) == 0; + } + bool operator<(const Ucl &rhs) const + { + return ucl_object_compare(obj.get(), rhs.obj.get()) < 0; + } + bool operator!=(const Ucl &rhs) const { - return ucl_object_compare (obj.get(), rhs.obj.get ()) == 0; + return !(*this == rhs); } - bool operator< (const Ucl &rhs) const + bool operator<=(const Ucl &rhs) const { - return ucl_object_compare (obj.get(), rhs.obj.get ()) < 0; + return !(rhs < *this); + } + bool operator>(const Ucl &rhs) const + { + return (rhs < *this); + } + bool operator>=(const Ucl &rhs) const + { + return !(*this < rhs); } - bool operator!= (const Ucl &rhs) const { return !(*this == rhs); } - bool operator<= (const Ucl &rhs) const { return !(rhs < *this); } - bool operator> (const Ucl &rhs) const { return (rhs < *this); } - bool operator>= (const Ucl &rhs) const { return !(*this < rhs); } - explicit operator bool () const + explicit operator bool() const { if (!obj || type() == UCL_NULL) { return false; } - if (type () == UCL_BOOLEAN) { - return bool_value (); + if (type() == UCL_BOOLEAN) { + return bool_value(); } return true; @@ -736,4 +778,4 @@ public: } }; -}; +};// namespace ucl diff --git a/include/ucl.h b/include/ucl.h index b8625b9fce2f..96ddaa9cb987 100644 --- a/include/ucl.h +++ b/include/ucl.h @@ -33,9 +33,9 @@ #include #ifdef _WIN32 -# define UCL_EXTERN __declspec(dllexport) +#define UCL_EXTERN __declspec(dllexport) #else -# define UCL_EXTERN +#define UCL_EXTERN #endif /** @@ -58,7 +58,7 @@ * JSON with less strict rules that make it more comfortable for * using as a configuration language */ -#ifdef __cplusplus +#ifdef __cplusplus extern "C" { #endif /* @@ -73,16 +73,29 @@ extern "C" { #ifndef UCL_FREE #define UCL_FREE(size, ptr) free(ptr) #endif +#ifndef UCL_REALLOC +#define UCL_REALLOC(ptr, size) realloc(ptr, size) +#endif +#ifndef UCL_STRDUP +static inline char *ucl_strdup_impl(const char *s) +{ + size_t len = strlen(s) + 1; + char *p = (char *) UCL_ALLOC(len); + if (p) memcpy(p, s, len); + return p; +} +#define UCL_STRDUP(str) ucl_strdup_impl(str) +#endif -#if __GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) -#define UCL_WARN_UNUSED_RESULT \ - __attribute__((warn_unused_result)) +#if __GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) +#define UCL_WARN_UNUSED_RESULT \ + __attribute__((warn_unused_result)) #else #define UCL_WARN_UNUSED_RESULT #endif #ifdef __GNUC__ -#define UCL_DEPRECATED(func) func __attribute__ ((deprecated)) +#define UCL_DEPRECATED(func) func __attribute__((deprecated)) #elif defined(_MSC_VER) #define UCL_DEPRECATED(func) __declspec(deprecated) func #else @@ -100,16 +113,16 @@ extern "C" { * The common error codes returned by ucl parser */ typedef enum ucl_error { - UCL_EOK = 0, /**< No error */ - UCL_ESYNTAX, /**< Syntax error occurred during parsing */ - UCL_EIO, /**< IO error occurred during parsing */ - UCL_ESTATE, /**< Invalid state machine state */ - UCL_ENESTED, /**< Input has too many recursion levels */ + UCL_EOK = 0, /**< No error */ + UCL_ESYNTAX, /**< Syntax error occurred during parsing */ + UCL_EIO, /**< IO error occurred during parsing */ + UCL_ESTATE, /**< Invalid state machine state */ + UCL_ENESTED, /**< Input has too many recursion levels */ UCL_EUNPAIRED, /**< Input has too many recursion levels */ - UCL_EMACRO, /**< Error processing a macro */ + UCL_EMACRO, /**< Error processing a macro */ UCL_EINTERNAL, /**< Internal unclassified error */ - UCL_ESSL, /**< SSL error */ - UCL_EMERGE /**< A merge error occurred */ + UCL_ESSL, /**< SSL error */ + UCL_EMERGE /**< A merge error occurred */ } ucl_error_t; /** @@ -120,26 +133,26 @@ typedef enum ucl_error { */ typedef enum ucl_type { UCL_OBJECT = 0, /**< UCL object - key/value pairs */ - UCL_ARRAY, /**< UCL array */ - UCL_INT, /**< Integer number */ - UCL_FLOAT, /**< Floating point number */ - UCL_STRING, /**< Null terminated string */ - UCL_BOOLEAN, /**< Boolean value */ - UCL_TIME, /**< Time value (floating point number of seconds) */ - UCL_USERDATA, /**< Opaque userdata pointer (may be used in macros) */ - UCL_NULL /**< Null value */ + UCL_ARRAY, /**< UCL array */ + UCL_INT, /**< Integer number */ + UCL_FLOAT, /**< Floating point number */ + UCL_STRING, /**< Null terminated string */ + UCL_BOOLEAN, /**< Boolean value */ + UCL_TIME, /**< Time value (floating point number of seconds) */ + UCL_USERDATA, /**< Opaque userdata pointer (may be used in macros) */ + UCL_NULL /**< Null value */ } ucl_type_t; /** * You can use one of these types to serialise #ucl_object_t by using ucl_object_emit(). */ typedef enum ucl_emitter { - UCL_EMIT_JSON = 0, /**< Emit fine formatted JSON */ + UCL_EMIT_JSON = 0, /**< Emit fine formatted JSON */ UCL_EMIT_JSON_COMPACT, /**< Emit compacted JSON */ - UCL_EMIT_CONFIG, /**< Emit human readable config format */ - UCL_EMIT_YAML, /**< Emit embedded YAML format */ - UCL_EMIT_MSGPACK, /**< Emit msgpack output */ - UCL_EMIT_MAX /**< Unsupported emitter type */ + UCL_EMIT_CONFIG, /**< Emit human readable config format */ + UCL_EMIT_YAML, /**< Emit embedded YAML format */ + UCL_EMIT_MSGPACK, /**< Emit msgpack output */ + UCL_EMIT_MAX /**< Unsupported emitter type */ } ucl_emitter_t; /** @@ -149,32 +162,32 @@ typedef enum ucl_emitter { * UCL still has to perform copying implicitly. */ typedef enum ucl_parser_flags { - UCL_PARSER_DEFAULT = 0, /**< No special flags */ - UCL_PARSER_KEY_LOWERCASE = (1 << 0), /**< Convert all keys to lower case */ - UCL_PARSER_ZEROCOPY = (1 << 1), /**< Parse input in zero-copy mode if possible */ - UCL_PARSER_NO_TIME = (1 << 2), /**< Do not parse time and treat time values as strings */ + UCL_PARSER_DEFAULT = 0, /**< No special flags */ + UCL_PARSER_KEY_LOWERCASE = (1 << 0), /**< Convert all keys to lower case */ + UCL_PARSER_ZEROCOPY = (1 << 1), /**< Parse input in zero-copy mode if possible */ + UCL_PARSER_NO_TIME = (1 << 2), /**< Do not parse time and treat time values as strings */ UCL_PARSER_NO_IMPLICIT_ARRAYS = (1 << 3), /** Create explicit arrays instead of implicit ones */ - UCL_PARSER_SAVE_COMMENTS = (1 << 4), /** Save comments in the parser context */ - UCL_PARSER_DISABLE_MACRO = (1 << 5), /** Treat macros as comments */ - UCL_PARSER_NO_FILEVARS = (1 << 6) /** Do not set file vars */ + UCL_PARSER_SAVE_COMMENTS = (1 << 4), /** Save comments in the parser context */ + UCL_PARSER_DISABLE_MACRO = (1 << 5), /** Treat macros as comments */ + UCL_PARSER_NO_FILEVARS = (1 << 6) /** Do not set file vars */ } ucl_parser_flags_t; /** * String conversion flags, that are used in #ucl_object_fromstring_common function. */ typedef enum ucl_string_flags { - UCL_STRING_RAW = 0x0, /**< Treat string as is */ - UCL_STRING_ESCAPE = (1 << 0), /**< Perform JSON escape */ - UCL_STRING_TRIM = (1 << 1), /**< Trim leading and trailing whitespaces */ - UCL_STRING_PARSE_BOOLEAN = (1 << 2), /**< Parse passed string and detect boolean */ - UCL_STRING_PARSE_INT = (1 << 3), /**< Parse passed string and detect integer number */ - UCL_STRING_PARSE_DOUBLE = (1 << 4), /**< Parse passed string and detect integer or float number */ - UCL_STRING_PARSE_TIME = (1 << 5), /**< Parse time strings */ - UCL_STRING_PARSE_NUMBER = UCL_STRING_PARSE_INT|UCL_STRING_PARSE_DOUBLE|UCL_STRING_PARSE_TIME, /**< + UCL_STRING_RAW = 0x0, /**< Treat string as is */ + UCL_STRING_ESCAPE = (1 << 0), /**< Perform JSON escape */ + UCL_STRING_TRIM = (1 << 1), /**< Trim leading and trailing whitespaces */ + UCL_STRING_PARSE_BOOLEAN = (1 << 2), /**< Parse passed string and detect boolean */ + UCL_STRING_PARSE_INT = (1 << 3), /**< Parse passed string and detect integer number */ + UCL_STRING_PARSE_DOUBLE = (1 << 4), /**< Parse passed string and detect integer or float number */ + UCL_STRING_PARSE_TIME = (1 << 5), /**< Parse time strings */ + UCL_STRING_PARSE_NUMBER = UCL_STRING_PARSE_INT | UCL_STRING_PARSE_DOUBLE | UCL_STRING_PARSE_TIME, /**< Parse passed string and detect number */ - UCL_STRING_PARSE = UCL_STRING_PARSE_BOOLEAN|UCL_STRING_PARSE_NUMBER, /**< + UCL_STRING_PARSE = UCL_STRING_PARSE_BOOLEAN | UCL_STRING_PARSE_NUMBER, /**< Parse passed string (and detect booleans and numbers) */ - UCL_STRING_PARSE_BYTES = (1 << 6) /**< Treat numbers as bytes */ + UCL_STRING_PARSE_BYTES = (1 << 6) /**< Treat numbers as bytes */ } ucl_string_flags_t; /** @@ -182,15 +195,15 @@ typedef enum ucl_string_flags { * for priorities) */ typedef enum ucl_object_flags { - UCL_OBJECT_ALLOCATED_KEY = (1 << 0), /**< An object has key allocated internally */ + UCL_OBJECT_ALLOCATED_KEY = (1 << 0), /**< An object has key allocated internally */ UCL_OBJECT_ALLOCATED_VALUE = (1 << 1), /**< An object has a string value allocated internally */ UCL_OBJECT_NEED_KEY_ESCAPE = (1 << 2), /**< The key of an object need to be escaped on output */ - UCL_OBJECT_EPHEMERAL = (1 << 3), /**< Temporary object that does not need to be freed really */ - UCL_OBJECT_MULTILINE = (1 << 4), /**< String should be displayed as multiline string */ - UCL_OBJECT_MULTIVALUE = (1 << 5), /**< Object is a key with multiple values */ - UCL_OBJECT_INHERITED = (1 << 6), /**< Object has been inherited from another */ - UCL_OBJECT_BINARY = (1 << 7), /**< Object contains raw binary data */ - UCL_OBJECT_SQUOTED = (1 << 8) /**< Object has been enclosed in single quotes */ + UCL_OBJECT_EPHEMERAL = (1 << 3), /**< Temporary object that does not need to be freed really */ + UCL_OBJECT_MULTILINE = (1 << 4), /**< String should be displayed as multiline string */ + UCL_OBJECT_MULTIVALUE = (1 << 5), /**< Object is a key with multiple values */ + UCL_OBJECT_INHERITED = (1 << 6), /**< Object has been inherited from another */ + UCL_OBJECT_BINARY = (1 << 7), /**< Object contains raw binary data */ + UCL_OBJECT_SQUOTED = (1 << 8) /**< Object has been enclosed in single quotes */ } ucl_object_flags_t; /** @@ -198,9 +211,9 @@ typedef enum ucl_object_flags { */ enum ucl_duplicate_strategy { UCL_DUPLICATE_APPEND = 0, /**< Default policy to merge based on priorities */ - UCL_DUPLICATE_MERGE, /**< Merge new object with old one */ - UCL_DUPLICATE_REWRITE, /**< Rewrite old keys */ - UCL_DUPLICATE_ERROR /**< Stop parsing on duplicate found */ + UCL_DUPLICATE_MERGE, /**< Merge new object with old one */ + UCL_DUPLICATE_REWRITE, /**< Rewrite old keys */ + UCL_DUPLICATE_ERROR /**< Stop parsing on duplicate found */ }; /** @@ -209,8 +222,8 @@ enum ucl_duplicate_strategy { enum ucl_parse_type { UCL_PARSE_UCL = 0, /**< Default ucl format */ UCL_PARSE_MSGPACK, /**< Message pack input format */ - UCL_PARSE_CSEXP, /**< Canonical S-expressions */ - UCL_PARSE_AUTO /**< Try to detect parse type */ + UCL_PARSE_CSEXP, /**< Canonical S-expressions */ + UCL_PARSE_AUTO /**< Try to detect parse type */ }; /** @@ -222,22 +235,22 @@ typedef struct ucl_object_s { * Variant value type */ union { - int64_t iv; /**< Int value of an object */ - const char *sv; /**< String value of an object */ - double dv; /**< Double value of an object */ - void *av; /**< Array */ - void *ov; /**< Object */ - void* ud; /**< Opaque user data */ + int64_t iv; /**< Int value of an object */ + const char *sv; /**< String value of an object */ + double dv; /**< Double value of an object */ + void *av; /**< Array */ + void *ov; /**< Object */ + void *ud; /**< Opaque user data */ } value; - const char *key; /**< Key of an object */ - struct ucl_object_s *next; /**< Array handle */ - struct ucl_object_s *prev; /**< Array handle */ - uint32_t keylen; /**< Length of a key */ - uint32_t len; /**< Size of an object */ - uint32_t ref; /**< Reference count */ - uint16_t flags; /**< Object flags */ - uint16_t type; /**< Real type */ - unsigned char* trash_stack[2]; /**< Pointer to allocated chunks */ + const char *key; /**< Key of an object */ + struct ucl_object_s *next; /**< Array handle */ + struct ucl_object_s *prev; /**< Array handle */ + uint32_t keylen; /**< Length of a key */ + uint32_t len; /**< Size of an object */ + uint32_t ref; /**< Reference count */ + uint16_t flags; /**< Object flags */ + uint16_t type; /**< Real type */ + unsigned char *trash_stack[2]; /**< Pointer to allocated chunks */ } ucl_object_t; /** @@ -245,7 +258,7 @@ typedef struct ucl_object_s { * @param ud user specified data pointer */ typedef void (*ucl_userdata_dtor)(void *ud); -typedef const char* (*ucl_userdata_emitter)(void *ud); +typedef const char *(*ucl_userdata_emitter)(void *ud); /** @} */ @@ -260,27 +273,27 @@ typedef const char* (*ucl_userdata_emitter)(void *ud); * @param obj CL object * @return zero terminated key */ -UCL_EXTERN char* ucl_copy_key_trash (const ucl_object_t *obj); +UCL_EXTERN char *ucl_copy_key_trash(const ucl_object_t *obj); /** * Copy and return a string value of an object, returned key is zero-terminated * @param obj CL object * @return zero terminated string representation of object value */ -UCL_EXTERN char* ucl_copy_value_trash (const ucl_object_t *obj); +UCL_EXTERN char *ucl_copy_value_trash(const ucl_object_t *obj); /** * Creates a new object * @return new object */ -UCL_EXTERN ucl_object_t* ucl_object_new (void) UCL_WARN_UNUSED_RESULT; +UCL_EXTERN ucl_object_t *ucl_object_new(void) UCL_WARN_UNUSED_RESULT; /** * Create new object with type specified * @param type type of a new object * @return new object */ -UCL_EXTERN ucl_object_t* ucl_object_typed_new (ucl_type_t type) UCL_WARN_UNUSED_RESULT; +UCL_EXTERN ucl_object_t *ucl_object_typed_new(ucl_type_t type) UCL_WARN_UNUSED_RESULT; /** * Create new object with type and priority specified @@ -288,7 +301,7 @@ UCL_EXTERN ucl_object_t* ucl_object_typed_new (ucl_type_t type) UCL_WARN_UNUSED_ * @param priority priority of an object * @return new object */ -UCL_EXTERN ucl_object_t* ucl_object_new_full (ucl_type_t type, unsigned priority) +UCL_EXTERN ucl_object_t *ucl_object_new_full(ucl_type_t type, unsigned priority) UCL_WARN_UNUSED_RESULT; /** @@ -298,29 +311,29 @@ UCL_EXTERN ucl_object_t* ucl_object_new_full (ucl_type_t type, unsigned priority * @param ptr opaque pointer * @return new object */ -UCL_EXTERN ucl_object_t* ucl_object_new_userdata (ucl_userdata_dtor dtor, - ucl_userdata_emitter emitter, void *ptr) UCL_WARN_UNUSED_RESULT; +UCL_EXTERN ucl_object_t *ucl_object_new_userdata(ucl_userdata_dtor dtor, + ucl_userdata_emitter emitter, void *ptr) UCL_WARN_UNUSED_RESULT; /** * Perform deep copy of an object copying everything * @param other object to copy * @return new object with refcount equal to 1 */ -UCL_EXTERN ucl_object_t * ucl_object_copy (const ucl_object_t *other) +UCL_EXTERN ucl_object_t *ucl_object_copy(const ucl_object_t *other) UCL_WARN_UNUSED_RESULT; /** * Return the type of an object * @return the object type */ -UCL_EXTERN ucl_type_t ucl_object_type (const ucl_object_t *obj); +UCL_EXTERN ucl_type_t ucl_object_type(const ucl_object_t *obj); /** * Converts ucl object type to its string representation * @param type type of object * @return constant string describing type */ -UCL_EXTERN const char * ucl_object_type_to_string (ucl_type_t type); +UCL_EXTERN const char *ucl_object_type_to_string(ucl_type_t type); /** * Converts string that represents ucl type to real ucl type enum @@ -328,7 +341,7 @@ UCL_EXTERN const char * ucl_object_type_to_string (ucl_type_t type); * @param res resulting target * @return true if `input` is a name of type stored in `res` */ -UCL_EXTERN bool ucl_object_string_to_type (const char *input, ucl_type_t *res); +UCL_EXTERN bool ucl_object_string_to_type(const char *input, ucl_type_t *res); /** * Convert any string to an ucl object making the specified transformations @@ -337,15 +350,15 @@ UCL_EXTERN bool ucl_object_string_to_type (const char *input, ucl_type_t *res); * @param flags conversion flags * @return new object */ -UCL_EXTERN ucl_object_t * ucl_object_fromstring_common (const char *str, size_t len, - enum ucl_string_flags flags) UCL_WARN_UNUSED_RESULT; +UCL_EXTERN ucl_object_t *ucl_object_fromstring_common(const char *str, size_t len, + enum ucl_string_flags flags) UCL_WARN_UNUSED_RESULT; /** * Create a UCL object from the specified string * @param str NULL terminated string, will be json escaped * @return new object */ -UCL_EXTERN ucl_object_t *ucl_object_fromstring (const char *str) UCL_WARN_UNUSED_RESULT; +UCL_EXTERN ucl_object_t *ucl_object_fromstring(const char *str) UCL_WARN_UNUSED_RESULT; /** * Create a UCL object from the specified string @@ -353,29 +366,29 @@ UCL_EXTERN ucl_object_t *ucl_object_fromstring (const char *str) UCL_WARN_UNUSED * @param len length of a string * @return new object */ -UCL_EXTERN ucl_object_t *ucl_object_fromlstring (const char *str, - size_t len) UCL_WARN_UNUSED_RESULT; +UCL_EXTERN ucl_object_t *ucl_object_fromlstring(const char *str, + size_t len) UCL_WARN_UNUSED_RESULT; /** * Create an object from an integer number * @param iv number * @return new object */ -UCL_EXTERN ucl_object_t* ucl_object_fromint (int64_t iv) UCL_WARN_UNUSED_RESULT; +UCL_EXTERN ucl_object_t *ucl_object_fromint(int64_t iv) UCL_WARN_UNUSED_RESULT; /** * Create an object from a float number * @param dv number * @return new object */ -UCL_EXTERN ucl_object_t* ucl_object_fromdouble (double dv) UCL_WARN_UNUSED_RESULT; +UCL_EXTERN ucl_object_t *ucl_object_fromdouble(double dv) UCL_WARN_UNUSED_RESULT; /** * Create an object from a boolean * @param bv bool value * @return new object */ -UCL_EXTERN ucl_object_t* ucl_object_frombool (bool bv) UCL_WARN_UNUSED_RESULT; +UCL_EXTERN ucl_object_t *ucl_object_frombool(bool bv) UCL_WARN_UNUSED_RESULT; /** * Insert a object 'elt' to the hash 'top' and associate it with key 'key' @@ -386,8 +399,8 @@ UCL_EXTERN ucl_object_t* ucl_object_frombool (bool bv) UCL_WARN_UNUSED_RESULT; * @param copy_key make an internal copy of key * @return true if key has been inserted */ -UCL_EXTERN bool ucl_object_insert_key (ucl_object_t *top, ucl_object_t *elt, - const char *key, size_t keylen, bool copy_key); +UCL_EXTERN bool ucl_object_insert_key(ucl_object_t *top, ucl_object_t *elt, + const char *key, size_t keylen, bool copy_key); /** * Replace a object 'elt' to the hash 'top' and associate it with key 'key', old object will be unrefed, @@ -399,8 +412,8 @@ UCL_EXTERN bool ucl_object_insert_key (ucl_object_t *top, ucl_object_t *elt, * @param copy_key make an internal copy of key * @return true if key has been inserted */ -UCL_EXTERN bool ucl_object_replace_key (ucl_object_t *top, ucl_object_t *elt, - const char *key, size_t keylen, bool copy_key); +UCL_EXTERN bool ucl_object_replace_key(ucl_object_t *top, ucl_object_t *elt, + const char *key, size_t keylen, bool copy_key); /** * Merge the keys from one object to another object. Overwrite on conflict @@ -409,7 +422,7 @@ UCL_EXTERN bool ucl_object_replace_key (ucl_object_t *top, ucl_object_t *elt, * @param copy copy rather than reference the elements * @return true if all keys have been merged */ -UCL_EXTERN bool ucl_object_merge (ucl_object_t *top, ucl_object_t *elt, bool copy); +UCL_EXTERN bool ucl_object_merge(ucl_object_t *top, ucl_object_t *elt, bool copy); /** * Delete a object associated with key 'key', old object will be unrefered, @@ -417,16 +430,16 @@ UCL_EXTERN bool ucl_object_merge (ucl_object_t *top, ucl_object_t *elt, bool cop * @param key key associated to the object to remove * @param keylen length of the key (or 0 for NULL terminated keys) */ -UCL_EXTERN bool ucl_object_delete_keyl (ucl_object_t *top, - const char *key, size_t keylen); +UCL_EXTERN bool ucl_object_delete_keyl(ucl_object_t *top, + const char *key, size_t keylen); /** * Delete a object associated with key 'key', old object will be unrefered, * @param top object * @param key key associated to the object to remove */ -UCL_EXTERN bool ucl_object_delete_key (ucl_object_t *top, - const char *key); +UCL_EXTERN bool ucl_object_delete_key(ucl_object_t *top, + const char *key); /** @@ -438,8 +451,8 @@ UCL_EXTERN bool ucl_object_delete_key (ucl_object_t *top, * @param keylen length of the key (or 0 for NULL terminated keys) * @return removed object or NULL if object has not been found */ -UCL_EXTERN ucl_object_t* ucl_object_pop_keyl (ucl_object_t *top, const char *key, - size_t keylen) UCL_WARN_UNUSED_RESULT; +UCL_EXTERN ucl_object_t *ucl_object_pop_keyl(ucl_object_t *top, const char *key, + size_t keylen) UCL_WARN_UNUSED_RESULT; /** * Removes `key` from `top` object returning the object that was removed. This @@ -449,7 +462,7 @@ UCL_EXTERN ucl_object_t* ucl_object_pop_keyl (ucl_object_t *top, const char *key * @param key key to remove * @return removed object or NULL if object has not been found */ -UCL_EXTERN ucl_object_t* ucl_object_pop_key (ucl_object_t *top, const char *key) +UCL_EXTERN ucl_object_t *ucl_object_pop_key(ucl_object_t *top, const char *key) UCL_WARN_UNUSED_RESULT; /** @@ -462,8 +475,8 @@ UCL_EXTERN ucl_object_t* ucl_object_pop_key (ucl_object_t *top, const char *key) * @param copy_key make an internal copy of key * @return true if key has been inserted */ -UCL_EXTERN bool ucl_object_insert_key_merged (ucl_object_t *top, ucl_object_t *elt, - const char *key, size_t keylen, bool copy_key); +UCL_EXTERN bool ucl_object_insert_key_merged(ucl_object_t *top, ucl_object_t *elt, + const char *key, size_t keylen, bool copy_key); /** * Reserve space in ucl array or object for `elt` elements @@ -471,7 +484,7 @@ UCL_EXTERN bool ucl_object_insert_key_merged (ucl_object_t *top, ucl_object_t *e * @param reserved size to reserve in an object * @return 0 on success, -1 on failure (i.e. ENOMEM) */ -UCL_EXTERN bool ucl_object_reserve (ucl_object_t *obj, size_t reserved); +UCL_EXTERN bool ucl_object_reserve(ucl_object_t *obj, size_t reserved); /** * Append an element to the end of array object @@ -479,8 +492,8 @@ UCL_EXTERN bool ucl_object_reserve (ucl_object_t *obj, size_t reserved); * @param elt element to append (must NOT be NULL) * @return true if value has been inserted */ -UCL_EXTERN bool ucl_array_append (ucl_object_t *top, - ucl_object_t *elt); +UCL_EXTERN bool ucl_array_append(ucl_object_t *top, + ucl_object_t *elt); /** * Append an element to the start of array object @@ -488,8 +501,8 @@ UCL_EXTERN bool ucl_array_append (ucl_object_t *top, * @param elt element to append (must NOT be NULL) * @return true if value has been inserted */ -UCL_EXTERN bool ucl_array_prepend (ucl_object_t *top, - ucl_object_t *elt); +UCL_EXTERN bool ucl_array_prepend(ucl_object_t *top, + ucl_object_t *elt); /** * Merge all elements of second array into the first array @@ -498,8 +511,8 @@ UCL_EXTERN bool ucl_array_prepend (ucl_object_t *top, * @param copy copy elements instead of referencing them * @return true if arrays were merged */ -UCL_EXTERN bool ucl_array_merge (ucl_object_t *top, ucl_object_t *elt, - bool copy); +UCL_EXTERN bool ucl_array_merge(ucl_object_t *top, ucl_object_t *elt, + bool copy); /** * Removes an element `elt` from the array `top`, returning the object that was @@ -509,22 +522,22 @@ UCL_EXTERN bool ucl_array_merge (ucl_object_t *top, ucl_object_t *elt, * @param elt element to remove * @return removed element or NULL if `top` is NULL or not an array */ -UCL_EXTERN ucl_object_t* ucl_array_delete (ucl_object_t *top, - ucl_object_t *elt); +UCL_EXTERN ucl_object_t *ucl_array_delete(ucl_object_t *top, + ucl_object_t *elt); /** * Returns the first element of the array `top` * @param top array ucl object * @return element or NULL if `top` is NULL or not an array */ -UCL_EXTERN const ucl_object_t* ucl_array_head (const ucl_object_t *top); +UCL_EXTERN const ucl_object_t *ucl_array_head(const ucl_object_t *top); /** * Returns the last element of the array `top` * @param top array ucl object * @return element or NULL if `top` is NULL or not an array */ -UCL_EXTERN const ucl_object_t* ucl_array_tail (const ucl_object_t *top); +UCL_EXTERN const ucl_object_t *ucl_array_tail(const ucl_object_t *top); /** * Removes the last element from the array `top`, returning the object that was @@ -533,7 +546,7 @@ UCL_EXTERN const ucl_object_t* ucl_array_tail (const ucl_object_t *top); * @param top array ucl object * @return removed element or NULL if `top` is NULL or not an array */ -UCL_EXTERN ucl_object_t* ucl_array_pop_last (ucl_object_t *top); +UCL_EXTERN ucl_object_t *ucl_array_pop_last(ucl_object_t *top); /** * Removes the first element from the array `top`, returning the object that was @@ -542,14 +555,14 @@ UCL_EXTERN ucl_object_t* ucl_array_pop_last (ucl_object_t *top); * @param top array ucl object * @return removed element or NULL if `top` is NULL or not an array */ -UCL_EXTERN ucl_object_t* ucl_array_pop_first (ucl_object_t *top); +UCL_EXTERN ucl_object_t *ucl_array_pop_first(ucl_object_t *top); /** * Return size of the array `top` * @param top object to get size from (must be of type UCL_ARRAY) * @return size of the array */ -UCL_EXTERN unsigned int ucl_array_size (const ucl_object_t *top); +UCL_EXTERN unsigned int ucl_array_size(const ucl_object_t *top); /** * Return object identified by index of the array `top` @@ -557,8 +570,8 @@ UCL_EXTERN unsigned int ucl_array_size (const ucl_object_t *top); * @param index array index to return * @return object at the specified index or NULL if index is not found */ -UCL_EXTERN const ucl_object_t* ucl_array_find_index (const ucl_object_t *top, - unsigned int index); +UCL_EXTERN const ucl_object_t *ucl_array_find_index(const ucl_object_t *top, + unsigned int index); /** * Return the index of `elt` in the array `top` @@ -566,8 +579,8 @@ UCL_EXTERN const ucl_object_t* ucl_array_find_index (const ucl_object_t *top, * @param elt element to find index of (must NOT be NULL) * @return index of `elt` in the array `top or (unsigned int)-1 if `elt` is not found */ -UCL_EXTERN unsigned int ucl_array_index_of (ucl_object_t *top, - ucl_object_t *elt); +UCL_EXTERN unsigned int ucl_array_index_of(ucl_object_t *top, + ucl_object_t *elt); /** * Replace an element in an array with a different element, returning the object @@ -579,8 +592,8 @@ UCL_EXTERN unsigned int ucl_array_index_of (ucl_object_t *top, * @return object that was replaced or NULL if index is not found */ ucl_object_t * -ucl_array_replace_index (ucl_object_t *top, ucl_object_t *elt, - unsigned int index); +ucl_array_replace_index(ucl_object_t *top, ucl_object_t *elt, + unsigned int index); /** * Append a element to another element forming an implicit array @@ -588,8 +601,8 @@ ucl_array_replace_index (ucl_object_t *top, ucl_object_t *elt, * @param elt new element * @return the new implicit array */ -UCL_EXTERN ucl_object_t * ucl_elt_append (ucl_object_t *head, - ucl_object_t *elt); +UCL_EXTERN ucl_object_t *ucl_elt_append(ucl_object_t *head, + ucl_object_t *elt); /** * Converts an object to double value @@ -597,14 +610,14 @@ UCL_EXTERN ucl_object_t * ucl_elt_append (ucl_object_t *head, * @param target target double variable * @return true if conversion was successful */ -UCL_EXTERN bool ucl_object_todouble_safe (const ucl_object_t *obj, double *target); +UCL_EXTERN bool ucl_object_todouble_safe(const ucl_object_t *obj, double *target); /** * Unsafe version of \ref ucl_obj_todouble_safe * @param obj CL object * @return double value */ -UCL_EXTERN double ucl_object_todouble (const ucl_object_t *obj); +UCL_EXTERN double ucl_object_todouble(const ucl_object_t *obj); /** * Converts an object to integer value @@ -612,14 +625,14 @@ UCL_EXTERN double ucl_object_todouble (const ucl_object_t *obj); * @param target target integer variable * @return true if conversion was successful */ -UCL_EXTERN bool ucl_object_toint_safe (const ucl_object_t *obj, int64_t *target); +UCL_EXTERN bool ucl_object_toint_safe(const ucl_object_t *obj, int64_t *target); /** * Unsafe version of \ref ucl_obj_toint_safe * @param obj CL object * @return int value */ -UCL_EXTERN int64_t ucl_object_toint (const ucl_object_t *obj); +UCL_EXTERN int64_t ucl_object_toint(const ucl_object_t *obj); /** * Converts an object to boolean value @@ -627,14 +640,14 @@ UCL_EXTERN int64_t ucl_object_toint (const ucl_object_t *obj); * @param target target boolean variable * @return true if conversion was successful */ -UCL_EXTERN bool ucl_object_toboolean_safe (const ucl_object_t *obj, bool *target); +UCL_EXTERN bool ucl_object_toboolean_safe(const ucl_object_t *obj, bool *target); /** * Unsafe version of \ref ucl_obj_toboolean_safe * @param obj CL object * @return boolean value */ -UCL_EXTERN bool ucl_object_toboolean (const ucl_object_t *obj); +UCL_EXTERN bool ucl_object_toboolean(const ucl_object_t *obj); /** * Converts an object to string value @@ -642,21 +655,21 @@ UCL_EXTERN bool ucl_object_toboolean (const ucl_object_t *obj); * @param target target string variable, no need to free value * @return true if conversion was successful */ -UCL_EXTERN bool ucl_object_tostring_safe (const ucl_object_t *obj, const char **target); +UCL_EXTERN bool ucl_object_tostring_safe(const ucl_object_t *obj, const char **target); /** * Unsafe version of \ref ucl_obj_tostring_safe * @param obj CL object * @return string value */ -UCL_EXTERN const char* ucl_object_tostring (const ucl_object_t *obj); +UCL_EXTERN const char *ucl_object_tostring(const ucl_object_t *obj); /** * Convert any object to a string in JSON notation if needed * @param obj CL object * @return string value */ -UCL_EXTERN const char* ucl_object_tostring_forced (const ucl_object_t *obj); +UCL_EXTERN const char *ucl_object_tostring_forced(const ucl_object_t *obj); /** * Return string as char * and len, string may be not zero terminated, more efficient that \ref ucl_obj_tostring as it @@ -666,15 +679,15 @@ UCL_EXTERN const char* ucl_object_tostring_forced (const ucl_object_t *obj); * @param tlen target length * @return true if conversion was successful */ -UCL_EXTERN bool ucl_object_tolstring_safe (const ucl_object_t *obj, - const char **target, size_t *tlen); +UCL_EXTERN bool ucl_object_tolstring_safe(const ucl_object_t *obj, + const char **target, size_t *tlen); /** * Unsafe version of \ref ucl_obj_tolstring_safe * @param obj CL object * @return string value */ -UCL_EXTERN const char* ucl_object_tolstring (const ucl_object_t *obj, size_t *tlen); +UCL_EXTERN const char *ucl_object_tolstring(const ucl_object_t *obj, size_t *tlen); /** * Return object identified by a key in the specified object @@ -682,8 +695,8 @@ UCL_EXTERN const char* ucl_object_tolstring (const ucl_object_t *obj, size_t *tl * @param key key to search * @return object matching the specified key or NULL if key was not found */ -UCL_EXTERN const ucl_object_t* ucl_object_lookup (const ucl_object_t *obj, - const char *key); +UCL_EXTERN const ucl_object_t *ucl_object_lookup(const ucl_object_t *obj, + const char *key); #define ucl_object_find_key ucl_object_lookup /** @@ -696,8 +709,8 @@ UCL_EXTERN const ucl_object_t* ucl_object_lookup (const ucl_object_t *obj, * @param ... list of alternative keys to search (NULL terminated) * @return object matching the specified key or NULL if key was not found */ -UCL_EXTERN const ucl_object_t* ucl_object_lookup_any (const ucl_object_t *obj, - const char *key, ...); +UCL_EXTERN const ucl_object_t *ucl_object_lookup_any(const ucl_object_t *obj, + const char *key, ...); #define ucl_object_find_any_key ucl_object_lookup_any /** @@ -707,8 +720,8 @@ UCL_EXTERN const ucl_object_t* ucl_object_lookup_any (const ucl_object_t *obj, * @param klen length of a key * @return object matching the specified key or NULL if key was not found */ -UCL_EXTERN const ucl_object_t* ucl_object_lookup_len (const ucl_object_t *obj, - const char *key, size_t klen); +UCL_EXTERN const ucl_object_t *ucl_object_lookup_len(const ucl_object_t *obj, + const char *key, size_t klen); #define ucl_object_find_keyl ucl_object_lookup_len /** @@ -717,8 +730,8 @@ UCL_EXTERN const ucl_object_t* ucl_object_lookup_len (const ucl_object_t *obj, * @param path dot.notation.path to the path to lookup. May use numeric .index on arrays * @return object matched the specified path or NULL if path is not found */ -UCL_EXTERN const ucl_object_t *ucl_object_lookup_path (const ucl_object_t *obj, - const char *path); +UCL_EXTERN const ucl_object_t *ucl_object_lookup_path(const ucl_object_t *obj, + const char *path); #define ucl_lookup_path ucl_object_lookup_path /** @@ -728,8 +741,8 @@ UCL_EXTERN const ucl_object_t *ucl_object_lookup_path (const ucl_object_t *obj, * @param sep the sepatorator to use in place of . (incase keys have . in them) * @return object matched the specified path or NULL if path is not found */ -UCL_EXTERN const ucl_object_t *ucl_object_lookup_path_char (const ucl_object_t *obj, - const char *path, char sep); +UCL_EXTERN const ucl_object_t *ucl_object_lookup_path_char(const ucl_object_t *obj, + const char *path, char sep); #define ucl_lookup_path_char ucl_object_lookup_path_char /** @@ -737,7 +750,7 @@ UCL_EXTERN const ucl_object_t *ucl_object_lookup_path_char (const ucl_object_t * * @param obj CL object * @return key or NULL if there is no key */ -UCL_EXTERN const char* ucl_object_key (const ucl_object_t *obj); +UCL_EXTERN const char *ucl_object_key(const ucl_object_t *obj); /** * Returns a key of an object as a fixed size string (may be more efficient) @@ -745,26 +758,26 @@ UCL_EXTERN const char* ucl_object_key (const ucl_object_t *obj); * @param len target key length * @return key pointer */ -UCL_EXTERN const char* ucl_object_keyl (const ucl_object_t *obj, size_t *len); +UCL_EXTERN const char *ucl_object_keyl(const ucl_object_t *obj, size_t *len); /** * Increase reference count for an object * @param obj object to ref * @return the referenced object */ -UCL_EXTERN ucl_object_t* ucl_object_ref (const ucl_object_t *obj); +UCL_EXTERN ucl_object_t *ucl_object_ref(const ucl_object_t *obj); /** * Free ucl object * @param obj ucl object to free */ -UCL_DEPRECATED(UCL_EXTERN void ucl_object_free (ucl_object_t *obj)); +UCL_DEPRECATED(UCL_EXTERN void ucl_object_free(ucl_object_t *obj)); /** * Decrease reference count for an object * @param obj object to unref */ -UCL_EXTERN void ucl_object_unref (ucl_object_t *obj); +UCL_EXTERN void ucl_object_unref(ucl_object_t *obj); /** * Compare objects `o1` and `o2` @@ -776,8 +789,8 @@ UCL_EXTERN void ucl_object_unref (ucl_object_t *obj); * 2) Size of objects * 3) Content of objects */ -UCL_EXTERN int ucl_object_compare (const ucl_object_t *o1, - const ucl_object_t *o2); +UCL_EXTERN int ucl_object_compare(const ucl_object_t *o1, + const ucl_object_t *o2); /** * Compare objects `o1` and `o2` useful for sorting @@ -789,16 +802,16 @@ UCL_EXTERN int ucl_object_compare (const ucl_object_t *o1, * 2) Size of objects * 3) Content of objects */ -UCL_EXTERN int ucl_object_compare_qsort (const ucl_object_t **o1, - const ucl_object_t **o2); +UCL_EXTERN int ucl_object_compare_qsort(const ucl_object_t **o1, + const ucl_object_t **o2); /** * Sort UCL array using `cmp` compare function * @param ar * @param cmp */ -UCL_EXTERN void ucl_object_array_sort (ucl_object_t *ar, - int (*cmp)(const ucl_object_t **o1, const ucl_object_t **o2)); +UCL_EXTERN void ucl_object_array_sort(ucl_object_t *ar, + int (*cmp)(const ucl_object_t **o1, const ucl_object_t **o2)); enum ucl_object_keys_sort_flags { UCL_SORT_KEYS_DEFAULT = 0, @@ -810,28 +823,28 @@ enum ucl_object_keys_sort_flags { * @param obj * @param how */ -UCL_EXTERN void ucl_object_sort_keys (ucl_object_t *obj, - enum ucl_object_keys_sort_flags how); +UCL_EXTERN void ucl_object_sort_keys(ucl_object_t *obj, + enum ucl_object_keys_sort_flags how); /** * Get the priority for specific UCL object * @param obj any ucl object * @return priority of an object */ -UCL_EXTERN unsigned int ucl_object_get_priority (const ucl_object_t *obj); +UCL_EXTERN unsigned int ucl_object_get_priority(const ucl_object_t *obj); /** * Set explicit priority of an object. * @param obj any ucl object * @param priority new priroity value (only 4 least significant bits are considred) */ -UCL_EXTERN void ucl_object_set_priority (ucl_object_t *obj, - unsigned int priority); +UCL_EXTERN void ucl_object_set_priority(ucl_object_t *obj, + unsigned int priority); /** * Opaque iterator object */ -typedef void* ucl_object_iter_t; +typedef void *ucl_object_iter_t; /** * Get next key from an object @@ -842,8 +855,8 @@ typedef void* ucl_object_iter_t; * @param ep pointer record exception (such as ENOMEM), could be NULL * @return the next object or NULL */ -UCL_EXTERN const ucl_object_t* ucl_object_iterate_with_error (const ucl_object_t *obj, - ucl_object_iter_t *iter, bool expand_values, int *ep); +UCL_EXTERN const ucl_object_t *ucl_object_iterate_with_error(const ucl_object_t *obj, + ucl_object_iter_t *iter, bool expand_values, int *ep); #define ucl_iterate_object ucl_object_iterate #define ucl_object_iterate(ob, it, ev) ucl_object_iterate_with_error((ob), (it), (ev), NULL) @@ -853,7 +866,7 @@ UCL_EXTERN const ucl_object_t* ucl_object_iterate_with_error (const ucl_object_t * @param obj object to iterate * @return new iterator object that should be used with safe iterators API only */ -UCL_EXTERN ucl_object_iter_t ucl_object_iterate_new (const ucl_object_t *obj) +UCL_EXTERN ucl_object_iter_t ucl_object_iterate_new(const ucl_object_t *obj) UCL_WARN_UNUSED_RESULT; /** * Check safe iterator object after performing some operations on it @@ -869,8 +882,8 @@ UCL_EXTERN bool ucl_object_iter_chk_excpn(ucl_object_iter_t *it); * @param obj new object to iterate * @return modified iterator object */ -UCL_EXTERN ucl_object_iter_t ucl_object_iterate_reset (ucl_object_iter_t it, - const ucl_object_t *obj); +UCL_EXTERN ucl_object_iter_t ucl_object_iterate_reset(ucl_object_iter_t it, + const ucl_object_t *obj); /** * Get the next object from the `obj`. This function iterates over arrays, objects @@ -879,15 +892,15 @@ UCL_EXTERN ucl_object_iter_t ucl_object_iterate_reset (ucl_object_iter_t it, * @param expand_values expand explicit arrays and objects * @return the next object in sequence */ -UCL_EXTERN const ucl_object_t* ucl_object_iterate_safe (ucl_object_iter_t iter, - bool expand_values); +UCL_EXTERN const ucl_object_t *ucl_object_iterate_safe(ucl_object_iter_t iter, + bool expand_values); /** * Iteration type enumerator */ enum ucl_iterate_type { - UCL_ITERATE_EXPLICIT = 1 << 0, /**< Iterate just explicit arrays and objects */ - UCL_ITERATE_IMPLICIT = 1 << 1, /**< Iterate just implicit arrays */ - UCL_ITERATE_BOTH = (1 << 0) | (1 << 1), /**< Iterate both explicit and implicit arrays*/ + UCL_ITERATE_EXPLICIT = 1 << 0, /**< Iterate just explicit arrays and objects */ + UCL_ITERATE_IMPLICIT = 1 << 1, /**< Iterate just implicit arrays */ + UCL_ITERATE_BOTH = (1 << 0) | (1 << 1), /**< Iterate both explicit and implicit arrays*/ }; /** @@ -897,14 +910,14 @@ enum ucl_iterate_type { * @param * @return the next object in sequence */ -UCL_EXTERN const ucl_object_t* ucl_object_iterate_full (ucl_object_iter_t iter, - enum ucl_iterate_type type); +UCL_EXTERN const ucl_object_t *ucl_object_iterate_full(ucl_object_iter_t iter, + enum ucl_iterate_type type); /** * Free memory associated with the safe iterator * @param it safe iterator object */ -UCL_EXTERN void ucl_object_iterate_free (ucl_object_iter_t it); +UCL_EXTERN void ucl_object_iterate_free(ucl_object_iter_t it); /** @} */ @@ -925,9 +938,9 @@ UCL_EXTERN void ucl_object_iterate_free (ucl_object_iter_t it); * @param err error pointer * @return true if macro has been parsed */ -typedef bool (*ucl_macro_handler) (const unsigned char *data, size_t len, - const ucl_object_t *arguments, - void* ud); +typedef bool (*ucl_macro_handler)(const unsigned char *data, size_t len, + const ucl_object_t *arguments, + void *ud); /** * Context dependent macro handler for a parser @@ -939,10 +952,10 @@ typedef bool (*ucl_macro_handler) (const unsigned char *data, size_t len, * @param err error pointer * @return true if macro has been parsed */ -typedef bool (*ucl_context_macro_handler) (const unsigned char *data, size_t len, - const ucl_object_t *arguments, - const ucl_object_t *context, - void* ud); +typedef bool (*ucl_context_macro_handler)(const unsigned char *data, size_t len, + const ucl_object_t *arguments, + const ucl_object_t *context, + void *ud); /* Opaque parser */ struct ucl_parser; @@ -952,7 +965,7 @@ struct ucl_parser; * @param pool pool to allocate memory from * @return new parser object */ -UCL_EXTERN struct ucl_parser* ucl_parser_new (int flags); +UCL_EXTERN struct ucl_parser *ucl_parser_new(int flags); /** * Sets the default priority for the parser applied to chunks that do not @@ -961,15 +974,15 @@ UCL_EXTERN struct ucl_parser* ucl_parser_new (int flags); * @param prio default priority (0 .. 16) * @return true if parser's default priority was set */ -UCL_EXTERN bool ucl_parser_set_default_priority (struct ucl_parser *parser, - unsigned prio); +UCL_EXTERN bool ucl_parser_set_default_priority(struct ucl_parser *parser, + unsigned prio); /** * Gets the default priority for the parser applied to chunks that do not * specify priority explicitly * @param parser parser object * @return true default priority (0 .. 16), -1 for failure */ -UCL_EXTERN int ucl_parser_get_default_priority (struct ucl_parser *parser); +UCL_EXTERN int ucl_parser_get_default_priority(struct ucl_parser *parser); /** * Register new handler for a macro @@ -979,9 +992,9 @@ UCL_EXTERN int ucl_parser_get_default_priority (struct ucl_parser *parser); * @param ud opaque user data for a handler * @return true on success, false on failure (i.e. ENOMEM) */ -UCL_EXTERN bool ucl_parser_register_macro (struct ucl_parser *parser, - const char *macro, - ucl_macro_handler handler, void* ud); +UCL_EXTERN bool ucl_parser_register_macro(struct ucl_parser *parser, + const char *macro, + ucl_macro_handler handler, void *ud); /** * Register new context dependent handler for a macro @@ -991,10 +1004,10 @@ UCL_EXTERN bool ucl_parser_register_macro (struct ucl_parser *parser, * @param ud opaque user data for a handler * @return true on success, false on failure (i.e. ENOMEM) */ -UCL_EXTERN bool ucl_parser_register_context_macro (struct ucl_parser *parser, - const char *macro, - ucl_context_macro_handler handler, - void* ud); +UCL_EXTERN bool ucl_parser_register_context_macro(struct ucl_parser *parser, + const char *macro, + ucl_context_macro_handler handler, + void *ud); /** * Handler to detect unregistered variables @@ -1006,8 +1019,8 @@ UCL_EXTERN bool ucl_parser_register_context_macro (struct ucl_parser *parser, * @param ud opaque userdata * @return true if variable */ -typedef bool (*ucl_variable_handler) (const unsigned char *data, size_t len, - unsigned char **replace, size_t *replace_len, bool *need_free, void* ud); +typedef bool (*ucl_variable_handler)(const unsigned char *data, size_t len, + unsigned char **replace, size_t *replace_len, bool *need_free, void *ud); /** * Register new parser variable @@ -1015,8 +1028,8 @@ typedef bool (*ucl_variable_handler) (const unsigned char *data, size_t len, * @param var variable name * @param value variable value */ -UCL_EXTERN void ucl_parser_register_variable (struct ucl_parser *parser, const char *var, - const char *value); +UCL_EXTERN void ucl_parser_register_variable(struct ucl_parser *parser, const char *var, + const char *value); /** * Set handler for unknown variables @@ -1024,8 +1037,8 @@ UCL_EXTERN void ucl_parser_register_variable (struct ucl_parser *parser, const c * @param handler desired handler * @param ud opaque data for the handler */ -UCL_EXTERN void ucl_parser_set_variables_handler (struct ucl_parser *parser, - ucl_variable_handler handler, void *ud); +UCL_EXTERN void ucl_parser_set_variables_handler(struct ucl_parser *parser, + ucl_variable_handler handler, void *ud); /** * Load new chunk to a parser @@ -1034,8 +1047,8 @@ UCL_EXTERN void ucl_parser_set_variables_handler (struct ucl_parser *parser, * @param len the length of a chunk * @return true if chunk has been added and false in case of error */ -UCL_EXTERN bool ucl_parser_add_chunk (struct ucl_parser *parser, - const unsigned char *data, size_t len); +UCL_EXTERN bool ucl_parser_add_chunk(struct ucl_parser *parser, + const unsigned char *data, size_t len); /** * Load new chunk to a parser with the specified priority @@ -1046,8 +1059,8 @@ UCL_EXTERN bool ucl_parser_add_chunk (struct ucl_parser *parser, * are considered for this parameter) * @return true if chunk has been added and false in case of error */ -UCL_EXTERN bool ucl_parser_add_chunk_priority (struct ucl_parser *parser, - const unsigned char *data, size_t len, unsigned priority); +UCL_EXTERN bool ucl_parser_add_chunk_priority(struct ucl_parser *parser, + const unsigned char *data, size_t len, unsigned priority); /** * Insert new chunk to a parser (must have previously processed data with an existing top object) @@ -1056,8 +1069,8 @@ UCL_EXTERN bool ucl_parser_add_chunk_priority (struct ucl_parser *parser, * @param len the length of a chunk * @return true if chunk has been added and false in case of error */ -UCL_EXTERN bool ucl_parser_insert_chunk (struct ucl_parser *parser, - const unsigned char *data, size_t len); +UCL_EXTERN bool ucl_parser_insert_chunk(struct ucl_parser *parser, + const unsigned char *data, size_t len); /** * Full version of ucl_add_chunk with priority and duplicate strategy @@ -1070,9 +1083,9 @@ UCL_EXTERN bool ucl_parser_insert_chunk (struct ucl_parser *parser, * @param parse_type input format * @return true if chunk has been added and false in case of error */ -UCL_EXTERN bool ucl_parser_add_chunk_full (struct ucl_parser *parser, - const unsigned char *data, size_t len, unsigned priority, - enum ucl_duplicate_strategy strat, enum ucl_parse_type parse_type); +UCL_EXTERN bool ucl_parser_add_chunk_full(struct ucl_parser *parser, + const unsigned char *data, size_t len, unsigned priority, + enum ucl_duplicate_strategy strat, enum ucl_parse_type parse_type); /** * Load ucl object from a string @@ -1081,8 +1094,8 @@ UCL_EXTERN bool ucl_parser_add_chunk_full (struct ucl_parser *parser, * @param len the length of the string, if `len` is 0 then `data` must be zero-terminated string * @return true if string has been added and false in case of error */ -UCL_EXTERN bool ucl_parser_add_string (struct ucl_parser *parser, - const char *data, size_t len); +UCL_EXTERN bool ucl_parser_add_string(struct ucl_parser *parser, + const char *data, size_t len); /** * Load ucl object from a string @@ -1093,8 +1106,8 @@ UCL_EXTERN bool ucl_parser_add_string (struct ucl_parser *parser, * are considered for this parameter) * @return true if string has been added and false in case of error */ -UCL_EXTERN bool ucl_parser_add_string_priority (struct ucl_parser *parser, - const char *data, size_t len, unsigned priority); +UCL_EXTERN bool ucl_parser_add_string_priority(struct ucl_parser *parser, + const char *data, size_t len, unsigned priority); /** * Load and add data from a file @@ -1103,8 +1116,8 @@ UCL_EXTERN bool ucl_parser_add_string_priority (struct ucl_parser *parser, * @param err if *err is NULL it is set to parser error * @return true if chunk has been added and false in case of error */ -UCL_EXTERN bool ucl_parser_add_file (struct ucl_parser *parser, - const char *filename); +UCL_EXTERN bool ucl_parser_add_file(struct ucl_parser *parser, + const char *filename); /** * Load and add data from a file @@ -1115,8 +1128,8 @@ UCL_EXTERN bool ucl_parser_add_file (struct ucl_parser *parser, * are considered for this parameter) * @return true if chunk has been added and false in case of error */ -UCL_EXTERN bool ucl_parser_add_file_priority (struct ucl_parser *parser, - const char *filename, unsigned priority); +UCL_EXTERN bool ucl_parser_add_file_priority(struct ucl_parser *parser, + const char *filename, unsigned priority); /** * Load and add data from a file @@ -1128,9 +1141,9 @@ UCL_EXTERN bool ucl_parser_add_file_priority (struct ucl_parser *parser, * @param parse_type Parser type to use while parsing this file * @return true if chunk has been added and false in case of error */ -UCL_EXTERN bool ucl_parser_add_file_full (struct ucl_parser *parser, const char *filename, - unsigned priority, enum ucl_duplicate_strategy strat, - enum ucl_parse_type parse_type); +UCL_EXTERN bool ucl_parser_add_file_full(struct ucl_parser *parser, const char *filename, + unsigned priority, enum ucl_duplicate_strategy strat, + enum ucl_parse_type parse_type); /** * Load and add data from a file descriptor @@ -1139,8 +1152,8 @@ UCL_EXTERN bool ucl_parser_add_file_full (struct ucl_parser *parser, const char * @param err if *err is NULL it is set to parser error * @return true if chunk has been added and false in case of error */ -UCL_EXTERN bool ucl_parser_add_fd (struct ucl_parser *parser, - int fd); +UCL_EXTERN bool ucl_parser_add_fd(struct ucl_parser *parser, + int fd); /** * Load and add data from a file descriptor @@ -1151,8 +1164,8 @@ UCL_EXTERN bool ucl_parser_add_fd (struct ucl_parser *parser, * are considered for this parameter) * @return true if chunk has been added and false in case of error */ -UCL_EXTERN bool ucl_parser_add_fd_priority (struct ucl_parser *parser, - int fd, unsigned priority); +UCL_EXTERN bool ucl_parser_add_fd_priority(struct ucl_parser *parser, + int fd, unsigned priority); /** * Load and add data from a file descriptor @@ -1165,9 +1178,9 @@ UCL_EXTERN bool ucl_parser_add_fd_priority (struct ucl_parser *parser, * @param parse_type Parser type to use while parsing this file * @return true if chunk has been added and false in case of error */ -UCL_EXTERN bool ucl_parser_add_fd_full (struct ucl_parser *parser, int fd, - unsigned priority, enum ucl_duplicate_strategy strat, - enum ucl_parse_type parse_type); +UCL_EXTERN bool ucl_parser_add_fd_full(struct ucl_parser *parser, int fd, + unsigned priority, enum ucl_duplicate_strategy strat, + enum ucl_parse_type parse_type); /** * Provide a UCL_ARRAY of paths to search for include files. The object is @@ -1176,8 +1189,8 @@ UCL_EXTERN bool ucl_parser_add_fd_full (struct ucl_parser *parser, int fd, * @param paths UCL_ARRAY of paths to search * @return true if the path search array was replaced in the parser */ -UCL_EXTERN bool ucl_set_include_path (struct ucl_parser *parser, - ucl_object_t *paths); +UCL_EXTERN bool ucl_set_include_path(struct ucl_parser *parser, + ucl_object_t *paths); /** * Get a top object for a parser (refcount is increased) @@ -1185,7 +1198,7 @@ UCL_EXTERN bool ucl_set_include_path (struct ucl_parser *parser, * @param err if *err is NULL it is set to parser error * @return top parser object or NULL */ -UCL_EXTERN ucl_object_t* ucl_parser_get_object (struct ucl_parser *parser); +UCL_EXTERN ucl_object_t *ucl_parser_get_object(struct ucl_parser *parser); /** * Get the current stack object as stack accessor function for use in macro @@ -1194,61 +1207,61 @@ UCL_EXTERN ucl_object_t* ucl_parser_get_object (struct ucl_parser *parser); * @param depth depth of stack to retrieve (top is 0) * @return current stack object or NULL */ -UCL_EXTERN ucl_object_t* ucl_parser_get_current_stack_object (struct ucl_parser *parser, unsigned int depth); +UCL_EXTERN ucl_object_t *ucl_parser_get_current_stack_object(struct ucl_parser *parser, unsigned int depth); /** * Peek at the character at the current chunk position * @param parser parser structure * @return current chunk position character */ -UCL_EXTERN unsigned char ucl_parser_chunk_peek (struct ucl_parser *parser); +UCL_EXTERN unsigned char ucl_parser_chunk_peek(struct ucl_parser *parser); /** * Skip the character at the current chunk position * @param parser parser structure * @return success boolean */ -UCL_EXTERN bool ucl_parser_chunk_skip (struct ucl_parser *parser); +UCL_EXTERN bool ucl_parser_chunk_skip(struct ucl_parser *parser); /** * Get the error string if parsing has been failed * @param parser parser object * @return error description */ -UCL_EXTERN const char *ucl_parser_get_error (struct ucl_parser *parser); +UCL_EXTERN const char *ucl_parser_get_error(struct ucl_parser *parser); /** * Get the code of the last error * @param parser parser object * @return error code */ -UCL_EXTERN int ucl_parser_get_error_code (struct ucl_parser *parser); +UCL_EXTERN int ucl_parser_get_error_code(struct ucl_parser *parser); /** * Get the current column number within parser * @param parser parser object * @return current column number */ -UCL_EXTERN unsigned ucl_parser_get_column (struct ucl_parser *parser); +UCL_EXTERN unsigned ucl_parser_get_column(struct ucl_parser *parser); /** * Get the current line number within parser * @param parser parser object * @return current line number */ -UCL_EXTERN unsigned ucl_parser_get_linenum (struct ucl_parser *parser); +UCL_EXTERN unsigned ucl_parser_get_linenum(struct ucl_parser *parser); /** * Clear the error in the parser * @param parser parser object */ -UCL_EXTERN void ucl_parser_clear_error (struct ucl_parser *parser); +UCL_EXTERN void ucl_parser_clear_error(struct ucl_parser *parser); /** * Free ucl parser object * @param parser parser object */ -UCL_EXTERN void ucl_parser_free (struct ucl_parser *parser); +UCL_EXTERN void ucl_parser_free(struct ucl_parser *parser); /** * Get constant opaque pointer to comments structure for this parser. Increase @@ -1256,7 +1269,7 @@ UCL_EXTERN void ucl_parser_free (struct ucl_parser *parser); * @param parser parser structure * @return ucl comments pointer or NULL */ -UCL_EXTERN const ucl_object_t * ucl_parser_get_comments (struct ucl_parser *parser); +UCL_EXTERN const ucl_object_t *ucl_parser_get_comments(struct ucl_parser *parser); /** * Utility function to find a comment object for the specified object in the input @@ -1264,8 +1277,8 @@ UCL_EXTERN const ucl_object_t * ucl_parser_get_comments (struct ucl_parser *pars * @param srch search object * @return string comment enclosed in ucl_object_t */ -UCL_EXTERN const ucl_object_t * ucl_comments_find (const ucl_object_t *comments, - const ucl_object_t *srch); +UCL_EXTERN const ucl_object_t *ucl_comments_find(const ucl_object_t *comments, + const ucl_object_t *srch); /** * Move comment from `from` object to `to` object @@ -1274,8 +1287,8 @@ UCL_EXTERN const ucl_object_t * ucl_comments_find (const ucl_object_t *comments, * @param with destination object * @return `true` if `from` has comment and it has been moved to `to` */ -UCL_EXTERN bool ucl_comments_move (ucl_object_t *comments, - const ucl_object_t *from, const ucl_object_t *to); +UCL_EXTERN bool ucl_comments_move(ucl_object_t *comments, + const ucl_object_t *from, const ucl_object_t *to); /** * Adds a new comment for an object @@ -1283,8 +1296,8 @@ UCL_EXTERN bool ucl_comments_move (ucl_object_t *comments, * @param obj object to add comment to * @param comment string representation of a comment */ -UCL_EXTERN void ucl_comments_add (ucl_object_t *comments, - const ucl_object_t *obj, const char *comment); +UCL_EXTERN void ucl_comments_add(ucl_object_t *comments, + const ucl_object_t *obj, const char *comment); /** * Add new public key to parser for signatures check @@ -1294,8 +1307,8 @@ UCL_EXTERN void ucl_comments_add (ucl_object_t *comments, * @param err if *err is NULL it is set to parser error * @return true if a key has been successfully added */ -UCL_EXTERN bool ucl_parser_pubkey_add (struct ucl_parser *parser, - const unsigned char *key, size_t len); +UCL_EXTERN bool ucl_parser_pubkey_add(struct ucl_parser *parser, + const unsigned char *key, size_t len); /** * Set FILENAME and CURDIR variables in parser @@ -1304,23 +1317,23 @@ UCL_EXTERN bool ucl_parser_pubkey_add (struct ucl_parser *parser, * @param need_expand perform realpath() if this variable is true and filename is not NULL * @return true if variables has been set */ -UCL_EXTERN bool ucl_parser_set_filevars (struct ucl_parser *parser, const char *filename, - bool need_expand); +UCL_EXTERN bool ucl_parser_set_filevars(struct ucl_parser *parser, const char *filename, + bool need_expand); /** * Returns current file for the parser * @param parser parser object * @return current file or NULL if parsing memory */ -UCL_EXTERN const char *ucl_parser_get_cur_file (struct ucl_parser *parser); +UCL_EXTERN const char *ucl_parser_get_cur_file(struct ucl_parser *parser); /** * Defines special handler for certain types of data (identified by magic) */ -typedef bool (*ucl_parser_special_handler_t) (struct ucl_parser *parser, - const unsigned char *source, size_t source_len, - unsigned char **destination, size_t *dest_len, - void *user_data); +typedef bool (*ucl_parser_special_handler_t)(struct ucl_parser *parser, + const unsigned char *source, size_t source_len, + unsigned char **destination, size_t *dest_len, + void *user_data); /** * Special handler flags @@ -1338,7 +1351,7 @@ struct ucl_parser_special_handler { size_t magic_len; enum ucl_special_handler_flags flags; ucl_parser_special_handler_t handler; - void (*free_function) (unsigned char *data, size_t len, void *user_data); + void (*free_function)(unsigned char *data, size_t len, void *user_data); void *user_data; struct ucl_parser_special_handler *next; /* Used internally */ }; @@ -1348,8 +1361,8 @@ struct ucl_parser_special_handler { * @param parser parser structure * @param handler handler structure */ -UCL_EXTERN void ucl_parser_add_special_handler (struct ucl_parser *parser, - struct ucl_parser_special_handler *handler); +UCL_EXTERN void ucl_parser_add_special_handler(struct ucl_parser *parser, + struct ucl_parser_special_handler *handler); /** * Handler for include traces: @@ -1360,12 +1373,12 @@ UCL_EXTERN void ucl_parser_add_special_handler (struct ucl_parser *parser, * @param pathlen length of the path * @param user_data opaque userdata */ -typedef void (ucl_include_trace_func_t) (struct ucl_parser *parser, - const ucl_object_t *parent, - const ucl_object_t *args, - const char *path, - size_t pathlen, - void *user_data); +typedef void(ucl_include_trace_func_t)(struct ucl_parser *parser, + const ucl_object_t *parent, + const ucl_object_t *args, + const char *path, + size_t pathlen, + void *user_data); /** * Register trace function for an include handler @@ -1373,9 +1386,9 @@ typedef void (ucl_include_trace_func_t) (struct ucl_parser *parser, * @param func function to trace includes * @param user_data opaque data */ -UCL_EXTERN void ucl_parser_set_include_tracer (struct ucl_parser *parser, - ucl_include_trace_func_t func, - void *user_data); +UCL_EXTERN void ucl_parser_set_include_tracer(struct ucl_parser *parser, + ucl_include_trace_func_t func, + void *user_data); /** @} */ @@ -1392,13 +1405,13 @@ struct ucl_emitter_context; */ struct ucl_emitter_functions { /** Append a single character */ - int (*ucl_emitter_append_character) (unsigned char c, size_t nchars, void *ud); + int (*ucl_emitter_append_character)(unsigned char c, size_t nchars, void *ud); /** Append a string of a specified length */ - int (*ucl_emitter_append_len) (unsigned const char *str, size_t len, void *ud); + int (*ucl_emitter_append_len)(unsigned const char *str, size_t len, void *ud); /** Append a 64 bit integer */ - int (*ucl_emitter_append_int) (int64_t elt, void *ud); + int (*ucl_emitter_append_int)(int64_t elt, void *ud); /** Append floating point element */ - int (*ucl_emitter_append_double) (double elt, void *ud); + int (*ucl_emitter_append_double)(double elt, void *ud); /** Free userdata */ void (*ucl_emitter_free_func)(void *ud); /** Opaque userdata pointer */ @@ -1407,19 +1420,19 @@ struct ucl_emitter_functions { struct ucl_emitter_operations { /** Write a primitive element */ - void (*ucl_emitter_write_elt) (struct ucl_emitter_context *ctx, - const ucl_object_t *obj, bool first, bool print_key); + void (*ucl_emitter_write_elt)(struct ucl_emitter_context *ctx, + const ucl_object_t *obj, bool first, bool print_key); /** Start ucl object */ - void (*ucl_emitter_start_object) (struct ucl_emitter_context *ctx, - const ucl_object_t *obj, bool first, bool print_key); + void (*ucl_emitter_start_object)(struct ucl_emitter_context *ctx, + const ucl_object_t *obj, bool first, bool print_key); /** End ucl object */ - void (*ucl_emitter_end_object) (struct ucl_emitter_context *ctx, - const ucl_object_t *obj); + void (*ucl_emitter_end_object)(struct ucl_emitter_context *ctx, + const ucl_object_t *obj); /** Start ucl array */ - void (*ucl_emitter_start_array) (struct ucl_emitter_context *ctx, - const ucl_object_t *obj, bool first, bool print_key); - void (*ucl_emitter_end_array) (struct ucl_emitter_context *ctx, - const ucl_object_t *obj); + void (*ucl_emitter_start_array)(struct ucl_emitter_context *ctx, + const ucl_object_t *obj, bool first, bool print_key); + void (*ucl_emitter_end_array)(struct ucl_emitter_context *ctx, + const ucl_object_t *obj); }; /** @@ -1449,8 +1462,8 @@ struct ucl_emitter_context { * #UCL_EMIT_CONFIG then emit config like object * @return dump of an object (must be freed after using) or NULL in case of error */ -UCL_EXTERN unsigned char *ucl_object_emit (const ucl_object_t *obj, - enum ucl_emitter emit_type); +UCL_EXTERN unsigned char *ucl_object_emit(const ucl_object_t *obj, + enum ucl_emitter emit_type); /** * Emit object to a string that can contain `\0` inside @@ -1460,8 +1473,8 @@ UCL_EXTERN unsigned char *ucl_object_emit (const ucl_object_t *obj, * @param len the resulting length * @return dump of an object (must be freed after using) or NULL in case of error */ -UCL_EXTERN unsigned char *ucl_object_emit_len (const ucl_object_t *obj, - enum ucl_emitter emit_type, size_t *len); +UCL_EXTERN unsigned char *ucl_object_emit_len(const ucl_object_t *obj, + enum ucl_emitter emit_type, size_t *len); /** * Emit object to a string @@ -1472,10 +1485,10 @@ UCL_EXTERN unsigned char *ucl_object_emit_len (const ucl_object_t *obj, * @param comments optional comments for the parser * @return dump of an object (must be freed after using) or NULL in case of error */ -UCL_EXTERN bool ucl_object_emit_full (const ucl_object_t *obj, - enum ucl_emitter emit_type, - struct ucl_emitter_functions *emitter, - const ucl_object_t *comments); +UCL_EXTERN bool ucl_object_emit_full(const ucl_object_t *obj, + enum ucl_emitter emit_type, + struct ucl_emitter_functions *emitter, + const ucl_object_t *comments); /** * Start streamlined UCL object emitter @@ -1485,65 +1498,65 @@ UCL_EXTERN bool ucl_object_emit_full (const ucl_object_t *obj, * @return new streamlined context that should be freed by * `ucl_object_emit_streamline_finish` */ -UCL_EXTERN struct ucl_emitter_context* ucl_object_emit_streamline_new ( - const ucl_object_t *obj, enum ucl_emitter emit_type, - struct ucl_emitter_functions *emitter); +UCL_EXTERN struct ucl_emitter_context *ucl_object_emit_streamline_new( + const ucl_object_t *obj, enum ucl_emitter emit_type, + struct ucl_emitter_functions *emitter); /** * Start object or array container for the streamlined output * @param ctx streamlined context * @param obj container object */ -UCL_EXTERN void ucl_object_emit_streamline_start_container ( - struct ucl_emitter_context *ctx, const ucl_object_t *obj); +UCL_EXTERN bool ucl_object_emit_streamline_start_container( + struct ucl_emitter_context *ctx, const ucl_object_t *obj); /** * Add a complete UCL object to streamlined output * @param ctx streamlined context * @param obj object to output */ -UCL_EXTERN void ucl_object_emit_streamline_add_object ( - struct ucl_emitter_context *ctx, const ucl_object_t *obj); +UCL_EXTERN void ucl_object_emit_streamline_add_object( + struct ucl_emitter_context *ctx, const ucl_object_t *obj); /** * End previously added container * @param ctx streamlined context */ -UCL_EXTERN void ucl_object_emit_streamline_end_container ( - struct ucl_emitter_context *ctx); +UCL_EXTERN void ucl_object_emit_streamline_end_container( + struct ucl_emitter_context *ctx); /** * Terminate streamlined container finishing all containers in it * @param ctx streamlined context */ -UCL_EXTERN void ucl_object_emit_streamline_finish ( - struct ucl_emitter_context *ctx); +UCL_EXTERN void ucl_object_emit_streamline_finish( + struct ucl_emitter_context *ctx); /** * Returns functions to emit object to memory * @param pmem target pointer (should be freed by caller) * @return emitter functions structure */ -UCL_EXTERN struct ucl_emitter_functions* ucl_object_emit_memory_funcs ( - void **pmem); +UCL_EXTERN struct ucl_emitter_functions *ucl_object_emit_memory_funcs( + void **pmem); /** * Returns functions to emit object to FILE * * @param fp FILE * object * @return emitter functions structure */ -UCL_EXTERN struct ucl_emitter_functions* ucl_object_emit_file_funcs ( - FILE *fp); +UCL_EXTERN struct ucl_emitter_functions *ucl_object_emit_file_funcs( + FILE *fp); /** * Returns functions to emit object to a file descriptor * @param fd file descriptor * @return emitter functions structure */ -UCL_EXTERN struct ucl_emitter_functions* ucl_object_emit_fd_funcs ( - int fd); +UCL_EXTERN struct ucl_emitter_functions *ucl_object_emit_fd_funcs( + int fd); /** * Free emitter functions * @param f pointer to functions */ -UCL_EXTERN void ucl_object_emit_funcs_free (struct ucl_emitter_functions *f); +UCL_EXTERN void ucl_object_emit_funcs_free(struct ucl_emitter_functions *f); /** @} */ @@ -1558,25 +1571,25 @@ UCL_EXTERN void ucl_object_emit_funcs_free (struct ucl_emitter_functions *f); * Used to define UCL schema error */ enum ucl_schema_error_code { - UCL_SCHEMA_OK = 0, /**< no error */ - UCL_SCHEMA_TYPE_MISMATCH, /**< type of object is incorrect */ - UCL_SCHEMA_INVALID_SCHEMA, /**< schema is invalid */ - UCL_SCHEMA_MISSING_PROPERTY,/**< one or more missing properties */ - UCL_SCHEMA_CONSTRAINT, /**< constraint found */ - UCL_SCHEMA_MISSING_DEPENDENCY, /**< missing dependency */ + UCL_SCHEMA_OK = 0, /**< no error */ + UCL_SCHEMA_TYPE_MISMATCH, /**< type of object is incorrect */ + UCL_SCHEMA_INVALID_SCHEMA, /**< schema is invalid */ + UCL_SCHEMA_MISSING_PROPERTY, /**< one or more missing properties */ + UCL_SCHEMA_CONSTRAINT, /**< constraint found */ + UCL_SCHEMA_MISSING_DEPENDENCY, /**< missing dependency */ UCL_SCHEMA_EXTERNAL_REF_MISSING, /**< cannot fetch external ref */ UCL_SCHEMA_EXTERNAL_REF_INVALID, /**< invalid external ref */ - UCL_SCHEMA_INTERNAL_ERROR, /**< something bad happened */ - UCL_SCHEMA_UNKNOWN /**< generic error */ + UCL_SCHEMA_INTERNAL_ERROR, /**< something bad happened */ + UCL_SCHEMA_UNKNOWN /**< generic error */ }; /** * Generic ucl schema error */ struct ucl_schema_error { - enum ucl_schema_error_code code; /**< error code */ - char msg[128]; /**< error message */ - const ucl_object_t *obj; /**< object where error occurred */ + enum ucl_schema_error_code code; /**< error code */ + char msg[128]; /**< error message */ + const ucl_object_t *obj; /**< object where error occurred */ }; /** @@ -1587,8 +1600,8 @@ struct ucl_schema_error { * occurred, then `err` is filled with the exact error definition. * @return true if `obj` is valid using `schema` */ -UCL_EXTERN bool ucl_object_validate (const ucl_object_t *schema, - const ucl_object_t *obj, struct ucl_schema_error *err); +UCL_EXTERN bool ucl_object_validate(const ucl_object_t *schema, + const ucl_object_t *obj, struct ucl_schema_error *err); /** * Validate object `obj` using schema object `schema` and root schema at `root`. @@ -1599,10 +1612,10 @@ UCL_EXTERN bool ucl_object_validate (const ucl_object_t *schema, * occurred, then `err` is filled with the exact error definition. * @return true if `obj` is valid using `schema` */ -UCL_EXTERN bool ucl_object_validate_root (const ucl_object_t *schema, - const ucl_object_t *obj, - const ucl_object_t *root, - struct ucl_schema_error *err); +UCL_EXTERN bool ucl_object_validate_root(const ucl_object_t *schema, + const ucl_object_t *obj, + const ucl_object_t *root, + struct ucl_schema_error *err); /** * Validate object `obj` using schema object `schema` and root schema at `root` @@ -1615,15 +1628,15 @@ UCL_EXTERN bool ucl_object_validate_root (const ucl_object_t *schema, * occurred, then `err` is filled with the exact error definition. * @return true if `obj` is valid using `schema` */ -UCL_EXTERN bool ucl_object_validate_root_ext (const ucl_object_t *schema, - const ucl_object_t *obj, - const ucl_object_t *root, - ucl_object_t *ext_refs, - struct ucl_schema_error *err); +UCL_EXTERN bool ucl_object_validate_root_ext(const ucl_object_t *schema, + const ucl_object_t *obj, + const ucl_object_t *root, + ucl_object_t *ext_refs, + struct ucl_schema_error *err); /** @} */ -#ifdef __cplusplus +#ifdef __cplusplus } #endif /* diff --git a/lua/lua_ucl.c b/lua/lua_ucl.c index d6be69e42a71..40f7c780f9aa 100644 --- a/lua/lua_ucl.c +++ b/lua/lua_ucl.c @@ -648,7 +648,13 @@ static int lua_ucl_parser_init (lua_State *L) { struct ucl_parser *parser, **pparser; - int flags = UCL_PARSER_NO_FILEVARS; + /* + * We disable file variables and macros by default, as + * the most use cases are parsing of JSON and not of the real + * files. Macros in the parser are very dangerous and should be used + * for trusted data only. + */ + int flags = UCL_PARSER_NO_FILEVARS|UCL_PARSER_DISABLE_MACRO; if (lua_gettop (L) >= 1) { flags = lua_tonumber (L, 1); diff --git a/m4/gcov.m4 b/m4/gcov.m4 index a1359a0de64b..7b7266a99657 100644 --- a/m4/gcov.m4 +++ b/m4/gcov.m4 @@ -25,7 +25,7 @@ AC_DEFUN([AX_CODE_COVERAGE], [ -AC_ARG_ENABLE(coverage, AC_HELP_STRING([--enable-coverage],[configure code coverage analysis tools])) +AC_ARG_ENABLE(coverage, AS_HELP_STRING([--enable-coverage],[configure code coverage analysis tools])) HAVE_GCOV_TOOLS=0 diff --git a/src/mum.h b/src/mum.h index 318efea50268..aa1ed2d840a3 100644 --- a/src/mum.h +++ b/src/mum.h @@ -69,14 +69,14 @@ typedef unsigned __int64 uint64_t; #endif #endif -#if defined(__GNUC__) && ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 9) || (__GNUC__ > 4)) +#if defined(__GNUC__) && ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 9) || (__GNUC__ > 4)) #define _MUM_FRESH_GCC #endif #if defined(__GNUC__) && !defined(__llvm__) && defined(_MUM_FRESH_GCC) -#define _MUM_ATTRIBUTE_UNUSED __attribute__((unused)) -#define _MUM_OPTIMIZE(opts) __attribute__((__optimize__ (opts))) -#define _MUM_TARGET(opts) __attribute__((__target__ (opts))) +#define _MUM_ATTRIBUTE_UNUSED __attribute__((unused)) +#define _MUM_OPTIMIZE(opts) __attribute__((__optimize__(opts))) +#define _MUM_TARGET(opts) __attribute__((__target__(opts))) #else #define _MUM_ATTRIBUTE_UNUSED #define _MUM_OPTIMIZE(opts) @@ -95,93 +95,108 @@ static uint64_t _mum_tail_prime = 0xaf47d47c99b1461bULL; static uint64_t _mum_finish_prime1 = 0xa9a7ae7ceff79f3fULL; static uint64_t _mum_finish_prime2 = 0xaf47d47c99b1461bULL; -static uint64_t _mum_primes [] = { - 0X9ebdcae10d981691, 0X32b9b9b97a27ac7d, 0X29b5584d83d35bbd, 0X4b04e0e61401255f, - 0X25e8f7b1f1c9d027, 0X80d4c8c000f3e881, 0Xbd1255431904b9dd, 0X8a3bd4485eee6d81, - 0X3bc721b2aad05197, 0X71b1a19b907d6e33, 0X525e6c1084a8534b, 0X9e4c2cd340c1299f, - 0Xde3add92e94caa37, 0X7e14eadb1f65311d, 0X3f5aa40f89812853, 0X33b15a3b587d15c9, +static uint64_t _mum_primes[] = { + 0X9ebdcae10d981691, + 0X32b9b9b97a27ac7d, + 0X29b5584d83d35bbd, + 0X4b04e0e61401255f, + 0X25e8f7b1f1c9d027, + 0X80d4c8c000f3e881, + 0Xbd1255431904b9dd, + 0X8a3bd4485eee6d81, + 0X3bc721b2aad05197, + 0X71b1a19b907d6e33, + 0X525e6c1084a8534b, + 0X9e4c2cd340c1299f, + 0Xde3add92e94caa37, + 0X7e14eadb1f65311d, + 0X3f5aa40f89812853, + 0X33b15a3b587d15c9, }; /* Multiply 64-bit V and P and return sum of high and low parts of the result. */ static inline uint64_t -_mum (uint64_t v, uint64_t p) { - uint64_t hi, lo; +_mum(uint64_t v, uint64_t p) +{ + uint64_t hi, lo; #if _MUM_USE_INT128 #if defined(__aarch64__) - /* AARCH64 needs 2 insns to calculate 128-bit result of the + /* AARCH64 needs 2 insns to calculate 128-bit result of the multiplication. If we use a generic code we actually call a function doing 128x128->128 bit multiplication. The function is very slow. */ - lo = v * p, hi; - asm ("umulh %0, %1, %2" : "=r" (hi) : "r" (v), "r" (p)); + lo = v * p, hi; + asm("umulh %0, %1, %2" : "=r"(hi) : "r"(v), "r"(p)); #else - __uint128_t r = (__uint128_t) v * (__uint128_t) p; - hi = (uint64_t) (r >> 64); - lo = (uint64_t) r; + __uint128_t r = (__uint128_t) v * (__uint128_t) p; + hi = (uint64_t) (r >> 64); + lo = (uint64_t) r; #endif #else - /* Implementation of 64x64->128-bit multiplication by four 32x32->64 + /* Implementation of 64x64->128-bit multiplication by four 32x32->64 bit multiplication. */ - uint64_t hv = v >> 32, hp = p >> 32; - uint64_t lv = (uint32_t) v, lp = (uint32_t) p; - uint64_t rh = hv * hp; - uint64_t rm_0 = hv * lp; - uint64_t rm_1 = hp * lv; - uint64_t rl = lv * lp; - uint64_t t, carry = 0; - - /* We could ignore a carry bit here if we did not care about the + uint64_t hv = v >> 32, hp = p >> 32; + uint64_t lv = (uint32_t) v, lp = (uint32_t) p; + uint64_t rh = hv * hp; + uint64_t rm_0 = hv * lp; + uint64_t rm_1 = hp * lv; + uint64_t rl = lv * lp; + uint64_t t, carry = 0; + + /* We could ignore a carry bit here if we did not care about the same hash for 32-bit and 64-bit targets. */ - t = rl + (rm_0 << 32); + t = rl + (rm_0 << 32); #ifdef MUM_TARGET_INDEPENDENT_HASH - carry = t < rl; + carry = t < rl; #endif - lo = t + (rm_1 << 32); + lo = t + (rm_1 << 32); #ifdef MUM_TARGET_INDEPENDENT_HASH - carry += lo < t; + carry += lo < t; #endif - hi = rh + (rm_0 >> 32) + (rm_1 >> 32) + carry; + hi = rh + (rm_0 >> 32) + (rm_1 >> 32) + carry; #endif - /* We could use XOR here too but, for some reasons, on Haswell and + /* We could use XOR here too but, for some reasons, on Haswell and Power7 using an addition improves hashing performance by 10% for small strings. */ - return hi + lo; + return hi + lo; } #if defined(_MSC_VER) -#define _mum_bswap_32(x) _byteswap_uint32_t (x) -#define _mum_bswap_64(x) _byteswap_uint64_t (x) +#define _mum_bswap_32(x) _byteswap_uint32_t(x) +#define _mum_bswap_64(x) _byteswap_uint64_t(x) #elif defined(__APPLE__) #include -#define _mum_bswap_32(x) OSSwapInt32 (x) -#define _mum_bswap_64(x) OSSwapInt64 (x) +#define _mum_bswap_32(x) OSSwapInt32(x) +#define _mum_bswap_64(x) OSSwapInt64(x) #elif defined(__GNUC__) -#define _mum_bswap32(x) __builtin_bswap32 (x) -#define _mum_bswap64(x) __builtin_bswap64 (x) +#define _mum_bswap32(x) __builtin_bswap32(x) +#define _mum_bswap64(x) __builtin_bswap64(x) #else #include -#define _mum_bswap32(x) bswap32 (x) -#define _mum_bswap64(x) bswap64 (x) +#define _mum_bswap32(x) bswap32(x) +#define _mum_bswap64(x) bswap64(x) #endif static inline uint64_t -_mum_le (uint64_t v) { +_mum_le(uint64_t v) +{ #if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ || !defined(MUM_TARGET_INDEPENDENT_HASH) - return v; + return v; #elif __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__ - return _mum_bswap64 (v); + return _mum_bswap64(v); #else #error "Unknown endianness" #endif } static inline uint32_t -_mum_le32 (uint32_t v) { +_mum_le32(uint32_t v) +{ #if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ || !defined(MUM_TARGET_INDEPENDENT_HASH) - return v; + return v; #elif __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__ - return _mum_bswap32 (v); + return _mum_bswap32(v); #else #error "Unknown endianness" #endif @@ -214,71 +229,74 @@ _mum_le32 (uint32_t v) { #define _MUM_UNROLL_FACTOR (1 << _MUM_UNROLL_FACTOR_POWER) static inline uint64_t _MUM_OPTIMIZE("unroll-loops") -_mum_hash_aligned (uint64_t start, const void *key, size_t len) { - uint64_t result = start; - const unsigned char *str = (const unsigned char *) key; - uint64_t u64; - int i; - size_t n; - - result = _mum (result, _mum_block_start_prime); - while (len > _MUM_UNROLL_FACTOR * sizeof (uint64_t)) { - /* This loop could be vectorized when we have vector insns for + _mum_hash_aligned(uint64_t start, const void *key, size_t len) +{ + uint64_t result = start; + const unsigned char *str = (const unsigned char *) key; + uint64_t u64; + int i; + size_t n; + + result = _mum(result, _mum_block_start_prime); + while (len > _MUM_UNROLL_FACTOR * sizeof(uint64_t)) { + /* This loop could be vectorized when we have vector insns for 64x64->128-bit multiplication. AVX2 currently only have a vector insn for 4 32x32->64-bit multiplication. */ - for (i = 0; i < _MUM_UNROLL_FACTOR; i++) - result ^= _mum (_mum_le (((uint64_t *) str)[i]), _mum_primes[i]); - len -= _MUM_UNROLL_FACTOR * sizeof (uint64_t); - str += _MUM_UNROLL_FACTOR * sizeof (uint64_t); - /* We will use the same prime numbers on the next iterations -- + for (i = 0; i < _MUM_UNROLL_FACTOR; i++) + result ^= _mum(_mum_le(((uint64_t *) str)[i]), _mum_primes[i]); + len -= _MUM_UNROLL_FACTOR * sizeof(uint64_t); + str += _MUM_UNROLL_FACTOR * sizeof(uint64_t); + /* We will use the same prime numbers on the next iterations -- randomize the state. */ - result = _mum (result, _mum_unroll_prime); - } - n = len / sizeof (uint64_t); - for (i = 0; i < (int)n; i++) - result ^= _mum (_mum_le (((uint64_t *) str)[i]), _mum_primes[i]); - len -= n * sizeof (uint64_t); str += n * sizeof (uint64_t); - switch (len) { - case 7: - u64 = _mum_le32 (*(uint32_t *) str); - u64 |= (uint64_t) str[4] << 32; - u64 |= (uint64_t) str[5] << 40; - u64 |= (uint64_t) str[6] << 48; - return result ^ _mum (u64, _mum_tail_prime); - case 6: - u64 = _mum_le32 (*(uint32_t *) str); - u64 |= (uint64_t) str[4] << 32; - u64 |= (uint64_t) str[5] << 40; - return result ^ _mum (u64, _mum_tail_prime); - case 5: - u64 = _mum_le32 (*(uint32_t *) str); - u64 |= (uint64_t) str[4] << 32; - return result ^ _mum (u64, _mum_tail_prime); - case 4: - u64 = _mum_le32 (*(uint32_t *) str); - return result ^ _mum (u64, _mum_tail_prime); - case 3: - u64 = str[0]; - u64 |= (uint64_t) str[1] << 8; - u64 |= (uint64_t) str[2] << 16; - return result ^ _mum (u64, _mum_tail_prime); - case 2: - u64 = str[0]; - u64 |= (uint64_t) str[1] << 8; - return result ^ _mum (u64, _mum_tail_prime); - case 1: - u64 = str[0]; - return result ^ _mum (u64, _mum_tail_prime); - } - return result; + result = _mum(result, _mum_unroll_prime); + } + n = len / sizeof(uint64_t); + for (i = 0; i < (int) n; i++) + result ^= _mum(_mum_le(((uint64_t *) str)[i]), _mum_primes[i]); + len -= n * sizeof(uint64_t); + str += n * sizeof(uint64_t); + switch (len) { + case 7: + u64 = _mum_le32(*(uint32_t *) str); + u64 |= (uint64_t) str[4] << 32; + u64 |= (uint64_t) str[5] << 40; + u64 |= (uint64_t) str[6] << 48; + return result ^ _mum(u64, _mum_tail_prime); + case 6: + u64 = _mum_le32(*(uint32_t *) str); + u64 |= (uint64_t) str[4] << 32; + u64 |= (uint64_t) str[5] << 40; + return result ^ _mum(u64, _mum_tail_prime); + case 5: + u64 = _mum_le32(*(uint32_t *) str); + u64 |= (uint64_t) str[4] << 32; + return result ^ _mum(u64, _mum_tail_prime); + case 4: + u64 = _mum_le32(*(uint32_t *) str); + return result ^ _mum(u64, _mum_tail_prime); + case 3: + u64 = str[0]; + u64 |= (uint64_t) str[1] << 8; + u64 |= (uint64_t) str[2] << 16; + return result ^ _mum(u64, _mum_tail_prime); + case 2: + u64 = str[0]; + u64 |= (uint64_t) str[1] << 8; + return result ^ _mum(u64, _mum_tail_prime); + case 1: + u64 = str[0]; + return result ^ _mum(u64, _mum_tail_prime); + } + return result; } /* Final randomization of H. */ static inline uint64_t -_mum_final (uint64_t h) { - h ^= _mum (h, _mum_finish_prime1); - h ^= _mum (h, _mum_finish_prime2); - return h; +_mum_final(uint64_t h) +{ + h ^= _mum(h, _mum_finish_prime1); + h ^= _mum(h, _mum_finish_prime2); + return h; } #if defined(__x86_64__) && defined(_MUM_FRESH_GCC) @@ -288,16 +306,14 @@ _mum_final (uint64_t h) { 3-cycles vs. 4 for MULX, MULX permits more freedom in insn scheduling as it uses less fixed registers. */ static inline uint64_t _MUM_TARGET("arch=haswell") -_mum_hash_avx2 (const void * key, size_t len, uint64_t seed) { - return _mum_final (_mum_hash_aligned (seed + len, key, len)); + _mum_hash_avx2(const void *key, size_t len, uint64_t seed) +{ + return _mum_final(_mum_hash_aligned(seed + len, key, len)); } #endif #ifndef _MUM_UNALIGNED_ACCESS -#if defined(__x86_64__) || defined(__i386__) || defined(__PPC64__) \ - || defined(__s390__) || defined(__m32c__) || defined(cris) \ - || defined(__CR16__) || defined(__vax__) || defined(__m68k__) \ - || defined(__aarch64__) +#if defined(__x86_64__) || defined(__i386__) || defined(__PPC64__) || defined(__s390__) || defined(__m32c__) || defined(cris) || defined(__CR16__) || defined(__vax__) || defined(__m68k__) || defined(__aarch64__) #define _MUM_UNALIGNED_ACCESS 1 #else #define _MUM_UNALIGNED_ACCESS 0 @@ -317,101 +333,108 @@ _mum_hash_avx2 (const void * key, size_t len, uint64_t seed) { static inline uint64_t #if defined(__x86_64__) -_MUM_TARGET("inline-all-stringops") + _MUM_TARGET("inline-all-stringops") #endif -_mum_hash_default (const void *key, size_t len, uint64_t seed) { - uint64_t result; - const unsigned char *str = (const unsigned char *) key; - size_t block_len; - uint64_t buf[_MUM_BLOCK_LEN / sizeof (uint64_t)]; - - result = seed + len; - if (_MUM_UNALIGNED_ACCESS || ((size_t) str & 0x7) == 0) - result = _mum_hash_aligned (result, key, len); - else { - while (len != 0) { - block_len = len < _MUM_BLOCK_LEN ? len : _MUM_BLOCK_LEN; - memmove (buf, str, block_len); - result = _mum_hash_aligned (result, buf, block_len); - len -= block_len; - str += block_len; - } - } - return _mum_final (result); + _mum_hash_default(const void *key, size_t len, uint64_t seed) +{ + uint64_t result; + const unsigned char *str = (const unsigned char *) key; + size_t block_len; + uint64_t buf[_MUM_BLOCK_LEN / sizeof(uint64_t)]; + + result = seed + len; + if (_MUM_UNALIGNED_ACCESS || ((size_t) str & 0x7) == 0) + result = _mum_hash_aligned(result, key, len); + else { + while (len != 0) { + block_len = len < _MUM_BLOCK_LEN ? len : _MUM_BLOCK_LEN; + memmove(buf, str, block_len); + result = _mum_hash_aligned(result, buf, block_len); + len -= block_len; + str += block_len; + } + } + return _mum_final(result); } static inline uint64_t -_mum_next_factor (void) { - uint64_t start = 0; - int i; +_mum_next_factor(void) +{ + uint64_t start = 0; + int i; - for (i = 0; i < 8; i++) - start = (start << 8) | rand() % 256; - return start; + for (i = 0; i < 8; i++) + start = (start << 8) | rand() % 256; + return start; } /* ++++++++++++++++++++++++++ Interface functions: +++++++++++++++++++ */ /* Set random multiplicators depending on SEED. */ static inline void -mum_hash_randomize (uint64_t seed) { - int i; - - srand (seed); - _mum_hash_step_prime = _mum_next_factor (); - _mum_key_step_prime = _mum_next_factor (); - _mum_finish_prime1 = _mum_next_factor (); - _mum_finish_prime2 = _mum_next_factor (); - _mum_block_start_prime = _mum_next_factor (); - _mum_unroll_prime = _mum_next_factor (); - _mum_tail_prime = _mum_next_factor (); - for (i = 0; i < (int)(sizeof (_mum_primes) / sizeof (uint64_t)); i++) - _mum_primes[i] = _mum_next_factor (); +mum_hash_randomize(uint64_t seed) +{ + int i; + + srand(seed); + _mum_hash_step_prime = _mum_next_factor(); + _mum_key_step_prime = _mum_next_factor(); + _mum_finish_prime1 = _mum_next_factor(); + _mum_finish_prime2 = _mum_next_factor(); + _mum_block_start_prime = _mum_next_factor(); + _mum_unroll_prime = _mum_next_factor(); + _mum_tail_prime = _mum_next_factor(); + for (i = 0; i < (int) (sizeof(_mum_primes) / sizeof(uint64_t)); i++) + _mum_primes[i] = _mum_next_factor(); } /* Start hashing data with SEED. Return the state. */ static inline uint64_t -mum_hash_init (uint64_t seed) { - return seed; +mum_hash_init(uint64_t seed) +{ + return seed; } /* Process data KEY with the state H and return the updated state. */ static inline uint64_t -mum_hash_step (uint64_t h, uint64_t key) +mum_hash_step(uint64_t h, uint64_t key) { - return _mum (h, _mum_hash_step_prime) ^ _mum (key, _mum_key_step_prime); + return _mum(h, _mum_hash_step_prime) ^ _mum(key, _mum_key_step_prime); } /* Return the result of hashing using the current state H. */ static inline uint64_t -mum_hash_finish (uint64_t h) { - return _mum_final (h); +mum_hash_finish(uint64_t h) +{ + return _mum_final(h); } /* Fast hashing of KEY with SEED. The hash is always the same for the same key on any target. */ static inline size_t -mum_hash64 (uint64_t key, uint64_t seed) { - return mum_hash_finish (mum_hash_step (mum_hash_init (seed), key)); +mum_hash64(uint64_t key, uint64_t seed) +{ + return mum_hash_finish(mum_hash_step(mum_hash_init(seed), key)); } /* Hash data KEY of length LEN and SEED. The hash depends on the target endianness and the unroll factor. */ static inline uint64_t -mum_hash (const void *key, size_t len, uint64_t seed) { +mum_hash(const void *key, size_t len, uint64_t seed) +{ #if defined(__x86_64__) && defined(_MUM_FRESH_GCC) - static int avx2_support = 0; - - if (avx2_support > 0) - return _mum_hash_avx2 (key, len, seed); - else if (! avx2_support) { - __builtin_cpu_init (); - avx2_support = __builtin_cpu_supports ("avx2") ? 1 : -1; - if (avx2_support > 0) - return _mum_hash_avx2 (key, len, seed); - } + static int avx2_support = 0; + + if (avx2_support > 0) + return _mum_hash_avx2(key, len, seed); + else if (!avx2_support) { + __builtin_cpu_init(); + avx2_support = __builtin_cpu_supports("avx2") ? 1 : -1; + if (avx2_support > 0) + return _mum_hash_avx2(key, len, seed); + } #endif - return _mum_hash_default (key, len, seed); + return _mum_hash_default(key, len, seed); } #endif diff --git a/src/tree.h b/src/tree.h index 404b4a867be9..bb5fe46ff6a9 100644 --- a/src/tree.h +++ b/src/tree.h @@ -43,177 +43,167 @@ #define __tree_h -#define TREE_DELTA_MAX 1 +#define TREE_DELTA_MAX 1 #ifndef _HU_FUNCTION -# if defined(__GNUC__) || defined(__clang__) -# define _HU_FUNCTION(x) __attribute__((__unused__)) x -# else -# define _HU_FUNCTION(x) x -# endif +#if defined(__GNUC__) || defined(__clang__) +#define _HU_FUNCTION(x) __attribute__((__unused__)) x +#else +#define _HU_FUNCTION(x) x +#endif #endif -#define TREE_ENTRY(type) \ - struct { \ - struct type *avl_left; \ - struct type *avl_right; \ - int avl_height; \ - } +#define TREE_ENTRY(type) \ + struct { \ + struct type *avl_left; \ + struct type *avl_right; \ + int avl_height; \ + } -#define TREE_HEAD(name, type) \ - struct name { \ - struct type *th_root; \ - int (*th_cmp)(struct type *lhs, struct type *rhs); \ - } +#define TREE_HEAD(name, type) \ + struct name { \ + struct type *th_root; \ + int (*th_cmp)(struct type * lhs, struct type *rhs); \ + } -#define TREE_INITIALIZER(cmp) { 0, cmp } +#define TREE_INITIALIZER(cmp) {0, cmp} -#define TREE_DELTA(self, field) \ - (( (((self)->field.avl_left) ? (self)->field.avl_left->field.avl_height : 0)) \ - - (((self)->field.avl_right) ? (self)->field.avl_right->field.avl_height : 0)) +#define TREE_DELTA(self, field) \ + (((((self)->field.avl_left) ? (self)->field.avl_left->field.avl_height : 0)) - (((self)->field.avl_right) ? (self)->field.avl_right->field.avl_height : 0)) /* Recursion prevents the following from being defined as macros. */ -#define TREE_DEFINE(node, field) \ - \ - static struct node *_HU_FUNCTION(TREE_BALANCE_##node##_##field)(struct node *); \ - \ - static struct node *_HU_FUNCTION(TREE_ROTL_##node##_##field)(struct node *self) \ - { \ - struct node *r= self->field.avl_right; \ - self->field.avl_right= r->field.avl_left; \ - r->field.avl_left= TREE_BALANCE_##node##_##field(self); \ - return TREE_BALANCE_##node##_##field(r); \ - } \ - \ - static struct node *_HU_FUNCTION(TREE_ROTR_##node##_##field)(struct node *self) \ - { \ - struct node *l= self->field.avl_left; \ - self->field.avl_left= l->field.avl_right; \ - l->field.avl_right= TREE_BALANCE_##node##_##field(self); \ - return TREE_BALANCE_##node##_##field(l); \ - } \ - \ - static struct node *_HU_FUNCTION(TREE_BALANCE_##node##_##field)(struct node *self) \ - { \ - int delta= TREE_DELTA(self, field); \ - \ - if (delta < -TREE_DELTA_MAX) \ - { \ - if (TREE_DELTA(self->field.avl_right, field) > 0) \ - self->field.avl_right= TREE_ROTR_##node##_##field(self->field.avl_right); \ - return TREE_ROTL_##node##_##field(self); \ - } \ - else if (delta > TREE_DELTA_MAX) \ - { \ - if (TREE_DELTA(self->field.avl_left, field) < 0) \ - self->field.avl_left= TREE_ROTL_##node##_##field(self->field.avl_left); \ - return TREE_ROTR_##node##_##field(self); \ - } \ - self->field.avl_height= 0; \ - if (self->field.avl_left && (self->field.avl_left->field.avl_height > self->field.avl_height)) \ - self->field.avl_height= self->field.avl_left->field.avl_height; \ - if (self->field.avl_right && (self->field.avl_right->field.avl_height > self->field.avl_height)) \ - self->field.avl_height= self->field.avl_right->field.avl_height; \ - self->field.avl_height += 1; \ - return self; \ - } \ - \ - static struct node *_HU_FUNCTION(TREE_INSERT_##node##_##field) \ - (struct node *self, struct node *elm, int (*compare)(struct node *lhs, struct node *rhs)) \ - { \ - if (!self) \ - return elm; \ - if (compare(elm, self) < 0) \ - self->field.avl_left= TREE_INSERT_##node##_##field(self->field.avl_left, elm, compare); \ - else \ - self->field.avl_right= TREE_INSERT_##node##_##field(self->field.avl_right, elm, compare); \ - return TREE_BALANCE_##node##_##field(self); \ - } \ - \ - static struct node *_HU_FUNCTION(TREE_FIND_##node##_##field) \ - (struct node *self, struct node *elm, int (*compare)(struct node *lhs, struct node *rhs)) \ - { \ - if (!self) \ - return 0; \ - if (compare(elm, self) == 0) \ - return self; \ - if (compare(elm, self) < 0) \ - return TREE_FIND_##node##_##field(self->field.avl_left, elm, compare); \ - else \ - return TREE_FIND_##node##_##field(self->field.avl_right, elm, compare); \ - } \ - \ - static struct node *_HU_FUNCTION(TREE_MOVE_RIGHT)(struct node *self, struct node *rhs) \ - { \ - if (!self) \ - return rhs; \ - self->field.avl_right= TREE_MOVE_RIGHT(self->field.avl_right, rhs); \ - return TREE_BALANCE_##node##_##field(self); \ - } \ - \ - static struct node *_HU_FUNCTION(TREE_REMOVE_##node##_##field) \ - (struct node *self, struct node *elm, int (*compare)(struct node *lhs, struct node *rhs)) \ - { \ - if (!self) return 0; \ - \ - if (compare(elm, self) == 0) \ - { \ - struct node *tmp= TREE_MOVE_RIGHT(self->field.avl_left, self->field.avl_right); \ - self->field.avl_left= 0; \ - self->field.avl_right= 0; \ - return tmp; \ - } \ - if (compare(elm, self) < 0) \ - self->field.avl_left= TREE_REMOVE_##node##_##field(self->field.avl_left, elm, compare); \ - else \ - self->field.avl_right= TREE_REMOVE_##node##_##field(self->field.avl_right, elm, compare); \ - return TREE_BALANCE_##node##_##field(self); \ - } \ - \ - static void _HU_FUNCTION(TREE_FORWARD_APPLY_ALL_##node##_##field) \ - (struct node *self, void (*function)(struct node *node, void *data), void *data) \ - { \ - if (self) \ - { \ - TREE_FORWARD_APPLY_ALL_##node##_##field(self->field.avl_left, function, data); \ - function(self, data); \ - TREE_FORWARD_APPLY_ALL_##node##_##field(self->field.avl_right, function, data); \ - } \ - } \ - \ - static void _HU_FUNCTION(TREE_REVERSE_APPLY_ALL_##node##_##field) \ - (struct node *self, void (*function)(struct node *node, void *data), void *data) \ - { \ - if (self) \ - { \ - TREE_REVERSE_APPLY_ALL_##node##_##field(self->field.avl_right, function, data); \ - function(self, data); \ - TREE_REVERSE_APPLY_ALL_##node##_##field(self->field.avl_left, function, data); \ - } \ - } - -#define TREE_INSERT(head, node, field, elm) \ - ((head)->th_root= TREE_INSERT_##node##_##field((head)->th_root, (elm), (head)->th_cmp)) - -#define TREE_FIND(head, node, field, elm) \ - (TREE_FIND_##node##_##field((head)->th_root, (elm), (head)->th_cmp)) - -#define TREE_REMOVE(head, node, field, elm) \ - ((head)->th_root= TREE_REMOVE_##node##_##field((head)->th_root, (elm), (head)->th_cmp)) - -#define TREE_DEPTH(head, field) \ - ((head)->th_root->field.avl_height) - -#define TREE_FORWARD_APPLY(head, node, field, function, data) \ - TREE_FORWARD_APPLY_ALL_##node##_##field((head)->th_root, function, data) - -#define TREE_REVERSE_APPLY(head, node, field, function, data) \ - TREE_REVERSE_APPLY_ALL_##node##_##field((head)->th_root, function, data) - -#define TREE_INIT(head, cmp) do { \ - (head)->th_root= 0; \ - (head)->th_cmp= (cmp); \ - } while (0) +#define TREE_DEFINE(node, field) \ + \ + static struct node *_HU_FUNCTION(TREE_BALANCE_##node##_##field)(struct node *); \ + \ + static struct node *_HU_FUNCTION(TREE_ROTL_##node##_##field)(struct node * self) \ + { \ + struct node *r = self->field.avl_right; \ + self->field.avl_right = r->field.avl_left; \ + r->field.avl_left = TREE_BALANCE_##node##_##field(self); \ + return TREE_BALANCE_##node##_##field(r); \ + } \ + \ + static struct node *_HU_FUNCTION(TREE_ROTR_##node##_##field)(struct node * self) \ + { \ + struct node *l = self->field.avl_left; \ + self->field.avl_left = l->field.avl_right; \ + l->field.avl_right = TREE_BALANCE_##node##_##field(self); \ + return TREE_BALANCE_##node##_##field(l); \ + } \ + \ + static struct node *_HU_FUNCTION(TREE_BALANCE_##node##_##field)(struct node * self) \ + { \ + int delta = TREE_DELTA(self, field); \ + \ + if (delta < -TREE_DELTA_MAX) { \ + if (TREE_DELTA(self->field.avl_right, field) > 0) \ + self->field.avl_right = TREE_ROTR_##node##_##field(self->field.avl_right); \ + return TREE_ROTL_##node##_##field(self); \ + } \ + else if (delta > TREE_DELTA_MAX) { \ + if (TREE_DELTA(self->field.avl_left, field) < 0) \ + self->field.avl_left = TREE_ROTL_##node##_##field(self->field.avl_left); \ + return TREE_ROTR_##node##_##field(self); \ + } \ + self->field.avl_height = 0; \ + if (self->field.avl_left && (self->field.avl_left->field.avl_height > self->field.avl_height)) \ + self->field.avl_height = self->field.avl_left->field.avl_height; \ + if (self->field.avl_right && (self->field.avl_right->field.avl_height > self->field.avl_height)) \ + self->field.avl_height = self->field.avl_right->field.avl_height; \ + self->field.avl_height += 1; \ + return self; \ + } \ + \ + static struct node *_HU_FUNCTION(TREE_INSERT_##node##_##field)(struct node * self, struct node * elm, int (*compare)(struct node * lhs, struct node * rhs)) \ + { \ + if (!self) \ + return elm; \ + if (compare(elm, self) < 0) \ + self->field.avl_left = TREE_INSERT_##node##_##field(self->field.avl_left, elm, compare); \ + else \ + self->field.avl_right = TREE_INSERT_##node##_##field(self->field.avl_right, elm, compare); \ + return TREE_BALANCE_##node##_##field(self); \ + } \ + \ + static struct node *_HU_FUNCTION(TREE_FIND_##node##_##field)(struct node * self, struct node * elm, int (*compare)(struct node * lhs, struct node * rhs)) \ + { \ + if (!self) \ + return 0; \ + if (compare(elm, self) == 0) \ + return self; \ + if (compare(elm, self) < 0) \ + return TREE_FIND_##node##_##field(self->field.avl_left, elm, compare); \ + else \ + return TREE_FIND_##node##_##field(self->field.avl_right, elm, compare); \ + } \ + \ + static struct node *_HU_FUNCTION(TREE_MOVE_RIGHT)(struct node * self, struct node * rhs) \ + { \ + if (!self) \ + return rhs; \ + self->field.avl_right = TREE_MOVE_RIGHT(self->field.avl_right, rhs); \ + return TREE_BALANCE_##node##_##field(self); \ + } \ + \ + static struct node *_HU_FUNCTION(TREE_REMOVE_##node##_##field)(struct node * self, struct node * elm, int (*compare)(struct node * lhs, struct node * rhs)) \ + { \ + if (!self) return 0; \ + \ + if (compare(elm, self) == 0) { \ + struct node *tmp = TREE_MOVE_RIGHT(self->field.avl_left, self->field.avl_right); \ + self->field.avl_left = 0; \ + self->field.avl_right = 0; \ + return tmp; \ + } \ + if (compare(elm, self) < 0) \ + self->field.avl_left = TREE_REMOVE_##node##_##field(self->field.avl_left, elm, compare); \ + else \ + self->field.avl_right = TREE_REMOVE_##node##_##field(self->field.avl_right, elm, compare); \ + return TREE_BALANCE_##node##_##field(self); \ + } \ + \ + static void _HU_FUNCTION(TREE_FORWARD_APPLY_ALL_##node##_##field)(struct node * self, void (*function)(struct node * node, void *data), void *data) \ + { \ + if (self) { \ + TREE_FORWARD_APPLY_ALL_##node##_##field(self->field.avl_left, function, data); \ + function(self, data); \ + TREE_FORWARD_APPLY_ALL_##node##_##field(self->field.avl_right, function, data); \ + } \ + } \ + \ + static void _HU_FUNCTION(TREE_REVERSE_APPLY_ALL_##node##_##field)(struct node * self, void (*function)(struct node * node, void *data), void *data) \ + { \ + if (self) { \ + TREE_REVERSE_APPLY_ALL_##node##_##field(self->field.avl_right, function, data); \ + function(self, data); \ + TREE_REVERSE_APPLY_ALL_##node##_##field(self->field.avl_left, function, data); \ + } \ + } + +#define TREE_INSERT(head, node, field, elm) \ + ((head)->th_root = TREE_INSERT_##node##_##field((head)->th_root, (elm), (head)->th_cmp)) + +#define TREE_FIND(head, node, field, elm) \ + (TREE_FIND_##node##_##field((head)->th_root, (elm), (head)->th_cmp)) + +#define TREE_REMOVE(head, node, field, elm) \ + ((head)->th_root = TREE_REMOVE_##node##_##field((head)->th_root, (elm), (head)->th_cmp)) + +#define TREE_DEPTH(head, field) \ + ((head)->th_root->field.avl_height) + +#define TREE_FORWARD_APPLY(head, node, field, function, data) \ + TREE_FORWARD_APPLY_ALL_##node##_##field((head)->th_root, function, data) + +#define TREE_REVERSE_APPLY(head, node, field, function, data) \ + TREE_REVERSE_APPLY_ALL_##node##_##field((head)->th_root, function, data) + +#define TREE_INIT(head, cmp) \ + do { \ + (head)->th_root = 0; \ + (head)->th_cmp = (cmp); \ + } while (0) #endif /* __tree_h */ diff --git a/src/ucl_chartable.h b/src/ucl_chartable.h index 7571a1d91549..aa896ea5f0a3 100644 --- a/src/ucl_chartable.h +++ b/src/ucl_chartable.h @@ -27,240 +27,239 @@ #include "ucl_internal.h" static const unsigned int ucl_chartable[256] = { -UCL_CHARACTER_JSON_UNSAFE|UCL_CHARACTER_VALUE_END|UCL_CHARACTER_UCL_UNSAFE, UCL_CHARACTER_DENIED, UCL_CHARACTER_DENIED, -UCL_CHARACTER_DENIED, UCL_CHARACTER_DENIED, UCL_CHARACTER_DENIED, -UCL_CHARACTER_DENIED, UCL_CHARACTER_DENIED, -UCL_CHARACTER_JSON_UNSAFE|UCL_CHARACTER_UCL_UNSAFE, -UCL_CHARACTER_WHITESPACE|UCL_CHARACTER_WHITESPACE_UNSAFE|UCL_CHARACTER_KEY_SEP|UCL_CHARACTER_JSON_UNSAFE|UCL_CHARACTER_UCL_UNSAFE, -UCL_CHARACTER_WHITESPACE_UNSAFE|UCL_CHARACTER_VALUE_END|UCL_CHARACTER_JSON_UNSAFE|UCL_CHARACTER_UCL_UNSAFE, -UCL_CHARACTER_WHITESPACE_UNSAFE, -UCL_CHARACTER_WHITESPACE_UNSAFE|UCL_CHARACTER_JSON_UNSAFE|UCL_CHARACTER_UCL_UNSAFE, -UCL_CHARACTER_WHITESPACE_UNSAFE|UCL_CHARACTER_VALUE_END|UCL_CHARACTER_JSON_UNSAFE|UCL_CHARACTER_UCL_UNSAFE, -UCL_CHARACTER_DENIED, UCL_CHARACTER_DENIED, UCL_CHARACTER_DENIED, -UCL_CHARACTER_DENIED, UCL_CHARACTER_DENIED, UCL_CHARACTER_DENIED, -UCL_CHARACTER_DENIED, UCL_CHARACTER_DENIED, UCL_CHARACTER_DENIED, -UCL_CHARACTER_DENIED, UCL_CHARACTER_DENIED, UCL_CHARACTER_DENIED, -UCL_CHARACTER_DENIED, UCL_CHARACTER_DENIED, UCL_CHARACTER_DENIED, -UCL_CHARACTER_DENIED, UCL_CHARACTER_DENIED, UCL_CHARACTER_DENIED, -UCL_CHARACTER_WHITESPACE|UCL_CHARACTER_WHITESPACE_UNSAFE|UCL_CHARACTER_VALUE_STR|UCL_CHARACTER_KEY_SEP|UCL_CHARACTER_UCL_UNSAFE /* */, -UCL_CHARACTER_VALUE_STR /* ! */, -UCL_CHARACTER_VALUE_STR|UCL_CHARACTER_ESCAPE|UCL_CHARACTER_JSON_UNSAFE|UCL_CHARACTER_UCL_UNSAFE /* " */, -UCL_CHARACTER_VALUE_END /* # */, UCL_CHARACTER_VALUE_STR /* $ */, -UCL_CHARACTER_VALUE_STR /* % */, UCL_CHARACTER_VALUE_STR /* & */, -UCL_CHARACTER_VALUE_STR /* ' */, UCL_CHARACTER_VALUE_STR /* ( */, -UCL_CHARACTER_VALUE_STR /* ) */, UCL_CHARACTER_VALUE_STR /* * */, -UCL_CHARACTER_VALUE_STR|UCL_CHARACTER_VALUE_DIGIT|UCL_CHARACTER_UCL_UNSAFE /* + */, -UCL_CHARACTER_VALUE_END /* , */, -UCL_CHARACTER_KEY|UCL_CHARACTER_VALUE_STR|UCL_CHARACTER_VALUE_DIGIT_START|UCL_CHARACTER_VALUE_DIGIT /* - */, -UCL_CHARACTER_KEY|UCL_CHARACTER_VALUE_STR|UCL_CHARACTER_VALUE_DIGIT /* . */, -UCL_CHARACTER_KEY_START|UCL_CHARACTER_KEY|UCL_CHARACTER_VALUE_STR|UCL_CHARACTER_ESCAPE /* / */, -UCL_CHARACTER_KEY_START|UCL_CHARACTER_KEY|UCL_CHARACTER_VALUE_STR|UCL_CHARACTER_VALUE_DIGIT_START|UCL_CHARACTER_VALUE_DIGIT /* 0 */, -UCL_CHARACTER_KEY_START|UCL_CHARACTER_KEY|UCL_CHARACTER_VALUE_STR|UCL_CHARACTER_VALUE_DIGIT_START|UCL_CHARACTER_VALUE_DIGIT /* 1 */, -UCL_CHARACTER_KEY_START|UCL_CHARACTER_KEY|UCL_CHARACTER_VALUE_STR|UCL_CHARACTER_VALUE_DIGIT_START|UCL_CHARACTER_VALUE_DIGIT /* 2 */, -UCL_CHARACTER_KEY_START|UCL_CHARACTER_KEY|UCL_CHARACTER_VALUE_STR|UCL_CHARACTER_VALUE_DIGIT_START|UCL_CHARACTER_VALUE_DIGIT /* 3 */, -UCL_CHARACTER_KEY_START|UCL_CHARACTER_KEY|UCL_CHARACTER_VALUE_STR|UCL_CHARACTER_VALUE_DIGIT_START|UCL_CHARACTER_VALUE_DIGIT /* 4 */, -UCL_CHARACTER_KEY_START|UCL_CHARACTER_KEY|UCL_CHARACTER_VALUE_STR|UCL_CHARACTER_VALUE_DIGIT_START|UCL_CHARACTER_VALUE_DIGIT /* 5 */, -UCL_CHARACTER_KEY_START|UCL_CHARACTER_KEY|UCL_CHARACTER_VALUE_STR|UCL_CHARACTER_VALUE_DIGIT_START|UCL_CHARACTER_VALUE_DIGIT /* 6 */, -UCL_CHARACTER_KEY_START|UCL_CHARACTER_KEY|UCL_CHARACTER_VALUE_STR|UCL_CHARACTER_VALUE_DIGIT_START|UCL_CHARACTER_VALUE_DIGIT /* 7 */, -UCL_CHARACTER_KEY_START|UCL_CHARACTER_KEY|UCL_CHARACTER_VALUE_STR|UCL_CHARACTER_VALUE_DIGIT_START|UCL_CHARACTER_VALUE_DIGIT /* 8 */, -UCL_CHARACTER_KEY_START|UCL_CHARACTER_KEY|UCL_CHARACTER_VALUE_STR|UCL_CHARACTER_VALUE_DIGIT_START|UCL_CHARACTER_VALUE_DIGIT /* 9 */, -UCL_CHARACTER_VALUE_STR|UCL_CHARACTER_KEY_SEP|UCL_CHARACTER_UCL_UNSAFE /* : */, -UCL_CHARACTER_VALUE_END /* ; */, UCL_CHARACTER_VALUE_STR /* < */, -UCL_CHARACTER_VALUE_STR|UCL_CHARACTER_KEY_SEP|UCL_CHARACTER_UCL_UNSAFE /* = */, -UCL_CHARACTER_VALUE_STR /* > */, UCL_CHARACTER_VALUE_STR /* ? */, -UCL_CHARACTER_VALUE_STR /* @ */, -UCL_CHARACTER_KEY_START|UCL_CHARACTER_KEY|UCL_CHARACTER_VALUE_STR|UCL_CHARACTER_VALUE_DIGIT /* A */, -UCL_CHARACTER_KEY_START|UCL_CHARACTER_KEY|UCL_CHARACTER_VALUE_STR|UCL_CHARACTER_VALUE_DIGIT /* B */, -UCL_CHARACTER_KEY_START|UCL_CHARACTER_KEY|UCL_CHARACTER_VALUE_STR|UCL_CHARACTER_VALUE_DIGIT /* C */, -UCL_CHARACTER_KEY_START|UCL_CHARACTER_KEY|UCL_CHARACTER_VALUE_STR|UCL_CHARACTER_VALUE_DIGIT /* D */, -UCL_CHARACTER_KEY_START|UCL_CHARACTER_KEY|UCL_CHARACTER_VALUE_STR|UCL_CHARACTER_VALUE_DIGIT /* E */, -UCL_CHARACTER_KEY_START|UCL_CHARACTER_KEY|UCL_CHARACTER_VALUE_STR|UCL_CHARACTER_VALUE_DIGIT /* F */, -UCL_CHARACTER_KEY_START|UCL_CHARACTER_KEY|UCL_CHARACTER_VALUE_STR|UCL_CHARACTER_VALUE_DIGIT /* G */, -UCL_CHARACTER_KEY_START|UCL_CHARACTER_KEY|UCL_CHARACTER_VALUE_STR|UCL_CHARACTER_VALUE_DIGIT /* H */, -UCL_CHARACTER_KEY_START|UCL_CHARACTER_KEY|UCL_CHARACTER_VALUE_STR|UCL_CHARACTER_VALUE_DIGIT /* I */, -UCL_CHARACTER_KEY_START|UCL_CHARACTER_KEY|UCL_CHARACTER_VALUE_STR|UCL_CHARACTER_VALUE_DIGIT /* J */, -UCL_CHARACTER_KEY_START|UCL_CHARACTER_KEY|UCL_CHARACTER_VALUE_STR|UCL_CHARACTER_VALUE_DIGIT /* K */, -UCL_CHARACTER_KEY_START|UCL_CHARACTER_KEY|UCL_CHARACTER_VALUE_STR|UCL_CHARACTER_VALUE_DIGIT /* L */, -UCL_CHARACTER_KEY_START|UCL_CHARACTER_KEY|UCL_CHARACTER_VALUE_STR|UCL_CHARACTER_VALUE_DIGIT /* M */, -UCL_CHARACTER_KEY_START|UCL_CHARACTER_KEY|UCL_CHARACTER_VALUE_STR|UCL_CHARACTER_VALUE_DIGIT /* N */, -UCL_CHARACTER_KEY_START|UCL_CHARACTER_KEY|UCL_CHARACTER_VALUE_STR|UCL_CHARACTER_VALUE_DIGIT /* O */, -UCL_CHARACTER_KEY_START|UCL_CHARACTER_KEY|UCL_CHARACTER_VALUE_STR|UCL_CHARACTER_VALUE_DIGIT /* P */, -UCL_CHARACTER_KEY_START|UCL_CHARACTER_KEY|UCL_CHARACTER_VALUE_STR|UCL_CHARACTER_VALUE_DIGIT /* Q */, -UCL_CHARACTER_KEY_START|UCL_CHARACTER_KEY|UCL_CHARACTER_VALUE_STR|UCL_CHARACTER_VALUE_DIGIT /* R */, -UCL_CHARACTER_KEY_START|UCL_CHARACTER_KEY|UCL_CHARACTER_VALUE_STR|UCL_CHARACTER_VALUE_DIGIT /* S */, -UCL_CHARACTER_KEY_START|UCL_CHARACTER_KEY|UCL_CHARACTER_VALUE_STR|UCL_CHARACTER_VALUE_DIGIT /* T */, -UCL_CHARACTER_KEY_START|UCL_CHARACTER_KEY|UCL_CHARACTER_VALUE_STR|UCL_CHARACTER_VALUE_DIGIT /* U */, -UCL_CHARACTER_KEY_START|UCL_CHARACTER_KEY|UCL_CHARACTER_VALUE_STR|UCL_CHARACTER_VALUE_DIGIT /* V */, -UCL_CHARACTER_KEY_START|UCL_CHARACTER_KEY|UCL_CHARACTER_VALUE_STR|UCL_CHARACTER_VALUE_DIGIT /* W */, -UCL_CHARACTER_KEY_START|UCL_CHARACTER_KEY|UCL_CHARACTER_VALUE_STR|UCL_CHARACTER_VALUE_DIGIT /* X */, -UCL_CHARACTER_KEY_START|UCL_CHARACTER_KEY|UCL_CHARACTER_VALUE_STR|UCL_CHARACTER_VALUE_DIGIT /* Y */, -UCL_CHARACTER_KEY_START|UCL_CHARACTER_KEY|UCL_CHARACTER_VALUE_STR|UCL_CHARACTER_VALUE_DIGIT /* Z */, -UCL_CHARACTER_VALUE_STR|UCL_CHARACTER_UCL_UNSAFE /* [ */, -UCL_CHARACTER_VALUE_STR|UCL_CHARACTER_ESCAPE|UCL_CHARACTER_JSON_UNSAFE|UCL_CHARACTER_UCL_UNSAFE /* \ */, -UCL_CHARACTER_VALUE_END /* ] */, UCL_CHARACTER_VALUE_STR /* ^ */, -UCL_CHARACTER_KEY_START|UCL_CHARACTER_KEY|UCL_CHARACTER_VALUE_STR /* _ */, -UCL_CHARACTER_VALUE_STR /* ` */, -UCL_CHARACTER_KEY_START|UCL_CHARACTER_KEY|UCL_CHARACTER_VALUE_STR|UCL_CHARACTER_VALUE_DIGIT /* a */, -UCL_CHARACTER_KEY_START|UCL_CHARACTER_KEY|UCL_CHARACTER_VALUE_STR|UCL_CHARACTER_VALUE_DIGIT|UCL_CHARACTER_ESCAPE /* b */, -UCL_CHARACTER_KEY_START|UCL_CHARACTER_KEY|UCL_CHARACTER_VALUE_STR|UCL_CHARACTER_VALUE_DIGIT /* c */, -UCL_CHARACTER_KEY_START|UCL_CHARACTER_KEY|UCL_CHARACTER_VALUE_STR|UCL_CHARACTER_VALUE_DIGIT /* d */, -UCL_CHARACTER_KEY_START|UCL_CHARACTER_KEY|UCL_CHARACTER_VALUE_STR|UCL_CHARACTER_VALUE_DIGIT /* e */, -UCL_CHARACTER_KEY_START|UCL_CHARACTER_KEY|UCL_CHARACTER_VALUE_STR|UCL_CHARACTER_VALUE_DIGIT|UCL_CHARACTER_ESCAPE /* f */, -UCL_CHARACTER_KEY_START|UCL_CHARACTER_KEY|UCL_CHARACTER_VALUE_STR|UCL_CHARACTER_VALUE_DIGIT /* g */, -UCL_CHARACTER_KEY_START|UCL_CHARACTER_KEY|UCL_CHARACTER_VALUE_STR|UCL_CHARACTER_VALUE_DIGIT /* h */, -UCL_CHARACTER_KEY_START|UCL_CHARACTER_KEY|UCL_CHARACTER_VALUE_STR|UCL_CHARACTER_VALUE_DIGIT /* i */, -UCL_CHARACTER_KEY_START|UCL_CHARACTER_KEY|UCL_CHARACTER_VALUE_STR|UCL_CHARACTER_VALUE_DIGIT /* j */, -UCL_CHARACTER_KEY_START|UCL_CHARACTER_KEY|UCL_CHARACTER_VALUE_STR|UCL_CHARACTER_VALUE_DIGIT /* k */, -UCL_CHARACTER_KEY_START|UCL_CHARACTER_KEY|UCL_CHARACTER_VALUE_STR|UCL_CHARACTER_VALUE_DIGIT /* l */, -UCL_CHARACTER_KEY_START|UCL_CHARACTER_KEY|UCL_CHARACTER_VALUE_STR|UCL_CHARACTER_VALUE_DIGIT /* m */, -UCL_CHARACTER_KEY_START|UCL_CHARACTER_KEY|UCL_CHARACTER_VALUE_STR|UCL_CHARACTER_VALUE_DIGIT|UCL_CHARACTER_ESCAPE /* n */, -UCL_CHARACTER_KEY_START|UCL_CHARACTER_KEY|UCL_CHARACTER_VALUE_STR|UCL_CHARACTER_VALUE_DIGIT /* o */, -UCL_CHARACTER_KEY_START|UCL_CHARACTER_KEY|UCL_CHARACTER_VALUE_STR|UCL_CHARACTER_VALUE_DIGIT /* p */, -UCL_CHARACTER_KEY_START|UCL_CHARACTER_KEY|UCL_CHARACTER_VALUE_STR|UCL_CHARACTER_VALUE_DIGIT /* q */, -UCL_CHARACTER_KEY_START|UCL_CHARACTER_KEY|UCL_CHARACTER_VALUE_STR|UCL_CHARACTER_VALUE_DIGIT|UCL_CHARACTER_ESCAPE /* r */, -UCL_CHARACTER_KEY_START|UCL_CHARACTER_KEY|UCL_CHARACTER_VALUE_STR|UCL_CHARACTER_VALUE_DIGIT /* s */, -UCL_CHARACTER_KEY_START|UCL_CHARACTER_KEY|UCL_CHARACTER_VALUE_STR|UCL_CHARACTER_VALUE_DIGIT|UCL_CHARACTER_ESCAPE /* t */, -UCL_CHARACTER_KEY_START|UCL_CHARACTER_KEY|UCL_CHARACTER_VALUE_STR|UCL_CHARACTER_VALUE_DIGIT|UCL_CHARACTER_ESCAPE /* u */, -UCL_CHARACTER_KEY_START|UCL_CHARACTER_KEY|UCL_CHARACTER_VALUE_STR|UCL_CHARACTER_VALUE_DIGIT /* v */, -UCL_CHARACTER_KEY_START|UCL_CHARACTER_KEY|UCL_CHARACTER_VALUE_STR|UCL_CHARACTER_VALUE_DIGIT /* w */, -UCL_CHARACTER_KEY_START|UCL_CHARACTER_KEY|UCL_CHARACTER_VALUE_STR|UCL_CHARACTER_VALUE_DIGIT /* x */, -UCL_CHARACTER_KEY_START|UCL_CHARACTER_KEY|UCL_CHARACTER_VALUE_STR|UCL_CHARACTER_VALUE_DIGIT /* y */, -UCL_CHARACTER_KEY_START|UCL_CHARACTER_KEY|UCL_CHARACTER_VALUE_STR|UCL_CHARACTER_VALUE_DIGIT /* z */, -UCL_CHARACTER_VALUE_STR|UCL_CHARACTER_UCL_UNSAFE /* { */, -UCL_CHARACTER_VALUE_STR /* | */, UCL_CHARACTER_VALUE_END /* } */, -UCL_CHARACTER_VALUE_STR /* ~ */, UCL_CHARACTER_DENIED, -UCL_CHARACTER_KEY_START|UCL_CHARACTER_KEY|UCL_CHARACTER_VALUE_STR, -UCL_CHARACTER_KEY_START|UCL_CHARACTER_KEY|UCL_CHARACTER_VALUE_STR, -UCL_CHARACTER_KEY_START|UCL_CHARACTER_KEY|UCL_CHARACTER_VALUE_STR, -UCL_CHARACTER_KEY_START|UCL_CHARACTER_KEY|UCL_CHARACTER_VALUE_STR, -UCL_CHARACTER_KEY_START|UCL_CHARACTER_KEY|UCL_CHARACTER_VALUE_STR, -UCL_CHARACTER_KEY_START|UCL_CHARACTER_KEY|UCL_CHARACTER_VALUE_STR, -UCL_CHARACTER_KEY_START|UCL_CHARACTER_KEY|UCL_CHARACTER_VALUE_STR, -UCL_CHARACTER_KEY_START|UCL_CHARACTER_KEY|UCL_CHARACTER_VALUE_STR, -UCL_CHARACTER_KEY_START|UCL_CHARACTER_KEY|UCL_CHARACTER_VALUE_STR, -UCL_CHARACTER_KEY_START|UCL_CHARACTER_KEY|UCL_CHARACTER_VALUE_STR, -UCL_CHARACTER_KEY_START|UCL_CHARACTER_KEY|UCL_CHARACTER_VALUE_STR, -UCL_CHARACTER_KEY_START|UCL_CHARACTER_KEY|UCL_CHARACTER_VALUE_STR, -UCL_CHARACTER_KEY_START|UCL_CHARACTER_KEY|UCL_CHARACTER_VALUE_STR, -UCL_CHARACTER_KEY_START|UCL_CHARACTER_KEY|UCL_CHARACTER_VALUE_STR, -UCL_CHARACTER_KEY_START|UCL_CHARACTER_KEY|UCL_CHARACTER_VALUE_STR, -UCL_CHARACTER_KEY_START|UCL_CHARACTER_KEY|UCL_CHARACTER_VALUE_STR, -UCL_CHARACTER_KEY_START|UCL_CHARACTER_KEY|UCL_CHARACTER_VALUE_STR, -UCL_CHARACTER_KEY_START|UCL_CHARACTER_KEY|UCL_CHARACTER_VALUE_STR, -UCL_CHARACTER_KEY_START|UCL_CHARACTER_KEY|UCL_CHARACTER_VALUE_STR, -UCL_CHARACTER_KEY_START|UCL_CHARACTER_KEY|UCL_CHARACTER_VALUE_STR, -UCL_CHARACTER_KEY_START|UCL_CHARACTER_KEY|UCL_CHARACTER_VALUE_STR, -UCL_CHARACTER_KEY_START|UCL_CHARACTER_KEY|UCL_CHARACTER_VALUE_STR, -UCL_CHARACTER_KEY_START|UCL_CHARACTER_KEY|UCL_CHARACTER_VALUE_STR, -UCL_CHARACTER_KEY_START|UCL_CHARACTER_KEY|UCL_CHARACTER_VALUE_STR, -UCL_CHARACTER_KEY_START|UCL_CHARACTER_KEY|UCL_CHARACTER_VALUE_STR, -UCL_CHARACTER_KEY_START|UCL_CHARACTER_KEY|UCL_CHARACTER_VALUE_STR, -UCL_CHARACTER_KEY_START|UCL_CHARACTER_KEY|UCL_CHARACTER_VALUE_STR, -UCL_CHARACTER_KEY_START|UCL_CHARACTER_KEY|UCL_CHARACTER_VALUE_STR, -UCL_CHARACTER_KEY_START|UCL_CHARACTER_KEY|UCL_CHARACTER_VALUE_STR, -UCL_CHARACTER_KEY_START|UCL_CHARACTER_KEY|UCL_CHARACTER_VALUE_STR, -UCL_CHARACTER_KEY_START|UCL_CHARACTER_KEY|UCL_CHARACTER_VALUE_STR, -UCL_CHARACTER_KEY_START|UCL_CHARACTER_KEY|UCL_CHARACTER_VALUE_STR, -UCL_CHARACTER_KEY_START|UCL_CHARACTER_KEY|UCL_CHARACTER_VALUE_STR, -UCL_CHARACTER_KEY_START|UCL_CHARACTER_KEY|UCL_CHARACTER_VALUE_STR, -UCL_CHARACTER_KEY_START|UCL_CHARACTER_KEY|UCL_CHARACTER_VALUE_STR, -UCL_CHARACTER_KEY_START|UCL_CHARACTER_KEY|UCL_CHARACTER_VALUE_STR, -UCL_CHARACTER_KEY_START|UCL_CHARACTER_KEY|UCL_CHARACTER_VALUE_STR, -UCL_CHARACTER_KEY_START|UCL_CHARACTER_KEY|UCL_CHARACTER_VALUE_STR, -UCL_CHARACTER_KEY_START|UCL_CHARACTER_KEY|UCL_CHARACTER_VALUE_STR, -UCL_CHARACTER_KEY_START|UCL_CHARACTER_KEY|UCL_CHARACTER_VALUE_STR, -UCL_CHARACTER_KEY_START|UCL_CHARACTER_KEY|UCL_CHARACTER_VALUE_STR, -UCL_CHARACTER_KEY_START|UCL_CHARACTER_KEY|UCL_CHARACTER_VALUE_STR, -UCL_CHARACTER_KEY_START|UCL_CHARACTER_KEY|UCL_CHARACTER_VALUE_STR, -UCL_CHARACTER_KEY_START|UCL_CHARACTER_KEY|UCL_CHARACTER_VALUE_STR, -UCL_CHARACTER_KEY_START|UCL_CHARACTER_KEY|UCL_CHARACTER_VALUE_STR, -UCL_CHARACTER_KEY_START|UCL_CHARACTER_KEY|UCL_CHARACTER_VALUE_STR, -UCL_CHARACTER_KEY_START|UCL_CHARACTER_KEY|UCL_CHARACTER_VALUE_STR, -UCL_CHARACTER_KEY_START|UCL_CHARACTER_KEY|UCL_CHARACTER_VALUE_STR, -UCL_CHARACTER_KEY_START|UCL_CHARACTER_KEY|UCL_CHARACTER_VALUE_STR, -UCL_CHARACTER_KEY_START|UCL_CHARACTER_KEY|UCL_CHARACTER_VALUE_STR, -UCL_CHARACTER_KEY_START|UCL_CHARACTER_KEY|UCL_CHARACTER_VALUE_STR, -UCL_CHARACTER_KEY_START|UCL_CHARACTER_KEY|UCL_CHARACTER_VALUE_STR, -UCL_CHARACTER_KEY_START|UCL_CHARACTER_KEY|UCL_CHARACTER_VALUE_STR, -UCL_CHARACTER_KEY_START|UCL_CHARACTER_KEY|UCL_CHARACTER_VALUE_STR, -UCL_CHARACTER_KEY_START|UCL_CHARACTER_KEY|UCL_CHARACTER_VALUE_STR, -UCL_CHARACTER_KEY_START|UCL_CHARACTER_KEY|UCL_CHARACTER_VALUE_STR, -UCL_CHARACTER_KEY_START|UCL_CHARACTER_KEY|UCL_CHARACTER_VALUE_STR, -UCL_CHARACTER_KEY_START|UCL_CHARACTER_KEY|UCL_CHARACTER_VALUE_STR, -UCL_CHARACTER_KEY_START|UCL_CHARACTER_KEY|UCL_CHARACTER_VALUE_STR, -UCL_CHARACTER_KEY_START|UCL_CHARACTER_KEY|UCL_CHARACTER_VALUE_STR, -UCL_CHARACTER_KEY_START|UCL_CHARACTER_KEY|UCL_CHARACTER_VALUE_STR, -UCL_CHARACTER_KEY_START|UCL_CHARACTER_KEY|UCL_CHARACTER_VALUE_STR, -UCL_CHARACTER_KEY_START|UCL_CHARACTER_KEY|UCL_CHARACTER_VALUE_STR, -UCL_CHARACTER_KEY_START|UCL_CHARACTER_KEY|UCL_CHARACTER_VALUE_STR, -UCL_CHARACTER_KEY_START|UCL_CHARACTER_KEY|UCL_CHARACTER_VALUE_STR, -UCL_CHARACTER_KEY_START|UCL_CHARACTER_KEY|UCL_CHARACTER_VALUE_STR, -UCL_CHARACTER_KEY_START|UCL_CHARACTER_KEY|UCL_CHARACTER_VALUE_STR, -UCL_CHARACTER_KEY_START|UCL_CHARACTER_KEY|UCL_CHARACTER_VALUE_STR, -UCL_CHARACTER_KEY_START|UCL_CHARACTER_KEY|UCL_CHARACTER_VALUE_STR, -UCL_CHARACTER_KEY_START|UCL_CHARACTER_KEY|UCL_CHARACTER_VALUE_STR, -UCL_CHARACTER_KEY_START|UCL_CHARACTER_KEY|UCL_CHARACTER_VALUE_STR, -UCL_CHARACTER_KEY_START|UCL_CHARACTER_KEY|UCL_CHARACTER_VALUE_STR, -UCL_CHARACTER_KEY_START|UCL_CHARACTER_KEY|UCL_CHARACTER_VALUE_STR, -UCL_CHARACTER_KEY_START|UCL_CHARACTER_KEY|UCL_CHARACTER_VALUE_STR, -UCL_CHARACTER_KEY_START|UCL_CHARACTER_KEY|UCL_CHARACTER_VALUE_STR, -UCL_CHARACTER_KEY_START|UCL_CHARACTER_KEY|UCL_CHARACTER_VALUE_STR, -UCL_CHARACTER_KEY_START|UCL_CHARACTER_KEY|UCL_CHARACTER_VALUE_STR, -UCL_CHARACTER_KEY_START|UCL_CHARACTER_KEY|UCL_CHARACTER_VALUE_STR, -UCL_CHARACTER_KEY_START|UCL_CHARACTER_KEY|UCL_CHARACTER_VALUE_STR, -UCL_CHARACTER_KEY_START|UCL_CHARACTER_KEY|UCL_CHARACTER_VALUE_STR, -UCL_CHARACTER_KEY_START|UCL_CHARACTER_KEY|UCL_CHARACTER_VALUE_STR, -UCL_CHARACTER_KEY_START|UCL_CHARACTER_KEY|UCL_CHARACTER_VALUE_STR, -UCL_CHARACTER_KEY_START|UCL_CHARACTER_KEY|UCL_CHARACTER_VALUE_STR, -UCL_CHARACTER_KEY_START|UCL_CHARACTER_KEY|UCL_CHARACTER_VALUE_STR, -UCL_CHARACTER_KEY_START|UCL_CHARACTER_KEY|UCL_CHARACTER_VALUE_STR, -UCL_CHARACTER_KEY_START|UCL_CHARACTER_KEY|UCL_CHARACTER_VALUE_STR, -UCL_CHARACTER_KEY_START|UCL_CHARACTER_KEY|UCL_CHARACTER_VALUE_STR, -UCL_CHARACTER_KEY_START|UCL_CHARACTER_KEY|UCL_CHARACTER_VALUE_STR, -UCL_CHARACTER_KEY_START|UCL_CHARACTER_KEY|UCL_CHARACTER_VALUE_STR, -UCL_CHARACTER_KEY_START|UCL_CHARACTER_KEY|UCL_CHARACTER_VALUE_STR, -UCL_CHARACTER_KEY_START|UCL_CHARACTER_KEY|UCL_CHARACTER_VALUE_STR, -UCL_CHARACTER_KEY_START|UCL_CHARACTER_KEY|UCL_CHARACTER_VALUE_STR, -UCL_CHARACTER_KEY_START|UCL_CHARACTER_KEY|UCL_CHARACTER_VALUE_STR, -UCL_CHARACTER_KEY_START|UCL_CHARACTER_KEY|UCL_CHARACTER_VALUE_STR, -UCL_CHARACTER_KEY_START|UCL_CHARACTER_KEY|UCL_CHARACTER_VALUE_STR, -UCL_CHARACTER_KEY_START|UCL_CHARACTER_KEY|UCL_CHARACTER_VALUE_STR, -UCL_CHARACTER_KEY_START|UCL_CHARACTER_KEY|UCL_CHARACTER_VALUE_STR, -UCL_CHARACTER_KEY_START|UCL_CHARACTER_KEY|UCL_CHARACTER_VALUE_STR, -UCL_CHARACTER_KEY_START|UCL_CHARACTER_KEY|UCL_CHARACTER_VALUE_STR, -UCL_CHARACTER_KEY_START|UCL_CHARACTER_KEY|UCL_CHARACTER_VALUE_STR, -UCL_CHARACTER_KEY_START|UCL_CHARACTER_KEY|UCL_CHARACTER_VALUE_STR, -UCL_CHARACTER_KEY_START|UCL_CHARACTER_KEY|UCL_CHARACTER_VALUE_STR, -UCL_CHARACTER_KEY_START|UCL_CHARACTER_KEY|UCL_CHARACTER_VALUE_STR, -UCL_CHARACTER_KEY_START|UCL_CHARACTER_KEY|UCL_CHARACTER_VALUE_STR, -UCL_CHARACTER_KEY_START|UCL_CHARACTER_KEY|UCL_CHARACTER_VALUE_STR, -UCL_CHARACTER_KEY_START|UCL_CHARACTER_KEY|UCL_CHARACTER_VALUE_STR, -UCL_CHARACTER_KEY_START|UCL_CHARACTER_KEY|UCL_CHARACTER_VALUE_STR, -UCL_CHARACTER_KEY_START|UCL_CHARACTER_KEY|UCL_CHARACTER_VALUE_STR, -UCL_CHARACTER_KEY_START|UCL_CHARACTER_KEY|UCL_CHARACTER_VALUE_STR, -UCL_CHARACTER_KEY_START|UCL_CHARACTER_KEY|UCL_CHARACTER_VALUE_STR, -UCL_CHARACTER_KEY_START|UCL_CHARACTER_KEY|UCL_CHARACTER_VALUE_STR, -UCL_CHARACTER_KEY_START|UCL_CHARACTER_KEY|UCL_CHARACTER_VALUE_STR, -UCL_CHARACTER_KEY_START|UCL_CHARACTER_KEY|UCL_CHARACTER_VALUE_STR, -UCL_CHARACTER_KEY_START|UCL_CHARACTER_KEY|UCL_CHARACTER_VALUE_STR, -UCL_CHARACTER_KEY_START|UCL_CHARACTER_KEY|UCL_CHARACTER_VALUE_STR, -UCL_CHARACTER_KEY_START|UCL_CHARACTER_KEY|UCL_CHARACTER_VALUE_STR, -UCL_CHARACTER_KEY_START|UCL_CHARACTER_KEY|UCL_CHARACTER_VALUE_STR, -UCL_CHARACTER_KEY_START|UCL_CHARACTER_KEY|UCL_CHARACTER_VALUE_STR, -UCL_CHARACTER_KEY_START|UCL_CHARACTER_KEY|UCL_CHARACTER_VALUE_STR, -UCL_CHARACTER_KEY_START|UCL_CHARACTER_KEY|UCL_CHARACTER_VALUE_STR, -UCL_CHARACTER_KEY_START|UCL_CHARACTER_KEY|UCL_CHARACTER_VALUE_STR, -UCL_CHARACTER_KEY_START|UCL_CHARACTER_KEY|UCL_CHARACTER_VALUE_STR, -UCL_CHARACTER_KEY_START|UCL_CHARACTER_KEY|UCL_CHARACTER_VALUE_STR, -UCL_CHARACTER_KEY_START|UCL_CHARACTER_KEY|UCL_CHARACTER_VALUE_STR, -UCL_CHARACTER_KEY_START|UCL_CHARACTER_KEY|UCL_CHARACTER_VALUE_STR, -UCL_CHARACTER_KEY_START|UCL_CHARACTER_KEY|UCL_CHARACTER_VALUE_STR, -UCL_CHARACTER_KEY_START|UCL_CHARACTER_KEY|UCL_CHARACTER_VALUE_STR, -UCL_CHARACTER_KEY_START|UCL_CHARACTER_KEY|UCL_CHARACTER_VALUE_STR -}; + UCL_CHARACTER_JSON_UNSAFE | UCL_CHARACTER_VALUE_END | UCL_CHARACTER_UCL_UNSAFE, UCL_CHARACTER_DENIED, UCL_CHARACTER_DENIED, + UCL_CHARACTER_DENIED, UCL_CHARACTER_DENIED, UCL_CHARACTER_DENIED, + UCL_CHARACTER_DENIED, UCL_CHARACTER_DENIED, + UCL_CHARACTER_JSON_UNSAFE | UCL_CHARACTER_UCL_UNSAFE, + UCL_CHARACTER_WHITESPACE | UCL_CHARACTER_WHITESPACE_UNSAFE | UCL_CHARACTER_KEY_SEP | UCL_CHARACTER_JSON_UNSAFE | UCL_CHARACTER_UCL_UNSAFE, + UCL_CHARACTER_WHITESPACE_UNSAFE | UCL_CHARACTER_VALUE_END | UCL_CHARACTER_JSON_UNSAFE | UCL_CHARACTER_UCL_UNSAFE, + UCL_CHARACTER_WHITESPACE_UNSAFE, + UCL_CHARACTER_WHITESPACE_UNSAFE | UCL_CHARACTER_JSON_UNSAFE | UCL_CHARACTER_UCL_UNSAFE, + UCL_CHARACTER_WHITESPACE_UNSAFE | UCL_CHARACTER_VALUE_END | UCL_CHARACTER_JSON_UNSAFE | UCL_CHARACTER_UCL_UNSAFE, + UCL_CHARACTER_DENIED, UCL_CHARACTER_DENIED, UCL_CHARACTER_DENIED, + UCL_CHARACTER_DENIED, UCL_CHARACTER_DENIED, UCL_CHARACTER_DENIED, + UCL_CHARACTER_DENIED, UCL_CHARACTER_DENIED, UCL_CHARACTER_DENIED, + UCL_CHARACTER_DENIED, UCL_CHARACTER_DENIED, UCL_CHARACTER_DENIED, + UCL_CHARACTER_DENIED, UCL_CHARACTER_DENIED, UCL_CHARACTER_DENIED, + UCL_CHARACTER_DENIED, UCL_CHARACTER_DENIED, UCL_CHARACTER_DENIED, + UCL_CHARACTER_WHITESPACE | UCL_CHARACTER_WHITESPACE_UNSAFE | UCL_CHARACTER_VALUE_STR | UCL_CHARACTER_KEY_SEP | UCL_CHARACTER_UCL_UNSAFE /* */, + UCL_CHARACTER_VALUE_STR /* ! */, + UCL_CHARACTER_VALUE_STR | UCL_CHARACTER_ESCAPE | UCL_CHARACTER_JSON_UNSAFE | UCL_CHARACTER_UCL_UNSAFE /* " */, + UCL_CHARACTER_VALUE_END /* # */, UCL_CHARACTER_VALUE_STR /* $ */, + UCL_CHARACTER_VALUE_STR /* % */, UCL_CHARACTER_VALUE_STR /* & */, + UCL_CHARACTER_VALUE_STR /* ' */, UCL_CHARACTER_VALUE_STR /* ( */, + UCL_CHARACTER_VALUE_STR /* ) */, UCL_CHARACTER_VALUE_STR /* * */, + UCL_CHARACTER_VALUE_STR | UCL_CHARACTER_VALUE_DIGIT | UCL_CHARACTER_UCL_UNSAFE /* + */, + UCL_CHARACTER_VALUE_END /* , */, + UCL_CHARACTER_KEY | UCL_CHARACTER_VALUE_STR | UCL_CHARACTER_VALUE_DIGIT_START | UCL_CHARACTER_VALUE_DIGIT /* - */, + UCL_CHARACTER_KEY | UCL_CHARACTER_VALUE_STR | UCL_CHARACTER_VALUE_DIGIT /* . */, + UCL_CHARACTER_KEY_START | UCL_CHARACTER_KEY | UCL_CHARACTER_VALUE_STR | UCL_CHARACTER_ESCAPE /* / */, + UCL_CHARACTER_KEY_START | UCL_CHARACTER_KEY | UCL_CHARACTER_VALUE_STR | UCL_CHARACTER_VALUE_DIGIT_START | UCL_CHARACTER_VALUE_DIGIT /* 0 */, + UCL_CHARACTER_KEY_START | UCL_CHARACTER_KEY | UCL_CHARACTER_VALUE_STR | UCL_CHARACTER_VALUE_DIGIT_START | UCL_CHARACTER_VALUE_DIGIT /* 1 */, + UCL_CHARACTER_KEY_START | UCL_CHARACTER_KEY | UCL_CHARACTER_VALUE_STR | UCL_CHARACTER_VALUE_DIGIT_START | UCL_CHARACTER_VALUE_DIGIT /* 2 */, + UCL_CHARACTER_KEY_START | UCL_CHARACTER_KEY | UCL_CHARACTER_VALUE_STR | UCL_CHARACTER_VALUE_DIGIT_START | UCL_CHARACTER_VALUE_DIGIT /* 3 */, + UCL_CHARACTER_KEY_START | UCL_CHARACTER_KEY | UCL_CHARACTER_VALUE_STR | UCL_CHARACTER_VALUE_DIGIT_START | UCL_CHARACTER_VALUE_DIGIT /* 4 */, + UCL_CHARACTER_KEY_START | UCL_CHARACTER_KEY | UCL_CHARACTER_VALUE_STR | UCL_CHARACTER_VALUE_DIGIT_START | UCL_CHARACTER_VALUE_DIGIT /* 5 */, + UCL_CHARACTER_KEY_START | UCL_CHARACTER_KEY | UCL_CHARACTER_VALUE_STR | UCL_CHARACTER_VALUE_DIGIT_START | UCL_CHARACTER_VALUE_DIGIT /* 6 */, + UCL_CHARACTER_KEY_START | UCL_CHARACTER_KEY | UCL_CHARACTER_VALUE_STR | UCL_CHARACTER_VALUE_DIGIT_START | UCL_CHARACTER_VALUE_DIGIT /* 7 */, + UCL_CHARACTER_KEY_START | UCL_CHARACTER_KEY | UCL_CHARACTER_VALUE_STR | UCL_CHARACTER_VALUE_DIGIT_START | UCL_CHARACTER_VALUE_DIGIT /* 8 */, + UCL_CHARACTER_KEY_START | UCL_CHARACTER_KEY | UCL_CHARACTER_VALUE_STR | UCL_CHARACTER_VALUE_DIGIT_START | UCL_CHARACTER_VALUE_DIGIT /* 9 */, + UCL_CHARACTER_VALUE_STR | UCL_CHARACTER_KEY_SEP | UCL_CHARACTER_UCL_UNSAFE /* : */, + UCL_CHARACTER_VALUE_END /* ; */, UCL_CHARACTER_VALUE_STR /* < */, + UCL_CHARACTER_VALUE_STR | UCL_CHARACTER_KEY_SEP | UCL_CHARACTER_UCL_UNSAFE /* = */, + UCL_CHARACTER_VALUE_STR /* > */, UCL_CHARACTER_VALUE_STR /* ? */, + UCL_CHARACTER_VALUE_STR /* @ */, + UCL_CHARACTER_KEY_START | UCL_CHARACTER_KEY | UCL_CHARACTER_VALUE_STR | UCL_CHARACTER_VALUE_DIGIT /* A */, + UCL_CHARACTER_KEY_START | UCL_CHARACTER_KEY | UCL_CHARACTER_VALUE_STR | UCL_CHARACTER_VALUE_DIGIT /* B */, + UCL_CHARACTER_KEY_START | UCL_CHARACTER_KEY | UCL_CHARACTER_VALUE_STR | UCL_CHARACTER_VALUE_DIGIT /* C */, + UCL_CHARACTER_KEY_START | UCL_CHARACTER_KEY | UCL_CHARACTER_VALUE_STR | UCL_CHARACTER_VALUE_DIGIT /* D */, + UCL_CHARACTER_KEY_START | UCL_CHARACTER_KEY | UCL_CHARACTER_VALUE_STR | UCL_CHARACTER_VALUE_DIGIT /* E */, + UCL_CHARACTER_KEY_START | UCL_CHARACTER_KEY | UCL_CHARACTER_VALUE_STR | UCL_CHARACTER_VALUE_DIGIT /* F */, + UCL_CHARACTER_KEY_START | UCL_CHARACTER_KEY | UCL_CHARACTER_VALUE_STR | UCL_CHARACTER_VALUE_DIGIT /* G */, + UCL_CHARACTER_KEY_START | UCL_CHARACTER_KEY | UCL_CHARACTER_VALUE_STR | UCL_CHARACTER_VALUE_DIGIT /* H */, + UCL_CHARACTER_KEY_START | UCL_CHARACTER_KEY | UCL_CHARACTER_VALUE_STR | UCL_CHARACTER_VALUE_DIGIT /* I */, + UCL_CHARACTER_KEY_START | UCL_CHARACTER_KEY | UCL_CHARACTER_VALUE_STR | UCL_CHARACTER_VALUE_DIGIT /* J */, + UCL_CHARACTER_KEY_START | UCL_CHARACTER_KEY | UCL_CHARACTER_VALUE_STR | UCL_CHARACTER_VALUE_DIGIT /* K */, + UCL_CHARACTER_KEY_START | UCL_CHARACTER_KEY | UCL_CHARACTER_VALUE_STR | UCL_CHARACTER_VALUE_DIGIT /* L */, + UCL_CHARACTER_KEY_START | UCL_CHARACTER_KEY | UCL_CHARACTER_VALUE_STR | UCL_CHARACTER_VALUE_DIGIT /* M */, + UCL_CHARACTER_KEY_START | UCL_CHARACTER_KEY | UCL_CHARACTER_VALUE_STR | UCL_CHARACTER_VALUE_DIGIT /* N */, + UCL_CHARACTER_KEY_START | UCL_CHARACTER_KEY | UCL_CHARACTER_VALUE_STR | UCL_CHARACTER_VALUE_DIGIT /* O */, + UCL_CHARACTER_KEY_START | UCL_CHARACTER_KEY | UCL_CHARACTER_VALUE_STR | UCL_CHARACTER_VALUE_DIGIT /* P */, + UCL_CHARACTER_KEY_START | UCL_CHARACTER_KEY | UCL_CHARACTER_VALUE_STR | UCL_CHARACTER_VALUE_DIGIT /* Q */, + UCL_CHARACTER_KEY_START | UCL_CHARACTER_KEY | UCL_CHARACTER_VALUE_STR | UCL_CHARACTER_VALUE_DIGIT /* R */, + UCL_CHARACTER_KEY_START | UCL_CHARACTER_KEY | UCL_CHARACTER_VALUE_STR | UCL_CHARACTER_VALUE_DIGIT /* S */, + UCL_CHARACTER_KEY_START | UCL_CHARACTER_KEY | UCL_CHARACTER_VALUE_STR | UCL_CHARACTER_VALUE_DIGIT /* T */, + UCL_CHARACTER_KEY_START | UCL_CHARACTER_KEY | UCL_CHARACTER_VALUE_STR | UCL_CHARACTER_VALUE_DIGIT /* U */, + UCL_CHARACTER_KEY_START | UCL_CHARACTER_KEY | UCL_CHARACTER_VALUE_STR | UCL_CHARACTER_VALUE_DIGIT /* V */, + UCL_CHARACTER_KEY_START | UCL_CHARACTER_KEY | UCL_CHARACTER_VALUE_STR | UCL_CHARACTER_VALUE_DIGIT /* W */, + UCL_CHARACTER_KEY_START | UCL_CHARACTER_KEY | UCL_CHARACTER_VALUE_STR | UCL_CHARACTER_VALUE_DIGIT /* X */, + UCL_CHARACTER_KEY_START | UCL_CHARACTER_KEY | UCL_CHARACTER_VALUE_STR | UCL_CHARACTER_VALUE_DIGIT /* Y */, + UCL_CHARACTER_KEY_START | UCL_CHARACTER_KEY | UCL_CHARACTER_VALUE_STR | UCL_CHARACTER_VALUE_DIGIT /* Z */, + UCL_CHARACTER_VALUE_STR | UCL_CHARACTER_UCL_UNSAFE /* [ */, + UCL_CHARACTER_VALUE_STR | UCL_CHARACTER_ESCAPE | UCL_CHARACTER_JSON_UNSAFE | UCL_CHARACTER_UCL_UNSAFE /* \ */, + UCL_CHARACTER_VALUE_END /* ] */, UCL_CHARACTER_VALUE_STR /* ^ */, + UCL_CHARACTER_KEY_START | UCL_CHARACTER_KEY | UCL_CHARACTER_VALUE_STR /* _ */, + UCL_CHARACTER_VALUE_STR /* ` */, + UCL_CHARACTER_KEY_START | UCL_CHARACTER_KEY | UCL_CHARACTER_VALUE_STR | UCL_CHARACTER_VALUE_DIGIT /* a */, + UCL_CHARACTER_KEY_START | UCL_CHARACTER_KEY | UCL_CHARACTER_VALUE_STR | UCL_CHARACTER_VALUE_DIGIT | UCL_CHARACTER_ESCAPE /* b */, + UCL_CHARACTER_KEY_START | UCL_CHARACTER_KEY | UCL_CHARACTER_VALUE_STR | UCL_CHARACTER_VALUE_DIGIT /* c */, + UCL_CHARACTER_KEY_START | UCL_CHARACTER_KEY | UCL_CHARACTER_VALUE_STR | UCL_CHARACTER_VALUE_DIGIT /* d */, + UCL_CHARACTER_KEY_START | UCL_CHARACTER_KEY | UCL_CHARACTER_VALUE_STR | UCL_CHARACTER_VALUE_DIGIT /* e */, + UCL_CHARACTER_KEY_START | UCL_CHARACTER_KEY | UCL_CHARACTER_VALUE_STR | UCL_CHARACTER_VALUE_DIGIT | UCL_CHARACTER_ESCAPE /* f */, + UCL_CHARACTER_KEY_START | UCL_CHARACTER_KEY | UCL_CHARACTER_VALUE_STR | UCL_CHARACTER_VALUE_DIGIT /* g */, + UCL_CHARACTER_KEY_START | UCL_CHARACTER_KEY | UCL_CHARACTER_VALUE_STR | UCL_CHARACTER_VALUE_DIGIT /* h */, + UCL_CHARACTER_KEY_START | UCL_CHARACTER_KEY | UCL_CHARACTER_VALUE_STR | UCL_CHARACTER_VALUE_DIGIT /* i */, + UCL_CHARACTER_KEY_START | UCL_CHARACTER_KEY | UCL_CHARACTER_VALUE_STR | UCL_CHARACTER_VALUE_DIGIT /* j */, + UCL_CHARACTER_KEY_START | UCL_CHARACTER_KEY | UCL_CHARACTER_VALUE_STR | UCL_CHARACTER_VALUE_DIGIT /* k */, + UCL_CHARACTER_KEY_START | UCL_CHARACTER_KEY | UCL_CHARACTER_VALUE_STR | UCL_CHARACTER_VALUE_DIGIT /* l */, + UCL_CHARACTER_KEY_START | UCL_CHARACTER_KEY | UCL_CHARACTER_VALUE_STR | UCL_CHARACTER_VALUE_DIGIT /* m */, + UCL_CHARACTER_KEY_START | UCL_CHARACTER_KEY | UCL_CHARACTER_VALUE_STR | UCL_CHARACTER_VALUE_DIGIT | UCL_CHARACTER_ESCAPE /* n */, + UCL_CHARACTER_KEY_START | UCL_CHARACTER_KEY | UCL_CHARACTER_VALUE_STR | UCL_CHARACTER_VALUE_DIGIT /* o */, + UCL_CHARACTER_KEY_START | UCL_CHARACTER_KEY | UCL_CHARACTER_VALUE_STR | UCL_CHARACTER_VALUE_DIGIT /* p */, + UCL_CHARACTER_KEY_START | UCL_CHARACTER_KEY | UCL_CHARACTER_VALUE_STR | UCL_CHARACTER_VALUE_DIGIT /* q */, + UCL_CHARACTER_KEY_START | UCL_CHARACTER_KEY | UCL_CHARACTER_VALUE_STR | UCL_CHARACTER_VALUE_DIGIT | UCL_CHARACTER_ESCAPE /* r */, + UCL_CHARACTER_KEY_START | UCL_CHARACTER_KEY | UCL_CHARACTER_VALUE_STR | UCL_CHARACTER_VALUE_DIGIT /* s */, + UCL_CHARACTER_KEY_START | UCL_CHARACTER_KEY | UCL_CHARACTER_VALUE_STR | UCL_CHARACTER_VALUE_DIGIT | UCL_CHARACTER_ESCAPE /* t */, + UCL_CHARACTER_KEY_START | UCL_CHARACTER_KEY | UCL_CHARACTER_VALUE_STR | UCL_CHARACTER_VALUE_DIGIT | UCL_CHARACTER_ESCAPE /* u */, + UCL_CHARACTER_KEY_START | UCL_CHARACTER_KEY | UCL_CHARACTER_VALUE_STR | UCL_CHARACTER_VALUE_DIGIT /* v */, + UCL_CHARACTER_KEY_START | UCL_CHARACTER_KEY | UCL_CHARACTER_VALUE_STR | UCL_CHARACTER_VALUE_DIGIT /* w */, + UCL_CHARACTER_KEY_START | UCL_CHARACTER_KEY | UCL_CHARACTER_VALUE_STR | UCL_CHARACTER_VALUE_DIGIT /* x */, + UCL_CHARACTER_KEY_START | UCL_CHARACTER_KEY | UCL_CHARACTER_VALUE_STR | UCL_CHARACTER_VALUE_DIGIT /* y */, + UCL_CHARACTER_KEY_START | UCL_CHARACTER_KEY | UCL_CHARACTER_VALUE_STR | UCL_CHARACTER_VALUE_DIGIT /* z */, + UCL_CHARACTER_VALUE_STR | UCL_CHARACTER_UCL_UNSAFE /* { */, + UCL_CHARACTER_VALUE_STR /* | */, UCL_CHARACTER_VALUE_END /* } */, + UCL_CHARACTER_VALUE_STR /* ~ */, UCL_CHARACTER_DENIED, + UCL_CHARACTER_KEY_START | UCL_CHARACTER_KEY | UCL_CHARACTER_VALUE_STR, + UCL_CHARACTER_KEY_START | UCL_CHARACTER_KEY | UCL_CHARACTER_VALUE_STR, + UCL_CHARACTER_KEY_START | UCL_CHARACTER_KEY | UCL_CHARACTER_VALUE_STR, + UCL_CHARACTER_KEY_START | UCL_CHARACTER_KEY | UCL_CHARACTER_VALUE_STR, + UCL_CHARACTER_KEY_START | UCL_CHARACTER_KEY | UCL_CHARACTER_VALUE_STR, + UCL_CHARACTER_KEY_START | UCL_CHARACTER_KEY | UCL_CHARACTER_VALUE_STR, + UCL_CHARACTER_KEY_START | UCL_CHARACTER_KEY | UCL_CHARACTER_VALUE_STR, + UCL_CHARACTER_KEY_START | UCL_CHARACTER_KEY | UCL_CHARACTER_VALUE_STR, + UCL_CHARACTER_KEY_START | UCL_CHARACTER_KEY | UCL_CHARACTER_VALUE_STR, + UCL_CHARACTER_KEY_START | UCL_CHARACTER_KEY | UCL_CHARACTER_VALUE_STR, + UCL_CHARACTER_KEY_START | UCL_CHARACTER_KEY | UCL_CHARACTER_VALUE_STR, + UCL_CHARACTER_KEY_START | UCL_CHARACTER_KEY | UCL_CHARACTER_VALUE_STR, + UCL_CHARACTER_KEY_START | UCL_CHARACTER_KEY | UCL_CHARACTER_VALUE_STR, + UCL_CHARACTER_KEY_START | UCL_CHARACTER_KEY | UCL_CHARACTER_VALUE_STR, + UCL_CHARACTER_KEY_START | UCL_CHARACTER_KEY | UCL_CHARACTER_VALUE_STR, + UCL_CHARACTER_KEY_START | UCL_CHARACTER_KEY | UCL_CHARACTER_VALUE_STR, + UCL_CHARACTER_KEY_START | UCL_CHARACTER_KEY | UCL_CHARACTER_VALUE_STR, + UCL_CHARACTER_KEY_START | UCL_CHARACTER_KEY | UCL_CHARACTER_VALUE_STR, + UCL_CHARACTER_KEY_START | UCL_CHARACTER_KEY | UCL_CHARACTER_VALUE_STR, + UCL_CHARACTER_KEY_START | UCL_CHARACTER_KEY | UCL_CHARACTER_VALUE_STR, + UCL_CHARACTER_KEY_START | UCL_CHARACTER_KEY | UCL_CHARACTER_VALUE_STR, + UCL_CHARACTER_KEY_START | UCL_CHARACTER_KEY | UCL_CHARACTER_VALUE_STR, + UCL_CHARACTER_KEY_START | UCL_CHARACTER_KEY | UCL_CHARACTER_VALUE_STR, + UCL_CHARACTER_KEY_START | UCL_CHARACTER_KEY | UCL_CHARACTER_VALUE_STR, + UCL_CHARACTER_KEY_START | UCL_CHARACTER_KEY | UCL_CHARACTER_VALUE_STR, + UCL_CHARACTER_KEY_START | UCL_CHARACTER_KEY | UCL_CHARACTER_VALUE_STR, + UCL_CHARACTER_KEY_START | UCL_CHARACTER_KEY | UCL_CHARACTER_VALUE_STR, + UCL_CHARACTER_KEY_START | UCL_CHARACTER_KEY | UCL_CHARACTER_VALUE_STR, + UCL_CHARACTER_KEY_START | UCL_CHARACTER_KEY | UCL_CHARACTER_VALUE_STR, + UCL_CHARACTER_KEY_START | UCL_CHARACTER_KEY | UCL_CHARACTER_VALUE_STR, + UCL_CHARACTER_KEY_START | UCL_CHARACTER_KEY | UCL_CHARACTER_VALUE_STR, + UCL_CHARACTER_KEY_START | UCL_CHARACTER_KEY | UCL_CHARACTER_VALUE_STR, + UCL_CHARACTER_KEY_START | UCL_CHARACTER_KEY | UCL_CHARACTER_VALUE_STR, + UCL_CHARACTER_KEY_START | UCL_CHARACTER_KEY | UCL_CHARACTER_VALUE_STR, + UCL_CHARACTER_KEY_START | UCL_CHARACTER_KEY | UCL_CHARACTER_VALUE_STR, + UCL_CHARACTER_KEY_START | UCL_CHARACTER_KEY | UCL_CHARACTER_VALUE_STR, + UCL_CHARACTER_KEY_START | UCL_CHARACTER_KEY | UCL_CHARACTER_VALUE_STR, + UCL_CHARACTER_KEY_START | UCL_CHARACTER_KEY | UCL_CHARACTER_VALUE_STR, + UCL_CHARACTER_KEY_START | UCL_CHARACTER_KEY | UCL_CHARACTER_VALUE_STR, + UCL_CHARACTER_KEY_START | UCL_CHARACTER_KEY | UCL_CHARACTER_VALUE_STR, + UCL_CHARACTER_KEY_START | UCL_CHARACTER_KEY | UCL_CHARACTER_VALUE_STR, + UCL_CHARACTER_KEY_START | UCL_CHARACTER_KEY | UCL_CHARACTER_VALUE_STR, + UCL_CHARACTER_KEY_START | UCL_CHARACTER_KEY | UCL_CHARACTER_VALUE_STR, + UCL_CHARACTER_KEY_START | UCL_CHARACTER_KEY | UCL_CHARACTER_VALUE_STR, + UCL_CHARACTER_KEY_START | UCL_CHARACTER_KEY | UCL_CHARACTER_VALUE_STR, + UCL_CHARACTER_KEY_START | UCL_CHARACTER_KEY | UCL_CHARACTER_VALUE_STR, + UCL_CHARACTER_KEY_START | UCL_CHARACTER_KEY | UCL_CHARACTER_VALUE_STR, + UCL_CHARACTER_KEY_START | UCL_CHARACTER_KEY | UCL_CHARACTER_VALUE_STR, + UCL_CHARACTER_KEY_START | UCL_CHARACTER_KEY | UCL_CHARACTER_VALUE_STR, + UCL_CHARACTER_KEY_START | UCL_CHARACTER_KEY | UCL_CHARACTER_VALUE_STR, + UCL_CHARACTER_KEY_START | UCL_CHARACTER_KEY | UCL_CHARACTER_VALUE_STR, + UCL_CHARACTER_KEY_START | UCL_CHARACTER_KEY | UCL_CHARACTER_VALUE_STR, + UCL_CHARACTER_KEY_START | UCL_CHARACTER_KEY | UCL_CHARACTER_VALUE_STR, + UCL_CHARACTER_KEY_START | UCL_CHARACTER_KEY | UCL_CHARACTER_VALUE_STR, + UCL_CHARACTER_KEY_START | UCL_CHARACTER_KEY | UCL_CHARACTER_VALUE_STR, + UCL_CHARACTER_KEY_START | UCL_CHARACTER_KEY | UCL_CHARACTER_VALUE_STR, + UCL_CHARACTER_KEY_START | UCL_CHARACTER_KEY | UCL_CHARACTER_VALUE_STR, + UCL_CHARACTER_KEY_START | UCL_CHARACTER_KEY | UCL_CHARACTER_VALUE_STR, + UCL_CHARACTER_KEY_START | UCL_CHARACTER_KEY | UCL_CHARACTER_VALUE_STR, + UCL_CHARACTER_KEY_START | UCL_CHARACTER_KEY | UCL_CHARACTER_VALUE_STR, + UCL_CHARACTER_KEY_START | UCL_CHARACTER_KEY | UCL_CHARACTER_VALUE_STR, + UCL_CHARACTER_KEY_START | UCL_CHARACTER_KEY | UCL_CHARACTER_VALUE_STR, + UCL_CHARACTER_KEY_START | UCL_CHARACTER_KEY | UCL_CHARACTER_VALUE_STR, + UCL_CHARACTER_KEY_START | UCL_CHARACTER_KEY | UCL_CHARACTER_VALUE_STR, + UCL_CHARACTER_KEY_START | UCL_CHARACTER_KEY | UCL_CHARACTER_VALUE_STR, + UCL_CHARACTER_KEY_START | UCL_CHARACTER_KEY | UCL_CHARACTER_VALUE_STR, + UCL_CHARACTER_KEY_START | UCL_CHARACTER_KEY | UCL_CHARACTER_VALUE_STR, + UCL_CHARACTER_KEY_START | UCL_CHARACTER_KEY | UCL_CHARACTER_VALUE_STR, + UCL_CHARACTER_KEY_START | UCL_CHARACTER_KEY | UCL_CHARACTER_VALUE_STR, + UCL_CHARACTER_KEY_START | UCL_CHARACTER_KEY | UCL_CHARACTER_VALUE_STR, + UCL_CHARACTER_KEY_START | UCL_CHARACTER_KEY | UCL_CHARACTER_VALUE_STR, + UCL_CHARACTER_KEY_START | UCL_CHARACTER_KEY | UCL_CHARACTER_VALUE_STR, + UCL_CHARACTER_KEY_START | UCL_CHARACTER_KEY | UCL_CHARACTER_VALUE_STR, + UCL_CHARACTER_KEY_START | UCL_CHARACTER_KEY | UCL_CHARACTER_VALUE_STR, + UCL_CHARACTER_KEY_START | UCL_CHARACTER_KEY | UCL_CHARACTER_VALUE_STR, + UCL_CHARACTER_KEY_START | UCL_CHARACTER_KEY | UCL_CHARACTER_VALUE_STR, + UCL_CHARACTER_KEY_START | UCL_CHARACTER_KEY | UCL_CHARACTER_VALUE_STR, + UCL_CHARACTER_KEY_START | UCL_CHARACTER_KEY | UCL_CHARACTER_VALUE_STR, + UCL_CHARACTER_KEY_START | UCL_CHARACTER_KEY | UCL_CHARACTER_VALUE_STR, + UCL_CHARACTER_KEY_START | UCL_CHARACTER_KEY | UCL_CHARACTER_VALUE_STR, + UCL_CHARACTER_KEY_START | UCL_CHARACTER_KEY | UCL_CHARACTER_VALUE_STR, + UCL_CHARACTER_KEY_START | UCL_CHARACTER_KEY | UCL_CHARACTER_VALUE_STR, + UCL_CHARACTER_KEY_START | UCL_CHARACTER_KEY | UCL_CHARACTER_VALUE_STR, + UCL_CHARACTER_KEY_START | UCL_CHARACTER_KEY | UCL_CHARACTER_VALUE_STR, + UCL_CHARACTER_KEY_START | UCL_CHARACTER_KEY | UCL_CHARACTER_VALUE_STR, + UCL_CHARACTER_KEY_START | UCL_CHARACTER_KEY | UCL_CHARACTER_VALUE_STR, + UCL_CHARACTER_KEY_START | UCL_CHARACTER_KEY | UCL_CHARACTER_VALUE_STR, + UCL_CHARACTER_KEY_START | UCL_CHARACTER_KEY | UCL_CHARACTER_VALUE_STR, + UCL_CHARACTER_KEY_START | UCL_CHARACTER_KEY | UCL_CHARACTER_VALUE_STR, + UCL_CHARACTER_KEY_START | UCL_CHARACTER_KEY | UCL_CHARACTER_VALUE_STR, + UCL_CHARACTER_KEY_START | UCL_CHARACTER_KEY | UCL_CHARACTER_VALUE_STR, + UCL_CHARACTER_KEY_START | UCL_CHARACTER_KEY | UCL_CHARACTER_VALUE_STR, + UCL_CHARACTER_KEY_START | UCL_CHARACTER_KEY | UCL_CHARACTER_VALUE_STR, + UCL_CHARACTER_KEY_START | UCL_CHARACTER_KEY | UCL_CHARACTER_VALUE_STR, + UCL_CHARACTER_KEY_START | UCL_CHARACTER_KEY | UCL_CHARACTER_VALUE_STR, + UCL_CHARACTER_KEY_START | UCL_CHARACTER_KEY | UCL_CHARACTER_VALUE_STR, + UCL_CHARACTER_KEY_START | UCL_CHARACTER_KEY | UCL_CHARACTER_VALUE_STR, + UCL_CHARACTER_KEY_START | UCL_CHARACTER_KEY | UCL_CHARACTER_VALUE_STR, + UCL_CHARACTER_KEY_START | UCL_CHARACTER_KEY | UCL_CHARACTER_VALUE_STR, + UCL_CHARACTER_KEY_START | UCL_CHARACTER_KEY | UCL_CHARACTER_VALUE_STR, + UCL_CHARACTER_KEY_START | UCL_CHARACTER_KEY | UCL_CHARACTER_VALUE_STR, + UCL_CHARACTER_KEY_START | UCL_CHARACTER_KEY | UCL_CHARACTER_VALUE_STR, + UCL_CHARACTER_KEY_START | UCL_CHARACTER_KEY | UCL_CHARACTER_VALUE_STR, + UCL_CHARACTER_KEY_START | UCL_CHARACTER_KEY | UCL_CHARACTER_VALUE_STR, + UCL_CHARACTER_KEY_START | UCL_CHARACTER_KEY | UCL_CHARACTER_VALUE_STR, + UCL_CHARACTER_KEY_START | UCL_CHARACTER_KEY | UCL_CHARACTER_VALUE_STR, + UCL_CHARACTER_KEY_START | UCL_CHARACTER_KEY | UCL_CHARACTER_VALUE_STR, + UCL_CHARACTER_KEY_START | UCL_CHARACTER_KEY | UCL_CHARACTER_VALUE_STR, + UCL_CHARACTER_KEY_START | UCL_CHARACTER_KEY | UCL_CHARACTER_VALUE_STR, + UCL_CHARACTER_KEY_START | UCL_CHARACTER_KEY | UCL_CHARACTER_VALUE_STR, + UCL_CHARACTER_KEY_START | UCL_CHARACTER_KEY | UCL_CHARACTER_VALUE_STR, + UCL_CHARACTER_KEY_START | UCL_CHARACTER_KEY | UCL_CHARACTER_VALUE_STR, + UCL_CHARACTER_KEY_START | UCL_CHARACTER_KEY | UCL_CHARACTER_VALUE_STR, + UCL_CHARACTER_KEY_START | UCL_CHARACTER_KEY | UCL_CHARACTER_VALUE_STR, + UCL_CHARACTER_KEY_START | UCL_CHARACTER_KEY | UCL_CHARACTER_VALUE_STR, + UCL_CHARACTER_KEY_START | UCL_CHARACTER_KEY | UCL_CHARACTER_VALUE_STR, + UCL_CHARACTER_KEY_START | UCL_CHARACTER_KEY | UCL_CHARACTER_VALUE_STR, + UCL_CHARACTER_KEY_START | UCL_CHARACTER_KEY | UCL_CHARACTER_VALUE_STR, + UCL_CHARACTER_KEY_START | UCL_CHARACTER_KEY | UCL_CHARACTER_VALUE_STR, + UCL_CHARACTER_KEY_START | UCL_CHARACTER_KEY | UCL_CHARACTER_VALUE_STR, + UCL_CHARACTER_KEY_START | UCL_CHARACTER_KEY | UCL_CHARACTER_VALUE_STR, + UCL_CHARACTER_KEY_START | UCL_CHARACTER_KEY | UCL_CHARACTER_VALUE_STR, + UCL_CHARACTER_KEY_START | UCL_CHARACTER_KEY | UCL_CHARACTER_VALUE_STR, + UCL_CHARACTER_KEY_START | UCL_CHARACTER_KEY | UCL_CHARACTER_VALUE_STR, + UCL_CHARACTER_KEY_START | UCL_CHARACTER_KEY | UCL_CHARACTER_VALUE_STR, + UCL_CHARACTER_KEY_START | UCL_CHARACTER_KEY | UCL_CHARACTER_VALUE_STR, + UCL_CHARACTER_KEY_START | UCL_CHARACTER_KEY | UCL_CHARACTER_VALUE_STR, + UCL_CHARACTER_KEY_START | UCL_CHARACTER_KEY | UCL_CHARACTER_VALUE_STR}; static inline bool -ucl_test_character (unsigned char c, int type_flags) +ucl_test_character(unsigned char c, int type_flags) { return (ucl_chartable[c] & type_flags) != 0; } diff --git a/src/ucl_emitter.c b/src/ucl_emitter.c index 97d8f618021f..84c1b13e1865 100644 --- a/src/ucl_emitter.c +++ b/src/ucl_emitter.c @@ -40,20 +40,20 @@ * Serialise UCL object to various of output formats */ -static void ucl_emitter_common_elt (struct ucl_emitter_context *ctx, - const ucl_object_t *obj, bool first, bool print_key, bool compact); - -#define UCL_EMIT_TYPE_OPS(type) \ - static void ucl_emit_ ## type ## _elt (struct ucl_emitter_context *ctx, \ - const ucl_object_t *obj, bool first, bool print_key); \ - static void ucl_emit_ ## type ## _start_obj (struct ucl_emitter_context *ctx, \ - const ucl_object_t *obj, bool first, bool print_key); \ - static void ucl_emit_ ## type## _start_array (struct ucl_emitter_context *ctx, \ - const ucl_object_t *obj, bool first, bool print_key); \ - static void ucl_emit_ ##type## _end_object (struct ucl_emitter_context *ctx, \ - const ucl_object_t *obj); \ - static void ucl_emit_ ##type## _end_array (struct ucl_emitter_context *ctx, \ - const ucl_object_t *obj) +static void ucl_emitter_common_elt(struct ucl_emitter_context *ctx, + const ucl_object_t *obj, bool first, bool print_key, bool compact); + +#define UCL_EMIT_TYPE_OPS(type) \ + static void ucl_emit_##type##_elt(struct ucl_emitter_context *ctx, \ + const ucl_object_t *obj, bool first, bool print_key); \ + static void ucl_emit_##type##_start_obj(struct ucl_emitter_context *ctx, \ + const ucl_object_t *obj, bool first, bool print_key); \ + static void ucl_emit_##type##_start_array(struct ucl_emitter_context *ctx, \ + const ucl_object_t *obj, bool first, bool print_key); \ + static void ucl_emit_##type##_end_object(struct ucl_emitter_context *ctx, \ + const ucl_object_t *obj); \ + static void ucl_emit_##type##_end_array(struct ucl_emitter_context *ctx, \ + const ucl_object_t *obj) /* * JSON format operations @@ -64,27 +64,25 @@ UCL_EMIT_TYPE_OPS(config); UCL_EMIT_TYPE_OPS(yaml); UCL_EMIT_TYPE_OPS(msgpack); -#define UCL_EMIT_TYPE_CONTENT(type) { \ - .ucl_emitter_write_elt = ucl_emit_ ## type ## _elt, \ - .ucl_emitter_start_object = ucl_emit_ ## type ##_start_obj, \ - .ucl_emitter_start_array = ucl_emit_ ## type ##_start_array, \ - .ucl_emitter_end_object = ucl_emit_ ## type ##_end_object, \ - .ucl_emitter_end_array = ucl_emit_ ## type ##_end_array \ -} +#define UCL_EMIT_TYPE_CONTENT(type) { \ + .ucl_emitter_write_elt = ucl_emit_##type##_elt, \ + .ucl_emitter_start_object = ucl_emit_##type##_start_obj, \ + .ucl_emitter_start_array = ucl_emit_##type##_start_array, \ + .ucl_emitter_end_object = ucl_emit_##type##_end_object, \ + .ucl_emitter_end_array = ucl_emit_##type##_end_array} const struct ucl_emitter_operations ucl_standartd_emitter_ops[] = { [UCL_EMIT_JSON] = UCL_EMIT_TYPE_CONTENT(json), [UCL_EMIT_JSON_COMPACT] = UCL_EMIT_TYPE_CONTENT(json_compact), [UCL_EMIT_CONFIG] = UCL_EMIT_TYPE_CONTENT(config), [UCL_EMIT_YAML] = UCL_EMIT_TYPE_CONTENT(yaml), - [UCL_EMIT_MSGPACK] = UCL_EMIT_TYPE_CONTENT(msgpack) -}; + [UCL_EMIT_MSGPACK] = UCL_EMIT_TYPE_CONTENT(msgpack)}; /* * Utility to check whether we need a top object */ #define UCL_EMIT_IDENT_TOP_OBJ(ctx, obj) ((ctx)->top != (obj) || \ - ((ctx)->id == UCL_EMIT_JSON_COMPACT || (ctx)->id == UCL_EMIT_JSON)) + ((ctx)->id == UCL_EMIT_JSON_COMPACT || (ctx)->id == UCL_EMIT_JSON)) /** @@ -93,11 +91,11 @@ const struct ucl_emitter_operations ucl_standartd_emitter_ops[] = { * @param tabs number of tabs to add */ static inline void -ucl_add_tabs (const struct ucl_emitter_functions *func, unsigned int tabs, - bool compact) +ucl_add_tabs(const struct ucl_emitter_functions *func, unsigned int tabs, + bool compact) { if (!compact && tabs > 0) { - func->ucl_emitter_append_character (' ', tabs * 4, func->ud); + func->ucl_emitter_append_character(' ', tabs * 4, func->ud); } } @@ -107,8 +105,8 @@ ucl_add_tabs (const struct ucl_emitter_functions *func, unsigned int tabs, * @param obj */ static void -ucl_emitter_print_key (bool print_key, struct ucl_emitter_context *ctx, - const ucl_object_t *obj, bool compact) +ucl_emitter_print_key(bool print_key, struct ucl_emitter_context *ctx, + const ucl_object_t *obj, bool compact) { const struct ucl_emitter_functions *func = ctx->func; @@ -118,52 +116,52 @@ ucl_emitter_print_key (bool print_key, struct ucl_emitter_context *ctx, if (ctx->id == UCL_EMIT_CONFIG) { if (obj->flags & UCL_OBJECT_NEED_KEY_ESCAPE) { - ucl_elt_string_write_json (obj->key, obj->keylen, ctx); + ucl_elt_string_write_json(obj->key, obj->keylen, ctx); } else { - func->ucl_emitter_append_len (obj->key, obj->keylen, func->ud); + func->ucl_emitter_append_len(obj->key, obj->keylen, func->ud); } if (obj->type != UCL_OBJECT && obj->type != UCL_ARRAY) { - func->ucl_emitter_append_len (" = ", 3, func->ud); + func->ucl_emitter_append_len(" = ", 3, func->ud); } else { - func->ucl_emitter_append_character (' ', 1, func->ud); + func->ucl_emitter_append_character(' ', 1, func->ud); } } else if (ctx->id == UCL_EMIT_YAML) { if (obj->keylen > 0 && (obj->flags & UCL_OBJECT_NEED_KEY_ESCAPE)) { - ucl_elt_string_write_json (obj->key, obj->keylen, ctx); + ucl_elt_string_write_json(obj->key, obj->keylen, ctx); } else if (obj->keylen > 0) { - func->ucl_emitter_append_len (obj->key, obj->keylen, func->ud); + func->ucl_emitter_append_len(obj->key, obj->keylen, func->ud); } else { - func->ucl_emitter_append_len ("null", 4, func->ud); + func->ucl_emitter_append_len("null", 4, func->ud); } - func->ucl_emitter_append_len (": ", 2, func->ud); + func->ucl_emitter_append_len(": ", 2, func->ud); } else { if (obj->keylen > 0) { - ucl_elt_string_write_json (obj->key, obj->keylen, ctx); + ucl_elt_string_write_json(obj->key, obj->keylen, ctx); } else { - func->ucl_emitter_append_len ("null", 4, func->ud); + func->ucl_emitter_append_len("null", 4, func->ud); } if (compact) { - func->ucl_emitter_append_character (':', 1, func->ud); + func->ucl_emitter_append_character(':', 1, func->ud); } else { - func->ucl_emitter_append_len (": ", 2, func->ud); + func->ucl_emitter_append_len(": ", 2, func->ud); } } } static void -ucl_emitter_finish_object (struct ucl_emitter_context *ctx, - const ucl_object_t *obj, bool compact, bool is_array) +ucl_emitter_finish_object(struct ucl_emitter_context *ctx, + const ucl_object_t *obj, bool compact, bool is_array) { const struct ucl_emitter_functions *func = ctx->func; @@ -171,15 +169,15 @@ ucl_emitter_finish_object (struct ucl_emitter_context *ctx, if (obj->type != UCL_OBJECT && obj->type != UCL_ARRAY) { if (!is_array) { /* Objects are split by ';' */ - func->ucl_emitter_append_len (";\n", 2, func->ud); + func->ucl_emitter_append_len(";\n", 2, func->ud); } else { /* Use commas for arrays */ - func->ucl_emitter_append_len (",\n", 2, func->ud); + func->ucl_emitter_append_len(",\n", 2, func->ud); } } else { - func->ucl_emitter_append_character ('\n', 1, func->ud); + func->ucl_emitter_append_character('\n', 1, func->ud); } } } @@ -190,27 +188,27 @@ ucl_emitter_finish_object (struct ucl_emitter_context *ctx, * @param compact compact flag */ static void -ucl_emitter_common_end_object (struct ucl_emitter_context *ctx, - const ucl_object_t *obj, bool compact) +ucl_emitter_common_end_object(struct ucl_emitter_context *ctx, + const ucl_object_t *obj, bool compact) { const struct ucl_emitter_functions *func = ctx->func; if (UCL_EMIT_IDENT_TOP_OBJ(ctx, obj)) { - ctx->indent --; + ctx->indent--; if (compact) { - func->ucl_emitter_append_character ('}', 1, func->ud); + func->ucl_emitter_append_character('}', 1, func->ud); } else { if (ctx->id != UCL_EMIT_CONFIG) { /* newline is already added for this format */ - func->ucl_emitter_append_character ('\n', 1, func->ud); + func->ucl_emitter_append_character('\n', 1, func->ud); } - ucl_add_tabs (func, ctx->indent, compact); - func->ucl_emitter_append_character ('}', 1, func->ud); + ucl_add_tabs(func, ctx->indent, compact); + func->ucl_emitter_append_character('}', 1, func->ud); } } - ucl_emitter_finish_object (ctx, obj, compact, false); + ucl_emitter_finish_object(ctx, obj, compact, false); } /** @@ -219,25 +217,25 @@ ucl_emitter_common_end_object (struct ucl_emitter_context *ctx, * @param compact compact flag */ static void -ucl_emitter_common_end_array (struct ucl_emitter_context *ctx, - const ucl_object_t *obj, bool compact) +ucl_emitter_common_end_array(struct ucl_emitter_context *ctx, + const ucl_object_t *obj, bool compact) { const struct ucl_emitter_functions *func = ctx->func; - ctx->indent --; + ctx->indent--; if (compact) { - func->ucl_emitter_append_character (']', 1, func->ud); + func->ucl_emitter_append_character(']', 1, func->ud); } else { if (ctx->id != UCL_EMIT_CONFIG) { /* newline is already added for this format */ - func->ucl_emitter_append_character ('\n', 1, func->ud); + func->ucl_emitter_append_character('\n', 1, func->ud); } - ucl_add_tabs (func, ctx->indent, compact); - func->ucl_emitter_append_character (']', 1, func->ud); + ucl_add_tabs(func, ctx->indent, compact); + func->ucl_emitter_append_character(']', 1, func->ud); } - ucl_emitter_finish_object (ctx, obj, compact, true); + ucl_emitter_finish_object(ctx, obj, compact, true); } /** @@ -247,8 +245,8 @@ ucl_emitter_common_end_array (struct ucl_emitter_context *ctx, * @param compact compact flag */ static void -ucl_emitter_common_start_array (struct ucl_emitter_context *ctx, - const ucl_object_t *obj, bool first, bool print_key, bool compact) +ucl_emitter_common_start_array(struct ucl_emitter_context *ctx, + const ucl_object_t *obj, bool first, bool print_key, bool compact) { const ucl_object_t *cur; ucl_object_iter_t iter = NULL; @@ -257,33 +255,34 @@ ucl_emitter_common_start_array (struct ucl_emitter_context *ctx, if (ctx->id != UCL_EMIT_CONFIG && !first) { if (compact) { - func->ucl_emitter_append_character (',', 1, func->ud); + func->ucl_emitter_append_character(',', 1, func->ud); } else { if (ctx->id == UCL_EMIT_YAML && ctx->indent == 0) { - func->ucl_emitter_append_len ("\n", 1, func->ud); - } else { - func->ucl_emitter_append_len (",\n", 2, func->ud); + func->ucl_emitter_append_len("\n", 1, func->ud); + } + else { + func->ucl_emitter_append_len(",\n", 2, func->ud); } } - ucl_add_tabs (func, ctx->indent, compact); + ucl_add_tabs(func, ctx->indent, compact); } - ucl_emitter_print_key (print_key, ctx, obj, compact); + ucl_emitter_print_key(print_key, ctx, obj, compact); if (compact) { - func->ucl_emitter_append_character ('[', 1, func->ud); + func->ucl_emitter_append_character('[', 1, func->ud); } else { - func->ucl_emitter_append_len ("[\n", 2, func->ud); + func->ucl_emitter_append_len("[\n", 2, func->ud); } - ctx->indent ++; + ctx->indent++; if (obj->type == UCL_ARRAY) { /* explicit array */ - while ((cur = ucl_object_iterate (obj, &iter, true)) != NULL) { - ucl_emitter_common_elt (ctx, cur, first_key, false, compact); + while ((cur = ucl_object_iterate(obj, &iter, true)) != NULL) { + ucl_emitter_common_elt(ctx, cur, first_key, false, compact); first_key = false; } } @@ -291,13 +290,11 @@ ucl_emitter_common_start_array (struct ucl_emitter_context *ctx, /* implicit array */ cur = obj; while (cur) { - ucl_emitter_common_elt (ctx, cur, first_key, false, compact); + ucl_emitter_common_elt(ctx, cur, first_key, false, compact); first_key = false; cur = cur->next; } } - - } /** @@ -307,8 +304,8 @@ ucl_emitter_common_start_array (struct ucl_emitter_context *ctx, * @param compact compact flag */ static void -ucl_emitter_common_start_object (struct ucl_emitter_context *ctx, - const ucl_object_t *obj, bool first, bool print_key, bool compact) +ucl_emitter_common_start_object(struct ucl_emitter_context *ctx, + const ucl_object_t *obj, bool first, bool print_key, bool compact) { ucl_hash_iter_t it = NULL; const ucl_object_t *cur, *elt; @@ -317,57 +314,53 @@ ucl_emitter_common_start_object (struct ucl_emitter_context *ctx, if (ctx->id != UCL_EMIT_CONFIG && !first) { if (compact) { - func->ucl_emitter_append_character (',', 1, func->ud); + func->ucl_emitter_append_character(',', 1, func->ud); } else { if (ctx->id == UCL_EMIT_YAML && ctx->indent == 0) { - func->ucl_emitter_append_len ("\n", 1, func->ud); - } else { - func->ucl_emitter_append_len (",\n", 2, func->ud); + func->ucl_emitter_append_len("\n", 1, func->ud); + } + else { + func->ucl_emitter_append_len(",\n", 2, func->ud); } } - ucl_add_tabs (func, ctx->indent, compact); + ucl_add_tabs(func, ctx->indent, compact); } - ucl_emitter_print_key (print_key, ctx, obj, compact); + ucl_emitter_print_key(print_key, ctx, obj, compact); /* * Print { * */ if (UCL_EMIT_IDENT_TOP_OBJ(ctx, obj)) { if (compact) { - func->ucl_emitter_append_character ('{', 1, func->ud); + func->ucl_emitter_append_character('{', 1, func->ud); } else { - func->ucl_emitter_append_len ("{\n", 2, func->ud); + func->ucl_emitter_append_len("{\n", 2, func->ud); } - ctx->indent ++; + ctx->indent++; } - while ((cur = ucl_hash_iterate (obj->value.ov, &it))) { + while ((cur = ucl_hash_iterate(obj->value.ov, &it))) { if (ctx->id == UCL_EMIT_CONFIG) { - LL_FOREACH (cur, elt) { - ucl_emitter_common_elt (ctx, elt, first_key, true, compact); + LL_FOREACH(cur, elt) + { + ucl_emitter_common_elt(ctx, elt, first_key, true, compact); } } else { /* Expand implicit arrays */ if (cur->next != NULL) { - if (!first_key) { - if (compact) { - func->ucl_emitter_append_character (',', 1, func->ud); - } - else { - func->ucl_emitter_append_len (",\n", 2, func->ud); - } + if (first_key) { + ucl_add_tabs(func, ctx->indent, compact); } - ucl_add_tabs (func, ctx->indent, compact); - ucl_emitter_common_start_array (ctx, cur, first_key, true, compact); - ucl_emitter_common_end_array (ctx, cur, compact); + ucl_emitter_common_start_array(ctx, cur, first_key, true, compact); + ucl_emitter_common_end_array(ctx, cur, compact); } else { - ucl_emitter_common_elt (ctx, cur, first_key, true, compact); + ucl_emitter_common_elt(ctx, cur, first_key, true, compact); } } @@ -384,8 +377,8 @@ ucl_emitter_common_start_object (struct ucl_emitter_context *ctx, * @param compact compact output */ static void -ucl_emitter_common_elt (struct ucl_emitter_context *ctx, - const ucl_object_t *obj, bool first, bool print_key, bool compact) +ucl_emitter_common_elt(struct ucl_emitter_context *ctx, + const ucl_object_t *obj, bool first, bool print_key, bool compact) { const struct ucl_emitter_functions *func = ctx->func; bool flag; @@ -395,31 +388,33 @@ ucl_emitter_common_elt (struct ucl_emitter_context *ctx, if (ctx->id != UCL_EMIT_CONFIG && !first) { if (compact) { - func->ucl_emitter_append_character (',', 1, func->ud); + func->ucl_emitter_append_character(',', 1, func->ud); } else { if (ctx->id == UCL_EMIT_YAML && ctx->indent == 0) { - func->ucl_emitter_append_len ("\n", 1, func->ud); - } else { - func->ucl_emitter_append_len (",\n", 2, func->ud); + func->ucl_emitter_append_len("\n", 1, func->ud); + } + else { + func->ucl_emitter_append_len(",\n", 2, func->ud); } } } - ucl_add_tabs (func, ctx->indent, compact); + ucl_add_tabs(func, ctx->indent, compact); if (ctx->comments && ctx->id == UCL_EMIT_CONFIG) { - comment = ucl_object_lookup_len (ctx->comments, (const char *)&obj, - sizeof (void *)); + comment = ucl_object_lookup_len(ctx->comments, (const char *) &obj, + sizeof(void *)); if (comment) { if (!(comment->flags & UCL_OBJECT_INHERITED)) { - DL_FOREACH (comment, cur_comment) { - func->ucl_emitter_append_len (cur_comment->value.sv, - cur_comment->len, - func->ud); - func->ucl_emitter_append_character ('\n', 1, func->ud); - ucl_add_tabs (func, ctx->indent, compact); + DL_FOREACH(comment, cur_comment) + { + func->ucl_emitter_append_len(cur_comment->value.sv, + cur_comment->len, + func->ud); + func->ucl_emitter_append_character('\n', 1, func->ud); + ucl_add_tabs(func, ctx->indent, compact); } comment = NULL; @@ -429,81 +424,84 @@ ucl_emitter_common_elt (struct ucl_emitter_context *ctx, switch (obj->type) { case UCL_INT: - ucl_emitter_print_key (print_key, ctx, obj, compact); - func->ucl_emitter_append_int (ucl_object_toint (obj), func->ud); - ucl_emitter_finish_object (ctx, obj, compact, !print_key); + ucl_emitter_print_key(print_key, ctx, obj, compact); + func->ucl_emitter_append_int(ucl_object_toint(obj), func->ud); + ucl_emitter_finish_object(ctx, obj, compact, !print_key); break; case UCL_FLOAT: case UCL_TIME: - ucl_emitter_print_key (print_key, ctx, obj, compact); - func->ucl_emitter_append_double (ucl_object_todouble (obj), func->ud); - ucl_emitter_finish_object (ctx, obj, compact, !print_key); + ucl_emitter_print_key(print_key, ctx, obj, compact); + func->ucl_emitter_append_double(ucl_object_todouble(obj), func->ud); + ucl_emitter_finish_object(ctx, obj, compact, !print_key); break; case UCL_BOOLEAN: - ucl_emitter_print_key (print_key, ctx, obj, compact); - flag = ucl_object_toboolean (obj); + ucl_emitter_print_key(print_key, ctx, obj, compact); + flag = ucl_object_toboolean(obj); if (flag) { - func->ucl_emitter_append_len ("true", 4, func->ud); + func->ucl_emitter_append_len("true", 4, func->ud); } else { - func->ucl_emitter_append_len ("false", 5, func->ud); + func->ucl_emitter_append_len("false", 5, func->ud); } - ucl_emitter_finish_object (ctx, obj, compact, !print_key); + ucl_emitter_finish_object(ctx, obj, compact, !print_key); break; case UCL_STRING: - ucl_emitter_print_key (print_key, ctx, obj, compact); + ucl_emitter_print_key(print_key, ctx, obj, compact); if (ctx->id == UCL_EMIT_CONFIG) { - if (ucl_maybe_long_string (obj)) { - ucl_elt_string_write_multiline (obj->value.sv, obj->len, ctx); - } else { + if (ucl_maybe_long_string(obj)) { + ucl_elt_string_write_multiline(obj->value.sv, obj->len, ctx); + } + else { if (obj->flags & UCL_OBJECT_SQUOTED) { - ucl_elt_string_write_squoted (obj->value.sv, obj->len, ctx); - } else { - ucl_elt_string_write_json (obj->value.sv, obj->len, ctx); + ucl_elt_string_write_squoted(obj->value.sv, obj->len, ctx); + } + else { + ucl_elt_string_write_json(obj->value.sv, obj->len, ctx); } } } else { - ucl_elt_string_write_json (obj->value.sv, obj->len, ctx); + ucl_elt_string_write_json(obj->value.sv, obj->len, ctx); } - ucl_emitter_finish_object (ctx, obj, compact, !print_key); + ucl_emitter_finish_object(ctx, obj, compact, !print_key); break; case UCL_NULL: - ucl_emitter_print_key (print_key, ctx, obj, compact); - func->ucl_emitter_append_len ("null", 4, func->ud); - ucl_emitter_finish_object (ctx, obj, compact, !print_key); + ucl_emitter_print_key(print_key, ctx, obj, compact); + func->ucl_emitter_append_len("null", 4, func->ud); + ucl_emitter_finish_object(ctx, obj, compact, !print_key); break; case UCL_OBJECT: - ucl_emitter_common_start_object (ctx, obj, true, print_key, compact); - ucl_emitter_common_end_object (ctx, obj, compact); + ucl_emitter_common_start_object(ctx, obj, true, print_key, compact); + ucl_emitter_common_end_object(ctx, obj, compact); break; case UCL_ARRAY: - ucl_emitter_common_start_array (ctx, obj, true, print_key, compact); - ucl_emitter_common_end_array (ctx, obj, compact); + ucl_emitter_common_start_array(ctx, obj, true, print_key, compact); + ucl_emitter_common_end_array(ctx, obj, compact); break; case UCL_USERDATA: - ud = (struct ucl_object_userdata *)obj; - ucl_emitter_print_key (print_key, ctx, obj, compact); + ud = (struct ucl_object_userdata *) obj; + ucl_emitter_print_key(print_key, ctx, obj, compact); if (ud->emitter) { - ud_out = ud->emitter (obj->value.ud); + ud_out = ud->emitter(obj->value.ud); if (ud_out == NULL) { ud_out = "null"; } } - ucl_elt_string_write_json (ud_out, strlen (ud_out), ctx); - ucl_emitter_finish_object (ctx, obj, compact, !print_key); + ucl_elt_string_write_json(ud_out, strlen(ud_out), ctx); + ucl_emitter_finish_object(ctx, obj, compact, !print_key); break; } if (comment) { - DL_FOREACH (comment, cur_comment) { - func->ucl_emitter_append_len (cur_comment->value.sv, - cur_comment->len, - func->ud); - func->ucl_emitter_append_character ('\n', 1, func->ud); + DL_FOREACH(comment, cur_comment) + { + func->ucl_emitter_append_len(cur_comment->value.sv, + cur_comment->len, + func->ud); + func->ucl_emitter_append_character('\n', 1, func->ud); if (cur_comment->next) { - ucl_add_tabs (func, ctx->indent, compact); + ucl_add_tabs(func, ctx->indent, compact); } } } @@ -512,26 +510,31 @@ ucl_emitter_common_elt (struct ucl_emitter_context *ctx, /* * Specific standard implementations of the emitter functions */ -#define UCL_EMIT_TYPE_IMPL(type, compact) \ - static void ucl_emit_ ## type ## _elt (struct ucl_emitter_context *ctx, \ - const ucl_object_t *obj, bool first, bool print_key) { \ - ucl_emitter_common_elt (ctx, obj, first, print_key, (compact)); \ - } \ - static void ucl_emit_ ## type ## _start_obj (struct ucl_emitter_context *ctx, \ - const ucl_object_t *obj, bool first, bool print_key) { \ - ucl_emitter_common_start_object (ctx, obj, first, print_key, (compact)); \ - } \ - static void ucl_emit_ ## type## _start_array (struct ucl_emitter_context *ctx, \ - const ucl_object_t *obj, bool first, bool print_key) { \ - ucl_emitter_common_start_array (ctx, obj, first, print_key, (compact)); \ - } \ - static void ucl_emit_ ##type## _end_object (struct ucl_emitter_context *ctx, \ - const ucl_object_t *obj) { \ - ucl_emitter_common_end_object (ctx, obj, (compact)); \ - } \ - static void ucl_emit_ ##type## _end_array (struct ucl_emitter_context *ctx, \ - const ucl_object_t *obj) { \ - ucl_emitter_common_end_array (ctx, obj, (compact)); \ +#define UCL_EMIT_TYPE_IMPL(type, compact) \ + static void ucl_emit_##type##_elt(struct ucl_emitter_context *ctx, \ + const ucl_object_t *obj, bool first, bool print_key) \ + { \ + ucl_emitter_common_elt(ctx, obj, first, print_key, (compact)); \ + } \ + static void ucl_emit_##type##_start_obj(struct ucl_emitter_context *ctx, \ + const ucl_object_t *obj, bool first, bool print_key) \ + { \ + ucl_emitter_common_start_object(ctx, obj, first, print_key, (compact)); \ + } \ + static void ucl_emit_##type##_start_array(struct ucl_emitter_context *ctx, \ + const ucl_object_t *obj, bool first, bool print_key) \ + { \ + ucl_emitter_common_start_array(ctx, obj, first, print_key, (compact)); \ + } \ + static void ucl_emit_##type##_end_object(struct ucl_emitter_context *ctx, \ + const ucl_object_t *obj) \ + { \ + ucl_emitter_common_end_object(ctx, obj, (compact)); \ + } \ + static void ucl_emit_##type##_end_array(struct ucl_emitter_context *ctx, \ + const ucl_object_t *obj) \ + { \ + ucl_emitter_common_end_array(ctx, obj, (compact)); \ } UCL_EMIT_TYPE_IMPL(json, false) @@ -540,8 +543,8 @@ UCL_EMIT_TYPE_IMPL(config, false) UCL_EMIT_TYPE_IMPL(yaml, false) static void -ucl_emit_msgpack_elt (struct ucl_emitter_context *ctx, - const ucl_object_t *obj, bool _first, bool print_key) +ucl_emit_msgpack_elt(struct ucl_emitter_context *ctx, + const ucl_object_t *obj, bool _first, bool print_key) { ucl_object_iter_t it; struct ucl_object_userdata *ud; @@ -550,46 +553,47 @@ ucl_emit_msgpack_elt (struct ucl_emitter_context *ctx, switch (obj->type) { case UCL_INT: - ucl_emitter_print_key_msgpack (print_key, ctx, obj); - ucl_emitter_print_int_msgpack (ctx, ucl_object_toint (obj)); + ucl_emitter_print_key_msgpack(print_key, ctx, obj); + ucl_emitter_print_int_msgpack(ctx, ucl_object_toint(obj)); break; case UCL_FLOAT: case UCL_TIME: - ucl_emitter_print_key_msgpack (print_key, ctx, obj); - ucl_emitter_print_double_msgpack (ctx, ucl_object_todouble (obj)); + ucl_emitter_print_key_msgpack(print_key, ctx, obj); + ucl_emitter_print_double_msgpack(ctx, ucl_object_todouble(obj)); break; case UCL_BOOLEAN: - ucl_emitter_print_key_msgpack (print_key, ctx, obj); - ucl_emitter_print_bool_msgpack (ctx, ucl_object_toboolean (obj)); + ucl_emitter_print_key_msgpack(print_key, ctx, obj); + ucl_emitter_print_bool_msgpack(ctx, ucl_object_toboolean(obj)); break; case UCL_STRING: - ucl_emitter_print_key_msgpack (print_key, ctx, obj); + ucl_emitter_print_key_msgpack(print_key, ctx, obj); if (obj->flags & UCL_OBJECT_BINARY) { - ucl_emitter_print_binary_string_msgpack (ctx, obj->value.sv, - obj->len); + ucl_emitter_print_binary_string_msgpack(ctx, obj->value.sv, + obj->len); } else { - ucl_emitter_print_string_msgpack (ctx, obj->value.sv, obj->len); + ucl_emitter_print_string_msgpack(ctx, obj->value.sv, obj->len); } break; case UCL_NULL: - ucl_emitter_print_key_msgpack (print_key, ctx, obj); - ucl_emitter_print_null_msgpack (ctx); + ucl_emitter_print_key_msgpack(print_key, ctx, obj); + ucl_emitter_print_null_msgpack(ctx); break; case UCL_OBJECT: - ucl_emitter_print_key_msgpack (print_key, ctx, obj); - ucl_emit_msgpack_start_obj (ctx, obj, false, print_key); + ucl_emitter_print_key_msgpack(print_key, ctx, obj); + ucl_emit_msgpack_start_obj(ctx, obj, false, print_key); it = NULL; - while ((cur = ucl_object_iterate (obj, &it, true)) != NULL) { - LL_FOREACH (cur, celt) { - ucl_emit_msgpack_elt (ctx, celt, false, true); + while ((cur = ucl_object_iterate(obj, &it, true)) != NULL) { + LL_FOREACH(cur, celt) + { + ucl_emit_msgpack_elt(ctx, celt, false, true); /* XXX: * in msgpack the length of objects is encoded within a single elt * so in case of multi-value keys we are using merely the first @@ -602,68 +606,66 @@ ucl_emit_msgpack_elt (struct ucl_emitter_context *ctx, break; case UCL_ARRAY: - ucl_emitter_print_key_msgpack (print_key, ctx, obj); - ucl_emit_msgpack_start_array (ctx, obj, false, print_key); + ucl_emitter_print_key_msgpack(print_key, ctx, obj); + ucl_emit_msgpack_start_array(ctx, obj, false, print_key); it = NULL; - while ((cur = ucl_object_iterate (obj, &it, true)) != NULL) { - ucl_emit_msgpack_elt (ctx, cur, false, false); + while ((cur = ucl_object_iterate(obj, &it, true)) != NULL) { + ucl_emit_msgpack_elt(ctx, cur, false, false); } break; case UCL_USERDATA: - ud = (struct ucl_object_userdata *)obj; - ucl_emitter_print_key_msgpack (print_key, ctx, obj); + ud = (struct ucl_object_userdata *) obj; + ucl_emitter_print_key_msgpack(print_key, ctx, obj); if (ud->emitter) { - ud_out = ud->emitter (obj->value.ud); + ud_out = ud->emitter(obj->value.ud); if (ud_out == NULL) { ud_out = "null"; } } - ucl_emitter_print_string_msgpack (ctx, obj->value.sv, obj->len); + ucl_emitter_print_string_msgpack(ctx, obj->value.sv, obj->len); break; } } static void -ucl_emit_msgpack_start_obj (struct ucl_emitter_context *ctx, - const ucl_object_t *obj, bool _first, bool _print_key) +ucl_emit_msgpack_start_obj(struct ucl_emitter_context *ctx, + const ucl_object_t *obj, bool _first, bool _print_key) { - ucl_emitter_print_object_msgpack (ctx, obj->len); + ucl_emitter_print_object_msgpack(ctx, obj->len); } static void -ucl_emit_msgpack_start_array (struct ucl_emitter_context *ctx, - const ucl_object_t *obj, bool _first, bool _print_key) +ucl_emit_msgpack_start_array(struct ucl_emitter_context *ctx, + const ucl_object_t *obj, bool _first, bool _print_key) { - ucl_emitter_print_array_msgpack (ctx, obj->len); + ucl_emitter_print_array_msgpack(ctx, obj->len); } static void -ucl_emit_msgpack_end_object (struct ucl_emitter_context *ctx, - const ucl_object_t *obj) +ucl_emit_msgpack_end_object(struct ucl_emitter_context *ctx, + const ucl_object_t *obj) { - } static void -ucl_emit_msgpack_end_array (struct ucl_emitter_context *ctx, - const ucl_object_t *obj) +ucl_emit_msgpack_end_array(struct ucl_emitter_context *ctx, + const ucl_object_t *obj) { - } unsigned char * -ucl_object_emit (const ucl_object_t *obj, enum ucl_emitter emit_type) +ucl_object_emit(const ucl_object_t *obj, enum ucl_emitter emit_type) { - return ucl_object_emit_len (obj, emit_type, NULL); + return ucl_object_emit_len(obj, emit_type, NULL); } unsigned char * -ucl_object_emit_len (const ucl_object_t *obj, enum ucl_emitter emit_type, - size_t *outlen) +ucl_object_emit_len(const ucl_object_t *obj, enum ucl_emitter emit_type, + size_t *outlen) { unsigned char *res = NULL; struct ucl_emitter_functions *func; @@ -673,40 +675,39 @@ ucl_object_emit_len (const ucl_object_t *obj, enum ucl_emitter emit_type, return NULL; } - func = ucl_object_emit_memory_funcs ((void **)&res); + func = ucl_object_emit_memory_funcs((void **) &res); if (func != NULL) { s = func->ud; - ucl_object_emit_full (obj, emit_type, func, NULL); + ucl_object_emit_full(obj, emit_type, func, NULL); if (outlen != NULL) { *outlen = s->i; } - ucl_object_emit_funcs_free (func); + ucl_object_emit_funcs_free(func); } return res; } -bool -ucl_object_emit_full (const ucl_object_t *obj, enum ucl_emitter emit_type, - struct ucl_emitter_functions *emitter, - const ucl_object_t *comments) +bool ucl_object_emit_full(const ucl_object_t *obj, enum ucl_emitter emit_type, + struct ucl_emitter_functions *emitter, + const ucl_object_t *comments) { const struct ucl_emitter_context *ctx; struct ucl_emitter_context my_ctx; bool res = false; - ctx = ucl_emit_get_standard_context (emit_type); + ctx = ucl_emit_get_standard_context(emit_type); if (ctx != NULL) { - memcpy (&my_ctx, ctx, sizeof (my_ctx)); + memcpy(&my_ctx, ctx, sizeof(my_ctx)); my_ctx.func = emitter; my_ctx.indent = 0; my_ctx.top = obj; my_ctx.comments = comments; - my_ctx.ops->ucl_emitter_write_elt (&my_ctx, obj, true, false); + my_ctx.ops->ucl_emitter_write_elt(&my_ctx, obj, true, false); res = true; } diff --git a/src/ucl_emitter_streamline.c b/src/ucl_emitter_streamline.c index 8ca86fa081c9..1da1b7c5b14c 100644 --- a/src/ucl_emitter_streamline.c +++ b/src/ucl_emitter_streamline.c @@ -57,39 +57,38 @@ struct ucl_emitter_context_streamline { struct ucl_emitter_streamline_stack *containers; }; -#define TO_STREAMLINE(ctx) (struct ucl_emitter_context_streamline *)(ctx) +#define TO_STREAMLINE(ctx) (struct ucl_emitter_context_streamline *) (ctx) -struct ucl_emitter_context* -ucl_object_emit_streamline_new (const ucl_object_t *obj, - enum ucl_emitter emit_type, - struct ucl_emitter_functions *emitter) +struct ucl_emitter_context * +ucl_object_emit_streamline_new(const ucl_object_t *obj, + enum ucl_emitter emit_type, + struct ucl_emitter_functions *emitter) { const struct ucl_emitter_context *ctx; struct ucl_emitter_context_streamline *sctx; - ctx = ucl_emit_get_standard_context (emit_type); + ctx = ucl_emit_get_standard_context(emit_type); if (ctx == NULL) { return NULL; } - sctx = calloc (1, sizeof (*sctx)); + sctx = calloc(1, sizeof(*sctx)); if (sctx == NULL) { return NULL; } - memcpy (sctx, ctx, sizeof (*ctx)); + memcpy(sctx, ctx, sizeof(*ctx)); sctx->func = emitter; sctx->top = obj; - ucl_object_emit_streamline_start_container ((struct ucl_emitter_context *)sctx, - obj); + ucl_object_emit_streamline_start_container((struct ucl_emitter_context *) sctx, + obj); - return (struct ucl_emitter_context *)sctx; + return (struct ucl_emitter_context *) sctx; } -void -ucl_object_emit_streamline_start_container (struct ucl_emitter_context *ctx, - const ucl_object_t *obj) +bool ucl_object_emit_streamline_start_container(struct ucl_emitter_context *ctx, + const ucl_object_t *obj) { struct ucl_emitter_context_streamline *sctx = TO_STREAMLINE(ctx); struct ucl_emitter_streamline_stack *st, *top; @@ -101,7 +100,7 @@ ucl_object_emit_streamline_start_container (struct ucl_emitter_context *ctx, } top = sctx->containers; - st = malloc (sizeof (*st)); + st = malloc(sizeof(*st)); if (st != NULL) { st->empty = true; if (top && !top->is_array) { @@ -111,19 +110,26 @@ ucl_object_emit_streamline_start_container (struct ucl_emitter_context *ctx, st->obj = obj; if (obj != NULL && obj->type == UCL_ARRAY) { st->is_array = true; - sctx->ops->ucl_emitter_start_array (ctx, obj, top == NULL, print_key); + sctx->ops->ucl_emitter_start_array(ctx, obj, top == NULL, print_key); } - else { + else if (obj != NULL && obj->type == UCL_OBJECT) { st->is_array = false; - sctx->ops->ucl_emitter_start_object (ctx, obj, top == NULL, print_key); + sctx->ops->ucl_emitter_start_object(ctx, obj, top == NULL, print_key); } - LL_PREPEND (sctx->containers, st); + else { + /* API MISUSE */ + free(st); + + return false; + } + LL_PREPEND(sctx->containers, st); } + + return true; } -void -ucl_object_emit_streamline_add_object ( - struct ucl_emitter_context *ctx, const ucl_object_t *obj) +void ucl_object_emit_streamline_add_object( + struct ucl_emitter_context *ctx, const ucl_object_t *obj) { struct ucl_emitter_context_streamline *sctx = TO_STREAMLINE(ctx); bool is_array = false, is_first = false; @@ -138,11 +144,10 @@ ucl_object_emit_streamline_add_object ( } } - sctx->ops->ucl_emitter_write_elt (ctx, obj, is_first, !is_array); + sctx->ops->ucl_emitter_write_elt(ctx, obj, is_first, !is_array); } -void -ucl_object_emit_streamline_end_container (struct ucl_emitter_context *ctx) +void ucl_object_emit_streamline_end_container(struct ucl_emitter_context *ctx) { struct ucl_emitter_context_streamline *sctx = TO_STREAMLINE(ctx); struct ucl_emitter_streamline_stack *st; @@ -151,24 +156,23 @@ ucl_object_emit_streamline_end_container (struct ucl_emitter_context *ctx) st = sctx->containers; if (st->is_array) { - sctx->ops->ucl_emitter_end_array (ctx, st->obj); + sctx->ops->ucl_emitter_end_array(ctx, st->obj); } else { - sctx->ops->ucl_emitter_end_object (ctx, st->obj); + sctx->ops->ucl_emitter_end_object(ctx, st->obj); } sctx->containers = st->next; - free (st); + free(st); } } -void -ucl_object_emit_streamline_finish (struct ucl_emitter_context *ctx) +void ucl_object_emit_streamline_finish(struct ucl_emitter_context *ctx) { struct ucl_emitter_context_streamline *sctx = TO_STREAMLINE(ctx); while (sctx->containers != NULL) { - ucl_object_emit_streamline_end_container (ctx); + ucl_object_emit_streamline_end_container(ctx); } - free (sctx); + free(sctx); } diff --git a/src/ucl_emitter_utils.c b/src/ucl_emitter_utils.c index b9f7de8f0224..7f966228bba2 100644 --- a/src/ucl_emitter_utils.c +++ b/src/ucl_emitter_utils.c @@ -43,39 +43,17 @@ static const struct ucl_emitter_context ucl_standard_emitters[] = { .name = "json", .id = UCL_EMIT_JSON, .func = NULL, - .ops = &ucl_standartd_emitter_ops[UCL_EMIT_JSON] - }, - [UCL_EMIT_JSON_COMPACT] = { - .name = "json_compact", - .id = UCL_EMIT_JSON_COMPACT, - .func = NULL, - .ops = &ucl_standartd_emitter_ops[UCL_EMIT_JSON_COMPACT] - }, - [UCL_EMIT_CONFIG] = { - .name = "config", - .id = UCL_EMIT_CONFIG, - .func = NULL, - .ops = &ucl_standartd_emitter_ops[UCL_EMIT_CONFIG] - }, - [UCL_EMIT_YAML] = { - .name = "yaml", - .id = UCL_EMIT_YAML, - .func = NULL, - .ops = &ucl_standartd_emitter_ops[UCL_EMIT_YAML] - }, - [UCL_EMIT_MSGPACK] = { - .name = "msgpack", - .id = UCL_EMIT_MSGPACK, - .func = NULL, - .ops = &ucl_standartd_emitter_ops[UCL_EMIT_MSGPACK] - } -}; + .ops = &ucl_standartd_emitter_ops[UCL_EMIT_JSON]}, + [UCL_EMIT_JSON_COMPACT] = {.name = "json_compact", .id = UCL_EMIT_JSON_COMPACT, .func = NULL, .ops = &ucl_standartd_emitter_ops[UCL_EMIT_JSON_COMPACT]}, + [UCL_EMIT_CONFIG] = {.name = "config", .id = UCL_EMIT_CONFIG, .func = NULL, .ops = &ucl_standartd_emitter_ops[UCL_EMIT_CONFIG]}, + [UCL_EMIT_YAML] = {.name = "yaml", .id = UCL_EMIT_YAML, .func = NULL, .ops = &ucl_standartd_emitter_ops[UCL_EMIT_YAML]}, + [UCL_EMIT_MSGPACK] = {.name = "msgpack", .id = UCL_EMIT_MSGPACK, .func = NULL, .ops = &ucl_standartd_emitter_ops[UCL_EMIT_MSGPACK]}}; static inline void _ucl_emitter_free(void *p) { - free(p); + free(p); } /** @@ -84,7 +62,7 @@ _ucl_emitter_free(void *p) * @return context or NULL if input is invalid */ const struct ucl_emitter_context * -ucl_emit_get_standard_context (enum ucl_emitter emit_type) +ucl_emit_get_standard_context(enum ucl_emitter emit_type) { if (emit_type >= UCL_EMIT_JSON && emit_type < UCL_EMIT_MAX) { return &ucl_standard_emitters[emit_type]; @@ -98,132 +76,129 @@ ucl_emit_get_standard_context (enum ucl_emitter emit_type) * @param str string to emit * @param buf target buffer */ -void -ucl_elt_string_write_json (const char *str, size_t size, - struct ucl_emitter_context *ctx) +void ucl_elt_string_write_json(const char *str, size_t size, + struct ucl_emitter_context *ctx) { const char *p = str, *c = str; size_t len = 0; const struct ucl_emitter_functions *func = ctx->func; - func->ucl_emitter_append_character ('"', 1, func->ud); + func->ucl_emitter_append_character('"', 1, func->ud); while (size) { - if (ucl_test_character (*p, (UCL_CHARACTER_JSON_UNSAFE| - UCL_CHARACTER_DENIED| - UCL_CHARACTER_WHITESPACE_UNSAFE))) { + if (ucl_test_character(*p, (UCL_CHARACTER_JSON_UNSAFE | + UCL_CHARACTER_DENIED | + UCL_CHARACTER_WHITESPACE_UNSAFE))) { if (len > 0) { - func->ucl_emitter_append_len (c, len, func->ud); + func->ucl_emitter_append_len(c, len, func->ud); } switch (*p) { case '\n': - func->ucl_emitter_append_len ("\\n", 2, func->ud); + func->ucl_emitter_append_len("\\n", 2, func->ud); break; case '\r': - func->ucl_emitter_append_len ("\\r", 2, func->ud); + func->ucl_emitter_append_len("\\r", 2, func->ud); break; case '\b': - func->ucl_emitter_append_len ("\\b", 2, func->ud); + func->ucl_emitter_append_len("\\b", 2, func->ud); break; case '\t': - func->ucl_emitter_append_len ("\\t", 2, func->ud); + func->ucl_emitter_append_len("\\t", 2, func->ud); break; case '\f': - func->ucl_emitter_append_len ("\\f", 2, func->ud); + func->ucl_emitter_append_len("\\f", 2, func->ud); break; case '\v': - func->ucl_emitter_append_len ("\\u000B", 6, func->ud); + func->ucl_emitter_append_len("\\u000B", 6, func->ud); break; case '\\': - func->ucl_emitter_append_len ("\\\\", 2, func->ud); + func->ucl_emitter_append_len("\\\\", 2, func->ud); break; case ' ': - func->ucl_emitter_append_character (' ', 1, func->ud); + func->ucl_emitter_append_character(' ', 1, func->ud); break; case '"': - func->ucl_emitter_append_len ("\\\"", 2, func->ud); + func->ucl_emitter_append_len("\\\"", 2, func->ud); break; default: /* Emit unicode unknown character */ - func->ucl_emitter_append_len ("\\uFFFD", 6, func->ud); + func->ucl_emitter_append_len("\\uFFFD", 6, func->ud); break; } len = 0; c = ++p; } else { - p ++; - len ++; + p++; + len++; } - size --; + size--; } if (len > 0) { - func->ucl_emitter_append_len (c, len, func->ud); + func->ucl_emitter_append_len(c, len, func->ud); } - func->ucl_emitter_append_character ('"', 1, func->ud); + func->ucl_emitter_append_character('"', 1, func->ud); } -void -ucl_elt_string_write_squoted (const char *str, size_t size, - struct ucl_emitter_context *ctx) +void ucl_elt_string_write_squoted(const char *str, size_t size, + struct ucl_emitter_context *ctx) { const char *p = str, *c = str; size_t len = 0; const struct ucl_emitter_functions *func = ctx->func; - func->ucl_emitter_append_character ('\'', 1, func->ud); + func->ucl_emitter_append_character('\'', 1, func->ud); while (size) { if (*p == '\'') { if (len > 0) { - func->ucl_emitter_append_len (c, len, func->ud); + func->ucl_emitter_append_len(c, len, func->ud); } len = 0; c = ++p; - func->ucl_emitter_append_len ("\\\'", 2, func->ud); + func->ucl_emitter_append_len("\\\'", 2, func->ud); } else { - p ++; - len ++; + p++; + len++; } - size --; + size--; } if (len > 0) { - func->ucl_emitter_append_len (c, len, func->ud); + func->ucl_emitter_append_len(c, len, func->ud); } - func->ucl_emitter_append_character ('\'', 1, func->ud); + func->ucl_emitter_append_character('\'', 1, func->ud); } -void -ucl_elt_string_write_multiline (const char *str, size_t size, - struct ucl_emitter_context *ctx) +void ucl_elt_string_write_multiline(const char *str, size_t size, + struct ucl_emitter_context *ctx) { const struct ucl_emitter_functions *func = ctx->func; - func->ucl_emitter_append_len ("<ud); - func->ucl_emitter_append_len (str, size, func->ud); - func->ucl_emitter_append_len ("\nEOD", sizeof ("\nEOD") - 1, func->ud); + func->ucl_emitter_append_len("<ud); + func->ucl_emitter_append_len(str, size, func->ud); + func->ucl_emitter_append_len("\nEOD", sizeof("\nEOD") - 1, func->ud); } /* * Generic utstring output */ static int -ucl_utstring_append_character (unsigned char c, size_t len, void *ud) +ucl_utstring_append_character(unsigned char c, size_t len, void *ud) { UT_string *buf = ud; if (len == 1) { - utstring_append_c (buf, c); + utstring_append_c(buf, c); } else { - utstring_reserve (buf, len + 1); - memset (&buf->d[buf->i], c, len); + utstring_reserve(buf, len + 1); + memset(&buf->d[buf->i], c, len); buf->i += len; buf->d[buf->i] = '\0'; } @@ -232,39 +207,39 @@ ucl_utstring_append_character (unsigned char c, size_t len, void *ud) } static int -ucl_utstring_append_len (const unsigned char *str, size_t len, void *ud) +ucl_utstring_append_len(const unsigned char *str, size_t len, void *ud) { UT_string *buf = ud; - utstring_append_len (buf, str, len); + utstring_append_len(buf, str, len); return 0; } static int -ucl_utstring_append_int (int64_t val, void *ud) +ucl_utstring_append_int(int64_t val, void *ud) { UT_string *buf = ud; - utstring_printf (buf, "%jd", (intmax_t)val); + utstring_printf(buf, "%jd", (intmax_t) val); return 0; } static int -ucl_utstring_append_double (double val, void *ud) +ucl_utstring_append_double(double val, void *ud) { UT_string *buf = ud; const double delta = 0.0000001; - if (val == (double)(int)val) { - utstring_printf (buf, "%.1lf", val); + if (val == (double) (int) val) { + utstring_printf(buf, "%.1lf", val); } - else if (fabs (val - (double)(int)val) < delta) { + else if (fabs(val - (double) (int) val) < delta) { /* Write at maximum precision */ - utstring_printf (buf, "%.*lg", DBL_DIG, val); + utstring_printf(buf, "%.*lg", DBL_DIG, val); } else { - utstring_printf (buf, "%lf", val); + utstring_printf(buf, "%lf", val); } return 0; @@ -274,52 +249,52 @@ ucl_utstring_append_double (double val, void *ud) * Generic file output */ static int -ucl_file_append_character (unsigned char c, size_t len, void *ud) +ucl_file_append_character(unsigned char c, size_t len, void *ud) { FILE *fp = ud; - while (len --) { - fputc (c, fp); + while (len--) { + fputc(c, fp); } return 0; } static int -ucl_file_append_len (const unsigned char *str, size_t len, void *ud) +ucl_file_append_len(const unsigned char *str, size_t len, void *ud) { FILE *fp = ud; - fwrite (str, len, 1, fp); + fwrite(str, len, 1, fp); return 0; } static int -ucl_file_append_int (int64_t val, void *ud) +ucl_file_append_int(int64_t val, void *ud) { FILE *fp = ud; - fprintf (fp, "%jd", (intmax_t)val); + fprintf(fp, "%jd", (intmax_t) val); return 0; } static int -ucl_file_append_double (double val, void *ud) +ucl_file_append_double(double val, void *ud) { FILE *fp = ud; const double delta = 0.0000001; - if (val == (double)(int)val) { - fprintf (fp, "%.1lf", val); + if (val == (double) (int) val) { + fprintf(fp, "%.1lf", val); } - else if (fabs (val - (double)(int)val) < delta) { + else if (fabs(val - (double) (int) val) < delta) { /* Write at maximum precision */ - fprintf (fp, "%.*lg", DBL_DIG, val); + fprintf(fp, "%.*lg", DBL_DIG, val); } else { - fprintf (fp, "%lf", val); + fprintf(fp, "%lf", val); } return 0; @@ -329,31 +304,31 @@ ucl_file_append_double (double val, void *ud) * Generic file descriptor writing functions */ static int -ucl_fd_append_character (unsigned char c, size_t len, void *ud) +ucl_fd_append_character(unsigned char c, size_t len, void *ud) { - int fd = *(int *)ud; + int fd = *(int *) ud; unsigned char *buf; if (len == 1) { - return write (fd, &c, 1); + return write(fd, &c, 1); } else { - buf = malloc (len); + buf = malloc(len); if (buf == NULL) { /* Fallback */ - while (len --) { - if (write (fd, &c, 1) == -1) { + while (len--) { + if (write(fd, &c, 1) == -1) { return -1; } } } else { - memset (buf, c, len); - if (write (fd, buf, len) == -1) { + memset(buf, c, len); + if (write(fd, buf, len) == -1) { free(buf); return -1; } - free (buf); + free(buf); } } @@ -361,51 +336,51 @@ ucl_fd_append_character (unsigned char c, size_t len, void *ud) } static int -ucl_fd_append_len (const unsigned char *str, size_t len, void *ud) +ucl_fd_append_len(const unsigned char *str, size_t len, void *ud) { - int fd = *(int *)ud; + int fd = *(int *) ud; - return write (fd, str, len); + return write(fd, str, len); } static int -ucl_fd_append_int (int64_t val, void *ud) +ucl_fd_append_int(int64_t val, void *ud) { - int fd = *(int *)ud; + int fd = *(int *) ud; char intbuf[64]; - snprintf (intbuf, sizeof (intbuf), "%jd", (intmax_t)val); - return write (fd, intbuf, strlen (intbuf)); + snprintf(intbuf, sizeof(intbuf), "%jd", (intmax_t) val); + return write(fd, intbuf, strlen(intbuf)); } static int -ucl_fd_append_double (double val, void *ud) +ucl_fd_append_double(double val, void *ud) { - int fd = *(int *)ud; + int fd = *(int *) ud; const double delta = 0.0000001; char nbuf[64]; - if (val == (double)(int)val) { - snprintf (nbuf, sizeof (nbuf), "%.1lf", val); + if (val == (double) (int) val) { + snprintf(nbuf, sizeof(nbuf), "%.1lf", val); } - else if (fabs (val - (double)(int)val) < delta) { + else if (fabs(val - (double) (int) val) < delta) { /* Write at maximum precision */ - snprintf (nbuf, sizeof (nbuf), "%.*lg", DBL_DIG, val); + snprintf(nbuf, sizeof(nbuf), "%.*lg", DBL_DIG, val); } else { - snprintf (nbuf, sizeof (nbuf), "%lf", val); + snprintf(nbuf, sizeof(nbuf), "%lf", val); } - return write (fd, nbuf, strlen (nbuf)); + return write(fd, nbuf, strlen(nbuf)); } -struct ucl_emitter_functions* -ucl_object_emit_memory_funcs (void **pmem) +struct ucl_emitter_functions * +ucl_object_emit_memory_funcs(void **pmem) { struct ucl_emitter_functions *f; UT_string *s; - f = calloc (1, sizeof (*f)); + f = calloc(1, sizeof(*f)); if (f != NULL) { f->ucl_emitter_append_character = ucl_utstring_append_character; @@ -413,7 +388,7 @@ ucl_object_emit_memory_funcs (void **pmem) f->ucl_emitter_append_int = ucl_utstring_append_int; f->ucl_emitter_append_len = ucl_utstring_append_len; f->ucl_emitter_free_func = _ucl_emitter_free; - utstring_new (s); + utstring_new(s); f->ud = s; *pmem = s->d; s->pd = pmem; @@ -422,12 +397,12 @@ ucl_object_emit_memory_funcs (void **pmem) return f; } -struct ucl_emitter_functions* -ucl_object_emit_file_funcs (FILE *fp) +struct ucl_emitter_functions * +ucl_object_emit_file_funcs(FILE *fp) { struct ucl_emitter_functions *f; - f = calloc (1, sizeof (*f)); + f = calloc(1, sizeof(*f)); if (f != NULL) { f->ucl_emitter_append_character = ucl_file_append_character; @@ -441,22 +416,22 @@ ucl_object_emit_file_funcs (FILE *fp) return f; } -struct ucl_emitter_functions* -ucl_object_emit_fd_funcs (int fd) +struct ucl_emitter_functions * +ucl_object_emit_fd_funcs(int fd) { struct ucl_emitter_functions *f; int *ip; - f = calloc (1, sizeof (*f)); + f = calloc(1, sizeof(*f)); if (f != NULL) { - ip = malloc (sizeof (fd)); + ip = malloc(sizeof(fd)); if (ip == NULL) { - free (f); + free(f); return NULL; } - memcpy (ip, &fd, sizeof (fd)); + memcpy(ip, &fd, sizeof(fd)); f->ucl_emitter_append_character = ucl_fd_append_character; f->ucl_emitter_append_double = ucl_fd_append_double; f->ucl_emitter_append_int = ucl_fd_append_int; @@ -468,20 +443,19 @@ ucl_object_emit_fd_funcs (int fd) return f; } -void -ucl_object_emit_funcs_free (struct ucl_emitter_functions *f) +void ucl_object_emit_funcs_free(struct ucl_emitter_functions *f) { if (f != NULL) { if (f->ucl_emitter_free_func != NULL) { - f->ucl_emitter_free_func (f->ud); + f->ucl_emitter_free_func(f->ud); } - free (f); + free(f); } } unsigned char * -ucl_object_emit_single_json (const ucl_object_t *obj) +ucl_object_emit_single_json(const ucl_object_t *obj) { UT_string *buf = NULL; unsigned char *res = NULL; @@ -490,43 +464,43 @@ ucl_object_emit_single_json (const ucl_object_t *obj) return NULL; } - utstring_new (buf); + utstring_new(buf); if (buf != NULL) { switch (obj->type) { case UCL_OBJECT: - ucl_utstring_append_len ("object", 6, buf); + ucl_utstring_append_len("object", 6, buf); break; case UCL_ARRAY: - ucl_utstring_append_len ("array", 5, buf); + ucl_utstring_append_len("array", 5, buf); break; case UCL_INT: - ucl_utstring_append_int (obj->value.iv, buf); + ucl_utstring_append_int(obj->value.iv, buf); break; case UCL_FLOAT: case UCL_TIME: - ucl_utstring_append_double (obj->value.dv, buf); + ucl_utstring_append_double(obj->value.dv, buf); break; case UCL_NULL: - ucl_utstring_append_len ("null", 4, buf); + ucl_utstring_append_len("null", 4, buf); break; case UCL_BOOLEAN: if (obj->value.iv) { - ucl_utstring_append_len ("true", 4, buf); + ucl_utstring_append_len("true", 4, buf); } else { - ucl_utstring_append_len ("false", 5, buf); + ucl_utstring_append_len("false", 5, buf); } break; case UCL_STRING: - ucl_utstring_append_len (obj->value.sv, obj->len, buf); + ucl_utstring_append_len(obj->value.sv, obj->len, buf); break; case UCL_USERDATA: - ucl_utstring_append_len ("userdata", 8, buf); + ucl_utstring_append_len("userdata", 8, buf); break; } - res = utstring_body (buf); - free (buf); + res = utstring_body(buf); + free(buf); } return res; @@ -534,12 +508,11 @@ ucl_object_emit_single_json (const ucl_object_t *obj) #define LONG_STRING_LIMIT 80 -bool -ucl_maybe_long_string (const ucl_object_t *obj) +bool ucl_maybe_long_string(const ucl_object_t *obj) { if (obj->len > LONG_STRING_LIMIT || (obj->flags & UCL_OBJECT_MULTILINE)) { /* String is long enough, so search for newline characters in it */ - if (memchr (obj->value.sv, '\n', obj->len) != NULL) { + if (memchr(obj->value.sv, '\n', obj->len) != NULL) { return true; } } diff --git a/src/ucl_hash.c b/src/ucl_hash.c index 0208cfd29c9a..d648f405951b 100644 --- a/src/ucl_hash.c +++ b/src/ucl_hash.c @@ -42,7 +42,7 @@ struct ucl_hash_struct { }; static uint64_t -ucl_hash_seed (void) +ucl_hash_seed(void) { static uint64_t seed; if (seed == 0) { @@ -50,7 +50,7 @@ ucl_hash_seed (void) seed = UCL_RANDOM_FUNCTION; #else /* Not very random but can be useful for our purposes */ - seed = time (NULL); + seed = time(NULL); #endif } @@ -58,72 +58,71 @@ ucl_hash_seed (void) } static const unsigned char lc_map[256] = { - 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, - 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, - 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, - 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, - 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, - 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, - 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, - 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, - 0x40, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, - 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, - 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, - 0x78, 0x79, 0x7a, 0x5b, 0x5c, 0x5d, 0x5e, 0x5f, - 0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, - 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, - 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, - 0x78, 0x79, 0x7a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f, - 0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, - 0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f, - 0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, - 0x98, 0x99, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f, - 0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, - 0xa8, 0xa9, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf, - 0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7, - 0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf, - 0xc0, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, - 0xc8, 0xc9, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf, - 0xd0, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, - 0xd8, 0xd9, 0xda, 0xdb, 0xdc, 0xdd, 0xde, 0xdf, - 0xe0, 0xe1, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, - 0xe8, 0xe9, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef, - 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, - 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff -}; - -#if (defined(WORD_BIT) && WORD_BIT == 64) || \ + 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, + 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, + 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, + 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, + 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, + 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, + 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, + 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, + 0x40, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, + 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, + 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, + 0x78, 0x79, 0x7a, 0x5b, 0x5c, 0x5d, 0x5e, 0x5f, + 0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, + 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, + 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, + 0x78, 0x79, 0x7a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f, + 0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, + 0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f, + 0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, + 0x98, 0x99, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f, + 0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, + 0xa8, 0xa9, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf, + 0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7, + 0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf, + 0xc0, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, + 0xc8, 0xc9, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf, + 0xd0, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, + 0xd8, 0xd9, 0xda, 0xdb, 0xdc, 0xdd, 0xde, 0xdf, + 0xe0, 0xe1, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, + 0xe8, 0xe9, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef, + 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, + 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff}; + +#if (defined(WORD_BIT) && WORD_BIT == 64) || \ (defined(__WORDSIZE) && __WORDSIZE == 64) || \ - defined(__x86_64__) || \ + defined(__x86_64__) || \ defined(__amd64__) #define UCL64_BIT_HASH 1 #endif static inline uint32_t -ucl_hash_func (const ucl_object_t *o) +ucl_hash_func(const ucl_object_t *o) { - return mum_hash (o->key, o->keylen, ucl_hash_seed ()); + return mum_hash(o->key, o->keylen, ucl_hash_seed()); } static inline int -ucl_hash_equal (const ucl_object_t *k1, const ucl_object_t *k2) +ucl_hash_equal(const ucl_object_t *k1, const ucl_object_t *k2) { if (k1->keylen == k2->keylen) { - return memcmp (k1->key, k2->key, k1->keylen) == 0; + return memcmp(k1->key, k2->key, k1->keylen) == 0; } return 0; } -KHASH_INIT (ucl_hash_node, const ucl_object_t *, struct ucl_hash_elt *, 1, - ucl_hash_func, ucl_hash_equal) +KHASH_INIT(ucl_hash_node, const ucl_object_t *, struct ucl_hash_elt *, 1, + ucl_hash_func, ucl_hash_equal) static inline uint32_t -ucl_hash_caseless_func (const ucl_object_t *o) +ucl_hash_caseless_func(const ucl_object_t *o) { unsigned len = o->keylen; unsigned leftover = o->keylen % 8; unsigned fp, i; - const uint8_t* s = (const uint8_t*)o->key; + const uint8_t *s = (const uint8_t *) o->key; union { struct { unsigned char c1, c2, c3, c4, c5, c6, c7, c8; @@ -133,7 +132,7 @@ ucl_hash_caseless_func (const ucl_object_t *o) uint64_t r; fp = len - leftover; - r = ucl_hash_seed (); + r = ucl_hash_seed(); for (i = 0; i != fp; i += 8) { u.c.c1 = s[i], u.c.c2 = s[i + 1], u.c.c3 = s[i + 2], u.c.c4 = s[i + 3]; @@ -146,40 +145,40 @@ ucl_hash_caseless_func (const ucl_object_t *o) u.c.c6 = lc_map[u.c.c6]; u.c.c7 = lc_map[u.c.c7]; u.c.c8 = lc_map[u.c.c8]; - r = mum_hash_step (r, u.pp); + r = mum_hash_step(r, u.pp); } u.pp = 0; switch (leftover) { case 7: - u.c.c7 = lc_map[(unsigned char)s[i++]]; + u.c.c7 = lc_map[(unsigned char) s[i++]]; /* FALLTHRU */ case 6: - u.c.c6 = lc_map[(unsigned char)s[i++]]; + u.c.c6 = lc_map[(unsigned char) s[i++]]; /* FALLTHRU */ case 5: - u.c.c5 = lc_map[(unsigned char)s[i++]]; + u.c.c5 = lc_map[(unsigned char) s[i++]]; /* FALLTHRU */ case 4: - u.c.c4 = lc_map[(unsigned char)s[i++]]; + u.c.c4 = lc_map[(unsigned char) s[i++]]; /* FALLTHRU */ case 3: - u.c.c3 = lc_map[(unsigned char)s[i++]]; + u.c.c3 = lc_map[(unsigned char) s[i++]]; /* FALLTHRU */ case 2: - u.c.c2 = lc_map[(unsigned char)s[i++]]; + u.c.c2 = lc_map[(unsigned char) s[i++]]; /* FALLTHRU */ case 1: - u.c.c1 = lc_map[(unsigned char)s[i]]; - r = mum_hash_step (r, u.pp); + u.c.c1 = lc_map[(unsigned char) s[i]]; + r = mum_hash_step(r, u.pp); break; } - return mum_hash_finish (r); + return mum_hash_finish(r); } static inline int -ucl_hash_caseless_equal (const ucl_object_t *k1, const ucl_object_t *k2) +ucl_hash_caseless_equal(const ucl_object_t *k1, const ucl_object_t *k2) { if (k1->keylen == k2->keylen) { unsigned fp, i; @@ -212,7 +211,7 @@ ucl_hash_caseless_equal (const ucl_object_t *k1, const ucl_object_t *k2) } while (leftover > 0) { - if (lc_map[(unsigned char)s[i]] != lc_map[(unsigned char)d[i]]) { + if (lc_map[(unsigned char) s[i]] != lc_map[(unsigned char) d[i]]) { return 0; } @@ -226,27 +225,27 @@ ucl_hash_caseless_equal (const ucl_object_t *k1, const ucl_object_t *k2) return 0; } -KHASH_INIT (ucl_hash_caseless_node, const ucl_object_t *, struct ucl_hash_elt *, 1, - ucl_hash_caseless_func, ucl_hash_caseless_equal) +KHASH_INIT(ucl_hash_caseless_node, const ucl_object_t *, struct ucl_hash_elt *, 1, + ucl_hash_caseless_func, ucl_hash_caseless_equal) -ucl_hash_t* -ucl_hash_create (bool ignore_case) +ucl_hash_t * +ucl_hash_create(bool ignore_case) { ucl_hash_t *new; - new = UCL_ALLOC (sizeof (ucl_hash_t)); + new = UCL_ALLOC(sizeof(ucl_hash_t)); if (new != NULL) { void *h; new->head = NULL; new->caseless = ignore_case; if (ignore_case) { - h = (void *)kh_init (ucl_hash_caseless_node); + h = (void *) kh_init(ucl_hash_caseless_node); } else { - h = (void *)kh_init (ucl_hash_node); + h = (void *) kh_init(ucl_hash_node); } if (h == NULL) { - UCL_FREE (sizeof (ucl_hash_t), new); + UCL_FREE(sizeof(ucl_hash_t), new); return NULL; } new->hash = h; @@ -254,7 +253,7 @@ ucl_hash_create (bool ignore_case) return new; } -void ucl_hash_destroy (ucl_hash_t* hashlin, ucl_hash_free_func func) +void ucl_hash_destroy(ucl_hash_t *hashlin, ucl_hash_free_func func) { if (hashlin == NULL) { @@ -264,16 +263,16 @@ void ucl_hash_destroy (ucl_hash_t* hashlin, ucl_hash_free_func func) if (func != NULL) { /* Iterate over the hash first */ khash_t(ucl_hash_node) *h = (khash_t(ucl_hash_node) *) - hashlin->hash; + hashlin->hash; khiter_t k; const ucl_object_t *cur, *tmp; - for (k = kh_begin (h); k != kh_end (h); ++k) { - if (kh_exist (h, k)) { - cur = (kh_value (h, k))->obj; + for (k = kh_begin(h); k != kh_end(h); ++k) { + if (kh_exist(h, k)) { + cur = (kh_value(h, k))->obj; while (cur != NULL) { tmp = cur->next; - func (__DECONST (ucl_object_t *, cur)); + func(__DECONST(ucl_object_t *, cur)); cur = tmp; } } @@ -282,27 +281,27 @@ void ucl_hash_destroy (ucl_hash_t* hashlin, ucl_hash_free_func func) if (hashlin->caseless) { khash_t(ucl_hash_caseless_node) *h = (khash_t(ucl_hash_caseless_node) *) - hashlin->hash; - kh_destroy (ucl_hash_caseless_node, h); + hashlin->hash; + kh_destroy(ucl_hash_caseless_node, h); } else { khash_t(ucl_hash_node) *h = (khash_t(ucl_hash_node) *) - hashlin->hash; - kh_destroy (ucl_hash_node, h); + hashlin->hash; + kh_destroy(ucl_hash_node, h); } struct ucl_hash_elt *cur, *tmp; - DL_FOREACH_SAFE(hashlin->head, cur, tmp) { + DL_FOREACH_SAFE(hashlin->head, cur, tmp) + { UCL_FREE(sizeof(*cur), cur); } - UCL_FREE (sizeof (*hashlin), hashlin); + UCL_FREE(sizeof(*hashlin), hashlin); } -bool -ucl_hash_insert (ucl_hash_t* hashlin, const ucl_object_t *obj, - const char *key, unsigned keylen) +bool ucl_hash_insert(ucl_hash_t *hashlin, const ucl_object_t *obj, + const char *key, unsigned keylen) { khiter_t k; int ret; @@ -314,11 +313,11 @@ ucl_hash_insert (ucl_hash_t* hashlin, const ucl_object_t *obj, if (hashlin->caseless) { khash_t(ucl_hash_caseless_node) *h = (khash_t(ucl_hash_caseless_node) *) - hashlin->hash; - k = kh_put (ucl_hash_caseless_node, h, obj, &ret); + hashlin->hash; + k = kh_put(ucl_hash_caseless_node, h, obj, &ret); if (ret > 0) { elt = UCL_ALLOC(sizeof(*elt)); - pelt = &kh_value (h, k); + pelt = &kh_value(h, k); *pelt = elt; DL_APPEND(hashlin->head, elt); elt->obj = obj; @@ -329,15 +328,16 @@ ucl_hash_insert (ucl_hash_t* hashlin, const ucl_object_t *obj, } else { khash_t(ucl_hash_node) *h = (khash_t(ucl_hash_node) *) - hashlin->hash; - k = kh_put (ucl_hash_node, h, obj, &ret); + hashlin->hash; + k = kh_put(ucl_hash_node, h, obj, &ret); if (ret > 0) { elt = UCL_ALLOC(sizeof(*elt)); - pelt = &kh_value (h, k); + pelt = &kh_value(h, k); *pelt = elt; DL_APPEND(hashlin->head, elt); elt->obj = obj; - } else if (ret < 0) { + } + else if (ret < 0) { goto e0; } } @@ -346,8 +346,8 @@ e0: return false; } -void ucl_hash_replace (ucl_hash_t* hashlin, const ucl_object_t *old, - const ucl_object_t *new) +void ucl_hash_replace(ucl_hash_t *hashlin, const ucl_object_t *old, + const ucl_object_t *new) { khiter_t k; int ret; @@ -359,12 +359,12 @@ void ucl_hash_replace (ucl_hash_t* hashlin, const ucl_object_t *old, if (hashlin->caseless) { khash_t(ucl_hash_caseless_node) *h = (khash_t(ucl_hash_caseless_node) *) - hashlin->hash; - k = kh_put (ucl_hash_caseless_node, h, old, &ret); + hashlin->hash; + k = kh_put(ucl_hash_caseless_node, h, old, &ret); if (ret == 0) { elt = kh_value(h, k); - kh_del (ucl_hash_caseless_node, h, k); - k = kh_put (ucl_hash_caseless_node, h, new, &ret); + kh_del(ucl_hash_caseless_node, h, k); + k = kh_put(ucl_hash_caseless_node, h, new, &ret); nelt = UCL_ALLOC(sizeof(*nelt)); nelt->obj = new; kh_value(h, k) = nelt; @@ -374,12 +374,12 @@ void ucl_hash_replace (ucl_hash_t* hashlin, const ucl_object_t *old, } else { khash_t(ucl_hash_node) *h = (khash_t(ucl_hash_node) *) - hashlin->hash; - k = kh_put (ucl_hash_node, h, old, &ret); + hashlin->hash; + k = kh_put(ucl_hash_node, h, old, &ret); if (ret == 0) { - elt = kh_value (h, k); - kh_del (ucl_hash_node, h, k); - k = kh_put (ucl_hash_node, h, new, &ret); + elt = kh_value(h, k); + kh_del(ucl_hash_node, h, k); + k = kh_put(ucl_hash_node, h, new, &ret); nelt = UCL_ALLOC(sizeof(*nelt)); nelt->obj = new; kh_value(h, k) = nelt; @@ -393,12 +393,15 @@ struct ucl_hash_real_iter { const struct ucl_hash_elt *cur; }; -#define UHI_SETERR(ep, ern) {if (ep != NULL) *ep = (ern);} +#define UHI_SETERR(ep, ern) \ + { \ + if (ep != NULL) *ep = (ern); \ + } -const void* -ucl_hash_iterate2 (ucl_hash_t *hashlin, ucl_hash_iter_t *iter, int *ep) +const void * +ucl_hash_iterate2(ucl_hash_t *hashlin, ucl_hash_iter_t *iter, int *ep) { - struct ucl_hash_real_iter *it = (struct ucl_hash_real_iter *)(*iter); + struct ucl_hash_real_iter *it = (struct ucl_hash_real_iter *) (*iter); const ucl_object_t *ret = NULL; if (hashlin == NULL) { @@ -407,7 +410,7 @@ ucl_hash_iterate2 (ucl_hash_t *hashlin, ucl_hash_iter_t *iter, int *ep) } if (it == NULL) { - it = UCL_ALLOC (sizeof (*it)); + it = UCL_ALLOC(sizeof(*it)); if (it == NULL) { UHI_SETERR(ep, ENOMEM); @@ -423,7 +426,7 @@ ucl_hash_iterate2 (ucl_hash_t *hashlin, ucl_hash_iter_t *iter, int *ep) it->cur = it->cur->next; } else { - UCL_FREE (sizeof (*it), it); + UCL_FREE(sizeof(*it), it); *iter = NULL; return NULL; } @@ -433,17 +436,16 @@ ucl_hash_iterate2 (ucl_hash_t *hashlin, ucl_hash_iter_t *iter, int *ep) return ret; } -bool -ucl_hash_iter_has_next (ucl_hash_t *hashlin, ucl_hash_iter_t iter) +bool ucl_hash_iter_has_next(ucl_hash_t *hashlin, ucl_hash_iter_t iter) { - struct ucl_hash_real_iter *it = (struct ucl_hash_real_iter *)(iter); + struct ucl_hash_real_iter *it = (struct ucl_hash_real_iter *) (iter); return it->cur != NULL; } -const ucl_object_t* -ucl_hash_search (ucl_hash_t* hashlin, const char *key, unsigned keylen) +const ucl_object_t * +ucl_hash_search(ucl_hash_t *hashlin, const char *key, unsigned keylen) { khiter_t k; const ucl_object_t *ret = NULL; @@ -459,20 +461,20 @@ ucl_hash_search (ucl_hash_t* hashlin, const char *key, unsigned keylen) if (hashlin->caseless) { khash_t(ucl_hash_caseless_node) *h = (khash_t(ucl_hash_caseless_node) *) - hashlin->hash; + hashlin->hash; - k = kh_get (ucl_hash_caseless_node, h, &search); - if (k != kh_end (h)) { - elt = kh_value (h, k); + k = kh_get(ucl_hash_caseless_node, h, &search); + if (k != kh_end(h)) { + elt = kh_value(h, k); ret = elt->obj; } } else { khash_t(ucl_hash_node) *h = (khash_t(ucl_hash_node) *) - hashlin->hash; - k = kh_get (ucl_hash_node, h, &search); - if (k != kh_end (h)) { - elt = kh_value (h, k); + hashlin->hash; + k = kh_get(ucl_hash_node, h, &search); + if (k != kh_end(h)) { + elt = kh_value(h, k); ret = elt->obj; } } @@ -480,8 +482,7 @@ ucl_hash_search (ucl_hash_t* hashlin, const char *key, unsigned keylen) return ret; } -void -ucl_hash_delete (ucl_hash_t* hashlin, const ucl_object_t *obj) +void ucl_hash_delete(ucl_hash_t *hashlin, const ucl_object_t *obj) { khiter_t k; struct ucl_hash_elt *elt; @@ -492,52 +493,53 @@ ucl_hash_delete (ucl_hash_t* hashlin, const ucl_object_t *obj) if (hashlin->caseless) { khash_t(ucl_hash_caseless_node) *h = (khash_t(ucl_hash_caseless_node) *) - hashlin->hash; + hashlin->hash; - k = kh_get (ucl_hash_caseless_node, h, obj); - if (k != kh_end (h)) { - elt = kh_value (h, k); + k = kh_get(ucl_hash_caseless_node, h, obj); + if (k != kh_end(h)) { + elt = kh_value(h, k); DL_DELETE(hashlin->head, elt); - kh_del (ucl_hash_caseless_node, h, k); + kh_del(ucl_hash_caseless_node, h, k); UCL_FREE(sizeof(*elt), elt); } } else { khash_t(ucl_hash_node) *h = (khash_t(ucl_hash_node) *) - hashlin->hash; - k = kh_get (ucl_hash_node, h, obj); - if (k != kh_end (h)) { - elt = kh_value (h, k); + hashlin->hash; + k = kh_get(ucl_hash_node, h, obj); + if (k != kh_end(h)) { + elt = kh_value(h, k); DL_DELETE(hashlin->head, elt); - kh_del (ucl_hash_node, h, k); + kh_del(ucl_hash_node, h, k); UCL_FREE(sizeof(*elt), elt); } } } -bool ucl_hash_reserve (ucl_hash_t *hashlin, size_t sz) +bool ucl_hash_reserve(ucl_hash_t *hashlin, size_t sz) { if (hashlin == NULL) { return false; } - if (sz > kh_size((khash_t(ucl_hash_node) *)hashlin->hash)) { + if (sz > kh_size((khash_t(ucl_hash_node) *) hashlin->hash)) { if (hashlin->caseless) { khash_t(ucl_hash_caseless_node) *h = (khash_t( - ucl_hash_caseless_node) *) - hashlin->hash; - kh_resize (ucl_hash_caseless_node, h, sz * 2); - } else { + ucl_hash_caseless_node) *) + hashlin->hash; + kh_resize(ucl_hash_caseless_node, h, sz * 2); + } + else { khash_t(ucl_hash_node) *h = (khash_t(ucl_hash_node) *) - hashlin->hash; - kh_resize (ucl_hash_node, h, sz * 2); + hashlin->hash; + kh_resize(ucl_hash_node, h, sz * 2); } } return true; } static int -ucl_lc_cmp (const char *s, const char *d, size_t l) +ucl_lc_cmp(const char *s, const char *d, size_t l) { unsigned int fp, i; unsigned char c1, c2, c3, c4; @@ -569,7 +571,7 @@ ucl_lc_cmp (const char *s, const char *d, size_t l) } while (leftover > 0) { - if (lc_map[(unsigned char)s[i]] != lc_map[(unsigned char)d[i]]) { + if (lc_map[(unsigned char) s[i]] != lc_map[(unsigned char) d[i]]) { return s[i] - d[i]; } @@ -581,33 +583,32 @@ ucl_lc_cmp (const char *s, const char *d, size_t l) } static int -ucl_hash_cmp_icase (const void *a, const void *b) +ucl_hash_cmp_icase(const void *a, const void *b) { - const struct ucl_hash_elt *oa = (const struct ucl_hash_elt *)a, - *ob = (const struct ucl_hash_elt *)b; + const struct ucl_hash_elt *oa = (const struct ucl_hash_elt *) a, + *ob = (const struct ucl_hash_elt *) b; if (oa->obj->keylen == ob->obj->keylen) { - return ucl_lc_cmp (oa->obj->key, ob->obj->key, oa->obj->keylen); + return ucl_lc_cmp(oa->obj->key, ob->obj->key, oa->obj->keylen); } - return ((int)(oa->obj->keylen)) - ob->obj->keylen; + return ((int) (oa->obj->keylen)) - ob->obj->keylen; } static int -ucl_hash_cmp_case_sens (const void *a, const void *b) +ucl_hash_cmp_case_sens(const void *a, const void *b) { - const struct ucl_hash_elt *oa = (const struct ucl_hash_elt *)a, - *ob = (const struct ucl_hash_elt *)b; + const struct ucl_hash_elt *oa = (const struct ucl_hash_elt *) a, + *ob = (const struct ucl_hash_elt *) b; if (oa->obj->keylen == ob->obj->keylen) { - return memcmp (oa->obj->key, ob->obj->key, oa->obj->keylen); + return memcmp(oa->obj->key, ob->obj->key, oa->obj->keylen); } - return ((int)(oa->obj->keylen)) - ob->obj->keylen; + return ((int) (oa->obj->keylen)) - ob->obj->keylen; } -void -ucl_hash_sort (ucl_hash_t *hashlin, enum ucl_object_keys_sort_flags fl) +void ucl_hash_sort(ucl_hash_t *hashlin, enum ucl_object_keys_sort_flags fl) { if (fl & UCL_SORT_KEYS_ICASE) { @@ -620,9 +621,10 @@ ucl_hash_sort (ucl_hash_t *hashlin, enum ucl_object_keys_sort_flags fl) if (fl & UCL_SORT_KEYS_RECURSIVE) { struct ucl_hash_elt *elt; - DL_FOREACH(hashlin->head, elt) { - if (ucl_object_type (elt->obj) == UCL_OBJECT) { - ucl_hash_sort (elt->obj->value.ov, fl); + DL_FOREACH(hashlin->head, elt) + { + if (ucl_object_type(elt->obj) == UCL_OBJECT) { + ucl_hash_sort(elt->obj->value.ov, fl); } } } diff --git a/src/ucl_hash.h b/src/ucl_hash.h index 8f6d69e21a25..95fe206b677e 100644 --- a/src/ucl_hash.h +++ b/src/ucl_hash.h @@ -31,9 +31,9 @@ struct ucl_hash_node_s; typedef struct ucl_hash_node_s ucl_hash_node_t; -typedef int (*ucl_hash_cmp_func) (const void* void_a, const void* void_b); -typedef void (*ucl_hash_free_func) (void *ptr); -typedef void* ucl_hash_iter_t; +typedef int (*ucl_hash_cmp_func)(const void *void_a, const void *void_b); +typedef void (*ucl_hash_free_func)(void *ptr); +typedef void *ucl_hash_iter_t; /** @@ -46,36 +46,36 @@ typedef struct ucl_hash_struct ucl_hash_t; /** * Initializes the hashtable. */ -ucl_hash_t* ucl_hash_create (bool ignore_case); +ucl_hash_t *ucl_hash_create(bool ignore_case); /** * Deinitializes the hashtable. */ -void ucl_hash_destroy (ucl_hash_t* hashlin, ucl_hash_free_func func); +void ucl_hash_destroy(ucl_hash_t *hashlin, ucl_hash_free_func func); /** * Inserts an element in the the hashtable. * @return true on success, false on failure (i.e. ENOMEM) */ -bool ucl_hash_insert (ucl_hash_t* hashlin, const ucl_object_t *obj, const char *key, - unsigned keylen); +bool ucl_hash_insert(ucl_hash_t *hashlin, const ucl_object_t *obj, const char *key, + unsigned keylen); /** * Replace element in the hash */ -void ucl_hash_replace (ucl_hash_t* hashlin, const ucl_object_t *old, - const ucl_object_t *new); +void ucl_hash_replace(ucl_hash_t *hashlin, const ucl_object_t *old, + const ucl_object_t *new); /** * Delete an element from the the hashtable. */ -void ucl_hash_delete (ucl_hash_t* hashlin, const ucl_object_t *obj); +void ucl_hash_delete(ucl_hash_t *hashlin, const ucl_object_t *obj); /** * Searches an element in the hashtable. */ -const ucl_object_t* ucl_hash_search (ucl_hash_t* hashlin, const char *key, - unsigned keylen); +const ucl_object_t *ucl_hash_search(ucl_hash_t *hashlin, const char *key, + unsigned keylen); /** @@ -85,7 +85,7 @@ const ucl_object_t* ucl_hash_search (ucl_hash_t* hashlin, const char *key, * @param ep pointer record exception (such as ENOMEM), could be NULL * @return the next object */ -const void* ucl_hash_iterate2 (ucl_hash_t *hashlin, ucl_hash_iter_t *iter, int *ep); +const void *ucl_hash_iterate2(ucl_hash_t *hashlin, ucl_hash_iter_t *iter, int *ep); /** * Helper macro to support older code @@ -95,15 +95,15 @@ const void* ucl_hash_iterate2 (ucl_hash_t *hashlin, ucl_hash_iter_t *iter, int * /** * Check whether an iterator has next element */ -bool ucl_hash_iter_has_next (ucl_hash_t *hashlin, ucl_hash_iter_t iter); +bool ucl_hash_iter_has_next(ucl_hash_t *hashlin, ucl_hash_iter_t iter); /** * Reserves space in hash * @return true on sucess, false on failure (e.g. ENOMEM) * @param hashlin */ -bool ucl_hash_reserve (ucl_hash_t *hashlin, size_t sz); +bool ucl_hash_reserve(ucl_hash_t *hashlin, size_t sz); -void ucl_hash_sort (ucl_hash_t *hashlin, enum ucl_object_keys_sort_flags fl); +void ucl_hash_sort(ucl_hash_t *hashlin, enum ucl_object_keys_sort_flags fl); #endif diff --git a/src/ucl_internal.h b/src/ucl_internal.h index 2c5fdf84fee7..5d58ddc486f5 100644 --- a/src/ucl_internal.h +++ b/src/ucl_internal.h @@ -46,7 +46,7 @@ #define HAVE_STDINT_H #define HAVE_STDARG_H #ifndef _WIN32 -# define HAVE_REGEX_H +#define HAVE_REGEX_H #endif #endif @@ -55,17 +55,17 @@ #endif #ifdef HAVE_SYS_MMAN_H -# ifndef _WIN32 -# include -# endif +#ifndef _WIN32 +#include +#endif #endif #ifdef HAVE_SYS_STAT_H #include #endif #ifdef HAVE_SYS_PARAM_H -# ifndef _WIN32 -# include -# endif +#ifndef _WIN32 +#include +#endif #endif #ifdef HAVE_LIMITS_H @@ -78,9 +78,9 @@ #include #endif #ifdef HAVE_UNISTD_H -# ifndef _WIN32 -# include -# endif +#ifndef _WIN32 +#include +#endif #endif #ifdef HAVE_CTYPE_H #include @@ -132,7 +132,7 @@ typedef SSIZE_T ssize_t; #endif #ifndef __DECONST -#define __DECONST(type, var) ((type)(uintptr_t)(const void *)(var)) +#define __DECONST(type, var) ((type) (uintptr_t) (const void *) (var)) #endif /** @@ -182,14 +182,15 @@ struct ucl_macro { ucl_macro_handler handler; ucl_context_macro_handler context_handler; } h; - void* ud; + void *ud; bool is_context; UT_hash_handle hh; }; enum ucl_stack_flags { UCL_STACK_HAS_OBRACE = (1u << 0), - UCL_STACK_MAX = (1u << 1), + UCL_STACK_AUTOMATIC = (1u << 1), + UCL_STACK_MAX = (1u << 2), }; struct ucl_stack { @@ -284,14 +285,14 @@ struct ucl_object_userdata { * Unescape json string inplace * @param str */ -size_t ucl_unescape_json_string (char *str, size_t len); +size_t ucl_unescape_json_string(char *str, size_t len); /** * Unescape single quoted string inplace * @param str */ -size_t ucl_unescape_squoted_string (char *str, size_t len); +size_t ucl_unescape_squoted_string(char *str, size_t len); /** * Handle include macro @@ -301,8 +302,8 @@ size_t ucl_unescape_squoted_string (char *str, size_t len); * @param ud user data * @return */ -bool ucl_include_handler (const unsigned char *data, size_t len, - const ucl_object_t *args, void* ud); +bool ucl_include_handler(const unsigned char *data, size_t len, + const ucl_object_t *args, void *ud); /** * Handle tryinclude macro @@ -312,8 +313,8 @@ bool ucl_include_handler (const unsigned char *data, size_t len, * @param ud user data * @return */ -bool ucl_try_include_handler (const unsigned char *data, size_t len, - const ucl_object_t *args, void* ud); +bool ucl_try_include_handler(const unsigned char *data, size_t len, + const ucl_object_t *args, void *ud); /** * Handle includes macro @@ -323,8 +324,8 @@ bool ucl_try_include_handler (const unsigned char *data, size_t len, * @param ud user data * @return */ -bool ucl_includes_handler (const unsigned char *data, size_t len, - const ucl_object_t *args, void* ud); +bool ucl_includes_handler(const unsigned char *data, size_t len, + const ucl_object_t *args, void *ud); /** * Handle priority macro @@ -334,8 +335,8 @@ bool ucl_includes_handler (const unsigned char *data, size_t len, * @param ud user data * @return */ -bool ucl_priority_handler (const unsigned char *data, size_t len, - const ucl_object_t *args, void* ud); +bool ucl_priority_handler(const unsigned char *data, size_t len, + const ucl_object_t *args, void *ud); /** * Handle load macro @@ -345,8 +346,8 @@ bool ucl_priority_handler (const unsigned char *data, size_t len, * @param ud user data * @return */ -bool ucl_load_handler (const unsigned char *data, size_t len, - const ucl_object_t *args, void* ud); +bool ucl_load_handler(const unsigned char *data, size_t len, + const ucl_object_t *args, void *ud); /** * Handle inherit macro * @param data include data @@ -356,37 +357,37 @@ bool ucl_load_handler (const unsigned char *data, size_t len, * @param ud user data * @return */ -bool ucl_inherit_handler (const unsigned char *data, size_t len, - const ucl_object_t *args, const ucl_object_t *ctx, void* ud); +bool ucl_inherit_handler(const unsigned char *data, size_t len, + const ucl_object_t *args, const ucl_object_t *ctx, void *ud); -size_t ucl_strlcpy (char *dst, const char *src, size_t siz); -size_t ucl_strlcpy_unsafe (char *dst, const char *src, size_t siz); -size_t ucl_strlcpy_tolower (char *dst, const char *src, size_t siz); +size_t ucl_strlcpy(char *dst, const char *src, size_t siz); +size_t ucl_strlcpy_unsafe(char *dst, const char *src, size_t siz); +size_t ucl_strlcpy_tolower(char *dst, const char *src, size_t siz); -char *ucl_strnstr (const char *s, const char *find, int len); -char *ucl_strncasestr (const char *s, const char *find, int len); +char *ucl_strnstr(const char *s, const char *find, int len); +char *ucl_strncasestr(const char *s, const char *find, int len); #ifdef __GNUC__ static inline void -ucl_create_err (UT_string **err, const char *fmt, ...) -__attribute__ (( format( printf, 2, 3) )); +ucl_create_err(UT_string **err, const char *fmt, ...) + __attribute__((format(printf, 2, 3))); #endif #undef UCL_FATAL_ERRORS static inline void -ucl_create_err (UT_string **err, const char *fmt, ...) +ucl_create_err(UT_string **err, const char *fmt, ...) { if (*err == NULL) { - utstring_new (*err); + utstring_new(*err); va_list ap; - va_start (ap, fmt); - utstring_printf_va (*err, fmt, ap); - va_end (ap); + va_start(ap, fmt); + utstring_printf_va(*err, fmt, ap); + va_end(ap); } #ifdef UCL_FATAL_ERRORS - assert (0); + assert(0); #endif } @@ -398,39 +399,39 @@ ucl_create_err (UT_string **err, const char *fmt, ...) * @return true if a string is a boolean value */ static inline bool -ucl_maybe_parse_boolean (ucl_object_t *obj, const unsigned char *start, size_t len) +ucl_maybe_parse_boolean(ucl_object_t *obj, const unsigned char *start, size_t len) { - const char *p = (const char *)start; + const char *p = (const char *) start; bool ret = false, val = false; if (len == 5) { - if ((p[0] == 'f' || p[0] == 'F') && strncasecmp (p, "false", 5) == 0) { + if ((p[0] == 'f' || p[0] == 'F') && strncasecmp(p, "false", 5) == 0) { ret = true; val = false; } } else if (len == 4) { - if ((p[0] == 't' || p[0] == 'T') && strncasecmp (p, "true", 4) == 0) { + if ((p[0] == 't' || p[0] == 'T') && strncasecmp(p, "true", 4) == 0) { ret = true; val = true; } } else if (len == 3) { - if ((p[0] == 'y' || p[0] == 'Y') && strncasecmp (p, "yes", 3) == 0) { + if ((p[0] == 'y' || p[0] == 'Y') && strncasecmp(p, "yes", 3) == 0) { ret = true; val = true; } - else if ((p[0] == 'o' || p[0] == 'O') && strncasecmp (p, "off", 3) == 0) { + else if ((p[0] == 'o' || p[0] == 'O') && strncasecmp(p, "off", 3) == 0) { ret = true; val = false; } } else if (len == 2) { - if ((p[0] == 'n' || p[0] == 'N') && strncasecmp (p, "no", 2) == 0) { + if ((p[0] == 'n' || p[0] == 'N') && strncasecmp(p, "no", 2) == 0) { ret = true; val = false; } - else if ((p[0] == 'o' || p[0] == 'O') && strncasecmp (p, "on", 2) == 0) { + else if ((p[0] == 'o' || p[0] == 'O') && strncasecmp(p, "on", 2) == 0) { ret = true; val = true; } @@ -453,37 +454,38 @@ ucl_maybe_parse_boolean (ucl_object_t *obj, const unsigned char *start, size_t l * @param allow_double allow parsing of floating point values * @return 0 if string is numeric and error code (EINVAL or ERANGE) in case of conversion error */ -int ucl_maybe_parse_number (ucl_object_t *obj, - const char *start, const char *end, const char **pos, - bool allow_double, bool number_bytes, bool allow_time); +int ucl_maybe_parse_number(ucl_object_t *obj, + const char *start, const char *end, const char **pos, + bool allow_double, bool number_bytes, bool allow_time); static inline const ucl_object_t * -ucl_hash_search_obj (ucl_hash_t* hashlin, ucl_object_t *obj) +ucl_hash_search_obj(ucl_hash_t *hashlin, ucl_object_t *obj) { - return (const ucl_object_t *)ucl_hash_search (hashlin, obj->key, obj->keylen); + return (const ucl_object_t *) ucl_hash_search(hashlin, obj->key, obj->keylen); } -static inline ucl_hash_t * ucl_hash_insert_object (ucl_hash_t *hashlin, - const ucl_object_t *obj, - bool ignore_case) UCL_WARN_UNUSED_RESULT; +static inline ucl_hash_t *ucl_hash_insert_object(ucl_hash_t *hashlin, + const ucl_object_t *obj, + bool ignore_case) UCL_WARN_UNUSED_RESULT; static inline ucl_hash_t * -ucl_hash_insert_object (ucl_hash_t *hashlin, - const ucl_object_t *obj, - bool ignore_case) +ucl_hash_insert_object(ucl_hash_t *hashlin, + const ucl_object_t *obj, + bool ignore_case) { ucl_hash_t *nhp; if (hashlin == NULL) { - nhp = ucl_hash_create (ignore_case); + nhp = ucl_hash_create(ignore_case); if (nhp == NULL) { return NULL; } - } else { + } + else { nhp = hashlin; } - if (!ucl_hash_insert (nhp, obj, obj->key, obj->keylen)) { + if (!ucl_hash_insert(nhp, obj, obj->key, obj->keylen)) { if (nhp != hashlin) { ucl_hash_destroy(nhp, NULL); } @@ -499,15 +501,15 @@ ucl_hash_insert_object (ucl_hash_t *hashlin, * @return context or NULL if input is invalid */ const struct ucl_emitter_context * -ucl_emit_get_standard_context (enum ucl_emitter emit_type); +ucl_emit_get_standard_context(enum ucl_emitter emit_type); /** * Serialize string as JSON string * @param str string to emit * @param buf target buffer */ -void ucl_elt_string_write_json (const char *str, size_t size, - struct ucl_emitter_context *ctx); +void ucl_elt_string_write_json(const char *str, size_t size, + struct ucl_emitter_context *ctx); /** @@ -515,9 +517,8 @@ void ucl_elt_string_write_json (const char *str, size_t size, * @param str string to emit * @param buf target buffer */ -void -ucl_elt_string_write_squoted (const char *str, size_t size, - struct ucl_emitter_context *ctx); +void ucl_elt_string_write_squoted(const char *str, size_t size, + struct ucl_emitter_context *ctx); /** * Write multiline string using `EOD` as string terminator @@ -525,15 +526,15 @@ ucl_elt_string_write_squoted (const char *str, size_t size, * @param size * @param ctx */ -void ucl_elt_string_write_multiline (const char *str, size_t size, - struct ucl_emitter_context *ctx); +void ucl_elt_string_write_multiline(const char *str, size_t size, + struct ucl_emitter_context *ctx); /** * Emit a single object to string * @param obj * @return */ -unsigned char * ucl_object_emit_single_json (const ucl_object_t *obj); +unsigned char *ucl_object_emit_single_json(const ucl_object_t *obj); /** * Check whether a specified string is long and should be likely printed in @@ -541,37 +542,37 @@ unsigned char * ucl_object_emit_single_json (const ucl_object_t *obj); * @param obj * @return */ -bool ucl_maybe_long_string (const ucl_object_t *obj); +bool ucl_maybe_long_string(const ucl_object_t *obj); /** * Print integer to the msgpack output * @param ctx * @param val */ -void ucl_emitter_print_int_msgpack (struct ucl_emitter_context *ctx, - int64_t val); +void ucl_emitter_print_int_msgpack(struct ucl_emitter_context *ctx, + int64_t val); /** * Print integer to the msgpack output * @param ctx * @param val */ -void ucl_emitter_print_double_msgpack (struct ucl_emitter_context *ctx, - double val); +void ucl_emitter_print_double_msgpack(struct ucl_emitter_context *ctx, + double val); /** * Print double to the msgpack output * @param ctx * @param val */ -void ucl_emitter_print_bool_msgpack (struct ucl_emitter_context *ctx, - bool val); +void ucl_emitter_print_bool_msgpack(struct ucl_emitter_context *ctx, + bool val); /** * Print string to the msgpack output * @param ctx * @param s * @param len */ -void ucl_emitter_print_string_msgpack (struct ucl_emitter_context *ctx, - const char *s, size_t len); +void ucl_emitter_print_string_msgpack(struct ucl_emitter_context *ctx, + const char *s, size_t len); /** * Print binary string to the msgpack output @@ -579,38 +580,38 @@ void ucl_emitter_print_string_msgpack (struct ucl_emitter_context *ctx, * @param s * @param len */ -void ucl_emitter_print_binary_string_msgpack (struct ucl_emitter_context *ctx, - const char *s, size_t len); +void ucl_emitter_print_binary_string_msgpack(struct ucl_emitter_context *ctx, + const char *s, size_t len); /** * Print array preamble for msgpack * @param ctx * @param len */ -void ucl_emitter_print_array_msgpack (struct ucl_emitter_context *ctx, - size_t len); +void ucl_emitter_print_array_msgpack(struct ucl_emitter_context *ctx, + size_t len); /** * Print object preamble for msgpack * @param ctx * @param len */ -void ucl_emitter_print_object_msgpack (struct ucl_emitter_context *ctx, - size_t len); +void ucl_emitter_print_object_msgpack(struct ucl_emitter_context *ctx, + size_t len); /** * Print NULL to the msgpack output * @param ctx */ -void ucl_emitter_print_null_msgpack (struct ucl_emitter_context *ctx); +void ucl_emitter_print_null_msgpack(struct ucl_emitter_context *ctx); /** * Print object's key if needed to the msgpack output * @param print_key * @param ctx * @param obj */ -void ucl_emitter_print_key_msgpack (bool print_key, - struct ucl_emitter_context *ctx, - const ucl_object_t *obj); +void ucl_emitter_print_key_msgpack(bool print_key, + struct ucl_emitter_context *ctx, + const ucl_object_t *obj); /** * Fetch URL into a buffer @@ -620,11 +621,11 @@ void ucl_emitter_print_key_msgpack (bool print_key, * @param err pointer to error argument * @param must_exist fail if cannot find a url */ -bool ucl_fetch_url (const unsigned char *url, - unsigned char **buf, - size_t *buflen, - UT_string **err, - bool must_exist); +bool ucl_fetch_url(const unsigned char *url, + unsigned char **buf, + size_t *buflen, + UT_string **err, + bool must_exist); /** * Fetch a file and save results to the memory buffer @@ -634,11 +635,11 @@ bool ucl_fetch_url (const unsigned char *url, * @param buflen target length * @return */ -bool ucl_fetch_file (const unsigned char *filename, - unsigned char **buf, - size_t *buflen, - UT_string **err, - bool must_exist); +bool ucl_fetch_file(const unsigned char *filename, + unsigned char **buf, + size_t *buflen, + UT_string **err, + bool must_exist); /** * Add new element to an object using the current merge strategy and priority @@ -646,22 +647,22 @@ bool ucl_fetch_file (const unsigned char *filename, * @param nobj * @return */ -bool ucl_parser_process_object_element (struct ucl_parser *parser, - ucl_object_t *nobj); +bool ucl_parser_process_object_element(struct ucl_parser *parser, + ucl_object_t *nobj); /** * Parse msgpack chunk * @param parser * @return */ -bool ucl_parse_msgpack (struct ucl_parser *parser); +bool ucl_parse_msgpack(struct ucl_parser *parser); -bool ucl_parse_csexp (struct ucl_parser *parser); +bool ucl_parse_csexp(struct ucl_parser *parser); /** * Free ucl chunk * @param chunk */ -void ucl_chunk_free (struct ucl_chunk *chunk); +void ucl_chunk_free(struct ucl_chunk *chunk); #endif /* UCL_INTERNAL_H_ */ diff --git a/src/ucl_msgpack.c b/src/ucl_msgpack.c index 3335e39cd9e7..536ac4881aa8 100644 --- a/src/ucl_msgpack.c +++ b/src/ucl_msgpack.c @@ -39,46 +39,51 @@ #endif #if !defined(__LITTLE_ENDIAN__) && !defined(__BIG_ENDIAN__) - #if __BYTE_ORDER == __LITTLE_ENDIAN - #define __LITTLE_ENDIAN__ - #elif __BYTE_ORDER == __BIG_ENDIAN - #define __BIG_ENDIAN__ - #elif _WIN32 - #define __LITTLE_ENDIAN__ - #endif +#if __BYTE_ORDER == __LITTLE_ENDIAN +#define __LITTLE_ENDIAN__ +#elif __BYTE_ORDER == __BIG_ENDIAN +#define __BIG_ENDIAN__ +#elif _WIN32 +#define __LITTLE_ENDIAN__ +#endif #endif -#define SWAP_LE_BE16(val) ((uint16_t) ( \ - (uint16_t) ((uint16_t) (val) >> 8) | \ - (uint16_t) ((uint16_t) (val) << 8))) +#define SWAP_LE_BE16(val) ((uint16_t) ((uint16_t) ((uint16_t) (val) >> 8) | \ + (uint16_t) ((uint16_t) (val) << 8))) -#if defined(__clang__) || (defined(__GNUC__) && __GNUC__ >= 4 && defined (__GNUC_MINOR__) && __GNUC_MINOR__ >= 3) -# define SWAP_LE_BE32(val) ((uint32_t)__builtin_bswap32 ((uint32_t)(val))) -# define SWAP_LE_BE64(val) ((uint64_t)__builtin_bswap64 ((uint64_t)(val))) +#if defined(__clang__) || (defined(__GNUC__) && __GNUC__ >= 4 && defined(__GNUC_MINOR__) && __GNUC_MINOR__ >= 3) +#define SWAP_LE_BE32(val) ((uint32_t) __builtin_bswap32((uint32_t) (val))) +#define SWAP_LE_BE64(val) ((uint64_t) __builtin_bswap64((uint64_t) (val))) #else - #define SWAP_LE_BE32(val) ((uint32_t)( \ - (((uint32_t)(val) & (uint32_t)0x000000ffU) << 24) | \ - (((uint32_t)(val) & (uint32_t)0x0000ff00U) << 8) | \ - (((uint32_t)(val) & (uint32_t)0x00ff0000U) >> 8) | \ - (((uint32_t)(val) & (uint32_t)0xff000000U) >> 24))) - - #define SWAP_LE_BE64(val) ((uint64_t)( \ - (((uint64_t)(val) & \ - (uint64_t)(0x00000000000000ffULL)) << 56) | \ - (((uint64_t)(val) & \ - (uint64_t)(0x000000000000ff00ULL)) << 40) | \ - (((uint64_t)(val) & \ - (uint64_t)(0x0000000000ff0000ULL)) << 24) | \ - (((uint64_t)(val) & \ - (uint64_t) (0x00000000ff000000ULL)) << 8) | \ - (((uint64_t)(val) & \ - (uint64_t)(0x000000ff00000000ULL)) >> 8) | \ - (((uint64_t)(val) & \ - (uint64_t)(0x0000ff0000000000ULL)) >> 24) | \ - (((uint64_t)(val) & \ - (uint64_t)(0x00ff000000000000ULL)) >> 40) | \ - (((uint64_t)(val) & \ - (uint64_t)(0xff00000000000000ULL)) >> 56))) +#define SWAP_LE_BE32(val) ((uint32_t) ((((uint32_t) (val) & (uint32_t) 0x000000ffU) << 24) | \ + (((uint32_t) (val) & (uint32_t) 0x0000ff00U) << 8) | \ + (((uint32_t) (val) & (uint32_t) 0x00ff0000U) >> 8) | \ + (((uint32_t) (val) & (uint32_t) 0xff000000U) >> 24))) + +#define SWAP_LE_BE64(val) ((uint64_t) ((((uint64_t) (val) & \ + (uint64_t) (0x00000000000000ffULL)) \ + << 56) | \ + (((uint64_t) (val) & \ + (uint64_t) (0x000000000000ff00ULL)) \ + << 40) | \ + (((uint64_t) (val) & \ + (uint64_t) (0x0000000000ff0000ULL)) \ + << 24) | \ + (((uint64_t) (val) & \ + (uint64_t) (0x00000000ff000000ULL)) \ + << 8) | \ + (((uint64_t) (val) & \ + (uint64_t) (0x000000ff00000000ULL)) >> \ + 8) | \ + (((uint64_t) (val) & \ + (uint64_t) (0x0000ff0000000000ULL)) >> \ + 24) | \ + (((uint64_t) (val) & \ + (uint64_t) (0x00ff000000000000ULL)) >> \ + 40) | \ + (((uint64_t) (val) & \ + (uint64_t) (0xff00000000000000ULL)) >> \ + 56))) #endif #ifdef __LITTLE_ENDIAN__ @@ -89,22 +94,21 @@ #define FROM_BE32 SWAP_LE_BE32 #define FROM_BE64 SWAP_LE_BE64 #else -#define TO_BE16(val) (uint16_t)(val) -#define TO_BE32(val) (uint32_t)(val) -#define TO_BE64(val) (uint64_t)(val) -#define FROM_BE16(val) (uint16_t)(val) -#define FROM_BE32(val) (uint32_t)(val) -#define FROM_BE64(val) (uint64_t)(val) +#define TO_BE16(val) (uint16_t) (val) +#define TO_BE32(val) (uint32_t) (val) +#define TO_BE64(val) (uint64_t) (val) +#define FROM_BE16(val) (uint16_t) (val) +#define FROM_BE32(val) (uint32_t) (val) +#define FROM_BE64(val) (uint64_t) (val) #endif -void -ucl_emitter_print_int_msgpack (struct ucl_emitter_context *ctx, int64_t val) +void ucl_emitter_print_int_msgpack(struct ucl_emitter_context *ctx, int64_t val) { const struct ucl_emitter_functions *func = ctx->func; unsigned char buf[sizeof(uint64_t) + 1]; const unsigned char mask_positive = 0x7f, mask_negative = 0xe0, - uint8_ch = 0xcc, uint16_ch = 0xcd, uint32_ch = 0xce, uint64_ch = 0xcf, - int8_ch = 0xd0, int16_ch = 0xd1, int32_ch = 0xd2, int64_ch = 0xd3; + uint8_ch = 0xcc, uint16_ch = 0xcd, uint32_ch = 0xce, uint64_ch = 0xcf, + int8_ch = 0xd0, int16_ch = 0xd1, int32_ch = 0xd2, int64_ch = 0xd3; unsigned len; if (val >= 0) { @@ -119,25 +123,25 @@ ucl_emitter_print_int_msgpack (struct ucl_emitter_context *ctx, int64_t val) buf[1] = val & 0xff; } else if (val <= UINT16_MAX) { - uint16_t v = TO_BE16 (val); + uint16_t v = TO_BE16(val); len = 3; buf[0] = uint16_ch; - memcpy (&buf[1], &v, sizeof (v)); + memcpy(&buf[1], &v, sizeof(v)); } else if (val <= UINT32_MAX) { - uint32_t v = TO_BE32 (val); + uint32_t v = TO_BE32(val); len = 5; buf[0] = uint32_ch; - memcpy (&buf[1], &v, sizeof (v)); + memcpy(&buf[1], &v, sizeof(v)); } else { - uint64_t v = TO_BE64 (val); + uint64_t v = TO_BE64(val); len = 9; buf[0] = uint64_ch; - memcpy (&buf[1], &v, sizeof (v)); + memcpy(&buf[1], &v, sizeof(v)); } } else { @@ -150,39 +154,38 @@ ucl_emitter_print_int_msgpack (struct ucl_emitter_context *ctx, int64_t val) buf[0] = (mask_negative | uval) & 0xff; } else if (uval <= INT8_MAX) { - uint8_t v = (uint8_t)val; + uint8_t v = (uint8_t) val; len = 2; buf[0] = int8_ch; buf[1] = v; } else if (uval <= INT16_MAX) { - uint16_t v = TO_BE16 (val); + uint16_t v = TO_BE16(val); len = 3; buf[0] = int16_ch; - memcpy (&buf[1], &v, sizeof (v)); + memcpy(&buf[1], &v, sizeof(v)); } else if (uval <= INT32_MAX) { - uint32_t v = TO_BE32 (val); + uint32_t v = TO_BE32(val); len = 5; buf[0] = int32_ch; - memcpy (&buf[1], &v, sizeof (v)); + memcpy(&buf[1], &v, sizeof(v)); } else { - uint64_t v = TO_BE64 (val); + uint64_t v = TO_BE64(val); len = 9; buf[0] = int64_ch; - memcpy (&buf[1], &v, sizeof (v)); + memcpy(&buf[1], &v, sizeof(v)); } } - func->ucl_emitter_append_len (buf, len, func->ud); + func->ucl_emitter_append_len(buf, len, func->ud); } -void -ucl_emitter_print_double_msgpack (struct ucl_emitter_context *ctx, double val) +void ucl_emitter_print_double_msgpack(struct ucl_emitter_context *ctx, double val) { const struct ucl_emitter_functions *func = ctx->func; union { @@ -194,25 +197,23 @@ ucl_emitter_print_double_msgpack (struct ucl_emitter_context *ctx, double val) /* Convert to big endian */ u.d = val; - u.i = TO_BE64 (u.i); + u.i = TO_BE64(u.i); buf[0] = dbl_ch; - memcpy (&buf[1], &u.d, sizeof (double)); - func->ucl_emitter_append_len (buf, sizeof (buf), func->ud); + memcpy(&buf[1], &u.d, sizeof(double)); + func->ucl_emitter_append_len(buf, sizeof(buf), func->ud); } -void -ucl_emitter_print_bool_msgpack (struct ucl_emitter_context *ctx, bool val) +void ucl_emitter_print_bool_msgpack(struct ucl_emitter_context *ctx, bool val) { const struct ucl_emitter_functions *func = ctx->func; const unsigned char true_ch = 0xc3, false_ch = 0xc2; - func->ucl_emitter_append_character (val ? true_ch : false_ch, 1, func->ud); + func->ucl_emitter_append_character(val ? true_ch : false_ch, 1, func->ud); } -void -ucl_emitter_print_string_msgpack (struct ucl_emitter_context *ctx, - const char *s, size_t len) +void ucl_emitter_print_string_msgpack(struct ucl_emitter_context *ctx, + const char *s, size_t len) { const struct ucl_emitter_functions *func = ctx->func; const unsigned char fix_mask = 0xA0, l8_ch = 0xd9, l16_ch = 0xda, l32_ch = 0xdb; @@ -229,27 +230,26 @@ ucl_emitter_print_string_msgpack (struct ucl_emitter_context *ctx, buf[1] = len & 0xff; } else if (len <= 0xffff) { - uint16_t bl = TO_BE16 (len); + uint16_t bl = TO_BE16(len); blen = 3; buf[0] = l16_ch; - memcpy (&buf[1], &bl, sizeof (bl)); + memcpy(&buf[1], &bl, sizeof(bl)); } else { - uint32_t bl = TO_BE32 (len); + uint32_t bl = TO_BE32(len); blen = 5; buf[0] = l32_ch; - memcpy (&buf[1], &bl, sizeof (bl)); + memcpy(&buf[1], &bl, sizeof(bl)); } - func->ucl_emitter_append_len (buf, blen, func->ud); - func->ucl_emitter_append_len (s, len, func->ud); + func->ucl_emitter_append_len(buf, blen, func->ud); + func->ucl_emitter_append_len(s, len, func->ud); } -void -ucl_emitter_print_binary_string_msgpack (struct ucl_emitter_context *ctx, - const char *s, size_t len) +void ucl_emitter_print_binary_string_msgpack(struct ucl_emitter_context *ctx, + const char *s, size_t len) { const struct ucl_emitter_functions *func = ctx->func; const unsigned char l8_ch = 0xc4, l16_ch = 0xc5, l32_ch = 0xc6; @@ -262,44 +262,41 @@ ucl_emitter_print_binary_string_msgpack (struct ucl_emitter_context *ctx, buf[1] = len & 0xff; } else if (len <= 0xffff) { - uint16_t bl = TO_BE16 (len); + uint16_t bl = TO_BE16(len); blen = 3; buf[0] = l16_ch; - memcpy (&buf[1], &bl, sizeof (bl)); + memcpy(&buf[1], &bl, sizeof(bl)); } else { - uint32_t bl = TO_BE32 (len); + uint32_t bl = TO_BE32(len); blen = 5; buf[0] = l32_ch; - memcpy (&buf[1], &bl, sizeof (bl)); + memcpy(&buf[1], &bl, sizeof(bl)); } - func->ucl_emitter_append_len (buf, blen, func->ud); - func->ucl_emitter_append_len (s, len, func->ud); + func->ucl_emitter_append_len(buf, blen, func->ud); + func->ucl_emitter_append_len(s, len, func->ud); } -void -ucl_emitter_print_null_msgpack (struct ucl_emitter_context *ctx) +void ucl_emitter_print_null_msgpack(struct ucl_emitter_context *ctx) { const struct ucl_emitter_functions *func = ctx->func; const unsigned char nil = 0xc0; - func->ucl_emitter_append_character (nil, 1, func->ud); + func->ucl_emitter_append_character(nil, 1, func->ud); } -void -ucl_emitter_print_key_msgpack (bool print_key, struct ucl_emitter_context *ctx, - const ucl_object_t *obj) +void ucl_emitter_print_key_msgpack(bool print_key, struct ucl_emitter_context *ctx, + const ucl_object_t *obj) { if (print_key) { - ucl_emitter_print_string_msgpack (ctx, obj->key, obj->keylen); + ucl_emitter_print_string_msgpack(ctx, obj->key, obj->keylen); } } -void -ucl_emitter_print_array_msgpack (struct ucl_emitter_context *ctx, size_t len) +void ucl_emitter_print_array_msgpack(struct ucl_emitter_context *ctx, size_t len) { const struct ucl_emitter_functions *func = ctx->func; const unsigned char fix_mask = 0x90, l16_ch = 0xdc, l32_ch = 0xdd; @@ -311,25 +308,24 @@ ucl_emitter_print_array_msgpack (struct ucl_emitter_context *ctx, size_t len) buf[0] = (len | fix_mask) & 0xff; } else if (len <= 0xffff) { - uint16_t bl = TO_BE16 (len); + uint16_t bl = TO_BE16(len); blen = 3; buf[0] = l16_ch; - memcpy (&buf[1], &bl, sizeof (bl)); + memcpy(&buf[1], &bl, sizeof(bl)); } else { - uint32_t bl = TO_BE32 (len); + uint32_t bl = TO_BE32(len); blen = 5; buf[0] = l32_ch; - memcpy (&buf[1], &bl, sizeof (bl)); + memcpy(&buf[1], &bl, sizeof(bl)); } - func->ucl_emitter_append_len (buf, blen, func->ud); + func->ucl_emitter_append_len(buf, blen, func->ud); } -void -ucl_emitter_print_object_msgpack (struct ucl_emitter_context *ctx, size_t len) +void ucl_emitter_print_object_msgpack(struct ucl_emitter_context *ctx, size_t len) { const struct ucl_emitter_functions *func = ctx->func; const unsigned char fix_mask = 0x80, l16_ch = 0xde, l32_ch = 0xdf; @@ -341,21 +337,21 @@ ucl_emitter_print_object_msgpack (struct ucl_emitter_context *ctx, size_t len) buf[0] = (len | fix_mask) & 0xff; } else if (len <= 0xffff) { - uint16_t bl = TO_BE16 (len); + uint16_t bl = TO_BE16(len); blen = 3; buf[0] = l16_ch; - memcpy (&buf[1], &bl, sizeof (bl)); + memcpy(&buf[1], &bl, sizeof(bl)); } else { - uint32_t bl = TO_BE32 (len); + uint32_t bl = TO_BE32(len); blen = 5; buf[0] = l32_ch; - memcpy (&buf[1], &bl, sizeof (bl)); + memcpy(&buf[1], &bl, sizeof(bl)); } - func->ucl_emitter_append_len (buf, blen, func->ud); + func->ucl_emitter_append_len(buf, blen, func->ud); } @@ -400,33 +396,33 @@ enum ucl_msgpack_format { }; typedef ssize_t (*ucl_msgpack_parse_function)(struct ucl_parser *parser, - struct ucl_stack *container, size_t len, enum ucl_msgpack_format fmt, - const unsigned char *pos, size_t remain); - -static ssize_t ucl_msgpack_parse_map (struct ucl_parser *parser, - struct ucl_stack *container, size_t len, enum ucl_msgpack_format fmt, - const unsigned char *pos, size_t remain); -static ssize_t ucl_msgpack_parse_array (struct ucl_parser *parser, - struct ucl_stack *container, size_t len, enum ucl_msgpack_format fmt, - const unsigned char *pos, size_t remain); -static ssize_t ucl_msgpack_parse_string (struct ucl_parser *parser, - struct ucl_stack *container, size_t len, enum ucl_msgpack_format fmt, - const unsigned char *pos, size_t remain); -static ssize_t ucl_msgpack_parse_int (struct ucl_parser *parser, - struct ucl_stack *container, size_t len, enum ucl_msgpack_format fmt, - const unsigned char *pos, size_t remain); -static ssize_t ucl_msgpack_parse_float (struct ucl_parser *parser, - struct ucl_stack *container, size_t len, enum ucl_msgpack_format fmt, - const unsigned char *pos, size_t remain); -static ssize_t ucl_msgpack_parse_bool (struct ucl_parser *parser, - struct ucl_stack *container, size_t len, enum ucl_msgpack_format fmt, - const unsigned char *pos, size_t remain); -static ssize_t ucl_msgpack_parse_null (struct ucl_parser *parser, - struct ucl_stack *container, size_t len, enum ucl_msgpack_format fmt, - const unsigned char *pos, size_t remain); -static ssize_t ucl_msgpack_parse_ignore (struct ucl_parser *parser, - struct ucl_stack *container, size_t len, enum ucl_msgpack_format fmt, - const unsigned char *pos, size_t remain); + struct ucl_stack *container, size_t len, enum ucl_msgpack_format fmt, + const unsigned char *pos, size_t remain); + +static ssize_t ucl_msgpack_parse_map(struct ucl_parser *parser, + struct ucl_stack *container, size_t len, enum ucl_msgpack_format fmt, + const unsigned char *pos, size_t remain); +static ssize_t ucl_msgpack_parse_array(struct ucl_parser *parser, + struct ucl_stack *container, size_t len, enum ucl_msgpack_format fmt, + const unsigned char *pos, size_t remain); +static ssize_t ucl_msgpack_parse_string(struct ucl_parser *parser, + struct ucl_stack *container, size_t len, enum ucl_msgpack_format fmt, + const unsigned char *pos, size_t remain); +static ssize_t ucl_msgpack_parse_int(struct ucl_parser *parser, + struct ucl_stack *container, size_t len, enum ucl_msgpack_format fmt, + const unsigned char *pos, size_t remain); +static ssize_t ucl_msgpack_parse_float(struct ucl_parser *parser, + struct ucl_stack *container, size_t len, enum ucl_msgpack_format fmt, + const unsigned char *pos, size_t remain); +static ssize_t ucl_msgpack_parse_bool(struct ucl_parser *parser, + struct ucl_stack *container, size_t len, enum ucl_msgpack_format fmt, + const unsigned char *pos, size_t remain); +static ssize_t ucl_msgpack_parse_null(struct ucl_parser *parser, + struct ucl_stack *container, size_t len, enum ucl_msgpack_format fmt, + const unsigned char *pos, size_t remain); +static ssize_t ucl_msgpack_parse_ignore(struct ucl_parser *parser, + struct ucl_stack *container, size_t len, enum ucl_msgpack_format fmt, + const unsigned char *pos, size_t remain); #define MSGPACK_FLAG_FIXED (1 << 0) #define MSGPACK_FLAG_CONTAINER (1 << 1) @@ -439,318 +435,245 @@ static ssize_t ucl_msgpack_parse_ignore (struct ucl_parser *parser, * Search tree packed in array */ struct ucl_msgpack_parser { - uint8_t prefix; /* Prefix byte */ - uint8_t prefixlen; /* Length of prefix in bits */ - uint8_t fmt; /* The desired format */ - uint8_t len; /* Length of the object + uint8_t prefix; /* Prefix byte */ + uint8_t prefixlen; /* Length of prefix in bits */ + uint8_t fmt; /* The desired format */ + uint8_t len; /* Length of the object (either length bytes or length of value in case of fixed objects */ - uint8_t flags; /* Flags of the specified type */ - ucl_msgpack_parse_function func; /* Parser function */ + uint8_t flags; /* Flags of the specified type */ + ucl_msgpack_parse_function func; /* Parser function */ } parsers[] = { - { - 0xa0, - 3, - msgpack_fixstr, - 0, - MSGPACK_FLAG_FIXED|MSGPACK_FLAG_KEY, - ucl_msgpack_parse_string - }, - { - 0x0, - 1, - msgpack_positive_fixint, - 0, - MSGPACK_FLAG_FIXED|MSGPACK_FLAG_TYPEVALUE, - ucl_msgpack_parse_int - }, - { - 0xe0, - 3, - msgpack_negative_fixint, - 0, - MSGPACK_FLAG_FIXED|MSGPACK_FLAG_TYPEVALUE, - ucl_msgpack_parse_int - }, - { - 0x80, - 4, - msgpack_fixmap, - 0, - MSGPACK_FLAG_FIXED|MSGPACK_FLAG_CONTAINER|MSGPACK_FLAG_ASSOC, - ucl_msgpack_parse_map - }, - { - 0x90, - 4, - msgpack_fixarray, - 0, - MSGPACK_FLAG_FIXED|MSGPACK_FLAG_CONTAINER, - ucl_msgpack_parse_array - }, - { - 0xd9, - 8, - msgpack_str8, - 1, - MSGPACK_FLAG_KEY, - ucl_msgpack_parse_string - }, - { - 0xc4, - 8, - msgpack_bin8, - 1, - MSGPACK_FLAG_KEY, - ucl_msgpack_parse_string - }, - { - 0xcf, - 8, - msgpack_uint64, - 8, - MSGPACK_FLAG_FIXED, - ucl_msgpack_parse_int - }, - { - 0xd3, - 8, - msgpack_int64, - 8, - MSGPACK_FLAG_FIXED, - ucl_msgpack_parse_int - }, - { - 0xce, - 8, - msgpack_uint32, - 4, - MSGPACK_FLAG_FIXED, - ucl_msgpack_parse_int - }, - { - 0xd2, - 8, - msgpack_int32, - 4, - MSGPACK_FLAG_FIXED, - ucl_msgpack_parse_int - }, - { - 0xcb, - 8, - msgpack_float64, - 8, - MSGPACK_FLAG_FIXED, - ucl_msgpack_parse_float - }, - { - 0xca, - 8, - msgpack_float32, - 4, - MSGPACK_FLAG_FIXED, - ucl_msgpack_parse_float - }, - { - 0xc2, - 8, - msgpack_false, - 1, - MSGPACK_FLAG_FIXED | MSGPACK_FLAG_TYPEVALUE, - ucl_msgpack_parse_bool - }, - { - 0xc3, - 8, - msgpack_true, - 1, - MSGPACK_FLAG_FIXED | MSGPACK_FLAG_TYPEVALUE, - ucl_msgpack_parse_bool - }, - { - 0xcc, - 8, - msgpack_uint8, - 1, - MSGPACK_FLAG_FIXED, - ucl_msgpack_parse_int - }, - { - 0xcd, - 8, - msgpack_uint16, - 2, - MSGPACK_FLAG_FIXED, - ucl_msgpack_parse_int - }, - { - 0xd0, - 8, - msgpack_int8, - 1, - MSGPACK_FLAG_FIXED, - ucl_msgpack_parse_int - }, - { - 0xd1, - 8, - msgpack_int16, - 2, - MSGPACK_FLAG_FIXED, - ucl_msgpack_parse_int - }, - { - 0xc0, - 8, - msgpack_nil, - 0, - MSGPACK_FLAG_FIXED | MSGPACK_FLAG_TYPEVALUE, - ucl_msgpack_parse_null - }, - { - 0xda, - 8, - msgpack_str16, - 2, - MSGPACK_FLAG_KEY, - ucl_msgpack_parse_string - }, - { - 0xdb, - 8, - msgpack_str32, - 4, - MSGPACK_FLAG_KEY, - ucl_msgpack_parse_string - }, - { - 0xc5, - 8, - msgpack_bin16, - 2, - MSGPACK_FLAG_KEY, - ucl_msgpack_parse_string - }, - { - 0xc6, - 8, - msgpack_bin32, - 4, - MSGPACK_FLAG_KEY, - ucl_msgpack_parse_string - }, - { - 0xdc, - 8, - msgpack_array16, - 2, - MSGPACK_FLAG_CONTAINER, - ucl_msgpack_parse_array - }, - { - 0xdd, - 8, - msgpack_array32, - 4, - MSGPACK_FLAG_CONTAINER, - ucl_msgpack_parse_array - }, - { - 0xde, - 8, - msgpack_map16, - 2, - MSGPACK_FLAG_CONTAINER|MSGPACK_FLAG_ASSOC, - ucl_msgpack_parse_map - }, - { - 0xdf, - 8, - msgpack_map32, - 4, - MSGPACK_FLAG_CONTAINER|MSGPACK_FLAG_ASSOC, - ucl_msgpack_parse_map - }, - { - 0xc7, - 8, - msgpack_ext8, - 1, - MSGPACK_FLAG_EXT, - ucl_msgpack_parse_ignore - }, - { - 0xc8, - 8, - msgpack_ext16, - 2, - MSGPACK_FLAG_EXT, - ucl_msgpack_parse_ignore - }, - { - 0xc9, - 8, - msgpack_ext32, - 4, - MSGPACK_FLAG_EXT, - ucl_msgpack_parse_ignore - }, - { - 0xd4, - 8, - msgpack_fixext1, - 1, - MSGPACK_FLAG_FIXED | MSGPACK_FLAG_EXT, - ucl_msgpack_parse_ignore - }, - { - 0xd5, - 8, - msgpack_fixext2, - 2, - MSGPACK_FLAG_FIXED | MSGPACK_FLAG_EXT, - ucl_msgpack_parse_ignore - }, - { - 0xd6, - 8, - msgpack_fixext4, - 4, - MSGPACK_FLAG_FIXED | MSGPACK_FLAG_EXT, - ucl_msgpack_parse_ignore - }, - { - 0xd7, - 8, - msgpack_fixext8, - 8, - MSGPACK_FLAG_FIXED | MSGPACK_FLAG_EXT, - ucl_msgpack_parse_ignore - }, - { - 0xd8, - 8, - msgpack_fixext16, - 16, - MSGPACK_FLAG_FIXED | MSGPACK_FLAG_EXT, - ucl_msgpack_parse_ignore - } -}; + {0xa0, + 3, + msgpack_fixstr, + 0, + MSGPACK_FLAG_FIXED | MSGPACK_FLAG_KEY, + ucl_msgpack_parse_string}, + {0x0, + 1, + msgpack_positive_fixint, + 0, + MSGPACK_FLAG_FIXED | MSGPACK_FLAG_TYPEVALUE, + ucl_msgpack_parse_int}, + {0xe0, + 3, + msgpack_negative_fixint, + 0, + MSGPACK_FLAG_FIXED | MSGPACK_FLAG_TYPEVALUE, + ucl_msgpack_parse_int}, + {0x80, + 4, + msgpack_fixmap, + 0, + MSGPACK_FLAG_FIXED | MSGPACK_FLAG_CONTAINER | MSGPACK_FLAG_ASSOC, + ucl_msgpack_parse_map}, + {0x90, + 4, + msgpack_fixarray, + 0, + MSGPACK_FLAG_FIXED | MSGPACK_FLAG_CONTAINER, + ucl_msgpack_parse_array}, + {0xd9, + 8, + msgpack_str8, + 1, + MSGPACK_FLAG_KEY, + ucl_msgpack_parse_string}, + {0xc4, + 8, + msgpack_bin8, + 1, + MSGPACK_FLAG_KEY, + ucl_msgpack_parse_string}, + {0xcf, + 8, + msgpack_uint64, + 8, + MSGPACK_FLAG_FIXED, + ucl_msgpack_parse_int}, + {0xd3, + 8, + msgpack_int64, + 8, + MSGPACK_FLAG_FIXED, + ucl_msgpack_parse_int}, + {0xce, + 8, + msgpack_uint32, + 4, + MSGPACK_FLAG_FIXED, + ucl_msgpack_parse_int}, + {0xd2, + 8, + msgpack_int32, + 4, + MSGPACK_FLAG_FIXED, + ucl_msgpack_parse_int}, + {0xcb, + 8, + msgpack_float64, + 8, + MSGPACK_FLAG_FIXED, + ucl_msgpack_parse_float}, + {0xca, + 8, + msgpack_float32, + 4, + MSGPACK_FLAG_FIXED, + ucl_msgpack_parse_float}, + {0xc2, + 8, + msgpack_false, + 1, + MSGPACK_FLAG_FIXED | MSGPACK_FLAG_TYPEVALUE, + ucl_msgpack_parse_bool}, + {0xc3, + 8, + msgpack_true, + 1, + MSGPACK_FLAG_FIXED | MSGPACK_FLAG_TYPEVALUE, + ucl_msgpack_parse_bool}, + {0xcc, + 8, + msgpack_uint8, + 1, + MSGPACK_FLAG_FIXED, + ucl_msgpack_parse_int}, + {0xcd, + 8, + msgpack_uint16, + 2, + MSGPACK_FLAG_FIXED, + ucl_msgpack_parse_int}, + {0xd0, + 8, + msgpack_int8, + 1, + MSGPACK_FLAG_FIXED, + ucl_msgpack_parse_int}, + {0xd1, + 8, + msgpack_int16, + 2, + MSGPACK_FLAG_FIXED, + ucl_msgpack_parse_int}, + {0xc0, + 8, + msgpack_nil, + 0, + MSGPACK_FLAG_FIXED | MSGPACK_FLAG_TYPEVALUE, + ucl_msgpack_parse_null}, + {0xda, + 8, + msgpack_str16, + 2, + MSGPACK_FLAG_KEY, + ucl_msgpack_parse_string}, + {0xdb, + 8, + msgpack_str32, + 4, + MSGPACK_FLAG_KEY, + ucl_msgpack_parse_string}, + {0xc5, + 8, + msgpack_bin16, + 2, + MSGPACK_FLAG_KEY, + ucl_msgpack_parse_string}, + {0xc6, + 8, + msgpack_bin32, + 4, + MSGPACK_FLAG_KEY, + ucl_msgpack_parse_string}, + {0xdc, + 8, + msgpack_array16, + 2, + MSGPACK_FLAG_CONTAINER, + ucl_msgpack_parse_array}, + {0xdd, + 8, + msgpack_array32, + 4, + MSGPACK_FLAG_CONTAINER, + ucl_msgpack_parse_array}, + {0xde, + 8, + msgpack_map16, + 2, + MSGPACK_FLAG_CONTAINER | MSGPACK_FLAG_ASSOC, + ucl_msgpack_parse_map}, + {0xdf, + 8, + msgpack_map32, + 4, + MSGPACK_FLAG_CONTAINER | MSGPACK_FLAG_ASSOC, + ucl_msgpack_parse_map}, + {0xc7, + 8, + msgpack_ext8, + 1, + MSGPACK_FLAG_EXT, + ucl_msgpack_parse_ignore}, + {0xc8, + 8, + msgpack_ext16, + 2, + MSGPACK_FLAG_EXT, + ucl_msgpack_parse_ignore}, + {0xc9, + 8, + msgpack_ext32, + 4, + MSGPACK_FLAG_EXT, + ucl_msgpack_parse_ignore}, + {0xd4, + 8, + msgpack_fixext1, + 1, + MSGPACK_FLAG_FIXED | MSGPACK_FLAG_EXT, + ucl_msgpack_parse_ignore}, + {0xd5, + 8, + msgpack_fixext2, + 2, + MSGPACK_FLAG_FIXED | MSGPACK_FLAG_EXT, + ucl_msgpack_parse_ignore}, + {0xd6, + 8, + msgpack_fixext4, + 4, + MSGPACK_FLAG_FIXED | MSGPACK_FLAG_EXT, + ucl_msgpack_parse_ignore}, + {0xd7, + 8, + msgpack_fixext8, + 8, + MSGPACK_FLAG_FIXED | MSGPACK_FLAG_EXT, + ucl_msgpack_parse_ignore}, + {0xd8, + 8, + msgpack_fixext16, + 16, + MSGPACK_FLAG_FIXED | MSGPACK_FLAG_EXT, + ucl_msgpack_parse_ignore}}; #undef MSGPACK_DEBUG_PARSER static inline struct ucl_msgpack_parser * -ucl_msgpack_get_parser_from_type (unsigned char t) +ucl_msgpack_get_parser_from_type(unsigned char t) { unsigned int i, shift, mask; - for (i = 0; i < sizeof (parsers) / sizeof (parsers[0]); i ++) { + for (i = 0; i < sizeof(parsers) / sizeof(parsers[0]); i++) { shift = CHAR_BIT - parsers[i].prefixlen; mask = parsers[i].prefix >> shift; - if (mask == (((unsigned int)t) >> shift)) { + if (mask == (((unsigned int) t) >> shift)) { return &parsers[i]; } } @@ -759,32 +682,32 @@ ucl_msgpack_get_parser_from_type (unsigned char t) } static inline struct ucl_stack * -ucl_msgpack_get_container (struct ucl_parser *parser, - struct ucl_msgpack_parser *obj_parser, uint64_t len) +ucl_msgpack_get_container(struct ucl_parser *parser, + struct ucl_msgpack_parser *obj_parser, uint64_t len) { struct ucl_stack *stack; - assert (obj_parser != NULL); + assert(obj_parser != NULL); if (obj_parser->flags & MSGPACK_FLAG_CONTAINER) { /* * Insert new container to the stack */ if (parser->stack == NULL) { - parser->stack = calloc (1, sizeof (struct ucl_stack)); + parser->stack = calloc(1, sizeof(struct ucl_stack)); if (parser->stack == NULL) { - ucl_create_err (&parser->err, "no memory"); + ucl_create_err(&parser->err, "no memory"); return NULL; } parser->stack->chunk = parser->chunks; } else { - stack = calloc (1, sizeof (struct ucl_stack)); + stack = calloc(1, sizeof(struct ucl_stack)); if (stack == NULL) { - ucl_create_err (&parser->err, "no memory"); + ucl_create_err(&parser->err, "no memory"); return NULL; } @@ -802,7 +725,7 @@ ucl_msgpack_get_container (struct ucl_parser *parser, stack = stack->next; } - fprintf(stderr, "%s -> %d\n", obj_parser->flags & MSGPACK_FLAG_ASSOC ? "object" : "array", (int)len); + fprintf(stderr, "%s -> %d\n", obj_parser->flags & MSGPACK_FLAG_ASSOC ? "object" : "array", (int) len); #endif } else { @@ -813,7 +736,7 @@ ucl_msgpack_get_container (struct ucl_parser *parser, return parser->stack; } else { - ucl_create_err (&parser->err, "bad top level object for msgpack"); + ucl_create_err(&parser->err, "bad top level object for msgpack"); return NULL; } } @@ -822,9 +745,9 @@ ucl_msgpack_get_container (struct ucl_parser *parser, } static bool -ucl_msgpack_is_container_finished (struct ucl_stack *container) +ucl_msgpack_is_container_finished(struct ucl_stack *container) { - assert (container != NULL); + assert(container != NULL); if (container->e.len == 0) { @@ -835,24 +758,24 @@ ucl_msgpack_is_container_finished (struct ucl_stack *container) } static bool -ucl_msgpack_insert_object (struct ucl_parser *parser, - const unsigned char *key, - size_t keylen, ucl_object_t *obj) +ucl_msgpack_insert_object(struct ucl_parser *parser, + const unsigned char *key, + size_t keylen, ucl_object_t *obj) { struct ucl_stack *container; container = parser->stack; - assert (container != NULL); - assert (container->e.len > 0); - assert (obj != NULL); - assert (container->obj != NULL); + assert(container != NULL); + assert(container->e.len > 0); + assert(obj != NULL); + assert(container->obj != NULL); if (container->obj->type == UCL_ARRAY) { - ucl_array_append (container->obj, obj); + ucl_array_append(container->obj, obj); } else if (container->obj->type == UCL_OBJECT) { if (key == NULL || keylen == 0) { - ucl_create_err (&parser->err, "cannot insert object with no key"); + ucl_create_err(&parser->err, "cannot insert object with no key"); return false; } @@ -860,13 +783,13 @@ ucl_msgpack_insert_object (struct ucl_parser *parser, obj->keylen = keylen; if (!(parser->flags & UCL_PARSER_ZEROCOPY)) { - ucl_copy_key_trash (obj); + ucl_copy_key_trash(obj); } - ucl_parser_process_object_element (parser, obj); + ucl_parser_process_object_element(parser, obj); } else { - ucl_create_err (&parser->err, "bad container type"); + ucl_create_err(&parser->err, "bad container type"); return false; } @@ -876,7 +799,7 @@ ucl_msgpack_insert_object (struct ucl_parser *parser, } static struct ucl_stack * -ucl_msgpack_get_next_container (struct ucl_parser *parser) +ucl_msgpack_get_next_container(struct ucl_parser *parser) { struct ucl_stack *cur = NULL; uint64_t len; @@ -893,18 +816,18 @@ ucl_msgpack_get_next_container (struct ucl_parser *parser) /* We need to switch to the previous container */ parser->stack = cur->next; parser->cur_obj = cur->obj; - free (cur); + free(cur); #ifdef MSGPACK_DEBUG_PARSER cur = parser->stack; - while (cur) { - fprintf(stderr, "-"); - cur = cur->next; - } - fprintf(stderr, "-%s -> %d\n", parser->cur_obj->type == UCL_OBJECT ? "object" : "array", (int)parser->cur_obj->len); + while (cur) { + fprintf(stderr, "-"); + cur = cur->next; + } + fprintf(stderr, "-%s -> %d\n", parser->cur_obj->type == UCL_OBJECT ? "object" : "array", (int) parser->cur_obj->len); #endif - return ucl_msgpack_get_next_container (parser); + return ucl_msgpack_get_next_container(parser); } /* @@ -912,40 +835,41 @@ ucl_msgpack_get_next_container (struct ucl_parser *parser) * message pack blob into the top level container */ - assert (cur->obj != NULL); + assert(cur->obj != NULL); return cur; } -#define CONSUME_RET do { \ - if (ret != -1) { \ - p += ret; \ - remain -= ret; \ - obj_parser = NULL; \ - assert (remain >= 0); \ - } \ - else { \ - ucl_create_err (&parser->err, \ - "cannot parse type %d of len %u", \ - (int)obj_parser->fmt, \ - (unsigned)len); \ - return false; \ - } \ -} while(0) - -#define GET_NEXT_STATE do { \ - container = ucl_msgpack_get_next_container (parser); \ - if (container == NULL) { \ - ucl_create_err (&parser->err, \ - "empty container"); \ - return false; \ - } \ - next_state = container->obj->type == UCL_OBJECT ? \ - read_assoc_key : read_array_value; \ -} while(0) +#define CONSUME_RET \ + do { \ + if (ret != -1) { \ + p += ret; \ + remain -= ret; \ + obj_parser = NULL; \ + assert(remain >= 0); \ + } \ + else { \ + ucl_create_err(&parser->err, \ + "cannot parse type %d of len %u", \ + (int) obj_parser->fmt, \ + (unsigned) len); \ + return false; \ + } \ + } while (0) + +#define GET_NEXT_STATE \ + do { \ + container = ucl_msgpack_get_next_container(parser); \ + if (container == NULL) { \ + ucl_create_err(&parser->err, \ + "empty container"); \ + return false; \ + } \ + next_state = container->obj->type == UCL_OBJECT ? read_assoc_key : read_array_value; \ + } while (0) static bool -ucl_msgpack_consume (struct ucl_parser *parser) +ucl_msgpack_consume(struct ucl_parser *parser) { const unsigned char *p, *end, *key = NULL; struct ucl_stack *container; @@ -959,7 +883,8 @@ ucl_msgpack_consume (struct ucl_parser *parser) read_array_value, finish_array_value, error_state - } state = read_type, next_state = error_state; + } state = read_type, + next_state = error_state; struct ucl_msgpack_parser *obj_parser = NULL; uint64_t len = 0; ssize_t ret, remain, keylen = 0; @@ -979,11 +904,11 @@ ucl_msgpack_consume (struct ucl_parser *parser) #endif switch (state) { case read_type: - obj_parser = ucl_msgpack_get_parser_from_type (*p); + obj_parser = ucl_msgpack_get_parser_from_type(*p); if (obj_parser == NULL) { - ucl_create_err (&parser->err, "unknown msgpack format: %x", - (unsigned int)*p); + ucl_create_err(&parser->err, "unknown msgpack format: %x", + (unsigned int) *p); return false; } @@ -995,9 +920,9 @@ ucl_msgpack_consume (struct ucl_parser *parser) } else { if (remain < obj_parser->len) { - ucl_create_err (&parser->err, "not enough data remain to " - "read object's length: %u remain, %u needed", - (unsigned)remain, obj_parser->len); + ucl_create_err(&parser->err, "not enough data remain to " + "read object's length: %u remain, %u needed", + (unsigned) remain, obj_parser->len); return false; } @@ -1008,8 +933,8 @@ ucl_msgpack_consume (struct ucl_parser *parser) if (!(obj_parser->flags & MSGPACK_FLAG_TYPEVALUE)) { /* We must pass value as the second byte */ if (remain > 0) { - p ++; - remain --; + p++; + remain--; } } else { @@ -1019,34 +944,34 @@ ucl_msgpack_consume (struct ucl_parser *parser) } else { /* Length is not embedded */ - remain --; + remain--; if (remain < obj_parser->len) { - ucl_create_err (&parser->err, "not enough data remain to " - "read object's length: %u remain, %u needed", - (unsigned)remain, obj_parser->len); + ucl_create_err(&parser->err, "not enough data remain to " + "read object's length: %u remain, %u needed", + (unsigned) remain, obj_parser->len); return false; } - p ++; + p++; switch (obj_parser->len) { case 1: len = *p; break; case 2: - len = FROM_BE16 (*(uint16_t *)p); + len = FROM_BE16(*(uint16_t *) p); break; case 4: - len = FROM_BE32 (*(uint32_t *)p); + len = FROM_BE32(*(uint32_t *) p); break; case 8: - len = FROM_BE64 (*(uint64_t *)p); + len = FROM_BE64(*(uint64_t *) p); break; default: - ucl_create_err (&parser->err, "invalid length of the length field: %u", - (unsigned)obj_parser->len); + ucl_create_err(&parser->err, "invalid length of the length field: %u", + (unsigned) obj_parser->len); return false; } @@ -1059,7 +984,7 @@ ucl_msgpack_consume (struct ucl_parser *parser) /* We have just read the new associative map */ state = start_assoc; } - else if (obj_parser->flags & MSGPACK_FLAG_CONTAINER){ + else if (obj_parser->flags & MSGPACK_FLAG_CONTAINER) { state = start_array; } else { @@ -1068,22 +993,22 @@ ucl_msgpack_consume (struct ucl_parser *parser) break; case start_assoc: - parser->cur_obj = ucl_object_new_full (UCL_OBJECT, - parser->chunks->priority); + parser->cur_obj = ucl_object_new_full(UCL_OBJECT, + parser->chunks->priority); /* Insert to the previous level container */ - if (parser->stack && !ucl_msgpack_insert_object (parser, - key, keylen, parser->cur_obj)) { + if (parser->stack && !ucl_msgpack_insert_object(parser, + key, keylen, parser->cur_obj)) { return false; } /* Get new container */ - container = ucl_msgpack_get_container (parser, obj_parser, len); + container = ucl_msgpack_get_container(parser, obj_parser, len); if (container == NULL) { return false; } - ret = obj_parser->func (parser, container, len, obj_parser->fmt, - p, remain); + ret = obj_parser->func(parser, container, len, obj_parser->fmt, + p, remain); CONSUME_RET; key = NULL; keylen = 0; @@ -1099,22 +1024,22 @@ ucl_msgpack_consume (struct ucl_parser *parser) break; case start_array: - parser->cur_obj = ucl_object_new_full (UCL_ARRAY, - parser->chunks->priority); + parser->cur_obj = ucl_object_new_full(UCL_ARRAY, + parser->chunks->priority); /* Insert to the previous level container */ - if (parser->stack && !ucl_msgpack_insert_object (parser, - key, keylen, parser->cur_obj)) { + if (parser->stack && !ucl_msgpack_insert_object(parser, + key, keylen, parser->cur_obj)) { return false; } /* Get new container */ - container = ucl_msgpack_get_container (parser, obj_parser, len); + container = ucl_msgpack_get_container(parser, obj_parser, len); if (container == NULL) { return false; } - ret = obj_parser->func (parser, container, len, obj_parser->fmt, - p, remain); + ret = obj_parser->func(parser, container, len, obj_parser->fmt, + p, remain); CONSUME_RET; if (len > 0) { @@ -1135,23 +1060,28 @@ ucl_msgpack_consume (struct ucl_parser *parser) container = parser->stack; if (parser->stack == NULL) { - ucl_create_err (&parser->err, - "read assoc value when no container represented"); + ucl_create_err(&parser->err, + "read assoc value when no container represented"); return false; } - ret = obj_parser->func (parser, container, len, obj_parser->fmt, - p, remain); + ret = obj_parser->func(parser, container, len, obj_parser->fmt, + p, remain); CONSUME_RET; /* Insert value to the container and check if we have finished array */ - if (!ucl_msgpack_insert_object (parser, NULL, 0, - parser->cur_obj)) { - return false; + if (parser->cur_obj) { + if (!ucl_msgpack_insert_object(parser, NULL, 0, + parser->cur_obj)) { + return false; + } + } + else { + /* We have parsed ext, ignore it */ } - if (ucl_msgpack_is_container_finished (container)) { + if (ucl_msgpack_is_container_finished(container)) { state = finish_array_value; } else { @@ -1167,8 +1097,9 @@ ucl_msgpack_consume (struct ucl_parser *parser) * Keys must have string type for ucl msgpack */ if (!(obj_parser->flags & MSGPACK_FLAG_KEY)) { - ucl_create_err (&parser->err, "bad type for key: %u, expected " - "string", (unsigned)obj_parser->fmt); + ucl_create_err(&parser->err, "bad type for key: %u, expected " + "string", + (unsigned) obj_parser->fmt); return false; } @@ -1177,7 +1108,7 @@ ucl_msgpack_consume (struct ucl_parser *parser) keylen = len; if (keylen > remain || keylen == 0) { - ucl_create_err (&parser->err, "too long or empty key"); + ucl_create_err(&parser->err, "too long or empty key"); return false; } @@ -1196,27 +1127,29 @@ ucl_msgpack_consume (struct ucl_parser *parser) container = parser->stack; if (container == NULL) { - ucl_create_err (&parser->err, - "read assoc value when no container represented"); + ucl_create_err(&parser->err, + "read assoc value when no container represented"); return false; } - ret = obj_parser->func (parser, container, len, obj_parser->fmt, - p, remain); + ret = obj_parser->func(parser, container, len, obj_parser->fmt, + p, remain); CONSUME_RET; - assert (key != NULL && keylen > 0); + assert(key != NULL && keylen > 0); - if (!ucl_msgpack_insert_object (parser, key, keylen, - parser->cur_obj)) { + if (parser->cur_obj) { + if (!ucl_msgpack_insert_object(parser, key, keylen, + parser->cur_obj)) { - return false; + return false; + } } key = NULL; keylen = 0; - if (ucl_msgpack_is_container_finished (container)) { + if (ucl_msgpack_is_container_finished(container)) { state = finish_assoc_value; } else { @@ -1233,7 +1166,7 @@ ucl_msgpack_consume (struct ucl_parser *parser) break; case error_state: - ucl_create_err (&parser->err, "invalid state machine state"); + ucl_create_err(&parser->err, "invalid state machine state"); return false; } @@ -1245,42 +1178,42 @@ ucl_msgpack_consume (struct ucl_parser *parser) case start_assoc: /* Empty container at the end */ if (len != 0) { - ucl_create_err (&parser->err, - "invalid non-empty container at the end; len=%zu", - (uintmax_t)len); + ucl_create_err(&parser->err, + "invalid non-empty container at the end; len=%zu", + (uintmax_t) len); return false; } - parser->cur_obj = ucl_object_new_full ( - state == start_array ? UCL_ARRAY : UCL_OBJECT, - parser->chunks->priority); + parser->cur_obj = ucl_object_new_full( + state == start_array ? UCL_ARRAY : UCL_OBJECT, + parser->chunks->priority); if (parser->stack == NULL) { - ucl_create_err (&parser->err, - "read assoc value when no container represented"); + ucl_create_err(&parser->err, + "read assoc value when no container represented"); return false; } /* Insert to the previous level container */ - if (!ucl_msgpack_insert_object (parser, - key, keylen, parser->cur_obj)) { + if (!ucl_msgpack_insert_object(parser, + key, keylen, parser->cur_obj)) { return false; } /* Get new container */ - container = ucl_msgpack_get_container (parser, obj_parser, len); + container = ucl_msgpack_get_container(parser, obj_parser, len); if (container == NULL) { return false; } - ret = obj_parser->func (parser, container, len, obj_parser->fmt, - p, remain); + ret = obj_parser->func(parser, container, len, obj_parser->fmt, + p, remain); break; case read_array_value: case read_assoc_value: if (len != 0) { - ucl_create_err (&parser->err, "unfinished value at the end"); + ucl_create_err(&parser->err, "unfinished value at the end"); return false; } @@ -1288,20 +1221,22 @@ ucl_msgpack_consume (struct ucl_parser *parser) container = parser->stack; if (parser->stack == NULL) { - ucl_create_err (&parser->err, - "read assoc value when no container represented"); + ucl_create_err(&parser->err, + "read assoc value when no container represented"); return false; } - ret = obj_parser->func (parser, container, len, obj_parser->fmt, - p, remain); + ret = obj_parser->func(parser, container, len, obj_parser->fmt, + p, remain); CONSUME_RET; /* Insert value to the container and check if we have finished array */ - if (!ucl_msgpack_insert_object (parser, NULL, 0, - parser->cur_obj)) { - return false; + if (parser->cur_obj) { + if (!ucl_msgpack_insert_object(parser, NULL, 0, + parser->cur_obj)) { + return false; + } } break; case finish_array_value: @@ -1311,17 +1246,17 @@ ucl_msgpack_consume (struct ucl_parser *parser) break; default: /* Invalid finishing state */ - ucl_create_err (&parser->err, "invalid state machine finishing state: %d", - state); + ucl_create_err(&parser->err, "invalid state machine finishing state: %d", + state); return false; } /* Rewind to the top level container */ - ucl_msgpack_get_next_container (parser); + ucl_msgpack_get_next_container(parser); if (parser->stack != NULL) { - ucl_create_err (&parser->err, "incomplete container"); + ucl_create_err(&parser->err, "incomplete container"); return false; } @@ -1329,17 +1264,16 @@ ucl_msgpack_consume (struct ucl_parser *parser) return true; } -bool -ucl_parse_msgpack (struct ucl_parser *parser) +bool ucl_parse_msgpack(struct ucl_parser *parser) { ucl_object_t *container = NULL; const unsigned char *p; bool ret; - assert (parser != NULL); - assert (parser->chunks != NULL); - assert (parser->chunks->begin != NULL); - assert (parser->chunks->remain != 0); + assert(parser != NULL); + assert(parser->chunks != NULL); + assert(parser->chunks->begin != NULL); + assert(parser->chunks->remain != 0); p = parser->chunks->begin; @@ -1354,12 +1288,12 @@ ucl_parse_msgpack (struct ucl_parser *parser) */ if (container == NULL) { if ((*p & 0x80) != 0x80 && !(*p >= 0xdc && *p <= 0xdf)) { - ucl_create_err (&parser->err, "bad top level object for msgpack"); + ucl_create_err(&parser->err, "bad top level object for msgpack"); return false; } } - ret = ucl_msgpack_consume (parser); + ret = ucl_msgpack_consume(parser); if (ret && parser->top_obj == NULL) { parser->top_obj = parser->cur_obj; @@ -1369,9 +1303,9 @@ ucl_parse_msgpack (struct ucl_parser *parser) } static ssize_t -ucl_msgpack_parse_map (struct ucl_parser *parser, - struct ucl_stack *container, size_t len, enum ucl_msgpack_format fmt, - const unsigned char *pos, size_t remain) +ucl_msgpack_parse_map(struct ucl_parser *parser, + struct ucl_stack *container, size_t len, enum ucl_msgpack_format fmt, + const unsigned char *pos, size_t remain) { container->obj = parser->cur_obj; @@ -1379,9 +1313,9 @@ ucl_msgpack_parse_map (struct ucl_parser *parser, } static ssize_t -ucl_msgpack_parse_array (struct ucl_parser *parser, - struct ucl_stack *container, size_t len, enum ucl_msgpack_format fmt, - const unsigned char *pos, size_t remain) +ucl_msgpack_parse_array(struct ucl_parser *parser, + struct ucl_stack *container, size_t len, enum ucl_msgpack_format fmt, + const unsigned char *pos, size_t remain) { container->obj = parser->cur_obj; @@ -1389,9 +1323,9 @@ ucl_msgpack_parse_array (struct ucl_parser *parser, } static ssize_t -ucl_msgpack_parse_string (struct ucl_parser *parser, - struct ucl_stack *container, size_t len, enum ucl_msgpack_format fmt, - const unsigned char *pos, size_t remain) +ucl_msgpack_parse_string(struct ucl_parser *parser, + struct ucl_stack *container, size_t len, enum ucl_msgpack_format fmt, + const unsigned char *pos, size_t remain) { ucl_object_t *obj; @@ -1399,7 +1333,7 @@ ucl_msgpack_parse_string (struct ucl_parser *parser, return -1; } - obj = ucl_object_new_full (UCL_STRING, parser->chunks->priority); + obj = ucl_object_new_full(UCL_STRING, parser->chunks->priority); obj->value.sv = pos; obj->len = len; @@ -1409,14 +1343,14 @@ ucl_msgpack_parse_string (struct ucl_parser *parser, if (!(parser->flags & UCL_PARSER_ZEROCOPY)) { if (obj->flags & UCL_OBJECT_BINARY) { - obj->trash_stack[UCL_TRASH_VALUE] = malloc (len); + obj->trash_stack[UCL_TRASH_VALUE] = malloc(len); if (obj->trash_stack[UCL_TRASH_VALUE] != NULL) { - memcpy (obj->trash_stack[UCL_TRASH_VALUE], pos, len); + memcpy(obj->trash_stack[UCL_TRASH_VALUE], pos, len); } } else { - ucl_copy_value_trash (obj); + ucl_copy_value_trash(obj); } } @@ -1426,9 +1360,9 @@ ucl_msgpack_parse_string (struct ucl_parser *parser, } static ssize_t -ucl_msgpack_parse_int (struct ucl_parser *parser, - struct ucl_stack *container, size_t len, enum ucl_msgpack_format fmt, - const unsigned char *pos, size_t remain) +ucl_msgpack_parse_int(struct ucl_parser *parser, + struct ucl_stack *container, size_t len, enum ucl_msgpack_format fmt, + const unsigned char *pos, size_t remain) { ucl_object_t *obj; int8_t iv8; @@ -1444,7 +1378,7 @@ ucl_msgpack_parse_int (struct ucl_parser *parser, return -1; } - obj = ucl_object_new_full (UCL_INT, parser->chunks->priority); + obj = ucl_object_new_full(UCL_INT, parser->chunks->priority); switch (fmt) { case msgpack_positive_fixint: @@ -1452,33 +1386,33 @@ ucl_msgpack_parse_int (struct ucl_parser *parser, len = 1; break; case msgpack_negative_fixint: - obj->value.iv = - (*pos & 0x1f); + obj->value.iv = -(*pos & 0x1f); len = 1; break; case msgpack_uint8: - obj->value.iv = (unsigned char)*pos; + obj->value.iv = (unsigned char) *pos; len = 1; break; case msgpack_int8: - memcpy (&iv8, pos, sizeof (iv8)); + memcpy(&iv8, pos, sizeof(iv8)); obj->value.iv = iv8; len = 1; break; case msgpack_int16: - memcpy (&iv16, pos, sizeof (iv16)); - iv16 = FROM_BE16 (iv16); + memcpy(&iv16, pos, sizeof(iv16)); + iv16 = FROM_BE16(iv16); obj->value.iv = iv16; len = 2; break; case msgpack_uint16: - memcpy (&uiv16, pos, sizeof (uiv16)); - uiv16 = FROM_BE16 (uiv16); + memcpy(&uiv16, pos, sizeof(uiv16)); + uiv16 = FROM_BE16(uiv16); obj->value.iv = uiv16; len = 2; break; case msgpack_int32: - memcpy (&iv32, pos, sizeof (iv32)); - iv32 = FROM_BE32 (iv32); + memcpy(&iv32, pos, sizeof(iv32)); + iv32 = FROM_BE32(iv32); obj->value.iv = iv32; len = 4; break; @@ -1489,8 +1423,8 @@ ucl_msgpack_parse_int (struct ucl_parser *parser, len = 4; break; case msgpack_int64: - memcpy (&iv64, pos, sizeof (iv64)); - iv64 = FROM_BE64 (iv64); + memcpy(&iv64, pos, sizeof(iv64)); + iv64 = FROM_BE64(iv64); obj->value.iv = iv64; len = 8; break; @@ -1501,7 +1435,7 @@ ucl_msgpack_parse_int (struct ucl_parser *parser, len = 8; break; default: - assert (0); + assert(0); break; } @@ -1511,9 +1445,9 @@ ucl_msgpack_parse_int (struct ucl_parser *parser, } static ssize_t -ucl_msgpack_parse_float (struct ucl_parser *parser, - struct ucl_stack *container, size_t len, enum ucl_msgpack_format fmt, - const unsigned char *pos, size_t remain) +ucl_msgpack_parse_float(struct ucl_parser *parser, + struct ucl_stack *container, size_t len, enum ucl_msgpack_format fmt, + const unsigned char *pos, size_t remain) { ucl_object_t *obj; union { @@ -1526,7 +1460,7 @@ ucl_msgpack_parse_float (struct ucl_parser *parser, return -1; } - obj = ucl_object_new_full (UCL_FLOAT, parser->chunks->priority); + obj = ucl_object_new_full(UCL_FLOAT, parser->chunks->priority); switch (fmt) { case msgpack_float32: @@ -1543,7 +1477,7 @@ ucl_msgpack_parse_float (struct ucl_parser *parser, len = 8; break; default: - assert (0); + assert(0); break; } @@ -1553,9 +1487,9 @@ ucl_msgpack_parse_float (struct ucl_parser *parser, } static ssize_t -ucl_msgpack_parse_bool (struct ucl_parser *parser, - struct ucl_stack *container, size_t len, enum ucl_msgpack_format fmt, - const unsigned char *pos, size_t remain) +ucl_msgpack_parse_bool(struct ucl_parser *parser, + struct ucl_stack *container, size_t len, enum ucl_msgpack_format fmt, + const unsigned char *pos, size_t remain) { ucl_object_t *obj; @@ -1563,7 +1497,7 @@ ucl_msgpack_parse_bool (struct ucl_parser *parser, return -1; } - obj = ucl_object_new_full (UCL_BOOLEAN, parser->chunks->priority); + obj = ucl_object_new_full(UCL_BOOLEAN, parser->chunks->priority); switch (fmt) { case msgpack_true: @@ -1573,7 +1507,7 @@ ucl_msgpack_parse_bool (struct ucl_parser *parser, obj->value.iv = false; break; default: - assert (0); + assert(0); break; } @@ -1583,9 +1517,9 @@ ucl_msgpack_parse_bool (struct ucl_parser *parser, } static ssize_t -ucl_msgpack_parse_null (struct ucl_parser *parser, - struct ucl_stack *container, size_t len, enum ucl_msgpack_format fmt, - const unsigned char *pos, size_t remain) +ucl_msgpack_parse_null(struct ucl_parser *parser, + struct ucl_stack *container, size_t len, enum ucl_msgpack_format fmt, + const unsigned char *pos, size_t remain) { ucl_object_t *obj; @@ -1593,16 +1527,16 @@ ucl_msgpack_parse_null (struct ucl_parser *parser, return -1; } - obj = ucl_object_new_full (UCL_NULL, parser->chunks->priority); + obj = ucl_object_new_full(UCL_NULL, parser->chunks->priority); parser->cur_obj = obj; return 1; } static ssize_t -ucl_msgpack_parse_ignore (struct ucl_parser *parser, - struct ucl_stack *container, size_t len, enum ucl_msgpack_format fmt, - const unsigned char *pos, size_t remain) +ucl_msgpack_parse_ignore(struct ucl_parser *parser, + struct ucl_stack *container, size_t len, enum ucl_msgpack_format fmt, + const unsigned char *pos, size_t remain) { if (len > remain) { return -1; @@ -1630,9 +1564,11 @@ ucl_msgpack_parse_ignore (struct ucl_parser *parser, len = len + 1; break; default: - ucl_create_err (&parser->err, "bad type: %x", (unsigned)fmt); + ucl_create_err(&parser->err, "bad type: %x", (unsigned) fmt); return -1; } + parser->cur_obj = NULL; + return len; } diff --git a/src/ucl_parser.c b/src/ucl_parser.c index 6be16d12169c..c52dd09ffe9a 100644 --- a/src/ucl_parser.c +++ b/src/ucl_parser.c @@ -45,23 +45,24 @@ struct ucl_parser_saved_state { * @param len * @return new position in chunk */ -#define ucl_chunk_skipc(chunk, p) \ -do { \ - if (p == chunk->end) { \ - break; \ - } \ - if (*(p) == '\n') { \ - (chunk)->line ++; \ - (chunk)->column = 0; \ - } \ - else (chunk)->column ++; \ - (p++); \ - (chunk)->pos ++; \ - (chunk)->remain --; \ -} while (0) +#define ucl_chunk_skipc(chunk, p) \ + do { \ + if (p == chunk->end) { \ + break; \ + } \ + if (*(p) == '\n') { \ + (chunk)->line++; \ + (chunk)->column = 0; \ + } \ + else \ + (chunk)->column++; \ + (p++); \ + (chunk)->pos++; \ + (chunk)->remain--; \ + } while (0) static inline void -ucl_set_err (struct ucl_parser *parser, int code, const char *str, UT_string **err) +ucl_set_err(struct ucl_parser *parser, int code, const char *str, UT_string **err) { const char *fmt_string, *filename; struct ucl_chunk *chunk = parser->chunks; @@ -74,21 +75,21 @@ ucl_set_err (struct ucl_parser *parser, int code, const char *str, UT_string **e } if (chunk->pos < chunk->end) { - if (isgraph (*chunk->pos)) { + if (isgraph(*chunk->pos)) { fmt_string = "error while parsing %s: " - "line: %d, column: %d - '%s', character: '%c'"; + "line: %d, column: %d - '%s', character: '%c'"; } else { fmt_string = "error while parsing %s: " - "line: %d, column: %d - '%s', character: '0x%02x'"; + "line: %d, column: %d - '%s', character: '0x%02x'"; } - ucl_create_err (err, fmt_string, - filename, chunk->line, chunk->column, - str, *chunk->pos); + ucl_create_err(err, fmt_string, + filename, chunk->line, chunk->column, + str, *chunk->pos); } else { - ucl_create_err (err, "error while parsing %s: at the end of chunk: %s", - filename, str); + ucl_create_err(err, "error while parsing %s: at the end of chunk: %s", + filename, str); } parser->err_code = code; @@ -96,16 +97,16 @@ ucl_set_err (struct ucl_parser *parser, int code, const char *str, UT_string **e } static void -ucl_save_comment (struct ucl_parser *parser, const char *begin, size_t len) +ucl_save_comment(struct ucl_parser *parser, const char *begin, size_t len) { ucl_object_t *nobj; if (len > 0 && begin != NULL) { - nobj = ucl_object_fromstring_common (begin, len, 0); + nobj = ucl_object_fromstring_common(begin, len, 0); if (parser->last_comment) { /* We need to append data to an existing object */ - DL_APPEND (parser->last_comment, nobj); + DL_APPEND(parser->last_comment, nobj); } else { parser->last_comment = nobj; @@ -114,11 +115,11 @@ ucl_save_comment (struct ucl_parser *parser, const char *begin, size_t len) } static void -ucl_attach_comment (struct ucl_parser *parser, ucl_object_t *obj, bool before) +ucl_attach_comment(struct ucl_parser *parser, ucl_object_t *obj, bool before) { if (parser->last_comment) { - ucl_object_insert_key (parser->comments, parser->last_comment, - (const char *)&obj, sizeof (void *), true); + ucl_object_insert_key(parser->comments, parser->last_comment, + (const char *) &obj, sizeof(void *), true); if (before) { parser->last_comment->flags |= UCL_OBJECT_INHERITED; @@ -134,7 +135,7 @@ ucl_attach_comment (struct ucl_parser *parser, ucl_object_t *obj, bool before) * @return */ static bool -ucl_skip_comments (struct ucl_parser *parser) +ucl_skip_comments(struct ucl_parser *parser) { struct ucl_chunk *chunk = parser->chunks; const unsigned char *p, *beg = NULL; @@ -146,73 +147,72 @@ ucl_skip_comments (struct ucl_parser *parser) start: if (chunk->remain > 0 && *p == '#') { if (parser->state != UCL_STATE_SCOMMENT && - parser->state != UCL_STATE_MCOMMENT) { + parser->state != UCL_STATE_MCOMMENT) { beg = p; while (p < chunk->end) { if (*p == '\n') { if (parser->flags & UCL_PARSER_SAVE_COMMENTS) { - ucl_save_comment (parser, beg, p - beg); + ucl_save_comment(parser, beg, p - beg); beg = NULL; } - ucl_chunk_skipc (chunk, p); + ucl_chunk_skipc(chunk, p); goto start; } - ucl_chunk_skipc (chunk, p); + ucl_chunk_skipc(chunk, p); } } } - else if (chunk->remain >= 2 && *p == '/') { - if (p[1] == '*') { - beg = p; - ucl_chunk_skipc (chunk, p); - comments_nested ++; - ucl_chunk_skipc (chunk, p); - - while (p < chunk->end) { - if (*p == '"' && *(p - 1) != '\\') { - quoted = !quoted; - } - - if (!quoted) { - if (*p == '*') { - ucl_chunk_skipc (chunk, p); - if (chunk->remain > 0 && *p == '/') { - comments_nested --; - if (comments_nested == 0) { - if (parser->flags & UCL_PARSER_SAVE_COMMENTS) { - ucl_save_comment (parser, beg, p - beg + 1); - beg = NULL; - } - - ucl_chunk_skipc (chunk, p); - goto start; - } - } - ucl_chunk_skipc (chunk, p); - } - else if (p[0] == '/' && chunk->remain >= 2 && p[1] == '*') { - comments_nested ++; - ucl_chunk_skipc (chunk, p); - ucl_chunk_skipc (chunk, p); - continue; + else if (chunk->remain >= 2 && *p == '/' && p[1] == '*') { + beg = p; + comments_nested++; + ucl_chunk_skipc(chunk, p); + ucl_chunk_skipc(chunk, p); + while (p < chunk->end) { + if (*p == '"' && *(p - 1) != '\\') { + /* begin or end double-quoted string */ + quoted = !quoted; + ucl_chunk_skipc(chunk, p); + } + else if (quoted) { + /* quoted character */ + ucl_chunk_skipc(chunk, p); + } + else if (chunk->remain >= 2 && *p == '*' && p[1] == '/') { + /* end of comment */ + ucl_chunk_skipc(chunk, p); + ucl_chunk_skipc(chunk, p); + comments_nested--; + if (comments_nested == 0) { + if (parser->flags & UCL_PARSER_SAVE_COMMENTS) { + ucl_save_comment(parser, beg, p - beg + 1); + beg = NULL; } + goto start; } - - ucl_chunk_skipc (chunk, p); } - if (comments_nested != 0) { - ucl_set_err (parser, UCL_ENESTED, - "unfinished multiline comment", &parser->err); - return false; + else if (chunk->remain >= 2 && *p == '/' && p[1] == '*') { + /* start of nested comment */ + comments_nested++; + ucl_chunk_skipc(chunk, p); + ucl_chunk_skipc(chunk, p); + } + else { + /* anything else */ + ucl_chunk_skipc(chunk, p); } } + if (comments_nested != 0) { + ucl_set_err(parser, UCL_ENESTED, + "unfinished multiline comment", &parser->err); + return false; + } } if (beg && p > beg && (parser->flags & UCL_PARSER_SAVE_COMMENTS)) { - ucl_save_comment (parser, beg, p - beg); + ucl_save_comment(parser, beg, p - beg); } return true; @@ -225,20 +225,20 @@ start: * @return multiplier */ static inline unsigned long -ucl_lex_num_multiplier (const unsigned char c, bool is_bytes) { +ucl_lex_num_multiplier(const unsigned char c, bool is_bytes) +{ const struct { char c; long mult_normal; long mult_bytes; } multipliers[] = { - {'m', 1000 * 1000, 1024 * 1024}, - {'k', 1000, 1024}, - {'g', 1000 * 1000 * 1000, 1024 * 1024 * 1024} - }; + {'m', 1000 * 1000, 1024 * 1024}, + {'k', 1000, 1024}, + {'g', 1000 * 1000 * 1000, 1024 * 1024 * 1024}}; int i; - for (i = 0; i < 3; i ++) { - if (tolower (c) == multipliers[i].c) { + for (i = 0; i < 3; i++) { + if (tolower(c) == multipliers[i].c) { if (is_bytes) { return multipliers[i].mult_bytes; } @@ -256,21 +256,21 @@ ucl_lex_num_multiplier (const unsigned char c, bool is_bytes) { * @return */ static inline double -ucl_lex_time_multiplier (const unsigned char c) { +ucl_lex_time_multiplier(const unsigned char c) +{ const struct { char c; double mult; } multipliers[] = { - {'m', 60}, - {'h', 60 * 60}, - {'d', 60 * 60 * 24}, - {'w', 60 * 60 * 24 * 7}, - {'y', 60 * 60 * 24 * 365} - }; + {'m', 60}, + {'h', 60 * 60}, + {'d', 60 * 60 * 24}, + {'w', 60 * 60 * 24 * 7}, + {'y', 60 * 60 * 24 * 365}}; int i; - for (i = 0; i < 5; i ++) { - if (tolower (c) == multipliers[i].c) { + for (i = 0; i < 5; i++) { + if (tolower(c) == multipliers[i].c) { return multipliers[i].mult; } } @@ -284,13 +284,13 @@ ucl_lex_time_multiplier (const unsigned char c) { * @return */ static inline bool -ucl_lex_is_atom_end (const unsigned char c) +ucl_lex_is_atom_end(const unsigned char c) { - return ucl_test_character (c, UCL_CHARACTER_VALUE_END); + return ucl_test_character(c, UCL_CHARACTER_VALUE_END); } static inline bool -ucl_lex_is_comment (const unsigned char c1, const unsigned char c2) +ucl_lex_is_comment(const unsigned char c1, const unsigned char c2) { if (c1 == '/') { if (c2 == '*') { @@ -314,18 +314,19 @@ ucl_lex_is_comment (const unsigned char c1, const unsigned char c2) * @return */ static inline const char * -ucl_check_variable_safe (struct ucl_parser *parser, const char *ptr, size_t remain, - size_t *out_len, bool strict, bool *found) +ucl_check_variable_safe(struct ucl_parser *parser, const char *ptr, size_t remain, + size_t *out_len, bool strict, bool *found) { struct ucl_variable *var; unsigned char *dst; size_t dstlen; bool need_free = false; - LL_FOREACH (parser->variables, var) { + LL_FOREACH(parser->variables, var) + { if (strict) { if (remain == var->var_len) { - if (memcmp (ptr, var->var, var->var_len) == 0) { + if (memcmp(ptr, var->var, var->var_len) == 0) { *out_len += var->value_len; *found = true; return (ptr + var->var_len); @@ -334,7 +335,7 @@ ucl_check_variable_safe (struct ucl_parser *parser, const char *ptr, size_t rema } else { if (remain >= var->var_len) { - if (memcmp (ptr, var->var, var->var_len) == 0) { + if (memcmp(ptr, var->var, var->var_len) == 0) { *out_len += var->value_len; *found = true; return (ptr + var->var_len); @@ -346,13 +347,13 @@ ucl_check_variable_safe (struct ucl_parser *parser, const char *ptr, size_t rema /* XXX: can only handle ${VAR} */ if (!(*found) && parser->var_handler != NULL && strict) { /* Call generic handler */ - if (parser->var_handler (ptr, remain, &dst, &dstlen, &need_free, - parser->var_data)) { + if (parser->var_handler(ptr, remain, &dst, &dstlen, &need_free, + parser->var_data)) { *found = true; *out_len = dstlen; if (need_free) { - free (dst); + free(dst); } return (ptr + remain); } @@ -371,8 +372,8 @@ ucl_check_variable_safe (struct ucl_parser *parser, const char *ptr, size_t rema * @return */ static const char * -ucl_check_variable (struct ucl_parser *parser, const char *ptr, - size_t remain, size_t *out_len, bool *vars_found) +ucl_check_variable(struct ucl_parser *parser, const char *ptr, + size_t remain, size_t *out_len, bool *vars_found) { const char *p, *end, *ret = ptr; bool found = false; @@ -383,11 +384,11 @@ ucl_check_variable (struct ucl_parser *parser, const char *ptr, end = ptr + remain; while (p < end) { if (*p == '}') { - ret = ucl_check_variable_safe (parser, ptr + 1, p - ptr - 1, - out_len, true, &found); + ret = ucl_check_variable_safe(parser, ptr + 1, p - ptr - 1, + out_len, true, &found); if (found) { /* {} must be excluded actually */ - ret ++; + ret++; if (!*vars_found) { *vars_found = true; } @@ -397,25 +398,25 @@ ucl_check_variable (struct ucl_parser *parser, const char *ptr, } break; } - p ++; + p++; } - if(p == end) { - (*out_len) ++; + if (p == end) { + (*out_len)++; } } else if (*ptr != '$') { /* Not count escaped dollar sign */ - ret = ucl_check_variable_safe (parser, ptr, remain, out_len, false, &found); + ret = ucl_check_variable_safe(parser, ptr, remain, out_len, false, &found); if (found && !*vars_found) { *vars_found = true; } if (!found) { - (*out_len) ++; + (*out_len)++; } } else { - ret ++; - (*out_len) ++; + ret++; + (*out_len)++; } return ret; @@ -431,8 +432,8 @@ ucl_check_variable (struct ucl_parser *parser, const char *ptr, * @return */ static const char * -ucl_expand_single_variable (struct ucl_parser *parser, const char *ptr, - size_t in_len, unsigned char **dest, size_t out_len) +ucl_expand_single_variable(struct ucl_parser *parser, const char *ptr, + size_t in_len, unsigned char **dest, size_t out_len) { unsigned char *d = *dest, *dst; const char *p = ptr + 1, *ret; @@ -444,7 +445,7 @@ ucl_expand_single_variable (struct ucl_parser *parser, const char *ptr, ret = ptr + 1; /* For the $ sign */ - in_len --; + in_len--; if (*p == '$') { *d++ = *p++; @@ -452,17 +453,18 @@ ucl_expand_single_variable (struct ucl_parser *parser, const char *ptr, return p; } else if (*p == '{') { - p ++; - in_len --; + p++; + in_len--; strict = true; ret += 2; } - LL_FOREACH (parser->variables, var) { + LL_FOREACH(parser->variables, var) + { if (out_len >= var->value_len && in_len >= (var->var_len + (strict ? 1 : 0))) { - if (memcmp (p, var->var, var->var_len) == 0) { + if (memcmp(p, var->var, var->var_len) == 0) { if (!strict || p[var->var_len] == '}') { - memcpy (d, var->value, var->value_len); + memcpy(d, var->value, var->value_len); ret += var->var_len; d += var->value_len; found = true; @@ -476,12 +478,12 @@ ucl_expand_single_variable (struct ucl_parser *parser, const char *ptr, if (strict && parser->var_handler != NULL) { dstlen = out_len; - if (parser->var_handler (p, in_len, &dst, &dstlen, &need_free, - parser->var_data)) { + if (parser->var_handler(p, in_len, &dst, &dstlen, &need_free, + parser->var_data)) { if (dstlen > out_len) { /* We do not have enough space! */ if (need_free) { - free (dst); + free(dst); } } else { @@ -501,13 +503,13 @@ ucl_expand_single_variable (struct ucl_parser *parser, const char *ptr, if (!found) { if (strict && out_len >= 2) { /* Copy '${' */ - memcpy (d, ptr, 2); + memcpy(d, ptr, 2); d += 2; - ret --; + ret--; } else { - memcpy (d, ptr, 1); - d ++; + memcpy(d, ptr, 1); + d++; } } } @@ -525,8 +527,8 @@ ucl_expand_single_variable (struct ucl_parser *parser, const char *ptr, * @return */ static ssize_t -ucl_expand_variable (struct ucl_parser *parser, unsigned char **dst, - const char *src, size_t in_len) +ucl_expand_variable(struct ucl_parser *parser, unsigned char **dst, + const char *src, size_t in_len) { const char *p, *end = src + in_len; unsigned char *d, *d_end; @@ -541,11 +543,11 @@ ucl_expand_variable (struct ucl_parser *parser, unsigned char **dst, p = src; while (p != end) { if (*p == '$' && p + 1 != end) { - p = ucl_check_variable (parser, p + 1, end - p - 1, &out_len, &vars_found); + p = ucl_check_variable(parser, p + 1, end - p - 1, &out_len, &vars_found); } else { - p ++; - out_len ++; + p++; + out_len++; } } @@ -555,7 +557,7 @@ ucl_expand_variable (struct ucl_parser *parser, unsigned char **dst, return in_len; } - *dst = UCL_ALLOC (out_len + 1); + *dst = UCL_ALLOC(out_len + 1); if (*dst == NULL) { return in_len; } @@ -565,7 +567,7 @@ ucl_expand_variable (struct ucl_parser *parser, unsigned char **dst, p = src; while (p != end && d != d_end) { if (*p == '$' && p + 1 != end) { - p = ucl_expand_single_variable (parser, p, end - p, &d, d_end - d); + p = ucl_expand_single_variable(parser, p, end - p, &d, d_end - d); } else { *d++ = *p++; @@ -591,45 +593,45 @@ ucl_expand_variable (struct ucl_parser *parser, unsigned char **dst, * @return output length (excluding \0 symbol) */ static inline ssize_t -ucl_copy_or_store_ptr (struct ucl_parser *parser, - const unsigned char *src, unsigned char **dst, - const char **dst_const, size_t in_len, - bool need_unescape, bool need_lowercase, bool need_expand, - bool unescape_squote) +ucl_copy_or_store_ptr(struct ucl_parser *parser, + const unsigned char *src, unsigned char **dst, + const char **dst_const, size_t in_len, + bool need_unescape, bool need_lowercase, bool need_expand, + bool unescape_squote) { ssize_t ret = -1, tret; unsigned char *tmp; if (need_unescape || need_lowercase || - (need_expand && parser->variables != NULL) || - !(parser->flags & UCL_PARSER_ZEROCOPY)) { + (need_expand && parser->variables != NULL) || + !(parser->flags & UCL_PARSER_ZEROCOPY)) { /* Copy string */ - *dst = UCL_ALLOC (in_len + 1); + *dst = UCL_ALLOC(in_len + 1); if (*dst == NULL) { - ucl_set_err (parser, UCL_EINTERNAL, "cannot allocate memory for a string", - &parser->err); + ucl_set_err(parser, UCL_EINTERNAL, "cannot allocate memory for a string", + &parser->err); return false; } if (need_lowercase) { - ret = ucl_strlcpy_tolower (*dst, src, in_len + 1); + ret = ucl_strlcpy_tolower(*dst, src, in_len + 1); } else { - ret = ucl_strlcpy_unsafe (*dst, src, in_len + 1); + ret = ucl_strlcpy_unsafe(*dst, src, in_len + 1); } if (need_unescape) { if (!unescape_squote) { - ret = ucl_unescape_json_string (*dst, ret); + ret = ucl_unescape_json_string(*dst, ret); } else { - ret = ucl_unescape_squoted_string (*dst, ret); + ret = ucl_unescape_squoted_string(*dst, ret); } } if (need_expand) { tmp = *dst; tret = ret; - ret = ucl_expand_variable (parser, dst, tmp, ret); + ret = ucl_expand_variable(parser, dst, tmp, ret); if (*dst == NULL) { /* Nothing to expand */ *dst = tmp; @@ -637,7 +639,7 @@ ucl_copy_or_store_ptr (struct ucl_parser *parser, } else { /* Free unexpanded value */ - UCL_FREE (in_len + 1, tmp); + UCL_FREE(in_len + 1, tmp); } } *dst_const = *dst; @@ -658,23 +660,24 @@ ucl_copy_or_store_ptr (struct ucl_parser *parser, * @return */ static inline ucl_object_t * -ucl_parser_add_container (ucl_object_t *obj, struct ucl_parser *parser, - bool is_array, uint32_t level, bool has_obrace) +ucl_parser_add_container(ucl_object_t *obj, struct ucl_parser *parser, + bool is_array, uint32_t level, bool has_obrace) { struct ucl_stack *st; ucl_object_t *nobj; if (obj == NULL) { - nobj = ucl_object_new_full (is_array ? UCL_ARRAY : UCL_OBJECT, parser->chunks->priority); + nobj = ucl_object_new_full(is_array ? UCL_ARRAY : UCL_OBJECT, parser->chunks->priority); if (nobj == NULL) { goto enomem0; } - } else { + } + else { if (obj->type == (is_array ? UCL_OBJECT : UCL_ARRAY)) { /* Bad combination for merge: array and object */ - ucl_set_err (parser, UCL_EMERGE, - "cannot merge an object with an array", - &parser->err); + ucl_set_err(parser, UCL_EMERGE, + "cannot merge an object with an array", + &parser->err); return NULL; } @@ -684,17 +687,18 @@ ucl_parser_add_container (ucl_object_t *obj, struct ucl_parser *parser, if (!is_array) { if (nobj->value.ov == NULL) { - nobj->value.ov = ucl_hash_create (parser->flags & UCL_PARSER_KEY_LOWERCASE); + nobj->value.ov = ucl_hash_create(parser->flags & UCL_PARSER_KEY_LOWERCASE); if (nobj->value.ov == NULL) { goto enomem1; } } parser->state = UCL_STATE_KEY; - } else { + } + else { parser->state = UCL_STATE_VALUE; } - st = UCL_ALLOC (sizeof (struct ucl_stack)); + st = UCL_ALLOC(sizeof(struct ucl_stack)); if (st == NULL) { goto enomem1; @@ -703,14 +707,14 @@ ucl_parser_add_container (ucl_object_t *obj, struct ucl_parser *parser, st->obj = nobj; if (level >= UINT16_MAX) { - ucl_set_err (parser, UCL_ENESTED, - "objects are nesting too deep (over 65535 limit)", - &parser->err); + ucl_set_err(parser, UCL_ENESTED, + "objects are nesting too deep (over 65535 limit)", + &parser->err); if (nobj != obj) { - ucl_object_unref (obj); + ucl_object_unref(obj); } - UCL_FREE(sizeof (struct ucl_stack), st); + UCL_FREE(sizeof(struct ucl_stack), st); return NULL; } @@ -727,50 +731,49 @@ ucl_parser_add_container (ucl_object_t *obj, struct ucl_parser *parser, st->e.params.flags = 0; } - LL_PREPEND (parser->stack, st); + LL_PREPEND(parser->stack, st); parser->cur_obj = nobj; return nobj; enomem1: if (nobj != obj) - ucl_object_unref (nobj); + ucl_object_unref(nobj); enomem0: - ucl_set_err (parser, UCL_EINTERNAL, "cannot allocate memory for an object", - &parser->err); + ucl_set_err(parser, UCL_EINTERNAL, "cannot allocate memory for an object", + &parser->err); return NULL; } -int -ucl_maybe_parse_number (ucl_object_t *obj, - const char *start, const char *end, const char **pos, - bool allow_double, bool number_bytes, bool allow_time) +int ucl_maybe_parse_number(ucl_object_t *obj, + const char *start, const char *end, const char **pos, + bool allow_double, bool number_bytes, bool allow_time) { const char *p = start, *c = start; char *endptr; bool got_dot = false, got_exp = false, need_double = false, - is_time = false, valid_start = false, is_hex = false; + is_time = false, valid_start = false, is_hex = false; int is_neg = 0; double dv = 0; int64_t lv = 0; if (*p == '-') { is_neg = 1; - c ++; - p ++; + c++; + p++; } while (p < end) { - if (is_hex && isxdigit (*p)) { - p ++; + if (is_hex && isxdigit(*p)) { + p++; } - else if (isdigit (*p)) { + else if (isdigit(*p)) { valid_start = true; - p ++; + p++; } else if (!is_hex && (*p == 'x' || *p == 'X')) { is_hex = true; allow_double = false; c = p + 1; - p ++; + p++; } else if (allow_double) { if (p == c) { @@ -787,7 +790,7 @@ ucl_maybe_parse_number (ucl_object_t *obj, else { got_dot = true; need_double = true; - p ++; + p++; } } else if (*p == 'e' || *p == 'E') { @@ -799,18 +802,18 @@ ucl_maybe_parse_number (ucl_object_t *obj, else { got_exp = true; need_double = true; - p ++; + p++; if (p >= end) { *pos = start; return EINVAL; } - if (!isdigit (*p) && *p != '+' && *p != '-') { + if (!isdigit(*p) && *p != '+' && *p != '-') { /* Wrong exponent sign */ *pos = start; return EINVAL; } else { - p ++; + p++; } } } @@ -836,29 +839,29 @@ ucl_maybe_parse_number (ucl_object_t *obj, char numbuf[128]; - if ((size_t)(p - c + 1) >= sizeof(numbuf)) { + if ((size_t) (p - c + 1) >= sizeof(numbuf)) { *pos = start; return EINVAL; } if (is_neg) { numbuf[0] = '-'; - ucl_strlcpy (&numbuf[1], c, p - c + 1); + ucl_strlcpy(&numbuf[1], c, p - c + 1); } else { - ucl_strlcpy (numbuf, c, p - c + 1); + ucl_strlcpy(numbuf, c, p - c + 1); } errno = 0; if (need_double) { - dv = strtod (numbuf, &endptr); + dv = strtod(numbuf, &endptr); } else { if (is_hex) { - lv = strtoimax (numbuf, &endptr, 16); + lv = strtoimax(numbuf, &endptr, 16); } else { - lv = strtoimax (numbuf, &endptr, 10); + lv = strtoimax(numbuf, &endptr, 10); } } if (errno == ERANGE) { @@ -869,13 +872,13 @@ ucl_maybe_parse_number (ucl_object_t *obj, /* Now check endptr and move it from numbuf to the real ending */ if (endptr != NULL) { long shift = endptr - numbuf - is_neg; - endptr = (char *)c + shift; + endptr = (char *) c + shift; } if (endptr >= end) { p = end; goto set_obj; } - if (endptr == NULL || ucl_lex_is_atom_end (*endptr) || *endptr == '\0') { + if (endptr == NULL || ucl_lex_is_atom_end(*endptr) || *endptr == '\0') { p = endptr; goto set_obj; } @@ -901,10 +904,10 @@ ucl_maybe_parse_number (ucl_object_t *obj, dv /= 1000.; } else { - dv *= ucl_lex_num_multiplier (*p, false); + dv *= ucl_lex_num_multiplier(*p, false); } p += 2; - if (end - p > 0 && !ucl_lex_is_atom_end (*p)) { + if (end - p > 0 && !ucl_lex_is_atom_end(*p)) { *pos = start; return EINVAL; } @@ -916,28 +919,28 @@ ucl_maybe_parse_number (ucl_object_t *obj, need_double = false; lv = dv; } - lv *= ucl_lex_num_multiplier (*p, true); + lv *= ucl_lex_num_multiplier(*p, true); p += 2; - if (end - p > 0 && !ucl_lex_is_atom_end (*p)) { + if (end - p > 0 && !ucl_lex_is_atom_end(*p)) { *pos = start; return EINVAL; } goto set_obj; } - else if (ucl_lex_is_atom_end (p[1])) { + else if (ucl_lex_is_atom_end(p[1])) { if (need_double) { - dv *= ucl_lex_num_multiplier (*p, false); + dv *= ucl_lex_num_multiplier(*p, false); } else { - lv *= ucl_lex_num_multiplier (*p, number_bytes); + lv *= ucl_lex_num_multiplier(*p, number_bytes); } - p ++; + p++; goto set_obj; } else if (allow_time && end - p >= 3) { - if (tolower (p[0]) == 'm' && - tolower (p[1]) == 'i' && - tolower (p[2]) == 'n') { + if (tolower(p[0]) == 'm' && + tolower(p[1]) == 'i' && + tolower(p[2]) == 'n') { /* Minutes */ if (!need_double) { need_double = true; @@ -946,7 +949,7 @@ ucl_maybe_parse_number (ucl_object_t *obj, is_time = true; dv *= 60.; p += 3; - if (end - p > 0 && !ucl_lex_is_atom_end (*p)) { + if (end - p > 0 && !ucl_lex_is_atom_end(*p)) { *pos = start; return EINVAL; } @@ -956,13 +959,13 @@ ucl_maybe_parse_number (ucl_object_t *obj, } else { if (need_double) { - dv *= ucl_lex_num_multiplier (*p, false); + dv *= ucl_lex_num_multiplier(*p, false); } else { - lv *= ucl_lex_num_multiplier (*p, number_bytes); + lv *= ucl_lex_num_multiplier(*p, number_bytes); } - p ++; - if (end - p > 0 && !ucl_lex_is_atom_end (*p)) { + p++; + if (end - p > 0 && !ucl_lex_is_atom_end(*p)) { *pos = start; return EINVAL; } @@ -972,12 +975,12 @@ ucl_maybe_parse_number (ucl_object_t *obj, case 'S': case 's': if (allow_time && - (p == end - 1 || ucl_lex_is_atom_end (p[1]))) { + (p == end - 1 || ucl_lex_is_atom_end(p[1]))) { if (!need_double) { need_double = true; dv = lv; } - p ++; + p++; is_time = true; goto set_obj; } @@ -991,14 +994,14 @@ ucl_maybe_parse_number (ucl_object_t *obj, case 'Y': case 'y': if (allow_time && - (p == end - 1 || ucl_lex_is_atom_end (p[1]))) { + (p == end - 1 || ucl_lex_is_atom_end(p[1]))) { if (!need_double) { need_double = true; dv = lv; } is_time = true; - dv *= ucl_lex_time_multiplier (*p); - p ++; + dv *= ucl_lex_time_multiplier(*p); + p++; goto set_obj; } break; @@ -1007,7 +1010,7 @@ ucl_maybe_parse_number (ucl_object_t *obj, while (p < end && ucl_test_character(*p, UCL_CHARACTER_WHITESPACE)) { p++; } - if (ucl_lex_is_atom_end(*p)) + if (p == end || ucl_lex_is_atom_end(*p)) goto set_obj; break; } @@ -1049,14 +1052,14 @@ set_obj: * @return true if a number has been parsed */ static bool -ucl_lex_number (struct ucl_parser *parser, - struct ucl_chunk *chunk, ucl_object_t *obj) +ucl_lex_number(struct ucl_parser *parser, + struct ucl_chunk *chunk, ucl_object_t *obj) { const unsigned char *pos; int ret; - ret = ucl_maybe_parse_number (obj, chunk->pos, chunk->end, (const char **)&pos, - true, false, ((parser->flags & UCL_PARSER_NO_TIME) == 0)); + ret = ucl_maybe_parse_number(obj, chunk->pos, chunk->end, (const char **) &pos, + true, false, ((parser->flags & UCL_PARSER_NO_TIME) == 0)); if (ret == 0) { chunk->remain -= pos - chunk->pos; @@ -1065,8 +1068,8 @@ ucl_lex_number (struct ucl_parser *parser, return true; } else if (ret == ERANGE) { - ucl_set_err (parser, UCL_ESYNTAX, "numeric value out of range", - &parser->err); + ucl_set_err(parser, UCL_ESYNTAX, "numeric value out of range", + &parser->err); } return false; @@ -1082,11 +1085,11 @@ ucl_lex_number (struct ucl_parser *parser, * @return true if a string has been parsed */ static bool -ucl_lex_json_string (struct ucl_parser *parser, - struct ucl_chunk *chunk, - bool *need_unescape, - bool *ucl_escape, - bool *var_expand) +ucl_lex_json_string(struct ucl_parser *parser, + struct ucl_chunk *chunk, + bool *need_unescape, + bool *ucl_escape, + bool *var_expand) { const unsigned char *p = chunk->pos; unsigned char c; @@ -1097,43 +1100,43 @@ ucl_lex_json_string (struct ucl_parser *parser, if (c < 0x1F) { /* Unmasked control character */ if (c == '\n') { - ucl_set_err (parser, UCL_ESYNTAX, "unexpected newline", - &parser->err); + ucl_set_err(parser, UCL_ESYNTAX, "unexpected newline", + &parser->err); } else { - ucl_set_err (parser, UCL_ESYNTAX, "unexpected control character", - &parser->err); + ucl_set_err(parser, UCL_ESYNTAX, "unexpected control character", + &parser->err); } return false; } else if (c == '\\') { - ucl_chunk_skipc (chunk, p); + ucl_chunk_skipc(chunk, p); if (p >= chunk->end) { - ucl_set_err (parser, UCL_ESYNTAX, "unfinished escape character", - &parser->err); + ucl_set_err(parser, UCL_ESYNTAX, "unfinished escape character", + &parser->err); return false; } c = *p; - if (ucl_test_character (c, UCL_CHARACTER_ESCAPE)) { + if (ucl_test_character(c, UCL_CHARACTER_ESCAPE)) { if (c == 'u') { - ucl_chunk_skipc (chunk, p); - for (i = 0; i < 4 && p < chunk->end; i ++) { - if (!isxdigit (*p)) { - ucl_set_err (parser, UCL_ESYNTAX, "invalid utf escape", - &parser->err); + ucl_chunk_skipc(chunk, p); + for (i = 0; i < 4 && p < chunk->end; i++) { + if (!isxdigit(*p)) { + ucl_set_err(parser, UCL_ESYNTAX, "invalid utf escape", + &parser->err); return false; } - ucl_chunk_skipc (chunk, p); + ucl_chunk_skipc(chunk, p); } if (p >= chunk->end) { - ucl_set_err (parser, UCL_ESYNTAX, - "unfinished escape character", - &parser->err); + ucl_set_err(parser, UCL_ESYNTAX, + "unfinished escape character", + &parser->err); return false; } } else { - ucl_chunk_skipc (chunk, p); + ucl_chunk_skipc(chunk, p); } } *need_unescape = true; @@ -1141,21 +1144,21 @@ ucl_lex_json_string (struct ucl_parser *parser, continue; } else if (c == '"') { - ucl_chunk_skipc (chunk, p); + ucl_chunk_skipc(chunk, p); return true; } - else if (ucl_test_character (c, UCL_CHARACTER_UCL_UNSAFE)) { + else if (ucl_test_character(c, UCL_CHARACTER_UCL_UNSAFE)) { *ucl_escape = true; } else if (c == '$') { *var_expand = true; } - ucl_chunk_skipc (chunk, p); + ucl_chunk_skipc(chunk, p); } - ucl_set_err (parser, UCL_ESYNTAX, - "no quote at the end of json string", - &parser->err); + ucl_set_err(parser, UCL_ESYNTAX, + "no quote at the end of json string", + &parser->err); return false; } @@ -1167,8 +1170,8 @@ ucl_lex_json_string (struct ucl_parser *parser, * @return */ static bool -ucl_lex_squoted_string (struct ucl_parser *parser, - struct ucl_chunk *chunk, bool *need_unescape) +ucl_lex_squoted_string(struct ucl_parser *parser, + struct ucl_chunk *chunk, bool *need_unescape) { const unsigned char *p = chunk->pos; unsigned char c; @@ -1176,68 +1179,67 @@ ucl_lex_squoted_string (struct ucl_parser *parser, while (p < chunk->end) { c = *p; if (c == '\\') { - ucl_chunk_skipc (chunk, p); + ucl_chunk_skipc(chunk, p); if (p >= chunk->end) { - ucl_set_err (parser, UCL_ESYNTAX, - "unfinished escape character", - &parser->err); + ucl_set_err(parser, UCL_ESYNTAX, + "unfinished escape character", + &parser->err); return false; } else { - ucl_chunk_skipc (chunk, p); + ucl_chunk_skipc(chunk, p); } *need_unescape = true; continue; } else if (c == '\'') { - ucl_chunk_skipc (chunk, p); + ucl_chunk_skipc(chunk, p); return true; } - ucl_chunk_skipc (chunk, p); + ucl_chunk_skipc(chunk, p); } - ucl_set_err (parser, UCL_ESYNTAX, - "no quote at the end of single quoted string", - &parser->err); + ucl_set_err(parser, UCL_ESYNTAX, + "no quote at the end of single quoted string", + &parser->err); return false; } static void -ucl_parser_append_elt (struct ucl_parser *parser, ucl_hash_t *cont, - ucl_object_t *top, - ucl_object_t *elt) +ucl_parser_append_elt(struct ucl_parser *parser, ucl_hash_t *cont, + ucl_object_t *top, + ucl_object_t *elt) { ucl_object_t *nobj; if ((parser->flags & UCL_PARSER_NO_IMPLICIT_ARRAYS) == 0) { /* Implicit array */ top->flags |= UCL_OBJECT_MULTIVALUE; - DL_APPEND (top, elt); - parser->stack->obj->len ++; + DL_APPEND(top, elt); + parser->stack->obj->len++; } else { if ((top->flags & UCL_OBJECT_MULTIVALUE) != 0) { /* Just add to the explicit array */ - ucl_array_append (top, elt); + ucl_array_append(top, elt); } else { /* Convert to an array */ - nobj = ucl_object_typed_new (UCL_ARRAY); + nobj = ucl_object_typed_new(UCL_ARRAY); nobj->key = top->key; nobj->keylen = top->keylen; nobj->flags |= UCL_OBJECT_MULTIVALUE; - ucl_array_append (nobj, top); - ucl_array_append (nobj, elt); - ucl_hash_replace (cont, top, nobj); + ucl_array_append(nobj, top); + ucl_array_append(nobj, elt); + ucl_hash_replace(cont, top, nobj); } } } -bool -ucl_parser_process_object_element (struct ucl_parser *parser, ucl_object_t *nobj) +bool ucl_parser_process_object_element(struct ucl_parser *parser, ucl_object_t *nobj) { ucl_hash_t *container; ucl_object_t *tobj = NULL, *cur; @@ -1245,28 +1247,40 @@ ucl_parser_process_object_element (struct ucl_parser *parser, ucl_object_t *nobj container = parser->stack->obj->value.ov; - DL_FOREACH (parser->stack->obj, cur) { - tobj = __DECONST (ucl_object_t *, ucl_hash_search_obj (cur->value.ov, nobj)); + DL_FOREACH(parser->stack->obj, cur) + { + if (cur->type == UCL_OBJECT) { + tobj = __DECONST(ucl_object_t *, ucl_hash_search_obj(cur->value.ov, nobj)); - if (tobj != NULL) { - break; + if (tobj != NULL) { + /* + * Check if we have found an object in the same container. + * If not, we should probably ignore it as we cannot replace it + * effectively and we definitely should not unref it. + */ + if (cur->value.ov != container) { + tobj = NULL; + continue; + } + break; + } } } if (tobj == NULL) { - container = ucl_hash_insert_object (container, nobj, - parser->flags & UCL_PARSER_KEY_LOWERCASE); + container = ucl_hash_insert_object(container, nobj, + parser->flags & UCL_PARSER_KEY_LOWERCASE); if (container == NULL) { return false; } nobj->prev = nobj; nobj->next = NULL; - parser->stack->obj->len ++; + parser->stack->obj->len++; } else { - unsigned priold = ucl_object_get_priority (tobj), - prinew = ucl_object_get_priority (nobj); + unsigned priold = ucl_object_get_priority(tobj), + prinew = ucl_object_get_priority(nobj); switch (parser->chunks->strategy) { case UCL_DUPLICATE_APPEND: @@ -1284,7 +1298,7 @@ ucl_parser_process_object_element (struct ucl_parser *parser, ucl_object_t *nobj } if (priold == prinew) { - ucl_parser_append_elt (parser, container, tobj, nobj); + ucl_parser_append_elt(parser, container, tobj, nobj); } else if (priold > prinew) { /* @@ -1292,27 +1306,27 @@ ucl_parser_process_object_element (struct ucl_parser *parser, ucl_object_t *nobj * that it won't come to any real object * XXX: rather inefficient approach */ - DL_APPEND (parser->trash_objs, nobj); + DL_APPEND(parser->trash_objs, nobj); } else { - ucl_hash_replace (container, tobj, nobj); - ucl_object_unref (tobj); + ucl_hash_replace(container, tobj, nobj); + ucl_object_unref(tobj); } break; case UCL_DUPLICATE_REWRITE: /* We just rewrite old values regardless of priority */ - ucl_hash_replace (container, tobj, nobj); - ucl_object_unref (tobj); + ucl_hash_replace(container, tobj, nobj); + ucl_object_unref(tobj); break; case UCL_DUPLICATE_ERROR: snprintf(errmsg, sizeof(errmsg), - "duplicate element for key '%s' found", - nobj->key); - ucl_set_err (parser, UCL_EMERGE, errmsg, &parser->err); + "duplicate element for key '%s' found", + nobj->key); + ucl_set_err(parser, UCL_EMERGE, errmsg, &parser->err); return false; case UCL_DUPLICATE_MERGE: @@ -1321,11 +1335,11 @@ ucl_parser_process_object_element (struct ucl_parser *parser, ucl_object_t *nobj * Check priority and then perform the merge on the remaining objects */ if (tobj->type == UCL_OBJECT || tobj->type == UCL_ARRAY) { - ucl_object_unref (nobj); + ucl_object_unref(nobj); nobj = tobj; } else if (priold == prinew) { - ucl_parser_append_elt (parser, container, tobj, nobj); + ucl_parser_append_elt(parser, container, tobj, nobj); } else if (priold > prinew) { /* @@ -1333,11 +1347,11 @@ ucl_parser_process_object_element (struct ucl_parser *parser, ucl_object_t *nobj * that it won't come to any real object * XXX: rather inefficient approach */ - DL_APPEND (parser->trash_objs, nobj); + DL_APPEND(parser->trash_objs, nobj); } else { - ucl_hash_replace (container, tobj, nobj); - ucl_object_unref (tobj); + ucl_hash_replace(container, tobj, nobj); + ucl_object_unref(tobj); } break; } @@ -1345,7 +1359,7 @@ ucl_parser_process_object_element (struct ucl_parser *parser, ucl_object_t *nobj parser->stack->obj->value.ov = container; parser->cur_obj = nobj; - ucl_attach_comment (parser, nobj, false); + ucl_attach_comment(parser, nobj, false); return true; } @@ -1359,21 +1373,21 @@ ucl_parser_process_object_element (struct ucl_parser *parser, ucl_object_t *nobj * @return true if a key has been parsed */ static bool -ucl_parse_key (struct ucl_parser *parser, struct ucl_chunk *chunk, - bool *next_key, bool *end_of_object, bool *got_content) +ucl_parse_key(struct ucl_parser *parser, struct ucl_chunk *chunk, + bool *next_key, bool *end_of_object, bool *got_content) { const unsigned char *p, *c = NULL, *end, *t; const char *key = NULL; bool got_quote = false, got_eq = false, got_semicolon = false, - need_unescape = false, ucl_escape = false, var_expand = false, - got_sep = false; + need_unescape = false, ucl_escape = false, var_expand = false, + got_sep = false; ucl_object_t *nobj; ssize_t keylen; p = chunk->pos; if (*p == '.' && !(parser->flags & UCL_PARSER_DISABLE_MACRO)) { - ucl_chunk_skipc (chunk, p); + ucl_chunk_skipc(chunk, p); parser->prev_state = parser->state; parser->state = UCL_STATE_MACRO_NAME; *end_of_object = false; @@ -1384,19 +1398,19 @@ ucl_parse_key (struct ucl_parser *parser, struct ucl_chunk *chunk, * A key must start with alpha, number, '/' or '_' and end with space character */ if (c == NULL) { - if (chunk->remain >= 2 && ucl_lex_is_comment (p[0], p[1])) { - if (!ucl_skip_comments (parser)) { + if (chunk->remain >= 2 && ucl_lex_is_comment(p[0], p[1])) { + if (!ucl_skip_comments(parser)) { return false; } p = chunk->pos; } - else if (ucl_test_character (*p, UCL_CHARACTER_WHITESPACE_UNSAFE)) { - ucl_chunk_skipc (chunk, p); + else if (ucl_test_character(*p, UCL_CHARACTER_WHITESPACE_UNSAFE)) { + ucl_chunk_skipc(chunk, p); } - else if (ucl_test_character (*p, UCL_CHARACTER_KEY_START)) { + else if (ucl_test_character(*p, UCL_CHARACTER_KEY_START)) { /* The first symbol */ c = p; - ucl_chunk_skipc (chunk, p); + ucl_chunk_skipc(chunk, p); *got_content = true; } else if (*p == '"') { @@ -1404,7 +1418,7 @@ ucl_parse_key (struct ucl_parser *parser, struct ucl_chunk *chunk, c = p + 1; got_quote = true; *got_content = true; - ucl_chunk_skipc (chunk, p); + ucl_chunk_skipc(chunk, p); } else if (*p == '}') { /* We have actually end of an object */ @@ -1412,38 +1426,38 @@ ucl_parse_key (struct ucl_parser *parser, struct ucl_chunk *chunk, return true; } else if (*p == '.' && !(parser->flags & UCL_PARSER_DISABLE_MACRO)) { - ucl_chunk_skipc (chunk, p); + ucl_chunk_skipc(chunk, p); parser->prev_state = parser->state; parser->state = UCL_STATE_MACRO_NAME; return true; } else { /* Invalid identifier */ - ucl_set_err (parser, UCL_ESYNTAX, "key must begin with a letter", - &parser->err); + ucl_set_err(parser, UCL_ESYNTAX, "key must begin with a letter", + &parser->err); return false; } } else { /* Parse the body of a key */ if (!got_quote) { - if (ucl_test_character (*p, UCL_CHARACTER_KEY)) { + if (ucl_test_character(*p, UCL_CHARACTER_KEY)) { *got_content = true; - ucl_chunk_skipc (chunk, p); + ucl_chunk_skipc(chunk, p); } - else if (ucl_test_character (*p, UCL_CHARACTER_KEY_SEP)) { + else if (ucl_test_character(*p, UCL_CHARACTER_KEY_SEP)) { end = p; break; } else { - ucl_set_err (parser, UCL_ESYNTAX, "invalid character in a key", - &parser->err); + ucl_set_err(parser, UCL_ESYNTAX, "invalid character in a key", + &parser->err); return false; } } else { /* We need to parse json like quoted string */ - if (!ucl_lex_json_string (parser, chunk, &need_unescape, &ucl_escape, &var_expand)) { + if (!ucl_lex_json_string(parser, chunk, &need_unescape, &ucl_escape, &var_expand)) { return false; } /* Always escape keys obtained via json */ @@ -1455,7 +1469,7 @@ ucl_parse_key (struct ucl_parser *parser, struct ucl_chunk *chunk, } if (p >= chunk->end && *got_content) { - ucl_set_err (parser, UCL_ESYNTAX, "unfinished key", &parser->err); + ucl_set_err(parser, UCL_ESYNTAX, "unfinished key", &parser->err); return false; } else if (!*got_content) { @@ -1464,34 +1478,34 @@ ucl_parse_key (struct ucl_parser *parser, struct ucl_chunk *chunk, *end_of_object = false; /* We are now at the end of the key, need to parse the rest */ while (p < chunk->end) { - if (ucl_test_character (*p, UCL_CHARACTER_WHITESPACE)) { - ucl_chunk_skipc (chunk, p); + if (ucl_test_character(*p, UCL_CHARACTER_WHITESPACE)) { + ucl_chunk_skipc(chunk, p); } else if (*p == '=') { if (!got_eq && !got_semicolon) { - ucl_chunk_skipc (chunk, p); + ucl_chunk_skipc(chunk, p); got_eq = true; } else { - ucl_set_err (parser, UCL_ESYNTAX, "unexpected '=' character", - &parser->err); + ucl_set_err(parser, UCL_ESYNTAX, "unexpected '=' character", + &parser->err); return false; } } else if (*p == ':') { if (!got_eq && !got_semicolon) { - ucl_chunk_skipc (chunk, p); + ucl_chunk_skipc(chunk, p); got_semicolon = true; } else { - ucl_set_err (parser, UCL_ESYNTAX, "unexpected ':' character", - &parser->err); + ucl_set_err(parser, UCL_ESYNTAX, "unexpected ':' character", + &parser->err); return false; } } - else if (chunk->remain >= 2 && ucl_lex_is_comment (p[0], p[1])) { + else if (chunk->remain >= 2 && ucl_lex_is_comment(p[0], p[1])) { /* Check for comment */ - if (!ucl_skip_comments (parser)) { + if (!ucl_skip_comments(parser)) { return false; } p = chunk->pos; @@ -1503,7 +1517,7 @@ ucl_parse_key (struct ucl_parser *parser, struct ucl_chunk *chunk, } if (p >= chunk->end && got_content) { - ucl_set_err (parser, UCL_ESYNTAX, "unfinished key", &parser->err); + ucl_set_err(parser, UCL_ESYNTAX, "unfinished key", &parser->err); return false; } @@ -1519,8 +1533,8 @@ ucl_parse_key (struct ucl_parser *parser, struct ucl_chunk *chunk, */ t = p; *next_key = false; - while (ucl_test_character (*t, UCL_CHARACTER_WHITESPACE)) { - t ++; + while (ucl_test_character(*t, UCL_CHARACTER_WHITESPACE)) { + t++; } /* Check first non-space character after a key */ if (*t != '{' && *t != '[') { @@ -1532,33 +1546,33 @@ ucl_parse_key (struct ucl_parser *parser, struct ucl_chunk *chunk, *next_key = true; break; } - t ++; + t++; } } } /* Create a new object */ - nobj = ucl_object_new_full (UCL_NULL, parser->chunks->priority); + nobj = ucl_object_new_full(UCL_NULL, parser->chunks->priority); if (nobj == NULL) { return false; } - keylen = ucl_copy_or_store_ptr (parser, c, &nobj->trash_stack[UCL_TRASH_KEY], - &key, end - c, need_unescape, parser->flags & UCL_PARSER_KEY_LOWERCASE, - false, false); + keylen = ucl_copy_or_store_ptr(parser, c, &nobj->trash_stack[UCL_TRASH_KEY], + &key, end - c, need_unescape, parser->flags & UCL_PARSER_KEY_LOWERCASE, + false, false); if (keylen == -1) { - ucl_object_unref (nobj); + ucl_object_unref(nobj); return false; } else if (keylen == 0) { - ucl_set_err (parser, UCL_ESYNTAX, "empty keys are not allowed", &parser->err); - ucl_object_unref (nobj); + ucl_set_err(parser, UCL_ESYNTAX, "empty keys are not allowed", &parser->err); + ucl_object_unref(nobj); return false; } nobj->key = key; nobj->keylen = keylen; - if (!ucl_parser_process_object_element (parser, nobj)) { + if (!ucl_parser_process_object_element(parser, nobj)) { return false; } @@ -1579,8 +1593,8 @@ ucl_parse_key (struct ucl_parser *parser, struct ucl_chunk *chunk, * @return true if a key has been parsed */ static bool -ucl_parse_string_value (struct ucl_parser *parser, - struct ucl_chunk *chunk, bool *var_expand, bool *need_unescape) +ucl_parse_string_value(struct ucl_parser *parser, + struct ucl_chunk *chunk, bool *var_expand, bool *need_unescape) { const unsigned char *p; enum { @@ -1596,25 +1610,25 @@ ucl_parse_string_value (struct ucl_parser *parser, /* Skip pairs of figure braces */ if (*p == '{') { - braces[UCL_BRACE_FIGURE][0] ++; + braces[UCL_BRACE_FIGURE][0]++; } else if (*p == '}') { - braces[UCL_BRACE_FIGURE][1] ++; + braces[UCL_BRACE_FIGURE][1]++; if (braces[UCL_BRACE_FIGURE][1] <= braces[UCL_BRACE_FIGURE][0]) { /* This is not a termination symbol, continue */ - ucl_chunk_skipc (chunk, p); + ucl_chunk_skipc(chunk, p); continue; } } /* Skip pairs of square braces */ else if (*p == '[') { - braces[UCL_BRACE_SQUARE][0] ++; + braces[UCL_BRACE_SQUARE][0]++; } else if (*p == ']') { - braces[UCL_BRACE_SQUARE][1] ++; + braces[UCL_BRACE_SQUARE][1]++; if (braces[UCL_BRACE_SQUARE][1] <= braces[UCL_BRACE_SQUARE][0]) { /* This is not a termination symbol, continue */ - ucl_chunk_skipc (chunk, p); + ucl_chunk_skipc(chunk, p); continue; } } @@ -1623,17 +1637,17 @@ ucl_parse_string_value (struct ucl_parser *parser, } else if (*p == '\\') { *need_unescape = true; - ucl_chunk_skipc (chunk, p); + ucl_chunk_skipc(chunk, p); if (p < chunk->end) { - ucl_chunk_skipc (chunk, p); + ucl_chunk_skipc(chunk, p); } continue; } - if (ucl_lex_is_atom_end (*p) || (chunk->remain >= 2 && ucl_lex_is_comment (p[0], p[1]))) { + if (ucl_lex_is_atom_end(*p) || (chunk->remain >= 2 && ucl_lex_is_comment(p[0], p[1]))) { break; } - ucl_chunk_skipc (chunk, p); + ucl_chunk_skipc(chunk, p); } return true; @@ -1650,10 +1664,10 @@ ucl_parse_string_value (struct ucl_parser *parser, * @return size of multiline string or 0 in case of error */ static int -ucl_parse_multiline_string (struct ucl_parser *parser, - struct ucl_chunk *chunk, const unsigned char *term, - int term_len, unsigned char const **beg, - bool *var_expand) +ucl_parse_multiline_string(struct ucl_parser *parser, + struct ucl_chunk *chunk, const unsigned char *term, + int term_len, unsigned char const **beg, + bool *var_expand) { const unsigned char *p, *c, *tend; bool newline = false; @@ -1668,11 +1682,11 @@ ucl_parse_multiline_string (struct ucl_parser *parser, if (chunk->end - p < term_len) { return 0; } - else if (memcmp (p, term, term_len) == 0) { + else if (memcmp(p, term, term_len) == 0) { tend = p + term_len; - if (*tend != '\n' && *tend != ';' && *tend != ',') { + if (tend < chunk->end && *tend != '\n' && *tend != ';' && *tend != ',') { /* Incomplete terminator */ - ucl_chunk_skipc (chunk, p); + ucl_chunk_skipc(chunk, p); continue; } len = p - c; @@ -1692,14 +1706,14 @@ ucl_parse_multiline_string (struct ucl_parser *parser, } newline = false; } - ucl_chunk_skipc (chunk, p); + ucl_chunk_skipc(chunk, p); } return len; } -static inline ucl_object_t* -ucl_parser_get_container (struct ucl_parser *parser) +static inline ucl_object_t * +ucl_parser_get_container(struct ucl_parser *parser) { ucl_object_t *t, *obj = NULL; @@ -1709,16 +1723,16 @@ ucl_parser_get_container (struct ucl_parser *parser) if (parser->stack->obj->type == UCL_ARRAY) { /* Object must be allocated */ - obj = ucl_object_new_full (UCL_NULL, parser->chunks->priority); + obj = ucl_object_new_full(UCL_NULL, parser->chunks->priority); t = parser->stack->obj; - if (!ucl_array_append (t, obj)) { - ucl_object_unref (obj); + if (!ucl_array_append(t, obj)) { + ucl_object_unref(obj); return NULL; } parser->cur_obj = obj; - ucl_attach_comment (parser, obj, false); + ucl_attach_comment(parser, obj, false); } else { /* Object has been already allocated */ @@ -1735,7 +1749,7 @@ ucl_parser_get_container (struct ucl_parser *parser) * @return */ static bool -ucl_parse_value (struct ucl_parser *parser, struct ucl_chunk *chunk) +ucl_parse_value(struct ucl_parser *parser, struct ucl_chunk *chunk) { const unsigned char *p, *c; ucl_object_t *obj = NULL; @@ -1746,12 +1760,12 @@ ucl_parse_value (struct ucl_parser *parser, struct ucl_chunk *chunk) p = chunk->pos; /* Skip any spaces and comments */ - if (ucl_test_character (*p, UCL_CHARACTER_WHITESPACE_UNSAFE) || - (chunk->remain >= 2 && ucl_lex_is_comment (p[0], p[1]))) { - while (p < chunk->end && ucl_test_character (*p, UCL_CHARACTER_WHITESPACE_UNSAFE)) { - ucl_chunk_skipc (chunk, p); + if (ucl_test_character(*p, UCL_CHARACTER_WHITESPACE_UNSAFE) || + (chunk->remain >= 2 && ucl_lex_is_comment(p[0], p[1]))) { + while (p < chunk->end && ucl_test_character(*p, UCL_CHARACTER_WHITESPACE_UNSAFE)) { + ucl_chunk_skipc(chunk, p); } - if (!ucl_skip_comments (parser)) { + if (!ucl_skip_comments(parser)) { return false; } p = chunk->pos; @@ -1761,24 +1775,24 @@ ucl_parse_value (struct ucl_parser *parser, struct ucl_chunk *chunk) c = p; switch (*p) { case '"': - ucl_chunk_skipc (chunk, p); + ucl_chunk_skipc(chunk, p); - if (!ucl_lex_json_string (parser, chunk, &need_unescape, &ucl_escape, - &var_expand)) { + if (!ucl_lex_json_string(parser, chunk, &need_unescape, &ucl_escape, + &var_expand)) { return false; } - obj = ucl_parser_get_container (parser); + obj = ucl_parser_get_container(parser); if (!obj) { return false; } str_len = chunk->pos - c - 2; obj->type = UCL_STRING; - if ((str_len = ucl_copy_or_store_ptr (parser, c + 1, - &obj->trash_stack[UCL_TRASH_VALUE], - &obj->value.sv, str_len, need_unescape, false, - var_expand, false)) == -1) { + if ((str_len = ucl_copy_or_store_ptr(parser, c + 1, + &obj->trash_stack[UCL_TRASH_VALUE], + &obj->value.sv, str_len, need_unescape, false, + var_expand, false)) == -1) { return false; } @@ -1788,13 +1802,13 @@ ucl_parse_value (struct ucl_parser *parser, struct ucl_chunk *chunk) return true; break; case '\'': - ucl_chunk_skipc (chunk, p); + ucl_chunk_skipc(chunk, p); - if (!ucl_lex_squoted_string (parser, chunk, &need_unescape)) { + if (!ucl_lex_squoted_string(parser, chunk, &need_unescape)) { return false; } - obj = ucl_parser_get_container (parser); + obj = ucl_parser_get_container(parser); if (!obj) { return false; } @@ -1803,10 +1817,10 @@ ucl_parse_value (struct ucl_parser *parser, struct ucl_chunk *chunk) obj->type = UCL_STRING; obj->flags |= UCL_OBJECT_SQUOTED; - if ((str_len = ucl_copy_or_store_ptr (parser, c + 1, - &obj->trash_stack[UCL_TRASH_VALUE], - &obj->value.sv, str_len, need_unescape, false, - var_expand, true)) == -1) { + if ((str_len = ucl_copy_or_store_ptr(parser, c + 1, + &obj->trash_stack[UCL_TRASH_VALUE], + &obj->value.sv, str_len, need_unescape, false, + var_expand, true)) == -1) { return false; } @@ -1817,17 +1831,17 @@ ucl_parse_value (struct ucl_parser *parser, struct ucl_chunk *chunk) return true; break; case '{': - obj = ucl_parser_get_container (parser); + obj = ucl_parser_get_container(parser); if (obj == NULL) { parser->state = UCL_STATE_ERROR; ucl_set_err(parser, UCL_ESYNTAX, "object value must be a part of an object", - &parser->err); + &parser->err); return false; } /* We have a new object */ if (parser->stack) { - obj = ucl_parser_add_container (obj, parser, false, - parser->stack->e.params.level, true); + obj = ucl_parser_add_container(obj, parser, false, + parser->stack->e.params.level, true); } else { return false; @@ -1836,22 +1850,22 @@ ucl_parse_value (struct ucl_parser *parser, struct ucl_chunk *chunk) return false; } - ucl_chunk_skipc (chunk, p); + ucl_chunk_skipc(chunk, p); return true; break; case '[': - obj = ucl_parser_get_container (parser); + obj = ucl_parser_get_container(parser); if (obj == NULL) { parser->state = UCL_STATE_ERROR; ucl_set_err(parser, UCL_ESYNTAX, "array value must be a part of an object", - &parser->err); + &parser->err); return false; } /* We have a new array */ if (parser->stack) { - obj = ucl_parser_add_container (obj, parser, true, - parser->stack->e.params.level, true); + obj = ucl_parser_add_container(obj, parser, true, + parser->stack->e.params.level, true); } else { return false; @@ -1861,7 +1875,7 @@ ucl_parse_value (struct ucl_parser *parser, struct ucl_chunk *chunk) return false; } - ucl_chunk_skipc (chunk, p); + ucl_chunk_skipc(chunk, p); return true; break; @@ -1876,46 +1890,46 @@ ucl_parse_value (struct ucl_parser *parser, struct ucl_chunk *chunk) } break; case '<': - obj = ucl_parser_get_container (parser); + obj = ucl_parser_get_container(parser); if (obj == NULL) { parser->state = UCL_STATE_ERROR; ucl_set_err(parser, UCL_ESYNTAX, "multiline value must be a part of an object", - &parser->err); + &parser->err); return false; } /* We have something like multiline value, which must be <<[A-Z]+\n */ if (chunk->end - p > 3) { - if (memcmp (p, "<<", 2) == 0) { + if (memcmp(p, "<<", 2) == 0) { p += 2; /* We allow only uppercase characters in multiline definitions */ while (p < chunk->end && *p >= 'A' && *p <= 'Z') { - p ++; + p++; } - if(p == chunk->end) { - ucl_set_err (parser, UCL_ESYNTAX, - "unterminated multiline value", &parser->err); + if (p == chunk->end) { + ucl_set_err(parser, UCL_ESYNTAX, + "unterminated multiline value", &parser->err); return false; } - if (*p =='\n') { + if (*p == '\n') { /* Set chunk positions and start multiline parsing */ chunk->remain -= p - c + 1; c += 2; chunk->pos = p + 1; chunk->column = 0; - chunk->line ++; - if ((str_len = ucl_parse_multiline_string (parser, chunk, c, - p - c, &c, &var_expand)) == 0) { - ucl_set_err (parser, UCL_ESYNTAX, - "unterminated multiline value", &parser->err); + chunk->line++; + if ((str_len = ucl_parse_multiline_string(parser, chunk, c, + p - c, &c, &var_expand)) == 0) { + ucl_set_err(parser, UCL_ESYNTAX, + "unterminated multiline value", &parser->err); return false; } obj->type = UCL_STRING; obj->flags |= UCL_OBJECT_MULTILINE; - if ((str_len = ucl_copy_or_store_ptr (parser, c, - &obj->trash_stack[UCL_TRASH_VALUE], - &obj->value.sv, str_len - 1, false, - false, var_expand, false)) == -1) { + if ((str_len = ucl_copy_or_store_ptr(parser, c, + &obj->trash_stack[UCL_TRASH_VALUE], + &obj->value.sv, str_len - 1, false, + false, var_expand, false)) == -1) { return false; } obj->len = str_len; @@ -1929,21 +1943,21 @@ ucl_parse_value (struct ucl_parser *parser, struct ucl_chunk *chunk) /* Fallback to ordinary strings */ /* FALLTHRU */ default: -parse_string: + parse_string: if (obj == NULL) { - obj = ucl_parser_get_container (parser); + obj = ucl_parser_get_container(parser); } if (obj == NULL) { parser->state = UCL_STATE_ERROR; ucl_set_err(parser, UCL_ESYNTAX, "value must be a part of an object", - &parser->err); + &parser->err); return false; } /* Parse atom */ - if (ucl_test_character (*p, UCL_CHARACTER_VALUE_DIGIT_START)) { - if (!ucl_lex_number (parser, chunk, obj)) { + if (ucl_test_character(*p, UCL_CHARACTER_VALUE_DIGIT_START)) { + if (!ucl_lex_number(parser, chunk, obj)) { if (parser->state == UCL_STATE_ERROR) { return false; } @@ -1955,42 +1969,42 @@ parse_string: /* Fallback to normal string */ } - if (!ucl_parse_string_value (parser, chunk, &var_expand, - &need_unescape)) { + if (!ucl_parse_string_value(parser, chunk, &var_expand, + &need_unescape)) { return false; } /* Cut trailing spaces */ stripped_spaces = 0; - while (ucl_test_character (*(chunk->pos - 1 - stripped_spaces), - UCL_CHARACTER_WHITESPACE)) { - stripped_spaces ++; + while (ucl_test_character(*(chunk->pos - 1 - stripped_spaces), + UCL_CHARACTER_WHITESPACE)) { + stripped_spaces++; } str_len = chunk->pos - c - stripped_spaces; if (str_len <= 0) { - ucl_set_err (parser, UCL_ESYNTAX, "string value must not be empty", - &parser->err); + ucl_set_err(parser, UCL_ESYNTAX, "string value must not be empty", + &parser->err); return false; } - else if (str_len == 4 && memcmp (c, "null", 4) == 0) { + else if (str_len == 4 && memcmp(c, "null", 4) == 0) { obj->len = 0; obj->type = UCL_NULL; } - else if (str_len == 3 && memcmp (c, "nan", 3) == 0) { + else if (str_len == 3 && memcmp(c, "nan", 3) == 0) { obj->len = 0; obj->type = UCL_FLOAT; obj->value.dv = NAN; } - else if (str_len == 3 && memcmp (c, "inf", 3) == 0) { + else if (str_len == 3 && memcmp(c, "inf", 3) == 0) { obj->len = 0; obj->type = UCL_FLOAT; obj->value.dv = INFINITY; } - else if (!ucl_maybe_parse_boolean (obj, c, str_len)) { + else if (!ucl_maybe_parse_boolean(obj, c, str_len)) { obj->type = UCL_STRING; - if ((str_len = ucl_copy_or_store_ptr (parser, c, - &obj->trash_stack[UCL_TRASH_VALUE], - &obj->value.sv, str_len, need_unescape, - false, var_expand, false)) == -1) { + if ((str_len = ucl_copy_or_store_ptr(parser, c, + &obj->trash_stack[UCL_TRASH_VALUE], + &obj->value.sv, str_len, need_unescape, + false, var_expand, false)) == -1) { return false; } obj->len = str_len; @@ -2013,7 +2027,7 @@ parse_string: * @return */ static bool -ucl_parse_after_value (struct ucl_parser *parser, struct ucl_chunk *chunk) +ucl_parse_after_value(struct ucl_parser *parser, struct ucl_chunk *chunk) { const unsigned char *p; bool got_sep = false; @@ -2022,48 +2036,53 @@ ucl_parse_after_value (struct ucl_parser *parser, struct ucl_chunk *chunk) p = chunk->pos; while (p < chunk->end) { - if (ucl_test_character (*p, UCL_CHARACTER_WHITESPACE)) { + if (ucl_test_character(*p, UCL_CHARACTER_WHITESPACE)) { /* Skip whitespaces */ - ucl_chunk_skipc (chunk, p); + ucl_chunk_skipc(chunk, p); } - else if (chunk->remain >= 2 && ucl_lex_is_comment (p[0], p[1])) { + else if (chunk->remain >= 2 && ucl_lex_is_comment(p[0], p[1])) { /* Skip comment */ - if (!ucl_skip_comments (parser)) { + if (!ucl_skip_comments(parser)) { return false; } /* Treat comment as a separator */ got_sep = true; p = chunk->pos; } - else if (ucl_test_character (*p, UCL_CHARACTER_VALUE_END)) { + else if (ucl_test_character(*p, UCL_CHARACTER_VALUE_END)) { if (*p == '}' || *p == ']') { if (parser->stack == NULL) { - ucl_set_err (parser, UCL_ESYNTAX, - "end of array or object detected without corresponding start", - &parser->err); + ucl_set_err(parser, UCL_ESYNTAX, + "end of array or object detected without corresponding start", + &parser->err); return false; } if ((*p == '}' && parser->stack->obj->type == UCL_OBJECT) || - (*p == ']' && parser->stack->obj->type == UCL_ARRAY)) { + (*p == ']' && parser->stack->obj->type == UCL_ARRAY)) { /* Pop all nested objects from a stack */ st = parser->stack; if (!(st->e.params.flags & UCL_STACK_HAS_OBRACE)) { parser->err_code = UCL_EUNPAIRED; - ucl_create_err (&parser->err, - "%s:%d object closed with } is not opened with { at line %d", - chunk->fname ? chunk->fname : "memory", - parser->chunks->line, st->e.params.line); + ucl_create_err(&parser->err, + "%s:%d object closed with } is not opened with { at line %d", + chunk->fname ? chunk->fname : "memory", + parser->chunks->line, st->e.params.line); return false; } - parser->stack = st->next; - UCL_FREE (sizeof (struct ucl_stack), st); + if ((st->e.params.flags & UCL_STACK_AUTOMATIC)) { + st->e.params.flags = 0; + } + else { + parser->stack = st->next; + UCL_FREE(sizeof(struct ucl_stack), st); + } if (parser->cur_obj) { - ucl_attach_comment (parser, parser->cur_obj, true); + ucl_attach_comment(parser, parser->cur_obj, true); } while (parser->stack != NULL) { @@ -2079,13 +2098,13 @@ ucl_parse_after_value (struct ucl_parser *parser, struct ucl_chunk *chunk) parser->stack = st->next; parser->cur_obj = st->obj; - UCL_FREE (sizeof (struct ucl_stack), st); + UCL_FREE(sizeof(struct ucl_stack), st); } } else { - ucl_set_err (parser, UCL_ESYNTAX, - "unexpected terminating symbol detected", - &parser->err); + ucl_set_err(parser, UCL_ESYNTAX, + "unexpected terminating symbol detected", + &parser->err); return false; } @@ -2094,21 +2113,21 @@ ucl_parse_after_value (struct ucl_parser *parser, struct ucl_chunk *chunk) return true; } else { - ucl_chunk_skipc (chunk, p); + ucl_chunk_skipc(chunk, p); } got_sep = true; } else { /* Got a separator */ got_sep = true; - ucl_chunk_skipc (chunk, p); + ucl_chunk_skipc(chunk, p); } } else { /* Anything else */ if (!got_sep) { - ucl_set_err (parser, UCL_ESYNTAX, "delimiter is missing", - &parser->err); + ucl_set_err(parser, UCL_ESYNTAX, "delimiter is missing", + &parser->err); return false; } return true; @@ -2119,8 +2138,8 @@ ucl_parse_after_value (struct ucl_parser *parser, struct ucl_chunk *chunk) } static bool -ucl_skip_macro_as_comment (struct ucl_parser *parser, - struct ucl_chunk *chunk) +ucl_skip_macro_as_comment(struct ucl_parser *parser, + struct ucl_chunk *chunk) { const unsigned char *p, *c; enum { @@ -2131,7 +2150,8 @@ ucl_skip_macro_as_comment (struct ucl_parser *parser, macro_has_backslash, macro_has_sqbrace, macro_save - } state = macro_skip_start, prev_state = macro_skip_start; + } state = macro_skip_start, + prev_state = macro_skip_start; p = chunk->pos; c = chunk->pos; @@ -2139,15 +2159,15 @@ ucl_skip_macro_as_comment (struct ucl_parser *parser, while (p < chunk->end) { switch (state) { case macro_skip_start: - if (!ucl_test_character (*p, UCL_CHARACTER_WHITESPACE)) { + if (!ucl_test_character(*p, UCL_CHARACTER_WHITESPACE)) { state = macro_has_symbols; } - else if (ucl_test_character (*p, UCL_CHARACTER_WHITESPACE_UNSAFE)) { + else if (ucl_test_character(*p, UCL_CHARACTER_WHITESPACE_UNSAFE)) { state = macro_save; continue; } - ucl_chunk_skipc (chunk, p); + ucl_chunk_skipc(chunk, p); break; case macro_has_symbols: @@ -2165,7 +2185,7 @@ ucl_skip_macro_as_comment (struct ucl_parser *parser, continue; } - ucl_chunk_skipc (chunk, p); + ucl_chunk_skipc(chunk, p); break; case macro_has_obrace: @@ -2177,7 +2197,7 @@ ucl_skip_macro_as_comment (struct ucl_parser *parser, state = macro_has_symbols; } - ucl_chunk_skipc (chunk, p); + ucl_chunk_skipc(chunk, p); break; case macro_has_sqbrace: @@ -2189,7 +2209,7 @@ ucl_skip_macro_as_comment (struct ucl_parser *parser, state = macro_save; } - ucl_chunk_skipc (chunk, p); + ucl_chunk_skipc(chunk, p); break; case macro_has_quote: @@ -2201,17 +2221,17 @@ ucl_skip_macro_as_comment (struct ucl_parser *parser, state = macro_save; } - ucl_chunk_skipc (chunk, p); + ucl_chunk_skipc(chunk, p); break; case macro_has_backslash: state = prev_state; - ucl_chunk_skipc (chunk, p); + ucl_chunk_skipc(chunk, p); break; case macro_save: if (parser->flags & UCL_PARSER_SAVE_COMMENTS) { - ucl_save_comment (parser, c, p - c); + ucl_save_comment(parser, c, p - c); } return true; @@ -2231,9 +2251,9 @@ ucl_skip_macro_as_comment (struct ucl_parser *parser, * @return */ static bool -ucl_parse_macro_value (struct ucl_parser *parser, - struct ucl_chunk *chunk, struct ucl_macro *macro, - unsigned char const **macro_start, size_t *macro_len) +ucl_parse_macro_value(struct ucl_parser *parser, + struct ucl_chunk *chunk, struct ucl_macro *macro, + unsigned char const **macro_start, size_t *macro_len) { const unsigned char *p, *c; bool need_unescape = false, ucl_escape = false, var_expand = false; @@ -2244,8 +2264,8 @@ ucl_parse_macro_value (struct ucl_parser *parser, case '"': /* We have macro value encoded in quotes */ c = p; - ucl_chunk_skipc (chunk, p); - if (!ucl_lex_json_string (parser, chunk, &need_unescape, &ucl_escape, &var_expand)) { + ucl_chunk_skipc(chunk, p); + if (!ucl_lex_json_string(parser, chunk, &need_unescape, &ucl_escape, &var_expand)) { return false; } @@ -2255,11 +2275,11 @@ ucl_parse_macro_value (struct ucl_parser *parser, break; case '{': /* We got a multiline macro body */ - ucl_chunk_skipc (chunk, p); + ucl_chunk_skipc(chunk, p); /* Skip spaces at the beginning */ while (p < chunk->end) { - if (ucl_test_character (*p, UCL_CHARACTER_WHITESPACE_UNSAFE)) { - ucl_chunk_skipc (chunk, p); + if (ucl_test_character(*p, UCL_CHARACTER_WHITESPACE_UNSAFE)) { + ucl_chunk_skipc(chunk, p); } else { break; @@ -2270,20 +2290,20 @@ ucl_parse_macro_value (struct ucl_parser *parser, if (*p == '}') { break; } - ucl_chunk_skipc (chunk, p); + ucl_chunk_skipc(chunk, p); } *macro_start = c; *macro_len = p - c; - ucl_chunk_skipc (chunk, p); + ucl_chunk_skipc(chunk, p); break; default: /* Macro is not enclosed in quotes or braces */ c = p; while (p < chunk->end) { - if (ucl_lex_is_atom_end (*p)) { + if (ucl_lex_is_atom_end(*p)) { break; } - ucl_chunk_skipc (chunk, p); + ucl_chunk_skipc(chunk, p); } *macro_start = c; *macro_len = p - c; @@ -2293,10 +2313,10 @@ ucl_parse_macro_value (struct ucl_parser *parser, /* We are at the end of a macro */ /* Skip ';' and space characters and return to previous state */ while (p < chunk->end) { - if (!ucl_test_character (*p, UCL_CHARACTER_WHITESPACE_UNSAFE) && *p != ';') { + if (!ucl_test_character(*p, UCL_CHARACTER_WHITESPACE_UNSAFE) && *p != ';') { break; } - ucl_chunk_skipc (chunk, p); + ucl_chunk_skipc(chunk, p); } return true; } @@ -2308,8 +2328,8 @@ ucl_parse_macro_value (struct ucl_parser *parser, * @return */ static ucl_object_t * -ucl_parse_macro_arguments (struct ucl_parser *parser, - struct ucl_chunk *chunk) +ucl_parse_macro_arguments(struct ucl_parser *parser, + struct ucl_chunk *chunk) { ucl_object_t *res = NULL; struct ucl_parser *params_parser; @@ -2329,7 +2349,7 @@ ucl_parse_macro_arguments (struct ucl_parser *parser, } /* Set begin and start */ - ucl_chunk_skipc (chunk, p); + ucl_chunk_skipc(chunk, p); c = p; while ((p) < (chunk)->end) { @@ -2337,10 +2357,10 @@ ucl_parse_macro_arguments (struct ucl_parser *parser, case 0: /* Parse symbols and check for '(', ')' and '"' */ if (*p == '(') { - obraces ++; + obraces++; } else if (*p == ')') { - ebraces ++; + ebraces++; } else if (*p == '"') { state = 1; @@ -2350,13 +2370,13 @@ ucl_parse_macro_arguments (struct ucl_parser *parser, state = 99; } else { - args_len ++; + args_len++; } /* Check overflow */ if (chunk->remain == 0) { goto restore_chunk; } - ucl_chunk_skipc (chunk, p); + ucl_chunk_skipc(chunk, p); break; case 1: /* We have quote character, so skip all but quotes */ @@ -2366,23 +2386,23 @@ ucl_parse_macro_arguments (struct ucl_parser *parser, if (chunk->remain == 0) { goto restore_chunk; } - args_len ++; - ucl_chunk_skipc (chunk, p); + args_len++; + ucl_chunk_skipc(chunk, p); break; case 99: /* * We have read the full body of arguments, so we need to parse and set * object from that */ - params_parser = ucl_parser_new (parser->flags); - if (!ucl_parser_add_chunk (params_parser, c, args_len)) { - ucl_set_err (parser, UCL_ESYNTAX, "macro arguments parsing error", - &parser->err); + params_parser = ucl_parser_new(parser->flags); + if (!ucl_parser_add_chunk(params_parser, c, args_len)) { + ucl_set_err(parser, UCL_ESYNTAX, "macro arguments parsing error", + &parser->err); } else { - res = ucl_parser_get_object (params_parser); + res = ucl_parser_get_object(params_parser); } - ucl_parser_free (params_parser); + ucl_parser_free(params_parser); return res; @@ -2401,20 +2421,21 @@ restore_chunk: return NULL; } -#define SKIP_SPACES_COMMENTS(parser, chunk, p) do { \ - while ((p) < (chunk)->end) { \ - if (!ucl_test_character (*(p), UCL_CHARACTER_WHITESPACE_UNSAFE)) { \ - if ((chunk)->remain >= 2 && ucl_lex_is_comment ((p)[0], (p)[1])) { \ - if (!ucl_skip_comments (parser)) { \ - return false; \ - } \ - p = (chunk)->pos; \ - } \ - break; \ - } \ - ucl_chunk_skipc (chunk, p); \ - } \ -} while(0) +#define SKIP_SPACES_COMMENTS(parser, chunk, p) \ + do { \ + while ((p) < (chunk)->end) { \ + if (!ucl_test_character(*(p), UCL_CHARACTER_WHITESPACE_UNSAFE)) { \ + if ((chunk)->remain >= 2 && ucl_lex_is_comment((p)[0], (p)[1])) { \ + if (!ucl_skip_comments(parser)) { \ + return false; \ + } \ + p = (chunk)->pos; \ + } \ + break; \ + } \ + ucl_chunk_skipc(chunk, p); \ + } \ + } while (0) /** * Handle the main states of rcl parser @@ -2422,7 +2443,7 @@ restore_chunk: * @return true if chunk has been parsed and false in case of error */ static bool -ucl_state_machine (struct ucl_parser *parser) +ucl_state_machine(struct ucl_parser *parser) { ucl_object_t *obj, *macro_args; struct ucl_chunk *chunk = parser->chunks; @@ -2445,7 +2466,7 @@ ucl_state_machine (struct ucl_parser *parser) * if we got [ or { correspondingly or can just treat new data as * a key of newly created object */ - if (!ucl_skip_comments (parser)) { + if (!ucl_skip_comments(parser)) { parser->prev_state = parser->state; parser->state = UCL_STATE_ERROR; return false; @@ -2454,9 +2475,9 @@ ucl_state_machine (struct ucl_parser *parser) bool seen_obrace = false; /* Skip any spaces */ - while (p < chunk->end && ucl_test_character (*p, - UCL_CHARACTER_WHITESPACE_UNSAFE)) { - ucl_chunk_skipc (chunk, p); + while (p < chunk->end && ucl_test_character(*p, + UCL_CHARACTER_WHITESPACE_UNSAFE)) { + ucl_chunk_skipc(chunk, p); } p = chunk->pos; @@ -2464,13 +2485,13 @@ ucl_state_machine (struct ucl_parser *parser) if (p < chunk->end) { if (*p == '[') { parser->state = UCL_STATE_VALUE; - ucl_chunk_skipc (chunk, p); + ucl_chunk_skipc(chunk, p); seen_obrace = true; } else { if (*p == '{') { - ucl_chunk_skipc (chunk, p); + ucl_chunk_skipc(chunk, p); parser->state = UCL_STATE_KEY_OBRACE; seen_obrace = true; } @@ -2482,12 +2503,12 @@ ucl_state_machine (struct ucl_parser *parser) if (parser->top_obj == NULL) { if (parser->state == UCL_STATE_VALUE) { - obj = ucl_parser_add_container (NULL, parser, true, 0, - seen_obrace); + obj = ucl_parser_add_container(NULL, parser, true, 0, + seen_obrace); } else { - obj = ucl_parser_add_container (NULL, parser, false, 0, - seen_obrace); + obj = ucl_parser_add_container(NULL, parser, false, 0, + seen_obrace); } if (obj == NULL) { @@ -2497,14 +2518,15 @@ ucl_state_machine (struct ucl_parser *parser) parser->top_obj = obj; parser->cur_obj = obj; } - } break; - case UCL_STATE_KEY: case UCL_STATE_KEY_OBRACE: + parser->stack->e.params.flags |= UCL_STACK_HAS_OBRACE | UCL_STACK_AUTOMATIC; + /* FALLTHROUGHT */ + case UCL_STATE_KEY: /* Skip any spaces */ - while (p < chunk->end && ucl_test_character (*p, UCL_CHARACTER_WHITESPACE_UNSAFE)) { - ucl_chunk_skipc (chunk, p); + while (p < chunk->end && ucl_test_character(*p, UCL_CHARACTER_WHITESPACE_UNSAFE)) { + ucl_chunk_skipc(chunk, p); } if (p == chunk->end || *p == '}') { /* We have the end of an object */ @@ -2513,8 +2535,9 @@ ucl_state_machine (struct ucl_parser *parser) } if (parser->stack == NULL) { /* No objects are on stack, but we want to parse a key */ - ucl_set_err (parser, UCL_ESYNTAX, "top object is finished but the parser " - "expects a key", &parser->err); + ucl_set_err(parser, UCL_ESYNTAX, "top object is finished but the parser " + "expects a key", + &parser->err); parser->prev_state = parser->state; parser->state = UCL_STATE_ERROR; return false; @@ -2522,7 +2545,7 @@ ucl_state_machine (struct ucl_parser *parser) got_content = false; - if (!ucl_parse_key (parser, chunk, &next_key, &end_of_object, &got_content)) { + if (!ucl_parse_key(parser, chunk, &next_key, &end_of_object, &got_content)) { parser->prev_state = parser->state; parser->state = UCL_STATE_ERROR; return false; @@ -2536,11 +2559,11 @@ ucl_state_machine (struct ucl_parser *parser) else if (parser->state != UCL_STATE_MACRO_NAME) { if (next_key && parser->stack->obj->type == UCL_OBJECT) { /* Parse more keys and nest objects accordingly */ - obj = ucl_parser_add_container (parser->cur_obj, - parser, - false, - parser->stack->e.params.level + 1, - parser->state == UCL_STATE_KEY_OBRACE); + obj = ucl_parser_add_container(parser->cur_obj, + parser, + false, + parser->stack->e.params.level + 1, + parser->state == UCL_STATE_KEY_OBRACE); if (obj == NULL) { return false; } @@ -2557,7 +2580,7 @@ ucl_state_machine (struct ucl_parser *parser) break; case UCL_STATE_VALUE: /* We need to check what we do have */ - if (!parser->cur_obj || !ucl_parse_value (parser, chunk)) { + if (!parser->cur_obj || !ucl_parse_value(parser, chunk)) { parser->prev_state = parser->state; parser->state = UCL_STATE_ERROR; return false; @@ -2566,7 +2589,7 @@ ucl_state_machine (struct ucl_parser *parser) p = chunk->pos; break; case UCL_STATE_AFTER_VALUE: - if (!ucl_parse_after_value (parser, chunk)) { + if (!ucl_parse_after_value(parser, chunk)) { parser->prev_state = parser->state; parser->state = UCL_STATE_ERROR; return false; @@ -2590,13 +2613,13 @@ ucl_state_machine (struct ucl_parser *parser) break; case UCL_STATE_MACRO_NAME: if (parser->flags & UCL_PARSER_DISABLE_MACRO) { - if (!ucl_skip_macro_as_comment (parser, chunk)) { + if (!ucl_skip_macro_as_comment(parser, chunk)) { /* We have invalid macro */ - ucl_create_err (&parser->err, - "error at %s:%d at column %d: invalid macro", - chunk->fname ? chunk->fname : "memory", - chunk->line, - chunk->column); + ucl_create_err(&parser->err, + "error at %s:%d at column %d: invalid macro", + chunk->fname ? chunk->fname : "memory", + chunk->line, + chunk->column); parser->state = UCL_STATE_ERROR; return false; } @@ -2606,25 +2629,25 @@ ucl_state_machine (struct ucl_parser *parser) } } else { - if (!ucl_test_character (*p, UCL_CHARACTER_WHITESPACE_UNSAFE) && - *p != '(') { - ucl_chunk_skipc (chunk, p); + if (!ucl_test_character(*p, UCL_CHARACTER_WHITESPACE_UNSAFE) && + *p != '(') { + ucl_chunk_skipc(chunk, p); } else { if (c != NULL && p - c > 0) { /* We got macro name */ macro_len = (size_t) (p - c); - HASH_FIND (hh, parser->macroes, c, macro_len, macro); + HASH_FIND(hh, parser->macroes, c, macro_len, macro); if (macro == NULL) { - ucl_create_err (&parser->err, - "error at %s:%d at column %d: " - "unknown macro: '%.*s', character: '%c'", - chunk->fname ? chunk->fname : "memory", - chunk->line, - chunk->column, - (int) (p - c), - c, - *chunk->pos); + ucl_create_err(&parser->err, + "error at %s:%d at column %d: " + "unknown macro: '%.*s', character: '%c'", + chunk->fname ? chunk->fname : "memory", + chunk->line, + chunk->column, + (int) (p - c), + c, + *chunk->pos); parser->state = UCL_STATE_ERROR; return false; } @@ -2634,11 +2657,11 @@ ucl_state_machine (struct ucl_parser *parser) } else { /* We have invalid macro name */ - ucl_create_err (&parser->err, - "error at %s:%d at column %d: invalid macro name", - chunk->fname ? chunk->fname : "memory", - chunk->line, - chunk->column); + ucl_create_err(&parser->err, + "error at %s:%d at column %d: invalid macro name", + chunk->fname ? chunk->fname : "memory", + chunk->line, + chunk->column); parser->state = UCL_STATE_ERROR; return false; } @@ -2647,7 +2670,7 @@ ucl_state_machine (struct ucl_parser *parser) break; case UCL_STATE_MACRO: if (*chunk->pos == '(') { - macro_args = ucl_parse_macro_arguments (parser, chunk); + macro_args = ucl_parse_macro_arguments(parser, chunk); p = chunk->pos; if (macro_args) { SKIP_SPACES_COMMENTS(parser, chunk, p); @@ -2656,46 +2679,46 @@ ucl_state_machine (struct ucl_parser *parser) else { macro_args = NULL; } - if (!ucl_parse_macro_value (parser, chunk, macro, - ¯o_start, ¯o_len)) { + if (!ucl_parse_macro_value(parser, chunk, macro, + ¯o_start, ¯o_len)) { parser->prev_state = parser->state; parser->state = UCL_STATE_ERROR; return false; } - macro_len = ucl_expand_variable (parser, ¯o_escaped, - macro_start, macro_len); + macro_len = ucl_expand_variable(parser, ¯o_escaped, + macro_start, macro_len); parser->state = parser->prev_state; if (macro_escaped == NULL && macro != NULL) { if (macro->is_context) { - ret = macro->h.context_handler (macro_start, macro_len, - macro_args, - parser->top_obj, - macro->ud); + ret = macro->h.context_handler(macro_start, macro_len, + macro_args, + parser->top_obj, + macro->ud); } else { - ret = macro->h.handler (macro_start, macro_len, macro_args, - macro->ud); + ret = macro->h.handler(macro_start, macro_len, macro_args, + macro->ud); } } else if (macro != NULL) { if (macro->is_context) { - ret = macro->h.context_handler (macro_escaped, macro_len, - macro_args, - parser->top_obj, - macro->ud); + ret = macro->h.context_handler(macro_escaped, macro_len, + macro_args, + parser->top_obj, + macro->ud); } else { - ret = macro->h.handler (macro_escaped, macro_len, macro_args, - macro->ud); + ret = macro->h.handler(macro_escaped, macro_len, macro_args, + macro->ud); } - UCL_FREE (macro_len + 1, macro_escaped); + UCL_FREE(macro_len + 1, macro_escaped); } else { ret = false; - ucl_set_err (parser, UCL_EINTERNAL, - "internal error: parser has macro undefined", &parser->err); + ucl_set_err(parser, UCL_EINTERNAL, + "internal error: parser has macro undefined", &parser->err); } /* @@ -2705,7 +2728,7 @@ ucl_state_machine (struct ucl_parser *parser) p = chunk->pos; if (macro_args) { - ucl_object_unref (macro_args); + ucl_object_unref(macro_args); } if (!ret) { @@ -2716,8 +2739,8 @@ ucl_state_machine (struct ucl_parser *parser) /* Already in the error state */ return false; default: - ucl_set_err (parser, UCL_EINTERNAL, - "internal error: parser is in an unknown state", &parser->err); + ucl_set_err(parser, UCL_EINTERNAL, + "internal error: parser is in an unknown state", &parser->err); parser->state = UCL_STATE_ERROR; return false; } @@ -2725,16 +2748,16 @@ ucl_state_machine (struct ucl_parser *parser) if (parser->last_comment) { if (parser->cur_obj) { - ucl_attach_comment (parser, parser->cur_obj, true); + ucl_attach_comment(parser, parser->cur_obj, true); } else if (parser->stack && parser->stack->obj) { - ucl_attach_comment (parser, parser->stack->obj, true); + ucl_attach_comment(parser, parser->stack->obj, true); } else if (parser->top_obj) { - ucl_attach_comment (parser, parser->top_obj, true); + ucl_attach_comment(parser, parser->top_obj, true); } else { - ucl_object_unref (parser->last_comment); + ucl_object_unref(parser->last_comment); } } @@ -2742,19 +2765,20 @@ ucl_state_machine (struct ucl_parser *parser) struct ucl_stack *st; bool has_error = false; - LL_FOREACH (parser->stack, st) { + LL_FOREACH(parser->stack, st) + { if (st->chunk != parser->chunks) { break; /* Not our chunk, give up */ } if (st->e.params.flags & UCL_STACK_HAS_OBRACE) { if (parser->err == NULL) { - utstring_new (parser->err); + utstring_new(parser->err); } - utstring_printf (parser->err, "%s:%d unmatched open brace at %d; ", - chunk->fname ? chunk->fname : "memory", - parser->chunks->line, - st->e.params.line); + utstring_printf(parser->err, "%s:%d unmatched open brace at %d; ", + chunk->fname ? chunk->fname : "memory", + parser->chunks->line, + st->e.params.line); has_error = true; } @@ -2770,22 +2794,23 @@ ucl_state_machine (struct ucl_parser *parser) return true; } -#define UPRM_SAFE(fn, a, b, c, el) do { \ - if (!fn(a, b, c, a)) \ - goto el; \ +#define UPRM_SAFE(fn, a, b, c, el) \ + do { \ + if (!fn(a, b, c, a)) \ + goto el; \ } while (0) -struct ucl_parser* -ucl_parser_new (int flags) +struct ucl_parser * +ucl_parser_new(int flags) { struct ucl_parser *parser; - parser = UCL_ALLOC (sizeof (struct ucl_parser)); + parser = UCL_ALLOC(sizeof(struct ucl_parser)); if (parser == NULL) { return NULL; } - memset (parser, 0, sizeof (struct ucl_parser)); + memset(parser, 0, sizeof(struct ucl_parser)); UPRM_SAFE(ucl_parser_register_macro, parser, "include", ucl_include_handler, e0); UPRM_SAFE(ucl_parser_register_macro, parser, "try_include", ucl_try_include_handler, e0); @@ -2798,12 +2823,12 @@ ucl_parser_new (int flags) parser->includepaths = NULL; if (flags & UCL_PARSER_SAVE_COMMENTS) { - parser->comments = ucl_object_typed_new (UCL_OBJECT); + parser->comments = ucl_object_typed_new(UCL_OBJECT); } if (!(flags & UCL_PARSER_NO_FILEVARS)) { /* Initial assumption about filevars */ - ucl_parser_set_filevars (parser, NULL, false); + ucl_parser_set_filevars(parser, NULL, false); } return parser; @@ -2812,8 +2837,7 @@ e0: return NULL; } -bool -ucl_parser_set_default_priority (struct ucl_parser *parser, unsigned prio) +bool ucl_parser_set_default_priority(struct ucl_parser *parser, unsigned prio) { if (parser == NULL) { return false; @@ -2824,8 +2848,7 @@ ucl_parser_set_default_priority (struct ucl_parser *parser, unsigned prio) return true; } -int -ucl_parser_get_default_priority (struct ucl_parser *parser) +int ucl_parser_get_default_priority(struct ucl_parser *parser) { if (parser == NULL) { return -1; @@ -2834,9 +2857,8 @@ ucl_parser_get_default_priority (struct ucl_parser *parser) return parser->default_priority; } -bool -ucl_parser_register_macro (struct ucl_parser *parser, const char *macro, - ucl_macro_handler handler, void* ud) +bool ucl_parser_register_macro(struct ucl_parser *parser, const char *macro, + ucl_macro_handler handler, void *ud) { struct ucl_macro *new; @@ -2844,26 +2866,25 @@ ucl_parser_register_macro (struct ucl_parser *parser, const char *macro, return false; } - new = UCL_ALLOC (sizeof (struct ucl_macro)); + new = UCL_ALLOC(sizeof(struct ucl_macro)); if (new == NULL) { return false; } - memset (new, 0, sizeof (struct ucl_macro)); + memset(new, 0, sizeof(struct ucl_macro)); new->h.handler = handler; - new->name = strdup (macro); + new->name = UCL_STRDUP(macro); if (new->name == NULL) { - UCL_FREE (sizeof (struct ucl_macro), new); + UCL_FREE(sizeof(struct ucl_macro), new); return false; } new->ud = ud; - HASH_ADD_KEYPTR (hh, parser->macroes, new->name, strlen (new->name), new); + HASH_ADD_KEYPTR(hh, parser->macroes, new->name, strlen(new->name), new); return true; } -bool -ucl_parser_register_context_macro (struct ucl_parser *parser, const char *macro, - ucl_context_macro_handler handler, void* ud) +bool ucl_parser_register_context_macro(struct ucl_parser *parser, const char *macro, + ucl_context_macro_handler handler, void *ud) { struct ucl_macro *new; @@ -2871,27 +2892,26 @@ ucl_parser_register_context_macro (struct ucl_parser *parser, const char *macro, return false; } - new = UCL_ALLOC (sizeof (struct ucl_macro)); + new = UCL_ALLOC(sizeof(struct ucl_macro)); if (new == NULL) { return false; } - memset (new, 0, sizeof (struct ucl_macro)); + memset(new, 0, sizeof(struct ucl_macro)); new->h.context_handler = handler; - new->name = strdup (macro); + new->name = UCL_STRDUP(macro); if (new->name == NULL) { - UCL_FREE (sizeof (struct ucl_macro), new); + UCL_FREE(sizeof(struct ucl_macro), new); return false; } new->ud = ud; new->is_context = true; - HASH_ADD_KEYPTR (hh, parser->macroes, new->name, strlen (new->name), new); + HASH_ADD_KEYPTR(hh, parser->macroes, new->name, strlen(new->name), new); return true; } -void -ucl_parser_register_variable (struct ucl_parser *parser, const char *var, - const char *value) +void ucl_parser_register_variable(struct ucl_parser *parser, const char *var, + const char *value) { struct ucl_variable *new = NULL, *cur; @@ -2900,8 +2920,9 @@ ucl_parser_register_variable (struct ucl_parser *parser, const char *var, } /* Find whether a variable already exists */ - LL_FOREACH (parser->variables, cur) { - if (strcmp (cur->var, var) == 0) { + LL_FOREACH(parser->variables, cur) + { + if (strcmp(cur->var, var) == 0) { new = cur; break; } @@ -2911,10 +2932,10 @@ ucl_parser_register_variable (struct ucl_parser *parser, const char *var, if (new != NULL) { /* Remove variable */ - DL_DELETE (parser->variables, new); - free (new->var); - free (new->value); - UCL_FREE (sizeof (struct ucl_variable), new); + DL_DELETE(parser->variables, new); + UCL_FREE(new->var_len + 1, new->var); + UCL_FREE(new->value_len + 1, new->value); + UCL_FREE(sizeof(struct ucl_variable), new); } else { /* Do nothing */ @@ -2923,38 +2944,36 @@ ucl_parser_register_variable (struct ucl_parser *parser, const char *var, } else { if (new == NULL) { - new = UCL_ALLOC (sizeof (struct ucl_variable)); + new = UCL_ALLOC(sizeof(struct ucl_variable)); if (new == NULL) { return; } - memset (new, 0, sizeof (struct ucl_variable)); - new->var = strdup (var); - new->var_len = strlen (var); - new->value = strdup (value); - new->value_len = strlen (value); + memset(new, 0, sizeof(struct ucl_variable)); + new->var = UCL_STRDUP(var); + new->var_len = strlen(var); + new->value = UCL_STRDUP(value); + new->value_len = strlen(value); - DL_APPEND (parser->variables, new); + DL_APPEND(parser->variables, new); } else { - free (new->value); - new->value = strdup (value); - new->value_len = strlen (value); + UCL_FREE(new->value_len + 1, new->value); + new->value = UCL_STRDUP(value); + new->value_len = strlen(value); } } } -void -ucl_parser_set_variables_handler (struct ucl_parser *parser, - ucl_variable_handler handler, void *ud) +void ucl_parser_set_variables_handler(struct ucl_parser *parser, + ucl_variable_handler handler, void *ud) { parser->var_handler = handler; parser->var_data = ud; } -bool -ucl_parser_add_chunk_full (struct ucl_parser *parser, const unsigned char *data, - size_t len, unsigned priority, enum ucl_duplicate_strategy strat, - enum ucl_parse_type parse_type) +bool ucl_parser_add_chunk_full(struct ucl_parser *parser, const unsigned char *data, + size_t len, unsigned priority, enum ucl_duplicate_strategy strat, + enum ucl_parse_type parse_type) { struct ucl_chunk *chunk; struct ucl_parser_special_handler *special_handler; @@ -2964,43 +2983,44 @@ ucl_parser_add_chunk_full (struct ucl_parser *parser, const unsigned char *data, } if (data == NULL && len != 0) { - ucl_create_err (&parser->err, "invalid chunk added"); + ucl_create_err(&parser->err, "invalid chunk added"); return false; } if (parser->state != UCL_STATE_ERROR) { - chunk = UCL_ALLOC (sizeof (struct ucl_chunk)); + chunk = UCL_ALLOC(sizeof(struct ucl_chunk)); if (chunk == NULL) { - ucl_create_err (&parser->err, "cannot allocate chunk structure"); + ucl_create_err(&parser->err, "cannot allocate chunk structure"); return false; } - memset (chunk, 0, sizeof (*chunk)); + memset(chunk, 0, sizeof(*chunk)); /* Apply all matching handlers from the first to the last */ - LL_FOREACH (parser->special_handlers, special_handler) { + LL_FOREACH(parser->special_handlers, special_handler) + { if ((special_handler->flags & UCL_SPECIAL_HANDLER_PREPROCESS_ALL) || - (len >= special_handler->magic_len && - memcmp (data, special_handler->magic, special_handler->magic_len) == 0)) { + (len >= special_handler->magic_len && + memcmp(data, special_handler->magic, special_handler->magic_len) == 0)) { unsigned char *ndata = NULL; size_t nlen = 0; - if (!special_handler->handler (parser, data, len, &ndata, &nlen, - special_handler->user_data)) { - UCL_FREE(sizeof (struct ucl_chunk), chunk); - ucl_create_err (&parser->err, "call for external handler failed"); + if (!special_handler->handler(parser, data, len, &ndata, &nlen, + special_handler->user_data)) { + UCL_FREE(sizeof(struct ucl_chunk), chunk); + ucl_create_err(&parser->err, "call for external handler failed"); return false; } struct ucl_parser_special_handler_chain *nchain; - nchain = UCL_ALLOC (sizeof (*nchain)); + nchain = UCL_ALLOC(sizeof(*nchain)); nchain->begin = ndata; nchain->len = nlen; nchain->special_handler = special_handler; /* Free order is reversed */ - LL_PREPEND (chunk->special_handlers, nchain); + LL_PREPEND(chunk->special_handlers, nchain); data = ndata; len = nlen; @@ -3031,15 +3051,15 @@ ucl_parser_add_chunk_full (struct ucl_parser *parser, const unsigned char *data, chunk->parse_type = parse_type; if (parser->cur_file) { - chunk->fname = strdup (parser->cur_file); + chunk->fname = strdup(parser->cur_file); } - LL_PREPEND (parser->chunks, chunk); - parser->recursion ++; + LL_PREPEND(parser->chunks, chunk); + parser->recursion++; if (parser->recursion > UCL_MAX_RECURSION) { - ucl_create_err (&parser->err, "maximum include nesting limit is reached: %d", - parser->recursion); + ucl_create_err(&parser->err, "maximum include nesting limit is reached: %d", + parser->recursion); return false; } @@ -3048,11 +3068,11 @@ ucl_parser_add_chunk_full (struct ucl_parser *parser, const unsigned char *data, switch (parse_type) { default: case UCL_PARSE_UCL: - return ucl_state_machine (parser); + return ucl_state_machine(parser); case UCL_PARSE_MSGPACK: - return ucl_parse_msgpack (parser); + return ucl_parse_msgpack(parser); case UCL_PARSE_CSEXP: - return ucl_parse_csexp (parser); + return ucl_parse_csexp(parser); } } else { @@ -3062,46 +3082,43 @@ ucl_parser_add_chunk_full (struct ucl_parser *parser, const unsigned char *data, * In case of empty object, create one to indicate that we've * read something */ - parser->top_obj = ucl_object_new_full (UCL_OBJECT, priority); + parser->top_obj = ucl_object_new_full(UCL_OBJECT, priority); } return true; } } - ucl_create_err (&parser->err, "a parser is in an invalid state"); + ucl_create_err(&parser->err, "a parser is in an invalid state"); return false; } -bool -ucl_parser_add_chunk_priority (struct ucl_parser *parser, - const unsigned char *data, size_t len, unsigned priority) +bool ucl_parser_add_chunk_priority(struct ucl_parser *parser, + const unsigned char *data, size_t len, unsigned priority) { /* We dereference parser, so this check is essential */ if (parser == NULL) { return false; } - return ucl_parser_add_chunk_full (parser, data, len, - priority, UCL_DUPLICATE_APPEND, UCL_PARSE_UCL); + return ucl_parser_add_chunk_full(parser, data, len, + priority, UCL_DUPLICATE_APPEND, UCL_PARSE_UCL); } -bool -ucl_parser_add_chunk (struct ucl_parser *parser, const unsigned char *data, - size_t len) +bool ucl_parser_add_chunk(struct ucl_parser *parser, const unsigned char *data, + size_t len) { if (parser == NULL) { return false; } - return ucl_parser_add_chunk_full (parser, data, len, - parser->default_priority, UCL_DUPLICATE_APPEND, UCL_PARSE_UCL); + return ucl_parser_add_chunk_full(parser, data, len, + parser->default_priority, UCL_DUPLICATE_APPEND, UCL_PARSE_UCL); } -bool -ucl_parser_insert_chunk (struct ucl_parser *parser, const unsigned char *data, - size_t len) +bool ucl_parser_insert_chunk(struct ucl_parser *parser, const unsigned char *data, + size_t len) { if (parser == NULL || parser->top_obj == NULL) { return false; @@ -3118,15 +3135,15 @@ ucl_parser_insert_chunk (struct ucl_parser *parser, const unsigned char *data, parser->stack->e.params.level = parser->stack->next->e.params.level; } - res = ucl_parser_add_chunk_full (parser, data, len, parser->chunks->priority, - parser->chunks->strategy, parser->chunks->parse_type); + res = ucl_parser_add_chunk_full(parser, data, len, parser->chunks->priority, + parser->chunks->strategy, parser->chunks->parse_type); /* Remove chunk from the stack */ chunk = parser->chunks; if (chunk != NULL) { parser->chunks = chunk->next; - ucl_chunk_free (chunk); - parser->recursion --; + ucl_chunk_free(chunk); + parser->recursion--; } parser->state = state; @@ -3134,47 +3151,44 @@ ucl_parser_insert_chunk (struct ucl_parser *parser, const unsigned char *data, return res; } -bool -ucl_parser_add_string_priority (struct ucl_parser *parser, const char *data, - size_t len, unsigned priority) +bool ucl_parser_add_string_priority(struct ucl_parser *parser, const char *data, + size_t len, unsigned priority) { if (data == NULL) { - ucl_create_err (&parser->err, "invalid string added"); + ucl_create_err(&parser->err, "invalid string added"); return false; } if (len == 0) { - len = strlen (data); + len = strlen(data); } - return ucl_parser_add_chunk_priority (parser, - (const unsigned char *)data, len, priority); + return ucl_parser_add_chunk_priority(parser, + (const unsigned char *) data, len, priority); } -bool -ucl_parser_add_string (struct ucl_parser *parser, const char *data, - size_t len) +bool ucl_parser_add_string(struct ucl_parser *parser, const char *data, + size_t len) { if (parser == NULL) { return false; } - return ucl_parser_add_string_priority (parser, - (const unsigned char *)data, len, parser->default_priority); + return ucl_parser_add_string_priority(parser, + (const unsigned char *) data, len, parser->default_priority); } -bool -ucl_set_include_path (struct ucl_parser *parser, ucl_object_t *paths) +bool ucl_set_include_path(struct ucl_parser *parser, ucl_object_t *paths) { - if (parser == NULL || paths == NULL) { + if (parser == NULL || paths == NULL || paths->type != UCL_ARRAY) { return false; } if (parser->includepaths == NULL) { - parser->includepaths = ucl_object_copy (paths); + parser->includepaths = ucl_object_copy(paths); } else { - ucl_object_unref (parser->includepaths); - parser->includepaths = ucl_object_copy (paths); + ucl_object_unref(parser->includepaths); + parser->includepaths = ucl_object_copy(paths); } if (parser->includepaths == NULL) { @@ -3184,17 +3198,17 @@ ucl_set_include_path (struct ucl_parser *parser, ucl_object_t *paths) return true; } -unsigned char ucl_parser_chunk_peek (struct ucl_parser *parser) +unsigned char ucl_parser_chunk_peek(struct ucl_parser *parser) { if (parser == NULL || parser->chunks == NULL || parser->chunks->pos == NULL || parser->chunks->end == NULL || parser->chunks->pos == parser->chunks->end) { return 0; } - return( *parser->chunks->pos ); + return (*parser->chunks->pos); } -bool ucl_parser_chunk_skip (struct ucl_parser *parser) +bool ucl_parser_chunk_skip(struct ucl_parser *parser) { if (parser == NULL || parser->chunks == NULL || parser->chunks->pos == NULL || parser->chunks->end == NULL || parser->chunks->pos == parser->chunks->end) { @@ -3202,13 +3216,13 @@ bool ucl_parser_chunk_skip (struct ucl_parser *parser) } const unsigned char *p = parser->chunks->pos; - ucl_chunk_skipc( parser->chunks, p ); - if( parser->chunks->pos != NULL ) return true; + ucl_chunk_skipc(parser->chunks, p); + if (parser->chunks->pos != NULL) return true; return false; } -ucl_object_t* -ucl_parser_get_current_stack_object (struct ucl_parser *parser, unsigned int depth) +ucl_object_t * +ucl_parser_get_current_stack_object(struct ucl_parser *parser, unsigned int depth) { ucl_object_t *obj; @@ -3217,21 +3231,17 @@ ucl_parser_get_current_stack_object (struct ucl_parser *parser, unsigned int dep } struct ucl_stack *stack = parser->stack; - if(stack == NULL || stack->obj == NULL || ucl_object_type (stack->obj) != UCL_OBJECT) - { + if (stack == NULL || stack->obj == NULL || ucl_object_type(stack->obj) != UCL_OBJECT) { return NULL; } - for( unsigned int i = 0; i < depth; ++i ) - { + for (unsigned int i = 0; i < depth; ++i) { stack = stack->next; - if(stack == NULL || stack->obj == NULL || ucl_object_type (stack->obj) != UCL_OBJECT) - { + if (stack == NULL || stack->obj == NULL || ucl_object_type(stack->obj) != UCL_OBJECT) { return NULL; } } - obj = ucl_object_ref (stack->obj); + obj = ucl_object_ref(stack->obj); return obj; } - diff --git a/src/ucl_schema.c b/src/ucl_schema.c index f4ec0ed3284a..02362d16b838 100644 --- a/src/ucl_schema.c +++ b/src/ucl_schema.c @@ -41,11 +41,11 @@ #endif #include -static bool ucl_schema_validate (const ucl_object_t *schema, - const ucl_object_t *obj, bool try_array, - struct ucl_schema_error *err, - const ucl_object_t *root, - ucl_object_t *ext_ref); +static bool ucl_schema_validate(const ucl_object_t *schema, + const ucl_object_t *obj, bool try_array, + struct ucl_schema_error *err, + const ucl_object_t *root, + ucl_object_t *ext_ref); /* * Create validation error @@ -53,25 +53,25 @@ static bool ucl_schema_validate (const ucl_object_t *schema, #ifdef __GNUC__ static inline void -ucl_schema_create_error (struct ucl_schema_error *err, - enum ucl_schema_error_code code, const ucl_object_t *obj, - const char *fmt, ...) -__attribute__ (( format( printf, 4, 5) )); +ucl_schema_create_error(struct ucl_schema_error *err, + enum ucl_schema_error_code code, const ucl_object_t *obj, + const char *fmt, ...) + __attribute__((format(printf, 4, 5))); #endif static inline void -ucl_schema_create_error (struct ucl_schema_error *err, - enum ucl_schema_error_code code, const ucl_object_t *obj, - const char *fmt, ...) +ucl_schema_create_error(struct ucl_schema_error *err, + enum ucl_schema_error_code code, const ucl_object_t *obj, + const char *fmt, ...) { va_list va; if (err != NULL) { err->code = code; err->obj = obj; - va_start (va, fmt); - vsnprintf (err->msg, sizeof (err->msg), fmt, va); - va_end (va); + va_start(va, fmt); + vsnprintf(err->msg, sizeof(err->msg), fmt, va); + va_end(va); } } @@ -79,7 +79,7 @@ ucl_schema_create_error (struct ucl_schema_error *err, * Check whether we have a pattern specified */ static const ucl_object_t * -ucl_schema_test_pattern (const ucl_object_t *obj, const char *pattern, bool recursive) +ucl_schema_test_pattern(const ucl_object_t *obj, const char *pattern, bool recursive) { const ucl_object_t *res = NULL; #ifdef HAVE_REGEX_H @@ -87,19 +87,20 @@ ucl_schema_test_pattern (const ucl_object_t *obj, const char *pattern, bool recu const ucl_object_t *elt; ucl_object_iter_t iter = NULL; - if (regcomp (®, pattern, REG_EXTENDED | REG_NOSUB) == 0) { + if (regcomp(®, pattern, REG_EXTENDED | REG_NOSUB) == 0) { if (recursive) { - while ((elt = ucl_object_iterate (obj, &iter, true)) != NULL) { - if (regexec (®, ucl_object_key (elt), 0, NULL, 0) == 0) { + while ((elt = ucl_object_iterate(obj, &iter, true)) != NULL) { + if (regexec(®, ucl_object_key(elt), 0, NULL, 0) == 0) { res = elt; break; } } - } else { - if (regexec (®, ucl_object_key (obj), 0, NULL, 0) == 0) + } + else { + if (regexec(®, ucl_object_key(obj), 0, NULL, 0) == 0) res = obj; } - regfree (®); + regfree(®); } #endif return res; @@ -109,33 +110,33 @@ ucl_schema_test_pattern (const ucl_object_t *obj, const char *pattern, bool recu * Check dependencies for an object */ static bool -ucl_schema_validate_dependencies (const ucl_object_t *deps, - const ucl_object_t *obj, struct ucl_schema_error *err, - const ucl_object_t *root, - ucl_object_t *ext_ref) +ucl_schema_validate_dependencies(const ucl_object_t *deps, + const ucl_object_t *obj, struct ucl_schema_error *err, + const ucl_object_t *root, + ucl_object_t *ext_ref) { const ucl_object_t *elt, *cur, *cur_dep; ucl_object_iter_t iter = NULL, piter; bool ret = true; - while (ret && (cur = ucl_object_iterate (deps, &iter, true)) != NULL) { - elt = ucl_object_lookup (obj, ucl_object_key (cur)); + while (ret && (cur = ucl_object_iterate(deps, &iter, true)) != NULL) { + elt = ucl_object_lookup(obj, ucl_object_key(cur)); if (elt != NULL) { /* Need to check dependencies */ if (cur->type == UCL_ARRAY) { piter = NULL; - while (ret && (cur_dep = ucl_object_iterate (cur, &piter, true)) != NULL) { - if (ucl_object_lookup (obj, ucl_object_tostring (cur_dep)) == NULL) { - ucl_schema_create_error (err, UCL_SCHEMA_MISSING_DEPENDENCY, elt, - "dependency %s is missing for key %s", - ucl_object_tostring (cur_dep), ucl_object_key (cur)); + while (ret && (cur_dep = ucl_object_iterate(cur, &piter, true)) != NULL) { + if (ucl_object_lookup(obj, ucl_object_tostring(cur_dep)) == NULL) { + ucl_schema_create_error(err, UCL_SCHEMA_MISSING_DEPENDENCY, elt, + "dependency %s is missing for key %s", + ucl_object_tostring(cur_dep), ucl_object_key(cur)); ret = false; break; } } } else if (cur->type == UCL_OBJECT) { - ret = ucl_schema_validate (cur, obj, true, err, root, ext_ref); + ret = ucl_schema_validate(cur, obj, true, err, root, ext_ref); } } } @@ -147,32 +148,32 @@ ucl_schema_validate_dependencies (const ucl_object_t *deps, * Validate object */ static bool -ucl_schema_validate_object (const ucl_object_t *schema, - const ucl_object_t *obj, struct ucl_schema_error *err, - const ucl_object_t *root, - ucl_object_t *ext_ref) +ucl_schema_validate_object(const ucl_object_t *schema, + const ucl_object_t *obj, struct ucl_schema_error *err, + const ucl_object_t *root, + ucl_object_t *ext_ref) { const ucl_object_t *elt, *prop, *found, *additional_schema = NULL, - *required = NULL, *pat, *pelt; + *required = NULL, *pat, *pelt; ucl_object_iter_t iter = NULL, piter = NULL; bool ret = true, allow_additional = true; int64_t minmax; - while (ret && (elt = ucl_object_iterate (schema, &iter, true)) != NULL) { + while (ret && (elt = ucl_object_iterate(schema, &iter, true)) != NULL) { if (elt->type == UCL_OBJECT && - strcmp (ucl_object_key (elt), "properties") == 0) { + strcmp(ucl_object_key(elt), "properties") == 0) { piter = NULL; - while (ret && (prop = ucl_object_iterate (elt, &piter, true)) != NULL) { - found = ucl_object_lookup (obj, ucl_object_key (prop)); + while (ret && (prop = ucl_object_iterate(elt, &piter, true)) != NULL) { + found = ucl_object_lookup(obj, ucl_object_key(prop)); if (found) { - ret = ucl_schema_validate (prop, found, true, err, root, - ext_ref); + ret = ucl_schema_validate(prop, found, true, err, root, + ext_ref); } } } - else if (strcmp (ucl_object_key (elt), "additionalProperties") == 0) { + else if (strcmp(ucl_object_key(elt), "additionalProperties") == 0) { if (elt->type == UCL_BOOLEAN) { - if (!ucl_object_toboolean (elt)) { + if (!ucl_object_toboolean(elt)) { /* Deny additional fields completely */ allow_additional = false; } @@ -182,62 +183,60 @@ ucl_schema_validate_object (const ucl_object_t *schema, additional_schema = elt; } else { - ucl_schema_create_error (err, UCL_SCHEMA_INVALID_SCHEMA, elt, - "additionalProperties attribute is invalid in schema"); + ucl_schema_create_error(err, UCL_SCHEMA_INVALID_SCHEMA, elt, + "additionalProperties attribute is invalid in schema"); ret = false; break; } } - else if (strcmp (ucl_object_key (elt), "required") == 0) { + else if (strcmp(ucl_object_key(elt), "required") == 0) { if (elt->type == UCL_ARRAY) { required = elt; } else { - ucl_schema_create_error (err, UCL_SCHEMA_INVALID_SCHEMA, elt, - "required attribute is invalid in schema"); + ucl_schema_create_error(err, UCL_SCHEMA_INVALID_SCHEMA, elt, + "required attribute is invalid in schema"); ret = false; break; } } - else if (strcmp (ucl_object_key (elt), "minProperties") == 0 - && ucl_object_toint_safe (elt, &minmax)) { + else if (strcmp(ucl_object_key(elt), "minProperties") == 0 && ucl_object_toint_safe(elt, &minmax)) { if (obj->len < minmax) { - ucl_schema_create_error (err, UCL_SCHEMA_CONSTRAINT, obj, - "object has not enough properties: %u, minimum is: %u", - obj->len, (unsigned)minmax); + ucl_schema_create_error(err, UCL_SCHEMA_CONSTRAINT, obj, + "object has not enough properties: %u, minimum is: %u", + obj->len, (unsigned) minmax); ret = false; break; } } - else if (strcmp (ucl_object_key (elt), "maxProperties") == 0 - && ucl_object_toint_safe (elt, &minmax)) { + else if (strcmp(ucl_object_key(elt), "maxProperties") == 0 && ucl_object_toint_safe(elt, &minmax)) { if (obj->len > minmax) { - ucl_schema_create_error (err, UCL_SCHEMA_CONSTRAINT, obj, - "object has too many properties: %u, maximum is: %u", - obj->len, (unsigned)minmax); + ucl_schema_create_error(err, UCL_SCHEMA_CONSTRAINT, obj, + "object has too many properties: %u, maximum is: %u", + obj->len, (unsigned) minmax); ret = false; break; } } - else if (strcmp (ucl_object_key (elt), "patternProperties") == 0) { + else if (strcmp(ucl_object_key(elt), "patternProperties") == 0) { const ucl_object_t *vobj; ucl_object_iter_t viter; piter = NULL; - while (ret && (prop = ucl_object_iterate (elt, &piter, true)) != NULL) { + while (ret && (prop = ucl_object_iterate(elt, &piter, true)) != NULL) { viter = NULL; - while (ret && (vobj = ucl_object_iterate (obj, &viter, true)) != NULL) { - found = ucl_schema_test_pattern (vobj, ucl_object_key (prop), false); + while (ret && (vobj = ucl_object_iterate(obj, &viter, true)) != NULL) { + found = ucl_schema_test_pattern(vobj, ucl_object_key(prop), false); if (found) { - ret = ucl_schema_validate (prop, found, true, err, root, - ext_ref); + ret = ucl_schema_validate(prop, found, true, err, root, + ext_ref); } } } } else if (elt->type == UCL_OBJECT && - strcmp (ucl_object_key (elt), "dependencies") == 0) { - ret = ucl_schema_validate_dependencies (elt, obj, err, root, - ext_ref); + strcmp(ucl_object_key(elt), "dependencies") == 0) { + ret = ucl_schema_validate_dependencies(elt, obj, err, root, + ext_ref); } } @@ -245,51 +244,51 @@ ucl_schema_validate_object (const ucl_object_t *schema, /* Additional properties */ if (!allow_additional || additional_schema != NULL) { /* Check if we have exactly the same properties in schema and object */ - iter = ucl_object_iterate_new (obj); - prop = ucl_object_lookup (schema, "properties"); - while ((elt = ucl_object_iterate_safe (iter, true)) != NULL) { - found = ucl_object_lookup (prop, ucl_object_key (elt)); + iter = ucl_object_iterate_new(obj); + prop = ucl_object_lookup(schema, "properties"); + while ((elt = ucl_object_iterate_safe(iter, true)) != NULL) { + found = ucl_object_lookup(prop, ucl_object_key(elt)); if (found == NULL) { /* Try patternProperties */ - pat = ucl_object_lookup (schema, "patternProperties"); - piter = ucl_object_iterate_new (pat); - while ((pelt = ucl_object_iterate_safe (piter, true)) != NULL) { - found = ucl_schema_test_pattern (obj, ucl_object_key (pelt), true); + pat = ucl_object_lookup(schema, "patternProperties"); + piter = ucl_object_iterate_new(pat); + while ((pelt = ucl_object_iterate_safe(piter, true)) != NULL) { + found = ucl_schema_test_pattern(obj, ucl_object_key(pelt), true); if (found != NULL) { break; } } - ucl_object_iterate_free (piter); + ucl_object_iterate_free(piter); piter = NULL; } if (found == NULL) { if (!allow_additional) { - ucl_schema_create_error (err, UCL_SCHEMA_CONSTRAINT, obj, - "object has non-allowed property %s", - ucl_object_key (elt)); + ucl_schema_create_error(err, UCL_SCHEMA_CONSTRAINT, obj, + "object has non-allowed property %s", + ucl_object_key(elt)); ret = false; break; } else if (additional_schema != NULL) { - if (!ucl_schema_validate (additional_schema, elt, - true, err, root, ext_ref)) { + if (!ucl_schema_validate(additional_schema, elt, + true, err, root, ext_ref)) { ret = false; break; } } } } - ucl_object_iterate_free (iter); + ucl_object_iterate_free(iter); iter = NULL; } /* Required properties */ if (required != NULL) { iter = NULL; - while ((elt = ucl_object_iterate (required, &iter, true)) != NULL) { - if (ucl_object_lookup (obj, ucl_object_tostring (elt)) == NULL) { - ucl_schema_create_error (err, UCL_SCHEMA_MISSING_PROPERTY, obj, - "object has missing property %s", - ucl_object_tostring (elt)); + while ((elt = ucl_object_iterate(required, &iter, true)) != NULL) { + if (ucl_object_lookup(obj, ucl_object_tostring(elt)) == NULL) { + ucl_schema_create_error(err, UCL_SCHEMA_MISSING_PROPERTY, obj, + "object has missing property %s", + ucl_object_tostring(elt)); ret = false; break; } @@ -302,8 +301,8 @@ ucl_schema_validate_object (const ucl_object_t *schema, } static bool -ucl_schema_validate_number (const ucl_object_t *schema, - const ucl_object_t *obj, struct ucl_schema_error *err) +ucl_schema_validate_number(const ucl_object_t *schema, + const ucl_object_t *obj, struct ucl_schema_error *err) { const ucl_object_t *elt, *test; ucl_object_iter_t iter = NULL; @@ -311,53 +310,53 @@ ucl_schema_validate_number (const ucl_object_t *schema, double constraint, val; const double alpha = 1e-16; - while (ret && (elt = ucl_object_iterate (schema, &iter, true)) != NULL) { + while (ret && (elt = ucl_object_iterate(schema, &iter, true)) != NULL) { if ((elt->type == UCL_FLOAT || elt->type == UCL_INT) && - strcmp (ucl_object_key (elt), "multipleOf") == 0) { - constraint = ucl_object_todouble (elt); + strcmp(ucl_object_key(elt), "multipleOf") == 0) { + constraint = ucl_object_todouble(elt); if (constraint <= 0) { - ucl_schema_create_error (err, UCL_SCHEMA_INVALID_SCHEMA, elt, - "multipleOf must be greater than zero"); + ucl_schema_create_error(err, UCL_SCHEMA_INVALID_SCHEMA, elt, + "multipleOf must be greater than zero"); ret = false; break; } - val = ucl_object_todouble (obj); - if (fabs (remainder (val, constraint)) > alpha) { - ucl_schema_create_error (err, UCL_SCHEMA_CONSTRAINT, obj, - "number %.4f is not multiple of %.4f, remainder is %.7f", - val, constraint, remainder (val, constraint)); + val = ucl_object_todouble(obj); + if (fabs(remainder(val, constraint)) > alpha) { + ucl_schema_create_error(err, UCL_SCHEMA_CONSTRAINT, obj, + "number %.4f is not multiple of %.4f, remainder is %.7f", + val, constraint, remainder(val, constraint)); ret = false; break; } } else if ((elt->type == UCL_FLOAT || elt->type == UCL_INT) && - strcmp (ucl_object_key (elt), "maximum") == 0) { - constraint = ucl_object_todouble (elt); - test = ucl_object_lookup (schema, "exclusiveMaximum"); + strcmp(ucl_object_key(elt), "maximum") == 0) { + constraint = ucl_object_todouble(elt); + test = ucl_object_lookup(schema, "exclusiveMaximum"); if (test && test->type == UCL_BOOLEAN) { - exclusive = ucl_object_toboolean (test); + exclusive = ucl_object_toboolean(test); } - val = ucl_object_todouble (obj); + val = ucl_object_todouble(obj); if (val > constraint || (exclusive && val >= constraint)) { - ucl_schema_create_error (err, UCL_SCHEMA_CONSTRAINT, obj, - "number is too big: %.3f, maximum is: %.3f", - val, constraint); + ucl_schema_create_error(err, UCL_SCHEMA_CONSTRAINT, obj, + "number is too big: %.3f, maximum is: %.3f", + val, constraint); ret = false; break; } } else if ((elt->type == UCL_FLOAT || elt->type == UCL_INT) && - strcmp (ucl_object_key (elt), "minimum") == 0) { - constraint = ucl_object_todouble (elt); - test = ucl_object_lookup (schema, "exclusiveMinimum"); + strcmp(ucl_object_key(elt), "minimum") == 0) { + constraint = ucl_object_todouble(elt); + test = ucl_object_lookup(schema, "exclusiveMinimum"); if (test && test->type == UCL_BOOLEAN) { - exclusive = ucl_object_toboolean (test); + exclusive = ucl_object_toboolean(test); } - val = ucl_object_todouble (obj); + val = ucl_object_todouble(obj); if (val < constraint || (exclusive && val <= constraint)) { - ucl_schema_create_error (err, UCL_SCHEMA_CONSTRAINT, obj, - "number is too small: %.3f, minimum is: %.3f", - val, constraint); + ucl_schema_create_error(err, UCL_SCHEMA_CONSTRAINT, obj, + "number is too small: %.3f, minimum is: %.3f", + val, constraint); ret = false; break; } @@ -368,8 +367,8 @@ ucl_schema_validate_number (const ucl_object_t *schema, } static bool -ucl_schema_validate_string (const ucl_object_t *schema, - const ucl_object_t *obj, struct ucl_schema_error *err) +ucl_schema_validate_string(const ucl_object_t *schema, + const ucl_object_t *obj, struct ucl_schema_error *err) { const ucl_object_t *elt; ucl_object_iter_t iter = NULL; @@ -379,46 +378,46 @@ ucl_schema_validate_string (const ucl_object_t *schema, regex_t re; #endif - while (ret && (elt = ucl_object_iterate (schema, &iter, true)) != NULL) { + while (ret && (elt = ucl_object_iterate(schema, &iter, true)) != NULL) { if (elt->type == UCL_INT && - strcmp (ucl_object_key (elt), "maxLength") == 0) { - constraint = ucl_object_toint (elt); + strcmp(ucl_object_key(elt), "maxLength") == 0) { + constraint = ucl_object_toint(elt); if (obj->len > constraint) { - ucl_schema_create_error (err, UCL_SCHEMA_CONSTRAINT, obj, - "string is too big: %u, maximum is: %" PRId64, - obj->len, constraint); + ucl_schema_create_error(err, UCL_SCHEMA_CONSTRAINT, obj, + "string is too big: %u, maximum is: %" PRId64, + obj->len, constraint); ret = false; break; } } else if (elt->type == UCL_INT && - strcmp (ucl_object_key (elt), "minLength") == 0) { - constraint = ucl_object_toint (elt); + strcmp(ucl_object_key(elt), "minLength") == 0) { + constraint = ucl_object_toint(elt); if (obj->len < constraint) { - ucl_schema_create_error (err, UCL_SCHEMA_CONSTRAINT, obj, - "string is too short: %u, minimum is: %" PRId64, - obj->len, constraint); + ucl_schema_create_error(err, UCL_SCHEMA_CONSTRAINT, obj, + "string is too short: %u, minimum is: %" PRId64, + obj->len, constraint); ret = false; break; } } #ifdef HAVE_REGEX_H else if (elt->type == UCL_STRING && - strcmp (ucl_object_key (elt), "pattern") == 0) { - if (regcomp (&re, ucl_object_tostring (elt), - REG_EXTENDED | REG_NOSUB) != 0) { - ucl_schema_create_error (err, UCL_SCHEMA_INVALID_SCHEMA, elt, - "cannot compile pattern %s", ucl_object_tostring (elt)); + strcmp(ucl_object_key(elt), "pattern") == 0) { + if (regcomp(&re, ucl_object_tostring(elt), + REG_EXTENDED | REG_NOSUB) != 0) { + ucl_schema_create_error(err, UCL_SCHEMA_INVALID_SCHEMA, elt, + "cannot compile pattern %s", ucl_object_tostring(elt)); ret = false; break; } - if (regexec (&re, ucl_object_tostring (obj), 0, NULL, 0) != 0) { - ucl_schema_create_error (err, UCL_SCHEMA_CONSTRAINT, obj, - "string doesn't match regexp %s", - ucl_object_tostring (elt)); + if (regexec(&re, ucl_object_tostring(obj), 0, NULL, 0) != 0) { + ucl_schema_create_error(err, UCL_SCHEMA_CONSTRAINT, obj, + "string doesn't match regexp %s", + ucl_object_tostring(elt)); ret = false; } - regfree (&re); + regfree(&re); } #endif } @@ -428,7 +427,8 @@ ucl_schema_validate_string (const ucl_object_t *schema, struct ucl_compare_node { const ucl_object_t *obj; - TREE_ENTRY(ucl_compare_node) link; + TREE_ENTRY(ucl_compare_node) + link; struct ucl_compare_node *next; }; @@ -437,72 +437,73 @@ typedef TREE_HEAD(_tree, ucl_compare_node) ucl_compare_tree_t; TREE_DEFINE(ucl_compare_node, link) static int -ucl_schema_elt_compare (struct ucl_compare_node *n1, struct ucl_compare_node *n2) +ucl_schema_elt_compare(struct ucl_compare_node *n1, struct ucl_compare_node *n2) { const ucl_object_t *o1 = n1->obj, *o2 = n2->obj; - return ucl_object_compare (o1, o2); + return ucl_object_compare(o1, o2); } static bool -ucl_schema_array_is_unique (const ucl_object_t *obj, struct ucl_schema_error *err) +ucl_schema_array_is_unique(const ucl_object_t *obj, struct ucl_schema_error *err) { - ucl_compare_tree_t tree = TREE_INITIALIZER (ucl_schema_elt_compare); + ucl_compare_tree_t tree = TREE_INITIALIZER(ucl_schema_elt_compare); ucl_object_iter_t iter = NULL; const ucl_object_t *elt; struct ucl_compare_node *node, test, *nodes = NULL, *tmp; bool ret = true; - while ((elt = ucl_object_iterate (obj, &iter, true)) != NULL) { + while ((elt = ucl_object_iterate(obj, &iter, true)) != NULL) { test.obj = elt; - node = TREE_FIND (&tree, ucl_compare_node, link, &test); + node = TREE_FIND(&tree, ucl_compare_node, link, &test); if (node != NULL) { - ucl_schema_create_error (err, UCL_SCHEMA_CONSTRAINT, elt, - "duplicate values detected while uniqueItems is true"); + ucl_schema_create_error(err, UCL_SCHEMA_CONSTRAINT, elt, + "duplicate values detected while uniqueItems is true"); ret = false; break; } - node = calloc (1, sizeof (*node)); + node = calloc(1, sizeof(*node)); if (node == NULL) { - ucl_schema_create_error (err, UCL_SCHEMA_UNKNOWN, elt, - "cannot allocate tree node"); + ucl_schema_create_error(err, UCL_SCHEMA_UNKNOWN, elt, + "cannot allocate tree node"); ret = false; break; } node->obj = elt; - TREE_INSERT (&tree, ucl_compare_node, link, node); - LL_PREPEND (nodes, node); + TREE_INSERT(&tree, ucl_compare_node, link, node); + LL_PREPEND(nodes, node); } - LL_FOREACH_SAFE (nodes, node, tmp) { - free (node); + LL_FOREACH_SAFE(nodes, node, tmp) + { + free(node); } return ret; } static bool -ucl_schema_validate_array (const ucl_object_t *schema, - const ucl_object_t *obj, struct ucl_schema_error *err, - const ucl_object_t *root, - ucl_object_t *ext_ref) +ucl_schema_validate_array(const ucl_object_t *schema, + const ucl_object_t *obj, struct ucl_schema_error *err, + const ucl_object_t *root, + ucl_object_t *ext_ref) { const ucl_object_t *elt, *it, *found, *additional_schema = NULL, - *first_unvalidated = NULL; + *first_unvalidated = NULL; ucl_object_iter_t iter = NULL, piter = NULL; bool ret = true, allow_additional = true, need_unique = false; int64_t minmax; unsigned int idx = 0; - while (ret && (elt = ucl_object_iterate (schema, &iter, true)) != NULL) { - if (strcmp (ucl_object_key (elt), "items") == 0) { + while (ret && (elt = ucl_object_iterate(schema, &iter, true)) != NULL) { + if (strcmp(ucl_object_key(elt), "items") == 0) { if (elt->type == UCL_ARRAY) { - found = ucl_array_head (obj); - while (ret && (it = ucl_object_iterate (elt, &piter, true)) != NULL) { + found = ucl_array_head(obj); + while (ret && (it = ucl_object_iterate(elt, &piter, true)) != NULL) { if (found) { - ret = ucl_schema_validate (it, found, false, err, - root, ext_ref); - found = ucl_array_find_index (obj, ++idx); + ret = ucl_schema_validate(it, found, false, err, + root, ext_ref); + found = ucl_array_find_index(obj, ++idx); } } if (found != NULL) { @@ -512,21 +513,21 @@ ucl_schema_validate_array (const ucl_object_t *schema, } else if (elt->type == UCL_OBJECT) { /* Validate all items using the specified schema */ - while (ret && (it = ucl_object_iterate (obj, &piter, true)) != NULL) { - ret = ucl_schema_validate (elt, it, false, err, root, - ext_ref); + while (ret && (it = ucl_object_iterate(obj, &piter, true)) != NULL) { + ret = ucl_schema_validate(elt, it, false, err, root, + ext_ref); } } else { - ucl_schema_create_error (err, UCL_SCHEMA_INVALID_SCHEMA, elt, - "items attribute is invalid in schema"); + ucl_schema_create_error(err, UCL_SCHEMA_INVALID_SCHEMA, elt, + "items attribute is invalid in schema"); ret = false; break; } } - else if (strcmp (ucl_object_key (elt), "additionalItems") == 0) { + else if (strcmp(ucl_object_key(elt), "additionalItems") == 0) { if (elt->type == UCL_BOOLEAN) { - if (!ucl_object_toboolean (elt)) { + if (!ucl_object_toboolean(elt)) { /* Deny additional fields completely */ allow_additional = false; } @@ -536,32 +537,30 @@ ucl_schema_validate_array (const ucl_object_t *schema, additional_schema = elt; } else { - ucl_schema_create_error (err, UCL_SCHEMA_INVALID_SCHEMA, elt, - "additionalItems attribute is invalid in schema"); + ucl_schema_create_error(err, UCL_SCHEMA_INVALID_SCHEMA, elt, + "additionalItems attribute is invalid in schema"); ret = false; break; } } else if (elt->type == UCL_BOOLEAN && - strcmp (ucl_object_key (elt), "uniqueItems") == 0) { - need_unique = ucl_object_toboolean (elt); + strcmp(ucl_object_key(elt), "uniqueItems") == 0) { + need_unique = ucl_object_toboolean(elt); } - else if (strcmp (ucl_object_key (elt), "minItems") == 0 - && ucl_object_toint_safe (elt, &minmax)) { + else if (strcmp(ucl_object_key(elt), "minItems") == 0 && ucl_object_toint_safe(elt, &minmax)) { if (obj->len < minmax) { - ucl_schema_create_error (err, UCL_SCHEMA_CONSTRAINT, obj, - "array has not enough items: %u, minimum is: %u", - obj->len, (unsigned)minmax); + ucl_schema_create_error(err, UCL_SCHEMA_CONSTRAINT, obj, + "array has not enough items: %u, minimum is: %u", + obj->len, (unsigned) minmax); ret = false; break; } } - else if (strcmp (ucl_object_key (elt), "maxItems") == 0 - && ucl_object_toint_safe (elt, &minmax)) { + else if (strcmp(ucl_object_key(elt), "maxItems") == 0 && ucl_object_toint_safe(elt, &minmax)) { if (obj->len > minmax) { - ucl_schema_create_error (err, UCL_SCHEMA_CONSTRAINT, obj, - "array has too many items: %u, maximum is: %u", - obj->len, (unsigned)minmax); + ucl_schema_create_error(err, UCL_SCHEMA_CONSTRAINT, obj, + "array has too many items: %u, maximum is: %u", + obj->len, (unsigned) minmax); ret = false; break; } @@ -573,26 +572,26 @@ ucl_schema_validate_array (const ucl_object_t *schema, if (!allow_additional || additional_schema != NULL) { if (first_unvalidated != NULL) { if (!allow_additional) { - ucl_schema_create_error (err, UCL_SCHEMA_CONSTRAINT, obj, - "array has undefined item"); + ucl_schema_create_error(err, UCL_SCHEMA_CONSTRAINT, obj, + "array has undefined item"); ret = false; } else if (additional_schema != NULL) { - elt = ucl_array_find_index (obj, idx); + elt = ucl_array_find_index(obj, idx); while (elt) { - if (!ucl_schema_validate (additional_schema, elt, false, - err, root, ext_ref)) { + if (!ucl_schema_validate(additional_schema, elt, false, + err, root, ext_ref)) { ret = false; break; } - elt = ucl_array_find_index (obj, idx ++); + elt = ucl_array_find_index(obj, idx++); } } } } /* Required properties */ if (ret && need_unique) { - ret = ucl_schema_array_is_unique (obj, err); + ret = ucl_schema_array_is_unique(obj, err); } } @@ -603,8 +602,8 @@ ucl_schema_validate_array (const ucl_object_t *schema, * Returns whether this object is allowed for this type */ static bool -ucl_schema_type_is_allowed (const ucl_object_t *type, const ucl_object_t *obj, - struct ucl_schema_error *err) +ucl_schema_type_is_allowed(const ucl_object_t *type, const ucl_object_t *obj, + struct ucl_schema_error *err) { ucl_object_iter_t iter = NULL; const ucl_object_t *elt; @@ -618,17 +617,17 @@ ucl_schema_type_is_allowed (const ucl_object_t *type, const ucl_object_t *obj, if (type->type == UCL_ARRAY) { /* One of allowed types */ - while ((elt = ucl_object_iterate (type, &iter, true)) != NULL) { - if (ucl_schema_type_is_allowed (elt, obj, err)) { + while ((elt = ucl_object_iterate(type, &iter, true)) != NULL) { + if (ucl_schema_type_is_allowed(elt, obj, err)) { return true; } } } else if (type->type == UCL_STRING) { - type_str = ucl_object_tostring (type); - if (!ucl_object_string_to_type (type_str, &t)) { - ucl_schema_create_error (err, UCL_SCHEMA_INVALID_SCHEMA, type, - "Type attribute is invalid in schema"); + type_str = ucl_object_tostring(type); + if (!ucl_object_string_to_type(type_str, &t)) { + ucl_schema_create_error(err, UCL_SCHEMA_INVALID_SCHEMA, type, + "Type attribute is invalid in schema"); return false; } if (obj->type != t) { @@ -640,10 +639,10 @@ ucl_schema_type_is_allowed (const ucl_object_t *type, const ucl_object_t *obj, return true; } else { - ucl_schema_create_error (err, UCL_SCHEMA_TYPE_MISMATCH, obj, - "Invalid type of %s, expected %s", - ucl_object_type_to_string (obj->type), - ucl_object_type_to_string (t)); + ucl_schema_create_error(err, UCL_SCHEMA_TYPE_MISMATCH, obj, + "Invalid type of %s, expected %s", + ucl_object_type_to_string(obj->type), + ucl_object_type_to_string(t)); } } else { @@ -659,23 +658,23 @@ ucl_schema_type_is_allowed (const ucl_object_t *type, const ucl_object_t *obj, * Check if object is equal to one of elements of enum */ static bool -ucl_schema_validate_enum (const ucl_object_t *en, const ucl_object_t *obj, - struct ucl_schema_error *err) +ucl_schema_validate_enum(const ucl_object_t *en, const ucl_object_t *obj, + struct ucl_schema_error *err) { ucl_object_iter_t iter = NULL; const ucl_object_t *elt; bool ret = false; - while ((elt = ucl_object_iterate (en, &iter, true)) != NULL) { - if (ucl_object_compare (elt, obj) == 0) { + while ((elt = ucl_object_iterate(en, &iter, true)) != NULL) { + if (ucl_object_compare(elt, obj) == 0) { ret = true; break; } } if (!ret) { - ucl_schema_create_error (err, UCL_SCHEMA_CONSTRAINT, obj, - "object is not one of enumerated patterns"); + ucl_schema_create_error(err, UCL_SCHEMA_CONSTRAINT, obj, + "object is not one of enumerated patterns"); } return ret; @@ -686,9 +685,9 @@ ucl_schema_validate_enum (const ucl_object_t *en, const ucl_object_t *obj, * Check a single ref component */ static const ucl_object_t * -ucl_schema_resolve_ref_component (const ucl_object_t *cur, - const char *refc, int len, - struct ucl_schema_error *err) +ucl_schema_resolve_ref_component(const ucl_object_t *cur, + const char *refc, int len, + struct ucl_schema_error *err) { const ucl_object_t *res = NULL; char *err_str; @@ -696,22 +695,22 @@ ucl_schema_resolve_ref_component (const ucl_object_t *cur, if (cur->type == UCL_OBJECT) { /* Find a key inside an object */ - res = ucl_object_lookup_len (cur, refc, len); + res = ucl_object_lookup_len(cur, refc, len); if (res == NULL) { - ucl_schema_create_error (err, UCL_SCHEMA_INVALID_SCHEMA, cur, - "reference %s is invalid, missing path component", refc); + ucl_schema_create_error(err, UCL_SCHEMA_INVALID_SCHEMA, cur, + "reference %s is invalid, missing path component", refc); return NULL; } } else if (cur->type == UCL_ARRAY) { /* We must figure out a number inside array */ - num = strtoul (refc, &err_str, 10); + num = strtoul(refc, &err_str, 10); if (err_str != NULL && *err_str != '/' && *err_str != '\0') { - ucl_schema_create_error (err, UCL_SCHEMA_INVALID_SCHEMA, cur, - "reference %s is invalid, invalid item number", refc); + ucl_schema_create_error(err, UCL_SCHEMA_INVALID_SCHEMA, cur, + "reference %s is invalid, invalid item number", refc); return NULL; } - res = ucl_array_head (cur); + res = ucl_array_head(cur); i = 0; while (res != NULL) { if (i == num) { @@ -720,16 +719,16 @@ ucl_schema_resolve_ref_component (const ucl_object_t *cur, res = res->next; } if (res == NULL) { - ucl_schema_create_error (err, UCL_SCHEMA_INVALID_SCHEMA, cur, - "reference %s is invalid, item number %d does not exist", - refc, num); + ucl_schema_create_error(err, UCL_SCHEMA_INVALID_SCHEMA, cur, + "reference %s is invalid, item number %d does not exist", + refc, num); return NULL; } } else { - ucl_schema_create_error (err, UCL_SCHEMA_INVALID_SCHEMA, res, - "reference %s is invalid, contains primitive object in the path", - refc); + ucl_schema_create_error(err, UCL_SCHEMA_INVALID_SCHEMA, res, + "reference %s is invalid, contains primitive object in the path", + refc); return NULL; } @@ -739,9 +738,9 @@ ucl_schema_resolve_ref_component (const ucl_object_t *cur, * Find reference schema */ static const ucl_object_t * -ucl_schema_resolve_ref (const ucl_object_t *root, const char *ref, - struct ucl_schema_error *err, ucl_object_t *ext_ref, - ucl_object_t const ** nroot) +ucl_schema_resolve_ref(const ucl_object_t *root, const char *ref, + struct ucl_schema_error *err, ucl_object_t *ext_ref, + ucl_object_t const **nroot) { UT_string *url_err = NULL; struct ucl_parser *parser; @@ -753,18 +752,18 @@ ucl_schema_resolve_ref (const ucl_object_t *root, const char *ref, size_t url_buflen; if (ref[0] != '#') { - hash_ptr = strrchr (ref, '#'); + hash_ptr = strrchr(ref, '#'); if (hash_ptr) { - url_copy = malloc (hash_ptr - ref + 1); + url_copy = malloc(hash_ptr - ref + 1); if (url_copy == NULL) { - ucl_schema_create_error (err, UCL_SCHEMA_INTERNAL_ERROR, root, - "cannot allocate memory"); + ucl_schema_create_error(err, UCL_SCHEMA_INTERNAL_ERROR, root, + "cannot allocate memory"); return NULL; } - ucl_strlcpy (url_copy, ref, hash_ptr - ref + 1); + ucl_strlcpy(url_copy, ref, hash_ptr - ref + 1); p = url_copy; } else { @@ -772,59 +771,59 @@ ucl_schema_resolve_ref (const ucl_object_t *root, const char *ref, p = ref; } - ext_obj = ucl_object_lookup (ext_ref, p); + ext_obj = ucl_object_lookup(ext_ref, p); if (ext_obj == NULL) { - if (ucl_strnstr (p, "://", strlen (p)) != NULL) { - if (!ucl_fetch_url (p, &url_buf, &url_buflen, &url_err, true)) { - - ucl_schema_create_error (err, - UCL_SCHEMA_INVALID_SCHEMA, - root, - "cannot fetch reference %s: %s", - p, - url_err != NULL ? utstring_body (url_err) - : "unknown"); - free (url_copy); + if (ucl_strnstr(p, "://", strlen(p)) != NULL) { + if (!ucl_fetch_url(p, &url_buf, &url_buflen, &url_err, true)) { + + ucl_schema_create_error(err, + UCL_SCHEMA_INVALID_SCHEMA, + root, + "cannot fetch reference %s: %s", + p, + url_err != NULL ? utstring_body(url_err) + : "unknown"); + free(url_copy); return NULL; } } else { - if (!ucl_fetch_file (p, &url_buf, &url_buflen, &url_err, - true)) { - ucl_schema_create_error (err, - UCL_SCHEMA_INVALID_SCHEMA, - root, - "cannot fetch reference %s: %s", - p, - url_err != NULL ? utstring_body (url_err) - : "unknown"); - free (url_copy); + if (!ucl_fetch_file(p, &url_buf, &url_buflen, &url_err, + true)) { + ucl_schema_create_error(err, + UCL_SCHEMA_INVALID_SCHEMA, + root, + "cannot fetch reference %s: %s", + p, + url_err != NULL ? utstring_body(url_err) + : "unknown"); + free(url_copy); return NULL; } } - parser = ucl_parser_new (0); + parser = ucl_parser_new(0); - if (!ucl_parser_add_chunk (parser, url_buf, url_buflen)) { - ucl_schema_create_error (err, UCL_SCHEMA_INVALID_SCHEMA, root, - "cannot fetch reference %s: %s", p, - ucl_parser_get_error (parser)); - ucl_parser_free (parser); - free (url_copy); + if (!ucl_parser_add_chunk(parser, url_buf, url_buflen)) { + ucl_schema_create_error(err, UCL_SCHEMA_INVALID_SCHEMA, root, + "cannot fetch reference %s: %s", p, + ucl_parser_get_error(parser)); + ucl_parser_free(parser); + free(url_copy); return NULL; } - url_obj = ucl_parser_get_object (parser); + url_obj = ucl_parser_get_object(parser); ext_obj = url_obj; - ucl_object_insert_key (ext_ref, url_obj, p, 0, true); - free (url_buf); + ucl_object_insert_key(ext_ref, url_obj, p, 0, true); + free(url_buf); } - free (url_copy); + free(url_copy); if (hash_ptr) { p = hash_ptr + 1; @@ -852,28 +851,28 @@ ucl_schema_resolve_ref (const ucl_object_t *root, const char *ref, while (*p != '\0') { if (*p == '/') { if (p - c == 0) { - ucl_schema_create_error (err, UCL_SCHEMA_INVALID_SCHEMA, res, - "reference %s is invalid, empty path component", ref); + ucl_schema_create_error(err, UCL_SCHEMA_INVALID_SCHEMA, res, + "reference %s is invalid, empty path component", ref); return NULL; } /* Now we have some url part, so we need to figure out where we are */ - res = ucl_schema_resolve_ref_component (res, c, p - c, err); + res = ucl_schema_resolve_ref_component(res, c, p - c, err); if (res == NULL) { return NULL; } c = p + 1; } - p ++; + p++; } if (p - c != 0) { - res = ucl_schema_resolve_ref_component (res, c, p - c, err); + res = ucl_schema_resolve_ref_component(res, c, p - c, err); } if (res == NULL || res->type != UCL_OBJECT) { - ucl_schema_create_error (err, UCL_SCHEMA_INVALID_SCHEMA, res, - "reference %s is invalid, cannot find specified object", - ref); + ucl_schema_create_error(err, UCL_SCHEMA_INVALID_SCHEMA, res, + "reference %s is invalid, cannot find specified object", + ref); return NULL; } @@ -881,44 +880,44 @@ ucl_schema_resolve_ref (const ucl_object_t *root, const char *ref, } static bool -ucl_schema_validate_values (const ucl_object_t *schema, const ucl_object_t *obj, - struct ucl_schema_error *err) +ucl_schema_validate_values(const ucl_object_t *schema, const ucl_object_t *obj, + struct ucl_schema_error *err) { const ucl_object_t *elt, *cur; int64_t constraint, i; - elt = ucl_object_lookup (schema, "maxValues"); + elt = ucl_object_lookup(schema, "maxValues"); if (elt != NULL && elt->type == UCL_INT) { - constraint = ucl_object_toint (elt); + constraint = ucl_object_toint(elt); cur = obj; i = 0; while (cur) { if (i > constraint) { - ucl_schema_create_error (err, UCL_SCHEMA_CONSTRAINT, obj, - "object has more values than defined: %ld", - (long int)constraint); + ucl_schema_create_error(err, UCL_SCHEMA_CONSTRAINT, obj, + "object has more values than defined: %ld", + (long int) constraint); return false; } - i ++; + i++; cur = cur->next; } } - elt = ucl_object_lookup (schema, "minValues"); + elt = ucl_object_lookup(schema, "minValues"); if (elt != NULL && elt->type == UCL_INT) { - constraint = ucl_object_toint (elt); + constraint = ucl_object_toint(elt); cur = obj; i = 0; while (cur) { if (i >= constraint) { break; } - i ++; + i++; cur = cur->next; } if (i < constraint) { - ucl_schema_create_error (err, UCL_SCHEMA_CONSTRAINT, obj, - "object has less values than defined: %ld", - (long int)constraint); + ucl_schema_create_error(err, UCL_SCHEMA_CONSTRAINT, obj, + "object has less values than defined: %ld", + (long int) constraint); return false; } } @@ -927,20 +926,20 @@ ucl_schema_validate_values (const ucl_object_t *schema, const ucl_object_t *obj, } static bool -ucl_schema_validate (const ucl_object_t *schema, - const ucl_object_t *obj, bool try_array, - struct ucl_schema_error *err, - const ucl_object_t *root, - ucl_object_t *external_refs) +ucl_schema_validate(const ucl_object_t *schema, + const ucl_object_t *obj, bool try_array, + struct ucl_schema_error *err, + const ucl_object_t *root, + ucl_object_t *external_refs) { const ucl_object_t *elt, *cur, *ref_root; ucl_object_iter_t iter = NULL; bool ret; if (schema->type != UCL_OBJECT) { - ucl_schema_create_error (err, UCL_SCHEMA_INVALID_SCHEMA, schema, - "schema is %s instead of object", - ucl_object_type_to_string (schema->type)); + ucl_schema_create_error(err, UCL_SCHEMA_INVALID_SCHEMA, schema, + "schema is %s instead of object", + ucl_object_type_to_string(schema->type)); return false; } @@ -948,40 +947,41 @@ ucl_schema_validate (const ucl_object_t *schema, /* * Special case for multiple values */ - if (!ucl_schema_validate_values (schema, obj, err)) { + if (!ucl_schema_validate_values(schema, obj, err)) { return false; } - LL_FOREACH (obj, cur) { - if (!ucl_schema_validate (schema, cur, false, err, root, external_refs)) { + LL_FOREACH(obj, cur) + { + if (!ucl_schema_validate(schema, cur, false, err, root, external_refs)) { return false; } } return true; } - elt = ucl_object_lookup (schema, "enum"); + elt = ucl_object_lookup(schema, "enum"); if (elt != NULL && elt->type == UCL_ARRAY) { - if (!ucl_schema_validate_enum (elt, obj, err)) { + if (!ucl_schema_validate_enum(elt, obj, err)) { return false; } } - elt = ucl_object_lookup (schema, "allOf"); + elt = ucl_object_lookup(schema, "allOf"); if (elt != NULL && elt->type == UCL_ARRAY) { iter = NULL; - while ((cur = ucl_object_iterate (elt, &iter, true)) != NULL) { - ret = ucl_schema_validate (cur, obj, true, err, root, external_refs); + while ((cur = ucl_object_iterate(elt, &iter, true)) != NULL) { + ret = ucl_schema_validate(cur, obj, true, err, root, external_refs); if (!ret) { return false; } } } - elt = ucl_object_lookup (schema, "anyOf"); + elt = ucl_object_lookup(schema, "anyOf"); if (elt != NULL && elt->type == UCL_ARRAY) { iter = NULL; - while ((cur = ucl_object_iterate (elt, &iter, true)) != NULL) { - ret = ucl_schema_validate (cur, obj, true, err, root, external_refs); + while ((cur = ucl_object_iterate(elt, &iter, true)) != NULL) { + ret = ucl_schema_validate(cur, obj, true, err, root, external_refs); if (ret) { break; } @@ -995,15 +995,15 @@ ucl_schema_validate (const ucl_object_t *schema, } } - elt = ucl_object_lookup (schema, "oneOf"); + elt = ucl_object_lookup(schema, "oneOf"); if (elt != NULL && elt->type == UCL_ARRAY) { iter = NULL; ret = false; - while ((cur = ucl_object_iterate (elt, &iter, true)) != NULL) { + while ((cur = ucl_object_iterate(elt, &iter, true)) != NULL) { if (!ret) { - ret = ucl_schema_validate (cur, obj, true, err, root, external_refs); + ret = ucl_schema_validate(cur, obj, true, err, root, external_refs); } - else if (ucl_schema_validate (cur, obj, true, err, root, external_refs)) { + else if (ucl_schema_validate(cur, obj, true, err, root, external_refs)) { ret = false; break; } @@ -1013,9 +1013,9 @@ ucl_schema_validate (const ucl_object_t *schema, } } - elt = ucl_object_lookup (schema, "not"); + elt = ucl_object_lookup(schema, "not"); if (elt != NULL && elt->type == UCL_OBJECT) { - if (ucl_schema_validate (elt, obj, true, err, root, external_refs)) { + if (ucl_schema_validate(elt, obj, true, err, root, external_refs)) { return false; } else { @@ -1024,39 +1024,39 @@ ucl_schema_validate (const ucl_object_t *schema, } } - elt = ucl_object_lookup (schema, "$ref"); + elt = ucl_object_lookup(schema, "$ref"); if (elt != NULL) { ref_root = root; - cur = ucl_schema_resolve_ref (root, ucl_object_tostring (elt), - err, external_refs, &ref_root); + cur = ucl_schema_resolve_ref(root, ucl_object_tostring(elt), + err, external_refs, &ref_root); if (cur == NULL) { return false; } - if (!ucl_schema_validate (cur, obj, try_array, err, ref_root, - external_refs)) { + if (!ucl_schema_validate(cur, obj, try_array, err, ref_root, + external_refs)) { return false; } } - elt = ucl_object_lookup (schema, "type"); - if (!ucl_schema_type_is_allowed (elt, obj, err)) { + elt = ucl_object_lookup(schema, "type"); + if (!ucl_schema_type_is_allowed(elt, obj, err)) { return false; } switch (obj->type) { case UCL_OBJECT: - return ucl_schema_validate_object (schema, obj, err, root, external_refs); + return ucl_schema_validate_object(schema, obj, err, root, external_refs); break; case UCL_ARRAY: - return ucl_schema_validate_array (schema, obj, err, root, external_refs); + return ucl_schema_validate_array(schema, obj, err, root, external_refs); break; case UCL_INT: case UCL_FLOAT: - return ucl_schema_validate_number (schema, obj, err); + return ucl_schema_validate_number(schema, obj, err); break; case UCL_STRING: - return ucl_schema_validate_string (schema, obj, err); + return ucl_schema_validate_string(schema, obj, err); break; default: break; @@ -1065,40 +1065,37 @@ ucl_schema_validate (const ucl_object_t *schema, return true; } -bool -ucl_object_validate (const ucl_object_t *schema, - const ucl_object_t *obj, struct ucl_schema_error *err) +bool ucl_object_validate(const ucl_object_t *schema, + const ucl_object_t *obj, struct ucl_schema_error *err) { - return ucl_object_validate_root_ext (schema, obj, schema, NULL, err); + return ucl_object_validate_root_ext(schema, obj, schema, NULL, err); } -bool -ucl_object_validate_root (const ucl_object_t *schema, - const ucl_object_t *obj, - const ucl_object_t *root, - struct ucl_schema_error *err) +bool ucl_object_validate_root(const ucl_object_t *schema, + const ucl_object_t *obj, + const ucl_object_t *root, + struct ucl_schema_error *err) { - return ucl_object_validate_root_ext (schema, obj, root, NULL, err); + return ucl_object_validate_root_ext(schema, obj, root, NULL, err); } -bool -ucl_object_validate_root_ext (const ucl_object_t *schema, - const ucl_object_t *obj, - const ucl_object_t *root, - ucl_object_t *ext_refs, - struct ucl_schema_error *err) +bool ucl_object_validate_root_ext(const ucl_object_t *schema, + const ucl_object_t *obj, + const ucl_object_t *root, + ucl_object_t *ext_refs, + struct ucl_schema_error *err) { bool ret, need_unref = false; if (ext_refs == NULL) { - ext_refs = ucl_object_typed_new (UCL_OBJECT); + ext_refs = ucl_object_typed_new(UCL_OBJECT); need_unref = true; } - ret = ucl_schema_validate (schema, obj, true, err, root, ext_refs); + ret = ucl_schema_validate(schema, obj, true, err, root, ext_refs); if (need_unref) { - ucl_object_unref (ext_refs); + ucl_object_unref(ext_refs); } return ret; diff --git a/src/ucl_sexp.c b/src/ucl_sexp.c index 1ad93d23458e..e174cf45ca01 100644 --- a/src/ucl_sexp.c +++ b/src/ucl_sexp.c @@ -31,33 +31,33 @@ #include "ucl_internal.h" #include "utlist.h" -#define NEXT_STATE do { \ -if (p >= end) { \ - if (state != read_ebrace) { \ - ucl_create_err (&parser->err,\ - "extra data");\ - state = parse_err; \ - } \ -} \ -else { \ -switch (*p) { \ - case '(': \ - state = read_obrace; \ - break; \ - case ')': \ - state = read_ebrace; \ - break; \ - default: \ - len = 0; \ - mult = 1; \ - state = read_length; \ - break; \ - } \ -} \ -} while(0) - -bool -ucl_parse_csexp (struct ucl_parser *parser) +#define NEXT_STATE \ + do { \ + if (p >= end) { \ + if (state != read_ebrace) { \ + ucl_create_err(&parser->err, \ + "extra data"); \ + state = parse_err; \ + } \ + } \ + else { \ + switch (*p) { \ + case '(': \ + state = read_obrace; \ + break; \ + case ')': \ + state = read_ebrace; \ + break; \ + default: \ + len = 0; \ + mult = 1; \ + state = read_length; \ + break; \ + } \ + } \ + } while (0) + +bool ucl_parse_csexp(struct ucl_parser *parser) { const unsigned char *p, *end; ucl_object_t *obj; @@ -72,10 +72,10 @@ ucl_parse_csexp (struct ucl_parser *parser) parse_err } state = start_parse; - assert (parser != NULL); - assert (parser->chunks != NULL); - assert (parser->chunks->begin != NULL); - assert (parser->chunks->remain != 0); + assert(parser != NULL); + assert(parser->chunks != NULL); + assert(parser->chunks->begin != NULL); + assert(parser->chunks->remain != 0); p = parser->chunks->begin; end = p + parser->chunks->remain; @@ -88,27 +88,28 @@ ucl_parse_csexp (struct ucl_parser *parser) state = read_obrace; } else { - ucl_create_err (&parser->err, "bad starting character for " - "sexp block: %x", (int)*p); + ucl_create_err(&parser->err, "bad starting character for " + "sexp block: %x", + (int) *p); state = parse_err; } break; case read_obrace: - st = calloc (1, sizeof (*st)); + st = calloc(1, sizeof(*st)); if (st == NULL) { - ucl_create_err (&parser->err, "no memory"); + ucl_create_err(&parser->err, "no memory"); state = parse_err; continue; } - st->obj = ucl_object_typed_new (UCL_ARRAY); + st->obj = ucl_object_typed_new(UCL_ARRAY); if (st->obj == NULL) { - ucl_create_err (&parser->err, "no memory"); + ucl_create_err(&parser->err, "no memory"); state = parse_err; - free (st); + free(st); continue; } @@ -122,10 +123,10 @@ ucl_parse_csexp (struct ucl_parser *parser) } else { /* Prepend new element to the stack */ - LL_PREPEND (parser->stack, st); + LL_PREPEND(parser->stack, st); } - p ++; + p++; NEXT_STATE; break; @@ -133,7 +134,7 @@ ucl_parse_csexp (struct ucl_parser *parser) case read_length: if (*p == ':') { if (len == 0) { - ucl_create_err (&parser->err, "zero length element"); + ucl_create_err(&parser->err, "zero length element"); state = parse_err; continue; } @@ -145,40 +146,41 @@ ucl_parse_csexp (struct ucl_parser *parser) mult *= 10; if (len > UINT32_MAX) { - ucl_create_err (&parser->err, "too big length of an " - "element"); + ucl_create_err(&parser->err, "too big length of an " + "element"); state = parse_err; continue; } } else { - ucl_create_err (&parser->err, "bad length character: %x", - (int)*p); + ucl_create_err(&parser->err, "bad length character: %x", + (int) *p); state = parse_err; continue; } - p ++; + p++; break; case read_value: - if ((uint64_t)(end - p) > len || len == 0) { - ucl_create_err (&parser->err, "invalid length: %llu, %ld " - "remain", (long long unsigned)len, (long)(end - p)); + if ((uint64_t) (end - p) > len || len == 0) { + ucl_create_err(&parser->err, "invalid length: %llu, %ld " + "remain", + (long long unsigned) len, (long) (end - p)); state = parse_err; continue; } - obj = ucl_object_typed_new (UCL_STRING); + obj = ucl_object_typed_new(UCL_STRING); - obj->value.sv = (const char*)p; + obj->value.sv = (const char *) p; obj->len = len; obj->flags |= UCL_OBJECT_BINARY; if (!(parser->flags & UCL_PARSER_ZEROCOPY)) { - ucl_copy_value_trash (obj); + ucl_copy_value_trash(obj); } - ucl_array_append (parser->stack->obj, obj); + ucl_array_append(parser->stack->obj, obj); p += len; NEXT_STATE; break; @@ -186,8 +188,9 @@ ucl_parse_csexp (struct ucl_parser *parser) case read_ebrace: if (parser->stack == NULL) { /* We have an extra end brace */ - ucl_create_err (&parser->err, "invalid length: %llu, %ld " - "remain", (long long unsigned)len, (long)(end - p)); + ucl_create_err(&parser->err, "invalid length: %llu, %ld " + "remain", + (long long unsigned) len, (long) (end - p)); state = parse_err; continue; } @@ -196,16 +199,16 @@ ucl_parse_csexp (struct ucl_parser *parser) parser->stack = st->next; if (parser->stack->obj->type == UCL_ARRAY) { - ucl_array_append (parser->stack->obj, st->obj); + ucl_array_append(parser->stack->obj, st->obj); } else { - ucl_create_err (&parser->err, "bad container object, array " - "expected"); + ucl_create_err(&parser->err, "bad container object, array " + "expected"); state = parse_err; continue; } - free (st); + free(st); st = NULL; p++; NEXT_STATE; @@ -218,7 +221,7 @@ ucl_parse_csexp (struct ucl_parser *parser) } if (state != read_ebrace) { - ucl_create_err (&parser->err, "invalid finishing state: %d", state); + ucl_create_err(&parser->err, "invalid finishing state: %d", state); return false; } diff --git a/src/ucl_util.c b/src/ucl_util.c index 8f97c20db503..3566632275a5 100644 --- a/src/ucl_util.c +++ b/src/ucl_util.c @@ -41,14 +41,14 @@ #ifdef HAVE_LIBGEN_H #ifndef _WIN32 -# include /* For dirname */ +#include /* For dirname */ #endif #endif typedef kvec_t(ucl_object_t *) ucl_array_t; #define UCL_ARRAY_GET(ar, obj) ucl_array_t *ar = \ - (ucl_array_t *)((obj) != NULL ? (obj)->value.av : NULL) + (ucl_array_t *) ((obj) != NULL ? (obj)->value.av : NULL) #ifdef HAVE_OPENSSL #include @@ -73,22 +73,22 @@ typedef kvec_t(ucl_object_t *) ucl_array_t; #include #ifndef PROT_READ -#define PROT_READ 1 +#define PROT_READ 1 #endif #ifndef PROT_WRITE -#define PROT_WRITE 2 +#define PROT_WRITE 2 #endif #ifndef PROT_READWRITE -#define PROT_READWRITE 3 +#define PROT_READWRITE 3 #endif #ifndef MAP_SHARED -#define MAP_SHARED 1 +#define MAP_SHARED 1 #endif #ifndef MAP_PRIVATE -#define MAP_PRIVATE 2 +#define MAP_PRIVATE 2 #endif #ifndef MAP_FAILED -#define MAP_FAILED ((void *) -1) +#define MAP_FAILED ((void *) -1) #endif #define getcwd _getcwd @@ -102,30 +102,27 @@ static void *ucl_mmap(char *addr, size_t length, int prot, int access, int fd, o switch (prot) { default: - case PROT_READ: - { - handle = CreateFileMapping((HANDLE) _get_osfhandle(fd), 0, PAGE_READONLY, 0, length, 0); - if (!handle) break; - map = (void *) MapViewOfFile(handle, FILE_MAP_READ, 0, 0, length); - CloseHandle(handle); - break; - } - case PROT_WRITE: - { - handle = CreateFileMapping((HANDLE) _get_osfhandle(fd), 0, PAGE_READWRITE, 0, length, 0); - if (!handle) break; - map = (void *) MapViewOfFile(handle, FILE_MAP_WRITE, 0, 0, length); - CloseHandle(handle); - break; - } - case PROT_READWRITE: - { - handle = CreateFileMapping((HANDLE) _get_osfhandle(fd), 0, PAGE_READWRITE, 0, length, 0); - if (!handle) break; - map = (void *) MapViewOfFile(handle, FILE_MAP_ALL_ACCESS, 0, 0, length); - CloseHandle(handle); - break; - } + case PROT_READ: { + handle = CreateFileMapping((HANDLE) _get_osfhandle(fd), 0, PAGE_READONLY, 0, length, 0); + if (!handle) break; + map = (void *) MapViewOfFile(handle, FILE_MAP_READ, 0, 0, length); + CloseHandle(handle); + break; + } + case PROT_WRITE: { + handle = CreateFileMapping((HANDLE) _get_osfhandle(fd), 0, PAGE_READWRITE, 0, length, 0); + if (!handle) break; + map = (void *) MapViewOfFile(handle, FILE_MAP_WRITE, 0, 0, length); + CloseHandle(handle); + break; + } + case PROT_READWRITE: { + handle = CreateFileMapping((HANDLE) _get_osfhandle(fd), 0, PAGE_READWRITE, 0, length, 0); + if (!handle) break; + map = (void *) MapViewOfFile(handle, FILE_MAP_ALL_ACCESS, 0, 0, length); + CloseHandle(handle); + break; + } } if (map == (void *) NULL) { return (void *) MAP_FAILED; @@ -133,21 +130,21 @@ static void *ucl_mmap(char *addr, size_t length, int prot, int access, int fd, o return (void *) ((char *) map + offset); } -static int ucl_munmap(void *map,size_t length) +static int ucl_munmap(void *map, size_t length) { if (!UnmapViewOfFile(map)) { - return(-1); + return (-1); } - return(0); + return (0); } -static char* ucl_realpath(const char *path, char *resolved_path) +static char *ucl_realpath(const char *path, char *resolved_path) { char *p; char tmp[MAX_PATH + 1]; - strncpy(tmp, path, sizeof(tmp)-1); + strncpy(tmp, path, sizeof(tmp) - 1); p = tmp; - while(*p) { + while (*p) { if (*p == '/') *p = '\\'; p++; } @@ -163,7 +160,7 @@ char *dirname(char *path) char fname[_MAX_FNAME]; char ext[_MAX_EXT]; - _splitpath (path, drive, dir, fname, ext); + _splitpath(path, drive, dir, fname, ext); _makepath(path_buffer, drive, dir, NULL, NULL); return path_buffer; @@ -188,31 +185,31 @@ char *basename(char *path) #define ucl_realpath realpath #endif -typedef void (*ucl_object_dtor) (ucl_object_t *obj); -static void ucl_object_free_internal (ucl_object_t *obj, bool allow_rec, - ucl_object_dtor dtor); -static void ucl_object_dtor_unref (ucl_object_t *obj); +typedef void (*ucl_object_dtor)(ucl_object_t *obj); +static void ucl_object_free_internal(ucl_object_t *obj, bool allow_rec, + ucl_object_dtor dtor); +static void ucl_object_dtor_unref(ucl_object_t *obj); static void -ucl_object_dtor_free (ucl_object_t *obj) +ucl_object_dtor_free(ucl_object_t *obj) { if (obj->trash_stack[UCL_TRASH_KEY] != NULL) { - UCL_FREE (obj->hh.keylen, obj->trash_stack[UCL_TRASH_KEY]); + UCL_FREE(obj->hh.keylen, obj->trash_stack[UCL_TRASH_KEY]); } if (obj->trash_stack[UCL_TRASH_VALUE] != NULL) { - UCL_FREE (obj->len, obj->trash_stack[UCL_TRASH_VALUE]); + UCL_FREE(obj->len, obj->trash_stack[UCL_TRASH_VALUE]); } /* Do not free ephemeral objects */ if ((obj->flags & UCL_OBJECT_EPHEMERAL) == 0) { if (obj->type != UCL_USERDATA) { - UCL_FREE (sizeof (ucl_object_t), obj); + UCL_FREE(sizeof(ucl_object_t), obj); } else { - struct ucl_object_userdata *ud = (struct ucl_object_userdata *)obj; + struct ucl_object_userdata *ud = (struct ucl_object_userdata *) obj; if (ud->dtor) { - ud->dtor (obj->value.ud); + ud->dtor(obj->value.ud); } - UCL_FREE (sizeof (*ud), obj); + UCL_FREE(sizeof(*ud), obj); } } } @@ -223,67 +220,67 @@ ucl_object_dtor_free (ucl_object_t *obj) * to use it for individual elements of arrays and multiple values */ static void -ucl_object_dtor_unref_single (ucl_object_t *obj) +ucl_object_dtor_unref_single(ucl_object_t *obj) { if (obj != NULL) { #ifdef HAVE_ATOMIC_BUILTINS - unsigned int rc = __sync_sub_and_fetch (&obj->ref, 1); + unsigned int rc = __sync_sub_and_fetch(&obj->ref, 1); if (rc == 0) { #else if (--obj->ref == 0) { #endif - ucl_object_free_internal (obj, false, ucl_object_dtor_unref); + ucl_object_free_internal(obj, false, ucl_object_dtor_unref); } } } static void -ucl_object_dtor_unref (ucl_object_t *obj) +ucl_object_dtor_unref(ucl_object_t *obj) { if (obj->ref == 0) { - ucl_object_dtor_free (obj); + ucl_object_dtor_free(obj); } else { /* This may cause dtor unref being called one more time */ - ucl_object_dtor_unref_single (obj); + ucl_object_dtor_unref_single(obj); } } static void -ucl_object_free_internal (ucl_object_t *obj, bool allow_rec, ucl_object_dtor dtor) +ucl_object_free_internal(ucl_object_t *obj, bool allow_rec, ucl_object_dtor dtor) { ucl_object_t *tmp, *sub; while (obj != NULL) { if (obj->type == UCL_ARRAY) { - UCL_ARRAY_GET (vec, obj); + UCL_ARRAY_GET(vec, obj); unsigned int i; if (vec != NULL) { - for (i = 0; i < vec->n; i ++) { - sub = kv_A (*vec, i); + for (i = 0; i < vec->n; i++) { + sub = kv_A(*vec, i); if (sub != NULL) { tmp = sub; while (sub) { tmp = sub->next; - dtor (sub); + dtor(sub); sub = tmp; } } } - kv_destroy (*vec); - UCL_FREE (sizeof (*vec), vec); + kv_destroy(*vec); + UCL_FREE(sizeof(*vec), vec); } obj->value.av = NULL; } else if (obj->type == UCL_OBJECT) { if (obj->value.ov != NULL) { - ucl_hash_destroy (obj->value.ov, (ucl_hash_free_func)dtor); + ucl_hash_destroy(obj->value.ov, (ucl_hash_free_func) dtor); } obj->value.ov = NULL; } tmp = obj->next; - dtor (obj); + dtor(obj); obj = tmp; if (!allow_rec) { @@ -292,14 +289,13 @@ ucl_object_free_internal (ucl_object_t *obj, bool allow_rec, ucl_object_dtor dto } } -void -ucl_object_free (ucl_object_t *obj) +void ucl_object_free(ucl_object_t *obj) { - ucl_object_free_internal (obj, true, ucl_object_dtor_free); + ucl_object_free_internal(obj, true, ucl_object_dtor_free); } size_t -ucl_unescape_json_string (char *str, size_t len) +ucl_unescape_json_string(char *str, size_t len) { char *t = str, *h = str; int i, uval; @@ -311,14 +307,14 @@ ucl_unescape_json_string (char *str, size_t len) while (len) { if (*h == '\\') { - h ++; + h++; if (len == 1) { /* * If \ is last, then do not try to go further * Issue: #74 */ - len --; + len--; *t++ = '\\'; continue; } @@ -348,13 +344,13 @@ ucl_unescape_json_string (char *str, size_t len) case 'u': /* Unicode escape */ uval = 0; - h ++; /* u character */ - len --; + h++; /* u character */ + len--; if (len > 3) { for (i = 0; i < 4; i++) { uval <<= 4; - if (isdigit (h[i])) { + if (isdigit(h[i])) { uval += h[i] - '0'; } else if (h[i] >= 'a' && h[i] <= 'f') { @@ -369,16 +365,16 @@ ucl_unescape_json_string (char *str, size_t len) } /* Encode */ - if(uval < 0x80) { - t[0] = (char)uval; - t ++; + if (uval < 0x80) { + t[0] = (char) uval; + t++; } - else if(uval < 0x800) { + else if (uval < 0x800) { t[0] = 0xC0 + ((uval & 0x7C0) >> 6); t[1] = 0x80 + ((uval & 0x03F)); t += 2; } - else if(uval < 0x10000) { + else if (uval < 0x10000) { t[0] = 0xE0 + ((uval & 0xF000) >> 12); t[1] = 0x80 + ((uval & 0x0FC0) >> 6); t[2] = 0x80 + ((uval & 0x003F)); @@ -403,7 +399,7 @@ ucl_unescape_json_string (char *str, size_t len) len -= 4; if (len > 0) { - len --; /* for '\' character */ + len--; /* for '\' character */ } continue; } @@ -415,15 +411,15 @@ ucl_unescape_json_string (char *str, size_t len) *t++ = *h; break; } - h ++; - len --; + h++; + len--; } else { *t++ = *h++; } if (len > 0) { - len --; + len--; } } *t = '\0'; @@ -432,7 +428,7 @@ ucl_unescape_json_string (char *str, size_t len) } size_t -ucl_unescape_squoted_string (char *str, size_t len) +ucl_unescape_squoted_string(char *str, size_t len) { char *t = str, *h = str; @@ -444,14 +440,14 @@ ucl_unescape_squoted_string (char *str, size_t len) while (len) { if (*h == '\\') { - h ++; + h++; if (len == 1) { /* * If \ is last, then do not try to go further * Issue: #74 */ - len --; + len--; *t++ = '\\'; continue; } @@ -466,8 +462,8 @@ ucl_unescape_squoted_string (char *str, size_t len) case '\r': /* Ignore \r and the following \n if needed */ if (len > 1 && h[1] == '\n') { - h ++; - len --; + h++; + len--; } break; default: @@ -477,15 +473,15 @@ ucl_unescape_squoted_string (char *str, size_t len) break; } - h ++; - len --; + h++; + len--; } else { *t++ = *h++; } if (len > 0) { - len --; + len--; } } @@ -495,7 +491,7 @@ ucl_unescape_squoted_string (char *str, size_t len) } char * -ucl_copy_key_trash (const ucl_object_t *obj) +ucl_copy_key_trash(const ucl_object_t *obj) { ucl_object_t *deconst; @@ -503,10 +499,10 @@ ucl_copy_key_trash (const ucl_object_t *obj) return NULL; } if (obj->trash_stack[UCL_TRASH_KEY] == NULL && obj->key != NULL) { - deconst = __DECONST (ucl_object_t *, obj); - deconst->trash_stack[UCL_TRASH_KEY] = malloc (obj->keylen + 1); + deconst = __DECONST(ucl_object_t *, obj); + deconst->trash_stack[UCL_TRASH_KEY] = malloc(obj->keylen + 1); if (deconst->trash_stack[UCL_TRASH_KEY] != NULL) { - memcpy (deconst->trash_stack[UCL_TRASH_KEY], obj->key, obj->keylen); + memcpy(deconst->trash_stack[UCL_TRASH_KEY], obj->key, obj->keylen); deconst->trash_stack[UCL_TRASH_KEY][obj->keylen] = '\0'; } deconst->key = obj->trash_stack[UCL_TRASH_KEY]; @@ -516,37 +512,38 @@ ucl_copy_key_trash (const ucl_object_t *obj) return obj->trash_stack[UCL_TRASH_KEY]; } -void -ucl_chunk_free (struct ucl_chunk *chunk) +void ucl_chunk_free(struct ucl_chunk *chunk) { if (chunk) { struct ucl_parser_special_handler_chain *chain, *tmp; - LL_FOREACH_SAFE (chunk->special_handlers, chain, tmp) { + LL_FOREACH_SAFE(chunk->special_handlers, chain, tmp) + { if (chain->special_handler->free_function) { - chain->special_handler->free_function ( - chain->begin, - chain->len, - chain->special_handler->user_data); - } else { - UCL_FREE (chain->len, chain->begin); + chain->special_handler->free_function( + chain->begin, + chain->len, + chain->special_handler->user_data); + } + else { + UCL_FREE(chain->len, chain->begin); } - UCL_FREE (sizeof (*chain), chain); + UCL_FREE(sizeof(*chain), chain); } chunk->special_handlers = NULL; if (chunk->fname) { - free (chunk->fname); + free(chunk->fname); } - UCL_FREE (sizeof (*chunk), chunk); + UCL_FREE(sizeof(*chunk), chunk); } } char * -ucl_copy_value_trash (const ucl_object_t *obj) +ucl_copy_value_trash(const ucl_object_t *obj) { ucl_object_t *deconst; @@ -554,25 +551,25 @@ ucl_copy_value_trash (const ucl_object_t *obj) return NULL; } if (obj->trash_stack[UCL_TRASH_VALUE] == NULL) { - deconst = __DECONST (ucl_object_t *, obj); + deconst = __DECONST(ucl_object_t *, obj); if (obj->type == UCL_STRING) { /* Special case for strings */ if (obj->flags & UCL_OBJECT_BINARY) { - deconst->trash_stack[UCL_TRASH_VALUE] = malloc (obj->len); + deconst->trash_stack[UCL_TRASH_VALUE] = malloc(obj->len); if (deconst->trash_stack[UCL_TRASH_VALUE] != NULL) { - memcpy (deconst->trash_stack[UCL_TRASH_VALUE], - obj->value.sv, - obj->len); + memcpy(deconst->trash_stack[UCL_TRASH_VALUE], + obj->value.sv, + obj->len); deconst->value.sv = obj->trash_stack[UCL_TRASH_VALUE]; } } else { - deconst->trash_stack[UCL_TRASH_VALUE] = malloc (obj->len + 1); + deconst->trash_stack[UCL_TRASH_VALUE] = malloc(obj->len + 1); if (deconst->trash_stack[UCL_TRASH_VALUE] != NULL) { - memcpy (deconst->trash_stack[UCL_TRASH_VALUE], - obj->value.sv, - obj->len); + memcpy(deconst->trash_stack[UCL_TRASH_VALUE], + obj->value.sv, + obj->len); deconst->trash_stack[UCL_TRASH_VALUE][obj->len] = '\0'; deconst->value.sv = obj->trash_stack[UCL_TRASH_VALUE]; } @@ -580,8 +577,8 @@ ucl_copy_value_trash (const ucl_object_t *obj) } else { /* Just emit value in json notation */ - deconst->trash_stack[UCL_TRASH_VALUE] = ucl_object_emit_single_json (obj); - deconst->len = strlen (obj->trash_stack[UCL_TRASH_VALUE]); + deconst->trash_stack[UCL_TRASH_VALUE] = ucl_object_emit_single_json(obj); + deconst->len = strlen(obj->trash_stack[UCL_TRASH_VALUE]); } deconst->flags |= UCL_OBJECT_ALLOCATED_VALUE; } @@ -589,18 +586,17 @@ ucl_copy_value_trash (const ucl_object_t *obj) return obj->trash_stack[UCL_TRASH_VALUE]; } -ucl_object_t* -ucl_parser_get_object (struct ucl_parser *parser) +ucl_object_t * +ucl_parser_get_object(struct ucl_parser *parser) { if (parser->state != UCL_STATE_ERROR && parser->top_obj != NULL) { - return ucl_object_ref (parser->top_obj); + return ucl_object_ref(parser->top_obj); } return NULL; } -void -ucl_parser_free (struct ucl_parser *parser) +void ucl_parser_free(struct ucl_parser *parser) { struct ucl_stack *stack, *stmp; struct ucl_macro *macro, *mtmp; @@ -614,49 +610,55 @@ ucl_parser_free (struct ucl_parser *parser) } if (parser->top_obj != NULL) { - ucl_object_unref (parser->top_obj); + ucl_object_unref(parser->top_obj); } if (parser->includepaths != NULL) { - ucl_object_unref (parser->includepaths); + ucl_object_unref(parser->includepaths); } - LL_FOREACH_SAFE (parser->stack, stack, stmp) { - free (stack); + LL_FOREACH_SAFE(parser->stack, stack, stmp) + { + free(stack); } - HASH_ITER (hh, parser->macroes, macro, mtmp) { - free (macro->name); - HASH_DEL (parser->macroes, macro); - UCL_FREE (sizeof (struct ucl_macro), macro); + HASH_ITER(hh, parser->macroes, macro, mtmp) + { + free(macro->name); + HASH_DEL(parser->macroes, macro); + UCL_FREE(sizeof(struct ucl_macro), macro); } - LL_FOREACH_SAFE (parser->chunks, chunk, ctmp) { - ucl_chunk_free (chunk); + LL_FOREACH_SAFE(parser->chunks, chunk, ctmp) + { + ucl_chunk_free(chunk); } - LL_FOREACH_SAFE (parser->keys, key, ktmp) { - UCL_FREE (sizeof (struct ucl_pubkey), key); + LL_FOREACH_SAFE(parser->keys, key, ktmp) + { + UCL_FREE(sizeof(struct ucl_pubkey), key); } - LL_FOREACH_SAFE (parser->variables, var, vtmp) { - free (var->value); - free (var->var); - UCL_FREE (sizeof (struct ucl_variable), var); + LL_FOREACH_SAFE(parser->variables, var, vtmp) + { + free(var->value); + free(var->var); + UCL_FREE(sizeof(struct ucl_variable), var); } - LL_FOREACH_SAFE (parser->trash_objs, tr, trtmp) { - ucl_object_free_internal (tr, false, ucl_object_dtor_free); + LL_FOREACH_SAFE(parser->trash_objs, tr, trtmp) + { + ucl_object_free_internal(tr, false, ucl_object_dtor_free); } if (parser->err != NULL) { - utstring_free (parser->err); + utstring_free(parser->err); } if (parser->cur_file) { - free (parser->cur_file); + UCL_FREE(strlen(parser->cur_file) + 1, parser->cur_file); } if (parser->comments) { - ucl_object_unref (parser->comments); + ucl_object_unref(parser->comments); } - UCL_FREE (sizeof (struct ucl_parser), parser); + UCL_FREE(sizeof(struct ucl_parser), parser); } const char * @@ -670,11 +672,10 @@ ucl_parser_get_error(struct ucl_parser *parser) return NULL; } - return utstring_body (parser->err); + return utstring_body(parser->err); } -int -ucl_parser_get_error_code(struct ucl_parser *parser) +int ucl_parser_get_error_code(struct ucl_parser *parser) { if (parser == NULL) { return 0; @@ -703,8 +704,7 @@ ucl_parser_get_linenum(struct ucl_parser *parser) return parser->chunks->line; } -void -ucl_parser_clear_error(struct ucl_parser *parser) +void ucl_parser_clear_error(struct ucl_parser *parser) { if (parser != NULL && parser->err != NULL) { utstring_free(parser->err); @@ -713,44 +713,43 @@ ucl_parser_clear_error(struct ucl_parser *parser) } } -bool -ucl_pubkey_add (struct ucl_parser *parser, const unsigned char *key, size_t len) +bool ucl_pubkey_add(struct ucl_parser *parser, const unsigned char *key, size_t len) { #ifndef HAVE_OPENSSL - ucl_create_err (&parser->err, "cannot check signatures without openssl"); + ucl_create_err(&parser->err, "cannot check signatures without openssl"); return false; #else -# if (OPENSSL_VERSION_NUMBER < 0x10000000L) - ucl_create_err (&parser->err, "cannot check signatures, openssl version is unsupported"); +#if (OPENSSL_VERSION_NUMBER < 0x10000000L) + ucl_create_err(&parser->err, "cannot check signatures, openssl version is unsupported"); return EXIT_FAILURE; -# else +#else struct ucl_pubkey *nkey; BIO *mem; - mem = BIO_new_mem_buf ((void *)key, len); - nkey = UCL_ALLOC (sizeof (struct ucl_pubkey)); + mem = BIO_new_mem_buf((void *) key, len); + nkey = UCL_ALLOC(sizeof(struct ucl_pubkey)); if (nkey == NULL) { - ucl_create_err (&parser->err, "cannot allocate memory for key"); + ucl_create_err(&parser->err, "cannot allocate memory for key"); return false; } - nkey->key = PEM_read_bio_PUBKEY (mem, &nkey->key, NULL, NULL); - BIO_free (mem); + nkey->key = PEM_read_bio_PUBKEY(mem, &nkey->key, NULL, NULL); + BIO_free(mem); if (nkey->key == NULL) { - UCL_FREE (sizeof (struct ucl_pubkey), nkey); - ucl_create_err (&parser->err, "%s", - ERR_error_string (ERR_get_error (), NULL)); + UCL_FREE(sizeof(struct ucl_pubkey), nkey); + ucl_create_err(&parser->err, "%s", + ERR_error_string(ERR_get_error(), NULL)); return false; } - LL_PREPEND (parser->keys, nkey); -# endif + LL_PREPEND(parser->keys, nkey); +#endif #endif return true; } -void ucl_parser_add_special_handler (struct ucl_parser *parser, - struct ucl_parser_special_handler *handler) +void ucl_parser_add_special_handler(struct ucl_parser *parser, + struct ucl_parser_special_handler *handler) { - LL_APPEND (parser->special_handlers, handler); + LL_APPEND(parser->special_handlers, handler); } #ifdef CURL_FOUND @@ -760,17 +759,17 @@ struct ucl_curl_cbdata { }; static size_t -ucl_curl_write_callback (void* contents, size_t size, size_t nmemb, void* ud) +ucl_curl_write_callback(void *contents, size_t size, size_t nmemb, void *ud) { struct ucl_curl_cbdata *cbdata = ud; size_t realsize = size * nmemb; - cbdata->buf = realloc (cbdata->buf, cbdata->buflen + realsize + 1); + cbdata->buf = realloc(cbdata->buf, cbdata->buflen + realsize + 1); if (cbdata->buf == NULL) { return 0; } - memcpy (&(cbdata->buf[cbdata->buflen]), contents, realsize); + memcpy(&(cbdata->buf[cbdata->buflen]), contents, realsize); cbdata->buflen += realsize; cbdata->buf[cbdata->buflen] = 0; @@ -786,9 +785,8 @@ ucl_curl_write_callback (void* contents, size_t size, size_t nmemb, void* ud) * @param buflen target length * @return */ -bool -ucl_fetch_url (const unsigned char *url, unsigned char **buf, size_t *buflen, - UT_string **err, bool must_exist) +bool ucl_fetch_url(const unsigned char *url, unsigned char **buf, size_t *buflen, + UT_string **err, bool must_exist) { #ifdef HAVE_FETCH_H @@ -796,81 +794,81 @@ ucl_fetch_url (const unsigned char *url, unsigned char **buf, size_t *buflen, struct url_stat us; FILE *in; - fetch_url = fetchParseURL (url); + fetch_url = fetchParseURL(url); if (fetch_url == NULL) { - ucl_create_err (err, "invalid URL %s: %s", - url, strerror (errno)); + ucl_create_err(err, "invalid URL %s: %s", + url, strerror(errno)); return false; } - if ((in = fetchXGet (fetch_url, &us, "")) == NULL) { + if ((in = fetchXGet(fetch_url, &us, "")) == NULL) { if (!must_exist) { - ucl_create_err (err, "cannot fetch URL %s: %s", - url, strerror (errno)); + ucl_create_err(err, "cannot fetch URL %s: %s", + url, strerror(errno)); } - fetchFreeURL (fetch_url); + fetchFreeURL(fetch_url); return false; } *buflen = us.size; - *buf = malloc (*buflen); + *buf = malloc(*buflen); if (*buf == NULL) { - ucl_create_err (err, "cannot allocate buffer for URL %s: %s", - url, strerror (errno)); - fclose (in); - fetchFreeURL (fetch_url); + ucl_create_err(err, "cannot allocate buffer for URL %s: %s", + url, strerror(errno)); + fclose(in); + fetchFreeURL(fetch_url); return false; } - if (fread (*buf, *buflen, 1, in) != 1) { - ucl_create_err (err, "cannot read URL %s: %s", - url, strerror (errno)); - fclose (in); - fetchFreeURL (fetch_url); + if (fread(*buf, *buflen, 1, in) != 1) { + ucl_create_err(err, "cannot read URL %s: %s", + url, strerror(errno)); + fclose(in); + fetchFreeURL(fetch_url); return false; } - fetchFreeURL (fetch_url); + fetchFreeURL(fetch_url); return true; #elif defined(CURL_FOUND) CURL *curl; int r; struct ucl_curl_cbdata cbdata; - curl = curl_easy_init (); + curl = curl_easy_init(); if (curl == NULL) { - ucl_create_err (err, "CURL interface is broken"); + ucl_create_err(err, "CURL interface is broken"); return false; } - if ((r = curl_easy_setopt (curl, CURLOPT_URL, url)) != CURLE_OK) { - ucl_create_err (err, "invalid URL %s: %s", - url, curl_easy_strerror (r)); - curl_easy_cleanup (curl); + if ((r = curl_easy_setopt(curl, CURLOPT_URL, url)) != CURLE_OK) { + ucl_create_err(err, "invalid URL %s: %s", + url, curl_easy_strerror(r)); + curl_easy_cleanup(curl); return false; } - curl_easy_setopt (curl, CURLOPT_WRITEFUNCTION, ucl_curl_write_callback); + curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, ucl_curl_write_callback); cbdata.buf = NULL; cbdata.buflen = 0; - curl_easy_setopt (curl, CURLOPT_WRITEDATA, &cbdata); + curl_easy_setopt(curl, CURLOPT_WRITEDATA, &cbdata); - if ((r = curl_easy_perform (curl)) != CURLE_OK) { + if ((r = curl_easy_perform(curl)) != CURLE_OK) { if (!must_exist) { - ucl_create_err (err, "error fetching URL %s: %s", - url, curl_easy_strerror (r)); + ucl_create_err(err, "error fetching URL %s: %s", + url, curl_easy_strerror(r)); } - curl_easy_cleanup (curl); + curl_easy_cleanup(curl); if (cbdata.buf) { - free (cbdata.buf); + free(cbdata.buf); } return false; } *buf = cbdata.buf; *buflen = cbdata.buflen; - curl_easy_cleanup (curl); + curl_easy_cleanup(curl); return true; #else - ucl_create_err (err, "URL support is disabled"); + ucl_create_err(err, "URL support is disabled"); return false; #endif } @@ -883,32 +881,31 @@ ucl_fetch_url (const unsigned char *url, unsigned char **buf, size_t *buflen, * @param buflen target length * @return */ -bool -ucl_fetch_file (const unsigned char *filename, unsigned char **buf, size_t *buflen, - UT_string **err, bool must_exist) +bool ucl_fetch_file(const unsigned char *filename, unsigned char **buf, size_t *buflen, + UT_string **err, bool must_exist) { int fd; struct stat st; - if ((fd = open (filename, O_RDONLY)) == -1) { - ucl_create_err (err, "cannot open file %s: %s", - filename, strerror (errno)); + if ((fd = open(filename, O_RDONLY)) == -1) { + ucl_create_err(err, "cannot open file %s: %s", + filename, strerror(errno)); return false; } - if (fstat (fd, &st) == -1) { + if (fstat(fd, &st) == -1) { if (must_exist || errno == EPERM) { - ucl_create_err (err, "cannot stat file %s: %s", - filename, strerror (errno)); + ucl_create_err(err, "cannot stat file %s: %s", + filename, strerror(errno)); } - close (fd); + close(fd); return false; } - if (!S_ISREG (st.st_mode)) { + if (!S_ISREG(st.st_mode)) { if (must_exist) { - ucl_create_err (err, "file %s is not a regular file", filename); + ucl_create_err(err, "file %s is not a regular file", filename); } - close (fd); + close(fd); return false; } @@ -922,7 +919,7 @@ ucl_fetch_file (const unsigned char *filename, unsigned char **buf, size_t *bufl if ((*buf = ucl_mmap(NULL, st.st_size, PROT_READ, MAP_SHARED, fd, 0)) == MAP_FAILED) { close(fd); ucl_create_err(err, "cannot mmap file %s: %s", - filename, strerror(errno)); + filename, strerror(errno)); *buf = NULL; return false; @@ -930,7 +927,7 @@ ucl_fetch_file (const unsigned char *filename, unsigned char **buf, size_t *bufl *buflen = st.st_size; } - close (fd); + close(fd); return true; } @@ -938,8 +935,8 @@ ucl_fetch_file (const unsigned char *filename, unsigned char **buf, size_t *bufl #if (defined(HAVE_OPENSSL) && OPENSSL_VERSION_NUMBER >= 0x10000000L) static inline bool -ucl_sig_check (const unsigned char *data, size_t datalen, - const unsigned char *sig, size_t siglen, struct ucl_parser *parser) +ucl_sig_check(const unsigned char *data, size_t datalen, + const unsigned char *sig, size_t siglen, struct ucl_parser *parser) { struct ucl_pubkey *key; char dig[EVP_MAX_MD_SIZE]; @@ -947,38 +944,39 @@ ucl_sig_check (const unsigned char *data, size_t datalen, EVP_PKEY_CTX *key_ctx; EVP_MD_CTX *sign_ctx = NULL; - sign_ctx = EVP_MD_CTX_create (); + sign_ctx = EVP_MD_CTX_create(); - LL_FOREACH (parser->keys, key) { - key_ctx = EVP_PKEY_CTX_new (key->key, NULL); + LL_FOREACH(parser->keys, key) + { + key_ctx = EVP_PKEY_CTX_new(key->key, NULL); if (key_ctx != NULL) { - if (EVP_PKEY_verify_init (key_ctx) <= 0) { - EVP_PKEY_CTX_free (key_ctx); + if (EVP_PKEY_verify_init(key_ctx) <= 0) { + EVP_PKEY_CTX_free(key_ctx); continue; } - if (EVP_PKEY_CTX_set_rsa_padding (key_ctx, RSA_PKCS1_PADDING) <= 0) { - EVP_PKEY_CTX_free (key_ctx); + if (EVP_PKEY_CTX_set_rsa_padding(key_ctx, RSA_PKCS1_PADDING) <= 0) { + EVP_PKEY_CTX_free(key_ctx); continue; } - if (EVP_PKEY_CTX_set_signature_md (key_ctx, EVP_sha256 ()) <= 0) { - EVP_PKEY_CTX_free (key_ctx); + if (EVP_PKEY_CTX_set_signature_md(key_ctx, EVP_sha256()) <= 0) { + EVP_PKEY_CTX_free(key_ctx); continue; } - EVP_DigestInit (sign_ctx, EVP_sha256 ()); - EVP_DigestUpdate (sign_ctx, data, datalen); - EVP_DigestFinal (sign_ctx, dig, &diglen); + EVP_DigestInit(sign_ctx, EVP_sha256()); + EVP_DigestUpdate(sign_ctx, data, datalen); + EVP_DigestFinal(sign_ctx, dig, &diglen); - if (EVP_PKEY_verify (key_ctx, sig, siglen, dig, diglen) == 1) { - EVP_MD_CTX_destroy (sign_ctx); - EVP_PKEY_CTX_free (key_ctx); + if (EVP_PKEY_verify(key_ctx, sig, siglen, dig, diglen) == 1) { + EVP_MD_CTX_destroy(sign_ctx); + EVP_PKEY_CTX_free(key_ctx); return true; } - EVP_PKEY_CTX_free (key_ctx); + EVP_PKEY_CTX_free(key_ctx); } } - EVP_MD_CTX_destroy (sign_ctx); + EVP_MD_CTX_destroy(sign_ctx); return false; } @@ -1007,9 +1005,9 @@ struct ucl_include_params { * @return */ static bool -ucl_include_url (const unsigned char *data, size_t len, - struct ucl_parser *parser, - struct ucl_include_params *params) +ucl_include_url(const unsigned char *data, size_t len, + struct ucl_parser *parser, + struct ucl_include_params *params) { bool res; @@ -1019,11 +1017,11 @@ ucl_include_url (const unsigned char *data, size_t len, char urlbuf[PATH_MAX]; int prev_state; - snprintf (urlbuf, sizeof (urlbuf), "%.*s", (int)len, data); + snprintf(urlbuf, sizeof(urlbuf), "%.*s", (int) len, data); - if (!ucl_fetch_url (urlbuf, &buf, &buflen, &parser->err, params->must_exist)) { + if (!ucl_fetch_url(urlbuf, &buf, &buflen, &parser->err, params->must_exist)) { if (!params->must_exist) { - ucl_parser_clear_error (parser); + ucl_parser_clear_error(parser); } return !params->must_exist; } @@ -1033,21 +1031,21 @@ ucl_include_url (const unsigned char *data, size_t len, unsigned char *sigbuf = NULL; size_t siglen = 0; /* We need to check signature first */ - snprintf (urlbuf, sizeof (urlbuf), "%.*s.sig", (int)len, data); - if (!ucl_fetch_url (urlbuf, &sigbuf, &siglen, &parser->err, true)) { + snprintf(urlbuf, sizeof(urlbuf), "%.*s.sig", (int) len, data); + if (!ucl_fetch_url(urlbuf, &sigbuf, &siglen, &parser->err, true)) { return false; } - if (!ucl_sig_check (buf, buflen, sigbuf, siglen, parser)) { - ucl_create_err (&parser->err, "cannot verify url %s: %s", - urlbuf, - ERR_error_string (ERR_get_error (), NULL)); + if (!ucl_sig_check(buf, buflen, sigbuf, siglen, parser)) { + ucl_create_err(&parser->err, "cannot verify url %s: %s", + urlbuf, + ERR_error_string(ERR_get_error(), NULL)); if (siglen > 0) { - ucl_munmap (sigbuf, siglen); + free(sigbuf); } return false; } if (siglen > 0) { - ucl_munmap (sigbuf, siglen); + free(sigbuf); } #endif } @@ -1055,19 +1053,19 @@ ucl_include_url (const unsigned char *data, size_t len, prev_state = parser->state; parser->state = UCL_STATE_INIT; - res = ucl_parser_add_chunk_full (parser, buf, buflen, params->priority, - params->strat, params->parse_type); + res = ucl_parser_add_chunk_full(parser, buf, buflen, params->priority, + params->strat, params->parse_type); if (res == true) { /* Remove chunk from the stack */ chunk = parser->chunks; if (chunk != NULL) { parser->chunks = chunk->next; - ucl_chunk_free (chunk); + ucl_chunk_free(chunk); } } parser->state = prev_state; - free (buf); + free(buf); return res; } @@ -1084,8 +1082,8 @@ ucl_include_url (const unsigned char *data, size_t len, * @return */ static bool -ucl_include_file_single (const unsigned char *data, size_t len, - struct ucl_parser *parser, struct ucl_include_params *params) +ucl_include_file_single(const unsigned char *data, size_t len, + struct ucl_parser *parser, struct ucl_include_params *params) { bool res; struct ucl_chunk *chunk; @@ -1095,7 +1093,7 @@ ucl_include_file_single (const unsigned char *data, size_t len, char filebuf[PATH_MAX], realbuf[PATH_MAX]; int prev_state; struct ucl_variable *cur_var, *tmp_var, *old_curdir = NULL, - *old_filename = NULL; + *old_filename = NULL; ucl_object_t *nest_obj = NULL, *old_obj = NULL, *new_obj = NULL; ucl_hash_t *container = NULL; struct ucl_stack *st = NULL; @@ -1105,8 +1103,8 @@ ucl_include_file_single (const unsigned char *data, size_t len, return false; } - snprintf (filebuf, sizeof (filebuf), "%.*s", (int)len, data); - if (ucl_realpath (filebuf, realbuf) == NULL) { + snprintf(filebuf, sizeof(filebuf), "%.*s", (int) len, data); + if (ucl_realpath(filebuf, realbuf) == NULL) { if (params->soft_fail) { return false; } @@ -1114,24 +1112,24 @@ ucl_include_file_single (const unsigned char *data, size_t len, return true; } - ucl_create_err (&parser->err, "cannot open file %s: %s", - filebuf, - strerror (errno)); + ucl_create_err(&parser->err, "cannot open file %s: %s", + filebuf, + strerror(errno)); return false; } - if (parser->cur_file && strcmp (realbuf, parser->cur_file) == 0) { + if (parser->cur_file && strcmp(realbuf, parser->cur_file) == 0) { /* We are likely including the file itself */ if (params->soft_fail) { return false; } - ucl_create_err (&parser->err, "trying to include the file %s from itself", - realbuf); + ucl_create_err(&parser->err, "trying to include the file %s from itself", + realbuf); return false; } - if (!ucl_fetch_file (realbuf, &buf, &buflen, &parser->err, params->must_exist)) { + if (!ucl_fetch_file(realbuf, &buf, &buflen, &parser->err, params->must_exist)) { if (params->soft_fail) { return false; } @@ -1141,7 +1139,7 @@ ucl_include_file_single (const unsigned char *data, size_t len, return false; } - ucl_parser_clear_error (parser); + ucl_parser_clear_error(parser); return true; } @@ -1151,30 +1149,30 @@ ucl_include_file_single (const unsigned char *data, size_t len, unsigned char *sigbuf = NULL; size_t siglen = 0; /* We need to check signature first */ - snprintf (filebuf, sizeof (filebuf), "%s.sig", realbuf); - if (!ucl_fetch_file (filebuf, &sigbuf, &siglen, &parser->err, true)) { + snprintf(filebuf, sizeof(filebuf), "%s.sig", realbuf); + if (!ucl_fetch_file(filebuf, &sigbuf, &siglen, &parser->err, true)) { if (buf) { - ucl_munmap (buf, buflen); + ucl_munmap(buf, buflen); } return false; } - if (!ucl_sig_check (buf, buflen, sigbuf, siglen, parser)) { - ucl_create_err (&parser->err, "cannot verify file %s: %s", - filebuf, - ERR_error_string (ERR_get_error (), NULL)); + if (!ucl_sig_check(buf, buflen, sigbuf, siglen, parser)) { + ucl_create_err(&parser->err, "cannot verify file %s: %s", + filebuf, + ERR_error_string(ERR_get_error(), NULL)); if (sigbuf) { - ucl_munmap (sigbuf, siglen); + ucl_munmap(sigbuf, siglen); } if (buf) { - ucl_munmap (buf, buflen); + ucl_munmap(buf, buflen); } return false; } if (sigbuf) { - ucl_munmap (sigbuf, siglen); + ucl_munmap(sigbuf, siglen); } #endif } @@ -1183,27 +1181,28 @@ ucl_include_file_single (const unsigned char *data, size_t len, parser->cur_file = NULL; /* Store old file vars */ - DL_FOREACH_SAFE (parser->variables, cur_var, tmp_var) { - if (strcmp (cur_var->var, "CURDIR") == 0) { + DL_FOREACH_SAFE(parser->variables, cur_var, tmp_var) + { + if (strcmp(cur_var->var, "CURDIR") == 0) { old_curdir = cur_var; - DL_DELETE (parser->variables, cur_var); + DL_DELETE(parser->variables, cur_var); } - else if (strcmp (cur_var->var, "FILENAME") == 0) { + else if (strcmp(cur_var->var, "FILENAME") == 0) { old_filename = cur_var; - DL_DELETE (parser->variables, cur_var); + DL_DELETE(parser->variables, cur_var); } } - ucl_parser_set_filevars (parser, realbuf, false); + ucl_parser_set_filevars(parser, realbuf, false); prev_state = parser->state; parser->state = UCL_STATE_INIT; if (params->use_prefix && params->prefix == NULL) { /* Auto generate a key name based on the included filename */ - params->prefix = basename (realbuf); - ext = strrchr (params->prefix, '.'); - if (ext != NULL && (strcmp (ext, ".conf") == 0 || strcmp (ext, ".ucl") == 0)) { + params->prefix = basename(realbuf); + ext = strrchr(params->prefix, '.'); + if (ext != NULL && (strcmp(ext, ".conf") == 0 || strcmp(ext, ".ucl") == 0)) { /* Strip off .conf or .ucl */ *ext = '\0'; } @@ -1212,39 +1211,39 @@ ucl_include_file_single (const unsigned char *data, size_t len, /* This is a prefixed include */ container = parser->stack->obj->value.ov; - old_obj = __DECONST (ucl_object_t *, ucl_hash_search (container, - params->prefix, strlen (params->prefix))); + old_obj = __DECONST(ucl_object_t *, ucl_hash_search(container, + params->prefix, strlen(params->prefix))); - if (strcasecmp (params->target, "array") == 0) { + if (strcasecmp(params->target, "array") == 0) { if (old_obj == NULL) { /* Create an array with key: prefix */ - old_obj = ucl_object_new_full (UCL_ARRAY, params->priority); + old_obj = ucl_object_new_full(UCL_ARRAY, params->priority); old_obj->key = params->prefix; - old_obj->keylen = strlen (params->prefix); - ucl_copy_key_trash (old_obj); + old_obj->keylen = strlen(params->prefix); + ucl_copy_key_trash(old_obj); old_obj->prev = old_obj; old_obj->next = NULL; - container = ucl_hash_insert_object (container, old_obj, - parser->flags & UCL_PARSER_KEY_LOWERCASE); + container = ucl_hash_insert_object(container, old_obj, + parser->flags & UCL_PARSER_KEY_LOWERCASE); parser->stack->obj->len++; - nest_obj = ucl_object_new_full (UCL_OBJECT, params->priority); + nest_obj = ucl_object_new_full(UCL_OBJECT, params->priority); nest_obj->prev = nest_obj; nest_obj->next = NULL; - ucl_array_append (old_obj, nest_obj); + ucl_array_append(old_obj, nest_obj); } else { - if (ucl_object_type (old_obj) == UCL_ARRAY) { + if (ucl_object_type(old_obj) == UCL_ARRAY) { /* Append to the existing array */ - nest_obj = ucl_object_new_full (UCL_OBJECT, - params->priority); + nest_obj = ucl_object_new_full(UCL_OBJECT, + params->priority); if (nest_obj == NULL) { - ucl_create_err (&parser->err, - "cannot allocate memory for an object"); + ucl_create_err(&parser->err, + "cannot allocate memory for an object"); if (buf) { - ucl_munmap (buf, buflen); + ucl_munmap(buf, buflen); } return false; @@ -1252,16 +1251,16 @@ ucl_include_file_single (const unsigned char *data, size_t len, nest_obj->prev = nest_obj; nest_obj->next = NULL; - ucl_array_append (old_obj, nest_obj); + ucl_array_append(old_obj, nest_obj); } else { /* Convert the object to an array */ - new_obj = ucl_object_typed_new (UCL_ARRAY); + new_obj = ucl_object_typed_new(UCL_ARRAY); if (new_obj == NULL) { - ucl_create_err (&parser->err, - "cannot allocate memory for an object"); + ucl_create_err(&parser->err, + "cannot allocate memory for an object"); if (buf) { - ucl_munmap (buf, buflen); + ucl_munmap(buf, buflen); } return false; @@ -1272,25 +1271,25 @@ ucl_include_file_single (const unsigned char *data, size_t len, new_obj->prev = new_obj; new_obj->next = NULL; - nest_obj = ucl_object_new_full (UCL_OBJECT, - params->priority); + nest_obj = ucl_object_new_full(UCL_OBJECT, + params->priority); if (nest_obj == NULL) { - ucl_create_err (&parser->err, - "cannot allocate memory for an object"); + ucl_create_err(&parser->err, + "cannot allocate memory for an object"); if (buf) { - ucl_munmap (buf, buflen); + ucl_munmap(buf, buflen); } - ucl_object_unref (new_obj); + ucl_object_unref(new_obj); return false; } nest_obj->prev = nest_obj; nest_obj->next = NULL; - ucl_array_append (new_obj, old_obj); - ucl_array_append (new_obj, nest_obj); - ucl_hash_replace (container, old_obj, new_obj); + ucl_array_append(new_obj, old_obj); + ucl_array_append(new_obj, nest_obj); + ucl_hash_replace(container, old_obj, new_obj); } } } @@ -1298,40 +1297,40 @@ ucl_include_file_single (const unsigned char *data, size_t len, /* Case of object */ if (old_obj == NULL) { /* Create an object with key: prefix */ - nest_obj = ucl_object_new_full (UCL_OBJECT, params->priority); + nest_obj = ucl_object_new_full(UCL_OBJECT, params->priority); if (nest_obj == NULL) { - ucl_create_err (&parser->err, "cannot allocate memory for an object"); + ucl_create_err(&parser->err, "cannot allocate memory for an object"); if (buf) { - ucl_munmap (buf, buflen); + ucl_munmap(buf, buflen); } return false; } nest_obj->key = params->prefix; - nest_obj->keylen = strlen (params->prefix); + nest_obj->keylen = strlen(params->prefix); ucl_copy_key_trash(nest_obj); nest_obj->prev = nest_obj; nest_obj->next = NULL; - container = ucl_hash_insert_object (container, nest_obj, - parser->flags & UCL_PARSER_KEY_LOWERCASE); - parser->stack->obj->len ++; + container = ucl_hash_insert_object(container, nest_obj, + parser->flags & UCL_PARSER_KEY_LOWERCASE); + parser->stack->obj->len++; } else { - if (ucl_object_type (old_obj) == UCL_OBJECT) { + if (ucl_object_type(old_obj) == UCL_OBJECT) { /* Append to existing Object*/ nest_obj = old_obj; } else { /* The key is not an object */ - ucl_create_err (&parser->err, - "Conflicting type for key: %s, asked %s, has %s", - params->prefix, params->target, - ucl_object_type_to_string (ucl_object_type (old_obj))); + ucl_create_err(&parser->err, + "Conflicting type for key: %s, asked %s, has %s", + params->prefix, params->target, + ucl_object_type_to_string(ucl_object_type(old_obj))); if (buf) { - ucl_munmap (buf, buflen); + ucl_munmap(buf, buflen); } return false; @@ -1343,13 +1342,13 @@ ucl_include_file_single (const unsigned char *data, size_t len, /* Put all of the content of the include inside that object */ parser->stack->obj->value.ov = container; - st = UCL_ALLOC (sizeof (struct ucl_stack)); + st = UCL_ALLOC(sizeof(struct ucl_stack)); if (st == NULL) { - ucl_create_err (&parser->err, "cannot allocate memory for an object"); - ucl_object_unref (nest_obj); + ucl_create_err(&parser->err, "cannot allocate memory for an object"); + ucl_object_unref(nest_obj); if (buf) { - ucl_munmap (buf, buflen); + ucl_munmap(buf, buflen); } return false; @@ -1359,59 +1358,61 @@ ucl_include_file_single (const unsigned char *data, size_t len, st->e.params.flags = parser->stack->e.params.flags; st->e.params.line = parser->stack->e.params.line; st->chunk = parser->chunks; - LL_PREPEND (parser->stack, st); + LL_PREPEND(parser->stack, st); parser->cur_obj = nest_obj; } - res = ucl_parser_add_chunk_full (parser, buf, buflen, params->priority, - params->strat, params->parse_type); + res = ucl_parser_add_chunk_full(parser, buf, buflen, params->priority, + params->strat, params->parse_type); if (res) { /* Stop nesting the include, take 1 level off the stack */ if (params->prefix != NULL && nest_obj != NULL) { parser->stack = st->next; - UCL_FREE (sizeof (struct ucl_stack), st); + UCL_FREE(sizeof(struct ucl_stack), st); } /* Remove chunk from the stack */ chunk = parser->chunks; if (chunk != NULL) { parser->chunks = chunk->next; - ucl_chunk_free (chunk); + ucl_chunk_free(chunk); parser->recursion--; } /* Restore old file vars */ if (parser->cur_file) { - free (parser->cur_file); + UCL_FREE(strlen(parser->cur_file) + 1, parser->cur_file); } parser->cur_file = old_curfile; - DL_FOREACH_SAFE (parser->variables, cur_var, tmp_var) { - if (strcmp (cur_var->var, "CURDIR") == 0 && old_curdir) { - DL_DELETE (parser->variables, cur_var); - free (cur_var->var); - free (cur_var->value); - UCL_FREE (sizeof (struct ucl_variable), cur_var); - } else if (strcmp (cur_var->var, "FILENAME") == 0 && old_filename) { - DL_DELETE (parser->variables, cur_var); - free (cur_var->var); - free (cur_var->value); - UCL_FREE (sizeof (struct ucl_variable), cur_var); + DL_FOREACH_SAFE(parser->variables, cur_var, tmp_var) + { + if (strcmp(cur_var->var, "CURDIR") == 0 && old_curdir) { + DL_DELETE(parser->variables, cur_var); + free(cur_var->var); + free(cur_var->value); + UCL_FREE(sizeof(struct ucl_variable), cur_var); + } + else if (strcmp(cur_var->var, "FILENAME") == 0 && old_filename) { + DL_DELETE(parser->variables, cur_var); + free(cur_var->var); + free(cur_var->value); + UCL_FREE(sizeof(struct ucl_variable), cur_var); } } if (old_filename) { - DL_APPEND (parser->variables, old_filename); + DL_APPEND(parser->variables, old_filename); } if (old_curdir) { - DL_APPEND (parser->variables, old_curdir); + DL_APPEND(parser->variables, old_curdir); } parser->state = prev_state; } if (buflen > 0) { - ucl_munmap (buf, buflen); + ucl_munmap(buf, buflen); } return res; @@ -1426,10 +1427,10 @@ ucl_include_file_single (const unsigned char *data, size_t len, * @return */ static bool -ucl_include_file (const unsigned char *data, size_t len, - struct ucl_parser *parser, - struct ucl_include_params *params, - const ucl_object_t *args) +ucl_include_file(const unsigned char *data, size_t len, + struct ucl_parser *parser, + struct ucl_include_params *params, + const ucl_object_t *args) { const unsigned char *p = data, *end = data + len; bool need_glob = false; @@ -1439,7 +1440,7 @@ ucl_include_file (const unsigned char *data, size_t len, #ifndef _WIN32 if (!params->allow_glob) { - return ucl_include_file_single (data, len, parser, params); + return ucl_include_file_single(data, len, parser, params); } else { /* Check for special symbols in a filename */ @@ -1448,17 +1449,17 @@ ucl_include_file (const unsigned char *data, size_t len, need_glob = true; break; } - p ++; + p++; } if (need_glob) { glob_t globbuf; - memset (&globbuf, 0, sizeof (globbuf)); - ucl_strlcpy (glob_pattern, (const char *)data, - (len + 1 < sizeof (glob_pattern) ? len + 1 : sizeof (glob_pattern))); - if (glob (glob_pattern, 0, NULL, &globbuf) != 0) { + memset(&globbuf, 0, sizeof(globbuf)); + ucl_strlcpy(glob_pattern, (const char *) data, + (len + 1 < sizeof(glob_pattern) ? len + 1 : sizeof(glob_pattern))); + if (glob(glob_pattern, 0, NULL, &globbuf) != 0) { return (!params->must_exist || false); } - for (i = 0; i < globbuf.gl_pathc; i ++) { + for (i = 0; i < globbuf.gl_pathc; i++) { if (parser->include_trace_func) { const ucl_object_t *parent = NULL; @@ -1467,38 +1468,38 @@ ucl_include_file (const unsigned char *data, size_t len, parent = parser->stack->obj; } - parser->include_trace_func (parser, parent, NULL, - globbuf.gl_pathv[i], - strlen (globbuf.gl_pathv[i]), - parser->include_trace_ud); + parser->include_trace_func(parser, parent, NULL, + globbuf.gl_pathv[i], + strlen(globbuf.gl_pathv[i]), + parser->include_trace_ud); } - if (!ucl_include_file_single ((unsigned char *)globbuf.gl_pathv[i], - strlen (globbuf.gl_pathv[i]), parser, params)) { + if (!ucl_include_file_single((unsigned char *) globbuf.gl_pathv[i], + strlen(globbuf.gl_pathv[i]), parser, params)) { if (params->soft_fail) { continue; } - globfree (&globbuf); + globfree(&globbuf); return false; } - cnt ++; + cnt++; } - globfree (&globbuf); + globfree(&globbuf); if (cnt == 0 && params->must_exist) { - ucl_create_err (&parser->err, "cannot match any files for pattern %s", - glob_pattern); + ucl_create_err(&parser->err, "cannot match any files for pattern %s", + glob_pattern); return false; } } else { - return ucl_include_file_single (data, len, parser, params); + return ucl_include_file_single(data, len, parser, params); } } #else /* Win32 compilers do not support globbing. Therefore, for Win32, treat allow_glob/need_glob as a NOOP and just return */ - return ucl_include_file_single (data, len, parser, params); + return ucl_include_file_single(data, len, parser, params); #endif return true; @@ -1515,10 +1516,10 @@ ucl_include_file (const unsigned char *data, size_t len, * @return */ static bool -ucl_include_common (const unsigned char *data, size_t len, - const ucl_object_t *args, struct ucl_parser *parser, - bool default_try, - bool default_sign) +ucl_include_common(const unsigned char *data, size_t len, + const ucl_object_t *args, struct ucl_parser *parser, + bool default_try, + bool default_sign) { bool allow_url = false, search = false; const char *duplicate; @@ -1546,104 +1547,104 @@ ucl_include_common (const unsigned char *data, size_t len, parent = parser->stack->obj; } - parser->include_trace_func (parser, parent, args, - data, len, parser->include_trace_ud); + parser->include_trace_func(parser, parent, args, + data, len, parser->include_trace_ud); } /* Process arguments */ if (args != NULL && args->type == UCL_OBJECT) { - while ((param = ucl_object_iterate (args, &it, true)) != NULL) { + while ((param = ucl_object_iterate(args, &it, true)) != NULL) { if (param->type == UCL_BOOLEAN) { - if (strncmp (param->key, "try", param->keylen) == 0) { - params.must_exist = !ucl_object_toboolean (param); + if (strncmp(param->key, "try", param->keylen) == 0) { + params.must_exist = !ucl_object_toboolean(param); } - else if (strncmp (param->key, "sign", param->keylen) == 0) { - params.check_signature = ucl_object_toboolean (param); + else if (strncmp(param->key, "sign", param->keylen) == 0) { + params.check_signature = ucl_object_toboolean(param); } - else if (strncmp (param->key, "glob", param->keylen) == 0) { - params.allow_glob = ucl_object_toboolean (param); + else if (strncmp(param->key, "glob", param->keylen) == 0) { + params.allow_glob = ucl_object_toboolean(param); } - else if (strncmp (param->key, "url", param->keylen) == 0) { - allow_url = ucl_object_toboolean (param); + else if (strncmp(param->key, "url", param->keylen) == 0) { + allow_url = ucl_object_toboolean(param); } - else if (strncmp (param->key, "prefix", param->keylen) == 0) { - params.use_prefix = ucl_object_toboolean (param); + else if (strncmp(param->key, "prefix", param->keylen) == 0) { + params.use_prefix = ucl_object_toboolean(param); } } else if (param->type == UCL_STRING) { - if (strncmp (param->key, "key", param->keylen) == 0) { - params.prefix = ucl_object_tostring (param); + if (strncmp(param->key, "key", param->keylen) == 0) { + params.prefix = ucl_object_tostring(param); } - else if (strncmp (param->key, "target", param->keylen) == 0) { - params.target = ucl_object_tostring (param); + else if (strncmp(param->key, "target", param->keylen) == 0) { + params.target = ucl_object_tostring(param); } - else if (strncmp (param->key, "duplicate", param->keylen) == 0) { - duplicate = ucl_object_tostring (param); + else if (strncmp(param->key, "duplicate", param->keylen) == 0) { + duplicate = ucl_object_tostring(param); - if (strcmp (duplicate, "append") == 0) { + if (strcmp(duplicate, "append") == 0) { params.strat = UCL_DUPLICATE_APPEND; } - else if (strcmp (duplicate, "merge") == 0) { + else if (strcmp(duplicate, "merge") == 0) { params.strat = UCL_DUPLICATE_MERGE; } - else if (strcmp (duplicate, "rewrite") == 0) { + else if (strcmp(duplicate, "rewrite") == 0) { params.strat = UCL_DUPLICATE_REWRITE; } - else if (strcmp (duplicate, "error") == 0) { + else if (strcmp(duplicate, "error") == 0) { params.strat = UCL_DUPLICATE_ERROR; } } } else if (param->type == UCL_ARRAY) { - if (strncmp (param->key, "path", param->keylen) == 0) { - ucl_set_include_path (parser, __DECONST(ucl_object_t *, param)); + if (strncmp(param->key, "path", param->keylen) == 0) { + ucl_set_include_path(parser, __DECONST(ucl_object_t *, param)); } } else if (param->type == UCL_INT) { - if (strncmp (param->key, "priority", param->keylen) == 0) { - params.priority = ucl_object_toint (param); + if (strncmp(param->key, "priority", param->keylen) == 0) { + params.priority = ucl_object_toint(param); } } } } if (parser->includepaths == NULL) { - if (allow_url && ucl_strnstr (data, "://", len) != NULL) { + if (allow_url && ucl_strnstr(data, "://", len) != NULL) { /* Globbing is not used for URL's */ - return ucl_include_url (data, len, parser, ¶ms); + return ucl_include_url(data, len, parser, ¶ms); } else if (data != NULL) { /* Try to load a file */ - return ucl_include_file (data, len, parser, ¶ms, args); + return ucl_include_file(data, len, parser, ¶ms, args); } } else { - if (allow_url && ucl_strnstr (data, "://", len) != NULL) { + if (allow_url && ucl_strnstr(data, "://", len) != NULL) { /* Globbing is not used for URL's */ - return ucl_include_url (data, len, parser, ¶ms); + return ucl_include_url(data, len, parser, ¶ms); } - ip = ucl_object_iterate_new (parser->includepaths); - while ((param = ucl_object_iterate_safe (ip, true)) != NULL) { + ip = ucl_object_iterate_new(parser->includepaths); + while ((param = ucl_object_iterate_safe(ip, true)) != NULL) { if (ucl_object_type(param) == UCL_STRING) { - snprintf (ipath, sizeof (ipath), "%s/%.*s", ucl_object_tostring(param), - (int)len, data); - if ((search = ucl_include_file (ipath, strlen (ipath), - parser, ¶ms, args))) { + snprintf(ipath, sizeof(ipath), "%s/%.*s", ucl_object_tostring(param), + (int) len, data); + if ((search = ucl_include_file(ipath, strlen(ipath), + parser, ¶ms, args))) { if (!params.allow_glob) { break; } } } } - ucl_object_iterate_free (ip); + ucl_object_iterate_free(ip); if (search == true) { return true; } else { - ucl_create_err (&parser->err, - "cannot find file: %.*s in search path", - (int)len, data); + ucl_create_err(&parser->err, + "cannot find file: %.*s in search path", + (int) len, data); return false; } } @@ -1659,13 +1660,12 @@ ucl_include_common (const unsigned char *data, size_t len, * @param ud user data * @return */ -bool -ucl_include_handler (const unsigned char *data, size_t len, - const ucl_object_t *args, void* ud) +bool ucl_include_handler(const unsigned char *data, size_t len, + const ucl_object_t *args, void *ud) { struct ucl_parser *parser = ud; - return ucl_include_common (data, len, args, parser, false, false); + return ucl_include_common(data, len, args, parser, false, false); } /** @@ -1676,13 +1676,12 @@ ucl_include_handler (const unsigned char *data, size_t len, * @param ud user data * @return */ -bool -ucl_includes_handler (const unsigned char *data, size_t len, - const ucl_object_t *args, void* ud) +bool ucl_includes_handler(const unsigned char *data, size_t len, + const ucl_object_t *args, void *ud) { struct ucl_parser *parser = ud; - return ucl_include_common (data, len, args, parser, false, true); + return ucl_include_common(data, len, args, parser, false, true); } /** @@ -1693,13 +1692,12 @@ ucl_includes_handler (const unsigned char *data, size_t len, * @param ud user data * @return */ -bool -ucl_try_include_handler (const unsigned char *data, size_t len, - const ucl_object_t *args, void* ud) +bool ucl_try_include_handler(const unsigned char *data, size_t len, + const ucl_object_t *args, void *ud) { struct ucl_parser *parser = ud; - return ucl_include_common (data, len, args, parser, true, false); + return ucl_include_common(data, len, args, parser, true, false); } /** @@ -1710,9 +1708,8 @@ ucl_try_include_handler (const unsigned char *data, size_t len, * @param ud user data * @return */ -bool -ucl_priority_handler (const unsigned char *data, size_t len, - const ucl_object_t *args, void* ud) +bool ucl_priority_handler(const unsigned char *data, size_t len, + const ucl_object_t *args, void *ud) { struct ucl_parser *parser = ud; unsigned priority = 255; @@ -1727,10 +1724,10 @@ ucl_priority_handler (const unsigned char *data, size_t len, /* Process arguments */ if (args != NULL && args->type == UCL_OBJECT) { - while ((param = ucl_object_iterate (args, &it, true)) != NULL) { + while ((param = ucl_object_iterate(args, &it, true)) != NULL) { if (param->type == UCL_INT) { - if (strncmp (param->key, "priority", param->keylen) == 0) { - priority = ucl_object_toint (param); + if (strncmp(param->key, "priority", param->keylen) == 0) { + priority = ucl_object_toint(param); found = true; } } @@ -1739,11 +1736,11 @@ ucl_priority_handler (const unsigned char *data, size_t len, if (len > 0) { value = malloc(len + 1); - ucl_strlcpy(value, (const char *)data, len + 1); + ucl_strlcpy(value, (const char *) data, len + 1); priority = strtol(value, &leftover, 10); if (*leftover != '\0') { - ucl_create_err (&parser->err, "Invalid priority value in macro: %s", - value); + ucl_create_err(&parser->err, "Invalid priority value in macro: %s", + value); free(value); return false; } @@ -1756,7 +1753,7 @@ ucl_priority_handler (const unsigned char *data, size_t len, return true; } - ucl_create_err (&parser->err, "Unable to parse priority macro"); + ucl_create_err(&parser->err, "Unable to parse priority macro"); return false; } @@ -1768,9 +1765,8 @@ ucl_priority_handler (const unsigned char *data, size_t len, * @param ud user data * @return */ -bool -ucl_load_handler (const unsigned char *data, size_t len, - const ucl_object_t *args, void* ud) +bool ucl_load_handler(const unsigned char *data, size_t len, + const ucl_object_t *args, void *ud) { struct ucl_parser *parser = ud; const ucl_object_t *param; @@ -1806,132 +1802,131 @@ ucl_load_handler (const unsigned char *data, size_t len, /* Process arguments */ if (args != NULL && args->type == UCL_OBJECT) { - while ((param = ucl_object_iterate (args, &it, true)) != NULL) { + while ((param = ucl_object_iterate(args, &it, true)) != NULL) { if (param->type == UCL_BOOLEAN) { - if (strncmp (param->key, "try", param->keylen) == 0) { - try_load = ucl_object_toboolean (param); + if (strncmp(param->key, "try", param->keylen) == 0) { + try_load = ucl_object_toboolean(param); } - else if (strncmp (param->key, "multiline", param->keylen) == 0) { - multiline = ucl_object_toboolean (param); + else if (strncmp(param->key, "multiline", param->keylen) == 0) { + multiline = ucl_object_toboolean(param); } - else if (strncmp (param->key, "escape", param->keylen) == 0) { - test = ucl_object_toboolean (param); + else if (strncmp(param->key, "escape", param->keylen) == 0) { + test = ucl_object_toboolean(param); if (test) { flags |= UCL_STRING_ESCAPE; } } - else if (strncmp (param->key, "trim", param->keylen) == 0) { - test = ucl_object_toboolean (param); + else if (strncmp(param->key, "trim", param->keylen) == 0) { + test = ucl_object_toboolean(param); if (test) { flags |= UCL_STRING_TRIM; } } } else if (param->type == UCL_STRING) { - if (strncmp (param->key, "key", param->keylen) == 0) { - prefix = ucl_object_tostring (param); + if (strncmp(param->key, "key", param->keylen) == 0) { + prefix = ucl_object_tostring(param); } - else if (strncmp (param->key, "target", param->keylen) == 0) { - target = ucl_object_tostring (param); + else if (strncmp(param->key, "target", param->keylen) == 0) { + target = ucl_object_tostring(param); } } else if (param->type == UCL_INT) { - if (strncmp (param->key, "priority", param->keylen) == 0) { - priority = ucl_object_toint (param); + if (strncmp(param->key, "priority", param->keylen) == 0) { + priority = ucl_object_toint(param); } } } } - if (prefix == NULL || strlen (prefix) == 0) { - ucl_create_err (&parser->err, "No Key specified in load macro"); + if (prefix == NULL || strlen(prefix) == 0) { + ucl_create_err(&parser->err, "No Key specified in load macro"); return false; } if (len > 0) { - load_file = malloc (len + 1); + load_file = malloc(len + 1); if (!load_file) { - ucl_create_err (&parser->err, "cannot allocate memory for suffix"); + ucl_create_err(&parser->err, "cannot allocate memory for suffix"); return false; } - snprintf (load_file, len + 1, "%.*s", (int)len, data); + snprintf(load_file, len + 1, "%.*s", (int) len, data); - if (!ucl_fetch_file (load_file, &buf, &buflen, &parser->err, - !try_load)) { - free (load_file); + if (!ucl_fetch_file(load_file, &buf, &buflen, &parser->err, + !try_load)) { + free(load_file); if (try_load) { - ucl_parser_clear_error (parser); + ucl_parser_clear_error(parser); } return (try_load || false); } - free (load_file); + free(load_file); container = parser->stack->obj; - old_obj = __DECONST (ucl_object_t *, ucl_object_lookup (container, - prefix)); + old_obj = __DECONST(ucl_object_t *, ucl_object_lookup(container, + prefix)); if (old_obj != NULL) { - ucl_create_err (&parser->err, "Key %s already exists", prefix); + ucl_create_err(&parser->err, "Key %s already exists", prefix); if (buf) { - ucl_munmap (buf, buflen); + ucl_munmap(buf, buflen); } return false; } - if (strcasecmp (target, "string") == 0) { - obj = ucl_object_fromstring_common (buf, buflen, flags); - ucl_copy_value_trash (obj); + if (strcasecmp(target, "string") == 0) { + obj = ucl_object_fromstring_common(buf, buflen, flags); + ucl_copy_value_trash(obj); if (multiline) { obj->flags |= UCL_OBJECT_MULTILINE; } } - else if (strcasecmp (target, "int") == 0) { - tmp = malloc (buflen + 1); + else if (strcasecmp(target, "int") == 0) { + tmp = malloc(buflen + 1); if (tmp == NULL) { - ucl_create_err (&parser->err, "Memory allocation failed"); + ucl_create_err(&parser->err, "Memory allocation failed"); if (buf) { - ucl_munmap (buf, buflen); + ucl_munmap(buf, buflen); } return false; } - snprintf (tmp, buflen + 1, "%.*s", (int)buflen, buf); - iv = strtoll (tmp, NULL, 10); - obj = ucl_object_fromint (iv); - free (tmp); + snprintf(tmp, buflen + 1, "%.*s", (int) buflen, buf); + iv = strtoll(tmp, NULL, 10); + obj = ucl_object_fromint(iv); + free(tmp); } if (buf) { - ucl_munmap (buf, buflen); + ucl_munmap(buf, buflen); } if (obj != NULL) { obj->key = prefix; - obj->keylen = strlen (prefix); - ucl_copy_key_trash (obj); + obj->keylen = strlen(prefix); + ucl_copy_key_trash(obj); obj->prev = obj; obj->next = NULL; - ucl_object_set_priority (obj, priority); - ucl_object_insert_key (container, obj, obj->key, obj->keylen, false); + ucl_object_set_priority(obj, priority); + ucl_object_insert_key(container, obj, obj->key, obj->keylen, false); } return true; } - ucl_create_err (&parser->err, "Unable to parse load macro"); + ucl_create_err(&parser->err, "Unable to parse load macro"); return false; } -bool -ucl_inherit_handler (const unsigned char *data, size_t len, - const ucl_object_t *args, const ucl_object_t *ctx, void* ud) +bool ucl_inherit_handler(const unsigned char *data, size_t len, + const ucl_object_t *args, const ucl_object_t *ctx, void *ud) { const ucl_object_t *parent, *cur; ucl_object_t *target, *copy; @@ -1939,192 +1934,185 @@ ucl_inherit_handler (const unsigned char *data, size_t len, bool replace = false; struct ucl_parser *parser = ud; - parent = ucl_object_lookup_len (ctx, data, len); + parent = ucl_object_lookup_len(ctx, data, len); /* Some sanity checks */ - if (parent == NULL || ucl_object_type (parent) != UCL_OBJECT) { - ucl_create_err (&parser->err, "Unable to find inherited object %.*s", - (int)len, data); + if (parent == NULL || ucl_object_type(parent) != UCL_OBJECT) { + ucl_create_err(&parser->err, "Unable to find inherited object %.*s", + (int) len, data); return false; } if (parser->stack == NULL || parser->stack->obj == NULL || - ucl_object_type (parser->stack->obj) != UCL_OBJECT) { - ucl_create_err (&parser->err, "Invalid inherit context"); + ucl_object_type(parser->stack->obj) != UCL_OBJECT) { + ucl_create_err(&parser->err, "Invalid inherit context"); return false; } target = parser->stack->obj; - if (args && (cur = ucl_object_lookup (args, "replace")) != NULL) { - replace = ucl_object_toboolean (cur); + if (args && (cur = ucl_object_lookup(args, "replace")) != NULL) { + replace = ucl_object_toboolean(cur); } - while ((cur = ucl_object_iterate (parent, &it, true))) { + while ((cur = ucl_object_iterate(parent, &it, true))) { /* We do not replace existing keys */ - if (!replace && ucl_object_lookup_len (target, cur->key, cur->keylen)) { + if (!replace && ucl_object_lookup_len(target, cur->key, cur->keylen)) { continue; } - copy = ucl_object_copy (cur); + copy = ucl_object_copy(cur); if (!replace) { copy->flags |= UCL_OBJECT_INHERITED; } - ucl_object_insert_key (target, copy, copy->key, - copy->keylen, false); + ucl_object_insert_key(target, copy, copy->key, + copy->keylen, false); } return true; } -bool -ucl_parser_set_filevars (struct ucl_parser *parser, const char *filename, bool need_expand) +bool ucl_parser_set_filevars(struct ucl_parser *parser, const char *filename, bool need_expand) { char realbuf[PATH_MAX], *curdir; if (filename != NULL) { if (need_expand) { - if (ucl_realpath (filename, realbuf) == NULL) { + if (ucl_realpath(filename, realbuf) == NULL) { return false; } } else { - ucl_strlcpy (realbuf, filename, sizeof (realbuf)); + ucl_strlcpy(realbuf, filename, sizeof(realbuf)); } if (parser->cur_file) { - free (parser->cur_file); + UCL_FREE(strlen(parser->cur_file) + 1, parser->cur_file); } - parser->cur_file = strdup (realbuf); + parser->cur_file = UCL_STRDUP(realbuf); /* Define variables */ - ucl_parser_register_variable (parser, "FILENAME", realbuf); - curdir = dirname (realbuf); - ucl_parser_register_variable (parser, "CURDIR", curdir); + ucl_parser_register_variable(parser, "FILENAME", realbuf); + curdir = dirname(realbuf); + ucl_parser_register_variable(parser, "CURDIR", curdir); } else { /* Set everything from the current dir */ - curdir = getcwd (realbuf, sizeof (realbuf)); - ucl_parser_register_variable (parser, "FILENAME", "undef"); - ucl_parser_register_variable (parser, "CURDIR", curdir); + curdir = getcwd(realbuf, sizeof(realbuf)); + ucl_parser_register_variable(parser, "FILENAME", "undef"); + ucl_parser_register_variable(parser, "CURDIR", curdir); } return true; } -bool -ucl_parser_add_file_full (struct ucl_parser *parser, const char *filename, - unsigned priority, enum ucl_duplicate_strategy strat, - enum ucl_parse_type parse_type) +bool ucl_parser_add_file_full(struct ucl_parser *parser, const char *filename, + unsigned priority, enum ucl_duplicate_strategy strat, + enum ucl_parse_type parse_type) { unsigned char *buf; size_t len; bool ret; char realbuf[PATH_MAX]; - if (ucl_realpath (filename, realbuf) == NULL) { - ucl_create_err (&parser->err, "cannot open file %s: %s", - filename, - strerror (errno)); + if (ucl_realpath(filename, realbuf) == NULL) { + ucl_create_err(&parser->err, "cannot open file %s: %s", + filename, + strerror(errno)); return false; } - if (!ucl_fetch_file (realbuf, &buf, &len, &parser->err, true)) { + if (!ucl_fetch_file(realbuf, &buf, &len, &parser->err, true)) { return false; } - ucl_parser_set_filevars (parser, realbuf, false); - ret = ucl_parser_add_chunk_full (parser, buf, len, priority, strat, - parse_type); + ucl_parser_set_filevars(parser, realbuf, false); + ret = ucl_parser_add_chunk_full(parser, buf, len, priority, strat, + parse_type); if (len > 0) { - ucl_munmap (buf, len); + ucl_munmap(buf, len); } return ret; } -bool -ucl_parser_add_file_priority (struct ucl_parser *parser, const char *filename, - unsigned priority) +bool ucl_parser_add_file_priority(struct ucl_parser *parser, const char *filename, + unsigned priority) { if (parser == NULL) { return false; } return ucl_parser_add_file_full(parser, filename, priority, - UCL_DUPLICATE_APPEND, UCL_PARSE_UCL); + UCL_DUPLICATE_APPEND, UCL_PARSE_UCL); } -bool -ucl_parser_add_file (struct ucl_parser *parser, const char *filename) +bool ucl_parser_add_file(struct ucl_parser *parser, const char *filename) { if (parser == NULL) { return false; } return ucl_parser_add_file_full(parser, filename, - parser->default_priority, UCL_DUPLICATE_APPEND, - UCL_PARSE_UCL); + parser->default_priority, UCL_DUPLICATE_APPEND, + UCL_PARSE_UCL); } -bool -ucl_parser_add_fd_full (struct ucl_parser *parser, int fd, - unsigned priority, enum ucl_duplicate_strategy strat, - enum ucl_parse_type parse_type) +bool ucl_parser_add_fd_full(struct ucl_parser *parser, int fd, + unsigned priority, enum ucl_duplicate_strategy strat, + enum ucl_parse_type parse_type) { unsigned char *buf; size_t len; bool ret; struct stat st; - if (fstat (fd, &st) == -1) { - ucl_create_err (&parser->err, "cannot stat fd %d: %s", - fd, strerror (errno)); + if (fstat(fd, &st) == -1) { + ucl_create_err(&parser->err, "cannot stat fd %d: %s", + fd, strerror(errno)); return false; } if (st.st_size == 0) { return true; } - if ((buf = ucl_mmap (NULL, st.st_size, PROT_READ, MAP_SHARED, fd, 0)) == MAP_FAILED) { - ucl_create_err (&parser->err, "cannot mmap fd %d: %s", - fd, strerror (errno)); + if ((buf = ucl_mmap(NULL, st.st_size, PROT_READ, MAP_SHARED, fd, 0)) == MAP_FAILED) { + ucl_create_err(&parser->err, "cannot mmap fd %d: %s", + fd, strerror(errno)); return false; } if (parser->cur_file) { - free (parser->cur_file); + UCL_FREE(strlen(parser->cur_file) + 1, parser->cur_file); } parser->cur_file = NULL; len = st.st_size; - ret = ucl_parser_add_chunk_full (parser, buf, len, priority, strat, - parse_type); + ret = ucl_parser_add_chunk_full(parser, buf, len, priority, strat, + parse_type); if (len > 0) { - ucl_munmap (buf, len); + ucl_munmap(buf, len); } return ret; } -bool -ucl_parser_add_fd_priority (struct ucl_parser *parser, int fd, - unsigned priority) +bool ucl_parser_add_fd_priority(struct ucl_parser *parser, int fd, + unsigned priority) { if (parser == NULL) { return false; } return ucl_parser_add_fd_full(parser, fd, parser->default_priority, - UCL_DUPLICATE_APPEND, UCL_PARSE_UCL); + UCL_DUPLICATE_APPEND, UCL_PARSE_UCL); } -bool -ucl_parser_add_fd (struct ucl_parser *parser, int fd) +bool ucl_parser_add_fd(struct ucl_parser *parser, int fd) { if (parser == NULL) { return false; @@ -2134,7 +2122,7 @@ ucl_parser_add_fd (struct ucl_parser *parser, int fd) } size_t -ucl_strlcpy (char *dst, const char *src, size_t siz) +ucl_strlcpy(char *dst, const char *src, size_t siz) { char *d = dst; const char *s = src; @@ -2153,20 +2141,20 @@ ucl_strlcpy (char *dst, const char *src, size_t siz) *d = '\0'; } - return (s - src - 1); /* count does not include NUL */ + return (s - src - 1); /* count does not include NUL */ } size_t -ucl_strlcpy_unsafe (char *dst, const char *src, size_t siz) +ucl_strlcpy_unsafe(char *dst, const char *src, size_t siz) { - memcpy (dst, src, siz - 1); + memcpy(dst, src, siz - 1); dst[siz - 1] = '\0'; return siz - 1; } size_t -ucl_strlcpy_tolower (char *dst, const char *src, size_t siz) +ucl_strlcpy_tolower(char *dst, const char *src, size_t siz) { char *d = dst; const char *s = src; @@ -2175,7 +2163,7 @@ ucl_strlcpy_tolower (char *dst, const char *src, size_t siz) /* Copy as many bytes as will fit */ if (n != 0) { while (--n != 0) { - if ((*d++ = tolower (*s++)) == '\0') { + if ((*d++ = tolower(*s++)) == '\0') { break; } } @@ -2185,56 +2173,56 @@ ucl_strlcpy_tolower (char *dst, const char *src, size_t siz) *d = '\0'; } - return (s - src); /* count does not include NUL */ + return (s - src); /* count does not include NUL */ } /* * Find the first occurrence of find in s */ char * -ucl_strnstr (const char *s, const char *find, int len) +ucl_strnstr(const char *s, const char *find, int len) { char c, sc; int mlen; if ((c = *find++) != 0) { - mlen = strlen (find); + mlen = strlen(find); do { do { if ((sc = *s++) == 0 || len-- < mlen) return (NULL); } while (sc != c); - } while (strncmp (s, find, mlen) != 0); + } while (strncmp(s, find, mlen) != 0); s--; } - return ((char *)s); + return ((char *) s); } /* * Find the first occurrence of find in s, ignore case. */ char * -ucl_strncasestr (const char *s, const char *find, int len) +ucl_strncasestr(const char *s, const char *find, int len) { char c, sc; int mlen; if ((c = *find++) != 0) { - c = tolower (c); - mlen = strlen (find); + c = tolower(c); + mlen = strlen(find); do { do { if ((sc = *s++) == 0 || len-- == 0) return (NULL); - } while (tolower (sc) != c); - } while (strncasecmp (s, find, mlen) != 0); + } while (tolower(sc) != c); + } while (strncasecmp(s, find, mlen) != 0); s--; } - return ((char *)s); + return ((char *) s); } ucl_object_t * -ucl_object_fromstring_common (const char *str, size_t len, enum ucl_string_flags flags) +ucl_object_fromstring_common(const char *str, size_t len, enum ucl_string_flags flags) { ucl_object_t *obj; const char *start, *end, *p, *pos; @@ -2245,25 +2233,25 @@ ucl_object_fromstring_common (const char *str, size_t len, enum ucl_string_flags return NULL; } - obj = ucl_object_new (); + obj = ucl_object_new(); if (obj) { if (len == 0) { - len = strlen (str); + len = strlen(str); } if (flags & UCL_STRING_TRIM) { /* Skip leading spaces */ - for (start = str; (size_t)(start - str) < len; start ++) { - if (!ucl_test_character (*start, UCL_CHARACTER_WHITESPACE_UNSAFE)) { + for (start = str; (size_t) (start - str) < len; start++) { + if (!ucl_test_character(*start, UCL_CHARACTER_WHITESPACE_UNSAFE)) { break; } } /* Skip trailing spaces */ - for (end = str + len - 1; end > start; end --) { - if (!ucl_test_character (*end, UCL_CHARACTER_WHITESPACE_UNSAFE)) { + for (end = str + len - 1; end > start; end--) { + if (!ucl_test_character(*end, UCL_CHARACTER_WHITESPACE_UNSAFE)) { break; } } - end ++; + end++; } else { start = str; @@ -2272,8 +2260,8 @@ ucl_object_fromstring_common (const char *str, size_t len, enum ucl_string_flags obj->type = UCL_STRING; if (flags & UCL_STRING_ESCAPE) { - for (p = start, escaped_len = 0; p < end; p ++, escaped_len ++) { - if (ucl_test_character (*p, UCL_CHARACTER_JSON_UNSAFE | UCL_CHARACTER_WHITESPACE_UNSAFE)) { + for (p = start, escaped_len = 0; p < end; p++, escaped_len++) { + if (ucl_test_character(*p, UCL_CHARACTER_JSON_UNSAFE | UCL_CHARACTER_WHITESPACE_UNSAFE)) { switch (*p) { case '\v': case '\0': @@ -2282,15 +2270,15 @@ ucl_object_fromstring_common (const char *str, size_t len, enum ucl_string_flags case ' ': break; default: - escaped_len ++; + escaped_len++; break; } } } - dst = malloc (escaped_len + 1); + dst = malloc(escaped_len + 1); if (dst != NULL) { - for (p = start, d = dst; p < end; p ++, d ++) { - if (ucl_test_character (*p, UCL_CHARACTER_JSON_UNSAFE | UCL_CHARACTER_WHITESPACE_UNSAFE)) { + for (p = start, d = dst; p < end; p++, d++) { + if (ucl_test_character(*p, UCL_CHARACTER_JSON_UNSAFE | UCL_CHARACTER_WHITESPACE_UNSAFE)) { switch (*p) { case '\n': *d++ = '\\'; @@ -2318,7 +2306,7 @@ ucl_object_fromstring_common (const char *str, size_t len, enum ucl_string_flags *d++ = '0'; *d++ = '0'; *d++ = '0'; - *d = '0'; + *d = '0'; break; case '\v': *d++ = '\\'; @@ -2326,7 +2314,7 @@ ucl_object_fromstring_common (const char *str, size_t len, enum ucl_string_flags *d++ = '0'; *d++ = '0'; *d++ = '0'; - *d = 'B'; + *d = 'B'; break; case '\\': *d++ = '\\'; @@ -2352,9 +2340,9 @@ ucl_object_fromstring_common (const char *str, size_t len, enum ucl_string_flags } } else { - dst = malloc (end - start + 1); + dst = malloc(end - start + 1); if (dst != NULL) { - ucl_strlcpy_unsafe (dst, start, end - start + 1); + ucl_strlcpy_unsafe(dst, start, end - start + 1); obj->value.sv = dst; obj->trash_stack[UCL_TRASH_VALUE] = dst; obj->len = end - start; @@ -2363,18 +2351,18 @@ ucl_object_fromstring_common (const char *str, size_t len, enum ucl_string_flags if ((flags & UCL_STRING_PARSE) && dst != NULL) { /* Parse what we have */ if (flags & UCL_STRING_PARSE_BOOLEAN) { - if (!ucl_maybe_parse_boolean (obj, dst, obj->len) && (flags & UCL_STRING_PARSE_NUMBER)) { - ucl_maybe_parse_number (obj, dst, dst + obj->len, &pos, - flags & UCL_STRING_PARSE_DOUBLE, - flags & UCL_STRING_PARSE_BYTES, - flags & UCL_STRING_PARSE_TIME); + if (!ucl_maybe_parse_boolean(obj, dst, obj->len) && (flags & UCL_STRING_PARSE_NUMBER)) { + ucl_maybe_parse_number(obj, dst, dst + obj->len, &pos, + flags & UCL_STRING_PARSE_DOUBLE, + flags & UCL_STRING_PARSE_BYTES, + flags & UCL_STRING_PARSE_TIME); } } else { - ucl_maybe_parse_number (obj, dst, dst + obj->len, &pos, - flags & UCL_STRING_PARSE_DOUBLE, - flags & UCL_STRING_PARSE_BYTES, - flags & UCL_STRING_PARSE_TIME); + ucl_maybe_parse_number(obj, dst, dst + obj->len, &pos, + flags & UCL_STRING_PARSE_DOUBLE, + flags & UCL_STRING_PARSE_BYTES, + flags & UCL_STRING_PARSE_TIME); } } } @@ -2383,8 +2371,8 @@ ucl_object_fromstring_common (const char *str, size_t len, enum ucl_string_flags } static bool -ucl_object_insert_key_common (ucl_object_t *top, ucl_object_t *elt, - const char *key, size_t keylen, bool copy_key, bool merge, bool replace) +ucl_object_insert_key_common(ucl_object_t *top, ucl_object_t *elt, + const char *key, size_t keylen, bool copy_key, bool merge, bool replace) { ucl_object_t *found, *tmp; const ucl_object_t *cur; @@ -2412,15 +2400,15 @@ ucl_object_insert_key_common (ucl_object_t *top, ucl_object_t *elt, } if (top->value.ov == NULL) { - top->value.ov = ucl_hash_create (false); + top->value.ov = ucl_hash_create(false); } if (keylen == 0) { - keylen = strlen (key); + keylen = strlen(key); } - for (p = key; p < key + keylen; p ++) { - if (ucl_test_character (*p, UCL_CHARACTER_UCL_UNSAFE)) { + for (p = key; p < key + keylen; p++) { + if (ucl_test_character(*p, UCL_CHARACTER_UCL_UNSAFE)) { elt->flags |= UCL_OBJECT_NEED_KEY_ESCAPE; break; } @@ -2428,9 +2416,9 @@ ucl_object_insert_key_common (ucl_object_t *top, ucl_object_t *elt, /* workaround for some use cases */ if (elt->trash_stack[UCL_TRASH_KEY] != NULL && - key != (const char *)elt->trash_stack[UCL_TRASH_KEY]) { + key != (const char *) elt->trash_stack[UCL_TRASH_KEY]) { /* Remove copied key */ - free (elt->trash_stack[UCL_TRASH_KEY]); + free(elt->trash_stack[UCL_TRASH_KEY]); elt->trash_stack[UCL_TRASH_KEY] = NULL; elt->flags &= ~UCL_OBJECT_ALLOCATED_KEY; } @@ -2439,60 +2427,59 @@ ucl_object_insert_key_common (ucl_object_t *top, ucl_object_t *elt, elt->keylen = keylen; if (copy_key) { - ucl_copy_key_trash (elt); + ucl_copy_key_trash(elt); } - found = __DECONST (ucl_object_t *, ucl_hash_search_obj (top->value.ov, elt)); + found = __DECONST(ucl_object_t *, ucl_hash_search_obj(top->value.ov, elt)); if (found == NULL) { - top->value.ov = ucl_hash_insert_object (top->value.ov, elt, false); - top->len ++; + top->value.ov = ucl_hash_insert_object(top->value.ov, elt, false); + top->len++; if (replace) { ret = false; } } else { if (replace) { - ucl_hash_replace (top->value.ov, found, elt); - ucl_object_unref (found); + ucl_hash_replace(top->value.ov, found, elt); + ucl_object_unref(found); } else if (merge) { if (found->type != UCL_OBJECT && elt->type == UCL_OBJECT) { /* Insert old elt to new one */ - ucl_object_insert_key_common (elt, found, found->key, - found->keylen, copy_key, false, false); - ucl_hash_delete (top->value.ov, found); - top->value.ov = ucl_hash_insert_object (top->value.ov, elt, false); + ucl_object_insert_key_common(elt, found, found->key, + found->keylen, copy_key, false, false); + ucl_hash_delete(top->value.ov, found); + top->value.ov = ucl_hash_insert_object(top->value.ov, elt, false); } else if (found->type == UCL_OBJECT && elt->type != UCL_OBJECT) { /* Insert new to old */ - ucl_object_insert_key_common (found, elt, elt->key, - elt->keylen, copy_key, false, false); + ucl_object_insert_key_common(found, elt, elt->key, + elt->keylen, copy_key, false, false); } else if (found->type == UCL_OBJECT && elt->type == UCL_OBJECT) { /* Mix two hashes */ - while ((cur = ucl_object_iterate (elt, &it, true)) != NULL) { - tmp = ucl_object_ref (cur); - ucl_object_insert_key_common (found, tmp, cur->key, - cur->keylen, copy_key, true, false); + while ((cur = ucl_object_iterate(elt, &it, true)) != NULL) { + tmp = ucl_object_ref(cur); + ucl_object_insert_key_common(found, tmp, cur->key, + cur->keylen, copy_key, true, false); } - ucl_object_unref (elt); + ucl_object_unref(elt); } else { /* Just make a list of scalars */ - DL_CONCAT (found, elt); + DL_CONCAT(found, elt); } } else { - DL_CONCAT (found, elt); + DL_CONCAT(found, elt); } } return ret; } -bool -ucl_object_delete_keyl (ucl_object_t *top, const char *key, size_t keylen) +bool ucl_object_delete_keyl(ucl_object_t *top, const char *key, size_t keylen) { ucl_object_t *found; @@ -2500,73 +2487,68 @@ ucl_object_delete_keyl (ucl_object_t *top, const char *key, size_t keylen) return false; } - found = __DECONST (ucl_object_t *, ucl_object_lookup_len (top, key, keylen)); + found = __DECONST(ucl_object_t *, ucl_object_lookup_len(top, key, keylen)); if (found == NULL) { return false; } - ucl_hash_delete (top->value.ov, found); - ucl_object_unref (found); - top->len --; + ucl_hash_delete(top->value.ov, found); + ucl_object_unref(found); + top->len--; return true; } -bool -ucl_object_delete_key (ucl_object_t *top, const char *key) +bool ucl_object_delete_key(ucl_object_t *top, const char *key) { - return ucl_object_delete_keyl (top, key, strlen (key)); + return ucl_object_delete_keyl(top, key, strlen(key)); } -ucl_object_t* -ucl_object_pop_keyl (ucl_object_t *top, const char *key, size_t keylen) +ucl_object_t * +ucl_object_pop_keyl(ucl_object_t *top, const char *key, size_t keylen) { const ucl_object_t *found; if (top == NULL || key == NULL) { return false; } - found = ucl_object_lookup_len (top, key, keylen); + found = ucl_object_lookup_len(top, key, keylen); if (found == NULL) { return NULL; } - ucl_hash_delete (top->value.ov, found); - top->len --; + ucl_hash_delete(top->value.ov, found); + top->len--; - return __DECONST (ucl_object_t *, found); + return __DECONST(ucl_object_t *, found); } -ucl_object_t* -ucl_object_pop_key (ucl_object_t *top, const char *key) +ucl_object_t * +ucl_object_pop_key(ucl_object_t *top, const char *key) { - return ucl_object_pop_keyl (top, key, strlen (key)); + return ucl_object_pop_keyl(top, key, strlen(key)); } -bool -ucl_object_insert_key (ucl_object_t *top, ucl_object_t *elt, - const char *key, size_t keylen, bool copy_key) +bool ucl_object_insert_key(ucl_object_t *top, ucl_object_t *elt, + const char *key, size_t keylen, bool copy_key) { - return ucl_object_insert_key_common (top, elt, key, keylen, copy_key, false, false); + return ucl_object_insert_key_common(top, elt, key, keylen, copy_key, false, false); } -bool -ucl_object_insert_key_merged (ucl_object_t *top, ucl_object_t *elt, - const char *key, size_t keylen, bool copy_key) +bool ucl_object_insert_key_merged(ucl_object_t *top, ucl_object_t *elt, + const char *key, size_t keylen, bool copy_key) { - return ucl_object_insert_key_common (top, elt, key, keylen, copy_key, true, false); + return ucl_object_insert_key_common(top, elt, key, keylen, copy_key, true, false); } -bool -ucl_object_replace_key (ucl_object_t *top, ucl_object_t *elt, - const char *key, size_t keylen, bool copy_key) +bool ucl_object_replace_key(ucl_object_t *top, ucl_object_t *elt, + const char *key, size_t keylen, bool copy_key) { - return ucl_object_insert_key_common (top, elt, key, keylen, copy_key, false, true); + return ucl_object_insert_key_common(top, elt, key, keylen, copy_key, false, true); } -bool -ucl_object_merge (ucl_object_t *top, ucl_object_t *elt, bool copy) +bool ucl_object_merge(ucl_object_t *top, ucl_object_t *elt, bool copy) { ucl_object_t *cur = NULL, *cp = NULL, *found = NULL; ucl_object_iter_t iter = NULL; @@ -2578,16 +2560,16 @@ ucl_object_merge (ucl_object_t *top, ucl_object_t *elt, bool copy) if (top->type == UCL_ARRAY) { if (elt->type == UCL_ARRAY) { /* Merge two arrays */ - return ucl_array_merge (top, elt, copy); + return ucl_array_merge(top, elt, copy); } else { if (copy) { - ucl_array_append (top, ucl_object_copy (elt)); + ucl_array_append(top, ucl_object_copy(elt)); return true; } else { - ucl_array_append (top, ucl_object_ref (elt)); + ucl_array_append(top, ucl_object_ref(elt)); return true; } @@ -2596,67 +2578,68 @@ ucl_object_merge (ucl_object_t *top, ucl_object_t *elt, bool copy) else if (top->type == UCL_OBJECT) { if (elt->type == UCL_OBJECT) { /* Mix two hashes */ - while ((cur = (ucl_object_t *) ucl_hash_iterate (elt->value.ov, - &iter))) { + while ((cur = (ucl_object_t *) ucl_hash_iterate(elt->value.ov, + &iter))) { if (copy) { - cp = ucl_object_copy (cur); - } else { - cp = ucl_object_ref (cur); + cp = ucl_object_copy(cur); + } + else { + cp = ucl_object_ref(cur); } found = __DECONST(ucl_object_t *, - ucl_hash_search (top->value.ov, cp->key, cp->keylen)); + ucl_hash_search(top->value.ov, cp->key, cp->keylen)); if (found == NULL) { /* The key does not exist */ - top->value.ov = ucl_hash_insert_object (top->value.ov, cp, - false); + top->value.ov = ucl_hash_insert_object(top->value.ov, cp, + false); top->len++; } else { /* The key already exists, merge it recursively */ if (found->type == UCL_OBJECT || found->type == UCL_ARRAY) { - if (!ucl_object_merge (found, cp, copy)) { + if (!ucl_object_merge(found, cp, copy)) { return false; } - ucl_object_unref (cp); + ucl_object_unref(cp); } else { - ucl_hash_replace (top->value.ov, found, cp); - ucl_object_unref (found); + ucl_hash_replace(top->value.ov, found, cp); + ucl_object_unref(found); } } } } else { if (copy) { - cp = ucl_object_copy (elt); + cp = ucl_object_copy(elt); } else { - cp = ucl_object_ref (elt); + cp = ucl_object_ref(elt); } found = __DECONST(ucl_object_t *, - ucl_hash_search (top->value.ov, cp->key, cp->keylen)); + ucl_hash_search(top->value.ov, cp->key, cp->keylen)); if (found == NULL) { /* The key does not exist */ - top->value.ov = ucl_hash_insert_object (top->value.ov, cp, - false); + top->value.ov = ucl_hash_insert_object(top->value.ov, cp, + false); top->len++; } else { /* The key already exists, merge it recursively */ if (found->type == UCL_OBJECT || found->type == UCL_ARRAY) { - if (!ucl_object_merge (found, cp, copy)) { + if (!ucl_object_merge(found, cp, copy)) { return false; } - ucl_object_unref (cp); + ucl_object_unref(cp); } else { - ucl_hash_replace (top->value.ov, found, cp); - ucl_object_unref (found); + ucl_hash_replace(top->value.ov, found, cp); + ucl_object_unref(found); } } } @@ -2670,7 +2653,7 @@ ucl_object_merge (ucl_object_t *top, ucl_object_t *elt, bool copy) } const ucl_object_t * -ucl_object_lookup_len (const ucl_object_t *obj, const char *key, size_t klen) +ucl_object_lookup_len(const ucl_object_t *obj, const char *key, size_t klen) { const ucl_object_t *ret; ucl_object_t srch; @@ -2681,24 +2664,24 @@ ucl_object_lookup_len (const ucl_object_t *obj, const char *key, size_t klen) srch.key = key; srch.keylen = klen; - ret = ucl_hash_search_obj (obj->value.ov, &srch); + ret = ucl_hash_search_obj(obj->value.ov, &srch); return ret; } const ucl_object_t * -ucl_object_lookup (const ucl_object_t *obj, const char *key) +ucl_object_lookup(const ucl_object_t *obj, const char *key) { if (key == NULL) { return NULL; } - return ucl_object_lookup_len (obj, key, strlen (key)); + return ucl_object_lookup_len(obj, key, strlen(key)); } -const ucl_object_t* -ucl_object_lookup_any (const ucl_object_t *obj, - const char *key, ...) +const ucl_object_t * +ucl_object_lookup_any(const ucl_object_t *obj, + const char *key, ...) { va_list ap; const ucl_object_t *ret = NULL; @@ -2708,31 +2691,31 @@ ucl_object_lookup_any (const ucl_object_t *obj, return NULL; } - ret = ucl_object_lookup_len (obj, key, strlen (key)); + ret = ucl_object_lookup_len(obj, key, strlen(key)); if (ret == NULL) { - va_start (ap, key); + va_start(ap, key); while (ret == NULL) { - nk = va_arg (ap, const char *); + nk = va_arg(ap, const char *); if (nk == NULL) { break; } else { - ret = ucl_object_lookup_len (obj, nk, strlen (nk)); + ret = ucl_object_lookup_len(obj, nk, strlen(nk)); } } - va_end (ap); + va_end(ap); } return ret; } -const ucl_object_t* -ucl_object_iterate_with_error (const ucl_object_t *obj, ucl_object_iter_t *iter, bool expand_values, - int *ep) +const ucl_object_t * +ucl_object_iterate_with_error(const ucl_object_t *obj, ucl_object_iter_t *iter, bool expand_values, + int *ep) { const ucl_object_t *elt = NULL; @@ -2743,22 +2726,22 @@ ucl_object_iterate_with_error (const ucl_object_t *obj, ucl_object_iter_t *iter, if (expand_values) { switch (obj->type) { case UCL_OBJECT: - return (const ucl_object_t*)ucl_hash_iterate2 (obj->value.ov, iter, ep); + return (const ucl_object_t *) ucl_hash_iterate2(obj->value.ov, iter, ep); break; case UCL_ARRAY: { unsigned int idx; - UCL_ARRAY_GET (vec, obj); - idx = (unsigned int)(uintptr_t)(*iter); + UCL_ARRAY_GET(vec, obj); + idx = (unsigned int) (uintptr_t) (*iter); if (vec != NULL) { - while (idx < kv_size (*vec)) { - if ((elt = kv_A (*vec, idx)) != NULL) { - idx ++; + while (idx < kv_size(*vec)) { + if ((elt = kv_A(*vec, idx)) != NULL) { + idx++; break; } - idx ++; + idx++; } - *iter = (void *)(uintptr_t)idx; + *iter = (void *) (uintptr_t) idx; } return elt; @@ -2777,7 +2760,7 @@ ucl_object_iterate_with_error (const ucl_object_t *obj, ucl_object_iter_t *iter, else if (elt == obj) { return NULL; } - *iter = __DECONST (void *, elt->next ? elt->next : obj); + *iter = __DECONST(void *, elt->next ? elt->next : obj); return elt; /* Not reached */ @@ -2797,51 +2780,51 @@ struct ucl_object_safe_iter { char magic[4]; /* safety check */ uint32_t flags; const ucl_object_t *impl_it; /* implicit object iteration */ - ucl_object_iter_t expl_it; /* explicit iteration */ + ucl_object_iter_t expl_it; /* explicit iteration */ }; -#define UCL_SAFE_ITER(ptr) (struct ucl_object_safe_iter *)(ptr) -#define UCL_SAFE_ITER_CHECK(it) do { \ - assert (it != NULL); \ - assert (memcmp (it->magic, safe_iter_magic, sizeof (it->magic)) == 0); \ - } while (0) +#define UCL_SAFE_ITER(ptr) (struct ucl_object_safe_iter *) (ptr) +#define UCL_SAFE_ITER_CHECK(it) \ + do { \ + assert(it != NULL); \ + assert(memcmp(it->magic, safe_iter_magic, sizeof(it->magic)) == 0); \ + } while (0) ucl_object_iter_t -ucl_object_iterate_new (const ucl_object_t *obj) +ucl_object_iterate_new(const ucl_object_t *obj) { struct ucl_object_safe_iter *it; - it = UCL_ALLOC (sizeof (*it)); + it = UCL_ALLOC(sizeof(*it)); if (it != NULL) { - memcpy (it->magic, safe_iter_magic, sizeof (it->magic)); + memcpy(it->magic, safe_iter_magic, sizeof(it->magic)); it->flags = UCL_ITERATE_FLAG_UNDEFINED; it->expl_it = NULL; it->impl_it = obj; } - return (ucl_object_iter_t)it; + return (ucl_object_iter_t) it; } -bool -ucl_object_iter_chk_excpn(ucl_object_iter_t *it) +bool ucl_object_iter_chk_excpn(ucl_object_iter_t *it) { - struct ucl_object_safe_iter *rit = UCL_SAFE_ITER (it); + struct ucl_object_safe_iter *rit = UCL_SAFE_ITER(it); - UCL_SAFE_ITER_CHECK (rit); + UCL_SAFE_ITER_CHECK(rit); return (rit->flags == UCL_ITERATE_FLAG_EXCEPTION); } ucl_object_iter_t -ucl_object_iterate_reset (ucl_object_iter_t it, const ucl_object_t *obj) +ucl_object_iterate_reset(ucl_object_iter_t it, const ucl_object_t *obj) { - struct ucl_object_safe_iter *rit = UCL_SAFE_ITER (it); + struct ucl_object_safe_iter *rit = UCL_SAFE_ITER(it); - UCL_SAFE_ITER_CHECK (rit); + UCL_SAFE_ITER_CHECK(rit); if (rit->expl_it != NULL) { if (rit->flags == UCL_ITERATE_FLAG_INSIDE_OBJECT) { - UCL_FREE (sizeof (*rit->expl_it), rit->expl_it); + UCL_FREE(sizeof(*rit->expl_it), rit->expl_it); } } @@ -2852,21 +2835,20 @@ ucl_object_iterate_reset (ucl_object_iter_t it, const ucl_object_t *obj) return it; } -const ucl_object_t* -ucl_object_iterate_safe (ucl_object_iter_t it, bool expand_values) +const ucl_object_t * +ucl_object_iterate_safe(ucl_object_iter_t it, bool expand_values) { - return ucl_object_iterate_full (it, expand_values ? UCL_ITERATE_BOTH : - UCL_ITERATE_IMPLICIT); + return ucl_object_iterate_full(it, expand_values ? UCL_ITERATE_BOTH : UCL_ITERATE_IMPLICIT); } -const ucl_object_t* -ucl_object_iterate_full (ucl_object_iter_t it, enum ucl_iterate_type type) +const ucl_object_t * +ucl_object_iterate_full(ucl_object_iter_t it, enum ucl_iterate_type type) { - struct ucl_object_safe_iter *rit = UCL_SAFE_ITER (it); + struct ucl_object_safe_iter *rit = UCL_SAFE_ITER(it); const ucl_object_t *ret = NULL; int ern; - UCL_SAFE_ITER_CHECK (rit); + UCL_SAFE_ITER_CHECK(rit); if (rit->impl_it == NULL) { return NULL; @@ -2874,7 +2856,7 @@ ucl_object_iterate_full (ucl_object_iter_t it, enum ucl_iterate_type type) if (rit->impl_it->type == UCL_OBJECT) { rit->flags = UCL_ITERATE_FLAG_INSIDE_OBJECT; - ret = ucl_object_iterate_with_error (rit->impl_it, &rit->expl_it, true, &ern); + ret = ucl_object_iterate_with_error(rit->impl_it, &rit->expl_it, true, &ern); if (ret == NULL && ern != 0) { rit->flags = UCL_ITERATE_FLAG_EXCEPTION; @@ -2886,19 +2868,19 @@ ucl_object_iterate_full (ucl_object_iter_t it, enum ucl_iterate_type type) rit->impl_it = rit->impl_it->next; rit->expl_it = NULL; - return ucl_object_iterate_safe (it, type); + return ucl_object_iterate_safe(it, type); } } else if (rit->impl_it->type == UCL_ARRAY) { rit->flags = UCL_ITERATE_FLAG_INSIDE_ARRAY; - ret = ucl_object_iterate (rit->impl_it, &rit->expl_it, true); + ret = ucl_object_iterate(rit->impl_it, &rit->expl_it, true); if (ret == NULL && (type & UCL_ITERATE_IMPLICIT)) { /* Need to switch to another implicit object in chain */ rit->impl_it = rit->impl_it->next; rit->expl_it = NULL; - return ucl_object_iterate_safe (it, type); + return ucl_object_iterate_safe(it, type); } } else { @@ -2910,7 +2892,7 @@ ucl_object_iterate_full (ucl_object_iter_t it, enum ucl_iterate_type type) if (type & UCL_ITERATE_EXPLICIT) { /* We flatten objects if need to expand values */ if (ret->type == UCL_OBJECT || ret->type == UCL_ARRAY) { - return ucl_object_iterate_safe (it, type); + return ucl_object_iterate_safe(it, type); } } } @@ -2918,30 +2900,31 @@ ucl_object_iterate_full (ucl_object_iter_t it, enum ucl_iterate_type type) return ret; } -void -ucl_object_iterate_free (ucl_object_iter_t it) +void ucl_object_iterate_free(ucl_object_iter_t it) { - struct ucl_object_safe_iter *rit = UCL_SAFE_ITER (it); + struct ucl_object_safe_iter *rit = UCL_SAFE_ITER(it); - UCL_SAFE_ITER_CHECK (rit); + UCL_SAFE_ITER_CHECK(rit); if (rit->expl_it != NULL) { if (rit->flags == UCL_ITERATE_FLAG_INSIDE_OBJECT) { - UCL_FREE (sizeof (*rit->expl_it), rit->expl_it); + UCL_FREE(sizeof(*rit->expl_it), rit->expl_it); } } - UCL_FREE (sizeof (*rit), it); + UCL_FREE(sizeof(*rit), it); } const ucl_object_t * -ucl_object_lookup_path (const ucl_object_t *top, const char *path_in) { - return ucl_object_lookup_path_char (top, path_in, '.'); +ucl_object_lookup_path(const ucl_object_t *top, const char *path_in) +{ + return ucl_object_lookup_path_char(top, path_in, '.'); } const ucl_object_t * -ucl_object_lookup_path_char (const ucl_object_t *top, const char *path_in, const char sep) { +ucl_object_lookup_path_char(const ucl_object_t *top, const char *path_in, const char sep) +{ const ucl_object_t *o = NULL, *found; const char *p, *c; char *err_str; @@ -2956,25 +2939,25 @@ ucl_object_lookup_path_char (const ucl_object_t *top, const char *path_in, const /* Skip leading dots */ while (*p == sep) { - p ++; + p++; } c = p; while (*p != '\0') { - p ++; + p++; if (*p == sep || *p == '\0') { if (p > c) { switch (top->type) { case UCL_ARRAY: /* Key should be an int */ - index = strtoul (c, &err_str, 10); + index = strtoul(c, &err_str, 10); if (err_str != NULL && (*err_str != sep && *err_str != '\0')) { return NULL; } - o = ucl_array_find_index (top, index); + o = ucl_array_find_index(top, index); break; default: - o = ucl_object_lookup_len (top, c, p - c); + o = ucl_object_lookup_len(top, c, p - c); break; } if (o == NULL) { @@ -2994,95 +2977,95 @@ ucl_object_lookup_path_char (const ucl_object_t *top, const char *path_in, const ucl_object_t * -ucl_object_new (void) +ucl_object_new(void) { - return ucl_object_typed_new (UCL_NULL); + return ucl_object_typed_new(UCL_NULL); } ucl_object_t * -ucl_object_typed_new (ucl_type_t type) +ucl_object_typed_new(ucl_type_t type) { - return ucl_object_new_full (type, 0); + return ucl_object_new_full(type, 0); } ucl_object_t * -ucl_object_new_full (ucl_type_t type, unsigned priority) +ucl_object_new_full(ucl_type_t type, unsigned priority) { ucl_object_t *new; if (type != UCL_USERDATA) { - new = UCL_ALLOC (sizeof (ucl_object_t)); + new = UCL_ALLOC(sizeof(ucl_object_t)); if (new != NULL) { - memset (new, 0, sizeof (ucl_object_t)); + memset(new, 0, sizeof(ucl_object_t)); new->ref = 1; new->type = (type <= UCL_NULL ? type : UCL_NULL); new->next = NULL; new->prev = new; - ucl_object_set_priority (new, priority); + ucl_object_set_priority(new, priority); if (type == UCL_ARRAY) { - new->value.av = UCL_ALLOC (sizeof (ucl_array_t)); + new->value.av = UCL_ALLOC(sizeof(ucl_array_t)); if (new->value.av) { - memset (new->value.av, 0, sizeof (ucl_array_t)); - UCL_ARRAY_GET (vec, new); + memset(new->value.av, 0, sizeof(ucl_array_t)); + UCL_ARRAY_GET(vec, new); /* Preallocate some space for arrays */ - kv_resize_safe (ucl_object_t *, *vec, 8, enomem); + kv_resize_safe(ucl_object_t *, *vec, 8, enomem); } } } } else { - new = ucl_object_new_userdata (NULL, NULL, NULL); - ucl_object_set_priority (new, priority); + new = ucl_object_new_userdata(NULL, NULL, NULL); + ucl_object_set_priority(new, priority); } enomem: return new; } -bool ucl_object_reserve (ucl_object_t *obj, size_t reserved) +bool ucl_object_reserve(ucl_object_t *obj, size_t reserved) { if (obj->type == UCL_ARRAY) { - UCL_ARRAY_GET (vec, obj); + UCL_ARRAY_GET(vec, obj); if (vec->m < reserved) { /* Preallocate some space for arrays */ - kv_resize_safe (ucl_object_t *, *vec, reserved, e0); + kv_resize_safe(ucl_object_t *, *vec, reserved, e0); } } else if (obj->type == UCL_OBJECT) { - ucl_hash_reserve (obj->value.ov, reserved); + ucl_hash_reserve(obj->value.ov, reserved); } return true; e0: return false; } -ucl_object_t* -ucl_object_new_userdata (ucl_userdata_dtor dtor, - ucl_userdata_emitter emitter, - void *ptr) +ucl_object_t * +ucl_object_new_userdata(ucl_userdata_dtor dtor, + ucl_userdata_emitter emitter, + void *ptr) { struct ucl_object_userdata *new; - size_t nsize = sizeof (*new); + size_t nsize = sizeof(*new); - new = UCL_ALLOC (nsize); + new = UCL_ALLOC(nsize); if (new != NULL) { - memset (new, 0, nsize); + memset(new, 0, nsize); new->obj.ref = 1; new->obj.type = UCL_USERDATA; new->obj.next = NULL; - new->obj.prev = (ucl_object_t *)new; + new->obj.prev = (ucl_object_t *) new; new->dtor = dtor; new->emitter = emitter; new->obj.value.ud = ptr; } - return (ucl_object_t *)new; + return (ucl_object_t *) new; } ucl_type_t -ucl_object_type (const ucl_object_t *obj) +ucl_object_type(const ucl_object_t *obj) { if (obj == NULL) { return UCL_NULL; @@ -3091,24 +3074,24 @@ ucl_object_type (const ucl_object_t *obj) return obj->type; } -ucl_object_t* -ucl_object_fromstring (const char *str) +ucl_object_t * +ucl_object_fromstring(const char *str) { - return ucl_object_fromstring_common (str, 0, UCL_STRING_RAW); + return ucl_object_fromstring_common(str, 0, UCL_STRING_RAW); } ucl_object_t * -ucl_object_fromlstring (const char *str, size_t len) +ucl_object_fromlstring(const char *str, size_t len) { - return ucl_object_fromstring_common (str, len, UCL_STRING_RAW); + return ucl_object_fromstring_common(str, len, UCL_STRING_RAW); } ucl_object_t * -ucl_object_fromint (int64_t iv) +ucl_object_fromint(int64_t iv) { ucl_object_t *obj; - obj = ucl_object_new (); + obj = ucl_object_new(); if (obj != NULL) { obj->type = UCL_INT; obj->value.iv = iv; @@ -3118,11 +3101,11 @@ ucl_object_fromint (int64_t iv) } ucl_object_t * -ucl_object_fromdouble (double dv) +ucl_object_fromdouble(double dv) { ucl_object_t *obj; - obj = ucl_object_new (); + obj = ucl_object_new(); if (obj != NULL) { obj->type = UCL_FLOAT; obj->value.dv = dv; @@ -3131,12 +3114,12 @@ ucl_object_fromdouble (double dv) return obj; } -ucl_object_t* -ucl_object_frombool (bool bv) +ucl_object_t * +ucl_object_frombool(bool bv) { ucl_object_t *obj; - obj = ucl_object_new (); + obj = ucl_object_new(); if (obj != NULL) { obj->type = UCL_BOOLEAN; obj->value.iv = bv; @@ -3145,64 +3128,69 @@ ucl_object_frombool (bool bv) return obj; } -bool -ucl_array_append (ucl_object_t *top, ucl_object_t *elt) +bool ucl_array_append(ucl_object_t *top, ucl_object_t *elt) { - UCL_ARRAY_GET (vec, top); + if (top->type != UCL_ARRAY) { + return false; + } + + UCL_ARRAY_GET(vec, top); if (elt == NULL || top == NULL) { return false; } if (vec == NULL) { - vec = UCL_ALLOC (sizeof (*vec)); + vec = UCL_ALLOC(sizeof(*vec)); if (vec == NULL) { return false; } - kv_init (*vec); - top->value.av = (void *)vec; + kv_init(*vec); + top->value.av = (void *) vec; } - kv_push_safe (ucl_object_t *, *vec, elt, e0); + kv_push_safe(ucl_object_t *, *vec, elt, e0); - top->len ++; + top->len++; return true; e0: return false; } -bool -ucl_array_prepend (ucl_object_t *top, ucl_object_t *elt) +bool ucl_array_prepend(ucl_object_t *top, ucl_object_t *elt) { - UCL_ARRAY_GET (vec, top); + if (top->type != UCL_ARRAY) { + return false; + } + + UCL_ARRAY_GET(vec, top); if (elt == NULL || top == NULL) { return false; } if (vec == NULL) { - vec = UCL_ALLOC (sizeof (*vec)); - kv_init (*vec); - top->value.av = (void *)vec; - kv_push_safe (ucl_object_t *, *vec, elt, e0); + vec = UCL_ALLOC(sizeof(*vec)); + kv_init(*vec); + top->value.av = (void *) vec; + kv_push_safe(ucl_object_t *, *vec, elt, e0); } else { /* Slow O(n) algorithm */ - kv_prepend_safe (ucl_object_t *, *vec, elt, e0); + kv_prepend_safe(ucl_object_t *, *vec, elt, e0); } - top->len ++; + top->len++; return true; e0: return false; } -bool -ucl_array_merge (ucl_object_t *top, ucl_object_t *elt, bool copy) +bool ucl_array_merge(ucl_object_t *top, ucl_object_t *elt, bool copy) { unsigned i; ucl_object_t *cp = NULL; @@ -3213,24 +3201,24 @@ ucl_array_merge (ucl_object_t *top, ucl_object_t *elt, bool copy) } if (copy) { - cp = ucl_object_copy (elt); + cp = ucl_object_copy(elt); } else { - cp = ucl_object_ref (elt); + cp = ucl_object_ref(elt); } - UCL_ARRAY_GET (v1, top); - UCL_ARRAY_GET (v2, cp); + UCL_ARRAY_GET(v1, top); + UCL_ARRAY_GET(v2, cp); if (v1 && v2) { - kv_concat_safe (ucl_object_t *, *v1, *v2, e0); + kv_concat_safe(ucl_object_t *, *v1, *v2, e0); - for (i = v2->n; i < v1->n; i ++) { - obj = &kv_A (*v1, i); + for (i = v2->n; i < v1->n; i++) { + obj = &kv_A(*v1, i); if (*obj == NULL) { continue; } - top->len ++; + top->len++; } } @@ -3240,9 +3228,13 @@ e0: } ucl_object_t * -ucl_array_delete (ucl_object_t *top, ucl_object_t *elt) +ucl_array_delete(ucl_object_t *top, ucl_object_t *elt) { - UCL_ARRAY_GET (vec, top); + if (top->type != UCL_ARRAY) { + return NULL; + } + + UCL_ARRAY_GET(vec, top); ucl_object_t *ret = NULL; unsigned i; @@ -3250,11 +3242,11 @@ ucl_array_delete (ucl_object_t *top, ucl_object_t *elt) return NULL; } - for (i = 0; i < vec->n; i ++) { - if (kv_A (*vec, i) == elt) { - kv_del (ucl_object_t *, *vec, i); + for (i = 0; i < vec->n; i++) { + if (kv_A(*vec, i) == elt) { + kv_del(ucl_object_t *, *vec, i); ret = elt; - top->len --; + top->len--; break; } } @@ -3263,12 +3255,12 @@ ucl_array_delete (ucl_object_t *top, ucl_object_t *elt) } const ucl_object_t * -ucl_array_head (const ucl_object_t *top) +ucl_array_head(const ucl_object_t *top) { - UCL_ARRAY_GET (vec, top); + UCL_ARRAY_GET(vec, top); if (vec == NULL || top == NULL || top->type != UCL_ARRAY || - top->value.av == NULL) { + top->value.av == NULL) { return NULL; } @@ -3276,9 +3268,9 @@ ucl_array_head (const ucl_object_t *top) } const ucl_object_t * -ucl_array_tail (const ucl_object_t *top) +ucl_array_tail(const ucl_object_t *top) { - UCL_ARRAY_GET (vec, top); + UCL_ARRAY_GET(vec, top); if (top == NULL || top->type != UCL_ARRAY || top->value.av == NULL) { return NULL; @@ -3288,45 +3280,53 @@ ucl_array_tail (const ucl_object_t *top) } ucl_object_t * -ucl_array_pop_last (ucl_object_t *top) +ucl_array_pop_last(ucl_object_t *top) { - UCL_ARRAY_GET (vec, top); + if (top->type != UCL_ARRAY) { + return NULL; + } + + UCL_ARRAY_GET(vec, top); ucl_object_t **obj, *ret = NULL; if (vec != NULL && vec->n > 0) { - obj = &kv_A (*vec, vec->n - 1); + obj = &kv_A(*vec, vec->n - 1); ret = *obj; - kv_del (ucl_object_t *, *vec, vec->n - 1); - top->len --; + kv_del(ucl_object_t *, *vec, vec->n - 1); + top->len--; } return ret; } ucl_object_t * -ucl_array_pop_first (ucl_object_t *top) +ucl_array_pop_first(ucl_object_t *top) { - UCL_ARRAY_GET (vec, top); + if (top->type != UCL_ARRAY) { + return NULL; + } + + UCL_ARRAY_GET(vec, top); ucl_object_t **obj, *ret = NULL; if (vec != NULL && vec->n > 0) { - obj = &kv_A (*vec, 0); + obj = &kv_A(*vec, 0); ret = *obj; - kv_del (ucl_object_t *, *vec, 0); - top->len --; + kv_del(ucl_object_t *, *vec, 0); + top->len--; } return ret; } unsigned int -ucl_array_size (const ucl_object_t *top) +ucl_array_size(const ucl_object_t *top) { if (top == NULL || top->type != UCL_ARRAY) { return 0; } - UCL_ARRAY_GET (vec, top); + UCL_ARRAY_GET(vec, top); if (vec != NULL) { return kv_size(*vec); @@ -3336,53 +3336,65 @@ ucl_array_size (const ucl_object_t *top) } const ucl_object_t * -ucl_array_find_index (const ucl_object_t *top, unsigned int index) +ucl_array_find_index(const ucl_object_t *top, unsigned int index) { - UCL_ARRAY_GET (vec, top); + if (top->type != UCL_ARRAY) { + return NULL; + } + + UCL_ARRAY_GET(vec, top); if (vec != NULL && vec->n > 0 && index < vec->n) { - return kv_A (*vec, index); + return kv_A(*vec, index); } return NULL; } unsigned int -ucl_array_index_of (ucl_object_t *top, ucl_object_t *elt) +ucl_array_index_of(ucl_object_t *top, ucl_object_t *elt) { - UCL_ARRAY_GET (vec, top); + if (top->type != UCL_ARRAY) { + return (unsigned int) (-1); + } + + UCL_ARRAY_GET(vec, top); unsigned i; if (vec == NULL) { - return (unsigned int)(-1); + return (unsigned int) (-1); } - for (i = 0; i < vec->n; i ++) { - if (kv_A (*vec, i) == elt) { + for (i = 0; i < vec->n; i++) { + if (kv_A(*vec, i) == elt) { return i; } } - return (unsigned int)(-1); + return (unsigned int) (-1); } ucl_object_t * -ucl_array_replace_index (ucl_object_t *top, ucl_object_t *elt, - unsigned int index) +ucl_array_replace_index(ucl_object_t *top, ucl_object_t *elt, + unsigned int index) { - UCL_ARRAY_GET (vec, top); + if (top->type != UCL_ARRAY) { + return NULL; + } + + UCL_ARRAY_GET(vec, top); ucl_object_t *ret = NULL; if (vec != NULL && vec->n > 0 && index < vec->n) { - ret = kv_A (*vec, index); - kv_A (*vec, index) = elt; + ret = kv_A(*vec, index); + kv_A(*vec, index) = elt; } return ret; } ucl_object_t * -ucl_elt_append (ucl_object_t *head, ucl_object_t *elt) +ucl_elt_append(ucl_object_t *head, ucl_object_t *elt) { if (head == NULL) { @@ -3391,17 +3403,26 @@ ucl_elt_append (ucl_object_t *head, ucl_object_t *elt) head = elt; } else { - elt->prev = head->prev; - head->prev->next = elt; - head->prev = elt; - elt->next = NULL; + if (head->type == UCL_USERDATA) { + /* Userdata objects are VERY special! */ + struct ucl_object_userdata *ud = (struct ucl_object_userdata *) head; + elt->prev = ud->obj.prev; + ud->obj.prev->next = elt; + ud->obj.prev = elt; + elt->next = NULL; + } + else { + elt->prev = head->prev; + head->prev->next = elt; + head->prev = elt; + elt->next = NULL; + } } return head; } -bool -ucl_object_todouble_safe (const ucl_object_t *obj, double *target) +bool ucl_object_todouble_safe(const ucl_object_t *obj, double *target) { if (obj == NULL || target == NULL) { return false; @@ -3422,16 +3443,15 @@ ucl_object_todouble_safe (const ucl_object_t *obj, double *target) } double -ucl_object_todouble (const ucl_object_t *obj) +ucl_object_todouble(const ucl_object_t *obj) { double result = 0.; - ucl_object_todouble_safe (obj, &result); + ucl_object_todouble_safe(obj, &result); return result; } -bool -ucl_object_toint_safe (const ucl_object_t *obj, int64_t *target) +bool ucl_object_toint_safe(const ucl_object_t *obj, int64_t *target) { if (obj == NULL || target == NULL) { return false; @@ -3452,16 +3472,15 @@ ucl_object_toint_safe (const ucl_object_t *obj, int64_t *target) } int64_t -ucl_object_toint (const ucl_object_t *obj) +ucl_object_toint(const ucl_object_t *obj) { int64_t result = 0; - ucl_object_toint_safe (obj, &result); + ucl_object_toint_safe(obj, &result); return result; } -bool -ucl_object_toboolean_safe (const ucl_object_t *obj, bool *target) +bool ucl_object_toboolean_safe(const ucl_object_t *obj, bool *target) { if (obj == NULL || target == NULL) { return false; @@ -3477,17 +3496,15 @@ ucl_object_toboolean_safe (const ucl_object_t *obj, bool *target) return true; } -bool -ucl_object_toboolean (const ucl_object_t *obj) +bool ucl_object_toboolean(const ucl_object_t *obj) { bool result = false; - ucl_object_toboolean_safe (obj, &result); + ucl_object_toboolean_safe(obj, &result); return result; } -bool -ucl_object_tostring_safe (const ucl_object_t *obj, const char **target) +bool ucl_object_tostring_safe(const ucl_object_t *obj, const char **target) { if (obj == NULL || target == NULL) { return false; @@ -3496,7 +3513,7 @@ ucl_object_tostring_safe (const ucl_object_t *obj, const char **target) switch (obj->type) { case UCL_STRING: if (!(obj->flags & UCL_OBJECT_BINARY)) { - *target = ucl_copy_value_trash (obj); + *target = ucl_copy_value_trash(obj); } break; default: @@ -3507,27 +3524,26 @@ ucl_object_tostring_safe (const ucl_object_t *obj, const char **target) } const char * -ucl_object_tostring (const ucl_object_t *obj) +ucl_object_tostring(const ucl_object_t *obj) { const char *result = NULL; - ucl_object_tostring_safe (obj, &result); + ucl_object_tostring_safe(obj, &result); return result; } const char * -ucl_object_tostring_forced (const ucl_object_t *obj) +ucl_object_tostring_forced(const ucl_object_t *obj) { /* TODO: For binary strings we might encode string here */ if (!(obj->flags & UCL_OBJECT_BINARY)) { - return ucl_copy_value_trash (obj); + return ucl_copy_value_trash(obj); } return NULL; } -bool -ucl_object_tolstring_safe (const ucl_object_t *obj, const char **target, size_t *tlen) +bool ucl_object_tolstring_safe(const ucl_object_t *obj, const char **target, size_t *tlen) { if (obj == NULL || target == NULL) { return false; @@ -3547,22 +3563,22 @@ ucl_object_tolstring_safe (const ucl_object_t *obj, const char **target, size_t } const char * -ucl_object_tolstring (const ucl_object_t *obj, size_t *tlen) +ucl_object_tolstring(const ucl_object_t *obj, size_t *tlen) { const char *result = NULL; - ucl_object_tolstring_safe (obj, &result, tlen); + ucl_object_tolstring_safe(obj, &result, tlen); return result; } const char * -ucl_object_key (const ucl_object_t *obj) +ucl_object_key(const ucl_object_t *obj) { - return ucl_copy_key_trash (obj); + return ucl_copy_key_trash(obj); } const char * -ucl_object_keyl (const ucl_object_t *obj, size_t *len) +ucl_object_keyl(const ucl_object_t *obj, size_t *len) { if (len == NULL || obj == NULL) { return NULL; @@ -3572,7 +3588,7 @@ ucl_object_keyl (const ucl_object_t *obj, size_t *len) } ucl_object_t * -ucl_object_ref (const ucl_object_t *obj) +ucl_object_ref(const ucl_object_t *obj) { ucl_object_t *res = NULL; @@ -3583,14 +3599,14 @@ ucl_object_ref (const ucl_object_t *obj) * is NOT increased, since ephemeral objects does not need refcount * at all */ - res = ucl_object_copy (obj); + res = ucl_object_copy(obj); } else { - res = __DECONST (ucl_object_t *, obj); + res = __DECONST(ucl_object_t *, obj); #ifdef HAVE_ATOMIC_BUILTINS - (void)__sync_add_and_fetch (&res->ref, 1); + (void) __sync_add_and_fetch(&res->ref, 1); #else - res->ref ++; + res->ref++; #endif } } @@ -3598,17 +3614,21 @@ ucl_object_ref (const ucl_object_t *obj) } static ucl_object_t * -ucl_object_copy_internal (const ucl_object_t *other, bool allow_array) +ucl_object_copy_internal(const ucl_object_t *other, bool allow_array) { ucl_object_t *new; ucl_object_iter_t it = NULL; const ucl_object_t *cur; + size_t sz = sizeof(*new); - new = malloc (sizeof (*new)); + if (other->type == UCL_USERDATA) { + sz = sizeof(struct ucl_object_userdata); + } + new = UCL_ALLOC(sz); if (new != NULL) { - memcpy (new, other, sizeof (*new)); + memcpy(new, other, sz); if (other->flags & UCL_OBJECT_EPHEMERAL) { /* Copied object is always non ephemeral */ new->flags &= ~UCL_OBJECT_EPHEMERAL; @@ -3621,8 +3641,8 @@ ucl_object_copy_internal (const ucl_object_t *other, bool allow_array) /* deep copy of values stored */ if (other->trash_stack[UCL_TRASH_KEY] != NULL) { new->trash_stack[UCL_TRASH_KEY] = NULL; - if (other->key == (const char *)other->trash_stack[UCL_TRASH_KEY]) { - new->trash_stack[UCL_TRASH_KEY] = malloc(other->keylen + 1); + if (other->key == (const char *) other->trash_stack[UCL_TRASH_KEY]) { + new->trash_stack[UCL_TRASH_KEY] = UCL_ALLOC(other->keylen + 1); memcpy(new->trash_stack[UCL_TRASH_KEY], other->trash_stack[UCL_TRASH_KEY], other->keylen); new->trash_stack[UCL_TRASH_KEY][other->keylen] = '\0'; new->key = new->trash_stack[UCL_TRASH_KEY]; @@ -3630,7 +3650,7 @@ ucl_object_copy_internal (const ucl_object_t *other, bool allow_array) } if (other->trash_stack[UCL_TRASH_VALUE] != NULL) { new->trash_stack[UCL_TRASH_VALUE] = - strdup (other->trash_stack[UCL_TRASH_VALUE]); + UCL_STRDUP(other->trash_stack[UCL_TRASH_VALUE]); if (new->type == UCL_STRING) { new->value.sv = new->trash_stack[UCL_TRASH_VALUE]; } @@ -3638,26 +3658,27 @@ ucl_object_copy_internal (const ucl_object_t *other, bool allow_array) if (other->type == UCL_ARRAY || other->type == UCL_OBJECT) { /* reset old value */ - memset (&new->value, 0, sizeof (new->value)); + memset(&new->value, 0, sizeof(new->value)); - while ((cur = ucl_object_iterate (other, &it, true)) != NULL) { + while ((cur = ucl_object_iterate(other, &it, true)) != NULL) { if (other->type == UCL_ARRAY) { - ucl_array_append (new, ucl_object_copy_internal (cur, false)); + ucl_array_append(new, ucl_object_copy_internal(cur, false)); } else { - ucl_object_t *cp = ucl_object_copy_internal (cur, true); + ucl_object_t *cp = ucl_object_copy_internal(cur, true); if (cp != NULL) { - ucl_object_insert_key (new, cp, cp->key, cp->keylen, - false); + ucl_object_insert_key(new, cp, cp->key, cp->keylen, + false); } } } } else if (allow_array && other->next != NULL) { - LL_FOREACH (other->next, cur) { - ucl_object_t *cp = ucl_object_copy_internal (cur, false); + LL_FOREACH(other->next, cur) + { + ucl_object_t *cp = ucl_object_copy_internal(cur, false); if (cp != NULL) { - DL_APPEND (new, cp); + DL_APPEND(new, cp); } } } @@ -3667,28 +3688,26 @@ ucl_object_copy_internal (const ucl_object_t *other, bool allow_array) } ucl_object_t * -ucl_object_copy (const ucl_object_t *other) +ucl_object_copy(const ucl_object_t *other) { - return ucl_object_copy_internal (other, true); + return ucl_object_copy_internal(other, true); } -void -ucl_object_unref (ucl_object_t *obj) +void ucl_object_unref(ucl_object_t *obj) { if (obj != NULL) { #ifdef HAVE_ATOMIC_BUILTINS - unsigned int rc = __sync_sub_and_fetch (&obj->ref, 1); + unsigned int rc = __sync_sub_and_fetch(&obj->ref, 1); if (rc == 0) { #else if (--obj->ref == 0) { #endif - ucl_object_free_internal (obj, true, ucl_object_dtor_unref); + ucl_object_free_internal(obj, true, ucl_object_dtor_unref); } } } -int -ucl_object_compare (const ucl_object_t *o1, const ucl_object_t *o2) +int ucl_object_compare(const ucl_object_t *o1, const ucl_object_t *o2) { const ucl_object_t *it1, *it2; ucl_object_iter_t iter = NULL; @@ -3701,7 +3720,7 @@ ucl_object_compare (const ucl_object_t *o1, const ucl_object_t *o2) switch (o1->type) { case UCL_STRING: if (o1->len == o2->len && o1->len > 0) { - ret = strcmp (ucl_object_tostring(o1), ucl_object_tostring(o2)); + ret = strcmp(ucl_object_tostring(o1), ucl_object_tostring(o2)); } else { ret = o1->len - o2->len; @@ -3710,21 +3729,21 @@ ucl_object_compare (const ucl_object_t *o1, const ucl_object_t *o2) case UCL_FLOAT: case UCL_INT: case UCL_TIME: - ret = ucl_object_todouble (o1) - ucl_object_todouble (o2); + ret = ucl_object_todouble(o1) - ucl_object_todouble(o2); break; case UCL_BOOLEAN: - ret = ucl_object_toboolean (o1) - ucl_object_toboolean (o2); + ret = ucl_object_toboolean(o1) - ucl_object_toboolean(o2); break; case UCL_ARRAY: if (o1->len == o2->len && o1->len > 0) { - UCL_ARRAY_GET (vec1, o1); - UCL_ARRAY_GET (vec2, o2); + UCL_ARRAY_GET(vec1, o1); + UCL_ARRAY_GET(vec2, o2); unsigned i; /* Compare all elements in both arrays */ - for (i = 0; i < vec1->n; i ++) { - it1 = kv_A (*vec1, i); - it2 = kv_A (*vec2, i); + for (i = 0; i < vec1->n; i++) { + it1 = kv_A(*vec1, i); + it2 = kv_A(*vec2, i); if (it1 == NULL && it2 != NULL) { return -1; @@ -3733,7 +3752,7 @@ ucl_object_compare (const ucl_object_t *o1, const ucl_object_t *o2) return 1; } else if (it1 != NULL && it2 != NULL) { - ret = ucl_object_compare (it1, it2); + ret = ucl_object_compare(it1, it2); if (ret != 0) { break; } @@ -3746,13 +3765,13 @@ ucl_object_compare (const ucl_object_t *o1, const ucl_object_t *o2) break; case UCL_OBJECT: if (o1->len == o2->len && o1->len > 0) { - while ((it1 = ucl_object_iterate (o1, &iter, true)) != NULL) { - it2 = ucl_object_lookup (o2, ucl_object_key (it1)); + while ((it1 = ucl_object_iterate(o1, &iter, true)) != NULL) { + it2 = ucl_object_lookup(o2, ucl_object_key(it1)); if (it2 == NULL) { ret = 1; break; } - ret = ucl_object_compare (it1, it2); + ret = ucl_object_compare(it1, it2); if (ret != 0) { break; } @@ -3770,85 +3789,82 @@ ucl_object_compare (const ucl_object_t *o1, const ucl_object_t *o2) return ret; } -int -ucl_object_compare_qsort (const ucl_object_t **o1, - const ucl_object_t **o2) +int ucl_object_compare_qsort(const ucl_object_t **o1, + const ucl_object_t **o2) { - return ucl_object_compare (*o1, *o2); + return ucl_object_compare(*o1, *o2); } -void -ucl_object_array_sort (ucl_object_t *ar, - int (*cmp)(const ucl_object_t **o1, const ucl_object_t **o2)) +void ucl_object_array_sort(ucl_object_t *ar, + int (*cmp)(const ucl_object_t **o1, const ucl_object_t **o2)) { - UCL_ARRAY_GET (vec, ar); + UCL_ARRAY_GET(vec, ar); if (cmp == NULL || ar == NULL || ar->type != UCL_ARRAY) { return; } - qsort (vec->a, vec->n, sizeof (ucl_object_t *), - (int (*)(const void *, const void *))cmp); + qsort(vec->a, vec->n, sizeof(ucl_object_t *), + (int (*)(const void *, const void *)) cmp); } -void ucl_object_sort_keys (ucl_object_t *obj, - enum ucl_object_keys_sort_flags how) +void ucl_object_sort_keys(ucl_object_t *obj, + enum ucl_object_keys_sort_flags how) { if (obj != NULL && obj->type == UCL_OBJECT) { - ucl_hash_sort (obj->value.ov, how); + ucl_hash_sort(obj->value.ov, how); } } #define PRIOBITS 4 unsigned int -ucl_object_get_priority (const ucl_object_t *obj) +ucl_object_get_priority(const ucl_object_t *obj) { if (obj == NULL) { return 0; } - return (obj->flags >> ((sizeof (obj->flags) * NBBY) - PRIOBITS)); + return (obj->flags >> ((sizeof(obj->flags) * NBBY) - PRIOBITS)); } -void -ucl_object_set_priority (ucl_object_t *obj, - unsigned int priority) +void ucl_object_set_priority(ucl_object_t *obj, + unsigned int priority) { if (obj != NULL) { priority &= (0x1 << PRIOBITS) - 1; - priority <<= ((sizeof (obj->flags) * NBBY) - PRIOBITS); - priority |= obj->flags & ((1 << ((sizeof (obj->flags) * NBBY) - - PRIOBITS)) - 1); + priority <<= ((sizeof(obj->flags) * NBBY) - PRIOBITS); + priority |= obj->flags & ((1 << ((sizeof(obj->flags) * NBBY) - + PRIOBITS)) - + 1); obj->flags = priority; } } -bool -ucl_object_string_to_type (const char *input, ucl_type_t *res) +bool ucl_object_string_to_type(const char *input, ucl_type_t *res) { - if (strcasecmp (input, "object") == 0) { + if (strcasecmp(input, "object") == 0) { *res = UCL_OBJECT; } - else if (strcasecmp (input, "array") == 0) { + else if (strcasecmp(input, "array") == 0) { *res = UCL_ARRAY; } - else if (strcasecmp (input, "integer") == 0) { + else if (strcasecmp(input, "integer") == 0) { *res = UCL_INT; } - else if (strcasecmp (input, "number") == 0) { + else if (strcasecmp(input, "number") == 0) { *res = UCL_FLOAT; } - else if (strcasecmp (input, "string") == 0) { + else if (strcasecmp(input, "string") == 0) { *res = UCL_STRING; } - else if (strcasecmp (input, "boolean") == 0) { + else if (strcasecmp(input, "boolean") == 0) { *res = UCL_BOOLEAN; } - else if (strcasecmp (input, "null") == 0) { + else if (strcasecmp(input, "null") == 0) { *res = UCL_NULL; } - else if (strcasecmp (input, "userdata") == 0) { + else if (strcasecmp(input, "userdata") == 0) { *res = UCL_USERDATA; } else { @@ -3859,7 +3875,7 @@ ucl_object_string_to_type (const char *input, ucl_type_t *res) } const char * -ucl_object_type_to_string (ucl_type_t type) +ucl_object_type_to_string(ucl_type_t type) { const char *res = "unknown"; @@ -3895,7 +3911,7 @@ ucl_object_type_to_string (ucl_type_t type) } const ucl_object_t * -ucl_parser_get_comments (struct ucl_parser *parser) +ucl_parser_get_comments(struct ucl_parser *parser) { if (parser && parser->comments) { return parser->comments; @@ -3905,35 +3921,34 @@ ucl_parser_get_comments (struct ucl_parser *parser) } const ucl_object_t * -ucl_comments_find (const ucl_object_t *comments, - const ucl_object_t *srch) +ucl_comments_find(const ucl_object_t *comments, + const ucl_object_t *srch) { if (comments && srch) { - return ucl_object_lookup_len (comments, (const char *)&srch, - sizeof (void *)); + return ucl_object_lookup_len(comments, (const char *) &srch, + sizeof(void *)); } return NULL; } -bool -ucl_comments_move (ucl_object_t *comments, - const ucl_object_t *from, const ucl_object_t *to) +bool ucl_comments_move(ucl_object_t *comments, + const ucl_object_t *from, const ucl_object_t *to) { const ucl_object_t *found; ucl_object_t *obj; if (comments && from && to) { - found = ucl_object_lookup_len (comments, - (const char *)&from, sizeof (void *)); + found = ucl_object_lookup_len(comments, + (const char *) &from, sizeof(void *)); if (found) { /* Replace key */ - obj = ucl_object_ref (found); - ucl_object_delete_keyl (comments, (const char *)&from, - sizeof (void *)); - ucl_object_insert_key (comments, obj, (const char *)&to, - sizeof (void *), true); + obj = ucl_object_ref(found); + ucl_object_delete_keyl(comments, (const char *) &from, + sizeof(void *)); + ucl_object_insert_key(comments, obj, (const char *) &to, + sizeof(void *), true); return true; } @@ -3942,27 +3957,25 @@ ucl_comments_move (ucl_object_t *comments, return false; } -void -ucl_comments_add (ucl_object_t *comments, const ucl_object_t *obj, - const char *comment) +void ucl_comments_add(ucl_object_t *comments, const ucl_object_t *obj, + const char *comment) { if (comments && obj && comment) { - ucl_object_insert_key (comments, ucl_object_fromstring (comment), - (const char *)&obj, sizeof (void *), true); + ucl_object_insert_key(comments, ucl_object_fromstring(comment), + (const char *) &obj, sizeof(void *), true); } } -void -ucl_parser_set_include_tracer (struct ucl_parser *parser, - ucl_include_trace_func_t func, - void *user_data) +void ucl_parser_set_include_tracer(struct ucl_parser *parser, + ucl_include_trace_func_t func, + void *user_data) { parser->include_trace_func = func; parser->include_trace_ud = user_data; } const char * -ucl_parser_get_cur_file (struct ucl_parser *parser) +ucl_parser_get_cur_file(struct ucl_parser *parser) { return parser->cur_file; } diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt new file mode 100644 index 000000000000..e66c3d10a60a --- /dev/null +++ b/tests/CMakeLists.txt @@ -0,0 +1,31 @@ +set(COMMON_TEST_INCLUDES + ${CMAKE_SOURCE_DIR}/include + ${CMAKE_SOURCE_DIR}/src + ${CMAKE_SOURCE_DIR}/uthash +) + +set(COMMON_TEST_LIBS ucl) + +set(TEST_ENV_VARS + "TEST_DIR=${CMAKE_SOURCE_DIR}/tests" + "TEST_OUT_DIR=${CMAKE_BINARY_DIR}/tests" + "TEST_BINARY_DIR=${CMAKE_BINARY_DIR}/tests" +) + +macro(add_ucl_test testname sourcefile wrapper) + add_executable(${testname} ${sourcefile}) + target_include_directories(${testname} PRIVATE ${COMMON_TEST_INCLUDES}) + target_link_libraries(${testname} PRIVATE ${COMMON_TEST_LIBS}) + IF(NOT CMAKE_SYSTEM_NAME STREQUAL "Windows") + add_test(NAME ${testname} COMMAND ${CMAKE_SOURCE_DIR}/tests/${wrapper}) + set_tests_properties(${testname} PROPERTIES ENVIRONMENT "${TEST_ENV_VARS}") + ENDIF() +endmacro() + +# Build test binaries always (not just for testing) +add_ucl_test(test_basic test_basic.c basic.test) +add_ucl_test(test_speed test_speed.c speed.test) +add_ucl_test(test_schema test_schema.c schema.test) +add_ucl_test(test_msgpack test_msgpack.c msgpack.test) +add_ucl_test(test_generate test_generate.c generate.test) + diff --git a/tests/Makefile.am b/tests/Makefile.am index 055eb8bd85b0..d3442275cf0d 100644 --- a/tests/Makefile.am +++ b/tests/Makefile.am @@ -5,8 +5,8 @@ TESTS = basic.test \ generate.test \ schema.test \ msgpack.test \ - speed.test \ - msgpack.test + speed.test + TESTS_ENVIRONMENT = $(SH) \ TEST_DIR=$(top_srcdir)/tests \ TEST_OUT_DIR=$(top_builddir)/tests \ @@ -41,5 +41,5 @@ test_msgpack_SOURCES = test_msgpack.c test_msgpack_LDADD = $(common_test_ldadd) test_msgpack_CFLAGS = $(common_test_cflags) -check_PROGRAMS = test_basic test_speed test_generate test_schema test_streamline \ - test_msgpack \ No newline at end of file +check_PROGRAMS = test_basic test_speed test_generate test_schema \ + test_streamline test_msgpack diff --git a/tests/basic/23-json-with-braces.inc b/tests/basic/23-json-with-braces.inc new file mode 100644 index 000000000000..b6f13e15edb7 --- /dev/null +++ b/tests/basic/23-json-with-braces.inc @@ -0,0 +1 @@ +{ "a": "b" } diff --git a/tests/basic/23-json-without-braces.inc b/tests/basic/23-json-without-braces.inc new file mode 100644 index 000000000000..bfad85f2f011 --- /dev/null +++ b/tests/basic/23-json-without-braces.inc @@ -0,0 +1,2 @@ +# Note: This is arguably not a valid JSON file, but it is supposed to be parsable UCL. +"b": "c" diff --git a/tests/basic/23-ucl-with-braces.inc b/tests/basic/23-ucl-with-braces.inc new file mode 100644 index 000000000000..38f5a8708dc3 --- /dev/null +++ b/tests/basic/23-ucl-with-braces.inc @@ -0,0 +1 @@ +{ c = "d"; } diff --git a/tests/basic/23-ucl-without-braces.inc b/tests/basic/23-ucl-without-braces.inc new file mode 100644 index 000000000000..1072dfc8682b --- /dev/null +++ b/tests/basic/23-ucl-without-braces.inc @@ -0,0 +1 @@ +d = "e"; diff --git a/tests/basic/23.in b/tests/basic/23.in new file mode 100644 index 000000000000..8778a5060d09 --- /dev/null +++ b/tests/basic/23.in @@ -0,0 +1,8 @@ +a = 1; +b = 2; +.include() "${CURDIR}/23-json-with-braces.inc" +.include() "${CURDIR}/23-json-without-braces.inc" +.include() "${CURDIR}/23-ucl-with-braces.inc" +.include() "${CURDIR}/23-ucl-without-braces.inc" +c = 3; +d = 4; diff --git a/tests/basic/23.res b/tests/basic/23.res new file mode 100644 index 000000000000..a98313c4e421 --- /dev/null +++ b/tests/basic/23.res @@ -0,0 +1,9 @@ +a = 1; +a = "b"; +b = 2; +b = "c"; +c = "d"; +c = 3; +d = "e"; +d = 4; + diff --git a/tests/basic/comments.in b/tests/basic/comments.in index 3144fa004fa2..fbaa009e6465 100644 --- a/tests/basic/comments.in +++ b/tests/basic/comments.in @@ -1,4 +1,8 @@ # This test is intended to check various comments in ucl +/***/ +/* + * "" + */ obj { diff --git a/tests/basic/issue319.in b/tests/basic/issue319.in new file mode 100644 index 000000000000..f21900f1086f --- /dev/null +++ b/tests/basic/issue319.in @@ -0,0 +1,3 @@ +key = < #include + +#ifndef _WIN32 #include -#include "ucl.h" +#endif static int read_stdin (char **buf) diff --git a/tests/test_speed.c b/tests/test_speed.c index 51476c94940b..ed539402067b 100644 --- a/tests/test_speed.c +++ b/tests/test_speed.c @@ -21,13 +21,24 @@ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ +#include "ucl.h" +#include "ucl_internal.h" + #include + +#ifndef _WIN32 #include -#include #include +#endif + +#include #include #include + +#ifndef _WIN32 #include +#endif + #include #include @@ -37,8 +48,6 @@ #endif #endif -#include "ucl.h" - static double get_ticks (void) { diff --git a/utils/CMakeLists.txt b/utils/CMakeLists.txt index 4de95fd7b4b0..6d8e543aa994 100644 --- a/utils/CMakeLists.txt +++ b/utils/CMakeLists.txt @@ -4,6 +4,10 @@ PROJECT(libucl-utils C) FUNCTION(MAKE_UTIL UTIL_NAME UTIL_SRCS) ADD_EXECUTABLE(${UTIL_NAME} ${UTIL_SRCS}) TARGET_LINK_LIBRARIES(${UTIL_NAME} ucl) + TARGET_INCLUDE_DIRECTORIES(${UTIL_NAME} PRIVATE + ${CMAKE_SOURCE_DIR}/include + ${CMAKE_SOURCE_DIR}/src + ) INSTALL(TARGETS ${UTIL_NAME} DESTINATION bin) ENDFUNCTION() diff --git a/utils/ucl-tool.c b/utils/ucl-tool.c index 9b807d35c092..677dd11aed58 100644 --- a/utils/ucl-tool.c +++ b/utils/ucl-tool.c @@ -22,149 +22,160 @@ #include "ucl.h" -void usage(const char *name, FILE *out) { - fprintf(out, "Usage: %s [--help] [-i|--in file] [-o|--out file]\n", name); - fprintf(out, " [-s|--schema file] [-f|--format format]\n\n"); - fprintf(out, " --help - print this message and exit\n"); - fprintf(out, " --in - specify input filename " - "(default: standard input)\n"); - fprintf(out, " --out - specify output filename " - "(default: standard output)\n"); - fprintf(out, " --schema - specify schema file for validation\n"); - fprintf(out, " --format - output format. Options: ucl (default), " - "json, compact_json, yaml, msgpack\n"); +void usage(const char *name, FILE *out) +{ + fprintf(out, "Usage: %s [--help] [-i|--in file] [-o|--out file]\n", name); + fprintf(out, " [-s|--schema file] [-f|--format format]\n\n"); + fprintf(out, " --help - print this message and exit\n"); + fprintf(out, " --in - specify input filename " + "(default: standard input)\n"); + fprintf(out, " --out - specify output filename " + "(default: standard output)\n"); + fprintf(out, " --schema - specify schema file for validation\n"); + fprintf(out, " --format - output format. Options: ucl (default), " + "json, compact_json, yaml, msgpack\n"); } -int main(int argc, char **argv) { - int i; - char ch; - FILE *in = stdin, *out = stdout; - const char *schema = NULL, *parm, *val; - unsigned char *buf = NULL; - size_t size = 0, r = 0; - struct ucl_parser *parser = NULL; - ucl_object_t *obj = NULL; - ucl_emitter_t emitter = UCL_EMIT_CONFIG; - - for (i = 1; i < argc; ++i) { - parm = argv[i]; - val = ((i + 1) < argc) ? argv[++i] : NULL; - - if ((strcmp(parm, "--help") == 0) || (strcmp(parm, "-h") == 0)) { - usage(argv[0], stdout); - exit(0); - - } else if ((strcmp(parm, "--in") == 0) || (strcmp(parm, "-i") == 0)) { - if (!val) - goto err_val; - - in = fopen(val, "r"); - if (in == NULL) { - perror("fopen on input file"); - exit(EXIT_FAILURE); - } - } else if ((strcmp(parm, "--out") == 0) || (strcmp(parm, "-o") == 0)) { - if (!val) - goto err_val; - - out = fopen(val, "w"); - if (out == NULL) { - perror("fopen on output file"); - exit(EXIT_FAILURE); - } - } else if ((strcmp(parm, "--schema") == 0) || (strcmp(parm, "-s") == 0)) { - if (!val) - goto err_val; - schema = val; - - } else if ((strcmp(parm, "--format") == 0) || (strcmp(parm, "-f") == 0)) { - if (!val) - goto err_val; - - if (strcmp(val, "ucl") == 0) { - emitter = UCL_EMIT_CONFIG; - } else if (strcmp(val, "json") == 0) { - emitter = UCL_EMIT_JSON; - } else if (strcmp(val, "yaml") == 0) { - emitter = UCL_EMIT_YAML; - } else if (strcmp(val, "compact_json") == 0) { - emitter = UCL_EMIT_JSON_COMPACT; - } else if (strcmp(val, "msgpack") == 0) { - emitter = UCL_EMIT_MSGPACK; - } else { - fprintf(stderr, "Unknown output format: %s\n", val); - exit(EXIT_FAILURE); - } - } else { - usage(argv[0], stderr); - exit(EXIT_FAILURE); - } - } - - parser = ucl_parser_new(0); - buf = malloc(BUFSIZ); - size = BUFSIZ; - while (!feof(in) && !ferror(in)) { - if (r == size) { - buf = realloc(buf, size*2); - size *= 2; - if (buf == NULL) { - perror("realloc"); - exit(EXIT_FAILURE); - } - } - r += fread(buf + r, 1, size - r, in); - } - if (ferror(in)) { - fprintf(stderr, "Failed to read the input file.\n"); - exit(EXIT_FAILURE); - } - fclose(in); - if (!ucl_parser_add_chunk(parser, buf, r)) { - fprintf(stderr, "Failed to parse input file: %s\n", - ucl_parser_get_error(parser)); - exit(EXIT_FAILURE); - } - if ((obj = ucl_parser_get_object(parser)) == NULL) { - fprintf(stderr, "Failed to get root object: %s\n", - ucl_parser_get_error(parser)); - exit(EXIT_FAILURE); - } - if (schema != NULL) { - struct ucl_parser *schema_parser = ucl_parser_new(0); - ucl_object_t *schema_obj = NULL; - struct ucl_schema_error error; - - if (!ucl_parser_add_file(schema_parser, schema)) { - fprintf(stderr, "Failed to parse schema file: %s\n", - ucl_parser_get_error(schema_parser)); - exit(EXIT_FAILURE); - } - if ((schema_obj = ucl_parser_get_object(schema_parser)) == NULL) { - fprintf(stderr, "Failed to get root object: %s\n", - ucl_parser_get_error(schema_parser)); - exit(EXIT_FAILURE); - } - if (!ucl_object_validate(schema_obj, obj, &error)) { - fprintf(stderr, "Validation failed: %s\n", error.msg); - exit(EXIT_FAILURE); - } - } - - if (emitter != UCL_EMIT_MSGPACK) { - fprintf(out, "%s\n", ucl_object_emit(obj, emitter)); - } else { - size_t len; - unsigned char *res; - - res = ucl_object_emit_len(obj, emitter, &len); - fwrite(res, 1, len, out); - } - - return 0; +int main(int argc, char **argv) +{ + int i; + char ch; + FILE *in = stdin, *out = stdout; + const char *schema = NULL, *parm, *val; + unsigned char *buf = NULL; + size_t size = 0, r = 0; + struct ucl_parser *parser = NULL; + ucl_object_t *obj = NULL; + ucl_emitter_t emitter = UCL_EMIT_CONFIG; + + for (i = 1; i < argc; ++i) { + parm = argv[i]; + val = ((i + 1) < argc) ? argv[++i] : NULL; + + if ((strcmp(parm, "--help") == 0) || (strcmp(parm, "-h") == 0)) { + usage(argv[0], stdout); + exit(0); + } + else if ((strcmp(parm, "--in") == 0) || (strcmp(parm, "-i") == 0)) { + if (!val) + goto err_val; + + in = fopen(val, "r"); + if (in == NULL) { + perror("fopen on input file"); + exit(EXIT_FAILURE); + } + } + else if ((strcmp(parm, "--out") == 0) || (strcmp(parm, "-o") == 0)) { + if (!val) + goto err_val; + + out = fopen(val, "w"); + if (out == NULL) { + perror("fopen on output file"); + exit(EXIT_FAILURE); + } + } + else if ((strcmp(parm, "--schema") == 0) || (strcmp(parm, "-s") == 0)) { + if (!val) + goto err_val; + schema = val; + } + else if ((strcmp(parm, "--format") == 0) || (strcmp(parm, "-f") == 0)) { + if (!val) + goto err_val; + + if (strcmp(val, "ucl") == 0) { + emitter = UCL_EMIT_CONFIG; + } + else if (strcmp(val, "json") == 0) { + emitter = UCL_EMIT_JSON; + } + else if (strcmp(val, "yaml") == 0) { + emitter = UCL_EMIT_YAML; + } + else if (strcmp(val, "compact_json") == 0) { + emitter = UCL_EMIT_JSON_COMPACT; + } + else if (strcmp(val, "msgpack") == 0) { + emitter = UCL_EMIT_MSGPACK; + } + else { + fprintf(stderr, "Unknown output format: %s\n", val); + exit(EXIT_FAILURE); + } + } + else { + usage(argv[0], stderr); + exit(EXIT_FAILURE); + } + } + + parser = ucl_parser_new(UCL_PARSER_NO_FILEVARS | UCL_PARSER_DISABLE_MACRO); + buf = malloc(BUFSIZ); + size = BUFSIZ; + while (!feof(in) && !ferror(in)) { + if (r == size) { + buf = realloc(buf, size * 2); + size *= 2; + if (buf == NULL) { + perror("realloc"); + exit(EXIT_FAILURE); + } + } + r += fread(buf + r, 1, size - r, in); + } + if (ferror(in)) { + fprintf(stderr, "Failed to read the input file.\n"); + exit(EXIT_FAILURE); + } + fclose(in); + if (!ucl_parser_add_chunk(parser, buf, r)) { + fprintf(stderr, "Failed to parse input file: %s\n", + ucl_parser_get_error(parser)); + exit(EXIT_FAILURE); + } + if ((obj = ucl_parser_get_object(parser)) == NULL) { + fprintf(stderr, "Failed to get root object: %s\n", + ucl_parser_get_error(parser)); + exit(EXIT_FAILURE); + } + if (schema != NULL) { + struct ucl_parser *schema_parser = ucl_parser_new(0); + ucl_object_t *schema_obj = NULL; + struct ucl_schema_error error; + + if (!ucl_parser_add_file(schema_parser, schema)) { + fprintf(stderr, "Failed to parse schema file: %s\n", + ucl_parser_get_error(schema_parser)); + exit(EXIT_FAILURE); + } + if ((schema_obj = ucl_parser_get_object(schema_parser)) == NULL) { + fprintf(stderr, "Failed to get root object: %s\n", + ucl_parser_get_error(schema_parser)); + exit(EXIT_FAILURE); + } + if (!ucl_object_validate(schema_obj, obj, &error)) { + fprintf(stderr, "Validation failed: %s\n", error.msg); + exit(EXIT_FAILURE); + } + } + + if (emitter != UCL_EMIT_MSGPACK) { + fprintf(out, "%s\n", ucl_object_emit(obj, emitter)); + } + else { + size_t len; + unsigned char *res; + + res = ucl_object_emit_len(obj, emitter, &len); + fwrite(res, 1, len, out); + } + + return 0; err_val: - fprintf(stderr, "Parameter %s is missing mandatory value\n", parm); - usage(argv[0], stderr); - exit(EXIT_FAILURE); + fprintf(stderr, "Parameter %s is missing mandatory value\n", parm); + usage(argv[0], stderr); + exit(EXIT_FAILURE); } -- cgit v1.2.3