reg 0.4.8 → 0.5.0a0

data/lib/regrepeat.rb

@@ -0,0 +1,307 @@
+=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 'regarray'
+module Reg
+
+  #--------------------------
+  class Repeat
+    include Reg,Backtrace,Multiple,Composite
+
+    attr :times
+
+    def max_matches; @times.end end
+
+    def regs(ri) @reg end
+
+    def initialize(reg,times)
+      Integer===times and times=times..times
+      times.exclude_end? and times=times.begin..times.end-1
+      assert times.begin <= times.end
+      assert times.begin < Infinity
+      assert times.begin >= 0
+      assert times.end >= 0
+      if Multiple===reg
+        class<<self
+          #alias mmatch mmatch_full #this doesn't work... why?
+          def mmatch(*xx) mmatch_full(*xx); end #have to do this instead
+        end
+      else
+        assert reg.itemrange==(1..1)
+        @itemrange=times
+      end
+      @reg,@times=reg,times
+      super
+    end
+
+    def itemrange
+      defined? @itemrange and return @itemrange
+      
+      list=Thread.current[:$Reg__Repeat__irs_in_progress]||={}
+      list[__id__] and huh
+      list[__id__]=1
+      i=@reg.itemrange
+      rf,rl=i.first,i.last
+      tf,tl=times.first,times.last
+      @itemrange = rf*tf ..
+          if tl==0 or rl==0
+            0
+          elsif tl==Infinity
+            #ought to emit warnings if trouble here...
+            #rl==Infinity and maybe trouble
+            #rf==0 and trouble
+            Infinity
+          elsif rl==Infinity
+            #...and here
+            #maybe trouble #... combinatorial explosion
+            Infinity
+          else
+            rl*tl
+          end
+    ensure
+      list.delete __id__ if list
+    end
+
+
+    def enough_matches? matchcnt,*bogus
+      @times===matchcnt
+    end
+
+    def inspect
+      "(#{@reg.inspect})"+
+      if @times.end==Infinity
+        if (0..1)===@times.begin
+          "."+%w[* +][@times.begin]
+        else
+        "+#{@times.begin}"
+        end
+      elsif @times.begin==0
+        "-#{@times.end}"
+      elsif @times.begin==@times.end
+        "*#{@times.begin}"
+      else
+        "*(#{@times.begin}..#{@times.end})"
+      end
+    end
+
+    def subregs; [@reg] end
+
+  private
+
+  end
+
+
+
+
+
+
+  #--------------------------
+  class None; end
+  class <<None #class as singleton instance
+    include Reg
+    def new; self end
+
+    def *(times) 
+      times===0 ? Many[0] : self
+    end
+
+    def ~; Any;  end
+
+    def &(other); self; end
+
+    def |(other) other.reg end
+    def ^(other) other.reg end
+
+    def ===(other); false; end
+    def matches_class; self; end
+    def inspect; "~_" end  #hmmmm...
+  end
+
+
+  #--------------------------
+  class Any; end
+  class <<Any  #maybe all this can be in Object's meta-class....
+    include Reg
+    
+    #any is a singleton
+    def new;        self      end
+
+    def *(times)
+      Many.new(times)
+    end
+
+    def ~; None;  end
+
+    def &(other) 
+      if other.itemrange.first>=1
+        other.reg 
+      else
+        And.new(self,other)
+      end      
+    end
+
+    def |(other); self;  end
+    def ^(other); ~other.reg end
+
+    def ===(other); true;end
+    def matches_class; ::Object end
+    def inspect; "_" end    #hmmmm...
+  end
+
+
+
+  #--------------------------
+  module HasCmatch; end
+  module HasBmatch; end
+  class ManyClass
+    include Reg
+    include Multiple
+
+    class <<self
+      @@RAMs={}
+      alias uncached__new new
+      def new times=0..Infinity
+        Range===times and times.exclude_end? and times=times.begin..times.end-1
+        @@RAMs[times] ||= uncached__new times
+      end
+      alias [] new
+    end
+
+    def initialize(times=0..Infinity)
+      Integer===times and times=times..times
+      @times=times
+      extend @times.begin==@times.end ? HasBmatch : HasCmatch
+#      super
+    end
+
+    def mmatch(arr,start)
+      left=arr.size-start
+      beg=@times.begin
+      if beg==left ; [arr[start..-1],left]
+      elsif beg<left
+        SingleRepeatMatchSet.new([left,@times.end].min, -1, beg)
+      end
+    end
+
+    def subregs; [Any]  end
+
+    def inspect
+      if @times.end.to_f.infinite?
+        if @times.begin.zero?
+          "__"
+        else
+          "(Any+#{@times.begin})"
+        end
+      elsif @times.begin==@times.end
+        "(Any*#{@times.begin})"
+      elsif @times.begin.zero?
+        "(Any-#{@times.end})"
+      else
+        "(Any*(#{@times}))"
+      end
+    end
+    
+    def l; ManyLazyClass.new(@times) end
+    def g; self end
+    
+    def itemrange; @times end
+  end
+  
+  #--------------------------
+  class ManyLazyClass
+    include Reg
+    include Multiple
+
+    class <<self
+      @@RAMs={}
+      alias uncached__new new
+      def new times=0..Infinity
+        Range===times and times.exclude_end? and times=times.begin..times.end-1
+        @@RAMs[times] ||= uncached__new times
+      end
+      alias [] new
+    end
+
+    def initialize(times=0..Infinity)
+      Integer===times and times=times..times
+      @times=times
+#      super
+    end
+
+ 
+    def subregs; [Any]  end
+
+    def inspect
+      if @times.end.to_f.infinite?
+        if @times.begin.zero?
+          "Many"
+        else
+          "(Any+#{@times.begin})"
+        end
+      elsif @times.begin==@times.end
+        "(Any*#{@times.begin})"
+      elsif @times.begin.zero?
+        "(Any-#{@times.end})"
+      else
+        "(Any*(#{@times}))"
+      end+".l"
+    end
+    
+    def mmatch(arr,start)
+      left=arr.size-start
+      beg=@times.begin
+      if beg==left ; [arr[start..-1],left]
+      elsif beg<left
+        SingleRepeatMatchSet.new(beg, 1, [left,@times.end].min)
+      end
+    end
+  
+       def g; ManyClass.new(@times) end
+       def l; self end
+    
+  end
+  
+  
+  Many=ManyClass.new
+  class<<Many
+    extend Forwardable
+    def_delegators ManyClass, :new, :[]
+  end
+
+  #--------------------------
+  class <<::Object
+    _Objects_class=::Object.__id__
+    define_method :reg do
+      __id__==_Objects_class ? Any : Fixed.new(self)
+    end
+  end
+  OB=Any
+  OBS=Many
+
+if false #traditional and uncomplicated version of OB and OBS  
+    OB=::Object.reg
+    OBS=OB+0  #std abbreviation for 0 or more of anything
+    def OBS.inspect
+      "OBS"
+    end
+    def OB.inspect
+      "OB"
+    end  
+end
+
+end

data/lib/regreplace.rb

@@ -0,0 +1,254 @@
+=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 'ron/graphedge'
+
+module Reg
+  module Reg
+
+    #turns a Reg that matches into a Reg that matches and
+    #replaces. (creates a Reg::Transform)
+    def >>(rep)
+      Transform.new(self,rep)
+    end
+    
+    def finally(&block)
+      Finally.new(self,block)
+    end
+  end
+  
+  class Finally
+    include Reg,Undoable,Composite
+    
+    def initialize(reg,block=nil,&block2)
+      raise ArgumentError if block and block2
+      @reg,@block=reg,block||block2
+      super
+    end
+    
+    def mmatch(progress)
+      progress.register_later progress(&@block) #shouldn't this be after mmatch?
+      
+      @reg.mmatch progress
+    end
+    
+    #forward most other things to @reg (but what??)
+  end
+
+
+=begin contexts for a Reg::Transform
+    an element of a Reg::Array, Reg::Subseq or Reg::Repeat (sequence)
+    a key matcher in a Reg::Hash or similar
+    a value matcher in Reg::Hash or similar
+    a value matcher in Reg::Object
+    directly in a top-level matcher
+
+    but a Reg::Logical (Or,  for instance) could be in any of above, and a Transform could be within.
+=end
+  
+  module TransformUndoable
+    include Undoable
+  end
+  
+  class Transform
+    include Reg,TransformUndoable,Composite
+    
+    def initialize(reg,rep)
+      Replace===rep or rep=Replace.make_replace( rep )
+      @left,@right=reg,rep
+      #@reg,@rep=reg,rep
+      super
+    end
+
+    attr_accessor :left,:right
+    #attr_reader :reg,:rep
+    alias reg left
+    alias rep right
+    alias from left
+    alias to right
+    alias from= left=
+    alias to= right=
+
+     
+    def mmatch(progress)
+      origpos=progress.get_index
+      result=@reg.mmatch(progress) or return 
+      MatchSet===result and return ReplaceMatchSet.new(self,progress,origpos,result)
+      replace origpos,result.last,progress
+      return result    
+    end
+    
+    def replace(origpos,len,progress)
+      Eventually===@rep and huh
+      progress.register_replace(origpos,len, @rep) 
+    end
+    
+    def subregs 
+      [@left]
+    end
+  end
+  
+=begin  
+  varieties of Reg::Replace: (replacement values)
+  Reg::BackrefLike
+  Reg::Bound ???
+  Reg::RepProc ... not invented yet
+  Reg::ItemThat... maybe not, but some sort of Deferred?
+  Reg::Equals (or Literal, it's descendant)
+  Reg::Fixed
+  Reg::Subseq... interpolate items
+  any other Object (as if wrapped in Reg::Fixed)
+  (Reg::Array inserts an array at that point. Reg::Subseq 
+   inlines its items at that point. when used this way, 
+   they are not matching anything, nor are the contents necessarily matchers.
+   they just serve as convenient container classes.)
+  (to actually insert a Reg::Array or anything that's special at this point,
+   wrap it in a Reg::Literal.)
+  Array (as if Reg::Array?)
+  Reg::Transform????
+=end
+  
+  module Replace
+    def self.evaluate(item,progress,gpoint) #at match time
+      huh
+      case item
+      when BackrefLike; item.formula_value(nil,progress)
+      when ItemThatLike; item.formula_value(gpoint.old_value,progress)
+#      when Bound; huh
+#      when Transform; huh????
+      when ::Reg::Array 
+        assert gpoint.is_a?( GraphPoint::Array)
+        [item.regs]
+      when ::Reg::Subseq
+        assert gpoint.is_a?( GraphPoint::Array)
+        item.regs
+      when ::Array; huh 'like Reg::Array or Reg::Subseq?'
+      when ::Reg::Wrapper; item.unwrap
+      when Replace::Form; item.fill_out(progress,gpoint)
+      else item #like it was wrapped in Reg::Fixed
+      end
+    end
+  
+    def self.make_replace item #at compile time
+      case item
+      when Deferred,Wrapper,BoundRef; Deferred.defang! item
+      #when ::Reg::Subseq; huh
+      #when ::Reg::Reg; huh #error?
+      else 
+        needsinterp=false
+        Ron::GraphWalk.breadth_graphwalk(item){|cntr,datum,idx,idxtype|
+          Deferred.defang! datum
+          case datum
+          when Deferred,Wrapper,BoundRef #,Formula ??
+            needsinterp=true
+          end
+        }
+        needsinterp and item=Replace::Form.new(item)
+      end
+      item      
+    end
+  
+    
+    
+    class Form #kinda like a lisp form... as far as i understand them anyway
+      def initialize(repldata)
+        @repldata=repldata
+        rebuild_dupset
+      end
+
+      def initialize_copy(other)
+        @repldata=other.repldata.clone rescue other.repldata
+        rebuild_dupset
+      end
+
+      def _dump
+        Marshal.dump(@repldata)
+      end
+
+      def self.load(str)
+        new(Marshal.load(str))
+      end
+
+      def rebuild_dupset
+        cntrstack=[]
+        @alwaysdupit=Set[]
+        seen=Set[]
+        traverser=proc{|cntr,o,i,ty|
+          next if seen.include? o.__id__
+          seen<< o.__id__          
+
+          cntrstack.push cntr.__id__     if cntr
+            case o
+            when Deferred,Literal; @alwaysdupit|=cntrstack
+            end
+            Ron::GraphWalk.traverse(o,&traverser)
+          cntrstack.pop
+        }
+        Ron::GraphWalk.traverse(repldata,&traverser)
+      end
+
+      attr :repldata
+
+      def repldata= repldata
+        @repldata=repldata
+        rebuild_dupset
+      end
+      
+      def fill_out_simple(session,other)
+        incomplete=false
+        result=Ron::GraphWalk.breadth_graphcopy(@repldata) {|cntr,o,i,ty,useit|
+          useit[0]=true
+          newo=@alwaysdupit.include?(o.__id__) ? o.dup : 
+          case o
+#          when ItemThatLike,RegThatLike;
+#            o.formula_value(other,session)
+          when Formula           #if there's any Deferred items in @repldata, evaluate (#formula_value) them now
+            o.formula_value(other,session)
+          when Literal;  o.unwrap #literal items should be unwrapped
+          when BoundRef; o.formula_value(other,session) #unreachable; BoundRefs are always Formulas currently
+          else useit[0]=false
+          end
+          incomplete=true if Formula===newo and not Literal===o
+          newo
+        }
+        result=Form.new result if incomplete and !session["final"]
+        return result
+      end
+
+      def fill_out(progress,gpoint)
+        Ron::GraphWalk.breadth_graphcopy(@repldata) {|cntr,o,i,ty,useit|
+          useit[0]=true
+          @alwaysdupit.include?(o.__id__) ? o.dup : 
+          case o
+          when ItemThatLike,RegThatLike
+            o.formula_value(gpoint.old_value,progress)
+          when Deferred;           huh #if there's any Deferred items in @repldata, evaluate (#formula_value) them now
+            o.formula_value(huh(nil),progress)
+          when Literal;  o.unwrap #literal items should be unwrapped
+          else useit[0]=false
+          end        
+        }
+        
+      
+        huh
+      end
+    
+    end
+  end
+  
+end