antelope 0.3.2 → 0.4.0

data/lib/antelope/generator/templates/{ruby.ant → ruby.erb}

@@ -1,178 +1,171 @@
-
-# This file assumes that the output of the generator will be placed
-# within a module or a class.  However, the module/class requires a
-# `type` method, which takes a terminal and gives its type, as a
-# symbol.  These types should line up with the terminals that were
-# defined in the original grammar.
-
-# The actions to take during parsing.  In every state, there are a
-# set of acceptable peek tokens; this table tells the parser what
-# to do on each acceptable peek token.  The possible actions include
-# `:accept`, `:reduce`, and `:state`; `:accept` means to accept the
-# input and return the value of the pasing.  `:reduce` means to
-# reduce the top of the stack into a given nonterminal.  `:state`
-# means to transition to another state.
-#
-# @return [Array<Hash<(Symbol, Array<(Symbol, Numeric)>)>>]
-ACTION_TABLE = {{= generate_action_table }}.freeze
-
-# The default action that is taken for most reductions.
-#
-# @return [Proc]
-DEFAULT_PROC = proc { |_| _ }
-# A list of all of the productions.  Only includes the left-hand side,
-# the number of tokens on the right-hand side, and the block to call
-# on reduction.
-#
-# @return [Array<Array<(Symbol, Numeric, Proc)>>]
-PRODUCTIONS  = {{= generate_productions_list }}.freeze
-
-# Runs the parser.
-#
-# @param input [Array] the input to run the parser over.
-# @return [Object] the result of the accept.
-def parse(input)
-  stack = []
-  stack.push([nil, 0])
-  last  = nil
-  input = input.to_a.dup
-
-  until stack.empty? do
-    last = parse_action(stack, input)
-  end
-
-  last
-
-end
-
-# Actually performs the parsing action on the given stack on input.
-# If you want to implement a push parser, than messing with this
-# method is probably the way to go.
-#
-# @param stack [Array<Array<(Object, Numeric)>>] the stack of the
-#   parser.  The actual order of the stack is important.
-# @param input [Array<Object>] the input to run the parser over.
-#   The elements of this may be passed to the `type` method.
-# @return [Object] the result of the last accepting reduction.
-def parse_action(stack, input)
-  last = nil
-  peek_token = if input.empty?
-    :$end
-  else
-    type(input.first)
-  end
-
-  action = ACTION_TABLE[stack.last.last].fetch(peek_token) do
-    ACTION_TABLE[stack.last.last].fetch(:$default)
-  end
-
-  case action.first
-  when :accept
-    production = PRODUCTIONS[action.last]
-    last       = stack.pop(production[1]).first.first
-    stack.pop
-  when :reduce
-    production = PRODUCTIONS[action.last]
-    removing   = stack.pop(production[1])
-    value = instance_exec(removing.map(&:first), &production[2])
-    goto  = ACTION_TABLE[stack.last.last][production[0]]
-    stack.push([value, goto.last])
-  when :state
-    stack.push([input.shift, action.last])
-  else
-    raise NotImplementedError, "Unknown action #{action.first}"
-  end
-
-  last
-
-rescue KeyError => e
-  peek = input.first
-
-  if handle_error({
-      :stack     => stack,
-      :peek      => peek_token,
-      :remaining => input,
-      :error     => e,
-      :line      => line_of(peek),
-      :column    => column_of(peek),
-      :expected  => ACTION_TABLE[stack.last.last].keys
-    })
-    retry
-  else
-    raise
-  end
-end
-
-private
-
-def line_of(peek)
-  if peek.respond_to?(:line)
-    peek.line
-  else
-    0
-  end
-end
-
-def column_of(peek)
-  if peek.respond_to?(:column)
-    peek.column
-  else
-    0
-  end
-end
-
-{{ if define_own_handler? }}
-def handle_error(data, _ = false)
-{{   if panic_mode? }}
-  if _ || data[:peek] == :$end # we can't recover if
-                               # we're at the end
-{{   end }}
-    raise {{= error_class }},
-      "Unexpected token #{data[:peek]} on line #{data[:line]}, " \
-      "column #{data[:column]}; expected one of " \
-      "#{data[:expected].join(', ')}",
-      data[:error].backtrace
-{{   if panic_mode? }}
-  end
-
-  new_peek = :$error
-  acceptable_state = false
-  state = nil
-
-  until data[:stack].empty? or acceptable_state
-    state = data[:stack].last.last
-
-    if ACTION_TABLE[state].key?(new_peek)
-      acceptable_state = true
-    else
-      data[:stack].pop # discard
-    end
-  end
-
-  return handle_error(data, true) unless acceptable_state
-
-  action = ACTION_TABLE[state][new_peek]
-  lookaheads = nil
-
-  until lookaheads
-    if action[0] == :state
-      lookaheads = ACTION_TABLE[action.last].keys
-    elsif action[0] == :reduce
-      rule   = PRODUCTIONS[action.last]
-      action = ACTION_TABLE[stack[-rule[1]].last][rule[0]]
-    end
-  end
-
-  begin
-    until lookaheads.include?(data[:remaining][0].peek)
-      data[:remaining].next
-    end
-  rescue StopIteration
-  end
-
-  data[:remaining].unshift([new_peek, data[:error]])
-  true
-
-{{   end }}
-end
-{{ end }}
+# This file assumes that the output of the generator will be placed
+# within a module or a class.  However, the module/class requires a
+# `type` method, which takes a terminal and gives its type, as a
+# symbol.  These types should line up with the terminals that were
+# defined in the original grammar.
+
+# The actions to take during parsing.  In every state, there are a
+# set of acceptable peek tokens; this table tells the parser what
+# to do on each acceptable peek token.  The possible actions include
+# `:accept`, `:reduce`, and `:state`; `:accept` means to accept the
+# input and return the value of the pasing.  `:reduce` means to
+# reduce the top of the stack into a given nonterminal.  `:state`
+# means to transition to another state.
+#
+# @return [Array<Hash<(Symbol, Array<(Symbol, Numeric)>)>>]
+ACTION_TABLE = <%= generate_action_table %>.freeze
+
+# The default action that is taken for most reductions.
+#
+# @return [Proc]
+DEFAULT_PROC = proc { |_| _ }
+# A list of all of the productions.  Only includes the left-hand side,
+# the number of tokens on the right-hand side, and the block to call
+# on reduction.
+#
+# @return [Array<Array<(Symbol, Numeric, Proc)>>]
+PRODUCTIONS  = <%= generate_productions_list %>.freeze
+
+# Runs the parser.
+#
+# @param input [Array] the input to run the parser over.
+# @return [Object] the result of the accept.
+def parse(input)
+  stack = []
+  stack.push([nil, 0])
+  input = input.to_a.dup
+
+  parse_action(stack, input) until stack.empty?
+end
+
+# Actually performs the parsing action on the given stack on input.
+# If you want to implement a push parser, than messing with this
+# method is probably the way to go.
+#
+# @param stack [Array<Array<(Object, Numeric)>>] the stack of the
+#   parser.  The actual order of the stack is important.
+# @param input [Array<Object>] the input to run the parser over.
+#   The elements of this may be passed to the `type` method.
+# @return [Object] the result of the last accepting reduction.
+def parse_action(stack, input)
+  last = nil
+  peek_token = if input.empty?
+                 :$end
+               else
+                 type(input.first)
+               end
+
+  action = ACTION_TABLE[stack.last.last].fetch(peek_token) do
+    ACTION_TABLE[stack.last.last].fetch(:$default)
+  end
+
+  case action.first
+  when :accept
+    production = PRODUCTIONS[action.last]
+    last       = stack.pop(production[1]).first.first
+    stack.pop
+  when :reduce
+    production = PRODUCTIONS[action.last]
+    removing   = stack.pop(production[1])
+    value = instance_exec(removing.map(&:first), &production[2])
+    goto  = ACTION_TABLE[stack.last.last][production[0]]
+    stack.push([value, goto.last])
+  when :state
+    stack.push([input.shift, action.last])
+  else
+    raise NotImplementedError, "Unknown action #{action.first}"
+  end
+
+  last
+
+rescue KeyError => e
+  peek = input.first
+
+  if handle_error(
+    stack:     stack,
+    peek:      peek_token,
+    remaining: input,
+    error:     e,
+    line:      line_of(peek),
+    column:    column_of(peek),
+    expected:  ACTION_TABLE[stack.last.last].keys
+    )
+    retry
+  else
+    raise
+  end
+end
+
+private
+
+def line_of(peek)
+  if peek.respond_to?(:line)
+    peek.line
+  else
+    0
+  end
+end
+
+def column_of(peek)
+  if peek.respond_to?(:column)
+    peek.column
+  else
+    0
+  end
+end
+
+<% if define_own_handler? -%>
+def handle_error(data, _ = false)
+  <%- if panic_mode? -%>
+  if _ || data[:peek] == :$end # we can't recover if
+                               # we're at the end
+  <%- end -%>
+    raise <%= error_class %>,
+      "Unexpected token #{data[:peek]} on line #{data[:line]}, " \
+      "column #{data[:column]}; expected one of " \
+      "#{data[:expected].join(', ')}",
+      data[:error].backtrace
+  <%- if panic_mode? -%>
+  end
+
+  new_peek = :$error
+  acceptable_state = false
+  state = nil
+
+  until data[:stack].empty? or acceptable_state
+    state = data[:stack].last.last
+
+    if ACTION_TABLE[state].key?(new_peek)
+      acceptable_state = true
+    else
+      data[:stack].pop # discard
+    end
+  end
+
+  return handle_error(data, true) unless acceptable_state
+
+  action = ACTION_TABLE[state][new_peek]
+  lookaheads = nil
+
+  until lookaheads
+    if action[0] == :state
+      lookaheads = ACTION_TABLE[action.last].keys
+    elsif action[0] == :reduce
+      rule   = PRODUCTIONS[action.last]
+      action = ACTION_TABLE[stack[-rule[1]].last][rule[0]]
+    end
+  end
+
+  begin
+    until lookaheads.include?(data[:remaining][0].peek)
+      data[:remaining].next
+    end
+  rescue StopIteration
+  end
+
+  data[:remaining].unshift([new_peek, data[:error]])
+  true
+
+  <%- end -%>
+end
+<%- end -%>

data/lib/antelope/generator.rb

@@ -1,66 +1,62 @@
-# encoding: utf-8
-require "erb"
-require "pathname"
-
-module Antelope
-
-  # Contains the classes that generate parsers.  This contains a
-  # registery of all of the generators available to antelope.
-  module Generator
-
-    # Returns a hash of all of the generators registered within this
-    # module.  If a generator is accessed that does not exist on the
-    # hash, it by default returns the {Generator::Null} class.
-    #
-    # @return [Hash<(Symbol, String) => Generator::Base>]
-    def generators
-      @_generators ||= Hash.new { |h, k| h[k] = Generator::Null }
-    end
-    # Returns a hash of all of the directives that are available in
-    # the generators of this module.
-    #
-    # @see .generators
-    # @return [Hash]
-    def directives
-      generators.values.map(&:directives).
-        inject({}, :merge)
-    end
-
-    # Registers a generator with the given names.  If multiple names
-    # are given, they are assigned the generator as a value in the
-    # {#generators} hash; otherwise, the one name is assigned the
-    # generator as a value.
-    #
-    # @param generator [Generator::Base] the generator class to
-    #   associate the key with.
-    # @param name [String, Symbol] a name to associate the generator
-    #   with.
-    def register_generator(generator, *names)
-      names = [names].flatten
-      raise ArgumentError,
-        "Requires at least one name" unless names.any?
-      raise ArgumentError,
-        "All name values must be a Symbol or string" unless names.
-        all? {|_| [Symbol, String].include?(_.class) }
-
-      names.each do |name|
-        generators[name.to_s.downcase] = generator
-      end
-    end
-
-    extend self
-
-  end
-end
-
-require "antelope/generator/base"
-require "antelope/generator/group"
-require "antelope/generator/info"
-require "antelope/generator/error"
-require "antelope/generator/output"
-require "antelope/generator/html"
-require "antelope/generator/ruby"
-require "antelope/generator/null"
-require "antelope/generator/c_header"
-require "antelope/generator/c_source"
-require "antelope/generator/c"
+# encoding: utf-8
+require "erb"
+require "pathname"
+
+module Antelope
+
+  # Contains the classes that generate parsers.  This contains a
+  # registery of all of the generators available to antelope.
+  module Generator
+
+    # Returns a hash of all of the generators registered within this
+    # module.  If a generator is accessed that does not exist on the
+    # hash, it by default returns the {Generator::Null} class.
+    #
+    # @return [Hash<(Symbol, String) => Generator::Base>]
+    def generators
+      @_generators ||= Hash.new { |h, k| h[k] = Generator::Null }
+    end
+    # Returns a hash of all of the directives that are available in
+    # the generators of this module.
+    #
+    # @see .generators
+    # @return [Hash]
+    def directives
+      generators.values.map(&:directives).
+        inject({}, :merge)
+    end
+
+    # Registers a generator with the given names.  If multiple names
+    # are given, they are assigned the generator as a value in the
+    # {#generators} hash; otherwise, the one name is assigned the
+    # generator as a value.
+    #
+    # @param generator [Generator::Base] the generator class to
+    #   associate the key with.
+    # @param name [String, Symbol] a name to associate the generator
+    #   with.
+    def register_generator(generator, *names)
+      names = [names].flatten
+      raise ArgumentError,
+        "Requires at least one name" unless names.any?
+      raise ArgumentError,
+        "All name values must be a Symbol or string" unless names.
+        all? {|_| [Symbol, String].include?(_.class) }
+
+      names.each do |name|
+        generators[name.to_s.downcase] = generator
+      end
+    end
+
+    extend self
+
+  end
+end
+
+require "antelope/generator/base"
+require "antelope/generator/group"
+require "antelope/generator/info"
+require "antelope/generator/error"
+require "antelope/generator/output"
+require "antelope/generator/ruby"
+require "antelope/generator/null"

data/lib/antelope/grammar/generation.rb

@@ -1,76 +1,76 @@
-# encoding: utf-8
-
-module Antelope
-  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],
-      [:tableizer,   Generation::Tableizer  ]
-    ].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 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(options    = {},
-                   generators = :guess,
-                   modifiers  = DEFAULT_MODIFIERS)
-        mods = modifiers.map(&:last)
-               .map  { |x| x.new(self) }
-        mods.each do |mod|
-          puts "Running mod #{mod.class}..." if options[:verbose]
-          mod.call
-        end
-        hash = Hash[modifiers.map(&:first).zip(mods)]
-        # This is when we'd generate
-
-        find_generators(generators, options).each do |gen|
-          puts "Running generator #{gen}..." if options[:verbose]
-          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 << Generator.generators.fetch(type.to_s)
-
-        generators
-
-      rescue KeyError
-        raise NoTypeError, "Undefined type #{type}"
-      end
-    end
-  end
-end
+# encoding: utf-8
+
+module Antelope
+  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],
+      [:tableizer,   Generation::Tableizer  ]
+    ].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 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(options    = {},
+                   generators = :guess,
+                   modifiers  = DEFAULT_MODIFIERS)
+        mods = modifiers.map(&:last)
+               .map  { |x| x.new(self) }
+        mods.each do |mod|
+          puts "Running mod #{mod.class}..." if options[:verbose]
+          mod.call
+        end
+        hash = Hash[modifiers.map(&:first).zip(mods)]
+        # This is when we'd generate
+
+        find_generators(generators, options).each do |gen|
+          puts "Running generator #{gen}..." if options[:verbose]
+          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 << Generator.generators.fetch(type.to_s)
+
+        generators
+
+      rescue KeyError
+        raise NoTypeError, "Undefined type #{type}"
+      end
+    end
+  end
+end