aboutsummaryrefslogtreecommitdiff
diff options
context:
space:
mode:
Diffstat
-rw-r--r--ChangeLog.md6
-rw-r--r--configure.ac6
-rw-r--r--doc/api.md34
-rw-r--r--doc/libucl.351
-rw-r--r--doc/pandoc.template4
-rw-r--r--include/ucl.h110
-rw-r--r--src/Makefile.am2
-rw-r--r--src/ucl_emitter.c934
-rw-r--r--src/ucl_emitter_streamline.c166
-rw-r--r--src/ucl_emitter_utils.c466
-rw-r--r--src/ucl_internal.h16
-rw-r--r--src/ucl_parser.c13
-rw-r--r--tests/Makefile.am9
-rw-r--r--tests/streamline.res8
-rwxr-xr-xtests/streamline.test12
-rw-r--r--tests/test_basic.c32
-rw-r--r--tests/test_streamline.c92
-rw-r--r--uthash/utstring.h4
18 files changed, 1257 insertions, 708 deletions
diff --git a/ChangeLog.md b/ChangeLog.md
new file mode 100644
index 000000000000..09c331f4c6d1
--- /dev/null
+++ b/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
diff --git a/configure.ac b/configure.ac
index de78e8b183aa..2d612f6236e8 100644
--- a/configure.ac
+++ b/configure.ac
@@ -1,7 +1,7 @@
m4_define([maj_ver], [0])
-m4_define([med_ver], [4])
-m4_define([min_ver], [1])
-m4_define([so_version], [1:0:0])
+m4_define([med_ver], [5])
+m4_define([min_ver], [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])
diff --git a/doc/api.md b/doc/api.md
index 41e660a428ea..174c7ff47060 100644
--- a/doc/api.md
+++ b/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)
-- `Config` - human-readable configuration format (losseless)
+- `JSON` - valid json format (can possibly lose some original data, such as implicit arrays)
+- `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_fromlstring` - converts `const char *` and `size_t` len to UCL object (string can be not 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 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). \ No newline at end of file
+`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).
diff --git a/doc/libucl.3 b/doc/libucl.3
index a185d1a56675..e319a0d3f932 100644
--- a/doc/libucl.3
+++ b/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
-compact json format actually.
+For objects, arrays, booleans 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
@@ -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]ucl_object_fromlstring\f[] \- converts \f[C]const\ char\ *\f[]
-and \f[C]size_t\f[] len to UCL object (string can be not NULL
-terminated)
+\f[C]const\ char\ *\f[] to UCL object (this string should be NULL
+terminated) \- \f[C]ucl_object_fromlstring\f[] \- converts
+\f[C]const\ char\ *\f[] and \f[C]size_t\f[] len to UCL object (string
+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
-error just returning \f[C]false\f[].
+If a caller sets \f[C]err\f[] to NULL then this function does not set
+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
-object where error has been occurred.
+\f[C]msg\f[] is a string description of an error and \f[C]obj\f[] 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).
.SH AUTHORS
diff --git a/doc/pandoc.template b/doc/pandoc.template
index e29e20c287b7..6d5f0277ae40 100644
--- a/doc/pandoc.template
+++ b/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
diff --git a/include/ucl.h b/include/ucl.h
index 3eeea9a7df0e..b40f11322508 100644
--- a/include/ucl.h
+++ b/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);
+
/** @} */
/**
diff --git a/src/Makefile.am b/src/Makefile.am
index 76391cd044f0..417d34e161ca 100644
--- a/src/Makefile.am
+++ b/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 \
diff --git a/src/ucl_emitter.c b/src/ucl_emitter.c
index 04c3d4b13232..11fe50c00602 100644
--- a/src/ucl_emitter.c
+++ b/src/ucl_emitter.c
@@ -36,38 +36,55 @@
#endif
/**
- * @file rcl_emitter.c
+ * @file ucl_emitter.c
* Serialise UCL object to various of output formats
*/
+static void ucl_emitter_common_elt (struct ucl_emitter_context *ctx,
+ const ucl_object_t *obj, bool first, bool print_key, bool compact);
+
+#define UCL_EMIT_TYPE_OPS(type) \
+ static void ucl_emit_ ## type ## _elt (struct ucl_emitter_context *ctx, \
+ const ucl_object_t *obj, bool first, bool print_key); \
+ static void ucl_emit_ ## type ## _start_obj (struct ucl_emitter_context *ctx, \
+ const ucl_object_t *obj, bool print_key); \
+ static void ucl_emit_ ## type## _start_array (struct ucl_emitter_context *ctx, \
+ const ucl_object_t *obj, bool print_key); \
+ static void ucl_emit_ ##type## _end_object (struct ucl_emitter_context *ctx, \
+ const ucl_object_t *obj); \
+ static void ucl_emit_ ##type## _end_array (struct ucl_emitter_context *ctx, \
+ const ucl_object_t *obj)
+
+/*
+ * JSON format operations
+ */
+UCL_EMIT_TYPE_OPS(json);
+UCL_EMIT_TYPE_OPS(json_compact);
+UCL_EMIT_TYPE_OPS(config);
+UCL_EMIT_TYPE_OPS(yaml);
+
+#define UCL_EMIT_TYPE_CONTENT(type) { \
+ .ucl_emitter_write_elt = ucl_emit_ ## type ## _elt, \
+ .ucl_emitter_start_object = ucl_emit_ ## type ##_start_obj, \
+ .ucl_emitter_start_array = ucl_emit_ ## type ##_start_array, \
+ .ucl_emitter_end_object = ucl_emit_ ## type ##_end_object, \
+ .ucl_emitter_end_array = ucl_emit_ ## type ##_end_array \
+}
+
+
+const struct ucl_emitter_operations ucl_standartd_emitter_ops[] = {
+ [UCL_EMIT_JSON] = UCL_EMIT_TYPE_CONTENT(json),
+ [UCL_EMIT_JSON_COMPACT] = UCL_EMIT_TYPE_CONTENT(json_compact),
+ [UCL_EMIT_CONFIG] = UCL_EMIT_TYPE_CONTENT(config),
+ [UCL_EMIT_YAML] = UCL_EMIT_TYPE_CONTENT(yaml)
+};
+
+/*
+ * Utility to check whether we need a top object
+ */
+#define UCL_EMIT_IDENT_TOP_OBJ(ctx, obj) ((ctx)->top != (obj) || \
+ ((ctx)->id == UCL_EMIT_JSON_COMPACT || (ctx)->id == UCL_EMIT_JSON))
-static void ucl_obj_write_json (const ucl_object_t *obj,
- struct ucl_emitter_functions *func,
- unsigned int tabs,
- bool start_tabs,
- bool compact);
-static void ucl_elt_write_json (const ucl_object_t *obj,
- struct ucl_emitter_functions *func,
- unsigned int tabs,
- bool start_tabs,
- bool compact);
-static void ucl_elt_write_config (const ucl_object_t *obj,
- struct ucl_emitter_functions *func,
- unsigned int tabs,
- bool start_tabs,
- bool is_top,
- bool expand_array);
-static void ucl_elt_write_yaml (const ucl_object_t *obj,
- struct ucl_emitter_functions *func,
- unsigned int tabs,
- bool start_tabs,
- bool compact,
- bool expand_array);
-static void ucl_elt_array_write_yaml (const ucl_object_t *obj,
- struct ucl_emitter_functions *func,
- unsigned int tabs,
- bool start_tabs,
- bool is_top);
/**
* Add tabulation to the output buffer
@@ -75,689 +92,358 @@ static void ucl_elt_array_write_yaml (const ucl_object_t *obj,
* @param tabs number of tabs to add
*/
static inline void
-ucl_add_tabs (struct ucl_emitter_functions *func, unsigned int tabs, bool compact)
+ucl_add_tabs (const struct ucl_emitter_functions *func, unsigned int tabs,
+ bool compact)
{
- if (!compact) {
+ if (!compact && tabs > 0) {
func->ucl_emitter_append_character (' ', tabs * 4, func->ud);
}
}
/**
- * Serialise string
- * @param str string to emit
- * @param buf target buffer
+ * Print key for the element
+ * @param ctx
+ * @param obj
*/
static void
-ucl_elt_string_write_json (const char *str, size_t size,
- struct ucl_emitter_functions *func)
+ucl_emitter_print_key (bool print_key, struct ucl_emitter_context *ctx,
+ const ucl_object_t *obj, bool compact)
{
- const char *p = str, *c = str;
- size_t len = 0;
-
- 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;
+ const struct ucl_emitter_functions *func = ctx->func;
+
+ if (!print_key) {
+ return;
+ }
+
+ if (ctx->id == UCL_EMIT_CONFIG) {
+ if (obj->flags & UCL_OBJECT_NEED_KEY_ESCAPE) {
+ ucl_elt_string_write_json (obj->key, obj->keylen, ctx);
}
else {
- p ++;
- len ++;
+ func->ucl_emitter_append_len (obj->key, obj->keylen, func->ud);
}
- size --;
- }
- if (len > 0) {
- func->ucl_emitter_append_len (c, len, func->ud);
- }
- func->ucl_emitter_append_character ('"', 1, func->ud);
-}
-/**
- * Write a single object to the buffer
- * @param obj object to write
- * @param buf target buffer
- */
-static void
-ucl_elt_obj_write_json (const ucl_object_t *obj, struct ucl_emitter_functions *func,
- unsigned int tabs, bool start_tabs, bool compact)
-{
- const ucl_object_t *cur;
- ucl_hash_iter_t it = NULL;
-
- if (start_tabs) {
- ucl_add_tabs (func, tabs, compact);
- }
- if (compact) {
- func->ucl_emitter_append_character ('{', 1, func->ud);
+ if (obj->type != UCL_OBJECT && obj->type != UCL_ARRAY) {
+ func->ucl_emitter_append_len (" = ", 3, func->ud);
+ }
+ else {
+ func->ucl_emitter_append_character (' ', 1, func->ud);
+ }
}
else {
- func->ucl_emitter_append_len ("{\n", 2, func->ud);
- }
- while ((cur = ucl_hash_iterate (obj->value.ov, &it))) {
- ucl_add_tabs (func, tabs + 1, compact);
- if (cur->keylen > 0) {
- ucl_elt_string_write_json (cur->key, cur->keylen, func);
+ if (obj->keylen > 0) {
+ ucl_elt_string_write_json (obj->key, obj->keylen, ctx);
}
else {
func->ucl_emitter_append_len ("null", 4, func->ud);
}
+
if (compact) {
func->ucl_emitter_append_character (':', 1, func->ud);
}
else {
func->ucl_emitter_append_len (": ", 2, func->ud);
}
- ucl_obj_write_json (cur, func, tabs + 1, false, compact);
- if (ucl_hash_iter_has_next (it)) {
- if (compact) {
- func->ucl_emitter_append_character (',', 1, func->ud);
- }
- else {
- func->ucl_emitter_append_len (",\n", 2, func->ud);
- }
- }
- else if (!compact) {
- func->ucl_emitter_append_character ('\n', 1, func->ud);
- }
}
- ucl_add_tabs (func, tabs, compact);
- func->ucl_emitter_append_character ('}', 1, func->ud);
}
-/**
- * Write a single array to the buffer
- * @param obj array to write
- * @param buf target buffer
- */
static void
-ucl_elt_array_write_json (const ucl_object_t *obj, struct ucl_emitter_functions *func,
- unsigned int tabs, bool start_tabs, bool compact)
+ucl_emitter_finish_object (struct ucl_emitter_context *ctx,
+ const ucl_object_t *obj, bool compact, bool is_array)
{
- const ucl_object_t *cur = obj;
+ const struct ucl_emitter_functions *func = ctx->func;
- if (start_tabs) {
- ucl_add_tabs (func, tabs, compact);
- }
- if (compact) {
- func->ucl_emitter_append_character ('[', 1, func->ud);
- }
- else {
- func->ucl_emitter_append_len ("[\n", 2, func->ud);
- }
- while (cur) {
- ucl_elt_write_json (cur, func, tabs + 1, true, compact);
- if (cur->next != NULL) {
- if (compact) {
- func->ucl_emitter_append_character (',', 1, func->ud);
+ if (ctx->id == UCL_EMIT_CONFIG && obj != ctx->top) {
+ if (obj->type != UCL_OBJECT && obj->type != UCL_ARRAY) {
+ if (!is_array) {
+ /* Objects are split by ';' */
+ func->ucl_emitter_append_len (";\n", 2, func->ud);
}
else {
+ /* Use commas for arrays */
func->ucl_emitter_append_len (",\n", 2, func->ud);
}
}
- else if (!compact) {
- func->ucl_emitter_append_character ('\n', 1, func->ud);
- }
- cur = cur->next;
- }
- ucl_add_tabs (func, tabs, compact);
- func->ucl_emitter_append_character (']', 1, func->ud);
-}
-
-/**
- * Emit a single element
- * @param obj object
- * @param buf buffer
- */
-static void
-ucl_elt_write_json (const ucl_object_t *obj, struct ucl_emitter_functions *func,
- unsigned int tabs, bool start_tabs, bool compact)
-{
- bool flag;
-
- switch (obj->type) {
- case UCL_INT:
- if (start_tabs) {
- ucl_add_tabs (func, tabs, compact);
- }
- func->ucl_emitter_append_int (ucl_object_toint (obj), func->ud);
- break;
- case UCL_FLOAT:
- case UCL_TIME:
- if (start_tabs) {
- ucl_add_tabs (func, tabs, compact);
- }
- func->ucl_emitter_append_double (ucl_object_todouble (obj), func->ud);
- break;
- case UCL_BOOLEAN:
- if (start_tabs) {
- ucl_add_tabs (func, tabs, compact);
- }
- flag = ucl_object_toboolean (obj);
- if (flag) {
- func->ucl_emitter_append_len ("true", 4, func->ud);
- }
else {
- func->ucl_emitter_append_len ("false", 5, func->ud);
- }
- break;
- case UCL_STRING:
- if (start_tabs) {
- ucl_add_tabs (func, tabs, compact);
- }
- ucl_elt_string_write_json (obj->value.sv, obj->len, func);
- break;
- case UCL_NULL:
- if (start_tabs) {
- ucl_add_tabs (func, tabs, compact);
+ func->ucl_emitter_append_character ('\n', 1, func->ud);
}
- func->ucl_emitter_append_len ("null", 4, func->ud);
- break;
- case UCL_OBJECT:
- ucl_elt_obj_write_json (obj, func, tabs, start_tabs, compact);
- break;
- case UCL_ARRAY:
- ucl_elt_array_write_json (obj->value.av, func, tabs, start_tabs, compact);
- break;
- case UCL_USERDATA:
- break;
}
}
/**
- * Write a single object to the buffer
- * @param obj object
- * @param buf target buffer
+ * End standard ucl object
+ * @param ctx emitter context
+ * @param compact compact flag
*/
static void
-ucl_obj_write_json (const ucl_object_t *obj, struct ucl_emitter_functions *func,
- unsigned int tabs, bool start_tabs, bool compact)
+ucl_emitter_common_end_object (struct ucl_emitter_context *ctx,
+ const ucl_object_t *obj, bool compact)
{
- const ucl_object_t *cur;
- bool is_array = (obj->next != NULL);
-
- if (is_array) {
- /* This is an array actually */
- if (start_tabs) {
- ucl_add_tabs (func, tabs, compact);
- }
+ const struct ucl_emitter_functions *func = ctx->func;
+ if (UCL_EMIT_IDENT_TOP_OBJ(ctx, obj)) {
+ ctx->ident --;
if (compact) {
- func->ucl_emitter_append_character ('[', 1, func->ud);
+ func->ucl_emitter_append_character ('}', 1, func->ud);
}
else {
- func->ucl_emitter_append_len ("[\n", 2, func->ud);
- }
- cur = obj;
- while (cur != NULL) {
- ucl_elt_write_json (cur, func, tabs + 1, true, compact);
- if (cur->next) {
- func->ucl_emitter_append_character (',', 1, func->ud);
- }
- if (!compact) {
+ if (ctx->id != UCL_EMIT_CONFIG) {
+ /* newline is already added for this format */
func->ucl_emitter_append_character ('\n', 1, func->ud);
}
- cur = cur->next;
+ ucl_add_tabs (func, ctx->ident, compact);
+ func->ucl_emitter_append_character ('}', 1, func->ud);
}
- ucl_add_tabs (func, tabs, compact);
- func->ucl_emitter_append_character (']', 1, func->ud);
- }
- else {
- ucl_elt_write_json (obj, func, tabs, start_tabs, compact);
}
+ ucl_emitter_finish_object (ctx, obj, compact, false);
}
/**
- * Emit an object to json
- * @param obj object
- * @return json output (should be freed after using)
+ * End standard ucl array
+ * @param ctx emitter context
+ * @param compact compact flag
*/
static void
-ucl_object_emit_json (const ucl_object_t *obj, bool compact,
- struct ucl_emitter_functions *func)
+ucl_emitter_common_end_array (struct ucl_emitter_context *ctx,
+ const ucl_object_t *obj, bool compact)
{
- ucl_obj_write_json (obj, func, 0, false, compact);
-}
-
-/**
- * Write a single object to the buffer
- * @param obj object to write
- * @param buf target buffer
- */
-static void
-ucl_elt_obj_write_config (const ucl_object_t *obj, struct ucl_emitter_functions *func,
- unsigned int tabs, bool start_tabs, bool is_top)
-{
- const ucl_object_t *cur, *cur_obj;
- ucl_hash_iter_t it = NULL;
+ const struct ucl_emitter_functions *func = ctx->func;
- if (start_tabs) {
- ucl_add_tabs (func, tabs, is_top);
- }
- if (!is_top) {
- func->ucl_emitter_append_len ("{\n", 2, func->ud);
+ ctx->ident --;
+ if (compact) {
+ func->ucl_emitter_append_character (']', 1, func->ud);
}
-
- while ((cur = ucl_hash_iterate (obj->value.ov, &it))) {
- LL_FOREACH (cur, cur_obj) {
- ucl_add_tabs (func, tabs + 1, is_top);
- if (cur_obj->flags & UCL_OBJECT_NEED_KEY_ESCAPE) {
- ucl_elt_string_write_json (cur_obj->key, cur_obj->keylen, func);
- }
- else {
- func->ucl_emitter_append_len (cur_obj->key, cur_obj->keylen, func->ud);
- }
- if (cur_obj->type != UCL_OBJECT && cur_obj->type != UCL_ARRAY) {
- func->ucl_emitter_append_len (" = ", 3, func->ud);
- }
- else {
- func->ucl_emitter_append_character (' ', 1, func->ud);
- }
- ucl_elt_write_config (cur_obj, func,
- is_top ? tabs : tabs + 1,
- false, false, false);
- if (cur_obj->type != UCL_OBJECT && cur_obj->type != UCL_ARRAY) {
- func->ucl_emitter_append_len (";\n", 2, func->ud);
- }
- else {
- func->ucl_emitter_append_character ('\n', 1, func->ud);
- }
+ else {
+ if (ctx->id != UCL_EMIT_CONFIG) {
+ /* newline is already added for this format */
+ func->ucl_emitter_append_character ('\n', 1, func->ud);
}
+ ucl_add_tabs (func, ctx->ident, compact);
+ func->ucl_emitter_append_character (']', 1, func->ud);
}
- ucl_add_tabs (func, tabs, is_top);
- if (!is_top) {
- func->ucl_emitter_append_character ('}', 1, func->ud);
- }
+ ucl_emitter_finish_object (ctx, obj, compact, true);
}
/**
- * Write a single array to the buffer
- * @param obj array to write
- * @param buf target buffer
+ * Start emit standard UCL array
+ * @param ctx emitter context
+ * @param obj object to write
+ * @param compact compact flag
*/
static void
-ucl_elt_array_write_config (const ucl_object_t *obj, struct ucl_emitter_functions *func,
- unsigned int tabs, bool start_tabs, bool is_top)
+ucl_emitter_common_start_array (struct ucl_emitter_context *ctx,
+ const ucl_object_t *obj, bool print_key, bool compact)
{
- const ucl_object_t *cur = obj;
-
- if (start_tabs) {
- ucl_add_tabs (func, tabs, false);
- }
+ const ucl_object_t *cur;
+ const struct ucl_emitter_functions *func = ctx->func;
+ bool first = true;
- func->ucl_emitter_append_len ("[\n", 2, func->ud);
- while (cur) {
- ucl_elt_write_config (cur, func, tabs + 1, true, false, false);
- func->ucl_emitter_append_len (",\n", 2, func->ud);
- cur = cur->next;
- }
- ucl_add_tabs (func, tabs, false);
- func->ucl_emitter_append_character (']', 1, func->ud);
-}
+ ucl_emitter_print_key (print_key, ctx, obj, compact);
-/**
- * Emit a single element
- * @param obj object
- * @param buf buffer
- */
-static void
-ucl_elt_write_config (const ucl_object_t *obj, struct ucl_emitter_functions *func,
- unsigned int tabs, bool start_tabs, bool is_top, bool expand_array)
-{
- bool flag;
-
- if (expand_array && obj->next != NULL) {
- ucl_elt_array_write_config (obj, func, tabs, start_tabs, is_top);
+ if (compact) {
+ func->ucl_emitter_append_character ('[', 1, func->ud);
}
else {
- switch (obj->type) {
- case UCL_INT:
- if (start_tabs) {
- ucl_add_tabs (func, tabs, false);
- }
- func->ucl_emitter_append_int (ucl_object_toint (obj), func->ud);
- break;
- case UCL_FLOAT:
- case UCL_TIME:
- if (start_tabs) {
- ucl_add_tabs (func, tabs, false);
- }
- func->ucl_emitter_append_double (ucl_object_todouble (obj), func->ud);
- break;
- case UCL_BOOLEAN:
- if (start_tabs) {
- ucl_add_tabs (func, tabs, false);
- }
- flag = ucl_object_toboolean (obj);
- if (flag) {
- func->ucl_emitter_append_len ("true", 4, func->ud);
- }
- else {
- func->ucl_emitter_append_len ("false", 5, func->ud);
- }
- break;
- case UCL_STRING:
- if (start_tabs) {
- ucl_add_tabs (func, tabs, false);
- }
- ucl_elt_string_write_json (obj->value.sv, obj->len, func);
- break;
- case UCL_NULL:
- if (start_tabs) {
- ucl_add_tabs (func, tabs, false);
- }
- func->ucl_emitter_append_len ("null", 4, func->ud);
- break;
- case UCL_OBJECT:
- ucl_elt_obj_write_config (obj, func, tabs, start_tabs, is_top);
- break;
- case UCL_ARRAY:
- ucl_elt_array_write_config (obj->value.av, func, tabs, start_tabs, is_top);
- break;
- case UCL_USERDATA:
- break;
- }
+ func->ucl_emitter_append_len ("[\n", 2, func->ud);
}
-}
-/**
- * Emit an object to rcl
- * @param obj object
- * @return rcl output (should be freed after using)
- */
-static void
-ucl_object_emit_config (const ucl_object_t *obj, struct ucl_emitter_functions *func)
-{
- ucl_elt_write_config (obj, func, 0, false, true, true);
-}
+ ctx->ident ++;
-
-static void
-ucl_obj_write_yaml (const ucl_object_t *obj, struct ucl_emitter_functions *func,
- unsigned int tabs, bool start_tabs)
-{
- bool is_array = (obj->next != NULL);
-
- if (is_array) {
- ucl_elt_array_write_yaml (obj, func, tabs, start_tabs, false);
+ if (obj->type == UCL_ARRAY) {
+ /* explicit array */
+ cur = obj->value.av;
}
else {
- ucl_elt_write_yaml (obj, func, tabs, start_tabs, false, true);
+ /* implicit array */
+ cur = obj;
+ }
+
+ while (cur) {
+ ucl_emitter_common_elt (ctx, cur, first, false, compact);
+ first = false;
+ cur = cur->next;
}
}
/**
- * Write a single object to the buffer
+ * Start emit standard UCL object
+ * @param ctx emitter context
* @param obj object to write
- * @param buf target buffer
+ * @param compact compact flag
*/
static void
-ucl_elt_obj_write_yaml (const ucl_object_t *obj, struct ucl_emitter_functions *func,
- unsigned int tabs, bool start_tabs, bool is_top)
+ucl_emitter_common_start_object (struct ucl_emitter_context *ctx,
+ const ucl_object_t *obj, bool print_key, bool compact)
{
- const ucl_object_t *cur;
ucl_hash_iter_t it = NULL;
-
- if (start_tabs) {
- ucl_add_tabs (func, tabs, is_top);
- }
- if (!is_top) {
- func->ucl_emitter_append_len ("{\n", 2, func->ud);
+ const ucl_object_t *cur, *elt;
+ const struct ucl_emitter_functions *func = ctx->func;
+ bool first = true;
+
+ ucl_emitter_print_key (print_key, ctx, obj, compact);
+ /*
+ * Print <ident_level>{
+ * <ident_level + 1><object content>
+ */
+ if (UCL_EMIT_IDENT_TOP_OBJ(ctx, obj)) {
+ if (compact) {
+ func->ucl_emitter_append_character ('{', 1, func->ud);
+ }
+ else {
+ func->ucl_emitter_append_len ("{\n", 2, func->ud);
+ }
+ ctx->ident ++;
}
while ((cur = ucl_hash_iterate (obj->value.ov, &it))) {
- ucl_add_tabs (func, tabs + 1, is_top);
- if (cur->keylen > 0) {
- ucl_elt_string_write_json (cur->key, cur->keylen, func);
+
+ if (ctx->id == UCL_EMIT_CONFIG) {
+ LL_FOREACH (cur, elt) {
+ ucl_emitter_common_elt (ctx, elt, first, true, compact);
+ }
}
else {
- func->ucl_emitter_append_len ("null", 4, func->ud);
- }
- func->ucl_emitter_append_len (": ", 2, func->ud);
- ucl_obj_write_yaml (cur, func, is_top ? tabs : tabs + 1, false);
- if (ucl_hash_iter_has_next(it)) {
- if (!is_top) {
- func->ucl_emitter_append_len (",\n", 2, func->ud);
+ /* Expand implicit arrays */
+ if (cur->next != NULL) {
+ if (!first) {
+ if (compact) {
+ func->ucl_emitter_append_character (',', 1, func->ud);
+ }
+ else {
+ func->ucl_emitter_append_len (",\n", 2, func->ud);
+ }
+ }
+ ucl_add_tabs (func, ctx->ident, compact);
+ ucl_emitter_common_start_array (ctx, cur, true, compact);
+ ucl_emitter_common_end_array (ctx, cur, compact);
}
else {
- func->ucl_emitter_append_character ('\n', 1, func->ud);
+ ucl_emitter_common_elt (ctx, cur, first, true, compact);
}
}
- else {
- func->ucl_emitter_append_character ('\n', 1, func->ud);
- }
- }
- ucl_add_tabs (func, tabs, is_top);
- if (!is_top) {
- func->ucl_emitter_append_character ('}', 1, func->ud);
+ first = false;
}
}
/**
- * Write a single array to the buffer
- * @param obj array to write
- * @param buf target buffer
+ * Common choice of object emitting
+ * @param ctx emitter context
+ * @param obj object to print
+ * @param first flag to mark the first element
+ * @param print_key print key of an object
+ * @param compact compact output
*/
static void
-ucl_elt_array_write_yaml (const ucl_object_t *obj, struct ucl_emitter_functions *func,
- unsigned int tabs, bool start_tabs, bool is_top)
+ucl_emitter_common_elt (struct ucl_emitter_context *ctx,
+ const ucl_object_t *obj, bool first, bool print_key, bool compact)
{
- const ucl_object_t *cur = obj;
-
- if (start_tabs) {
- ucl_add_tabs (func, tabs, false);
- }
+ const struct ucl_emitter_functions *func = ctx->func;
+ bool flag;
- func->ucl_emitter_append_len ("[\n", 2, func->ud);
- while (cur) {
- ucl_elt_write_yaml (cur, func, tabs + 1, true, false, false);
- func->ucl_emitter_append_len (",\n", 2, func->ud);
- cur = cur->next;
+ if (ctx->id != UCL_EMIT_CONFIG && !first) {
+ if (compact) {
+ func->ucl_emitter_append_character (',', 1, func->ud);
+ }
+ else {
+ func->ucl_emitter_append_len (",\n", 2, func->ud);
+ }
}
- ucl_add_tabs (func, tabs, false);
- func->ucl_emitter_append_character (']', 1, func->ud);
-}
-/**
- * Emit a single element
- * @param obj object
- * @param buf buffer
- */
-static void
-ucl_elt_write_yaml (const ucl_object_t *obj, struct ucl_emitter_functions *func,
- unsigned int tabs, bool start_tabs, bool is_top, bool expand_array)
-{
- bool flag;
+ ucl_add_tabs (func, ctx->ident, compact);
- if (expand_array && obj->next != NULL ) {
- ucl_elt_array_write_yaml (obj, func, tabs, start_tabs, is_top);
- }
- else {
- switch (obj->type) {
- case UCL_INT:
- if (start_tabs) {
- ucl_add_tabs (func, tabs, false);
- }
- func->ucl_emitter_append_int (ucl_object_toint (obj), func->ud);
- break;
- case UCL_FLOAT:
- case UCL_TIME:
- if (start_tabs) {
- ucl_add_tabs (func, tabs, false);
- }
- func->ucl_emitter_append_double (ucl_object_todouble (obj), func->ud);
- break;
- case UCL_BOOLEAN:
- if (start_tabs) {
- ucl_add_tabs (func, tabs, false);
- }
- flag = ucl_object_toboolean (obj);
- if (flag) {
- func->ucl_emitter_append_len ("true", 4, func->ud);
- }
- else {
- func->ucl_emitter_append_len ("false", 5, func->ud);
- }
- break;
- case UCL_STRING:
- if (start_tabs) {
- ucl_add_tabs (func, tabs, false);
- }
- ucl_elt_string_write_json (obj->value.sv, obj->len, func);
- break;
- case UCL_NULL:
- if (start_tabs) {
- ucl_add_tabs (func, tabs, false);
- }
- func->ucl_emitter_append_len ("null", 4, func->ud);
- break;
- case UCL_OBJECT:
- ucl_elt_obj_write_yaml (obj, func, tabs, start_tabs, is_top);
- break;
- case UCL_ARRAY:
- ucl_elt_array_write_yaml (obj->value.av, func, tabs, start_tabs, is_top);
- break;
- case UCL_USERDATA:
- break;
+ switch (obj->type) {
+ case UCL_INT:
+ ucl_emitter_print_key (print_key, ctx, obj, compact);
+ func->ucl_emitter_append_int (ucl_object_toint (obj), func->ud);
+ ucl_emitter_finish_object (ctx, obj, compact, !print_key);
+ break;
+ case UCL_FLOAT:
+ case UCL_TIME:
+ ucl_emitter_print_key (print_key, ctx, obj, compact);
+ func->ucl_emitter_append_double (ucl_object_todouble (obj), func->ud);
+ ucl_emitter_finish_object (ctx, obj, compact, !print_key);
+ break;
+ case UCL_BOOLEAN:
+ ucl_emitter_print_key (print_key, ctx, obj, compact);
+ flag = ucl_object_toboolean (obj);
+ if (flag) {
+ func->ucl_emitter_append_len ("true", 4, func->ud);
+ }
+ else {
+ func->ucl_emitter_append_len ("false", 5, func->ud);
}
+ ucl_emitter_finish_object (ctx, obj, compact, !print_key);
+ break;
+ case UCL_STRING:
+ ucl_emitter_print_key (print_key, ctx, obj, compact);
+ ucl_elt_string_write_json (obj->value.sv, obj->len, ctx);
+ ucl_emitter_finish_object (ctx, obj, compact, !print_key);
+ break;
+ case UCL_NULL:
+ ucl_emitter_print_key (print_key, ctx, obj, compact);
+ func->ucl_emitter_append_len ("null", 4, func->ud);
+ ucl_emitter_finish_object (ctx, obj, compact, !print_key);
+ break;
+ case UCL_OBJECT:
+ ucl_emitter_common_start_object (ctx, obj, print_key, compact);
+ ucl_emitter_common_end_object (ctx, obj, compact);
+ break;
+ case UCL_ARRAY:
+ ucl_emitter_common_start_array (ctx, obj, print_key, compact);
+ ucl_emitter_common_end_array (ctx, obj, compact);
+ break;
+ case UCL_USERDATA:
+ break;
}
}
-/**
- * Emit an object to rcl
- * @param obj object
- * @return rcl output (should be freed after using)
- */
-static void
-ucl_object_emit_yaml (const ucl_object_t *obj, struct ucl_emitter_functions *func)
-{
- ucl_elt_write_yaml (obj, func, 0, false, true, true);
-}
-
/*
- * Generic utstring output
+ * Specific standard implementations of the emitter functions
*/
-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;
-}
-
+#define UCL_EMIT_TYPE_IMPL(type, compact) \
+ static void ucl_emit_ ## type ## _elt (struct ucl_emitter_context *ctx, \
+ const ucl_object_t *obj, bool first, bool print_key) { \
+ ucl_emitter_common_elt (ctx, obj, first, print_key, (compact)); \
+ } \
+ static void ucl_emit_ ## type ## _start_obj (struct ucl_emitter_context *ctx, \
+ const ucl_object_t *obj, bool print_key) { \
+ ucl_emitter_common_start_object (ctx, obj, print_key, (compact)); \
+ } \
+ static void ucl_emit_ ## type## _start_array (struct ucl_emitter_context *ctx, \
+ const ucl_object_t *obj, bool print_key) { \
+ ucl_emitter_common_start_array (ctx, obj, print_key, (compact)); \
+ } \
+ static void ucl_emit_ ##type## _end_object (struct ucl_emitter_context *ctx, \
+ const ucl_object_t *obj) { \
+ ucl_emitter_common_end_object (ctx, obj, (compact)); \
+ } \
+ static void ucl_emit_ ##type## _end_array (struct ucl_emitter_context *ctx, \
+ const ucl_object_t *obj) { \
+ ucl_emitter_common_end_array (ctx, obj, (compact)); \
+ }
+
+UCL_EMIT_TYPE_IMPL(json, false);
+UCL_EMIT_TYPE_IMPL(json_compact, true);
+UCL_EMIT_TYPE_IMPL(config, false);
+UCL_EMIT_TYPE_IMPL(yaml, false);
unsigned char *
ucl_object_emit (const ucl_object_t *obj, enum ucl_emitter emit_type)
{
- UT_string *buf = NULL;
unsigned char *res = NULL;
- struct ucl_emitter_functions func = {
- .ucl_emitter_append_character = ucl_utstring_append_character,
- .ucl_emitter_append_len = ucl_utstring_append_len,
- .ucl_emitter_append_int = ucl_utstring_append_int,
- .ucl_emitter_append_double = ucl_utstring_append_double
- };
-
+ struct ucl_emitter_functions *func;
if (obj == NULL) {
return NULL;
}
- utstring_new (buf);
- func.ud = buf;
-
- if (buf != NULL) {
- if (emit_type == UCL_EMIT_JSON) {
- ucl_object_emit_json (obj, false, &func);
- }
- else if (emit_type == UCL_EMIT_JSON_COMPACT) {
- ucl_object_emit_json (obj, true, &func);
- }
- else if (emit_type == UCL_EMIT_YAML) {
- ucl_object_emit_yaml (obj, &func);
- }
- else {
- ucl_object_emit_config (obj, &func);
- }
+ func = ucl_object_emit_memory_funcs ((void **)&res);
- res = utstring_body (buf);
- free (buf);
+ if (func != NULL) {
+ ucl_object_emit_full (obj, emit_type, func);
+ ucl_object_emit_funcs_free (func);
}
return res;
@@ -767,71 +453,19 @@ bool
ucl_object_emit_full (const ucl_object_t *obj, enum ucl_emitter emit_type,
struct ucl_emitter_functions *emitter)
{
- if (emit_type == UCL_EMIT_JSON) {
- ucl_object_emit_json (obj, false, emitter);
- }
- else if (emit_type == UCL_EMIT_JSON_COMPACT) {
- ucl_object_emit_json (obj, true, emitter);
- }
- else if (emit_type == UCL_EMIT_YAML) {
- ucl_object_emit_yaml (obj, emitter);
- }
- else {
- ucl_object_emit_config (obj, emitter);
- }
-
- /* XXX: need some error checks here */
- return true;
-}
-
-
-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);
+ const struct ucl_emitter_context *ctx;
+ struct ucl_emitter_context my_ctx;
+ bool res = false;
+
+ ctx = ucl_emit_get_standard_context (emit_type);
+ if (ctx != NULL) {
+ memcpy (&my_ctx, ctx, sizeof (my_ctx));
+ my_ctx.func = emitter;
+ my_ctx.ident = 0;
+ my_ctx.top = obj;
+
+ my_ctx.ops->ucl_emitter_write_elt (&my_ctx, obj, true, false);
+ res = true;
}
return res;
diff --git a/src/ucl_emitter_streamline.c b/src/ucl_emitter_streamline.c
new file mode 100644
index 000000000000..acf4a305a46e
--- /dev/null
+++ b/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);
+}
diff --git a/src/ucl_emitter_utils.c b/src/ucl_emitter_utils.c
new file mode 100644
index 000000000000..c619ab9df15e
--- /dev/null
+++ b/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;
+}
diff --git a/src/ucl_internal.h b/src/ucl_internal.h
index 0e3ecd012cc7..0ac8de84c2ed 100644
--- a/src/ucl_internal.h
+++ b/src/ucl_internal.h
@@ -343,6 +343,22 @@ ucl_hash_insert_object (ucl_hash_t *hashlin, const ucl_object_t *obj)
}
/**
+ * 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
* @return
diff --git a/src/ucl_parser.c b/src/ucl_parser.c
index b4fe5afc8246..87685744716e 100644
--- a/src/ucl_parser.c
+++ b/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);
- d += 2;
- ret --;
+ if (strict) {
+ /* Copy '${' */
+ memcpy (d, ptr, 2);
+ d += 2;
+ ret --;
+ }
+ else {
+ memcpy (d, ptr, 1);
+ d ++;
+ }
}
}
diff --git a/tests/Makefile.am b/tests/Makefile.am
index 880036d900f5..a21a65c16534 100644
--- a/tests/Makefile.am
+++ b/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 \ No newline at end of file
+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 \ No newline at end of file
diff --git a/tests/streamline.res b/tests/streamline.res
new file mode 100644
index 000000000000..5eb18d7c2737
--- /dev/null
+++ b/tests/streamline.res
@@ -0,0 +1,8 @@
+key1 = "test string";
+key2 = "test \\nstring";
+key3 = " test string \n";
+key4 [
+ 10,
+ 10.100000,
+ 9.999000,
+]
diff --git a/tests/streamline.test b/tests/streamline.test
new file mode 100755
index 000000000000..dbe583622fca
--- /dev/null
+++ b/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 \ No newline at end of file
diff --git a/tests/test_basic.c b/tests/test_basic.c
index 5a977aa7191a..b4ed7788dce4 100644
--- a/tests/test_basic.c
+++ b/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);
diff --git a/tests/test_streamline.c b/tests/test_streamline.c
new file mode 100644
index 000000000000..4c56c4cdcffd
--- /dev/null
+++ b/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;
+}
diff --git a/uthash/utstring.h b/uthash/utstring.h
index 4ef7b5690dc6..f11f34b77e75 100644
--- a/uthash/utstring.h
+++ b/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)
generated by cgit v1.2.3 (git 2.25.1) at 2024-05-14 03:57:37 +0000