* @param len
* @return new position in chunk
*/
-#define ucl_chunk_skipc(chunk, p) \
-do { \
- if (p == chunk->end) { \
- break; \
- } \
- if (*(p) == '\n') { \
- (chunk)->line ++; \
- (chunk)->column = 0; \
- } \
- else (chunk)->column ++; \
- (p++); \
- (chunk)->pos ++; \
- (chunk)->remain --; \
-} while (0)
+#define ucl_chunk_skipc(chunk, p) \
+ do { \
+ if (p == chunk->end) { \
+ break; \
+ } \
+ if (*(p) == '\n') { \
+ (chunk)->line++; \
+ (chunk)->column = 0; \
+ } \
+ else \
+ (chunk)->column++; \
+ (p++); \
+ (chunk)->pos++; \
+ (chunk)->remain--; \
+ } while (0)
static inline void
-ucl_set_err (struct ucl_parser *parser, int code, const char *str, UT_string **err)
+ucl_set_err(struct ucl_parser *parser, int code, const char *str, UT_string **err)
{
const char *fmt_string, *filename;
struct ucl_chunk *chunk = parser->chunks;
}
if (chunk->pos < chunk->end) {
- if (isgraph (*chunk->pos)) {
+ if (isgraph(*chunk->pos)) {
fmt_string = "error while parsing %s: "
- "line: %d, column: %d - '%s', character: '%c'";
+ "line: %d, column: %d - '%s', character: '%c'";
}
else {
fmt_string = "error while parsing %s: "
- "line: %d, column: %d - '%s', character: '0x%02x'";
+ "line: %d, column: %d - '%s', character: '0x%02x'";
}
- ucl_create_err (err, fmt_string,
- filename, chunk->line, chunk->column,
- str, *chunk->pos);
+ ucl_create_err(err, fmt_string,
+ filename, chunk->line, chunk->column,
+ str, *chunk->pos);
}
else {
- ucl_create_err (err, "error while parsing %s: at the end of chunk: %s",
- filename, str);
+ ucl_create_err(err, "error while parsing %s: at the end of chunk: %s",
+ filename, str);
}
parser->err_code = code;
}
static void
-ucl_save_comment (struct ucl_parser *parser, const char *begin, size_t len)
+ucl_save_comment(struct ucl_parser *parser, const char *begin, size_t len)
{
ucl_object_t *nobj;
if (len > 0 && begin != NULL) {
- nobj = ucl_object_fromstring_common (begin, len, 0);
+ nobj = ucl_object_fromstring_common(begin, len, 0);
if (parser->last_comment) {
/* We need to append data to an existing object */
- DL_APPEND (parser->last_comment, nobj);
+ DL_APPEND(parser->last_comment, nobj);
}
else {
parser->last_comment = nobj;
}
static void
-ucl_attach_comment (struct ucl_parser *parser, ucl_object_t *obj, bool before)
+ucl_attach_comment(struct ucl_parser *parser, ucl_object_t *obj, bool before)
{
if (parser->last_comment) {
- ucl_object_insert_key (parser->comments, parser->last_comment,
- (const char *)&obj, sizeof (void *), true);
+ ucl_object_insert_key(parser->comments, parser->last_comment,
+ (const char *) &obj, sizeof(void *), true);
if (before) {
parser->last_comment->flags |= UCL_OBJECT_INHERITED;
* @return
*/
static bool
-ucl_skip_comments (struct ucl_parser *parser)
+ucl_skip_comments(struct ucl_parser *parser)
{
struct ucl_chunk *chunk = parser->chunks;
const unsigned char *p, *beg = NULL;
start:
if (chunk->remain > 0 && *p == '#') {
if (parser->state != UCL_STATE_SCOMMENT &&
- parser->state != UCL_STATE_MCOMMENT) {
+ parser->state != UCL_STATE_MCOMMENT) {
beg = p;
while (p < chunk->end) {
if (*p == '\n') {
if (parser->flags & UCL_PARSER_SAVE_COMMENTS) {
- ucl_save_comment (parser, beg, p - beg);
+ ucl_save_comment(parser, beg, p - beg);
beg = NULL;
}
- ucl_chunk_skipc (chunk, p);
+ ucl_chunk_skipc(chunk, p);
goto start;
}
- ucl_chunk_skipc (chunk, p);
+ ucl_chunk_skipc(chunk, p);
}
}
}
else if (chunk->remain >= 2 && *p == '/') {
if (p[1] == '*') {
beg = p;
- ucl_chunk_skipc (chunk, p);
- comments_nested ++;
- ucl_chunk_skipc (chunk, p);
+ ucl_chunk_skipc(chunk, p);
+ comments_nested++;
+ ucl_chunk_skipc(chunk, p);
while (p < chunk->end) {
if (*p == '"' && *(p - 1) != '\\') {
if (!quoted) {
if (*p == '*') {
- ucl_chunk_skipc (chunk, p);
+ ucl_chunk_skipc(chunk, p);
if (chunk->remain > 0 && *p == '/') {
- comments_nested --;
+ comments_nested--;
if (comments_nested == 0) {
if (parser->flags & UCL_PARSER_SAVE_COMMENTS) {
- ucl_save_comment (parser, beg, p - beg + 1);
+ ucl_save_comment(parser, beg, p - beg + 1);
beg = NULL;
}
- ucl_chunk_skipc (chunk, p);
+ ucl_chunk_skipc(chunk, p);
goto start;
}
}
- ucl_chunk_skipc (chunk, p);
+ ucl_chunk_skipc(chunk, p);
}
else if (p[0] == '/' && chunk->remain >= 2 && p[1] == '*') {
- comments_nested ++;
- ucl_chunk_skipc (chunk, p);
- ucl_chunk_skipc (chunk, p);
+ comments_nested++;
+ ucl_chunk_skipc(chunk, p);
+ ucl_chunk_skipc(chunk, p);
continue;
}
}
- ucl_chunk_skipc (chunk, p);
+ ucl_chunk_skipc(chunk, p);
}
if (comments_nested != 0) {
- ucl_set_err (parser, UCL_ENESTED,
- "unfinished multiline comment", &parser->err);
+ ucl_set_err(parser, UCL_ENESTED,
+ "unfinished multiline comment", &parser->err);
return false;
}
}
}
if (beg && p > beg && (parser->flags & UCL_PARSER_SAVE_COMMENTS)) {
- ucl_save_comment (parser, beg, p - beg);
+ ucl_save_comment(parser, beg, p - beg);
}
return true;
* @return multiplier
*/
static inline unsigned long
-ucl_lex_num_multiplier (const unsigned char c, bool is_bytes) {
+ucl_lex_num_multiplier(const unsigned char c, bool is_bytes)
+{
const struct {
char c;
long mult_normal;
long mult_bytes;
} multipliers[] = {
- {'m', 1000 * 1000, 1024 * 1024},
- {'k', 1000, 1024},
- {'g', 1000 * 1000 * 1000, 1024 * 1024 * 1024}
- };
+ {'m', 1000 * 1000, 1024 * 1024},
+ {'k', 1000, 1024},
+ {'g', 1000 * 1000 * 1000, 1024 * 1024 * 1024}};
int i;
- for (i = 0; i < 3; i ++) {
- if (tolower (c) == multipliers[i].c) {
+ for (i = 0; i < 3; i++) {
+ if (tolower(c) == multipliers[i].c) {
if (is_bytes) {
return multipliers[i].mult_bytes;
}
* @return
*/
static inline double
-ucl_lex_time_multiplier (const unsigned char c) {
+ucl_lex_time_multiplier(const unsigned char c)
+{
const struct {
char c;
double mult;
} multipliers[] = {
- {'m', 60},
- {'h', 60 * 60},
- {'d', 60 * 60 * 24},
- {'w', 60 * 60 * 24 * 7},
- {'y', 60 * 60 * 24 * 365}
- };
+ {'m', 60},
+ {'h', 60 * 60},
+ {'d', 60 * 60 * 24},
+ {'w', 60 * 60 * 24 * 7},
+ {'y', 60 * 60 * 24 * 365}};
int i;
- for (i = 0; i < 5; i ++) {
- if (tolower (c) == multipliers[i].c) {
+ for (i = 0; i < 5; i++) {
+ if (tolower(c) == multipliers[i].c) {
return multipliers[i].mult;
}
}
* @return
*/
static inline bool
-ucl_lex_is_atom_end (const unsigned char c)
+ucl_lex_is_atom_end(const unsigned char c)
{
- return ucl_test_character (c, UCL_CHARACTER_VALUE_END);
+ return ucl_test_character(c, UCL_CHARACTER_VALUE_END);
}
static inline bool
-ucl_lex_is_comment (const unsigned char c1, const unsigned char c2)
+ucl_lex_is_comment(const unsigned char c1, const unsigned char c2)
{
if (c1 == '/') {
if (c2 == '*') {
* @return
*/
static inline const char *
-ucl_check_variable_safe (struct ucl_parser *parser, const char *ptr, size_t remain,
- size_t *out_len, bool strict, bool *found)
+ucl_check_variable_safe(struct ucl_parser *parser, const char *ptr, size_t remain,
+ size_t *out_len, bool strict, bool *found)
{
struct ucl_variable *var;
unsigned char *dst;
size_t dstlen;
bool need_free = false;
- LL_FOREACH (parser->variables, var) {
+ LL_FOREACH(parser->variables, var)
+ {
if (strict) {
if (remain == var->var_len) {
- if (memcmp (ptr, var->var, var->var_len) == 0) {
+ if (memcmp(ptr, var->var, var->var_len) == 0) {
*out_len += var->value_len;
*found = true;
return (ptr + var->var_len);
}
else {
if (remain >= var->var_len) {
- if (memcmp (ptr, var->var, var->var_len) == 0) {
+ if (memcmp(ptr, var->var, var->var_len) == 0) {
*out_len += var->value_len;
*found = true;
return (ptr + var->var_len);
/* XXX: can only handle ${VAR} */
if (!(*found) && parser->var_handler != NULL && strict) {
/* Call generic handler */
- if (parser->var_handler (ptr, remain, &dst, &dstlen, &need_free,
- parser->var_data)) {
+ if (parser->var_handler(ptr, remain, &dst, &dstlen, &need_free,
+ parser->var_data)) {
*found = true;
*out_len = dstlen;
if (need_free) {
- free (dst);
+ free(dst);
}
return (ptr + remain);
}
* @return
*/
static const char *
-ucl_check_variable (struct ucl_parser *parser, const char *ptr,
- size_t remain, size_t *out_len, bool *vars_found)
+ucl_check_variable(struct ucl_parser *parser, const char *ptr,
+ size_t remain, size_t *out_len, bool *vars_found)
{
const char *p, *end, *ret = ptr;
bool found = false;
end = ptr + remain;
while (p < end) {
if (*p == '}') {
- ret = ucl_check_variable_safe (parser, ptr + 1, p - ptr - 1,
- out_len, true, &found);
+ ret = ucl_check_variable_safe(parser, ptr + 1, p - ptr - 1,
+ out_len, true, &found);
if (found) {
/* {} must be excluded actually */
- ret ++;
+ ret++;
if (!*vars_found) {
*vars_found = true;
}
}
break;
}
- p ++;
+ p++;
}
- if(p == end) {
- (*out_len) ++;
+ if (p == end) {
+ (*out_len)++;
}
}
else if (*ptr != '$') {
/* Not count escaped dollar sign */
- ret = ucl_check_variable_safe (parser, ptr, remain, out_len, false, &found);
+ ret = ucl_check_variable_safe(parser, ptr, remain, out_len, false, &found);
if (found && !*vars_found) {
*vars_found = true;
}
if (!found) {
- (*out_len) ++;
+ (*out_len)++;
}
}
else {
- ret ++;
- (*out_len) ++;
+ ret++;
+ (*out_len)++;
}
return ret;
* @return
*/
static const char *
-ucl_expand_single_variable (struct ucl_parser *parser, const char *ptr,
- size_t in_len, unsigned char **dest, size_t out_len)
+ucl_expand_single_variable(struct ucl_parser *parser, const char *ptr,
+ size_t in_len, unsigned char **dest, size_t out_len)
{
unsigned char *d = *dest, *dst;
const char *p = ptr + 1, *ret;
ret = ptr + 1;
/* For the $ sign */
- in_len --;
+ in_len--;
if (*p == '$') {
*d++ = *p++;
return p;
}
else if (*p == '{') {
- p ++;
- in_len --;
+ p++;
+ in_len--;
strict = true;
ret += 2;
}
- LL_FOREACH (parser->variables, var) {
+ LL_FOREACH(parser->variables, var)
+ {
if (out_len >= var->value_len && in_len >= (var->var_len + (strict ? 1 : 0))) {
- if (memcmp (p, var->var, var->var_len) == 0) {
+ if (memcmp(p, var->var, var->var_len) == 0) {
if (!strict || p[var->var_len] == '}') {
- memcpy (d, var->value, var->value_len);
+ memcpy(d, var->value, var->value_len);
ret += var->var_len;
d += var->value_len;
found = true;
if (strict && parser->var_handler != NULL) {
dstlen = out_len;
- if (parser->var_handler (p, in_len, &dst, &dstlen, &need_free,
- parser->var_data)) {
+ if (parser->var_handler(p, in_len, &dst, &dstlen, &need_free,
+ parser->var_data)) {
if (dstlen > out_len) {
/* We do not have enough space! */
if (need_free) {
- free (dst);
+ free(dst);
}
}
else {
if (!found) {
if (strict && out_len >= 2) {
/* Copy '${' */
- memcpy (d, ptr, 2);
+ memcpy(d, ptr, 2);
d += 2;
- ret --;
+ ret--;
}
else {
- memcpy (d, ptr, 1);
- d ++;
+ memcpy(d, ptr, 1);
+ d++;
}
}
}
* @return
*/
static ssize_t
-ucl_expand_variable (struct ucl_parser *parser, unsigned char **dst,
- const char *src, size_t in_len)
+ucl_expand_variable(struct ucl_parser *parser, unsigned char **dst,
+ const char *src, size_t in_len)
{
const char *p, *end = src + in_len;
unsigned char *d, *d_end;
p = src;
while (p != end) {
if (*p == '$' && p + 1 != end) {
- p = ucl_check_variable (parser, p + 1, end - p - 1, &out_len, &vars_found);
+ p = ucl_check_variable(parser, p + 1, end - p - 1, &out_len, &vars_found);
}
else {
- p ++;
- out_len ++;
+ p++;
+ out_len++;
}
}
return in_len;
}
- *dst = UCL_ALLOC (out_len + 1);
+ *dst = UCL_ALLOC(out_len + 1);
if (*dst == NULL) {
return in_len;
}
p = src;
while (p != end && d != d_end) {
if (*p == '$' && p + 1 != end) {
- p = ucl_expand_single_variable (parser, p, end - p, &d, d_end - d);
+ p = ucl_expand_single_variable(parser, p, end - p, &d, d_end - d);
}
else {
*d++ = *p++;
* @return output length (excluding \0 symbol)
*/
static inline ssize_t
-ucl_copy_or_store_ptr (struct ucl_parser *parser,
- const unsigned char *src, unsigned char **dst,
- const char **dst_const, size_t in_len,
- bool need_unescape, bool need_lowercase, bool need_expand,
- bool unescape_squote)
+ucl_copy_or_store_ptr(struct ucl_parser *parser,
+ const unsigned char *src, unsigned char **dst,
+ const char **dst_const, size_t in_len,
+ bool need_unescape, bool need_lowercase, bool need_expand,
+ bool unescape_squote)
{
ssize_t ret = -1, tret;
unsigned char *tmp;
if (need_unescape || need_lowercase ||
- (need_expand && parser->variables != NULL) ||
- !(parser->flags & UCL_PARSER_ZEROCOPY)) {
+ (need_expand && parser->variables != NULL) ||
+ !(parser->flags & UCL_PARSER_ZEROCOPY)) {
/* Copy string */
- *dst = UCL_ALLOC (in_len + 1);
+ *dst = UCL_ALLOC(in_len + 1);
if (*dst == NULL) {
- ucl_set_err (parser, UCL_EINTERNAL, "cannot allocate memory for a string",
- &parser->err);
+ ucl_set_err(parser, UCL_EINTERNAL, "cannot allocate memory for a string",
+ &parser->err);
return false;
}
if (need_lowercase) {
- ret = ucl_strlcpy_tolower (*dst, src, in_len + 1);
+ ret = ucl_strlcpy_tolower(*dst, src, in_len + 1);
}
else {
- ret = ucl_strlcpy_unsafe (*dst, src, in_len + 1);
+ ret = ucl_strlcpy_unsafe(*dst, src, in_len + 1);
}
if (need_unescape) {
if (!unescape_squote) {
- ret = ucl_unescape_json_string (*dst, ret);
+ ret = ucl_unescape_json_string(*dst, ret);
}
else {
- ret = ucl_unescape_squoted_string (*dst, ret);
+ ret = ucl_unescape_squoted_string(*dst, ret);
}
}
if (need_expand) {
tmp = *dst;
tret = ret;
- ret = ucl_expand_variable (parser, dst, tmp, ret);
+ ret = ucl_expand_variable(parser, dst, tmp, ret);
if (*dst == NULL) {
/* Nothing to expand */
*dst = tmp;
}
else {
/* Free unexpanded value */
- UCL_FREE (in_len + 1, tmp);
+ UCL_FREE(in_len + 1, tmp);
}
}
*dst_const = *dst;
* @return
*/
static inline ucl_object_t *
-ucl_parser_add_container (ucl_object_t *obj, struct ucl_parser *parser,
- bool is_array, uint32_t level, bool has_obrace)
+ucl_parser_add_container(ucl_object_t *obj, struct ucl_parser *parser,
+ bool is_array, uint32_t level, bool has_obrace)
{
struct ucl_stack *st;
ucl_object_t *nobj;
if (obj == NULL) {
- nobj = ucl_object_new_full (is_array ? UCL_ARRAY : UCL_OBJECT, parser->chunks->priority);
+ nobj = ucl_object_new_full(is_array ? UCL_ARRAY : UCL_OBJECT, parser->chunks->priority);
if (nobj == NULL) {
goto enomem0;
}
- } else {
+ }
+ else {
if (obj->type == (is_array ? UCL_OBJECT : UCL_ARRAY)) {
/* Bad combination for merge: array and object */
- ucl_set_err (parser, UCL_EMERGE,
- "cannot merge an object with an array",
- &parser->err);
+ ucl_set_err(parser, UCL_EMERGE,
+ "cannot merge an object with an array",
+ &parser->err);
return NULL;
}
if (!is_array) {
if (nobj->value.ov == NULL) {
- nobj->value.ov = ucl_hash_create (parser->flags & UCL_PARSER_KEY_LOWERCASE);
+ nobj->value.ov = ucl_hash_create(parser->flags & UCL_PARSER_KEY_LOWERCASE);
if (nobj->value.ov == NULL) {
goto enomem1;
}
}
parser->state = UCL_STATE_KEY;
- } else {
+ }
+ else {
parser->state = UCL_STATE_VALUE;
}
- st = UCL_ALLOC (sizeof (struct ucl_stack));
+ st = UCL_ALLOC(sizeof(struct ucl_stack));
if (st == NULL) {
goto enomem1;
st->obj = nobj;
if (level >= UINT16_MAX) {
- ucl_set_err (parser, UCL_ENESTED,
- "objects are nesting too deep (over 65535 limit)",
- &parser->err);
+ ucl_set_err(parser, UCL_ENESTED,
+ "objects are nesting too deep (over 65535 limit)",
+ &parser->err);
if (nobj != obj) {
- ucl_object_unref (obj);
+ ucl_object_unref(obj);
}
- UCL_FREE(sizeof (struct ucl_stack), st);
+ UCL_FREE(sizeof(struct ucl_stack), st);
return NULL;
}
st->e.params.flags = 0;
}
- LL_PREPEND (parser->stack, st);
+ LL_PREPEND(parser->stack, st);
parser->cur_obj = nobj;
return nobj;
enomem1:
if (nobj != obj)
- ucl_object_unref (nobj);
+ ucl_object_unref(nobj);
enomem0:
- ucl_set_err (parser, UCL_EINTERNAL, "cannot allocate memory for an object",
- &parser->err);
+ ucl_set_err(parser, UCL_EINTERNAL, "cannot allocate memory for an object",
+ &parser->err);
return NULL;
}
-int
-ucl_maybe_parse_number (ucl_object_t *obj,
- const char *start, const char *end, const char **pos,
- bool allow_double, bool number_bytes, bool allow_time)
+int ucl_maybe_parse_number(ucl_object_t *obj,
+ const char *start, const char *end, const char **pos,
+ bool allow_double, bool number_bytes, bool allow_time)
{
const char *p = start, *c = start;
char *endptr;
bool got_dot = false, got_exp = false, need_double = false,
- is_time = false, valid_start = false, is_hex = false;
+ is_time = false, valid_start = false, is_hex = false;
int is_neg = 0;
double dv = 0;
int64_t lv = 0;
if (*p == '-') {
is_neg = 1;
- c ++;
- p ++;
+ c++;
+ p++;
}
while (p < end) {
- if (is_hex && isxdigit (*p)) {
- p ++;
+ if (is_hex && isxdigit(*p)) {
+ p++;
}
- else if (isdigit (*p)) {
+ else if (isdigit(*p)) {
valid_start = true;
- p ++;
+ p++;
}
else if (!is_hex && (*p == 'x' || *p == 'X')) {
is_hex = true;
allow_double = false;
c = p + 1;
- p ++;
+ p++;
}
else if (allow_double) {
if (p == c) {
else {
got_dot = true;
need_double = true;
- p ++;
+ p++;
}
}
else if (*p == 'e' || *p == 'E') {
else {
got_exp = true;
need_double = true;
- p ++;
+ p++;
if (p >= end) {
*pos = start;
return EINVAL;
}
- if (!isdigit (*p) && *p != '+' && *p != '-') {
+ if (!isdigit(*p) && *p != '+' && *p != '-') {
/* Wrong exponent sign */
*pos = start;
return EINVAL;
}
else {
- p ++;
+ p++;
}
}
}
char numbuf[128];
- if ((size_t)(p - c + 1) >= sizeof(numbuf)) {
+ if ((size_t) (p - c + 1) >= sizeof(numbuf)) {
*pos = start;
return EINVAL;
}
if (is_neg) {
numbuf[0] = '-';
- ucl_strlcpy (&numbuf[1], c, p - c + 1);
+ ucl_strlcpy(&numbuf[1], c, p - c + 1);
}
else {
- ucl_strlcpy (numbuf, c, p - c + 1);
+ ucl_strlcpy(numbuf, c, p - c + 1);
}
errno = 0;
if (need_double) {
- dv = strtod (numbuf, &endptr);
+ dv = strtod(numbuf, &endptr);
}
else {
if (is_hex) {
- lv = strtoimax (numbuf, &endptr, 16);
+ lv = strtoimax(numbuf, &endptr, 16);
}
else {
- lv = strtoimax (numbuf, &endptr, 10);
+ lv = strtoimax(numbuf, &endptr, 10);
}
}
if (errno == ERANGE) {
/* Now check endptr and move it from numbuf to the real ending */
if (endptr != NULL) {
long shift = endptr - numbuf - is_neg;
- endptr = (char *)c + shift;
+ endptr = (char *) c + shift;
}
if (endptr >= end) {
p = end;
goto set_obj;
}
- if (endptr == NULL || ucl_lex_is_atom_end (*endptr) || *endptr == '\0') {
+ if (endptr == NULL || ucl_lex_is_atom_end(*endptr) || *endptr == '\0') {
p = endptr;
goto set_obj;
}
dv /= 1000.;
}
else {
- dv *= ucl_lex_num_multiplier (*p, false);
+ dv *= ucl_lex_num_multiplier(*p, false);
}
p += 2;
- if (end - p > 0 && !ucl_lex_is_atom_end (*p)) {
+ if (end - p > 0 && !ucl_lex_is_atom_end(*p)) {
*pos = start;
return EINVAL;
}
need_double = false;
lv = dv;
}
- lv *= ucl_lex_num_multiplier (*p, true);
+ lv *= ucl_lex_num_multiplier(*p, true);
p += 2;
- if (end - p > 0 && !ucl_lex_is_atom_end (*p)) {
+ if (end - p > 0 && !ucl_lex_is_atom_end(*p)) {
*pos = start;
return EINVAL;
}
goto set_obj;
}
- else if (ucl_lex_is_atom_end (p[1])) {
+ else if (ucl_lex_is_atom_end(p[1])) {
if (need_double) {
- dv *= ucl_lex_num_multiplier (*p, false);
+ dv *= ucl_lex_num_multiplier(*p, false);
}
else {
- lv *= ucl_lex_num_multiplier (*p, number_bytes);
+ lv *= ucl_lex_num_multiplier(*p, number_bytes);
}
- p ++;
+ p++;
goto set_obj;
}
else if (allow_time && end - p >= 3) {
- if (tolower (p[0]) == 'm' &&
- tolower (p[1]) == 'i' &&
- tolower (p[2]) == 'n') {
+ if (tolower(p[0]) == 'm' &&
+ tolower(p[1]) == 'i' &&
+ tolower(p[2]) == 'n') {
/* Minutes */
if (!need_double) {
need_double = true;
is_time = true;
dv *= 60.;
p += 3;
- if (end - p > 0 && !ucl_lex_is_atom_end (*p)) {
+ if (end - p > 0 && !ucl_lex_is_atom_end(*p)) {
*pos = start;
return EINVAL;
}
}
else {
if (need_double) {
- dv *= ucl_lex_num_multiplier (*p, false);
+ dv *= ucl_lex_num_multiplier(*p, false);
}
else {
- lv *= ucl_lex_num_multiplier (*p, number_bytes);
+ lv *= ucl_lex_num_multiplier(*p, number_bytes);
}
- p ++;
- if (end - p > 0 && !ucl_lex_is_atom_end (*p)) {
+ p++;
+ if (end - p > 0 && !ucl_lex_is_atom_end(*p)) {
*pos = start;
return EINVAL;
}
case 'S':
case 's':
if (allow_time &&
- (p == end - 1 || ucl_lex_is_atom_end (p[1]))) {
+ (p == end - 1 || ucl_lex_is_atom_end(p[1]))) {
if (!need_double) {
need_double = true;
dv = lv;
}
- p ++;
+ p++;
is_time = true;
goto set_obj;
}
case 'Y':
case 'y':
if (allow_time &&
- (p == end - 1 || ucl_lex_is_atom_end (p[1]))) {
+ (p == end - 1 || ucl_lex_is_atom_end(p[1]))) {
if (!need_double) {
need_double = true;
dv = lv;
}
is_time = true;
- dv *= ucl_lex_time_multiplier (*p);
- p ++;
+ dv *= ucl_lex_time_multiplier(*p);
+ p++;
goto set_obj;
}
break;
* @return true if a number has been parsed
*/
static bool
-ucl_lex_number (struct ucl_parser *parser,
- struct ucl_chunk *chunk, ucl_object_t *obj)
+ucl_lex_number(struct ucl_parser *parser,
+ struct ucl_chunk *chunk, ucl_object_t *obj)
{
const unsigned char *pos;
int ret;
- ret = ucl_maybe_parse_number (obj, chunk->pos, chunk->end, (const char **)&pos,
- true, false, ((parser->flags & UCL_PARSER_NO_TIME) == 0));
+ ret = ucl_maybe_parse_number(obj, chunk->pos, chunk->end, (const char **) &pos,
+ true, false, ((parser->flags & UCL_PARSER_NO_TIME) == 0));
if (ret == 0) {
chunk->remain -= pos - chunk->pos;
return true;
}
else if (ret == ERANGE) {
- ucl_set_err (parser, UCL_ESYNTAX, "numeric value out of range",
- &parser->err);
+ ucl_set_err(parser, UCL_ESYNTAX, "numeric value out of range",
+ &parser->err);
}
return false;
* @return true if a string has been parsed
*/
static bool
-ucl_lex_json_string (struct ucl_parser *parser,
- struct ucl_chunk *chunk,
- bool *need_unescape,
- bool *ucl_escape,
- bool *var_expand)
+ucl_lex_json_string(struct ucl_parser *parser,
+ struct ucl_chunk *chunk,
+ bool *need_unescape,
+ bool *ucl_escape,
+ bool *var_expand)
{
const unsigned char *p = chunk->pos;
unsigned char c;
if (c < 0x1F) {
/* Unmasked control character */
if (c == '\n') {
- ucl_set_err (parser, UCL_ESYNTAX, "unexpected newline",
- &parser->err);
+ ucl_set_err(parser, UCL_ESYNTAX, "unexpected newline",
+ &parser->err);
}
else {
- ucl_set_err (parser, UCL_ESYNTAX, "unexpected control character",
- &parser->err);
+ ucl_set_err(parser, UCL_ESYNTAX, "unexpected control character",
+ &parser->err);
}
return false;
}
else if (c == '\\') {
- ucl_chunk_skipc (chunk, p);
+ ucl_chunk_skipc(chunk, p);
if (p >= chunk->end) {
- ucl_set_err (parser, UCL_ESYNTAX, "unfinished escape character",
- &parser->err);
+ ucl_set_err(parser, UCL_ESYNTAX, "unfinished escape character",
+ &parser->err);
return false;
}
c = *p;
- if (ucl_test_character (c, UCL_CHARACTER_ESCAPE)) {
+ if (ucl_test_character(c, UCL_CHARACTER_ESCAPE)) {
if (c == 'u') {
- ucl_chunk_skipc (chunk, p);
- for (i = 0; i < 4 && p < chunk->end; i ++) {
- if (!isxdigit (*p)) {
- ucl_set_err (parser, UCL_ESYNTAX, "invalid utf escape",
- &parser->err);
+ ucl_chunk_skipc(chunk, p);
+ for (i = 0; i < 4 && p < chunk->end; i++) {
+ if (!isxdigit(*p)) {
+ ucl_set_err(parser, UCL_ESYNTAX, "invalid utf escape",
+ &parser->err);
return false;
}
- ucl_chunk_skipc (chunk, p);
+ ucl_chunk_skipc(chunk, p);
}
if (p >= chunk->end) {
- ucl_set_err (parser, UCL_ESYNTAX,
- "unfinished escape character",
- &parser->err);
+ ucl_set_err(parser, UCL_ESYNTAX,
+ "unfinished escape character",
+ &parser->err);
return false;
}
}
else {
- ucl_chunk_skipc (chunk, p);
+ ucl_chunk_skipc(chunk, p);
}
}
*need_unescape = true;
continue;
}
else if (c == '"') {
- ucl_chunk_skipc (chunk, p);
+ ucl_chunk_skipc(chunk, p);
return true;
}
- else if (ucl_test_character (c, UCL_CHARACTER_UCL_UNSAFE)) {
+ else if (ucl_test_character(c, UCL_CHARACTER_UCL_UNSAFE)) {
*ucl_escape = true;
}
else if (c == '$') {
*var_expand = true;
}
- ucl_chunk_skipc (chunk, p);
+ ucl_chunk_skipc(chunk, p);
}
- ucl_set_err (parser, UCL_ESYNTAX,
- "no quote at the end of json string",
- &parser->err);
+ ucl_set_err(parser, UCL_ESYNTAX,
+ "no quote at the end of json string",
+ &parser->err);
return false;
}
* @return
*/
static bool
-ucl_lex_squoted_string (struct ucl_parser *parser,
- struct ucl_chunk *chunk, bool *need_unescape)
+ucl_lex_squoted_string(struct ucl_parser *parser,
+ struct ucl_chunk *chunk, bool *need_unescape)
{
const unsigned char *p = chunk->pos;
unsigned char c;
while (p < chunk->end) {
c = *p;
if (c == '\\') {
- ucl_chunk_skipc (chunk, p);
+ ucl_chunk_skipc(chunk, p);
if (p >= chunk->end) {
- ucl_set_err (parser, UCL_ESYNTAX,
- "unfinished escape character",
- &parser->err);
+ ucl_set_err(parser, UCL_ESYNTAX,
+ "unfinished escape character",
+ &parser->err);
return false;
}
else {
- ucl_chunk_skipc (chunk, p);
+ ucl_chunk_skipc(chunk, p);
}
*need_unescape = true;
continue;
}
else if (c == '\'') {
- ucl_chunk_skipc (chunk, p);
+ ucl_chunk_skipc(chunk, p);
return true;
}
- ucl_chunk_skipc (chunk, p);
+ ucl_chunk_skipc(chunk, p);
}
- ucl_set_err (parser, UCL_ESYNTAX,
- "no quote at the end of single quoted string",
- &parser->err);
+ ucl_set_err(parser, UCL_ESYNTAX,
+ "no quote at the end of single quoted string",
+ &parser->err);
return false;
}
static void
-ucl_parser_append_elt (struct ucl_parser *parser, ucl_hash_t *cont,
- ucl_object_t *top,
- ucl_object_t *elt)
+ucl_parser_append_elt(struct ucl_parser *parser, ucl_hash_t *cont,
+ ucl_object_t *top,
+ ucl_object_t *elt)
{
ucl_object_t *nobj;
if ((parser->flags & UCL_PARSER_NO_IMPLICIT_ARRAYS) == 0) {
/* Implicit array */
top->flags |= UCL_OBJECT_MULTIVALUE;
- DL_APPEND (top, elt);
- parser->stack->obj->len ++;
+ DL_APPEND(top, elt);
+ parser->stack->obj->len++;
}
else {
if ((top->flags & UCL_OBJECT_MULTIVALUE) != 0) {
/* Just add to the explicit array */
- ucl_array_append (top, elt);
+ ucl_array_append(top, elt);
}
else {
/* Convert to an array */
- nobj = ucl_object_typed_new (UCL_ARRAY);
+ nobj = ucl_object_typed_new(UCL_ARRAY);
nobj->key = top->key;
nobj->keylen = top->keylen;
nobj->flags |= UCL_OBJECT_MULTIVALUE;
- ucl_array_append (nobj, top);
- ucl_array_append (nobj, elt);
- ucl_hash_replace (cont, top, nobj);
+ ucl_array_append(nobj, top);
+ ucl_array_append(nobj, elt);
+ ucl_hash_replace(cont, top, nobj);
}
}
}
-bool
-ucl_parser_process_object_element (struct ucl_parser *parser, ucl_object_t *nobj)
+bool ucl_parser_process_object_element(struct ucl_parser *parser, ucl_object_t *nobj)
{
ucl_hash_t *container;
ucl_object_t *tobj = NULL, *cur;
container = parser->stack->obj->value.ov;
- DL_FOREACH (parser->stack->obj, cur) {
+ DL_FOREACH(parser->stack->obj, cur)
+ {
if (cur->type == UCL_OBJECT) {
- tobj = __DECONST (ucl_object_t *, ucl_hash_search_obj (cur->value.ov, nobj));
+ tobj = __DECONST(ucl_object_t *, ucl_hash_search_obj(cur->value.ov, nobj));
if (tobj != NULL) {
break;
if (tobj == NULL) {
- container = ucl_hash_insert_object (container, nobj,
- parser->flags & UCL_PARSER_KEY_LOWERCASE);
+ container = ucl_hash_insert_object(container, nobj,
+ parser->flags & UCL_PARSER_KEY_LOWERCASE);
if (container == NULL) {
return false;
}
nobj->prev = nobj;
nobj->next = NULL;
- parser->stack->obj->len ++;
+ parser->stack->obj->len++;
}
else {
- unsigned priold = ucl_object_get_priority (tobj),
- prinew = ucl_object_get_priority (nobj);
+ unsigned priold = ucl_object_get_priority(tobj),
+ prinew = ucl_object_get_priority(nobj);
switch (parser->chunks->strategy) {
case UCL_DUPLICATE_APPEND:
}
if (priold == prinew) {
- ucl_parser_append_elt (parser, container, tobj, nobj);
+ ucl_parser_append_elt(parser, container, tobj, nobj);
}
else if (priold > prinew) {
/*
* that it won't come to any real object
* XXX: rather inefficient approach
*/
- DL_APPEND (parser->trash_objs, nobj);
+ DL_APPEND(parser->trash_objs, nobj);
}
else {
- ucl_hash_replace (container, tobj, nobj);
- ucl_object_unref (tobj);
+ ucl_hash_replace(container, tobj, nobj);
+ ucl_object_unref(tobj);
}
break;
case UCL_DUPLICATE_REWRITE:
/* We just rewrite old values regardless of priority */
- ucl_hash_replace (container, tobj, nobj);
- ucl_object_unref (tobj);
+ ucl_hash_replace(container, tobj, nobj);
+ ucl_object_unref(tobj);
break;
case UCL_DUPLICATE_ERROR:
snprintf(errmsg, sizeof(errmsg),
- "duplicate element for key '%s' found",
- nobj->key);
- ucl_set_err (parser, UCL_EMERGE, errmsg, &parser->err);
+ "duplicate element for key '%s' found",
+ nobj->key);
+ ucl_set_err(parser, UCL_EMERGE, errmsg, &parser->err);
return false;
case UCL_DUPLICATE_MERGE:
* Check priority and then perform the merge on the remaining objects
*/
if (tobj->type == UCL_OBJECT || tobj->type == UCL_ARRAY) {
- ucl_object_unref (nobj);
+ ucl_object_unref(nobj);
nobj = tobj;
}
else if (priold == prinew) {
- ucl_parser_append_elt (parser, container, tobj, nobj);
+ ucl_parser_append_elt(parser, container, tobj, nobj);
}
else if (priold > prinew) {
/*
* that it won't come to any real object
* XXX: rather inefficient approach
*/
- DL_APPEND (parser->trash_objs, nobj);
+ DL_APPEND(parser->trash_objs, nobj);
}
else {
- ucl_hash_replace (container, tobj, nobj);
- ucl_object_unref (tobj);
+ ucl_hash_replace(container, tobj, nobj);
+ ucl_object_unref(tobj);
}
break;
}
parser->stack->obj->value.ov = container;
parser->cur_obj = nobj;
- ucl_attach_comment (parser, nobj, false);
+ ucl_attach_comment(parser, nobj, false);
return true;
}
* @return true if a key has been parsed
*/
static bool
-ucl_parse_key (struct ucl_parser *parser, struct ucl_chunk *chunk,
- bool *next_key, bool *end_of_object, bool *got_content)
+ucl_parse_key(struct ucl_parser *parser, struct ucl_chunk *chunk,
+ bool *next_key, bool *end_of_object, bool *got_content)
{
const unsigned char *p, *c = NULL, *end, *t;
const char *key = NULL;
bool got_quote = false, got_eq = false, got_semicolon = false,
- need_unescape = false, ucl_escape = false, var_expand = false,
- got_sep = false;
+ need_unescape = false, ucl_escape = false, var_expand = false,
+ got_sep = false;
ucl_object_t *nobj;
ssize_t keylen;
p = chunk->pos;
if (*p == '.' && !(parser->flags & UCL_PARSER_DISABLE_MACRO)) {
- ucl_chunk_skipc (chunk, p);
+ ucl_chunk_skipc(chunk, p);
parser->prev_state = parser->state;
parser->state = UCL_STATE_MACRO_NAME;
*end_of_object = false;
* A key must start with alpha, number, '/' or '_' and end with space character
*/
if (c == NULL) {
- if (chunk->remain >= 2 && ucl_lex_is_comment (p[0], p[1])) {
- if (!ucl_skip_comments (parser)) {
+ if (chunk->remain >= 2 && ucl_lex_is_comment(p[0], p[1])) {
+ if (!ucl_skip_comments(parser)) {
return false;
}
p = chunk->pos;
}
- else if (ucl_test_character (*p, UCL_CHARACTER_WHITESPACE_UNSAFE)) {
- ucl_chunk_skipc (chunk, p);
+ else if (ucl_test_character(*p, UCL_CHARACTER_WHITESPACE_UNSAFE)) {
+ ucl_chunk_skipc(chunk, p);
}
- else if (ucl_test_character (*p, UCL_CHARACTER_KEY_START)) {
+ else if (ucl_test_character(*p, UCL_CHARACTER_KEY_START)) {
/* The first symbol */
c = p;
- ucl_chunk_skipc (chunk, p);
+ ucl_chunk_skipc(chunk, p);
*got_content = true;
}
else if (*p == '"') {
c = p + 1;
got_quote = true;
*got_content = true;
- ucl_chunk_skipc (chunk, p);
+ ucl_chunk_skipc(chunk, p);
}
else if (*p == '}') {
/* We have actually end of an object */
return true;
}
else if (*p == '.' && !(parser->flags & UCL_PARSER_DISABLE_MACRO)) {
- ucl_chunk_skipc (chunk, p);
+ ucl_chunk_skipc(chunk, p);
parser->prev_state = parser->state;
parser->state = UCL_STATE_MACRO_NAME;
return true;
}
else {
/* Invalid identifier */
- ucl_set_err (parser, UCL_ESYNTAX, "key must begin with a letter",
- &parser->err);
+ ucl_set_err(parser, UCL_ESYNTAX, "key must begin with a letter",
+ &parser->err);
return false;
}
}
else {
/* Parse the body of a key */
if (!got_quote) {
- if (ucl_test_character (*p, UCL_CHARACTER_KEY)) {
+ if (ucl_test_character(*p, UCL_CHARACTER_KEY)) {
*got_content = true;
- ucl_chunk_skipc (chunk, p);
+ ucl_chunk_skipc(chunk, p);
}
- else if (ucl_test_character (*p, UCL_CHARACTER_KEY_SEP)) {
+ else if (ucl_test_character(*p, UCL_CHARACTER_KEY_SEP)) {
end = p;
break;
}
else {
- ucl_set_err (parser, UCL_ESYNTAX, "invalid character in a key",
- &parser->err);
+ ucl_set_err(parser, UCL_ESYNTAX, "invalid character in a key",
+ &parser->err);
return false;
}
}
else {
/* We need to parse json like quoted string */
- if (!ucl_lex_json_string (parser, chunk, &need_unescape, &ucl_escape, &var_expand)) {
+ if (!ucl_lex_json_string(parser, chunk, &need_unescape, &ucl_escape, &var_expand)) {
return false;
}
/* Always escape keys obtained via json */
}
if (p >= chunk->end && *got_content) {
- ucl_set_err (parser, UCL_ESYNTAX, "unfinished key", &parser->err);
+ ucl_set_err(parser, UCL_ESYNTAX, "unfinished key", &parser->err);
return false;
}
else if (!*got_content) {
*end_of_object = false;
/* We are now at the end of the key, need to parse the rest */
while (p < chunk->end) {
- if (ucl_test_character (*p, UCL_CHARACTER_WHITESPACE)) {
- ucl_chunk_skipc (chunk, p);
+ if (ucl_test_character(*p, UCL_CHARACTER_WHITESPACE)) {
+ ucl_chunk_skipc(chunk, p);
}
else if (*p == '=') {
if (!got_eq && !got_semicolon) {
- ucl_chunk_skipc (chunk, p);
+ ucl_chunk_skipc(chunk, p);
got_eq = true;
}
else {
- ucl_set_err (parser, UCL_ESYNTAX, "unexpected '=' character",
- &parser->err);
+ ucl_set_err(parser, UCL_ESYNTAX, "unexpected '=' character",
+ &parser->err);
return false;
}
}
else if (*p == ':') {
if (!got_eq && !got_semicolon) {
- ucl_chunk_skipc (chunk, p);
+ ucl_chunk_skipc(chunk, p);
got_semicolon = true;
}
else {
- ucl_set_err (parser, UCL_ESYNTAX, "unexpected ':' character",
- &parser->err);
+ ucl_set_err(parser, UCL_ESYNTAX, "unexpected ':' character",
+ &parser->err);
return false;
}
}
- else if (chunk->remain >= 2 && ucl_lex_is_comment (p[0], p[1])) {
+ else if (chunk->remain >= 2 && ucl_lex_is_comment(p[0], p[1])) {
/* Check for comment */
- if (!ucl_skip_comments (parser)) {
+ if (!ucl_skip_comments(parser)) {
return false;
}
p = chunk->pos;
}
if (p >= chunk->end && got_content) {
- ucl_set_err (parser, UCL_ESYNTAX, "unfinished key", &parser->err);
+ ucl_set_err(parser, UCL_ESYNTAX, "unfinished key", &parser->err);
return false;
}
*/
t = p;
*next_key = false;
- while (ucl_test_character (*t, UCL_CHARACTER_WHITESPACE)) {
- t ++;
+ while (ucl_test_character(*t, UCL_CHARACTER_WHITESPACE)) {
+ t++;
}
/* Check first non-space character after a key */
if (*t != '{' && *t != '[') {
*next_key = true;
break;
}
- t ++;
+ t++;
}
}
}
/* Create a new object */
- nobj = ucl_object_new_full (UCL_NULL, parser->chunks->priority);
+ nobj = ucl_object_new_full(UCL_NULL, parser->chunks->priority);
if (nobj == NULL) {
return false;
}
- keylen = ucl_copy_or_store_ptr (parser, c, &nobj->trash_stack[UCL_TRASH_KEY],
- &key, end - c, need_unescape, parser->flags & UCL_PARSER_KEY_LOWERCASE,
- false, false);
+ keylen = ucl_copy_or_store_ptr(parser, c, &nobj->trash_stack[UCL_TRASH_KEY],
+ &key, end - c, need_unescape, parser->flags & UCL_PARSER_KEY_LOWERCASE,
+ false, false);
if (keylen == -1) {
- ucl_object_unref (nobj);
+ ucl_object_unref(nobj);
return false;
}
else if (keylen == 0) {
- ucl_set_err (parser, UCL_ESYNTAX, "empty keys are not allowed", &parser->err);
- ucl_object_unref (nobj);
+ ucl_set_err(parser, UCL_ESYNTAX, "empty keys are not allowed", &parser->err);
+ ucl_object_unref(nobj);
return false;
}
nobj->key = key;
nobj->keylen = keylen;
- if (!ucl_parser_process_object_element (parser, nobj)) {
+ if (!ucl_parser_process_object_element(parser, nobj)) {
return false;
}
* @return true if a key has been parsed
*/
static bool
-ucl_parse_string_value (struct ucl_parser *parser,
- struct ucl_chunk *chunk, bool *var_expand, bool *need_unescape)
+ucl_parse_string_value(struct ucl_parser *parser,
+ struct ucl_chunk *chunk, bool *var_expand, bool *need_unescape)
{
const unsigned char *p;
enum {
/* Skip pairs of figure braces */
if (*p == '{') {
- braces[UCL_BRACE_FIGURE][0] ++;
+ braces[UCL_BRACE_FIGURE][0]++;
}
else if (*p == '}') {
- braces[UCL_BRACE_FIGURE][1] ++;
+ braces[UCL_BRACE_FIGURE][1]++;
if (braces[UCL_BRACE_FIGURE][1] <= braces[UCL_BRACE_FIGURE][0]) {
/* This is not a termination symbol, continue */
- ucl_chunk_skipc (chunk, p);
+ ucl_chunk_skipc(chunk, p);
continue;
}
}
/* Skip pairs of square braces */
else if (*p == '[') {
- braces[UCL_BRACE_SQUARE][0] ++;
+ braces[UCL_BRACE_SQUARE][0]++;
}
else if (*p == ']') {
- braces[UCL_BRACE_SQUARE][1] ++;
+ braces[UCL_BRACE_SQUARE][1]++;
if (braces[UCL_BRACE_SQUARE][1] <= braces[UCL_BRACE_SQUARE][0]) {
/* This is not a termination symbol, continue */
- ucl_chunk_skipc (chunk, p);
+ ucl_chunk_skipc(chunk, p);
continue;
}
}
}
else if (*p == '\\') {
*need_unescape = true;
- ucl_chunk_skipc (chunk, p);
+ ucl_chunk_skipc(chunk, p);
if (p < chunk->end) {
- ucl_chunk_skipc (chunk, p);
+ ucl_chunk_skipc(chunk, p);
}
continue;
}
- if (ucl_lex_is_atom_end (*p) || (chunk->remain >= 2 && ucl_lex_is_comment (p[0], p[1]))) {
+ if (ucl_lex_is_atom_end(*p) || (chunk->remain >= 2 && ucl_lex_is_comment(p[0], p[1]))) {
break;
}
- ucl_chunk_skipc (chunk, p);
+ ucl_chunk_skipc(chunk, p);
}
return true;
* @return size of multiline string or 0 in case of error
*/
static int
-ucl_parse_multiline_string (struct ucl_parser *parser,
- struct ucl_chunk *chunk, const unsigned char *term,
- int term_len, unsigned char const **beg,
- bool *var_expand)
+ucl_parse_multiline_string(struct ucl_parser *parser,
+ struct ucl_chunk *chunk, const unsigned char *term,
+ int term_len, unsigned char const **beg,
+ bool *var_expand)
{
const unsigned char *p, *c, *tend;
bool newline = false;
if (chunk->end - p < term_len) {
return 0;
}
- else if (memcmp (p, term, term_len) == 0) {
+ else if (memcmp(p, term, term_len) == 0) {
tend = p + term_len;
if (*tend != '\n' && *tend != ';' && *tend != ',') {
/* Incomplete terminator */
- ucl_chunk_skipc (chunk, p);
+ ucl_chunk_skipc(chunk, p);
continue;
}
len = p - c;
}
newline = false;
}
- ucl_chunk_skipc (chunk, p);
+ ucl_chunk_skipc(chunk, p);
}
return len;
}
-static inline ucl_object_t*
-ucl_parser_get_container (struct ucl_parser *parser)
+static inline ucl_object_t *
+ucl_parser_get_container(struct ucl_parser *parser)
{
ucl_object_t *t, *obj = NULL;
if (parser->stack->obj->type == UCL_ARRAY) {
/* Object must be allocated */
- obj = ucl_object_new_full (UCL_NULL, parser->chunks->priority);
+ obj = ucl_object_new_full(UCL_NULL, parser->chunks->priority);
t = parser->stack->obj;
- if (!ucl_array_append (t, obj)) {
- ucl_object_unref (obj);
+ if (!ucl_array_append(t, obj)) {
+ ucl_object_unref(obj);
return NULL;
}
parser->cur_obj = obj;
- ucl_attach_comment (parser, obj, false);
+ ucl_attach_comment(parser, obj, false);
}
else {
/* Object has been already allocated */
* @return
*/
static bool
-ucl_parse_value (struct ucl_parser *parser, struct ucl_chunk *chunk)
+ucl_parse_value(struct ucl_parser *parser, struct ucl_chunk *chunk)
{
const unsigned char *p, *c;
ucl_object_t *obj = NULL;
p = chunk->pos;
/* Skip any spaces and comments */
- if (ucl_test_character (*p, UCL_CHARACTER_WHITESPACE_UNSAFE) ||
- (chunk->remain >= 2 && ucl_lex_is_comment (p[0], p[1]))) {
- while (p < chunk->end && ucl_test_character (*p, UCL_CHARACTER_WHITESPACE_UNSAFE)) {
- ucl_chunk_skipc (chunk, p);
+ if (ucl_test_character(*p, UCL_CHARACTER_WHITESPACE_UNSAFE) ||
+ (chunk->remain >= 2 && ucl_lex_is_comment(p[0], p[1]))) {
+ while (p < chunk->end && ucl_test_character(*p, UCL_CHARACTER_WHITESPACE_UNSAFE)) {
+ ucl_chunk_skipc(chunk, p);
}
- if (!ucl_skip_comments (parser)) {
+ if (!ucl_skip_comments(parser)) {
return false;
}
p = chunk->pos;
c = p;
switch (*p) {
case '"':
- ucl_chunk_skipc (chunk, p);
+ ucl_chunk_skipc(chunk, p);
- if (!ucl_lex_json_string (parser, chunk, &need_unescape, &ucl_escape,
- &var_expand)) {
+ if (!ucl_lex_json_string(parser, chunk, &need_unescape, &ucl_escape,
+ &var_expand)) {
return false;
}
- obj = ucl_parser_get_container (parser);
+ obj = ucl_parser_get_container(parser);
if (!obj) {
return false;
}
str_len = chunk->pos - c - 2;
obj->type = UCL_STRING;
- if ((str_len = ucl_copy_or_store_ptr (parser, c + 1,
- &obj->trash_stack[UCL_TRASH_VALUE],
- &obj->value.sv, str_len, need_unescape, false,
- var_expand, false)) == -1) {
+ if ((str_len = ucl_copy_or_store_ptr(parser, c + 1,
+ &obj->trash_stack[UCL_TRASH_VALUE],
+ &obj->value.sv, str_len, need_unescape, false,
+ var_expand, false)) == -1) {
return false;
}
return true;
break;
case '\'':
- ucl_chunk_skipc (chunk, p);
+ ucl_chunk_skipc(chunk, p);
- if (!ucl_lex_squoted_string (parser, chunk, &need_unescape)) {
+ if (!ucl_lex_squoted_string(parser, chunk, &need_unescape)) {
return false;
}
- obj = ucl_parser_get_container (parser);
+ obj = ucl_parser_get_container(parser);
if (!obj) {
return false;
}
obj->type = UCL_STRING;
obj->flags |= UCL_OBJECT_SQUOTED;
- if ((str_len = ucl_copy_or_store_ptr (parser, c + 1,
- &obj->trash_stack[UCL_TRASH_VALUE],
- &obj->value.sv, str_len, need_unescape, false,
- var_expand, true)) == -1) {
+ if ((str_len = ucl_copy_or_store_ptr(parser, c + 1,
+ &obj->trash_stack[UCL_TRASH_VALUE],
+ &obj->value.sv, str_len, need_unescape, false,
+ var_expand, true)) == -1) {
return false;
}
return true;
break;
case '{':
- obj = ucl_parser_get_container (parser);
+ obj = ucl_parser_get_container(parser);
if (obj == NULL) {
parser->state = UCL_STATE_ERROR;
ucl_set_err(parser, UCL_ESYNTAX, "object value must be a part of an object",
- &parser->err);
+ &parser->err);
return false;
}
/* We have a new object */
if (parser->stack) {
- obj = ucl_parser_add_container (obj, parser, false,
- parser->stack->e.params.level, true);
+ obj = ucl_parser_add_container(obj, parser, false,
+ parser->stack->e.params.level, true);
}
else {
return false;
return false;
}
- ucl_chunk_skipc (chunk, p);
+ ucl_chunk_skipc(chunk, p);
return true;
break;
case '[':
- obj = ucl_parser_get_container (parser);
+ obj = ucl_parser_get_container(parser);
if (obj == NULL) {
parser->state = UCL_STATE_ERROR;
ucl_set_err(parser, UCL_ESYNTAX, "array value must be a part of an object",
- &parser->err);
+ &parser->err);
return false;
}
/* We have a new array */
if (parser->stack) {
- obj = ucl_parser_add_container (obj, parser, true,
- parser->stack->e.params.level, true);
+ obj = ucl_parser_add_container(obj, parser, true,
+ parser->stack->e.params.level, true);
}
else {
return false;
return false;
}
- ucl_chunk_skipc (chunk, p);
+ ucl_chunk_skipc(chunk, p);
return true;
break;
}
break;
case '<':
- obj = ucl_parser_get_container (parser);
+ obj = ucl_parser_get_container(parser);
if (obj == NULL) {
parser->state = UCL_STATE_ERROR;
ucl_set_err(parser, UCL_ESYNTAX, "multiline value must be a part of an object",
- &parser->err);
+ &parser->err);
return false;
}
/* We have something like multiline value, which must be <<[A-Z]+\n */
if (chunk->end - p > 3) {
- if (memcmp (p, "<<", 2) == 0) {
+ if (memcmp(p, "<<", 2) == 0) {
p += 2;
/* We allow only uppercase characters in multiline definitions */
while (p < chunk->end && *p >= 'A' && *p <= 'Z') {
- p ++;
+ p++;
}
- if(p == chunk->end) {
- ucl_set_err (parser, UCL_ESYNTAX,
- "unterminated multiline value", &parser->err);
+ if (p == chunk->end) {
+ ucl_set_err(parser, UCL_ESYNTAX,
+ "unterminated multiline value", &parser->err);
return false;
}
- if (*p =='\n') {
+ if (*p == '\n') {
/* Set chunk positions and start multiline parsing */
chunk->remain -= p - c + 1;
c += 2;
chunk->pos = p + 1;
chunk->column = 0;
- chunk->line ++;
- if ((str_len = ucl_parse_multiline_string (parser, chunk, c,
- p - c, &c, &var_expand)) == 0) {
- ucl_set_err (parser, UCL_ESYNTAX,
- "unterminated multiline value", &parser->err);
+ chunk->line++;
+ if ((str_len = ucl_parse_multiline_string(parser, chunk, c,
+ p - c, &c, &var_expand)) == 0) {
+ ucl_set_err(parser, UCL_ESYNTAX,
+ "unterminated multiline value", &parser->err);
return false;
}
obj->type = UCL_STRING;
obj->flags |= UCL_OBJECT_MULTILINE;
- if ((str_len = ucl_copy_or_store_ptr (parser, c,
- &obj->trash_stack[UCL_TRASH_VALUE],
- &obj->value.sv, str_len - 1, false,
- false, var_expand, false)) == -1) {
+ if ((str_len = ucl_copy_or_store_ptr(parser, c,
+ &obj->trash_stack[UCL_TRASH_VALUE],
+ &obj->value.sv, str_len - 1, false,
+ false, var_expand, false)) == -1) {
return false;
}
obj->len = str_len;
/* Fallback to ordinary strings */
/* FALLTHRU */
default:
-parse_string:
+ parse_string:
if (obj == NULL) {
- obj = ucl_parser_get_container (parser);
+ obj = ucl_parser_get_container(parser);
}
if (obj == NULL) {
parser->state = UCL_STATE_ERROR;
ucl_set_err(parser, UCL_ESYNTAX, "value must be a part of an object",
- &parser->err);
+ &parser->err);
return false;
}
/* Parse atom */
- if (ucl_test_character (*p, UCL_CHARACTER_VALUE_DIGIT_START)) {
- if (!ucl_lex_number (parser, chunk, obj)) {
+ if (ucl_test_character(*p, UCL_CHARACTER_VALUE_DIGIT_START)) {
+ if (!ucl_lex_number(parser, chunk, obj)) {
if (parser->state == UCL_STATE_ERROR) {
return false;
}
/* Fallback to normal string */
}
- if (!ucl_parse_string_value (parser, chunk, &var_expand,
- &need_unescape)) {
+ if (!ucl_parse_string_value(parser, chunk, &var_expand,
+ &need_unescape)) {
return false;
}
/* Cut trailing spaces */
stripped_spaces = 0;
- while (ucl_test_character (*(chunk->pos - 1 - stripped_spaces),
- UCL_CHARACTER_WHITESPACE)) {
- stripped_spaces ++;
+ while (ucl_test_character(*(chunk->pos - 1 - stripped_spaces),
+ UCL_CHARACTER_WHITESPACE)) {
+ stripped_spaces++;
}
str_len = chunk->pos - c - stripped_spaces;
if (str_len <= 0) {
- ucl_set_err (parser, UCL_ESYNTAX, "string value must not be empty",
- &parser->err);
+ ucl_set_err(parser, UCL_ESYNTAX, "string value must not be empty",
+ &parser->err);
return false;
}
- else if (str_len == 4 && memcmp (c, "null", 4) == 0) {
+ else if (str_len == 4 && memcmp(c, "null", 4) == 0) {
obj->len = 0;
obj->type = UCL_NULL;
}
- else if (str_len == 3 && memcmp (c, "nan", 3) == 0) {
+ else if (str_len == 3 && memcmp(c, "nan", 3) == 0) {
obj->len = 0;
obj->type = UCL_FLOAT;
obj->value.dv = NAN;
}
- else if (str_len == 3 && memcmp (c, "inf", 3) == 0) {
+ else if (str_len == 3 && memcmp(c, "inf", 3) == 0) {
obj->len = 0;
obj->type = UCL_FLOAT;
obj->value.dv = INFINITY;
}
- else if (!ucl_maybe_parse_boolean (obj, c, str_len)) {
+ else if (!ucl_maybe_parse_boolean(obj, c, str_len)) {
obj->type = UCL_STRING;
- if ((str_len = ucl_copy_or_store_ptr (parser, c,
- &obj->trash_stack[UCL_TRASH_VALUE],
- &obj->value.sv, str_len, need_unescape,
- false, var_expand, false)) == -1) {
+ if ((str_len = ucl_copy_or_store_ptr(parser, c,
+ &obj->trash_stack[UCL_TRASH_VALUE],
+ &obj->value.sv, str_len, need_unescape,
+ false, var_expand, false)) == -1) {
return false;
}
obj->len = str_len;
* @return
*/
static bool
-ucl_parse_after_value (struct ucl_parser *parser, struct ucl_chunk *chunk)
+ucl_parse_after_value(struct ucl_parser *parser, struct ucl_chunk *chunk)
{
const unsigned char *p;
bool got_sep = false;
p = chunk->pos;
while (p < chunk->end) {
- if (ucl_test_character (*p, UCL_CHARACTER_WHITESPACE)) {
+ if (ucl_test_character(*p, UCL_CHARACTER_WHITESPACE)) {
/* Skip whitespaces */
- ucl_chunk_skipc (chunk, p);
+ ucl_chunk_skipc(chunk, p);
}
- else if (chunk->remain >= 2 && ucl_lex_is_comment (p[0], p[1])) {
+ else if (chunk->remain >= 2 && ucl_lex_is_comment(p[0], p[1])) {
/* Skip comment */
- if (!ucl_skip_comments (parser)) {
+ if (!ucl_skip_comments(parser)) {
return false;
}
/* Treat comment as a separator */
got_sep = true;
p = chunk->pos;
}
- else if (ucl_test_character (*p, UCL_CHARACTER_VALUE_END)) {
+ else if (ucl_test_character(*p, UCL_CHARACTER_VALUE_END)) {
if (*p == '}' || *p == ']') {
if (parser->stack == NULL) {
- ucl_set_err (parser, UCL_ESYNTAX,
- "end of array or object detected without corresponding start",
- &parser->err);
+ ucl_set_err(parser, UCL_ESYNTAX,
+ "end of array or object detected without corresponding start",
+ &parser->err);
return false;
}
if ((*p == '}' && parser->stack->obj->type == UCL_OBJECT) ||
- (*p == ']' && parser->stack->obj->type == UCL_ARRAY)) {
+ (*p == ']' && parser->stack->obj->type == UCL_ARRAY)) {
/* Pop all nested objects from a stack */
st = parser->stack;
if (!(st->e.params.flags & UCL_STACK_HAS_OBRACE)) {
parser->err_code = UCL_EUNPAIRED;
- ucl_create_err (&parser->err,
- "%s:%d object closed with } is not opened with { at line %d",
- chunk->fname ? chunk->fname : "memory",
- parser->chunks->line, st->e.params.line);
+ ucl_create_err(&parser->err,
+ "%s:%d object closed with } is not opened with { at line %d",
+ chunk->fname ? chunk->fname : "memory",
+ parser->chunks->line, st->e.params.line);
return false;
}
- parser->stack = st->next;
- UCL_FREE (sizeof (struct ucl_stack), st);
+ if ((st->e.params.flags & UCL_STACK_AUTOMATIC)) {
+ st->e.params.flags = 0;
+ }
+ else {
+ parser->stack = st->next;
+ UCL_FREE(sizeof(struct ucl_stack), st);
+ }
if (parser->cur_obj) {
- ucl_attach_comment (parser, parser->cur_obj, true);
+ ucl_attach_comment(parser, parser->cur_obj, true);
}
while (parser->stack != NULL) {
parser->stack = st->next;
parser->cur_obj = st->obj;
- UCL_FREE (sizeof (struct ucl_stack), st);
+ UCL_FREE(sizeof(struct ucl_stack), st);
}
}
else {
- ucl_set_err (parser, UCL_ESYNTAX,
- "unexpected terminating symbol detected",
- &parser->err);
+ ucl_set_err(parser, UCL_ESYNTAX,
+ "unexpected terminating symbol detected",
+ &parser->err);
return false;
}
return true;
}
else {
- ucl_chunk_skipc (chunk, p);
+ ucl_chunk_skipc(chunk, p);
}
got_sep = true;
}
else {
/* Got a separator */
got_sep = true;
- ucl_chunk_skipc (chunk, p);
+ ucl_chunk_skipc(chunk, p);
}
}
else {
/* Anything else */
if (!got_sep) {
- ucl_set_err (parser, UCL_ESYNTAX, "delimiter is missing",
- &parser->err);
+ ucl_set_err(parser, UCL_ESYNTAX, "delimiter is missing",
+ &parser->err);
return false;
}
return true;
}
static bool
-ucl_skip_macro_as_comment (struct ucl_parser *parser,
- struct ucl_chunk *chunk)
+ucl_skip_macro_as_comment(struct ucl_parser *parser,
+ struct ucl_chunk *chunk)
{
const unsigned char *p, *c;
enum {
macro_has_backslash,
macro_has_sqbrace,
macro_save
- } state = macro_skip_start, prev_state = macro_skip_start;
+ } state = macro_skip_start,
+ prev_state = macro_skip_start;
p = chunk->pos;
c = chunk->pos;
while (p < chunk->end) {
switch (state) {
case macro_skip_start:
- if (!ucl_test_character (*p, UCL_CHARACTER_WHITESPACE)) {
+ if (!ucl_test_character(*p, UCL_CHARACTER_WHITESPACE)) {
state = macro_has_symbols;
}
- else if (ucl_test_character (*p, UCL_CHARACTER_WHITESPACE_UNSAFE)) {
+ else if (ucl_test_character(*p, UCL_CHARACTER_WHITESPACE_UNSAFE)) {
state = macro_save;
continue;
}
- ucl_chunk_skipc (chunk, p);
+ ucl_chunk_skipc(chunk, p);
break;
case macro_has_symbols:
continue;
}
- ucl_chunk_skipc (chunk, p);
+ ucl_chunk_skipc(chunk, p);
break;
case macro_has_obrace:
state = macro_has_symbols;
}
- ucl_chunk_skipc (chunk, p);
+ ucl_chunk_skipc(chunk, p);
break;
case macro_has_sqbrace:
state = macro_save;
}
- ucl_chunk_skipc (chunk, p);
+ ucl_chunk_skipc(chunk, p);
break;
case macro_has_quote:
state = macro_save;
}
- ucl_chunk_skipc (chunk, p);
+ ucl_chunk_skipc(chunk, p);
break;
case macro_has_backslash:
state = prev_state;
- ucl_chunk_skipc (chunk, p);
+ ucl_chunk_skipc(chunk, p);
break;
case macro_save:
if (parser->flags & UCL_PARSER_SAVE_COMMENTS) {
- ucl_save_comment (parser, c, p - c);
+ ucl_save_comment(parser, c, p - c);
}
return true;
* @return
*/
static bool
-ucl_parse_macro_value (struct ucl_parser *parser,
- struct ucl_chunk *chunk, struct ucl_macro *macro,
- unsigned char const **macro_start, size_t *macro_len)
+ucl_parse_macro_value(struct ucl_parser *parser,
+ struct ucl_chunk *chunk, struct ucl_macro *macro,
+ unsigned char const **macro_start, size_t *macro_len)
{
const unsigned char *p, *c;
bool need_unescape = false, ucl_escape = false, var_expand = false;
case '"':
/* We have macro value encoded in quotes */
c = p;
- ucl_chunk_skipc (chunk, p);
- if (!ucl_lex_json_string (parser, chunk, &need_unescape, &ucl_escape, &var_expand)) {
+ ucl_chunk_skipc(chunk, p);
+ if (!ucl_lex_json_string(parser, chunk, &need_unescape, &ucl_escape, &var_expand)) {
return false;
}
break;
case '{':
/* We got a multiline macro body */
- ucl_chunk_skipc (chunk, p);
+ ucl_chunk_skipc(chunk, p);
/* Skip spaces at the beginning */
while (p < chunk->end) {
- if (ucl_test_character (*p, UCL_CHARACTER_WHITESPACE_UNSAFE)) {
- ucl_chunk_skipc (chunk, p);
+ if (ucl_test_character(*p, UCL_CHARACTER_WHITESPACE_UNSAFE)) {
+ ucl_chunk_skipc(chunk, p);
}
else {
break;
if (*p == '}') {
break;
}
- ucl_chunk_skipc (chunk, p);
+ ucl_chunk_skipc(chunk, p);
}
*macro_start = c;
*macro_len = p - c;
- ucl_chunk_skipc (chunk, p);
+ ucl_chunk_skipc(chunk, p);
break;
default:
/* Macro is not enclosed in quotes or braces */
c = p;
while (p < chunk->end) {
- if (ucl_lex_is_atom_end (*p)) {
+ if (ucl_lex_is_atom_end(*p)) {
break;
}
- ucl_chunk_skipc (chunk, p);
+ ucl_chunk_skipc(chunk, p);
}
*macro_start = c;
*macro_len = p - c;
/* We are at the end of a macro */
/* Skip ';' and space characters and return to previous state */
while (p < chunk->end) {
- if (!ucl_test_character (*p, UCL_CHARACTER_WHITESPACE_UNSAFE) && *p != ';') {
+ if (!ucl_test_character(*p, UCL_CHARACTER_WHITESPACE_UNSAFE) && *p != ';') {
break;
}
- ucl_chunk_skipc (chunk, p);
+ ucl_chunk_skipc(chunk, p);
}
return true;
}
* @return
*/
static ucl_object_t *
-ucl_parse_macro_arguments (struct ucl_parser *parser,
- struct ucl_chunk *chunk)
+ucl_parse_macro_arguments(struct ucl_parser *parser,
+ struct ucl_chunk *chunk)
{
ucl_object_t *res = NULL;
struct ucl_parser *params_parser;
}
/* Set begin and start */
- ucl_chunk_skipc (chunk, p);
+ ucl_chunk_skipc(chunk, p);
c = p;
while ((p) < (chunk)->end) {
case 0:
/* Parse symbols and check for '(', ')' and '"' */
if (*p == '(') {
- obraces ++;
+ obraces++;
}
else if (*p == ')') {
- ebraces ++;
+ ebraces++;
}
else if (*p == '"') {
state = 1;
state = 99;
}
else {
- args_len ++;
+ args_len++;
}
/* Check overflow */
if (chunk->remain == 0) {
goto restore_chunk;
}
- ucl_chunk_skipc (chunk, p);
+ ucl_chunk_skipc(chunk, p);
break;
case 1:
/* We have quote character, so skip all but quotes */
if (chunk->remain == 0) {
goto restore_chunk;
}
- args_len ++;
- ucl_chunk_skipc (chunk, p);
+ args_len++;
+ ucl_chunk_skipc(chunk, p);
break;
case 99:
/*
* We have read the full body of arguments, so we need to parse and set
* object from that
*/
- params_parser = ucl_parser_new (parser->flags);
- if (!ucl_parser_add_chunk (params_parser, c, args_len)) {
- ucl_set_err (parser, UCL_ESYNTAX, "macro arguments parsing error",
- &parser->err);
+ params_parser = ucl_parser_new(parser->flags);
+ if (!ucl_parser_add_chunk(params_parser, c, args_len)) {
+ ucl_set_err(parser, UCL_ESYNTAX, "macro arguments parsing error",
+ &parser->err);
}
else {
- res = ucl_parser_get_object (params_parser);
+ res = ucl_parser_get_object(params_parser);
}
- ucl_parser_free (params_parser);
+ ucl_parser_free(params_parser);
return res;
return NULL;
}
-#define SKIP_SPACES_COMMENTS(parser, chunk, p) do { \
- while ((p) < (chunk)->end) { \
- if (!ucl_test_character (*(p), UCL_CHARACTER_WHITESPACE_UNSAFE)) { \
- if ((chunk)->remain >= 2 && ucl_lex_is_comment ((p)[0], (p)[1])) { \
- if (!ucl_skip_comments (parser)) { \
- return false; \
- } \
- p = (chunk)->pos; \
- } \
- break; \
- } \
- ucl_chunk_skipc (chunk, p); \
- } \
-} while(0)
+#define SKIP_SPACES_COMMENTS(parser, chunk, p) \
+ do { \
+ while ((p) < (chunk)->end) { \
+ if (!ucl_test_character(*(p), UCL_CHARACTER_WHITESPACE_UNSAFE)) { \
+ if ((chunk)->remain >= 2 && ucl_lex_is_comment((p)[0], (p)[1])) { \
+ if (!ucl_skip_comments(parser)) { \
+ return false; \
+ } \
+ p = (chunk)->pos; \
+ } \
+ break; \
+ } \
+ ucl_chunk_skipc(chunk, p); \
+ } \
+ } while (0)
/**
* Handle the main states of rcl parser
* @return true if chunk has been parsed and false in case of error
*/
static bool
-ucl_state_machine (struct ucl_parser *parser)
+ucl_state_machine(struct ucl_parser *parser)
{
ucl_object_t *obj, *macro_args;
struct ucl_chunk *chunk = parser->chunks;
* if we got [ or { correspondingly or can just treat new data as
* a key of newly created object
*/
- if (!ucl_skip_comments (parser)) {
+ if (!ucl_skip_comments(parser)) {
parser->prev_state = parser->state;
parser->state = UCL_STATE_ERROR;
return false;
bool seen_obrace = false;
/* Skip any spaces */
- while (p < chunk->end && ucl_test_character (*p,
- UCL_CHARACTER_WHITESPACE_UNSAFE)) {
- ucl_chunk_skipc (chunk, p);
+ while (p < chunk->end && ucl_test_character(*p,
+ UCL_CHARACTER_WHITESPACE_UNSAFE)) {
+ ucl_chunk_skipc(chunk, p);
}
p = chunk->pos;
if (p < chunk->end) {
if (*p == '[') {
parser->state = UCL_STATE_VALUE;
- ucl_chunk_skipc (chunk, p);
+ ucl_chunk_skipc(chunk, p);
seen_obrace = true;
}
else {
if (*p == '{') {
- ucl_chunk_skipc (chunk, p);
+ ucl_chunk_skipc(chunk, p);
parser->state = UCL_STATE_KEY_OBRACE;
seen_obrace = true;
}
if (parser->top_obj == NULL) {
if (parser->state == UCL_STATE_VALUE) {
- obj = ucl_parser_add_container (NULL, parser, true, 0,
- seen_obrace);
+ obj = ucl_parser_add_container(NULL, parser, true, 0,
+ seen_obrace);
}
else {
- obj = ucl_parser_add_container (NULL, parser, false, 0,
- seen_obrace);
+ obj = ucl_parser_add_container(NULL, parser, false, 0,
+ seen_obrace);
}
if (obj == NULL) {
parser->top_obj = obj;
parser->cur_obj = obj;
}
-
}
break;
- case UCL_STATE_KEY:
case UCL_STATE_KEY_OBRACE:
+ parser->stack->e.params.flags |= UCL_STACK_HAS_OBRACE | UCL_STACK_AUTOMATIC;
+ /* FALLTHROUGHT */
+ case UCL_STATE_KEY:
/* Skip any spaces */
- while (p < chunk->end && ucl_test_character (*p, UCL_CHARACTER_WHITESPACE_UNSAFE)) {
- ucl_chunk_skipc (chunk, p);
+ while (p < chunk->end && ucl_test_character(*p, UCL_CHARACTER_WHITESPACE_UNSAFE)) {
+ ucl_chunk_skipc(chunk, p);
}
if (p == chunk->end || *p == '}') {
/* We have the end of an object */
}
if (parser->stack == NULL) {
/* No objects are on stack, but we want to parse a key */
- ucl_set_err (parser, UCL_ESYNTAX, "top object is finished but the parser "
- "expects a key", &parser->err);
+ ucl_set_err(parser, UCL_ESYNTAX, "top object is finished but the parser "
+ "expects a key",
+ &parser->err);
parser->prev_state = parser->state;
parser->state = UCL_STATE_ERROR;
return false;
got_content = false;
- if (!ucl_parse_key (parser, chunk, &next_key, &end_of_object, &got_content)) {
+ if (!ucl_parse_key(parser, chunk, &next_key, &end_of_object, &got_content)) {
parser->prev_state = parser->state;
parser->state = UCL_STATE_ERROR;
return false;
else if (parser->state != UCL_STATE_MACRO_NAME) {
if (next_key && parser->stack->obj->type == UCL_OBJECT) {
/* Parse more keys and nest objects accordingly */
- obj = ucl_parser_add_container (parser->cur_obj,
- parser,
- false,
- parser->stack->e.params.level + 1,
- parser->state == UCL_STATE_KEY_OBRACE);
+ obj = ucl_parser_add_container(parser->cur_obj,
+ parser,
+ false,
+ parser->stack->e.params.level + 1,
+ parser->state == UCL_STATE_KEY_OBRACE);
if (obj == NULL) {
return false;
}
break;
case UCL_STATE_VALUE:
/* We need to check what we do have */
- if (!parser->cur_obj || !ucl_parse_value (parser, chunk)) {
+ if (!parser->cur_obj || !ucl_parse_value(parser, chunk)) {
parser->prev_state = parser->state;
parser->state = UCL_STATE_ERROR;
return false;
p = chunk->pos;
break;
case UCL_STATE_AFTER_VALUE:
- if (!ucl_parse_after_value (parser, chunk)) {
+ if (!ucl_parse_after_value(parser, chunk)) {
parser->prev_state = parser->state;
parser->state = UCL_STATE_ERROR;
return false;
break;
case UCL_STATE_MACRO_NAME:
if (parser->flags & UCL_PARSER_DISABLE_MACRO) {
- if (!ucl_skip_macro_as_comment (parser, chunk)) {
+ if (!ucl_skip_macro_as_comment(parser, chunk)) {
/* We have invalid macro */
- ucl_create_err (&parser->err,
- "error at %s:%d at column %d: invalid macro",
- chunk->fname ? chunk->fname : "memory",
- chunk->line,
- chunk->column);
+ ucl_create_err(&parser->err,
+ "error at %s:%d at column %d: invalid macro",
+ chunk->fname ? chunk->fname : "memory",
+ chunk->line,
+ chunk->column);
parser->state = UCL_STATE_ERROR;
return false;
}
}
}
else {
- if (!ucl_test_character (*p, UCL_CHARACTER_WHITESPACE_UNSAFE) &&
- *p != '(') {
- ucl_chunk_skipc (chunk, p);
+ if (!ucl_test_character(*p, UCL_CHARACTER_WHITESPACE_UNSAFE) &&
+ *p != '(') {
+ ucl_chunk_skipc(chunk, p);
}
else {
if (c != NULL && p - c > 0) {
/* We got macro name */
macro_len = (size_t) (p - c);
- HASH_FIND (hh, parser->macroes, c, macro_len, macro);
+ HASH_FIND(hh, parser->macroes, c, macro_len, macro);
if (macro == NULL) {
- ucl_create_err (&parser->err,
- "error at %s:%d at column %d: "
- "unknown macro: '%.*s', character: '%c'",
- chunk->fname ? chunk->fname : "memory",
- chunk->line,
- chunk->column,
- (int) (p - c),
- c,
- *chunk->pos);
+ ucl_create_err(&parser->err,
+ "error at %s:%d at column %d: "
+ "unknown macro: '%.*s', character: '%c'",
+ chunk->fname ? chunk->fname : "memory",
+ chunk->line,
+ chunk->column,
+ (int) (p - c),
+ c,
+ *chunk->pos);
parser->state = UCL_STATE_ERROR;
return false;
}
}
else {
/* We have invalid macro name */
- ucl_create_err (&parser->err,
- "error at %s:%d at column %d: invalid macro name",
- chunk->fname ? chunk->fname : "memory",
- chunk->line,
- chunk->column);
+ ucl_create_err(&parser->err,
+ "error at %s:%d at column %d: invalid macro name",
+ chunk->fname ? chunk->fname : "memory",
+ chunk->line,
+ chunk->column);
parser->state = UCL_STATE_ERROR;
return false;
}
break;
case UCL_STATE_MACRO:
if (*chunk->pos == '(') {
- macro_args = ucl_parse_macro_arguments (parser, chunk);
+ macro_args = ucl_parse_macro_arguments(parser, chunk);
p = chunk->pos;
if (macro_args) {
SKIP_SPACES_COMMENTS(parser, chunk, p);
else {
macro_args = NULL;
}
- if (!ucl_parse_macro_value (parser, chunk, macro,
- ¯o_start, ¯o_len)) {
+ if (!ucl_parse_macro_value(parser, chunk, macro,
+ ¯o_start, ¯o_len)) {
parser->prev_state = parser->state;
parser->state = UCL_STATE_ERROR;
return false;
}
- macro_len = ucl_expand_variable (parser, ¯o_escaped,
- macro_start, macro_len);
+ macro_len = ucl_expand_variable(parser, ¯o_escaped,
+ macro_start, macro_len);
parser->state = parser->prev_state;
if (macro_escaped == NULL && macro != NULL) {
if (macro->is_context) {
- ret = macro->h.context_handler (macro_start, macro_len,
- macro_args,
- parser->top_obj,
- macro->ud);
+ ret = macro->h.context_handler(macro_start, macro_len,
+ macro_args,
+ parser->top_obj,
+ macro->ud);
}
else {
- ret = macro->h.handler (macro_start, macro_len, macro_args,
- macro->ud);
+ ret = macro->h.handler(macro_start, macro_len, macro_args,
+ macro->ud);
}
}
else if (macro != NULL) {
if (macro->is_context) {
- ret = macro->h.context_handler (macro_escaped, macro_len,
- macro_args,
- parser->top_obj,
- macro->ud);
+ ret = macro->h.context_handler(macro_escaped, macro_len,
+ macro_args,
+ parser->top_obj,
+ macro->ud);
}
else {
- ret = macro->h.handler (macro_escaped, macro_len, macro_args,
- macro->ud);
+ ret = macro->h.handler(macro_escaped, macro_len, macro_args,
+ macro->ud);
}
- UCL_FREE (macro_len + 1, macro_escaped);
+ UCL_FREE(macro_len + 1, macro_escaped);
}
else {
ret = false;
- ucl_set_err (parser, UCL_EINTERNAL,
- "internal error: parser has macro undefined", &parser->err);
+ ucl_set_err(parser, UCL_EINTERNAL,
+ "internal error: parser has macro undefined", &parser->err);
}
/*
p = chunk->pos;
if (macro_args) {
- ucl_object_unref (macro_args);
+ ucl_object_unref(macro_args);
}
if (!ret) {
/* Already in the error state */
return false;
default:
- ucl_set_err (parser, UCL_EINTERNAL,
- "internal error: parser is in an unknown state", &parser->err);
+ ucl_set_err(parser, UCL_EINTERNAL,
+ "internal error: parser is in an unknown state", &parser->err);
parser->state = UCL_STATE_ERROR;
return false;
}
if (parser->last_comment) {
if (parser->cur_obj) {
- ucl_attach_comment (parser, parser->cur_obj, true);
+ ucl_attach_comment(parser, parser->cur_obj, true);
}
else if (parser->stack && parser->stack->obj) {
- ucl_attach_comment (parser, parser->stack->obj, true);
+ ucl_attach_comment(parser, parser->stack->obj, true);
}
else if (parser->top_obj) {
- ucl_attach_comment (parser, parser->top_obj, true);
+ ucl_attach_comment(parser, parser->top_obj, true);
}
else {
- ucl_object_unref (parser->last_comment);
+ ucl_object_unref(parser->last_comment);
}
}
struct ucl_stack *st;
bool has_error = false;
- LL_FOREACH (parser->stack, st) {
+ LL_FOREACH(parser->stack, st)
+ {
if (st->chunk != parser->chunks) {
break; /* Not our chunk, give up */
}
if (st->e.params.flags & UCL_STACK_HAS_OBRACE) {
if (parser->err == NULL) {
- utstring_new (parser->err);
+ utstring_new(parser->err);
}
- utstring_printf (parser->err, "%s:%d unmatched open brace at %d; ",
- chunk->fname ? chunk->fname : "memory",
- parser->chunks->line,
- st->e.params.line);
+ utstring_printf(parser->err, "%s:%d unmatched open brace at %d; ",
+ chunk->fname ? chunk->fname : "memory",
+ parser->chunks->line,
+ st->e.params.line);
has_error = true;
}
return true;
}
-#define UPRM_SAFE(fn, a, b, c, el) do { \
- if (!fn(a, b, c, a)) \
- goto el; \
+#define UPRM_SAFE(fn, a, b, c, el) \
+ do { \
+ if (!fn(a, b, c, a)) \
+ goto el; \
} while (0)
-struct ucl_parser*
-ucl_parser_new (int flags)
+struct ucl_parser *
+ucl_parser_new(int flags)
{
struct ucl_parser *parser;
- parser = UCL_ALLOC (sizeof (struct ucl_parser));
+ parser = UCL_ALLOC(sizeof(struct ucl_parser));
if (parser == NULL) {
return NULL;
}
- memset (parser, 0, sizeof (struct ucl_parser));
+ memset(parser, 0, sizeof(struct ucl_parser));
UPRM_SAFE(ucl_parser_register_macro, parser, "include", ucl_include_handler, e0);
UPRM_SAFE(ucl_parser_register_macro, parser, "try_include", ucl_try_include_handler, e0);
parser->includepaths = NULL;
if (flags & UCL_PARSER_SAVE_COMMENTS) {
- parser->comments = ucl_object_typed_new (UCL_OBJECT);
+ parser->comments = ucl_object_typed_new(UCL_OBJECT);
}
if (!(flags & UCL_PARSER_NO_FILEVARS)) {
/* Initial assumption about filevars */
- ucl_parser_set_filevars (parser, NULL, false);
+ ucl_parser_set_filevars(parser, NULL, false);
}
return parser;
return NULL;
}
-bool
-ucl_parser_set_default_priority (struct ucl_parser *parser, unsigned prio)
+bool ucl_parser_set_default_priority(struct ucl_parser *parser, unsigned prio)
{
if (parser == NULL) {
return false;
return true;
}
-int
-ucl_parser_get_default_priority (struct ucl_parser *parser)
+int ucl_parser_get_default_priority(struct ucl_parser *parser)
{
if (parser == NULL) {
return -1;
return parser->default_priority;
}
-bool
-ucl_parser_register_macro (struct ucl_parser *parser, const char *macro,
- ucl_macro_handler handler, void* ud)
+bool ucl_parser_register_macro(struct ucl_parser *parser, const char *macro,
+ ucl_macro_handler handler, void *ud)
{
struct ucl_macro *new;
return false;
}
- new = UCL_ALLOC (sizeof (struct ucl_macro));
+ new = UCL_ALLOC(sizeof(struct ucl_macro));
if (new == NULL) {
return false;
}
- memset (new, 0, sizeof (struct ucl_macro));
+ memset(new, 0, sizeof(struct ucl_macro));
new->h.handler = handler;
- new->name = strdup (macro);
+ new->name = strdup(macro);
if (new->name == NULL) {
- UCL_FREE (sizeof (struct ucl_macro), new);
+ UCL_FREE(sizeof(struct ucl_macro), new);
return false;
}
new->ud = ud;
- HASH_ADD_KEYPTR (hh, parser->macroes, new->name, strlen (new->name), new);
+ HASH_ADD_KEYPTR(hh, parser->macroes, new->name, strlen(new->name), new);
return true;
}
-bool
-ucl_parser_register_context_macro (struct ucl_parser *parser, const char *macro,
- ucl_context_macro_handler handler, void* ud)
+bool ucl_parser_register_context_macro(struct ucl_parser *parser, const char *macro,
+ ucl_context_macro_handler handler, void *ud)
{
struct ucl_macro *new;
return false;
}
- new = UCL_ALLOC (sizeof (struct ucl_macro));
+ new = UCL_ALLOC(sizeof(struct ucl_macro));
if (new == NULL) {
return false;
}
- memset (new, 0, sizeof (struct ucl_macro));
+ memset(new, 0, sizeof(struct ucl_macro));
new->h.context_handler = handler;
- new->name = strdup (macro);
+ new->name = strdup(macro);
if (new->name == NULL) {
- UCL_FREE (sizeof (struct ucl_macro), new);
+ UCL_FREE(sizeof(struct ucl_macro), new);
return false;
}
new->ud = ud;
new->is_context = true;
- HASH_ADD_KEYPTR (hh, parser->macroes, new->name, strlen (new->name), new);
+ HASH_ADD_KEYPTR(hh, parser->macroes, new->name, strlen(new->name), new);
return true;
}
-void
-ucl_parser_register_variable (struct ucl_parser *parser, const char *var,
- const char *value)
+void ucl_parser_register_variable(struct ucl_parser *parser, const char *var,
+ const char *value)
{
struct ucl_variable *new = NULL, *cur;
}
/* Find whether a variable already exists */
- LL_FOREACH (parser->variables, cur) {
- if (strcmp (cur->var, var) == 0) {
+ LL_FOREACH(parser->variables, cur)
+ {
+ if (strcmp(cur->var, var) == 0) {
new = cur;
break;
}
if (new != NULL) {
/* Remove variable */
- DL_DELETE (parser->variables, new);
- free (new->var);
- free (new->value);
- UCL_FREE (sizeof (struct ucl_variable), new);
+ DL_DELETE(parser->variables, new);
+ free(new->var);
+ free(new->value);
+ UCL_FREE(sizeof(struct ucl_variable), new);
}
else {
/* Do nothing */
}
else {
if (new == NULL) {
- new = UCL_ALLOC (sizeof (struct ucl_variable));
+ new = UCL_ALLOC(sizeof(struct ucl_variable));
if (new == NULL) {
return;
}
- memset (new, 0, sizeof (struct ucl_variable));
- new->var = strdup (var);
- new->var_len = strlen (var);
- new->value = strdup (value);
- new->value_len = strlen (value);
+ memset(new, 0, sizeof(struct ucl_variable));
+ new->var = strdup(var);
+ new->var_len = strlen(var);
+ new->value = strdup(value);
+ new->value_len = strlen(value);
- DL_APPEND (parser->variables, new);
+ DL_APPEND(parser->variables, new);
}
else {
- free (new->value);
- new->value = strdup (value);
- new->value_len = strlen (value);
+ free(new->value);
+ new->value = strdup(value);
+ new->value_len = strlen(value);
}
}
}
-void
-ucl_parser_set_variables_handler (struct ucl_parser *parser,
- ucl_variable_handler handler, void *ud)
+void ucl_parser_set_variables_handler(struct ucl_parser *parser,
+ ucl_variable_handler handler, void *ud)
{
parser->var_handler = handler;
parser->var_data = ud;
}
-bool
-ucl_parser_add_chunk_full (struct ucl_parser *parser, const unsigned char *data,
- size_t len, unsigned priority, enum ucl_duplicate_strategy strat,
- enum ucl_parse_type parse_type)
+bool ucl_parser_add_chunk_full(struct ucl_parser *parser, const unsigned char *data,
+ size_t len, unsigned priority, enum ucl_duplicate_strategy strat,
+ enum ucl_parse_type parse_type)
{
struct ucl_chunk *chunk;
struct ucl_parser_special_handler *special_handler;
}
if (data == NULL && len != 0) {
- ucl_create_err (&parser->err, "invalid chunk added");
+ ucl_create_err(&parser->err, "invalid chunk added");
return false;
}
if (parser->state != UCL_STATE_ERROR) {
- chunk = UCL_ALLOC (sizeof (struct ucl_chunk));
+ chunk = UCL_ALLOC(sizeof(struct ucl_chunk));
if (chunk == NULL) {
- ucl_create_err (&parser->err, "cannot allocate chunk structure");
+ ucl_create_err(&parser->err, "cannot allocate chunk structure");
return false;
}
- memset (chunk, 0, sizeof (*chunk));
+ memset(chunk, 0, sizeof(*chunk));
/* Apply all matching handlers from the first to the last */
- LL_FOREACH (parser->special_handlers, special_handler) {
+ LL_FOREACH(parser->special_handlers, special_handler)
+ {
if ((special_handler->flags & UCL_SPECIAL_HANDLER_PREPROCESS_ALL) ||
- (len >= special_handler->magic_len &&
- memcmp (data, special_handler->magic, special_handler->magic_len) == 0)) {
+ (len >= special_handler->magic_len &&
+ memcmp(data, special_handler->magic, special_handler->magic_len) == 0)) {
unsigned char *ndata = NULL;
size_t nlen = 0;
- if (!special_handler->handler (parser, data, len, &ndata, &nlen,
- special_handler->user_data)) {
- UCL_FREE(sizeof (struct ucl_chunk), chunk);
- ucl_create_err (&parser->err, "call for external handler failed");
+ if (!special_handler->handler(parser, data, len, &ndata, &nlen,
+ special_handler->user_data)) {
+ UCL_FREE(sizeof(struct ucl_chunk), chunk);
+ ucl_create_err(&parser->err, "call for external handler failed");
return false;
}
struct ucl_parser_special_handler_chain *nchain;
- nchain = UCL_ALLOC (sizeof (*nchain));
+ nchain = UCL_ALLOC(sizeof(*nchain));
nchain->begin = ndata;
nchain->len = nlen;
nchain->special_handler = special_handler;
/* Free order is reversed */
- LL_PREPEND (chunk->special_handlers, nchain);
+ LL_PREPEND(chunk->special_handlers, nchain);
data = ndata;
len = nlen;
chunk->parse_type = parse_type;
if (parser->cur_file) {
- chunk->fname = strdup (parser->cur_file);
+ chunk->fname = strdup(parser->cur_file);
}
- LL_PREPEND (parser->chunks, chunk);
- parser->recursion ++;
+ LL_PREPEND(parser->chunks, chunk);
+ parser->recursion++;
if (parser->recursion > UCL_MAX_RECURSION) {
- ucl_create_err (&parser->err, "maximum include nesting limit is reached: %d",
- parser->recursion);
+ ucl_create_err(&parser->err, "maximum include nesting limit is reached: %d",
+ parser->recursion);
return false;
}
switch (parse_type) {
default:
case UCL_PARSE_UCL:
- return ucl_state_machine (parser);
+ return ucl_state_machine(parser);
case UCL_PARSE_MSGPACK:
- return ucl_parse_msgpack (parser);
+ return ucl_parse_msgpack(parser);
case UCL_PARSE_CSEXP:
- return ucl_parse_csexp (parser);
+ return ucl_parse_csexp(parser);
}
}
else {
* In case of empty object, create one to indicate that we've
* read something
*/
- parser->top_obj = ucl_object_new_full (UCL_OBJECT, priority);
+ parser->top_obj = ucl_object_new_full(UCL_OBJECT, priority);
}
return true;
}
}
- ucl_create_err (&parser->err, "a parser is in an invalid state");
+ ucl_create_err(&parser->err, "a parser is in an invalid state");
return false;
}
-bool
-ucl_parser_add_chunk_priority (struct ucl_parser *parser,
- const unsigned char *data, size_t len, unsigned priority)
+bool ucl_parser_add_chunk_priority(struct ucl_parser *parser,
+ const unsigned char *data, size_t len, unsigned priority)
{
/* We dereference parser, so this check is essential */
if (parser == NULL) {
return false;
}
- return ucl_parser_add_chunk_full (parser, data, len,
- priority, UCL_DUPLICATE_APPEND, UCL_PARSE_UCL);
+ return ucl_parser_add_chunk_full(parser, data, len,
+ priority, UCL_DUPLICATE_APPEND, UCL_PARSE_UCL);
}
-bool
-ucl_parser_add_chunk (struct ucl_parser *parser, const unsigned char *data,
- size_t len)
+bool ucl_parser_add_chunk(struct ucl_parser *parser, const unsigned char *data,
+ size_t len)
{
if (parser == NULL) {
return false;
}
- return ucl_parser_add_chunk_full (parser, data, len,
- parser->default_priority, UCL_DUPLICATE_APPEND, UCL_PARSE_UCL);
+ return ucl_parser_add_chunk_full(parser, data, len,
+ parser->default_priority, UCL_DUPLICATE_APPEND, UCL_PARSE_UCL);
}
-bool
-ucl_parser_insert_chunk (struct ucl_parser *parser, const unsigned char *data,
- size_t len)
+bool ucl_parser_insert_chunk(struct ucl_parser *parser, const unsigned char *data,
+ size_t len)
{
if (parser == NULL || parser->top_obj == NULL) {
return false;
parser->stack->e.params.level = parser->stack->next->e.params.level;
}
- res = ucl_parser_add_chunk_full (parser, data, len, parser->chunks->priority,
- parser->chunks->strategy, parser->chunks->parse_type);
+ res = ucl_parser_add_chunk_full(parser, data, len, parser->chunks->priority,
+ parser->chunks->strategy, parser->chunks->parse_type);
/* Remove chunk from the stack */
chunk = parser->chunks;
if (chunk != NULL) {
parser->chunks = chunk->next;
- ucl_chunk_free (chunk);
- parser->recursion --;
+ ucl_chunk_free(chunk);
+ parser->recursion--;
}
parser->state = state;
return res;
}
-bool
-ucl_parser_add_string_priority (struct ucl_parser *parser, const char *data,
- size_t len, unsigned priority)
+bool ucl_parser_add_string_priority(struct ucl_parser *parser, const char *data,
+ size_t len, unsigned priority)
{
if (data == NULL) {
- ucl_create_err (&parser->err, "invalid string added");
+ ucl_create_err(&parser->err, "invalid string added");
return false;
}
if (len == 0) {
- len = strlen (data);
+ len = strlen(data);
}
- return ucl_parser_add_chunk_priority (parser,
- (const unsigned char *)data, len, priority);
+ return ucl_parser_add_chunk_priority(parser,
+ (const unsigned char *) data, len, priority);
}
-bool
-ucl_parser_add_string (struct ucl_parser *parser, const char *data,
- size_t len)
+bool ucl_parser_add_string(struct ucl_parser *parser, const char *data,
+ size_t len)
{
if (parser == NULL) {
return false;
}
- return ucl_parser_add_string_priority (parser,
- (const unsigned char *)data, len, parser->default_priority);
+ return ucl_parser_add_string_priority(parser,
+ (const unsigned char *) data, len, parser->default_priority);
}
-bool
-ucl_set_include_path (struct ucl_parser *parser, ucl_object_t *paths)
+bool ucl_set_include_path(struct ucl_parser *parser, ucl_object_t *paths)
{
if (parser == NULL || paths == NULL || paths->type != UCL_ARRAY) {
return false;
}
if (parser->includepaths == NULL) {
- parser->includepaths = ucl_object_copy (paths);
+ parser->includepaths = ucl_object_copy(paths);
}
else {
- ucl_object_unref (parser->includepaths);
- parser->includepaths = ucl_object_copy (paths);
+ ucl_object_unref(parser->includepaths);
+ parser->includepaths = ucl_object_copy(paths);
}
if (parser->includepaths == NULL) {
return true;
}
-unsigned char ucl_parser_chunk_peek (struct ucl_parser *parser)
+unsigned char ucl_parser_chunk_peek(struct ucl_parser *parser)
{
if (parser == NULL || parser->chunks == NULL || parser->chunks->pos == NULL || parser->chunks->end == NULL ||
parser->chunks->pos == parser->chunks->end) {
return 0;
}
- return( *parser->chunks->pos );
+ return (*parser->chunks->pos);
}
-bool ucl_parser_chunk_skip (struct ucl_parser *parser)
+bool ucl_parser_chunk_skip(struct ucl_parser *parser)
{
if (parser == NULL || parser->chunks == NULL || parser->chunks->pos == NULL || parser->chunks->end == NULL ||
parser->chunks->pos == parser->chunks->end) {
}
const unsigned char *p = parser->chunks->pos;
- ucl_chunk_skipc( parser->chunks, p );
- if( parser->chunks->pos != NULL ) return true;
+ ucl_chunk_skipc(parser->chunks, p);
+ if (parser->chunks->pos != NULL) return true;
return false;
}
-ucl_object_t*
-ucl_parser_get_current_stack_object (struct ucl_parser *parser, unsigned int depth)
+ucl_object_t *
+ucl_parser_get_current_stack_object(struct ucl_parser *parser, unsigned int depth)
{
ucl_object_t *obj;
}
struct ucl_stack *stack = parser->stack;
- if(stack == NULL || stack->obj == NULL || ucl_object_type (stack->obj) != UCL_OBJECT)
- {
+ if (stack == NULL || stack->obj == NULL || ucl_object_type(stack->obj) != UCL_OBJECT) {
return NULL;
}
- for( unsigned int i = 0; i < depth; ++i )
- {
+ for (unsigned int i = 0; i < depth; ++i) {
stack = stack->next;
- if(stack == NULL || stack->obj == NULL || ucl_object_type (stack->obj) != UCL_OBJECT)
- {
+ if (stack == NULL || stack->obj == NULL || ucl_object_type(stack->obj) != UCL_OBJECT) {
return NULL;
}
}
- obj = ucl_object_ref (stack->obj);
+ obj = ucl_object_ref(stack->obj);
return obj;
}
-
projects / thirdparty / rspamd.git / commitdiff
