refe 0.8.0.2 → 0.8.0.3

data/data/refe/function_source/undefine/final

@@ -1,4 +1,4 @@
-gc.c:1708
+gc.c:1706
 static VALUE
 undefine_final(os, obj)
     VALUE os, obj;

data/data/refe/function_source/uninitialized/constant

@@ -1,4 +1,4 @@
-variable.c:1197
+variable.c:1199
 NORETURN(static void uninitialized_constant _((VALUE, ID)));
 static void
 uninitialized_constant(klass, id)

data/data/refe/function_source/unknown/node

@@ -1,8 +1,16 @@
-eval.c:2812
+eval.c:2813
 static void
 unknown_node(node)
     NODE *volatile node;
 {
     ruby_current_node = 0;
-    rb_bug("unknown node type %d", nd_type(node));
+    if (node->flags == 0) {
+        rb_bug("terminated node (0x%lx)", node);
+    }
+    else if (BUILTIN_TYPE(node) != T_NODE) {
+        rb_bug("not a node 0x%02lx (0x%lx)", BUILTIN_TYPE(node), node);
+    }
+    else {
+        rb_bug("unknown node type %d (0x%lx)", nd_type(node), node);
+    }
 }

data/data/refe/function_source/unlink/internal

@@ -1,7 +1,9 @@
-file.c:2015
+file.c:2175
+static void unlink_internal _((const char *, void *));
 static void
-unlink_internal(path)
+unlink_internal(path, arg)
     const char *path;
+    void *arg;
 {
     if (unlink(path) < 0)
 	rb_sys_fail(path);

data/data/refe/function_source/utf8/startpos

@@ -1,4 +1,4 @@
-regex.c:4621
+regex.c:4622
 static unsigned int
 utf8_startpos(string, pos)
      const char *string;

data/data/refe/function_source/utime/internal

@@ -1,9 +1,10 @@
-file.c:1873
+file.c:2023
 static void
-utime_internal(path, utp)
+utime_internal(path, arg)
     const char *path;
-    struct utimbuf *utp;
+    void *arg;
 {
+    struct utimbuf *utp = arg;
     if (utime(path, utp) < 0)
 	rb_sys_fail(path);
 }

data/data/refe/function_source/vafuncall

@@ -1,4 +1,4 @@
-eval.c:5954
+eval.c:5974
 static VALUE
 vafuncall(recv, mid, n, ar)
     VALUE recv;

data/data/refe/function_source/value/expr0

@@ -1,4 +1,4 @@
-parse.c:9665
+parse.c:9021
 static int
 value_expr0(node)
     NODE *node;

data/data/refe/function_source/vms/fileact

@@ -1,4 +1,4 @@
-dln.c:1878
+dln.c:1879
 static int vms_fileact(char *filespec, int type)
 {
     if (vms_filespec)

data/data/refe/function_source/vms/fisexh

@@ -1,4 +1,4 @@
-dln.c:1888
+dln.c:1889
 static long vms_fisexh(long *sigarr, long *mecarr)
 {
     sys$unwind(1, 0);

data/data/refe/function_source/void/expr0

@@ -1,4 +1,4 @@
-parse.c:9721
+parse.c:9077
 static void
 void_expr0(node)
     NODE *node;

data/data/refe/function_source/void/stmts

@@ -1,4 +1,4 @@
-parse.c:9817
+parse.c:9173
 static void
 void_stmts(node)
     NODE *node;

data/data/refe/function_source/w32/io/info

@@ -0,0 +1,32 @@
+file.c:666
+static HANDLE
+w32_io_info(file, st)
+    VALUE *file;
+    BY_HANDLE_FILE_INFORMATION *st;
+{
+    VALUE tmp;
+    HANDLE f, ret = 0;
+
+    tmp = rb_check_convert_type(*file, T_FILE, "IO", "to_io");
+    if (!NIL_P(tmp)) {
+	OpenFile *fptr;
+
+	GetOpenFile(tmp, fptr);
+	f = (HANDLE)rb_w32_get_osfhandle(fileno(fptr->f));
+	if (f == (HANDLE)-1) return INVALID_HANDLE_VALUE;
+    }
+    else {
+	SafeStringValue(*file);
+	f = CreateFile(StringValueCStr(*file), 0,
+	               FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_EXISTING,
+	               rb_w32_iswin95() ? 0 : FILE_FLAG_BACKUP_SEMANTICS, NULL);
+	if (f == INVALID_HANDLE_VALUE) return f;
+	ret = f;
+    }
+    if (GetFileType(f) == FILE_TYPE_DISK) {
+	ZeroMemory(st, sizeof(*st));
+	if (GetFileInformationByHandle(f, st)) return ret;
+    }
+    if (ret) CloseHandle(ret);
+    return INVALID_HANDLE_VALUE;
+}

data/data/refe/function_source/warn/unless/e/option

@@ -1,4 +1,4 @@
-parse.c:9905
+parse.c:9261
 static void
 warn_unless_e_option(node, str)
     NODE *node;

data/data/refe/function_source/warning/unless/e/option

@@ -1,4 +1,4 @@
-parse.c:9913
+parse.c:9269
 static void
 warning_unless_e_option(node, str)
     NODE *node;

data/data/refe/function_source/whole/match/p

@@ -1,4 +1,4 @@
-parse.c:7894
+parse.c:7236
 static int
 whole_match_p(eos, len, indent)
     char *eos;

data/data/refe/function_source/win32/get/exception/list

@@ -1,4 +1,4 @@
-eval.c:9530
+eval.c:9573
 static inline DWORD
 win32_get_exception_list()
 {

data/data/refe/function_source/win32/set/exception/list

@@ -1,4 +1,4 @@
-eval.c:9557
+eval.c:9600
 static inline void
 win32_set_exception_list(p)
     DWORD p;

data/data/refe/function_source/wsplit/p

@@ -1,4 +1,4 @@
-io.c:403
+io.c:409
 static int
 wsplit_p(OpenFile *fptr)
 {

data/data/refe/function_source/yield/under/-

@@ -1,4 +1,4 @@
-eval.c:6487
+eval.c:6517
 static VALUE
 yield_under(under, self)
     VALUE under, self;

data/data/refe/function_source/yield/under/i

@@ -1,4 +1,4 @@
-eval.c:6479
+eval.c:6509
 static VALUE
 yield_under_i(self)
     VALUE self;

data/data/refe/function_source/yycompile

@@ -1,4 +1,4 @@
-parse.c:7219
+parse.c:6561
 static NODE*
 yycompile(f, line)
     char *f;

data/data/refe/function_source/yyerror

@@ -1,4 +1,4 @@
-parse.c:7168
+parse.c:6507
 static int
 yyerror(msg)
     const char *msg;

data/data/refe/function_source/yylex

@@ -1,10 +1,11 @@
-parse.c:8004
+parse.c:7346
 static int
 yylex()
 {
     register int c;
     int space_seen = 0;
     int cmd_state;
+    enum lex_state last_state;
 
     if (lex_strterm) {
 	int token;
@@ -892,6 +893,7 @@ yylex()
 	return '%';
 
       case '$':
+	last_state = lex_state;
 	lex_state = EXPR_END;
 	newtok();
 	c = nextc();
@@ -934,7 +936,13 @@ yylex()
 	    tokadd('$');
 	    tokadd(c);
 	    c = nextc();
-	    tokadd(c);
+	    if (is_identchar(c)) {
+		tokadd(c);
+	    }
+	    else {
+		pushback(c);
+	    }
+	  gvar:
 	    tokfix();
 	    yylval.id = rb_intern(tok());
 	    /* xxx shouldn't check if valid option variable */
@@ -944,6 +952,11 @@ yylex()
 	  case '`':		/* $`: string before last match */
 	  case '\'':		/* $': string after last match */
 	  case '+':		/* $+: string matches last paren. */
+	    if (last_state == EXPR_FNAME) {
+		tokadd('$');
+		tokadd(c);
+		goto gvar;
+	    }
 	    yylval.node = NEW_BACK_REF(c);
 	    return tBACK_REF;
 
@@ -956,6 +969,7 @@ yylex()
 		c = nextc();
 	    } while (ISDIGIT(c));
 	    pushback(c);
+	    if (last_state == EXPR_FNAME) goto gvar;
 	    tokfix();
 	    yylval.node = NEW_NTH_REF(atoi(tok()+1));
 	    return tNTH_REF;
@@ -1033,8 +1047,8 @@ yylex()
 
     {
 	int result = 0;
-	enum lex_state last_state = lex_state;
 
+	last_state = lex_state;
 	switch (tok()[0]) {
 	  case '$':
 	    lex_state = EXPR_END;

data/data/refe/function_source/yyparse

@@ -0,0 +1,2905 @@
+parse.c:3337
+int
+yyparse (YYPARSE_PARAM_ARG)
+     YYPARSE_PARAM_DECL
+{
+  /* If reentrant, generate the variables here. */
+#if YYPURE
+  YY_DECL_VARIABLES
+#endif  /* !YYPURE */
+
+  register int yystate;
+  register int yyn;
+  int yyresult;
+  /* Number of tokens to shift before error messages enabled.  */
+  int yyerrstatus;
+  /* Lookahead token as an internal (translated) token number.  */
+  int yychar1 = 0;
+
+  /* Three stacks and their tools:
+     `yyss': related to states,
+     `yyvs': related to semantic values,
+     `yyls': related to locations.
+
+     Refer to the stacks thru separate pointers, to allow yyoverflow
+     to reallocate them elsewhere.  */
+
+  /* The state stack. */
+  short	yyssa[YYINITDEPTH];
+  short *yyss = yyssa;
+  register short *yyssp;
+
+  /* The semantic value stack.  */
+  YYSTYPE yyvsa[YYINITDEPTH];
+  YYSTYPE *yyvs = yyvsa;
+  register YYSTYPE *yyvsp;
+
+#if YYLSP_NEEDED
+  /* The location stack.  */
+  YYLTYPE yylsa[YYINITDEPTH];
+  YYLTYPE *yyls = yylsa;
+  YYLTYPE *yylsp;
+#endif
+
+#if YYLSP_NEEDED
+# define YYPOPSTACK   (yyvsp--, yyssp--, yylsp--)
+#else
+# define YYPOPSTACK   (yyvsp--, yyssp--)
+#endif
+
+  YYSIZE_T yystacksize = YYINITDEPTH;
+
+
+  /* The variables used to return semantic value and location from the
+     action routines.  */
+  YYSTYPE yyval;
+#if YYLSP_NEEDED
+  YYLTYPE yyloc;
+#endif
+
+  /* When reducing, the number of symbols on the RHS of the reduced
+     rule. */
+  int yylen;
+
+  YYDPRINTF ((stderr, "Starting parse\n"));
+
+  yystate = 0;
+  yyerrstatus = 0;
+  yynerrs = 0;
+  yychar = YYEMPTY;		/* Cause a token to be read.  */
+
+  /* Initialize stack pointers.
+     Waste one element of value and location stack
+     so that they stay on the same level as the state stack.
+     The wasted elements are never initialized.  */
+
+  yyssp = yyss;
+  yyvsp = yyvs;
+#if YYLSP_NEEDED
+  yylsp = yyls;
+#endif
+  goto yysetstate;
+
+/*------------------------------------------------------------.
+| yynewstate -- Push a new state, which is found in yystate.  |
+`------------------------------------------------------------*/
+ yynewstate:
+  /* In all cases, when you get here, the value and location stacks
+     have just been pushed. so pushing a state here evens the stacks.
+     */
+  yyssp++;
+
+ yysetstate:
+  *yyssp = yystate;
+
+  if (yyssp >= yyss + yystacksize - 1)
+    {
+      /* Get the current used size of the three stacks, in elements.  */
+      YYSIZE_T yysize = yyssp - yyss + 1;
+
+#ifdef yyoverflow
+      {
+	/* Give user a chance to reallocate the stack. Use copies of
+	   these so that the &'s don't force the real ones into
+	   memory.  */
+	YYSTYPE *yyvs1 = yyvs;
+	short *yyss1 = yyss;
+
+	/* Each stack pointer address is followed by the size of the
+	   data in use in that stack, in bytes.  */
+# if YYLSP_NEEDED
+	YYLTYPE *yyls1 = yyls;
+	/* This used to be a conditional around just the two extra args,
+	   but that might be undefined if yyoverflow is a macro.  */
+	yyoverflow ("parser stack overflow",
+		    &yyss1, yysize * sizeof (*yyssp),
+		    &yyvs1, yysize * sizeof (*yyvsp),
+		    &yyls1, yysize * sizeof (*yylsp),
+		    &yystacksize);
+	yyls = yyls1;
+# else
+	yyoverflow ("parser stack overflow",
+		    &yyss1, yysize * sizeof (*yyssp),
+		    &yyvs1, yysize * sizeof (*yyvsp),
+		    &yystacksize);
+# endif
+	yyss = yyss1;
+	yyvs = yyvs1;
+      }
+#else /* no yyoverflow */
+# ifndef YYSTACK_RELOCATE
+      goto yyoverflowlab;
+# else
+      /* Extend the stack our own way.  */
+      if (yystacksize >= YYMAXDEPTH)
+	goto yyoverflowlab;
+      yystacksize *= 2;
+      if (yystacksize > YYMAXDEPTH)
+	yystacksize = YYMAXDEPTH;
+
+      {
+	short *yyss1 = yyss;
+	union yyalloc *yyptr =
+	  (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
+	if (! yyptr)
+	  goto yyoverflowlab;
+	YYSTACK_RELOCATE (yyss);
+	YYSTACK_RELOCATE (yyvs);
+# if YYLSP_NEEDED
+	YYSTACK_RELOCATE (yyls);
+# endif
+# undef YYSTACK_RELOCATE
+	if (yyss1 != yyssa)
+	  YYSTACK_FREE (yyss1);
+      }
+# endif
+#endif /* no yyoverflow */
+
+      yyssp = yyss + yysize - 1;
+      yyvsp = yyvs + yysize - 1;
+#if YYLSP_NEEDED
+      yylsp = yyls + yysize - 1;
+#endif
+
+      YYDPRINTF ((stderr, "Stack size increased to %lu\n",
+		  (unsigned long int) yystacksize));
+
+      if (yyssp >= yyss + yystacksize - 1)
+	YYABORT;
+    }
+
+  YYDPRINTF ((stderr, "Entering state %d\n", yystate));
+
+  goto yybackup;
+
+
+/*-----------.
+| yybackup.  |
+`-----------*/
+yybackup:
+
+/* Do appropriate processing given the current state.  */
+/* Read a lookahead token if we need one and don't already have one.  */
+/* yyresume: */
+
+  /* First try to decide what to do without reference to lookahead token.  */
+
+  yyn = yypact[yystate];
+  if (yyn == YYFLAG)
+    goto yydefault;
+
+  /* Not known => get a lookahead token if don't already have one.  */
+
+  /* yychar is either YYEMPTY or YYEOF
+     or a valid token in external form.  */
+
+  if (yychar == YYEMPTY)
+    {
+      YYDPRINTF ((stderr, "Reading a token: "));
+      yychar = YYLEX;
+    }
+
+  /* Convert token to internal form (in yychar1) for indexing tables with */
+
+  if (yychar <= 0)		/* This means end of input. */
+    {
+      yychar1 = 0;
+      yychar = YYEOF;		/* Don't call YYLEX any more */
+
+      YYDPRINTF ((stderr, "Now at end of input.\n"));
+    }
+  else
+    {
+      yychar1 = YYTRANSLATE (yychar);
+
+#if YYDEBUG
+     /* We have to keep this `#if YYDEBUG', since we use variables
+	which are defined only if `YYDEBUG' is set.  */
+      if (yydebug)
+	{
+	  YYFPRINTF (stderr, "Next token is %d (%s",
+		     yychar, yytname[yychar1]);
+	  /* Give the individual parser a way to print the precise
+	     meaning of a token, for further debugging info.  */
+# ifdef YYPRINT
+	  YYPRINT (stderr, yychar, yylval);
+# endif
+	  YYFPRINTF (stderr, ")\n");
+	}
+#endif
+    }
+
+  yyn += yychar1;
+  if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != yychar1)
+    goto yydefault;
+
+  yyn = yytable[yyn];
+
+  /* yyn is what to do for this token type in this state.
+     Negative => reduce, -yyn is rule number.
+     Positive => shift, yyn is new state.
+       New state is final state => don't bother to shift,
+       just return success.
+     0, or most negative number => error.  */
+
+  if (yyn < 0)
+    {
+      if (yyn == YYFLAG)
+	goto yyerrlab;
+      yyn = -yyn;
+      goto yyreduce;
+    }
+  else if (yyn == 0)
+    goto yyerrlab;
+
+  if (yyn == YYFINAL)
+    YYACCEPT;
+
+  /* Shift the lookahead token.  */
+  YYDPRINTF ((stderr, "Shifting token %d (%s), ",
+	      yychar, yytname[yychar1]));
+
+  /* Discard the token being shifted unless it is eof.  */
+  if (yychar != YYEOF)
+    yychar = YYEMPTY;
+
+  *++yyvsp = yylval;
+#if YYLSP_NEEDED
+  *++yylsp = yylloc;
+#endif
+
+  /* Count tokens shifted since error; after three, turn off error
+     status.  */
+  if (yyerrstatus)
+    yyerrstatus--;
+
+  yystate = yyn;
+  goto yynewstate;
+
+
+/*-----------------------------------------------------------.
+| yydefault -- do the default action for the current state.  |
+`-----------------------------------------------------------*/
+yydefault:
+  yyn = yydefact[yystate];
+  if (yyn == 0)
+    goto yyerrlab;
+  goto yyreduce;
+
+
+/*-----------------------------.
+| yyreduce -- Do a reduction.  |
+`-----------------------------*/
+yyreduce:
+  /* yyn is the number of a rule to reduce with.  */
+  yylen = yyr2[yyn];
+
+  /* If YYLEN is nonzero, implement the default value of the action:
+     `$$ = $1'.
+
+     Otherwise, the following line sets YYVAL to the semantic value of
+     the lookahead token.  This behavior is undocumented and Bison
+     users should not rely upon it.  Assigning to YYVAL
+     unconditionally makes the parser a bit smaller, and it avoids a
+     GCC warning that YYVAL may be used uninitialized.  */
+  yyval = yyvsp[1-yylen];
+
+#if YYLSP_NEEDED
+  /* Similarly for the default location.  Let the user run additional
+     commands if for instance locations are ranges.  */
+  yyloc = yylsp[1-yylen];
+  YYLLOC_DEFAULT (yyloc, (yylsp - yylen), yylen);
+#endif
+
+#if YYDEBUG
+  /* We have to keep this `#if YYDEBUG', since we use variables which
+     are defined only if `YYDEBUG' is set.  */
+  if (yydebug)
+    {
+      int yyi;
+
+      YYFPRINTF (stderr, "Reducing via rule %d (line %d), ",
+		 yyn, yyrline[yyn]);
+
+      /* Print the symbols being reduced, and their result.  */
+      for (yyi = yyprhs[yyn]; yyrhs[yyi] > 0; yyi++)
+	YYFPRINTF (stderr, "%s ", yytname[yyrhs[yyi]]);
+      YYFPRINTF (stderr, " -> %s\n", yytname[yyr1[yyn]]);
+    }
+#endif
+
+  switch (yyn) {
+
+case 1:
+#line 345 "parse.y"
+{
+			lex_state = EXPR_BEG;
+                        top_local_init();
+			if (ruby_class == rb_cObject) class_nest = 0;
+			else class_nest = 1;
+		    }
+    break;
+case 2:
+#line 352 "parse.y"
+{
+			if (yyvsp[0].node && !compile_for_eval) {
+                            /* last expression should not be void */
+			    if (nd_type(yyvsp[0].node) != NODE_BLOCK) void_expr(yyvsp[0].node);
+			    else {
+				NODE *node = yyvsp[0].node;
+				while (node->nd_next) {
+				    node = node->nd_next;
+				}
+				void_expr(node->nd_head);
+			    }
+			}
+			ruby_eval_tree = block_append(ruby_eval_tree, yyvsp[0].node);
+                        top_local_setup();
+			class_nest = 0;
+		    }
+    break;
+case 3:
+#line 374 "parse.y"
+{
+		        yyval.node = yyvsp[-3].node;
+			if (yyvsp[-2].node) {
+			    yyval.node = NEW_RESCUE(yyvsp[-3].node, yyvsp[-2].node, yyvsp[-1].node);
+			}
+			else if (yyvsp[-1].node) {
+			    rb_warn("else without rescue is useless");
+			    yyval.node = block_append(yyval.node, yyvsp[-1].node);
+			}
+			if (yyvsp[0].node) {
+			    yyval.node = NEW_ENSURE(yyval.node, yyvsp[0].node);
+			}
+			fixpos(yyval.node, yyvsp[-3].node);
+		    }
+    break;
+case 4:
+#line 391 "parse.y"
+{
+			void_stmts(yyvsp[-1].node);
+		        yyval.node = yyvsp[-1].node;
+		    }
+    break;
+case 6:
+#line 399 "parse.y"
+{
+			yyval.node = newline_node(yyvsp[0].node);
+		    }
+    break;
+case 7:
+#line 403 "parse.y"
+{
+			yyval.node = block_append(yyvsp[-2].node, newline_node(yyvsp[0].node));
+		    }
+    break;
+case 8:
+#line 407 "parse.y"
+{
+			yyval.node = yyvsp[0].node;
+		    }
+    break;
+case 9:
+#line 412 "parse.y"
+{lex_state = EXPR_FNAME;}
+    break;
+case 10:
+#line 413 "parse.y"
+{
+		        yyval.node = NEW_ALIAS(yyvsp[-2].id, yyvsp[0].id);
+		    }
+    break;
+case 11:
+#line 417 "parse.y"
+{
+		        yyval.node = NEW_VALIAS(yyvsp[-1].id, yyvsp[0].id);
+		    }
+    break;
+case 12:
+#line 421 "parse.y"
+{
+			char buf[3];
+
+			sprintf(buf, "$%c", (char)yyvsp[0].node->nd_nth);
+		        yyval.node = NEW_VALIAS(yyvsp[-1].id, rb_intern(buf));
+		    }
+    break;
+case 13:
+#line 428 "parse.y"
+{
+		        yyerror("can't make alias for the number variables");
+		        yyval.node = 0;
+		    }
+    break;
+case 14:
+#line 433 "parse.y"
+{
+			yyval.node = yyvsp[0].node;
+		    }
+    break;
+case 15:
+#line 437 "parse.y"
+{
+			yyval.node = NEW_IF(cond(yyvsp[0].node), yyvsp[-2].node, 0);
+		        fixpos(yyval.node, yyvsp[0].node);
+			if (cond_negative(&yyval.node->nd_cond)) {
+		            yyval.node->nd_else = yyval.node->nd_body;
+		            yyval.node->nd_body = 0;
+			}
+		    }
+    break;
+case 16:
+#line 446 "parse.y"
+{
+			yyval.node = NEW_UNLESS(cond(yyvsp[0].node), yyvsp[-2].node, 0);
+		        fixpos(yyval.node, yyvsp[0].node);
+			if (cond_negative(&yyval.node->nd_cond)) {
+		            yyval.node->nd_body = yyval.node->nd_else;
+		            yyval.node->nd_else = 0;
+			}
+		    }
+    break;
+case 17:
+#line 455 "parse.y"
+{
+			if (yyvsp[-2].node && nd_type(yyvsp[-2].node) == NODE_BEGIN) {
+			    yyval.node = NEW_WHILE(cond(yyvsp[0].node), yyvsp[-2].node->nd_body, 0);
+			}
+			else {
+			    yyval.node = NEW_WHILE(cond(yyvsp[0].node), yyvsp[-2].node, 1);
+			}
+			if (cond_negative(&yyval.node->nd_cond)) {
+			    nd_set_type(yyval.node, NODE_UNTIL);
+			}
+		    }
+    break;
+case 18:
+#line 467 "parse.y"
+{
+			if (yyvsp[-2].node && nd_type(yyvsp[-2].node) == NODE_BEGIN) {
+			    yyval.node = NEW_UNTIL(cond(yyvsp[0].node), yyvsp[-2].node->nd_body, 0);
+			}
+			else {
+			    yyval.node = NEW_UNTIL(cond(yyvsp[0].node), yyvsp[-2].node, 1);
+			}
+			if (cond_negative(&yyval.node->nd_cond)) {
+			    nd_set_type(yyval.node, NODE_WHILE);
+			}
+		    }
+    break;
+case 19:
+#line 479 "parse.y"
+{
+			yyval.node = NEW_RESCUE(yyvsp[-2].node, NEW_RESBODY(0,yyvsp[0].node,0), 0);
+		    }
+    break;
+case 20:
+#line 483 "parse.y"
+{
+			if (in_def || in_single) {
+			    yyerror("BEGIN in method");
+			}
+			local_push(0);
+		    }
+    break;
+case 21:
+#line 490 "parse.y"
+{
+			ruby_eval_tree_begin = block_append(ruby_eval_tree_begin,
+						            NEW_PREEXE(yyvsp[-1].node));
+		        local_pop();
+		        yyval.node = 0;
+		    }
+    break;
+case 22:
+#line 497 "parse.y"
+{
+			if (in_def || in_single) {
+			    rb_warn("END in method; use at_exit");
+			}
+
+			yyval.node = NEW_ITER(0, NEW_POSTEXE(), yyvsp[-1].node);
+		    }
+    break;
+case 23:
+#line 505 "parse.y"
+{
+			yyval.node = node_assign(yyvsp[-2].node, yyvsp[0].node);
+		    }
+    break;
+case 24:
+#line 509 "parse.y"
+{
+			value_expr(yyvsp[0].node);
+			yyvsp[-2].node->nd_value = (yyvsp[-2].node->nd_head) ? NEW_TO_ARY(yyvsp[0].node) : NEW_ARRAY(yyvsp[0].node);
+			yyval.node = yyvsp[-2].node;
+		    }
+    break;
+case 25:
+#line 515 "parse.y"
+{
+			value_expr(yyvsp[0].node);
+			if (yyvsp[-2].node) {
+			    ID vid = yyvsp[-2].node->nd_vid;
+			    if (yyvsp[-1].id == tOROP) {
+				yyvsp[-2].node->nd_value = yyvsp[0].node;
+				yyval.node = NEW_OP_ASGN_OR(gettable(vid), yyvsp[-2].node);
+				if (is_asgn_or_id(vid)) {
+				    yyval.node->nd_aid = vid;
+				}
+			    }
+			    else if (yyvsp[-1].id == tANDOP) {
+				yyvsp[-2].node->nd_value = yyvsp[0].node;
+				yyval.node = NEW_OP_ASGN_AND(gettable(vid), yyvsp[-2].node);
+			    }
+			    else {
+				yyval.node = yyvsp[-2].node;
+				yyval.node->nd_value = call_op(gettable(vid),yyvsp[-1].id,1,yyvsp[0].node);
+			    }
+			}
+			else {
+			    yyval.node = 0;
+			}
+		    }
+    break;
+case 26:
+#line 540 "parse.y"
+{
+                        NODE *args;
+
+			value_expr(yyvsp[0].node);
+		        args = NEW_LIST(yyvsp[0].node);
+			if (yyvsp[-3].node && nd_type(yyvsp[-3].node) != NODE_ARRAY)
+			    yyvsp[-3].node = NEW_LIST(yyvsp[-3].node);
+			yyvsp[-3].node = list_append(yyvsp[-3].node, NEW_NIL());
+			list_concat(args, yyvsp[-3].node);
+			if (yyvsp[-1].id == tOROP) {
+			    yyvsp[-1].id = 0;
+			}
+			else if (yyvsp[-1].id == tANDOP) {
+			    yyvsp[-1].id = 1;
+			}
+			yyval.node = NEW_OP_ASGN1(yyvsp[-5].node, yyvsp[-1].id, args);
+		        fixpos(yyval.node, yyvsp[-5].node);
+		    }
+    break;
+case 27:
+#line 559 "parse.y"
+{
+			value_expr(yyvsp[0].node);
+			if (yyvsp[-1].id == tOROP) {
+			    yyvsp[-1].id = 0;
+			}
+			else if (yyvsp[-1].id == tANDOP) {
+			    yyvsp[-1].id = 1;
+			}
+			yyval.node = NEW_OP_ASGN2(yyvsp[-4].node, yyvsp[-2].id, yyvsp[-1].id, yyvsp[0].node);
+		        fixpos(yyval.node, yyvsp[-4].node);
+		    }
+    break;
+case 28:
+#line 571 "parse.y"
+{
+			value_expr(yyvsp[0].node);
+			if (yyvsp[-1].id == tOROP) {
+			    yyvsp[-1].id = 0;
+			}
+			else if (yyvsp[-1].id == tANDOP) {
+			    yyvsp[-1].id = 1;
+			}
+			yyval.node = NEW_OP_ASGN2(yyvsp[-4].node, yyvsp[-2].id, yyvsp[-1].id, yyvsp[0].node);
+		        fixpos(yyval.node, yyvsp[-4].node);
+		    }
+    break;
+case 29:
+#line 583 "parse.y"
+{
+			value_expr(yyvsp[0].node);
+			if (yyvsp[-1].id == tOROP) {
+			    yyvsp[-1].id = 0;
+			}
+			else if (yyvsp[-1].id == tANDOP) {
+			    yyvsp[-1].id = 1;
+			}
+			yyval.node = NEW_OP_ASGN2(yyvsp[-4].node, yyvsp[-2].id, yyvsp[-1].id, yyvsp[0].node);
+		        fixpos(yyval.node, yyvsp[-4].node);
+		    }
+    break;
+case 30:
+#line 595 "parse.y"
+{
+		        rb_backref_error(yyvsp[-2].node);
+			yyval.node = 0;
+		    }
+    break;
+case 31:
+#line 600 "parse.y"
+{
+			yyval.node = node_assign(yyvsp[-2].node, NEW_SVALUE(yyvsp[0].node));
+		    }
+    break;
+case 32:
+#line 604 "parse.y"
+{
+			yyvsp[-2].node->nd_value = (yyvsp[-2].node->nd_head) ? NEW_TO_ARY(yyvsp[0].node) : NEW_ARRAY(yyvsp[0].node);
+			yyval.node = yyvsp[-2].node;
+		    }
+    break;
+case 33:
+#line 609 "parse.y"
+{
+			yyvsp[-2].node->nd_value = yyvsp[0].node;
+			yyval.node = yyvsp[-2].node;
+		    }
+    break;
+case 36:
+#line 618 "parse.y"
+{
+			yyval.node = logop(NODE_AND, yyvsp[-2].node, yyvsp[0].node);
+		    }
+    break;
+case 37:
+#line 622 "parse.y"
+{
+			yyval.node = logop(NODE_OR, yyvsp[-2].node, yyvsp[0].node);
+		    }
+    break;
+case 38:
+#line 626 "parse.y"
+{
+			yyval.node = NEW_NOT(cond(yyvsp[0].node));
+		    }
+    break;
+case 39:
+#line 630 "parse.y"
+{
+			yyval.node = NEW_NOT(cond(yyvsp[0].node));
+		    }
+    break;
+case 41:
+#line 637 "parse.y"
+{
+			value_expr(yyval.node);
+			yyval.node = yyvsp[0].node;
+		    }
+    break;
+case 44:
+#line 646 "parse.y"
+{
+			yyval.node = NEW_RETURN(ret_args(yyvsp[0].node));
+		    }
+    break;
+case 45:
+#line 650 "parse.y"
+{
+			yyval.node = NEW_BREAK(ret_args(yyvsp[0].node));
+		    }
+    break;
+case 46:
+#line 654 "parse.y"
+{
+			yyval.node = NEW_NEXT(ret_args(yyvsp[0].node));
+		    }
+    break;
+case 48:
+#line 661 "parse.y"
+{
+			yyval.node = new_call(yyvsp[-3].node, yyvsp[-1].id, yyvsp[0].node);
+		    }
+    break;
+case 49:
+#line 665 "parse.y"
+{
+			yyval.node = new_call(yyvsp[-3].node, yyvsp[-1].id, yyvsp[0].node);
+		    }
+    break;
+case 50:
+#line 671 "parse.y"
+{
+			yyval.vars = dyna_push();
+			yyvsp[0].num = ruby_sourceline;
+		    }
+    break;
+case 51:
+#line 675 "parse.y"
+{yyval.vars = ruby_dyna_vars;}
+    break;
+case 52:
+#line 678 "parse.y"
+{
+			yyval.node = NEW_ITER(yyvsp[-3].node, 0, dyna_init(yyvsp[-1].node, yyvsp[-2].vars));
+			nd_set_line(yyval.node, yyvsp[-5].num);
+			dyna_pop(yyvsp[-4].vars);
+		    }
+    break;
+case 53:
+#line 686 "parse.y"
+{
+			yyval.node = new_fcall(yyvsp[-1].id, yyvsp[0].node);
+		        fixpos(yyval.node, yyvsp[0].node);
+		   }
+    break;
+case 54:
+#line 691 "parse.y"
+{
+			yyval.node = new_fcall(yyvsp[-2].id, yyvsp[-1].node);
+			if (yyvsp[0].node) {
+			    if (nd_type(yyval.node) == NODE_BLOCK_PASS) {
+				rb_compile_error("both block arg and actual block given");
+			    }
+			    yyvsp[0].node->nd_iter = yyval.node;
+			    yyval.node = yyvsp[0].node;
+			}
+		        fixpos(yyval.node, yyvsp[-1].node);
+		   }
+    break;
+case 55:
+#line 703 "parse.y"
+{
+			yyval.node = new_call(yyvsp[-3].node, yyvsp[-1].id, yyvsp[0].node);
+		        fixpos(yyval.node, yyvsp[-3].node);
+		    }
+    break;
+case 56:
+#line 708 "parse.y"
+{
+			yyval.node = new_call(yyvsp[-4].node, yyvsp[-2].id, yyvsp[-1].node);
+			if (yyvsp[0].node) {
+			    if (nd_type(yyval.node) == NODE_BLOCK_PASS) {
+				rb_compile_error("both block arg and actual block given");
+			    }
+			    yyvsp[0].node->nd_iter = yyval.node;
+			    yyval.node = yyvsp[0].node;
+			}
+		        fixpos(yyval.node, yyvsp[-4].node);
+		   }
+    break;
+case 57:
+#line 720 "parse.y"
+{
+			yyval.node = new_call(yyvsp[-3].node, yyvsp[-1].id, yyvsp[0].node);
+		        fixpos(yyval.node, yyvsp[-3].node);
+		    }
+    break;
+case 58:
+#line 725 "parse.y"
+{
+			yyval.node = new_call(yyvsp[-4].node, yyvsp[-2].id, yyvsp[-1].node);
+			if (yyvsp[0].node) {
+			    if (nd_type(yyval.node) == NODE_BLOCK_PASS) {
+				rb_compile_error("both block arg and actual block given");
+			    }
+			    yyvsp[0].node->nd_iter = yyval.node;
+			    yyval.node = yyvsp[0].node;
+			}
+		        fixpos(yyval.node, yyvsp[-4].node);
+		   }
+    break;
+case 59:
+#line 737 "parse.y"
+{
+			yyval.node = new_super(yyvsp[0].node);
+		        fixpos(yyval.node, yyvsp[0].node);
+		    }
+    break;
+case 60:
+#line 742 "parse.y"
+{
+			yyval.node = new_yield(yyvsp[0].node);
+		        fixpos(yyval.node, yyvsp[0].node);
+		    }
+    break;
+case 62:
+#line 750 "parse.y"
+{
+			yyval.node = yyvsp[-1].node;
+		    }
+    break;
+case 64:
+#line 757 "parse.y"
+{
+			yyval.node = NEW_MASGN(NEW_LIST(yyvsp[-1].node), 0);
+		    }
+    break;
+case 65:
+#line 763 "parse.y"
+{
+			yyval.node = NEW_MASGN(yyvsp[0].node, 0);
+		    }
+    break;
+case 66:
+#line 767 "parse.y"
+{
+			yyval.node = NEW_MASGN(list_append(yyvsp[-1].node,yyvsp[0].node), 0);
+		    }
+    break;
+case 67:
+#line 771 "parse.y"
+{
+			yyval.node = NEW_MASGN(yyvsp[-2].node, yyvsp[0].node);
+		    }
+    break;
+case 68:
+#line 775 "parse.y"
+{
+			yyval.node = NEW_MASGN(yyvsp[-1].node, -1);
+		    }
+    break;
+case 69:
+#line 779 "parse.y"
+{
+			yyval.node = NEW_MASGN(0, yyvsp[0].node);
+		    }
+    break;
+case 70:
+#line 783 "parse.y"
+{
+			yyval.node = NEW_MASGN(0, -1);
+		    }
+    break;
+case 72:
+#line 790 "parse.y"
+{
+			yyval.node = yyvsp[-1].node;
+		    }
+    break;
+case 73:
+#line 796 "parse.y"
+{
+			yyval.node = NEW_LIST(yyvsp[-1].node);
+		    }
+    break;
+case 74:
+#line 800 "parse.y"
+{
+			yyval.node = list_append(yyvsp[-2].node, yyvsp[-1].node);
+		    }
+    break;
+case 75:
+#line 806 "parse.y"
+{
+			yyval.node = assignable(yyvsp[0].id, 0);
+		    }
+    break;
+case 76:
+#line 810 "parse.y"
+{
+			yyval.node = aryset(yyvsp[-3].node, yyvsp[-1].node);
+		    }
+    break;
+case 77:
+#line 814 "parse.y"
+{
+			yyval.node = attrset(yyvsp[-2].node, yyvsp[0].id);
+		    }
+    break;
+case 78:
+#line 818 "parse.y"
+{
+			yyval.node = attrset(yyvsp[-2].node, yyvsp[0].id);
+		    }
+    break;
+case 79:
+#line 822 "parse.y"
+{
+			yyval.node = attrset(yyvsp[-2].node, yyvsp[0].id);
+		    }
+    break;
+case 80:
+#line 826 "parse.y"
+{
+			if (in_def || in_single)
+			    yyerror("dynamic constant assignment");
+			yyval.node = NEW_CDECL(0, 0, NEW_COLON2(yyvsp[-2].node, yyvsp[0].id));
+		    }
+    break;
+case 81:
+#line 832 "parse.y"
+{
+			if (in_def || in_single)
+			    yyerror("dynamic constant assignment");
+			yyval.node = NEW_CDECL(0, 0, NEW_COLON3(yyvsp[0].id));
+		    }
+    break;
+case 82:
+#line 838 "parse.y"
+{
+		        rb_backref_error(yyvsp[0].node);
+			yyval.node = 0;
+		    }
+    break;
+case 83:
+#line 845 "parse.y"
+{
+			yyval.node = assignable(yyvsp[0].id, 0);
+		    }
+    break;
+case 84:
+#line 849 "parse.y"
+{
+			yyval.node = aryset(yyvsp[-3].node, yyvsp[-1].node);
+		    }
+    break;
+case 85:
+#line 853 "parse.y"
+{
+			yyval.node = attrset(yyvsp[-2].node, yyvsp[0].id);
+		    }
+    break;
+case 86:
+#line 857 "parse.y"
+{
+			yyval.node = attrset(yyvsp[-2].node, yyvsp[0].id);
+		    }
+    break;
+case 87:
+#line 861 "parse.y"
+{
+			yyval.node = attrset(yyvsp[-2].node, yyvsp[0].id);
+		    }
+    break;
+case 88:
+#line 865 "parse.y"
+{
+			if (in_def || in_single)
+			    yyerror("dynamic constant assignment");
+			yyval.node = NEW_CDECL(0, 0, NEW_COLON2(yyvsp[-2].node, yyvsp[0].id));
+		    }
+    break;
+case 89:
+#line 871 "parse.y"
+{
+			if (in_def || in_single)
+			    yyerror("dynamic constant assignment");
+			yyval.node = NEW_CDECL(0, 0, NEW_COLON3(yyvsp[0].id));
+		    }
+    break;
+case 90:
+#line 877 "parse.y"
+{
+		        rb_backref_error(yyvsp[0].node);
+			yyval.node = 0;
+		    }
+    break;
+case 91:
+#line 884 "parse.y"
+{
+			yyerror("class/module name must be CONSTANT");
+		    }
+    break;
+case 93:
+#line 891 "parse.y"
+{
+			yyval.node = NEW_COLON3(yyvsp[0].id);
+		    }
+    break;
+case 94:
+#line 895 "parse.y"
+{
+			yyval.node = NEW_COLON2(0, yyval.node);
+		    }
+    break;
+case 95:
+#line 899 "parse.y"
+{
+			yyval.node = NEW_COLON2(yyvsp[-2].node, yyvsp[0].id);
+		    }
+    break;
+case 99:
+#line 908 "parse.y"
+{
+			lex_state = EXPR_END;
+			yyval.id = yyvsp[0].id;
+		    }
+    break;
+case 100:
+#line 913 "parse.y"
+{
+			lex_state = EXPR_END;
+			yyval.id = yyvsp[0].id;
+		    }
+    break;
+case 103:
+#line 924 "parse.y"
+{
+			yyval.node = NEW_UNDEF(yyvsp[0].id);
+		    }
+    break;
+case 104:
+#line 927 "parse.y"
+{lex_state = EXPR_FNAME;}
+    break;
+case 105:
+#line 928 "parse.y"
+{
+			yyval.node = block_append(yyvsp[-3].node, NEW_UNDEF(yyvsp[0].id));
+		    }
+    break;
+case 106:
+#line 933 "parse.y"
+{ yyval.id = '|'; }
+    break;
+case 107:
+#line 934 "parse.y"
+{ yyval.id = '^'; }
+    break;
+case 108:
+#line 935 "parse.y"
+{ yyval.id = '&'; }
+    break;
+case 109:
+#line 936 "parse.y"
+{ yyval.id = tCMP; }
+    break;
+case 110:
+#line 937 "parse.y"
+{ yyval.id = tEQ; }
+    break;
+case 111:
+#line 938 "parse.y"
+{ yyval.id = tEQQ; }
+    break;
+case 112:
+#line 939 "parse.y"
+{ yyval.id = tMATCH; }
+    break;
+case 113:
+#line 940 "parse.y"
+{ yyval.id = '>'; }
+    break;
+case 114:
+#line 941 "parse.y"
+{ yyval.id = tGEQ; }
+    break;
+case 115:
+#line 942 "parse.y"
+{ yyval.id = '<'; }
+    break;
+case 116:
+#line 943 "parse.y"
+{ yyval.id = tLEQ; }
+    break;
+case 117:
+#line 944 "parse.y"
+{ yyval.id = tLSHFT; }
+    break;
+case 118:
+#line 945 "parse.y"
+{ yyval.id = tRSHFT; }
+    break;
+case 119:
+#line 946 "parse.y"
+{ yyval.id = '+'; }
+    break;
+case 120:
+#line 947 "parse.y"
+{ yyval.id = '-'; }
+    break;
+case 121:
+#line 948 "parse.y"
+{ yyval.id = '*'; }
+    break;
+case 122:
+#line 949 "parse.y"
+{ yyval.id = '*'; }
+    break;
+case 123:
+#line 950 "parse.y"
+{ yyval.id = '/'; }
+    break;
+case 124:
+#line 951 "parse.y"
+{ yyval.id = '%'; }
+    break;
+case 125:
+#line 952 "parse.y"
+{ yyval.id = tPOW; }
+    break;
+case 126:
+#line 953 "parse.y"
+{ yyval.id = '~'; }
+    break;
+case 127:
+#line 954 "parse.y"
+{ yyval.id = tUPLUS; }
+    break;
+case 128:
+#line 955 "parse.y"
+{ yyval.id = tUMINUS; }
+    break;
+case 129:
+#line 956 "parse.y"
+{ yyval.id = tAREF; }
+    break;
+case 130:
+#line 957 "parse.y"
+{ yyval.id = tASET; }
+    break;
+case 131:
+#line 958 "parse.y"
+{ yyval.id = '`'; }
+    break;
+case 173:
+#line 971 "parse.y"
+{
+			yyval.node = node_assign(yyvsp[-2].node, yyvsp[0].node);
+		    }
+    break;
+case 174:
+#line 975 "parse.y"
+{
+			yyval.node = node_assign(yyvsp[-4].node, NEW_RESCUE(yyvsp[-2].node, NEW_RESBODY(0,yyvsp[0].node,0), 0));
+		    }
+    break;
+case 175:
+#line 979 "parse.y"
+{
+			value_expr(yyvsp[0].node);
+			if (yyvsp[-2].node) {
+			    ID vid = yyvsp[-2].node->nd_vid;
+			    if (yyvsp[-1].id == tOROP) {
+				yyvsp[-2].node->nd_value = yyvsp[0].node;
+				yyval.node = NEW_OP_ASGN_OR(gettable(vid), yyvsp[-2].node);
+				if (is_asgn_or_id(vid)) {
+				    yyval.node->nd_aid = vid;
+				}
+			    }
+			    else if (yyvsp[-1].id == tANDOP) {
+				yyvsp[-2].node->nd_value = yyvsp[0].node;
+				yyval.node = NEW_OP_ASGN_AND(gettable(vid), yyvsp[-2].node);
+			    }
+			    else {
+				yyval.node = yyvsp[-2].node;
+				yyval.node->nd_value = call_op(gettable(vid),yyvsp[-1].id,1,yyvsp[0].node);
+			    }
+			}
+			else {
+			    yyval.node = 0;
+			}
+		    }
+    break;
+case 176:
+#line 1004 "parse.y"
+{
+                        NODE *args;
+
+			value_expr(yyvsp[0].node);
+			args = NEW_LIST(yyvsp[0].node);
+			if (yyvsp[-3].node && nd_type(yyvsp[-3].node) != NODE_ARRAY)
+			    yyvsp[-3].node = NEW_LIST(yyvsp[-3].node);
+			yyvsp[-3].node = list_append(yyvsp[-3].node, NEW_NIL());
+			list_concat(args, yyvsp[-3].node);
+			if (yyvsp[-1].id == tOROP) {
+			    yyvsp[-1].id = 0;
+			}
+			else if (yyvsp[-1].id == tANDOP) {
+			    yyvsp[-1].id = 1;
+			}
+			yyval.node = NEW_OP_ASGN1(yyvsp[-5].node, yyvsp[-1].id, args);
+		        fixpos(yyval.node, yyvsp[-5].node);
+		    }
+    break;
+case 177:
+#line 1023 "parse.y"
+{
+			value_expr(yyvsp[0].node);
+			if (yyvsp[-1].id == tOROP) {
+			    yyvsp[-1].id = 0;
+			}
+			else if (yyvsp[-1].id == tANDOP) {
+			    yyvsp[-1].id = 1;
+			}
+			yyval.node = NEW_OP_ASGN2(yyvsp[-4].node, yyvsp[-2].id, yyvsp[-1].id, yyvsp[0].node);
+		        fixpos(yyval.node, yyvsp[-4].node);
+		    }
+    break;
+case 178:
+#line 1035 "parse.y"
+{
+			value_expr(yyvsp[0].node);
+			if (yyvsp[-1].id == tOROP) {
+			    yyvsp[-1].id = 0;
+			}
+			else if (yyvsp[-1].id == tANDOP) {
+			    yyvsp[-1].id = 1;
+			}
+			yyval.node = NEW_OP_ASGN2(yyvsp[-4].node, yyvsp[-2].id, yyvsp[-1].id, yyvsp[0].node);
+		        fixpos(yyval.node, yyvsp[-4].node);
+		    }
+    break;
+case 179:
+#line 1047 "parse.y"
+{
+			value_expr(yyvsp[0].node);
+			if (yyvsp[-1].id == tOROP) {
+			    yyvsp[-1].id = 0;
+			}
+			else if (yyvsp[-1].id == tANDOP) {
+			    yyvsp[-1].id = 1;
+			}
+			yyval.node = NEW_OP_ASGN2(yyvsp[-4].node, yyvsp[-2].id, yyvsp[-1].id, yyvsp[0].node);
+		        fixpos(yyval.node, yyvsp[-4].node);
+		    }
+    break;
+case 180:
+#line 1059 "parse.y"
+{
+			yyerror("constant re-assignment");
+			yyval.node = 0;
+		    }
+    break;
+case 181:
+#line 1064 "parse.y"
+{
+			yyerror("constant re-assignment");
+			yyval.node = 0;
+		    }
+    break;
+case 182:
+#line 1069 "parse.y"
+{
+		        rb_backref_error(yyvsp[-2].node);
+			yyval.node = 0;
+		    }
+    break;
+case 183:
+#line 1074 "parse.y"
+{
+			value_expr(yyvsp[-2].node);
+			value_expr(yyvsp[0].node);
+			if (nd_type(yyvsp[-2].node) == NODE_LIT && FIXNUM_P(yyvsp[-2].node->nd_lit) &&
+			    nd_type(yyvsp[0].node) == NODE_LIT && FIXNUM_P(yyvsp[0].node->nd_lit)) {
+			    yyvsp[-2].node->nd_lit = rb_range_new(yyvsp[-2].node->nd_lit, yyvsp[0].node->nd_lit, Qfalse);
+			    yyval.node = yyvsp[-2].node;
+			}
+			else {
+			    yyval.node = NEW_DOT2(yyvsp[-2].node, yyvsp[0].node);
+			}
+		    }
+    break;
+case 184:
+#line 1087 "parse.y"
+{
+			value_expr(yyvsp[-2].node);
+			value_expr(yyvsp[0].node);
+			if (nd_type(yyvsp[-2].node) == NODE_LIT && FIXNUM_P(yyvsp[-2].node->nd_lit) &&
+			    nd_type(yyvsp[0].node) == NODE_LIT && FIXNUM_P(yyvsp[0].node->nd_lit)) {
+			    yyvsp[-2].node->nd_lit = rb_range_new(yyvsp[-2].node->nd_lit, yyvsp[0].node->nd_lit, Qtrue);
+			    yyval.node = yyvsp[-2].node;
+			}
+			else {
+			    yyval.node = NEW_DOT3(yyvsp[-2].node, yyvsp[0].node);
+			}
+		    }
+    break;
+case 185:
+#line 1100 "parse.y"
+{
+			yyval.node = call_op(yyvsp[-2].node, '+', 1, yyvsp[0].node);
+		    }
+    break;
+case 186:
+#line 1104 "parse.y"
+{
+		        yyval.node = call_op(yyvsp[-2].node, '-', 1, yyvsp[0].node);
+		    }
+    break;
+case 187:
+#line 1108 "parse.y"
+{
+		        yyval.node = call_op(yyvsp[-2].node, '*', 1, yyvsp[0].node);
+		    }
+    break;
+case 188:
+#line 1112 "parse.y"
+{
+			yyval.node = call_op(yyvsp[-2].node, '/', 1, yyvsp[0].node);
+		    }
+    break;
+case 189:
+#line 1116 "parse.y"
+{
+			yyval.node = call_op(yyvsp[-2].node, '%', 1, yyvsp[0].node);
+		    }
+    break;
+case 190:
+#line 1120 "parse.y"
+{
+			yyval.node = call_op(yyvsp[-2].node, tPOW, 1, yyvsp[0].node);
+		    }
+    break;
+case 191:
+#line 1124 "parse.y"
+{
+			yyval.node = call_op(call_op(yyvsp[-2].node, tPOW, 1, yyvsp[0].node), tUMINUS, 0, 0);
+		    }
+    break;
+case 192:
+#line 1128 "parse.y"
+{
+			yyval.node = call_op(call_op(yyvsp[-2].node, tPOW, 1, yyvsp[0].node), tUMINUS, 0, 0);
+		    }
+    break;
+case 193:
+#line 1132 "parse.y"
+{
+			if (yyvsp[0].node && nd_type(yyvsp[0].node) == NODE_LIT) {
+			    yyval.node = yyvsp[0].node;
+			}
+			else {
+			    yyval.node = call_op(yyvsp[0].node, tUPLUS, 0, 0);
+			}
+		    }
+    break;
+case 194:
+#line 1141 "parse.y"
+{
+			yyval.node = call_op(yyvsp[0].node, tUMINUS, 0, 0);
+		    }
+    break;
+case 195:
+#line 1145 "parse.y"
+{
+		        yyval.node = call_op(yyvsp[-2].node, '|', 1, yyvsp[0].node);
+		    }
+    break;
+case 196:
+#line 1149 "parse.y"
+{
+			yyval.node = call_op(yyvsp[-2].node, '^', 1, yyvsp[0].node);
+		    }
+    break;
+case 197:
+#line 1153 "parse.y"
+{
+			yyval.node = call_op(yyvsp[-2].node, '&', 1, yyvsp[0].node);
+		    }
+    break;
+case 198:
+#line 1157 "parse.y"
+{
+			yyval.node = call_op(yyvsp[-2].node, tCMP, 1, yyvsp[0].node);
+		    }
+    break;
+case 199:
+#line 1161 "parse.y"
+{
+			yyval.node = call_op(yyvsp[-2].node, '>', 1, yyvsp[0].node);
+		    }
+    break;
+case 200:
+#line 1165 "parse.y"
+{
+			yyval.node = call_op(yyvsp[-2].node, tGEQ, 1, yyvsp[0].node);
+		    }
+    break;
+case 201:
+#line 1169 "parse.y"
+{
+			yyval.node = call_op(yyvsp[-2].node, '<', 1, yyvsp[0].node);
+		    }
+    break;
+case 202:
+#line 1173 "parse.y"
+{
+			yyval.node = call_op(yyvsp[-2].node, tLEQ, 1, yyvsp[0].node);
+		    }
+    break;
+case 203:
+#line 1177 "parse.y"
+{
+			yyval.node = call_op(yyvsp[-2].node, tEQ, 1, yyvsp[0].node);
+		    }
+    break;
+case 204:
+#line 1181 "parse.y"
+{
+			yyval.node = call_op(yyvsp[-2].node, tEQQ, 1, yyvsp[0].node);
+		    }
+    break;
+case 205:
+#line 1185 "parse.y"
+{
+			yyval.node = NEW_NOT(call_op(yyvsp[-2].node, tEQ, 1, yyvsp[0].node));
+		    }
+    break;
+case 206:
+#line 1189 "parse.y"
+{
+			yyval.node = match_gen(yyvsp[-2].node, yyvsp[0].node);
+		    }
+    break;
+case 207:
+#line 1193 "parse.y"
+{
+			yyval.node = NEW_NOT(match_gen(yyvsp[-2].node, yyvsp[0].node));
+		    }
+    break;
+case 208:
+#line 1197 "parse.y"
+{
+			yyval.node = NEW_NOT(cond(yyvsp[0].node));
+		    }
+    break;
+case 209:
+#line 1201 "parse.y"
+{
+			yyval.node = call_op(yyvsp[0].node, '~', 0, 0);
+		    }
+    break;
+case 210:
+#line 1205 "parse.y"
+{
+			yyval.node = call_op(yyvsp[-2].node, tLSHFT, 1, yyvsp[0].node);
+		    }
+    break;
+case 211:
+#line 1209 "parse.y"
+{
+			yyval.node = call_op(yyvsp[-2].node, tRSHFT, 1, yyvsp[0].node);
+		    }
+    break;
+case 212:
+#line 1213 "parse.y"
+{
+			yyval.node = logop(NODE_AND, yyvsp[-2].node, yyvsp[0].node);
+		    }
+    break;
+case 213:
+#line 1217 "parse.y"
+{
+			yyval.node = logop(NODE_OR, yyvsp[-2].node, yyvsp[0].node);
+		    }
+    break;
+case 214:
+#line 1220 "parse.y"
+{in_defined = 1;}
+    break;
+case 215:
+#line 1221 "parse.y"
+{
+		        in_defined = 0;
+			yyval.node = NEW_DEFINED(yyvsp[0].node);
+		    }
+    break;
+case 216:
+#line 1226 "parse.y"
+{
+			yyval.node = NEW_IF(cond(yyvsp[-4].node), yyvsp[-2].node, yyvsp[0].node);
+		        fixpos(yyval.node, yyvsp[-4].node);
+		    }
+    break;
+case 217:
+#line 1231 "parse.y"
+{
+			yyval.node = yyvsp[0].node;
+		    }
+    break;
+case 218:
+#line 1237 "parse.y"
+{
+			value_expr(yyvsp[0].node);
+			yyval.node = yyvsp[0].node;
+		    }
+    break;
+case 220:
+#line 1245 "parse.y"
+{
+		        rb_warn("parenthesize argument(s) for future version");
+			yyval.node = NEW_LIST(yyvsp[-1].node);
+		    }
+    break;
+case 221:
+#line 1250 "parse.y"
+{
+			yyval.node = yyvsp[-1].node;
+		    }
+    break;
+case 222:
+#line 1254 "parse.y"
+{
+			value_expr(yyvsp[-1].node);
+			yyval.node = arg_concat(yyvsp[-4].node, yyvsp[-1].node);
+		    }
+    break;
+case 223:
+#line 1259 "parse.y"
+{
+			yyval.node = NEW_LIST(NEW_HASH(yyvsp[-1].node));
+		    }
+    break;
+case 224:
+#line 1263 "parse.y"
+{
+			value_expr(yyvsp[-1].node);
+			yyval.node = NEW_NEWLINE(NEW_SPLAT(yyvsp[-1].node));
+		    }
+    break;
+case 225:
+#line 1270 "parse.y"
+{
+			yyval.node = yyvsp[-1].node;
+		    }
+    break;
+case 226:
+#line 1274 "parse.y"
+{
+			yyval.node = yyvsp[-2].node;
+		    }
+    break;
+case 227:
+#line 1278 "parse.y"
+{
+		        rb_warn("parenthesize argument for future version");
+			yyval.node = NEW_LIST(yyvsp[-2].node);
+		    }
+    break;
+case 228:
+#line 1283 "parse.y"
+{
+		        rb_warn("parenthesize argument for future version");
+			yyval.node = list_append(yyvsp[-4].node, yyvsp[-2].node);
+		    }
+    break;
+case 231:
+#line 1294 "parse.y"
+{
+		        rb_warn("parenthesize argument(s) for future version");
+			yyval.node = NEW_LIST(yyvsp[0].node);
+		    }
+    break;
+case 232:
+#line 1299 "parse.y"
+{
+			yyval.node = arg_blk_pass(yyvsp[-1].node, yyvsp[0].node);
+		    }
+    break;
+case 233:
+#line 1303 "parse.y"
+{
+			yyval.node = arg_concat(yyvsp[-4].node, yyvsp[-1].node);
+			yyval.node = arg_blk_pass(yyval.node, yyvsp[0].node);
+		    }
+    break;
+case 234:
+#line 1308 "parse.y"
+{
+			yyval.node = NEW_LIST(NEW_HASH(yyvsp[-1].node));
+			yyval.node = arg_blk_pass(yyval.node, yyvsp[0].node);
+		    }
+    break;
+case 235:
+#line 1313 "parse.y"
+{
+			yyval.node = arg_concat(NEW_LIST(NEW_HASH(yyvsp[-4].node)), yyvsp[-1].node);
+			yyval.node = arg_blk_pass(yyval.node, yyvsp[0].node);
+		    }
+    break;
+case 236:
+#line 1318 "parse.y"
+{
+			yyval.node = list_append(yyvsp[-3].node, NEW_HASH(yyvsp[-1].node));
+			yyval.node = arg_blk_pass(yyval.node, yyvsp[0].node);
+		    }
+    break;
+case 237:
+#line 1323 "parse.y"
+{
+			value_expr(yyvsp[-1].node);
+			yyval.node = arg_concat(list_append(yyvsp[-6].node, NEW_HASH(yyvsp[-4].node)), yyvsp[-1].node);
+			yyval.node = arg_blk_pass(yyval.node, yyvsp[0].node);
+		    }
+    break;
+case 238:
+#line 1329 "parse.y"
+{
+			yyval.node = arg_blk_pass(NEW_SPLAT(yyvsp[-1].node), yyvsp[0].node);
+		    }
+    break;
+case 240:
+#line 1336 "parse.y"
+{
+			yyval.node = arg_blk_pass(list_concat(NEW_LIST(yyvsp[-3].node),yyvsp[-1].node), yyvsp[0].node);
+		    }
+    break;
+case 241:
+#line 1340 "parse.y"
+{
+                        yyval.node = arg_blk_pass(yyvsp[-2].node, yyvsp[0].node);
+                    }
+    break;
+case 242:
+#line 1344 "parse.y"
+{
+			yyval.node = arg_concat(NEW_LIST(yyvsp[-4].node), yyvsp[-1].node);
+			yyval.node = arg_blk_pass(yyval.node, yyvsp[0].node);
+		    }
+    break;
+case 243:
+#line 1349 "parse.y"
+{
+                       yyval.node = arg_concat(list_concat(NEW_LIST(yyvsp[-6].node),yyvsp[-4].node), yyvsp[-1].node);
+			yyval.node = arg_blk_pass(yyval.node, yyvsp[0].node);
+		    }
+    break;
+case 244:
+#line 1354 "parse.y"
+{
+			yyval.node = NEW_LIST(NEW_HASH(yyvsp[-1].node));
+			yyval.node = arg_blk_pass(yyval.node, yyvsp[0].node);
+		    }
+    break;
+case 245:
+#line 1359 "parse.y"
+{
+			yyval.node = arg_concat(NEW_LIST(NEW_HASH(yyvsp[-4].node)), yyvsp[-1].node);
+			yyval.node = arg_blk_pass(yyval.node, yyvsp[0].node);
+		    }
+    break;
+case 246:
+#line 1364 "parse.y"
+{
+			yyval.node = list_append(NEW_LIST(yyvsp[-3].node), NEW_HASH(yyvsp[-1].node));
+			yyval.node = arg_blk_pass(yyval.node, yyvsp[0].node);
+		    }
+    break;
+case 247:
+#line 1369 "parse.y"
+{
+			yyval.node = list_append(list_concat(NEW_LIST(yyvsp[-5].node),yyvsp[-3].node), NEW_HASH(yyvsp[-1].node));
+			yyval.node = arg_blk_pass(yyval.node, yyvsp[0].node);
+		    }
+    break;
+case 248:
+#line 1374 "parse.y"
+{
+			yyval.node = arg_concat(list_append(NEW_LIST(yyvsp[-6].node), NEW_HASH(yyvsp[-4].node)), yyvsp[-1].node);
+			yyval.node = arg_blk_pass(yyval.node, yyvsp[0].node);
+		    }
+    break;
+case 249:
+#line 1379 "parse.y"
+{
+			yyval.node = arg_concat(list_append(list_concat(NEW_LIST(yyvsp[-8].node), yyvsp[-6].node), NEW_HASH(yyvsp[-4].node)), yyvsp[-1].node);
+			yyval.node = arg_blk_pass(yyval.node, yyvsp[0].node);
+		    }
+    break;
+case 250:
+#line 1384 "parse.y"
+{
+			yyval.node = arg_blk_pass(NEW_SPLAT(yyvsp[-1].node), yyvsp[0].node);
+		    }
+    break;
+case 252:
+#line 1390 "parse.y"
+{
+			yyval.num = cmdarg_stack;
+			CMDARG_PUSH(1);
+		    }
+    break;
+case 253:
+#line 1395 "parse.y"
+{
+			/* CMDARG_POP() */
+		        cmdarg_stack = yyvsp[-1].num;
+			yyval.node = yyvsp[0].node;
+		    }
+    break;
+case 255:
+#line 1403 "parse.y"
+{lex_state = EXPR_ENDARG;}
+    break;
+case 256:
+#line 1404 "parse.y"
+{
+		        rb_warn("don't put space before argument parentheses");
+			yyval.node = 0;
+		    }
+    break;
+case 257:
+#line 1408 "parse.y"
+{lex_state = EXPR_ENDARG;}
+    break;
+case 258:
+#line 1409 "parse.y"
+{
+		        rb_warn("don't put space before argument parentheses");
+			yyval.node = yyvsp[-2].node;
+		    }
+    break;
+case 259:
+#line 1416 "parse.y"
+{
+			yyval.node = NEW_BLOCK_PASS(yyvsp[0].node);
+		    }
+    break;
+case 260:
+#line 1422 "parse.y"
+{
+			yyval.node = yyvsp[0].node;
+		    }
+    break;
+case 262:
+#line 1429 "parse.y"
+{
+			yyval.node = NEW_LIST(yyvsp[0].node);
+		    }
+    break;
+case 263:
+#line 1433 "parse.y"
+{
+			yyval.node = list_append(yyvsp[-2].node, yyvsp[0].node);
+		    }
+    break;
+case 264:
+#line 1439 "parse.y"
+{
+			yyval.node = list_append(yyvsp[-2].node, yyvsp[0].node);
+		    }
+    break;
+case 265:
+#line 1443 "parse.y"
+{
+			yyval.node = arg_concat(yyvsp[-3].node, yyvsp[0].node);
+		    }
+    break;
+case 266:
+#line 1447 "parse.y"
+{
+			yyval.node = NEW_SPLAT(yyvsp[0].node);
+		    }
+    break;
+case 275:
+#line 1461 "parse.y"
+{
+			yyval.node = NEW_FCALL(yyvsp[0].id, 0);
+		    }
+    break;
+case 276:
+#line 1465 "parse.y"
+{
+			yyvsp[0].num = ruby_sourceline;
+		    }
+    break;
+case 277:
+#line 1470 "parse.y"
+{
+			if (yyvsp[-1].node == NULL)
+			    yyval.node = NEW_NIL();
+			else
+			    yyval.node = NEW_BEGIN(yyvsp[-1].node);
+			nd_set_line(yyval.node, yyvsp[-3].num);
+		    }
+    break;
+case 278:
+#line 1477 "parse.y"
+{lex_state = EXPR_ENDARG;}
+    break;
+case 279:
+#line 1478 "parse.y"
+{
+		        rb_warning("(...) interpreted as grouped expression");
+			yyval.node = yyvsp[-3].node;
+		    }
+    break;
+case 280:
+#line 1483 "parse.y"
+{
+			yyval.node = yyvsp[-1].node;
+		    }
+    break;
+case 281:
+#line 1487 "parse.y"
+{
+			yyval.node = NEW_COLON2(yyvsp[-2].node, yyvsp[0].id);
+		    }
+    break;
+case 282:
+#line 1491 "parse.y"
+{
+			yyval.node = NEW_COLON3(yyvsp[0].id);
+		    }
+    break;
+case 283:
+#line 1495 "parse.y"
+{
+			if (yyvsp[-3].node && nd_type(yyvsp[-3].node) == NODE_SELF)
+			    yyval.node = NEW_FCALL(tAREF, yyvsp[-1].node);
+			else
+			    yyval.node = NEW_CALL(yyvsp[-3].node, tAREF, yyvsp[-1].node);
+			fixpos(yyval.node, yyvsp[-3].node);
+		    }
+    break;
+case 284:
+#line 1503 "parse.y"
+{
+		        if (yyvsp[-1].node == 0) {
+			    yyval.node = NEW_ZARRAY(); /* zero length array*/
+			}
+			else {
+			    yyval.node = yyvsp[-1].node;
+			}
+		    }
+    break;
+case 285:
+#line 1512 "parse.y"
+{
+			yyval.node = NEW_HASH(yyvsp[-1].node);
+		    }
+    break;
+case 286:
+#line 1516 "parse.y"
+{
+			yyval.node = NEW_RETURN(0);
+		    }
+    break;
+case 287:
+#line 1520 "parse.y"
+{
+			yyval.node = new_yield(yyvsp[-1].node);
+		    }
+    break;
+case 288:
+#line 1524 "parse.y"
+{
+			yyval.node = NEW_YIELD(0, Qfalse);
+		    }
+    break;
+case 289:
+#line 1528 "parse.y"
+{
+			yyval.node = NEW_YIELD(0, Qfalse);
+		    }
+    break;
+case 290:
+#line 1531 "parse.y"
+{in_defined = 1;}
+    break;
+case 291:
+#line 1532 "parse.y"
+{
+		        in_defined = 0;
+			yyval.node = NEW_DEFINED(yyvsp[-1].node);
+		    }
+    break;
+case 292:
+#line 1537 "parse.y"
+{
+			yyvsp[0].node->nd_iter = NEW_FCALL(yyvsp[-1].id, 0);
+			yyval.node = yyvsp[0].node;
+			fixpos(yyvsp[0].node->nd_iter, yyvsp[0].node);
+		    }
+    break;
+case 294:
+#line 1544 "parse.y"
+{
+			if (yyvsp[-1].node && nd_type(yyvsp[-1].node) == NODE_BLOCK_PASS) {
+			    rb_compile_error("both block arg and actual block given");
+			}
+			yyvsp[0].node->nd_iter = yyvsp[-1].node;
+			yyval.node = yyvsp[0].node;
+		        fixpos(yyval.node, yyvsp[-1].node);
+		    }
+    break;
+case 295:
+#line 1556 "parse.y"
+{
+			yyval.node = NEW_IF(cond(yyvsp[-4].node), yyvsp[-2].node, yyvsp[-1].node);
+		        fixpos(yyval.node, yyvsp[-4].node);
+			if (cond_negative(&yyval.node->nd_cond)) {
+		            NODE *tmp = yyval.node->nd_body;
+		            yyval.node->nd_body = yyval.node->nd_else;
+		            yyval.node->nd_else = tmp;
+			}
+		    }
+    break;
+case 296:
+#line 1569 "parse.y"
+{
+			yyval.node = NEW_UNLESS(cond(yyvsp[-4].node), yyvsp[-2].node, yyvsp[-1].node);
+		        fixpos(yyval.node, yyvsp[-4].node);
+			if (cond_negative(&yyval.node->nd_cond)) {
+		            NODE *tmp = yyval.node->nd_body;
+		            yyval.node->nd_body = yyval.node->nd_else;
+		            yyval.node->nd_else = tmp;
+			}
+		    }
+    break;
+case 297:
+#line 1578 "parse.y"
+{COND_PUSH(1);}
+    break;
+case 298:
+#line 1578 "parse.y"
+{COND_POP();}
+    break;
+case 299:
+#line 1581 "parse.y"
+{
+			yyval.node = NEW_WHILE(cond(yyvsp[-4].node), yyvsp[-1].node, 1);
+		        fixpos(yyval.node, yyvsp[-4].node);
+			if (cond_negative(&yyval.node->nd_cond)) {
+			    nd_set_type(yyval.node, NODE_UNTIL);
+			}
+		    }
+    break;
+case 300:
+#line 1588 "parse.y"
+{COND_PUSH(1);}
+    break;
+case 301:
+#line 1588 "parse.y"
+{COND_POP();}
+    break;
+case 302:
+#line 1591 "parse.y"
+{
+			yyval.node = NEW_UNTIL(cond(yyvsp[-4].node), yyvsp[-1].node, 1);
+		        fixpos(yyval.node, yyvsp[-4].node);
+			if (cond_negative(&yyval.node->nd_cond)) {
+			    nd_set_type(yyval.node, NODE_WHILE);
+			}
+		    }
+    break;
+case 303:
+#line 1601 "parse.y"
+{
+			yyval.node = NEW_CASE(yyvsp[-3].node, yyvsp[-1].node);
+		        fixpos(yyval.node, yyvsp[-3].node);
+		    }
+    break;
+case 304:
+#line 1606 "parse.y"
+{
+			yyval.node = yyvsp[-1].node;
+		    }
+    break;
+case 305:
+#line 1610 "parse.y"
+{
+			yyval.node = yyvsp[-1].node;
+		    }
+    break;
+case 306:
+#line 1613 "parse.y"
+{COND_PUSH(1);}
+    break;
+case 307:
+#line 1613 "parse.y"
+{COND_POP();}
+    break;
+case 308:
+#line 1616 "parse.y"
+{
+			yyval.node = NEW_FOR(yyvsp[-7].node, yyvsp[-4].node, yyvsp[-1].node);
+		        fixpos(yyval.node, yyvsp[-7].node);
+		    }
+    break;
+case 309:
+#line 1621 "parse.y"
+{
+			if (in_def || in_single)
+			    yyerror("class definition in method body");
+			class_nest++;
+			local_push(0);
+		        yyval.num = ruby_sourceline;
+		    }
+    break;
+case 310:
+#line 1630 "parse.y"
+{
+		        yyval.node = NEW_CLASS(yyvsp[-4].node, yyvsp[-1].node, yyvsp[-3].node);
+		        nd_set_line(yyval.node, yyvsp[-2].num);
+		        local_pop();
+			class_nest--;
+		    }
+    break;
+case 311:
+#line 1637 "parse.y"
+{
+			yyval.num = in_def;
+		        in_def = 0;
+		    }
+    break;
+case 312:
+#line 1642 "parse.y"
+{
+		        yyval.num = in_single;
+		        in_single = 0;
+			class_nest++;
+			local_push(0);
+		    }
+    break;
+case 313:
+#line 1650 "parse.y"
+{
+		        yyval.node = NEW_SCLASS(yyvsp[-5].node, yyvsp[-1].node);
+		        fixpos(yyval.node, yyvsp[-5].node);
+		        local_pop();
+			class_nest--;
+		        in_def = yyvsp[-4].num;
+		        in_single = yyvsp[-2].num;
+		    }
+    break;
+case 314:
+#line 1659 "parse.y"
+{
+			if (in_def || in_single)
+			    yyerror("module definition in method body");
+			class_nest++;
+			local_push(0);
+		        yyval.num = ruby_sourceline;
+		    }
+    break;
+case 315:
+#line 1668 "parse.y"
+{
+		        yyval.node = NEW_MODULE(yyvsp[-3].node, yyvsp[-1].node);
+		        nd_set_line(yyval.node, yyvsp[-2].num);
+		        local_pop();
+			class_nest--;
+		    }
+    break;
+case 316:
+#line 1675 "parse.y"
+{
+			yyval.id = cur_mid;
+			cur_mid = yyvsp[0].id;
+			in_def++;
+			local_push(0);
+		    }
+    break;
+case 317:
+#line 1684 "parse.y"
+{
+			if (!yyvsp[-1].node) yyvsp[-1].node = NEW_NIL();
+			yyval.node = NEW_DEFN(yyvsp[-4].id, yyvsp[-2].node, yyvsp[-1].node, NOEX_PRIVATE);
+		        fixpos(yyval.node, yyvsp[-2].node);
+		        local_pop();
+			in_def--;
+			cur_mid = yyvsp[-3].id;
+		    }
+    break;
+case 318:
+#line 1692 "parse.y"
+{lex_state = EXPR_FNAME;}
+    break;
+case 319:
+#line 1693 "parse.y"
+{
+			in_single++;
+			local_push(0);
+		        lex_state = EXPR_END; /* force for args */
+		    }
+    break;
+case 320:
+#line 1701 "parse.y"
+{
+			yyval.node = NEW_DEFS(yyvsp[-7].node, yyvsp[-4].id, yyvsp[-2].node, yyvsp[-1].node);
+		        fixpos(yyval.node, yyvsp[-7].node);
+		        local_pop();
+			in_single--;
+		    }
+    break;
+case 321:
+#line 1708 "parse.y"
+{
+			yyval.node = NEW_BREAK(0);
+		    }
+    break;
+case 322:
+#line 1712 "parse.y"
+{
+			yyval.node = NEW_NEXT(0);
+		    }
+    break;
+case 323:
+#line 1716 "parse.y"
+{
+			yyval.node = NEW_REDO();
+		    }
+    break;
+case 324:
+#line 1720 "parse.y"
+{
+			yyval.node = NEW_RETRY();
+		    }
+    break;
+case 325:
+#line 1726 "parse.y"
+{
+			value_expr(yyvsp[0].node);
+			yyval.node = yyvsp[0].node;
+		    }
+    break;
+case 334:
+#line 1747 "parse.y"
+{
+			yyval.node = NEW_IF(cond(yyvsp[-3].node), yyvsp[-1].node, yyvsp[0].node);
+		        fixpos(yyval.node, yyvsp[-3].node);
+		    }
+    break;
+case 336:
+#line 1755 "parse.y"
+{
+			yyval.node = yyvsp[0].node;
+		    }
+    break;
+case 340:
+#line 1766 "parse.y"
+{
+			yyval.node = (NODE*)1;
+		    }
+    break;
+case 341:
+#line 1770 "parse.y"
+{
+			yyval.node = (NODE*)1;
+		    }
+    break;
+case 342:
+#line 1774 "parse.y"
+{
+			yyval.node = yyvsp[-1].node;
+		    }
+    break;
+case 343:
+#line 1780 "parse.y"
+{
+		        yyval.vars = dyna_push();
+			yyvsp[0].num = ruby_sourceline;
+		    }
+    break;
+case 344:
+#line 1784 "parse.y"
+{yyval.vars = ruby_dyna_vars;}
+    break;
+case 345:
+#line 1787 "parse.y"
+{
+			yyval.node = NEW_ITER(yyvsp[-3].node, 0, dyna_init(yyvsp[-1].node, yyvsp[-2].vars));
+			nd_set_line(yyval.node, yyvsp[-5].num);
+			dyna_pop(yyvsp[-4].vars);
+		    }
+    break;
+case 346:
+#line 1795 "parse.y"
+{
+			if (yyvsp[-1].node && nd_type(yyvsp[-1].node) == NODE_BLOCK_PASS) {
+			    rb_compile_error("both block arg and actual block given");
+			}
+			yyvsp[0].node->nd_iter = yyvsp[-1].node;
+			yyval.node = yyvsp[0].node;
+		        fixpos(yyval.node, yyvsp[-1].node);
+		    }
+    break;
+case 347:
+#line 1804 "parse.y"
+{
+			yyval.node = new_call(yyvsp[-3].node, yyvsp[-1].id, yyvsp[0].node);
+		    }
+    break;
+case 348:
+#line 1808 "parse.y"
+{
+			yyval.node = new_call(yyvsp[-3].node, yyvsp[-1].id, yyvsp[0].node);
+		    }
+    break;
+case 349:
+#line 1814 "parse.y"
+{
+			yyval.node = new_fcall(yyvsp[-1].id, yyvsp[0].node);
+		        fixpos(yyval.node, yyvsp[0].node);
+		    }
+    break;
+case 350:
+#line 1819 "parse.y"
+{
+			yyval.node = new_call(yyvsp[-3].node, yyvsp[-1].id, yyvsp[0].node);
+		        fixpos(yyval.node, yyvsp[-3].node);
+		    }
+    break;
+case 351:
+#line 1824 "parse.y"
+{
+			yyval.node = new_call(yyvsp[-3].node, yyvsp[-1].id, yyvsp[0].node);
+		        fixpos(yyval.node, yyvsp[-3].node);
+		    }
+    break;
+case 352:
+#line 1829 "parse.y"
+{
+			yyval.node = new_call(yyvsp[-2].node, yyvsp[0].id, 0);
+		    }
+    break;
+case 353:
+#line 1833 "parse.y"
+{
+			yyval.node = new_super(yyvsp[0].node);
+		    }
+    break;
+case 354:
+#line 1837 "parse.y"
+{
+			yyval.node = NEW_ZSUPER();
+		    }
+    break;
+case 355:
+#line 1843 "parse.y"
+{
+		        yyval.vars = dyna_push();
+			yyvsp[0].num = ruby_sourceline;
+		    }
+    break;
+case 356:
+#line 1847 "parse.y"
+{yyval.vars = ruby_dyna_vars;}
+    break;
+case 357:
+#line 1849 "parse.y"
+{
+			yyval.node = NEW_ITER(yyvsp[-3].node, 0, dyna_init(yyvsp[-1].node, yyvsp[-2].vars));
+			nd_set_line(yyval.node, yyvsp[-5].num);
+			dyna_pop(yyvsp[-4].vars);
+		    }
+    break;
+case 358:
+#line 1855 "parse.y"
+{
+		        yyval.vars = dyna_push();
+			yyvsp[0].num = ruby_sourceline;
+		    }
+    break;
+case 359:
+#line 1859 "parse.y"
+{yyval.vars = ruby_dyna_vars;}
+    break;
+case 360:
+#line 1861 "parse.y"
+{
+			yyval.node = NEW_ITER(yyvsp[-3].node, 0, dyna_init(yyvsp[-1].node, yyvsp[-2].vars));
+			nd_set_line(yyval.node, yyvsp[-5].num);
+			dyna_pop(yyvsp[-4].vars);
+		    }
+    break;
+case 361:
+#line 1871 "parse.y"
+{
+			yyval.node = NEW_WHEN(yyvsp[-3].node, yyvsp[-1].node, yyvsp[0].node);
+		    }
+    break;
+case 363:
+#line 1877 "parse.y"
+{
+			yyval.node = list_append(yyvsp[-3].node, NEW_WHEN(yyvsp[0].node, 0, 0));
+		    }
+    break;
+case 364:
+#line 1881 "parse.y"
+{
+			yyval.node = NEW_LIST(NEW_WHEN(yyvsp[0].node, 0, 0));
+		    }
+    break;
+case 367:
+#line 1893 "parse.y"
+{
+		        if (yyvsp[-3].node) {
+		            yyvsp[-3].node = node_assign(yyvsp[-3].node, NEW_GVAR(rb_intern("$!")));
+			    yyvsp[-1].node = block_append(yyvsp[-3].node, yyvsp[-1].node);
+			}
+			yyval.node = NEW_RESBODY(yyvsp[-4].node, yyvsp[-1].node, yyvsp[0].node);
+		        fixpos(yyval.node, yyvsp[-4].node?yyvsp[-4].node:yyvsp[-1].node);
+		    }
+    break;
+case 369:
+#line 1905 "parse.y"
+{
+			yyval.node = NEW_LIST(yyvsp[0].node);
+		    }
+    break;
+case 372:
+#line 1913 "parse.y"
+{
+			yyval.node = yyvsp[0].node;
+		    }
+    break;
+case 374:
+#line 1920 "parse.y"
+{
+			if (yyvsp[0].node)
+			    yyval.node = yyvsp[0].node;
+			else
+			    /* place holder */
+			    yyval.node = NEW_NIL();
+		    }
+    break;
+case 377:
+#line 1932 "parse.y"
+{
+			yyval.node = NEW_LIT(ID2SYM(yyvsp[0].id));
+		    }
+    break;
+case 379:
+#line 1939 "parse.y"
+{
+			NODE *node = yyvsp[0].node;
+			if (!node) {
+			    node = NEW_STR(rb_str_new(0, 0));
+			}
+			else {
+			    node = evstr2dstr(node);
+			}
+			yyval.node = node;
+		    }
+    break;
+case 381:
+#line 1953 "parse.y"
+{
+			yyval.node = literal_concat(yyvsp[-1].node, yyvsp[0].node);
+		    }
+    break;
+case 382:
+#line 1959 "parse.y"
+{
+			yyval.node = yyvsp[-1].node;
+		    }
+    break;
+case 383:
+#line 1965 "parse.y"
+{
+			NODE *node = yyvsp[-1].node;
+			if (!node) {
+			    node = NEW_XSTR(rb_str_new(0, 0));
+			}
+			else {
+			    switch (nd_type(node)) {
+			      case NODE_STR:
+				nd_set_type(node, NODE_XSTR);
+				break;
+			      case NODE_DSTR:
+				nd_set_type(node, NODE_DXSTR);
+				break;
+			      default:
+				node = NEW_NODE(NODE_DXSTR, rb_str_new(0, 0), 1, NEW_LIST(node));
+				break;
+			    }
+			}
+			yyval.node = node;
+		    }
+    break;
+case 384:
+#line 1988 "parse.y"
+{
+			int options = yyvsp[0].num;
+			NODE *node = yyvsp[-1].node;
+			if (!node) {
+			    node = NEW_LIT(rb_reg_new("", 0, options & ~RE_OPTION_ONCE));
+			}
+			else switch (nd_type(node)) {
+			  case NODE_STR:
+			    {
+				VALUE src = node->nd_lit;
+				nd_set_type(node, NODE_LIT);
+				node->nd_lit = rb_reg_new(RSTRING(src)->ptr,
+							  RSTRING(src)->len,
+							  options & ~RE_OPTION_ONCE);
+			    }
+			    break;
+			  default:
+			    node = NEW_NODE(NODE_DSTR, rb_str_new(0, 0), 1, NEW_LIST(node));
+			  case NODE_DSTR:
+			    if (options & RE_OPTION_ONCE) {
+				nd_set_type(node, NODE_DREGX_ONCE);
+			    }
+			    else {
+				nd_set_type(node, NODE_DREGX);
+			    }
+			    node->nd_cflag = options & ~RE_OPTION_ONCE;
+			    break;
+			}
+			yyval.node = node;
+		    }
+    break;
+case 385:
+#line 2021 "parse.y"
+{
+			yyval.node = NEW_ZARRAY();
+		    }
+    break;
+case 386:
+#line 2025 "parse.y"
+{
+			yyval.node = yyvsp[-1].node;
+		    }
+    break;
+case 387:
+#line 2031 "parse.y"
+{
+			yyval.node = 0;
+		    }
+    break;
+case 388:
+#line 2035 "parse.y"
+{
+			yyval.node = list_append(yyvsp[-2].node, evstr2dstr(yyvsp[-1].node));
+		    }
+    break;
+case 390:
+#line 2042 "parse.y"
+{
+			yyval.node = literal_concat(yyvsp[-1].node, yyvsp[0].node);
+		    }
+    break;
+case 391:
+#line 2048 "parse.y"
+{
+			yyval.node = NEW_ZARRAY();
+		    }
+    break;
+case 392:
+#line 2052 "parse.y"
+{
+			yyval.node = yyvsp[-1].node;
+		    }
+    break;
+case 393:
+#line 2058 "parse.y"
+{
+			yyval.node = 0;
+		    }
+    break;
+case 394:
+#line 2062 "parse.y"
+{
+			yyval.node = list_append(yyvsp[-2].node, yyvsp[-1].node);
+		    }
+    break;
+case 395:
+#line 2068 "parse.y"
+{
+			yyval.node = 0;
+		    }
+    break;
+case 396:
+#line 2072 "parse.y"
+{
+			yyval.node = literal_concat(yyvsp[-1].node, yyvsp[0].node);
+		    }
+    break;
+case 397:
+#line 2078 "parse.y"
+{
+			yyval.node = 0;
+		    }
+    break;
+case 398:
+#line 2082 "parse.y"
+{
+			yyval.node = literal_concat(yyvsp[-1].node, yyvsp[0].node);
+		    }
+    break;
+case 400:
+#line 2089 "parse.y"
+{
+			yyval.node = lex_strterm;
+			lex_strterm = 0;
+			lex_state = EXPR_BEG;
+		    }
+    break;
+case 401:
+#line 2095 "parse.y"
+{
+			lex_strterm = yyvsp[-1].node;
+		        yyval.node = NEW_EVSTR(yyvsp[0].node);
+		    }
+    break;
+case 402:
+#line 2100 "parse.y"
+{
+			yyval.node = lex_strterm;
+			lex_strterm = 0;
+			lex_state = EXPR_BEG;
+			COND_PUSH(0);
+			CMDARG_PUSH(0);
+		    }
+    break;
+case 403:
+#line 2108 "parse.y"
+{
+			lex_strterm = yyvsp[-2].node;
+			COND_LEXPOP();
+			CMDARG_LEXPOP();
+			if ((yyval.node = yyvsp[-1].node) && nd_type(yyval.node) == NODE_NEWLINE) {
+			    yyval.node = yyval.node->nd_next;
+			    rb_gc_force_recycle((VALUE)yyvsp[-1].node);
+			}
+			yyval.node = new_evstr(yyval.node);
+		    }
+    break;
+case 404:
+#line 2120 "parse.y"
+{yyval.node = NEW_GVAR(yyvsp[0].id);}
+    break;
+case 405:
+#line 2121 "parse.y"
+{yyval.node = NEW_IVAR(yyvsp[0].id);}
+    break;
+case 406:
+#line 2122 "parse.y"
+{yyval.node = NEW_CVAR(yyvsp[0].id);}
+    break;
+case 408:
+#line 2127 "parse.y"
+{
+		        lex_state = EXPR_END;
+			yyval.id = yyvsp[0].id;
+		    }
+    break;
+case 413:
+#line 2140 "parse.y"
+{
+		        lex_state = EXPR_END;
+			if (!(yyval.node = yyvsp[-1].node)) {
+			    yyerror("empty symbol literal");
+			}
+			else {
+			    VALUE lit;
+
+			    switch (nd_type(yyval.node)) {
+			      case NODE_DSTR:
+				nd_set_type(yyval.node, NODE_DSYM);
+				break;
+			      case NODE_STR:
+				lit = yyval.node->nd_lit;
+				if (RSTRING(lit)->len == 0) {
+				    yyerror("empty symbol literal");
+				    break;
+				}
+				if (strlen(RSTRING(lit)->ptr) == RSTRING(lit)->len) {
+				    yyval.node->nd_lit = ID2SYM(rb_intern(RSTRING(yyval.node->nd_lit)->ptr));
+				    nd_set_type(yyval.node, NODE_LIT);
+				    break;
+				}
+				/* fall through */
+			      default:
+				yyval.node = NEW_NODE(NODE_DSYM, rb_str_new(0, 0), 1, NEW_LIST(yyval.node));
+				break;
+			    }
+			}
+		    }
+    break;
+case 416:
+#line 2175 "parse.y"
+{
+			yyval.node = negate_lit(yyvsp[0].node);
+		    }
+    break;
+case 417:
+#line 2179 "parse.y"
+{
+			yyval.node = negate_lit(yyvsp[0].node);
+		    }
+    break;
+case 423:
+#line 2189 "parse.y"
+{yyval.id = kNIL;}
+    break;
+case 424:
+#line 2190 "parse.y"
+{yyval.id = kSELF;}
+    break;
+case 425:
+#line 2191 "parse.y"
+{yyval.id = kTRUE;}
+    break;
+case 426:
+#line 2192 "parse.y"
+{yyval.id = kFALSE;}
+    break;
+case 427:
+#line 2193 "parse.y"
+{yyval.id = k__FILE__;}
+    break;
+case 428:
+#line 2194 "parse.y"
+{yyval.id = k__LINE__;}
+    break;
+case 429:
+#line 2198 "parse.y"
+{
+			yyval.node = gettable(yyvsp[0].id);
+		    }
+    break;
+case 430:
+#line 2204 "parse.y"
+{
+			yyval.node = assignable(yyvsp[0].id, 0);
+		    }
+    break;
+case 433:
+#line 2214 "parse.y"
+{
+			yyval.node = 0;
+		    }
+    break;
+case 434:
+#line 2218 "parse.y"
+{
+			lex_state = EXPR_BEG;
+		    }
+    break;
+case 435:
+#line 2222 "parse.y"
+{
+			yyval.node = yyvsp[-1].node;
+		    }
+    break;
+case 436:
+#line 2225 "parse.y"
+{yyerrok; yyval.node = 0;}
+    break;
+case 437:
+#line 2229 "parse.y"
+{
+			yyval.node = yyvsp[-2].node;
+			lex_state = EXPR_BEG;
+		    }
+    break;
+case 438:
+#line 2234 "parse.y"
+{
+			yyval.node = yyvsp[-1].node;
+		    }
+    break;
+case 439:
+#line 2240 "parse.y"
+{
+			yyval.node = block_append(NEW_ARGS(yyvsp[-5].num, yyvsp[-3].node, yyvsp[-1].id), yyvsp[0].node);
+		    }
+    break;
+case 440:
+#line 2244 "parse.y"
+{
+			yyval.node = block_append(NEW_ARGS(yyvsp[-3].num, yyvsp[-1].node, -1), yyvsp[0].node);
+		    }
+    break;
+case 441:
+#line 2248 "parse.y"
+{
+			yyval.node = block_append(NEW_ARGS(yyvsp[-3].num, 0, yyvsp[-1].id), yyvsp[0].node);
+		    }
+    break;
+case 442:
+#line 2252 "parse.y"
+{
+			yyval.node = block_append(NEW_ARGS(yyvsp[-1].num, 0, -1), yyvsp[0].node);
+		    }
+    break;
+case 443:
+#line 2256 "parse.y"
+{
+			yyval.node = block_append(NEW_ARGS(0, yyvsp[-3].node, yyvsp[-1].id), yyvsp[0].node);
+		    }
+    break;
+case 444:
+#line 2260 "parse.y"
+{
+			yyval.node = block_append(NEW_ARGS(0, yyvsp[-1].node, -1), yyvsp[0].node);
+		    }
+    break;
+case 445:
+#line 2264 "parse.y"
+{
+			yyval.node = block_append(NEW_ARGS(0, 0, yyvsp[-1].id), yyvsp[0].node);
+		    }
+    break;
+case 446:
+#line 2268 "parse.y"
+{
+			yyval.node = block_append(NEW_ARGS(0, 0, -1), yyvsp[0].node);
+		    }
+    break;
+case 447:
+#line 2272 "parse.y"
+{
+			yyval.node = NEW_ARGS(0, 0, -1);
+		    }
+    break;
+case 448:
+#line 2278 "parse.y"
+{
+			yyerror("formal argument cannot be a constant");
+		    }
+    break;
+case 449:
+#line 2282 "parse.y"
+{
+                        yyerror("formal argument cannot be an instance variable");
+		    }
+    break;
+case 450:
+#line 2286 "parse.y"
+{
+                        yyerror("formal argument cannot be a global variable");
+		    }
+    break;
+case 451:
+#line 2290 "parse.y"
+{
+                        yyerror("formal argument cannot be a class variable");
+		    }
+    break;
+case 452:
+#line 2294 "parse.y"
+{
+			if (!is_local_id(yyvsp[0].id))
+			    yyerror("formal argument must be local variable");
+			else if (local_id(yyvsp[0].id))
+			    yyerror("duplicate argument name");
+			local_cnt(yyvsp[0].id);
+			yyval.num = 1;
+		    }
+    break;
+case 454:
+#line 2306 "parse.y"
+{
+			yyval.num += 1;
+		    }
+    break;
+case 455:
+#line 2312 "parse.y"
+{
+			if (!is_local_id(yyvsp[-2].id))
+			    yyerror("formal argument must be local variable");
+			else if (local_id(yyvsp[-2].id))
+			    yyerror("duplicate optional argument name");
+			yyval.node = assignable(yyvsp[-2].id, yyvsp[0].node);
+		    }
+    break;
+case 456:
+#line 2322 "parse.y"
+{
+			yyval.node = NEW_BLOCK(yyvsp[0].node);
+			yyval.node->nd_end = yyval.node;
+		    }
+    break;
+case 457:
+#line 2327 "parse.y"
+{
+			yyval.node = block_append(yyvsp[-2].node, yyvsp[0].node);
+		    }
+    break;
+case 460:
+#line 2337 "parse.y"
+{
+			if (!is_local_id(yyvsp[0].id))
+			    yyerror("rest argument must be local variable");
+			else if (local_id(yyvsp[0].id))
+			    yyerror("duplicate rest argument name");
+			yyval.id = local_cnt(yyvsp[0].id);
+		    }
+    break;
+case 461:
+#line 2345 "parse.y"
+{
+			yyval.id = -2;
+		    }
+    break;
+case 464:
+#line 2355 "parse.y"
+{
+			if (!is_local_id(yyvsp[0].id))
+			    yyerror("block argument must be local variable");
+			else if (local_id(yyvsp[0].id))
+			    yyerror("duplicate block argument name");
+			yyval.node = NEW_BLOCK_ARG(yyvsp[0].id);
+		    }
+    break;
+case 465:
+#line 2365 "parse.y"
+{
+			yyval.node = yyvsp[0].node;
+		    }
+    break;
+case 467:
+#line 2372 "parse.y"
+{
+			if (nd_type(yyvsp[0].node) == NODE_SELF) {
+			    yyval.node = NEW_SELF();
+			}
+			else {
+			    yyval.node = yyvsp[0].node;
+		            value_expr(yyval.node);
+			}
+		    }
+    break;
+case 468:
+#line 2381 "parse.y"
+{lex_state = EXPR_BEG;}
+    break;
+case 469:
+#line 2382 "parse.y"
+{
+			if (yyvsp[-2].node == 0) {
+			    yyerror("can't define singleton method for ().");
+			}
+			else {
+			    switch (nd_type(yyvsp[-2].node)) {
+			      case NODE_STR:
+			      case NODE_DSTR:
+			      case NODE_XSTR:
+			      case NODE_DXSTR:
+			      case NODE_DREGX:
+			      case NODE_LIT:
+			      case NODE_ARRAY:
+			      case NODE_ZARRAY:
+				yyerror("can't define singleton method for literals");
+			      default:
+				value_expr(yyvsp[-2].node);
+				break;
+			    }
+			}
+			yyval.node = yyvsp[-2].node;
+		    }
+    break;
+case 471:
+#line 2408 "parse.y"
+{
+			yyval.node = yyvsp[-1].node;
+		    }
+    break;
+case 472:
+#line 2412 "parse.y"
+{
+			if (yyvsp[-1].node->nd_alen%2 != 0) {
+			    yyerror("odd number list for Hash");
+			}
+			yyval.node = yyvsp[-1].node;
+		    }
+    break;
+case 474:
+#line 2422 "parse.y"
+{
+			yyval.node = list_concat(yyvsp[-2].node, yyvsp[0].node);
+		    }
+    break;
+case 475:
+#line 2428 "parse.y"
+{
+			yyval.node = list_append(NEW_LIST(yyvsp[-2].node), yyvsp[0].node);
+		    }
+    break;
+case 495:
+#line 2466 "parse.y"
+{yyerrok;}
+    break;
+case 498:
+#line 2471 "parse.y"
+{yyerrok;}
+    break;
+case 499:
+#line 2474 "parse.y"
+{yyval.node = 0;}
+    break;
+}