d/freebsd-dev
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Update libucl to the 2014-07-16 snapshot

Browse Source 
This update brings streamlined ucl emitter support
This commit is contained in:
Baptiste Daroussin 2014-07-18 06:58:01 +00:00
commit 3dcf5eb705
Notes: svn2git 2020-12-20 02:59:44 +00:00 
svn path=/head/; revision=268831
19 changed files with 1280 additions and 729 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
contrib/libucl/ChangeLog.md Normal file
View File

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

6
contrib/libucl/configure.ac
View File

@ -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])

34
contrib/libucl/doc/api.md
View File

@ -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).
`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).

51
contrib/libucl/doc/libucl.3
View File

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

4
contrib/libucl/doc/pandoc.template
View File

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

110
contrib/libucl/include/ucl.h
View File

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

2
contrib/libucl/src/Makefile.am
View File

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

974
contrib/libucl/src/ucl_emitter.c
View File

File diff suppressed because it is too large Load Diff

166
contrib/libucl/src/ucl_emitter_streamline.c Normal file
View File

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

466
contrib/libucl/src/ucl_emitter_utils.c Normal file
View File

@ -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;
}

16
contrib/libucl/src/ucl_internal.h
View File

@ -342,6 +342,22 @@ ucl_hash_insert_object (ucl_hash_t *hashlin, const ucl_object_t *obj)
return hashlin;
}
/**
* Get standard emitter context for a specified emit_type
* @param emit_type type of emitter
* @return context or NULL if input is invalid
*/
const struct ucl_emitter_context *
ucl_emit_get_standard_context (enum ucl_emitter emit_type);
/**
* Serialise string
* @param str string to emit
* @param buf target buffer
*/
void ucl_elt_string_write_json (const char *str, size_t size,
struct ucl_emitter_context *ctx);
/**
* Emit a single object to string
* @param obj

13
contrib/libucl/src/ucl_parser.c
View File

@ -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 ++;
}
}
}

9
contrib/libucl/tests/Makefile.am
View File

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

8
contrib/libucl/tests/streamline.res Normal file
View File

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

12
contrib/libucl/tests/streamline.test Executable file
View File

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

32
contrib/libucl/tests/test_basic.c
View File

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

92
contrib/libucl/tests/test_streamline.c Normal file
View File

@ -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;
}

4
contrib/libucl/uthash/utstring.h
View File

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

4
lib/libucl/Makefile
View File

@ -5,7 +5,9 @@ LIBUCL= ${.CURDIR}/../../contrib/libucl
LIB= ucl
PRIVATELIB= true
SHLIB_MAJOR= 1
SRCS= ucl_emitter.c \
SRCS= ucl_emitter_streamline.c \
ucl_emitter_utils.c \
ucl_emitter.c \
ucl_hash.c \
ucl_parser.c \
ucl_schema.c \