PageRenderTime 172ms CodeModel.GetById 19ms RepoModel.GetById 0ms app.codeStats 0ms

/src/lexer.h

http://github.com/pikelang/Pike
C Header | 1418 lines | 1201 code | 114 blank | 103 comment | 238 complexity | efc8c75249da8ae34c99b957fe48109c MD5 | raw file
Possible License(s): LGPL-2.1, MPL-2.0-no-copyleft-exception 
    

  1. /*
    2. 

  2. || This file is part of Pike. For copyright information see COPYRIGHT.
    3. 

  3. || Pike is distributed under GPL, LGPL and MPL. See the file COPYING
    4. 

  4. || for more information.
    5. 

  5. */
    6. 

  6. 

  7. /*
    8. 

  8.  * Lexical analyzer template.
    9. 

  9.  */
    10. 

  10. 

  11. #ifndef SHIFT
    12. 

  12. #error Internal error: SHIFT not defined
    13. 

  13. #endif
    14. 

  14. 

  15. /*
    16. 

  16.  * Definitions
    17. 

  17.  */
    18. 

  18. 

  19. /* Generic */
    20. 

  20. #define GOBBLE(c) (LOOK()==c?(SKIP(),1):0)
    21. 

  21. #define SKIPSPACE() do { while(wide_isspace(LOOK()) && LOOK()!='\n') SKIP(); }while(0)
    22. 

  22. #define SKIPWHITE() do { while(wide_isspace(LOOK())) SKIP(); }while(0)
    23. 

  23. #define SKIPUPTO(X) do { while(LOOK()!=(X) && LOOK()) SKIP(); }while(0)
    24. 

  24. 

  25. #if (SHIFT == 0)
    26. 

  26. 

  27. #define WCHAR p_wchar0
    28. 

  28. 

  29. #define LOOK() EXTRACT_UCHAR(lex->pos)
    30. 

  30. #define GETC() EXTRACT_UCHAR(lex->pos++)
    31. 

  31. #define SKIP() lex->pos++
    32. 

  32. #define SKIPN(N) (lex->pos += (N))
    33. 

  33. 

  34. #define READBUF(X) do {				\
    35. 

  35.   int C;				\
    36. 

  36.   buf = lex->pos;				\
    37. 

  37.   while((C = LOOK()) && (X))			\
    38. 

  38.     lex->pos++;					\
    39. 

  39.   len = (size_t)(lex->pos - buf);		\
    40. 

  40. } while(0)
    41. 

  41. 

  42. #define TWO_CHAR(X,Y) ((X)<<8)+(Y)
    43. 

  43. #define ISWORD(X) ((len == CONSTANT_STRLEN(X)) && !memcmp(buf,X,len))
    44. 

  44. 

  45. /*
    46. 

  46.  * Function renaming
    47. 

  47.  */
    48. 

  48. 

  49. #define parse_esc_seq parse_esc_seq0
    50. 

  50. #define yylex yylex0
    51. 

  51. #define low_yylex low_yylex0
    52. 

  52. #define lex_atoi atoi
    53. 

  53. #define lex_strtol strtol
    54. 

  54. #define lex_strtod my_strtod
    55. 

  55. #define lex_isidchar isidchar
    56. 

  56. 

  57. #else /* SHIFT != 0 */
    58. 

  58. 

  59. #define LOOK() INDEX_CHARP(lex->pos,0,SHIFT)
    60. 

  60. #define SKIP() (lex->pos += (1<<SHIFT))
    61. 

  61. #define SKIPN(N) (lex->pos += (N) < 0 ? -(-(N) << SHIFT) : ((N)<<SHIFT))
    62. 

  62. #define GETC() (SKIP(),INDEX_CHARP(lex->pos-(1<<SHIFT),0,SHIFT))
    63. 

  63. 

  64. #define READBUF(X) do {				\
    65. 

  65.   int C;                                        \
    66. 

  66.   buf = lex->pos;				\
    67. 

  67.   while((C = LOOK()) && (X))			\
    68. 

  68.     SKIP();					\
    69. 

  69.   len = (size_t)((lex->pos - buf) >> SHIFT);	\
    70. 

  70. } while(0)
    71. 

  71. 

  72. #define TWO_CHAR(X,Y) ((X)<<8)+(Y)
    73. 

  73. 

  74. #define ISWORD(X) ((len == strlen(X)) && low_isword(buf, X, len))
    75. 

  75. 

  76. #if (SHIFT == 1)
    77. 

  77. 

  78. #define WCHAR p_wchar1
    79. 

  79. 

  80. /* Function renaming */
    81. 

  81. #define low_isword low_isword1
    82. 

  82. #define parse_esc_seq parse_esc_seq1
    83. 

  83. #define char_const char_const1
    84. 

  84. #define readstring readstring1
    85. 

  85. #define yylex yylex1
    86. 

  86. #define low_yylex low_yylex1
    87. 

  87. #define lex_atoi lex_atoi1
    88. 

  88. #define lex_strtol lex_strtol1
    89. 

  89. #define lex_strtod lex_strtod1
    90. 

  90. 

  91. #else /* SHIFT != 1 */
    92. 

  92. 

  93. #define WCHAR p_wchar2
    94. 

  94. 

  95. /* Function renaming */
    96. 

  96. #define low_isword low_isword2
    97. 

  97. #define parse_esc_seq parse_esc_seq2
    98. 

  98. #define char_const char_const2
    99. 

  99. #define readstring readstring2
    100. 

  100. #define yylex yylex2
    101. 

  101. #define low_yylex low_yylex2
    102. 

  102. #define lex_atoi lex_atoi2
    103. 

  103. #define lex_strtol lex_strtol2
    104. 

  104. #define lex_strtod lex_strtod2
    105. 

  105. 

  106. #endif /* SHIFT == 1 */
    107. 

  107. 

  108. 

  109. #define lex_isidchar(X) wide_isidchar(X)
    110. 

  110. 

  111. static int low_isword(char *buf, char *X, size_t len)
    112. 

  112. {
    113. 

  113.   while(len--) {
    114. 

  114.     if (INDEX_CHARP(buf, len, SHIFT) != ((unsigned char *)X)[len]) {
    115. 

  115.       return 0;
    116. 

  116.     }
    117. 

  117.   }
    118. 

  118.   return 1;
    119. 

  119. }
    120. 

  120. 

  121. static int lex_atoi(char *buf)
    122. 

  122. {
    123. 

  123.   /* NOTE: Cuts at 63 digits */
    124. 

  124.   char buff[64];
    125. 

  125.   int i=0;
    126. 

  126.   int c;
    127. 

  127. 

  128.   while(((c = INDEX_CHARP(buf, i, SHIFT))>='0') && (c <= '9') && (i < 63)) {
    129. 

  129.     buff[i++] = c;
    130. 

  130.   }
    131. 

  131.   buff[i] = 0;
    132. 

  132.   return atoi(buff);
    133. 

  133. }
    134. 

  134. 

  135. static long lex_strtol(char *buf, char **end, int base)
    136. 

  136. {
    137. 

  137.   PCHARP foo;
    138. 

  138.   long ret;
    139. 

  139.   ret=STRTOL_PCHARP(MKPCHARP(buf,SHIFT),&foo,base);
    140. 

  140.   if(end) end[0]=(char *)foo.ptr;
    141. 

  141.   return ret;
    142. 

  142. }
    143. 

  143. 

  144. static FLOAT_TYPE lex_strtod(char *buf, char **end)
    145. 

  145. {
    146. 

  146.   PCHARP foo;
    147. 

  147. #if SIZEOF_FLOAT_TYPE > SIZEOF_DOUBLE
    148. 

  148.   FLOAT_TYPE ret;
    149. 

  149.   ret=STRTOLD_PCHARP(MKPCHARP(buf,SHIFT),&foo);
    150. 

  150. #else
    151. 

  151.   double ret;
    152. 

  152.   ret=STRTOD_PCHARP(MKPCHARP(buf,SHIFT),&foo);
    153. 

  153. #endif
    154. 

  154.   if(end) end[0]=(char *)foo.ptr;
    155. 

  155.   return ret;
    156. 

  156. }
    157. 

  157. 

  158. #endif /* SHIFT == 0 */
    159. 

  159. 

  160. 

  161. /*** Lexical analyzing ***/
    162. 

  162. 

  163. /* String escape sequences
    164. 

  164.  *
    165. 

  165.  * Sequence		Character
    166. 

  166.  *   \\			backslash
    167. 

  167.  *   \[0-7]*		octal escape
    168. 

  168.  *   \a			alert (BEL)
    169. 

  169.  *   \b			backspace (BS)
    170. 

  170.  *   \d[0-9]*		decimal escape
    171. 

  171.  *   \e			escape (ESC)
    172. 

  172.  *   \f			form-feed (FF)
    173. 

  173.  *   \n			newline (LF)
    174. 

  174.  *   \r			carriage-return (CR)
    175. 

  175.  *   \t			tab (HT)
    176. 

  176.  *   \v			vertical-tab (VT)
    177. 

  177.  *   \x[0-9a-fA-F]*	hexadecimal escape
    178. 

  178.  *   \u+[0-9a-fA-F]{4,4} 16 bit unicode style escape
    179. 

  179.  *   \U+[0-9a-fA-F]{8,8} 32 bit unicode style escape
    180. 

  180.  *
    181. 

  181.  * If there are more than one u or U in the unicode style escapes, one
    182. 

  182.  * is removed and the escape remains otherwise intact.
    183. 

  183.  */
    184. 

  184. 

  185. int parse_esc_seq (WCHAR *buf, p_wchar2 *chr, ptrdiff_t *len)
    186. 

  186. /* buf is assumed to be after the backslash. Return codes:
    187. 

  187.  * 0: All ok. The char's in *chr, consumed length in *len.
    188. 

  188.  * 1: Found a literal \r at *buf.
    189. 

  189.  * 2: Found a literal \n at *buf.
    190. 

  190.  * 3: Found a literal \0 at *buf.
    191. 

  191.  * 4: Too large octal escape. *len is gobbled to the end of it all.
    192. 

  192.  * 5: Too large hexadecimal escape. *len is gobbled to the end of it all.
    193. 

  193.  * 6: Too large decimal escape. *len is gobbled to the end of it all.
    194. 

  194.  * 7: Not 4 digits in \u escape. *len is up to the last found digit.
    195. 

  195.  * 8: Not 8 digits in \U escape. *len is up to the last found digit. */
    196. 

  196. {
    197. 

  197.   ptrdiff_t l = 1;
    198. 

  198.   p_wchar2 c;
    199. 

  199.   int of = 0;
    200. 

  200. 

  201.   switch ((c = *buf))
    202. 

  202.   {
    203. 

  203.     case '\r': return 1;
    204. 

  204.     case '\n': return 2;
    205. 

  205.     case 0: return 3;
    206. 

  206. 

  207.     case 'a': c = 7; break;	/* BEL */
    208. 

  208.     case 'b': c = 8; break;	/* BS */
    209. 

  209.     case 't': c = 9; break;	/* HT */
    210. 

  210.     case 'n': c = 10; break;	/* LF */
    211. 

  211.     case 'v': c = 11; break;	/* VT */
    212. 

  212.     case 'f': c = 12; break;	/* FF */
    213. 

  213.     case 'r': c = 13; break;	/* CR */
    214. 

  214.     case 'e': c = 27; break;	/* ESC */
    215. 

  215. 

  216.     case '0': case '1': case '2': case '3':
    217. 

  217.     case '4': case '5': case '6': case '7': {
    218. 

  218.       unsigned INT32 n = c-'0';
    219. 

  219.       for (l = 1; buf[l] >= '0' && buf[l] < '8'; l++) {
    220. 

  220. 	if (DO_UINT32_MUL_OVERFLOW(n, 8, &n))
    221. 

  221. 	  of = 1;
    222. 

  222. 	else
    223. 

  223. 	  n += buf[l] - '0';
    224. 

  224.       }
    225. 

  225.       if (of) {
    226. 

  226. 	*len = l;
    227. 

  227. 	return 4;
    228. 

  228.       }
    229. 

  229.       c = (p_wchar2)n;
    230. 

  230.       break;
    231. 

  231.     }
    232. 

  232. 

  233.     case '8': case '9':
    234. 

  234.       if( Pike_compiler->compiler_pass == COMPILER_PASS_FIRST )
    235. 

  235. 	yywarning("%c is not a valid octal digit.", c);
    236. 

  236.       break;
    237. 

  237. 

  238.     case 'x': {
    239. 

  239.       unsigned INT32 n=0;
    240. 

  240.       for (l = 1;; l++) {
    241. 

  241. 	switch (buf[l]) {
    242. 

  242. 	  case '0': case '1': case '2': case '3': case '4':
    243. 

  243. 	  case '5': case '6': case '7': case '8': case '9':
    244. 

  244. 	    if (DO_UINT32_MUL_OVERFLOW(n, 16, &n))
    245. 

  245. 	      of = 1;
    246. 

  246.             else
    247. 

  247. 	      n += buf[l] - '0';
    248. 

  248. 	    continue;
    249. 

  249. 	  case 'a': case 'b': case 'c': case 'd': case 'e': case 'f':
    250. 

  250. 	    if (DO_UINT32_MUL_OVERFLOW(n, 16, &n))
    251. 

  251. 	      of = 1;
    252. 

  252.             else
    253. 

  253. 	      n += buf[l] - 'a' + 10;
    254. 

  254. 	    continue;
    255. 

  255. 	  case 'A': case 'B': case 'C': case 'D': case 'E': case 'F':
    256. 

  256. 	    if (DO_UINT32_MUL_OVERFLOW(n, 16, &n))
    257. 

  257. 	      of = 1;
    258. 

  258.             else
    259. 

  259. 	      n += buf[l] - 'A' + 10;
    260. 

  260. 	    continue;
    261. 

  261. 	}
    262. 

  262. 	break;
    263. 

  263.       }
    264. 

  264.       if (of) {
    265. 

  265. 	*len = l;
    266. 

  266. 	return 5;
    267. 

  267.       }
    268. 

  268.       c = (p_wchar2)n;
    269. 

  269.       break;
    270. 

  270.     }
    271. 

  271. 

  272.     case 'd': {
    273. 

  273.       unsigned INT32 n=0;
    274. 

  274.       for (l = 1;; l++) {
    275. 

  275. 	switch (buf[l]) {
    276. 

  276. 	  case '0': case '1': case '2': case '3': case '4':
    277. 

  277. 	  case '5': case '6': case '7': case '8': case '9':
    278. 

  278. 	    if (DO_UINT32_MUL_OVERFLOW(n, 10, &n) || DO_UINT32_ADD_OVERFLOW(n, buf[l] - '0', &n)) {
    279. 

  279. 	      of = 1;
    280. 

  280.             }
    281. 

  281. 	    continue;
    282. 

  282. 	}
    283. 

  283. 	break;
    284. 

  284.       }
    285. 

  285.       if (of) {
    286. 

  286. 	*len = l;
    287. 

  287. 	return 6;
    288. 

  288.       }
    289. 

  289.       c = (p_wchar2)n;
    290. 

  290.       break;
    291. 

  291.     }
    292. 

  292. 

  293.     case 'u':
    294. 

  294.     case 'U': {
    295. 

  295.       /* FIXME: Do we need compat goo to turn this off? */
    296. 

  296.       /* Note: Code dup in gobble_identifier in preprocessor.h. */
    297. 

  297.       unsigned INT32 n = 0;
    298. 

  298.       int stop, longq;
    299. 

  299.       l = 1;
    300. 

  300.       if (buf[1] == c) {
    301. 

  301. 	/* A double-u quoted escape. Convert the "\u" or "\U" to "\",
    302. 

  302. 	 * thereby shaving off a "u" or "U" from the escape
    303. 

  303. 	 * sequence. */
    304. 

  304. 	/* Don't check that there's a valid number of hex digits in
    305. 

  305. 	 * this case, since the encoding code that can produce them
    306. 

  306. 	 * doesn't check that. */
    307. 

  307. 	c = '\\';
    308. 

  308. 	break;
    309. 

  309.       }
    310. 

  310.       if (c == 'u') {
    311. 

  311. 	stop = l + 4;
    312. 

  312. 	longq = 0;
    313. 

  313.       }
    314. 

  314.       else {
    315. 

  315. 	stop = l + 8;
    316. 

  316. 	longq = 1;
    317. 

  317.       }
    318. 

  318.       for (; l < stop; l++)
    319. 

  319. 	switch (buf[l]) {
    320. 

  320. 	  case '0': case '1': case '2': case '3': case '4':
    321. 

  321. 	  case '5': case '6': case '7': case '8': case '9':
    322. 

  322. 	    n = 16 * n + buf[l] - '0';
    323. 

  323. 	    break;
    324. 

  324. 	  case 'a': case 'b': case 'c': case 'd': case 'e': case 'f':
    325. 

  325. 	    n = 16 * n + buf[l] - 'a' + 10;
    326. 

  326. 	    break;
    327. 

  327. 	  case 'A': case 'B': case 'C': case 'D': case 'E': case 'F':
    328. 

  328. 	    n = 16 * n + buf[l] - 'A' + 10;
    329. 

  329. 	    break;
    330. 

  330. 	  default:
    331. 

  331. 	    *len = l;
    332. 

  332. 	    return longq ? 8 : 7;
    333. 

  333. 	}
    334. 

  334.       c = (p_wchar2)n;
    335. 

  335.       break;
    336. 

  336.     }
    337. 

  337.   case '\\': case '\'': case '\"':
    338. 

  338.     break;
    339. 

  339.   default:
    340. 

  340.     /* Warn about this as it is commonly due to broken escaping,
    341. 

  341.      * and to be forward compatible with adding future new escapes.
    342. 

  342.      */
    343. 

  343.     if (Pike_compiler->compiler_pass == COMPILER_PASS_FIRST) {
    344. 

  344.       yywarning("Redundant backslash-escape: \'\\%c\'.", c);
    345. 

  345.     }
    346. 

  346.     break;
    347. 

  347.   }
    348. 

  348. 

  349.   *len = l;
    350. 

  350.   *chr = c;
    351. 

  351.   return 0;
    352. 

  352. }
    353. 

  353. 

  354. static p_wchar2 char_const(struct lex *lex)
    355. 

  355. {
    356. 

  356.   p_wchar2 c;
    357. 

  357.   ptrdiff_t l;
    358. 

  358.   switch (parse_esc_seq ((WCHAR *)lex->pos, &c, &l)) {
    359. 

  359.     case 0:
    360. 

  360.       break;
    361. 

  361.     case 1:
    362. 

  362.       SKIP();
    363. 

  363.       return '\r';
    364. 

  364.     case 2:
    365. 

  365.       SKIP();
    366. 

  366.       lex->current_line++;
    367. 

  367.       return '\n';
    368. 

  368.     case 3:
    369. 

  369.       yyerror("Unexpected end of file.");
    370. 

  370.       lex->pos -= (1<<SHIFT);
    371. 

  371.       return 0;
    372. 

  372.     case 4: case 5: case 6:
    373. 

  373.       if( Pike_compiler->compiler_pass == COMPILER_PASS_FIRST )
    374. 

  374.         yyerror ("Too large character value in escape.");
    375. 

  375.       c = -1;
    376. 

  376.       break;
    377. 

  377.     case 7:
    378. 

  378.       if( Pike_compiler->compiler_pass == COMPILER_PASS_FIRST )
    379. 

  379.         yyerror ("Too few hex digits in \\u escape.");
    380. 

  380.       return '\\';
    381. 

  381.     case 8:
    382. 

  382.       if( Pike_compiler->compiler_pass == COMPILER_PASS_FIRST )
    383. 

  383.         yyerror ("Too few hex digits in \\U escape.");
    384. 

  384.       return '\\';
    385. 

  385.   }
    386. 

  386.   SKIPN (l);
    387. 

  387.   return c;
    388. 

  388. }
    389. 

  389. 

  390. static struct pike_string *readstring(struct lex *lex)
    391. 

  391. {
    392. 

  392.   int c;
    393. 

  393.   struct string_builder tmp;
    394. 

  394. #if (SHIFT != 0)
    395. 

  395.   PCHARP bufptr = { NULL, SHIFT };
    396. 

  396. #endif /* SHIFT != 0 */
    397. 

  397. 

  398.   init_string_builder(&tmp,0);
    399. 

  399. 

  400.   while(1)
    401. 

  401.   {
    402. 

  402.     char *buf;
    403. 

  403.     size_t len;
    404. 

  404. 

  405.     READBUF(((C > '\\') ||
    406. 

  406. 	     ((C != '"') && (C != '\\') && (C != '\n') && (C != '\r'))));
    407. 

  407.     if (len) {
    408. 

  408. #if (SHIFT == 0)
    409. 

  409.       string_builder_binary_strcat(&tmp, buf, len);
    410. 

  410. #else /* SHIFT != 0 */
    411. 

  411.       bufptr.ptr = (p_wchar0 *)buf;
    412. 

  412.       string_builder_append(&tmp, bufptr, len);
    413. 

  413. #endif /* SHIFT == 0 */
    414. 

  414.     }
    415. 

  415.     switch(c=GETC())
    416. 

  416.     {
    417. 

  417.     case 0:
    418. 

  418.       lex->pos -= (1<<SHIFT);
    419. 

  419.       yyerror("End of file in string.");
    420. 

  420.       break;
    421. 

  421. 

  422.     case '\n': case '\r':
    423. 

  423.       lex->current_line++;
    424. 

  424.       yyerror("Newline in string.");
    425. 

  425.       break;
    426. 

  426. 

  427.     case '\\':
    428. 

  428.       string_builder_putchar(&tmp, char_const(lex));
    429. 

  429.       continue;
    430. 

  430. 

  431.     case '"':
    432. 

  432.       break;
    433. 

  433. 

  434.     default:
    435. 

  435. #ifdef PIKE_DEBUG
    436. 

  436.       Pike_fatal("Default case in readstring() reached. c:%d\n", c);
    437. 

  437. #endif /* PIKE_DEBUG */
    438. 

  438.       break;
    439. 

  439.     }
    440. 

  440.     break;
    441. 

  441.   }
    442. 

  442.   return dmalloc_touch(struct pike_string *, finish_string_builder(&tmp));
    443. 

  443. }
    444. 

  444. 

  445. 

  446. 

  447. #if LEXDEBUG>4
    448. 

  448. static int low_yylex(struct lex *lex, YYSTYPE *);
    449. 

  449. #endif /* LEXDEBUG>4 */
    450. 

  450. int yylex(struct lex *lex, YYSTYPE *yylval)
    451. 

  451. #if LEXDEBUG>4
    452. 

  452. {
    453. 

  453.   int t;
    454. 

  454. #if LEXDEBUG>8
    455. 

  455.   fprintf(stderr, "YYLEX:\n");
    456. 

  456. #endif /* LEXDEBUG>8 */
    457. 

  457. 

  458.   t=low_yylex(lex, yylval);
    459. 

  459.   if(t<256)
    460. 

  460.   {
    461. 

  461.     fprintf(stderr,"YYLEX: '%c' (%d) at %s:%d\n",t,t,lex.current_file->str,lex.current_line);
    462. 

  462.   }else{
    463. 

  463.     fprintf(stderr,"YYLEX: token #%d at %s:%d\n",t,lex.current_file->str,lex.current_line);
    464. 

  464.   }
    465. 

  465.   return t;
    466. 

  466. }
    467. 

  467. 

  468. static int low_yylex(struct lex *lex, YYSTYPE *yylval)
    469. 

  469. #endif /* LEXDEBUG>4 */
    470. 

  470. {
    471. 

  471.   INT32 c;
    472. 

  472.   size_t len;
    473. 

  473.   char *buf;
    474. 

  474. 

  475. #ifdef __CHECKER__
    476. 

  476.   memset(yylval,0,sizeof(YYSTYPE));
    477. 

  477. #endif
    478. 

  478. #ifdef MALLOC_DEBUG
    479. 

  479.   check_sfltable();
    480. 

  480. #endif
    481. 

  481. 

  482.   while(1)
    483. 

  483.   {
    484. 

  484.     c = GETC();
    485. 

  485. 

  486.     if((c>'9') && lex_isidchar(c))
    487. 

  487.     {
    488. 

  488.       lex->pos -= (1<<SHIFT);
    489. 

  489.       READBUF(lex_isidchar(C));
    490. 

  490. 

  491.       PIKE_MEM_WO_RANGE (yylval, sizeof (YYSTYPE));
    492. 

  492. 

  493.       if(len>1 && len<16)
    494. 

  494.       {
    495. 

  495. 	/* NOTE: TWO_CHAR() will generate false positives with wide strings,
    496. 

  496. 	 * but that doesn't matter, since ISWORD() will fix it.
    497. 

  497. 	 */
    498. 

  498. 	switch(TWO_CHAR(INDEX_CHARP(buf, 0, SHIFT),
    499. 

  499. 			INDEX_CHARP(buf, 1, SHIFT)))
    500. 

  500. 	{
    501. 

  501. 	case TWO_CHAR('a','r'):
    502. 

  502. 	  if(ISWORD("array")) return TOK_ARRAY_ID;
    503. 

  503. 	  break;
    504. 

  504. 	case TWO_CHAR('a','w'):
    505. 

  505. 	  if (ISWORD("await")) {
    506. 

  506. 	    if (Pike_compiler->compiler_pass == COMPILER_PASS_FIRST) {
    507. 

  507. 	      yywarning("await will soon be a reserved keyword.");
    508. 

  508. 	    }
    509. 

  509. 	    break;
    510. 

  510. 	  }
    511. 

  511. 	  break;
    512. 

  512. 	case TWO_CHAR('a','u'):
    513. 

  513. 	  if(ISWORD("auto")) return TOK_AUTO_ID;
    514. 

  514. 	  break;
    515. 

  515. 	case TWO_CHAR('b','r'):
    516. 

  516. 	  if(ISWORD("break")) return TOK_BREAK;
    517. 

  517. 	  break;
    518. 

  518. 	case TWO_CHAR('c','a'):
    519. 

  519. 	  if(ISWORD("case")) return TOK_CASE;
    520. 

  520. 	  if(ISWORD("catch")) return TOK_CATCH;
    521. 

  521. 	  break;
    522. 

  522. 	case TWO_CHAR('c','l'):
    523. 

  523. 	  if(ISWORD("class")) return TOK_CLASS;
    524. 

  524. 	  break;
    525. 

  525. 	case TWO_CHAR('c','o'):
    526. 

  526. 	  if(ISWORD("constant")) return TOK_CONSTANT;
    527. 

  527. 	  if(ISWORD("continue")) return TOK_CONTINUE;
    528. 

  528. 	  if(ISWORD("const")) {
    529. 

  529. 	    if (Pike_compiler->compiler_pass == COMPILER_PASS_FIRST) {
    530. 

  530. 	      yywarning("const will soon be a reserved keyword.");
    531. 

  531. 	    }
    532. 

  532. 	    break;
    533. 

  533. 	  }
    534. 

  534. 	  break;
    535. 

  535. 	case TWO_CHAR('d','e'):
    536. 

  536. 	  if(ISWORD("default")) return TOK_DEFAULT;
    537. 

  537. 	  break;
    538. 

  538. 	case TWO_CHAR('d','o'):
    539. 

  539. 	  if(ISWORD("do")) return TOK_DO;
    540. 

  540. 	  break;
    541. 

  541. 	case TWO_CHAR('e','l'):
    542. 

  542. 	  if(ISWORD("else")) return TOK_ELSE;
    543. 

  543. 	  break;
    544. 

  544. 	case TWO_CHAR('e','n'):
    545. 

  545. 	  if(ISWORD("enum")) return TOK_ENUM;
    546. 

  546. 	  break;
    547. 

  547. 	case TWO_CHAR('e','x'):
    548. 

  548. 	  if(ISWORD("extern")) return TOK_EXTERN;
    549. 

  549. 	  break;
    550. 

  550. 	case TWO_CHAR('f','i'):
    551. 

  551. 	  if(ISWORD("final")) return TOK_FINAL_ID;
    552. 

  552. 	  break;
    553. 

  553. 	case TWO_CHAR('f','l'):
    554. 

  554. 	  if(ISWORD("float")) return TOK_FLOAT_ID;
    555. 

  555. 	  break;
    556. 

  556. 	case TWO_CHAR('f','o'):
    557. 

  557. 	  if(ISWORD("for")) return TOK_FOR;
    558. 

  558. 	  if(ISWORD("foreach")) return TOK_FOREACH;
    559. 

  559. 	  break;
    560. 

  560. 	case TWO_CHAR('f','u'):
    561. 

  561. 	  if(ISWORD("function")) return TOK_FUNCTION_ID;
    562. 

  562. 	  break;
    563. 

  563. 	case TWO_CHAR('g','a'):
    564. 

  564. 	  if(ISWORD("gauge")) return TOK_GAUGE;
    565. 

  565. 	  break;
    566. 

  566. 	case TWO_CHAR('g','l'):
    567. 

  567. 	  if (ISWORD("global")) return TOK_GLOBAL;
    568. 

  568. 	  break;
    569. 

  569. 	case TWO_CHAR('i','f'):
    570. 

  570. 	  if(ISWORD("if")) return TOK_IF;
    571. 

  571. 	  break;
    572. 

  572. 	case TWO_CHAR('i','m'):
    573. 

  573. 	  if(ISWORD("import")) return TOK_IMPORT;
    574. 

  574. 	  break;
    575. 

  575. 	case TWO_CHAR('i','n'):
    576. 

  576. 	  if(ISWORD("int")) return TOK_INT_ID;
    577. 

  577. 	  if(ISWORD("inherit")) return TOK_INHERIT;
    578. 

  578. 	  if(ISWORD("inline")) return TOK_INLINE;
    579. 

  579. 	  break;
    580. 

  580. 	case TWO_CHAR('l','a'):
    581. 

  581. 	  if(ISWORD("lambda")) return TOK_LAMBDA;
    582. 

  582. 	  break;
    583. 

  583. 	case TWO_CHAR('l','o'):
    584. 

  584. 	  if(ISWORD("local")) return TOK_LOCAL_ID;
    585. 

  585. 	  break;
    586. 

  586. 	case TWO_CHAR('m','a'):
    587. 

  587. 	  if(ISWORD("mapping")) return TOK_MAPPING_ID;
    588. 

  588. 	  break;
    589. 

  589. 	case TWO_CHAR('m','i'):
    590. 

  590. 	  if(ISWORD("mixed")) return TOK_MIXED_ID;
    591. 

  591. 	  break;
    592. 

  592. 	case TWO_CHAR('m','u'):
    593. 

  593. 	  if(ISWORD("multiset")) return TOK_MULTISET_ID;
    594. 

  594. 	  break;
    595. 

  595. 	case TWO_CHAR('o','b'):
    596. 

  596. 	  if(ISWORD("object")) return TOK_OBJECT_ID;
    597. 

  597. 	  break;
    598. 

  598. 	case TWO_CHAR('o','p'):
    599. 

  599. 	  if(ISWORD("optional")) return TOK_OPTIONAL;
    600. 

  600. 	  break;
    601. 

  601. 	case TWO_CHAR('p','r'):
    602. 

  602. 	  if(ISWORD("program")) return TOK_PROGRAM_ID;
    603. 

  603. 	  if(ISWORD("predef")) return TOK_PREDEF;
    604. 

  604. 	  if(ISWORD("private")) return TOK_PRIVATE;
    605. 

  605. 	  if(ISWORD("protected")) return TOK_PROTECTED;
    606. 

  606. 	  break;
    607. 

  607. 	case TWO_CHAR('p','u'):
    608. 

  608. 	  if(ISWORD("public")) return TOK_PUBLIC;
    609. 

  609. 	  break;
    610. 

  610. 	case TWO_CHAR('r','e'):
    611. 

  611. 	  if(ISWORD("return")) return TOK_RETURN;
    612. 

  612. 	  break;
    613. 

  613. 	case TWO_CHAR('s','s'):
    614. 

  614. 	  if(ISWORD("sscanf")) return TOK_SSCANF;
    615. 

  615. 	  break;
    616. 

  616. 	case TWO_CHAR('s','t'):
    617. 

  617. 	  if(ISWORD("string")) return TOK_STRING_ID;
    618. 

  618. 	  if(ISWORD("static")) return TOK_STATIC;
    619. 

  619. 	  break;
    620. 

  620. 	case TWO_CHAR('s','w'):
    621. 

  621. 	  if(ISWORD("switch")) return TOK_SWITCH;
    622. 

  622. 	  break;
    623. 

  623. 	case TWO_CHAR('t','y'):
    624. 

  624. 	  if(ISWORD("typedef")) return TOK_TYPEDEF;
    625. 

  625. 	  if(ISWORD("typeof")) return TOK_TYPEOF;
    626. 

  626. 	  break;
    627. 

  627. 	case TWO_CHAR('v','a'):
    628. 

  628. 	  if(ISWORD("variant")) return TOK_VARIANT;
    629. 

  629. 	  break;
    630. 

  630. 	case TWO_CHAR('v','o'):
    631. 

  631. 	  if(ISWORD("void")) return TOK_VOID_ID;
    632. 

  632. 	  break;
    633. 

  633. 	case TWO_CHAR('w','h'):
    634. 

  634. 	  if(ISWORD("while")) return TOK_WHILE;
    635. 

  635. 	  break;
    636. 

  636. 	case TWO_CHAR('_','S'):
    637. 

  637. 	  if(ISWORD("_Static_assert")) return TOK_STATIC_ASSERT;
    638. 

  638. 	  break;
    639. 

  639. 	case TWO_CHAR('_','_'):
    640. 

  640. 	  if(len < 5) break;
    641. 

  641. 	  if(ISWORD("__attribute__"))
    642. 

  642. 	    return TOK_ATTRIBUTE_ID;
    643. 

  643. 	  if(ISWORD("__deprecated__"))
    644. 

  644. 	    return TOK_DEPRECATED_ID;
    645. 

  645. 	  if(ISWORD("__func__"))
    646. 

  646. 	    return TOK_FUNCTION_NAME;
    647. 

  647. 	  if(ISWORD("__weak__"))
    648. 

  648. 	    return TOK_WEAK;
    649. 

  649. 	  if(ISWORD("__unused__"))
    650. 

  650. 	    return TOK_UNUSED;
    651. 

  651. 	  /* Allow triple (or more) underscore for the user, and make sure we
    652. 

  652. 	   * don't get false matches below for wide strings.
    653. 

  653. 	   */
    654. 

  654. 	  if((INDEX_CHARP(buf, 2, SHIFT) == '_') ||
    655. 

  655. 	     (INDEX_CHARP(buf, len-3, SHIFT) == '_') ||
    656. 

  656. 	     (INDEX_CHARP(buf, len-2, SHIFT) != '_') ||
    657. 

  657. 	     (INDEX_CHARP(buf, len-1, SHIFT) != '_') ||
    658. 

  658. 	     (INDEX_CHARP(buf, 0, SHIFT) != '_') ||
    659. 

  659. 	     (INDEX_CHARP(buf, 1, SHIFT) != '_')) break;
    660. 

  660. 	  {
    661. 

  661. 	    /* Double underscore before and after is reserved for keywords. */
    662. 

  662. #if (SHIFT == 0)
    663. 

  663. 	    struct pike_string *tmp = make_shared_binary_string(buf, len);
    664. 

  664. #else /* SHIFT != 0 */
    665. 

  665. #if (SHIFT == 1)
    666. 

  666. 	    struct pike_string *tmp = make_shared_binary_string1((p_wchar1 *)buf,
    667. 

  667. 								 len);
    668. 

  668. #else /* SHIFT != 1 */
    669. 

  669. 	    struct pike_string *tmp = make_shared_binary_string2((p_wchar2 *)buf,
    670. 

  670. 								 len);
    671. 

  671. #endif /* SHIFT == 1 */
    672. 

  672. #endif /* SHIFT == 0 */
    673. 

  673. 	    yylval->n=mkstrnode(tmp);
    674. 

  674. 	    /* - But only for lower case US-ASCII.
    675. 

  675. 	     * - Upper case is used for symbols intended for #if constant().
    676. 

  676. 	     */
    677. 

  677. 	    if (tmp->size_shift) {
    678. 

  678. 	      free_string(tmp);
    679. 

  679. 	      return TOK_IDENTIFIER;
    680. 

  680. 	    }
    681. 

  681. 	    if(ISWORD("__args__")) {
    682. 

  682. 	      free_string(tmp);
    683. 

  683. 	      return TOK_IDENTIFIER;
    684. 

  684. 	    }
    685. 

  685. 	    while(len--) {
    686. 

  686. 	      int c = tmp->str[len];
    687. 

  687. 	      if ((c >= 'A') && (c <= 'Z')) {
    688. 

  688. 		free_string(tmp);
    689. 

  689. 		return TOK_IDENTIFIER;
    690. 

  690. 	      }
    691. 

  691. 	    }
    692. 

  692. 	    free_string(tmp);
    693. 

  693. 	  }
    694. 

  694. 	  return TOK_RESERVED;
    695. 

  695. 	}
    696. 

  696.       }
    697. 

  697.       {
    698. 

  698. #if (SHIFT == 0)
    699. 

  699. 	struct pike_string *tmp = make_shared_binary_string(buf, len);
    700. 

  700. #else /* SHIFT != 0 */
    701. 

  701. #if (SHIFT == 1)
    702. 

  702. 	struct pike_string *tmp = make_shared_binary_string1((p_wchar1 *)buf,
    703. 

  703. 							       len);
    704. 

  704. #else /* SHIFT != 1 */
    705. 

  705. 	struct pike_string *tmp = make_shared_binary_string2((p_wchar2 *)buf,
    706. 

  706. 							       len);
    707. 

  707. #endif /* SHIFT == 1 */
    708. 

  708. #endif /* SHIFT == 0 */
    709. 

  709. 	yylval->n=mkstrnode(tmp);
    710. 

  710. 	free_string(tmp);
    711. 

  711. 	return TOK_IDENTIFIER;
    712. 

  712.       }
    713. 

  713.     }
    714. 

  714. 

  715.     /* Note that 0 <= c <= 255 at this point. */
    716. 

  716. 

  717.     switch(c)
    718. 

  718.     {
    719. 

  719.     case 0:
    720. 

  720.       lex->pos -= (1<<SHIFT);
    721. 

  721.       if(lex->end != lex->pos)
    722. 

  722. 	yyerror("Illegal character (NUL)");
    723. 

  723. 

  724. #ifdef TOK_LEX_EOF
    725. 

  725.       return TOK_LEX_EOF;
    726. 

  726. #else /* !TOK_LEX_EOF */
    727. 

  727.       return 0;
    728. 

  728. #endif /* TOK_LEX_EOF */
    729. 

  729. 

  730.     case '\n':
    731. 

  731.       lex->current_line++;
    732. 

  732.       continue;
    733. 

  733. 

  734.     case 0x1b: case 0x9b:	/* ESC or CSI */
    735. 

  735.       /* Assume ANSI/DEC escape sequence.
    736. 

  736.        * Format supported:
    737. 

  737.        * 	<ESC>[\040-\077]+[\100-\177]
    738. 

  738.        * or
    739. 

  739.        * 	<CSI>[\040-\077]*[\100-\177]
    740. 

  740.        */
    741. 

  741.       while ((c = LOOK()) && (c == ((c & 0x1f)|0x20))) {
    742. 

  742. 	SKIP();
    743. 

  743.       }
    744. 

  744.       if (c == ((c & 0x3f)|0x40)) {
    745. 

  745. 	SKIP();
    746. 

  746.       } else {
    747. 

  747. 	/* FIXME: Warning here? */
    748. 

  748.       }
    749. 

  749.       continue;
    750. 

  750. 

  751.     case '#':
    752. 

  752.       SKIPSPACE();
    753. 

  753.       READBUF(!wide_isspace(C));
    754. 

  754. 

  755.       switch(len>0?INDEX_CHARP(buf, 0, SHIFT):0)
    756. 

  756.       {
    757. 

  757.       case 'l':
    758. 

  758. 	if (ISWORD("line"))
    759. 

  759. 	{
    760. 

  760. 	  SKIPSPACE();
    761. 

  761. 

  762. 	  if (LOOK() < '0' || LOOK() > '9') goto unknown_directive;
    763. 

  763. 

  764. 	  READBUF(!wide_isspace(C));
    765. 

  765. 	} else goto unknown_directive;
    766. 

  766. 	/* FALLTHRU */
    767. 

  767.       case '0': case '1': case '2': case '3': case '4':
    768. 

  768.       case '5': case '6': case '7': case '8': case '9':
    769. 

  769. 	lex->current_line = lex_strtol(buf, NULL, 10)-1;
    770. 

  770. 	SKIPSPACE();
    771. 

  771. 	if(GOBBLE('"'))
    772. 

  772. 	{
    773. 

  773. 	  struct pike_string *tmp=readstring(lex);
    774. 

  774. 	  free_string(lex->current_file);
    775. 

  775. 	  lex->current_file = dmalloc_touch(struct pike_string *, tmp);
    776. 

  776. 	}
    777. 

  777. 	if (Pike_compiler->compiler_pass == COMPILER_PASS_FIRST &&
    778. 

  778. 	    !Pike_compiler->new_program->num_linenumbers) {
    779. 

  779. 	  /* A nested program will always get an entry right away in
    780. 

  780. 	   * language.yacc. */
    781. 

  781. 	  store_linenumber(0, lex->current_file);
    782. 

  782. #ifdef DEBUG_MALLOC
    783. 

  783. 	  if(strcmp(lex->current_file->str,"-"))
    784. 

  784. 	    debug_malloc_name(Pike_compiler->new_program, lex->current_file->str, 0);
    785. 

  785. #endif
    786. 

  786. 	}
    787. 

  787. 	break;
    788. 

  788. 

  789.       case 'p':
    790. 

  790. 	if(ISWORD("pragma"))
    791. 

  791. 	{
    792. 

  792. 	  SKIPSPACE();
    793. 

  793. 	  READBUF(!wide_isspace(C));
    794. 

  794. 	  if (ISWORD("all_inline"))
    795. 

  795. 	  {
    796. 

  796. 	    lex->pragmas |= ID_INLINE;
    797. 

  797. 	  }
    798. 

  798. 	  else if (ISWORD("all_final"))
    799. 

  799. 	  {
    800. 

  800. 	    lex->pragmas |= ID_FINAL;
    801. 

  801. 	  }
    802. 

  802. 	  else if (ISWORD("strict_types"))
    803. 

  803. 	  {
    804. 

  804. 	    lex->pragmas |= ID_STRICT_TYPES;
    805. 

  805. 	  }
    806. 

  806. 	  else if (ISWORD("no_strict_types"))
    807. 

  807. 	  {
    808. 

  808. 	    lex->pragmas &= ~ID_STRICT_TYPES;
    809. 

  809. 	  }
    810. 

  810. 	  else if (ISWORD("save_parent"))
    811. 

  811. 	  {
    812. 

  812. 	    lex->pragmas |= ID_SAVE_PARENT;
    813. 

  813. 	  }
    814. 

  814. 	  else if (ISWORD("dont_save_parent"))
    815. 

  815. 	  {
    816. 

  816. 	    lex->pragmas |= ID_DONT_SAVE_PARENT;
    817. 

  817. 	  }
    818. 

  818. 	  else if (ISWORD("no_deprecation_warnings"))
    819. 

  819. 	  {
    820. 

  820. 	    lex->pragmas |= ID_NO_DEPRECATION_WARNINGS;
    821. 

  821. 	  }
    822. 

  822. 	  else if (ISWORD("deprecation_warnings"))
    823. 

  823. 	  {
    824. 

  824. 	    lex->pragmas &= ~ID_NO_DEPRECATION_WARNINGS;
    825. 

  825. 	  }
    826. 

  826. 	  else if (ISWORD("disassemble"))
    827. 

  827. 	  {
    828. 

  828. 	    lex->pragmas |= ID_DISASSEMBLE;
    829. 

  829. 	  }
    830. 

  830. 	  else if (ISWORD("no_disassemble"))
    831. 

  831. 	  {
    832. 

  832. 	    lex->pragmas &= ~ID_DISASSEMBLE;
    833. 

  833. 	  }
    834. 

  834.           else if (ISWORD("dynamic_dot"))
    835. 

  835.           {
    836. 

  836.             lex->pragmas |= ID_DYNAMIC_DOT;
    837. 

  837.           }
    838. 

  838.           else if (ISWORD("no_dynamic_dot"))
    839. 

  839.           {
    840. 

  840.             lex->pragmas &= ~ID_DYNAMIC_DOT;
    841. 

  841.           }
    842. 

  842.           else
    843. 

  843.           {
    844. 

  844.             if( Pike_compiler->compiler_pass == COMPILER_PASS_FIRST )
    845. 

  845.               yywarning("Unknown #pragma directive.");
    846. 

  846.           }
    847. 

  847. 	  break;
    848. 

  848. 	}
    849. 

  849. 

  850. 	if(ISWORD("pike"))
    851. 

  851. 	{
    852. 

  852. 	  int minor;
    853. 

  853. 	  int major;
    854. 

  854. 	  SKIPSPACE();
    855. 

  855. 	  READBUF(C!='.' && C!='\n');
    856. 

  856. 	  major=lex_atoi(buf);
    857. 

  857. 	  if(!GOBBLE('.'))
    858. 

  858. 	  {
    859. 

  859. 	    yyerror("Missing '.' in #pike directive.");
    860. 

  860. 	    minor=0;
    861. 

  861. 	  }else{
    862. 

  862. 	    READBUF(C!='\n' && C!='.');
    863. 

  863. 	    minor=lex_atoi(buf);
    864. 

  864. 	    if(GOBBLE('.'))
    865. 

  865. 	      yyerror("Build numbers not supported in #pike directive.");
    866. 

  866. 

  867. 	    READBUF(C!='\n');
    868. 

  868. 	    change_compiler_compatibility(major, minor);
    869. 

  869. 	  }
    870. 

  870. 	  break;
    871. 

  871. 	}
    872. 

  872. 	/* FALLTHRU */
    873. 

  873. 

  874.       default:
    875. 

  875. unknown_directive:
    876. 

  876. 	if (len < 256) {
    877. 

  877. #if (SHIFT == 0)
    878. 

  878. 	  struct pike_string *dir =
    879. 

  879. 	    make_shared_binary_string(buf, len);
    880. 

  880. #elif (SHIFT == 1)
    881. 

  881. 	  struct pike_string *dir =
    882. 

  882. 	    make_shared_binary_string1((p_wchar1 *)buf, len);
    883. 

  883. #elif (SHIFT == 2)
    884. 

  884. 	  struct pike_string *dir =
    885. 

  885. 	    make_shared_binary_string2((p_wchar2 *)buf, len);
    886. 

  886. #endif
    887. 

  887. 	  my_yyerror("Unknown preprocessor directive %S.", dir);
    888. 

  888. 	  free_string(dir);
    889. 

  889. 	} else {
    890. 

  890. 	  yyerror("Unknown preprocessor directive.");
    891. 

  891. 	}
    892. 

  892. 	SKIPUPTO('\n');
    893. 

  893. 	continue;
    894. 

  894.       }
    895. 

  895.       continue;
    896. 

  896. 

  897.     case ' ':
    898. 

  898.     case '\t':
    899. 

  899.     case '\r':
    900. 

  900.       continue;
    901. 

  901. 

  902.     case '\'':
    903. 

  903.       {
    904. 

  904.         unsigned int l = 0;
    905. 

  905.         struct svalue res = svalue_int_zero;
    906. 

  906.         MP_INT bigint;
    907. 

  907. 

  908.         while(1)
    909. 

  909.         {
    910. 

  910.           INT32 tmp;
    911. 

  911.           switch( (tmp=GETC()) )
    912. 

  912.           {
    913. 

  913.             case 0:
    914. 

  914.               lex->pos -= (1<<SHIFT);
    915. 

  915.               yyerror("Unexpected end of file\n");
    916. 

  916.               goto return_char;
    917. 

  917. 

  918.             case '\\':
    919. 

  919.               tmp = char_const(lex);
    920. 

  920.               /* fallthrough. */
    921. 

  921.             default:
    922. 

  922.               l++;
    923. 

  923.               if( l == sizeof(INT_TYPE)-1 )
    924. 

  924.               {
    925. 

  925.                 /* overflow possible. Switch to bignums. */
    926. 

  926.                 mpz_init(&bigint);
    927. 

  927.                 mpz_set_ui(&bigint,res.u.integer);
    928. 

  928.                 TYPEOF(res) = PIKE_T_OBJECT;
    929. 

  929.               }
    930. 

  930. 

  931.               if( l >= sizeof(INT_TYPE)-1 )
    932. 

  932.               {
    933. 

  933.                 mpz_mul_2exp(&bigint,&bigint,8);
    934. 

  934.                 mpz_add_ui(&bigint,&bigint,tmp);
    935. 

  935.               }
    936. 

  936.               else
    937. 

  937.               {
    938. 

  938.                 res.u.integer <<= 8;
    939. 

  939.                 res.u.integer |= tmp;
    940. 

  940.               }
    941. 

  941.               break;
    942. 

  942. 

  943.             case '\'':
    944. 

  944.               if( l == 0 )
    945. 

  945.                 yyerror("Zero-length character constant.");
    946. 

  946.               goto return_char;
    947. 

  947.           }
    948. 

  948.         }
    949. 

  949.       return_char:
    950. 

  950.         if( TYPEOF(res) == PIKE_T_OBJECT )
    951. 

  951.         {
    952. 

  952.           push_bignum( &bigint );
    953. 

  953.           mpz_clear(&bigint);
    954. 

  954.           reduce_stack_top_bignum();
    955. 

  955.           res = *--Pike_sp;
    956. 

  956.         }
    957. 

  957.         debug_malloc_pass( yylval->n=mksvaluenode(&res) );
    958. 

  958.         free_svalue( &res );
    959. 

  959.         return TOK_NUMBER;
    960. 

  960.       }
    961. 

  961.       UNREACHABLE(break);
    962. 

  962.     case '"':
    963. 

  963.     {
    964. 

  964.       struct pike_string *s=readstring(lex);
    965. 

  965.       yylval->n=mkstrnode(s);
    966. 

  966.       free_string(s);
    967. 

  967.       return TOK_STRING;
    968. 

  968.     }
    969. 

  969. 

  970.     case ':':
    971. 

  971.       if(GOBBLE(':')) return TOK_COLON_COLON;
    972. 

  972.       return c;
    973. 

  973. 

  974.     case '.':
    975. 

  975.       if(GOBBLE('.'))
    976. 

  976.       {
    977. 

  977. 	if(GOBBLE('.')) return TOK_DOT_DOT_DOT;
    978. 

  978. 	return TOK_DOT_DOT;
    979. 

  979.       }
    980. 

  980.       if (((c = INDEX_CHARP(lex->pos, 0, SHIFT)) <= '9') &&
    981. 

  981. 	  (c >= '0')) {
    982. 

  982.         lex->pos -= (1<<SHIFT);
    983. 

  983. 	goto read_float;
    984. 

  984.       }
    985. 

  985.       return '.';
    986. 

  986. 

  987.     case '0':
    988. 

  988.     {
    989. 

  989.       int base = 0;
    990. 

  990. 

  991.       if(GOBBLE('b') || GOBBLE('B'))
    992. 

  992.       {
    993. 

  993. 	base = 2;
    994. 

  994. 	goto read_based_number;
    995. 

  995.       }
    996. 

  996.       else if(GOBBLE('x') || GOBBLE('X'))
    997. 

  997.       {
    998. 

  998. 	struct svalue sval;
    999. 

  999. 	base = 16;
    1000. 

  1000.       read_based_number:
    1001. 

  1001. 	SET_SVAL(sval, PIKE_T_INT, NUMBER_NUMBER, integer, 0);
    1002. 

  1002. 	safe_wide_string_to_svalue_inumber(&sval,
    1003. 

  1003. 					   lex->pos,
    1004. 

  1004. 					   &lex->pos,
    1005. 

  1005. 					   base,
    1006. 

  1006. 					   0,
    1007. 

  1007. 					   SHIFT);
    1008. 

  1008. 	dmalloc_touch_svalue(&sval);
    1009. 

  1009. 	yylval->n = mksvaluenode(&sval);
    1010. 

  1010. 	free_svalue(&sval);
    1011. 

  1011. 	return TOK_NUMBER;
    1012. 

  1012.       }
    1013. 

  1013.     }
    1014. 

  1014.     /* FALLTHRU */
    1015. 

  1015. 

  1016.     case '1': case '2': case '3': case '4':
    1017. 

  1017.     case '5': case '6': case '7': case '8': case '9':
    1018. 

  1018.     {
    1019. 

  1019.       char *p1, *p2;
    1020. 

  1020.       FLOAT_TYPE f;
    1021. 

  1021.       long l;
    1022. 

  1022.       struct svalue sval;
    1023. 

  1023. 

  1024.       lex->pos -= (1<<SHIFT);
    1025. 

  1025.       if(INDEX_CHARP(lex->pos, 0, SHIFT)=='0')
    1026. 

  1026. 	for(l=1;INDEX_CHARP(lex->pos, l, SHIFT)<='9' &&
    1027. 

  1027. 	      INDEX_CHARP(lex->pos, l, SHIFT)>='0';l++)
    1028. 

  1028. 	  if(INDEX_CHARP(lex->pos, l, SHIFT)>='8')
    1029. 

  1029. 	    my_yyerror("Illegal octal digit '%c'.",
    1030. 

  1030. 		       INDEX_CHARP(lex->pos, l, SHIFT));
    1031. 

  1031. 

  1032.     read_float:
    1033. 

  1033.       f=lex_strtod(lex->pos, &p1);
    1034. 

  1034. 

  1035.       SET_SVAL(sval, PIKE_T_INT, NUMBER_NUMBER, integer, 0);
    1036. 

  1036. 

  1037.       safe_wide_string_to_svalue_inumber(&sval,
    1038. 

  1038. 					 lex->pos,
    1039. 

  1039. 					 &p2,
    1040. 

  1040. 					 0,
    1041. 

  1041. 					 0,
    1042. 

  1042. 					 SHIFT);
    1043. 

  1043.       if(p1>p2)
    1044. 

  1044.       {
    1045. 

  1045. 	/* Floating point or version. */
    1046. 

  1046. 	if ((TYPEOF(sval) == PIKE_T_INT) &&
    1047. 

  1047. 	    (INDEX_CHARP(p2, 0, SHIFT) == '.')) {
    1048. 

  1048. 	  int major = sval.u.integer;
    1049. 

  1049. 	  char *p3 = p2;
    1050. 

  1050. 	  p2 += (1<<SHIFT);
    1051. 

  1051. 	  dmalloc_touch_svalue(&sval);
    1052. 

  1052. 

  1053. 	  sval.u.integer = 0;
    1054. 

  1054. 	  safe_wide_string_to_svalue_inumber(&sval,
    1055. 

  1055. 					     p2,
    1056. 

  1056. 					     &p3,
    1057. 

  1057. 					     0,
    1058. 

  1058. 					     0,
    1059. 

  1059. 					     SHIFT);
    1060. 

  1060. 	  dmalloc_touch_svalue(&sval);
    1061. 

  1061. 	  if ((TYPEOF(sval) == PIKE_T_INT) && (p3 > p2)) {
    1062. 

  1062.             for (l=0; wide_isspace(INDEX_CHARP(p3, l, SHIFT)); l++)
    1063. 

  1063. 	      ;
    1064. 

  1064. 	    if ((INDEX_CHARP(p3, l, SHIFT) == ':') &&
    1065. 

  1065. 		(INDEX_CHARP(p3, l+1, SHIFT) == ':')) {
    1066. 

  1066. 	      /* Version prefix. */
    1067. 

  1067. 	      lex->pos = p3;
    1068. 

  1068. 	      yylval->n = mkversionnode(major, sval.u.integer);
    1069. 

  1069. 	      return TOK_VERSION;
    1070. 

  1070. 	    }
    1071. 

  1071. 	  }
    1072. 

  1072. 	}
    1073. 

  1073. 	free_svalue(&sval);
    1074. 

  1074. 	yylval->fnum=f;
    1075. 

  1075. #if 0
    1076. 

  1076. 	fprintf(stderr, "LEX: \"%.8s\" => %"PRINTPIKEFLOAT"f\n",
    1077. 

  1077. 		(char *)lex->pos, f);
    1078. 

  1078. #endif /* 0 */
    1079. 

  1079. 	lex->pos=p1;
    1080. 

  1080. 	if (lex_isidchar (LOOK())) {
    1081. 

  1081. 	  my_yyerror ("Invalid char '%c' in constant.", LOOK());
    1082. 

  1082. 	  do SKIP(); while (lex_isidchar (LOOK()));
    1083. 

  1083. 	}
    1084. 

  1084. 	return TOK_FLOAT;
    1085. 

  1085.       }else{
    1086. 

  1086. 	dmalloc_touch_svalue(&sval);
    1087. 

  1087. 	yylval->n = mksvaluenode(&sval);
    1088. 

  1088. 	free_svalue(&sval);
    1089. 

  1089. 	debug_malloc_touch(yylval->n);
    1090. 

  1090. 	lex->pos=p2;
    1091. 

  1091. 	if (lex_isidchar (LOOK()))
    1092. 

  1092.         {
    1093. 

  1093.           if( GOBBLE('b') )
    1094. 

  1094.             if( GOBBLE( 'i' ) )
    1095. 

  1095.               if( GOBBLE( 't' ) )
    1096. 

  1096.               {
    1097. 

  1097.                 GOBBLE('s');
    1098. 

  1098.                 return TOK_BITS;
    1099. 

  1099.               }
    1100. 

  1100. 

  1101. 	  my_yyerror ("Invalid char '%c' in constant.", LOOK());
    1102. 

  1102. 	  do SKIP(); while (lex_isidchar (LOOK()));
    1103. 

  1103. 	}
    1104. 

  1104. 	return TOK_NUMBER;
    1105. 

  1105.       }
    1106. 

  1106.     }
    1107. 

  1107. 

  1108.     case '-':
    1109. 

  1109.       if(GOBBLE('=')) return TOK_SUB_EQ;
    1110. 

  1110.       if(GOBBLE('>')) {
    1111. 

  1111. 	if(GOBBLE('?') ) /* ->? */
    1112. 

  1112. 	  return TOK_SAFE_INDEX;
    1113. 

  1113. 	else
    1114. 

  1114. 	  return TOK_ARROW;
    1115. 

  1115.       }
    1116. 

  1116.       if(GOBBLE('-')) return TOK_DEC;
    1117. 

  1117.       return '-';
    1118. 

  1118. 

  1119.     case '+':
    1120. 

  1120.       if(GOBBLE('=')) return TOK_ADD_EQ;
    1121. 

  1121.       if(GOBBLE('+')) return TOK_INC;
    1122. 

  1122.       return '+';
    1123. 

  1123. 

  1124.     case '&':
    1125. 

  1125.       if(GOBBLE('=')) return TOK_AND_EQ;
    1126. 

  1126.       if(GOBBLE('&')) return TOK_LAND;
    1127. 

  1127.       return '&';
    1128. 

  1128. 

  1129.     case '|':
    1130. 

  1130.       if(GOBBLE('=')) return TOK_OR_EQ;
    1131. 

  1131.       if(GOBBLE('|')) return TOK_LOR;
    1132. 

  1132.       return '|';
    1133. 

  1133. 

  1134.     case '^':
    1135. 

  1135.       if(GOBBLE('=')) return TOK_XOR_EQ;
    1136. 

  1136.       return '^';
    1137. 

  1137. 

  1138.     case '*':
    1139. 

  1139.       if(GOBBLE('=')) return TOK_MULT_EQ;
    1140. 

  1140.       if(GOBBLE('*'))
    1141. 

  1141.       {
    1142. 

  1142.           if(GOBBLE('=')) return TOK_POW_EQ;
    1143. 

  1143.           return TOK_POW;
    1144. 

  1144.       }
    1145. 

  1145.       return '*';
    1146. 

  1146. 

  1147.     case '%':
    1148. 

  1148.       if(GOBBLE('=')) return TOK_MOD_EQ;
    1149. 

  1149.       return '%';
    1150. 

  1150. 

  1151.     case '/':
    1152. 

  1152.       if(GOBBLE('=')) return TOK_DIV_EQ;
    1153. 

  1153.       return '/';
    1154. 

  1154. 

  1155.     case '=':
    1156. 

  1156.       if(GOBBLE('=')) return TOK_EQ;
    1157. 

  1157.       return '=';
    1158. 

  1158. 

  1159.     case '<':
    1160. 

  1160.       if(GOBBLE('<'))
    1161. 

  1161.       {
    1162. 

  1162. 	if(GOBBLE('=')) return TOK_LSH_EQ;
    1163. 

  1163. 	return TOK_LSH;
    1164. 

  1164.       }
    1165. 

  1165.       if(GOBBLE('=')) return TOK_LE;
    1166. 

  1166.       return '<';
    1167. 

  1167. 

  1168.     case '>':
    1169. 

  1169.       if(GOBBLE(')')) return TOK_MULTISET_END;
    1170. 

  1170.       if(GOBBLE('=')) return TOK_GE;
    1171. 

  1171.       if(GOBBLE('>'))
    1172. 

  1172.       {
    1173. 

  1173. 	if(GOBBLE('=')) return TOK_RSH_EQ;
    1174. 

  1174. 	return TOK_RSH;
    1175. 

  1175.       }
    1176. 

  1176.       return '>';
    1177. 

  1177. 

  1178.     case '!':
    1179. 

  1179.       if(GOBBLE('=')) return TOK_NE;
    1180. 

  1180.       return TOK_NOT;
    1181. 

  1181. 

  1182.     case '(':
    1183. 

  1183.       if(GOBBLE('<')) return TOK_MULTISET_START;
    1184. 

  1184.       if(GOBBLE('?') ) /* (? */
    1185. 

  1185. 	  return TOK_SAFE_APPLY;
    1186. 

  1186.       return '(';
    1187. 

  1187. 

  1188.     case '?':
    1189. 

  1189.       if(GOBBLE(':'))
    1190. 

  1190.         return TOK_LOR;
    1191. 

  1191. 

  1192.       if(GOBBLE('-') )
    1193. 

  1193.       {
    1194. 

  1194.         if( GOBBLE( '>' ) ) { /* ?-> */
    1195. 

  1195. 	  yywarning(" ?-> safe indexing is deprecated, use ->?");
    1196. 

  1196. 	  return TOK_SAFE_INDEX;
    1197. 

  1197. 	}
    1198. 

  1198.         SKIPN(-1); /* Undo GOBBLE('-') above */
    1199. 

  1199.       }
    1200. 

  1200. 

  1201.       if (GOBBLE('='))
    1202. 

  1202. 	return TOK_ATOMIC_GET_SET;
    1203. 

  1203. 

  1204.       /* FALLTHRU */
    1205. 

  1205. 

  1206.     case ']':
    1207. 

  1207.     case ',':
    1208. 

  1208.     case '~':
    1209. 

  1209.     case '@':
    1210. 

  1210.     case ')':
    1211. 

  1211. 

  1212.     case '{':
    1213. 

  1213.     case ';':
    1214. 

  1214.     case '}': return c;
    1215. 

  1215. 

  1216.     case '[':
    1217. 

  1217.       if( GOBBLE('?' ) )
    1218. 

  1218.         return TOK_SAFE_START_INDEX;
    1219. 

  1219.       return c;
    1220. 

  1220. 

  1221.     case '`':
    1222. 

  1222.     {
    1223. 

  1223.       char *tmp;
    1224. 

  1224.       int offset=2;
    1225. 

  1225.       if(GOBBLE('`')) {
    1226. 

  1226. 	offset--;
    1227. 

  1227. 	if(GOBBLE('`')) {
    1228. 

  1228. 	  offset--;
    1229. 

  1229. 	}
    1230. 

  1230.       }
    1231. 

  1231. 

  1232.       switch(c = GETC())
    1233. 

  1233.       {
    1234. 

  1234.       case '/': tmp="```/"; break;
    1235. 

  1235.       case '%': tmp="```%"; break;
    1236. 

  1236.       case '*':
    1237. 

  1237.           if( GOBBLE('*') )
    1238. 

  1238.               tmp="```**";
    1239. 

  1239.           else
    1240. 

  1240.               tmp="```*";
    1241. 

  1241.           break;
    1242. 

  1242.       case '&': tmp="```&"; break;
    1243. 

  1243.       case '|': tmp="```|"; break;
    1244. 

  1244.       case '^': tmp="```^"; break;
    1245. 

  1245.       case '~': tmp="```~"; break;
    1246. 

  1246.       case '+':
    1247. 

  1247. 	if(GOBBLE('=')) { tmp="```+="; break; }
    1248. 

  1248. 	tmp="```+";
    1249. 

  1249. 	break;
    1250. 

  1250.       case '<':
    1251. 

  1251. 	if(GOBBLE('<')) { tmp="```<<"; break; }
    1252. 

  1252. 	if(GOBBLE('=')) { tmp="```<="; break; }
    1253. 

  1253. 	tmp="```<";
    1254. 

  1254. 	break;
    1255. 

  1255. 

  1256.       case '>':
    1257. 

  1257. 	if(GOBBLE('>')) { tmp="```>>"; break; }
    1258. 

  1258. 	if(GOBBLE('=')) { tmp="```>="; break; }
    1259. 

  1259. 	tmp="```>";
    1260. 

  1260. 	break;
    1261. 

  1261. 

  1262.       case '!':
    1263. 

  1263. 	if(GOBBLE('=')) { tmp="```!="; break; }
    1264. 

  1264. 	tmp="```!";
    1265. 

  1265. 	break;
    1266. 

  1266. 

  1267.       case '=':
    1268. 

  1268. 	if(GOBBLE('=')) { tmp="```=="; break; }
    1269. 

  1269. 	tmp="```=";
    1270. 

  1270. 	break;
    1271. 

  1271. 

  1272.       case '(':
    1273. 

  1273. 	tmp="```()";
    1274. 

  1274. 	if(GOBBLE(')'))
    1275. 

  1275. 	{
    1276. 

  1276. 	  break;
    1277. 

  1277. 	}
    1278. 

  1278. 	yyerror("Illegal ` identifier. Expected `().");
    1279. 

  1279. 	break;
    1280. 

  1280. 

  1281.       case '-':
    1282. 

  1282. 	if(GOBBLE('>'))
    1283. 

  1283. 	{
    1284. 

  1284. 	  if ((offset == 2) && lex_isidchar(LOOK())) {
    1285. 

  1285. 	    /* Getter/setter (old-style)
    1286. 

  1286. 	     *
    1287. 

  1287. 	     * Either
    1288. 

  1288. 	     *   `->symbol
    1289. 

  1289. 	     * Or
    1290. 

  1290. 	     *   `->symbol=
    1291. 

  1291. 	     */
    1292. 

  1292. 	    char *buf;
    1293. 

  1293. 	    size_t len;
    1294. 

  1294. 	    struct pike_string *s;
    1295. 

  1295. 	    READBUF(lex_isidchar(C));
    1296. 

  1296. 	    if (GOBBLE('=')) len += 1;
    1297. 

  1297. 	    /* Adjust for the prefix (`->). */
    1298. 

  1298. 	    len += 3;
    1299. 

  1299. 	    buf -= 3<<SHIFT;
    1300. 

  1300. #if (SHIFT == 0)
    1301. 

  1301. 	    s = make_shared_binary_string(buf, len);
    1302. 

  1302. #else /* SHIFT != 0 */
    1303. 

  1303. #if (SHIFT == 1)
    1304. 

  1304. 	    s = make_shared_binary_string1((p_wchar1 *)buf, len);
    1305. 

  1305. #else /* SHIFT != 1 */
    1306. 

  1306. 	    s = make_shared_binary_string2((p_wchar2 *)buf, len);
    1307. 

  1307. #endif /* SHIFT == 1 */
    1308. 

  1308. #endif /* SHIFT == 0 */
    1309. 

  1309. 	    yylval->n = mkstrnode(s);
    1310. 

  1310. 	    free_string(s);
    1311. 

  1311. 	    return TOK_IDENTIFIER;
    1312. 

  1312. 	  }
    1313. 

  1313. 	  tmp="```->";
    1314. 

  1314. 	  if(GOBBLE('=')) tmp="```->=";
    1315. 

  1315. 	}else{
    1316. 

  1316. 	  tmp="```-";
    1317. 

  1317. 	}
    1318. 

  1318. 	break;
    1319. 

  1319. 

  1320.       case '[':
    1321. 

  1321. 	tmp="```[]";
    1322. 

  1322. 	if(GOBBLE(']'))
    1323. 

  1323. 	{
    1324. 

  1324. 	  if(GOBBLE('=')) tmp="```[]=";
    1325. 

  1325. 	  break;
    1326. 

  1326. 	}
    1327. 

  1327. 	if (GOBBLE ('.') && GOBBLE ('.') && GOBBLE (']')) {
    1328. 

  1328. 	  tmp = "```[..]";
    1329. 

  1329. 	  break;
    1330. 

  1330. 	}
    1331. 

  1331. 	yyerror("Illegal ` identifier. Expected `[], `[]= or `[..].");
    1332. 

  1332. 	break;
    1333. 

  1333. 

  1334.       default:
    1335. 

  1335. 	  if (offset==2 && lex_isidchar(c)) {
    1336. 

  1336. 	    /* Getter/setter (new-style)
    1337. 

  1337. 	     *
    1338. 

  1338. 	     * Either
    1339. 

  1339. 	     *   `symbol
    1340. 

  1340. 	     * Or
    1341. 

  1341. 	     *   `symbol=
    1342. 

  1342. 	     */
    1343. 

  1343. 	    char *buf;
    1344. 

  1344. 	    size_t len;
    1345. 

  1345. 	    struct pike_string *s;
    1346. 

  1346. 	    READBUF(lex_isidchar(C));
    1347. 

  1347. 	    if (GOBBLE('=')) len += 1;
    1348. 

  1348. 	    /* Adjust for the prefix (`c). */
    1349. 

  1349. 	    len += 2;
    1350. 

  1350. 	    buf -= 2<<SHIFT;
    1351. 

  1351. #if (SHIFT == 0)
    1352. 

  1352. 	    s = make_shared_binary_string(buf, len);
    1353. 

  1353. #else /* SHIFT != 0 */
    1354. 

  1354. #if (SHIFT == 1)
    1355. 

  1355. 	    s = make_shared_binary_string1((p_wchar1 *)buf, len);
    1356. 

  1356. #else /* SHIFT != 1 */
    1357. 

  1357. 	    s = make_shared_binary_string2((p_wchar2 *)buf, len);
    1358. 

  1358. #endif /* SHIFT == 1 */
    1359. 

  1359. #endif /* SHIFT == 0 */
    1360. 

  1360. 	    yylval->n = mkstrnode(s);
    1361. 

  1361. 	    free_string(s);
    1362. 

  1362. 	    return TOK_IDENTIFIER;
    1363. 

  1363. 	  }
    1364. 

  1364. 	yyerror("Illegal ` identifier.");
    1365. 

  1365. 	lex->pos -= (1<<SHIFT);
    1366. 

  1366. 	tmp="```";
    1367. 

  1367. 	break;
    1368. 

  1368.       }
    1369. 

  1369. 

  1370.       {
    1371. 

  1371. 	struct pike_string *s=make_shared_string(tmp+offset);
    1372. 

  1372. 	yylval->n=mkstrnode(s);
    1373. 

  1373. 	free_string(s);
    1374. 

  1374. 	return TOK_IDENTIFIER;
    1375. 

  1375.       }
    1376. 

  1376.     }
    1377. 

  1377. 

  1378. 

  1379.     default:
    1380. 

  1380.       {
    1381. 

  1381. 	if (c > 31) {
    1382. 

  1382. 	  my_yyerror("Illegal character '%c' (0x%02x)", c, c);
    1383. 

  1383. 	} else {
    1384. 

  1384. 	  my_yyerror("Illegal character 0x%02x", c);
    1385. 

  1385. 	}
    1386. 

  1386. 	return ' ';
    1387. 

  1387.       }
    1388. 

  1388.     }
    1389. 

  1389.   }
    1390. 

  1390. }
    1391. 

  1391. 

  1392. /*
    1393. 

  1393.  * Clear the defines for the next pass
    1394. 

  1394.  */
    1395. 

  1395. 

  1396. #undef WCHAR
    1397. 

  1397. #undef LOOK
    1398. 

  1398. #undef GETC
    1399. 

  1399. #undef SKIP
    1400. 

  1400. #undef SKIPN
    1401. 

  1401. #undef GOBBLE
    1402. 

  1402. #undef SKIPSPACE
    1403. 

  1403. #undef SKIPWHITE
    1404. 

  1404. #undef SKIPUPTO
    1405. 

  1405. #undef READBUF
    1406. 

  1406. #undef TWO_CHAR
    1407. 

  1407. #undef ISWORD
    1408. 

  1408. 

  1409. #undef low_isword
    1410. 

  1410. #undef parse_esc_seq
    1411. 

  1411. #undef char_const
    1412. 

  1412. #undef readstring
    1413. 

  1413. #undef yylex
    1414. 

  1414. #undef low_yylex
    1415. 

  1415. #undef lex_atoi
    1416. 

  1416. #undef lex_strtol
    1417. 

  1417. #undef lex_strtod
    1418. 

  1418. #undef lex_isidchar
    1419. 

  1419.