lib/ll/parser.rll

%name LL::Parser;

%terminals T_RUBY T_NAME T_TERMINALS T_INNER T_HEADER T_IDENT T_EQUALS T_COLON;
%terminals T_PIPE T_EPSILON T_SEMICOLON T_STAR T_PLUS T_QUESTION;
%terminals T_LPAREN T_RPAREN;

grammar
  = elements { s(:grammar, val[0]) }
  ;

elements
  = element*
  ;

element
  = rule
  | name
  | terminals
  | inner
  | header
  ;

# %name directives
#
# This handles the parsing of %name directives, which can either contain a
# single name (e.g. "Foo") or a Ruby namespace (e.g. "Foo::Bar").

name
  = T_NAME ident namespace_part* T_SEMICOLON
    {
      s(:name, [val[1], *val[2]], :source_line => val[0].source_line)
    }
  ;

namespace_part
  = T_COLON T_COLON ident { val[2] }
  ;

# Generic Directives

terminals
  = T_TERMINALS idents T_SEMICOLON
    {
      s(:terminals, val[1], :source_line => val[0].source_line)
    }
  ;

# Code Directives
#
# These are directives that can be used to specify inline Ruby code (e.g. %inner
# and %header).

inner
  = T_INNER ruby
    {
      s(:inner, [val[1]], :source_line => val[0].source_line)
    }
  ;

header
  = T_HEADER ruby
    {
      s(:header, [val[1]], :source_line => val[0].source_line)
    }
  ;

# Generic identifiers

idents
  = ident+
  ;

ident
  = T_IDENT
    {
      s(:ident, [val[0].value], :source_line => val[0].source_line)
    }
  ;

ident_with_operator
  # X and X+
  = ident operator?
    {
      val[1] ? s(val[1][0], [val[0]], :source_line => val[1][1]) : val[0]
    }

  # (X Y Z)+
  | T_LPAREN idents T_RPAREN operator
    {
      s(val[3][0], val[1], :source_line => val[0].source_line)
    }
  ;

operator
  = T_PLUS     { [:plus, val[0].source_line] }
  | T_STAR     { [:star, val[0].source_line] }
  | T_QUESTION { [:question, val[0].source_line] }
  ;

idents_or_epsilon
  = ident_with_operator+
    {
      s(:steps, val[0], :source_line => val[0][0].source_line)
    }
  | epsilon
    {
      s(:steps, [val[0]], :source_line => val[0].source_line)
    }
  ;

epsilon
  = T_EPSILON { s(:epsilon, [], :source_line => val[0].source_line) }
  ;

# Rules

branch
  = idents_or_epsilon ruby?
    {
      steps = [val[0]]

      steps << val[1] if val[1]

      s(:branch, steps, :source_line => val[0].source_line)
    }
  ;

ruby
  = T_RUBY { s(:ruby, [val[0].value], :source_line => val[0].source_line) }
  ;

branches
  = branch another_branch* { [val[0], *val[1]] }
  ;

another_branch
  = T_PIPE branch { val[1] }
  ;

rule
  = ident T_EQUALS branches T_SEMICOLON
    {
      s(:rule, [val[0], *val[2]], :source_line => val[0].source_line)
    }
  ;

%inner
{
  ##
  # @see [LL::Lexer#initialize]
  #
  def initialize(*args)
    @lexer = Lexer.new(*args)
  end

  ##
  # @yieldparam [Symbol] type
  # @yieldparam [String] value
  #
  def each_token
    @lexer.advance do |token|
      yield [token.type, token]
    end

    yield [-1, -1]
  end

  ##
  # @see [LL::AST::Node#initialize]
  #
  def s(*args)
    return AST::Node.new(*args)
  end

  ##
  # @see [LL::Driver#parser_error]
  #
  def parser_error(stack_type, stack_value, token_type, token_value)
    message = parser_error_message(stack_type, stack_value, token_type)

    if token_value.is_a?(LL::Token)
      sl       = token_value.source_line
      message += " (line #{sl.line}, column #{sl.column})"
    end

    raise ParserError, message
  end
}