Anthony Liguori | 5ab8558 | 2009-11-11 10:39:14 -0600 | [diff] [blame] | 1 | /* |
| 2 | * JSON lexer |
| 3 | * |
| 4 | * Copyright IBM, Corp. 2009 |
| 5 | * |
| 6 | * Authors: |
| 7 | * Anthony Liguori <aliguori@us.ibm.com> |
| 8 | * |
| 9 | * This work is licensed under the terms of the GNU LGPL, version 2.1 or later. |
| 10 | * See the COPYING.LIB file in the top-level directory. |
| 11 | * |
| 12 | */ |
| 13 | |
Peter Maydell | f2ad72b | 2016-01-29 17:50:01 +0000 | [diff] [blame] | 14 | #include "qemu/osdep.h" |
Markus Armbruster | 86cdf9e | 2018-08-23 18:40:20 +0200 | [diff] [blame] | 15 | #include "json-parser-int.h" |
Anthony Liguori | 5ab8558 | 2009-11-11 10:39:14 -0600 | [diff] [blame] | 16 | |
Anthony Liguori | 325601b | 2011-06-01 12:14:52 -0500 | [diff] [blame] | 17 | #define MAX_TOKEN_SIZE (64ULL << 20) |
| 18 | |
Anthony Liguori | 5ab8558 | 2009-11-11 10:39:14 -0600 | [diff] [blame] | 19 | /* |
Markus Armbruster | eddc0a7 | 2018-08-23 18:39:46 +0200 | [diff] [blame] | 20 | * From RFC 8259 "The JavaScript Object Notation (JSON) Data |
| 21 | * Interchange Format", with [comments in brackets]: |
Eric Blake | ff5394a | 2016-06-09 20:48:06 -0600 | [diff] [blame] | 22 | * |
Markus Armbruster | eddc0a7 | 2018-08-23 18:39:46 +0200 | [diff] [blame] | 23 | * The set of tokens includes six structural characters, strings, |
| 24 | * numbers, and three literal names. |
Eric Blake | ff5394a | 2016-06-09 20:48:06 -0600 | [diff] [blame] | 25 | * |
Markus Armbruster | eddc0a7 | 2018-08-23 18:39:46 +0200 | [diff] [blame] | 26 | * These are the six structural characters: |
Eric Blake | ff5394a | 2016-06-09 20:48:06 -0600 | [diff] [blame] | 27 | * |
Markus Armbruster | eddc0a7 | 2018-08-23 18:39:46 +0200 | [diff] [blame] | 28 | * begin-array = ws %x5B ws ; [ left square bracket |
| 29 | * begin-object = ws %x7B ws ; { left curly bracket |
| 30 | * end-array = ws %x5D ws ; ] right square bracket |
| 31 | * end-object = ws %x7D ws ; } right curly bracket |
| 32 | * name-separator = ws %x3A ws ; : colon |
| 33 | * value-separator = ws %x2C ws ; , comma |
Eric Blake | ff5394a | 2016-06-09 20:48:06 -0600 | [diff] [blame] | 34 | * |
Markus Armbruster | eddc0a7 | 2018-08-23 18:39:46 +0200 | [diff] [blame] | 35 | * Insignificant whitespace is allowed before or after any of the six |
| 36 | * structural characters. |
| 37 | * [This lexer accepts it before or after any token, which is actually |
| 38 | * the same, as the grammar always has structural characters between |
| 39 | * other tokens.] |
Eric Blake | ff5394a | 2016-06-09 20:48:06 -0600 | [diff] [blame] | 40 | * |
Markus Armbruster | eddc0a7 | 2018-08-23 18:39:46 +0200 | [diff] [blame] | 41 | * ws = *( |
| 42 | * %x20 / ; Space |
| 43 | * %x09 / ; Horizontal tab |
| 44 | * %x0A / ; Line feed or New line |
| 45 | * %x0D ) ; Carriage return |
Anthony Liguori | 5ab8558 | 2009-11-11 10:39:14 -0600 | [diff] [blame] | 46 | * |
Markus Armbruster | eddc0a7 | 2018-08-23 18:39:46 +0200 | [diff] [blame] | 47 | * [...] three literal names: |
| 48 | * false null true |
| 49 | * [This lexer accepts [a-z]+, and leaves rejecting unknown literal |
| 50 | * names to the parser.] |
| 51 | * |
| 52 | * [Numbers:] |
| 53 | * |
| 54 | * number = [ minus ] int [ frac ] [ exp ] |
| 55 | * decimal-point = %x2E ; . |
| 56 | * digit1-9 = %x31-39 ; 1-9 |
| 57 | * e = %x65 / %x45 ; e E |
| 58 | * exp = e [ minus / plus ] 1*DIGIT |
| 59 | * frac = decimal-point 1*DIGIT |
| 60 | * int = zero / ( digit1-9 *DIGIT ) |
| 61 | * minus = %x2D ; - |
| 62 | * plus = %x2B ; + |
| 63 | * zero = %x30 ; 0 |
| 64 | * |
| 65 | * [Strings:] |
| 66 | * string = quotation-mark *char quotation-mark |
| 67 | * |
| 68 | * char = unescaped / |
| 69 | * escape ( |
| 70 | * %x22 / ; " quotation mark U+0022 |
| 71 | * %x5C / ; \ reverse solidus U+005C |
| 72 | * %x2F / ; / solidus U+002F |
| 73 | * %x62 / ; b backspace U+0008 |
| 74 | * %x66 / ; f form feed U+000C |
| 75 | * %x6E / ; n line feed U+000A |
| 76 | * %x72 / ; r carriage return U+000D |
| 77 | * %x74 / ; t tab U+0009 |
| 78 | * %x75 4HEXDIG ) ; uXXXX U+XXXX |
| 79 | * escape = %x5C ; \ |
| 80 | * quotation-mark = %x22 ; " |
| 81 | * unescaped = %x20-21 / %x23-5B / %x5D-10FFFF |
Markus Armbruster | b2da4a4 | 2018-08-23 18:39:53 +0200 | [diff] [blame] | 82 | * [This lexer accepts any non-control character after escape, and |
| 83 | * leaves rejecting invalid ones to the parser.] |
Markus Armbruster | eddc0a7 | 2018-08-23 18:39:46 +0200 | [diff] [blame] | 84 | * |
| 85 | * |
| 86 | * Extensions over RFC 8259: |
| 87 | * - Extra escape sequence in strings: |
| 88 | * 0x27 (apostrophe) is recognized after escape, too |
| 89 | * - Single-quoted strings: |
| 90 | * Like double-quoted strings, except they're delimited by %x27 |
| 91 | * (apostrophe) instead of %x22 (quotation mark), and can't contain |
| 92 | * unescaped apostrophe, but can contain unescaped quotation mark. |
Markus Armbruster | 2cbd15a | 2018-08-23 18:40:05 +0200 | [diff] [blame] | 93 | * - Interpolation, if enabled: |
Markus Armbruster | f7617d4 | 2018-08-23 18:40:07 +0200 | [diff] [blame] | 94 | * The lexer accepts %[A-Za-z0-9]*, and leaves rejecting invalid |
| 95 | * ones to the parser. |
Markus Armbruster | eddc0a7 | 2018-08-23 18:39:46 +0200 | [diff] [blame] | 96 | * |
| 97 | * Note: |
Markus Armbruster | 4b1c0cd | 2018-08-23 18:39:52 +0200 | [diff] [blame] | 98 | * - Input must be encoded in modified UTF-8. |
Markus Armbruster | eddc0a7 | 2018-08-23 18:39:46 +0200 | [diff] [blame] | 99 | * - Decoding and validating is left to the parser. |
Anthony Liguori | 5ab8558 | 2009-11-11 10:39:14 -0600 | [diff] [blame] | 100 | */ |
| 101 | |
| 102 | enum json_lexer_state { |
Markus Armbruster | 2ce4ee6 | 2018-08-31 09:58:40 +0200 | [diff] [blame] | 103 | IN_RECOVERY = 1, |
Anthony Liguori | 5ab8558 | 2009-11-11 10:39:14 -0600 | [diff] [blame] | 104 | IN_DQ_STRING_ESCAPE, |
| 105 | IN_DQ_STRING, |
Anthony Liguori | 5ab8558 | 2009-11-11 10:39:14 -0600 | [diff] [blame] | 106 | IN_SQ_STRING_ESCAPE, |
| 107 | IN_SQ_STRING, |
| 108 | IN_ZERO, |
Markus Armbruster | 4d40066 | 2018-08-23 18:40:09 +0200 | [diff] [blame] | 109 | IN_EXP_DIGITS, |
| 110 | IN_EXP_SIGN, |
Anthony Liguori | 5ab8558 | 2009-11-11 10:39:14 -0600 | [diff] [blame] | 111 | IN_EXP_E, |
| 112 | IN_MANTISSA, |
| 113 | IN_MANTISSA_DIGITS, |
Markus Armbruster | 4d40066 | 2018-08-23 18:40:09 +0200 | [diff] [blame] | 114 | IN_DIGITS, |
| 115 | IN_SIGN, |
Anthony Liguori | 5ab8558 | 2009-11-11 10:39:14 -0600 | [diff] [blame] | 116 | IN_KEYWORD, |
Markus Armbruster | 6103028 | 2018-08-23 18:40:04 +0200 | [diff] [blame] | 117 | IN_INTERP, |
Anthony Liguori | 5ab8558 | 2009-11-11 10:39:14 -0600 | [diff] [blame] | 118 | IN_START, |
Markus Armbruster | 2cbd15a | 2018-08-23 18:40:05 +0200 | [diff] [blame] | 119 | IN_START_INTERP, /* must be IN_START + 1 */ |
Anthony Liguori | 5ab8558 | 2009-11-11 10:39:14 -0600 | [diff] [blame] | 120 | }; |
| 121 | |
Markus Armbruster | 2ce4ee6 | 2018-08-31 09:58:40 +0200 | [diff] [blame] | 122 | QEMU_BUILD_BUG_ON(JSON_ERROR != 0); |
| 123 | QEMU_BUILD_BUG_ON(IN_RECOVERY != JSON_ERROR + 1); |
Markus Armbruster | 2cbd15a | 2018-08-23 18:40:05 +0200 | [diff] [blame] | 124 | QEMU_BUILD_BUG_ON((int)JSON_MIN <= (int)IN_START_INTERP); |
Markus Armbruster | c0ee3af | 2018-08-31 09:58:38 +0200 | [diff] [blame] | 125 | QEMU_BUILD_BUG_ON(JSON_MAX >= 0x80); |
Markus Armbruster | 2cbd15a | 2018-08-23 18:40:05 +0200 | [diff] [blame] | 126 | QEMU_BUILD_BUG_ON(IN_START_INTERP != IN_START + 1); |
Markus Armbruster | b8d3b1d | 2015-11-25 22:23:25 +0100 | [diff] [blame] | 127 | |
Markus Armbruster | c0ee3af | 2018-08-31 09:58:38 +0200 | [diff] [blame] | 128 | #define LOOKAHEAD 0x80 |
| 129 | #define TERMINAL(state) [0 ... 0xFF] = ((state) | LOOKAHEAD) |
Paolo Bonzini | f7c0527 | 2010-05-24 09:39:52 +0200 | [diff] [blame] | 130 | |
Anthony Liguori | 5ab8558 | 2009-11-11 10:39:14 -0600 | [diff] [blame] | 131 | static const uint8_t json_lexer[][256] = { |
Markus Armbruster | b8d3b1d | 2015-11-25 22:23:25 +0100 | [diff] [blame] | 132 | /* Relies on default initialization to IN_ERROR! */ |
| 133 | |
Markus Armbruster | 0f07a5d | 2018-08-31 09:58:39 +0200 | [diff] [blame] | 134 | /* error recovery */ |
| 135 | [IN_RECOVERY] = { |
| 136 | /* |
| 137 | * Skip characters until a structural character, an ASCII |
| 138 | * control character other than '\t', or impossible UTF-8 |
| 139 | * bytes '\xFE', '\xFF'. Structural characters and line |
| 140 | * endings are promising resynchronization points. Clients |
| 141 | * may use the others to force the JSON parser into known-good |
Peter Maydell | d565725 | 2023-05-15 17:22:43 +0100 | [diff] [blame] | 142 | * state; see docs/interop/qmp-spec.rst. |
Markus Armbruster | 0f07a5d | 2018-08-31 09:58:39 +0200 | [diff] [blame] | 143 | */ |
| 144 | [0 ... 0x1F] = IN_START | LOOKAHEAD, |
| 145 | [0x20 ... 0xFD] = IN_RECOVERY, |
| 146 | [0xFE ... 0xFF] = IN_START | LOOKAHEAD, |
| 147 | ['\t'] = IN_RECOVERY, |
| 148 | ['['] = IN_START | LOOKAHEAD, |
| 149 | [']'] = IN_START | LOOKAHEAD, |
| 150 | ['{'] = IN_START | LOOKAHEAD, |
| 151 | ['}'] = IN_START | LOOKAHEAD, |
| 152 | [':'] = IN_START | LOOKAHEAD, |
| 153 | [','] = IN_START | LOOKAHEAD, |
| 154 | }, |
| 155 | |
Anthony Liguori | 5ab8558 | 2009-11-11 10:39:14 -0600 | [diff] [blame] | 156 | /* double quote string */ |
Anthony Liguori | 5ab8558 | 2009-11-11 10:39:14 -0600 | [diff] [blame] | 157 | [IN_DQ_STRING_ESCAPE] = { |
Markus Armbruster | b2da4a4 | 2018-08-23 18:39:53 +0200 | [diff] [blame] | 158 | [0x20 ... 0xFD] = IN_DQ_STRING, |
Anthony Liguori | 5ab8558 | 2009-11-11 10:39:14 -0600 | [diff] [blame] | 159 | }, |
| 160 | [IN_DQ_STRING] = { |
Markus Armbruster | de930f4 | 2018-08-23 18:39:51 +0200 | [diff] [blame] | 161 | [0x20 ... 0xFD] = IN_DQ_STRING, |
Anthony Liguori | 5ab8558 | 2009-11-11 10:39:14 -0600 | [diff] [blame] | 162 | ['\\'] = IN_DQ_STRING_ESCAPE, |
Paolo Bonzini | 28e91a6 | 2010-05-24 09:39:53 +0200 | [diff] [blame] | 163 | ['"'] = JSON_STRING, |
Anthony Liguori | 5ab8558 | 2009-11-11 10:39:14 -0600 | [diff] [blame] | 164 | }, |
| 165 | |
| 166 | /* single quote string */ |
Anthony Liguori | 5ab8558 | 2009-11-11 10:39:14 -0600 | [diff] [blame] | 167 | [IN_SQ_STRING_ESCAPE] = { |
Markus Armbruster | b2da4a4 | 2018-08-23 18:39:53 +0200 | [diff] [blame] | 168 | [0x20 ... 0xFD] = IN_SQ_STRING, |
Anthony Liguori | 5ab8558 | 2009-11-11 10:39:14 -0600 | [diff] [blame] | 169 | }, |
| 170 | [IN_SQ_STRING] = { |
Markus Armbruster | de930f4 | 2018-08-23 18:39:51 +0200 | [diff] [blame] | 171 | [0x20 ... 0xFD] = IN_SQ_STRING, |
Anthony Liguori | 5ab8558 | 2009-11-11 10:39:14 -0600 | [diff] [blame] | 172 | ['\\'] = IN_SQ_STRING_ESCAPE, |
Paolo Bonzini | 28e91a6 | 2010-05-24 09:39:53 +0200 | [diff] [blame] | 173 | ['\''] = JSON_STRING, |
Anthony Liguori | 5ab8558 | 2009-11-11 10:39:14 -0600 | [diff] [blame] | 174 | }, |
| 175 | |
| 176 | /* Zero */ |
| 177 | [IN_ZERO] = { |
| 178 | TERMINAL(JSON_INTEGER), |
Markus Armbruster | 2ce4ee6 | 2018-08-31 09:58:40 +0200 | [diff] [blame] | 179 | ['0' ... '9'] = JSON_ERROR, |
Anthony Liguori | 5ab8558 | 2009-11-11 10:39:14 -0600 | [diff] [blame] | 180 | ['.'] = IN_MANTISSA, |
| 181 | }, |
| 182 | |
| 183 | /* Float */ |
Markus Armbruster | 4d40066 | 2018-08-23 18:40:09 +0200 | [diff] [blame] | 184 | [IN_EXP_DIGITS] = { |
Anthony Liguori | 5ab8558 | 2009-11-11 10:39:14 -0600 | [diff] [blame] | 185 | TERMINAL(JSON_FLOAT), |
Markus Armbruster | 4d40066 | 2018-08-23 18:40:09 +0200 | [diff] [blame] | 186 | ['0' ... '9'] = IN_EXP_DIGITS, |
Anthony Liguori | 5ab8558 | 2009-11-11 10:39:14 -0600 | [diff] [blame] | 187 | }, |
| 188 | |
Markus Armbruster | 4d40066 | 2018-08-23 18:40:09 +0200 | [diff] [blame] | 189 | [IN_EXP_SIGN] = { |
| 190 | ['0' ... '9'] = IN_EXP_DIGITS, |
Anthony Liguori | 5ab8558 | 2009-11-11 10:39:14 -0600 | [diff] [blame] | 191 | }, |
| 192 | |
| 193 | [IN_EXP_E] = { |
Markus Armbruster | 4d40066 | 2018-08-23 18:40:09 +0200 | [diff] [blame] | 194 | ['-'] = IN_EXP_SIGN, |
| 195 | ['+'] = IN_EXP_SIGN, |
| 196 | ['0' ... '9'] = IN_EXP_DIGITS, |
Anthony Liguori | 5ab8558 | 2009-11-11 10:39:14 -0600 | [diff] [blame] | 197 | }, |
| 198 | |
| 199 | [IN_MANTISSA_DIGITS] = { |
| 200 | TERMINAL(JSON_FLOAT), |
| 201 | ['0' ... '9'] = IN_MANTISSA_DIGITS, |
| 202 | ['e'] = IN_EXP_E, |
| 203 | ['E'] = IN_EXP_E, |
| 204 | }, |
| 205 | |
| 206 | [IN_MANTISSA] = { |
| 207 | ['0' ... '9'] = IN_MANTISSA_DIGITS, |
| 208 | }, |
| 209 | |
| 210 | /* Number */ |
Markus Armbruster | 4d40066 | 2018-08-23 18:40:09 +0200 | [diff] [blame] | 211 | [IN_DIGITS] = { |
Anthony Liguori | 5ab8558 | 2009-11-11 10:39:14 -0600 | [diff] [blame] | 212 | TERMINAL(JSON_INTEGER), |
Markus Armbruster | 4d40066 | 2018-08-23 18:40:09 +0200 | [diff] [blame] | 213 | ['0' ... '9'] = IN_DIGITS, |
Anthony Liguori | 5ab8558 | 2009-11-11 10:39:14 -0600 | [diff] [blame] | 214 | ['e'] = IN_EXP_E, |
| 215 | ['E'] = IN_EXP_E, |
| 216 | ['.'] = IN_MANTISSA, |
| 217 | }, |
| 218 | |
Markus Armbruster | 4d40066 | 2018-08-23 18:40:09 +0200 | [diff] [blame] | 219 | [IN_SIGN] = { |
Anthony Liguori | 5ab8558 | 2009-11-11 10:39:14 -0600 | [diff] [blame] | 220 | ['0'] = IN_ZERO, |
Markus Armbruster | 4d40066 | 2018-08-23 18:40:09 +0200 | [diff] [blame] | 221 | ['1' ... '9'] = IN_DIGITS, |
Anthony Liguori | 5ab8558 | 2009-11-11 10:39:14 -0600 | [diff] [blame] | 222 | }, |
| 223 | |
| 224 | /* keywords */ |
| 225 | [IN_KEYWORD] = { |
| 226 | TERMINAL(JSON_KEYWORD), |
| 227 | ['a' ... 'z'] = IN_KEYWORD, |
| 228 | }, |
| 229 | |
Markus Armbruster | 6103028 | 2018-08-23 18:40:04 +0200 | [diff] [blame] | 230 | /* interpolation */ |
Markus Armbruster | 6103028 | 2018-08-23 18:40:04 +0200 | [diff] [blame] | 231 | [IN_INTERP] = { |
Markus Armbruster | f7617d4 | 2018-08-23 18:40:07 +0200 | [diff] [blame] | 232 | TERMINAL(JSON_INTERP), |
| 233 | ['A' ... 'Z'] = IN_INTERP, |
| 234 | ['a' ... 'z'] = IN_INTERP, |
| 235 | ['0' ... '9'] = IN_INTERP, |
Anthony Liguori | 5ab8558 | 2009-11-11 10:39:14 -0600 | [diff] [blame] | 236 | }, |
| 237 | |
Markus Armbruster | 2cbd15a | 2018-08-23 18:40:05 +0200 | [diff] [blame] | 238 | /* |
| 239 | * Two start states: |
| 240 | * - IN_START recognizes JSON tokens with our string extensions |
| 241 | * - IN_START_INTERP additionally recognizes interpolation. |
| 242 | */ |
| 243 | [IN_START ... IN_START_INTERP] = { |
Anthony Liguori | 5ab8558 | 2009-11-11 10:39:14 -0600 | [diff] [blame] | 244 | ['"'] = IN_DQ_STRING, |
| 245 | ['\''] = IN_SQ_STRING, |
| 246 | ['0'] = IN_ZERO, |
Markus Armbruster | 4d40066 | 2018-08-23 18:40:09 +0200 | [diff] [blame] | 247 | ['1' ... '9'] = IN_DIGITS, |
| 248 | ['-'] = IN_SIGN, |
Markus Armbruster | c546166 | 2015-11-25 22:23:26 +0100 | [diff] [blame] | 249 | ['{'] = JSON_LCURLY, |
| 250 | ['}'] = JSON_RCURLY, |
| 251 | ['['] = JSON_LSQUARE, |
| 252 | [']'] = JSON_RSQUARE, |
| 253 | [','] = JSON_COMMA, |
| 254 | [':'] = JSON_COLON, |
Anthony Liguori | 5ab8558 | 2009-11-11 10:39:14 -0600 | [diff] [blame] | 255 | ['a' ... 'z'] = IN_KEYWORD, |
Markus Armbruster | 1e960b4 | 2018-08-31 09:58:41 +0200 | [diff] [blame] | 256 | [' '] = IN_START, |
| 257 | ['\t'] = IN_START, |
| 258 | ['\r'] = IN_START, |
| 259 | ['\n'] = IN_START, |
Anthony Liguori | 5ab8558 | 2009-11-11 10:39:14 -0600 | [diff] [blame] | 260 | }, |
Markus Armbruster | 2cbd15a | 2018-08-23 18:40:05 +0200 | [diff] [blame] | 261 | [IN_START_INTERP]['%'] = IN_INTERP, |
Anthony Liguori | 5ab8558 | 2009-11-11 10:39:14 -0600 | [diff] [blame] | 262 | }; |
| 263 | |
Markus Armbruster | c0ee3af | 2018-08-31 09:58:38 +0200 | [diff] [blame] | 264 | static inline uint8_t next_state(JSONLexer *lexer, char ch, bool flush, |
| 265 | bool *char_consumed) |
| 266 | { |
| 267 | uint8_t next; |
| 268 | |
Liam Merwick | 19e8ff4 | 2019-03-21 11:57:52 +0000 | [diff] [blame] | 269 | assert(lexer->state < ARRAY_SIZE(json_lexer)); |
Markus Armbruster | c0ee3af | 2018-08-31 09:58:38 +0200 | [diff] [blame] | 270 | next = json_lexer[lexer->state][(uint8_t)ch]; |
| 271 | *char_consumed = !flush && !(next & LOOKAHEAD); |
| 272 | return next & ~LOOKAHEAD; |
| 273 | } |
| 274 | |
Markus Armbruster | 2cbd15a | 2018-08-23 18:40:05 +0200 | [diff] [blame] | 275 | void json_lexer_init(JSONLexer *lexer, bool enable_interpolation) |
Anthony Liguori | 5ab8558 | 2009-11-11 10:39:14 -0600 | [diff] [blame] | 276 | { |
Markus Armbruster | 2cbd15a | 2018-08-23 18:40:05 +0200 | [diff] [blame] | 277 | lexer->start_state = lexer->state = enable_interpolation |
| 278 | ? IN_START_INTERP : IN_START; |
Paolo Bonzini | d2ca7c0 | 2015-11-25 22:23:29 +0100 | [diff] [blame] | 279 | lexer->token = g_string_sized_new(3); |
Luiz Capitulino | 03308f6 | 2010-05-17 17:50:01 -0300 | [diff] [blame] | 280 | lexer->x = lexer->y = 0; |
Anthony Liguori | 5ab8558 | 2009-11-11 10:39:14 -0600 | [diff] [blame] | 281 | } |
| 282 | |
Marc-André Lureau | 7c1e1d5 | 2018-08-23 18:39:58 +0200 | [diff] [blame] | 283 | static void json_lexer_feed_char(JSONLexer *lexer, char ch, bool flush) |
Anthony Liguori | 5ab8558 | 2009-11-11 10:39:14 -0600 | [diff] [blame] | 284 | { |
Markus Armbruster | 852dfa7 | 2018-08-31 09:58:37 +0200 | [diff] [blame] | 285 | int new_state; |
| 286 | bool char_consumed = false; |
Paolo Bonzini | f7c0527 | 2010-05-24 09:39:52 +0200 | [diff] [blame] | 287 | |
Anthony Liguori | 5ab8558 | 2009-11-11 10:39:14 -0600 | [diff] [blame] | 288 | lexer->x++; |
| 289 | if (ch == '\n') { |
| 290 | lexer->x = 0; |
| 291 | lexer->y++; |
| 292 | } |
| 293 | |
Markus Armbruster | 852dfa7 | 2018-08-31 09:58:37 +0200 | [diff] [blame] | 294 | while (flush ? lexer->state != lexer->start_state : !char_consumed) { |
Markus Armbruster | c0ee3af | 2018-08-31 09:58:38 +0200 | [diff] [blame] | 295 | new_state = next_state(lexer, ch, flush, &char_consumed); |
Markus Armbruster | 852dfa7 | 2018-08-31 09:58:37 +0200 | [diff] [blame] | 296 | if (char_consumed) { |
Markus Armbruster | c0ee3af | 2018-08-31 09:58:38 +0200 | [diff] [blame] | 297 | assert(!flush); |
Paolo Bonzini | d2ca7c0 | 2015-11-25 22:23:29 +0100 | [diff] [blame] | 298 | g_string_append_c(lexer->token, ch); |
Paolo Bonzini | f7c0527 | 2010-05-24 09:39:52 +0200 | [diff] [blame] | 299 | } |
Anthony Liguori | 5ab8558 | 2009-11-11 10:39:14 -0600 | [diff] [blame] | 300 | |
Paolo Bonzini | f7c0527 | 2010-05-24 09:39:52 +0200 | [diff] [blame] | 301 | switch (new_state) { |
Markus Armbruster | c546166 | 2015-11-25 22:23:26 +0100 | [diff] [blame] | 302 | case JSON_LCURLY: |
| 303 | case JSON_RCURLY: |
| 304 | case JSON_LSQUARE: |
| 305 | case JSON_RSQUARE: |
| 306 | case JSON_COLON: |
| 307 | case JSON_COMMA: |
Markus Armbruster | 6103028 | 2018-08-23 18:40:04 +0200 | [diff] [blame] | 308 | case JSON_INTERP: |
Paolo Bonzini | f7c0527 | 2010-05-24 09:39:52 +0200 | [diff] [blame] | 309 | case JSON_INTEGER: |
| 310 | case JSON_FLOAT: |
| 311 | case JSON_KEYWORD: |
| 312 | case JSON_STRING: |
Markus Armbruster | 037f244 | 2018-08-23 18:40:00 +0200 | [diff] [blame] | 313 | json_message_process_token(lexer, lexer->token, new_state, |
| 314 | lexer->x, lexer->y); |
Stefan Weil | 0b0404b | 2012-01-09 18:29:51 +0100 | [diff] [blame] | 315 | /* fall through */ |
Markus Armbruster | 0f07a5d | 2018-08-31 09:58:39 +0200 | [diff] [blame] | 316 | case IN_START: |
Markus Armbruster | 1e960b4 | 2018-08-31 09:58:41 +0200 | [diff] [blame] | 317 | g_string_truncate(lexer->token, 0); |
Markus Armbruster | 2cbd15a | 2018-08-23 18:40:05 +0200 | [diff] [blame] | 318 | new_state = lexer->start_state; |
Paolo Bonzini | f7c0527 | 2010-05-24 09:39:52 +0200 | [diff] [blame] | 319 | break; |
Markus Armbruster | 2ce4ee6 | 2018-08-31 09:58:40 +0200 | [diff] [blame] | 320 | case JSON_ERROR: |
Markus Armbruster | 037f244 | 2018-08-23 18:40:00 +0200 | [diff] [blame] | 321 | json_message_process_token(lexer, lexer->token, JSON_ERROR, |
| 322 | lexer->x, lexer->y); |
Markus Armbruster | 0f07a5d | 2018-08-31 09:58:39 +0200 | [diff] [blame] | 323 | new_state = IN_RECOVERY; |
| 324 | /* fall through */ |
| 325 | case IN_RECOVERY: |
Paolo Bonzini | d2ca7c0 | 2015-11-25 22:23:29 +0100 | [diff] [blame] | 326 | g_string_truncate(lexer->token, 0); |
Markus Armbruster | 0f07a5d | 2018-08-31 09:58:39 +0200 | [diff] [blame] | 327 | break; |
Paolo Bonzini | f7c0527 | 2010-05-24 09:39:52 +0200 | [diff] [blame] | 328 | default: |
| 329 | break; |
| 330 | } |
| 331 | lexer->state = new_state; |
Markus Armbruster | 852dfa7 | 2018-08-31 09:58:37 +0200 | [diff] [blame] | 332 | } |
Anthony Liguori | 325601b | 2011-06-01 12:14:52 -0500 | [diff] [blame] | 333 | |
| 334 | /* Do not let a single token grow to an arbitrarily large size, |
| 335 | * this is a security consideration. |
| 336 | */ |
Paolo Bonzini | d2ca7c0 | 2015-11-25 22:23:29 +0100 | [diff] [blame] | 337 | if (lexer->token->len > MAX_TOKEN_SIZE) { |
Markus Armbruster | 037f244 | 2018-08-23 18:40:00 +0200 | [diff] [blame] | 338 | json_message_process_token(lexer, lexer->token, lexer->state, |
| 339 | lexer->x, lexer->y); |
Paolo Bonzini | d2ca7c0 | 2015-11-25 22:23:29 +0100 | [diff] [blame] | 340 | g_string_truncate(lexer->token, 0); |
Markus Armbruster | 2cbd15a | 2018-08-23 18:40:05 +0200 | [diff] [blame] | 341 | lexer->state = lexer->start_state; |
Anthony Liguori | 325601b | 2011-06-01 12:14:52 -0500 | [diff] [blame] | 342 | } |
Anthony Liguori | 5ab8558 | 2009-11-11 10:39:14 -0600 | [diff] [blame] | 343 | } |
| 344 | |
Marc-André Lureau | 7c1e1d5 | 2018-08-23 18:39:58 +0200 | [diff] [blame] | 345 | void json_lexer_feed(JSONLexer *lexer, const char *buffer, size_t size) |
Anthony Liguori | 5ab8558 | 2009-11-11 10:39:14 -0600 | [diff] [blame] | 346 | { |
| 347 | size_t i; |
| 348 | |
| 349 | for (i = 0; i < size; i++) { |
Marc-André Lureau | 7c1e1d5 | 2018-08-23 18:39:58 +0200 | [diff] [blame] | 350 | json_lexer_feed_char(lexer, buffer[i], false); |
Anthony Liguori | 5ab8558 | 2009-11-11 10:39:14 -0600 | [diff] [blame] | 351 | } |
Anthony Liguori | 5ab8558 | 2009-11-11 10:39:14 -0600 | [diff] [blame] | 352 | } |
| 353 | |
Marc-André Lureau | 7c1e1d5 | 2018-08-23 18:39:58 +0200 | [diff] [blame] | 354 | void json_lexer_flush(JSONLexer *lexer) |
Anthony Liguori | 5ab8558 | 2009-11-11 10:39:14 -0600 | [diff] [blame] | 355 | { |
Markus Armbruster | 852dfa7 | 2018-08-31 09:58:37 +0200 | [diff] [blame] | 356 | json_lexer_feed_char(lexer, 0, true); |
| 357 | assert(lexer->state == lexer->start_state); |
Markus Armbruster | f927791 | 2018-08-23 18:40:12 +0200 | [diff] [blame] | 358 | json_message_process_token(lexer, lexer->token, JSON_END_OF_INPUT, |
| 359 | lexer->x, lexer->y); |
Anthony Liguori | 5ab8558 | 2009-11-11 10:39:14 -0600 | [diff] [blame] | 360 | } |
| 361 | |
| 362 | void json_lexer_destroy(JSONLexer *lexer) |
| 363 | { |
Paolo Bonzini | d2ca7c0 | 2015-11-25 22:23:29 +0100 | [diff] [blame] | 364 | g_string_free(lexer->token, true); |
Anthony Liguori | 5ab8558 | 2009-11-11 10:39:14 -0600 | [diff] [blame] | 365 | } |