babel_bridge 0.3.1 → 0.4.0

data/babel_bridge.gemspec

@@ -1,20 +1,23 @@
 require File.join(File.dirname(__FILE__),"lib/babel_bridge.rb")
 
-$gemspec = Gem::Specification.new do |s|
-  s.name = "babel_bridge"
-  s.version = BabelBridge::VERSION
-  s.author = "Shane Brinkman-Davis"
-  s.date = "2010-11-28"
-  s.email = "shanebdavis@gmail.com"
-  s.homepage = "http://babel-bridge.rubyforge.org"
-  s.platform = Gem::Platform::RUBY
-  s.rubyforge_project = "babel-bridge"
-  s.summary = "A Ruby-based parser-generator based on Parsing Expression Grammars."
-  s.description = <<DESCRIPTION
-Babel Bridge is an object oriented parser generator for parsing expression grammars (PEG). 
+$gemspec = Gem::Specification.new do |gem|
+  gem.name = "babel_bridge"
+  gem.version = BabelBridge::VERSION
+  gem.author = "Shane Brinkman-Davis"
+  gem.date = "2010-11-28"
+  gem.email = "shanebdavis@gmail.com"
+  gem.homepage = "http://babel-bridge.rubyforge.org"
+  gem.platform = Gem::Platform::RUBY
+  gem.rubyforge_project = "babel-bridge"
+  gem.summary = "A Ruby-based parser-generator based on Parsing Expression Grammars."
+  gem.description = <<DESCRIPTION
+Babel Bridge is an object oriented parser generator for parsing expression grammars (PEG).
 Generate memoizing packrat parsers 100% in Ruby code with a simple embedded DSL.
 DESCRIPTION
-  
-  s.files = ["LICENSE", "README", "Rakefile", "babel_bridge.gemspec", "{test,lib,doc,examples}/**/*"].map{|p| Dir[p]}.flatten
-  s.has_rdoc = false
+
+  gem.files = ["LICENSE", "README", "Rakefile", "babel_bridge.gemspec", "{test,spec,lib,doc,examples}/**/*"].map{|p| Dir[p]}.flatten
+  gem.has_rdoc = false
+
+  gem.add_development_dependency 'rake'
+  gem.add_development_dependency 'rspec'
 end

data/examples/turing/turing++.rb

@@ -0,0 +1,154 @@
+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]
+
+# DONE: turing.rb PLUS
+# => functions
+# => local variables
+# => stack
+# TODO: add variables and functions
+# TODO: add closures
+# TODO: add classes
+
+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||=[]
+  end
+
+  # the stack consists of an array of hashs
+  # Each entry in the stack is a call-frame with a hash of local variable names
+  def stack; @stack ||= [{}]; end
+
+  def current_stack_frame; stack[-1]; end
+  def globals; stack[0]; end
+
+  rule :statements, many(:statement,";"), match?(";") do
+    def evaluate
+      ret = nil
+      statement.each do |s|
+        ret = s.evaluate
+      end
+      ret
+    end
+  end
+
+  rule :statement, :function_definition
+
+  rule :function_definition, "def", :identifier, :parameter_list?, "do", :statements, "end" do
+    def evaluate
+      stack_frame = parser.current_stack_frame
+      stack_frame[identifier.to_sym] = self
+      1 # return true
+    end
+
+    def parameter_names; @parameter_names||=parameter_list ? parameter_list.parameter_names : []; end
+
+    def evaluate_function(params)
+      params ||= []
+      locals = {}
+      raise "wrong number of parameters. #{identifier} expects #{parameter_names.length} but got #{params.length}" unless params.length == parameter_names.length
+      parameter_names.each_with_index do |name,index|
+        locals[name] = params[index]
+      end
+      parser.stack << locals
+      statements.evaluate.tap {parser.stack.pop}
+    end
+  end
+
+  rule :parameter_list, "(", many(:identifier, ","), ")" do
+    def parameter_names
+      @parameter_names ||= identifier.collect{|a|a.to_sym}
+    end
+  end
+
+  rule :statement, "if", :statement, "then", :statements, :else_clause?, "end" do
+    def evaluate
+      if statement.evaluate
+        statements.evaluate
+      elsif else_clause
+        else_clause.evaluate 
+      end
+    end
+  end
+  rule :else_clause, "else", :statements
+
+  rule :statement, "while", :statement, "do", :statements, "end" do
+    def evaluate
+      ret = nil
+      while statement.evaluate
+        ret = statements.evaluate
+      end
+      ret
+    end
+  end
+
+  binary_operators_rule :statement, :operand, [[:/, :*], [:+, :-], [:<, :<=, :>, :>=, :==]] do
+    def evaluate
+      ret = left.evaluate.send operator, right.evaluate
+      case operator
+      when :<, :<=, :>, :>=, :== then ret ? 1 : nil
+      else ret
+      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, "nil" do
+    def evaluate
+      nil
+    end
+  end
+
+  rule :operand, :identifier, "=", :statement do
+    def evaluate
+      stack_frame = parser.current_stack_frame
+      stack_frame[identifier.to_sym] = statement.evaluate
+    end
+  end
+
+  rule :operand, :identifier, :parameters? do
+    def evaluate
+      globals = parser.globals
+      stack_frame = parser.current_stack_frame
+      name = identifier.to_sym
+      raise "undefined variable: #{name.inspect}" unless globals.has_key?(name) || stack_frame.has_key?(name)
+      case value = stack_frame.has_key?(name) ? stack_frame[name] : globals[name]
+      when BabelBridge::Node then value.evaluate_function(parameters.evaluate)
+      else value
+      end
+    end
+  end
+
+  rule :parameters, "(", many(:statement,","), ")" do 
+    def evaluate
+      statement.collect {|s|s.evaluate}
+    end
+  end
+
+  rule :identifier, /[_a-zA-Z][_a-zA-Z0-9]*/
+
+  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

@@ -1,44 +1,32 @@
-require File.join(File.dirname(__FILE__),"..","..","lib","babel_bridge")
+require "babel_bridge"
 
 class TuringParser < BabelBridge::Parser
   ignore_whitespace
 
   def store
     @store||=[]
-  end  
+  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
+      if matches[1].evaluate
+        matches[3].evaluate
       else 
         else_clause.evaluate if else_clause
       end
     end
   end
-  rule :else_clause, "else", :statement
+  rule :else_clause, "else", :statements
 
   rule :statement, "while", :statement, "do", :statements, "end" do
     def evaluate
@@ -46,7 +34,19 @@ class TuringParser < BabelBridge::Parser
         statements.evaluate
       end
     end
-  end  
+  end
+
+  binary_operators_rule :statement, :operand, [[:/, :*], [:+, :-], [:<, :<=, :>, :>=, :==]] do
+    def evaluate
+      res = left.evaluate.send operator, right.evaluate
+      case operator
+      when :<, :<=, :>, :>=, :==
+        res ? 1 : nil
+      else
+        res
+      end    
+    end
+  end
 
   rule :operand, "[", :statement, "]", "=", :statement do
     def evaluate
@@ -61,7 +61,7 @@ class TuringParser < BabelBridge::Parser
   end
 
   rule :operand, "(", :statement, ")"
-  rule :operand, /-?[0-9]+/ do
+  rule :operand, /[-]?[0-9]+/ do
     def evaluate
       to_s.to_i
     end

data/lib/nodes.rb

@@ -3,7 +3,8 @@
   empty_node
   terminal_node
   non_terminal_node
+  rule_node
   many_node
 }.each do |file|
   require File.join(File.dirname(__FILE__),"nodes",file)
-end
+end

data/lib/nodes/empty_node.rb

@@ -13,5 +13,15 @@ class EmptyNode < Node
   def inspect(options={})
     "EmptyNode" unless options[:simple]
   end
+
+  # EmptyNodes should always match at the beginning of the whitespace range
+  def node_init(parent_or_parser)
+    super
+    self.offset = preceding_whitespace_range.first
+    self.preceding_whitespace_range = match_range
+  end
+
+  def matches; [self]; end
+
+end
 end
-end

data/lib/nodes/many_node.rb

@@ -5,60 +5,49 @@ http://babel-bridge.rubyforge.org/
 =end
 
 module BabelBridge
-  # generated by a :poly PatternElement
-  # Not subclassed
-  class ManyNode < Node
-    attr_accessor :matches,:delimiter_matches
-    def initialize(parent)
-      node_init(parent)
-      self.matches=[]
-      self.delimiter_matches=[]
-    end
-
-    def match_length; self.next-offset end
+# generated by a :poly PatternElement
+# Not subclassed
+class ManyNode < NonTerminalNode
 
-    def next
-      if m=matches[-1]
-        m_next=m.next
-        if d=delimiter_matches[-1]
-          d_next=d.next
-          m_next > d_next ? m_next : d_next
-        else
-          m_next
-        end
-      else
-        parent.next
-      end
-    end
+  def delimiter_matches
+    @delimiter_matches||=[]
+  end
 
-    def inspect_helper(list,options)
-      simple=options[:simple]
-      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 
-        ret = ret.collect {|a| "  "+a.gsub("\n","\n  ")}
-        (simple ? ret : ["[",ret,"]"]).flatten.join("\n") #.gsub("\n","\n  ")
-      end
-      ret
-    end
+  def separate_delimiter_matches
+    count = 0
+    @matches, @delimiter_matches = @matches.partition {|el| count+=1;(count%2==1)}
+    @delimiter_matches = @delimiter_matches[0..@matches.length-2] #delimiter_matches should be exactly 1 shorter
+    update_match_length
+  end
 
-    def inspect(options={})
-      if options[:simple]
-        c=[]
-        matches.each_with_index {|n,i| c<<n;c<<delimiter_matches[i]}
-        c=c.compact
-        inspect_helper(c,options)
-      else
-        ret=inspect_helper(matches,options)
-        ret+=" delimiters="+inspect_helper(delimiter_matches,options) if delimiter_matches.length>0
-        ret
-      end
+  def inspect_helper(list,options)
+    simple=options[:simple]
+    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
+      ret = ret.collect {|a| "  "+a.gsub("\n","\n  ")}
+      (simple ? ret : ["[",ret,"]"]).flatten.join("\n") #.gsub("\n","\n  ")
     end
+    ret
+  end
 
-    def method_missing(method_name, *args)  #method_name is a symbol
-      self.map {|match| match.send(method_name,*args)}
+  def inspect(options={})
+    if options[:simple]
+      c=[]
+      matches.each_with_index {|n,i| c<<n;c<<delimiter_matches[i]}
+      c=c.compact
+      inspect_helper(c,options)
+    else
+      ret=inspect_helper(matches,options)
+      ret+=" delimiters="+inspect_helper(delimiter_matches,options) if delimiter_matches.length>0
+      ret
     end
+  end
 
+  def method_missing(method_name, *args)  #method_name is a symbol
+    self.map {|match| match.send(method_name,*args)}
   end
+
+end
 end

data/lib/nodes/node.rb

@@ -7,12 +7,33 @@ end
 
 # base class for all parse-tree nodes
 class Node
-  attr_accessor :src,:offset,:match_length,:parent,:parser
+  attr_accessor :src,:offset,:match_length,:parent,:parser,:preceding_whitespace_range
+
+  def whitespace_regexp
+    parser.whitespace_regexp
+  end
+
+  # the index of the first character after the match
+  def offset_after_match
+    offset + match_length
+  end
+
+  def match_range
+    offset..(offset+match_length-1)
+  end
+
+  def trailing_whitespace_range
+    parser.white_space_range offset_after_match
+  end
 
   def to_s
     text
   end
 
+  def to_sym
+    to_s.to_sym
+  end
+
   def node_init(parent_or_parser)
     self.match_length=0
     case parent_or_parser
@@ -24,6 +45,7 @@ class Node
       self.parent=parent_or_parser
       self.parser=parent.parser
       self.offset=parent.next
+      self.preceding_whitespace_range=parent.trailing_whitespace_range
       self.src=parent.src
       raise "parent node does not have parser set" unless parser
     else
@@ -51,8 +73,8 @@ class Node
   #********************
   # info methods
   #********************
-  def next; offset+match_length end       # index of first character after match
-  def text; src[offset,match_length] end  # the substring in src matched
+  def next; trailing_whitespace_range.last+1 end # index of first character after match and any trailing whitespace
+  def text; src[match_range] end  # the substring in src matched
 
   # length returns the number of sub-nodes
   def length
@@ -66,36 +88,8 @@ class Node
   def node_path
     "#{parent && (parent.node_path+' > ')}#{self.class}(#{offset})"
   end
-
-  #*****************************
-  # Array interface implementation
-  #*****************************
-  def matches # override this with function that returns array of matches to be used for Array indexing and iteration
-    []
-  end
-
-  include Enumerable
-  def length
-    matches.length
-  end
-
-  def <<(node)
-    matches<<node
-  end
-
-  def add_delimiter(node)
-    delimiter_matches<<node
-  end
-
-  def [](i)
-    matches[i]
-  end
-
-  def each(&block)
-    matches.each(&block)
-  end
 end
 
 class RootNode < Node
 end
-end
+end