- Fixed a bug with macros that come after an empty object

- `ucl_object_emit_full` now accepts additional argument `comments` that could be used to emit comments with UCL output

### Libucl 0.8.1

- Create ucl_parser_add_file_full() to be able to specify merge mode and parser type (by Allan Jude)

- C++ wrapper improvements (by @ftilde)

- C++ wrapper: add convenience method at() and lookup() (by Yonghee Kim)

- C++ wrapper: add assignment operator to Ucl class (by Yonghee Kim)

- C++ wrapper: support variables in parser (by Yonghee Kim)

- C++ wrapper: refactoring C++ interface (by Yonghee Kim):

    - use auto variables (if possible)

    - remove dangling expressions

    - use std::set::emplace instead of std::set::insert

    - not use std::move in return statement; considering copy elision

- C++ wrapper: fix compilation error and warnings (by Zhe Wang)

- C++ wrapper: fix iteration over objects in which the first value is `false` (by Zhe Wang)

- C++ wrapper: Macro helper functions (by Chris Meacham)

- C++ wrapper: Changing the duplicate strategy in the C++ API (by Chris Meacham)

- C++ wrapper: Added access functions for the size of a UCL_ARRAY (by Chris Meacham)

- Fix caseless comparison

- Fix include when EPERM is issued

- Fix Windows build

- Allow to reserve space in arrays and hashes

- Fix bug with including of empty files

- Move to mum_hash from xxhash

- Fix msgpack on non-x86

- python: Add support to Python 3 (by Denis Volpato Martins)

- python: Add support for Python 2.6 tests (by Denis Volpato Martins)

- python: Implement validation function and tests (by Denis Volpato Martins)

- python: Added UCL_NULL handling and tests (by Denis Volpato Martins)

- Fix schema validation for patternProperties with object data (by Denis Volpato Martins)

- Remove the dependency on NBBY, add missing <strings.h> include (by Ed Schouten)

- Allow to emit msgpack from Lua

- Performance improvements in Lua API

- Allow to pass opaque objects in Lua API for transparent C passthrough

- Various bugs fixed

- Couple of memory leaks plugged

C_COMMON_FLAGS ?= -fPIC -Wall -W -Wno-unused-parameter -Wno-pointer-sign -I./include -I./uthash -I./src -I./klib

		$(SRCDIR)/mum.h

		$(OBJDIR)/ucl_schema.o

		$(SRCDIR)/mum.h

		$(OBJDIR)/ucl_schema.o

[![CircleCI](https://circleci.com/gh/vstakhov/libucl.svg?style=svg)](https://circleci.com/gh/vstakhov/libucl)

[![Coverity](https://scan.coverity.com/projects/4138/badge.svg)](https://scan.coverity.com/projects/4138)

[![Coverage Status](https://coveralls.io/repos/github/vstakhov/libucl/badge.svg?branch=master)](https://coveralls.io/github/vstakhov/libucl?branch=master)

	- [Comments](#comments)

	- [Single quoted strings](#single-quoted-strings)

## Introduction

            host = "hostname";

```nginx

### Comments

* single line: `#`

/*

.macro_name "sometext";

.macro_name {

.macro_name(param=value) "something";

.macro_name(param={key=value}) "something";

.macro_name(.include "params.conf") "something";

.macro_name(#this is multiline macro

.macro_name(key="()") "something";

Search ends after the first match, unless `glob` is true, then all matches are included.

	- `merge` - if we have object or array, then new keys are merged inside, if we have a plain object then an implicit array is formed (regardless of priorities)

* The initial and the final newlines are not inserted to the resulting string, but you can still specify newlines at the beginning and at the end of a value, for example:

### Single quoted strings

It is possible to use single quoted strings to simplify escaping rules. All values passed in single quoted strings are *NOT* escaped, with two exceptions: a single `'` character just before `\` character, and a newline character just after `\` character that is ignored.

```

key = 'value'; # Read as value

key = 'value\n\'; # Read as  value\n\

key = 'value\''; # Read as value'

key = 'value\

bla'; # Read as valuebla

```

I got a 19Mb file that consist of ~700 thousand lines of json (obtained via

JSON language and therefore can be used as a simple JSON parser. Macro logic provides an ability to extend configuration

language (for example by including some lua code) and comments allow to disable or enable the parts of a configuration

m4_define([min_ver], [1])

m4_define([so_version], [6:0:1])

AC_CHECK_HEADERS_ONCE([strings.h])

- `ucl_object_frombool` - converts `bool` to UCL object

###Brief content:

- *arrays* are converted to lua tables with numeric indices suitable for `ipairs` iterations

- *objects* are converted to lua tables with string indices

 * Import UCL object from lua state, escaping JSON strings

 * @param L lua state

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

/**

#include <tuple>

		*need_free = false;

		}

		}

 		}

			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

	struct macro_handler_s {

		ucl_macro_handler         handler;

		ucl_context_macro_handler ctx_handler;

	};

	struct macro_userdata_s {

		ucl_parser    *parser;

		void          *userdata;

	};

			if (!cur->obj) {

			if (cur && !cur->obj) {

	std::string key () const {

	std::string string_value (const std::string& default_val = "") const

	size_t size () const

	{

		if (type () == UCL_ARRAY) {

			return ucl_array_size (obj.get());

		}

		return 0;

	}

	Ucl at (size_t i) const

	Ucl lookup (const std::string &key) const

	inline Ucl operator[] (size_t i) const

	inline Ucl operator[](const std::string &key) const

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

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

	}

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

	{

		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)

	{

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

				}

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

				}

			}

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

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

	}

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

	{

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

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

				}

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

				}

			}

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

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

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

	{

		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)

		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)

	{

		if (!in) {

			err = "null input";

			return nullptr;

		}

		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)

	{

		if (!in) {

			err = "null input";

			return nullptr;

		}

		return parse (std::string (in), replacer, macros, err, duplicate_strategy);

		return result;

	UCL_EUNPAIRED, /**< Input has too many recursion levels */

	UCL_EMERGE /**< A merge error occurred */

 * Basic flags for an object (can use up to 12 bits as higher 4 bits are used

 * for priorities)

	UCL_OBJECT_BINARY = (1 << 7), /**< Object contains raw binary data */

	UCL_OBJECT_SQUOTED = (1 << 8) /**< Object has been enclosed in single quotes */

 * Reserve space in ucl array or object for `elt` elements

 * @param obj object to reserve

 * @param reserved size to reserve in an object

 */

UCL_EXTERN void ucl_object_reserve (ucl_object_t *obj, size_t reserved);

/**

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

/**

 * Get the next object from the `obj`. This function iterates over arrays, objects

 * Get the next object from the `obj`. This function iterates over arrays, objects

 * Sets the default priority for the parser applied to chunks that do not

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

/**

 * Insert new chunk to a parser (must have previously processed data with an existing top object)

 * @param parser parser structure

 * @param data the pointer to the beginning of a chunk

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

/**

		const char *data, size_t len);

 * Get the current stack object as stack accessor function for use in macro

 * functions (refcount is increased)

 * @param parser parser object

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

/**

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

/**

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

/**

 * @param with destination object

/**

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

/**

 * Special handler structure

 */

struct ucl_parser_special_handler {

	const unsigned char *magic;

	size_t magic_len;

	ucl_parser_special_handler_t handler;

	void (*free_function) (unsigned char *data, size_t len, void *user_data);

	void *user_data;

	struct ucl_parser_special_handler *next; /* Used internally */

};

/**

 * Add special handler for a parser

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

	const ucl_object_t *obj;			/**< object where error occurred */

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

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

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

#define NULL_META "ucl.null.meta"

#define UCL_OBJECT_TYPE_META "ucl.type.object"

#define UCL_ARRAY_TYPE_META "ucl.type.array"

#define UCL_IMPL_ARRAY_TYPE_META "ucl.type.impl_array"

static ucl_object_t* ucl_object_lua_fromtable (lua_State *L, int idx, ucl_string_flags_t flags);

static ucl_object_t* ucl_object_lua_fromelt (lua_State *L, int idx, ucl_string_flags_t flags);

	lua_createtable (L, 0, obj->len);

	luaL_getmetatable (L, UCL_OBJECT_TYPE_META);

	lua_setmetatable (L, -2);

		luaL_getmetatable (L, UCL_ARRAY_TYPE_META);

		lua_setmetatable (L, -2);

		luaL_getmetatable (L, UCL_IMPL_ARRAY_TYPE_META);

		lua_setmetatable (L, -2);

ucl_object_lua_fromtable (lua_State *L, int idx, ucl_string_flags_t flags)

	ucl_object_t *obj, *top = NULL, *cur;

	bool is_array = true, is_implicit = false, found_mt = false;

	size_t max = 0, nelts = 0;

	/* First, we check from metatable */

	if (luaL_getmetafield (L, idx, "class") != 0) {

		if (lua_type (L, -1) == LUA_TSTRING) {

			const char *classname = lua_tostring (L, -1);

			if (strcmp (classname, UCL_OBJECT_TYPE_META) == 0) {

				found_mt = true;

			} else if (strcmp (classname, UCL_ARRAY_TYPE_META) == 0) {

				is_array = true;

				found_mt = true;

#if LUA_VERSION_NUM >= 502

				max = lua_rawlen (L, idx);

#else

				max = lua_objlen (L, idx);

#endif

				nelts = max;

			} else if (strcmp (classname, UCL_IMPL_ARRAY_TYPE_META) == 0) {

				is_array = true;

				is_implicit = true;

				found_mt = true;

#if LUA_VERSION_NUM >= 502

				max = lua_rawlen (L, idx);

#else

				max = lua_objlen (L, idx);

#endif

				nelts = max;

	if (!found_mt) {

		/* Check for array */

		lua_pushnil (L);

		while (lua_next (L, idx) != 0) {

			if (lua_type (L, -2) == LUA_TNUMBER) {

				double num = lua_tonumber (L, -2);

				if (num == (int) num) {

					if (num > max) {

						max = num;

					}

				} else {

					/* Keys are not integer */

					is_array = false;

				}

			} else {

				/* Keys are not numeric */

				is_array = false;

			}

			lua_pop (L, 1);

			nelts ++;

		}

	}

		if (!is_implicit) {

			top = ucl_object_typed_new (UCL_ARRAY);

			ucl_object_reserve (top, nelts);

		}

		else {

			top = NULL;

		}

			obj = ucl_object_lua_fromelt (L, lua_gettop (L), flags);

				if (is_implicit) {

					DL_APPEND (top, obj);

				}

				else {

					ucl_array_append (top, obj);

				}

		ucl_object_reserve (top, nelts);

			lua_pushvalue (L, -2);

			k = lua_tolstring (L, -1, &keylen);

			obj = ucl_object_lua_fromelt (L, lua_gettop (L) - 1, flags);

				DL_FOREACH (obj, cur) {

					if (cur->keylen == 0) {

						cur->keylen = obj->keylen;

						cur->key = obj->key;

					}

				}

			lua_pop (L, 2);

ucl_object_lua_fromelt (lua_State *L, int idx, ucl_string_flags_t flags)

	const char *str;

	size_t sz;

		str = lua_tolstring (L, idx, &sz);

		if (str) {

			obj = ucl_object_fromstring_common (str, sz, flags);

		}

		else {

			obj = ucl_object_typed_new (UCL_NULL);

		}

				obj = ucl_object_lua_fromelt (L, 1, flags);

				obj = ucl_object_lua_fromtable (L, idx, flags);

		obj = ucl_object_lua_fromtable (L, idx, 0);

		obj = ucl_object_lua_fromelt (L, idx, 0);

		break;

	}

	return obj;

}

/**

 * @function ucl_object_lua_import_escape(L, idx)

 * Extracts ucl object from lua variable at `idx` position escaping JSON strings

 * @see ucl_object_push_lua for conversion definitions

 * @param {lua_state} L lua state machine pointer

 * @param {int} idx index where the source variable is placed

 * @return {ucl_object_t} new ucl object extracted from lua variable. Reference count of this object is 1,

 * this object thus needs to be unref'ed after usage.

 */

ucl_object_t *

ucl_object_lua_import_escape (lua_State *L, int idx)

{

	ucl_object_t *obj;

	int t;

	t = lua_type (L, idx);

	switch (t) {

	case LUA_TTABLE:

		obj = ucl_object_lua_fromtable (L, idx, UCL_STRING_RAW);

		break;

	default:

		obj = ucl_object_lua_fromelt (L, idx, UCL_STRING_RAW);

 * @method parser:register_variable(name, value)

 * Register parser variable

 * @param {string} name name of variable

 * @param {string} value value of variable

 * @return {bool} success

@example

local parser = ucl.parser()

local res = parser:register_variable('CONFDIR', '/etc/foo')

 */

static int

lua_ucl_parser_register_variable (lua_State *L)

{

	struct ucl_parser *parser;

	const char *name, *value;

	int ret = 2;

	parser = lua_ucl_parser_get (L, 1);

	name = luaL_checkstring (L, 2);

	value = luaL_checkstring (L, 3);

	if (parser != NULL && name != NULL && value != NULL) {

		ucl_parser_register_variable (parser, name, value);

		lua_pushboolean (L, true);

		ret = 1;

	}

	else {

		return luaL_error (L, "invalid arguments");

	}

	return ret;

}

/***

 * @method parser:register_variables(vars)

 * Register parser variables

 * @param {table} vars names/values of variables

 * @return {bool} success

@example

local parser = ucl.parser()

local res = parser:register_variables({CONFDIR = '/etc/foo', VARDIR = '/var'})

 */

static int

lua_ucl_parser_register_variables (lua_State *L)

{

	struct ucl_parser *parser;

	const char *name, *value;

	int ret = 2;

	parser = lua_ucl_parser_get (L, 1);

	if (parser != NULL && lua_type (L, 2) == LUA_TTABLE) {

		for (lua_pushnil (L); lua_next (L, 2); lua_pop (L, 1)) {

			lua_pushvalue (L, -2);

			name = luaL_checkstring (L, -1);

			value = luaL_checkstring (L, -2);

			ucl_parser_register_variable (parser, name, value);

			lua_pop (L, 1);

		}

		lua_pushboolean (L, true);

		ret = 1;

	}

	else {

		return luaL_error (L, "invalid arguments");

	}

	return ret;

}

/***

struct _rspamd_lua_text {

	const char *start;

	unsigned int len;

	unsigned int flags;

};

/***

 * @method parser:parse_text(input)

 * Parse UCL object from file.

 * @param {string} input string to parse

 * @return {bool[, string]} if res is `true` then file has been parsed successfully, otherwise an error string is also returned

 */

static int

lua_ucl_parser_parse_text (lua_State *L)

{

	struct ucl_parser *parser;

	struct _rspamd_lua_text *t;

	enum ucl_parse_type type = UCL_PARSE_UCL;

	int ret = 2;

	parser = lua_ucl_parser_get (L, 1);

	t = luaL_checkudata (L, 2, "rspamd{text}");

	if (lua_type (L, 3) == LUA_TSTRING) {

		type = lua_ucl_str_to_parse_type (lua_tostring (L, 3));

	}

	if (parser != NULL && t != NULL) {

		if (ucl_parser_add_chunk_full (parser, (const unsigned char *)t->start,

				t->len, 0, UCL_DUPLICATE_APPEND, type)) {

			lua_pushboolean (L, true);

			ret = 1;

		}

		else {

			lua_pushboolean (L, false);

			lua_pushstring (L, ucl_parser_get_error (parser));

		}

	}

	else {

		lua_pushboolean (L, false);

		lua_pushstring (L, "invalid arguments");

	}

	return ret;

}

	lua_pushcfunction (L, lua_ucl_parser_parse_text);

	lua_setfield (L, -2, "parse_text");

	lua_pushcfunction (L, lua_ucl_parser_register_variable);

	lua_setfield (L, -2, "register_variable");

	lua_pushcfunction (L, lua_ucl_parser_register_variables);

	lua_setfield (L, -2, "register_variables");

static void

lua_ucl_types_mt (lua_State *L)

{

	luaL_newmetatable (L, UCL_OBJECT_TYPE_META);

	lua_pushcfunction (L, lua_ucl_object_tostring);

	lua_setfield (L, -2, "__tostring");

	lua_pushcfunction (L, lua_ucl_object_tostring);

	lua_setfield (L, -2, "tostring");

	lua_pushstring (L, UCL_OBJECT_TYPE_META);

	lua_setfield (L, -2, "class");

	lua_pop (L, 1);

	luaL_newmetatable (L, UCL_ARRAY_TYPE_META);

	lua_pushcfunction (L, lua_ucl_object_tostring);

	lua_setfield (L, -2, "__tostring");

	lua_pushcfunction (L, lua_ucl_object_tostring);

	lua_setfield (L, -2, "tostring");

	lua_pushstring (L, UCL_ARRAY_TYPE_META);

	lua_setfield (L, -2, "class");

	lua_pop (L, 1);

	luaL_newmetatable (L, UCL_IMPL_ARRAY_TYPE_META);

	lua_pushcfunction (L, lua_ucl_object_tostring);

	lua_setfield (L, -2, "__tostring");

	lua_pushcfunction (L, lua_ucl_object_tostring);

	lua_setfield (L, -2, "tostring");

	lua_pushstring (L, UCL_IMPL_ARRAY_TYPE_META);

	lua_setfield (L, -2, "class");

	lua_pop (L, 1);

}

 * they return string value, then this value is used for output.

	lua_ucl_types_mt (L);

   strings (at least up to 512-bit) on Haswell and Power7.  The MUM bulk

#error "Unknown endianness"

#error "Unknown endianness"

   target endianness and the unroll factor.  */

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

				}

			}

static inline void

_ucl_emitter_free(void *p)

{

    free(p);

}

		if (ucl_test_character (*p, (UCL_CHARACTER_JSON_UNSAFE|

				UCL_CHARACTER_DENIED|

				UCL_CHARACTER_WHITESPACE_UNSAFE))) {

			case '\v':

				func->ucl_emitter_append_len ("\\u000B", 6, func->ud);

				break;

			case ' ':

				func->ucl_emitter_append_character (' ', 1, func->ud);

				break;

				func->ucl_emitter_append_len ("\\uFFFD", 6, func->ud);

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

	while (size) {

		if (*p == '\'') {

			if (len > 0) {

				func->ucl_emitter_append_len (c, len, func->ud);

			}

			len = 0;

			c = ++p;

			func->ucl_emitter_append_len ("\\\'", 2, func->ud);

		}

		else {

			p ++;

			len ++;

		}

		size --;

	}

	if (len > 0) {

		func->ucl_emitter_append_len (c, len, func->ud);

	}

	func->ucl_emitter_append_character ('\'', 1, func->ud);

}

void

		f->ucl_emitter_free_func = _ucl_emitter_free;

		f->ucl_emitter_free_func = _ucl_emitter_free;