jslex.c 20 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905
  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 iscontrolparen(int token)
  400. {
  401. return token == TK_IF || token == TK_WHILE || token == TK_FOR ||
  402. token == TK_WITH || token == TK_SWITCH || token == TK_CATCH;
  403. }
  404. static int isregexpcontext(js_State *J)
  405. {
  406. int last = J->lasttoken;
  407. /* A ')' that closed a control head starts a statement, so a regex
  408. * literal may follow it (`for (...) /re/.test(x)`). */
  409. if (last == ')')
  410. return J->last_paren_control;
  411. switch (last) {
  412. case ']':
  413. case ')':
  414. case '}':
  415. case TK_IDENTIFIER:
  416. case TK_NUMBER:
  417. case TK_STRING:
  418. case TK_FALSE:
  419. case TK_NULL:
  420. case TK_THIS:
  421. case TK_TRUE:
  422. return 0;
  423. default:
  424. return 1;
  425. }
  426. }
  427. static int lexregexp(js_State *J)
  428. {
  429. const char *s;
  430. int g, m, i, flags;
  431. int inclass = 0;
  432. /* already consumed initial '/' */
  433. textinit(J);
  434. /* regexp body */
  435. while (J->lexchar != '/' || inclass) {
  436. if (J->lexchar == EOF || J->lexchar == '\n') {
  437. jsY_error(J, "regular expression not terminated");
  438. } else if (jsY_accept(J, '\\')) {
  439. if (jsY_accept(J, '/')) {
  440. textpush(J, '/');
  441. } else {
  442. textpush(J, '\\');
  443. if (J->lexchar == EOF || J->lexchar == '\n')
  444. jsY_error(J, "regular expression not terminated");
  445. textpush(J, J->lexchar);
  446. jsY_next(J);
  447. }
  448. } else {
  449. if (J->lexchar == '[' && !inclass)
  450. inclass = 1;
  451. if (J->lexchar == ']' && inclass)
  452. inclass = 0;
  453. textpush(J, J->lexchar);
  454. jsY_next(J);
  455. }
  456. }
  457. jsY_expect(J, '/');
  458. s = textend(J);
  459. /* regexp flags */
  460. g = i = m = 0;
  461. while (jsY_isidentifierpart(J->lexchar)) {
  462. if (jsY_accept(J, 'g')) ++g;
  463. else if (jsY_accept(J, 'i')) ++i;
  464. else if (jsY_accept(J, 'm')) ++m;
  465. else jsY_error(J, "illegal flag in regular expression: %c", J->lexchar);
  466. }
  467. if (g > 1 || i > 1 || m > 1)
  468. jsY_error(J, "duplicated flag in regular expression");
  469. J->text = s;
  470. flags = 0;
  471. if (g) flags |= JS_REGEXP_G;
  472. if (i) flags |= JS_REGEXP_I;
  473. if (m) flags |= JS_REGEXP_M;
  474. J->number = flags;
  475. return TK_REGEXP;
  476. }
  477. /* simple "return [no Line Terminator here] ..." contexts */
  478. static int isnlthcontext(int last)
  479. {
  480. switch (last) {
  481. case TK_BREAK:
  482. case TK_CONTINUE:
  483. case TK_RETURN:
  484. case TK_THROW:
  485. return 1;
  486. default:
  487. return 0;
  488. }
  489. }
  490. static int jsY_lexx(js_State *J)
  491. {
  492. J->newline = 0;
  493. while (1) {
  494. J->lexline = J->line; /* save location of beginning of token */
  495. while (jsY_iswhite(J->lexchar))
  496. jsY_next(J);
  497. if (jsY_accept(J, '\n')) {
  498. J->newline = 1;
  499. if (isnlthcontext(J->lasttoken))
  500. return ';';
  501. continue;
  502. }
  503. if (jsY_accept(J, '/')) {
  504. if (jsY_accept(J, '/')) {
  505. lexlinecomment(J);
  506. continue;
  507. } else if (jsY_accept(J, '*')) {
  508. if (lexcomment(J))
  509. jsY_error(J, "multi-line comment not terminated");
  510. continue;
  511. } else if (isregexpcontext(J)) {
  512. return lexregexp(J);
  513. } else if (jsY_accept(J, '=')) {
  514. return TK_DIV_ASS;
  515. } else {
  516. return '/';
  517. }
  518. }
  519. if (J->lexchar >= '0' && J->lexchar <= '9') {
  520. return lexnumber(J);
  521. }
  522. switch (J->lexchar) {
  523. case '(':
  524. if (J->paren_top < nelem(J->paren_control))
  525. J->paren_control[J->paren_top++] =
  526. iscontrolparen(J->lasttoken);
  527. jsY_next(J);
  528. return '(';
  529. case ')':
  530. J->last_paren_control = J->paren_top > 0 ?
  531. J->paren_control[--J->paren_top] : 0;
  532. jsY_next(J);
  533. return ')';
  534. case ',': jsY_next(J); return ',';
  535. case ':': jsY_next(J); return ':';
  536. case ';': jsY_next(J); return ';';
  537. case '?': jsY_next(J); return '?';
  538. case '[': jsY_next(J); return '[';
  539. case ']': jsY_next(J); return ']';
  540. case '{': jsY_next(J); return '{';
  541. case '}': jsY_next(J); return '}';
  542. case '~': jsY_next(J); return '~';
  543. case '\'':
  544. case '"':
  545. return lexstring(J);
  546. case '.':
  547. return lexnumber(J);
  548. case '<':
  549. jsY_next(J);
  550. if (jsY_accept(J, '<')) {
  551. if (jsY_accept(J, '='))
  552. return TK_SHL_ASS;
  553. return TK_SHL;
  554. }
  555. if (jsY_accept(J, '='))
  556. return TK_LE;
  557. return '<';
  558. case '>':
  559. jsY_next(J);
  560. if (jsY_accept(J, '>')) {
  561. if (jsY_accept(J, '>')) {
  562. if (jsY_accept(J, '='))
  563. return TK_USHR_ASS;
  564. return TK_USHR;
  565. }
  566. if (jsY_accept(J, '='))
  567. return TK_SHR_ASS;
  568. return TK_SHR;
  569. }
  570. if (jsY_accept(J, '='))
  571. return TK_GE;
  572. return '>';
  573. case '=':
  574. jsY_next(J);
  575. if (jsY_accept(J, '=')) {
  576. if (jsY_accept(J, '='))
  577. return TK_STRICTEQ;
  578. return TK_EQ;
  579. }
  580. return '=';
  581. case '!':
  582. jsY_next(J);
  583. if (jsY_accept(J, '=')) {
  584. if (jsY_accept(J, '='))
  585. return TK_STRICTNE;
  586. return TK_NE;
  587. }
  588. return '!';
  589. case '+':
  590. jsY_next(J);
  591. if (jsY_accept(J, '+'))
  592. return TK_INC;
  593. if (jsY_accept(J, '='))
  594. return TK_ADD_ASS;
  595. return '+';
  596. case '-':
  597. jsY_next(J);
  598. if (jsY_accept(J, '-'))
  599. return TK_DEC;
  600. if (jsY_accept(J, '='))
  601. return TK_SUB_ASS;
  602. return '-';
  603. case '*':
  604. jsY_next(J);
  605. if (jsY_accept(J, '='))
  606. return TK_MUL_ASS;
  607. return '*';
  608. case '%':
  609. jsY_next(J);
  610. if (jsY_accept(J, '='))
  611. return TK_MOD_ASS;
  612. return '%';
  613. case '&':
  614. jsY_next(J);
  615. if (jsY_accept(J, '&'))
  616. return TK_AND;
  617. if (jsY_accept(J, '='))
  618. return TK_AND_ASS;
  619. return '&';
  620. case '|':
  621. jsY_next(J);
  622. if (jsY_accept(J, '|'))
  623. return TK_OR;
  624. if (jsY_accept(J, '='))
  625. return TK_OR_ASS;
  626. return '|';
  627. case '^':
  628. jsY_next(J);
  629. if (jsY_accept(J, '='))
  630. return TK_XOR_ASS;
  631. return '^';
  632. case EOF:
  633. return 0; /* EOF */
  634. }
  635. /* Handle \uXXXX escapes in identifiers */
  636. jsY_unescape(J);
  637. if (jsY_isidentifierstart(J->lexchar)) {
  638. textinit(J);
  639. textpush(J, J->lexchar);
  640. jsY_next(J);
  641. jsY_unescape(J);
  642. while (jsY_isidentifierpart(J->lexchar)) {
  643. textpush(J, J->lexchar);
  644. jsY_next(J);
  645. jsY_unescape(J);
  646. }
  647. textend(J);
  648. return jsY_findkeyword(J, J->lexbuf.text);
  649. }
  650. if (J->lexchar >= 0x20 && J->lexchar <= 0x7E)
  651. jsY_error(J, "unexpected character: '%c'", J->lexchar);
  652. jsY_error(J, "unexpected character: \\u%04X", J->lexchar);
  653. }
  654. }
  655. void jsY_initlex(js_State *J, const char *filename, const char *source)
  656. {
  657. J->filename = filename;
  658. J->source = source;
  659. J->line = 1;
  660. J->lasttoken = 0;
  661. J->paren_top = 0;
  662. J->last_paren_control = 0;
  663. jsY_next(J); /* load first lookahead character */
  664. }
  665. int jsY_lex(js_State *J)
  666. {
  667. return J->lasttoken = jsY_lexx(J);
  668. }
  669. static int lexjsonnumber(js_State *J)
  670. {
  671. const char *s = J->source - 1;
  672. if (J->lexchar == '-')
  673. jsY_next(J);
  674. if (J->lexchar == '0')
  675. jsY_next(J);
  676. else if (J->lexchar >= '1' && J->lexchar <= '9')
  677. while (isdigit(J->lexchar))
  678. jsY_next(J);
  679. else
  680. jsY_error(J, "unexpected non-digit");
  681. if (jsY_accept(J, '.')) {
  682. if (isdigit(J->lexchar))
  683. while (isdigit(J->lexchar))
  684. jsY_next(J);
  685. else
  686. jsY_error(J, "missing digits after decimal point");
  687. }
  688. if (jsY_accept(J, 'e') || jsY_accept(J, 'E')) {
  689. if (J->lexchar == '-' || J->lexchar == '+')
  690. jsY_next(J);
  691. if (isdigit(J->lexchar))
  692. while (isdigit(J->lexchar))
  693. jsY_next(J);
  694. else
  695. jsY_error(J, "missing digits after exponent indicator");
  696. }
  697. J->number = js_strtod(s, NULL);
  698. return TK_NUMBER;
  699. }
  700. static int lexjsonescape(js_State *J)
  701. {
  702. int x = 0;
  703. /* already consumed '\' */
  704. switch (J->lexchar) {
  705. default: jsY_error(J, "invalid escape sequence");
  706. case 'u':
  707. jsY_next(J);
  708. if (!jsY_ishex(J->lexchar)) return 1; else { x |= jsY_tohex(J->lexchar) << 12; jsY_next(J); }
  709. if (!jsY_ishex(J->lexchar)) return 1; else { x |= jsY_tohex(J->lexchar) << 8; jsY_next(J); }
  710. if (!jsY_ishex(J->lexchar)) return 1; else { x |= jsY_tohex(J->lexchar) << 4; jsY_next(J); }
  711. if (!jsY_ishex(J->lexchar)) return 1; else { x |= jsY_tohex(J->lexchar); jsY_next(J); }
  712. textpush(J, x);
  713. break;
  714. case '"': textpush(J, '"'); jsY_next(J); break;
  715. case '\\': textpush(J, '\\'); jsY_next(J); break;
  716. case '/': textpush(J, '/'); jsY_next(J); break;
  717. case 'b': textpush(J, '\b'); jsY_next(J); break;
  718. case 'f': textpush(J, '\f'); jsY_next(J); break;
  719. case 'n': textpush(J, '\n'); jsY_next(J); break;
  720. case 'r': textpush(J, '\r'); jsY_next(J); break;
  721. case 't': textpush(J, '\t'); jsY_next(J); break;
  722. }
  723. return 0;
  724. }
  725. static int lexjsonstring(js_State *J)
  726. {
  727. const char *s;
  728. textinit(J);
  729. while (J->lexchar != '"') {
  730. if (J->lexchar == EOF)
  731. jsY_error(J, "unterminated string");
  732. else if (J->lexchar < 32)
  733. jsY_error(J, "invalid control character in string");
  734. else if (jsY_accept(J, '\\'))
  735. lexjsonescape(J);
  736. else {
  737. textpush(J, J->lexchar);
  738. jsY_next(J);
  739. }
  740. }
  741. jsY_expect(J, '"');
  742. s = textend(J);
  743. J->text = s;
  744. return TK_STRING;
  745. }
  746. int jsY_lexjson(js_State *J)
  747. {
  748. while (1) {
  749. J->lexline = J->line; /* save location of beginning of token */
  750. while (jsY_iswhite(J->lexchar) || J->lexchar == '\n')
  751. jsY_next(J);
  752. if ((J->lexchar >= '0' && J->lexchar <= '9') || J->lexchar == '-')
  753. return lexjsonnumber(J);
  754. switch (J->lexchar) {
  755. case ',': jsY_next(J); return ',';
  756. case ':': jsY_next(J); return ':';
  757. case '[': jsY_next(J); return '[';
  758. case ']': jsY_next(J); return ']';
  759. case '{': jsY_next(J); return '{';
  760. case '}': jsY_next(J); return '}';
  761. case '"':
  762. jsY_next(J);
  763. return lexjsonstring(J);
  764. case 'f':
  765. jsY_next(J); jsY_expect(J, 'a'); jsY_expect(J, 'l'); jsY_expect(J, 's'); jsY_expect(J, 'e');
  766. return TK_FALSE;
  767. case 'n':
  768. jsY_next(J); jsY_expect(J, 'u'); jsY_expect(J, 'l'); jsY_expect(J, 'l');
  769. return TK_NULL;
  770. case 't':
  771. jsY_next(J); jsY_expect(J, 'r'); jsY_expect(J, 'u'); jsY_expect(J, 'e');
  772. return TK_TRUE;
  773. case EOF:
  774. return 0; /* EOF */
  775. }
  776. if (J->lexchar >= 0x20 && J->lexchar <= 0x7E)
  777. jsY_error(J, "unexpected character: '%c'", J->lexchar);
  778. jsY_error(J, "unexpected character: \\u%04X", J->lexchar);
  779. }
  780. }