Class: Antlr4ruby::ATNDeserializer

Inherits:

Object

• Object
• Antlr4ruby::ATNDeserializer

Defined in:

lib/antlr4ruby/atn/atn_deserializer.rb

Constant Summary

SERIALIZED_VERSION =

4

Instance Method Summary

• #deserialize(data) ⇒ Object
• #initialize(options = ATNDeserializationOptions.get_default_options) ⇒ ATNDeserializer constructor

  A new instance of ATNDeserializer.

Constructor Details

#initialize(options = ATNDeserializationOptions.get_default_options) ⇒ ATNDeserializer

Returns a new instance of ATNDeserializer.

# File 'lib/antlr4ruby/atn/atn_deserializer.rb', line 20

def initialize(options = ATNDeserializationOptions.get_default_options)
  @deserialization_options = options
end

Instance Method Details

#deserialize(data) ⇒ Object

# File 'lib/antlr4ruby/atn/atn_deserializer.rb', line 24

def deserialize(data)
  # data[0] 是版本号
  version = data[0]
  raise "Could not deserialize ATN with version #{version} (expected #{SERIALIZED_VERSION})." if version != SERIALIZED_VERSION
  # data[1] 是类型，0表示 lexer，1 表示 parser
  grammar_type = data[1] == 0 ? :LEXER : :PARSER
  atn = ATN.new(grammar_type, data[2])



  p = 3
  loop_back_state_numbers = []
  end_state_numbers = []
  n_states = data[p]; p += 1
  n_states.times do |i|
    s_type = data[p]; p += 1
    if s_type == ATNState::INVALID_TYPE
      atn.add_state(nil)
      next
    end

    rule_index = data[p]; p += 1
    s = state_factory(s_type, rule_index)

    if s_type == ATNState::LOOP_END
      loop_back_state_number = data[p]; p += 1
      loop_back_state_numbers << Pair.new(s, loop_back_state_number)
    elsif s.instance_of?(BlockStartState)
      end_state_number = data[p]; p += 1
      end_state_numbers << Pair.new(s, end_state_number)
    end

    atn.add_state(s)
  end

  loop_back_state_numbers.each { |pair|  pair.first.loop_back_state = atn.states[pair.second] }
  end_state_numbers.each { |pair| pair.first.end_state = atn.states[pair.second] }

  num_non_greedy_states = data[p]; p += 1
  num_non_greedy_states.times do |i|
    state_number = data[p]; p += 1
    atn.states[state_number].non_greedy = true
  end

  num_precedence_states = data[p]; p += 1
  num_non_greedy_states.times do |i|
    state_number = data[p]; p += 1
    atn.states[state_number].is_left_recursive_rule = true
  end

  n_rules = data[p]; p += 1
  atn.rule_to_token_type = Array.new(n_rules, 0) if atn.grammar_type == :LEXER

  atn.rule_to_start_state = Array.new(n_rules)
  n_rules.times do |i|
    s = data[p]; p += 1
    start_state = atn.states[s]
    atn.rule_to_start_state[i] = start_state
    if atn.grammar_type == :LEXER
      token_type = data[p]; p += 1
      atn.rule_to_token_type[i] = token_type
    end
  end

  atn.rule_to_stop_state = Array.new(n_rules)
  atn.states.each do |state|
    next unless state.instance_of?(RuleStartState)
    atn.rule_to_stop_state[state.rule_index] = state
    atn.rule_to_start_state[state.rule_index] = state
  end

  n_modes = data[p]; p += 1
  n_modes.times do |i|
    s = data[p]; p += 1
    atn.mode_to_start_state << atn.states[s]
  end

  sets = []
  p = deserialize_sets(data, p, sets)

  n_edges = data[p]; p += 1
  n_edges.times do |i|
    src, trg, token_type, arg1, arg2, arg3 =
      data[p], data[p+1], data[p+2], data[p+3], data[p+4], data[p+5]

    trans = edge_factory(atn, token_type, src, trg, arg1, arg2, arg3, sets)
    src_state = atn.states[src]
    src_state.add_transition(trans)
    p += 6
  end

  atn.states.each do |state|
    state.get_number_of_transitions.times do |i|
      t = state.get_transition(i)
      next unless t.instance_of?(RuleTransition)
      outermost_precedence_return = -1
      if t && atn.rule_to_start_state[t.target.rule_index].is_left_recursive_rule
        outermost_precedence_return = t.target.rule_index if t.precedence == 0
      end

      return_transition = EpsilonTransition.new(t.follow_state, outermost_precedence_return)
      atn.rule_to_stop_state[t.target.rule_index].add_transition(return_transition)
    end
  end

  atn.states.each do |state|
    if state.instance_of?(BlockStartState)
      raise "illegal state." if ! state.end_state || state.end_state.start_state

      state.end_state.start_state = state
    end

    if state.instance_of?(PlusLoopbackState)
      loop_back_state = state
      loop_back_state.get_number_of_transitions.times do |i|
        target = loop_back_state.get_transition(i).target
        target.loop_back_state = loop_back_state if target.instance_of?(PlusBlockStartState)
      end

    elsif state.instance_of?(StarLoopbackState)
      loop_back_state = state
      loop_back_state.get_number_of_transitions.times do |i|
        target = loop_back_state.get_transition(i).target
        target.loop_back_state = loop_back_state if target.instance_of?(StarLoopbackState)
      end
    end

  end

  n_decisions = data[p]; p += 1
  n_decisions.times do |i|
    s = data[p]; p += 1
    dec_state = atn.states[s]
    atn.decision_to_state << dec_state
    dec_state.decision = i-1
  end

  if atn.grammar_type == :LEXER
    len = data[p]; p += 1
    atn.lexer_actions = Array.new(len)

    atn.lexer_actions.length.times do |i|
      t = data[p]; p += 1
      action_type = [:CHANNEL, :CUSTOM, :MODE, :MORE, :POP_MODE, :PUSH_MODE, :SKIP, :TYPE].at(t)
      data1 = data[p]; p += 1
      data2 = data[p]; p += 1
      lexer_action = lexer_action_factory(action_type, data1, data2)

      atn.lexer_actions[i] = lexer_action
    end
  end

  mark_precedence_decisions(atn)

  verify_atn(atn) if deserialization_options.is_verify_atn?

  if deserialization_options.is_generate_rule_bypass_transitions? && atn.grammar_type == :PARSER
    atn.rule_to_token_type = Array.new(atn.rule_to_start_state.length)
    atn.rule_to_start_state.length.times do |i|
      atn.rule_to_token_type[i] = atn.max_token_type + i + 1
    end

    atn.rule_to_start_state.length.times do |i|
      bypass_start = BasicBlockStartState.new
      bypass_start.rule_index = i
      atn.add_state(bypass_start)

      bypass_stop = BlockEndState.new
      bypass_stop.rule_index = i
      atn.add_state(bypass_stop)

      bypass_start.end_state = bypass_stop
      atn.define_decision_state(bypass_start)

      bypass_stop.start_state = bypass_start

      exclude_transition = nil
      end_state = nil
      if atn.rule_to_start_state[i].is_left_recursive_rule
        # end_state = nil
        atn.states.each do |state|
          next if state.rule_index != i
          next unless state.instance_of?(StarLoopEntryState)
          maybe_loop_end_state = state.get_transition(state.get_number_of_transitions-1).target
          next unless maybe_loop_end_state.instance_of?(LoopEndState)

          if maybe_loop_end_state.epsilon_only_transitions && maybe_loop_end_state.get_transition(0).target.instance_of?(RuleStopState)
            end_state = state
            break
          end

        end

        raise "" unless  end_state
        exclude_transition = end_state.loop_back_state.get_transition(0)
      else
        end_state = atn.rule_to_stop_state[i]
      end


      atn.states.each { |state|
        state.transitions.each { |transition|
          next if transition == exclude_transition
          transition.target = bypass_stop if transition.target == end_state
        }
      }

      while atn.rule_to_start_state[i].get_number_of_transitions > 0
        transition = atn.rule_to_start_state[i].remove_transition(atn.rule_to_start_state[i].get_number_of_transitions-1)
        bypass_start.add_transition(transition)
      end

      atn.rule_to_start_state[i].add_transition(EpsilonTransition.new(bypass_start))
      bypass_stop.add_transition(EpsilonTransition.new(end_state))

      match_state = BasicState.new
      atn.add_state(match_state)
      match_state.add_transition(AtomTransition.new(bypass_stop, atn.rule_to_token_type[i]))
      bypass_start.add_transition(EpsilonTransition(match_state))
    end

    verify_atn(atn) if deserialization_options.is_verify_atn?
  end

  atn
end