| | @@ -30,11 +30,11 @@ |
| 30 | 30 | /* Determine the integer type use to parse non-floating point numbers */ |
| 31 | 31 | #ifdef _WIN32 |
| 32 | 32 | typedef __int64 JSON_int_t; |
| 33 | 33 | #define JSON_PARSER_INTEGER_SSCANF_TOKEN "%I64d" |
| 34 | 34 | #define JSON_PARSER_INTEGER_SPRINTF_TOKEN "%I64d" |
| 35 | | -#elif (__STDC_VERSION__ >= 199901L) || (HAVE_LONG_LONG == 1) |
| 35 | +#elif __STDC_VERSION__ >= 199901L || HAVE_LONG_LONG == 1 |
| 36 | 36 | typedef long long JSON_int_t; |
| 37 | 37 | #define JSON_PARSER_INTEGER_SSCANF_TOKEN "%lld" |
| 38 | 38 | #define JSON_PARSER_INTEGER_SPRINTF_TOKEN "%lld" |
| 39 | 39 | #else |
| 40 | 40 | typedef long JSON_int_t; |
| | @@ -103,11 +103,11 @@ |
| 103 | 103 | JSON_T_NULL, JSON_T_TRUE, and JSON_T_FALSE. String values are always returned |
| 104 | 104 | as zero-terminated C strings. |
| 105 | 105 | |
| 106 | 106 | \return Non-zero if parsing should continue, else zero. |
| 107 | 107 | */ |
| 108 | | -typedef int (*JSON_parser_callback)(void* ctx, int type, const struct JSON_value_struct* value); |
| 108 | +typedef int (*JSON_parser_callback)(void* ctx, int type, const JSON_value* value); |
| 109 | 109 | |
| 110 | 110 | |
| 111 | 111 | /** |
| 112 | 112 | A typedef for allocator functions semantically compatible with malloc(). |
| 113 | 113 | */ |
| | @@ -233,11 +233,11 @@ |
| 233 | 233 | |
| 234 | 234 | #endif /* JSON_PARSER_H */ |
| 235 | 235 | /* end file parser/JSON_parser.h */ |
| 236 | 236 | /* begin file parser/JSON_parser.c */ |
| 237 | 237 | /* |
| 238 | | -Copyright (c) 2005 JSON.org |
| 238 | +Copyright (c) 2007-2013 Jean Gressmann ([email protected]) |
| 239 | 239 | |
| 240 | 240 | Permission is hereby granted, free of charge, to any person obtaining a copy |
| 241 | 241 | of this software and associated documentation files (the "Software"), to deal |
| 242 | 242 | in the Software without restriction, including without limitation the rights |
| 243 | 243 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell |
| | @@ -245,12 +245,10 @@ |
| 245 | 245 | furnished to do so, subject to the following conditions: |
| 246 | 246 | |
| 247 | 247 | The above copyright notice and this permission notice shall be included in all |
| 248 | 248 | copies or substantial portions of the Software. |
| 249 | 249 | |
| 250 | | -The Software shall be used for Good, not Evil. |
| 251 | | - |
| 252 | 250 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
| 253 | 251 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
| 254 | 252 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
| 255 | 253 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
| 256 | 254 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, |
| | @@ -257,49 +255,52 @@ |
| 257 | 255 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE |
| 258 | 256 | SOFTWARE. |
| 259 | 257 | */ |
| 260 | 258 | |
| 261 | 259 | /* |
| 262 | | - Callbacks, comments, Unicode handling by Jean Gressmann ([email protected]), 2007-2010. |
| 263 | | - |
| 264 | | - |
| 265 | 260 | Changelog: |
| 261 | + 2013-09-08 |
| 262 | + Updated license to to be compatible with Debian license requirements. |
| 263 | + |
| 264 | + 2012-06-06 |
| 265 | + Fix for invalid UTF16 characters and some comment fixex ([email protected]). |
| 266 | + |
| 266 | 267 | 2010-11-25 |
| 267 | 268 | Support for custom memory allocation ([email protected]). |
| 268 | | - |
| 269 | + |
| 269 | 270 | 2010-05-07 |
| 270 | | - Added error handling for memory allocation failure ([email protected]). |
| 271 | + Added error handling for memory allocation failure ([email protected]). |
| 271 | 272 | Added diagnosis errors for invalid JSON. |
| 272 | | - |
| 273 | + |
| 273 | 274 | 2010-03-25 |
| 274 | 275 | Fixed buffer overrun in grow_parse_buffer & cleaned up code. |
| 275 | | - |
| 276 | + |
| 276 | 277 | 2009-10-19 |
| 277 | | - Replaced long double in JSON_value_struct with double after reports |
| 278 | + Replaced long double in JSON_value_struct with double after reports |
| 278 | 279 | of strtold being broken on some platforms ([email protected]). |
| 279 | | - |
| 280 | | - 2009-05-17 |
| 280 | + |
| 281 | + 2009-05-17 |
| 281 | 282 | Incorporated [email protected] fix for UTF16 decoding. |
| 282 | | - |
| 283 | | - 2009-05-14 |
| 283 | + |
| 284 | + 2009-05-14 |
| 284 | 285 | Fixed float parsing bug related to a locale being set that didn't |
| 285 | 286 | use '.' as decimal point character ([email protected]). |
| 286 | | - |
| 287 | | - 2008-10-14 |
| 287 | + |
| 288 | + 2008-10-14 |
| 288 | 289 | Renamed states.IN to states.IT to avoid name clash which IN macro |
| 289 | 290 | defined in windef.h ([email protected]) |
| 290 | | - |
| 291 | | - 2008-07-19 |
| 291 | + |
| 292 | + 2008-07-19 |
| 292 | 293 | Removed some duplicate code & debugging variable ([email protected]) |
| 293 | | - |
| 294 | | - 2008-05-28 |
| 295 | | - Made JSON_value structure ansi C compliant. This bug was report by |
| 294 | + |
| 295 | + 2008-05-28 |
| 296 | + Made JSON_value structure ansi C compliant. This bug was report by |
| 296 | 297 | [email protected] |
| 297 | | - |
| 298 | | - 2008-05-20 |
| 299 | | - Fixed bug reported by [email protected] where the switching |
| 300 | | - from static to dynamic parse buffer did not copy the static parse |
| 298 | + |
| 299 | + 2008-05-20 |
| 300 | + Fixed bug reported by [email protected] where the switching |
| 301 | + from static to dynamic parse buffer did not copy the static parse |
| 301 | 302 | buffer's content. |
| 302 | 303 | */ |
| 303 | 304 | |
| 304 | 305 | |
| 305 | 306 | |
| | @@ -362,11 +363,11 @@ |
| 362 | 363 | char static_parse_buffer[JSON_PARSER_PARSE_BUFFER_SIZE]; |
| 363 | 364 | JSON_malloc_t malloc; |
| 364 | 365 | JSON_free_t free; |
| 365 | 366 | }; |
| 366 | 367 | |
| 367 | | -#define COUNTOF(x) (sizeof(x)/sizeof(x[0])) |
| 368 | +#define COUNTOF(x) (sizeof(x)/sizeof(x[0])) |
| 368 | 369 | |
| 369 | 370 | /* |
| 370 | 371 | Characters are mapped into these character classes. This allows for |
| 371 | 372 | a significant reduction in the size of the state transition table. |
| 372 | 373 | */ |
| | @@ -403,11 +404,11 @@ |
| 403 | 404 | C_LOW_T, /* t */ |
| 404 | 405 | C_LOW_U, /* u */ |
| 405 | 406 | C_ABCDF, /* ABCDF */ |
| 406 | 407 | C_E, /* E */ |
| 407 | 408 | C_ETC, /* everything else */ |
| 408 | | - C_STAR, /* * */ |
| 409 | + C_STAR, /* * */ |
| 409 | 410 | NR_CLASSES |
| 410 | 411 | }; |
| 411 | 412 | |
| 412 | 413 | static const signed char ascii_class[128] = { |
| 413 | 414 | /* |
| | @@ -419,11 +420,11 @@ |
| 419 | 420 | __, C_WHITE, C_WHITE, __, __, C_WHITE, __, __, |
| 420 | 421 | __, __, __, __, __, __, __, __, |
| 421 | 422 | __, __, __, __, __, __, __, __, |
| 422 | 423 | |
| 423 | 424 | C_SPACE, C_ETC, C_QUOTE, C_ETC, C_ETC, C_ETC, C_ETC, C_ETC, |
| 424 | | - C_ETC, C_ETC, C_STAR, C_PLUS, C_COMMA, C_MINUS, C_POINT, C_SLASH, |
| 425 | + C_ETC, C_ETC, C_STAR, C_PLUS, C_COMMA, C_MINUS, C_POINT, C_SLASH, |
| 425 | 426 | C_ZERO, C_DIGIT, C_DIGIT, C_DIGIT, C_DIGIT, C_DIGIT, C_DIGIT, C_DIGIT, |
| 426 | 427 | C_DIGIT, C_DIGIT, C_COLON, C_ETC, C_ETC, C_ETC, C_ETC, C_ETC, |
| 427 | 428 | |
| 428 | 429 | C_ETC, C_ABCDF, C_ABCDF, C_ABCDF, C_ABCDF, C_E, C_ABCDF, C_ETC, |
| 429 | 430 | C_ETC, C_ETC, C_ETC, C_ETC, C_ETC, C_ETC, C_ETC, C_ETC, |
| | @@ -536,11 +537,11 @@ |
| 536 | 537 | /*false F4*/ {__,__,__,__,__,__,__,__,__,__,CB,__,__,__,__,__,__,__,__,__,OK,__,__,__,__,__,__,__,__,__,__,__}, |
| 537 | 538 | /*nu N1*/ {__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,N2,__,__,__,__}, |
| 538 | 539 | /*nul N2*/ {__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,N3,__,__,__,__,__,__,__,__,__}, |
| 539 | 540 | /*null N3*/ {__,__,__,__,__,__,__,__,__,__,CB,__,__,__,__,__,__,__,__,__,__,__,OK,__,__,__,__,__,__,__,__,__}, |
| 540 | 541 | /*/ C1*/ {__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,C2}, |
| 541 | | -/*/* 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}, |
| 542 | +/*/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}, |
| 542 | 543 | /** 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}, |
| 543 | 544 | /*_. FX*/ {OK,OK,__,-8,__,-7,__,-3,__,__,__,__,__,__,FR,FR,__,__,__,__,E1,__,__,__,__,__,__,__,__,E1,__,__}, |
| 544 | 545 | /*\ D1*/ {__,__,__,__,__,__,__,__,__,D2,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__}, |
| 545 | 546 | /*\ D2*/ {__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,__,U1,__,__,__,__}, |
| 546 | 547 | }; |
| | @@ -548,27 +549,27 @@ |
| 548 | 549 | |
| 549 | 550 | /* |
| 550 | 551 | These modes can be pushed on the stack. |
| 551 | 552 | */ |
| 552 | 553 | enum modes { |
| 553 | | - MODE_ARRAY = 1, |
| 554 | | - MODE_DONE = 2, |
| 555 | | - MODE_KEY = 3, |
| 554 | + MODE_ARRAY = 1, |
| 555 | + MODE_DONE = 2, |
| 556 | + MODE_KEY = 3, |
| 556 | 557 | MODE_OBJECT = 4 |
| 557 | 558 | }; |
| 558 | 559 | |
| 559 | 560 | static void set_error(JSON_parser jc) |
| 560 | 561 | { |
| 561 | 562 | switch (jc->state) { |
| 562 | 563 | case GO: |
| 563 | 564 | switch (jc->current_char) { |
| 564 | | - case '{': case '}': case '[': case ']': |
| 565 | + case '{': case '}': case '[': case ']': |
| 565 | 566 | jc->error = JSON_E_UNBALANCED_COLLECTION; |
| 566 | 567 | break; |
| 567 | 568 | default: |
| 568 | 569 | jc->error = JSON_E_INVALID_CHAR; |
| 569 | | - break; |
| 570 | + break; |
| 570 | 571 | } |
| 571 | 572 | break; |
| 572 | 573 | case OB: |
| 573 | 574 | jc->error = JSON_E_EXPECTED_KEY; |
| 574 | 575 | break; |
| | @@ -604,11 +605,11 @@ |
| 604 | 605 | { |
| 605 | 606 | /* |
| 606 | 607 | Push a mode onto the stack. Return false if there is overflow. |
| 607 | 608 | */ |
| 608 | 609 | assert(jc->top <= jc->stack_capacity); |
| 609 | | - |
| 610 | + |
| 610 | 611 | if (jc->depth < 0) { |
| 611 | 612 | if (jc->top == jc->stack_capacity) { |
| 612 | 613 | const size_t bytes_to_copy = jc->stack_capacity * sizeof(jc->stack[0]); |
| 613 | 614 | const size_t new_capacity = jc->stack_capacity * 2; |
| 614 | 615 | const size_t bytes_to_allocate = new_capacity * sizeof(jc->stack[0]); |
| | @@ -653,17 +654,17 @@ |
| 653 | 654 | #define parse_buffer_clear(jc) \ |
| 654 | 655 | do {\ |
| 655 | 656 | jc->parse_buffer_count = 0;\ |
| 656 | 657 | jc->parse_buffer[0] = 0;\ |
| 657 | 658 | } while (0) |
| 658 | | - |
| 659 | + |
| 659 | 660 | #define parse_buffer_pop_back_char(jc)\ |
| 660 | 661 | do {\ |
| 661 | 662 | assert(jc->parse_buffer_count >= 1);\ |
| 662 | 663 | --jc->parse_buffer_count;\ |
| 663 | 664 | jc->parse_buffer[jc->parse_buffer_count] = 0;\ |
| 664 | | - } while (0) |
| 665 | + } while (0) |
| 665 | 666 | |
| 666 | 667 | |
| 667 | 668 | |
| 668 | 669 | void delete_JSON_parser(JSON_parser jc) |
| 669 | 670 | { |
| | @@ -673,25 +674,25 @@ |
| 673 | 674 | } |
| 674 | 675 | if (jc->parse_buffer != &jc->static_parse_buffer[0]) { |
| 675 | 676 | jc->free((void*)jc->parse_buffer); |
| 676 | 677 | } |
| 677 | 678 | jc->free((void*)jc); |
| 678 | | - } |
| 679 | + } |
| 679 | 680 | } |
| 680 | 681 | |
| 681 | 682 | int JSON_parser_reset(JSON_parser jc) |
| 682 | 683 | { |
| 683 | 684 | if (NULL == jc) { |
| 684 | 685 | return false; |
| 685 | 686 | } |
| 686 | | - |
| 687 | + |
| 687 | 688 | jc->state = GO; |
| 688 | 689 | jc->top = -1; |
| 689 | 690 | |
| 690 | 691 | /* parser has been used previously? */ |
| 691 | 692 | if (NULL == jc->parse_buffer) { |
| 692 | | - |
| 693 | + |
| 693 | 694 | /* Do we want non-bound stack? */ |
| 694 | 695 | if (jc->depth > 0) { |
| 695 | 696 | jc->stack_capacity = jc->depth; |
| 696 | 697 | if (jc->depth <= (int)COUNTOF(jc->static_stack)) { |
| 697 | 698 | jc->stack = &jc->static_stack[0]; |
| | @@ -705,20 +706,20 @@ |
| 705 | 706 | } else { |
| 706 | 707 | jc->stack_capacity = (int)COUNTOF(jc->static_stack); |
| 707 | 708 | jc->depth = -1; |
| 708 | 709 | jc->stack = &jc->static_stack[0]; |
| 709 | 710 | } |
| 710 | | - |
| 711 | + |
| 711 | 712 | /* set up the parse buffer */ |
| 712 | 713 | jc->parse_buffer = &jc->static_parse_buffer[0]; |
| 713 | 714 | jc->parse_buffer_capacity = COUNTOF(jc->static_parse_buffer); |
| 714 | 715 | } |
| 715 | | - |
| 716 | + |
| 716 | 717 | /* set parser to start */ |
| 717 | 718 | push(jc, MODE_DONE); |
| 718 | 719 | parse_buffer_clear(jc); |
| 719 | | - |
| 720 | + |
| 720 | 721 | return true; |
| 721 | 722 | } |
| 722 | 723 | |
| 723 | 724 | JSON_parser |
| 724 | 725 | new_JSON_parser(JSON_config const * config) |
| | @@ -735,29 +736,29 @@ |
| 735 | 736 | |
| 736 | 737 | int use_std_malloc = false; |
| 737 | 738 | JSON_config default_config; |
| 738 | 739 | JSON_parser jc; |
| 739 | 740 | JSON_malloc_t alloc; |
| 740 | | - |
| 741 | + |
| 741 | 742 | /* set to default configuration if none was provided */ |
| 742 | 743 | if (NULL == config) { |
| 743 | 744 | /* initialize configuration */ |
| 744 | 745 | init_JSON_config(&default_config); |
| 745 | 746 | config = &default_config; |
| 746 | 747 | } |
| 747 | | - |
| 748 | + |
| 748 | 749 | /* use std malloc if either the allocator or deallocator function isn't set */ |
| 749 | 750 | use_std_malloc = NULL == config->malloc || NULL == config->free; |
| 750 | | - |
| 751 | + |
| 751 | 752 | alloc = use_std_malloc ? malloc : config->malloc; |
| 752 | | - |
| 753 | | - jc = JSON_parser_malloc(alloc, sizeof(*jc), "parser"); |
| 754 | | - |
| 753 | + |
| 754 | + jc = (JSON_parser)JSON_parser_malloc(alloc, sizeof(*jc), "parser"); |
| 755 | + |
| 755 | 756 | if (NULL == jc) { |
| 756 | 757 | return NULL; |
| 757 | 758 | } |
| 758 | | - |
| 759 | + |
| 759 | 760 | /* configure the parser */ |
| 760 | 761 | memset(jc, 0, sizeof(*jc)); |
| 761 | 762 | jc->malloc = alloc; |
| 762 | 763 | jc->free = use_std_malloc ? free : config->free; |
| 763 | 764 | jc->callback = config->callback; |
| | @@ -765,42 +766,42 @@ |
| 765 | 766 | jc->allow_comments = (signed char)(config->allow_comments != 0); |
| 766 | 767 | jc->handle_floats_manually = (signed char)(config->handle_floats_manually != 0); |
| 767 | 768 | jc->decimal_point = *localeconv()->decimal_point; |
| 768 | 769 | /* We need to be able to push at least one object */ |
| 769 | 770 | jc->depth = config->depth == 0 ? 1 : config->depth; |
| 770 | | - |
| 771 | + |
| 771 | 772 | /* reset the parser */ |
| 772 | 773 | if (!JSON_parser_reset(jc)) { |
| 773 | 774 | jc->free(jc); |
| 774 | 775 | return NULL; |
| 775 | 776 | } |
| 776 | | - |
| 777 | + |
| 777 | 778 | return jc; |
| 778 | 779 | } |
| 779 | 780 | |
| 780 | 781 | static int parse_buffer_grow(JSON_parser jc) |
| 781 | 782 | { |
| 782 | 783 | const size_t bytes_to_copy = jc->parse_buffer_count * sizeof(jc->parse_buffer[0]); |
| 783 | 784 | const size_t new_capacity = jc->parse_buffer_capacity * 2; |
| 784 | 785 | const size_t bytes_to_allocate = new_capacity * sizeof(jc->parse_buffer[0]); |
| 785 | 786 | void* mem = JSON_parser_malloc(jc->malloc, bytes_to_allocate, "parse buffer"); |
| 786 | | - |
| 787 | + |
| 787 | 788 | if (mem == NULL) { |
| 788 | 789 | jc->error = JSON_E_OUT_OF_MEMORY; |
| 789 | 790 | return false; |
| 790 | 791 | } |
| 791 | | - |
| 792 | + |
| 792 | 793 | assert(new_capacity > 0); |
| 793 | 794 | memcpy(mem, jc->parse_buffer, bytes_to_copy); |
| 794 | | - |
| 795 | + |
| 795 | 796 | if (jc->parse_buffer != &jc->static_parse_buffer[0]) { |
| 796 | 797 | jc->free(jc->parse_buffer); |
| 797 | 798 | } |
| 798 | | - |
| 799 | + |
| 799 | 800 | jc->parse_buffer = (char*)mem; |
| 800 | 801 | jc->parse_buffer_capacity = new_capacity; |
| 801 | | - |
| 802 | + |
| 802 | 803 | return true; |
| 803 | 804 | } |
| 804 | 805 | |
| 805 | 806 | static int parse_buffer_reserve_for(JSON_parser jc, unsigned chars) |
| 806 | 807 | { |
| | @@ -808,11 +809,11 @@ |
| 808 | 809 | if (!parse_buffer_grow(jc)) { |
| 809 | 810 | assert(jc->error == JSON_E_OUT_OF_MEMORY); |
| 810 | 811 | return false; |
| 811 | 812 | } |
| 812 | 813 | } |
| 813 | | - |
| 814 | + |
| 814 | 815 | return true; |
| 815 | 816 | } |
| 816 | 817 | |
| 817 | 818 | #define parse_buffer_has_space_for(jc, count) \ |
| 818 | 819 | (jc->parse_buffer_count + (count) + 1 <= jc->parse_buffer_capacity) |
| | @@ -830,27 +831,27 @@ |
| 830 | 831 | jc->type == JSON_T_FALSE || \ |
| 831 | 832 | jc->type == JSON_T_TRUE || \ |
| 832 | 833 | jc->type == JSON_T_FLOAT || \ |
| 833 | 834 | jc->type == JSON_T_INTEGER || \ |
| 834 | 835 | jc->type == JSON_T_STRING) |
| 835 | | - |
| 836 | + |
| 836 | 837 | |
| 837 | 838 | static int parse_parse_buffer(JSON_parser jc) |
| 838 | 839 | { |
| 839 | 840 | if (jc->callback) { |
| 840 | 841 | JSON_value value, *arg = NULL; |
| 841 | | - |
| 842 | + |
| 842 | 843 | if (jc->type != JSON_T_NONE) { |
| 843 | 844 | assert_is_non_container_type(jc); |
| 844 | | - |
| 845 | + |
| 845 | 846 | switch(jc->type) { |
| 846 | 847 | case JSON_T_FLOAT: |
| 847 | 848 | arg = &value; |
| 848 | 849 | if (jc->handle_floats_manually) { |
| 849 | 850 | value.vu.str.value = jc->parse_buffer; |
| 850 | 851 | value.vu.str.length = jc->parse_buffer_count; |
| 851 | | - } else { |
| 852 | + } else { |
| 852 | 853 | /* not checking with end pointer b/c there may be trailing ws */ |
| 853 | 854 | value.vu.float_value = strtod(jc->parse_buffer, NULL); |
| 854 | 855 | } |
| 855 | 856 | break; |
| 856 | 857 | case JSON_T_INTEGER: |
| | @@ -861,19 +862,19 @@ |
| 861 | 862 | arg = &value; |
| 862 | 863 | value.vu.str.value = jc->parse_buffer; |
| 863 | 864 | value.vu.str.length = jc->parse_buffer_count; |
| 864 | 865 | break; |
| 865 | 866 | } |
| 866 | | - |
| 867 | + |
| 867 | 868 | if (!(*jc->callback)(jc->ctx, jc->type, arg)) { |
| 868 | 869 | return false; |
| 869 | 870 | } |
| 870 | 871 | } |
| 871 | 872 | } |
| 872 | | - |
| 873 | + |
| 873 | 874 | parse_buffer_clear(jc); |
| 874 | | - |
| 875 | + |
| 875 | 876 | return true; |
| 876 | 877 | } |
| 877 | 878 | |
| 878 | 879 | #define IS_HIGH_SURROGATE(uc) (((uc) & 0xFC00) == 0xD800) |
| 879 | 880 | #define IS_LOW_SURROGATE(uc) (((uc) & 0xFC00) == 0xDC00) |
| | @@ -884,35 +885,39 @@ |
| 884 | 885 | { |
| 885 | 886 | int i; |
| 886 | 887 | unsigned uc = 0; |
| 887 | 888 | char* p; |
| 888 | 889 | int trail_bytes; |
| 889 | | - |
| 890 | + |
| 890 | 891 | assert(jc->parse_buffer_count >= 6); |
| 891 | | - |
| 892 | + |
| 892 | 893 | p = &jc->parse_buffer[jc->parse_buffer_count - 4]; |
| 893 | | - |
| 894 | + |
| 894 | 895 | for (i = 12; i >= 0; i -= 4, ++p) { |
| 895 | 896 | unsigned x = *p; |
| 896 | | - |
| 897 | + |
| 897 | 898 | if (x >= 'a') { |
| 898 | 899 | x -= ('a' - 10); |
| 899 | 900 | } else if (x >= 'A') { |
| 900 | 901 | x -= ('A' - 10); |
| 901 | 902 | } else { |
| 902 | 903 | x &= ~0x30u; |
| 903 | 904 | } |
| 904 | | - |
| 905 | + |
| 905 | 906 | assert(x < 16); |
| 906 | | - |
| 907 | + |
| 907 | 908 | uc |= x << i; |
| 908 | 909 | } |
| 909 | | - |
| 910 | + |
| 910 | 911 | /* clear UTF-16 char from buffer */ |
| 911 | 912 | jc->parse_buffer_count -= 6; |
| 912 | 913 | jc->parse_buffer[jc->parse_buffer_count] = 0; |
| 913 | | - |
| 914 | + |
| 915 | + if (uc == 0xffff || uc == 0xfffe) { |
| 916 | + return false; |
| 917 | + } |
| 918 | + |
| 914 | 919 | /* attempt decoding ... */ |
| 915 | 920 | if (jc->utf16_high_surrogate) { |
| 916 | 921 | if (IS_LOW_SURROGATE(uc)) { |
| 917 | 922 | uc = DECODE_SURROGATE_PAIR(jc->utf16_high_surrogate, uc); |
| 918 | 923 | trail_bytes = 3; |
| | @@ -935,26 +940,26 @@ |
| 935 | 940 | return false; |
| 936 | 941 | } else { |
| 937 | 942 | trail_bytes = 2; |
| 938 | 943 | } |
| 939 | 944 | } |
| 940 | | - |
| 945 | + |
| 941 | 946 | jc->parse_buffer[jc->parse_buffer_count++] = (char) ((uc >> (trail_bytes * 6)) | utf8_lead_bits[trail_bytes]); |
| 942 | | - |
| 947 | + |
| 943 | 948 | for (i = trail_bytes * 6 - 6; i >= 0; i -= 6) { |
| 944 | 949 | jc->parse_buffer[jc->parse_buffer_count++] = (char) (((uc >> i) & 0x3F) | 0x80); |
| 945 | 950 | } |
| 946 | 951 | |
| 947 | 952 | jc->parse_buffer[jc->parse_buffer_count] = 0; |
| 948 | | - |
| 953 | + |
| 949 | 954 | return true; |
| 950 | 955 | } |
| 951 | 956 | |
| 952 | 957 | static int add_escaped_char_to_parse_buffer(JSON_parser jc, int next_char) |
| 953 | 958 | { |
| 954 | 959 | assert(parse_buffer_has_space_for(jc, 1)); |
| 955 | | - |
| 960 | + |
| 956 | 961 | jc->escaped = 0; |
| 957 | 962 | /* remove the backslash */ |
| 958 | 963 | parse_buffer_pop_back_char(jc); |
| 959 | 964 | switch(next_char) { |
| 960 | 965 | case 'b': |
| | @@ -996,22 +1001,22 @@ |
| 996 | 1001 | { |
| 997 | 1002 | if (!parse_buffer_reserve_for(jc, 1)) { |
| 998 | 1003 | assert(JSON_E_OUT_OF_MEMORY == jc->error); |
| 999 | 1004 | return false; |
| 1000 | 1005 | } |
| 1001 | | - |
| 1006 | + |
| 1002 | 1007 | if (jc->escaped) { |
| 1003 | 1008 | if (!add_escaped_char_to_parse_buffer(jc, next_char)) { |
| 1004 | 1009 | jc->error = JSON_E_INVALID_ESCAPE_SEQUENCE; |
| 1005 | | - return false; |
| 1010 | + return false; |
| 1006 | 1011 | } |
| 1007 | 1012 | } else if (!jc->comment) { |
| 1008 | 1013 | if ((jc->type != JSON_T_NONE) | !((next_class == C_SPACE) | (next_class == C_WHITE)) /* non-white-space */) { |
| 1009 | 1014 | parse_buffer_push_back_char(jc, (char)next_char); |
| 1010 | 1015 | } |
| 1011 | 1016 | } |
| 1012 | | - |
| 1017 | + |
| 1013 | 1018 | return true; |
| 1014 | 1019 | } |
| 1015 | 1020 | |
| 1016 | 1021 | #define assert_type_isnt_string_null_or_bool(jc) \ |
| 1017 | 1022 | assert(jc->type != JSON_T_FALSE); \ |
| | @@ -1031,13 +1036,13 @@ |
| 1031 | 1036 | */ |
| 1032 | 1037 | int next_class, next_state; |
| 1033 | 1038 | |
| 1034 | 1039 | /* |
| 1035 | 1040 | Store the current char for error handling |
| 1036 | | -*/ |
| 1041 | +*/ |
| 1037 | 1042 | jc->current_char = next_char; |
| 1038 | | - |
| 1043 | + |
| 1039 | 1044 | /* |
| 1040 | 1045 | Determine the character's class. |
| 1041 | 1046 | */ |
| 1042 | 1047 | if (next_char < 0) { |
| 1043 | 1048 | jc->error = JSON_E_INVALID_CHAR; |
| | @@ -1050,15 +1055,15 @@ |
| 1050 | 1055 | if (next_class <= __) { |
| 1051 | 1056 | set_error(jc); |
| 1052 | 1057 | return false; |
| 1053 | 1058 | } |
| 1054 | 1059 | } |
| 1055 | | - |
| 1060 | + |
| 1056 | 1061 | if (!add_char_to_parse_buffer(jc, next_char, next_class)) { |
| 1057 | 1062 | return false; |
| 1058 | 1063 | } |
| 1059 | | - |
| 1064 | + |
| 1060 | 1065 | /* |
| 1061 | 1066 | Get the next state from the state transition table. |
| 1062 | 1067 | */ |
| 1063 | 1068 | next_state = state_transition_table[jc->state][next_class]; |
| 1064 | 1069 | if (next_state >= 0) { |
| | @@ -1069,11 +1074,11 @@ |
| 1069 | 1074 | } else { |
| 1070 | 1075 | /* |
| 1071 | 1076 | Or perform one of the actions. |
| 1072 | 1077 | */ |
| 1073 | 1078 | switch (next_state) { |
| 1074 | | -/* Unicode character */ |
| 1079 | +/* Unicode character */ |
| 1075 | 1080 | case UC: |
| 1076 | 1081 | if(!decode_unicode_char(jc)) { |
| 1077 | 1082 | jc->error = JSON_E_INVALID_UNICODE_SEQUENCE; |
| 1078 | 1083 | return false; |
| 1079 | 1084 | } |
| | @@ -1091,78 +1096,78 @@ |
| 1091 | 1096 | break; |
| 1092 | 1097 | /* integer detected by minus */ |
| 1093 | 1098 | case MX: |
| 1094 | 1099 | jc->type = JSON_T_INTEGER; |
| 1095 | 1100 | jc->state = MI; |
| 1096 | | - break; |
| 1097 | | -/* integer detected by zero */ |
| 1101 | + break; |
| 1102 | +/* integer detected by zero */ |
| 1098 | 1103 | case ZX: |
| 1099 | 1104 | jc->type = JSON_T_INTEGER; |
| 1100 | 1105 | jc->state = ZE; |
| 1101 | | - break; |
| 1102 | | -/* integer detected by 1-9 */ |
| 1106 | + break; |
| 1107 | +/* integer detected by 1-9 */ |
| 1103 | 1108 | case IX: |
| 1104 | 1109 | jc->type = JSON_T_INTEGER; |
| 1105 | 1110 | jc->state = IT; |
| 1106 | | - break; |
| 1107 | | - |
| 1111 | + break; |
| 1112 | + |
| 1108 | 1113 | /* floating point number detected by exponent*/ |
| 1109 | 1114 | case DE: |
| 1110 | 1115 | assert_type_isnt_string_null_or_bool(jc); |
| 1111 | 1116 | jc->type = JSON_T_FLOAT; |
| 1112 | 1117 | jc->state = E1; |
| 1113 | | - break; |
| 1114 | | - |
| 1118 | + break; |
| 1119 | + |
| 1115 | 1120 | /* floating point number detected by fraction */ |
| 1116 | 1121 | case DF: |
| 1117 | 1122 | assert_type_isnt_string_null_or_bool(jc); |
| 1118 | 1123 | if (!jc->handle_floats_manually) { |
| 1119 | 1124 | /* |
| 1120 | | - Some versions of strtod (which underlies sscanf) don't support converting |
| 1125 | + Some versions of strtod (which underlies sscanf) don't support converting |
| 1121 | 1126 | C-locale formated floating point values. |
| 1122 | | -*/ |
| 1127 | +*/ |
| 1123 | 1128 | assert(jc->parse_buffer[jc->parse_buffer_count-1] == '.'); |
| 1124 | 1129 | jc->parse_buffer[jc->parse_buffer_count-1] = jc->decimal_point; |
| 1125 | | - } |
| 1130 | + } |
| 1126 | 1131 | jc->type = JSON_T_FLOAT; |
| 1127 | 1132 | jc->state = FX; |
| 1128 | | - break; |
| 1133 | + break; |
| 1129 | 1134 | /* string begin " */ |
| 1130 | 1135 | case SB: |
| 1131 | 1136 | parse_buffer_clear(jc); |
| 1132 | 1137 | assert(jc->type == JSON_T_NONE); |
| 1133 | 1138 | jc->type = JSON_T_STRING; |
| 1134 | 1139 | jc->state = ST; |
| 1135 | | - break; |
| 1136 | | - |
| 1140 | + break; |
| 1141 | + |
| 1137 | 1142 | /* n */ |
| 1138 | 1143 | case NU: |
| 1139 | 1144 | assert(jc->type == JSON_T_NONE); |
| 1140 | 1145 | jc->type = JSON_T_NULL; |
| 1141 | 1146 | jc->state = N1; |
| 1142 | | - break; |
| 1147 | + break; |
| 1143 | 1148 | /* f */ |
| 1144 | 1149 | case FA: |
| 1145 | 1150 | assert(jc->type == JSON_T_NONE); |
| 1146 | 1151 | jc->type = JSON_T_FALSE; |
| 1147 | 1152 | jc->state = F1; |
| 1148 | | - break; |
| 1153 | + break; |
| 1149 | 1154 | /* t */ |
| 1150 | 1155 | case TR: |
| 1151 | 1156 | assert(jc->type == JSON_T_NONE); |
| 1152 | 1157 | jc->type = JSON_T_TRUE; |
| 1153 | 1158 | jc->state = T1; |
| 1154 | | - break; |
| 1155 | | - |
| 1159 | + break; |
| 1160 | + |
| 1156 | 1161 | /* closing comment */ |
| 1157 | 1162 | case CE: |
| 1158 | 1163 | jc->comment = 0; |
| 1159 | 1164 | assert(jc->parse_buffer_count == 0); |
| 1160 | 1165 | assert(jc->type == JSON_T_NONE); |
| 1161 | 1166 | jc->state = jc->before_comment_state; |
| 1162 | | - break; |
| 1163 | | - |
| 1167 | + break; |
| 1168 | + |
| 1164 | 1169 | /* opening comment */ |
| 1165 | 1170 | case CB: |
| 1166 | 1171 | if (!jc->allow_comments) { |
| 1167 | 1172 | return false; |
| 1168 | 1173 | } |
| | @@ -1172,11 +1177,11 @@ |
| 1172 | 1177 | } |
| 1173 | 1178 | assert(jc->parse_buffer_count == 0); |
| 1174 | 1179 | assert(jc->type != JSON_T_STRING); |
| 1175 | 1180 | switch (jc->stack[jc->top]) { |
| 1176 | 1181 | case MODE_ARRAY: |
| 1177 | | - case MODE_OBJECT: |
| 1182 | + case MODE_OBJECT: |
| 1178 | 1183 | switch(jc->state) { |
| 1179 | 1184 | case VA: |
| 1180 | 1185 | case AR: |
| 1181 | 1186 | jc->before_comment_state = jc->state; |
| 1182 | 1187 | break; |
| | @@ -1192,11 +1197,11 @@ |
| 1192 | 1197 | jc->type = JSON_T_NONE; |
| 1193 | 1198 | jc->state = C1; |
| 1194 | 1199 | jc->comment = 1; |
| 1195 | 1200 | break; |
| 1196 | 1201 | /* empty } */ |
| 1197 | | - case -9: |
| 1202 | + case -9: |
| 1198 | 1203 | parse_buffer_clear(jc); |
| 1199 | 1204 | if (jc->callback && !(*jc->callback)(jc->ctx, JSON_T_OBJECT_END, NULL)) { |
| 1200 | 1205 | return false; |
| 1201 | 1206 | } |
| 1202 | 1207 | if (!pop(jc, MODE_KEY)) { |
| | @@ -1231,11 +1236,11 @@ |
| 1231 | 1236 | } |
| 1232 | 1237 | if (!pop(jc, MODE_ARRAY)) { |
| 1233 | 1238 | jc->error = JSON_E_UNBALANCED_COLLECTION; |
| 1234 | 1239 | return false; |
| 1235 | 1240 | } |
| 1236 | | - |
| 1241 | + |
| 1237 | 1242 | jc->type = JSON_T_NONE; |
| 1238 | 1243 | jc->state = OK; |
| 1239 | 1244 | break; |
| 1240 | 1245 | |
| 1241 | 1246 | /* { */ case -6: |
| | @@ -1267,11 +1272,11 @@ |
| 1267 | 1272 | switch (jc->stack[jc->top]) { |
| 1268 | 1273 | case MODE_KEY: |
| 1269 | 1274 | assert(jc->type == JSON_T_STRING); |
| 1270 | 1275 | jc->type = JSON_T_NONE; |
| 1271 | 1276 | jc->state = CO; |
| 1272 | | - |
| 1277 | + |
| 1273 | 1278 | if (jc->callback) { |
| 1274 | 1279 | JSON_value value; |
| 1275 | 1280 | value.vu.str.value = jc->parse_buffer; |
| 1276 | 1281 | value.vu.str.length = jc->parse_buffer_count; |
| 1277 | 1282 | if (!(*jc->callback)(jc->ctx, JSON_T_KEY, &value)) { |
| | @@ -1357,29 +1362,29 @@ |
| 1357 | 1362 | |
| 1358 | 1363 | |
| 1359 | 1364 | int JSON_parser_is_legal_white_space_string(const char* s) |
| 1360 | 1365 | { |
| 1361 | 1366 | int c, char_class; |
| 1362 | | - |
| 1367 | + |
| 1363 | 1368 | if (s == NULL) { |
| 1364 | 1369 | return false; |
| 1365 | 1370 | } |
| 1366 | | - |
| 1367 | | - for (; *s; ++s) { |
| 1371 | + |
| 1372 | + for (; *s; ++s) { |
| 1368 | 1373 | c = *s; |
| 1369 | | - |
| 1374 | + |
| 1370 | 1375 | if (c < 0 || c >= 128) { |
| 1371 | 1376 | return false; |
| 1372 | 1377 | } |
| 1373 | | - |
| 1378 | + |
| 1374 | 1379 | char_class = ascii_class[c]; |
| 1375 | | - |
| 1380 | + |
| 1376 | 1381 | if (char_class != C_SPACE && char_class != C_WHITE) { |
| 1377 | 1382 | return false; |
| 1378 | 1383 | } |
| 1379 | 1384 | } |
| 1380 | | - |
| 1385 | + |
| 1381 | 1386 | return true; |
| 1382 | 1387 | } |
| 1383 | 1388 | |
| 1384 | 1389 | int JSON_parser_get_last_error(JSON_parser jc) |
| 1385 | 1390 | { |
| | @@ -1389,16 +1394,17 @@ |
| 1389 | 1394 | |
| 1390 | 1395 | void init_JSON_config(JSON_config* config) |
| 1391 | 1396 | { |
| 1392 | 1397 | if (config) { |
| 1393 | 1398 | memset(config, 0, sizeof(*config)); |
| 1394 | | - |
| 1399 | + |
| 1395 | 1400 | config->depth = JSON_PARSER_STACK_SIZE - 1; |
| 1396 | 1401 | config->malloc = malloc; |
| 1397 | 1402 | config->free = free; |
| 1398 | 1403 | } |
| 1399 | 1404 | } |
| 1405 | + |
| 1400 | 1406 | /* end file parser/JSON_parser.c */ |
| 1401 | 1407 | /* begin file ./cson.c */ |
| 1402 | 1408 | #include <assert.h> |
| 1403 | 1409 | #include <stdlib.h> /* malloc()/free() */ |
| 1404 | 1410 | #include <string.h> |
| 1405 | 1411 | |