antelope 0.3.2 → 0.4.0

data/lib/antelope/generation/tableizer.rb

@@ -1,176 +1,176 @@
-# encoding: utf-8
-
-module Antelope
-  module Generation
-
-    # Constructs the table required for the parser.
-    class Tableizer
-
-      # The grammar that the table is based off of.
-      #
-      # @return [Grammar]
-      attr_accessor :grammar
-
-      # The table itself.
-      #
-      # @return [Array<Hash<(Symbol, Array<(Symbol, Numeric)>)>>]
-      attr_accessor :table
-
-      # All rules in the grammar.
-      #
-      # @return [Hash<(Numeric, Recognizer::Rule)>]
-      attr_accessor :rules
-
-      attr_reader :conflicts
-
-      # Initialize.
-      #
-      # @param grammar [Grammar]
-      def initialize(grammar)
-        @grammar = grammar
-      end
-
-      # Construct the table, and then check the table for conflicts.
-      #
-      # @return [void]
-      # @see #tablize
-      # @see #conflictize
-      def call
-        tablize
-        conflictize
-        defaultize
-      end
-
-      # Construct a table based on the grammar.  The table itself is
-      # an array whose elements are hashes; the index of the array
-      # corresponds to the state ID, and the keys of the hashes
-      # correspond to acceptable tokens.  The values of the hashes
-      # should be an array of arrays (at this point).
-      #
-      # @return [void]
-      def tablize
-        @table = Array.new(grammar.states.size) do
-          Hash.new { |h, k| h[k] = [] }
-        end
-        @rules = []
-
-        grammar.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.production.id] = rule.production
-            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][:$end] =
-                  [[:accept, rule.production.id]]
-              end
-            end
-          end
-        end
-
-        table
-      end
-
-      # Resolve any conflicts through precedence, if we can.  If we
-      # can't, let the user know.  This makes sure that every value
-      # of the hashes is a single array.
-      #
-      # @raise [UnresolvableConflictError] if a conflict could not be
-      #   resolved using precedence rules.
-      # @return [void]
-      def conflictize
-        states = grammar.states.to_a.sort_by(&:id)
-        @conflicts = Hash.new { |h, k| h[k] = {} }
-        @table.each_with_index do |v, state|
-          v.each do |on, data|
-            if data.size == 1
-              @table[state][on] = data[0]
-              next
-            end
-
-            terminal = if states[state].transitions.key?(on)
-              states[state].rules.
-                detect { |rule| rule.active.name == on }.precedence
-            end
-            rule_part, other_part = data.sort_by { |(t, _)| t }
-
-            conflict = proc do |result|
-              hash = { result: result,
-                       terminal: terminal,
-                       prec: @rules[rule_part[1]].prec,
-                       data: data,
-                       rules: [], transitions: [] }
-
-              hash[:rules].concat(data.select { |part|
-                  part[0] == :reduce || part[0] == :accept
-                }.map { |(_, id)|
-                  states[state].rules.select(&:final?).
-                    detect { |rule| rule.production.id == id }
-                })
-              hash[:transitions].concat(data.select { |part|
-                  part[0] == :state
-                }.map { |_|
-                  states[state].rules.
-                    detect { |rule| rule.active.name == on }
-                })
-
-              conflicts[state][on] = hash
-            end
-
-            unless other_part[0] == :state
-              conflict.call(0)
-              $stderr.puts \
-                "Could not determine move for #{on} in state " \
-                "#{state} (reduce/reduce conflict)"
-              next
-            end
-
-            result = @rules[rule_part[1]].prec <=> terminal
-            conflict.call(result)
-
-            case result
-            when 0
-              @table[state][on] = nil
-              $stderr.puts \
-                "Could not determine move for #{on} in state " \
-                "#{state} (shift/reduce conflict)"
-            when 1
-              @table[state][on] = rule_part
-            when -1
-              @table[state][on] = other_part
-            end
-          end
-        end
-      end
-
-      # Reduce many transitions into a single `$default` transition.
-      # This only works if there is no `$empty` transition; if there
-      # is an `$empty` transition, then the `$default` transition is
-      # set to be the `$empty` transition.
-      #
-      # @return [void]
-      def defaultize
-        max = @table.map { |s| s.keys.size }.max
-        @table.each_with_index do |state|
-          common = state.group_by { |k, v| v }.values.
-            sort_by(&:size).first
-
-          if common.size > (max / 2)
-            action = common[0][1]
-
-            keys = common.map(&:first)
-            state.delete_if { |k, _| keys.include?(k) }
-            state[:$default] = action
-          end
-        end
-      end
-    end
-  end
-end
+# encoding: utf-8
+
+module Antelope
+  module Generation
+
+    # Constructs the table required for the parser.
+    class Tableizer
+
+      # The grammar that the table is based off of.
+      #
+      # @return [Grammar]
+      attr_accessor :grammar
+
+      # The table itself.
+      #
+      # @return [Array<Hash<(Symbol, Array<(Symbol, Numeric)>)>>]
+      attr_accessor :table
+
+      # All rules in the grammar.
+      #
+      # @return [Hash<(Numeric, Recognizer::Rule)>]
+      attr_accessor :rules
+
+      attr_reader :conflicts
+
+      # Initialize.
+      #
+      # @param grammar [Grammar]
+      def initialize(grammar)
+        @grammar = grammar
+      end
+
+      # Construct the table, and then check the table for conflicts.
+      #
+      # @return [void]
+      # @see #tablize
+      # @see #conflictize
+      def call
+        tablize
+        conflictize
+        defaultize
+      end
+
+      # Construct a table based on the grammar.  The table itself is
+      # an array whose elements are hashes; the index of the array
+      # corresponds to the state ID, and the keys of the hashes
+      # correspond to acceptable tokens.  The values of the hashes
+      # should be an array of arrays (at this point).
+      #
+      # @return [void]
+      def tablize
+        @table = Array.new(grammar.states.size) do
+          Hash.new { |h, k| h[k] = [] }
+        end
+        @rules = []
+
+        grammar.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.production.id] = rule.production
+            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][:$end] =
+                  [[:accept, rule.production.id]]
+              end
+            end
+          end
+        end
+
+        table
+      end
+
+      # Resolve any conflicts through precedence, if we can.  If we
+      # can't, let the user know.  This makes sure that every value
+      # of the hashes is a single array.
+      #
+      # @raise [UnresolvableConflictError] if a conflict could not be
+      #   resolved using precedence rules.
+      # @return [void]
+      def conflictize
+        states = grammar.states.to_a.sort_by(&:id)
+        @conflicts = Hash.new { |h, k| h[k] = {} }
+        @table.each_with_index do |v, state|
+          v.each do |on, data|
+            if data.size == 1
+              @table[state][on] = data[0]
+              next
+            end
+
+            terminal = if states[state].transitions.key?(on)
+              states[state].rules.
+                detect { |rule| rule.active.name == on }.precedence
+            end
+            rule_part, other_part = data.sort_by { |(t, _)| t }
+
+            conflict = proc do |result|
+              hash = { result: result,
+                       terminal: terminal,
+                       prec: @rules[rule_part[1]].prec,
+                       data: data,
+                       rules: [], transitions: [] }
+
+              hash[:rules].concat(data.select { |part|
+                  part[0] == :reduce || part[0] == :accept
+                }.map { |(_, id)|
+                  states[state].rules.select(&:final?).
+                    detect { |rule| rule.production.id == id }
+                })
+              hash[:transitions].concat(data.select { |part|
+                  part[0] == :state
+                }.map { |_|
+                  states[state].rules.
+                    detect { |rule| rule.active.name == on }
+                })
+
+              conflicts[state][on] = hash
+            end
+
+            unless other_part[0] == :state
+              conflict.call(0)
+              $stderr.puts \
+                "Could not determine move for #{on} in state " \
+                "#{state} (reduce/reduce conflict)"
+              next
+            end
+
+            result = @rules[rule_part[1]].prec <=> terminal
+            conflict.call(result)
+
+            case result
+            when 0
+              @table[state][on] = nil
+              $stderr.puts \
+                "Could not determine move for #{on} in state " \
+                "#{state} (shift/reduce conflict)"
+            when 1
+              @table[state][on] = rule_part
+            when -1
+              @table[state][on] = other_part
+            end
+          end
+        end
+      end
+
+      # Reduce many transitions into a single `$default` transition.
+      # This only works if there is no `$empty` transition; if there
+      # is an `$empty` transition, then the `$default` transition is
+      # set to be the `$empty` transition.
+      #
+      # @return [void]
+      def defaultize
+        max = @table.map { |s| s.keys.size }.max
+        @table.each_with_index do |state|
+          common = state.group_by { |k, v| v }.values.
+            sort_by(&:size).first
+
+          if common.size > (max / 2)
+            action = common[0][1]
+
+            keys = common.map(&:first)
+            state.delete_if { |k, _| keys.include?(k) }
+            state[:$default] = action
+          end
+        end
+      end
+    end
+  end
+end

data/lib/antelope/generation.rb

@@ -1,15 +1,15 @@
-# encoding: utf-8
-
-require "antelope/generation/errors"
-require "antelope/generation/constructor"
-require "antelope/generation/recognizer"
-require "antelope/generation/tableizer"
-require "antelope/generation/null"
-
-module Antelope
-
-  # Contains the generation mods.
-  module Generation
-
-  end
-end
+# encoding: utf-8
+
+require "antelope/generation/errors"
+require "antelope/generation/constructor"
+require "antelope/generation/recognizer"
+require "antelope/generation/tableizer"
+require "antelope/generation/null"
+
+module Antelope
+
+  # Contains the generation mods.
+  module Generation
+
+  end
+end

data/lib/antelope/generator/base/coerce.rb

@@ -0,0 +1,115 @@
+module Antelope
+  module Generator
+    class Base
+      # Handles coercion of directives and their values.
+      module Coerce
+        # Retrieves all directives from the grammar, and giving them
+        # the proper values for this instance.
+        #
+        # @see .directive?
+        # @see #coerce_directive_value
+        # @return [Hash]
+        def directives
+          @_directives ||= begin
+            hash = Hashie::Mash.new
+
+            self.class.directives.each do |key, (_, definition)|
+              directive_value =
+                coerce_directive_value(grammar.options.key?(key),
+                  grammar.options[key], definition)
+              value = coerce_nested_hash(key, directive_value)
+              hash.deep_merge!(value)
+            end
+
+            hash
+          end
+        end
+
+        # Coerces a key of the format `<name>[.<name>]*` into a full
+        # hash accessable by ruby.
+        #
+        # @param key [String] the key of the directive.
+        # @param value [String] the value of the directive.
+        # @return [Hash] the resultant hash.
+        def coerce_nested_hash(key, value)
+          parts = key.split('.').map { |p| p.gsub(/-/, '_') }
+          top   = {}
+          hash  = top
+          parts.each do |part|
+            hash[part] = if parts.last == part
+                           value
+                         else
+                           {}
+                         end
+            hash = hash[part]
+          end
+
+          top[key] = value
+          top
+        end
+
+        # Coerce the given directive value to the given type.  For the
+        # type `nil`, it checks the size of the values; for no values,
+        # it returns true; for one value, it returns that one value;
+        # for any other size value, it returns the values.  For the
+        # type `Boolean`, if no values were given, or if the first
+        # value isn't "false", it returns true.  For the type
+        # `:single` (or `:one`), it returns the first value.  For the
+        # type `Array`, it returns the values.  For any other type
+        # that is a class, it tries to initialize the class with the
+        # given arguments.
+        #
+        # @param defined [Boolean] Whether or not the value was
+        #   actively defined in the grammar.
+        # @param values [Array<String>] The values that the directive
+        #   was defined with.
+        # @param type [Object?] The type expected of the arguments
+        #   given.
+        # @return [Object?]
+        def coerce_directive_value(defined, values, type)
+          return nil unless defined || type.is_a?(Array)
+
+          case type
+          when nil
+            values.any? ? values[0] : true
+          when :single, :one
+            values[0]
+          when Boolean
+            values[0].to_s != 'false'
+          when Array
+            values.zip(type).map do |value, t|
+              coerce_directive_value(defined, [value], t)
+            end
+          when Class
+            coerce_directive_class(values, type)
+          else
+            raise UnknownTypeError, "unknown type #{type}"
+          end
+        end
+
+        # If the expected of the directive is a Class, then we try to
+        # determine which class is expected, and return the proper
+        # values.
+        #
+        # @param values [Array<String>] The values that the directive
+        #   was defined with.
+        # @param type [Class] The type expected of the arguments
+        #   given.
+        # @return [Object]
+        def coerce_directive_class(values, type)
+          if type == Array
+            values
+          elsif type == String
+            values[0].to_s
+          elsif type == Fixnum || type == Integer || type == Numeric
+            values[0].to_i
+          elsif type == Float
+            values[0].to_f
+          else
+            type.new(*values)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/antelope/generator/base/extra.rb

@@ -0,0 +1,50 @@
+module Antelope
+  module Generator
+    class Base
+      # Includes some extra processed information about the grammar
+      # to be provided to general generators.
+      module Extra
+        # The actual table that is used for parsing.  This returns an
+        # array of hashes; the array index corresponds to the state
+        # number, and the hash keys correspond to the lookahead tokens.
+        # The hash values are an array; the first element of that array
+        # is the action to be taken, and the second element of the
+        # array is the argument for that action.  Possible actions
+        # include `:accept`, `:reduce`, and `:state`; `:accept` means
+        # to accept the string; `:reduce` means to perform the given
+        # reduction; and `:state` means to transition to the given
+        # state.
+        #
+        # @return [Array<Hash<Symbol => Array<(Symbol, Numeric)>>>]
+        def table
+          if mods[:tableizer].is_a? Generation::Tableizer
+            mods[:tableizer].table
+          else
+            []
+          end
+        end
+
+        # Returns an array of the production information of each
+        # production needed by the parser.  The first element of any
+        # element in the array is an {Ace::Token::Nonterminal} that
+        # that specific production reduces to; the second element
+        # is a number describing the number of items in the right hand
+        # side of the production; the string represents the action
+        # that should be taken on reduction.
+        #
+        # This information is used for `:reduce` actions in the parser;
+        # the value of the `:reduce` action corresponds to the array
+        # index of the production in this array.
+        #
+        # @return [Array<Array<(Ace::Token::Nonterminal, Numeric, String)>]
+        def productions
+          grammar.all_productions.map do |production|
+            [production[:label],
+             production[:items].size,
+             production[:block]]
+          end
+        end
+      end
+    end
+  end
+end