antelope 0.2.0 → 0.2.2

data/lib/antelope/generator/c_header.rb

@@ -1,105 +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
+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

@@ -1,39 +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
+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

data/lib/antelope/generator/error.rb

@@ -0,0 +1,34 @@
+# encoding: utf-8
+
+module Antelope
+  module Generator
+
+    # Generates an output file, mainly for debugging.  Included always
+    # as a generator for a grammar.
+    class Error < Base
+
+      register_as "error"
+
+      has_directive "output.verbose", Boolean
+
+      # Defines singleton method for every mod that the grammar passed
+      # to the generator.
+      #
+      # @see Generator#initialize
+      def initialize(*)
+        super
+        mods.each do |k, v|
+          define_singleton_method (k) { v }
+        end
+      end
+
+      # Actually performs the generation.  Uses the template in
+      # output.erb, and generates the file `<file>.output`.
+      #
+      # @return [void]
+      def generate
+        template "error", "#{file}.err"
+      end
+    end
+  end
+end

data/lib/antelope/generator/group.rb

@@ -1,57 +1,57 @@
-module Antelope
-  module Generator
-
-    # For use to use multiple generators as a bundle.  Works exactly
-    # like a normal generator, i.e. responds to both {.register_as}
-    # and {#generate}, but also responds to {.register_generator},
-    # like {Generator}.  Any generators registered to the group are
-    # used to generate the files.
-    #
-    # @abtract Subclass and use {.register_generator} to create a
-    #   group generator.
-    class Group < Base
-
-      extend Generator
-
-      # Initialize the group generator.  Calls {Base#initialize}, and
-      # then instantizes all of the generators in the group.
-      def initialize(*_)
-        super
-
-        generators.map! do |gen|
-          gen.new(*_)
-        end
-      end
-
-      # Generates files using the generators contained within this
-      # group.  If it encounters an error in one of the generators, it
-      # will continue to try to generate the rest of the generators.
-      # It will then raise the last error given at the end.
-      #
-      # @return [void]
-      def generate
-        error = nil
-        generators.map do |gen|
-          begin
-            gen.generate
-          rescue => e
-            $stderr.puts "Error running #{gen.class}: #{e.message}"
-            error = e
-          end
-        end
-
-        raise error if error
-      end
-
-      private
-
-      # Retrieve a list of all of the generators that are contained
-      # within this group.
-      #
-      # @return [Array<Generator::Base>]
-      def generators
-        @_generators ||= self.class.generators.values
-      end
-    end
-  end
-end
+module Antelope
+  module Generator
+
+    # For use to use multiple generators as a bundle.  Works exactly
+    # like a normal generator, i.e. responds to both {.register_as}
+    # and {#generate}, but also responds to {.register_generator},
+    # like {Generator}.  Any generators registered to the group are
+    # used to generate the files.
+    #
+    # @abtract Subclass and use {.register_generator} to create a
+    #   group generator.
+    class Group < Base
+
+      extend Generator
+
+      # Initialize the group generator.  Calls {Base#initialize}, and
+      # then instantizes all of the generators in the group.
+      def initialize(*_)
+        super
+
+        generators.map! do |gen|
+          gen.new(*_)
+        end
+      end
+
+      # Generates files using the generators contained within this
+      # group.  If it encounters an error in one of the generators, it
+      # will continue to try to generate the rest of the generators.
+      # It will then raise the last error given at the end.
+      #
+      # @return [void]
+      def generate
+        error = nil
+        generators.map do |gen|
+          begin
+            gen.generate
+          rescue => e
+            $stderr.puts "Error running #{gen.class}: #{e.message}"
+            error = e
+          end
+        end
+
+        raise error if error
+      end
+
+      private
+
+      # Retrieve a list of all of the generators that are contained
+      # within this group.
+      #
+      # @return [Array<Generator::Base>]
+      def generators
+        @_generators ||= self.class.generators.values
+      end
+    end
+  end
+end

data/lib/antelope/generator/html.rb

@@ -0,0 +1,51 @@
+# encoding: utf-8
+
+module Antelope
+  module Generator
+
+    # Generates an output file, mainly for debugging.  Included always
+    # as a generator for a grammar.
+    class HTML < Base
+
+      register_as "html"
+
+      has_directive "html.show-lookahead", Boolean
+
+      # Defines singleton method for every mod that the grammar passed
+      # to the generator.
+      #
+      # @see Generator#initialize
+      def initialize(*)
+        super
+        mods.each do |k, v|
+          define_singleton_method (k) { v }
+        end
+      end
+
+      def unused_symbols
+        @_unused_symbols ||= begin
+          used = grammar.all_productions.map(&:items).flatten.uniq
+          all  = grammar.symbols.map do |s|
+            if Symbol === s
+              grammar.find_token(s)
+            else
+              s
+            end
+          end
+
+          all - used - [grammar.find_token(:"$start")]
+        end
+      end
+
+      # Actually performs the generation.  Uses the template in
+      # output.erb, and generates the file `<file>.output`.
+      #
+      # @return [void]
+      def generate
+        template "html/html", "#{file}.html"
+        template "html/css", "#{file}.css"
+        template "html/js", "#{file}.js"
+      end
+    end
+  end
+end

data/lib/antelope/generator/info.rb

@@ -0,0 +1,47 @@
+# encoding: utf-8
+
+module Antelope
+  module Generator
+
+    # Generates an output file, mainly for debugging.  Included always
+    # as a generator for a grammar.
+    class Info < Base
+
+      register_as "info"
+
+      # Defines singleton method for every mod that the grammar passed
+      # to the generator.
+      #
+      # @see Generator#initialize
+      def initialize(*)
+        super
+        mods.each do |k, v|
+          define_singleton_method (k) { v }
+        end
+      end
+
+      def unused_symbols
+        @_unused_symbols ||= begin
+          used = grammar.all_productions.map(&:items).flatten.uniq
+          all  = grammar.symbols.map do |s|
+            if Symbol === s
+              grammar.find_token(s)
+            else
+              s
+            end
+          end
+
+          all - used - [grammar.find_token(:"$start")]
+        end
+      end
+
+      # Actually performs the generation.  Uses the template in
+      # output.erb, and generates the file `<file>.output`.
+      #
+      # @return [void]
+      def generate
+        template "info", "#{file}.inf"
+      end
+    end
+  end
+end

data/lib/antelope/generator/null.rb

@@ -1,18 +1,18 @@
-module Antelope
-  module Generator
-
-    # Represents a generator that does not generate anything.
-    class Null < Base
-
-      register_as "null"
-
-      has_directive "null.data"
-      has_directive "comment"
-
-      # Does nothing.
-      #
-      # @return [void]
-      def generate; end
-    end
-  end
-end
+module Antelope
+  module Generator
+
+    # Represents a generator that does not generate anything.
+    class Null < Base
+
+      register_as "null"
+
+      has_directive "null.data"
+      has_directive "comment"
+
+      # Does nothing.
+      #
+      # @return [void]
+      def generate; end
+    end
+  end
+end

data/lib/antelope/generator/output.rb

@@ -1,49 +1,17 @@
-# encoding: utf-8
-
-module Antelope
-  module Generator
-
-    # Generates an output file, mainly for debugging.  Included always
-    # as a generator for a grammar.
-    class Output < Base
-
-      register_as "output"
-
-      has_directive "output.show-lookahead", Boolean
-
-      # Defines singleton method for every mod that the grammar passed
-      # to the generator.
-      #
-      # @see Generator#initialize
-      def initialize(*)
-        super
-        mods.each do |k, v|
-          define_singleton_method (k) { v }
-        end
-      end
-
-      def unused_symbols
-        @_unused_symbols ||= begin
-          used = grammar.all_productions.map(&:items).flatten.uniq
-          all  = grammar.symbols.map do |s|
-            if Symbol === s
-              grammar.find_token(s)
-            else
-              s
-            end
-          end
-
-          all - used - [grammar.find_token(:"$start")]
-        end
-      end
-
-      # Actually performs the generation.  Uses the template in
-      # output.erb, and generates the file `<file>.output`.
-      #
-      # @return [void]
-      def generate
-        template "output", "#{file}.output"
-      end
-    end
-  end
-end
+# encoding: utf-8
+
+module Antelope
+  module Generator
+
+    # Generates an output file, mainly for debugging.  Included always
+    # as a generator for a grammar.
+    class Output < Group
+
+      register_as "output"
+
+      register_generator Info,  "info"
+      register_generator Error, "error"
+
+    end
+  end
+end