lwjson_stream.c 22 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504
  1. /**
  2. * \file lwjson_stream.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. #if defined(LWJSON_DEV)
  36. #include <stdio.h>
  37. #define DEBUG_STRING_PREFIX_SPACES \
  38. " "
  39. #define LWJSON_DEBUG(jsp, ...) \
  40. do { \
  41. if ((jsp) != NULL) { \
  42. printf("%.*s", (int)(4 * (jsp)->stack_pos), DEBUG_STRING_PREFIX_SPACES); \
  43. } \
  44. printf(__VA_ARGS__); \
  45. } while (0)
  46. /* Strings for debug */
  47. const char* const lwjson_type_strings[] = {
  48. [LWJSON_STREAM_TYPE_NONE] = "none",
  49. [LWJSON_STREAM_TYPE_OBJECT] = "object",
  50. [LWJSON_STREAM_TYPE_OBJECT_END] = "object_end",
  51. [LWJSON_STREAM_TYPE_ARRAY] = "array",
  52. [LWJSON_STREAM_TYPE_ARRAY_END] = "array_end",
  53. [LWJSON_STREAM_TYPE_KEY] = "key",
  54. [LWJSON_STREAM_TYPE_STRING] = "string",
  55. [LWJSON_STREAM_TYPE_TRUE] = "true",
  56. [LWJSON_STREAM_TYPE_FALSE] = "false",
  57. [LWJSON_STREAM_TYPE_NULL] = "null",
  58. [LWJSON_STREAM_TYPE_NUMBER] = "number",
  59. };
  60. #else
  61. #define LWJSON_DEBUG(jsp, ...)
  62. #endif /* defined(LWJSON_DEV) */
  63. /**
  64. * \brief Sends an event to user for further processing
  65. *
  66. */
  67. #define SEND_EVT(jsp, type) \
  68. if ((jsp) != NULL && (jsp)->evt_fn != NULL) { \
  69. (jsp)->evt_fn((jsp), (type)); \
  70. }
  71. /**
  72. * \brief Check if character is a space character (with extended chars)
  73. * \param[in] c: Character to check
  74. * \return `1` if considered extended space, `0` otherwise
  75. */
  76. #define prv_is_space_char_ext(c) ((c) == ' ' || (c) == '\t' || (c) == '\r' || (c) == '\n' || (c) == '\f')
  77. /**
  78. * \brief Push "parent" state to the artificial stack
  79. * \param jsp: JSON stream parser instance
  80. * \param type: Stream type to be pushed on stack
  81. * \return `1` on success, `0` otherwise
  82. */
  83. static uint8_t
  84. prv_stack_push(lwjson_stream_parser_t* jsp, lwjson_stream_type_t type) {
  85. if (jsp->stack_pos < LWJSON_ARRAYSIZE(jsp->stack)) {
  86. jsp->stack[jsp->stack_pos].type = type;
  87. jsp->stack[jsp->stack_pos].meta.index = 0;
  88. LWJSON_DEBUG(jsp, "Pushed to stack: %s\r\n", lwjson_type_strings[type]);
  89. jsp->stack_pos++;
  90. return 1;
  91. }
  92. return 0;
  93. }
  94. /**
  95. * \brief Pop value from stack (remove it) and return its value
  96. * \param jsp: JSON stream parser instance
  97. * \return Member of \ref lwjson_stream_type_t enumeration
  98. */
  99. static lwjson_stream_type_t
  100. prv_stack_pop(lwjson_stream_parser_t* jsp) {
  101. if (jsp->stack_pos > 0) {
  102. lwjson_stream_type_t type = jsp->stack[--jsp->stack_pos].type;
  103. jsp->stack[jsp->stack_pos].type = LWJSON_STREAM_TYPE_NONE;
  104. LWJSON_DEBUG(jsp, "Popped from stack: %s\r\n", lwjson_type_strings[type]);
  105. /* Take care of array to indicate number of entries */
  106. if (jsp->stack_pos > 0 && jsp->stack[jsp->stack_pos - 1].type == LWJSON_STREAM_TYPE_ARRAY) {
  107. jsp->stack[jsp->stack_pos - 1].meta.index++;
  108. }
  109. return type;
  110. }
  111. return LWJSON_STREAM_TYPE_NONE;
  112. }
  113. /**
  114. * \brief Get top type value currently on the stack
  115. * \param jsp: JSON stream parser instance
  116. * \return Member of \ref lwjson_stream_type_t enumeration
  117. */
  118. static lwjson_stream_type_t
  119. prv_stack_get_top(lwjson_stream_parser_t* jsp) {
  120. if (jsp->stack_pos > 0) {
  121. return jsp->stack[jsp->stack_pos - 1].type;
  122. }
  123. return LWJSON_STREAM_TYPE_NONE;
  124. }
  125. /**
  126. * \brief Initialize LwJSON stream object before parsing takes place
  127. * \param[in,out] jsp: Stream JSON structure
  128. * \return \ref lwjsonOK on success, member of \ref lwjsonr_t otherwise
  129. */
  130. lwjsonr_t
  131. lwjson_stream_init(lwjson_stream_parser_t* jsp, lwjson_stream_parser_callback_fn evt_fn) {
  132. LWJSON_MEMSET(jsp, 0x00, sizeof(*jsp));
  133. jsp->parse_state = LWJSON_STREAM_STATE_WAITINGFIRSTCHAR;
  134. jsp->evt_fn = evt_fn;
  135. jsp->user_data = NULL;
  136. return lwjsonOK;
  137. }
  138. /**
  139. * \brief Reset LwJSON stream structure
  140. *
  141. * \param[in,out] jsp: LwJSON stream parser
  142. * \return \ref lwjsonOK on success, member of \ref lwjsonr_t otherwise
  143. */
  144. lwjsonr_t
  145. lwjson_stream_reset(lwjson_stream_parser_t* jsp) {
  146. jsp->parse_state = LWJSON_STREAM_STATE_WAITINGFIRSTCHAR;
  147. jsp->stack_pos = 0;
  148. LWJSON_MEMSET(jsp->stack, 0x00, sizeof(jsp->stack));
  149. LWJSON_MEMSET(&jsp->data, 0x00, sizeof(jsp->data));
  150. jsp->prev_c = '\0';
  151. return lwjsonOK;
  152. }
  153. /**
  154. * \brief Set user_data in stream parser
  155. *
  156. * \param[in,out] jsp: LwJSON stream parser
  157. * \param[in] user_data: user data
  158. * \return \ref lwjsonOK on success, member of \ref lwjsonr_t otherwise
  159. */
  160. lwjsonr_t
  161. lwjson_stream_set_user_data(lwjson_stream_parser_t* jsp, void* user_data) {
  162. jsp->user_data = user_data;
  163. return lwjsonOK;
  164. }
  165. /**
  166. * \brief Get user_data in stream parser
  167. *
  168. * \param[in] jsp: LwJSON stream parser
  169. * \return pointer to user data
  170. */
  171. void*
  172. lwjson_stream_get_user_data(lwjson_stream_parser_t* jsp) {
  173. return jsp->user_data;
  174. }
  175. /**
  176. * \brief Parse JSON string in streaming mode
  177. * \param[in,out] jsp: Stream JSON structure
  178. * \param[in] chr: Character to parse
  179. * \return \ref lwjsonSTREAMWAITFIRSTCHAR when stream did not start parsing since no valid start character has been received
  180. * \return \ref lwjsonSTREAMINPROG if parsing is in progress and no hard error detected
  181. * \return \ref lwjsonSTREAMDONE when valid JSON was detected and stack level reached back `0` level
  182. * \return \ref One of enumeration otherwise
  183. */
  184. lwjsonr_t
  185. lwjson_stream_parse(lwjson_stream_parser_t* jsp, char chr) {
  186. /* Get first character first */
  187. if (jsp->parse_state == LWJSON_STREAM_STATE_WAITINGFIRSTCHAR && chr != '{' && chr != '[') {
  188. return prv_is_space_char_ext(chr) ? lwjsonSTREAMWAITFIRSTCHAR : lwjsonERRJSON;
  189. }
  190. start_over:
  191. /* Determine what to do from parsing state */
  192. switch (jsp->parse_state) {
  193. /*
  194. * Waiting for very first valid characters,
  195. * that is used to indicate start of JSON stream
  196. */
  197. case LWJSON_STREAM_STATE_WAITINGFIRSTCHAR:
  198. case LWJSON_STREAM_STATE_EXPECTING_COMMA_OR_END:
  199. case LWJSON_STREAM_STATE_PARSING: {
  200. /* Ignore whitespace chars */
  201. if (prv_is_space_char_ext(chr)) {
  202. break;
  203. /* Determine value separator */
  204. } else if (chr == ',') {
  205. if (jsp->parse_state == LWJSON_STREAM_STATE_EXPECTING_COMMA_OR_END) {
  206. jsp->parse_state = LWJSON_STREAM_STATE_PARSING;
  207. } else {
  208. LWJSON_DEBUG(jsp, "ERROR - ',' can only follow value\r\n");
  209. return lwjsonERRJSON;
  210. }
  211. /* Determine end of object or an array */
  212. } else if (chr == '}' || chr == ']') {
  213. lwjson_stream_type_t type = prv_stack_get_top(jsp);
  214. /*
  215. * If it is a key last entry on closing area,
  216. * it is an error - an example: {"key":}
  217. */
  218. if (type == LWJSON_STREAM_TYPE_KEY) {
  219. LWJSON_DEBUG(jsp, "ERROR - key should not be followed by ] without value for a key\r\n");
  220. return lwjsonERRJSON;
  221. }
  222. /*
  223. * Check if closing character matches stack value
  224. * Avoid cases like: {"key":"value"] or ["v1", "v2", "v3"}
  225. */
  226. if ((chr == '}' && type != LWJSON_STREAM_TYPE_OBJECT)
  227. || (chr == ']' && type != LWJSON_STREAM_TYPE_ARRAY)) {
  228. LWJSON_DEBUG(jsp, "ERROR - closing character '%c' does not match stack element \"%s\"\r\n", chr,
  229. lwjson_type_strings[type]);
  230. return lwjsonERRJSON;
  231. }
  232. /* Now remove the array or object from stack */
  233. if (prv_stack_pop(jsp) == LWJSON_STREAM_TYPE_NONE) {
  234. return lwjsonERRJSON;
  235. }
  236. SEND_EVT(jsp, chr == '}' ? LWJSON_STREAM_TYPE_OBJECT_END : LWJSON_STREAM_TYPE_ARRAY_END);
  237. /*
  238. * Check if above is a key type
  239. * and remove it too as we finished with processing of potential case.
  240. *
  241. * {"key":{"abc":1}} - remove "key" part
  242. */
  243. if (prv_stack_get_top(jsp) == LWJSON_STREAM_TYPE_KEY) {
  244. prv_stack_pop(jsp);
  245. }
  246. /* If that is the end of JSON */
  247. if (jsp->stack_pos == 0) {
  248. lwjson_stream_reset(jsp);
  249. return lwjsonSTREAMDONE;
  250. }
  251. jsp->parse_state = LWJSON_STREAM_STATE_EXPECTING_COMMA_OR_END;
  252. /* If comma or end was expected, then it is already error here */
  253. } else if (jsp->parse_state == LWJSON_STREAM_STATE_EXPECTING_COMMA_OR_END) {
  254. LWJSON_DEBUG(jsp, "ERROR - ',', '}' or ']' was expected\r\n");
  255. return lwjsonERRJSON;
  256. /* Determine start of string - can be key or regular string (in array or after key) */
  257. } else if (chr == '"') {
  258. #if defined(LWJSON_DEV)
  259. lwjson_stream_type_t type = prv_stack_get_top(jsp);
  260. if (type == LWJSON_STREAM_TYPE_OBJECT) {
  261. LWJSON_DEBUG(jsp, "Start of string parsing - expected key name in an object\r\n");
  262. } else if (type == LWJSON_STREAM_TYPE_KEY) {
  263. LWJSON_DEBUG(jsp,
  264. "Start of string parsing - string value associated to previous key in an object\r\n");
  265. } else if (type == LWJSON_STREAM_TYPE_ARRAY) {
  266. LWJSON_DEBUG(jsp, "Start of string parsing - string entry in an array\r\n");
  267. }
  268. #endif /* defined(LWJSON_DEV) */
  269. jsp->parse_state = LWJSON_STREAM_STATE_PARSING_STRING;
  270. LWJSON_MEMSET(&jsp->data.str, 0x00, sizeof(jsp->data.str));
  271. } else if (prv_stack_get_top(jsp) == LWJSON_STREAM_TYPE_OBJECT) {
  272. /* Key must be before value */
  273. LWJSON_DEBUG(jsp, "ERROR - key must be before value\r\n");
  274. return lwjsonERRJSON;
  275. /* Determine start of object or an array */
  276. } else if (chr == '{' || chr == '[') {
  277. /* Reset stack pointer if this character came from waiting for first character */
  278. if (jsp->parse_state == LWJSON_STREAM_STATE_WAITINGFIRSTCHAR) {
  279. jsp->stack_pos = 0;
  280. }
  281. SEND_EVT(jsp, chr == '{' ? LWJSON_STREAM_TYPE_OBJECT : LWJSON_STREAM_TYPE_ARRAY);
  282. if (!prv_stack_push(jsp, chr == '{' ? LWJSON_STREAM_TYPE_OBJECT : LWJSON_STREAM_TYPE_ARRAY)) {
  283. LWJSON_DEBUG(jsp, "Cannot push object/array to stack\r\n");
  284. return lwjsonERRMEM;
  285. }
  286. jsp->parse_state = LWJSON_STREAM_STATE_PARSING;
  287. /* Check if this is start of number or "true", "false" or "null" */
  288. } else if (chr == '-' || (chr >= '0' && chr <= '9') || chr == 't' || chr == 'f' || chr == 'n') {
  289. if (prv_stack_get_top(jsp) == LWJSON_STREAM_TYPE_OBJECT) {
  290. LWJSON_DEBUG(jsp, "ERROR - key must be before value (primitive)\r\n");
  291. /* Key must be before value */
  292. return lwjsonERRJSON;
  293. }
  294. LWJSON_DEBUG(jsp, "Start of primitive parsing parsing - %s, First char: %c\r\n",
  295. (chr == '-' || (chr >= '0' && chr <= '9')) ? "number" : "true,false,null", chr);
  296. jsp->parse_state = LWJSON_STREAM_STATE_PARSING_PRIMITIVE;
  297. LWJSON_MEMSET(&jsp->data.prim, 0x00, sizeof(jsp->data.prim));
  298. jsp->data.prim.buff[jsp->data.prim.buff_pos++] = chr;
  299. /* Wrong char */
  300. } else {
  301. LWJSON_DEBUG(jsp, "ERROR - wrong char %c\r\n", chr);
  302. return lwjsonERRJSON;
  303. }
  304. break;
  305. }
  306. /* Check for end of key character i.e. name separator ':' */
  307. case LWJSON_STREAM_STATE_EXPECTING_COLON:
  308. /* Ignore whitespace chars */
  309. if (prv_is_space_char_ext(chr)) {
  310. break;
  311. } else if (chr == ':') {
  312. jsp->parse_state = LWJSON_STREAM_STATE_PARSING;
  313. } else {
  314. LWJSON_DEBUG(jsp, "ERROR - expecting ':'\r\n");
  315. return lwjsonERRJSON;
  316. }
  317. break;
  318. /*
  319. * Parse any type of string in a sequence
  320. *
  321. * It is used for key or string in an object or an array
  322. */
  323. case LWJSON_STREAM_STATE_PARSING_STRING: {
  324. lwjson_stream_type_t type = prv_stack_get_top(jsp);
  325. /*
  326. * Quote character may trigger end of string,
  327. * or if backslasled before - it is part of string
  328. *
  329. * TODO: Handle backslash
  330. */
  331. if (chr == '"' && jsp->prev_c != '\\') {
  332. #if defined(LWJSON_DEV)
  333. if (type == LWJSON_STREAM_TYPE_OBJECT) {
  334. LWJSON_DEBUG(jsp, "End of string parsing - object key name: \"%s\"\r\n", jsp->data.str.buff);
  335. } else if (type == LWJSON_STREAM_TYPE_KEY) {
  336. LWJSON_DEBUG(
  337. jsp, "End of string parsing - string value associated to previous key in an object: \"%s\"\r\n",
  338. jsp->data.str.buff);
  339. } else if (type == LWJSON_STREAM_TYPE_ARRAY) {
  340. LWJSON_DEBUG(jsp, "End of string parsing - an array string entry: \"%s\"\r\n", jsp->data.str.buff);
  341. }
  342. #endif /* defined(LWJSON_DEV) */
  343. /* Set is_last to 1 as this is the last part of this string token */
  344. jsp->data.str.is_last = 1;
  345. /*
  346. * When top of stack is object - string is treated as a key
  347. * When top of stack is a key - string is a value for a key - notify user and pop the value for key
  348. * When top of stack is an array - string is one type - notify user and don't do anything
  349. */
  350. jsp->parse_state = LWJSON_STREAM_STATE_EXPECTING_COMMA_OR_END;
  351. if (type == LWJSON_STREAM_TYPE_OBJECT) {
  352. SEND_EVT(jsp, LWJSON_STREAM_TYPE_KEY);
  353. if (prv_stack_push(jsp, LWJSON_STREAM_TYPE_KEY)) {
  354. size_t len = jsp->data.str.buff_pos;
  355. if (len > (sizeof(jsp->stack[0].meta.name) - 1)) {
  356. len = sizeof(jsp->stack[0].meta.name) - 1;
  357. }
  358. LWJSON_MEMCPY(jsp->stack[jsp->stack_pos - 1].meta.name, jsp->data.str.buff, len);
  359. jsp->stack[jsp->stack_pos - 1].meta.name[len] = '\0';
  360. } else {
  361. LWJSON_DEBUG(jsp, "Cannot push key to stack\r\n");
  362. return lwjsonERRMEM;
  363. }
  364. jsp->parse_state = LWJSON_STREAM_STATE_EXPECTING_COLON;
  365. } else if (type == LWJSON_STREAM_TYPE_KEY) {
  366. SEND_EVT(jsp, LWJSON_STREAM_TYPE_STRING);
  367. prv_stack_pop(jsp);
  368. /* Next character to wait for is either space or comma or end of object */
  369. } else if (type == LWJSON_STREAM_TYPE_ARRAY) {
  370. SEND_EVT(jsp, LWJSON_STREAM_TYPE_STRING);
  371. jsp->stack[jsp->stack_pos - 1].meta.index++;
  372. }
  373. } else {
  374. /* TODO: Check other backslash elements */
  375. jsp->data.str.buff[jsp->data.str.buff_pos++] = chr;
  376. jsp->data.str.buff_total_pos++;
  377. /* Handle buffer "overflow" */
  378. if (jsp->data.str.buff_pos >= (LWJSON_CFG_STREAM_STRING_MAX_LEN - 1)) {
  379. jsp->data.str.buff[jsp->data.str.buff_pos] = '\0';
  380. /*
  381. * - For array or key types - following one is always string
  382. * - For object type - character is key
  383. */
  384. SEND_EVT(jsp, (type == LWJSON_STREAM_TYPE_KEY || type == LWJSON_STREAM_TYPE_ARRAY)
  385. ? LWJSON_STREAM_TYPE_STRING
  386. : LWJSON_STREAM_TYPE_KEY);
  387. jsp->data.str.buff_pos = 0;
  388. }
  389. }
  390. break;
  391. }
  392. /*
  393. * Parse any type of primitive that is not a string.
  394. *
  395. * true, false, null or any number primitive
  396. */
  397. case LWJSON_STREAM_STATE_PARSING_PRIMITIVE: {
  398. /* Any character except space, comma, or end of array/object are valid */
  399. if (!prv_is_space_char_ext(chr) && chr != ',' && chr != ']' && chr != '}') {
  400. if (jsp->data.prim.buff_pos < sizeof(jsp->data.prim.buff) - 1) {
  401. jsp->data.prim.buff[jsp->data.prim.buff_pos++] = chr;
  402. } else {
  403. LWJSON_DEBUG(jsp, "Buffer overflow for primitive\r\n");
  404. return lwjsonERRJSON;
  405. }
  406. } else {
  407. lwjson_stream_type_t type = prv_stack_get_top(jsp);
  408. #if defined(LWJSON_DEV)
  409. if (type == LWJSON_STREAM_TYPE_KEY) {
  410. LWJSON_DEBUG(
  411. jsp,
  412. "End of primitive parsing - string value associated to previous key in an object: \"%s\"\r\n",
  413. jsp->data.prim.buff);
  414. } else if (type == LWJSON_STREAM_TYPE_ARRAY) {
  415. LWJSON_DEBUG(jsp, "End of primitive parsing - an array string entry: \"%s\"\r\n",
  416. jsp->data.prim.buff);
  417. }
  418. #endif /* defined(LWJSON_DEV) */
  419. /*
  420. * This is the end of primitive parsing
  421. *
  422. * It is assumed that buffer for primitive can handle at least
  423. * true, false, null or all number characters (that being real or int number)
  424. */
  425. if (jsp->data.prim.buff_pos == 4 && strncmp(jsp->data.prim.buff, "true", 4) == 0) {
  426. LWJSON_DEBUG(jsp, "Primitive parsed as %s\r\n", "true");
  427. SEND_EVT(jsp, LWJSON_STREAM_TYPE_TRUE);
  428. } else if (jsp->data.prim.buff_pos == 4 && strncmp(jsp->data.prim.buff, "null", 4) == 0) {
  429. LWJSON_DEBUG(jsp, "Primitive parsed as %s\r\n", "null");
  430. SEND_EVT(jsp, LWJSON_STREAM_TYPE_NULL);
  431. } else if (jsp->data.prim.buff_pos == 5 && strncmp(jsp->data.prim.buff, "false", 5) == 0) {
  432. LWJSON_DEBUG(jsp, "Primitive parsed as %s\r\n", "false");
  433. SEND_EVT(jsp, LWJSON_STREAM_TYPE_FALSE);
  434. } else if (jsp->data.prim.buff[0] == '-'
  435. || (jsp->data.prim.buff[0] >= '0' && jsp->data.prim.buff[0] <= '9')) {
  436. LWJSON_DEBUG(jsp, "Primitive parsed - number\r\n");
  437. SEND_EVT(jsp, LWJSON_STREAM_TYPE_NUMBER);
  438. } else {
  439. LWJSON_DEBUG(jsp, "Invalid primitive type. Got: %s\r\n", jsp->data.prim.buff);
  440. return lwjsonERRJSON;
  441. }
  442. if (type == LWJSON_STREAM_TYPE_KEY) {
  443. prv_stack_pop(jsp);
  444. } else if (type == LWJSON_STREAM_TYPE_ARRAY) {
  445. jsp->stack[jsp->stack_pos - 1].meta.index++;
  446. }
  447. /*
  448. * Received character is not part of the primitive and must be processed again
  449. */
  450. jsp->parse_state = LWJSON_STREAM_STATE_EXPECTING_COMMA_OR_END;
  451. goto start_over;
  452. }
  453. break;
  454. }
  455. default: break;
  456. }
  457. jsp->prev_c = chr; /* Save current c as previous for next round */
  458. return lwjsonSTREAMINPROG;
  459. }