lwjson.c 27 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773
  1. /**
  2. * \file lwjson.c
  3. * \brief Lightweight JSON format parser
  4. */
  5. /*
  6. * Copyright (c) 2024 Tilen MAJERLE
  7. *
  8. * Permission is hereby granted, free of charge, to any person
  9. * obtaining a copy of this software and associated documentation
  10. * files (the "Software"), to deal in the Software without restriction,
  11. * including without limitation the rights to use, copy, modify, merge,
  12. * publish, distribute, sublicense, and/or sell copies of the Software,
  13. * and to permit persons to whom the Software is furnished to do so,
  14. * subject to the following conditions:
  15. *
  16. * The above copyright notice and this permission notice shall be
  17. * included in all copies or substantial portions of the Software.
  18. *
  19. * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  20. * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
  21. * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE
  22. * AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
  23. * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
  24. * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  25. * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
  26. * OTHER DEALINGS IN THE SOFTWARE.
  27. *
  28. * This file is part of LwJSON - Lightweight JSON format parser.
  29. *
  30. * Author: Tilen MAJERLE <tilen@majerle.eu>
  31. * Version: v1.8.1
  32. */
  33. #include <string.h>
  34. #include "lwjson.h"
  35. /**
  36. * \brief Internal string object
  37. */
  38. typedef struct {
  39. const char* start; /*!< Original pointer to beginning of JSON object */
  40. size_t len; /*!< Total length of input json string */
  41. const char* p; /*!< Current char pointer */
  42. } lwjson_int_str_t;
  43. /**
  44. * \brief Allocate new token for JSON block
  45. * \param[in] lwobj: LwJSON instance
  46. * \return Pointer to new token
  47. */
  48. static lwjson_token_t*
  49. prv_alloc_token(lwjson_t* lwobj) {
  50. if (lwobj->next_free_token_pos < lwobj->tokens_len) {
  51. LWJSON_MEMSET(&lwobj->tokens[lwobj->next_free_token_pos], 0x00, sizeof(*lwobj->tokens));
  52. return &lwobj->tokens[lwobj->next_free_token_pos++];
  53. }
  54. return NULL;
  55. }
  56. /**
  57. * \brief Skip all characters that are considered *blank* as per RFC4627
  58. * \param[in,out] pobj: Pointer to text that is modified on success
  59. * \return \ref lwjsonOK on success, member of \ref lwjsonr_t otherwise
  60. */
  61. static lwjsonr_t
  62. prv_skip_blank(lwjson_int_str_t* pobj) {
  63. while (pobj->p != NULL && (size_t)(pobj->p - pobj->start) < pobj->len && *pobj->p != '\0') {
  64. if (*pobj->p == ' ' || *pobj->p == '\t' || *pobj->p == '\r' || *pobj->p == '\n' || *pobj->p == '\f') {
  65. ++pobj->p;
  66. #if LWJSON_CFG_COMMENTS
  67. /* Check for comments and remove them */
  68. } else if (*pobj->p == '/') {
  69. ++pobj->p;
  70. if (pobj->p != NULL && (size_t)(pobj->p - pobj->start) < pobj->len && *pobj->p == '*') {
  71. ++pobj->p;
  72. while (pobj->p != NULL && (size_t)(pobj->p - pobj->start) < pobj->len && *pobj->p != '\0') {
  73. if (*pobj->p == '*') {
  74. ++pobj->p;
  75. if ((size_t)(pobj->p - pobj->start) < pobj->len && *pobj->p == '/') {
  76. ++pobj->p;
  77. break;
  78. }
  79. }
  80. ++pobj->p;
  81. }
  82. }
  83. #endif /* LWJSON_CFG_COMMENTS */
  84. } else {
  85. break;
  86. }
  87. }
  88. if (pobj->p != NULL && (size_t)(pobj->p - pobj->start) < pobj->len && *pobj->p != '\0') {
  89. return lwjsonOK;
  90. }
  91. return lwjsonERRJSON;
  92. }
  93. /**
  94. * \brief Parse JSON string that must start end end with double quotes `"` character
  95. * It just parses length of characters and does not perform any decode operation
  96. * \param[in,out] pobj: Pointer to text that is modified on success
  97. * \param[out] pout: Pointer to pointer to string that is set where string starts
  98. * \param[out] poutlen: Length of string in units of characters is stored here
  99. * \return \ref lwjsonOK on success, member of \ref lwjsonr_t otherwise
  100. */
  101. static lwjsonr_t
  102. prv_parse_string(lwjson_int_str_t* pobj, const char** pout, size_t* poutlen) {
  103. lwjsonr_t res;
  104. size_t len = 0;
  105. res = prv_skip_blank(pobj);
  106. if (res != lwjsonOK) {
  107. return res;
  108. }
  109. if ((size_t)(pobj->p - pobj->start) < pobj->len && *pobj->p++ != '"') {
  110. return lwjsonERRJSON;
  111. }
  112. *pout = pobj->p;
  113. /* Parse string but take care of escape characters */
  114. for (;; ++pobj->p, ++len) {
  115. if (pobj->p == NULL || (size_t)(pobj->p - pobj->start) >= pobj->len || *pobj->p == '\0') {
  116. return lwjsonERRJSON;
  117. }
  118. /* Check special characters */
  119. if (*pobj->p == '\\') {
  120. ++pobj->p;
  121. ++len;
  122. if ((size_t)(pobj->p - pobj->start) >= pobj->len) {
  123. return lwjsonERRJSON;
  124. }
  125. switch (*pobj->p) {
  126. case '"': /* fallthrough */
  127. case '\\': /* fallthrough */
  128. case '/': /* fallthrough */
  129. case 'b': /* fallthrough */
  130. case 'f': /* fallthrough */
  131. case 'n': /* fallthrough */
  132. case 'r': /* fallthrough */
  133. case 't': break;
  134. case 'u':
  135. ++pobj->p;
  136. for (size_t i = 0; i < 4; ++i, ++len) {
  137. if (!(((size_t)(pobj->p - pobj->start) < pobj->len)
  138. && ((*pobj->p >= '0' && *pobj->p <= '9') || (*pobj->p >= 'a' && *pobj->p <= 'f')
  139. || (*pobj->p >= 'A' && *pobj->p <= 'F')))) {
  140. return lwjsonERRJSON;
  141. }
  142. if (i < 3) {
  143. ++pobj->p;
  144. }
  145. }
  146. break;
  147. default: return lwjsonERRJSON;
  148. }
  149. } else if (*pobj->p == '"') {
  150. ++pobj->p;
  151. break;
  152. }
  153. }
  154. *poutlen = len;
  155. return res;
  156. }
  157. /**
  158. * \brief Parse property name that must comply with JSON string format as in RFC4627
  159. * Property string must be followed by colon character ":"
  160. * \param[in,out] pobj: Pointer to text that is modified on success
  161. * \param[out] t: Token instance to write property name to
  162. * \return \ref lwjsonOK on success, member of \ref lwjsonr_t otherwise
  163. */
  164. static lwjsonr_t
  165. prv_parse_property_name(lwjson_int_str_t* pobj, lwjson_token_t* t) {
  166. lwjsonr_t res;
  167. /* Parse property string first */
  168. res = prv_parse_string(pobj, &t->token_name, &t->token_name_len);
  169. if (res != lwjsonOK) {
  170. return res;
  171. }
  172. /* Skip any spaces */
  173. res = prv_skip_blank(pobj);
  174. if (res != lwjsonOK) {
  175. return res;
  176. }
  177. /* Must continue with colon */
  178. if ((size_t)(pobj->p - pobj->start) >= pobj->len || *pobj->p++ != ':') {
  179. return lwjsonERRJSON;
  180. }
  181. /* Skip any spaces */
  182. res = prv_skip_blank(pobj);
  183. if (res != lwjsonOK) {
  184. return res;
  185. }
  186. return lwjsonOK;
  187. }
  188. /**
  189. * \brief Calculate new value for exponent 10^exponent.
  190. * \param[in] exp: Exponent.
  191. * \param[in] is_minus: Indicates whether the exponent is negative.
  192. * \return Value of 10^exponent.
  193. */
  194. static lwjson_real_t
  195. prv_power10(lwjson_int_t exp, uint8_t is_minus) {
  196. lwjson_real_t result = (lwjson_real_t)1;
  197. lwjson_real_t base = (lwjson_real_t)10;
  198. for (; exp > 0; base *= base, exp >>= 1) {
  199. if ((exp & 1) == 1) {
  200. result *= base;
  201. }
  202. }
  203. return is_minus ? ((lwjson_real_t)1 / result) : result;
  204. }
  205. /**
  206. * \brief Parse number as described in RFC4627
  207. * \param[in,out] pobj: Pointer to text that is modified on success
  208. * \param[out] tout: Pointer to output number format
  209. * \param[out] fout: Pointer to output real-type variable. Used if type is REAL.
  210. * \param[out] iout: Pointer to output int-type variable. Used if type is INT.
  211. * \return \ref lwjsonOK on success, member of \ref lwjsonr_t otherwise
  212. */
  213. static lwjsonr_t
  214. prv_parse_number(lwjson_int_str_t* pobj, lwjson_type_t* tout, lwjson_real_t* fout, lwjson_int_t* iout) {
  215. lwjsonr_t res;
  216. uint8_t is_minus;
  217. lwjson_real_t real_num = 0;
  218. lwjson_int_t int_num = 0;
  219. lwjson_type_t type = LWJSON_TYPE_NUM_INT;
  220. res = prv_skip_blank(pobj);
  221. if (res != lwjsonOK) {
  222. return res;
  223. }
  224. if ((size_t)(pobj->p - pobj->start) >= pobj->len || *pobj->p == '\0') {
  225. return lwjsonERRJSON;
  226. }
  227. is_minus = *pobj->p == '-' ? (++pobj->p, 1) : 0;
  228. if ((size_t)(pobj->p - pobj->start) >= pobj->len /* End of json input */
  229. || *pobj->p == '\0' /* Invalid string */
  230. || *pobj->p < '0' || *pobj->p > '9' /* Character outside number range */
  231. || (*pobj->p == '0' && (size_t)(pobj->p + 1 - pobj->start) < pobj->len
  232. && (pobj->p[1] >= '0' && pobj->p[1] <= '9'))) { /* Number starts with 0 but not followed by dot */
  233. return lwjsonERRJSON;
  234. }
  235. /* Parse number */
  236. for (int_num = 0; (size_t)(pobj->p - pobj->start) < pobj->len && *pobj->p >= '0' && *pobj->p <= '9'; ++pobj->p) {
  237. int_num = int_num * (lwjson_int_t)10 + (*pobj->p - '0');
  238. }
  239. real_num = (lwjson_real_t)int_num;
  240. if (pobj->p != NULL && (size_t)(pobj->p - pobj->start) < pobj->len && *pobj->p == '.') { /* Number has exponent */
  241. lwjson_real_t exp;
  242. lwjson_int_t dec_num;
  243. real_num = (lwjson_real_t)int_num;
  244. type = LWJSON_TYPE_NUM_REAL; /* Format is real */
  245. ++pobj->p; /* Ignore comma character */
  246. if ((size_t)(pobj->p - pobj->start) >= pobj->len || *pobj->p < '0'
  247. || *pobj->p > '9') { /* Must be followed by number characters */
  248. return lwjsonERRJSON;
  249. }
  250. /* Get number after decimal point */
  251. for (exp = (lwjson_real_t)1, dec_num = 0;
  252. (size_t)(pobj->p - pobj->start) < pobj->len && *pobj->p >= '0' && *pobj->p <= '9';
  253. ++pobj->p, exp *= (lwjson_real_t)10) {
  254. dec_num = dec_num * (lwjson_int_t)10 + (lwjson_int_t)(*pobj->p - '0');
  255. }
  256. /* Add decimal part to number */
  257. real_num += (lwjson_real_t)dec_num / exp;
  258. }
  259. if (pobj->p != NULL && (size_t)(pobj->p - pobj->start) < pobj->len
  260. && (*pobj->p == 'e' || *pobj->p == 'E')) { /* Engineering mode */
  261. uint8_t is_minus_exp;
  262. lwjson_int_t exp_cnt;
  263. type = LWJSON_TYPE_NUM_REAL; /* Format is real */
  264. ++pobj->p; /* Ignore enginnering sing part */
  265. if ((size_t)(pobj->p - pobj->start) >= pobj->len) {
  266. return lwjsonERRJSON;
  267. }
  268. is_minus_exp = *pobj->p == '-' ? (++pobj->p, 1) : 0; /* Check if negative */
  269. if ((size_t)(pobj->p - pobj->start) < pobj->len && *pobj->p == '+') { /* Optional '+' is possible too */
  270. ++pobj->p;
  271. }
  272. if ((size_t)(pobj->p - pobj->start) >= pobj->len || *pobj->p < '0'
  273. || *pobj->p > '9') { /* Must be followed by number characters */
  274. return lwjsonERRJSON;
  275. }
  276. /* Parse exponent number */
  277. for (exp_cnt = 0; (size_t)(pobj->p - pobj->start) < pobj->len && *pobj->p >= '0' && *pobj->p <= '9';
  278. ++pobj->p) {
  279. exp_cnt = exp_cnt * (lwjson_int_t)10 + (lwjson_int_t)(*pobj->p - '0');
  280. }
  281. /* Calculate new value for exponent 10^exponent */
  282. real_num *= prv_power10(exp_cnt, is_minus_exp);
  283. }
  284. /* Write output values */
  285. if (tout != NULL) {
  286. *tout = type;
  287. }
  288. if (type == LWJSON_TYPE_NUM_INT) {
  289. *iout = is_minus ? -int_num : int_num;
  290. } else {
  291. *fout = is_minus ? -real_num : real_num;
  292. }
  293. return lwjsonOK;
  294. }
  295. /**
  296. * \brief Create path segment from input path for search operation
  297. * \param[in,out] ppath: Pointer to pointer to input path. Pointer is modified
  298. * \param[out] opath: Pointer to pointer to write path segment
  299. * \param[out] olen: Pointer to variable to write length of segment
  300. * \param[out] is_last: Pointer to write if this is last segment
  301. * \return `1` on success, `0` otherwise
  302. */
  303. static uint8_t
  304. prv_create_path_segment(const char** ppath, const char** opath, size_t* olen, uint8_t* is_last) {
  305. const char* segment = *ppath;
  306. *is_last = 0;
  307. *opath = NULL;
  308. *olen = 0;
  309. /* Check input path */
  310. if (segment == NULL || *segment == '\0') {
  311. *is_last = 1;
  312. return 0;
  313. }
  314. /*
  315. * Path must be one of:
  316. * - literal text
  317. * - "#" followed by dot "."
  318. */
  319. if (*segment == '#') {
  320. *opath = segment;
  321. for (*olen = 0;; ++segment, ++(*olen)) {
  322. if (*segment == '.') {
  323. ++segment;
  324. break;
  325. } else if (*segment == '\0') {
  326. if (*olen == 1) {
  327. return 0;
  328. } else {
  329. break;
  330. }
  331. }
  332. }
  333. *ppath = segment;
  334. } else {
  335. *opath = segment;
  336. for (*olen = 0; *segment != '\0' && *segment != '.'; ++(*olen), ++segment) {}
  337. *ppath = segment + 1;
  338. }
  339. if (*segment == '\0') {
  340. *is_last = 1;
  341. }
  342. return 1;
  343. }
  344. /**
  345. * \brief Input recursive function for find operation
  346. * \param[in] parent: Parent token of type \ref LWJSON_TYPE_ARRAY or LWJSON_TYPE_OBJECT
  347. * \param[in] path: Path to search for starting this token further
  348. * \return Found token on success, `NULL` otherwise
  349. */
  350. static const lwjson_token_t*
  351. prv_find(const lwjson_token_t* parent, const char* path) {
  352. const char* segment;
  353. size_t segment_len;
  354. uint8_t is_last, res;
  355. /* Get path segments */
  356. res = prv_create_path_segment(&path, &segment, &segment_len, &is_last);
  357. if (res != 0) {
  358. /* Check if detected an array request */
  359. if (*segment == '#') {
  360. /* Parent must be array */
  361. if (parent->type != LWJSON_TYPE_ARRAY) {
  362. return NULL;
  363. }
  364. /* Check if index requested */
  365. if (segment_len > 1) {
  366. const lwjson_token_t* tkn;
  367. size_t index = 0;
  368. /* Parse number */
  369. for (size_t i = 1; i < segment_len; ++i) {
  370. if (segment[i] < '0' || segment[i] > '9') {
  371. return NULL;
  372. } else {
  373. index = index * 10 + (segment[i] - '0');
  374. }
  375. }
  376. /* Start from beginning */
  377. for (tkn = parent->u.first_child; tkn != NULL && index > 0; tkn = tkn->next, --index) {}
  378. if (tkn != NULL) {
  379. if (is_last) {
  380. return tkn;
  381. } else {
  382. return prv_find(tkn, path);
  383. }
  384. }
  385. return NULL;
  386. }
  387. /* Scan all indexes and get first match */
  388. for (const lwjson_token_t* tkn = parent->u.first_child; tkn != NULL; tkn = tkn->next) {
  389. const lwjson_token_t* tmp = prv_find(tkn, path);
  390. if (tmp != NULL) {
  391. return tmp;
  392. }
  393. }
  394. } else {
  395. if (parent->type != LWJSON_TYPE_OBJECT) {
  396. return NULL;
  397. }
  398. for (const lwjson_token_t* tkn = parent->u.first_child; tkn != NULL; tkn = tkn->next) {
  399. if (tkn->token_name_len == segment_len && !strncmp(tkn->token_name, segment, segment_len)) {
  400. const lwjson_token_t* tmp;
  401. if (is_last) {
  402. return tkn;
  403. }
  404. tmp = prv_find(tkn, path);
  405. if (tmp != NULL) {
  406. return tmp;
  407. }
  408. }
  409. }
  410. }
  411. }
  412. return NULL;
  413. }
  414. /**
  415. * \brief Check for character after opening bracket of array or object
  416. * \param[in,out] pobj: JSON string
  417. * \param[in] t: Token to check for type
  418. * \return \ref lwjsonOK on success, member of \ref lwjsonr_t otherwise
  419. */
  420. static inline lwjsonr_t
  421. prv_check_valid_char_after_open_bracket(lwjson_int_str_t* pobj, lwjson_token_t* t) {
  422. lwjsonr_t res;
  423. /* Check next character after object open */
  424. res = prv_skip_blank(pobj);
  425. if (res != lwjsonOK) {
  426. return res;
  427. }
  428. if ((size_t)(pobj->p - pobj->start) >= pobj->len || *pobj->p == '\0'
  429. || (t->type == LWJSON_TYPE_OBJECT && (*pobj->p != '"' && *pobj->p != '}'))
  430. || (t->type == LWJSON_TYPE_ARRAY
  431. && (*pobj->p != '"' && *pobj->p != ']' && *pobj->p != '[' && *pobj->p != '{' && *pobj->p != '-'
  432. && (*pobj->p < '0' || *pobj->p > '9') && *pobj->p != 't' && *pobj->p != 'n' && *pobj->p != 'f'))) {
  433. res = lwjsonERRJSON;
  434. }
  435. return res;
  436. }
  437. /**
  438. * \brief Setup LwJSON instance for parsing JSON strings
  439. * \param[in,out] lwobj: LwJSON instance
  440. * \param[in] tokens: Pointer to array of tokens used for parsing
  441. * \param[in] tokens_len: Number of tokens
  442. * \return \ref lwjsonOK on success, member of \ref lwjsonr_t otherwise
  443. */
  444. lwjsonr_t
  445. lwjson_init(lwjson_t* lwobj, lwjson_token_t* tokens, size_t tokens_len) {
  446. LWJSON_MEMSET(lwobj, 0x00, sizeof(*lwobj));
  447. LWJSON_MEMSET(tokens, 0x00, sizeof(*tokens) * tokens_len);
  448. lwobj->tokens = tokens;
  449. lwobj->tokens_len = tokens_len;
  450. lwobj->first_token.type = LWJSON_TYPE_OBJECT;
  451. return lwjsonOK;
  452. }
  453. /**
  454. * \brief Parse JSON data with length parameter
  455. * JSON format must be complete and must comply with RFC4627
  456. * \param[in,out] lwobj: LwJSON instance
  457. * \param[in] json_data: JSON string to parse
  458. * \param[in] jsonČlen: JSON data length
  459. * \return \ref lwjsonOK on success, member of \ref lwjsonr_t otherwise
  460. */
  461. lwjsonr_t
  462. lwjson_parse_ex(lwjson_t* lwobj, const void* json_data, size_t json_len) {
  463. lwjsonr_t res = lwjsonOK;
  464. lwjson_token_t *t, *to;
  465. lwjson_int_str_t pobj = {.start = json_data, .len = json_len, .p = json_data};
  466. /* Check input parameters */
  467. if (lwobj == NULL || json_data == NULL || json_len == 0) {
  468. res = lwjsonERRPAR;
  469. goto ret;
  470. }
  471. /* set first token */
  472. to = &lwobj->first_token;
  473. /* values from very beginning */
  474. lwobj->flags.parsed = 0;
  475. lwobj->next_free_token_pos = 0;
  476. LWJSON_MEMSET(to, 0x00, sizeof(*to));
  477. /* First parse */
  478. res = prv_skip_blank(&pobj);
  479. if (res != lwjsonOK) {
  480. goto ret;
  481. }
  482. if ((size_t)(pobj.p - pobj.start) >= pobj.len) {
  483. res = lwjsonERRJSON;
  484. goto ret;
  485. }
  486. if (*pobj.p == '{') {
  487. to->type = LWJSON_TYPE_OBJECT;
  488. } else if (*pobj.p == '[') {
  489. to->type = LWJSON_TYPE_ARRAY;
  490. } else {
  491. res = lwjsonERRJSON;
  492. goto ret;
  493. }
  494. ++pobj.p;
  495. res = prv_check_valid_char_after_open_bracket(&pobj, to);
  496. if (res != lwjsonOK) {
  497. goto ret;
  498. }
  499. /* Process all characters as indicated by input user */
  500. while (pobj.p != NULL && (size_t)(pobj.p - pobj.start) < pobj.len && *pobj.p != '\0') {
  501. /* Filter out blanks */
  502. res = prv_skip_blank(&pobj);
  503. if (res != lwjsonOK) {
  504. goto ret;
  505. }
  506. if (*pobj.p == ',') {
  507. ++pobj.p;
  508. continue;
  509. }
  510. /* Check if end of object or array*/
  511. if (*pobj.p == (to->type == LWJSON_TYPE_OBJECT ? '}' : ']')) {
  512. lwjson_token_t* parent = to->next;
  513. to->next = NULL;
  514. ++pobj.p;
  515. /* End of string if to == NULL (no parent), check if properly terminated */
  516. to = parent;
  517. if (to == NULL) {
  518. prv_skip_blank(&pobj);
  519. res = (pobj.p == NULL || (size_t)(pobj.p - pobj.start) >= pobj.len || *pobj.p == '\0') ? lwjsonOK
  520. : lwjsonERR;
  521. goto ret;
  522. }
  523. continue;
  524. }
  525. /* Allocate new token */
  526. t = prv_alloc_token(lwobj);
  527. if (t == NULL) {
  528. res = lwjsonERRMEM;
  529. goto ret;
  530. }
  531. /* If object type is not array, first thing is property that starts with quotes */
  532. if (to->type != LWJSON_TYPE_ARRAY) {
  533. if (*pobj.p != '"') {
  534. res = lwjsonERRJSON;
  535. goto ret;
  536. }
  537. res = prv_parse_property_name(&pobj, t);
  538. if (res != lwjsonOK) {
  539. goto ret;
  540. }
  541. }
  542. /* Add element to linked list */
  543. if (to->u.first_child == NULL) {
  544. to->u.first_child = t;
  545. } else {
  546. lwjson_token_t* c;
  547. for (c = to->u.first_child; c->next != NULL; c = c->next) {}
  548. c->next = t;
  549. }
  550. /* Check next character to process */
  551. switch (*pobj.p) {
  552. case '{':
  553. case '[':
  554. t->type = *pobj.p == '{' ? LWJSON_TYPE_OBJECT : LWJSON_TYPE_ARRAY;
  555. ++pobj.p;
  556. res = prv_check_valid_char_after_open_bracket(&pobj, t);
  557. if (res != lwjsonOK) {
  558. goto ret;
  559. }
  560. t->next = to; /* Temporary saved as parent object */
  561. to = t;
  562. break;
  563. case '"':
  564. res = prv_parse_string(&pobj, &t->u.str.token_value, &t->u.str.token_value_len);
  565. if (res == lwjsonOK) {
  566. t->type = LWJSON_TYPE_STRING;
  567. } else {
  568. goto ret;
  569. }
  570. break;
  571. case 't':
  572. /* RFC4627 is lower-case only */
  573. if ((size_t)(pobj.p + 3 - pobj.start) < pobj.len && strncmp(pobj.p, "true", 4) == 0) {
  574. t->type = LWJSON_TYPE_TRUE;
  575. pobj.p += 4;
  576. } else {
  577. res = lwjsonERRJSON;
  578. goto ret;
  579. }
  580. break;
  581. case 'f':
  582. /* RFC4627 is lower-case only */
  583. if ((size_t)(pobj.p + 4 - pobj.start) < pobj.len && strncmp(pobj.p, "false", 5) == 0) {
  584. t->type = LWJSON_TYPE_FALSE;
  585. pobj.p += 5;
  586. } else {
  587. res = lwjsonERRJSON;
  588. goto ret;
  589. }
  590. break;
  591. case 'n':
  592. /* RFC4627 is lower-case only */
  593. if ((size_t)(pobj.p + 3 - pobj.start) < pobj.len && strncmp(pobj.p, "null", 4) == 0) {
  594. t->type = LWJSON_TYPE_NULL;
  595. pobj.p += 4;
  596. } else {
  597. res = lwjsonERRJSON;
  598. goto ret;
  599. }
  600. break;
  601. default:
  602. if (*pobj.p == '-' || (*pobj.p >= '0' && *pobj.p <= '9')) {
  603. if (prv_parse_number(&pobj, &t->type, &t->u.num_real, &t->u.num_int) != lwjsonOK) {
  604. res = lwjsonERRJSON;
  605. goto ret;
  606. }
  607. } else {
  608. res = lwjsonERRJSON;
  609. goto ret;
  610. }
  611. break;
  612. }
  613. /* Below code is used to check characters after valid tokens */
  614. if (t->type == LWJSON_TYPE_ARRAY || t->type == LWJSON_TYPE_OBJECT) {
  615. continue;
  616. }
  617. /*
  618. * Check what are values after the token value
  619. *
  620. * As per RFC4627, every token value may have one or more
  621. * blank characters, followed by one of below options:
  622. * - Comma separator for next token
  623. * - End of array indication
  624. * - End of object indication
  625. */
  626. res = prv_skip_blank(&pobj);
  627. if (res != lwjsonOK) {
  628. goto ret;
  629. }
  630. /* Check if valid string is availabe after */
  631. if (pobj.p == NULL || (size_t)(pobj.p - pobj.start) >= pobj.len || *pobj.p == '\0'
  632. || (*pobj.p != ',' && *pobj.p != ']' && *pobj.p != '}')) {
  633. res = lwjsonERRJSON;
  634. goto ret;
  635. } else if (*pobj.p == ',') { /* Check to advance to next token immediately */
  636. ++pobj.p;
  637. }
  638. }
  639. if (to != &lwobj->first_token || (to != NULL && to->next != NULL)) {
  640. res = lwjsonERRJSON;
  641. to = NULL;
  642. }
  643. if (to != NULL) {
  644. if (to->type != LWJSON_TYPE_ARRAY && to->type != LWJSON_TYPE_OBJECT) {
  645. res = lwjsonERRJSON;
  646. }
  647. to->token_name = NULL;
  648. to->token_name_len = 0;
  649. }
  650. ret:
  651. if (res == lwjsonOK) {
  652. lwobj->flags.parsed = 1;
  653. }
  654. return res;
  655. }
  656. /**
  657. * \brief Parse input JSON format
  658. * JSON format must be complete and must comply with RFC4627
  659. * \param[in,out] lwobj: LwJSON instance
  660. * \param[in] json_str: JSON string to parse
  661. * \return \ref lwjsonOK on success, member of \ref lwjsonr_t otherwise
  662. */
  663. lwjsonr_t
  664. lwjson_parse(lwjson_t* lwobj, const char* json_str) {
  665. return lwjson_parse_ex(lwobj, json_str, strlen(json_str));
  666. }
  667. /**
  668. * \brief Free token instances (specially used in case of dynamic memory allocation)
  669. * \param[in,out] lwobj: LwJSON instance
  670. * \return \ref lwjsonOK on success, member of \ref lwjsonr_t otherwise
  671. */
  672. lwjsonr_t
  673. lwjson_free(lwjson_t* lwobj) {
  674. LWJSON_MEMSET(lwobj->tokens, 0x00, sizeof(*lwobj->tokens) * lwobj->tokens_len);
  675. lwobj->flags.parsed = 0;
  676. return lwjsonOK;
  677. }
  678. /**
  679. * \brief Find first match in the given path for JSON entry
  680. * JSON must be valid and parsed with \ref lwjson_parse function
  681. * \param[in] lwobj: JSON instance with parsed JSON string
  682. * \param[in] path: Path with dot-separated entries to search for the JSON key to return
  683. * \return Pointer to found token on success, `NULL` if token cannot be found
  684. */
  685. const lwjson_token_t*
  686. lwjson_find(lwjson_t* lwobj, const char* path) {
  687. if (lwobj == NULL || !lwobj->flags.parsed || path == NULL) {
  688. return NULL;
  689. }
  690. return prv_find(lwjson_get_first_token(lwobj), path);
  691. }
  692. /**
  693. * \brief Find first match in the given path for JSON path
  694. * JSON must be valid and parsed with \ref lwjson_parse function
  695. *
  696. * \param[in] lwobj: JSON instance with parsed JSON string
  697. * \param[in] token: Root token to start search at.
  698. * Token must be type \ref LWJSON_TYPE_OBJECT or \ref LWJSON_TYPE_ARRAY.
  699. * Set to `NULL` to use root token of LwJSON object
  700. * \param[in] path: path with dot-separated entries to search for JSON key
  701. * \return Pointer to found token on success, `NULL` if token cannot be found
  702. */
  703. const lwjson_token_t*
  704. lwjson_find_ex(lwjson_t* lwobj, const lwjson_token_t* token, const char* path) {
  705. if (lwobj == NULL || !lwobj->flags.parsed || path == NULL) {
  706. return NULL;
  707. }
  708. if (token == NULL) {
  709. token = lwjson_get_first_token(lwobj);
  710. }
  711. if (token == NULL || (token->type != LWJSON_TYPE_ARRAY && token->type != LWJSON_TYPE_OBJECT)) {
  712. return NULL;
  713. }
  714. return prv_find(token, path);
  715. }