opal 0.3.2 → 0.3.6

data/lib/opal/ruby/ruby_parser.y

@@ -1,1298 +0,0 @@
-class Opal::RubyParser
-
-token CLASS MODULE DEF UNDEF BEGIN RESCUE ENSURE END IF UNLESS
-      THEN ELSIF ELSE CASE WHEN WHILE UNTIL FOR BREAK NEXT
-      REDO RETRY IN DO DO_COND DO_BLOCK RETURN YIELD SUPER
-      SELF NIL TRUE FALSE AND OR NOT IF_MOD UNLESS_MOD WHILE_MOD
-      UNTIL_MOD RESCUE_MOD ALIAS DEFINED klBEGIN klEND LINE
-      FILE IDENTIFIER FID GVAR IVAR CONSTANT CVAR NTH_REF
-      BACK_REF STRING_CONTENT INTEGER FLOAT REGEXP_END '+@'
-      '-@' '-@NUM' '**' '<=>' '==' '===' '!=' '>=' '<=' '&&'
-      '||' '=~' '!~' '.' '..' '...' '[]' '[]=' '<<' '>>'
-      '::' '::@' OP_ASGN '=>' PAREN_BEG '(' ')' tLPAREN_ARG
-      ARRAY_BEG ']' tLBRACE tLBRACE_ARG SPLAT '*' '&@' '&'
-      '~' '%' '/' '+' '-' '<' '>' '|' '!' '^'
-      '{@' '}' BACK_REF2 SYMBOL_BEG STRING_BEG XSTRING_BEG REGEXP_BEG
-      WORDS_BEG tAWORDS_BEG STRING_DBEG STRING_DVAR STRING_END STRING
-      SYMBOL '\\n' '?' ':' ',' SPACE ';' BLOCK_GIVEN
-
-prechigh
-  right    '!' '~' '+@'
-  right    '**'
-  right    '-@NUM' '-@'
-  left     '*' '/' '%'
-  left     '+' '-'
-  left     '<<' '>>'
-  left     '&'
-  left     '|' '^'
-  left     '>' '>=' '<' '<='
-  nonassoc '<=>' '==' '===' '!=' '=~' '!~'
-  left     '&&'
-  left     '||'
-  nonassoc '..' '...'
-  right    '?' ':'
-  left     RESCUE_MOD
-  right    '=' OP_ASGN
-  nonassoc DEFINED
-  right    NOT
-  left     OR AND
-  nonassoc IF_MOD UNLESS_MOD WHILE_MOD UNTIL_MOD
-  nonassoc tLBRACE_ARG
-  nonassoc LOWEST
-preclow
-
-rule
-
-target:
-    compstmt
-    {
-      result = val[0]
-    }
-
-bodystmt:
-    compstmt opt_rescue opt_else opt_ensure
-    {
-      result = BodyStatementsNode.new val[0], val[1], val[2], val[3]
-    }
-
-compstmt:
-    stmts opt_terms
-    {
-      result = val[0]
-    }
-
-stmts:
-    none
-    {
-      result = StatementsNode.new []
-    }
-  | stmt
-    {
-      result = StatementsNode.new [val[0]]
-    }
-  | stmts terms stmt
-    {
-      val[0] << val[2]
-      result = val[0]
-    }
-
-            stmt: ALIAS fitem fitem
-                | ALIAS GVAR GVAR
-                | ALIAS GVAR BACK_REF
-                | ALIAS GVAR NTH_REF
-                | UNDEF undef_list
-  | stmt IF_MOD expr_value
-    {
-      result = IfModNode.new val[1], val[2], val[0]
-    }
-  | stmt UNLESS_MOD expr_value
-    {
-      result = IfModNode.new val[1], val[2], val[0]
-    }
-                | stmt WHILE_MOD expr_value
-                | stmt UNTIL_MOD expr_value
-                | stmt RESCUE_MOD stmt
-                | klBEGIN '{@' compstmt '}'
-                | klEND '{@' compstmt '}'
-                | lhs '=' command_call
-                    {
-                      result = AssignNode.new val[0], val[2], val[1]
-                    }
-                | mlhs '=' command_call
-                | var_lhs OP_ASGN command_call
-                    {
-                      result = OpAsgnNode.new val[1], val[0], val[2]
-                    }
-                | primary_value '[@' aref_args ']' OP_ASGN command_call
-                | primary_value '.' IDENTIFIER OP_ASGN command_call
-                | primary_value '.' CONSTANT OP_ASGN command_call
-                | primary_value '::' IDENTIFIER OP_ASGN command_call
-                | backref OP_ASGN command_call
-                | lhs '=' mrhs
-                | mlhs '=' arg_value
-                | mlhs '=' mrhs
-                | expr
-
-            expr: command_call
-                | expr AND expr
-                    {
-                      result = "result = [val[1], val[0], val[2]];"
-                    }
-                | expr OR expr
-                    {
-                      result = "result = [val[1], val[0], val[2]];"
-                    }
-                | NOT expr
-                    {
-                      result = "result = ['unary', '!', val[1]];"
-                    }
-                | '!' command_call
-                    {
-                      result = "result = ['unary', '!', val[1]];"
-                    }
-                | arg
-
-      expr_value: expr
-
-    command_call: command
-                | block_command
-                | RETURN call_args
-                    {
-                      result = ReturnNode.new val[0], val[1]
-                    }
-                | BREAK call_args
-                    {
-                      result = "result = ['break', val[1]];"
-                    }
-                | NEXT call_args
-                    {
-                      result = "result = ['next', val[1]];"
-                    }
-                    
-   block_command: block_call
-                | block_call '.' operation2 command_args
-                | block_call '::' operation2 command_args
-
- cmd_brace_block: tLBRACE_ARG opt_block_var compstmt '}'
-
-command:
-    operation command_args =LOWEST
-    {
-      result = CallNode.new nil, val[0], val[1]
-    }
-                | operation command_args cmd_brace_block
-  | primary_value '.' operation2 command_args =LOWEST
-    {
-      result = CallNode.new val[0], val[2], val[3]
-    }
-                | primary_value '.' operation2 command_args cmd_brace_block
-                | primary_value '::' operation2 command_args =LOWEST
-                    {
-                      result = "result = ['call', val[0], val[2], val[3]];"
-                    }
-                | primary_value '::' operation2 command_args cmd_brace_block
-                | SUPER command_args
-                    {
-                      result = "result = ['super', val[1]];"
-                    }
-  | YIELD command_args
-    {
-      result = YieldNode.new val[0], val[1]
-    }
-
-            mlhs: mlhs_basic
-                | PAREN_BEG mlhs_entry ')'
-
-      mlhs_entry: mlhs_basic
-                | PAREN_BEG mlhs_entry ')'
-
-      mlhs_basic: mlhs_head
-                | mlhs_head mlhs_item
-                | mlhs_head SPLAT mlhs_node
-                | mlhs_head SPLAT
-                | SPLAT mlhs_node
-                | SPLAT
-
-       mlhs_item: mlhs_node
-                | PAREN_BEG mlhs_entry ')'
-
-       mlhs_head: mlhs_item ','
-                | mlhs_head mlhs_item ','
-
-       mlhs_node: variable
-                | primary_value '[@' aref_args ']'
-                | primary_value '.' IDENTIFIER
-                | primary_value '::' IDENTIFIER
-                | primary_value '.' CONSTANT
-                | primary_value '::' CONSTANT
-                | '::@' CONSTANT
-                | backref
-
-lhs:
-    variable
-  | primary_value '[@' aref_args ']'
-    {
-                      # result = "result = ['aref', val[0], val[2]];"
-                      result = "result = new this.ArefNode(val[0], val[2]);"
-      result = ArefNode.new val[0], val[2]
-    }
-  | primary_value '.' IDENTIFIER
-    {
-      result = CallNode.new val[0], val[2], [[]]
-    }
-  | primary_value '::' IDENTIFIER
-  | primary_value '.' CONSTANT
-  | primary_value '::' CONSTANT
-  | '::@' CONSTANT
-  | backref
-
-cname:
-    CONSTANT
-
-cpath:
-    '::@' cname
-    {
-      result = "result = ['::', val[1]];"
-    }
-  | cname
-    {
-      result = [nil, val[0]]
-    }
-  | primary_value '::' cname
-    {
-      result = "result = [val[0], val[2]];"
-    }
-
-           fname: IDENTIFIER
-                | CONSTANT
-                | FID
-                | op
-                | reswords
-
-           fitem: fname
-                | symbol
-
-      undef_list: fitem
-                | undef_list ',' fitem
-
-              op: '|'    | '^'     | '&'    | '<=>'  | '=='    | '==='
-                | '=~'   | '>'     | '>='   | '<'    | '<='    | '<<'
-                | '>>'   | '+'     | '-'    | '*'    | SPLAT   | '/'
-                | '%'    | '**'    | '~'    | '+@'   | '-@'    | '[]'
-                | '[]='  | BACK_REF2
-
-        reswords: LINE     | FILE       | klBEGIN   | klEND    | 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
-                | BLOCK_GIVEN
-
-arg:
-    lhs '=' arg
-    {
-      result = AssignNode.new val[0], val[2], val[1]
-    }
-                | lhs '=' arg RESCUE_MOD arg
-                | var_lhs OP_ASGN arg
-                    {
-                      result = OpAsgnNode.new val[1], val[0], val[2]
-                    }
-                | primary_value '[@' aref_args ']' OP_ASGN arg
-                | primary_value '.' IDENTIFIER OP_ASGN arg
-                | primary_value '.' CONSTANT OP_ASGN arg
-                | primary_value '::' IDENTIFIER OP_ASGN arg
-                | primary_value '::' CONSTANT OP_ASGN arg
-                | '::@' CONSTANT OP_ASGN arg
-                | backref OP_ASGN arg
-                | arg '..' arg
-                    {
-                      result = "result = ['range', val[1], val[0], val[2]];"
-                    }
-                | arg '...' arg
-                    {
-                      result = "result = ['range', val[1], val[0], val[2]];"
-                    }
-  | arg '+' arg
-    {
-      result = CallNode.new val[0], val[1], [[val[2]]]
-    }
-  | arg '-' arg
-    {
-      result = CallNode.new val[0], val[1], [[val[2]]]
-    }
-  | arg '*' arg
-    {
-      result = CallNode.new val[0], val[1], [[val[2]]]
-    }
-  | arg '/' arg
-    {
-      result = CallNode.new val[0], val[1], [[val[2]]]
-    }
-  | arg '%' arg
-    {
-      result = CallNode.new val[0], val[1], [[val[2]]]
-    }
-  | arg '**' arg
-    {
-      result = CallNode.new val[0], val[1], [[val[2]]]
-    }
-                | '-@NUM' INTEGER '**' arg
-                | '-@NUM' FLOAT '**' arg
-  | '+@' arg
-    {
-      result = CallNode.new val[1], val[0], []
-    }
-  | '-@' arg
-    {
-      result = CallNode.new val[1], val[0], []
-    }
-  | arg '|' arg
-    {
-      result = CallNode.new val[0], val[1], [[val[2]]]
-    }
-  | arg '^' arg
-    {
-      result = CallNode.new val[0], val[1], [[val[2]]]
-    }
-  | arg '&' arg
-    {
-      result = CallNode.new val[0], val[1], [[val[2]]]
-    }
-  | arg '<=>' arg
-    {
-      result = CallNode.new val[0], val[1], [[val[2]]]
-    }
-  | arg '>' arg
-    {
-      result = CallNode.new val[0], val[1], [[val[2]]]
-    }
-  | arg '>=' arg
-    {
-      result = CallNode.new val[0], val[1], [[val[2]]]
-    }
-  | arg '<' arg
-    {
-      result = CallNode.new val[0], val[1], [[val[2]]]
-    }
-  | arg '<=' arg
-    {
-      result = CallNode.new val[0], val[1], [[val[2]]]
-    }
-  | arg '==' arg
-    {
-      result = CallNode.new val[0], val[1], [[val[2]]]
-    }
-  | arg '===' arg
-    {
-      result = CallNode.new val[0], val[1], [[val[2]]]
-    }
-  | arg '!=' arg  
-    {
-      result = CallNode.new val[0], val[1], [[val[2]]]
-    }
-  | arg '=~' arg
-    {
-      result = CallNode.new val[0], val[1], [[val[2]]]
-    }
-  | arg '!~' arg
-    {
-      result = CallNode.new val[0], val[1], [[val[2]]]
-    }
-  | '!' arg
-    {
-      result = CallNode.new val[1], val[0], []
-    }
-  | '~' arg
-    {
-      result = CallNode.new val[1], val[0], []
-    }
-  | arg '<<' arg
-    {
-      result = CallNode.new val[0], val[1], [[val[2]]]
-    }
-  | arg '>>' arg
-    {
-      result = CallNode.new val[0], val[1], [[val[2]]]
-    }
-  | arg '&&' arg
-    {
-      result = AndNode.new val[1], val[0], val[2]
-    }
-  | arg '||' arg
-    {
-      result = OrNode.new val[1], val[0], val[2]
-    }
-                | DEFINED opt_nl arg
-                | arg '?' arg ':' arg
-                    {
-                      result = "result = ['ternary', val[0], val[2], val[4]];"
-                    }
-                | primary
-
-       arg_value: arg
-
-aref_args:
-    none
-    {
-      result = [[], nil]
-    }
-  | command opt_nl
-  | args trailer
-    {
-      result = [val[0], nil]
-    }
-  | args ',' SPLAT arg opt_nl
-    {
-      result = [val[0], val[3]]
-    }
-  | assocs trailer
-  | SPLAT arg opt_nl
-    {
-      result = [[], val[1]]
-    }
-
-paren_args:
-    '(' none ')'
-    {
-      result = [[]]
-    }
-  | '(' call_args opt_nl ')'
-    {
-      result = val[1]
-    }
-                | '(' block_call opt_nl ')'
-                | '(' args ',' block_call opt_nl ')'
-
-  opt_paren_args: none
-                    {
-                      result = []
-                    }
-                | paren_args
-
-call_args:
-    command
-    {
-      result = [[val[0]], nil, nil, nil]
-    }
-  | args opt_block_arg
-    {
-      result = [val[0], nil, nil, val[1]]
-    }
-  | args ',' SPLAT arg_value opt_block_arg
-    {
-      result = [val[0], val[3], nil, val[4]]
-    }
-  | assocs opt_block_arg
-    {
-      result = [nil, nil, val[0], val[1]]
-    }
-  | assocs ',' SPLAT arg_value opt_block_arg
-    {
-      result = [nil, val[3], val[0], val[4]]
-    }
-  | args ',' assocs opt_block_arg
-    {
-      result = [val[0], nil, val[2], val[3]]
-    }
-  | args ',' assocs ',' SPLAT arg opt_block_arg
-    {
-      result = [val[0], val[5], val[2], val[6]]
-    }
-  | SPLAT arg_value opt_block_arg
-    {
-      result = [nil, val[1], nil, val[2]]
-    }
-  | block_arg
-    {
-      result = [nil, nil, nil, val[0]]
-    }
-
-      call_args2: arg_value ',' args opt_block_arg
-                | arg_value ',' block_arg
-                | arg_value ',' SPLAT arg_value opt_block_arg
-                | arg_value ',' args ',' SPLAT arg_value opt_block_arg
-                | assocs opt_block_arg
-                | assocs ',' SPLAT arg_value opt_block_arg
-                | arg_value ',' assocs opt_block_arg
-                | arg_value ',' args ',' assocs opt_block_arg
-                | arg_value ',' assocs ',' SPLAT arg_value opt_block_arg
-                | arg_value ',' args ',' assocs ',' SPLAT arg_value opt_block_arg
-                | SPLAT arg_value opt_block_arg
-                | block_arg
-
-command_args: 
-    {
-      cmdarg_push 1
-    }
-    open_args
-    {
-      cmdarg_pop
-      result = val[1]
-    }
-
-open_args:
-    call_args
-  | tLPAREN_ARG ')'
-    {
-      result = [[]]
-    }
-  | tLPAREN_ARG call_args2 ')'
-    {
-      result = val[1]
-    }
-
-block_arg:
-    '&@' arg_value
-    {
-      result = val[1]
-    }
-
-opt_block_arg:
-    ',' block_arg
-    {
-      result = val[1]
-    }
-  | none_block_pass
-    {
-      result = nil
-    }
-
-            args: arg_value
-                    {
-                      result = [val[0]]
-                    }
-                | args ',' arg_value
-                    {
-                      result = val[0] << val[2]
-                    }
-
-            mrhs: args ',' arg_value
-                | args ',' SPLAT arg_value
-                | SPLAT arg_value
-
-         primary: literal
-                | strings
-                | xstring
-                | regexp
-                | words
-                | awords
-                | var_ref
-                | backref
-                | FID
-  | BEGIN bodystmt END
-    {
-      result = BeginNode.new val[0], val[1], val[2]
-    }
-  | tLPAREN_ARG expr opt_nl ')'
-  | PAREN_BEG compstmt ')'
-    {
-      result = ParenNode.new val[0], val[1], val[2]
-    }
-  | primary_value '::' CONSTANT
-    {
-      result = Colon2Node.new val[0], val[2]
-    }
-  | '::@' CONSTANT
-    {
-      result = Colon3Node.new val[1]
-    }
-  | primary_value '[@' aref_args ']'
-    {
-      result = CallNode.new val[0], { :line => val[0].line, :value => '[]' }, val[2]
-    }
-  | '[' aref_args ']'
-    {
-      result = ArrayNode.new val[1], val[0], val[2]
-    }
-  | '{' assoc_list '}'
-    {
-      result = HashNode.new val[1], val[0], val[2]
-    }
-  | RETURN
-    {
-      result = ReturnNode.new val[0], [nil]
-    }
-  | YIELD '(' call_args ')'
-    {
-      result = "result = new this.YieldNode(val[0], val[2]);"
-    }
-                | YIELD '(' ')'
-                    {
-                      result = "result = new this.YieldNode(val[0], [[]]);"
-                    }
-                | YIELD
-                    {
-                      result = YieldNode.new val[0], []
-                    }
-                | DEFINED opt_nl '(' expr ')'
-  | operation brace_block
-    {
-      result = CallNode.new nil, val[0], [[]]
-      result.block = val[1]
-    }
-                | method_call
-                | method_call brace_block
-                    {
-                      result = val[0];
-                      result.block = val[1]
-                    }
-  | IF expr_value then compstmt if_tail END
-    {
-      result = IfNode.new val[0], val[1], val[3], val[4], val[5]
-    }
-                | UNLESS expr_value then compstmt opt_else END
-                    {
-                      result = "result = ['unless', val[1], val[3], val[4]];"
-                    }
-                | WHILE
-                    {
-                      result = "this.cond_push(1);"
-                    }
-                  expr_value do
-                    {
-                      result = "this.cond_pop();"
-                    }
-                  compstmt END
-                    {
-                      result = "result = ['while', val[0], val[2], val[5]];"
-                    }
-                | UNTIL
-                    {
-                      result = "this.cond_push(1);"
-                    }
-                  expr_value do
-                    {
-                      result = "this.cond_pop();"
-                    }
-                  compstmt END
-                    {
-                      result = "result = ['while', val[0], val[2], val[5]];"
-                    }
-                | CASE expr_value opt_terms case_body END
-                    {
-                      result = "result = ['case', val[1], val[3]];"
-                    }
-                | CASE opt_terms case_body END
-                    {
-                      result = "result = ['case', null, val[2]];"
-                    }
-                | CASE opt_terms ELSE compstmt END
-                | FOR block_var IN
-                    {
-                      result = "this.cond_push(1);"
-                    }
-                  expr_value do
-                    {
-                      result = "this.cond_pop();"
-                    }
-                  compstmt END
-  | CLASS cpath superclass bodystmt END
-    {
-      result = ClassNode.new val[0], val[1], val[2], val[3], val[4]
-    }
-  | CLASS '<<' expr term bodystmt END
-    {
-      result = "result = ['class_shift', val[2], val[4]];"
-    }
-  | MODULE cpath bodystmt END
-    {
-      result = ModuleNode.new val[0], val[1], val[2], val[3]
-    }
-  | DEF fname f_arglist bodystmt END
-    {
-      result = DefNode.new val[0], nil, val[1], val[2], val[3], val[4]
-    }
-  | DEF singleton dot_or_colon fname f_arglist bodystmt END
-    {
-      result = DefNode.new val[0], val[1], val[3], val[4], val[5], val[6]
-    }
-                | BREAK
-                    {
-                      result = "result = ['break', null];"
-                    }
-                | NEXT
-                    {
-                      result = "result = ['next', null];"
-                    }
-                | REDO
-                | RETRY
-
-   primary_value: primary
-
-            then: term
-                | ':'
-                | THEN
-                | term THEN
-
-              do: term
-                | ':'
-                | DO_COND
-
-if_tail:
-    opt_else
-    {
-      result = val[0]
-    }
-  | ELSIF expr_value then compstmt if_tail
-    {
-      result = [[val[0], val[1], val[3]]].concat val[4]
-    }
-
-opt_else:
-    none
-    {
-      result = []
-    }
-  | ELSE compstmt
-    {
-      result = [[val[0], val[1]]]
-    }
-
-block_var:
-    block_var_args
-    {
-      result = [val[0], nil]
-    }
-
-block_var_args:
-    f_arg ',' f_block_optarg ',' f_rest_arg opt_f_block_arg
-    {
-      result = [val[0], val[2], val[4], val[5]]
-    }
-  | f_arg ',' f_block_optarg opt_f_block_arg
-    {
-      result = [val[0], val[2], nil, val[3]]
-    }
-  | f_arg ',' f_rest_arg opt_f_block_arg
-    {
-      result = [val[0], nil, val[2], val[3]]
-    }
-  | f_arg opt_f_block_arg
-    {
-      result = [val[0], nil, nil, val[1]]
-    }
-  | f_block_optarg ',' f_rest_arg opt_f_block_arg
-    {
-      result = [nil, val[0], val[2], val[3]]
-    }
-  | f_block_optarg opt_f_block_arg
-    {
-      result = [nil, val[0], nil, val[1]]
-    }
-  | f_rest_arg opt_f_block_arg
-    {
-      result = [nil, nil, val[0], val[1]]
-    }
-  | f_block_arg
-    {
-      result = [nil, nil, nil, val[0]]
-    }
-
-f_block_optarg:
-    f_block_opt
-    {
-      result = [val[0]]
-    }
-  | f_block_optarg ',' f_block_opt
-    {
-      val[0] << val[2]
-      result = val[0]
-    }
-
-f_block_opt:
-    IDENTIFIER '=' primary_value
-    {
-      result = [val[0], val[2]]
-    }
-
-opt_block_var:
-    none
-    {
-      result = [nil]
-    }
-  | '|' '|'
-    {
-      result = [nil]
-    }
-  | '||'
-    {
-      result = [nil]
-    }
-  | '|' block_var '|'
-    {
-      result = val[1]
-    }
-
-        do_block: DO_BLOCK
-                    {
-                      # result = "print('doing half command');"
-                    }
-                  opt_block_var compstmt END
-                    {
-                      result = BlockNode.new val[0], val[2], val[3], val[4]
-                    }
-
-      block_call: command do_block
-                    {
-                      result = val[0]
-                      val[0].block = val[1]
-                    }
-                | block_call '.' operation2 opt_paren_args
-                | block_call '::' operation2 opt_paren_args
-
-method_call:
-    operation paren_args
-    {
-      result = CallNode.new nil, val[0], val[1]
-    }
-  | primary_value '.' operation2 opt_paren_args
-    {
-      result = CallNode.new val[0], val[2], val[3]
-    }
-                | primary_value '::' operation2 paren_args
-                | primary_value '::' operation3
-                | SUPER paren_args
-                    {
-                      result = "result = ['super', val[1]];"
-                    }
-                | SUPER
-                    {
-                      result = "result = ['super', [[]]];"
-                    }
-
-brace_block:
-    '{@' opt_block_var compstmt '}'
-    {
-      result = BlockNode.new val[0], val[1], val[2], val[3]
-    }
-  | DO opt_block_var compstmt END
-    {
-      result = BlockNode.new val[0], val[1], val[2], val[3]
-    }
-
-       case_body: WHEN when_args then compstmt cases
-                    {
-                      result = 
-                        "result = [['when', val[1], val[3]]].concat(val[4]);"
-                    }
-                    
-       when_args: args
-                    {
-                      result = "result = val[0];"
-                    }
-                | args ',' SPLAT arg_value
-                    {
-                      result = "result = val[0];"
-                    }
-                | SPLAT arg_value
-                    {
-                      result = "result = [];"
-                    }
-
-           cases: opt_else 
-                | case_body
-
-opt_rescue:
-    RESCUE exc_list exc_var then compstmt opt_rescue
-    {
-      result = [[val[0], val[1], val[2], val[4]]]
-      result.concat val[5]
-    }
-  |
-    {
-      result = []
-    }
-
-        exc_list: arg_value
-                | mrhs
-                | none
-
-         exc_var: '=>' lhs
-                    {
-                      result = val[1]
-                    }
-                | none
-                    {
-                      result = nil
-                    }
-
-      opt_ensure: ENSURE compstmt
-                | none
-
-         literal: numeric
-                | symbol
-                | dsym
-
-         strings: string
-
-          string: string1
-                | string string1
-
-         string1: STRING_BEG string_contents STRING_END
-                    {
-                      result = StringNode.new val[1], val[2]
-                    }
-                | STRING
-
-xstring:
-    XSTRING_BEG xstring_contents STRING_END
-    {
-      result = XStringNode.new val[0], val[1], val[2]
-    }
-
-          regexp: REGEXP_BEG xstring_contents REGEXP_END
-                    {
-                      result = "result = ['regexp', val[1], val[2]];"
-                    }
-
-           words: WORDS_BEG SPACE STRING_END
-                | WORDS_BEG word_list STRING_END
-
-       word_list: none
-                | word_list word SPACE
-            word: string_content
-                | word string_content
-
-          awords: tAWORDS_BEG SPACE STRING_END
-                | tAWORDS_BEG qword_list STRING_END
-
-      qword_list: none
-                | qword_list STRING_CONTENT SPACE
-
- string_contents: none
-                    {
-                      result = []
-                    }
-                | string_contents string_content
-                    {
-                      result = val[0] << val[1]
-                    }
-                    
-xstring_contents: none
-                    {
-                      result = []
-                    }
-                | xstring_contents string_content
-                    {
-                      result = val[0].concat [val[1]]
-                    }
-                    
-  string_content: STRING_CONTENT
-                    {
-                      result = ['string_content', val[0]]
-                    }
-                | STRING_DVAR string_dvar
-                    {
-                      result = ['string_dvar', val[1]]
-                    }
-                | STRING_DBEG 
-                    {
-                      cond_push 0
-                      cmdarg_push 0
-                    }
-                compstmt '}'
-                    {
-                      cond_lexpop
-                      cmdarg_lexpop
-                      result = ['string_dbegin', val[2]]
-                    }
-
-     string_dvar: GVAR
-                | IVAR
-                | CVAR
-                | backref
-
-
-symbol:
-    SYMBOL_BEG sym
-    {
-      result = SymbolNode.new val[1]
-    }
-  | SYMBOL
-
-sym: fname
-  | IVAR
-  | GVAR
-  | CVAR
-
-dsym:
-    SYMBOL_BEG xstring_contents STRING_END
-    {
-      result = "result = ['dsym', val[1]];"
-    }
-
-numeric:
-    INTEGER
-    {
-      result = NumericNode.new val[0]
-    }
-  | FLOAT
-    {
-      result = NumericNode.new val[0]
-    }
-                | '-@NUM' INTEGER =LOWEST
-                | '-@NUM' FLOAT   =LOWEST
-
-variable:
-    IDENTIFIER
-    {
-      result = IdentifierNode.new val[0]
-    }
-  | IVAR
-    {
-      result = IvarNode.new val[0]
-    }
-  | GVAR
-    {
-      result = GvarNode.new val[0];
-    }
-  | CONSTANT
-    {
-      result = ConstantNode.new val[0]
-    }
-  | CVAR
-    {
-                      result = "result = ['cvar', val[0]];"
-    }
-  | NIL
-    {
-      result = NilNode.new val[0]
-    }
-  | SELF
-    {
-      result = SelfNode.new val[0]
-    }
-  | TRUE
-    {
-      result = TrueNode.new val[0]
-    }
-  | FALSE
-    {
-      result = FalseNode.new val[0]
-    }
-  | FILE
-    {
-      result = FileNode.new val[0]
-    }
-  | LINE
-    {
-      result = LineNode.new val[0]
-    }
-  | BLOCK_GIVEN
-    {
-      result = BlockGivenNode.new val[0]
-    }
-
-         var_ref: variable
-
-         var_lhs: variable
-
-         backref: NTH_REF
-                | BACK_REF
-
-superclass:
-    term
-    {
-      result = nil
-    }
-  | '<' expr_value term
-    {
-      result = val[1]
-    }
-  | error term
-    {
-      result = nil
-    }
-
-f_arglist:
-    '(' f_args opt_nl ')'
-    {
-      result = val[1]
-    }
-  | f_args term
-    {
-      result = val[0]
-    }
-
-f_args:
-    f_arg ',' f_optarg ',' f_rest_arg opt_f_block_arg
-    {
-      result = [val[0], val[2], val[4], val[5]]
-    }
-  | f_arg ',' f_optarg opt_f_block_arg
-    {
-      result = [val[0], val[2], nil, val[3]]
-    }
-  | f_arg ',' f_rest_arg opt_f_block_arg
-    {
-      result = [val[0], nil, val[2], val[3]]
-    }
-  | f_arg opt_f_block_arg
-    {
-      result = [val[0], nil, nil, val[1]]
-    }
-  | f_optarg ',' f_rest_arg opt_f_block_arg
-    {
-      rsult = [nil, val[0], val[2], val[3]]
-    }
-  | f_optarg opt_f_block_arg
-    {
-      result = [nil, val[0], nil, val[1]]
-    }
-  | f_rest_arg opt_f_block_arg
-    {
-      result = [nil, nil, val[0], val[1]]
-    }
-  | f_block_arg
-    {
-      result = [nil, nil, nil, val[0]]
-    }
-  |
-    {
-      result = [nil, nil, nil, nil]
-    }
-
-f_norm_arg:
-    CONSTANT
-    {
-                      result = "this.yyerror(
-                       'formal argument cannot be a constant');"
-    }
-  | IVAR
-    {
-                      result = "this.yyerror(
-                       'formal argument cannot be an instance variable');"
-    }
-  | CVAR
-    {
-                      result = "this.yyerror(
-                       'formal argument cannot be a class variable');"
-    }
-  | GVAR
-    {
-                      result = "this.yyerror(
-                        'formal argument cannot be a global variable');"
-    }
-  | IDENTIFIER
-
-f_arg:
-    f_norm_arg
-    {
-      result = [val[0]]
-    }
-  | f_arg ',' f_norm_arg
-    {
-      val[0] << val[2]
-      result = val[0]
-    }
-
-f_opt:
-    IDENTIFIER '=' arg_value
-    {
-      result = [val[0], val[2]]
-    }
-
-f_optarg:
-    f_opt
-    {
-      result = [val[0]]
-    }
-  | f_optarg ',' f_opt
-    {
-      result = val[0]
-      val[0] << val[2]
-    }
-
-restarg_mark:
-    '*'
-  | SPLAT
-
-f_rest_arg:
-    restarg_mark IDENTIFIER
-    {
-      result = val[1]
-    }
-  | restarg_mark
-    {
-      result = val[0]
-    }
-
-blkarg_mark:
-    '&'
-  | '&@'
-
-f_block_arg:
-    blkarg_mark IDENTIFIER
-    {
-      result = val[1]
-    }
-
-opt_f_block_arg:
-    ',' f_block_arg
-    {
-      result = val[1]
-    }
-  |
-    {
-      result = nil
-    }
-
-       singleton: var_ref
-                    {
-                      result = val[0]
-                    }
-                | '(' expr opt_nl ')'
-                    {
-                      result = val[1]
-                    }
-
-      assoc_list: none
-                    {
-                      result = []
-                    }
-                | assocs trailer
-                    {
-                      result = val[0]
-                    }
-                | args trailer
-                    {
-                      result = "this.yyerror('unsupported assoc list type');"
-                    }
-
-          assocs: assoc
-                    {
-                      result = [val[0]]
-                    }
-                | assocs ',' assoc
-                    {
-                      result = val[0] << val[2]
-                    }
-
-           assoc: arg_value '=>' arg_value
-                    {
-                      result = [val[0], val[2]]
-                    }
-
-       operation: IDENTIFIER
-                | CONSTANT
-                | FID
-                
-      operation2: IDENTIFIER
-                | CONSTANT
-                | FID
-                | op
-                
-      operation3: IDENTIFIER
-                | FID 
-                | op
-                
-    dot_or_colon: '.'
-                | '::'
-                
-       opt_terms:
-                | terms
-                
-          opt_nl:
-                | '\\n'
-                
-         trailer:
-                | '\\n'
-                | ','
-
-            term: ';'
-                | '\\n'
-
-           terms: term
-                | terms ';'
-
-            none:
-
- none_block_pass:
-
-end
-
----- inner
-