ruby-ll 1.0.0

data/lib/ll.rb

@@ -0,0 +1,26 @@
+require 'pathname'
+require 'erb'
+require 'set'
+require 'optparse'
+
+require 'ast'
+require 'ansi/code'
+
+require_relative 'll/setup'
+require_relative 'll/source_line'
+require_relative 'll/lexer'
+require_relative 'll/token'
+require_relative 'll/parser'
+require_relative 'll/grammar_compiler'
+require_relative 'll/code_generator'
+require_relative 'll/compiled_grammar'
+require_relative 'll/rule'
+require_relative 'll/branch'
+require_relative 'll/terminal'
+require_relative 'll/epsilon'
+require_relative 'll/message'
+require_relative 'll/ast/node'
+require_relative 'll/erb_context'
+require_relative 'll/configuration_compiler'
+require_relative 'll/compiled_configuration'
+require_relative 'll/cli'

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