yajl.c File Reference

#include <stdlib.h>
#include <string.h>
#include <stdarg.h>
#include <assert.h>
#include "yajl_parse.h"
#include "yajl_lex.h"
#include "yajl_parser.h"
#include "yajl_alloc.h"

Include dependency graph for yajl.c:

Go to the source code of this file.

Functions
const char *	yajl_status_to_string (yajl_status stat)
yajl_handle	yajl_alloc (const yajl_callbacks *callbacks, yajl_alloc_funcs *afs, void *ctx)
int	yajl_config (yajl_handle h, yajl_option opt,...)
void	yajl_free (yajl_handle handle)
yajl_status	yajl_parse (yajl_handle hand, const unsigned char *jsonText, size_t jsonTextLen)
yajl_status	yajl_complete_parse (yajl_handle hand)
unsigned char *	yajl_get_error (yajl_handle hand, int verbose, const unsigned char *jsonText, size_t jsonTextLen)
size_t	yajl_get_bytes_consumed (yajl_handle hand)
void	yajl_free_error (yajl_handle hand, unsigned char *str)

Function Documentation

yajl_handle yajl_alloc	(	const yajl_callbacks *	callbacks,
		yajl_alloc_funcs *	afs,
		void *	ctx
	)

Allocate a parser handle

Parameters

callbacks	A yajl callbacks structure specifying the functions to call when different JSON entities are encountered in the input text. May be NULL, which is only useful for validation.
afs	memory allocation functions, may be NULL for to use C runtime library routines (malloc and friends)
ctx	a context pointer that will be passed to callbacks.

Definition at line 46 of file yajl.c.

{
    yajl_handle hand = NULL;
    yajl_alloc_funcs afsBuffer;

    /* first order of business is to set up memory allocation routines */
    if (afs != NULL) {
        if (afs->malloc == NULL || afs->realloc == NULL || afs->free == NULL)
        {
            return NULL;
        }
    } else {
        yajl_set_default_alloc_funcs(&afsBuffer);
        afs = &afsBuffer;
    }

    hand = (yajl_handle) YA_MALLOC(afs, sizeof(struct yajl_handle_t));
    if (hand == NULL) {
        return NULL;
    }

    /* copy in pointers to allocation routines */
    memcpy((void *) &(hand->alloc), (void *) afs, sizeof(yajl_alloc_funcs));

    hand->callbacks = callbacks;
    hand->ctx = ctx;
    hand->lexer = NULL;
    hand->bytesConsumed = 0;
    hand->decodeBuf = yajl_buf_alloc(&(hand->alloc));
    hand->flags     = 0;
    yajl_bs_init(hand->stateStack, &(hand->alloc));
    yajl_bs_push(hand->stateStack, yajl_state_start);

    return hand;
}

yajl_status yajl_complete_parse

(

yajl_handle

hand

)

Parse any remaining buffered json. Since yajl is a stream-based parser, without an explicit end of input, yajl sometimes can't decide if content at the end of the stream is valid or not. For example, if "1" has been fed in, yajl can't know whether another digit is next or some character that would terminate the integer token.

Parameters

hand	- a handle to the json parser allocated with yajl_alloc()

Definition at line 142 of file yajl.c.

{
    /* The lexer is lazy allocated in the first call to parse.  if parse is
     * never called, then no data was provided to parse at all.  This is a
     * "premature EOF" error unless yajl_allow_partial_values is specified.
     * allocating the lexer now is the simplest possible way to handle this
     * case while preserving all the other semantics of the parser
     * (multiple values, partial values, etc). */
    if (hand->lexer == NULL) {
        hand->lexer = yajl_lex_alloc(&(hand->alloc),
                                     hand->flags & yajl_allow_comments,
                                     !(hand->flags & yajl_dont_validate_strings));
    }

    return yajl_do_finish(hand);
}

int yajl_config	(	yajl_handle	h,
		yajl_option	opt,
			...
	)

Allow the modification of parser options subsequent to handle allocation (via yajl_alloc())

Returns

zero in case of errors, non-zero otherwise

Definition at line 85 of file yajl.c.

{
    int rv = 1;
    va_list ap;
    va_start(ap, opt);

    switch(opt) {
        case yajl_allow_comments:
        case yajl_dont_validate_strings:
        case yajl_allow_trailing_garbage:
        case yajl_allow_multiple_values:
        case yajl_allow_partial_values:
            if (va_arg(ap, int)) h->flags |= opt;
            else h->flags &= ~opt;
            break;
        default:
            rv = 0;
    }
    va_end(ap);

    return rv;
}

void yajl_free

(

yajl_handle

handle

)

Free a parser handle

Definition at line 109 of file yajl.c.

{
    yajl_bs_free(handle->stateStack);
    yajl_buf_free(handle->decodeBuf);
    if (handle->lexer) {
        yajl_lex_free(handle->lexer);
        handle->lexer = NULL;
    }
    YA_FREE(&(handle->alloc), handle);
}

void yajl_free_error	(	yajl_handle	hand,
		unsigned char *	str
	)

Free an error returned from yajl_get_error()

Definition at line 175 of file yajl.c.

{
    /* use memory allocation functions if set */
    YA_FREE(&(hand->alloc), str);
}

size_t yajl_get_bytes_consumed

(

yajl_handle

hand

)

Get the amount of data consumed from the last chunk passed to YAJL.

In the case of a successful parse this can help you understand if the entire buffer was consumed (which will allow you to handle "junk at end of input").

In the event an error is encountered during parsing, this function affords the client a way to get the offset into the most recent chunk where the error occured. 0 will be returned if no error was encountered.

Definition at line 167 of file yajl.c.

{
    if (!hand) return 0;
    else return hand->bytesConsumed;
}

unsigned char* yajl_get_error	(	yajl_handle	hand,
		int	verbose,
		const unsigned char *	jsonText,
		size_t	jsonTextLength
	)

Get an error string describing the state of the parse.

If verbose is non-zero, the message will include the JSON text where the error occured, along with an arrow pointing to the specific char.

Returns

A dynamically allocated string will be returned which should be freed with yajl_free_error()

Definition at line 160 of file yajl.c.

{
    return yajl_render_error_string(hand, jsonText, jsonTextLen, verbose);
}

yajl_status yajl_parse	(	yajl_handle	hand,
		const unsigned char *	jsonText,
		size_t	jsonTextLength
	)

Parse some json!

Parameters

hand	- a handle to the json parser allocated with yajl_alloc()
jsonText	- a pointer to the UTF8 json text to be parsed
jsonTextLength	- the length, in bytes, of input text

Definition at line 121 of file yajl.c.

{
    yajl_status status;

    /* lazy allocation of the lexer */
    if (hand->lexer == NULL) {
        hand->lexer = yajl_lex_alloc(&(hand->alloc),
                                     hand->flags & yajl_allow_comments,
                                     !(hand->flags & yajl_dont_validate_strings));
    }
    if (hand->lexer == NULL) {
        return yajl_status_error;
    }

    status = yajl_do_parse(hand, jsonText, jsonTextLen);
    return status;
}

const char* yajl_status_to_string

(

yajl_status

code

)

Attain a human readable, english, string for an error

Definition at line 28 of file yajl.c.

{
    const char * statStr = "unknown";
    switch (stat) {
        case yajl_status_ok:
            statStr = "ok, no error";
            break;
        case yajl_status_client_canceled:
            statStr = "client canceled parse";
            break;
        case yajl_status_error:
            statStr = "parse error";
            break;
    }
    return statStr;
}