antelope 0.1.8 → 0.1.9

data/examples/simple.output

@@ -1,121 +0,0 @@
-Productions:
-  0 $start: e $ 
-  1 e: l "=" r  
-  2 e: r        
-  3 l: IDENT    
-  4 l: "*" r    
-  5 r: l        
-
-Precedence:
-  --- highest
-  nonassoc 1:
-    {_}
-  nonassoc 0:
-    {$}
-  --- lowest
-
-  State 0:
-    0/n0: $start →  • e $
-      {}
-    1/n1: e →  • l "=" r
-      {}
-    2/n1: e →  • r
-      {}
-    3/n1: l →  • IDENT
-      {}
-    4/n1: l →  • "*" r
-      {}
-    5/n1: r →  • l
-      {}
-    transitions:
-      e: State 1
-      l: State 2
-      r: State 3
-      IDENT: State 4
-      "*": State 5
-
-  State 1:
-    6/n0: $start → e • $
-      {}
-    transitions:
-      $: State 6
-
-  State 2:
-    7/n1: e → l • "=" r
-      {}
-    8/n1: r → l • 
-      {$}
-    transitions:
-      "=": State 7
-    reductions:
-      $: Rule 5
-
-  State 3:
-    9/n1: e → r • 
-      {$}
-    reductions:
-      $: Rule 2
-
-  State 4:
-    10/n1: l → IDENT • 
-      {"=", $}
-    reductions:
-      "=": Rule 3
-      $: Rule 3
-
-  State 5:
-    11/n1: l → "*" • r
-      {}
-    12/n1: r →  • l
-      {}
-    13/n1: l →  • IDENT
-      {}
-    14/n1: l →  • "*" r
-      {}
-    transitions:
-      r: State 8
-      l: State 9
-      IDENT: State 4
-      "*": State 5
-
-  State 6:
-    15/n0: $start → e $ • 
-      {}
-    accepting:
-      $: Rule 0
-
-  State 7:
-    16/n1: e → l "=" • r
-      {}
-    17/n1: r →  • l
-      {}
-    18/n1: l →  • IDENT
-      {}
-    19/n1: l →  • "*" r
-      {}
-    transitions:
-      r: State 10
-      l: State 9
-      IDENT: State 4
-      "*": State 5
-
-  State 8:
-    20/n1: l → "*" r • 
-      {"=", $}
-    reductions:
-      "=": Rule 4
-      $: Rule 4
-
-  State 9:
-    21/n1: r → l • 
-      {"=", $}
-    reductions:
-      "=": Rule 5
-      $: Rule 5
-
-  State 10:
-    22/n1: e → l "=" r • 
-      {$}
-    reductions:
-      $: Rule 1
-

data/lib/antelope/generator/templates/output.erb

@@ -1,56 +0,0 @@
-Productions:
-% len = grammar.all_productions.size.to_s.size
-% productions = grammar.all_productions.
-%   map { |x| ["#{x.label}: #{x.items.join(' ')}", x.block] }
-% body = productions.map { |_| _.first.size }.max
-% productions.each_with_index do |prod, i|
-  <%= "%#{len}s" % i %> <%= "%-#{body}s" % prod[0] %> <%= prod[1] %>
-% end
-
-% if unused_symbols.any?
-Symbols unused in grammar:
-%   unused_symbols.each do |sym|
-  <%= sym %>
-%   end
-% end
-
-Precedence:
-  --- highest
-% grammar.precedence.each do |pr|
-  <%= "%-8s" % pr.type %> <%= pr.level %>:
-    {<%= pr.tokens.to_a.join(", ") %>}
-% end
-  --- lowest
-
-% len = tableizer.table.flatten.map(&:keys).flatten.map(&:size).max
-% states = grammar.states.to_a
-% tableizer.table.each_with_index do |v, i|
-%   state = states[i]
-  State <%= i %>:
-%   state.rules.each do |rule|
-    <%= rule %>
-      {<%= rule.lookahead.to_a.join(", ") %>}
-%   end
-%   transitions = v.each.select { |_, a| a && a[0] == :state }
-%   reductions  = v.each.select { |_, a| a && a[0] == :reduce}
-%   accepting   = v.each.select { |_, a| a && a[0] == :accept}
-%   conflicts   = tableizer.conflicts[i].each
-%   thing = [:transitions, :reductions, :accepting]
-%   num_type = {transitions: "State", reductions: "Rule", accepting: "Rule"}
-%   h = Hash[thing.zip([transitions, reductions, accepting])]
-%   h.each do |key, value|
-%     next unless value.any?
-    <%= key %>:
-%     value.each do |token, (_, name)|
-%     token_value = grammar.terminals.find { |_| _.name == token } || token
-      <%= token_value %>: <%= num_type[key] %> <%= name %>
-%     end
-%   end
-%   if conflicts.any?
-    conflicts:
-%     conflicts.each do |token, (first, second, rule, terminal)|
-      <%= token %>: <%= first.join(" ") %>/<%= second.join(" ") %> (<%= rule %> vs <%= terminal %>)
-%     end
-%   end
-
-% end

data/lib/antelope/generator/templates/ruby.erb

@@ -1,63 +0,0 @@
-
-# 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 # >
-
-# 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<Object>] the input to run the parser over.
-# @return [Object] the result of the accept.
-def parse(input)
-  stack = []
-  stack.push([nil, 0])
-  input = input.dup
-  last  = nil
-
-  until stack.empty? do
-    peek_token = if input.empty?
-      :"$"
-    else
-      type(input.first)
-    end
-
-    action = ACTION_TABLE[stack.last.last].fetch(peek_token)
-    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
-    end
-  end
-
-  last
-end