depager 0.2.3 → 0.3.0.b20160729

data/lib/depager/ruby/plugins/rie.dr

@@ -0,0 +1,723 @@
+%defext Depager::RieExtension
+%extend Depager::Lexer ('plugins/lex.rb')
+%extend Depager::Action ('plugins/action.rb')
+%decorate @Action
+#%decorate Depager::LALR::ShiftReducePrinter ('plugins/srp.rb')
+%expanded_code_delimiter DEPAGER_EXPANDED_CODE
+%inner{
+  module Nodes
+    N_THREAD   = Struct.new :lineno, :targets, :excepts
+    N_TRANSFER = Struct.new :lineno, :targets, :excepts
+    N_EXCEPT   = Struct.new :lineno, :let_or_ids
+    N_LET      = Struct.new :lineno, :atoc, :expr, :state
+    N_ACTION   = Struct.new :lineno, :expr
+    N_ATOC     = Struct.new :lineno, :sym_name, :attr_name, :rx
+  end
+  include Nodes
+
+  begin
+    Depager.debug_mode? and require 'plugins/_rie_debug.rb'
+  rescue LoadError
+  end
+
+  attr_accessor :action_code, :on_reduce, :semantics, :attributes, :ecs
+  attr_reader   :grammar
+
+  def init_extension
+    @action_code   = ''
+    @on_reduce  = []
+    @on_state   = []
+    @attributes = []
+    @semantics  = [[]]
+    @locals     = [{}]
+    @ecs        = {}
+    if Depager.debug_mode?
+      @debug_output_path = "#{g_parser.file.path}.rie_debug.output"
+      File.unlink @debug_output_path rescue nil
+    end
+  end
+
+  def term_extension
+    $grammar = @grammar = g_parser.table.grammar
+    expand_short_hand_notation
+    error_exit_if_error_pending
+
+    check_lattr
+    error_exit_if_error_pending
+    debug_info "locals:\n#{@locals.pretty_inspect}"
+
+    generate_action
+    g_parser.outer_code << generate_rie_decorator_code(@on_reduce, @on_state, @action_code)
+  end
+
+  def expand_short_hand_notation
+    semantics = []
+    @semantics.each_with_index do |rule_semantics, x|
+      res = []
+      (rule_semantics || []).each do |semantic|
+        case semantic
+        when N_TRANSFER ; expand_transfer res, semantic, grammar[x]
+        when N_THREAD   ; expand_thread res, semantic, grammar[x]
+        else res << semantic
+        end
+      end
+      semantics << res
+    end
+    @semantics = semantics
+  end
+
+  def expand_transfer res, transfer, rule
+    lineno = transfer.lineno
+    transfer.targets.each do |attr_name|
+      unless @attributes[rule.lhs].include?(attr_name)
+        pending_error "#{attr_name} is not lhs attribute.", lineno
+        next
+      end
+      used   = false
+      rule.rhs.each_with_index do |rsym, i|
+        next unless grammar.nonterm? rsym
+
+        rname  = rule.rhs_names[i]
+        rattrs = @attributes[rsym] || []
+        next if !rattrs.include?(attr_name) || transfer.excepts.find do |e|
+          rname == e.sym_name and rattrs.include?(e.attr_name)
+        end
+        if attr_name[0] == ?_ # inherited attr
+          res << N_LET[lineno, N_ATOC[lineno, rname, attr_name, rule.n],
+            [N_ATOC[lineno, '$', attr_name, rule.n]]]
+          used = true
+        else
+          if used
+            pending_error "transfer `$.#{attr_name}' has too many source."
+            break
+          end
+          res << N_LET[lineno, N_ATOC[lineno, '$', attr_name, rule.n],
+            [N_ATOC[lineno, rname, attr_name, rule.n]]]
+          used = true
+        end
+      end
+      unless used
+        pending_error "no rhs symbol have attribute `#{attr_name}'", lineno
+      end
+    end
+  end
+
+  def expand_thread res, thread, rule
+    lineno, excepts  = thread.lineno, thread.excepts.dup
+    thread.targets.each do |syn_name|
+      inh_name = '_' + syn_name
+      from, used = nil, false
+
+      lname  = rule.lhs_name
+      lattrs = @attributes[rule.lhs]
+
+      if lattrs.include?(inh_name)
+        from = N_ATOC[lineno, '$', inh_name, rule.n]
+      end
+      rule.rhs.each_with_index do |rsym, i|
+        rname  = rule.rhs_names[i]
+        rattrs = @attributes[rsym] || []
+
+        if from and rattrs.include? inh_name and
+            not excepts.find{|e| rname == e.sym_name && rattrs.include?(e.attr_name) }
+          res << N_LET[lineno, N_ATOC[lineno, rname, inh_name, rule.n], [from]]
+          used = true
+        end
+        if rattrs.include? syn_name
+          from = N_ATOC[lineno, rname, syn_name, rule.n]
+        end
+      end
+      if from and lattrs.include?(syn_name) and
+          not excepts.find{|e| lname == e.sym_name && lattrs.include?(e.attr_name) }
+        res << N_LET[lineno, N_ATOC[lineno, '$', syn_name, rule.n], [from]]
+        used = true
+      end
+      unless used
+        pending_error "no rhs symbol have attribute `#{syn_name}'", lineno
+      end
+    end
+  end
+
+  def check_lattr
+    @inhs_of_nonterms = []
+    @semantics.each_with_index do |rule_semantics, x|
+      rule     = grammar[x]
+      assigned = {}
+      locals   = @locals[rule.n] = {}
+      rule_semantics.each do |semantic|
+        semantic.is_a? N_LET and check_lattr_let semantic, rule, locals, assigned
+      end
+
+      next if x == 0
+      lineno = rule_semantics.last.lineno rescue 0
+      @attributes[rule.lhs].each do |a|
+        if a[0] != ?_ and not assigned[['$', a]]
+          pending_error "attribute `$.#{a}' is not assigned.", lineno
+        end
+      end
+      rule.rhs.each_with_index do |rsym, y|
+        next unless grammar.nonterm? rsym
+        rname = rule.rhs_names[y]
+        @attributes[rsym].each do |a|
+          if a[0] == ?_ and not assigned[[rname, a]]
+            pending_error "attribute `#{rname}.#{a}' is not assigned.", lineno
+          end
+        end
+      end
+    end
+  end
+
+  def check_lattr_let let, rule, locals, assigned
+    lineno    = let.lineno
+    attr_name = let.atoc.attr_name
+    sym_name  = let.atoc.sym_name
+
+    # left hand side of let
+    unless valid_atoc? let.atoc
+      pending_error "invalid attribute occurrence `#{sym_name}.#{attr_name}'.", lineno
+      return
+    end
+    if    let.atoc.sym_name == '$' and inh_atoc?(let.atoc)
+      pending_error "cannot assign `$.#{attr_name}'(LHS INH).", lineno
+      return
+    elsif let.atoc.sym_name != '$' and syn_atoc?(let.atoc)
+      pending_error "cannot assign `#{sym_name}.#{attr_name}'(RHS SYN).", lineno
+      return
+    end
+    if local_atoc?(let.atoc)
+      if locals[attr_name]
+        warning "local attributes `#{attr_name}' is reassigned.", lineno
+      end
+      locals[attr_name] = 0
+    else
+      if assigned[[sym_name, attr_name]]
+        warning "attributes `#{sym_name}.#{attr_name}' is reassined.", lineno
+      else
+        assigned[[sym_name, attr_name]] = true
+      end
+    end
+
+    # right hand side of let
+    let.expr.find_all{|i| i.is_a? N_ATOC }.each do |expr_atoc|
+      unless valid_atoc? expr_atoc
+        next unless valid_atoc_name? expr_atoc # it is not atoc
+        pending_error "invalid attribute occurrence"<<
+              " `#{expr_atoc.sym_name}.#{expr_atoc.attr_name}'.", lineno
+        next
+      end
+      if    expr_atoc.sym_name == '$' and syn_atoc?(expr_atoc)
+        pending_error "cannot refer `$.#{expr_atoc.attr_name}'(LHS SYN).", lineno
+        next
+      elsif expr_atoc.sym_name != '$' and inh_atoc?(expr_atoc)
+        pending_error "cannot refer `#{expr_atoc.sym_name}." <<
+          "#{expr_atoc.attr_name}'(RHS INH).", lineno
+        next
+      end
+      if local_atoc?(let.atoc)
+        if local_atoc?(expr_atoc)    # local<-local
+          n = locals[expr_atoc.attr_name]
+        elsif syn_atoc?(expr_atoc)   # local<-rsym.syn
+          n = rhs_index(expr_atoc)+1
+        else                         # local<-$.inh
+          n = 0
+        end
+        locals[attr_name] = n if locals[attr_name] < n
+      elsif sym_name != '$' and local_atoc?(expr_atoc) and    # rhs<-local
+          rhs_index(let.atoc) <= locals[expr_atoc.attr_name]
+        pending_error "L-attribute violation.", lineno
+        next
+      elsif sym_name != '$' and expr_atoc.sym_name != '$' and # rhs<-rhs
+          rhs_index(let.atoc) <= rhs_index(expr_atoc)
+        pending_error "L-attribute violation.", lineno
+        next
+      end
+    end
+  end
+
+  def generate_action
+    # Actions on state change.
+    g_parser.table.states.each_with_index do |state, x|
+      actions = [ ]
+      inhs, locals = check_state_uniqueness(state)
+      inhs.each do |key, exprs| ; sym, attr_name = key
+        atoc = N_ATOC[0, "%#{sym}", attr_name]
+        actions << node_to_code(N_LET[0, atoc, exprs], state)
+      end
+      locals.each do |rx, attr_name, exprs|
+        atoc = N_ATOC[0, nil, attr_name, rx]
+        actions << node_to_code(N_LET[0, atoc, exprs], state)
+      end
+      unless actions.empty?
+        @action_code << "def _rie_state_#{x}\n  #{actions.join("\n  ")}\nend\n"
+        @on_state[x] = ":_rie_state_#{x}"
+      end
+    end
+
+    # Actions on reduce
+    @semantics.each_with_index do |rule_semantics, x|
+      actions = [ ]
+      rule = grammar[x]
+      rule_semantics.each do |semantic|
+        if semantic.is_a?(N_LET)
+          next if inh_atoc?(semantic.atoc)
+          next if local_atoc?(semantic.atoc) and not
+            @locals[x].find{|k,v| k == semantic.atoc.attr_name && v == rule.rhs.size }
+        end
+        code = node_to_code(semantic)
+        actions << code
+      end
+      unless actions.empty?
+        @action_code << "def _rie_reduce_#{x}\n  #{actions.join("\n  ")}\nend\n"
+        @on_reduce[x] = ":_rie_reduce_#{x}"
+      end
+    end
+  end
+
+  def node_to_code node, state=nil
+    case node
+    when N_LET
+      node_to_code(node.atoc, state) +" = "+
+        node_to_code(N_ACTION[0, node.expr], state)
+    when N_ACTION
+      node.expr.inject('') do |r, i|
+        r << (i.is_a?(N_ATOC) ? node_to_code(i, state) :
+          i.match(/^\s*[\{\[\(]$/) ? i : " #{i}")
+      end
+    when N_ATOC
+      return " #{node.sym_name}.#{node.attr_name}" unless valid_atoc? node
+      dot = 0
+      if state and item = state.closure.find{|i| i.rule.n == node.rx }
+        dot = item.n
+      elsif node.rx
+        dot = grammar[node.rx].rhs.size
+      end
+      if grammar.term? atoc_to_sym(node)
+        x = rhs_index(node) - dot
+        " _sstack(#{x}).syn.#{node.attr_name}"
+      elsif local_atoc? node
+        x = -dot
+        " _sstack(#{x-1}).local['#{node.attr_name}@#{node.rx}']"
+      elsif inh_atoc? node
+        # NEVER ASN LHS($).INH
+        if node.sym_name =~ /^%/   # ASN RHS.INH
+          x, sym = 0, $'
+        else                       # REF LHS($).INH / RHS.INH
+          x, sym = (rhs_index(node) || 0) - dot, atoc_to_sym(node)
+        end
+        ec = @ecs[[sym, node.attr_name]]
+        " _sstack(#{x-1}).inh['#{ec || sym}.#{node.attr_name}']"
+      else # syn_atoc?
+        # NEVER ASN RHS.SYN
+        if node.sym_name == '$' # ASN/REF LHS($).SYN
+          " @_rie_reduce_syn['#{node.attr_name}']"
+        else                    # REF RHS.SYN
+          x = rhs_index(node) - dot
+          " _sstack(#{x}).syn['#{node.attr_name}']"
+        end
+      end
+    else ; raise "cannot happen(#{node.inspect})."
+    end
+  rescue ; warn node.pretty_inspect ; raise
+  end
+
+  def check_state_uniqueness state
+    inhs, ec_inhs, locals = {}, {}, []
+    state.closure.each do |item|
+      rule = item.rule
+      @semantics[rule.n].each do |let|
+        next if !let.is_a?(N_LET)
+        next if item.n == rule.rhs.size
+        if local_atoc?(let.atoc)
+          @locals[rule.n].find{|k, v| k == let.atoc.attr_name && v == item.n } and
+            locals << [rule.n, let.atoc.attr_name, let.expr]
+          next
+        end
+        next if syn_atoc?(let.atoc) or rhs_index(let.atoc) != item.n
+
+        # ok, atoc is A._inh(B -> alpa _ A beta). set E_state(atoc).
+        attr_name = let.atoc.attr_name
+        sym       = atoc_to_sym(let.atoc)
+        key       = [sym, attr_name]
+        if expr = inhs[key]
+          if expr.size == 1 and expr[0].is_a?(N_ATOC) and
+              atoc_to_sym(expr[0]) == sym and expr[0].attr_name == attr_name
+            # older is self copy, update it.
+            inhs.delete(key)
+            inhs[key] = replace_atoc expr, inhs
+          elsif let.expr.size == 1 and let.expr[0].is_a?(N_ATOC) and
+              atoc_to_sym(let.expr[0]) == sym and let.expr[0].attr_name == attr_name
+            # newer is self copy, skip.
+          elsif not same_semantic? expr, let.expr
+            error_exit "LALR-attribute violation."
+          end
+        else
+          inhs[key] = replace_atoc let.expr, inhs
+        end
+      end
+    end
+
+    # check eclr
+    inhs.each do |k, v|
+      sym, attr_name = k
+      if ec = @ecs[k]
+        key = [ec, attr_name]
+        if ec_inhs[key]
+          unless same_semantic? ec_inhs[key], v
+            error_exit "ECLR-attribute violation."
+          end
+        else
+          ec_inhs[key] = v
+        end
+      else
+        ec_inhs[k] = v
+      end
+    end
+
+    debug_info "\n----------\n#{state}"
+    ec_inhs.each{|k,v| s,a=k;debug_info "#{grammar.symname s}:#{s}.#{a}=>#{v.pretty_inspect}" }
+    locals.each{|x,k,v| debug_info "#{x}.#{k}=>#{v.pretty_inspect}"}
+    return ec_inhs, locals
+  end
+
+  def same_semantic? sa, sb
+    return false unless sa.size == sb.size
+    sa.size.times do |x| a, b = sa[x], sb[x]
+      return false unless a.class == b.class
+      if a.is_a? N_ATOC
+        asym = a.sym_name == '$' ? atoc_to_sym(a) : a.sym_name
+        bsym = b.sym_name == '$' ? atoc_to_sym(b) : b.sym_name
+        asym = @ecs[[asym, a.attr_name]] if @ecs[[asym, a.attr_name]]
+        bsym = @ecs[[bsym, b.attr_name]] if @ecs[[bsym, b.attr_name]]
+        return false unless asym == bsym && a.attr_name == b.attr_name
+      else
+        return false unless a == b
+      end
+    end
+    return true
+  end
+
+  def replace_atoc expr, inhs={}
+    # warn "REPLACE:#{expr.pretty_inspect}"
+    res = []
+    expr and expr.each do |node|
+      if node.is_a? N_ATOC
+        if replace_to = inhs[[atoc_to_sym(node), node.attr_name]]
+          res.concat replace_to
+        else
+          res << node
+        end
+      elsif node.is_a? N_LET or node.is_a? N_ACTION
+        replaced = node.dup
+        replaced.expr = replace_atoc(node.expr, inhs)
+        res << replaced
+      else
+        res << node
+      end
+    end
+    # warn "=====>:#{res.pretty_inspect}"
+    return res
+  end
+
+  def valid_atoc_name? atoc
+    return true if local_atoc?(atoc)
+    return true if atoc.sym_name == '$'
+    return grammar[atoc.rx].rhs_name_to_sym(atoc.sym_name) ? true : false
+  end
+
+  def valid_atoc? atoc
+    return true if local_atoc?(atoc)
+    return true if atoc.sym_name =~ /^[%#]/
+    rule = grammar[atoc.rx]
+    sym  = atoc.sym_name == '$' ? rule.lhs : rule.rhs_name_to_sym(atoc.sym_name)
+    return true if sym and atoc.sym_name =~ /^[A-Z]/ # term(no check)
+    sym and @attributes[sym] and @attributes[sym].include?(atoc.attr_name)
+  rescue ; warn "ATOC?:#{atoc.pretty_inspect}"; false
+  end
+
+  def rhs_index atoc
+    return nil if local_atoc?(atoc)
+    grammar[atoc.rx].rhs_names.index(atoc.sym_name)
+  end
+
+  def atoc_to_sym atoc
+    return nil                  if local_atoc?(atoc)
+    return $1.to_i              if atoc.sym_name =~ /^%(\d+)$/
+    return grammar[atoc.rx].lhs if atoc.sym_name == '$'
+    grammar[atoc.rx].rhs_name_to_sym(atoc.sym_name) rescue nil
+  end
+
+  def local_atoc? atoc
+    atoc.sym_name == nil
+  end
+
+  def inh_atoc? atoc
+    !local_atoc?(atoc) and atoc.attr_name[0] == ?_
+  end
+
+  def syn_atoc? atoc
+    !local_atoc?(atoc) and atoc.attr_name[0] != ?_
+  end
+
+  def pending_error *args
+    @pending_errors ||= []
+    @pending_errors << g_parser.error_message(*args)
+  end
+
+  def error_exit_if_error_pending
+    @pending_errors and (warn @pending_errors.join("\n") ; exit 1)
+  end
+
+  def debug_info s
+    Depager.debug_mode? and File.open(@debug_output_path, 'a'){|f| f.write s}
+  end
+
+  def generate_rie_decorator_code on_reduce, on_state, action_code
+    on_reduce_code = on_reduce.map{|i| "            #{i||'nil'},\n"}
+    on_state_code  = on_state.map{|i| "            #{i||'nil'},\n"}
+
+    generate_decorator_code(decorator_name, "#{d_parser.parsing_method}::AdvancedParser", %{
+      on_reduce = [\n#{on_reduce_code.join}
+      ]
+      on_state  = [\n#{on_state_code.join}
+      ]
+      Tables = [on_reduce, on_state]
+      RieATTR = Struct.new(:inh, :syn, :local)
+      def initialize inside
+        super inside
+        @on_reduce, @on_state = self.class::Tables
+      end
+      def before_parse
+        after_shift
+      end
+      def after_shift
+        msg = @on_state[stack.last] and send(msg)
+      end
+      def before_reduce
+        stack.last == 0 and after_shift
+        @_rie_reduce_syn = {}
+        mes = @on_reduce[-action_value] and send(mes)
+      end
+      require 'pp'
+      def after_reduce
+        _sstack(-1); stack[-2][decorator_index].syn = @_rie_reduce_syn
+        after_shift
+      end
+      def _sstack n
+        n = n * 2
+        if -n == stack.size + 1
+          @_attr_for_state0 ||= RieATTR[{}, {}, {}]
+        else
+          stack[n][decorator_index] ||= RieATTR[{}, stack[n][1] == :NT ? {} : stack[n][1], {}]
+        end
+      rescue
+        warn "N:\#{n}"
+        raise
+      end
+      \n#{action_code}
+    }) #code
+  end
+%}
+%hook post_lhs /\[/
+%banner '[...]'
+%inner{
+  def do_default
+    master.attributes[g_parser.lhs] = []
+  end
+%}
+%%
+%LEX{
+  /\s+/          { }
+  /[a-zA-Z_]\w*/ { yield token(:ID, $&) }
+  ']'            { yield token(']'); yield token(nil) }
+  /./            { yield token($&) }
+%}
+#begin-rule
+  start:
+      '[' attr_list ']' { master.attributes[g_parser.lhs] = _attr_list }
+  ;
+  attr_list:
+      attr                { [ _attr ] }
+    | attr_list ',' attr
+      {
+        if _attr_list.include? _attr
+          warning "attribute `#{_attr}' reappeared."
+          _attr_list
+        else
+          _attr_list << _attr
+        end
+      }
+  ;
+  attr:
+      ID                  { _ID.value }
+    | ID ':' ID-ec
+      {
+        unless _ID.value[0] == ?_
+          error_exit "EC must be inherited attribute.", _ec.lineno
+        else
+          master.ecs[[g_parser.lhs, _ID.value]] = _ec.value
+        end
+        _ID.value
+      }
+  ;
+#end-rule
+%%
+%hook post_rhs /\{/
+%banner '{...}'
+%inner{
+  attr_accessor :locals
+  def before_parse
+    @nest = 0
+    @locals = {}
+  end
+  def do_default
+    master.semantics[g_parser.rules.size-1] = []
+  end
+  def skip_space
+    begin
+      @line.match(/^[\s\n]+(#[.\n]*)?/) and @line = $'
+      break unless @line.empty?
+    end while @original_line = @line = getline
+  end
+  def getline
+    begin ; line = @file.gets
+    end while line and line =~ /^\s*(#.*)?$/
+    line
+  end
+%}
+%prec{
+  left '.'
+  left ID
+%}
+%%
+%LEX{
+  /#.*/          { }
+  /[ \t]+/       { }
+  /\r?\n/        { yield token(';') }
+  /\s*\(/        { yield token('(', $&) ; skip_space }
+  /\s*\[/        { yield token('[', $&) ; skip_space }
+  /\s*\{/        { yield token('{', $&) ; skip_space ; @nest +=1 }
+  '}'            { yield token('}'); (@nest-=1) == 0 and yield token(nil) }
+  '.'            { yield token('.') ; @_mode = :AFTER_DOT }
+  ','            { yield token(','); @line.match(/[\s\n]*/) and @line = $' } #'
+  '%transfer'    { yield token(:TRANSFER) }
+  '%thread'      { yield token(:THREAD) }
+  '%except'      { yield token(:EXCEPT) }
+  '$.'           { yield token(:ID, '$'); yield token('.') ; @_mode = :AFTER_DOT }
+  /'([^'\\]+|\\.)*'/,
+  /"([^"\\]+|\\.)*"/,
+  /\/([^\/\\]+|\\.)*\//,
+  /(@|$|:)[a-zA-Z_]\w*/,
+  /[a-zA-Z_]\w*[!?]/,
+  /\d+/          { yield token(:RBTOKEN, $&) }
+  /(<=|>=|=>|==|===|!=|and|or)/,
+  /([+!~*\-\/%^<>&|?:]+|\.\.\.?)/
+                 { yield token(:RBTOKEN, $&) ; skip_space }
+  '='            { yield token('=') ; skip_space }
+  /[a-zA-Z_]\w*/
+  {
+    if @_mode != :AFTER_DOT and @locals[$&]
+      yield token(:LID, $&)
+    else
+      @_mode = nil
+      yield token(:ID, $&)
+    end
+  }
+  /./            { yield token($&) }
+%}
+%ACTION{
+  include Depager::RieExtension::Nodes
+%}
+#begin-rule
+  start:
+      '{' stmt_list '}'
+      {
+        basis.locals.clear
+        master.semantics[g_parser.rules.size-1] = _stmt_list.compact
+      }
+  ;
+
+  # stmt
+  stmt_list:
+      stmt
+      {
+        if _stmt.is_a? N_EXCEPT
+          error_exit "invalid %except.", _stmt.lineno
+        end
+        [ _stmt ]
+      }
+    | stmt_list ';' stmt
+      {
+        if _stmt.is_a? N_EXCEPT
+          unless [N_THREAD, N_TRANSFER].include?(_stmt_list.last.class)
+            error_exit "invalid %except.", _stmt.lineno
+          end
+          let_or_ids = _stmt.let_or_ids
+          if let_or_ids.is_a? N_LET
+            _stmt_list.last.excepts << let_or_ids.atoc
+            _stmt_list.insert(_stmt_list.size-1, let_or_ids)
+          else
+            _stmt_list.last.excepts.concat(let_or_ids)
+            _stmt_list
+          end
+        else
+          _stmt ? (_stmt_list << _stmt) : _stmt_list
+        end
+      }
+  ;
+  stmt:
+                            { nil }
+    | THREAD id_list        { N_THREAD[val[0].lineno, _id_list, []] }
+    | TRANSFER id_list      { N_TRANSFER[val[0].lineno, _id_list, []] }
+    | EXCEPT lhs_list       { N_EXCEPT[val[0].lineno, lhs_list] }
+    | EXCEPT lhs '=' rbexpr { N_EXCEPT[val[0].lineno, N_LET[_lhs.lineno, _lhs, _rbexpr]]}
+    | lhs '=' rbexpr        { N_LET[_lhs.lineno, _lhs, _rbexpr] }
+    | LID '=' rbexpr
+      {
+        N_LET[val[0].lineno, N_ATOC[val[0].lineno, nil, _LID.value, g_parser.rules.size-1], _rbexpr]
+      }
+    | ID '=' rbexpr
+      {
+        basis.locals[_ID.value] = true
+        N_LET[val[0].lineno, N_ATOC[val[0].lineno, nil, _ID.value, g_parser.rules.size-1], _rbexpr]
+      }
+    | rbexpr                { N_ACTION[basis.file.lineno, _rbexpr ] }
+  ;
+  # rbexpr
+  rbexpr_list:
+      rbexpr                 { _rbexpr }
+    | rbexpr_list ';'        { _rbexpr_list }
+    | rbexpr_list ';' rbexpr { (_rbexpr_list << ';').concat _rbexpr}
+  ;
+  rbexpr:
+      rbelem                 { _rbelem }
+    | rbexpr rbelem          { _rbexpr.concat _rbelem }
+  ;
+  rbelem:
+      lhs                    { [_lhs] }
+    | ID                     { [_ID.value] }
+    | LID                    { [ N_ATOC[_LID.lineno, nil, _LID.value, g_parser.rules.size-1] ] }
+    | RBTOKEN                { [_RBTOKEN.value] }
+    | '.'                    { ['.'] }
+    | ','                    { [','] }
+    | '[' ']'                { [ val[0].value, ']' ] }
+    | '[' rbexpr_list ']'    { [ val[0].value ].concat(_rbexpr_list) << ']' }
+    | '{' '}'                { [ val[0].value, '}' ]}
+    | '{' rbexpr_list '}'    { [ val[0].value ].concat(_rbexpr_list) << '}' }
+    | '(' ')'                { [ val[0].value, ')' ]}
+    | '(' rbexpr_list ')'    { [ val[0].value ].concat(_rbexpr_list) << ')' }
+  ;
+
+  # lhs
+  lhs_list:
+      lhs              { [ _lhs ]}
+    | lhs_list ',' lhs { lhs_list << lhs }
+  ;
+  lhs:
+      ID '.' ID-attr   { N_ATOC[_ID.lineno, _ID.value, _attr.value, g_parser.rules.size-1] }
+  ;
+  id_list:
+      ID               { [ _ID.value ] }
+    | id_list ',' ID   { _id_list << _ID.value }
+  ;
+#end-rule
+%%