antelope 0.0.1

data/examples/simple.output

@@ -0,0 +1,194 @@
+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:
+  --- highest
+  nonassoc 1:
+    {_}
+  nonassoc 0:
+    {$}
+  --- 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:
+  rules:
+    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)
+      {}
+
+  transitions:
+    e    : State 1
+    l    : State 2
+    r    : State 3
+    IDENT: State 4
+    STAR : State 5
+
+State 1:
+  rules:
+    6/n0: $start(0) → e • $
+      {}
+
+  transitions:
+    $: State 7
+
+State 2:
+  rules:
+    7/n1: e(0:1) → l • "=" r
+      {}
+    15/n1: r(8:10) → l • 
+      {$}
+
+  transitions:
+    EQUALS: State 8
+
+State 3:
+  rules:
+    9/n1: e(0:1) → r • 
+      {$}
+
+  transitions:
+
+State 4:
+  rules:
+    10/n1: l(8:2) → IDENT • 
+      {"=", $}
+
+  transitions:
+
+State 5:
+  rules:
+    11/n1: l(8:2) → "*" • r
+      {}
+    12/n1: r(8:10) →  • l(5:2)
+      {}
+    13/n1: l(8:2) →  • IDENT
+      {}
+    14/n1: l(8:2) →  • "*" r(5:9)
+      {}
+
+  transitions:
+    r    : State 9
+    l    : State 2
+    IDENT: State 4
+    STAR : State 5
+
+State 6:
+  rules:
+    15/n1: r(8:10) → l • 
+      {$}
+
+  transitions:
+
+State 7:
+  rules:
+    16/n0: $start(0) → e $ • 
+      {}
+
+  transitions:
+
+State 8:
+  rules:
+    17/n1: e(0:1) → l "=" • r
+      {}
+    18/n1: r(8:10) →  • l(8:2)
+      {}
+    19/n1: l(8:2) →  • IDENT
+      {}
+    20/n1: l(8:2) →  • "*" r(5:9)
+      {}
+
+  transitions:
+    r    : State 10
+    l    : State 2
+    IDENT: State 4
+    STAR : State 5
+
+State 9:
+  rules:
+    21/n1: l(8:2) → "*" r • 
+      {"=", $}
+
+  transitions:
+
+State 10:
+  rules:
+    22/n1: e(0:1) → l "=" r • 
+      {$}
+
+  transitions:
+

data/lib/antelope/ace/compiler.rb

@@ -0,0 +1,290 @@
+require "rubygems/requirement"
+
+module Antelope
+  module Ace
+
+    # Compiles a set of tokens generated by {Scanner}.  These tokens
+    # may not nessicarily have been generated by {Scanner}, however
+    # the tokens must follow the same rules even still.
+    #
+    # A list of all tokens that this compiler accepts:
+    #
+    # - `:directive` (2 arguments)
+    # - `:copy` (1 argument)
+    # - `:second` (no arguments)
+    # - `:label` (1 argument)
+    # - `:part` (1 argument)
+    # - `:or` (no arguments)
+    # - `:prec` (1 argument)
+    # - `:block` (1 argument)
+    # - `:third` (no arguments)
+    # - `:body` (1 argument)
+    #
+    # The tokens are handled by methods that follow the rule
+    # `compile_<token name>`.
+    class Compiler
+
+      # The body of the output compiler.  This should be formatted in
+      # the language that the parser is to be written in.  Some output
+      # generators may have special syntax that allows the parser to
+      # be put in the body; see the output generators for more.
+      #
+      # @return [String]
+      attr_accessor :body
+
+      # A list of all the rules that are defined in the file.  The
+      # rules are defined as such:
+      #
+      # - **`label`** (`Symbol`) &mdash; The left-hand side of the rule;
+      #   this is the nonterminal that the right side reduces to.
+      # - **`set`** (`Array<Symbol>`) &mdash; The right-hand side of the
+      #   rule.  This is a combination of terminals and nonterminals.
+      # - **`block`** (`String`) &mdash; 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`) &mdash; The presidence level for the
+      #   rule.  This should be a nonterminal or terminal.  Optional;
+      #   default value is `""`.
+      #
+      # @return [Array<Hash>]
+      attr_accessor :rules
+
+      # Options defined by directives in the first part of the file.
+      #
+      # - **`:terminals`** (`Array<Symbol, String?)>)` &mdash; A list
+      #   of all of the terminals in the language.  If this is not
+      #   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
+      #   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.
+      # - **`:extra`** (`Hash<Symbol, Array<Object>>`) &mdash; Extra
+      #   options that are not defined here.
+      # @return [Hash]
+      attr_accessor :options
+
+      # Creates a compiler, and then runs the compiler.
+      #
+      # @param (see #initialize)
+      # @see #compile
+      # @return [Compiler] the compiler.
+      def self.compile(tokens)
+        new(tokens).compile
+      end
+
+      # Initialize the compiler.  The compiler keeps track of a state;
+      # this state is basically which part of the file we're in.  The
+      # state can be `:first`, `:second`, or `:third`; some tokens
+      # may not exist in certain states.
+      #
+      # @param tokens [Array<Array<(Symbol, Object, ...)>>] the tokens
+      #   from the {Scanner}.
+      def initialize(tokens)
+        @tokens   = tokens
+        @body     = ""
+        @state    = :first
+        @rules    = []
+        @current  = nil
+        @current_label = nil
+        @options  = { :terminals => [], :prec => [], :extra => {} }
+      end
+
+      # Runs the compiler on the input tokens.  For each token,
+      # it calls `compile_<type>` with `<type>` being the first
+      # element of the token, with the remaining part of the array
+      # passed as arguments.
+      #
+      # @return [self]
+      def compile
+        @tokens.each do |token|
+          send(:"compile_#{token[0]}", *token[1..-1])
+        end
+
+        self
+      end
+
+      # Compiles a directive.  This may only be triggered in the first
+      # section of the file.  The directive accepts two arguments. The
+      # directive name can be any of the following:
+      #
+      # - `:terminal` &mdash; adds a terminal.  Requires 1-2
+      #   arguments; the first argument is the terminal name, and the
+      #   second argument is a string that can represent the terminal.
+      # - `:require` &mdash; requires a certain version of 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
+      #   is left associative.
+      # - `:right` &mdash; creates a new presidence level, with the
+      #   argument valeus being the symbols.  The presidence level
+      #   is right associative.
+      # - `:nonassoc` &mdash; creates a nre presidence level, with the
+      #   argument values being the symbols.  The presidence level
+      #   is nonassociative.
+      # - `:type` &mdash; the type of parser to generate.  This should
+      #   correspond to the output language of the parser.  Currently
+      #   ineffective.
+      #
+      # @param name [String, Symbol] the name of the directive.
+      #   Accepts any of `:terminal`, `:require`, `:left`, `:right`,
+      #   `:nonassoc`, and `:type`.  Any other values produce an
+      #   error on stderr and are put in the `:extra` hash on
+      #   {#options}.
+      # @param args [Array<String>] the arguments to the directive.
+      # @return [void]
+      # @see #options
+      def compile_directive(name, args)
+        require_state! :first
+        name = name.intern
+        case name
+        when :terminal
+          @options[:terminals] << [args[0].intern, args[1]]
+        when :require
+          compare_versions(args[0])
+        when :left, :right, :nonassoc
+          @options[:prec] << [name, *args.map(&:intern)]
+        when :type
+          @options[:type] = args[0]
+        else
+          @options[:extra][name] = args
+          $stderr.puts "Unknown Directive: #{name}"
+        end
+      end
+
+      # Compiles a copy token.  A copy token basically copies its
+      # argument directly into the body.  Used in both the first
+      # and third parts.
+      #
+      # @param body [String] the string to copy into the body.
+      # @return [void]
+      def compile_copy(body)
+        require_state! :first, :third
+        @body << body
+      end
+
+      # Sets the state to the second part.
+      #
+      # @return [void]
+      def compile_second
+        @state = :second
+      end
+
+      # Compiles a label.  This starts a rule definition.  The token
+      # should only exist in the second part.  A rule definition
+      # occurs by setting the `@current_label` to the first argument,
+      # and `@current` to a blank rule save the label set.  If a
+      # rule definition was already in progress, it is completed.
+      #
+      # @param label [String] the left-hand side of the rule; it
+      #   should be a nonterminal.
+      # @return [void]
+      def compile_label(label)
+        require_state! :second
+        if @current
+          @rules << @current
+        end
+
+        @current_label = label.intern
+
+        @current = {
+          label: @current_label,
+          set:   [],
+          block: "",
+          prec:  ""
+        }
+      end
+
+      # Compiles a part.  This should only occur during a rule
+      # definition.  The token should only exist in the second part.
+      # It adds the first argument to the set of the current rule.
+      #
+      # @param text [String] the symbol to append to the current rule.
+      def compile_part(text)
+        require_state! :second
+        @current[:set] << text.intern
+      end
+
+      # Compiles an or.  This should only occur in a rule definition,
+      # and in the second part.  It starts a new rule definition by
+      # calling {#compile_label} with the current label.
+      #
+      # @return [void]
+      # @see #compile_label
+      def compile_or
+        compile_label(@current_label)
+      end
+
+      # Compiles the presidence operator.  This should only occur in a
+      # rule definition, and in the second part.  It sets the
+      # presidence definition on the current rule.
+      #
+      # @param prec [String] the presidence of the rule.
+      # @return [void]
+      def compile_prec(prec)
+        require_state! :second
+        @current[:prec] = prec
+      end
+
+      # Compiles a block.  This should only occur in a rule
+      # definition, and in the second part.  It sets the block on the
+      # current rule.
+      #
+      # @param block [String] the block.
+      # @return [void]
+      def compile_block(block)
+        require_state! :second
+        @current[:block] = block
+      end
+
+      # Sets the state to the third part.  If a rule definition was
+      # in progress, it finishes the rule.
+      #
+      # @return [void]
+      def compile_third
+        if @current
+          @rules << @current
+          @current_label = @current = nil
+        end
+
+        @state = :third
+      end
+
+      private
+
+      # Checks the current state against the given states.
+      #
+      # @raise [InvalidStateError] if none of the given states match
+      #   the current state.
+      # @return [void]
+      def require_state!(*state)
+        raise InvalidStateError,
+          "In state #{@state}, " \
+          "required state #{state.join(", ")}" \
+          unless state.include?(@state)
+      end
+
+      # Compares the required version and the Antelope version.
+      #
+      # @raise [IncompatibleVersionError] if the Antelope version
+      #   doesn't meet the requirement.
+      # @return [void]
+      def compare_versions(required)
+        antelope_version = Gem::Version.new(Antelope::VERSION)
+        required_version = Gem::Requirement.new(required)
+
+        unless required_version =~ antelope_version
+          raise IncompatibleVersionError,
+            "Grammar requires #{args[0]}, " \
+            "have #{Antelope::VERSION}"
+        end
+      end
+    end
+  end
+end

data/lib/antelope/ace/errors.rb

@@ -0,0 +1,27 @@
+module Antelope
+  module Ace
+
+    # 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
+    end
+
+    # Used primarily in the {Scanner}, this is raised when an input
+    # is malformed.  The message should contain a snippet of the input
+    # which caused the error.
+    class SyntaxError < Error
+    end
+
+    # This is used primarily in the {Grammar}; if a rule references a
+    # token (a nonterminal or a terminal) that was not previously
+    # defined, this is raised.
+    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.
+    class InvalidStateError < Error
+    end
+  end
+end

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

@@ -0,0 +1,47 @@
+module Antelope
+  module Ace
+    class Grammar
+
+      # The default modifiers for generation.  It's not really
+      # recommended to (heh) modify this; however, adding your own
+      # modifier is always acceptable.
+      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
+
+      # Handles the generation of output for the grammar.
+      module Generation
+
+        # Generates the output.  First, it runs through every given
+        # modifier, and instintates it.  It then calls every modifier,
+        # turns it into a hash, and passes that hash to each of the
+        # given generators.
+        #
+        # @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,
+                     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|
+            gen.new(self, hash).generate
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,51 @@
+module Antelope
+  module Ace
+    class Grammar
+
+      # Handles loading to and from files and strings.
+      module Loading
+
+        # Defines class methods on the grammar.
+        module ClassMethods
+
+          # Loads a grammar from a file.  Assumes the output
+          # directory and name from the file name.
+          #
+          # @param file_name [String] the file name.
+          # @return [Grammar]
+          # @see #from_string
+          def from_file(file_name)
+            body     = File.read(file_name)
+            output   = File.dirname(file_name)
+            name     = File.basename(file_name).gsub(/\.[A-Za-z]+/, "")
+            from_string(name, output, body)
+          end
+
+          # Loads a grammar from a string.  First runs the scanner and
+          # compiler over the string, and then instantiates a new
+          # Grammar from the resultant.
+          #
+          # @param name [String] the name of the grammar.
+          # @param output [String] the output directory.
+          # @param string [String] the grammar body.
+          # @return [Grammar]
+          # @see Ace::Scanner
+          # @see Ace::Compiler
+          def from_string(name, output, string)
+            scanner  = Ace::Scanner.scan(string)
+            compiler = Ace::Compiler.compile(scanner)
+            new(name, output, compiler)
+          end
+        end
+
+        # Extends the grammar with the class methods.
+        #
+        # @param receiver [Grammar]
+        # @see ClassMethods
+        def self.included(receiver)
+          receiver.extend ClassMethods
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,59 @@
+require "set"
+
+module Antelope
+  module Ace
+    class Grammar
+
+      # Manages presidence for tokens.
+      module Presidence
+
+        # Accesses the generated presidence list.  Lazily generates
+        # the presidence rules on the go, and then caches it.
+        #
+        # @return [Array<Ace::Presidence>]
+        def presidence
+          @_presidence ||= generate_presidence
+        end
+
+        # Finds a presidence 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::Presidence]
+        def presidence_for(token)
+          token = token.name if token.is_a?(Token)
+
+          set = Set.new([token, :_])
+
+          presidence.
+            select { |pr| set.intersect?(pr.tokens) }.
+            first
+        end
+
+        private
+
+        # Generates the presidence rules.  Loops through the compiler
+        # given presidence settings, and then adds two default
+        # presidence rules; one for `:$` (level 0, nonassoc), and one
+        # for `:_` (level 1, nonassoc).
+        #
+        # @return [Array<Ace::Presidence>]
+        def generate_presidence
+          size = @compiler.options[:prec].size + 1
+          presidence = @compiler.options[:prec].
+            each_with_index.map do |prec, i|
+            Ace::Presidence.new(prec[0], prec[1..-1].to_set, size - i)
+          end
+
+          presidence <<
+            Ace::Presidence.new(:nonassoc, [:"$"].to_set, 0) <<
+            Ace::Presidence.new(:nonassoc, [:_].to_set, 1)
+          presidence.sort_by { |_| _.level }.reverse
+        end
+
+      end
+    end
+  end
+end