antelope 0.2.0 → 0.2.2

data/lib/antelope/ace/compiler.rb

@@ -1,334 +1,334 @@
-# encoding: utf-8
-
-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` (2 arguments)
-    # - `:part` (2 arguments)
-    # - `: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 precedence 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 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.
-      # - **`: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    => [],
-          :nonterminals => [],
-          :prec         => [],
-          :type         => nil,
-          :extra        => Hashie::Extensions::IndifferentAccess.
-            inject!({})
-        }
-      end
-
-      # Pretty inspect.
-      #
-      # @return [String]
-      def inspect
-        "#<#{self.class} state=#{@state.inspect} options=#{options.inspect}>"
-      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 precedence level, with the
-      #   argument values being the symbols.  The precedence level
-      #   is left associative.
-      # - `: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 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.
-      #
-      # @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, :token
-          handle_token(args)
-        when :require
-          compare_versions(args[0])
-        when :left, :right, :nonassoc
-          options[:prec] << [name, *args.map(&:intern)]
-        when :language, :generator, :"grammar.type"
-          options[:type] = args[0].downcase
-        when :type
-          raise SyntaxError, "%type directive requires first " \
-            "argument to be caret" unless args[0].caret?
-
-          options[:nonterminals] <<
-            [args[0], args[1..-1].map(&:intern)]
-        when :define
-          compile_extra(args[0], args[1..-1])
-        else
-          compile_extra(name, args)
-        end
-      end
-
-      def compile_extra(name, args)
-        matching = Generator.directives[name.to_s]
-
-        raise NoDirectiveError, "no directive named #{name}" \
-          unless matching
-
-        options[:extra][name] = args
-      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, val)
-        require_state! :second
-        if @current
-          @rules << @current
-        end
-
-        label = label.intern
-        @current_label = [label, val]
-
-        @current = {
-          label: label,
-          label_id: val,
-          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, val)
-        require_state! :second
-        @current[:set] << [text.intern, val]
-      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 precedence operator.  This should only occur in a
-      # rule definition, and in the second part.  It sets the
-      # precedence definition on the current rule.
-      #
-      # @param prec [String] the precedence 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
-
-      def handle_token(args)
-        type = ""
-        if args[0].caret?
-          type = args.shift
-        end
-
-        name = args.shift
-        value = args.shift
-
-        options[:terminals] << [name.intern, type, nil, value]
-      end
-
-      # 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 #{required}, " \
-            "have #{Antelope::VERSION}"
-        end
-      end
-    end
-  end
-end
+# encoding: utf-8
+
+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` (2 arguments)
+    # - `:part` (2 arguments)
+    # - `: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 precedence 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 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.
+      # - **`: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    => [],
+          :nonterminals => [],
+          :prec         => [],
+          :type         => nil,
+          :extra        => Hashie::Extensions::IndifferentAccess.
+            inject!({})
+        }
+      end
+
+      # Pretty inspect.
+      #
+      # @return [String]
+      def inspect
+        "#<#{self.class} state=#{@state.inspect} options=#{options.inspect}>"
+      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 precedence level, with the
+      #   argument values being the symbols.  The precedence level
+      #   is left associative.
+      # - `: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 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.
+      #
+      # @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, :token
+          handle_token(args)
+        when :require
+          compare_versions(args[0])
+        when :left, :right, :nonassoc
+          options[:prec] << [name, *args.map(&:intern)]
+        when :language, :generator, :"grammar.type"
+          options[:type] = args[0].downcase
+        when :type
+          raise SyntaxError, "%type directive requires first " \
+            "argument to be caret" unless args[0].caret?
+
+          options[:nonterminals] <<
+            [args[0], args[1..-1].map(&:intern)]
+        when :define
+          compile_extra(args[0], args[1..-1])
+        else
+          compile_extra(name, args)
+        end
+      end
+
+      def compile_extra(name, args)
+        matching = Generator.directives[name.to_s]
+
+        raise NoDirectiveError, "no directive named #{name}" \
+          unless matching
+
+        options[:extra][name] = args
+      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, val)
+        require_state! :second
+        if @current
+          @rules << @current
+        end
+
+        label = label.intern
+        @current_label = [label, val]
+
+        @current = {
+          label: label,
+          label_id: val,
+          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, val)
+        require_state! :second
+        @current[:set] << [text.intern, val]
+      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 precedence operator.  This should only occur in a
+      # rule definition, and in the second part.  It sets the
+      # precedence definition on the current rule.
+      #
+      # @param prec [String] the precedence 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
+
+      def handle_token(args)
+        type = ""
+        if args[0].caret?
+          type = args.shift
+        end
+
+        name = args.shift
+        value = args.shift
+
+        options[:terminals] << [name.intern, type, nil, value]
+      end
+
+      # 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 #{required}, " \
+            "have #{Antelope::VERSION}"
+        end
+      end
+    end
+  end
+end