ruby-ll 1.0.0-java

data/lib/ll/ast/node.rb

@@ -0,0 +1,13 @@
+module LL
+  module AST
+    ##
+    # Class containing details of a single node in an LL grammar AST.
+    #
+    class Node < ::AST::Node
+      ##
+      # @return [LL::SourceLine]
+      #
+      attr_reader :source_line
+    end # Node
+  end # AST
+end # LL

data/lib/ll/branch.rb

@@ -0,0 +1,57 @@
+module LL
+  ##
+  # The Branch class contains information of a single rule branch such as the
+  # steps and the associated callback code.
+  #
+  class Branch
+    attr_reader :steps, :source_line, :ruby_code
+
+    ##
+    # @param [Array] steps
+    # @param [LL::SourceLine] source_line
+    # @param [String] ruby_code
+    #
+    def initialize(steps, source_line, ruby_code = nil)
+      @steps       = steps
+      @source_line = source_line
+      @ruby_code   = ruby_code
+    end
+
+    ##
+    # Returns the FIRST() set of this branch.
+    #
+    # @return [Array<LL::Terminal>]
+    #
+    def first_set
+      first = steps[0]
+
+      return first.is_a?(Rule) ? first.first_set : [first]
+    end
+
+    ##
+    # Returns the FOLLOW() set of this branch.
+    #
+    # @return [Array<LL::Terminal>]
+    #
+    def follow_set
+      follow = steps[1]
+
+      if follow.is_a?(Rule)
+        set = follow.first_set
+      elsif follow
+        set = [follow]
+      else
+        set = []
+      end
+
+      return set
+    end
+
+    ##
+    # @return [String]
+    #
+    def inspect
+      return "Branch(steps: #{steps.inspect}, ruby_code: #{ruby_code.inspect})"
+    end
+  end # Branch
+end # LL

data/lib/ll/cli.rb

@@ -0,0 +1,118 @@
+module LL
+  ##
+  # CLI that can be used to generate ruby-ll parsers from a grammar file.
+  #
+  class CLI
+    ##
+    # @param [Array] argv
+    #
+    def run(argv = ARGV)
+      options, leftovers = parse(argv)
+
+      if leftovers.empty?
+        abort <<-EOF.strip
+Error: you must specify a grammar input file'
+
+#{parser}
+EOF
+      end
+
+      input = File.expand_path(leftovers[0])
+
+      unless options[:output]
+        options[:output] = output_from_input(input)
+      end
+
+      generate(input, options)
+    end
+
+    ##
+    # @param [String] input
+    # @return [String]
+    #
+    def output_from_input(input)
+      input_ext = File.extname(input)
+
+      return input.gsub(/#{Regexp.compile(input_ext)}$/, '.rb')
+    end
+
+    ##
+    # @param [String] input
+    # @param [Hash] options
+    #
+    def generate(input, options)
+      raw_grammar    = File.read(input)
+      parser         = Parser.new(raw_grammar, input)
+      gcompiler      = GrammarCompiler.new
+      codegen        = CodeGenerator.new
+      configcompiler = ConfigurationCompiler.new
+
+      ast      = parser.parse
+      cgrammar = gcompiler.compile(ast)
+
+      cgrammar.display_messages
+
+      if cgrammar.valid?
+        config = configcompiler.generate(cgrammar)
+        output = codegen.generate(config, options[:requires])
+
+        File.open(options[:output], 'w') do |file|
+          file.write(output)
+        end
+      else
+        exit 1
+      end
+    end
+
+    ##
+    # @param [Array] argv
+    # @return [Array]
+    #
+    def parse(argv)
+      options = {
+        :requires => true,
+        :output   => nil
+      }
+
+      parser = OptionParser.new do |opt|
+        opt.summary_indent = '  '
+
+        opt.banner = <<-EOF.strip
+Usage: ruby-ll [INPUT-GRAMMAR] [OPTIONS]
+
+About:
+
+  Generates a Ruby LL(1) parser from a ruby-ll compatible grammar file.
+
+Examples:
+
+  ruby-ll lib/ll/parser.rll                   # output goes to lib/ll/parser.rl
+  ruby-ll lib/ll/parser.rll -o /tmp/parser.rb # output goes to /tmp/parser.rb
+        EOF
+
+        opt.separator "\nOptions:\n\n"
+
+        opt.on '-h', '--help', 'Shows this help message' do
+          abort parser.to_s
+        end
+
+        opt.on '--no-requires', 'Disables adding of require calls' do
+          options[:requires] = false
+        end
+
+        opt.on '-o [PATH]', '--output [PATH]', 'Writes output to PATH' do |val|
+          options[:output] = val
+        end
+
+        opt.on '-v', '--version', 'Shows the current version' do
+          puts "ruby-ll #{VERSION} on #{RUBY_DESCRIPTION}"
+          exit
+        end
+      end
+
+      leftovers = parser.parse(argv)
+
+      return options, leftovers
+    end
+  end # CLI
+end # LL

data/lib/ll/code_generator.rb

@@ -0,0 +1,32 @@
+module LL
+  ##
+  # The CodeGenerator class takes a {LL::CompiledConfiguration} instance and
+  # turns it into a block of Ruby source code that can be used as an actual
+  # LL(1) parser.
+  #
+  class CodeGenerator
+    ##
+    # The ERB template to use for code generation.
+    #
+    # @return [String]
+    #
+    TEMPLATE = File.expand_path('../driver_template.erb', __FILE__)
+
+    ##
+    # @param [LL::CompiledConfiguration] config
+    # @param [TrueClass|FalseClass] add_requires
+    # @return [String]
+    #
+    def generate(config, add_requires = true)
+      context = ERBContext.new(
+        :config       => config,
+        :add_requires => add_requires
+      )
+
+      template = File.read(TEMPLATE)
+      erb      = ERB.new(template, nil, '-').result(context.get_binding)
+
+      return erb
+    end
+  end # CodeGenerator
+end # LL

data/lib/ll/compiled_configuration.rb

@@ -0,0 +1,35 @@
+module LL
+  ##
+  # Class for storing the compiled state/lookup/action tables and the likes.
+  #
+  class CompiledConfiguration
+    attr_reader :name, :namespace, :inner, :header, :terminals, :rules, :table,
+      :actions, :action_bodies
+
+    ##
+    # @param [Hash] options
+    #
+    # @option options [String] :name
+    # @option options [Array] :namespace
+    # @option options [String] :inner
+    # @option options [String] :header
+    # @option options [Array] :terminals
+    # @option options [Array] :rules
+    # @option options [Array] :table
+    # @option options [Array] :actions
+    # @option options [Hash] :action_bodies
+    #
+    def initialize(options = {})
+      options.each do |key, value|
+        instance_variable_set("@#{key}", value) if respond_to?(key)
+      end
+
+      @namespace     ||= []
+      @terminals     ||= []
+      @rules         ||= []
+      @table         ||= []
+      @actions       ||= []
+      @action_bodies ||= {}
+    end
+  end # CompiledConfiguration
+end # LL

data/lib/ll/compiled_grammar.rb

@@ -0,0 +1,167 @@
+module LL
+  ##
+  # The CompiledGrammar class contains compilation results such as the parser
+  # name, the rules of the grammar, the terminals, etc.
+  #
+  class CompiledGrammar
+    attr_accessor :name, :inner, :header
+
+    attr_reader :warnings, :errors
+
+    def initialize
+      @warnings  = []
+      @errors    = []
+      @terminals = {}
+      @rules     = {}
+      @inner     = nil
+      @header    = nil
+    end
+
+    ##
+    # @param [String] message
+    # @param [LL::SourceLine] source_line
+    #
+    def add_error(message, source_line)
+      @errors << Message.new(:error, message, source_line)
+    end
+
+    ##
+    # @param [String] message
+    # @param [LL::SourceLine] source_line
+    #
+    def add_warning(message, source_line)
+      @warnings << Message.new(:warning, message, source_line)
+    end
+
+    ##
+    # @param [String] name
+    # @return [TrueClass|FalseClass]
+    #
+    def has_terminal?(name)
+      return @terminals.key?(name)
+    end
+
+    ##
+    # @param [String] name
+    # @param [LL::SourceLine] source_line
+    # @return [LL::Terminal]
+    #
+    def add_terminal(name, source_line)
+      return @terminals[name] = Terminal.new(name, source_line)
+    end
+
+    ##
+    # Returns true if a rule for the given name has already been assigned.
+    #
+    # @param [String] name
+    # @return [TrueClass|FalseClass]
+    #
+    def has_rule?(name)
+      return @rules.key?(name)
+    end
+
+    ##
+    # Returns true if a rule already exists for a given name _and_ has at least
+    # 1 branch.
+    #
+    # @see [#has_rule?]
+    #
+    def has_rule_with_branches?(name)
+      return has_rule?(name) && !@rules[name].branches.empty?
+    end
+
+    ##
+    # @param [LL::Rule] rule
+    # @return [LL::Rule]
+    #
+    def add_rule(rule)
+      return @rules[rule.name] = rule
+    end
+
+    ##
+    # @param [String] name
+    # @return [LL::Rule]
+    #
+    def lookup_rule(name)
+      return @rules[name]
+    end
+
+    ##
+    # Looks up an identifier from the list of terminals and/or rules. Rules take
+    # precedence over terminals.
+    #
+    # If no rule/terminal could be found nil is returned instead.
+    #
+    # @param [String] name
+    # @return [LL::Rule|LL::Terminal|NilClass]
+    #
+    def lookup_identifier(name)
+      if has_rule?(name)
+        ident = lookup_rule(name)
+      elsif has_terminal?(name)
+        ident = @terminals[name]
+      else
+        ident = nil
+      end
+
+      return ident
+    end
+
+    ##
+    # @return [Array]
+    #
+    def rules
+      return @rules.values
+    end
+
+    ##
+    # @return [Hash]
+    #
+    def rule_indices
+      return rules.each_with_index.each_with_object({}) do |(rule, idx), h|
+        h[rule] = idx
+      end
+    end
+
+    ##
+    # @return [Array]
+    #
+    def terminals
+      return @terminals.values
+    end
+
+    ##
+    # @return [Hash]
+    #
+    def terminal_indices
+      return terminals.each_with_index.each_with_object({}) do |(term, idx), h|
+        h[term] = idx
+      end
+    end
+
+    ##
+    # @return [TrueClass|FalseClass]
+    #
+    def valid?
+      return @errors.empty?
+    end
+
+    ##
+    # Displays all warnings and errors.
+    #
+    def display_messages
+      [:errors, :warnings].each do |type|
+        send(type).each do |msg|
+          output.puts(msg.to_s)
+        end
+      end
+    end
+
+    ##
+    # @return [IO]
+    #
+    def output
+      return STDERR
+    end
+  end # CompiledGrammar
+end # LL

data/lib/ll/configuration_compiler.rb

@@ -0,0 +1,204 @@
+module LL
+  ##
+  # Compiles an instance of {LL::CompiledConfiguration} which is used by
+  # {LL::CodeGenerator} to actually generate Ruby source code.
+  #
+  class ConfigurationCompiler
+    ##
+    # @return [Hash]
+    #
+    TYPES = {
+      :rule     => 0,
+      :terminal => 1,
+      :epsilon  => 2,
+      :action   => 3
+    }.freeze
+
+    ##
+    # @return [String]
+    #
+    DEFAULT_RUBY_CODE = 'val'.freeze
+
+    ##
+    # @param [LL::CompiledGrammar] grammar
+    # @return [LL::CompiledConfiguration]
+    #
+    def generate(grammar)
+      return CompiledConfiguration.new(
+        :name          => generate_name(grammar),
+        :namespace     => generate_namespace(grammar),
+        :inner         => grammar.inner,
+        :header        => grammar.header,
+        :terminals     => generate_terminals(grammar),
+        :actions       => generate_actions(grammar),
+        :action_bodies => generate_action_bodies(grammar),
+        :rules         => generate_rules(grammar),
+        :table         => generate_table(grammar)
+      )
+    end
+
+    ##
+    # @param [LL::CompiledGrammar] grammar
+    # @return [String]
+    #
+    def generate_name(grammar)
+      return grammar.name.split('::').last
+    end
+
+    ##
+    # @param [LL::CompiledGrammar] grammar
+    # @return [Array]
+    #
+    def generate_namespace(grammar)
+      parts = grammar.name.split('::')
+
+      return parts.length > 1 ? parts[0..-2] : []
+    end
+
+    ##
+    # Returns an Array containing all the terminal names as symbols. The first
+    # terminal is always `:$EOF` to ensure the array has the same amount of rows
+    # as there are columns in the `table` array.
+    #
+    # @param [LL::CompiledGrammar] grammar
+    # @return [Array]
+    #
+    def generate_terminals(grammar)
+      terminals = [:$EOF]
+
+      grammar.terminals.each do |term|
+        terminals << term.name.to_sym
+      end
+
+      return terminals
+    end
+
+    ##
+    # @param [LL::CompiledGrammar] grammar
+    # @return [Array]
+    #
+    def generate_actions(grammar)
+      actions = []
+      index   = 0
+
+      grammar.rules.each do |rule|
+        rule.branches.each do |branch|
+          args = branch.steps.reject { |step| step.is_a?(Epsilon) }.length
+
+          actions << [:"_rule_#{index}", args]
+
+          index += 1
+        end
+      end
+
+      return actions
+    end
+
+    ##
+    # @param [LL::CompiledGrammar] grammar
+    # @return [Hash]
+    #
+    def generate_action_bodies(grammar)
+      bodies = {}
+      index  = 0
+
+      grammar.rules.each do |rule|
+        rule.branches.each do |branch|
+          bodies[:"_rule_#{index}"] = branch.ruby_code || DEFAULT_RUBY_CODE
+
+          index += 1
+        end
+      end
+
+      return bodies
+    end
+
+    ##
+    # Builds the rules table of the parser. Each row is built in reverse order.
+    #
+    # @param [LL::CompiledGrammar] grammar
+    # @return [Array]
+    #
+    def generate_rules(grammar)
+      rules        = []
+      action_index = 0
+      rule_indices = grammar.rule_indices
+      term_indices = grammar.terminal_indices
+
+      grammar.rules.each_with_index do |rule, rule_index|
+        rule.branches.each do |branch|
+          row = [TYPES[:action], action_index]
+
+          action_index += 1
+
+          branch.steps.reverse_each do |step|
+            if step.is_a?(LL::Terminal)
+              row << TYPES[:terminal]
+              row << term_indices[step] + 1
+
+            elsif step.is_a?(LL::Rule)
+              row << TYPES[:rule]
+              row << rule_indices[step]
+
+            elsif step.is_a?(LL::Epsilon)
+              row << TYPES[:epsilon]
+              row << 0
+            end
+          end
+
+          rules << row
+        end
+      end
+
+      return rules
+    end
+
+    ##
+    # Generates the table array for the parser. This array has the following
+    # structure:
+    #
+    #     [
+    #       [EOF, TERMINAL 1, TERMINAL 2, TERMINAL 3, ...]
+    #     ]
+    #
+    # EOF is always the first column and is used when running out of input while
+    # processing a rule.
+    #
+    # @param [LL::CompiledGrammar] grammar
+    # @return [Array]
+    #
+    def generate_table(grammar)
+      branch_index = 0
+      term_indices = grammar.terminal_indices
+      columns      = grammar.terminals.length + 1
+
+      table = Array.new(grammar.rules.length) do
+        Array.new(columns, -1)
+      end
+
+      grammar.rules.each_with_index do |rule, rule_index|
+        rule.branches.each do |branch|
+          branch.first_set.each do |step|
+            # For terminals we'll base the column index on the terminal index.
+            if step.is_a?(Terminal)
+              terminal_index = term_indices[step]
+
+              table[rule_index][terminal_index + 1] = branch_index
+
+            # For the rest (= epsilon) we'll update all columns that haven't
+            # been updated yet.
+            else
+              table[rule_index].each_with_index do |col, col_index|
+                table[rule_index][col_index] = branch_index if col == -1
+              end
+            end
+          end
+
+          branch_index += 1
+        end
+      end
+
+      return table
+    end
+  end # ConfigurationCompiler
+end # LL