void modp_json_add_int(modp_json_ctx* ctx, int v)
{
    unsigned int uv = (v < 0) ? (unsigned int)(-v) : (unsigned int)(v);
    size_t r =
       (uv >= 1000000000) ? 10 : (uv >= 100000000) ? 9 : (uv >= 10000000) ? 8 : 
       (uv >= 1000000) ? 7 : (uv >= 100000) ? 6 : (uv >= 10000) ? 5 : 
       (uv >= 1000) ? 4 : (uv >= 100) ? 3 : (uv >= 10) ? 2 : 1;

    modp_json_add_value(ctx);

    if (ctx->dest) {
        char* wstr = ctx->dest;
        if (v < 0) {
            *wstr = '-';
            r += 1;
        }
        wstr += r -1;


        // Conversion. Number is reversed.
        do *wstr-- = (char)(48 + (uv % 10)); while (uv /= 10);
    }

    ctx->size += r;
}
示例#2
0
void modp_json_add_uint32(modp_json_ctx* ctx, uint32_t uv)
{
    char* wstr;
    size_t r =
        (uv >= 1000000000UL) ? 10 :
        (uv >= 100000000UL) ? 9 :
        (uv >= 10000000UL) ? 8 :
        (uv >= 1000000UL) ? 7 :
        (uv >= 100000UL) ? 6 :
        (uv >= 10000UL) ? 5 :
        (uv >= 1000UL) ? 4 :
        (uv >= 100UL) ? 3 :
        (uv >= 10UL) ? 2 :
        1UL;

    modp_json_add_value(ctx);

    if (ctx->dest) {
        wstr = ctx->dest + ctx->size;
        wstr += r - 1;
        do *wstr-- = (char)(48 + (uv % 10)); while (uv /= 10);
    }

    ctx->size += r;
}
void modp_json_ary_open(modp_json_ctx* ctx)
{
    modp_json_add_value(ctx);
    ctx->depth++;
    ctx->state[ctx->depth] = JSON_ARY_OPEN;
    modp_json_add_char(ctx, '[');
}
示例#4
0
void modp_json_add_int32(modp_json_ctx* ctx, int v)
{
    char* wstr;
    if (v > 0) {
        return modp_json_add_uint32(ctx, (uint32_t) v);
    }
    uint32_t uv = (uint32_t)(-v);
    size_t r =
        (uv >= 1000000000) ? 10 :
        (uv >= 100000000) ? 9 :
        (uv >= 10000000) ? 8 :
        (uv >= 1000000) ? 7 :
        (uv >= 100000) ? 6 :
        (uv >= 10000) ? 5 :
        (uv >= 1000) ? 4 :
        (uv >= 100) ? 3 :
        (uv >= 10) ? 2 :
        1;

    modp_json_add_value(ctx);

    if (ctx->dest) {
        wstr = ctx->dest + ctx->size;
        *wstr = '-';
        wstr += r;
        /* Conversion. Number is reversed. */
        do *wstr-- = (char)(48 + (uv % 10)); while (uv /= 10);
    }

    ctx->size += r + 1; /* +1 for '-' minus sign */
}
void modp_json_map_open(modp_json_ctx* ctx)
{
    modp_json_add_value(ctx);

    ctx->depth++;
    ctx->state[ctx->depth] = JSON_MAP_OPEN;
    
    modp_json_add_char(ctx, '{');
}
void modp_json_add_string(modp_json_ctx* ctx, const char* src, size_t len) 
{
    modp_json_add_value(ctx);

    if (ctx->dest) {
        ctx->size += modp_bjson_encode(ctx->dest + ctx->size, src, len);
    } else {
        ctx->size += modp_bjson_encode_strlen(src, len);
    }
}
示例#7
0
void modp_json_add_bool(modp_json_ctx* ctx, int val)
{

    modp_json_add_value(ctx);

    if (val) {
        modp_json_add_true(ctx);
    } else {
        modp_json_add_false(ctx);
    }
}
示例#8
0
void modp_json_add_uint64(modp_json_ctx* ctx, uint64_t uv,
                          int stringonly)
{
    size_t r =
        (uv >= 10000000000000000000ULL) ? 20 :
        (uv >= 1000000000000000000ULL) ? 19 :
        (uv >= 100000000000000000ULL) ? 18 :
        (uv >= 10000000000000000ULL) ? 17 :
        (uv >= 1000000000000000ULL) ? 16 :
        (uv >= 100000000000000ULL) ? 15 :
        (uv >= 10000000000000ULL) ? 14 :
        (uv >= 1000000000000ULL) ? 13 :
        (uv >= 100000000000ULL) ? 12 :
        (uv >= 10000000000ULL) ? 11 :
        (uv >= 1000000000ULL) ? 10 :
        (uv >= 100000000ULL) ? 9 :
        (uv >= 10000000ULL) ? 8 :
        (uv >= 1000000ULL) ? 7 :
        (uv >= 100000ULL) ? 6 :
        (uv >= 10000ULL) ? 5 :
        (uv >= 1000ULL) ? 4 :
        (uv >= 100ULL) ? 3 :
        (uv >= 10ULL) ? 2 :
        1ULL;

    if (uv > (1ULL << 53)) {
        stringonly = 1;
    }

    modp_json_add_value(ctx);

    if (ctx->dest) {
        char* wstr = ctx->dest + ctx->size;
        if (stringonly) {
            wstr[0] = '"';
            wstr[r+1] = '"';
            wstr += r;
        } else {
            wstr += r - 1;
        }

        /* Conversion. Number is reversed. */
        do *wstr-- = (char)(48 + (uv % 10)); while (uv /= 10);

    }

    if (stringonly) {
        r += 2;
    }

    ctx->size += r;
}
示例#9
0
void modp_json_add_null(modp_json_ctx* ctx)
{
    char* wstr;

    modp_json_add_value(ctx);

    if (ctx->dest) {
        wstr = ctx->dest + ctx->size;
        wstr[0] = 'n';
        wstr[1] = 'u';
        wstr[2] = 'l';
        wstr[3] = 'l';
    }
    ctx->size += 4;
}