jdk-build-libs
/
json-c
Not watched
1
0
Fork 0
Code
Releases 11 Wiki evaluate Activity
Issues 0 Pull Requests 0 Datasets Model Cloudbrain HPC
You can not select more than 25 topics Topics must start with a chinese character,a letter or number, can include dashes ('-') and can be up to 35 characters long.
Tree: 22dee7cb59
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '22dee7cb59'
${ noResults }
json-c/json_tokener.c

521 lines
13 kB
Raw Blame History 

  1. /*

  2.  * $Id: json_tokener.c,v 1.20 2006/07/25 03:24:50 mclark Exp $

  3.  *

  4.  * Copyright (c) 2004, 2005 Metaparadigm Pte. Ltd.

  5.  * Michael Clark <michael@metaparadigm.com>

  6.  *

  7.  * This library is free software; you can redistribute it and/or modify

  8.  * it under the terms of the MIT license. See COPYING for details.

  9.  *

  10.  */

  11. 

  12. #include "config.h"

  13. 

  14. #include <stdio.h>

  15. #include <stdlib.h>

  16. #include <stddef.h>

  17. #include <ctype.h>

  18. #include <string.h>

  19. 

  20. #include "bits.h"

  21. #include "debug.h"

  22. #include "printbuf.h"

  23. #include "arraylist.h"

  24. #include "json_object.h"

  25. #include "json_tokener.h"

  26. 

  27. 

  28. #if !HAVE_STRNCASECMP && defined(_MSC_VER)

  29.   /* MSC has the version as _strnicmp */

  30. # define strncasecmp _strnicmp

  31. #elif !HAVE_STRNCASECMP

  32. # error You do not have strncasecmp on your system.

  33. #endif /* HAVE_STRNCASECMP */

  34. 

  35. 

  36. static const char* json_null_str = "null";

  37. static const char* json_true_str = "true";

  38. static const char* json_false_str = "false";

  39. 

  40. const char* json_tokener_errors[] = {

  41.   "success",

  42.   "continue",

  43.   "nesting to deep",

  44.   "unexpected end of data",

  45.   "unexpected character",

  46.   "null expected",

  47.   "boolean expected",

  48.   "number expected",

  49.   "array value separator ',' expected",

  50.   "quoted object property name expected",

  51.   "object property name separator ':' expected",

  52.   "object value separator ',' expected",

  53.   "invalid string sequence",

  54.   "expected comment",

  55. };

  56. 

  57. 

  58. struct json_tokener* json_tokener_new(void)

  59. {

  60.   struct json_tokener *tok = calloc(1, sizeof(struct json_tokener));

  61.   tok->pb = printbuf_new();

  62.   json_tokener_reset(tok);

  63.   return tok;

  64. }

  65. 

  66. void json_tokener_free(struct json_tokener *tok)

  67. {

  68.   json_tokener_reset(tok);

  69.   if(tok) printbuf_free(tok->pb);

  70.   free(tok);

  71. }

  72. 

  73. static void json_tokener_reset_level(struct json_tokener *tok, int depth)

  74. {

  75.   tok->stack[depth].state = json_tokener_state_eatws;

  76.   tok->stack[depth].saved_state = json_tokener_state_start;

  77.   json_object_put(tok->stack[depth].current);

  78.   tok->stack[depth].current = NULL;

  79.   free(tok->stack[depth].obj_field_name);

  80.   tok->stack[depth].obj_field_name = NULL;

  81. }

  82. 

  83. void json_tokener_reset(struct json_tokener *tok)

  84. {

  85.   int i;

  86.   if (!tok)

  87.     return;

  88. 

  89.   for(i = tok->depth; i >= 0; i--)

  90.     json_tokener_reset_level(tok, i);

  91.   tok->depth = 0;

  92.   tok->err = json_tokener_success;

  93. }

  94. 

  95. struct json_object* json_tokener_parse(char *str)

  96. {

  97.   struct json_tokener* tok;

  98.   struct json_object* obj;

  99. 

  100.   tok = json_tokener_new();

  101.   obj = json_tokener_parse_ex(tok, str, -1);

  102.   if(tok->err != json_tokener_success)

  103.     obj = error_ptr(-tok->err);

  104.   json_tokener_free(tok);

  105.   return obj;

  106. }

  107. 

  108. 

  109. #if !HAVE_STRNDUP

  110. /* CAW: compliant version of strndup() */

  111. char* strndup(const char* str, size_t n)

  112. {

  113.   if(str) {

  114.     size_t len = strlen(str);

  115.     size_t nn = min(len,n);

  116.     char* s = (char*)malloc(sizeof(char) * (nn + 1));

  117. 

  118.     if(s) {

  119.       memcpy(s, str, nn);

  120.       s[nn] = '\0';

  121.     }

  122. 

  123.     return s;

  124.   }

  125. 

  126.   return NULL;

  127. }

  128. #endif

  129. 

  130. 

  131. #define state  tok->stack[tok->depth].state

  132. #define saved_state  tok->stack[tok->depth].saved_state

  133. #define current tok->stack[tok->depth].current

  134. #define obj_field_name tok->stack[tok->depth].obj_field_name

  135. 

  136. struct json_object* json_tokener_parse_ex(struct json_tokener *tok,

  137. 					  char *str, int len)

  138. {

  139.   struct json_object *obj = NULL;

  140.   char c;

  141. 

  142.   tok->char_offset = 0;

  143.   tok->err = json_tokener_success;

  144. 

  145.   do {

  146.     if(tok->char_offset == len) {

  147.       if(tok->depth == 0 && state == json_tokener_state_eatws &&

  148. 	 saved_state == json_tokener_state_finish)

  149. 	tok->err = json_tokener_success;

  150.       else

  151. 	tok->err = json_tokener_continue;

  152.       goto out;

  153.     }

  154. 

  155.     c = *str;

  156.   redo_char:

  157.     switch(state) {

  158. 

  159.     case json_tokener_state_eatws:

  160.       if(isspace(c)) {

  161. 	/* okay */

  162.       } else if(c == '/') {

  163. 	printbuf_reset(tok->pb);

  164. 	printbuf_memappend(tok->pb, &c, 1);

  165. 	state = json_tokener_state_comment_start;

  166.       } else {

  167. 	state = saved_state;

  168. 	goto redo_char;

  169.       }

  170.       break;

  171. 

  172.     case json_tokener_state_start:

  173.       switch(c) {

  174.       case '{':

  175. 	state = json_tokener_state_eatws;

  176. 	saved_state = json_tokener_state_object_field_start;

  177. 	current = json_object_new_object();

  178. 	break;

  179.       case '[':

  180. 	state = json_tokener_state_eatws;

  181. 	saved_state = json_tokener_state_array;

  182. 	current = json_object_new_array();

  183. 	break;

  184.       case 'N':

  185.       case 'n':

  186. 	state = json_tokener_state_null;

  187. 	printbuf_reset(tok->pb);

  188. 	tok->st_pos = 0;

  189. 	goto redo_char;

  190.       case '"':

  191.       case '\'':

  192. 	state = json_tokener_state_string;

  193. 	printbuf_reset(tok->pb);

  194. 	tok->quote_char = c;

  195. 	break;

  196.       case 'T':

  197.       case 't':

  198.       case 'F':

  199.       case 'f':

  200. 	state = json_tokener_state_boolean;

  201. 	printbuf_reset(tok->pb);

  202. 	tok->st_pos = 0;

  203. 	goto redo_char;

  204. #if defined(__GNUC__)

  205. 	  case '0' ... '9':

  206. #else

  207. 	  case '0':

  208.       case '1':

  209.       case '2':

  210.       case '3':

  211.       case '4':

  212.       case '5':

  213.       case '6':

  214.       case '7':

  215.       case '8':

  216.       case '9':

  217. #endif

  218.       case '-':

  219. 	state = json_tokener_state_number;

  220. 	printbuf_reset(tok->pb);

  221. 	tok->is_double = 0;

  222. 	goto redo_char;

  223.       default:

  224. 	tok->err = json_tokener_error_parse_unexpected;

  225. 	goto out;

  226.       }

  227.       break;

  228. 

  229.     case json_tokener_state_finish:

  230.       if(tok->depth == 0) goto out;

  231.       obj = json_object_get(current);

  232.       json_tokener_reset_level(tok, tok->depth);

  233.       tok->depth--;

  234.       goto redo_char;

  235. 

  236.     case json_tokener_state_null:

  237.       printbuf_memappend(tok->pb, &c, 1);

  238.       if(strncasecmp(json_null_str, tok->pb->buf,

  239. 		     min(tok->st_pos+1, strlen(json_null_str))) == 0) {

  240. 	if(tok->st_pos == strlen(json_null_str)) {

  241. 	  current = NULL;

  242. 	  saved_state = json_tokener_state_finish;

  243. 	  state = json_tokener_state_eatws;

  244. 	  goto redo_char;

  245. 	}

  246.       } else {

  247. 	tok->err = json_tokener_error_parse_null;

  248. 	goto out;

  249.       }

  250.       tok->st_pos++;

  251.       break;

  252. 

  253.     case json_tokener_state_comment_start:

  254.       if(c == '*') {

  255. 	state = json_tokener_state_comment;

  256.       } else if(c == '/') {

  257. 	state = json_tokener_state_comment_eol;

  258.       } else {

  259. 	tok->err = json_tokener_error_parse_comment;

  260. 	goto out;

  261.       }

  262.       printbuf_memappend(tok->pb, &c, 1);

  263.       break;

  264. 

  265.     case json_tokener_state_comment:

  266.       if(c == '*') state = json_tokener_state_comment_end;

  267.       printbuf_memappend(tok->pb, &c, 1);

  268.       break;

  269. 

  270.     case json_tokener_state_comment_eol:

  271.       if(c == '\n') {

  272. 	MC_DEBUG("json_tokener_comment: %s\n", tok->pb->buf);

  273. 	state = json_tokener_state_eatws;

  274.       } else {

  275. 	printbuf_memappend(tok->pb, &c, 1);

  276.       }

  277.       break;

  278. 

  279.     case json_tokener_state_comment_end:

  280.       printbuf_memappend(tok->pb, &c, 1);

  281.       if(c == '/') {

  282. 	MC_DEBUG("json_tokener_comment: %s\n", tok->pb->buf);

  283. 	state = json_tokener_state_eatws;

  284.       } else {

  285. 	state = json_tokener_state_comment;

  286.       }

  287.       break;

  288. 

  289.     case json_tokener_state_string:

  290.       if(c == tok->quote_char) {

  291. 	current = json_object_new_string(tok->pb->buf);

  292. 	saved_state = json_tokener_state_finish;

  293. 	state = json_tokener_state_eatws;

  294.       } else if(c == '\\') {

  295. 	saved_state = json_tokener_state_string;

  296. 	state = json_tokener_state_string_escape;

  297.       } else {

  298. 	printbuf_memappend(tok->pb, &c, 1);

  299.       }

  300.       break;

  301. 

  302.     case json_tokener_state_string_escape:

  303.       switch(c) {

  304.       case '"':

  305.       case '\\':

  306.       case '/':

  307. 	printbuf_memappend(tok->pb, &c, 1);

  308. 	state = saved_state;

  309. 	break;

  310.       case 'b':

  311.       case 'n':

  312.       case 'r':

  313.       case 't':

  314. 	if(c == 'b') printbuf_memappend(tok->pb, "\b", 1);

  315. 	else if(c == 'n') printbuf_memappend(tok->pb, "\n", 1);

  316. 	else if(c == 'r') printbuf_memappend(tok->pb, "\r", 1);

  317. 	else if(c == 't') printbuf_memappend(tok->pb, "\t", 1);

  318. 	state = saved_state;

  319. 	break;

  320.       case 'u':

  321. 	tok->ucs_char = 0;

  322. 	tok->st_pos = 0;

  323. 	state = json_tokener_state_escape_unicode;

  324. 	break;

  325.       default:

  326. 	tok->err = json_tokener_error_parse_string;

  327. 	goto out;

  328.       }

  329.       break;

  330. 

  331.     case json_tokener_state_escape_unicode:

  332.       if(strchr(json_hex_chars, c)) {

  333. 	tok->ucs_char += ((unsigned int)hexdigit(c) << ((3-tok->st_pos++)*4));

  334. 	if(tok->st_pos == 4) {

  335. 	  unsigned char utf_out[3];

  336. 	  if (tok->ucs_char < 0x80) {

  337. 	    utf_out[0] = tok->ucs_char;

  338. 	    printbuf_memappend(tok->pb, (char*)utf_out, 1);

  339. 	  } else if (tok->ucs_char < 0x800) {

  340. 	    utf_out[0] = 0xc0 | (tok->ucs_char >> 6);

  341. 	    utf_out[1] = 0x80 | (tok->ucs_char & 0x3f);

  342. 	    printbuf_memappend(tok->pb, (char*)utf_out, 2);

  343. 	  } else {

  344. 	    utf_out[0] = 0xe0 | (tok->ucs_char >> 12);

  345. 	    utf_out[1] = 0x80 | ((tok->ucs_char >> 6) & 0x3f);

  346. 	    utf_out[2] = 0x80 | (tok->ucs_char & 0x3f);

  347. 	    printbuf_memappend(tok->pb, (char*)utf_out, 3);

  348. 	  }

  349. 	  state = saved_state;

  350. 	}

  351.       } else {

  352. 	tok->err = json_tokener_error_parse_string;

  353. 	goto out;

  354.       }

  355.       break;

  356. 

  357.     case json_tokener_state_boolean:

  358.       printbuf_memappend(tok->pb, &c, 1);

  359.       if(strncasecmp(json_true_str, tok->pb->buf,

  360. 		     min(tok->st_pos+1, strlen(json_true_str))) == 0) {

  361. 	if(tok->st_pos == strlen(json_true_str)) {

  362. 	  current = json_object_new_boolean(1);

  363. 	  saved_state = json_tokener_state_finish;

  364. 	  state = json_tokener_state_eatws;

  365. 	  goto redo_char;

  366. 	}

  367.       } else if(strncasecmp(json_false_str, tok->pb->buf,

  368. 			    min(tok->st_pos+1, strlen(json_false_str))) == 0) {

  369. 	if(tok->st_pos == strlen(json_false_str)) {

  370. 	  current = json_object_new_boolean(0);

  371. 	  saved_state = json_tokener_state_finish;

  372. 	  state = json_tokener_state_eatws;

  373. 	  goto redo_char;

  374. 	}

  375.       } else {

  376. 	tok->err = json_tokener_error_parse_boolean;

  377. 	goto out;

  378.       }

  379.       tok->st_pos++;

  380.       break;

  381. 

  382.     case json_tokener_state_number:

  383.       if(c && strchr(json_number_chars, c)) {

  384. 	printbuf_memappend(tok->pb, &c, 1);	

  385. 	if(c == '.' || c == 'e' || c == 'E') tok->is_double = 1;

  386.       } else {

  387. 	int numi;

  388. 	double numd;

  389. 	if(!tok->is_double && sscanf(tok->pb->buf, "%d", &numi) == 1) {

  390. 	  current = json_object_new_int(numi);

  391. 	} else if(tok->is_double && sscanf(tok->pb->buf, "%lf", &numd) == 1) {

  392. 	  current = json_object_new_double(numd);

  393. 	} else {

  394. 	  tok->err = json_tokener_error_parse_number;

  395. 	  goto out;

  396. 	}

  397. 	saved_state = json_tokener_state_finish;

  398. 	state = json_tokener_state_eatws;

  399. 	goto redo_char;

  400.       }

  401.       break;

  402. 

  403.     case json_tokener_state_array:

  404.       if(c == ']') {

  405. 	saved_state = json_tokener_state_finish;

  406. 	state = json_tokener_state_eatws;

  407.       } else {

  408. 	if(tok->depth >= JSON_TOKENER_MAX_DEPTH-1) {

  409. 	  tok->err = json_tokener_error_depth;

  410. 	  goto out;

  411. 	}

  412. 	state = json_tokener_state_array_add;

  413. 	tok->depth++;

  414. 	json_tokener_reset_level(tok, tok->depth);

  415. 	goto redo_char;

  416.       }

  417.       break;

  418. 

  419.     case json_tokener_state_array_add:

  420.       json_object_array_add(current, obj);

  421.       saved_state = json_tokener_state_array_sep;

  422.       state = json_tokener_state_eatws;

  423.       goto redo_char;

  424. 

  425.     case json_tokener_state_array_sep:

  426.       if(c == ']') {

  427. 	saved_state = json_tokener_state_finish;

  428. 	state = json_tokener_state_eatws;

  429.       } else if(c == ',') {

  430. 	saved_state = json_tokener_state_array;

  431. 	state = json_tokener_state_eatws;

  432.       } else {

  433. 	tok->err = json_tokener_error_parse_array;

  434. 	goto out;

  435.       }

  436.       break;

  437. 

  438.     case json_tokener_state_object_field_start:

  439.       if(c == '}') {

  440. 	saved_state = json_tokener_state_finish;

  441. 	state = json_tokener_state_eatws;

  442.       } else if (c == '"' || c == '\'') {

  443. 	tok->quote_char = c;

  444. 	printbuf_reset(tok->pb);

  445. 	state = json_tokener_state_object_field;

  446.       } else {

  447. 	tok->err = json_tokener_error_parse_object_key_name;

  448. 	goto out;

  449.       }

  450.       break;

  451. 

  452.     case json_tokener_state_object_field:

  453.       if(c == tok->quote_char) {

  454. 	obj_field_name = strdup(tok->pb->buf);

  455. 	saved_state = json_tokener_state_object_field_end;

  456. 	state = json_tokener_state_eatws;

  457.       } else if(c == '\\') {

  458. 	saved_state = json_tokener_state_object_field;

  459. 	state = json_tokener_state_string_escape;

  460.       } else {

  461. 	printbuf_memappend(tok->pb, &c, 1);

  462.       }

  463.       break;

  464. 

  465.     case json_tokener_state_object_field_end:

  466.       if(c == ':') {

  467. 	saved_state = json_tokener_state_object_value;

  468. 	state = json_tokener_state_eatws;

  469.       } else {

  470. 	tok->err = json_tokener_error_parse_object_key_sep;

  471. 	goto out;

  472.       }

  473.       break;

  474. 

  475.     case json_tokener_state_object_value:

  476.       if(tok->depth >= JSON_TOKENER_MAX_DEPTH-1) {

  477. 	tok->err = json_tokener_error_depth;

  478. 	goto out;

  479.       }

  480.       state = json_tokener_state_object_value_add;

  481.       tok->depth++;

  482.       json_tokener_reset_level(tok, tok->depth);

  483.       goto redo_char;

  484. 

  485.     case json_tokener_state_object_value_add:

  486.       json_object_object_add(current, obj_field_name, obj);

  487.       free(obj_field_name);

  488.       obj_field_name = NULL;

  489.       saved_state = json_tokener_state_object_sep;

  490.       state = json_tokener_state_eatws;

  491.       goto redo_char;

  492. 

  493.     case json_tokener_state_object_sep:

  494.       if(c == '}') {

  495. 	saved_state = json_tokener_state_finish;

  496. 	state = json_tokener_state_eatws;

  497.       } else if(c == ',') {

  498. 	saved_state = json_tokener_state_object_field_start;

  499. 	state = json_tokener_state_eatws;

  500.       } else {

  501. 	tok->err = json_tokener_error_parse_object_value_sep;

  502. 	goto out;

  503.       }

  504.       break;

  505. 

  506.     }

  507.     str++;

  508.     tok->char_offset++;

  509.   } while(c);

  510. 

  511.   if(state != json_tokener_state_finish &&

  512.      saved_state != json_tokener_state_finish)

  513.     tok->err = json_tokener_error_parse_eof;

  514. 

  515.  out:

  516.   if(tok->err == json_tokener_success) return json_object_get(current);

  517.   MC_DEBUG("json_tokener_parse_ex: error %s at offset %d\n",

  518. 	   json_tokener_errors[tok->err], tok->char_offset);

  519.   return NULL;

  520. }