PageRenderTime 75ms CodeModel.GetById 21ms RepoModel.GetById 0ms app.codeStats 0ms

/lib/ext/melbourne/grammar18.y

https://github.com/p8/rubinius
Happy | 6095 lines | 5550 code | 545 blank | 0 comment | 0 complexity | 0499a8e92768e9872d9d40662461ef83 MD5 | raw file
Possible License(s): BSD-3-Clause, LGPL-2.1 
    

  1. /**********************************************************************
    2. 

    3. 

  3.   parse.y -
    4. 

    5. 

  5.   $Author: matz $
    6. 

  6.   $Date: 2004/11/29 06:13:51 $
    7. 

  7.   created at: Fri May 28 18:02:42 JST 1993
    8. 

    9. 

  9.   Copyright (C) 1993-2003 Yukihiro Matsumoto
    10. 

    11. 

  11. **********************************************************************/
    12. 

  12. 

  13. %{
    14. 

  14. 

  15. #define YYDEBUG 1
    16. 

  16. #define YYERROR_VERBOSE 1
    17. 

  17. 

  18. #include <stdio.h>
    19. 

  19. #include <errno.h>
    20. 

  20. #include <ctype.h>
    21. 

  21. #include <string.h>
    22. 

  22. #include <stdbool.h>
    23. 

  23. #include <stdint.h>
    24. 

  24. #include <assert.h>
    25. 

  25. 

  26. #include "ruby.h"
    27. 

  27. 

  28. #include "grammar18.hpp"
    29. 

  29. #include "parser_state18.hpp"
    30. 

  30. #include "visitor18.hpp"
    31. 

  31. #include "symbols.hpp"
    32. 

  32. 

  33. namespace melbourne {
    34. 

  34. 

  35. namespace grammar18 {
    36. 

  36. 

  37. #ifndef isnumber
    38. 

  38. #define isnumber isdigit
    39. 

  39. #endif
    40. 

  40. 

  41. /* Defined at least in mach/boolean.h on OS X. */
    42. 

  42. #ifdef  TRUE
    43. 

  43.   #undef  TRUE
    44. 

  44. #endif
    45. 

  45. 

  46. #ifdef  FALSE
    47. 

  47.   #undef FALSE
    48. 

  48. #endif
    49. 

  49. 

  50. #define TRUE  true
    51. 

  51. #define FALSE false
    52. 

  52. 

  53. /*
    54. 

  54. #define ISALPHA isalpha
    55. 

  55. #define ISSPACE isspace
    56. 

  56. #define ISALNUM(x) (isalpha(x) || isnumber(x))
    57. 

  57. #define ISDIGIT isdigit
    58. 

  58. #define ISXDIGIT isxdigit
    59. 

  59. #define ISUPPER isupper
    60. 

  60. */
    61. 

  61. 

  62. #define ismbchar(c) (0)
    63. 

  63. #define mbclen(c) (1)
    64. 

  64. 

  65. #define string_new(ptr, len) blk2bstr(ptr, len)
    66. 

  66. #define string_new2(ptr) cstr2bstr(ptr)
    67. 

  67. 

  68. static int
    69. 

  69. mel_yyerror(const char *, rb_parser_state*);
    70. 

  70. #define yyparse mel_yyparse
    71. 

  71. #define yylex mel_yylex
    72. 

  72. #define yyerror(str) mel_yyerror(str, (rb_parser_state*)parser_state)
    73. 

  73. #define yylval mel_yylval
    74. 

  74. #define yychar mel_yychar
    75. 

  75. #define yydebug mel_yydebug
    76. 

  76. 

  77. #define YYPARSE_PARAM parser_state
    78. 

  78. #define YYLEX_PARAM parser_state
    79. 

  79. 

  80. #define ID_SCOPE_SHIFT 3
    81. 

  81. #define ID_SCOPE_MASK 0x07
    82. 

  82. #define ID_LOCAL    0x01
    83. 

  83. #define ID_INSTANCE 0x02
    84. 

  84. #define ID_GLOBAL   0x03
    85. 

  85. #define ID_ATTRSET  0x04
    86. 

  86. #define ID_CONST    0x05
    87. 

  87. #define ID_CLASS    0x06
    88. 

  88. #define ID_JUNK     0x07
    89. 

  89. #define ID_INTERNAL ID_JUNK
    90. 

  90. 

  91. #define is_notop_id(id) ((id)>tLAST_TOKEN)
    92. 

  92. #define is_local_id(id) (is_notop_id(id)&&((id)&ID_SCOPE_MASK)==ID_LOCAL)
    93. 

  93. #define is_global_id(id) (is_notop_id(id)&&((id)&ID_SCOPE_MASK)==ID_GLOBAL)
    94. 

  94. #define is_instance_id(id) (is_notop_id(id)&&((id)&ID_SCOPE_MASK)==ID_INSTANCE)
    95. 

  95. #define is_attrset_id(id) (is_notop_id(id)&&((id)&ID_SCOPE_MASK)==ID_ATTRSET)
    96. 

  96. #define is_const_id(id) (is_notop_id(id)&&((id)&ID_SCOPE_MASK)==ID_CONST)
    97. 

  97. #define is_class_id(id) (is_notop_id(id)&&((id)&ID_SCOPE_MASK)==ID_CLASS)
    98. 

  98. #define is_junk_id(id) (is_notop_id(id)&&((id)&ID_SCOPE_MASK)==ID_JUNK)
    99. 

  99. 

  100. #define is_asgn_or_id(id) ((is_notop_id(id)) && \
    101. 

  101.         (((id)&ID_SCOPE_MASK) == ID_GLOBAL || \
    102. 

  102.          ((id)&ID_SCOPE_MASK) == ID_INSTANCE || \
    103. 

  103.          ((id)&ID_SCOPE_MASK) == ID_CLASS))
    104. 

  104. 

  105. 

  106. /* FIXME these went into the ruby_state instead of parser_state
    107. 

  107.    because a ton of other crap depends on it
    108. 

  108. char *ruby_sourcefile;          current source file
    109. 

  109. int   ruby_sourceline;          current line no.
    110. 

  110. */
    111. 

  111. static int yylex(void*, void *);
    112. 

  112. 

  113. 

  114. #define BITSTACK_PUSH(stack, n) (stack = (stack<<1)|((n)&1))
    115. 

  115. #define BITSTACK_POP(stack)     (stack >>= 1)
    116. 

  116. #define BITSTACK_LEXPOP(stack)  (stack = (stack >> 1) | (stack & 1))
    117. 

  117. #define BITSTACK_SET_P(stack)   (stack&1)
    118. 

  118. 

  119. #define COND_PUSH(n)    BITSTACK_PUSH(cond_stack, n)
    120. 

  120. #define COND_POP()      BITSTACK_POP(cond_stack)
    121. 

  121. #define COND_LEXPOP()   BITSTACK_LEXPOP(cond_stack)
    122. 

  122. #define COND_P()        BITSTACK_SET_P(cond_stack)
    123. 

  123. 

  124. #define CMDARG_PUSH(n)  BITSTACK_PUSH(cmdarg_stack, n)
    125. 

  125. #define CMDARG_POP()    BITSTACK_POP(cmdarg_stack)
    126. 

  126. #define CMDARG_LEXPOP() BITSTACK_LEXPOP(cmdarg_stack)
    127. 

  127. #define CMDARG_P()      BITSTACK_SET_P(cmdarg_stack)
    128. 

  128. 

  129. static NODE *cond(NODE*,rb_parser_state*);
    130. 

  130. static NODE *logop(enum node_type,NODE*,NODE*,rb_parser_state*);
    131. 

  131. static int cond_negative(NODE**);
    132. 

  132. 

  133. static NODE *newline_node(rb_parser_state*,NODE*);
    134. 

  134. static void fixpos(NODE*,NODE*);
    135. 

  135. 

  136. static int value_expr0(NODE*,rb_parser_state*);
    137. 

  137. static void void_expr0(NODE*,rb_parser_state*);
    138. 

  138. static void void_stmts(NODE*,rb_parser_state*);
    139. 

  139. static NODE *remove_begin(NODE*,rb_parser_state*);
    140. 

  140. #define  value_expr(node)  value_expr0((node) = \
    141. 

  141.                               remove_begin(node, (rb_parser_state*)parser_state), \
    142. 

  142.                               (rb_parser_state*)parser_state)
    143. 

  143. #define void_expr(node) void_expr0((node) = \
    144. 

  144.                               remove_begin(node, (rb_parser_state*)parser_state), \
    145. 

  145.                               (rb_parser_state*)parser_state)
    146. 

  146. 

  147. static NODE *block_append(rb_parser_state*,NODE*,NODE*);
    148. 

  148. static NODE *list_append(rb_parser_state*,NODE*,NODE*);
    149. 

  149. static NODE *list_concat(NODE*,NODE*);
    150. 

  150. static NODE *arg_concat(rb_parser_state*,NODE*,NODE*);
    151. 

  151. static NODE *arg_prepend(rb_parser_state*,NODE*,NODE*);
    152. 

  152. static NODE *literal_concat(rb_parser_state*,NODE*,NODE*);
    153. 

  153. static NODE *new_evstr(rb_parser_state*,NODE*);
    154. 

  154. static NODE *evstr2dstr(rb_parser_state*,NODE*);
    155. 

  155. static NODE *call_op(NODE*,QUID,int,NODE*,rb_parser_state*);
    156. 

  156. 

  157. /* static NODE *negate_lit(NODE*); */
    158. 

  158. static NODE *ret_args(rb_parser_state*,NODE*);
    159. 

  159. static NODE *arg_blk_pass(NODE*,NODE*);
    160. 

  160. static NODE *new_call(rb_parser_state*,NODE*,QUID,NODE*);
    161. 

  161. static NODE *new_fcall(rb_parser_state*,QUID,NODE*);
    162. 

  162. static NODE *new_super(rb_parser_state*,NODE*);
    163. 

  163. static NODE *new_yield(rb_parser_state*,NODE*);
    164. 

  164. 

  165. static NODE *mel_gettable(rb_parser_state*,QUID);
    166. 

  166. #define gettable(i) mel_gettable((rb_parser_state*)parser_state, i)
    167. 

  167. static NODE *assignable(QUID,NODE*,rb_parser_state*);
    168. 

  168. static NODE *aryset(NODE*,NODE*,rb_parser_state*);
    169. 

  169. static NODE *attrset(NODE*,QUID,rb_parser_state*);
    170. 

  170. static void rb_backref_error(NODE*,rb_parser_state*);
    171. 

  171. static NODE *node_assign(NODE*,NODE*,rb_parser_state*);
    172. 

  172. 

  173. static NODE *match_gen(NODE*,NODE*,rb_parser_state*);
    174. 

  174. static void mel_local_push(rb_parser_state*, int cnt);
    175. 

  175. #define local_push(cnt) mel_local_push(vps, cnt)
    176. 

  176. static void mel_local_pop(rb_parser_state*);
    177. 

  177. #define local_pop() mel_local_pop(vps)
    178. 

  178. static intptr_t  mel_local_cnt(rb_parser_state*,QUID);
    179. 

  179. #define local_cnt(i) mel_local_cnt(vps, i)
    180. 

  180. static int  mel_local_id(rb_parser_state*,QUID);
    181. 

  181. #define local_id(i) mel_local_id(vps, i)
    182. 

  182. static QUID  *mel_local_tbl(rb_parser_state *st);
    183. 

  183. static QUID   convert_op(QUID id);
    184. 

  184. 

  185. #define QUID2SYM(x)   (x)
    186. 

  186. 

  187. static void tokadd(char c, rb_parser_state *parser_state);
    188. 

  188. static int tokadd_string(int, int, int, QUID*, rb_parser_state*);
    189. 

  189. 

  190. rb_parser_state *parser_alloc_state() {
    191. 

  191.   rb_parser_state *parser_state;
    192. 

  192. 

  193.   parser_state = (rb_parser_state*)calloc(1, sizeof(rb_parser_state));
    194. 

  194. 

  195.   lex_pbeg = 0;
    196. 

  196.   lex_p = 0;
    197. 

  197.   lex_pend = 0;
    198. 

  198.   parse_error = false;
    199. 

  199. 

  200.   eofp = false;
    201. 

  201.   command_start = true;
    202. 

  202.   class_nest = 0;
    203. 

  203.   in_single = 0;
    204. 

  204.   in_def = 0;
    205. 

  205.   compile_for_eval = 0;
    206. 

  206.   cur_mid = 0;
    207. 

  207.   tokenbuf = NULL;
    208. 

  208.   tokidx = 0;
    209. 

  209.   toksiz = 0;
    210. 

  210.   memory_cur = NULL;
    211. 

  211.   memory_last_addr = NULL;
    212. 

  212.   current_pool = 0;
    213. 

  213.   pool_size = 0;
    214. 

  214.   memory_size = 204800;
    215. 

  215.   memory_pools = NULL;
    216. 

  216.   emit_warnings = 0;
    217. 

  217.   verbose = RTEST(ruby_verbose);
    218. 

  218.   magic_comments = new std::vector<bstring>;
    219. 

  219.   start_lines = new std::list<StartPosition>;
    220. 

  220. 

  221.   return parser_state;
    222. 

  222. }
    223. 

  223. 

  224. void *pt_allocate(rb_parser_state *parser_state, int size) {
    225. 

  225.   void *cur;
    226. 

  226. 

  227.   if(!memory_cur || ((memory_cur + size) >= memory_last_addr)) {
    228. 

  228.     if(memory_cur) current_pool++;
    229. 

  229. 

  230.     if(current_pool == pool_size) {
    231. 

  231.       pool_size += 10;
    232. 

  232.       if(memory_pools) {
    233. 

  233.         memory_pools = (void**)realloc(memory_pools, sizeof(void*) * pool_size);
    234. 

  234.       } else {
    235. 

  235.         memory_pools = (void**)malloc(sizeof(void*) * pool_size);
    236. 

  236.       }
    237. 

  237.     }
    238. 

  238.     memory_pools[current_pool] = malloc(memory_size);
    239. 

  239.     memory_cur = (char*)memory_pools[current_pool];
    240. 

  240.     memory_last_addr = memory_cur + memory_size - 1;
    241. 

  241.   }
    242. 

  242. 

  243.   cur = (void*)memory_cur;
    244. 

  244.   memory_cur = memory_cur + size;
    245. 

  245. 

  246.   return cur;
    247. 

  247. }
    248. 

  248. 

  249. void pt_free(rb_parser_state *parser_state) {
    250. 

  250.   int i;
    251. 

  251. 

  252.   if(line_buffer) {
    253. 

  253.     bdestroy(line_buffer);
    254. 

  254.   }
    255. 

  255. 

  256.   if(lex_lastline) {
    257. 

  257.     bdestroy(lex_lastline);
    258. 

  258.   }
    259. 

  259. 

  260.   free(tokenbuf);
    261. 

  261.   delete variables;
    262. 

  262. 

  263.   for(std::vector<bstring>::iterator i = magic_comments->begin();
    264. 

  264.       i != magic_comments->end();
    265. 

  265.       i++) {
    266. 

  266.     bdestroy(*i);
    267. 

  267.   }
    268. 

  268. 

  269.   delete magic_comments;
    270. 

  270.   delete start_lines;
    271. 

  271. 

  272.   if(!memory_pools) return;
    273. 

  273. 

  274.   for(i = 0; i <= current_pool; i++) {
    275. 

  275.     free(memory_pools[i]);
    276. 

  276.   }
    277. 

  277.   free(memory_pools);
    278. 

  278. 

  279. }
    280. 

  280. 

  281. #define SHOW_PARSER_WARNS 0
    282. 

  282. 

  283. static int rb_compile_error(rb_parser_state *st, const char *fmt, ...) {
    284. 

  284.   va_list ar;
    285. 

  285.   char msg[256];
    286. 

  286.   int count;
    287. 

  287. 

  288.   va_start(ar, fmt);
    289. 

  289.   count = vsnprintf(msg, 256, fmt, ar);
    290. 

  290.   va_end(ar);
    291. 

  291. 

  292.   mel_yyerror(msg, st);
    293. 

  293. 

  294.   return count;
    295. 

  295. }
    296. 

  296. 

  297. static int _debug_print(const char *fmt, ...) {
    298. 

  298. #if SHOW_PARSER_WARNS
    299. 

  299.   va_list ar;
    300. 

  300.   int i;
    301. 

  301. 

  302.   va_start(ar, fmt);
    303. 

  303.   i = vprintf(fmt, ar);
    304. 

  304.   va_end(ar);
    305. 

  305.   return i;
    306. 

  306. #else
    307. 

  307.   return 0;
    308. 

  308. #endif
    309. 

  309. }
    310. 

  310. 

  311. #define rb_warn _debug_print
    312. 

  312. #define rb_warning _debug_print
    313. 

  313. 

  314. void push_start_line(rb_parser_state* parser_state, int line, const char* which) {
    315. 

  315.   start_lines->push_back(StartPosition(line, which));
    316. 

  316. }
    317. 

  317. 

  318. #define PUSH_LINE(which) push_start_line((rb_parser_state*)parser_state, ruby_sourceline, which)
    319. 

  319. 

  320. void pop_start_line(rb_parser_state* parser_state) {
    321. 

  321.   start_lines->pop_back();
    322. 

  322. }
    323. 

  323. 

  324. #define POP_LINE() pop_start_line((rb_parser_state*)parser_state)
    325. 

  325. 

  326. static QUID rb_parser_sym(const char *name);
    327. 

  327. static QUID rb_id_attrset(QUID);
    328. 

  328. 

  329. static int scan_oct(const char *start, int len, int *retlen);
    330. 

  330. static int scan_hex(const char *start, int len, int *retlen);
    331. 

  331. 

  332. static void reset_block(rb_parser_state *parser_state);
    333. 

  333. static NODE *extract_block_vars(rb_parser_state *parser_state, NODE* node, var_table vars);
    334. 

  334. 

  335. #ifndef RE_OPTION_IGNORECASE
    336. 

  336. #define RE_OPTION_IGNORECASE         (1)
    337. 

  337. #endif
    338. 

  338. 

  339. #ifndef RE_OPTION_EXTENDED
    340. 

  340. #define RE_OPTION_EXTENDED           (2)
    341. 

  341. #endif
    342. 

  342. 

  343. #ifndef RE_OPTION_MULTILINE
    344. 

  344. #define RE_OPTION_MULTILINE          (4)
    345. 

  345. #endif
    346. 

  346. 

  347. #define RE_OPTION_DONT_CAPTURE_GROUP (128)
    348. 

  348. #define RE_OPTION_CAPTURE_GROUP      (256)
    349. 

  349. #define RE_OPTION_ONCE               (8192)
    350. 

  350. 

  351. #define NODE_STRTERM NODE_ZARRAY        /* nothing to gc */
    352. 

  352. #define NODE_HEREDOC NODE_ARRAY         /* 1, 3 to gc */
    353. 

  353. #define SIGN_EXTEND(x,n) (((1<<((n)-1))^((x)&~(~0<<(n))))-(1<<((n)-1)))
    354. 

  354. #define nd_func u1.id
    355. 

  355. #if SIZEOF_SHORT != 2
    356. 

  356. #define nd_term(node) SIGN_EXTEND((node)->u2.id, (CHAR_BIT*2))
    357. 

  357. #else
    358. 

  358. #define nd_term(node) ((signed short)(node)->u2.id)
    359. 

  359. #endif
    360. 

  360. #define nd_paren(node) (char)((node)->u2.id >> (CHAR_BIT*2))
    361. 

  361. #define nd_nest u3.id
    362. 

  362. 

  363. #define NEW_BLOCK_VAR(b, v) NEW_NODE(NODE_BLOCK_PASS, 0, b, v)
    364. 

  364. 

  365. /* Older versions of Yacc set YYMAXDEPTH to a very low value by default (150,
    366. 

  366.    for instance).  This is too low for Ruby to parse some files, such as
    367. 

  367.    date/format.rb, therefore bump the value up to at least Bison's default. */
    368. 

  368. #ifdef OLD_YACC
    369. 

  369. #ifndef YYMAXDEPTH
    370. 

  370. #define YYMAXDEPTH 10000
    371. 

  371. #endif
    372. 

  372. #endif
    373. 

  373. 

  374. #define vps ((rb_parser_state*)parser_state)
    375. 

  375. 

  376. %}
    377. 

  377. 

  378. %pure-parser
    379. 

  379. 

  380. %union {
    381. 

  381.     VALUE val;
    382. 

  382.     NODE *node;
    383. 

  383.     QUID id;
    384. 

  384.     int num;
    385. 

  385.     var_table vars;
    386. 

  386. }
    387. 

  387. 

  388. %token  kCLASS
    389. 

  389.         kMODULE
    390. 

  390.         kDEF
    391. 

  391.         kUNDEF
    392. 

  392.         kBEGIN
    393. 

  393.         kRESCUE
    394. 

  394.         kENSURE
    395. 

  395.         kEND
    396. 

  396.         kIF
    397. 

  397.         kUNLESS
    398. 

  398.         kTHEN
    399. 

  399.         kELSIF
    400. 

  400.         kELSE
    401. 

  401.         kCASE
    402. 

  402.         kWHEN
    403. 

  403.         kWHILE
    404. 

  404.         kUNTIL
    405. 

  405.         kFOR
    406. 

  406.         kBREAK
    407. 

  407.         kNEXT
    408. 

  408.         kREDO
    409. 

  409.         kRETRY
    410. 

  410.         kIN
    411. 

  411.         kDO
    412. 

  412.         kDO_COND
    413. 

  413.         kDO_BLOCK
    414. 

  414.         kRETURN
    415. 

  415.         kYIELD
    416. 

  416.         kSUPER
    417. 

  417.         kSELF
    418. 

  418.         kNIL
    419. 

  419.         kTRUE
    420. 

  420.         kFALSE
    421. 

  421.         kAND
    422. 

  422.         kOR
    423. 

  423.         kNOT
    424. 

  424.         kIF_MOD
    425. 

  425.         kUNLESS_MOD
    426. 

  426.         kWHILE_MOD
    427. 

  427.         kUNTIL_MOD
    428. 

  428.         kRESCUE_MOD
    429. 

  429.         kALIAS
    430. 

  430.         kDEFINED
    431. 

  431.         klBEGIN
    432. 

  432.         klEND
    433. 

  433.         k__LINE__
    434. 

  434.         k__FILE__
    435. 

  435. 

  436. %token <id>   tIDENTIFIER tFID tGVAR tIVAR tCONSTANT tCVAR tXSTRING_BEG
    437. 

  437. %token <node> tINTEGER tFLOAT tSTRING_CONTENT
    438. 

  438. %token <node> tNTH_REF tBACK_REF
    439. 

  439. %token <num>  tREGEXP_END
    440. 

  440. %type <node> singleton strings string string1 xstring regexp
    441. 

  441. %type <node> string_contents xstring_contents string_content
    442. 

  442. %type <node> words qwords word_list qword_list word
    443. 

  443. %type <node> literal numeric dsym cpath
    444. 

  444. %type <node> bodystmt compstmt stmts stmt expr arg primary command command_call method_call
    445. 

  445. %type <node> expr_value arg_value primary_value
    446. 

  446. %type <node> if_tail opt_else case_body cases opt_rescue exc_list exc_var opt_ensure
    447. 

  447. %type <node> args when_args call_args call_args2 open_args paren_args opt_paren_args
    448. 

  448. %type <node> command_args aref_args opt_block_arg block_arg var_ref var_lhs
    449. 

  449. %type <node> mrhs superclass block_call block_command
    450. 

  450. %type <node> f_arglist f_args f_optarg f_opt f_block_arg opt_f_block_arg
    451. 

  451. %type <node> assoc_list assocs assoc undef_list backref string_dvar
    452. 

  452. %type <node> for_var block_var opt_block_var block_par
    453. 

  453. %type <node> brace_block cmd_brace_block do_block lhs none fitem
    454. 

  454. %type <node> mlhs mlhs_head mlhs_basic mlhs_entry mlhs_item mlhs_node
    455. 

  455. %type <id>   fsym variable sym symbol operation operation2 operation3
    456. 

  456. %type <id>   cname fname op f_rest_arg
    457. 

  457. %type <num>  f_norm_arg f_arg
    458. 

  458. %token tUPLUS           /* unary+ */
    459. 

  459. %token tUMINUS          /* unary- */
    460. 

  460. %token tUBS             /* unary\ */
    461. 

  461. %token tPOW             /* ** */
    462. 

  462. %token tCMP             /* <=> */
    463. 

  463. %token tEQ              /* == */
    464. 

  464. %token tEQQ             /* === */
    465. 

  465. %token tNEQ             /* != */
    466. 

  466. %token tGEQ             /* >= */
    467. 

  467. %token tLEQ             /* <= */
    468. 

  468. %token tANDOP tOROP     /* && and || */
    469. 

  469. %token tMATCH tNMATCH   /* =~ and !~ */
    470. 

  470. %token tDOT2 tDOT3      /* .. and ... */
    471. 

  471. %token tAREF tASET      /* [] and []= */
    472. 

  472. %token tLSHFT tRSHFT    /* << and >> */
    473. 

  473. %token tCOLON2          /* :: */
    474. 

  474. %token tCOLON3          /* :: at EXPR_BEG */
    475. 

  475. %token <id> tOP_ASGN    /* +=, -=  etc. */
    476. 

  476. %token tASSOC           /* => */
    477. 

  477. %token tLPAREN          /* ( */
    478. 

  478. %token tLPAREN_ARG      /* ( */
    479. 

  479. %token tRPAREN          /* ) */
    480. 

  480. %token tLBRACK          /* [ */
    481. 

  481. %token tLBRACE          /* { */
    482. 

  482. %token tLBRACE_ARG      /* { */
    483. 

  483. %token tSTAR            /* * */
    484. 

  484. %token tAMPER           /* & */
    485. 

  485. %token tSYMBEG tSTRING_BEG tREGEXP_BEG tWORDS_BEG tQWORDS_BEG
    486. 

  486. %token tSTRING_DBEG tSTRING_DVAR tSTRING_END
    487. 

  487. 

  488. /*
    489. 

  489.  *      precedence table
    490. 

  490.  */
    491. 

  491. 

  492. %nonassoc tLOWEST
    493. 

  493. %nonassoc tLBRACE_ARG
    494. 

  494. 

  495. %nonassoc  kIF_MOD kUNLESS_MOD kWHILE_MOD kUNTIL_MOD
    496. 

  496. %left  kOR kAND
    497. 

  497. %right kNOT
    498. 

  498. %nonassoc kDEFINED
    499. 

  499. %right '=' tOP_ASGN
    500. 

  500. %left kRESCUE_MOD
    501. 

  501. %right '?' ':'
    502. 

  502. %nonassoc tDOT2 tDOT3
    503. 

  503. %left  tOROP
    504. 

  504. %left  tANDOP
    505. 

  505. %nonassoc  tCMP tEQ tEQQ tNEQ tMATCH tNMATCH
    506. 

  506. %left  '>' tGEQ '<' tLEQ
    507. 

  507. %left  '|' '^'
    508. 

  508. %left  '&'
    509. 

  509. %left  tLSHFT tRSHFT
    510. 

  510. %left  '+' '-'
    511. 

  511. %left  '*' '/' '%'
    512. 

  512. %right tUMINUS_NUM tUMINUS
    513. 

  513. %right tPOW
    514. 

  514. %right '!' '~' tUPLUS
    515. 

  515. 

  516. %token tLAST_TOKEN
    517. 

  517. 

  518. %%
    519. 

  519. program         :  {
    520. 

  520.                         lex_state = EXPR_BEG;
    521. 

  521.                         variables = new LocalState(0);
    522. 

  522.                         class_nest = 0;
    523. 

  523.                     }
    524. 

  524.                   compstmt
    525. 

  525.                     {
    526. 

  526.                         if ($2 && !compile_for_eval) {
    527. 

  527.                             /* last expression should not be void */
    528. 

  528.                             if (nd_type($2) != NODE_BLOCK) void_expr($2);
    529. 

  529.                             else {
    530. 

  530.                                 NODE *node = $2;
    531. 

  531.                                 while (node->nd_next) {
    532. 

  532.                                     node = node->nd_next;
    533. 

  533.                                 }
    534. 

  534.                                 void_expr(node->nd_head);
    535. 

  535.                             }
    536. 

  536.                         }
    537. 

  537.                         top_node = block_append(vps, top_node, $2);
    538. 

  538.                         class_nest = 0;
    539. 

  539.                     }
    540. 

  540.                 ;
    541. 

  541. 

  542. bodystmt        : compstmt
    543. 

  543.                   opt_rescue
    544. 

  544.                   opt_else
    545. 

  545.                   opt_ensure
    546. 

  546.                     {
    547. 

  547.                         $$ = $1;
    548. 

  548.                         if ($2) {
    549. 

  549.                             $$ = NEW_RESCUE($1, $2, $3);
    550. 

  550.                         }
    551. 

  551.                         else if ($3) {
    552. 

  552.                             rb_warn("else without rescue is useless");
    553. 

  553.                             $$ = block_append(vps, $$, $3);
    554. 

  554.                         }
    555. 

  555.                         if ($4) {
    556. 

  556.                             $$ = NEW_ENSURE($$, $4);
    557. 

  557.                         }
    558. 

  558.                         fixpos($$, $1);
    559. 

  559.                     }
    560. 

  560.                 ;
    561. 

  561. 

  562. compstmt        : stmts opt_terms
    563. 

  563.                     {
    564. 

  564.                         void_stmts($1, vps);
    565. 

  565.                         $$ = $1;
    566. 

  566.                     }
    567. 

  567.                 ;
    568. 

  568. 

  569. stmts           : none
    570. 

  570.                 | stmt
    571. 

  571.                     {
    572. 

  572.                         $$ = newline_node(vps, $1);
    573. 

  573.                     }
    574. 

  574.                 | stmts terms stmt
    575. 

  575.                     {
    576. 

  576.                         $$ = block_append(vps, $1, newline_node(vps, $3));
    577. 

  577.                     }
    578. 

  578.                 | error stmt
    579. 

  579.                     {
    580. 

  580.                         $$ = remove_begin($2, vps);
    581. 

  581.                     }
    582. 

  582.                 ;
    583. 

  583. 

  584. stmt            : kALIAS fitem {lex_state = EXPR_FNAME;} fitem
    585. 

  585.                     {
    586. 

  586.                         $$ = NEW_ALIAS($2, $4);
    587. 

  587.                     }
    588. 

  588.                 | kALIAS tGVAR tGVAR
    589. 

  589.                     {
    590. 

  590.                         $$ = NEW_VALIAS($2, $3);
    591. 

  591.                     }
    592. 

  592.                 | kALIAS tGVAR tBACK_REF
    593. 

  593.                     {
    594. 

  594.                         char buf[3];
    595. 

  595. 

  596.                         snprintf(buf, sizeof(buf), "$%c", (char)$3->nd_nth);
    597. 

  597.                         $$ = NEW_VALIAS($2, rb_parser_sym(buf));
    598. 

  598.                     }
    599. 

  599.                 | kALIAS tGVAR tNTH_REF
    600. 

  600.                     {
    601. 

  601.                         yyerror("can't make alias for the number variables");
    602. 

  602.                         $$ = 0;
    603. 

  603.                     }
    604. 

  604.                 | kUNDEF undef_list
    605. 

  605.                     {
    606. 

  606.                         $$ = $2;
    607. 

  607.                     }
    608. 

  608.                 | stmt kIF_MOD expr_value
    609. 

  609.                     {
    610. 

  610.                         $$ = NEW_IF(cond($3, vps), remove_begin($1, vps), 0);
    611. 

  611.                         fixpos($$, $3);
    612. 

  612.                         if (cond_negative(&$$->nd_cond)) {
    613. 

  613.                             $$->nd_else = $$->nd_body;
    614. 

  614.                             $$->nd_body = 0;
    615. 

  615.                         }
    616. 

  616.                     }
    617. 

  617.                 | stmt kUNLESS_MOD expr_value
    618. 

  618.                     {
    619. 

  619.                         $$ = NEW_UNLESS(cond($3, vps), remove_begin($1, vps), 0);
    620. 

  620.                         fixpos($$, $3);
    621. 

  621.                         if (cond_negative(&$$->nd_cond)) {
    622. 

  622.                             $$->nd_body = $$->nd_else;
    623. 

  623.                             $$->nd_else = 0;
    624. 

  624.                         }
    625. 

  625.                     }
    626. 

  626.                 | stmt kWHILE_MOD expr_value
    627. 

  627.                     {
    628. 

  628.                         if ($1 && nd_type($1) == NODE_BEGIN) {
    629. 

  629.                             $$ = NEW_WHILE(cond($3, vps), $1->nd_body, 0);
    630. 

  630.                         }
    631. 

  631.                         else {
    632. 

  632.                             $$ = NEW_WHILE(cond($3, vps), $1, 1);
    633. 

  633.                         }
    634. 

  634.                         if (cond_negative(&$$->nd_cond)) {
    635. 

  635.                             nd_set_type($$, NODE_UNTIL);
    636. 

  636.                         }
    637. 

  637.                     }
    638. 

  638.                 | stmt kUNTIL_MOD expr_value
    639. 

  639.                     {
    640. 

  640.                         if ($1 && nd_type($1) == NODE_BEGIN) {
    641. 

  641.                             $$ = NEW_UNTIL(cond($3, vps), $1->nd_body, 0);
    642. 

  642.                         }
    643. 

  643.                         else {
    644. 

  644.                             $$ = NEW_UNTIL(cond($3, vps), $1, 1);
    645. 

  645.                         }
    646. 

  646.                         if (cond_negative(&$$->nd_cond)) {
    647. 

  647.                             nd_set_type($$, NODE_WHILE);
    648. 

  648.                         }
    649. 

  649.                     }
    650. 

  650.                 | stmt kRESCUE_MOD stmt
    651. 

  651.                     {
    652. 

  652.                         NODE *resq = NEW_RESBODY(0, remove_begin($3, vps), 0);
    653. 

  653.                         $$ = NEW_RESCUE(remove_begin($1, vps), resq, 0);
    654. 

  654.                     }
    655. 

  655.                 | klBEGIN
    656. 

  656.                     {
    657. 

  657.                         if (in_def || in_single) {
    658. 

  658.                             yyerror("BEGIN in method");
    659. 

  659.                         }
    660. 

  660.                         local_push(0);
    661. 

  661.                     }
    662. 

  662.                   '{' compstmt '}'
    663. 

  663.                     {
    664. 

  664.                         /*
    665. 

  665.                         ruby_eval_tree_begin = block_append(ruby_eval_tree_begin,
    666. 

  666.                                                             NEW_PREEXE($4));
    667. 

  667.                         */
    668. 

  668.                         local_pop();
    669. 

  669.                         $$ = 0;
    670. 

  670.                     }
    671. 

  671.                 | klEND '{' compstmt '}'
    672. 

  672.                     {
    673. 

  673.                         if (in_def || in_single) {
    674. 

  674.                             rb_warn("END in method; use at_exit");
    675. 

  675.                         }
    676. 

  676. 

  677.                         $$ = NEW_ITER(0, NEW_POSTEXE(), $3);
    678. 

  678.                     }
    679. 

  679.                 | lhs '=' command_call
    680. 

  680.                     {
    681. 

  681.                         $$ = node_assign($1, $3, vps);
    682. 

  682.                     }
    683. 

  683.                 | mlhs '=' command_call
    684. 

  684.                     {
    685. 

  685.                         value_expr($3);
    686. 

  686.                         $1->nd_value = ($1->nd_head) ? NEW_TO_ARY($3) : NEW_ARRAY($3);
    687. 

  687.                         $$ = $1;
    688. 

  688.                     }
    689. 

  689.                 | var_lhs tOP_ASGN command_call
    690. 

  690.                     {
    691. 

  691.                         value_expr($3);
    692. 

  692.                         if ($1) {
    693. 

  693.                             QUID vid = $1->nd_vid;
    694. 

  694.                             if ($2 == tOROP) {
    695. 

  695.                                 $1->nd_value = $3;
    696. 

  696.                                 $$ = NEW_OP_ASGN_OR(gettable(vid), $1);
    697. 

  697.                                 if (is_asgn_or_id(vid)) {
    698. 

  698.                                     $$->nd_aid = vid;
    699. 

  699.                                 }
    700. 

  700.                             }
    701. 

  701.                             else if ($2 == tANDOP) {
    702. 

  702.                                 $1->nd_value = $3;
    703. 

  703.                                 $$ = NEW_OP_ASGN_AND(gettable(vid), $1);
    704. 

  704.                             }
    705. 

  705.                             else {
    706. 

  706.                                 $$ = $1;
    707. 

  707.                                 $$->nd_value = call_op(gettable(vid),$2,1,$3, vps);
    708. 

  708.                             }
    709. 

  709.                         }
    710. 

  710.                         else {
    711. 

  711.                             $$ = 0;
    712. 

  712.                         }
    713. 

  713.                     }
    714. 

  714.                 | primary_value '[' aref_args ']' tOP_ASGN command_call
    715. 

  715.                     {
    716. 

  716.                         NODE *args;
    717. 

  717. 

  718.                         value_expr($6);
    719. 

  719.                         if (!$3) $3 = NEW_ZARRAY();
    720. 

  720.                         args = arg_concat(vps, $6, $3);
    721. 

  721.                         if ($5 == tOROP) {
    722. 

  722.                             $5 = 0;
    723. 

  723.                         }
    724. 

  724.                         else if ($5 == tANDOP) {
    725. 

  725.                             $5 = 1;
    726. 

  726.                         }
    727. 

  727.                         $$ = NEW_OP_ASGN1($1, $5, args);
    728. 

  728.                         fixpos($$, $1);
    729. 

  729.                     }
    730. 

  730.                 | primary_value '.' tIDENTIFIER tOP_ASGN command_call
    731. 

  731.                     {
    732. 

  732.                         value_expr($5);
    733. 

  733.                         if ($4 == tOROP) {
    734. 

  734.                             $4 = 0;
    735. 

  735.                         }
    736. 

  736.                         else if ($4 == tANDOP) {
    737. 

  737.                             $4 = 1;
    738. 

  738.                         }
    739. 

  739.                         $$ = NEW_OP_ASGN2($1, $3, $4, $5);
    740. 

  740.                         fixpos($$, $1);
    741. 

  741.                     }
    742. 

  742.                 | primary_value '.' tCONSTANT tOP_ASGN command_call
    743. 

  743.                     {
    744. 

  744.                         value_expr($5);
    745. 

  745.                         if ($4 == tOROP) {
    746. 

  746.                             $4 = 0;
    747. 

  747.                         }
    748. 

  748.                         else if ($4 == tANDOP) {
    749. 

  749.                             $4 = 1;
    750. 

  750.                         }
    751. 

  751.                         $$ = NEW_OP_ASGN2($1, $3, $4, $5);
    752. 

  752.                         fixpos($$, $1);
    753. 

  753.                     }
    754. 

  754.                 | primary_value tCOLON2 tIDENTIFIER tOP_ASGN command_call
    755. 

  755.                     {
    756. 

  756.                         value_expr($5);
    757. 

  757.                         if ($4 == tOROP) {
    758. 

  758.                             $4 = 0;
    759. 

  759.                         }
    760. 

  760.                         else if ($4 == tANDOP) {
    761. 

  761.                             $4 = 1;
    762. 

  762.                         }
    763. 

  763.                         $$ = NEW_OP_ASGN2($1, $3, $4, $5);
    764. 

  764.                         fixpos($$, $1);
    765. 

  765.                     }
    766. 

  766.                 | backref tOP_ASGN command_call
    767. 

  767.                     {
    768. 

  768.                         rb_backref_error($1, vps);
    769. 

  769.                         $$ = 0;
    770. 

  770.                     }
    771. 

  771.                 | lhs '=' mrhs
    772. 

  772.                     {
    773. 

  773.                         $$ = node_assign($1, NEW_SVALUE($3), vps);
    774. 

  774.                     }
    775. 

  775.                 | mlhs '=' arg_value
    776. 

  776.                     {
    777. 

  777.                         $1->nd_value = ($1->nd_head) ? NEW_TO_ARY($3) : NEW_ARRAY($3);
    778. 

  778.                         $$ = $1;
    779. 

  779.                     }
    780. 

  780.                 | mlhs '=' mrhs
    781. 

  781.                     {
    782. 

  782.                         $1->nd_value = $3;
    783. 

  783.                         $$ = $1;
    784. 

  784.                     }
    785. 

  785.                 | expr
    786. 

  786.                 ;
    787. 

  787. 

  788. expr            : command_call
    789. 

  789.                 | expr kAND expr
    790. 

  790.                     {
    791. 

  791.                         $$ = logop(NODE_AND, $1, $3, vps);
    792. 

  792.                     }
    793. 

  793.                 | expr kOR expr
    794. 

  794.                     {
    795. 

  795.                         $$ = logop(NODE_OR, $1, $3, vps);
    796. 

  796.                     }
    797. 

  797.                 | kNOT expr
    798. 

  798.                     {
    799. 

  799.                         $$ = NEW_NOT(cond($2, vps));
    800. 

  800.                     }
    801. 

  801.                 | '!' command_call
    802. 

  802.                     {
    803. 

  803.                         $$ = NEW_NOT(cond($2, vps));
    804. 

  804.                     }
    805. 

  805.                 | arg
    806. 

  806.                 ;
    807. 

  807. 

  808. expr_value      : expr
    809. 

  809.                     {
    810. 

  810.                         value_expr($$);
    811. 

  811.                         $$ = $1;
    812. 

  812.                     }
    813. 

  813.                 ;
    814. 

  814. 

  815. command_call    : command
    816. 

  816.                 | block_command
    817. 

  817.                 | kRETURN call_args
    818. 

  818.                     {
    819. 

  819.                         $$ = NEW_RETURN(ret_args(vps, $2));
    820. 

  820.                     }
    821. 

  821.                 | kBREAK call_args
    822. 

  822.                     {
    823. 

  823.                         $$ = NEW_BREAK(ret_args(vps, $2));
    824. 

  824.                     }
    825. 

  825.                 | kNEXT call_args
    826. 

  826.                     {
    827. 

  827.                         $$ = NEW_NEXT(ret_args(vps, $2));
    828. 

  828.                     }
    829. 

  829.                 ;
    830. 

  830. 

  831. block_command   : block_call
    832. 

  832.                 | block_call '.' operation2 command_args
    833. 

  833.                     {
    834. 

  834.                         $$ = new_call(vps, $1, $3, $4);
    835. 

  835.                     }
    836. 

  836.                 | block_call tCOLON2 operation2 command_args
    837. 

  837.                     {
    838. 

  838.                         $$ = new_call(vps, $1, $3, $4);
    839. 

  839.                     }
    840. 

  840.                 ;
    841. 

  841. 

  842. cmd_brace_block : tLBRACE_ARG
    843. 

  843.                     {
    844. 

  844.                         $<num>1 = ruby_sourceline;
    845. 

  845.                         reset_block(vps);
    846. 

  846.                     }
    847. 

  847.                   opt_block_var { $<vars>$ = variables->block_vars; }
    848. 

  848.                   compstmt
    849. 

  849.                   '}'
    850. 

  850.                     {
    851. 

  851.                         $$ = NEW_ITER($3, 0, extract_block_vars(vps, $5, $<vars>4));
    852. 

  852.                         nd_set_line($$, $<num>1);
    853. 

  853.                     }
    854. 

  854.                 ;
    855. 

  855. 

  856. command         : operation command_args       %prec tLOWEST
    857. 

  857.                     {
    858. 

  858.                         $$ = new_fcall(vps, $1, $2);
    859. 

  859.                         fixpos($$, $2);
    860. 

  860.                    }
    861. 

  861.                 | operation command_args cmd_brace_block
    862. 

  862.                     {
    863. 

  863.                         $$ = new_fcall(vps, $1, $2);
    864. 

  864.                         if ($3) {
    865. 

  865.                             if (nd_type($$) == NODE_BLOCK_PASS) {
    866. 

  866.                                 rb_compile_error(vps, "both block arg and actual block given");
    867. 

  867.                             }
    868. 

  868.                             $3->nd_iter = $$;
    869. 

  869.                             $$ = $3;
    870. 

  870.                         }
    871. 

  871.                         fixpos($$, $2);
    872. 

  872.                    }
    873. 

  873.                 | primary_value '.' operation2 command_args     %prec tLOWEST
    874. 

  874.                     {
    875. 

  875.                         $$ = new_call(vps, $1, $3, $4);
    876. 

  876.                         fixpos($$, $1);
    877. 

  877.                     }
    878. 

  878.                 | primary_value '.' operation2 command_args cmd_brace_block
    879. 

  879.                     {
    880. 

  880.                         $$ = new_call(vps, $1, $3, $4);
    881. 

  881.                         if ($5) {
    882. 

  882.                             if (nd_type($$) == NODE_BLOCK_PASS) {
    883. 

  883.                                 rb_compile_error(vps, "both block arg and actual block given");
    884. 

  884.                             }
    885. 

  885.                             $5->nd_iter = $$;
    886. 

  886.                             $$ = $5;
    887. 

  887.                         }
    888. 

  888.                         fixpos($$, $1);
    889. 

  889.                    }
    890. 

  890.                 | primary_value tCOLON2 operation2 command_args %prec tLOWEST
    891. 

  891.                     {
    892. 

  892.                         $$ = new_call(vps, $1, $3, $4);
    893. 

  893.                         fixpos($$, $1);
    894. 

  894.                     }
    895. 

  895.                 | primary_value tCOLON2 operation2 command_args cmd_brace_block
    896. 

  896.                     {
    897. 

  897.                         $$ = new_call(vps, $1, $3, $4);
    898. 

  898.                         if ($5) {
    899. 

  899.                             if (nd_type($$) == NODE_BLOCK_PASS) {
    900. 

  900.                                 rb_compile_error(vps, "both block arg and actual block given");
    901. 

  901.                             }
    902. 

  902.                             $5->nd_iter = $$;
    903. 

  903.                             $$ = $5;
    904. 

  904.                         }
    905. 

  905.                         fixpos($$, $1);
    906. 

  906.                    }
    907. 

  907.                 | kSUPER command_args
    908. 

  908.                     {
    909. 

  909.                         $$ = new_super(vps, $2);
    910. 

  910.                         fixpos($$, $2);
    911. 

  911.                     }
    912. 

  912.                 | kYIELD command_args
    913. 

  913.                     {
    914. 

  914.                         $$ = new_yield(vps, $2);
    915. 

  915.                         fixpos($$, $2);
    916. 

  916.                     }
    917. 

  917.                 ;
    918. 

  918. 

  919. mlhs            : mlhs_basic
    920. 

  920.                 | tLPAREN mlhs_entry ')'
    921. 

  921.                     {
    922. 

  922.                         $$ = $2;
    923. 

  923.                     }
    924. 

  924.                 ;
    925. 

  925. 

  926. mlhs_entry      : mlhs_basic
    927. 

  927.                 | tLPAREN mlhs_entry ')'
    928. 

  928.                     {
    929. 

  929.                         $$ = NEW_MASGN(NEW_LIST($2), 0);
    930. 

  930.                     }
    931. 

  931.                 ;
    932. 

  932. 

  933. mlhs_basic      : mlhs_head
    934. 

  934.                     {
    935. 

  935.                         $$ = NEW_MASGN($1, 0);
    936. 

  936.                     }
    937. 

  937.                 | mlhs_head mlhs_item
    938. 

  938.                     {
    939. 

  939.                         $$ = NEW_MASGN(list_append(vps, $1,$2), 0);
    940. 

  940.                     }
    941. 

  941.                 | mlhs_head tSTAR mlhs_node
    942. 

  942.                     {
    943. 

  943.                         $$ = NEW_MASGN($1, $3);
    944. 

  944.                     }
    945. 

  945.                 | mlhs_head tSTAR
    946. 

  946.                     {
    947. 

  947.                         $$ = NEW_MASGN($1, -1);
    948. 

  948.                     }
    949. 

  949.                 | tSTAR mlhs_node
    950. 

  950.                     {
    951. 

  951.                         $$ = NEW_MASGN(0, $2);
    952. 

  952.                     }
    953. 

  953.                 | tSTAR
    954. 

  954.                     {
    955. 

  955.                         $$ = NEW_MASGN(0, -1);
    956. 

  956.                     }
    957. 

  957.                 ;
    958. 

  958. 

  959. mlhs_item       : mlhs_node
    960. 

  960.                 | tLPAREN mlhs_entry ')'
    961. 

  961.                     {
    962. 

  962.                         $$ = $2;
    963. 

  963.                     }
    964. 

  964.                 ;
    965. 

  965. 

  966. mlhs_head       : mlhs_item ','
    967. 

  967.                     {
    968. 

  968.                         $$ = NEW_LIST($1);
    969. 

  969.                     }
    970. 

  970.                 | mlhs_head mlhs_item ','
    971. 

  971.                     {
    972. 

  972.                         $$ = list_append(vps, $1, $2);
    973. 

  973.                     }
    974. 

  974.                 ;
    975. 

  975. 

  976. mlhs_node       : variable
    977. 

  977.                     {
    978. 

  978.                         $$ = assignable($1, 0, vps);
    979. 

  979.                     }
    980. 

  980.                 | primary_value '[' aref_args ']'
    981. 

  981.                     {
    982. 

  982.                         $$ = aryset($1, $3, vps);
    983. 

  983.                     }
    984. 

  984.                 | primary_value '.' tIDENTIFIER
    985. 

  985.                     {
    986. 

  986.                         $$ = attrset($1, $3, vps);
    987. 

  987.                     }
    988. 

  988.                 | primary_value tCOLON2 tIDENTIFIER
    989. 

  989.                     {
    990. 

  990.                         $$ = attrset($1, $3, vps);
    991. 

  991.                     }
    992. 

  992.                 | primary_value '.' tCONSTANT
    993. 

  993.                     {
    994. 

  994.                         $$ = attrset($1, $3, vps);
    995. 

  995.                     }
    996. 

  996.                 | primary_value tCOLON2 tCONSTANT
    997. 

  997.                     {
    998. 

  998.                         if (in_def || in_single)
    999. 

  999.                             yyerror("dynamic constant assignment");
    1000. 

  1000.                         $$ = NEW_CDECL(0, 0, NEW_COLON2($1, $3));
    1001. 

  1001.                     }
    1002. 

  1002.                 | tCOLON3 tCONSTANT
    1003. 

  1003.                     {
    1004. 

  1004.                         if (in_def || in_single)
    1005. 

  1005.                             yyerror("dynamic constant assignment");
    1006. 

  1006.                         $$ = NEW_CDECL(0, 0, NEW_COLON3($2));
    1007. 

  1007.                     }
    1008. 

  1008.                 | backref
    1009. 

  1009.                     {
    1010. 

  1010.                         rb_backref_error($1, vps);
    1011. 

  1011.                         $$ = 0;
    1012. 

  1012.                     }
    1013. 

  1013.                 ;
    1014. 

  1014. 

  1015. lhs             : variable
    1016. 

  1016.                     {
    1017. 

  1017.                         $$ = assignable($1, 0, vps);
    1018. 

  1018.                     }
    1019. 

  1019.                 | primary_value '[' aref_args ']'
    1020. 

  1020.                     {
    1021. 

  1021.                         $$ = aryset($1, $3, vps);
    1022. 

  1022.                     }
    1023. 

  1023.                 | primary_value '.' tIDENTIFIER
    1024. 

  1024.                     {
    1025. 

  1025.                         $$ = attrset($1, $3, vps);
    1026. 

  1026.                     }
    1027. 

  1027.                 | primary_value tCOLON2 tIDENTIFIER
    1028. 

  1028.                     {
    1029. 

  1029.                         $$ = attrset($1, $3, vps);
    1030. 

  1030.                     }
    1031. 

  1031.                 | primary_value '.' tCONSTANT
    1032. 

  1032.                     {
    1033. 

  1033.                         $$ = attrset($1, $3, vps);
    1034. 

  1034.                     }
    1035. 

  1035.                 | primary_value tCOLON2 tCONSTANT
    1036. 

  1036.                     {
    1037. 

  1037.                         if (in_def || in_single)
    1038. 

  1038.                             yyerror("dynamic constant assignment");
    1039. 

  1039.                         $$ = NEW_CDECL(0, 0, NEW_COLON2($1, $3));
    1040. 

  1040.                     }
    1041. 

  1041.                 | tCOLON3 tCONSTANT
    1042. 

  1042.                     {
    1043. 

  1043.                         if (in_def || in_single)
    1044. 

  1044.                             yyerror("dynamic constant assignment");
    1045. 

  1045.                         $$ = NEW_CDECL(0, 0, NEW_COLON3($2));
    1046. 

  1046.                     }
    1047. 

  1047.                 | backref
    1048. 

  1048.                     {
    1049. 

  1049.                         rb_backref_error($1, vps);
    1050. 

  1050.                         $$ = 0;
    1051. 

  1051.                     }
    1052. 

  1052.                 ;
    1053. 

  1053. 

  1054. cname           : tIDENTIFIER
    1055. 

  1055.                     {
    1056. 

  1056.                         yyerror("class/module name must be CONSTANT");
    1057. 

  1057.                     }
    1058. 

  1058.                 | tCONSTANT
    1059. 

  1059.                 ;
    1060. 

  1060. 

  1061. cpath           : tCOLON3 cname
    1062. 

  1062.                     {
    1063. 

  1063.                         $$ = NEW_COLON3($2);
    1064. 

  1064.                     }
    1065. 

  1065.                 | cname
    1066. 

  1066.                     {
    1067. 

  1067.                         $$ = NEW_COLON2(0, $$);
    1068. 

  1068.                     }
    1069. 

  1069.                 | primary_value tCOLON2 cname
    1070. 

  1070.                     {
    1071. 

  1071.                         $$ = NEW_COLON2($1, $3);
    1072. 

  1072.                     }
    1073. 

  1073.                 ;
    1074. 

  1074. 

  1075. fname           : tIDENTIFIER
    1076. 

  1076.                 | tCONSTANT
    1077. 

  1077.                 | tFID
    1078. 

  1078.                 | op
    1079. 

  1079.                     {
    1080. 

  1080.                         lex_state = EXPR_END;
    1081. 

  1081.                         $$ = convert_op($1);
    1082. 

  1082.                     }
    1083. 

  1083.                 | reswords
    1084. 

  1084.                     {
    1085. 

  1085.                         lex_state = EXPR_END;
    1086. 

  1086.                         $$ = $<id>1;
    1087. 

  1087.                     }
    1088. 

  1088.                 ;
    1089. 

  1089. 

  1090. fsym            : fname
    1091. 

  1091.                 | symbol
    1092. 

  1092.                 ;
    1093. 

  1093. 

  1094. fitem           : fsym
    1095. 

  1095.                     {
    1096. 

  1096.                         $$ = NEW_LIT(QUID2SYM($1));
    1097. 

  1097.                     }
    1098. 

  1098.                 | dsym
    1099. 

  1099.                 ;
    1100. 

  1100. 

  1101. undef_list      : fitem
    1102. 

  1102.                     {
    1103. 

  1103.                         $$ = NEW_UNDEF($1);
    1104. 

  1104.                     }
    1105. 

  1105.                 | undef_list ',' {lex_state = EXPR_FNAME;} fitem
    1106. 

  1106.                     {
    1107. 

  1107.                         $$ = block_append(vps, $1, NEW_UNDEF($4));
    1108. 

  1108.                     }
    1109. 

  1109.                 ;
    1110. 

  1110. 

  1111. op              : '|'           { $$ = '|'; }
    1112. 

  1112.                 | '^'           { $$ = '^'; }
    1113. 

  1113.                 | '&'           { $$ = '&'; }
    1114. 

  1114.                 | tCMP          { $$ = tCMP; }
    1115. 

  1115.                 | tEQ           { $$ = tEQ; }
    1116. 

  1116.                 | tEQQ          { $$ = tEQQ; }
    1117. 

  1117.                 | tMATCH        { $$ = tMATCH; }
    1118. 

  1118.                 | '>'           { $$ = '>'; }
    1119. 

  1119.                 | tGEQ          { $$ = tGEQ; }
    1120. 

  1120.                 | '<'           { $$ = '<'; }
    1121. 

  1121.                 | tLEQ          { $$ = tLEQ; }
    1122. 

  1122.                 | tLSHFT        { $$ = tLSHFT; }
    1123. 

  1123.                 | tRSHFT        { $$ = tRSHFT; }
    1124. 

  1124.                 | '+'           { $$ = '+'; }
    1125. 

  1125.                 | '-'           { $$ = '-'; }
    1126. 

  1126.                 | '*'           { $$ = '*'; }
    1127. 

  1127.                 | tSTAR         { $$ = '*'; }
    1128. 

  1128.                 | '/'           { $$ = '/'; }
    1129. 

  1129.                 | '%'           { $$ = '%'; }
    1130. 

  1130.                 | tPOW          { $$ = tPOW; }
    1131. 

  1131.                 | '~'           { $$ = '~'; }
    1132. 

  1132.                 | tUPLUS        { $$ = tUPLUS; }
    1133. 

  1133.                 | tUMINUS       { $$ = tUMINUS; }
    1134. 

  1134.                 | tAREF         { $$ = tAREF; }
    1135. 

  1135.                 | tASET         { $$ = tASET; }
    1136. 

  1136.                 | '`'           { $$ = '`'; }
    1137. 

  1137.                 ;
    1138. 

  1138. 

  1139. reswords        : k__LINE__ | k__FILE__  | klBEGIN | klEND
    1140. 

  1140.                 | kALIAS | kAND | kBEGIN | kBREAK | kCASE | kCLASS | kDEF
    1141. 

  1141.                 | kDEFINED | kDO | kELSE | kELSIF | kEND | kENSURE | kFALSE
    1142. 

  1142.                 | kFOR | kIN | kMODULE | kNEXT | kNIL | kNOT
    1143. 

  1143.                 | kOR | kREDO | kRESCUE | kRETRY | kRETURN | kSELF | kSUPER
    1144. 

  1144.                 | kTHEN | kTRUE | kUNDEF | kWHEN | kYIELD
    1145. 

  1145.                 | kIF_MOD | kUNLESS_MOD | kWHILE_MOD | kUNTIL_MOD | kRESCUE_MOD
    1146. 

  1146.                 ;
    1147. 

  1147. 

  1148. arg             : lhs '=' arg
    1149. 

  1149.                     {
    1150. 

  1150.                         $$ = node_assign($1, $3, vps);
    1151. 

  1151.                     }
    1152. 

  1152.                 | lhs '=' arg kRESCUE_MOD arg
    1153. 

  1153.                     {
    1154. 

  1154.                         $$ = node_assign($1, NEW_RESCUE($3, NEW_RESBODY(0,$5,0), 0), vps);
    1155. 

  1155.                     }
    1156. 

  1156.                 | var_lhs tOP_ASGN arg
    1157. 

  1157.                     {
    1158. 

  1158.                         value_expr($3);
    1159. 

  1159.                         if ($1) {
    1160. 

  1160.                             QUID vid = $1->nd_vid;
    1161. 

  1161.                             if ($2 == tOROP) {
    1162. 

  1162.                                 $1->nd_value = $3;
    1163. 

  1163.                                 $$ = NEW_OP_ASGN_OR(gettable(vid), $1);
    1164. 

  1164.                                 if (is_asgn_or_id(vid)) {
    1165. 

  1165.                                     $$->nd_aid = vid;
    1166. 

  1166.                                 }
    1167. 

  1167.                             }
    1168. 

  1168.                             else if ($2 == tANDOP) {
    1169. 

  1169.                                 $1->nd_value = $3;
    1170. 

  1170.                                 $$ = NEW_OP_ASGN_AND(gettable(vid), $1);
    1171. 

  1171.                             }
    1172. 

  1172.                             else {
    1173. 

  1173.                                 $$ = $1;
    1174. 

  1174.                                 $$->nd_value = call_op(gettable(vid),$2,1,$3, vps);
    1175. 

  1175.                             }
    1176. 

  1176.                         }
    1177. 

  1177.                         else {
    1178. 

  1178.                             $$ = 0;
    1179. 

  1179.                         }
    1180. 

  1180.                     }
    1181. 

  1181.                 | primary_value '[' aref_args ']' tOP_ASGN arg
    1182. 

  1182.                     {
    1183. 

  1183.                         NODE *args;
    1184. 

  1184. 

  1185.                         value_expr($6);
    1186. 

  1186.                         if (!$3) $3 = NEW_ZARRAY();
    1187. 

  1187.                         args = arg_concat(vps, $6, $3);
    1188. 

  1188.                         if ($5 == tOROP) {
    1189. 

  1189.                             $5 = 0;
    1190. 

  1190.                         }
    1191. 

  1191.                         else if ($5 == tANDOP) {
    1192. 

  1192.                             $5 = 1;
    1193. 

  1193.                         }
    1194. 

  1194.                         $$ = NEW_OP_ASGN1($1, $5, args);
    1195. 

  1195.                         fixpos($$, $1);
    1196. 

  1196.                     }
    1197. 

  1197.                 | primary_value '.' tIDENTIFIER tOP_ASGN arg
    1198. 

  1198.                     {
    1199. 

  1199.                         value_expr($5);
    1200. 

  1200.                         if ($4 == tOROP) {
    1201. 

  1201.                             $4 = 0;
    1202. 

  1202.                         }
    1203. 

  1203.                         else if ($4 == tANDOP) {
    1204. 

  1204.                             $4 = 1;
    1205. 

  1205.                         }
    1206. 

  1206.                         $$ = NEW_OP_ASGN2($1, $3, $4, $5);
    1207. 

  1207.                         fixpos($$, $1);
    1208. 

  1208.                     }
    1209. 

  1209.                 | primary_value '.' tCONSTANT tOP_ASGN arg
    1210. 

  1210.                     {
    1211. 

  1211.                         value_expr($5);
    1212. 

  1212.                         if ($4 == tOROP) {
    1213. 

  1213.                             $4 = 0;
    1214. 

  1214.                         }
    1215. 

  1215.                         else if ($4 == tANDOP) {
    1216. 

  1216.                             $4 = 1;
    1217. 

  1217.                         }
    1218. 

  1218.                         $$ = NEW_OP_ASGN2($1, $3, $4, $5);
    1219. 

  1219.                         fixpos($$, $1);
    1220. 

  1220.                     }
    1221. 

  1221.                 | primary_value tCOLON2 tIDENTIFIER tOP_ASGN arg
    1222. 

  1222.                     {
    1223. 

  1223.                         value_expr($5);
    1224. 

  1224.                         if ($4 == tOROP) {
    1225. 

  1225.                             $4 = 0;
    1226. 

  1226.                         }
    1227. 

  1227.                         else if ($4 == tANDOP) {
    1228. 

  1228.                             $4 = 1;
    1229. 

  1229.                         }
    1230. 

  1230.                         $$ = NEW_OP_ASGN2($1, $3, $4, $5);
    1231. 

  1231.                         fixpos($$, $1);
    1232. 

  1232.                     }
    1233. 

  1233.                 | primary_value tCOLON2 tCONSTANT tOP_ASGN arg
    1234. 

  1234.                     {
    1235. 

  1235.                         yyerror("constant re-assignment");
    1236. 

  1236.                         $$ = 0;
    1237. 

  1237.                     }
    1238. 

  1238.                 | tCOLON3 tCONSTANT tOP_ASGN arg
    1239. 

  1239.                     {
    1240. 

  1240.                         yyerror("constant re-assignment");
    1241. 

  1241.                         $$ = 0;
    1242. 

  1242.                     }
    1243. 

  1243.                 | backref tOP_ASGN arg
    1244. 

  1244.                     {
    1245. 

  1245.                         rb_backref_error($1, vps);
    1246. 

  1246.                         $$ = 0;
    1247. 

  1247.                     }
    1248. 

  1248.                 | arg tDOT2 arg
    1249. 

  1249.                     {
    1250. 

  1250.                         value_expr($1);
    1251. 

  1251.                         value_expr($3);
    1252. 

  1252.                         $$ = NEW_DOT2($1, $3);
    1253. 

  1253.                     }
    1254. 

  1254.                 | arg tDOT3 arg
    1255. 

  1255.                     {
    1256. 

  1256.                         value_expr($1);
    1257. 

  1257.                         value_expr($3);
    1258. 

  1258.                         $$ = NEW_DOT3($1, $3);
    1259. 

  1259.                     }
    1260. 

  1260.                 | arg '+' arg
    1261. 

  1261.                     {
    1262. 

  1262.                         $$ = call_op($1, '+', 1, $3, vps);
    1263. 

  1263.                     }
    1264. 

  1264.                 | arg '-' arg
    1265. 

  1265.                     {
    1266. 

  1266.                         $$ = call_op($1, '-', 1, $3, vps);
    1267. 

  1267.                     }
    1268. 

  1268.                 | arg '*' arg
    1269. 

  1269.                     {
    1270. 

  1270.                         $$ = call_op($1, '*', 1, $3, vps);
    1271. 

  1271.                     }
    1272. 

  1272.                 | arg '/' arg
    1273. 

  1273.                     {
    1274. 

  1274.                         $$ = call_op($1, '/', 1, $3, vps);
    1275. 

  1275.                     }
    1276. 

  1276.                 | arg '%' arg
    1277. 

  1277.                     {
    1278. 

  1278.                         $$ = call_op($1, '%', 1, $3, vps);
    1279. 

  1279.                     }
    1280. 

  1280.                 | arg tPOW arg
    1281. 

  1281.                     {
    1282. 

  1282.                         $$ = call_op($1, tPOW, 1, $3, vps);
    1283. 

  1283.                     }
    1284. 

  1284.                 | tUMINUS_NUM tINTEGER tPOW arg
    1285. 

  1285.                     {
    1286. 

  1286.                         $$ = call_op(call_op($2, tPOW, 1, $4, vps), tUMINUS, 0, 0, vps);
    1287. 

  1287.                     }
    1288. 

  1288.                 | tUMINUS_NUM tFLOAT tPOW arg
    1289. 

  1289.                     {
    1290. 

  1290.                         $$ = call_op(call_op($2, tPOW, 1, $4, vps), tUMINUS, 0, 0, vps);
    1291. 

  1291.                     }
    1292. 

  1292.                 | tUPLUS arg
    1293. 

  1293.                     {
    1294. 

  1294.                         if ($2 && nd_type($2) == NODE_LIT) {
    1295. 

  1295.                             $$ = $2;
    1296. 

  1296.                         }
    1297. 

  1297.                         else {
    1298. 

  1298.                             $$ = call_op($2, tUPLUS, 0, 0, vps);
    1299. 

  1299.                         }
    1300. 

  1300.                     }
    1301. 

  1301.                 | tUMINUS arg
    1302. 

  1302.                     {
    1303. 

  1303.                         $$ = call_op($2, tUMINUS, 0, 0, vps);
    1304. 

  1304.                     }
    1305. 

  1305.                 | arg '|' arg
    1306. 

  1306.                     {
    1307. 

  1307.                         $$ = call_op($1, '|', 1, $3, vps);
    1308. 

  1308.                     }
    1309. 

  1309.                 | arg '^' arg
    1310. 

  1310.                     {
    1311. 

  1311.                         $$ = call_op($1, '^', 1, $3, vps);
    1312. 

  1312.                     }
    1313. 

  1313.                 | arg '&' arg
    1314. 

  1314.                     {
    1315. 

  1315.                         $$ = call_op($1, '&', 1, $3, vps);
    1316. 

  1316.                     }
    1317. 

  1317.                 | arg tCMP arg
    1318. 

  1318.                     {
    1319. 

  1319.                         $$ = call_op($1, tCMP, 1, $3, vps);
    1320. 

  1320.                     }
    1321. 

  1321.                 | arg '>' arg
    1322. 

  1322.                     {
    1323. 

  1323.                         $$ = call_op($1, '>', 1, $3, vps);
    1324. 

  1324.                     }
    1325. 

  1325.                 | arg tGEQ arg
    1326. 

  1326.                     {
    1327. 

  1327.                         $$ = call_op($1, tGEQ, 1, $3, vps);
    1328. 

  1328.                     }
    1329. 

  1329.                 | arg '<' arg
    1330. 

  1330.                     {
    1331. 

  1331.                         $$ = call_op($1, '<', 1, $3, vps);
    1332. 

  1332.                     }
    1333. 

  1333.                 | arg tLEQ arg
    1334. 

  1334.                     {
    1335. 

  1335.                         $$ = call_op($1, tLEQ, 1, $3, vps);
    1336. 

  1336.                     }
    1337. 

  1337.                 | arg tEQ arg
    1338. 

  1338.                     {
    1339. 

  1339.                         $$ = call_op($1, tEQ, 1, $3, vps);
    1340. 

  1340.                     }
    1341. 

  1341.                 | arg tEQQ arg
    1342. 

  1342.                     {
    1343. 

  1343.                         $$ = call_op($1, tEQQ, 1, $3, vps);
    1344. 

  1344.                     }
    1345. 

  1345.                 | arg tNEQ arg
    1346. 

  1346.                     {
    1347. 

  1347.                         $$ = NEW_NOT(call_op($1, tEQ, 1, $3, vps));
    1348. 

  1348.                     }
    1349. 

  1349.                 | arg tMATCH arg
    1350. 

  1350.                     {
    1351. 

  1351.                         $$ = match_gen($1, $3, vps);
    1352. 

  1352.                     }
    1353. 

  1353.                 | arg tNMATCH arg
    1354. 

  1354.                     {
    1355. 

  1355.                         $$ = NEW_NOT(match_gen($1, $3, vps));
    1356. 

  1356.                     }
    1357. 

  1357.                 | '!' arg
    1358. 

  1358.                     {
    1359. 

  1359.                         $$ = NEW_NOT(cond($2, vps));
    1360. 

  1360.                     }
    1361. 

  1361.                 | '~' arg
    1362. 

  1362.                     {
    1363. 

  1363.                         $$ = call_op($2, '~', 0, 0, vps);
    1364. 

  1364.                     }
    1365. 

  1365.                 | arg tLSHFT arg
    1366. 

  1366.                     {
    1367. 

  1367.                         $$ = call_op($1, tLSHFT, 1, $3, vps);
    1368. 

  1368.                     }
    1369. 

  1369.                 | arg tRSHFT arg
    1370. 

  1370.                     {
    1371. 

  1371.                         $$ = call_op($1, tRSHFT, 1, $3, vps);
    1372. 

  1372.                     }
    1373. 

  1373.                 | arg tANDOP arg
    1374. 

  1374.                     {
    1375. 

  1375.                         $$ = logop(NODE_AND, $1, $3, vps);
    1376. 

  1376.                     }
    1377. 

  1377.                 | arg tOROP arg
    1378. 

  1378.                     {
    1379. 

  1379.                         $$ = logop(NODE_OR, $1, $3, vps);
    1380. 

  1380.                     }
    1381. 

  1381.                 | kDEFINED opt_nl {in_defined = 1;} arg
    1382. 

  1382.                     {
    1383. 

  1383.                         in_defined = 0;
    1384. 

  1384.                         $$ = NEW_DEFINED($4);
    1385. 

  1385.                     }
    1386. 

  1386.                 | arg '?' {ternary_colon++;} arg ':' arg
    1387. 

  1387.                     {
    1388. 

  1388.                         $$ = NEW_IF(cond($1, vps), $4, $6);
    1389. 

  1389.                         fixpos($$, $1);
    1390. 

  1390.                         ternary_colon--;
    1391. 

  1391.                     }
    1392. 

  1392.                 | primary
    1393. 

  1393.                     {
    1394. 

  1394.                         $$ = $1;
    1395. 

  1395.                     }
    1396. 

  1396.                 ;
    1397. 

  1397. 

  1398. arg_value       : arg
    1399. 

  1399.                     {
    1400. 

  1400.                         value_expr($1);
    1401. 

  1401.                         $$ = $1;
    1402. 

  1402.                     }
    1403. 

  1403.                 ;
    1404. 

  1404. 

  1405. aref_args       : none
    1406. 

  1406.                 | command opt_nl
    1407. 

  1407.                     {
    1408. 

  1408.                         rb_warn("parenthesize argument(s) for future version");
    1409. 

  1409.                         $$ = NEW_LIST($1);
    1410. 

  1410.                     }
    1411. 

  1411.                 | args trailer
    1412. 

  1412.                     {
    1413. 

  1413.                         $$ = $1;
    1414. 

  1414.                     }
    1415. 

  1415.                 | args ',' tSTAR arg opt_nl
    1416. 

  1416.                     {
    1417. 

  1417.                         value_expr($4);
    1418. 

  1418.                         $$ = arg_concat(vps, $1, $4);
    1419. 

  1419.                     }
    1420. 

  1420.                 | assocs trailer
    1421. 

  1421.                     {
    1422. 

  1422.                         $$ = NEW_LIST(NEW_HASH($1));
    1423. 

  1423.                     }
    1424. 

  1424.                 | tSTAR arg opt_nl
    1425. 

  1425.                     {
    1426. 

  1426.                         value_expr($2);
    1427. 

  1427.                         $$ = NEW_NEWLINE(NEW_SPLAT($2));
    1428. 

  1428.                     }
    1429. 

  1429.                 ;
    1430. 

  1430. 

  1431. paren_args      : '(' none ')'
    1432. 

  1432.                     {
    1433. 

  1433.                         $$ = $2;
    1434. 

  1434.                     }
    1435. 

  1435.                 | '(' call_args opt_nl ')'
    1436. 

  1436.                     {
    1437. 

  1437.                         $$ = $2;
    1438. 

  1438.                     }
    1439. 

  1439.                 | '(' block_call opt_nl ')'
    1440. 

  1440.                     {
    1441. 

  1441.                         rb_warn("parenthesize argument for future version");
    1442. 

  1442.                         $$ = NEW_LIST($2);
    1443. 

  1443.                     }
    1444. 

  1444.                 | '(' args ',' block_call opt_nl ')'
    1445. 

  1445.                     {
    1446. 

  1446.                         rb_warn("parenthesize argument for future version");
    1447. 

  1447.                         $$ = list_append(vps, $2, $4);
    1448. 

  1448.                     }
    1449. 

  1449.                 ;
    1450. 

  1450. 

  1451. opt_paren_args  : none
    1452. 

  1452.                 | paren_args
    1453. 

  1453.                 ;
    1454. 

  1454. 

  1455. call_args       : command
    1456. 

  1456.                     {
    1457. 

  1457.                         rb_warn("parenthesize argument(s) for future version");
    1458. 

  1458.                         $$ = NEW_LIST($1);
    1459. 

  1459.                     }
    1460. 

  1460.                 | args opt_block_arg
    1461. 

  1461.                     {
    1462. 

  1462.                         $$ = arg_blk_pass($1, $2);
    1463. 

  1463.                     }
    1464. 

  1464.                 | args ',' tSTAR arg_value opt_block_arg
    1465. 

  1465.                     {
    1466. 

  1466.                         $$ = arg_concat(vps, $1, $4);
    1467. 

  1467.                         $$ = arg_blk_pass($$, $5);
    1468. 

  1468.                     }
    1469. 

  1469.                 | assocs opt_block_arg
    1470. 

  1470.                     {
    1471. 

  1471.                         $$ = NEW_LIST(NEW_HASH($1));
    1472. 

  1472.                         $$ = arg_blk_pass($$, $2);
    1473. 

  1473.                     }
    1474. 

  1474.                 | assocs ',' tSTAR arg_value opt_block_arg
    1475. 

  1475.                     {
    1476. 

  1476.                         $$ = arg_concat(vps, NEW_LIST(NEW_HASH($1)), $4);
    1477. 

  1477.                         $$ = arg_blk_pass($$, $5);
    1478. 

  1478.                     }
    1479. 

  1479.                 | args ',' assocs opt_block_arg
    1480. 

  1480.                     {
    1481. 

  1481.                         $$ = list_append(vps, $1, NEW_HASH($3));
    1482. 

  1482.                         $$ = arg_blk_pass($$, $4);
    1483. 

  1483.                     }
    1484. 

  1484.                 | args ',' assocs ',' tSTAR arg opt_block_arg
    1485. 

  1485.                     {
    1486. 

  1486.                         value_expr($6);
    1487. 

  1487.                         $$ = arg_concat(vps, list_append(vps, $1, NEW_HASH($3)), $6);
    1488. 

  1488.                         $$ = arg_blk_pass($$, $7);
    1489. 

  1489.                     }
    1490. 

  1490.                 | tSTAR arg_value opt_block_arg
    1491. 

  1491.                     {
    1492. 

  1492.                         $$ = arg_blk_pass(NEW_SPLAT($2), $3);
    1493. 

  1493.                     }
    1494. 

  1494.                 | block_arg
    1495. 

  1495.                 ;
    1496. 

  1496. 

  1497. call_args2      : arg_value ',' args opt_block_arg
    1498. 

  1498.                     {
    1499. 

  1499.                         $$ = arg_blk_pass(list_concat(NEW_LIST($1),$3), $4);
    1500. 

  1500.                     }
    1501. 

  1501.                 | arg_value ',' block_arg
    1502. 

  1502.                     {
    1503. 

  1503.                         $$ = arg_blk_pass($1, $3);
    1504. 

  1504.                     }
    1505. 

  1505.                 | arg_value ',' tSTAR arg_value opt_block_arg
    1506. 

  1506.                     {
    1507. 

  1507.                         $$ = arg_concat(vps, NEW_LIST($1), $4);
    1508. 

  1508.                         $$ = arg_blk_pass($$, $5);
    1509. 

  1509.                     }
    1510. 

  1510.                 | arg_value ',' args ',' tSTAR arg_value opt_block_arg
    1511. 

  1511.                     {
    1512. 

  1512.                         $$ = arg_concat(vps, list_concat(NEW_LIST($1),$3), $6);
    1513. 

  1513.                         $$ = arg_blk_pass($$, $7);
    1514. 

  1514.                     }
    1515. 

  1515.                 | assocs opt_block_arg
    1516. 

  1516.                     {
    1517. 

  1517.                         $$ = NEW_LIST(NEW_HASH($1));
    1518. 

  1518.                         $$ = arg_blk_pass($$, $2);
    1519. 

  1519.                     }
    1520. 

  1520.                 | assocs ',' tSTAR arg_value opt_block_arg
    1521. 

  1521.                     {
    1522. 

  1522.                         $$ = arg_concat(vps, NEW_LIST(NEW_HASH($1)), $4);
    1523. 

  1523.                         $$ = arg_blk_pass($$, $5);
    1524. 

  1524.                     }
    1525. 

  1525.                 | arg_value ',' assocs opt_block_arg
    1526. 

  1526.                     {
    1527. 

  1527.                         $$ = list_append(vps, NEW_LIST($1), NEW_HASH($3));
    1528. 

  1528.                         $$ = arg_blk_pass($$, $4);
    1529. 

  1529.                     }
    1530. 

  1530.                 | arg_value ',' args ',' assocs opt_block_arg
    1531. 

  1531.                     {
    1532. 

  1532.                         $$ = list_append(vps, list_concat(NEW_LIST($1),$3), NEW_HASH($5));
    1533. 

  1533.                         $$ = arg_blk_pass($$, $6);
    1534. 

  1534.                     }
    1535. 

  1535.                 | arg_value ',' assocs ',' tSTAR arg_value opt_block_arg
    1536. 

  1536.                     {
    1537. 

  1537.                         $$ = arg_concat(vps, list_append(vps, NEW_LIST($1), NEW_HASH($3)), $6);
    1538. 

  1538.                         $$ = arg_blk_pass($$, $7);
    1539. 

  1539.                     }
    1540. 

  1540.                 | arg_value ',' args ',' assocs ',' tSTAR arg_value opt_block_arg
    1541. 

  1541.                     {
    1542. 

  1542.                         $$ = arg_concat(vps, list_append(vps,
    1543. 

  1543.                                         list_concat(NEW_LIST($1), $3), NEW_HASH($5)), $8);
    1544. 

  1544.                         $$ = arg_blk_pass($$, $9);
    1545. 

  1545.                     }
    1546. 

  1546.                 | tSTAR arg_value opt_block_arg
    1547. 

  1547.                     {
    1548. 

  1548.                         $$ = arg_blk_pass(NEW_SPLAT($2), $3);
    1549. 

  1549.                     }
    1550. 

  1550.                 | block_arg
    1551. 

  1551.                 ;
    1552. 

  1552. 

  1553. command_args    :  {
    1554. 

  1554.                         $<val>$ = cmdarg_stack;
    1555. 

  1555.                         CMDARG_PUSH(1);
    1556. 

  1556.                     }
    1557. 

  1557.                   open_args
    1558. 

  1558.                     {
    1559. 

  1559.                         /* CMDARG_POP() */
    1560. 

  1560.                         cmdarg_stack = $<val>1;
    1561. 

  1561.                         $$ = $2;
    1562. 

  1562.                     }
    1563. 

  1563.                 ;
    1564. 

  1564. 

  1565. open_args       : call_args
    1566. 

  1566.                 | tLPAREN_ARG  {lex_state = EXPR_ENDARG;} ')'
    1567. 

  1567.                     {
    1568. 

  1568.                         rb_warn("don't put space before argument parentheses");
    1569. 

  1569.                         $$ = 0;
    1570. 

  1570.                     }
    1571. 

  1571.                 | tLPAREN_ARG call_args2 {lex_state = EXPR_ENDARG;} ')'
    1572. 

  1572.                     {
    1573. 

  1573.                         rb_warn("don't put space before argument parentheses");
    1574. 

  1574.                         $$ = $2;
    1575. 

  1575.                     }
    1576. 

  1576.                 ;
    1577. 

  1577. 

  1578. block_arg       : tAMPER arg_value
    1579. 

  1579.                     {
    1580. 

  1580.                         $$ = NEW_BLOCK_PASS($2);
    1581. 

  1581.                     }
    1582. 

  1582.                 ;
    1583. 

  1583. 

  1584. opt_block_arg   : ',' block_arg
    1585. 

  1585.                     {
    1586. 

  1586.                         $$ = $2;
    1587. 

  1587.                     }
    1588. 

  1588.                 | none
    1589. 

  1589.                 ;
    1590. 

  1590. 

  1591. args            : arg_value
    1592. 

  1592.                     {
    1593. 

  1593.                         $$ = NEW_LIST($1);
    1594. 

  1594.                     }
    1595. 

  1595.                 | args ',' arg_value
    1596. 

  1596.                     {
    1597. 

  1597.                         $$ = list_append(vps, $1, $3);
    1598. 

  1598.                     }
    1599. 

  1599.                 ;
    1600. 

  1600. 

  1601. mrhs            : args ',' arg_value
    1602. 

  1602.                     {
    1603. 

  1603.                         $$ = list_append(vps, $1, $3);
    1604. 

  1604.                     }
    1605. 

  1605.                 | args ',' tSTAR arg_value
    1606. 

  1606.                     {
    1607. 

  1607.                         $$ = arg_concat(vps, $1, $4);
    1608. 

  1608.                     }
    1609. 

  1609.                 | tSTAR arg_value
    1610. 

  1610.                     {
    1611. 

  1611.                         $$ = NEW_SPLAT($2);
    1612. 

  1612.                     }
    1613. 

  1613.                 ;
    1614. 

  1614. 

  1615. primary         : literal
    1616. 

  1616.                 | strings
    1617. 

  1617.                 | xstring
    1618. 

  1618.                 | regexp
    1619. 

  1619.                 | words
    1620. 

  1620.                 | qwords
    1621. 

  1621.                 | var_ref
    1622. 

  1622.                 | backref
    1623. 

  1623.                 | tFID
    1624. 

  1624.                     {
    1625. 

  1625.                         $$ = NEW_FCALL($1, 0);
    1626. 

  1626.                     }
    1627. 

  1627.                 | kBEGIN
    1628. 

  1628.                     {
    1629. 

  1629.                         $<num>1 = ruby_sourceline;
    1630. 

  1630.                         PUSH_LINE("begin");
    1631. 

  1631.                     }
    1632. 

  1632.                   bodystmt
    1633. 

  1633.                   kEND
    1634. 

  1634.                     {
    1635. 

  1635.                         POP_LINE();
    1636. 

  1636.                         if ($3 == NULL)
    1637. 

  1637.                             $$ = NEW_NIL();
    1638. 

  1638.                         else
    1639. 

  1639.                             $$ = NEW_BEGIN($3);
    1640. 

  1640.                         nd_set_line($$, $<num>1);
    1641. 

  1641.                     }
    1642. 

  1642.                 | tLPAREN_ARG expr {lex_state = EXPR_ENDARG;} opt_nl ')'
    1643. 

  1643.                     {
    1644. 

  1644.                         rb_warning("(...) interpreted as grouped expression");
    1645. 

  1645.                         $$ = $2;
    1646. 

  1646.                     }
    1647. 

  1647.                 | tLPAREN compstmt ')'
    1648. 

  1648.                     {
    1649. 

  1649.                         if (!$2) $$ = NEW_NIL();
    1650. 

  1650.                         else $$ = $2;
    1651. 

  1651.                     }
    1652. 

  1652.                 | primary_value tCOLON2 tCONSTANT
    1653. 

  1653.                     {
    1654. 

  1654.                         $$ = NEW_COLON2($1, $3);
    1655. 

  1655.                     }
    1656. 

  1656.                 | tCOLON3 tCONSTANT
    1657. 

  1657.                     {
    1658. 

  1658.                         $$ = NEW_COLON3($2);
    1659. 

  1659.                     }
    1660. 

  1660.                 | primary_value '[' aref_args ']'
    1661. 

  1661.                     {
    1662. 

  1662.                         if ($1 && nd_type($1) == NODE_SELF) {
    1663. 

  1663.                             $$ = NEW_FCALL(convert_op(tAREF), $3);
    1664. 

  1664.                         } else {
    1665. 

  1665.                             $$ = NEW_CALL($1, convert_op(tAREF), $3);
    1666. 

  1666.                         }
    1667. 

  1667.                         fixpos($$, $1);
    1668. 

  1668.                     }
    1669. 

  1669.                 | tLBRACK aref_args ']'
    1670. 

  1670.                     {
    1671. 

  1671.                         if ($2 == 0) {
    1672. 

  1672.                             $$ = NEW_ZARRAY(); /* zero length array*/
    1673. 

  1673.                         }
    1674. 

  1674.                         else {
    1675. 

  1675.                             $$ = $2;
    1676. 

  1676.                         }
    1677. 

  1677.                     }
    1678. 

  1678.                 | tLBRACE assoc_list '}'
    1679. 

  1679.                     {
    1680. 

  1680.                         $$ = NEW_HASH($2);
    1681. 

  1681.                     }
    1682. 

  1682.                 | kRETURN
    1683. 

  1683.                     {
    1684. 

  1684.                         $$ = NEW_RETURN(0);
    1685. 

  1685.                     }
    1686. 

  1686.                 | kYIELD '(' call_args ')'
    1687. 

  1687.                     {
    1688. 

  1688.                         $$ = new_yield(vps, $3);
    1689. 

  1689.                     }
    1690. 

  1690.                 | kYIELD '(' ')'
    1691. 

  1691.                     {
    1692. 

  1692.                         $$ = NEW_YIELD(0, Qfalse);
    1693. 

  1693.                     }
    1694. 

  1694.                 | kYIELD
    1695. 

  1695.                     {
    1696. 

  1696.                         $$ = NEW_YIELD(0, Qfalse);
    1697. 

  1697.                     }
    1698. 

  1698.                 | kDEFINED opt_nl '(' {in_defined = 1;} expr ')'
    1699. 

  1699.                     {
    1700. 

  1700.                         in_defined = 0;
    1701. 

  1701.                         $$ = NEW_DEFINED($5);
    1702. 

  1702.                     }
    1703. 

  1703.                 | operation brace_block
    1704. 

  1704.                     {
    1705. 

  1705.                         $2->nd_iter = NEW_FCALL($1, 0);
    1706. 

  1706.                         $$ = $2;
    1707. 

  1707.                         fixpos($2->nd_iter, $2);
    1708. 

  1708.                     }
    1709. 

  1709.                 | method_call
    1710. 

  1710.                 | method_call brace_block
    1711. 

  1711.                     {
    1712. 

  1712.                         if ($1 && nd_type($1) == NODE_BLOCK_PASS) {
    1713. 

  1713.                             rb_compile_error(vps, "both block arg and actual block given");
    1714. 

  1714.                         }
    1715. 

  1715.                         $2->nd_iter = $1;
    1716. 

  1716.                         $$ = $2;
    1717. 

  1717.                         fixpos($$, $1);
    1718. 

  1718.                     }
    1719. 

  1719.                 | kIF {
    1720. 

  1720.                     PUSH_LINE("if");
    1721. 

  1721.                   } expr_value then
    1722. 

  1722.                   compstmt
    1723. 

  1723.                   if_tail
    1724. 

  1724.                   kEND
    1725. 

  1725.                     {
    1726. 

  1726.                         POP_LINE();
    1727. 

  1727.                         $$ = NEW_IF(cond($3, vps), $5, $6);
    1728. 

  1728.                         fixpos($$, $3);
    1729. 

  1729.                         if (cond_negative(&$$->nd_cond)) {
    1730. 

  1730.                             NODE *tmp = $$->nd_body;
    1731. 

  1731.                             $$->nd_body = $$->nd_else;
    1732. 

  1732.                             $$->nd_else = tmp;
    1733. 

  1733.                         }
    1734. 

  1734.                     }
    1735. 

  1735.                 | kUNLESS {
    1736. 

  1736.                     PUSH_LINE("unless");
    1737. 

  1737.                   } expr_value then
    1738. 

  1738.                   compstmt
    1739. 

  1739.                   opt_else
    1740. 

  1740.                   kEND
    1741. 

  1741.                     {
    1742. 

  1742.                         POP_LINE();
    1743. 

  1743.                         $$ = NEW_UNLESS(cond($3, vps), $5, $6);
    1744. 

  1744.                         fixpos($$, $3);
    1745. 

  1745.                         if (cond_negative(&$$->nd_cond)) {
    1746. 

  1746.                             NODE *tmp = $$->nd_body;
    1747. 

  1747.                             $$->nd_body = $$->nd_else;
    1748. 

  1748.                             $$->nd_else = tmp;
    1749. 

  1749.                         }
    1750. 

  1750.                     }
    1751. 

  1751.                 | kWHILE {
    1752. 

  1752.                     PUSH_LINE("while");
    1753. 

  1753.                     COND_PUSH(1);
    1754. 

  1754.                   } expr_value do {COND_POP();}
    1755. 

  1755.                   compstmt
    1756. 

  1756.                   kEND
    1757. 

  1757.                     {
    1758. 

  1758.                         POP_LINE();
    1759. 

  1759.                         $$ = NEW_WHILE(cond($3, vps), $6, 1);
    1760. 

  1760.                         fixpos($$, $3);
    1761. 

  1761.                         if (cond_negative(&$$->nd_cond)) {
    1762. 

  1762.                             nd_set_type($$, NODE_UNTIL);
    1763. 

  1763.                         }
    1764. 

  1764.                     }
    1765. 

  1765.                 | kUNTIL {
    1766. 

  1766.                     PUSH_LINE("until");
    1767. 

  1767.                     COND_PUSH(1);
    1768. 

  1768.                   } expr_value do {COND_POP();}
    1769. 

  1769.                   compstmt
    1770. 

  1770.                   kEND
    1771. 

  1771.                     {
    1772. 

  1772.                         POP_LINE();
    1773. 

  1773.                         $$ = NEW_UNTIL(cond($3, vps), $6, 1);
    1774. 

  1774.                         fixpos($$, $3);
    1775. 

  1775.                         if (cond_negative(&$$->nd_cond)) {
    1776. 

  1776.                             nd_set_type($$, NODE_WHILE);
    1777. 

  1777.                         }
    1778. 

  1778.                     }
    1779. 

  1779.                 | kCASE {
    1780. 

  1780.                     PUSH_LINE("case");
    1781. 

  1781.                   } expr_value opt_terms
    1782. 

  1782.                   case_body
    1783. 

  1783.                   kEND
    1784. 

  1784.                     {
    1785. 

  1785.                         POP_LINE();
    1786. 

  1786.                         $$ = NEW_CASE($3, $5);
    1787. 

  1787.                         fixpos($$, $3);
    1788. 

  1788.                     }
    1789. 

  1789.                 | kCASE opt_terms { 
    1790. 

  1790.                     push_start_line((rb_parser_state*)parser_state, ruby_sourceline - 1, "case");
    1791. 

  1791.                   } case_body kEND
    1792. 

  1792.                     {
    1793. 

  1793.                         POP_LINE();
    1794. 

  1794.                         $$ = $4;
    1795. 

  1795.                     }
    1796. 

  1796.                 | kCASE opt_terms {
    1797. 

  1797.                     push_start_line((rb_parser_state*)parser_state, ruby_sourceline - 1, "case");
    1798. 

  1798.                   } kELSE compstmt kEND
    1799. 

  1799.                     {
    1800. 

  1800.                         POP_LINE();
    1801. 

  1801.                         $$ = $5;
    1802. 

  1802.                     }
    1803. 

  1803.                 | kFOR {
    1804. 

  1804.                     PUSH_LINE("for");
    1805. 

  1805.                   } for_var kIN {COND_PUSH(1);} expr_value do {COND_POP();}
    1806. 

  1806.                   compstmt
    1807. 

  1807.                   kEND
    1808. 

  1808.                     {
    1809. 

  1809.                         POP_LINE();
    1810. 

  1810.                         $$ = NEW_FOR($3, $6, $9);
    1811. 

  1811.                         fixpos($$, $3);
    1812. 

  1812.                     }
    1813. 

  1813.                 | kCLASS cpath superclass
    1814. 

  1814.                     {
    1815. 

  1815.                         PUSH_LINE("class");
    1816. 

  1816.                         if (in_def || in_single)
    1817. 

  1817.                             yyerror("class definition in method body");
    1818. 

  1818.                         class_nest++;
    1819. 

  1819.                         local_push(0);
    1820. 

  1820.                         $<num>$ = ruby_sourceline;
    1821. 

  1821.                     }
    1822. 

  1822.                   bodystmt
    1823. 

  1823.                   kEND
    1824. 

  1824.                     {
    1825. 

  1825.                         POP_LINE();
    1826. 

  1826.                         $$ = NEW_CLASS($2, $5, $3);
    1827. 

  1827.                         nd_set_line($$, $<num>4);
    1828. 

  1828.                         local_pop();
    1829. 

  1829.                         class_nest--;
    1830. 

  1830.                     }
    1831. 

  1831.                 | kCLASS tLSHFT expr
    1832. 

  1832.                     {
    1833. 

  1833.                         PUSH_LINE("class");
    1834. 

  1834.                         $<num>$ = in_def;
    1835. 

  1835.                         in_def = 0;
    1836. 

  1836.                     }
    1837. 

  1837.                   term
    1838. 

  1838.                     {
    1839. 

  1839.                         $<num>$ = in_single;
    1840. 

  1840.                         in_single = 0;
    1841. 

  1841.                         class_nest++;
    1842. 

  1842.                         local_push(0);
    1843. 

  1843.                     }
    1844. 

  1844.                   bodystmt
    1845. 

  1845.                   kEND
    1846. 

  1846.                     {
    1847. 

  1847.                         POP_LINE();
    1848. 

  1848.                         $$ = NEW_SCLASS($3, $7);
    1849. 

  1849.                         fixpos($$, $3);
    1850. 

  1850.                         local_pop();
    1851. 

  1851.                         class_nest--;
    1852. 

  1852.                         in_def = $<num>4;
    1853. 

  1853.                         in_single = $<num>6;
    1854. 

  1854.                     }
    1855. 

  1855.                 | kMODULE cpath
    1856. 

  1856.                     {
    1857. 

  1857.                         PUSH_LINE("module");
    1858. 

  1858.                         if (in_def || in_single)
    1859. 

  1859.                             yyerror("module definition in method body");
    1860. 

  1860.                         class_nest++;
    1861. 

  1861.                         local_push(0);
    1862. 

  1862.                         $<num>$ = ruby_sourceline;
    1863. 

  1863.                     }
    1864. 

  1864.                   bodystmt
    1865. 

  1865.                   kEND
    1866. 

  1866.                     {
    1867. 

  1867.                         POP_LINE();
    1868. 

  1868.                         $$ = NEW_MODULE($2, $4);
    1869. 

  1869.                         nd_set_line($$, $<num>3);
    1870. 

  1870.                         local_pop();
    1871. 

  1871.                         class_nest--;
    1872. 

  1872.                     }
    1873. 

  1873.                 | kDEF fname
    1874. 

  1874.                     {
    1875. 

  1875.                         PUSH_LINE("def");
    1876. 

  1876.                         $<id>$ = cur_mid;
    1877. 

  1877.                         cur_mid = $2;
    1878. 

  1878.                         in_def++;
    1879. 

  1879.                         local_push(0);
    1880. 

  1880.                     }
    1881. 

  1881.                   f_arglist
    1882. 

  1882.                   bodystmt
    1883. 

  1883.                   kEND
    1884. 

  1884.                     {
    1885. 

  1885.                         POP_LINE();
    1886. 

  1886.                         if (!$5) $5 = NEW_NIL();
    1887. 

  1887.                         $$ = NEW_DEFN($2, $4, $5, NOEX_PRIVATE);
    1888. 

  1888.                         fixpos($$, $4);
    1889. 

  1889.                         local_pop();
    1890. 

  1890.                         in_def--;
    1891. 

  1891.                         cur_mid = $<id>3;
    1892. 

  1892.                     }
    1893. 

  1893.                 | kDEF singleton dot_or_colon {lex_state = EXPR_FNAME;} fname
    1894. 

  1894.                     {
    1895. 

  1895.                         PUSH_LINE("def");
    1896. 

  1896.                         in_single++;
    1897. 

  1897.                         local_push(0);
    1898. 

  1898.                         lex_state = EXPR_END; /* force for args */
    1899. 

  1899.                     }
    1900. 

  1900.                   f_arglist
    1901. 

  1901.                   bodystmt
    1902. 

  1902.                   kEND
    1903. 

  1903.                     {
    1904. 

  1904.                         POP_LINE();
    1905. 

  1905.                         $$ = NEW_DEFS($2, $5, $7, $8);
    1906. 

  1906.                         fixpos($$, $2);
    1907. 

  1907.                         local_pop();
    1908. 

  1908.                         in_single--;
    1909. 

  1909.                     }
    1910. 

  1910.                 | kBREAK
    1911. 

  1911.                     {
    1912. 

  1912.                         $$ = NEW_BREAK(0);
    1913. 

  1913.                     }
    1914. 

  1914.                 | kNEXT
    1915. 

  1915.                     {
    1916. 

  1916.                         $$ = NEW_NEXT(0);
    1917. 

  1917.                     }
    1918. 

  1918.                 | kREDO
    1919. 

  1919.                     {
    1920. 

  1920.                         $$ = NEW_REDO();
    1921. 

  1921.                     }
    1922. 

  1922.                 | kRETRY
    1923. 

  1923.                     {
    1924. 

  1924.                         $$ = NEW_RETRY();
    1925. 

  1925.                     }
    1926. 

  1926.                 ;
    1927. 

  1927. 

  1928. primary_value   : primary
    1929. 

  1929.                     {
    1930. 

  1930.                         value_expr($1);
    1931. 

  1931.                         $$ = $1;
    1932. 

  1932.                     }
    1933. 

  1933.                 ;
    1934. 

  1934. 

  1935. then            : term
    1936. 

  1936.                 | ':'
    1937. 

  1937.                 | kTHEN
    1938. 

  1938.                 | term kTHEN
    1939. 

  1939.                 ;
    1940. 

  1940. 

  1941. do              : term
    1942. 

  1942.                 | ':'
    1943. 

  1943.                 | kDO_COND
    1944. 

  1944.                 ;
    1945. 

  1945. 

  1946. if_tail         : opt_else
    1947. 

  1947.                 | kELSIF expr_value then
    1948. 

  1948.                   compstmt
    1949. 

  1949.                   if_tail
    1950. 

  1950.                     {
    1951. 

  1951.                         $$ = NEW_IF(cond($2, vps), $4, $5);
    1952. 

  1952.                         fixpos($$, $2);
    1953. 

  1953.                     }
    1954. 

  1954.                 ;
    1955. 

  1955. 

  1956. opt_else        : none
    1957. 

  1957.                 | kELSE compstmt
    1958. 

  1958.                     {
    1959. 

  1959.                         $$ = $2;
    1960. 

  1960.                     }
    1961. 

  1961.                 ;
    1962. 

  1962. 

  1963. for_var         : lhs
    1964. 

  1964.                 | mlhs
    1965. 

  1965.                 ;
    1966. 

  1966. 

  1967. block_par       : mlhs_item
    1968. 

  1968.                     {
    1969. 

  1969.                         $$ = NEW_LIST($1);
    1970. 

  1970.                     }
    1971. 

  1971.                 | block_par ',' mlhs_item
    1972. 

  1972.                     {
    1973. 

  1973.                         $$ = list_append(vps, $1, $3);
    1974. 

  1974.                     }
    1975. 

  1975.                 ;
    1976. 

  1976. 

  1977. block_var       : block_par
    1978. 

  1978.                     {
    1979. 

  1979.                         if ($1->nd_alen == 1) {
    1980. 

  1980.                             $$ = $1->nd_head;
    1981. 

  1981.                         }
    1982. 

  1982.                         else {
    1983. 

  1983.                             $$ = NEW_MASGN($1, 0);
    1984. 

  1984.                         }
    1985. 

  1985.                     }
    1986. 

  1986.                 | block_par ','
    1987. 

  1987.                     {
    1988. 

  1988.                         $$ = NEW_MASGN($1, 0);
    1989. 

  1989.                     }
    1990. 

  1990.                 | block_par ',' tAMPER lhs
    1991. 

  1991.                     {
    1992. 

  1992.                         $$ = NEW_BLOCK_VAR($4, NEW_MASGN($1, 0));
    1993. 

  1993.                     }
    1994. 

  1994.                 | block_par ',' tSTAR lhs ',' tAMPER lhs
    1995. 

  1995.                     {
    1996. 

  1996.                         $$ = NEW_BLOCK_VAR($7, NEW_MASGN($1, $4));
    1997. 

  1997.                     }
    1998. 

  1998.                 | block_par ',' tSTAR ',' tAMPER lhs
    1999. 

  1999.                     {
    2000. 

  2000.                         $$ = NEW_BLOCK_VAR($6, NEW_MASGN($1, -1));
    2001. 

  2001.                     }
    2002. 

  2002.                 | block_par ',' tSTAR lhs
    2003. 

  2003.                     {
    2004. 

  2004.                         $$ = NEW_MASGN($1, $4);
    2005. 

  2005.                     }
    2006. 

  2006.                 | block_par ',' tSTAR
    2007. 

  2007.                     {
    2008. 

  2008.                         $$ = NEW_MASGN($1, -1);
    2009. 

  2009.                     }
    2010. 

  2010.                 | tSTAR lhs ',' tAMPER lhs
    2011. 

  2011.                     {
    2012. 

  2012.                         $$ = NEW_BLOCK_VAR($5, NEW_MASGN(0, $2));
    2013. 

  2013.                     }
    2014. 

  2014.                 | tSTAR ',' tAMPER lhs
    2015. 

  2015.                     {
    2016. 

  2016.                         $$ = NEW_BLOCK_VAR($4, NEW_MASGN(0, -1));
    2017. 

  2017.                     }
    2018. 

  2018.                 | tSTAR lhs
    2019. 

  2019.                     {
    2020. 

  2020.                         $$ = NEW_MASGN(0, $2);
    2021. 

  2021.                     }
    2022. 

  2022.                 | tSTAR
    2023. 

  2023.                     {
    2024. 

  2024.                         $$ = NEW_MASGN(0, -1);
    2025. 

  2025.                     }
    2026. 

  2026.                 | tAMPER lhs
    2027. 

  2027.                     {
    2028. 

  2028.                         $$ = NEW_BLOCK_VAR($2, (NODE*)1);
    2029. 

  2029.                     }
    2030. 

  2030.                 ;
    2031. 

  2031. 

  2032. opt_block_var   : none
    2033. 

  2033.                 | '|' /* none */ '|'
    2034. 

  2034.                     {
    2035. 

  2035.                         $$ = (NODE*)1;
    2036. 

  2036.                     }
    2037. 

  2037.                 | tOROP
    2038. 

  2038.                     {
    2039. 

  2039.                         $$ = (NODE*)1;
    2040. 

  2040.                     }
    2041. 

  2041.                 | '|' block_var '|'
    2042. 

  2042.                     {
    2043. 

  2043.                         $$ = $2;
    2044. 

  2044.                     }
    2045. 

  2045.                 ;
    2046. 

  2046. 

  2047. do_block        : kDO_BLOCK
    2048. 

  2048.                     {
    2049. 

  2049.                         PUSH_LINE("do");
    2050. 

  2050.                         $<num>1 = ruby_sourceline;
    2051. 

  2051.                         reset_block(vps);
    2052. 

  2052.                     }
    2053. 

  2053.                   opt_block_var
    2054. 

  2054.                     {
    2055. 

  2055.                       $<vars>$ = variables->block_vars;
    2056. 

  2056.                     }
    2057. 

  2057.                   compstmt
    2058. 

  2058.                   kEND
    2059. 

  2059.                     {
    2060. 

  2060.                         POP_LINE();
    2061. 

  2061.                         $$ = NEW_ITER($3, 0, extract_block_vars(vps, $5, $<vars>4));
    2062. 

  2062.                         nd_set_line($$, $<num>1);
    2063. 

  2063.                     }
    2064. 

  2064.                 ;
    2065. 

  2065. 

  2066. block_call      : command do_block
    2067. 

  2067.                     {
    2068. 

  2068.                         if ($1 && nd_type($1) == NODE_BLOCK_PASS) {
    2069. 

  2069.                             rb_compile_error(vps, "both block arg and actual block given");
    2070. 

  2070.                         }
    2071. 

  2071.                         $2->nd_iter = $1;
    2072. 

  2072.                         $$ = $2;
    2073. 

  2073.                         fixpos($$, $1);
    2074. 

  2074.                     }
    2075. 

  2075.                 | block_call '.' operation2 opt_paren_args
    2076. 

  2076.                     {
    2077. 

  2077.                         $$ = new_call(vps, $1, $3, $4);
    2078. 

  2078.                     }
    2079. 

  2079.                 | block_call tCOLON2 operation2 opt_paren_args
    2080. 

  2080.                     {
    2081. 

  2081.                         $$ = new_call(vps, $1, $3, $4);
    2082. 

  2082.                     }
    2083. 

  2083.                 ;
    2084. 

  2084. 

  2085. method_call     : operation paren_args
    2086. 

  2086.                     {
    2087. 

  2087.                         $$ = new_fcall(vps, $1, $2);
    2088. 

  2088.                         fixpos($$, $2);
    2089. 

  2089.                     }
    2090. 

  2090.                 | primary_value '.' operation2 opt_paren_args
    2091. 

  2091.                     {
    2092. 

  2092.                         $$ = new_call(vps, $1, $3, $4);
    2093. 

  2093.                         fixpos($$, $1);
    2094. 

  2094.                     }
    2095. 

  2095.                 | primary_value tCOLON2 operation2 paren_args
    2096. 

  2096.                     {
    2097. 

  2097.                         $$ = new_call(vps, $1, $3, $4);
    2098. 

  2098.                         fixpos($$, $1);
    2099. 

  2099.                     }
    2100. 

  2100.                 | primary_value tCOLON2 operation3
    2101. 

  2101.                     {
    2102. 

  2102.                         $$ = new_call(vps, $1, $3, 0);
    2103. 

  2103.                     }
    2104. 

  2104.                 | primary_value '\\' operation2
    2105. 

  2105.                     {
    2106. 

  2106.                         $$ = NEW_CALL($1, rb_parser_sym("get_reference"),
    2107. 

  2107.                         NEW_LIST(NEW_LIT(QUID2SYM($3))));
    2108. 

  2108.                     }
    2109. 

  2109.                 | tUBS operation2
    2110. 

  2110.                     {
    2111. 

  2111.                         $$ = NEW_FCALL(rb_parser_sym("get_reference"),
    2112. 

  2112.                         NEW_LIST(NEW_LIT(QUID2SYM($2))));
    2113. 

  2113.                     }
    2114. 

  2114.                 | kSUPER paren_args
    2115. 

  2115.                     {
    2116. 

  2116.                         $$ = new_super(vps, $2);
    2117. 

  2117.                     }
    2118. 

  2118.                 | kSUPER
    2119. 

  2119.                     {
    2120. 

  2120.                         $$ = NEW_ZSUPER();
    2121. 

  2121.                     }
    2122. 

  2122.                 ;
    2123. 

  2123. 

  2124. brace_block     : '{'
    2125. 

  2125.                     {
    2126. 

  2126.                         $<num>1 = ruby_sourceline;
    2127. 

  2127.                         reset_block(vps);
    2128. 

  2128.                     }
    2129. 

  2129.                   opt_block_var { $<vars>$ = variables->block_vars; }
    2130. 

  2130.                   compstmt '}'
    2131. 

  2131.                     {
    2132. 

  2132.                         $$ = NEW_ITER($3, 0, extract_block_vars(vps, $5, $<vars>4));
    2133. 

  2133.                         nd_set_line($$, $<num>1);
    2134. 

  2134.                     }
    2135. 

  2135.                 | kDO
    2136. 

  2136.                     {
    2137. 

  2137.                         PUSH_LINE("do");
    2138. 

  2138.                         $<num>1 = ruby_sourceline;
    2139. 

  2139.                         reset_block(vps);
    2140. 

  2140.                     }
    2141. 

  2141.                   opt_block_var { $<vars>$ = variables->block_vars; }
    2142. 

  2142.                   compstmt kEND
    2143. 

  2143.                     {
    2144. 

  2144.                         POP_LINE();
    2145. 

  2145.                         $$ = NEW_ITER($3, 0, extract_block_vars(vps, $5, $<vars>4));
    2146. 

  2146.                         nd_set_line($$, $<num>1);
    2147. 

  2147.                     }
    2148. 

  2148.                 ;
    2149. 

  2149. 

  2150. case_body       : kWHEN when_args then
    2151. 

  2151.                   compstmt
    2152. 

  2152.                   cases
    2153. 

  2153.                     {
    2154. 

  2154.                         $$ = NEW_WHEN($2, $4, $5);
    2155. 

  2155.                     }
    2156. 

  2156.                 ;
    2157. 

  2157. when_args       : args
    2158. 

  2158.                 | args ',' tSTAR arg_value
    2159. 

  2159.                     {
    2160. 

  2160.                         $$ = list_append(vps, $1, NEW_WHEN($4, 0, 0));
    2161. 

  2161.                     }
    2162. 

  2162.                 | tSTAR arg_value
    2163. 

  2163.                     {
    2164. 

  2164.                         $$ = NEW_LIST(NEW_WHEN($2, 0, 0));
    2165. 

  2165.                     }
    2166. 

  2166.                 ;
    2167. 

  2167. 

  2168. cases           : opt_else
    2169. 

  2169.                 | case_body
    2170. 

  2170.                 ;
    2171. 

  2171. 

  2172. opt_rescue      : kRESCUE exc_list exc_var then
    2173. 

  2173.                   compstmt
    2174. 

  2174.                   opt_rescue
    2175. 

  2175.                     {
    2176. 

  2176.                         if ($3) {
    2177. 

  2177.                             $3 = node_assign($3, NEW_GVAR(rb_parser_sym("$!")), vps);
    2178. 

  2178.                             $5 = block_append(vps, $3, $5);
    2179. 

  2179.                         }
    2180. 

  2180.                         $$ = NEW_RESBODY($2, $5, $6);
    2181. 

  2181.                         fixpos($$, $2?$2:$5);
    2182. 

  2182.                     }
    2183. 

  2183.                 | none
    2184. 

  2184.                 ;
    2185. 

  2185. 

  2186. exc_list        : arg_value
    2187. 

  2187.                     {
    2188. 

  2188.                         $$ = NEW_LIST($1);
    2189. 

  2189.                     }
    2190. 

  2190.                 | mrhs
    2191. 

  2191.                 | none
    2192. 

  2192.                 ;
    2193. 

  2193. 

  2194. exc_var         : tASSOC lhs
    2195. 

  2195.                     {
    2196. 

  2196.                         $$ = $2;
    2197. 

  2197.                     }
    2198. 

  2198.                 | none
    2199. 

  2199.                 ;
    2200. 

  2200. 

  2201. opt_ensure      : kENSURE compstmt
    2202. 

  2202.                     {
    2203. 

  2203.                         if ($2)
    2204. 

  2204.                             $$ = $2;
    2205. 

  2205.                         else
    2206. 

  2206.                             /* place holder */
    2207. 

  2207.                             $$ = NEW_NIL();
    2208. 

  2208.                     }
    2209. 

  2209.                 | none
    2210. 

  2210.                 ;
    2211. 

  2211. 

  2212. literal         : numeric
    2213. 

  2213.                 | symbol
    2214. 

  2214.                     {
    2215. 

  2215.                         $$ = NEW_LIT(QUID2SYM($1));
    2216. 

  2216.                     }
    2217. 

  2217.                 | dsym
    2218. 

  2218.                 ;
    2219. 

  2219. 

  2220. strings         : string
    2221. 

  2221.                     {
    2222. 

  2222.                         NODE *node = $1;
    2223. 

  2223.                         if (!node) {
    2224. 

  2224.                             node = NEW_STR(string_new(0, 0));
    2225. 

  2225.                         }
    2226. 

  2226.                         else {
    2227. 

  2227.                             node = evstr2dstr(vps, node);
    2228. 

  2228.                         }
    2229. 

  2229.                         $$ = node;
    2230. 

  2230.                     }
    2231. 

  2231.                 ;
    2232. 

  2232. 

  2233. string          : string1
    2234. 

  2234.                 | string string1
    2235. 

  2235.                     {
    2236. 

  2236.                         $$ = literal_concat(vps, $1, $2);
    2237. 

  2237.                     }
    2238. 

  2238.                 ;
    2239. 

  2239. 

  2240. string1         : tSTRING_BEG string_contents tSTRING_END
    2241. 

  2241.                     {
    2242. 

  2242.                         $$ = $2;
    2243. 

  2243.                     }
    2244. 

  2244.                 ;
    2245. 

  2245. 

  2246. xstring         : tXSTRING_BEG xstring_contents tSTRING_END
    2247. 

  2247.                     {
    2248. 

  2248.                         NODE *node = $2;
    2249. 

  2249.                         if (!node) {
    2250. 

  2250.                             node = NEW_XSTR(string_new(0, 0));
    2251. 

  2251.                         }
    2252. 

  2252.                         else {
    2253. 

  2253.                             switch (nd_type(node)) {
    2254. 

  2254.                               case NODE_STR:
    2255. 

  2255.                                 nd_set_type(node, NODE_XSTR);
    2256. 

  2256.                                 break;
    2257. 

  2257.                               case NODE_DSTR:
    2258. 

  2258.                                 nd_set_type(node, NODE_DXSTR);
    2259. 

  2259.                                 break;
    2260. 

  2260.                               default:
    2261. 

  2261.                                 node = NEW_NODE(NODE_DXSTR, string_new(0, 0), 1, NEW_LIST(node));
    2262. 

  2262.                                 break;
    2263. 

  2263.                             }
    2264. 

  2264.                         }
    2265. 

  2265.                         $$ = node;
    2266. 

  2266.                     }
    2267. 

  2267.                 ;
    2268. 

  2268. 

  2269. regexp          : tREGEXP_BEG xstring_contents tREGEXP_END
    2270. 

  2270.                     {
    2271. 

  2271.                         intptr_t options = $3;
    2272. 

  2272.                         NODE *node = $2;
    2273. 

  2273.                         if (!node) {
    2274. 

  2274.                             node = NEW_REGEX(string_new2(""), options & ~RE_OPTION_ONCE);
    2275. 

  2275.                         }
    2276. 

  2276.                         else switch (nd_type(node)) {
    2277. 

  2277.                           case NODE_STR:
    2278. 

  2278.                             {
    2279. 

  2279.                                 nd_set_type(node, NODE_REGEX);
    2280. 

  2280.                                 node->nd_cnt = options & ~RE_OPTION_ONCE;
    2281. 

  2281.                             }
    2282. 

  2282.                             break;
    2283. 

  2283.                           default:
    2284. 

  2284.                             node = NEW_NODE(NODE_DSTR, string_new(0, 0), 1, NEW_LIST(node));
    2285. 

  2285.                           case NODE_DSTR:
    2286. 

  2286.                             if (options & RE_OPTION_ONCE) {
    2287. 

  2287.                                 nd_set_type(node, NODE_DREGX_ONCE);
    2288. 

  2288.                             }
    2289. 

  2289.                             else {
    2290. 

  2290.                                 nd_set_type(node, NODE_DREGX);
    2291. 

  2291.                             }
    2292. 

  2292.                             node->nd_cflag = options & ~RE_OPTION_ONCE;
    2293. 

  2293.                             break;
    2294. 

  2294.                         }
    2295. 

  2295.                         $$ = node;
    2296. 

  2296.                     }
    2297. 

  2297.                 ;
    2298. 

  2298. 

  2299. words           : tWORDS_BEG ' ' tSTRING_END
    2300. 

  2300.                     {
    2301. 

  2301.                         $$ = NEW_ZARRAY();
    2302. 

  2302.                     }
    2303. 

  2303.                 | tWORDS_BEG word_list tSTRING_END
    2304. 

  2304.                     {
    2305. 

  2305.                         $$ = $2;
    2306. 

  2306.                     }
    2307. 

  2307.                 ;
    2308. 

  2308. 

  2309. word_list       : /* none */
    2310. 

  2310.                     {
    2311. 

  2311.                         $$ = 0;
    2312. 

  2312.                     }
    2313. 

  2313.                 | word_list word ' '
    2314. 

  2314.                     {
    2315. 

  2315.                         $$ = list_append(vps, $1, evstr2dstr(vps, $2));
    2316. 

  2316.                     }
    2317. 

  2317.                 ;
    2318. 

  2318. 

  2319. word            : string_content
    2320. 

  2320.                 | word string_content
    2321. 

  2321.                     {
    2322. 

  2322.                         $$ = literal_concat(vps, $1, $2);
    2323. 

  2323.                     }
    2324. 

  2324.                 ;
    2325. 

  2325. 

  2326. qwords          : tQWORDS_BEG ' ' tSTRING_END
    2327. 

  2327.                     {
    2328. 

  2328.                         $$ = NEW_ZARRAY();
    2329. 

  2329.                     }
    2330. 

  2330.                 | tQWORDS_BEG qword_list tSTRING_END
    2331. 

  2331.                     {
    2332. 

  2332.                         $$ = $2;
    2333. 

  2333.                     }
    2334. 

  2334.                 ;
    2335. 

  2335. 

  2336. qword_list      : /* none */
    2337. 

  2337.                     {
    2338. 

  2338.                         $$ = 0;
    2339. 

  2339.                     }
    2340. 

  2340.                 | qword_list tSTRING_CONTENT ' '
    2341. 

  2341.                     {
    2342. 

  2342.                         $$ = list_append(vps, $1, $2);
    2343. 

  2343.                     }
    2344. 

  2344.                 ;
    2345. 

  2345. 

  2346. string_contents : /* none */
    2347. 

  2347.                     {
    2348. 

  2348.                         $$ = 0;
    2349. 

  2349.                     }
    2350. 

  2350.                 | string_contents string_content
    2351. 

  2351.                     {
    2352. 

  2352.                         $$ = literal_concat(vps, $1, $2);
    2353. 

  2353.                     }
    2354. 

  2354.                 ;
    2355. 

  2355. 

  2356. xstring_contents: /* none */
    2357. 

  2357.                     {
    2358. 

  2358.                         $$ = 0;
    2359. 

  2359.                     }
    2360. 

  2360.                 | xstring_contents string_content
    2361. 

  2361.                     {
    2362. 

  2362.                         $$ = literal_concat(vps, $1, $2);
    2363. 

  2363.                     }
    2364. 

  2364.                 ;
    2365. 

  2365. 

  2366. string_content  : tSTRING_CONTENT
    2367. 

  2367.                 | tSTRING_DVAR
    2368. 

  2368.                     {
    2369. 

  2369.                         $<node>$ = lex_strterm;
    2370. 

  2370.                         lex_strterm = 0;
    2371. 

  2371.                         lex_state = EXPR_BEG;
    2372. 

  2372.                     }
    2373. 

  2373.                   string_dvar
    2374. 

  2374.                     {
    2375. 

  2375.                         lex_strterm = $<node>2;
    2376. 

  2376.                         $$ = NEW_EVSTR($3);
    2377. 

  2377.                     }
    2378. 

  2378.                 | tSTRING_DBEG
    2379. 

  2379.                     {
    2380. 

  2380.                         $<node>$ = lex_strterm;
    2381. 

  2381.                         lex_strterm = 0;
    2382. 

  2382.                         lex_state = EXPR_BEG;
    2383. 

  2383.                         COND_PUSH(0);
    2384. 

  2384.                         CMDARG_PUSH(0);
    2385. 

  2385.                     }
    2386. 

  2386.                   compstmt '}'
    2387. 

  2387.                     {
    2388. 

  2388.                         lex_strterm = $<node>2;
    2389. 

  2389.                         COND_LEXPOP();
    2390. 

  2390.                         CMDARG_LEXPOP();
    2391. 

  2391.                         if (($$ = $3) && nd_type($$) == NODE_NEWLINE) {
    2392. 

  2392.                             $$ = $$->nd_next;
    2393. 

  2393.                         }
    2394. 

  2394.                         $$ = new_evstr(vps, $$);
    2395. 

  2395.                     }
    2396. 

  2396.                 ;
    2397. 

  2397. 

  2398. string_dvar     : tGVAR {$$ = NEW_GVAR($1);}
    2399. 

  2399.                 | tIVAR {$$ = NEW_IVAR($1);}
    2400. 

  2400.                 | tCVAR {$$ = NEW_CVAR($1);}
    2401. 

  2401.                 | backref
    2402. 

  2402.                 ;
    2403. 

  2403. 

  2404. symbol          : tSYMBEG sym
    2405. 

  2405.                     {
    2406. 

  2406.                         lex_state = EXPR_END;
    2407. 

  2407.                         $$ = $2;
    2408. 

  2408.                     }
    2409. 

  2409.                 ;
    2410. 

  2410. 

  2411. sym             : fname
    2412. 

  2412.                 | tIVAR
    2413. 

  2413.                 | tGVAR
    2414. 

  2414.                 | tCVAR
    2415. 

  2415.                 ;
    2416. 

  2416. 

  2417. dsym            : tSYMBEG xstring_contents tSTRING_END
    2418. 

  2418.                     {
    2419. 

  2419.                         lex_state = EXPR_END;
    2420. 

  2420.                         if (!($$ = $2)) {
    2421. 

  2421.                             yyerror("empty symbol literal");
    2422. 

  2422.                         }
    2423. 

  2423.                         else {
    2424. 

  2424.                             switch (nd_type($$)) {
    2425. 

  2425.                               case NODE_DSTR:
    2426. 

  2426.                                 nd_set_type($$, NODE_DSYM);
    2427. 

  2427.                                 break;
    2428. 

  2428.                               case NODE_STR:
    2429. 

  2429.                                 /* TODO: this line should never fail unless nd_str is binary */
    2430. 

  2430.                                 if (strlen(bdatae($$->nd_str,"")) == (size_t)blength($$->nd_str)) {
    2431. 

  2431.                                   QUID tmp = rb_parser_sym(bdata($$->nd_str));
    2432. 

  2432.                                   bdestroy($$->nd_str);
    2433. 

  2433.                                   $$->nd_lit = QUID2SYM(tmp);
    2434. 

  2434.                                   nd_set_type($$, NODE_LIT);
    2435. 

  2435.                                   break;
    2436. 

  2436.                                 } else {
    2437. 

  2437.                                   bdestroy($$->nd_str);
    2438. 

  2438.                                 }
    2439. 

  2439.                                 /* fall through */
    2440. 

  2440.                               default:
    2441. 

  2441.                                 $$ = NEW_NODE(NODE_DSYM, string_new(0, 0), 1, NEW_LIST($$));
    2442. 

  2442.                                 break;
    2443. 

  2443.                             }
    2444. 

  2444.                         }
    2445. 

  2445.                     }
    2446. 

  2446.                 ;
    2447. 

  2447. 

  2448. numeric         : tINTEGER
    2449. 

  2449.                 | tFLOAT
    2450. 

  2450.                 | tUMINUS_NUM tINTEGER         %prec tLOWEST
    2451. 

  2451.                     {
    2452. 

  2452.                         $$ = NEW_NEGATE($2);
    2453. 

  2453.                     }
    2454. 

  2454.                 | tUMINUS_NUM tFLOAT           %prec tLOWEST
    2455. 

  2455.                     {
    2456. 

  2456.                         $$ = NEW_NEGATE($2);
    2457. 

  2457.                     }
    2458. 

  2458.                 ;
    2459. 

  2459. 

  2460. variable        : tIDENTIFIER
    2461. 

  2461.                 | tIVAR
    2462. 

  2462.                 | tGVAR
    2463. 

  2463.                 | tCONSTANT
    2464. 

  2464.                 | tCVAR
    2465. 

  2465.                 | kNIL {$$ = kNIL;}
    2466. 

  2466.                 | kSELF {$$ = kSELF;}
    2467. 

  2467.                 | kTRUE {$$ = kTRUE;}
    2468. 

  2468.                 | kFALSE {$$ = kFALSE;}
    2469. 

  2469.                 | k__FILE__ {$$ = k__FILE__;}
    2470. 

  2470.                 | k__LINE__ {$$ = k__LINE__;}
    2471. 

  2471.                 ;
    2472. 

  2472. 

  2473. var_ref         : variable
    2474. 

  2474.                     {
    2475. 

  2475.                         $$ = gettable($1);
    2476. 

  2476.                     }
    2477. 

  2477.                 ;
    2478. 

  2478. 

  2479. var_lhs         : variable
    2480. 

  2480.                     {
    2481. 

  2481.                         $$ = assignable($1, 0, vps);
    2482. 

  2482.                     }
    2483. 

  2483.                 ;
    2484. 

  2484. 

  2485. backref         : tNTH_REF
    2486. 

  2486.                 | tBACK_REF
    2487. 

  2487.                 ;
    2488. 

  2488. 

  2489. superclass      : term
    2490. 

  2490.                     {
    2491. 

  2491.                         $$ = 0;
    2492. 

  2492.                     }
    2493. 

  2493.                 | '<'
    2494. 

  2494.                     {
    2495. 

  2495.                         lex_state = EXPR_BEG;
    2496. 

  2496.                     }
    2497. 

  2497.                   expr_value term
    2498. 

  2498.                     {
    2499. 

  2499.                         $$ = $3;
    2500. 

  2500.                     }
    2501. 

  2501.                 | error term {yyerrok; $$ = 0;}
    2502. 

  2502.                 ;
    2503. 

  2503. 

  2504. f_arglist       : '(' f_args opt_nl ')'
    2505. 

  2505.                     {
    2506. 

  2506.                         $$ = $2;
    2507. 

  2507.                         lex_state = EXPR_BEG;
    2508. 

  2508.                         command_start = TRUE;
    2509. 

  2509.                     }
    2510. 

  2510.                 | f_args term
    2511. 

  2511.                     {
    2512. 

  2512.                         $$ = $1;
    2513. 

  2513.                     }
    2514. 

  2514.                 ;
    2515. 

  2515. 

  2516. f_args          : f_arg ',' f_optarg ',' f_rest_arg opt_f_block_arg
    2517. 

  2517.                     {
    2518. 

  2518.                         $$ = block_append(vps, NEW_ARGS((intptr_t)$1, $3, $5), $6);
    2519. 

  2519.                     }
    2520. 

  2520.                 | f_arg ',' f_optarg opt_f_block_arg
    2521. 

  2521.                     {
    2522. 

  2522.                         $$ = block_append(vps, NEW_ARGS((intptr_t)$1, $3, 0), $4);
    2523. 

  2523.                     }
    2524. 

  2524.                 | f_arg ',' f_rest_arg opt_f_block_arg
    2525. 

  2525.                     {
    2526. 

  2526.                         $$ = block_append(vps, NEW_ARGS((intptr_t)$1, 0, $3), $4);
    2527. 

  2527.                     }
    2528. 

  2528.                 | f_arg opt_f_block_arg
    2529. 

  2529.                     {
    2530. 

  2530.                         $$ = block_append(vps, NEW_ARGS((intptr_t)$1, 0, 0), $2);
    2531. 

  2531.                     }
    2532. 

  2532.                 | f_optarg ',' f_rest_arg opt_f_block_arg
    2533. 

  2533.                     {
    2534. 

  2534.                         $$ = block_append(vps, NEW_ARGS(0, $1, $3), $4);
    2535. 

  2535.                     }
    2536. 

  2536.                 | f_optarg opt_f_block_arg
    2537. 

  2537.                     {
    2538. 

  2538.                         $$ = block_append(vps, NEW_ARGS(0, $1, 0), $2);
    2539. 

  2539.                     }
    2540. 

  2540.                 | f_rest_arg opt_f_block_arg
    2541. 

  2541.                     {
    2542. 

  2542.                         $$ = block_append(vps, NEW_ARGS(0, 0, $1), $2);
    2543. 

  2543.                     }
    2544. 

  2544.                 | f_block_arg
    2545. 

  2545.                     {
    2546. 

  2546.                         $$ = block_append(vps, NEW_ARGS(0, 0, 0), $1);
    2547. 

  2547.                     }
    2548. 

  2548.                 | /* none */
    2549. 

  2549.                     {
    2550. 

  2550.                         $$ = NEW_ARGS(0, 0, 0);
    2551. 

  2551.                     }
    2552. 

  2552.                 ;
    2553. 

  2553. 

  2554. f_norm_arg      : tCONSTANT
    2555. 

  2555.                     {
    2556. 

  2556.                         yyerror("formal argument cannot be a constant");
    2557. 

  2557.                     }
    2558. 

  2558.                 | tIVAR
    2559. 

  2559.                     {
    2560. 

  2560.                         yyerror("formal argument cannot be an instance variable");
    2561. 

  2561.                     }
    2562. 

  2562.                 | tGVAR
    2563. 

  2563.                     {
    2564. 

  2564.                         yyerror("formal argument cannot be a global variable");
    2565. 

  2565.                     }
    2566. 

  2566.                 | tCVAR
    2567. 

  2567.                     {
    2568. 

  2568.                         yyerror("formal argument cannot be a class variable");
    2569. 

  2569.                     }
    2570. 

  2570.                 | tIDENTIFIER
    2571. 

  2571.                     {
    2572. 

  2572.                         if (!is_local_id($1))
    2573. 

  2573.                             yyerror("formal argument must be local variable");
    2574. 

  2574.                         else if (local_id($1))
    2575. 

  2575.                             yyerror("duplicate argument name");
    2576. 

  2576.                         local_cnt($1);
    2577. 

  2577.                         $$ = 1;
    2578. 

  2578.                     }
    2579. 

  2579.                 ;
    2580. 

  2580. 

  2581. f_arg           : f_norm_arg
    2582. 

  2582.                 | f_arg ',' f_norm_arg
    2583. 

  2583.                     {
    2584. 

  2584.                         $$ += 1;
    2585. 

  2585.                     }
    2586. 

  2586.                 ;
    2587. 

  2587. 

  2588. f_opt           : tIDENTIFIER '=' arg_value
    2589. 

  2589.                     {
    2590. 

  2590.                         if (!is_local_id($1))
    2591. 

  2591.                             yyerror("formal argument must be local variable");
    2592. 

  2592.                         else if (local_id($1))
    2593. 

  2593.                             yyerror("duplicate optional argument name");
    2594. 

  2594.                         $$ = assignable($1, $3, vps);
    2595. 

  2595.                     }
    2596. 

  2596.                 ;
    2597. 

  2597. 

  2598. f_optarg        : f_opt
    2599. 

  2599.                     {
    2600. 

  2600.                         $$ = NEW_BLOCK($1);
    2601. 

  2601.                         $$->nd_end = $$;
    2602. 

  2602.                     }
    2603. 

  2603.                 | f_optarg ',' f_opt
    2604. 

  2604.                     {
    2605. 

  2605.                         $$ = block_append(vps, $1, $3);
    2606. 

  2606.                     }
    2607. 

  2607.                 ;
    2608. 

  2608. 

  2609. restarg_mark    : '*'
    2610. 

  2610.                 | tSTAR
    2611. 

  2611.                 ;
    2612. 

  2612. 

  2613. f_rest_arg      : restarg_mark tIDENTIFIER
    2614. 

  2614.                     {
    2615. 

  2615.                         if (!is_local_id($2))
    2616. 

  2616.                             yyerror("rest argument must be local variable");
    2617. 

  2617.                         else if (local_id($2))
    2618. 

  2618.                             yyerror("duplicate rest argument name");
    2619. 

  2619.                         $$ = local_cnt($2) + 1;
    2620. 

  2620.                     }
    2621. 

  2621.                 | restarg_mark
    2622. 

  2622.                     {
    2623. 

  2623.                         $$ = -2;
    2624. 

  2624.                     }
    2625. 

  2625.                 ;
    2626. 

  2626. 

  2627. blkarg_mark     : '&'
    2628. 

  2628.                 | tAMPER
    2629. 

  2629.                 ;
    2630. 

  2630. 

  2631. f_block_arg     : blkarg_mark tIDENTIFIER
    2632. 

  2632.                     {
    2633. 

  2633.                         if (!is_local_id($2))
    2634. 

  2634.                             yyerror("block argument must be local variable");
    2635. 

  2635.                         else if (local_id($2))
    2636. 

  2636.                             yyerror("duplicate block argument name");
    2637. 

  2637.                         $$ = NEW_BLOCK_ARG($2);
    2638. 

  2638.                     }
    2639. 

  2639.                 ;
    2640. 

  2640. 

  2641. opt_f_block_arg : ',' f_block_arg
    2642. 

  2642.                     {
    2643. 

  2643.                         $$ = $2;
    2644. 

  2644.                     }
    2645. 

  2645.                 | none
    2646. 

  2646.                 ;
    2647. 

  2647. 

  2648. singleton       : var_ref
    2649. 

  2649.                     {
    2650. 

  2650.                         $$ = $1;
    2651. 

  2651.                         value_expr($$);
    2652. 

  2652.                     }
    2653. 

  2653.                 | '(' {lex_state = EXPR_BEG;} expr opt_nl ')'
    2654. 

  2654.                     {
    2655. 

  2655.                         if ($3 == 0) {
    2656. 

  2656.                             yyerror("can't define singleton method for ().");
    2657. 

  2657.                         }
    2658. 

  2658.                         else {
    2659. 

  2659.                             switch (nd_type($3)) {
    2660. 

  2660.                               case NODE_STR:
    2661. 

  2661.                               case NODE_DSTR:
    2662. 

  2662.                               case NODE_XSTR:
    2663. 

  2663.                               case NODE_DXSTR:
    2664. 

  2664.                               case NODE_DREGX:
    2665. 

  2665.                               case NODE_LIT:
    2666. 

  2666.                               case NODE_ARRAY:
    2667. 

  2667.                               case NODE_ZARRAY:
    2668. 

  2668.                                 yyerror("can't define singleton method for literals");
    2669. 

  2669.                               default:
    2670. 

  2670.                                 value_expr($3);
    2671. 

  2671.                                 break;
    2672. 

  2672.                             }
    2673. 

  2673.                         }
    2674. 

  2674.                         $$ = $3;
    2675. 

  2675.                     }
    2676. 

  2676.                 ;
    2677. 

  2677. 

  2678. assoc_list      : none
    2679. 

  2679.                 | assocs trailer
    2680. 

  2680.                     {
    2681. 

  2681.                         $$ = $1;
    2682. 

  2682.                     }
    2683. 

  2683.                 | args trailer
    2684. 

  2684.                     {
    2685. 

  2685.                         if ($1->nd_alen%2 != 0) {
    2686. 

  2686.                             yyerror("odd number list for Hash");
    2687. 

  2687.                         }
    2688. 

  2688.                         $$ = $1;
    2689. 

  2689.                     }
    2690. 

  2690.                 ;
    2691. 

  2691. 

  2692. assocs          : assoc
    2693. 

  2693.                 | assocs ',' assoc
    2694. 

  2694.                     {
    2695. 

  2695.                         $$ = list_concat($1, $3);
    2696. 

  2696.                     }
    2697. 

  2697.                 ;
    2698. 

  2698. 

  2699. assoc           : arg_value tASSOC arg_value
    2700. 

  2700.                     {
    2701. 

  2701.                         $$ = list_append(vps, NEW_LIST($1), $3);
    2702. 

  2702.                     }
    2703. 

  2703.                 ;
    2704. 

  2704. 

  2705. operation       : tIDENTIFIER
    2706. 

  2706.                 | tCONSTANT
    2707. 

  2707.                 | tFID
    2708. 

  2708.                 ;
    2709. 

  2709. 

  2710. operation2      : tIDENTIFIER
    2711. 

  2711.                 | tCONSTANT
    2712. 

  2712.                 | tFID
    2713. 

  2713.                 | op
    2714. 

  2714.                 ;
    2715. 

  2715. 

  2716. operation3      : tIDENTIFIER
    2717. 

  2717.                 | tFID
    2718. 

  2718.                 | op
    2719. 

  2719.                 ;
    2720. 

  2720. 

  2721. dot_or_colon    : '.'
    2722. 

  2722.                 | tCOLON2
    2723. 

  2723.                 ;
    2724. 

  2724. 

  2725. opt_terms       : /* none */
    2726. 

  2726.                 | terms
    2727. 

  2727.                 ;
    2728. 

  2728. 

  2729. opt_nl          : /* none */
    2730. 

  2730.                 | '\n'
    2731. 

  2731.                 ;
    2732. 

  2732. 

  2733. trailer         : /* none */
    2734. 

  2734.                 | '\n'
    2735. 

  2735.                 | ','
    2736. 

  2736.                 ;
    2737. 

  2737. 

  2738. term            : ';' {yyerrok;}
    2739. 

  2739.                 | '\n'
    2740. 

  2740.                 ;
    2741. 

  2741. 

  2742. terms           : term
    2743. 

  2743.                 | terms ';' {yyerrok;}
    2744. 

  2744.                 ;
    2745. 

  2745. 

  2746. none            : /* none */ {$$ = 0;}
    2747. 

  2747.                 ;
    2748. 

  2748. %%
    2749. 

  2749. 

  2750. /* We remove any previous definition of `SIGN_EXTEND_CHAR',
    2751. 

  2751.    since ours (we hope) works properly with all combinations of
    2752. 

  2752.    machines, compilers, `char' and `unsigned char' argument types.
    2753. 

  2753.    (Per Bothner suggested the basic approach.)  */
    2754. 

  2754. #undef SIGN_EXTEND_CHAR
    2755. 

  2755. #if __STDC__
    2756. 

  2756. # define SIGN_EXTEND_CHAR(c) ((signed char)(c))
    2757. 

  2757. #else  /* not __STDC__ */
    2758. 

  2758. /* As in Harbison and Steele.  */
    2759. 

  2759. # define SIGN_EXTEND_CHAR(c) ((((unsigned char)(c)) ^ 128) - 128)
    2760. 

  2760. #endif
    2761. 

  2761. #define is_identchar(c) (SIGN_EXTEND_CHAR(c)!=-1&&(ISALNUM(c) || (c) == '_' || ismbchar(c)))
    2762. 

  2762. 

  2763. #define LEAVE_BS 1
    2764. 

  2764. 

  2765. static int
    2766. 

  2766. mel_yyerror(const char *msg, rb_parser_state *parser_state)
    2767. 

  2767. {
    2768. 

  2768.     create_error(parser_state, (char *)msg);
    2769. 

  2769. 

  2770.     return 1;
    2771. 

  2771. }
    2772. 

  2772. 

  2773. static int
    2774. 

  2774. yycompile(rb_parser_state *parser_state, char *f, int line)
    2775. 

  2775. {
    2776. 

  2776.     int n;
    2777. 

  2777.     /* Setup an initial empty scope. */
    2778. 

  2778.     heredoc_end = 0;
    2779. 

  2779.     lex_strterm = 0;
    2780. 

  2780.     end_seen = 0;
    2781. 

  2781.     ruby_sourcefile = f;
    2782. 

  2782.     command_start = TRUE;
    2783. 

  2783.     n = yyparse(parser_state);
    2784. 

  2784.     ruby_debug_lines = 0;
    2785. 

  2785.     compile_for_eval = 0;
    2786. 

  2786.     cond_stack = 0;
    2787. 

  2787.     cmdarg_stack = 0;
    2788. 

  2788.     command_start = TRUE;
    2789. 

  2789.     class_nest = 0;
    2790. 

  2790.     in_single = 0;
    2791. 

  2791.     in_def = 0;
    2792. 

  2792.     cur_mid = 0;
    2793. 

  2793. 

  2794.     lex_strterm = 0;
    2795. 

  2795. 

  2796.     return n;
    2797. 

  2797. }
    2798. 

  2798. 

  2799. static bool
    2800. 

  2800. lex_get_str(rb_parser_state *parser_state)
    2801. 

  2801. {
    2802. 

  2802.     const char *str;
    2803. 

  2803.     const char *beg, *end, *pend;
    2804. 

  2804.     int sz;
    2805. 

  2805. 

  2806.     str = bdata(lex_string);
    2807. 

  2807.     beg = str;
    2808. 

  2808. 

  2809.     if (lex_str_used) {
    2810. 

  2810.       if (blength(lex_string) == lex_str_used) {
    2811. 

  2811.         return false;
    2812. 

  2812.       }
    2813. 

  2813. 

  2814.       beg += lex_str_used;
    2815. 

  2815.     }
    2816. 

  2816. 

  2817.     pend = str + blength(lex_string);
    2818. 

  2818.     end = beg;
    2819. 

  2819. 

  2820.     while(end < pend) {
    2821. 

  2821.       if(*end++ == '\n') break;
    2822. 

  2822.     }
    2823. 

  2823. 

  2824.     sz = (int)(end - beg);
    2825. 

  2825.     bcatblk(line_buffer, beg, sz);
    2826. 

  2826.     lex_str_used += sz;
    2827. 

  2827. 

  2828.     return TRUE;
    2829. 

  2829. }
    2830. 

  2830. 

  2831. static bool
    2832. 

  2832. lex_getline(rb_parser_state *parser_state)
    2833. 

  2833. {
    2834. 

  2834.   if(!line_buffer) {
    2835. 

  2835.     line_buffer = cstr2bstr("");
    2836. 

  2836.   } else {
    2837. 

  2837.     btrunc(line_buffer, 0);
    2838. 

  2838.   }
    2839. 

  2839. 

  2840.   return lex_gets(parser_state);
    2841. 

  2841. }
    2842. 

  2842. 

  2843. VALUE
    2844. 

  2844. string_to_ast(VALUE ptp, const char *f, bstring s, int line)
    2845. 

  2845. {
    2846. 

  2846.     int n;
    2847. 

  2847.     VALUE ret;
    2848. 

  2848.     rb_parser_state *parser_state = parser_alloc_state();
    2849. 

  2849. 

  2850.     lex_string = s;
    2851. 

  2851.     lex_gets = lex_get_str;
    2852. 

  2852.     processor = ptp;
    2853. 

  2853.     ruby_sourceline = line - 1;
    2854. 

  2854.     compile_for_eval = 1;
    2855. 

  2855. 

  2856.     n = yycompile(parser_state, (char*)f, line);
    2857. 

  2857. 

  2858.     if(!parse_error) {
    2859. 

  2859.       for(std::vector<bstring>::iterator i = magic_comments->begin();
    2860. 

  2860.           i != magic_comments->end();
    2861. 

  2861.           i++) {
    2862. 

  2862.         rb_funcall(ptp, rb_intern("add_magic_comment"), 1,
    2863. 

  2863.           rb_str_new((const char*)(*i)->data, (*i)->slen));
    2864. 

  2864.       }
    2865. 

  2865.       ret = process_parse_tree(parser_state, ptp, top_node, NULL);
    2866. 

  2866.     } else {
    2867. 

  2867.         ret = Qnil;
    2868. 

  2868.     }
    2869. 

  2869.     pt_free(parser_state);
    2870. 

  2870.     free(parser_state);
    2871. 

  2871.     quark_cleanup();
    2872. 

  2872.     return ret;
    2873. 

  2873. }
    2874. 

  2874. 

  2875. static bool parse_io_gets(rb_parser_state *parser_state) {
    2876. 

  2876.   if(feof(lex_io)) {
    2877. 

  2877.     return false;
    2878. 

  2878.   }
    2879. 

  2879. 

  2880.   while(TRUE) {
    2881. 

  2881.     char *ptr, buf[1024];
    2882. 

  2882.     int read;
    2883. 

  2883. 

  2884.     ptr = fgets(buf, sizeof(buf), lex_io);
    2885. 

  2885.     if(!ptr) {
    2886. 

  2886.       return false;
    2887. 

  2887.     }
    2888. 

  2888. 

  2889.     read = (int)strlen(ptr);
    2890. 

  2890.     bcatblk(line_buffer, ptr, read);
    2891. 

  2891. 

  2892.     /* check whether we read a full line */
    2893. 

  2893.     if(!(read == (sizeof(buf) - 1) && ptr[read] != '\n')) {
    2894. 

  2894.       break;
    2895. 

  2895.     }
    2896. 

  2896.   }
    2897. 

  2897. 

  2898.   return TRUE;
    2899. 

  2899. }
    2900. 

  2900. 

  2901. VALUE
    2902. 

  2902. file_to_ast(VALUE ptp, const char *f, FILE *file, int start)
    2903. 

  2903. {
    2904. 

  2904.     int n;
    2905. 

  2905.     VALUE ret;
    2906. 

  2906.     rb_parser_state *parser_state = parser_alloc_state();
    2907. 

  2907. 

  2908.     lex_io = file;
    2909. 

  2909.     lex_gets = parse_io_gets;
    2910. 

  2910.     processor = ptp;
    2911. 

  2911.     ruby_sourceline = start - 1;
    2912. 

  2912. 

  2913.     n = yycompile(parser_state, (char*)f, start);
    2914. 

  2914. 

  2915.     if(!parse_error) {
    2916. 

  2916.       for(std::vector<bstring>::iterator i = magic_comments->begin();
    2917. 

  2917.           i != magic_comments->end();
    2918. 

  2918.           i++) {
    2919. 

  2919.         rb_funcall(ptp, rb_intern("add_magic_comment"), 1,
    2920. 

  2920.           rb_str_new((const char*)(*i)->data, (*i)->slen));
    2921. 

  2921.       }
    2922. 

  2922.         ret = process_parse_tree(parser_state, ptp, top_node, NULL);
    2923. 

  2923. 

  2924.         if (end_seen && lex_io) {
    2925. 

  2925.           rb_funcall(ptp, rb_sData, 1, ULONG2NUM(ftell(lex_io)));
    2926. 

  2926.         }
    2927. 

  2927.     } else {
    2928. 

  2928.         ret = Qnil;
    2929. 

  2929.     }
    2930. 

  2930. 

  2931.     pt_free(parser_state);
    2932. 

  2932.     free(parser_state);
    2933. 

  2933.     quark_cleanup();
    2934. 

  2934.     return ret;
    2935. 

  2935. }
    2936. 

  2936. 

  2937. #define nextc() ps_nextc(parser_state)
    2938. 

  2938. 

  2939. static inline int
    2940. 

  2940. ps_nextc(rb_parser_state *parser_state)
    2941. 

  2941. {
    2942. 

  2942.     int c;
    2943. 

  2943. 

  2944.     if (lex_p == lex_pend) {
    2945. 

  2945.         bstring v;
    2946. 

  2946. 

  2947.         if (!lex_getline(parser_state)) return -1;
    2948. 

  2948.         v = line_buffer;
    2949. 

  2949. 

  2950.         if (heredoc_end > 0) {
    2951. 

  2951.             ruby_sourceline = heredoc_end;
    2952. 

  2952.             heredoc_end = 0;
    2953. 

  2953.         }
    2954. 

  2954.         ruby_sourceline++;
    2955. 

  2955. 

  2956.         /* This code is setup so that lex_pend can be compared to
    2957. 

  2957.            the data in lex_lastline. Thats important, otherwise
    2958. 

  2958.            the heredoc code breaks. */
    2959. 

  2959.         if(lex_lastline) {
    2960. 

  2960.           bassign(lex_lastline, v);
    2961. 

  2961.         } else {
    2962. 

  2962.           lex_lastline = bstrcpy(v);
    2963. 

  2963.         }
    2964. 

  2964. 

  2965.         v = lex_lastline;
    2966. 

  2966. 

  2967.         lex_pbeg = lex_p = bdata(v);
    2968. 

  2968.         lex_pend = lex_p + blength(v);
    2969. 

  2969.     }
    2970. 

  2970.     c = (unsigned char)*(lex_p++);
    2971. 

  2971.     if (c == '\r' && lex_p < lex_pend && *(lex_p) == '\n') {
    2972. 

  2972.         lex_p++;
    2973. 

  2973.         c = '\n';
    2974. 

  2974.         column = 0;
    2975. 

  2975.     } else if(c == '\n') {
    2976. 

  2976.         column = 0;
    2977. 

  2977.     } else {
    2978. 

  2978.         column++;
    2979. 

  2979.     }
    2980. 

  2980. 

  2981.     return c;
    2982. 

  2982. }
    2983. 

  2983. 

  2984. static void
    2985. 

  2985. pushback(int c, rb_parser_state *parser_state)
    2986. 

  2986. {
    2987. 

  2987.     if (c == -1) return;
    2988. 

  2988.     lex_p--;
    2989. 

  2989. }
    2990. 

  2990. 

  2991. /* Indicates if we're currently at the beginning of a line. */
    2992. 

  2992. #define was_bol() (lex_p == lex_pbeg + 1)
    2993. 

  2993. #define peek(c) (lex_p != lex_pend && (c) == *(lex_p))
    2994. 

  2994. 

  2995. /* The token buffer. It's just a global string that has
    2996. 

  2996.    functions to build up the string easily. */
    2997. 

  2997. 

  2998. #define tokfix() (tokenbuf[tokidx]='\0')
    2999. 

  2999. #define tok() tokenbuf
    3000. 

  3000. #define toklen() tokidx
    3001. 

  3001. #define toklast() (tokidx>0?tokenbuf[tokidx-1]:0)
    3002. 

  3002. 

  3003. static char*
    3004. 

  3004. newtok(rb_parser_state *parser_state)
    3005. 

  3005. {
    3006. 

  3006.     tokidx = 0;
    3007. 

  3007.     if (!tokenbuf) {
    3008. 

  3008.         toksiz = 60;
    3009. 

  3009.         tokenbuf = ALLOC_N(char, 60);
    3010. 

  3010.     }
    3011. 

  3011.     if (toksiz > 4096) {
    3012. 

  3012.         toksiz = 60;
    3013. 

  3013.         REALLOC_N(tokenbuf, char, 60);
    3014. 

  3014.     }
    3015. 

  3015.     return tokenbuf;
    3016. 

  3016. }
    3017. 

  3017. 

  3018. static void tokadd(char c, rb_parser_state *parser_state)
    3019. 

  3019. {
    3020. 

  3020.     assert(tokidx < toksiz && tokidx >= 0);
    3021. 

  3021.     tokenbuf[tokidx++] = c;
    3022. 

  3022.     if (tokidx >= toksiz) {
    3023. 

  3023.         toksiz *= 2;
    3024. 

  3024.         REALLOC_N(tokenbuf, char, toksiz);
    3025. 

  3025.     }
    3026. 

  3026. }
    3027. 

  3027. 

  3028. static int
    3029. 

  3029. read_escape(rb_parser_state *parser_state)
    3030. 

  3030. {
    3031. 

  3031.     int c;
    3032. 

  3032. 

  3033.     switch (c = nextc()) {
    3034. 

  3034.       case '\\':        /* Backslash */
    3035. 

  3035.         return c;
    3036. 

  3036. 

  3037.       case 'n': /* newline */
    3038. 

  3038.         return '\n';
    3039. 

  3039. 

  3040.       case 't': /* horizontal tab */
    3041. 

  3041.         return '\t';
    3042. 

  3042. 

  3043.       case 'r': /* carriage-return */
    3044. 

  3044.         return '\r';
    3045. 

  3045. 

  3046.       case 'f': /* form-feed */
    3047. 

  3047.         return '\f';
    3048. 

  3048. 

  3049.       case 'v': /* vertical tab */
    3050. 

  3050.         return '\13';
    3051. 

  3051. 

  3052.       case 'a': /* alarm(bell) */
    3053. 

  3053.         return '\007';
    3054. 

  3054. 

  3055.       case 'e': /* escape */
    3056. 

  3056.         return 033;
    3057. 

  3057. 

  3058.       case '0': case '1': case '2': case '3': /* octal constant */
    3059. 

  3059.       case '4': case '5': case '6': case '7':
    3060. 

  3060.         {
    3061. 

  3061.             int numlen;
    3062. 

  3062. 

  3063.             pushback(c, parser_state);
    3064. 

  3064.             c = scan_oct(lex_p, 3, &numlen);
    3065. 

  3065.             lex_p += numlen;
    3066. 

  3066.         }
    3067. 

  3067.         return c;
    3068. 

  3068. 

  3069.       case 'x': /* hex constant */
    3070. 

  3070.         {
    3071. 

  3071.             int numlen;
    3072. 

  3072. 

  3073.             c = scan_hex(lex_p, 2, &numlen);
    3074. 

  3074.             if (numlen == 0) {
    3075. 

  3075.                 yyerror("Invalid escape character syntax");
    3076. 

  3076.                 return 0;
    3077. 

  3077.             }
    3078. 

  3078.             lex_p += numlen;
    3079. 

  3079.         }
    3080. 

  3080.         return c;
    3081. 

  3081. 

  3082.       case 'b': /* backspace */
    3083. 

  3083.         return '\010';
    3084. 

  3084. 

  3085.       case 's': /* space */
    3086. 

  3086.         return ' ';
    3087. 

  3087. 

  3088.       case 'M':
    3089. 

  3089.         if ((c = nextc()) != '-') {
    3090. 

  3090.             yyerror("Invalid escape character syntax");
    3091. 

  3091.             pushback(c, parser_state);
    3092. 

  3092.             return '\0';
    3093. 

  3093.         }
    3094. 

  3094.         if ((c = nextc()) == '\\') {
    3095. 

  3095.             return read_escape(parser_state) | 0x80;
    3096. 

  3096.         }
    3097. 

  3097.         else if (c == -1) goto eof;
    3098. 

  3098.         else {
    3099. 

  3099.             return ((c & 0xff) | 0x80);
    3100. 

  3100.         }
    3101. 

  3101. 

  3102.       case 'C':
    3103. 

  3103.         if ((c = nextc()) != '-') {
    3104. 

  3104.             yyerror("Invalid escape character syntax");
    3105. 

  3105.             pushback(c, parser_state);
    3106. 

  3106.             return '\0';
    3107. 

  3107.         }
    3108. 

  3108.       case 'c':
    3109. 

  3109.         if ((c = nextc())== '\\') {
    3110. 

  3110.             c = read_escape(parser_state);
    3111. 

  3111.         }
    3112. 

  3112.         else if (c == '?')
    3113. 

  3113.             return 0177;
    3114. 

  3114.         else if (c == -1) goto eof;
    3115. 

  3115.         return c & 0x9f;
    3116. 

  3116. 

  3117.       eof:
    3118. 

  3118.       case -1:
    3119. 

  3119.         yyerror("Invalid escape character syntax");
    3120. 

  3120.         return '\0';
    3121. 

  3121. 

  3122.       default:
    3123. 

  3123.         return c;
    3124. 

  3124.     }
    3125. 

  3125. }
    3126. 

  3126. 

  3127. static int
    3128. 

  3128. tokadd_escape(int term, rb_parser_state *parser_state)
    3129. 

  3129. {
    3130. 

  3130.     int c;
    3131. 

  3131. 

  3132.     switch (c = nextc()) {
    3133. 

  3133.       case '\n':
    3134. 

  3134.         return 0;               /* just ignore */
    3135. 

  3135. 

  3136.       case '0': case '1': case '2': case '3': /* octal constant */
    3137. 

  3137.       case '4': case '5': case '6': case '7':
    3138. 

  3138.         {
    3139. 

  3139.             int i;
    3140. 

  3140. 

  3141.             tokadd((char)'\\', parser_state);
    3142. 

  3142.             tokadd((char)c, parser_state);
    3143. 

  3143.             for (i=0; i<2; i++) {
    3144. 

  3144.                 c = nextc();
    3145. 

  3145.                 if (c == -1) goto eof;
    3146. 

  3146.                 if (c < '0' || '7' < c) {
    3147. 

  3147.                     pushback(c, parser_state);
    3148. 

  3148.                     break;
    3149. 

  3149.                 }
    3150. 

  3150.                 tokadd((char)c, parser_state);
    3151. 

  3151.             }
    3152. 

  3152.         }
    3153. 

  3153.         return 0;
    3154. 

  3154. 

  3155.       case 'x': /* hex constant */
    3156. 

  3156.         {
    3157. 

  3157.             int numlen;
    3158. 

  3158. 

  3159.             tokadd('\\', parser_state);
    3160. 

  3160.             tokadd((char)c, parser_state);
    3161. 

  3161.             scan_hex(lex_p, 2, &numlen);
    3162. 

  3162.             if (numlen == 0) {
    3163. 

  3163.                 yyerror("Invalid escape character syntax");
    3164. 

  3164.                 return -1;
    3165. 

  3165.             }
    3166. 

  3166.             while (numlen--)
    3167. 

  3167.                 tokadd((char)nextc(), parser_state);
    3168. 

  3168.         }
    3169. 

  3169.         return 0;
    3170. 

  3170. 

  3171.       case 'M':
    3172. 

  3172.         if ((c = nextc()) != '-') {
    3173. 

  3173.             yyerror("Invalid escape character syntax");
    3174. 

  3174.             pushback(c, parser_state);
    3175. 

  3175.             return 0;
    3176. 

  3176.         }
    3177. 

  3177.         tokadd('\\',parser_state);
    3178. 

  3178.         tokadd('M', parser_state);
    3179. 

  3179.         tokadd('-', parser_state);
    3180. 

  3180.         goto escaped;
    3181. 

  3181. 

  3182.       case 'C':
    3183. 

  3183.         if ((c = nextc()) != '-') {
    3184. 

  3184.             yyerror("Invalid escape character syntax");
    3185. 

  3185.             pushback(c, parser_state);
    3186. 

  3186.             return 0;
    3187. 

  3187.         }
    3188. 

  3188.         tokadd('\\', parser_state);
    3189. 

  3189.         tokadd('C', parser_state);
    3190. 

  3190.         tokadd('-', parser_state);
    3191. 

  3191.         goto escaped;
    3192. 

  3192. 

  3193.       case 'c':
    3194. 

  3194.         tokadd('\\', parser_state);
    3195. 

  3195.         tokadd('c', parser_state);
    3196. 

  3196.       escaped:
    3197. 

  3197.         if ((c = nextc()) == '\\') {
    3198. 

  3198.             return tokadd_escape(term, parser_state);
    3199. 

  3199.         }
    3200. 

  3200.         else if (c == -1) goto eof;
    3201. 

  3201.         tokadd((char)c, parser_state);
    3202. 

  3202.         return 0;
    3203. 

  3203. 

  3204.       eof:
    3205. 

  3205.       case -1:
    3206. 

  3206.         yyerror("Invalid escape character syntax");
    3207. 

  3207.         return -1;
    3208. 

  3208. 

  3209.       default:
    3210. 

  3210.         if (c != '\\' || c != term)
    3211. 

  3211.             tokadd('\\', parser_state);
    3212. 

  3212.         tokadd((char)c, parser_state);
    3213. 

  3213.     }
    3214. 

  3214.     return 0;
    3215. 

  3215. }
    3216. 

  3216. 

  3217. static int
    3218. 

  3218. regx_options(rb_parser_state *parser_state)
    3219. 

  3219. {
    3220. 

  3220.     char kcode = 0;
    3221. 

  3221.     int options = 0;
    3222. 

  3222.     int c;
    3223. 

  3223. 

  3224.     newtok(parser_state);
    3225. 

  3225.     while (c = nextc(), ISALPHA(c)) {
    3226. 

  3226.         switch (c) {
    3227. 

  3227.           case 'i':
    3228. 

  3228.             options |= RE_OPTION_IGNORECASE;
    3229. 

  3229.             break;
    3230. 

  3230.           case 'x':
    3231. 

  3231.             options |= RE_OPTION_EXTENDED;
    3232. 

  3232.             break;
    3233. 

  3233.           case 'm':
    3234. 

  3234.             options |= RE_OPTION_MULTILINE;
    3235. 

  3235.             break;
    3236. 

  3236.           case 'o':
    3237. 

  3237.             options |= RE_OPTION_ONCE;
    3238. 

  3238.             break;
    3239. 

  3239.           case 'G':
    3240. 

  3240.             options |= RE_OPTION_CAPTURE_GROUP;
    3241. 

  3241.             break;
    3242. 

  3242.           case 'g':
    3243. 

  3243.             options |= RE_OPTION_DONT_CAPTURE_GROUP;
    3244. 

  3244.             break;
    3245. 

  3245.           case 'n':
    3246. 

  3246.             kcode = 16;
    3247. 

  3247.             break;
    3248. 

  3248.           case 'e':
    3249. 

  3249.             kcode = 32;
    3250. 

  3250.             break;
    3251. 

  3251.           case 's':
    3252. 

  3252.             kcode = 48;
    3253. 

  3253.             break;
    3254. 

  3254.           case 'u':
    3255. 

  3255.             kcode = 64;
    3256. 

  3256.             break;
    3257. 

  3257.           default:
    3258. 

  3258.             tokadd((char)c, parser_state);
    3259. 

  3259.             break;
    3260. 

  3260.         }
    3261. 

  3261.     }
    3262. 

  3262.     pushback(c, parser_state);
    3263. 

  3263.     if (toklen()) {
    3264. 

  3264.         tokfix();
    3265. 

  3265.         rb_compile_error(parser_state, "unknown regexp option%s - %s",
    3266. 

  3266.                          toklen() > 1 ? "s" : "", tok());
    3267. 

  3267.     }
    3268. 

  3268.     return options | kcode;
    3269. 

  3269. }
    3270. 

  3270. 

  3271. #define STR_FUNC_ESCAPE 0x01
    3272. 

  3272. #define STR_FUNC_EXPAND 0x02
    3273. 

  3273. #define STR_FUNC_REGEXP 0x04
    3274. 

  3274. #define STR_FUNC_QWORDS 0x08
    3275. 

  3275. #define STR_FUNC_SYMBOL 0x10
    3276. 

  3276. #define STR_FUNC_INDENT 0x20
    3277. 

  3277. 

  3278. enum string_type {
    3279. 

  3279.     str_squote = (0),
    3280. 

  3280.     str_dquote = (STR_FUNC_EXPAND),
    3281. 

  3281.     str_xquote = (STR_FUNC_EXPAND),
    3282. 

  3282.     str_regexp = (STR_FUNC_REGEXP|STR_FUNC_ESCAPE|STR_FUNC_EXPAND),
    3283. 

  3283.     str_sword  = (STR_FUNC_QWORDS),
    3284. 

  3284.     str_dword  = (STR_FUNC_QWORDS|STR_FUNC_EXPAND),
    3285. 

  3285.     str_ssym   = (STR_FUNC_SYMBOL),
    3286. 

  3286.     str_dsym   = (STR_FUNC_SYMBOL|STR_FUNC_EXPAND),
    3287. 

  3287. };
    3288. 

  3288. 

  3289. static int tokadd_string(int func, int term, int paren, quark *nest, rb_parser_state *parser_state)
    3290. 

  3290. {
    3291. 

  3291.     int c;
    3292. 

  3292. 

  3293.     while ((c = nextc()) != -1) {
    3294. 

  3294.         if (paren && c == paren) {
    3295. 

  3295.             ++*nest;
    3296. 

  3296.         }
    3297. 

  3297.         else if (c == term) {
    3298. 

  3298.             if (!nest || !*nest) {
    3299. 

  3299.                 pushback(c, parser_state);
    3300. 

  3300.                 break;
    3301. 

  3301.             }
    3302. 

  3302.             --*nest;
    3303. 

  3303.         }
    3304. 

  3304.         else if ((func & STR_FUNC_EXPAND) && c == '#' && lex_p < lex_pend) {
    3305. 

  3305.             int c2 = *(lex_p);
    3306. 

  3306.             if (c2 == '$' || c2 == '@' || c2 == '{') {
    3307. 

  3307.                 pushback(c, parser_state);
    3308. 

  3308.                 break;
    3309. 

  3309.             }
    3310. 

  3310.         }
    3311. 

  3311.         else if (c == '\\') {
    3312. 

  3312.             c = nextc();
    3313. 

  3313.             switch (c) {
    3314. 

  3314.               case '\n':
    3315. 

  3315.                 if (func & STR_FUNC_QWORDS) break;
    3316. 

  3316.                 if (func & STR_FUNC_EXPAND) continue;
    3317. 

  3317.                 tokadd('\\', parser_state);
    3318. 

  3318.                 break;
    3319. 

  3319. 

  3320.               case '\\':
    3321. 

  3321.                 if (func & STR_FUNC_ESCAPE) tokadd((char)c, parser_state);
    3322. 

  3322.                 break;
    3323. 

  3323. 

  3324.               default:
    3325. 

  3325.                 if (func & STR_FUNC_REGEXP) {
    3326. 

  3326.                     pushback(c, parser_state);
    3327. 

  3327.                     if (tokadd_escape(term, parser_state) < 0)
    3328. 

  3328.                         return -1;
    3329. 

  3329.                     continue;
    3330. 

  3330.                 }
    3331. 

  3331.                 else if (func & STR_FUNC_EXPAND) {
    3332. 

  3332.                     pushback(c, parser_state);
    3333. 

  3333.                     if (func & STR_FUNC_ESCAPE) tokadd('\\', parser_state);
    3334. 

  3334.                     c = read_escape(parser_state);
    3335. 

  3335.                 }
    3336. 

  3336.                 else if ((func & STR_FUNC_QWORDS) && ISSPACE(c)) {
    3337. 

  3337.                     /* ignore backslashed spaces in %w */
    3338. 

  3338.                 }
    3339. 

  3339.                 else if (c != term && !(paren && c == paren)) {
    3340. 

  3340.                     tokadd('\\', parser_state);
    3341. 

  3341.                 }
    3342. 

  3342.             }
    3343. 

  3343.         }
    3344. 

  3344.         else if (ismbchar(c)) {
    3345. 

  3345.             int i, len = mbclen(c)-1;
    3346. 

  3346. 

  3347.             for (i = 0; i < len; i++) {
    3348. 

  3348.                 tokadd((char)c, parser_state);
    3349. 

  3349.                 c = nextc();
    3350. 

  3350.             }
    3351. 

  3351.         }
    3352. 

  3352.         else if ((func & STR_FUNC_QWORDS) && ISSPACE(c)) {
    3353. 

  3353.             pushback(c, parser_state);
    3354. 

  3354.             break;
    3355. 

  3355.         }
    3356. 

  3356.         if (!c && (func & STR_FUNC_SYMBOL)) {
    3357. 

  3357.             func &= ~STR_FUNC_SYMBOL;
    3358. 

  3358.             rb_compile_error(parser_state, "symbol cannot contain '\\0'");
    3359. 

  3359.             continue;
    3360. 

  3360.         }
    3361. 

  3361.         tokadd((char)c, parser_state);
    3362. 

  3362.     }
    3363. 

  3363.     return c;
    3364. 

  3364. }
    3365. 

  3365. 

  3366. #define NEW_STRTERM(func, term, paren) \
    3367. 

  3367.   node_newnode(NODE_STRTERM, (VALUE)(func), \
    3368. 

  3368.                (VALUE)((term) | ((paren) << (CHAR_BIT * 2))), 0)
    3369. 

  3369. #define pslval ((YYSTYPE *)lval)
    3370. 

  3370. static int
    3371. 

  3371. parse_string(NODE *quote, rb_parser_state *parser_state)
    3372. 

  3372. {
    3373. 

  3373.     int func = (int)quote->nd_func;
    3374. 

  3374.     int term = nd_term(quote);
    3375. 

  3375.     int paren = nd_paren(quote);
    3376. 

  3376.     int c, space = 0;
    3377. 

  3377. 

  3378.     long start_line = ruby_sourceline;
    3379. 

  3379. 

  3380.     if (func == -1) return tSTRING_END;
    3381. 

  3381.     c = nextc();
    3382. 

  3382.     if ((func & STR_FUNC_QWORDS) && ISSPACE(c)) {
    3383. 

  3383.         do {c = nextc();} while (ISSPACE(c));
    3384. 

  3384.         space = 1;
    3385. 

  3385.     }
    3386. 

  3386.     if (c == term && !quote->nd_nest) {
    3387. 

  3387.         if (func & STR_FUNC_QWORDS) {
    3388. 

  3388.             quote->nd_func = -1;
    3389. 

  3389.             return ' ';
    3390. 

  3390.         }
    3391. 

  3391.         if (!(func & STR_FUNC_REGEXP)) return tSTRING_END;
    3392. 

  3392.         pslval->num = regx_options(parser_state);
    3393. 

  3393.         return tREGEXP_END;
    3394. 

  3394.     }
    3395. 

  3395.     if (space) {
    3396. 

  3396.         pushback(c, parser_state);
    3397. 

  3397.         return ' ';
    3398. 

  3398.     }
    3399. 

  3399.     newtok(parser_state);
    3400. 

  3400.     if ((func & STR_FUNC_EXPAND) && c == '#') {
    3401. 

  3401.         switch (c = nextc()) {
    3402. 

  3402.           case '$':
    3403. 

  3403.           case '@':
    3404. 

  3404.             pushback(c, parser_state);
    3405. 

  3405.             return tSTRING_DVAR;
    3406. 

  3406.           case '{':
    3407. 

  3407.             return tSTRING_DBEG;
    3408. 

  3408.         }
    3409. 

  3409.         tokadd('#', parser_state);
    3410. 

  3410.     }
    3411. 

  3411.     pushback(c, parser_state);
    3412. 

  3412.     if (tokadd_string(func, term, paren, &quote->nd_nest, parser_state) == -1) {
    3413. 

  3413.         ruby_sourceline = nd_line(quote);
    3414. 

  3414.         rb_compile_error(parser_state, "unterminated string meets end of file");
    3415. 

  3415.         return tSTRING_END;
    3416. 

  3416.     }
    3417. 

  3417. 

  3418.     tokfix();
    3419. 

  3419.     pslval->node = NEW_STR(string_new(tok(), toklen()));
    3420. 

  3420.     nd_set_line(pslval->node, start_line);
    3421. 

  3421.     return tSTRING_CONTENT;
    3422. 

  3422. }
    3423. 

  3423. 

  3424. /* Called when the lexer detects a heredoc is beginning. This pulls
    3425. 

  3425.    in more characters and detects what kind of heredoc it is. */
    3426. 

  3426. static int
    3427. 

  3427. heredoc_identifier(rb_parser_state *parser_state)
    3428. 

  3428. {
    3429. 

  3429.     int c = nextc(), term, func = 0;
    3430. 

  3430.     size_t len;
    3431. 

  3431. 

  3432.     if (c == '-') {
    3433. 

  3433.         c = nextc();
    3434. 

  3434.         func = STR_FUNC_INDENT;
    3435. 

  3435.     }
    3436. 

  3436.     switch (c) {
    3437. 

  3437.       case '\'':
    3438. 

  3438.         func |= str_squote; goto quoted;
    3439. 

  3439.       case '"':
    3440. 

  3440.         func |= str_dquote; goto quoted;
    3441. 

  3441.       case '`':
    3442. 

  3442.         func |= str_xquote;
    3443. 

  3443.       quoted:
    3444. 

  3444.         /* The heredoc indent is quoted, so its easy to find, we just
    3445. 

  3445.            continue to consume characters into the token buffer until
    3446. 

  3446.            we hit the terminating character. */
    3447. 

  3447. 

  3448.         newtok(parser_state);
    3449. 

  3449.         tokadd((char)func, parser_state);
    3450. 

  3450.         term = c;
    3451. 

  3451. 

  3452.         /* Where of where has the term gone.. */
    3453. 

  3453.         while ((c = nextc()) != -1 && c != term) {
    3454. 

  3454.             len = mbclen(c);
    3455. 

  3455.             do {
    3456. 

  3456.               tokadd((char)c, parser_state);
    3457. 

  3457.             } while (--len > 0 && (c = nextc()) != -1);
    3458. 

  3458.         }
    3459. 

  3459.         /* Ack! end of file or end of string. */
    3460. 

  3460.         if (c == -1) {
    3461. 

  3461.             rb_compile_error(parser_state, "unterminated here document identifier");
    3462. 

  3462.             return 0;
    3463. 

  3463.         }
    3464. 

  3464. 

  3465.         break;
    3466. 

  3466. 

  3467.       default:
    3468. 

  3468.         /* Ok, this is an unquoted heredoc ident. We just consume
    3469. 

  3469.            until we hit a non-ident character. */
    3470. 

  3470. 

  3471.         /* Do a quick check that first character is actually valid.
    3472. 

  3472.            if it's not, then this isn't actually a heredoc at all!
    3473. 

  3473.            It sucks that it's way down here in this function that in
    3474. 

  3474.            finally bails with this not being a heredoc.*/
    3475. 

  3475. 

  3476.         if (!is_identchar(c)) {
    3477. 

  3477.             pushback(c, parser_state);
    3478. 

  3478.             if (func & STR_FUNC_INDENT) {
    3479. 

  3479.                 pushback('-', parser_state);
    3480. 

  3480.             }
    3481. 

  3481.             return 0;
    3482. 

  3482.         }
    3483. 

  3483. 

  3484.         /* Finally, setup the token buffer and begin to fill it. */
    3485. 

  3485.         newtok(parser_state);
    3486. 

  3486.         term = '"';
    3487. 

  3487.         tokadd((char)(func |= str_dquote), parser_state);
    3488. 

  3488.         do {
    3489. 

  3489.             len = mbclen(c);
    3490. 

  3490.             do { tokadd((char)c, parser_state); } while (--len > 0 && (c = nextc()) != -1);
    3491. 

  3491.         } while ((c = nextc()) != -1 && is_identchar(c));
    3492. 

  3492.         pushback(c, parser_state);
    3493. 

  3493.         break;
    3494. 

  3494.     }
    3495. 

  3495. 

  3496. 

  3497.     /* Fixup the token buffer, ie set the last character to null. */
    3498. 

  3498.     tokfix();
    3499. 

  3499.     len = lex_p - lex_pbeg;
    3500. 

  3500.     lex_p = lex_pend;
    3501. 

  3501.     pslval->id = 0;
    3502. 

  3502. 

  3503.     /* Tell the lexer that we're inside a string now. nd_lit is
    3504. 

  3504.        the heredoc identifier that we watch the stream for to
    3505. 

  3505.        detect the end of the heredoc. */
    3506. 

  3506.     bstring str = bstrcpy(lex_lastline);
    3507. 

  3507.     lex_strterm = node_newnode(NODE_HEREDOC,
    3508. 

  3508.                                (VALUE)string_new(tok(), toklen()),  /* nd_lit */
    3509. 

  3509.                                (VALUE)len,                          /* nd_nth */
    3510. 

  3510.                                (VALUE)str);                         /* nd_orig */
    3511. 

  3511.     return term == '`' ? tXSTRING_BEG : tSTRING_BEG;
    3512. 

  3512. }
    3513. 

  3513. 

  3514. static void
    3515. 

  3515. heredoc_restore(NODE *here, rb_parser_state *parser_state)
    3516. 

  3516. {
    3517. 

  3517.     bstring line = here->nd_orig;
    3518. 

  3518. 

  3519.     bdestroy(lex_lastline);
    3520. 

  3520. 

  3521.     lex_lastline = line;
    3522. 

  3522.     lex_pbeg = bdata(line);
    3523. 

  3523.     lex_pend = lex_pbeg + blength(line);
    3524. 

  3524.     lex_p = lex_pbeg + here->nd_nth;
    3525. 

  3525.     heredoc_end = ruby_sourceline;
    3526. 

  3526.     ruby_sourceline = nd_line(here);
    3527. 

  3527.     bdestroy((bstring)here->nd_lit);
    3528. 

  3528. }
    3529. 

  3529. 

  3530. static int
    3531. 

  3531. whole_match_p(const char *eos, int len, int indent, rb_parser_state *parser_state)
    3532. 

  3532. {
    3533. 

  3533.     char *p = lex_pbeg;
    3534. 

  3534.     int n;
    3535. 

  3535. 

  3536.     if (indent) {
    3537. 

  3537.         while (*p && ISSPACE(*p)) p++;
    3538. 

  3538.     }
    3539. 

  3539.     n = (int)(lex_pend - (p + len));
    3540. 

  3540.     if (n < 0 || (n > 0 && p[len] != '\n' && p[len] != '\r')) return FALSE;
    3541. 

  3541.     if (strncmp(eos, p, len) == 0) return TRUE;
    3542. 

  3542.     return FALSE;
    3543. 

  3543. }
    3544. 

  3544. 

  3545. /* Called when the lexer knows it's inside a heredoc. This function
    3546. 

  3546.    is responsible for detecting an expandions (ie #{}) in the heredoc
    3547. 

  3547.    and emitting a lex token and also detecting the end of the heredoc. */
    3548. 

  3548. 

  3549. static int
    3550. 

  3550. here_document(NODE *here, rb_parser_state *parser_state)
    3551. 

  3551. {
    3552. 

  3552.     int c, func, indent = 0;
    3553. 

  3553.     char *eos, *p, *pend;
    3554. 

  3554.     long len;
    3555. 

  3555.     bstring str = NULL;
    3556. 

  3556. 

  3557.     /* eos == the heredoc ident that we found when the heredoc started */
    3558. 

  3558.     eos = bdata(here->nd_str);
    3559. 

  3559.     len = blength(here->nd_str) - 1;
    3560. 

  3560. 

  3561.     /* indicates if we should search for expansions. */
    3562. 

  3562.     indent = (func = *eos++) & STR_FUNC_INDENT;
    3563. 

  3563. 

  3564.     /* Ack! EOF or end of input string! */
    3565. 

  3565.     if ((c = nextc()) == -1) {
    3566. 

  3566.       error:
    3567. 

  3567.         rb_compile_error(parser_state, "can't find string \"%s\" anywhere before EOF", eos);
    3568. 

  3568.         heredoc_restore(lex_strterm, parser_state);
    3569. 

  3569.         lex_strterm = 0;
    3570. 

  3570.         return 0;
    3571. 

  3571.     }
    3572. 

  3572.     /* Gr. not yet sure what was_bol() means other than it seems like
    3573. 

  3573.        it means only 1 character has been consumed. */
    3574. 

  3574. 

  3575.     if (was_bol() && whole_match_p(eos, (int)len, indent, parser_state)) {
    3576. 

  3576.         heredoc_restore(lex_strterm, parser_state);
    3577. 

  3577.         return tSTRING_END;
    3578. 

  3578.     }
    3579. 

  3579. 

  3580.     /* If aren't doing expansions, we can just scan until
    3581. 

  3581.        we find the identifier. */
    3582. 

  3582. 

  3583.     if ((func & STR_FUNC_EXPAND) == 0) {
    3584. 

  3584.         do {
    3585. 

  3585.             p = bdata(lex_lastline);
    3586. 

  3586.             pend = lex_pend;
    3587. 

  3587.             if (pend > p) {
    3588. 

  3588.                 switch (pend[-1]) {
    3589. 

  3589.                   case '\n':
    3590. 

  3590.                     if (--pend == p || pend[-1] != '\r') {
    3591. 

  3591.                         pend++;
    3592. 

  3592.                         break;
    3593. 

  3593.                     }
    3594. 

  3594.                   case '\r':
    3595. 

  3595.                     --pend;
    3596. 

  3596.                 }
    3597. 

  3597.             }
    3598. 

  3598.             if (str) {
    3599. 

  3599.                 bcatblk(str, p, (int)(pend - p));
    3600. 

  3600.             } else {
    3601. 

  3601.                 str = blk2bstr(p, (int)(pend - p));
    3602. 

  3602.             }
    3603. 

  3603.             if (pend < lex_pend) bcatblk(str, "\n", 1);
    3604. 

  3604.             lex_p = lex_pend;
    3605. 

  3605.             if (nextc() == -1) {
    3606. 

  3606.                 if (str) bdestroy(str);
    3607. 

  3607.                 goto error;
    3608. 

  3608.             }
    3609. 

  3609.         } while (!whole_match_p(eos, (int)len, indent, parser_state));
    3610. 

  3610.     }
    3611. 

  3611.     else {
    3612. 

  3612.         newtok(parser_state);
    3613. 

  3613.         if (c == '#') {
    3614. 

  3614.             switch (c = nextc()) {
    3615. 

  3615.               case '$':
    3616. 

  3616.               case '@':
    3617. 

  3617.                 pushback(c, parser_state);
    3618. 

  3618.                 return tSTRING_DVAR;
    3619. 

  3619.               case '{':
    3620. 

  3620.                 return tSTRING_DBEG;
    3621. 

  3621.             }
    3622. 

  3622.             tokadd('#', parser_state);
    3623. 

  3623.         }
    3624. 

  3624. 

  3625.         /* Loop while we haven't found a the heredoc ident. */
    3626. 

  3626.         do {
    3627. 

  3627.             pushback(c, parser_state);
    3628. 

  3628.             /* Scan up until a \n and fill in the token buffer. */
    3629. 

  3629.             if ((c = tokadd_string(func, '\n', 0, NULL, parser_state)) == -1) goto error;
    3630. 

  3630. 

  3631.             /* We finished scanning, but didn't find a \n, so we setup the node
    3632. 

  3632.                and have the lexer file in more. */
    3633. 

  3633.             if (c != '\n') {
    3634. 

  3634.                 pslval->node = NEW_STR(string_new(tok(), toklen()));
    3635. 

  3635.                 return tSTRING_CONTENT;
    3636. 

  3636.             }
    3637. 

  3637. 

  3638.             /* I think this consumes the \n */
    3639. 

  3639.             tokadd((char)nextc(), parser_state);
    3640. 

  3640.             if ((c = nextc()) == -1) goto error;
    3641. 

  3641.         } while (!whole_match_p(eos, (int)len, indent, parser_state));
    3642. 

  3642.         str = string_new(tok(), toklen());
    3643. 

  3643.     }
    3644. 

  3644.     heredoc_restore(lex_strterm, parser_state);
    3645. 

  3645.     lex_strterm = NEW_STRTERM(-1, 0, 0);
    3646. 

  3646.     pslval->node = NEW_STR(str);
    3647. 

  3647.     return tSTRING_CONTENT;
    3648. 

  3648. }
    3649. 

  3649. 

  3650. #include "lex.c.tab"
    3651. 

  3651. 

  3652. static void
    3653. 

  3653. arg_ambiguous()
    3654. 

  3654. {
    3655. 

  3655.     rb_warning("ambiguous first argument; put parentheses or even spaces");
    3656. 

  3656. }
    3657. 

  3657. 

  3658. #define IS_ARG() (lex_state == EXPR_ARG || lex_state == EXPR_CMDARG)
    3659. 

  3659. 

  3660. 

  3661. static char* parse_comment(struct rb_parser_state* parser_state) {
    3662. 

  3662.   int len = (int)(lex_pend - lex_p);
    3663. 

  3663. 

  3664.   char* str = lex_p;
    3665. 

  3665.   while(len-- > 0 && ISSPACE(str[0])) str++;
    3666. 

  3666.   if(len <= 2) return NULL;
    3667. 

  3667. 

  3668.   if(str[0] == '-' && str[1] == '*' && str[2] == '-') return str;
    3669. 

  3669. 

  3670.   return NULL;
    3671. 

  3671. }
    3672. 

  3672. 

  3673. static int
    3674. 

  3674. yylex(void *yylval_v, void *vstate)
    3675. 

  3675. {
    3676. 

  3676.     register int c;
    3677. 

  3677.     int space_seen = 0;
    3678. 

  3678.     int cmd_state;
    3679. 

  3679.     struct rb_parser_state *parser_state;
    3680. 

  3680.     bstring cur_line;
    3681. 

  3681.     enum lex_state_e last_state;
    3682. 

  3682. 

  3683.     YYSTYPE *yylval = (YYSTYPE*)yylval_v;
    3684. 

  3684.     parser_state = (struct rb_parser_state*)vstate;
    3685. 

  3685. 

  3686.     lval = (void *)yylval;
    3687. 

  3687. 

  3688.     /*
    3689. 

  3689.     c = nextc();
    3690. 

  3690.     printf("lex char: %c\n", c);
    3691. 

  3691.     pushback(c, parser_state);
    3692. 

  3692.     */
    3693. 

  3693. 

  3694.     if (lex_strterm) {
    3695. 

  3695.         int token;
    3696. 

  3696.         if (nd_type(lex_strterm) == NODE_HEREDOC) {
    3697. 

  3697.             token = here_document(lex_strterm, parser_state);
    3698. 

  3698.             if (token == tSTRING_END) {
    3699. 

  3699.                 lex_strterm = 0;
    3700. 

  3700.                 lex_state = EXPR_END;
    3701. 

  3701.             }
    3702. 

  3702.         }
    3703. 

  3703.         else {
    3704. 

  3704.             token = parse_string(lex_strterm, parser_state);
    3705. 

  3705.             if (token == tSTRING_END || token == tREGEXP_END) {
    3706. 

  3706.                 lex_strterm = 0;
    3707. 

  3707.                 lex_state = EXPR_END;
    3708. 

  3708.             }
    3709. 

  3709.         }
    3710. 

  3710.         return token;
    3711. 

  3711.     }
    3712. 

  3712. 

  3713.     cmd_state = command_start;
    3714. 

  3714.     command_start = FALSE;
    3715. 

  3715.   retry:
    3716. 

  3716.     switch (c = nextc()) {
    3717. 

  3717.       case '\0':                /* NUL */
    3718. 

  3718.       case '\004':              /* ^D */
    3719. 

  3719.       case '\032':              /* ^Z */
    3720. 

  3720.       case -1:                  /* end of script. */
    3721. 

  3721.         return 0;
    3722. 

  3722. 

  3723.         /* white spaces */
    3724. 

  3724.       case ' ': case '\t': case '\f': case '\r':
    3725. 

  3725.       case '\13': /* '\v' */
    3726. 

  3726.         space_seen++;
    3727. 

  3727.         goto retry;
    3728. 

  3728. 

  3729.       case '#':         /* it's a comment */
    3730. 

  3730.         if(char* str = parse_comment(parser_state)) {
    3731. 

  3731.             int len = (int)(lex_pend - str - 1); // - 1 for the \n
    3732. 

  3732.             cur_line = blk2bstr(str, len);
    3733. 

  3733.             magic_comments->push_back(cur_line);
    3734. 

  3734.         }
    3735. 

  3735.         lex_p = lex_pend;
    3736. 

  3736.         /* fall through */
    3737. 

  3737.       case '\n':
    3738. 

  3738.         switch (lex_state) {
    3739. 

  3739.           case EXPR_BEG:
    3740. 

  3740.           case EXPR_FNAME:
    3741. 

  3741.           case EXPR_DOT:
    3742. 

  3742.           case EXPR_CLASS:
    3743. 

  3743.             goto retry;
    3744. 

  3744.           default:
    3745. 

  3745.             break;
    3746. 

  3746.         }
    3747. 

  3747.         command_start = TRUE;
    3748. 

  3748.         lex_state = EXPR_BEG;
    3749. 

  3749.         return '\n';
    3750. 

  3750. 

  3751.       case '*':
    3752. 

  3752.         if ((c = nextc()) == '*') {
    3753. 

  3753.             if ((c = nextc()) == '=') {
    3754. 

  3754.                 pslval->id = tPOW;
    3755. 

  3755.                 lex_state = EXPR_BEG;
    3756. 

  3756.                 return tOP_ASGN;
    3757. 

  3757.             }
    3758. 

  3758.             pushback(c, parser_state);
    3759. 

  3759.             c = tPOW;
    3760. 

  3760.         }
    3761. 

  3761.         else {
    3762. 

  3762.             if (c == '=') {
    3763. 

  3763.                 pslval->id = '*';
    3764. 

  3764.                 lex_state = EXPR_BEG;
    3765. 

  3765.                 return tOP_ASGN;
    3766. 

  3766.             }
    3767. 

  3767.             pushback(c, parser_state);
    3768. 

  3768.             if (IS_ARG() && space_seen && !ISSPACE(c)){
    3769. 

  3769.                 rb_warning("`*' interpreted as argument prefix");
    3770. 

  3770.                 c = tSTAR;
    3771. 

  3771.             }
    3772. 

  3772.             else if (lex_state == EXPR_BEG || lex_state == EXPR_MID) {
    3773. 

  3773.                 c = tSTAR;
    3774. 

  3774.             }
    3775. 

  3775.             else {
    3776. 

  3776.                 c = '*';
    3777. 

  3777.             }
    3778. 

  3778.         }
    3779. 

  3779.         switch (lex_state) {
    3780. 

  3780.           case EXPR_FNAME: case EXPR_DOT:
    3781. 

  3781.             lex_state = EXPR_ARG; break;
    3782. 

  3782.           default:
    3783. 

  3783.             lex_state = EXPR_BEG; break;
    3784. 

  3784.         }
    3785. 

  3785.         return c;
    3786. 

  3786. 

  3787.       case '!':
    3788. 

  3788.         lex_state = EXPR_BEG;
    3789. 

  3789.         if ((c = nextc()) == '=') {
    3790. 

  3790.             return tNEQ;
    3791. 

  3791.         }
    3792. 

  3792.         if (c == '~') {
    3793. 

  3793.             return tNMATCH;
    3794. 

  3794.         }
    3795. 

  3795.         pushback(c, parser_state);
    3796. 

  3796.         return '!';
    3797. 

  3797. 

  3798.       case '=':
    3799. 

  3799.         if (was_bol()) {
    3800. 

  3800.             /* skip embedded rd document */
    3801. 

  3801.             if (strncmp(lex_p, "begin", 5) == 0 && ISSPACE(lex_p[5])) {
    3802. 

  3802.                 for (;;) {
    3803. 

  3803.                     lex_p = lex_pend;
    3804. 

  3804.                     c = nextc();
    3805. 

  3805.                     if (c == -1) {
    3806. 

  3806.                         rb_compile_error(parser_state, "embedded document meets end of file");
    3807. 

  3807.                         return 0;
    3808. 

  3808.                     }
    3809. 

  3809.                     if (c != '=') continue;
    3810. 

  3810.                     if (strncmp(lex_p, "end", 3) == 0 &&
    3811. 

  3811.                         (lex_p + 3 == lex_pend || ISSPACE(lex_p[3]))) {
    3812. 

  3812.                         break;
    3813. 

  3813.                     }
    3814. 

  3814.                 }
    3815. 

  3815.                 lex_p = lex_pend;
    3816. 

  3816.                 goto retry;
    3817. 

  3817.             }
    3818. 

  3818.         }
    3819. 

  3819. 

  3820.         switch (lex_state) {
    3821. 

  3821.           case EXPR_FNAME: case EXPR_DOT:
    3822. 

  3822.             lex_state = EXPR_ARG; break;
    3823. 

  3823.           default:
    3824. 

  3824.             lex_state = EXPR_BEG; break;
    3825. 

  3825.         }
    3826. 

  3826.         if ((c = nextc()) == '=') {
    3827. 

  3827.             if ((c = nextc()) == '=') {
    3828. 

  3828.                 return tEQQ;
    3829. 

  3829.             }
    3830. 

  3830.             pushback(c, parser_state);
    3831. 

  3831.             return tEQ;
    3832. 

  3832.         }
    3833. 

  3833.         if (c == '~') {
    3834. 

  3834.             return tMATCH;
    3835. 

  3835.         }
    3836. 

  3836.         else if (c == '>') {
    3837. 

  3837.             return tASSOC;
    3838. 

  3838.         }
    3839. 

  3839.         pushback(c, parser_state);
    3840. 

  3840.         return '=';
    3841. 

  3841. 

  3842.       case '<':
    3843. 

  3843.         c = nextc();
    3844. 

  3844.         if (c == '<' &&
    3845. 

  3845.             lex_state != EXPR_END &&
    3846. 

  3846.             lex_state != EXPR_DOT &&
    3847. 

  3847.             lex_state != EXPR_ENDARG &&
    3848. 

  3848.             lex_state != EXPR_CLASS &&
    3849. 

  3849.             (!IS_ARG() || space_seen)) {
    3850. 

  3850.             int token = heredoc_identifier(parser_state);
    3851. 

  3851.             if (token) return token;
    3852. 

  3852.         }
    3853. 

  3853.         switch (lex_state) {
    3854. 

  3854.           case EXPR_FNAME: case EXPR_DOT:
    3855. 

  3855.             lex_state = EXPR_ARG; break;
    3856. 

  3856.           default:
    3857. 

  3857.             lex_state = EXPR_BEG; break;
    3858. 

  3858.         }
    3859. 

  3859.         if (c == '=') {
    3860. 

  3860.             if ((c = nextc()) == '>') {
    3861. 

  3861.                 return tCMP;
    3862. 

  3862.             }
    3863. 

  3863.             pushback(c, parser_state);
    3864. 

  3864.             return tLEQ;
    3865. 

  3865.         }
    3866. 

  3866.         if (c == '<') {
    3867. 

  3867.             if ((c = nextc()) == '=') {
    3868. 

  3868.                 pslval->id = tLSHFT;
    3869. 

  3869.                 lex_state = EXPR_BEG;
    3870. 

  3870.                 return tOP_ASGN;
    3871. 

  3871.             }
    3872. 

  3872.             pushback(c, parser_state);
    3873. 

  3873.             return tLSHFT;
    3874. 

  3874.         }
    3875. 

  3875.         pushback(c, parser_state);
    3876. 

  3876.         return '<';
    3877. 

  3877. 

  3878.       case '>':
    3879. 

  3879.         switch (lex_state) {
    3880. 

  3880.           case EXPR_FNAME: case EXPR_DOT:
    3881. 

  3881.             lex_state = EXPR_ARG; break;
    3882. 

  3882.           default:
    3883. 

  3883.             lex_state = EXPR_BEG; break;
    3884. 

  3884.         }
    3885. 

  3885.         if ((c = nextc()) == '=') {
    3886. 

  3886.             return tGEQ;
    3887. 

  3887.         }
    3888. 

  3888.         if (c == '>') {
    3889. 

  3889.             if ((c = nextc()) == '=') {
    3890. 

  3890.                 pslval->id = tRSHFT;
    3891. 

  3891.                 lex_state = EXPR_BEG;
    3892. 

  3892.                 return tOP_ASGN;
    3893. 

  3893.             }
    3894. 

  3894.             pushback(c, parser_state);
    3895. 

  3895.             return tRSHFT;
    3896. 

  3896.         }
    3897. 

  3897.         pushback(c, parser_state);
    3898. 

  3898.         return '>';
    3899. 

  3899. 

  3900.       case '"':
    3901. 

  3901.         lex_strterm = NEW_STRTERM(str_dquote, '"', 0);
    3902. 

  3902.         return tSTRING_BEG;
    3903. 

  3903. 

  3904.       case '`':
    3905. 

  3905.         if (lex_state == EXPR_FNAME) {
    3906. 

  3906.             lex_state = EXPR_END;
    3907. 

  3907.             return c;
    3908. 

  3908.         }
    3909. 

  3909.         if (lex_state == EXPR_DOT) {
    3910. 

  3910.             if (cmd_state)
    3911. 

  3911.                 lex_state = EXPR_CMDARG;
    3912. 

  3912.             else
    3913. 

  3913.                 lex_state = EXPR_ARG;
    3914. 

  3914.             return c;
    3915. 

  3915.         }
    3916. 

  3916.         lex_strterm = NEW_STRTERM(str_xquote, '`', 0);
    3917. 

  3917.         pslval->id = 0; /* so that xstring gets used normally */
    3918. 

  3918.         return tXSTRING_BEG;
    3919. 

  3919. 

  3920.       case '\'':
    3921. 

  3921.         lex_strterm = NEW_STRTERM(str_squote, '\'', 0);
    3922. 

  3922.         pslval->id = 0; /* so that xstring gets used normally */
    3923. 

  3923.         return tSTRING_BEG;
    3924. 

  3924. 

  3925.       case '?':
    3926. 

  3926.         if (lex_state == EXPR_END || lex_state == EXPR_ENDARG) {
    3927. 

  3927.             lex_state = EXPR_BEG;
    3928. 

  3928.             return '?';
    3929. 

  3929.         }
    3930. 

  3930.         c = nextc();
    3931. 

  3931.         if (c == -1) {
    3932. 

  3932.             rb_compile_error(parser_state, "incomplete character syntax");
    3933. 

  3933.             return 0;
    3934. 

  3934.         }
    3935. 

  3935.         if (ISSPACE(c)){
    3936. 

  3936.             if (!IS_ARG()){
    3937. 

  3937.                 int c2 = 0;
    3938. 

  3938.                 switch (c) {
    3939. 

  3939.                   case ' ':
    3940. 

  3940.                     c2 = 's';
    3941. 

  3941.                     break;
    3942. 

  3942.                   case '\n':
    3943. 

  3943.                     c2 = 'n';
    3944. 

  3944.                     break;
    3945. 

  3945.                   case '\t':
    3946. 

  3946.                     c2 = 't';
    3947. 

  3947.                     break;
    3948. 

  3948.                   case '\v':
    3949. 

  3949.                     c2 = 'v';
    3950. 

  3950.                     break;
    3951. 

  3951.                   case '\r':
    3952. 

  3952.                     c2 = 'r';
    3953. 

  3953.                     break;
    3954. 

  3954.                   case '\f':
    3955. 

  3955.                     c2 = 'f';
    3956. 

  3956.                     break;
    3957. 

  3957.                 }
    3958. 

  3958.                 if (c2) {
    3959. 

  3959.                     rb_warn("invalid character syntax; use ?\\%c", c2);
    3960. 

  3960.                 }
    3961. 

  3961.             }
    3962. 

  3962.           ternary:
    3963. 

  3963.             pushback(c, parser_state);
    3964. 

  3964.             lex_state = EXPR_BEG;
    3965. 

  3965.             ternary_colon = 1;
    3966. 

  3966.             return '?';
    3967. 

  3967.         }
    3968. 

  3968.         else if (ismbchar(c)) {
    3969. 

  3969.             rb_warn("multibyte character literal not supported yet; use ?\\%.3o", c);
    3970. 

  3970.             goto ternary;
    3971. 

  3971.         }
    3972. 

  3972.         else if ((ISALNUM(c) || c == '_') && lex_p < lex_pend && is_identchar(*(lex_p))) {
    3973. 

  3973.             goto ternary;
    3974. 

  3974.         }
    3975. 

  3975.         else if (c == '\\') {
    3976. 

  3976.             c = read_escape(parser_state);
    3977. 

  3977.         }
    3978. 

  3978.         c &= 0xff;
    3979. 

  3979.         lex_state = EXPR_END;
    3980. 

  3980.         pslval->node = NEW_FIXNUM((intptr_t)c);
    3981. 

  3981.         return tINTEGER;
    3982. 

  3982. 

  3983.       case '&':
    3984. 

  3984.         if ((c = nextc()) == '&') {
    3985. 

  3985.             lex_state = EXPR_BEG;
    3986. 

  3986.             if ((c = nextc()) == '=') {
    3987. 

  3987.                 pslval->id = tANDOP;
    3988. 

  3988.                 lex_state = EXPR_BEG;
    3989. 

  3989.                 return tOP_ASGN;
    3990. 

  3990.             }
    3991. 

  3991.             pushback(c, parser_state);
    3992. 

  3992.             return tANDOP;
    3993. 

  3993.         }
    3994. 

  3994.         else if (c == '=') {
    3995. 

  3995.             pslval->id = '&';
    3996. 

  3996.             lex_state = EXPR_BEG;
    3997. 

  3997.             return tOP_ASGN;
    3998. 

  3998.         }
    3999. 

  3999.         pushback(c, parser_state);
    4000. 

  4000.         if (IS_ARG() && space_seen && !ISSPACE(c)){
    4001. 

  4001.             rb_warning("`&' interpreted as argument prefix");
    4002. 

  4002.             c = tAMPER;
    4003. 

  4003.         }
    4004. 

  4004.         else if (lex_state == EXPR_BEG || lex_state == EXPR_MID) {
    4005. 

  4005.             c = tAMPER;
    4006. 

  4006.         }
    4007. 

  4007.         else {
    4008. 

  4008.             c = '&';
    4009. 

  4009.         }
    4010. 

  4010.         switch (lex_state) {
    4011. 

  4011.           case EXPR_FNAME: case EXPR_DOT:
    4012. 

  4012.             lex_state = EXPR_ARG; break;
    4013. 

  4013.           default:
    4014. 

  4014.             lex_state = EXPR_BEG;
    4015. 

  4015.         }
    4016. 

  4016.         return c;
    4017. 

  4017. 

  4018.       case '|':
    4019. 

  4019.         if ((c = nextc()) == '|') {
    4020. 

  4020.             lex_state = EXPR_BEG;
    4021. 

  4021.             if ((c = nextc()) == '=') {
    4022. 

  4022.                 pslval->id = tOROP;
    4023. 

  4023.                 lex_state = EXPR_BEG;
    4024. 

  4024.                 return tOP_ASGN;
    4025. 

  4025.             }
    4026. 

  4026.             pushback(c, parser_state);
    4027. 

  4027.             return tOROP;
    4028. 

  4028.         }
    4029. 

  4029.         if (c == '=') {
    4030. 

  4030.             pslval->id = '|';
    4031. 

  4031.             lex_state = EXPR_BEG;
    4032. 

  4032.             return tOP_ASGN;
    4033. 

  4033.         }
    4034. 

  4034.         if (lex_state == EXPR_FNAME || lex_state == EXPR_DOT) {
    4035. 

  4035.             lex_state = EXPR_ARG;
    4036. 

  4036.         }
    4037. 

  4037.         else {
    4038. 

  4038.             lex_state = EXPR_BEG;
    4039. 

  4039.         }
    4040. 

  4040.         pushback(c, parser_state);
    4041. 

  4041.         return '|';
    4042. 

  4042. 

  4043.       case '+':
    4044. 

  4044.         c = nextc();
    4045. 

  4045.         if (lex_state == EXPR_FNAME || lex_state == EXPR_DOT) {
    4046. 

  4046.             lex_state = EXPR_ARG;
    4047. 

  4047.             if (c == '@') {
    4048. 

  4048.                 return tUPLUS;
    4049. 

  4049.             }
    4050. 

  4050.             pushback(c, parser_state);
    4051. 

  4051.             return '+';
    4052. 

  4052.         }
    4053. 

  4053.         if (c == '=') {
    4054. 

  4054.             pslval->id = '+';
    4055. 

  4055.             lex_state = EXPR_BEG;
    4056. 

  4056.             return tOP_ASGN;
    4057. 

  4057.         }
    4058. 

  4058.         if (lex_state == EXPR_BEG || lex_state == EXPR_MID ||
    4059. 

  4059.             (IS_ARG() && space_seen && !ISSPACE(c))) {
    4060. 

  4060.             if (IS_ARG()) arg_ambiguous();
    4061. 

  4061.             lex_state = EXPR_BEG;
    4062. 

  4062.             pushback(c, parser_state);
    4063. 

  4063.             if (ISDIGIT(c)) {
    4064. 

  4064.                 c = '+';
    4065. 

  4065.                 goto start_num;
    4066. 

  4066.             }
    4067. 

  4067.             return tUPLUS;
    4068. 

  4068.         }
    4069. 

  4069.         lex_state = EXPR_BEG;
    4070. 

  4070.         pushback(c, parser_state);
    4071. 

  4071.         return '+';
    4072. 

  4072. 

  4073.       case '-':
    4074. 

  4074.         c = nextc();
    4075. 

  4075.         if (lex_state == EXPR_FNAME || lex_state == EXPR_DOT) {
    4076. 

  4076.             lex_state = EXPR_ARG;
    4077. 

  4077.             if (c == '@') {
    4078. 

  4078.                 return tUMINUS;
    4079. 

  4079.             }
    4080. 

  4080.             pushback(c, parser_state);
    4081. 

  4081.             return '-';
    4082. 

  4082.         }
    4083. 

  4083.         if (c == '=') {
    4084. 

  4084.             pslval->id = '-';
    4085. 

  4085.             lex_state = EXPR_BEG;
    4086. 

  4086.             return tOP_ASGN;
    4087. 

  4087.         }
    4088. 

  4088.         if (lex_state == EXPR_BEG || lex_state == EXPR_MID ||
    4089. 

  4089.             (IS_ARG() && space_seen && !ISSPACE(c))) {
    4090. 

  4090.             if (IS_ARG()) arg_ambiguous();
    4091. 

  4091.             lex_state = EXPR_BEG;
    4092. 

  4092.             pushback(c, parser_state);
    4093. 

  4093.             if (ISDIGIT(c)) {
    4094. 

  4094.                 return tUMINUS_NUM;
    4095. 

  4095.             }
    4096. 

  4096.             return tUMINUS;
    4097. 

  4097.         }
    4098. 

  4098.         lex_state = EXPR_BEG;
    4099. 

  4099.         pushback(c, parser_state);
    4100. 

  4100.         return '-';
    4101. 

  4101. 

  4102.       case '.':
    4103. 

  4103.         lex_state = EXPR_BEG;
    4104. 

  4104.         if ((c = nextc()) == '.') {
    4105. 

  4105.             if ((c = nextc()) == '.') {
    4106. 

  4106.                 return tDOT3;
    4107. 

  4107.             }
    4108. 

  4108.             pushback(c, parser_state);
    4109. 

  4109.             return tDOT2;
    4110. 

  4110.         }
    4111. 

  4111.         pushback(c, parser_state);
    4112. 

  4112.         if (ISDIGIT(c)) {
    4113. 

  4113.             yyerror("no .<digit> floating literal anymore; put 0 before dot");
    4114. 

  4114.         }
    4115. 

  4115.         lex_state = EXPR_DOT;
    4116. 

  4116.         return '.';
    4117. 

  4117. 

  4118.       start_num:
    4119. 

  4119.       case '0': case '1': case '2': case '3': case '4':
    4120. 

  4120.       case '5': case '6': case '7': case '8': case '9':
    4121. 

  4121.         {
    4122. 

  4122.             int is_float, seen_point, seen_e, nondigit;
    4123. 

  4123. 

  4124.             is_float = seen_point = seen_e = nondigit = 0;
    4125. 

  4125.             lex_state = EXPR_END;
    4126. 

  4126.             newtok(parser_state);
    4127. 

  4127.             if (c == '-' || c == '+') {
    4128. 

  4128.                 tokadd((char)c,parser_state);
    4129. 

  4129.                 c = nextc();
    4130. 

  4130.             }
    4131. 

  4131.             if (c == '0') {
    4132. 

  4132.                 int start = toklen();
    4133. 

  4133.                 c = nextc();
    4134. 

  4134.                 if (c == 'x' || c == 'X') {
    4135. 

  4135.                     /* hexadecimal */
    4136. 

  4136.                     c = nextc();
    4137. 

  4137.                     if (ISXDIGIT(c)) {
    4138. 

  4138.                         do {
    4139. 

  4139.                             if (c == '_') {
    4140. 

  4140.                                 if (nondigit) break;
    4141. 

  4141.                                 nondigit = c;
    4142. 

  4142.                                 continue;
    4143. 

  4143.                             }
    4144. 

  4144.                             if (!ISXDIGIT(c)) break;
    4145. 

  4145.                             nondigit = 0;
    4146. 

  4146.                             tokadd((char)c,parser_state);
    4147. 

  4147.                         } while ((c = nextc()) != -1);
    4148. 

  4148.                     }
    4149. 

  4149.                     pushback(c, parser_state);
    4150. 

  4150.                     tokfix();
    4151. 

  4151.                     if (toklen() == start) {
    4152. 

  4152.                         yyerror("numeric literal without digits");
    4153. 

  4153.                     }
    4154. 

  4154.                     else if (nondigit) goto trailing_uc;
    4155. 

  4155.                     pslval->node = NEW_HEXNUM(string_new2(tok()));
    4156. 

  4156.                     return tINTEGER;
    4157. 

  4157.                 }
    4158. 

  4158.                 if (c == 'b' || c == 'B') {
    4159. 

  4159.                     /* binary */
    4160. 

  4160.                     c = nextc();
    4161. 

  4161.                     if (c == '0' || c == '1') {
    4162. 

  4162.                         do {
    4163. 

  4163.                             if (c == '_') {
    4164. 

  4164.                                 if (nondigit) break;
    4165. 

  4165.                                 nondigit = c;
    4166. 

  4166.                                 continue;
    4167. 

  4167.                             }
    4168. 

  4168.                             if (c != '0' && c != '1') break;
    4169. 

  4169.                             nondigit = 0;
    4170. 

  4170.                             tokadd((char)c, parser_state);
    4171. 

  4171.                         } while ((c = nextc()) != -1);
    4172. 

  4172.                     }
    4173. 

  4173.                     pushback(c, parser_state);
    4174. 

  4174.                     tokfix();
    4175. 

  4175.                     if (toklen() == start) {
    4176. 

  4176.                         yyerror("numeric literal without digits");
    4177. 

  4177.                     }
    4178. 

  4178.                     else if (nondigit) goto trailing_uc;
    4179. 

  4179.                     pslval->node = NEW_BINNUM(string_new2(tok()));
    4180. 

  4180.                     return tINTEGER;
    4181. 

  4181.                 }
    4182. 

  4182.                 if (c == 'd' || c == 'D') {
    4183. 

  4183.                     /* decimal */
    4184. 

  4184.                     c = nextc();
    4185. 

  4185.                     if (ISDIGIT(c)) {
    4186. 

  4186.                         do {
    4187. 

  4187.                             if (c == '_') {
    4188. 

  4188.                                 if (nondigit) break;
    4189. 

  4189.                                 nondigit = c;
    4190. 

  4190.                                 continue;
    4191. 

  4191.                             }
    4192. 

  4192.                             if (!ISDIGIT(c)) break;
    4193. 

  4193.                             nondigit = 0;
    4194. 

  4194.                             tokadd((char)c, parser_state);
    4195. 

  4195.                         } while ((c = nextc()) != -1);
    4196. 

  4196.                     }
    4197. 

  4197.                     pushback(c, parser_state);
    4198. 

  4198.                     tokfix();
    4199. 

  4199.                     if (toklen() == start) {
    4200. 

  4200.                         yyerror("numeric literal without digits");
    4201. 

  4201.                     }
    4202. 

  4202.                     else if (nondigit) goto trailing_uc;
    4203. 

  4203.                     pslval->node = NEW_NUMBER(string_new2(tok()));
    4204. 

  4204.                     return tINTEGER;
    4205. 

  4205.                 }
    4206. 

  4206.                 if (c == '_') {
    4207. 

  4207.                     /* 0_0 */
    4208. 

  4208.                     goto octal_number;
    4209. 

  4209.                 }
    4210. 

  4210.                 if (c == 'o' || c == 'O') {
    4211. 

  4211.                     /* prefixed octal */
    4212. 

  4212.                     c = nextc();
    4213. 

  4213.                     if (c == '_') {
    4214. 

  4214.                         yyerror("numeric literal without digits");
    4215. 

  4215.                     }
    4216. 

  4216.                 }
    4217. 

  4217.                 if (c >= '0' && c <= '7') {
    4218. 

  4218.                     /* octal */
    4219. 

  4219.                   octal_number:
    4220. 

  4220.                     do {
    4221. 

  4221.                         if (c == '_') {
    4222. 

  4222.                             if (nondigit) break;
    4223. 

  4223.                             nondigit = c;
    4224. 

  4224.                             continue;
    4225. 

  4225.                         }
    4226. 

  4226.                         if (c < '0' || c > '7') break;
    4227. 

  4227.                         nondigit = 0;
    4228. 

  4228.                         tokadd((char)c, parser_state);
    4229. 

  4229.                     } while ((c = nextc()) != -1);
    4230. 

  4230.                     if (toklen() > start) {
    4231. 

  4231.                         pushback(c, parser_state);
    4232. 

  4232.                         tokfix();
    4233. 

  4233.                         if (nondigit) goto trailing_uc;
    4234. 

  4234.                         pslval->node = NEW_OCTNUM(string_new2(tok()));
    4235. 

  4235.                         return tINTEGER;
    4236. 

  4236.                     }
    4237. 

  4237.                     if (nondigit) {
    4238. 

  4238.                         pushback(c, parser_state);
    4239. 

  4239.                         goto trailing_uc;
    4240. 

  4240.                     }
    4241. 

  4241.                 }
    4242. 

  4242.                 if (c > '7' && c <= '9') {
    4243. 

  4243.                     yyerror("Illegal octal digit");
    4244. 

  4244.                 }
    4245. 

  4245.                 else if (c == '.' || c == 'e' || c == 'E') {
    4246. 

  4246.                     tokadd('0', parser_state);
    4247. 

  4247.                 }
    4248. 

  4248.                 else {
    4249. 

  4249.                     pushback(c, parser_state);
    4250. 

  4250.                     pslval->node = NEW_FIXNUM(0);
    4251. 

  4251.                     return tINTEGER;
    4252. 

  4252.                 }
    4253. 

  4253.             }
    4254. 

  4254. 

  4255.             for (;;) {
    4256. 

  4256.                 switch (c) {
    4257. 

  4257.                   case '0': case '1': case '2': case '3': case '4':
    4258. 

  4258.                   case '5': case '6': case '7': case '8': case '9':
    4259. 

  4259.                     nondigit = 0;
    4260. 

  4260.                     tokadd((char)c, parser_state);
    4261. 

  4261.                     break;
    4262. 

  4262. 

  4263.                   case '.':
    4264. 

  4264.                     if (nondigit) goto trailing_uc;
    4265. 

  4265.                     if (seen_point || seen_e) {
    4266. 

  4266.                         goto decode_num;
    4267. 

  4267.                     }
    4268. 

  4268.                     else {
    4269. 

  4269.                         int c0 = nextc();
    4270. 

  4270.                         if (!ISDIGIT(c0)) {
    4271. 

  4271.                             pushback(c0, parser_state);
    4272. 

  4272.                             goto decode_num;
    4273. 

  4273.                         }
    4274. 

  4274.                         c = c0;
    4275. 

  4275.                     }
    4276. 

  4276.                     tokadd('.', parser_state);
    4277. 

  4277.                     tokadd((char)c, parser_state);
    4278. 

  4278.                     is_float++;
    4279. 

  4279.                     seen_point++;
    4280. 

  4280.                     nondigit = 0;
    4281. 

  4281.                     break;
    4282. 

  4282. 

  4283.                   case 'e':
    4284. 

  4284.                   case 'E':
    4285. 

  4285.                     if (nondigit) {
    4286. 

  4286.                         pushback(c, parser_state);
    4287. 

  4287.                         c = nondigit;
    4288. 

  4288.                         goto decode_num;
    4289. 

  4289.                     }
    4290. 

  4290.                     if (seen_e) {
    4291. 

  4291.                         goto decode_num;
    4292. 

  4292.                     }
    4293. 

  4293.                     tokadd((char)c, parser_state);
    4294. 

  4294.                     seen_e++;
    4295. 

  4295.                     is_float++;
    4296. 

  4296.                     nondigit = c;
    4297. 

  4297.                     c = nextc();
    4298. 

  4298.                     if (c != '-' && c != '+') continue;
    4299. 

  4299.                     tokadd((char)c, parser_state);
    4300. 

  4300.                     nondigit = c;
    4301. 

  4301.                     break;
    4302. 

  4302. 

  4303.                   case '_':     /* `_' in number just ignored */
    4304. 

  4304.                     if (nondigit) goto decode_num;
    4305. 

  4305.                     nondigit = c;
    4306. 

  4306.                     break;
    4307. 

  4307. 

  4308.                   default:
    4309. 

  4309.                     goto decode_num;
    4310. 

  4310.                 }
    4311. 

  4311.                 c = nextc();
    4312. 

  4312.             }
    4313. 

  4313. 

  4314.           decode_num:
    4315. 

  4315.             pushback(c, parser_state);
    4316. 

  4316.             tokfix();
    4317. 

  4317.             if (nondigit) {
    4318. 

  4318.                 char tmp[30];
    4319. 

  4319.               trailing_uc:
    4320. 

  4320.                 snprintf(tmp, sizeof(tmp), "trailing `%c' in number", nondigit);
    4321. 

  4321.                 yyerror(tmp);
    4322. 

  4322.             }
    4323. 

  4323.             if (is_float) {
    4324. 

  4324.                 pslval->node = NEW_FLOAT(string_new2(tok()));
    4325. 

  4325.                 return tFLOAT;
    4326. 

  4326.             }
    4327. 

  4327.             pslval->node = NEW_NUMBER(string_new2(tok()));
    4328. 

  4328.             return tINTEGER;
    4329. 

  4329.         }
    4330. 

  4330. 

  4331.       case ']':
    4332. 

  4332.       case '}':
    4333. 

  4333.       case ')':
    4334. 

  4334.         COND_LEXPOP();
    4335. 

  4335.         CMDARG_LEXPOP();
    4336. 

  4336.         lex_state = EXPR_END;
    4337. 

  4337.         return c;
    4338. 

  4338. 

  4339.       case ':':
    4340. 

  4340.         c = nextc();
    4341. 

  4341.         if (c == ':') {
    4342. 

  4342.             if (lex_state == EXPR_BEG ||  lex_state == EXPR_MID ||
    4343. 

  4343.                 lex_state == EXPR_CLASS || (IS_ARG() && space_seen)) {
    4344. 

  4344.                 lex_state = EXPR_BEG;
    4345. 

  4345.                 return tCOLON3;
    4346. 

  4346.             }
    4347. 

  4347.             lex_state = EXPR_DOT;
    4348. 

  4348.             return tCOLON2;
    4349. 

  4349.         }
    4350. 

  4350.         if (lex_state == EXPR_END || lex_state == EXPR_ENDARG || ISSPACE(c)) {
    4351. 

  4351.             pushback(c, parser_state);
    4352. 

  4352.             lex_state = EXPR_BEG;
    4353. 

  4353.             return ':';
    4354. 

  4354.         }
    4355. 

  4355.         switch (c) {
    4356. 

  4356.           case '\'':
    4357. 

  4357.             lex_strterm = NEW_STRTERM(str_ssym, (intptr_t)c, 0);
    4358. 

  4358.             break;
    4359. 

  4359.           case '"':
    4360. 

  4360.             lex_strterm = NEW_STRTERM(str_dsym, (intptr_t)c, 0);
    4361. 

  4361.             break;
    4362. 

  4362.           default:
    4363. 

  4363.             pushback(c, parser_state);
    4364. 

  4364.             break;
    4365. 

  4365.         }
    4366. 

  4366.         lex_state = EXPR_FNAME;
    4367. 

  4367.         return tSYMBEG;
    4368. 

  4368. 

  4369.       case '/':
    4370. 

  4370.         if (lex_state == EXPR_BEG || lex_state == EXPR_MID) {
    4371. 

  4371.             lex_strterm = NEW_STRTERM(str_regexp, '/', 0);
    4372. 

  4372.             return tREGEXP_BEG;
    4373. 

  4373.         }
    4374. 

  4374.         if ((c = nextc()) == '=') {
    4375. 

  4375.             pslval->id = '/';
    4376. 

  4376.             lex_state = EXPR_BEG;
    4377. 

  4377.             return tOP_ASGN;
    4378. 

  4378.         }
    4379. 

  4379.         pushback(c, parser_state);
    4380. 

  4380.         if (IS_ARG() && space_seen) {
    4381. 

  4381.             if (!ISSPACE(c)) {
    4382. 

  4382.                 arg_ambiguous();
    4383. 

  4383.                 lex_strterm = NEW_STRTERM(str_regexp, '/', 0);
    4384. 

  4384.                 return tREGEXP_BEG;
    4385. 

  4385.             }
    4386. 

  4386.         }
    4387. 

  4387.         switch (lex_state) {
    4388. 

  4388.           case EXPR_FNAME: case EXPR_DOT:
    4389. 

  4389.             lex_state = EXPR_ARG; break;
    4390. 

  4390.           default:
    4391. 

  4391.             lex_state = EXPR_BEG; break;
    4392. 

  4392.         }
    4393. 

  4393.         return '/';
    4394. 

  4394. 

  4395.       case '^':
    4396. 

  4396.         if ((c = nextc()) == '=') {
    4397. 

  4397.             pslval->id = '^';
    4398. 

  4398.             lex_state = EXPR_BEG;
    4399. 

  4399.             return tOP_ASGN;
    4400. 

  4400.         }
    4401. 

  4401.         switch (lex_state) {
    4402. 

  4402.           case EXPR_FNAME: case EXPR_DOT:
    4403. 

  4403.             lex_state = EXPR_ARG; break;
    4404. 

  4404.           default:
    4405. 

  4405.             lex_state = EXPR_BEG; break;
    4406. 

  4406.         }
    4407. 

  4407.         pushback(c, parser_state);
    4408. 

  4408.         return '^';
    4409. 

  4409. 

  4410.       case ';':
    4411. 

  4411.         command_start = TRUE;
    4412. 

  4412.       case ',':
    4413. 

  4413.         lex_state = EXPR_BEG;
    4414. 

  4414.         return c;
    4415. 

  4415. 

  4416.       case '~':
    4417. 

  4417.         if (lex_state == EXPR_FNAME || lex_state == EXPR_DOT) {
    4418. 

  4418.             if ((c = nextc()) != '@') {
    4419. 

  4419.                 pushback(c, parser_state);
    4420. 

  4420.             }
    4421. 

  4421.         }
    4422. 

  4422.         switch (lex_state) {
    4423. 

  4423.           case EXPR_FNAME: case EXPR_DOT:
    4424. 

  4424.             lex_state = EXPR_ARG; break;
    4425. 

  4425.           default:
    4426. 

  4426.             lex_state = EXPR_BEG; break;
    4427. 

  4427.         }
    4428. 

  4428.         return '~';
    4429. 

  4429. 

  4430.       case '(':
    4431. 

  4431.         command_start = TRUE;
    4432. 

  4432.         if (lex_state == EXPR_BEG || lex_state == EXPR_MID) {
    4433. 

  4433.             c = tLPAREN;
    4434. 

  4434.         }
    4435. 

  4435.         else if (space_seen) {
    4436. 

  4436.             if (lex_state == EXPR_CMDARG) {
    4437. 

  4437.                 c = tLPAREN_ARG;
    4438. 

  4438.             }
    4439. 

  4439.             else if (lex_state == EXPR_ARG) {
    4440. 

  4440.                 rb_warn("don't put space before argument parentheses");
    4441. 

  4441.                 c = '(';
    4442. 

  4442.             }
    4443. 

  4443.         }
    4444. 

  4444.         COND_PUSH(0);
    4445. 

  4445.         CMDARG_PUSH(0);
    4446. 

  4446.         lex_state = EXPR_BEG;
    4447. 

  4447.         return c;
    4448. 

  4448. 

  4449.       case '[':
    4450. 

  4450.         if (lex_state == EXPR_FNAME || lex_state == EXPR_DOT) {
    4451. 

  4451.             lex_state = EXPR_ARG;
    4452. 

  4452.             if ((c = nextc()) == ']') {
    4453. 

  4453.                 if ((c = nextc()) == '=') {
    4454. 

  4454.                     return tASET;
    4455. 

  4455.                 }
    4456. 

  4456.                 pushback(c, parser_state);
    4457. 

  4457.                 return tAREF;
    4458. 

  4458.             }
    4459. 

  4459.             pushback(c, parser_state);
    4460. 

  4460.             return '[';
    4461. 

  4461.         }
    4462. 

  4462.         else if (lex_state == EXPR_BEG || lex_state == EXPR_MID) {
    4463. 

  4463.             c = tLBRACK;
    4464. 

  4464.         }
    4465. 

  4465.         else if (IS_ARG() && space_seen) {
    4466. 

  4466.             c = tLBRACK;
    4467. 

  4467.         }
    4468. 

  4468.         lex_state = EXPR_BEG;
    4469. 

  4469.         COND_PUSH(0);
    4470. 

  4470.         CMDARG_PUSH(0);
    4471. 

  4471.         return c;
    4472. 

  4472. 

  4473.       case '{':
    4474. 

  4474.         if (IS_ARG() || lex_state == EXPR_END)
    4475. 

  4475.             c = '{';          /* block (primary) */
    4476. 

  4476.         else if (lex_state == EXPR_ENDARG)
    4477. 

  4477.             c = tLBRACE_ARG;  /* block (expr) */
    4478. 

  4478.         else
    4479. 

  4479.             c = tLBRACE;      /* hash */
    4480. 

  4480.         COND_PUSH(0);
    4481. 

  4481.         CMDARG_PUSH(0);
    4482. 

  4482.         lex_state = EXPR_BEG;
    4483. 

  4483.         return c;
    4484. 

  4484. 

  4485.       case '\\':
    4486. 

  4486.         c = nextc();
    4487. 

  4487.         if (c == '\n') {
    4488. 

  4488.             space_seen = 1;
    4489. 

  4489.             goto retry; /* skip \\n */
    4490. 

  4490.         }
    4491. 

  4491.         pushback(c, parser_state);
    4492. 

  4492.         if(lex_state == EXPR_BEG
    4493. 

  4493.            || lex_state == EXPR_MID || space_seen) {
    4494. 

  4494.             lex_state = EXPR_DOT;
    4495. 

  4495.             return tUBS;
    4496. 

  4496.         }
    4497. 

  4497.         lex_state = EXPR_DOT;
    4498. 

  4498.         return '\\';
    4499. 

  4499. 

  4500.       case '%':
    4501. 

  4501.         if (lex_state == EXPR_BEG || lex_state == EXPR_MID) {
    4502. 

  4502.             intptr_t term;
    4503. 

  4503.             intptr_t paren;
    4504. 

  4504.             char tmpstr[256];
    4505. 

  4505.             char *cur;
    4506. 

  4506. 

  4507.             c = nextc();
    4508. 

  4508.           quotation:
    4509. 

  4509.             if (!ISALNUM(c)) {
    4510. 

  4510.                 term = c;
    4511. 

  4511.                 c = 'Q';
    4512. 

  4512.             }
    4513. 

  4513.             else {
    4514. 

  4514.                 term = nextc();
    4515. 

  4515.                 if (ISALNUM(term) || ismbchar(term)) {
    4516. 

  4516.                     cur = tmpstr;
    4517. 

  4517.                     *cur++ = c;
    4518. 

  4518.                     while(ISALNUM(term) || ismbchar(term)) {
    4519. 

  4519.                         *cur++ = term;
    4520. 

  4520.                         term = nextc();
    4521. 

  4521.                     }
    4522. 

  4522.                     *cur = 0;
    4523. 

  4523.                     c = 1;
    4524. 

  4524. 

  4525.                 }
    4526. 

  4526.             }
    4527. 

  4527.             if (c == -1 || term == -1) {
    4528. 

  4528.                 rb_compile_error(parser_state, "unterminated quoted string meets end of file");
    4529. 

  4529.                 return 0;
    4530. 

  4530.             }
    4531. 

  4531.             paren = term;
    4532. 

  4532.             if (term == '(') term = ')';
    4533. 

  4533.             else if (term == '[') term = ']';
    4534. 

  4534.             else if (term == '{') term = '}';
    4535. 

  4535.             else if (term == '<') term = '>';
    4536. 

  4536.             else paren = 0;
    4537. 

  4537. 

  4538.             switch (c) {
    4539. 

  4539.               case 'Q':
    4540. 

  4540.                 lex_strterm = NEW_STRTERM(str_dquote, term, paren);
    4541. 

  4541.                 return tSTRING_BEG;
    4542. 

  4542. 

  4543.               case 'q':
    4544. 

  4544.                 lex_strterm = NEW_STRTERM(str_squote, term, paren);
    4545. 

  4545.                 return tSTRING_BEG;
    4546. 

  4546. 

  4547.               case 'W':
    4548. 

  4548.                 lex_strterm = NEW_STRTERM(str_dquote | STR_FUNC_QWORDS, term, paren);
    4549. 

  4549.                 do {c = nextc();} while (ISSPACE(c));
    4550. 

  4550.                 pushback(c, parser_state);
    4551. 

  4551.                 return tWORDS_BEG;
    4552. 

  4552. 

  4553.               case 'w':
    4554. 

  4554.                 lex_strterm = NEW_STRTERM(str_squote | STR_FUNC_QWORDS, term, paren);
    4555. 

  4555.                 do {c = nextc();} while (ISSPACE(c));
    4556. 

  4556.                 pushback(c, parser_state);
    4557. 

  4557.                 return tQWORDS_BEG;
    4558. 

  4558. 

  4559.               case 'x':
    4560. 

  4560.                 lex_strterm = NEW_STRTERM(str_xquote, term, paren);
    4561. 

  4561.                 pslval->id = 0;
    4562. 

  4562.                 return tXSTRING_BEG;
    4563. 

  4563. 

  4564.               case 'r':
    4565. 

  4565.                 lex_strterm = NEW_STRTERM(str_regexp, term, paren);
    4566. 

  4566.                 return tREGEXP_BEG;
    4567. 

  4567. 

  4568.               case 's':
    4569. 

  4569.                 lex_strterm = NEW_STRTERM(str_ssym, term, paren);
    4570. 

  4570.                 lex_state = EXPR_FNAME;
    4571. 

  4571.                 return tSYMBEG;
    4572. 

  4572. 

  4573.               case 1:
    4574. 

  4574.                 lex_strterm = NEW_STRTERM(str_xquote, term, paren);
    4575. 

  4575.                 pslval->id = rb_parser_sym(tmpstr);
    4576. 

  4576.                 return tXSTRING_BEG;
    4577. 

  4577. 

  4578.               default:
    4579. 

  4579.                 lex_strterm = NEW_STRTERM(str_xquote, term, paren);
    4580. 

  4580.                 tmpstr[0] = c;
    4581. 

  4581.                 tmpstr[1] = 0;
    4582. 

  4582.                 pslval->id = rb_parser_sym(tmpstr);
    4583. 

  4583.                 return tXSTRING_BEG;
    4584. 

  4584.             }
    4585. 

  4585.         }
    4586. 

  4586.         if ((c = nextc()) == '=') {
    4587. 

  4587.             pslval->id = '%';
    4588. 

  4588.             lex_state = EXPR_BEG;
    4589. 

  4589.             return tOP_ASGN;
    4590. 

  4590.         }
    4591. 

  4591.         if (IS_ARG() && space_seen && !ISSPACE(c)) {
    4592. 

  4592.             goto quotation;
    4593. 

  4593.         }
    4594. 

  4594.         switch (lex_state) {
    4595. 

  4595.           case EXPR_FNAME: case EXPR_DOT:
    4596. 

  4596.             lex_state = EXPR_ARG; break;
    4597. 

  4597.           default:
    4598. 

  4598.             lex_state = EXPR_BEG; break;
    4599. 

  4599.         }
    4600. 

  4600.         pushback(c, parser_state);
    4601. 

  4601.         return '%';
    4602. 

  4602. 

  4603.       case '$':
    4604. 

  4604.         last_state = lex_state;
    4605. 

  4605.         lex_state = EXPR_END;
    4606. 

  4606.         newtok(parser_state);
    4607. 

  4607.         c = nextc();
    4608. 

  4608.         switch (c) {
    4609. 

  4609.           case '_':             /* $_: last read line string */
    4610. 

  4610.             c = nextc();
    4611. 

  4611.             if (is_identchar(c)) {
    4612. 

  4612.                 tokadd('$', parser_state);
    4613. 

  4613.                 tokadd('_', parser_state);
    4614. 

  4614.                 break;
    4615. 

  4615.             }
    4616. 

  4616.             pushback(c, parser_state);
    4617. 

  4617.             c = '_';
    4618. 

  4618.             /* fall through */
    4619. 

  4619.           case '~':             /* $~: match-data */
    4620. 

  4620.             local_cnt(c);
    4621. 

  4621.             /* fall through */
    4622. 

  4622.           case '*':             /* $*: argv */
    4623. 

  4623.           case '$':             /* $$: pid */
    4624. 

  4624.           case '?':             /* $?: last status */
    4625. 

  4625.           case '!':             /* $!: error string */
    4626. 

  4626.           case '@':             /* $@: error position */
    4627. 

  4627.           case '/':             /* $/: input record separator */
    4628. 

  4628.           case '\\':            /* $\: output record separator */
    4629. 

  4629.           case ';':             /* $;: field separator */
    4630. 

  4630.           case ',':             /* $,: output field separator */
    4631. 

  4631.           case '.':             /* $.: last read line number */
    4632. 

  4632.           case '=':             /* $=: ignorecase */
    4633. 

  4633.           case ':':             /* $:: load path */
    4634. 

  4634.           case '<':             /* $<: reading filename */
    4635. 

  4635.           case '>':             /* $>: default output handle */
    4636. 

  4636.           case '\"':            /* $": already loaded files */
    4637. 

  4637.             tokadd('$', parser_state);
    4638. 

  4638.             tokadd((char)c, parser_state);
    4639. 

  4639.             tokfix();
    4640. 

  4640.             pslval->id = rb_parser_sym(tok());
    4641. 

  4641.             return tGVAR;
    4642. 

  4642. 

  4643.           case '-':
    4644. 

  4644.             tokadd('$', parser_state);
    4645. 

  4645.             tokadd((char)c, parser_state);
    4646. 

  4646.             c = nextc();
    4647. 

  4647.             tokadd((char)c, parser_state);
    4648. 

  4648.           gvar:
    4649. 

  4649.             tokfix();
    4650. 

  4650.             pslval->id = rb_parser_sym(tok());
    4651. 

  4651.             /* xxx shouldn't check if valid option variable */
    4652. 

  4652.             return tGVAR;
    4653. 

  4653. 

  4654.           case '&':             /* $&: last match */
    4655. 

  4655.           case '`':             /* $`: string before last match */
    4656. 

  4656.           case '\'':            /* $': string after last match */
    4657. 

  4657.           case '+':             /* $+: string matches last paren. */
    4658. 

  4658. 	    if (last_state == EXPR_FNAME) {
    4659. 

  4659. 		tokadd((char)'$', parser_state);
    4660. 

  4660. 		tokadd(c, parser_state);
    4661. 

  4661. 		goto gvar;
    4662. 

  4662. 	    }
    4663. 

  4663.             pslval->node = NEW_BACK_REF((intptr_t)c);
    4664. 

  4664.             return tBACK_REF;
    4665. 

  4665. 

  4666.           case '1': case '2': case '3':
    4667. 

  4667.           case '4': case '5': case '6':
    4668. 

  4668.           case '7': case '8': case '9':
    4669. 

  4669.             tokadd('$', parser_state);
    4670. 

  4670.             do {
    4671. 

  4671.                 tokadd((char)c, parser_state);
    4672. 

  4672.                 c = nextc();
    4673. 

  4673.             } while (ISDIGIT(c));
    4674. 

  4674.             pushback(c, parser_state);
    4675. 

  4675. 	    if (last_state == EXPR_FNAME) goto gvar;
    4676. 

  4676.             tokfix();
    4677. 

  4677.             pslval->node = NEW_NTH_REF((intptr_t)atoi(tok()+1));
    4678. 

  4678.             return tNTH_REF;
    4679. 

  4679. 

  4680.           default:
    4681. 

  4681.             if (!is_identchar(c)) {
    4682. 

  4682.                 pushback(c, parser_state);
    4683. 

  4683.                 return '$';
    4684. 

  4684.             }
    4685. 

  4685.           case '0':
    4686. 

  4686.             tokadd('$', parser_state);
    4687. 

  4687.         }
    4688. 

  4688.         break;
    4689. 

  4689. 

  4690.       case '@':
    4691. 

  4691.         c = nextc();
    4692. 

  4692.         newtok(parser_state);
    4693. 

  4693.         tokadd('@', parser_state);
    4694. 

  4694.         if (c == '@') {
    4695. 

  4695.             tokadd('@', parser_state);
    4696. 

  4696.             c = nextc();
    4697. 

  4697.         }
    4698. 

  4698.         if (ISDIGIT(c)) {
    4699. 

  4699.             if (tokidx == 1) {
    4700. 

  4700.                 rb_compile_error(parser_state,
    4701. 

  4701.                     "`@%c' is not allowed as an instance variable name", c);
    4702. 

  4702.             }
    4703. 

  4703.             else {
    4704. 

  4704.                 rb_compile_error(parser_state,
    4705. 

  4705.                     "`@@%c' is not allowed as a class variable name", c);
    4706. 

  4706.             }
    4707. 

  4707.         }
    4708. 

  4708.         if (!is_identchar(c)) {
    4709. 

  4709.             pushback(c, parser_state);
    4710. 

  4710.             return '@';
    4711. 

  4711.         }
    4712. 

  4712.         break;
    4713. 

  4713. 

  4714.       case '_':
    4715. 

  4715.         if (was_bol() && whole_match_p("__END__", 7, 0, parser_state)) {
    4716. 

  4716.             end_seen = 1;
    4717. 

  4717.             return -1;
    4718. 

  4718.         }
    4719. 

  4719.         newtok(parser_state);
    4720. 

  4720.         break;
    4721. 

  4721. 

  4722.       default:
    4723. 

  4723.         if (!is_identchar(c)) {
    4724. 

  4724.             rb_compile_error(parser_state, "Invalid char `\\%03o' in expression", c);
    4725. 

  4725.             goto retry;
    4726. 

  4726.         }
    4727. 

  4727. 

  4728.         newtok(parser_state);
    4729. 

  4729.         break;
    4730. 

  4730.     }
    4731. 

  4731. 

  4732.     do {
    4733. 

  4733.         tokadd((char)c, parser_state);
    4734. 

  4734.         if (ismbchar(c)) {
    4735. 

  4735.             int i, len = mbclen(c)-1;
    4736. 

  4736. 

  4737.             for (i = 0; i < len; i++) {
    4738. 

  4738.                 c = nextc();
    4739. 

  4739.                 tokadd((char)c, parser_state);
    4740. 

  4740.             }
    4741. 

  4741.         }
    4742. 

  4742.         c = nextc();
    4743. 

  4743.     } while (is_identchar(c));
    4744. 

  4744.     if ((c == '!' || c == '?') && is_identchar(tok()[0]) && !peek('=')) {
    4745. 

  4745.         tokadd((char)c, parser_state);
    4746. 

  4746.     }
    4747. 

  4747.     else {
    4748. 

  4748.         pushback(c, parser_state);
    4749. 

  4749.     }
    4750. 

  4750.     tokfix();
    4751. 

  4751. 

  4752.     {
    4753. 

  4753.         int result = 0;
    4754. 

  4754. 

  4755.         last_state = lex_state;
    4756. 

  4756.         switch (tok()[0]) {
    4757. 

  4757.           case '$':
    4758. 

  4758.             lex_state = EXPR_END;
    4759. 

  4759.             result = tGVAR;
    4760. 

  4760.             break;
    4761. 

  4761.           case '@':
    4762. 

  4762.             lex_state = EXPR_END;
    4763. 

  4763.             if (tok()[1] == '@')
    4764. 

  4764.                 result = tCVAR;
    4765. 

  4765.             else
    4766. 

  4766.                 result = tIVAR;
    4767. 

  4767.             break;
    4768. 

  4768. 

  4769.           default:
    4770. 

  4770.             if (toklast() == '!' || toklast() == '?') {
    4771. 

  4771.                 result = tFID;
    4772. 

  4772.             }
    4773. 

  4773.             else {
    4774. 

  4774.                 if (lex_state == EXPR_FNAME) {
    4775. 

  4775.                     if ((c = nextc()) == '=' && !peek('~') && !peek('>') &&
    4776. 

  4776.                         (!peek('=') || (lex_p + 1 < lex_pend && (lex_p)[1] == '>'))) {
    4777. 

  4777.                         result = tIDENTIFIER;
    4778. 

  4778.                         tokadd((char)c, parser_state);
    4779. 

  4779.                         tokfix();
    4780. 

  4780.                     }
    4781. 

  4781.                     else {
    4782. 

  4782.                         pushback(c, parser_state);
    4783. 

  4783.                     }
    4784. 

  4784.                 }
    4785. 

  4785.                 if (result == 0 && ISUPPER(tok()[0])) {
    4786. 

  4786.                     result = tCONSTANT;
    4787. 

  4787.                 }
    4788. 

  4788.                 else {
    4789. 

  4789.                     result = tIDENTIFIER;
    4790. 

  4790.                 }
    4791. 

  4791.             }
    4792. 

  4792. 

  4793.             if (lex_state != EXPR_DOT) {
    4794. 

  4794.                 const struct kwtable *kw;
    4795. 

  4795. 

  4796.                 /* See if it is a reserved word.  */
    4797. 

  4797.                 kw = mel_reserved_word(tok(), toklen());
    4798. 

  4798.                 if (kw) {
    4799. 

  4799.                     enum lex_state_e state = lex_state;
    4800. 

  4800.                     lex_state = kw->state;
    4801. 

  4801.                     if (state == EXPR_FNAME) {
    4802. 

  4802.                         pslval->id = rb_parser_sym(kw->name);
    4803. 

  4803.                         // Hack. Ignore the different variants of do
    4804. 

  4804.                         // if we're just trying to match a FNAME
    4805. 

  4805.                         if(kw->id[0] == kDO) return kDO;
    4806. 

  4806.                     }
    4807. 

  4807.                     if (kw->id[0] == kDO) {
    4808. 

  4808.                         command_start = TRUE;
    4809. 

  4809.                         if (COND_P()) return kDO_COND;
    4810. 

  4810.                         if (CMDARG_P() && state != EXPR_CMDARG)
    4811. 

  4811.                             return kDO_BLOCK;
    4812. 

  4812.                         if (state == EXPR_ENDARG)
    4813. 

  4813.                             return kDO_BLOCK;
    4814. 

  4814.                         return kDO;
    4815. 

  4815.                     }
    4816. 

  4816.                     if (state == EXPR_BEG)
    4817. 

  4817.                         return kw->id[0];
    4818. 

  4818.                     else {
    4819. 

  4819.                         if (kw->id[0] != kw->id[1])
    4820. 

  4820.                             lex_state = EXPR_BEG;
    4821. 

  4821.                         return kw->id[1];
    4822. 

  4822.                     }
    4823. 

  4823.                 }
    4824. 

  4824.             }
    4825. 

  4825. 

  4826.             if (lex_state == EXPR_BEG ||
    4827. 

  4827.                 lex_state == EXPR_MID ||
    4828. 

  4828.                 lex_state == EXPR_DOT ||
    4829. 

  4829.                 lex_state == EXPR_ARG ||
    4830. 

  4830.                 lex_state == EXPR_CMDARG) {
    4831. 

  4831.                 if (cmd_state) {
    4832. 

  4832.                     lex_state = EXPR_CMDARG;
    4833. 

  4833.                 }
    4834. 

  4834.                 else {
    4835. 

  4835.                     lex_state = EXPR_ARG;
    4836. 

  4836.                 }
    4837. 

  4837.             }
    4838. 

  4838.             else {
    4839. 

  4839.                 lex_state = EXPR_END;
    4840. 

  4840.             }
    4841. 

  4841.         }
    4842. 

  4842.         pslval->id = rb_parser_sym(tok());
    4843. 

  4843.         if(is_local_id(pslval->id) &&
    4844. 

  4844.            last_state != EXPR_DOT &&
    4845. 

  4845.            local_id(pslval->id)) {
    4846. 

  4846.            lex_state = EXPR_END;
    4847. 

  4847.         }
    4848. 

  4848. 

  4849. /*         if (is_local_id(pslval->id) && local_id(pslval->id)) { */
    4850. 

  4850. /*             lex_state = EXPR_END; */
    4851. 

  4851. /*         } */
    4852. 

  4852. 

  4853.         return result;
    4854. 

  4854.     }
    4855. 

  4855. }
    4856. 

  4856. 

  4857. 

  4858. NODE*
    4859. 

  4859. parser_node_newnode(rb_parser_state *parser_state, enum node_type type,
    4860. 

  4860.                     VALUE a0, VALUE a1, VALUE a2)
    4861. 

  4861. {
    4862. 

  4862.     NODE *n = (NODE*)pt_allocate(parser_state, sizeof(NODE));
    4863. 

  4863. 

  4864.     n->flags = 0;
    4865. 

  4865.     nd_set_type(n, type);
    4866. 

  4866.     nd_set_line(n, ruby_sourceline);
    4867. 

  4867.     n->nd_file = ruby_sourcefile;
    4868. 

  4868. 

  4869.     n->u1.value = a0;
    4870. 

  4870.     n->u2.value = a1;
    4871. 

  4871.     n->u3.value = a2;
    4872. 

  4872. 

  4873.     return n;
    4874. 

  4874. }
    4875. 

  4875. 

  4876. static NODE*
    4877. 

  4877. newline_node(rb_parser_state *parser_state, NODE *node)
    4878. 

  4878. {
    4879. 

  4879.     NODE *nl = 0;
    4880. 

  4880.     if (node) {
    4881. 

  4881.         if (nd_type(node) == NODE_NEWLINE) return node;
    4882. 

  4882.         nl = NEW_NEWLINE(node);
    4883. 

  4883.         fixpos(nl, node);
    4884. 

  4884.         nl->nd_nth = nd_line(node);
    4885. 

  4885.     }
    4886. 

  4886.     return nl;
    4887. 

  4887. }
    4888. 

  4888. 

  4889. static void
    4890. 

  4890. fixpos(NODE *node, NODE *orig)
    4891. 

  4891. {
    4892. 

  4892.     if (!node) return;
    4893. 

  4893.     if (!orig) return;
    4894. 

  4894.     if (orig == (NODE*)1) return;
    4895. 

  4895.     node->nd_file = orig->nd_file;
    4896. 

  4896.     nd_set_line(node, nd_line(orig));
    4897. 

  4897. }
    4898. 

  4898. 

  4899. static void
    4900. 

  4900. parser_warning(rb_parser_state *parser_state, NODE *node, const char *mesg)
    4901. 

  4901. {
    4902. 

  4902.     int line = ruby_sourceline;
    4903. 

  4903.     if(emit_warnings) {
    4904. 

  4904.       ruby_sourceline = nd_line(node);
    4905. 

  4905.       printf("%s:%i: warning: %s\n", ruby_sourcefile, ruby_sourceline, mesg);
    4906. 

  4906.       ruby_sourceline = line;
    4907. 

  4907.     }
    4908. 

  4908. }
    4909. 

  4909. 

  4910. static NODE*
    4911. 

  4911. block_append(rb_parser_state *parser_state, NODE *head, NODE *tail)
    4912. 

  4912. {
    4913. 

  4913.     NODE *end, *h = head;
    4914. 

  4914. 

  4915.     if (tail == 0) return head;
    4916. 

  4916. 

  4917.   again:
    4918. 

  4918.     if (h == 0) return tail;
    4919. 

  4919.     switch (nd_type(h)) {
    4920. 

  4920.       case NODE_NEWLINE:
    4921. 

  4921.         h = h->nd_next;
    4922. 

  4922.         goto again;
    4923. 

  4923.       case NODE_STR:
    4924. 

  4924.       case NODE_LIT:
    4925. 

  4925.         parser_warning(parser_state, h, "unused literal ignored");
    4926. 

  4926.         return tail;
    4927. 

  4927.       default:
    4928. 

  4928.         h = end = NEW_BLOCK(head);
    4929. 

  4929.         end->nd_end = end;
    4930. 

  4930.         fixpos(end, head);
    4931. 

  4931.         head = end;
    4932. 

  4932.         break;
    4933. 

  4933.       case NODE_BLOCK:
    4934. 

  4934.         end = h->nd_end;
    4935. 

  4935.         break;
    4936. 

  4936.     }
    4937. 

  4937. 

  4938.     if (verbose) {
    4939. 

  4939.         NODE *nd = end->nd_head;
    4940. 

  4940.       newline:
    4941. 

  4941.         switch (nd_type(nd)) {
    4942. 

  4942.           case NODE_RETURN:
    4943. 

  4943.           case NODE_BREAK:
    4944. 

  4944.           case NODE_NEXT:
    4945. 

  4945.           case NODE_REDO:
    4946. 

  4946.           case NODE_RETRY:
    4947. 

  4947.             parser_warning(parser_state, nd, "statement not reached");
    4948. 

  4948.             break;
    4949. 

  4949. 

  4950.         case NODE_NEWLINE:
    4951. 

  4951.             nd = nd->nd_next;
    4952. 

  4952.             goto newline;
    4953. 

  4953. 

  4954.           default:
    4955. 

  4955.             break;
    4956. 

  4956.         }
    4957. 

  4957.     }
    4958. 

  4958. 

  4959.     if (nd_type(tail) != NODE_BLOCK) {
    4960. 

  4960.         tail = NEW_BLOCK(tail);
    4961. 

  4961.         tail->nd_end = tail;
    4962. 

  4962.     }
    4963. 

  4963.     end->nd_next = tail;
    4964. 

  4964.     h->nd_end = tail->nd_end;
    4965. 

  4965.     return head;
    4966. 

  4966. }
    4967. 

  4967. 

  4968. /* append item to the list */
    4969. 

  4969. static NODE*
    4970. 

  4970. list_append(rb_parser_state *parser_state, NODE *list, NODE *item)
    4971. 

  4971. {
    4972. 

  4972.     NODE *last;
    4973. 

  4973. 

  4974.     if (list == 0) return NEW_LIST(item);
    4975. 

  4975.     if (list->nd_next) {
    4976. 

  4976.         last = list->nd_next->nd_end;
    4977. 

  4977.     }
    4978. 

  4978.     else {
    4979. 

  4979.         last = list;
    4980. 

  4980.     }
    4981. 

  4981. 

  4982.     list->nd_alen += 1;
    4983. 

  4983.     last->nd_next = NEW_LIST(item);
    4984. 

  4984.     list->nd_next->nd_end = last->nd_next;
    4985. 

  4985.     return list;
    4986. 

  4986. }
    4987. 

  4987. 

  4988. /* concat two lists */
    4989. 

  4989. static NODE*
    4990. 

  4990. list_concat(NODE *head, NODE *tail)
    4991. 

  4991. {
    4992. 

  4992.     NODE *last;
    4993. 

  4993. 

  4994.     if (head->nd_next) {
    4995. 

  4995.         last = head->nd_next->nd_end;
    4996. 

  4996.     }
    4997. 

  4997.     else {
    4998. 

  4998.         last = head;
    4999. 

  4999.     }
    5000. 

  5000. 

  5001.     head->nd_alen += tail->nd_alen;
    5002. 

  5002.     last->nd_next = tail;
    5003. 

  5003.     if (tail->nd_next) {
    5004. 

  5004.         head->nd_next->nd_end = tail->nd_next->nd_end;
    5005. 

  5005.     }
    5006. 

  5006.     else {
    5007. 

  5007.         head->nd_next->nd_end = tail;
    5008. 

  5008.     }
    5009. 

  5009. 

  5010.     return head;
    5011. 

  5011. }
    5012. 

  5012. 

  5013. /* concat two string literals */
    5014. 

  5014. static NODE *
    5015. 

  5015. literal_concat(rb_parser_state *parser_state, NODE *head, NODE *tail)
    5016. 

  5016. {
    5017. 

  5017.     enum node_type htype;
    5018. 

  5018. 

  5019.     if (!head) return tail;
    5020. 

  5020.     if (!tail) return head;
    5021. 

  5021. 

  5022.     htype = (enum node_type)nd_type(head);
    5023. 

  5023.     if (htype == NODE_EVSTR) {
    5024. 

  5024.         NODE *node = NEW_DSTR(string_new(0, 0));
    5025. 

  5025.         head = list_append(parser_state, node, head);
    5026. 

  5026.     }
    5027. 

  5027.     switch (nd_type(tail)) {
    5028. 

  5028.       case NODE_STR:
    5029. 

  5029.         if (htype == NODE_STR) {
    5030. 

  5030.             if(head->nd_str) {
    5031. 

  5031.                 bconcat(head->nd_str, tail->nd_str);
    5032. 

  5032.                 bdestroy(tail->nd_str);
    5033. 

  5033.             } else {
    5034. 

  5034.                 head = tail;
    5035. 

  5035.             }
    5036. 

  5036.         }
    5037. 

  5037.         else {
    5038. 

  5038.             list_append(parser_state, head, tail);
    5039. 

  5039.         }
    5040. 

  5040.         break;
    5041. 

  5041. 

  5042.       case NODE_DSTR:
    5043. 

  5043.         if (htype == NODE_STR) {
    5044. 

  5044.             bconcat(head->nd_str, tail->nd_str);
    5045. 

  5045.             bdestroy(tail->nd_str);
    5046. 

  5046. 

  5047.             tail->nd_lit = head->nd_lit;
    5048. 

  5048.             head = tail;
    5049. 

  5049.         }
    5050. 

  5050.         else {
    5051. 

  5051.             nd_set_type(tail, NODE_ARRAY);
    5052. 

  5052.             tail->nd_head = NEW_STR(tail->nd_lit);
    5053. 

  5053.             list_concat(head, tail);
    5054. 

  5054.         }
    5055. 

  5055.         break;
    5056. 

  5056. 

  5057.       case NODE_EVSTR:
    5058. 

  5058.         if (htype == NODE_STR) {
    5059. 

  5059.             nd_set_type(head, NODE_DSTR);
    5060. 

  5060.             head->nd_alen = 1;
    5061. 

  5061.         }
    5062. 

  5062.         list_append(parser_state, head, tail);
    5063. 

  5063.         break;
    5064. 

  5064.     }
    5065. 

  5065.     return head;
    5066. 

  5066. }
    5067. 

  5067. 

  5068. static NODE *
    5069. 

  5069. evstr2dstr(rb_parser_state *parser_state, NODE *node)
    5070. 

  5070. {
    5071. 

  5071.     if (nd_type(node) == NODE_EVSTR) {
    5072. 

  5072.         node = list_append(parser_state, NEW_DSTR(string_new(0, 0)), node);
    5073. 

  5073.     }
    5074. 

  5074.     return node;
    5075. 

  5075. }
    5076. 

  5076. 

  5077. static NODE *
    5078. 

  5078. new_evstr(rb_parser_state *parser_state, NODE *node)
    5079. 

  5079. {
    5080. 

  5080.     NODE *head = node;
    5081. 

  5081. 

  5082.   again:
    5083. 

  5083.     if (node) {
    5084. 

  5084.         switch (nd_type(node)) {
    5085. 

  5085.           case NODE_STR: case NODE_DSTR: case NODE_EVSTR:
    5086. 

  5086.             return node;
    5087. 

  5087.           case NODE_NEWLINE:
    5088. 

  5088.             node = node->nd_next;
    5089. 

  5089.             goto again;
    5090. 

  5090.         }
    5091. 

  5091.     }
    5092. 

  5092.     return NEW_EVSTR(head);
    5093. 

  5093. }
    5094. 

  5094. 

  5095. static const struct {
    5096. 

  5096.     QUID token;
    5097. 

  5097.     const char name[12];
    5098. 

  5098. } op_tbl[] = {
    5099. 

  5099.     {tDOT2,     ".."},
    5100. 

  5100.     {tDOT3,     "..."},
    5101. 

  5101.     {'+',       "+"},
    5102. 

  5102.     {'-',       "-"},
    5103. 

  5103.     {'+',       "+(binary)"},
    5104. 

  5104.     {'-',       "-(binary)"},
    5105. 

  5105.     {'*',       "*"},
    5106. 

  5106.     {'/',       "/"},
    5107. 

  5107.     {'%',       "%"},
    5108. 

  5108.     {tPOW,      "**"},
    5109. 

  5109.     {tUPLUS,    "+@"},
    5110. 

  5110.     {tUMINUS,   "-@"},
    5111. 

  5111.     {tUPLUS,    "+(unary)"},
    5112. 

  5112.     {tUMINUS,   "-(unary)"},
    5113. 

  5113.     {'|',       "|"},
    5114. 

  5114.     {'^',       "^"},
    5115. 

  5115.     {'&',       "&"},
    5116. 

  5116.     {tCMP,      "<=>"},
    5117. 

  5117.     {'>',       ">"},
    5118. 

  5118.     {tGEQ,      ">="},
    5119. 

  5119.     {'<',       "<"},
    5120. 

  5120.     {tLEQ,      "<="},
    5121. 

  5121.     {tEQ,       "=="},
    5122. 

  5122.     {tEQQ,      "==="},
    5123. 

  5123.     {tNEQ,      "!="},
    5124. 

  5124.     {tMATCH,    "=~"},
    5125. 

  5125.     {tNMATCH,   "!~"},
    5126. 

  5126.     {'!',       "!"},
    5127. 

  5127.     {'~',       "~"},
    5128. 

  5128.     {'!',       "!(unary)"},
    5129. 

  5129.     {'~',       "~(unary)"},
    5130. 

  5130.     {'!',       "!@"},
    5131. 

  5131.     {'~',       "~@"},
    5132. 

  5132.     {tAREF,     "[]"},
    5133. 

  5133.     {tASET,     "[]="},
    5134. 

  5134.     {tLSHFT,    "<<"},
    5135. 

  5135.     {tRSHFT,    ">>"},
    5136. 

  5136.     {tCOLON2,   "::"},
    5137. 

  5137.     {'`',       "`"},
    5138. 

  5138.     {0, ""}
    5139. 

  5139. };
    5140. 

  5140. 

  5141. static QUID convert_op(QUID id) {
    5142. 

  5142.     int i;
    5143. 

  5143.     for(i = 0; op_tbl[i].token; i++) {
    5144. 

  5144.         if(op_tbl[i].token == id) {
    5145. 

  5145.             return rb_parser_sym(op_tbl[i].name);
    5146. 

  5146.         }
    5147. 

  5147.     }
    5148. 

  5148.     return id;
    5149. 

  5149. }
    5150. 

  5150. 

  5151. static NODE *
    5152. 

  5152. call_op(NODE *recv, QUID id, int narg, NODE *arg1, rb_parser_state *parser_state)
    5153. 

  5153. {
    5154. 

  5154.     value_expr(recv);
    5155. 

  5155.     if (narg == 1) {
    5156. 

  5156.         value_expr(arg1);
    5157. 

  5157.         arg1 = NEW_LIST(arg1);
    5158. 

  5158.     }
    5159. 

  5159.     else {
    5160. 

  5160.         arg1 = 0;
    5161. 

  5161.     }
    5162. 

  5162. 

  5163.     id = convert_op(id);
    5164. 

  5164. 

  5165. 

  5166.     NODE* n = NEW_CALL(recv, id, arg1);
    5167. 

  5167. 

  5168.     fixpos(n, recv);
    5169. 

  5169. 

  5170.     return n;
    5171. 

  5171. }
    5172. 

  5172. 

  5173. static NODE*
    5174. 

  5174. match_gen(NODE *node1, NODE *node2, rb_parser_state *parser_state)
    5175. 

  5175. {
    5176. 

  5176.     local_cnt('~');
    5177. 

  5177. 

  5178.     value_expr(node1);
    5179. 

  5179.     value_expr(node2);
    5180. 

  5180.     if (node1) {
    5181. 

  5181.         switch (nd_type(node1)) {
    5182. 

  5182.           case NODE_DREGX:
    5183. 

  5183.           case NODE_DREGX_ONCE:
    5184. 

  5184.             return NEW_MATCH2(node1, node2);
    5185. 

  5185. 

  5186.           case NODE_REGEX:
    5187. 

  5187.               return NEW_MATCH2(node1, node2);
    5188. 

  5188.         }
    5189. 

  5189.     }
    5190. 

  5190. 

  5191.     if (node2) {
    5192. 

  5192.         switch (nd_type(node2)) {
    5193. 

  5193.           case NODE_DREGX:
    5194. 

  5194.           case NODE_DREGX_ONCE:
    5195. 

  5195.             return NEW_MATCH3(node2, node1);
    5196. 

  5196. 

  5197.           case NODE_REGEX:
    5198. 

  5198.             return NEW_MATCH3(node2, node1);
    5199. 

  5199.         }
    5200. 

  5200.     }
    5201. 

  5201. 

  5202.     return NEW_CALL(node1, convert_op(tMATCH), NEW_LIST(node2));
    5203. 

  5203. }
    5204. 

  5204. 

  5205. static NODE*
    5206. 

  5206. mel_gettable(rb_parser_state *parser_state, QUID id)
    5207. 

  5207. {
    5208. 

  5208.     if (id == kSELF) {
    5209. 

  5209.         return NEW_SELF();
    5210. 

  5210.     }
    5211. 

  5211.     else if (id == kNIL) {
    5212. 

  5212.         return NEW_NIL();
    5213. 

  5213.     }
    5214. 

  5214.     else if (id == kTRUE) {
    5215. 

  5215.         return NEW_TRUE();
    5216. 

  5216.     }
    5217. 

  5217.     else if (id == kFALSE) {
    5218. 

  5218.         return NEW_FALSE();
    5219. 

  5219.     }
    5220. 

  5220.     else if (id == k__FILE__) {
    5221. 

  5221.         return NEW_FILE();
    5222. 

  5222.     }
    5223. 

  5223.     else if (id == k__LINE__) {
    5224. 

  5224.         return NEW_FIXNUM(ruby_sourceline);
    5225. 

  5225.     }
    5226. 

  5226.     else if (is_local_id(id)) {
    5227. 

  5227.         if (local_id(id)) return NEW_LVAR(id);
    5228. 

  5228.         /* method call without arguments */
    5229. 

  5229.         return NEW_VCALL(id);
    5230. 

  5230.     }
    5231. 

  5231.     else if (is_global_id(id)) {
    5232. 

  5232.         return NEW_GVAR(id);
    5233. 

  5233.     }
    5234. 

  5234.     else if (is_instance_id(id)) {
    5235. 

  5235.         return NEW_IVAR(id);
    5236. 

  5236.     }
    5237. 

  5237.     else if (is_const_id(id)) {
    5238. 

  5238.         return NEW_CONST(id);
    5239. 

  5239.     }
    5240. 

  5240.     else if (is_class_id(id)) {
    5241. 

  5241.         return NEW_CVAR(id);
    5242. 

  5242.     }
    5243. 

  5243.     /* FIXME: indicate which identifier. */
    5244. 

  5244.     rb_compile_error(parser_state, "identifier is not valid 1\n");
    5245. 

  5245.     return 0;
    5246. 

  5246. }
    5247. 

  5247. 

  5248. static void
    5249. 

  5249. reset_block(rb_parser_state *parser_state) {
    5250. 

  5250.   if(!variables->block_vars) {
    5251. 

  5251.     variables->block_vars = var_table_create();
    5252. 

  5252.   } else {
    5253. 

  5253.     variables->block_vars = var_table_push(variables->block_vars);
    5254. 

  5254.   }
    5255. 

  5255. }
    5256. 

  5256. 

  5257. static NODE *
    5258. 

  5258. extract_block_vars(rb_parser_state *parser_state, NODE* node, var_table vars)
    5259. 

  5259. {
    5260. 

  5260.     int i;
    5261. 

  5261.     NODE *var, *out = node;
    5262. 

  5262. 

  5263.     // we don't create any DASGN_CURR nodes
    5264. 

  5264.     goto out;
    5265. 

  5265. 

  5266.     if (!node) goto out;
    5267. 

  5267.     if(var_table_size(vars) == 0) goto out;
    5268. 

  5268. 

  5269.     var = NULL;
    5270. 

  5270.     for(i = 0; i < var_table_size(vars); i++) {
    5271. 

  5271.         var = NEW_DASGN_CURR(var_table_get(vars, i), var);
    5272. 

  5272.     }
    5273. 

  5273.     out = block_append(parser_state, var, node);
    5274. 

  5274. 

  5275. out:
    5276. 

  5276.   variables->block_vars = var_table_pop(variables->block_vars);
    5277. 

  5277. 

  5278.   return out;
    5279. 

  5279. }
    5280. 

  5280. 

  5281. static NODE*
    5282. 

  5282. assignable(QUID id, NODE *val, rb_parser_state *parser_state)
    5283. 

  5283. {
    5284. 

  5284.     value_expr(val);
    5285. 

  5285.     if (id == kSELF) {
    5286. 

  5286.         yyerror("Can't change the value of self");
    5287. 

  5287.     }
    5288. 

  5288.     else if (id == kNIL) {
    5289. 

  5289.         yyerror("Can't assign to nil");
    5290. 

  5290.     }
    5291. 

  5291.     else if (id == kTRUE) {
    5292. 

  5292.         yyerror("Can't assign to true");
    5293. 

  5293.     }
    5294. 

  5294.     else if (id == kFALSE) {
    5295. 

  5295.         yyerror("Can't assign to false");
    5296. 

  5296.     }
    5297. 

  5297.     else if (id == k__FILE__) {
    5298. 

  5298.         yyerror("Can't assign to __FILE__");
    5299. 

  5299.     }
    5300. 

  5300.     else if (id == k__LINE__) {
    5301. 

  5301.         yyerror("Can't assign to __LINE__");
    5302. 

  5302.     }
    5303. 

  5303.     else if (is_local_id(id)) {
    5304. 

  5304.         if(variables->block_vars) {
    5305. 

  5305.           var_table_add(variables->block_vars, id);
    5306. 

  5306.         }
    5307. 

  5307.         return NEW_LASGN(id, val);
    5308. 

  5308.     }
    5309. 

  5309.     else if (is_global_id(id)) {
    5310. 

  5310.         return NEW_GASGN(id, val);
    5311. 

  5311.     }
    5312. 

  5312.     else if (is_instance_id(id)) {
    5313. 

  5313.         return NEW_IASGN(id, val);
    5314. 

  5314.     }
    5315. 

  5315.     else if (is_const_id(id)) {
    5316. 

  5316.         if (in_def || in_single)
    5317. 

  5317.             yyerror("dynamic constant assignment");
    5318. 

  5318.         return NEW_CDECL(id, val, 0);
    5319. 

  5319.     }
    5320. 

  5320.     else if (is_class_id(id)) {
    5321. 

  5321.         if (in_def || in_single) return NEW_CVASGN(id, val);
    5322. 

  5322.         return NEW_CVDECL(id, val);
    5323. 

  5323.     }
    5324. 

  5324.     else {
    5325. 

  5325.         /* FIXME: indicate which identifier. */
    5326. 

  5326.         rb_compile_error(parser_state, "identifier is not valid 2 (%d)\n", id);
    5327. 

  5327.     }
    5328. 

  5328.     return 0;
    5329. 

  5329. }
    5330. 

  5330. 

  5331. static NODE *
    5332. 

  5332. aryset(NODE *recv, NODE *idx, rb_parser_state *parser_state)
    5333. 

  5333. {
    5334. 

  5334.     if (recv && nd_type(recv) == NODE_SELF)
    5335. 

  5335.         recv = (NODE *)1;
    5336. 

  5336.     else
    5337. 

  5337.         value_expr(recv);
    5338. 

  5338.     return NEW_ATTRASGN(recv, convert_op(tASET), idx);
    5339. 

  5339. }
    5340. 

  5340. 

  5341. 

  5342. static QUID
    5343. 

  5343. rb_id_attrset(QUID id)
    5344. 

  5344. {
    5345. 

  5345.     id &= ~ID_SCOPE_MASK;
    5346. 

  5346.     id |= ID_ATTRSET;
    5347. 

  5347.     return id;
    5348. 

  5348. }
    5349. 

  5349. 

  5350. static NODE *
    5351. 

  5351. attrset(NODE *recv, QUID id, rb_parser_state *parser_state)
    5352. 

  5352. {
    5353. 

  5353.     if (recv && nd_type(recv) == NODE_SELF)
    5354. 

  5354.         recv = (NODE *)1;
    5355. 

  5355.     else
    5356. 

  5356.         value_expr(recv);
    5357. 

  5357.     return NEW_ATTRASGN(recv, rb_id_attrset(id), 0);
    5358. 

  5358. }
    5359. 

  5359. 

  5360. static void
    5361. 

  5361. rb_backref_error(NODE *node, rb_parser_state *parser_state)
    5362. 

  5362. {
    5363. 

  5363.     switch (nd_type(node)) {
    5364. 

  5364.       case NODE_NTH_REF:
    5365. 

  5365.         rb_compile_error(parser_state, "Can't set variable $%u", node->nd_nth);
    5366. 

  5366.         break;
    5367. 

  5367.       case NODE_BACK_REF:
    5368. 

  5368.         rb_compile_error(parser_state, "Can't set variable $%c", (int)node->nd_nth);
    5369. 

  5369.         break;
    5370. 

  5370.     }
    5371. 

  5371. }
    5372. 

  5372. 

  5373. static NODE *
    5374. 

  5374. arg_concat(rb_parser_state *parser_state, NODE *node1, NODE *node2)
    5375. 

  5375. {
    5376. 

  5376.     if (!node2) return node1;
    5377. 

  5377.     return NEW_ARGSCAT(node1, node2);
    5378. 

  5378. }
    5379. 

  5379. 

  5380. static NODE *
    5381. 

  5381. arg_add(rb_parser_state *parser_state, NODE *node1, NODE *node2)
    5382. 

  5382. {
    5383. 

  5383.     if (!node1) return NEW_LIST(node2);
    5384. 

  5384.     if (nd_type(node1) == NODE_ARRAY) {
    5385. 

  5385.         return list_append(parser_state, node1, node2);
    5386. 

  5386.     }
    5387. 

  5387.     else {
    5388. 

  5388.         return NEW_ARGSPUSH(node1, node2);
    5389. 

  5389.     }
    5390. 

  5390. }
    5391. 

  5391. 

  5392. static NODE*
    5393. 

  5393. node_assign(NODE *lhs, NODE *rhs, rb_parser_state *parser_state)
    5394. 

  5394. {
    5395. 

  5395.     if (!lhs) return 0;
    5396. 

  5396. 

  5397.     value_expr(rhs);
    5398. 

  5398.     switch (nd_type(lhs)) {
    5399. 

  5399.       case NODE_GASGN:
    5400. 

  5400.       case NODE_IASGN:
    5401. 

  5401.       case NODE_LASGN:
    5402. 

  5402.       case NODE_DASGN:
    5403. 

  5403.       case NODE_DASGN_CURR:
    5404. 

  5404.       case NODE_MASGN:
    5405. 

  5405.       case NODE_CDECL:
    5406. 

  5406.       case NODE_CVDECL:
    5407. 

  5407.       case NODE_CVASGN:
    5408. 

  5408.         lhs->nd_value = rhs;
    5409. 

  5409.         break;
    5410. 

  5410. 

  5411.       case NODE_ATTRASGN:
    5412. 

  5412.       case NODE_CALL:
    5413. 

  5413.         lhs->nd_args = arg_add(parser_state, lhs->nd_args, rhs);
    5414. 

  5414.         break;
    5415. 

  5415. 

  5416.       default:
    5417. 

  5417.         /* should not happen */
    5418. 

  5418.         break;
    5419. 

  5419.     }
    5420. 

  5420. 

  5421.     return lhs;
    5422. 

  5422. }
    5423. 

  5423. 

  5424. static int
    5425. 

  5425. value_expr0(NODE *node, rb_parser_state *parser_state)
    5426. 

  5426. {
    5427. 

  5427.     int cond = 0;
    5428. 

  5428. 

  5429.     while (node) {
    5430. 

  5430.         switch (nd_type(node)) {
    5431. 

  5431.           case NODE_DEFN:
    5432. 

  5432.           case NODE_DEFS:
    5433. 

  5433.             parser_warning(parser_state, node, "void value expression");
    5434. 

  5434.             return FALSE;
    5435. 

  5435. 

  5436.           case NODE_RETURN:
    5437. 

  5437.           case NODE_BREAK:
    5438. 

  5438.           case NODE_NEXT:
    5439. 

  5439.           case NODE_REDO:
    5440. 

  5440.           case NODE_RETRY:
    5441. 

  5441.             if (!cond) yyerror("void value expression");
    5442. 

  5442.             /* or "control never reach"? */
    5443. 

  5443.             return FALSE;
    5444. 

  5444. 

  5445.           case NODE_BLOCK:
    5446. 

  5446.             while (node->nd_next) {
    5447. 

  5447.                 node = node->nd_next;
    5448. 

  5448.             }
    5449. 

  5449.             node = node->nd_head;
    5450. 

  5450.             break;
    5451. 

  5451. 

  5452.           case NODE_BEGIN:
    5453. 

  5453.             node = node->nd_body;
    5454. 

  5454.             break;
    5455. 

  5455. 

  5456.           case NODE_IF:
    5457. 

  5457.             if (!value_expr(node->nd_body)) return FALSE;
    5458. 

  5458.             node = node->nd_else;
    5459. 

  5459.             break;
    5460. 

  5460. 

  5461.           case NODE_AND:
    5462. 

  5462.           case NODE_OR:
    5463. 

  5463.             cond = 1;
    5464. 

  5464.             node = node->nd_2nd;
    5465. 

  5465.             break;
    5466. 

  5466. 

  5467.           case NODE_NEWLINE:
    5468. 

  5468.             node = node->nd_next;
    5469. 

  5469.             break;
    5470. 

  5470. 

  5471.           default:
    5472. 

  5472.             return TRUE;
    5473. 

  5473.         }
    5474. 

  5474.     }
    5475. 

  5475. 

  5476.     return TRUE;
    5477. 

  5477. }
    5478. 

  5478. 

  5479. static void
    5480. 

  5480. void_expr0(NODE *node, rb_parser_state *parser_state)
    5481. 

  5481. {
    5482. 

  5482.   const char *useless = NULL;
    5483. 

  5483. 

  5484.     if (!verbose) return;
    5485. 

  5485. 

  5486.   again:
    5487. 

  5487.     if (!node) return;
    5488. 

  5488.     switch (nd_type(node)) {
    5489. 

  5489.       case NODE_NEWLINE:
    5490. 

  5490.         node = node->nd_next;
    5491. 

  5491.         goto again;
    5492. 

  5492. 

  5493.       case NODE_CALL:
    5494. 

  5494.         switch (node->nd_mid) {
    5495. 

  5495.           case '+':
    5496. 

  5496.           case '-':
    5497. 

  5497.           case '*':
    5498. 

  5498.           case '/':
    5499. 

  5499.           case '%':
    5500. 

  5500.           case tPOW:
    5501. 

  5501.           case tUPLUS:
    5502. 

  5502.           case tUMINUS:
    5503. 

  5503.           case '|':
    5504. 

  5504.           case '^':
    5505. 

  5505.           case '&':
    5506. 

  5506.           case tCMP:
    5507. 

  5507.           case '>':
    5508. 

  5508.           case tGEQ:
    5509. 

  5509.           case '<':
    5510. 

  5510.           case tLEQ:
    5511. 

  5511.           case tEQ:
    5512. 

  5512.           case tNEQ:
    5513. 

  5513.             useless = "";
    5514. 

  5514.             break;
    5515. 

  5515.         }
    5516. 

  5516.         break;
    5517. 

  5517. 

  5518.       case NODE_LVAR:
    5519. 

  5519.       case NODE_DVAR:
    5520. 

  5520.       case NODE_GVAR:
    5521. 

  5521.       case NODE_IVAR:
    5522. 

  5522.       case NODE_CVAR:
    5523. 

  5523.       case NODE_NTH_REF:
    5524. 

  5524.       case NODE_BACK_REF:
    5525. 

  5525.         useless = "a variable";
    5526. 

  5526.         break;
    5527. 

  5527.       case NODE_CONST:
    5528. 

  5528.       case NODE_CREF:
    5529. 

  5529.         useless = "a constant";
    5530. 

  5530.         break;
    5531. 

  5531.       case NODE_LIT:
    5532. 

  5532.       case NODE_STR:
    5533. 

  5533.       case NODE_DSTR:
    5534. 

  5534.       case NODE_DREGX:
    5535. 

  5535.       case NODE_DREGX_ONCE:
    5536. 

  5536.         useless = "a literal";
    5537. 

  5537.         break;
    5538. 

  5538.       case NODE_COLON2:
    5539. 

  5539.       case NODE_COLON3:
    5540. 

  5540.         useless = "::";
    5541. 

  5541.         break;
    5542. 

  5542.       case NODE_DOT2:
    5543. 

  5543.         useless = "..";
    5544. 

  5544.         break;
    5545. 

  5545.       case NODE_DOT3:
    5546. 

  5546.         useless = "...";
    5547. 

  5547.         break;
    5548. 

  5548.       case NODE_SELF:
    5549. 

  5549.         useless = "self";
    5550. 

  5550.         break;
    5551. 

  5551.       case NODE_NIL:
    5552. 

  5552.         useless = "nil";
    5553. 

  5553.         break;
    5554. 

  5554.       case NODE_TRUE:
    5555. 

  5555.         useless = "true";
    5556. 

  5556.         break;
    5557. 

  5557.       case NODE_FALSE:
    5558. 

  5558.         useless = "false";
    5559. 

  5559.         break;
    5560. 

  5560.       case NODE_DEFINED:
    5561. 

  5561.         useless = "defined?";
    5562. 

  5562.         break;
    5563. 

  5563.     }
    5564. 

  5564. 

  5565.     if (useless) {
    5566. 

  5566.         int line = ruby_sourceline;
    5567. 

  5567. 

  5568.         ruby_sourceline = nd_line(node);
    5569. 

  5569.         rb_warn("useless use of %s in void context", useless);
    5570. 

  5570.         ruby_sourceline = line;
    5571. 

  5571.     }
    5572. 

  5572. }
    5573. 

  5573. 

  5574. static void
    5575. 

  5575. void_stmts(NODE *node, rb_parser_state *parser_state)
    5576. 

  5576. {
    5577. 

  5577.     if (!verbose) return;
    5578. 

  5578.     if (!node) return;
    5579. 

  5579.     if (nd_type(node) != NODE_BLOCK) return;
    5580. 

  5580. 

  5581.     for (;;) {
    5582. 

  5582.         if (!node->nd_next) return;
    5583. 

  5583.         void_expr(node->nd_head);
    5584. 

  5584.         node = node->nd_next;
    5585. 

  5585.     }
    5586. 

  5586. }
    5587. 

  5587. 

  5588. static NODE *
    5589. 

  5589. remove_begin(NODE *node, rb_parser_state *parser_state)
    5590. 

  5590. {
    5591. 

  5591.     NODE **n = &node;
    5592. 

  5592.     while (*n) {
    5593. 

  5593.         switch (nd_type(*n)) {
    5594. 

  5594.           case NODE_NEWLINE:
    5595. 

  5595.             n = &(*n)->nd_next;
    5596. 

  5596.             continue;
    5597. 

  5597.           case NODE_BEGIN:
    5598. 

  5598.             *n = (*n)->nd_body;
    5599. 

  5599.           default:
    5600. 

  5600.             return node;
    5601. 

  5601.         }
    5602. 

  5602.     }
    5603. 

  5603.     return node;
    5604. 

  5604. }
    5605. 

  5605. 

  5606. static int
    5607. 

  5607. assign_in_cond(NODE *node, rb_parser_state *parser_state)
    5608. 

  5608. {
    5609. 

  5609.     switch (nd_type(node)) {
    5610. 

  5610.       case NODE_MASGN:
    5611. 

  5611.         yyerror("multiple assignment in conditional");
    5612. 

  5612.         return 1;
    5613. 

  5613. 

  5614.       case NODE_LASGN:
    5615. 

  5615.       case NODE_DASGN:
    5616. 

  5616.       case NODE_GASGN:
    5617. 

  5617.       case NODE_IASGN:
    5618. 

  5618.         break;
    5619. 

  5619. 

  5620.       case NODE_NEWLINE:
    5621. 

  5621.       default:
    5622. 

  5622.         return 0;
    5623. 

  5623.     }
    5624. 

  5624. 

  5625.     switch (nd_type(node->nd_value)) {
    5626. 

  5626.       case NODE_LIT:
    5627. 

  5627.       case NODE_STR:
    5628. 

  5628.       case NODE_NIL:
    5629. 

  5629.       case NODE_TRUE:
    5630. 

  5630.       case NODE_FALSE:
    5631. 

  5631.         return 1;
    5632. 

  5632. 

  5633.       case NODE_DSTR:
    5634. 

  5634.       case NODE_XSTR:
    5635. 

  5635.       case NODE_DXSTR:
    5636. 

  5636.       case NODE_EVSTR:
    5637. 

  5637.       case NODE_DREGX:
    5638. 

  5638.       default:
    5639. 

  5639.         break;
    5640. 

  5640.     }
    5641. 

  5641.     return 1;
    5642. 

  5642. }
    5643. 

  5643. 

  5644. static int
    5645. 

  5645. parser_e_option_supplied(rb_parser_state* parser_state)
    5646. 

  5646. {
    5647. 

  5647.     if (strcmp(ruby_sourcefile, "-e") == 0)
    5648. 

  5648.         return TRUE;
    5649. 

  5649.     return FALSE;
    5650. 

  5650. }
    5651. 

  5651. 

  5652. #define e_option_supplied()   parser_e_option_supplied(parser_state)
    5653. 

  5653. 

  5654. static void
    5655. 

  5655. warn_unless_e_option(rb_parser_state *parser_state, NODE *node, const char *str)
    5656. 

  5656. {
    5657. 

  5657.     if (!e_option_supplied()) parser_warning(parser_state, node, str);
    5658. 

  5658. }
    5659. 

  5659. 

  5660. static NODE *cond0(NODE *node, rb_parser_state *parser_state);
    5661. 

  5661. 

  5662. static NODE*
    5663. 

  5663. range_op(NODE *node, rb_parser_state *parser_state)
    5664. 

  5664. {
    5665. 

  5665.     enum node_type type;
    5666. 

  5666. 

  5667.     if (!e_option_supplied()) return node;
    5668. 

  5668.     if (node == 0) return 0;
    5669. 

  5669. 

  5670.     value_expr(node);
    5671. 

  5671.     node = cond0(node, parser_state);
    5672. 

  5672.     type = (enum node_type)nd_type(node);
    5673. 

  5673.     if (type == NODE_NEWLINE) {
    5674. 

  5674.         node = node->nd_next;
    5675. 

  5675.         type = (enum node_type)nd_type(node);
    5676. 

  5676.     }
    5677. 

  5677.     if (type == NODE_LIT && FIXNUM_P(node->nd_lit)) {
    5678. 

  5678.         warn_unless_e_option(parser_state, node, "integer literal in conditional range");
    5679. 

  5679.         return call_op(node,tEQ,1,NEW_GVAR(rb_parser_sym("$.")), parser_state);
    5680. 

  5680.     }
    5681. 

  5681.     return node;
    5682. 

  5682. }
    5683. 

  5683. 

  5684. static int
    5685. 

  5685. literal_node(NODE *node)
    5686. 

  5686. {
    5687. 

  5687.     if (!node) return 1;        /* same as NODE_NIL */
    5688. 

  5688.     switch (nd_type(node)) {
    5689. 

  5689.       case NODE_LIT:
    5690. 

  5690.       case NODE_STR:
    5691. 

  5691.       case NODE_DSTR:
    5692. 

  5692.       case NODE_EVSTR:
    5693. 

  5693.       case NODE_DREGX:
    5694. 

  5694.       case NODE_DREGX_ONCE:
    5695. 

  5695.       case NODE_DSYM:
    5696. 

  5696.         return 2;
    5697. 

  5697.       case NODE_TRUE:
    5698. 

  5698.       case NODE_FALSE:
    5699. 

  5699.       case NODE_NIL:
    5700. 

  5700.         return 1;
    5701. 

  5701.     }
    5702. 

  5702.     return 0;
    5703. 

  5703. }
    5704. 

  5704. 

  5705. static NODE*
    5706. 

  5706. cond0(NODE *node, rb_parser_state *parser_state)
    5707. 

  5707. {
    5708. 

  5708.     if (node == 0) return 0;
    5709. 

  5709.     assign_in_cond(node, parser_state);
    5710. 

  5710. 

  5711.     switch (nd_type(node)) {
    5712. 

  5712.       case NODE_DSTR:
    5713. 

  5713.       case NODE_EVSTR:
    5714. 

  5714.       case NODE_STR:
    5715. 

  5715.         break;
    5716. 

  5716. 

  5717.       case NODE_DREGX:
    5718. 

  5718.       case NODE_DREGX_ONCE:
    5719. 

  5719.         local_cnt('_');
    5720. 

  5720.         local_cnt('~');
    5721. 

  5721.         return NEW_MATCH2(node, NEW_GVAR(rb_parser_sym("$_")));
    5722. 

  5722. 

  5723.       case NODE_AND:
    5724. 

  5724.       case NODE_OR:
    5725. 

  5725.         node->nd_1st = cond0(node->nd_1st, parser_state);
    5726. 

  5726.         node->nd_2nd = cond0(node->nd_2nd, parser_state);
    5727. 

  5727.         break;
    5728. 

  5728. 

  5729.       case NODE_DOT2:
    5730. 

  5730.       case NODE_DOT3:
    5731. 

  5731.         node->nd_beg = range_op(node->nd_beg, parser_state);
    5732. 

  5732.         node->nd_end = range_op(node->nd_end, parser_state);
    5733. 

  5733.         if (nd_type(node) == NODE_DOT2) nd_set_type(node,NODE_FLIP2);
    5734. 

  5734.         else if (nd_type(node) == NODE_DOT3) nd_set_type(node, NODE_FLIP3);
    5735. 

  5735.         if (!e_option_supplied()) {
    5736. 

  5736.             int b = literal_node(node->nd_beg);
    5737. 

  5737.             int e = literal_node(node->nd_end);
    5738. 

  5738.             if ((b == 1 && e == 1) || (b + e >= 2 && verbose)) {
    5739. 

  5739.             }
    5740. 

  5740.         }
    5741. 

  5741.         break;
    5742. 

  5742. 

  5743.       case NODE_DSYM:
    5744. 

  5744.         break;
    5745. 

  5745. 

  5746.       case NODE_REGEX:
    5747. 

  5747.         nd_set_type(node, NODE_MATCH);
    5748. 

  5748.         local_cnt('_');
    5749. 

  5749.         local_cnt('~');
    5750. 

  5750.       default:
    5751. 

  5751.         break;
    5752. 

  5752.     }
    5753. 

  5753.     return node;
    5754. 

  5754. }
    5755. 

  5755. 

  5756. static NODE*
    5757. 

  5757. cond(NODE *node, rb_parser_state *parser_state)
    5758. 

  5758. {
    5759. 

  5759.     if (node == 0) return 0;
    5760. 

  5760.     value_expr(node);
    5761. 

  5761.     if (nd_type(node) == NODE_NEWLINE){
    5762. 

  5762.         node->nd_next = cond0(node->nd_next, parser_state);
    5763. 

  5763.         return node;
    5764. 

  5764.     }
    5765. 

  5765.     return cond0(node, parser_state);
    5766. 

  5766. }
    5767. 

  5767. 

  5768. static NODE*
    5769. 

  5769. logop(enum node_type type, NODE *left, NODE *right, rb_parser_state *parser_state)
    5770. 

  5770. {
    5771. 

  5771.     value_expr(left);
    5772. 

  5772.     if (left && nd_type(left) == type) {
    5773. 

  5773.         NODE *node = left, *second;
    5774. 

  5774.         while ((second = node->nd_2nd) != 0 && nd_type(second) == type) {
    5775. 

  5775.             node = second;
    5776. 

  5776.         }
    5777. 

  5777.         node->nd_2nd = NEW_NODE(type, second, right, 0);
    5778. 

  5778.         return left;
    5779. 

  5779.     }
    5780. 

  5780.     return NEW_NODE(type, left, right, 0);
    5781. 

  5781. }
    5782. 

  5782. 

  5783. static int
    5784. 

  5784. cond_negative(NODE **nodep)
    5785. 

  5785. {
    5786. 

  5786.     NODE *c = *nodep;
    5787. 

  5787. 

  5788.     if (!c) return 0;
    5789. 

  5789.     switch (nd_type(c)) {
    5790. 

  5790.       case NODE_NOT:
    5791. 

  5791.         *nodep = c->nd_body;
    5792. 

  5792.         return 1;
    5793. 

  5793.       case NODE_NEWLINE:
    5794. 

  5794.         if (c->nd_next && nd_type(c->nd_next) == NODE_NOT) {
    5795. 

  5795.             c->nd_next = c->nd_next->nd_body;
    5796. 

  5796.             return 1;
    5797. 

  5797.         }
    5798. 

  5798.     }
    5799. 

  5799.     return 0;
    5800. 

  5800. }
    5801. 

  5801. 

  5802. static void
    5803. 

  5803. no_blockarg(rb_parser_state *parser_state, NODE *node)
    5804. 

  5804. {
    5805. 

  5805.     if (node && nd_type(node) == NODE_BLOCK_PASS) {
    5806. 

  5806.         rb_compile_error(parser_state, "block argument should not be given");
    5807. 

  5807.     }
    5808. 

  5808. }
    5809. 

  5809. 

  5810. static NODE *
    5811. 

  5811. ret_args(rb_parser_state *parser_state, NODE *node)
    5812. 

  5812. {
    5813. 

  5813.     if (node) {
    5814. 

  5814.         no_blockarg(parser_state, node);
    5815. 

  5815.         if (nd_type(node) == NODE_ARRAY && node->nd_next == 0) {
    5816. 

  5816.             node = node->nd_head;
    5817. 

  5817.         }
    5818. 

  5818.         if (node && nd_type(node) == NODE_SPLAT) {
    5819. 

  5819.             node = NEW_SVALUE(node);
    5820. 

  5820.         }
    5821. 

  5821.     }
    5822. 

  5822.     return node;
    5823. 

  5823. }
    5824. 

  5824. 

  5825. static NODE *
    5826. 

  5826. new_yield(rb_parser_state *parser_state, NODE *node)
    5827. 

  5827. {
    5828. 

  5828.     VALUE state = Qtrue;
    5829. 

  5829. 

  5830.     if (node) {
    5831. 

  5831.         no_blockarg(parser_state, node);
    5832. 

  5832.         if (nd_type(node) == NODE_ARRAY && node->nd_next == 0) {
    5833. 

  5833.             node = node->nd_head;
    5834. 

  5834.             state = Qfalse;
    5835. 

  5835.         }
    5836. 

  5836.         if (node && nd_type(node) == NODE_SPLAT) {
    5837. 

  5837.             state = Qtrue;
    5838. 

  5838.         }
    5839. 

  5839.     }
    5840. 

  5840.     else {
    5841. 

  5841.         state = Qfalse;
    5842. 

  5842.     }
    5843. 

  5843.     return NEW_YIELD(node, state);
    5844. 

  5844. }
    5845. 

  5845. 

  5846. static NODE *
    5847. 

  5847. arg_blk_pass(NODE *node1, NODE *node2)
    5848. 

  5848. {
    5849. 

  5849.     if (node2) {
    5850. 

  5850.         node2->nd_head = node1;
    5851. 

  5851.         return node2;
    5852. 

  5852.     }
    5853. 

  5853.     return node1;
    5854. 

  5854. }
    5855. 

  5855. 

  5856. static NODE*
    5857. 

  5857. arg_prepend(rb_parser_state *parser_state, NODE *node1, NODE *node2)
    5858. 

  5858. {
    5859. 

  5859.     switch (nd_type(node2)) {
    5860. 

  5860.       case NODE_ARRAY:
    5861. 

  5861.         return list_concat(NEW_LIST(node1), node2);
    5862. 

  5862. 

  5863.       case NODE_SPLAT:
    5864. 

  5864.         return arg_concat(parser_state, node1, node2->nd_head);
    5865. 

  5865. 

  5866.       case NODE_BLOCK_PASS:
    5867. 

  5867.         node2->nd_body = arg_prepend(parser_state, node1, node2->nd_body);
    5868. 

  5868.         return node2;
    5869. 

  5869. 

  5870.       default:
    5871. 

  5871.         printf("unknown nodetype(%d) for arg_prepend", nd_type(node2));
    5872. 

  5872.         abort();
    5873. 

  5873.     }
    5874. 

  5874.     return 0;                   /* not reached */
    5875. 

  5875. }
    5876. 

  5876. 

  5877. static NODE*
    5878. 

  5878. new_call(rb_parser_state *parser_state,NODE *r,QUID m,NODE *a)
    5879. 

  5879. {
    5880. 

  5880.     if (a && nd_type(a) == NODE_BLOCK_PASS) {
    5881. 

  5881.         a->nd_iter = NEW_CALL(r,convert_op(m),a->nd_head);
    5882. 

  5882.         return a;
    5883. 

  5883.     }
    5884. 

  5884.     return NEW_CALL(r,convert_op(m),a);
    5885. 

  5885. }
    5886. 

  5886. 

  5887. static NODE*
    5888. 

  5888. new_fcall(rb_parser_state *parser_state,QUID m,NODE *a)
    5889. 

  5889. {
    5890. 

  5890.     if (a && nd_type(a) == NODE_BLOCK_PASS) {
    5891. 

  5891.         a->nd_iter = NEW_FCALL(m,a->nd_head);
    5892. 

  5892.         return a;
    5893. 

  5893.     }
    5894. 

  5894.     return NEW_FCALL(m,a);
    5895. 

  5895. }
    5896. 

  5896. 

  5897. static NODE*
    5898. 

  5898. new_super(rb_parser_state *parser_state,NODE *a)
    5899. 

  5899. {
    5900. 

  5900.     if (a && nd_type(a) == NODE_BLOCK_PASS) {
    5901. 

  5901.         a->nd_iter = NEW_SUPER(a->nd_head);
    5902. 

  5902.         return a;
    5903. 

  5903.     }
    5904. 

  5904.     return NEW_SUPER(a);
    5905. 

  5905. }
    5906. 

  5906. 

  5907. 

  5908. static void
    5909. 

  5909. mel_local_push(rb_parser_state *parser_state, int cnt)
    5910. 

  5910. {
    5911. 

  5911.     variables = LocalState::push(variables);
    5912. 

  5912. }
    5913. 

  5913. 

  5914. static void
    5915. 

  5915. mel_local_pop(rb_parser_state *parser_state)
    5916. 

  5916. {
    5917. 

  5917.     variables = LocalState::pop(variables);
    5918. 

  5918. }
    5919. 

  5919. 

  5920. 

  5921. static QUID*
    5922. 

  5922. mel_local_tbl(rb_parser_state *parser_state)
    5923. 

  5923. {
    5924. 

  5924.     QUID *lcl_tbl;
    5925. 

  5925.     var_table tbl;
    5926. 

  5926.     int i, len;
    5927. 

  5927.     tbl = variables->local_vars;
    5928. 

  5928.     len = var_table_size(tbl);
    5929. 

  5929.     lcl_tbl = (QUID*)pt_allocate(parser_state, (int)(sizeof(QUID) * (len + 3)));
    5930. 

  5930.     lcl_tbl[0] = (QUID)len;
    5931. 

  5931.     lcl_tbl[1] = '_';
    5932. 

  5932.     lcl_tbl[2] = '~';
    5933. 

  5933.     for(i = 0; i < len; i++) {
    5934. 

  5934.         lcl_tbl[i + 3] = var_table_get(tbl, i);
    5935. 

  5935.     }
    5936. 

  5936.     return lcl_tbl;
    5937. 

  5937. }
    5938. 

  5938. 

  5939. static intptr_t
    5940. 

  5940. mel_local_cnt(rb_parser_state *parser_state, QUID id)
    5941. 

  5941. {
    5942. 

  5942.     int idx;
    5943. 

  5943.     /* Leave these hardcoded here because they arne't REALLY ids at all. */
    5944. 

  5944.     if(id == '_') {
    5945. 

  5945.         return 0;
    5946. 

  5946.     } else if(id == '~') {
    5947. 

  5947.         return 1;
    5948. 

  5948.     }
    5949. 

  5949. 

  5950.     // if there are block variables, check to see if there is already
    5951. 

  5951.     // a local by this name. If not, create one in the top block_vars
    5952. 

  5952.     // table.
    5953. 

  5953.     if(variables->block_vars) {
    5954. 

  5954.       idx = var_table_find_chained(variables->block_vars, id);
    5955. 

  5955.       if(idx >= 0) {
    5956. 

  5956.         return idx;
    5957. 

  5957.       } else {
    5958. 

  5958.         return var_table_add(variables->block_vars, id);
    5959. 

  5959.       }
    5960. 

  5960.     }
    5961. 

  5961. 

  5962.     idx = var_table_find(variables->local_vars, id);
    5963. 

  5963.     if(idx >= 0) {
    5964. 

  5964.       return idx + 2;
    5965. 

  5965.     }
    5966. 

  5966. 

  5967.     return var_table_add(variables->local_vars, id);
    5968. 

  5968. }
    5969. 

  5969. 

  5970. static int
    5971. 

  5971. mel_local_id(rb_parser_state *parser_state, QUID id)
    5972. 

  5972. {
    5973. 

  5973.     if(variables->block_vars) {
    5974. 

  5974.       if(var_table_find_chained(variables->block_vars, id) >= 0) return 1;
    5975. 

  5975.     }
    5976. 

  5976. 

  5977.     if(var_table_find(variables->local_vars, id) >= 0) return 1;
    5978. 

  5978.     return 0;
    5979. 

  5979. }
    5980. 

  5980. 

  5981. static QUID
    5982. 

  5982. rb_parser_sym(const char *name)
    5983. 

  5983. {
    5984. 

  5984.     const char *m = name;
    5985. 

  5985.     QUID id, pre, qrk, bef;
    5986. 

  5986.     int last;
    5987. 

  5987. 

  5988.     id = 0;
    5989. 

  5989.     last = (int)strlen(name)-1;
    5990. 

  5990.     switch (*name) {
    5991. 

  5991.       case '$':
    5992. 

  5992.         id |= ID_GLOBAL;
    5993. 

  5993.         m++;
    5994. 

  5994.         if(!m[0]) { // Detect a :"$"
    5995. 

  5995.           id = ID_LOCAL;
    5996. 

  5996.         } else if (!is_identchar(*m)) {
    5997. 

  5997.           m++;
    5998. 

  5998.         }
    5999. 

  5999.         break;
    6000. 

  6000.       case '@':
    6001. 

  6001.         if (name[1] == '@') {
    6002. 

  6002.             m++;
    6003. 

  6003.             id |= ID_CLASS;
    6004. 

  6004.         }
    6005. 

  6005.         else {
    6006. 

  6006.             id |= ID_INSTANCE;
    6007. 

  6007.         }
    6008. 

  6008.         m++;
    6009. 

  6009.         break;
    6010. 

  6010.       default:
    6011. 

  6011.         if (name[0] != '_' && !ISALPHA(name[0]) && !ismbchar(name[0])) {
    6012. 

  6012.             int i;
    6013. 

  6013. 

  6014.             for (i=0; op_tbl[i].token; i++) {
    6015. 

  6015.                 if (*op_tbl[i].name == *name &&
    6016. 

  6016.                     strcmp(op_tbl[i].name, name) == 0) {
    6017. 

  6017.                     id = op_tbl[i].token;
    6018. 

  6018.                     return id;
    6019. 

  6019.                 }
    6020. 

  6020.             }
    6021. 

  6021.         }
    6022. 

  6022. 

  6023.         if (name[last] == '=') {
    6024. 

  6024.             id = ID_ATTRSET;
    6025. 

  6025.         }
    6026. 

  6026.         else if (ISUPPER(name[0])) {
    6027. 

  6027.             id = ID_CONST;
    6028. 

  6028.         }
    6029. 

  6029.         else {
    6030. 

  6030.             id = ID_LOCAL;
    6031. 

  6031.         }
    6032. 

  6032.         break;
    6033. 

  6033.     }
    6034. 

  6034.     while (m <= name + last && is_identchar(*m)) {
    6035. 

  6035.         m += mbclen(*m);
    6036. 

  6036.     }
    6037. 

  6037.     if (*m) id = ID_JUNK;
    6038. 

  6038.     qrk = (QUID)quark_from_string(name);
    6039. 

  6039.     pre = qrk + tLAST_TOKEN;
    6040. 

  6040.     bef = id;
    6041. 

  6041.     id |= ( pre << ID_SCOPE_SHIFT );
    6042. 

  6042.     return id;
    6043. 

  6043. }
    6044. 

  6044. 

  6045. static int
    6046. 

  6046. scan_oct(const char *start, int len, int *retlen)
    6047. 

  6047. {
    6048. 

  6048.     register const char *s = start;
    6049. 

  6049.     register int retval = 0;
    6050. 

  6050. 

  6051.     while (len-- && *s >= '0' && *s <= '7') {
    6052. 

  6052.         retval <<= 3;
    6053. 

  6053.         retval |= *s++ - '0';
    6054. 

  6054.     }
    6055. 

  6055.     *retlen = (int)(s - start);
    6056. 

  6056.     return retval;
    6057. 

  6057. }
    6058. 

  6058. 

  6059. static int
    6060. 

  6060. scan_hex(const char *start, int len, int *retlen)
    6061. 

  6061. {
    6062. 

  6062.     static const char hexdigit[] = "0123456789abcdef0123456789ABCDEF";
    6063. 

  6063.     register const char *s = start;
    6064. 

  6064.     register int retval = 0;
    6065. 

  6065.     const char *tmp;
    6066. 

  6066. 

  6067.     while (len-- && *s && (tmp = strchr(hexdigit, *s))) {
    6068. 

  6068.         retval <<= 4;
    6069. 

  6069.         retval |= (int)((tmp - hexdigit) & 15);
    6070. 

  6070.         s++;
    6071. 

  6071.     }
    6072. 

  6072.     *retlen = (int)(s - start);
    6073. 

  6073.     return retval;
    6074. 

  6074. }
    6075. 

  6075. 

  6076. const char *op_to_name(QUID id) {
    6077. 

  6077.   if(id < tLAST_TOKEN) {
    6078. 

  6078.     int i = 0;
    6079. 

  6079. 

  6080.     for (i=0; op_tbl[i].token; i++) {
    6081. 

  6081.         if (op_tbl[i].token == id)
    6082. 

  6082.             return op_tbl[i].name;
    6083. 

  6083.     }
    6084. 

  6084.   }
    6085. 

  6085.   return NULL;
    6086. 

  6086. }
    6087. 

  6087. quark id_to_quark(QUID id) {
    6088. 

  6088.   quark qrk;
    6089. 

  6089. 

  6090.   qrk = (quark)((id >> ID_SCOPE_SHIFT) - tLAST_TOKEN);
    6091. 

  6091.   return qrk;
    6092. 

  6092. }
    6093. 

  6093. 

  6094. }; // namespace grammar18
    6095. 

  6095. }; // namespace melbourne
    6096. 

  6096.