m4_define([maj_ver], [0])

m4_define([min_ver], [0])

m4_define([so_version], [maj_ver:med_ver])

m4_define([ucl_version], [maj_ver.med_ver.min_ver])

### ucl_object_emit

~~~C

~~~

Allocate a string that is suitable to fit the underlying UCL object `obj` and fill it with the textual representation of the object `obj` according to style `emit_type`. The caller should free the returned string after using.

### ucl_object_emit_full

~~~C

		struct ucl_emitter_functions *emitter);

~~~

## ucl_iterate_object

~~~C

	ucl_object_iter_t *iter, bool expand_values);

~~~

~~~C

ucl_object_iter_t it = NULL, it_obj = NULL;

/* Iterate over the object */

while ((obj = ucl_iterate_object (top, &it, true))) {

## ucl_object_validate

~~~C

~~~

This function uses ucl object `schema`, that must be valid in terms of `json-schema` draft v4, to validate input object `obj`. If this function returns `true` then validation procedure has been succeed. Otherwise, `false` is returned and `err` is set to a specific value. If caller set `err` to NULL then this function does not set any error just returning `false`. Error is the structure defined as following:

\f[B]ucl_parser_add_string\f[], \f[B]ucl_parser_add_file\f[],

\f[B]ucl_parser_get_object\f[], \f[B]ucl_parser_get_error\f[],

\f[B]ucl_parser_free\f[], \f[B]ucl_pubkey_add\f[],

parser and utility functions

.SH LIBRARY

.PP

.SH SYNOPSIS

.PP

\f[C]#include\ <ucl.h>\f[]

Convert \f[C]ucl\f[] objects to some textual or binary representation.

Currently, libucl supports the following exports:

.IP \[bu] 2

data, such as implicit arrays)

.IP \[bu] 2

.IP \[bu] 2

\f[C]json\f[] output)

.SS Conversion functions

.PP

.SS Validation functions

.PP

Validation functions are used to validate some object \f[C]obj\f[] using

Both input and schema must be UCL objects to perform validation.

.SS Utility functions

.PP

.PP

Creates new parser with the specified flags:

.IP \[bu] 2

.IP \[bu] 2

.IP \[bu] 2

parsing them as floats

.SS ucl_parser_register_macro

.IP

.PP

This function acts exactly like \f[C]ucl_parser_add_chunk\f[] does but

if \f[C]len\f[] argument is zero, then the string \f[C]data\f[] must be

character.

.SS ucl_parser_add_file

.IP

This function adds a public key from text blob \f[C]key\f[] of length

\f[C]len\f[] to the \f[C]parser\f[] object.

This public key should be in the \f[C]PEM\f[] format and can be used by

\f[C]Openssl\f[] support should be enabled to make this function

working.

If a key cannot be added (e.g.

Add the standard file variables to the \f[C]parser\f[] based on the

\f[C]filename\f[] specified:

.IP \[bu] 2

.IP \[bu] 2

.PP

.IP \[bu] 2

.IP \[bu] 2

.PP

if \f[C]need_expand\f[] parameter is \f[C]true\f[] then all relative

paths are expanded using \f[C]realpath\f[] call.

.IP \[bu] 2

.IP \[bu] 2

.SS Parser usage example

.PP

The following example loads, parses and extracts \f[C]ucl\f[] object

in\ =\ stdin;

parser\ =\ ucl_parser_new\ (0);

while\ (!feof\ (in)\ &&\ r\ <\ (int)sizeof\ (inbuf))\ {

}

ucl_parser_add_chunk\ (parser,\ inbuf,\ r);

fclose\ (in);

.PP

Libucl can transform UCL objects to a number of tectual formats:

.IP \[bu] 2

configuration file where implicit arrays are transformed to the

duplicate keys

.IP \[bu] 2

without spaces

.IP \[bu] 2

newlines and spaces

.IP \[bu] 2

.PP

Moreover, libucl API allows to select a custom set of emitting functions

Libucl uses the following structure to support this feature:

.IP

.nf

.PP

This structure defines the following callbacks:

.IP \[bu] 2

append \f[C]nchars\f[] characters equal to \f[C]c\f[]

.IP \[bu] 2

\f[C]len\f[] starting from pointer \f[C]str\f[]

.IP \[bu] 2

numbers

.IP \[bu] 2

.PP

The set of these functions could be used to output text formats of

\f[C]UCL\f[] objects to different structures or streams.

.IP

.nf

\f[C]

\f[]

.fi

.PP

.IP

.nf

\f[C]

\ \ \ \ \ \ \ \ struct\ ucl_emitter_functions\ *emitter);

\f[]

.fi

strings and 0 for numbers)

.PP

Also there is a single \f[C]ucl_object_tostring_forced\f[] function that

to a string representation.

For compound and numeric types this function performs emitting to a

compact json format actually.

.PP

Here is a list of all conversion functions:

.IP \[bu] 2

.IP \[bu] 2

.IP \[bu] 2

.IP \[bu] 2

object (this string is NULL terminated)

.IP \[bu] 2

\f[C]size_t\f[] len of UCL object (string can be not NULL terminated)

.IP \[bu] 2

any UCL object

.PP

Strings returned by these pointers are associated with the UCL object

\f[]

.fi

.PP

.PP

This object should be released by caller.

.SS Primitive objects generation

.PP

Libucl provides the functions similar to inverse conversion functions

.PP

Also there is a function to generate UCL object from a string performing

various parsing or conversion operations called

This function is used to convert a string \f[C]str\f[] of size

\f[C]len\f[] to an UCL objects applying \f[C]flags\f[] conversions.

If \f[C]len\f[] is equal to zero then a \f[C]str\f[] is assumed as

This function supports the following flags (a set of flags can be

specified using logical \f[C]OR\f[] operation):

.IP \[bu] 2

.IP \[bu] 2

.IP \[bu] 2

boolean

.IP \[bu] 2

number

.IP \[bu] 2

integer or float number

.IP \[bu] 2

numbers

.IP \[bu] 2

.IP \[bu] 2

numbers and time values)

.IP \[bu] 2

.PP

If parsing operations fail then the resulting UCL object will be a

\f[C]UCL_STRING\f[].

.IP

.nf

\f[C]

\ \ \ \ ucl_object_iter_t\ *iter,\ bool\ expand_values);

\f[]

.fi

.nf

\f[C]

ucl_object_iter_t\ it\ =\ NULL,\ it_obj\ =\ NULL;

/*\ Iterate\ over\ the\ object\ */

while\ ((obj\ =\ ucl_iterate_object\ (top,\ &it,\ true)))\ {

.IP

.nf

\f[C]

\f[]

.fi

.PP

This function uses ucl object \f[C]schema\f[], that must be valid in

\f[C]obj\f[].

If this function returns \f[C]true\f[] then validation procedure has

been succeed.

#define UCL_WARN_UNUSED_RESULT

#endif

/**

 * @defgroup structures Structures and types

 * UCL defines several enumeration types used for error reporting or specifying flags and attributes.

 * @param obj CL object

 * @return zero terminated key

 */

/**

 * 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

 */

/**

 * Creates a new object

 * @param str NULL terminated string, will be json escaped

 * @return new object

 */

/**

 * Create a UCL object from the specified string

 * @param len length of a string

 * @return new object

 */

/**

 * Create an object from an integer number

 * @param iv number

 * @return new object

 */

/**

 * Create an object from a float number

 * @param dv number

 * @return new object

 */

/**

 * Create an object from a boolean

 * @param bv bool value

 * @return new object

 */

/**

 * Insert a object 'elt' to the hash 'top' and associate it with key 'key'

 * @param key key to associate with this object (either const or preallocated)

 * @param keylen length of the key (or 0 for NULL terminated keys)

 * @param copy_key make an internal copy of key

 */

/**

 * Replace a object 'elt' to the hash 'top' and associate it with key 'key', old object will be unrefed,

 * @param key key to associate with this object (either const or preallocated)

 * @param keylen length of the key (or 0 for NULL terminated keys)

 * @param copy_key make an internal copy of key

 */

/**

 * Delete a object associated with key 'key', old object will be unrefered,

 * @param key key associated to the object to remove

 * @param keylen length of the key (or 0 for NULL terminated keys)

 */

/**

 * Delete a object associated with key 'key', old object will be unrefered,

 * @param top object

 * @param key key associated to the object to remove

 */

/**

 * @param key key to associate with this object (either const or preallocated)

 * @param keylen length of the key (or 0 for NULL terminated keys)

 * @param copy_key make an internal copy of key

 */

/**

 * Append an element to the front of array object

 * @param top destination object (will be created automatically if top is NULL)

 * @param elt element to append (must NOT be NULL)

 */

/**

 * Append an element to the start of array object

 * @param top destination object (will be created automatically if top is NULL)

 * @param elt element to append (must NOT be NULL)

 */

/**

 * Removes an element `elt` from the array `top`. Caller must unref the returned object when it is not

 * @param elt element to remove

 * @return removed element or NULL if `top` is NULL or not an array

 */

/**

 * 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

 */

/**

 * 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

 */

/**

 * Removes the last element from the array `top`. Caller must unref the returned object when it is not

 * Append a element to another element forming an implicit array

 * @param head head to append (may be NULL)

 * @param elt new element

 */

/**

 * Converts an object to double value

 * @param target target double variable

 * @return true if conversion was successful

 */

/**

 * Unsafe version of \ref ucl_obj_todouble_safe

 * @param obj CL object

 * @return double value

 */

/**

 * Converts an object to integer value

 * @param target target integer variable

 * @return true if conversion was successful

 */

/**

 * Unsafe version of \ref ucl_obj_toint_safe

 * @param obj CL object

 * @return int value

 */

/**

 * Converts an object to boolean value

 * @param target target boolean variable

 * @return true if conversion was successful

 */

/**

 * Unsafe version of \ref ucl_obj_toboolean_safe

 * @param obj CL object

 * @return boolean value

 */

/**

 * Converts an object to string value

 * @param target target string variable, no need to free value

 * @return true if conversion was successful

 */

/**

 * Unsafe version of \ref ucl_obj_tostring_safe

 * @param obj CL object

 * @return string value

 */

/**

 * Convert any object to a string in JSON notation if needed

 * @param obj CL object

 * @return string value

 */

/**

 * Return string as char * and len, string may be not zero terminated, more efficient that \ref ucl_obj_tostring as it

 * @param tlen target length

 * @return true if conversion was successful

 */

		const char **target, size_t *tlen);

/**

 * @param obj CL object

 * @return string value

 */

/**

 * Return object identified by a key in the specified object

 * @param key key to search

 * @return object matched the specified key or NULL if key is not found

 */

/**

 * Return object identified by a fixed size key in the specified object

 * @param klen length of a key

 * @return object matched the specified key or NULL if key is not found

 */

/**

 * Returns a key of an object as a NULL terminated string

 * @param obj CL object

 * @return key or NULL if there is no key

 */

/**

 * Returns a key of an object as a fixed size string (may be more efficient)

 * @param len target key length

 * @return key pointer

 */

/**

 */

/**

 */

/**

 * Decrease reference count for an object

 * 2) Size of objects

 * 3) Content of objects

 */

/**

 * Sort UCL array using `cmp` compare function

 * @param cmp

 */

UCL_EXTERN void ucl_object_array_sort (ucl_object_t *ar,

/**

 * Opaque iterator object

 * while ((cur = ucl_iterate_object (obj, &it)) != NULL) ...

 * @return the next object or NULL

 */

/** @} */

 * @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

 */

/**

 * @param parser parser structure

 * @param err if *err is NULL it is set to parser error

 * @return top parser object or NULL

 * #UCL_EMIT_CONFIG then emit config like object

 * @return dump of an object (must be freed after using) or NULL in case of error

 */

/**

 * Emit object to a string

 * #UCL_EMIT_CONFIG then emit config like object

 * @return dump of an object (must be freed after using) or NULL in case of error

 */

		struct ucl_emitter_functions *emitter);

/** @} */

struct ucl_schema_error {

	enum ucl_schema_error_code code;	/**< error code */

	char msg[128];						/**< error message */

};

/**

 * occured, then `err` is filled with the exact error definition.

 * @return true if `obj` is valid using `schema`

 */

/** @} */

 */

		struct ucl_emitter_functions *func,

		unsigned int tabs,

		bool start_tabs,

		bool compact);

		struct ucl_emitter_functions *func,

		unsigned int tabs,

		bool start_tabs,

		bool compact);

		struct ucl_emitter_functions *func,

		unsigned int tabs,

		bool start_tabs,

		bool is_top,

		bool expand_array);

		struct ucl_emitter_functions *func,

		unsigned int tabs,

		bool start_tabs,

		bool compact,

		bool expand_array);

		struct ucl_emitter_functions *func,

		unsigned int tabs,

		bool start_tabs,

 * @param buf target buffer

 */

static void

		unsigned int tabs, bool start_tabs, bool compact)

{

	ucl_hash_iter_t it = NULL;

	if (start_tabs) {

 * @param buf target buffer

 */

static void

		unsigned int tabs, bool start_tabs, bool compact)

{

	if (start_tabs) {

		ucl_add_tabs (func, tabs, compact);

 * @param buf buffer

 */

static void

		unsigned int tabs, bool start_tabs, bool compact)

{

	bool flag;

 * @param buf target buffer

 */

static void

		unsigned int tabs, bool start_tabs, bool compact)

{

	bool is_array = (obj->next != NULL);

	if (is_array) {

 * @return json output (should be freed after using)

 */

static void

{

	ucl_obj_write_json (obj, func, 0, false, compact);

}

 * @param buf target buffer

 */

static void

		unsigned int tabs, bool start_tabs, bool is_top)

{

	ucl_hash_iter_t it = NULL;

	if (start_tabs) {

 * @param buf target buffer

 */

static void

		unsigned int tabs, bool start_tabs, bool is_top)

{

	if (start_tabs) {

		ucl_add_tabs (func, tabs, false);

 * @param buf buffer

 */

static void

		unsigned int tabs, bool start_tabs, bool is_top, bool expand_array)

{

	bool flag;

 * @return rcl output (should be freed after using)

 */

static void

{

	ucl_elt_write_config (obj, func, 0, false, true, true);

}

static void

		unsigned int tabs, bool start_tabs)

{

	bool is_array = (obj->next != NULL);

 * @param buf target buffer

 */

static void

		unsigned int tabs, bool start_tabs, bool is_top)

{

	ucl_hash_iter_t it = NULL;

	if (start_tabs) {

 * @param buf target buffer

 */

static void

		unsigned int tabs, bool start_tabs, bool is_top)

{

	if (start_tabs) {

		ucl_add_tabs (func, tabs, false);

 * @param buf buffer

 */

static void

		unsigned int tabs, bool start_tabs, bool is_top, bool expand_array)

{

	bool flag;

 * @return rcl output (should be freed after using)

 */

static void

{

	ucl_elt_write_yaml (obj, func, 0, false, true, true);

}

unsigned char *

{

	UT_string *buf = NULL;

	unsigned char *res = NULL;

}

bool

		struct ucl_emitter_functions *emitter)

{

	if (emit_type == UCL_EMIT_JSON) {

unsigned char *

{

	UT_string *buf = NULL;

	unsigned char *res = NULL;

void ucl_hash_destroy (ucl_hash_t* hashlin, ucl_hash_free_func *func)

{

	ucl_hash_node_t *elt, *tmp;

	HASH_ITER (hh, hashlin->buckets, elt, tmp) {

		HASH_DELETE (hh, hashlin->buckets, elt);

		if (func) {

			DL_FOREACH_SAFE (elt->data, cur, otmp) {

			}

		}

		UCL_FREE (sizeof (ucl_hash_node_t), elt);

}

void

{

	ucl_hash_node_t *node;

	HASH_ADD_KEYPTR (hh, hashlin->buckets, key, keylen, node);

}

ucl_hash_iterate (ucl_hash_t *hashlin, ucl_hash_iter_t *iter)

{

	ucl_hash_node_t *elt = *iter;

}

ucl_hash_search (ucl_hash_t* hashlin, const char *key, unsigned keylen)

{

	ucl_hash_node_t *found;

}

void

{

	ucl_hash_node_t *found;

typedef struct ucl_hash_node_s

{

	UT_hash_handle hh;

} ucl_hash_node_t;

/**

 * Inserts an element in the the hashtable.

 */

/**

 * Delete an element from the the hashtable.

 */

/**

 * Searches an element in the hashtable.

 */

/**

 * @param iter iterator (must be NULL on first iteration)

 * @return the next object

 */

/**

 * Check whether an iterator has next element

#include <openssl/evp.h>

#endif

/**

 * @file rcl_internal.h

 * Internal structures and functions of UCL library

		bool allow_double, bool number_bytes, bool allow_time);

ucl_hash_search_obj (ucl_hash_t* hashlin, ucl_object_t *obj)

{

}

static inline ucl_hash_t *

static inline ucl_hash_t *

{

	if (hashlin == NULL) {

		hashlin = ucl_hash_create ();

 * @param obj

 * @return

 */

#endif /* UCL_INTERNAL_H_ */

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

	if (keylen == -1) {

		return false;

	}

	else if (keylen == 0) {

		ucl_set_err (chunk, UCL_ESYNTAX, "empty keys are not allowed", &parser->err);

		return false;

	}

	container = parser->stack->obj->value.ov;

	nobj->key = key;

	nobj->keylen = keylen;

	if (tobj == NULL) {

		container = ucl_hash_insert_object (container, nobj);

		nobj->prev = nobj;

#include <math.h>

#endif

		struct ucl_schema_error *err,

static bool

ucl_string_to_type (const char *input, ucl_type_t *res)

 */

static void

ucl_schema_create_error (struct ucl_schema_error *err,

		const char *fmt, ...)

{

	va_list va;

/*

 * Check whether we have a pattern specified

 */

{

#ifdef HAVE_REGEX_H

	regex_t reg;

	ucl_object_iter_t iter = NULL;

	if (regcomp (&reg, pattern, REG_EXTENDED | REG_NOSUB) == 0) {

 * Check dependencies for an object

 */

static bool

{

	ucl_object_iter_t iter = NULL, piter;

	bool ret = true;

 * Validate object

 */

static bool

{

			*required = NULL, *pat, *pelt;

	ucl_object_iter_t iter = NULL, piter = NULL;

	bool ret = true, allow_additional = true;

}

static bool

{

	ucl_object_iter_t iter = NULL;

	bool ret = true, exclusive = false;

	double constraint, val;

}

static bool

{

	ucl_object_iter_t iter = NULL;

	bool ret = true;

	int64_t constraint;

}

struct ucl_compare_node {

	TREE_ENTRY(ucl_compare_node) link;

	struct ucl_compare_node *next;

};

static int

ucl_schema_elt_compare (struct ucl_compare_node *n1, struct ucl_compare_node *n2)

{

	return ucl_object_compare (o1, o2);

}

static bool

{

	ucl_compare_tree_t tree = TREE_INITIALIZER (ucl_schema_elt_compare);

	ucl_object_iter_t iter = NULL;

	struct ucl_compare_node *node, test, *nodes = NULL, *tmp;

	bool ret = true;

}

static bool

{

			*first_unvalidated = NULL;

	ucl_object_iter_t iter = NULL, piter = NULL;

	bool ret = true, allow_additional = true, need_unique = false;

 * Returns whether this object is allowed for this type

 */

static bool

		struct ucl_schema_error *err)

{

	ucl_object_iter_t iter = NULL;

	const char *type_str;

	ucl_type_t t;

 * Check if object is equal to one of elements of enum

 */

static bool

		struct ucl_schema_error *err)

{

	ucl_object_iter_t iter = NULL;

	bool ret = false;

	while ((elt = ucl_iterate_object (en, &iter, true)) != NULL) {

/*

 * Check a single ref component

 */

		const char *refc, int len,

		struct ucl_schema_error *err)

{

	char *err_str;

	int num, i;

/*

 * Find reference schema

 */

		struct ucl_schema_error *err)

{

	const char *p, *c;

	if (ref[0] != '#') {

}

static bool

		struct ucl_schema_error *err)

{

	int64_t constraint, i;

	elt = ucl_object_find_key (schema, "maxValues");

}

static bool

		struct ucl_schema_error *err,

{

	ucl_object_iter_t iter = NULL;

	bool ret;

}

bool

{

	return ucl_schema_validate (schema, obj, true, err, schema);

}

	return (t - str);

}

{

	if (obj == NULL) {

		return NULL;

	}

	if (obj->trash_stack[UCL_TRASH_KEY] == NULL && obj->key != NULL) {

		}

	}

	return obj->trash_stack[UCL_TRASH_KEY];

}

{

	if (obj == NULL) {

		return NULL;

	}

	if (obj->trash_stack[UCL_TRASH_VALUE] == NULL) {

		if (obj->type == UCL_STRING) {

			/* Special case for strings */

			}

		}

		else {

			/* Just emit value in json notation */

		}

	}

	return obj->trash_stack[UCL_TRASH_VALUE];

}

	return obj;

}

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_iter_t it = NULL;

	const char *p;

	if (elt == NULL || key == NULL) {

	}

	if (top == NULL) {

	}

	if (top->type != UCL_OBJECT) {

		}

		else {

			/* Refuse converting of other object types */

		}

	}

		ucl_copy_key_trash (elt);

	}

	if (!found) {

		top->value.ov = ucl_hash_insert_object (top->value.ov, elt);

		DL_APPEND (found, elt);

		top->len ++;

	}

	else {

		if (replace) {

		else if (merge) {

			if (found->type != UCL_OBJECT && elt->type == UCL_OBJECT) {

				/* Insert old elt to new one */

				ucl_hash_delete (top->value.ov, found);

				top->value.ov = ucl_hash_insert_object (top->value.ov, elt);

			}

			else if (found->type == UCL_OBJECT && elt->type != UCL_OBJECT) {

				/* Insert new to old */

			}

			else if (found->type == UCL_OBJECT && elt->type == UCL_OBJECT) {

				/* Mix two hashes */

				while ((cur = ucl_iterate_object (elt, &it, true)) != NULL) {