babel_bridge 0.3.0 → 0.3.1

data/examples/test.rb

@@ -0,0 +1,31 @@
+require File.join(File.dirname(__FILE__),"..","lib","babel_bridge")
+
+class TestParser < BabelBridge::Parser
+
+  rule :expr, :bin_op do
+    def evaluate
+      output = bin_op.evaluate
+      input = to_s
+      puts "bbtest: #{output} = #{eval output}"
+      puts "ruby: #{input} = #{eval input}"
+    end
+  end
+
+  #rule :bin_op, :operand, "+", :operand do
+  #rule :bin_op, many(:operand,"+") do
+  #rule :bin_op, :operand, /([-+\/*])|(\*\*)/, :bin_op do
+  #rule :bin_op, many(:operand,/([-+\/*])|(\*\*)/) do
+  binary_operators_rule :bin_op, :operand, ["**", [:/, :*], [:+, "-"]], :right_operators => ["**"] do
+    def evaluate 
+      "(#{left.evaluate}#{operator}#{right.evaluate})"
+    end
+  end
+
+  rule :operand, "(", :bin_op, ")"
+ 
+  rule :operand, /[-]?[0-9]+/ do
+    def evaluate; to_s; end
+  end
+end
+
+BabelBridge::Shell.new(TestParser.new).start

data/examples/turing/examples.turing

@@ -0,0 +1,33 @@
+# this language doesn't support comments, should copy-paste the examples between
+# the comments
+
+# calculate 2^[0]
+[0]=10;[1]=1;while [0]>0 do [0]=[0]-1;[1]=[1]*2 end;[1]
+
+# return the [0]th number in the fibonancci sequence:
+# [0] == fib number to output
+# [1] == current fib number 
+# [2] == fib[[1]]
+# [3] == fib[[1]-1]
+# [4] == temp
+[0]=5;[1]=2;[2]=[3]=1;while [1]<[0] do [4]=[2]+[3];[2]=[3];[3]=[4];[1]=[1]+1 end;[3]
+
+# simulate a turing machine
+# [0] == current state
+# [1] == head position
+# [2] == number of symbols this machine recognizes
+# [3] == current state + read value offset
+# [state*[2]*3+10] == write at the current head position(nil or any number)
+# [state*[2]*3+11] == move head amount (-1, 0, 1)
+# [state*[2]*3+12] == next-state (states starting from 0)
+# [10000+] == tape - pick a large enough constant that the turing machine doesn't corrupt your states
+# -1 is the stop-state
+# Assumes you initalized your turing program for all your states.
+[0]=-1;
+[1]=10000; 
+while [0]>=0 do 
+  [3] = 10 + ([0]*[2]+[[1]]) * 3;
+  [[1]] = [[3]];
+  [1] = [1] + [[3]+1];
+  [0] = [[3]+2];
+end

data/examples/turing/notes.rb

@@ -0,0 +1,111 @@
+turing0: #babel-bridge setup
+turing1: #introducing rules -> show interactive shell in action
+  rule :int, /[-]?[0-9]+/
+
+turing2: #the "add" rule (with 2 variants to support recursive matching)
+  rule :add, :int, "+", :add
+  rule :add, :int
+
+turing3: #add evaluate methods
+  rule :add, :int, "+", :add do
+    def evaluate
+      int.evaluate + add.evaluate
+    end
+  end
+  rule :add, :int
+
+  rule :int, /[-]?[0-9]+/ do
+    def evaluate
+      to_s.to_i
+    end
+  end
+
+turing4: #multiple operators, but "3*10+2" or "2+10*3" breaks!
+  # add :operator rule, update evaluate
+  rule :add, :int, /[-+\/*]/, :add do
+    def evaluate
+      int.evaluate.send match[1].to_s.to_sym, add.evaluate
+    end
+  end
+
+turing5: # binary_operators_rule
+  # replace all but the int rule with:
+  binary_operators_rule :statement, :int, [[:/, :*], [:+, :-]] do
+    def evaluate
+      left.evaluate.send operator, right.evaluate
+    end
+  end
+
+turing6: # add parenthesis
+  # rename :int to :operand
+  rule :operand, "(", :statement, ")"
+
+turing7: # show "5 + 2" fails -> ignore_whitespace
+  ignore_whitespace
+
+turing8: # add comparators
+  binary_operators_rule :statement, :operand, [[:/, :*], [:+, :-], 
+      [:<, :<=, :>, :>=, :==]] do
+    def evaluate
+      case operator
+      when :<, :<=, :>, :>=, :==
+        (left.evaluate.send operator, right.evaluate) ? 1 : nil
+      else
+        left.evaluate.send operator, right.evaluate
+      end
+    end
+  end
+
+turing9: # add if 
+  rule :statement, "if", :statement, "then", :statement, :else_clause?, "end" do
+    def evaluate
+      if matches[1].evaluate
+        matches[3].evaluate
+      else 
+        else_clause.evaluate if else_clause
+      end
+    end
+  end
+  rule :else_clause, "else", :statement
+
+turing10: #add store
+
+  def store
+    @store||=[]
+  end
+
+    rule :operand, "[", :statement, "]", "=", :statement do
+    def evaluate
+      parser.store[statement[0].evaluate] = statement[1].evaluate
+    end
+  end
+
+  rule :operand, "[", :statement, "]" do
+    def evaluate
+      parser.store[statement.evaluate]
+    end
+  end
+
+turing11: #statements
+  # update "if" bodies to have statements
+
+  rule :statements, many(:statement,";"), match?(";") do
+    def evaluate
+      ret = nil
+      statement.each do |s|
+        ret = s.evaluate
+      end
+      ret
+    end
+  end
+
+turing12: # while
+
+  rule :statement, "while", :statement, "do", :statements, "end" do
+    def evaluate
+      while statement.evaluate
+        statements.evaluate
+      end
+    end
+  end
+  

data/examples/turing/turing.rb

@@ -1,7 +1,14 @@
 require File.join(File.dirname(__FILE__),"..","..","lib","babel_bridge")
+# A turing complete programming language
+# Example program that computes the power of two of the value stored in the [0] register:
+# => [0]=32;[1]=1;while [0]>0 do [1] = [1] * 2; [0] = [0]-1; end;[1]
+
+# TODO: add variables and functions
 
 class TuringParser < BabelBridge::Parser
   ignore_whitespace
+  # TODO: add "whole_words" option to convert all literal matching patterns that are words into /word\b/
+
 
   def store
     @store||=[]
@@ -17,18 +24,18 @@ class TuringParser < BabelBridge::Parser
     end
   end
 
-  rule :statement, /if\b/, :statement, /then\b/, :statement, :else_clause?, /end\b/ do
+  rule :statement, "if", :statement, "then", :statements, :else_clause?, "end" do
     def evaluate
-      if statement[0].evaluate
-        statement[1].evaluate
+      if statement.evaluate
+        statements.evaluate
       else 
         else_clause.evaluate if else_clause
       end
     end
   end
-  rule :else_clause, /else\b/, :statement
+  rule :else_clause, "else", :statements
 
-  rule :statement, /while\b/, :statement, /do\b/, :statements, /end\b/ do
+  rule :statement, "while", :statement, "do", :statements, "end" do
     def evaluate
       while statement.evaluate
         statements.evaluate
@@ -36,7 +43,7 @@ class TuringParser < BabelBridge::Parser
     end
   end
 
-  binary_operators_rule :statement, :operand, [[:<, :<=, :>, :>=, :==], [:+, :-], [:/, :*]] do
+  binary_operators_rule :statement, :operand, [[:/, :*], [:+, :-], [:<, :<=, :>, :>=, :==]] do
     def evaluate
       case operator
       when :<, :<=, :>, :>=, :==

data/examples/turing/turing00.rb

@@ -0,0 +1,7 @@
+require File.join(File.dirname(__FILE__),"..","..","lib","babel_bridge")
+
+class TuringParser < BabelBridge::Parser
+  
+end
+
+BabelBridge::Shell.new(TuringParser.new).start

data/examples/turing/turing01.rb

@@ -0,0 +1,8 @@
+require File.join(File.dirname(__FILE__),"..","..","lib","babel_bridge")
+
+class TuringParser < BabelBridge::Parser
+  
+  rule :int, /[-]?[0-9]+/
+end
+
+BabelBridge::Shell.new(TuringParser.new).start

data/examples/turing/turing02.rb

@@ -0,0 +1,10 @@
+require File.join(File.dirname(__FILE__),"..","..","lib","babel_bridge")
+
+class TuringParser < BabelBridge::Parser
+
+  rule :add, :int, "+", :add
+  rule :add, :int
+  rule :int, /[-]?[0-9]+/
+end
+
+BabelBridge::Shell.new(TuringParser.new).start

data/examples/turing/turing03.rb

@@ -0,0 +1,19 @@
+require File.join(File.dirname(__FILE__),"..","..","lib","babel_bridge")
+
+class TuringParser < BabelBridge::Parser
+
+  rule :add, :int, "+", :add do
+    def evaluate
+      int.evaluate + add.evaluate
+    end
+  end
+  rule :add, :int
+
+  rule :int, /[-]?[0-9]+/ do
+    def evaluate
+      to_s.to_i
+    end
+  end
+end
+
+BabelBridge::Shell.new(TuringParser.new).start

data/examples/turing/turing04.rb

@@ -0,0 +1,19 @@
+require File.join(File.dirname(__FILE__),"..","..","lib","babel_bridge")
+
+class TuringParser < BabelBridge::Parser
+
+  rule :add, :int, /[-+\/*]/, :add do
+    def evaluate
+      int.evaluate.send matches[1].to_s.to_sym, add.evaluate
+    end
+  end
+  rule :add, :int
+  
+  rule :int, /[-]?[0-9]+/ do
+    def evaluate
+      to_s.to_i
+    end
+  end
+end
+
+BabelBridge::Shell.new(TuringParser.new).start

data/examples/turing/turing05.rb

@@ -0,0 +1,18 @@
+require File.join(File.dirname(__FILE__),"..","..","lib","babel_bridge")
+
+class TuringParser < BabelBridge::Parser
+
+  binary_operators_rule :statement, :int, [[:/, :*], [:+, :-]] do
+    def evaluate
+      left.evaluate.send operator, right.evaluate
+    end
+  end
+
+  rule :int, /[-]?[0-9]+/ do
+    def evaluate
+      to_s.to_i
+    end
+  end
+end
+
+BabelBridge::Shell.new(TuringParser.new).start

data/examples/turing/turing06.rb

@@ -0,0 +1,20 @@
+require File.join(File.dirname(__FILE__),"..","..","lib","babel_bridge")
+
+class TuringParser < BabelBridge::Parser
+
+  binary_operators_rule :statement, :operand, [[:/, :*], [:+, :-]] do
+    def evaluate
+      left.evaluate.send operator, right.evaluate
+    end
+  end
+
+  rule :operand, "(", :statement, ")"
+  
+  rule :operand, /[-]?[0-9]+/ do
+    def evaluate
+      to_s.to_i
+    end
+  end
+end
+
+BabelBridge::Shell.new(TuringParser.new).start

data/examples/turing/turing07.rb

@@ -0,0 +1,21 @@
+require File.join(File.dirname(__FILE__),"..","..","lib","babel_bridge")
+
+class TuringParser < BabelBridge::Parser
+  ignore_whitespace
+
+  binary_operators_rule :statement, :operand, [[:/, :*], [:+, :-]] do
+    def evaluate
+      left.evaluate.send operator, right.evaluate
+    end
+  end
+
+  rule :operand, "(", :statement, ")"
+  
+  rule :operand, /[-]?[0-9]+/ do
+    def evaluate
+      to_s.to_i
+    end
+  end
+end
+
+BabelBridge::Shell.new(TuringParser.new).start

data/examples/turing/turing08.rb

@@ -0,0 +1,26 @@
+require File.join(File.dirname(__FILE__),"..","..","lib","babel_bridge")
+
+class TuringParser < BabelBridge::Parser
+  ignore_whitespace
+
+  binary_operators_rule :statement, :operand, [[:/, :*], [:+, :-], [:<, :<=, :>, :>=, :==]] do
+    def evaluate
+      case operator
+      when :<, :<=, :>, :>=, :==
+        (left.evaluate.send operator, right.evaluate) ? 1 : nil
+      else
+        left.evaluate.send operator, right.evaluate
+      end
+    end
+  end
+
+  rule :operand, "(", :statement, ")"
+  
+  rule :operand, /[-]?[0-9]+/ do
+    def evaluate
+      to_s.to_i
+    end
+  end
+end
+
+BabelBridge::Shell.new(TuringParser.new).start

data/examples/turing/turing09.rb

@@ -0,0 +1,37 @@
+require File.join(File.dirname(__FILE__),"..","..","lib","babel_bridge")
+
+class TuringParser < BabelBridge::Parser
+  ignore_whitespace
+
+  rule :statement, "if", :statement, "then", :statement, :else_clause?, "end" do
+    def evaluate
+      if matches[1].evaluate
+        matches[3].evaluate
+      else 
+        else_clause.evaluate if else_clause
+      end
+    end
+  end
+  rule :else_clause, "else", :statement
+
+  binary_operators_rule :statement, :operand, [[:/, :*], [:+, :-], [:<, :<=, :>, :>=, :==]] do
+    def evaluate
+      case operator
+      when :<, :<=, :>, :>=, :==
+        (left.evaluate.send operator, right.evaluate) ? 1 : nil
+      else
+        left.evaluate.send operator, right.evaluate
+      end
+    end
+  end
+
+  rule :operand, "(", :statement, ")"
+  
+  rule :operand, /[-]?[0-9]+/ do
+    def evaluate
+      to_s.to_i
+    end
+  end
+end
+
+BabelBridge::Shell.new(TuringParser.new).start

data/examples/turing/turing10.rb

@@ -0,0 +1,53 @@
+require File.join(File.dirname(__FILE__),"..","..","lib","babel_bridge")
+
+class TuringParser < BabelBridge::Parser
+  ignore_whitespace
+
+  def store
+    @store||=[]
+  end
+
+  rule :statement, "if", :statement, "then", :statement, :else_clause?, "end" do
+    def evaluate
+      if statement[0].evaluate
+        statement[1].evaluate
+      else 
+        else_clause.evaluate if else_clause
+      end
+    end
+  end
+  rule :else_clause, "else", :statement
+
+  binary_operators_rule :statement, :operand, [[:/, :*], [:+, :-], [:<, :<=, :>, :>=, :==]] do
+    def evaluate
+      case operator
+      when :<, :<=, :>, :>=, :==
+        (left.evaluate.send operator, right.evaluate) ? 1 : nil
+      else
+        left.evaluate.send operator, right.evaluate
+      end
+    end
+  end
+
+  rule :operand, "(", :statement, ")"
+  
+  rule :operand, "[", :statement, "]", "=", :statement do
+    def evaluate
+      parser.store[statement[0].evaluate] = statement[1].evaluate
+    end
+  end
+
+  rule :operand, "[", :statement, "]" do
+    def evaluate
+      parser.store[statement.evaluate]
+    end
+  end
+
+  rule :operand, /[-]?[0-9]+/ do
+    def evaluate
+      to_s.to_i
+    end
+  end
+end
+
+BabelBridge::Shell.new(TuringParser.new).start

data/examples/turing/turing11.rb

@@ -0,0 +1,63 @@
+require File.join(File.dirname(__FILE__),"..","..","lib","babel_bridge")
+
+class TuringParser < BabelBridge::Parser
+  ignore_whitespace
+
+  def store
+    @store||=[]
+  end
+
+  rule :statements, many(:statement,";"), match?(";") do
+    def evaluate
+      ret = nil
+      statement.each do |s|
+        ret = s.evaluate
+      end
+      ret
+    end
+  end
+
+  rule :statement, "if", :statement, "then", :statements, :else_clause?, "end" do
+    def evaluate
+      if statement.evaluate
+        statements.evaluate
+      else 
+        else_clause.evaluate if else_clause
+      end
+    end
+  end
+  rule :else_clause, "else", :statements
+
+  binary_operators_rule :statement, :operand, [[:/, :*], [:+, :-], [:<, :<=, :>, :>=, :==]] do
+    def evaluate
+      case operator
+      when :<, :<=, :>, :>=, :==
+        (left.evaluate.send operator, right.evaluate) ? 1 : nil
+      else
+        left.evaluate.send operator, right.evaluate
+      end
+    end
+  end
+
+  rule :operand, "(", :statement, ")"
+  
+  rule :operand, "[", :statement, "]", "=", :statement do
+    def evaluate
+      parser.store[statement[0].evaluate] = statement[1].evaluate
+    end
+  end
+
+  rule :operand, "[", :statement, "]" do
+    def evaluate
+      parser.store[statement.evaluate]
+    end
+  end
+
+  rule :operand, /[-]?[0-9]+/ do
+    def evaluate
+      to_s.to_i
+    end
+  end
+end
+
+BabelBridge::Shell.new(TuringParser.new).start

data/examples/turing/turing12.rb

@@ -0,0 +1,71 @@
+require File.join(File.dirname(__FILE__),"..","..","lib","babel_bridge")
+
+class TuringParser < BabelBridge::Parser
+  ignore_whitespace
+
+  def store
+    @store||=[]
+  end
+
+  rule :statements, many(:statement,";"), match?(";") do
+    def evaluate
+      ret = nil
+      statement.each do |s|
+        ret = s.evaluate
+      end
+      ret
+    end
+  end
+
+  rule :statement, "if", :statement, "then", :statements, :else_clause?, "end" do
+    def evaluate
+      if statement.evaluate
+        statements.evaluate
+      else 
+        else_clause.evaluate if else_clause
+      end
+    end
+  end
+  rule :else_clause, "else", :statements
+
+  rule :statement, "while", :statement, "do", :statements, "end" do
+    def evaluate
+      while statement.evaluate
+        statements.evaluate
+      end
+    end
+  end
+
+  binary_operators_rule :statement, :operand, [[:/, :*], [:+, :-], [:<, :<=, :>, :>=, :==]] do
+    def evaluate
+      case operator
+      when :<, :<=, :>, :>=, :==
+        (left.evaluate.send operator, right.evaluate) ? 1 : nil
+      else
+        left.evaluate.send operator, right.evaluate
+      end
+    end
+  end
+
+  rule :operand, "(", :statement, ")"
+  
+  rule :operand, "[", :statement, "]", "=", :statement do
+    def evaluate
+      parser.store[statement[0].evaluate] = statement[1].evaluate
+    end
+  end
+
+  rule :operand, "[", :statement, "]" do
+    def evaluate
+      parser.store[statement.evaluate]
+    end
+  end
+
+  rule :operand, /[-]?[0-9]+/ do
+    def evaluate
+      to_s.to_i
+    end
+  end
+end
+
+BabelBridge::Shell.new(TuringParser.new).start

data/examples/turing/turing_demo.rb

@@ -0,0 +1,71 @@
+require File.join(File.dirname(__FILE__),"..","..","lib","babel_bridge")
+
+class TuringParser < BabelBridge::Parser
+  ignore_whitespace
+
+  def store
+    @store||=[]
+  end  
+
+  rule :statements, many(:statement,";"), match?(";") do
+    def evaluate
+      ret = nil
+      statement.each do |s|
+        puts "class is: "+s.class
+        ret = s.evaluate
+      end
+      ret
+    end
+  end  
+
+  binary_operators_rule :statement, :operand, [[:/, :*], [:+, :-], [:<, :<=, :>, :>=, :==]] do
+    def evaluate
+      case operator
+      when :<, :<=, :>, :>=, :==
+        (left.evaluate.send operator, right.evaluate) ? 1 : nil
+      else
+        left.evaluate.send operator, right.evaluate
+      end
+    end
+  end
+
+  rule :statement, "if", :statement, "then", :statements, :else_clause?, "end" do
+    def evaluate
+      if statement[0].evaluate
+        statement[1].evaluate
+      else 
+        else_clause.evaluate if else_clause
+      end
+    end
+  end
+  rule :else_clause, "else", :statement
+
+  rule :statement, "while", :statement, "do", :statements, "end" do
+    def evaluate
+      while statement.evaluate
+        statements.evaluate
+      end
+    end
+  end  
+
+  rule :operand, "[", :statement, "]", "=", :statement do
+    def evaluate
+      parser.store[statement[0].evaluate] = statement[1].evaluate
+    end
+  end
+
+  rule :operand, "[", :statement, "]" do
+    def evaluate
+      parser.store[statement.evaluate]
+    end
+  end
+
+  rule :operand, "(", :statement, ")"
+  rule :operand, /-?[0-9]+/ do
+    def evaluate
+      to_s.to_i
+    end
+  end
+end
+
+BabelBridge::Shell.new(TuringParser.new).start

data/lib/nodes/many_node.rb

@@ -36,7 +36,9 @@ module BabelBridge
       ret=list.collect {|a|a.inspect(options)}.compact
       ret= if ret.length==0 then simple ? nil : "[]"
       elsif ret.length==1 && !ret[0]["\n"] then (simple ? ret[0] : "[#{ret[0]}]")
-      else (simple ? ret : ["[",ret,"]"]).flatten.join("\n") #.gsub("\n","\n  ")
+      else 
+        ret = ret.collect {|a| "  "+a.gsub("\n","\n  ")}
+        (simple ? ret : ["[",ret,"]"]).flatten.join("\n") #.gsub("\n","\n  ")
       end
       ret
     end

data/lib/nodes/node.rb

@@ -41,6 +41,13 @@ class Node
     self
   end
 
+  # Returns a human-readable representation of the parse tree
+  # options
+  #   :simple => output a simplified representation of the parse tree
+  def inspect(options={})
+    "(TODO: def #{self.class}#inspect(options={}))"
+  end
+
   #********************
   # info methods
   #********************

data/lib/parser.rb

@@ -160,6 +160,7 @@ class Parser
   attr_accessor :expecting_list
   attr_accessor :src
   attr_accessor :parse_cache
+  attr_accessor :failed_parse # gets set if the entire input was not matched
 
   def initialize
     reset_parser_tracking
@@ -209,6 +210,7 @@ class Parser
         if ret.next<src.length # parse only succeeds if the whole input is matched
           @parsing_did_not_match_entire_input=true
           @failure_index=ret.next
+          @failed_parse = ret
           ret=nil
         else
           reset_parser_tracking
@@ -235,51 +237,68 @@ class Parser
     node_list && node_list[common_root.length..-1].map{|p|"#{p.class}(#{p.offset})"}.join(" > ")
   end
 
-  def parser_failure_info
-    return unless src
-    bracketing_lines=5
-    line,col=src.line_col(failure_index)
-    ret=<<-ENDTXT
-Parsing error at line #{line} column #{col} offset #{failure_index}
-
-Source:
-...
-#{(failure_index==0 ? "" : src[0..(failure_index-1)]).last_lines(bracketing_lines)}<HERE>#{src[(failure_index)..-1].first_lines(bracketing_lines)}
-...
-ENDTXT
+  def nodes_interesting_parse_path(node)
+    path = node.parent_list
+    path << node
+    path.pop while path[-1] && !path[-1].kind_of?(NonTerminalNode)
+    path
+  end
 
-      if @parsing_did_not_match_entire_input
-        ret+="\nParser did not match entire input."
-      else
 
-        common_root=nil
-        expecting_list.values.each do |e|
-          node=e[:node]
-          pl=node.parent_list
-          if common_root
-            common_root.each_index do |i|
-              if pl[i]!=common_root[i]
-                common_root=common_root[0..i-1]
-                break
-              end
-            end
-          else
-            common_root=node.parent_list
+  def expecting_output
+    return "" if expecting_list.length==0
+    common_root=nil
+    expecting_list.values.each do |e|
+      node=e[:node]
+      pl=nodes_interesting_parse_path(node)
+      pl.pop # ignore the node itself
+      if common_root
+        common_root.each_index do |i|
+          if pl[i]!=common_root[i]
+            common_root=common_root[0..i-1]
+            break
           end
         end
-        ret+=<<ENDTXT
+      else
+        common_root=pl
+      end
+    end
+    <<ENDTXT
 
-Successfully matched rules up to failure:
+Parse path at failure:
   #{node_list_string(common_root)}
 
 Expecting#{expecting_list.length>1 ? ' one of' : ''}:
   #{expecting_list.values.collect do |a|
-    list=node_list_string(a[:node].parent_list,common_root)
+    list=node_list_string(nodes_interesting_parse_path(a[:node]),common_root)
     [list,"#{a[:pattern].inspect} (#{list})"]
   end.sort.map{|i|i[1]}.join("\n  ")}
 ENDTXT
+  end
+
+  #option: :verbose => true
+  def parser_failure_info(options={})    
+    return unless src
+    verbose = options[:verbose]
+    bracketing_lines=5
+    line,col=src.line_col(failure_index)
+    ret=<<-ENDTXT
+Parsing error at line #{line} column #{col} offset #{failure_index}
+
+Source:
+...
+#{(failure_index==0 ? "" : src[0..(failure_index-1)]).last_lines(bracketing_lines)}<HERE>#{src[(failure_index)..-1].first_lines(bracketing_lines)}
+...
+ENDTXT
+
+    if @parsing_did_not_match_entire_input
+      ret+="\nParser did not match entire input.\n"
+      if verbose
+        ret+="\nParsed:\n#{Tools::indent failed_parse.inspect}\n"
+      end      
     end
-    ret
+  
+    ret+expecting_output
   end
 end
 end

data/lib/pattern_element.rb

@@ -32,6 +32,10 @@ class PatternElement
     raise "pattern element cannot be both :dont and :optional" if negative && optional
   end
 
+  def inspect
+    "<PatternElement rule_variant=#{rule_variant.variant_node_class} match=#{match.inspect}>"
+  end
+
   def to_s
     match.inspect
   end
@@ -50,6 +54,11 @@ class PatternElement
     # Could-match patterns (PEG: &element)
     match.match_length=0 if match && could_match
 
+    if !match && terminal
+      # log failures on Terminal patterns for debug output if overall parse fails
+      parent_node.parser.log_parsing_failure(parent_node.next,:pattern=>self.match,:node=>parent_node)
+    end
+
     # return match
     match
   end
@@ -139,7 +148,7 @@ class PatternElement
 
     # generate delimiter_pattern_element
     delimiter_pattern_element= hash[:delimiter] && PatternElement.new(hash[:delimiter],rule_variant)
-
+    
     # generate post_delimiter_element
     post_delimiter_element=hash[:post_delimiter] && case hash[:post_delimiter]
     when TrueClass then delimiter_pattern_element

data/lib/rule_variant.rb

@@ -25,13 +25,7 @@ class RuleVariant
       match=pe.parse(node)
 
       # if parse failed
-      if !match
-        if pe.terminal
-          # log failures on Terminal patterns for debug output if overall parse fails
-          node.parser.log_parsing_failure(node.next,:pattern=>pe.match,:node=>node)
-        end
-        return nil
-      end
+      return if !match
 
       # parse succeeded, add to node and continue
       node.add_match(match,pe.name)

data/lib/shell.rb

@@ -8,9 +8,14 @@ class Shell
   end
 
   def evaluate(parse_tree_node)
-    parse_tree_node.evaluate
+    if parse_tree_node.respond_to? :evaluate
+      " => "+parse_tree_node.evaluate.inspect
+    else
+      "\nParse tree:\n  "+
+      parse_tree_node.inspect.gsub("\n","\n  ")+"\n\n"
+    end
   rescue Exception => e
-    @stderr.puts "Error evaluating parse tree: #{e}\n  "+e.backtrace.join("\n  ")
+    @stderr.puts "Error evaluating parse tree: #{e}\n  "+e.backtrace.join("\n  ")+"\nParse Tree:\n"+parse_tree_node.inspect
   end
 
   # if block is provided, successful parsers are yield to block
@@ -19,16 +24,18 @@ class Shell
     @stdout = options[:stdout] || $stdout
     @stderr = options[:stdout] || @stdout
     @stdin = options[:stdin] || $stdin
-    while line = @stdin == $stdin ? Readline.readline("> ", true) : @stdin.gets
-      ret = parser.parse line.strip
+    while line = @stdin == $stdin ? Readline.readline("> ", true) : @stdin.gets      
+      line.strip!
+      next if line.length==0
+      ret = parser.parse line
       if ret
         if block
           yield ret
         else
-          @stdout.puts " => #{evaluate(ret).inspect}"
+          @stdout.puts evaluate(ret)
         end
       else
-        @stderr.puts parser.parser_failure_info
+        @stderr.puts parser.parser_failure_info :verbose => true
       end
     end
   end

data/lib/string.rb

@@ -14,8 +14,11 @@ module BabelBridge
       lines.length<=n ? self : lines[-n..-1].join("\n")
     end
 
+    # return the line and column of a given offset into this string
+    # line and column are 1-based
     def line_col(offset)
-      lines=self[0..offset-1].split("\n")
+      return 1,1 if length==0 || offset==0
+      lines=(self[0..offset-1]+" ").split("\n")
       return lines.length, lines[-1].length
     end
   end

data/lib/tools.rb

@@ -2,15 +2,33 @@ module BabelBridge
 class Tools
   class << self
 
+    def indent(string,indent="  ")
+      indent + string.gsub("\n", "\n#{indent}")
+    end
+
+    def symbols_to_strings(array)
+      array.collect {|op| op.kind_of?(Symbol) ? op.to_s : op}
+    end
+
+    def regexp_and_strings_to_regexpstrings(array)
+      array.collect {|op| op.kind_of?(Regexp) ? op.source : Regexp.escape(op)}
+    end
+
+    # sort strings first, regexp second
+    # sort strings by lenght, longest first
+    # will then match first to last
+    def sort_operator_patterns(array)
+      array.sort_by {|a| a.kind_of?(Regexp) ? 0 : -a.length}
+    end
+
     # Takes an array of Strings and Regexp and generates a new Regexp 
     # that matches the or ("|") of all strings and Regexp
     def array_to_or_regexp_string(array)
-      new_re=array.flatten.collect do |op|
-        "("+case op
-        when Regexp then op.source
-        when String, Symbol then Regexp.escape(op.to_s)
-        end+")"
-      end.sort{|a|a.length}.join('|')
+      array = symbols_to_strings array.flatten
+      array = sort_operator_patterns array
+      array = regexp_and_strings_to_regexpstrings array
+
+      array.collect {|op| "(#{op})"}.join('|') #.tap {|a| puts "array_to_or_regexp_string(#{array.inspect}) -> /#{a}/"}
     end
 
     def array_to_anchored_or_regexp(array)
@@ -33,9 +51,10 @@ class BinaryOperatorProcessor
 
     operator_precedence.each_with_index do |op_level,i|
       (op_level.kind_of?(Array) ? op_level : [op_level]).each do |op|
+        precedence = operator_precedence.length - i
         case op
-        when String, Symbol then @exact_operator_precedence[op.to_s] = i
-        when Regexp then @regexp_operator_precedence << [op,i]
+        when String, Symbol then @exact_operator_precedence[op.to_s] = precedence
+        when Regexp then @regexp_operator_precedence << [op,precedence]
         end
       end
     end

data/lib/version.rb

@@ -1,3 +1,3 @@
 module BabelBridge
-  VERSION = "0.3.0"
+  VERSION = "0.3.1"
 end

data/test/test_bb.rb

@@ -394,7 +394,7 @@ class BBTests < TestHelper
 
   def test_binary_operator_rule
     parser=new_parser do
-      binary_operators_rule :bin_op, :int, [[:+, "-"], [:/, :*], "**"], :right_operators => ["**"] do
+      binary_operators_rule :bin_op, :int, ["**", [:/, :*], [:+, "-"]], :right_operators => ["**"] do
         def evaluate  
           "(#{left.evaluate}#{operator}#{right.evaluate})"
         end
@@ -408,11 +408,26 @@ class BBTests < TestHelper
     assert_equal "((1+2)+3)", parser.parse("1+2+3").evaluate
     assert_equal "(1+(2*3))", parser.parse("1+2*3").evaluate
     assert_equal "((1*2)+3)", parser.parse("1*2+3").evaluate
-    assert_equal "(5**6)", parser.parse("5**6").evaluate
+    assert_equal "(5**6)",    parser.parse("5**6").evaluate
     assert_equal "((1-2)+((3*4)/(5**6)))", parser.parse("1-2+3*4/5**6").evaluate
     assert_equal "(5**(6**7))", parser.parse("5**6**7").evaluate
   end
 
+  def test_line_col
+    assert_equal [1,1], "".line_col(0)
+    assert_equal [1,1], " ".line_col(0)
+    assert_equal [1,1], "a\nbb\nccc".line_col(0)
+    assert_equal [1,2], "a\nbb\nccc".line_col(1)
+    assert_equal [2,1], "a\nbb\nccc".line_col(2)
+    assert_equal [2,2], "a\nbb\nccc".line_col(3)
+    assert_equal [2,3], "a\nbb\nccc".line_col(4)
+    assert_equal [3,1], "a\nbb\nccc".line_col(5)
+    assert_equal [3,2], "a\nbb\nccc".line_col(6)
+    assert_equal [3,3], "a\nbb\nccc".line_col(7)
+    assert_equal [3,4], "a\nbb\nccc".line_col(8)
+    assert_equal [3,4], "a\nbb\nccc".line_col(9)
+  end
+
   def disabled_test_recursive_block
     # PEG does have this problem, so this isn't really an error
     # But maybe in the future we'll handle it better.

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: babel_bridge
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.3.1
   prerelease: 
 platform: ruby
 authors:
@@ -40,8 +40,24 @@ files:
 - lib/version.rb
 - examples/indention_grouping.rb
 - examples/indention_grouping_test.txt
-- examples/turing/test.rb
+- examples/test.rb
+- examples/turing/examples.turing
+- examples/turing/notes.rb
 - examples/turing/turing.rb
+- examples/turing/turing00.rb
+- examples/turing/turing01.rb
+- examples/turing/turing02.rb
+- examples/turing/turing03.rb
+- examples/turing/turing04.rb
+- examples/turing/turing05.rb
+- examples/turing/turing06.rb
+- examples/turing/turing07.rb
+- examples/turing/turing08.rb
+- examples/turing/turing09.rb
+- examples/turing/turing10.rb
+- examples/turing/turing11.rb
+- examples/turing/turing12.rb
+- examples/turing/turing_demo.rb
 homepage: http://babel-bridge.rubyforge.org
 licenses: []
 post_install_message: 

data/examples/turing/test.rb

@@ -1,28 +0,0 @@
-require File.join(File.dirname(__FILE__),"..","..","lib","babel_bridge")
-
-class TestParser < BabelBridge::Parser
-
-  rule :expr, :bin_op do
-    def evaluate
-      output = bin_op.evaluate
-      input = to_s
-      puts "bbtest: #{output} = #{eval output}"
-      puts "ruby: #{input} = #{eval input}"
-    end
-  end
-
-  #rule :bin_op, many(:int,/[-+\/*]/) do
-  binary_operators_rule :bin_op, :operand, [[:+, "-"], [:/, :*], "**"], :right_operators => ["**"] do
-    def evaluate  
-      "(#{left.evaluate}#{operator}#{right.evaluate})"
-    end
-  end
-
-  rule :operand, "(", :bin_op, ")"
- 
-  rule :operand, /[-]?[0-9]+/ do
-    def evaluate; to_s; end
-  end
-end
-
-BabelBridge::Shell.new(TestParser.new).start