bison_parser.rby

%token IDENTIFIER
%token NUMBER
%token STRING
%token COLON
%token SEMICOLON
%token LBRACK
%token RBRACK
%token PIPE
%token HASH
%token DOUBLE_HASH
%token KW_TOKEN
%token KW_LEFT
%token KW_RIGHT
%token ACTIONS


%%

grammar_file :
  token_list[tokens] DOUBLE_HASH grammar_rules[rules] optional_code[code]
  { self.result = Bison::GrammarFile.new(tokens, rules, code) }
;

optional_code :
  { nil }
|
  DOUBLE_HASH ACTIONS[actions]
  { actions }
;

token_list :
  { [] }
|
  token_list[list] token[token]
  { list << token }
;

token:
  HASH KW_TOKEN IDENTIFIER[name]
  { Bison::Token.new(name) }
| assoc_token
| token[token] NUMBER[num]
  { token.tap{ |t| t.number = num } }
;

assoc_token:
  HASH KW_LEFT IDENTIFIER[name]
  { Bison::Token.new(name, :left) }
|
  HASH KW_RIGHT IDENTIFIER[name]
  { Bison::Token.new(name, :right) }
|
  assoc_token[token] IDENTIFIER[name]
  { token.tap{ |t| t.names << name } }
;

grammar_rules:
  { [] }
|
  grammar_rules[list] grammar_rule[rule]
  { list << rule }
;

grammar_rule:
  IDENTIFIER[name] COLON components[components] SEMICOLON
  { Bison::Rule.new(name, components).tap{ |r| r.location = @name } }
;

components:
  sequence[sequence]
  { [sequence] }
|
  components[sequences] PIPE sequence[sequence]
  { sequences << sequence }
;


sequence:
  { Bison::Sequence.new }
| sequence[sequence] ACTIONS[code]
  { sequence << Bison::Action.new(code).tap{ |a| a.location = @code } }
|
  sequence[sequence] IDENTIFIER[follower]
  { sequence << Bison::Nonterminal.new(follower).tap{ |x| x.location = @follower } }
|
  sequence[sequence] IDENTIFIER[follower] LBRACK IDENTIFIER[tag] RBRACK
  { sequence << Bison::Nonterminal.new(follower, tag).tap{ |x| x.location = @follower } }
;

%%

class BisonParser
  attr_accessor :section

  def lex
    self.section ||= 0
    self.lex_value = nil

    if section == 2
      self.lex_value = io.read
      self.section += 2
      return Tokens::ACTIONS
    end

    c = read_over_whitespace(line_comment_prefix: '#')
    return nil unless c

    case c
    when ':'
      return Tokens::COLON
    when ';'
      return Tokens::SEMICOLON
    when '|'
      return Tokens::PIPE
    when '%'
      if self.peak == '%'
        self.read
        self.section += 1
        return Tokens::DOUBLE_HASH
      end
      return Tokens::HASH
    when '['
      return Tokens::LBRACK
    when ']'
      return Tokens::RBRACK
    when '{'
      nesting = 1
      action = ''
      while (c = self.read) && nesting > 0
        nesting += 1 if c == '{'
        nesting -= 1 if c == '}'
        action << c unless nesting.zero?
      end
      self.lex_value = action
      return Tokens::ACTIONS
    when '0'..'9'
      number = c
      while (c = self.peak) && ('0'..'9').include?(c)
        number << self.read
      end
      self.lex_value = number.to_i
      return Tokens::NUMBER
    end

    if c =~ /\w/
      string = c
      while (c = self.peak) && c =~ /\w/
        self.read
        string << c
      end

      if section.zero? && string == 'token'
        return Tokens::KW_TOKEN
      elsif section.zero? && string == 'left'
        return Tokens::KW_LEFT
      elsif section.zero? && string == 'right'
        return Tokens::KW_RIGHT
      else
        self.lex_value = string
        return Tokens::IDENTIFIER
      end
    end

    return nil
  end
end