Import libucl 2014-07-16

svn path=/vendor/libucl/dist/; revision=268828
svn path=/vendor/libucl/20140716/; revision=268829; tag=vendor/libucl/20140716

ChangeLog.md

@@ -0,0 +1,6 @@
+# Version history
+
+## Libucl 0.5
+
+- Streamline emitter has been added, so it is now possible to output partial `ucl` objects
+- Emitter now is more flexible due to emitter_context structure

configure.ac

@@ -1,7 +1,7 @@
 m4_define([maj_ver], [0])
-m4_define([med_ver], [4])
+m4_define([med_ver], [5])
-m4_define([min_ver], [1])
+m4_define([min_ver], [0])
-m4_define([so_version], [1:0:0])
+m4_define([so_version], [2:0:0])
 m4_define([ucl_version], [maj_ver.med_ver.min_ver])
 
 AC_INIT([libucl],[ucl_version],[https://github.com/vstakhov/libucl],[libucl])

doc/api.md

@@ -52,15 +52,15 @@ Used to parse `ucl` files and provide interface to extract `ucl` object. Current
 ### Emitting functions
 Convert `ucl` objects to some textual or binary representation. Currently, libucl supports the following exports:
 
-- `JSON` - valid json format (can possibly loose some original data, such as implicit arrays)
+- `JSON` - valid json format (can possibly lose some original data, such as implicit arrays)
-- `Config` - human-readable configuration format (losseless)
+- `Config` - human-readable configuration format (lossless)
 - `YAML` - embedded yaml format (has the same limitations as `json` output)
 
 ### Conversion functions
 Help to convert `ucl` objects to C types. These functions are used to convert `ucl_object_t` to C primitive types, such as numbers, strings or boolean values.
 
 ### Generation functions
-Allow creating of `ucl` objects from C types and creating of complex `ucl` objects, such as hashes or arrays from primitive `ucl` objects, such as numbers or strings.
+Allow creation of `ucl` objects from C types and creating of complex `ucl` objects, such as hashes or arrays from primitive `ucl` objects, such as numbers or strings.
 
 ### Iteration functions
 Iterate over `ucl` complex objects or over a chain of values, for example when a key in an object has multiple values (that can be treated as implicit array or implicit consolidation).
@@ -148,7 +148,7 @@ bool ucl_parser_add_file (struct ucl_parser *parser,
     const char *filename);
 ~~~
 
-Load file `filename` and parse it with the specified `parser`. This function uses `mmap` call to load file, therefore, it should not be `shrinked` during parsing. Otherwise, `libucl` can cause memory corruption and terminate the calling application. This function is also used by the internal handler of `include` macro, hence, this macro has the same limitation.
+Load file `filename` and parse it with the specified `parser`. This function uses `mmap` call to load file, therefore, it should not be `shrunk` during parsing. Otherwise, `libucl` can cause memory corruption and terminate the calling application. This function is also used by the internal handler of `include` macro, hence, this macro has the same limitation.
 
 ### ucl_parser_get_object
 
@@ -225,7 +225,7 @@ ucl_parser_add_chunk (parser, inbuf, r);
 fclose (in);
 
 if (ucl_parser_get_error (parser)) {
-	printf ("Error occured: %s\n", ucl_parser_get_error (parser));
+	printf ("Error occurred: %s\n", ucl_parser_get_error (parser));
 	ret = 1;
 }
 else {
@@ -251,7 +251,7 @@ Libucl can transform UCL objects to a number of tectual formats:
 - compact yaml: `UCL_EMIT_YAML` - compact YAML output
 
 Moreover, libucl API allows to select a custom set of emitting functions allowing 
-efficent and zero-copy output of libucl objects. Libucl uses the following structure to support this feature:
+efficient and zero-copy output of libucl objects. Libucl uses the following structure to support this feature:
 
 ~~~C
 struct ucl_emitter_functions {
@@ -298,12 +298,12 @@ This function is similar to the previous with the exception that it accepts the
 
 # Conversion functions
 
-Conversion functions are used to convert UCL objects to primitive types, such as strings, numbers or boolean values. There are two types of conversion functions:
+Conversion functions are used to convert UCL objects to primitive types, such as strings, numbers, or boolean values. There are two types of conversion functions:
 
 - safe: try to convert an ucl object to a primitive type and fail if such a conversion is not possible
 - unsafe: return primitive type without additional checks, if the object cannot be converted then some reasonable default is returned (NULL for strings and 0 for numbers)
 
-Also there is a single `ucl_object_tostring_forced` function that converts any UCL object (including compound types - arrays and objects) to a string representation. For compound and numeric types this function performs emitting to a compact json format actually.
+Also there is a single `ucl_object_tostring_forced` function that converts any UCL object (including compound types - arrays and objects) to a string representation. For objects, arrays, booleans and numeric types this function performs emitting to a compact json format actually.
 
 Here is a list of all conversion functions:
 
@@ -311,14 +311,14 @@ Here is a list of all conversion functions:
 - `ucl_object_todouble` - returns `double` of UCL object
 - `ucl_object_toboolean` - returns `bool` of UCL object
 - `ucl_object_tostring` - returns `const char *` of UCL object (this string is NULL terminated)
-- `ucl_object_tolstring` - returns `const char *` and `size_t` len of UCL object (string can be not NULL terminated)
+- `ucl_object_tolstring` - returns `const char *` and `size_t` len of UCL object (string does not need to be NULL terminated)
 - `ucl_object_tostring_forced` - returns string representation of any UCL object
 
 Strings returned by these pointers are associated with the UCL object and exist over its lifetime. A caller should not free this memory.
 
 # Generation functions
 
-It is possible to generate UCL objects from C primitive types. Moreover, libucl permits to create and modify complex UCL objects, such as arrays or associative objects. 
+It is possible to generate UCL objects from C primitive types. Moreover, libucl allows creation and modifying complex UCL objects, such as arrays or associative objects. 
 
 ## ucl_object_new
 ~~~C
@@ -350,8 +350,8 @@ Libucl provides the functions similar to inverse conversion functions called wit
 - `ucl_object_fromint` - converts `int64_t` to UCL object
 - `ucl_object_fromdouble` - converts `double` to UCL object
 - `ucl_object_fromboolean` - converts `bool` to UCL object
-- `ucl_object_fromstring` - converts `const char *` to UCL object (this string is NULL terminated)
+- `ucl_object_fromstring` - converts `const char *` to UCL object (this string should be NULL terminated)
-- `ucl_object_fromlstring` - converts `const char *` and `size_t` len to UCL object (string can be not NULL terminated)
+- `ucl_object_fromlstring` - converts `const char *` and `size_t` len to UCL object (string does not need to be NULL terminated)
 
 Also there is a function to generate UCL object from a string performing various parsing or conversion operations called `ucl_object_fromstring_common`.
 
@@ -361,7 +361,7 @@ ucl_object_t * ucl_object_fromstring_common (const char *str,
 	size_t len, enum ucl_string_flags flags)
 ~~~
 
-This function is used to convert a string `str` of size `len` to an UCL objects applying `flags` conversions. If `len` is equal to zero then a `str` is assumed as NULL-terminated. This function supports the following flags (a set of flags can be specified using logical `OR` operation):
+This function is used to convert a string `str` of size `len` to a UCL object applying `flags` conversions. If `len` is equal to zero then a `str` is assumed as NULL-terminated. This function supports the following flags (a set of flags can be specified using logical `OR` operation):
 
 - `UCL_STRING_ESCAPE` - perform JSON escape
 - `UCL_STRING_TRIM` - trim leading and trailing whitespaces
@@ -385,7 +385,7 @@ const ucl_object_t* ucl_iterate_object (const ucl_object_t *obj,
 	ucl_object_iter_t *iter, bool expand_values);
 ~~~
 
-This function accept opaque iterator pointer `iter`. In the first call this iterator *must* be initialized to `NULL`. Iterator is changed by this function call. `ucl_iterate_object` returns the next UCL object in the compound object `obj` or `NULL` if all objects have been iterated. The reference count of the object returned is not increased, so a caller should not unref the object or modify its content (e.g. by inserting to another compound object). The object `obj` should not be changed during the iteration process as well. `expand_values` flag speicifies whether `ucl_iterate_object` should expand keys with multiple values. The general rule is that if you need to iterate throught the *object* or *explicit array*, then you always need to set this flag to `true`. However, if you get some key in the object and want to extract all its values then you should set `expand_values` to `false`. Mixing of iteration types are not permitted since the iterator is set according to the iteration type and cannot be reused. Here is an example of iteration over the objects using libucl API (assuming that `top` is `UCL_OBJECT` in this example):
+This function accepts opaque iterator pointer `iter`. In the first call this iterator *must* be initialized to `NULL`. Iterator is changed by this function call. `ucl_iterate_object` returns the next UCL object in the compound object `obj` or `NULL` if all objects have been iterated. The reference count of the object returned is not increased, so a caller should not unref the object or modify its content (e.g. by inserting to another compound object). The object `obj` should not be changed during the iteration process as well. `expand_values` flag speicifies whether `ucl_iterate_object` should expand keys with multiple values. The general rule is that if you need to iterate through the *object* or *explicit array*, then you always need to set this flag to `true`. However, if you get some key in the object and want to extract all its values then you should set `expand_values` to `false`. Mixing of iteration types is not permitted since the iterator is set according to the iteration type and cannot be reused. Here is an example of iteration over the objects using libucl API (assuming that `top` is `UCL_OBJECT` in this example):
 
 ~~~C
 ucl_object_iter_t it = NULL, it_obj = NULL;
@@ -412,13 +412,13 @@ bool ucl_object_validate (const ucl_object_t *schema,
 	const ucl_object_t *obj, struct ucl_schema_error *err);
 ~~~
 
-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:
+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 a caller sets `err` to NULL then this function does not set any error just returning `false`. Error is the structure defined as following:
 
 ~~~C
 struct ucl_schema_error {
 	enum ucl_schema_error_code code;	/* error code */
 	char msg[128];				/* error message */
-	ucl_object_t *obj;			/* object where error occured */
+	ucl_object_t *obj;			/* object where error occurred */
 };
 ~~~
 
@@ -436,4 +436,4 @@ enum ucl_schema_error_code {
 };
 ~~~
 
-`msg` is a stiring description of an error and `obj` is an object where error has been occurred. Error object is not allocated by libucl, so there is no need to free it after validation (a static object should thus be used).
+`msg` is a string description of an error and `obj` is an object where error has occurred. Error object is not allocated by libucl, so there is no need to free it after validation (a static object should thus be used).

doc/libucl.3

@@ -1,4 +1,4 @@
-.TH LIBUCL 5 "March 20, 2014" "Libucl manual"
+.TH "LIBUCL" "3" "July 26, 2014" "Libucl manual" ""
 .SH NAME
 .PP
 \f[B]ucl_parser_new\f[], \f[B]ucl_parser_register_macro\f[],
@@ -32,10 +32,10 @@ In future, this limitation can be removed.
 Convert \f[C]ucl\f[] objects to some textual or binary representation.
 Currently, libucl supports the following exports:
 .IP \[bu] 2
-\f[C]JSON\f[] \- valid json format (can possibly loose some original
+\f[C]JSON\f[] \- valid json format (can possibly lose some original
 data, such as implicit arrays)
 .IP \[bu] 2
-\f[C]Config\f[] \- human\-readable configuration format (losseless)
+\f[C]Config\f[] \- human\-readable configuration format (lossless)
 .IP \[bu] 2
 \f[C]YAML\f[] \- embedded yaml format (has the same limitations as
 \f[C]json\f[] output)
@@ -46,7 +46,7 @@ These functions are used to convert \f[C]ucl_object_t\f[] to C primitive
 types, such as numbers, strings or boolean values.
 .SS Generation functions
 .PP
-Allow creating of \f[C]ucl\f[] objects from C types and creating of
+Allow creation of \f[C]ucl\f[] objects from C types and creating of
 complex \f[C]ucl\f[] objects, such as hashes or arrays from primitive
 \f[C]ucl\f[] objects, such as numbers or strings.
 .SS Iteration functions
@@ -175,7 +175,7 @@ bool\ ucl_parser_add_file\ (struct\ ucl_parser\ *parser,\
 Load file \f[C]filename\f[] and parse it with the specified
 \f[C]parser\f[].
 This function uses \f[C]mmap\f[] call to load file, therefore, it should
-not be \f[C]shrinked\f[] during parsing.
+not be \f[C]shrunk\f[] during parsing.
 Otherwise, \f[C]libucl\f[] can cause memory corruption and terminate the
 calling application.
 This function is also used by the internal handler of \f[C]include\f[]
@@ -290,7 +290,7 @@ ucl_parser_add_chunk\ (parser,\ inbuf,\ r);
 fclose\ (in);
 
 if\ (ucl_parser_get_error\ (parser))\ {
-\ \ \ \ printf\ ("Error\ occured:\ %s\\n",\ ucl_parser_get_error\ (parser));
+\ \ \ \ printf\ ("Error\ occurred:\ %s\\n",\ ucl_parser_get_error\ (parser));
 \ \ \ \ ret\ =\ 1;
 }
 else\ {
@@ -323,7 +323,7 @@ newlines and spaces
 compact yaml: \f[C]UCL_EMIT_YAML\f[] \- compact YAML output
 .PP
 Moreover, libucl API allows to select a custom set of emitting functions
-allowing efficent and zero\-copy output of libucl objects.
+allowing efficient and zero\-copy output of libucl objects.
 Libucl uses the following structure to support this feature:
 .IP
 .nf
@@ -390,7 +390,7 @@ emitters (including C++ ones, for example).
 .SH CONVERSION FUNCTIONS
 .PP
 Conversion functions are used to convert UCL objects to primitive types,
-such as strings, numbers or boolean values.
+such as strings, numbers, or boolean values.
 There are two types of conversion functions:
 .IP \[bu] 2
 safe: try to convert an ucl object to a primitive type and fail if such
@@ -403,8 +403,8 @@ strings and 0 for numbers)
 Also there is a single \f[C]ucl_object_tostring_forced\f[] function that
 converts any UCL object (including compound types \- arrays and objects)
 to a string representation.
-For compound and numeric types this function performs emitting to a
+For objects, arrays, booleans and numeric types this function performs
-compact json format actually.
+emitting to a compact json format actually.
 .PP
 Here is a list of all conversion functions:
 .IP \[bu] 2
@@ -418,7 +418,8 @@ Here is a list of all conversion functions:
 object (this string is NULL terminated)
 .IP \[bu] 2
 \f[C]ucl_object_tolstring\f[] \- returns \f[C]const\ char\ *\f[] and
-\f[C]size_t\f[] len of UCL object (string can be not NULL terminated)
+\f[C]size_t\f[] len of UCL object (string does not need to be NULL
+terminated)
 .IP \[bu] 2
 \f[C]ucl_object_tostring_forced\f[] \- returns string representation of
 any UCL object
@@ -429,7 +430,7 @@ A caller should not free this memory.
 .SH GENERATION FUNCTIONS
 .PP
 It is possible to generate UCL objects from C primitive types.
-Moreover, libucl permits to create and modify complex UCL objects, such
+Moreover, libucl allows creation and modifying complex UCL objects, such
 as arrays or associative objects.
 .SS ucl_object_new
 .IP
@@ -467,10 +468,10 @@ converts \f[C]int64_t\f[] to UCL object \-
 \f[C]ucl_object_fromdouble\f[] \- converts \f[C]double\f[] to UCL object
 \- \f[C]ucl_object_fromboolean\f[] \- converts \f[C]bool\f[] to UCL
 object \- \f[C]ucl_object_fromstring\f[] \- converts
-\f[C]const\ char\ *\f[] to UCL object (this string is NULL terminated)
+\f[C]const\ char\ *\f[] to UCL object (this string should be NULL
-\- \f[C]ucl_object_fromlstring\f[] \- converts \f[C]const\ char\ *\f[]
+terminated) \- \f[C]ucl_object_fromlstring\f[] \- converts
-and \f[C]size_t\f[] len to UCL object (string can be not NULL
+\f[C]const\ char\ *\f[] and \f[C]size_t\f[] len to UCL object (string
-terminated)
+does not need to be NULL terminated)
 .PP
 Also there is a function to generate UCL object from a string performing
 various parsing or conversion operations called
@@ -485,7 +486,7 @@ ucl_object_t\ *\ ucl_object_fromstring_common\ (const\ char\ *str,\
 .fi
 .PP
 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.
+\f[C]len\f[] to a UCL object applying \f[C]flags\f[] conversions.
 If \f[C]len\f[] is equal to zero then a \f[C]str\f[] is assumed as
 NULL\-terminated.
 This function supports the following flags (a set of flags can be
@@ -538,7 +539,7 @@ const\ ucl_object_t*\ ucl_iterate_object\ (const\ ucl_object_t\ *obj,\
 \f[]
 .fi
 .PP
-This function accept opaque iterator pointer \f[C]iter\f[].
+This function accepts opaque iterator pointer \f[C]iter\f[].
 In the first call this iterator \f[I]must\f[] be initialized to
 \f[C]NULL\f[].
 Iterator is changed by this function call.
@@ -551,12 +552,12 @@ The object \f[C]obj\f[] should not be changed during the iteration
 process as well.
 \f[C]expand_values\f[] flag speicifies whether
 \f[C]ucl_iterate_object\f[] should expand keys with multiple values.
-The general rule is that if you need to iterate throught the
+The general rule is that if you need to iterate through the
 \f[I]object\f[] or \f[I]explicit array\f[], then you always need to set
 this flag to \f[C]true\f[].
 However, if you get some key in the object and want to extract all its
 values then you should set \f[C]expand_values\f[] to \f[C]false\f[].
-Mixing of iteration types are not permitted since the iterator is set
+Mixing of iteration types is not permitted since the iterator is set
 according to the iteration type and cannot be reused.
 Here is an example of iteration over the objects using libucl API
 (assuming that \f[C]top\f[] is \f[C]UCL_OBJECT\f[] in this example):
@@ -599,8 +600,8 @@ If this function returns \f[C]true\f[] then validation procedure has
 been succeed.
 Otherwise, \f[C]false\f[] is returned and \f[C]err\f[] is set to a
 specific value.
-If caller set \f[C]err\f[] to NULL then this function does not set any
+If a caller sets \f[C]err\f[] to NULL then this function does not set
-error just returning \f[C]false\f[].
+any error just returning \f[C]false\f[].
 Error is the structure defined as following:
 .IP
 .nf
@@ -608,7 +609,7 @@ Error is the structure defined as following:
 struct\ ucl_schema_error\ {
 \ \ \ \ enum\ ucl_schema_error_code\ code;\ \ \ \ /*\ error\ code\ */
 \ \ \ \ char\ msg[128];\ \ \ \ \ \ \ \ \ \ \ \ \ \ /*\ error\ message\ */
-\ \ \ \ ucl_object_t\ *obj;\ \ \ \ \ \ \ \ \ \ /*\ object\ where\ error\ occured\ */
+\ \ \ \ ucl_object_t\ *obj;\ \ \ \ \ \ \ \ \ \ /*\ object\ where\ error\ occurred\ */
 };
 \f[]
 .fi
@@ -629,8 +630,8 @@ enum\ ucl_schema_error_code\ {
 \f[]
 .fi
 .PP
-\f[C]msg\f[] is a stiring description of an error and \f[C]obj\f[] is an
+\f[C]msg\f[] is a string description of an error and \f[C]obj\f[] is an
-object where error has been occurred.
+object where error has occurred.
 Error object is not allocated by libucl, so there is no need to free it
 after validation (a static object should thus be used).
 .SH AUTHORS

doc/pandoc.template

@@ -1,6 +1,6 @@
-% LIBUCL(5) Libucl manual
+% LIBUCL(3) Libucl manual
 % Vsevolod Stakhov <vsevolod@highsecure.ru>
-% March 20, 2014
+% July 26, 2014
 
 # Name
 

include/ucl.h

@@ -786,6 +786,7 @@ UCL_EXTERN bool ucl_parser_set_filevars (struct ucl_parser *parser, const char *
  * @{
  */
 
+struct ucl_emitter_context;
 /**
  * Structure using for emitter callbacks
  */
@@ -798,10 +799,49 @@ struct ucl_emitter_functions {
 	int (*ucl_emitter_append_int) (int64_t elt, void *ud);
 	/** Append floating point element */
 	int (*ucl_emitter_append_double) (double elt, void *ud);
+	/** Free userdata */
+	void (*ucl_emitter_free_func)(void *ud);
 	/** Opaque userdata pointer */
 	void *ud;
 };
 
+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);
+	/** Start ucl object */
+	void (*ucl_emitter_start_object) (struct ucl_emitter_context *ctx,
+		const ucl_object_t *obj, bool print_key);
+	/** End ucl object */
+	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 print_key);
+	void (*ucl_emitter_end_array) (struct ucl_emitter_context *ctx,
+		const ucl_object_t *obj);
+};
+
+/**
+ * Structure that defines emitter functions
+ */
+struct ucl_emitter_context {
+	/** Name of emitter (e.g. json, compact_json) */
+	const char *name;
+	/** Unique id (e.g. UCL_EMIT_JSON for standard emitters */
+	int id;
+	/** A set of output functions */
+	const struct ucl_emitter_functions *func;
+	/** A set of output operations */
+	const struct ucl_emitter_operations *ops;
+	/** Current amount of indent tabs */
+	unsigned int ident;
+	/** Top level object */
+	const ucl_object_t *top;
+	/** The rest of context */
+	unsigned char data[1];
+};
+
 /**
  * Emit object to a string
  * @param obj object
@@ -817,11 +857,81 @@ UCL_EXTERN unsigned char *ucl_object_emit (const ucl_object_t *obj,
  * @param obj object
  * @param emit_type if type is #UCL_EMIT_JSON then emit json, if type is
  * #UCL_EMIT_CONFIG then emit config like object
+ * @param emitter a set of emitter functions
  * @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);
+
+/**
+ * Start streamlined UCL object emitter
+ * @param obj top UCL object
+ * @param emit_type emit type
+ * @param emitter a set of emitter functions
+ * @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);
+
+/**
+ * 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);
+/**
+ * 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);
+/**
+ * End previously added container
+ * @param ctx streamlined context
+ */
+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);
+
+/**
+ * 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);
+
+/**
+ * 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);
+/**
+ * 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);
+
+/**
+ * Free emitter functions
+ * @param f pointer to functions
+ */
+UCL_EXTERN void ucl_object_emit_funcs_free (struct ucl_emitter_functions *f);
+
 /** @} */
 
 /**

src/Makefile.am

@@ -4,6 +4,8 @@ libucl_common_cflags=	-I$(top_srcdir)/src \
 			-Wall -W -Wno-unused-parameter -Wno-pointer-sign
 lib_LTLIBRARIES=	libucl.la
 libucl_la_SOURCES=	ucl_emitter.c \
+					ucl_emitter_streamline.c \
+					ucl_emitter_utils.c \
 					ucl_hash.c \
 					ucl_parser.c \
 					ucl_schema.c \

src/ucl_emitter_streamline.c

@@ -0,0 +1,166 @@
+/* Copyright (c) 2014, Vsevolod Stakhov
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *       * Redistributions of source code must retain the above copyright
+ *         notice, this list of conditions and the following disclaimer.
+ *       * Redistributions in binary form must reproduce the above copyright
+ *         notice, this list of conditions and the following disclaimer in the
+ *         documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED ''AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL AUTHOR BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include "ucl.h"
+#include "ucl_internal.h"
+#include "ucl_chartable.h"
+
+struct ucl_emitter_streamline_stack {
+	bool is_array;
+	bool empty;
+	const ucl_object_t *obj;
+	struct ucl_emitter_streamline_stack *next;
+};
+
+struct ucl_emitter_context_streamline {
+	/* Inherited from the main context */
+	const char *name;
+	int id;
+	const struct ucl_emitter_functions *func;
+	const struct ucl_emitter_operations *ops;
+	unsigned int ident;
+	const ucl_object_t *top;
+
+	/* Streamline specific fields */
+	struct ucl_emitter_streamline_stack *containers;
+};
+
+#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)
+{
+	const struct ucl_emitter_context *ctx;
+	struct ucl_emitter_context_streamline *sctx;
+
+	ctx = ucl_emit_get_standard_context (emit_type);
+	if (ctx == NULL) {
+		return NULL;
+	}
+
+	sctx = calloc (1, sizeof (*sctx));
+	if (sctx == NULL) {
+		return NULL;
+	}
+
+	memcpy (sctx, ctx, sizeof (*ctx));
+	sctx->func = emitter;
+	sctx->top = obj;
+
+	ucl_object_emit_streamline_start_container ((struct ucl_emitter_context *)sctx,
+			obj);
+
+	return (struct ucl_emitter_context *)sctx;
+}
+
+void
+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;
+	bool print_key = false;
+
+	/* Check top object presence */
+	if (sctx->top == NULL) {
+		sctx->top = obj;
+	}
+
+	top = sctx->containers;
+	st = malloc (sizeof (*st));
+	if (st != NULL) {
+		if (top != NULL && !top->is_array) {
+			print_key = true;
+		}
+		st->empty = true;
+		st->obj = obj;
+		if (obj != NULL && obj->type == UCL_ARRAY) {
+			st->is_array = true;
+			sctx->ops->ucl_emitter_start_array (ctx, obj, print_key);
+		}
+		else {
+			st->is_array = false;
+			sctx->ops->ucl_emitter_start_object (ctx, obj, print_key);
+		}
+	}
+
+	LL_PREPEND (sctx->containers, st);
+}
+
+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;
+
+	if (sctx->containers != NULL) {
+		if (sctx->containers->is_array) {
+			is_array = true;
+		}
+		if (sctx->containers->empty) {
+			is_first = true;
+			sctx->containers->empty = false;
+		}
+	}
+
+	sctx->ops->ucl_emitter_write_elt (ctx, obj, is_first, !is_array);
+}
+
+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;
+
+	if (sctx->containers != NULL) {
+		st = sctx->containers;
+
+		if (st->is_array) {
+			sctx->ops->ucl_emitter_end_array (ctx, st->obj);
+		}
+		else {
+			sctx->ops->ucl_emitter_end_object (ctx, st->obj);
+		}
+		sctx->containers = st->next;
+		free (st);
+	}
+}
+
+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);
+	}
+
+	free (sctx);
+}

src/ucl_emitter_utils.c

@@ -0,0 +1,466 @@
+/* Copyright (c) 2014, Vsevolod Stakhov
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *       * Redistributions of source code must retain the above copyright
+ *         notice, this list of conditions and the following disclaimer.
+ *       * Redistributions in binary form must reproduce the above copyright
+ *         notice, this list of conditions and the following disclaimer in the
+ *         documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED ''AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL AUTHOR BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include "ucl.h"
+#include "ucl_internal.h"
+#include "ucl_chartable.h"
+
+#ifdef HAVE_FLOAT_H
+#include <float.h>
+#endif
+#ifdef HAVE_MATH_H
+#include <math.h>
+#endif
+
+extern const struct ucl_emitter_operations ucl_standartd_emitter_ops[];
+
+static const struct ucl_emitter_context ucl_standard_emitters[] = {
+	[UCL_EMIT_JSON] = {
+		.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]
+	}
+};
+
+/**
+ * Get standard emitter context for a specified emit_type
+ * @param emit_type type of emitter
+ * @return context or NULL if input is invalid
+ */
+const struct ucl_emitter_context *
+ucl_emit_get_standard_context (enum ucl_emitter emit_type)
+{
+	if (emit_type >= UCL_EMIT_JSON && emit_type <= UCL_EMIT_YAML) {
+		return &ucl_standard_emitters[emit_type];
+	}
+
+	return NULL;
+}
+
+/**
+ * Serialise 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)
+{
+	const char *p = str, *c = str;
+	size_t len = 0;
+	const struct ucl_emitter_functions *func = ctx->func;
+
+	if (ctx->id != UCL_EMIT_YAML) {
+		func->ucl_emitter_append_character ('"', 1, func->ud);
+	}
+
+	while (size) {
+		if (ucl_test_character (*p, UCL_CHARACTER_JSON_UNSAFE)) {
+			if (len > 0) {
+				func->ucl_emitter_append_len (c, len, func->ud);
+			}
+			switch (*p) {
+			case '\n':
+				func->ucl_emitter_append_len ("\\n", 2, func->ud);
+				break;
+			case '\r':
+				func->ucl_emitter_append_len ("\\r", 2, func->ud);
+				break;
+			case '\b':
+				func->ucl_emitter_append_len ("\\b", 2, func->ud);
+				break;
+			case '\t':
+				func->ucl_emitter_append_len ("\\t", 2, func->ud);
+				break;
+			case '\f':
+				func->ucl_emitter_append_len ("\\f", 2, func->ud);
+				break;
+			case '\\':
+				func->ucl_emitter_append_len ("\\\\", 2, func->ud);
+				break;
+			case '"':
+				func->ucl_emitter_append_len ("\\\"", 2, func->ud);
+				break;
+			}
+			len = 0;
+			c = ++p;
+		}
+		else {
+			p ++;
+			len ++;
+		}
+		size --;
+	}
+	if (len > 0) {
+		func->ucl_emitter_append_len (c, len, func->ud);
+	}
+	if (ctx->id != UCL_EMIT_YAML) {
+		func->ucl_emitter_append_character ('"', 1, func->ud);
+	}
+}
+
+/*
+ * Generic utstring output
+ */
+static int
+ucl_utstring_append_character (unsigned char c, size_t len, void *ud)
+{
+	UT_string *buf = ud;
+
+	if (len == 1) {
+		utstring_append_c (buf, c);
+	}
+	else {
+		utstring_reserve (buf, len);
+		memset (&buf->d[buf->i], c, len);
+		buf->i += len;
+		buf->d[buf->i] = '\0';
+	}
+
+	return 0;
+}
+
+static int
+ucl_utstring_append_len (const unsigned char *str, size_t len, void *ud)
+{
+	UT_string *buf = ud;
+
+	utstring_append_len (buf, str, len);
+
+	return 0;
+}
+
+static int
+ucl_utstring_append_int (int64_t val, void *ud)
+{
+	UT_string *buf = ud;
+
+	utstring_printf (buf, "%jd", (intmax_t)val);
+	return 0;
+}
+
+static int
+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);
+	}
+	else if (fabs (val - (double)(int)val) < delta) {
+		/* Write at maximum precision */
+		utstring_printf (buf, "%.*lg", DBL_DIG, val);
+	}
+	else {
+		utstring_printf (buf, "%lf", val);
+	}
+
+	return 0;
+}
+
+/*
+ * Generic file output
+ */
+static int
+ucl_file_append_character (unsigned char c, size_t len, void *ud)
+{
+	FILE *fp = ud;
+
+	while (len --) {
+		fputc (c, fp);
+	}
+
+	return 0;
+}
+
+static int
+ucl_file_append_len (const unsigned char *str, size_t len, void *ud)
+{
+	FILE *fp = ud;
+
+	fwrite (str, len, 1, fp);
+
+	return 0;
+}
+
+static int
+ucl_file_append_int (int64_t val, void *ud)
+{
+	FILE *fp = ud;
+
+	fprintf (fp, "%jd", (intmax_t)val);
+
+	return 0;
+}
+
+static int
+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);
+	}
+	else if (fabs (val - (double)(int)val) < delta) {
+		/* Write at maximum precision */
+		fprintf (fp, "%.*lg", DBL_DIG, val);
+	}
+	else {
+		fprintf (fp, "%lf", val);
+	}
+
+	return 0;
+}
+
+/*
+ * Generic file descriptor writing functions
+ */
+static int
+ucl_fd_append_character (unsigned char c, size_t len, void *ud)
+{
+	int fd = *(int *)ud;
+	unsigned char *buf;
+
+	if (len == 1) {
+		write (fd, &c, 1);
+	}
+	else {
+		buf = malloc (len);
+		if (buf == NULL) {
+			/* Fallback */
+			while (len --) {
+				write (fd, &c, 1);
+			}
+		}
+		else {
+			memset (buf, c, len);
+			write (fd, buf, len);
+			free (buf);
+		}
+	}
+
+	return 0;
+}
+
+static int
+ucl_fd_append_len (const unsigned char *str, size_t len, void *ud)
+{
+	int fd = *(int *)ud;
+
+	write (fd, str, len);
+
+	return 0;
+}
+
+static int
+ucl_fd_append_int (int64_t val, void *ud)
+{
+	int fd = *(int *)ud;
+	char intbuf[64];
+
+	snprintf (intbuf, sizeof (intbuf), "%jd", (intmax_t)val);
+	write (fd, intbuf, strlen (intbuf));
+
+	return 0;
+}
+
+static int
+ucl_fd_append_double (double val, void *ud)
+{
+	int fd = *(int *)ud;
+	const double delta = 0.0000001;
+	char nbuf[64];
+
+	if (val == (double)(int)val) {
+		snprintf (nbuf, sizeof (nbuf), "%.1lf", val);
+	}
+	else if (fabs (val - (double)(int)val) < delta) {
+		/* Write at maximum precision */
+		snprintf (nbuf, sizeof (nbuf), "%.*lg", DBL_DIG, val);
+	}
+	else {
+		snprintf (nbuf, sizeof (nbuf), "%lf", val);
+	}
+
+	write (fd, nbuf, strlen (nbuf));
+
+	return 0;
+}
+
+struct ucl_emitter_functions*
+ucl_object_emit_memory_funcs (void **pmem)
+{
+	struct ucl_emitter_functions *f;
+	UT_string *s;
+
+	f = calloc (1, sizeof (*f));
+
+	if (f != NULL) {
+		f->ucl_emitter_append_character = ucl_utstring_append_character;
+		f->ucl_emitter_append_double = ucl_utstring_append_double;
+		f->ucl_emitter_append_int = ucl_utstring_append_int;
+		f->ucl_emitter_append_len = ucl_utstring_append_len;
+		f->ucl_emitter_free_func = free;
+		utstring_new (s);
+		f->ud = s;
+		*pmem = s->d;
+		s->pd = pmem;
+	}
+
+	return f;
+}
+
+struct ucl_emitter_functions*
+ucl_object_emit_file_funcs (FILE *fp)
+{
+	struct ucl_emitter_functions *f;
+
+	f = calloc (1, sizeof (*f));
+
+	if (f != NULL) {
+		f->ucl_emitter_append_character = ucl_file_append_character;
+		f->ucl_emitter_append_double = ucl_file_append_double;
+		f->ucl_emitter_append_int = ucl_file_append_int;
+		f->ucl_emitter_append_len = ucl_file_append_len;
+		f->ucl_emitter_free_func = NULL;
+		f->ud = fp;
+	}
+
+	return f;
+}
+
+struct ucl_emitter_functions*
+ucl_object_emit_fd_funcs (int fd)
+{
+	struct ucl_emitter_functions *f;
+	int *ip;
+
+	f = calloc (1, sizeof (*f));
+
+	if (f != NULL) {
+		ip = malloc (sizeof (fd));
+		if (ip == NULL) {
+			free (f);
+			return NULL;
+		}
+
+		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;
+		f->ucl_emitter_append_len = ucl_fd_append_len;
+		f->ucl_emitter_free_func = free;
+		f->ud = ip;
+	}
+
+	return 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);
+		}
+		free (f);
+	}
+}
+
+
+unsigned char *
+ucl_object_emit_single_json (const ucl_object_t *obj)
+{
+	UT_string *buf = NULL;
+	unsigned char *res = NULL;
+
+	if (obj == NULL) {
+		return NULL;
+	}
+
+	utstring_new (buf);
+
+	if (buf != NULL) {
+		switch (obj->type) {
+		case UCL_OBJECT:
+			ucl_utstring_append_len ("object", 6, buf);
+			break;
+		case UCL_ARRAY:
+			ucl_utstring_append_len ("array", 5, buf);
+			break;
+		case UCL_INT:
+			ucl_utstring_append_int (obj->value.iv, buf);
+			break;
+		case UCL_FLOAT:
+		case UCL_TIME:
+			ucl_utstring_append_double (obj->value.dv, buf);
+			break;
+		case UCL_NULL:
+			ucl_utstring_append_len ("null", 4, buf);
+			break;
+		case UCL_BOOLEAN:
+			if (obj->value.iv) {
+				ucl_utstring_append_len ("true", 4, buf);
+			}
+			else {
+				ucl_utstring_append_len ("false", 5, buf);
+			}
+			break;
+		case UCL_STRING:
+			ucl_utstring_append_len (obj->value.sv, obj->len, buf);
+			break;
+		case UCL_USERDATA:
+			ucl_utstring_append_len ("userdata", 8, buf);
+			break;
+		}
+		res = utstring_body (buf);
+		free (buf);
+	}
+
+	return res;
+}

src/ucl_internal.h

@@ -342,6 +342,22 @@ ucl_hash_insert_object (ucl_hash_t *hashlin, const ucl_object_t *obj)
 	return hashlin;
 }
 
+/**
+ * Get standard emitter context for a specified emit_type
+ * @param emit_type type of emitter
+ * @return context or NULL if input is invalid
+ */
+const struct ucl_emitter_context *
+ucl_emit_get_standard_context (enum ucl_emitter emit_type);
+
+/**
+ * Serialise 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);
+
 /**
  * Emit a single object to string
  * @param obj

src/ucl_parser.c

@@ -393,9 +393,16 @@ ucl_expand_single_variable (struct ucl_parser *parser, const char *ptr,
 
 		/* Leave variable as is */
 		if (!found) {
-			memcpy (d, ptr, 2);
+			if (strict) {
-			d += 2;
+				/* Copy '${' */
-			ret --;
+				memcpy (d, ptr, 2);
+				d += 2;
+				ret --;
+			}
+			else {
+				memcpy (d, ptr, 1);
+				d ++;
+			}
 		}
 	}
 

tests/Makefile.am

@@ -3,7 +3,8 @@ EXTRA_DIST = $(TESTS) basic schema generate.res rcl_test.json.xz
 TESTS = basic.test \
 		generate.test \
 		schema.test \
-		speed.test
+		speed.test \
+		streamline.test
 TESTS_ENVIRONMENT = $(SH) \
 			TEST_DIR=$(top_srcdir)/tests \
 			TEST_OUT_DIR=$(top_builddir)/tests \
@@ -30,4 +31,8 @@ test_schema_SOURCES = test_schema.c
 test_schema_LDADD = $(common_test_ldadd)
 test_schema_CFLAGS = $(common_test_cflags)
 
-check_PROGRAMS = test_basic test_speed test_generate test_schema
+test_streamline_SOURCES = test_streamline.c
+test_streamline_LDADD = $(common_test_ldadd)
+test_streamline_CFLAGS = $(common_test_cflags)
+
+check_PROGRAMS = test_basic test_speed test_generate test_schema test_streamline

tests/streamline.res

@@ -0,0 +1,8 @@
+key1 = "test string";
+key2 = "test \\nstring";
+key3 = "  test string    \n";
+key4 [
+    10,
+    10.100000,
+    9.999000,
+]

tests/streamline.test

@@ -0,0 +1,12 @@
+#!/bin/sh
+
+PROG=${TEST_BINARY_DIR}/test_streamline
+
+$PROG ${TEST_OUT_DIR}/streamline.out
+diff -s ${TEST_OUT_DIR}/streamline.out ${TEST_DIR}/streamline.res -u 2>/dev/null
+if [ $? -ne 0 ] ; then
+	rm ${TEST_OUT_DIR}/streamline.out
+	echo "Test: streamline.res output missmatch"
+	exit 1
+fi
+rm ${TEST_OUT_DIR}/streamline.out

tests/test_basic.c

@@ -33,15 +33,21 @@ main (int argc, char **argv)
 	FILE *in, *out;
 	unsigned char *emitted = NULL;
 	const char *fname_in = NULL, *fname_out = NULL;
-	int ret = 0, inlen, opt, json = 0;
+	int ret = 0, inlen, opt, json = 0, compact = 0, yaml = 0;
 
-	while ((opt = getopt(argc, argv, "j")) != -1) {
+	while ((opt = getopt(argc, argv, "jcy")) != -1) {
 		switch (opt) {
 		case 'j':
 			json = 1;
 			break;
+		case 'c':
+			compact = 1;
+			break;
+		case 'y':
+			yaml = 1;
+			break;
 		default: /* '?' */
-			fprintf (stderr, "Usage: %s [-j] [in] [out]\n",
+			fprintf (stderr, "Usage: %s [-jcy] [in] [out]\n",
 					argv[0]);
 			exit (EXIT_FAILURE);
 		}
@@ -104,7 +110,15 @@ main (int argc, char **argv)
 	}
 	obj = ucl_parser_get_object (parser);
 	if (json) {
-		emitted = ucl_object_emit (obj, UCL_EMIT_JSON);
+		if (compact) {
+			emitted = ucl_object_emit (obj, UCL_EMIT_JSON_COMPACT);
+		}
+		else {
+			emitted = ucl_object_emit (obj, UCL_EMIT_JSON);
+		}
+	}
+	else if (yaml) {
+		emitted = ucl_object_emit (obj, UCL_EMIT_YAML);
 	}
 	else {
 		emitted = ucl_object_emit (obj, UCL_EMIT_CONFIG);
@@ -125,7 +139,15 @@ main (int argc, char **argv)
 	}
 	obj = ucl_parser_get_object (parser2);
 	if (json) {
-		emitted = ucl_object_emit (obj, UCL_EMIT_JSON);
+		if (compact) {
+			emitted = ucl_object_emit (obj, UCL_EMIT_JSON_COMPACT);
+		}
+		else {
+			emitted = ucl_object_emit (obj, UCL_EMIT_JSON);
+		}
+	}
+	else if (yaml) {
+		emitted = ucl_object_emit (obj, UCL_EMIT_YAML);
 	}
 	else {
 		emitted = ucl_object_emit (obj, UCL_EMIT_CONFIG);

tests/test_streamline.c

@@ -0,0 +1,92 @@
+/* Copyright (c) 2013, Vsevolod Stakhov
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *       * Redistributions of source code must retain the above copyright
+ *         notice, this list of conditions and the following disclaimer.
+ *       * Redistributions in binary form must reproduce the above copyright
+ *         notice, this list of conditions and the following disclaimer in the
+ *         documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED ''AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL AUTHOR BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include <stdio.h>
+#include <errno.h>
+#include <assert.h>
+#include "ucl.h"
+
+int
+main (int argc, char **argv)
+{
+	ucl_object_t *obj, *cur, *ar;
+	FILE *out;
+	const char *fname_out = NULL;
+	struct ucl_emitter_context *ctx;
+	struct ucl_emitter_functions *f;
+	int ret = 0;
+
+	switch (argc) {
+	case 2:
+		fname_out = argv[1];
+		break;
+	}
+
+	if (fname_out != NULL) {
+		out = fopen (fname_out, "w");
+		if (out == NULL) {
+			exit (-errno);
+		}
+	}
+	else {
+		out = stdout;
+	}
+
+	obj = ucl_object_typed_new (UCL_OBJECT);
+
+	/* Create some strings */
+	cur = ucl_object_fromstring_common ("  test string    ", 0, UCL_STRING_TRIM);
+	ucl_object_insert_key (obj, cur, "key1", 0, false);
+	cur = ucl_object_fromstring_common ("  test \nstring\n    ", 0, UCL_STRING_TRIM | UCL_STRING_ESCAPE);
+	ucl_object_insert_key (obj, cur, "key2", 0, false);
+	cur = ucl_object_fromstring_common ("  test string    \n", 0, 0);
+	ucl_object_insert_key (obj, cur, "key3", 0, false);
+
+	f = ucl_object_emit_file_funcs (out);
+	ctx = ucl_object_emit_streamline_new (obj, UCL_EMIT_CONFIG, f);
+
+	assert (ctx != NULL);
+
+	/* Array of numbers */
+	ar = ucl_object_typed_new (UCL_ARRAY);
+	ar->key = "key4";
+	ar->keylen = sizeof ("key4") - 1;
+
+	ucl_object_emit_streamline_start_container (ctx, ar);
+	cur = ucl_object_fromint (10);
+	ucl_object_emit_streamline_add_object (ctx, cur);
+	cur = ucl_object_fromdouble (10.1);
+	ucl_object_emit_streamline_add_object (ctx, cur);
+	cur = ucl_object_fromdouble (9.999);
+	ucl_object_emit_streamline_add_object (ctx, cur);
+
+
+	ucl_object_emit_streamline_end_container (ctx);
+	ucl_object_emit_streamline_finish (ctx);
+	ucl_object_emit_funcs_free (f);
+	ucl_object_unref (obj);
+
+	fclose (out);
+
+	return ret;
+}

uthash/utstring.h

@@ -44,6 +44,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 typedef struct {
     char *d;
+    void **pd;
     size_t n; /* allocd size */
     size_t i; /* index of first unused byte */
 } UT_string;
@@ -54,6 +55,7 @@ do {                                                       \
      (s)->d = (char*)realloc((s)->d, (s)->n + amt);        \
      if ((s)->d == NULL) oom();                            \
      (s)->n += amt;                                        \
+     if ((s)->pd) *((s)->pd) = (s)->d;                     \
   }                                                        \
 } while(0)
 
@@ -78,7 +80,7 @@ do {                                                       \
 
 #define utstring_new(s)                                    \
 do {                                                       \
-   s = (UT_string*)calloc(sizeof(UT_string),1);            \
+   s = (UT_string*)calloc(1, sizeof(UT_string));          \
    if (!s) oom();                                          \
    utstring_init(s);                                       \
 } while(0)