721a59b libucl: update to latest upstream version — HardenedBSD-pkg

HardenedBSD-pkg

rad:z3QDZAW2FAfuLvihrhiyDC9fAD8G9

HardenedBSD Package Manager

libucl: update to latest upstream version

Baptiste Daroussin committed 22 days ago

commit 721a59bce99101be08a93ecccd7747ed681d1fea
parent b2354c3

17 files changed +4890 -4652

modified external/libucl/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_ */

modified external/libucl/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

modified external/libucl/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,25 +855,48 @@ 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)
 /**
  * Free resources associated with an inline iterator when iteration is
  * abandoned before completion. Only needed for UCL_OBJECT iteration where
  * internal heap state is allocated. Safe to call with a NULL iterator or
  * on non-object types.
  *
  * Example usage:
  * ucl_object_iter_t it = NULL;
  * while ((cur = ucl_iterate_object(obj, &it, true))) {
  *     if (error) {
  *         ucl_object_iterate_end(obj, &it);
  *         return;
  *     }
  * }
  *
  * @param obj the object being iterated
  * @param iter pointer to the iterator to free
  */
 UCL_EXTERN void ucl_object_iterate_end(const ucl_object_t *obj,
 										ucl_object_iter_t *iter);
 #define ucl_iterate_object_end ucl_object_iterate_end
 /**
  * Create new safe iterator for the specified object
  * @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
  * (such as ucl_object_iterate_safe()) to see if operation has encountered
  * fatal exception while performing that operation (e.g. ENOMEM).
  * @param iter opaque iterator
  * @return true if exception has occurred, false otherwise
  * @return true if exception has occured, false otherwise
  */
 UCL_EXTERN bool ucl_object_iter_chk_excpn(ucl_object_iter_t *it);

@@ -869,8 +905,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 +915,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 +933,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 +961,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 +975,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 +988,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 +997,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 +1015,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 +1027,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 +1042,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 +1051,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 +1060,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 +1070,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 +1082,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 +1092,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 +1106,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 +1117,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 +1129,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 +1139,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 +1151,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 +1164,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 +1175,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 +1187,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 +1201,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 +1212,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 +1221,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 +1230,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 +1292,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 +1300,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 +1310,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 +1319,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 +1330,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 +1340,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 +1374,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 +1384,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 +1396,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 +1409,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 +1428,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 +1443,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 +1485,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 +1496,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 +1508,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 +1521,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 +1594,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 +1623,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 +1635,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 +1651,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
 /*

modified external/libucl/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 [] = {
 X9ebdcae10d981691, 0X32b9b9b97a27ac7d, 0X29b5584d83d35bbd, 0X4b04e0e61401255f,
 X25e8f7b1f1c9d027, 0X80d4c8c000f3e881, 0Xbd1255431904b9dd, 0X8a3bd4485eee6d81,
 X3bc721b2aad05197, 0X71b1a19b907d6e33, 0X525e6c1084a8534b, 0X9e4c2cd340c1299f,
 Xde3add92e94caa37, 0X7e14eadb1f65311d, 0X3f5aa40f89812853, 0X33b15a3b587d15c9,
 static uint64_t _mum_primes[] = {
 X9ebdcae10d981691,
 X32b9b9b97a27ac7d,
 X29b5584d83d35bbd,
 X4b04e0e61401255f,
 X25e8f7b1f1c9d027,
 X80d4c8c000f3e881,
 Xbd1255431904b9dd,
 X8a3bd4485eee6d81,
 X3bc721b2aad05197,
 X71b1a19b907d6e33,
 X525e6c1084a8534b,
 X9e4c2cd340c1299f,
 Xde3add92e94caa37,
 X7e14eadb1f65311d,
 X3f5aa40f89812853,
 X33b15a3b587d15c9,
 };
 /* 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
 x64->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) {

 -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

modified external/libucl/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 */

modified external/libucl/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;
 }

modified external/libucl/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,38 +314,40 @@ 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 {

@@ -356,18 +355,18 @@ ucl_emitter_common_start_object (struct ucl_emitter_context *ctx,

 			if (cur->next != NULL) {
 				if (!first_key) {
 					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);
 					}
 				}
 				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_add_tabs(func, ctx->indent, compact);
 				ucl_emitter_common_start_array(ctx, cur, true, 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 +383,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 +394,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 +430,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 +516,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 +549,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 +559,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 +612,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 +681,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;
 	}

modified external/libucl/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);
 }

modified external/libucl/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,170 @@ 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);
 	/*
 	 * Check if the string contains a backslash followed by a single quote.
 	 * The squoted parser treats \' as an escape sequence, but there is no
 	 * way to escape a literal backslash in squoted strings (the parser's
 	 * default case for \<other> preserves both characters). Fall back to
 	 * double-quoted output to avoid roundtrip corruption.
 	 */
 	{
 		const char *scan = str;
 		size_t remaining = size;
 		while (remaining > 1) {
 			if (scan[0] == '\\' && scan[1] == '\'') {
 				ucl_elt_string_write_json(str, size, ctx);
 				return;
 			}
 			scan++;
 			remaining--;
 		}
 	}
 	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;
 			func->ucl_emitter_append_len("\\\'", 2, func->ud);
 			c = ++p;
 			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);
 	/*
 	 * If the string contains "\nEOD\n", the heredoc would be prematurely
 	 * closed on re-parse.  Fall back to JSON-style escaping in that case.
 	 */
 	if (size >= 4) {
 		const char *found = str;
 		const char *send = str + size - 4;
 		while (found <= send) {
 			found = memchr(found, '\n', send - found + 1);
 			if (found == NULL) {
 				break;
 			}
 			if (memcmp(found + 1, "EOD", 3) == 0 &&
 				(found + 4 >= str + size || found[4] == '\n')) {
 				ucl_elt_string_write_json(str, size, ctx);
 				return;
 			}
 			found++;
 		}
 	}
 	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 +248,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 +290,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 +345,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 +377,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 +429,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 +438,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 +457,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 +484,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 +505,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 +549,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;
 		}
 	}

modified external/libucl/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] = {
 x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
 x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
 x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
 x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f,
 x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27,
 x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f,
 x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37,
 x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f,
 x40, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67,
 x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f,
 x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77,
 x78, 0x79, 0x7a, 0x5b, 0x5c, 0x5d, 0x5e, 0x5f,
 x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67,
 x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f,
 x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77,
 x78, 0x79, 0x7a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f,
 x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
 x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f,
 x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97,
 x98, 0x99, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f,
 xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7,
 xa8, 0xa9, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf,
 xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7,
 xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf,
 xc0, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7,
 xc8, 0xc9, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf,
 xd0, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7,
 xd8, 0xd9, 0xda, 0xdb, 0xdc, 0xdd, 0xde, 0xdf,
 xe0, 0xe1, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7,
 xe8, 0xe9, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef,
 xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
 xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
 };
 #if (defined(WORD_BIT) && WORD_BIT == 64) || \
 x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
 x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
 x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
 x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f,
 x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27,
 x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f,
 x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37,
 x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f,
 x40, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67,
 x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f,
 x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77,
 x78, 0x79, 0x7a, 0x5b, 0x5c, 0x5d, 0x5e, 0x5f,
 x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67,
 x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f,
 x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77,
 x78, 0x79, 0x7a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f,
 x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
 x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f,
 x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97,
 x98, 0x99, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f,
 xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7,
 xa8, 0xa9, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf,
 xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7,
 xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf,
 xc0, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7,
 xc8, 0xc9, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf,
 xd0, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7,
 xd8, 0xd9, 0xda, 0xdb, 0xdc, 0xdd, 0xde, 0xdf,
 xe0, 0xe1, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7,
 xe8, 0xe9, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef,
 xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
 xf8, 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,24 @@ 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;
 }
 void ucl_hash_iterate_free(ucl_hash_iter_t iter)
 {
 	struct ucl_hash_real_iter *it = (struct ucl_hash_real_iter *) (iter);
 	if (it != NULL) {
 		UCL_FREE(sizeof(*it), it);
 	}
 }
 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 +469,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 +490,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 +501,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 +579,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,34 +591,36 @@ 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 (hashlin == NULL) {
 		return;
 	}
 	if (fl & UCL_SORT_KEYS_ICASE) {
 		DL_SORT(hashlin->head, ucl_hash_cmp_icase);

@@ -620,9 +632,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);
 			}
 		}
 	}

modified external/libucl/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) (ucl_object_t *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,21 @@ 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);
 /**
  * Free a hash iterator (used when iteration is abandoned early)
  * @param iter iterator to free, may be NULL
  */
 void ucl_hash_iterate_free(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

modified external/libucl/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
 /**

@@ -141,6 +141,7 @@ typedef SSIZE_T ssize_t;

  */
 #define UCL_MAX_RECURSION 16
 #define UCL_MAX_NESTING 1024
 #define UCL_TRASH_KEY 0
 #define UCL_TRASH_VALUE 1

@@ -182,14 +183,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 +286,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 +303,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 +314,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 +325,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 +336,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 +347,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 +358,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 +400,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 +455,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 +502,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 +518,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 +527,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 +543,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 +581,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 +622,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 +636,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 +648,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_ */

modified external/libucl/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)) >> \
 ) |                                    \
 									   (((uint64_t) (val) &                     \
 										 (uint64_t) (0x0000ff0000000000ULL)) >> \
 ) |                                   \
 									   (((uint64_t) (val) &                     \
 										 (uint64_t) (0x00ff000000000000ULL)) >> \
 ) |                                   \
 									   (((uint64_t) (val) &                     \
 										 (uint64_t) (0xff00000000000000ULL)) >> \
 )))
 #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 {

@@ -145,44 +149,43 @@ ucl_emitter_print_int_msgpack (struct ucl_emitter_context *ctx, int64_t val)

 		/* Bithack abs */
 		uval = ((val ^ (val >> 63)) - (val >> 63));
 		if (val > -(1 << 5)) {
 		if (val >= -32) {
 			len = 1;
 			buf[0] = (mask_negative | uval) & 0xff;
 			buf[0] = (uint8_t)(int8_t)val;
 		}
 		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[] = {
 	{
 xa0,
 ,
 			msgpack_fixstr,
 ,
 			MSGPACK_FLAG_FIXED|MSGPACK_FLAG_KEY,
 			ucl_msgpack_parse_string
 	},
 	{
 x0,
 ,
 			msgpack_positive_fixint,
 ,
 			MSGPACK_FLAG_FIXED|MSGPACK_FLAG_TYPEVALUE,
 			ucl_msgpack_parse_int
 	},
 	{
 xe0,
 ,
 			msgpack_negative_fixint,
 ,
 			MSGPACK_FLAG_FIXED|MSGPACK_FLAG_TYPEVALUE,
 			ucl_msgpack_parse_int
 	},
 	{
 x80,
 ,
 			msgpack_fixmap,
 ,
 			MSGPACK_FLAG_FIXED|MSGPACK_FLAG_CONTAINER|MSGPACK_FLAG_ASSOC,
 			ucl_msgpack_parse_map
 	},
 	{
 x90,
 ,
 			msgpack_fixarray,
 ,
 			MSGPACK_FLAG_FIXED|MSGPACK_FLAG_CONTAINER,
 			ucl_msgpack_parse_array
 	},
 	{
 xd9,
 ,
 			msgpack_str8,
 ,
 			MSGPACK_FLAG_KEY,
 			ucl_msgpack_parse_string
 	},
 	{
 xc4,
 ,
 			msgpack_bin8,
 ,
 			MSGPACK_FLAG_KEY,
 			ucl_msgpack_parse_string
 	},
 	{
 xcf,
 ,
 			msgpack_uint64,
 ,
 			MSGPACK_FLAG_FIXED,
 			ucl_msgpack_parse_int
 	},
 	{
 xd3,
 ,
 			msgpack_int64,
 ,
 			MSGPACK_FLAG_FIXED,
 			ucl_msgpack_parse_int
 	},
 	{
 xce,
 ,
 			msgpack_uint32,
 ,
 			MSGPACK_FLAG_FIXED,
 			ucl_msgpack_parse_int
 	},
 	{
 xd2,
 ,
 			msgpack_int32,
 ,
 			MSGPACK_FLAG_FIXED,
 			ucl_msgpack_parse_int
 	},
 	{
 xcb,
 ,
 			msgpack_float64,
 ,
 			MSGPACK_FLAG_FIXED,
 			ucl_msgpack_parse_float
 	},
 	{
 xca,
 ,
 			msgpack_float32,
 ,
 			MSGPACK_FLAG_FIXED,
 			ucl_msgpack_parse_float
 	},
 	{
 xc2,
 ,
 			msgpack_false,
 ,
 			MSGPACK_FLAG_FIXED | MSGPACK_FLAG_TYPEVALUE,
 			ucl_msgpack_parse_bool
 	},
 	{
 xc3,
 ,
 			msgpack_true,
 ,
 			MSGPACK_FLAG_FIXED | MSGPACK_FLAG_TYPEVALUE,
 			ucl_msgpack_parse_bool
 	},
 	{
 xcc,
 ,
 			msgpack_uint8,
 ,
 			MSGPACK_FLAG_FIXED,
 			ucl_msgpack_parse_int
 	},
 	{
 xcd,
 ,
 			msgpack_uint16,
 ,
 			MSGPACK_FLAG_FIXED,
 			ucl_msgpack_parse_int
 	},
 	{
 xd0,
 ,
 			msgpack_int8,
 ,
 			MSGPACK_FLAG_FIXED,
 			ucl_msgpack_parse_int
 	},
 	{
 xd1,
 ,
 			msgpack_int16,
 ,
 			MSGPACK_FLAG_FIXED,
 			ucl_msgpack_parse_int
 	},
 	{
 xc0,
 ,
 			msgpack_nil,
 ,
 			MSGPACK_FLAG_FIXED | MSGPACK_FLAG_TYPEVALUE,
 			ucl_msgpack_parse_null
 	},
 	{
 xda,
 ,
 			msgpack_str16,
 ,
 			MSGPACK_FLAG_KEY,
 			ucl_msgpack_parse_string
 	},
 	{
 xdb,
 ,
 			msgpack_str32,
 ,
 			MSGPACK_FLAG_KEY,
 			ucl_msgpack_parse_string
 	},
 	{
 xc5,
 ,
 			msgpack_bin16,
 ,
 			MSGPACK_FLAG_KEY,
 			ucl_msgpack_parse_string
 	},
 	{
 xc6,
 ,
 			msgpack_bin32,
 ,
 			MSGPACK_FLAG_KEY,
 			ucl_msgpack_parse_string
 	},
 	{
 xdc,
 ,
 			msgpack_array16,
 ,
 			MSGPACK_FLAG_CONTAINER,
 			ucl_msgpack_parse_array
 	},
 	{
 xdd,
 ,
 			msgpack_array32,
 ,
 			MSGPACK_FLAG_CONTAINER,
 			ucl_msgpack_parse_array
 	},
 	{
 xde,
 ,
 			msgpack_map16,
 ,
 			MSGPACK_FLAG_CONTAINER|MSGPACK_FLAG_ASSOC,
 			ucl_msgpack_parse_map
 	},
 	{
 xdf,
 ,
 			msgpack_map32,
 ,
 			MSGPACK_FLAG_CONTAINER|MSGPACK_FLAG_ASSOC,
 			ucl_msgpack_parse_map
 	},
 	{
 xc7,
 ,
 			msgpack_ext8,
 ,
 			MSGPACK_FLAG_EXT,
 			ucl_msgpack_parse_ignore
 	},
 	{
 xc8,
 ,
 			msgpack_ext16,
 ,
 			MSGPACK_FLAG_EXT,
 			ucl_msgpack_parse_ignore
 	},
 	{
 xc9,
 ,
 			msgpack_ext32,
 ,
 			MSGPACK_FLAG_EXT,
 			ucl_msgpack_parse_ignore
 	},
 	{
 xd4,
 ,
 			msgpack_fixext1,
 ,
 			MSGPACK_FLAG_FIXED | MSGPACK_FLAG_EXT,
 			ucl_msgpack_parse_ignore
 	},
 	{
 xd5,
 ,
 			msgpack_fixext2,
 ,
 			MSGPACK_FLAG_FIXED | MSGPACK_FLAG_EXT,
 			ucl_msgpack_parse_ignore
 	},
 	{
 xd6,
 ,
 			msgpack_fixext4,
 ,
 			MSGPACK_FLAG_FIXED | MSGPACK_FLAG_EXT,
 			ucl_msgpack_parse_ignore
 	},
 	{
 xd7,
 ,
 			msgpack_fixext8,
 ,
 			MSGPACK_FLAG_FIXED | MSGPACK_FLAG_EXT,
 			ucl_msgpack_parse_ignore
 	},
 	{
 xd8,
 ,
 			msgpack_fixext16,
 ,
 			MSGPACK_FLAG_FIXED | MSGPACK_FLAG_EXT,
 			ucl_msgpack_parse_ignore
 	}
 };
 	{0xa0,
 ,
 	 msgpack_fixstr,
 ,
 	 MSGPACK_FLAG_FIXED | MSGPACK_FLAG_KEY,
 	 ucl_msgpack_parse_string},
 	{0x0,
 ,
 	 msgpack_positive_fixint,
 ,
 	 MSGPACK_FLAG_FIXED | MSGPACK_FLAG_TYPEVALUE,
 	 ucl_msgpack_parse_int},
 	{0xe0,
 ,
 	 msgpack_negative_fixint,
 ,
 	 MSGPACK_FLAG_FIXED | MSGPACK_FLAG_TYPEVALUE,
 	 ucl_msgpack_parse_int},
 	{0x80,
 ,
 	 msgpack_fixmap,
 ,
 	 MSGPACK_FLAG_FIXED | MSGPACK_FLAG_CONTAINER | MSGPACK_FLAG_ASSOC,
 	 ucl_msgpack_parse_map},
 	{0x90,
 ,
 	 msgpack_fixarray,
 ,
 	 MSGPACK_FLAG_FIXED | MSGPACK_FLAG_CONTAINER,
 	 ucl_msgpack_parse_array},
 	{0xd9,
 ,
 	 msgpack_str8,
 ,
 	 MSGPACK_FLAG_KEY,
 	 ucl_msgpack_parse_string},
 	{0xc4,
 ,
 	 msgpack_bin8,
 ,
 	 MSGPACK_FLAG_KEY,
 	 ucl_msgpack_parse_string},
 	{0xcf,
 ,
 	 msgpack_uint64,
 ,
 	 MSGPACK_FLAG_FIXED,
 	 ucl_msgpack_parse_int},
 	{0xd3,
 ,
 	 msgpack_int64,
 ,
 	 MSGPACK_FLAG_FIXED,
 	 ucl_msgpack_parse_int},
 	{0xce,
 ,
 	 msgpack_uint32,
 ,
 	 MSGPACK_FLAG_FIXED,
 	 ucl_msgpack_parse_int},
 	{0xd2,
 ,
 	 msgpack_int32,
 ,
 	 MSGPACK_FLAG_FIXED,
 	 ucl_msgpack_parse_int},
 	{0xcb,
 ,
 	 msgpack_float64,
 ,
 	 MSGPACK_FLAG_FIXED,
 	 ucl_msgpack_parse_float},
 	{0xca,
 ,
 	 msgpack_float32,
 ,
 	 MSGPACK_FLAG_FIXED,
 	 ucl_msgpack_parse_float},
 	{0xc2,
 ,
 	 msgpack_false,
 ,
 	 MSGPACK_FLAG_FIXED | MSGPACK_FLAG_TYPEVALUE,
 	 ucl_msgpack_parse_bool},
 	{0xc3,
 ,
 	 msgpack_true,
 ,
 	 MSGPACK_FLAG_FIXED | MSGPACK_FLAG_TYPEVALUE,
 	 ucl_msgpack_parse_bool},
 	{0xcc,
 ,
 	 msgpack_uint8,
 ,
 	 MSGPACK_FLAG_FIXED,
 	 ucl_msgpack_parse_int},
 	{0xcd,
 ,
 	 msgpack_uint16,
 ,
 	 MSGPACK_FLAG_FIXED,
 	 ucl_msgpack_parse_int},
 	{0xd0,
 ,
 	 msgpack_int8,
 ,
 	 MSGPACK_FLAG_FIXED,
 	 ucl_msgpack_parse_int},
 	{0xd1,
 ,
 	 msgpack_int16,
 ,
 	 MSGPACK_FLAG_FIXED,
 	 ucl_msgpack_parse_int},
 	{0xc0,
 ,
 	 msgpack_nil,
 ,
 	 MSGPACK_FLAG_FIXED | MSGPACK_FLAG_TYPEVALUE,
 	 ucl_msgpack_parse_null},
 	{0xda,
 ,
 	 msgpack_str16,
 ,
 	 MSGPACK_FLAG_KEY,
 	 ucl_msgpack_parse_string},
 	{0xdb,
 ,
 	 msgpack_str32,
 ,
 	 MSGPACK_FLAG_KEY,
 	 ucl_msgpack_parse_string},
 	{0xc5,
 ,
 	 msgpack_bin16,
 ,
 	 MSGPACK_FLAG_KEY,
 	 ucl_msgpack_parse_string},
 	{0xc6,
 ,
 	 msgpack_bin32,
 ,
 	 MSGPACK_FLAG_KEY,
 	 ucl_msgpack_parse_string},
 	{0xdc,
 ,
 	 msgpack_array16,
 ,
 	 MSGPACK_FLAG_CONTAINER,
 	 ucl_msgpack_parse_array},
 	{0xdd,
 ,
 	 msgpack_array32,
 ,
 	 MSGPACK_FLAG_CONTAINER,
 	 ucl_msgpack_parse_array},
 	{0xde,
 ,
 	 msgpack_map16,
 ,
 	 MSGPACK_FLAG_CONTAINER | MSGPACK_FLAG_ASSOC,
 	 ucl_msgpack_parse_map},
 	{0xdf,
 ,
 	 msgpack_map32,
 ,
 	 MSGPACK_FLAG_CONTAINER | MSGPACK_FLAG_ASSOC,
 	 ucl_msgpack_parse_map},
 	{0xc7,
 ,
 	 msgpack_ext8,
 ,
 	 MSGPACK_FLAG_EXT,
 	 ucl_msgpack_parse_ignore},
 	{0xc8,
 ,
 	 msgpack_ext16,
 ,
 	 MSGPACK_FLAG_EXT,
 	 ucl_msgpack_parse_ignore},
 	{0xc9,
 ,
 	 msgpack_ext32,
 ,
 	 MSGPACK_FLAG_EXT,
 	 ucl_msgpack_parse_ignore},
 	{0xd4,
 ,
 	 msgpack_fixext1,
 ,
 	 MSGPACK_FLAG_FIXED | MSGPACK_FLAG_EXT,
 	 ucl_msgpack_parse_ignore},
 	{0xd5,
 ,
 	 msgpack_fixext2,
 ,
 	 MSGPACK_FLAG_FIXED | MSGPACK_FLAG_EXT,
 	 ucl_msgpack_parse_ignore},
 	{0xd6,
 ,
 	 msgpack_fixext4,
 ,
 	 MSGPACK_FLAG_FIXED | MSGPACK_FLAG_EXT,
 	 ucl_msgpack_parse_ignore},
 	{0xd7,
 ,
 	 msgpack_fixext8,
 ,
 	 MSGPACK_FLAG_FIXED | MSGPACK_FLAG_EXT,
 	 ucl_msgpack_parse_ignore},
 	{0xd8,
 ,
 	 msgpack_fixext16,
 ,
 	 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,44 @@ 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
 		 */
 		unsigned int depth = 0;
 		struct ucl_stack *sp;
 		for (sp = parser->stack; sp != NULL; sp = sp->next) {
 			depth++;
 		}
 		if (depth >= UCL_MAX_NESTING) {
 			ucl_create_err(&parser->err,
 						   "msgpack containers are nested too deep (over %d)",
 						   UCL_MAX_NESTING);
 			return NULL;
 		}
 		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 +737,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 +748,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 +757,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 +770,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 +795,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 +811,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 +828,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 +847,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 +895,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 +916,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 +932,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 +945,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 +956,43 @@ 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);
 				case 2: {
 					uint16_t v;
 					memcpy(&v, p, sizeof(v));
 					len = FROM_BE16(v);
 					break;
 				case 4:
 					len = FROM_BE32 (*(uint32_t *)p);
 				}
 				case 4: {
 					uint32_t v;
 					memcpy(&v, p, sizeof(v));
 					len = FROM_BE32(v);
 					break;
 				case 8:
 					len = FROM_BE64 (*(uint64_t *)p);
 				}
 				case 8: {
 					uint64_t v;
 					memcpy(&v, p, sizeof(v));
 					len = FROM_BE64(v);
 					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 +1005,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 +1014,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 +1045,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 +1081,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,20 +1118,21 @@ 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;
 			}
 			key = p;
 			keylen = len;
 			if (keylen > remain || keylen == 0) {
 				ucl_create_err (&parser->err, "too long or empty key");
 			if (len == 0 || (int64_t)len > remain) {
 				ucl_create_err(&parser->err, "too long or empty key");
 				return false;
 			}
 			keylen = len;
 			p += len;
 			remain -= len;

@@ -1196,27 +1148,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 +1187,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 +1199,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 +1242,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 +1267,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 +1285,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 +1309,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 +1324,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 +1334,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 +1344,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 +1354,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 +1364,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 +1381,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 +1399,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 +1407,33 @@ ucl_msgpack_parse_int (struct ucl_parser *parser,

 		len = 1;
 		break;
 	case msgpack_negative_fixint:
 		obj->value.iv = - (*pos & 0x1f);
 		obj->value.iv = (int8_t)*pos;
 		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 +1444,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 +1456,7 @@ ucl_msgpack_parse_int (struct ucl_parser *parser,

 		len = 8;
 		break;
 	default:
 		assert (0);
 		assert(0);
 		break;
 	}

@@ -1511,9 +1466,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 +1481,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 +1498,7 @@ ucl_msgpack_parse_float (struct ucl_parser *parser,

 		len = 8;
 		break;
 	default:
 		assert (0);
 		assert(0);
 		break;
 	}

@@ -1553,9 +1508,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 +1518,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 +1528,7 @@ ucl_msgpack_parse_bool (struct ucl_parser *parser,

 		obj->value.iv = false;
 		break;
 	default:
 		assert (0);
 		assert(0);
 		break;
 	}

@@ -1583,9 +1538,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 +1548,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 +1585,15 @@ 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;
 	}
 	if (len > remain) {
 		return -1;
 	}
 	parser->cur_obj = NULL;
 	return len;
 }

modified external/libucl/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,11 +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);
 		}

@@ -369,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;

@@ -381,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;
 					}

@@ -395,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;

@@ -429,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;

@@ -442,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++;

@@ -450,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;

@@ -474,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 {

@@ -499,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++;
 			}
 		}
 	}

@@ -523,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;

@@ -539,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++;
 		}
 	}

@@ -553,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;
 	}

@@ -563,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++;

@@ -589,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;

@@ -635,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;

@@ -656,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;
 		}

@@ -682,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;

@@ -701,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;
 	}

@@ -725,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) {

@@ -785,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') {

@@ -797,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++;
 					}
 				}
 			}

@@ -834,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) {

@@ -867,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;
 	}

@@ -899,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;
 					}

@@ -914,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;

@@ -944,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;
 						}

@@ -954,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;
 				}

@@ -970,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;
 			}

@@ -989,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;

@@ -1005,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;
 		}

@@ -1047,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;

@@ -1063,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;

@@ -1080,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;

@@ -1095,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;

@@ -1139,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;
 }

@@ -1165,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;

@@ -1174,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;

@@ -1243,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:

@@ -1282,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) {
 				/*

@@ -1290,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:

@@ -1319,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) {
 				/*

@@ -1331,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;
 		}

@@ -1343,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;
 }

@@ -1357,25 +1373,29 @@ 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)
 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_content = 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 == '.') {
 		/* It is macro actually */
 		if (!(parser->flags & UCL_PARSER_DISABLE_MACRO)) {
 			ucl_chunk_skipc (chunk, p);
 		}
 	if (p >= chunk->end) {
 		ucl_set_err(parser, UCL_ESYNTAX,
 					"unexpected end of input while parsing key",
 					&parser->err);
 		*end_of_object = true;
 		return true;
 	}
 	if (*p == '.' && !(parser->flags & UCL_PARSER_DISABLE_MACRO)) {
 		ucl_chunk_skipc(chunk, p);
 		parser->prev_state = parser->state;
 		parser->state = UCL_STATE_MACRO_NAME;
 		*end_of_object = false;

@@ -1386,66 +1406,66 @@ 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);
 				got_content = true;
 				ucl_chunk_skipc(chunk, p);
 				*got_content = true;
 			}
 			else if (*p == '"') {
 				/* JSON style key */
 				c = p + 1;
 				got_quote = true;
 				got_content = true;
 				ucl_chunk_skipc (chunk, p);
 				*got_content = true;
 				ucl_chunk_skipc(chunk, p);
 			}
 			else if (*p == '}') {
 				/* We have actually end of an object */
 				*end_of_object = true;
 				return true;
 			}
 			else if (*p == '.') {
 				ucl_chunk_skipc (chunk, p);
 			else if (*p == '.' && !(parser->flags & UCL_PARSER_DISABLE_MACRO)) {
 				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)) {
 					got_content = true;
 					ucl_chunk_skipc (chunk, p);
 				if (ucl_test_character(*p, UCL_CHARACTER_KEY)) {
 					*got_content = true;
 					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 */

@@ -1456,44 +1476,44 @@ 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);
 	if (p >= chunk->end && *got_content) {
 		ucl_set_err(parser, UCL_ESYNTAX, "unfinished key", &parser->err);
 		return false;
 	}
 	else if (!got_content) {
 	else if (!*got_content) {
 		return true;
 	}
 	*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;

@@ -1505,7 +1525,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;
 	}

@@ -1521,8 +1541,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 != '[') {

@@ -1534,33 +1554,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;
 	}

@@ -1581,8 +1601,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 {

@@ -1598,25 +1618,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;
 			}
 		}

@@ -1625,17 +1645,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;

@@ -1652,10 +1672,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;

@@ -1670,11 +1690,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;

@@ -1694,14 +1714,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;

@@ -1711,16 +1731,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 */

@@ -1737,7 +1757,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;

@@ -1748,12 +1768,13 @@ 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 (p < chunk->end &&
 		(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;

@@ -1763,24 +1784,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;
 			}

@@ -1790,13 +1811,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;
 			}

@@ -1805,10 +1826,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;
 			}

@@ -1819,14 +1840,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);
 				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;

@@ -1835,19 +1859,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);
 				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;

@@ -1857,7 +1884,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;

@@ -1872,40 +1899,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);
 				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;

@@ -1919,14 +1952,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);
 				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;
 					}

@@ -1938,42 +1978,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;

@@ -1996,7 +2036,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;

@@ -2005,48 +2045,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) {

@@ -2062,13 +2107,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;
 				}

@@ -2077,21 +2122,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;

@@ -2102,8 +2147,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 {

@@ -2114,7 +2159,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;

@@ -2122,15 +2168,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:

@@ -2148,7 +2194,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:

@@ -2160,7 +2206,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:

@@ -2172,7 +2218,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:

@@ -2184,17 +2230,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;

@@ -2214,21 +2260,28 @@ 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;
 	p = chunk->pos;
 	if (p >= chunk->end) {
 		ucl_set_err(parser, UCL_ESYNTAX,
 					"unexpected end of input while parsing macro value",
 					&parser->err);
 		return false;
 	}
 	switch (*p) {
 	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;
 		}

@@ -2238,11 +2291,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;

@@ -2253,20 +2306,26 @@ ucl_parse_macro_value (struct ucl_parser *parser,

 			if (*p == '}') {
 				break;
 			}
 			ucl_chunk_skipc (chunk, p);
 			ucl_chunk_skipc(chunk, p);
 		}
 		if (p >= chunk->end) {
 			ucl_set_err(parser, UCL_ESYNTAX,
 						"unterminated macro value, missing '}'",
 						&parser->err);
 			return false;
 		}
 		*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;

@@ -2276,10 +2335,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;
 }

@@ -2291,8 +2350,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;

@@ -2307,12 +2366,12 @@ ucl_parse_macro_arguments (struct ucl_parser *parser,

 	saved.remain = chunk->remain;
 	p = chunk->pos;
 	if (*p != '(' || chunk->remain < 2) {
 	if (chunk->remain < 2 || *p != '(') {
 		return NULL;
 	}
 	/* Set begin and start */
 	ucl_chunk_skipc (chunk, p);
 	ucl_chunk_skipc(chunk, p);
 	c = p;
 	while ((p) < (chunk)->end) {

@@ -2320,10 +2379,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;

@@ -2333,13 +2392,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 */

@@ -2349,23 +2408,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;

@@ -2384,20 +2443,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

@@ -2405,7 +2465,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;

@@ -2413,7 +2473,7 @@ ucl_state_machine (struct ucl_parser *parser)

 	unsigned char *macro_escaped;
 	size_t macro_len = 0;
 	struct ucl_macro *macro = NULL;
 	bool next_key = false, end_of_object = false, ret;
 	bool next_key = false, end_of_object = false, got_content = false, ret;
 	if (parser->top_obj == NULL) {
 		parser->state = UCL_STATE_INIT;

@@ -2428,7 +2488,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;

@@ -2437,9 +2497,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;

@@ -2447,13 +2507,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;
 						}

@@ -2465,12 +2525,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) {

@@ -2480,14 +2540,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 */

@@ -2496,13 +2557,17 @@ 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;
 			}
 			if (!ucl_parse_key (parser, chunk, &next_key, &end_of_object)) {
 			got_content = false;
 			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;

@@ -2516,16 +2581,17 @@ 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;
 					}
 				}
 				else {
 				else if (got_content) {
 					/* Do not switch state if we have not read any content */
 					parser->state = UCL_STATE_VALUE;
 				}
 			}

@@ -2536,7 +2602,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;

@@ -2545,7 +2611,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;

@@ -2569,13 +2635,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;
 				}

@@ -2585,25 +2651,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;
 						}

@@ -2613,11 +2679,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;
 					}

@@ -2626,7 +2692,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);

@@ -2635,46 +2701,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);
 			}
 			/*

@@ -2684,16 +2750,19 @@ 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) {
 				return false;
 			}
 			break;
 		case UCL_STATE_ERROR:
 			/* 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;
 		}

@@ -2701,16 +2770,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);
 		}
 	}

@@ -2718,19 +2787,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;
 			}

@@ -2746,22 +2816,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);

@@ -2774,12 +2845,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;

@@ -2788,8 +2859,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;

@@ -2800,8 +2870,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;

@@ -2810,9 +2879,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;

@@ -2820,26 +2888,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;

@@ -2847,27 +2914,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;

@@ -2876,8 +2942,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;
 		}

@@ -2887,10 +2954,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 */

@@ -2899,38 +2966,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;

@@ -2940,43 +3005,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;

@@ -2985,7 +3051,7 @@ ucl_parser_add_chunk_full (struct ucl_parser *parser, const unsigned char *data,

 		if (parse_type == UCL_PARSE_AUTO && len > 0) {
 			/* We need to detect parse type by the first symbol */
 			if ((*data & 0x80) == 0x80 && (*data >= 0xdc && *data <= 0xdf)) {
 			if ((*data & 0x80) == 0x80) {
 				parse_type = UCL_PARSE_MSGPACK;
 			}
 			else if (*data == '(') {

@@ -3007,15 +3073,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;
 		}

@@ -3024,11 +3090,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 {

@@ -3038,46 +3104,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;

@@ -3094,15 +3157,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;

@@ -3110,47 +3173,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) {

@@ -3160,17 +3220,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) {

@@ -3178,13 +3238,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;

@@ -3193,21 +3253,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;
 }

modified external/libucl/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;
 			}

@@ -991,19 +991,21 @@ ucl_schema_validate (const ucl_object_t *schema,

 		}
 		else {
 			/* Reset error */
 			err->code = UCL_SCHEMA_OK;
 			if (err != NULL) {
 				err->code = UCL_SCHEMA_OK;
 			}
 		}
 	}
 	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,50 +1015,52 @@ 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 {
 			/* Reset error */
 			err->code = UCL_SCHEMA_OK;
 			if (err != NULL) {
 				err->code = UCL_SCHEMA_OK;
 			}
 		}
 	}
 	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 +1069,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;

modified external/libucl/src/ucl_sexp.c

@@ -31,38 +31,38 @@

 #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;                      \
 				state = read_length;          \
 				break;                        \
 			}                                 \
 		}                                     \
 	} while (0)
 bool ucl_parse_csexp(struct ucl_parser *parser)
 {
 	const unsigned char *p, *end;
 	ucl_object_t *obj;
 	struct ucl_stack *st;
 	uint64_t len = 0, mult = 1;
 	uint64_t len = 0;
 	unsigned int depth = 0;
 	enum {
 		start_parse,
 		read_obrace,

@@ -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,36 @@ 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));
 			if (depth >= UCL_MAX_NESTING) {
 				ucl_create_err(&parser->err,
 							   "csexp nesting too deep (over %d)",
 							   UCL_MAX_NESTING);
 				state = parse_err;
 				continue;
 			}
 			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 +131,11 @@ 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 ++;
 			depth++;
 			p++;
 			NEXT_STATE;
 			break;

@@ -133,7 +143,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;
 				}

@@ -141,44 +151,51 @@ ucl_parse_csexp (struct ucl_parser *parser)

 				state = read_value;
 			}
 			else if (*p >= '0' && *p <= '9') {
 				len += (*p - '0') * mult;
 				mult *= 10;
 				len = len * 10 + (*p - '0');
 				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);
 			if (parser->stack == NULL) {
 				ucl_object_unref(obj);
 				ucl_create_err(&parser->err, "value outside of any list");
 				state = parse_err;
 				continue;
 			}
 			ucl_array_append(parser->stack->obj, obj);
 			p += len;
 			NEXT_STATE;
 			break;

@@ -186,8 +203,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;
 			}

@@ -195,30 +213,55 @@ ucl_parse_csexp (struct ucl_parser *parser)

 			st = parser->stack;
 			parser->stack = st->next;
 			if (parser->stack->obj->type == UCL_ARRAY) {
 				ucl_array_append (parser->stack->obj, st->obj);
 			}
 			else {
 				ucl_create_err (&parser->err, "bad container object, array "
 						"expected");
 				state = parse_err;
 				continue;
 			if (parser->stack != NULL) {
 				if (parser->stack->obj->type == UCL_ARRAY) {
 					ucl_array_append(parser->stack->obj, st->obj);
 				}
 				else {
 					ucl_create_err(&parser->err, "bad container object, array "
 												 "expected");
 					state = parse_err;
 					continue;
 				}
 			}
 			free (st);
 			free(st);
 			st = NULL;
 			if (depth > 0) {
 				depth--;
 			}
 			p++;
 			NEXT_STATE;
 			break;
 		case parse_err:
 		default:
 			/* Clean up orphaned stack objects that were never appended
 			 * to the tree. The outermost frame's obj == parser->top_obj
 			 * and will be freed by ucl_parser_free; all others are
 			 * orphaned and must be explicitly released here. */
 			while (parser->stack != NULL) {
 				struct ucl_stack *st_err = parser->stack;
 				parser->stack = st_err->next;
 				if (st_err->obj != NULL && st_err->obj != parser->top_obj) {
 					ucl_object_unref(st_err->obj);
 				}
 				free(st_err);
 			}
 			return false;
 		}
 	}
 	if (state != read_ebrace) {
 		ucl_create_err (&parser->err, "invalid finishing state: %d", state);
 		ucl_create_err(&parser->err, "invalid finishing state: %d", state);
 		while (parser->stack != NULL) {
 			struct ucl_stack *st_err = parser->stack;
 			parser->stack = st_err->next;
 			if (st_err->obj != NULL && st_err->obj != parser->top_obj) {
 				ucl_object_unref(st_err->obj);
 			}
 			free(st_err);
 		}
 		return false;
 	}

modified external/libucl/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,13 +1093,18 @@ 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;
 	snprintf (filebuf, sizeof (filebuf), "%.*s", (int)len, data);
 	if (ucl_realpath (filebuf, realbuf) == NULL) {
 	if (parser->state == UCL_STATE_ERROR) {
 		/* Return immediately if we are in the error state... */
 		return false;
 	}
 	snprintf(filebuf, sizeof(filebuf), "%.*s", (int) len, data);
 	if (ucl_realpath(filebuf, realbuf) == NULL) {
 		if (params->soft_fail) {
 			return false;
 		}

@@ -1109,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;
 		}

@@ -1136,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;
 	}

@@ -1146,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
 	}

@@ -1178,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';
 		}

@@ -1207,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;

@@ -1247,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;

@@ -1267,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);
 				}
 			}
 		}

@@ -1293,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;

@@ -1338,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;

@@ -1354,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;

@@ -1421,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;

@@ -1434,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 */

@@ -1443,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;

@@ -1462,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;

@@ -1510,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;

@@ -1541,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;
 		}
 	}

@@ -1654,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);
 }
 /**

@@ -1671,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);
 }
 /**

@@ -1688,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);
 }
 /**

@@ -1705,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;

@@ -1722,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;
 				}
 			}

@@ -1734,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;
 		}

@@ -1751,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;
 }

@@ -1763,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;

@@ -1801,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;

@@ -1934,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;

@@ -2129,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;

@@ -2148,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;

@@ -2170,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;
 			}
 		}

@@ -2180,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;

@@ -2240,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;

@@ -2267,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':

@@ -2277,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++ = '\\';

@@ -2313,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++ = '\\';

@@ -2321,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++ = '\\';

@@ -2347,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;

@@ -2358,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);
 			}
 		}
 	}

@@ -2378,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;

@@ -2407,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;
 		}

@@ -2423,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;
 	}

@@ -2434,60 +2427,57 @@ 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 ++;
 		if (replace) {
 			ret = false;
 		}
 		top->value.ov = ucl_hash_insert_object(top->value.ov, elt, false);
 		top->len++;
 		/* Key was inserted - return true regardless of replace flag */
 	}
 	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;

@@ -2495,73 +2485,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;

@@ -2573,16 +2558,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;
 			}

@@ -2591,67 +2576,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);
 				}
 			}
 		}

@@ -2665,7 +2651,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;

@@ -2676,24 +2662,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;

@@ -2703,31 +2689,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;

@@ -2738,22 +2724,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;

@@ -2772,13 +2758,27 @@ 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 */
 	return NULL;
 }
 void
 ucl_object_iterate_end(const ucl_object_t *obj, ucl_object_iter_t *iter)
 {
 	if (iter == NULL || *iter == NULL) {
 		return;
 	}
 	if (obj != NULL && obj->type == UCL_OBJECT) {
 		ucl_hash_iterate_free(*iter);
 	}
 	*iter = NULL;
 }
 enum ucl_safe_iter_flags {
 	UCL_ITERATE_FLAG_UNDEFINED = 0,
 	UCL_ITERATE_FLAG_INSIDE_ARRAY,

@@ -2792,51 +2792,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);
 		}
 	}

@@ -2847,21 +2847,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;

@@ -2869,7 +2868,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;

@@ -2881,19 +2880,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 {

@@ -2905,7 +2904,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);
 			}
 		}
 	}

@@ -2913,30 +2912,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;

@@ -2951,25 +2951,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) {

@@ -2989,95 +2989,105 @@ 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 == NULL) {
 			/* Allocate array storage if not present (e.g., copied empty array) */
 			vec = UCL_ALLOC(sizeof(*vec));
 			if (vec == NULL) {
 				return false;
 			}
 			kv_init(*vec);
 			obj->value.av = (void *)vec;
 		}
 		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;

@@ -3086,24 +3096,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;

@@ -3113,11 +3123,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;

@@ -3126,12 +3136,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;

@@ -3140,64 +3150,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;

@@ -3208,24 +3223,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++;
 		}
 	}

@@ -3235,9 +3250,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;

@@ -3245,11 +3264,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;
 		}
 	}

@@ -3258,12 +3277,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;
 	}

@@ -3271,9 +3290,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;

@@ -3283,45 +3302,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);

@@ -3331,53 +3358,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) {

@@ -3386,17 +3425,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;

@@ -3417,16 +3465,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;

@@ -3447,16 +3494,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;

@@ -3472,17 +3518,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;

@@ -3491,7 +3535,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:

@@ -3502,27 +3546,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;

@@ -3542,22 +3585,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;

@@ -3567,7 +3610,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;

@@ -3578,14 +3621,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
 		}
 	}

@@ -3593,17 +3636,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;

@@ -3616,8 +3663,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];

@@ -3625,34 +3672,36 @@ 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];
 			}
 		}
 		if (other->type == UCL_ARRAY || other->type == UCL_OBJECT) {
 			/* reset old value */
 			memset (&new->value, 0, sizeof (new->value));
 			/* reset old value and length since we will re-add elements below */
 			memset(&new->value, 0, sizeof(new->value));
 			new->len = 0;
 			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);
 				}
 			}
 		}

@@ -3662,28 +3711,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;

@@ -3696,7 +3743,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;

@@ -3705,21 +3752,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;

@@ -3728,7 +3775,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;
 					}

@@ -3741,13 +3788,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;
 				}

@@ -3765,85 +3812,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)) -
 );
 		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 {

@@ -3854,7 +3898,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";

@@ -3890,7 +3934,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;

@@ -3900,35 +3944,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;
 		}

@@ -3937,27 +3980,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;
 }