From beb4699091e9fab1c5f465056bef35c9ddf7f9fc Mon Sep 17 00:00:00 2001 From: Robert Haas Date: Wed, 29 Jan 2020 10:19:24 -0500 Subject: Move jsonapi.c and jsonapi.h to src/common. To make this work, (1) makeJsonLexContextCstringLen now takes the encoding to be used as an argument; (2) check_stack_depth() is made to do nothing in frontend code, and (3) elog(ERROR, ...) is changed to pg_log_fatal + exit in frontend code. Mark Dilger, reviewed and slightly revised by me. Discussion: http://postgr.es/m/CA+TgmoYfOXhd27MUDGioVh6QtpD0C1K-f6ObSA10AWiHBAL5bA@mail.gmail.com --- src/backend/tsearch/to_tsany.c | 2 +- src/backend/tsearch/wparser.c | 2 +- src/backend/utils/adt/Makefile | 1 - src/backend/utils/adt/json.c | 2 +- src/backend/utils/adt/jsonapi.c | 1096 ----------------------------------- src/backend/utils/adt/jsonb.c | 2 +- src/backend/utils/adt/jsonb_util.c | 2 +- src/backend/utils/adt/jsonfuncs.c | 7 +- src/common/Makefile | 1 + src/common/jsonapi.c | 1114 ++++++++++++++++++++++++++++++++++++ src/include/common/jsonapi.h | 169 ++++++ src/include/utils/jsonapi.h | 167 ------ src/include/utils/jsonfuncs.h | 2 +- 13 files changed, 1294 insertions(+), 1273 deletions(-) delete mode 100644 src/backend/utils/adt/jsonapi.c create mode 100644 src/common/jsonapi.c create mode 100644 src/include/common/jsonapi.h delete mode 100644 src/include/utils/jsonapi.h (limited to 'src') diff --git a/src/backend/tsearch/to_tsany.c b/src/backend/tsearch/to_tsany.c index adf181c191f..1fe67c4c998 100644 --- a/src/backend/tsearch/to_tsany.c +++ b/src/backend/tsearch/to_tsany.c @@ -13,10 +13,10 @@ */ #include "postgres.h" +#include "common/jsonapi.h" #include "tsearch/ts_cache.h" #include "tsearch/ts_utils.h" #include "utils/builtins.h" -#include "utils/jsonapi.h" #include "utils/jsonfuncs.h" diff --git a/src/backend/tsearch/wparser.c b/src/backend/tsearch/wparser.c index c7499a94ac6..88005c0519a 100644 --- a/src/backend/tsearch/wparser.c +++ b/src/backend/tsearch/wparser.c @@ -16,11 +16,11 @@ #include "catalog/namespace.h" #include "catalog/pg_type.h" #include "commands/defrem.h" +#include "common/jsonapi.h" #include "funcapi.h" #include "tsearch/ts_cache.h" #include "tsearch/ts_utils.h" #include "utils/builtins.h" -#include "utils/jsonapi.h" #include "utils/jsonfuncs.h" #include "utils/varlena.h" diff --git a/src/backend/utils/adt/Makefile b/src/backend/utils/adt/Makefile index 790d7a24fb8..13efa9338c1 100644 --- a/src/backend/utils/adt/Makefile +++ b/src/backend/utils/adt/Makefile @@ -44,7 +44,6 @@ OBJS = \ int.o \ int8.o \ json.o \ - jsonapi.o \ jsonb.o \ jsonb_gin.o \ jsonb_op.o \ diff --git a/src/backend/utils/adt/json.c b/src/backend/utils/adt/json.c index f6cd2b99115..567eab1e01e 100644 --- a/src/backend/utils/adt/json.c +++ b/src/backend/utils/adt/json.c @@ -127,7 +127,7 @@ json_recv(PG_FUNCTION_ARGS) str = pq_getmsgtext(buf, buf->len - buf->cursor, &nbytes); /* Validate it. */ - lex = makeJsonLexContextCstringLen(str, nbytes, false); + lex = makeJsonLexContextCstringLen(str, nbytes, GetDatabaseEncoding(), false); pg_parse_json_or_ereport(lex, &nullSemAction); PG_RETURN_TEXT_P(cstring_to_text_with_len(str, nbytes)); diff --git a/src/backend/utils/adt/jsonapi.c b/src/backend/utils/adt/jsonapi.c deleted file mode 100644 index 230a55b1013..00000000000 --- a/src/backend/utils/adt/jsonapi.c +++ /dev/null @@ -1,1096 +0,0 @@ -/*------------------------------------------------------------------------- - * - * jsonapi.c - * JSON parser and lexer interfaces - * - * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group - * Portions Copyright (c) 1994, Regents of the University of California - * - * IDENTIFICATION - * src/backend/utils/adt/jsonapi.c - * - *------------------------------------------------------------------------- - */ -#include "postgres.h" - -#include "mb/pg_wchar.h" -#include "miscadmin.h" -#include "utils/jsonapi.h" - -/* - * The context of the parser is maintained by the recursive descent - * mechanism, but is passed explicitly to the error reporting routine - * for better diagnostics. - */ -typedef enum /* contexts of JSON parser */ -{ - JSON_PARSE_VALUE, /* expecting a value */ - JSON_PARSE_STRING, /* expecting a string (for a field name) */ - JSON_PARSE_ARRAY_START, /* saw '[', expecting value or ']' */ - JSON_PARSE_ARRAY_NEXT, /* saw array element, expecting ',' or ']' */ - JSON_PARSE_OBJECT_START, /* saw '{', expecting label or '}' */ - JSON_PARSE_OBJECT_LABEL, /* saw object label, expecting ':' */ - JSON_PARSE_OBJECT_NEXT, /* saw object value, expecting ',' or '}' */ - JSON_PARSE_OBJECT_COMMA, /* saw object ',', expecting next label */ - JSON_PARSE_END /* saw the end of a document, expect nothing */ -} JsonParseContext; - -static inline JsonParseErrorType json_lex_string(JsonLexContext *lex); -static inline JsonParseErrorType json_lex_number(JsonLexContext *lex, char *s, - bool *num_err, int *total_len); -static inline JsonParseErrorType parse_scalar(JsonLexContext *lex, JsonSemAction *sem); -static JsonParseErrorType parse_object_field(JsonLexContext *lex, JsonSemAction *sem); -static JsonParseErrorType parse_object(JsonLexContext *lex, JsonSemAction *sem); -static JsonParseErrorType parse_array_element(JsonLexContext *lex, JsonSemAction *sem); -static JsonParseErrorType parse_array(JsonLexContext *lex, JsonSemAction *sem); -static JsonParseErrorType report_parse_error(JsonParseContext ctx, JsonLexContext *lex); -static char *extract_token(JsonLexContext *lex); - -/* the null action object used for pure validation */ -JsonSemAction nullSemAction = -{ - NULL, NULL, NULL, NULL, NULL, - NULL, NULL, NULL, NULL, NULL -}; - -/* Recursive Descent parser support routines */ - -/* - * lex_peek - * - * what is the current look_ahead token? -*/ -static inline JsonTokenType -lex_peek(JsonLexContext *lex) -{ - return lex->token_type; -} - -/* - * lex_expect - * - * move the lexer to the next token if the current look_ahead token matches - * the parameter token. Otherwise, report an error. - */ -static inline JsonParseErrorType -lex_expect(JsonParseContext ctx, JsonLexContext *lex, JsonTokenType token) -{ - if (lex_peek(lex) == token) - return json_lex(lex); - else - return report_parse_error(ctx, lex); -} - -/* chars to consider as part of an alphanumeric token */ -#define JSON_ALPHANUMERIC_CHAR(c) \ - (((c) >= 'a' && (c) <= 'z') || \ - ((c) >= 'A' && (c) <= 'Z') || \ - ((c) >= '0' && (c) <= '9') || \ - (c) == '_' || \ - IS_HIGHBIT_SET(c)) - -/* - * Utility function to check if a string is a valid JSON number. - * - * str is of length len, and need not be null-terminated. - */ -bool -IsValidJsonNumber(const char *str, int len) -{ - bool numeric_error; - int total_len; - JsonLexContext dummy_lex; - - if (len <= 0) - return false; - - /* - * json_lex_number expects a leading '-' to have been eaten already. - * - * having to cast away the constness of str is ugly, but there's not much - * easy alternative. - */ - if (*str == '-') - { - dummy_lex.input = unconstify(char *, str) +1; - dummy_lex.input_length = len - 1; - } - else - { - dummy_lex.input = unconstify(char *, str); - dummy_lex.input_length = len; - } - - json_lex_number(&dummy_lex, dummy_lex.input, &numeric_error, &total_len); - - return (!numeric_error) && (total_len == dummy_lex.input_length); -} - -/* - * makeJsonLexContextCstringLen - * - * lex constructor, with or without StringInfo object for de-escaped lexemes. - * - * Without is better as it makes the processing faster, so only make one - * if really required. - */ -JsonLexContext * -makeJsonLexContextCstringLen(char *json, int len, bool need_escapes) -{ - JsonLexContext *lex = palloc0(sizeof(JsonLexContext)); - - lex->input = lex->token_terminator = lex->line_start = json; - lex->line_number = 1; - lex->input_length = len; - if (need_escapes) - lex->strval = makeStringInfo(); - return lex; -} - -/* - * pg_parse_json - * - * Publicly visible entry point for the JSON parser. - * - * lex is a lexing context, set up for the json to be processed by calling - * makeJsonLexContext(). sem is a structure of function pointers to semantic - * action routines to be called at appropriate spots during parsing, and a - * pointer to a state object to be passed to those routines. - */ -JsonParseErrorType -pg_parse_json(JsonLexContext *lex, JsonSemAction *sem) -{ - JsonTokenType tok; - JsonParseErrorType result; - - /* get the initial token */ - result = json_lex(lex); - if (result != JSON_SUCCESS) - return result; - - tok = lex_peek(lex); - - /* parse by recursive descent */ - switch (tok) - { - case JSON_TOKEN_OBJECT_START: - result = parse_object(lex, sem); - break; - case JSON_TOKEN_ARRAY_START: - result = parse_array(lex, sem); - break; - default: - result = parse_scalar(lex, sem); /* json can be a bare scalar */ - } - - if (result == JSON_SUCCESS) - result = lex_expect(JSON_PARSE_END, lex, JSON_TOKEN_END); - - return result; -} - -/* - * json_count_array_elements - * - * Returns number of array elements in lex context at start of array token - * until end of array token at same nesting level. - * - * Designed to be called from array_start routines. - */ -JsonParseErrorType -json_count_array_elements(JsonLexContext *lex, int *elements) -{ - JsonLexContext copylex; - int count; - JsonParseErrorType result; - - /* - * It's safe to do this with a shallow copy because the lexical routines - * don't scribble on the input. They do scribble on the other pointers - * etc, so doing this with a copy makes that safe. - */ - memcpy(©lex, lex, sizeof(JsonLexContext)); - copylex.strval = NULL; /* not interested in values here */ - copylex.lex_level++; - - count = 0; - result = lex_expect(JSON_PARSE_ARRAY_START, ©lex, - JSON_TOKEN_ARRAY_START); - if (result != JSON_SUCCESS) - return result; - if (lex_peek(©lex) != JSON_TOKEN_ARRAY_END) - { - while (1) - { - count++; - result = parse_array_element(©lex, &nullSemAction); - if (result != JSON_SUCCESS) - return result; - if (copylex.token_type != JSON_TOKEN_COMMA) - break; - result = json_lex(©lex); - if (result != JSON_SUCCESS) - return result; - } - } - result = lex_expect(JSON_PARSE_ARRAY_NEXT, ©lex, - JSON_TOKEN_ARRAY_END); - if (result != JSON_SUCCESS) - return result; - - *elements = count; - return JSON_SUCCESS; -} - -/* - * Recursive Descent parse routines. There is one for each structural - * element in a json document: - * - scalar (string, number, true, false, null) - * - array ( [ ] ) - * - array element - * - object ( { } ) - * - object field - */ -static inline JsonParseErrorType -parse_scalar(JsonLexContext *lex, JsonSemAction *sem) -{ - char *val = NULL; - json_scalar_action sfunc = sem->scalar; - JsonTokenType tok = lex_peek(lex); - JsonParseErrorType result; - - /* a scalar must be a string, a number, true, false, or null */ - if (tok != JSON_TOKEN_STRING && tok != JSON_TOKEN_NUMBER && - tok != JSON_TOKEN_TRUE && tok != JSON_TOKEN_FALSE && - tok != JSON_TOKEN_NULL) - return report_parse_error(JSON_PARSE_VALUE, lex); - - /* if no semantic function, just consume the token */ - if (sfunc == NULL) - return json_lex(lex); - - /* extract the de-escaped string value, or the raw lexeme */ - if (lex_peek(lex) == JSON_TOKEN_STRING) - { - if (lex->strval != NULL) - val = pstrdup(lex->strval->data); - } - else - { - int len = (lex->token_terminator - lex->token_start); - - val = palloc(len + 1); - memcpy(val, lex->token_start, len); - val[len] = '\0'; - } - - /* consume the token */ - result = json_lex(lex); - if (result != JSON_SUCCESS) - return result; - - /* invoke the callback */ - (*sfunc) (sem->semstate, val, tok); - - return JSON_SUCCESS; -} - -static JsonParseErrorType -parse_object_field(JsonLexContext *lex, JsonSemAction *sem) -{ - /* - * An object field is "fieldname" : value where value can be a scalar, - * object or array. Note: in user-facing docs and error messages, we - * generally call a field name a "key". - */ - - char *fname = NULL; /* keep compiler quiet */ - json_ofield_action ostart = sem->object_field_start; - json_ofield_action oend = sem->object_field_end; - bool isnull; - JsonTokenType tok; - JsonParseErrorType result; - - if (lex_peek(lex) != JSON_TOKEN_STRING) - return report_parse_error(JSON_PARSE_STRING, lex); - if ((ostart != NULL || oend != NULL) && lex->strval != NULL) - fname = pstrdup(lex->strval->data); - result = json_lex(lex); - if (result != JSON_SUCCESS) - return result; - - result = lex_expect(JSON_PARSE_OBJECT_LABEL, lex, JSON_TOKEN_COLON); - if (result != JSON_SUCCESS) - return result; - - tok = lex_peek(lex); - isnull = tok == JSON_TOKEN_NULL; - - if (ostart != NULL) - (*ostart) (sem->semstate, fname, isnull); - - switch (tok) - { - case JSON_TOKEN_OBJECT_START: - result = parse_object(lex, sem); - break; - case JSON_TOKEN_ARRAY_START: - result = parse_array(lex, sem); - break; - default: - result = parse_scalar(lex, sem); - } - if (result != JSON_SUCCESS) - return result; - - if (oend != NULL) - (*oend) (sem->semstate, fname, isnull); - return JSON_SUCCESS; -} - -static JsonParseErrorType -parse_object(JsonLexContext *lex, JsonSemAction *sem) -{ - /* - * an object is a possibly empty sequence of object fields, separated by - * commas and surrounded by curly braces. - */ - json_struct_action ostart = sem->object_start; - json_struct_action oend = sem->object_end; - JsonTokenType tok; - JsonParseErrorType result; - - check_stack_depth(); - - if (ostart != NULL) - (*ostart) (sem->semstate); - - /* - * Data inside an object is at a higher nesting level than the object - * itself. Note that we increment this after we call the semantic routine - * for the object start and restore it before we call the routine for the - * object end. - */ - lex->lex_level++; - - Assert(lex_peek(lex) == JSON_TOKEN_OBJECT_START); - result = json_lex(lex); - if (result != JSON_SUCCESS) - return result; - - tok = lex_peek(lex); - switch (tok) - { - case JSON_TOKEN_STRING: - result = parse_object_field(lex, sem); - while (result == JSON_SUCCESS && lex_peek(lex) == JSON_TOKEN_COMMA) - { - result = json_lex(lex); - if (result != JSON_SUCCESS) - break; - result = parse_object_field(lex, sem); - } - break; - case JSON_TOKEN_OBJECT_END: - break; - default: - /* case of an invalid initial token inside the object */ - result = report_parse_error(JSON_PARSE_OBJECT_START, lex); - } - if (result != JSON_SUCCESS) - return result; - - result = lex_expect(JSON_PARSE_OBJECT_NEXT, lex, JSON_TOKEN_OBJECT_END); - if (result != JSON_SUCCESS) - return result; - - lex->lex_level--; - - if (oend != NULL) - (*oend) (sem->semstate); - - return JSON_SUCCESS; -} - -static JsonParseErrorType -parse_array_element(JsonLexContext *lex, JsonSemAction *sem) -{ - json_aelem_action astart = sem->array_element_start; - json_aelem_action aend = sem->array_element_end; - JsonTokenType tok = lex_peek(lex); - JsonParseErrorType result; - - bool isnull; - - isnull = tok == JSON_TOKEN_NULL; - - if (astart != NULL) - (*astart) (sem->semstate, isnull); - - /* an array element is any object, array or scalar */ - switch (tok) - { - case JSON_TOKEN_OBJECT_START: - result = parse_object(lex, sem); - break; - case JSON_TOKEN_ARRAY_START: - result = parse_array(lex, sem); - break; - default: - result = parse_scalar(lex, sem); - } - - if (result != JSON_SUCCESS) - return result; - - if (aend != NULL) - (*aend) (sem->semstate, isnull); - - return JSON_SUCCESS; -} - -static JsonParseErrorType -parse_array(JsonLexContext *lex, JsonSemAction *sem) -{ - /* - * an array is a possibly empty sequence of array elements, separated by - * commas and surrounded by square brackets. - */ - json_struct_action astart = sem->array_start; - json_struct_action aend = sem->array_end; - JsonParseErrorType result; - - check_stack_depth(); - - if (astart != NULL) - (*astart) (sem->semstate); - - /* - * Data inside an array is at a higher nesting level than the array - * itself. Note that we increment this after we call the semantic routine - * for the array start and restore it before we call the routine for the - * array end. - */ - lex->lex_level++; - - result = lex_expect(JSON_PARSE_ARRAY_START, lex, JSON_TOKEN_ARRAY_START); - if (result == JSON_SUCCESS && lex_peek(lex) != JSON_TOKEN_ARRAY_END) - { - result = parse_array_element(lex, sem); - - while (result == JSON_SUCCESS && lex_peek(lex) == JSON_TOKEN_COMMA) - { - result = json_lex(lex); - if (result != JSON_SUCCESS) - break; - result = parse_array_element(lex, sem); - } - } - if (result != JSON_SUCCESS) - return result; - - result = lex_expect(JSON_PARSE_ARRAY_NEXT, lex, JSON_TOKEN_ARRAY_END); - if (result != JSON_SUCCESS) - return result; - - lex->lex_level--; - - if (aend != NULL) - (*aend) (sem->semstate); - - return JSON_SUCCESS; -} - -/* - * Lex one token from the input stream. - */ -JsonParseErrorType -json_lex(JsonLexContext *lex) -{ - char *s; - int len; - JsonParseErrorType result; - - /* Skip leading whitespace. */ - s = lex->token_terminator; - len = s - lex->input; - while (len < lex->input_length && - (*s == ' ' || *s == '\t' || *s == '\n' || *s == '\r')) - { - if (*s == '\n') - ++lex->line_number; - ++s; - ++len; - } - lex->token_start = s; - - /* Determine token type. */ - if (len >= lex->input_length) - { - lex->token_start = NULL; - lex->prev_token_terminator = lex->token_terminator; - lex->token_terminator = s; - lex->token_type = JSON_TOKEN_END; - } - else - { - switch (*s) - { - /* Single-character token, some kind of punctuation mark. */ - case '{': - lex->prev_token_terminator = lex->token_terminator; - lex->token_terminator = s + 1; - lex->token_type = JSON_TOKEN_OBJECT_START; - break; - case '}': - lex->prev_token_terminator = lex->token_terminator; - lex->token_terminator = s + 1; - lex->token_type = JSON_TOKEN_OBJECT_END; - break; - case '[': - lex->prev_token_terminator = lex->token_terminator; - lex->token_terminator = s + 1; - lex->token_type = JSON_TOKEN_ARRAY_START; - break; - case ']': - lex->prev_token_terminator = lex->token_terminator; - lex->token_terminator = s + 1; - lex->token_type = JSON_TOKEN_ARRAY_END; - break; - case ',': - lex->prev_token_terminator = lex->token_terminator; - lex->token_terminator = s + 1; - lex->token_type = JSON_TOKEN_COMMA; - break; - case ':': - lex->prev_token_terminator = lex->token_terminator; - lex->token_terminator = s + 1; - lex->token_type = JSON_TOKEN_COLON; - break; - case '"': - /* string */ - result = json_lex_string(lex); - if (result != JSON_SUCCESS) - return result; - lex->token_type = JSON_TOKEN_STRING; - break; - case '-': - /* Negative number. */ - result = json_lex_number(lex, s + 1, NULL, NULL); - if (result != JSON_SUCCESS) - return result; - lex->token_type = JSON_TOKEN_NUMBER; - break; - case '0': - case '1': - case '2': - case '3': - case '4': - case '5': - case '6': - case '7': - case '8': - case '9': - /* Positive number. */ - result = json_lex_number(lex, s, NULL, NULL); - if (result != JSON_SUCCESS) - return result; - lex->token_type = JSON_TOKEN_NUMBER; - break; - default: - { - char *p; - - /* - * We're not dealing with a string, number, legal - * punctuation mark, or end of string. The only legal - * tokens we might find here are true, false, and null, - * but for error reporting purposes we scan until we see a - * non-alphanumeric character. That way, we can report - * the whole word as an unexpected token, rather than just - * some unintuitive prefix thereof. - */ - for (p = s; p - s < lex->input_length - len && JSON_ALPHANUMERIC_CHAR(*p); p++) - /* skip */ ; - - /* - * We got some sort of unexpected punctuation or an - * otherwise unexpected character, so just complain about - * that one character. - */ - if (p == s) - { - lex->prev_token_terminator = lex->token_terminator; - lex->token_terminator = s + 1; - return JSON_INVALID_TOKEN; - } - - /* - * We've got a real alphanumeric token here. If it - * happens to be true, false, or null, all is well. If - * not, error out. - */ - lex->prev_token_terminator = lex->token_terminator; - lex->token_terminator = p; - if (p - s == 4) - { - if (memcmp(s, "true", 4) == 0) - lex->token_type = JSON_TOKEN_TRUE; - else if (memcmp(s, "null", 4) == 0) - lex->token_type = JSON_TOKEN_NULL; - else - return JSON_INVALID_TOKEN; - } - else if (p - s == 5 && memcmp(s, "false", 5) == 0) - lex->token_type = JSON_TOKEN_FALSE; - else - return JSON_INVALID_TOKEN; - - } - } /* end of switch */ - } - - return JSON_SUCCESS; -} - -/* - * The next token in the input stream is known to be a string; lex it. - */ -static inline JsonParseErrorType -json_lex_string(JsonLexContext *lex) -{ - char *s; - int len; - int hi_surrogate = -1; - - if (lex->strval != NULL) - resetStringInfo(lex->strval); - - Assert(lex->input_length > 0); - s = lex->token_start; - len = lex->token_start - lex->input; - for (;;) - { - s++; - len++; - /* Premature end of the string. */ - if (len >= lex->input_length) - { - lex->token_terminator = s; - return JSON_INVALID_TOKEN; - } - else if (*s == '"') - break; - else if ((unsigned char) *s < 32) - { - /* Per RFC4627, these characters MUST be escaped. */ - /* Since *s isn't printable, exclude it from the context string */ - lex->token_terminator = s; - return JSON_ESCAPING_REQUIRED; - } - else if (*s == '\\') - { - /* OK, we have an escape character. */ - s++; - len++; - if (len >= lex->input_length) - { - lex->token_terminator = s; - return JSON_INVALID_TOKEN; - } - else if (*s == 'u') - { - int i; - int ch = 0; - - for (i = 1; i <= 4; i++) - { - s++; - len++; - if (len >= lex->input_length) - { - lex->token_terminator = s; - return JSON_INVALID_TOKEN; - } - else if (*s >= '0' && *s <= '9') - ch = (ch * 16) + (*s - '0'); - else if (*s >= 'a' && *s <= 'f') - ch = (ch * 16) + (*s - 'a') + 10; - else if (*s >= 'A' && *s <= 'F') - ch = (ch * 16) + (*s - 'A') + 10; - else - { - lex->token_terminator = s + pg_mblen(s); - return JSON_UNICODE_ESCAPE_FORMAT; - } - } - if (lex->strval != NULL) - { - char utf8str[5]; - int utf8len; - - if (ch >= 0xd800 && ch <= 0xdbff) - { - if (hi_surrogate != -1) - return JSON_UNICODE_HIGH_SURROGATE; - hi_surrogate = (ch & 0x3ff) << 10; - continue; - } - else if (ch >= 0xdc00 && ch <= 0xdfff) - { - if (hi_surrogate == -1) - return JSON_UNICODE_LOW_SURROGATE; - ch = 0x10000 + hi_surrogate + (ch & 0x3ff); - hi_surrogate = -1; - } - - if (hi_surrogate != -1) - return JSON_UNICODE_LOW_SURROGATE; - - /* - * For UTF8, replace the escape sequence by the actual - * utf8 character in lex->strval. Do this also for other - * encodings if the escape designates an ASCII character, - * otherwise raise an error. - */ - - if (ch == 0) - { - /* We can't allow this, since our TEXT type doesn't */ - return JSON_UNICODE_CODE_POINT_ZERO; - } - else if (GetDatabaseEncoding() == PG_UTF8) - { - unicode_to_utf8(ch, (unsigned char *) utf8str); - utf8len = pg_utf_mblen((unsigned char *) utf8str); - appendBinaryStringInfo(lex->strval, utf8str, utf8len); - } - else if (ch <= 0x007f) - { - /* - * This is the only way to designate things like a - * form feed character in JSON, so it's useful in all - * encodings. - */ - appendStringInfoChar(lex->strval, (char) ch); - } - else - return JSON_UNICODE_HIGH_ESCAPE; - - } - } - else if (lex->strval != NULL) - { - if (hi_surrogate != -1) - return JSON_UNICODE_LOW_SURROGATE; - - switch (*s) - { - case '"': - case '\\': - case '/': - appendStringInfoChar(lex->strval, *s); - break; - case 'b': - appendStringInfoChar(lex->strval, '\b'); - break; - case 'f': - appendStringInfoChar(lex->strval, '\f'); - break; - case 'n': - appendStringInfoChar(lex->strval, '\n'); - break; - case 'r': - appendStringInfoChar(lex->strval, '\r'); - break; - case 't': - appendStringInfoChar(lex->strval, '\t'); - break; - default: - /* Not a valid string escape, so signal error. */ - lex->token_start = s; - lex->token_terminator = s + pg_mblen(s); - return JSON_ESCAPING_INVALID; - } - } - else if (strchr("\"\\/bfnrt", *s) == NULL) - { - /* - * Simpler processing if we're not bothered about de-escaping - * - * It's very tempting to remove the strchr() call here and - * replace it with a switch statement, but testing so far has - * shown it's not a performance win. - */ - lex->token_start = s; - lex->token_terminator = s + pg_mblen(s); - return JSON_ESCAPING_INVALID; - } - - } - else if (lex->strval != NULL) - { - if (hi_surrogate != -1) - return JSON_UNICODE_LOW_SURROGATE; - - appendStringInfoChar(lex->strval, *s); - } - - } - - if (hi_surrogate != -1) - return JSON_UNICODE_LOW_SURROGATE; - - /* Hooray, we found the end of the string! */ - lex->prev_token_terminator = lex->token_terminator; - lex->token_terminator = s + 1; - return JSON_SUCCESS; -} - -/* - * The next token in the input stream is known to be a number; lex it. - * - * In JSON, a number consists of four parts: - * - * (1) An optional minus sign ('-'). - * - * (2) Either a single '0', or a string of one or more digits that does not - * begin with a '0'. - * - * (3) An optional decimal part, consisting of a period ('.') followed by - * one or more digits. (Note: While this part can be omitted - * completely, it's not OK to have only the decimal point without - * any digits afterwards.) - * - * (4) An optional exponent part, consisting of 'e' or 'E', optionally - * followed by '+' or '-', followed by one or more digits. (Note: - * As with the decimal part, if 'e' or 'E' is present, it must be - * followed by at least one digit.) - * - * The 's' argument to this function points to the ostensible beginning - * of part 2 - i.e. the character after any optional minus sign, or the - * first character of the string if there is none. - * - * If num_err is not NULL, we return an error flag to *num_err rather than - * raising an error for a badly-formed number. Also, if total_len is not NULL - * the distance from lex->input to the token end+1 is returned to *total_len. - */ -static inline JsonParseErrorType -json_lex_number(JsonLexContext *lex, char *s, - bool *num_err, int *total_len) -{ - bool error = false; - int len = s - lex->input; - - /* Part (1): leading sign indicator. */ - /* Caller already did this for us; so do nothing. */ - - /* Part (2): parse main digit string. */ - if (len < lex->input_length && *s == '0') - { - s++; - len++; - } - else if (len < lex->input_length && *s >= '1' && *s <= '9') - { - do - { - s++; - len++; - } while (len < lex->input_length && *s >= '0' && *s <= '9'); - } - else - error = true; - - /* Part (3): parse optional decimal portion. */ - if (len < lex->input_length && *s == '.') - { - s++; - len++; - if (len == lex->input_length || *s < '0' || *s > '9') - error = true; - else - { - do - { - s++; - len++; - } while (len < lex->input_length && *s >= '0' && *s <= '9'); - } - } - - /* Part (4): parse optional exponent. */ - if (len < lex->input_length && (*s == 'e' || *s == 'E')) - { - s++; - len++; - if (len < lex->input_length && (*s == '+' || *s == '-')) - { - s++; - len++; - } - if (len == lex->input_length || *s < '0' || *s > '9') - error = true; - else - { - do - { - s++; - len++; - } while (len < lex->input_length && *s >= '0' && *s <= '9'); - } - } - - /* - * Check for trailing garbage. As in json_lex(), any alphanumeric stuff - * here should be considered part of the token for error-reporting - * purposes. - */ - for (; len < lex->input_length && JSON_ALPHANUMERIC_CHAR(*s); s++, len++) - error = true; - - if (total_len != NULL) - *total_len = len; - - if (num_err != NULL) - { - /* let the caller handle any error */ - *num_err = error; - } - else - { - /* return token endpoint */ - lex->prev_token_terminator = lex->token_terminator; - lex->token_terminator = s; - /* handle error if any */ - if (error) - return JSON_INVALID_TOKEN; - } - - return JSON_SUCCESS; -} - -/* - * Report a parse error. - * - * lex->token_start and lex->token_terminator must identify the current token. - */ -static JsonParseErrorType -report_parse_error(JsonParseContext ctx, JsonLexContext *lex) -{ - /* Handle case where the input ended prematurely. */ - if (lex->token_start == NULL || lex->token_type == JSON_TOKEN_END) - return JSON_EXPECTED_MORE; - - /* Otherwise choose the error type based on the parsing context. */ - switch (ctx) - { - case JSON_PARSE_END: - return JSON_EXPECTED_END; - case JSON_PARSE_VALUE: - return JSON_EXPECTED_JSON; - case JSON_PARSE_STRING: - return JSON_EXPECTED_STRING; - case JSON_PARSE_ARRAY_START: - return JSON_EXPECTED_ARRAY_FIRST; - case JSON_PARSE_ARRAY_NEXT: - return JSON_EXPECTED_ARRAY_NEXT; - case JSON_PARSE_OBJECT_START: - return JSON_EXPECTED_OBJECT_FIRST; - case JSON_PARSE_OBJECT_LABEL: - return JSON_EXPECTED_COLON; - case JSON_PARSE_OBJECT_NEXT: - return JSON_EXPECTED_OBJECT_NEXT; - case JSON_PARSE_OBJECT_COMMA: - return JSON_EXPECTED_STRING; - } - - /* - * We don't use a default: case, so that the compiler will warn about - * unhandled enum values. But this needs to be here anyway to cover the - * possibility of an incorrect input. - */ - elog(ERROR, "unexpected json parse state: %d", (int) ctx); - return JSON_SUCCESS; /* silence stupider compilers */ -} - -/* - * Construct a detail message for a JSON error. - */ -char * -json_errdetail(JsonParseErrorType error, JsonLexContext *lex) -{ - switch (error) - { - case JSON_SUCCESS: - /* fall through to the error code after switch */ - break; - case JSON_ESCAPING_INVALID: - return psprintf(_("Escape sequence \"\\%s\" is invalid."), - extract_token(lex)); - case JSON_ESCAPING_REQUIRED: - return psprintf(_("Character with value 0x%02x must be escaped."), - (unsigned char) *(lex->token_terminator)); - case JSON_EXPECTED_END: - return psprintf(_("Expected end of input, but found \"%s\"."), - extract_token(lex)); - case JSON_EXPECTED_ARRAY_FIRST: - return psprintf(_("Expected array element or \"]\", but found \"%s\"."), - extract_token(lex)); - case JSON_EXPECTED_ARRAY_NEXT: - return psprintf(_("Expected \",\" or \"]\", but found \"%s\"."), - extract_token(lex)); - case JSON_EXPECTED_COLON: - return psprintf(_("Expected \":\", but found \"%s\"."), - extract_token(lex)); - case JSON_EXPECTED_JSON: - return psprintf(_("Expected JSON value, but found \"%s\"."), - extract_token(lex)); - case JSON_EXPECTED_MORE: - return _("The input string ended unexpectedly."); - case JSON_EXPECTED_OBJECT_FIRST: - return psprintf(_("Expected string or \"}\", but found \"%s\"."), - extract_token(lex)); - case JSON_EXPECTED_OBJECT_NEXT: - return psprintf(_("Expected \",\" or \"}\", but found \"%s\"."), - extract_token(lex)); - case JSON_EXPECTED_STRING: - return psprintf(_("Expected string, but found \"%s\"."), - extract_token(lex)); - case JSON_INVALID_TOKEN: - return psprintf(_("Token \"%s\" is invalid."), - extract_token(lex)); - case JSON_UNICODE_CODE_POINT_ZERO: - return _("\\u0000 cannot be converted to text."); - case JSON_UNICODE_ESCAPE_FORMAT: - return _("\"\\u\" must be followed by four hexadecimal digits."); - case JSON_UNICODE_HIGH_ESCAPE: - return _("Unicode escape values cannot be used for code point values above 007F when the server encoding is not UTF8."); - case JSON_UNICODE_HIGH_SURROGATE: - return _("Unicode high surrogate must not follow a high surrogate."); - case JSON_UNICODE_LOW_SURROGATE: - return _("Unicode low surrogate must follow a high surrogate."); - } - - /* - * We don't use a default: case, so that the compiler will warn about - * unhandled enum values. But this needs to be here anyway to cover the - * possibility of an incorrect input. - */ - elog(ERROR, "unexpected json parse error type: %d", (int) error); - return NULL; /* silence stupider compilers */ -} - -/* - * Extract the current token from a lexing context, for error reporting. - */ -static char * -extract_token(JsonLexContext *lex) -{ - int toklen = lex->token_terminator - lex->token_start; - char *token = palloc(toklen + 1); - - memcpy(token, lex->token_start, toklen); - token[toklen] = '\0'; - return token; -} diff --git a/src/backend/utils/adt/jsonb.c b/src/backend/utils/adt/jsonb.c index c912f8932df..fea43359515 100644 --- a/src/backend/utils/adt/jsonb.c +++ b/src/backend/utils/adt/jsonb.c @@ -261,7 +261,7 @@ jsonb_from_cstring(char *json, int len) memset(&state, 0, sizeof(state)); memset(&sem, 0, sizeof(sem)); - lex = makeJsonLexContextCstringLen(json, len, true); + lex = makeJsonLexContextCstringLen(json, len, GetDatabaseEncoding(), true); sem.semstate = (void *) &state; diff --git a/src/backend/utils/adt/jsonb_util.c b/src/backend/utils/adt/jsonb_util.c index b33c3ef43ce..edec657cd3c 100644 --- a/src/backend/utils/adt/jsonb_util.c +++ b/src/backend/utils/adt/jsonb_util.c @@ -15,12 +15,12 @@ #include "catalog/pg_collation.h" #include "catalog/pg_type.h" +#include "common/jsonapi.h" #include "miscadmin.h" #include "utils/builtins.h" #include "utils/datetime.h" #include "utils/hashutils.h" #include "utils/json.h" -#include "utils/jsonapi.h" #include "utils/jsonb.h" #include "utils/memutils.h" #include "utils/varlena.h" diff --git a/src/backend/utils/adt/jsonfuncs.c b/src/backend/utils/adt/jsonfuncs.c index 66ea11b971c..4f6fd0de023 100644 --- a/src/backend/utils/adt/jsonfuncs.c +++ b/src/backend/utils/adt/jsonfuncs.c @@ -18,6 +18,7 @@ #include "access/htup_details.h" #include "catalog/pg_type.h" +#include "common/jsonapi.h" #include "fmgr.h" #include "funcapi.h" #include "lib/stringinfo.h" @@ -27,7 +28,6 @@ #include "utils/builtins.h" #include "utils/hsearch.h" #include "utils/json.h" -#include "utils/jsonapi.h" #include "utils/jsonb.h" #include "utils/jsonfuncs.h" #include "utils/lsyscache.h" @@ -514,6 +514,7 @@ makeJsonLexContext(text *json, bool need_escapes) { return makeJsonLexContextCstringLen(VARDATA_ANY(json), VARSIZE_ANY_EXHDR(json), + GetDatabaseEncoding(), need_escapes); } @@ -2605,7 +2606,7 @@ populate_array_json(PopulateArrayContext *ctx, char *json, int len) PopulateArrayState state; JsonSemAction sem; - state.lex = makeJsonLexContextCstringLen(json, len, true); + state.lex = makeJsonLexContextCstringLen(json, len, GetDatabaseEncoding(), true); state.ctx = ctx; memset(&sem, 0, sizeof(sem)); @@ -3448,7 +3449,7 @@ get_json_object_as_hash(char *json, int len, const char *funcname) HASHCTL ctl; HTAB *tab; JHashState *state; - JsonLexContext *lex = makeJsonLexContextCstringLen(json, len, true); + JsonLexContext *lex = makeJsonLexContextCstringLen(json, len, GetDatabaseEncoding(), true); JsonSemAction *sem; memset(&ctl, 0, sizeof(ctl)); diff --git a/src/common/Makefile b/src/common/Makefile index 44ca68fa6c3..e757fb73996 100644 --- a/src/common/Makefile +++ b/src/common/Makefile @@ -56,6 +56,7 @@ OBJS_COMMON = \ f2s.o \ file_perm.o \ ip.o \ + jsonapi.o \ keywords.o \ kwlookup.o \ link-canary.o \ diff --git a/src/common/jsonapi.c b/src/common/jsonapi.c new file mode 100644 index 00000000000..f08a03c1690 --- /dev/null +++ b/src/common/jsonapi.c @@ -0,0 +1,1114 @@ +/*------------------------------------------------------------------------- + * + * jsonapi.c + * JSON parser and lexer interfaces + * + * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group + * Portions Copyright (c) 1994, Regents of the University of California + * + * IDENTIFICATION + * src/common/jsonapi.c + * + *------------------------------------------------------------------------- + */ +#ifndef FRONTEND +#include "postgres.h" +#else +#include "postgres_fe.h" +#endif + +#include "common/jsonapi.h" +#include "mb/pg_wchar.h" + +#ifdef FRONTEND +#include "common/logging.h" +#else +#include "miscadmin.h" +#endif + +#ifdef FRONTEND +#define check_stack_depth() +#define json_log_and_abort(...) \ + do { pg_log_fatal(__VA_ARGS__); exit(1); } while(0) +#else +#define json_log_and_abort(...) elog(ERROR, __VA_ARGS__) +#endif + +/* + * The context of the parser is maintained by the recursive descent + * mechanism, but is passed explicitly to the error reporting routine + * for better diagnostics. + */ +typedef enum /* contexts of JSON parser */ +{ + JSON_PARSE_VALUE, /* expecting a value */ + JSON_PARSE_STRING, /* expecting a string (for a field name) */ + JSON_PARSE_ARRAY_START, /* saw '[', expecting value or ']' */ + JSON_PARSE_ARRAY_NEXT, /* saw array element, expecting ',' or ']' */ + JSON_PARSE_OBJECT_START, /* saw '{', expecting label or '}' */ + JSON_PARSE_OBJECT_LABEL, /* saw object label, expecting ':' */ + JSON_PARSE_OBJECT_NEXT, /* saw object value, expecting ',' or '}' */ + JSON_PARSE_OBJECT_COMMA, /* saw object ',', expecting next label */ + JSON_PARSE_END /* saw the end of a document, expect nothing */ +} JsonParseContext; + +static inline JsonParseErrorType json_lex_string(JsonLexContext *lex); +static inline JsonParseErrorType json_lex_number(JsonLexContext *lex, char *s, + bool *num_err, int *total_len); +static inline JsonParseErrorType parse_scalar(JsonLexContext *lex, JsonSemAction *sem); +static JsonParseErrorType parse_object_field(JsonLexContext *lex, JsonSemAction *sem); +static JsonParseErrorType parse_object(JsonLexContext *lex, JsonSemAction *sem); +static JsonParseErrorType parse_array_element(JsonLexContext *lex, JsonSemAction *sem); +static JsonParseErrorType parse_array(JsonLexContext *lex, JsonSemAction *sem); +static JsonParseErrorType report_parse_error(JsonParseContext ctx, JsonLexContext *lex); +static char *extract_token(JsonLexContext *lex); + +/* the null action object used for pure validation */ +JsonSemAction nullSemAction = +{ + NULL, NULL, NULL, NULL, NULL, + NULL, NULL, NULL, NULL, NULL +}; + +/* Recursive Descent parser support routines */ + +/* + * lex_peek + * + * what is the current look_ahead token? +*/ +static inline JsonTokenType +lex_peek(JsonLexContext *lex) +{ + return lex->token_type; +} + +/* + * lex_expect + * + * move the lexer to the next token if the current look_ahead token matches + * the parameter token. Otherwise, report an error. + */ +static inline JsonParseErrorType +lex_expect(JsonParseContext ctx, JsonLexContext *lex, JsonTokenType token) +{ + if (lex_peek(lex) == token) + return json_lex(lex); + else + return report_parse_error(ctx, lex); +} + +/* chars to consider as part of an alphanumeric token */ +#define JSON_ALPHANUMERIC_CHAR(c) \ + (((c) >= 'a' && (c) <= 'z') || \ + ((c) >= 'A' && (c) <= 'Z') || \ + ((c) >= '0' && (c) <= '9') || \ + (c) == '_' || \ + IS_HIGHBIT_SET(c)) + +/* + * Utility function to check if a string is a valid JSON number. + * + * str is of length len, and need not be null-terminated. + */ +bool +IsValidJsonNumber(const char *str, int len) +{ + bool numeric_error; + int total_len; + JsonLexContext dummy_lex; + + if (len <= 0) + return false; + + /* + * json_lex_number expects a leading '-' to have been eaten already. + * + * having to cast away the constness of str is ugly, but there's not much + * easy alternative. + */ + if (*str == '-') + { + dummy_lex.input = unconstify(char *, str) +1; + dummy_lex.input_length = len - 1; + } + else + { + dummy_lex.input = unconstify(char *, str); + dummy_lex.input_length = len; + } + + json_lex_number(&dummy_lex, dummy_lex.input, &numeric_error, &total_len); + + return (!numeric_error) && (total_len == dummy_lex.input_length); +} + +/* + * makeJsonLexContextCstringLen + * + * lex constructor, with or without StringInfo object for de-escaped lexemes. + * + * Without is better as it makes the processing faster, so only make one + * if really required. + */ +JsonLexContext * +makeJsonLexContextCstringLen(char *json, int len, int encoding, bool need_escapes) +{ + JsonLexContext *lex = palloc0(sizeof(JsonLexContext)); + + lex->input = lex->token_terminator = lex->line_start = json; + lex->line_number = 1; + lex->input_length = len; + lex->input_encoding = encoding; + if (need_escapes) + lex->strval = makeStringInfo(); + return lex; +} + +/* + * pg_parse_json + * + * Publicly visible entry point for the JSON parser. + * + * lex is a lexing context, set up for the json to be processed by calling + * makeJsonLexContext(). sem is a structure of function pointers to semantic + * action routines to be called at appropriate spots during parsing, and a + * pointer to a state object to be passed to those routines. + */ +JsonParseErrorType +pg_parse_json(JsonLexContext *lex, JsonSemAction *sem) +{ + JsonTokenType tok; + JsonParseErrorType result; + + /* get the initial token */ + result = json_lex(lex); + if (result != JSON_SUCCESS) + return result; + + tok = lex_peek(lex); + + /* parse by recursive descent */ + switch (tok) + { + case JSON_TOKEN_OBJECT_START: + result = parse_object(lex, sem); + break; + case JSON_TOKEN_ARRAY_START: + result = parse_array(lex, sem); + break; + default: + result = parse_scalar(lex, sem); /* json can be a bare scalar */ + } + + if (result == JSON_SUCCESS) + result = lex_expect(JSON_PARSE_END, lex, JSON_TOKEN_END); + + return result; +} + +/* + * json_count_array_elements + * + * Returns number of array elements in lex context at start of array token + * until end of array token at same nesting level. + * + * Designed to be called from array_start routines. + */ +JsonParseErrorType +json_count_array_elements(JsonLexContext *lex, int *elements) +{ + JsonLexContext copylex; + int count; + JsonParseErrorType result; + + /* + * It's safe to do this with a shallow copy because the lexical routines + * don't scribble on the input. They do scribble on the other pointers + * etc, so doing this with a copy makes that safe. + */ + memcpy(©lex, lex, sizeof(JsonLexContext)); + copylex.strval = NULL; /* not interested in values here */ + copylex.lex_level++; + + count = 0; + result = lex_expect(JSON_PARSE_ARRAY_START, ©lex, + JSON_TOKEN_ARRAY_START); + if (result != JSON_SUCCESS) + return result; + if (lex_peek(©lex) != JSON_TOKEN_ARRAY_END) + { + while (1) + { + count++; + result = parse_array_element(©lex, &nullSemAction); + if (result != JSON_SUCCESS) + return result; + if (copylex.token_type != JSON_TOKEN_COMMA) + break; + result = json_lex(©lex); + if (result != JSON_SUCCESS) + return result; + } + } + result = lex_expect(JSON_PARSE_ARRAY_NEXT, ©lex, + JSON_TOKEN_ARRAY_END); + if (result != JSON_SUCCESS) + return result; + + *elements = count; + return JSON_SUCCESS; +} + +/* + * Recursive Descent parse routines. There is one for each structural + * element in a json document: + * - scalar (string, number, true, false, null) + * - array ( [ ] ) + * - array element + * - object ( { } ) + * - object field + */ +static inline JsonParseErrorType +parse_scalar(JsonLexContext *lex, JsonSemAction *sem) +{ + char *val = NULL; + json_scalar_action sfunc = sem->scalar; + JsonTokenType tok = lex_peek(lex); + JsonParseErrorType result; + + /* a scalar must be a string, a number, true, false, or null */ + if (tok != JSON_TOKEN_STRING && tok != JSON_TOKEN_NUMBER && + tok != JSON_TOKEN_TRUE && tok != JSON_TOKEN_FALSE && + tok != JSON_TOKEN_NULL) + return report_parse_error(JSON_PARSE_VALUE, lex); + + /* if no semantic function, just consume the token */ + if (sfunc == NULL) + return json_lex(lex); + + /* extract the de-escaped string value, or the raw lexeme */ + if (lex_peek(lex) == JSON_TOKEN_STRING) + { + if (lex->strval != NULL) + val = pstrdup(lex->strval->data); + } + else + { + int len = (lex->token_terminator - lex->token_start); + + val = palloc(len + 1); + memcpy(val, lex->token_start, len); + val[len] = '\0'; + } + + /* consume the token */ + result = json_lex(lex); + if (result != JSON_SUCCESS) + return result; + + /* invoke the callback */ + (*sfunc) (sem->semstate, val, tok); + + return JSON_SUCCESS; +} + +static JsonParseErrorType +parse_object_field(JsonLexContext *lex, JsonSemAction *sem) +{ + /* + * An object field is "fieldname" : value where value can be a scalar, + * object or array. Note: in user-facing docs and error messages, we + * generally call a field name a "key". + */ + + char *fname = NULL; /* keep compiler quiet */ + json_ofield_action ostart = sem->object_field_start; + json_ofield_action oend = sem->object_field_end; + bool isnull; + JsonTokenType tok; + JsonParseErrorType result; + + if (lex_peek(lex) != JSON_TOKEN_STRING) + return report_parse_error(JSON_PARSE_STRING, lex); + if ((ostart != NULL || oend != NULL) && lex->strval != NULL) + fname = pstrdup(lex->strval->data); + result = json_lex(lex); + if (result != JSON_SUCCESS) + return result; + + result = lex_expect(JSON_PARSE_OBJECT_LABEL, lex, JSON_TOKEN_COLON); + if (result != JSON_SUCCESS) + return result; + + tok = lex_peek(lex); + isnull = tok == JSON_TOKEN_NULL; + + if (ostart != NULL) + (*ostart) (sem->semstate, fname, isnull); + + switch (tok) + { + case JSON_TOKEN_OBJECT_START: + result = parse_object(lex, sem); + break; + case JSON_TOKEN_ARRAY_START: + result = parse_array(lex, sem); + break; + default: + result = parse_scalar(lex, sem); + } + if (result != JSON_SUCCESS) + return result; + + if (oend != NULL) + (*oend) (sem->semstate, fname, isnull); + return JSON_SUCCESS; +} + +static JsonParseErrorType +parse_object(JsonLexContext *lex, JsonSemAction *sem) +{ + /* + * an object is a possibly empty sequence of object fields, separated by + * commas and surrounded by curly braces. + */ + json_struct_action ostart = sem->object_start; + json_struct_action oend = sem->object_end; + JsonTokenType tok; + JsonParseErrorType result; + + check_stack_depth(); + + if (ostart != NULL) + (*ostart) (sem->semstate); + + /* + * Data inside an object is at a higher nesting level than the object + * itself. Note that we increment this after we call the semantic routine + * for the object start and restore it before we call the routine for the + * object end. + */ + lex->lex_level++; + + Assert(lex_peek(lex) == JSON_TOKEN_OBJECT_START); + result = json_lex(lex); + if (result != JSON_SUCCESS) + return result; + + tok = lex_peek(lex); + switch (tok) + { + case JSON_TOKEN_STRING: + result = parse_object_field(lex, sem); + while (result == JSON_SUCCESS && lex_peek(lex) == JSON_TOKEN_COMMA) + { + result = json_lex(lex); + if (result != JSON_SUCCESS) + break; + result = parse_object_field(lex, sem); + } + break; + case JSON_TOKEN_OBJECT_END: + break; + default: + /* case of an invalid initial token inside the object */ + result = report_parse_error(JSON_PARSE_OBJECT_START, lex); + } + if (result != JSON_SUCCESS) + return result; + + result = lex_expect(JSON_PARSE_OBJECT_NEXT, lex, JSON_TOKEN_OBJECT_END); + if (result != JSON_SUCCESS) + return result; + + lex->lex_level--; + + if (oend != NULL) + (*oend) (sem->semstate); + + return JSON_SUCCESS; +} + +static JsonParseErrorType +parse_array_element(JsonLexContext *lex, JsonSemAction *sem) +{ + json_aelem_action astart = sem->array_element_start; + json_aelem_action aend = sem->array_element_end; + JsonTokenType tok = lex_peek(lex); + JsonParseErrorType result; + + bool isnull; + + isnull = tok == JSON_TOKEN_NULL; + + if (astart != NULL) + (*astart) (sem->semstate, isnull); + + /* an array element is any object, array or scalar */ + switch (tok) + { + case JSON_TOKEN_OBJECT_START: + result = parse_object(lex, sem); + break; + case JSON_TOKEN_ARRAY_START: + result = parse_array(lex, sem); + break; + default: + result = parse_scalar(lex, sem); + } + + if (result != JSON_SUCCESS) + return result; + + if (aend != NULL) + (*aend) (sem->semstate, isnull); + + return JSON_SUCCESS; +} + +static JsonParseErrorType +parse_array(JsonLexContext *lex, JsonSemAction *sem) +{ + /* + * an array is a possibly empty sequence of array elements, separated by + * commas and surrounded by square brackets. + */ + json_struct_action astart = sem->array_start; + json_struct_action aend = sem->array_end; + JsonParseErrorType result; + + check_stack_depth(); + + if (astart != NULL) + (*astart) (sem->semstate); + + /* + * Data inside an array is at a higher nesting level than the array + * itself. Note that we increment this after we call the semantic routine + * for the array start and restore it before we call the routine for the + * array end. + */ + lex->lex_level++; + + result = lex_expect(JSON_PARSE_ARRAY_START, lex, JSON_TOKEN_ARRAY_START); + if (result == JSON_SUCCESS && lex_peek(lex) != JSON_TOKEN_ARRAY_END) + { + result = parse_array_element(lex, sem); + + while (result == JSON_SUCCESS && lex_peek(lex) == JSON_TOKEN_COMMA) + { + result = json_lex(lex); + if (result != JSON_SUCCESS) + break; + result = parse_array_element(lex, sem); + } + } + if (result != JSON_SUCCESS) + return result; + + result = lex_expect(JSON_PARSE_ARRAY_NEXT, lex, JSON_TOKEN_ARRAY_END); + if (result != JSON_SUCCESS) + return result; + + lex->lex_level--; + + if (aend != NULL) + (*aend) (sem->semstate); + + return JSON_SUCCESS; +} + +/* + * Lex one token from the input stream. + */ +JsonParseErrorType +json_lex(JsonLexContext *lex) +{ + char *s; + int len; + JsonParseErrorType result; + + /* Skip leading whitespace. */ + s = lex->token_terminator; + len = s - lex->input; + while (len < lex->input_length && + (*s == ' ' || *s == '\t' || *s == '\n' || *s == '\r')) + { + if (*s == '\n') + ++lex->line_number; + ++s; + ++len; + } + lex->token_start = s; + + /* Determine token type. */ + if (len >= lex->input_length) + { + lex->token_start = NULL; + lex->prev_token_terminator = lex->token_terminator; + lex->token_terminator = s; + lex->token_type = JSON_TOKEN_END; + } + else + { + switch (*s) + { + /* Single-character token, some kind of punctuation mark. */ + case '{': + lex->prev_token_terminator = lex->token_terminator; + lex->token_terminator = s + 1; + lex->token_type = JSON_TOKEN_OBJECT_START; + break; + case '}': + lex->prev_token_terminator = lex->token_terminator; + lex->token_terminator = s + 1; + lex->token_type = JSON_TOKEN_OBJECT_END; + break; + case '[': + lex->prev_token_terminator = lex->token_terminator; + lex->token_terminator = s + 1; + lex->token_type = JSON_TOKEN_ARRAY_START; + break; + case ']': + lex->prev_token_terminator = lex->token_terminator; + lex->token_terminator = s + 1; + lex->token_type = JSON_TOKEN_ARRAY_END; + break; + case ',': + lex->prev_token_terminator = lex->token_terminator; + lex->token_terminator = s + 1; + lex->token_type = JSON_TOKEN_COMMA; + break; + case ':': + lex->prev_token_terminator = lex->token_terminator; + lex->token_terminator = s + 1; + lex->token_type = JSON_TOKEN_COLON; + break; + case '"': + /* string */ + result = json_lex_string(lex); + if (result != JSON_SUCCESS) + return result; + lex->token_type = JSON_TOKEN_STRING; + break; + case '-': + /* Negative number. */ + result = json_lex_number(lex, s + 1, NULL, NULL); + if (result != JSON_SUCCESS) + return result; + lex->token_type = JSON_TOKEN_NUMBER; + break; + case '0': + case '1': + case '2': + case '3': + case '4': + case '5': + case '6': + case '7': + case '8': + case '9': + /* Positive number. */ + result = json_lex_number(lex, s, NULL, NULL); + if (result != JSON_SUCCESS) + return result; + lex->token_type = JSON_TOKEN_NUMBER; + break; + default: + { + char *p; + + /* + * We're not dealing with a string, number, legal + * punctuation mark, or end of string. The only legal + * tokens we might find here are true, false, and null, + * but for error reporting purposes we scan until we see a + * non-alphanumeric character. That way, we can report + * the whole word as an unexpected token, rather than just + * some unintuitive prefix thereof. + */ + for (p = s; p - s < lex->input_length - len && JSON_ALPHANUMERIC_CHAR(*p); p++) + /* skip */ ; + + /* + * We got some sort of unexpected punctuation or an + * otherwise unexpected character, so just complain about + * that one character. + */ + if (p == s) + { + lex->prev_token_terminator = lex->token_terminator; + lex->token_terminator = s + 1; + return JSON_INVALID_TOKEN; + } + + /* + * We've got a real alphanumeric token here. If it + * happens to be true, false, or null, all is well. If + * not, error out. + */ + lex->prev_token_terminator = lex->token_terminator; + lex->token_terminator = p; + if (p - s == 4) + { + if (memcmp(s, "true", 4) == 0) + lex->token_type = JSON_TOKEN_TRUE; + else if (memcmp(s, "null", 4) == 0) + lex->token_type = JSON_TOKEN_NULL; + else + return JSON_INVALID_TOKEN; + } + else if (p - s == 5 && memcmp(s, "false", 5) == 0) + lex->token_type = JSON_TOKEN_FALSE; + else + return JSON_INVALID_TOKEN; + + } + } /* end of switch */ + } + + return JSON_SUCCESS; +} + +/* + * The next token in the input stream is known to be a string; lex it. + */ +static inline JsonParseErrorType +json_lex_string(JsonLexContext *lex) +{ + char *s; + int len; + int hi_surrogate = -1; + + if (lex->strval != NULL) + resetStringInfo(lex->strval); + + Assert(lex->input_length > 0); + s = lex->token_start; + len = lex->token_start - lex->input; + for (;;) + { + s++; + len++; + /* Premature end of the string. */ + if (len >= lex->input_length) + { + lex->token_terminator = s; + return JSON_INVALID_TOKEN; + } + else if (*s == '"') + break; + else if ((unsigned char) *s < 32) + { + /* Per RFC4627, these characters MUST be escaped. */ + /* Since *s isn't printable, exclude it from the context string */ + lex->token_terminator = s; + return JSON_ESCAPING_REQUIRED; + } + else if (*s == '\\') + { + /* OK, we have an escape character. */ + s++; + len++; + if (len >= lex->input_length) + { + lex->token_terminator = s; + return JSON_INVALID_TOKEN; + } + else if (*s == 'u') + { + int i; + int ch = 0; + + for (i = 1; i <= 4; i++) + { + s++; + len++; + if (len >= lex->input_length) + { + lex->token_terminator = s; + return JSON_INVALID_TOKEN; + } + else if (*s >= '0' && *s <= '9') + ch = (ch * 16) + (*s - '0'); + else if (*s >= 'a' && *s <= 'f') + ch = (ch * 16) + (*s - 'a') + 10; + else if (*s >= 'A' && *s <= 'F') + ch = (ch * 16) + (*s - 'A') + 10; + else + { + lex->token_terminator = s + pg_encoding_mblen(lex->input_encoding, s); + return JSON_UNICODE_ESCAPE_FORMAT; + } + } + if (lex->strval != NULL) + { + char utf8str[5]; + int utf8len; + + if (ch >= 0xd800 && ch <= 0xdbff) + { + if (hi_surrogate != -1) + return JSON_UNICODE_HIGH_SURROGATE; + hi_surrogate = (ch & 0x3ff) << 10; + continue; + } + else if (ch >= 0xdc00 && ch <= 0xdfff) + { + if (hi_surrogate == -1) + return JSON_UNICODE_LOW_SURROGATE; + ch = 0x10000 + hi_surrogate + (ch & 0x3ff); + hi_surrogate = -1; + } + + if (hi_surrogate != -1) + return JSON_UNICODE_LOW_SURROGATE; + + /* + * For UTF8, replace the escape sequence by the actual + * utf8 character in lex->strval. Do this also for other + * encodings if the escape designates an ASCII character, + * otherwise raise an error. + */ + + if (ch == 0) + { + /* We can't allow this, since our TEXT type doesn't */ + return JSON_UNICODE_CODE_POINT_ZERO; + } + else if (lex->input_encoding == PG_UTF8) + { + unicode_to_utf8(ch, (unsigned char *) utf8str); + utf8len = pg_utf_mblen((unsigned char *) utf8str); + appendBinaryStringInfo(lex->strval, utf8str, utf8len); + } + else if (ch <= 0x007f) + { + /* + * This is the only way to designate things like a + * form feed character in JSON, so it's useful in all + * encodings. + */ + appendStringInfoChar(lex->strval, (char) ch); + } + else + return JSON_UNICODE_HIGH_ESCAPE; + + } + } + else if (lex->strval != NULL) + { + if (hi_surrogate != -1) + return JSON_UNICODE_LOW_SURROGATE; + + switch (*s) + { + case '"': + case '\\': + case '/': + appendStringInfoChar(lex->strval, *s); + break; + case 'b': + appendStringInfoChar(lex->strval, '\b'); + break; + case 'f': + appendStringInfoChar(lex->strval, '\f'); + break; + case 'n': + appendStringInfoChar(lex->strval, '\n'); + break; + case 'r': + appendStringInfoChar(lex->strval, '\r'); + break; + case 't': + appendStringInfoChar(lex->strval, '\t'); + break; + default: + /* Not a valid string escape, so signal error. */ + lex->token_start = s; + lex->token_terminator = s + pg_encoding_mblen(lex->input_encoding, s); + return JSON_ESCAPING_INVALID; + } + } + else if (strchr("\"\\/bfnrt", *s) == NULL) + { + /* + * Simpler processing if we're not bothered about de-escaping + * + * It's very tempting to remove the strchr() call here and + * replace it with a switch statement, but testing so far has + * shown it's not a performance win. + */ + lex->token_start = s; + lex->token_terminator = s + pg_encoding_mblen(lex->input_encoding, s); + return JSON_ESCAPING_INVALID; + } + + } + else if (lex->strval != NULL) + { + if (hi_surrogate != -1) + return JSON_UNICODE_LOW_SURROGATE; + + appendStringInfoChar(lex->strval, *s); + } + + } + + if (hi_surrogate != -1) + return JSON_UNICODE_LOW_SURROGATE; + + /* Hooray, we found the end of the string! */ + lex->prev_token_terminator = lex->token_terminator; + lex->token_terminator = s + 1; + return JSON_SUCCESS; +} + +/* + * The next token in the input stream is known to be a number; lex it. + * + * In JSON, a number consists of four parts: + * + * (1) An optional minus sign ('-'). + * + * (2) Either a single '0', or a string of one or more digits that does not + * begin with a '0'. + * + * (3) An optional decimal part, consisting of a period ('.') followed by + * one or more digits. (Note: While this part can be omitted + * completely, it's not OK to have only the decimal point without + * any digits afterwards.) + * + * (4) An optional exponent part, consisting of 'e' or 'E', optionally + * followed by '+' or '-', followed by one or more digits. (Note: + * As with the decimal part, if 'e' or 'E' is present, it must be + * followed by at least one digit.) + * + * The 's' argument to this function points to the ostensible beginning + * of part 2 - i.e. the character after any optional minus sign, or the + * first character of the string if there is none. + * + * If num_err is not NULL, we return an error flag to *num_err rather than + * raising an error for a badly-formed number. Also, if total_len is not NULL + * the distance from lex->input to the token end+1 is returned to *total_len. + */ +static inline JsonParseErrorType +json_lex_number(JsonLexContext *lex, char *s, + bool *num_err, int *total_len) +{ + bool error = false; + int len = s - lex->input; + + /* Part (1): leading sign indicator. */ + /* Caller already did this for us; so do nothing. */ + + /* Part (2): parse main digit string. */ + if (len < lex->input_length && *s == '0') + { + s++; + len++; + } + else if (len < lex->input_length && *s >= '1' && *s <= '9') + { + do + { + s++; + len++; + } while (len < lex->input_length && *s >= '0' && *s <= '9'); + } + else + error = true; + + /* Part (3): parse optional decimal portion. */ + if (len < lex->input_length && *s == '.') + { + s++; + len++; + if (len == lex->input_length || *s < '0' || *s > '9') + error = true; + else + { + do + { + s++; + len++; + } while (len < lex->input_length && *s >= '0' && *s <= '9'); + } + } + + /* Part (4): parse optional exponent. */ + if (len < lex->input_length && (*s == 'e' || *s == 'E')) + { + s++; + len++; + if (len < lex->input_length && (*s == '+' || *s == '-')) + { + s++; + len++; + } + if (len == lex->input_length || *s < '0' || *s > '9') + error = true; + else + { + do + { + s++; + len++; + } while (len < lex->input_length && *s >= '0' && *s <= '9'); + } + } + + /* + * Check for trailing garbage. As in json_lex(), any alphanumeric stuff + * here should be considered part of the token for error-reporting + * purposes. + */ + for (; len < lex->input_length && JSON_ALPHANUMERIC_CHAR(*s); s++, len++) + error = true; + + if (total_len != NULL) + *total_len = len; + + if (num_err != NULL) + { + /* let the caller handle any error */ + *num_err = error; + } + else + { + /* return token endpoint */ + lex->prev_token_terminator = lex->token_terminator; + lex->token_terminator = s; + /* handle error if any */ + if (error) + return JSON_INVALID_TOKEN; + } + + return JSON_SUCCESS; +} + +/* + * Report a parse error. + * + * lex->token_start and lex->token_terminator must identify the current token. + */ +static JsonParseErrorType +report_parse_error(JsonParseContext ctx, JsonLexContext *lex) +{ + /* Handle case where the input ended prematurely. */ + if (lex->token_start == NULL || lex->token_type == JSON_TOKEN_END) + return JSON_EXPECTED_MORE; + + /* Otherwise choose the error type based on the parsing context. */ + switch (ctx) + { + case JSON_PARSE_END: + return JSON_EXPECTED_END; + case JSON_PARSE_VALUE: + return JSON_EXPECTED_JSON; + case JSON_PARSE_STRING: + return JSON_EXPECTED_STRING; + case JSON_PARSE_ARRAY_START: + return JSON_EXPECTED_ARRAY_FIRST; + case JSON_PARSE_ARRAY_NEXT: + return JSON_EXPECTED_ARRAY_NEXT; + case JSON_PARSE_OBJECT_START: + return JSON_EXPECTED_OBJECT_FIRST; + case JSON_PARSE_OBJECT_LABEL: + return JSON_EXPECTED_COLON; + case JSON_PARSE_OBJECT_NEXT: + return JSON_EXPECTED_OBJECT_NEXT; + case JSON_PARSE_OBJECT_COMMA: + return JSON_EXPECTED_STRING; + } + + /* + * We don't use a default: case, so that the compiler will warn about + * unhandled enum values. But this needs to be here anyway to cover the + * possibility of an incorrect input. + */ + json_log_and_abort("unexpected json parse state: %d", (int) ctx); + return JSON_SUCCESS; /* silence stupider compilers */ +} + +/* + * Construct a detail message for a JSON error. + */ +char * +json_errdetail(JsonParseErrorType error, JsonLexContext *lex) +{ + switch (error) + { + case JSON_SUCCESS: + /* fall through to the error code after switch */ + break; + case JSON_ESCAPING_INVALID: + return psprintf(_("Escape sequence \"\\%s\" is invalid."), + extract_token(lex)); + case JSON_ESCAPING_REQUIRED: + return psprintf(_("Character with value 0x%02x must be escaped."), + (unsigned char) *(lex->token_terminator)); + case JSON_EXPECTED_END: + return psprintf(_("Expected end of input, but found \"%s\"."), + extract_token(lex)); + case JSON_EXPECTED_ARRAY_FIRST: + return psprintf(_("Expected array element or \"]\", but found \"%s\"."), + extract_token(lex)); + case JSON_EXPECTED_ARRAY_NEXT: + return psprintf(_("Expected \",\" or \"]\", but found \"%s\"."), + extract_token(lex)); + case JSON_EXPECTED_COLON: + return psprintf(_("Expected \":\", but found \"%s\"."), + extract_token(lex)); + case JSON_EXPECTED_JSON: + return psprintf(_("Expected JSON value, but found \"%s\"."), + extract_token(lex)); + case JSON_EXPECTED_MORE: + return _("The input string ended unexpectedly."); + case JSON_EXPECTED_OBJECT_FIRST: + return psprintf(_("Expected string or \"}\", but found \"%s\"."), + extract_token(lex)); + case JSON_EXPECTED_OBJECT_NEXT: + return psprintf(_("Expected \",\" or \"}\", but found \"%s\"."), + extract_token(lex)); + case JSON_EXPECTED_STRING: + return psprintf(_("Expected string, but found \"%s\"."), + extract_token(lex)); + case JSON_INVALID_TOKEN: + return psprintf(_("Token \"%s\" is invalid."), + extract_token(lex)); + case JSON_UNICODE_CODE_POINT_ZERO: + return _("\\u0000 cannot be converted to text."); + case JSON_UNICODE_ESCAPE_FORMAT: + return _("\"\\u\" must be followed by four hexadecimal digits."); + case JSON_UNICODE_HIGH_ESCAPE: + return _("Unicode escape values cannot be used for code point values above 007F when the server encoding is not UTF8."); + case JSON_UNICODE_HIGH_SURROGATE: + return _("Unicode high surrogate must not follow a high surrogate."); + case JSON_UNICODE_LOW_SURROGATE: + return _("Unicode low surrogate must follow a high surrogate."); + } + + /* + * We don't use a default: case, so that the compiler will warn about + * unhandled enum values. But this needs to be here anyway to cover the + * possibility of an incorrect input. + */ + json_log_and_abort("unexpected json parse error type: %d", (int) error); + return NULL; /* silence stupider compilers */ +} + +/* + * Extract the current token from a lexing context, for error reporting. + */ +static char * +extract_token(JsonLexContext *lex) +{ + int toklen = lex->token_terminator - lex->token_start; + char *token = palloc(toklen + 1); + + memcpy(token, lex->token_start, toklen); + token[toklen] = '\0'; + return token; +} diff --git a/src/include/common/jsonapi.h b/src/include/common/jsonapi.h new file mode 100644 index 00000000000..bcfd57cc53c --- /dev/null +++ b/src/include/common/jsonapi.h @@ -0,0 +1,169 @@ +/*------------------------------------------------------------------------- + * + * jsonapi.h + * Declarations for JSON API support. + * + * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group + * Portions Copyright (c) 1994, Regents of the University of California + * + * src/include/utils/jsonapi.h + * + *------------------------------------------------------------------------- + */ + +#ifndef JSONAPI_H +#define JSONAPI_H + +#include "lib/stringinfo.h" + +typedef enum +{ + JSON_TOKEN_INVALID, + JSON_TOKEN_STRING, + JSON_TOKEN_NUMBER, + JSON_TOKEN_OBJECT_START, + JSON_TOKEN_OBJECT_END, + JSON_TOKEN_ARRAY_START, + JSON_TOKEN_ARRAY_END, + JSON_TOKEN_COMMA, + JSON_TOKEN_COLON, + JSON_TOKEN_TRUE, + JSON_TOKEN_FALSE, + JSON_TOKEN_NULL, + JSON_TOKEN_END +} JsonTokenType; + +typedef enum +{ + JSON_SUCCESS, + JSON_ESCAPING_INVALID, + JSON_ESCAPING_REQUIRED, + JSON_EXPECTED_ARRAY_FIRST, + JSON_EXPECTED_ARRAY_NEXT, + JSON_EXPECTED_COLON, + JSON_EXPECTED_END, + JSON_EXPECTED_JSON, + JSON_EXPECTED_MORE, + JSON_EXPECTED_OBJECT_FIRST, + JSON_EXPECTED_OBJECT_NEXT, + JSON_EXPECTED_STRING, + JSON_INVALID_TOKEN, + JSON_UNICODE_CODE_POINT_ZERO, + JSON_UNICODE_ESCAPE_FORMAT, + JSON_UNICODE_HIGH_ESCAPE, + JSON_UNICODE_HIGH_SURROGATE, + JSON_UNICODE_LOW_SURROGATE +} JsonParseErrorType; + + +/* + * All the fields in this structure should be treated as read-only. + * + * If strval is not null, then it should contain the de-escaped value + * of the lexeme if it's a string. Otherwise most of these field names + * should be self-explanatory. + * + * line_number and line_start are principally for use by the parser's + * error reporting routines. + * token_terminator and prev_token_terminator point to the character + * AFTER the end of the token, i.e. where there would be a nul byte + * if we were using nul-terminated strings. + */ +typedef struct JsonLexContext +{ + char *input; + int input_length; + int input_encoding; + char *token_start; + char *token_terminator; + char *prev_token_terminator; + JsonTokenType token_type; + int lex_level; + int line_number; + char *line_start; + StringInfo strval; +} JsonLexContext; + +typedef void (*json_struct_action) (void *state); +typedef void (*json_ofield_action) (void *state, char *fname, bool isnull); +typedef void (*json_aelem_action) (void *state, bool isnull); +typedef void (*json_scalar_action) (void *state, char *token, JsonTokenType tokentype); + + +/* + * Semantic Action structure for use in parsing json. + * Any of these actions can be NULL, in which case nothing is done at that + * point, Likewise, semstate can be NULL. Using an all-NULL structure amounts + * to doing a pure parse with no side-effects, and is therefore exactly + * what the json input routines do. + * + * The 'fname' and 'token' strings passed to these actions are palloc'd. + * They are not free'd or used further by the parser, so the action function + * is free to do what it wishes with them. + */ +typedef struct JsonSemAction +{ + void *semstate; + json_struct_action object_start; + json_struct_action object_end; + json_struct_action array_start; + json_struct_action array_end; + json_ofield_action object_field_start; + json_ofield_action object_field_end; + json_aelem_action array_element_start; + json_aelem_action array_element_end; + json_scalar_action scalar; +} JsonSemAction; + +/* + * pg_parse_json will parse the string in the lex calling the + * action functions in sem at the appropriate points. It is + * up to them to keep what state they need in semstate. If they + * need access to the state of the lexer, then its pointer + * should be passed to them as a member of whatever semstate + * points to. If the action pointers are NULL the parser + * does nothing and just continues. + */ +extern JsonParseErrorType pg_parse_json(JsonLexContext *lex, + JsonSemAction *sem); + +/* the null action object used for pure validation */ +extern JsonSemAction nullSemAction; + +/* + * json_count_array_elements performs a fast secondary parse to determine the + * number of elements in passed array lex context. It should be called from an + * array_start action. + * + * The return value indicates whether any error occurred, while the number + * of elements is stored into *elements (but only if the return value is + * JSON_SUCCESS). + */ +extern JsonParseErrorType json_count_array_elements(JsonLexContext *lex, + int *elements); + +/* + * constructor for JsonLexContext, with or without strval element. + * If supplied, the strval element will contain a de-escaped version of + * the lexeme. However, doing this imposes a performance penalty, so + * it should be avoided if the de-escaped lexeme is not required. + */ +extern JsonLexContext *makeJsonLexContextCstringLen(char *json, + int len, + int encoding, + bool need_escapes); + +/* lex one token */ +extern JsonParseErrorType json_lex(JsonLexContext *lex); + +/* construct an error detail string for a json error */ +extern char *json_errdetail(JsonParseErrorType error, JsonLexContext *lex); + +/* + * Utility function to check if a string is a valid JSON number. + * + * str argument does not need to be nul-terminated. + */ +extern bool IsValidJsonNumber(const char *str, int len); + +#endif /* JSONAPI_H */ diff --git a/src/include/utils/jsonapi.h b/src/include/utils/jsonapi.h deleted file mode 100644 index 4d69b184951..00000000000 --- a/src/include/utils/jsonapi.h +++ /dev/null @@ -1,167 +0,0 @@ -/*------------------------------------------------------------------------- - * - * jsonapi.h - * Declarations for JSON API support. - * - * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group - * Portions Copyright (c) 1994, Regents of the University of California - * - * src/include/utils/jsonapi.h - * - *------------------------------------------------------------------------- - */ - -#ifndef JSONAPI_H -#define JSONAPI_H - -#include "lib/stringinfo.h" - -typedef enum -{ - JSON_TOKEN_INVALID, - JSON_TOKEN_STRING, - JSON_TOKEN_NUMBER, - JSON_TOKEN_OBJECT_START, - JSON_TOKEN_OBJECT_END, - JSON_TOKEN_ARRAY_START, - JSON_TOKEN_ARRAY_END, - JSON_TOKEN_COMMA, - JSON_TOKEN_COLON, - JSON_TOKEN_TRUE, - JSON_TOKEN_FALSE, - JSON_TOKEN_NULL, - JSON_TOKEN_END -} JsonTokenType; - -typedef enum -{ - JSON_SUCCESS, - JSON_ESCAPING_INVALID, - JSON_ESCAPING_REQUIRED, - JSON_EXPECTED_ARRAY_FIRST, - JSON_EXPECTED_ARRAY_NEXT, - JSON_EXPECTED_COLON, - JSON_EXPECTED_END, - JSON_EXPECTED_JSON, - JSON_EXPECTED_MORE, - JSON_EXPECTED_OBJECT_FIRST, - JSON_EXPECTED_OBJECT_NEXT, - JSON_EXPECTED_STRING, - JSON_INVALID_TOKEN, - JSON_UNICODE_CODE_POINT_ZERO, - JSON_UNICODE_ESCAPE_FORMAT, - JSON_UNICODE_HIGH_ESCAPE, - JSON_UNICODE_HIGH_SURROGATE, - JSON_UNICODE_LOW_SURROGATE -} JsonParseErrorType; - - -/* - * All the fields in this structure should be treated as read-only. - * - * If strval is not null, then it should contain the de-escaped value - * of the lexeme if it's a string. Otherwise most of these field names - * should be self-explanatory. - * - * line_number and line_start are principally for use by the parser's - * error reporting routines. - * token_terminator and prev_token_terminator point to the character - * AFTER the end of the token, i.e. where there would be a nul byte - * if we were using nul-terminated strings. - */ -typedef struct JsonLexContext -{ - char *input; - int input_length; - char *token_start; - char *token_terminator; - char *prev_token_terminator; - JsonTokenType token_type; - int lex_level; - int line_number; - char *line_start; - StringInfo strval; -} JsonLexContext; - -typedef void (*json_struct_action) (void *state); -typedef void (*json_ofield_action) (void *state, char *fname, bool isnull); -typedef void (*json_aelem_action) (void *state, bool isnull); -typedef void (*json_scalar_action) (void *state, char *token, JsonTokenType tokentype); - - -/* - * Semantic Action structure for use in parsing json. - * Any of these actions can be NULL, in which case nothing is done at that - * point, Likewise, semstate can be NULL. Using an all-NULL structure amounts - * to doing a pure parse with no side-effects, and is therefore exactly - * what the json input routines do. - * - * The 'fname' and 'token' strings passed to these actions are palloc'd. - * They are not free'd or used further by the parser, so the action function - * is free to do what it wishes with them. - */ -typedef struct JsonSemAction -{ - void *semstate; - json_struct_action object_start; - json_struct_action object_end; - json_struct_action array_start; - json_struct_action array_end; - json_ofield_action object_field_start; - json_ofield_action object_field_end; - json_aelem_action array_element_start; - json_aelem_action array_element_end; - json_scalar_action scalar; -} JsonSemAction; - -/* - * pg_parse_json will parse the string in the lex calling the - * action functions in sem at the appropriate points. It is - * up to them to keep what state they need in semstate. If they - * need access to the state of the lexer, then its pointer - * should be passed to them as a member of whatever semstate - * points to. If the action pointers are NULL the parser - * does nothing and just continues. - */ -extern JsonParseErrorType pg_parse_json(JsonLexContext *lex, - JsonSemAction *sem); - -/* the null action object used for pure validation */ -extern JsonSemAction nullSemAction; - -/* - * json_count_array_elements performs a fast secondary parse to determine the - * number of elements in passed array lex context. It should be called from an - * array_start action. - * - * The return value indicates whether any error occurred, while the number - * of elements is stored into *elements (but only if the return value is - * JSON_SUCCESS). - */ -extern JsonParseErrorType json_count_array_elements(JsonLexContext *lex, - int *elements); - -/* - * constructor for JsonLexContext, with or without strval element. - * If supplied, the strval element will contain a de-escaped version of - * the lexeme. However, doing this imposes a performance penalty, so - * it should be avoided if the de-escaped lexeme is not required. - */ -extern JsonLexContext *makeJsonLexContextCstringLen(char *json, - int len, - bool need_escapes); - -/* lex one token */ -extern JsonParseErrorType json_lex(JsonLexContext *lex); - -/* construct an error detail string for a json error */ -extern char *json_errdetail(JsonParseErrorType error, JsonLexContext *lex); - -/* - * Utility function to check if a string is a valid JSON number. - * - * str argument does not need to be nul-terminated. - */ -extern bool IsValidJsonNumber(const char *str, int len); - -#endif /* JSONAPI_H */ diff --git a/src/include/utils/jsonfuncs.h b/src/include/utils/jsonfuncs.h index b993f38409f..1f1b4029cbf 100644 --- a/src/include/utils/jsonfuncs.h +++ b/src/include/utils/jsonfuncs.h @@ -14,7 +14,7 @@ #ifndef JSONFUNCS_H #define JSONFUNCS_H -#include "utils/jsonapi.h" +#include "common/jsonapi.h" #include "utils/jsonb.h" /* -- cgit v1.2.3