reg 0.4.8 → 0.5.0a0

data/{regarrayold.rb → lib/regarrayold.rb}

@@ -1,6 +1,6 @@
 =begin copyright
     reg - the ruby extended grammar
-    Copyright (C) 2005  Caleb Clausen
+    Copyright (C) 2005, 2016  Caleb Clausen
 
     This library is free software; you can redistribute it and/or
     modify it under the terms of the GNU Lesser General Public
@@ -18,6 +18,32 @@
 =end
 
 module Reg
+  module Reg
+    #--------------------------
+    #set a breakpoint when matches against a Reg
+    #are made. of dubious value to those unfamiliar
+    #with Reg::Array source code.
+    def bp #:nodoc: all
+      class <<self #:nodoc:
+        alias_method :unbroken___eee, :===     #:nodoc:
+        alias_method :unbroken___mmatch,
+           method_defined?(:mmatch) ? :mmatch : :fail #:nodoc:
+        def ===(other)  #:nodoc:
+          (defined? DEBUGGER__ or defined? Debugger) and Process.kill("INT",0)
+          unbroken___eee other
+        rescue
+          false
+        end
+
+        def mmatch(*xx)  #:nodoc:
+          (defined? DEBUGGER__ or defined? Debugger) and Process.kill("INT",0)
+          unbroken___mmatch(*xx)
+        end
+      end
+      self
+    end
+  end
+
   module Backtrace
     #--------------------------
     def Backtrace.clean_result(result,restype=RR)
@@ -142,7 +168,7 @@ module Reg
 
     #--------------------------
     def backtrace(arr,start,result,ri)
-      assert ri != INFINITY
+      assert ri != Infinity
       assert(Backtrace.check_result result)
       mat,matlen,di=nil
       loop do #might have to bt multiple times if prev prelim set also fails
@@ -338,7 +364,7 @@ module Reg
       return SingleRepeatMatchSet.new(i,-1,@times.begin)
     end
 
-    def mmatch_multiple(arr,start)
+    def mmatch_full(arr,start)
       assert start <= arr.size
       r=[RR[]]
 
@@ -348,7 +374,7 @@ module Reg
         ri=di=0
       else
         arr.size==start and return nil
-        assert @times.begin<INFINITY
+        assert @times.begin<Infinity
         r,di,ri=bt_match(arr,start,0,0,r,@times.begin)  #matches @reg @times.begin times
         r.nil? and return nil
       end
@@ -398,7 +424,7 @@ module Reg
       return [RR[arr[start,@regs.size]], @regs.size]
     end
     
-    def mmatch_multiple(arr,start)
+    def mmatch_full(arr,start)
     #in this version, at least one of @regs is a multiple reg
       #start==arr.size and huh
       assert( (0..arr.size).include?( start))
@@ -452,7 +478,7 @@ module Reg
       return result
     end
 
-    def subregs; @regs end
+    def subregs; @regs.dup end
   end
 
   #--------------------------
@@ -474,4 +500,4 @@ module Reg
     end
   end
 
-end
+end

data/lib/regbackref.rb

@@ -0,0 +1,73 @@
+=begin copyright
+    reg - the ruby extended grammar
+    Copyright (C) 2005, 2016  Caleb Clausen
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+=end
+require 'pp'
+require 'regdeferred'
+
+module Reg
+
+
+  #----------------------------------
+  module BackrefLike
+    def mmatch(pr)
+      huh #need info thats in Progress
+    end
+    
+    def mixmod; BackrefLike end
+  end
+  #----------------------------------
+  class Backref 
+    include BlankSlate
+    restore :inspect,:extend
+    restore :respond_to?
+    include Formula
+    include BackrefLike
+    def initialize(name,*path)
+      #complex paths not handled yet
+      raise ParameterError.new unless path.empty? 
+      @name=normalize_bind_name name
+      #super
+    end
+    
+    def formula_value(other,progress)
+      progress.lookup_var @name
+    end
+    
+    class<<self
+      alias [] new
+    end
+  end
+
+
+  #----------------------------------
+  module BRLike
+    include BackrefLike
+    include Reg
+    def mixmod; BRLike end
+  end
+  class BR < Backref
+    include BRLike
+    restore :respond_to?
+    def inspect
+      'BR['+@name.inspect+']'
+    end
+  end
+  
+  def self.BR(*args) BR.new(*args) end
+  def self.BackRef(*args) BackRef.new(*args) end
+end

data/lib/regbind.rb

@@ -0,0 +1,230 @@
+=begin copyright
+    reg - the ruby extended grammar
+    Copyright (C) 2005, 2016  Caleb Clausen
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+=end
+module Reg
+  module Reg
+    def bind(name=self)
+      name=name.name if BoundRef===name
+      Bound.new(name,self)
+    end
+    alias % bind
+    
+    def side_effect(&block); SideEffect.new(self,&block) end
+    def undo(&block); Undo.new(self,&block) end
+    def trace(&block); Trace.new(self,&block) end
+
+    def normalize_bind_name(name)
+      case name    
+      when Reg; name=name.inspect
+      when Symbol
+      else name=name.to_s.to_sym
+      end
+    end
+
+  end
+  
+  #-------------------------------------
+  class Bound
+    include Reg,Undoable,Composite
+    def initialize(name,reg)
+      @name,@reg=(normalize_bind_name name),reg
+      super
+    end
+  
+    def mmatch(progress)
+      progress.register_var(@name,progress.get_index)
+      result=@reg.mmatch(progress)
+      #the variable needs to be unbound if the match failed
+      result or progress.delete_variable @name
+      result
+    end
+  
+  
+    def mmatch_full(progress)
+      huh "what if result is a matchset?"
+      if result=@reg.mmatch(progress) 
+        idx=progress.get_index
+        range= if 1==result.last then idx else idx...idx+result.last end
+        progress.register_var(@name,range)
+      end
+      return result
+    end
+    
+    def inspect
+      @reg.inspect+"%"+@name.inspect
+    end
+  end
+
+  #-------------------------------------
+  class BoundRef
+    include Formula
+    def initialize(name)
+      @name=name
+    end
+    attr :name
+
+    def formula_value(other,session)
+      session[@name]
+    end
+
+    def == other
+      BoundRef===other and other.name==name
+    end
+
+    def hash
+      "BoundRef of ".<<(name.to_s).hash
+    end
+
+    def unparse o
+      inspect
+    end
+  end
+
+
+  #-------------------------------------
+  class WithBoundRefValues
+    include Formula
+    def initialize(br,values)
+      @br,@values=br,values
+    end
+    attr_reader :br,:values
+
+    def formula_value(other,session)
+      saved_keys=@values.keys
+      saved=saved_keys.map{|k| session[k] }
+      result=@br.formula_value(other,session.merge!(@values))
+      saved_keys.each_with_index{|k,i|
+        session[k]=saved[i]
+      }
+
+      if $Reg_rtrace and $Reg_rtrace===other
+        if values.size>1
+          vals=@values.dup
+          vals.delete :self
+          vals_str="values=#{vals.inspect}"
+        end
+        with=@br
+        with=with.repldata if Replace::Form===with
+        puts "replacing \n#{other.inspect} with \n#{with.inspect} #{vals_str}"
+      end
+
+      return result
+    end
+
+    def == other
+      other.is_a? WithBoundRefValues and
+        @br==other.br and @values==other.values
+    end
+
+    def hash
+      #@value is a Hash, and Hash#hash doesn't work in ruby 1.8 (fixed in 1.9)
+      #I thought I had a good implementation of Hash#hash somewhere....
+      @br.hash^@values.to_a.sort_by{|(k,v)| k }.hash
+    end
+
+    def chain_to inner
+      ::Ron::GraphWalk.graphcopy(self){|cntr,o,i,ty,useit|
+        if BoundRef===o and o.name==:self
+          useit[0]=true
+          inner
+        end
+      }
+    end
+  end
+
+  #-------------------------------------
+  class Trace
+    include Reg,Composite
+  
+    def initialize(reg,&block)
+      block||=proc{|reg2,other,result|
+        print "not " unless result
+        print reg2.inspect, " === ", other.inspect, "\n"
+      } 
+      @reg,@block=reg,block
+      super
+#      extend( HasCmatch===@reg ? HasCmatch : HasBmatch )
+    end
+  
+    def === other
+      result= @reg===other
+      @block.call @reg,other,result
+      return result
+    end
+
+      def generate_bmatch
+        "
+        begin
+          item=progress.cursor.readahead1
+          result=@reg.bmatch progress
+        ensure
+          @block.call @reg,item,result
+        end
+        "
+      end
+      def generate_cmatch
+        "
+        begin
+          success=nil
+          item=progress.cursor.readahead1
+          @reg.cmatch(progress){
+            @block.call @reg,item,true
+            success=true
+            yield
+          }
+        ensure
+          @block.call @reg,item,false unless success
+        end
+        "
+      end
+  end
+  
+  #-------------------------------------
+  class SideEffect
+    include Reg,Composite
+  
+    def initialize(reg,&block)
+      @reg,@block=reg,block
+      super
+    end
+  
+    def mmatch(progress)
+      huh "what if result is a matchset?"
+      result=@reg.mmatch(progress) and 
+        @block.call(progress)
+      return result
+    end
+  end
+  
+  #------------------------------------
+  class Undo
+    include Reg,Undoable,Composite
+  
+    def initialize(reg,&block)
+      @reg,@block=reg,block
+      super
+    end
+  
+    def mmatch(progress)
+      huh "what if result is a matchset?"
+      result=@reg.mmatch(progress) and 
+        progress.register_undo(@block)
+      return result
+    end
+  end
+end

data/{regcase.rb → lib/regcase.rb}

@@ -1,6 +1,6 @@
 =begin copyright
     reg - the ruby extended grammar
-    Copyright (C) 2005  Caleb Clausen
+    Copyright (C) 2005, 2016  Caleb Clausen
 
     This library is free software; you can redistribute it and/or
     modify it under the terms of the GNU Lesser General Public
@@ -18,6 +18,8 @@
 =end
 module Reg
   class Case
+    include Reg
+    include Composite
     def initialize(*args)
       if args.size==1 and Hash===args.first 
         scalars=[]; sets=[]
@@ -35,7 +37,8 @@ module Reg
         args=scalars+sets+matchers
       end
       
-      @others=others_given=nil
+      @others=None
+      others_given=nil
       @pairlist=args.delete_if{|a|
           if !(Pair===a)
             warn "ignoring non-Reg::Pair in Reg::Case: #{a}"
@@ -43,16 +46,17 @@ module Reg
           elsif OB==a.left
             others_given and warn 'more than one default specified'
             others_given=true
-            @others=v
+            @others=a.right
           end  
       }
+      super
+      assert(!is_a? Multiple)
     end
   
     def ===(other)
       @pairlist.each{|pair|
         pair.left===other and pair.right===other || return
-      }
-      @others===other
+      } or @others===other
     end
   
     #hash-based optimization of scalars and sets is possible here
@@ -70,6 +74,12 @@ module Reg
       }
       
     end
+    
+    def subregs
+      result=@pairlist.inject([]){|a,pair| a+pair.to_a}
+      result+=[OB,@others] if @others
+      return result
+    end
   
   end