jslex.c 19 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881
  1. #include "jsi.h"
  2. #include "utf.h"
  3. JS_NORETURN static void jsY_error(js_State *J, const char *fmt, ...) JS_PRINTFLIKE(2,3);
  4. static void jsY_error(js_State *J, const char *fmt, ...)
  5. {
  6. va_list ap;
  7. char buf[512];
  8. char msgbuf[256];
  9. va_start(ap, fmt);
  10. vsnprintf(msgbuf, 256, fmt, ap);
  11. va_end(ap);
  12. snprintf(buf, 256, "%s:%d: ", J->filename, J->lexline);
  13. strcat(buf, msgbuf);
  14. js_newsyntaxerror(J, buf);
  15. js_throw(J);
  16. }
  17. static const char *tokenstring[] = {
  18. "(end-of-file)",
  19. "'\\x01'", "'\\x02'", "'\\x03'", "'\\x04'", "'\\x05'", "'\\x06'", "'\\x07'",
  20. "'\\x08'", "'\\x09'", "'\\x0A'", "'\\x0B'", "'\\x0C'", "'\\x0D'", "'\\x0E'", "'\\x0F'",
  21. "'\\x10'", "'\\x11'", "'\\x12'", "'\\x13'", "'\\x14'", "'\\x15'", "'\\x16'", "'\\x17'",
  22. "'\\x18'", "'\\x19'", "'\\x1A'", "'\\x1B'", "'\\x1C'", "'\\x1D'", "'\\x1E'", "'\\x1F'",
  23. "' '", "'!'", "'\"'", "'#'", "'$'", "'%'", "'&'", "'\\''",
  24. "'('", "')'", "'*'", "'+'", "','", "'-'", "'.'", "'/'",
  25. "'0'", "'1'", "'2'", "'3'", "'4'", "'5'", "'6'", "'7'",
  26. "'8'", "'9'", "':'", "';'", "'<'", "'='", "'>'", "'?'",
  27. "'@'", "'A'", "'B'", "'C'", "'D'", "'E'", "'F'", "'G'",
  28. "'H'", "'I'", "'J'", "'K'", "'L'", "'M'", "'N'", "'O'",
  29. "'P'", "'Q'", "'R'", "'S'", "'T'", "'U'", "'V'", "'W'",
  30. "'X'", "'Y'", "'Z'", "'['", "'\'", "']'", "'^'", "'_'",
  31. "'`'", "'a'", "'b'", "'c'", "'d'", "'e'", "'f'", "'g'",
  32. "'h'", "'i'", "'j'", "'k'", "'l'", "'m'", "'n'", "'o'",
  33. "'p'", "'q'", "'r'", "'s'", "'t'", "'u'", "'v'", "'w'",
  34. "'x'", "'y'", "'z'", "'{'", "'|'", "'}'", "'~'", "'\\x7F'",
  35. 0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0,
  36. 0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0,
  37. 0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0,
  38. 0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0,
  39. 0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0,
  40. 0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0,
  41. 0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0,
  42. 0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0,
  43. "(identifier)", "(number)", "(string)", "(regexp)",
  44. "'<='", "'>='", "'=='", "'!='", "'==='", "'!=='",
  45. "'<<'", "'>>'", "'>>>'", "'&&'", "'||'",
  46. "'+='", "'-='", "'*='", "'/='", "'%='",
  47. "'<<='", "'>>='", "'>>>='", "'&='", "'|='", "'^='",
  48. "'++'", "'--'",
  49. "'break'", "'case'", "'catch'", "'continue'", "'debugger'",
  50. "'default'", "'delete'", "'do'", "'else'", "'false'", "'finally'", "'for'",
  51. "'function'", "'if'", "'in'", "'instanceof'", "'new'", "'null'", "'return'",
  52. "'switch'", "'this'", "'throw'", "'true'", "'try'", "'typeof'", "'var'",
  53. "'void'", "'while'", "'with'",
  54. };
  55. const char *jsY_tokenstring(int token)
  56. {
  57. if (token >= 0 && token < (int)nelem(tokenstring))
  58. if (tokenstring[token])
  59. return tokenstring[token];
  60. return "<unknown>";
  61. }
  62. static const char *keywords[] = {
  63. "break", "case", "catch", "continue", "debugger", "default", "delete",
  64. "do", "else", "false", "finally", "for", "function", "if", "in",
  65. "instanceof", "new", "null", "return", "switch", "this", "throw",
  66. "true", "try", "typeof", "var", "void", "while", "with",
  67. };
  68. int jsY_findword(const char *s, const char **list, int num)
  69. {
  70. int l = 0;
  71. int r = num - 1;
  72. while (l <= r) {
  73. int m = (l + r) >> 1;
  74. int c = strcmp(s, list[m]);
  75. if (c < 0)
  76. r = m - 1;
  77. else if (c > 0)
  78. l = m + 1;
  79. else
  80. return m;
  81. }
  82. return -1;
  83. }
  84. static int jsY_findkeyword(js_State *J, const char *s)
  85. {
  86. int i = jsY_findword(s, keywords, nelem(keywords));
  87. if (i >= 0) {
  88. J->text = keywords[i];
  89. return TK_BREAK + i; /* first keyword + i */
  90. }
  91. J->text = s;
  92. return TK_IDENTIFIER;
  93. }
  94. int jsY_iswhite(int c)
  95. {
  96. return c == 0x9 || c == 0xB || c == 0xC || c == 0x20 || c == 0xA0 || c == 0xFEFF;
  97. }
  98. int jsY_isnewline(int c)
  99. {
  100. return c == 0xA || c == 0xD || c == 0x2028 || c == 0x2029;
  101. }
  102. #ifndef isalpha
  103. #define isalpha(c) ((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z'))
  104. #endif
  105. #ifndef isdigit
  106. #define isdigit(c) (c >= '0' && c <= '9')
  107. #endif
  108. #ifndef ishex
  109. #define ishex(c) ((c >= 'a' && c <= 'f') || (c >= 'A' && c <= 'F'))
  110. #endif
  111. static int jsY_isidentifierstart(int c)
  112. {
  113. return isalpha(c) || c == '$' || c == '_' || isalpharune(c);
  114. }
  115. static int jsY_isidentifierpart(int c)
  116. {
  117. return isdigit(c) || isalpha(c) || c == '$' || c == '_' || isalpharune(c);
  118. }
  119. static int jsY_isdec(int c)
  120. {
  121. return isdigit(c);
  122. }
  123. int jsY_ishex(int c)
  124. {
  125. return isdigit(c) || ishex(c);
  126. }
  127. int jsY_tohex(int c)
  128. {
  129. if (c >= '0' && c <= '9') return c - '0';
  130. if (c >= 'a' && c <= 'f') return c - 'a' + 0xA;
  131. if (c >= 'A' && c <= 'F') return c - 'A' + 0xA;
  132. return 0;
  133. }
  134. static void jsY_next(js_State *J)
  135. {
  136. Rune c;
  137. if (*J->source == 0) {
  138. J->lexchar = EOF;
  139. return;
  140. }
  141. J->source += chartorune(&c, J->source);
  142. /* consume CR LF as one unit */
  143. if (c == '\r' && *J->source == '\n')
  144. ++J->source;
  145. if (jsY_isnewline(c)) {
  146. J->line++;
  147. c = '\n';
  148. }
  149. J->lexchar = c;
  150. }
  151. #define jsY_accept(J, x) (J->lexchar == x ? (jsY_next(J), 1) : 0)
  152. #define jsY_expect(J, x) if (!jsY_accept(J, x)) jsY_error(J, "expected '%c'", x)
  153. static void jsY_unescape(js_State *J)
  154. {
  155. if (jsY_accept(J, '\\')) {
  156. if (jsY_accept(J, 'u')) {
  157. int x = 0;
  158. if (!jsY_ishex(J->lexchar)) { goto error; } x |= jsY_tohex(J->lexchar) << 12; jsY_next(J);
  159. if (!jsY_ishex(J->lexchar)) { goto error; } x |= jsY_tohex(J->lexchar) << 8; jsY_next(J);
  160. if (!jsY_ishex(J->lexchar)) { goto error; } x |= jsY_tohex(J->lexchar) << 4; jsY_next(J);
  161. if (!jsY_ishex(J->lexchar)) { goto error; } x |= jsY_tohex(J->lexchar);
  162. J->lexchar = x;
  163. return;
  164. }
  165. error:
  166. jsY_error(J, "unexpected escape sequence");
  167. }
  168. }
  169. static void textinit(js_State *J)
  170. {
  171. if (!J->lexbuf.text) {
  172. J->lexbuf.cap = 4096;
  173. J->lexbuf.text = js_malloc(J, J->lexbuf.cap);
  174. }
  175. J->lexbuf.len = 0;
  176. }
  177. static void textpush(js_State *J, Rune c)
  178. {
  179. int n, newcap;
  180. if (c == EOF)
  181. n = 1;
  182. else
  183. n = runelen(c);
  184. if (J->lexbuf.len + n > J->lexbuf.cap) {
  185. newcap = J->lexbuf.cap * 2;
  186. J->lexbuf.text = js_realloc(J, J->lexbuf.text, newcap);
  187. J->lexbuf.cap = newcap;
  188. }
  189. if (c == EOF)
  190. J->lexbuf.text[J->lexbuf.len++] = 0;
  191. else
  192. J->lexbuf.len += runetochar(J->lexbuf.text + J->lexbuf.len, &c);
  193. }
  194. static char *textend(js_State *J)
  195. {
  196. textpush(J, EOF);
  197. return J->lexbuf.text;
  198. }
  199. static void lexlinecomment(js_State *J)
  200. {
  201. while (J->lexchar != EOF && J->lexchar != '\n')
  202. jsY_next(J);
  203. }
  204. static int lexcomment(js_State *J)
  205. {
  206. /* already consumed initial '/' '*' sequence */
  207. while (J->lexchar != EOF) {
  208. if (jsY_accept(J, '*')) {
  209. while (J->lexchar == '*')
  210. jsY_next(J);
  211. if (jsY_accept(J, '/'))
  212. return 0;
  213. }
  214. else
  215. jsY_next(J);
  216. }
  217. return -1;
  218. }
  219. static double lexhex(js_State *J)
  220. {
  221. double n = 0;
  222. if (!jsY_ishex(J->lexchar))
  223. jsY_error(J, "malformed hexadecimal number");
  224. while (jsY_ishex(J->lexchar)) {
  225. n = n * 16 + jsY_tohex(J->lexchar);
  226. jsY_next(J);
  227. }
  228. return n;
  229. }
  230. #if 0
  231. static double lexinteger(js_State *J)
  232. {
  233. double n = 0;
  234. if (!jsY_isdec(J->lexchar))
  235. jsY_error(J, "malformed number");
  236. while (jsY_isdec(J->lexchar)) {
  237. n = n * 10 + (J->lexchar - '0');
  238. jsY_next(J);
  239. }
  240. return n;
  241. }
  242. static double lexfraction(js_State *J)
  243. {
  244. double n = 0;
  245. double d = 1;
  246. while (jsY_isdec(J->lexchar)) {
  247. n = n * 10 + (J->lexchar - '0');
  248. d = d * 10;
  249. jsY_next(J);
  250. }
  251. return n / d;
  252. }
  253. static double lexexponent(js_State *J)
  254. {
  255. double sign;
  256. if (jsY_accept(J, 'e') || jsY_accept(J, 'E')) {
  257. if (jsY_accept(J, '-')) sign = -1;
  258. else if (jsY_accept(J, '+')) sign = 1;
  259. else sign = 1;
  260. return sign * lexinteger(J);
  261. }
  262. return 0;
  263. }
  264. static int lexnumber(js_State *J)
  265. {
  266. double n;
  267. double e;
  268. if (jsY_accept(J, '0')) {
  269. if (jsY_accept(J, 'x') || jsY_accept(J, 'X')) {
  270. J->number = lexhex(J);
  271. return TK_NUMBER;
  272. }
  273. if (jsY_isdec(J->lexchar))
  274. jsY_error(J, "number with leading zero");
  275. n = 0;
  276. if (jsY_accept(J, '.'))
  277. n += lexfraction(J);
  278. } else if (jsY_accept(J, '.')) {
  279. if (!jsY_isdec(J->lexchar))
  280. return '.';
  281. n = lexfraction(J);
  282. } else {
  283. n = lexinteger(J);
  284. if (jsY_accept(J, '.'))
  285. n += lexfraction(J);
  286. }
  287. e = lexexponent(J);
  288. if (e < 0)
  289. n /= pow(10, -e);
  290. else if (e > 0)
  291. n *= pow(10, e);
  292. if (jsY_isidentifierstart(J->lexchar))
  293. jsY_error(J, "number with letter suffix");
  294. J->number = n;
  295. return TK_NUMBER;
  296. }
  297. #else
  298. static int lexnumber(js_State *J)
  299. {
  300. const char *s = J->source - 1;
  301. if (jsY_accept(J, '0')) {
  302. if (jsY_accept(J, 'x') || jsY_accept(J, 'X')) {
  303. J->number = lexhex(J);
  304. return TK_NUMBER;
  305. }
  306. if (jsY_isdec(J->lexchar))
  307. jsY_error(J, "number with leading zero");
  308. if (jsY_accept(J, '.')) {
  309. while (jsY_isdec(J->lexchar))
  310. jsY_next(J);
  311. }
  312. } else if (jsY_accept(J, '.')) {
  313. if (!jsY_isdec(J->lexchar))
  314. return '.';
  315. while (jsY_isdec(J->lexchar))
  316. jsY_next(J);
  317. } else {
  318. while (jsY_isdec(J->lexchar))
  319. jsY_next(J);
  320. if (jsY_accept(J, '.')) {
  321. while (jsY_isdec(J->lexchar))
  322. jsY_next(J);
  323. }
  324. }
  325. if (jsY_accept(J, 'e') || jsY_accept(J, 'E')) {
  326. if (J->lexchar == '-' || J->lexchar == '+')
  327. jsY_next(J);
  328. if (jsY_isdec(J->lexchar))
  329. while (jsY_isdec(J->lexchar))
  330. jsY_next(J);
  331. else
  332. jsY_error(J, "missing exponent");
  333. }
  334. if (jsY_isidentifierstart(J->lexchar))
  335. jsY_error(J, "number with letter suffix");
  336. J->number = js_strtod(s, NULL);
  337. return TK_NUMBER;
  338. }
  339. #endif
  340. static int lexescape(js_State *J)
  341. {
  342. int x = 0;
  343. /* already consumed '\' */
  344. if (jsY_accept(J, '\n'))
  345. return 0;
  346. switch (J->lexchar) {
  347. case EOF: jsY_error(J, "unterminated escape sequence");
  348. case 'u':
  349. jsY_next(J);
  350. if (!jsY_ishex(J->lexchar)) return 1; else { x |= jsY_tohex(J->lexchar) << 12; jsY_next(J); }
  351. if (!jsY_ishex(J->lexchar)) return 1; else { x |= jsY_tohex(J->lexchar) << 8; jsY_next(J); }
  352. if (!jsY_ishex(J->lexchar)) return 1; else { x |= jsY_tohex(J->lexchar) << 4; jsY_next(J); }
  353. if (!jsY_ishex(J->lexchar)) return 1; else { x |= jsY_tohex(J->lexchar); jsY_next(J); }
  354. textpush(J, x);
  355. break;
  356. case 'x':
  357. jsY_next(J);
  358. if (!jsY_ishex(J->lexchar)) return 1; else { x |= jsY_tohex(J->lexchar) << 4; jsY_next(J); }
  359. if (!jsY_ishex(J->lexchar)) return 1; else { x |= jsY_tohex(J->lexchar); jsY_next(J); }
  360. textpush(J, x);
  361. break;
  362. case '0': textpush(J, 0); jsY_next(J); break;
  363. case '\\': textpush(J, '\\'); jsY_next(J); break;
  364. case '\'': textpush(J, '\''); jsY_next(J); break;
  365. case '"': textpush(J, '"'); jsY_next(J); break;
  366. case 'b': textpush(J, '\b'); jsY_next(J); break;
  367. case 'f': textpush(J, '\f'); jsY_next(J); break;
  368. case 'n': textpush(J, '\n'); jsY_next(J); break;
  369. case 'r': textpush(J, '\r'); jsY_next(J); break;
  370. case 't': textpush(J, '\t'); jsY_next(J); break;
  371. case 'v': textpush(J, '\v'); jsY_next(J); break;
  372. default: textpush(J, J->lexchar); jsY_next(J); break;
  373. }
  374. return 0;
  375. }
  376. static int lexstring(js_State *J)
  377. {
  378. const char *s;
  379. int q = J->lexchar;
  380. jsY_next(J);
  381. textinit(J);
  382. while (J->lexchar != q) {
  383. if (J->lexchar == EOF || J->lexchar == '\n')
  384. jsY_error(J, "string not terminated");
  385. if (jsY_accept(J, '\\')) {
  386. if (lexescape(J))
  387. jsY_error(J, "malformed escape sequence");
  388. } else {
  389. textpush(J, J->lexchar);
  390. jsY_next(J);
  391. }
  392. }
  393. jsY_expect(J, q);
  394. s = textend(J);
  395. J->text = s;
  396. return TK_STRING;
  397. }
  398. /* the ugliest language wart ever... */
  399. static int isregexpcontext(int last)
  400. {
  401. switch (last) {
  402. case ']':
  403. case ')':
  404. case '}':
  405. case TK_IDENTIFIER:
  406. case TK_NUMBER:
  407. case TK_STRING:
  408. case TK_FALSE:
  409. case TK_NULL:
  410. case TK_THIS:
  411. case TK_TRUE:
  412. return 0;
  413. default:
  414. return 1;
  415. }
  416. }
  417. static int lexregexp(js_State *J)
  418. {
  419. const char *s;
  420. int g, m, i, flags;
  421. int inclass = 0;
  422. /* already consumed initial '/' */
  423. textinit(J);
  424. /* regexp body */
  425. while (J->lexchar != '/' || inclass) {
  426. if (J->lexchar == EOF || J->lexchar == '\n') {
  427. jsY_error(J, "regular expression not terminated");
  428. } else if (jsY_accept(J, '\\')) {
  429. if (jsY_accept(J, '/')) {
  430. textpush(J, '/');
  431. } else {
  432. textpush(J, '\\');
  433. if (J->lexchar == EOF || J->lexchar == '\n')
  434. jsY_error(J, "regular expression not terminated");
  435. textpush(J, J->lexchar);
  436. jsY_next(J);
  437. }
  438. } else {
  439. if (J->lexchar == '[' && !inclass)
  440. inclass = 1;
  441. if (J->lexchar == ']' && inclass)
  442. inclass = 0;
  443. textpush(J, J->lexchar);
  444. jsY_next(J);
  445. }
  446. }
  447. jsY_expect(J, '/');
  448. s = textend(J);
  449. /* regexp flags */
  450. g = i = m = 0;
  451. while (jsY_isidentifierpart(J->lexchar)) {
  452. if (jsY_accept(J, 'g')) ++g;
  453. else if (jsY_accept(J, 'i')) ++i;
  454. else if (jsY_accept(J, 'm')) ++m;
  455. else jsY_error(J, "illegal flag in regular expression: %c", J->lexchar);
  456. }
  457. if (g > 1 || i > 1 || m > 1)
  458. jsY_error(J, "duplicated flag in regular expression");
  459. J->text = s;
  460. flags = 0;
  461. if (g) flags |= JS_REGEXP_G;
  462. if (i) flags |= JS_REGEXP_I;
  463. if (m) flags |= JS_REGEXP_M;
  464. J->number = flags;
  465. return TK_REGEXP;
  466. }
  467. /* simple "return [no Line Terminator here] ..." contexts */
  468. static int isnlthcontext(int last)
  469. {
  470. switch (last) {
  471. case TK_BREAK:
  472. case TK_CONTINUE:
  473. case TK_RETURN:
  474. case TK_THROW:
  475. return 1;
  476. default:
  477. return 0;
  478. }
  479. }
  480. static int jsY_lexx(js_State *J)
  481. {
  482. J->newline = 0;
  483. while (1) {
  484. J->lexline = J->line; /* save location of beginning of token */
  485. while (jsY_iswhite(J->lexchar))
  486. jsY_next(J);
  487. if (jsY_accept(J, '\n')) {
  488. J->newline = 1;
  489. if (isnlthcontext(J->lasttoken))
  490. return ';';
  491. continue;
  492. }
  493. if (jsY_accept(J, '/')) {
  494. if (jsY_accept(J, '/')) {
  495. lexlinecomment(J);
  496. continue;
  497. } else if (jsY_accept(J, '*')) {
  498. if (lexcomment(J))
  499. jsY_error(J, "multi-line comment not terminated");
  500. continue;
  501. } else if (isregexpcontext(J->lasttoken)) {
  502. return lexregexp(J);
  503. } else if (jsY_accept(J, '=')) {
  504. return TK_DIV_ASS;
  505. } else {
  506. return '/';
  507. }
  508. }
  509. if (J->lexchar >= '0' && J->lexchar <= '9') {
  510. return lexnumber(J);
  511. }
  512. switch (J->lexchar) {
  513. case '(': jsY_next(J); return '(';
  514. case ')': jsY_next(J); return ')';
  515. case ',': jsY_next(J); return ',';
  516. case ':': jsY_next(J); return ':';
  517. case ';': jsY_next(J); return ';';
  518. case '?': jsY_next(J); return '?';
  519. case '[': jsY_next(J); return '[';
  520. case ']': jsY_next(J); return ']';
  521. case '{': jsY_next(J); return '{';
  522. case '}': jsY_next(J); return '}';
  523. case '~': jsY_next(J); return '~';
  524. case '\'':
  525. case '"':
  526. return lexstring(J);
  527. case '.':
  528. return lexnumber(J);
  529. case '<':
  530. jsY_next(J);
  531. if (jsY_accept(J, '<')) {
  532. if (jsY_accept(J, '='))
  533. return TK_SHL_ASS;
  534. return TK_SHL;
  535. }
  536. if (jsY_accept(J, '='))
  537. return TK_LE;
  538. return '<';
  539. case '>':
  540. jsY_next(J);
  541. if (jsY_accept(J, '>')) {
  542. if (jsY_accept(J, '>')) {
  543. if (jsY_accept(J, '='))
  544. return TK_USHR_ASS;
  545. return TK_USHR;
  546. }
  547. if (jsY_accept(J, '='))
  548. return TK_SHR_ASS;
  549. return TK_SHR;
  550. }
  551. if (jsY_accept(J, '='))
  552. return TK_GE;
  553. return '>';
  554. case '=':
  555. jsY_next(J);
  556. if (jsY_accept(J, '=')) {
  557. if (jsY_accept(J, '='))
  558. return TK_STRICTEQ;
  559. return TK_EQ;
  560. }
  561. return '=';
  562. case '!':
  563. jsY_next(J);
  564. if (jsY_accept(J, '=')) {
  565. if (jsY_accept(J, '='))
  566. return TK_STRICTNE;
  567. return TK_NE;
  568. }
  569. return '!';
  570. case '+':
  571. jsY_next(J);
  572. if (jsY_accept(J, '+'))
  573. return TK_INC;
  574. if (jsY_accept(J, '='))
  575. return TK_ADD_ASS;
  576. return '+';
  577. case '-':
  578. jsY_next(J);
  579. if (jsY_accept(J, '-'))
  580. return TK_DEC;
  581. if (jsY_accept(J, '='))
  582. return TK_SUB_ASS;
  583. return '-';
  584. case '*':
  585. jsY_next(J);
  586. if (jsY_accept(J, '='))
  587. return TK_MUL_ASS;
  588. return '*';
  589. case '%':
  590. jsY_next(J);
  591. if (jsY_accept(J, '='))
  592. return TK_MOD_ASS;
  593. return '%';
  594. case '&':
  595. jsY_next(J);
  596. if (jsY_accept(J, '&'))
  597. return TK_AND;
  598. if (jsY_accept(J, '='))
  599. return TK_AND_ASS;
  600. return '&';
  601. case '|':
  602. jsY_next(J);
  603. if (jsY_accept(J, '|'))
  604. return TK_OR;
  605. if (jsY_accept(J, '='))
  606. return TK_OR_ASS;
  607. return '|';
  608. case '^':
  609. jsY_next(J);
  610. if (jsY_accept(J, '='))
  611. return TK_XOR_ASS;
  612. return '^';
  613. case EOF:
  614. return 0; /* EOF */
  615. }
  616. /* Handle \uXXXX escapes in identifiers */
  617. jsY_unescape(J);
  618. if (jsY_isidentifierstart(J->lexchar)) {
  619. textinit(J);
  620. textpush(J, J->lexchar);
  621. jsY_next(J);
  622. jsY_unescape(J);
  623. while (jsY_isidentifierpart(J->lexchar)) {
  624. textpush(J, J->lexchar);
  625. jsY_next(J);
  626. jsY_unescape(J);
  627. }
  628. textend(J);
  629. return jsY_findkeyword(J, J->lexbuf.text);
  630. }
  631. if (J->lexchar >= 0x20 && J->lexchar <= 0x7E)
  632. jsY_error(J, "unexpected character: '%c'", J->lexchar);
  633. jsY_error(J, "unexpected character: \\u%04X", J->lexchar);
  634. }
  635. }
  636. void jsY_initlex(js_State *J, const char *filename, const char *source)
  637. {
  638. J->filename = filename;
  639. J->source = source;
  640. J->line = 1;
  641. J->lasttoken = 0;
  642. jsY_next(J); /* load first lookahead character */
  643. }
  644. int jsY_lex(js_State *J)
  645. {
  646. return J->lasttoken = jsY_lexx(J);
  647. }
  648. static int lexjsonnumber(js_State *J)
  649. {
  650. const char *s = J->source - 1;
  651. if (J->lexchar == '-')
  652. jsY_next(J);
  653. if (J->lexchar == '0')
  654. jsY_next(J);
  655. else if (J->lexchar >= '1' && J->lexchar <= '9')
  656. while (isdigit(J->lexchar))
  657. jsY_next(J);
  658. else
  659. jsY_error(J, "unexpected non-digit");
  660. if (jsY_accept(J, '.')) {
  661. if (isdigit(J->lexchar))
  662. while (isdigit(J->lexchar))
  663. jsY_next(J);
  664. else
  665. jsY_error(J, "missing digits after decimal point");
  666. }
  667. if (jsY_accept(J, 'e') || jsY_accept(J, 'E')) {
  668. if (J->lexchar == '-' || J->lexchar == '+')
  669. jsY_next(J);
  670. if (isdigit(J->lexchar))
  671. while (isdigit(J->lexchar))
  672. jsY_next(J);
  673. else
  674. jsY_error(J, "missing digits after exponent indicator");
  675. }
  676. J->number = js_strtod(s, NULL);
  677. return TK_NUMBER;
  678. }
  679. static int lexjsonescape(js_State *J)
  680. {
  681. int x = 0;
  682. /* already consumed '\' */
  683. switch (J->lexchar) {
  684. default: jsY_error(J, "invalid escape sequence");
  685. case 'u':
  686. jsY_next(J);
  687. if (!jsY_ishex(J->lexchar)) return 1; else { x |= jsY_tohex(J->lexchar) << 12; jsY_next(J); }
  688. if (!jsY_ishex(J->lexchar)) return 1; else { x |= jsY_tohex(J->lexchar) << 8; jsY_next(J); }
  689. if (!jsY_ishex(J->lexchar)) return 1; else { x |= jsY_tohex(J->lexchar) << 4; jsY_next(J); }
  690. if (!jsY_ishex(J->lexchar)) return 1; else { x |= jsY_tohex(J->lexchar); jsY_next(J); }
  691. textpush(J, x);
  692. break;
  693. case '"': textpush(J, '"'); jsY_next(J); break;
  694. case '\\': textpush(J, '\\'); jsY_next(J); break;
  695. case '/': textpush(J, '/'); jsY_next(J); break;
  696. case 'b': textpush(J, '\b'); jsY_next(J); break;
  697. case 'f': textpush(J, '\f'); jsY_next(J); break;
  698. case 'n': textpush(J, '\n'); jsY_next(J); break;
  699. case 'r': textpush(J, '\r'); jsY_next(J); break;
  700. case 't': textpush(J, '\t'); jsY_next(J); break;
  701. }
  702. return 0;
  703. }
  704. static int lexjsonstring(js_State *J)
  705. {
  706. const char *s;
  707. textinit(J);
  708. while (J->lexchar != '"') {
  709. if (J->lexchar == EOF)
  710. jsY_error(J, "unterminated string");
  711. else if (J->lexchar < 32)
  712. jsY_error(J, "invalid control character in string");
  713. else if (jsY_accept(J, '\\'))
  714. lexjsonescape(J);
  715. else {
  716. textpush(J, J->lexchar);
  717. jsY_next(J);
  718. }
  719. }
  720. jsY_expect(J, '"');
  721. s = textend(J);
  722. J->text = s;
  723. return TK_STRING;
  724. }
  725. int jsY_lexjson(js_State *J)
  726. {
  727. while (1) {
  728. J->lexline = J->line; /* save location of beginning of token */
  729. while (jsY_iswhite(J->lexchar) || J->lexchar == '\n')
  730. jsY_next(J);
  731. if ((J->lexchar >= '0' && J->lexchar <= '9') || J->lexchar == '-')
  732. return lexjsonnumber(J);
  733. switch (J->lexchar) {
  734. case ',': jsY_next(J); return ',';
  735. case ':': jsY_next(J); return ':';
  736. case '[': jsY_next(J); return '[';
  737. case ']': jsY_next(J); return ']';
  738. case '{': jsY_next(J); return '{';
  739. case '}': jsY_next(J); return '}';
  740. case '"':
  741. jsY_next(J);
  742. return lexjsonstring(J);
  743. case 'f':
  744. jsY_next(J); jsY_expect(J, 'a'); jsY_expect(J, 'l'); jsY_expect(J, 's'); jsY_expect(J, 'e');
  745. return TK_FALSE;
  746. case 'n':
  747. jsY_next(J); jsY_expect(J, 'u'); jsY_expect(J, 'l'); jsY_expect(J, 'l');
  748. return TK_NULL;
  749. case 't':
  750. jsY_next(J); jsY_expect(J, 'r'); jsY_expect(J, 'u'); jsY_expect(J, 'e');
  751. return TK_TRUE;
  752. case EOF:
  753. return 0; /* EOF */
  754. }
  755. if (J->lexchar >= 0x20 && J->lexchar <= 0x7E)
  756. jsY_error(J, "unexpected character: '%c'", J->lexchar);
  757. jsY_error(J, "unexpected character: \\u%04X", J->lexchar);
  758. }
  759. }