antelope 0.0.1

data/lib/antelope/generation/recognizer/rule.rb

@@ -0,0 +1,93 @@
+# encoding: utf-8
+
+module Antelope
+  module Generation
+    class Recognizer
+      class Rule
+
+        attr_reader :left
+        attr_reader :right
+        attr_reader :position
+        attr_reader :block
+        attr_accessor :lookahead
+        attr_accessor :id
+        attr_accessor :presidence
+        attr_reader :production
+
+        include Comparable
+
+        def initialize(production, position, inherited = false)
+          @left       = production.label
+          @position   = position
+          @lookahead  = Set.new
+          @presidence = production.prec
+          @production = production
+          @block      = production.block
+          @id         = SecureRandom.hex
+
+          if inherited
+            @right = inherited
+          else
+            @right = production.items.map(&:dup).freeze
+          end
+        end
+
+        def inspect
+          "#<#{self.class} id=#{id} left=#{left} right=[#{right.join(" ")}] position=#{position}>"
+        end
+
+        def to_s(dot = true)
+          "#{id}/#{presidence.type.to_s[0]}#{presidence.level}: #{left} → #{right[0, position].join(" ")}#{" • " if dot}#{right[position..-1].join(" ")}"
+        end
+
+        def active
+          right[position] or Ace::Token.new(nil)
+        end
+
+        def succ
+          Rule.new(production, position + 1)
+        end
+
+        def succ?
+          right.size > (position)
+        end
+
+        def final?
+          !succ?
+        end
+
+        def <=>(other)
+          if other.is_a? Rule
+            to_a <=> other.to_a
+          else
+            super
+          end
+        end
+
+        def without_transitions
+          @_without_transitions ||=
+            Rule.new(production, position)
+        end
+
+        def ===(other)
+          if other.is_a? Rule
+            left === other.left and right.each_with_index.
+              all? { |e, i| e === other.right[i] }
+          else
+            super
+          end
+        end
+
+        def hash
+          to_a.hash
+        end
+
+        alias_method :eql?, :==
+
+        def to_a
+          [left, right, position]
+        end
+      end
+    end
+  end
+end

data/lib/antelope/generation/recognizer/state.rb

@@ -0,0 +1,56 @@
+require "forwardable"
+require "securerandom"
+
+module Antelope
+  module Generation
+    class Recognizer
+      class State
+
+        attr_reader :rules
+        attr_reader :transitions
+        attr_accessor :id
+
+        include Enumerable
+        extend Forwardable
+
+        def_delegator :@rules, :each
+
+        def initialize
+          @rules = Set.new
+          @transitions = {} #Hash.new { |hash, key| hash[key] = State.new }
+          @id = SecureRandom.hex
+        end
+
+        def inspect
+          "#<#{self.class} id=#{id} transitions=[#{transitions.keys.join(", ")}] rules=[{#{rules.to_a.join("} {")}}]>"
+        end
+
+        def merge!(other)
+          return if other == :_ignore
+          raise ArgumentError, "Expected #{self.class}, " +
+            "got #{other.class}" unless other.is_a? State
+
+          self << other
+          self.transitions.merge! other.transitions
+
+          self
+        end
+
+        def rule_for(production)
+          rules.find { |rule| production === rule }
+        end
+
+        def <<(rule)
+          if rule.is_a? State
+            rule.rules.each { |r| self << r }
+          else
+            rules << rule unless rules.include? rule
+          end
+        end
+
+        alias_method :push, :<<
+
+      end
+    end
+  end
+end

data/lib/antelope/generation/recognizer.rb

@@ -0,0 +1,152 @@
+require "antelope/generation/recognizer/rule"
+require "antelope/generation/recognizer/state"
+
+module Antelope
+  module Generation
+
+    # Recognizes all of the states in the grammar.
+    #
+    # @see http://redjazz96.tumblr.com/post/88446352960
+    class Recognizer
+
+      # A list of all of the states in the grammar.
+      #
+      # @return [Set<State>]
+      attr_reader :states
+
+      # The initial state.  This is the state that is constructed from
+      # the rule with the left-hand side being `$start`.
+      #
+      # @return [State]
+      attr_reader :start
+
+      # The grammar that the recognizer is running off of.
+      #
+      # @return [Ace::Grammar]
+      attr_reader :grammar
+
+      # Initialize the recognizer.
+      #
+      # @param grammar [Ace::Grammar]
+      def initialize(grammar)
+        @grammar = grammar
+        @states = Set.new
+      end
+
+      # Runs the recognizer.  After all states have been created, it
+      # resets the state ids into a more friendly form (they were
+      # originally hexadecimal, see {State#initialize}), and then
+      # resets the rule ids in each state into a more friendly form
+      # (they were also originally hexadecmial, see {Rule#initialize}
+      # ).
+      #
+      # @see #compute_initial_state
+      # @return [void]
+      def call
+        @states = Set.new
+        @start  = compute_initial_state
+        redefine_state_ids
+        redefine_rule_ids
+        grammar.states = states
+      end
+
+      # Computes the initial state.  Starting with the default
+      # production of `$start`, it then generates the whole state
+      # and then the spawned states from it.
+      #
+      # @return [State]
+      def compute_initial_state
+        production = grammar.productions[:$start][0]
+        rule = Rule.new(production, 0)
+        compute_whole_state(rule)
+      end
+
+      # Computes the entire initial state from the initial rule.
+      # It starts with a blank state, adds the initial rule to it, and
+      # then generates the closure for that state; it then computes
+      # the rest of the states in the grammar.
+      #
+      # @param rule [Rule] the initial rule.
+      # @return [State]
+      def compute_whole_state(rule)
+        state = State.new
+        state << rule
+        compute_closure(state)
+        states << state
+        compute_states
+        state
+      end
+
+      # Computes all states.  Uses a fix point iteration to determine
+      # when no states have been added.  Loops through every state and
+      # every rule, looking for rules that have an active nonterminal
+      # and computing
+      def compute_states
+        fixed_point(states) do
+          states.dup.each do |state|
+            state.rules.each do |rule|
+              next unless rule.succ?
+              transitional = find_state_for(rule.succ) do |succ|
+                ns = State.new
+                ns << succ
+                compute_closure(ns)
+                states << ns
+                ns
+              end
+
+              if state.transitions[rule.active.name]
+                state.transitions[rule.active.name].merge! transitional
+              else
+                state.transitions[rule.active.name] = transitional
+              end
+            end
+          end
+        end
+      end
+
+      def compute_closure(state)
+        fixed_point(state.rules) do
+          state.rules.select { |_| _.active.nonterminal? }.each do |rule|
+            grammar.productions[rule.active.name].each do |prod|
+              state << Rule.new(prod, 0)
+            end
+          end
+        end
+      end
+
+      private
+
+      def find_state_for(rule)
+        states.find { |state| state.include?(rule) } or yield(rule)
+      end
+
+      def redefine_state_ids
+        states.each_with_index do |state, i|
+          state.id = i
+        end
+      end
+
+      def redefine_rule_ids
+        start = 0
+
+        states.each do |state|
+          state.rules.each do |rule|
+            rule.id = start
+            start  += 1
+          end
+        end
+      end
+
+      def fixed_point(enum)
+        added = 1
+
+        until added.zero?
+          added = enum.size
+          yield
+          added = enum.size - added
+        end
+      end
+
+    end
+  end
+end

data/lib/antelope/generation/tableizer.rb

@@ -0,0 +1,80 @@
+module Antelope
+  module Generation
+
+    class UnresolvableConflictError < StandardError; end
+
+    class Tableizer
+
+      attr_accessor :parser
+      attr_accessor :table
+      attr_accessor :rules
+
+      def initialize(parser)
+        @parser = parser
+      end
+
+      def call
+        tablize
+        conflictize
+      end
+
+      def tablize
+        @table = Array.new(parser.states.size) do
+          Hash.new { |h, k| h[k] = [] }
+        end
+        @rules = []
+
+        parser.states.each do |state|
+          state.transitions.each do |on, to|
+            table[state.id][on] << [:state, to.id]
+          end
+
+          state.rules.each do |rule|
+            @rules[rule.id] = rule
+            if rule.final?
+              rule.lookahead.each do |look|
+                table[state.id][look.name] <<
+                  [:reduce, rule.production.id]
+              end
+
+              if rule.production.id.zero?
+                table[state.id][:"$"] = [[:accept, rule.production.id]]
+              end
+            end
+          end
+        end
+
+        table
+      end
+
+      def conflictize
+        @table.each_with_index do |v, state|
+          v.each do |on, data|
+            if data.size == 1
+              @table[state][on] = data[0]
+              next
+            end
+
+            terminal = parser.presidence_for(on)
+
+            state_part = data.select { |(t, d)| t == :state }.first
+            rule_part  = data.select { |(t, d)| t == :reduce}.first
+
+            result = @rules[rule_part[1]].presidence <=> terminal
+
+            case result
+            when 0
+              p v, terminal, @rules[rule_part[1]].presidence
+              raise UnresolvableConflictError,
+                "Could not determine move for #{on} in state #{state}"
+            when 1
+              @table[state][on] = rule_part
+            when -1
+              @table[state][on] = state_part
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/antelope/generation.rb

@@ -0,0 +1,12 @@
+require "antelope/generation/conflictor"
+require "antelope/generation/constructor"
+require "antelope/generation/recognizer"
+require "antelope/generation/tableizer"
+
+module Antelope
+
+  # Contains the generation mods.
+  module Generation
+
+  end
+end

data/lib/antelope/generator/output.rb

@@ -0,0 +1,30 @@
+require "pp"
+
+module Antelope
+  class Generator
+
+    # Generates an output file, mainly for debugging.  Included always
+    # as a generator for a grammar.
+    class Output < Generator
+
+      # Defines singleton method for every mod that the grammar passed
+      # to the generator.
+      #
+      # @see Generator#initialize
+      def initialize(*)
+        super
+        mods.each do |k, v|
+          define_singleton_method (k) { v }
+        end
+      end
+
+      # Actually performs the generation.  Uses the template in
+      # output.erb, and generates the file `<file>.output`.
+      #
+      # @return [void]
+      def generate
+        template "output.erb", "#{file}.output"
+      end
+    end
+  end
+end

data/lib/antelope/generator/ruby.rb

@@ -0,0 +1,57 @@
+require "pp"
+
+module Antelope
+  class Generator
+
+    # Generates a ruby parser.
+    class Ruby < Generator
+
+      # Creates an action table for the parser.
+      #
+      # @return [String]
+      def generate_action_table
+        out = ""
+        PP.pp(mods[:tableizer].table, out)
+        out
+      end
+
+      # Outputs an array of all of the productions.
+      #
+      # @return [String]
+      def generate_productions_list
+        out = "["
+
+        grammar.all_productions.each do |production|
+          out                              <<
+            "["                            <<
+            production.label.name.inspect  <<
+            ", "                           <<
+            production.items.size.inspect  <<
+            ", "
+
+          block = if production.block.empty?
+            "proc {}"
+          else
+            "proc #{production.block}"
+          end
+
+          out << block << "],\n"
+        end
+
+        out.chomp!(",\n")
+
+        out << "]"
+      end
+
+      # Actually performs the generation.  Takes the template from
+      # ruby.erb and outputs it to `<file>_parser.rb`.
+      #
+      # @return [void]
+      def generate
+        template "ruby.erb", "#{file}_parser.rb" do |body|
+          sprintf(grammar.compiler.body, :write => body)
+        end
+      end
+    end
+  end
+end

data/lib/antelope/generator/templates/output.erb

@@ -0,0 +1,49 @@
+Productions:
+% constructor.productions.each do |production|
+    <%= production.to_s(false) %>
+% end
+
+Original Productions:
+% grammar.productions.each do |k, v|
+%  v.each do |prod|
+  <%= k %> → <%= prod[:items].join(" ") %>
+    <%= prod[:block] %>
+%  end
+% end
+
+Conflicts:
+% conflictor.conflicts.each do |conflict|
+  State <%= conflict.state.id %>:
+    rules : <%= conflict.rules.map(&:id).join(", ") %>
+    type  : <%= conflict.type %>
+    tokens: {<%= conflict.token.to_a.join(", ") %>}
+% end
+
+Presidence:
+  --- highest
+% grammar.presidence.each do |pr|
+  <%= "%-8s" % pr.type %> <%= pr.level %>:
+    {<%= pr.tokens.to_a.join(", ") %>}
+% end
+  --- lowest
+
+Table:
+% PP.pp(Hash[tableizer.table.each_with_index.to_a.map(&:reverse)], _erbout)
+
+% PP.pp(tableizer.rules, _erbout)
+
+% grammar.states.each do |state|
+State <%= state.id %>:
+  rules:
+%   state.rules.each do |rule|
+    <%= rule %>
+      {<%= rule.lookahead.to_a.join(", ") %>}
+%   end
+
+  transitions:
+%   max = state.transitions.keys.map(&:length).max || 0
+%   state.transitions.each do |on, to|
+    <%= "%-#{max}s" % on %>: State <%= to.id %>
+%   end
+
+% end

data/lib/antelope/generator/templates/ruby.erb

@@ -0,0 +1,62 @@
+# This file assumes that the output of the generator will be placed
+# within a module or a class.  However, the module/class requires a
+# `type` method, which takes a terminal and gives its type, as a
+# symbol.  These types should line up with the terminals that were
+# defined in the original grammar.
+
+# The actions to take during parsing.  In every state, there are a
+# set of acceptable peek tokens; this table tells the parser what
+# to do on each acceptable peek token.  The possible actions include
+# `:accept`, `:reduce`, and `:state`; `:accept` means to accept the
+# input and return the value of the pasing.  `:reduce` means to
+# reduce the top of the stack into a given nonterminal.  `:state`
+# means to transition to another state.
+#
+# @return [Array<Hash<(Symbol, Array<(Symbol, Numeric)>)>>]
+ACTION_TABLE = <%= generate_action_table %>.freeze # >
+
+# A list of all of the productions.  Only includes the left-hand side,
+# the number of tokens on the right-hand side, and the block to call
+# on reduction.
+#
+# @return [Array<Array<(Symbol, Numeric, Proc)>>]
+PRODUCTIONS  = <%= generate_productions_list %>.freeze # >
+
+# Runs the parser.
+#
+# @param input [Array<Object>] the input to run the parser over.
+# @return [Object] the result of the accept.
+def parse(input)
+  stack = []
+  stack.push([nil, 0])
+  input = input.dup
+  last  = nil
+
+  until stack.empty? do
+    peek_token = if input.empty?
+      :"$"
+    else
+      type(input.first)
+    end
+
+    action = ACTION_TABLE[stack.last.last].fetch(peek_token)
+    case action.first
+    when :accept
+      production = PRODUCTIONS[action.last]
+      last       = stack.pop(production[1]).first.first
+      stack.pop
+    when :reduce
+      production = PRODUCTIONS[action.last]
+      removing   = stack.pop(production[1])
+      value = production[2].call(*removing.map(&:first))
+      goto  = ACTION_TABLE[stack.last.last][production[0]]
+      stack.push([value, goto.last])
+    when :state
+      stack.push([input.shift, action.last])
+    else
+      raise
+    end
+  end
+
+  last
+end

data/lib/antelope/generator.rb

@@ -0,0 +1,84 @@
+require "antelope/generator/output"
+require "antelope/generator/ruby"
+require "erb"
+require "pathname"
+
+module Antelope
+
+  # Generates a parser.  This is normally the parent class, and the
+  # specific implementations inherit from this.  The generated
+  # parser should, ideally, be completely independent (not requiring
+  # any external source code), as well as be under a permissive
+  # license.
+  class Generator
+
+    # The modifiers that were applied to the grammar.
+    #
+    # @return [Hash<(Symbol, Object)>]
+    attr_reader :mods
+
+    # The file name (not including the extension) that the grammar
+    # should output to.
+    #
+    # @return [String]
+    attr_reader :file
+
+    # The grammar that the generator is for.
+    #
+    # @return [Ace::Grammar]
+    attr_reader :grammar
+
+    # The source root directory for templates.  Overwrite to change.
+    #
+    # @return [Pathname]
+    def self.source_root
+      Pathname.new("../generator/templates").expand_path(__FILE__)
+    end
+
+    # Initialize the generator.
+    #
+    # @param grammar [Grammar]
+    # @param mods [Hash<(Symbol, Object)>]
+    def initialize(grammar, mods)
+      @file    = grammar.name
+      @grammar = grammar
+      @mods    = mods
+    end
+
+    # Actually does the generation.  A subclass should implement this.
+    #
+    # @raise [NotImplementedError]
+    # @return [void]
+    def generate
+      raise NotImplementedError
+    end
+
+    protected
+
+    # Copies a template from the source, runs it through erb (in the
+    # context of this class), and then outputs it at the destination.
+    # If given a block, it will call the block after the template is
+    # run through erb with the content from erb; the result of the
+    # block is then used as the content instead.
+    #
+    # @param source [String] the source file.  This should be in
+    #   {.source_root}.
+    # @param destination [String] the destination file.  This will be
+    #   in {Ace::Grammar#output}.
+    # @yieldparam [String] content The content that ERB created.
+    # @yieldreturn [String] The new content to write to the output.
+    # @return [void]
+    def template(source, destination)
+      src_file  = self.class.source_root + source
+      src       = src_file.open("r")
+      context   = instance_eval('binding')
+      content   = ERB.new(src.read, nil, "%").result(context)
+      content   = yield content if block_given?
+      dest_file = grammar.output + destination
+      dest_file.open("w") do |f|
+        f.write(content)
+      end
+    end
+
+  end
+end

data/lib/antelope/version.rb

@@ -0,0 +1,4 @@
+module Antelope
+  # The current running version of antelope.
+  VERSION = "0.0.1".freeze
+end

data/lib/antelope.rb

@@ -0,0 +1,9 @@
+require "antelope/automaton"
+require "antelope/generation"
+require "antelope/generator"
+require "antelope/version"
+require "antelope/ace"
+
+module Antelope
+  # Your code goes here...
+end