antelope 0.1.8 → 0.1.9

data/lib/antelope/ace/token.rb

@@ -35,14 +35,30 @@ module Antelope
       # @return [Recognizer::State]
       attr_accessor :to
 
+      # The type of the token.  This is given by a caret argument to
+      # the grammar.  This is primarily used for generators.
+      #
+      # @return [String]
+      attr_accessor :type
+
+      attr_accessor :id
+
       # Initialize.
       #
       # @param name [Symbol] the name of the token.
+      # @param type [String?] the type of the token.  For definitions,
+      #   this is the given type of the token (for typed language
+      #   output).
+      # @param id [String?] the id of the token in the production.
+      #   For some languages, this allows references to the token via
+      #   the id.
       # @param value [String?] the value of the token.  This is only
       #   used in output representation to the developer.
-      def initialize(name, value = nil)
+      def initialize(name, type = nil, id = nil, value = nil)
         @name  = name
         @value = value
+        @type  = type
+        @id    = id
         @from  = nil
         @to    = nil
       end
@@ -110,6 +126,9 @@ module Antelope
         buf
       end
 
+      # Returns a nice inspect.
+      #
+      # @return [String]
       def inspect
         "#<#{self.class} from=#{from.id if from} to=#{to.id if to} " \
           "name=#{name.inspect} value=#{@value.inspect}>"
@@ -149,7 +168,7 @@ module Antelope
       #
       # @return [Token]
       def without_transitions
-        self.class.new(name, @value)
+        self.class.new(name, @type, @id, @value)
       end
 
       # Generates a hash for this class.

data/lib/antelope/cli.rb

@@ -3,6 +3,8 @@
 require "thor"
 
 module Antelope
+
+  # Handles the command line interface.
   class CLI < Thor
 
     class_option :verbose, default: false, type: :boolean
@@ -10,19 +12,37 @@ module Antelope
     option :type, default: nil, type: :string,
       desc: "The type of generator to use"
     desc "compile FILE [FILE]*", "compile the given files"
+
+    # Compile.
     def compile(*files)
       files.each do |file|
         compile_file(file)
       end
     end
 
+    desc "check FILE [FILE]*", "check the syntax of the given files"
+
+    # Check.
+    def check(*files)
+      files.each do |file|
+        compile_file(file, [Generator::Null])
+      end
+    end
+
     private
 
-    def compile_file(file)
+    # Compiles the given file, and then generates.  If an error
+    # occurs, it prints it out to stderr, along with a backtrace if
+    # the verbose flag was set.
+    #
+    # @param file [String] the file to compile.
+    # @param gen [Array, Symbol] the generator to use.
+    # @return [void]
+    def compile_file(file, gen = :guess)
       puts "Compiling #{file}... "
 
       grammar = Ace::Grammar.from_file(file)
-      grammar.generate(options)
+      grammar.generate(options, gen)
 
     rescue => e
       $stderr.puts "Error while compiling: #{e.class}: #{e.message}"

data/lib/antelope/generation/constructor/first.rb

@@ -16,7 +16,7 @@ module Antelope
         # Constructs the first set for a given token.  This is how
         # the method should behave:
         #
-        #     FIRST(ε)  == []  # if ϵ is the epsilon token
+        #     FIRST(ε)  == []  # if ε is the epsilon token
         #     FIRST(x)  == [x] # if x is a terminal
         #     FIRST(αβ) == if nullable?(α)
         #       FIRST(α) U FIRST(β)

data/lib/antelope/generation/constructor.rb

@@ -63,6 +63,7 @@ module Antelope
           production.items = []
 
           current_state = state
+          old_state = state
 
           production.label.from = state
           production.label.to   = state.transitions[rule.left.name]
@@ -78,6 +79,7 @@ module Antelope
 
             production.items << new_item
 
+            old_state = current_state
             current_state = transition
           end
 

data/lib/antelope/generation/null.rb

@@ -0,0 +1,13 @@
+module Antelope
+  module Generation
+    class Null
+
+
+      def initialize(*)
+      end
+
+      def call(*)
+      end
+    end
+  end
+end

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

@@ -168,8 +168,9 @@ module Antelope
         # @return [Numeric]
         def ===(other)
           if other.is_a? Rule
-            left === other.left and right.each_with_index.
-              all? { |e, i| e === other.right[i] }
+            left === other.left and right.size == other.right.size and
+              right.each_with_index.
+                all? { |e, i| e === other.right[i] }
           else
             super
           end
@@ -203,7 +204,7 @@ module Antelope
         # @private
         # @return [Array<(Ace::Token::Nonterminal, Array<Ace::Token>, Numeric)>]
         def to_a
-          [left, right, position].flatten
+          [left, right, position]
         end
       end
     end

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

@@ -86,10 +86,15 @@ module Antelope
         # @param rule [State, Rule] the object to append.
         # @return [self]
         def <<(rule)
-          if rule.is_a? State
+          case rule
+          when State
             rule.rules.map(&:clone).each { |r| self << r }
-          elsif rule.is_a? Rule
+          when Rule
             rules << rule unless rules.include? rule
+          when Array, Set
+            rule.each do |part|
+              self << part
+            end
           else
             raise ArgumentError, "Expected #{State} or #{Rule}, " \
               "got #{rule.class}"
@@ -100,11 +105,21 @@ module Antelope
 
         alias_method :push, :<<
 
+        # Check to see if this state is fuzzily equivalent to another
+        # state.  It does this by checking if the transitions are
+        # equivalent, and then that the rules are fuzzily equivalent.
+        # Ideally, the method is commutative; that is,
+        # `(a === b) == (b === a)`.
+        #
+        # @param other [State] the state to check.
+        # @return [Boolean]
+        # @see Rule#===
         def ===(other)
           return super unless other.is_a? State
 
           other_rules = other.rules.to_a
-          other.transitions == transitions and
+          other.transitions == transitions &&
+            rules.size == other_rules.size &&
             rules.each_with_index.
             all? { |rule, i| rule === other_rules[i] }
         end

data/lib/antelope/generation/recognizer.rb

@@ -90,21 +90,7 @@ module Antelope
       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 << succ
-                compute_closure(ns)
-                @map[succ] = ns
-              end
-
-              if state.transitions[rule.active.name]
-                state.transitions[rule.active.name].merge! transitional
-              else
-                states << transitional
-                state.transitions[rule.active.name] = transitional
-              end
-            end
+            compute_gotos(state)
           end
         end
       end
@@ -124,18 +110,27 @@ module Antelope
         end
       end
 
-      private
+      def compute_gotos(state)
+        actives = state.rules.map(&:active).select(&:name).to_set
+
+        actives.each do |active|
+          next if state.transitions[active.name]
+          rules = state.rules.
+            select { |r| r.active == active && r.succ? }.
+            map(&:succ).to_set
+          s = states.find { |st| rules <= st.rules } || begin
+            s = State.new << rules
+            compute_closure(s)
+            states << s
+            s
+          end
 
-      # Find a state that include a specific rule, or yields the rule.
-      #
-      # @param rule [Rule]
-      # @yield [rule]
-      # @return [State]
-      def find_state_for(rule, &block)
-        #states.find { |state| state.include?(rule) } or yield(rule)
-        @map.fetch(rule) { block.call(rule) }
+          state.transitions[active.name] = s
+        end
       end
 
+      private
+
       # Changes the IDs of the states into a more friendly format.
       #
       # @return [void]

data/lib/antelope/generation/tableizer.rb

@@ -38,6 +38,7 @@ module Antelope
       def call
         tablize
         conflictize
+        defaultize
       end
 
       # Construct a table based on the grammar.  The table itself is
@@ -67,7 +68,8 @@ module Antelope
               end
 
               if rule.production.id.zero?
-                table[state.id][:"$"] = [[:accept, rule.production.id]]
+                table[state.id][:$end] =
+                  [[:accept, rule.production.id]]
               end
             end
           end
@@ -94,7 +96,7 @@ module Antelope
 
             terminal = grammar.precedence_for(on)
 
-            rule_part, other_part = data.sort_by { |(t, d)| t }
+            rule_part, other_part = data.sort_by { |(t, _)| t }
 
             unless other_part[0] == :state
               $stderr.puts \
@@ -121,6 +123,32 @@ module Antelope
           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|
+          if state.key?(:$empty)
+            state[:$default] = state[:$empty]
+          else
+            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
 end

data/lib/antelope/generation.rb

@@ -4,6 +4,7 @@ require "antelope/generation/errors"
 require "antelope/generation/constructor"
 require "antelope/generation/recognizer"
 require "antelope/generation/tableizer"
+require "antelope/generation/null"
 
 module Antelope
 

data/lib/antelope/generator/base.rb

@@ -1,3 +1,5 @@
+require 'hashie/mash'
+
 module Antelope
   module Generator
 
@@ -10,6 +12,7 @@ module Antelope
     # @abstract Subclass and redefine {#generate} to create a
     #   generator.
     class Base
+      Boolean = Object.new
       # The modifiers that were applied to the grammar.
       #
       # @return [Hash<(Symbol, Object)>]
@@ -37,6 +40,43 @@ module Antelope
         Generator.register_generator(self, *names)
       end
 
+      # Called by ruby on subclassing.
+      #
+      # @param subclass [Class]
+      # @return [void]
+      def self.inherited(subclass)
+        directives.each do |name, (_, type)|
+          subclass.has_directive(name, type)
+        end
+      end
+
+      # Allows a directive for this generator.  This is checked in
+      # the compiler to allow the option.  If the compiler encounters
+      # a bad directive, it'll error (to give the developer a warning).
+      #
+      # @param directive [Symbol, String]
+      # @param type [Object] used to define how the value should be
+      #   coerced.
+      # @see #directives
+      # @see #coerce_directive_value
+      # @return [void]
+      def self.has_directive(directive, type = nil)
+        directive = directive.to_s
+        directives[directive] = [self, type]
+      end
+
+      # The directives in the class.
+      #
+      # @see .has_directive
+      # @return [Hash]
+      def self.directives
+        @_directives ||= {}
+      end
+
+      class << self
+        alias_method :has_directives, :has_directive
+      end
+
       # Initialize the generator.
       #
       # @param grammar [Grammar]
@@ -57,6 +97,93 @@ module Antelope
 
       protected
 
+      # Retrieves all directives from the grammar, and giving them the
+      # proper values for this instance.
+      #
+      # @see .has_directive
+      # @see #coerce_directive_value
+      # @return [Hash]
+      def directives
+        @_directives ||= begin
+          hash = Hashie::Mash.new
+
+          self.class.directives.each do |key, dict|
+            value = [grammar.options.key?(key), grammar.options[key]]
+            hash.deep_merge! coerce_nested_hash(key,
+              coerce_directive_value(*value, dict[1]))
+          end
+
+          hash
+        end
+      end
+
+      def coerce_nested_hash(key, value)
+        parts = key.split('.').map { |p| p.gsub(/-/, "_") }
+        top   = {}
+        hash  = top
+        parts.each_with_index do |part, i|
+          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.
+      def coerce_directive_value(defined, values, type)
+        return nil unless defined || Array === type
+        case type
+        when nil
+          case values.size
+          when 0
+            true
+          when 1
+            values[0]
+          else
+            values
+          end
+        when :single, :one
+          values[0]
+        when Boolean
+          # For bool, if there were no arguments, then return true;
+          # otherwise, if the first argument isn't "false", return
+          # true.
+
+          values[0].to_s != "false"
+        when Array
+          values.zip(type).map do |value, t|
+            coerce_directive_value(defined, [value], t)
+          end
+        when Class
+          if type == Array
+            values
+          elsif type == String
+            values[0].to_s
+          elsif [Fixnum, Integer, Numeric].include?(type)
+            values[0].to_i
+          elsif type == Float
+            values[0].to_f
+          else
+            type.new(*values)
+          end
+        else
+          raise UnknownTypeError, "unknown type #{type}"
+        end
+      end
+
       # 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
@@ -71,18 +198,22 @@ module Antelope
       # @yieldreturn [String] The new content to write to the output.
       # @return [void]
       def template(source, destination)
-        src_file  = Pathname.new(source)
-          .expand_path(self.class.source_root)
-        src       = src_file.open("r")
-        context   = instance_eval('binding')
-        erb       = ERB.new(src.read, nil, "%")
-        erb.filename = source
-        content   = erb.result(context)
-        content   = yield content if block_given?
-        dest_file = Pathname.new(destination)
-          .expand_path(grammar.output)
-        dest_file.open("w") do |f|
-          f.write(content)
+        src  = Pathname.new("#{source}.ant").
+          expand_path(self.class.source_root)
+
+        template = Template.new(src)
+        content  = template.result(instance_eval('binding'))
+        content.gsub!(/[ \t]+\n/, "\n")
+
+        if block_given?
+          content = yield content
+        end
+
+        dest = Pathname.new(destination).
+          expand_path(grammar.output)
+
+        dest.open("w") do |file|
+          file.write(content)
         end
       end
 
@@ -99,7 +230,11 @@ module Antelope
       #
       # @return [Array<Hash<Symbol => Array<(Symbol, Numeric)>>>]
       def table
-        mods[:tableizer].table
+        if mods[:tableizer].is_a? Generation::Tableizer
+          mods[:tableizer].table
+        else
+          []
+        end
       end
 
       # Returns an array of the production information of each
@@ -122,6 +257,8 @@ module Antelope
            production[:block]]
         end
       end
+
+
     end
   end
 end

data/lib/antelope/generator/c.rb

@@ -0,0 +1,11 @@
+module Antelope
+  module Generator
+    class C < Group
+      register_as "c", "C"
+
+      register_generator CHeader, "c-header"
+      register_generator CSource, "c-source"
+
+    end
+  end
+end

data/lib/antelope/generator/c_header.rb

@@ -0,0 +1,105 @@
+module Antelope
+  module Generator
+    class CHeader < Base
+
+      register_as "c-header", "c_header"
+
+      has_directive "union", Array[String, String]
+      has_directive "api.prefix", String
+      has_directive "api.push-pull", String
+      has_directive "api.value.type", String
+      has_directive "api.token.prefix", String
+      has_directive "parse-param", Array
+      has_directive "lex-param", Array
+      has_directive "param", Array
+
+      def push?
+        directives.api.push_pull == "push"
+      end
+
+      def define_stype?
+        !!directives.union[0] && !directives.api.value.type
+      end
+
+      def lex_params
+        params = [directives.lex_param, directives.param].compact.
+          flatten
+
+        if params.any?
+          ", " << params.join(", ")
+        else
+          ""
+        end
+      end
+
+      def parse_params
+        [directives.parse_param, directives.param].compact.flatten.
+          join(", ")
+      end
+
+      def params
+        if directives.param
+          directives.param.join(", ")
+        else
+          ""
+        end
+      end
+
+      def stype
+        prefix.upcase << if directives.api.value.type
+          directives.api.value.type
+        elsif directives.union.size > 1
+          directives.union[0]
+        else
+          "STYPE"
+        end
+      end
+
+      def union_body
+        directives.union.last
+      end
+
+      def terminal_type
+        "int" # for now
+      end
+
+      def token_prefix
+        if directives.api.token.prefix
+          directives.api.token.prefix
+        elsif directives.api.prefix
+          prefix.upcase
+        else
+          ""
+        end
+      end
+
+      def prefix
+        if directives.api.prefix
+          directives.api.prefix
+        else
+          "yy"
+        end
+      end
+
+      def upper_prefix
+        prefix.upcase
+      end
+
+      def symbols
+        @_symbols ||= begin
+          sym  = grammar.terminals.map(&:name) + grammar.nonterminals
+          nums = sym.each_with_index.map { |v, i| [v, i + 257] }
+          Hash[nums]
+        end
+      end
+
+      def guard_name
+        "#{prefix.upcase}#{file.gsub(/[\W]/, "_").upcase}"
+      end
+
+      def generate
+        template "c_header", "#{file}.h"
+      end
+    end
+  end
+end

data/lib/antelope/generator/c_source.rb

@@ -0,0 +1,39 @@
+module Antelope
+  module Generator
+    class CSource < CHeader
+
+      def action_for(state)
+        out = ""
+
+        grammar.terminals.each do |terminal|
+          action = state[terminal.name]
+
+          if action.size == 2 && action[0] == :state
+            out << "#{action[1] + 1}, "
+          elsif action.size == 2 &&
+            [:reduce, :accept].include?(action[0])
+            if $DEBUG
+              out << "#{prefix.upcase}STATES + #{action[1] + 1}, "
+            else
+              out << "#{table.size + action[1] + 1}, "
+            end
+          else
+            out << "0, "
+          end
+
+        end
+
+        out.chomp(", ")
+      end
+
+      def cify_block(block)
+        block.gsub(/\$([0-9]+)/, "#{prefix}vals[\\1]")
+             .gsub(/\$\$/, "#{prefix}out")
+      end
+
+      def generate
+        template "c_source", "#{file}.c"
+      end
+    end
+  end
+end