X-Git-Url: http://www.project-moonshot.org/gitweb/?a=blobdiff_plain;f=src%2Fload.c;h=f05230ba41e0d1f2867b3d314a8d47ccd99212a9;hb=5422a862de2354b3419ef628bac5a18c6ef522da;hp=d28721e5f6d08e4b5c73f0895064df10223a9643;hpb=f41e3809844319feae0033ce84d3acc2c5340e8d;p=jansson.git diff --git a/src/load.c b/src/load.c index d28721e..f05230b 100644 --- a/src/load.c +++ b/src/load.c @@ -1,11 +1,18 @@ +/* + * Copyright (c) 2009, 2010 Petri Lehtinen + * + * Jansson is free software; you can redistribute it and/or modify + * it under the terms of the MIT license. See LICENSE for details. + */ + #define _GNU_SOURCE #include #include +#include #include #include #include #include -#include #include #include @@ -45,7 +52,7 @@ typedef struct { int line, column; union { char *string; - int integer; + json_int_t integer; double real; } value; } lex_t; @@ -53,60 +60,53 @@ typedef struct { /*** error reporting ***/ -static void error_init(json_error_t *error) -{ - if(error) - { - error->text[0] = '\0'; - error->line = -1; - } -} - static void error_set(json_error_t *error, const lex_t *lex, const char *msg, ...) { va_list ap; - char text[JSON_ERROR_TEXT_LENGTH]; + char msg_text[JSON_ERROR_TEXT_LENGTH]; - if(!error || error->text[0] != '\0') { - /* error already set */ + int line = -1, col = -1; + const char *result = msg_text; + + if(!error) return; - } va_start(ap, msg); - vsnprintf(text, JSON_ERROR_TEXT_LENGTH, msg, ap); + vsnprintf(msg_text, JSON_ERROR_TEXT_LENGTH, msg, ap); va_end(ap); if(lex) { const char *saved_text = strbuffer_value(&lex->saved_text); - error->line = lex->line; + char msg_with_context[JSON_ERROR_TEXT_LENGTH]; + + line = lex->line; + if(saved_text && saved_text[0]) { if(lex->saved_text.length <= 20) { - snprintf(error->text, JSON_ERROR_TEXT_LENGTH, - "%s near '%s'", text, saved_text); + snprintf(msg_with_context, JSON_ERROR_TEXT_LENGTH, + "%s near '%s'", msg_text, saved_text); + result = msg_with_context; } - else - snprintf(error->text, JSON_ERROR_TEXT_LENGTH, "%s", text); } else { - snprintf(error->text, JSON_ERROR_TEXT_LENGTH, - "%s near end of file", text); + snprintf(msg_with_context, JSON_ERROR_TEXT_LENGTH, + "%s near end of file", msg_text); + result = msg_with_context; } } - else - { - error->line = -1; - snprintf(error->text, JSON_ERROR_TEXT_LENGTH, "%s", text); - } + + jsonp_error_set(error, line, col, "%s", result); } /*** lexical analyzer ***/ -void stream_init(stream_t *stream, get_func get, eof_func eof, void *data) +static void +stream_init(stream_t *stream, get_func get, eof_func eof, void *data) { stream->get = get; stream->eof = eof; @@ -127,10 +127,7 @@ static char stream_get(stream_t *stream, json_error_t *error) c = stream->buffer[0]; - if(c == EOF && stream->eof(stream->data)) - return EOF; - - if(c < 0) + if((unsigned char)c >= 0x80 && c != (char)EOF) { /* multi-byte UTF-8 sequence */ int i, count; @@ -144,7 +141,7 @@ static char stream_get(stream_t *stream, json_error_t *error) for(i = 1; i < count; i++) stream->buffer[i] = stream->get(stream->data); - if(!utf8_check_full(stream->buffer, count)) + if(!utf8_check_full(stream->buffer, count, NULL)) goto out; stream->stream_pos += count; @@ -217,10 +214,10 @@ static void lex_save_cached(lex_t *lex) } /* assumes that str points to 'u' plus at least 4 valid hex digits */ -static int decode_unicode_escape(const char *str) +static int32_t decode_unicode_escape(const char *str) { int i; - int value = 0; + int32_t value = 0; assert(str[0] == 'u'); @@ -250,17 +247,17 @@ static void lex_scan_string(lex_t *lex, json_error_t *error) lex->value.string = NULL; lex->token = TOKEN_INVALID; - /* skip the " */ c = lex_get_save(lex, error); while(c != '"') { - if(c == EOF) { + if(c == (char)EOF) { + lex_unget_unsave(lex, c); if(lex_eof(lex)) error_set(error, lex, "premature end of input"); goto out; } - else if(0 <= c && c <= 0x1F) { + else if((unsigned char)c <= 0x1F) { /* control character */ lex_unget_unsave(lex, c); if(c == '\n') @@ -321,7 +318,7 @@ static void lex_scan_string(lex_t *lex, json_error_t *error) if(*p == 'u') { char buffer[4]; int length; - int value; + int32_t value; value = decode_unicode_escape(p); p += 5; @@ -329,14 +326,15 @@ static void lex_scan_string(lex_t *lex, json_error_t *error) if(0xD800 <= value && value <= 0xDBFF) { /* surrogate pair */ if(*p == '\\' && *(p + 1) == 'u') { - int value2 = decode_unicode_escape(++p); + int32_t value2 = decode_unicode_escape(++p); p += 5; if(0xDC00 <= value2 && value2 <= 0xDFFF) { /* valid second surrogate */ - value = ((value - 0xD800) << 10) + - (value2 - 0xDC00) + - 0x10000; + value = + ((value - 0xD800) << 10) + + (value2 - 0xDC00) + + 0x10000; } else { /* invalid second surrogate */ @@ -395,10 +393,17 @@ out: free(lex->value.string); } -static void lex_scan_number(lex_t *lex, char c, json_error_t *error) +#if JSON_INTEGER_IS_LONG_LONG +#define json_strtoint strtoll +#else +#define json_strtoint strtol +#endif + +static int lex_scan_number(lex_t *lex, char c, json_error_t *error) { const char *saved_text; char *end; + double value; lex->token = TOKEN_INVALID; @@ -412,21 +417,38 @@ static void lex_scan_number(lex_t *lex, char c, json_error_t *error) goto out; } } - else /* c != '0' */ { + else if(isdigit(c)) { c = lex_get_save(lex, error); while(isdigit(c)) c = lex_get_save(lex, error); } + else { + lex_unget_unsave(lex, c); + goto out; + } if(c != '.' && c != 'E' && c != 'e') { + json_int_t value; + lex_unget_unsave(lex, c); - lex->token = TOKEN_INTEGER; saved_text = strbuffer_value(&lex->saved_text); - lex->value.integer = strtol(saved_text, &end, 10); + + errno = 0; + value = json_strtoint(saved_text, &end, 10); + if(errno == ERANGE) { + if(value < 0) + error_set(error, lex, "too big negative integer"); + else + error_set(error, lex, "too big integer"); + goto out; + } + assert(end == saved_text + lex->saved_text.length); - return; + lex->token = TOKEN_INTEGER; + lex->value.integer = value; + return 0; } if(c == '.') { @@ -456,14 +478,22 @@ static void lex_scan_number(lex_t *lex, char c, json_error_t *error) } lex_unget_unsave(lex, c); - lex->token = TOKEN_REAL; saved_text = strbuffer_value(&lex->saved_text); - lex->value.real = strtod(saved_text, &end); + value = strtod(saved_text, &end); assert(end == saved_text + lex->saved_text.length); + if(errno == ERANGE && value != 0) { + error_set(error, lex, "real number overflow"); + goto out; + } + + lex->token = TOKEN_REAL; + lex->value.real = value; + return 0; + out: - return; + return -1; } static int lex_scan(lex_t *lex, json_error_t *error) @@ -473,8 +503,8 @@ static int lex_scan(lex_t *lex, json_error_t *error) strbuffer_clear(&lex->saved_text); if(lex->token == TOKEN_STRING) { - free(lex->value.string); - lex->value.string = NULL; + free(lex->value.string); + lex->value.string = NULL; } c = lex_get(lex, error); @@ -486,7 +516,7 @@ static int lex_scan(lex_t *lex, json_error_t *error) c = lex_get(lex, error); } - if(c == EOF) { + if(c == (char)EOF) { if(lex_eof(lex)) lex->token = TOKEN_EOF; else @@ -502,8 +532,10 @@ static int lex_scan(lex_t *lex, json_error_t *error) else if(c == '"') lex_scan_string(lex, error); - else if(isdigit(c) || c == '-') - lex_scan_number(lex, c, error); + else if(isdigit(c) || c == '-') { + if(lex_scan_number(lex, c, error)) + goto out; + } else if(isupper(c) || islower(c)) { /* eat up the whole identifier for clearer error messages */ @@ -537,6 +569,17 @@ out: return lex->token; } +static char *lex_steal_string(lex_t *lex) +{ + char *result = NULL; + if(lex->token == TOKEN_STRING) + { + result = lex->value.string; + lex->value.string = NULL; + } + return result; +} + static int lex_init(lex_t *lex, get_func get, eof_func eof, void *data) { stream_init(&lex->stream, get, eof, data); @@ -580,7 +623,7 @@ static json_t *parse_object(lex_t *lex, json_error_t *error) goto error; } - key = strdup(lex->value.string); + key = lex_steal_string(lex); if(!key) return NULL; @@ -699,7 +742,7 @@ static json_t *parse_value(lex_t *lex, json_error_t *error) break; case '{': - json = parse_object(lex, error); + json = parse_object(lex, error); break; case '[': @@ -721,10 +764,8 @@ static json_t *parse_value(lex_t *lex, json_error_t *error) return json; } -json_t *parse_json(lex_t *lex, json_error_t *error) +static json_t *parse_json(lex_t *lex, json_error_t *error) { - error_init(error); - lex_scan(lex, error); if(lex->token != '[' && lex->token != '{') { error_set(error, lex, "'[' or '{' expected"); @@ -760,19 +801,19 @@ static int string_eof(void *data) return (stream->data[stream->pos] == '\0'); } -json_t *json_loads(const char *string, json_error_t *error) +json_t *json_loads(const char *string, size_t flags, json_error_t *error) { lex_t lex; json_t *result; + (void)flags; /* unused */ - string_data_t stream_data = { - .data = string, - .pos = 0 - }; + string_data_t stream_data = {string, 0}; if(lex_init(&lex, string_get, string_eof, (void *)&stream_data)) return NULL; + jsonp_error_init(error, ""); + result = parse_json(&lex, error); if(!result) goto out; @@ -789,25 +830,46 @@ out: return result; } -json_t *json_loadf(FILE *input, json_error_t *error) +json_t *json_loadf(FILE *input, size_t flags, json_error_t *error) { lex_t lex; + const char *source; json_t *result; + (void)flags; /* unused */ if(lex_init(&lex, (get_func)fgetc, (eof_func)feof, input)) return NULL; + if(input == stdin) + source = ""; + else + source = ""; + + jsonp_error_init(error, source); + result = parse_json(&lex, error); + if(!result) + goto out; + lex_scan(&lex, error); + if(lex.token != TOKEN_EOF) { + error_set(error, &lex, "end of file expected"); + json_decref(result); + result = NULL; + } + +out: lex_close(&lex); return result; } -json_t *json_load_file(const char *path, json_error_t *error) +json_t *json_load_file(const char *path, size_t flags, json_error_t *error) { json_t *result; FILE *fp; + jsonp_error_init(error, path); + fp = fopen(path, "r"); if(!fp) { @@ -816,7 +878,7 @@ json_t *json_load_file(const char *path, json_error_t *error) return NULL; } - result = json_loadf(fp, error); + result = json_loadf(fp, flags, error); fclose(fp); return result;