PageRenderTime 170ms CodeModel.GetById 33ms RepoModel.GetById 1ms app.codeStats 0ms

/vm/parser/grammar.y

https://github.com/marnen/rubinius
Happy | 5824 lines | 5319 code | 505 blank | 0 comment | 0 complexity | d209f2aa0306d73b42ccf033d3c0c404 MD5 | raw file
Possible License(s): BSD-3-Clause, GPL-2.0, BSD-2-Clause, LGPL-2.1, JSON

Large files files are truncated, but you can click here to view the full file

  1. /**********************************************************************
  2. parse.y -
  3. $Author: matz $
  4. $Date: 2004/11/29 06:13:51 $
  5. created at: Fri May 28 18:02:42 JST 1993
  6. Copyright (C) 1993-2003 Yukihiro Matsumoto
  7. **********************************************************************/
  8. %{
  9. #define YYDEBUG 1
  10. #define YYERROR_VERBOSE 1
  11. #include <stdio.h>
  12. #include <errno.h>
  13. #include <ctype.h>
  14. #include <string.h>
  15. #include <stdbool.h>
  16. #include "builtin/array.hpp"
  17. #include "parser/grammar_internal.hpp"
  18. #include "parser/grammar_runtime.hpp"
  19. #include "objectmemory.hpp"
  20. namespace rubinius {
  21. namespace parser {
  22. #undef VALUE
  23. #ifndef isnumber
  24. #define isnumber isdigit
  25. #endif
  26. #define ISALPHA isalpha
  27. #define ISSPACE isspace
  28. #define ISALNUM(x) (isalpha(x) || isnumber(x))
  29. #define ISDIGIT isdigit
  30. #define ISXDIGIT isxdigit
  31. #define ISUPPER isupper
  32. #define ismbchar(c) (0)
  33. #define mbclen(c) (1)
  34. #define ID2SYM(i) (Object*)i
  35. #define string_new(ptr, len) blk2bstr(ptr, len)
  36. #define string_new2(ptr) cstr2bstr(ptr)
  37. intptr_t syd_sourceline;
  38. static char *syd_sourcefile;
  39. #define ruby_sourceline syd_sourceline
  40. #define ruby_sourcefile syd_sourcefile
  41. static int
  42. syd_yyerror(const char *, rb_parse_state*);
  43. #define yyparse syd_yyparse
  44. #define yylex syd_yylex
  45. #define yyerror(str) syd_yyerror(str, (rb_parse_state*)parse_state)
  46. #define yylval syd_yylval
  47. #define yychar syd_yychar
  48. #define yydebug syd_yydebug
  49. #define YYPARSE_PARAM parse_state
  50. #define YYLEX_PARAM parse_state
  51. #define ID_SCOPE_SHIFT 3
  52. #define ID_SCOPE_MASK 0x07
  53. #define ID_LOCAL 0x01
  54. #define ID_INSTANCE 0x02
  55. #define ID_GLOBAL 0x03
  56. #define ID_ATTRSET 0x04
  57. #define ID_CONST 0x05
  58. #define ID_CLASS 0x06
  59. #define ID_JUNK 0x07
  60. #define ID_INTERNAL ID_JUNK
  61. #define is_notop_id(id) ((id)>tLAST_TOKEN)
  62. #define is_local_id(id) (is_notop_id(id)&&((id)&ID_SCOPE_MASK)==ID_LOCAL)
  63. #define is_global_id(id) (is_notop_id(id)&&((id)&ID_SCOPE_MASK)==ID_GLOBAL)
  64. #define is_instance_id(id) (is_notop_id(id)&&((id)&ID_SCOPE_MASK)==ID_INSTANCE)
  65. #define is_attrset_id(id) (is_notop_id(id)&&((id)&ID_SCOPE_MASK)==ID_ATTRSET)
  66. #define is_const_id(id) (is_notop_id(id)&&((id)&ID_SCOPE_MASK)==ID_CONST)
  67. #define is_class_id(id) (is_notop_id(id)&&((id)&ID_SCOPE_MASK)==ID_CLASS)
  68. #define is_junk_id(id) (is_notop_id(id)&&((id)&ID_SCOPE_MASK)==ID_JUNK)
  69. #define is_asgn_or_id(id) ((is_notop_id(id)) && \
  70. (((id)&ID_SCOPE_MASK) == ID_GLOBAL || \
  71. ((id)&ID_SCOPE_MASK) == ID_INSTANCE || \
  72. ((id)&ID_SCOPE_MASK) == ID_CLASS))
  73. /* FIXME these went into the ruby_state instead of parse_state
  74. because a ton of other crap depends on it
  75. char *ruby_sourcefile; current source file
  76. int ruby_sourceline; current line no.
  77. */
  78. static int yylex(void*, void *);
  79. #define BITSTACK_PUSH(stack, n) (stack = (stack<<1)|((n)&1))
  80. #define BITSTACK_POP(stack) (stack >>= 1)
  81. #define BITSTACK_LEXPOP(stack) (stack = (stack >> 1) | (stack & 1))
  82. #define BITSTACK_SET_P(stack) (stack&1)
  83. #define COND_PUSH(n) BITSTACK_PUSH(vps->cond_stack, n)
  84. #define COND_POP() BITSTACK_POP(vps->cond_stack)
  85. #define COND_LEXPOP() BITSTACK_LEXPOP(vps->cond_stack)
  86. #define COND_P() BITSTACK_SET_P(vps->cond_stack)
  87. #define CMDARG_PUSH(n) BITSTACK_PUSH(vps->cmdarg_stack, n)
  88. #define CMDARG_POP() BITSTACK_POP(vps->cmdarg_stack)
  89. #define CMDARG_LEXPOP() BITSTACK_LEXPOP(vps->cmdarg_stack)
  90. #define CMDARG_P() BITSTACK_SET_P(vps->cmdarg_stack)
  91. /*
  92. static int class_nest = 0;
  93. static int in_single = 0;
  94. static int in_def = 0;
  95. static int compile_for_eval = 0;
  96. static ID cur_mid = 0;
  97. */
  98. static NODE *cond(NODE*,rb_parse_state*);
  99. static NODE *logop(enum node_type,NODE*,NODE*,rb_parse_state*);
  100. static int cond_negative(NODE**);
  101. static NODE *newline_node(rb_parse_state*,NODE*);
  102. static void fixpos(NODE*,NODE*);
  103. static int value_expr0(NODE*,rb_parse_state*);
  104. static void void_expr0(NODE *);
  105. static void void_stmts(NODE*,rb_parse_state*);
  106. static NODE *remove_begin(NODE*,rb_parse_state*);
  107. #define value_expr(node) value_expr0((node) = \
  108. remove_begin(node, (rb_parse_state*)parse_state), \
  109. (rb_parse_state*)parse_state)
  110. #define void_expr(node) void_expr0((node) = remove_begin(node, (rb_parse_state*)parse_state))
  111. static NODE *block_append(rb_parse_state*,NODE*,NODE*);
  112. static NODE *list_append(rb_parse_state*,NODE*,NODE*);
  113. static NODE *list_concat(NODE*,NODE*);
  114. static NODE *arg_concat(rb_parse_state*,NODE*,NODE*);
  115. static NODE *arg_prepend(rb_parse_state*,NODE*,NODE*);
  116. static NODE *literal_concat(rb_parse_state*,NODE*,NODE*);
  117. static NODE *new_evstr(rb_parse_state*,NODE*);
  118. static NODE *evstr2dstr(rb_parse_state*,NODE*);
  119. static NODE *call_op(NODE*,ID,int,NODE*,rb_parse_state*);
  120. /* static NODE *negate_lit(NODE*); */
  121. static NODE *ret_args(rb_parse_state*,NODE*);
  122. static NODE *arg_blk_pass(NODE*,NODE*);
  123. static NODE *new_call(rb_parse_state*,NODE*,ID,NODE*);
  124. static NODE *new_fcall(rb_parse_state*,ID,NODE*);
  125. static NODE *new_super(rb_parse_state*,NODE*);
  126. static NODE *new_yield(rb_parse_state*,NODE*);
  127. static NODE *syd_gettable(rb_parse_state*,ID);
  128. #define gettable(i) syd_gettable((rb_parse_state*)parse_state, i)
  129. static NODE *assignable(ID,NODE*,rb_parse_state*);
  130. static NODE *aryset(NODE*,NODE*,rb_parse_state*);
  131. static NODE *attrset(NODE*,ID,rb_parse_state*);
  132. static void rb_backref_error(NODE*);
  133. static NODE *node_assign(NODE*,NODE*,rb_parse_state*);
  134. static NODE *match_gen(NODE*,NODE*,rb_parse_state*);
  135. static void syd_local_push(rb_parse_state*, int cnt);
  136. #define local_push(cnt) syd_local_push(vps, cnt)
  137. static void syd_local_pop(rb_parse_state*);
  138. #define local_pop() syd_local_pop(vps)
  139. static intptr_t syd_local_cnt(rb_parse_state*,ID);
  140. #define local_cnt(i) syd_local_cnt(vps, i)
  141. static int syd_local_id(rb_parse_state*,ID);
  142. #define local_id(i) syd_local_id(vps, i)
  143. static ID *syd_local_tbl(rb_parse_state *st);
  144. static ID convert_op(ID id);
  145. static void tokadd(char c, rb_parse_state *parse_state);
  146. static int tokadd_string(int, int, int, quark *, rb_parse_state*);
  147. #define SHOW_PARSER_WARNS 0
  148. static int _debug_print(const char *fmt, ...) {
  149. #if SHOW_PARSER_WARNS
  150. va_list ar;
  151. int i;
  152. va_start(ar, fmt);
  153. i = vprintf(fmt, ar);
  154. va_end(ar);
  155. return i;
  156. #else
  157. return 0;
  158. #endif
  159. }
  160. #define rb_warn _debug_print
  161. #define rb_warning _debug_print
  162. #define rb_compile_error _debug_print
  163. static ID rb_intern(const char *name);
  164. static ID rb_id_attrset(ID);
  165. rb_parse_state *alloc_parse_state();
  166. static unsigned long scan_oct(const char *start, int len, int *retlen);
  167. static unsigned long scan_hex(const char *start, int len, int *retlen);
  168. static void reset_block(rb_parse_state *parse_state);
  169. static NODE *extract_block_vars(rb_parse_state *parse_state, NODE* node, var_table vars);
  170. #define ruby_verbose 0
  171. #define RE_OPTION_ONCE 0x80
  172. #define RE_OPTION_IGNORECASE (1L)
  173. #define RE_OPTION_EXTENDED (RE_OPTION_IGNORECASE<<1)
  174. #define RE_OPTION_MULTILINE (RE_OPTION_EXTENDED<<1)
  175. #define RE_OPTION_SINGLELINE (RE_OPTION_MULTILINE<<1)
  176. #define RE_OPTION_LONGEST (RE_OPTION_SINGLELINE<<1)
  177. #define RE_MAY_IGNORECASE (RE_OPTION_LONGEST<<1)
  178. #define RE_OPTIMIZE_ANCHOR (RE_MAY_IGNORECASE<<1)
  179. #define RE_OPTIMIZE_EXACTN (RE_OPTIMIZE_ANCHOR<<1)
  180. #define RE_OPTIMIZE_NO_BM (RE_OPTIMIZE_EXACTN<<1)
  181. #define RE_OPTIMIZE_BMATCH (RE_OPTIMIZE_NO_BM<<1)
  182. #define NODE_STRTERM NODE_ZARRAY /* nothing to gc */
  183. #define NODE_HEREDOC NODE_ARRAY /* 1, 3 to gc */
  184. #define SIGN_EXTEND(x,n) (((1<<((n)-1))^((x)&~(~0<<(n))))-(1<<((n)-1)))
  185. #define nd_func u1.id
  186. #if SIZEOF_SHORT != 2
  187. #define nd_term(node) SIGN_EXTEND((node)->u2.id, (CHAR_BIT*2))
  188. #else
  189. #define nd_term(node) ((signed short)(node)->u2.id)
  190. #endif
  191. #define nd_paren(node) (char)((node)->u2.id >> (CHAR_BIT*2))
  192. #define nd_nest u3.id
  193. /* Older versions of Yacc set YYMAXDEPTH to a very low value by default (150,
  194. for instance). This is too low for Ruby to parse some files, such as
  195. date/format.rb, therefore bump the value up to at least Bison's default. */
  196. #ifdef OLD_YACC
  197. #ifndef YYMAXDEPTH
  198. #define YYMAXDEPTH 10000
  199. #endif
  200. #endif
  201. #define vps ((rb_parse_state*)parse_state)
  202. %}
  203. %pure-parser
  204. %union {
  205. NODE *node;
  206. ID id;
  207. int num;
  208. var_table vars;
  209. }
  210. %token kCLASS
  211. kMODULE
  212. kDEF
  213. kUNDEF
  214. kBEGIN
  215. kRESCUE
  216. kENSURE
  217. kEND
  218. kIF
  219. kUNLESS
  220. kTHEN
  221. kELSIF
  222. kELSE
  223. kCASE
  224. kWHEN
  225. kWHILE
  226. kUNTIL
  227. kFOR
  228. kBREAK
  229. kNEXT
  230. kREDO
  231. kRETRY
  232. kIN
  233. kDO
  234. kDO_COND
  235. kDO_BLOCK
  236. kRETURN
  237. kYIELD
  238. kSUPER
  239. kSELF
  240. kNIL
  241. kTRUE
  242. kFALSE
  243. kAND
  244. kOR
  245. kNOT
  246. kIF_MOD
  247. kUNLESS_MOD
  248. kWHILE_MOD
  249. kUNTIL_MOD
  250. kRESCUE_MOD
  251. kALIAS
  252. kDEFINED
  253. klBEGIN
  254. klEND
  255. k__LINE__
  256. k__FILE__
  257. %token <id> tIDENTIFIER tFID tGVAR tIVAR tCONSTANT tCVAR tXSTRING_BEG
  258. %token <node> tINTEGER tFLOAT tSTRING_CONTENT
  259. %token <node> tNTH_REF tBACK_REF
  260. %token <num> tREGEXP_END
  261. %type <node> singleton strings string string1 xstring regexp
  262. %type <node> string_contents xstring_contents string_content
  263. %type <node> words qwords word_list qword_list word
  264. %type <node> literal numeric dsym cpath
  265. %type <node> bodystmt compstmt stmts stmt expr arg primary command command_call method_call
  266. %type <node> expr_value arg_value primary_value
  267. %type <node> if_tail opt_else case_body cases opt_rescue exc_list exc_var opt_ensure
  268. %type <node> args when_args call_args call_args2 open_args paren_args opt_paren_args
  269. %type <node> command_args aref_args opt_block_arg block_arg var_ref var_lhs
  270. %type <node> mrhs superclass block_call block_command
  271. %type <node> f_arglist f_args f_optarg f_opt f_block_arg opt_f_block_arg
  272. %type <node> assoc_list assocs assoc undef_list backref string_dvar
  273. %type <node> block_var opt_block_var brace_block cmd_brace_block do_block lhs none
  274. %type <node> mlhs mlhs_head mlhs_basic mlhs_entry mlhs_item mlhs_node
  275. %type <id> fitem variable sym symbol operation operation2 operation3
  276. %type <id> cname fname op f_rest_arg
  277. %type <num> f_norm_arg f_arg
  278. %token tUPLUS /* unary+ */
  279. %token tUMINUS /* unary- */
  280. %token tUBS /* unary\ */
  281. %token tPOW /* ** */
  282. %token tCMP /* <=> */
  283. %token tEQ /* == */
  284. %token tEQQ /* === */
  285. %token tNEQ /* != */
  286. %token tGEQ /* >= */
  287. %token tLEQ /* <= */
  288. %token tANDOP tOROP /* && and || */
  289. %token tMATCH tNMATCH /* =~ and !~ */
  290. %token tDOT2 tDOT3 /* .. and ... */
  291. %token tAREF tASET /* [] and []= */
  292. %token tLSHFT tRSHFT /* << and >> */
  293. %token tCOLON2 /* :: */
  294. %token tCOLON3 /* :: at EXPR_BEG */
  295. %token <id> tOP_ASGN /* +=, -= etc. */
  296. %token tASSOC /* => */
  297. %token tLPAREN /* ( */
  298. %token tLPAREN_ARG /* ( */
  299. %token tRPAREN /* ) */
  300. %token tLBRACK /* [ */
  301. %token tLBRACE /* { */
  302. %token tLBRACE_ARG /* { */
  303. %token tSTAR /* * */
  304. %token tAMPER /* & */
  305. %token tSYMBEG tSTRING_BEG tREGEXP_BEG tWORDS_BEG tQWORDS_BEG
  306. %token tSTRING_DBEG tSTRING_DVAR tSTRING_END
  307. /*
  308. * precedence table
  309. */
  310. %nonassoc tLOWEST
  311. %nonassoc tLBRACE_ARG
  312. %nonassoc kIF_MOD kUNLESS_MOD kWHILE_MOD kUNTIL_MOD
  313. %left kOR kAND
  314. %right kNOT
  315. %nonassoc kDEFINED
  316. %right '=' tOP_ASGN
  317. %left kRESCUE_MOD
  318. %right '?' ':'
  319. %nonassoc tDOT2 tDOT3
  320. %left tOROP
  321. %left tANDOP
  322. %nonassoc tCMP tEQ tEQQ tNEQ tMATCH tNMATCH
  323. %left '>' tGEQ '<' tLEQ
  324. %left '|' '^'
  325. %left '&'
  326. %left tLSHFT tRSHFT
  327. %left '+' '-'
  328. %left '*' '/' '%'
  329. %right tUMINUS_NUM tUMINUS
  330. %right tPOW
  331. %right '!' '~' tUPLUS
  332. %token tLAST_TOKEN
  333. %%
  334. program : {
  335. vps->lex_state = EXPR_BEG;
  336. vps->variables = var_table_create();
  337. class_nest = 0;
  338. }
  339. compstmt
  340. {
  341. if ($2 && !compile_for_eval) {
  342. /* last expression should not be void */
  343. if (nd_type($2) != NODE_BLOCK) void_expr($2);
  344. else {
  345. NODE *node = $2;
  346. while (node->nd_next) {
  347. node = node->nd_next;
  348. }
  349. void_expr(node->nd_head);
  350. }
  351. }
  352. vps->top = block_append(vps, vps->top, $2);
  353. class_nest = 0;
  354. }
  355. ;
  356. bodystmt : compstmt
  357. opt_rescue
  358. opt_else
  359. opt_ensure
  360. {
  361. $$ = $1;
  362. if ($2) {
  363. $$ = NEW_RESCUE($1, $2, $3);
  364. }
  365. else if ($3) {
  366. rb_warn("else without rescue is useless");
  367. $$ = block_append(vps, $$, $3);
  368. }
  369. if ($4) {
  370. $$ = NEW_ENSURE($$, $4);
  371. }
  372. fixpos($$, $1);
  373. }
  374. ;
  375. compstmt : stmts opt_terms
  376. {
  377. void_stmts($1, vps);
  378. $$ = $1;
  379. }
  380. ;
  381. stmts : none
  382. | stmt
  383. {
  384. $$ = newline_node(vps, $1);
  385. }
  386. | stmts terms stmt
  387. {
  388. $$ = block_append(vps, $1, newline_node(vps, $3));
  389. }
  390. | error stmt
  391. {
  392. $$ = remove_begin($2, vps);
  393. }
  394. ;
  395. stmt : kALIAS fitem {vps->lex_state = EXPR_FNAME;} fitem
  396. {
  397. $$ = NEW_ALIAS($2, $4);
  398. }
  399. | kALIAS tGVAR tGVAR
  400. {
  401. $$ = NEW_VALIAS($2, $3);
  402. }
  403. | kALIAS tGVAR tBACK_REF
  404. {
  405. char buf[3];
  406. snprintf(buf, sizeof(buf), "$%c", (char)$3->nd_nth);
  407. $$ = NEW_VALIAS($2, rb_intern(buf));
  408. }
  409. | kALIAS tGVAR tNTH_REF
  410. {
  411. yyerror("can't make alias for the number variables");
  412. $$ = 0;
  413. }
  414. | kUNDEF undef_list
  415. {
  416. $$ = $2;
  417. }
  418. | stmt kIF_MOD expr_value
  419. {
  420. $$ = NEW_IF(cond($3, vps), remove_begin($1, vps), 0);
  421. fixpos($$, $3);
  422. if (cond_negative(&$$->nd_cond)) {
  423. $$->nd_else = $$->nd_body;
  424. $$->nd_body = 0;
  425. }
  426. }
  427. | stmt kUNLESS_MOD expr_value
  428. {
  429. $$ = NEW_UNLESS(cond($3, vps), remove_begin($1, vps), 0);
  430. fixpos($$, $3);
  431. if (cond_negative(&$$->nd_cond)) {
  432. $$->nd_body = $$->nd_else;
  433. $$->nd_else = 0;
  434. }
  435. }
  436. | stmt kWHILE_MOD expr_value
  437. {
  438. if ($1 && nd_type($1) == NODE_BEGIN) {
  439. $$ = NEW_WHILE(cond($3, vps), $1->nd_body, 0);
  440. }
  441. else {
  442. $$ = NEW_WHILE(cond($3, vps), $1, 1);
  443. }
  444. if (cond_negative(&$$->nd_cond)) {
  445. nd_set_type($$, NODE_UNTIL);
  446. }
  447. }
  448. | stmt kUNTIL_MOD expr_value
  449. {
  450. if ($1 && nd_type($1) == NODE_BEGIN) {
  451. $$ = NEW_UNTIL(cond($3, vps), $1->nd_body, 0);
  452. }
  453. else {
  454. $$ = NEW_UNTIL(cond($3, vps), $1, 1);
  455. }
  456. if (cond_negative(&$$->nd_cond)) {
  457. nd_set_type($$, NODE_WHILE);
  458. }
  459. }
  460. | stmt kRESCUE_MOD stmt
  461. {
  462. NODE *resq = NEW_RESBODY(0, remove_begin($3, vps), 0);
  463. $$ = NEW_RESCUE(remove_begin($1, vps), resq, 0);
  464. }
  465. | klBEGIN
  466. {
  467. if (in_def || in_single) {
  468. yyerror("BEGIN in method");
  469. }
  470. local_push(0);
  471. }
  472. '{' compstmt '}'
  473. {
  474. /*
  475. ruby_eval_tree_begin = block_append(ruby_eval_tree_begin,
  476. NEW_PREEXE($4));
  477. */
  478. local_pop();
  479. $$ = 0;
  480. }
  481. | klEND '{' compstmt '}'
  482. {
  483. if (in_def || in_single) {
  484. rb_warn("END in method; use at_exit");
  485. }
  486. $$ = NEW_ITER(0, NEW_POSTEXE(), $3);
  487. }
  488. | lhs '=' command_call
  489. {
  490. $$ = node_assign($1, $3, vps);
  491. }
  492. | mlhs '=' command_call
  493. {
  494. value_expr($3);
  495. $1->nd_value = ($1->nd_head) ? NEW_TO_ARY($3) : NEW_ARRAY($3);
  496. $$ = $1;
  497. }
  498. | var_lhs tOP_ASGN command_call
  499. {
  500. value_expr($3);
  501. if ($1) {
  502. ID vid = $1->nd_vid;
  503. if ($2 == tOROP) {
  504. $1->nd_value = $3;
  505. $$ = NEW_OP_ASGN_OR(gettable(vid), $1);
  506. if (is_asgn_or_id(vid)) {
  507. $$->nd_aid = vid;
  508. }
  509. }
  510. else if ($2 == tANDOP) {
  511. $1->nd_value = $3;
  512. $$ = NEW_OP_ASGN_AND(gettable(vid), $1);
  513. }
  514. else {
  515. $$ = $1;
  516. $$->nd_value = call_op(gettable(vid),$2,1,$3, vps);
  517. }
  518. }
  519. else {
  520. $$ = 0;
  521. }
  522. }
  523. | primary_value '[' aref_args ']' tOP_ASGN command_call
  524. {
  525. NODE *args;
  526. value_expr($6);
  527. if (!$3) $3 = NEW_ZARRAY();
  528. args = arg_concat(vps, $6, $3);
  529. if ($5 == tOROP) {
  530. $5 = 0;
  531. }
  532. else if ($5 == tANDOP) {
  533. $5 = 1;
  534. }
  535. $$ = NEW_OP_ASGN1($1, $5, args);
  536. fixpos($$, $1);
  537. }
  538. | primary_value '.' tIDENTIFIER tOP_ASGN command_call
  539. {
  540. value_expr($5);
  541. if ($4 == tOROP) {
  542. $4 = 0;
  543. }
  544. else if ($4 == tANDOP) {
  545. $4 = 1;
  546. }
  547. $$ = NEW_OP_ASGN2($1, $3, $4, $5);
  548. fixpos($$, $1);
  549. }
  550. | primary_value '.' tCONSTANT tOP_ASGN command_call
  551. {
  552. value_expr($5);
  553. if ($4 == tOROP) {
  554. $4 = 0;
  555. }
  556. else if ($4 == tANDOP) {
  557. $4 = 1;
  558. }
  559. $$ = NEW_OP_ASGN2($1, $3, $4, $5);
  560. fixpos($$, $1);
  561. }
  562. | primary_value tCOLON2 tIDENTIFIER tOP_ASGN command_call
  563. {
  564. value_expr($5);
  565. if ($4 == tOROP) {
  566. $4 = 0;
  567. }
  568. else if ($4 == tANDOP) {
  569. $4 = 1;
  570. }
  571. $$ = NEW_OP_ASGN2($1, $3, $4, $5);
  572. fixpos($$, $1);
  573. }
  574. | backref tOP_ASGN command_call
  575. {
  576. rb_backref_error($1);
  577. $$ = 0;
  578. }
  579. | lhs '=' mrhs
  580. {
  581. $$ = node_assign($1, NEW_SVALUE($3), vps);
  582. }
  583. | mlhs '=' arg_value
  584. {
  585. $1->nd_value = ($1->nd_head) ? NEW_TO_ARY($3) : NEW_ARRAY($3);
  586. $$ = $1;
  587. }
  588. | mlhs '=' mrhs
  589. {
  590. $1->nd_value = $3;
  591. $$ = $1;
  592. }
  593. | expr
  594. ;
  595. expr : command_call
  596. | expr kAND expr
  597. {
  598. $$ = logop(NODE_AND, $1, $3, vps);
  599. }
  600. | expr kOR expr
  601. {
  602. $$ = logop(NODE_OR, $1, $3, vps);
  603. }
  604. | kNOT expr
  605. {
  606. $$ = NEW_NOT(cond($2, vps));
  607. }
  608. | '!' command_call
  609. {
  610. $$ = NEW_NOT(cond($2, vps));
  611. }
  612. | arg
  613. ;
  614. expr_value : expr
  615. {
  616. value_expr($$);
  617. $$ = $1;
  618. }
  619. ;
  620. command_call : command
  621. | block_command
  622. | kRETURN call_args
  623. {
  624. $$ = NEW_RETURN(ret_args(vps, $2));
  625. }
  626. | kBREAK call_args
  627. {
  628. $$ = NEW_BREAK(ret_args(vps, $2));
  629. }
  630. | kNEXT call_args
  631. {
  632. $$ = NEW_NEXT(ret_args(vps, $2));
  633. }
  634. ;
  635. block_command : block_call
  636. | block_call '.' operation2 command_args
  637. {
  638. $$ = new_call(vps, $1, $3, $4);
  639. }
  640. | block_call tCOLON2 operation2 command_args
  641. {
  642. $$ = new_call(vps, $1, $3, $4);
  643. }
  644. ;
  645. cmd_brace_block : tLBRACE_ARG
  646. {
  647. $<num>1 = ruby_sourceline;
  648. reset_block(vps);
  649. }
  650. opt_block_var { $<vars>$ = vps->block_vars; }
  651. compstmt
  652. '}'
  653. {
  654. $$ = NEW_ITER($3, 0, extract_block_vars(vps, $5, $<vars>4));
  655. nd_set_line($$, $<num>1);
  656. }
  657. ;
  658. command : operation command_args %prec tLOWEST
  659. {
  660. $$ = new_fcall(vps, $1, $2);
  661. fixpos($$, $2);
  662. }
  663. | operation command_args cmd_brace_block
  664. {
  665. $$ = new_fcall(vps, $1, $2);
  666. if ($3) {
  667. if (nd_type($$) == NODE_BLOCK_PASS) {
  668. rb_compile_error("both block arg and actual block given");
  669. }
  670. $3->nd_iter = $$;
  671. $$ = $3;
  672. }
  673. fixpos($$, $2);
  674. }
  675. | primary_value '.' operation2 command_args %prec tLOWEST
  676. {
  677. $$ = new_call(vps, $1, $3, $4);
  678. fixpos($$, $1);
  679. }
  680. | primary_value '.' operation2 command_args cmd_brace_block
  681. {
  682. $$ = new_call(vps, $1, $3, $4);
  683. if ($5) {
  684. if (nd_type($$) == NODE_BLOCK_PASS) {
  685. rb_compile_error("both block arg and actual block given");
  686. }
  687. $5->nd_iter = $$;
  688. $$ = $5;
  689. }
  690. fixpos($$, $1);
  691. }
  692. | primary_value tCOLON2 operation2 command_args %prec tLOWEST
  693. {
  694. $$ = new_call(vps, $1, $3, $4);
  695. fixpos($$, $1);
  696. }
  697. | primary_value tCOLON2 operation2 command_args cmd_brace_block
  698. {
  699. $$ = new_call(vps, $1, $3, $4);
  700. if ($5) {
  701. if (nd_type($$) == NODE_BLOCK_PASS) {
  702. rb_compile_error("both block arg and actual block given");
  703. }
  704. $5->nd_iter = $$;
  705. $$ = $5;
  706. }
  707. fixpos($$, $1);
  708. }
  709. | kSUPER command_args
  710. {
  711. $$ = new_super(vps, $2);
  712. fixpos($$, $2);
  713. }
  714. | kYIELD command_args
  715. {
  716. $$ = new_yield(vps, $2);
  717. fixpos($$, $2);
  718. }
  719. ;
  720. mlhs : mlhs_basic
  721. | tLPAREN mlhs_entry ')'
  722. {
  723. $$ = $2;
  724. }
  725. ;
  726. mlhs_entry : mlhs_basic
  727. | tLPAREN mlhs_entry ')'
  728. {
  729. $$ = NEW_MASGN(NEW_LIST($2), 0);
  730. }
  731. ;
  732. mlhs_basic : mlhs_head
  733. {
  734. $$ = NEW_MASGN($1, 0);
  735. }
  736. | mlhs_head mlhs_item
  737. {
  738. $$ = NEW_MASGN(list_append(vps, $1,$2), 0);
  739. }
  740. | mlhs_head tSTAR mlhs_node
  741. {
  742. $$ = NEW_MASGN($1, $3);
  743. }
  744. | mlhs_head tSTAR
  745. {
  746. $$ = NEW_MASGN($1, -1);
  747. }
  748. | tSTAR mlhs_node
  749. {
  750. $$ = NEW_MASGN(0, $2);
  751. }
  752. | tSTAR
  753. {
  754. $$ = NEW_MASGN(0, -1);
  755. }
  756. ;
  757. mlhs_item : mlhs_node
  758. | tLPAREN mlhs_entry ')'
  759. {
  760. $$ = $2;
  761. }
  762. ;
  763. mlhs_head : mlhs_item ','
  764. {
  765. $$ = NEW_LIST($1);
  766. }
  767. | mlhs_head mlhs_item ','
  768. {
  769. $$ = list_append(vps, $1, $2);
  770. }
  771. ;
  772. mlhs_node : variable
  773. {
  774. $$ = assignable($1, 0, vps);
  775. }
  776. | primary_value '[' aref_args ']'
  777. {
  778. $$ = aryset($1, $3, vps);
  779. }
  780. | primary_value '.' tIDENTIFIER
  781. {
  782. $$ = attrset($1, $3, vps);
  783. }
  784. | primary_value tCOLON2 tIDENTIFIER
  785. {
  786. $$ = attrset($1, $3, vps);
  787. }
  788. | primary_value '.' tCONSTANT
  789. {
  790. $$ = attrset($1, $3, vps);
  791. }
  792. | primary_value tCOLON2 tCONSTANT
  793. {
  794. if (in_def || in_single)
  795. yyerror("dynamic constant assignment");
  796. $$ = NEW_CDECL(0, 0, NEW_COLON2($1, $3));
  797. }
  798. | tCOLON3 tCONSTANT
  799. {
  800. if (in_def || in_single)
  801. yyerror("dynamic constant assignment");
  802. $$ = NEW_CDECL(0, 0, NEW_COLON3($2));
  803. }
  804. | backref
  805. {
  806. rb_backref_error($1);
  807. $$ = 0;
  808. }
  809. ;
  810. lhs : variable
  811. {
  812. $$ = assignable($1, 0, vps);
  813. }
  814. | primary_value '[' aref_args ']'
  815. {
  816. $$ = aryset($1, $3, vps);
  817. }
  818. | primary_value '.' tIDENTIFIER
  819. {
  820. $$ = attrset($1, $3, vps);
  821. }
  822. | primary_value tCOLON2 tIDENTIFIER
  823. {
  824. $$ = attrset($1, $3, vps);
  825. }
  826. | primary_value '.' tCONSTANT
  827. {
  828. $$ = attrset($1, $3, vps);
  829. }
  830. | primary_value tCOLON2 tCONSTANT
  831. {
  832. if (in_def || in_single)
  833. yyerror("dynamic constant assignment");
  834. $$ = NEW_CDECL(0, 0, NEW_COLON2($1, $3));
  835. }
  836. | tCOLON3 tCONSTANT
  837. {
  838. if (in_def || in_single)
  839. yyerror("dynamic constant assignment");
  840. $$ = NEW_CDECL(0, 0, NEW_COLON3($2));
  841. }
  842. | backref
  843. {
  844. rb_backref_error($1);
  845. $$ = 0;
  846. }
  847. ;
  848. cname : tIDENTIFIER
  849. {
  850. yyerror("class/module name must be CONSTANT");
  851. }
  852. | tCONSTANT
  853. ;
  854. cpath : tCOLON3 cname
  855. {
  856. $$ = NEW_COLON3($2);
  857. }
  858. | cname
  859. {
  860. $$ = NEW_COLON2(0, $$);
  861. }
  862. | primary_value tCOLON2 cname
  863. {
  864. $$ = NEW_COLON2($1, $3);
  865. }
  866. ;
  867. fname : tIDENTIFIER
  868. | tCONSTANT
  869. | tFID
  870. | op
  871. {
  872. vps->lex_state = EXPR_END;
  873. $$ = convert_op($1);
  874. }
  875. | reswords
  876. {
  877. vps->lex_state = EXPR_END;
  878. $$ = $<id>1;
  879. }
  880. ;
  881. fitem : fname
  882. | symbol
  883. ;
  884. undef_list : fitem
  885. {
  886. $$ = NEW_UNDEF($1);
  887. }
  888. | undef_list ',' {vps->lex_state = EXPR_FNAME;} fitem
  889. {
  890. $$ = block_append(vps, $1, NEW_UNDEF($4));
  891. }
  892. ;
  893. op : '|' { $$ = '|'; }
  894. | '^' { $$ = '^'; }
  895. | '&' { $$ = '&'; }
  896. | tCMP { $$ = tCMP; }
  897. | tEQ { $$ = tEQ; }
  898. | tEQQ { $$ = tEQQ; }
  899. | tMATCH { $$ = tMATCH; }
  900. | '>' { $$ = '>'; }
  901. | tGEQ { $$ = tGEQ; }
  902. | '<' { $$ = '<'; }
  903. | tLEQ { $$ = tLEQ; }
  904. | tLSHFT { $$ = tLSHFT; }
  905. | tRSHFT { $$ = tRSHFT; }
  906. | '+' { $$ = '+'; }
  907. | '-' { $$ = '-'; }
  908. | '*' { $$ = '*'; }
  909. | tSTAR { $$ = '*'; }
  910. | '/' { $$ = '/'; }
  911. | '%' { $$ = '%'; }
  912. | tPOW { $$ = tPOW; }
  913. | '~' { $$ = '~'; }
  914. | tUPLUS { $$ = tUPLUS; }
  915. | tUMINUS { $$ = tUMINUS; }
  916. | tAREF { $$ = tAREF; }
  917. | tASET { $$ = tASET; }
  918. | '`' { $$ = '`'; }
  919. ;
  920. reswords : k__LINE__ | k__FILE__ | klBEGIN | klEND
  921. | kALIAS | kAND | kBEGIN | kBREAK | kCASE | kCLASS | kDEF
  922. | kDEFINED | kDO | kELSE | kELSIF | kEND | kENSURE | kFALSE
  923. | kFOR | kIN | kMODULE | kNEXT | kNIL | kNOT
  924. | kOR | kREDO | kRESCUE | kRETRY | kRETURN | kSELF | kSUPER
  925. | kTHEN | kTRUE | kUNDEF | kWHEN | kYIELD
  926. | kIF_MOD | kUNLESS_MOD | kWHILE_MOD | kUNTIL_MOD | kRESCUE_MOD
  927. ;
  928. arg : lhs '=' arg
  929. {
  930. $$ = node_assign($1, $3, vps);
  931. }
  932. | lhs '=' arg kRESCUE_MOD arg
  933. {
  934. $$ = node_assign($1, NEW_RESCUE($3, NEW_RESBODY(0,$5,0), 0), vps);
  935. }
  936. | var_lhs tOP_ASGN arg
  937. {
  938. value_expr($3);
  939. if ($1) {
  940. ID vid = $1->nd_vid;
  941. if ($2 == tOROP) {
  942. $1->nd_value = $3;
  943. $$ = NEW_OP_ASGN_OR(gettable(vid), $1);
  944. if (is_asgn_or_id(vid)) {
  945. $$->nd_aid = vid;
  946. }
  947. }
  948. else if ($2 == tANDOP) {
  949. $1->nd_value = $3;
  950. $$ = NEW_OP_ASGN_AND(gettable(vid), $1);
  951. }
  952. else {
  953. $$ = $1;
  954. $$->nd_value = call_op(gettable(vid),$2,1,$3, vps);
  955. }
  956. }
  957. else {
  958. $$ = 0;
  959. }
  960. }
  961. | primary_value '[' aref_args ']' tOP_ASGN arg
  962. {
  963. NODE *args;
  964. value_expr($6);
  965. if (!$3) $3 = NEW_ZARRAY();
  966. args = arg_concat(vps, $6, $3);
  967. if ($5 == tOROP) {
  968. $5 = 0;
  969. }
  970. else if ($5 == tANDOP) {
  971. $5 = 1;
  972. }
  973. $$ = NEW_OP_ASGN1($1, $5, args);
  974. fixpos($$, $1);
  975. }
  976. | primary_value '.' tIDENTIFIER tOP_ASGN arg
  977. {
  978. value_expr($5);
  979. if ($4 == tOROP) {
  980. $4 = 0;
  981. }
  982. else if ($4 == tANDOP) {
  983. $4 = 1;
  984. }
  985. $$ = NEW_OP_ASGN2($1, $3, $4, $5);
  986. fixpos($$, $1);
  987. }
  988. | primary_value '.' tCONSTANT tOP_ASGN arg
  989. {
  990. value_expr($5);
  991. if ($4 == tOROP) {
  992. $4 = 0;
  993. }
  994. else if ($4 == tANDOP) {
  995. $4 = 1;
  996. }
  997. $$ = NEW_OP_ASGN2($1, $3, $4, $5);
  998. fixpos($$, $1);
  999. }
  1000. | primary_value tCOLON2 tIDENTIFIER tOP_ASGN arg
  1001. {
  1002. value_expr($5);
  1003. if ($4 == tOROP) {
  1004. $4 = 0;
  1005. }
  1006. else if ($4 == tANDOP) {
  1007. $4 = 1;
  1008. }
  1009. $$ = NEW_OP_ASGN2($1, $3, $4, $5);
  1010. fixpos($$, $1);
  1011. }
  1012. | primary_value tCOLON2 tCONSTANT tOP_ASGN arg
  1013. {
  1014. yyerror("constant re-assignment");
  1015. $$ = 0;
  1016. }
  1017. | tCOLON3 tCONSTANT tOP_ASGN arg
  1018. {
  1019. yyerror("constant re-assignment");
  1020. $$ = 0;
  1021. }
  1022. | backref tOP_ASGN arg
  1023. {
  1024. rb_backref_error($1);
  1025. $$ = 0;
  1026. }
  1027. | arg tDOT2 arg
  1028. {
  1029. value_expr($1);
  1030. value_expr($3);
  1031. $$ = NEW_DOT2($1, $3);
  1032. }
  1033. | arg tDOT3 arg
  1034. {
  1035. value_expr($1);
  1036. value_expr($3);
  1037. $$ = NEW_DOT3($1, $3);
  1038. }
  1039. | arg '+' arg
  1040. {
  1041. $$ = call_op($1, '+', 1, $3, vps);
  1042. }
  1043. | arg '-' arg
  1044. {
  1045. $$ = call_op($1, '-', 1, $3, vps);
  1046. }
  1047. | arg '*' arg
  1048. {
  1049. $$ = call_op($1, '*', 1, $3, vps);
  1050. }
  1051. | arg '/' arg
  1052. {
  1053. $$ = call_op($1, '/', 1, $3, vps);
  1054. }
  1055. | arg '%' arg
  1056. {
  1057. $$ = call_op($1, '%', 1, $3, vps);
  1058. }
  1059. | arg tPOW arg
  1060. {
  1061. $$ = call_op($1, tPOW, 1, $3, vps);
  1062. }
  1063. | tUMINUS_NUM tINTEGER tPOW arg
  1064. {
  1065. $$ = call_op(call_op($2, tPOW, 1, $4, vps), tUMINUS, 0, 0, vps);
  1066. }
  1067. | tUMINUS_NUM tFLOAT tPOW arg
  1068. {
  1069. $$ = call_op(call_op($2, tPOW, 1, $4, vps), tUMINUS, 0, 0, vps);
  1070. }
  1071. | tUPLUS arg
  1072. {
  1073. if ($2 && nd_type($2) == NODE_LIT) {
  1074. $$ = $2;
  1075. }
  1076. else {
  1077. $$ = call_op($2, tUPLUS, 0, 0, vps);
  1078. }
  1079. }
  1080. | tUMINUS arg
  1081. {
  1082. $$ = call_op($2, tUMINUS, 0, 0, vps);
  1083. }
  1084. | arg '|' arg
  1085. {
  1086. $$ = call_op($1, '|', 1, $3, vps);
  1087. }
  1088. | arg '^' arg
  1089. {
  1090. $$ = call_op($1, '^', 1, $3, vps);
  1091. }
  1092. | arg '&' arg
  1093. {
  1094. $$ = call_op($1, '&', 1, $3, vps);
  1095. }
  1096. | arg tCMP arg
  1097. {
  1098. $$ = call_op($1, tCMP, 1, $3, vps);
  1099. }
  1100. | arg '>' arg
  1101. {
  1102. $$ = call_op($1, '>', 1, $3, vps);
  1103. }
  1104. | arg tGEQ arg
  1105. {
  1106. $$ = call_op($1, tGEQ, 1, $3, vps);
  1107. }
  1108. | arg '<' arg
  1109. {
  1110. $$ = call_op($1, '<', 1, $3, vps);
  1111. }
  1112. | arg tLEQ arg
  1113. {
  1114. $$ = call_op($1, tLEQ, 1, $3, vps);
  1115. }
  1116. | arg tEQ arg
  1117. {
  1118. $$ = call_op($1, tEQ, 1, $3, vps);
  1119. }
  1120. | arg tEQQ arg
  1121. {
  1122. $$ = call_op($1, tEQQ, 1, $3, vps);
  1123. }
  1124. | arg tNEQ arg
  1125. {
  1126. $$ = NEW_NOT(call_op($1, tEQ, 1, $3, vps));
  1127. }
  1128. | arg tMATCH arg
  1129. {
  1130. $$ = match_gen($1, $3, vps);
  1131. }
  1132. | arg tNMATCH arg
  1133. {
  1134. $$ = NEW_NOT(match_gen($1, $3, vps));
  1135. }
  1136. | '!' arg
  1137. {
  1138. $$ = NEW_NOT(cond($2, vps));
  1139. }
  1140. | '~' arg
  1141. {
  1142. $$ = call_op($2, '~', 0, 0, vps);
  1143. }
  1144. | arg tLSHFT arg
  1145. {
  1146. $$ = call_op($1, tLSHFT, 1, $3, vps);
  1147. }
  1148. | arg tRSHFT arg
  1149. {
  1150. $$ = call_op($1, tRSHFT, 1, $3, vps);
  1151. }
  1152. | arg tANDOP arg
  1153. {
  1154. $$ = logop(NODE_AND, $1, $3, vps);
  1155. }
  1156. | arg tOROP arg
  1157. {
  1158. $$ = logop(NODE_OR, $1, $3, vps);
  1159. }
  1160. | kDEFINED opt_nl {vps->in_defined = 1;} arg
  1161. {
  1162. vps->in_defined = 0;
  1163. $$ = NEW_DEFINED($4);
  1164. }
  1165. | arg '?' {vps->ternary_colon++;} arg ':' arg
  1166. {
  1167. $$ = NEW_IF(cond($1, vps), $4, $6);
  1168. fixpos($$, $1);
  1169. vps->ternary_colon--;
  1170. }
  1171. | primary
  1172. {
  1173. $$ = $1;
  1174. }
  1175. ;
  1176. arg_value : arg
  1177. {
  1178. value_expr($1);
  1179. $$ = $1;
  1180. }
  1181. ;
  1182. aref_args : none
  1183. | command opt_nl
  1184. {
  1185. rb_warn("parenthesize argument(s) for future version");
  1186. $$ = NEW_LIST($1);
  1187. }
  1188. | args trailer
  1189. {
  1190. $$ = $1;
  1191. }
  1192. | args ',' tSTAR arg opt_nl
  1193. {
  1194. value_expr($4);
  1195. $$ = arg_concat(vps, $1, $4);
  1196. }
  1197. | assocs trailer
  1198. {
  1199. $$ = NEW_LIST(NEW_HASH($1));
  1200. }
  1201. | tSTAR arg opt_nl
  1202. {
  1203. value_expr($2);
  1204. $$ = NEW_NEWLINE(NEW_SPLAT($2));
  1205. }
  1206. ;
  1207. paren_args : '(' none ')'
  1208. {
  1209. $$ = $2;
  1210. }
  1211. | '(' call_args opt_nl ')'
  1212. {
  1213. $$ = $2;
  1214. }
  1215. | '(' block_call opt_nl ')'
  1216. {
  1217. rb_warn("parenthesize argument for future version");
  1218. $$ = NEW_LIST($2);
  1219. }
  1220. | '(' args ',' block_call opt_nl ')'
  1221. {
  1222. rb_warn("parenthesize argument for future version");
  1223. $$ = list_append(vps, $2, $4);
  1224. }
  1225. ;
  1226. opt_paren_args : none
  1227. | paren_args
  1228. ;
  1229. call_args : command
  1230. {
  1231. rb_warn("parenthesize argument(s) for future version");
  1232. $$ = NEW_LIST($1);
  1233. }
  1234. | args opt_block_arg
  1235. {
  1236. $$ = arg_blk_pass($1, $2);
  1237. }
  1238. | args ',' tSTAR arg_value opt_block_arg
  1239. {
  1240. $$ = arg_concat(vps, $1, $4);
  1241. $$ = arg_blk_pass($$, $5);
  1242. }
  1243. | assocs opt_block_arg
  1244. {
  1245. $$ = NEW_LIST(NEW_HASH($1));
  1246. $$ = arg_blk_pass($$, $2);
  1247. }
  1248. | assocs ',' tSTAR arg_value opt_block_arg
  1249. {
  1250. $$ = arg_concat(vps, NEW_LIST(NEW_HASH($1)), $4);
  1251. $$ = arg_blk_pass($$, $5);
  1252. }
  1253. | args ',' assocs opt_block_arg
  1254. {
  1255. $$ = list_append(vps, $1, NEW_HASH($3));
  1256. $$ = arg_blk_pass($$, $4);
  1257. }
  1258. | args ',' assocs ',' tSTAR arg opt_block_arg
  1259. {
  1260. value_expr($6);
  1261. $$ = arg_concat(vps, list_append(vps, $1, NEW_HASH($3)), $6);
  1262. $$ = arg_blk_pass($$, $7);
  1263. }
  1264. | tSTAR arg_value opt_block_arg
  1265. {
  1266. $$ = arg_blk_pass(NEW_SPLAT($2), $3);
  1267. }
  1268. | block_arg
  1269. ;
  1270. call_args2 : arg_value ',' args opt_block_arg
  1271. {
  1272. $$ = arg_blk_pass(list_concat(NEW_LIST($1),$3), $4);
  1273. }
  1274. | arg_value ',' block_arg
  1275. {
  1276. $$ = arg_blk_pass($1, $3);
  1277. }
  1278. | arg_value ',' tSTAR arg_value opt_block_arg
  1279. {
  1280. $$ = arg_concat(vps, NEW_LIST($1), $4);
  1281. $$ = arg_blk_pass($$, $5);
  1282. }
  1283. | arg_value ',' args ',' tSTAR arg_value opt_block_arg
  1284. {
  1285. $$ = arg_concat(vps, list_concat(NEW_LIST($1),$3), $6);
  1286. $$ = arg_blk_pass($$, $7);
  1287. }
  1288. | assocs opt_block_arg
  1289. {
  1290. $$ = NEW_LIST(NEW_HASH($1));
  1291. $$ = arg_blk_pass($$, $2);
  1292. }
  1293. | assocs ',' tSTAR arg_value opt_block_arg
  1294. {
  1295. $$ = arg_concat(vps, NEW_LIST(NEW_HASH($1)), $4);
  1296. $$ = arg_blk_pass($$, $5);
  1297. }
  1298. | arg_value ',' assocs opt_block_arg
  1299. {
  1300. $$ = list_append(vps, NEW_LIST($1), NEW_HASH($3));
  1301. $$ = arg_blk_pass($$, $4);
  1302. }
  1303. | arg_value ',' args ',' assocs opt_block_arg
  1304. {
  1305. $$ = list_append(vps, list_concat(NEW_LIST($1),$3), NEW_HASH($5));
  1306. $$ = arg_blk_pass($$, $6);
  1307. }
  1308. | arg_value ',' assocs ',' tSTAR arg_value opt_block_arg
  1309. {
  1310. $$ = arg_concat(vps, list_append(vps, NEW_LIST($1), NEW_HASH($3)), $6);
  1311. $$ = arg_blk_pass($$, $7);
  1312. }
  1313. | arg_value ',' args ',' assocs ',' tSTAR arg_value opt_block_arg
  1314. {
  1315. $$ = arg_concat(vps, list_append(vps,
  1316. list_concat(NEW_LIST($1), $3), NEW_HASH($5)), $8);
  1317. $$ = arg_blk_pass($$, $9);
  1318. }
  1319. | tSTAR arg_value opt_block_arg
  1320. {
  1321. $$ = arg_blk_pass(NEW_SPLAT($2), $3);
  1322. }
  1323. | block_arg
  1324. ;
  1325. command_args : {
  1326. $<num>$ = vps->cmdarg_stack;
  1327. CMDARG_PUSH(1);
  1328. }
  1329. open_args
  1330. {
  1331. /* CMDARG_POP() */
  1332. vps->cmdarg_stack = $<num>1;
  1333. $$ = $2;
  1334. }
  1335. ;
  1336. open_args : call_args
  1337. | tLPAREN_ARG {vps->lex_state = EXPR_ENDARG;} ')'
  1338. {
  1339. rb_warn("don't put space before argument parentheses");
  1340. $$ = 0;
  1341. }
  1342. | tLPAREN_ARG call_args2 {vps->lex_state = EXPR_ENDARG;} ')'
  1343. {
  1344. rb_warn("don't put space before argument parentheses");
  1345. $$ = $2;
  1346. }
  1347. ;
  1348. block_arg : tAMPER arg_value

Large files files are truncated, but you can click here to view the full file