jsonapi.h File Reference

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

Macros
#define	jsonapi_StrValType   StringInfoData
#define	JSONLEX_FREE_STRUCT   (1 << 0)
#define	JSONLEX_FREE_STRVAL   (1 << 1)
#define	JSONLEX_CTX_OWNS_TOKENS   (1 << 2)

Typedefs
typedef enum JsonTokenType	JsonTokenType
typedef enum JsonParseErrorType	JsonParseErrorType
typedef struct JsonParserStack	JsonParserStack
typedef struct JsonIncrementalState	JsonIncrementalState
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_INCOMPLETE , JSON_INVALID_LEXER_TYPE , JSON_NESTING_TOO_DEEP ,   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_OUT_OF_MEMORY , 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, const JsonSemAction *sem)
JsonParseErrorType	pg_parse_json_incremental (JsonLexContext *lex, const JsonSemAction *sem, const char *json, size_t len, bool is_last)
JsonParseErrorType	json_count_array_elements (JsonLexContext *lex, int *elements)
JsonLexContext *	makeJsonLexContextCstringLen (JsonLexContext *lex, const char *json, size_t len, int encoding, bool need_escapes)
JsonLexContext *	makeJsonLexContextIncremental (JsonLexContext *lex, int encoding, bool need_escapes)
void	setJsonLexContextOwnsTokens (JsonLexContext *lex, bool owned_by_context)
void	freeJsonLexContext (JsonLexContext *lex)
JsonParseErrorType	json_lex (JsonLexContext *lex)
char *	json_errdetail (JsonParseErrorType error, JsonLexContext *lex)
bool	IsValidJsonNumber (const char *str, size_t len)

Variables
PGDLLIMPORT const JsonSemAction	nullSemAction

Macro Definition Documentation

jsonapi_StrValType

#define jsonapi_StrValType   StringInfoData

Definition at line 73 of file jsonapi.h.

JSONLEX_CTX_OWNS_TOKENS

#define JSONLEX_CTX_OWNS_TOKENS   (1 << 2)

Definition at line 99 of file jsonapi.h.

JSONLEX_FREE_STRUCT

#define JSONLEX_FREE_STRUCT   (1 << 0)

Definition at line 97 of file jsonapi.h.

JSONLEX_FREE_STRVAL

#define JSONLEX_FREE_STRVAL   (1 << 1)

Definition at line 98 of file jsonapi.h.

Typedef Documentation

json_aelem_action

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

Definition at line 129 of file jsonapi.h.

json_ofield_action

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

Definition at line 128 of file jsonapi.h.

json_scalar_action

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

Definition at line 130 of file jsonapi.h.

json_struct_action

typedef JsonParseErrorType(* json_struct_action) (void *state)

Definition at line 127 of file jsonapi.h.

JsonIncrementalState

typedef struct JsonIncrementalState JsonIncrementalState

Definition at line 64 of file jsonapi.h.

JsonLexContext

typedef struct JsonLexContext JsonLexContext

JsonParseErrorType

typedef enum JsonParseErrorType JsonParseErrorType

JsonParserStack

typedef struct JsonParserStack JsonParserStack

Definition at line 63 of file jsonapi.h.

JsonSemAction

typedef struct JsonSemAction JsonSemAction

JsonTokenType

typedef enum JsonTokenType JsonTokenType

Enumeration Type Documentation

JsonParseErrorType

enum JsonParseErrorType

Enumerator
JSON_SUCCESS
JSON_INCOMPLETE
JSON_INVALID_LEXER_TYPE
JSON_NESTING_TOO_DEEP
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_OUT_OF_MEMORY
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 34 of file jsonapi.h.

{
    JSON_SUCCESS,
    JSON_INCOMPLETE,
    JSON_INVALID_LEXER_TYPE,
    JSON_NESTING_TOO_DEEP,
    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_OUT_OF_MEMORY,
    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 17 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

freeJsonLexContext()

void freeJsonLexContext

(

JsonLexContext *

lex

)

Definition at line 687 of file jsonapi.c.

{
    static const JsonLexContext empty = {0};
 
    if (!lex || lex == &failed_oom)
        return;
 
    if (lex->flags & JSONLEX_FREE_STRVAL)
        jsonapi_destroyStringInfo(lex->strval);
 
    if (lex->errormsg)
        jsonapi_destroyStringInfo(lex->errormsg);
 
    if (lex->incremental)
    {
        jsonapi_termStringInfo(&lex->inc_state->partial_token);
        FREE(lex->inc_state);
        FREE(lex->pstack->prediction);
 
        if (lex->flags & JSONLEX_CTX_OWNS_TOKENS)
        {
            int         i;
 
            /* Clean up any tokens that were left behind. */
            for (i = 0; i <= lex->lex_level; i++)
                FREE(lex->pstack->fnames[i]);
        }
 
        FREE(lex->pstack->fnames);
        FREE(lex->pstack->fnull);
        FREE(lex->pstack->scalar_val);
        FREE(lex->pstack);
    }
 
    if (lex->flags & JSONLEX_FREE_STRUCT)
        FREE(lex);
    else
        *lex = empty;

References JsonLexContext::errormsg, failed_oom, JsonLexContext::flags, JsonParserStack::fnames, JsonParserStack::fnull, FREE, i, JsonLexContext::inc_state, JsonLexContext::incremental, jsonapi_destroyStringInfo, jsonapi_termStringInfo, JSONLEX_CTX_OWNS_TOKENS, JSONLEX_FREE_STRUCT, JSONLEX_FREE_STRVAL, JsonLexContext::lex_level, JsonIncrementalState::partial_token, JsonParserStack::prediction, JsonLexContext::pstack, JsonParserStack::scalar_val, and JsonLexContext::strval.

Referenced by datum_to_jsonb_internal(), each_worker(), elements_worker(), get_json_object_as_hash(), get_worker(), handle_oauth_sasl_error(), iterate_json_values(), json_object_keys(), json_parse_manifest(), json_parse_manifest_incremental_shutdown(), json_validate(), main(), parse_oauth_json(), populate_array_json(), populate_recordset_worker(), test_gb18030_json(), and transform_json_string_values().

IsValidJsonNumber()

bool IsValidJsonNumber	(	const char *	str,
		size_t	len
	)

Definition at line 339 of file jsonapi.c.

{
    bool        numeric_error;
    size_t      total_len;
    JsonLexContext dummy_lex = {0};
 
    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 = str + 1;
        dummy_lex.input_length = len - 1;
    }
    else
    {
        dummy_lex.input = str;
        dummy_lex.input_length = len;
    }
 
    dummy_lex.token_start = dummy_lex.input;
 
    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, str, and JsonLexContext::token_start.

Referenced by 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 803 of file jsonapi.c.

{
    JsonLexContext copylex;
    int         count;
    JsonParseErrorType result;
 
    if (lex == &failed_oom)
        return JSON_OUT_OF_MEMORY;
 
    /*
     * 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.need_escapes = false;   /* 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 failed_oom, json_lex(), JSON_OUT_OF_MEMORY, 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(), JsonLexContext::need_escapes, nullSemAction, parse_array_element(), and JsonLexContext::token_type.

Referenced by get_array_start().

json_errdetail()

char * json_errdetail	(	JsonParseErrorType	error,
		JsonLexContext *	lex
	)

Definition at line 2404 of file jsonapi.c.

{
    if (error == JSON_OUT_OF_MEMORY || lex == &failed_oom)
    {
        /* Short circuit. Allocating anything for this case is unhelpful. */
        return _("out of memory");
    }
 
    if (lex->errormsg)
        jsonapi_resetStringInfo(lex->errormsg);
    else
        lex->errormsg = jsonapi_makeStringInfo();
 
    /*
     * A helper for error messages that should print the current token. The
     * format must contain exactly one %.*s specifier.
     */
#define json_token_error(lex, format) \
    jsonapi_appendStringInfo((lex)->errormsg, _(format), \
                             (int) ((lex)->token_terminator - (lex)->token_start), \
                             (lex)->token_start);
 
    switch (error)
    {
        case JSON_INCOMPLETE:
        case JSON_SUCCESS:
            /* fall through to the error code after switch */
            break;
        case JSON_INVALID_LEXER_TYPE:
            if (lex->incremental)
                return _("Recursive descent parser cannot use incremental lexer.");
            else
                return _("Incremental parser requires incremental lexer.");
        case JSON_NESTING_TOO_DEEP:
            return (_("JSON nested too deep, maximum permitted depth is 6400."));
        case JSON_ESCAPING_INVALID:
            json_token_error(lex, "Escape sequence \"\\%.*s\" is invalid.");
            break;
        case JSON_ESCAPING_REQUIRED:
            jsonapi_appendStringInfo(lex->errormsg,
                                     _("Character with value 0x%02x must be escaped."),
                                     (unsigned char) *(lex->token_terminator));
            break;
        case JSON_EXPECTED_END:
            json_token_error(lex, "Expected end of input, but found \"%.*s\".");
            break;
        case JSON_EXPECTED_ARRAY_FIRST:
            json_token_error(lex, "Expected array element or \"]\", but found \"%.*s\".");
            break;
        case JSON_EXPECTED_ARRAY_NEXT:
            json_token_error(lex, "Expected \",\" or \"]\", but found \"%.*s\".");
            break;
        case JSON_EXPECTED_COLON:
            json_token_error(lex, "Expected \":\", but found \"%.*s\".");
            break;
        case JSON_EXPECTED_JSON:
            json_token_error(lex, "Expected JSON value, but found \"%.*s\".");
            break;
        case JSON_EXPECTED_MORE:
            return _("The input string ended unexpectedly.");
        case JSON_EXPECTED_OBJECT_FIRST:
            json_token_error(lex, "Expected string or \"}\", but found \"%.*s\".");
            break;
        case JSON_EXPECTED_OBJECT_NEXT:
            json_token_error(lex, "Expected \",\" or \"}\", but found \"%.*s\".");
            break;
        case JSON_EXPECTED_STRING:
            json_token_error(lex, "Expected string, but found \"%.*s\".");
            break;
        case JSON_INVALID_TOKEN:
            json_token_error(lex, "Token \"%.*s\" is invalid.");
            break;
        case JSON_OUT_OF_MEMORY:
            /* should have been handled above; use the error path */
            break;
        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 and not frontend.
             * #ifdef it away so the frontend doesn't try to link against
             * backend functionality.
             */
#ifndef FRONTEND
            return psprintf(_("Unicode escape value could not be translated to the server's encoding %s."),
                            GetDatabaseEncodingName());
#else
            Assert(false);
            break;
#endif
        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;
    }
#undef json_token_error
 
    /* Note that lex->errormsg can be NULL in shlib code. */
    if (lex->errormsg && lex->errormsg->len == 0)
    {
        /*
         * 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.
         */
        jsonapi_appendStringInfo(lex->errormsg,
                                 "unexpected json parse error type: %d",
                                 (int) error);
    }
 
#ifdef JSONAPI_USE_PQEXPBUFFER
    if (PQExpBufferBroken(lex->errormsg))
        return _("out of memory while constructing error description");
#endif
 
    return lex->errormsg->data;

References _, Assert(), error(), JsonLexContext::errormsg, failed_oom, GetDatabaseEncodingName(), JsonLexContext::incremental, 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_INCOMPLETE, JSON_INVALID_LEXER_TYPE, JSON_INVALID_TOKEN, JSON_NESTING_TOO_DEEP, JSON_OUT_OF_MEMORY, JSON_SEM_ACTION_FAILED, JSON_SUCCESS, json_token_error, JSON_UNICODE_CODE_POINT_ZERO, JSON_UNICODE_ESCAPE_FORMAT, JSON_UNICODE_HIGH_ESCAPE, JSON_UNICODE_HIGH_SURROGATE, JSON_UNICODE_LOW_SURROGATE, JSON_UNICODE_UNTRANSLATABLE, jsonapi_appendStringInfo, jsonapi_makeStringInfo, jsonapi_resetStringInfo, PQExpBufferBroken, psprintf(), and JsonLexContext::token_terminator.

Referenced by handle_oauth_sasl_error(), json_errsave_error(), json_parse_manifest(), json_parse_manifest_incremental_chunk(), main(), parse_oauth_json(), and test_gb18030_json().

json_lex()

JsonParseErrorType json_lex

(

JsonLexContext *

lex

)

Definition at line 1588 of file jsonapi.c.

{
    const char *s;
    const char *const end = lex->input + lex->input_length;
    JsonParseErrorType result;
 
    if (lex == &failed_oom || lex->inc_state == &failed_inc_oom)
        return JSON_OUT_OF_MEMORY;
 
    if (lex->incremental)
    {
        if (lex->inc_state->partial_completed)
        {
            /*
             * We just lexed a completed partial token on the last call, so
             * reset everything
             */
            jsonapi_resetStringInfo(&(lex->inc_state->partial_token));
            lex->token_terminator = lex->input;
            lex->inc_state->partial_completed = false;
        }
 
#ifdef JSONAPI_USE_PQEXPBUFFER
        /* Make sure our partial token buffer is valid before using it below. */
        if (PQExpBufferDataBroken(lex->inc_state->partial_token))
            return JSON_OUT_OF_MEMORY;
#endif
    }
 
    s = lex->token_terminator;
 
    if (lex->incremental && lex->inc_state->partial_token.len)
    {
        /*
         * We have a partial token. Extend it and if completed lex it by a
         * recursive call
         */
        jsonapi_StrValType *ptok = &(lex->inc_state->partial_token);
        size_t      added = 0;
        bool        tok_done = false;
        JsonLexContext dummy_lex = {0};
        JsonParseErrorType partial_result;
 
        if (ptok->data[0] == '"')
        {
            /*
             * It's a string. Accumulate characters until we reach an
             * unescaped '"'.
             */
            int         escapes = 0;
 
            for (int i = ptok->len - 1; i > 0; i--)
            {
                /* count the trailing backslashes on the partial token */
                if (ptok->data[i] == '\\')
                    escapes++;
                else
                    break;
            }
 
            for (size_t i = 0; i < lex->input_length; i++)
            {
                char        c = lex->input[i];
 
                jsonapi_appendStringInfoCharMacro(ptok, c);
                added++;
                if (c == '"' && escapes % 2 == 0)
                {
                    tok_done = true;
                    break;
                }
                if (c == '\\')
                    escapes++;
                else
                    escapes = 0;
            }
        }
        else
        {
            /* not a string */
            char        c = ptok->data[0];
 
            if (c == '-' || (c >= '0' && c <= '9'))
            {
                /* for numbers look for possible numeric continuations */
 
                bool        numend = false;
 
                for (size_t i = 0; i < lex->input_length && !numend; i++)
                {
                    char        cc = lex->input[i];
 
                    switch (cc)
                    {
                        case '+':
                        case '-':
                        case 'e':
                        case 'E':
                        case '0':
                        case '1':
                        case '2':
                        case '3':
                        case '4':
                        case '5':
                        case '6':
                        case '7':
                        case '8':
                        case '9':
                            {
                                jsonapi_appendStringInfoCharMacro(ptok, cc);
                                added++;
                            }
                            break;
                        default:
                            numend = true;
                    }
                }
            }
 
            /*
             * Add any remaining alphanumeric chars. This takes care of the
             * {null, false, true} literals as well as any trailing
             * alphanumeric junk on non-string tokens.
             */
            for (size_t i = added; i < lex->input_length; i++)
            {
                char        cc = lex->input[i];
 
                if (JSON_ALPHANUMERIC_CHAR(cc))
                {
                    jsonapi_appendStringInfoCharMacro(ptok, cc);
                    added++;
                }
                else
                {
                    tok_done = true;
                    break;
                }
            }
            if (added == lex->input_length &&
                lex->inc_state->is_last_chunk)
            {
                tok_done = true;
            }
        }
 
        if (!tok_done)
        {
            /* We should have consumed the whole chunk in this case. */
            Assert(added == lex->input_length);
 
            if (!lex->inc_state->is_last_chunk)
                return JSON_INCOMPLETE;
 
            /* json_errdetail() needs access to the accumulated token. */
            lex->token_start = ptok->data;
            lex->token_terminator = ptok->data + ptok->len;
            return JSON_INVALID_TOKEN;
        }
 
        /*
         * Everything up to lex->input[added] has been added to the partial
         * token, so move the input past it.
         */
        lex->input += added;
        lex->input_length -= added;
 
        dummy_lex.input = dummy_lex.token_terminator =
            dummy_lex.line_start = ptok->data;
        dummy_lex.line_number = lex->line_number;
        dummy_lex.input_length = ptok->len;
        dummy_lex.input_encoding = lex->input_encoding;
        dummy_lex.incremental = false;
        dummy_lex.need_escapes = lex->need_escapes;
        dummy_lex.strval = lex->strval;
 
        partial_result = json_lex(&dummy_lex);
 
        /*
         * We either have a complete token or an error. In either case we need
         * to point to the partial token data for the semantic or error
         * routines. If it's not an error we'll readjust on the next call to
         * json_lex.
         */
        lex->token_type = dummy_lex.token_type;
        lex->line_number = dummy_lex.line_number;
 
        /*
         * We know the prev_token_terminator must be back in some previous
         * piece of input, so we just make it NULL.
         */
        lex->prev_token_terminator = NULL;
 
        /*
         * Normally token_start would be ptok->data, but it could be later,
         * see json_lex_string's handling of invalid escapes.
         */
        lex->token_start = dummy_lex.token_start;
        lex->token_terminator = dummy_lex.token_terminator;
        if (partial_result == JSON_SUCCESS)
        {
            /* make sure we've used all the input */
            if (lex->token_terminator - lex->token_start != ptok->len)
            {
                Assert(false);
                return JSON_INVALID_TOKEN;
            }
 
            lex->inc_state->partial_completed = true;
        }
        return partial_result;
        /* end of partial token processing */
    }
 
    /* Skip leading whitespace. */
    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:
                {
                    const 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;
                    }
 
                    if (lex->incremental && !lex->inc_state->is_last_chunk &&
                        p == lex->input + lex->input_length)
                    {
                        jsonapi_appendBinaryStringInfo(&(lex->inc_state->partial_token), s, end - s);
                        return JSON_INCOMPLETE;
                    }
 
                    /*
                     * 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 */
    }
 
    if (lex->incremental && lex->token_type == JSON_TOKEN_END && !lex->inc_state->is_last_chunk)
        return JSON_INCOMPLETE;
    else
        return JSON_SUCCESS;

References Assert(), failed_inc_oom, failed_oom, i, JsonLexContext::inc_state, JsonLexContext::incremental, JsonLexContext::input, JsonLexContext::input_encoding, JsonLexContext::input_length, JsonIncrementalState::is_last_chunk, JSON_ALPHANUMERIC_CHAR, JSON_INCOMPLETE, JSON_INVALID_TOKEN, json_lex(), json_lex_number(), json_lex_string(), JSON_OUT_OF_MEMORY, 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, jsonapi_appendBinaryStringInfo, jsonapi_appendStringInfoCharMacro, jsonapi_resetStringInfo, jsonapi_StrValType, JsonLexContext::line_number, JsonLexContext::line_start, JsonLexContext::need_escapes, JsonIncrementalState::partial_completed, JsonIncrementalState::partial_token, PQExpBufferDataBroken, JsonLexContext::prev_token_terminator, JsonLexContext::strval, JsonLexContext::token_start, JsonLexContext::token_terminator, and JsonLexContext::token_type.

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

makeJsonLexContextCstringLen()

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

Definition at line 392 of file jsonapi.c.

{
    if (lex == NULL)
    {
        lex = ALLOC0(sizeof(JsonLexContext));
        if (!lex)
            return &failed_oom;
        lex->flags |= JSONLEX_FREE_STRUCT;
    }
    else
        memset(lex, 0, sizeof(JsonLexContext));
 
    lex->errormsg = NULL;
    lex->input = lex->token_terminator = lex->line_start = json;
    lex->line_number = 1;
    lex->input_length = len;
    lex->input_encoding = encoding;
    lex->need_escapes = need_escapes;
    if (need_escapes)
    {
        /*
         * This call can fail in shlib code. We defer error handling to time
         * of use (json_lex_string()) since we might not need to parse any
         * strings anyway.
         */
        lex->strval = jsonapi_makeStringInfo();
        lex->flags |= JSONLEX_FREE_STRVAL;
    }
 
    return lex;
}

References ALLOC0, encoding, JsonLexContext::errormsg, failed_oom, JsonLexContext::flags, JsonLexContext::input, JsonLexContext::input_encoding, JsonLexContext::input_length, jsonapi_makeStringInfo, JSONLEX_FREE_STRUCT, JSONLEX_FREE_STRVAL, len, JsonLexContext::line_number, JsonLexContext::line_start, JsonLexContext::need_escapes, JsonLexContext::strval, and JsonLexContext::token_terminator.

Referenced by get_json_object_as_hash(), handle_oauth_sasl_error(), json_parse_manifest(), json_recv(), jsonb_from_cstring(), main(), makeJsonLexContext(), parse_oauth_json(), populate_array_json(), and test_gb18030_json().

makeJsonLexContextIncremental()

JsonLexContext * makeJsonLexContextIncremental	(	JsonLexContext *	lex,
		int	encoding,
		bool	need_escapes
	)

Definition at line 497 of file jsonapi.c.

{
    if (lex == NULL)
    {
        lex = ALLOC0(sizeof(JsonLexContext));
        if (!lex)
            return &failed_oom;
 
        lex->flags |= JSONLEX_FREE_STRUCT;
    }
    else
        memset(lex, 0, sizeof(JsonLexContext));
 
    lex->line_number = 1;
    lex->input_encoding = encoding;
 
    if (!allocate_incremental_state(lex))
    {
        if (lex->flags & JSONLEX_FREE_STRUCT)
        {
            FREE(lex);
            return &failed_oom;
        }
 
        /* lex->inc_state tracks the OOM failure; we can return here. */
        return lex;
    }
 
    lex->need_escapes = need_escapes;
    if (need_escapes)
    {
        /*
         * This call can fail in shlib code. We defer error handling to time
         * of use (json_lex_string()) since we might not need to parse any
         * strings anyway.
         */
        lex->strval = jsonapi_makeStringInfo();
        lex->flags |= JSONLEX_FREE_STRVAL;
    }
 
    return lex;

References ALLOC0, allocate_incremental_state(), encoding, failed_oom, JsonLexContext::flags, FREE, JsonLexContext::input_encoding, jsonapi_makeStringInfo, JSONLEX_FREE_STRUCT, JSONLEX_FREE_STRVAL, JsonLexContext::line_number, JsonLexContext::need_escapes, and JsonLexContext::strval.

Referenced by json_parse_manifest_incremental_init(), and main().

pg_parse_json()

JsonParseErrorType pg_parse_json	(	JsonLexContext *	lex,
		const JsonSemAction *	sem
	)

Definition at line 744 of file jsonapi.c.

{
#ifdef FORCE_JSON_PSTACK
    /*
     * We don't need partial token processing, there is only one chunk. But we
     * still need to init the partial token string so that freeJsonLexContext
     * works, so perform the full incremental initialization.
     */
    if (!allocate_incremental_state(lex))
        return JSON_OUT_OF_MEMORY;
 
    return pg_parse_json_incremental(lex, sem, lex->input, lex->input_length, true);
 
#else
 
    JsonTokenType tok;
    JsonParseErrorType result;
 
    if (lex == &failed_oom)
        return JSON_OUT_OF_MEMORY;
    if (lex->incremental)
        return JSON_INVALID_LEXER_TYPE;
 
    /* 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;
#endif

References allocate_incremental_state(), failed_oom, JsonLexContext::incremental, JsonLexContext::input, JsonLexContext::input_length, JSON_INVALID_LEXER_TYPE, json_lex(), JSON_OUT_OF_MEMORY, JSON_PARSE_END, JSON_SUCCESS, JSON_TOKEN_ARRAY_START, JSON_TOKEN_END, JSON_TOKEN_OBJECT_START, lex_expect(), lex_peek(), parse_array(), parse_object(), parse_scalar(), pg_parse_json_incremental(), and sem.

Referenced by handle_oauth_sasl_error(), json_parse_manifest(), json_validate(), main(), parse_oauth_json(), pg_parse_json_or_errsave(), and test_gb18030_json().

pg_parse_json_incremental()

JsonParseErrorType pg_parse_json_incremental	(	JsonLexContext *	lex,
		const JsonSemAction *	sem,
		const char *	json,
		size_t	len,
		bool	is_last
	)

Definition at line 868 of file jsonapi.c.

{
    JsonTokenType tok;
    JsonParseErrorType result;
    JsonParseContext ctx = JSON_PARSE_VALUE;
    JsonParserStack *pstack = lex->pstack;
 
    if (lex == &failed_oom || lex->inc_state == &failed_inc_oom)
        return JSON_OUT_OF_MEMORY;
    if (!lex->incremental)
        return JSON_INVALID_LEXER_TYPE;
 
    lex->input = lex->token_terminator = lex->line_start = json;
    lex->input_length = len;
    lex->inc_state->is_last_chunk = is_last;
    lex->inc_state->started = true;
 
    /* get the initial token */
    result = json_lex(lex);
    if (result != JSON_SUCCESS)
        return result;
 
    tok = lex_peek(lex);
 
    /* use prediction stack for incremental parsing */
 
    if (!have_prediction(pstack))
    {
        td_entry    goal = TD_ENTRY(JSON_PROD_GOAL);
 
        push_prediction(pstack, goal);
    }
 
    while (have_prediction(pstack))
    {
        char        top = pop_prediction(pstack);
        td_entry    entry;
 
        /*
         * these first two branches are the guts of the Table Driven method
         */
        if (top == tok)
        {
            /*
             * tok can only be a terminal symbol, so top must be too. the
             * token matches the top of the stack, so get the next token.
             */
            if (tok < JSON_TOKEN_END)
            {
                result = json_lex(lex);
                if (result != JSON_SUCCESS)
                    return result;
                tok = lex_peek(lex);
            }
        }
        else if (IS_NT(top) && (entry = td_parser_table[OFS(top)][tok]).prod != NULL)
        {
            /*
             * the token is in the director set for a production of the
             * non-terminal at the top of the stack, so push the reversed RHS
             * of the production onto the stack.
             */
            push_prediction(pstack, entry);
        }
        else if (IS_SEM(top))
        {
            /*
             * top is a semantic action marker, so take action accordingly.
             * It's important to have these markers in the prediction stack
             * before any token they might need so we don't advance the token
             * prematurely. Note in a couple of cases we need to do something
             * both before and after the token.
             */
            switch (top)
            {
                case JSON_SEM_OSTART:
                    {
                        json_struct_action ostart = sem->object_start;
 
                        if (lex->lex_level >= JSON_TD_MAX_STACK)
                            return JSON_NESTING_TOO_DEEP;
 
                        if (ostart != NULL)
                        {
                            result = (*ostart) (sem->semstate);
                            if (result != JSON_SUCCESS)
                                return result;
                        }
 
                        if (!inc_lex_level(lex))
                            return JSON_OUT_OF_MEMORY;
                    }
                    break;
                case JSON_SEM_OEND:
                    {
                        json_struct_action oend = sem->object_end;
 
                        dec_lex_level(lex);
                        if (oend != NULL)
                        {
                            result = (*oend) (sem->semstate);
                            if (result != JSON_SUCCESS)
                                return result;
                        }
                    }
                    break;
                case JSON_SEM_ASTART:
                    {
                        json_struct_action astart = sem->array_start;
 
                        if (lex->lex_level >= JSON_TD_MAX_STACK)
                            return JSON_NESTING_TOO_DEEP;
 
                        if (astart != NULL)
                        {
                            result = (*astart) (sem->semstate);
                            if (result != JSON_SUCCESS)
                                return result;
                        }
 
                        if (!inc_lex_level(lex))
                            return JSON_OUT_OF_MEMORY;
                    }
                    break;
                case JSON_SEM_AEND:
                    {
                        json_struct_action aend = sem->array_end;
 
                        dec_lex_level(lex);
                        if (aend != NULL)
                        {
                            result = (*aend) (sem->semstate);
                            if (result != JSON_SUCCESS)
                                return result;
                        }
                    }
                    break;
                case JSON_SEM_OFIELD_INIT:
                    {
                        /*
                         * all we do here is save out the field name. We have
                         * to wait to get past the ':' to see if the next
                         * value is null so we can call the semantic routine
                         */
                        char       *fname = NULL;
                        json_ofield_action ostart = sem->object_field_start;
                        json_ofield_action oend = sem->object_field_end;
 
                        if ((ostart != NULL || oend != NULL) && lex->need_escapes)
                        {
                            fname = STRDUP(lex->strval->data);
                            if (fname == NULL)
                                return JSON_OUT_OF_MEMORY;
                        }
                        set_fname(lex, fname);
                    }
                    break;
                case JSON_SEM_OFIELD_START:
                    {
                        /*
                         * the current token should be the first token of the
                         * value
                         */
                        bool        isnull = tok == JSON_TOKEN_NULL;
                        json_ofield_action ostart = sem->object_field_start;
 
                        set_fnull(lex, isnull);
 
                        if (ostart != NULL)
                        {
                            char       *fname = get_fname(lex);
 
                            result = (*ostart) (sem->semstate, fname, isnull);
                            if (result != JSON_SUCCESS)
                                return result;
                        }
                    }
                    break;
                case JSON_SEM_OFIELD_END:
                    {
                        json_ofield_action oend = sem->object_field_end;
 
                        if (oend != NULL)
                        {
                            char       *fname = get_fname(lex);
                            bool        isnull = get_fnull(lex);
 
                            result = (*oend) (sem->semstate, fname, isnull);
                            if (result != JSON_SUCCESS)
                                return result;
                        }
                    }
                    break;
                case JSON_SEM_AELEM_START:
                    {
                        json_aelem_action astart = sem->array_element_start;
                        bool        isnull = tok == JSON_TOKEN_NULL;
 
                        set_fnull(lex, isnull);
 
                        if (astart != NULL)
                        {
                            result = (*astart) (sem->semstate, isnull);
                            if (result != JSON_SUCCESS)
                                return result;
                        }
                    }
                    break;
                case JSON_SEM_AELEM_END:
                    {
                        json_aelem_action aend = sem->array_element_end;
 
                        if (aend != NULL)
                        {
                            bool        isnull = get_fnull(lex);
 
                            result = (*aend) (sem->semstate, isnull);
                            if (result != JSON_SUCCESS)
                                return result;
                        }
                    }
                    break;
                case JSON_SEM_SCALAR_INIT:
                    {
                        json_scalar_action sfunc = sem->scalar;
 
                        pstack->scalar_val = NULL;
 
                        if (sfunc != NULL)
                        {
                            /*
                             * extract the de-escaped string value, or the raw
                             * lexeme
                             */
                            /*
                             * XXX copied from RD parser but looks like a
                             * buglet
                             */
                            if (tok == JSON_TOKEN_STRING)
                            {
                                if (lex->need_escapes)
                                {
                                    pstack->scalar_val = STRDUP(lex->strval->data);
                                    if (pstack->scalar_val == NULL)
                                        return JSON_OUT_OF_MEMORY;
                                }
                            }
                            else
                            {
                                ptrdiff_t   tlen = (lex->token_terminator - lex->token_start);
 
                                pstack->scalar_val = ALLOC(tlen + 1);
                                if (pstack->scalar_val == NULL)
                                    return JSON_OUT_OF_MEMORY;
 
                                memcpy(pstack->scalar_val, lex->token_start, tlen);
                                pstack->scalar_val[tlen] = '\0';
                            }
                            pstack->scalar_tok = tok;
                        }
                    }
                    break;
                case JSON_SEM_SCALAR_CALL:
                    {
                        /*
                         * We'd like to be able to get rid of this business of
                         * two bits of scalar action, but we can't. It breaks
                         * certain semantic actions which expect that when
                         * called the lexer has consumed the item. See for
                         * example get_scalar() in jsonfuncs.c.
                         */
                        json_scalar_action sfunc = sem->scalar;
 
                        if (sfunc != NULL)
                        {
                            result = (*sfunc) (sem->semstate, pstack->scalar_val, pstack->scalar_tok);
 
                            /*
                             * Either ownership of the token passed to the
                             * callback, or we need to free it now. Either
                             * way, clear our pointer to it so it doesn't get
                             * freed in the future.
                             */
                            if (lex->flags & JSONLEX_CTX_OWNS_TOKENS)
                                FREE(pstack->scalar_val);
                            pstack->scalar_val = NULL;
 
                            if (result != JSON_SUCCESS)
                                return result;
                        }
                    }
                    break;
                default:
                    /* should not happen */
                    break;
            }
        }
        else
        {
            /*
             * The token didn't match the stack top if it's a terminal nor a
             * production for the stack top if it's a non-terminal.
             *
             * Various cases here are Asserted to be not possible, as the
             * token would not appear at the top of the prediction stack
             * unless the lookahead matched.
             */
            switch (top)
            {
                case JSON_TOKEN_STRING:
                    if (next_prediction(pstack) == JSON_TOKEN_COLON)
                        ctx = JSON_PARSE_STRING;
                    else
                    {
                        Assert(false);
                        ctx = JSON_PARSE_VALUE;
                    }
                    break;
                case JSON_TOKEN_NUMBER:
                case JSON_TOKEN_TRUE:
                case JSON_TOKEN_FALSE:
                case JSON_TOKEN_NULL:
                case JSON_TOKEN_ARRAY_START:
                case JSON_TOKEN_OBJECT_START:
                    Assert(false);
                    ctx = JSON_PARSE_VALUE;
                    break;
                case JSON_TOKEN_ARRAY_END:
                    Assert(false);
                    ctx = JSON_PARSE_ARRAY_NEXT;
                    break;
                case JSON_TOKEN_OBJECT_END:
                    Assert(false);
                    ctx = JSON_PARSE_OBJECT_NEXT;
                    break;
                case JSON_TOKEN_COMMA:
                    Assert(false);
                    if (next_prediction(pstack) == JSON_TOKEN_STRING)
                        ctx = JSON_PARSE_OBJECT_NEXT;
                    else
                        ctx = JSON_PARSE_ARRAY_NEXT;
                    break;
                case JSON_TOKEN_COLON:
                    ctx = JSON_PARSE_OBJECT_LABEL;
                    break;
                case JSON_TOKEN_END:
                    ctx = JSON_PARSE_END;
                    break;
                case JSON_NT_MORE_ARRAY_ELEMENTS:
                    ctx = JSON_PARSE_ARRAY_NEXT;
                    break;
                case JSON_NT_ARRAY_ELEMENTS:
                    ctx = JSON_PARSE_ARRAY_START;
                    break;
                case JSON_NT_MORE_KEY_PAIRS:
                    ctx = JSON_PARSE_OBJECT_NEXT;
                    break;
                case JSON_NT_KEY_PAIRS:
                    ctx = JSON_PARSE_OBJECT_START;
                    break;
                default:
                    ctx = JSON_PARSE_VALUE;
            }
            return report_parse_error(ctx, lex);
        }
    }
 
    return JSON_SUCCESS;

References ALLOC, JsonSemAction::array_element_end, JsonSemAction::array_element_start, JsonSemAction::array_end, JsonSemAction::array_start, Assert(), dec_lex_level(), failed_inc_oom, failed_oom, JsonLexContext::flags, FREE, get_fname(), get_fnull(), have_prediction(), inc_lex_level(), JsonLexContext::inc_state, JsonLexContext::incremental, JsonLexContext::input, JsonLexContext::input_length, JsonIncrementalState::is_last_chunk, IS_NT, IS_SEM, JSON_INVALID_LEXER_TYPE, json_lex(), JSON_NESTING_TOO_DEEP, JSON_NT_ARRAY_ELEMENTS, JSON_NT_KEY_PAIRS, JSON_NT_MORE_ARRAY_ELEMENTS, JSON_NT_MORE_KEY_PAIRS, JSON_OUT_OF_MEMORY, JSON_PARSE_ARRAY_NEXT, JSON_PARSE_ARRAY_START, JSON_PARSE_END, JSON_PARSE_OBJECT_LABEL, JSON_PARSE_OBJECT_NEXT, JSON_PARSE_OBJECT_START, JSON_PARSE_STRING, JSON_PARSE_VALUE, JSON_PROD_GOAL, JSON_SEM_AELEM_END, JSON_SEM_AELEM_START, JSON_SEM_AEND, JSON_SEM_ASTART, JSON_SEM_OEND, JSON_SEM_OFIELD_END, JSON_SEM_OFIELD_INIT, JSON_SEM_OFIELD_START, JSON_SEM_OSTART, JSON_SEM_SCALAR_CALL, JSON_SEM_SCALAR_INIT, JSON_SUCCESS, JSON_TD_MAX_STACK, 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, JSONLEX_CTX_OWNS_TOKENS, len, JsonLexContext::lex_level, lex_peek(), JsonLexContext::line_start, JsonLexContext::need_escapes, next_prediction(), JsonSemAction::object_end, JsonSemAction::object_field_end, JsonSemAction::object_field_start, JsonSemAction::object_start, OFS, pop_prediction(), JsonLexContext::pstack, push_prediction(), report_parse_error(), JsonSemAction::scalar, JsonParserStack::scalar_tok, JsonParserStack::scalar_val, sem, JsonSemAction::semstate, set_fname(), set_fnull(), JsonIncrementalState::started, STRDUP, JsonLexContext::strval, TD_ENTRY, td_parser_table, JsonLexContext::token_start, and JsonLexContext::token_terminator.

Referenced by json_parse_manifest_incremental_chunk(), main(), and pg_parse_json().

setJsonLexContextOwnsTokens()

void setJsonLexContextOwnsTokens	(	JsonLexContext *	lex,
		bool	owned_by_context
	)

Definition at line 542 of file jsonapi.c.

{
    if (lex->incremental && lex->inc_state->started)
    {
        /*
         * Switching this flag after parsing has already started is a
         * programming error.
         */
        Assert(false);
        return;
    }
 
    if (owned_by_context)
        lex->flags |= JSONLEX_CTX_OWNS_TOKENS;
    else
        lex->flags &= ~JSONLEX_CTX_OWNS_TOKENS;

References Assert(), JsonLexContext::flags, JsonLexContext::inc_state, JsonLexContext::incremental, JSONLEX_CTX_OWNS_TOKENS, and JsonIncrementalState::started.

Referenced by handle_oauth_sasl_error(), main(), and parse_oauth_json().

Variable Documentation

nullSemAction

PGDLLIMPORT const JsonSemAction nullSemAction

extern

Definition at line 287 of file jsonapi.c.

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