AnonymousFox

//proc/self/root/opt/alt/ruby32/share/ruby/racc/grammar.rb

#--
#
#
#
# Copyright (c) 1999-2006 Minero Aoki
#
# This program is free software.
# You can distribute/modify this program under the same terms of ruby.
# see the file "COPYING".
#
#++

require 'racc/compat'
require 'racc/iset'
require 'racc/sourcetext'
require 'racc/logfilegenerator'
require 'racc/exception'
require 'forwardable'

module Racc

class Grammar

def initialize(debug_flags = DebugFlags.new)
      @symboltable = SymbolTable.new
      @debug_symbol = debug_flags.token
      @rules   = []  # :: [Rule]
      @start   = nil
      @n_expected_srconflicts = nil
      @prec_table = []
      @prec_table_closed = false
      @closed = false
      @states = nil
    end

attr_reader :start
    attr_reader :symboltable
    attr_accessor :n_expected_srconflicts

def [](x)
      @rules[x]
    end

def each_rule(&block)
      @rules.each(&block)
    end

alias each each_rule

def each_index(&block)
      @rules.each_index(&block)
    end

def each_with_index(&block)
      @rules.each_with_index(&block)
    end

def size
      @rules.size
    end

def to_s
      "<Racc::Grammar>"
    end

extend Forwardable

def_delegator "@symboltable", :each, :each_symbol
    def_delegator "@symboltable", :each_terminal
    def_delegator "@symboltable", :each_nonterminal

def intern(value, dummy = false)
      @symboltable.intern(value, dummy)
    end

def symbols
      @symboltable.symbols
    end

def nonterminal_base
      @symboltable.nt_base
    end

def useless_nonterminal_exist?
      n_useless_nonterminals() != 0
    end

def n_useless_nonterminals
      @n_useless_nonterminals ||= each_useless_nonterminal.count
    end

def each_useless_nonterminal
      return to_enum __method__ unless block_given?

@symboltable.each_nonterminal do |sym|
        yield sym if sym.useless?
      end
    end

def useless_rule_exist?
      n_useless_rules() != 0
    end

def n_useless_rules
      @n_useless_rules ||= each_useless_rule.count
    end

def each_useless_rule
      return to_enum __method__ unless block_given?

each do |r|
        yield r if r.useless?
      end
    end

def nfa
      (@states ||= States.new(self)).nfa
    end

def dfa
      (@states ||= States.new(self)).dfa
    end

alias states dfa

def state_transition_table
      states().state_transition_table
    end

def parser_class
      states = states()   # cache
      if $DEBUG
        srcfilename = caller(1).first.slice(/\A(.*?):/, 1)
        begin
          write_log srcfilename + ".output"
        rescue SystemCallError
        end
        report = lambda {|s| $stderr.puts "racc: #{srcfilename}: #{s}" }
        if states.should_report_srconflict?
          report["#{states.n_srconflicts} shift/reduce conflicts"]
        end
        if states.rrconflict_exist?
          report["#{states.n_rrconflicts} reduce/reduce conflicts"]
        end
        g = states.grammar
        if g.useless_nonterminal_exist?
          report["#{g.n_useless_nonterminals} useless nonterminals"]
        end
        if g.useless_rule_exist?
          report["#{g.n_useless_rules} useless rules"]
        end
      end
      states.state_transition_table.parser_class
    end

def write_log(path)
      File.open(path, 'w') {|f|
        LogFileGenerator.new(states()).output f
      }
    end

#
    # Grammar Definition Interface
    #

def add(rule)
      raise ArgumentError, "rule added after the Grammar closed" if @closed
      @rules.push rule
    end

def added?(sym)
      @rules.detect {|r| r.target == sym }
    end

def start_symbol=(s)
      raise CompileError, "start symbol set twice'" if @start
      @start = s
    end

def declare_precedence(assoc, syms)
      raise CompileError, "precedence table defined twice" if @prec_table_closed
      @prec_table.push [assoc, syms]
    end

def end_precedence_declaration(reverse)
      @prec_table_closed = true
      return if @prec_table.empty?
      table = reverse ? @prec_table.reverse : @prec_table
      table.each_with_index do |(assoc, syms), idx|
        syms.each do |sym|
          sym.assoc = assoc
          sym.precedence = idx
        end
      end
    end

#
    # Dynamic Generation Interface
    #

def Grammar.define(&block)
      env = DefinitionEnv.new
      env.instance_eval(&block)
      env.grammar
    end

class DefinitionEnv
      def initialize
        @grammar = Grammar.new
        @seqs = Hash.new(0)
        @delayed = []
      end

def grammar
        flush_delayed
        @grammar.each do |rule|
          if rule.specified_prec
            rule.specified_prec = @grammar.intern(rule.specified_prec)
          end
        end
        @grammar.init
        @grammar
      end

def precedence_table(&block)
        env = PrecedenceDefinitionEnv.new(@grammar)
        env.instance_eval(&block)
        @grammar.end_precedence_declaration env.reverse
      end

def method_missing(mid, *args, &block)
        unless mid.to_s[-1,1] == '='
          super   # raises NoMethodError
        end
        target = @grammar.intern(mid.to_s.chop.intern)
        unless args.size == 1
          raise ArgumentError, "too many arguments for #{mid} (#{args.size} for 1)"
        end
        _add target, args.first
      end

def _add(target, x)
        case x
        when Sym
          @delayed.each do |rule|
            rule.replace x, target if rule.target == x
          end
          @grammar.symboltable.delete x
        else
          x.each_rule do |r|
            r.target = target
            @grammar.add r
          end
        end
        flush_delayed
      end

def _delayed_add(rule)
        @delayed.push rule
      end

def _added?(sym)
        @grammar.added?(sym) or @delayed.detect {|r| r.target == sym }
      end

def flush_delayed
        return if @delayed.empty?
        @delayed.each do |rule|
          @grammar.add rule
        end
        @delayed.clear
      end

def seq(*list, &block)
        Rule.new(nil, list.map {|x| _intern(x) }, UserAction.proc(block))
      end

def null(&block)
        seq(&block)
      end

def action(&block)
        id = "@#{@seqs["action"] += 1}".intern
        _delayed_add Rule.new(@grammar.intern(id), [], UserAction.proc(block))
        id
      end

alias _ action

def option(sym, default = nil, &block)
        _defmetasyntax("option", _intern(sym), block) {|target|
          seq() { default } | seq(sym)
        }
      end

def many(sym, &block)
        _defmetasyntax("many", _intern(sym), block) {|target|
            seq() { [] }\
          | seq(target, sym) {|list, x| list.push x; list }
        }
      end

def many1(sym, &block)
        _defmetasyntax("many1", _intern(sym), block) {|target|
            seq(sym) {|x| [x] }\
          | seq(target, sym) {|list, x| list.push x; list }
        }
      end

def separated_by(sep, sym, &block)
        option(separated_by1(sep, sym), [], &block)
      end

def separated_by1(sep, sym, &block)
        _defmetasyntax("separated_by1", _intern(sym), block) {|target|
            seq(sym) {|x| [x] }\
          | seq(target, sep, sym) {|list, _, x| list.push x; list }
        }
      end

def _intern(x)
        case x
        when Symbol, String
          @grammar.intern(x)
        when Racc::Sym
          x
        else
          raise TypeError, "wrong type #{x.class} (expected Symbol/String/Racc::Sym)"
        end
      end

private

def _defmetasyntax(type, id, action, &block)
        if action
          idbase = "#{type}@#{id}-#{@seqs[type] += 1}"
          target = _wrap(idbase, "#{idbase}-core", action)
          _register("#{idbase}-core", &block)
        else
          target = _register("#{type}@#{id}", &block)
        end
        @grammar.intern(target)
      end

def _register(target_name)
        target = target_name.intern
        unless _added?(@grammar.intern(target))
          yield(target).each_rule do |rule|
            rule.target = @grammar.intern(target)
            _delayed_add rule
          end
        end
        target
      end

def _wrap(target_name, sym, block)
        target = target_name.intern
        _delayed_add Rule.new(@grammar.intern(target),
                              [@grammar.intern(sym.intern)],
                              UserAction.proc(block))
        target
      end
    end

class PrecedenceDefinitionEnv
      def initialize(g)
        @grammar = g
        @prechigh_seen = false
        @preclow_seen = false
        @reverse = false
      end

attr_reader :reverse

def higher
        if @prechigh_seen
          raise CompileError, "prechigh used twice"
        end
        @prechigh_seen = true
      end

def lower
        if @preclow_seen
          raise CompileError, "preclow used twice"
        end
        if @prechigh_seen
          @reverse = true
        end
        @preclow_seen = true
      end

def left(*syms)
        @grammar.declare_precedence :Left, syms.map {|s| @grammar.intern(s) }
      end

def right(*syms)
        @grammar.declare_precedence :Right, syms.map {|s| @grammar.intern(s) }
      end

def nonassoc(*syms)
        @grammar.declare_precedence :Nonassoc, syms.map {|s| @grammar.intern(s)}
      end
    end

#
    # Computation
    #

def init
      return if @closed
      @closed = true
      @start ||= @rules.map {|r| r.target }.detect {|sym| not sym.dummy? }
      raise CompileError, 'no rule in input' if @rules.empty?
      add_start_rule
      @rules.freeze
      fix_ident
      compute_hash
      compute_heads
      determine_terminals
      compute_nullable_0
      @symboltable.fix
      compute_locate
      @symboltable.each_nonterminal {|t| compute_expand t }
      compute_nullable
      compute_useless
    end

private

def add_start_rule
      r = Rule.new(@symboltable.dummy,
                   [@start, @symboltable.anchor, @symboltable.anchor],
                   UserAction.empty)
      r.ident = 0
      r.hash = 0
      r.precedence = nil
      @rules.unshift r
    end

# Rule#ident
    # LocationPointer#ident
    def fix_ident
      @rules.each_with_index do |rule, idx|
        rule.ident = idx
      end
    end

# Rule#hash
    def compute_hash
      hash = 4   # size of dummy rule
      @rules.each do |rule|
        rule.hash = hash
        hash += (rule.size + 1)
      end
    end

# Sym#heads
    def compute_heads
      @rules.each do |rule|
        rule.target.heads.push rule.ptrs[0]
      end
    end

# Sym#terminal?
    def determine_terminals
      @symboltable.each do |s|
        s.term = s.heads.empty?
      end
    end

# Sym#self_null?
    def compute_nullable_0
      @symboltable.each do |s|
        if s.terminal?
          s.snull = false
        else
          s.snull = s.heads.any? {|loc| loc.reduce? }
        end
      end
    end

# Sym#locate
    def compute_locate
      @rules.each do |rule|
        t = nil
        rule.ptrs.each do |ptr|
          unless ptr.reduce?
            tok = ptr.dereference
            tok.locate.push ptr
            t = tok if tok.terminal?
          end
        end
        rule.precedence = t
      end
    end

# Sym#expand
    def compute_expand(t)
      puts "expand> #{t.to_s}" if @debug_symbol
      t.expand = _compute_expand(t, ISet.new, [])
      puts "expand< #{t.to_s}: #{t.expand.to_s}" if @debug_symbol
    end

def _compute_expand(t, set, lock)
      if tmp = t.expand
        set.update tmp
        return set
      end
      tok = nil
      set.update_a t.heads
      t.heads.each do |ptr|
        tok = ptr.dereference
        if tok and tok.nonterminal?
          unless lock[tok.ident]
            lock[tok.ident] = true
            _compute_expand tok, set, lock
          end
        end
      end
      set
    end

# Sym#nullable?, Rule#nullable?
    def compute_nullable
      @rules.each       {|r| r.null = false }
      @symboltable.each {|t| t.null = false }
      r = @rules.dup
      s = @symboltable.nonterminals
      begin
        rs = r.size
        ss = s.size
        check_rules_nullable r
        check_symbols_nullable s
      end until rs == r.size and ss == s.size
    end

def check_rules_nullable(rules)
      rules.delete_if do |rule|
        rule.null = true
        rule.symbols.each do |t|
          unless t.nullable?
            rule.null = false
            break
          end
        end
        rule.nullable?
      end
    end

def check_symbols_nullable(symbols)
      symbols.delete_if do |sym|
        sym.heads.each do |ptr|
          if ptr.rule.nullable?
            sym.null = true
            break
          end
        end
        sym.nullable?
      end
    end

# Sym#useless?, Rule#useless?
    # FIXME: what means "useless"?
    def compute_useless
      @symboltable.each_terminal {|sym| sym.useless = false }
      @symboltable.each_nonterminal {|sym| sym.useless = true }
      @rules.each {|rule| rule.useless = true }
      r = @rules.dup
      s = @symboltable.nonterminals
      begin
        rs = r.size
        ss = s.size
        check_rules_useless r
        check_symbols_useless s
      end until r.size == rs and s.size == ss
    end

def check_rules_useless(rules)
      rules.delete_if do |rule|
        rule.useless = false
        rule.symbols.each do |sym|
          if sym.useless?
            rule.useless = true
            break
          end
        end
        not rule.useless?
      end
    end

def check_symbols_useless(s)
      s.delete_if do |t|
        t.heads.each do |ptr|
          unless ptr.rule.useless?
            t.useless = false
            break
          end
        end
        not t.useless?
      end
    end

end   # class Grammar

class Rule

def initialize(target, syms, act)
      @target = target
      @symbols = syms
      @action = act
      @alternatives = []

@ident = nil
      @hash = nil
      @ptrs = nil
      @precedence = nil
      @specified_prec = nil
      @null = nil
      @useless = nil
    end

attr_accessor :target
    attr_reader :symbols
    attr_reader :action

def |(x)
      @alternatives.push x.rule
      self
    end

def rule
      self
    end

def each_rule(&block)
      yield self
      @alternatives.each(&block)
    end

attr_accessor :ident

attr_reader :hash
    attr_reader :ptrs

def hash=(n)
      @hash = n
      ptrs = []
      @symbols.each_with_index do |sym, idx|
        ptrs.push LocationPointer.new(self, idx, sym)
      end
      ptrs.push LocationPointer.new(self, @symbols.size, nil)
      @ptrs = ptrs
    end

def precedence
      @specified_prec || @precedence
    end

def precedence=(sym)
      @precedence ||= sym
    end

def prec(sym, &block)
      @specified_prec = sym
      if block
        unless @action.empty?
          raise CompileError, 'both of rule action block and prec block given'
        end
        @action = UserAction.proc(block)
      end
      self
    end

attr_accessor :specified_prec

def nullable?() @null end
    def null=(n)    @null = n end

def useless?()  @useless end
    def useless=(u) @useless = u end

def inspect
      "#<Racc::Rule id=#{@ident} (#{@target})>"
    end

def ==(other)
      other.kind_of?(Rule) and @ident == other.ident
    end

def [](idx)
      @symbols[idx]
    end

def size
      @symbols.size
    end

def empty?
      @symbols.empty?
    end

def to_s
      "#<rule#{@ident}>"
    end

def accept?
      if tok = @symbols[-1]
        tok.anchor?
      else
        false
      end
    end

def each(&block)
      @symbols.each(&block)
    end

def replace(src, dest)
      @target = dest
      @symbols = @symbols.map {|s| s == src ? dest : s }
    end

end   # class Rule

class UserAction

def UserAction.source_text(src)
      new(src, nil)
    end

def UserAction.proc(pr = nil, &block)
      if pr and block
        raise ArgumentError, "both of argument and block given"
      end
      new(nil, pr || block)
    end

def UserAction.empty
      new(nil, nil)
    end

private_class_method :new

def initialize(src, proc)
      @source = src
      @proc = proc
    end

attr_reader :source
    attr_reader :proc

def source?
      not @proc
    end

def proc?
      not @source
    end

def empty?
      not @proc and not @source
    end

def name
      "{action type=#{@source || @proc || 'nil'}}"
    end

alias inspect name

end

class OrMark
    def initialize(lineno)
      @lineno = lineno
    end

def name
      '|'
    end

alias inspect name

attr_reader :lineno
  end

class Prec
    def initialize(symbol, lineno)
      @symbol = symbol
      @lineno = lineno
    end

def name
      "=#{@symbol}"
    end

alias inspect name

attr_reader :symbol
    attr_reader :lineno
  end

#
  # A set of rule and position in it's RHS.
  # Note that the number of pointers is more than rule's RHS array,
  # because pointer points right edge of the final symbol when reducing.
  #
  class LocationPointer

def initialize(rule, i, sym)
      @rule   = rule
      @index  = i
      @symbol = sym
      @ident  = @rule.hash + i
      @reduce = sym.nil?
    end

attr_reader :rule
    attr_reader :index
    attr_reader :symbol

alias dereference symbol

attr_reader :ident
    alias hash ident
    attr_reader :reduce
    alias reduce? reduce

def to_s
      sprintf('(%d,%d %s)',
              @rule.ident, @index, (reduce?() ? '#' : @symbol.to_s))
    end

alias inspect to_s

def eql?(ot)
      @hash == ot.hash
    end

alias == eql?

def head?
      @index == 0
    end

def next
      @rule.ptrs[@index + 1] or ptr_bug!
    end

alias increment next

def before(len)
      @rule.ptrs[@index - len] or ptr_bug!
    end

private

def ptr_bug!
      raise "racc: fatal: pointer not exist: self: #{to_s}"
    end

end   # class LocationPointer

class SymbolTable

include Enumerable

def initialize
      @symbols = []   # :: [Racc::Sym]
      @cache   = {}   # :: {(String|Symbol) => Racc::Sym}
      @dummy  = intern(:$start, true)
      @anchor = intern(false, true)     # Symbol ID = 0
      @error  = intern(:error, false)   # Symbol ID = 1
    end

attr_reader :dummy
    attr_reader :anchor
    attr_reader :error

def [](id)
      @symbols[id]
    end

def intern(val, dummy = false)
      @cache[val] ||=
          begin
            sym = Sym.new(val, dummy)
            @symbols.push sym
            sym
          end
    end

attr_reader :symbols
    alias to_a symbols

def delete(sym)
      @symbols.delete sym
      @cache.delete sym.value
    end

attr_reader :nt_base

def nt_max
      @symbols.size
    end

def each(&block)
      @symbols.each(&block)
    end

def terminals(&block)
      @symbols[0, @nt_base]
    end

def each_terminal(&block)
      @terms.each(&block)
    end

def nonterminals
      @symbols[@nt_base, @symbols.size - @nt_base]
    end

def each_nonterminal(&block)
      @nterms.each(&block)
    end

def fix
      terms, nterms = @symbols.partition {|s| s.terminal? }
      @symbols = terms + nterms
      @terms = terms
      @nterms = nterms
      @nt_base = terms.size
      fix_ident
      check_terminals
    end

private

def fix_ident
      @symbols.each_with_index do |t, i|
        t.ident = i
      end
    end

def check_terminals
      return unless @symbols.any? {|s| s.should_terminal? }
      @anchor.should_terminal
      @error.should_terminal
      each_terminal do |t|
        t.should_terminal if t.string_symbol?
      end
      each do |s|
        s.should_terminal if s.assoc
      end
      terminals().reject {|t| t.should_terminal? }.each do |t|
        raise CompileError, "terminal #{t} not declared as terminal"
      end
      nonterminals().select {|n| n.should_terminal? }.each do |n|
        raise CompileError, "symbol #{n} declared as terminal but is not terminal"
      end
    end

end   # class SymbolTable

# Stands terminal and nonterminal symbols.
  class Sym

def initialize(value, dummyp)
      @ident = nil
      @value = value
      @dummyp = dummyp

@term  = nil
      @nterm = nil
      @should_terminal = false
      @precedence = nil
      case value
      when Symbol
        @to_s = value.to_s
        @serialized = value.inspect
        @string = false
      when String
        @to_s = value.inspect
        @serialized = value.dump
        @string = true
      when false
        @to_s = '$end'
        @serialized = 'false'
        @string = false
      when ErrorSymbolValue
        @to_s = 'error'
        @serialized = 'Object.new'
        @string = false
      else
        raise ArgumentError, "unknown symbol value: #{value.class}"
      end

@heads    = []
      @locate   = []
      @snull    = nil
      @null     = nil
      @expand   = nil
      @useless  = nil
    end

class << self
      def once_writer(nm)
        nm = nm.id2name
        module_eval(<<-EOS)
          def #{nm}=(v)
            raise 'racc: fatal: @#{nm} != nil' unless @#{nm}.nil?
            @#{nm} = v
          end
        EOS
      end
    end

once_writer :ident
    attr_reader :ident

alias hash ident

attr_reader :value

def dummy?
      @dummyp
    end

def terminal?
      @term
    end

def nonterminal?
      @nterm
    end

def term=(t)
      raise 'racc: fatal: term= called twice' unless @term.nil?
      @term = t
      @nterm = !t
    end

def should_terminal
      @should_terminal = true
    end

def should_terminal?
      @should_terminal
    end

def string_symbol?
      @string
    end

def serialize
      @serialized
    end

attr_writer :serialized

attr_accessor :precedence
    attr_accessor :assoc

def to_s
      @to_s.dup
    end

alias inspect to_s

def |(x)
      rule() | x.rule
    end

def rule
      Rule.new(nil, [self], UserAction.empty)
    end

#
    # cache
    #

attr_reader :heads
    attr_reader :locate

def self_null?
      @snull
    end

once_writer :snull

def nullable?
      @null
    end

def null=(n)
      @null = n
    end

attr_reader :expand
    once_writer :expand

def useless?
      @useless
    end

def useless=(f)
      @useless = f
    end

end   # class Sym

end   # module Racc