123456789_123456789_123456789_123456789_123456789_

Class: Racc::Grammar::DefinitionEnv

Relationships & Source Files
Inherits: Object
Defined in: lib/racc/grammar.rb

Class Method Summary

Instance Method Summary

Constructor Details

.new ⇒ DefinitionEnv

[ GitHub ] 

  


# File 'lib/racc/grammar.rb', line 210



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


  







Dynamic Method Handling

  

    This class handles dynamic methods through the method_missing method




  

    #method_missing(mid, *args, &block)  
  

  [ GitHub ]


  

  


# File 'lib/racc/grammar.rb', line 233



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


  







Instance Method Details



  

    #_(&block)  
  



  

    

Alias for #action.


  



  [ GitHub ]


  

  


# File 'lib/racc/grammar.rb', line 290



alias _ action


  








  

    #_add(target, x)  
  

  [ GitHub ]


  

  


# File 'lib/racc/grammar.rb', line 244



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


  








  

    #_added?(sym)  ⇒ Boolean 
  



  

    
  





  


  [ GitHub ]


  

  


# File 'lib/racc/grammar.rb', line 264



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


  








  

    #_defmetasyntax(type, id, action, &block)   (private)
  

  [ GitHub ]


  

  


# File 'lib/racc/grammar.rb', line 336



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


  








  

    #_delayed_add(rule)  
  

  [ GitHub ]


  

  


# File 'lib/racc/grammar.rb', line 260



def _delayed_add(rule)
  @delayed.push rule
end


  








  

    #_intern(x)  
  

  [ GitHub ]


  

  


# File 'lib/racc/grammar.rb', line 323



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


  








  

    #_register(target_name)   (private)
  

  [ GitHub ]


  

  


# File 'lib/racc/grammar.rb', line 347



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


  








  

    #_wrap(target_name, sym, block)   (private)
  

  [ GitHub ]


  

  


# File 'lib/racc/grammar.rb', line 358



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


  








  

    #action(&block)  
    Also known as: #_
  

  [ GitHub ]


  

  


# File 'lib/racc/grammar.rb', line 284



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


  








  

    #flush_delayed  
  

  [ GitHub ]


  

  


# File 'lib/racc/grammar.rb', line 268



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


  








  

    #grammar  
  

  [ GitHub ]


  

  


# File 'lib/racc/grammar.rb', line 216



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


  








  

    #many(sym, &block)  
  

  [ GitHub ]


  

  


# File 'lib/racc/grammar.rb', line 298



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


  








  

    #many1(sym, &block)  
  

  [ GitHub ]


  

  


# File 'lib/racc/grammar.rb', line 305



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


  








  

    #null(&block)  
  

  [ GitHub ]


  

  


# File 'lib/racc/grammar.rb', line 280



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


  








  

    #option(sym, default = nil, &block)  
  

  [ GitHub ]


  

  


# File 'lib/racc/grammar.rb', line 292



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


  








  

    #precedence_table(&block)  
  

  [ GitHub ]


  

  


# File 'lib/racc/grammar.rb', line 227



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


  








  

    #separated_by(sep, sym, &block)  
  

  [ GitHub ]


  

  


# File 'lib/racc/grammar.rb', line 312



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


  








  

    #separated_by1(sep, sym, &block)  
  

  [ GitHub ]


  

  


# File 'lib/racc/grammar.rb', line 316



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


  








  

    #seq(*list, &block)  
  

  [ GitHub ]


  

  


# File 'lib/racc/grammar.rb', line 276



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