svn commit: r268831 - in head: contrib/libucl contrib/libucl/doc contrib/libucl/include contrib/libucl/src contrib/libucl/tests contrib/libucl/uthash lib/libucl
Baptiste Daroussin
bapt at FreeBSD.org
Fri Jul 18 06:58:03 UTC 2014
Author: bapt
Date: Fri Jul 18 06:58:01 2014
New Revision: 268831
URL: http://svnweb.freebsd.org/changeset/base/268831
Log:
Update libucl to the 2014-07-16 snapshot
This update brings streamlined ucl emitter support
Added:
head/contrib/libucl/ChangeLog.md
- copied unchanged from r268829, vendor/libucl/dist/ChangeLog.md
head/contrib/libucl/src/ucl_emitter_streamline.c
- copied unchanged from r268829, vendor/libucl/dist/src/ucl_emitter_streamline.c
head/contrib/libucl/src/ucl_emitter_utils.c
- copied unchanged from r268829, vendor/libucl/dist/src/ucl_emitter_utils.c
head/contrib/libucl/tests/streamline.res
- copied unchanged from r268829, vendor/libucl/dist/tests/streamline.res
head/contrib/libucl/tests/streamline.test
- copied unchanged from r268829, vendor/libucl/dist/tests/streamline.test
head/contrib/libucl/tests/test_streamline.c
- copied unchanged from r268829, vendor/libucl/dist/tests/test_streamline.c
Modified:
head/contrib/libucl/configure.ac
head/contrib/libucl/doc/api.md
head/contrib/libucl/doc/libucl.3
head/contrib/libucl/doc/pandoc.template
head/contrib/libucl/include/ucl.h
head/contrib/libucl/src/Makefile.am
head/contrib/libucl/src/ucl_emitter.c
head/contrib/libucl/src/ucl_internal.h
head/contrib/libucl/src/ucl_parser.c
head/contrib/libucl/tests/Makefile.am
head/contrib/libucl/tests/test_basic.c
head/contrib/libucl/uthash/utstring.h
head/lib/libucl/Makefile
Directory Properties:
head/contrib/libucl/ (props changed)
Copied: head/contrib/libucl/ChangeLog.md (from r268829, vendor/libucl/dist/ChangeLog.md)
==============================================================================
--- /dev/null 00:00:00 1970 (empty, because file is newly added)
+++ head/contrib/libucl/ChangeLog.md Fri Jul 18 06:58:01 2014 (r268831, copy of r268829, vendor/libucl/dist/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
Modified: head/contrib/libucl/configure.ac
==============================================================================
--- head/contrib/libucl/configure.ac Fri Jul 18 06:56:24 2014 (r268830)
+++ head/contrib/libucl/configure.ac Fri Jul 18 06:58:01 2014 (r268831)
@@ -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])
Modified: head/contrib/libucl/doc/api.md
==============================================================================
--- head/contrib/libucl/doc/api.md Fri Jul 18 06:56:24 2014 (r268830)
+++ head/contrib/libucl/doc/api.md Fri Jul 18 06:58:01 2014 (r268831)
@@ -52,15 +52,15 @@ Used to parse `ucl` files and provide in
### 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_par
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 nu
- 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
# 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 functio
- `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
- `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_com
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 (
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 t
ype 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_obje
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).
Modified: head/contrib/libucl/doc/libucl.3
==============================================================================
--- head/contrib/libucl/doc/libucl.3 Fri Jul 18 06:56:24 2014 (r268830)
+++ head/contrib/libucl/doc/libucl.3 Fri Jul 18 06:58:01 2014 (r268831)
@@ -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 remove
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
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_
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,\
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 exampl
.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 functio
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_c
.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
\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 ch
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[] t
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 follow
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
Modified: head/contrib/libucl/doc/pandoc.template
==============================================================================
--- head/contrib/libucl/doc/pandoc.template Fri Jul 18 06:56:24 2014 (r268830)
+++ head/contrib/libucl/doc/pandoc.template Fri Jul 18 06:58:01 2014 (r268831)
@@ -1,6 +1,6 @@
-% LIBUCL(5) Libucl manual
+% LIBUCL(3) Libucl manual
% Vsevolod Stakhov <vsevolod at highsecure.ru>
-% March 20, 2014
+% July 26, 2014
# Name
Modified: head/contrib/libucl/include/ucl.h
==============================================================================
--- head/contrib/libucl/include/ucl.h Fri Jul 18 06:56:24 2014 (r268830)
+++ head/contrib/libucl/include/ucl.h Fri Jul 18 06:58:01 2014 (r268831)
@@ -786,6 +786,7 @@ UCL_EXTERN bool ucl_parser_set_filevars
* @{
*/
+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_emi
* @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);
+
/** @} */
/**
Modified: head/contrib/libucl/src/Makefile.am
==============================================================================
--- head/contrib/libucl/src/Makefile.am Fri Jul 18 06:56:24 2014 (r268830)
+++ head/contrib/libucl/src/Makefile.am Fri Jul 18 06:58:01 2014 (r268831)
@@ -4,6 +4,8 @@ libucl_common_cflags= -I$(top_srcdir)/sr
-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 \
Modified: head/contrib/libucl/src/ucl_emitter.c
==============================================================================
--- head/contrib/libucl/src/ucl_emitter.c Fri Jul 18 06:56:24 2014 (r268830)
+++ head/contrib/libucl/src/ucl_emitter.c Fri Jul 18 06:58:01 2014 (r268831)
@@ -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 (co
* @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;
+ const struct ucl_emitter_functions *func = ctx->func;
- 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;
+ 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;
*** DIFF OUTPUT TRUNCATED AT 1000 LINES ***
More information about the svn-src-head
mailing list