load.c 29 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321132213231324132513261327132813291330133113321333133413351336133713381339134013411342134313441345134613471348134913501351135213531354135513561357135813591360136113621363136413651366136713681369137013711372137313741375137613771378137913801381138213831384138513861387138813891390139113921393139413951396139713981399140014011402140314041405140614071408140914101411141214131414141514161417141814191420142114221423
  1. /*
  2. * Copyright (c) 2009-2016 Petri Lehtinen <petri@digip.org>
  3. *
  4. * Jansson is free software; you can redistribute it and/or modify
  5. * it under the terms of the MIT license. See LICENSE for details.
  6. (C) Copyright 2020 Hewlett Packard Enterprise Development LP<BR>
  7. SPDX-License-Identifier: BSD-2-Clause-Patent AND MIT
  8. */
  9. #ifndef _GNU_SOURCE
  10. #define _GNU_SOURCE
  11. #endif
  12. #include "jansson_private.h"
  13. #include <assert.h>
  14. #include <errno.h>
  15. #include <limits.h>
  16. #include <stdio.h>
  17. #include <stdlib.h>
  18. #include <string.h>
  19. #ifdef HAVE_UNISTD_H
  20. #include <unistd.h>
  21. #endif
  22. #include "jansson.h"
  23. #include "strbuffer.h"
  24. #include "utf.h"
  25. #define STREAM_STATE_OK 0
  26. #define STREAM_STATE_EOF -1
  27. #define STREAM_STATE_ERROR -2
  28. #define TOKEN_INVALID -1
  29. #define TOKEN_EOF 0
  30. #define TOKEN_STRING 256
  31. #define TOKEN_INTEGER 257
  32. #define TOKEN_REAL 258
  33. #define TOKEN_TRUE 259
  34. #define TOKEN_FALSE 260
  35. #define TOKEN_NULL 261
  36. /* Locale independent versions of isxxx() functions */
  37. #define l_isupper(c) ('A' <= (c) && (c) <= 'Z')
  38. #define l_islower(c) ('a' <= (c) && (c) <= 'z')
  39. #define l_isalpha(c) (l_isupper(c) || l_islower(c))
  40. #define l_isdigit(c) ('0' <= (c) && (c) <= '9')
  41. #define l_isxdigit(c) \
  42. (l_isdigit(c) || ('A' <= (c) && (c) <= 'F') || ('a' <= (c) && (c) <= 'f'))
  43. /* Read one byte from stream, convert to unsigned char, then int, and
  44. return. return EOF on end of file. This corresponds to the
  45. behaviour of fgetc(). */
  46. typedef int (*get_func)(
  47. void *data
  48. );
  49. typedef struct {
  50. get_func get;
  51. void *data;
  52. char buffer[5];
  53. size_t buffer_pos;
  54. int state;
  55. int line;
  56. int column, last_column;
  57. size_t position;
  58. } stream_t;
  59. typedef struct {
  60. stream_t stream;
  61. strbuffer_t saved_text;
  62. size_t flags;
  63. size_t depth;
  64. int token;
  65. union {
  66. struct {
  67. char *val;
  68. size_t len;
  69. } string;
  70. json_int_t integer;
  71. double real;
  72. } value;
  73. } lex_t;
  74. #define stream_to_lex(stream) container_of(stream, lex_t, stream)
  75. /*** error reporting ***/
  76. static void
  77. error_set (
  78. json_error_t *error,
  79. const lex_t *lex,
  80. enum json_error_code code,
  81. const char *msg,
  82. ...
  83. )
  84. {
  85. va_list ap;
  86. char msg_text[JSON_ERROR_TEXT_LENGTH];
  87. char msg_with_context[JSON_ERROR_TEXT_LENGTH];
  88. int line = -1, col = -1;
  89. size_t pos = 0;
  90. const char *result = msg_text;
  91. if (!error) {
  92. return;
  93. }
  94. va_start (ap, msg);
  95. vsnprintf (msg_text, JSON_ERROR_TEXT_LENGTH, msg, ap);
  96. msg_text[JSON_ERROR_TEXT_LENGTH - 1] = '\0';
  97. va_end (ap);
  98. if (lex) {
  99. const char *saved_text = strbuffer_value (&lex->saved_text);
  100. line = lex->stream.line;
  101. col = lex->stream.column;
  102. pos = lex->stream.position;
  103. if (saved_text && saved_text[0]) {
  104. if (lex->saved_text.length <= 20) {
  105. snprintf (
  106. msg_with_context,
  107. JSON_ERROR_TEXT_LENGTH,
  108. "%s near '%s'",
  109. msg_text,
  110. saved_text
  111. );
  112. msg_with_context[JSON_ERROR_TEXT_LENGTH - 1] = '\0';
  113. result = msg_with_context;
  114. }
  115. } else {
  116. if (code == json_error_invalid_syntax) {
  117. /* More specific error code for premature end of file. */
  118. code = json_error_premature_end_of_input;
  119. }
  120. if (lex->stream.state == STREAM_STATE_ERROR) {
  121. /* No context for UTF-8 decoding errors */
  122. result = msg_text;
  123. } else {
  124. snprintf (
  125. msg_with_context,
  126. JSON_ERROR_TEXT_LENGTH,
  127. "%s near end of file",
  128. msg_text
  129. );
  130. msg_with_context[JSON_ERROR_TEXT_LENGTH - 1] = '\0';
  131. result = msg_with_context;
  132. }
  133. }
  134. }
  135. jsonp_error_set (error, line, col, pos, code, "%s", result);
  136. }
  137. /*** lexical analyzer ***/
  138. static void
  139. stream_init (
  140. stream_t *stream,
  141. get_func get,
  142. void *data
  143. )
  144. {
  145. stream->get = get;
  146. stream->data = data;
  147. stream->buffer[0] = '\0';
  148. stream->buffer_pos = 0;
  149. stream->state = STREAM_STATE_OK;
  150. stream->line = 1;
  151. stream->column = 0;
  152. stream->position = 0;
  153. }
  154. static int
  155. stream_get (
  156. stream_t *stream,
  157. json_error_t *error
  158. )
  159. {
  160. int c;
  161. if (stream->state != STREAM_STATE_OK) {
  162. return stream->state;
  163. }
  164. if (!stream->buffer[stream->buffer_pos]) {
  165. c = stream->get (stream->data);
  166. if (c == EOF) {
  167. stream->state = STREAM_STATE_EOF;
  168. return STREAM_STATE_EOF;
  169. }
  170. stream->buffer[0] = c;
  171. stream->buffer_pos = 0;
  172. if ((0x80 <= c) && (c <= 0xFF)) {
  173. /* multi-byte UTF-8 sequence */
  174. size_t i, count;
  175. count = utf8_check_first (c);
  176. if (!count) {
  177. goto out;
  178. }
  179. assert (count >= 2);
  180. for (i = 1; i < count; i++) {
  181. stream->buffer[i] = stream->get (stream->data);
  182. }
  183. if (!utf8_check_full (stream->buffer, count, NULL)) {
  184. goto out;
  185. }
  186. stream->buffer[count] = '\0';
  187. } else {
  188. stream->buffer[1] = '\0';
  189. }
  190. }
  191. c = stream->buffer[stream->buffer_pos++];
  192. stream->position++;
  193. if (c == '\n') {
  194. stream->line++;
  195. stream->last_column = stream->column;
  196. stream->column = 0;
  197. } else if (utf8_check_first (c)) {
  198. /* track the Unicode character column, so increment only if
  199. this is the first character of a UTF-8 sequence */
  200. stream->column++;
  201. }
  202. return c;
  203. out:
  204. stream->state = STREAM_STATE_ERROR;
  205. error_set (
  206. error,
  207. stream_to_lex (stream),
  208. json_error_invalid_utf8,
  209. "unable to decode byte 0x%x",
  210. c
  211. );
  212. return STREAM_STATE_ERROR;
  213. }
  214. static void
  215. stream_unget (
  216. stream_t *stream,
  217. int c
  218. )
  219. {
  220. if ((c == STREAM_STATE_EOF) || (c == STREAM_STATE_ERROR)) {
  221. return;
  222. }
  223. stream->position--;
  224. if (c == '\n') {
  225. stream->line--;
  226. stream->column = stream->last_column;
  227. } else if (utf8_check_first (c)) {
  228. stream->column--;
  229. }
  230. assert (stream->buffer_pos > 0);
  231. stream->buffer_pos--;
  232. assert (stream->buffer[stream->buffer_pos] == c);
  233. }
  234. static int
  235. lex_get (
  236. lex_t *lex,
  237. json_error_t *error
  238. )
  239. {
  240. return stream_get (&lex->stream, error);
  241. }
  242. static void
  243. lex_save (
  244. lex_t *lex,
  245. int c
  246. )
  247. {
  248. strbuffer_append_byte (&lex->saved_text, c);
  249. }
  250. static int
  251. lex_get_save (
  252. lex_t *lex,
  253. json_error_t *error
  254. )
  255. {
  256. int c = stream_get (&lex->stream, error);
  257. if ((c != STREAM_STATE_EOF) && (c != STREAM_STATE_ERROR)) {
  258. lex_save (lex, c);
  259. }
  260. return c;
  261. }
  262. static void
  263. lex_unget (
  264. lex_t *lex,
  265. int c
  266. )
  267. {
  268. stream_unget (&lex->stream, c);
  269. }
  270. static void
  271. lex_unget_unsave (
  272. lex_t *lex,
  273. int c
  274. )
  275. {
  276. if ((c != STREAM_STATE_EOF) && (c != STREAM_STATE_ERROR)) {
  277. /* Since we treat warnings as errors, when assertions are turned
  278. * off the "d" variable would be set but never used. Which is
  279. * treated as an error by GCC.
  280. */
  281. #ifndef NDEBUG
  282. char d;
  283. #endif
  284. stream_unget (&lex->stream, c);
  285. #ifndef NDEBUG
  286. d =
  287. #endif
  288. strbuffer_pop (&lex->saved_text);
  289. assert (c == d);
  290. }
  291. }
  292. static void
  293. lex_save_cached (
  294. lex_t *lex
  295. )
  296. {
  297. while (lex->stream.buffer[lex->stream.buffer_pos] != '\0') {
  298. lex_save (lex, lex->stream.buffer[lex->stream.buffer_pos]);
  299. lex->stream.buffer_pos++;
  300. lex->stream.position++;
  301. }
  302. }
  303. static void
  304. lex_free_string (
  305. lex_t *lex
  306. )
  307. {
  308. jsonp_free (lex->value.string.val);
  309. lex->value.string.val = NULL;
  310. lex->value.string.len = 0;
  311. }
  312. /* assumes that str points to 'u' plus at least 4 valid hex digits */
  313. static int32_t
  314. decode_unicode_escape (
  315. const char *str
  316. )
  317. {
  318. int i;
  319. int32_t value = 0;
  320. assert (str[0] == 'u');
  321. for (i = 1; i <= 4; i++) {
  322. char c = str[i];
  323. value <<= 4;
  324. if (l_isdigit (c)) {
  325. value += c - '0';
  326. } else if (l_islower (c)) {
  327. value += c - 'a' + 10;
  328. } else if (l_isupper (c)) {
  329. value += c - 'A' + 10;
  330. } else {
  331. return -1;
  332. }
  333. }
  334. return value;
  335. }
  336. static void
  337. lex_scan_string (
  338. lex_t *lex,
  339. json_error_t *error
  340. )
  341. {
  342. int c;
  343. const char *p;
  344. char *t;
  345. int i;
  346. lex->value.string.val = NULL;
  347. lex->token = TOKEN_INVALID;
  348. c = lex_get_save (lex, error);
  349. while (c != '"') {
  350. if (c == STREAM_STATE_ERROR) {
  351. goto out;
  352. } else if (c == STREAM_STATE_EOF) {
  353. error_set (
  354. error,
  355. lex,
  356. json_error_premature_end_of_input,
  357. "premature end of input"
  358. );
  359. goto out;
  360. } else if ((0 <= c) && (c <= 0x1F)) {
  361. /* control character */
  362. lex_unget_unsave (lex, c);
  363. if (c == '\n') {
  364. error_set (error, lex, json_error_invalid_syntax, "unexpected newline");
  365. } else {
  366. error_set (
  367. error,
  368. lex,
  369. json_error_invalid_syntax,
  370. "control character 0x%x",
  371. c
  372. );
  373. }
  374. goto out;
  375. } else if (c == '\\') {
  376. c = lex_get_save (lex, error);
  377. if (c == 'u') {
  378. c = lex_get_save (lex, error);
  379. for (i = 0; i < 4; i++) {
  380. if (!l_isxdigit (c)) {
  381. error_set (
  382. error,
  383. lex,
  384. json_error_invalid_syntax,
  385. "invalid escape"
  386. );
  387. goto out;
  388. }
  389. c = lex_get_save (lex, error);
  390. }
  391. } else if ((c == '"') || (c == '\\') || (c == '/') || (c == 'b') || (c == 'f') ||
  392. (c == 'n') || (c == 'r') || (c == 't'))
  393. {
  394. c = lex_get_save (lex, error);
  395. } else {
  396. error_set (error, lex, json_error_invalid_syntax, "invalid escape");
  397. goto out;
  398. }
  399. } else {
  400. c = lex_get_save (lex, error);
  401. }
  402. }
  403. /* the actual value is at most of the same length as the source
  404. string, because:
  405. - shortcut escapes (e.g. "\t") (length 2) are converted to 1 byte
  406. - a single \uXXXX escape (length 6) is converted to at most 3 bytes
  407. - two \uXXXX escapes (length 12) forming an UTF-16 surrogate pair
  408. are converted to 4 bytes
  409. */
  410. t = jsonp_malloc (lex->saved_text.length + 1);
  411. if (!t) {
  412. /* this is not very nice, since TOKEN_INVALID is returned */
  413. goto out;
  414. }
  415. lex->value.string.val = t;
  416. /* + 1 to skip the " */
  417. p = strbuffer_value (&lex->saved_text) + 1;
  418. while (*p != '"') {
  419. if (*p == '\\') {
  420. p++;
  421. if (*p == 'u') {
  422. size_t length;
  423. int32_t value;
  424. value = decode_unicode_escape (p);
  425. if (value < 0) {
  426. error_set (
  427. error,
  428. lex,
  429. json_error_invalid_syntax,
  430. "invalid Unicode escape '%.6s'",
  431. p - 1
  432. );
  433. goto out;
  434. }
  435. p += 5;
  436. if ((0xD800 <= value) && (value <= 0xDBFF)) {
  437. /* surrogate pair */
  438. if ((*p == '\\') && (*(p + 1) == 'u')) {
  439. int32_t value2 = decode_unicode_escape (++p);
  440. if (value2 < 0) {
  441. error_set (
  442. error,
  443. lex,
  444. json_error_invalid_syntax,
  445. "invalid Unicode escape '%.6s'",
  446. p - 1
  447. );
  448. goto out;
  449. }
  450. p += 5;
  451. if ((0xDC00 <= value2) && (value2 <= 0xDFFF)) {
  452. /* valid second surrogate */
  453. value =
  454. ((value - 0xD800) << 10) + (value2 - 0xDC00) + 0x10000;
  455. } else {
  456. /* invalid second surrogate */
  457. error_set (
  458. error,
  459. lex,
  460. json_error_invalid_syntax,
  461. "invalid Unicode '\\u%04X\\u%04X'",
  462. value,
  463. value2
  464. );
  465. goto out;
  466. }
  467. } else {
  468. /* no second surrogate */
  469. error_set (
  470. error,
  471. lex,
  472. json_error_invalid_syntax,
  473. "invalid Unicode '\\u%04X'",
  474. value
  475. );
  476. goto out;
  477. }
  478. } else if ((0xDC00 <= value) && (value <= 0xDFFF)) {
  479. error_set (
  480. error,
  481. lex,
  482. json_error_invalid_syntax,
  483. "invalid Unicode '\\u%04X'",
  484. value
  485. );
  486. goto out;
  487. }
  488. if (utf8_encode (value, t, &length)) {
  489. assert (0);
  490. }
  491. t += length;
  492. } else {
  493. switch (*p) {
  494. case '"':
  495. case '\\':
  496. case '/':
  497. *t = *p;
  498. break;
  499. case 'b':
  500. *t = '\b';
  501. break;
  502. case 'f':
  503. *t = '\f';
  504. break;
  505. case 'n':
  506. *t = '\n';
  507. break;
  508. case 'r':
  509. *t = '\r';
  510. break;
  511. case 't':
  512. *t = '\t';
  513. break;
  514. default:
  515. assert (0);
  516. }
  517. t++;
  518. p++;
  519. }
  520. } else {
  521. *(t++) = *(p++);
  522. }
  523. }
  524. *t = '\0';
  525. lex->value.string.len = t - lex->value.string.val;
  526. lex->token = TOKEN_STRING;
  527. return;
  528. out:
  529. lex_free_string (lex);
  530. }
  531. #ifndef JANSSON_USING_CMAKE /* disabled if using cmake */
  532. #if JSON_INTEGER_IS_LONG_LONG
  533. #ifdef _MSC_VER /* Microsoft Visual Studio */
  534. #define json_strtoint _strtoi64
  535. #else
  536. #define json_strtoint strtoll
  537. #endif
  538. #else
  539. #define json_strtoint strtol
  540. #endif
  541. #endif
  542. static int
  543. lex_scan_number (
  544. lex_t *lex,
  545. int c,
  546. json_error_t *error
  547. )
  548. {
  549. const char *saved_text;
  550. char *end;
  551. double doubleval;
  552. lex->token = TOKEN_INVALID;
  553. if (c == '-') {
  554. c = lex_get_save (lex, error);
  555. }
  556. if (c == '0') {
  557. c = lex_get_save (lex, error);
  558. if (l_isdigit (c)) {
  559. lex_unget_unsave (lex, c);
  560. goto out;
  561. }
  562. } else if (l_isdigit (c)) {
  563. do {
  564. c = lex_get_save (lex, error);
  565. } while (l_isdigit (c));
  566. } else {
  567. lex_unget_unsave (lex, c);
  568. goto out;
  569. }
  570. if (!(lex->flags & JSON_DECODE_INT_AS_REAL) && (c != '.') && (c != 'E') && (c != 'e')) {
  571. json_int_t intval;
  572. lex_unget_unsave (lex, c);
  573. saved_text = strbuffer_value (&lex->saved_text);
  574. errno = 0;
  575. intval = json_strtoint (saved_text, &end, 10);
  576. if (errno == ERANGE) {
  577. if (intval < 0) {
  578. error_set (
  579. error,
  580. lex,
  581. json_error_numeric_overflow,
  582. "too big negative integer"
  583. );
  584. } else {
  585. error_set (error, lex, json_error_numeric_overflow, "too big integer");
  586. }
  587. goto out;
  588. }
  589. assert (end == saved_text + lex->saved_text.length);
  590. lex->token = TOKEN_INTEGER;
  591. lex->value.integer = intval;
  592. return 0;
  593. }
  594. if (c == '.') {
  595. c = lex_get (lex, error);
  596. if (!l_isdigit (c)) {
  597. lex_unget (lex, c);
  598. goto out;
  599. }
  600. lex_save (lex, c);
  601. do {
  602. c = lex_get_save (lex, error);
  603. } while (l_isdigit (c));
  604. }
  605. if ((c == 'E') || (c == 'e')) {
  606. c = lex_get_save (lex, error);
  607. if ((c == '+') || (c == '-')) {
  608. c = lex_get_save (lex, error);
  609. }
  610. if (!l_isdigit (c)) {
  611. lex_unget_unsave (lex, c);
  612. goto out;
  613. }
  614. do {
  615. c = lex_get_save (lex, error);
  616. } while (l_isdigit (c));
  617. }
  618. lex_unget_unsave (lex, c);
  619. if (jsonp_strtod (&lex->saved_text, &doubleval)) {
  620. error_set (error, lex, json_error_numeric_overflow, "real number overflow");
  621. goto out;
  622. }
  623. lex->token = TOKEN_REAL;
  624. lex->value.real = doubleval;
  625. return 0;
  626. out:
  627. return -1;
  628. }
  629. static int
  630. lex_scan (
  631. lex_t *lex,
  632. json_error_t *error
  633. )
  634. {
  635. int c;
  636. strbuffer_clear (&lex->saved_text);
  637. if (lex->token == TOKEN_STRING) {
  638. lex_free_string (lex);
  639. }
  640. do {
  641. c = lex_get (lex, error);
  642. } while (c == ' ' || c == '\t' || c == '\n' || c == '\r');
  643. if (c == STREAM_STATE_EOF) {
  644. lex->token = TOKEN_EOF;
  645. goto out;
  646. }
  647. if (c == STREAM_STATE_ERROR) {
  648. lex->token = TOKEN_INVALID;
  649. goto out;
  650. }
  651. lex_save (lex, c);
  652. if ((c == '{') || (c == '}') || (c == '[') || (c == ']') || (c == ':') || (c == ',')) {
  653. lex->token = c;
  654. } else if (c == '"') {
  655. lex_scan_string (lex, error);
  656. } else if (l_isdigit (c) || (c == '-')) {
  657. if (lex_scan_number (lex, c, error)) {
  658. goto out;
  659. }
  660. } else if (l_isalpha (c)) {
  661. /* eat up the whole identifier for clearer error messages */
  662. const char *saved_text;
  663. do {
  664. c = lex_get_save (lex, error);
  665. } while (l_isalpha (c));
  666. lex_unget_unsave (lex, c);
  667. saved_text = strbuffer_value (&lex->saved_text);
  668. if (strcmp (saved_text, "true") == 0) {
  669. lex->token = TOKEN_TRUE;
  670. } else if (strcmp (saved_text, "false") == 0) {
  671. lex->token = TOKEN_FALSE;
  672. } else if (strcmp (saved_text, "null") == 0) {
  673. lex->token = TOKEN_NULL;
  674. } else {
  675. lex->token = TOKEN_INVALID;
  676. }
  677. } else {
  678. /* save the rest of the input UTF-8 sequence to get an error
  679. message of valid UTF-8 */
  680. lex_save_cached (lex);
  681. lex->token = TOKEN_INVALID;
  682. }
  683. out:
  684. return lex->token;
  685. }
  686. static char *
  687. lex_steal_string (
  688. lex_t *lex,
  689. size_t *out_len
  690. )
  691. {
  692. char *result = NULL;
  693. if (lex->token == TOKEN_STRING) {
  694. result = lex->value.string.val;
  695. *out_len = lex->value.string.len;
  696. lex->value.string.val = NULL;
  697. lex->value.string.len = 0;
  698. }
  699. return result;
  700. }
  701. static int
  702. lex_init (
  703. lex_t *lex,
  704. get_func get,
  705. size_t flags,
  706. void *data
  707. )
  708. {
  709. stream_init (&lex->stream, get, data);
  710. if (strbuffer_init (&lex->saved_text)) {
  711. return -1;
  712. }
  713. lex->flags = flags;
  714. lex->token = TOKEN_INVALID;
  715. return 0;
  716. }
  717. static void
  718. lex_close (
  719. lex_t *lex
  720. )
  721. {
  722. if (lex->token == TOKEN_STRING) {
  723. lex_free_string (lex);
  724. }
  725. strbuffer_close (&lex->saved_text);
  726. }
  727. /*** parser ***/
  728. static json_t *
  729. parse_value (
  730. lex_t *lex,
  731. size_t flags,
  732. json_error_t *error
  733. );
  734. static json_t *
  735. parse_object (
  736. lex_t *lex,
  737. size_t flags,
  738. json_error_t *error
  739. )
  740. {
  741. json_t *object = json_object ();
  742. if (!object) {
  743. return NULL;
  744. }
  745. lex_scan (lex, error);
  746. if (lex->token == '}') {
  747. return object;
  748. }
  749. while (1) {
  750. char *key;
  751. size_t len;
  752. json_t *value;
  753. if (lex->token != TOKEN_STRING) {
  754. error_set (error, lex, json_error_invalid_syntax, "string or '}' expected");
  755. goto error;
  756. }
  757. key = lex_steal_string (lex, &len);
  758. if (!key) {
  759. return NULL;
  760. }
  761. if (memchr (key, '\0', len)) {
  762. jsonp_free (key);
  763. error_set (
  764. error,
  765. lex,
  766. json_error_null_byte_in_key,
  767. "NUL byte in object key not supported"
  768. );
  769. goto error;
  770. }
  771. if (flags & JSON_REJECT_DUPLICATES) {
  772. if (json_object_get (object, key)) {
  773. jsonp_free (key);
  774. error_set (error, lex, json_error_duplicate_key, "duplicate object key");
  775. goto error;
  776. }
  777. }
  778. lex_scan (lex, error);
  779. if (lex->token != ':') {
  780. jsonp_free (key);
  781. error_set (error, lex, json_error_invalid_syntax, "':' expected");
  782. goto error;
  783. }
  784. lex_scan (lex, error);
  785. value = parse_value (lex, flags, error);
  786. if (!value) {
  787. jsonp_free (key);
  788. goto error;
  789. }
  790. if (json_object_set_new_nocheck (object, key, value)) {
  791. jsonp_free (key);
  792. goto error;
  793. }
  794. jsonp_free (key);
  795. lex_scan (lex, error);
  796. if (lex->token != ',') {
  797. break;
  798. }
  799. lex_scan (lex, error);
  800. }
  801. if (lex->token != '}') {
  802. error_set (error, lex, json_error_invalid_syntax, "'}' expected");
  803. goto error;
  804. }
  805. return object;
  806. error:
  807. json_decref (object);
  808. return NULL;
  809. }
  810. static json_t *
  811. parse_array (
  812. lex_t *lex,
  813. size_t flags,
  814. json_error_t *error
  815. )
  816. {
  817. json_t *array = json_array ();
  818. if (!array) {
  819. return NULL;
  820. }
  821. lex_scan (lex, error);
  822. if (lex->token == ']') {
  823. return array;
  824. }
  825. while (lex->token) {
  826. json_t *elem = parse_value (lex, flags, error);
  827. if (!elem) {
  828. goto error;
  829. }
  830. if (json_array_append_new (array, elem)) {
  831. goto error;
  832. }
  833. lex_scan (lex, error);
  834. if (lex->token != ',') {
  835. break;
  836. }
  837. lex_scan (lex, error);
  838. }
  839. if (lex->token != ']') {
  840. error_set (error, lex, json_error_invalid_syntax, "']' expected");
  841. goto error;
  842. }
  843. return array;
  844. error:
  845. json_decref (array);
  846. return NULL;
  847. }
  848. static json_t *
  849. parse_value (
  850. lex_t *lex,
  851. size_t flags,
  852. json_error_t *error
  853. )
  854. {
  855. json_t *json;
  856. lex->depth++;
  857. if (lex->depth > JSON_PARSER_MAX_DEPTH) {
  858. error_set (error, lex, json_error_stack_overflow, "maximum parsing depth reached");
  859. return NULL;
  860. }
  861. switch (lex->token) {
  862. case TOKEN_STRING:
  863. {
  864. const char *value = lex->value.string.val;
  865. size_t len = lex->value.string.len;
  866. if (!(flags & JSON_ALLOW_NUL)) {
  867. if (memchr (value, '\0', len)) {
  868. error_set (
  869. error,
  870. lex,
  871. json_error_null_character,
  872. "\\u0000 is not allowed without JSON_ALLOW_NUL"
  873. );
  874. return NULL;
  875. }
  876. }
  877. json = jsonp_stringn_nocheck_own (value, len);
  878. lex->value.string.val = NULL;
  879. lex->value.string.len = 0;
  880. break;
  881. }
  882. case TOKEN_INTEGER:
  883. {
  884. json = json_integer (lex->value.integer);
  885. break;
  886. }
  887. case TOKEN_REAL:
  888. {
  889. json = json_real (lex->value.real);
  890. break;
  891. }
  892. case TOKEN_TRUE:
  893. json = json_true ();
  894. break;
  895. case TOKEN_FALSE:
  896. json = json_false ();
  897. break;
  898. case TOKEN_NULL:
  899. json = json_null ();
  900. break;
  901. case '{':
  902. json = parse_object (lex, flags, error);
  903. break;
  904. case '[':
  905. json = parse_array (lex, flags, error);
  906. break;
  907. case TOKEN_INVALID:
  908. error_set (error, lex, json_error_invalid_syntax, "invalid token");
  909. return NULL;
  910. default:
  911. error_set (error, lex, json_error_invalid_syntax, "unexpected token");
  912. return NULL;
  913. }
  914. if (!json) {
  915. return NULL;
  916. }
  917. lex->depth--;
  918. return json;
  919. }
  920. static json_t *
  921. parse_json (
  922. lex_t *lex,
  923. size_t flags,
  924. json_error_t *error
  925. )
  926. {
  927. json_t *result;
  928. lex->depth = 0;
  929. lex_scan (lex, error);
  930. if (!(flags & JSON_DECODE_ANY)) {
  931. if ((lex->token != '[') && (lex->token != '{')) {
  932. error_set (error, lex, json_error_invalid_syntax, "'[' or '{' expected");
  933. return NULL;
  934. }
  935. }
  936. result = parse_value (lex, flags, error);
  937. if (!result) {
  938. return NULL;
  939. }
  940. if (!(flags & JSON_DISABLE_EOF_CHECK)) {
  941. lex_scan (lex, error);
  942. if (lex->token != TOKEN_EOF) {
  943. error_set (
  944. error,
  945. lex,
  946. json_error_end_of_input_expected,
  947. "end of file expected"
  948. );
  949. json_decref (result);
  950. return NULL;
  951. }
  952. }
  953. if (error) {
  954. /* Save the position even though there was no error */
  955. error->position = (int)lex->stream.position;
  956. }
  957. return result;
  958. }
  959. typedef struct {
  960. const char *data;
  961. size_t pos;
  962. } string_data_t;
  963. static int
  964. string_get (
  965. void *data
  966. )
  967. {
  968. char c;
  969. string_data_t *stream = (string_data_t *)data;
  970. c = stream->data[stream->pos];
  971. if (c == '\0') {
  972. return EOF;
  973. } else {
  974. stream->pos++;
  975. return (unsigned char)c;
  976. }
  977. }
  978. json_t *
  979. json_loads (
  980. const char *string,
  981. size_t flags,
  982. json_error_t *error
  983. )
  984. {
  985. lex_t lex;
  986. json_t *result;
  987. string_data_t stream_data;
  988. jsonp_error_init (error, "<string>");
  989. if (string == NULL) {
  990. error_set (error, NULL, json_error_invalid_argument, "wrong arguments");
  991. return NULL;
  992. }
  993. stream_data.data = string;
  994. stream_data.pos = 0;
  995. if (lex_init (&lex, string_get, flags, (void *)&stream_data)) {
  996. return NULL;
  997. }
  998. result = parse_json (&lex, flags, error);
  999. lex_close (&lex);
  1000. return result;
  1001. }
  1002. typedef struct {
  1003. const char *data;
  1004. size_t len;
  1005. size_t pos;
  1006. } buffer_data_t;
  1007. static int
  1008. buffer_get (
  1009. void *data
  1010. )
  1011. {
  1012. char c;
  1013. buffer_data_t *stream = data;
  1014. if (stream->pos >= stream->len) {
  1015. return EOF;
  1016. }
  1017. c = stream->data[stream->pos];
  1018. stream->pos++;
  1019. return (unsigned char)c;
  1020. }
  1021. json_t *
  1022. json_loadb (
  1023. const char *buffer,
  1024. size_t buflen,
  1025. size_t flags,
  1026. json_error_t *error
  1027. )
  1028. {
  1029. lex_t lex;
  1030. json_t *result;
  1031. buffer_data_t stream_data;
  1032. jsonp_error_init (error, "<buffer>");
  1033. if (buffer == NULL) {
  1034. error_set (error, NULL, json_error_invalid_argument, "wrong arguments");
  1035. return NULL;
  1036. }
  1037. stream_data.data = buffer;
  1038. stream_data.pos = 0;
  1039. stream_data.len = buflen;
  1040. if (lex_init (&lex, buffer_get, flags, (void *)&stream_data)) {
  1041. return NULL;
  1042. }
  1043. result = parse_json (&lex, flags, error);
  1044. lex_close (&lex);
  1045. return result;
  1046. }
  1047. json_t *
  1048. json_loadf (
  1049. FILE *input,
  1050. size_t flags,
  1051. json_error_t *error
  1052. )
  1053. {
  1054. lex_t lex;
  1055. const char *source;
  1056. json_t *result;
  1057. #ifdef HAVE_UNISTD_H
  1058. if (input == stdin) {
  1059. source = "<stdin>";
  1060. } else
  1061. #endif
  1062. source = "<stream>";
  1063. jsonp_error_init (error, source);
  1064. if (input == NULL) {
  1065. error_set (error, NULL, json_error_invalid_argument, "wrong arguments");
  1066. return NULL;
  1067. }
  1068. if (lex_init (&lex, (get_func)fgetc, flags, input)) {
  1069. return NULL;
  1070. }
  1071. result = parse_json (&lex, flags, error);
  1072. lex_close (&lex);
  1073. return result;
  1074. }
  1075. static int
  1076. fd_get_func (
  1077. int *fd
  1078. )
  1079. {
  1080. #ifdef HAVE_UNISTD_H
  1081. uint8_t c;
  1082. if (read (*fd, &c, 1) == 1) {
  1083. return c;
  1084. }
  1085. #endif
  1086. return EOF;
  1087. }
  1088. json_t *
  1089. json_loadfd (
  1090. int input,
  1091. size_t flags,
  1092. json_error_t *error
  1093. )
  1094. {
  1095. lex_t lex;
  1096. const char *source;
  1097. json_t *result;
  1098. #ifdef HAVE_UNISTD_H
  1099. if (input == STDIN_FILENO) {
  1100. source = "<stdin>";
  1101. } else
  1102. #endif
  1103. source = "<stream>";
  1104. jsonp_error_init (error, source);
  1105. if (input < 0) {
  1106. error_set (error, NULL, json_error_invalid_argument, "wrong arguments");
  1107. return NULL;
  1108. }
  1109. if (lex_init (&lex, (get_func)fd_get_func, flags, &input)) {
  1110. return NULL;
  1111. }
  1112. result = parse_json (&lex, flags, error);
  1113. lex_close (&lex);
  1114. return result;
  1115. }
  1116. json_t *
  1117. json_load_file (
  1118. const char *path,
  1119. size_t flags,
  1120. json_error_t *error
  1121. )
  1122. {
  1123. json_t *result;
  1124. FILE *fp;
  1125. jsonp_error_init (error, path);
  1126. if (path == NULL) {
  1127. error_set (error, NULL, json_error_invalid_argument, "wrong arguments");
  1128. return NULL;
  1129. }
  1130. fp = fopen (path, "rb");
  1131. if (!fp) {
  1132. error_set (
  1133. error,
  1134. NULL,
  1135. json_error_cannot_open_file,
  1136. "unable to open %s: %s",
  1137. path,
  1138. strerror (errno)
  1139. );
  1140. return NULL;
  1141. }
  1142. result = json_loadf (fp, flags, error);
  1143. fclose (fp);
  1144. return result;
  1145. }
  1146. #define MAX_BUF_LEN 1024
  1147. typedef struct {
  1148. char data[MAX_BUF_LEN];
  1149. size_t len;
  1150. size_t pos;
  1151. json_load_callback_t callback;
  1152. void *arg;
  1153. } callback_data_t;
  1154. static int
  1155. callback_get (
  1156. void *data
  1157. )
  1158. {
  1159. char c;
  1160. callback_data_t *stream = data;
  1161. if (stream->pos >= stream->len) {
  1162. stream->pos = 0;
  1163. stream->len = stream->callback (stream->data, MAX_BUF_LEN, stream->arg);
  1164. if ((stream->len == 0) || (stream->len == (size_t)-1)) {
  1165. return EOF;
  1166. }
  1167. }
  1168. c = stream->data[stream->pos];
  1169. stream->pos++;
  1170. return (unsigned char)c;
  1171. }
  1172. json_t *
  1173. json_load_callback (
  1174. json_load_callback_t callback,
  1175. void *arg,
  1176. size_t flags,
  1177. json_error_t *error
  1178. )
  1179. {
  1180. lex_t lex;
  1181. json_t *result;
  1182. callback_data_t stream_data;
  1183. memset (&stream_data, 0, sizeof (stream_data));
  1184. stream_data.callback = callback;
  1185. stream_data.arg = arg;
  1186. jsonp_error_init (error, "<callback>");
  1187. if (callback == NULL) {
  1188. error_set (error, NULL, json_error_invalid_argument, "wrong arguments");
  1189. return NULL;
  1190. }
  1191. if (lex_init (&lex, (get_func)callback_get, flags, &stream_data)) {
  1192. return NULL;
  1193. }
  1194. result = parse_json (&lex, flags, error);
  1195. lex_close (&lex);
  1196. return result;
  1197. }