can access the variable by casting it
   to the proper pointer type.  */

#ifdef YYPARSE_PARAM
# if defined (__STDC__) || defined (__cplusplus)
#  define YYPARSE_PARAM_ARG void *YYPARSE_PARAM
#  define YYPARSE_PARAM_DECL
# else
#  define YYPARSE_PARAM_ARG YYPARSE_PARAM
#  define YYPARSE_PARAM_DECL void *YYPARSE_PARAM;
# endif
#else /* !YYPARSE_PARAM */
# define YYPARSE_PARAM_ARG
# define YYPARSE_PARAM_DECL
#endif /* !YYPARSE_PARAM */

/* Prevent warning if -Wstrict-prototypes.  */
#ifdef __GNUC__
# ifdef YYPARSE_PARAM
int yyparse (void *);
# else
int yyparse (void);
# endif
#endif

/* YY_DECL_VARIABLES -- depending whether we use a pure parser,
   variables are global, or local to YYPARSE.  */

#define YY_DECL_NON_LSP_VARIABLES			\
/* The lookahead symbol.  */				\
int yychar;						\
							\
/* The semantic value of the lookahead symbol. */	\
YYSTYPE yylval;						\
							\
/* Number of parse errors so far.  */			\
int yynerrs;

#if YYLSP_NEEDED
# define YY_DECL_VARIABLES			\
YY_DECL_NON_LSP_VARIABLES			\
						\
/* Location data for the lookahead symbol.  */	\
YYLTYPE yylloc;
#else
# define YY_DECL_VARIABLES			\
YY_DECL_NON_LSP_VARIABLES
#endif


/* If nonreentrant, generate the variables here. */

#if !YYPURE
YY_DECL_VARIABLES
#endif  /* !YYPURE */

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 267 "parse.y"
{
		        yyval.vars = ruby_dyna_vars;
			lex_state = EXPR_BEG;
                        top_local_init();
			if ((VALUE)ruby_class == rb_cObject) class_nest = 0;
			else class_nest = 1;
		    }
    break;
case 2:
#line 275 "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;
		        ruby_dyna_vars = yyvsp[-1].vars;
		    }
    break;
case 3:
#line 295 "parse.y"
{
			void_stmts(yyvsp[-1].node);
			yyval.node = yyvsp[-1].node;
		    }
    break;
case 5:
#line 303 "parse.y"
{
			yyval.node = newline_node(yyvsp[0].node);
		    }
    break;
case 6:
#line 307 "parse.y"
{
			yyval.node = block_append(yyvsp[-2].node, newline_node(yyvsp[0].node));
		    }
    break;
case 7:
#line 311 "parse.y"
{
			yyval.node = yyvsp[0].node;
		    }
    break;
case 8:
#line 316 "parse.y"
{lex_state = EXPR_FNAME;}
    break;
case 9:
#line 317 "parse.y"
{
			if (in_def || in_single)
			    yyerror("alias within method");
		        yyval.node = NEW_ALIAS(yyvsp[-2].id, yyvsp[0].id);
		    }
    break;
case 10:
#line 323 "parse.y"
{
			if (in_def || in_single)
			    yyerror("alias within method");
		        yyval.node = NEW_VALIAS(yyvsp[-1].id, yyvsp[0].id);
		    }
    break;
case 11:
#line 329 "parse.y"
{
			char buf[3];

			if (in_def || in_single)
			    yyerror("alias within method");
			sprintf(buf, "$%c", (int)yyvsp[0].node->nd_nth);
		        yyval.node = NEW_VALIAS(yyvsp[-1].id, rb_intern(buf));
		    }
    break;
case 12:
#line 338 "parse.y"
{
		        yyerror("can't make alias for the number variables");
		        yyval.node = 0;
		    }
    break;
case 13:
#line 343 "parse.y"
{
			if (in_def || in_single)
			    yyerror("undef within method");
			yyval.node = yyvsp[0].node;
		    }
    break;
case 14:
#line 349 "parse.y"
{
			value_expr(yyvsp[0].node);
			yyval.node = NEW_IF(cond(yyvsp[0].node), yyvsp[-2].node, 0);
		        fixpos(yyval.node, yyvsp[0].node);
		    }
    break;
case 15:
#line 355 "parse.y"
{
			value_expr(yyvsp[0].node);
			yyval.node = NEW_UNLESS(cond(yyvsp[0].node), yyvsp[-2].node, 0);
		        fixpos(yyval.node, yyvsp[0].node);
		    }
    break;
case 16:
#line 361 "parse.y"
{
			value_expr(yyvsp[0].node);
			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);
			}
		    }
    break;
case 17:
#line 371 "parse.y"
{
			value_expr(yyvsp[0].node);
			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);
			}
		    }
    break;
case 18:
#line 381 "parse.y"
{
			yyval.node = NEW_RESCUE(yyvsp[-2].node, NEW_RESBODY(0,yyvsp[0].node,0), 0);
		    }
    break;
case 19:
#line 385 "parse.y"
{
			if (in_def || in_single) {
			    yyerror("BEGIN in method");
			}
			local_push(0);
		    }
    break;
case 20:
#line 392 "parse.y"
{
			ruby_eval_tree_begin = block_append(ruby_eval_tree_begin,
						            NEW_PREEXE(yyvsp[-1].node));
		        local_pop();
		        yyval.node = 0;
		    }
    break;
case 21:
#line 399 "parse.y"
{
			if (compile_for_eval && (in_def || in_single)) {
			    yyerror("END in method; use at_exit");
			}

			yyval.node = NEW_ITER(0, NEW_POSTEXE(), yyvsp[-1].node);
		    }
    break;
case 22:
#line 407 "parse.y"
{
			yyval.node = node_assign(yyvsp[-2].node, yyvsp[0].node);
		    }
    break;
case 23:
#line 411 "parse.y"
{
			value_expr(yyvsp[0].node);
			yyvsp[-2].node->nd_value = yyvsp[0].node;
			yyval.node = yyvsp[-2].node;
		    }
    break;
case 24:
#line 417 "parse.y"
{
			yyval.node = node_assign(yyvsp[-2].node, yyvsp[0].node);
		    }
    break;
case 26:
#line 424 "parse.y"
{
			value_expr(yyvsp[0].node);
			yyvsp[-2].node->nd_value = yyvsp[0].node;
			yyval.node = yyvsp[-2].node;
		    }
    break;
case 27:
#line 430 "parse.y"
{
			if (!compile_for_eval && !in_def && !in_single)
			    yyerror("return appeared outside of method");
			yyval.node = NEW_RETURN(yyvsp[0].node);
		    }
    break;
case 29:
#line 437 "parse.y"
{
			yyval.node = logop(NODE_AND, yyvsp[-2].node, yyvsp[0].node);
		    }
    break;
case 30:
#line 441 "parse.y"
{
			yyval.node = logop(NODE_OR, yyvsp[-2].node, yyvsp[0].node);
		    }
    break;
case 31:
#line 445 "parse.y"
{
			value_expr(yyvsp[0].node);
			yyval.node = NEW_NOT(cond(yyvsp[0].node));
		    }
    break;
case 32:
#line 450 "parse.y"
{
			value_expr(yyvsp[0].node);
			yyval.node = NEW_NOT(cond(yyvsp[0].node));
		    }
    break;
case 37:
#line 463 "parse.y"
{
			value_expr(yyvsp[-3].node);
			yyval.node = new_call(yyvsp[-3].node, yyvsp[-1].id, yyvsp[0].node);
		    }
    break;
case 38:
#line 468 "parse.y"
{
			value_expr(yyvsp[-3].node);
			yyval.node = new_call(yyvsp[-3].node, yyvsp[-1].id, yyvsp[0].node);
		    }
    break;
case 39:
#line 475 "parse.y"
{
			yyval.node = new_fcall(yyvsp[-1].id, yyvsp[0].node);
		        fixpos(yyval.node, yyvsp[0].node);
		   }
    break;
case 40:
#line 480 "parse.y"
{
			value_expr(yyvsp[-3].node);
			yyval.node = new_call(yyvsp[-3].node, yyvsp[-1].id, yyvsp[0].node);
		        fixpos(yyval.node, yyvsp[-3].node);
		    }
    break;
case 41:
#line 486 "parse.y"
{
			value_expr(yyvsp[-3].node);
			yyval.node = new_call(yyvsp[-3].node, yyvsp[-1].id, yyvsp[0].node);
		        fixpos(yyval.node, yyvsp[-3].node);
		    }
    break;
case 42:
#line 492 "parse.y"
{
			if (!compile_for_eval && !in_def && !in_single)
			    yyerror("super called outside of method");
			yyval.node = new_super(yyvsp[0].node);
		        fixpos(yyval.node, yyvsp[0].node);
		    }
    break;
case 43:
#line 499 "parse.y"
{
			yyval.node = NEW_YIELD(yyvsp[0].node);
		        fixpos(yyval.node, yyvsp[0].node);
		    }
    break;
case 45:
#line 507 "parse.y"
{
			yyval.node = yyvsp[-1].node;
		    }
    break;
case 47:
#line 514 "parse.y"
{
			yyval.node = NEW_MASGN(NEW_LIST(yyvsp[-1].node), 0);
		    }
    break;
case 48:
#line 520 "parse.y"
{
			yyval.node = NEW_MASGN(yyvsp[0].node, 0);
		    }
    break;
case 49:
#line 524 "parse.y"
{
			yyval.node = NEW_MASGN(list_append(yyvsp[-1].node,yyvsp[0].node), 0);
		    }
    break;
case 50:
#line 528 "parse.y"
{
			yyval.node = NEW_MASGN(yyvsp[-2].node, yyvsp[0].node);
		    }
    break;
case 51:
#line 532 "parse.y"
{
			yyval.node = NEW_MASGN(yyvsp[-1].node, -1);
		    }
    break;
case 52:
#line 536 "parse.y"
{
			yyval.node = NEW_MASGN(0, yyvsp[0].node);
		    }
    break;
case 53:
#line 540 "parse.y"
{
			yyval.node = NEW_MASGN(0, -1);
		    }
    break;
case 55:
#line 547 "parse.y"
{
			yyval.node = yyvsp[-1].node;
		    }
    break;
case 56:
#line 553 "parse.y"
{
			yyval.node = NEW_LIST(yyvsp[-1].node);
		    }
    break;
case 57:
#line 557 "parse.y"
{
			yyval.node = list_append(yyvsp[-2].node, yyvsp[-1].node);
		    }
    break;
case 58:
#line 563 "parse.y"
{
			yyval.node = assignable(yyvsp[0].id, 0);
		    }
    break;
case 59:
#line 567 "parse.y"
{
			yyval.node = aryset(yyvsp[-3].node, yyvsp[-1].node);
		    }
    break;
case 60:
#line 571 "parse.y"
{
			yyval.node = attrset(yyvsp[-2].node, yyvsp[0].id);
		    }
    break;
case 61:
#line 575 "parse.y"
{
			yyval.node = attrset(yyvsp[-2].node, yyvsp[0].id);
		    }
    break;
case 62:
#line 579 "parse.y"
{
			yyval.node = attrset(yyvsp[-2].node, yyvsp[0].id);
		    }
    break;
case 63:
#line 583 "parse.y"
{
		        rb_backref_error(yyvsp[0].node);
			yyval.node = 0;
		    }
    break;
case 64:
#line 590 "parse.y"
{
			yyval.node = assignable(yyvsp[0].id, 0);
		    }
    break;
case 65:
#line 594 "parse.y"
{
			yyval.node = aryset(yyvsp[-3].node, yyvsp[-1].node);
		    }
    break;
case 66:
#line 598 "parse.y"
{
			yyval.node = attrset(yyvsp[-2].node, yyvsp[0].id);
		    }
    break;
case 67:
#line 602 "parse.y"
{
			yyval.node = attrset(yyvsp[-2].node, yyvsp[0].id);
		    }
    break;
case 68:
#line 606 "parse.y"
{
			yyval.node = attrset(yyvsp[-2].node, yyvsp[0].id);
		    }
    break;
case 69:
#line 610 "parse.y"
{
		        rb_backref_error(yyvsp[0].node);
			yyval.node = 0;
		    }
    break;
case 70:
#line 617 "parse.y"
{
			yyerror("class/module name must be CONSTANT");
		    }
    break;
case 75:
#line 627 "parse.y"
{
			lex_state = EXPR_END;
			yyval.id = yyvsp[0].id;
		    }
    break;
case 76:
#line 632 "parse.y"
{
			lex_state = EXPR_END;
			yyval.id = yyvsp[0].id;
		    }
    break;
case 79:
#line 643 "parse.y"
{
			yyval.node = NEW_UNDEF(yyvsp[0].id);
		    }
    break;
case 80:
#line 646 "parse.y"
{lex_state = EXPR_FNAME;}
    break;
case 81:
#line 647 "parse.y"
{
			yyval.node = block_append(yyvsp[-3].node, NEW_UNDEF(yyvsp[0].id));
		    }
    break;
case 82:
#line 652 "parse.y"
{ yyval.id = '|'; }
    break;
case 83:
#line 653 "parse.y"
{ yyval.id = '^'; }
    break;
case 84:
#line 654 "parse.y"
{ yyval.id = '&'; }
    break;
case 85:
#line 655 "parse.y"
{ yyval.id = tCMP; }
    break;
case 86:
#line 656 "parse.y"
{ yyval.id = tEQ; }
    break;
case 87:
#line 657 "parse.y"
{ yyval.id = tEQQ; }
    break;
case 88:
#line 658 "parse.y"
{ yyval.id = tMATCH; }
    break;
case 89:
#line 659 "parse.y"
{ yyval.id = '>'; }
    break;
case 90:
#line 660 "parse.y"
{ yyval.id = tGEQ; }
    break;
case 91:
#line 661 "parse.y"
{ yyval.id = '<'; }
    break;
case 92:
#line 662 "parse.y"
{ yyval.id = tLEQ; }
    break;
case 93:
#line 663 "parse.y"
{ yyval.id = tLSHFT; }
    break;
case 94:
#line 664 "parse.y"
{ yyval.id = tRSHFT; }
    break;
case 95:
#line 665 "parse.y"
{ yyval.id = '+'; }
    break;
case 96:
#line 666 "parse.y"
{ yyval.id = '-'; }
    break;
case 97:
#line 667 "parse.y"
{ yyval.id = '*'; }
    break;
case 98:
#line 668 "parse.y"
{ yyval.id = '*'; }
    break;
case 99:
#line 669 "parse.y"
{ yyval.id = '/'; }
    break;
case 100:
#line 670 "parse.y"
{ yyval.id = '%'; }
    break;
case 101:
#line 671 "parse.y"
{ yyval.id = tPOW; }
    break;
case 102:
#line 672 "parse.y"
{ yyval.id = '~'; }
    break;
case 103:
#line 673 "parse.y"
{ yyval.id = tUPLUS; }
    break;
case 104:
#line 674 "parse.y"
{ yyval.id = tUMINUS; }
    break;
case 105:
#line 675 "parse.y"
{ yyval.id = tAREF; }
    break;
case 106:
#line 676 "parse.y"
{ yyval.id = tASET; }
    break;
case 107:
#line 677 "parse.y"
{ yyval.id = '`'; }
    break;
case 149:
#line 690 "parse.y"
{
			yyval.node = node_assign(yyvsp[-2].node, yyvsp[0].node);
		    }
    break;
case 150:
#line 693 "parse.y"
{yyval.node = assignable(yyvsp[-1].id, 0);}
    break;
case 151:
#line 694 "parse.y"
{
			value_expr(yyvsp[0].node);
			if (yyvsp[-1].node) {
			    if (yyvsp[-2].id == tOROP) {
				yyvsp[-1].node->nd_value = yyvsp[0].node;
				yyval.node = NEW_OP_ASGN_OR(gettable(yyvsp[-3].id), yyvsp[-1].node);
				if (is_instance_id(yyvsp[-3].id)) {
				    yyval.node->nd_aid = yyvsp[-3].id;
				}
			    }
			    else if (yyvsp[-2].id == tANDOP) {
				yyvsp[-1].node->nd_value = yyvsp[0].node;
				yyval.node = NEW_OP_ASGN_AND(gettable(yyvsp[-3].id), yyvsp[-1].node);
			    }
			    else {
				yyval.node = yyvsp[-1].node;
				yyval.node->nd_value = call_op(gettable(yyvsp[-3].id),yyvsp[-2].id,1,yyvsp[0].node);
			    }
			    fixpos(yyval.node, yyvsp[0].node);
			}
			else {
			    yyval.node = 0;
			}
		    }
    break;
case 152:
#line 719 "parse.y"
{
                        NODE *args = NEW_LIST(yyvsp[0].node);

			value_expr(yyvsp[0].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 153:
#line 735 "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 154:
#line 747 "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 155:
#line 759 "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 156:
#line 771 "parse.y"
{
		        rb_backref_error(yyvsp[-2].node);
			yyval.node = 0;
		    }
    break;
case 157:
#line 776 "parse.y"
{
			value_expr(yyvsp[-2].node);
			value_expr(yyvsp[0].node);
			yyval.node = NEW_DOT2(yyvsp[-2].node, yyvsp[0].node);
		    }
    break;
case 158:
#line 782 "parse.y"
{
			value_expr(yyvsp[-2].node);
			value_expr(yyvsp[0].node);
			yyval.node = NEW_DOT3(yyvsp[-2].node, yyvsp[0].node);
		    }
    break;
case 159:
#line 788 "parse.y"
{
			yyval.node = call_op(yyvsp[-2].node, '+', 1, yyvsp[0].node);
		    }
    break;
case 160:
#line 792 "parse.y"
{
		        yyval.node = call_op(yyvsp[-2].node, '-', 1, yyvsp[0].node);
		    }
    break;
case 161:
#line 796 "parse.y"
{
		        yyval.node = call_op(yyvsp[-2].node, '*', 1, yyvsp[0].node);
		    }
    break;
case 162:
#line 800 "parse.y"
{
			yyval.node = call_op(yyvsp[-2].node, '/', 1, yyvsp[0].node);
		    }
    break;
case 163:
#line 804 "parse.y"
{
			yyval.node = call_op(yyvsp[-2].node, '%', 1, yyvsp[0].node);
		    }
    break;
case 164:
#line 808 "parse.y"
{
			int need_negate = Qfalse;

			if (yyvsp[-2].node && nd_type(yyvsp[-2].node) == NODE_LIT) {

			    switch (TYPE(yyvsp[-2].node->nd_lit)) {
			      case T_FIXNUM:
			      case T_FLOAT:
			      case T_BIGNUM:
				if (RTEST(rb_funcall(yyvsp[-2].node->nd_lit,'<',1,INT2FIX(0)))) {
				    yyvsp[-2].node->nd_lit = rb_funcall(yyvsp[-2].node->nd_lit,rb_intern("-@"),0,0);
				    need_negate = Qtrue;
				}
			      default:
				break;
			    }
			}
			yyval.node = call_op(yyvsp[-2].node, tPOW, 1, yyvsp[0].node);
			if (need_negate) {
			    yyval.node = call_op(yyval.node, tUMINUS, 0, 0);
			}
		    }
    break;
case 165:
#line 831 "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 166:
#line 840 "parse.y"
{
			if (yyvsp[0].node && nd_type(yyvsp[0].node) == NODE_LIT && FIXNUM_P(yyvsp[0].node->nd_lit)) {
			    long i = FIX2LONG(yyvsp[0].node->nd_lit);

			    yyvsp[0].node->nd_lit = INT2NUM(-i);
			    yyval.node = yyvsp[0].node;
			}
			else {
			    yyval.node = call_op(yyvsp[0].node, tUMINUS, 0, 0);
			}
		    }
    break;
case 167:
#line 852 "parse.y"
{
		        yyval.node = call_op(yyvsp[-2].node, '|', 1, yyvsp[0].node);
		    }
    break;
case 168:
#line 856 "parse.y"
{
			yyval.node = call_op(yyvsp[-2].node, '^', 1, yyvsp[0].node);
		    }
    break;
case 169:
#line 860 "parse.y"
{
			yyval.node = call_op(yyvsp[-2].node, '&', 1, yyvsp[0].node);
		    }
    break;
case 170:
#line 864 "parse.y"
{
			yyval.node = call_op(yyvsp[-2].node, tCMP, 1, yyvsp[0].node);
		    }
    break;
case 171:
#line 868 "parse.y"
{
			yyval.node = call_op(yyvsp[-2].node, '>', 1, yyvsp[0].node);
		    }
    break;
case 172:
#line 872 "parse.y"
{
			yyval.node = call_op(yyvsp[-2].node, tGEQ, 1, yyvsp[0].node);
		    }
    break;
case 173:
#line 876 "parse.y"
{
			yyval.node = call_op(yyvsp[-2].node, '<', 1, yyvsp[0].node);
		    }
    break;
case 174:
#line 880 "parse.y"
{
			yyval.node = call_op(yyvsp[-2].node, tLEQ, 1, yyvsp[0].node);
		    }
    break;
case 175:
#line 884 "parse.y"
{
			yyval.node = call_op(yyvsp[-2].node, tEQ, 1, yyvsp[0].node);
		    }
    break;
case 176:
#line 888 "parse.y"
{
			yyval.node = call_op(yyvsp[-2].node, tEQQ, 1, yyvsp[0].node);
		    }
    break;
case 177:
#line 892 "parse.y"
{
			yyval.node = NEW_NOT(call_op(yyvsp[-2].node, tEQ, 1, yyvsp[0].node));
		    }
    break;
case 178:
#line 896 "parse.y"
{
			yyval.node = match_gen(yyvsp[-2].node, yyvsp[0].node);
		    }
    break;
case 179:
#line 900 "parse.y"
{
			yyval.node = NEW_NOT(match_gen(yyvsp[-2].node, yyvsp[0].node));
		    }
    break;
case 180:
#line 904 "parse.y"
{
			value_expr(yyvsp[0].node);
			yyval.node = NEW_NOT(cond(yyvsp[0].node));
		    }
    break;
case 181:
#line 909 "parse.y"
{
			yyval.node = call_op(yyvsp[0].node, '~', 0, 0);
		    }
    break;
case 182:
#line 913 "parse.y"
{
			yyval.node = call_op(yyvsp[-2].node, tLSHFT, 1, yyvsp[0].node);
		    }
    break;
case 183:
#line 917 "parse.y"
{
			yyval.node = call_op(yyvsp[-2].node, tRSHFT, 1, yyvsp[0].node);
		    }
    break;
case 184:
#line 921 "parse.y"
{
			yyval.node = logop(NODE_AND, yyvsp[-2].node, yyvsp[0].node);
		    }
    break;
case 185:
#line 925 "parse.y"
{
			yyval.node = logop(NODE_OR, yyvsp[-2].node, yyvsp[0].node);
		    }
    break;
case 186:
#line 928 "parse.y"
{in_defined = 1;}
    break;
case 187:
#line 929 "parse.y"
{
		        in_defined = 0;
			yyval.node = NEW_DEFINED(yyvsp[0].node);
		    }
    break;
case 188:
#line 934 "parse.y"
{
			value_expr(yyvsp[-4].node);
			yyval.node = NEW_IF(cond(yyvsp[-4].node), yyvsp[-2].node, yyvsp[0].node);
		        fixpos(yyval.node, yyvsp[-4].node);
		    }
    break;
case 189:
#line 940 "parse.y"
{
			yyval.node = yyvsp[0].node;
		    }
    break;
case 191:
#line 947 "parse.y"
{
			yyval.node = NEW_LIST(yyvsp[-1].node);
		    }
    break;
case 192:
#line 951 "parse.y"
{
			yyval.node = list_append(yyvsp[-3].node, yyvsp[-1].node);
		    }
    break;
case 193:
#line 955 "parse.y"
{
			yyval.node = yyvsp[-1].node;
		    }
    break;
case 194:
#line 959 "parse.y"
{
			value_expr(yyvsp[-1].node);
			yyval.node = arg_concat(yyvsp[-4].node, yyvsp[-1].node);
		    }
    break;
case 195:
#line 964 "parse.y"
{
			yyval.node = NEW_LIST(NEW_HASH(yyvsp[-1].node));
		    }
    break;
case 196:
#line 968 "parse.y"
{
			value_expr(yyvsp[-1].node);
			yyval.node = NEW_RESTARGS(yyvsp[-1].node);
		    }
    break;
case 197:
#line 975 "parse.y"
{
			yyval.node = yyvsp[-1].node;
		    }
    break;
case 198:
#line 979 "parse.y"
{
			yyval.node = yyvsp[-2].node;
		    }
    break;
case 199:
#line 983 "parse.y"
{
			yyval.node = NEW_LIST(yyvsp[-2].node);
		    }
    break;
case 200:
#line 987 "parse.y"
{
			yyval.node = list_append(yyvsp[-4].node, yyvsp[-2].node);
		    }
    break;
case 203:
#line 997 "parse.y"
{
			yyval.node = NEW_LIST(yyvsp[0].node);
		    }
    break;
case 204:
#line 1001 "parse.y"
{
			yyval.node = list_append(yyvsp[-2].node, yyvsp[0].node);
		    }
    break;
case 205:
#line 1005 "parse.y"
{
			yyval.node = arg_blk_pass(yyvsp[-1].node, yyvsp[0].node);
		    }
    break;
case 206:
#line 1009 "parse.y"
{
			value_expr(yyvsp[-1].node);
			yyval.node = arg_concat(yyvsp[-4].node, yyvsp[-1].node);
			yyval.node = arg_blk_pass(yyval.node, yyvsp[0].node);
		    }
    break;
case 207:
#line 1015 "parse.y"
{
			yyval.node = NEW_LIST(NEW_HASH(yyvsp[-1].node));
			yyval.node = arg_blk_pass(yyval.node, yyvsp[0].node);
		    }
    break;
case 208:
#line 1020 "parse.y"
{
			value_expr(yyvsp[-1].node);
			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 209:
#line 1026 "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 210:
#line 1031 "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 211:
#line 1037 "parse.y"
{
			value_expr(yyvsp[-1].node);
			yyval.node = arg_blk_pass(NEW_RESTARGS(yyvsp[-1].node), yyvsp[0].node);
		    }
    break;
case 213:
#line 1044 "parse.y"
{CMDARG_PUSH;}
    break;
case 214:
#line 1045 "parse.y"
{
		        CMDARG_POP;
			yyval.node = yyvsp[0].node;
		    }
    break;
case 215:
#line 1052 "parse.y"
{
			value_expr(yyvsp[0].node);
			yyval.node = NEW_BLOCK_PASS(yyvsp[0].node);
		    }
    break;
case 216:
#line 1059 "parse.y"
{
			yyval.node = yyvsp[0].node;
		    }
    break;
case 218:
#line 1066 "parse.y"
{
			value_expr(yyvsp[0].node);
			yyval.node = NEW_LIST(yyvsp[0].node);
		    }
    break;
case 219:
#line 1071 "parse.y"
{
			value_expr(yyvsp[0].node);
			yyval.node = list_append(yyvsp[-2].node, yyvsp[0].node);
		    }
    break;
case 220:
#line 1078 "parse.y"
{
			value_expr(yyvsp[0].node);
			yyval.node = yyvsp[0].node;
		    }
    break;
case 222:
#line 1086 "parse.y"
{
			value_expr(yyvsp[0].node);
			yyval.node = list_append(yyvsp[-2].node, yyvsp[0].node);
		    }
    break;
case 223:
#line 1091 "parse.y"
{
			value_expr(yyvsp[0].node);
			yyval.node = arg_concat(yyvsp[-3].node, yyvsp[0].node);
		    }
    break;
case 224:
#line 1096 "parse.y"
{
			value_expr(yyvsp[0].node);
			yyval.node = yyvsp[0].node;
		    }
    break;
case 225:
#line 1103 "parse.y"
{
			yyval.node = yyvsp[0].node;
			if (yyvsp[0].node) {
			    if (nd_type(yyvsp[0].node) == NODE_ARRAY &&
				yyvsp[0].node->nd_next == 0) {
				yyval.node = yyvsp[0].node->nd_head;
			    }
			    else if (nd_type(yyvsp[0].node) == NODE_BLOCK_PASS) {
				rb_compile_error("block argument should not be given");
			    }
			}
		    }
    break;
case 226:
#line 1118 "parse.y"
{
			yyval.node = NEW_LIT(yyvsp[0].val);
		    }
    break;
case 228:
#line 1123 "parse.y"
{
			yyval.node = NEW_XSTR(yyvsp[0].val);
		    }
    break;
case 234:
#line 1132 "parse.y"
{
			yyval.node = NEW_VCALL(yyvsp[0].id);
		    }
    break;
case 235:
#line 1141 "parse.y"
{
			if (!yyvsp[-3].node && !yyvsp[-2].node && !yyvsp[-1].node)
			    yyval.node = NEW_BEGIN(yyvsp[-4].node);
			else {
			    if (yyvsp[-3].node) yyvsp[-4].node = NEW_RESCUE(yyvsp[-4].node, yyvsp[-3].node, yyvsp[-2].node);
			    else if (yyvsp[-2].node) {
				rb_warn("else without rescue is useless");
				yyvsp[-4].node = block_append(yyvsp[-4].node, yyvsp[-2].node);
			    }
			    if (yyvsp[-1].node) yyvsp[-4].node = NEW_ENSURE(yyvsp[-4].node, yyvsp[-1].node);
			    yyval.node = yyvsp[-4].node;
			}
		        fixpos(yyval.node, yyvsp[-4].node);
		    }
    break;
case 236:
#line 1156 "parse.y"
{
			yyval.node = yyvsp[-1].node;
		    }
    break;
case 237:
#line 1160 "parse.y"
{
			value_expr(yyvsp[-2].node);
			yyval.node = NEW_COLON2(yyvsp[-2].node, yyvsp[0].id);
		    }
    break;
case 238:
#line 1165 "parse.y"
{
			yyval.node = NEW_COLON3(yyvsp[0].id);
		    }
    break;
case 239:
#line 1169 "parse.y"
{
			value_expr(yyvsp[-3].node);
			yyval.node = NEW_CALL(yyvsp[-3].node, tAREF, yyvsp[-1].node);
		    }
    break;
case 240:
#line 1174 "parse.y"
{
			if (yyvsp[-1].node == 0)
			    yyval.node = NEW_ZARRAY(); /* zero length array*/
			else {
			    yyval.node = yyvsp[-1].node;
			}
		    }
    break;
case 241:
#line 1182 "parse.y"
{
			yyval.node = NEW_HASH(yyvsp[-1].node);
		    }
    break;
case 242:
#line 1186 "parse.y"
{
			if (!compile_for_eval && !in_def && !in_single)
			    yyerror("return appeared outside of method");
			value_expr(yyvsp[-1].node);
			yyval.node = NEW_RETURN(yyvsp[-1].node);
		    }
    break;
case 243:
#line 1193 "parse.y"
{
			if (!compile_for_eval && !in_def && !in_single)
			    yyerror("return appeared outside of method");
			yyval.node = NEW_RETURN(0);
		    }
    break;
case 244:
#line 1199 "parse.y"
{
			if (!compile_for_eval && !in_def && !in_single)
			    yyerror("return appeared outside of method");
			yyval.node = NEW_RETURN(0);
		    }
    break;
case 245:
#line 1205 "parse.y"
{
			value_expr(yyvsp[-1].node);
			yyval.node = NEW_YIELD(yyvsp[-1].node);
		    }
    break;
case 246:
#line 1210 "parse.y"
{
			yyval.node = NEW_YIELD(0);
		    }
    break;
case 247:
#line 1214 "parse.y"
{
			yyval.node = NEW_YIELD(0);
		    }
    break;
case 248:
#line 1217 "parse.y"
{in_defined = 1;}
    break;
case 249:
#line 1218 "parse.y"
{
		        in_defined = 0;
			yyval.node = NEW_DEFINED(yyvsp[-1].node);
		    }
    break;
case 250:
#line 1223 "parse.y"
{
			yyvsp[0].node->nd_iter = NEW_FCALL(yyvsp[-1].id, 0);
			yyval.node = yyvsp[0].node;
		    }
    break;
case 252:
#line 1229 "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 253:
#line 1241 "parse.y"
{
			value_expr(yyvsp[-4].node);
			yyval.node = NEW_IF(cond(yyvsp[-4].node), yyvsp[-2].node, yyvsp[-1].node);
		        fixpos(yyval.node, yyvsp[-4].node);
		    }
    break;
case 254:
#line 1250 "parse.y"
{
			value_expr(yyvsp[-4].node);
			yyval.node = NEW_UNLESS(cond(yyvsp[-4].node), yyvsp[-2].node, yyvsp[-1].node);
		        fixpos(yyval.node, yyvsp[-4].node);
		    }
    break;
case 255:
#line 1255 "parse.y"
{COND_PUSH;}
    break;
case 256:
#line 1255 "parse.y"
{COND_POP;}
    break;
case 257:
#line 1258 "parse.y"
{
			value_expr(yyvsp[-4].node);
			yyval.node = NEW_WHILE(cond(yyvsp[-4].node), yyvsp[-1].node, 1);
		        fixpos(yyval.node, yyvsp[-4].node);
		    }
    break;
case 258:
#line 1263 "parse.y"
{COND_PUSH;}
    break;
case 259:
#line 1263 "parse.y"
{COND_POP;}
    break;
case 260:
#line 1266 "parse.y"
{
			value_expr(yyvsp[-4].node);
			yyval.node = NEW_UNTIL(cond(yyvsp[-4].node), yyvsp[-1].node, 1);
		        fixpos(yyval.node, yyvsp[-4].node);
		    }
    break;
case 261:
#line 1274 "parse.y"
{
			value_expr(yyvsp[-3].node);
			yyval.node = NEW_CASE(yyvsp[-3].node, yyvsp[-1].node);
		        fixpos(yyval.node, yyvsp[-3].node);
		    }
    break;
case 262:
#line 1280 "parse.y"
{
			yyval.node = yyvsp[-1].node;
		    }
    break;
case 263:
#line 1283 "parse.y"
{COND_PUSH;}
    break;
case 264:
#line 1283 "parse.y"
{COND_POP;}
    break;
case 265:
#line 1286 "parse.y"
{
			value_expr(yyvsp[-4].node);
			yyval.node = NEW_FOR(yyvsp[-7].node, yyvsp[-4].node, yyvsp[-1].node);
		        fixpos(yyval.node, yyvsp[-7].node);
		    }
    break;
case 266:
#line 1292 "parse.y"
{
			if (in_def || in_single)
			    yyerror("class definition in method body");
			class_nest++;
			local_push(0);
		        yyval.num = ruby_sourceline;
		    }
    break;
case 267:
#line 1301 "parse.y"
{
		        yyval.node = NEW_CLASS(yyvsp[-4].id, yyvsp[-1].node, yyvsp[-3].node);
		        nd_set_line(yyval.node, yyvsp[-2].num);
		        local_pop();
			class_nest--;
		    }
    break;
case 268:
#line 1308 "parse.y"
{
			yyval.num = in_def;
		        in_def = 0;
		    }
    break;
case 269:
#line 1313 "parse.y"
{
		        yyval.num = in_single;
		        in_single = 0;
			class_nest++;
			local_push(0);
		    }
    break;
case 270:
#line 1321 "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 271:
#line 1330 "parse.y"
{
			if (in_def || in_single)
			    yyerror("module definition in method body");
			class_nest++;
			local_push(0);
		        yyval.num = ruby_sourceline;
		    }
    break;
case 272:
#line 1339 "parse.y"
{
		        yyval.node = NEW_MODULE(yyvsp[-3].id, yyvsp[-1].node);
		        nd_set_line(yyval.node, yyvsp[-2].num);
		        local_pop();
			class_nest--;
		    }
    break;
case 273:
#line 1346 "parse.y"
{
			if (in_def || in_single)
			    yyerror("nested method definition");
			yyval.id = cur_mid;
			cur_mid = yyvsp[0].id;
			in_def++;
			local_push(0);
		    }
    break;
case 274:
#line 1360 "parse.y"
{
		        if (yyvsp[-3].node) yyvsp[-4].node = NEW_RESCUE(yyvsp[-4].node, yyvsp[-3].node, yyvsp[-2].node);
			else if (yyvsp[-2].node) {
			    rb_warn("else without rescue is useless");
			    yyvsp[-4].node = block_append(yyvsp[-4].node, yyvsp[-2].node);
			}
			if (yyvsp[-1].node) yyvsp[-4].node = NEW_ENSURE(yyvsp[-4].node, yyvsp[-1].node);

			yyval.node = NEW_DEFN(yyvsp[-7].id, yyvsp[-5].node, yyvsp[-4].node, NOEX_PRIVATE);
			if (is_attrset_id(yyvsp[-7].id)) yyval.node->nd_noex = NOEX_PUBLIC;
		        fixpos(yyval.node, yyvsp[-5].node);
		        local_pop();
			in_def--;
			cur_mid = yyvsp[-6].id;
		    }
    break;
case 275:
#line 1375 "parse.y"
{lex_state = EXPR_FNAME;}
    break;
case 276:
#line 1376 "parse.y"
{
			value_expr(yyvsp[-3].node);
			in_single++;
			local_push(0);
		        lex_state = EXPR_END; /* force for args */
		    }
    break;
case 277:
#line 1388 "parse.y"
{
		        if (yyvsp[-3].node) yyvsp[-4].node = NEW_RESCUE(yyvsp[-4].node, yyvsp[-3].node, yyvsp[-2].node);
			else if (yyvsp[-2].node) {
			    rb_warn("else without rescue is useless");
			    yyvsp[-4].node = block_append(yyvsp[-4].node, yyvsp[-2].node);
			}
			if (yyvsp[-1].node) yyvsp[-4].node = NEW_ENSURE(yyvsp[-4].node, yyvsp[-1].node);

			yyval.node = NEW_DEFS(yyvsp[-10].node, yyvsp[-7].id, yyvsp[-5].node, yyvsp[-4].node);
		        fixpos(yyval.node, yyvsp[-10].node);
		        local_pop();
			in_single--;
		    }
    break;
case 278:
#line 1402 "parse.y"
{
			yyval.node = NEW_BREAK();
		    }
    break;
case 279:
#line 1406 "parse.y"
{
			yyval.node = NEW_NEXT();
		    }
    break;
case 280:
#line 1410 "parse.y"
{
			yyval.node = NEW_REDO();
		    }
    break;
case 281:
#line 1414 "parse.y"
{
			yyval.node = NEW_RETRY();
		    }
    break;
case 288:
#line 1432 "parse.y"
{
			value_expr(yyvsp[-3].node);
			yyval.node = NEW_IF(cond(yyvsp[-3].node), yyvsp[-1].node, yyvsp[0].node);
		        fixpos(yyval.node, yyvsp[-3].node);
		    }
    break;
case 290:
#line 1441 "parse.y"
{
			yyval.node = yyvsp[0].node;
		    }
    break;
case 294:
#line 1452 "parse.y"
{
			yyval.node = (NODE*)1;
		    }
    break;
case 295:
#line 1456 "parse.y"
{
			yyval.node = (NODE*)1;
		    }
    break;
case 296:
#line 1460 "parse.y"
{
			yyval.node = yyvsp[-1].node;
		    }
    break;
case 297:
#line 1467 "parse.y"
{
		        yyval.vars = dyna_push();
		    }
    break;
case 298:
#line 1473 "parse.y"
{
			yyval.node = NEW_ITER(yyvsp[-2].node, 0, yyvsp[-1].node);
		        fixpos(yyval.node, yyvsp[-2].node?yyvsp[-2].node:yyvsp[-1].node);
			dyna_pop(yyvsp[-3].vars);
		    }
    break;
case 299:
#line 1481 "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[0].node);
		    }
    break;
case 300:
#line 1490 "parse.y"
{
			value_expr(yyvsp[-3].node);
			yyval.node = new_call(yyvsp[-3].node, yyvsp[-1].id, yyvsp[0].node);
		    }
    break;
case 301:
#line 1495 "parse.y"
{
			value_expr(yyvsp[-3].node);
			yyval.node = new_call(yyvsp[-3].node, yyvsp[-1].id, yyvsp[0].node);
		    }
    break;
case 302:
#line 1502 "parse.y"
{
			yyval.node = new_fcall(yyvsp[-1].id, yyvsp[0].node);
		        fixpos(yyval.node, yyvsp[0].node);
		    }
    break;
case 303:
#line 1507 "parse.y"
{
			value_expr(yyvsp[-3].node);
			yyval.node = new_call(yyvsp[-3].node, yyvsp[-1].id, yyvsp[0].node);
		        fixpos(yyval.node, yyvsp[-3].node);
		    }
    break;
case 304:
#line 1513 "parse.y"
{
			value_expr(yyvsp[-3].node);
			yyval.node = new_call(yyvsp[-3].node, yyvsp[-1].id, yyvsp[0].node);
		        fixpos(yyval.node, yyvsp[-3].node);
		    }
    break;
case 305:
#line 1519 "parse.y"
{
			value_expr(yyvsp[-2].node);
			yyval.node = new_call(yyvsp[-2].node, yyvsp[0].id, 0);
		    }
    break;
case 306:
#line 1524 "parse.y"
{
			if (!compile_for_eval && !in_def &&
		            !in_single && !in_defined)
			    yyerror("super called outside of method");
			yyval.node = new_super(yyvsp[0].node);
		    }
    break;
case 307:
#line 1531 "parse.y"
{
			if (!compile_for_eval && !in_def &&
		            !in_single && !in_defined)
			    yyerror("super called outside of method");
			yyval.node = NEW_ZSUPER();
		    }
    break;
case 308:
#line 1540 "parse.y"
{
		        yyval.vars = dyna_push();
		    }
    break;
case 309:
#line 1545 "parse.y"
{
			yyval.node = NEW_ITER(yyvsp[-2].node, 0, yyvsp[-1].node);
		        fixpos(yyval.node, yyvsp[-1].node);
			dyna_pop(yyvsp[-3].vars);
		    }
    break;
case 310:
#line 1551 "parse.y"
{
		        yyval.vars = dyna_push();
		    }
    break;
case 311:
#line 1556 "parse.y"
{
			yyval.node = NEW_ITER(yyvsp[-2].node, 0, yyvsp[-1].node);
		        fixpos(yyval.node, yyvsp[-1].node);
			dyna_pop(yyvsp[-3].vars);
		    }
    break;
case 312:
#line 1566 "parse.y"
{
			yyval.node = NEW_WHEN(yyvsp[-3].node, yyvsp[-1].node, yyvsp[0].node);
		    }
    break;
case 314:
#line 1573 "parse.y"
{
			value_expr(yyvsp[0].node);
			yyval.node = list_append(yyvsp[-3].node, NEW_WHEN(yyvsp[0].node, 0, 0));
		    }
    break;
case 315:
#line 1578 "parse.y"
{
			value_expr(yyvsp[0].node);
			yyval.node = NEW_LIST(NEW_WHEN(yyvsp[0].node, 0, 0));
		    }
    break;
case 320:
#line 1593 "parse.y"
{
			yyval.node = yyvsp[0].node;
		    }
    break;
case 322:
#line 1602 "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 325:
#line 1615 "parse.y"
{
			if (yyvsp[0].node)
			    yyval.node = yyvsp[0].node;
			else
			    /* place holder */
			    yyval.node = NEW_NIL();
		    }
    break;
case 327:
#line 1626 "parse.y"
{
			yyval.val = ID2SYM(yyvsp[0].id);
		    }
    break;
case 329:
#line 1633 "parse.y"
{
			yyval.node = NEW_STR(yyvsp[0].val);
		    }
    break;
case 331:
#line 1638 "parse.y"
{
		        if (nd_type(yyvsp[-1].node) == NODE_DSTR) {
			    list_append(yyvsp[-1].node, NEW_STR(yyvsp[0].val));
			}
			else {
			    rb_str_concat(yyvsp[-1].node->nd_lit, yyvsp[0].val);
			}
			yyval.node = yyvsp[-1].node;
		    }
    break;
case 332:
#line 1648 "parse.y"
{
		        if (nd_type(yyvsp[-1].node) == NODE_STR) {
			    yyval.node = NEW_DSTR(yyvsp[-1].node->nd_lit);
			}
			else {
			    yyval.node = yyvsp[-1].node;
			}
			yyvsp[0].node->nd_head = NEW_STR(yyvsp[0].node->nd_lit);
			nd_set_type(yyvsp[0].node, NODE_ARRAY);
			list_concat(yyval.node, yyvsp[0].node);
		    }
    break;
case 333:
#line 1662 "parse.y"
{
		        lex_state = EXPR_END;
			yyval.id = yyvsp[0].id;
		    }
    break;
case 345:
#line 1683 "parse.y"
{yyval.id = kNIL;}
    break;
case 346:
#line 1684 "parse.y"
{yyval.id = kSELF;}
    break;
case 347:
#line 1685 "parse.y"
{yyval.id = kTRUE;}
    break;
case 348:
#line 1686 "parse.y"
{yyval.id = kFALSE;}
    break;
case 349:
#line 1687 "parse.y"
{yyval.id = k__FILE__;}
    break;
case 350:
#line 1688 "parse.y"
{yyval.id = k__LINE__;}
    break;
case 351:
#line 1692 "parse.y"
{
			yyval.node = gettable(yyvsp[0].id);
		    }
    break;
case 354:
#line 1702 "parse.y"
{
			yyval.node = 0;
		    }
    break;
case 355:
#line 1706 "parse.y"
{
			lex_state = EXPR_BEG;
		    }
    break;
case 356:
#line 1710 "parse.y"
{
			yyval.node = yyvsp[-1].node;
		    }
    break;
case 357:
#line 1713 "parse.y"
{yyerrok; yyval.node = 0;}
    break;
case 358:
#line 1717 "parse.y"
{
			yyval.node = yyvsp[-2].node;
			lex_state = EXPR_BEG;
		    }
    break;
case 359:
#line 1722 "parse.y"
{
			yyval.node = yyvsp[-1].node;
		    }
    break;
case 360:
#line 1728 "parse.y"
{
			yyval.node = block_append(NEW_ARGS(yyvsp[-5].num, yyvsp[-3].node, yyvsp[-1].id), yyvsp[0].node);
		    }
    break;
case 361:
#line 1732 "parse.y"
{
			yyval.node = block_append(NEW_ARGS(yyvsp[-3].num, yyvsp[-1].node, -1), yyvsp[0].node);
		    }
    break;
case 362:
#line 1736 "parse.y"
{
			yyval.node = block_append(NEW_ARGS(yyvsp[-3].num, 0, yyvsp[-1].id), yyvsp[0].node);
		    }
    break;
case 363:
#line 1740 "parse.y"
{
			yyval.node = block_append(NEW_ARGS(yyvsp[-1].num, 0, -1), yyvsp[0].node);
		    }
    break;
case 364:
#line 1744 "parse.y"
{
			yyval.node = block_append(NEW_ARGS(0, yyvsp[-3].node, yyvsp[-1].id), yyvsp[0].node);
		    }
    break;
case 365:
#line 1748 "parse.y"
{
			yyval.node = block_append(NEW_ARGS(0, yyvsp[-1].node, -1), yyvsp[0].node);
		    }
    break;
case 366:
#line 1752 "parse.y"
{
			yyval.node = block_append(NEW_ARGS(0, 0, yyvsp[-1].id), yyvsp[0].node);
		    }
    break;
case 367:
#line 1756 "parse.y"
{
			yyval.node = block_append(NEW_ARGS(0, 0, -1), yyvsp[0].node);
		    }
    break;
case 368:
#line 1760 "parse.y"
{
			yyval.node = NEW_ARGS(0, 0, -1);
		    }
    break;
case 369:
#line 1766 "parse.y"
{
			yyerror("formal argument cannot be a constant");
		    }
    break;
case 370:
#line 1770 "parse.y"
{
                        yyerror("formal argument cannot be an instance variable");
		    }
    break;
case 371:
#line 1774 "parse.y"
{
                        yyerror("formal argument cannot be a global variable");
		    }
    break;
case 372:
#line 1778 "parse.y"
{
                        yyerror("formal argument cannot be a class variable");
		    }
    break;
case 373:
#line 1782 "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 375:
#line 1794 "parse.y"
{
			yyval.num += 1;
		    }
    break;
case 376:
#line 1800 "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 377:
#line 1810 "parse.y"
{
			yyval.node = NEW_BLOCK(yyvsp[0].node);
			yyval.node->nd_end = yyval.node;
		    }
    break;
case 378:
#line 1815 "parse.y"
{
			yyval.node = block_append(yyvsp[-2].node, yyvsp[0].node);
		    }
    break;
case 379:
#line 1821 "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 380:
#line 1829 "parse.y"
{
			yyval.id = -2;
		    }
    break;
case 381:
#line 1835 "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 382:
#line 1845 "parse.y"
{
			yyval.node = yyvsp[0].node;
		    }
    break;
case 384:
#line 1852 "parse.y"
{
			if (nd_type(yyvsp[0].node) == NODE_SELF) {
			    yyval.node = NEW_SELF();
			}
			else {
			    yyval.node = yyvsp[0].node;
			}
		    }
    break;
case 385:
#line 1860 "parse.y"
{lex_state = EXPR_BEG;}
    break;
case 386:
#line 1861 "parse.y"
{
					if (yyvsp[-2].node == 0) {
			    yyerror("can't define single 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 single method for literals");
			      default:
				value_expr(yyvsp[-2].node);
				break;
			    }
			}
			yyval.node = yyvsp[-2].node;
		    }
    break;
case 388:
#line 1887 "parse.y"
{
			yyval.node = yyvsp[-1].node;
		    }
    break;
case 389:
#line 1891 "parse.y"
{
			if (yyvsp[-1].node->nd_alen%2 != 0) {
			    yyerror("odd number list for Hash");
			}
			yyval.node = yyvsp[-1].node;
		    }
    break;
case 391:
#line 1901 "parse.y"
{
			yyval.node = list_concat(yyvsp[-2].node, yyvsp[0].node);
		    }
    break;
case 392:
#line 1907 "parse.y"
{
			yyval.node = list_append(NEW_LIST(yyvsp[-2].node), yyvsp[0].node);
		    }
    break;
case 412:
#line 1945 "parse.y"
{yyerrok;}
    break;
case 415:
#line 1950 "parse.y"
{yyerrok;}
    break;
case 416:
#line 1954 "parse.y"
{
			yyval.node = 0;
		    }
    break;
}

#line 705 "/usr/share/bison/bison.simple"