racc 1.4.14-java → 1.4.15-java

data/test/assets/nokogiri-css.y

@@ -0,0 +1,255 @@
+class Nokogiri::CSS::Parser
+
+token FUNCTION INCLUDES DASHMATCH LBRACE HASH PLUS GREATER S STRING IDENT
+token COMMA NUMBER PREFIXMATCH SUFFIXMATCH SUBSTRINGMATCH TILDE NOT_EQUAL
+token SLASH DOUBLESLASH NOT EQUAL RPAREN LSQUARE RSQUARE HAS
+
+rule
+  selector
+    : selector COMMA simple_selector_1toN {
+        result = [val.first, val.last].flatten
+      }
+    | prefixless_combinator_selector { result = val.flatten }
+    | optional_S simple_selector_1toN { result = [val.last].flatten }
+    ;
+  combinator
+    : PLUS { result = :DIRECT_ADJACENT_SELECTOR }
+    | GREATER { result = :CHILD_SELECTOR }
+    | TILDE { result = :FOLLOWING_SELECTOR }
+    | DOUBLESLASH { result = :DESCENDANT_SELECTOR }
+    | SLASH { result = :CHILD_SELECTOR }
+    ;
+  simple_selector
+    : element_name hcap_0toN {
+        result =  if val[1].nil?
+                    val.first
+                  else
+                    Node.new(:CONDITIONAL_SELECTOR, [val.first, val[1]])
+                  end
+      }
+    | function
+    | function pseudo {
+        result = Node.new(:CONDITIONAL_SELECTOR, val)
+      }
+    | function attrib {
+        result = Node.new(:CONDITIONAL_SELECTOR, val)
+      }
+    | hcap_1toN {
+        result = Node.new(:CONDITIONAL_SELECTOR,
+          [Node.new(:ELEMENT_NAME, ['*']), val.first]
+        )
+      }
+    ;
+  prefixless_combinator_selector
+    : combinator simple_selector_1toN {
+        result = Node.new(val.first, [nil, val.last])
+      }
+    ;
+  simple_selector_1toN
+    : simple_selector combinator simple_selector_1toN {
+        result = Node.new(val[1], [val.first, val.last])
+      }
+    | simple_selector S simple_selector_1toN {
+        result = Node.new(:DESCENDANT_SELECTOR, [val.first, val.last])
+      }
+    | simple_selector
+    ;
+  class
+    : '.' IDENT { result = Node.new(:CLASS_CONDITION, [val[1]]) }
+    ;
+  element_name
+    : namespaced_ident
+    | '*' { result = Node.new(:ELEMENT_NAME, val) }
+    ;
+  namespaced_ident
+    : namespace '|' IDENT {
+        result = Node.new(:ELEMENT_NAME,
+          [[val.first, val.last].compact.join(':')]
+        )
+      }
+    | IDENT {
+        name = @namespaces.key?('xmlns') ? "xmlns:#{val.first}" : val.first
+        result = Node.new(:ELEMENT_NAME, [name])
+      }
+    ;
+  namespace
+    : IDENT { result = val[0] }
+    |
+    ;
+  attrib
+    : LSQUARE attrib_name attrib_val_0or1 RSQUARE {
+        result = Node.new(:ATTRIBUTE_CONDITION,
+          [val[1]] + (val[2] || [])
+        )
+      }
+    | LSQUARE function attrib_val_0or1 RSQUARE {
+        result = Node.new(:ATTRIBUTE_CONDITION,
+          [val[1]] + (val[2] || [])
+        )
+      }
+    | LSQUARE NUMBER RSQUARE {
+        # Non standard, but hpricot supports it.
+        result = Node.new(:PSEUDO_CLASS,
+          [Node.new(:FUNCTION, ['nth-child(', val[1]])]
+        )
+      }
+    ;
+  attrib_name
+    : namespace '|' IDENT {
+        result = Node.new(:ELEMENT_NAME,
+          [[val.first, val.last].compact.join(':')]
+        )
+      }
+    | IDENT {
+        # Default namespace is not applied to attributes.
+        # So we don't add prefix "xmlns:" as in namespaced_ident.
+        result = Node.new(:ELEMENT_NAME, [val.first])
+      }
+    ;
+  function
+    : FUNCTION RPAREN {
+        result = Node.new(:FUNCTION, [val.first.strip])
+      }
+    | FUNCTION expr RPAREN {
+        result = Node.new(:FUNCTION, [val.first.strip, val[1]].flatten)
+      }
+    | FUNCTION nth RPAREN {
+        result = Node.new(:FUNCTION, [val.first.strip, val[1]].flatten)
+      }
+    | NOT expr RPAREN {
+        result = Node.new(:FUNCTION, [val.first.strip, val[1]].flatten)
+      }
+    | HAS selector RPAREN {
+        result = Node.new(:FUNCTION, [val.first.strip, val[1]].flatten)
+      }
+    ;
+  expr
+    : NUMBER COMMA expr { result = [val.first, val.last] }
+    | STRING COMMA expr { result = [val.first, val.last] }
+    | IDENT COMMA expr { result = [val.first, val.last] }
+    | NUMBER
+    | STRING
+    | IDENT                             # even, odd
+      {
+        case val[0]
+        when 'even'
+          result = Node.new(:NTH, ['2','n','+','0'])
+        when 'odd'
+          result = Node.new(:NTH, ['2','n','+','1'])
+        when 'n'
+          result = Node.new(:NTH, ['1','n','+','0'])
+        else
+          # This is not CSS standard.  It allows us to support this:
+          # assert_xpath("//a[foo(., @href)]", @parser.parse('a:foo(@href)'))
+          # assert_xpath("//a[foo(., @a, b)]", @parser.parse('a:foo(@a, b)'))
+          # assert_xpath("//a[foo(., a, 10)]", @parser.parse('a:foo(a, 10)'))
+          result = val
+        end
+      }
+    ;
+  nth
+    : NUMBER IDENT PLUS NUMBER          # 5n+3 -5n+3
+      {
+        if val[1] == 'n'
+          result = Node.new(:NTH, val)
+        else
+          raise Racc::ParseError, "parse error on IDENT '#{val[1]}'"
+        end
+      }
+    | IDENT PLUS NUMBER {               # n+3, -n+3
+        if val[0] == 'n'
+          val.unshift("1")
+          result = Node.new(:NTH, val)
+        elsif val[0] == '-n'
+          val[0] = 'n'
+          val.unshift("-1")
+          result = Node.new(:NTH, val)
+        else
+          raise Racc::ParseError, "parse error on IDENT '#{val[1]}'"
+        end
+      }
+    | NUMBER IDENT {                    # 5n, -5n, 10n-1
+        n = val[1]
+        if n[0, 2] == 'n-'
+          val[1] = 'n'
+          val << "-"
+          # b is contained in n as n is the string "n-b"
+          val << n[2, n.size]
+          result = Node.new(:NTH, val)
+        elsif n == 'n'
+          val << "+"
+          val << "0"
+          result = Node.new(:NTH, val)
+        else
+          raise Racc::ParseError, "parse error on IDENT '#{val[1]}'"
+        end
+      }
+    ;
+  pseudo
+    : ':' function {
+        result = Node.new(:PSEUDO_CLASS, [val[1]])
+      }
+    | ':' IDENT { result = Node.new(:PSEUDO_CLASS, [val[1]]) }
+    ;
+  hcap_0toN
+    : hcap_1toN
+    |
+    ;
+  hcap_1toN
+    : attribute_id hcap_1toN {
+        result = Node.new(:COMBINATOR, val)
+      }
+    | class hcap_1toN {
+        result = Node.new(:COMBINATOR, val)
+      }
+    | attrib hcap_1toN {
+        result = Node.new(:COMBINATOR, val)
+      }
+    | pseudo hcap_1toN {
+        result = Node.new(:COMBINATOR, val)
+      }
+    | negation hcap_1toN {
+        result = Node.new(:COMBINATOR, val)
+      }
+    | attribute_id
+    | class
+    | attrib
+    | pseudo
+    | negation
+    ;
+  attribute_id
+    : HASH { result = Node.new(:ID, val) }
+    ;
+  attrib_val_0or1
+    : eql_incl_dash IDENT { result = [val.first, val[1]] }
+    | eql_incl_dash STRING { result = [val.first, val[1]] }
+    |
+    ;
+  eql_incl_dash
+    : EQUAL           { result = :equal }
+    | PREFIXMATCH     { result = :prefix_match }
+    | SUFFIXMATCH     { result = :suffix_match }
+    | SUBSTRINGMATCH  { result = :substring_match }
+    | NOT_EQUAL       { result = :not_equal }
+    | INCLUDES        { result = :includes }
+    | DASHMATCH       { result = :dash_match }
+    ;
+  negation
+    : NOT negation_arg RPAREN {
+        result = Node.new(:NOT, [val[1]])
+      }
+    ;
+  negation_arg
+    : element_name
+    | element_name hcap_1toN
+    | hcap_1toN
+    ;
+  optional_S
+    : S
+    |
+    ;
+end
+
+---- header
+
+require 'nokogiri/css/parser_extras'

data/test/assets/opal.y

@@ -0,0 +1,1807 @@
+# Copyright (C) 2013 by Adam Beynon
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+
+class Opal::Parser
+
+token kCLASS kMODULE kDEF kUNDEF kBEGIN kRESCUE kENSURE kEND kIF kUNLESS
+      kTHEN kELSIF kELSE kCASE kWHEN kWHILE kUNTIL kFOR kBREAK kNEXT
+      kREDO kRETRY kIN kDO kDO_COND kDO_BLOCK kDO_LAMBDA kRETURN kYIELD kSUPER
+      kSELF kNIL kTRUE kFALSE kAND kOR kNOT kIF_MOD kUNLESS_MOD kWHILE_MOD
+      kUNTIL_MOD kRESCUE_MOD kALIAS kDEFINED klBEGIN klEND k__LINE__
+      k__FILE__ k__ENCODING__ tIDENTIFIER tFID tGVAR tIVAR tCONSTANT
+      tLABEL tCVAR tNTH_REF tBACK_REF tSTRING_CONTENT tINTEGER tFLOAT
+      tREGEXP_END tUPLUS tUMINUS tUMINUS_NUM tPOW tCMP tEQ tEQQ tNEQ tGEQ tLEQ tANDOP
+      tOROP tMATCH tNMATCH tJSDOT tDOT tDOT2 tDOT3 tAREF tASET tLSHFT tRSHFT
+      tCOLON2 tCOLON3 tOP_ASGN tASSOC tLPAREN tLPAREN2 tRPAREN tLPAREN_ARG
+      ARRAY_BEG tRBRACK tLBRACE tLBRACE_ARG tSTAR tSTAR2 tAMPER tAMPER2
+      tTILDE tPERCENT tDIVIDE tPLUS tMINUS tLT tGT tPIPE tBANG tCARET
+      tLCURLY tRCURLY tBACK_REF2 tSYMBEG tSTRING_BEG tXSTRING_BEG tREGEXP_BEG
+      tWORDS_BEG tAWORDS_BEG tSTRING_DBEG tSTRING_DVAR tSTRING_END tSTRING
+      tSYMBOL tNL tEH tCOLON tCOMMA tSPACE tSEMI tLAMBDA tLAMBEG
+      tLBRACK2 tLBRACK tJSLBRACK tDSTAR
+
+prechigh
+  right    tBANG tTILDE tUPLUS
+  right    tPOW
+  right    tUMINUS_NUM tUMINUS
+  left     tSTAR2 tDIVIDE tPERCENT
+  left     tPLUS tMINUS
+  left     tLSHFT tRSHFT
+  left     tAMPER2
+  left     tPIPE tCARET
+  left     tGT tGEQ tLT tLEQ
+  nonassoc tCMP tEQ tEQQ tNEQ tMATCH tNMATCH
+  left     tANDOP
+  left     tOROP
+  nonassoc tDOT2 tDOT3
+  right    tEH tCOLON
+  left     kRESCUE_MOD
+  right    tEQL tOP_ASGN
+  nonassoc kDEFINED
+  right    kNOT
+  left     kOR kAND
+  nonassoc kIF_MOD kUNLESS_MOD kWHILE_MOD kUNTIL_MOD
+  nonassoc tLBRACE_ARG
+  nonassoc tLOWEST
+preclow
+
+rule
+
+         program: top_compstmt
+
+    top_compstmt: top_stmts opt_terms
+                    {
+                      result = new_compstmt val[0]
+                    }
+
+       top_stmts: # none
+                    {
+                      result = new_block
+                    }
+                | top_stmt
+                    {
+                      result = new_block val[0]
+                    }
+                | top_stmts terms top_stmt
+                    {
+                      val[0] << val[2]
+                      result = val[0]
+                    }
+
+        top_stmt: stmt
+                | klBEGIN tLCURLY top_compstmt tRCURLY
+                    {
+                      result = val[2]
+                    }
+
+        bodystmt: compstmt opt_rescue opt_else opt_ensure
+                    {
+                      result = new_body(val[0], val[1], val[2], val[3])
+                    }
+
+        compstmt: stmts opt_terms
+                    {
+                      result = new_compstmt val[0]
+                    }
+
+           stmts: # none
+                    {
+                      result = new_block
+                    }
+                | stmt
+                    {
+                      result = new_block val[0]
+                    }
+                | stmts terms stmt
+                    {
+                      val[0] << val[2]
+                      result = val[0]
+                    }
+
+            stmt: kALIAS fitem
+                    {
+                      lexer.lex_state = :expr_fname
+                    }
+                    fitem
+                    {
+                      result = new_alias(val[0], val[1], val[3])
+                    }
+                | kALIAS tGVAR tGVAR
+                    {
+                      result = s(:valias, value(val[1]).to_sym, value(val[2]).to_sym)
+                    }
+                | kALIAS tGVAR tBACK_REF
+                | kALIAS tGVAR tNTH_REF
+                    {
+                      result = s(:valias, value(val[1]).to_sym, value(val[2]).to_sym)
+                    }
+                | kUNDEF undef_list
+                    {
+                      result = val[1]
+                    }
+                | stmt kIF_MOD expr_value
+                    {
+                      result = new_if(val[1], val[2], val[0], nil)
+                    }
+                | stmt kUNLESS_MOD expr_value
+                    {
+                      result = new_if(val[1], val[2], nil, val[0])
+                    }
+                | stmt kWHILE_MOD expr_value
+                    {
+                      result = new_while(val[1], val[2], val[0])
+                    }
+                | stmt kUNTIL_MOD expr_value
+                    {
+                      result = new_until(val[1], val[2], val[0])
+                    }
+                | stmt kRESCUE_MOD stmt
+                    {
+                      result = new_rescue_mod(val[1], val[0], val[2])
+                    }
+                | klEND tLCURLY compstmt tRCURLY
+                | lhs tEQL command_call
+                    {
+                      result = new_assign(val[0], val[1], val[2])
+                    }
+                | mlhs tEQL command_call
+                    {
+                      result = s(:masgn, val[0], s(:to_ary, val[2]))
+                    }
+                | var_lhs tOP_ASGN command_call
+                    {
+                      result = new_op_asgn val[1], val[0], val[2]
+                    }
+                | primary_value tLBRACK2 aref_args tRBRACK tOP_ASGN command_call
+                | primary_value tJSLBRACK aref_args tRBRACK tOP_ASGN command_call
+                | primary_value tDOT tIDENTIFIER tOP_ASGN command_call
+                    {
+                      result = s(:op_asgn2, val[0], op_to_setter(val[2]), value(val[3]).to_sym, val[4])
+                    }
+                | primary_value tDOT tCONSTANT tOP_ASGN command_call
+                | primary_value tCOLON2 tIDENTIFIER tOP_ASGN command_call
+                | backref tOP_ASGN command_call
+                | lhs tEQL mrhs
+                    {
+                      result = new_assign val[0], val[1], s(:svalue, val[2])
+                    }
+                | mlhs tEQL arg_value
+                    {
+                      result = s(:masgn, val[0], s(:to_ary, val[2]))
+                    }
+                | mlhs tEQL mrhs
+                    {
+                      result = s(:masgn, val[0], val[2])
+                    }
+                | expr
+
+            expr: command_call
+                | expr kAND expr
+                    {
+                      result = s(:and, val[0], val[2])
+                    }
+                | expr kOR expr
+                    {
+                      result = s(:or, val[0], val[2])
+                    }
+                | kNOT expr
+                    {
+                      result = new_unary_call(['!', []], val[1])
+                    }
+                | tBANG command_call
+                    {
+                      result = new_unary_call(val[0], val[1])
+                    }
+                | arg
+
+      expr_value: expr
+
+    command_call: command
+                | block_command
+                | kRETURN call_args
+                    {
+                      result = new_return(val[0], val[1])
+                    }
+                | kBREAK call_args
+                    {
+                      result = new_break(val[0], val[1])
+                    }
+                | kNEXT call_args
+                    {
+                      result = new_next(val[0], val[1])
+                    }
+
+   block_command: block_call
+                | block_call tJSDOT operation2 command_args
+                | block_call tDOT operation2 command_args
+                | block_call tCOLON2 operation2 command_args
+
+ cmd_brace_block: tLBRACE_ARG opt_block_var compstmt tRCURLY
+
+         command: operation command_args =tLOWEST
+                    {
+                      result = new_call(nil, val[0], val[1])
+                    }
+                | operation command_args cmd_brace_block
+                | primary_value tJSDOT operation2 command_args =tLOWEST
+                    {
+                      result = new_js_call(val[0], val[2], val[3])
+                    }
+                | primary_value tJSDOT operation2 command_args cmd_brace_block
+                | primary_value tDOT operation2 command_args =tLOWEST
+                    {
+                      result = new_call(val[0], val[2], val[3])
+                    }
+                | primary_value tDOT operation2 command_args cmd_brace_block
+                | primary_value tCOLON2 operation2 command_args =tLOWEST
+                  {
+                    result = new_call(val[0], val[2], val[3])
+                  }
+                | primary_value tCOLON2 operation2 command_args cmd_brace_block
+                | kSUPER command_args
+                    {
+                      result = new_super(val[0], val[1])
+                    }
+                | kYIELD command_args
+                    {
+                      result = new_yield val[1]
+                    }
+
+            mlhs: mlhs_basic
+                    {
+                      result = val[0]
+                    }
+                | tLPAREN mlhs_entry tRPAREN
+                    {
+                      result = val[1]
+                    }
+
+      mlhs_entry: mlhs_basic
+                    {
+                      result = val[0]
+                    }
+                | tLPAREN mlhs_entry tRPAREN
+                    {
+                      result = val[1]
+                    }
+
+      mlhs_basic: mlhs_head
+                    {
+                      result = val[0]
+                    }
+                | mlhs_head mlhs_item
+                    {
+                      result = val[0] << val[1]
+                    }
+                | mlhs_head tSTAR mlhs_node
+                    {
+                      result = val[0] << s(:splat, val[2])
+                    }
+                | mlhs_head tSTAR mlhs_node tCOMMA mlhs_post
+                | mlhs_head tSTAR
+                    {
+                      result = val[0] << s(:splat)
+                    }
+                | mlhs_head tSTAR tCOMMA mlhs_post
+                | tSTAR mlhs_node
+                    {
+                      result = s(:array, s(:splat, val[1]))
+                    }
+                | tSTAR
+                    {
+                      result = s(:array, s(:splat))
+                    }
+                | tSTAR tCOMMA mlhs_post
+
+       mlhs_item: mlhs_node
+                    {
+                      result = val[0]
+                    }
+                | tLPAREN mlhs_entry tRPAREN
+                    {
+                      result = val[1]
+                    }
+
+       mlhs_head: mlhs_item tCOMMA
+                    {
+                      result = s(:array, val[0])
+                    }
+                | mlhs_head mlhs_item tCOMMA
+                    {
+                      result = val[0] << val[1]
+                    }
+
+       mlhs_post: mlhs_item
+                | mlhs_post tCOMMA mlhs_item
+
+       mlhs_node: variable
+                    {
+                      result = new_assignable val[0]
+                    }
+                | primary_value tLBRACK2 aref_args tRBRACK
+                    {
+                      args = val[2] ? val[2] : []
+                      result = s(:attrasgn, val[0], :[]=, s(:arglist, *args))
+                    }
+                | primary_value tDOT tIDENTIFIER
+                    {
+                      result = new_call val[0], val[2], []
+                    }
+                | primary_value tCOLON2 tIDENTIFIER
+                | primary_value tDOT tCONSTANT
+                | primary_value tCOLON2 tCONSTANT
+                | tCOLON3 tCONSTANT
+                | backref
+
+             lhs: variable
+                    {
+                      result = new_assignable val[0]
+                    }
+                | primary_value tJSLBRACK aref_args tRBRACK
+                    {
+                      result = new_js_attrasgn(val[0], val[2])
+                    }
+                | primary_value tLBRACK2 aref_args tRBRACK
+                    {
+                      result = new_attrasgn(val[0], :[]=, val[2])
+                    }
+                | primary_value tDOT tIDENTIFIER
+                    {
+                      result = new_attrasgn(val[0], op_to_setter(val[2]))
+                    }
+                | primary_value tCOLON2 tIDENTIFIER
+                    {
+                      result = new_attrasgn(val[0], op_to_setter(val[2]))
+                    }
+                | primary_value tDOT tCONSTANT
+                    {
+                      result = new_attrasgn(val[0], op_to_setter(val[2]))
+                    }
+                | primary_value tCOLON2 tCONSTANT
+                    {
+                      result = new_colon2(val[0], val[1], val[2])
+                    }
+                | tCOLON3 tCONSTANT
+                    {
+                      result = new_colon3(val[0], val[1])
+                    }
+                | backref
+
+           cname: tCONSTANT
+
+           cpath: tCOLON3 cname
+                    {
+                      result = new_colon3(val[0], val[1])
+                    }
+                | cname
+                    {
+                      result = new_const(val[0])
+                    }
+                | primary_value tCOLON2 cname
+                    {
+                      result = new_colon2(val[0], val[1], val[2])
+                    }
+
+           fname: tIDENTIFIER
+                | tCONSTANT
+                | tFID
+                | op
+                    {
+                      lexer.lex_state = :expr_end
+                      result = val[0]
+                    }
+                | reswords
+                    {
+                      lexer.lex_state = :expr_end
+                      result = val[0]
+                    }
+
+           fitem: fname
+                    {
+                      result = new_sym(val[0])
+                    }
+                | symbol
+
+      undef_list: fitem
+                    {
+                      result = s(:undef, val[0])
+                    }
+                | undef_list tCOMMA fitem
+                    {
+                      result = val[0] << val[2]
+                    }
+
+              op: tPIPE    | tCARET    | tAMPER2  | tCMP     | tEQ      | tEQQ
+                | tMATCH   | tNMATCH   | tGT      | tGEQ     | tLT      | tLEQ
+                | tNEQ     | tLSHFT    | tRSHFT   | tPLUS    | tMINUS   | tSTAR2
+                | tSTAR    | tDIVIDE   | tPERCENT | tPOW     | tBANG    | tTILDE
+                | tUPLUS   | tUMINUS   | tAREF    | tASET    | tBACK_REF2
+
+        reswords: k__LINE__ | k__FILE__   | klBEGIN    | klEND      | kALIAS  | kAND
+                | kBEGIN    | kBREAK      | kCASE      | kCLASS     | kDEF    | kDEFINED
+                | kDO       | kELSE       | kELSIF     | kEND       | kENSURE | kFALSE
+                | kFOR      | kIN         | kMODULE    | kNEXT      | kNIL    | kNOT
+                | kOR       | kREDO       | kRESCUE    | kRETRY     | kRETURN | kSELF
+                | kSUPER    | kTHEN       | kTRUE      | kUNDEF     | kWHEN   | kYIELD
+                | kIF_MOD   | kUNLESS_MOD | kWHILE_MOD | kUNTIL_MOD | kRESCUE_MOD
+                | kIF       | kWHILE      | kUNTIL     | kUNLESS
+
+             arg: lhs tEQL arg
+                    {
+                      result = new_assign(val[0], val[1], val[2])
+                    }
+                | lhs tEQL arg kRESCUE_MOD arg
+                    {
+                      result = new_assign val[0], val[1], s(:rescue_mod, val[2], val[4])
+                    }
+                | var_lhs tOP_ASGN arg
+                    {
+                      result = new_op_asgn val[1], val[0], val[2]
+                    }
+                | primary_value tLBRACK2 aref_args tRBRACK tOP_ASGN arg
+                    {
+                      result = new_op_asgn1(val[0], val[2], val[4], val[5])
+                    }
+                | primary_value tJSLBRACK aref_args tRBRACK tOP_ASGN arg
+                    {
+                      raise ".JS[...] #{val[4]} is not supported"
+                    }
+                | primary_value tDOT tIDENTIFIER tOP_ASGN arg
+                    {
+                      result = s(:op_asgn2, val[0], op_to_setter(val[2]), value(val[3]).to_sym, val[4])
+                    }
+                | primary_value tDOT tCONSTANT tOP_ASGN arg
+                | primary_value tCOLON2 tIDENTIFIER tOP_ASGN arg
+                | primary_value tCOLON2 tCONSTANT tOP_ASGN arg
+                | tCOLON3 tCONSTANT tOP_ASGN arg
+                | backref tOP_ASGN arg
+                | arg tDOT2 arg
+                    {
+                      result = new_irange(val[0], val[1], val[2])
+                    }
+                | arg tDOT3 arg
+                    {
+                      result = new_erange(val[0], val[1], val[2])
+                    }
+                | arg tPLUS arg
+                    {
+                      result = new_binary_call(val[0], val[1], val[2])
+                    }
+                | arg tMINUS arg
+                    {
+                      result = new_binary_call(val[0], val[1], val[2])
+                    }
+                | arg tSTAR2 arg
+                    {
+                      result = new_binary_call(val[0], val[1], val[2])
+                    }
+                | arg tDIVIDE arg
+                    {
+                      result = new_binary_call(val[0], val[1], val[2])
+                    }
+                | arg tPERCENT arg
+                    {
+                      result = new_binary_call(val[0], val[1], val[2])
+                    }
+                | arg tPOW arg
+                    {
+                      result = new_binary_call(val[0], val[1], val[2])
+                    }
+                | '-@NUM' tINTEGER tPOW arg
+                    {
+                      result = new_call new_binary_call(new_int(val[1]), val[2], val[3]), [:"-@", []], []
+                    }
+                | '-@NUM' tFLOAT tPOW arg
+                    {
+                      result = new_call new_binary_call(new_float(val[1]), val[2], val[3]), [:"-@", []], []
+                    }
+                | tUPLUS arg
+                    {
+                      result = new_call val[1], [:"+@", []], []
+                      if [:int, :float].include? val[1].type
+                        result = val[1]
+                      end
+                    }
+                | tUMINUS arg
+                    {
+                      result = new_call val[1], [:"-@", []], []
+                      if val[1].type == :int
+                        val[1][1] = -val[1][1]
+                        result = val[1]
+                      elsif val[1].type == :float
+                        val[1][1] = -val[1][1].to_f
+                        result = val[1]
+                      end
+                    }
+                | arg tPIPE arg
+                    {
+                      result = new_binary_call(val[0], val[1], val[2])
+                    }
+                | arg tCARET arg
+                    {
+                      result = new_binary_call(val[0], val[1], val[2])
+                    }
+                | arg tAMPER2 arg
+                    {
+                      result = new_binary_call(val[0], val[1], val[2])
+                    }
+                | arg tCMP arg
+                    {
+                      result = new_binary_call(val[0], val[1], val[2])
+                    }
+                | arg tGT arg
+                    {
+                      result = new_binary_call(val[0], val[1], val[2])
+                    }
+                | arg tGEQ arg
+                    {
+                      result = new_binary_call(val[0], val[1], val[2])
+                    }
+                | arg tLT arg
+                    {
+                      result = new_binary_call(val[0], val[1], val[2])
+                    }
+                | arg tLEQ arg
+                    {
+                      result = new_binary_call(val[0], val[1], val[2])
+                    }
+                | arg tEQ arg
+                    {
+                      result = new_binary_call(val[0], val[1], val[2])
+                    }
+                | arg tEQQ arg
+                    {
+                      result = new_binary_call(val[0], val[1], val[2])
+                    }
+                | arg tNEQ arg
+                    {
+                      result = new_binary_call(val[0], val[1], val[2])
+                    }
+                | arg tMATCH arg
+                    {
+                      result = new_binary_call(val[0], val[1], val[2])
+                    }
+                | arg tNMATCH arg
+                    {
+                      result = new_binary_call(val[0], val[1], val[2])
+                    }
+                | tBANG arg
+                    {
+                      result = new_unary_call(val[0], val[1])
+                    }
+                | tTILDE arg
+                    {
+                      result = new_unary_call(val[0], val[1])
+                    }
+                | arg tLSHFT arg
+                    {
+                      result = new_binary_call(val[0], val[1], val[2])
+                    }
+                | arg tRSHFT arg
+                    {
+                      result = new_binary_call(val[0], val[1], val[2])
+                    }
+                | arg tANDOP arg
+                    {
+                      result = new_and(val[0], val[1], val[2])
+                    }
+                | arg tOROP arg
+                    {
+                      result = new_or(val[0], val[1], val[2])
+                    }
+                | kDEFINED opt_nl arg
+                    {
+                      result = s(:defined, val[2])
+                    }
+                | arg tEH arg tCOLON arg
+                    {
+                      result = new_if(val[1], val[0], val[2], val[4])
+                    }
+                | primary
+
+       arg_value: arg
+
+       aref_args: none
+                    {
+                      result = nil
+                    }
+                | command opt_nl
+                    {
+                      result = [val[0]]
+                    }
+                | args trailer
+                    {
+                      result = val[0]
+                    }
+                | args tCOMMA assocs trailer
+                    {
+                      val[0] << s(:hash, *val[2])
+                      result = val[0]
+                    }
+                | assocs trailer
+                    {
+                      result = [s(:hash, *val[0])]
+                    }
+
+      paren_args: tLPAREN2 opt_call_args rparen
+                    {
+                      result = val[1]
+                    }
+
+          rparen: opt_nl tRPAREN
+
+  opt_paren_args: none
+                    {
+                      result = []
+                    }
+                | paren_args
+
+   opt_call_args: none
+                    {
+                      result = []
+                    }
+                | call_args
+                | args tCOMMA
+                    {
+                      result = val[0]
+                    }
+                | args tCOMMA assocs tCOMMA
+                    {
+                      result = val[0]
+                      result << new_hash(nil, val[2], nil)
+                    }
+                | assocs tCOMMA
+                    {
+                      result = [new_hash(nil, val[0], nil)]
+                    }
+
+       call_args: command
+                    {
+                      result = [val[0]]
+                    }
+                | args opt_block_arg
+                    {
+                      result = val[0]
+                      add_block_pass val[0], val[1]
+                    }
+                | assocs opt_block_arg
+                    {
+                      result = [new_hash(nil, val[0], nil)]
+                      add_block_pass result, val[1]
+                    }
+                | args tCOMMA assocs opt_block_arg
+                    {
+                      result = val[0]
+                      result << new_hash(nil, val[2], nil)
+                      result << val[3] if val[3]
+                    }
+                | block_arg
+                    {
+                      result = []
+                      add_block_pass result, val[0]
+                    }
+
+      call_args2: arg_value tCOMMA args opt_block_arg
+                | block_arg
+
+    command_args:   {
+                      lexer.cmdarg_push 1
+                    }
+                    open_args
+                    {
+                      lexer.cmdarg_pop
+                      result = val[1]
+                    }
+
+       open_args: call_args
+                | tLPAREN_ARG tRPAREN
+                    {
+                      result = nil
+                    }
+                | tLPAREN_ARG call_args2 tRPAREN
+                    {
+                      result = val[1]
+                    }
+
+       block_arg: tAMPER arg_value
+                    {
+                      result = new_block_pass(val[0], val[1])
+                    }
+
+   opt_block_arg: tCOMMA block_arg
+                    {
+                      result = val[1]
+                    }
+                | # none
+                    {
+                      result = nil
+                    }
+
+            args: arg_value
+                    {
+                      result = [val[0]]
+                    }
+                | tSTAR arg_value
+                    {
+                      result = [new_splat(val[0], val[1])]
+                    }
+                | args tCOMMA arg_value
+                    {
+                      result = val[0] << val[2]
+                    }
+                | args tCOMMA tSTAR arg_value
+                    {
+                      result  = val[0] << new_splat(val[2], val[3])
+                    }
+
+            mrhs: args tCOMMA arg_value
+                    {
+                      val[0] << val[2]
+                      result = s(:array, *val[0])
+                    }
+                | args tCOMMA tSTAR arg_value
+                    {
+                      val[0] << s(:splat, val[3])
+                      result = s(:array, *val[0])
+                    }
+                | tSTAR arg_value
+                    {
+                      result = s(:splat, val[1])
+                    }
+
+         primary: literal
+                | strings
+                | xstring
+                | regexp
+                | words
+                | awords
+                | var_ref
+                | backref
+                | tFID
+                | kBEGIN
+                    {
+                      result = lexer.line
+                    }
+                    bodystmt kEND
+                    {
+                      result = s(:begin, val[2])
+                    }
+                | tLPAREN_ARG expr opt_nl tRPAREN
+                    {
+                      result = val[1]
+                    }
+                | tLPAREN compstmt tRPAREN
+                    {
+                      result = new_paren(val[0], val[1], val[2])
+                    }
+                | primary_value tCOLON2 tCONSTANT
+                    {
+                      result = new_colon2(val[0], val[1], val[2])
+                    }
+                | tCOLON3 tCONSTANT
+                    {
+                      result = new_colon3(val[0], val[1])
+                    }
+                | primary_value tLBRACK2 aref_args tRBRACK
+                    {
+                      result = new_call val[0], [:[], []], val[2]
+                    }
+                | primary_value tJSLBRACK aref_args tRBRACK
+                    {
+                      result = new_js_call val[0], [:[], []], val[2]
+                    }
+                | tLBRACK aref_args tRBRACK
+                    {
+                      result = new_array(val[0], val[1], val[2])
+                    }
+                | tLBRACE assoc_list tRCURLY
+                    {
+                      result = new_hash(val[0], val[1], val[2])
+                    }
+                | kRETURN
+                    {
+                      result = new_return(val[0])
+                    }
+                | kYIELD tLPAREN2 call_args tRPAREN
+                    {
+                      result = new_yield val[2]
+                    }
+                | kYIELD tLPAREN2 tRPAREN
+                    {
+                      result = s(:yield)
+                    }
+                | kYIELD
+                    {
+                      result = s(:yield)
+                    }
+                | kDEFINED opt_nl tLPAREN2 expr tRPAREN
+                    {
+                      result = s(:defined, val[3])
+                    }
+                | kNOT tLPAREN2 expr tRPAREN
+                    {
+                      result = new_unary_call(['!', []], val[2])
+                    }
+                | kNOT tLPAREN2 tRPAREN
+                    {
+                      result = new_unary_call(['!', []], new_nil(val[0]))
+                    }
+                | operation brace_block
+                    {
+                      result = new_call(nil, val[0], [])
+                      result << val[1]
+                    }
+                | method_call
+                | method_call brace_block
+                    {
+                      val[0] << val[1]
+                      result = val[0]
+                    }
+                | tLAMBDA lambda
+                    {
+                      result = val[1]
+                    }
+                | kIF expr_value then compstmt if_tail kEND
+                    {
+                      result = new_if(val[0], val[1], val[3], val[4])
+                    }
+                | kUNLESS expr_value then compstmt opt_else kEND
+                    {
+                      result = new_if(val[0], val[1], val[4], val[3])
+                    }
+                | kWHILE
+                    {
+                      lexer.cond_push 1
+                      result = lexer.line
+                    }
+                    expr_value do
+                    {
+                      lexer.cond_pop
+                    }
+                    compstmt kEND
+                    {
+                      result = s(:while, val[2], val[5])
+                    }
+                | kUNTIL
+                    {
+                      lexer.cond_push 1
+                      result = lexer.line
+                    }
+                    expr_value do
+                    {
+                      lexer.cond_pop
+                    }
+                    compstmt kEND
+                    {
+                      result = s(:until, val[2], val[5])
+                    }
+                | kCASE expr_value opt_terms case_body kEND
+                    {
+                      result = s(:case, val[1], *val[3])
+                    }
+                | kCASE opt_terms case_body kEND
+                    {
+                      result = s(:case, nil, *val[2])
+                    }
+                | kCASE opt_terms kELSE compstmt kEND
+                    {
+                      result = s(:case, nil, val[3])
+                    }
+                | kFOR for_var kIN
+                    {
+                      lexer.cond_push 1
+                      result = lexer.line
+                    }
+                    expr_value do
+                    {
+                      lexer.cond_pop
+                    }
+                    compstmt kEND
+                    {
+                      result = s(:for, val[4], val[1], val[7])
+                    }
+                | kCLASS cpath superclass
+                    {
+                      # ...
+                    }
+                    bodystmt kEND
+                    {
+                      result = new_class val[0], val[1], val[2], val[4], val[5]
+                    }
+                | kCLASS tLSHFT
+                    {
+                      result = lexer.line
+                    }
+                    expr term
+                    {
+                      # ...
+                    }
+                    bodystmt kEND
+                    {
+                      result = new_sclass(val[0], val[3], val[6], val[7])
+                    }
+                | kMODULE
+                    {
+                      result = lexer.line
+                    }
+                    cpath
+                    {
+                      # ...
+                    }
+                    bodystmt kEND
+                    {
+                      result = new_module(val[0], val[2], val[4], val[5])
+                    }
+                | kDEF fname
+                    {
+                      push_scope
+                      lexer.lex_state = :expr_endfn
+                    }
+                    f_arglist bodystmt kEND
+                    {
+                      result = new_def(val[0], nil, val[1], val[3], val[4], val[5])
+                      pop_scope
+                    }
+                | kDEF singleton dot_or_colon
+                    {
+                       lexer.lex_state = :expr_fname
+                    }
+                    fname
+                    {
+                      push_scope
+                      lexer.lex_state = :expr_endfn
+                    }
+                    f_arglist bodystmt kEND
+                    {
+                      result = new_def(val[0], val[1], val[4], val[6], val[7], val[8])
+                      pop_scope
+                    }
+                | kBREAK
+                    {
+                      result = new_break(val[0])
+                    }
+                | kNEXT
+                    {
+                      result = s(:next)
+                    }
+                | kREDO
+                    {
+                      result = s(:redo)
+                    }
+                | kRETRY
+
+   primary_value: primary
+
+            then: term
+                | tCOLON
+                | kTHEN
+                | term kTHEN
+
+              do: term
+                | tCOLON
+                | kDO_COND
+
+          lambda: f_larglist lambda_body
+                    {
+                      result = new_call nil, [:lambda, []], []
+                      result << new_iter(val[0], val[1])
+                    }
+
+      f_larglist: tLPAREN2 block_param tRPAREN
+                    {
+                      result = val[1]
+                    }
+                | tLPAREN2 tRPAREN
+                    {
+                      result = nil
+                    }
+                | block_param
+                | none
+
+     lambda_body: tLAMBEG compstmt tRCURLY
+                    {
+                      result = val[1]
+                    }
+                | kDO_LAMBDA compstmt kEND
+                    {
+                      result = val[1]
+                    }
+
+         if_tail: opt_else
+                    {
+                      result = val[0]
+                    }
+                | kELSIF expr_value then compstmt if_tail
+                    {
+                      result = new_if(val[0], val[1], val[3], val[4])
+                    }
+
+        opt_else: none
+                | kELSE compstmt
+                    {
+                      result = val[1]
+                    }
+
+  f_block_optarg: f_block_opt
+                    {
+                      result = s(:block, val[0])
+                    }
+                | f_block_optarg tCOMMA f_block_opt
+                    {
+                      val[0] << val[2]
+                      result = val[0]
+                    }
+
+     f_block_opt: tIDENTIFIER tEQL primary_value
+                    {
+                      result = new_assign(new_assignable(new_ident(
+                                  val[0])), val[1], val[2])
+                    }
+
+   opt_block_var: none
+                | tPIPE tPIPE
+                    {
+                      result = nil
+                    }
+                | tOROP
+                    {
+                      result = nil
+                    }
+                | tPIPE block_param tPIPE
+                    {
+                      result = val[1]
+                    }
+
+ block_args_tail: f_block_arg
+                    {
+                      result = val[0]
+                    }
+
+opt_block_args_tail: tCOMMA block_args_tail
+                    {
+                      result = val[1]
+                    }
+                | none
+                    {
+                      nil
+                    }
+
+     block_param: f_arg tCOMMA f_block_optarg tCOMMA f_rest_arg opt_block_args_tail
+                    {
+                      result = new_block_args(val[0], val[2], val[4], val[5])
+                    }
+                | f_arg tCOMMA f_block_optarg opt_block_args_tail
+                    {
+                      result = new_block_args(val[0], val[2], nil, val[3])
+                    }
+                | f_arg tCOMMA f_rest_arg opt_block_args_tail
+                    {
+                      result = new_block_args(val[0], nil, val[2], val[3])
+                    }
+                | f_arg tCOMMA
+                    {
+                      result = new_block_args(val[0], nil, nil, nil)
+                    }
+                | f_arg opt_block_args_tail
+                    {
+                      result = new_block_args(val[0], nil, nil, val[1])
+                    }
+                | f_block_optarg tCOMMA f_rest_arg opt_block_args_tail
+                    {
+                      result = new_block_args(nil, val[0], val[2], val[3])
+                    }
+                | f_block_optarg opt_block_args_tail
+                    {
+                      result = new_block_args(nil, val[0], nil, val[1])
+                    }
+                | f_rest_arg opt_block_args_tail
+                    {
+                      result = new_block_args(nil, nil, val[0], val[1])
+                    }
+                | block_args_tail
+                    {
+                      result = new_block_args(nil, nil, nil, val[0])
+                    }
+
+        do_block: kDO_BLOCK
+                    {
+                      push_scope :block
+                      result = lexer.line
+                    }
+                    opt_block_var compstmt kEND
+                    {
+                      result = new_iter val[2], val[3]
+                      pop_scope
+                    }
+
+      block_call: command do_block
+                    {
+                      val[0] << val[1]
+                      result = val[0]
+                    }
+                | block_call tJSDOT operation2 opt_paren_args
+                | block_call tDOT operation2 opt_paren_args
+                | block_call tCOLON2 operation2 opt_paren_args
+
+     method_call: operation paren_args
+                    {
+                      result = new_call(nil, val[0], val[1])
+                    }
+                | primary_value tDOT operation2 opt_paren_args
+                    {
+                      result = new_call(val[0], val[2], val[3])
+                    }
+                | primary_value tJSDOT operation2 opt_paren_args
+                    {
+                      result = new_js_call(val[0], val[2], val[3])
+                    }
+                | primary_value tDOT paren_args
+                    {
+                      result = new_call(val[0], [:call, []], val[2])
+                    }
+                | primary_value tCOLON2 operation2 paren_args
+                    {
+                      result = new_call(val[0], val[2], val[3])
+                    }
+                | primary_value tCOLON2 operation3
+                    {
+                      result = new_call(val[0], val[2])
+                    }
+                | kSUPER paren_args
+                    {
+                      result = new_super(val[0], val[1])
+                    }
+                | kSUPER
+                    {
+                      result = new_super(val[0], nil)
+                    }
+
+     brace_block: tLCURLY
+                    {
+                      push_scope :block
+                      result = lexer.line
+                    }
+                    opt_block_var compstmt tRCURLY
+                    {
+                      result = new_iter val[2], val[3]
+                      pop_scope
+                    }
+                | kDO
+                    {
+                      push_scope :block
+                      result = lexer.line
+                    }
+                    opt_block_var compstmt kEND
+                    {
+                      result = new_iter val[2], val[3]
+                      pop_scope
+                    }
+
+       case_body: kWHEN
+                    {
+                      result = lexer.line
+                    }
+                    args then compstmt cases
+                    {
+                      part = s(:when, s(:array, *val[2]), val[4])
+                      result = [part]
+                      result.push(*val[5]) if val[5]
+                    }
+
+           cases: opt_else
+                    {
+                      result = [val[0]]
+                    }
+                | case_body
+
+      opt_rescue: kRESCUE exc_list exc_var then compstmt opt_rescue
+                    {
+                      exc = val[1] || s(:array)
+                      exc << new_assign(val[2], val[2], s(:gvar, '$!'.intern)) if val[2]
+                      result = [s(:resbody, exc, val[4])]
+                      result.push val[5].first if val[5]
+                    }
+                | # none
+                    {
+                      result = nil
+                    }
+
+        exc_list: arg_value
+                    {
+                      result = s(:array, val[0])
+                    }
+                | mrhs
+                | none
+
+         exc_var: tASSOC lhs
+                    {
+                      result = val[1]
+                    }
+                | none
+                    {
+                      result = nil
+                    }
+
+      opt_ensure: kENSURE compstmt
+                    {
+                      result = val[1].nil? ? s(:nil) : val[1]
+                    }
+                | none
+
+         literal: numeric
+                | symbol
+                | dsym
+
+         strings: string
+                    {
+                      result = new_str val[0]
+                    }
+
+          string: string1
+                | string string1
+                  {
+                    result = str_append val[0], val[1]
+                  }
+
+         string1: tSTRING_BEG string_contents tSTRING_END
+                    {
+                      result = val[1]
+                    }
+                | tSTRING
+                    {
+                      result = s(:str, value(val[0]))
+                    }
+
+         xstring: tXSTRING_BEG xstring_contents tSTRING_END
+                    {
+                      result = new_xstr(val[0], val[1], val[2])
+                    }
+
+          regexp: tREGEXP_BEG xstring_contents tREGEXP_END
+                    {
+                      result = new_regexp val[1], val[2]
+                    }
+
+           words: tWORDS_BEG tSPACE tSTRING_END
+                    {
+                      result = s(:array)
+                    }
+                | tWORDS_BEG word_list tSTRING_END
+                    {
+                      result = val[1]
+                    }
+
+       word_list: none
+                    {
+                      result = s(:array)
+                    }
+                | word_list word tSPACE
+                    {
+                      part = val[1]
+                      part = s(:dstr, "", val[1]) if part.type == :evstr
+                      result = val[0] << part
+                    }
+
+            word: string_content
+                    {
+                      result = val[0]
+                    }
+                | word string_content
+                    {
+                      result = val[0].concat([val[1]])
+                    }
+
+          awords: tAWORDS_BEG tSPACE tSTRING_END
+                    {
+                      result = s(:array)
+                    }
+                | tAWORDS_BEG qword_list tSTRING_END
+                    {
+                      result = val[1]
+                    }
+
+      qword_list: none
+                    {
+                      result = s(:array)
+                    }
+                | qword_list tSTRING_CONTENT tSPACE
+                    {
+                      result = val[0] << s(:str, value(val[1]))
+                    }
+
+ string_contents: none
+                    {
+                      result = nil
+                    }
+                | string_contents string_content
+                    {
+                      result = str_append val[0], val[1]
+                    }
+
+xstring_contents: none
+                    {
+                      result = nil
+                    }
+                | xstring_contents string_content
+                    {
+                      result = str_append val[0], val[1]
+                    }
+
+  string_content: tSTRING_CONTENT
+                    {
+                      result = new_str_content(val[0])
+                    }
+                | tSTRING_DVAR
+                    {
+                      result = lexer.strterm
+                      lexer.strterm = nil
+                    }
+                    string_dvar
+                    {
+                      lexer.strterm = val[1]
+                      result = new_evstr(val[2])
+                    }
+                | tSTRING_DBEG
+                    {
+                      lexer.cond_push 0
+                      lexer.cmdarg_push 0
+                      result = lexer.strterm
+                      lexer.strterm = nil
+                      lexer.lex_state = :expr_beg
+                    }
+                    compstmt tRCURLY
+                    {
+                      lexer.strterm = val[1]
+                      lexer.cond_lexpop
+                      lexer.cmdarg_lexpop
+                      result = new_evstr(val[2])
+                    }
+
+     string_dvar: tGVAR
+                    {
+                      result = new_gvar(val[0])
+                    }
+                | tIVAR
+                    {
+                      result = new_ivar(val[0])
+                    }
+                | tCVAR
+                    {
+                      result = new_cvar(val[0])
+                    }
+                | backref
+
+
+          symbol: tSYMBEG sym
+                    {
+                      result = new_sym(val[1])
+                      lexer.lex_state = :expr_end
+                    }
+                | tSYMBOL
+                    {
+                      result = new_sym(val[0])
+                    }
+
+             sym: fname
+                | tIVAR
+                | tGVAR
+                | tCVAR
+
+            dsym: tSYMBEG xstring_contents tSTRING_END
+                    {
+                      result = new_dsym val[1]
+                    }
+
+         numeric: tINTEGER
+                    {
+                      result = new_int(val[0])
+                    }
+                | tFLOAT
+                    {
+                      result = new_float(val[0])
+                    }
+                | '-@NUM' tINTEGER =tLOWEST
+                  {
+                    result = negate_num(new_int(val[1]))
+                  }
+                | '-@NUM' tFLOAT   =tLOWEST
+                  {
+                    result = negate_num(new_float(val[1]))
+                  }
+                | '+@NUM' tINTEGER =tLOWEST
+                  {
+                    result = new_int(val[1])
+                  }
+                | '+@NUM' tFLOAT   =tLOWEST
+                  {
+                    result = new_float(val[1])
+                  }
+
+        variable: tIDENTIFIER
+                    {
+                      result = new_ident(val[0])
+                    }
+                | tIVAR
+                    {
+                      result = new_ivar(val[0])
+                    }
+                | tGVAR
+                    {
+                      result = new_gvar(val[0])
+                    }
+                | tCONSTANT
+                    {
+                      result = new_const(val[0])
+                    }
+                | tCVAR
+                    {
+                      result = new_cvar(val[0])
+                    }
+                | kNIL
+                    {
+                      result = new_nil(val[0])
+                    }
+                | kSELF
+                    {
+                      result = new_self(val[0])
+                    }
+                | kTRUE
+                    {
+                      result = new_true(val[0])
+                    }
+                | kFALSE
+                    {
+                      result = new_false(val[0])
+                    }
+                | k__FILE__
+                    {
+                      result = new___FILE__(val[0])
+                    }
+                | k__LINE__
+                    {
+                      result = new___LINE__(val[0])
+                    }
+
+         var_ref: variable
+                    {
+                      result = new_var_ref(val[0])
+                    }
+
+         var_lhs: variable
+                    {
+                      result = new_assignable val[0]
+                    }
+
+         backref: tNTH_REF
+                    {
+                      result = s(:nth_ref, value(val[0]))
+                    }
+                | tBACK_REF
+
+      superclass: term
+                    {
+                      result = nil
+                    }
+                | tLT expr_value term
+                    {
+                      result = val[1]
+                    }
+                | error term
+                    {
+                      result = nil
+                    }
+
+       f_arglist: tLPAREN2 f_args opt_nl tRPAREN
+                    {
+                      result = val[1]
+                      lexer.lex_state = :expr_beg
+                    }
+                | f_args term
+                    {
+                      result = val[0]
+                      lexer.lex_state = :expr_beg
+                    }
+
+     kwrest_mark: tPOW
+                | tDSTAR
+
+        f_kwrest: kwrest_mark tIDENTIFIER
+                    {
+                      result = new_kwrestarg(val[1])
+                    }
+                | kwrest_mark
+                    {
+                      result = new_kwrestarg()
+                    }
+
+         f_label: tLABEL
+                    {
+                      result = new_sym(val[0])
+                    }
+
+            f_kw: f_label arg_value
+                    {
+                      result = new_kwoptarg(val[0], val[1])
+                    }
+                | f_label
+                    {
+                      result = new_kwarg(val[0])
+                    }
+
+         f_kwarg: f_kw
+                    {
+                      result = [val[0]]
+                    }
+                | f_kwarg tCOMMA f_kw
+                    {
+                      result = val[0]
+                      result << val[2]
+                    }
+
+       args_tail: f_kwarg tCOMMA f_kwrest opt_f_block_arg
+                    {
+                      result = new_args_tail(val[0], val[2], val[3])
+                    }
+                | f_kwarg opt_f_block_arg
+                    {
+                      result = new_args_tail(val[0], nil, val[1])
+                    }
+                | f_kwrest opt_f_block_arg
+                    {
+                      result = new_args_tail(nil, val[0], val[1])
+                    }
+                | f_block_arg
+                    {
+                      result = new_args_tail(nil, nil, val[0])
+                    }
+
+   opt_args_tail: tCOMMA args_tail
+                    {
+                      result = val[1]
+                    }
+                | # none
+                    {
+                      result = new_args_tail(nil, nil, nil)
+                    }
+
+          f_args: f_arg tCOMMA f_optarg tCOMMA f_rest_arg opt_args_tail
+                    {
+                      result = new_args(val[0], val[2], val[4], val[5])
+                    }
+                | f_arg tCOMMA f_optarg opt_args_tail
+                    {
+                      result = new_args(val[0], val[2], nil, val[3])
+                    }
+                | f_arg tCOMMA f_rest_arg opt_args_tail
+                    {
+                      result = new_args(val[0], nil, val[2], val[3])
+                    }
+                | f_arg opt_args_tail
+                    {
+                      result = new_args(val[0], nil, nil, val[1])
+                    }
+                | f_optarg tCOMMA f_rest_arg opt_args_tail
+                    {
+                      result = new_args(nil, val[0], val[2], val[3])
+                    }
+                | f_optarg opt_args_tail
+                    {
+                      result = new_args(nil, val[0], nil, val[1])
+                    }
+                | f_rest_arg opt_args_tail
+                    {
+                      result = new_args(nil, nil, val[0], val[1])
+                    }
+                | args_tail
+                    {
+                      result = new_args(nil, nil, nil, val[0])
+                    }
+                | # none
+                    {
+                      result = new_args(nil, nil, nil, nil)
+                    }
+
+      f_norm_arg: f_bad_arg
+                | tIDENTIFIER
+                    {
+                      result = value(val[0]).to_sym
+                      scope.add_local result
+                    }
+
+       f_bad_arg: tCONSTANT
+                    {
+                      raise 'formal argument cannot be a constant'
+                    }
+                | tIVAR
+                    {
+                      raise 'formal argument cannot be an instance variable'
+                    }
+                | tCVAR
+                    {
+                      raise 'formal argument cannot be a class variable'
+                    }
+                | tGVAR
+                    {
+                      raise 'formal argument cannot be a global variable'
+                    }
+
+      f_arg_item: f_norm_arg
+                    {
+                      result = val[0]
+                    }
+                | tLPAREN f_margs tRPAREN
+                    {
+                      result = val[1]
+                    }
+
+         for_var: lhs
+                | mlhs
+
+          f_marg: f_norm_arg
+                    {
+                      result = s(:lasgn, val[0])
+                    }
+                | tLPAREN f_margs tRPAREN
+
+     f_marg_list: f_marg
+                    {
+                      result = s(:array, val[0])
+                    }
+                | f_marg_list tCOMMA f_marg
+                    {
+                      val[0] << val[2]
+                      result = val[0]
+                    }
+
+         f_margs: f_marg_list
+                | f_marg_list tCOMMA tSTAR f_norm_arg
+                | f_marg_list tCOMMA tSTAR
+                | tSTAR f_norm_arg
+                | tSTAR
+
+           f_arg: f_arg_item
+                    {
+                      result = [val[0]]
+                    }
+                | f_arg tCOMMA f_arg_item
+                    {
+                      val[0] << val[2]
+                      result = val[0]
+                    }
+
+           f_opt: tIDENTIFIER tEQL arg_value
+                    {
+                      result = new_assign(new_assignable(new_ident(val[0])), val[1], val[2])
+                    }
+
+        f_optarg: f_opt
+                    {
+                      result = s(:block, val[0])
+                    }
+                | f_optarg tCOMMA f_opt
+                    {
+                      result = val[0]
+                      val[0] << val[2]
+                    }
+
+    restarg_mark: tSTAR2
+                | tSTAR
+
+      f_rest_arg: restarg_mark tIDENTIFIER
+                    {
+                      result = "*#{value(val[1])}".to_sym
+                    }
+                | restarg_mark
+                    {
+                      result = :"*"
+                    }
+
+     blkarg_mark: tAMPER2
+                | tAMPER
+
+     f_block_arg: blkarg_mark tIDENTIFIER
+                    {
+                      result = "&#{value(val[1])}".to_sym
+                    }
+
+ opt_f_block_arg: tCOMMA f_block_arg
+                    {
+                      result = val[1]
+                    }
+                | # none
+                    {
+                      result = nil
+                    }
+
+       singleton: var_ref
+                    {
+                      result = val[0]
+                    }
+                | tLPAREN2 expr opt_nl tRPAREN
+                    {
+                      result = val[1]
+                    }
+
+      assoc_list: # none
+                    {
+                      result = []
+                    }
+                | assocs trailer
+                    {
+                      result = val[0]
+                    }
+
+          assocs: assoc
+                    {
+                      result = val[0]
+                    }
+                | assocs tCOMMA assoc
+                    {
+                      result = val[0].push(*val[2])
+                    }
+
+           assoc: arg_value tASSOC arg_value
+                    {
+                      result = [val[0], val[2]]
+                    }
+                | tLABEL arg_value
+                    {
+                      result = [new_sym(val[0]), val[1]]
+                    }
+
+       operation: tIDENTIFIER
+                | tCONSTANT
+                | tFID
+
+      operation2: tIDENTIFIER
+                | tCONSTANT
+                | tFID
+                | op
+
+      operation3: tIDENTIFIER
+                | tFID
+                | op
+
+    dot_or_colon: tDOT
+                | tCOLON2
+
+       opt_terms: # none
+                | terms
+
+          opt_nl: # none
+                | tNL
+
+         trailer: # none
+                | tNL
+                | tCOMMA
+
+            term: tSEMI
+                | tNL
+
+           terms: term
+                | terms tSEMI
+
+            none: # none
+                    {
+                      result = nil
+                    }
+end
+
+---- inner