reg 0.4.8 → 0.5.0a0

data/lib/reginstrumentation.rb

@@ -0,0 +1,36 @@
+=begin copyright
+    reg - the ruby extended grammar
+    Copyright (C) 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 'instrument'
+require 'reg'
+
+Instrument.on_entry_to(Reg::Progress, :bt_match, "args[0]||matcher")
+Instrument.on_exit_from(Reg::Progress, :bt_match)
+
+Instrument.on_entry_to(Reg::Progress, :last_next_match,
+  "args[0].matcher", "args[0].regsidx", "args[0].cursor.pos", "(args[0]||context).position_inc_stack")
+Instrument.on_exit_from(Reg::Progress, :last_next_match, "(args[0] || context).position_inc_stack")
+
+Instrument.on_entry_to(Reg::RepeatMatchSet, :next_match, :@consumed, "@context.matcher", "@context.position_inc_stack")
+Instrument.on_exit_from(Reg::RepeatMatchSet, :next_match, "@context.position_inc_stack")
+
+Instrument.on_entry_to(Reg::SubseqMatchSet, :next_match)
+Instrument.on_exit_from(Reg::SubseqMatchSet, :next_match)
+
+Instrument.on_entry_to(Reg::Progress, :backtrack, :position_stack, :position_inc_stack, "(args[0] || context).regsidx", "(args[0] || context).matcher")
+Instrument.on_exit_from(Reg::Progress, :backtrack)

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

@@ -1,6 +1,6 @@
 =begin copyright
     reg - the ruby extended grammar
-    Copyright (C) 2005,2009  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
@@ -25,12 +25,12 @@ module Reg
       return ItemThat.new(klass) unless block
        
       class <<block
-          #include arguments to include appear to be processed in a strange order... this is 
+          # arguments to include appear to be processed in a strange order... this is 
           #significant if order is important to you
           #the #included methods are perhaps not called when i think they should be....
           #(DON'T simplify the next line; it'll break.)
-        [BlankSlate ,Formula, BlockLike].each{|mod| include mod}
-        restore :inspect,:extend,:call
+        [BlankSlate ,];[Formula, BlockLike].each{|mod| include mod}
+#        restore :inspect,:extend,:call
 
         alias === eeee #workaround-- shouldn't be needed
         alias formula_value call
@@ -57,6 +57,11 @@ module Reg
     alias === eeee #does nothing in includers.... why?
     def formula_value *a,&b; call( *a,&b) end
 
+    def % name
+      super unless Symbol===name
+      Bound.new(name,self)
+    end
+
     
     def mixmod; ItemThatLike end
     def reg; dup.extend Reg end
@@ -64,20 +69,22 @@ module Reg
   
  #----------------------------------
   module DeferredQuery
-  #just an ancestor for ItemThat and RegThat
+  #just an ancestor for ItemThatLike and RegThatLike
     def eee(item)
-      begin formula_value item
-      rescue; false
-      end
+      formula_value item,{} rescue false
     end
     alias === eee #this doesn't work!!! WHY????
     #there's no way to define the method === in this
     #module and have it be defined in class ItemThat.
     #mixmod and reg don't have this problem. this must
-    #be a bug. for now, I work around it with clever 
+    #be a bug(??). for now, I work around it with clever 
     #alias/undefing in places that include/extend ItemThatLike
     #(seemingly, this is only a problem when including, not extending... dunno why)
     #this bug may be gone now; need to try to get rid of weird eee stuff.
+    
+  #  def mmatch(pr)
+  #    !pr.cursor.eof? and self===pr.cursor.readahead1 and [true,1]
+  #  end
   
   end
   
@@ -87,6 +94,13 @@ module Reg
     
     def mixmod; ItemThatLike end
     def reg; dup.extend RegThatLike end
+    
+    
+    #I should really consider adding better definitions of to_str, to_ary, (maybe) to_proc here
+    #respond_to? would be a good one too.
+    #or even in Deferred, maybe
+    #as it is, all kinds of weird stuff happens if respond_to? and to_ary both return true values,
+    #(which they do currently)
   end
   
   #----------------------------------
@@ -118,10 +132,16 @@ module Reg
     include Reg
     
     def mixmod; RegThatLike end
+    def reg; self end
+  end
+  
+  #----------------------------------
+  class RegThat < ItemThat
+    include RegThatLike
   end
   
   #----------------------------------
-  class RegThat
+  nil&&class RegThat
     include BlankSlate
     restore :inspect,:extend
     include Formula
@@ -130,13 +150,14 @@ module Reg
     undef eee
     def initialize(klass=nil)
       @klass=klass
+      super
     end
     
     def formula_value(val,*rest)
       #the exception raised here should be (eventually) caught by 
       #the handler in RegThatLike#eee. calling RegThat#formula_value isn't
       #really legitimate otherwise.
-      @klass and @klass===val || fail("item_that constraint mismatch")
+      @klass and @klass===val || fail("reg_that constraint mismatch")
     
       val
     end

data/{regknows.rb → lib/regknows.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
@@ -20,7 +20,9 @@ module Reg
   class Knows
     include Reg
     attr :sym
-    def initialize(sym) @sym=sym end
+    def initialize(sym) 
+      @sym=sym 
+    end
   
     def === (obj)
       obj.respond_to? @sym

data/{reglogic.rb → lib/reglogic.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
@@ -17,7 +17,7 @@
     Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 =end
 
-
+require 'warning'
 
 module Reg
 
@@ -81,10 +81,10 @@ module Reg
 
   #--------------------------
   class Not
-    include Reg
+    include Reg,Composite
     def initialize(reg)
-      @reg=reg
-      maybe_multiples(reg)
+      @reg=Deferred.defang! reg
+      super
     end
     def ===(obj)
       !(@reg===obj)
@@ -92,6 +92,7 @@ module Reg
     def ~
       @reg
     end
+    
 
     #deMorgan's methods...
     def &(reg)
@@ -108,8 +109,20 @@ module Reg
         super reg
       end
     end
+    def ^(reg)
+      if Not===reg
+        ~self ^ ~reg
+      else
+        super reg
+      end
+    end
+    #a|b|!a|!b|!a^!b|a^b
+    #0|0|1 |1 |0    |0
+    #0|1|1 |0 |1    |1
+    #1|0|0 |1 |1    |1
+    #1|1|1 |1 |0    |0
 
-    #mmatch_multiple implementation needed
+    #mmatch_full implementation needed
 
     def inspect
       "~("+@reg.inspect+")"
@@ -117,79 +130,83 @@ module Reg
 
     def subregs; [@reg] end
   end
-
+  
   #--------------------------
-  class Or
-    include Reg
+  #only subclasses should be created
+  class Logical
+    include Reg,Composite
     attr :regs
+    class<<self
+    def new(*regs)
+      #"optimization of Logicals over a single sub-expression disabled"
+      #regs.size==1 and return regs.first
+      regs=regs.map{|r| Deferred.defang! r }
+      super
+    end
+    alias [] new
+    end
     def initialize(*regs)
       @regs=regs
+      (@regs.size-1).downto(0){|i|
+        @regs[i,1]=*@regs[i].subregs if self.class==@regs[i].class
+      }
 
-      maybe_multiples(*regs)
-    end
-    def ===(obj)
-      @regs.each {|reg| reg===obj and return obj||true }
-      return false
+      super
     end
-
-    def |(reg)
-      newregs=@regs + ((self.class===reg )? reg.regs : [reg])
+    def subregs; @regs.dup end
+    
+    
+    def op(reg)
+      newregs=@regs + ((self.class===reg )? reg.subregs : [reg])
       self.class.new(*newregs)
     end
 
-
-    def inspect
-      @regs.collect{|r| r.inspect}.join' | '
+    def mmatch(progress)
+      progress.cursor.eof? and return
+      other=progress.cursor.readahead1
+      self.eee other and [true,1]
     end
+    
+    def max_matches; @regs.size end
 
-    def subregs; @regs end
+    def self.specialize_with_operator oper
+      %{
+        alias_method :#{oper}, :op
+        def inspect
+          @regs.size==0 and return "::#{name}[]"
+          @regs.size==1 and return "::#{name}[\#{@regs.first.inspect}]"
+          @regs.collect{|r| r.inspect}.join' #{oper} '
+        end
+      }
+    end  
   end
 
   #--------------------------
-  class And
-    include Reg
-    attr :regs
-    def initialize(*regs)
-      @regs=regs
-      maybe_multiples(*regs)
-    end
+  class Or < Logical
     def ===(obj)
-      @regs.each {|reg| reg===obj or return false }
-      return obj||true
-    end
-    def &(reg)
-      newregs=@regs + ((self.class===reg)? reg.regs : [reg])
-      self.class.new(*newregs)
-    end
-
-    def inspect
-      @regs.collect{|r| r.inspect}.join' & '
+      @regs.each {|reg| reg===obj  and return obj || true }
+      return false
     end
-
-    def subregs; @regs end
+    alias eee ===
+    eval specialize_with_operator(:|)
   end
-
   #--------------------------
-  class Xor
-    include Reg
-    attr :regs
-    def initialize(*regs)
-      @regs=regs
-      maybe_multiples(*regs)
-    end
+  class And < Logical
     def ===(obj)
-      @regs.find_all {|reg| reg===obj }.size==1
+      @regs.each {|reg| reg===obj  or return false }
+      return obj || true
     end
-    def ^(reg)
-      newregs=@regs + ((self.class===reg )? reg.regs : [reg])
-      self.class.new(*newregs)
-    end
-
-
-    def inspect
-      @regs.collect{|r| r.inspect}.join' ^ '
+    alias eee ===
+    eval specialize_with_operator(:&)
+  end
+  #--------------------------
+  class Xor < Logical
+    def ===(obj)
+      @regs.find_all {|reg| reg===obj }.size==1 or return
+      return obj || true
     end
-
-    def subregs; @regs end
+    alias eee ===
+    eval specialize_with_operator(:^) 
   end
+  
 end

data/{reglookab.rb → lib/reglookab.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
@@ -26,73 +26,83 @@ module Reg
   class LookAhead
     include Reg
     include Multiple
+    include Composite
     def initialize(reg)
       @reg=reg
+      super
     end
     
     def mmatch(pr)
-      @reg.mmatch(pr.subprogress( pr.cursor.position,@reg ))
+      @reg.mmatch(pr)
+      return [true,0]
+    end
+    
+    def mmatch_full
+      huh
     end
     
     def itemrange; 0..0 end
     
-    def subregs; [@reg] end
-  
     #most methods should be forwarded to @reg... tbd
-
+  
   end
   
   
   class LookBack
     include Reg
     include Multiple
+    include Composite
+    
     
     def initialize(reg)
       
       r=reg.itemrange
       @r=r.last-r.first
       @reg=reg
-      
+      super
     end
 
     def itemrange; 0..0 end
- 
-    def regs
-      [*regs_ary(huh)]
+    
+    def mmatch(pr)
+      warn "look at prev item, not next_"
+      @reg.mmatch(pr)
+      return [true,0]
     end
-
+    
     def regs_ary(pos,r=@r)
       [ (OB-r).l, @reg, Position[pos] ] #require unimplemented lazy operator....
     end 
 
-    def mmatch(pr)
+    def mmatch_full(pr)
+      huh
+
       cu=pr.cursor
       ra=@reg.itemrange
       pos=cu.pos
       startpos=pos-ra.last
+      pos>=ra.first or return
       r=if startpos<0 
         huh 'dunno what to do here'
-        foo=ra.first+startpos
+        newlast=ra.last+startpos
+        assert newlast>=ra.first #???
         startpos=0
-        pos-ra.first
+        ra=ra.first..ra.last+startpos
+        ra.last-ra.first
       else
         @r
       end
       reg= +regs_ary(pos,r)
-      cu=cu.position
-      cu.pos=startpos
-      reg.mmatch pr.subprogress(cu,reg)
+      reg.mmatch pr.subprogress(cu.position(startpos))
       
       #original pr.cursor position should be unchanged
       assert pos==cu.pos
       
-      huh #result should be fixed up to remove evidence of 
+      #huh #result should be fixed up to remove evidence of 
       #the subsequence and all but it's middle element.
+      return [true,0]
     end
-
-    def subregs; [@reg] end
-
+ 
     #most methods should be forwarded to @reg... tbd
   end
-
 end