123456789_123456789_123456789_123456789_123456789_

Class: Racc::Parser

Relationships & Source Files
Extension / Inclusion / Inheritance Descendants
Subclasses:
Inherits: Object
Defined in: lib/rdoc/rd/block_parser.rb,
lib/rdoc/rd/inline_parser.rb

Constant Summary

Class Method Summary

  • .racc_runtime_type Internal use only

    See additional method definition at file lib/rdoc/rd/block_parser.rb line 235.

Instance Method Summary

Class Method Details

.racc_runtime_type

This method is for internal use only.

See additional method definition at file lib/rdoc/rd/block_parser.rb line 235.

[ GitHub ]

  
# File 'lib/rdoc/rd/inline_parser.rb', line 235

def Parser.racc_runtime_type # :nodoc:
  Racc_Runtime_Type
end

Instance Method Details

#_racc_do_parse_rb(arg, in_debug)

See additional method definition at file lib/rdoc/rd/block_parser.rb line 298.

[ GitHub ]

  
# File 'lib/rdoc/rd/inline_parser.rb', line 298

def _racc_do_parse_rb(arg, in_debug)
  action_table, action_check, action_default, action_pointer,
  _,            _,            _,              _,
  _,            _,            token_table,    * = arg

  _racc_init_sysvars
  tok = act = i = nil

  catch(:racc_end_parse) {
    while true
      if i = action_pointer[@racc_state[-1]]
        if @racc_read_next
          if @racc_t != 0   # not EOF
            tok, @racc_val = next_token()
            unless tok      # EOF
              @racc_t = 0
            else
              @racc_t = (token_table[tok] or 1)   # error token
            end
            racc_read_token(@racc_t, tok, @racc_val) if @yydebug
            @racc_read_next = false
          end
        end
        i += @racc_t
        unless i >= 0 and
               act = action_table[i] and
               action_check[i] == @racc_state[-1]
          act = action_default[@racc_state[-1]]
        end
      else
        act = action_default[@racc_state[-1]]
      end
      while act = _racc_evalact(act, arg)
        ;
      end
    end
  }
end

#_racc_do_reduce(arg, act)

See additional method definition at file lib/rdoc/rd/block_parser.rb line 498.

[ GitHub ]

  
# File 'lib/rdoc/rd/inline_parser.rb', line 498

def _racc_do_reduce(arg, act)
  _,          _,            _,            _,
  goto_table, goto_check,   goto_default, goto_pointer,
  nt_base,    reduce_table, _,            _,
  _,          use_result,   * = arg

  state = @racc_state
  vstack = @racc_vstack
  tstack = @racc_tstack

  i = act * -3
  len       = reduce_table[i]
  reduce_to = reduce_table[i+1]
  method_id = reduce_table[i+2]
  void_array = []

  tmp_t = tstack[-len, len] if @yydebug
  tmp_v = vstack[-len, len]
  tstack[-len, len] = void_array if @yydebug
  vstack[-len, len] = void_array
  state[-len, len]  = void_array

  # tstack must be updated AFTER method call
  if use_result
    vstack.push __send__(method_id, tmp_v, vstack, tmp_v[0])
  else
    vstack.push __send__(method_id, tmp_v, vstack)
  end
  tstack.push reduce_to

  racc_reduce(tmp_t, reduce_to, tstack, vstack) if @yydebug

  k1 = reduce_to - nt_base
  if i = goto_pointer[k1]
    i += state[-1]
    if i >= 0 and (curstate = goto_table[i]) and goto_check[i] == k1
      return curstate
    end
  end
  goto_default[k1]
end

#_racc_evalact(act, arg)

common

See additional method definition at file lib/rdoc/rd/block_parser.rb line 401.

[ GitHub ]

  
# File 'lib/rdoc/rd/inline_parser.rb', line 401

def _racc_evalact(act, arg)
  action_table, action_check, _, action_pointer,
  _,            _,            _, _,
  _,            _,            _, shift_n,
  reduce_n,     * = arg
  nerr = 0   # tmp

  if act > 0 and act < shift_n
    #
    # shift
    #
    if @racc_error_status > 0
      @racc_error_status -= 1 unless @racc_t <= 1 # error token or EOF
    end
    @racc_vstack.push @racc_val
    @racc_state.push act
    @racc_read_next = true
    if @yydebug
      @racc_tstack.push @racc_t
      racc_shift @racc_t, @racc_tstack, @racc_vstack
    end

  elsif act < 0 and act > -reduce_n
    #
    # reduce
    #
    code = catch(:racc_jump) {
      @racc_state.push _racc_do_reduce(arg, act)
      false
    }
    if code
      case code
      when 1 # yyerror
        @racc_user_yyerror = true   # user_yyerror
        return -reduce_n
      when 2 # yyaccept
        return shift_n
      else
        raise '[Racc Bug] unknown jump code'
      end
    end

  elsif act == shift_n
    #
    # accept
    #
    racc_accept if @yydebug
    throw :racc_end_parse, @racc_vstack[0]

  elsif act == -reduce_n
    #
    # error
    #
    case @racc_error_status
    when 0
      unless arg[21]    # user_yyerror
        nerr += 1
        on_error @racc_t, @racc_val, @racc_vstack
      end
    when 3
      if @racc_t == 0   # is $
        # We're at EOF, and another error occurred immediately after
        # attempting auto-recovery
        throw :racc_end_parse, nil
      end
      @racc_read_next = true
    end
    @racc_user_yyerror = false
    @racc_error_status = 3
    while true
      if i = action_pointer[@racc_state[-1]]
        i += 1   # error token
        if  i >= 0 and
            (act = action_table[i]) and
            action_check[i] == @racc_state[-1]
          break
        end
      end
      throw :racc_end_parse, nil if @racc_state.size <= 1
      @racc_state.pop
      @racc_vstack.pop
      if @yydebug
        @racc_tstack.pop
        racc_e_pop @racc_state, @racc_tstack, @racc_vstack
      end
    end
    return act

  else
    raise "[Racc Bug] unknown action #{act.inspect}"
  end

  racc_next_state(@racc_state[-1], @racc_state) if @yydebug

  nil
end

#_racc_init_sysvars

See additional method definition at file lib/rdoc/rd/block_parser.rb line 251.

[ GitHub ]

  
# File 'lib/rdoc/rd/inline_parser.rb', line 251

def _racc_init_sysvars
  @racc_state  = [0]
  @racc_tstack = []
  @racc_vstack = []

  @racc_t = nil
  @racc_val = nil

  @racc_read_next = true

  @racc_user_yyerror = false
  @racc_error_status = 0
end

#_racc_setup

See additional method definition at file lib/rdoc/rd/block_parser.rb line 239.

[ GitHub ]

  
# File 'lib/rdoc/rd/inline_parser.rb', line 239

def _racc_setup
  @yydebug = false unless self.class::Racc_debug_parser
  @yydebug = false unless defined?(@yydebug)
  if @yydebug
    @racc_debug_out = $stderr unless defined?(@racc_debug_out)
    @racc_debug_out ||= $stderr
  end
  arg = self.class::Racc_arg
  arg[13] = true if arg.size < 14
  arg
end

#_racc_yyparse_rb(recv, mid, arg, c_debug)

See additional method definition at file lib/rdoc/rd/block_parser.rb line 348.

[ GitHub ]

  
# File 'lib/rdoc/rd/inline_parser.rb', line 348

def _racc_yyparse_rb(recv, mid, arg, c_debug)
  action_table, action_check, action_default, action_pointer,
  _,            _,            _,              _,
  _,            _,            token_table,    * = arg

  _racc_init_sysvars

  catch(:racc_end_parse) {
    until i = action_pointer[@racc_state[-1]]
      while act = _racc_evalact(action_default[@racc_state[-1]], arg)
        ;
      end
    end
    recv.__send__(mid) do |tok, val|
      unless tok
        @racc_t = 0
      else
        @racc_t = (token_table[tok] or 1)   # error token
      end
      @racc_val = val
      @racc_read_next = false

      i += @racc_t
      unless i >= 0 and
             act = action_table[i] and
             action_check[i] == @racc_state[-1]
        act = action_default[@racc_state[-1]]
      end
      while act = _racc_evalact(act, arg)
        ;
      end

      while !(i = action_pointer[@racc_state[-1]]) ||
            ! @racc_read_next ||
            @racc_t == 0  # $
        unless i and i += @racc_t and
               i >= 0 and
               act = action_table[i] and
               action_check[i] == @racc_state[-1]
          act = action_default[@racc_state[-1]]
        end
        while act = _racc_evalact(act, arg)
          ;
        end
      end
    end
  }
end

#next_token

The method to fetch next token. If you use #do_parse method, you must implement #next_token.

The format of return value is [TOKEN_SYMBOL, VALUE]. token-symbol is represented by Ruby’s symbol by default, e.g. :IDENT for ‘IDENT’. “;” (String) for ‘;’.

The final symbol (End of file) must be false.

See additional method definition at file lib/rdoc/rd/block_parser.rb line 294.

Raises:

  • (NotImplementedError)
[ GitHub ]

  
# File 'lib/rdoc/rd/inline_parser.rb', line 294

def next_token
  raise NotImplementedError, "#{self.class}\#next_token is not defined"
end

#on_error(t, val, vstack)

This method is called when a parse error is found.

ERROR_TOKEN_ID is an internal ID of token which caused error. You can get string representation of this ID by calling #token_to_str.

ERROR_VALUE is a value of error token.

value_stack is a stack of symbol values. DO NOT MODIFY this object.

This method raises ParseError by default.

If this method returns, parsers enter “error recovering mode”.

See additional method definition at file lib/rdoc/rd/block_parser.rb line 554.

Raises:

[ GitHub ]

  
# File 'lib/rdoc/rd/inline_parser.rb', line 554

def on_error(t, val, vstack)
  raise ParseError, sprintf("parse error on value %s (%s)",
                            val.inspect, token_to_str(t) || '?')
end

#racc_accept

See additional method definition at file lib/rdoc/rd/block_parser.rb line 603.

[ GitHub ]

  
# File 'lib/rdoc/rd/inline_parser.rb', line 603

def racc_accept
  @racc_debug_out.puts 'accept'
  @racc_debug_out.puts
end

#racc_e_pop(state, tstack, vstack)

See additional method definition at file lib/rdoc/rd/block_parser.rb line 608.

[ GitHub ]

  
# File 'lib/rdoc/rd/inline_parser.rb', line 608

def racc_e_pop(state, tstack, vstack)
  @racc_debug_out.puts 'error recovering mode: pop token'
  racc_print_states state
  racc_print_stacks tstack, vstack
  @racc_debug_out.puts
end

#racc_next_state(curstate, state)

See additional method definition at file lib/rdoc/rd/block_parser.rb line 615.

[ GitHub ]

  
# File 'lib/rdoc/rd/inline_parser.rb', line 615

def racc_next_state(curstate, state)
  @racc_debug_out.puts  "goto    #{curstate}"
  racc_print_states state
  @racc_debug_out.puts
end

#racc_print_stacks(t, v)

See additional method definition at file lib/rdoc/rd/block_parser.rb line 621.

[ GitHub ]

  
# File 'lib/rdoc/rd/inline_parser.rb', line 621

def racc_print_stacks(t, v)
  out = @racc_debug_out
  out.print '        ['
  t.each_index do |i|
    out.print ' (', racc_token2str(t[i]), ' ', v[i].inspect, ')'
  end
  out.puts ' ]'
end

#racc_print_states(s)

See additional method definition at file lib/rdoc/rd/block_parser.rb line 630.

[ GitHub ]

  
# File 'lib/rdoc/rd/inline_parser.rb', line 630

def racc_print_states(s)
  out = @racc_debug_out
  out.print '        ['
  s.each {|st| out.print ' ', st }
  out.puts ' ]'
end

#racc_read_token(t, tok, val)

For debugging output

See additional method definition at file lib/rdoc/rd/block_parser.rb line 577.

[ GitHub ]

  
# File 'lib/rdoc/rd/inline_parser.rb', line 577

def racc_read_token(t, tok, val)
  @racc_debug_out.print 'read    '
  @racc_debug_out.print tok.inspect, '(', racc_token2str(t), ') '
  @racc_debug_out.puts val.inspect
  @racc_debug_out.puts
end

#racc_reduce(toks, sim, tstack, vstack)

See additional method definition at file lib/rdoc/rd/block_parser.rb line 590.

[ GitHub ]

  
# File 'lib/rdoc/rd/inline_parser.rb', line 590

def racc_reduce(toks, sim, tstack, vstack)
  out = @racc_debug_out
  out.print 'reduce '
  if toks.empty?
    out.print ' <none>'
  else
    toks.each {|t| out.print ' ', racc_token2str(t) }
  end
  out.puts " --> #{racc_token2str(sim)}"
  racc_print_stacks tstack, vstack
  @racc_debug_out.puts
end

#racc_shift(tok, tstack, vstack)

See additional method definition at file lib/rdoc/rd/block_parser.rb line 584.

[ GitHub ]

  
# File 'lib/rdoc/rd/inline_parser.rb', line 584

def racc_shift(tok, tstack, vstack)
  @racc_debug_out.puts "shift   #{racc_token2str tok}"
  racc_print_stacks tstack, vstack
  @racc_debug_out.puts
end

#racc_token2str(tok)

See additional method definition at file lib/rdoc/rd/block_parser.rb line 637.

[ GitHub ]

  
# File 'lib/rdoc/rd/inline_parser.rb', line 637

def racc_token2str(tok)
  self.class::Racc_token_to_s_table[tok] or
      raise "[Racc Bug] can't convert token #{tok} to string"
end

#token_to_str(t)

Convert internal ID of token symbol to the string.

See additional method definition at file lib/rdoc/rd/block_parser.rb line 643.

[ GitHub ]

  
# File 'lib/rdoc/rd/inline_parser.rb', line 643

def token_to_str(t)
  self.class::Racc_token_to_s_table[t]
end

#yyaccept

Exit parser. Return value is 0.

See additional method definition at file lib/rdoc/rd/block_parser.rb line 567.

[ GitHub ]

  
# File 'lib/rdoc/rd/inline_parser.rb', line 567

def yyaccept
  throw :racc_jump, 2
end

#yyerrok

Leave error recovering mode.

See additional method definition at file lib/rdoc/rd/block_parser.rb line 572.

[ GitHub ]

  
# File 'lib/rdoc/rd/inline_parser.rb', line 572

def yyerrok
  @racc_error_status = 0
end

#yyerror

Enter error recovering mode. This method does not call #on_error.

See additional method definition at file lib/rdoc/rd/block_parser.rb line 561.

[ GitHub ]

  
# File 'lib/rdoc/rd/inline_parser.rb', line 561

def yyerror
  throw :racc_jump, 1
end