antelope 0.2.4 → 0.3.0

data/examples/example.ate.inf

@@ -0,0 +1,432 @@
+Productions:
+  15/n1: expression → NUMBER                     { match[0][1] }
+  26/n0: $start → expression $end
+  79/r4: expression → expression "^" expression  { match[0] ** match[2] }
+  85/l2: expression → expression "+" expression  { match[0] + match[2] }
+  91/l2: expression → expression "-" expression  { match[0] - match[2] }
+  97/l3: expression → expression "*" expression  { match[0] * match[2] }
+  103/l3: expression → expression "/" expression { match[0] / match[2] }
+  109/n1: expression → "(" expression ")"        { match[1] }
+  110/n1: expression → "(" $error ")"            { match[1] }
+
+
+Precedence:
+  --- highest
+  right    4:
+    {EXPONENTIATE}
+  left     3:
+    {MULTIPLY, DIVIDE}
+  left     2:
+    {ADD, SUBTRACT}
+  nonassoc 1:
+    {_}
+  nonassoc 0:
+    {$end}
+  --- lowest
+
+  State 0:
+    0/n0: $start →  • expression $end
+      {}
+    1/n1: expression →  • NUMBER
+      {}
+    2/r4: expression →  • expression "^" expression
+      {}
+    3/l2: expression →  • expression "+" expression
+      {}
+    4/l2: expression →  • expression "-" expression
+      {}
+    5/l3: expression →  • expression "*" expression
+      {}
+    6/l3: expression →  • expression "/" expression
+      {}
+    7/n1: expression →  • "(" expression ")"
+      {}
+    8/n1: expression →  • "(" $error ")"
+      {}
+    9/n0: $start → expression • $end
+      {}
+    10/r4: expression → expression • "^" expression
+      {}
+    11/l2: expression → expression • "+" expression
+      {}
+    12/l2: expression → expression • "-" expression
+      {}
+    13/l3: expression → expression • "*" expression
+      {}
+    14/l3: expression → expression • "/" expression
+      {}
+    15/n1: expression → NUMBER •
+      {$end, "^", "+", "-", "*", "/", ")"}
+    16/n1: expression → "(" • expression ")"
+      {}
+    17/n1: expression → "(" • $error ")"
+      {}
+    26/n0: $start → expression $end •
+      {}
+    27/r4: expression → expression "^" • expression
+      {}
+    36/l2: expression → expression "+" • expression
+      {}
+    45/l2: expression → expression "-" • expression
+      {}
+    54/l3: expression → expression "*" • expression
+      {}
+    63/l3: expression → expression "/" • expression
+      {}
+    72/n1: expression → "(" expression • ")"
+      {}
+    78/n1: expression → "(" $error • ")"
+      {}
+    79/r4: expression → expression "^" expression •
+      {$end, "^", "+", "-", "*", "/", ")"}
+    85/l2: expression → expression "+" expression •
+      {$end, "^", "+", "-", "*", "/", ")"}
+    91/l2: expression → expression "-" expression •
+      {$end, "^", "+", "-", "*", "/", ")"}
+    97/l3: expression → expression "*" expression •
+      {$end, "^", "+", "-", "*", "/", ")"}
+    103/l3: expression → expression "/" expression •
+      {$end, "^", "+", "-", "*", "/", ")"}
+    109/n1: expression → "(" expression ")" •
+      {$end, "^", "+", "-", "*", "/", ")"}
+    110/n1: expression → "(" $error ")" •
+      {$end, "^", "+", "-", "*", "/", ")"}
+    transitions:
+      expression: State 1
+      NUMBER: State 2
+      "(": State 3
+
+  State 1:
+    9/n0: $start → expression • $end
+      {}
+    10/r4: expression → expression • "^" expression
+      {}
+    11/l2: expression → expression • "+" expression
+      {}
+    12/l2: expression → expression • "-" expression
+      {}
+    13/l3: expression → expression • "*" expression
+      {}
+    14/l3: expression → expression • "/" expression
+      {}
+    transitions:
+      $end: State 4
+      "^": State 5
+      "+": State 6
+      "-": State 7
+      "*": State 8
+      "/": State 9
+
+  State 2:
+    15/n1: expression → NUMBER •
+      {$end, "^", "+", "-", "*", "/", ")"}
+    reductions:
+      $default: Rule 1
+
+  State 3:
+    16/n1: expression → "(" • expression ")"
+      {}
+    17/n1: expression → "(" • $error ")"
+      {}
+    18/n1: expression →  • NUMBER
+      {}
+    19/r4: expression →  • expression "^" expression
+      {}
+    20/l2: expression →  • expression "+" expression
+      {}
+    21/l2: expression →  • expression "-" expression
+      {}
+    22/l3: expression →  • expression "*" expression
+      {}
+    23/l3: expression →  • expression "/" expression
+      {}
+    24/n1: expression →  • "(" expression ")"
+      {}
+    25/n1: expression →  • "(" $error ")"
+      {}
+    transitions:
+      expression: State 10
+      $error: State 11
+      NUMBER: State 2
+      "(": State 3
+
+  State 4:
+    26/n0: $start → expression $end •
+      {}
+    accepting:
+      $end: Rule 0
+
+  State 5:
+    27/r4: expression → expression "^" • expression
+      {}
+    28/n1: expression →  • NUMBER
+      {}
+    29/r4: expression →  • expression "^" expression
+      {}
+    30/l2: expression →  • expression "+" expression
+      {}
+    31/l2: expression →  • expression "-" expression
+      {}
+    32/l3: expression →  • expression "*" expression
+      {}
+    33/l3: expression →  • expression "/" expression
+      {}
+    34/n1: expression →  • "(" expression ")"
+      {}
+    35/n1: expression →  • "(" $error ")"
+      {}
+    transitions:
+      expression: State 12
+      NUMBER: State 2
+      "(": State 3
+
+  State 6:
+    36/l2: expression → expression "+" • expression
+      {}
+    37/n1: expression →  • NUMBER
+      {}
+    38/r4: expression →  • expression "^" expression
+      {}
+    39/l2: expression →  • expression "+" expression
+      {}
+    40/l2: expression →  • expression "-" expression
+      {}
+    41/l3: expression →  • expression "*" expression
+      {}
+    42/l3: expression →  • expression "/" expression
+      {}
+    43/n1: expression →  • "(" expression ")"
+      {}
+    44/n1: expression →  • "(" $error ")"
+      {}
+    transitions:
+      expression: State 13
+      NUMBER: State 2
+      "(": State 3
+
+  State 7:
+    45/l2: expression → expression "-" • expression
+      {}
+    46/n1: expression →  • NUMBER
+      {}
+    47/r4: expression →  • expression "^" expression
+      {}
+    48/l2: expression →  • expression "+" expression
+      {}
+    49/l2: expression →  • expression "-" expression
+      {}
+    50/l3: expression →  • expression "*" expression
+      {}
+    51/l3: expression →  • expression "/" expression
+      {}
+    52/n1: expression →  • "(" expression ")"
+      {}
+    53/n1: expression →  • "(" $error ")"
+      {}
+    transitions:
+      expression: State 14
+      NUMBER: State 2
+      "(": State 3
+
+  State 8:
+    54/l3: expression → expression "*" • expression
+      {}
+    55/n1: expression →  • NUMBER
+      {}
+    56/r4: expression →  • expression "^" expression
+      {}
+    57/l2: expression →  • expression "+" expression
+      {}
+    58/l2: expression →  • expression "-" expression
+      {}
+    59/l3: expression →  • expression "*" expression
+      {}
+    60/l3: expression →  • expression "/" expression
+      {}
+    61/n1: expression →  • "(" expression ")"
+      {}
+    62/n1: expression →  • "(" $error ")"
+      {}
+    transitions:
+      expression: State 15
+      NUMBER: State 2
+      "(": State 3
+
+  State 9:
+    63/l3: expression → expression "/" • expression
+      {}
+    64/n1: expression →  • NUMBER
+      {}
+    65/r4: expression →  • expression "^" expression
+      {}
+    66/l2: expression →  • expression "+" expression
+      {}
+    67/l2: expression →  • expression "-" expression
+      {}
+    68/l3: expression →  • expression "*" expression
+      {}
+    69/l3: expression →  • expression "/" expression
+      {}
+    70/n1: expression →  • "(" expression ")"
+      {}
+    71/n1: expression →  • "(" $error ")"
+      {}
+    transitions:
+      expression: State 16
+      NUMBER: State 2
+      "(": State 3
+
+  State 10:
+    72/n1: expression → "(" expression • ")"
+      {}
+    73/r4: expression → expression • "^" expression
+      {}
+    74/l2: expression → expression • "+" expression
+      {}
+    75/l2: expression → expression • "-" expression
+      {}
+    76/l3: expression → expression • "*" expression
+      {}
+    77/l3: expression → expression • "/" expression
+      {}
+    transitions:
+      ")": State 17
+      "^": State 5
+      "+": State 6
+      "-": State 7
+      "*": State 8
+      "/": State 9
+
+  State 11:
+    78/n1: expression → "(" $error • ")"
+      {}
+    transitions:
+      ")": State 18
+
+  State 12:
+    79/r4: expression → expression "^" expression •
+      {$end, "^", "+", "-", "*", "/", ")"}
+    80/r4: expression → expression • "^" expression
+      {}
+    81/l2: expression → expression • "+" expression
+      {}
+    82/l2: expression → expression • "-" expression
+      {}
+    83/l3: expression → expression • "*" expression
+      {}
+    84/l3: expression → expression • "/" expression
+      {}
+    transitions:
+      "^": State 5
+    reductions:
+      "+": Rule 2
+      "-": Rule 2
+      "*": Rule 2
+      "/": Rule 2
+      $end: Rule 2
+      ")": Rule 2
+
+  State 13:
+    85/l2: expression → expression "+" expression •
+      {$end, "^", "+", "-", "*", "/", ")"}
+    86/r4: expression → expression • "^" expression
+      {}
+    87/l2: expression → expression • "+" expression
+      {}
+    88/l2: expression → expression • "-" expression
+      {}
+    89/l3: expression → expression • "*" expression
+      {}
+    90/l3: expression → expression • "/" expression
+      {}
+    transitions:
+      "^": State 5
+      "*": State 8
+      "/": State 9
+    reductions:
+      "+": Rule 3
+      "-": Rule 3
+      $end: Rule 3
+      ")": Rule 3
+
+  State 14:
+    91/l2: expression → expression "-" expression •
+      {$end, "^", "+", "-", "*", "/", ")"}
+    92/r4: expression → expression • "^" expression
+      {}
+    93/l2: expression → expression • "+" expression
+      {}
+    94/l2: expression → expression • "-" expression
+      {}
+    95/l3: expression → expression • "*" expression
+      {}
+    96/l3: expression → expression • "/" expression
+      {}
+    transitions:
+      "^": State 5
+      "*": State 8
+      "/": State 9
+    reductions:
+      "+": Rule 4
+      "-": Rule 4
+      $end: Rule 4
+      ")": Rule 4
+
+  State 15:
+    97/l3: expression → expression "*" expression •
+      {$end, "^", "+", "-", "*", "/", ")"}
+    98/r4: expression → expression • "^" expression
+      {}
+    99/l2: expression → expression • "+" expression
+      {}
+    100/l2: expression → expression • "-" expression
+      {}
+    101/l3: expression → expression • "*" expression
+      {}
+    102/l3: expression → expression • "/" expression
+      {}
+    transitions:
+      "^": State 5
+    reductions:
+      "+": Rule 5
+      "-": Rule 5
+      "*": Rule 5
+      "/": Rule 5
+      $end: Rule 5
+      ")": Rule 5
+
+  State 16:
+    103/l3: expression → expression "/" expression •
+      {$end, "^", "+", "-", "*", "/", ")"}
+    104/r4: expression → expression • "^" expression
+      {}
+    105/l2: expression → expression • "+" expression
+      {}
+    106/l2: expression → expression • "-" expression
+      {}
+    107/l3: expression → expression • "*" expression
+      {}
+    108/l3: expression → expression • "/" expression
+      {}
+    transitions:
+      "^": State 5
+    reductions:
+      "+": Rule 6
+      "-": Rule 6
+      "*": Rule 6
+      "/": Rule 6
+      $end: Rule 6
+      ")": Rule 6
+
+  State 17:
+    109/n1: expression → "(" expression ")" •
+      {$end, "^", "+", "-", "*", "/", ")"}
+    reductions:
+      $default: Rule 7
+
+  State 18:
+    110/n1: expression → "(" $error ")" •
+      {$end, "^", "+", "-", "*", "/", ")"}
+    reductions:
+      $default: Rule 8
+

data/lib/antelope/ace/compiler.rb

@@ -53,7 +53,7 @@ module Antelope
 
       # Options defined by directives in the first part of the file.
       #
-      # - **`:terminals`** (`Array<Symbol, String?)>)` &mdash; A list
+      # - **`: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.
@@ -105,9 +105,9 @@ module Antelope
       # Pretty inspect.
       #
       # @return [String]
-      def inspect
-        "#<#{self.class} state=#{@state.inspect} options=#{options.inspect}>"
-      end
+      # 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

data/lib/antelope/ace/errors.rb

@@ -9,35 +9,17 @@ module Antelope
     class Error < Antelope::Error
     end
 
-    # Used primarily in the {Compiler}, this is raised when the
-    # version requirement of the Ace file doesn't match the running
-    # version of Ace.
-    class IncompatibleVersionError < Error
-    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
-
     # 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
-
     # Primarily used in the {Compiler}, it is raised if it encounters
     # a directive it cannot handle.  This is more to warn the
     # developer that a directive they wrote may not be accepted by any

data/lib/antelope/ace.rb

@@ -1,15 +1,10 @@
 # encoding: utf-8
 
-require "antelope/ace/errors"
-require "antelope/ace/scanner"
-require "antelope/ace/compiler"
-require "antelope/ace/token"
-require "antelope/ace/precedence"
-require "antelope/ace/production"
-require "antelope/ace/grammar"
+require 'antelope/ace/errors'
+require 'antelope/ace/scanner'
+require 'antelope/ace/compiler'
 
 module Antelope
-
   # Defines the Ace file.  The Ace file format works similarly to
   # bison's y file format.  The Ace file is seperated into three
   # parts:
@@ -27,18 +22,18 @@ module Antelope
   #     %%
   #
   # The first part consists of _directives_ and _blocks_; directives
-  # look something like `"%" <directive>[ <argument>]*\n`, with
+  # look something like `'%' <directive>[ <argument>]*\n`, with
   # `<directive>` being any alphanumerical character, including
   # underscores and dashes, and `<argument>` being any word character
   # or a quote-delimited string.  Blocks consist of
-  # `"%{" <content> "\n" "\s"* "%}"`, with `<content>` being any
+  # `'%{" <content> "\n" "\s"* "%}'`, with `<content>` being any
   # characters.  The content is copied directly into the body of the
   # output.
   #
   # The second part consists of rules.  Rules look something like
   # this:
   #
-  #     <nonterminal>: (<nonterminal> | <terminal>)* ["{" <content> "}"] ["|" (<nonterminal> | <terminal>)* ["{" <content> "}"]]* [;]
+  #     <nonterminal>: (<nonterminal> | <terminal>)* ['{" <content> "}"] ["|" (<nonterminal> | <terminal>)* ["{" <content> "}']]* [;]
   #
   # Where `<nonterminal>` is any lowercase alphabetical cahracter,
   # `<terminal>` is any uppercase alphabetical character, and
@@ -48,6 +43,5 @@ module Antelope
   # The third part consists of a body, which is copied directly into
   # the output.
   module Ace
-
   end
 end

data/lib/antelope/cli.rb

@@ -46,7 +46,7 @@ module Antelope
     def compile_file(file, gen = :guess)
       puts "Compiling #{file}... "
 
-      grammar = Ace::Grammar.from_file(file)
+      grammar = Grammar.from_file(file)
       grammar.generate(options, gen)
 
     rescue => e

data/lib/antelope/dsl/compiler.rb

@@ -0,0 +1,117 @@
+# encoding: utf-8
+
+require 'rubygems/requirement'
+
+module Antelope
+  module DSL
+    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.
+      #
+      # For the DSL compiler, this is the :default template; if the
+      # :default template does not exist, the compilation will error.
+      #
+      # @return [String]
+      attr_reader :body
+
+      # A list of all the rules that are defined in the file.  The
+      # rules are defined as such:
+      #
+      # - **`label`** (`Symbol`) — 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_reader :rules
+
+      # Options defined by the file itself.
+      #
+      # - **`: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_reader :options
+
+      def self.compile(env = {}, &block)
+        new(env, &block).tap(&:compile)
+      end
+
+      def initialize(env = {}, &block)
+        @env = env
+        @options = {}
+        @block = block
+      end
+
+      def compile
+        call
+        handle_requirement
+        handle_rules
+        handle_options
+        @body = @context[:templates].fetch(:default)
+      end
+
+      def call
+        @context ||= Contexts::Main.new(options.fetch(:context, {}))
+                     .call(&@block)
+      end
+
+      protected
+
+      def handle_requirement
+        required = @options.fetch(:require, ">= 0.0.0")
+        antelope_version = Gem::Version.new(Antelope::VERSION)
+        required_version = Gem::Requirement.new(required)
+
+        raise IncompatibleVersionError, "Grammar requires " \
+          "#{required}, have #{Antelope::VERSION}" unless
+          required_version =~ antelope_version
+      end
+
+      def handle_rules
+        @rules = []
+
+        @context[:productions].each do |label, rules|
+          rules.each do |rule|
+            @rules << { label: label,
+                        set: rule[:body].map { |x| [x, nil] },
+                        block: rule[:action],
+                        prec: rule[:prec] }
+          end
+        end
+      end
+
+      def handle_options
+        @options[:prec]         = @context[:precedences]
+        @options[:extra]        = @context[:defines]
+        @options[:type]         = @env[:output]
+        @options[:nonterminals] = []
+        @options[:terminals]    = @context[:terminals].map do |name, value|
+          if value.is_a?(TrueClass)
+            [name.intern, nil, nil, nil]
+          else
+            [name.intern, nil, nil, value]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/antelope/dsl/contexts/base.rb

@@ -0,0 +1,29 @@
+module Antelope
+  module DSL
+    module Contexts
+      # The base context, which implements some helper methods.
+      class Base
+        attr_reader :options
+
+        def initialize(options)
+          @options = options
+          @contexts = Hash.new { |h, k| h[k] = k.new(@options) }
+        end
+
+        def call(&block)
+          before_call
+          instance_exec(self, &block)
+          data
+        end
+
+        def context(name, &block)
+          @contexts[name].call(&block)
+        end
+
+        def before_call; end
+
+        def data; end
+      end
+    end
+  end
+end