CMAKE_MINIMUM_REQUIRED(VERSION 3.1.0 FATAL_ERROR)

SET(LIBUCL_VERSION_MINOR 8)

SET(LIBUCL_VERSION_PATCH 3)

        PUBLIC

          $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>

          $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>

        PRIVATE

          ${CMAKE_CURRENT_SOURCE_DIR}/src

          ${CMAKE_CURRENT_SOURCE_DIR}/uthash

          ${CMAKE_CURRENT_SOURCE_DIR}/klib)

INSTALL(TARGETS ucl EXPORT uclConfig DESTINATION ${CMAKE_INSTALL_LIBDIR}

install(EXPORT uclConfig

	FILE ucl-config.cmake

	NAMESPACE ucl::

	DESTINATION "share/ucl"

)

- Couple of memory leaks plugged

### Libucl 0.8.2

* .include: also validate priority to be within range

* Add -W into list of warnings

* Add ability to add file preprocessors

* Add ability to pass both the parser and userdata into a macro handler

* Add missing tests for .gitignore

* Add more safe guards when trying to insert objects

* Add some documentation/example about the .priority macro

* Add tests for single quotes

* Added CMake compile definitions

* Added CMake support to build utils

* Added a fuzzer for OSS-fuzz integration

* Added a return statement if the string is 0

* Added default CMake "build" directory to gitignore

* Added fuzzer for msgpack

* Adding another fix

* Adjust example.

* Allow to test msgpack inputs

* Another sync

* Assume gcov absense as a non-fatal error

* Avoid read when a chunk is ended

* CMake: Install headers and library.

* Check for NULL inputs in ucl_object_compare()

* Cleanup CURL handle after use

* Cleanup CURL handle after use

* Convert ucl_hash_insert() from returning int to returning bool.

* Convert ucl_hash_reserve() from returning int to bool.

* Do not try to emit single quoted strings in json mode

* Document single quotes

* Document ucl_object_iter_chk_excpn().

* Document usage of ucl_object_iter_chk_excpn().

* Don't double-escape Lua strings

* Excercise ucl_object_iter_chk_excpn().

* Fix '\v' encoding

* Fix 68d87c362b0d7fbb45f395bfae616a28439e0bbc by setting error to 0 always. Which makes it even uglier.

* Fix cmake public include install

* Fix emitting of the bad unicode escapes

* Fix format strings, add printf attribute to schema functions

* Fix levels and objects closing

* Fix load macro with try=true

* Fix mismerge.

* Fix mismerge.

* Fix old issue with parsing numbers

* Fix processing of the incomplete msgpack objects

* Fix remain calculations

* Fix remain lenght calculation that led to assertion failure

* Fix single quotes emitting

* Fix spelling and markup errors.

* Fix typos: replace missmatch with mismatch

* Fix ucl++ bug where iterators stop on a null field.

* Fix ucl_util.c not having the prototype for ucl_hash_sort()

* Fix variables expansion

* Fix vertical tab handling

* Fixed Visual Studio compilation error

* Fixed expanding variables at runtime

* Fixed linker error

* Fixed ucl_tool's command line argument parsing

* Fixing error with installing using pip from git with following command: 'pip install -e git+https://github.com/vstakhov/libucl.git/#egg=ucl

* Forgot hash sort function

* Improve ENOMEM handling: handle most of errors while consuructing parser, also extend iterator routines to allow capturing such exception and checking it in the higher level code using new ucl_object_iter_chk_excpn() API.

* Mark + as unsafe which fixes export a key with + in config mode

* Modernise the CMake build system slightly.

* Modernize CMake file with target-based includes.

* Pass correct pointer to var_handler

* Port util objdump to Windows (Visual Studio)

* Port util ucl-tool to Windows

* Provide inline free(3) wrapper, so it's easier to plug the code into out memory usage tracking framework.

* Provide inline free(3) wrapper, so it's easier to plug the code into out memory usage tracking framework.

* Provide priority validation for the .priority macro

* Put space between "exit" and ().

* Put space between name of teh function and ().

* Python build fixes

* Read data in chunks

* Remove leak in the test

* Remove one more bit of unused logic

* Remove one more stupid assertion

* Remove unnecessary (and ignored) `const` from return types.

* Remove unnecessary std::move from return statement.

* Remove unused CMake logic and ad -Wno-pointer-sign.

* Removed dependency from rspamd CMake file

* Removed null-terminator for input data

* Rename ENOMEM-safe version of kv_xxx macros from kv_xxx into kv_xxx_safe and put back old version as well (with a big warning in the header file) for a compat purposes.

* Renamed util binaries to match autotools

* Replace *neat* and *tidy* implementation of kv_xxx() macros using error handling labels with a much *uglier* implementation using "error code pointer". One man's "ugly" is other man's "pretty", I suppose.

* Replaced spaces by tabs to match coding style

* Rework hash table structure to provide pointers and order safety

* Save chunk in the parser stack

* Save filename in chunk

* Split level and flags, add obrace flag, fix msgpack flags

* Squelch incompatible pointer type warning

* Support single quoted strings

* Suppress the [-Wunused-parameter] warning.

* Sync changes from Rspamd

* Sync changes from rspamd

* Sync with Rspamd

* Understand nan and inf

* Use safe iterator - avoid leaking memory.

* docs: fix simple typo, tectual -> textual

* fix: Changed OpenSSL check inside configure.am

* fix: Incorrect pointer arithmetics in ucl_expand_single_variable

* fix: ucl_expand_single_variable doesn't call free

* lua: Return early when init fails

* make use of the undocumented flag UCL_PARSER_NO_IMPLICIT_ARRAYS, so that multiple keys are treated as arrays, and special code doesn't have to be added to the Python module to handle it.

* mypy/stubgen: add typeinterfaces for ucl python module

* o `ucl_object_iterate2()` -> `ucl_object_iterate_with_error()`;

* python: update package to 0.8.1

* `ucl_check_variable`: fix out_len on unterminated variable

* `ucl_chunk_skipc`: avoid out-of-bounds read

* `ucl_expand_single_variable`: better bounds check

* `ucl_expand_variable`: fix out-of-bounds read

* `ucl_inherit_handler`: fix format string for non-null-terminated strings

* `ucl_lc_cmp` is not used outside ucl_hash.c

* `ucl_lex_json_string`: fix out-of-bounds read

* `ucl_maybe_parse_number`: if there is trailing content, it is not a number

* `ucl_object_copy_internal`: null terminate keys

* `ucl_object_copy_internal`: use memcpy instead of strdup

* `ucl_object_free` is deprecated

* `ucl_parse_value`: fix out-of-bounds read

* `ucl_strnstr`: fix out-of-bounds read

* update JSON example to match w/ UCL example

	-$(LCOV) --gcov-tool $(GCOV) --zerocounters --directory $(top_builddir) || true

* `YAML` - yaml inlined notation;

* `messagepack` - MessagePack binary format.

m4_define([min_ver], [3])

			/*

			 * ucl_object_fromstring_common has a `logic` to use strlen if sz is zero

			 * which is totally broken...

			 */

			if (sz > 0) {

				obj = ucl_object_fromstring_common(str, sz, flags);

			}

			else {

				obj = ucl_object_fromstring_common("", sz, flags);

			}

#if defined(__x86_64__) && defined(_MUM_FRESH_GCC)

	struct ucl_hash_elt *prev, *next;

	struct ucl_hash_elt *head;

KHASH_INIT (ucl_hash_node, const ucl_object_t *, struct ucl_hash_elt *, 1,

KHASH_INIT (ucl_hash_caseless_node, const ucl_object_t *, struct ucl_hash_elt *, 1,

		new->head = NULL;

		const ucl_object_t *cur, *tmp;

				cur = (kh_value (h, k))->obj;

	struct ucl_hash_elt *cur, *tmp;

	DL_FOREACH_SAFE(hashlin->head, cur, tmp) {

		UCL_FREE(sizeof(*cur), cur);

	}

	struct ucl_hash_elt **pelt, *elt;

			elt = UCL_ALLOC(sizeof(*elt));

			pelt = &kh_value (h, k);

			*pelt = elt;

			DL_APPEND(hashlin->head, elt);

		}

		else if (ret < 0) {

			goto e0;

			elt = UCL_ALLOC(sizeof(*elt));

			pelt = &kh_value (h, k);

			*pelt = elt;

			DL_APPEND(hashlin->head, elt);

	struct ucl_hash_elt *elt, *nelt;

			elt = kh_value(h, k);

			nelt = UCL_ALLOC(sizeof(*nelt));

			nelt->obj = new;

			kh_value(h, k) = nelt;

			DL_REPLACE_ELEM(hashlin->head, elt, nelt);

			UCL_FREE(sizeof(*elt), elt);

			nelt = UCL_ALLOC(sizeof(*nelt));

			nelt->obj = new;

			kh_value(h, k) = nelt;

			DL_REPLACE_ELEM(hashlin->head, elt, nelt);

			UCL_FREE(sizeof(*elt), elt);

	const struct ucl_hash_elt *cur;

		it->cur = hashlin->head;

	if (it->cur) {

		ret = it->cur->obj;

		it->cur = it->cur->next;

	return it->cur != NULL;

			elt = kh_value (h, k);

			elt = kh_value (h, k);

			elt = kh_value (h, k);

			DL_DELETE(hashlin->head, elt);

			UCL_FREE(sizeof(*elt), elt);

			elt = kh_value (h, k);

			DL_DELETE(hashlin->head, elt);

			UCL_FREE(sizeof(*elt), elt);

	if (sz > kh_size((khash_t(ucl_hash_node) *)hashlin->hash)) {

	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 ((int)(oa->obj->keylen)) - ob->obj->keylen;

	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 ((int)(oa->obj->keylen)) - ob->obj->keylen;

		DL_SORT(hashlin->head, ucl_hash_cmp_icase);

		DL_SORT(hashlin->head, ucl_hash_cmp_case_sens);

		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);

	if (p == chunk->end) {       \

		break;                   \

	}                            \

						if (chunk->remain > 0 && *p == '/') {

		if(p == end) {

			(*out_len) ++;

		}

 * @param in_len

 * @param out_len

		size_t in_len, unsigned char **dest, size_t out_len)

	/* For the $ sign */

	in_len --;

		in_len --;

		if (out_len >= var->value_len && in_len >= (var->var_len + (strict ? 1 : 0))) {

				if (!strict || p[var->var_len] == '}') {

					memcpy (d, var->value, var->value_len);

					ret += var->var_len;

					d += var->value_len;

					found = true;

					break;

				}

			dstlen = out_len;

			if (parser->var_handler (p, in_len, &dst, &dstlen, &need_free,

				if (dstlen > out_len) {

					/* We do not have enough space! */

					if (need_free) {

						free (dst);

					}

				}

				else {

					memcpy(d, dst, dstlen);

					ret += in_len;

					d += dstlen;

					found = true;

					if (need_free) {

						free(dst);

					}

		/* Leave variable as is, in this case we use dest */

			if (strict && out_len >= 2) {

	unsigned char *d, *d_end;

		if (*p == '$' && p + 1 != end) {

	d_end = d + out_len;

	while (p != end && d != d_end) {

		if (*p == '$' && p + 1 != end) {

			p = ucl_expand_single_variable (parser, p, end - p, &d, d_end - d);

		UCL_FREE(sizeof (struct ucl_stack), st);

			is_time = false, valid_start = false, is_hex = false;

	int is_neg = 0;

		is_neg = 1;

			p ++;

		else if (!allow_double && *p == '.') {

			/* Unexpected dot */

			*pos = start;

			return EINVAL;

		}

	if (!valid_start || p == c) {

	char numbuf[128];

	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);

	}

	else {

		ucl_strlcpy (numbuf, c, p - c + 1);

	}

		dv = strtod (numbuf, &endptr);

			lv = strtoimax (numbuf, &endptr, 16);

			lv = strtoimax (numbuf, &endptr, 10);

	/* 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;

	}

	if (endptr >= end) {

		p = end;

		goto set_obj;

	}

					if (end - p > 0 && !ucl_lex_is_atom_end (*p)) {

						*pos = start;

						return EINVAL;

					}

					if (end - p > 0 && !ucl_lex_is_atom_end (*p)) {

						*pos = start;

						return EINVAL;

					}

						if (end - p > 0 && !ucl_lex_is_atom_end (*p)) {

							*pos = start;

							return EINVAL;

						}

				if (end - p > 0 && !ucl_lex_is_atom_end (*p)) {

					*pos = start;

					return EINVAL;

				}

		p = end;

			obj->value.dv = dv;

			obj->value.iv = lv;

			c = *p;

			if (ucl_test_character (c, UCL_CHARACTER_ESCAPE)) {

					if(p == chunk->end) {

						ucl_set_err (parser, UCL_ESYNTAX,

								"unterminated multiline value", &parser->err);

						return false;

					}

					UCL_FREE(sizeof (struct ucl_chunk), chunk);

#include <inttypes.h>

			iter = ucl_object_iterate_new (obj);

			while ((elt = ucl_object_iterate_safe (iter, true)) != NULL) {

					piter = ucl_object_iterate_new (pat);

					while ((pelt = ucl_object_iterate_safe (piter, true)) != NULL) {

					ucl_object_iterate_free (piter);

					piter = NULL;

			ucl_object_iterate_free (iter);

			iter = NULL;

#if defined(_WIN32)

	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) {

		close (fd);

		close (fd);

		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));

	close (fd);

		if (!params->must_exist) {

			ucl_parser_clear_error (parser);

		}

		ucl_parser_clear_error (parser);

			if (buf) {

				ucl_munmap (buf, buflen);

			}

			if (buf) {

				ucl_munmap (buf, buflen);

			}

						ucl_object_unref (new_obj);

		priority = strtol(value, &leftover, 10);

		if (*leftover != '\0') {

			if (try_load) {

				ucl_parser_clear_error (parser);

			}

		ucl_create_err (&parser->err, "Unable to find inherited object %.*s",

				if ((sc = *s++) == 0 || len-- < mlen)

						ucl_object_unref (cp);

					ucl_object_unref (cp);

			new->trash_stack[UCL_TRASH_KEY] = NULL;

				new->trash_stack[UCL_TRASH_KEY] = malloc(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';