From: Vsevolod Stakhov Date: Thu, 30 Oct 2025 10:17:31 +0000 (+0000) Subject: [Minor] Update libucl with automatic stack management X-Git-Tag: 3.14.0~29 X-Git-Url: http://git.ipfire.org/?a=commitdiff_plain;h=0f8eb2b6b6c9528848ff337c252acd505caa956a;p=thirdparty%2Frspamd.git [Minor] Update libucl with automatic stack management Merge changes from upstream libucl commit 26bec99: - Add UCL_STACK_AUTOMATIC flag for automatic stack preservation - Modify stack cleanup to conditionally preserve automatic stacks - Enable parsing of included files without outer braces This allows parsing of UCL configurations that include files with content like 'key = value;' without requiring explicit braces, improving compatibility with various UCL file formats. --- diff --git a/contrib/libucl/ucl_internal.h b/contrib/libucl/ucl_internal.h index a7dd6eeaca..a472fed328 100644 --- a/contrib/libucl/ucl_internal.h +++ b/contrib/libucl/ucl_internal.h @@ -188,7 +188,8 @@ struct ucl_macro { enum ucl_stack_flags { UCL_STACK_HAS_OBRACE = (1u << 0), - UCL_STACK_MAX = (1u << 1), + UCL_STACK_AUTOMATIC = (1u << 1), + UCL_STACK_MAX = (1u << 2), }; struct ucl_stack { diff --git a/contrib/libucl/ucl_parser.c b/contrib/libucl/ucl_parser.c index e56a010ffc..11dd991cb9 100644 --- a/contrib/libucl/ucl_parser.c +++ b/contrib/libucl/ucl_parser.c @@ -45,23 +45,24 @@ struct ucl_parser_saved_state { * @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; @@ -74,21 +75,21 @@ ucl_set_err (struct ucl_parser *parser, int code, const char *str, UT_string **e } 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; @@ -96,16 +97,16 @@ ucl_set_err (struct ucl_parser *parser, int code, const char *str, UT_string **e } 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; @@ -114,11 +115,11 @@ ucl_save_comment (struct ucl_parser *parser, const char *begin, size_t len) } 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; @@ -134,7 +135,7 @@ ucl_attach_comment (struct ucl_parser *parser, ucl_object_t *obj, bool before) * @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; @@ -146,30 +147,30 @@ ucl_skip_comments (struct ucl_parser *parser) 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) != '\\') { @@ -178,41 +179,41 @@ start: 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; @@ -225,20 +226,20 @@ start: * @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; } @@ -256,21 +257,21 @@ ucl_lex_num_multiplier (const unsigned char c, bool is_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; } } @@ -284,13 +285,13 @@ ucl_lex_time_multiplier (const unsigned char c) { * @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 == '*') { @@ -314,18 +315,19 @@ ucl_lex_is_comment (const unsigned char c1, const unsigned char 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); @@ -334,7 +336,7 @@ ucl_check_variable_safe (struct ucl_parser *parser, const char *ptr, size_t rema } 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); @@ -346,13 +348,13 @@ ucl_check_variable_safe (struct ucl_parser *parser, const char *ptr, size_t rema /* 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); } @@ -371,8 +373,8 @@ ucl_check_variable_safe (struct ucl_parser *parser, const char *ptr, size_t rema * @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; @@ -383,11 +385,11 @@ ucl_check_variable (struct ucl_parser *parser, const char *ptr, 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; } @@ -397,25 +399,25 @@ ucl_check_variable (struct ucl_parser *parser, const char *ptr, } 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; @@ -431,8 +433,8 @@ ucl_check_variable (struct ucl_parser *parser, const char *ptr, * @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; @@ -444,7 +446,7 @@ ucl_expand_single_variable (struct ucl_parser *parser, const char *ptr, ret = ptr + 1; /* For the $ sign */ - in_len --; + in_len--; if (*p == '$') { *d++ = *p++; @@ -452,17 +454,18 @@ ucl_expand_single_variable (struct ucl_parser *parser, const char *ptr, 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; @@ -476,12 +479,12 @@ ucl_expand_single_variable (struct ucl_parser *parser, const char *ptr, 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 { @@ -501,13 +504,13 @@ ucl_expand_single_variable (struct ucl_parser *parser, const char *ptr, 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++; } } } @@ -525,8 +528,8 @@ ucl_expand_single_variable (struct ucl_parser *parser, const char *ptr, * @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; @@ -541,11 +544,11 @@ ucl_expand_variable (struct ucl_parser *parser, unsigned char **dst, 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++; } } @@ -555,7 +558,7 @@ ucl_expand_variable (struct ucl_parser *parser, unsigned char **dst, return in_len; } - *dst = UCL_ALLOC (out_len + 1); + *dst = UCL_ALLOC(out_len + 1); if (*dst == NULL) { return in_len; } @@ -565,7 +568,7 @@ ucl_expand_variable (struct ucl_parser *parser, unsigned char **dst, 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++; @@ -591,45 +594,45 @@ ucl_expand_variable (struct ucl_parser *parser, unsigned char **dst, * @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; @@ -637,7 +640,7 @@ ucl_copy_or_store_ptr (struct ucl_parser *parser, } else { /* Free unexpanded value */ - UCL_FREE (in_len + 1, tmp); + UCL_FREE(in_len + 1, tmp); } } *dst_const = *dst; @@ -658,23 +661,24 @@ ucl_copy_or_store_ptr (struct ucl_parser *parser, * @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; } @@ -684,17 +688,18 @@ ucl_parser_add_container (ucl_object_t *obj, struct ucl_parser *parser, 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; @@ -703,14 +708,14 @@ ucl_parser_add_container (ucl_object_t *obj, struct ucl_parser *parser, 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; } @@ -727,50 +732,49 @@ ucl_parser_add_container (ucl_object_t *obj, struct ucl_parser *parser, 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) { @@ -787,7 +791,7 @@ ucl_maybe_parse_number (ucl_object_t *obj, else { got_dot = true; need_double = true; - p ++; + p++; } } else if (*p == 'e' || *p == 'E') { @@ -799,18 +803,18 @@ ucl_maybe_parse_number (ucl_object_t *obj, 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++; } } } @@ -836,29 +840,29 @@ ucl_maybe_parse_number (ucl_object_t *obj, 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) { @@ -869,13 +873,13 @@ ucl_maybe_parse_number (ucl_object_t *obj, /* 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; } @@ -901,10 +905,10 @@ ucl_maybe_parse_number (ucl_object_t *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; } @@ -916,28 +920,28 @@ ucl_maybe_parse_number (ucl_object_t *obj, 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; @@ -946,7 +950,7 @@ ucl_maybe_parse_number (ucl_object_t *obj, 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; } @@ -956,13 +960,13 @@ ucl_maybe_parse_number (ucl_object_t *obj, } 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; } @@ -972,12 +976,12 @@ ucl_maybe_parse_number (ucl_object_t *obj, 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; } @@ -991,14 +995,14 @@ ucl_maybe_parse_number (ucl_object_t *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; @@ -1049,14 +1053,14 @@ set_obj: * @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; @@ -1065,8 +1069,8 @@ ucl_lex_number (struct ucl_parser *parser, 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; @@ -1082,11 +1086,11 @@ ucl_lex_number (struct ucl_parser *parser, * @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; @@ -1097,43 +1101,43 @@ ucl_lex_json_string (struct ucl_parser *parser, 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; @@ -1141,21 +1145,21 @@ ucl_lex_json_string (struct ucl_parser *parser, 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; } @@ -1167,8 +1171,8 @@ ucl_lex_json_string (struct ucl_parser *parser, * @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; @@ -1176,68 +1180,67 @@ ucl_lex_squoted_string (struct ucl_parser *parser, 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; @@ -1245,9 +1248,10 @@ ucl_parser_process_object_element (struct ucl_parser *parser, ucl_object_t *nobj 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; @@ -1257,18 +1261,18 @@ ucl_parser_process_object_element (struct ucl_parser *parser, ucl_object_t *nobj 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: @@ -1286,7 +1290,7 @@ ucl_parser_process_object_element (struct ucl_parser *parser, ucl_object_t *nobj } if (priold == prinew) { - ucl_parser_append_elt (parser, container, tobj, nobj); + ucl_parser_append_elt(parser, container, tobj, nobj); } else if (priold > prinew) { /* @@ -1294,27 +1298,27 @@ ucl_parser_process_object_element (struct ucl_parser *parser, ucl_object_t *nobj * 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: @@ -1323,11 +1327,11 @@ ucl_parser_process_object_element (struct ucl_parser *parser, ucl_object_t *nobj * 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) { /* @@ -1335,11 +1339,11 @@ ucl_parser_process_object_element (struct ucl_parser *parser, ucl_object_t *nobj * 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; } @@ -1347,7 +1351,7 @@ ucl_parser_process_object_element (struct ucl_parser *parser, ucl_object_t *nobj parser->stack->obj->value.ov = container; parser->cur_obj = nobj; - ucl_attach_comment (parser, nobj, false); + ucl_attach_comment(parser, nobj, false); return true; } @@ -1361,21 +1365,21 @@ ucl_parser_process_object_element (struct ucl_parser *parser, ucl_object_t *nobj * @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; @@ -1386,19 +1390,19 @@ ucl_parse_key (struct ucl_parser *parser, struct ucl_chunk *chunk, * 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 == '"') { @@ -1406,7 +1410,7 @@ ucl_parse_key (struct ucl_parser *parser, struct ucl_chunk *chunk, 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 */ @@ -1414,38 +1418,38 @@ ucl_parse_key (struct ucl_parser *parser, struct ucl_chunk *chunk, 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 */ @@ -1457,7 +1461,7 @@ ucl_parse_key (struct ucl_parser *parser, struct ucl_chunk *chunk, } 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) { @@ -1466,34 +1470,34 @@ ucl_parse_key (struct ucl_parser *parser, struct ucl_chunk *chunk, *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; @@ -1505,7 +1509,7 @@ ucl_parse_key (struct ucl_parser *parser, struct ucl_chunk *chunk, } 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; } @@ -1521,8 +1525,8 @@ ucl_parse_key (struct ucl_parser *parser, struct ucl_chunk *chunk, */ 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 != '[') { @@ -1534,33 +1538,33 @@ ucl_parse_key (struct ucl_parser *parser, struct ucl_chunk *chunk, *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; } @@ -1581,8 +1585,8 @@ ucl_parse_key (struct ucl_parser *parser, struct ucl_chunk *chunk, * @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 { @@ -1598,25 +1602,25 @@ ucl_parse_string_value (struct ucl_parser *parser, /* 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; } } @@ -1625,17 +1629,17 @@ ucl_parse_string_value (struct ucl_parser *parser, } 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; @@ -1652,10 +1656,10 @@ ucl_parse_string_value (struct ucl_parser *parser, * @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; @@ -1670,11 +1674,11 @@ ucl_parse_multiline_string (struct ucl_parser *parser, 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; @@ -1694,14 +1698,14 @@ ucl_parse_multiline_string (struct ucl_parser *parser, } 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; @@ -1711,16 +1715,16 @@ ucl_parser_get_container (struct ucl_parser *parser) 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 */ @@ -1737,7 +1741,7 @@ ucl_parser_get_container (struct ucl_parser *parser) * @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; @@ -1748,12 +1752,12 @@ ucl_parse_value (struct ucl_parser *parser, struct ucl_chunk *chunk) 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; @@ -1763,24 +1767,24 @@ ucl_parse_value (struct ucl_parser *parser, struct ucl_chunk *chunk) 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; } @@ -1790,13 +1794,13 @@ ucl_parse_value (struct ucl_parser *parser, struct ucl_chunk *chunk) 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; } @@ -1805,10 +1809,10 @@ ucl_parse_value (struct ucl_parser *parser, struct ucl_chunk *chunk) 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; } @@ -1819,17 +1823,17 @@ ucl_parse_value (struct ucl_parser *parser, struct ucl_chunk *chunk) 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; @@ -1838,22 +1842,22 @@ ucl_parse_value (struct ucl_parser *parser, struct ucl_chunk *chunk) 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; @@ -1863,7 +1867,7 @@ ucl_parse_value (struct ucl_parser *parser, struct ucl_chunk *chunk) return false; } - ucl_chunk_skipc (chunk, p); + ucl_chunk_skipc(chunk, p); return true; break; @@ -1878,46 +1882,46 @@ ucl_parse_value (struct ucl_parser *parser, struct ucl_chunk *chunk) } 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; @@ -1931,21 +1935,21 @@ ucl_parse_value (struct ucl_parser *parser, struct ucl_chunk *chunk) /* 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; } @@ -1957,42 +1961,42 @@ parse_string: /* 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; @@ -2015,7 +2019,7 @@ parse_string: * @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; @@ -2024,48 +2028,53 @@ ucl_parse_after_value (struct ucl_parser *parser, struct ucl_chunk *chunk) 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) { @@ -2081,13 +2090,13 @@ ucl_parse_after_value (struct ucl_parser *parser, struct ucl_chunk *chunk) 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; } @@ -2096,21 +2105,21 @@ ucl_parse_after_value (struct ucl_parser *parser, struct ucl_chunk *chunk) 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; @@ -2121,8 +2130,8 @@ ucl_parse_after_value (struct ucl_parser *parser, struct ucl_chunk *chunk) } 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 { @@ -2133,7 +2142,8 @@ ucl_skip_macro_as_comment (struct ucl_parser *parser, 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; @@ -2141,15 +2151,15 @@ ucl_skip_macro_as_comment (struct ucl_parser *parser, 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: @@ -2167,7 +2177,7 @@ ucl_skip_macro_as_comment (struct ucl_parser *parser, continue; } - ucl_chunk_skipc (chunk, p); + ucl_chunk_skipc(chunk, p); break; case macro_has_obrace: @@ -2179,7 +2189,7 @@ ucl_skip_macro_as_comment (struct ucl_parser *parser, state = macro_has_symbols; } - ucl_chunk_skipc (chunk, p); + ucl_chunk_skipc(chunk, p); break; case macro_has_sqbrace: @@ -2191,7 +2201,7 @@ ucl_skip_macro_as_comment (struct ucl_parser *parser, state = macro_save; } - ucl_chunk_skipc (chunk, p); + ucl_chunk_skipc(chunk, p); break; case macro_has_quote: @@ -2203,17 +2213,17 @@ ucl_skip_macro_as_comment (struct ucl_parser *parser, 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; @@ -2233,9 +2243,9 @@ ucl_skip_macro_as_comment (struct ucl_parser *parser, * @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; @@ -2246,8 +2256,8 @@ ucl_parse_macro_value (struct ucl_parser *parser, 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; } @@ -2257,11 +2267,11 @@ ucl_parse_macro_value (struct ucl_parser *parser, 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; @@ -2272,20 +2282,20 @@ ucl_parse_macro_value (struct ucl_parser *parser, 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; @@ -2295,10 +2305,10 @@ ucl_parse_macro_value (struct ucl_parser *parser, /* 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; } @@ -2310,8 +2320,8 @@ ucl_parse_macro_value (struct ucl_parser *parser, * @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; @@ -2331,7 +2341,7 @@ ucl_parse_macro_arguments (struct ucl_parser *parser, } /* Set begin and start */ - ucl_chunk_skipc (chunk, p); + ucl_chunk_skipc(chunk, p); c = p; while ((p) < (chunk)->end) { @@ -2339,10 +2349,10 @@ ucl_parse_macro_arguments (struct ucl_parser *parser, case 0: /* Parse symbols and check for '(', ')' and '"' */ if (*p == '(') { - obraces ++; + obraces++; } else if (*p == ')') { - ebraces ++; + ebraces++; } else if (*p == '"') { state = 1; @@ -2352,13 +2362,13 @@ ucl_parse_macro_arguments (struct ucl_parser *parser, 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 */ @@ -2368,23 +2378,23 @@ ucl_parse_macro_arguments (struct ucl_parser *parser, 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; @@ -2403,20 +2413,21 @@ restore_chunk: 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 @@ -2424,7 +2435,7 @@ restore_chunk: * @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; @@ -2447,7 +2458,7 @@ ucl_state_machine (struct ucl_parser *parser) * 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; @@ -2456,9 +2467,9 @@ ucl_state_machine (struct ucl_parser *parser) 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; @@ -2466,13 +2477,13 @@ ucl_state_machine (struct ucl_parser *parser) 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; } @@ -2484,12 +2495,12 @@ ucl_state_machine (struct ucl_parser *parser) 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) { @@ -2499,14 +2510,15 @@ ucl_state_machine (struct ucl_parser *parser) 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 */ @@ -2515,8 +2527,9 @@ ucl_state_machine (struct ucl_parser *parser) } 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; @@ -2524,7 +2537,7 @@ ucl_state_machine (struct ucl_parser *parser) 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; @@ -2538,11 +2551,11 @@ ucl_state_machine (struct ucl_parser *parser) 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; } @@ -2559,7 +2572,7 @@ ucl_state_machine (struct ucl_parser *parser) 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; @@ -2568,7 +2581,7 @@ ucl_state_machine (struct ucl_parser *parser) 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; @@ -2592,13 +2605,13 @@ ucl_state_machine (struct ucl_parser *parser) 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; } @@ -2608,25 +2621,25 @@ ucl_state_machine (struct ucl_parser *parser) } } 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; } @@ -2636,11 +2649,11 @@ ucl_state_machine (struct ucl_parser *parser) } 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; } @@ -2649,7 +2662,7 @@ ucl_state_machine (struct ucl_parser *parser) 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); @@ -2658,46 +2671,46 @@ ucl_state_machine (struct ucl_parser *parser) 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); } /* @@ -2707,7 +2720,7 @@ ucl_state_machine (struct ucl_parser *parser) p = chunk->pos; if (macro_args) { - ucl_object_unref (macro_args); + ucl_object_unref(macro_args); } if (!ret) { @@ -2718,8 +2731,8 @@ ucl_state_machine (struct ucl_parser *parser) /* 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; } @@ -2727,16 +2740,16 @@ ucl_state_machine (struct ucl_parser *parser) 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); } } @@ -2744,19 +2757,20 @@ ucl_state_machine (struct ucl_parser *parser) 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; } @@ -2772,22 +2786,23 @@ ucl_state_machine (struct ucl_parser *parser) 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); @@ -2800,12 +2815,12 @@ ucl_parser_new (int flags) 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; @@ -2814,8 +2829,7 @@ e0: 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; @@ -2826,8 +2840,7 @@ ucl_parser_set_default_priority (struct ucl_parser *parser, unsigned prio) 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; @@ -2836,9 +2849,8 @@ ucl_parser_get_default_priority (struct ucl_parser *parser) 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; @@ -2846,26 +2858,25 @@ ucl_parser_register_macro (struct ucl_parser *parser, const char *macro, 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; @@ -2873,27 +2884,26 @@ ucl_parser_register_context_macro (struct ucl_parser *parser, const char *macro, 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; @@ -2902,8 +2912,9 @@ ucl_parser_register_variable (struct ucl_parser *parser, const char *var, } /* 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; } @@ -2913,10 +2924,10 @@ ucl_parser_register_variable (struct ucl_parser *parser, const char *var, 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 */ @@ -2925,38 +2936,36 @@ ucl_parser_register_variable (struct ucl_parser *parser, const char *var, } 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; @@ -2966,43 +2975,44 @@ ucl_parser_add_chunk_full (struct ucl_parser *parser, const unsigned char *data, } 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; @@ -3033,15 +3043,15 @@ ucl_parser_add_chunk_full (struct ucl_parser *parser, const unsigned char *data, 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; } @@ -3050,11 +3060,11 @@ ucl_parser_add_chunk_full (struct ucl_parser *parser, const unsigned char *data, 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 { @@ -3064,46 +3074,43 @@ ucl_parser_add_chunk_full (struct ucl_parser *parser, const unsigned char *data, * 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; @@ -3120,15 +3127,15 @@ ucl_parser_insert_chunk (struct ucl_parser *parser, const unsigned char *data, 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; @@ -3136,47 +3143,44 @@ ucl_parser_insert_chunk (struct ucl_parser *parser, const unsigned char *data, 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) { @@ -3186,17 +3190,17 @@ ucl_set_include_path (struct ucl_parser *parser, ucl_object_t *paths) 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) { @@ -3204,13 +3208,13 @@ bool ucl_parser_chunk_skip (struct ucl_parser *parser) } 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; @@ -3219,21 +3223,17 @@ ucl_parser_get_current_stack_object (struct ucl_parser *parser, unsigned int dep } 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; } -