diff options
Diffstat (limited to 'src/ucl_msgpack.c')
| -rw-r--r-- | src/ucl_msgpack.c | 1188 |
1 files changed, 562 insertions, 626 deletions
diff --git a/src/ucl_msgpack.c b/src/ucl_msgpack.c index 3335e39cd9e7..536ac4881aa8 100644 --- a/src/ucl_msgpack.c +++ b/src/ucl_msgpack.c @@ -39,46 +39,51 @@ #endif #if !defined(__LITTLE_ENDIAN__) && !defined(__BIG_ENDIAN__) - #if __BYTE_ORDER == __LITTLE_ENDIAN - #define __LITTLE_ENDIAN__ - #elif __BYTE_ORDER == __BIG_ENDIAN - #define __BIG_ENDIAN__ - #elif _WIN32 - #define __LITTLE_ENDIAN__ - #endif +#if __BYTE_ORDER == __LITTLE_ENDIAN +#define __LITTLE_ENDIAN__ +#elif __BYTE_ORDER == __BIG_ENDIAN +#define __BIG_ENDIAN__ +#elif _WIN32 +#define __LITTLE_ENDIAN__ +#endif #endif -#define SWAP_LE_BE16(val) ((uint16_t) ( \ - (uint16_t) ((uint16_t) (val) >> 8) | \ - (uint16_t) ((uint16_t) (val) << 8))) +#define SWAP_LE_BE16(val) ((uint16_t) ((uint16_t) ((uint16_t) (val) >> 8) | \ + (uint16_t) ((uint16_t) (val) << 8))) -#if defined(__clang__) || (defined(__GNUC__) && __GNUC__ >= 4 && defined (__GNUC_MINOR__) && __GNUC_MINOR__ >= 3) -# define SWAP_LE_BE32(val) ((uint32_t)__builtin_bswap32 ((uint32_t)(val))) -# define SWAP_LE_BE64(val) ((uint64_t)__builtin_bswap64 ((uint64_t)(val))) +#if defined(__clang__) || (defined(__GNUC__) && __GNUC__ >= 4 && defined(__GNUC_MINOR__) && __GNUC_MINOR__ >= 3) +#define SWAP_LE_BE32(val) ((uint32_t) __builtin_bswap32((uint32_t) (val))) +#define SWAP_LE_BE64(val) ((uint64_t) __builtin_bswap64((uint64_t) (val))) #else - #define SWAP_LE_BE32(val) ((uint32_t)( \ - (((uint32_t)(val) & (uint32_t)0x000000ffU) << 24) | \ - (((uint32_t)(val) & (uint32_t)0x0000ff00U) << 8) | \ - (((uint32_t)(val) & (uint32_t)0x00ff0000U) >> 8) | \ - (((uint32_t)(val) & (uint32_t)0xff000000U) >> 24))) - - #define SWAP_LE_BE64(val) ((uint64_t)( \ - (((uint64_t)(val) & \ - (uint64_t)(0x00000000000000ffULL)) << 56) | \ - (((uint64_t)(val) & \ - (uint64_t)(0x000000000000ff00ULL)) << 40) | \ - (((uint64_t)(val) & \ - (uint64_t)(0x0000000000ff0000ULL)) << 24) | \ - (((uint64_t)(val) & \ - (uint64_t) (0x00000000ff000000ULL)) << 8) | \ - (((uint64_t)(val) & \ - (uint64_t)(0x000000ff00000000ULL)) >> 8) | \ - (((uint64_t)(val) & \ - (uint64_t)(0x0000ff0000000000ULL)) >> 24) | \ - (((uint64_t)(val) & \ - (uint64_t)(0x00ff000000000000ULL)) >> 40) | \ - (((uint64_t)(val) & \ - (uint64_t)(0xff00000000000000ULL)) >> 56))) +#define SWAP_LE_BE32(val) ((uint32_t) ((((uint32_t) (val) & (uint32_t) 0x000000ffU) << 24) | \ + (((uint32_t) (val) & (uint32_t) 0x0000ff00U) << 8) | \ + (((uint32_t) (val) & (uint32_t) 0x00ff0000U) >> 8) | \ + (((uint32_t) (val) & (uint32_t) 0xff000000U) >> 24))) + +#define SWAP_LE_BE64(val) ((uint64_t) ((((uint64_t) (val) & \ + (uint64_t) (0x00000000000000ffULL)) \ + << 56) | \ + (((uint64_t) (val) & \ + (uint64_t) (0x000000000000ff00ULL)) \ + << 40) | \ + (((uint64_t) (val) & \ + (uint64_t) (0x0000000000ff0000ULL)) \ + << 24) | \ + (((uint64_t) (val) & \ + (uint64_t) (0x00000000ff000000ULL)) \ + << 8) | \ + (((uint64_t) (val) & \ + (uint64_t) (0x000000ff00000000ULL)) >> \ + 8) | \ + (((uint64_t) (val) & \ + (uint64_t) (0x0000ff0000000000ULL)) >> \ + 24) | \ + (((uint64_t) (val) & \ + (uint64_t) (0x00ff000000000000ULL)) >> \ + 40) | \ + (((uint64_t) (val) & \ + (uint64_t) (0xff00000000000000ULL)) >> \ + 56))) #endif #ifdef __LITTLE_ENDIAN__ @@ -89,22 +94,21 @@ #define FROM_BE32 SWAP_LE_BE32 #define FROM_BE64 SWAP_LE_BE64 #else -#define TO_BE16(val) (uint16_t)(val) -#define TO_BE32(val) (uint32_t)(val) -#define TO_BE64(val) (uint64_t)(val) -#define FROM_BE16(val) (uint16_t)(val) -#define FROM_BE32(val) (uint32_t)(val) -#define FROM_BE64(val) (uint64_t)(val) +#define TO_BE16(val) (uint16_t) (val) +#define TO_BE32(val) (uint32_t) (val) +#define TO_BE64(val) (uint64_t) (val) +#define FROM_BE16(val) (uint16_t) (val) +#define FROM_BE32(val) (uint32_t) (val) +#define FROM_BE64(val) (uint64_t) (val) #endif -void -ucl_emitter_print_int_msgpack (struct ucl_emitter_context *ctx, int64_t val) +void ucl_emitter_print_int_msgpack(struct ucl_emitter_context *ctx, int64_t val) { const struct ucl_emitter_functions *func = ctx->func; unsigned char buf[sizeof(uint64_t) + 1]; const unsigned char mask_positive = 0x7f, mask_negative = 0xe0, - uint8_ch = 0xcc, uint16_ch = 0xcd, uint32_ch = 0xce, uint64_ch = 0xcf, - int8_ch = 0xd0, int16_ch = 0xd1, int32_ch = 0xd2, int64_ch = 0xd3; + uint8_ch = 0xcc, uint16_ch = 0xcd, uint32_ch = 0xce, uint64_ch = 0xcf, + int8_ch = 0xd0, int16_ch = 0xd1, int32_ch = 0xd2, int64_ch = 0xd3; unsigned len; if (val >= 0) { @@ -119,25 +123,25 @@ ucl_emitter_print_int_msgpack (struct ucl_emitter_context *ctx, int64_t val) buf[1] = val & 0xff; } else if (val <= UINT16_MAX) { - uint16_t v = TO_BE16 (val); + uint16_t v = TO_BE16(val); len = 3; buf[0] = uint16_ch; - memcpy (&buf[1], &v, sizeof (v)); + memcpy(&buf[1], &v, sizeof(v)); } else if (val <= UINT32_MAX) { - uint32_t v = TO_BE32 (val); + uint32_t v = TO_BE32(val); len = 5; buf[0] = uint32_ch; - memcpy (&buf[1], &v, sizeof (v)); + memcpy(&buf[1], &v, sizeof(v)); } else { - uint64_t v = TO_BE64 (val); + uint64_t v = TO_BE64(val); len = 9; buf[0] = uint64_ch; - memcpy (&buf[1], &v, sizeof (v)); + memcpy(&buf[1], &v, sizeof(v)); } } else { @@ -150,39 +154,38 @@ ucl_emitter_print_int_msgpack (struct ucl_emitter_context *ctx, int64_t val) buf[0] = (mask_negative | uval) & 0xff; } else if (uval <= INT8_MAX) { - uint8_t v = (uint8_t)val; + uint8_t v = (uint8_t) val; len = 2; buf[0] = int8_ch; buf[1] = v; } else if (uval <= INT16_MAX) { - uint16_t v = TO_BE16 (val); + uint16_t v = TO_BE16(val); len = 3; buf[0] = int16_ch; - memcpy (&buf[1], &v, sizeof (v)); + memcpy(&buf[1], &v, sizeof(v)); } else if (uval <= INT32_MAX) { - uint32_t v = TO_BE32 (val); + uint32_t v = TO_BE32(val); len = 5; buf[0] = int32_ch; - memcpy (&buf[1], &v, sizeof (v)); + memcpy(&buf[1], &v, sizeof(v)); } else { - uint64_t v = TO_BE64 (val); + uint64_t v = TO_BE64(val); len = 9; buf[0] = int64_ch; - memcpy (&buf[1], &v, sizeof (v)); + memcpy(&buf[1], &v, sizeof(v)); } } - func->ucl_emitter_append_len (buf, len, func->ud); + func->ucl_emitter_append_len(buf, len, func->ud); } -void -ucl_emitter_print_double_msgpack (struct ucl_emitter_context *ctx, double val) +void ucl_emitter_print_double_msgpack(struct ucl_emitter_context *ctx, double val) { const struct ucl_emitter_functions *func = ctx->func; union { @@ -194,25 +197,23 @@ ucl_emitter_print_double_msgpack (struct ucl_emitter_context *ctx, double val) /* Convert to big endian */ u.d = val; - u.i = TO_BE64 (u.i); + u.i = TO_BE64(u.i); buf[0] = dbl_ch; - memcpy (&buf[1], &u.d, sizeof (double)); - func->ucl_emitter_append_len (buf, sizeof (buf), func->ud); + memcpy(&buf[1], &u.d, sizeof(double)); + func->ucl_emitter_append_len(buf, sizeof(buf), func->ud); } -void -ucl_emitter_print_bool_msgpack (struct ucl_emitter_context *ctx, bool val) +void ucl_emitter_print_bool_msgpack(struct ucl_emitter_context *ctx, bool val) { const struct ucl_emitter_functions *func = ctx->func; const unsigned char true_ch = 0xc3, false_ch = 0xc2; - func->ucl_emitter_append_character (val ? true_ch : false_ch, 1, func->ud); + func->ucl_emitter_append_character(val ? true_ch : false_ch, 1, func->ud); } -void -ucl_emitter_print_string_msgpack (struct ucl_emitter_context *ctx, - const char *s, size_t len) +void ucl_emitter_print_string_msgpack(struct ucl_emitter_context *ctx, + const char *s, size_t len) { const struct ucl_emitter_functions *func = ctx->func; const unsigned char fix_mask = 0xA0, l8_ch = 0xd9, l16_ch = 0xda, l32_ch = 0xdb; @@ -229,27 +230,26 @@ ucl_emitter_print_string_msgpack (struct ucl_emitter_context *ctx, buf[1] = len & 0xff; } else if (len <= 0xffff) { - uint16_t bl = TO_BE16 (len); + uint16_t bl = TO_BE16(len); blen = 3; buf[0] = l16_ch; - memcpy (&buf[1], &bl, sizeof (bl)); + memcpy(&buf[1], &bl, sizeof(bl)); } else { - uint32_t bl = TO_BE32 (len); + uint32_t bl = TO_BE32(len); blen = 5; buf[0] = l32_ch; - memcpy (&buf[1], &bl, sizeof (bl)); + memcpy(&buf[1], &bl, sizeof(bl)); } - func->ucl_emitter_append_len (buf, blen, func->ud); - func->ucl_emitter_append_len (s, len, func->ud); + func->ucl_emitter_append_len(buf, blen, func->ud); + func->ucl_emitter_append_len(s, len, func->ud); } -void -ucl_emitter_print_binary_string_msgpack (struct ucl_emitter_context *ctx, - const char *s, size_t len) +void ucl_emitter_print_binary_string_msgpack(struct ucl_emitter_context *ctx, + const char *s, size_t len) { const struct ucl_emitter_functions *func = ctx->func; const unsigned char l8_ch = 0xc4, l16_ch = 0xc5, l32_ch = 0xc6; @@ -262,44 +262,41 @@ ucl_emitter_print_binary_string_msgpack (struct ucl_emitter_context *ctx, buf[1] = len & 0xff; } else if (len <= 0xffff) { - uint16_t bl = TO_BE16 (len); + uint16_t bl = TO_BE16(len); blen = 3; buf[0] = l16_ch; - memcpy (&buf[1], &bl, sizeof (bl)); + memcpy(&buf[1], &bl, sizeof(bl)); } else { - uint32_t bl = TO_BE32 (len); + uint32_t bl = TO_BE32(len); blen = 5; buf[0] = l32_ch; - memcpy (&buf[1], &bl, sizeof (bl)); + memcpy(&buf[1], &bl, sizeof(bl)); } - func->ucl_emitter_append_len (buf, blen, func->ud); - func->ucl_emitter_append_len (s, len, func->ud); + func->ucl_emitter_append_len(buf, blen, func->ud); + func->ucl_emitter_append_len(s, len, func->ud); } -void -ucl_emitter_print_null_msgpack (struct ucl_emitter_context *ctx) +void ucl_emitter_print_null_msgpack(struct ucl_emitter_context *ctx) { const struct ucl_emitter_functions *func = ctx->func; const unsigned char nil = 0xc0; - func->ucl_emitter_append_character (nil, 1, func->ud); + func->ucl_emitter_append_character(nil, 1, func->ud); } -void -ucl_emitter_print_key_msgpack (bool print_key, struct ucl_emitter_context *ctx, - const ucl_object_t *obj) +void ucl_emitter_print_key_msgpack(bool print_key, struct ucl_emitter_context *ctx, + const ucl_object_t *obj) { if (print_key) { - ucl_emitter_print_string_msgpack (ctx, obj->key, obj->keylen); + ucl_emitter_print_string_msgpack(ctx, obj->key, obj->keylen); } } -void -ucl_emitter_print_array_msgpack (struct ucl_emitter_context *ctx, size_t len) +void ucl_emitter_print_array_msgpack(struct ucl_emitter_context *ctx, size_t len) { const struct ucl_emitter_functions *func = ctx->func; const unsigned char fix_mask = 0x90, l16_ch = 0xdc, l32_ch = 0xdd; @@ -311,25 +308,24 @@ ucl_emitter_print_array_msgpack (struct ucl_emitter_context *ctx, size_t len) buf[0] = (len | fix_mask) & 0xff; } else if (len <= 0xffff) { - uint16_t bl = TO_BE16 (len); + uint16_t bl = TO_BE16(len); blen = 3; buf[0] = l16_ch; - memcpy (&buf[1], &bl, sizeof (bl)); + memcpy(&buf[1], &bl, sizeof(bl)); } else { - uint32_t bl = TO_BE32 (len); + uint32_t bl = TO_BE32(len); blen = 5; buf[0] = l32_ch; - memcpy (&buf[1], &bl, sizeof (bl)); + memcpy(&buf[1], &bl, sizeof(bl)); } - func->ucl_emitter_append_len (buf, blen, func->ud); + func->ucl_emitter_append_len(buf, blen, func->ud); } -void -ucl_emitter_print_object_msgpack (struct ucl_emitter_context *ctx, size_t len) +void ucl_emitter_print_object_msgpack(struct ucl_emitter_context *ctx, size_t len) { const struct ucl_emitter_functions *func = ctx->func; const unsigned char fix_mask = 0x80, l16_ch = 0xde, l32_ch = 0xdf; @@ -341,21 +337,21 @@ ucl_emitter_print_object_msgpack (struct ucl_emitter_context *ctx, size_t len) buf[0] = (len | fix_mask) & 0xff; } else if (len <= 0xffff) { - uint16_t bl = TO_BE16 (len); + uint16_t bl = TO_BE16(len); blen = 3; buf[0] = l16_ch; - memcpy (&buf[1], &bl, sizeof (bl)); + memcpy(&buf[1], &bl, sizeof(bl)); } else { - uint32_t bl = TO_BE32 (len); + uint32_t bl = TO_BE32(len); blen = 5; buf[0] = l32_ch; - memcpy (&buf[1], &bl, sizeof (bl)); + memcpy(&buf[1], &bl, sizeof(bl)); } - func->ucl_emitter_append_len (buf, blen, func->ud); + func->ucl_emitter_append_len(buf, blen, func->ud); } @@ -400,33 +396,33 @@ enum ucl_msgpack_format { }; typedef ssize_t (*ucl_msgpack_parse_function)(struct ucl_parser *parser, - struct ucl_stack *container, size_t len, enum ucl_msgpack_format fmt, - const unsigned char *pos, size_t remain); - -static ssize_t ucl_msgpack_parse_map (struct ucl_parser *parser, - struct ucl_stack *container, size_t len, enum ucl_msgpack_format fmt, - const unsigned char *pos, size_t remain); -static ssize_t ucl_msgpack_parse_array (struct ucl_parser *parser, - struct ucl_stack *container, size_t len, enum ucl_msgpack_format fmt, - const unsigned char *pos, size_t remain); -static ssize_t ucl_msgpack_parse_string (struct ucl_parser *parser, - struct ucl_stack *container, size_t len, enum ucl_msgpack_format fmt, - const unsigned char *pos, size_t remain); -static ssize_t ucl_msgpack_parse_int (struct ucl_parser *parser, - struct ucl_stack *container, size_t len, enum ucl_msgpack_format fmt, - const unsigned char *pos, size_t remain); -static ssize_t ucl_msgpack_parse_float (struct ucl_parser *parser, - struct ucl_stack *container, size_t len, enum ucl_msgpack_format fmt, - const unsigned char *pos, size_t remain); -static ssize_t ucl_msgpack_parse_bool (struct ucl_parser *parser, - struct ucl_stack *container, size_t len, enum ucl_msgpack_format fmt, - const unsigned char *pos, size_t remain); -static ssize_t ucl_msgpack_parse_null (struct ucl_parser *parser, - struct ucl_stack *container, size_t len, enum ucl_msgpack_format fmt, - const unsigned char *pos, size_t remain); -static ssize_t ucl_msgpack_parse_ignore (struct ucl_parser *parser, - struct ucl_stack *container, size_t len, enum ucl_msgpack_format fmt, - const unsigned char *pos, size_t remain); + struct ucl_stack *container, size_t len, enum ucl_msgpack_format fmt, + const unsigned char *pos, size_t remain); + +static ssize_t ucl_msgpack_parse_map(struct ucl_parser *parser, + struct ucl_stack *container, size_t len, enum ucl_msgpack_format fmt, + const unsigned char *pos, size_t remain); +static ssize_t ucl_msgpack_parse_array(struct ucl_parser *parser, + struct ucl_stack *container, size_t len, enum ucl_msgpack_format fmt, + const unsigned char *pos, size_t remain); +static ssize_t ucl_msgpack_parse_string(struct ucl_parser *parser, + struct ucl_stack *container, size_t len, enum ucl_msgpack_format fmt, + const unsigned char *pos, size_t remain); +static ssize_t ucl_msgpack_parse_int(struct ucl_parser *parser, + struct ucl_stack *container, size_t len, enum ucl_msgpack_format fmt, + const unsigned char *pos, size_t remain); +static ssize_t ucl_msgpack_parse_float(struct ucl_parser *parser, + struct ucl_stack *container, size_t len, enum ucl_msgpack_format fmt, + const unsigned char *pos, size_t remain); +static ssize_t ucl_msgpack_parse_bool(struct ucl_parser *parser, + struct ucl_stack *container, size_t len, enum ucl_msgpack_format fmt, + const unsigned char *pos, size_t remain); +static ssize_t ucl_msgpack_parse_null(struct ucl_parser *parser, + struct ucl_stack *container, size_t len, enum ucl_msgpack_format fmt, + const unsigned char *pos, size_t remain); +static ssize_t ucl_msgpack_parse_ignore(struct ucl_parser *parser, + struct ucl_stack *container, size_t len, enum ucl_msgpack_format fmt, + const unsigned char *pos, size_t remain); #define MSGPACK_FLAG_FIXED (1 << 0) #define MSGPACK_FLAG_CONTAINER (1 << 1) @@ -439,318 +435,245 @@ static ssize_t ucl_msgpack_parse_ignore (struct ucl_parser *parser, * Search tree packed in array */ struct ucl_msgpack_parser { - uint8_t prefix; /* Prefix byte */ - uint8_t prefixlen; /* Length of prefix in bits */ - uint8_t fmt; /* The desired format */ - uint8_t len; /* Length of the object + uint8_t prefix; /* Prefix byte */ + uint8_t prefixlen; /* Length of prefix in bits */ + uint8_t fmt; /* The desired format */ + uint8_t len; /* Length of the object (either length bytes or length of value in case of fixed objects */ - uint8_t flags; /* Flags of the specified type */ - ucl_msgpack_parse_function func; /* Parser function */ + uint8_t flags; /* Flags of the specified type */ + ucl_msgpack_parse_function func; /* Parser function */ } parsers[] = { - { - 0xa0, - 3, - msgpack_fixstr, - 0, - MSGPACK_FLAG_FIXED|MSGPACK_FLAG_KEY, - ucl_msgpack_parse_string - }, - { - 0x0, - 1, - msgpack_positive_fixint, - 0, - MSGPACK_FLAG_FIXED|MSGPACK_FLAG_TYPEVALUE, - ucl_msgpack_parse_int - }, - { - 0xe0, - 3, - msgpack_negative_fixint, - 0, - MSGPACK_FLAG_FIXED|MSGPACK_FLAG_TYPEVALUE, - ucl_msgpack_parse_int - }, - { - 0x80, - 4, - msgpack_fixmap, - 0, - MSGPACK_FLAG_FIXED|MSGPACK_FLAG_CONTAINER|MSGPACK_FLAG_ASSOC, - ucl_msgpack_parse_map - }, - { - 0x90, - 4, - msgpack_fixarray, - 0, - MSGPACK_FLAG_FIXED|MSGPACK_FLAG_CONTAINER, - ucl_msgpack_parse_array - }, - { - 0xd9, - 8, - msgpack_str8, - 1, - MSGPACK_FLAG_KEY, - ucl_msgpack_parse_string - }, - { - 0xc4, - 8, - msgpack_bin8, - 1, - MSGPACK_FLAG_KEY, - ucl_msgpack_parse_string - }, - { - 0xcf, - 8, - msgpack_uint64, - 8, - MSGPACK_FLAG_FIXED, - ucl_msgpack_parse_int - }, - { - 0xd3, - 8, - msgpack_int64, - 8, - MSGPACK_FLAG_FIXED, - ucl_msgpack_parse_int - }, - { - 0xce, - 8, - msgpack_uint32, - 4, - MSGPACK_FLAG_FIXED, - ucl_msgpack_parse_int - }, - { - 0xd2, - 8, - msgpack_int32, - 4, - MSGPACK_FLAG_FIXED, - ucl_msgpack_parse_int - }, - { - 0xcb, - 8, - msgpack_float64, - 8, - MSGPACK_FLAG_FIXED, - ucl_msgpack_parse_float - }, - { - 0xca, - 8, - msgpack_float32, - 4, - MSGPACK_FLAG_FIXED, - ucl_msgpack_parse_float - }, - { - 0xc2, - 8, - msgpack_false, - 1, - MSGPACK_FLAG_FIXED | MSGPACK_FLAG_TYPEVALUE, - ucl_msgpack_parse_bool - }, - { - 0xc3, - 8, - msgpack_true, - 1, - MSGPACK_FLAG_FIXED | MSGPACK_FLAG_TYPEVALUE, - ucl_msgpack_parse_bool - }, - { - 0xcc, - 8, - msgpack_uint8, - 1, - MSGPACK_FLAG_FIXED, - ucl_msgpack_parse_int - }, - { - 0xcd, - 8, - msgpack_uint16, - 2, - MSGPACK_FLAG_FIXED, - ucl_msgpack_parse_int - }, - { - 0xd0, - 8, - msgpack_int8, - 1, - MSGPACK_FLAG_FIXED, - ucl_msgpack_parse_int - }, - { - 0xd1, - 8, - msgpack_int16, - 2, - MSGPACK_FLAG_FIXED, - ucl_msgpack_parse_int - }, - { - 0xc0, - 8, - msgpack_nil, - 0, - MSGPACK_FLAG_FIXED | MSGPACK_FLAG_TYPEVALUE, - ucl_msgpack_parse_null - }, - { - 0xda, - 8, - msgpack_str16, - 2, - MSGPACK_FLAG_KEY, - ucl_msgpack_parse_string - }, - { - 0xdb, - 8, - msgpack_str32, - 4, - MSGPACK_FLAG_KEY, - ucl_msgpack_parse_string - }, - { - 0xc5, - 8, - msgpack_bin16, - 2, - MSGPACK_FLAG_KEY, - ucl_msgpack_parse_string - }, - { - 0xc6, - 8, - msgpack_bin32, - 4, - MSGPACK_FLAG_KEY, - ucl_msgpack_parse_string - }, - { - 0xdc, - 8, - msgpack_array16, - 2, - MSGPACK_FLAG_CONTAINER, - ucl_msgpack_parse_array - }, - { - 0xdd, - 8, - msgpack_array32, - 4, - MSGPACK_FLAG_CONTAINER, - ucl_msgpack_parse_array - }, - { - 0xde, - 8, - msgpack_map16, - 2, - MSGPACK_FLAG_CONTAINER|MSGPACK_FLAG_ASSOC, - ucl_msgpack_parse_map - }, - { - 0xdf, - 8, - msgpack_map32, - 4, - MSGPACK_FLAG_CONTAINER|MSGPACK_FLAG_ASSOC, - ucl_msgpack_parse_map - }, - { - 0xc7, - 8, - msgpack_ext8, - 1, - MSGPACK_FLAG_EXT, - ucl_msgpack_parse_ignore - }, - { - 0xc8, - 8, - msgpack_ext16, - 2, - MSGPACK_FLAG_EXT, - ucl_msgpack_parse_ignore - }, - { - 0xc9, - 8, - msgpack_ext32, - 4, - MSGPACK_FLAG_EXT, - ucl_msgpack_parse_ignore - }, - { - 0xd4, - 8, - msgpack_fixext1, - 1, - MSGPACK_FLAG_FIXED | MSGPACK_FLAG_EXT, - ucl_msgpack_parse_ignore - }, - { - 0xd5, - 8, - msgpack_fixext2, - 2, - MSGPACK_FLAG_FIXED | MSGPACK_FLAG_EXT, - ucl_msgpack_parse_ignore - }, - { - 0xd6, - 8, - msgpack_fixext4, - 4, - MSGPACK_FLAG_FIXED | MSGPACK_FLAG_EXT, - ucl_msgpack_parse_ignore - }, - { - 0xd7, - 8, - msgpack_fixext8, - 8, - MSGPACK_FLAG_FIXED | MSGPACK_FLAG_EXT, - ucl_msgpack_parse_ignore - }, - { - 0xd8, - 8, - msgpack_fixext16, - 16, - MSGPACK_FLAG_FIXED | MSGPACK_FLAG_EXT, - ucl_msgpack_parse_ignore - } -}; + {0xa0, + 3, + msgpack_fixstr, + 0, + MSGPACK_FLAG_FIXED | MSGPACK_FLAG_KEY, + ucl_msgpack_parse_string}, + {0x0, + 1, + msgpack_positive_fixint, + 0, + MSGPACK_FLAG_FIXED | MSGPACK_FLAG_TYPEVALUE, + ucl_msgpack_parse_int}, + {0xe0, + 3, + msgpack_negative_fixint, + 0, + MSGPACK_FLAG_FIXED | MSGPACK_FLAG_TYPEVALUE, + ucl_msgpack_parse_int}, + {0x80, + 4, + msgpack_fixmap, + 0, + MSGPACK_FLAG_FIXED | MSGPACK_FLAG_CONTAINER | MSGPACK_FLAG_ASSOC, + ucl_msgpack_parse_map}, + {0x90, + 4, + msgpack_fixarray, + 0, + MSGPACK_FLAG_FIXED | MSGPACK_FLAG_CONTAINER, + ucl_msgpack_parse_array}, + {0xd9, + 8, + msgpack_str8, + 1, + MSGPACK_FLAG_KEY, + ucl_msgpack_parse_string}, + {0xc4, + 8, + msgpack_bin8, + 1, + MSGPACK_FLAG_KEY, + ucl_msgpack_parse_string}, + {0xcf, + 8, + msgpack_uint64, + 8, + MSGPACK_FLAG_FIXED, + ucl_msgpack_parse_int}, + {0xd3, + 8, + msgpack_int64, + 8, + MSGPACK_FLAG_FIXED, + ucl_msgpack_parse_int}, + {0xce, + 8, + msgpack_uint32, + 4, + MSGPACK_FLAG_FIXED, + ucl_msgpack_parse_int}, + {0xd2, + 8, + msgpack_int32, + 4, + MSGPACK_FLAG_FIXED, + ucl_msgpack_parse_int}, + {0xcb, + 8, + msgpack_float64, + 8, + MSGPACK_FLAG_FIXED, + ucl_msgpack_parse_float}, + {0xca, + 8, + msgpack_float32, + 4, + MSGPACK_FLAG_FIXED, + ucl_msgpack_parse_float}, + {0xc2, + 8, + msgpack_false, + 1, + MSGPACK_FLAG_FIXED | MSGPACK_FLAG_TYPEVALUE, + ucl_msgpack_parse_bool}, + {0xc3, + 8, + msgpack_true, + 1, + MSGPACK_FLAG_FIXED | MSGPACK_FLAG_TYPEVALUE, + ucl_msgpack_parse_bool}, + {0xcc, + 8, + msgpack_uint8, + 1, + MSGPACK_FLAG_FIXED, + ucl_msgpack_parse_int}, + {0xcd, + 8, + msgpack_uint16, + 2, + MSGPACK_FLAG_FIXED, + ucl_msgpack_parse_int}, + {0xd0, + 8, + msgpack_int8, + 1, + MSGPACK_FLAG_FIXED, + ucl_msgpack_parse_int}, + {0xd1, + 8, + msgpack_int16, + 2, + MSGPACK_FLAG_FIXED, + ucl_msgpack_parse_int}, + {0xc0, + 8, + msgpack_nil, + 0, + MSGPACK_FLAG_FIXED | MSGPACK_FLAG_TYPEVALUE, + ucl_msgpack_parse_null}, + {0xda, + 8, + msgpack_str16, + 2, + MSGPACK_FLAG_KEY, + ucl_msgpack_parse_string}, + {0xdb, + 8, + msgpack_str32, + 4, + MSGPACK_FLAG_KEY, + ucl_msgpack_parse_string}, + {0xc5, + 8, + msgpack_bin16, + 2, + MSGPACK_FLAG_KEY, + ucl_msgpack_parse_string}, + {0xc6, + 8, + msgpack_bin32, + 4, + MSGPACK_FLAG_KEY, + ucl_msgpack_parse_string}, + {0xdc, + 8, + msgpack_array16, + 2, + MSGPACK_FLAG_CONTAINER, + ucl_msgpack_parse_array}, + {0xdd, + 8, + msgpack_array32, + 4, + MSGPACK_FLAG_CONTAINER, + ucl_msgpack_parse_array}, + {0xde, + 8, + msgpack_map16, + 2, + MSGPACK_FLAG_CONTAINER | MSGPACK_FLAG_ASSOC, + ucl_msgpack_parse_map}, + {0xdf, + 8, + msgpack_map32, + 4, + MSGPACK_FLAG_CONTAINER | MSGPACK_FLAG_ASSOC, + ucl_msgpack_parse_map}, + {0xc7, + 8, + msgpack_ext8, + 1, + MSGPACK_FLAG_EXT, + ucl_msgpack_parse_ignore}, + {0xc8, + 8, + msgpack_ext16, + 2, + MSGPACK_FLAG_EXT, + ucl_msgpack_parse_ignore}, + {0xc9, + 8, + msgpack_ext32, + 4, + MSGPACK_FLAG_EXT, + ucl_msgpack_parse_ignore}, + {0xd4, + 8, + msgpack_fixext1, + 1, + MSGPACK_FLAG_FIXED | MSGPACK_FLAG_EXT, + ucl_msgpack_parse_ignore}, + {0xd5, + 8, + msgpack_fixext2, + 2, + MSGPACK_FLAG_FIXED | MSGPACK_FLAG_EXT, + ucl_msgpack_parse_ignore}, + {0xd6, + 8, + msgpack_fixext4, + 4, + MSGPACK_FLAG_FIXED | MSGPACK_FLAG_EXT, + ucl_msgpack_parse_ignore}, + {0xd7, + 8, + msgpack_fixext8, + 8, + MSGPACK_FLAG_FIXED | MSGPACK_FLAG_EXT, + ucl_msgpack_parse_ignore}, + {0xd8, + 8, + msgpack_fixext16, + 16, + MSGPACK_FLAG_FIXED | MSGPACK_FLAG_EXT, + ucl_msgpack_parse_ignore}}; #undef MSGPACK_DEBUG_PARSER static inline struct ucl_msgpack_parser * -ucl_msgpack_get_parser_from_type (unsigned char t) +ucl_msgpack_get_parser_from_type(unsigned char t) { unsigned int i, shift, mask; - for (i = 0; i < sizeof (parsers) / sizeof (parsers[0]); i ++) { + for (i = 0; i < sizeof(parsers) / sizeof(parsers[0]); i++) { shift = CHAR_BIT - parsers[i].prefixlen; mask = parsers[i].prefix >> shift; - if (mask == (((unsigned int)t) >> shift)) { + if (mask == (((unsigned int) t) >> shift)) { return &parsers[i]; } } @@ -759,32 +682,32 @@ ucl_msgpack_get_parser_from_type (unsigned char t) } static inline struct ucl_stack * -ucl_msgpack_get_container (struct ucl_parser *parser, - struct ucl_msgpack_parser *obj_parser, uint64_t len) +ucl_msgpack_get_container(struct ucl_parser *parser, + struct ucl_msgpack_parser *obj_parser, uint64_t len) { struct ucl_stack *stack; - assert (obj_parser != NULL); + assert(obj_parser != NULL); if (obj_parser->flags & MSGPACK_FLAG_CONTAINER) { /* * Insert new container to the stack */ if (parser->stack == NULL) { - parser->stack = calloc (1, sizeof (struct ucl_stack)); + parser->stack = calloc(1, sizeof(struct ucl_stack)); if (parser->stack == NULL) { - ucl_create_err (&parser->err, "no memory"); + ucl_create_err(&parser->err, "no memory"); return NULL; } parser->stack->chunk = parser->chunks; } else { - stack = calloc (1, sizeof (struct ucl_stack)); + stack = calloc(1, sizeof(struct ucl_stack)); if (stack == NULL) { - ucl_create_err (&parser->err, "no memory"); + ucl_create_err(&parser->err, "no memory"); return NULL; } @@ -802,7 +725,7 @@ ucl_msgpack_get_container (struct ucl_parser *parser, stack = stack->next; } - fprintf(stderr, "%s -> %d\n", obj_parser->flags & MSGPACK_FLAG_ASSOC ? "object" : "array", (int)len); + fprintf(stderr, "%s -> %d\n", obj_parser->flags & MSGPACK_FLAG_ASSOC ? "object" : "array", (int) len); #endif } else { @@ -813,7 +736,7 @@ ucl_msgpack_get_container (struct ucl_parser *parser, return parser->stack; } else { - ucl_create_err (&parser->err, "bad top level object for msgpack"); + ucl_create_err(&parser->err, "bad top level object for msgpack"); return NULL; } } @@ -822,9 +745,9 @@ ucl_msgpack_get_container (struct ucl_parser *parser, } static bool -ucl_msgpack_is_container_finished (struct ucl_stack *container) +ucl_msgpack_is_container_finished(struct ucl_stack *container) { - assert (container != NULL); + assert(container != NULL); if (container->e.len == 0) { @@ -835,24 +758,24 @@ ucl_msgpack_is_container_finished (struct ucl_stack *container) } static bool -ucl_msgpack_insert_object (struct ucl_parser *parser, - const unsigned char *key, - size_t keylen, ucl_object_t *obj) +ucl_msgpack_insert_object(struct ucl_parser *parser, + const unsigned char *key, + size_t keylen, ucl_object_t *obj) { struct ucl_stack *container; container = parser->stack; - assert (container != NULL); - assert (container->e.len > 0); - assert (obj != NULL); - assert (container->obj != NULL); + assert(container != NULL); + assert(container->e.len > 0); + assert(obj != NULL); + assert(container->obj != NULL); if (container->obj->type == UCL_ARRAY) { - ucl_array_append (container->obj, obj); + ucl_array_append(container->obj, obj); } else if (container->obj->type == UCL_OBJECT) { if (key == NULL || keylen == 0) { - ucl_create_err (&parser->err, "cannot insert object with no key"); + ucl_create_err(&parser->err, "cannot insert object with no key"); return false; } @@ -860,13 +783,13 @@ ucl_msgpack_insert_object (struct ucl_parser *parser, obj->keylen = keylen; if (!(parser->flags & UCL_PARSER_ZEROCOPY)) { - ucl_copy_key_trash (obj); + ucl_copy_key_trash(obj); } - ucl_parser_process_object_element (parser, obj); + ucl_parser_process_object_element(parser, obj); } else { - ucl_create_err (&parser->err, "bad container type"); + ucl_create_err(&parser->err, "bad container type"); return false; } @@ -876,7 +799,7 @@ ucl_msgpack_insert_object (struct ucl_parser *parser, } static struct ucl_stack * -ucl_msgpack_get_next_container (struct ucl_parser *parser) +ucl_msgpack_get_next_container(struct ucl_parser *parser) { struct ucl_stack *cur = NULL; uint64_t len; @@ -893,18 +816,18 @@ ucl_msgpack_get_next_container (struct ucl_parser *parser) /* We need to switch to the previous container */ parser->stack = cur->next; parser->cur_obj = cur->obj; - free (cur); + free(cur); #ifdef MSGPACK_DEBUG_PARSER cur = parser->stack; - while (cur) { - fprintf(stderr, "-"); - cur = cur->next; - } - fprintf(stderr, "-%s -> %d\n", parser->cur_obj->type == UCL_OBJECT ? "object" : "array", (int)parser->cur_obj->len); + while (cur) { + fprintf(stderr, "-"); + cur = cur->next; + } + fprintf(stderr, "-%s -> %d\n", parser->cur_obj->type == UCL_OBJECT ? "object" : "array", (int) parser->cur_obj->len); #endif - return ucl_msgpack_get_next_container (parser); + return ucl_msgpack_get_next_container(parser); } /* @@ -912,40 +835,41 @@ ucl_msgpack_get_next_container (struct ucl_parser *parser) * message pack blob into the top level container */ - assert (cur->obj != NULL); + assert(cur->obj != NULL); return cur; } -#define CONSUME_RET do { \ - if (ret != -1) { \ - p += ret; \ - remain -= ret; \ - obj_parser = NULL; \ - assert (remain >= 0); \ - } \ - else { \ - ucl_create_err (&parser->err, \ - "cannot parse type %d of len %u", \ - (int)obj_parser->fmt, \ - (unsigned)len); \ - return false; \ - } \ -} while(0) - -#define GET_NEXT_STATE do { \ - container = ucl_msgpack_get_next_container (parser); \ - if (container == NULL) { \ - ucl_create_err (&parser->err, \ - "empty container"); \ - return false; \ - } \ - next_state = container->obj->type == UCL_OBJECT ? \ - read_assoc_key : read_array_value; \ -} while(0) +#define CONSUME_RET \ + do { \ + if (ret != -1) { \ + p += ret; \ + remain -= ret; \ + obj_parser = NULL; \ + assert(remain >= 0); \ + } \ + else { \ + ucl_create_err(&parser->err, \ + "cannot parse type %d of len %u", \ + (int) obj_parser->fmt, \ + (unsigned) len); \ + return false; \ + } \ + } while (0) + +#define GET_NEXT_STATE \ + do { \ + container = ucl_msgpack_get_next_container(parser); \ + if (container == NULL) { \ + ucl_create_err(&parser->err, \ + "empty container"); \ + return false; \ + } \ + next_state = container->obj->type == UCL_OBJECT ? read_assoc_key : read_array_value; \ + } while (0) static bool -ucl_msgpack_consume (struct ucl_parser *parser) +ucl_msgpack_consume(struct ucl_parser *parser) { const unsigned char *p, *end, *key = NULL; struct ucl_stack *container; @@ -959,7 +883,8 @@ ucl_msgpack_consume (struct ucl_parser *parser) read_array_value, finish_array_value, error_state - } state = read_type, next_state = error_state; + } state = read_type, + next_state = error_state; struct ucl_msgpack_parser *obj_parser = NULL; uint64_t len = 0; ssize_t ret, remain, keylen = 0; @@ -979,11 +904,11 @@ ucl_msgpack_consume (struct ucl_parser *parser) #endif switch (state) { case read_type: - obj_parser = ucl_msgpack_get_parser_from_type (*p); + obj_parser = ucl_msgpack_get_parser_from_type(*p); if (obj_parser == NULL) { - ucl_create_err (&parser->err, "unknown msgpack format: %x", - (unsigned int)*p); + ucl_create_err(&parser->err, "unknown msgpack format: %x", + (unsigned int) *p); return false; } @@ -995,9 +920,9 @@ ucl_msgpack_consume (struct ucl_parser *parser) } else { if (remain < obj_parser->len) { - ucl_create_err (&parser->err, "not enough data remain to " - "read object's length: %u remain, %u needed", - (unsigned)remain, obj_parser->len); + ucl_create_err(&parser->err, "not enough data remain to " + "read object's length: %u remain, %u needed", + (unsigned) remain, obj_parser->len); return false; } @@ -1008,8 +933,8 @@ ucl_msgpack_consume (struct ucl_parser *parser) if (!(obj_parser->flags & MSGPACK_FLAG_TYPEVALUE)) { /* We must pass value as the second byte */ if (remain > 0) { - p ++; - remain --; + p++; + remain--; } } else { @@ -1019,34 +944,34 @@ ucl_msgpack_consume (struct ucl_parser *parser) } else { /* Length is not embedded */ - remain --; + remain--; if (remain < obj_parser->len) { - ucl_create_err (&parser->err, "not enough data remain to " - "read object's length: %u remain, %u needed", - (unsigned)remain, obj_parser->len); + ucl_create_err(&parser->err, "not enough data remain to " + "read object's length: %u remain, %u needed", + (unsigned) remain, obj_parser->len); return false; } - p ++; + p++; switch (obj_parser->len) { case 1: len = *p; break; case 2: - len = FROM_BE16 (*(uint16_t *)p); + len = FROM_BE16(*(uint16_t *) p); break; case 4: - len = FROM_BE32 (*(uint32_t *)p); + len = FROM_BE32(*(uint32_t *) p); break; case 8: - len = FROM_BE64 (*(uint64_t *)p); + len = FROM_BE64(*(uint64_t *) p); break; default: - ucl_create_err (&parser->err, "invalid length of the length field: %u", - (unsigned)obj_parser->len); + ucl_create_err(&parser->err, "invalid length of the length field: %u", + (unsigned) obj_parser->len); return false; } @@ -1059,7 +984,7 @@ ucl_msgpack_consume (struct ucl_parser *parser) /* We have just read the new associative map */ state = start_assoc; } - else if (obj_parser->flags & MSGPACK_FLAG_CONTAINER){ + else if (obj_parser->flags & MSGPACK_FLAG_CONTAINER) { state = start_array; } else { @@ -1068,22 +993,22 @@ ucl_msgpack_consume (struct ucl_parser *parser) break; case start_assoc: - parser->cur_obj = ucl_object_new_full (UCL_OBJECT, - parser->chunks->priority); + parser->cur_obj = ucl_object_new_full(UCL_OBJECT, + parser->chunks->priority); /* Insert to the previous level container */ - if (parser->stack && !ucl_msgpack_insert_object (parser, - key, keylen, parser->cur_obj)) { + if (parser->stack && !ucl_msgpack_insert_object(parser, + key, keylen, parser->cur_obj)) { return false; } /* Get new container */ - container = ucl_msgpack_get_container (parser, obj_parser, len); + container = ucl_msgpack_get_container(parser, obj_parser, len); if (container == NULL) { return false; } - ret = obj_parser->func (parser, container, len, obj_parser->fmt, - p, remain); + ret = obj_parser->func(parser, container, len, obj_parser->fmt, + p, remain); CONSUME_RET; key = NULL; keylen = 0; @@ -1099,22 +1024,22 @@ ucl_msgpack_consume (struct ucl_parser *parser) break; case start_array: - parser->cur_obj = ucl_object_new_full (UCL_ARRAY, - parser->chunks->priority); + parser->cur_obj = ucl_object_new_full(UCL_ARRAY, + parser->chunks->priority); /* Insert to the previous level container */ - if (parser->stack && !ucl_msgpack_insert_object (parser, - key, keylen, parser->cur_obj)) { + if (parser->stack && !ucl_msgpack_insert_object(parser, + key, keylen, parser->cur_obj)) { return false; } /* Get new container */ - container = ucl_msgpack_get_container (parser, obj_parser, len); + container = ucl_msgpack_get_container(parser, obj_parser, len); if (container == NULL) { return false; } - ret = obj_parser->func (parser, container, len, obj_parser->fmt, - p, remain); + ret = obj_parser->func(parser, container, len, obj_parser->fmt, + p, remain); CONSUME_RET; if (len > 0) { @@ -1135,23 +1060,28 @@ ucl_msgpack_consume (struct ucl_parser *parser) container = parser->stack; if (parser->stack == NULL) { - ucl_create_err (&parser->err, - "read assoc value when no container represented"); + ucl_create_err(&parser->err, + "read assoc value when no container represented"); return false; } - ret = obj_parser->func (parser, container, len, obj_parser->fmt, - p, remain); + ret = obj_parser->func(parser, container, len, obj_parser->fmt, + p, remain); CONSUME_RET; /* Insert value to the container and check if we have finished array */ - if (!ucl_msgpack_insert_object (parser, NULL, 0, - parser->cur_obj)) { - return false; + if (parser->cur_obj) { + if (!ucl_msgpack_insert_object(parser, NULL, 0, + parser->cur_obj)) { + return false; + } + } + else { + /* We have parsed ext, ignore it */ } - if (ucl_msgpack_is_container_finished (container)) { + if (ucl_msgpack_is_container_finished(container)) { state = finish_array_value; } else { @@ -1167,8 +1097,9 @@ ucl_msgpack_consume (struct ucl_parser *parser) * Keys must have string type for ucl msgpack */ if (!(obj_parser->flags & MSGPACK_FLAG_KEY)) { - ucl_create_err (&parser->err, "bad type for key: %u, expected " - "string", (unsigned)obj_parser->fmt); + ucl_create_err(&parser->err, "bad type for key: %u, expected " + "string", + (unsigned) obj_parser->fmt); return false; } @@ -1177,7 +1108,7 @@ ucl_msgpack_consume (struct ucl_parser *parser) keylen = len; if (keylen > remain || keylen == 0) { - ucl_create_err (&parser->err, "too long or empty key"); + ucl_create_err(&parser->err, "too long or empty key"); return false; } @@ -1196,27 +1127,29 @@ ucl_msgpack_consume (struct ucl_parser *parser) container = parser->stack; if (container == NULL) { - ucl_create_err (&parser->err, - "read assoc value when no container represented"); + ucl_create_err(&parser->err, + "read assoc value when no container represented"); return false; } - ret = obj_parser->func (parser, container, len, obj_parser->fmt, - p, remain); + ret = obj_parser->func(parser, container, len, obj_parser->fmt, + p, remain); CONSUME_RET; - assert (key != NULL && keylen > 0); + assert(key != NULL && keylen > 0); - if (!ucl_msgpack_insert_object (parser, key, keylen, - parser->cur_obj)) { + if (parser->cur_obj) { + if (!ucl_msgpack_insert_object(parser, key, keylen, + parser->cur_obj)) { - return false; + return false; + } } key = NULL; keylen = 0; - if (ucl_msgpack_is_container_finished (container)) { + if (ucl_msgpack_is_container_finished(container)) { state = finish_assoc_value; } else { @@ -1233,7 +1166,7 @@ ucl_msgpack_consume (struct ucl_parser *parser) break; case error_state: - ucl_create_err (&parser->err, "invalid state machine state"); + ucl_create_err(&parser->err, "invalid state machine state"); return false; } @@ -1245,42 +1178,42 @@ ucl_msgpack_consume (struct ucl_parser *parser) case start_assoc: /* Empty container at the end */ if (len != 0) { - ucl_create_err (&parser->err, - "invalid non-empty container at the end; len=%zu", - (uintmax_t)len); + ucl_create_err(&parser->err, + "invalid non-empty container at the end; len=%zu", + (uintmax_t) len); return false; } - parser->cur_obj = ucl_object_new_full ( - state == start_array ? UCL_ARRAY : UCL_OBJECT, - parser->chunks->priority); + parser->cur_obj = ucl_object_new_full( + state == start_array ? UCL_ARRAY : UCL_OBJECT, + parser->chunks->priority); if (parser->stack == NULL) { - ucl_create_err (&parser->err, - "read assoc value when no container represented"); + ucl_create_err(&parser->err, + "read assoc value when no container represented"); return false; } /* Insert to the previous level container */ - if (!ucl_msgpack_insert_object (parser, - key, keylen, parser->cur_obj)) { + if (!ucl_msgpack_insert_object(parser, + key, keylen, parser->cur_obj)) { return false; } /* Get new container */ - container = ucl_msgpack_get_container (parser, obj_parser, len); + container = ucl_msgpack_get_container(parser, obj_parser, len); if (container == NULL) { return false; } - ret = obj_parser->func (parser, container, len, obj_parser->fmt, - p, remain); + ret = obj_parser->func(parser, container, len, obj_parser->fmt, + p, remain); break; case read_array_value: case read_assoc_value: if (len != 0) { - ucl_create_err (&parser->err, "unfinished value at the end"); + ucl_create_err(&parser->err, "unfinished value at the end"); return false; } @@ -1288,20 +1221,22 @@ ucl_msgpack_consume (struct ucl_parser *parser) container = parser->stack; if (parser->stack == NULL) { - ucl_create_err (&parser->err, - "read assoc value when no container represented"); + ucl_create_err(&parser->err, + "read assoc value when no container represented"); return false; } - ret = obj_parser->func (parser, container, len, obj_parser->fmt, - p, remain); + ret = obj_parser->func(parser, container, len, obj_parser->fmt, + p, remain); CONSUME_RET; /* Insert value to the container and check if we have finished array */ - if (!ucl_msgpack_insert_object (parser, NULL, 0, - parser->cur_obj)) { - return false; + if (parser->cur_obj) { + if (!ucl_msgpack_insert_object(parser, NULL, 0, + parser->cur_obj)) { + return false; + } } break; case finish_array_value: @@ -1311,17 +1246,17 @@ ucl_msgpack_consume (struct ucl_parser *parser) break; default: /* Invalid finishing state */ - ucl_create_err (&parser->err, "invalid state machine finishing state: %d", - state); + ucl_create_err(&parser->err, "invalid state machine finishing state: %d", + state); return false; } /* Rewind to the top level container */ - ucl_msgpack_get_next_container (parser); + ucl_msgpack_get_next_container(parser); if (parser->stack != NULL) { - ucl_create_err (&parser->err, "incomplete container"); + ucl_create_err(&parser->err, "incomplete container"); return false; } @@ -1329,17 +1264,16 @@ ucl_msgpack_consume (struct ucl_parser *parser) return true; } -bool -ucl_parse_msgpack (struct ucl_parser *parser) +bool ucl_parse_msgpack(struct ucl_parser *parser) { ucl_object_t *container = NULL; const unsigned char *p; bool ret; - assert (parser != NULL); - assert (parser->chunks != NULL); - assert (parser->chunks->begin != NULL); - assert (parser->chunks->remain != 0); + assert(parser != NULL); + assert(parser->chunks != NULL); + assert(parser->chunks->begin != NULL); + assert(parser->chunks->remain != 0); p = parser->chunks->begin; @@ -1354,12 +1288,12 @@ ucl_parse_msgpack (struct ucl_parser *parser) */ if (container == NULL) { if ((*p & 0x80) != 0x80 && !(*p >= 0xdc && *p <= 0xdf)) { - ucl_create_err (&parser->err, "bad top level object for msgpack"); + ucl_create_err(&parser->err, "bad top level object for msgpack"); return false; } } - ret = ucl_msgpack_consume (parser); + ret = ucl_msgpack_consume(parser); if (ret && parser->top_obj == NULL) { parser->top_obj = parser->cur_obj; @@ -1369,9 +1303,9 @@ ucl_parse_msgpack (struct ucl_parser *parser) } static ssize_t -ucl_msgpack_parse_map (struct ucl_parser *parser, - struct ucl_stack *container, size_t len, enum ucl_msgpack_format fmt, - const unsigned char *pos, size_t remain) +ucl_msgpack_parse_map(struct ucl_parser *parser, + struct ucl_stack *container, size_t len, enum ucl_msgpack_format fmt, + const unsigned char *pos, size_t remain) { container->obj = parser->cur_obj; @@ -1379,9 +1313,9 @@ ucl_msgpack_parse_map (struct ucl_parser *parser, } static ssize_t -ucl_msgpack_parse_array (struct ucl_parser *parser, - struct ucl_stack *container, size_t len, enum ucl_msgpack_format fmt, - const unsigned char *pos, size_t remain) +ucl_msgpack_parse_array(struct ucl_parser *parser, + struct ucl_stack *container, size_t len, enum ucl_msgpack_format fmt, + const unsigned char *pos, size_t remain) { container->obj = parser->cur_obj; @@ -1389,9 +1323,9 @@ ucl_msgpack_parse_array (struct ucl_parser *parser, } static ssize_t -ucl_msgpack_parse_string (struct ucl_parser *parser, - struct ucl_stack *container, size_t len, enum ucl_msgpack_format fmt, - const unsigned char *pos, size_t remain) +ucl_msgpack_parse_string(struct ucl_parser *parser, + struct ucl_stack *container, size_t len, enum ucl_msgpack_format fmt, + const unsigned char *pos, size_t remain) { ucl_object_t *obj; @@ -1399,7 +1333,7 @@ ucl_msgpack_parse_string (struct ucl_parser *parser, return -1; } - obj = ucl_object_new_full (UCL_STRING, parser->chunks->priority); + obj = ucl_object_new_full(UCL_STRING, parser->chunks->priority); obj->value.sv = pos; obj->len = len; @@ -1409,14 +1343,14 @@ ucl_msgpack_parse_string (struct ucl_parser *parser, if (!(parser->flags & UCL_PARSER_ZEROCOPY)) { if (obj->flags & UCL_OBJECT_BINARY) { - obj->trash_stack[UCL_TRASH_VALUE] = malloc (len); + obj->trash_stack[UCL_TRASH_VALUE] = malloc(len); if (obj->trash_stack[UCL_TRASH_VALUE] != NULL) { - memcpy (obj->trash_stack[UCL_TRASH_VALUE], pos, len); + memcpy(obj->trash_stack[UCL_TRASH_VALUE], pos, len); } } else { - ucl_copy_value_trash (obj); + ucl_copy_value_trash(obj); } } @@ -1426,9 +1360,9 @@ ucl_msgpack_parse_string (struct ucl_parser *parser, } static ssize_t -ucl_msgpack_parse_int (struct ucl_parser *parser, - struct ucl_stack *container, size_t len, enum ucl_msgpack_format fmt, - const unsigned char *pos, size_t remain) +ucl_msgpack_parse_int(struct ucl_parser *parser, + struct ucl_stack *container, size_t len, enum ucl_msgpack_format fmt, + const unsigned char *pos, size_t remain) { ucl_object_t *obj; int8_t iv8; @@ -1444,7 +1378,7 @@ ucl_msgpack_parse_int (struct ucl_parser *parser, return -1; } - obj = ucl_object_new_full (UCL_INT, parser->chunks->priority); + obj = ucl_object_new_full(UCL_INT, parser->chunks->priority); switch (fmt) { case msgpack_positive_fixint: @@ -1452,33 +1386,33 @@ ucl_msgpack_parse_int (struct ucl_parser *parser, len = 1; break; case msgpack_negative_fixint: - obj->value.iv = - (*pos & 0x1f); + obj->value.iv = -(*pos & 0x1f); len = 1; break; case msgpack_uint8: - obj->value.iv = (unsigned char)*pos; + obj->value.iv = (unsigned char) *pos; len = 1; break; case msgpack_int8: - memcpy (&iv8, pos, sizeof (iv8)); + memcpy(&iv8, pos, sizeof(iv8)); obj->value.iv = iv8; len = 1; break; case msgpack_int16: - memcpy (&iv16, pos, sizeof (iv16)); - iv16 = FROM_BE16 (iv16); + memcpy(&iv16, pos, sizeof(iv16)); + iv16 = FROM_BE16(iv16); obj->value.iv = iv16; len = 2; break; case msgpack_uint16: - memcpy (&uiv16, pos, sizeof (uiv16)); - uiv16 = FROM_BE16 (uiv16); + memcpy(&uiv16, pos, sizeof(uiv16)); + uiv16 = FROM_BE16(uiv16); obj->value.iv = uiv16; len = 2; break; case msgpack_int32: - memcpy (&iv32, pos, sizeof (iv32)); - iv32 = FROM_BE32 (iv32); + memcpy(&iv32, pos, sizeof(iv32)); + iv32 = FROM_BE32(iv32); obj->value.iv = iv32; len = 4; break; @@ -1489,8 +1423,8 @@ ucl_msgpack_parse_int (struct ucl_parser *parser, len = 4; break; case msgpack_int64: - memcpy (&iv64, pos, sizeof (iv64)); - iv64 = FROM_BE64 (iv64); + memcpy(&iv64, pos, sizeof(iv64)); + iv64 = FROM_BE64(iv64); obj->value.iv = iv64; len = 8; break; @@ -1501,7 +1435,7 @@ ucl_msgpack_parse_int (struct ucl_parser *parser, len = 8; break; default: - assert (0); + assert(0); break; } @@ -1511,9 +1445,9 @@ ucl_msgpack_parse_int (struct ucl_parser *parser, } static ssize_t -ucl_msgpack_parse_float (struct ucl_parser *parser, - struct ucl_stack *container, size_t len, enum ucl_msgpack_format fmt, - const unsigned char *pos, size_t remain) +ucl_msgpack_parse_float(struct ucl_parser *parser, + struct ucl_stack *container, size_t len, enum ucl_msgpack_format fmt, + const unsigned char *pos, size_t remain) { ucl_object_t *obj; union { @@ -1526,7 +1460,7 @@ ucl_msgpack_parse_float (struct ucl_parser *parser, return -1; } - obj = ucl_object_new_full (UCL_FLOAT, parser->chunks->priority); + obj = ucl_object_new_full(UCL_FLOAT, parser->chunks->priority); switch (fmt) { case msgpack_float32: @@ -1543,7 +1477,7 @@ ucl_msgpack_parse_float (struct ucl_parser *parser, len = 8; break; default: - assert (0); + assert(0); break; } @@ -1553,9 +1487,9 @@ ucl_msgpack_parse_float (struct ucl_parser *parser, } static ssize_t -ucl_msgpack_parse_bool (struct ucl_parser *parser, - struct ucl_stack *container, size_t len, enum ucl_msgpack_format fmt, - const unsigned char *pos, size_t remain) +ucl_msgpack_parse_bool(struct ucl_parser *parser, + struct ucl_stack *container, size_t len, enum ucl_msgpack_format fmt, + const unsigned char *pos, size_t remain) { ucl_object_t *obj; @@ -1563,7 +1497,7 @@ ucl_msgpack_parse_bool (struct ucl_parser *parser, return -1; } - obj = ucl_object_new_full (UCL_BOOLEAN, parser->chunks->priority); + obj = ucl_object_new_full(UCL_BOOLEAN, parser->chunks->priority); switch (fmt) { case msgpack_true: @@ -1573,7 +1507,7 @@ ucl_msgpack_parse_bool (struct ucl_parser *parser, obj->value.iv = false; break; default: - assert (0); + assert(0); break; } @@ -1583,9 +1517,9 @@ ucl_msgpack_parse_bool (struct ucl_parser *parser, } static ssize_t -ucl_msgpack_parse_null (struct ucl_parser *parser, - struct ucl_stack *container, size_t len, enum ucl_msgpack_format fmt, - const unsigned char *pos, size_t remain) +ucl_msgpack_parse_null(struct ucl_parser *parser, + struct ucl_stack *container, size_t len, enum ucl_msgpack_format fmt, + const unsigned char *pos, size_t remain) { ucl_object_t *obj; @@ -1593,16 +1527,16 @@ ucl_msgpack_parse_null (struct ucl_parser *parser, return -1; } - obj = ucl_object_new_full (UCL_NULL, parser->chunks->priority); + obj = ucl_object_new_full(UCL_NULL, parser->chunks->priority); parser->cur_obj = obj; return 1; } static ssize_t -ucl_msgpack_parse_ignore (struct ucl_parser *parser, - struct ucl_stack *container, size_t len, enum ucl_msgpack_format fmt, - const unsigned char *pos, size_t remain) +ucl_msgpack_parse_ignore(struct ucl_parser *parser, + struct ucl_stack *container, size_t len, enum ucl_msgpack_format fmt, + const unsigned char *pos, size_t remain) { if (len > remain) { return -1; @@ -1630,9 +1564,11 @@ ucl_msgpack_parse_ignore (struct ucl_parser *parser, len = len + 1; break; default: - ucl_create_err (&parser->err, "bad type: %x", (unsigned)fmt); + ucl_create_err(&parser->err, "bad type: %x", (unsigned) fmt); return -1; } + parser->cur_obj = NULL; + return len; } |