grammar Ruby;

class DefaultRubyParser extends Parser;
options {
        importVocab=Ruby;
}

program       : /*{
                  lexer.setState(LexState.EXPR_BEG);
                  support.initTopLocalVariables();
              }*/ compstmt /*{
                  if ($2 != null) {
                      // last expression should not be void
                      if ($2 instanceof BlockNode) {
                          support.checkUselessStatement($<BlockNode>2.getLast());
                      } else {
                          support.checkUselessStatement($2);
                      }
                  }
                  support.getResult().seAST(support.addRootNode($2));
              }*/
    ;

bodystmt      : compstmt opt_rescue opt_else opt_ensure /*{
                  Node node = $1;

                  if ($2 != null) {
                      node = new RescueNode(getPosition($1, true), $1, $2, $3);
                  } else if ($3 != null) {
                      warnings.warn(getPosition($1), "else without rescue is useless");
                      node = support.appendToBlock($1, $3);
                  }
                  if ($4 != null) {
                      node = new EnsureNode(getPosition($1), node, $4);
                  }

                  $$ = node;
              }*/
    ;

compstmt      : stmts opt_terms /*{
                  if ($1 instanceof BlockNode) {
                      support.checkUselessStatements($<BlockNode>1);
                  }
                  $$ = $1;
              }*/
    ;

stmts         : none
              | stmt /*{
                  $$ = support.newline_node($1, getPosition($1, true));
              }*/
              | stmts terms stmt /*{
                  $$ = support.appendToBlock($1, support.newline_node($3, getPosition($3, true)));
              }*/
              /*| error stmt {
                  $$ = $2;
              }*/
    ;

stmt          : ALIAS fitem /*{
                  lexer.setState(LexState.EXPR_FNAME);
              }*/ fitem /*{
                  $$ = new AliasNode(support.union($1, $4), (String) $2.getValue(), (String) $4.getValue());
              }*/
              | ALIAS GVAR GVAR /*{
                  $$ = new VAliasNode(getPosition($1), (String) $2.getValue(), (String) $3.getValue());
              }*/
              | ALIAS GVAR BACK_REF /*{
                  $$ = new VAliasNode(getPosition($1), (String) $2.getValue(), "$" + $<BackRefNode>3.getType()); // XXX
              }*/
              | ALIAS GVAR NTH_REF /*{
                  yyerror("can't make alias for the number variables");
              }*/
              | UNDEF undef_list /*{
                  $$ = $2;
              }*/
              | stmt IF_MOD expr_value /*{
                  $$ = new IfNode(support.union($1, $3), support.getConditionNode($3), $1, null);
              }*/
              | stmt UNLESS_MOD expr_value /*{
                  $$ = new IfNode(support.union($1, $3), support.getConditionNode($3), null, $1);
              }*/
              | stmt WHILE_MOD expr_value /*{
                  if ($1 != null && $1 instanceof BeginNode) {
                      $$ = new WhileNode(getPosition($1), support.getConditionNode($3), $<BeginNode>1.getBodyNode(), false);
                  } else {
                      $$ = new WhileNode(getPosition($1), support.getConditionNode($3), $1, true);
                  }
              }*/
              | stmt UNTIL_MOD expr_value /*{
                  if ($1 != null && $1 instanceof BeginNode) {
                      $$ = new UntilNode(getPosition($1), support.getConditionNode($3), $<BeginNode>1.getBodyNode());
                  } else {
                      $$ = new UntilNode(getPosition($1), support.getConditionNode($3), $1);
                  }
              }*/
              | stmt RESCUE_MOD stmt /*{
                  $$ = new RescueNode(getPosition($1), $1, new RescueBodyNode(getPosition($1), null,$3, null), null);
              }*/
              | LBEGIN /*{
                  if (support.isInDef() || support.isInSingle()) {
                      yyerror("BEGIN in method");
                  }
                  support.pushLocalScope();
              }*/ LCURLY compstmt RCURLY /*{
                  support.getResult().addBeginNode(support.getCurrentScope(), $4);
                  support.popCurrentScope();
                  $$ = null; //XXX 0;
              }*/
              | LEND LCURLY compstmt RCURLY /*{
                  if (support.isInDef() || support.isInSingle()) {
                      yyerror("END in method; use at_exit");
                  }
                  // FIXME: Totally broken if scoping is important...though if not this is an improvement over iterNode
                  support.getResult().addEndNode(new PostExeNode(getPosition($1), $3));
                  $$ = null;
              }*/
              | lhs '=' command_call /*{
                  support.checkExpression($3);
                  $$ = support.node_assign($1, $3);
              }*/
              | mlhs '=' command_call /*{
                  support.checkExpression($3);
                  if ($1.getHeadNode() != null) {
                      $1.setValueNode(new ToAryNode(getPosition($1), $3));
                  } else {
                      $1.setValueNode(new ArrayNode(getPosition($1), $3));
                  }
                  $$ = $1;
              }*/
              | var_lhs OP_ASGN command_call /*{
                  support.checkExpression($3);

                  String name = $<INameNode>1.getName();
                  String asgnOp = (String) $2.getValue();
                  if (asgnOp.equals("||")) {
                      $1.setValueNode($3);
                      $$ = new OpAsgnOrNode(support.union($1, $3), support.gettable2(name, $1.getPosition()), $1);
                  } else if (asgnOp.equals("&&")) {
                      $1.setValueNode($3);
                      $$ = new OpAsgnAndNode(support.union($1, $3), support.gettable2(name, $1.getPosition()), $1);
                  } else {
                      $1.setValueNode(support.getOperatorCallNode(support.gettable2(name, $1.getPosition()), asgnOp, $3));
                      $1.setPosition(support.union($1, $3));
                      $$ = $1;
                  }
              }*/
              | primary_value '[' aref_args RBRACK OP_ASGN command_call /*{
                  $$ = new OpElementAsgnNode(getPosition($1), $1, (String) $5.getValue(), $3, $6);

              }*/
              | primary_value DOT IDENTIFIER OP_ASGN command_call /*{
                  $$ = new OpAsgnNode(getPosition($1), $1, $5, (String) $3.getValue(), (String) $4.getValue());
              }*/
              | primary_value DOT CONSTANT OP_ASGN command_call /*{
                  $$ = new OpAsgnNode(getPosition($1), $1, $5, (String) $3.getValue(), (String) $4.getValue());
              }*/
              | primary_value COLON2 IDENTIFIER OP_ASGN command_call /*{
                  $$ = new OpAsgnNode(getPosition($1), $1, $5, (String) $3.getValue(), (String) $4.getValue());
              }*/
              | backref OP_ASGN command_call /*{
                  support.backrefAssignError($1);
              }*/
              | lhs '=' mrhs /*{
                  $$ = support.node_assign($1, new SValueNode(getPosition($1), $3));
              }*/
              | mlhs '=' arg_value /*{
                  if ($1.getHeadNode() != null) {
                      $1.setValueNode(new ToAryNode(getPosition($1), $3));
                  } else {
                      $1.setValueNode(new ArrayNode(getPosition($1), $3));
                  }
                  $$ = $1;
              }*/
              | mlhs '=' mrhs /*{
                  $<AssignableNode>1.setValueNode($3);
                  $$ = $1;
                  $1.setPosition(support.union($1, $3));
              }*/
              | expr 
    ;

expr          : command_call 
              | expr AND expr /*{
                  $$ = support.newAndNode($1, $3);
              }*/
              | expr OR expr /*{
                  $$ = support.newOrNode($1, $3);
              }*/
              | NOT expr /*{
                  $$ = new NotNode(support.union($1, $2), support.getConditionNode($2));
              }*/
              | BANG command_call /*{
                  $$ = new NotNode(support.union($1, $2), support.getConditionNode($2));
              }*/
              | arg
    ;

expr_value    : expr /*{
                  support.checkExpression($1);
              }*/
    ;

command_call  : command
              | block_command
              | RETURN call_args /*{
                  $$ = new ReturnNode(support.union($1, $2), support.ret_args($2, getPosition($1)));
              }*/
              | BREAK call_args /*{
                  $$ = new BreakNode(support.union($1, $2), support.ret_args($2, getPosition($1)));
              }*/
              | NEXT call_args /*{
                  $$ = new NextNode(support.union($1, $2), support.ret_args($2, getPosition($1)));
              }*/
    ;

block_command : block_call
              | block_call DOT operation2 command_args /*{
                  $$ = support.new_call($1, $3, $4, null);
              }*/
              | block_call COLON2 operation2 command_args /*{
                  $$ = support.new_call($1, $3, $4, null);
              }*/
    ;

cmd_brace_block : LBRACE_ARG /*{
                    support.pushBlockScope();
                }*/ opt_block_var compstmt RCURLY /*{
                    $$ = new IterNode(getPosition($1), $3, support.getCurrentScope(), $4);
                    support.popCurrentScope();
                }*/
    ;

command       : operation command_args  /*%prec LOWEST*/ /*{
                  $$ = support.new_fcall($1, $2, null);
              }*/
              | operation command_args cmd_brace_block /*{
                  $$ = support.new_fcall($1, $2, $3); 
              }*/
              | primary_value DOT operation2 command_args /*%prec LOWEST*/ /*{
                  $$ = support.new_call($1, $3, $4, null);
              }*/
              | primary_value DOT operation2 command_args cmd_brace_block /*{
                  $$ = support.new_call($1, $3, $4, $5); 
              }*/
              | primary_value COLON2 operation2 command_args /*%prec LOWEST*/ /*{
                  $$ = support.new_call($1, $3, $4, null);
              }*/
              | primary_value COLON2 operation2 command_args cmd_brace_block /*{
                  $$ = support.new_call($1, $3, $4, $5); 
              }*/
              | SUPER command_args /*{
                  $$ = support.new_super($2, $1); // .setPosFrom($2);
              }*/
              | YIELD command_args /*{
                  $$ = support.new_yield(getPosition($1), $2);
              }*/
    ;

mlhs          : mlhs_basic
              | LPAREN mlhs_entry RPAREN /*{
                  $$ = $2;
              }*/
    ;

mlhs_entry    : mlhs_basic
              | LPAREN mlhs_entry RPAREN /*{
                  $$ = new MultipleAsgnNode(getPosition($1), new ArrayNode(getPosition($1), $2), null);
              }*/
    ;

mlhs_basic    : mlhs_head /*{
                  $$ = new MultipleAsgnNode(getPosition($1), $1, null);
              }*/
              | mlhs_head mlhs_item /*{
                  $$ = new MultipleAsgnNode(support.union($<Node>1, $<Node>2), $1.add($2), null);
                  $<Node>1.setPosition(support.union($<Node>1, $<Node>2));
              }*/
              | mlhs_head STAR mlhs_node /*{
                  $$ = new MultipleAsgnNode(getPosition($1), $1, $3);
              }*/
              | mlhs_head STAR /*{
                  $$ = new MultipleAsgnNode(getPosition($1), $1, new StarNode(getPosition(null)));
              }*/
              | STAR mlhs_node /*{
                  $$ = new MultipleAsgnNode(getPosition($1), null, $2);
              }*/
              | STAR /*{
                  $$ = new MultipleAsgnNode(getPosition($1), null, new StarNode(getPosition(null)));
              }*/
    ;

mlhs_item     : mlhs_node 
              | LPAREN mlhs_entry RPAREN /*{
                  $$ = $2;
              }*/
    ;

mlhs_head     : mlhs_item ',' /*{
                  $$ = new ArrayNode($1.getPosition(), $1);
              }*/
              | mlhs_head mlhs_item ',' /*{
                  $$ = $1.add($2);
              }*/
    ;

mlhs_node     : variable /*{
                  $$ = support.assignable($1, null);
              }*/
              | primary_value '[' aref_args RBRACK /*{
                  $$ = support.aryset($1, $3);
              }*/
              | primary_value DOT IDENTIFIER /*{
                  $$ = support.attrset($1, (String) $3.getValue());
              }*/
              | primary_value COLON2 IDENTIFIER /*{
                  $$ = support.attrset($1, (String) $3.getValue());
              }*/
              | primary_value DOT CONSTANT /*{
                  $$ = support.attrset($1, (String) $3.getValue());
              }*/
              | primary_value COLON2 CONSTANT /*{
                  if (support.isInDef() || support.isInSingle()) {
                      yyerror("dynamic constant assignment");
                  }

                  ISourcePosition position = support.union($1, $3);

                  $$ = new ConstDeclNode(position, null, new Colon2Node(position, $1, (String) $3.getValue()), null);
              }*/
              | COLON3 CONSTANT /*{
                  if (support.isInDef() || support.isInSingle()) {
                      yyerror("dynamic constant assignment");
                  }

                  ISourcePosition position = support.union($1, $2);

                  $$ = new ConstDeclNode(position, null, new Colon3Node(position, (String) $2.getValue()), null);
              }*/
              | backref /*{
                  support.backrefAssignError($1);
              }*/
    ;

lhs           : variable /*{
                  $$ = support.assignable($1, null);
              }*/
              | primary_value '[' aref_args RBRACK /*{
                  $$ = support.aryset($1, $3);
              }*/
              | primary_value DOT IDENTIFIER /*{
                  $$ = support.attrset($1, (String) $3.getValue());
              }*/
              | primary_value COLON2 IDENTIFIER /*{
                  $$ = support.attrset($1, (String) $3.getValue());
              }*/
              | primary_value DOT CONSTANT /*{
                  $$ = support.attrset($1, (String) $3.getValue());
              }*/
              | primary_value COLON2 CONSTANT /*{
                  if (support.isInDef() || support.isInSingle()) {
                      yyerror("dynamic constant assignment");
                  }
                        
                  ISourcePosition position = support.union($1, $3);

                  $$ = new ConstDeclNode(position, null, new Colon2Node(position, $1, (String) $3.getValue()), null);
              }*/
              | COLON3 CONSTANT /*{
                  if (support.isInDef() || support.isInSingle()) {
                      yyerror("dynamic constant assignment");
                  }

                  ISourcePosition position = support.union($1, $2);

                  $$ = new ConstDeclNode(position, null, new Colon3Node(position, (String) $2.getValue()), null);
              }*/
              | backref /*{
                   support.backrefAssignError($1);
              }*/
    ;

cname         : IDENTIFIER /*{
                  yyerror("class/module name must be CONSTANT");
              }*/
              | CONSTANT
    ;

cpath         : COLON3 cname /*{
                  $$ = new Colon3Node(support.union($1, $2), (String) $2.getValue());
              }*/
              | cname /*{
                  $$ = new Colon2Node($1.getPosition(), null, (String) $1.getValue());
              }*/
              | primary_value COLON2 cname /*{
                  $$ = new Colon2Node(support.union($1, $3), $1, (String) $3.getValue());
              }*/
    ;

// Token:fname - A function name [!null]
fname         : IDENTIFIER | CONSTANT | FID
              | op /*{
                  lexer.setState(LexState.EXPR_END);
                  $$ = $1;
              }*/
              // FIXME: reswords is really Keyword which is not a Token...This should bomb
              | reswords /*{
                  lexer.setState(LexState.EXPR_END);
                  $$ = $<>1;
              }*/
    ;

fitem         : fname | symbol
    ;

undef_list    : fitem /*{
                  $$ = new UndefNode(getPosition($1), (String) $1.getValue());
              }*/
              | undef_list ',' /*{
                  lexer.setState(LexState.EXPR_FNAME);
              }*/ fitem /*{
                  $$ = support.appendToBlock($1, new UndefNode(getPosition($1), (String) $4.getValue()));
              }*/
    ;

// Token:op - inline operations [!null]
op            : PIPE | CARET | AMPER2 | CMP | EQ | EQQ | MATCH | GT
              | GEQ | LT | LEQ | LSHFT | RSHFT | PLUS  | MINUS | STAR2
              | STAR | DIVIDE | PERCENT | POW | TILDE | UPLUS | UMINUS
              | AREF | ASET | BACK_REF2
    ;

// Keyword:reswords - reserved words [!null]
reswords        : U_LINE_U | U_FILE_U  | LBEGIN | LEND
                | ALIAS | AND | BEGIN | BREAK | CASE | CLASS | DEF
                | DEFINED | DO | ELSE | ELSIF | END | ENSURE | FALSE
                | FOR | IN | MODULE | NEXT | NIL | NOT
                | OR | REDO | RESCUE | RETRY | RETURN | SELF | SUPER
                | THEN | TRUE | UNDEF | WHEN | YIELD
                | IF_MOD | UNLESS_MOD | WHILE_MOD | UNTIL_MOD | RESCUE_MOD
    ;

arg           : lhs '=' arg /*{
                  $$ = support.node_assign($1, $3);
                  // FIXME: Consider fixing node_assign itself rather than single case
                  $<Node>$.setPosition(support.union($1, $3));
              }*/
              | lhs '=' arg RESCUE_MOD arg /*{
                  ISourcePosition position = support.union($4, $5);
                  $$ = support.node_assign($1, new RescueNode(position, $3, new RescueBodyNode(position, null, $5, null), null));
              }*/
              | var_lhs OP_ASGN arg /*{
                  support.checkExpression($3);
                  String name = $<INameNode>1.getName();
                  String asgnOp = (String) $2.getValue();

                  if (asgnOp.equals("||")) {
                      $1.setValueNode($3);
                      $$ = new OpAsgnOrNode(support.union($1, $3), support.gettable2(name, $1.getPosition()), $1);
                  } else if (asgnOp.equals("&&")) {
                      $1.setValueNode($3);
                      $$ = new OpAsgnAndNode(support.union($1, $3), support.gettable2(name, $1.getPosition()), $1);
                  } else {
                      $1.setValueNode(support.getOperatorCallNode(support.gettable2(name, $1.getPosition()), asgnOp, $3));
                      $1.setPosition(support.union($1, $3));
                      $$ = $1;
                  }
              }*/
              | primary_value '[' aref_args RBRACK OP_ASGN arg /*{
                  $$ = new OpElementAsgnNode(getPosition($1), $1, (String) $5.getValue(), $3, $6);
              }*/
              | primary_value DOT IDENTIFIER OP_ASGN arg /*{
                  $$ = new OpAsgnNode(getPosition($1), $1, $5, (String) $3.getValue(), (String) $4.getValue());
              }*/
              | primary_value DOT CONSTANT OP_ASGN arg /*{
                  $$ = new OpAsgnNode(getPosition($1), $1, $5, (String) $3.getValue(), (String) $4.getValue());
              }*/
              | primary_value COLON2 IDENTIFIER OP_ASGN arg /*{
                  $$ = new OpAsgnNode(getPosition($1), $1, $5, (String) $3.getValue(), (String) $4.getValue());
              }*/
              | primary_value COLON2 CONSTANT OP_ASGN arg /*{
                  yyerror("constant re-assignment");
              }*/
              | COLON3 CONSTANT OP_ASGN arg /*{
                  yyerror("constant re-assignment");
              }*/
              | backref OP_ASGN arg /*{
                  support.backrefAssignError($1);
              }*/
              | arg DOT2 arg /*{
                  support.checkExpression($1);
                  support.checkExpression($3);
                  $$ = new DotNode(support.union($1, $3), $1, $3, false);
              }*/
              | arg DOT3 arg /*{
                  support.checkExpression($1);
                  support.checkExpression($3);
                  $$ = new DotNode(support.union($1, $3), $1, $3, true);
              }*/
              | arg PLUS arg /*{
                  $$ = support.getOperatorCallNode($1, "+", $3, getPosition(null));
              }*/
              | arg MINUS arg /*{
                  $$ = support.getOperatorCallNode($1, "-", $3, getPosition(null));
              }*/
              | arg STAR2 arg /*{
                  $$ = support.getOperatorCallNode($1, "*", $3, getPosition(null));
              }*/
              | arg DIVIDE arg /*{
                  $$ = support.getOperatorCallNode($1, "/", $3, getPosition(null));
              }*/
              | arg PERCENT arg /*{
                  $$ = support.getOperatorCallNode($1, "%", $3, getPosition(null));
              }*/
              | arg POW arg /*{
                  $$ = support.getOperatorCallNode($1, "**", $3, getPosition(null));
              }*/
              | UMINUS_NUM INTEGER POW arg /*{
                  $$ = support.getOperatorCallNode(support.getOperatorCallNode($2, "**", $4, getPosition(null)), "-@");
              }*/
              | UMINUS_NUM FLOAT POW arg /*{
                  $$ = support.getOperatorCallNode(support.getOperatorCallNode($2, "**", $4, getPosition(null)), "-@");
              }*/
              | UPLUS arg /*{
                  if ($2 != null && $2 instanceof ILiteralNode) {
                      $$ = $2;
                  } else {
                      $$ = support.getOperatorCallNode($2, "+@");
                  }
              }*/
              | UMINUS arg /*{
                  $$ = support.getOperatorCallNode($2, "-@");
              }*/
              | arg PIPE arg /*{
                  $$ = support.getOperatorCallNode($1, "|", $3, getPosition(null));
              }*/
              | arg CARET arg /*{
                  $$ = support.getOperatorCallNode($1, "^", $3, getPosition(null));
              }*/
              | arg AMPER2 arg /*{
                  $$ = support.getOperatorCallNode($1, "&", $3, getPosition(null));
              }*/
              | arg CMP arg /*{
                  $$ = support.getOperatorCallNode($1, "<=>", $3, getPosition(null));
              }*/
              | arg GT arg /*{
                  $$ = support.getOperatorCallNode($1, ">", $3, getPosition(null));
              }*/
              | arg GEQ arg /*{
                  $$ = support.getOperatorCallNode($1, ">=", $3, getPosition(null));
              }*/
              | arg LT arg /*{
                  $$ = support.getOperatorCallNode($1, "<", $3, getPosition(null));
              }*/
              | arg LEQ arg /*{
                  $$ = support.getOperatorCallNode($1, "<=", $3, getPosition(null));
              }*/
              | arg EQ arg /*{
                  $$ = support.getOperatorCallNode($1, "==", $3, getPosition(null));
              }*/
              | arg EQQ arg /*{
                  $$ = support.getOperatorCallNode($1, "===", $3, getPosition(null));
              }*/
              | arg NEQ arg /*{
                  $$ = new NotNode(support.union($1, $3), support.getOperatorCallNode($1, "==", $3, getPosition(null)));
              }*/
              | arg MATCH arg /*{
                  $$ = support.getMatchNode($1, $3);
              }*/
              | arg NMATCH arg /*{
                  $$ = new NotNode(support.union($1, $3), support.getMatchNode($1, $3));
              }*/
              | BANG arg /*{
                  $$ = new NotNode(support.union($1, $2), support.getConditionNode($2));
              }*/
              | TILDE arg /*{
                  $$ = support.getOperatorCallNode($2, "~");
              }*/
              | arg LSHFT arg /*{
                  $$ = support.getOperatorCallNode($1, "<<", $3, getPosition(null));
              }*/
              | arg RSHFT arg /*{
                  $$ = support.getOperatorCallNode($1, ">>", $3, getPosition(null));
              }*/
              | arg ANDOP arg /*{
                  $$ = support.newAndNode($1, $3);
              }*/
              | arg OROP arg /*{
                  $$ = support.newOrNode($1, $3);
              }*/
              | DEFINED opt_nl arg /*{
                  $$ = new DefinedNode(getPosition($1), $3);
              }*/
              | arg '?' arg ':' arg /*{
                  $$ = new IfNode(getPosition($1), support.getConditionNode($1), $3, $5);
              }*/
              | primary /*{
                  $$ = $1;
              }*/
    ;

arg_value     : arg /*{
                  support.checkExpression($1);
                  $$ = $1;   
              }*/
    ;

aref_args     : none
              | command opt_nl /*{
                  warnings.warn(getPosition($1), "parenthesize argument(s) for future version");
                  $$ = new ArrayNode(getPosition($1), $1);
              }*/
              | args trailer /*{
                  $$ = $1;
              }*/
              | args ',' STAR arg opt_nl /*{
                  support.checkExpression($4);
                  $$ = support.arg_concat(getPosition($1), $1, $4);
              }*/
              | assocs trailer /*{
                  $$ = new ArrayNode(getPosition($1), new HashNode(getPosition(null), $1));
              }*/
              | STAR arg opt_nl /*{
                  support.checkExpression($2);
                  $$ = new NewlineNode(getPosition($1), new SplatNode(getPosition($1), $2));
              }*/
    ;

paren_args    : LPAREN2 none RPAREN /*{
                  $$ = new ArrayNode(support.union($1, $3));
              }*/
              | LPAREN2 call_args opt_nl RPAREN /*{
                  $$ = $2;
                  $<Node>$.setPosition(support.union($1, $4));
              }*/
              | LPAREN2 block_call opt_nl RPAREN /*{
                  warnings.warn(getPosition($1), "parenthesize argument(s) for future version");
                  $$ = new ArrayNode(getPosition($1), $2);
              }*/
              | LPAREN2 args ',' block_call opt_nl RPAREN /*{
                  warnings.warn(getPosition($1), "parenthesize argument(s) for future version");
                  $$ = $2.add($4);
              }*/
    ;

opt_paren_args: none | paren_args 
    ;

// Node:call_args - Arguments for a function call
call_args     : command /*{
                  warnings.warn($1.getPosition(), "parenthesize argument(s) for future version");
                  $$ = new ArrayNode(getPosition($1), $1);
              }*/
              | args opt_block_arg /*{
                  $$ = support.arg_blk_pass($1, $2);
              }*/
              | args ',' STAR arg_value opt_block_arg /*{
                  $$ = support.arg_concat(getPosition($1), $1, $4);
                  $$ = support.arg_blk_pass($<Node>$, $5);
              }*/
              | assocs opt_block_arg /*{
                  $$ = new ArrayNode(getPosition($1), new HashNode(getPosition(null), $1));
                  $$ = support.arg_blk_pass((Node)$$, $2);
              }*/
              | assocs ',' STAR arg_value opt_block_arg /*{
                  $$ = support.arg_concat(getPosition($1), new ArrayNode(getPosition($1), new HashNode(getPosition(null), $1)), $4);
                  $$ = support.arg_blk_pass((Node)$$, $5);
              }*/
              | args ',' assocs opt_block_arg /*{
                  $$ = $1.add(new HashNode(getPosition(null), $3));
                  $$ = support.arg_blk_pass((Node)$$, $4);
              }*/
              | args ',' assocs ',' STAR arg opt_block_arg /*{
                  support.checkExpression($6);
                  $$ = support.arg_concat(getPosition($1), $1.add(new HashNode(getPosition(null), $3)), $6);
                  $$ = support.arg_blk_pass((Node)$$, $7);
              }*/
              | STAR arg_value opt_block_arg /*{
                  $$ = support.arg_blk_pass(new SplatNode(getPosition($1), $2), $3);
              }*/
              | block_arg /*{}*/
    ;

call_args2    : arg_value ',' args opt_block_arg /*{
                  $$ = support.arg_blk_pass(new ArrayNode(getPosition($1), $1).addAll($3), $4);
              }*/
              | arg_value ',' block_arg /*{
                  $$ = support.arg_blk_pass(new ArrayNode(getPosition($1), $1), $3);
              }*/
              | arg_value ',' STAR arg_value opt_block_arg /*{
                  $$ = support.arg_concat(getPosition($1), new ArrayNode(getPosition($1), $1), $4);
                  $$ = support.arg_blk_pass((Node)$$, $5);
              }*/
              | arg_value ',' args ',' STAR arg_value opt_block_arg /*{
                  $$ = support.arg_concat(getPosition($1), new ArrayNode(getPosition($1), $1).addAll(new HashNode(getPosition(null), $3)), $6);
                  $$ = support.arg_blk_pass((Node)$$, $7);
              }*/
              | assocs opt_block_arg /*{
                  $$ = new ArrayNode(getPosition($1), new HashNode(getPosition(null), $1));
                  $$ = support.arg_blk_pass((Node)$$, $2);
              }*/
              | assocs ',' STAR arg_value opt_block_arg /*{
                  $$ = support.arg_concat(getPosition($1), new ArrayNode(getPosition($1), new HashNode(getPosition(null), $1)), $4);
                  $$ = support.arg_blk_pass((Node)$$, $5);
              }*/
              | arg_value ',' assocs opt_block_arg /*{
                  $$ = new ArrayNode(getPosition($1), $1).add(new HashNode(getPosition(null), $3));
                  $$ = support.arg_blk_pass((Node)$$, $4);
              }*/
              | arg_value ',' args ',' assocs opt_block_arg /*{
                  $$ = new ArrayNode(getPosition($1), $1).addAll($3).add(new HashNode(getPosition(null), $5));
                  $$ = support.arg_blk_pass((Node)$$, $6);
              }*/
              | arg_value ',' assocs ',' STAR arg_value opt_block_arg /*{
                  $$ = support.arg_concat(getPosition($1), new ArrayNode(getPosition($1), $1).add(new HashNode(getPosition(null), $3)), $6);
                  $$ = support.arg_blk_pass((Node)$$, $7);
              }*/
              | arg_value ',' args ',' assocs ',' STAR arg_value opt_block_arg /*{
                  $$ = support.arg_concat(getPosition($1), new ArrayNode(getPosition($1), $1).addAll($3).add(new HashNode(getPosition(null), $5)), $8);
                  $$ = support.arg_blk_pass((Node)$$, $9);
              }*/
              | STAR arg_value opt_block_arg /*{
                  $$ = support.arg_blk_pass(new SplatNode(getPosition($1), $2), $3);
              }*/
              | block_arg /*{}*/
    ;

command_args  : /* none */ /*{ 
                  $$ = new Long(lexer.getCmdArgumentState().begin());
              }*/ open_args /*{
                  lexer.getCmdArgumentState().reset($<Long>1.longValue());
                  $$ = $2;
              }*/
    ;

 open_args    : call_args
              | LPAREN_ARG  /*{                    
                  lexer.setState(LexState.EXPR_ENDARG);
              }*/ RPAREN /*{
                  warnings.warn(getPosition($1), "don't put space before argument parentheses");
                  $$ = null;
              }*/
              | LPAREN_ARG call_args2 /*{
                  lexer.setState(LexState.EXPR_ENDARG);
              }*/ RPAREN /*{
                  warnings.warn(getPosition($1), "don't put space before argument parentheses");
                  $$ = $2;
              }*/
    ;

block_arg     : AMPER arg_value /*{
                  support.checkExpression($2);
                  $$ = new BlockPassNode(support.union($1, $2), $2);
              }*/
    ;

opt_block_arg : ',' block_arg /*{
                  $$ = $2;
              }*/
              | none_block_pass
    ;

args          : arg_value /*{
                  $$ = new ArrayNode(getPosition2($1), $1);
              }*/
              | args ',' arg_value /*{
                  $$ = $1.add($3);
              }*/
    ;

mrhs          : args ',' arg_value /*{
                  $$ = $1.add($3);
              }*/
              | args ',' STAR arg_value /*{
                  $$ = support.arg_concat(getPosition($1), $1, $4);
              }*/
              | STAR arg_value /*{  
                  $$ = new SplatNode(getPosition($1), $2);
              }*/
    ;

primary       : literal
              | strings
              | xstring 
              | regexp
              | words
              | qwords
              | var_ref
              | backref
              | FID /*{
                  $$ = new FCallNode($1.getPosition(), (String) $1.getValue(), null);
              }*/
              | BEGIN bodystmt END /*{
                  $$ = new BeginNode(support.union($1, $3), $2);
              }*/
              | LPAREN_ARG expr /*{ 
                  lexer.setState(LexState.EXPR_ENDARG); 
              }*/ opt_nl RPAREN /*{
                  warnings.warning(getPosition($1), "(...) interpreted as grouped expression");
                  $$ = $2;
              }*/
              | LPAREN compstmt RPAREN /*{
                  $$ = $2;
              }*/
              | primary_value COLON2 CONSTANT /*{
                  $$ = new Colon2Node(support.union($1, $3), $1, (String) $3.getValue());
              }*/
              | COLON3 CONSTANT /*{
                  $$ = new Colon3Node(support.union($1, $2), (String) $2.getValue());
              }*/
              | primary_value '[' aref_args RBRACK /*{
                  if ($1 instanceof SelfNode) {
                      $$ = new FCallNode(getPosition($1), "[]", $3);
                  } else {
                      $$ = new CallNode(getPosition($1), $1, "[]", $3);
                  }
              }*/
              | LBRACK aref_args RBRACK /*{
                  ISourcePosition position = support.union($1, $3);
                  if ($2 == null) {
                      $$ = new ZArrayNode(position); // zero length array
                  } else {
                      $$ = $2;
                      $<ISourcePositionHolder>$.setPosition(position);
                  }
              }*/
              | LBRACE assoc_list RCURLY /*{
                  $$ = new HashNode(support.union($1, $3), $2);
              }*/
              | RETURN /*{
                  $$ = new ReturnNode($1.getPosition(), null);
              }*/
              | YIELD LPAREN2 call_args RPAREN /*{
                  $$ = support.new_yield(support.union($1, $4), $3);
              }*/
              | YIELD LPAREN2 RPAREN /*{
                  $$ = new YieldNode(support.union($1, $3), null, false);
              }*/
              | YIELD /*{
                  $$ = new YieldNode($1.getPosition(), null, false);
              }*/
              | DEFINED opt_nl LPAREN2 expr RPAREN /*{
                  $$ = new DefinedNode(getPosition($1), $4);
              }*/
              | operation brace_block /*{
                  $$ = new FCallNode(support.union($1, $2), (String) $1.getValue(), null, $2);
              }*/
              | method_call
              | method_call brace_block /*{
                  if ($1 != null && 
                      $<BlockAcceptingNode>1.getIterNode() instanceof BlockPassNode) {
                      throw new SyntaxException(getPosition($1), "Both block arg and actual block given.");
                  }
                  $<BlockAcceptingNode>1.setIterNode($2);
                  $<Node>1.setPosition(support.union($1, $2));
              }*/
              | IF expr_value then compstmt if_tail END /*{
                  $$ = new IfNode(support.union($1, $6), support.getConditionNode($2), $4, $5);
              }*/
              | UNLESS expr_value then compstmt opt_else END /*{
                  $$ = new IfNode(support.union($1, $6), support.getConditionNode($2), $5, $4);
              }*/
              | WHILE /*{ 
                  lexer.getConditionState().begin();
              }*/ expr_value do /*{
                  lexer.getConditionState().end();
              }*/ compstmt END /*{
                  $$ = new WhileNode(support.union($1, $7), support.getConditionNode($3), $6);
              }*/
              | UNTIL /*{
                  lexer.getConditionState().begin();
              }*/ expr_value do /*{
                  lexer.getConditionState().end();
              }*/ compstmt END /*{
                  $$ = new UntilNode(getPosition($1), support.getConditionNode($3), $6);
              }*/
              | CASE expr_value opt_terms case_body END /*{
                  $$ = new CaseNode(support.union($1, $5), $2, $4);
              }*/
              | CASE opt_terms case_body END /*{
                  $$ = new CaseNode(support.union($1, $4), null, $3);
              }*/
              | CASE opt_terms ELSE compstmt END /*{
                  $$ = $4;
              }*/
              | FOR block_var IN /*{
                  lexer.getConditionState().begin();
              }*/ expr_value do /*{
                  lexer.getConditionState().end();
              }*/ compstmt END /*{
                  $$ = new ForNode(support.union($1, $9), $2, $8, $5);
              }*/
              | CLASS cpath superclass /*{
                  if (support.isInDef() || support.isInSingle()) {
                      yyerror("class definition in method body");
                  }
                  support.pushLocalScope();
              }*/ bodystmt END /*{
                  $$ = new ClassNode(support.union($1, $6), $<Colon3Node>2, support.getCurrentScope(), $5, $3);
                  support.popCurrentScope();
              }*/
              | CLASS LSHFT expr /*{
                  $$ = new Boolean(support.isInDef());
                  support.setInDef(false);
              }*/ term /*{
                  $$ = new Integer(support.getInSingle());
                  support.setInSingle(0);
                  support.pushLocalScope();
              }*/ bodystmt END /*{
                  $$ = new SClassNode(support.union($1, $8), $3, support.getCurrentScope(), $7);
                  support.popCurrentScope();
                  support.setInDef($<Boolean>4.booleanValue());
                  support.setInSingle($<Integer>6.intValue());
              }*/
              | MODULE cpath /*{
                  if (support.isInDef() || support.isInSingle()) { 
                      yyerror("module definition in method body");
                  }
                  support.pushLocalScope();
              }*/ bodystmt END /*{
                  $$ = new ModuleNode(support.union($1, $5), $<Colon3Node>2, support.getCurrentScope(), $4);
                  support.popCurrentScope();
              }*/
              | DEF fname /*{
                  support.setInDef(true);
                  support.pushLocalScope();
              }*/ f_arglist bodystmt END /*{
                    // NOEX_PRIVATE for toplevel
                  $$ = new DefnNode(support.union($1, $6), new ArgumentNode($2.getPosition(), (String) $2.getValue()), $<ArgsNode>4, support.getCurrentScope(), $5, Visibility.PRIVATE);
                  support.popCurrentScope();
                  support.setInDef(false);
              }*/
              | DEF singleton dot_or_colon /*{
                  lexer.setState(LexState.EXPR_FNAME);
              }*/ fname /*{
                  support.setInSingle(support.getInSingle() + 1);
                  support.pushLocalScope();
                  lexer.setState(LexState.EXPR_END); // force for args
              }*/ f_arglist bodystmt END /*{
                  $$ = new DefsNode(support.union($1, $9), $2, new ArgumentNode($5.getPosition(), (String) $5.getValue()), $<ArgsNode>7, support.getCurrentScope(), $8);
                  support.popCurrentScope();
                  support.setInSingle(support.getInSingle() - 1);
              }*/
              | BREAK /*{
                  $$ = new BreakNode($1.getPosition());
              }*/
              | NEXT /*{
                  $$ = new NextNode($1.getPosition());
              }*/
              | REDO /*{
                  $$ = new RedoNode($1.getPosition());
              }*/
              | RETRY /*{
                  $$ = new RetryNode($1.getPosition());
              }*/
    ;

primary_value : primary /*{
                  support.checkExpression($1);
                  $$ = $1;
              }*/
    ;
 
then          : term
              | ':'
              | THEN
              | term THEN
    ;

do            : term
              | ':'
              | DO_COND
    ;

if_tail       : opt_else 
              | ELSIF expr_value then compstmt if_tail /*{
                  //mirko: support.union($<ISourcePositionHolder>1.getPosition(), getPosition($<ISourcePositionHolder>1)) ?
                  $$ = new IfNode(getPosition($1), support.getConditionNode($2), $4, $5);
              }*/
    ;

opt_else      : none 
              | ELSE compstmt /*{
                  $$ = $2;
              }*/
    ;

block_var     : lhs
              | mlhs /*{}*/
    ;

opt_block_var : none
              | PIPE /* none */ PIPE /*{
                  $$ = new ZeroArgNode(support.union($1, $2));
              }*/
              | OROP /*{
                  $$ = new ZeroArgNode($1.getPosition());
              }*/
              | PIPE block_var PIPE /*{
                  $$ = $2;

                  // Include pipes on multiple arg type
                  if ($2 instanceof MultipleAsgnNode) {
                      $2.setPosition(support.union($1, $3));
                  } 
              }*/
    ;

do_block      : DO_BLOCK /*{
                  support.pushBlockScope();
              }*/ opt_block_var compstmt END /*{
                  $$ = new IterNode(support.union($1, $5), $3, support.getCurrentScope(), $4);
                  support.popCurrentScope();
              }*/
    ;

block_call    : command do_block /*{
                  if ($1 != null && 
                      $<BlockAcceptingNode>1.getIterNode() instanceof BlockPassNode) {
                      throw new SyntaxException(getPosition($1), "Both block arg and actual block given.");
                  }
                  $<BlockAcceptingNode>1.setIterNode($2);
                  $<Node>1.setPosition(support.union($1, $2));
              }*/
              | block_call DOT operation2 opt_paren_args /*{
                  $$ = support.new_call($1, $3, $4, null);
              }*/
              | block_call COLON2 operation2 opt_paren_args /*{
                  $$ = support.new_call($1, $3, $4, null);
              }*/
    ;

method_call   : operation paren_args /*{
                  $$ = support.new_fcall($1, $2, null);
              }*/
              | primary_value DOT operation2 opt_paren_args /*{
                  $$ = support.new_call($1, $3, $4, null);
              }*/
              | primary_value COLON2 operation2 paren_args /*{
                  $$ = support.new_call($1, $3, $4, null);
              }*/
              | primary_value COLON2 operation3 /*{
                  $$ = support.new_call($1, $3, null, null);
              }*/
              | SUPER paren_args /*{
                  $$ = support.new_super($2, $1);
              }*/
              | SUPER /*{
                  $$ = new ZSuperNode($1.getPosition());
              }*/
    ;

// IterNode:brace_block - block invocation argument (foo >{...}< | foo >do end<) [!null]
brace_block   : LCURLY /*{
                  support.pushBlockScope();
              }*/ opt_block_var compstmt RCURLY /*{
                  $$ = new IterNode(support.union($1, $5), $3, support.getCurrentScope(), $4);
                  support.popCurrentScope();
              }*/
              | DO /*{
                  support.pushBlockScope();
              }*/ opt_block_var compstmt END /*{
                  $$ = new IterNode(support.union($1, $5), $3, support.getCurrentScope(), $4);
                  $<ISourcePositionHolder>0.setPosition(support.union($<ISourcePositionHolder>0, $<ISourcePositionHolder>$));
                  support.popCurrentScope();
              }*/
    ;

case_body     : WHEN when_args then compstmt cases /*{
                  $$ = new WhenNode(support.union($1, support.unwrapNewlineNode($4)), $2, $4, $5);
              }*/
    ;

when_args     : args
              | args ',' STAR arg_value /*{
                  $$ = $1.add(new WhenNode(getPosition($1), $4, null, null));
              }*/
              | STAR arg_value /*{
                  $$ = new ArrayNode(getPosition($1), new WhenNode(getPosition($1), $2, null, null));
              }*/
    ;

cases         : opt_else | case_body
    ;

opt_rescue    : RESCUE exc_list exc_var then compstmt opt_rescue /*{
                  Node node;
                  if ($3 != null) {
                     node = support.appendToBlock(support.node_assign($3, new GlobalVarNode(getPosition($1), "$!")), $5);
                     if($5 != null) {
                        node.setPosition(support.unwrapNewlineNode($5).getPosition());
                     }
                  } else {
                     node = $5;
                  }
                  $$ = new RescueBodyNode(getPosition($1, true), $2, node, $6);
              }*/
              | /*{$$ = null;}*/
    ;

exc_list      : arg_value /*{
                  $$ = new ArrayNode($1.getPosition(), $1);
              }*/
              | mrhs
              | none
    ;

exc_var       : ASSOC lhs /*{
                  $$ = $2;
              }*/
              | none
    ;

opt_ensure    : ENSURE compstmt /*{
                  if ($2 != null) {
                      $$ = $2;
                  } else {
                      $$ = new NilNode(getPosition(null));
                  }
              }*/
              | none
    ;

literal       : numeric
              | symbol /*{
                  $$ = new SymbolNode($1.getPosition(), (String) $1.getValue());
              }*/
              | dsym
    ;

strings       : string /*{
                  if ($1 instanceof EvStrNode) {
                      $$ = new DStrNode(getPosition($1)).add($1);
                  } else {
                      $$ = $1;
                  }
              }*/ 
    ;

string        : string1
              | string string1 /*{
                  $$ = support.literal_concat(getPosition($1), $1, $2);
              }*/
    ;

string1       : STRING_BEG string_contents STRING_END /*{
                  $$ = $2;
                  $<ISourcePositionHolder>$.setPosition(support.union($1, $3));
                  int extraLength = ((String) $1.getValue()).length() - 1;

                  // We may need to subtract addition offset off of first 
                  // string fragment (we optimistically take one off in
                  // ParserSupport.literal_concat).  Check token length
                  // and subtract as neeeded.
                  if (($2 instanceof DStrNode) && extraLength > 0) {
                     Node strNode = ((DStrNode)$2).get(0);
                     assert strNode != null;
                     strNode.getPosition().adjustStartOffset(-extraLength);
                  }
              }*/
    ;

xstring       : XSTRING_BEG xstring_contents STRING_END /*{
                  ISourcePosition position = support.union($1, $3);

                  if ($2 == null) {
                      $$ = new XStrNode(position, null);
                  } else if ($2 instanceof StrNode) {
                      $$ = new XStrNode(position, (ByteList) $<StrNode>2.getValue().clone());
                  } else if ($2 instanceof DStrNode) {
                      $$ = new DXStrNode(position, $<DStrNode>2);

                      $<Node>$.setPosition(position);
                  } else {
                      $$ = new DXStrNode(position).add($2);
                  }
              }*/
    ;

regexp        : REGEXP_BEG xstring_contents REGEXP_END /*{
                  int options = $3.getOptions();
                  Node node = $2;

                  if (node == null) {
                      $$ = new RegexpNode(getPosition($1), ByteList.create(""), options & ~ReOptions.RE_OPTION_ONCE);
                  } else if (node instanceof StrNode) {
                      $$ = new RegexpNode($2.getPosition(), (ByteList) ((StrNode) node).getValue().clone(), options & ~ReOptions.RE_OPTION_ONCE);
                  } else if (node instanceof DStrNode) {
                      $$ = new DRegexpNode(getPosition($1), (DStrNode) node, options, (options & ReOptions.RE_OPTION_ONCE) != 0);
                  } else {
                      $$ = new DRegexpNode(getPosition($1), options, (options & ReOptions.RE_OPTION_ONCE) != 0).add(node);
                  }
               }*/
    ;

words          : WORDS_BEG ' ' STRING_END /*{
                   $$ = new ZArrayNode(support.union($1, $3));
               }*/
               | WORDS_BEG word_list STRING_END /*{
                   $$ = $2;
                   $<ISourcePositionHolder>$.setPosition(support.union($1, $3));
               }*/
    ;

word_list      : /* none */ /*{
                   $$ = new ArrayNode(getPosition(null));
               }*/
               | word_list word ' ' /*{
                   $$ = $1.add($2 instanceof EvStrNode ? new DStrNode(getPosition($1)).add($2) : $2);
               }*/
    ;

word           : string_content
               | word string_content /*{
                   $$ = support.literal_concat(getPosition($1), $1, $2);
               }*/
    ;

qwords         : QWORDS_BEG ' ' STRING_END /*{
                   $$ = new ZArrayNode(support.union($1, $3));
               }*/
               | QWORDS_BEG qword_list STRING_END /*{
                   $$ = $2;
                   $<ISourcePositionHolder>$.setPosition(support.union($1, $3));
               }*/
    ;

qword_list     : /* none */ /*{
                   $$ = new ArrayNode(getPosition(null));
               }*/
               | qword_list STRING_CONTENT ' ' /*{
                   $$ = $1.add($2);
               }*/
    ;

string_contents: /* none */ /*{
                   $$ = new StrNode($<Token>0.getPosition(), ByteList.create(""));
               }*/
               | string_contents string_content /*{
                   $$ = support.literal_concat(getPosition($1), $1, $2);
               }*/
    ;

xstring_contents: /* none */ /*{
                   $$ = null;
               }*/
               | xstring_contents string_content /*{
                   $$ = support.literal_concat(getPosition($1), $1, $2);
               }*/
    ;

string_content : STRING_CONTENT /*{
                   $$ = $1;
               }*/
               | STRING_DVAR /*{
                   $$ = lexer.getStrTerm();
                   lexer.setStrTerm(null);
                   lexer.setState(LexState.EXPR_BEG);
               }*/ string_dvar /*{
                   lexer.setStrTerm($<StrTerm>2);
                   $$ = new EvStrNode(support.union($1, $3), $3);
               }*/
               | STRING_DBEG /*{
                   $$ = lexer.getStrTerm();
                   lexer.setStrTerm(null);
                   lexer.setState(LexState.EXPR_BEG);
               }*/ compstmt RCURLY /*{
                   lexer.setStrTerm($<StrTerm>2);

                   $$ = support.newEvStrNode(support.union($1, $4), $3);
               }*/
    ;

string_dvar    : GVAR /*{
                   $$ = new GlobalVarNode($1.getPosition(), (String) $1.getValue());
               }*/
               | IVAR /*{
                   $$ = new InstVarNode($1.getPosition(), (String) $1.getValue());
               }*/
               | CVAR /*{
                   $$ = new ClassVarNode($1.getPosition(), (String) $1.getValue());
               }*/
               | backref
    ;

symbol         : SYMBEG sym /*{
                   lexer.setState(LexState.EXPR_END);
                   $$ = $2;
                   $<ISourcePositionHolder>$.setPosition(support.union($1, $2));
               }*/
    ;

sym            : fname | IVAR | GVAR | CVAR
    ;

dsym           : SYMBEG xstring_contents STRING_END /*{
                   lexer.setState(LexState.EXPR_END);

                   // DStrNode: :"some text #{some expression}"
                   // StrNode: :"some text"
                   // EvStrNode :"#{some expression}"
                   DStrNode node;

                   if ($2 == null) {
                       yyerror("empty symbol literal");
                   }

                   if ($2 instanceof DStrNode) {
                       $$ = new DSymbolNode(support.union($1, $3), $<DStrNode>2);
                   } else {
                       ISourcePosition position = support.union($2, $3);

                       // We substract one since tsymbeg is longer than one
                       // and we cannot union it directly so we assume quote
                       // is one character long and subtract for it.
                       position.adjustStartOffset(-1);
                       $2.setPosition(position);
                       
                       $$ = new DSymbolNode(support.union($1, $3));
                       $<DSymbolNode>$.add($2);
                   }
               }*/
    ;

// Node:numeric - numeric value [!null]
numeric        : INTEGER | FLOAT /*{
                   $$ = $1;
               }*/
               | UMINUS_NUM INTEGER          /*%prec LOWEST*/ /*{
                   $$ = support.negateInteger($2);
               }*/
               | UMINUS_NUM FLOAT            /*%prec LOWEST*/ /*{
                   $$ = support.negateFloat($2);
               }*/
    ;

// Token:variable - name (special and normal onces)
variable       : IDENTIFIER | IVAR | GVAR | CONSTANT | CVAR
               | NIL /*{ 
                   $$ = new Token("nil", $1.getPosition());
               }*/
               | SELF /*{
                   $$ = new Token("self", $1.getPosition());
               }*/
               | TRUE /*{ 
                   $$ = new Token("true", $1.getPosition());
               }*/
               | FALSE /*{
                   $$ = new Token("false", $1.getPosition());
               }*/
               | U_FILE_U /*{
                   $$ = new Token("__FILE__", $1.getPosition());
               }*/
               | U_LINE_U /*{
                   $$ = new Token("__LINE__", $1.getPosition());
               }*/
    ;

var_ref        : variable /*{
                   $$ = support.gettable((String) $1.getValue(), $1.getPosition());
               }*/
    ;

var_lhs        : variable /*{
                   $$ = support.assignable($1, null);
               }*/
    ;

backref        : NTH_REF | BACK_REF
    ;

superclass     : term /*{
                   $$ = null;
               }*/
               | LT /*{
                   lexer.setState(LexState.EXPR_BEG);
               }*/ expr_value term /*{
                   $$ = $3;
               }*/
               /*| error term {
                   yyerrok();
                   $$ = null;
               }*/
    ;

// f_arglist: Function Argument list for definitions
f_arglist      : LPAREN2 f_args opt_nl RPAREN /*{
                   $$ = $2;
                   $<ISourcePositionHolder>$.setPosition(support.union($1, $4));
                   lexer.setState(LexState.EXPR_BEG);
               }*/
               | f_args term /*{
                   $$ = $1;
               }*/
    ;

f_args         : f_arg ',' f_optarg ',' f_rest_arg opt_f_block_arg /*{
                   $$ = new ArgsNode(support.union($1, $6), $1, $3, ((Integer) $5.getValue()).intValue(), $6);
               }*/
               | f_arg ',' f_optarg opt_f_block_arg /*{
                   $$ = new ArgsNode(getPosition($1), $1, $3, -1, $4);
               }*/
               | f_arg ',' f_rest_arg opt_f_block_arg /*{
                   $$ = new ArgsNode(support.union($1, $4), $1, null, ((Integer) $3.getValue()).intValue(), $4);
               }*/
               | f_arg opt_f_block_arg /*{
                   $$ = new ArgsNode($<ISourcePositionHolder>1.getPosition(), $1, null, -1, $2);
               }*/
               | f_optarg ',' f_rest_arg opt_f_block_arg /*{
                   $$ = new ArgsNode(getPosition($1), null, $1, ((Integer) $3.getValue()).intValue(), $4);
               }*/
               | f_optarg opt_f_block_arg /*{
                   $$ = new ArgsNode(getPosition($1), null, $1, -1, $2);
               }*/
               | f_rest_arg opt_f_block_arg /*{
                   $$ = new ArgsNode(getPosition($1), null, null, ((Integer) $1.getValue()).intValue(), $2);
               }*/
               | f_block_arg /*{
                   $$ = new ArgsNode(getPosition($1), null, null, -1, $1);
               }*/
               | /* none */ /*{
                   $$ = new ArgsNode(support.createEmptyArgsNodePosition(getPosition(null)), null, null, -1, null);
               }*/
    ;

f_norm_arg     : CONSTANT /*{
                   yyerror("formal argument cannot be a constant");
               }*/
               | IVAR /*{
                   yyerror("formal argument cannot be an instance variable");
               }*/
               | CVAR /*{
                   yyerror("formal argument cannot be a class variable");
               }*/
               | IDENTIFIER /*{
                   String identifier = (String) $1.getValue();
                   if (IdUtil.getVarType(identifier) != IdUtil.LOCAL_VAR) {
                       yyerror("formal argument must be local variable");
                   } else if (support.getCurrentScope().getLocalScope().isDefined(identifier) >= 0) {
                       yyerror("duplicate argument name");
                   }

                   support.getCurrentScope().getLocalScope().addVariable(identifier);
                   $$ = $1;
               }*/
    ;

f_arg          : f_norm_arg /*{
                    $$ = new ListNode($<ISourcePositionHolder>1.getPosition());
                    ((ListNode) $$).add(new ArgumentNode($<ISourcePositionHolder>1.getPosition(), (String) $1.getValue()));
               }*/
               | f_arg ',' f_norm_arg /*{
                   $1.add(new ArgumentNode($<ISourcePositionHolder>3.getPosition(), (String) $3.getValue()));
                   $1.setPosition(support.union($1, $3));
                   $$ = $1;
               }*/
    ;

f_opt          : IDENTIFIER '=' arg_value /*{
                   String identifier = (String) $1.getValue();

                   if (IdUtil.getVarType(identifier) != IdUtil.LOCAL_VAR) {
                       yyerror("formal argument must be local variable");
                   } else if (support.getCurrentScope().getLocalScope().isDefined(identifier) >= 0) {
                       yyerror("duplicate optional argument name");
                   }
                   support.getCurrentScope().getLocalScope().addVariable(identifier);
                   $$ = support.assignable($1, $3);
              }*/
    ;

f_optarg      : f_opt /*{
                  $$ = new BlockNode(getPosition($1)).add($1);
              }*/
              | f_optarg ',' f_opt /*{
                  $$ = support.appendToBlock($1, $3);
              }*/
    ;

restarg_mark  : STAR2 | STAR
    ;

f_rest_arg    : restarg_mark IDENTIFIER /*{
                  String identifier = (String) $2.getValue();

                  if (IdUtil.getVarType(identifier) != IdUtil.LOCAL_VAR) {
                      yyerror("rest argument must be local variable");
                   } else if (support.getCurrentScope().getLocalScope().isDefined(identifier) >= 0) {
                      yyerror("duplicate rest argument name");
                  }
                  $1.setValue(new Integer(support.getCurrentScope().getLocalScope().addVariable(identifier)));
                  $$ = $1;
              }*/
              | restarg_mark /*{
                  $1.setValue(new Integer(-2));
                  $$ = $1;
              }*/
    ;

blkarg_mark   : AMPER2 | AMPER
    ;

f_block_arg   : blkarg_mark IDENTIFIER /*{
                  String identifier = (String) $2.getValue();

                  if (IdUtil.getVarType(identifier) != IdUtil.LOCAL_VAR) {
                      yyerror("block argument must be local variable");
                  } else if (support.getCurrentScope().getLocalScope().isDefined(identifier) >= 0) {
                      yyerror("duplicate block argument name");
                  }
                  $$ = new BlockArgNode(support.union($1, $2), support.getCurrentScope().getLocalScope().addVariable(identifier), identifier);
              }*/
    ;

opt_f_block_arg: ',' f_block_arg /*{
                  $$ = $2;
              }*/
              | /* none */ /*{
                  $$ = null;
              }*/
    ;

singleton     : var_ref /*{
                  if (!($1 instanceof SelfNode)) {
                      support.checkExpression($1);
                  }
                  $$ = $1;
              }*/
              | LPAREN2 /*{
                  lexer.setState(LexState.EXPR_BEG);
              }*/ expr opt_nl RPAREN /*{
                  if ($3 instanceof ILiteralNode) {
                      yyerror("Can't define single method for literals.");
                  }
                  support.checkExpression($3);
                  $$ = $3;
              }*/
    ;

// ListNode:assoc_list - list of hash values pairs, like assocs but also
//   will accept ordinary list-style (e.g. a,b,c,d or a=>b,c=>d) [?null]
assoc_list    : none /*{ // [!null]
                  $$ = new ArrayNode(getPosition(null));
              }*/
              | assocs trailer /*{ // [!null]
                  $$ = $1;
              }*/
              | args trailer /*{
                  if ($1.size() % 2 != 0) {
                      yyerror("Odd number list for Hash.");
                  }
                  $$ = $1;
              }*/
    ;

// ListNode:assocs - list of hash value pairs (e.g. a => b, c => d) [!null]
assocs        : assoc // [!null]
              | assocs ',' assoc /*{ // [!null]
                  $$ = $1.addAll($3);
              }*/
    ;

// ListNode:assoc - A single hash value pair (e.g. a => b) [!null]
assoc         : arg_value ASSOC arg_value /*{ // [!null]
                  $$ = new ArrayNode(support.union($1, $3), $1).add($3);
              }*/
    ;

operation     : IDENTIFIER | CONSTANT | FID
    ;

operation2    : IDENTIFIER | CONSTANT | FID | op
    ;

operation3    : IDENTIFIER | FID | op
    ;

dot_or_colon  : DOT | COLON2
    ;

opt_terms     : /* none */ | terms
    ;

opt_nl        : /* none */ | '\n'
    ;

trailer       : /* none */ | '\n' | ','
    ;

term          : ';' /*{
                  yyerrok();
              }*/
              | '\n'
    ;

terms         : term
              | terms ';' /*{
                  yyerrok();
              }*/
    ;

none          : /* none */ /*{
                  $$ = null;
              }*/
    ;

none_block_pass: /* none */ /*{  
                  $$ = null;
              }*/
    ;