Class: Dhaka::Parser

### Home Classes Methods

### In Files

- lib/dhaka/parser/parser.rb

### Parent

Object

### Methods

- ::new
- #compile_to_ruby_source_as
- #inspect
- #to_dot

### Included Modules

- Dhaka::ParserMethods

### Class/Module Index

Quicksearch

- Dhaka
- Dhaka::CompiledLexer
- Dhaka::CompiledParser
- Dhaka::Evaluator
- Dhaka::Grammar
- Dhaka::GrammarSymbol
- Dhaka::Lexeme
- Dhaka::Lexer
- Dhaka::LexerRun
- Dhaka::LexerSpecification
- Dhaka::LexerSupport
- Dhaka::LexerSupport::AcceptAction
- Dhaka::LexerSupport::CheckpointAction
- Dhaka::LexerSupport::DFARun
- Dhaka::LexerSupport::InvalidRegexException
- Dhaka::LexerSupport::LookaheadAcceptAction
- Dhaka::LexerSupport::RegexParser
- Dhaka::LexerSupport::RegexTokenizer
- Dhaka::LexerSupport::State
- Dhaka::LexerSupport::StateMachine
- Dhaka::NoStartProductionsError
- Dhaka::ParseErrorResult
- Dhaka::ParseSuccessResult
- Dhaka::ParseTreeCompositeNode
- Dhaka::ParseTreeLeafNode
- Dhaka::Parser
- Dhaka::ParserMethods
- Dhaka::PrecedenceBuilder
- Dhaka::Production
- Dhaka::ProductionBuilder
- Dhaka::Token
- Dhaka::Tokenizer
- Dhaka::TokenizerErrorResult
- Dhaka::TokenizerState
- Dhaka::TokenizerSuccessResult

No matching classes.

# Dhaka::Parser

The parser generator. To generate a parser from a grammar specification `ArithmeticPrecedenceGrammar`, one would write:

    parser = Dhaka::Parser.new(ArithmeticPrecedenceGrammar)

To compile this parser to Ruby source as `ArithmeticPrecedenceParser`:

    parser.compile_to_ruby_source_as(:ArithmeticPrecedenceParser)

which returns a string of Ruby code.

### Attributes

grammar[R]

### Public Class Methods

new(grammar, logger = nil) click to toggle source

Creates a new parser from the given grammar. Messages are logged by default to STDOUT and the log level is WARN. Shift-reduce conflicts are reported at WARN and reduce-reduce conflicts at ERROR. You may pass in your own logger. Logging at DEBUG shows a lot of progress output.

    # File lib/dhaka/parser/parser.rb, line 16
    def initialize(grammar, logger = nil)
      @shift_actions  = Hash.new {|hash, state| hash[state] = ShiftAction.new(state)}
      @reduce_actions = Hash.new {|hash, production| hash[production] = ReduceAction.new(production)}
      @logger         = logger || default_logger
      @transitions    = Hash.new {|hash, state| hash[state] = {}}
      @grammar        = grammar
      @channels       = Hash.new {|hash, start_item| hash[start_item] = []}
      @states = Hash.new do |hash, kernel|
          closure, channels = grammar.closure(kernel)
          channels.each do |start_item, channel_set|
            @channels[start_item].concat channel_set.to_a
          end
          new_state    = ParserState.new(self, closure)
          hash[kernel] = new_state
          @logger.debug("Created #{new_state.unique_name}.")
          new_state.transition_items.each do |symbol, items|
            destination_kernel = ItemSet.new(items.collect{|item| item.next_item})
            destination_state  = hash[destination_kernel]
            items.each {|item| @channels[item] << grammar.passive_channel(item, destination_state.items[item.next_item])}
            @transitions[new_state][symbol] = destination_state
          end
          new_state
      end
      initialize_states
    end

### Public Instance Methods

compile_to_ruby_source_as(parser_class_name) click to toggle source

Returns the Ruby source of the generated parser compiled as `parser_class_name`. This can be written out to a file.

    # File lib/dhaka/parser/parser.rb, line 43
    def compile_to_ruby_source_as parser_class_name
      result = "class #{parser_class_name} < Dhaka::CompiledParser\n\n"
      result << "  self.grammar = #{grammar.name}\n\n"
      result << "  start_with #{start_state.id}\n\n"
      states.each do |state|
        result << "#{state.compile_to_ruby_source}\n\n"
      end
      result << "end"
      result
    end

inspect() click to toggle source

    # File lib/dhaka/parser/parser.rb, line 68
    def inspect
      "<Dhaka::Parser grammar : #{grammar}>"
    end

to_dot(options = {}) click to toggle source

Returns the dot representation of the parser. If `:hide_lookaheads` is set to true in the options hash, lookaheads are not written out to the parser states, which is helpful when there are dozens of lookahead symbols for every item in every state.

    # File lib/dhaka/parser/parser.rb, line 57
    def to_dot(options = {})
      Dot::Digraph.new(:fontsize => 10, :shape => :box, :size => 5) do |g|
        states.each do |state|
          g.node(state, :label => state.items.values.collect{|item| item.to_s(options)}.join("\n"))
          @transitions[state].each do |symbol, dest_state|
            g.edge(state, dest_state, :label => symbol.name)
          end
        end
      end.to_dot
    end

[Validate]

Generated with the Darkfish Rdoc Generator 2.