ebnf 1.1.2 → 2.1.1

data/lib/ebnf/isoebnf.rb

@@ -0,0 +1,229 @@
+require_relative 'isoebnf/meta'
+require 'logger'
+
+# ISO EBNF parser
+# Parses ISO EBNF into an array of {EBNF::Rule}.
+module EBNF
+  class ISOEBNF
+    include EBNF::PEG::Parser
+
+    # The base for terminal-character, which omits "'", '"', and '?'.
+    # Could be more optimized, and one might quible
+    # with the overly-strictly defined character set,
+    # but it is correct.
+    TERMINAL_CHARACTER_BASE = %r{
+      [a-zA-Z0-9] | # letter | decimal digit
+      ,           | # concatenate symbol
+      =           | # defining symbol
+      [\|\/!]     | # definition separator symbol
+      \*\)        | # end comment symbol
+      \)          | # end group symbol
+      \]          | # end option symbol
+      \}          | # end repeat symbol
+      \-          | # except symbol
+      #\'          | # first quote symbol
+      \*          | # repetition symbol
+      #\"          | # second quote symbol
+      #\?          | # special sequence symbol
+      \(\*        | # start comment symbol
+      \(          | # start group symbol
+      \[          | # start option symbol
+      \{          | # start repeat symbol
+      [;\.]       | # terminator symbol
+      [:+_%@&$<>^\x20\x23\\`~]  # other character
+    }x
+
+    TERMINAL_CHARACTER         = %r{#{TERMINAL_CHARACTER_BASE}|['"\?]}
+    FIRST_TERMINAL_CHARACTER   = %r{#{TERMINAL_CHARACTER_BASE}|["\?]}
+    SECOND_TERMINAL_CHARACTER  = %r{#{TERMINAL_CHARACTER_BASE}|['\?]}
+    SPECIAL_SEQUENCE_CHARACTER = %r{#{TERMINAL_CHARACTER_BASE}|['"]}
+
+    # Abstract syntax tree from parse
+    #
+    # @return [Array<EBNF::Rule>]
+    attr_reader :ast
+
+    # `[14] integer           ::= decimal_digit+`
+    terminal(:integer, /\d+/) do |value, prod|
+      value.to_i
+    end
+
+    # `[15] meta_identifier             ::= letter meta_identifier_character*`
+    terminal(:meta_identifier, /[a-zA-Z][a-zA-Z0-9_]*/) do |value|
+      value.to_sym
+    end
+
+    # `[17] terminal_string             ::= ("'" first_terminal_character+ "'")`
+    # `                                   | ('"' second_terminal_character+ '"')`
+    terminal(:terminal_string, /(?:'#{FIRST_TERMINAL_CHARACTER}+')|(?:"#{SECOND_TERMINAL_CHARACTER}+")/x) do |value|
+      value[1..-2]
+    end
+
+    # `[20] special_sequence            ::= '?' special_sequence_character* '?'`
+    terminal(:special_sequence, /\?#{SPECIAL_SEQUENCE_CHARACTER}+\?/)
+
+    # `[22] terminal_character          ::= [a-zA-Z0-9]`
+    # `                                   | [,=;*}#x2d?([{;]`
+    # `                                   | '*)'`
+    # `                                   | '(*'`
+    # `                                   | ']'`
+    # `                                   | other_character`
+    terminal(:terminal_character, TERMINAL_CHARACTER)
+
+    # `[25] empty                      ::= ''`
+    terminal(:empty, //)
+
+    # `[26] definition_separator_symbol ::= '|' | '/' | '!'`
+    terminal(:definition_separator_symbol, /[\|\/!]/)
+
+    # `[27] terminator_symbol           ::= ';' | '.'`
+    terminal(:terminator_symbol, /[;\.]/)
+
+    # `[28] start_option_symbol         ::= '['
+    terminal(:start_option_symbol, /\[|(?:\(\/)/)
+
+    # `[29] end_option_symbol           ::= ']'`
+    terminal(:end_option_symbol, /\]/)
+
+    # `[30] start_repeat_symbol         ::= '{' | '(:'`
+    terminal(:start_repeat_symbol, /{|\(:/)
+
+    # `[31] end_repeat_symbol           ::= '}' | ':)'`
+    terminal(:end_repeat_symbol, /}|:\)/)
+
+    # ## Non-terminal productions
+
+    # `[2]  syntax_rule       ::= meta_identifier '=' definitions_list terminator_symbol`
+    production(:syntax_rule, clear_packrat: true) do |value, data, callback|
+      # value contains an expression.
+      # Invoke callback
+      sym = value[0][:meta_identifier]
+      definitions_list = value[2][:definitions_list]
+      callback.call(:rule, EBNF::Rule.new(sym.to_sym, nil, definitions_list))
+      nil
+    end
+
+    # Setting `as_hash: true` in the start production makes the value of the form of a hash, rather than an array of hashes.
+    #
+    # `[3]  definitions_list  ::= single_definition (definition_separator_symbol definitions_list)*`
+    start_production(:definitions_list, as_hash: true)
+    production(:definitions_list) do |value|
+      if value[:_definitions_list_1].length > 0
+        [:alt, value[:single_definition]] + value[:_definitions_list_1]
+      else
+        value[:single_definition]
+      end
+    end
+    production(:_definitions_list_1) do |value|
+      Array(value.first)
+    end
+    start_production(:_definitions_list_2, as_hash: true)
+    production(:_definitions_list_2) do |value|
+      if Array(value[:definitions_list]).first == :alt
+        value[:definitions_list][1..-1]
+      else
+        [value[:definitions_list]]
+      end
+    end
+
+    # `[4]  single_definition ::= term (',' term)*`
+    start_production(:single_definition, as_hash: true)
+    production(:single_definition) do |value|
+      if value[:_single_definition_1].length > 0
+        [:seq, value[:term]] + value[:_single_definition_1]
+      else
+        value[:term]
+      end
+    end
+    production(:_single_definition_1) do |value|
+      value.map {|a1| a1.last[:term]}.compact # Get rid of '|'
+    end
+
+    # `[5]  term              ::= factor ('-' exception)?`
+    start_production(:term, as_hash: true)
+    production(:term) do |value|
+      if value[:_term_1]
+        [:diff, value[:factor], value[:_term_1]]
+      else
+        value[:factor]
+      end
+    end
+    production(:_term_1) do |value|
+      value.last[:exception] if value
+    end
+
+    # `[6]  exception         ::= factor`
+    start_production(:exception, as_hash: true)
+    production(:exception) do |value|
+      value[:factor]
+    end
+
+    # `[7]  factor            ::= (integer '*')? primary`
+    start_production(:factor, as_hash: true)
+    production(:factor) do |value|
+      if value[:_factor_1]
+        [:rept, value[:_factor_1], value[:_factor_1], value[:primary]]
+      else
+        value[:primary]
+      end
+    end
+    production(:_factor_2) do |value|
+      value.first[:integer]
+    end
+
+    # `[9]  optional_sequence ::= start_option_symbol definitions_list end_option_symbol`
+    production(:optional_sequence) do |value|
+      [:opt, value[1][:definitions_list]]
+    end
+
+    # `[10] repeated_sequence ::= start_repeat_symbol definitions_list end_repeat_symbol`
+    production(:repeated_sequence) do |value|
+      [:star, value[1][:definitions_list]]
+    end
+
+    # `[11] grouped_sequence  ::= '(' definitions_list ')'`
+    production(:grouped_sequence) do |value|
+      [:seq, value[1][:definitions_list]]
+    end
+
+    # ## Parser invocation.
+    # On start, yield ourselves if a block is given, otherwise, return this parser instance
+    #
+    # @param  [#read, #to_s]          input
+    # @param  [Hash{Symbol => Object}] options
+    # @option options [Boolean] :level
+    #   Trace level. 0(debug), 1(info), 2(warn), 3(error).
+    # @return [EBNFParser]
+    def initialize(input, **options, &block)
+      # If the `level` option is set, instantiate a logger for collecting trace information.
+      if options.has_key?(:level)
+        options[:logger] = Logger.new(STDERR)
+        options[:logger].level = options[:level]
+        options[:logger].formatter = lambda {|severity, datetime, progname, msg| "#{severity} #{msg}\n"}
+      end
+
+      # Read input, if necessary, which will be used in a Scanner.
+      @input = input.respond_to?(:read) ? input.read : input.to_s
+
+      parsing_terminals = false
+      @ast = []
+      parse(@input,
+            :syntax,
+            ISOEBNFMeta::RULES,
+            whitespace: %r{([\x09-\x0d\x20]|(?:\(\*(?:(?:\*[^\)])|[^*])*\*\)))+},
+            **options
+      ) do |context, *data|
+        rule = case context
+        when :rule
+          # A rule which has already been turned into a `Rule` object.
+          rule = data.first
+          rule.kind = :terminal if parsing_terminals
+          rule
+        end
+        @ast << rule if rule
+      end
+    rescue EBNF::PEG::Parser::Error => e
+      raise SyntaxError, e.message
+    end
+  end
+end

data/lib/ebnf/isoebnf/meta.rb

@@ -0,0 +1,75 @@
+# This file is automatically generated by ebnf version 2.0.0
+# Derived from etc/iso-ebnf.ebnf
+module ISOEBNFMeta
+  RULES = [
+    EBNF::Rule.new(:syntax, nil, [:star, :syntax_rule]).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:syntax_rule, nil, [:seq, :meta_identifier, :defining_symbol, :definitions_list, :terminator_symbol]).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:definitions_list, nil, [:seq, :single_definition, :_definitions_list_1]).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:_definitions_list_1, nil, [:star, :_definitions_list_2]).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:_definitions_list_2, nil, [:seq, :definition_separator_symbol, :definitions_list]).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:single_definition, nil, [:seq, :term, :_single_definition_1]).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:_single_definition_1, nil, [:star, :_single_definition_2]).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:_single_definition_2, nil, [:seq, ",", :term]).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:term, nil, [:seq, :factor, :_term_1]).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:_term_1, nil, [:opt, :_term_2]).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:_term_2, nil, [:seq, "-", :exception]).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:exception, nil, [:seq, :factor]).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:factor, nil, [:seq, :_factor_1, :primary]).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:_factor_1, nil, [:opt, :_factor_2]).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:_factor_2, nil, [:seq, :integer, "*"]).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:primary, nil, [:alt, :optional_sequence, :repeated_sequence, :special_sequence, :grouped_sequence, :meta_identifier, :terminal_string, :empty]).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:optional_sequence, nil, [:seq, :start_option_symbol, :definitions_list, :end_option_symbol]).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:repeated_sequence, nil, [:seq, :start_repeat_symbol, :definitions_list, :end_repeat_symbol]).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:grouped_sequence, nil, [:seq, "(", :definitions_list, ")"]).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:_terminals, nil, [:seq], kind: :terminals).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:terminal_string, nil, [:alt, :_terminal_string_1, :_terminal_string_2], kind: :terminal).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:_terminal_string_1, nil, [:seq, "'", :_terminal_string_3, "'"]).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:_terminal_string_3, nil, [:plus, :first_terminal_character]).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:_terminal_string_2, nil, [:seq, "\"", :_terminal_string_4, "\""]).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:_terminal_string_4, nil, [:plus, :second_terminal_character]).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:meta_identifier, nil, [:seq, :letter, :_meta_identifier_1], kind: :terminal).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:_meta_identifier_1, nil, [:star, :meta_identifier_character]).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:integer, nil, [:plus, :decimal_digit], kind: :terminal).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:special_sequence, nil, [:seq, "?", :_special_sequence_1, "?"], kind: :terminal).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:_special_sequence_1, nil, [:star, :special_sequence_character]).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:comment, nil, [:seq, :start_comment_symbol, :_comment_1, :end_comment_symbol], kind: :terminal).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:_comment_1, nil, [:star, :comment_symbol]).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:comment_symbol, nil, [:alt, :comment, :commentless_symbol, :other_character], kind: :terminal).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:commentless_symbol, nil, [:alt, :terminal_character, :meta_identifier, :integer, :terminal_string, :special_sequence], kind: :terminal).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:letter, nil, [:range, "a-zA-Z"], kind: :terminal).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:decimal_digit, nil, [:range, "0-9"], kind: :terminal).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:meta_identifier_character, nil, [:alt, :letter, :decimal_digit, "_"], kind: :terminal).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:first_terminal_character, nil, [:diff, :terminal_character, "'"], kind: :terminal).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:second_terminal_character, nil, [:diff, :terminal_character, "\""], kind: :terminal).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:special_sequence_character, nil, [:diff, :terminal_character, "?"], kind: :terminal).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:terminal_character, nil, [:alt, :letter, :decimal_digit, :concatenate_symbol, :defining_symbol, :definition_separator_symbol, :end_comment_symbol, :end_group_symbol, :end_option_symbol, :end_repeat_symbol, :except_symbol, :first_quote_symbol, :repetition_symbol, :second_quote_symbol, :special_sequence_symbol, :start_comment_symbol, :start_group_symbol, :start_option_symbol, :start_repeat_symbol, :terminator_symbol, :other_character], kind: :terminal).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:other_character, nil, [:alt, :_other_character_1, "\\"], kind: :terminal).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:_other_character_1, nil, [:range, ":+_%@&$<>^` ̃#x20#x23"], kind: :terminal).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:gap_separator, nil, [:range, "#x9#xa#xb#xc#xd#x20"], kind: :terminal).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:_pass, nil, [:alt, :__pass_1, :comment], kind: :pass).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:__pass_1, nil, [:plus, :gap_separator]).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:empty, nil, [:seq, ""], kind: :terminal).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:concatenate_symbol, nil, [:seq, ","], kind: :terminal).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:repetition_symbol, nil, [:seq, "*"], kind: :terminal).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:except_symbol, nil, [:seq, "-"], kind: :terminal).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:first_quote_symbol, nil, [:seq, "'"], kind: :terminal).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:second_quote_symbol, nil, [:seq, "\""], kind: :terminal).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:start_comment_symbol, nil, [:seq, "(*"], kind: :terminal).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:end_comment_symbol, nil, [:seq, "*)"], kind: :terminal).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:start_group_symbol, nil, [:seq, "("], kind: :terminal).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:end_group_symbol, nil, [:seq, ")"], kind: :terminal).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:special_sequence_symbol, nil, [:seq, "?"], kind: :terminal).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:defining_symbol, nil, [:alt, "=", ":"], kind: :terminal).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:definition_separator_symbol, nil, [:alt, "|", "/", "!"], kind: :terminal).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:terminator_symbol, nil, [:alt, ";", "."], kind: :terminal).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:start_option_symbol, nil, [:seq, "["], kind: :terminal).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:end_option_symbol, nil, [:seq, "]"], kind: :terminal).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:start_repeat_symbol, nil, [:alt, "{", "(:"], kind: :terminal).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:end_repeat_symbol, nil, [:alt, "}", ":)"], kind: :terminal).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:gap_free_symbol, nil, [:alt, :_gap_free_symbol_1, :terminal_string], kind: :terminal).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:_gap_free_symbol_1, nil, [:seq, :_gap_free_symbol_3, :terminal_character]).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:_gap_free_symbol_3, nil, [:not, :_gap_free_symbol_2]).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:_gap_free_symbol_2, nil, [:range, "'\""], kind: :terminal).extend(EBNF::PEG::Rule),
+  ]
+end
+

data/lib/ebnf/ll1.rb

@@ -1,4 +1,86 @@
 module EBNF
+  ##
+  # This module extends {EBNF::Base} to create metadata including _branch_,  [First/Follow][], and other tables which is used by {EBNF::LL1::Parser} to recognize examples of the associated grammar.
+  #
+  ### Branch Table
+  #
+  #  The Branch table is a hash mapping production rules to a hash relating terminals appearing in input to sequence of productions to follow when the corresponding input terminal is found. This allows either the `seq` primitive, where all terminals map to the same sequence of productions, or the `alt` primitive, where each terminal may map to a different production.
+  #
+  #      BRANCH = {
+  #        :alt => {
+  #          "(" => [:seq, :_alt_1],
+  #          :HEX => [:seq, :_alt_1],
+  #          :O_RANGE => [:seq, :_alt_1],
+  #          :RANGE => [:seq, :_alt_1],
+  #          :STRING1 => [:seq, :_alt_1],
+  #          :STRING2 => [:seq, :_alt_1],
+  #          :SYMBOL => [:seq, :_alt_1],
+  #        },
+  #        ...
+  #        :declaration => {
+  #          "@pass" => [:pass],
+  #          "@terminals" => ["@terminals"],
+  #        },
+  #        ...
+  #      }
+  #
+  #  In this case the `alt` rule is `seq ('|' seq)*` can happen when any of the specified tokens appears on the input stream. The all cause the same token to be passed to the `seq` rule and follow with `_alt_1`, which handles the `('|' seq)*` portion of the rule, after the first sequence is matched.
+  #
+  #  The `declaration` rule is `@terminals' | pass` using the `alt` primitive determining the production to run based on the terminal appearing on the input stream. Eventually, a terminal production is found and the token is consumed.
+  #
+  ### First/Follow Table
+  #
+  #  The [First/Follow][] table is a hash mapping production rules to the terminals that may proceed or follow the rule. For example:
+  #
+  #      FIRST = {
+  #        :alt => [
+  #          :HEX,
+  #          :SYMBOL,
+  #          :RANGE,
+  #          :O_RANGE,
+  #          :STRING1,
+  #          :STRING2,
+  #          "("],
+  #        ...
+  #      }
+  #
+  ### Terminals Table
+  #
+  #  This table is a simple list of the terminal productions found in the grammar. For example:
+  #
+  #      TERMINALS = ["(", ")", "-",
+  #        "@pass", "@terminals",
+  #         :HEX, :LHS, :O_RANGE,:POSTFIX,
+  #        :RANGE, :STRING1, :STRING2, :SYMBOL,"|"
+  #      ].freeze
+  #
+  ### Cleanup Table
+  #
+  #  This table identifies productions which used EBNF rules, which are transformed to BNF for actual parsing. This allows the parser, in some cases, to reproduce *star*, *plus*, and *opt* rule matches. For example:
+  #
+  #      CLEANUP = {
+  #        :_alt_1 => :star,
+  #        :_alt_3 => :merge,
+  #        :_diff_1 => :opt,
+  #        :ebnf => :star,
+  #        :_ebnf_2 => :merge,
+  #        :_postfix_1 => :opt,
+  #        :seq => :plus,
+  #        :_seq_1 => :star,
+  #        :_seq_2 => :merge,
+  #      }.freeze
+  #
+  #  In this case the `ebnf` rule was `(declaration | rule)*`. As BNF does not support a star operator, this is decomposed into a set of rules using `alt` and `seq` primitives:
+  #
+  #      ebnf    ::= _empty _ebnf_2
+  #      _ebnf_1 ::= declaration | rule
+  #      _ebnf_2 ::= _ebnf_1 ebnf
+  #      _ebnf_3 ::= ebnf
+  #
+  #  The `_empty` production matches an empty string, so allows for now value. `_ebnf_2` matches `declaration | rule` (using the `alt` primitive) followed by `ebnf`, creating a sequence of zero or more `declaration` or `alt` members.
+  #
+  # [First/Follow]: https://en.wikipedia.org/wiki/LL_parser#Constructing_an_LL.281.29_parsing_table
+
   module LL1
     autoload :Lexer,    "ebnf/ll1/lexer"
     autoload :Parser,   "ebnf/ll1/parser"
@@ -51,8 +133,40 @@ module EBNF
     ##
     # Create first/follow for each rule using techniques defined for LL(1) parsers.
     #
+    # This takes rules which have transformed into BNF and adds first/follow and otehr information to the rules to allow the generation of metadata tables used for driving a parser.
+    #
+    # Given an initial rule in EBNF:
+    #
+    #     (rule enbf "1" (star declaration rule))
+    #
+    # The BNF transformation becomes:
+    #
+    #     (rule ebnf "1" (alt _empty _ebnf_2))
+    #     (rule _ebnf_1 "1.1" (alt declaration rule))
+    #     (rule _ebnf_2 "1.2" (seq _ebnf_1 ebnf))
+    #     (rule _ebnf_3 "1.3" (seq ebnf))
+    #
+    # After running this method, the rules are annotated with first/follow and cleanup rules:
+    #
+    #     (rule ebnf "1"
+    #      (start #t)
+    #      (first "@pass" "@terminals" LHS _eps)
+    #      (follow _eof)
+    #      (cleanup star)
+    #      (alt _empty _ebnf_2))
+    #     (rule _ebnf_1 "1.1"
+    #      (first "@pass" "@terminals" LHS)
+    #      (follow "@pass" "@terminals" LHS _eof)
+    #      (alt declaration rule))
+    #     (rule _ebnf_2 "1.2"
+    #      (first "@pass" "@terminals" LHS)
+    #      (follow _eof)
+    #      (cleanup merge)
+    #      (seq _ebnf_1 ebnf))
+    #     (rule _ebnf_3 "1.3" (first "@pass" "@terminals" LHS _eps) (follow _eof) (seq ebnf))
+    #
     # @return [EBNF] self
-    # @see http://en.wikipedia.org/wiki/LL_parser#Constructing_an_LL.281.29_parsing_table
+    # @see https://en.wikipedia.org/wiki/LL_parser#Constructing_an_LL.281.29_parsing_table
     # @param [Array<Symbol>] starts
     #   Set of symbols which are start rules
     def first_follow(*starts)
@@ -96,8 +210,9 @@ module EBNF
           firsts, follows = 0, 0
           # add Fi(wi) to Fi(Ai) for every rule Ai → wi
           #
-          # For sequences, this is the first rule in the sequence.
-          # For alts, this is every rule in the sequence
+          # * For sequences, this is the first rule in the sequence.
+          # * For alts, this is every rule in the sequence
+          # * Other rules don't matter, as they don't appear in strict BNF
           each(:rule) do |ai|
             # Fi(a w' ) = { a } for every terminal a
             ai.terminals(ast).each do |t|
@@ -168,6 +283,10 @@ module EBNF
           progress("first_follow") {"(#{ittr}) firsts #{firsts}, follows #{follows}"}
           ittr += 1
         end while (firsts + follows) > 0
+
+        debug("Fi.2-post: non-terminals without first") do
+          ast.reject(&:terminal?).reject(&:first).map(&:sym)
+        end if ast.reject(&:terminal?).any? {|r| r.first.nil?}
       end
     end
 
@@ -216,7 +335,7 @@ module EBNF
       @branch = {}
       @already = []
       @agenda = []
-      @starts.each do |start|
+      Array(@starts).each do |start|
         do_production(start)
         while !@agenda.empty?
           x = @agenda.shift
@@ -265,13 +384,26 @@ module EBNF
           end
         end
         io.puts "#{ind0}}.freeze\n"
-      else
+      elsif table
         io.puts "#{ind0}#{name} = [\n#{ind1}" +
           table.sort_by{|t| t.to_s.sub(/^_/, '')}.map(&:inspect).join(",\n#{ind1}") +
           "\n#{ind0}].freeze\n"
       end
     end
 
+    ##
+    # Output Ruby parser files for LL(1) parsing
+    #
+    # @param [IO, StringIO] output
+    def to_ruby_ll1(output, **options)
+      self.outputTable(output, 'BRANCH', self.branch, 1)
+      self.outputTable(output, 'TERMINALS', self.terminals, 1)
+      self.outputTable(output, 'FIRST', self.first, 1)
+      self.outputTable(output, 'FOLLOW', self.follow, 1)
+      self.outputTable(output, 'CLEANUP', self.cleanup, 1)
+      self.outputTable(output, 'PASS', [self.pass], 1) if self.pass
+    end
+
     private
     def do_production(lhs)
       rule = find_rule(lhs)
@@ -287,16 +419,16 @@ module EBNF
 
       if rule.expr.first == :matches
         debug("prod") {"Rule is regexp: #{rule}"}
-
-        error("No record of what token #{lhs} can start with") unless rule.first
         return
       end
 
+      error("No record of what token #{lhs.inspect} can start with") unless rule.first
+
       if rule.alt?
         # A First/Follow conflict appears when _eps is in the first
         # of one rule and there is a token in the first and
         # follow of the same rule
-        if rule.first.include?(:_eps) && !(overlap = ((rule.first & (rule.follow || [])) - [:eps])).empty?
+        if Array(rule.first).include?(:_eps) && !(overlap = ((Array(rule.first) & (rule.follow || [])) - [:eps])).empty?
           error("First/Follow Conflict: #{overlap.first.inspect} is both first and follow of #{rule.sym}")
         end