From 4f49b16079b27d7ce633619e4cddfdf2bffbc952 Mon Sep 17 00:00:00 2001 From: cashmere Date: Fri, 4 Sep 2026 09:05:24 +0200 Subject: initial commit --- extsrc/cson_amalgamation.c | 5712 + extsrc/cson_amalgamation.h | 2871 + extsrc/linenoise-win32.c | 379 + extsrc/linenoise.c | 2812 + extsrc/linenoise.h | 149 + extsrc/pikchr-worker.js | 222 + extsrc/pikchr.c | 8350 ++ extsrc/pikchr.js | 757 + extsrc/pikchr.wasm | Bin 0 -> 97621 bytes extsrc/qrf.h | 207 + extsrc/shell.c | 39444 ++++++ extsrc/sqlite3.c | 269881 ++++++++++++++++++++++++++++++++++++++++++ extsrc/sqlite3.h | 14433 +++ 13 files changed, 345217 insertions(+) create mode 100644 extsrc/cson_amalgamation.c create mode 100644 extsrc/cson_amalgamation.h create mode 100644 extsrc/linenoise-win32.c create mode 100644 extsrc/linenoise.c create mode 100644 extsrc/linenoise.h create mode 100644 extsrc/pikchr-worker.js create mode 100644 extsrc/pikchr.c create mode 100644 extsrc/pikchr.js create mode 100644 extsrc/pikchr.wasm create mode 100644 extsrc/qrf.h create mode 100644 extsrc/shell.c create mode 100644 extsrc/sqlite3.c create mode 100644 extsrc/sqlite3.h (limited to 'extsrc') diff --git a/extsrc/cson_amalgamation.c b/extsrc/cson_amalgamation.c new file mode 100644 index 0000000..e8f17ff --- /dev/null +++ b/extsrc/cson_amalgamation.c @@ -0,0 +1,5712 @@ +#ifdef FOSSIL_ENABLE_JSON +/* auto-generated! Do not edit! */ +#include "cson_amalgamation.h" +/* begin file parser/JSON_parser.h */ +/* See JSON_parser.c for copyright information and licensing. */ + +#ifndef JSON_PARSER_H +#define JSON_PARSER_H + +/* JSON_parser.h */ + + +#include + +/* Windows DLL stuff */ +#ifdef JSON_PARSER_DLL +# ifdef _MSC_VER +# ifdef JSON_PARSER_DLL_EXPORTS +# define JSON_PARSER_DLL_API __declspec(dllexport) +# else +# define JSON_PARSER_DLL_API __declspec(dllimport) +# endif +# else +# define JSON_PARSER_DLL_API +# endif +#else +# define JSON_PARSER_DLL_API +#endif + +/* Determine the integer type use to parse non-floating point numbers */ +#ifdef _WIN32 +typedef __int64 JSON_int_t; +#define JSON_PARSER_INTEGER_SSCANF_TOKEN "%I64d" +#define JSON_PARSER_INTEGER_SPRINTF_TOKEN "%I64d" +#elif (__STDC_VERSION__ >= 199901L) || (HAVE_LONG_LONG == 1) +typedef long long JSON_int_t; +#define JSON_PARSER_INTEGER_SSCANF_TOKEN "%lld" +#define JSON_PARSER_INTEGER_SPRINTF_TOKEN "%lld" +#else +typedef long JSON_int_t; +#define JSON_PARSER_INTEGER_SSCANF_TOKEN "%ld" +#define JSON_PARSER_INTEGER_SPRINTF_TOKEN "%ld" +#endif + + +#ifdef __cplusplus +extern "C" { +#endif + +typedef enum +{ + JSON_E_NONE = 0, + JSON_E_INVALID_CHAR, + JSON_E_INVALID_KEYWORD, + JSON_E_INVALID_ESCAPE_SEQUENCE, + JSON_E_INVALID_UNICODE_SEQUENCE, + JSON_E_INVALID_NUMBER, + JSON_E_NESTING_DEPTH_REACHED, + JSON_E_UNBALANCED_COLLECTION, + JSON_E_EXPECTED_KEY, + JSON_E_EXPECTED_COLON, + JSON_E_OUT_OF_MEMORY +} JSON_error; + +typedef enum +{ + JSON_T_NONE = 0, + JSON_T_ARRAY_BEGIN, + JSON_T_ARRAY_END, + JSON_T_OBJECT_BEGIN, + JSON_T_OBJECT_END, + JSON_T_INTEGER, + JSON_T_FLOAT, + JSON_T_NULL, + JSON_T_TRUE, + JSON_T_FALSE, + JSON_T_STRING, + JSON_T_KEY, + JSON_T_MAX +} JSON_type; + +typedef struct JSON_value_struct { + union { + JSON_int_t integer_value; + + double float_value; + + struct { + const char* value; + size_t length; + } str; + } vu; +} JSON_value; + +typedef struct JSON_parser_struct* JSON_parser; + +/*! \brief JSON parser callback + + \param ctx The pointer passed to new_JSON_parser. + \param type An element of JSON_type but not JSON_T_NONE. + \param value A representation of the parsed value. This parameter is NULL for + JSON_T_ARRAY_BEGIN, JSON_T_ARRAY_END, JSON_T_OBJECT_BEGIN, JSON_T_OBJECT_END, + JSON_T_NULL, JSON_T_TRUE, and JSON_T_FALSE. String values are always returned + as zero-terminated C strings. + + \return Non-zero if parsing should continue, else zero. +*/ +typedef int (*JSON_parser_callback)(void* ctx, int type, const JSON_value* value); + + +/** + A typedef for allocator functions semantically compatible with malloc(). +*/ +typedef void* (*JSON_malloc_t)(size_t n); +/** + A typedef for deallocator functions semantically compatible with free(). +*/ +typedef void (*JSON_free_t)(void* mem); + +/*! \brief The structure used to configure a JSON parser object +*/ +typedef struct { + /** Pointer to a callback, called when the parser has something to tell + the user. This parameter may be NULL. In this case the input is + merely checked for validity. + */ + JSON_parser_callback callback; + /** + Callback context - client-specified data to pass to the + callback function. This parameter may be NULL. + */ + void* callback_ctx; + /** Specifies the levels of nested JSON to allow. Negative numbers yield unlimited nesting. + If negative, the parser can parse arbitrary levels of JSON, otherwise + the depth is the limit. + */ + int depth; + /** + To allow C style comments in JSON, set to non-zero. + */ + int allow_comments; + /** + To decode floating point numbers manually set this parameter to + non-zero. + */ + int handle_floats_manually; + /** + The memory allocation routine, which must be semantically + compatible with malloc(3). If set to NULL, malloc(3) is used. + + If this is set to a non-NULL value then the 'free' member MUST be + set to the proper deallocation counterpart for this function. + Failure to do so results in undefined behaviour at deallocation + time. + */ + JSON_malloc_t malloc; + /** + The memory deallocation routine, which must be semantically + compatible with free(3). If set to NULL, free(3) is used. + + If this is set to a non-NULL value then the 'alloc' member MUST be + set to the proper allocation counterpart for this function. + Failure to do so results in undefined behaviour at deallocation + time. + */ + JSON_free_t free; +} JSON_config; + +/*! \brief Initializes the JSON parser configuration structure to default values. + + The default configuration is + - 127 levels of nested JSON (depends on JSON_PARSER_STACK_SIZE, see json_parser.c) + - no parsing, just checking for JSON syntax + - no comments + - Uses realloc() for memory de/allocation. + + \param config. Used to configure the parser. +*/ +JSON_PARSER_DLL_API void init_JSON_config(JSON_config * config); + +/*! \brief Create a JSON parser object + + \param config. Used to configure the parser. Set to NULL to use + the default configuration. See init_JSON_config. Its contents are + copied by this function, so it need not outlive the returned + object. + + \return The parser object, which is owned by the caller and must eventually + be freed by calling delete_JSON_parser(). +*/ +JSON_PARSER_DLL_API JSON_parser new_JSON_parser(JSON_config const* config); + +/*! \brief Destroy a previously created JSON parser object. */ +JSON_PARSER_DLL_API void delete_JSON_parser(JSON_parser jc); + +/*! \brief Parse a character. + + \return Non-zero, if all characters passed to this function are part of are valid JSON. +*/ +JSON_PARSER_DLL_API int JSON_parser_char(JSON_parser jc, int next_char); + +/*! \brief Finalize parsing. + + Call this method once after all input characters have been consumed. + + \return Non-zero, if all parsed characters are valid JSON, zero otherwise. +*/ +JSON_PARSER_DLL_API int JSON_parser_done(JSON_parser jc); + +/*! \brief Determine if a given string is valid JSON white space + + \return Non-zero if the string is valid, zero otherwise. +*/ +JSON_PARSER_DLL_API int JSON_parser_is_legal_white_space_string(const char* s); + +/*! \brief Gets the last error that occurred during the use of JSON_parser. + + \return A value from the JSON_error enum. +*/ +JSON_PARSER_DLL_API int JSON_parser_get_last_error(JSON_parser jc); + +/*! \brief Re-sets the parser to prepare it for another parse run. + + \return True (non-zero) on success, 0 on error (e.g. !jc). +*/ +JSON_PARSER_DLL_API int JSON_parser_reset(JSON_parser jc); + + +#ifdef __cplusplus +} +#endif + + +#endif /* JSON_PARSER_H */ +/* end file parser/JSON_parser.h */ +/* begin file parser/JSON_parser.c */ +/* +Copyright (c) 2007-2013 Jean Gressmann (jean@0x42.de) + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. +*/ + +/* + Changelog: + 2013-09-08 + Updated license to to be compatible with Debian license requirements. + + 2012-06-06 + Fix for invalid UTF16 characters and some comment fixex (thomas.h.moog@intel.com). + + 2010-11-25 + Support for custom memory allocation (sgbeal@googlemail.com). + + 2010-05-07 + Added error handling for memory allocation failure (sgbeal@googlemail.com). + Added diagnosis errors for invalid JSON. + + 2010-03-25 + Fixed buffer overrun in grow_parse_buffer & cleaned up code. + + 2009-10-19 + Replaced long double in JSON_value_struct with double after reports + of strtold being broken on some platforms (charles@transmissionbt.com). + + 2009-05-17 + Incorporated benrudiak@googlemail.com fix for UTF16 decoding. + + 2009-05-14 + Fixed float parsing bug related to a locale being set that didn't + use '.' as decimal point character (charles@transmissionbt.com). + + 2008-10-14 + Renamed states.IN to states.IT to avoid name clash which IN macro + defined in windef.h (alexey.pelykh@gmail.com) + + 2008-07-19 + Removed some duplicate code & debugging variable (charles@transmissionbt.com) + + 2008-05-28 + Made JSON_value structure ansi C compliant. This bug was report by + trisk@acm.jhu.edu + + 2008-05-20 + Fixed bug reported by charles@transmissionbt.com where the switching + from static to dynamic parse buffer did not copy the static parse + buffer's content. +*/ + + + +#include +#include +#include +#include +#include +#include +#include +#include + + +#ifdef _MSC_VER +# if _MSC_VER >= 1400 /* Visual Studio 2005 and up */ +# pragma warning(disable:4996) /* unsecure sscanf */ +# pragma warning(disable:4127) /* conditional expression is constant */ +# endif +#endif + + +#define true 1 +#define false 0 +#define XX -1 /* the universal error code */ + +/* values chosen so that the object size is approx equal to one page (4K) */ +#ifndef JSON_PARSER_STACK_SIZE +# define JSON_PARSER_STACK_SIZE 128 +#endif + +#ifndef JSON_PARSER_PARSE_BUFFER_SIZE +# define JSON_PARSER_PARSE_BUFFER_SIZE 3500 +#endif + +typedef void* (*JSON_debug_malloc_t)(size_t bytes, const char* reason); + +#ifdef JSON_PARSER_DEBUG_MALLOC +# define JSON_parser_malloc(func, bytes, reason) ((JSON_debug_malloc_t)func)(bytes, reason) +#else +# define JSON_parser_malloc(func, bytes, reason) func(bytes) +#endif + +typedef unsigned short UTF16; + +struct JSON_parser_struct { + JSON_parser_callback callback; + void* ctx; + signed char state, before_comment_state, type, escaped, comment, allow_comments, handle_floats_manually, error; + char decimal_point; + UTF16 utf16_high_surrogate; + int current_char; + int depth; + int top; + int stack_capacity; + signed char* stack; + char* parse_buffer; + size_t parse_buffer_capacity; + size_t parse_buffer_count; + signed char static_stack[JSON_PARSER_STACK_SIZE]; + char static_parse_buffer[JSON_PARSER_PARSE_BUFFER_SIZE]; + JSON_malloc_t malloc; + JSON_free_t free; +}; + +#define COUNTOF(x) (sizeof(x)/sizeof(x[0])) + +/* + Characters are mapped into these character classes. This allows for + a significant reduction in the size of the state transition table. +*/ + + + +enum classes { + C_SPACE, /* space */ + C_WHITE, /* other whitespace */ + C_LCURB, /* { */ + C_RCURB, /* } */ + C_LSQRB, /* [ */ + C_RSQRB, /* ] */ + C_COLON, /* : */ + C_COMMA, /* , */ + C_QUOTE, /* " */ + C_BACKS, /* \ */ + C_SLASH, /* / */ + C_PLUS, /* + */ + C_MINUS, /* - */ + C_POINT, /* . */ + C_ZERO , /* 0 */ + C_DIGIT, /* 123456789 */ + C_LOW_A, /* a */ + C_LOW_B, /* b */ + C_LOW_C, /* c */ + C_LOW_D, /* d */ + C_LOW_E, /* e */ + C_LOW_F, /* f */ + C_LOW_L, /* l */ + C_LOW_N, /* n */ + C_LOW_R, /* r */ + C_LOW_S, /* s */ + C_LOW_T, /* t */ + C_LOW_U, /* u */ + C_ABCDF, /* ABCDF */ + C_E, /* E */ + C_ETC, /* everything else */ + C_STAR, /* * */ + NR_CLASSES +}; + +static const signed char ascii_class[128] = { +/* + This array maps the 128 ASCII characters into character classes. + The remaining Unicode characters should be mapped to C_ETC. + Non-whitespace control characters are errors. +*/ + XX, XX, XX, XX, XX, XX, XX, XX, + XX, C_WHITE, C_WHITE, XX, XX, C_WHITE, XX, XX, + XX, XX, XX, XX, XX, XX, XX, XX, + XX, XX, XX, XX, XX, XX, XX, XX, + + C_SPACE, C_ETC, C_QUOTE, C_ETC, C_ETC, C_ETC, C_ETC, C_ETC, + C_ETC, C_ETC, C_STAR, C_PLUS, C_COMMA, C_MINUS, C_POINT, C_SLASH, + C_ZERO, C_DIGIT, C_DIGIT, C_DIGIT, C_DIGIT, C_DIGIT, C_DIGIT, C_DIGIT, + C_DIGIT, C_DIGIT, C_COLON, C_ETC, C_ETC, C_ETC, C_ETC, C_ETC, + + C_ETC, C_ABCDF, C_ABCDF, C_ABCDF, C_ABCDF, C_E, C_ABCDF, C_ETC, + C_ETC, C_ETC, C_ETC, C_ETC, C_ETC, C_ETC, C_ETC, C_ETC, + C_ETC, C_ETC, C_ETC, C_ETC, C_ETC, C_ETC, C_ETC, C_ETC, + C_ETC, C_ETC, C_ETC, C_LSQRB, C_BACKS, C_RSQRB, C_ETC, C_ETC, + + C_ETC, C_LOW_A, C_LOW_B, C_LOW_C, C_LOW_D, C_LOW_E, C_LOW_F, C_ETC, + C_ETC, C_ETC, C_ETC, C_ETC, C_LOW_L, C_ETC, C_LOW_N, C_ETC, + C_ETC, C_ETC, C_LOW_R, C_LOW_S, C_LOW_T, C_LOW_U, C_ETC, C_ETC, + C_ETC, C_ETC, C_ETC, C_LCURB, C_ETC, C_RCURB, C_ETC, C_ETC +}; + + +/* + The state codes. +*/ +enum states { + GO, /* start */ + OK, /* ok */ + OB, /* object */ + KE, /* key */ + CO, /* colon */ + VA, /* value */ + AR, /* array */ + ST, /* string */ + ESC, /* escape */ + U1, /* u1 */ + U2, /* u2 */ + U3, /* u3 */ + U4, /* u4 */ + MI, /* minus */ + ZE, /* zero */ + IT, /* integer */ + FR, /* fraction */ + E1, /* e */ + E2, /* ex */ + E3, /* exp */ + T1, /* tr */ + T2, /* tru */ + T3, /* true */ + F1, /* fa */ + F2, /* fal */ + F3, /* fals */ + F4, /* false */ + N1, /* nu */ + N2, /* nul */ + N3, /* null */ + C1, /* / */ + C2, /* / * */ + C3, /* * */ + FX, /* *.* *eE* */ + D1, /* second UTF-16 character decoding started by \ */ + D2, /* second UTF-16 character proceeded by u */ + NR_STATES +}; + +enum actions +{ + CB = -10, /* comment begin */ + CE = -11, /* comment end */ + FA = -12, /* false */ + TR = -13, /* false */ + NU = -14, /* null */ + DE = -15, /* double detected by exponent e E */ + DF = -16, /* double detected by fraction . */ + SB = -17, /* string begin */ + MX = -18, /* integer detected by minus */ + ZX = -19, /* integer detected by zero */ + IX = -20, /* integer detected by 1-9 */ + EX = -21, /* next char is escaped */ + UC = -22 /* Unicode character read */ +}; + + +static const signed char state_transition_table[NR_STATES][NR_CLASSES] = { +/* + The state transition table takes the current state and the current symbol, + and returns either a new state or an action. An action is represented as a + negative number. A JSON text is accepted if at the end of the text the + state is OK and if the mode is MODE_DONE. + + white 1-9 ABCDF etc + space | { } [ ] : , " \ / + - . 0 | a b c d e f l n r s t u | E | * */ +/*start GO*/ {GO,GO,-6,XX,-5,XX,XX,XX,XX,XX,CB,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX}, +/*ok OK*/ {OK,OK,XX,-8,XX,-7,XX,-3,XX,XX,CB,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX}, +/*object OB*/ {OB,OB,XX,-9,XX,XX,XX,XX,SB,XX,CB,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX}, +/*key KE*/ {KE,KE,XX,XX,XX,XX,XX,XX,SB,XX,CB,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX}, +/*colon CO*/ {CO,CO,XX,XX,XX,XX,-2,XX,XX,XX,CB,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX}, +/*value VA*/ {VA,VA,-6,XX,-5,XX,XX,XX,SB,XX,CB,XX,MX,XX,ZX,IX,XX,XX,XX,XX,XX,FA,XX,NU,XX,XX,TR,XX,XX,XX,XX,XX}, +/*array AR*/ {AR,AR,-6,XX,-5,-7,XX,XX,SB,XX,CB,XX,MX,XX,ZX,IX,XX,XX,XX,XX,XX,FA,XX,NU,XX,XX,TR,XX,XX,XX,XX,XX}, +/*string ST*/ {ST,XX,ST,ST,ST,ST,ST,ST,-4,EX,ST,ST,ST,ST,ST,ST,ST,ST,ST,ST,ST,ST,ST,ST,ST,ST,ST,ST,ST,ST,ST,ST}, +/*escape ES*/ {XX,XX,XX,XX,XX,XX,XX,XX,ST,ST,ST,XX,XX,XX,XX,XX,XX,ST,XX,XX,XX,ST,XX,ST,ST,XX,ST,U1,XX,XX,XX,XX}, +/*u1 U1*/ {XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,U2,U2,U2,U2,U2,U2,U2,U2,XX,XX,XX,XX,XX,XX,U2,U2,XX,XX}, +/*u2 U2*/ {XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,U3,U3,U3,U3,U3,U3,U3,U3,XX,XX,XX,XX,XX,XX,U3,U3,XX,XX}, +/*u3 U3*/ {XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,U4,U4,U4,U4,U4,U4,U4,U4,XX,XX,XX,XX,XX,XX,U4,U4,XX,XX}, +/*u4 U4*/ {XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,UC,UC,UC,UC,UC,UC,UC,UC,XX,XX,XX,XX,XX,XX,UC,UC,XX,XX}, +/*minus MI*/ {XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,ZE,IT,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX}, +/*zero ZE*/ {OK,OK,XX,-8,XX,-7,XX,-3,XX,XX,CB,XX,XX,DF,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX}, +/*int IT*/ {OK,OK,XX,-8,XX,-7,XX,-3,XX,XX,CB,XX,XX,DF,IT,IT,XX,XX,XX,XX,DE,XX,XX,XX,XX,XX,XX,XX,XX,DE,XX,XX}, +/*frac FR*/ {OK,OK,XX,-8,XX,-7,XX,-3,XX,XX,CB,XX,XX,XX,FR,FR,XX,XX,XX,XX,E1,XX,XX,XX,XX,XX,XX,XX,XX,E1,XX,XX}, +/*e E1*/ {XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,E2,E2,XX,E3,E3,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX}, +/*ex E2*/ {XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,E3,E3,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX}, +/*exp E3*/ {OK,OK,XX,-8,XX,-7,XX,-3,XX,XX,XX,XX,XX,XX,E3,E3,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX}, +/*tr T1*/ {XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,T2,XX,XX,XX,XX,XX,XX,XX}, +/*tru T2*/ {XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,T3,XX,XX,XX,XX}, +/*true T3*/ {XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,CB,XX,XX,XX,XX,XX,XX,XX,XX,XX,OK,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX}, +/*fa F1*/ {XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,F2,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX}, +/*fal F2*/ {XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,F3,XX,XX,XX,XX,XX,XX,XX,XX,XX}, +/*fals F3*/ {XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,F4,XX,XX,XX,XX,XX,XX}, +/*false F4*/ {XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,CB,XX,XX,XX,XX,XX,XX,XX,XX,XX,OK,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX}, +/*nu N1*/ {XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,N2,XX,XX,XX,XX}, +/*nul N2*/ {XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,N3,XX,XX,XX,XX,XX,XX,XX,XX,XX}, +/*null N3*/ {XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,CB,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,OK,XX,XX,XX,XX,XX,XX,XX,XX,XX}, +/*/ C1*/ {XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,C2}, +/*/star C2*/ {C2,C2,C2,C2,C2,C2,C2,C2,C2,C2,C2,C2,C2,C2,C2,C2,C2,C2,C2,C2,C2,C2,C2,C2,C2,C2,C2,C2,C2,C2,C2,C3}, +/** C3*/ {C2,C2,C2,C2,C2,C2,C2,C2,C2,C2,CE,C2,C2,C2,C2,C2,C2,C2,C2,C2,C2,C2,C2,C2,C2,C2,C2,C2,C2,C2,C2,C3}, +/*_. FX*/ {OK,OK,XX,-8,XX,-7,XX,-3,XX,XX,XX,XX,XX,XX,FR,FR,XX,XX,XX,XX,E1,XX,XX,XX,XX,XX,XX,XX,XX,E1,XX,XX}, +/*\ D1*/ {XX,XX,XX,XX,XX,XX,XX,XX,XX,D2,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX}, +/*\ D2*/ {XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,XX,U1,XX,XX,XX,XX}, +}; + + +/* + These modes can be pushed on the stack. +*/ +enum modes { + MODE_ARRAY = 1, + MODE_DONE = 2, + MODE_KEY = 3, + MODE_OBJECT = 4 +}; + +static void set_error(JSON_parser jc) +{ + switch (jc->state) { + case GO: + switch (jc->current_char) { + case '{': case '}': case '[': case ']': + jc->error = JSON_E_UNBALANCED_COLLECTION; + break; + default: + jc->error = JSON_E_INVALID_CHAR; + break; + } + break; + case OB: + jc->error = JSON_E_EXPECTED_KEY; + break; + case AR: + jc->error = JSON_E_UNBALANCED_COLLECTION; + break; + case CO: + jc->error = JSON_E_EXPECTED_COLON; + break; + case KE: + jc->error = JSON_E_EXPECTED_KEY; + break; + /* \uXXXX\uYYYY */ + case U1: case U2: case U3: case U4: case D1: case D2: + jc->error = JSON_E_INVALID_UNICODE_SEQUENCE; + break; + /* true, false, null */ + case T1: case T2: case T3: case F1: case F2: case F3: case F4: case N1: case N2: case N3: + jc->error = JSON_E_INVALID_KEYWORD; + break; + /* minus, integer, fraction, exponent */ + case MI: case ZE: case IT: case FR: case E1: case E2: case E3: + jc->error = JSON_E_INVALID_NUMBER; + break; + default: + jc->error = JSON_E_INVALID_CHAR; + break; + } +} + +static int +push(JSON_parser jc, int mode) +{ +/* + Push a mode onto the stack. Return false if there is overflow. +*/ + assert(jc->top <= jc->stack_capacity); + + if (jc->depth < 0) { + if (jc->top == jc->stack_capacity) { + const size_t bytes_to_copy = jc->stack_capacity * sizeof(jc->stack[0]); + const size_t new_capacity = jc->stack_capacity * 2; + const size_t bytes_to_allocate = new_capacity * sizeof(jc->stack[0]); + void* mem = JSON_parser_malloc(jc->malloc, bytes_to_allocate, "stack"); + if (!mem) { + jc->error = JSON_E_OUT_OF_MEMORY; + return false; + } + jc->stack_capacity = (int)new_capacity; + memcpy(mem, jc->stack, bytes_to_copy); + if (jc->stack != &jc->static_stack[0]) { + jc->free(jc->stack); + } + jc->stack = (signed char*)mem; + } + } else { + if (jc->top == jc->depth) { + jc->error = JSON_E_NESTING_DEPTH_REACHED; + return false; + } + } + jc->stack[++jc->top] = (signed char)mode; + return true; +} + + +static int +pop(JSON_parser jc, int mode) +{ +/* + Pop the stack, assuring that the current mode matches the expectation. + Return false if there is underflow or if the modes mismatch. +*/ + if (jc->top < 0 || jc->stack[jc->top] != mode) { + return false; + } + jc->top -= 1; + return true; +} + + +#define parse_buffer_clear(jc) \ + do {\ + jc->parse_buffer_count = 0;\ + jc->parse_buffer[0] = 0;\ + } while (0) + +#define parse_buffer_pop_back_char(jc)\ + do {\ + assert(jc->parse_buffer_count >= 1);\ + --jc->parse_buffer_count;\ + jc->parse_buffer[jc->parse_buffer_count] = 0;\ + } while (0) + + + +void delete_JSON_parser(JSON_parser jc) +{ + if (jc) { + if (jc->stack != &jc->static_stack[0]) { + jc->free((void*)jc->stack); + } + if (jc->parse_buffer != &jc->static_parse_buffer[0]) { + jc->free((void*)jc->parse_buffer); + } + jc->free((void*)jc); + } +} + +int JSON_parser_reset(JSON_parser jc) +{ + if (NULL == jc) { + return false; + } + + jc->state = GO; + jc->top = -1; + + /* parser has been used previously? */ + if (NULL == jc->parse_buffer) { + + /* Do we want non-bound stack? */ + if (jc->depth > 0) { + jc->stack_capacity = jc->depth; + if (jc->depth <= (int)COUNTOF(jc->static_stack)) { + jc->stack = &jc->static_stack[0]; + } else { + const size_t bytes_to_alloc = jc->stack_capacity * sizeof(jc->stack[0]); + jc->stack = (signed char*)JSON_parser_malloc(jc->malloc, bytes_to_alloc, "stack"); + if (jc->stack == NULL) { + return false; + } + } + } else { + jc->stack_capacity = (int)COUNTOF(jc->static_stack); + jc->depth = -1; + jc->stack = &jc->static_stack[0]; + } + + /* set up the parse buffer */ + jc->parse_buffer = &jc->static_parse_buffer[0]; + jc->parse_buffer_capacity = COUNTOF(jc->static_parse_buffer); + } + + /* set parser to start */ + push(jc, MODE_DONE); + parse_buffer_clear(jc); + + return true; +} + +JSON_parser +new_JSON_parser(JSON_config const * config) +{ +/* + new_JSON_parser starts the checking process by constructing a JSON_parser + object. It takes a depth parameter that restricts the level of maximum + nesting. + + To continue the process, call JSON_parser_char for each character in the + JSON text, and then call JSON_parser_done to obtain the final result. + These functions are fully reentrant. +*/ + + int use_std_malloc = false; + JSON_config default_config; + JSON_parser jc; + JSON_malloc_t alloc; + + /* set to default configuration if none was provided */ + if (NULL == config) { + /* initialize configuration */ + init_JSON_config(&default_config); + config = &default_config; + } + + /* use std malloc if either the allocator or deallocator function isn't set */ + use_std_malloc = NULL == config->malloc || NULL == config->free; + + alloc = use_std_malloc ? malloc : config->malloc; + + jc = (JSON_parser)JSON_parser_malloc(alloc, sizeof(*jc), "parser"); + + if (NULL == jc) { + return NULL; + } + + /* configure the parser */ + memset(jc, 0, sizeof(*jc)); + jc->malloc = alloc; + jc->free = use_std_malloc ? free : config->free; + jc->callback = config->callback; + jc->ctx = config->callback_ctx; + jc->allow_comments = (signed char)(config->allow_comments != 0); + jc->handle_floats_manually = (signed char)(config->handle_floats_manually != 0); + jc->decimal_point = *localeconv()->decimal_point; + /* We need to be able to push at least one object */ + jc->depth = config->depth == 0 ? 1 : config->depth; + + /* reset the parser */ + if (!JSON_parser_reset(jc)) { + jc->free(jc); + return NULL; + } + + return jc; +} + +static int parse_buffer_grow(JSON_parser jc) +{ + const size_t bytes_to_copy = jc->parse_buffer_count * sizeof(jc->parse_buffer[0]); + const size_t new_capacity = jc->parse_buffer_capacity * 2; + const size_t bytes_to_allocate = new_capacity * sizeof(jc->parse_buffer[0]); + void* mem = JSON_parser_malloc(jc->malloc, bytes_to_allocate, "parse buffer"); + + if (mem == NULL) { + jc->error = JSON_E_OUT_OF_MEMORY; + return false; + } + + assert(new_capacity > 0); + memcpy(mem, jc->parse_buffer, bytes_to_copy); + + if (jc->parse_buffer != &jc->static_parse_buffer[0]) { + jc->free(jc->parse_buffer); + } + + jc->parse_buffer = (char*)mem; + jc->parse_buffer_capacity = new_capacity; + + return true; +} + +static int parse_buffer_reserve_for(JSON_parser jc, unsigned chars) +{ + while (jc->parse_buffer_count + chars + 1 > jc->parse_buffer_capacity) { + if (!parse_buffer_grow(jc)) { + assert(jc->error == JSON_E_OUT_OF_MEMORY); + return false; + } + } + + return true; +} + +#define parse_buffer_has_space_for(jc, count) \ + (jc->parse_buffer_count + (count) + 1 <= jc->parse_buffer_capacity) + +#define parse_buffer_push_back_char(jc, c)\ + do {\ + assert(parse_buffer_has_space_for(jc, 1)); \ + jc->parse_buffer[jc->parse_buffer_count++] = c;\ + jc->parse_buffer[jc->parse_buffer_count] = 0;\ + } while (0) + +#define assert_is_non_container_type(jc) \ + assert( \ + jc->type == JSON_T_NULL || \ + jc->type == JSON_T_FALSE || \ + jc->type == JSON_T_TRUE || \ + jc->type == JSON_T_FLOAT || \ + jc->type == JSON_T_INTEGER || \ + jc->type == JSON_T_STRING) + + +static int parse_parse_buffer(JSON_parser jc) +{ + if (jc->callback) { + JSON_value value, *arg = NULL; + + if (jc->type != JSON_T_NONE) { + assert_is_non_container_type(jc); + + switch(jc->type) { + case JSON_T_FLOAT: + arg = &value; + if (jc->handle_floats_manually) { + value.vu.str.value = jc->parse_buffer; + value.vu.str.length = jc->parse_buffer_count; + } else { + /* not checking with end pointer b/c there may be trailing ws */ + value.vu.float_value = strtod(jc->parse_buffer, NULL); + } + break; + case JSON_T_INTEGER: + arg = &value; + sscanf(jc->parse_buffer, JSON_PARSER_INTEGER_SSCANF_TOKEN, &value.vu.integer_value); + break; + case JSON_T_STRING: + arg = &value; + value.vu.str.value = jc->parse_buffer; + value.vu.str.length = jc->parse_buffer_count; + break; + } + + if (!(*jc->callback)(jc->ctx, jc->type, arg)) { + return false; + } + } + } + + parse_buffer_clear(jc); + + return true; +} + +#define IS_HIGH_SURROGATE(uc) (((uc) & 0xFC00) == 0xD800) +#define IS_LOW_SURROGATE(uc) (((uc) & 0xFC00) == 0xDC00) +#define DECODE_SURROGATE_PAIR(hi,lo) ((((hi) & 0x3FF) << 10) + ((lo) & 0x3FF) + 0x10000) +static const unsigned char utf8_lead_bits[4] = { 0x00, 0xC0, 0xE0, 0xF0 }; + +static int decode_unicode_char(JSON_parser jc) +{ + int i; + unsigned uc = 0; + char* p; + int trail_bytes; + + assert(jc->parse_buffer_count >= 6); + + p = &jc->parse_buffer[jc->parse_buffer_count - 4]; + + for (i = 12; i >= 0; i -= 4, ++p) { + unsigned x = *p; + + if (x >= 'a') { + x -= ('a' - 10); + } else if (x >= 'A') { + x -= ('A' - 10); + } else { + x &= ~0x30u; + } + + assert(x < 16); + + uc |= x << i; + } + + /* clear UTF-16 char from buffer */ + jc->parse_buffer_count -= 6; + jc->parse_buffer[jc->parse_buffer_count] = 0; + + if (uc == 0xffff || uc == 0xfffe) { + return false; + } + + /* attempt decoding ... */ + if (jc->utf16_high_surrogate) { + if (IS_LOW_SURROGATE(uc)) { + uc = DECODE_SURROGATE_PAIR(jc->utf16_high_surrogate, uc); + trail_bytes = 3; + jc->utf16_high_surrogate = 0; + } else { + /* high surrogate without a following low surrogate */ + return false; + } + } else { + if (uc < 0x80) { + trail_bytes = 0; + } else if (uc < 0x800) { + trail_bytes = 1; + } else if (IS_HIGH_SURROGATE(uc)) { + /* save the high surrogate and wait for the low surrogate */ + jc->utf16_high_surrogate = (UTF16)uc; + return true; + } else if (IS_LOW_SURROGATE(uc)) { + /* low surrogate without a preceding high surrogate */ + return false; + } else { + trail_bytes = 2; + } + } + + jc->parse_buffer[jc->parse_buffer_count++] = (char) ((uc >> (trail_bytes * 6)) | utf8_lead_bits[trail_bytes]); + + for (i = trail_bytes * 6 - 6; i >= 0; i -= 6) { + jc->parse_buffer[jc->parse_buffer_count++] = (char) (((uc >> i) & 0x3F) | 0x80); + } + + jc->parse_buffer[jc->parse_buffer_count] = 0; + + return true; +} + +static int add_escaped_char_to_parse_buffer(JSON_parser jc, int next_char) +{ + assert(parse_buffer_has_space_for(jc, 1)); + + jc->escaped = 0; + /* remove the backslash */ + parse_buffer_pop_back_char(jc); + switch(next_char) { + case 'b': + parse_buffer_push_back_char(jc, '\b'); + break; + case 'f': + parse_buffer_push_back_char(jc, '\f'); + break; + case 'n': + parse_buffer_push_back_char(jc, '\n'); + break; + case 'r': + parse_buffer_push_back_char(jc, '\r'); + break; + case 't': + parse_buffer_push_back_char(jc, '\t'); + break; + case '"': + parse_buffer_push_back_char(jc, '"'); + break; + case '\\': + parse_buffer_push_back_char(jc, '\\'); + break; + case '/': + parse_buffer_push_back_char(jc, '/'); + break; + case 'u': + parse_buffer_push_back_char(jc, '\\'); + parse_buffer_push_back_char(jc, 'u'); + break; + default: + return false; + } + + return true; +} + +static int add_char_to_parse_buffer(JSON_parser jc, int next_char, int next_class) +{ + if (!parse_buffer_reserve_for(jc, 1)) { + assert(JSON_E_OUT_OF_MEMORY == jc->error); + return false; + } + + if (jc->escaped) { + if (!add_escaped_char_to_parse_buffer(jc, next_char)) { + jc->error = JSON_E_INVALID_ESCAPE_SEQUENCE; + return false; + } + } else if (!jc->comment) { + if ((jc->type != JSON_T_NONE) | !((next_class == C_SPACE) | (next_class == C_WHITE)) /* non-white-space */) { + parse_buffer_push_back_char(jc, (char)next_char); + } + } + + return true; +} + +#define assert_type_isnt_string_null_or_bool(jc) \ + assert(jc->type != JSON_T_FALSE); \ + assert(jc->type != JSON_T_TRUE); \ + assert(jc->type != JSON_T_NULL); \ + assert(jc->type != JSON_T_STRING) + + +int +JSON_parser_char(JSON_parser jc, int next_char) +{ +/* + After calling new_JSON_parser, call this function for each character (or + partial character) in your JSON text. It can accept UTF-8, UTF-16, or + UTF-32. It returns true if things are looking ok so far. If it rejects the + text, it returns false. +*/ + int next_class, next_state; + +/* + Store the current char for error handling +*/ + jc->current_char = next_char; + +/* + Determine the character's class. +*/ + if (next_char < 0) { + jc->error = JSON_E_INVALID_CHAR; + return false; + } + if (next_char >= 128) { + next_class = C_ETC; + } else { + next_class = ascii_class[next_char]; + if (next_class <= XX) { + set_error(jc); + return false; + } + } + + if (!add_char_to_parse_buffer(jc, next_char, next_class)) { + return false; + } + +/* + Get the next state from the state transition table. +*/ + next_state = state_transition_table[jc->state][next_class]; + if (next_state >= 0) { +/* + Change the state. +*/ + jc->state = (signed char)next_state; + } else { +/* + Or perform one of the actions. +*/ + switch (next_state) { +/* Unicode character */ + case UC: + if(!decode_unicode_char(jc)) { + jc->error = JSON_E_INVALID_UNICODE_SEQUENCE; + return false; + } + /* check if we need to read a second UTF-16 char */ + if (jc->utf16_high_surrogate) { + jc->state = D1; + } else { + jc->state = ST; + } + break; +/* escaped char */ + case EX: + jc->escaped = 1; + jc->state = ESC; + break; +/* integer detected by minus */ + case MX: + jc->type = JSON_T_INTEGER; + jc->state = MI; + break; +/* integer detected by zero */ + case ZX: + jc->type = JSON_T_INTEGER; + jc->state = ZE; + break; +/* integer detected by 1-9 */ + case IX: + jc->type = JSON_T_INTEGER; + jc->state = IT; + break; + +/* floating point number detected by exponent*/ + case DE: + assert_type_isnt_string_null_or_bool(jc); + jc->type = JSON_T_FLOAT; + jc->state = E1; + break; + +/* floating point number detected by fraction */ + case DF: + assert_type_isnt_string_null_or_bool(jc); + if (!jc->handle_floats_manually) { +/* + Some versions of strtod (which underlies sscanf) don't support converting + C-locale formated floating point values. +*/ + assert(jc->parse_buffer[jc->parse_buffer_count-1] == '.'); + jc->parse_buffer[jc->parse_buffer_count-1] = jc->decimal_point; + } + jc->type = JSON_T_FLOAT; + jc->state = FX; + break; +/* string begin " */ + case SB: + parse_buffer_clear(jc); + assert(jc->type == JSON_T_NONE); + jc->type = JSON_T_STRING; + jc->state = ST; + break; + +/* n */ + case NU: + assert(jc->type == JSON_T_NONE); + jc->type = JSON_T_NULL; + jc->state = N1; + break; +/* f */ + case FA: + assert(jc->type == JSON_T_NONE); + jc->type = JSON_T_FALSE; + jc->state = F1; + break; +/* t */ + case TR: + assert(jc->type == JSON_T_NONE); + jc->type = JSON_T_TRUE; + jc->state = T1; + break; + +/* closing comment */ + case CE: + jc->comment = 0; + assert(jc->parse_buffer_count == 0); + assert(jc->type == JSON_T_NONE); + jc->state = jc->before_comment_state; + break; + +/* opening comment */ + case CB: + if (!jc->allow_comments) { + return false; + } + parse_buffer_pop_back_char(jc); + if (!parse_parse_buffer(jc)) { + return false; + } + assert(jc->parse_buffer_count == 0); + assert(jc->type != JSON_T_STRING); + switch (jc->stack[jc->top]) { + case MODE_ARRAY: + case MODE_OBJECT: + switch(jc->state) { + case VA: + case AR: + jc->before_comment_state = jc->state; + break; + default: + jc->before_comment_state = OK; + break; + } + break; + default: + jc->before_comment_state = jc->state; + break; + } + jc->type = JSON_T_NONE; + jc->state = C1; + jc->comment = 1; + break; +/* empty } */ + case -9: + parse_buffer_clear(jc); + if (jc->callback && !(*jc->callback)(jc->ctx, JSON_T_OBJECT_END, NULL)) { + return false; + } + if (!pop(jc, MODE_KEY)) { + return false; + } + jc->state = OK; + break; + +/* } */ case -8: + parse_buffer_pop_back_char(jc); + if (!parse_parse_buffer(jc)) { + return false; + } + if (jc->callback && !(*jc->callback)(jc->ctx, JSON_T_OBJECT_END, NULL)) { + return false; + } + if (!pop(jc, MODE_OBJECT)) { + jc->error = JSON_E_UNBALANCED_COLLECTION; + return false; + } + jc->type = JSON_T_NONE; + jc->state = OK; + break; + +/* ] */ case -7: + parse_buffer_pop_back_char(jc); + if (!parse_parse_buffer(jc)) { + return false; + } + if (jc->callback && !(*jc->callback)(jc->ctx, JSON_T_ARRAY_END, NULL)) { + return false; + } + if (!pop(jc, MODE_ARRAY)) { + jc->error = JSON_E_UNBALANCED_COLLECTION; + return false; + } + + jc->type = JSON_T_NONE; + jc->state = OK; + break; + +/* { */ case -6: + parse_buffer_pop_back_char(jc); + if (jc->callback && !(*jc->callback)(jc->ctx, JSON_T_OBJECT_BEGIN, NULL)) { + return false; + } + if (!push(jc, MODE_KEY)) { + return false; + } + assert(jc->type == JSON_T_NONE); + jc->state = OB; + break; + +/* [ */ case -5: + parse_buffer_pop_back_char(jc); + if (jc->callback && !(*jc->callback)(jc->ctx, JSON_T_ARRAY_BEGIN, NULL)) { + return false; + } + if (!push(jc, MODE_ARRAY)) { + return false; + } + assert(jc->type == JSON_T_NONE); + jc->state = AR; + break; + +/* string end " */ case -4: + parse_buffer_pop_back_char(jc); + switch (jc->stack[jc->top]) { + case MODE_KEY: + assert(jc->type == JSON_T_STRING); + jc->type = JSON_T_NONE; + jc->state = CO; + + if (jc->callback) { + JSON_value value; + value.vu.str.value = jc->parse_buffer; + value.vu.str.length = jc->parse_buffer_count; + if (!(*jc->callback)(jc->ctx, JSON_T_KEY, &value)) { + return false; + } + } + parse_buffer_clear(jc); + break; + case MODE_ARRAY: + case MODE_OBJECT: + assert(jc->type == JSON_T_STRING); + if (!parse_parse_buffer(jc)) { + return false; + } + jc->type = JSON_T_NONE; + jc->state = OK; + break; + default: + return false; + } + break; + +/* , */ case -3: + parse_buffer_pop_back_char(jc); + if (!parse_parse_buffer(jc)) { + return false; + } + switch (jc->stack[jc->top]) { + case MODE_OBJECT: +/* + A comma causes a flip from object mode to key mode. +*/ + if (!pop(jc, MODE_OBJECT) || !push(jc, MODE_KEY)) { + return false; + } + assert(jc->type != JSON_T_STRING); + jc->type = JSON_T_NONE; + jc->state = KE; + break; + case MODE_ARRAY: + assert(jc->type != JSON_T_STRING); + jc->type = JSON_T_NONE; + jc->state = VA; + break; + default: + return false; + } + break; + +/* : */ case -2: +/* + A colon causes a flip from key mode to object mode. +*/ + parse_buffer_pop_back_char(jc); + if (!pop(jc, MODE_KEY) || !push(jc, MODE_OBJECT)) { + return false; + } + assert(jc->type == JSON_T_NONE); + jc->state = VA; + break; +/* + Bad action. +*/ + default: + set_error(jc); + return false; + } + } + return true; +} + +int +JSON_parser_done(JSON_parser jc) +{ + if ((jc->state == OK || jc->state == GO) && pop(jc, MODE_DONE)) + { + return true; + } + + jc->error = JSON_E_UNBALANCED_COLLECTION; + return false; +} + + +int JSON_parser_is_legal_white_space_string(const char* s) +{ + int c, char_class; + + if (s == NULL) { + return false; + } + + for (; *s; ++s) { + c = *s; + + if (c < 0 || c >= 128) { + return false; + } + + char_class = ascii_class[c]; + + if (char_class != C_SPACE && char_class != C_WHITE) { + return false; + } + } + + return true; +} + +int JSON_parser_get_last_error(JSON_parser jc) +{ + return jc->error; +} + + +void init_JSON_config(JSON_config* config) +{ + if (config) { + memset(config, 0, sizeof(*config)); + + config->depth = JSON_PARSER_STACK_SIZE - 1; + config->malloc = malloc; + config->free = free; + } +} + +#undef XX +#undef COUNTOF +#undef parse_buffer_clear +#undef parse_buffer_pop_back_char +/* end file parser/JSON_parser.c */ +/* begin file ./cson.c */ +#include +#include /* malloc()/free() */ +#include +#include + +#ifdef _MSC_VER +# if _MSC_VER >= 1400 /* Visual Studio 2005 and up */ +# pragma warning( push ) +# pragma warning(disable:4996) /* unsecure sscanf (but snscanf() isn't in c89) */ +# pragma warning(disable:4244) /* complaining about data loss due + to integer precision in the + sqlite3 utf decoding routines */ +# endif +#endif + +#if 1 +#include +#define MARKER if(1) printf("MARKER: %s:%d:%s():\t",__FILE__,__LINE__,__func__); if(1) printf +#else +static void noop_printf(char const * fmt, ...) {} +#define MARKER if(0) printf +#endif + +#if defined(__cplusplus) +extern "C" { +#endif + + +/** + This type holds the "vtbl" for type-specific operations when + working with cson_value objects. + + All cson_values of a given logical type share a pointer to a single + library-internal instance of this class. +*/ +struct cson_value_api +{ + /** + The logical JavaScript/JSON type associated with + this object. + */ + const cson_type_id typeID; + /** + Must free any memory associated with self, + but not free self. If self is NULL then + this function must do nothing. + */ + void (*cleanup)( cson_value * self ); + /** + POSSIBLE TODOs: + + // Deep copy. + int (*clone)( cson_value const * self, cson_value ** tgt ); + + // Using JS semantics for true/value + char (*bool_value)( cson_value const * self ); + + // memcmp() return value semantics + int (*compare)( cson_value const * self, cson_value const * other ); + */ +}; + +typedef struct cson_value_api cson_value_api; + +/** + Empty-initialized cson_value_api object. +*/ +#define cson_value_api_empty_m { \ + CSON_TYPE_UNDEF/*typeID*/, \ + NULL/*cleanup*/\ + } +/** + Empty-initialized cson_value_api object. +*/ +/*static const cson_value_api cson_value_api_empty = cson_value_api_empty_m;*/ + + +typedef unsigned int cson_counter_t; +struct cson_value +{ + /** The "vtbl" of type-specific operations. All instances + of a given logical value type share a single api instance. + + Results are undefined if this value is NULL. + */ + cson_value_api const * api; + + /** The raw value. Its interpretation depends on the value of the + api member. Some value types require dynamically-allocated + memory, so one must always call cson_value_free() to destroy a + value when it is no longer needed. For stack-allocated values + (which client could SHOULD NOT USE unless they are intimately + familiar with the memory management rules and don't mind an + occasional leak or crash), use cson_value_clean() instead of + cson_value_free(). + */ + void * value; + + /** + We use this to allow us to store cson_value instances in + multiple containers or multiple times within a single container + (provided no cycles are introduced). + + Notes about the rc implementation: + + - The refcount is for the cson_value instance itself, not its + value pointer. + + - Instances start out with a refcount of 0 (not 1). Adding them + to a container will increase the refcount. Cleaning up the container + will decrement the count. + + - cson_value_free() decrements the refcount (if it is not already + 0) and cleans/frees the value only when the refcount is 0. + + - Some places in the internals add an "extra" reference to + objects to avoid a premature deletion. Don't try this at home. + */ + cson_counter_t refcount; +}; + + +/** + Empty-initialized cson_value object. +*/ +const cson_parse_opt cson_parse_opt_empty = cson_parse_opt_empty_m; +const cson_output_opt cson_output_opt_empty = cson_output_opt_empty_m; +const cson_object_iterator cson_object_iterator_empty = cson_object_iterator_empty_m; +const cson_buffer cson_buffer_empty = cson_buffer_empty_m; +const cson_parse_info cson_parse_info_empty = cson_parse_info_empty_m; + +static void cson_value_destroy_zero_it( cson_value * self ); +static void cson_value_destroy_object( cson_value * self ); +/** + If self is-a array then this function destroys its contents, + else this function does nothing. +*/ +static void cson_value_destroy_array( cson_value * self ); + +static const cson_value_api cson_value_api_null = { CSON_TYPE_NULL, cson_value_destroy_zero_it }; +static const cson_value_api cson_value_api_undef = { CSON_TYPE_UNDEF, cson_value_destroy_zero_it }; +static const cson_value_api cson_value_api_bool = { CSON_TYPE_BOOL, cson_value_destroy_zero_it }; +static const cson_value_api cson_value_api_integer = { CSON_TYPE_INTEGER, cson_value_destroy_zero_it }; +static const cson_value_api cson_value_api_double = { CSON_TYPE_DOUBLE, cson_value_destroy_zero_it }; +static const cson_value_api cson_value_api_string = { CSON_TYPE_STRING, cson_value_destroy_zero_it }; +static const cson_value_api cson_value_api_array = { CSON_TYPE_ARRAY, cson_value_destroy_array }; +static const cson_value_api cson_value_api_object = { CSON_TYPE_OBJECT, cson_value_destroy_object }; + +static const cson_value cson_value_undef = { &cson_value_api_undef, NULL, 0 }; +static const cson_value cson_value_integer_empty = { &cson_value_api_integer, NULL, 0 }; +static const cson_value cson_value_double_empty = { &cson_value_api_double, NULL, 0 }; +static const cson_value cson_value_string_empty = { &cson_value_api_string, NULL, 0 }; +static const cson_value cson_value_array_empty = { &cson_value_api_array, NULL, 0 }; +static const cson_value cson_value_object_empty = { &cson_value_api_object, NULL, 0 }; + +/** + Strings are allocated as an instances of this class with N+1 + trailing bytes, where N is the length of the string being + allocated. To convert a cson_string to c-string we simply increment + the cson_string pointer. To do the opposite we use (cstr - + sizeof(cson_string)). Zero-length strings are a special case + handled by a couple of the cson_string functions. +*/ +struct cson_string +{ + unsigned int length; +}; +#define cson_string_empty_m {0/*length*/} +static const cson_string cson_string_empty = cson_string_empty_m; + + +/** + Assumes V is a (cson_value*) ans V->value is a (T*). Returns + V->value cast to a (T*). +*/ +#define CSON_CAST(T,V) ((T*)((V)->value)) +/** + Assumes V is a pointer to memory which is allocated as part of a + cson_value instance (the bytes immediately after that part). + Returns a pointer a a cson_value by subtracting sizeof(cson_value) + from that address and casting it to a (cson_value*) +*/ +#define CSON_VCAST(V) ((cson_value *)(((unsigned char *)(V))-sizeof(cson_value))) + +/** + CSON_INT(V) assumes that V is a (cson_value*) of type + CSON_TYPE_INTEGER. This macro returns a (cson_int_t*) representing + its value (how that is stored depends on whether we are running in + 32- or 64-bit mode). + */ +#if CSON_VOID_PTR_IS_BIG +# define CSON_INT(V) ((cson_int_t*)(&((V)->value))) +#else +# define CSON_INT(V) ((cson_int_t*)(V)->value) +#endif + +#define CSON_DBL(V) CSON_CAST(cson_double_t,(V)) +#define CSON_STR(V) CSON_CAST(cson_string,(V)) +#define CSON_OBJ(V) CSON_CAST(cson_object,(V)) +#define CSON_ARRAY(V) CSON_CAST(cson_array,(V)) + +/** + Holds special shared "constant" (though they are non-const) + values. +*/ +static struct CSON_EMPTY_HOLDER_ +{ + char trueValue; + cson_string stringValue; +} CSON_EMPTY_HOLDER = { + 1/*trueValue*/, + cson_string_empty_m +}; + +/** + Indexes into the CSON_SPECIAL_VALUES array. + + If this enum changes in any way, + makes damned sure that CSON_SPECIAL_VALUES is updated + to match!!! +*/ +enum CSON_INTERNAL_VALUES { + + CSON_VAL_UNDEF = 0, + CSON_VAL_NULL = 1, + CSON_VAL_TRUE = 2, + CSON_VAL_FALSE = 3, + CSON_VAL_INT_0 = 4, + CSON_VAL_DBL_0 = 5, + CSON_VAL_STR_EMPTY = 6, + CSON_INTERNAL_VALUES_LENGTH +}; + +/** + Some "special" shared cson_value instances. + + These values MUST be initialized in the order specified + by the CSON_INTERNAL_VALUES enum. + + Note that they are not const because they are used as + shared-allocation objects in non-const contexts. However, the + public API provides no way to modifying them, and clients who + modify values directly are subject to The Wrath of Undefined + Behaviour. +*/ +static cson_value CSON_SPECIAL_VALUES[] = { +{ &cson_value_api_undef, NULL, 0 }, /* UNDEF */ +{ &cson_value_api_null, NULL, 0 }, /* NULL */ +{ &cson_value_api_bool, &CSON_EMPTY_HOLDER.trueValue, 0 }, /* TRUE */ +{ &cson_value_api_bool, NULL, 0 }, /* FALSE */ +{ &cson_value_api_integer, NULL, 0 }, /* INT_0 */ +{ &cson_value_api_double, NULL, 0 }, /* DBL_0 */ +{ &cson_value_api_string, &CSON_EMPTY_HOLDER.stringValue, 0 }, /* STR_EMPTY */ +{ NULL, NULL, 0 } +}; + + +/** + Returns non-0 (true) if m is one of our special + "built-in" values, e.g. from CSON_SPECIAL_VALUES and some + "empty" values. + + If this returns true, m MUST NOT be free()d! + */ +static char cson_value_is_builtin( void const * m ) +{ + if((m >= (void const *)&CSON_EMPTY_HOLDER) + && ( m < (void const *)(&CSON_EMPTY_HOLDER+1))) + return 1; + else return + ((m >= (void const *)&CSON_SPECIAL_VALUES[0]) + && ( m < (void const *)&CSON_SPECIAL_VALUES[CSON_INTERNAL_VALUES_LENGTH]) ) + ? 1 + : 0; +} + +char const * cson_rc_string(int rc) +{ + switch(rc){ +#define CHECK(N) case CSON_RC_##N: return #N; + CHECK(OK); + CHECK(ArgError); + CHECK(RangeError); + CHECK(TypeError); + CHECK(IOError); + CHECK(AllocError); + CHECK(NYIError); + CHECK(InternalError); + CHECK(UnsupportedError); + CHECK(NotFoundError); + CHECK(UnknownError); + CHECK(Parse_INVALID_CHAR); + CHECK(Parse_INVALID_KEYWORD); + CHECK(Parse_INVALID_ESCAPE_SEQUENCE); + CHECK(Parse_INVALID_UNICODE_SEQUENCE); + CHECK(Parse_INVALID_NUMBER); + CHECK(Parse_NESTING_DEPTH_REACHED); + CHECK(Parse_UNBALANCED_COLLECTION); + CHECK(Parse_EXPECTED_KEY); + CHECK(Parse_EXPECTED_COLON); + default: return "UnknownError"; + } +#undef CHECK +} + +/** + If CSON_LOG_ALLOC is true then the cson_malloc/realloc/free() routines + will log a message to stderr. +*/ +#define CSON_LOG_ALLOC 0 + + +/** + CSON_FOSSIL_MODE is only for use in the Fossil + source tree, so that we can plug in to its allocators. + We can't do this by, e.g., defining macros for the + malloc/free funcs because fossil's lack of header files + means we would have to #include "main.c" here to + get the declarations. + */ +#if defined(CSON_FOSSIL_MODE) +extern void *fossil_malloc(size_t n); +extern void fossil_free(void *p); +extern void *fossil_realloc(void *p, size_t n); +# define CSON_MALLOC_IMPL fossil_malloc +# define CSON_FREE_IMPL fossil_free +# define CSON_REALLOC_IMPL fossil_realloc +#endif + +#if !defined CSON_MALLOC_IMPL +# define CSON_MALLOC_IMPL malloc +#endif +#if !defined CSON_FREE_IMPL +# define CSON_FREE_IMPL free +#endif +#if !defined CSON_REALLOC_IMPL +# define CSON_REALLOC_IMPL realloc +#endif + +/** + A test/debug macro for simulating an OOM after the given number of + bytes have been allocated. +*/ +#define CSON_SIMULATE_OOM 0 +#if CSON_SIMULATE_OOM +static unsigned int cson_totalAlloced = 0; +#endif + +/** Simple proxy for malloc(). descr is a description of the allocation. */ +static void * cson_malloc( size_t n, char const * descr ) +{ +#if CSON_LOG_ALLOC + fprintf(stderr, "Allocating %u bytes [%s].\n", (unsigned int)n, descr); +#endif +#if CSON_SIMULATE_OOM + cson_totalAlloced += n; + if( cson_totalAlloced > CSON_SIMULATE_OOM ) + { + return NULL; + } +#endif + return CSON_MALLOC_IMPL(n); +} + +/** Simple proxy for free(). descr is a description of the memory being freed. */ +static void cson_free( void * p, char const * descr ) +{ +#if CSON_LOG_ALLOC + fprintf(stderr, "Freeing @%p [%s].\n", p, descr); +#endif + if( !cson_value_is_builtin(p) ) + { + CSON_FREE_IMPL( p ); + } +} +/** Simple proxy for realloc(). descr is a description of the (re)allocation. */ +static void * cson_realloc( void * hint, size_t n, char const * descr ) +{ +#if CSON_LOG_ALLOC + fprintf(stderr, "%sllocating %u bytes [%s].\n", + hint ? "Rea" : "A", + (unsigned int)n, descr); +#endif +#if CSON_SIMULATE_OOM + cson_totalAlloced += n; + if( cson_totalAlloced > CSON_SIMULATE_OOM ) + { + return NULL; + } +#endif + if( 0==n ) + { + cson_free(hint, descr); + return NULL; + } + else + { + return CSON_REALLOC_IMPL( hint, n ); + } +} + + +#undef CSON_LOG_ALLOC +#undef CSON_SIMULATE_OOM + + + +/** + CLIENTS CODE SHOULD NEVER USE THIS because it opens up doors to + memory leaks if it is not used in very controlled circumstances. + Users must be very aware of how the underlying memory management + works. + + Frees any resources owned by val, but does not free val itself + (which may be stack-allocated). If !val or val->api or + val->api->cleanup are NULL then this is a no-op. + + If v is a container type (object or array) its children are also + cleaned up, recursively. + + After calling this, val will have the special "undefined" type. +*/ +static void cson_value_clean( cson_value * val ); + +/** + Increments cv's reference count by 1. As a special case, values + for which cson_value_is_builtin() returns true are not + modified. assert()s if (NULL==cv). +*/ +static void cson_refcount_incr( cson_value * cv ) +{ + assert( NULL != cv ); + if( cson_value_is_builtin( cv ) ) + { /* do nothing: we do not want to modify the shared + instances. + */ + return; + } + else + { + ++cv->refcount; + } +} + +#if 0 +int cson_value_refcount_set( cson_value * cv, unsigned short rc ) +{ + if( NULL == cv ) return CSON_RC_ArgError; + else + { + cv->refcount = rc; + return 0; + } +} +#endif + +int cson_value_add_reference( cson_value * cv ) +{ + if( NULL == cv ) return CSON_RC_ArgError; + else if( (cv->refcount+1) < cv->refcount ) + { + return CSON_RC_RangeError; + } + else + { + cson_refcount_incr( cv ); + return 0; + } +} + +/** + If cv is NULL or cson_value_is_builtin(cv) returns true then this + function does nothing and returns 0, otherwise... If + cv->refcount is 0 or 1 then cson_value_clean(cv) is called, cv is + freed, and 0 is returned. If cv->refcount is any other value then + it is decremented and the new value is returned. +*/ +static cson_counter_t cson_refcount_decr( cson_value * cv ) +{ + if( (NULL == cv) || cson_value_is_builtin(cv) ) return 0; + else if( (0 == cv->refcount) || (0 == --cv->refcount) ) + { + cson_value_clean(cv); + cson_free(cv,"cson_value::refcount=0"); + return 0; + } + else return cv->refcount; +} + +unsigned int cson_string_length_bytes( cson_string const * str ) +{ + return str ? str->length : 0; +} + + +/** + Fetches v's string value as a non-const string. + + cson_strings are intended to be immutable, but this form provides + access to the immutable bits, which are v->length bytes long. A + length-0 string is returned as NULL from here, as opposed to + "". (This is a side-effect of the string allocation mechanism.) + Returns NULL if !v or if v is the internal empty-string singleton. +*/ +static char * cson_string_str(cson_string *v) +{ + /* + See http://groups.google.com/group/comp.lang.c.moderated/browse_thread/thread/2e0c0df5e8a0cd6a + */ +#if 1 + if( !v || (&CSON_EMPTY_HOLDER.stringValue == v) ) return NULL; + else return (char *)((unsigned char *)( v+1 )); +#else + static char empty[2] = {0,0}; + return ( NULL == v ) + ? NULL + : (v->length + ? (char *) (((unsigned char *)v) + sizeof(cson_string)) + : empty) + ; +#endif +} + +/** + Fetches v's string value as a const string. +*/ +char const * cson_string_cstr(cson_string const *v) +{ + /* + See http://groups.google.com/group/comp.lang.c.moderated/browse_thread/thread/2e0c0df5e8a0cd6a + */ +#if 1 + if( ! v ) return NULL; + else if( v == &CSON_EMPTY_HOLDER.stringValue ) return ""; + else { + assert((0 < v->length) && "How do we have a non-singleton empty string?"); + return (char const *)((unsigned char const *)(v+1)); + } +#else + return (NULL == v) + ? NULL + : (v->length + ? (char const *) ((unsigned char const *)(v+1)) + : ""); +#endif +} + + +#if 0 +/** + Just like strndup(3), in that neither are C89/C99-standard and both + are documented in detail in strndup(3). +*/ +static char * cson_strdup( char const * src, size_t n ) +{ + char * rc = (char *)cson_malloc(n+1, "cson_strdup"); + if( ! rc ) return NULL; + memset( rc, 0, n+1 ); + rc[n] = 0; + return strncpy( rc, src, n ); +} +#endif + +int cson_string_cmp_cstr_n( cson_string const * str, char const * other, unsigned int otherLen ) +{ + if( ! other && !str ) return 0; + else if( other && !str ) return 1; + else if( str && !other ) return -1; + else if( !otherLen ) return str->length ? 1 : 0; + else if( !str->length ) return otherLen ? -1 : 0; + else + { + unsigned const int max = (otherLen > str->length) ? otherLen : str->length; + int const rc = strncmp( cson_string_cstr(str), other, max ); + return ( (0 == rc) && (otherLen != str->length) ) + ? (str->length < otherLen) ? -1 : 1 + : rc; + } +} + +int cson_string_cmp_cstr( cson_string const * lhs, char const * rhs ) +{ + return cson_string_cmp_cstr_n( lhs, rhs, (rhs&&*rhs) ? strlen(rhs) : 0 ); +} +int cson_string_cmp( cson_string const * lhs, cson_string const * rhs ) +{ + return cson_string_cmp_cstr_n( lhs, cson_string_cstr(rhs), rhs ? rhs->length : 0 ); +} + + +/** + If self is not NULL, *self is overwritten to have the undefined + type. self is not cleaned up or freed. +*/ +void cson_value_destroy_zero_it( cson_value * self ) +{ + if( self ) + { + *self = cson_value_undef; + } +} + +/** + A key/value pair collection. + + Each of these objects owns its key/value pointers, and they + are cleaned up by cson_kvp_clean(). +*/ +struct cson_kvp +{ + cson_value * key; + cson_value * value; +}; +#define cson_kvp_empty_m {NULL,NULL} +static const cson_kvp cson_kvp_empty = cson_kvp_empty_m; + +/** @def CSON_OBJECT_PROPS_SORT + + Don't use this - it has not been updated to account for internal + changes in cson_object. + + If CSON_OBJECT_PROPS_SORT is set to a true value then + qsort() and bsearch() are used to sort (upon insertion) + and search cson_object::kvp property lists. This costs us + a re-sort on each insertion but searching is O(log n) + average/worst case (and O(1) best-case). + + i'm not yet convinced that the overhead of the qsort() justifies + the potentially decreased search times - it has not been + measured. Object property lists tend to be relatively short in + JSON, and a linear search which uses the cson_string::length + property as a quick check is quite fast when one compares it with + the sort overhead required by the bsearch() approach. +*/ +#define CSON_OBJECT_PROPS_SORT 0 + +/** @def CSON_OBJECT_PROPS_SORT_USE_LENGTH + + Don't use this - i'm not sure that it works how i'd like. + + If CSON_OBJECT_PROPS_SORT_USE_LENGTH is true then + we use string lengths as quick checks when sorting + property keys. This leads to a non-intuitive sorting + order but "should" be faster. + + This is ignored if CSON_OBJECT_PROPS_SORT is false. + +*/ +#define CSON_OBJECT_PROPS_SORT_USE_LENGTH 0 + +#if CSON_OBJECT_PROPS_SORT + +/** + cson_kvp comparator for use with qsort(). ALMOST compares with + strcmp() semantics, but it uses the strings' lengths as a quicker + approach. This might give non-intuitive results, but it's faster. + */ +static int cson_kvp_cmp( void const * lhs, void const * rhs ) +{ + cson_kvp const * lk = *((cson_kvp const * const*)lhs); + cson_kvp const * rk = *((cson_kvp const * const*)rhs); + cson_string const * l = cson_string_value(lk->key); + cson_string const * r = cson_string_value(rk->key); +#if CSON_OBJECT_PROPS_SORT_USE_LENGTH + if( l->length < r->length ) return -1; + else if( l->length > r->length ) return 1; + else return strcmp( cson_string_cstr( l ), cson_string_cstr( r ) ); +#else + return strcmp( cson_string_cstr( l ), + cson_string_cstr( r ) ); +#endif /*CSON_OBJECT_PROPS_SORT_USE_LENGTH*/ +} +#endif /*CSON_OBJECT_PROPS_SORT*/ + + +#if CSON_OBJECT_PROPS_SORT +#error "Need to rework this for cson_string-to-cson_value refactoring" +/** + A bsearch() comparison function which requires that lhs be a (char + const *) and rhs be-a (cson_kvp const * const *). It compares lhs + to rhs->key's value, using strcmp() semantics. + */ +static int cson_kvp_cmp_vs_cstr( void const * lhs, void const * rhs ) +{ + char const * lk = (char const *)lhs; + cson_kvp const * rk = + *((cson_kvp const * const*)rhs) + ; +#if CSON_OBJECT_PROPS_SORT_USE_LENGTH + unsigned int llen = strlen(lk); + if( llen < rk->key->length ) return -1; + else if( llen > rk->key->length ) return 1; + else return strcmp( lk, cson_string_cstr( rk->key ) ); +#else + return strcmp( lk, cson_string_cstr( rk->key ) ); +#endif /*CSON_OBJECT_PROPS_SORT_USE_LENGTH*/ +} +#endif /*CSON_OBJECT_PROPS_SORT*/ + + +struct cson_kvp_list +{ + cson_kvp ** list; + unsigned int count; + unsigned int alloced; +}; +typedef struct cson_kvp_list cson_kvp_list; +#define cson_kvp_list_empty_m {NULL/*list*/,0/*count*/,0/*alloced*/} +/*static const cson_kvp_list cson_kvp_list_empty = cson_kvp_list_empty_m;*/ + +struct cson_object +{ + cson_kvp_list kvp; +}; +/*typedef struct cson_object cson_object;*/ +#define cson_object_empty_m { cson_kvp_list_empty_m/*kvp*/ } +static const cson_object cson_object_empty = cson_object_empty_m; + +struct cson_value_list +{ + cson_value ** list; + unsigned int count; + unsigned int alloced; +}; +typedef struct cson_value_list cson_value_list; +#define cson_value_list_empty_m {NULL/*list*/,0/*count*/,0/*alloced*/} +static const cson_value_list cson_value_list_empty = cson_value_list_empty_m; + +struct cson_array +{ + cson_value_list list; +}; +/*typedef struct cson_array cson_array;*/ +#define cson_array_empty_m { cson_value_list_empty_m/*list*/ } +static const cson_array cson_array_empty = cson_array_empty_m; + + +struct cson_parser +{ + JSON_parser p; + cson_value * root; + cson_value * node; + cson_array stack; + cson_string * ckey; + int errNo; + unsigned int totalKeyCount; + unsigned int totalValueCount; +}; +typedef struct cson_parser cson_parser; +static const cson_parser cson_parser_empty = { +NULL/*p*/, +NULL/*root*/, +NULL/*node*/, +cson_array_empty_m/*stack*/, +NULL/*ckey*/, +0/*errNo*/, +0/*totalKeyCount*/, +0/*totalValueCount*/ +}; + +#if 1 +/* The following funcs are declared in generated code (cson_lists.h), + but we need early access to their decls for the Amalgamation build. +*/ +static unsigned int cson_value_list_reserve( cson_value_list * self, unsigned int n ); +static unsigned int cson_kvp_list_reserve( cson_kvp_list * self, unsigned int n ); +static int cson_kvp_list_append( cson_kvp_list * self, cson_kvp * cp ); +static void cson_kvp_list_clean( cson_kvp_list * self, + void (*cleaner)(cson_kvp * obj) ); +#if 0 +static int cson_value_list_append( cson_value_list * self, cson_value * cp ); +static void cson_value_list_clean( cson_value_list * self, void (*cleaner)(cson_value * obj)); +static int cson_kvp_list_visit( cson_kvp_list * self, + int (*visitor)(cson_kvp * obj, void * visitorState ), + void * visitorState ); +static int cson_value_list_visit( cson_value_list * self, + int (*visitor)(cson_value * obj, void * visitorState ), + void * visitorState ); +#endif +#endif + +#if 0 +# define LIST_T cson_value_list +# define VALUE_T cson_value * +# define VALUE_T_IS_PTR 1 +# define LIST_T cson_kvp_list +# define VALUE_T cson_kvp * +# define VALUE_T_IS_PTR 1 +#else +#endif + +/** + Allocates a new value of the specified type. Ownership is + transfered to the caller, who must eventually free it by passing it + to cson_value_free() or transfering ownership to a container. + + extra is only valid for type CSON_TYPE_STRING, and must be the length + of the string to allocate + 1 byte (for the NUL). + + The returned value->api member will be set appropriately and + val->value will be set to point to the memory allocated to hold the + native value type. Use the internal CSON_CAST() family of macros to + convert the cson_values to their corresponding native + representation. + + Returns NULL on allocation error. + + @see cson_value_new_array() + @see cson_value_new_object() + @see cson_value_new_string() + @see cson_value_new_integer() + @see cson_value_new_double() + @see cson_value_new_bool() + @see cson_value_free() +*/ +static cson_value * cson_value_new(cson_type_id t, size_t extra) +{ + static const size_t vsz = sizeof(cson_value); + const size_t sz = vsz + extra; + size_t tx = 0; + cson_value def = cson_value_undef; + cson_value * v = NULL; + char const * reason = "cson_value_new"; + switch(t) + { + case CSON_TYPE_ARRAY: + assert( 0 == extra ); + def = cson_value_array_empty; + tx = sizeof(cson_array); + reason = "cson_value:array"; + break; + case CSON_TYPE_DOUBLE: + assert( 0 == extra ); + def = cson_value_double_empty; + tx = sizeof(cson_double_t); + reason = "cson_value:double"; + break; + case CSON_TYPE_INTEGER: + assert( 0 == extra ); + def = cson_value_integer_empty; +#if !CSON_VOID_PTR_IS_BIG + tx = sizeof(cson_int_t); +#endif + reason = "cson_value:int"; + break; + case CSON_TYPE_STRING: + assert( 0 != extra ); + def = cson_value_string_empty; + tx = sizeof(cson_string); + reason = "cson_value:string"; + break; + case CSON_TYPE_OBJECT: + assert( 0 == extra ); + def = cson_value_object_empty; + tx = sizeof(cson_object); + reason = "cson_value:object"; + break; + default: + assert(0 && "Unhandled type in cson_value_new()!"); + return NULL; + } + assert( def.api->typeID != CSON_TYPE_UNDEF ); + v = (cson_value *)cson_malloc(sz+tx, reason); + if( v ) { + *v = def; + if(tx || extra){ + memset(v+1, 0, tx + extra); + v->value = (void *)(v+1); + } + } + return v; +} + +void cson_value_free(cson_value *v) +{ + cson_refcount_decr( v ); +} + +#if 0 /* we might actually want this later on. */ +/** Returns true if v is not NULL and has the given type ID. */ +static char cson_value_is_a( cson_value const * v, cson_type_id is ) +{ + return (v && v->api && (v->api->typeID == is)) ? 1 : 0; +} +#endif + +cson_type_id cson_value_type_id( cson_value const * v ) +{ + return (v && v->api) ? v->api->typeID : CSON_TYPE_UNDEF; +} + +char cson_value_is_undef( cson_value const * v ) +{ + return ( !v || !v->api || (v->api==&cson_value_api_undef)) + ? 1 : 0; +} +#define ISA(T,TID) char cson_value_is_##T( cson_value const * v ) { \ + /*return (v && v->api) ? cson_value_is_a(v,CSON_TYPE_##TID) : 0;*/ \ + return (v && (v->api == &cson_value_api_##T)) ? 1 : 0; \ + } extern char bogusPlaceHolderForEmacsIndention##TID +ISA(null,NULL); +ISA(bool,BOOL); +ISA(integer,INTEGER); +ISA(double,DOUBLE); +ISA(string,STRING); +ISA(array,ARRAY); +ISA(object,OBJECT); +#undef ISA +char cson_value_is_number( cson_value const * v ) +{ + return cson_value_is_integer(v) || cson_value_is_double(v); +} + + +void cson_value_clean( cson_value * val ) +{ + if( val && val->api && val->api->cleanup ) + { + if( ! cson_value_is_builtin( val ) ) + { + cson_counter_t const rc = val->refcount; + val->api->cleanup(val); + *val = cson_value_undef; + val->refcount = rc; + } + } +} + +static cson_value * cson_value_array_alloc(void) +{ + cson_value * v = cson_value_new(CSON_TYPE_ARRAY,0); + if( NULL != v ) + { + cson_array * ar = CSON_ARRAY(v); + assert(NULL != ar); + *ar = cson_array_empty; + } + return v; +} + +static cson_value * cson_value_object_alloc(void) +{ + cson_value * v = cson_value_new(CSON_TYPE_OBJECT,0); + if( NULL != v ) + { + cson_object * obj = CSON_OBJ(v); + assert(NULL != obj); + *obj = cson_object_empty; + } + return v; +} + +cson_value * cson_value_new_object(void) +{ + return cson_value_object_alloc(); +} + +cson_object * cson_new_object(void) +{ + + return cson_value_get_object( cson_value_new_object() ); +} + +cson_value * cson_value_new_array(void) +{ + return cson_value_array_alloc(); +} + + +cson_array * cson_new_array(void) +{ + return cson_value_get_array( cson_value_new_array() ); +} + +/** + Frees kvp->key and kvp->value and sets them to NULL, but does not free + kvp. If !kvp then this is a no-op. +*/ +static void cson_kvp_clean( cson_kvp * kvp ) +{ + if( kvp ) + { + if(kvp->key) + { + cson_value_free(kvp->key); + kvp->key = NULL; + } + if(kvp->value) + { + cson_value_free( kvp->value ); + kvp->value = NULL; + } + } +} + +cson_string * cson_kvp_key( cson_kvp const * kvp ) +{ + return kvp ? cson_value_get_string(kvp->key) : NULL; +} +cson_value * cson_kvp_value( cson_kvp const * kvp ) +{ + return kvp ? kvp->value : NULL; +} + + +/** + Calls cson_kvp_clean(kvp) and then frees kvp. +*/ +static void cson_kvp_free( cson_kvp * kvp ) +{ + if( kvp ) + { + cson_kvp_clean(kvp); + cson_free(kvp,"cson_kvp"); + } +} + + +/** + cson_value_api::destroy_value() impl for Object + values. Cleans up self-owned memory and overwrites + self to have the undefined value, but does not + free self. +*/ +static void cson_value_destroy_object( cson_value * self ) +{ + if(self && self->value) { + cson_object * obj = (cson_object *)self->value; + assert( self->value == obj ); + cson_kvp_list_clean( &obj->kvp, cson_kvp_free ); + *self = cson_value_undef; + } +} + +/** + Cleans up the contents of ar->list, but does not free ar. + + After calling this, ar will have a length of 0. + + If properlyCleanValues is 1 then cson_value_free() is called on + each non-NULL item, otherwise the outer list is destroyed but the + individual items are assumed to be owned by someone else and are + not freed. +*/ +static void cson_array_clean( cson_array * ar, char properlyCleanValues ) +{ + if( ar ) + { + unsigned int i = 0; + cson_value * val = NULL; + for( ; i < ar->list.count; ++i ) + { + val = ar->list.list[i]; + if(val) + { + ar->list.list[i] = NULL; + if( properlyCleanValues ) + { + cson_value_free( val ); + } + } + } + cson_value_list_reserve(&ar->list,0); + ar->list = cson_value_list_empty + /* Pedantic note: reserve(0) already clears the list-specific + fields, but we do this just in case we ever add new fields + to cson_value_list which are not used in the reserve() impl. + */ + ; + } +} + +/** + cson_value_api::destroy_value() impl for Array + values. Cleans up self-owned memory and overwrites + self to have the undefined value, but does not + free self. +*/ +static void cson_value_destroy_array( cson_value * self ) +{ + cson_array * ar = cson_value_get_array(self); + if(ar) { + assert( self->value == ar ); + cson_array_clean( ar, 1 ); + *self = cson_value_undef; + } +} + +int cson_buffer_fill_from( cson_buffer * dest, cson_data_source_f src, void * state ) +{ + int rc; + enum { BufSize = 1024 * 4 }; + char rbuf[BufSize]; + size_t total = 0; + unsigned int rlen = 0; + if( ! dest || ! src ) return CSON_RC_ArgError; + dest->used = 0; + while(1) + { + rlen = BufSize; + rc = src( state, rbuf, &rlen ); + if( rc ) break; + total += rlen; + if( dest->capacity < (total+1) ) + { + rc = cson_buffer_reserve( dest, total + 1); + if( 0 != rc ) break; + } + memcpy( dest->mem + dest->used, rbuf, rlen ); + dest->used += rlen; + if( rlen < BufSize ) break; + } + if( !rc && dest->used ) + { + assert( dest->used < dest->capacity ); + dest->mem[dest->used] = 0; + } + return rc; +} + +int cson_data_source_FILE( void * state, void * dest, unsigned int * n ) +{ + FILE * f = (FILE*) state; + if( ! state || ! n || !dest ) return CSON_RC_ArgError; + else if( !*n ) return CSON_RC_RangeError; + *n = (unsigned int)fread( dest, 1, *n, f ); + if( !*n ) + { + return feof(f) ? 0 : CSON_RC_IOError; + } + return 0; +} + +int cson_parse_FILE( cson_value ** tgt, FILE * src, + cson_parse_opt const * opt, cson_parse_info * err ) +{ + return cson_parse( tgt, cson_data_source_FILE, src, opt, err ); +} + + +int cson_value_fetch_bool( cson_value const * val, char * v ) +{ + /** + FIXME: move the to-bool operation into cson_value_api, like we + do in the C++ API. + */ + if( ! val || !val->api ) return CSON_RC_ArgError; + else + { + int rc = 0; + char b = 0; + switch( val->api->typeID ) + { + case CSON_TYPE_ARRAY: + case CSON_TYPE_OBJECT: + b = 1; + break; + case CSON_TYPE_STRING: { + char const * str = cson_string_cstr(cson_value_get_string(val)); + b = (str && *str) ? 1 : 0; + break; + } + case CSON_TYPE_UNDEF: + case CSON_TYPE_NULL: + break; + case CSON_TYPE_BOOL: + b = (NULL==val->value) ? 0 : 1; + break; + case CSON_TYPE_INTEGER: { + cson_int_t i = 0; + cson_value_fetch_integer( val, &i ); + b = i ? 1 : 0; + break; + } + case CSON_TYPE_DOUBLE: { + cson_double_t d = 0.0; + cson_value_fetch_double( val, &d ); + b = (0.0==d) ? 0 : 1; + break; + } + default: + rc = CSON_RC_TypeError; + break; + } + if( v ) *v = b; + return rc; + } +} + +char cson_value_get_bool( cson_value const * val ) +{ + char i = 0; + cson_value_fetch_bool( val, &i ); + return i; +} + +int cson_value_fetch_integer( cson_value const * val, cson_int_t * v ) +{ + if( ! val || !val->api ) return CSON_RC_ArgError; + else + { + cson_int_t i = 0; + int rc = 0; + switch(val->api->typeID) + { + case CSON_TYPE_UNDEF: + case CSON_TYPE_NULL: + i = 0; + break; + case CSON_TYPE_BOOL: { + char b = 0; + cson_value_fetch_bool( val, &b ); + i = b; + break; + } + case CSON_TYPE_INTEGER: { + cson_int_t const * x = CSON_INT(val); + if(!x) + { + assert( val == &CSON_SPECIAL_VALUES[CSON_VAL_INT_0] ); + } + i = x ? *x : 0; + break; + } + case CSON_TYPE_DOUBLE: { + cson_double_t d = 0.0; + cson_value_fetch_double( val, &d ); + i = (cson_int_t)d; + break; + } + case CSON_TYPE_STRING: + case CSON_TYPE_ARRAY: + case CSON_TYPE_OBJECT: + default: + rc = CSON_RC_TypeError; + break; + } + if(!rc && v) *v = i; + return rc; + } +} + +cson_int_t cson_value_get_integer( cson_value const * val ) +{ + cson_int_t i = 0; + cson_value_fetch_integer( val, &i ); + return i; +} + +int cson_value_fetch_double( cson_value const * val, cson_double_t * v ) +{ + if( ! val || !val->api ) return CSON_RC_ArgError; + else + { + cson_double_t d = 0.0; + int rc = 0; + switch(val->api->typeID) + { + case CSON_TYPE_UNDEF: + case CSON_TYPE_NULL: + d = 0; + break; + case CSON_TYPE_BOOL: { + char b = 0; + cson_value_fetch_bool( val, &b ); + d = b ? 1.0 : 0.0; + break; + } + case CSON_TYPE_INTEGER: { + cson_int_t i = 0; + cson_value_fetch_integer( val, &i ); + d = i; + break; + } + case CSON_TYPE_DOUBLE: { + cson_double_t const* dv = CSON_DBL(val); + d = dv ? *dv : 0.0; + break; + } + default: + rc = CSON_RC_TypeError; + break; + } + if(v) *v = d; + return rc; + } +} + +cson_double_t cson_value_get_double( cson_value const * val ) +{ + cson_double_t i = 0.0; + cson_value_fetch_double( val, &i ); + return i; +} + +int cson_value_fetch_string( cson_value const * val, cson_string ** dest ) +{ + if( ! val || ! dest ) return CSON_RC_ArgError; + else if( ! cson_value_is_string(val) ) return CSON_RC_TypeError; + else + { + if( dest ) *dest = CSON_STR(val); + return 0; + } +} + +cson_string * cson_value_get_string( cson_value const * val ) +{ + cson_string * rc = NULL; + cson_value_fetch_string( val, &rc ); + return rc; +} + +char const * cson_value_get_cstr( cson_value const * val ) +{ + return cson_string_cstr( cson_value_get_string(val) ); +} + +int cson_value_fetch_object( cson_value const * val, cson_object ** obj ) +{ + if( ! val ) return CSON_RC_ArgError; + else if( ! cson_value_is_object(val) ) return CSON_RC_TypeError; + else + { + if(obj) *obj = CSON_OBJ(val); + return 0; + } +} +cson_object * cson_value_get_object( cson_value const * v ) +{ + cson_object * obj = NULL; + cson_value_fetch_object( v, &obj ); + return obj; +} + +int cson_value_fetch_array( cson_value const * val, cson_array ** ar) +{ + if( ! val ) return CSON_RC_ArgError; + else if( !cson_value_is_array(val) ) return CSON_RC_TypeError; + else + { + if(ar) *ar = CSON_ARRAY(val); + return 0; + } +} + +cson_array * cson_value_get_array( cson_value const * v ) +{ + cson_array * ar = NULL; + cson_value_fetch_array( v, &ar ); + return ar; +} + +cson_kvp * cson_kvp_alloc(void) +{ + cson_kvp * kvp = (cson_kvp*)cson_malloc(sizeof(cson_kvp),"cson_kvp"); + if( kvp ) + { + *kvp = cson_kvp_empty; + } + return kvp; +} + + + +int cson_array_append( cson_array * ar, cson_value * v ) +{ + if( !ar || !v ) return CSON_RC_ArgError; + else if( (ar->list.count+1) < ar->list.count ) return CSON_RC_RangeError; + else + { + if( !ar->list.alloced || (ar->list.count == ar->list.alloced-1)) + { + unsigned int const n = ar->list.count ? (ar->list.count*2) : 7; + if( n > cson_value_list_reserve( &ar->list, n ) ) + { + return CSON_RC_AllocError; + } + } + return cson_array_set( ar, ar->list.count, v ); + } +} + +#if 0 +/** + Removes and returns the last value from the given array, + shrinking its size by 1. Returns NULL if ar is NULL, + ar->list.count is 0, or the element at that index is NULL. + + + If removeRef is true then cson_value_free() is called to remove + ar's reference count for the value. In that case NULL is returned, + even if the object still has live references. If removeRef is false + then the caller takes over ownership of that reference count point. + + If removeRef is false then the caller takes over ownership + of the return value, otherwise ownership is effectively + determined by any remaining references for the returned + value. +*/ +static cson_value * cson_array_pop_back( cson_array * ar, + char removeRef ) +{ + if( !ar ) return NULL; + else if( ! ar->list.count ) return NULL; + else + { + unsigned int const ndx = --ar->list.count; + cson_value * v = ar->list.list[ndx]; + ar->list.list[ndx] = NULL; + if( removeRef ) + { + cson_value_free( v ); + v = NULL; + } + return v; + } +} +#endif + +cson_value * cson_value_new_bool( char v ) +{ + return v ? &CSON_SPECIAL_VALUES[CSON_VAL_TRUE] : &CSON_SPECIAL_VALUES[CSON_VAL_FALSE]; +} + +cson_value * cson_value_true(void) +{ + return &CSON_SPECIAL_VALUES[CSON_VAL_TRUE]; +} +cson_value * cson_value_false(void) +{ + return &CSON_SPECIAL_VALUES[CSON_VAL_FALSE]; +} + +cson_value * cson_value_null(void) +{ + return &CSON_SPECIAL_VALUES[CSON_VAL_NULL]; +} + +cson_value * cson_new_int( cson_int_t v ) +{ + return cson_value_new_integer(v); +} + +cson_value * cson_value_new_integer( cson_int_t v ) +{ + if( 0 == v ) return &CSON_SPECIAL_VALUES[CSON_VAL_INT_0]; + else + { + cson_value * c = cson_value_new(CSON_TYPE_INTEGER,0); +#if !defined(NDEBUG) && CSON_VOID_PTR_IS_BIG + assert( sizeof(cson_int_t) <= sizeof(void *) ); +#endif + if( c ) + { + memcpy( CSON_INT(c), &v, sizeof(v) ); + } + return c; + } +} + +cson_value * cson_new_double( cson_double_t v ) +{ + return cson_value_new_double(v); +} + +cson_value * cson_value_new_double( cson_double_t v ) +{ + if( 0.0 == v ) return &CSON_SPECIAL_VALUES[CSON_VAL_DBL_0]; + else + { + cson_value * c = cson_value_new(CSON_TYPE_DOUBLE,0); + if( c ) + { + memcpy( CSON_DBL(c), &v, sizeof(v) ); + } + return c; + } +} + +cson_string * cson_new_string(char const * str, unsigned int len) +{ + if( !str || !*str || !len ) return &CSON_EMPTY_HOLDER.stringValue; + else + { + cson_value * c = cson_value_new(CSON_TYPE_STRING, len + 1/*NUL byte*/); + cson_string * s = NULL; + if( c ) + { + char * dest = NULL; + s = CSON_STR(c); + *s = cson_string_empty; + assert( NULL != s ); + s->length = len; + dest = cson_string_str(s); + assert( NULL != dest ); + memcpy( dest, str, len ); + dest[len] = 0; + } + return s; + } +} + +cson_value * cson_value_new_string( char const * str, unsigned int len ) +{ + return cson_string_value( cson_new_string(str, len) ); +} + +int cson_array_value_fetch( cson_array const * ar, unsigned int pos, cson_value ** v ) +{ + if( !ar) return CSON_RC_ArgError; + if( pos >= ar->list.count ) return CSON_RC_RangeError; + else + { + if(v) *v = ar->list.list[pos]; + return 0; + } +} + +cson_value * cson_array_get( cson_array const * ar, unsigned int pos ) +{ + cson_value *v = NULL; + cson_array_value_fetch(ar, pos, &v); + return v; +} + +int cson_array_length_fetch( cson_array const * ar, unsigned int * v ) +{ + if( ! ar || !v ) return CSON_RC_ArgError; + else + { + if(v) *v = ar->list.count; + return 0; + } +} + +unsigned int cson_array_length_get( cson_array const * ar ) +{ + unsigned int i = 0; + cson_array_length_fetch(ar, &i); + return i; +} + +int cson_array_reserve( cson_array * ar, unsigned int size ) +{ + if( ! ar ) return CSON_RC_ArgError; + else if( size <= ar->list.alloced ) + { + /* We don't want to introduce a can of worms by trying to + handle the cleanup from here. + */ + return 0; + } + else + { + return (ar->list.alloced > cson_value_list_reserve( &ar->list, size )) + ? CSON_RC_AllocError + : 0 + ; + } +} + +int cson_array_set( cson_array * ar, unsigned int ndx, cson_value * v ) +{ + if( !ar || !v ) return CSON_RC_ArgError; + else if( (ndx+1) < ndx) /* overflow */return CSON_RC_RangeError; + else + { + unsigned const int len = cson_value_list_reserve( &ar->list, ndx+1 ); + if( len <= ndx ) return CSON_RC_AllocError; + else + { + cson_value * old = ar->list.list[ndx]; + if( old ) + { + if(old == v) return 0; + else cson_value_free(old); + } + cson_refcount_incr( v ); + ar->list.list[ndx] = v; + if( ndx >= ar->list.count ) + { + ar->list.count = ndx+1; + } + return 0; + } + } +} + +/** @internal + + Searchs for the given key in the given object. + + Returns the found item on success, NULL on error. If ndx is not + NULL, it is set to the index (in obj->kvp.list) of the found + item. *ndx is not modified if no entry is found. +*/ +static cson_kvp * cson_object_search_impl( cson_object const * obj, char const * key, unsigned int * ndx ) +{ + if( obj && key && *key && obj->kvp.count) + { +#if CSON_OBJECT_PROPS_SORT + cson_kvp ** s = (cson_kvp**) + bsearch( key, obj->kvp.list, + obj->kvp.count, sizeof(cson_kvp*), + cson_kvp_cmp_vs_cstr ); + if( ndx && s ) + { /* index of found record is required by + cson_object_unset(). Calculate the offset based on s...*/ +#if 0 + *ndx = (((unsigned char const *)s - ((unsigned char const *)obj->kvp.list)) + / sizeof(cson_kvp*)); +#else + *ndx = s - obj->kvp.list; +#endif + } + return s ? *s : NULL; +#else + cson_kvp_list const * li = &obj->kvp; + unsigned int i = 0; + cson_kvp * kvp; + const unsigned int klen = strlen(key); + for( ; i < li->count; ++i ) + { + cson_string const * sKey; + kvp = li->list[i]; + assert( kvp && kvp->key ); + sKey = cson_value_get_string(kvp->key); + assert(sKey); + if( sKey->length != klen ) continue; + else if(0==strcmp(key,cson_string_cstr(sKey))) + { + if(ndx) *ndx = i; + return kvp; + } + } +#endif + } + return NULL; +} + +cson_value * cson_object_get( cson_object const * obj, char const * key ) +{ + cson_kvp * kvp = cson_object_search_impl( obj, key, NULL ); + return kvp ? kvp->value : NULL; +} + +cson_value * cson_object_get_s( cson_object const * obj, cson_string const *key ) +{ + cson_kvp * kvp = cson_object_search_impl( obj, cson_string_cstr(key), NULL ); + return kvp ? kvp->value : NULL; +} + + +#if CSON_OBJECT_PROPS_SORT +static void cson_object_sort_props( cson_object * obj ) +{ + assert( NULL != obj ); + if( obj->kvp.count ) + { + qsort( obj->kvp.list, obj->kvp.count, sizeof(cson_kvp*), + cson_kvp_cmp ); + } + +} +#endif + +int cson_object_unset( cson_object * obj, char const * key ) +{ + if( ! obj || !key || !*key ) return CSON_RC_ArgError; + else + { + unsigned int ndx = 0; + cson_kvp * kvp = cson_object_search_impl( obj, key, &ndx ); + if( ! kvp ) + { + return CSON_RC_NotFoundError; + } + assert( obj->kvp.count > 0 ); + assert( obj->kvp.list[ndx] == kvp ); + cson_kvp_free( kvp ); + obj->kvp.list[ndx] = NULL; + { /* if my brain were bigger i'd use memmove(). */ + unsigned int i = ndx; + for( ; i < obj->kvp.count; ++i ) + { + obj->kvp.list[i] = + (i < (obj->kvp.alloced-1)) + ? obj->kvp.list[i+1] + : NULL; + } + } + obj->kvp.list[--obj->kvp.count] = NULL; +#if CSON_OBJECT_PROPS_SORT + cson_object_sort_props( obj ); +#endif + return 0; + } +} + +int cson_object_set_s( cson_object * obj, cson_string * key, cson_value * v ) +{ + if( !obj || !key ) return CSON_RC_ArgError; + else if( NULL == v ) return cson_object_unset( obj, cson_string_cstr(key) ); + else + { + char const * cKey; + cson_value * vKey; + cson_kvp * kvp; + vKey = cson_string_value(key); + assert(vKey && (key==CSON_STR(vKey))); + if( vKey == CSON_VCAST(obj) ){ + return CSON_RC_ArgError; + } + cKey = cson_string_cstr(key); + kvp = cson_object_search_impl( obj, cKey, NULL ); + if( kvp ) + { /* "I told 'em we've already got one!" */ + if( kvp->key != vKey ){ + cson_value_free( kvp->key ); + cson_refcount_incr(vKey); + kvp->key = vKey; + } + if(kvp->value != v){ + cson_value_free( kvp->value ); + cson_refcount_incr( v ); + kvp->value = v; + } + return 0; + } + if( !obj->kvp.alloced || (obj->kvp.count == obj->kvp.alloced-1)) + { /* reserve space */ + unsigned int const n = obj->kvp.count ? (obj->kvp.count*2) : 6; + if( n > cson_kvp_list_reserve( &obj->kvp, n ) ) + { + return CSON_RC_AllocError; + } + } + { /* insert new item... */ + int rc = 0; + kvp = cson_kvp_alloc(); + if( ! kvp ) + { + return CSON_RC_AllocError; + } + rc = cson_kvp_list_append( &obj->kvp, kvp ); + if( 0 != rc ) + { + cson_kvp_free(kvp); + } + else + { + cson_refcount_incr(vKey); + cson_refcount_incr(v); + kvp->key = vKey; + kvp->value = v; +#if CSON_OBJECT_PROPS_SORT + cson_object_sort_props( obj ); +#endif + } + return rc; + } + } + +} +int cson_object_set( cson_object * obj, char const * key, cson_value * v ) +{ + if( ! obj || !key || !*key ) return CSON_RC_ArgError; + else if( NULL == v ) + { + return cson_object_unset( obj, key ); + } + else + { + cson_string * cs = cson_new_string(key,strlen(key)); + if(!cs) return CSON_RC_AllocError; + else + { + int const rc = cson_object_set_s(obj, cs, v); + if(rc) cson_value_free(cson_string_value(cs)); + return rc; + } + } +} + +cson_value * cson_object_take( cson_object * obj, char const * key ) +{ + if( ! obj || !key || !*key ) return NULL; + else + { + /* FIXME: this is 90% identical to cson_object_unset(), + only with different refcount handling. + Consolidate them. + */ + unsigned int ndx = 0; + cson_kvp * kvp = cson_object_search_impl( obj, key, &ndx ); + cson_value * rc = NULL; + if( ! kvp ) + { + return NULL; + } + assert( obj->kvp.count > 0 ); + assert( obj->kvp.list[ndx] == kvp ); + rc = kvp->value; + assert( rc ); + kvp->value = NULL; + cson_kvp_free( kvp ); + assert( rc->refcount > 0 ); + --rc->refcount; + obj->kvp.list[ndx] = NULL; + { /* if my brain were bigger i'd use memmove(). */ + unsigned int i = ndx; + for( ; i < obj->kvp.count; ++i ) + { + obj->kvp.list[i] = + (i < (obj->kvp.alloced-1)) + ? obj->kvp.list[i+1] + : NULL; + } + } + obj->kvp.list[--obj->kvp.count] = NULL; +#if CSON_OBJECT_PROPS_SORT + cson_object_sort_props( obj ); +#endif + return rc; + } +} +/** @internal + + If p->node is-a Object then value is inserted into the object + using p->key. In any other case CSON_RC_InternalError is returned. + + Returns CSON_RC_AllocError if an allocation fails. + + Returns 0 on success. On error, parsing must be ceased immediately. + + Ownership of val is ALWAYS TRANSFERED to this function. If this + function fails, val will be cleaned up and destroyed. (This + simplifies error handling in the core parser.) +*/ +static int cson_parser_set_key( cson_parser * p, cson_value * val ) +{ + assert( p && val ); + + if( p->ckey && cson_value_is_object(p->node) ) + { + int rc; + cson_object * obj = cson_value_get_object(p->node); + cson_kvp * kvp = NULL; + assert( obj && (p->node->value == obj) ); + /** + FIXME? Use cson_object_set() instead of our custom + finagling with the object? We do it this way to avoid an + extra alloc/strcpy of the key data. + */ + if( !obj->kvp.alloced || (obj->kvp.count == obj->kvp.alloced-1)) + { + if( obj->kvp.alloced > cson_kvp_list_reserve( &obj->kvp, obj->kvp.count ? (obj->kvp.count*2) : 5 ) ) + { + cson_value_free(val); + return CSON_RC_AllocError; + } + } + kvp = cson_kvp_alloc(); + if( ! kvp ) + { + cson_value_free(val); + return CSON_RC_AllocError; + } + kvp->key = cson_string_value(p->ckey)/*transfer ownership*/; + assert(0 == kvp->key->refcount); + cson_refcount_incr(kvp->key); + p->ckey = NULL; + kvp->value = val; + cson_refcount_incr( val ); + rc = cson_kvp_list_append( &obj->kvp, kvp ); + if( 0 != rc ) + { + cson_kvp_free( kvp ); + } + else + { + ++p->totalValueCount; + } + return rc; + } + else + { + if(val) cson_value_free(val); + return p->errNo = CSON_RC_InternalError; + } + +} + +/** @internal + + Pushes val into the current object/array parent node, depending on the + internal state of the parser. + + Ownership of val is always transfered to this function, regardless of + success or failure. + + Returns 0 on success. On error, parsing must be ceased immediately. +*/ +static int cson_parser_push_value( cson_parser * p, cson_value * val ) +{ + if( p->ckey ) + { /* we're in Object mode */ + assert( cson_value_is_object( p->node ) ); + return cson_parser_set_key( p, val ); + } + else if( cson_value_is_array( p->node ) ) + { /* we're in Array mode */ + cson_array * ar = cson_value_get_array( p->node ); + int rc; + assert( ar && (ar == p->node->value) ); + rc = cson_array_append( ar, val ); + if( 0 != rc ) + { + cson_value_free(val); + } + else + { + ++p->totalValueCount; + } + return rc; + } + else + { /* WTF? */ + assert( 0 && "Internal error in cson_parser code" ); + return p->errNo = CSON_RC_InternalError; + } +} + +/** + Callback for JSON_parser API. Reminder: it returns 0 (meaning false) + on error! +*/ +static int cson_parse_callback( void * cx, int type, JSON_value const * value ) +{ + cson_parser * p = (cson_parser *)cx; + int rc = 0; +#define ALLOC_V(T,V) cson_value * v = cson_value_new_##T(V); if( ! v ) { rc = CSON_RC_AllocError; break; } + switch(type) { + case JSON_T_ARRAY_BEGIN: + case JSON_T_OBJECT_BEGIN: { + cson_value * obja = (JSON_T_ARRAY_BEGIN == type) + ? cson_value_new_array() + : cson_value_new_object(); + if( ! obja ) + { + p->errNo = CSON_RC_AllocError; + break; + } + if( 0 != rc ) break; + if( ! p->root ) + { + p->root = p->node = obja; + rc = cson_array_append( &p->stack, obja ); + if( 0 != rc ) + { /* work around a (potential) corner case in the cleanup code. */ + cson_value_free( p->root ); + p->root = NULL; + } + else + { + cson_refcount_incr( p->root ) + /* simplifies cleanup later on. */ + ; + ++p->totalValueCount; + } + } + else + { + rc = cson_array_append( &p->stack, obja ); + if(rc) cson_value_free( obja ); + else + { + rc = cson_parser_push_value( p, obja ); + if( 0 == rc ) p->node = obja; + } + } + break; + } + case JSON_T_ARRAY_END: + case JSON_T_OBJECT_END: { + if( 0 == p->stack.list.count ) + { + rc = CSON_RC_RangeError; + break; + } +#if CSON_OBJECT_PROPS_SORT + if( cson_value_is_object(p->node) ) + {/* kludge: the parser uses custom cson_object property + insertion as a malloc/strcpy-reduction optimization. + Because of that, we have to sort the property list + ourselves... + */ + cson_object * obj = cson_value_get_object(p->node); + assert( NULL != obj ); + cson_object_sort_props( obj ); + } +#endif + +#if 1 + /* Reminder: do not use cson_array_pop_back( &p->stack ) + because that will clean up the object, and we don't want + that. We just want to forget this reference + to it. The object is either the root or was pushed into + an object/array in the parse tree (and is owned by that + object/array). + */ + --p->stack.list.count; + assert( p->node == p->stack.list.list[p->stack.list.count] ); + cson_refcount_decr( p->node ) + /* p->node might be owned by an outer object but we + need to remove the list's reference. For the + root node we manually add a reference to + avoid a special case here. Thus when we close + the root node, its refcount is still 1. + */; + p->stack.list.list[p->stack.list.count] = NULL; + if( p->stack.list.count ) + { + p->node = p->stack.list.list[p->stack.list.count-1]; + } + else + { + p->node = p->root; + } +#else + /* + Causing a leak? + */ + cson_array_pop_back( &p->stack, 1 ); + if( p->stack.list.count ) + { + p->node = p->stack.list.list[p->stack.list.count-1]; + } + else + { + p->node = p->root; + } + assert( p->node && (1==p->node->refcount) ); +#endif + break; + } + case JSON_T_INTEGER: { + ALLOC_V(integer, value->vu.integer_value ); + rc = cson_parser_push_value( p, v ); + break; + } + case JSON_T_FLOAT: { + ALLOC_V(double, value->vu.float_value ); + rc = cson_parser_push_value( p, v ); + break; + } + case JSON_T_NULL: { + rc = cson_parser_push_value( p, cson_value_null() ); + break; + } + case JSON_T_TRUE: { + rc = cson_parser_push_value( p, cson_value_true() ); + break; + } + case JSON_T_FALSE: { + rc = cson_parser_push_value( p, cson_value_false() ); + break; + } + case JSON_T_KEY: { + assert(!p->ckey); + p->ckey = cson_new_string( value->vu.str.value, value->vu.str.length ); + if( ! p->ckey ) + { + rc = CSON_RC_AllocError; + break; + } + ++p->totalKeyCount; + break; + } + case JSON_T_STRING: { + cson_value * v = cson_value_new_string( value->vu.str.value, value->vu.str.length ); + rc = ( NULL == v ) + ? CSON_RC_AllocError + : cson_parser_push_value( p, v ); + break; + } + default: + assert(0); + rc = CSON_RC_InternalError; + break; + } +#undef ALLOC_V + return ((p->errNo = rc)) ? 0 : 1; +} + + +/** + Converts a JSON_error code to one of the cson_rc values. +*/ +static int cson_json_err_to_rc( JSON_error jrc ) +{ + switch(jrc) + { + case JSON_E_NONE: return 0; + case JSON_E_INVALID_CHAR: return CSON_RC_Parse_INVALID_CHAR; + case JSON_E_INVALID_KEYWORD: return CSON_RC_Parse_INVALID_KEYWORD; + case JSON_E_INVALID_ESCAPE_SEQUENCE: return CSON_RC_Parse_INVALID_ESCAPE_SEQUENCE; + case JSON_E_INVALID_UNICODE_SEQUENCE: return CSON_RC_Parse_INVALID_UNICODE_SEQUENCE; + case JSON_E_INVALID_NUMBER: return CSON_RC_Parse_INVALID_NUMBER; + case JSON_E_NESTING_DEPTH_REACHED: return CSON_RC_Parse_NESTING_DEPTH_REACHED; + case JSON_E_UNBALANCED_COLLECTION: return CSON_RC_Parse_UNBALANCED_COLLECTION; + case JSON_E_EXPECTED_KEY: return CSON_RC_Parse_EXPECTED_KEY; + case JSON_E_EXPECTED_COLON: return CSON_RC_Parse_EXPECTED_COLON; + case JSON_E_OUT_OF_MEMORY: return CSON_RC_AllocError; + default: + return CSON_RC_InternalError; + } +} + +/** @internal + + Cleans up all contents of p but does not free p. + + To properly take over ownership of the parser's root node on a + successful parse: + + - Copy p->root's pointer and set p->root to NULL. + - Eventually free up p->root with cson_value_free(). + + If you do not set p->root to NULL, p->root will be freed along with + any other items inserted into it (or under it) during the parsing + process. +*/ +static int cson_parser_clean( cson_parser * p ) +{ + if( ! p ) return CSON_RC_ArgError; + else + { + if( p->p ) + { + delete_JSON_parser(p->p); + p->p = NULL; + } + if( p->ckey ){ + cson_value_free(cson_string_value(p->ckey)); + } + cson_array_clean( &p->stack, 1 ); + if( p->root ) + { + cson_value_free( p->root ); + } + *p = cson_parser_empty; + return 0; + } +} + + +int cson_parse( cson_value ** tgt, cson_data_source_f src, void * state, + cson_parse_opt const * opt_, cson_parse_info * info_ ) +{ + unsigned char ch[2] = {0,0}; + cson_parse_opt const opt = opt_ ? *opt_ : cson_parse_opt_empty; + int rc = 0; + unsigned int len = 1; + cson_parse_info info = info_ ? *info_ : cson_parse_info_empty; + cson_parser p = cson_parser_empty; + if( ! tgt || ! src ) return CSON_RC_ArgError; + + { + JSON_config jopt = {0}; + init_JSON_config( &jopt ); + jopt.allow_comments = opt.allowComments; + jopt.depth = opt.maxDepth; + jopt.callback_ctx = &p; + jopt.handle_floats_manually = 0; + jopt.callback = cson_parse_callback; + p.p = new_JSON_parser(&jopt); + if( ! p.p ) + { + return CSON_RC_AllocError; + } + } + + do + { /* FIXME: buffer the input in multi-kb chunks. */ + len = 1; + ch[0] = 0; + rc = src( state, ch, &len ); + if( 0 != rc ) break; + else if( !len /* EOF */ ) break; + ++info.length; + if('\n' == ch[0]) + { + ++info.line; + info.col = 0; + } + if( ! JSON_parser_char(p.p, ch[0]) ) + { + rc = cson_json_err_to_rc( JSON_parser_get_last_error(p.p) ); + if(0==rc) rc = p.errNo; + if(0==rc) rc = CSON_RC_InternalError; + info.errorCode = rc; + break; + } + if( '\n' != ch[0]) ++info.col; + } while(1); + if( info_ ) + { + info.totalKeyCount = p.totalKeyCount; + info.totalValueCount = p.totalValueCount; + *info_ = info; + } + if( 0 != rc ) + { + cson_parser_clean(&p); + return rc; + } + if( ! JSON_parser_done(p.p) ) + { + rc = cson_json_err_to_rc( JSON_parser_get_last_error(p.p) ); + cson_parser_clean(&p); + if(0==rc) rc = p.errNo; + if(0==rc) rc = CSON_RC_InternalError; + } + else + { + cson_value * root = p.root; + p.root = NULL; + cson_parser_clean(&p); + if( root ) + { + assert( (1 == root->refcount) && "Detected memory mismanagement in the parser." ); + root->refcount = 0 + /* HUGE KLUDGE! Avoids having one too many references + in some client code, leading to a leak. Here we're + accommodating a memory management workaround in the + parser code which manually adds a reference to the + root node to keep it from being cleaned up + prematurely. + */; + *tgt = root; + } + else + { /* then can happen on empty input. */ + rc = CSON_RC_UnknownError; + } + } + return rc; +} + +/** + The UTF code was originally taken from sqlite3's public-domain + source code (http://sqlite.org), modified only slightly for use + here. This code generates some "possible data loss" warnings on + MSVC, but if this code is good enough for sqlite3 then it's damned + well good enough for me, so we disable that warning for Windows + builds. +*/ + +/* +** This lookup table is used to help decode the first byte of +** a multi-byte UTF8 character. +*/ +static const unsigned char cson_utfTrans1[] = { + 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, + 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, + 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, + 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, + 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, + 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, + 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, + 0x00, 0x01, 0x02, 0x03, 0x00, 0x01, 0x00, 0x00 +}; + + +/* +** Translate a single UTF-8 character. Return the unicode value. +** +** During translation, assume that the byte that zTerm points +** is a 0x00. +** +** Write a pointer to the next unread byte back into *pzNext. +** +** Notes On Invalid UTF-8: +** +** * This routine never allows a 7-bit character (0x00 through 0x7f) to +** be encoded as a multi-byte character. Any multi-byte character that +** attempts to encode a value between 0x00 and 0x7f is rendered as 0xfffd. +** +** * This routine never allows a UTF16 surrogate value to be encoded. +** If a multi-byte character attempts to encode a value between +** 0xd800 and 0xe000 then it is rendered as 0xfffd. +** +** * Bytes in the range of 0x80 through 0xbf which occur as the first +** byte of a character are interpreted as single-byte characters +** and rendered as themselves even though they are technically +** invalid characters. +** +** * This routine accepts an infinite number of different UTF8 encodings +** for unicode values 0x80 and greater. It do not change over-length +** encodings to 0xfffd as some systems recommend. +*/ +#define READ_UTF8(zIn, zTerm, c) \ + c = *(zIn++); \ + if( c>=0xc0 ){ \ + c = cson_utfTrans1[c-0xc0]; \ + while( zIn!=zTerm && (*zIn & 0xc0)==0x80 ){ \ + c = (c<<6) + (0x3f & *(zIn++)); \ + } \ + if( c<0x80 \ + || (c&0xFFFFF800)==0xD800 \ + || (c&0xFFFFFFFE)==0xFFFE ){ c = 0xFFFD; } \ + } +static int cson_utf8Read( + const unsigned char *z, /* First byte of UTF-8 character */ + const unsigned char *zTerm, /* Pretend this byte is 0x00 */ + const unsigned char **pzNext /* Write first byte past UTF-8 char here */ +){ + int c; + READ_UTF8(z, zTerm, c); + *pzNext = z; + return c; +} +#undef READ_UTF8 + +#ifdef _MSC_VER +# if _MSC_VER >= 1400 /* Visual Studio 2005 and up */ +# pragma warning( pop ) +# endif +#endif + +unsigned int cson_string_length_utf8( cson_string const * str ) +{ + if( ! str ) return 0; + else + { + char unsigned const * pos = (char unsigned const *)cson_string_cstr(str); + char unsigned const * end = pos + str->length; + unsigned int rc = 0; + for( ; (pos < end) && cson_utf8Read(pos, end, &pos); + ++rc ) + { + }; + return rc; + } +} + +/** + Escapes the first len bytes of the given string as JSON and sends + it to the given output function (which will be called often - once + for each logical character). The output is also surrounded by + double-quotes. + + A NULL str will be escaped as an empty string, though we should + arguably export it as "null" (without quotes). We do this because + in JavaScript (typeof null === "object"), and by outputing null + here we would effectively change the data type from string to + object. +*/ +static int cson_str_to_json( char const * str, unsigned int len, + char escapeFwdSlash, + cson_data_dest_f f, void * state ) +{ + if( NULL == f ) return CSON_RC_ArgError; + else if( !str || !*str || (0 == len) ) + { /* special case for 0-length strings. */ + return f( state, "\"\"", 2 ); + } + else + { + unsigned char const * pos = (unsigned char const *)str; + unsigned char const * end = (unsigned char const *)(str ? (str + len) : NULL); + unsigned char const * next = NULL; + int ch; + unsigned char clen = 0; + char escChar[3] = {'\\',0,0}; + enum { UBLen = 20 }; + char ubuf[UBLen]; + int rc = 0; + rc = f(state, "\"", 1 ); + for( ; (pos < end) && (0 == rc); pos += clen ) + { + ch = cson_utf8Read(pos, end, &next); + if( 0 == ch ) break; + assert( next > pos ); + clen = next - pos; + assert( clen ); + if( 1 == clen ) + { /* ASCII */ +#if defined(CSON_FOSSIL_MODE) + /* Workaround for fossil repo artifact + f460839cff85d4e4f1360b366bb2858cef1411ea, + which has what appears to be latin1-encoded + text. file(1) thinks it's a FORTRAN program. + */ + if(0xfffd==ch){ + assert(*pos != ch); + /* MARKER("ch=%04x, *pos=%04x\n", ch, *pos); */ + ch = *pos + /* We should arguably translate to '?', and + will if this problem ever comes up with a + non-latin1 encoding. For latin1 this + workaround incidentally corrects the output + to proper UTF8-escaped characters, and only + for that reason is it being kept around. + */; + goto assume_latin1; + } +#endif + assert( (*pos == ch) && "Invalid UTF8" ); + escChar[1] = 0; + switch(ch) + { + case '\t': escChar[1] = 't'; break; + case '\r': escChar[1] = 'r'; break; + case '\n': escChar[1] = 'n'; break; + case '\f': escChar[1] = 'f'; break; + case '\b': escChar[1] = 'b'; break; + case '/': + /* + Regarding escaping of forward-slashes. See the main exchange below... + + -------------- + From: Douglas Crockford + To: Stephan Beal + Subject: Re: Is escaping of forward slashes required? + + It is allowed, not required. It is allowed so that JSON can be safely + embedded in HTML, which can freak out when seeing strings containing + " Hello, Jsonites, + > + > i'm a bit confused on a small grammatic detail of JSON: + > + > if i'm reading the grammar chart on http://www.json.org/ correctly, + > forward slashes (/) are supposed to be escaped in JSON. However, the + > JSON class provided with my browsers (Chrome and FF, both of which i + > assume are fairly standards/RFC-compliant) do not escape such characters. + > + > Is backslash-escaping forward slashes required? If so, what is the + > justification for it? (i ask because i find it unnecessary and hard to + > look at.) + -------------- + */ + if( escapeFwdSlash ) escChar[1] = '/'; + break; + case '\\': escChar[1] = '\\'; break; + case '"': escChar[1] = '"'; break; + default: break; + } + if( escChar[1]) + { + rc = f(state, escChar, 2); + } + else + { + rc = f(state, (char const *)pos, clen); + } + continue; + } + else + { /* UTF: transform it to \uXXXX */ +#if defined(CSON_FOSSIL_MODE) + assume_latin1: +#endif + memset(ubuf,0,UBLen); + if(ch <= 0xFFFF){ + rc = snprintf(ubuf, (size_t)UBLen, "\\u%04x",ch); + if( rc != 6 ) + { + rc = CSON_RC_RangeError; + break; + } + rc = f( state, ubuf, 6 ); + }else{ /* encode as a UTF16 surrogate pair */ + /* http://unicodebook.readthedocs.org/en/latest/unicode_encodings.html#surrogates */ + ch -= 0x10000; + rc = snprintf(ubuf, (size_t)UBLen, "\\u%04x\\u%04x", + (0xd800 | (ch>>10)), + (0xdc00 | (ch & 0x3ff))); + if( rc != 12 ) + { + rc = CSON_RC_RangeError; + break; + } + rc = f( state, ubuf, 12 ); + } + continue; + } + } + if( 0 == rc ) + { + rc = f(state, "\"", 1 ); + } + return rc; + } +} + +int cson_object_iter_init( cson_object const * obj, cson_object_iterator * iter ) +{ + if( ! obj || !iter ) return CSON_RC_ArgError; + else + { + iter->obj = obj; + iter->pos = 0; + return 0; + } +} + +cson_kvp * cson_object_iter_next( cson_object_iterator * iter ) +{ + if( ! iter || !iter->obj ) return NULL; + else if( iter->pos >= iter->obj->kvp.count ) return NULL; + else + { + cson_kvp * rc = iter->obj->kvp.list[iter->pos++]; + while( (NULL==rc) && (iter->pos < iter->obj->kvp.count)) + { + rc = iter->obj->kvp.list[iter->pos++]; + } + return rc; + } +} + +static int cson_output_null( cson_data_dest_f f, void * state ) +{ + if( !f ) return CSON_RC_ArgError; + else + { + return f(state, "null", 4); + } +} + +static int cson_output_bool( cson_value const * src, cson_data_dest_f f, void * state ) +{ + if( !f ) return CSON_RC_ArgError; + else + { + char const v = cson_value_get_bool(src); + return f(state, v ? "true" : "false", v ? 4 : 5); + } +} + +static int cson_output_integer( cson_value const * src, cson_data_dest_f f, void * state ) +{ + if( !f ) return CSON_RC_ArgError; + else if( !cson_value_is_integer(src) ) return CSON_RC_TypeError; + else + { + enum { BufLen = 100 }; + char b[BufLen]; + int rc; + memset( b, 0, BufLen ); + rc = snprintf( b, (size_t)BufLen, "%"CSON_INT_T_PFMT, + cson_value_get_integer(src) ); + return ( rc<=0 ) + ? CSON_RC_RangeError + : f( state, b, (unsigned int)rc ) + ; + } +} + +static int cson_output_double( cson_value const * src, cson_data_dest_f f, void * state ) +{ + if( !f ) return CSON_RC_ArgError; + else if( !cson_value_is_double(src) ) return CSON_RC_TypeError; + else + { + enum { BufLen = 128 /* this must be relatively large or huge + doubles can cause us to overrun here, + resulting in stack-smashing errors. + */}; + char b[BufLen]; + int rc; + memset( b, 0, BufLen ); + rc = snprintf( b, (size_t)BufLen, "%"CSON_DOUBLE_T_PFMT, + cson_value_get_double(src) ); + if( rc<=0 ) return CSON_RC_RangeError; + else if(1) + { /* Strip trailing zeroes before passing it on... */ + unsigned int urc = (unsigned int)rc; + char * pos = b + urc - 1; + for( ; ('0' == *pos) && urc && (*(pos-1) != '.'); --pos, --urc ) + { + *pos = 0; + } + assert(urc && *pos); + return f( state, b, urc ); + } + else + { + unsigned int urc = (unsigned int)rc; + return f( state, b, urc ); + } + return 0; + } +} + +static int cson_output_string( cson_value const * src, char escapeFwdSlash, cson_data_dest_f f, void * state ) +{ + if( !f ) return CSON_RC_ArgError; + else if( ! cson_value_is_string(src) ) return CSON_RC_TypeError; + else + { + cson_string const * str = cson_value_get_string(src); + assert( NULL != str ); + return cson_str_to_json(cson_string_cstr(str), str->length, escapeFwdSlash, f, state); + } +} + + +/** + Outputs indention spacing to f(). + + blanks: (0)=no indentation, (1)=1 TAB per/level, (>1)=n spaces/level + + depth is the current depth of the output tree, and determines how much + indentation to generate. + + If blanks is 0 this is a no-op. Returns non-0 on error, and the + error code will always come from f(). +*/ +static int cson_output_indent( cson_data_dest_f f, void * state, + unsigned char blanks, unsigned int depth ) +{ + if( 0 == blanks ) return 0; + else + { +#if 0 + /* FIXME: stuff the indention into the buffer and make a single + call to f(). + */ + enum { BufLen = 200 }; + char buf[BufLen]; +#endif + unsigned int i; + unsigned int x; + char const ch = (1==blanks) ? '\t' : ' '; + int rc = f(state, "\n", 1 ); + for( i = 0; (i < depth) && (0 == rc); ++i ) + { + for( x = 0; (x < blanks) && (0 == rc); ++x ) + { + rc = f(state, &ch, 1); + } + } + return rc; + } +} + +static int cson_output_array( cson_value const * src, cson_data_dest_f f, void * state, + cson_output_opt const * fmt, unsigned int level ); +static int cson_output_object( cson_value const * src, cson_data_dest_f f, void * state, + cson_output_opt const * fmt, unsigned int level ); +/** + Main cson_output() implementation. Dispatches to a different impl depending + on src->api->typeID. + + Returns 0 on success. +*/ +static int cson_output_impl( cson_value const * src, cson_data_dest_f f, void * state, + cson_output_opt const * fmt, unsigned int level ) +{ + if( ! src || !f || !src->api ) return CSON_RC_ArgError; + else + { + int rc = 0; + assert(fmt); + switch( src->api->typeID ) + { + case CSON_TYPE_UNDEF: + case CSON_TYPE_NULL: + rc = cson_output_null(f, state); + break; + case CSON_TYPE_BOOL: + rc = cson_output_bool(src, f, state); + break; + case CSON_TYPE_INTEGER: + rc = cson_output_integer(src, f, state); + break; + case CSON_TYPE_DOUBLE: + rc = cson_output_double(src, f, state); + break; + case CSON_TYPE_STRING: + rc = cson_output_string(src, fmt->escapeForwardSlashes, f, state); + break; + case CSON_TYPE_ARRAY: + rc = cson_output_array( src, f, state, fmt, level ); + break; + case CSON_TYPE_OBJECT: + rc = cson_output_object( src, f, state, fmt, level ); + break; + default: + rc = CSON_RC_TypeError; + break; + } + return rc; + } +} + + +static int cson_output_array( cson_value const * src, cson_data_dest_f f, void * state, + cson_output_opt const * fmt, unsigned int level ) +{ + if( !src || !f || !fmt ) return CSON_RC_ArgError; + else if( ! cson_value_is_array(src) ) return CSON_RC_TypeError; + else if( level > fmt->maxDepth ) return CSON_RC_RangeError; + else + { + int rc; + unsigned int i; + cson_value const * v; + char doIndent = fmt->indentation ? 1 : 0; + cson_array const * ar = cson_value_get_array(src); + assert( NULL != ar ); + if( 0 == ar->list.count ) + { + return f(state, "[]", 2 ); + } + else if( (1 == ar->list.count) && !fmt->indentSingleMemberValues ) doIndent = 0; + rc = f(state, "[", 1); + ++level; + if( doIndent ) + { + rc = cson_output_indent( f, state, fmt->indentation, level ); + } + for( i = 0; (i < ar->list.count) && (0 == rc); ++i ) + { + v = ar->list.list[i]; + if( v ) + { + rc = cson_output_impl( v, f, state, fmt, level ); + } + else + { + rc = cson_output_null( f, state ); + } + if( 0 == rc ) + { + if(i < (ar->list.count-1)) + { + rc = f(state, ",", 1); + if( 0 == rc ) + { + rc = doIndent + ? cson_output_indent( f, state, fmt->indentation, level ) + : 0 /*f( state, " ", 1 )*/; + } + } + } + } + --level; + if( doIndent && (0 == rc) ) + { + rc = cson_output_indent( f, state, fmt->indentation, level ); + } + return (0 == rc) + ? f(state, "]", 1) + : rc; + } +} + +static int cson_output_object( cson_value const * src, cson_data_dest_f f, void * state, + cson_output_opt const * fmt, unsigned int level ) +{ + if( !src || !f || !fmt ) return CSON_RC_ArgError; + else if( ! cson_value_is_object(src) ) return CSON_RC_TypeError; + else if( level > fmt->maxDepth ) return CSON_RC_RangeError; + else + { + int rc; + unsigned int i; + cson_kvp const * kvp; + char doIndent = fmt->indentation ? 1 : 0; + cson_object const * obj = cson_value_get_object(src); + assert( (NULL != obj) && (NULL != fmt)); + if( 0 == obj->kvp.count ) + { + return f(state, "{}", 2 ); + } + else if( (1 == obj->kvp.count) && !fmt->indentSingleMemberValues ) doIndent = 0; + rc = f(state, "{", 1); + ++level; + if( doIndent ) + { + rc = cson_output_indent( f, state, fmt->indentation, level ); + } + for( i = 0; (i < obj->kvp.count) && (0 == rc); ++i ) + { + kvp = obj->kvp.list[i]; + if( kvp && kvp->key ) + { + cson_string const * sKey = cson_value_get_string(kvp->key); + char const * cKey = cson_string_cstr(sKey); + rc = cson_str_to_json(cKey, sKey->length, + fmt->escapeForwardSlashes, f, state); + if( 0 == rc ) + { + rc = fmt->addSpaceAfterColon + ? f(state, ": ", 2 ) + : f(state, ":", 1 ) + ; + } + if( 0 == rc) + { + rc = ( kvp->value ) + ? cson_output_impl( kvp->value, f, state, fmt, level ) + : cson_output_null( f, state ); + } + } + else + { + assert( 0 && "Possible internal error." ); + continue /* internal error? */; + } + if( 0 == rc ) + { + if(i < (obj->kvp.count-1)) + { + rc = f(state, ",", 1); + if( 0 == rc ) + { + rc = doIndent + ? cson_output_indent( f, state, fmt->indentation, level ) + : 0 /*f( state, " ", 1 )*/; + } + } + } + } + --level; + if( doIndent && (0 == rc) ) + { + rc = cson_output_indent( f, state, fmt->indentation, level ); + } + return (0 == rc) + ? f(state, "}", 1) + : rc; + } +} + +int cson_output( cson_value const * src, cson_data_dest_f f, + void * state, cson_output_opt const * fmt ) +{ + int rc; + if(! fmt ) fmt = &cson_output_opt_empty; + rc = cson_output_impl(src, f, state, fmt, 0 ); + if( (0 == rc) && fmt->addNewline ) + { + rc = f(state, "\n", 1); + } + return rc; +} + +int cson_data_dest_FILE( void * state, void const * src, unsigned int n ) +{ + if( ! state ) return CSON_RC_ArgError; + else if( !src || !n ) return 0; + else + { + return ( 1 == fwrite( src, n, 1, (FILE*) state ) ) + ? 0 + : CSON_RC_IOError; + } +} + +int cson_output_FILE( cson_value const * src, FILE * dest, cson_output_opt const * fmt ) +{ + int rc = 0; + if( fmt ) + { + rc = cson_output( src, cson_data_dest_FILE, dest, fmt ); + } + else + { + /* We normally want a newline on FILE output. */ + cson_output_opt opt = cson_output_opt_empty; + opt.addNewline = 1; + rc = cson_output( src, cson_data_dest_FILE, dest, &opt ); + } + if( 0 == rc ) + { + fflush( dest ); + } + return rc; +} + +int cson_output_filename( cson_value const * src, char const * dest, cson_output_opt const * fmt ) +{ + if( !src || !dest ) return CSON_RC_ArgError; + else + { + FILE * f = fopen(dest,"wb"); + if( !f ) return CSON_RC_IOError; + else + { + int const rc = cson_output_FILE( src, f, fmt ); + fclose(f); + return rc; + } + } +} + +int cson_parse_filename( cson_value ** tgt, char const * src, + cson_parse_opt const * opt, cson_parse_info * err ) +{ + if( !src || !tgt ) return CSON_RC_ArgError; + else + { + FILE * f = fopen(src, "r"); + if( !f ) return CSON_RC_IOError; + else + { + int const rc = cson_parse_FILE( tgt, f, opt, err ); + fclose(f); + return rc; + } + } +} + +/** Internal type to hold state for a JSON input string. + */ +typedef struct cson_data_source_StringSource_ +{ + /** Start of input string. */ + char const * str; + /** Current iteration position. Must initially be == str. */ + char const * pos; + /** Logical EOF, one-past-the-end of str. */ + char const * end; +} cson_data_source_StringSource_t; + +/** + A cson_data_source_f() implementation which requires the state argument + to be a properly populated (cson_data_source_StringSource_t*). +*/ +static int cson_data_source_StringSource( void * state, void * dest, unsigned int * n ) +{ + if( !state || !n || !dest ) return CSON_RC_ArgError; + else if( !*n ) return 0 /* ignore this */; + else + { + unsigned int i; + cson_data_source_StringSource_t * ss = (cson_data_source_StringSource_t*) state; + unsigned char * tgt = (unsigned char *)dest; + for( i = 0; (i < *n) && (ss->pos < ss->end); ++i, ++ss->pos, ++tgt ) + { + *tgt = *ss->pos; + } + *n = i; + return 0; + } +} + +int cson_parse_string( cson_value ** tgt, char const * src, unsigned int len, + cson_parse_opt const * opt, cson_parse_info * err ) +{ + if( ! tgt || !src ) return CSON_RC_ArgError; + else if( !*src || (len<2/*2==len of {} and []*/) ) return CSON_RC_RangeError; + else + { + cson_data_source_StringSource_t ss; + ss.str = ss.pos = src; + ss.end = src + len; + return cson_parse( tgt, cson_data_source_StringSource, &ss, opt, err ); + } + +} + +int cson_parse_buffer( cson_value ** tgt, + cson_buffer const * buf, + cson_parse_opt const * opt, + cson_parse_info * err ) +{ + return ( !tgt || !buf || !buf->mem || !buf->used ) + ? CSON_RC_ArgError + : cson_parse_string( tgt, (char const *)buf->mem, + buf->used, opt, err ); +} + +int cson_buffer_reserve( cson_buffer * buf, cson_size_t n ) +{ + if( ! buf ) return CSON_RC_ArgError; + else if( 0 == n ) + { + cson_free(buf->mem, "cson_buffer::mem"); + *buf = cson_buffer_empty; + return 0; + } + else if( buf->capacity >= n ) + { + return 0; + } + else + { + unsigned char * x = (unsigned char *)cson_realloc( buf->mem, n, "cson_buffer::mem" ); + if( ! x ) return CSON_RC_AllocError; + memset( x + buf->used, 0, n - buf->used ); + buf->mem = x; + buf->capacity = n; + ++buf->timesExpanded; + return 0; + } +} + +cson_size_t cson_buffer_fill( cson_buffer * buf, char c ) +{ + if( !buf || !buf->capacity || !buf->mem ) return 0; + else + { + memset( buf->mem, c, buf->capacity ); + return buf->capacity; + } +} + +/** + cson_data_dest_f() implementation, used by cson_output_buffer(). + + arg MUST be a (cson_buffer*). This function appends n bytes at + position arg->used, expanding the buffer as necessary. +*/ +static int cson_data_dest_cson_buffer( void * arg, void const * data_, unsigned int n ) +{ + if( !arg ) return CSON_RC_ArgError; + else if( ! n ) return 0; + else + { + cson_buffer * sb = (cson_buffer*)arg; + char const * data = (char const *)data_; + cson_size_t npos = sb->used + n; + unsigned int i; + if( npos >= sb->capacity ) + { + const cson_size_t oldCap = sb->capacity; + const cson_size_t asz = npos * 2; + if( asz < npos ) return CSON_RC_ArgError; /* overflow */ + else if( 0 != cson_buffer_reserve( sb, asz ) ) return CSON_RC_AllocError; + assert( (sb->capacity > oldCap) && "Internal error in memory buffer management!" ); + /* make sure it gets NUL terminated. */ + memset( sb->mem + oldCap, 0, (sb->capacity - oldCap) ); + } + for( i = 0; i < n; ++i, ++sb->used ) + { + sb->mem[sb->used] = data[i]; + } + return 0; + } +} + + +int cson_output_buffer( cson_value const * v, cson_buffer * buf, + cson_output_opt const * opt ) +{ + int rc = cson_output( v, cson_data_dest_cson_buffer, buf, opt ); + if( 0 == rc ) + { /* Ensure that the buffer is null-terminated. */ + rc = cson_buffer_reserve( buf, buf->used + 1 ); + if( 0 == rc ) + { + buf->mem[buf->used] = 0; + } + } + return rc; +} + +/** @internal + +Tokenizes an input string on a given separator. Inputs are: + +- (inp) = is a pointer to the pointer to the start of the input. + +- (separator) = the separator character + +- (end) = a pointer to NULL. i.e. (*end == NULL) + +This function scans *inp for the given separator char or a NUL char. +Successive separators at the start of *inp are skipped. The effect is +that, when this function is called in a loop, all neighboring +separators are ignored. e.g. the string "aa.bb...cc" will tokenize to +the list (aa,bb,cc) if the separator is '.' and to (aa.,...cc) if the +separator is 'b'. + +Returns 0 (false) if it finds no token, else non-0 (true). + +Output: + +- (*inp) will be set to the first character of the next token. + +- (*end) will point to the one-past-the-end point of the token. + +If (*inp == *end) then the end of the string has been reached +without finding a token. + +Post-conditions: + +- (*end == *inp) if no token is found. + +- (*end > *inp) if a token is found. + +It is intolerant of NULL values for (inp, end), and will assert() in +debug builds if passed NULL as either parameter. +*/ +static char cson_next_token( char const ** inp, char separator, char const ** end ) +{ + char const * pos = NULL; + assert( inp && end && *inp ); + if( *inp == *end ) return 0; + pos = *inp; + if( !*pos ) + { + *end = pos; + return 0; + } + for( ; *pos && (*pos == separator); ++pos) { /* skip preceeding splitters */ } + *inp = pos; + for( ; *pos && (*pos != separator); ++pos) { /* find next splitter */ } + *end = pos; + return (pos > *inp) ? 1 : 0; +} + +int cson_object_fetch_sub2( cson_object const * obj, cson_value ** tgt, char const * path ) +{ + if( ! obj || !path ) return CSON_RC_ArgError; + else if( !*path || !*(1+path) ) return CSON_RC_RangeError; + else return cson_object_fetch_sub(obj, tgt, path+1, *path); +} + +int cson_object_fetch_sub( cson_object const * obj, cson_value ** tgt, char const * path, char sep ) +{ + if( ! obj || !path ) return CSON_RC_ArgError; + else if( !*path || !sep ) return CSON_RC_RangeError; + else + { + char const * beg = path; + char const * end = NULL; + int rc; + unsigned int i, len; + unsigned int tokenCount = 0; + cson_value * cv = NULL; + cson_object const * curObj = obj; + enum { BufSize = 128 }; + char buf[BufSize]; + memset( buf, 0, BufSize ); + + while( cson_next_token( &beg, sep, &end ) ) + { + if( beg == end ) break; + else + { + ++tokenCount; + beg = end; + end = NULL; + } + } + if( 0 == tokenCount ) return CSON_RC_RangeError; + beg = path; + end = NULL; + for( i = 0; i < tokenCount; ++i, beg=end, end=NULL ) + { + rc = cson_next_token( &beg, sep, &end ); + assert( 1 == rc ); + assert( beg != end ); + assert( end > beg ); + len = end - beg; + if( len > (BufSize-1) ) return CSON_RC_RangeError; + memset( buf, 0, len + 1 ); + memcpy( buf, beg, len ); + buf[len] = 0; + cv = cson_object_get( curObj, buf ); + if( NULL == cv ) return CSON_RC_NotFoundError; + else if( i == (tokenCount-1) ) + { + if(tgt) *tgt = cv; + return 0; + } + else if( cson_value_is_object(cv) ) + { + curObj = cson_value_get_object(cv); + assert((NULL != curObj) && "Detected mis-management of internal memory!"); + } + /* TODO: arrays. Requires numeric parsing for the index. */ + else + { + return CSON_RC_NotFoundError; + } + } + assert( i == tokenCount ); + return CSON_RC_NotFoundError; + } +} + +cson_value * cson_object_get_sub( cson_object const * obj, char const * path, char sep ) +{ + cson_value * v = NULL; + cson_object_fetch_sub( obj, &v, path, sep ); + return v; +} + +cson_value * cson_object_get_sub2( cson_object const * obj, char const * path ) +{ + cson_value * v = NULL; + cson_object_fetch_sub2( obj, &v, path ); + return v; +} + + +/** + If v is-a Object or Array then this function returns a deep + clone, otherwise it returns v. In either case, the refcount + of the returned value is increased by 1 by this call. +*/ +static cson_value * cson_value_clone_ref( cson_value * v ) +{ + cson_value * rc = NULL; +#define TRY_SHARING 1 +#if TRY_SHARING + if(!v ) return rc; + else if( cson_value_is_object(v) + || cson_value_is_array(v)) + { + rc = cson_value_clone( v ); + } + else + { + rc = v; + } +#else + rc = cson_value_clone(v); +#endif +#undef TRY_SHARING + cson_value_add_reference(rc); + return rc; +} + +static cson_value * cson_value_clone_array( cson_value const * orig ) +{ + unsigned int i = 0; + cson_array const * asrc = cson_value_get_array( orig ); + unsigned int alen = cson_array_length_get( asrc ); + cson_value * destV = NULL; + cson_array * destA = NULL; + assert( orig && asrc ); + destV = cson_value_new_array(); + if( NULL == destV ) return NULL; + destA = cson_value_get_array( destV ); + assert( destA ); + if( 0 != cson_array_reserve( destA, alen ) ) + { + cson_value_free( destV ); + return NULL; + } + for( ; i < alen; ++i ) + { + cson_value * ch = cson_array_get( asrc, i ); + if( NULL != ch ) + { + cson_value * cl = cson_value_clone_ref( ch ); + if( NULL == cl ) + { + cson_value_free( destV ); + return NULL; + } + if( 0 != cson_array_set( destA, i, cl ) ) + { + cson_value_free( cl ); + cson_value_free( destV ); + return NULL; + } + cson_value_free(cl)/*remove our artificial reference */; + } + } + return destV; +} + +static cson_value * cson_value_clone_object( cson_value const * orig ) +{ + cson_object const * src = cson_value_get_object( orig ); + cson_value * destV = NULL; + cson_object * dest = NULL; + cson_kvp const * kvp = NULL; + cson_object_iterator iter = cson_object_iterator_empty; + assert( orig && src ); + if( 0 != cson_object_iter_init( src, &iter ) ) + { + return NULL; + } + destV = cson_value_new_object(); + if( NULL == destV ) return NULL; + dest = cson_value_get_object( destV ); + assert( dest ); + if( src->kvp.count > cson_kvp_list_reserve( &dest->kvp, src->kvp.count ) ){ + cson_value_free( destV ); + return NULL; + } + while( (kvp = cson_object_iter_next( &iter )) ) + { + cson_value * key = NULL; + cson_value * val = NULL; + assert( kvp->key && (kvp->key->refcount>0) ); + key = cson_value_clone_ref(kvp->key); + val = key ? cson_value_clone_ref(kvp->value) : NULL; + if( ! key || !val ){ + goto error; + } + assert( CSON_STR(key) ); + if( 0 != cson_object_set_s( dest, CSON_STR(key), val ) ) + { + goto error; + } + /* remove our references */ + cson_value_free(key); + cson_value_free(val); + continue; + error: + cson_value_free(key); + cson_value_free(val); + cson_value_free(destV); + destV = NULL; + break; + } + return destV; +} + +cson_value * cson_value_clone( cson_value const * orig ) +{ + if( NULL == orig ) return NULL; + else + { + switch( orig->api->typeID ) + { + case CSON_TYPE_UNDEF: + assert(0 && "This should never happen."); + return NULL; + case CSON_TYPE_NULL: + return cson_value_null(); + case CSON_TYPE_BOOL: + return cson_value_new_bool( cson_value_get_bool( orig ) ); + case CSON_TYPE_INTEGER: + return cson_value_new_integer( cson_value_get_integer( orig ) ); + break; + case CSON_TYPE_DOUBLE: + return cson_value_new_double( cson_value_get_double( orig ) ); + break; + case CSON_TYPE_STRING: { + cson_string const * str = cson_value_get_string( orig ); + return cson_value_new_string( cson_string_cstr( str ), + cson_string_length_bytes( str ) ); + } + case CSON_TYPE_ARRAY: + return cson_value_clone_array( orig ); + case CSON_TYPE_OBJECT: + return cson_value_clone_object( orig ); + } + assert( 0 && "We can't get this far." ); + return NULL; + } +} + +cson_value * cson_string_value(cson_string const * s) +{ +#define MT CSON_SPECIAL_VALUES[CSON_VAL_STR_EMPTY] + return s + ? ((s==MT.value) ? &MT : CSON_VCAST(s)) + : NULL; +#undef MT +} + +cson_value * cson_object_value(cson_object const * s) +{ + return s + ? CSON_VCAST(s) + : NULL; +} + + +cson_value * cson_array_value(cson_array const * s) +{ + return s + ? CSON_VCAST(s) + : NULL; +} + +void cson_free_object(cson_object *x) +{ + if(x) cson_value_free(cson_object_value(x)); +} +void cson_free_array(cson_array *x) +{ + if(x) cson_value_free(cson_array_value(x)); +} + +void cson_free_string(cson_string *x) +{ + if(x) cson_value_free(cson_string_value(x)); +} +void cson_free_value(cson_value *x) +{ + if(x) cson_value_free(x); +} + + +#if 0 +/* i'm not happy with this... */ +char * cson_pod_to_string( cson_value const * orig ) +{ + if( ! orig ) return NULL; + else + { + enum { BufSize = 64 }; + char * v = NULL; + switch( orig->api->typeID ) + { + case CSON_TYPE_BOOL: { + char const bv = cson_value_get_bool(orig); + v = cson_strdup( bv ? "true" : "false", + bv ? 4 : 5 ); + break; + } + case CSON_TYPE_UNDEF: + case CSON_TYPE_NULL: { + v = cson_strdup( "null", 4 ); + break; + } + case CSON_TYPE_STRING: { + cson_string const * jstr = cson_value_get_string(orig); + unsigned const int slen = cson_string_length_bytes( jstr ); + assert( NULL != jstr ); + v = cson_strdup( cson_string_cstr( jstr ), slen ); + break; + } + case CSON_TYPE_INTEGER: { + char buf[BufSize] = {0}; + if( 0 < snprintf( v, (size_t)BufSize, "%"CSON_INT_T_PFMT, + cson_value_get_integer(orig)) ) + { + v = cson_strdup( buf, strlen(buf) ); + } + break; + } + case CSON_TYPE_DOUBLE: { + char buf[BufSize] = {0}; + if( 0 < snprintf( v, (size_t)BufSize, "%"CSON_DOUBLE_T_PFMT, + cson_value_get_double(orig)) ) + { + v = cson_strdup( buf, strlen(buf) ); + } + break; + } + default: + break; + } + return v; + } +} +#endif + +#if 0 +/* i'm not happy with this... */ +char * cson_pod_to_string( cson_value const * orig ) +{ + if( ! orig ) return NULL; + else + { + enum { BufSize = 64 }; + char * v = NULL; + switch( orig->api->typeID ) + { + case CSON_TYPE_BOOL: { + char const bv = cson_value_get_bool(orig); + v = cson_strdup( bv ? "true" : "false", + bv ? 4 : 5 ); + break; + } + case CSON_TYPE_UNDEF: + case CSON_TYPE_NULL: { + v = cson_strdup( "null", 4 ); + break; + } + case CSON_TYPE_STRING: { + cson_string const * jstr = cson_value_get_string(orig); + unsigned const int slen = cson_string_length_bytes( jstr ); + assert( NULL != jstr ); + v = cson_strdup( cson_string_cstr( jstr ), slen ); + break; + } + case CSON_TYPE_INTEGER: { + char buf[BufSize] = {0}; + if( 0 < snprintf( v, (size_t)BufSize, "%"CSON_INT_T_PFMT, + cson_value_get_integer(orig)) ) + { + v = cson_strdup( buf, strlen(buf) ); + } + break; + } + case CSON_TYPE_DOUBLE: { + char buf[BufSize] = {0}; + if( 0 < snprintf( v, (size_t)BufSize, "%"CSON_DOUBLE_T_PFMT, + cson_value_get_double(orig)) ) + { + v = cson_strdup( buf, strlen(buf) ); + } + break; + } + default: + break; + } + return v; + } +} +#endif + +unsigned int cson_value_msize(cson_value const * v) +{ + if(!v) return 0; + else if( cson_value_is_builtin(v) ) return 0; + else { + unsigned int rc = sizeof(cson_value); + assert(NULL != v->api); + switch(v->api->typeID){ + case CSON_TYPE_INTEGER: + assert( v != &CSON_SPECIAL_VALUES[CSON_VAL_INT_0]); + rc += sizeof(cson_int_t); + break; + case CSON_TYPE_DOUBLE: + assert( v != &CSON_SPECIAL_VALUES[CSON_VAL_DBL_0]); + rc += sizeof(cson_double_t); + break; + case CSON_TYPE_STRING: + rc += sizeof(cson_string) + + CSON_STR(v)->length + 1/*NUL*/; + break; + case CSON_TYPE_ARRAY:{ + cson_array const * ar = CSON_ARRAY(v); + cson_value_list const * li; + unsigned int i = 0; + assert( NULL != ar ); + li = &ar->list; + rc += sizeof(cson_array) + + (li->alloced * sizeof(cson_value *)); + for( ; i < li->count; ++i ){ + cson_value const * e = ar->list.list[i]; + if( e ) rc += cson_value_msize( e ); + } + break; + } + case CSON_TYPE_OBJECT:{ + cson_object const * obj = CSON_OBJ(v); + unsigned int i = 0; + cson_kvp_list const * kl; + assert(NULL != obj); + kl = &obj->kvp; + rc += sizeof(cson_object) + + (kl->alloced * sizeof(cson_kvp*)); + for( ; i < kl->count; ++i ){ + cson_kvp const * kvp = kl->list[i]; + assert(NULL != kvp); + rc += cson_value_msize(kvp->key); + rc += cson_value_msize(kvp->value); + } + break; + } + case CSON_TYPE_UNDEF: + case CSON_TYPE_NULL: + case CSON_TYPE_BOOL: + assert( 0 && "Should have been caught by is-builtin check!" ); + break; + default: + assert(0 && "Invalid typeID!"); + return 0; +#undef RCCHECK + } + return rc; + } +} + +int cson_object_merge( cson_object * dest, cson_object const * src, int flags ){ + cson_object_iterator iter = cson_object_iterator_empty; + int rc; + char const replace = (flags & CSON_MERGE_REPLACE); + char const recurse = !(flags & CSON_MERGE_NO_RECURSE); + cson_kvp const * kvp; + if((!dest || !src) || (dest==src)) return CSON_RC_ArgError; + rc = cson_object_iter_init( src, &iter ); + if(rc) return rc; + while( (kvp = cson_object_iter_next(&iter) ) ) + { + cson_string * key = cson_kvp_key(kvp); + cson_value * val = cson_kvp_value(kvp); + cson_value * check = cson_object_get_s( dest, key ); + if(!check){ + cson_object_set_s( dest, key, val ); + continue; + } + else if(!replace && !recurse) continue; + else if(replace && !recurse){ + cson_object_set_s( dest, key, val ); + continue; + } + else if( recurse ){ + if( cson_value_is_object(check) && + cson_value_is_object(val) ){ + rc = cson_object_merge( cson_value_get_object(check), + cson_value_get_object(val), + flags ); + if(rc) return rc; + else continue; + } + else continue; + } + else continue; + } + return 0; +} + +static cson_value * cson_guess_arg_type(char const *arg){ + char * end = NULL; + if(!arg || !*arg) return cson_value_null(); + else if(('0'>*arg) || ('9'<*arg)){ + goto do_string; + } + else{ /* try numbers... */ + long const val = strtol(arg, &end, 10); + if(!*end){ + return cson_value_new_integer( (cson_int_t)val); + } + else if( '.' != *end ) { + goto do_string; + } + else { + double const val = strtod(arg, &end); + if(!*end){ + return cson_value_new_double(val); + } + } + } + do_string: + return cson_value_new_string(arg, strlen(arg)); +} + + +int cson_parse_argv_flags( int argc, char const * const * argv, + cson_object ** tgt, unsigned int * count ){ + cson_object * o = NULL; + int rc = 0; + int i = 0; + if(argc<1 || !argc || !tgt) return CSON_RC_ArgError; + o = *tgt ? *tgt : cson_new_object(); + if(count) *count = 0; + for( i = 0; i < argc; ++i ){ + char const * arg = argv[i]; + char const * key = arg; + char const * pos; + cson_string * k = NULL; + cson_value * v = NULL; + if('-' != *arg) continue; + while('-'==*key) ++key; + if(!*key) continue; + pos = key; + while( *pos && ('=' != *pos)) ++pos; + k = cson_new_string(key, pos-key); + if(!k){ + rc = CSON_RC_AllocError; + break; + } + if(!*pos){ /** --key */ + v = cson_value_true(); + }else{ /** --key=...*/ + assert('=' == *pos); + ++pos /*skip '='*/; + v = cson_guess_arg_type(pos); + } + if(0 != (rc=cson_object_set_s(o, k, v))){ + cson_free_string(k); + cson_value_free(v); + break; + } + else if(count) ++*count; + } + if(o != *tgt){ + if(rc) cson_free_object(o); + else *tgt = o; + } + return rc; +} + +#if defined(__cplusplus) +} /*extern "C"*/ +#endif + +#undef MARKER +#undef CSON_OBJECT_PROPS_SORT +#undef CSON_OBJECT_PROPS_SORT_USE_LENGTH +#undef CSON_CAST +#undef CSON_INT +#undef CSON_DBL +#undef CSON_STR +#undef CSON_OBJ +#undef CSON_ARRAY +#undef CSON_VCAST +#undef CSON_MALLOC_IMPL +#undef CSON_FREE_IMPL +#undef CSON_REALLOC_IMPL +/* end file ./cson.c */ +/* begin file ./cson_lists.h */ +/* Auto-generated from cson_list.h. Edit at your own risk! */ +unsigned int cson_value_list_reserve( cson_value_list * self, unsigned int n ) +{ + if( !self ) return 0; + else if(0 == n) + { + if(0 == self->alloced) return 0; + cson_free(self->list, "cson_value_list_reserve"); + self->list = NULL; + self->alloced = self->count = 0; + return 0; + } + else if( self->alloced >= n ) + { + return self->alloced; + } + else + { + size_t const sz = sizeof(cson_value *) * n; + cson_value * * m = (cson_value **)cson_realloc( self->list, sz, "cson_value_list_reserve" ); + if( ! m ) return self->alloced; + + memset( m + self->alloced, 0, (sizeof(cson_value *)*(n-self->alloced))); + self->alloced = n; + self->list = m; + return n; + } +} +int cson_value_list_append( cson_value_list * self, cson_value * cp ) +{ + if( !self || !cp ) return cson_rc.ArgError; + else if( self->alloced > cson_value_list_reserve(self, self->count+1) ) + { + return cson_rc.AllocError; + } + else + { + self->list[self->count++] = cp; + return 0; + } +} +int cson_value_list_visit( cson_value_list * self, + + int (*visitor)(cson_value * obj, void * visitorState ), + + + + void * visitorState ) +{ + int rc = cson_rc.ArgError; + if( self && visitor ) + { + unsigned int i = 0; + for( rc = 0; (i < self->count) && (0 == rc); ++i ) + { + + cson_value * obj = self->list[i]; + + + + if(obj) rc = visitor( obj, visitorState ); + } + } + return rc; +} +void cson_value_list_clean( cson_value_list * self, + + void (*cleaner)(cson_value * obj) + + + + ) +{ + if( self && cleaner && self->count ) + { + unsigned int i = 0; + for( ; i < self->count; ++i ) + { + + cson_value * obj = self->list[i]; + + + + if(obj) cleaner(obj); + } + } + cson_value_list_reserve(self,0); +} +unsigned int cson_kvp_list_reserve( cson_kvp_list * self, unsigned int n ) +{ + if( !self ) return 0; + else if(0 == n) + { + if(0 == self->alloced) return 0; + cson_free(self->list, "cson_kvp_list_reserve"); + self->list = NULL; + self->alloced = self->count = 0; + return 0; + } + else if( self->alloced >= n ) + { + return self->alloced; + } + else + { + size_t const sz = sizeof(cson_kvp *) * n; + cson_kvp * * m = (cson_kvp **)cson_realloc( self->list, sz, "cson_kvp_list_reserve" ); + if( ! m ) return self->alloced; + + memset( m + self->alloced, 0, (sizeof(cson_kvp *)*(n-self->alloced))); + self->alloced = n; + self->list = m; + return n; + } +} +int cson_kvp_list_append( cson_kvp_list * self, cson_kvp * cp ) +{ + if( !self || !cp ) return cson_rc.ArgError; + else if( self->alloced > cson_kvp_list_reserve(self, self->count+1) ) + { + return cson_rc.AllocError; + } + else + { + self->list[self->count++] = cp; + return 0; + } +} +int cson_kvp_list_visit( cson_kvp_list * self, + + int (*visitor)(cson_kvp * obj, void * visitorState ), + + + + void * visitorState ) +{ + int rc = cson_rc.ArgError; + if( self && visitor ) + { + unsigned int i = 0; + for( rc = 0; (i < self->count) && (0 == rc); ++i ) + { + + cson_kvp * obj = self->list[i]; + + + + if(obj) rc = visitor( obj, visitorState ); + } + } + return rc; +} +void cson_kvp_list_clean( cson_kvp_list * self, + + void (*cleaner)(cson_kvp * obj) + + + + ) +{ + if( self && cleaner && self->count ) + { + unsigned int i = 0; + for( ; i < self->count; ++i ) + { + + cson_kvp * obj = self->list[i]; + + + + if(obj) cleaner(obj); + } + } + cson_kvp_list_reserve(self,0); +} +/* end file ./cson_lists.h */ +/* begin file ./cson_sqlite3.c */ +/** @file cson_sqlite3.c + +This file contains the implementation code for the cson +sqlite3-to-JSON API. + +License: the same as the cson core library. + +Author: Stephan Beal (http://wanderinghorse.net/home/stephan) +*/ +#if CSON_ENABLE_SQLITE3 /* we do this here for the sake of the amalgamation build */ +#include +#include /* strlen() */ + +#if 0 +#include +#define MARKER if(1) printf("MARKER: %s:%d:%s():\t",__FILE__,__LINE__,__func__); if(1) printf +#else +#define MARKER if(0) printf +#endif + +#if defined(__cplusplus) +extern "C" { +#endif + +cson_value * cson_sqlite3_column_to_value( sqlite3_stmt * st, int col ) +{ + if( ! st ) return NULL; + else + { +#if 0 + sqlite3_value * val = sqlite3_column_type(st,col); + int const vtype = val ? sqlite3_value_type(val) : -1; + if( ! val ) return cson_value_null(); +#else + int const vtype = sqlite3_column_type(st,col); +#endif + switch( vtype ) + { + case SQLITE_NULL: + return cson_value_null(); + case SQLITE_INTEGER: + /* FIXME: for large integers fall back to Double instead. */ + return cson_value_new_integer( (cson_int_t) sqlite3_column_int64(st, col) ); + case SQLITE_FLOAT: + return cson_value_new_double( sqlite3_column_double(st, col) ); + case SQLITE_BLOB: /* arguably fall through... */ + case SQLITE_TEXT: { + char const * str = (char const *)sqlite3_column_text(st,col); + return cson_value_new_string(str, str ? strlen(str) : 0); + } + default: + return NULL; + } + } +} + +cson_value * cson_sqlite3_column_names( sqlite3_stmt * st ) +{ + cson_value * aryV = NULL; + cson_array * ary = NULL; + char const * colName = NULL; + int i = 0; + int rc = 0; + int colCount = 0; + assert(st); + colCount = sqlite3_column_count(st); + if( colCount <= 0 ) return NULL; + + aryV = cson_value_new_array(); + if( ! aryV ) return NULL; + ary = cson_value_get_array(aryV); + assert(ary); + for( i = 0; (0 ==rc) && (i < colCount); ++i ) + { + colName = sqlite3_column_name( st, i ); + if( ! colName ) rc = cson_rc.AllocError; + else + { + rc = cson_array_set( ary, (unsigned int)i, + cson_value_new_string(colName, strlen(colName)) ); + } + } + if( 0 == rc ) return aryV; + else + { + cson_value_free(aryV); + return NULL; + } +} + + +cson_value * cson_sqlite3_row_to_object2( sqlite3_stmt * st, + cson_array * colNames ) +{ + cson_value * rootV = NULL; + cson_object * root = NULL; + cson_string * colName = NULL; + int i = 0; + int rc = 0; + cson_value * currentValue = NULL; + int const colCount = sqlite3_column_count(st); + if( !colCount || (colCount>cson_array_length_get(colNames)) ) { + return NULL; + } + rootV = cson_value_new_object(); + if(!rootV) return NULL; + root = cson_value_get_object(rootV); + for( i = 0; i < colCount; ++i ) + { + colName = cson_value_get_string( cson_array_get( colNames, i ) ); + if( ! colName ) goto error; + currentValue = cson_sqlite3_column_to_value(st,i); + if( ! currentValue ) currentValue = cson_value_null(); + rc = cson_object_set_s( root, colName, currentValue ); + if( 0 != rc ) + { + cson_value_free( currentValue ); + goto error; + } + } + goto end; + error: + cson_value_free( rootV ); + rootV = NULL; + end: + return rootV; +} + + +cson_value * cson_sqlite3_row_to_object( sqlite3_stmt * st ) +{ +#if 0 + cson_value * arV = cson_sqlite3_column_names(st); + cson_array * ar = NULL; + cson_value * rc = NULL; + if(!arV) return NULL; + ar = cson_value_get_array(arV); + assert( NULL != ar ); + rc = cson_sqlite3_row_to_object2(st, ar); + cson_value_free(arV); + return rc; +#else + cson_value * rootV = NULL; + cson_object * root = NULL; + char const * colName = NULL; + int i = 0; + int rc = 0; + cson_value * currentValue = NULL; + int const colCount = sqlite3_column_count(st); + if( !colCount ) return NULL; + rootV = cson_value_new_object(); + if(!rootV) return NULL; + root = cson_value_get_object(rootV); + for( i = 0; i < colCount; ++i ) + { + colName = sqlite3_column_name( st, i ); + if( ! colName ) goto error; + currentValue = cson_sqlite3_column_to_value(st,i); + if( ! currentValue ) currentValue = cson_value_null(); + rc = cson_object_set( root, colName, currentValue ); + if( 0 != rc ) + { + cson_value_free( currentValue ); + goto error; + } + } + goto end; + error: + cson_value_free( rootV ); + rootV = NULL; + end: + return rootV; +#endif +} + +cson_value * cson_sqlite3_row_to_array( sqlite3_stmt * st ) +{ + cson_value * aryV = NULL; + cson_array * ary = NULL; + int i = 0; + int rc = 0; + int const colCount = sqlite3_column_count(st); + if( ! colCount ) return NULL; + aryV = cson_value_new_array(); + if( ! aryV ) return NULL; + ary = cson_value_get_array(aryV); + rc = cson_array_reserve(ary, (unsigned int) colCount ); + if( 0 != rc ) goto error; + + for( i = 0; i < colCount; ++i ){ + cson_value * elem = cson_sqlite3_column_to_value(st,i); + if( ! elem ) goto error; + rc = cson_array_append(ary,elem); + if(0!=rc) + { + cson_value_free( elem ); + goto end; + } + } + goto end; + error: + cson_value_free(aryV); + aryV = NULL; + end: + return aryV; +} + + +/** + Internal impl of cson_sqlite3_stmt_to_json() when the 'fat' + parameter is non-0. +*/ +static int cson_sqlite3_stmt_to_json_fat( sqlite3_stmt * st, cson_value ** tgt ) +{ +#define RETURN(RC) { if(rootV) cson_value_free(rootV); return RC; } + if( ! tgt || !st ) return cson_rc.ArgError; + else + { + cson_value * rootV = NULL; + cson_object * root = NULL; + cson_value * colsV = NULL; + cson_array * cols = NULL; + cson_value * rowsV = NULL; + cson_array * rows = NULL; + cson_value * objV = NULL; + int rc = 0; + int const colCount = sqlite3_column_count(st); + if( colCount <= 0 ) return cson_rc.ArgError; + rootV = cson_value_new_object(); + if( ! rootV ) return cson_rc.AllocError; + colsV = cson_sqlite3_column_names(st); + if( ! colsV ) + { + cson_value_free( rootV ); + RETURN(cson_rc.AllocError); + } + cols = cson_value_get_array(colsV); + assert(NULL != cols); + root = cson_value_get_object(rootV); + rc = cson_object_set( root, "columns", colsV ); + if( rc ) + { + cson_value_free( colsV ); + RETURN(rc); + } + rowsV = cson_value_new_array(); + if( ! rowsV ) RETURN(cson_rc.AllocError); + rc = cson_object_set( root, "rows", rowsV ); + if( rc ) + { + cson_value_free( rowsV ); + RETURN(rc); + } + rows = cson_value_get_array(rowsV); + assert(rows); + while( SQLITE_ROW == sqlite3_step(st) ) + { + objV = cson_sqlite3_row_to_object2(st, cols); + if( ! objV ) RETURN(cson_rc.UnknownError); + rc = cson_array_append( rows, objV ); + if( rc ) + { + cson_value_free( objV ); + RETURN(rc); + } + } + *tgt = rootV; + return 0; + } +#undef RETURN +} + +/** + Internal impl of cson_sqlite3_stmt_to_json() when the 'fat' + parameter is 0. +*/ +static int cson_sqlite3_stmt_to_json_slim( sqlite3_stmt * st, cson_value ** tgt ) +{ +#define RETURN(RC) { if(rootV) cson_value_free(rootV); return RC; } + if( ! tgt || !st ) return cson_rc.ArgError; + else + { + cson_value * rootV = NULL; + cson_object * root = NULL; + cson_value * aryV = NULL; + cson_value * rowsV = NULL; + cson_array * rows = NULL; + int rc = 0; + int const colCount = sqlite3_column_count(st); + if( colCount <= 0 ) return cson_rc.ArgError; + rootV = cson_value_new_object(); + if( ! rootV ) return cson_rc.AllocError; + aryV = cson_sqlite3_column_names(st); + if( ! aryV ) + { + cson_value_free( rootV ); + RETURN(cson_rc.AllocError); + } + root = cson_value_get_object(rootV); + rc = cson_object_set( root, "columns", aryV ); + if( rc ) + { + cson_value_free( aryV ); + RETURN(rc); + } + aryV = NULL; + rowsV = cson_value_new_array(); + if( ! rowsV ) RETURN(cson_rc.AllocError); + rc = cson_object_set( root, "rows", rowsV ); + if( 0 != rc ) + { + cson_value_free( rowsV ); + RETURN(rc); + } + rows = cson_value_get_array(rowsV); + assert(rows); + while( SQLITE_ROW == sqlite3_step(st) ) + { + aryV = cson_sqlite3_row_to_array(st); + if( ! aryV ) RETURN(cson_rc.UnknownError); + rc = cson_array_append( rows, aryV ); + if( 0 != rc ) + { + cson_value_free( aryV ); + RETURN(rc); + } + } + *tgt = rootV; + return 0; + } +#undef RETURN +} + +int cson_sqlite3_stmt_to_json( sqlite3_stmt * st, cson_value ** tgt, char fat ) +{ + return fat + ? cson_sqlite3_stmt_to_json_fat(st,tgt) + : cson_sqlite3_stmt_to_json_slim(st,tgt) + ; +} + +int cson_sqlite3_sql_to_json( sqlite3 * db, cson_value ** tgt, char const * sql, char fat ) +{ + if( !db || !tgt || !sql || !*sql ) return cson_rc.ArgError; + else + { + sqlite3_stmt * st = NULL; + int rc = sqlite3_prepare_v2( db, sql, -1, &st, NULL ); + if( 0 != rc ) return cson_rc.IOError /* FIXME: Better error code? */; + rc = cson_sqlite3_stmt_to_json( st, tgt, fat ); + sqlite3_finalize( st ); + return rc; + } +} + +int cson_sqlite3_bind_value( sqlite3_stmt * st, int ndx, cson_value const * v ) +{ + int rc = 0; + char convertErr = 0; + if(!st) return cson_rc.ArgError; + else if( ndx < 1 ) { + rc = cson_rc.RangeError; + } + else if( cson_value_is_array(v) ){ + cson_array * ar = cson_value_get_array(v); + unsigned int len = cson_array_length_get(ar); + unsigned int i; + assert(NULL != ar); + for( i = 0; !rc && (i < len); ++i ){ + rc = cson_sqlite3_bind_value( st, (int)i+ndx, + cson_array_get(ar, i)); + } + } + else if(!v || cson_value_is_null(v)){ + rc = sqlite3_bind_null(st,ndx); + convertErr = 1; + } + else if( cson_value_is_double(v) ){ + rc = sqlite3_bind_double( st, ndx, cson_value_get_double(v) ); + convertErr = 1; + } + else if( cson_value_is_bool(v) ){ + rc = sqlite3_bind_int( st, ndx, cson_value_get_bool(v) ? 1 : 0 ); + convertErr = 1; + } + else if( cson_value_is_integer(v) ){ + rc = sqlite3_bind_int64( st, ndx, cson_value_get_integer(v) ); + convertErr = 1; + } + else if( cson_value_is_string(v) ){ + cson_string const * s = cson_value_get_string(v); + rc = sqlite3_bind_text( st, ndx, + cson_string_cstr(s), + cson_string_length_bytes(s), + SQLITE_TRANSIENT); + convertErr = 1; + } + else { + rc = cson_rc.TypeError; + } + if(convertErr && rc) switch(rc){ + case SQLITE_TOOBIG: + case SQLITE_RANGE: rc = cson_rc.RangeError; break; + case SQLITE_NOMEM: rc = cson_rc.AllocError; break; + case SQLITE_IOERR: rc = cson_rc.IOError; break; + default: rc = cson_rc.UnknownError; break; + }; + return rc; +} + + +#if defined(__cplusplus) +} /*extern "C"*/ +#endif +#undef MARKER +#endif /* CSON_ENABLE_SQLITE3 */ +/* end file ./cson_sqlite3.c */ +#endif /* FOSSIL_ENABLE_JSON */ diff --git a/extsrc/cson_amalgamation.h b/extsrc/cson_amalgamation.h new file mode 100644 index 0000000..7634b18 --- /dev/null +++ b/extsrc/cson_amalgamation.h @@ -0,0 +1,2871 @@ +#ifdef FOSSIL_ENABLE_JSON +#ifndef CSON_FOSSIL_MODE +#define CSON_FOSSIL_MODE +#endif +/* auto-generated! Do not edit! */ +/* begin file include/wh/cson/cson.h */ +#if !defined(WANDERINGHORSE_NET_CSON_H_INCLUDED) +#define WANDERINGHORSE_NET_CSON_H_INCLUDED 1 + +/*#include C99: fixed-size int types. */ +#include /* FILE decl */ + +#include + +/** @page page_cson cson JSON API + +cson (pronounced "season") is an object-oriented C API for generating +and consuming JSON (http://www.json.org) data. + +Its main claim to fame is that it can parse JSON from, and output it +to, damned near anywhere. The i/o routines use a callback function to +fetch/emit JSON data, allowing clients to easily plug in their own +implementations. Implementations are provided for string- and +FILE-based i/o. + +Project home page: https://fossil.wanderinghorse.net/r/cson + +Author: Stephan Beal (https://www.wanderinghorse.net/home/stephan/) + +License: Dual Public Domain/MIT + +The full license text is at the bottom of the main header file +(cson.h). + +Examples of how to use the library are scattered throughout +the API documentation, in the test.c file in the source repo, +and in the wiki on the project's home page. +*/ + +#if defined(__cplusplus) +extern "C" { +#endif + +#if defined(_WIN32) || defined(_WIN64) +# define CSON_ENABLE_UNIX 0 +#else +# define CSON_ENABLE_UNIX 1 +#endif + + +/** @typedef some_long_int_type cson_int_t + +Typedef for JSON-like integer types. This is (long long) where feasible, +otherwise (long). +*/ +#ifdef _WIN32 +typedef __int64 cson_int_t; +#define CSON_INT_T_SFMT "I64d" +#define CSON_INT_T_PFMT "I64d" +#elif (__STDC_VERSION__ >= 199901L) || (HAVE_LONG_LONG == 1) +typedef long long cson_int_t; +#define CSON_INT_T_SFMT "lld" +#define CSON_INT_T_PFMT "lld" +#else +typedef long cson_int_t; +#define CSON_INT_T_SFMT "ld" +#define CSON_INT_T_PFMT "ld" +#endif + +/** @typedef double_or_long_double cson_double_t + + This is the type of double value used by the library. + It is only lightly tested with long double, and when using + long double the memory requirements for such values goes + up. + + Note that by default cson uses C-API defaults for numeric + precision. To use a custom precision throughout the library, one + needs to define the macros CSON_DOUBLE_T_SFMT and/or + CSON_DOUBLE_T_PFMT macros to include their desired precision, and + must build BOTH cson AND the client using these same values. For + example: + + @code + #define CSON_DOUBLE_T_PFMT ".8Lf" // for Modified Julian Day values + #define HAVE_LONG_DOUBLE + @endcode + + (Only CSON_DOUBLE_T_PFTM should be needed for most + purposes.) +*/ + +#if defined(HAVE_LONG_DOUBLE) + typedef long double cson_double_t; +# ifndef CSON_DOUBLE_T_SFMT +# define CSON_DOUBLE_T_SFMT "Lf" +# endif +# ifndef CSON_DOUBLE_T_PFMT +# define CSON_DOUBLE_T_PFMT "Lf" +# endif +#else + typedef double cson_double_t; +# ifndef CSON_DOUBLE_T_SFMT +# define CSON_DOUBLE_T_SFMT "f" +# endif +# ifndef CSON_DOUBLE_T_PFMT +# define CSON_DOUBLE_T_PFMT "f" +# endif +#endif + +/** @def CSON_VOID_PTR_IS_BIG + +ONLY define this to a true value if you know that + +(sizeof(cson_int_t) <= sizeof(void*)) + +If that is the case, cson does not need to dynamically +allocate integers. However, enabling this may cause +compilation warnings in 32-bit builds even though the code +being warned about cannot ever be called. To get around such +warnings, when building on a 64-bit environment you can define +this to 1 to get "big" integer support. HOWEVER, all clients must +also use the same value for this macro. If i knew a halfway reliable +way to determine this automatically at preprocessor-time, i would +automate this. We might be able to do halfway reliably by looking +for a large INT_MAX value? +*/ +#if !defined(CSON_VOID_PTR_IS_BIG) + +/* Largely taken from http://predef.sourceforge.net/prearch.html + +See also: http://poshlib.hookatooka.com/poshlib/trac.cgi/browser/posh.h +*/ +# if defined(_WIN64) || defined(__LP64__)/*gcc*/ \ + || defined(_M_X64) || defined(__amd64__) || defined(__amd64) \ + || defined(__x86_64__) || defined(__x86_64) \ + || defined(__ia64__) || defined(__ia64) || defined(_IA64) || defined(__IA64__) \ + || defined(_M_IA64) \ + || defined(__sparc_v9__) || defined(__sparcv9) || defined(_ADDR64) \ + || defined(__64BIT__) +# define CSON_VOID_PTR_IS_BIG 1 +# else +# define CSON_VOID_PTR_IS_BIG 0 +# endif +#endif + +/** @def CSON_INT_T_SFMT + +scanf()-compatible format token for cson_int_t. +*/ + +/** @def CSON_INT_T_PFMT + +printf()-compatible format token for cson_int_t. +*/ + + +/** @def CSON_DOUBLE_T_SFMT + +scanf()-compatible format token for cson_double_t. +*/ + +/** @def CSON_DOUBLE_T_PFMT + +printf()-compatible format token for cson_double_t. +*/ + +/** + Type IDs corresponding to JavaScript/JSON types. + + These are only in the public API to allow O(1) client-side + dispatching based on cson_value types. +*/ +enum cson_type_id { + /** + The special "undefined" value constant. + + Its value must be 0 for internal reasons. + */ + CSON_TYPE_UNDEF = 0, + /** + The special "null" value constant. + */ + CSON_TYPE_NULL = 1, + /** + The bool value type. + */ + CSON_TYPE_BOOL = 2, + /** + The integer value type, represented in this library + by cson_int_t. + */ + CSON_TYPE_INTEGER = 3, + /** + The double value type, represented in this library + by cson_double_t. + */ + CSON_TYPE_DOUBLE = 4, + /** The immutable string type. This library stores strings + as immutable UTF8. + */ + CSON_TYPE_STRING = 5, + /** The "Array" type. */ + CSON_TYPE_ARRAY = 6, + /** The "Object" type. */ + CSON_TYPE_OBJECT = 7 +}; +/** + Convenience typedef. +*/ +typedef enum cson_type_id cson_type_id; + + +/** + Convenience typedef. +*/ +typedef struct cson_value cson_value; + +/** @struct cson_value + + The core value type of this API. It is opaque to clients, and + only the cson public API should be used for setting or + inspecting their values. + + This class is opaque because stack-based usage can easily cause + leaks if one does not intimately understand the underlying + internal memory management (which sometimes changes). + + It is (as of 20110323) legal to insert a given value instance into + multiple containers (they will share ownership using reference + counting) as long as those insertions do not cause cycles. However, + be very aware that such value re-use uses a reference to the + original copy, meaning that if its value is changed once, it is + changed everywhere. Also beware that multi-threaded write + operations on such references leads to undefined behaviour. + + PLEASE read the ACHTUNGEN below... + + ACHTUNG #1: + + cson_values MUST NOT form cycles (e.g. via object or array + entries). + + Not abiding th Holy Law Of No Cycles will lead to double-frees and + the like (i.e. undefined behaviour, likely crashes due to infinite + recursion or stepping on invalid (freed) pointers). + + ACHTUNG #2: + + ALL cson_values returned as non-const cson_value pointers from any + public functions in the cson API are to be treated as if they are + heap-allocated, and MUST be freed by client by doing ONE of: + + - Passing it to cson_value_free(). + + - Adding it to an Object or Array, in which case the object/array + takes over ownership. As of 20110323, a value may be inserted into + a single container multiple times, or into multiple containers, + in which case they all share ownership (via reference counting) + of the original value (meaning any changes to it are visible in + all references to it). + + Each call to cson_value_new_xxx() MUST eventually be followed up + by one of those options. + + Some cson_value_new_XXX() implementations do not actually allocate + memory, but this is an internal implementation detail. Client code + MUST NOT rely on this behaviour and MUST treat each object + returned by such a function as if it was a freshly-allocated copy + (even if their pointer addresses are the same). + + ACHTUNG #3: + + Note that ACHTUNG #2 tells us that we must always free (or transfer + ownership of) all pointers returned bycson_value_new_xxx(), but + that two calls to (e.g.) cson_value_new_bool(1) will (or might) + return the same address. The client must not rely on the + "non-allocation" policy of such special cases, and must pass each + returned value to cson_value_free(), even if two of them have the + same address. Some special values (e.g. null, true, false, integer + 0, double 0.0, and empty strings) use shared copies and in other + places reference counting is used internally to figure out when it + is safe to destroy an object. + + + @see cson_value_new_array() + @see cson_value_new_object() + @see cson_value_new_string() + @see cson_value_new_integer() + @see cson_value_new_double() + @see cson_value_new_bool() + @see cson_value_true() + @see cson_value_false() + @see cson_value_null() + @see cson_value_free() + @see cson_value_type_id() +*/ + +/** @var cson_rc + + Deprecated: clients are encouraged to use the CSON_RC_xxx values + which correspond to cson_rc.xxx, as those are more efficient. Some + docs and code may still refer to cson_rc, though. + + This object defines the error codes used by cson. + + Library routines which return int values almost always return a + value from this structure. None of the members in this struct have + published values except for the OK member, which has the value 0. + All other values might be incidentally defined where clients + can see them, but the numbers might change from release to + release, so clients should only use the symbolic names. + + Client code is expected to access these values via the shared + cson_rc object, and use them as demonstrated here: + + @code + int rc = cson_some_func(...); + if( 0 == rc ) {...success...} + else if( cson_rc.ArgError == rc ) { ... some argument was wrong ... } + else if( cson_rc.AllocError == rc ) { ... allocation error ... } + ... + @endcode + + Or with the preferred/newer method: + + @code + int rc = cson_some_func(...); + switch(rc){ + case 0: ...success...; + case CSON_RC_ArgError: ... some argument was wrong ... + case CSON_RC_AllocError: ... allocation error ... + ... + } + @endcode + + The entries named Parse_XXX are generally only returned by + cson_parse() and friends. + + @deprecated +*/ + +/** + The CSON_RC_xxx values are intended to replace the older + cson_rc.xxx values. +*/ +enum cson_rc_values { + /** The generic success value. Guaranteed to be 0. */ + CSON_RC_OK = 0, + /** Signifies an error in one or more arguments (e.g. NULL where it is not allowed). */ + CSON_RC_ArgError, + /** Signifies that some argument is not in a valid range. */ + CSON_RC_RangeError, + /** Signifies that some argument is not of the correct logical cson type. */ + CSON_RC_TypeError, + /** Signifies an input/ouput error. */ + CSON_RC_IOError, + /** Signifies an out-of-memory error. */ + CSON_RC_AllocError, + /** Signifies that the called code is "NYI" (Not Yet Implemented). */ + CSON_RC_NYIError, + /** Signifies that an internal error was triggered. If it happens, please report this as a bug! */ + CSON_RC_InternalError, + /** Signifies that the called operation is not supported in the + current environment. e.g. missing support from 3rd-party or + platform-specific code. + */ + CSON_RC_UnsupportedError, + /** + Signifies that the request resource could not be found. + */ + CSON_RC_NotFoundError, + /** + Signifies an unknown error, possibly because an underlying + 3rd-party API produced an error and we have no other reasonable + error code to convert it to. + */ + CSON_RC_UnknownError, + /** + Signifies that the parser found an unexpected character. + */ + CSON_RC_Parse_INVALID_CHAR, + /** + Signifies that the parser found an invalid keyword (possibly + an unquoted string). + */ + CSON_RC_Parse_INVALID_KEYWORD, + /** + Signifies that the parser found an invalid escape sequence. + */ + CSON_RC_Parse_INVALID_ESCAPE_SEQUENCE, + /** + Signifies that the parser found an invalid Unicode character + sequence. + */ + CSON_RC_Parse_INVALID_UNICODE_SEQUENCE, + /** + Signifies that the parser found an invalid numeric token. + */ + CSON_RC_Parse_INVALID_NUMBER, + /** + Signifies that the parser reached its maximum defined + parsing depth before finishing the input. + */ + CSON_RC_Parse_NESTING_DEPTH_REACHED, + /** + Signifies that the parser found an unclosed object or array. + */ + CSON_RC_Parse_UNBALANCED_COLLECTION, + /** + Signifies that the parser found an key in an unexpected place. + */ + CSON_RC_Parse_EXPECTED_KEY, + /** + Signifies that the parser expected to find a colon but + found none (e.g. between keys and values in an object). + */ + CSON_RC_Parse_EXPECTED_COLON +}; + +/** @struct cson_rc_ + See \ref cson_rc for details. +*/ +static const struct cson_rc_ +{ + /** The generic success value. Guaranteed to be 0. */ + const int OK; + /** Signifies an error in one or more arguments (e.g. NULL where it is not allowed). */ + const int ArgError; + /** Signifies that some argument is not in a valid range. */ + const int RangeError; + /** Signifies that some argument is not of the correct logical cson type. */ + const int TypeError; + /** Signifies an input/ouput error. */ + const int IOError; + /** Signifies an out-of-memory error. */ + const int AllocError; + /** Signifies that the called code is "NYI" (Not Yet Implemented). */ + const int NYIError; + /** Signifies that an internal error was triggered. If it happens, please report this as a bug! */ + const int InternalError; + /** Signifies that the called operation is not supported in the + current environment. e.g. missing support from 3rd-party or + platform-specific code. + */ + const int UnsupportedError; + /** + Signifies that the request resource could not be found. + */ + const int NotFoundError; + /** + Signifies an unknown error, possibly because an underlying + 3rd-party API produced an error and we have no other reasonable + error code to convert it to. + */ + const int UnknownError; + /** + Signifies that the parser found an unexpected character. + */ + const int Parse_INVALID_CHAR; + /** + Signifies that the parser found an invalid keyword (possibly + an unquoted string). + */ + const int Parse_INVALID_KEYWORD; + /** + Signifies that the parser found an invalid escape sequence. + */ + const int Parse_INVALID_ESCAPE_SEQUENCE; + /** + Signifies that the parser found an invalid Unicode character + sequence. + */ + const int Parse_INVALID_UNICODE_SEQUENCE; + /** + Signifies that the parser found an invalid numeric token. + */ + const int Parse_INVALID_NUMBER; + /** + Signifies that the parser reached its maximum defined + parsing depth before finishing the input. + */ + const int Parse_NESTING_DEPTH_REACHED; + /** + Signifies that the parser found an unclosed object or array. + */ + const int Parse_UNBALANCED_COLLECTION; + /** + Signifies that the parser found an key in an unexpected place. + */ + const int Parse_EXPECTED_KEY; + /** + Signifies that the parser expected to find a colon but + found none (e.g. between keys and values in an object). + */ + const int Parse_EXPECTED_COLON; +} cson_rc = { + CSON_RC_OK, + CSON_RC_ArgError, + CSON_RC_RangeError, + CSON_RC_TypeError, + CSON_RC_IOError, + CSON_RC_AllocError, + CSON_RC_NYIError, + CSON_RC_InternalError, + CSON_RC_UnsupportedError, + CSON_RC_NotFoundError, + CSON_RC_UnknownError, + CSON_RC_Parse_INVALID_CHAR, + CSON_RC_Parse_INVALID_KEYWORD, + CSON_RC_Parse_INVALID_ESCAPE_SEQUENCE, + CSON_RC_Parse_INVALID_UNICODE_SEQUENCE, + CSON_RC_Parse_INVALID_NUMBER, + CSON_RC_Parse_NESTING_DEPTH_REACHED, + CSON_RC_Parse_UNBALANCED_COLLECTION, + CSON_RC_Parse_EXPECTED_KEY, + CSON_RC_Parse_EXPECTED_COLON +}; + +/** + Returns the string form of the cson_rc code corresponding to rc, or + some unspecified, non-NULL string if it is an unknown code. + + The returned bytes are static and do not changing during the + lifetime of the application. +*/ +char const * cson_rc_string(int rc); + +/** @struct cson_parse_opt + Client-configurable options for the cson_parse() family of + functions. +*/ +struct cson_parse_opt +{ + /** + Maximum object/array depth to traverse. + */ + unsigned short maxDepth; + /** + Whether or not to allow C-style comments. Do not rely on this + option being available. If the underlying parser is replaced, + this option might no longer be supported. + */ + char allowComments; +}; +typedef struct cson_parse_opt cson_parse_opt; + +/** + Empty-initialized cson_parse_opt object. +*/ +#define cson_parse_opt_empty_m { 25/*maxDepth*/, 0/*allowComments*/} + + +/** + A class for holding JSON parser information. It is primarily + intended for finding the position of a parse error. +*/ +struct cson_parse_info +{ + /** + 1-based line number. + */ + unsigned int line; + /** + 0-based column number. + */ + unsigned int col; + + /** + Length, in bytes. + */ + unsigned int length; + + /** + Error code of the parse run (0 for no error). + */ + int errorCode; + + /** + The total number of object keys successfully processed by the + parser. + */ + unsigned int totalKeyCount; + + /** + The total number of object/array values successfully processed + by the parser, including the root node. + */ + unsigned int totalValueCount; +}; +typedef struct cson_parse_info cson_parse_info; + +/** + Empty-initialized cson_parse_info object. +*/ +#define cson_parse_info_empty_m {1/*line*/,\ + 0/*col*/, \ + 0/*length*/, \ + 0/*errorCode*/, \ + 0/*totalKeyCount*/, \ + 0/*totalValueCount*/ \ + } +/** + Empty-initialized cson_parse_info object. +*/ +extern const cson_parse_info cson_parse_info_empty; + +/** + Empty-initialized cson_parse_opt object. +*/ +extern const cson_parse_opt cson_parse_opt_empty; + +/** + Client-configurable options for the cson_output() family of + functions. +*/ +struct cson_output_opt +{ + /** + Specifies how to indent (or not) output. The values + are: + + (0) == no extra indentation. + + (1) == 1 TAB character for each level. + + (>1) == that number of SPACES for each level. + */ + unsigned char indentation; + + /** + Maximum object/array depth to traverse. Traversing deeply can + be indicative of cycles in the object/array tree, and this + value is used to figure out when to abort the traversal. + */ + unsigned short maxDepth; + + /** + If true, a newline will be added to generated output, + else not. + */ + char addNewline; + + /** + If true, a space will be added after the colon operator + in objects' key/value pairs. + */ + char addSpaceAfterColon; + + /** + If set to 1 then objects/arrays containing only a single value + will not indent an extra level for that value (but will indent + on subsequent levels if that value contains multiple values). + */ + char indentSingleMemberValues; + + /** + The JSON format allows, but does not require, JSON generators + to backslash-escape forward slashes. This option enables/disables + that feature. According to JSON's inventor, Douglas Crockford: + + + It is allowed, not required. It is allowed so that JSON can be + safely embedded in HTML, which can freak out when seeing + strings containing " + + (from an email on 2011-04-08) + + The default value is 0 (because it's just damned ugly). + */ + char escapeForwardSlashes; +}; +typedef struct cson_output_opt cson_output_opt; + +/** + Empty-initialized cson_output_opt object. +*/ +#define cson_output_opt_empty_m { 0/*indentation*/,\ + 25/*maxDepth*/, \ + 0/*addNewline*/, \ + 0/*addSpaceAfterColon*/, \ + 0/*indentSingleMemberValues*/, \ + 0/*escapeForwardSlashes*/ \ + } + +/** + Empty-initialized cson_output_opt object. +*/ +extern const cson_output_opt cson_output_opt_empty; + +/** + Typedef for functions which act as an input source for + the cson JSON parser. + + The arguments are: + + - state: implementation-specific state needed by the function. + + - n: when called, *n will be the number of bytes the function + should read and copy to dest. The function MUST NOT copy more than + *n bytes to dest. Before returning, *n must be set to the number of + bytes actually copied to dest. If that number is smaller than the + original *n value, the input is assumed to be completed (thus this + is not useful with non-blocking readers). + + - dest: the destination memory to copy the data do. + + Must return 0 on success, non-0 on error (preferably a value from + cson_rc). + + The parser allows this routine to return a partial character from a + UTF multi-byte character. The input routine does not need to + concern itself with character boundaries. +*/ +typedef int (*cson_data_source_f)( void * state, void * dest, unsigned int * n ); + +/** + Typedef for functions which act as an output destination for + generated JSON. + + The arguments are: + + - state: implementation-specific state needed by the function. + + - n: the length, in bytes, of src. + + - src: the source bytes which the output function should consume. + The src pointer will be invalidated shortly after this function + returns, so the implementation must copy or ignore the data, but not + hold a copy of the src pointer. + + Must return 0 on success, non-0 on error (preferably a value from + cson_rc). + + These functions are called relatively often during the JSON-output + process, and should try to be fast. +*/ +typedef int (*cson_data_dest_f)( void * state, void const * src, unsigned int n ); + +/** + Reads JSON-formatted string data (in ASCII, UTF8, or UTF16), using the + src function to fetch all input. This function fetches each input character + from the source function, which is calls like src(srcState, buffer, bufferSize), + and processes them. If anything is not JSON-kosher then this function + fails and returns one of the non-0 cson_rc codes. + + This function is only intended to read root nodes of a JSON tree, either + a single object or a single array, containing any number of child elements. + + On success, *tgt is assigned the value of the root node of the + JSON input, and the caller takes over ownership of that memory. + On error, *tgt is not modified and the caller need not do any + special cleanup, except possibly for the input source. + + + The opt argument may point to an initialized cson_parse_opt object + which contains any settings the caller wants. If it is NULL then + default settings (the values defined in cson_parse_opt_empty) are + used. + + The info argument may be NULL. If it is not NULL then the parser + populates it with information which is useful in error + reporting. Namely, it contains the line/column of parse errors. + + The srcState argument is ignored by this function but is passed on to src, + so any output-destination-specific state can be stored there and accessed + via the src callback. + + Non-parse error conditions include: + + - (!tgt) or !src: CSON_RC_ArgError + - CSON_RC_AllocError can happen at any time during the input phase + + Here's a complete example of using a custom input source: + + @code + // Internal type to hold state for a JSON input string. + typedef struct + { + char const * str; // start of input string + char const * pos; // current internal cursor position + char const * end; // logical EOF (one-past-the-end) + } StringSource; + + // cson_data_source_f() impl which uses StringSource. + static int cson_data_source_StringSource( void * state, void * dest, + unsigned int * n ) + { + StringSource * ss = (StringSource*) state; + unsigned int i; + unsigned char * tgt = (unsigned char *)dest; + if( ! ss || ! n || !dest ) return CSON_RC_ArgError; + else if( !*n ) return CSON_RC_RangeError; + for( i = 0; + (i < *n) && (ss->pos < ss->end); + ++i, ++ss->pos, ++tgt ) + { + *tgt = *ss->pos; + } + *n = i; + return 0; + } + + ... + // Now use StringSource together with cson_parse() + StringSource ss; + cson_value * root = NULL; + char const * json = "{\"k1\":123}"; + ss.str = ss.pos = json; + ss.end = json + strlen(json); + int rc = cson_parse( &root, cson_data_source_StringSource, &ss, NULL, NULL ); + @endcode + + It is recommended that clients wrap such utility code into + type-safe wrapper functions which also initialize the internal + state object and check the user-provided parameters for legality + before passing them on to cson_parse(). For examples of this, see + cson_parse_FILE() or cson_parse_string(). + + TODOs: + + - Buffer the input in larger chunks. We currently read + byte-by-byte, but i'm too tired to write/test the looping code for + the buffering. + + @see cson_parse_FILE() + @see cson_parse_string() +*/ +int cson_parse( cson_value ** tgt, cson_data_source_f src, void * srcState, + cson_parse_opt const * opt, cson_parse_info * info ); +/** + A cson_data_source_f() implementation which requires the state argument + to be a readable (FILE*) handle. +*/ +int cson_data_source_FILE( void * state, void * dest, unsigned int * n ); + +/** + Equivalent to cson_parse( tgt, cson_data_source_FILE, src, opt ). + + @see cson_parse_filename() +*/ +int cson_parse_FILE( cson_value ** tgt, FILE * src, + cson_parse_opt const * opt, cson_parse_info * info ); + +/** + Convenience wrapper around cson_parse_FILE() which opens the given filename. + + Returns CSON_RC_IOError if the file cannot be opened. + + @see cson_parse_FILE() +*/ +int cson_parse_filename( cson_value ** tgt, char const * src, + cson_parse_opt const * opt, cson_parse_info * info ); + +/** + Uses an internal helper class to pass src through cson_parse(). + See that function for the return value and argument semantics. + + src must be a string containing JSON code, at least len bytes long, + and the parser will attempt to parse exactly len bytes from src. + + If len is less than 2 (the minimum length of a legal top-node JSON + object) then CSON_RC_RangeError is returned. +*/ +int cson_parse_string( cson_value ** tgt, char const * src, unsigned int len, + cson_parse_opt const * opt, cson_parse_info * info ); + + + +/** + Outputs the given value as a JSON-formatted string, sending all + output to the given callback function. It is intended for top-level + objects or arrays, but can be used with any cson_value. + + If opt is NULL then default options (the values defined in + cson_output_opt_empty) are used. + + If opt->maxDepth is exceeded while traversing the value tree, + CSON_RC_RangeError is returned. + + The destState parameter is ignored by this function and is passed + on to the dest function. + + Returns 0 on success. On error, any amount of output might have been + generated before the error was triggered. + + Example: + + @code + int rc = cson_output( myValue, cson_data_dest_FILE, stdout, NULL ); + // basically equivalent to: cson_output_FILE( myValue, stdout, NULL ); + // but note that cson_output_FILE() actually uses different defaults + // for the output options. + @endcode +*/ +int cson_output( cson_value const * src, cson_data_dest_f dest, void * destState, cson_output_opt const * opt ); + + +/** + A cson_data_dest_f() implementation which requires the state argument + to be a writable (FILE*) handle. +*/ +int cson_data_dest_FILE( void * state, void const * src, unsigned int n ); + +/** + Almost equivalent to cson_output( src, cson_data_dest_FILE, dest, opt ), + with one minor difference: if opt is NULL then the default options + always include the addNewline option, since that is normally desired + for FILE output. + + @see cson_output_filename() +*/ +int cson_output_FILE( cson_value const * src, FILE * dest, cson_output_opt const * opt ); +/** + Convenience wrapper around cson_output_FILE() which writes to the given filename, destroying + any existing contents. Returns CSON_RC_IOError if the file cannot be opened. + + @see cson_output_FILE() +*/ +int cson_output_filename( cson_value const * src, char const * dest, cson_output_opt const * fmt ); + +/** + Returns the virtual type of v, or CSON_TYPE_UNDEF if !v. +*/ +cson_type_id cson_value_type_id( cson_value const * v ); + + +/** Returns true if v is null, v->api is NULL, or v holds the special undefined value. */ +char cson_value_is_undef( cson_value const * v ); +/** Returns true if v contains a null value. */ +char cson_value_is_null( cson_value const * v ); +/** Returns true if v contains a bool value. */ +char cson_value_is_bool( cson_value const * v ); +/** Returns true if v contains an integer value. */ +char cson_value_is_integer( cson_value const * v ); +/** Returns true if v contains a double value. */ +char cson_value_is_double( cson_value const * v ); +/** Returns true if v contains a number (double, integer) value. */ +char cson_value_is_number( cson_value const * v ); +/** Returns true if v contains a string value. */ +char cson_value_is_string( cson_value const * v ); +/** Returns true if v contains an array value. */ +char cson_value_is_array( cson_value const * v ); +/** Returns true if v contains an object value. */ +char cson_value_is_object( cson_value const * v ); + +/** @struct cson_object + + cson_object is an opaque handle to an Object value. + + They are used like: + + @code + cson_object * obj = cson_value_get_object(myValue); + ... + @endcode + + They can be created like: + + @code + cson_value * objV = cson_value_new_object(); + cson_object * obj = cson_value_get_object(objV); + // obj is owned by objV and objV must eventually be freed + // using cson_value_free() or added to a container + // object/array (which transfers ownership to that container). + @endcode + + @see cson_value_new_object() + @see cson_value_get_object() + @see cson_value_free() +*/ + +typedef struct cson_object cson_object; + +/** @struct cson_array + + cson_array is an opaque handle to an Array value. + + They are used like: + + @code + cson_array * obj = cson_value_get_array(myValue); + ... + @endcode + + They can be created like: + + @code + cson_value * arV = cson_value_new_array(); + cson_array * ar = cson_value_get_array(arV); + // ar is owned by arV and arV must eventually be freed + // using cson_value_free() or added to a container + // object/array (which transfers ownership to that container). + @endcode + + @see cson_value_new_array() + @see cson_value_get_array() + @see cson_value_free() + +*/ +typedef struct cson_array cson_array; + +/** @struct cson_string + + cson-internal string type, opaque to client code. Strings in cson + are immutable and allocated only by library internals, never + directly by client code. + + The actual string bytes are to be allocated together in the same + memory chunk as the cson_string object, which saves us 1 malloc() + and 1 pointer member in this type (because we no longer have a + direct pointer to the memory). + + Potential TODOs: + + @see cson_string_cstr() +*/ +typedef struct cson_string cson_string; + +/** + Converts the given value to a boolean, using JavaScript semantics depending + on the concrete type of val: + + undef or null: false + + boolean: same + + integer, double: 0 or 0.0 == false, else true + + object, array: true + + string: length-0 string is false, else true. + + Returns 0 on success and assigns *v (if v is not NULL) to either 0 or 1. + On error (val is NULL) then v is not modified. +*/ +int cson_value_fetch_bool( cson_value const * val, char * v ); + +/** + Similar to cson_value_fetch_bool(), but fetches an integer value. + + The conversion, if any, depends on the concrete type of val: + + NULL, null, undefined: *v is set to 0 and 0 is returned. + + string, object, array: *v is set to 0 and + CSON_RC_TypeError is returned. The error may normally be safely + ignored, but it is provided for those wanted to know whether a direct + conversion was possible. + + integer: *v is set to the int value and 0 is returned. + + double: *v is set to the value truncated to int and 0 is returned. +*/ +int cson_value_fetch_integer( cson_value const * val, cson_int_t * v ); + +/** + The same conversions and return values as + cson_value_fetch_integer(), except that the roles of int/double are + swapped. +*/ +int cson_value_fetch_double( cson_value const * val, cson_double_t * v ); + +/** + If cson_value_is_string(val) then this function assigns *str to the + contents of the string. str may be NULL, in which case this function + functions like cson_value_is_string() but returns 0 on success. + + Returns 0 if val is-a string, else non-0, in which case *str is not + modified. + + The bytes are owned by the given value and may be invalidated in any of + the following ways: + + - The value is cleaned up or freed. + + - An array or object containing the value peforms a re-allocation + (it shrinks or grows). + + And thus the bytes should be consumed before any further operations + on val or any container which holds it. + + Note that this routine does not convert non-String values to their + string representations. (Adding that ability would add more + overhead to every cson_value instance.) +*/ +int cson_value_fetch_string( cson_value const * val, cson_string ** str ); + +/** + If cson_value_is_object(val) then this function assigns *obj to the underlying + object value and returns 0, otherwise non-0 is returned and *obj is not modified. + + obj may be NULL, in which case this function works like cson_value_is_object() + but with inverse return value semantics (0==success) (and it's a few + CPU cycles slower). + + The *obj pointer is owned by val, and will be invalidated when val + is cleaned up. + + Achtung: for best results, ALWAYS pass a pointer to NULL as the + second argument, e.g.: + + @code + cson_object * obj = NULL; + int rc = cson_value_fetch_object( val, &obj ); + + // Or, more simply: + obj = cson_value_get_object( val ); + @endcode + + @see cson_value_get_object() +*/ +int cson_value_fetch_object( cson_value const * val, cson_object ** obj ); + +/** + Identical to cson_value_fetch_object(), but works on array values. + + @see cson_value_get_array() +*/ +int cson_value_fetch_array( cson_value const * val, cson_array ** tgt ); + +/** + Simplified form of cson_value_fetch_bool(). Returns 0 if val + is NULL. +*/ +char cson_value_get_bool( cson_value const * val ); + +/** + Simplified form of cson_value_fetch_integer(). Returns 0 if val + is NULL. +*/ +cson_int_t cson_value_get_integer( cson_value const * val ); + +/** + Simplified form of cson_value_fetch_double(). Returns 0.0 if val + is NULL. +*/ +cson_double_t cson_value_get_double( cson_value const * val ); + +/** + Simplified form of cson_value_fetch_string(). Returns NULL if val + is-not-a string value. +*/ +cson_string * cson_value_get_string( cson_value const * val ); + +/** + Returns a pointer to the NULL-terminated string bytes of str. + The bytes are owned by string and will be invalided when it + is cleaned up. + + If str is NULL then NULL is returned. If the string has a length + of 0 then "" is returned. + + @see cson_string_length_bytes() + @see cson_value_get_string() +*/ +char const * cson_string_cstr( cson_string const * str ); + +/** + Convenience function which returns the string bytes of + the given value if it is-a string, otherwise it returns + NULL. Note that this does no conversion of non-string types + to strings. + + Equivalent to cson_string_cstr(cson_value_get_string(val)). +*/ +char const * cson_value_get_cstr( cson_value const * val ); + +/** + Equivalent to cson_string_cmp_cstr_n(lhs, cson_string_cstr(rhs), cson_string_length_bytes(rhs)). +*/ +int cson_string_cmp( cson_string const * lhs, cson_string const * rhs ); + +/** + Compares lhs to rhs using memcmp()/strcmp() semantics. Generically + speaking it returns a negative number if lhs is less-than rhs, 0 if + they are equivalent, or a positive number if lhs is greater-than + rhs. It has the following rules for equivalence: + + - The maximum number of bytes compared is the lesser of rhsLen and + the length of lhs. If the strings do not match, but compare equal + up to the just-described comparison length, the shorter string is + considered to be less-than the longer one. + + - If lhs and rhs are both NULL, or both have a length of 0 then they will + compare equal. + + - If lhs is null/length-0 but rhs is not then lhs is considered to be less-than + rhs. + + - If rhs is null/length-0 but lhs is not then rhs is considered to be less-than + rhs. + + - i have no clue if the results are exactly correct for UTF strings. + +*/ +int cson_string_cmp_cstr_n( cson_string const * lhs, char const * rhs, unsigned int rhsLen ); + +/** + Equivalent to cson_string_cmp_cstr_n( lhs, rhs, (rhs&&*rhs)?strlen(rhs):0 ). +*/ +int cson_string_cmp_cstr( cson_string const * lhs, char const * rhs ); + +/** + Returns the length, in bytes, of str, or 0 if str is NULL. This is + an O(1) operation. + + TODO: add cson_string_length_chars() (is O(N) unless we add another + member to store the char length). + + @see cson_string_cstr() +*/ +unsigned int cson_string_length_bytes( cson_string const * str ); + +/** + Returns the number of UTF8 characters in str. This value will + be at most as long as cson_string_length_bytes() for the + same string, and less if it has multi-byte characters. + + Returns 0 if str is NULL. +*/ +unsigned int cson_string_length_utf8( cson_string const * str ); + +/** + Like cson_value_get_string(), but returns a copy of the underying + string bytes, which the caller owns and must eventually free + using free(). +*/ +char * cson_value_get_string_copy( cson_value const * val ); + +/** + Simplified form of cson_value_fetch_object(). Returns NULL if val + is-not-a object value. +*/ +cson_object * cson_value_get_object( cson_value const * val ); + +/** + Simplified form of cson_value_fetch_array(). Returns NULL if val + is-not-a array value. +*/ +cson_array * cson_value_get_array( cson_value const * val ); + +/** + Const-correct form of cson_value_get_array(). +*/ +cson_array const * cson_value_get_array_c( cson_value const * val ); + +/** + If ar is-a array and is at least (pos+1) entries long then *v (if v is not NULL) + is assigned to the value at that position (which may be NULL). + + Ownership of the *v return value is unchanged by this call. (The + containing array may share ownership of the value with other + containers.) + + If pos is out of range, non-0 is returned and *v is not modified. + + If v is NULL then this function returns 0 if pos is in bounds, but does not + otherwise return a value to the caller. +*/ +int cson_array_value_fetch( cson_array const * ar, unsigned int pos, cson_value ** v ); + +/** + Simplified form of cson_array_value_fetch() which returns NULL if + ar is NULL, pos is out of bounds or if ar has no element at that + position. +*/ +cson_value * cson_array_get( cson_array const * ar, unsigned int pos ); + +/** + Ensures that ar has allocated space for at least the given + number of entries. This never shrinks the array and never + changes its logical size, but may pre-allocate space in the + array for storing new (as-yet-unassigned) values. + + Returns 0 on success, or non-zero on error: + + - If ar is NULL: CSON_RC_ArgError + + - If allocation fails: CSON_RC_AllocError +*/ +int cson_array_reserve( cson_array * ar, unsigned int size ); + +/** + If ar is not NULL, sets *v (if v is not NULL) to the length of the array + and returns 0. Returns CSON_RC_ArgError if ar is NULL. +*/ +int cson_array_length_fetch( cson_array const * ar, unsigned int * v ); + +/** + Simplified form of cson_array_length_fetch() which returns 0 if ar + is NULL. +*/ +unsigned int cson_array_length_get( cson_array const * ar ); + +/** + Sets the given index of the given array to the given value. + + If ar already has an item at that index then it is cleaned up and + freed before inserting the new item. + + ar is expanded, if needed, to be able to hold at least (ndx+1) + items, and any new entries created by that expansion are empty + (NULL values). + + On success, 0 is returned and ownership of v is transfered to ar. + + On error ownership of v is NOT modified, and the caller may still + need to clean it up. For example, the following code will introduce + a leak if this function fails: + + @code + cson_array_append( myArray, cson_value_new_integer(42) ); + @endcode + + Because the value created by cson_value_new_integer() has no owner + and is not cleaned up. The "more correct" way to do this is: + + @code + cson_value * v = cson_value_new_integer(42); + int rc = cson_array_append( myArray, v ); + if( 0 != rc ) { + cson_value_free( v ); + ... handle error ... + } + @endcode + +*/ +int cson_array_set( cson_array * ar, unsigned int ndx, cson_value * v ); + +/** + Appends the given value to the given array, transfering ownership of + v to ar. On error, ownership of v is not modified. Ownership of ar + is never changed by this function. + + This is functionally equivalent to + cson_array_set(ar,cson_array_length_get(ar),v), but this + implementation has slightly different array-preallocation policy + (it grows more eagerly). + + Returns 0 on success, non-zero on error. Error cases include: + + - ar or v are NULL: CSON_RC_ArgError + + - Array cannot be expanded to hold enough elements: CSON_RC_AllocError. + + - Appending would cause a numeric overlow in the array's size: + CSON_RC_RangeError. (However, you'll get an AllocError long before + that happens!) + + On error ownership of v is NOT modified, and the caller may still + need to clean it up. See cson_array_set() for the details. + +*/ +int cson_array_append( cson_array * ar, cson_value * v ); + + +/** + Creates a new cson_value from the given boolean value. + + Ownership of the new value is passed to the caller, who must + eventually either free the value using cson_value_free() or + inserting it into a container (array or object), which transfers + ownership to the container. See the cson_value class documentation + for more details. + + Semantically speaking this function Returns NULL on allocation + error, but the implementation never actually allocates for this + case. Nonetheless, it must be treated as if it were an allocated + value. +*/ +cson_value * cson_value_new_bool( char v ); + + +/** + Alias for cson_value_new_bool(v). +*/ +cson_value * cson_new_bool(char v); + +/** + Returns the special JSON "null" value. When outputing JSON, + its string representation is "null" (without the quotes). + + See cson_value_new_bool() for notes regarding the returned + value's memory. +*/ +cson_value * cson_value_null( void ); + +/** + Equivalent to cson_value_new_bool(1). +*/ +cson_value * cson_value_true( void ); + +/** + Equivalent to cson_value_new_bool(0). +*/ +cson_value * cson_value_false( void ); + +/** + Semantically the same as cson_value_new_bool(), but for integers. +*/ +cson_value * cson_value_new_integer( cson_int_t v ); + +/** + Alias for cson_value_new_integer(v). +*/ +cson_value * cson_new_int(cson_int_t v); + +/** + Semantically the same as cson_value_new_bool(), but for doubles. +*/ +cson_value * cson_value_new_double( cson_double_t v ); + +/** + Alias for cson_value_new_double(v). +*/ +cson_value * cson_new_double(cson_double_t v); + +/** + Semantically the same as cson_value_new_bool(), but for strings. + This creates a JSON value which copies the first n bytes of str. + The string will automatically be NUL-terminated. + + Note that if str is NULL or n is 0, this function still + returns non-NULL value representing that empty string. + + Returns NULL on allocation error. + + See cson_value_new_bool() for important information about the + returned memory. +*/ +cson_value * cson_value_new_string( char const * str, unsigned int n ); + +/** + Allocates a new "object" value and transfers ownership of it to the + caller. It must eventually be destroyed, by the caller or its + owning container, by passing it to cson_value_free(). + + Returns NULL on allocation error. + + Post-conditions: cson_value_is_object(value) will return true. + + @see cson_value_new_array() + @see cson_value_free() +*/ +cson_value * cson_value_new_object( void ); + +/** + This works like cson_value_new_object() but returns an Object + handle directly. + + The value handle for the returned object can be fetched with + cson_object_value(theObject). + + Ownership is transfered to the caller, who must eventually free it + by passing the Value handle (NOT the Object handle) to + cson_value_free() or passing ownership to a parent container. + + Returns NULL on error (out of memory). +*/ +cson_object * cson_new_object( void ); + +/** + Identical to cson_new_object() except that it creates + an Array. +*/ +cson_array * cson_new_array( void ); + +/** + Identical to cson_new_object() except that it creates + a String. +*/ +cson_string * cson_new_string(char const * val, unsigned int len); + +/** + Equivalent to cson_value_free(cson_object_value(x)). +*/ +void cson_free_object(cson_object *x); + +/** + Equivalent to cson_value_free(cson_array_value(x)). +*/ +void cson_free_array(cson_array *x); + +/** + Equivalent to cson_value_free(cson_string_value(x)). +*/ +void cson_free_string(cson_string *x); + + +/** + Allocates a new "array" value and transfers ownership of it to the + caller. It must eventually be destroyed, by the caller or its + owning container, by passing it to cson_value_free(). + + Returns NULL on allocation error. + + Post-conditions: cson_value_is_array(value) will return true. + + @see cson_value_new_object() + @see cson_value_free() +*/ +cson_value * cson_value_new_array( void ); + +/** + Frees any resources owned by v, then frees v. If v is a container + type (object or array) its children are also freed (recursively). + + If v is NULL, this is a no-op. + + This function decrements a reference count and only destroys the + value if its reference count drops to 0. Reference counts are + increased by either inserting the value into a container or via + cson_value_add_reference(). Even if this function does not + immediately destroy the value, the value must be considered, from + the perspective of that client code, to have been + destroyed/invalidated by this call. + + + @see cson_value_new_object() + @see cson_value_new_array() + @see cson_value_add_reference() +*/ +void cson_value_free(cson_value * v); + +/** + Alias for cson_value_free(). +*/ +void cson_free_value(cson_value * v); + + +/** + Functionally similar to cson_array_set(), but uses a string key + as an index. Like arrays, if a value already exists for the given key, + it is destroyed by this function before inserting the new value. + + If v is NULL then this call is equivalent to + cson_object_unset(obj,key). Note that (v==NULL) is treated + differently from v having the special null value. In the latter + case, the key is set to the special null value. + + The key may be encoded as ASCII or UTF8. Results are undefined + with other encodings, and the errors won't show up here, but may + show up later, e.g. during output. + + Returns 0 on success, non-0 on error. It has the following error + cases: + + - CSON_RC_ArgError: obj or key are NULL or strlen(key) is 0. + + - CSON_RC_AllocError: an out-of-memory error + + On error ownership of v is NOT modified, and the caller may still + need to clean it up. For example, the following code will introduce + a leak if this function fails: + + @code + cson_object_set( myObj, "foo", cson_value_new_integer(42) ); + @endcode + + Because the value created by cson_value_new_integer() has no owner + and is not cleaned up. The "more correct" way to do this is: + + @code + cson_value * v = cson_value_new_integer(42); + int rc = cson_object_set( myObj, "foo", v ); + if( 0 != rc ) { + cson_value_free( v ); + ... handle error ... + } + @endcode + + Potential TODOs: + + - Add an overload which takes a cson_value key instead. To get + any value out of that we first need to be able to convert arbitrary + value types to strings. We could simply to-JSON them and use those + as keys. +*/ +int cson_object_set( cson_object * obj, char const * key, cson_value * v ); + +/** + Functionaly equivalent to cson_object_set(), but takes a + cson_string() as its KEY type. The string will be reference-counted + like any other values, and the key may legally be used within this + same container (as a value) or others (as a key or value) at the + same time. + + Returns 0 on success. On error, ownership (i.e. refcounts) of key + and value are not modified. On success key and value will get + increased refcounts unless they are replacing themselves (which is + a harmless no-op). +*/ +int cson_object_set_s( cson_object * obj, cson_string * key, cson_value * v ); + +/** + Removes a property from an object. + + If obj contains the given key, it is removed and 0 is returned. If + it is not found, CSON_RC_NotFoundError is returned (which can + normally be ignored by client code). + + CSON_RC_ArgError is returned if obj or key are NULL or key has + a length of 0. + + Returns 0 if the given key is found and removed. + + This is functionally equivalent calling + cson_object_set(obj,key,NULL). +*/ +int cson_object_unset( cson_object * obj, char const * key ); + +/** + Searches the given object for a property with the given key. If found, + it is returned. If no match is found, or any arguments are NULL, NULL is + returned. The returned object is owned by obj, and may be invalidated + by ANY operations which change obj's property list (i.e. add or remove + properties). + + FIXME: allocate the key/value pairs like we do for cson_array, + to get improve the lifetimes of fetched values. + + @see cson_object_fetch_sub() + @see cson_object_get_sub() +*/ +cson_value * cson_object_get( cson_object const * obj, char const * key ); + +/** + Equivalent to cson_object_get() but takes a cson_string argument + instead of a C-style string. +*/ +cson_value * cson_object_get_s( cson_object const * obj, cson_string const *key ); + +/** + Similar to cson_object_get(), but removes the value from the parent + object's ownership. If no item is found then NULL is returned, else + the object (now owned by the caller or possibly shared with other + containers) is returned. + + Returns NULL if either obj or key are NULL or key has a length + of 0. + + This function reduces the returned value's reference count but has + the specific property that it does not treat refcounts 0 and 1 + identically, meaning that the returned object may have a refcount + of 0. This behaviour works around a corner-case where we want to + extract a child element from its parent and then destroy the parent + (which leaves us in an undesireable (normally) reference count + state). +*/ +cson_value * cson_object_take( cson_object * obj, char const * key ); + +/** + Fetches a property from a child (or [great-]*grand-child) object. + + obj is the object to search. + + path is a delimited string, where the delimiter is the given + separator character. + + This function searches for the given path, starting at the given object + and traversing its properties as the path specifies. If a given part of the + path is not found, then this function fails with CSON_RC_NotFoundError. + + If it finds the given path, it returns the value by assiging *tgt + to it. If tgt is NULL then this function has no side-effects but + will return 0 if the given path is found within the object, so it can be used + to test for existence without fetching it. + + Returns 0 if it finds an entry, CSON_RC_NotFoundError if it finds + no item, and any other non-zero error code on a "real" error. Errors include: + + - obj or path are NULL: CSON_RC_ArgError + + - separator is 0, or path is an empty string or contains only + separator characters: CSON_RC_RangeError + + - There is an upper limit on how long a single path component may + be (some "reasonable" internal size), and CSON_RC_RangeError is + returned if that length is violated. + + + Limitations: + + - It has no way to fetch data from arrays this way. i could + imagine, e.g., a path of "subobj.subArray.0" for + subobj.subArray[0], or "0.3.1" for [0][3][1]. But i'm too + lazy/tired to add this. + + Example usage: + + + Assume we have a JSON structure which abstractly looks like: + + @code + {"subobj":{"subsubobj":{"myValue":[1,2,3]}}} + @endcode + + Out goal is to get the value of myValue. We can do that with: + + @code + cson_value * v = NULL; + int rc = cson_object_fetch_sub( object, &v, "subobj.subsubobj.myValue", '.' ); + @endcode + + Note that because keys in JSON may legally contain a '.', the + separator must be specified by the caller. e.g. the path + "subobj/subsubobj/myValue" with separator='/' is equivalent the + path "subobj.subsubobj.myValue" with separator='.'. The value of 0 + is not legal as a separator character because we cannot + distinguish that use from the real end-of-string without requiring + the caller to also pass in the length of the string. + + Multiple successive separators in the list are collapsed into a + single separator for parsing purposes. e.g. the path "a...b...c" + (separator='.') is equivalent to "a.b.c". + + @see cson_object_get_sub() + @see cson_object_get_sub2() +*/ +int cson_object_fetch_sub( cson_object const * obj, cson_value ** tgt, char const * path, char separator ); + +/** + Similar to cson_object_fetch_sub(), but derives the path separator + character from the first byte of the path argument. e.g. the + following arg equivalent: + + @code + cson_object_fetch_sub( obj, &tgt, "foo.bar.baz", '.' ); + cson_object_fetch_sub2( obj, &tgt, ".foo.bar.baz" ); + @endcode +*/ +int cson_object_fetch_sub2( cson_object const * obj, cson_value ** tgt, char const * path ); + +/** + Convenience form of cson_object_fetch_sub() which returns NULL if the given + item is not found. +*/ +cson_value * cson_object_get_sub( cson_object const * obj, char const * path, char sep ); + +/** + Convenience form of cson_object_fetch_sub2() which returns NULL if the given + item is not found. +*/ +cson_value * cson_object_get_sub2( cson_object const * obj, char const * path ); + +/** @enum CSON_MERGE_FLAGS + + Flags for cson_object_merge(). +*/ +enum CSON_MERGE_FLAGS { + CSON_MERGE_DEFAULT = 0, + CSON_MERGE_REPLACE = 0x01, + CSON_MERGE_NO_RECURSE = 0x02 +}; + +/** + "Merges" the src object's properties into dest. Each property in + src is copied (using reference counting, not cloning) into dest. If + dest already has the given property then behaviour depends on the + flags argument: + + If flag has the CSON_MERGE_REPLACE bit set then this function will + by default replace non-object properties with the src property. If + src and dest both have the property AND it is an Object then this + function operates recursively on those objects. If + CSON_MERGE_NO_RECURSE is set then objects are not recursed in this + manner, and will be completely replaced if CSON_MERGE_REPLACE is + set. + + Array properties in dest are NOT recursed for merging - they are + either replaced or left as-is, depending on whether flags contains + he CSON_MERGE_REPLACE bit. + + Returns 0 on success. The error conditions are: + + - dest or src are NULL or (dest==src) returns CSON_RC_ArgError. + + - dest or src contain cyclic references - this will likely cause a + crash due to endless recursion. + + Potential TODOs: + + - Add a flag to copy clones, not the original values. +*/ +int cson_object_merge( cson_object * dest, cson_object const * src, int flags ); + + +/** + An iterator type for traversing object properties. + + Its values must be considered private, not to be touched by client + code. + + @see cson_object_iter_init() + @see cson_object_iter_next() +*/ +struct cson_object_iterator +{ + + /** @internal + The underlying object. + */ + cson_object const * obj; + /** @internal + Current position in the property list. + */ + unsigned int pos; +}; +typedef struct cson_object_iterator cson_object_iterator; + +/** + Empty-initialized cson_object_iterator object. +*/ +#define cson_object_iterator_empty_m {NULL/*obj*/,0/*pos*/} + +/** + Empty-initialized cson_object_iterator object. +*/ +extern const cson_object_iterator cson_object_iterator_empty; + +/** + Initializes the given iterator to point at the start of obj's + properties. Returns 0 on success or CSON_RC_ArgError if !obj + or !iter. + + obj must outlive iter, or results are undefined. Results are also + undefined if obj is modified while the iterator is active. + + @see cson_object_iter_next() +*/ +int cson_object_iter_init( cson_object const * obj, cson_object_iterator * iter ); + +/** @struct cson_kvp + +This class represents a key/value pair and is used for storing +object properties. It is opaque to client code, and the public +API only uses this type for purposes of iterating over cson_object +properties using the cson_object_iterator interfaces. +*/ + +typedef struct cson_kvp cson_kvp; + +/** + Returns the next property from the given iterator's object, or NULL + if the end of the property list as been reached. + + Note that the order of object properties is undefined by the API, + and may change from version to version. + + The returned memory belongs to the underlying object and may be + invalidated by any changes to that object. + + Example usage: + + @code + cson_object_iterator it; + cson_object_iter_init( myObject, &it ); // only fails if either arg is 0 + cson_kvp * kvp; + cson_string const * key; + cson_value const * val; + while( (kvp = cson_object_iter_next(&it) ) ) + { + key = cson_kvp_key(kvp); + val = cson_kvp_value(kvp); + ... + } + @endcode + + There is no need to clean up an iterator, as it holds no dynamic resources. + + @see cson_kvp_key() + @see cson_kvp_value() +*/ +cson_kvp * cson_object_iter_next( cson_object_iterator * iter ); + + +/** + Returns the key associated with the given key/value pair, + or NULL if !kvp. The memory is owned by the object which contains + the key/value pair, and may be invalidated by any modifications + to that object. +*/ +cson_string * cson_kvp_key( cson_kvp const * kvp ); + +/** + Returns the value associated with the given key/value pair, + or NULL if !kvp. The memory is owned by the object which contains + the key/value pair, and may be invalidated by any modifications + to that object. +*/ +cson_value * cson_kvp_value( cson_kvp const * kvp ); + +/** @typedef some unsigned int type cson_size_t + +*/ +typedef unsigned int cson_size_t; + +/** + A generic buffer class. + + They can be used like this: + + @code + cson_buffer b = cson_buffer_empty; + int rc = cson_buffer_reserve( &buf, 100 ); + if( 0 != rc ) { ... allocation error ... } + ... use buf.mem ... + ... then free it up ... + cson_buffer_reserve( &buf, 0 ); + @endcode + + To take over ownership of a buffer's memory: + + @code + void * mem = b.mem; + // mem is b.capacity bytes long, but only b.used + // bytes of it has been "used" by the API. + b = cson_buffer_empty; + @endcode + + The memory now belongs to the caller and must eventually be + free()d. +*/ +struct cson_buffer +{ + /** + The number of bytes allocated for this object. + Use cson_buffer_reserve() to change its value. + */ + cson_size_t capacity; + /** + The number of bytes "used" by this object. It is not needed for + all use cases, and management of this value (if needed) is up + to the client. The cson_buffer public API does not use this + member. The intention is that this can be used to track the + length of strings which are allocated via cson_buffer, since + they need an explicit length and/or null terminator. + */ + cson_size_t used; + + /** + This is a debugging/metric-counting value + intended to help certain malloc()-conscious + clients tweak their memory reservation sizes. + Each time cson_buffer_reserve() expands the + buffer, it increments this value by 1. + */ + cson_size_t timesExpanded; + + /** + The memory allocated for and owned by this buffer. + Use cson_buffer_reserve() to change its size or + free it. To take over ownership, do: + + @code + void * myptr = buf.mem; + buf = cson_buffer_empty; + @endcode + + (You might also need to store buf.used and buf.capacity, + depending on what you want to do with the memory.) + + When doing so, the memory must eventually be passed to free() + to deallocate it. + */ + unsigned char * mem; +}; +/** Convenience typedef. */ +typedef struct cson_buffer cson_buffer; + +/** An empty-initialized cson_buffer object. */ +#define cson_buffer_empty_m {0/*capacity*/,0/*used*/,0/*timesExpanded*/,NULL/*mem*/} +/** An empty-initialized cson_buffer object. */ +extern const cson_buffer cson_buffer_empty; + +/** + Uses cson_output() to append all JSON output to the given buffer + object. The semantics for the (v, opt) parameters, and the return + value, are as documented for cson_output(). buf must be a non-NULL + pointer to a properly initialized buffer (see example below). + + Ownership of buf is not changed by calling this. + + On success 0 is returned and the contents of buf.mem are guaranteed + to be NULL-terminated. On error the buffer might contain partial + contents, and it should not be used except to free its contents. + + On error non-zero is returned. Errors include: + + - Invalid arguments: CSON_RC_ArgError + + - Buffer cannot be expanded (runs out of memory): CSON_RC_AllocError + + Example usage: + + @code + cson_buffer buf = cson_buffer_empty; + // optional: cson_buffer_reserve(&buf, 1024 * 10); + int rc = cson_output_buffer( myValue, &buf, NULL ); + if( 0 != rc ) { + ... error! ... + } + else { + ... use buffer ... + puts((char const*)buf.mem); + } + // In both cases, we eventually need to clean up the buffer: + cson_buffer_reserve( &buf, 0 ); + // Or take over ownership of its memory: + { + char * mem = (char *)buf.mem; + buf = cson_buffer_empty; + ... + free(mem); + } + @endcode + + @see cson_output() + +*/ +int cson_output_buffer( cson_value const * v, cson_buffer * buf, + cson_output_opt const * opt ); + +/** + This works identically to cson_parse_string(), but takes a + cson_buffer object as its input. buf->used bytes of buf->mem are + assumed to be valid JSON input, but it need not be NUL-terminated + (we only read up to buf->used bytes). The value of buf->used is + assumed to be the "string length" of buf->mem, i.e. not including + the NUL terminator. + + Returns 0 on success, non-0 on error. + + See cson_parse() for the semantics of the tgt, opt, and err + parameters. +*/ +int cson_parse_buffer( cson_value ** tgt, cson_buffer const * buf, + cson_parse_opt const * opt, cson_parse_info * err ); + + +/** + Reserves the given amount of memory for the given buffer object. + + If n is 0 then buf->mem is freed and its state is set to + NULL/0 values. + + If buf->capacity is less than or equal to n then 0 is returned and + buf is not modified. + + If n is larger than buf->capacity then buf->mem is (re)allocated + and buf->capacity contains the new length. Newly-allocated bytes + are filled with zeroes. + + On success 0 is returned. On error non-0 is returned and buf is not + modified. + + buf->mem is owned by buf and must eventually be freed by passing an + n value of 0 to this function. + + buf->used is never modified by this function unless n is 0, in which case + it is reset. +*/ +int cson_buffer_reserve( cson_buffer * buf, cson_size_t n ); + +/** + Fills all bytes of the given buffer with the given character. + Returns the number of bytes set (buf->capacity), or 0 if + !buf or buf has no memory allocated to it. +*/ +cson_size_t cson_buffer_fill( cson_buffer * buf, char c ); + +/** + Uses a cson_data_source_f() function to buffer input into a + cson_buffer. + + dest must be a non-NULL, initialized (though possibly empty) + cson_buffer object. Its contents, if any, will be overwritten by + this function, and any memory it holds might be re-used. + + The src function is called, and passed the state parameter, to + fetch the input. If it returns non-0, this function returns that + error code. src() is called, possibly repeatedly, until it reports + that there is no more data. + + Whether or not this function succeeds, dest still owns any memory + pointed to by dest->mem, and the client must eventually free it by + calling cson_buffer_reserve(dest,0). + + dest->mem might (and possibly will) be (re)allocated by this + function, so any pointers to it held from before this call might be + invalidated by this call. + + On error non-0 is returned and dest has almost certainly been + modified but its state must be considered incomplete. + + Errors include: + + - dest or src are NULL (CSON_RC_ArgError) + + - Allocation error (CSON_RC_AllocError) + + - src() returns an error code + + Whether or not the state parameter may be NULL depends on + the src implementation requirements. + + On success dest will contain the contents read from the input + source. dest->used will be the length of the read-in data, and + dest->mem will point to the memory. dest->mem is automatically + NUL-terminated if this function succeeds, but dest->used does not + count that terminator. On error the state of dest->mem must be + considered incomplete, and is not guaranteed to be NUL-terminated. + + Example usage: + + @code + cson_buffer buf = cson_buffer_empty; + int rc = cson_buffer_fill_from( &buf, + cson_data_source_FILE, + stdin ); + if( rc ) + { + fprintf(stderr,"Error %d (%s) while filling buffer.\n", + rc, cson_rc_string(rc)); + cson_buffer_reserve( &buf, 0 ); + return ...; + } + ... use the buf->mem ... + ... clean up the buffer ... + cson_buffer_reserve( &buf, 0 ); + @endcode + + To take over ownership of the buffer's memory, do: + + @code + void * mem = buf.mem; + buf = cson_buffer_empty; + @endcode + + In which case the memory must eventually be passed to free() to + free it. +*/ +int cson_buffer_fill_from( cson_buffer * dest, cson_data_source_f src, void * state ); + + +/** + Increments the reference count for the given value. This is a + low-level operation and should not normally be used by client code + without understanding exactly what side-effects it introduces. + Mis-use can lead to premature destruction or cause a value instance + to never be properly destructed (i.e. a memory leak). + + This function is probably only useful for the following cases: + + - You want to hold a reference to a value which is itself contained + in one or more containers, and you need to be sure that your + reference outlives the container(s) and/or that you can free your + copy of the reference without invaliding any references to the same + value held in containers. + + - You want to implement "value sharing" behaviour without using an + object or array to contain the shared value. This can be used to + ensure the lifetime of the shared value instance. Each sharing + point adds a reference and simply passed the value to + cson_value_free() when they're done. The object will be kept alive + for other sharing points which added a reference. + + Normally any such value handles would be invalidated when the + parent container(s) is/are cleaned up, but this function can be + used to effectively delay the cleanup. + + This function, at its lowest level, increments the value's + reference count by 1. + + To decrement the reference count, pass the value to + cson_value_free(), after which the value must be considered, from + the perspective of that client code, to be destroyed (though it + will not be if there are still other live references to + it). cson_value_free() will not _actually_ destroy the value until + its reference count drops to 0. + + Returns 0 on success. The only error conditions are if v is NULL + (CSON_RC_ArgError) or if the reference increment would overflow + (CSON_RC_RangeError). In theory a client would get allocation + errors long before the reference count could overflow (assuming + those reference counts come from container insertions, as opposed + to via this function). + + Insider notes which clients really need to know: + + For shared/constant value instances, such as those returned by + cson_value_true() and cson_value_null(), this function has no side + effects - it does not actually modify the reference count because + (A) those instances are shared across all client code and (B) those + objects are static and never get cleaned up. However, that is an + implementation detail which client code should not rely on. In + other words, if you call cson_value_add_reference() 3 times using + the value returned by cson_value_true() (which is incidentally a + shared cson_value instance), you must eventually call + cson_value_free() 3 times to (semantically) remove those + references. However, internally the reference count for that + specific cson_value instance will not be modified and those + objects will never be freed (they're stack-allocated). + + It might be interesting to note that newly-created objects + have a reference count of 0 instead of 1. This is partly because + if the initial reference is counted then it makes ownership + problematic when inserting values into containers. e.g. consider the + following code: + + @code + // ACHTUNG: this code is hypothetical and does not reflect + // what actually happens! + cson_value * v = + cson_value_new_integer( 42 ); // v's refcount = 1 + cson_array_append( myArray, v ); // v's refcount = 2 + @endcode + + If that were the case, the client would be forced to free his own + reference after inserting it into the container (which is a bit + counter-intuitive as well as intrusive). It would look a bit like + the following and would have to be done after every create/insert + operation: + + @code + // ACHTUNG: this code is hypothetical and does not reflect + // what actually happens! + cson_array_append( myArray, v ); // v's refcount = 2 + cson_value_free( v ); // v's refcount = 1 + @endcode + + (As i said: it's counter-intuitive and intrusive.) + + Instead, values start with a refcount of 0 and it is only increased + when the value is added to an object/array container or when this + function is used to manually increment it. cson_value_free() treats + a refcount of 0 or 1 equivalently, destroying the value + instance. The only semantic difference between 0 and 1, for + purposes of cleaning up, is that a value with a non-0 refcount has + been had its refcount adjusted, whereas a 0 refcount indicates a + fresh, "unowned" reference. +*/ +int cson_value_add_reference( cson_value * v ); + +#if 0 +/** + DO NOT use this unless you know EXACTLY what you're doing. + It is only in the public API to work around a couple corner + cases involving extracting child elements and discarding + their parents. + + This function sets v's reference count to the given value. + It does not clean up the object if rc is 0. + + Returns 0 on success, non-0 on error. +*/ +int cson_value_refcount_set( cson_value * v, unsigned short rc ); +#endif + +/** + Deeply copies a JSON value, be it an object/array or a "plain" + value (e.g. number/string/boolean). If cv is not NULL then this + function makes a deep clone of it and returns that clone. Ownership + of the clone is identical t transfered to the caller, who must + eventually free the value using cson_value_free() or add it to a + container object/array to transfer ownership to the container. The + returned object will be of the same logical type as orig. + + ACHTUNG: if orig contains any cyclic references at any depth level + this function will endlessly recurse. (Having _any_ cyclic + references violates this library's requirements.) + + Returns NULL if orig is NULL or if cloning fails. Assuming that + orig is in a valid state, the only "likely" error case is that an + allocation fails while constructing the clone. In other words, if + cloning fails due to something other than an allocation error then + either orig is in an invalid state or there is a bug. + + When this function clones Objects or Arrays it shares any immutable + values (including object keys) between the parent and the + clone. Mutable values (Objects and Arrays) are copied, however. + For example, if we clone: + + @code + { a: 1, b: 2, c:["hi"] } + @endcode + + The cloned object and the array "c" would be a new Object/Array + instances but the object keys (a,b,b) and the values of (a,b), as + well as the string value within the "c" array, would be shared + between the original and the clone. The "c" array itself would be + deeply cloned, such that future changes to the clone are not + visible to the parent, and vice versa, but immutable values within + the array are shared (in this case the string "hi"). The + justification for this heuristic is that immutable values can never + be changed, so there is no harm in sharing them across + clones. Additionally, such types can never contribute to cycles in + a JSON tree, so they are safe to share this way. Objects and + Arrays, on the other hand, can be modified later and can contribute + to cycles, and thus the clone needs to be an independent instance. + Note, however, that if this function directly passed a + non-Object/Array, that value is deeply cloned. The sharing + behaviour only applies when traversing Objects/Arrays. +*/ +cson_value * cson_value_clone( cson_value const * orig ); + +/** + Returns the value handle associated with s. The handle itself owns + s, and ownership of the handle is not changed by calling this + function. If the returned handle is part of a container, calling + cson_value_free() on the returned handle invoked undefined + behaviour (quite possibly downstream when the container tries to + use it). + + This function only returns NULL if s is NULL. The length of the + returned string is cson_string_length_bytes(). +*/ +cson_value * cson_string_value(cson_string const * s); +/** + The Object form of cson_string_value(). See that function + for full details. +*/ +cson_value * cson_object_value(cson_object const * s); + +/** + The Array form of cson_string_value(). See that function + for full details. +*/ +cson_value * cson_array_value(cson_array const * s); + + +/** + Calculates the approximate in-memory-allocated size of v, + recursively if it is a container type, with the following caveats + and limitations: + + If a given value is reference counted and encountered multiple + times within a traversed container, each reference is counted at + full cost. We have no way of knowing if a given reference has been + visited already and whether it should or should not be counted, so + we pessimistically count them even though the _might_ not really + count for the given object tree (it depends on where the other open + references live). + + This function returns 0 if any of the following are true: + + - v is NULL + + - v is one of the special singleton values (null, bools, empty + string, int 0, double 0.0) + + All other values require an allocation, and this will return their + total memory cost, including the cson-specific internals and the + native value(s). + + Note that because arrays and objects might have more internal slots + allocated than used, the alloced size of a container does not + necessarily increase when a new item is inserted into it. An interesting + side-effect of this is that when cson_clone()ing an array or object, the + size of the clone can actually be less than the original. +*/ +unsigned int cson_value_msize(cson_value const * v); + +/** + Parses command-line-style arguments into a JSON object. + + It expects arguments to be in any of these forms, and any number + of leading dashes are treated identically: + + --key : Treats key as a boolean with a true value. + + --key=VAL : Treats VAL as either a double, integer, or string. + + --key= : Treats key as a JSON null (not literal NULL) value. + + Arguments not starting with a dash are skipped. + + Each key/value pair is inserted into an object. If a given key + appears more than once then only the final entry is actually + stored. + + argc and argv are expected to be values from main() (or similar, + possibly adjusted to remove argv[0]). + + tgt must be either a pointer to NULL or a pointer to a + client-provided Object. If (NULL==*tgt) then this function + allocates a new object and on success it stores the new object in + *tgt (it is owned by the caller). If (NULL!=*tgt) then it is + assumed to be a properly allocated object. DO NOT pass a pointer to + an unitialized pointer, as that will fool this function into + thinking it is a valid object and Undefined Behaviour will ensue. + + If count is not NULL then the number of arugments parsed by this + function are assigned to it. On error, count will be the number of + options successfully parsed before the error was encountered. + + On success: + + - 0 is returned. + + - If (*tgt==NULL) then *tgt is assigned to a newly-allocated + object, owned by the caller. Note that even if no arguments are + parsed, the object is still created. + + On error: + + - non-0 is returned + + - If (*tgt==NULL) then it is not modified. + + - If (*tgt!=NULL) (i.e., the caller provides his own object) then + it might contain partial results. +*/ +int cson_parse_argv_flags( int argc, char const * const * argv, + cson_object ** tgt, unsigned int * count ); + +/** + Return values for the cson_pack() and cson_unpack() interfaces. +*/ +enum cson_pack_retval { + /** Signals an out-of-memory error. */ + CSON_PACK_ALLOC_ERROR = -1, + /** Signals a syntax error in the format string. */ + CSON_PACK_ARG_ERROR = -2, + /** + Signals an that an internal error has occurred. + This indicates a bug in this library. + */ + CSON_PACK_INTERNAL_ERROR = -3, + /** + Signals that the JSON document does not validate agains the format + string passed to cson_unpack(). + */ + CSON_PACK_VALIDATION_ERROR = -4 +}; + +/** + Construct arbitrarily complex JSON documents from native C types. + + Create a new object or array and add or merge the passed values and + properties to it according to the supplied format string. + + fmt is a format string, it must at least contain an array or object + specifier as its root value. Format specifiers start with a percent sign '\%' + followed by one or more modifiers and a type character. Object properties + are specified as key-value pairs where the key is specified as a string and + passed as an argument of const char *. Any space, tab, carriage return, line + feed, colon and comma characters between format specifiers are ignored. + + | Type | Description | + | :--: | :---------- | + | s | creates either a property name or a string value, in case of the former the corresponding argument is a pointer to const char which is a sequence of bytes specifying the name of the property that is to be created, in case of the latter the corresponding argument is a pointer to const char | + | d | creates an integer value, the corresponding argument is an int | + | i | ^ | + | f | creates a floating point value, the corresponding argument is a double | + | b | creates a boolean value, the corresponding argument is an int | + | N | creates a null value | + | [...] | creates an array, the corresponding argument is a pointer to a cson_array | + | {...} | creates an array, the corresponding argument is a pointer to a cson_object | + + | Modifier | Description | + | :------: | :---------- | + | l | specifies that the following d or i specifier applies to an argument which is a pointer to long | + | ll | specifies that the following d or i specifier applies to an argument which is a pointer to cson_int_t | + + | Short Form | Expands to + | :--------: | :--------- | + | {...} | %*{...} | + | [...] | %*[...] | + | \%D | \%lld | + + + Returns 0 on success. The error conditions are: + + - CSON_PACK_ARG_ERROR: fmt contains a syntax error + + - CSON_PACK_ALLOC_ERROR: a memory allocation failed + + - CSON_PACK_INTERNAL_ERROR: an internal error has occurred, this is a bug in + cson + + Example: + @code + cson_value * root_value; + cson_array * arr; + ... + rc = cson_pack( root_value, "{%s: %d, %s: %[]}", "foo", 42, "bar", arr ); + if( 0 != rc ) { + ... error ... + } + @endcode +*/ +int cson_pack( cson_value **root_valuep, const char *fmt, ... ); + +/** + Same as cson_pack() except that it takes a va_list instead of a variable + number of arguments. +*/ +int cson_vpack( cson_value **root_valuep, const char *fmt, va_list args ); + +/** + Iterate over the given object or array and convert an arbitrary number of + JSON values into their native C types or validates them according to the + given format string fmt. + + fmt is a format string, it must at least contain an array or object + specifier as its root value. Format specifiers start with a percent sign '\%' + followed by one or more modifiers and a type character. Object properties + are specified as key-value pairs where the key is specified as a string and + passed as an argument of const char *. Any space, tab, carriage return, line + feed, colon and comma characters between format specifiers are ignored. + + | Type | Description | + | :--: | :---------- | + | s | matches a either a property name or a string value, in case of the former the corresponding argument is a pointer to const char which is a sequence of bytes specifying the name of the property that is to be matched, in case of the latter the corresponding argument is a pointer to a pointer to const char unless the 'm' modifier is specified where the the corresponding argument is a pointer to a pointer to char | + | d | matches an integer value and must be used in with the "ll" modifier, the corresponding argument is a pointer to cson_int_t | + | i | ^ | + | f | matches a floating point value, the corresponding argument is a pointer to double | + | b | matches a boolean value, the corresponding argument is a pointer to int | + | N | matches a null value | + | [...] | matches an array, the corresponding argument is a pointer to a pointer to a cson_array | + | {...} | matches an array, the corresponding argument is a pointer to a pointer to a cson_object | + + | Modifier | Description | + | :------: | :---------- | + | ? | specifies that the property reffered to by the given property name is optional | + | * | suppresses assignment, only check for the presence and type of the specified value | + | m | allocates a memory buffer for the extracted string | + | ll | specifies that the following d or i specifier applies to an argument which is a pointer to cson_int_t | + + | Short Form | Expands to + | :--------: | :--------- | + | {...} | %*{...} | + | [...] | %*[...] | + | \%D | \%lld | + + Returns 0 on success. The error conditions are: + + - CSON_PACK_ARG_ERROR: fmt contains a syntax error + + - CSON_PACK_ALLOC_ERROR: a memory allocation failed + + - CSON_PACK_VALIDATION_ERROR: validation failed, the JSON document structure + differs from that described by the format string + + - CSON_PACK_INTERNAL_ERROR: an internal error has occurred, this + indicates a bug in this library. + + Example: + @code + cson_value * root_value; + cson_int_t x = 0; + cson_array * arr = NULL; + const char *str = NULL; + ... + rc = cson_unpack( root_value, "{%s: %d, %s: %[], %?s: %s}", "foo", &x, "bar", &arr, "baz", &str ); + if( rc < 3 && rc >= 0 ) { + ... optional property is missing ... + } else if ( CSON_PACK_ALLOC_ERROR == rc ) { + ... out of memory error ... + } else if ( CSON_PACK_VALIDATION_ERROR == rc ) { + ... unexpected JSON document structure ... + } else if ( rc ) { + ... internal error ... + } + @endcode + +*/ +int cson_unpack( cson_value *root_value, const char *fmt, ... ); + +/** + Same as cson_unpack() except that it takes a va_list instead of a variable + number of arguments. +*/ +int cson_vunpack( cson_value *root_value, const char *fmt, va_list args ); + +/* LICENSE + +This software's source code, including accompanying documentation and +demonstration applications, are licensed under the following +conditions... + +Certain files are imported from external projects and have their own +licensing terms. Namely, the JSON_parser.* files. See their files for +their official licenses, but the summary is "do what you want [with +them] but leave the license text and copyright in place." + +The author (Stephan G. Beal [http://wanderinghorse.net/home/stephan/]) +explicitly disclaims copyright in all jurisdictions which recognize +such a disclaimer. In such jurisdictions, this software is released +into the Public Domain. + +In jurisdictions which do not recognize Public Domain property +(e.g. Germany as of 2011), this software is Copyright (c) 2011 by +Stephan G. Beal, and is released under the terms of the MIT License +(see below). + +In jurisdictions which recognize Public Domain property, the user of +this software may choose to accept it either as 1) Public Domain, 2) +under the conditions of the MIT License (see below), or 3) under the +terms of dual Public Domain/MIT License conditions described here, as +they choose. + +The MIT License is about as close to Public Domain as a license can +get, and is described in clear, concise terms at: + + http://en.wikipedia.org/wiki/MIT_License + +The full text of the MIT License follows: + +-- +Copyright (c) 2011 Stephan G. Beal (http://wanderinghorse.net/home/stephan/) + +Permission is hereby granted, free of charge, to any person +obtaining a copy of this software and associated documentation +files (the "Software"), to deal in the Software without +restriction, including without limitation the rights to use, +copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the +Software is furnished to do so, subject to the following +conditions: + +The above copyright notice and this permission notice shall be +included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES +OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT +HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, +WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR +OTHER DEALINGS IN THE SOFTWARE. + +--END OF MIT LICENSE-- + +For purposes of the above license, the term "Software" includes +documentation and demonstration source code which accompanies +this software. ("Accompanies" = is contained in the Software's +primary public source code repository.) + +*/ + +#if defined(__cplusplus) +} /*extern "C"*/ +#endif + +#endif /* WANDERINGHORSE_NET_CSON_H_INCLUDED */ +/* end file include/wh/cson/cson.h */ +/* begin file include/wh/cson/cson_sqlite3.h */ +/** @file cson_sqlite3.h + +This file contains cson's public sqlite3-to-JSON API declarations +and API documentation. If CSON_ENABLE_SQLITE3 is not defined, +or is defined to 0, then including this file will have no side-effects +other than defining CSON_ENABLE_SQLITE3 (if it was not defined) to 0 +and defining a few include guard macros. i.e. if CSON_ENABLE_SQLITE3 +is not set to a true value then the API is not visible. + +This API requires that be in the INCLUDES path and that +the client eventually link to (or directly embed) the sqlite3 library. +*/ +#if !defined(WANDERINGHORSE_NET_CSON_SQLITE3_H_INCLUDED) +#define WANDERINGHORSE_NET_CSON_SQLITE3_H_INCLUDED 1 +#if !defined(CSON_ENABLE_SQLITE3) +# if defined(DOXYGEN) +#define CSON_ENABLE_SQLITE3 1 +# else +#define CSON_ENABLE_SQLITE3 1 +# endif +#endif + +#if CSON_ENABLE_SQLITE3 /* we do this here for the sake of the amalgamation build */ +#include "sqlite3.h" + +#if defined(__cplusplus) +extern "C" { +#endif + +/** + Converts a single value from a single 0-based column index to its JSON + equivalent. + + On success it returns a new JSON value, which will have a different concrete + type depending on the field type reported by sqlite3_column_type(st,col): + + Integer, double, null, or string (TEXT and BLOB data, though not + all blob data is legal for a JSON string). + + st must be a sqlite3_step()'d row and col must be a 0-based column + index within that result row. + */ +cson_value * cson_sqlite3_column_to_value( sqlite3_stmt * st, int col ); + +/** + Creates a JSON Array object containing the names of all columns + of the given prepared statement handle. + + Returns a new array value on success, which the caller owns. Its elements + are in the same order as in the underlying query. + + On error NULL is returned. + + st is not traversed or freed by this function - only the column + count and names are read. +*/ +cson_value * cson_sqlite3_column_names( sqlite3_stmt * st ); + +/** + Creates a JSON Object containing key/value pairs corresponding + to the result columns in the current row of the given statement + handle. st must be a sqlite3_step()'d row result. + + On success a new Object is returned which is owned by the + caller. On error NULL is returned. + + cson_sqlite3_column_to_value() is used to convert each column to a + JSON value, and the column names are taken from + sqlite3_column_name(). +*/ +cson_value * cson_sqlite3_row_to_object( sqlite3_stmt * st ); +/** + Functionally almost identical to cson_sqlite3_row_to_object(), the + only difference being how the result objects gets its column names. + st must be a freshly-step()'d handle holding a result row. + colNames must be an Array with at least the same number of columns + as st. If it has fewer, NULL is returned and this function has + no side-effects. + + For each column in the result set, the colNames entry at the same + index is used for the column key. If a given entry is-not-a String + then conversion will fail and NULL will be returned. + + The one reason to prefer this over cson_sqlite3_row_to_object() is + that this one can share the keys across multiple rows (or even + other JSON containers), whereas the former makes fresh copies of + the column names for each row. + +*/ +cson_value * cson_sqlite3_row_to_object2( sqlite3_stmt * st, + cson_array * colNames ); + +/** + Similar to cson_sqlite3_row_to_object(), but creates an Array + value which contains the JSON-form values of the given result + set row. +*/ +cson_value * cson_sqlite3_row_to_array( sqlite3_stmt * st ); +/** + Converts the results of an sqlite3 SELECT statement to JSON, + in the form of a cson_value object tree. + + st must be a prepared, but not yet traversed, SELECT query. + tgt must be a pointer to NULL (see the example below). If + either of those arguments are NULL, cson_rc.ArgError is returned. + + This walks the query results and returns a JSON object which + has a different structure depending on the value of the 'fat' + argument. + + + If 'fat' is 0 then the structure is: + + @code + { + "columns":["colName1",..."colNameN"], + "rows":[ + [colVal0, ... colValN], + [colVal0, ... colValN], + ... + ] + } + @endcode + + In the "non-fat" format the order of the columns and row values is + guaranteed to be the same as that of the underlying query. + + If 'fat' is not 0 then the structure is: + + @code + { + "columns":["colName1",..."colNameN"], + "rows":[ + {"colName1":value1,..."colNameN":valueN}, + {"colName1":value1,..."colNameN":valueN}, + ... + ] + } + @endcode + + In the "fat" format, the order of the "columns" entries is guaranteed + to be the same as the underlying query fields, but the order + of the keys in the "rows" might be different and might in fact + change when passed through different JSON implementations, + depending on how they implement object key/value pairs. + + On success it returns 0 and assigns *tgt to a newly-allocated + JSON object tree (using the above structure), which the caller owns. + If the query returns no rows, the "rows" value will be an empty + array, as opposed to null. + + On error non-0 is returned and *tgt is not modified. + + The error code cson_rc.IOError is used to indicate a db-level + error, and cson_rc.TypeError is returned if sqlite3_column_count(st) + returns 0 or less (indicating an invalid or non-SELECT statement). + + The JSON data types are determined by the column type as reported + by sqlite3_column_type(): + + SQLITE_INTEGER: integer + + SQLITE_FLOAT: double + + SQLITE_TEXT or SQLITE_BLOB: string, and this will only work if + the data is UTF8 compatible. + + If the db returns a literal or SQL NULL for a value it is converted + to a JSON null. If it somehow finds a column type it cannot handle, + the value is also converted to a NULL in the output. + + Example + + @code + cson_value * json = NULL; + int rc = cson_sqlite3_stmt_to_json( myStatement, &json, 1 ); + if( 0 != rc ) { ... error ... } + else { + cson_output_FILE( json, stdout, NULL ); + cson_value_free( json ); + } + @endcode +*/ +int cson_sqlite3_stmt_to_json( sqlite3_stmt * st, cson_value ** tgt, char fat ); + +/** + A convenience wrapper around cson_sqlite3_stmt_to_json(), which + takes SQL instead of a sqlite3_stmt object. It has the same + return value and argument semantics as that function. +*/ +int cson_sqlite3_sql_to_json( sqlite3 * db, cson_value ** tgt, char const * sql, char fat ); + +/** + Binds a JSON value to a 1-based parameter index in a prepared SQL + statement. v must be NULL or one of one of the types (null, string, + integer, double, boolean, array). Booleans are bound as integer 0 + or 1. NULL or null are bound as SQL NULL. Integers are bound as + 64-bit ints. Strings are bound using sqlite3_bind_text() (as + opposed to text16), but we could/should arguably bind them as + blobs. + + If v is an Array then ndx is is used as a starting position + (1-based) and each item in the array is bound to the next parameter + position (starting and ndx, though the array uses 0-based offsets). + + TODO: add Object support for named parameters. + + Returns 0 on success, non-0 on error. + */ +int cson_sqlite3_bind_value( sqlite3_stmt * st, int ndx, cson_value const * v ); + +#if defined(__cplusplus) +} /*extern "C"*/ +#endif + +#endif /* CSON_ENABLE_SQLITE3 */ +#endif /* WANDERINGHORSE_NET_CSON_SQLITE3_H_INCLUDED */ +/* end file include/wh/cson/cson_sqlite3.h */ +#endif /* FOSSIL_ENABLE_JSON */ diff --git a/extsrc/linenoise-win32.c b/extsrc/linenoise-win32.c new file mode 100644 index 0000000..716b26c --- /dev/null +++ b/extsrc/linenoise-win32.c @@ -0,0 +1,379 @@ + +/* this code is not standalone + * it is included into linenoise.c + * for windows. + * It is deliberately kept separate so that + * applications that have no need for windows + * support can omit this + */ +static DWORD orig_consolemode = 0; + +static int flushOutput(struct current *current); +static void outputNewline(struct current *current); + +static void refreshStart(struct current *current) +{ + (void)current; +} + +static void refreshEnd(struct current *current) +{ + (void)current; +} + +static void refreshStartChars(struct current *current) +{ + assert(current->output == NULL); + /* We accumulate all output here */ + current->output = sb_alloc(); +#ifdef USE_UTF8 + current->ubuflen = 0; +#endif +} + +static void refreshNewline(struct current *current) +{ + DRL(""); + outputNewline(current); +} + +static void refreshEndChars(struct current *current) +{ + assert(current->output); + flushOutput(current); + sb_free(current->output); + current->output = NULL; +} + +static int enableRawMode(struct current *current) { + DWORD n; + INPUT_RECORD irec; + + current->outh = GetStdHandle(STD_OUTPUT_HANDLE); + current->inh = GetStdHandle(STD_INPUT_HANDLE); + + if (!PeekConsoleInput(current->inh, &irec, 1, &n)) { + return -1; + } + if (getWindowSize(current) != 0) { + return -1; + } + if (GetConsoleMode(current->inh, &orig_consolemode)) { + SetConsoleMode(current->inh, ENABLE_PROCESSED_INPUT); + } +#ifdef USE_UTF8 + /* XXX is this the right thing to do? */ + SetConsoleCP(65001); +#endif + return 0; +} + +static void disableRawMode(struct current *current) +{ + SetConsoleMode(current->inh, orig_consolemode); +} + +void linenoiseClearScreen(void) +{ + /* XXX: This is ugly. Should just have the caller pass a handle */ + struct current current; + + current.outh = GetStdHandle(STD_OUTPUT_HANDLE); + + if (getWindowSize(¤t) == 0) { + COORD topleft = { 0, 0 }; + DWORD n; + + FillConsoleOutputCharacter(current.outh, ' ', + current.cols * current.rows, topleft, &n); + FillConsoleOutputAttribute(current.outh, + FOREGROUND_RED | FOREGROUND_BLUE | FOREGROUND_GREEN, + current.cols * current.rows, topleft, &n); + SetConsoleCursorPosition(current.outh, topleft); + } +} + +static void cursorToLeft(struct current *current) +{ + COORD pos; + DWORD n; + + pos.X = 0; + pos.Y = (SHORT)current->y; + + FillConsoleOutputAttribute(current->outh, + FOREGROUND_RED | FOREGROUND_BLUE | FOREGROUND_GREEN, current->cols, pos, &n); + current->x = 0; +} + +#ifdef USE_UTF8 +static void flush_ubuf(struct current *current) +{ + COORD pos; + DWORD nwritten; + pos.Y = (SHORT)current->y; + pos.X = (SHORT)current->x; + SetConsoleCursorPosition(current->outh, pos); + WriteConsoleW(current->outh, current->ubuf, current->ubuflen, &nwritten, 0); + current->x += current->ubufcols; + current->ubuflen = 0; + current->ubufcols = 0; +} + +static void add_ubuf(struct current *current, int ch) +{ + /* This code originally by: Author: Mark E. Davis, 1994. */ + static const int halfShift = 10; /* used for shifting by 10 bits */ + + static const DWORD halfBase = 0x0010000UL; + static const DWORD halfMask = 0x3FFUL; + + #define UNI_SUR_HIGH_START 0xD800 + #define UNI_SUR_HIGH_END 0xDBFF + #define UNI_SUR_LOW_START 0xDC00 + #define UNI_SUR_LOW_END 0xDFFF + + #define UNI_MAX_BMP 0x0000FFFF + + if (ch > UNI_MAX_BMP) { + /* convert from unicode to utf16 surrogate pairs + * There is always space for one extra word in ubuf + */ + ch -= halfBase; + current->ubuf[current->ubuflen++] = (WORD)((ch >> halfShift) + UNI_SUR_HIGH_START); + current->ubuf[current->ubuflen++] = (WORD)((ch & halfMask) + UNI_SUR_LOW_START); + } + else { + current->ubuf[current->ubuflen++] = ch; + } + current->ubufcols += utf8_width(ch); + if (current->ubuflen >= UBUF_MAX_CHARS) { + flush_ubuf(current); + } +} +#endif + +static int flushOutput(struct current *current) +{ + const char *pt = sb_str(current->output); + int len = sb_len(current->output); + +#ifdef USE_UTF8 + /* convert utf8 in current->output into utf16 in current->ubuf + */ + while (len) { + int ch; + int n = utf8_tounicode(pt, &ch); + + pt += n; + len -= n; + + add_ubuf(current, ch); + } + flush_ubuf(current); +#else + DWORD nwritten; + COORD pos; + + pos.Y = (SHORT)current->y; + pos.X = (SHORT)current->x; + + SetConsoleCursorPosition(current->outh, pos); + WriteConsoleA(current->outh, pt, len, &nwritten, 0); + + current->x += len; +#endif + + sb_clear(current->output); + + return 0; +} + +static int outputChars(struct current *current, const char *buf, int len) +{ + if (len < 0) { + len = strlen(buf); + } + assert(current->output); + + sb_append_len(current->output, buf, len); + + return 0; +} + +static void outputNewline(struct current *current) +{ + /* On the last row output a newline to force a scroll */ + if (current->y + 1 == current->rows) { + outputChars(current, "\n", 1); + } + flushOutput(current); + current->x = 0; + current->y++; +} + +static void setOutputHighlight(struct current *current, const int *props, int nprops) +{ + int colour = FOREGROUND_RED | FOREGROUND_BLUE | FOREGROUND_GREEN; + int bold = 0; + int reverse = 0; + int i; + + for (i = 0; i < nprops; i++) { + switch (props[i]) { + case 0: + colour = FOREGROUND_RED | FOREGROUND_BLUE | FOREGROUND_GREEN; + bold = 0; + reverse = 0; + break; + case 1: + bold = FOREGROUND_INTENSITY; + break; + case 7: + reverse = 1; + break; + case 30: + colour = 0; + break; + case 31: + colour = FOREGROUND_RED; + break; + case 32: + colour = FOREGROUND_GREEN; + break; + case 33: + colour = FOREGROUND_RED | FOREGROUND_GREEN; + break; + case 34: + colour = FOREGROUND_BLUE; + break; + case 35: + colour = FOREGROUND_RED | FOREGROUND_BLUE; + break; + case 36: + colour = FOREGROUND_BLUE | FOREGROUND_GREEN; + break; + case 37: + colour = FOREGROUND_RED | FOREGROUND_BLUE | FOREGROUND_GREEN; + break; + } + } + + flushOutput(current); + + if (reverse) { + SetConsoleTextAttribute(current->outh, BACKGROUND_INTENSITY); + } + else { + SetConsoleTextAttribute(current->outh, colour | bold); + } +} + +static void eraseEol(struct current *current) +{ + COORD pos; + DWORD n; + + pos.X = (SHORT) current->x; + pos.Y = (SHORT) current->y; + + FillConsoleOutputCharacter(current->outh, ' ', current->cols - current->x, pos, &n); +} + +static void setCursorXY(struct current *current) +{ + COORD pos; + + pos.X = (SHORT) current->x; + pos.Y = (SHORT) current->y; + + SetConsoleCursorPosition(current->outh, pos); +} + + +static void setCursorPos(struct current *current, int x) +{ + current->x = x; + setCursorXY(current); +} + +static void cursorUp(struct current *current, int n) +{ + current->y -= n; + setCursorXY(current); +} + +static void cursorDown(struct current *current, int n) +{ + current->y += n; + setCursorXY(current); +} + +static int fd_read(struct current *current) +{ + while (1) { + INPUT_RECORD irec; + DWORD n; + if (WaitForSingleObject(current->inh, INFINITE) != WAIT_OBJECT_0) { + break; + } + if (!ReadConsoleInputW(current->inh, &irec, 1, &n)) { + break; + } + if (irec.EventType == KEY_EVENT) { + KEY_EVENT_RECORD *k = &irec.Event.KeyEvent; + if (k->bKeyDown || k->wVirtualKeyCode == VK_MENU) { + if (k->dwControlKeyState & ENHANCED_KEY) { + switch (k->wVirtualKeyCode) { + case VK_LEFT: + return SPECIAL_LEFT; + case VK_RIGHT: + return SPECIAL_RIGHT; + case VK_UP: + return SPECIAL_UP; + case VK_DOWN: + return SPECIAL_DOWN; + case VK_INSERT: + return SPECIAL_INSERT; + case VK_DELETE: + return SPECIAL_DELETE; + case VK_HOME: + return SPECIAL_HOME; + case VK_END: + return SPECIAL_END; + case VK_PRIOR: + return SPECIAL_PAGE_UP; + case VK_NEXT: + return SPECIAL_PAGE_DOWN; + case VK_RETURN: + return k->uChar.UnicodeChar; + } + } + /* Note that control characters are already translated in AsciiChar */ + else if (k->wVirtualKeyCode == VK_CONTROL) + continue; + else { + return k->uChar.UnicodeChar; + } + } + } + } + return -1; +} + +static int getWindowSize(struct current *current) +{ + CONSOLE_SCREEN_BUFFER_INFO info; + if (!GetConsoleScreenBufferInfo(current->outh, &info)) { + return -1; + } + current->cols = info.dwSize.X; + current->rows = info.dwSize.Y; + if (current->cols <= 0 || current->rows <= 0) { + current->cols = 80; + return -1; + } + current->y = info.dwCursorPosition.Y; + current->x = info.dwCursorPosition.X; + return 0; +} diff --git a/extsrc/linenoise.c b/extsrc/linenoise.c new file mode 100644 index 0000000..0541382 --- /dev/null +++ b/extsrc/linenoise.c @@ -0,0 +1,2812 @@ +#line 1 "utf8.h" +#ifndef UTF8_UTIL_H +#define UTF8_UTIL_H + +#ifdef __cplusplus +extern "C" { +#endif + +/** + * UTF-8 utility functions + * + * (c) 2010-2019 Steve Bennett + * + * See utf8.c for licence details. + */ + +#ifndef USE_UTF8 +#include + +#define MAX_UTF8_LEN 1 + +/* No utf-8 support. 1 byte = 1 char */ +#define utf8_strlen(S, B) ((B) < 0 ? (int)strlen(S) : (B)) +#define utf8_strwidth(S, B) utf8_strlen((S), (B)) +#define utf8_tounicode(S, CP) (*(CP) = (unsigned char)*(S), 1) +#define utf8_index(C, I) (I) +#define utf8_charlen(C) 1 + #define utf8_width(C) 1 + +#else + +#define MAX_UTF8_LEN 4 + +/** + * Converts the given unicode codepoint (0 - 0x1fffff) to utf-8 + * and stores the result at 'p'. + * + * Returns the number of utf-8 characters + */ +int utf8_fromunicode(char *p, unsigned uc); + +/** + * Returns the length of the utf-8 sequence starting with 'c'. + * + * Returns 1-4, or -1 if this is not a valid start byte. + * + * Note that charlen=4 is not supported by the rest of the API. + */ +int utf8_charlen(int c); + +/** + * Returns the number of characters in the utf-8 + * string of the given byte length. + * + * Any bytes which are not part of an valid utf-8 + * sequence are treated as individual characters. + * + * The string *must* be null terminated. + * + * Does not support unicode code points > \u1fffff + */ +int utf8_strlen(const char *str, int bytelen); + +/** + * Calculates the display width of the first 'charlen' characters in 'str'. + * See utf8_width() + */ +int utf8_strwidth(const char *str, int charlen); + +/** + * Returns the byte index of the given character in the utf-8 string. + * + * The string *must* be null terminated. + * + * This will return the byte length of a utf-8 string + * if given the char length. + */ +int utf8_index(const char *str, int charindex); + +/** + * Returns the unicode codepoint corresponding to the + * utf-8 sequence 'str'. + * + * Stores the result in *uc and returns the number of bytes + * consumed. + * + * If 'str' is null terminated, then an invalid utf-8 sequence + * at the end of the string will be returned as individual bytes. + * + * If it is not null terminated, the length *must* be checked first. + * + * Does not support unicode code points > \u1fffff + */ +int utf8_tounicode(const char *str, int *uc); + +/** + * Returns the width (in characters) of the given unicode codepoint. + * This is 1 for normal letters and 0 for combining characters and 2 for wide characters. + */ +int utf8_width(int ch); + +#endif + +#ifdef __cplusplus +} +#endif + +#endif +#line 1 "utf8.c" +/** + * UTF-8 utility functions + * + * (c) 2010-2019 Steve Bennett + * + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * * Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * + * * Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR + * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON + * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include +#include +#include +#include +#ifndef UTF8_UTIL_H +#include "utf8.h" +#endif + +#ifdef USE_UTF8 +int utf8_fromunicode(char *p, unsigned uc) +{ + if (uc <= 0x7f) { + *p = uc; + return 1; + } + else if (uc <= 0x7ff) { + *p++ = 0xc0 | ((uc & 0x7c0) >> 6); + *p = 0x80 | (uc & 0x3f); + return 2; + } + else if (uc <= 0xffff) { + *p++ = 0xe0 | ((uc & 0xf000) >> 12); + *p++ = 0x80 | ((uc & 0xfc0) >> 6); + *p = 0x80 | (uc & 0x3f); + return 3; + } + /* Note: We silently truncate to 21 bits here: 0x1fffff */ + else { + *p++ = 0xf0 | ((uc & 0x1c0000) >> 18); + *p++ = 0x80 | ((uc & 0x3f000) >> 12); + *p++ = 0x80 | ((uc & 0xfc0) >> 6); + *p = 0x80 | (uc & 0x3f); + return 4; + } +} + +int utf8_charlen(int c) +{ + if ((c & 0x80) == 0) { + return 1; + } + if ((c & 0xe0) == 0xc0) { + return 2; + } + if ((c & 0xf0) == 0xe0) { + return 3; + } + if ((c & 0xf8) == 0xf0) { + return 4; + } + /* Invalid sequence */ + return -1; +} + +int utf8_strlen(const char *str, int bytelen) +{ + int charlen = 0; + if (bytelen < 0) { + bytelen = strlen(str); + } + while (bytelen > 0) { + int c; + int l = utf8_tounicode(str, &c); + charlen++; + str += l; + bytelen -= l; + } + return charlen; +} + +int utf8_strwidth(const char *str, int charlen) +{ + int width = 0; + while (charlen) { + int c; + int l = utf8_tounicode(str, &c); + width += utf8_width(c); + str += l; + charlen--; + } + return width; +} + +int utf8_index(const char *str, int index) +{ + const char *s = str; + while (index--) { + int c; + s += utf8_tounicode(s, &c); + } + return s - str; +} + +int utf8_tounicode(const char *str, int *uc) +{ + unsigned const char *s = (unsigned const char *)str; + + if (s[0] < 0xc0) { + *uc = s[0]; + return 1; + } + if (s[0] < 0xe0) { + if ((s[1] & 0xc0) == 0x80) { + *uc = ((s[0] & ~0xc0) << 6) | (s[1] & ~0x80); + if (*uc >= 0x80) { + return 2; + } + /* Otherwise this is an invalid sequence */ + } + } + else if (s[0] < 0xf0) { + if (((str[1] & 0xc0) == 0x80) && ((str[2] & 0xc0) == 0x80)) { + *uc = ((s[0] & ~0xe0) << 12) | ((s[1] & ~0x80) << 6) | (s[2] & ~0x80); + if (*uc >= 0x800) { + return 3; + } + /* Otherwise this is an invalid sequence */ + } + } + else if (s[0] < 0xf8) { + if (((str[1] & 0xc0) == 0x80) && ((str[2] & 0xc0) == 0x80) && ((str[3] & 0xc0) == 0x80)) { + *uc = ((s[0] & ~0xf0) << 18) | ((s[1] & ~0x80) << 12) | ((s[2] & ~0x80) << 6) | (s[3] & ~0x80); + if (*uc >= 0x10000) { + return 4; + } + /* Otherwise this is an invalid sequence */ + } + } + + /* Invalid sequence, so just return the byte */ + *uc = *s; + return 1; +} + +struct utf8range { + int lower; /* lower inclusive */ + int upper; /* upper exclusive */ +}; + +/* From http://unicode.org/Public/UNIDATA/UnicodeData.txt */ +static const struct utf8range unicode_range_combining[] = { + { 0x0300, 0x0370 }, { 0x0483, 0x048a }, { 0x0591, 0x05d0 }, { 0x0610, 0x061b }, + { 0x064b, 0x0660 }, { 0x0670, 0x0671 }, { 0x06d6, 0x06dd }, { 0x06df, 0x06e5 }, + { 0x06e7, 0x06ee }, { 0x0711, 0x0712 }, { 0x0730, 0x074d }, { 0x07a6, 0x07b1 }, + { 0x07eb, 0x07f4 }, { 0x0816, 0x0830 }, { 0x0859, 0x085e }, { 0x08d4, 0x0904 }, + { 0x093a, 0x0958 }, { 0x0962, 0x0964 }, { 0x0981, 0x0985 }, { 0x09bc, 0x09ce }, + { 0x09d7, 0x09dc }, { 0x09e2, 0x09e6 }, { 0x0a01, 0x0a05 }, { 0x0a3c, 0x0a59 }, + { 0x0a70, 0x0a72 }, { 0x0a75, 0x0a85 }, { 0x0abc, 0x0ad0 }, { 0x0ae2, 0x0ae6 }, + { 0x0afa, 0x0b05 }, { 0x0b3c, 0x0b5c }, { 0x0b62, 0x0b66 }, { 0x0b82, 0x0b83 }, + { 0x0bbe, 0x0bd0 }, { 0x0bd7, 0x0be6 }, { 0x0c00, 0x0c05 }, { 0x0c3e, 0x0c58 }, + { 0x0c62, 0x0c66 }, { 0x0c81, 0x0c85 }, { 0x0cbc, 0x0cde }, { 0x0ce2, 0x0ce6 }, + { 0x0d00, 0x0d05 }, { 0x0d3b, 0x0d4e }, { 0x0d57, 0x0d58 }, { 0x0d62, 0x0d66 }, + { 0x0d82, 0x0d85 }, { 0x0dca, 0x0de6 }, { 0x0df2, 0x0df4 }, { 0x0e31, 0x0e32 }, + { 0x0e34, 0x0e3f }, { 0x0e47, 0x0e4f }, { 0x0eb1, 0x0eb2 }, { 0x0eb4, 0x0ebd }, + { 0x0ec8, 0x0ed0 }, { 0x0f18, 0x0f1a }, { 0x0f35, 0x0f3a }, { 0x0f3e, 0x0f40 }, + { 0x0f71, 0x0f88 }, { 0x0f8d, 0x0fbe }, { 0x0fc6, 0x0fc7 }, { 0x102b, 0x103f }, + { 0x1056, 0x105a }, { 0x105e, 0x1065 }, { 0x1067, 0x106e }, { 0x1071, 0x1075 }, + { 0x1082, 0x1090 }, { 0x109a, 0x109e }, { 0x135d, 0x1360 }, { 0x1712, 0x1720 }, + { 0x1732, 0x1735 }, { 0x1752, 0x1760 }, { 0x1772, 0x1780 }, { 0x17b4, 0x17d4 }, + { 0x17dd, 0x17e0 }, { 0x180b, 0x180e }, { 0x1885, 0x1887 }, { 0x18a9, 0x18aa }, + { 0x1920, 0x1940 }, { 0x1a17, 0x1a1e }, { 0x1a55, 0x1a80 }, { 0x1ab0, 0x1b05 }, + { 0x1b34, 0x1b45 }, { 0x1b6b, 0x1b74 }, { 0x1b80, 0x1b83 }, { 0x1ba1, 0x1bae }, + { 0x1be6, 0x1bfc }, { 0x1c24, 0x1c3b }, { 0x1cd0, 0x1ce9 }, { 0x1ced, 0x1cee }, + { 0x1cf2, 0x1cf5 }, { 0x1cf7, 0x1d00 }, { 0x1dc0, 0x1e00 }, { 0x20d0, 0x2100 }, + { 0x2cef, 0x2cf2 }, { 0x2d7f, 0x2d80 }, { 0x2de0, 0x2e00 }, { 0x302a, 0x3030 }, + { 0x3099, 0x309b }, { 0xa66f, 0xa67e }, { 0xa69e, 0xa6a0 }, { 0xa6f0, 0xa6f2 }, + { 0xa802, 0xa803 }, { 0xa806, 0xa807 }, { 0xa80b, 0xa80c }, { 0xa823, 0xa828 }, + { 0xa880, 0xa882 }, { 0xa8b4, 0xa8ce }, { 0xa8e0, 0xa8f2 }, { 0xa926, 0xa92e }, + { 0xa947, 0xa95f }, { 0xa980, 0xa984 }, { 0xa9b3, 0xa9c1 }, { 0xa9e5, 0xa9e6 }, + { 0xaa29, 0xaa40 }, { 0xaa43, 0xaa44 }, { 0xaa4c, 0xaa50 }, { 0xaa7b, 0xaa7e }, + { 0xaab0, 0xaab5 }, { 0xaab7, 0xaab9 }, { 0xaabe, 0xaac2 }, { 0xaaeb, 0xaaf0 }, + { 0xaaf5, 0xab01 }, { 0xabe3, 0xabf0 }, { 0xfb1e, 0xfb1f }, { 0xfe00, 0xfe10 }, + { 0xfe20, 0xfe30 }, +}; + +/* From http://unicode.org/Public/UNIDATA/EastAsianWidth.txt */ +static const struct utf8range unicode_range_wide[] = { + { 0x1100, 0x115f }, { 0x231a, 0x231b }, { 0x2329, 0x232a }, { 0x23e9, 0x23ec }, + { 0x23f0, 0x23f0 }, { 0x23f3, 0x23f3 }, { 0x25fd, 0x25fe }, { 0x2614, 0x2615 }, + { 0x2648, 0x2653 }, { 0x267f, 0x267f }, { 0x2693, 0x2693 }, { 0x26a1, 0x26a1 }, + { 0x26aa, 0x26ab }, { 0x26bd, 0x26be }, { 0x26c4, 0x26c5 }, { 0x26ce, 0x26ce }, + { 0x26d4, 0x26d4 }, { 0x26ea, 0x26ea }, { 0x26f2, 0x26f3 }, { 0x26f5, 0x26f5 }, + { 0x26fa, 0x26fa }, { 0x26fd, 0x26fd }, { 0x2705, 0x2705 }, { 0x270a, 0x270b }, + { 0x2728, 0x2728 }, { 0x274c, 0x274c }, { 0x274e, 0x274e }, { 0x2753, 0x2755 }, + { 0x2757, 0x2757 }, { 0x2795, 0x2797 }, { 0x27b0, 0x27b0 }, { 0x27bf, 0x27bf }, + { 0x2b1b, 0x2b1c }, { 0x2b50, 0x2b50 }, { 0x2b55, 0x2b55 }, { 0x2e80, 0x2e99 }, + { 0x2e9b, 0x2ef3 }, { 0x2f00, 0x2fd5 }, { 0x2ff0, 0x2ffb }, { 0x3001, 0x303e }, + { 0x3041, 0x3096 }, { 0x3099, 0x30ff }, { 0x3105, 0x312e }, { 0x3131, 0x318e }, + { 0x3190, 0x31ba }, { 0x31c0, 0x31e3 }, { 0x31f0, 0x321e }, { 0x3220, 0x3247 }, + { 0x3250, 0x32fe }, { 0x3300, 0x4dbf }, { 0x4e00, 0xa48c }, { 0xa490, 0xa4c6 }, + { 0xa960, 0xa97c }, { 0xac00, 0xd7a3 }, { 0xf900, 0xfaff }, { 0xfe10, 0xfe19 }, + { 0xfe30, 0xfe52 }, { 0xfe54, 0xfe66 }, { 0xfe68, 0xfe6b }, { 0x16fe0, 0x16fe1 }, + { 0x17000, 0x187ec }, { 0x18800, 0x18af2 }, { 0x1b000, 0x1b11e }, { 0x1b170, 0x1b2fb }, + { 0x1f004, 0x1f004 }, { 0x1f0cf, 0x1f0cf }, { 0x1f18e, 0x1f18e }, { 0x1f191, 0x1f19a }, + { 0x1f200, 0x1f202 }, { 0x1f210, 0x1f23b }, { 0x1f240, 0x1f248 }, { 0x1f250, 0x1f251 }, + { 0x1f260, 0x1f265 }, { 0x1f300, 0x1f320 }, { 0x1f32d, 0x1f335 }, { 0x1f337, 0x1f37c }, + { 0x1f37e, 0x1f393 }, { 0x1f3a0, 0x1f3ca }, { 0x1f3cf, 0x1f3d3 }, { 0x1f3e0, 0x1f3f0 }, + { 0x1f3f4, 0x1f3f4 }, { 0x1f3f8, 0x1f43e }, { 0x1f440, 0x1f440 }, { 0x1f442, 0x1f4fc }, + { 0x1f4ff, 0x1f53d }, { 0x1f54b, 0x1f54e }, { 0x1f550, 0x1f567 }, { 0x1f57a, 0x1f57a }, + { 0x1f595, 0x1f596 }, { 0x1f5a4, 0x1f5a4 }, { 0x1f5fb, 0x1f64f }, { 0x1f680, 0x1f6c5 }, + { 0x1f6cc, 0x1f6cc }, { 0x1f6d0, 0x1f6d2 }, { 0x1f6eb, 0x1f6ec }, { 0x1f6f4, 0x1f6f8 }, + { 0x1f910, 0x1f93e }, { 0x1f940, 0x1f94c }, { 0x1f950, 0x1f96b }, { 0x1f980, 0x1f997 }, + { 0x1f9c0, 0x1f9c0 }, { 0x1f9d0, 0x1f9e6 }, { 0x20000, 0x2fffd }, { 0x30000, 0x3fffd }, +}; + +#define ARRAYSIZE(A) sizeof(A) / sizeof(*(A)) + +static int cmp_range(const void *key, const void *cm) +{ + const struct utf8range *range = (const struct utf8range *)cm; + int ch = *(int *)key; + if (ch < range->lower) { + return -1; + } + if (ch >= range->upper) { + return 1; + } + return 0; +} + +static int utf8_in_range(const struct utf8range *range, int num, int ch) +{ + const struct utf8range *r = + bsearch(&ch, range, num, sizeof(*range), cmp_range); + + if (r) { + return 1; + } + return 0; +} + +int utf8_width(int ch) +{ + /* short circuit for common case */ + if (isascii(ch)) { + return 1; + } + if (utf8_in_range(unicode_range_combining, ARRAYSIZE(unicode_range_combining), ch)) { + return 0; + } + if (utf8_in_range(unicode_range_wide, ARRAYSIZE(unicode_range_wide), ch)) { + return 2; + } + return 1; +} +#endif +#line 1 "stringbuf.h" +#ifndef STRINGBUF_H +#define STRINGBUF_H +/** + * resizable string buffer + * + * (c) 2017-2020 Steve Bennett + * + * See utf8.c for licence details. + */ +#ifdef __cplusplus +extern "C" { +#endif + +/** @file + * A stringbuf is a resizing, null terminated string buffer. + * + * The buffer is reallocated as necessary. + * + * In general it is *not* OK to call these functions with a NULL pointer + * unless stated otherwise. + * + * If USE_UTF8 is defined, supports utf8. + */ + +/** + * The stringbuf structure should not be accessed directly. + * Use the functions below. + */ +typedef struct { + int remaining; /**< Allocated, but unused space */ + int last; /**< Index of the null terminator (and thus the length of the string) */ +#ifdef USE_UTF8 + int chars; /**< Count of characters */ +#endif + char *data; /**< Allocated memory containing the string or NULL for empty */ +} stringbuf; + +/** + * Allocates and returns a new stringbuf with no elements. + */ +stringbuf *sb_alloc(void); + +/** + * Frees a stringbuf. + * It is OK to call this with NULL. + */ +void sb_free(stringbuf *sb); + +/** + * Returns an allocated copy of the stringbuf + */ +stringbuf *sb_copy(stringbuf *sb); + +/** + * Returns the byte length of the buffer. + * + * Returns 0 for both a NULL buffer and an empty buffer. + */ +static inline int sb_len(stringbuf *sb) { + return sb->last; +} + +/** + * Returns the utf8 character length of the buffer. + * + * Returns 0 for both a NULL buffer and an empty buffer. + */ +static inline int sb_chars(stringbuf *sb) { +#ifdef USE_UTF8 + return sb->chars; +#else + return sb->last; +#endif +} + +/** + * Appends a null terminated string to the stringbuf + */ +void sb_append(stringbuf *sb, const char *str); + +/** + * Like sb_append() except does not require a null terminated string. + * The length of 'str' is given as 'len' + * + * Note that in utf8 mode, characters will *not* be counted correctly + * if a partial utf8 sequence is added with sb_append_len() + */ +void sb_append_len(stringbuf *sb, const char *str, int len); + +/** + * Returns a pointer to the null terminated string in the buffer. + * + * Note this pointer only remains valid until the next modification to the + * string buffer. + * + * The returned pointer can be used to update the buffer in-place + * as long as care is taken to not overwrite the end of the buffer. + */ +static inline char *sb_str(const stringbuf *sb) +{ + return sb->data; +} + +/** + * Inserts the given string *before* (zero-based) byte 'index' in the stringbuf. + * If index is past the end of the buffer, the string is appended, + * just like sb_append() + */ +void sb_insert(stringbuf *sb, int index, const char *str); + +/** + * Delete 'len' bytes in the string at the given index. + * + * Any bytes past the end of the buffer are ignored. + * The buffer remains null terminated. + * + * If len is -1, deletes to the end of the buffer. + */ +void sb_delete(stringbuf *sb, int index, int len); + +/** + * Clear to an empty buffer. + */ +void sb_clear(stringbuf *sb); + +/** + * Return an allocated copy of buffer and frees 'sb'. + * + * If 'sb' is empty, returns an allocated copy of "". + */ +char *sb_to_string(stringbuf *sb); + +#ifdef __cplusplus +} +#endif + +#endif +#line 1 "stringbuf.c" +/** + * resizable string buffer + * + * (c) 2017-2020 Steve Bennett + * + * See utf8.c for licence details. + */ +#include +#include +#include +#include +#include + +#ifndef STRINGBUF_H +#include "stringbuf.h" +#endif +#ifdef USE_UTF8 +#ifndef UTF8_UTIL_H +#include "utf8.h" +#endif +#endif + +#define SB_INCREMENT 200 + +stringbuf *sb_alloc(void) +{ + stringbuf *sb = (stringbuf *)malloc(sizeof(*sb)); + sb->remaining = 0; + sb->last = 0; +#ifdef USE_UTF8 + sb->chars = 0; +#endif + sb->data = NULL; + + return(sb); +} + +void sb_free(stringbuf *sb) +{ + if (sb) { + free(sb->data); + } + free(sb); +} + +static void sb_realloc(stringbuf *sb, int newlen) +{ + sb->data = (char *)realloc(sb->data, newlen); + sb->remaining = newlen - sb->last; +} + +void sb_append(stringbuf *sb, const char *str) +{ + sb_append_len(sb, str, strlen(str)); +} + +void sb_append_len(stringbuf *sb, const char *str, int len) +{ + if (sb->remaining < len + 1) { + sb_realloc(sb, sb->last + len + 1 + SB_INCREMENT); + } + memcpy(sb->data + sb->last, str, len); + sb->data[sb->last + len] = 0; + + sb->last += len; + sb->remaining -= len; +#ifdef USE_UTF8 + sb->chars += utf8_strlen(str, len); +#endif +} + +char *sb_to_string(stringbuf *sb) +{ + if (sb->data == NULL) { + /* Return an allocated empty string, not null */ + return strdup(""); + } + else { + /* Just return the data and free the stringbuf structure */ + char *pt = sb->data; + free(sb); + return pt; + } +} + +/* Insert and delete operations */ + +/* Moves up all the data at position 'pos' and beyond by 'len' bytes + * to make room for new data + * + * Note: Does *not* update sb->chars + */ +static void sb_insert_space(stringbuf *sb, int pos, int len) +{ + assert(pos <= sb->last); + + /* Make sure there is enough space */ + if (sb->remaining < len) { + sb_realloc(sb, sb->last + len + SB_INCREMENT); + } + /* Now move it up */ + memmove(sb->data + pos + len, sb->data + pos, sb->last - pos); + sb->last += len; + sb->remaining -= len; + /* And null terminate */ + sb->data[sb->last] = 0; +} + +/** + * Move down all the data from pos + len, effectively + * deleting the data at position 'pos' of length 'len' + */ +static void sb_delete_space(stringbuf *sb, int pos, int len) +{ + assert(pos < sb->last); + assert(pos + len <= sb->last); + +#ifdef USE_UTF8 + sb->chars -= utf8_strlen(sb->data + pos, len); +#endif + + /* Now move it up */ + memmove(sb->data + pos, sb->data + pos + len, sb->last - pos - len); + sb->last -= len; + sb->remaining += len; + /* And null terminate */ + sb->data[sb->last] = 0; +} + +void sb_insert(stringbuf *sb, int index, const char *str) +{ + if (index >= sb->last) { + /* Inserting after the end of the list appends. */ + sb_append(sb, str); + } + else { + int len = strlen(str); + + sb_insert_space(sb, index, len); + memcpy(sb->data + index, str, len); +#ifdef USE_UTF8 + sb->chars += utf8_strlen(str, len); +#endif + } +} + +/** + * Delete the bytes at index 'index' for length 'len' + * Has no effect if the index is past the end of the list. + */ +void sb_delete(stringbuf *sb, int index, int len) +{ + if (index < sb->last) { + char *pos = sb->data + index; + if (len < 0) { + len = sb->last; + } + + sb_delete_space(sb, pos - sb->data, len); + } +} + +void sb_clear(stringbuf *sb) +{ + if (sb->data) { + /* Null terminate */ + sb->data[0] = 0; + sb->last = 0; +#ifdef USE_UTF8 + sb->chars = 0; +#endif + } +} +#line 1 "linenoise.c" +/* linenoise.c -- guerrilla line editing library against the idea that a + * line editing lib needs to be 20,000 lines of C code. + * + * You can find the latest source code at: + * + * http://github.com/msteveb/linenoise + * (forked from http://github.com/antirez/linenoise) + * + * Does a number of crazy assumptions that happen to be true in 99.9999% of + * the 2010 UNIX computers around. + * + * ------------------------------------------------------------------------ + * + * Copyright (c) 2010, Salvatore Sanfilippo + * Copyright (c) 2010, Pieter Noordhuis + * Copyright (c) 2011, Steve Bennett + * + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + * ------------------------------------------------------------------------ + * + * References: + * - http://invisible-island.net/xterm/ctlseqs/ctlseqs.html + * - http://www.3waylabs.com/nw/WWW/products/wizcon/vt220.html + * + * Bloat: + * - Completion? + * + * Unix/termios + * ------------ + * List of escape sequences used by this program, we do everything just + * a few sequences. In order to be so cheap we may have some + * flickering effect with some slow terminal, but the lesser sequences + * the more compatible. + * + * EL (Erase Line) + * Sequence: ESC [ 0 K + * Effect: clear from cursor to end of line + * + * CUF (CUrsor Forward) + * Sequence: ESC [ n C + * Effect: moves cursor forward n chars + * + * CR (Carriage Return) + * Sequence: \r + * Effect: moves cursor to column 1 + * + * The following are used to clear the screen: ESC [ H ESC [ 2 J + * This is actually composed of two sequences: + * + * cursorhome + * Sequence: ESC [ H + * Effect: moves the cursor to upper left corner + * + * ED2 (Clear entire screen) + * Sequence: ESC [ 2 J + * Effect: clear the whole screen + * + * == For highlighting control characters, we also use the following two == + * SO (enter StandOut) + * Sequence: ESC [ 7 m + * Effect: Uses some standout mode such as reverse video + * + * SE (Standout End) + * Sequence: ESC [ 0 m + * Effect: Exit standout mode + * + * == Only used if TIOCGWINSZ fails == + * DSR/CPR (Report cursor position) + * Sequence: ESC [ 6 n + * Effect: reports current cursor position as ESC [ NNN ; MMM R + * + * == Only used in multiline mode == + * CUU (Cursor Up) + * Sequence: ESC [ n A + * Effect: moves cursor up n chars. + * + * CUD (Cursor Down) + * Sequence: ESC [ n B + * Effect: moves cursor down n chars. + * + * win32/console + * ------------- + * If __MINGW32__ is defined, the win32 console API is used. + * This could probably be made to work for the msvc compiler too. + * This support based in part on work by Jon Griffiths. + */ + +#ifdef _WIN32 /* Windows platform, either MinGW or Visual Studio (MSVC) */ +#include +#include +#define USE_WINCONSOLE +#ifdef __MINGW32__ +#define HAVE_UNISTD_H +#endif +#else +#include +#include +#include +#define USE_TERMIOS +#define HAVE_UNISTD_H +#endif + +#ifdef HAVE_UNISTD_H +#include +#endif +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#if defined(_WIN32) && !defined(__MINGW32__) +/* Microsoft headers don't like old POSIX names */ +#define strdup _strdup +#define snprintf _snprintf +#endif + +#include "linenoise.h" +#ifndef STRINGBUF_H +#include "stringbuf.h" +#endif +#ifndef UTF8_UTIL_H +#include "utf8.h" +#endif + +#define LINENOISE_DEFAULT_HISTORY_MAX_LEN 100 + +/* ctrl('A') -> 0x01 */ +#define ctrl(C) ((C) - '@') +/* meta('a') -> 0xe1 */ +#define meta(C) ((C) | 0x80) + +/* Use -ve numbers here to co-exist with normal unicode chars */ +enum { + SPECIAL_NONE, + /* don't use -1 here since that indicates error */ + SPECIAL_UP = -20, + SPECIAL_DOWN = -21, + SPECIAL_LEFT = -22, + SPECIAL_RIGHT = -23, + SPECIAL_DELETE = -24, + SPECIAL_HOME = -25, + SPECIAL_END = -26, + SPECIAL_INSERT = -27, + SPECIAL_PAGE_UP = -28, + SPECIAL_PAGE_DOWN = -29, + + /* Some handy names for other special keycodes */ + CHAR_ESCAPE = 27, + CHAR_DELETE = 127, +}; + +static int history_max_len = LINENOISE_DEFAULT_HISTORY_MAX_LEN; +static int history_len = 0; +static int history_index = 0; +static char **history = NULL; + +/* Structure to contain the status of the current (being edited) line */ +struct current { + stringbuf *buf; /* Current buffer. Always null terminated */ + int pos; /* Cursor position, measured in chars */ + int cols; /* Size of the window, in chars */ + int nrows; /* How many rows are being used in multiline mode (>= 1) */ + int rpos; /* The current row containing the cursor - multiline mode only */ + int colsright; /* refreshLine() cached cols for insert_char() optimisation */ + int colsleft; /* refreshLine() cached cols for remove_char() optimisation */ + const char *prompt; + stringbuf *capture; /* capture buffer, or NULL for none. Always null terminated */ + stringbuf *output; /* used only during refreshLine() - output accumulator */ +#if defined(USE_TERMIOS) + int fd; /* Terminal fd */ + int pending; /* pending char fd_read_char() */ +#elif defined(USE_WINCONSOLE) + HANDLE outh; /* Console output handle */ + HANDLE inh; /* Console input handle */ + int rows; /* Screen rows */ + int x; /* Current column during output */ + int y; /* Current row */ +#ifdef USE_UTF8 + #define UBUF_MAX_CHARS 132 + WORD ubuf[UBUF_MAX_CHARS + 1]; /* Accumulates utf16 output - one extra for final surrogate pairs */ + int ubuflen; /* length used in ubuf */ + int ubufcols; /* how many columns are represented by the chars in ubuf? */ +#endif +#endif +}; + +static int fd_read(struct current *current); +static int getWindowSize(struct current *current); +static void cursorDown(struct current *current, int n); +static void cursorUp(struct current *current, int n); +static void eraseEol(struct current *current); +static void refreshLine(struct current *current); +static void refreshLineAlt(struct current *current, const char *prompt, const char *buf, int cursor_pos); +static void setCursorPos(struct current *current, int x); +static void setOutputHighlight(struct current *current, const int *props, int nprops); +static void set_current(struct current *current, const char *str); + +static int fd_isatty(struct current *current) +{ +#ifdef USE_TERMIOS + return isatty(current->fd); +#else + (void)current; + return 0; +#endif +} + +void linenoiseHistoryFree(void) { + if (history) { + int j; + + for (j = 0; j < history_len; j++) + free(history[j]); + free(history); + history = NULL; + history_len = 0; + } +} + +typedef enum { + EP_START, /* looking for ESC */ + EP_ESC, /* looking for [ */ + EP_DIGITS, /* parsing digits */ + EP_PROPS, /* parsing digits or semicolons */ + EP_END, /* ok */ + EP_ERROR, /* error */ +} ep_state_t; + +struct esc_parser { + ep_state_t state; + int props[5]; /* properties are stored here */ + int maxprops; /* size of the props[] array */ + int numprops; /* number of properties found */ + int termchar; /* terminator char, or 0 for any alpha */ + int current; /* current (partial) property value */ +}; + +/** + * Initialise the escape sequence parser at *parser. + * + * If termchar is 0 any alpha char terminates ok. Otherwise only the given + * char terminates successfully. + * Run the parser state machine with calls to parseEscapeSequence() for each char. + */ +static void initParseEscapeSeq(struct esc_parser *parser, int termchar) +{ + parser->state = EP_START; + parser->maxprops = sizeof(parser->props) / sizeof(*parser->props); + parser->numprops = 0; + parser->current = 0; + parser->termchar = termchar; +} + +/** + * Pass character 'ch' into the state machine to parse: + * 'ESC' '[' (';' )* + * + * The first character must be ESC. + * Returns the current state. The state machine is done when it returns either EP_END + * or EP_ERROR. + * + * On EP_END, the "property/attribute" values can be read from parser->props[] + * of length parser->numprops. + */ +static int parseEscapeSequence(struct esc_parser *parser, int ch) +{ + switch (parser->state) { + case EP_START: + parser->state = (ch == '\x1b') ? EP_ESC : EP_ERROR; + break; + case EP_ESC: + parser->state = (ch == '[') ? EP_DIGITS : EP_ERROR; + break; + case EP_PROPS: + if (ch == ';') { + parser->state = EP_DIGITS; +donedigits: + if (parser->numprops + 1 < parser->maxprops) { + parser->props[parser->numprops++] = parser->current; + parser->current = 0; + } + break; + } + /* fall through */ + case EP_DIGITS: + if (ch >= '0' && ch <= '9') { + parser->current = parser->current * 10 + (ch - '0'); + parser->state = EP_PROPS; + break; + } + /* must be terminator */ + if (parser->termchar != ch) { + if (parser->termchar != 0 || !((ch >= 'A' && ch <= 'Z') || (ch >= 'a' && ch <= 'z'))) { + parser->state = EP_ERROR; + break; + } + } + parser->state = EP_END; + goto donedigits; + case EP_END: + parser->state = EP_ERROR; + break; + case EP_ERROR: + break; + } + return parser->state; +} + +/*#define DEBUG_REFRESHLINE*/ + +#ifdef DEBUG_REFRESHLINE +#define DRL(ARGS...) fprintf(dfh, ARGS) +static FILE *dfh; + +static void DRL_CHAR(int ch) +{ + if (ch < ' ') { + DRL("^%c", ch + '@'); + } + else if (ch > 127) { + DRL("\\u%04x", ch); + } + else { + DRL("%c", ch); + } +} +static void DRL_STR(const char *str) +{ + while (*str) { + int ch; + int n = utf8_tounicode(str, &ch); + str += n; + DRL_CHAR(ch); + } +} +#else +#define DRL(...) +#define DRL_CHAR(ch) +#define DRL_STR(str) +#endif + +#if defined(USE_WINCONSOLE) +#include "linenoise-win32.c" +#endif + +#if defined(USE_TERMIOS) +static void linenoiseAtExit(void); +static struct termios orig_termios; /* in order to restore at exit */ +static int rawmode = 0; /* for atexit() function to check if restore is needed*/ +static int atexit_registered = 0; /* register atexit just 1 time */ + +static const char *unsupported_term[] = {"dumb","cons25","emacs",NULL}; + +static int isUnsupportedTerm(void) { + char *term = getenv("TERM"); + + if (term) { + int j; + for (j = 0; unsupported_term[j]; j++) { + if (strcmp(term, unsupported_term[j]) == 0) { + return 1; + } + } + } + return 0; +} + +static int enableRawMode(struct current *current) { + struct termios raw; + + current->fd = STDIN_FILENO; + current->cols = 0; + + if (!isatty(current->fd) || isUnsupportedTerm() || + tcgetattr(current->fd, &orig_termios) == -1) { +fatal: + errno = ENOTTY; + return -1; + } + + if (!atexit_registered) { + atexit(linenoiseAtExit); + atexit_registered = 1; + } + + raw = orig_termios; /* modify the original mode */ + /* input modes: no break, no CR to NL, no parity check, no strip char, + * no start/stop output control. */ + raw.c_iflag &= ~(BRKINT | ICRNL | INPCK | ISTRIP | IXON); + /* output modes - actually, no need to disable post processing */ + /*raw.c_oflag &= ~(OPOST);*/ + /* control modes - set 8 bit chars */ + raw.c_cflag |= (CS8); + /* local modes - choing off, canonical off, no extended functions, + * no signal chars (^Z,^C) */ + raw.c_lflag &= ~(ECHO | ICANON | IEXTEN | ISIG); + /* control chars - set return condition: min number of bytes and timer. + * We want read to return every single byte, without timeout. */ + raw.c_cc[VMIN] = 1; raw.c_cc[VTIME] = 0; /* 1 byte, no timer */ + + /* put terminal in raw mode. Because we aren't changing any output + * settings we don't need to use TCSADRAIN and I have seen that hang on + * OpenBSD when running under a pty + */ + if (tcsetattr(current->fd,TCSANOW,&raw) < 0) { + goto fatal; + } + rawmode = 1; + return 0; +} + +static void disableRawMode(struct current *current) { + /* Don't even check the return value as it's too late. */ + if (rawmode && tcsetattr(current->fd,TCSANOW,&orig_termios) != -1) + rawmode = 0; +} + +/* At exit we'll try to fix the terminal to the initial conditions. */ +static void linenoiseAtExit(void) { + if (rawmode) { + tcsetattr(STDIN_FILENO, TCSANOW, &orig_termios); + } + linenoiseHistoryFree(); +} + +/* gcc/glibc insists that we care about the return code of write! + * Clarification: This means that a void-cast like "(void) (EXPR)" + * does not work. + */ +#define IGNORE_RC(EXPR) if (EXPR) {} + +/** + * Output bytes directly, or accumulate output (if current->output is set) + */ +static void outputChars(struct current *current, const char *buf, int len) +{ + if (len < 0) { + len = strlen(buf); + } + if (current->output) { + sb_append_len(current->output, buf, len); + } + else { + IGNORE_RC(write(current->fd, buf, len)); + } +} + +/* Like outputChars, but using printf-style formatting + */ +static void outputFormatted(struct current *current, const char *format, ...) +{ + va_list args; + char buf[64]; + int n; + + va_start(args, format); + n = vsnprintf(buf, sizeof(buf), format, args); + /* This will never happen because we are sure to use outputFormatted() only for short sequences */ + assert(n < (int)sizeof(buf)); + va_end(args); + outputChars(current, buf, n); +} + +static void cursorToLeft(struct current *current) +{ + outputChars(current, "\r", -1); +} + +static void setOutputHighlight(struct current *current, const int *props, int nprops) +{ + outputChars(current, "\x1b[", -1); + while (nprops--) { + outputFormatted(current, "%d%c", *props, (nprops == 0) ? 'm' : ';'); + props++; + } +} + +static void eraseEol(struct current *current) +{ + outputChars(current, "\x1b[0K", -1); +} + +static void setCursorPos(struct current *current, int x) +{ + if (x == 0) { + cursorToLeft(current); + } + else { + outputFormatted(current, "\r\x1b[%dC", x); + } +} + +static void cursorUp(struct current *current, int n) +{ + if (n) { + outputFormatted(current, "\x1b[%dA", n); + } +} + +static void cursorDown(struct current *current, int n) +{ + if (n) { + outputFormatted(current, "\x1b[%dB", n); + } +} + +void linenoiseClearScreen(void) +{ + IGNORE_RC(write(STDOUT_FILENO, "\x1b[H\x1b[2J", 7)); +} + +/** + * Reads a char from 'current->fd', waiting at most 'timeout' milliseconds. + * + * A timeout of -1 means to wait forever. + * + * Returns -1 if no char is received within the time or an error occurs. + */ +static int fd_read_char(struct current *current, int timeout) +{ + struct pollfd p; + unsigned char c; + + if (current->pending) { + c = current->pending; + current->pending = 0; + return c; + } + + p.fd = current->fd; + p.events = POLLIN; + + if (poll(&p, 1, timeout) == 0) { + /* timeout */ + return -1; + } + if (read(current->fd, &c, 1) != 1) { + return -1; + } + return c; +} + +/** + * Reads a complete utf-8 character + * and returns the unicode value, or -1 on error. + */ +static int fd_read(struct current *current) +{ +#ifdef USE_UTF8 + char buf[MAX_UTF8_LEN]; + int n; + int i; + int c; + + if (current->pending) { + buf[0] = current->pending; + current->pending = 0; + } + else if (read(current->fd, &buf[0], 1) != 1) { + return -1; + } + n = utf8_charlen(buf[0]); + if (n < 1) { + return -1; + } + for (i = 1; i < n; i++) { + if (read(current->fd, &buf[i], 1) != 1) { + return -1; + } + } + /* decode and return the character */ + utf8_tounicode(buf, &c); + return c; +#else + return fd_read_char(current, -1); +#endif +} + + +/** + * Stores the current cursor column in '*cols'. + * Returns 1 if OK, or 0 if failed to determine cursor pos. + */ +static int queryCursor(struct current *current, int* cols) +{ + struct esc_parser parser; + int ch; + /* Unfortunately we don't have any persistent state, so assume + * a process will only ever interact with one terminal at a time. + */ + static int query_cursor_failed; + + if (query_cursor_failed) { + /* If it ever fails, don't try again */ + return 0; + } + + /* Should not be buffering this output, it needs to go immediately */ + assert(current->output == NULL); + + /* control sequence - report cursor location */ + outputChars(current, "\x1b[6n", -1); + + /* Parse the response: ESC [ rows ; cols R */ + initParseEscapeSeq(&parser, 'R'); + while ((ch = fd_read_char(current, 100)) > 0) { + switch (parseEscapeSequence(&parser, ch)) { + default: + continue; + case EP_END: + if (parser.numprops == 2 && parser.props[1] < 1000) { + *cols = parser.props[1]; + return 1; + } + break; + case EP_ERROR: + /* Push back the character that caused the error */ + current->pending = ch; + break; + } + /* failed */ + break; + } + query_cursor_failed = 1; + return 0; +} + +/** + * Updates current->cols with the current window size (width) + */ +static int getWindowSize(struct current *current) +{ + struct winsize ws; + + if (ioctl(STDOUT_FILENO, TIOCGWINSZ, &ws) == 0 && ws.ws_col != 0) { + current->cols = ws.ws_col; + return 0; + } + + /* Failed to query the window size. Perhaps we are on a serial terminal. + * Try to query the width by sending the cursor as far to the right + * and reading back the cursor position. + * Note that this is only done once per call to linenoise rather than + * every time the line is refreshed for efficiency reasons. + * + * In more detail, we: + * (a) request current cursor position, + * (b) move cursor far right, + * (c) request cursor position again, + * (d) at last move back to the old position. + * This gives us the width without messing with the externally + * visible cursor position. + */ + + if (current->cols == 0) { + int here; + + /* If anything fails => default 80 */ + current->cols = 80; + + /* (a) */ + if (queryCursor (current, &here)) { + /* (b) */ + setCursorPos(current, 999); + + /* (c). Note: If (a) succeeded, then (c) should as well. + * For paranoia we still check and have a fallback action + * for (d) in case of failure.. + */ + if (queryCursor (current, ¤t->cols)) { + /* (d) Reset the cursor back to the original location. */ + if (current->cols > here) { + setCursorPos(current, here); + } + } + } + } + + return 0; +} + +/** + * If CHAR_ESCAPE was received, reads subsequent + * chars to determine if this is a known special key. + * + * Returns SPECIAL_NONE if unrecognised, or -1 if EOF. + * + * If no additional char is received within a short time, + * CHAR_ESCAPE is returned. + */ +static int check_special(struct current *current) +{ + int c = fd_read_char(current, 50); + int c2; + + if (c < 0) { + return CHAR_ESCAPE; + } + else if (c >= 'a' && c <= 'z') { + /* esc-a => meta-a */ + return meta(c); + } + + c2 = fd_read_char(current, 50); + if (c2 < 0) { + return c2; + } + if (c == '[' || c == 'O') { + /* Potential arrow key */ + switch (c2) { + case 'A': + return SPECIAL_UP; + case 'B': + return SPECIAL_DOWN; + case 'C': + return SPECIAL_RIGHT; + case 'D': + return SPECIAL_LEFT; + case 'F': + return SPECIAL_END; + case 'H': + return SPECIAL_HOME; + } + } + if (c == '[' && c2 >= '1' && c2 <= '8') { + /* extended escape */ + c = fd_read_char(current, 50); + if (c == '~') { + switch (c2) { + case '2': + return SPECIAL_INSERT; + case '3': + return SPECIAL_DELETE; + case '5': + return SPECIAL_PAGE_UP; + case '6': + return SPECIAL_PAGE_DOWN; + case '7': + return SPECIAL_HOME; + case '8': + return SPECIAL_END; + } + } + while (c != -1 && c != '~') { + /* .e.g \e[12~ or '\e[11;2~ discard the complete sequence */ + c = fd_read_char(current, 50); + } + } + + return SPECIAL_NONE; +} +#endif + +static void clearOutputHighlight(struct current *current) +{ + int nohighlight = 0; + setOutputHighlight(current, &nohighlight, 1); +} + +static void outputControlChar(struct current *current, char ch) +{ + int reverse = 7; + setOutputHighlight(current, &reverse, 1); + outputChars(current, "^", 1); + outputChars(current, &ch, 1); + clearOutputHighlight(current); +} + +#ifndef utf8_getchars +static int utf8_getchars(char *buf, int c) +{ +#ifdef USE_UTF8 + return utf8_fromunicode(buf, c); +#else + *buf = c; + return 1; +#endif +} +#endif + +/** + * Returns the unicode character at the given offset, + * or -1 if none. + */ +static int get_char(struct current *current, int pos) +{ + if (pos >= 0 && pos < sb_chars(current->buf)) { + int c; + int i = utf8_index(sb_str(current->buf), pos); + (void)utf8_tounicode(sb_str(current->buf) + i, &c); + return c; + } + return -1; +} + +static int char_display_width(int ch) +{ + if (ch < ' ') { + /* control chars take two positions */ + return 2; + } + else { + return utf8_width(ch); + } +} + +#ifndef NO_COMPLETION +static linenoiseCompletionCallback *completionCallback = NULL; +static void *completionUserdata = NULL; +static int showhints = 1; +static linenoiseHintsCallback *hintsCallback = NULL; +static linenoiseFreeHintsCallback *freeHintsCallback = NULL; +static void *hintsUserdata = NULL; + +static void beep(void) { +#ifdef USE_TERMIOS + fprintf(stderr, "\x7"); + fflush(stderr); +#endif +} + +static void freeCompletions(linenoiseCompletions *lc) { + size_t i; + for (i = 0; i < lc->len; i++) + free(lc->cvec[i]); + free(lc->cvec); +} + +static int completeLine(struct current *current) { + linenoiseCompletions lc = { 0, NULL }; + int c = 0; + + completionCallback(sb_str(current->buf),&lc,completionUserdata); + if (lc.len == 0) { + beep(); + } else { + size_t stop = 0, i = 0; + + while(!stop) { + /* Show completion or original buffer */ + if (i < lc.len) { + int chars = utf8_strlen(lc.cvec[i], -1); + refreshLineAlt(current, current->prompt, lc.cvec[i], chars); + } else { + refreshLine(current); + } + + c = fd_read(current); + if (c == -1) { + break; + } + + switch(c) { + case '\t': /* tab */ + i = (i+1) % (lc.len+1); + if (i == lc.len) beep(); + break; + case CHAR_ESCAPE: /* escape */ + /* Re-show original buffer */ + if (i < lc.len) { + refreshLine(current); + } + stop = 1; + break; + default: + /* Update buffer and return */ + if (i < lc.len) { + set_current(current,lc.cvec[i]); + } + stop = 1; + break; + } + } + } + + freeCompletions(&lc); + return c; /* Return last read character */ +} + +/* Register a callback function to be called for tab-completion. + Returns the prior callback so that the caller may (if needed) + restore it when done. */ +linenoiseCompletionCallback * linenoiseSetCompletionCallback(linenoiseCompletionCallback *fn, void *userdata) { + linenoiseCompletionCallback * old = completionCallback; + completionCallback = fn; + completionUserdata = userdata; + return old; +} + +void linenoiseAddCompletion(linenoiseCompletions *lc, const char *str) { + lc->cvec = (char **)realloc(lc->cvec,sizeof(char*)*(lc->len+1)); + lc->cvec[lc->len++] = strdup(str); +} + +void linenoiseSetHintsCallback(linenoiseHintsCallback *callback, void *userdata) +{ + hintsCallback = callback; + hintsUserdata = userdata; +} + +void linenoiseSetFreeHintsCallback(linenoiseFreeHintsCallback *callback) +{ + freeHintsCallback = callback; +} + +#endif + + +static const char *reduceSingleBuf(const char *buf, int availcols, int *cursor_pos) +{ + /* We have availcols columns available. + * If necessary, strip chars off the front of buf until *cursor_pos + * fits within availcols + */ + int needcols = 0; + int pos = 0; + int new_cursor_pos = *cursor_pos; + const char *pt = buf; + + DRL("reduceSingleBuf: availcols=%d, cursor_pos=%d\n", availcols, *cursor_pos); + + while (*pt) { + int ch; + int n = utf8_tounicode(pt, &ch); + pt += n; + + needcols += char_display_width(ch); + + /* If we need too many cols, strip + * chars off the front of buf to make it fit. + * We keep 3 extra cols to the right of the cursor. + * 2 for possible wide chars, 1 for the last column that + * can't be used. + */ + while (needcols >= availcols - 3) { + n = utf8_tounicode(buf, &ch); + buf += n; + needcols -= char_display_width(ch); + DRL_CHAR(ch); + + /* and adjust the apparent cursor position */ + new_cursor_pos--; + + if (buf == pt) { + /* can't remove more than this */ + break; + } + } + + if (pos++ == *cursor_pos) { + break; + } + + } + DRL(""); + DRL_STR(buf); + DRL("\nafter reduce, needcols=%d, new_cursor_pos=%d\n", needcols, new_cursor_pos); + + /* Done, now new_cursor_pos contains the adjusted cursor position + * and buf points to he adjusted start + */ + *cursor_pos = new_cursor_pos; + return buf; +} + +static int mlmode = 0; + +void linenoiseSetMultiLine(int enableml) +{ + mlmode = enableml; +} + +/* Helper of refreshSingleLine() and refreshMultiLine() to show hints + * to the right of the prompt. + * Returns 1 if a hint was shown, or 0 if not + * If 'display' is 0, does no output. Just returns the appropriate return code. + */ +static int refreshShowHints(struct current *current, const char *buf, int availcols, int display) +{ + int rc = 0; + if (showhints && hintsCallback && availcols > 0) { + int bold = 0; + int color = -1; + char *hint = hintsCallback(buf, &color, &bold, hintsUserdata); + if (hint) { + rc = 1; + if (display) { + const char *pt; + if (bold == 1 && color == -1) color = 37; + if (bold || color > 0) { + int props[3] = { bold, color, 49 }; /* bold, color, fgnormal */ + setOutputHighlight(current, props, 3); + } + DRL("", bold, color); + pt = hint; + while (*pt) { + int ch; + int n = utf8_tounicode(pt, &ch); + int width = char_display_width(ch); + + if (width >= availcols) { + DRL(""); + break; + } + DRL_CHAR(ch); + + availcols -= width; + outputChars(current, pt, n); + pt += n; + } + if (bold || color > 0) { + clearOutputHighlight(current); + } + /* Call the function to free the hint returned. */ + if (freeHintsCallback) freeHintsCallback(hint, hintsUserdata); + } + } + } + return rc; +} + +#ifdef USE_TERMIOS +static void refreshStart(struct current *current) +{ + /* We accumulate all output here */ + assert(current->output == NULL); + current->output = sb_alloc(); +} + +static void refreshEnd(struct current *current) +{ + /* Output everything at once */ + IGNORE_RC(write(current->fd, sb_str(current->output), sb_len(current->output))); + sb_free(current->output); + current->output = NULL; +} + +static void refreshStartChars(struct current *current) +{ + (void)current; +} + +static void refreshNewline(struct current *current) +{ + DRL(""); + outputChars(current, "\n", 1); +} + +static void refreshEndChars(struct current *current) +{ + (void)current; +} +#endif + +static void refreshLineAlt(struct current *current, const char *prompt, const char *buf, int cursor_pos) +{ + int i; + const char *pt; + int displaycol; + int displayrow; + int visible; + int currentpos; + int notecursor; + int cursorcol = 0; + int cursorrow = 0; + int hint; + struct esc_parser parser; + +#ifdef DEBUG_REFRESHLINE + dfh = fopen("linenoise.debuglog", "a"); +#endif + + /* Should intercept SIGWINCH. For now, just get the size every time */ + getWindowSize(current); + + refreshStart(current); + + DRL("wincols=%d, cursor_pos=%d, nrows=%d, rpos=%d\n", current->cols, cursor_pos, current->nrows, current->rpos); + + /* Here is the plan: + * (a) move the the bottom row, going down the appropriate number of lines + * (b) move to beginning of line and erase the current line + * (c) go up one line and do the same, until we have erased up to the first row + * (d) output the prompt, counting cols and rows, taking into account escape sequences + * (e) output the buffer, counting cols and rows + * (e') when we hit the current pos, save the cursor position + * (f) move the cursor to the saved cursor position + * (g) save the current cursor row and number of rows + */ + + /* (a) - The cursor is currently at row rpos */ + cursorDown(current, current->nrows - current->rpos - 1); + DRL("", current->nrows - current->rpos - 1); + + /* (b), (c) - Erase lines upwards until we get to the first row */ + for (i = 0; i < current->nrows; i++) { + if (i) { + DRL(""); + cursorUp(current, 1); + } + DRL(""); + cursorToLeft(current); + eraseEol(current); + } + DRL("\n"); + + /* (d) First output the prompt. control sequences don't take up display space */ + pt = prompt; + displaycol = 0; /* current display column */ + displayrow = 0; /* current display row */ + visible = 1; + + refreshStartChars(current); + + while (*pt) { + int width; + int ch; + int n = utf8_tounicode(pt, &ch); + + if (visible && ch == CHAR_ESCAPE) { + /* The start of an escape sequence, so not visible */ + visible = 0; + initParseEscapeSeq(&parser, 'm'); + DRL(""); + } + + if (ch == '\n' || ch == '\r') { + /* treat both CR and NL the same and force wrap */ + refreshNewline(current); + displaycol = 0; + displayrow++; + } + else { + width = visible * utf8_width(ch); + + displaycol += width; + if (displaycol >= current->cols) { + /* need to wrap to the next line because of newline or if it doesn't fit + * XXX this is a problem in single line mode + */ + refreshNewline(current); + displaycol = width; + displayrow++; + } + + DRL_CHAR(ch); +#ifdef USE_WINCONSOLE + if (visible) { + outputChars(current, pt, n); + } +#else + outputChars(current, pt, n); +#endif + } + pt += n; + + if (!visible) { + switch (parseEscapeSequence(&parser, ch)) { + case EP_END: + visible = 1; + setOutputHighlight(current, parser.props, parser.numprops); + DRL("", parser.numprops); + break; + case EP_ERROR: + DRL(""); + visible = 1; + break; + } + } + } + + /* Now we are at the first line with all lines erased */ + DRL("\nafter prompt: displaycol=%d, displayrow=%d\n", displaycol, displayrow); + + + /* (e) output the buffer, counting cols and rows */ + if (mlmode == 0) { + /* In this mode we may need to trim chars from the start of the buffer until the + * cursor fits in the window. + */ + pt = reduceSingleBuf(buf, current->cols - displaycol, &cursor_pos); + } + else { + pt = buf; + } + + currentpos = 0; + notecursor = -1; + + while (*pt) { + int ch; + int n = utf8_tounicode(pt, &ch); + int width = char_display_width(ch); + + if (currentpos == cursor_pos) { + /* (e') wherever we output this character is where we want the cursor */ + notecursor = 1; + } + + if (displaycol + width >= current->cols) { + if (mlmode == 0) { + /* In single line mode stop once we print as much as we can on one line */ + DRL(""); + break; + } + /* need to wrap to the next line since it doesn't fit */ + refreshNewline(current); + displaycol = 0; + displayrow++; + } + + if (notecursor == 1) { + /* (e') Save this position as the current cursor position */ + cursorcol = displaycol; + cursorrow = displayrow; + notecursor = 0; + DRL(""); + } + + displaycol += width; + + if (ch < ' ') { + outputControlChar(current, ch + '@'); + } + else { + outputChars(current, pt, n); + } + DRL_CHAR(ch); + if (width != 1) { + DRL("", width); + } + + pt += n; + currentpos++; + } + + /* If we didn't see the cursor, it is at the current location */ + if (notecursor) { + DRL(""); + cursorcol = displaycol; + cursorrow = displayrow; + } + + DRL("\nafter buf: displaycol=%d, displayrow=%d, cursorcol=%d, cursorrow=%d\n", displaycol, displayrow, cursorcol, cursorrow); + + /* (f) show hints */ + hint = refreshShowHints(current, buf, current->cols - displaycol, 1); + + /* Remember how many many cols are available for insert optimisation */ + if (prompt == current->prompt && hint == 0) { + current->colsright = current->cols - displaycol; + current->colsleft = displaycol; + } + else { + /* Can't optimise */ + current->colsright = 0; + current->colsleft = 0; + } + DRL("\nafter hints: colsleft=%d, colsright=%d\n\n", current->colsleft, current->colsright); + + refreshEndChars(current); + + /* (g) move the cursor to the correct place */ + cursorUp(current, displayrow - cursorrow); + setCursorPos(current, cursorcol); + + /* (h) Update the number of rows if larger, but never reduce this */ + if (displayrow >= current->nrows) { + current->nrows = displayrow + 1; + } + /* And remember the row that the cursor is on */ + current->rpos = cursorrow; + + refreshEnd(current); + +#ifdef DEBUG_REFRESHLINE + fclose(dfh); +#endif +} + +static void refreshLine(struct current *current) +{ + refreshLineAlt(current, current->prompt, sb_str(current->buf), current->pos); +} + +static void set_current(struct current *current, const char *str) +{ + sb_clear(current->buf); + sb_append(current->buf, str); + current->pos = sb_chars(current->buf); +} + +/** + * Removes the char at 'pos'. + * + * Returns 1 if the line needs to be refreshed, 2 if not + * and 0 if nothing was removed + */ +static int remove_char(struct current *current, int pos) +{ + if (pos >= 0 && pos < sb_chars(current->buf)) { + int offset = utf8_index(sb_str(current->buf), pos); + int nbytes = utf8_index(sb_str(current->buf) + offset, 1); + int rc = 1; + + /* Now we try to optimise in the simple but very common case that: + * - outputChars() can be used directly (not win32) + * - we are removing the char at EOL + * - the buffer is not empty + * - there are columns available to the left + * - the char being deleted is not a wide or utf-8 character + * - no hints are being shown + */ + if (current->output && current->pos == pos + 1 && current->pos == sb_chars(current->buf) && pos > 0) { +#ifdef USE_UTF8 + /* Could implement utf8_prev_len() but simplest just to not optimise this case */ + char last = sb_str(current->buf)[offset]; +#else + char last = 0; +#endif + if (current->colsleft > 0 && (last & 0x80) == 0) { + /* Have cols on the left and not a UTF-8 char or continuation */ + /* Yes, can optimise */ + current->colsleft--; + current->colsright++; + rc = 2; + } + } + + sb_delete(current->buf, offset, nbytes); + + if (current->pos > pos) { + current->pos--; + } + if (rc == 2) { + if (refreshShowHints(current, sb_str(current->buf), current->colsright, 0)) { + /* A hint needs to be shown, so can't optimise after all */ + rc = 1; + } + else { + /* optimised output */ + outputChars(current, "\b \b", 3); + } + } + return rc; + return 1; + } + return 0; +} + +/** + * Insert 'ch' at position 'pos' + * + * Returns 1 if the line needs to be refreshed, 2 if not + * and 0 if nothing was inserted (no room) + */ +static int insert_char(struct current *current, int pos, int ch) +{ + if (pos >= 0 && pos <= sb_chars(current->buf)) { + char buf[MAX_UTF8_LEN + 1]; + int offset = utf8_index(sb_str(current->buf), pos); + int n = utf8_getchars(buf, ch); + int rc = 1; + + /* null terminate since sb_insert() requires it */ + buf[n] = 0; + + /* Now we try to optimise in the simple but very common case that: + * - outputChars() can be used directly (not win32) + * - we are inserting at EOL + * - there are enough columns available + * - no hints are being shown + */ + if (current->output && pos == current->pos && pos == sb_chars(current->buf)) { + int width = char_display_width(ch); + if (current->colsright > width) { + /* Yes, can optimise */ + current->colsright -= width; + current->colsleft -= width; + rc = 2; + } + } + sb_insert(current->buf, offset, buf); + if (current->pos >= pos) { + current->pos++; + } + if (rc == 2) { + if (refreshShowHints(current, sb_str(current->buf), current->colsright, 0)) { + /* A hint needs to be shown, so can't optimise after all */ + rc = 1; + } + else { + /* optimised output */ + outputChars(current, buf, n); + } + } + return rc; + } + return 0; +} + +/** + * Captures up to 'n' characters starting at 'pos' for the cut buffer. + * + * This replaces any existing characters in the cut buffer. + */ +static void capture_chars(struct current *current, int pos, int nchars) +{ + if (pos >= 0 && (pos + nchars - 1) < sb_chars(current->buf)) { + int offset = utf8_index(sb_str(current->buf), pos); + int nbytes = utf8_index(sb_str(current->buf) + offset, nchars); + + if (nbytes > 0) { + if (current->capture) { + sb_clear(current->capture); + } + else { + current->capture = sb_alloc(); + } + sb_append_len(current->capture, sb_str(current->buf) + offset, nbytes); + } + } +} + +/** + * Removes up to 'n' characters at cursor position 'pos'. + * + * Returns 0 if no chars were removed or non-zero otherwise. + */ +static int remove_chars(struct current *current, int pos, int n) +{ + int removed = 0; + + /* First save any chars which will be removed */ + capture_chars(current, pos, n); + + while (n-- && remove_char(current, pos)) { + removed++; + } + return removed; +} +/** + * Inserts the characters (string) 'chars' at the cursor position 'pos'. + * + * Returns 0 if no chars were inserted or non-zero otherwise. + */ +static int insert_chars(struct current *current, int pos, const char *chars) +{ + int inserted = 0; + + while (*chars) { + int ch; + int n = utf8_tounicode(chars, &ch); + if (insert_char(current, pos, ch) == 0) { + break; + } + inserted++; + pos++; + chars += n; + } + return inserted; +} + +static int skip_space_nonspace(struct current *current, int dir, int check_is_space) +{ + int moved = 0; + int checkoffset = (dir < 0) ? -1 : 0; + int limit = (dir < 0) ? 0 : sb_chars(current->buf); + while (current->pos != limit && (get_char(current, current->pos + checkoffset) == ' ') == check_is_space) { + current->pos += dir; + moved++; + } + return moved; +} + +static int skip_space(struct current *current, int dir) +{ + return skip_space_nonspace(current, dir, 1); +} + +static int skip_nonspace(struct current *current, int dir) +{ + return skip_space_nonspace(current, dir, 0); +} + +static void set_history_index(struct current *current, int new_index) +{ + if (history_len > 1) { + /* Update the current history entry before to + * overwrite it with the next one. */ + free(history[history_len - 1 - history_index]); + history[history_len - 1 - history_index] = strdup(sb_str(current->buf)); + /* Show the new entry */ + history_index = new_index; + if (history_index < 0) { + history_index = 0; + } else if (history_index >= history_len) { + history_index = history_len - 1; + } else { + set_current(current, history[history_len - 1 - history_index]); + refreshLine(current); + } + } +} + +/** + * Returns the keycode to process, or 0 if none. + */ +static int reverseIncrementalSearch(struct current *current) +{ + /* Display the reverse-i-search prompt and process chars */ + char rbuf[50]; + char rprompt[80]; + int rchars = 0; + int rlen = 0; + int searchpos = history_len - 1; + int c; + + rbuf[0] = 0; + while (1) { + int n = 0; + const char *p = NULL; + int skipsame = 0; + int searchdir = -1; + + snprintf(rprompt, sizeof(rprompt), "(reverse-i-search)'%s': ", rbuf); + refreshLineAlt(current, rprompt, sb_str(current->buf), current->pos); + c = fd_read(current); + if (c == ctrl('H') || c == CHAR_DELETE) { + if (rchars) { + int p_ind = utf8_index(rbuf, --rchars); + rbuf[p_ind] = 0; + rlen = strlen(rbuf); + } + continue; + } +#ifdef USE_TERMIOS + if (c == CHAR_ESCAPE) { + c = check_special(current); + } +#endif + if (c == ctrl('R')) { + /* Search for the previous (earlier) match */ + if (searchpos > 0) { + searchpos--; + } + skipsame = 1; + } + else if (c == ctrl('S')) { + /* Search for the next (later) match */ + if (searchpos < history_len) { + searchpos++; + } + searchdir = 1; + skipsame = 1; + } + else if (c == ctrl('P') || c == SPECIAL_UP) { + /* Exit Ctrl-R mode and go to the previous history line from the current search pos */ + set_history_index(current, history_len - searchpos); + c = 0; + break; + } + else if (c == ctrl('N') || c == SPECIAL_DOWN) { + /* Exit Ctrl-R mode and go to the next history line from the current search pos */ + set_history_index(current, history_len - searchpos - 2); + c = 0; + break; + } + else if (c >= ' ' && c <= '~') { + /* >= here to allow for null terminator */ + if (rlen >= (int)sizeof(rbuf) - MAX_UTF8_LEN) { + continue; + } + + n = utf8_getchars(rbuf + rlen, c); + rlen += n; + rchars++; + rbuf[rlen] = 0; + + /* Adding a new char resets the search location */ + searchpos = history_len - 1; + } + else { + /* Exit from incremental search mode */ + break; + } + + /* Now search through the history for a match */ + for (; searchpos >= 0 && searchpos < history_len; searchpos += searchdir) { + p = strstr(history[searchpos], rbuf); + if (p) { + /* Found a match */ + if (skipsame && strcmp(history[searchpos], sb_str(current->buf)) == 0) { + /* But it is identical, so skip it */ + continue; + } + /* Copy the matching line and set the cursor position */ + history_index = history_len - 1 - searchpos; + set_current(current,history[searchpos]); + current->pos = utf8_strlen(history[searchpos], p - history[searchpos]); + break; + } + } + if (!p && n) { + /* No match, so don't add it */ + rchars--; + rlen -= n; + rbuf[rlen] = 0; + } + } + if (c == ctrl('G') || c == ctrl('C')) { + /* ctrl-g terminates the search with no effect */ + set_current(current, ""); + history_index = 0; + c = 0; + } + else if (c == ctrl('J')) { + /* ctrl-j terminates the search leaving the buffer in place */ + history_index = 0; + c = 0; + } + /* Go process the char normally */ + refreshLine(current); + return c; +} + +static int linenoiseEdit(struct current *current) { + history_index = 0; + + refreshLine(current); + + while(1) { + int c = fd_read(current); + +#ifndef NO_COMPLETION + /* Only autocomplete when the callback is set. It returns < 0 when + * there was an error reading from fd. Otherwise it will return the + * character that should be handled next. */ + if (c == '\t' && current->pos == sb_chars(current->buf) && completionCallback != NULL) { + c = completeLine(current); + } +#endif + if (c == ctrl('R')) { + /* reverse incremental search will provide an alternative keycode or 0 for none */ + c = reverseIncrementalSearch(current); + /* go on to process the returned char normally */ + } + +#ifdef USE_TERMIOS + if (c == CHAR_ESCAPE) { /* escape sequence */ + c = check_special(current); + } +#endif + if (c == -1) { + /* Return on errors */ + return sb_len(current->buf); + } + + switch(c) { + case SPECIAL_NONE: + break; + case '\r': /* enter/CR */ + case '\n': /* LF */ + history_len--; + free(history[history_len]); + current->pos = sb_chars(current->buf); + if (mlmode || hintsCallback) { + showhints = 0; + refreshLine(current); + showhints = 1; + } + return sb_len(current->buf); + case ctrl('C'): /* ctrl-c */ + errno = EAGAIN; + return -1; + case ctrl('Z'): /* ctrl-z */ +#ifdef SIGTSTP + /* send ourselves SIGSUSP */ + disableRawMode(current); + raise(SIGTSTP); + /* and resume */ + enableRawMode(current); + refreshLine(current); +#endif + continue; + case CHAR_DELETE: /* backspace */ + case ctrl('H'): + if (remove_char(current, current->pos - 1) == 1) { + refreshLine(current); + } + break; + case ctrl('D'): /* ctrl-d */ + if (sb_len(current->buf) == 0) { + /* Empty line, so EOF */ + history_len--; + free(history[history_len]); + return -1; + } + /* Otherwise fall through to delete char to right of cursor */ + /* fall-thru */ + case SPECIAL_DELETE: + if (remove_char(current, current->pos) == 1) { + refreshLine(current); + } + break; + case SPECIAL_INSERT: + /* Ignore. Expansion Hook. + * Future possibility: Toggle Insert/Overwrite Modes + */ + break; + case meta('b'): /* meta-b, move word left */ + if (skip_nonspace(current, -1)) { + refreshLine(current); + } + else if (skip_space(current, -1)) { + skip_nonspace(current, -1); + refreshLine(current); + } + break; + case meta('f'): /* meta-f, move word right */ + if (skip_space(current, 1)) { + refreshLine(current); + } + else if (skip_nonspace(current, 1)) { + skip_space(current, 1); + refreshLine(current); + } + break; + case ctrl('W'): /* ctrl-w, delete word at left. save deleted chars */ + /* eat any spaces on the left */ + { + int pos = current->pos; + while (pos > 0 && get_char(current, pos - 1) == ' ') { + pos--; + } + + /* now eat any non-spaces on the left */ + while (pos > 0 && get_char(current, pos - 1) != ' ') { + pos--; + } + + if (remove_chars(current, pos, current->pos - pos)) { + refreshLine(current); + } + } + break; + case ctrl('T'): /* ctrl-t */ + if (current->pos > 0 && current->pos <= sb_chars(current->buf)) { + /* If cursor is at end, transpose the previous two chars */ + int fixer = (current->pos == sb_chars(current->buf)); + c = get_char(current, current->pos - fixer); + remove_char(current, current->pos - fixer); + insert_char(current, current->pos - 1, c); + refreshLine(current); + } + break; + case ctrl('V'): /* ctrl-v */ + /* Insert the ^V first */ + if (insert_char(current, current->pos, c)) { + refreshLine(current); + /* Now wait for the next char. Can insert anything except \0 */ + c = fd_read(current); + + /* Remove the ^V first */ + remove_char(current, current->pos - 1); + if (c > 0) { + /* Insert the actual char, can't be error or null */ + insert_char(current, current->pos, c); + } + refreshLine(current); + } + break; + case ctrl('B'): + case SPECIAL_LEFT: + if (current->pos > 0) { + current->pos--; + refreshLine(current); + } + break; + case ctrl('F'): + case SPECIAL_RIGHT: + if (current->pos < sb_chars(current->buf)) { + current->pos++; + refreshLine(current); + } + break; + case SPECIAL_PAGE_UP: /* move to start of history */ + set_history_index(current, history_len - 1); + break; + case SPECIAL_PAGE_DOWN: /* move to 0 == end of history, i.e. current */ + set_history_index(current, 0); + break; + case ctrl('P'): + case SPECIAL_UP: + set_history_index(current, history_index + 1); + break; + case ctrl('N'): + case SPECIAL_DOWN: + set_history_index(current, history_index - 1); + break; + case ctrl('A'): /* Ctrl+a, go to the start of the line */ + case SPECIAL_HOME: + current->pos = 0; + refreshLine(current); + break; + case ctrl('E'): /* ctrl+e, go to the end of the line */ + case SPECIAL_END: + current->pos = sb_chars(current->buf); + refreshLine(current); + break; + case ctrl('U'): /* Ctrl+u, delete to beginning of line, save deleted chars. */ + if (remove_chars(current, 0, current->pos)) { + refreshLine(current); + } + break; + case ctrl('K'): /* Ctrl+k, delete from current to end of line, save deleted chars. */ + if (remove_chars(current, current->pos, sb_chars(current->buf) - current->pos)) { + refreshLine(current); + } + break; + case ctrl('Y'): /* Ctrl+y, insert saved chars at current position */ + if (current->capture && insert_chars(current, current->pos, sb_str(current->capture))) { + refreshLine(current); + } + break; + case ctrl('L'): /* Ctrl+L, clear screen */ + linenoiseClearScreen(); + /* Force recalc of window size for serial terminals */ + current->cols = 0; + current->rpos = 0; + refreshLine(current); + break; + default: + if (c >= meta('a') && c <= meta('z')) { + /* Don't insert meta chars that are not bound */ + break; + } + /* Only tab is allowed without ^V */ + if (c == '\t' || c >= ' ') { + if (insert_char(current, current->pos, c) == 1) { + refreshLine(current); + } + } + break; + } + } + return sb_len(current->buf); +} + +int linenoiseColumns(void) +{ + struct current current; + current.output = NULL; + enableRawMode (¤t); + getWindowSize (¤t); + disableRawMode (¤t); + return current.cols; +} + +/** + * Reads a line from the file handle (without the trailing NL or CRNL) + * and returns it in a stringbuf. + * Returns NULL if no characters are read before EOF or error. + * + * Note that the character count will *not* be correct for lines containing + * utf8 sequences. Do not rely on the character count. + */ +static stringbuf *sb_getline(FILE *fh) +{ + stringbuf *sb = sb_alloc(); + int c; + int n = 0; + + while ((c = getc(fh)) != EOF) { + char ch; + n++; + if (c == '\r') { + /* CRLF -> LF */ + continue; + } + if (c == '\n' || c == '\r') { + break; + } + ch = c; + /* ignore the effect of character count for partial utf8 sequences */ + sb_append_len(sb, &ch, 1); + } + if (n == 0 || sb->data == NULL) { + sb_free(sb); + return NULL; + } + return sb; +} + +char *linenoiseWithInitial(const char *prompt, const char *initial) +{ + int count; + struct current current; + stringbuf *sb; + + memset(¤t, 0, sizeof(current)); + + if (enableRawMode(¤t) == -1) { + printf("%s", prompt); + fflush(stdout); + sb = sb_getline(stdin); + if (sb && !fd_isatty(¤t)) { + printf("%s\n", sb_str(sb)); + fflush(stdout); + } + } + else { + current.buf = sb_alloc(); + current.pos = 0; + current.nrows = 1; + current.prompt = prompt; + + /* The latest history entry is always our current buffer */ + linenoiseHistoryAdd(initial); + set_current(¤t, initial); + + count = linenoiseEdit(¤t); + + disableRawMode(¤t); + printf("\n"); + + sb_free(current.capture); + if (count == -1) { + sb_free(current.buf); + return NULL; + } + sb = current.buf; + } + return sb ? sb_to_string(sb) : NULL; +} + +char *linenoise(const char *prompt) +{ + return linenoiseWithInitial(prompt, ""); +} + +/* Using a circular buffer is smarter, but a bit more complex to handle. */ +static int linenoiseHistoryAddAllocated(char *line) { + + if (history_max_len == 0) { +notinserted: + free(line); + return 0; + } + if (history == NULL) { + history = (char **)calloc(sizeof(char*), history_max_len); + } + + /* do not insert duplicate lines into history */ + if (history_len > 0 && strcmp(line, history[history_len - 1]) == 0) { + goto notinserted; + } + + if (history_len == history_max_len) { + free(history[0]); + memmove(history,history+1,sizeof(char*)*(history_max_len-1)); + history_len--; + } + history[history_len] = line; + history_len++; + return 1; +} + +int linenoiseHistoryAdd(const char *line) { + return linenoiseHistoryAddAllocated(strdup(line)); +} + +int linenoiseHistoryGetMaxLen(void) { + return history_max_len; +} + +int linenoiseHistorySetMaxLen(int len) { + char **newHistory; + + if (len < 1) return 0; + if (history) { + int tocopy = history_len; + + newHistory = (char **)calloc(sizeof(char*), len); + + /* If we can't copy everything, free the elements we'll not use. */ + if (len < tocopy) { + int j; + + for (j = 0; j < tocopy-len; j++) free(history[j]); + tocopy = len; + } + memcpy(newHistory,history+(history_len-tocopy), sizeof(char*)*tocopy); + free(history); + history = newHistory; + } + history_max_len = len; + if (history_len > history_max_len) + history_len = history_max_len; + return 1; +} + +/* Save the history in the specified file. On success 0 is returned + * otherwise -1 is returned. */ +int linenoiseHistorySave(const char *filename) { + FILE *fp = fopen(filename,"w"); + int j; + + if (fp == NULL) return -1; + for (j = 0; j < history_len; j++) { + const char *str = history[j]; + /* Need to encode backslash, nl and cr */ + while (*str) { + if (*str == '\\') { + fputs("\\\\", fp); + } + else if (*str == '\n') { + fputs("\\n", fp); + } + else if (*str == '\r') { + fputs("\\r", fp); + } + else { + fputc(*str, fp); + } + str++; + } + fputc('\n', fp); + } + + fclose(fp); + return 0; +} + +/* Load the history from the specified file. + * + * If the file does not exist or can't be opened, no operation is performed + * and -1 is returned. + * Otherwise 0 is returned. + */ +int linenoiseHistoryLoad(const char *filename) { + FILE *fp = fopen(filename,"r"); + stringbuf *sb; + + if (fp == NULL) return -1; + + while ((sb = sb_getline(fp)) != NULL) { + /* Take the stringbuf and decode backslash escaped values */ + char *buf = sb_to_string(sb); + char *dest = buf; + const char *src; + + for (src = buf; *src; src++) { + char ch = *src; + + if (ch == '\\') { + src++; + if (*src == 'n') { + ch = '\n'; + } + else if (*src == 'r') { + ch = '\r'; + } else { + ch = *src; + } + } + *dest++ = ch; + } + *dest = 0; + + linenoiseHistoryAddAllocated(buf); + } + fclose(fp); + return 0; +} + +/* Provide access to the history buffer. + * + * If 'len' is not NULL, the length is stored in *len. + */ +char **linenoiseHistory(int *len) { + if (len) { + *len = history_len; + } + return history; +} diff --git a/extsrc/linenoise.h b/extsrc/linenoise.h new file mode 100644 index 0000000..8842de3 --- /dev/null +++ b/extsrc/linenoise.h @@ -0,0 +1,149 @@ +/* linenoise.h -- guerrilla line editing library against the idea that a + * line editing lib needs to be 20,000 lines of C code. + * + * See linenoise.c for more information. + * + * ------------------------------------------------------------------------ + * + * Copyright (c) 2010, Salvatore Sanfilippo + * Copyright (c) 2010, Pieter Noordhuis + * + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef __LINENOISE_H +#define __LINENOISE_H + +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef NO_COMPLETION +typedef struct linenoiseCompletions { + size_t len; + char **cvec; +} linenoiseCompletions; + +/* + * The callback type for tab completion handlers. + */ +typedef void(linenoiseCompletionCallback)(const char *prefix, linenoiseCompletions *comp, void *userdata); + +/* + * Sets the current tab completion handler and returns the previous one, or NULL + * if no prior one has been set. + */ +linenoiseCompletionCallback * linenoiseSetCompletionCallback(linenoiseCompletionCallback *comp, void *userdata); + +/* + * Adds a copy of the given string to the given completion list. The copy is owned + * by the linenoiseCompletions object. + */ +void linenoiseAddCompletion(linenoiseCompletions *comp, const char *str); + +typedef char*(linenoiseHintsCallback)(const char *, int *color, int *bold, void *userdata); +typedef void(linenoiseFreeHintsCallback)(void *hint, void *userdata); +void linenoiseSetHintsCallback(linenoiseHintsCallback *callback, void *userdata); +void linenoiseSetFreeHintsCallback(linenoiseFreeHintsCallback *callback); + +#endif + +/* + * Prompts for input using the given string as the input + * prompt. Returns when the user has tapped ENTER or (on an empty + * line) EOF (Ctrl-D on Unix, Ctrl-Z on Windows). Returns either + * a copy of the entered string (for ENTER) or NULL (on EOF). The + * caller owns the returned string and must eventually free() it. + */ +char *linenoise(const char *prompt); + +/** + * Like linenoise() but starts with an initial buffer. + */ +char *linenoiseWithInitial(const char *prompt, const char *initial); + +/** + * Clear the screen. + */ +void linenoiseClearScreen(void); + +/* + * Adds a copy of the given line of the command history. + */ +int linenoiseHistoryAdd(const char *line); + +/* + * Sets the maximum length of the command history, in lines. + * If the history is currently longer, it will be trimmed, + * retaining only the most recent entries. If len is 0 or less + * then this function does nothing. + */ +int linenoiseHistorySetMaxLen(int len); + +/* + * Returns the current maximum length of the history, in lines. + */ +int linenoiseHistoryGetMaxLen(void); + +/* + * Saves the current contents of the history to the given file. + * Returns 0 on success. + */ +int linenoiseHistorySave(const char *filename); + +/* + * Replaces the current history with the contents + * of the given file. Returns 0 on success. + */ +int linenoiseHistoryLoad(const char *filename); + +/* + * Frees all history entries, clearing the history. + */ +void linenoiseHistoryFree(void); + +/* + * Returns a pointer to the list of history entries, writing its + * length to *len if len is not NULL. The memory is owned by linenoise + * and must not be freed. + */ +char **linenoiseHistory(int *len); + +/* + * Returns the number of display columns in the current terminal. + */ +int linenoiseColumns(void); + +/** + * Enable or disable multiline mode (disabled by default) + */ +void linenoiseSetMultiLine(int enableml); + +#ifdef __cplusplus +} +#endif + +#endif /* __LINENOISE_H */ diff --git a/extsrc/pikchr-worker.js b/extsrc/pikchr-worker.js new file mode 100644 index 0000000..2df5bb5 --- /dev/null +++ b/extsrc/pikchr-worker.js @@ -0,0 +1,222 @@ +/* + 2022-05-20 + + The author disclaims copyright to this source code. In place of a + legal notice, here is a blessing: + + * May you do good and not evil. + * May you find forgiveness for yourself and forgive others. + * May you share freely, never taking more than you give. + + *********************************************************************** + + This is a JS Worker file for use with the pikchr wasm build. It + loads the pikchr wasm module and offers access to it via the Worker + message-passing interface. + + Because we can have only a single message handler, as opposed to an + arbitrary number of discrete event listeners like with DOM elements, + we have to define a lower-level message API. Messages abstractly + look like: + + { type: string, data: type-specific value } + + Where 'type' is used for dispatching and 'data' is a + 'type'-dependent value. + + The 'type' values expected by each side of the main/worker + connection vary. The types are described below but subject to + change at any time as this experiment evolves. + + Main-to-Worker message types: + + - pikchr: data=pikchr-format text to render or an object: + + { + pikchr: source code for the pikchr, + darkMode: boolean true to adjust colors for a dark color scheme, + cssClass: CSS class name to add to the SVG + } + + Workers-to-Main message types: + + - stdout, stderr: indicate stdout/stderr output from the wasm + layer. The data property is the string of the output, noting + that the emscripten binding emits these one line at a time. Thus, + if a C-side puts() emits multiple lines in a single call, the JS + side will see that as multiple calls. Example: + + {type:'stdout', data: 'Hi, world.'} + + - module: Status text. This is intended to alert the main thread + about module loading status so that, e.g., the main thread can + update a progress widget and DTRT when the module is finished + loading and available for work. Status messages come in the form + + {type:'module', data:{ + type:'status', + data: {text:string|null, step:1-based-integer} + } + + with an incrementing step value for each subsequent message. When + the module loading is complete, a message with a text value of + null is posted. + + - pikchr: + + {type: 'pikchr', + data:{ + pikchr: input text, + result: rendered result (SVG on success, HTML on error), + isError: bool, true if .pikchr holds an error report, + flags: integer: flags used to configure the pikchr rendering, + width: if !isError, width (integer pixels) of the SVG, + height: if !isError, height (integer pixels) of the SVG + } + } + +*/ + +"use strict"; +(function(){ + /** + Posts a message in the form {type,data} unless passed more than + 2 args, in which case it posts {type, data:[arg1...argN]}. + */ + const wMsg = function(type,data){ + postMessage({ + type, + data: arguments.length<3 + ? data + : Array.prototype.slice.call(arguments,1) + }); + }; + + const stderr = function(){wMsg('stderr', Array.prototype.slice.call(arguments));}; + + self.onerror = function(/*message, source, lineno, colno, error*/) { + const err = arguments[4]; + if(err && 'ExitStatus'==err.name){ + /* This "cannot happen" for this wasm binding, but just in + case... */ + pikchrModule.isDead = true; + stderr("FATAL ERROR:", err.message); + stderr("Restarting the app requires reloading the page."); + wMsg('error', err); + } + pikchrModule.setStatus('Exception thrown, see JavaScript console: '+err); + }; + + self.onmessage = function f(ev){ + ev = ev.data; + switch(ev.type){ + /** + Runs the given text through pikchr and emits a 'pikchr' + message result (output format documented above). + + Fires a working/start event before it starts and + working/end event when it finishes. + */ + case 'pikchr': + if(pikchrModule.isDead){ + stderr("wasm module has exit()ed. Cannot pikchr."); + return; + } + if(!f._){ + f._ = pikchrModule.cwrap('pikchr', 'string', [ + 'string'/*script*/, 'string'/*CSS class*/, 'number'/*flags*/, + 'number'/*output: SVG width*/, 'number'/*output: SVG height*/ + ]); + } + wMsg('working','start'); + const stack = pikchrModule.stackSave(); + try { + const pnWidth = pikchrModule.stackAlloc(4), + pnHeight = pikchrModule.stackAlloc(4); + let script = '', flags = 0, cssClass = null; + if('string'===typeof ev.data){ + script = ev.data; + }else if(ev.data && 'object'===typeof ev.data){ + script = ev.data.pikchr; + flags = ev.data.darkMode ? 0x02 : 0; + if(ev.data.cssClass) cssClass = ev.data.cssClass; + } + pikchrModule.setValue(pnWidth, 0, "i32"); + pikchrModule.setValue(pnHeight, 0, "i32"); + const msg = { + pikchr: script, + result: (f._(script, cssClass, flags, pnWidth, pnHeight) || "").trim(), + flags: flags + }; + msg.isError = !!(msg.result && msg.result.startsWith('