Return to pa_json.h CVS log

Up to [parser3project] / parser3 / src / lib / json

Annotation of parser3/src/lib/json/pa_json.h, revision 1.1

1.1     ! moko        1: /*
        !             2:  * Copyright (C) 2009 Vincent Hanquez <vincent@snarc.org>
        !             3:  *
        !             4:  * This program is free software; you can redistribute it and/or modify
        !             5:  * it under the terms of the GNU Lesser General Public License as published
        !             6:  * by the Free Software Foundation; version 2.1 or version 3.0 only.
        !             7:  *
        !             8:  * This program is distributed in the hope that it will be useful,
        !             9:  * but WITHOUT ANY WARRANTY; without even the implied warranty of
        !            10:  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
        !            11:  * GNU General Public License for more details.
        !            12:  */
        !            13: 
        !            14: #ifndef JSON_H
        !            15: #define JSON_H
        !            16: 
        !            17: #include "pa_config_includes.h"
        !            18: 
        !            19: #ifdef __cplusplus
        !            20: extern "C" {
        !            21: #endif
        !            22: 
        !            23: typedef enum 
        !            24: {
        !            25:        JSON_NONE,
        !            26:        JSON_ARRAY_BEGIN,
        !            27:        JSON_OBJECT_BEGIN,
        !            28:        JSON_ARRAY_END,
        !            29:        JSON_OBJECT_END,
        !            30:        JSON_INT,
        !            31:        JSON_FLOAT,
        !            32:        JSON_STRING,
        !            33:        JSON_KEY,
        !            34:        JSON_TRUE,
        !            35:        JSON_FALSE,
        !            36:        JSON_NULL,
        !            37: } json_type;
        !            38: 
        !            39: typedef enum
        !            40: {
        !            41:        /* SUCCESS = 0 */
        !            42:        /* running out of memory */
        !            43:        JSON_ERROR_NO_MEMORY = 1,
        !            44:        /* character < 32, except space newline tab */
        !            45:        JSON_ERROR_BAD_CHAR,
        !            46:        /* trying to pop more object/array than pushed on the stack */
        !            47:        JSON_ERROR_POP_EMPTY,
        !            48:        /* trying to pop wrong type of mode. popping array in object mode, vice versa */
        !            49:        JSON_ERROR_POP_UNEXPECTED_MODE,
        !            50:        /* reach nesting limit on stack */
        !            51:        JSON_ERROR_NESTING_LIMIT,
        !            52:        /* reach data limit on buffer */
        !            53:        JSON_ERROR_DATA_LIMIT,
        !            54:        /* comment are not allowed with current configuration */
        !            55:        JSON_ERROR_COMMENT_NOT_ALLOWED,
        !            56:        /* unexpected char in the current parser context */
        !            57:        JSON_ERROR_UNEXPECTED_CHAR,
        !            58:        /* unicode low surrogate missing after high surrogate */
        !            59:        JSON_ERROR_UNICODE_MISSING_LOW_SURROGATE,
        !            60:        /* unicode low surrogate missing without previous high surrogate */
        !            61:        JSON_ERROR_UNICODE_UNEXPECTED_LOW_SURROGATE,
        !            62:        /* found a comma not in structure (array/object) */
        !            63:        JSON_ERROR_COMMA_OUT_OF_STRUCTURE,
        !            64:        /* callback returns error */
        !            65:        JSON_ERROR_CALLBACK,
        !            66: } json_error;
        !            67: 
        !            68: #define LIBJSON_DEFAULT_STACK_SIZE 256
        !            69: #define LIBJSON_DEFAULT_BUFFER_SIZE 4096
        !            70: 
        !            71: typedef int (*json_parser_callback)(void *userdata, int type, const char *data, uint32_t length);
        !            72: 
        !            73: typedef struct {
        !            74:        uint32_t buffer_initial_size;
        !            75:        uint32_t max_nesting;
        !            76:        uint32_t max_data;
        !            77:        int allow_c_comments;
        !            78:        int allow_yaml_comments;
        !            79:        void * (*user_malloc)(size_t size);
        !            80:        void * (*user_realloc)(void *ptr, size_t size);
        !            81:        void (*user_free)(void *ptr);
        !            82: } json_config;
        !            83: 
        !            84: typedef struct json_parser {
        !            85:        json_config config;
        !            86: 
        !            87:        /* SAJ callback */
        !            88:        json_parser_callback callback;
        !            89:        void *userdata;
        !            90: 
        !            91:        /* parser state */
        !            92:        uint8_t state;
        !            93:        uint8_t save_state;
        !            94:        uint8_t expecting_key;
        !            95:        uint16_t unicode_multi;
        !            96:        json_type type;
        !            97: 
        !            98:        /* state stack */
        !            99:        uint8_t *stack;
        !           100:        uint32_t stack_offset;
        !           101:        uint32_t stack_size;
        !           102: 
        !           103:        /* parse buffer */
        !           104:        char *buffer;
        !           105:        uint32_t buffer_size;
        !           106:        uint32_t buffer_offset;
        !           107: } json_parser;
        !           108: 
        !           109: /** json_parser_init initialize a parser structure taking a config,
        !           110:  * a config and its userdata.
        !           111:  * return JSON_ERROR_NO_MEMORY if memory allocation failed or SUCCESS.  */
        !           112: int json_parser_init(json_parser *parser, json_config *cfg,
        !           113:                      json_parser_callback callback, void *userdata);
        !           114: 
        !           115: /** json_parser_free freed memory structure allocated by the parser */
        !           116: int json_parser_free(json_parser *parser);
        !           117: 
        !           118: /** json_parser_string append a string s with a specific length to the parser
        !           119:  * return 0 if everything went ok, a JSON_ERROR_* otherwise.
        !           120:  * the user can supplied a valid processed pointer that will
        !           121:  * be fill with the number of processed characters before returning */
        !           122: int json_parser_string(json_parser *parser, const char *string,
        !           123:                        uint32_t length, uint32_t *processed);
        !           124: 
        !           125: /** json_parser_char append one single char to the parser
        !           126:  * return 0 if everything went ok, a JSON_ERROR_* otherwise */
        !           127: int json_parser_char(json_parser *parser, unsigned char next_char);
        !           128: 
        !           129: /** json_parser_is_done return 0 is the parser isn't in a finish state. !0 if it is */
        !           130: int json_parser_is_done(json_parser *parser);
        !           131: 
        !           132: #ifdef __cplusplus
        !           133: }
        !           134: #endif
        !           135: 
        !           136: #endif /* JSON_H */