Import libucl 0.9.3vendor/libucl/0.9.3vendor/libucl

40 files changed, 5003 insertions, 4796 deletions

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<std::string *>(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<std::string *>(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<std::string *>(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<std::string *>(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<std::set<std::string> *>(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 <typename C, typename P>
-	static Ucl parse_with_strategy_function (C config_func, P parse_func, std::string &err)
+	template<typename C, typename P>
+	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<ucl_object_t, ucl_deleter> 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<void> it;
 		std::unique_ptr<Ucl> cur;
+
 	public:
 		typedef std::forward_iterator_tag iterator_category;
 
-		const_iterator(const Ucl &obj) {
-			it = std::shared_ptr<void>(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<void>(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<int64_t>(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 <class T, class = decltype(&T::to_ucl)>
-	Ucl(const T &t) : Ucl(t.to_ucl()) {}
+	template<class T, class = decltype(&T::to_ucl)>
+	Ucl(const T &t)
+		: Ucl(t.to_ucl())
+	{
+	}
 
 	// Implicit constructor: map-like objects (std::map, std::unordered_map, etc)
-	template <class M, typename std::enable_if<
-		std::is_constructible<std::string, typename M::key_type>::value
-		&& std::is_constructible<Ucl, typename M::mapped_type>::value,
-		int>::type = 0>
-	Ucl(const M &m) {
-		obj.reset (ucl_object_typed_new (UCL_OBJECT));
-		auto cobj = obj.get ();
+	template<class M, typename std::enable_if<
+						  std::is_constructible<std::string, typename M::key_type>::value && std::is_constructible<Ucl, typename M::mapped_type>::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 <class V, typename std::enable_if<
-		std::is_constructible<Ucl, typename V::value_type>::value,
-		int>::type = 0>
-	Ucl(const V &v) {
-		obj.reset (ucl_object_typed_new (UCL_ARRAY));
-		auto cobj = obj.get ();
+	template<class V, typename std::enable_if<
+						  std::is_constructible<Ucl, typename V::value_type>::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<void *>(&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<std::string, std::string>(), err, duplicate_strategy);
+		return parse(in, std::map<std::string, std::string>(), err, duplicate_strategy);
 	}
 
-	static Ucl parse (const std::string &in, const std::map<std::string, std::string> &vars,
-			std::string &err, enum ucl_duplicate_strategy duplicate_strategy = UCL_DUPLICATE_APPEND)
+	static Ucl parse(const std::string &in, const std::map<std::string, std::string> &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<std::tuple<std::string, macro_handler_s, void *>> 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*/ > > &macros,
-			std::string &err, enum ucl_duplicate_strategy duplicate_strategy = UCL_DUPLICATE_APPEND)
+	static Ucl parse(const std::string &in,
+					 std::vector<std::tuple<std::string /*name*/, macro_handler_s, void * /*userdata*/>> &macros,
+					 std::string &err, enum ucl_duplicate_strategy duplicate_strategy = UCL_DUPLICATE_APPEND)
 	{
-		return parse (in, std::map<std::string, std::string>(), macros, err, duplicate_strategy);
+		return parse(in, std::map<std::string, std::string>(), 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<std::string, std::string> &vars,
-			std::vector< std::tuple< std::string /*name*/, macro_handler_s, void * /*userdata*/ > > &macros,
-			std::string &err, enum ucl_duplicate_strategy duplicate_strategy = UCL_DUPLICATE_APPEND)
+	static Ucl parse(const std::string &in, const std::map<std::string, std::string> &vars,
+					 std::vector<std::tuple<std::string /*name*/, macro_handler_s, void * /*userdata*/>> &macros,
+					 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<macro_userdata_s> userdata_list;
-		userdata_list.reserve (macros.size());
-		auto config_func = [&userdata_list, &vars, &macros] (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, &macros](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 &macro: 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<void*>(&userdata_list.back()));
+					ucl_parser_register_macro(parser,
+											  std::get<0>(macro).c_str(),
+											  std::get<1>(macro).handler,
+											  reinterpret_cast<void *>(&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<void*>(&userdata_list.back()));
+					ucl_parser_register_context_macro(parser,
+													  std::get<0>(macro).c_str(),
+													  std::get<1>(macro).ctx_handler,
+													  reinterpret_cast<void *>(&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<std::tuple<std::string, macro_handler_s, void *>> 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*/ > > &macros,
-			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<std::tuple<std::string /*name*/, macro_handler_s, void * /*userdata*/>> &macros,
+					 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<macro_userdata_s> userdata_list;
-		userdata_list.reserve (macros.size());
-		auto config_func = [&userdata_list, &replacer, &macros] (ucl_parser *parser) {
-			ucl_parser_set_variables_handler (parser, ucl_variable_replacer, &const_cast<variable_replacer &>(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, &macros](ucl_parser *parser) {
+			ucl_parser_set_variables_handler(parser, ucl_variable_replacer, &const_cast<variable_replacer &>(replacer));
+			for (auto &macro: 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<void*>(&userdata_list.back()));
+					ucl_parser_register_macro(parser,
+											  std::get<0>(macro).c_str(),
+											  std::get<1>(macro).handler,
+											  reinterpret_cast<void *>(&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<void*>(&userdata_list.back()));
+					ucl_parser_register_context_macro(parser,
+													  std::get<0>(macro).c_str(),
+													  std::get<1>(macro).ctx_handler,
+													  reinterpret_cast<void *>(&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<std::string, std::string>(), err, duplicate_strategy);
+		return parse(in, std::map<std::string, std::string>(), err, duplicate_strategy);
 	}
 
-	static Ucl parse (const char *in, const std::map<std::string, std::string> &vars, std::string &err)
+	static Ucl parse(const char *in, const std::map<std::string, std::string> &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*/ > > &macros,
-			std::string &err, enum ucl_duplicate_strategy duplicate_strategy = UCL_DUPLICATE_APPEND)
+	static Ucl parse(const char *in,
+					 std::vector<std::tuple<std::string /*name*/, macro_handler_s, void * /*userdata*/>> &macros,
+					 std::string &err, enum ucl_duplicate_strategy duplicate_strategy = UCL_DUPLICATE_APPEND)
 	{
-		return parse (in, std::map<std::string, std::string>(), macros, err, duplicate_strategy);
+		return parse(in, std::map<std::string, std::string>(), macros, err, duplicate_strategy);
 	}
 
 	//Macro handler will receive a macro_userdata_s as void *ud
-	static Ucl parse (const char *in, const std::map<std::string, std::string> &vars,
-			std::vector< std::tuple< std::string /*name*/, macro_handler_s, void * /*userdata*/ > > &macros,
-			std::string &err, enum ucl_duplicate_strategy duplicate_strategy = UCL_DUPLICATE_APPEND)
+	static Ucl parse(const char *in, const std::map<std::string, std::string> &vars,
+					 std::vector<std::tuple<std::string /*name*/, macro_handler_s, void * /*userdata*/>> &macros,
+					 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*/ > > &macros,
-			std::string &err, enum ucl_duplicate_strategy duplicate_strategy = UCL_DUPLICATE_APPEND)
+	static Ucl parse(const char *in, const variable_replacer &replacer,
+					 std::vector<std::tuple<std::string /*name*/, macro_handler_s, void * /*userdata*/>> &macros,
+					 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<std::string, std::string>(), err);
+		return parse_from_file(filename, std::map<std::string, std::string>(), err);
 	}
 
-	static Ucl parse_from_file (const std::string &filename, const std::map<std::string, std::string> &vars, std::string &err)
+	static Ucl parse_from_file(const std::string &filename, const std::map<std::string, std::string> &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<variable_replacer &>(replacer));
+		auto config_func = [&replacer](ucl_parser *parser) {
+			ucl_parser_set_variables_handler(parser, ucl_variable_replacer,
+											 &const_cast<variable_replacer &>(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<std::string> find_variable (const std::string &in)
+	static std::vector<std::string> find_variable(const std::string &in)
 	{
-		auto parser = ucl_parser_new (UCL_PARSER_DEFAULT);
+		auto parser = ucl_parser_new(UCL_PARSER_DEFAULT);
 
 		std::set<std::string> 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<std::string> 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<std::string> find_variable (const char *in)
+	static std::vector<std::string> find_variable(const char *in)
 	{
 		if (!in) {
 			return std::vector<std::string>();
 		}
-		return find_variable (std::string (in));
+		return find_variable(std::string(in));
 	}
 
-	static std::vector<std::string> find_variable_from_file (const std::string &filename)
+	static std::vector<std::string> 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<std::string> 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<std::string> 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 <stdio.h>
 
 #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 <libkern/OSByteOrder.h>
-#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 <byteswap.h>
-#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 <ident_level>{
 	 * <ident_level + 1><object content>
 	 */
 	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 ("<<EOD\n", sizeof ("<<EOD\n") - 1, func->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("<<EOD\n", sizeof("<<EOD\n") - 1, func->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 <sys/mman.h>
-# endif
+#ifndef _WIN32
+#include <sys/mman.h>
+#endif
 #endif
 #ifdef HAVE_SYS_STAT_H
 #include <sys/stat.h>
 #endif
 #ifdef HAVE_SYS_PARAM_H
-# ifndef _WIN32
-# include <sys/param.h>
-# endif
+#ifndef _WIN32
+#include <sys/param.h>
+#endif
 #endif
 
 #ifdef HAVE_LIMITS_H
@@ -78,9 +78,9 @@
 #include <errno.h>
 #endif
 #ifdef HAVE_UNISTD_H
-# ifndef _WIN32
-# include <unistd.h>
-# endif
+#ifndef _WIN32
+#include <unistd.h>
+#endif
 #endif
 #ifdef HAVE_CTYPE_H
 #include <ctype.h>
@@ -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,
-					&macro_start, &macro_len)) {
+			if (!ucl_parse_macro_value(parser, chunk, macro,
+									   &macro_start, &macro_len)) {
 				parser->prev_state = parser->state;
 				parser->state = UCL_STATE_ERROR;
 				return false;
 			}
-			macro_len = ucl_expand_variable (parser, &macro_escaped,
-					macro_start, macro_len);
+			macro_len = ucl_expand_variable(parser, &macro_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 <inttypes.h>
 
-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 (&reg, pattern, REG_EXTENDED | REG_NOSUB) == 0) {
+	if (regcomp(&reg, pattern, REG_EXTENDED | REG_NOSUB) == 0) {
 		if (recursive) {
-			while ((elt = ucl_object_iterate (obj, &iter, true)) != NULL) {
-				if (regexec (&reg, ucl_object_key (elt), 0, NULL, 0) == 0) {
+			while ((elt = ucl_object_iterate(obj, &iter, true)) != NULL) {
+				if (regexec(&reg, ucl_object_key(elt), 0, NULL, 0) == 0) {
 					res = elt;
 					break;
 				}
 			}
-		} else {
-			if (regexec (&reg, ucl_object_key (obj), 0, NULL, 0) == 0)
+		}
+		else {
+			if (regexec(&reg, ucl_object_key(obj), 0, NULL, 0) == 0)
 				res = obj;
 		}
-		regfree (&reg);
+		regfree(&reg);
 	}
 #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 <libgen.h> /* For dirname */
+#include <libgen.h> /* 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 <openssl/err.h>
@@ -73,22 +73,22 @@ typedef kvec_t(ucl_object_t *) ucl_array_t;
 #include <direct.h>
 
 #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, &params);
+			return ucl_include_url(data, len, parser, &params);
 		}
 		else if (data != NULL) {
 			/* Try to load a file */
-			return ucl_include_file (data, len, parser, &params, args);
+			return ucl_include_file(data, len, parser, &params, 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, &params);
+			return ucl_include_url(data, len, parser, &params);
 		}
 
-		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, &params, args))) {
+				snprintf(ipath, sizeof(ipath), "%s/%.*s", ucl_object_tostring(param),
+						 (int) len, data);
+				if ((search = ucl_include_file(ipath, strlen(ipath),
+											   parser, &params, 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 = <<EOD
+value
+EOD
\ No newline at end of file
diff --git a/tests/basic/issue319.res b/tests/basic/issue319.res
new file mode 100644
index 000000000000..4b17c4b4eb1b
--- /dev/null
+++ b/tests/basic/issue319.res
@@ -0,0 +1,2 @@
+key = "value";
+
diff --git a/tests/test_generate.c b/tests/test_generate.c
index 302a733441cd..dad1e9868f0c 100644
--- a/tests/test_generate.c
+++ b/tests/test_generate.c
@@ -74,7 +74,7 @@ main (int argc, char **argv)
 	cur = ucl_object_fromstring_common ("value1", 0, UCL_STRING_TRIM);
 	ucl_object_insert_key (obj, cur, "key0", 0, false);
 	cur = ucl_object_fromdouble (0.1);
-	assert (ucl_object_replace_key (obj, cur, "key0", 0, false));
+	ucl_object_replace_key (obj, cur, "key0", 0, false);
 
 	/* Create some strings */
 	cur = ucl_object_fromstring_common ("  test string    ", 0, UCL_STRING_TRIM);
@@ -191,14 +191,14 @@ main (int argc, char **argv)
 	/* Object deletion */
 	cur = ucl_object_fromstring ("test");
 	ucl_object_insert_key (obj, cur, "key18", 0, true);
-	assert (ucl_object_delete_key (obj, "key18"));
-	assert (!ucl_object_delete_key (obj, "key18"));
+	ucl_object_delete_key (obj, "key18");
+	ucl_object_delete_key (obj, "key18");
 	cur = ucl_object_fromlstring ("test", 4);
 	ucl_object_insert_key (obj, cur, "key18\0\0", 7, true);
-	assert (ucl_object_lookup_len (obj, "key18\0\0", 7) == cur);
-	assert (ucl_object_lookup (obj, "key18") == NULL);
-	assert (ucl_object_lookup_len (obj, "key18\0\1", 7) == NULL);
-	assert (ucl_object_delete_keyl (obj, "key18\0\0", 7));
+	ucl_object_lookup_len (obj, "key18\0\0", 7);
+	ucl_object_lookup (obj, "key18");
+	ucl_object_lookup_len (obj, "key18\0\1", 7);
+	ucl_object_delete_keyl (obj, "key18\0\0", 7);
 
 	/* Comments */
 
@@ -274,7 +274,7 @@ main (int argc, char **argv)
 	ucl_object_iterate_free (it);
 
 	fn = ucl_object_emit_memory_funcs ((void **)&emitted);
-	assert (ucl_object_emit_full (obj, UCL_EMIT_CONFIG, fn, comments));
+	ucl_object_emit_full (obj, UCL_EMIT_CONFIG, fn, comments);
 	fprintf (out, "%s\n", emitted);
 	ucl_object_emit_funcs_free (fn);
 	ucl_object_unref (obj);
diff --git a/tests/test_schema.c b/tests/test_schema.c
index 675764925507..cfc6aafdefe1 100644
--- a/tests/test_schema.c
+++ b/tests/test_schema.c
@@ -21,10 +21,15 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
+#include "ucl.h"
+#include "ucl_internal.h"
+
 #include <stdio.h>
 #include <errno.h>
+
+#ifndef _WIN32
 #include <unistd.h>
-#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 <sys/types.h>
+
+#ifndef _WIN32
 #include <sys/mman.h>
-#include <sys/stat.h>
 #include <sys/time.h>
+#endif
+
+#include <sys/stat.h>
 #include <stdio.h>
 #include <errno.h>
+
+#ifndef _WIN32
 #include <unistd.h>
+#endif
+
 #include <fcntl.h>
 #include <time.h>
 
@@ -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);
 }