jsonapi.h File Reference

#include "lib/stringinfo.h"

Include dependency graph for jsonapi.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures
struct	JsonLexContext
struct	JsonSemAction

Typedefs
typedef enum JsonTokenType	JsonTokenType
typedef enum JsonParseErrorType	JsonParseErrorType
typedef struct JsonLexContext	JsonLexContext
typedef JsonParseErrorType(*	json_struct_action) (void *state)
typedef JsonParseErrorType(*	json_ofield_action) (void *state, char *fname, bool isnull)
typedef JsonParseErrorType(*	json_aelem_action) (void *state, bool isnull)
typedef JsonParseErrorType(*	json_scalar_action) (void *state, char *token, JsonTokenType tokentype)
typedef struct JsonSemAction	JsonSemAction

Enumerations
enum	JsonTokenType {   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 }
enum	JsonParseErrorType {   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_UNTRANSLATABLE , JSON_UNICODE_HIGH_SURROGATE , JSON_UNICODE_LOW_SURROGATE , JSON_SEM_ACTION_FAILED }

Functions
JsonParseErrorType	pg_parse_json (JsonLexContext *lex, JsonSemAction *sem)
JsonParseErrorType	json_count_array_elements (JsonLexContext *lex, int *elements)
JsonLexContext *	makeJsonLexContextCstringLen (char *json, int len, int encoding, bool need_escapes)
JsonParseErrorType	json_lex (JsonLexContext *lex)
char *	json_errdetail (JsonParseErrorType error, JsonLexContext *lex)
bool	IsValidJsonNumber (const char *str, int len)

Variables
PGDLLIMPORT JsonSemAction	nullSemAction

Typedef Documentation

json_aelem_action

typedef JsonParseErrorType(* json_aelem_action) (void *state, bool isnull)

Definition at line 91 of file jsonapi.h.

json_ofield_action

typedef JsonParseErrorType(* json_ofield_action) (void *state, char *fname, bool isnull)

Definition at line 90 of file jsonapi.h.

json_scalar_action

typedef JsonParseErrorType(* json_scalar_action) (void *state, char *token, JsonTokenType tokentype)

Definition at line 92 of file jsonapi.h.

json_struct_action

typedef JsonParseErrorType(* json_struct_action) (void *state)

Definition at line 89 of file jsonapi.h.

JsonLexContext

typedef struct JsonLexContext JsonLexContext

JsonParseErrorType

typedef enum JsonParseErrorType JsonParseErrorType

JsonSemAction

typedef struct JsonSemAction JsonSemAction

JsonTokenType

typedef enum JsonTokenType JsonTokenType

Enumeration Type Documentation

JsonParseErrorType

enum JsonParseErrorType

Enumerator
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_UNTRANSLATABLE
JSON_UNICODE_HIGH_SURROGATE
JSON_UNICODE_LOW_SURROGATE
JSON_SEM_ACTION_FAILED

Definition at line 36 of file jsonapi.h.

{
    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_UNTRANSLATABLE,
    JSON_UNICODE_HIGH_SURROGATE,
    JSON_UNICODE_LOW_SURROGATE,
    JSON_SEM_ACTION_FAILED      /* error should already be reported */
} JsonParseErrorType;

JsonTokenType

enum JsonTokenType

Enumerator
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

Definition at line 19 of file jsonapi.h.

{
    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;

Function Documentation

IsValidJsonNumber()

bool IsValidJsonNumber	(	const char *	str,
		int	len
	)

Definition at line 105 of file jsonapi.c.

{
    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);
}

References JsonLexContext::input, JsonLexContext::input_length, json_lex_number(), len, generate_unaccent_rules::str, and unconstify.

Referenced by datum_to_json(), hstore_to_json_loose(), and hstore_to_jsonb_loose().

json_count_array_elements()

JsonParseErrorType json_count_array_elements	(	JsonLexContext *	lex,
		int *	elements
	)

Definition at line 209 of file jsonapi.c.

{
    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(&copylex, lex, sizeof(JsonLexContext));
    copylex.strval = NULL;      /* not interested in values here */
    copylex.lex_level++;
 
    count = 0;
    result = lex_expect(JSON_PARSE_ARRAY_START, &copylex,
                        JSON_TOKEN_ARRAY_START);
    if (result != JSON_SUCCESS)
        return result;
    if (lex_peek(&copylex) != JSON_TOKEN_ARRAY_END)
    {
        while (1)
        {
            count++;
            result = parse_array_element(&copylex, &nullSemAction);
            if (result != JSON_SUCCESS)
                return result;
            if (copylex.token_type != JSON_TOKEN_COMMA)
                break;
            result = json_lex(&copylex);
            if (result != JSON_SUCCESS)
                return result;
        }
    }
    result = lex_expect(JSON_PARSE_ARRAY_NEXT, &copylex,
                        JSON_TOKEN_ARRAY_END);
    if (result != JSON_SUCCESS)
        return result;
 
    *elements = count;
    return JSON_SUCCESS;
}

References json_lex(), JSON_PARSE_ARRAY_NEXT, JSON_PARSE_ARRAY_START, JSON_SUCCESS, JSON_TOKEN_ARRAY_END, JSON_TOKEN_ARRAY_START, JSON_TOKEN_COMMA, lex_expect(), JsonLexContext::lex_level, lex_peek(), nullSemAction, parse_array_element(), JsonLexContext::strval, and JsonLexContext::token_type.

Referenced by get_array_start().

json_errdetail()

char* json_errdetail	(	JsonParseErrorType	error,
		JsonLexContext *	lex
	)

Definition at line 1136 of file jsonapi.c.

{
    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:
            /* note: this case is only reachable in frontend not backend */
            return _("Unicode escape values cannot be used for code point values above 007F when the encoding is not UTF8.");
        case JSON_UNICODE_UNTRANSLATABLE:
            /* note: this case is only reachable in backend not frontend */
            return psprintf(_("Unicode escape value could not be translated to the server's encoding %s."),
                            GetDatabaseEncodingName());
        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.");
        case JSON_SEM_ACTION_FAILED:
            /* fall through to the error code after switch */
            break;
    }
 
    /*
     * 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;
}

References _, elog(), ERROR, error(), extract_token(), GetDatabaseEncodingName(), 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_SEM_ACTION_FAILED, JSON_SUCCESS, JSON_UNICODE_CODE_POINT_ZERO, JSON_UNICODE_ESCAPE_FORMAT, JSON_UNICODE_HIGH_ESCAPE, JSON_UNICODE_HIGH_SURROGATE, JSON_UNICODE_LOW_SURROGATE, JSON_UNICODE_UNTRANSLATABLE, psprintf(), and JsonLexContext::token_terminator.

Referenced by json_errsave_error().

json_lex()

JsonParseErrorType json_lex

(

JsonLexContext *

lex

)

Definition at line 552 of file jsonapi.c.

{
    char       *s;
    char       *const end = lex->input + lex->input_length;
    JsonParseErrorType result;
 
    /* Skip leading whitespace. */
    s = lex->token_terminator;
    while (s < end && (*s == ' ' || *s == '\t' || *s == '\n' || *s == '\r'))
    {
        if (*s++ == '\n')
        {
            ++lex->line_number;
            lex->line_start = s;
        }
    }
    lex->token_start = s;
 
    /* Determine token type. */
    if (s >= end)
    {
        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 < end && 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;
}

References if(), JsonLexContext::input, JsonLexContext::input_length, JSON_ALPHANUMERIC_CHAR, JSON_INVALID_TOKEN, json_lex_number(), json_lex_string(), JSON_SUCCESS, JSON_TOKEN_ARRAY_END, JSON_TOKEN_ARRAY_START, JSON_TOKEN_COLON, JSON_TOKEN_COMMA, JSON_TOKEN_END, JSON_TOKEN_FALSE, JSON_TOKEN_NULL, JSON_TOKEN_NUMBER, JSON_TOKEN_OBJECT_END, JSON_TOKEN_OBJECT_START, JSON_TOKEN_STRING, JSON_TOKEN_TRUE, JsonLexContext::line_number, JsonLexContext::line_start, JsonLexContext::prev_token_terminator, JsonLexContext::token_start, JsonLexContext::token_terminator, and JsonLexContext::token_type.

Referenced by json_count_array_elements(), json_typeof(), lex_expect(), parse_array(), parse_object(), parse_object_field(), parse_scalar(), and pg_parse_json().

makeJsonLexContextCstringLen()

JsonLexContext* makeJsonLexContextCstringLen	(	char *	json,
		int	len,
		int	encoding,
		bool	need_escapes
	)

Definition at line 145 of file jsonapi.c.

{
    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;
}

References encoding, JsonLexContext::input, JsonLexContext::input_encoding, JsonLexContext::input_length, len, JsonLexContext::line_number, JsonLexContext::line_start, makeStringInfo(), palloc0(), JsonLexContext::strval, and JsonLexContext::token_terminator.

Referenced by get_json_object_as_hash(), json_parse_manifest(), json_recv(), jsonb_from_cstring(), makeJsonLexContext(), and populate_array_json().

pg_parse_json()

JsonParseErrorType pg_parse_json	(	JsonLexContext *	lex,
		JsonSemAction *	sem
	)

Definition at line 169 of file jsonapi.c.

{
    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;
}

References json_lex(), JSON_PARSE_END, JSON_SUCCESS, JSON_TOKEN_ARRAY_START, JSON_TOKEN_END, JSON_TOKEN_OBJECT_START, lex_expect(), lex_peek(), parse_array(), parse_object(), and parse_scalar().

Referenced by json_parse_manifest(), and pg_parse_json_or_errsave().

Variable Documentation

nullSemAction

PGDLLIMPORT JsonSemAction nullSemAction

extern

Definition at line 57 of file jsonapi.c.

Referenced by json_count_array_elements(), json_in(), and json_recv().