antelope 0.0.1 → 0.1.0

data/examples/simple.output

@@ -1,30 +1,36 @@
 Productions:
-    0/n0: $start(0) → e(0:1) $
-    1/n1: e(0:1) → l(0:2) "=" r(8:10)
-    2/n1: e(0:1) → r(0:3)
-    3/n1: l(8:2) → IDENT
-    4/n1: l(8:2) → "*" r(5:9)
-    5/n1: r(8:10) → l(0:2)
-    12/n1: r(8:10) → l(5:2)
-    18/n1: r(8:10) → l(8:2)
-
-Original Productions:
-  e → l "=" r
-    
-  e → r
-    
-  l → IDENT
-    
-  l → "*" r
-    
-  r → l
-    
-  $start → e $
-    
-
-Conflicts:
-
-Presidence:
+  e → l "=" r 
+  e → r 
+  l → IDENT 
+  l → "*" r 
+  r → l 
+  $start → e $ 
+
+Productions, Again:
+  0/n0: $start(0) → e(0:1) $
+  1/n1: e(0:1) → l(0:2) "=" r(8:10)
+  2/n1: e(0:1) → r(0:3)
+  3/n1: l(0:2) → IDENT
+  4/n1: l(0:2) → "*" r(5:9)
+  5/n1: r(0:3) → l(0:2)
+  12/n1: r(5:9) → l(5:2)
+  13/n1: l(5:2) → IDENT
+  14/n1: l(5:2) → "*" r(5:9)
+  18/n1: r(8:10) → l(8:2)
+  19/n1: l(8:2) → IDENT
+  20/n1: l(8:2) → "*" r(5:9)
+
+FOLLOW:
+  $start(0): {}
+  e(0:1): {$}
+  l(0:2): {"=", $}
+  r(0:3): {$}
+  r(5:9): {"=", $}
+  l(5:2): {}
+  l(8:2): {$}
+  r(8:10): {$}
+
+Precedence:
   --- highest
   nonassoc 1:
     {_}
@@ -33,48 +39,40 @@ Presidence:
   --- lowest
 
 Table:
-{0=>
-  {:e=>[:state, 1],
-   :l=>[:state, 2],
-   :r=>[:state, 3],
-   :IDENT=>[:state, 4],
-   :STAR=>[:state, 5]},
- 1=>{:"$"=>[:state, 7]},
- 2=>{:EQUALS=>[:state, 8], :"$"=>[:reduce, 5]},
- 3=>{:"$"=>[:reduce, 2]},
- 4=>{:EQUALS=>[:reduce, 3], :"$"=>[:reduce, 3]},
- 5=>
-  {:r=>[:state, 9], :l=>[:state, 2], :IDENT=>[:state, 4], :STAR=>[:state, 5]},
- 6=>{:"$"=>[:reduce, 5]},
- 7=>{:"$"=>[:accept, 0]},
- 8=>
-  {:r=>[:state, 10], :l=>[:state, 2], :IDENT=>[:state, 4], :STAR=>[:state, 5]},
- 9=>{:EQUALS=>[:reduce, 4], :"$"=>[:reduce, 4]},
- 10=>{:"$"=>[:reduce, 1]}}
-
-[#<Antelope::Generation::Recognizer::Rule id=0 left=$start(0) right=[e(0:1) $] position=0>,
- #<Antelope::Generation::Recognizer::Rule id=1 left=e(0:1) right=[l(0:2) "=" r(8:10)] position=0>,
- #<Antelope::Generation::Recognizer::Rule id=2 left=e(0:1) right=[r(0:3)] position=0>,
- #<Antelope::Generation::Recognizer::Rule id=3 left=l(8:2) right=[IDENT] position=0>,
- #<Antelope::Generation::Recognizer::Rule id=4 left=l(8:2) right=["*" r(5:9)] position=0>,
- #<Antelope::Generation::Recognizer::Rule id=5 left=r(8:10) right=[l(0:2)] position=0>,
- #<Antelope::Generation::Recognizer::Rule id=6 left=$start(0) right=[e $] position=1>,
- #<Antelope::Generation::Recognizer::Rule id=7 left=e(0:1) right=[l "=" r] position=1>,
- nil,
- #<Antelope::Generation::Recognizer::Rule id=9 left=e(0:1) right=[r] position=1>,
- #<Antelope::Generation::Recognizer::Rule id=10 left=l(8:2) right=[IDENT] position=1>,
- #<Antelope::Generation::Recognizer::Rule id=11 left=l(8:2) right=["*" r] position=1>,
- #<Antelope::Generation::Recognizer::Rule id=12 left=r(8:10) right=[l(5:2)] position=0>,
- #<Antelope::Generation::Recognizer::Rule id=13 left=l(8:2) right=[IDENT] position=0>,
- #<Antelope::Generation::Recognizer::Rule id=14 left=l(8:2) right=["*" r(5:9)] position=0>,
- #<Antelope::Generation::Recognizer::Rule id=15 left=r(8:10) right=[l] position=1>,
- #<Antelope::Generation::Recognizer::Rule id=16 left=$start(0) right=[e $] position=2>,
- #<Antelope::Generation::Recognizer::Rule id=17 left=e(0:1) right=[l "=" r] position=2>,
- #<Antelope::Generation::Recognizer::Rule id=18 left=r(8:10) right=[l(8:2)] position=0>,
- #<Antelope::Generation::Recognizer::Rule id=19 left=l(8:2) right=[IDENT] position=0>,
- #<Antelope::Generation::Recognizer::Rule id=20 left=l(8:2) right=["*" r(5:9)] position=0>,
- #<Antelope::Generation::Recognizer::Rule id=21 left=l(8:2) right=["*" r] position=2>,
- #<Antelope::Generation::Recognizer::Rule id=22 left=e(0:1) right=[l "=" r] position=3>]
+  State 0:
+    e     : state (1)
+    l     : state (2)
+    r     : state (3)
+    IDENT : state (4)
+    STAR  : state (5)
+  State 1:
+    $     : state (7)
+  State 2:
+    EQUALS: state (8)
+    $     : reduce (5)
+  State 3:
+    $     : reduce (2)
+  State 4:
+    $     : reduce (3)
+  State 5:
+    r     : state (9)
+    l     : state (2)
+    IDENT : state (4)
+    STAR  : state (5)
+  State 6:
+    $     : reduce (5)
+  State 7:
+    $     : accept (0)
+  State 8:
+    r     : state (10)
+    l     : state (2)
+    IDENT : state (4)
+    STAR  : state (5)
+  State 9:
+    $     : reduce (4)
+  State 10:
+    $     : reduce (1)
+  
 
 State 0:
   rules:
@@ -84,11 +82,11 @@ State 0:
       {}
     2/n1: e(0:1) →  • r(0:3)
       {}
-    3/n1: l(8:2) →  • IDENT
+    3/n1: l(0:2) →  • IDENT
       {}
-    4/n1: l(8:2) →  • "*" r(5:9)
+    4/n1: l(0:2) →  • "*" r(5:9)
       {}
-    5/n1: r(8:10) →  • l(0:2)
+    5/n1: r(0:3) →  • l(0:2)
       {}
 
   transitions:
@@ -100,7 +98,7 @@ State 0:
 
 State 1:
   rules:
-    6/n0: $start(0) → e • $
+    6/n0: $start → e • $
       {}
 
   transitions:
@@ -108,9 +106,9 @@ State 1:
 
 State 2:
   rules:
-    7/n1: e(0:1) → l • "=" r
+    7/n1: e → l • "=" r
       {}
-    15/n1: r(8:10) → l • 
+    15/n1: r → l • 
       {$}
 
   transitions:
@@ -118,27 +116,27 @@ State 2:
 
 State 3:
   rules:
-    9/n1: e(0:1) → r • 
+    9/n1: e → r • 
       {$}
 
   transitions:
 
 State 4:
   rules:
-    10/n1: l(8:2) → IDENT • 
-      {"=", $}
+    10/n1: l → IDENT • 
+      {$}
 
   transitions:
 
 State 5:
   rules:
-    11/n1: l(8:2) → "*" • r
+    11/n1: l → "*" • r
       {}
-    12/n1: r(8:10) →  • l(5:2)
+    12/n1: r(5:9) →  • l(5:2)
       {}
-    13/n1: l(8:2) →  • IDENT
+    13/n1: l(5:2) →  • IDENT
       {}
-    14/n1: l(8:2) →  • "*" r(5:9)
+    14/n1: l(5:2) →  • "*" r(5:9)
       {}
 
   transitions:
@@ -149,21 +147,21 @@ State 5:
 
 State 6:
   rules:
-    15/n1: r(8:10) → l • 
+    15/n1: r → l • 
       {$}
 
   transitions:
 
 State 7:
   rules:
-    16/n0: $start(0) → e $ • 
+    16/n0: $start → e $ • 
       {}
 
   transitions:
 
 State 8:
   rules:
-    17/n1: e(0:1) → l "=" • r
+    17/n1: e → l "=" • r
       {}
     18/n1: r(8:10) →  • l(8:2)
       {}
@@ -180,14 +178,14 @@ State 8:
 
 State 9:
   rules:
-    21/n1: l(8:2) → "*" r • 
-      {"=", $}
+    21/n1: l → "*" r • 
+      {$}
 
   transitions:
 
 State 10:
   rules:
-    22/n1: e(0:1) → l "=" r • 
+    22/n1: e → l "=" r • 
       {$}
 
   transitions:

data/lib/antelope/ace/compiler.rb

@@ -42,7 +42,7 @@ module Antelope
       # - **`block`** (`String`) — The code to be run on a reduction.
       #   this should be formatted in the language that the output
       #   parser is written in.  Optional; default value is `""`.
-      # - **`prec`** (`String`) — The presidence level for the
+      # - **`prec`** (`String`) — The precedence level for the
       #   rule.  This should be a nonterminal or terminal.  Optional;
       #   default value is `""`.
       #
@@ -56,13 +56,12 @@ module Antelope
       #   properly defined, the grammar will throw an error saying
       #   that a symbol used in the grammar is not defined.
       # - **`:prec`** (`Array<(Symbol, Array<Symbol>)>`) &mdash; A list
-      #   of the presidence rules of the grammar.  The first element
-      #   of each element is the _type_ of presidence (and should be
+      #   of the precedence rules of the grammar.  The first element
+      #   of each element is the _type_ of precedence (and should be
       #   any of `:left`, `:right`, or `:nonassoc`), and the second
       #   element should be the symbols that are on that level.
       # - **`:type`** (`String`) &mdash; The type of generator to
-      #   generate; this should be a language.  It's currently
-      #   ineffective.
+      #   generate; this should be a language.
       # - **`:extra`** (`Hash<Symbol, Array<Object>>`) &mdash; Extra
       #   options that are not defined here.
       # @return [Hash]
@@ -119,18 +118,17 @@ module Antelope
       #   Requires 1 argument.  If the first argument is a version
       #   greater than the current version of Antelope, it raises
       #   an error.
-      # - `:left` &mdash; creates a new presidence level, with the
-      #   argument values being the symbols.  The presidence level
+      # - `:left` &mdash; creates a new precedence level, with the
+      #   argument values being the symbols.  The precedence level
       #   is left associative.
-      # - `:right` &mdash; creates a new presidence level, with the
-      #   argument valeus being the symbols.  The presidence level
+      # - `:right` &mdash; creates a new precedence level, with the
+      #   argument valeus being the symbols.  The precedence level
       #   is right associative.
-      # - `:nonassoc` &mdash; creates a nre presidence level, with the
-      #   argument values being the symbols.  The presidence level
+      # - `:nonassoc` &mdash; creates a nre precedence level, with the
+      #   argument values being the symbols.  The precedence level
       #   is nonassociative.
       # - `:type` &mdash; the type of parser to generate.  This should
-      #   correspond to the output language of the parser.  Currently
-      #   ineffective.
+      #   correspond to the output language of the parser.
       #
       # @param name [String, Symbol] the name of the directive.
       #   Accepts any of `:terminal`, `:require`, `:left`, `:right`,
@@ -221,11 +219,11 @@ module Antelope
         compile_label(@current_label)
       end
 
-      # Compiles the presidence operator.  This should only occur in a
+      # Compiles the precedence operator.  This should only occur in a
       # rule definition, and in the second part.  It sets the
-      # presidence definition on the current rule.
+      # precedence definition on the current rule.
       #
-      # @param prec [String] the presidence of the rule.
+      # @param prec [String] the precedence of the rule.
       # @return [void]
       def compile_prec(prec)
         require_state! :second

data/lib/antelope/ace/errors.rb

@@ -4,7 +4,7 @@ module Antelope
     # Defines an error that can occur within the Ace module.  All
     # errors that are raised within the Ace module are subclasses of
     # this.
-    class Error < StandardError
+    class Error < Antelope::Error
     end
 
     # Used primarily in the {Scanner}, this is raised when an input
@@ -19,9 +19,15 @@ module Antelope
     class UndefinedTokenError < Error
     end
 
-    # Pimarily used in the {Compiler}, if a scanner token appears that
-    # should not be in the current state, this is raised.
+    # Primarily used in the {Compiler}, if a scanner token appears
+    # that should not be in the current state, this is raised.
     class InvalidStateError < Error
     end
+
+    # Primarily used in the {Grammar} (specifically
+    # {Grammar::Generation}), if the grammar could not determine the
+    # generator to use for the generation, it raises this.
+    class NoTypeError < Error
+    end
   end
 end

data/lib/antelope/ace/grammar/generation.rb

@@ -8,14 +8,12 @@ module Antelope
       DEFAULT_MODIFIERS = [
         [:recognizer,  Generation::Recognizer ],
         [:constructor, Generation::Constructor],
-        [:conflictor,  Generation::Conflictor ],
         [:tableizer,   Generation::Tableizer  ]
       ].freeze
 
-      # The (as of right now) default generators.  Later on, the
-      # grammar will guess which generators are needed for the
-      # specific ace file.
-      DEFAULT_GENERATORS = [Generator::Output, Generator::Ruby].freeze
+      DEFAULT_GENERATORS = {
+        "ruby" => [Generator::Ruby]
+      }
 
       # Handles the generation of output for the grammar.
       module Generation
@@ -25,22 +23,55 @@ module Antelope
         # turns it into a hash, and passes that hash to each of the
         # given generators.
         #
+        # @param options [Hash] options.
         # @param generators [Array<Generator>] a list of generators
         #   to use in generation.
         # @param modifiers [Array<Array<(Symbol, #call)>>] a list of
         #   modifiers to apply to the grammar.
         # @return [void]
-        def generate(generators = DEFAULT_GENERATORS,
+        def generate(options    = {},
+                     generators = :guess,
                      modifiers  = DEFAULT_MODIFIERS)
           mods = modifiers.map(&:last).
             map  { |x| x.new(self) }
           mods.map(&:call)
           hash = Hash[modifiers.map(&:first).zip(mods)]
           # This is when we'd generate
-          generators.each do |gen|
+
+          find_generators(generators, options).each do |gen|
             gen.new(self, hash).generate
           end
         end
+
+        private
+
+        # Find the corresponding generators.  If the first argument
+        # isn't `:guess`, it returns the first argument.  Otherwise,
+        # it tries to "intelligently guess" by checking the type from
+        # the options _or_ the compiler.  If it is unable to find the
+        # type, it will raise a {NoTypeError}.
+        #
+        # @raise [NoTypeError] if it could not determine the type of
+        #   the generator.
+        # @param generators [Symbol, Array<Generator>]
+        # @param options [Hash]
+        # @return [Array<Generator>]
+        def find_generators(generators, options)
+          return generators unless generators == :guess
+
+          generators = [Generator::Output]
+
+          # command line precedence...
+          type = options[:type] || options["type"] ||
+            compiler.options.fetch(:type)
+
+          generators += DEFAULT_GENERATORS.fetch(type)
+
+          generators
+
+        rescue KeyError => e
+          raise NoTypeError, "Undefined type #{type}"
+        end
       end
     end
   end

data/lib/antelope/ace/grammar/precedences.rb

@@ -0,0 +1,59 @@
+require "set"
+
+module Antelope
+  module Ace
+    class Grammar
+
+      # Manages precedence for tokens.
+      module Precedences
+
+        # Accesses the generated precedence list.  Lazily generates
+        # the precedence rules on the go, and then caches it.
+        #
+        # @return [Array<Ace::Precedence>]
+        def precedence
+          @_precedence ||= generate_precedence
+        end
+
+        # Finds a precedence rule for a given token.  If no direct
+        # rule is defined for that token, it will check for a rule
+        # defined for the special symbol, `:_`.  By default, there
+        # is always a rule defined for `:_`.
+        #
+        # @param token [Ace::Token, Symbol]
+        # @return [Ace::Precedence]
+        def precedence_for(token)
+          token = token.name if token.is_a?(Token)
+
+          set = Set.new([token, :_])
+
+          precedence.
+            select { |pr| set.intersect?(pr.tokens) }.
+            first
+        end
+
+        private
+
+        # Generates the precedence rules.  Loops through the compiler
+        # given precedence settings, and then adds two default
+        # precedence rules; one for `:$` (level 0, nonassoc), and one
+        # for `:_` (level 1, nonassoc).
+        #
+        # @return [Array<Ace::Precedence>]
+        def generate_precedence
+          size = @compiler.options[:prec].size + 1
+          precedence = @compiler.options[:prec].
+            each_with_index.map do |prec, i|
+            Ace::Precedence.new(prec[0], prec[1..-1].to_set, size - i)
+          end
+
+          precedence <<
+            Ace::Precedence.new(:nonassoc, [:"$"].to_set, 0) <<
+            Ace::Precedence.new(:nonassoc, [:_].to_set, 1)
+          precedence.sort_by { |_| _.level }.reverse
+        end
+
+      end
+    end
+  end
+end

data/lib/antelope/ace/grammar/production.rb

@@ -3,32 +3,31 @@ module Antelope
     class Grammar
 
       # Defines a production.
-      #
-      # @!attribute [rw] label
-      #   The label (or left-hand side) of the production.  This
-      #   should be a nonterminal.
-      #
-      #   @return [Symbol]
-      # @!attribute [rw] items
-      #   The body (or right-hand side) of the production.  This can
-      #   be array of terminals and nonterminals.
-      #
-      #   @return [Array<Token>]
-      # @!attribute [rw] block
-      #   The block of code to be executed when the production's right
-      #   hand side is reduced.
-      #
-      #   @return [String]
-      # @!attribute [rw] prec
-      #   The presidence declaration for the production.
-      #
-      #   @return [Ace::Presidence]
-      # @!attribute [rw] id
-      #   The ID of the production.  The starting production always
-      #   has an ID of 0.
-      #
-      #   @return [Numeric]
       class Production < Struct.new(:label, :items, :block, :prec, :id)
+        # @!attribute [rw] label
+        #   The label (or left-hand side) of the production.  This
+        #   should be a nonterminal.
+        #
+        #   @return [Symbol]
+        # @!attribute [rw] items
+        #   The body (or right-hand side) of the production.  This can
+        #   be array of terminals and nonterminals.
+        #
+        #   @return [Array<Token>]
+        # @!attribute [rw] block
+        #   The block of code to be executed when the production's right
+        #   hand side is reduced.
+        #
+        #   @return [String]
+        # @!attribute [rw] prec
+        #   The precedence declaration for the production.
+        #
+        #   @return [Ace::Precedence]
+        # @!attribute [rw] id
+        #   The ID of the production.  The starting production always
+        #   has an ID of 0.
+        #
+        #   @return [Numeric]
 
         # Creates a new production from a hash.  The hash's keys
         # correspond to the attributes on this class.

data/lib/antelope/ace/grammar/productions.rb

@@ -48,11 +48,11 @@ module Antelope
 
         # Generates a production for a given compiler rule.  Converts
         # the tokens in the set to their {Token} counterparts,
-        # and then sets the presidence for the production.  If the
-        # presidence declaration from the compiler rule is empty,
+        # and then sets the precedence for the production.  If the
+        # precedence declaration from the compiler rule is empty,
         # then it'll use the last terminal from the set to check for
-        # presidence; otherwise, it'll use the presidence declaration.
-        # This is to make sure that every production has a presidence
+        # precedence; otherwise, it'll use the precedence declaration.
+        # This is to make sure that every production has a precedence
         # declaration.
         #
         # @param rule [Hash] the compiler's rule.
@@ -67,7 +67,7 @@ module Antelope
             find_token(rule[:prec])
           end
 
-          prec  = presidence_for(prec)
+          prec  = precedence_for(prec)
 
           Production.new(Token::Nonterminal.new(left), items,
                rule[:block], prec, id + 1)
@@ -77,14 +77,14 @@ module Antelope
         # hand side of the production is the `:$start` symbol, with
         # the right hand side being the first rule's left-hand side
         # and the terminal `$`.  This production is automagically
-        # given the last presidence, and an id of 0.
+        # given the last precedence, and an id of 0.
         #
         # @return [Production]
         def default_production
           Production.new(Token::Nonterminal.new(:$start), [
               Token::Nonterminal.new(@compiler.rules.first[:label]),
               Token::Terminal.new(:"$")
-            ], "", presidence.last, 0)
+            ], "", precedence.last, 0)
         end
 
         # Finds a token based on its corresponding symbol.  First
@@ -92,7 +92,7 @@ module Antelope
         # tries to find it in the terminals; otherwise, if the symbol
         # is `error`, it returns a {Token::Error}; if the symbol is
         # `nothing` or `ε`, it returns a {Token::Epsilon}; if it's
-        # none of those, it raises an {UndefiendTokenError}.
+        # none of those, it raises an {UndefinedTokenError}.
         #
         # @raise [UndefinedTokenError] if the token doesn't exist.
         # @param value [String, Symbol, #intern] the token's symbol to

data/lib/antelope/ace/grammar.rb

@@ -1,6 +1,6 @@
 require "antelope/ace/grammar/terminals"
 require "antelope/ace/grammar/productions"
-require "antelope/ace/grammar/presidence"
+require "antelope/ace/grammar/precedences"
 require "antelope/ace/grammar/loading"
 require "antelope/ace/grammar/generation"
 require "antelope/ace/grammar/production"
@@ -9,13 +9,13 @@ module Antelope
   module Ace
 
     # Defines a grammar from an Ace file.  This handles setting up
-    # productions, loading from files, terminals, presidence, and
+    # productions, loading from files, terminals, precedence, and
     # generation.
     class Grammar
 
       include Terminals
       include Productions
-      include Presidence
+      include Precedences
       include Loading
       include Grammar::Generation
 

data/lib/antelope/ace/{presidence.rb → precedence.rb}

@@ -1,41 +1,41 @@
 module Antelope
   module Ace
 
-    # Defines a presidence.  A presidence has a type, tokens, and a
+    # Defines a precedence.  A precedence has a type, tokens, and a
     # level.
-    class Presidence < Struct.new(:type, :tokens, :level)
+    class Precedence < Struct.new(:type, :tokens, :level)
 
       # @!attribute [rw] type
-      #   The type of presidence level.  This should be one of
+      #   The type of precedence level.  This should be one of
       #   `:left`, `:right`, or `:nonassoc`.
       #
       #   @return [Symbol] the type.
       # @!attribute [rw] tokens
-      #   An set of tokens that are on this specific presidence
+      #   An set of tokens that are on this specific precedence
       #   level.  The tokens are identified as symbols.  The special
       #   symbol, `:_`, represents any token.
       #
       #   @return [Set<Symbol>] the tokens on this level.
       # @!attribute [rw] level
       #   The level we're on.  The higher the level, the higher the
-      #   presidence.
+      #   precedence.
 
       include Comparable
 
       # Compares the other object to this object.  If the other object
-      # isn't a {Presidence}, it returns nil.  If the other
-      # presidence isn't on the same level as this one, then the
+      # isn't a {Precedence}, it returns nil.  If the other
+      # precedence isn't on the same level as this one, then the
       # levels are compared and the result of that is returned.  If
-      # it is, however, the type is checked; if this presidence is
+      # it is, however, the type is checked; if this precedence is
       # left associative, then it returns 1 (it is greater than the
-      # other); if this presidence is right associative, then it
-      # returns -1 (it is less than the other); if this presidence is
+      # other); if this precedence is right associative, then it
+      # returns -1 (it is less than the other); if this precedence is
       # nonassociative, it returns 0 (it is equal to the other).
       #
       # @param other [Object] the object to compare to this one.
       # @return [Numeric?]
       def <=>(other)
-        return nil unless other.is_a? Presidence
+        return nil unless other.is_a? Precedence
         if level != other.level
           level <=> other.level
         elsif type == :left