#
# DO NOT MODIFY!!!!
# This file is automatically generated by racc 1.4.5
# from racc grammer file "abnf/parser.y".
#
#
# abnf/parser.rb: generated by racc (runtime embedded)
#
###### racc/parser.rb begin
unless $".index 'racc/parser.rb'
$".push 'racc/parser.rb'

self.class.module_eval <<'..end racc/parser.rb modeval..idc99707eba6', 'racc/parser.rb', 1
#
# $Id: parser.rb,v 1.7 2005/11/20 17:31:32 aamine Exp $
#
# Copyright (c) 1999-2005 Minero Aoki
#
# This program is free software.
# You can distribute/modify this program under the same terms of ruby.
#
# As a special exception, when this code is copied by Racc
# into a Racc output file, you may use that output file
# without restriction.
#

unless defined?(NotImplementedError)
  NotImplementedError = NotImplementError
end

module Racc
  class ParseError < StandardError; end
end
unless defined?(::ParseError)
  ParseError = Racc::ParseError
end

module Racc

  unless defined?(Racc_No_Extentions)
    Racc_No_Extentions = false
  end

  class Parser

    Racc_Runtime_Version = '1.4.5'
    Racc_Runtime_Revision = '$Revision: 1.7 $'.split[1]

    Racc_Runtime_Core_Version_R = '1.4.5'
    Racc_Runtime_Core_Revision_R = '$Revision: 1.7 $'.split[1]
    begin
      require 'racc/cparse'
    # Racc_Runtime_Core_Version_C  = (defined in extention)
      Racc_Runtime_Core_Revision_C = Racc_Runtime_Core_Id_C.split[2]
      unless new.respond_to?(:_racc_do_parse_c, true)
        raise LoadError, 'old cparse.so'
      end
      if Racc_No_Extentions
        raise LoadError, 'selecting ruby version of racc runtime core'
      end

      Racc_Main_Parsing_Routine    = :_racc_do_parse_c
      Racc_YY_Parse_Method         = :_racc_yyparse_c
      Racc_Runtime_Core_Version    = Racc_Runtime_Core_Version_C
      Racc_Runtime_Core_Revision   = Racc_Runtime_Core_Revision_C
      Racc_Runtime_Type            = 'c'
    rescue LoadError
      Racc_Main_Parsing_Routine    = :_racc_do_parse_rb
      Racc_YY_Parse_Method         = :_racc_yyparse_rb
      Racc_Runtime_Core_Version    = Racc_Runtime_Core_Version_R
      Racc_Runtime_Core_Revision   = Racc_Runtime_Core_Revision_R
      Racc_Runtime_Type            = 'ruby'
    end

    def Parser.racc_runtime_type
      Racc_Runtime_Type
    end

    private

    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

    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

    ###
    ### do_parse
    ###

    def do_parse
      __send__(Racc_Main_Parsing_Routine, _racc_setup(), false)
    end

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

    def _racc_do_parse_rb(arg, in_debug)
      action_table, action_check, action_default, action_pointer,
      goto_table,   goto_check,   goto_default,   goto_pointer,
      nt_base,      reduce_table, token_table,    shift_n,
      reduce_n,     use_result,   * = arg

      _racc_init_sysvars
      tok = act = i = nil
      nerr = 0

      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

    ###
    ### yyparse
    ###

    def yyparse(recv, mid)
      __send__(Racc_YY_Parse_Method, recv, mid, _racc_setup(), true)
    end

    def _racc_yyparse_rb(recv, mid, arg, c_debug)
      action_table, action_check, action_default, action_pointer,
      goto_table,   goto_check,   goto_default,   goto_pointer,
      nt_base,      reduce_table, token_table,    shift_n,
      reduce_n,     use_result,   * = arg

      _racc_init_sysvars
      tok = nil
      act = nil
      i = nil
      nerr = 0

      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 not (i = action_pointer[@racc_state[-1]]) or
                not @racc_read_next or
                @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

    ###
    ### common
    ###

    def _racc_evalact(act, arg)
      action_table, action_check, action_default, action_pointer,
      goto_table,   goto_check,   goto_default,   goto_pointer,
      nt_base,      reduce_table, token_table,    shift_n,
      reduce_n,     use_result,   * = 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
        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 $
            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

    def _racc_do_reduce(arg, act)
      action_table, action_check, action_default, action_pointer,
      goto_table,   goto_check,   goto_default,   goto_pointer,
      nt_base,      reduce_table, token_table,    shift_n,
      reduce_n,     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

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

    def yyerror
      throw :racc_jump, 1
    end

    def yyaccept
      throw :racc_jump, 2
    end

    def yyerrok
      @racc_error_status = 0
    end

    #
    # for debugging output
    #

    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

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

    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

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

    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

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

    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

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

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

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

  end

end
..end racc/parser.rb modeval..idc99707eba6
end
###### racc/parser.rb end



require 'abnf/grammar'

class ABNF
  def ABNF.parse(desc, dont_merge_core_rules=false)
    grammar = ABNF.new
    Parser.new(grammar).parse(desc)
    grammar.merge(CoreRules) unless dont_merge_core_rules
    grammar
  end


class Parser < Racc::Parser

module_eval <<'..end abnf/parser.y modeval..ida44c0bccf6', 'abnf/parser.y', 48

  def initialize(grammar)
    @grammar = grammar
  end

  def parse(input)
    @input = input
    yyparse self, :scan
  end

  def scan
    prev = nil
    scan1 {|toktype, tokval|
      if prev
	if prev[0] == :name && toktype == :assign
	  yield [:defname, prev[1]]
	else
	  yield prev
	end
      end
      prev = [toktype, tokval]
    }
    yield prev
  end

  def scan1
    @input.each_line {|line|
      until line.empty?
        case line
	when /\A[ \t\r\n]+/
	  t = $&
	when /\A;/
	  t = line
	when /\A[A-Za-z][A-Za-z0-9\-_]*/ # _ is not permitted by ABNF
	  yield :name, (t = $&).downcase.intern
	when /\A=\/?/
	  yield :assign, (t = $&) # | is not permitted by ABNF
	when /\A[\/|]/
	  yield :altop, (t = $&)
	when /\A\*/
	  yield :repop, (t = $&)
	when /\A\(/
	  yield :lparen, (t = $&)
	when /\A\)/
	  yield :rparen, (t = $&)
	when /\A\[/
	  yield :lbracket, (t = $&)
	when /\A\]/
	  yield :rbracket, (t = $&)
	when /\A\d+/
	  yield :int, (t = $&).to_i
	when /\A"([ !#-~]*)"/
	  es = []
	  (t = $&)[1...-1].each_byte {|b|
	    case b
	    when 0x41..0x5a # ?A..?Z
	      b2 = b - 0x41 + 0x61 # ?A + ?a
	      es << Term.new(NatSet.new(b, b2))
	    when 0x61..0x7a # ?a..?z
	      b2 = b - 0x61 + 0x41 # ?a + ?A
	      es << Term.new(NatSet.new(b, b2))
	    else
	      es << Term.new(NatSet.new(b))
	    end
	  }
	  yield :val, Seq.new(*es)
	when /\A%b([01]+)-([01]+)/
	  t = $&
	  yield :val, Term.new(NatSet.new($1.to_i(2)..$2.to_i(2)))
	when /\A%b[01]+(?:\.[01]+)*/
	  es = []
	  (t = $&).scan(/[0-1]+/) {|v|
	    es << Term.new(NatSet.new(v.to_i(2)))
	  }
	  yield :val, Seq.new(*es)
	when /\A%d([0-9]+)-([0-9]+)/
	  t = $&
	  yield :val, Term.new(NatSet.new($1.to_i..$2.to_i))
	when /\A%d[0-9]+(?:\.[0-9]+)*/
	  es = []
	  (t = $&).scan(/[0-9]+/) {|v|
	    es << Term.new(NatSet.new(v.to_i))
	  }
	  yield :val, Seq.new(*es)
	when /\A%x([0-9A-Fa-f]+)-([0-9A-Fa-f]+)/
	  t = $&
	  yield :val, Term.new(NatSet.new($1.hex..$2.hex))
	when /\A%x[0-9A-Fa-f]+(?:\.[0-9A-Fa-f]+)*/
	  es = []
	  (t = $&).scan(/[0-9A-Fa-f]+/) {|v|
	    es << Term.new(NatSet.new(v.hex))
	  }
	  yield :val, Seq.new(*es)
	when /\A<([\x20-\x3D\x3F-\x7E]*)>/
	  raise ScanError.new("prose-val is not supported: #{$&}")
	else
	  raise ScanError.new(line)
	end
	line[0, t.length] = ''
      end
    }
    yield false, false
  end

  class ScanError < StandardError
  end

..end abnf/parser.y modeval..ida44c0bccf6

##### racc 1.4.5 generates ###

racc_reduce_table = [
 0, 0, :racc_error,
 0, 14, :_reduce_1,
 2, 14, :_reduce_2,
 3, 15, :_reduce_3,
 1, 16, :_reduce_none,
 3, 16, :_reduce_5,
 1, 17, :_reduce_none,
 2, 17, :_reduce_7,
 1, 18, :_reduce_none,
 2, 18, :_reduce_9,
 1, 20, :_reduce_10,
 2, 20, :_reduce_11,
 1, 20, :_reduce_12,
 2, 20, :_reduce_13,
 3, 20, :_reduce_14,
 1, 19, :_reduce_15,
 3, 19, :_reduce_16,
 3, 19, :_reduce_17,
 1, 19, :_reduce_none ]

racc_reduce_n = 19

racc_shift_n = 29

racc_action_table = [
     8,    10,    12,    14,    19,    17,     2,     7,     3,     6,
    18,    28,     8,    10,    12,    14,    26,    17,    19,     7,
     8,    10,    12,    14,     5,    17,    20,     7,     8,    10,
    12,    14,   nil,    17,   nil,     7,     8,    10,    12,    14,
   nil,    17,   nil,     7,     8,    10,    12,    14,   nil,    17,
   nil,     7,    12,    14,    19,    17,   nil,     7,   nil,    27 ]

racc_action_check = [
    25,    25,    25,    25,    24,    25,     1,    25,     1,     3,
     8,    24,    19,    19,    19,    19,    20,    19,     9,    19,
     6,     6,     6,     6,     2,     6,    10,     6,    17,    17,
    17,    17,   nil,    17,   nil,    17,    11,    11,    11,    11,
   nil,    11,   nil,    11,    14,    14,    14,    14,   nil,    14,
   nil,    14,    16,    16,    22,    16,   nil,    16,   nil,    22 ]

racc_action_pointer = [
   nil,     6,    24,     6,   nil,   nil,    15,   nil,     4,    14,
    21,    31,   nil,   nil,    39,   nil,    45,    23,   nil,     7,
    10,   nil,    50,   nil,     0,    -5,   nil,   nil,   nil ]

racc_action_default = [
    -1,   -19,   -19,   -19,    -2,    29,   -19,   -18,   -10,    -3,
   -12,    -4,   -15,    -6,   -19,    -8,   -19,   -19,   -11,   -19,
   -13,    -7,   -19,    -9,   -19,    -5,   -14,   -16,   -17 ]

racc_goto_table = [
    21,     9,    25,     1,     4,    23,   nil,   nil,   nil,    22,
   nil,   nil,    24,   nil,    21 ]

racc_goto_check = [
     5,     3,     4,     1,     2,     6,   nil,   nil,   nil,     3,
   nil,   nil,     3,   nil,     5 ]

racc_goto_pointer = [
   nil,     3,     3,    -5,   -17,   -11,   -11,   nil ]

racc_goto_default = [
   nil,   nil,   nil,   nil,    11,    13,    15,    16 ]

racc_token_table = {
 false => 0,
 Object.new => 1,
 :defname => 2,
 :assign => 3,
 :altop => 4,
 :repop => 5,
 :int => 6,
 :name => 7,
 :lparen => 8,
 :rparen => 9,
 :lbracket => 10,
 :rbracket => 11,
 :val => 12 }

racc_use_result_var = true

racc_nt_base = 13

Racc_arg = [
 racc_action_table,
 racc_action_check,
 racc_action_default,
 racc_action_pointer,
 racc_goto_table,
 racc_goto_check,
 racc_goto_default,
 racc_goto_pointer,
 racc_nt_base,
 racc_reduce_table,
 racc_token_table,
 racc_shift_n,
 racc_reduce_n,
 racc_use_result_var ]

Racc_token_to_s_table = [
'$end',
'error',
'defname',
'assign',
'altop',
'repop',
'int',
'name',
'lparen',
'rparen',
'lbracket',
'rbracket',
'val',
'$start',
'rulelist',
'rule',
'alt',
'seq',
'rep',
'element',
'repeat']

Racc_debug_parser = false

##### racc system variables end #####

 # reduce 0 omitted

module_eval <<'.,.,', 'abnf/parser.y', 3
  def _reduce_1( val, _values, result )
 result = nil
   result
  end
.,.,

module_eval <<'.,.,', 'abnf/parser.y', 10
  def _reduce_2( val, _values, result )
				  name = val[1][0]
				  rhs = val[1][1]
				  @grammar.add(name, rhs)
		                  result ||= name
   result
  end
.,.,

module_eval <<'.,.,', 'abnf/parser.y', 11
  def _reduce_3( val, _values, result )
 result = [val[0], val[2]]
   result
  end
.,.,

 # reduce 4 omitted

module_eval <<'.,.,', 'abnf/parser.y', 14
  def _reduce_5( val, _values, result )
 result = val[0] | val[2]
   result
  end
.,.,

 # reduce 6 omitted

module_eval <<'.,.,', 'abnf/parser.y', 17
  def _reduce_7( val, _values, result )
 result = val[0] + val[1]
   result
  end
.,.,

 # reduce 8 omitted

module_eval <<'.,.,', 'abnf/parser.y', 20
  def _reduce_9( val, _values, result )
 result = val[1].rep(*val[0])
   result
  end
.,.,

module_eval <<'.,.,', 'abnf/parser.y', 22
  def _reduce_10( val, _values, result )
 result = [0, nil]
   result
  end
.,.,

module_eval <<'.,.,', 'abnf/parser.y', 23
  def _reduce_11( val, _values, result )
 result = [0, val[1]]
   result
  end
.,.,

module_eval <<'.,.,', 'abnf/parser.y', 24
  def _reduce_12( val, _values, result )
 result = [val[0], val[0]]
   result
  end
.,.,

module_eval <<'.,.,', 'abnf/parser.y', 25
  def _reduce_13( val, _values, result )
 result = [val[0], nil]
   result
  end
.,.,

module_eval <<'.,.,', 'abnf/parser.y', 26
  def _reduce_14( val, _values, result )
 result = [val[0], val[2]]
   result
  end
.,.,

module_eval <<'.,.,', 'abnf/parser.y', 28
  def _reduce_15( val, _values, result )
 result = Var.new(val[0])
   result
  end
.,.,

module_eval <<'.,.,', 'abnf/parser.y', 29
  def _reduce_16( val, _values, result )
 result = val[1]
   result
  end
.,.,

module_eval <<'.,.,', 'abnf/parser.y', 30
  def _reduce_17( val, _values, result )
 result = val[1].rep(0, 1)
   result
  end
.,.,

 # reduce 18 omitted

 def _reduce_none( val, _values, result )
  result
 end

end   # class Parser

end