reg 0.4.6

data/regposition.rb

@@ -0,0 +1,68 @@
+=begin copyright
+    reg - the ruby extended grammar
+    Copyright (C) 2005  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
+  class Position
+    require 'reg'
+    
+    class<<self
+      alias new__no_negatives
+      def new(nums)
+        nums.respond_to? :to_i and 0>nums and 
+          return PositionFromEnd.new(-nums)
+        new__no_negatives nums
+      end
+      alias [] new
+    end
+    
+    def initialize(nums)
+      Float===nums and nums=nums.to_i  #enables Position[-0.1]
+      @positions=nums
+    end
+    
+    def mmatch(pr)
+      pos=@positions
+      pos=adjust_position(pr,pos)
+        
+      to_res pos===pr.cursor.pos
+    
+    end
+
+    def itemrange
+      0..0
+    end
+
+  private
+    def adjust_position(pr,pos)
+      pos
+    end
+  
+    def to_res bool
+      bool ? 0  : nil
+    end
+  end
+
+
+  class PositionFromEnd < Position
+  private
+    def adjust_position(pr,pos)
+      pr.cursor.size+pos
+    end
+  end
+  
+end

data/regprogress.rb

@@ -0,0 +1,1067 @@
+=begin copyright
+    reg - the ruby extended grammar
+    Copyright (C) 2005  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
+begin
+  require 'rubygems'
+rescue #do nothing
+end
+
+require 'cursor'
+require 'cursor/indexed'
+
+
+=begin the internal api
+originally:
+ResAryFrag=Array #it would be nice to get a more precise definition....
+ResAry=+[ResAryFrag,-[MatchSet,Integer,ResAryFrag].*]
+
+Reg%:mmatch[Array,Integer,
+  Returns MatchSet|ResAryFrag|nil
+]
+Backtrace%:bt_match[Array,Integer,Integer,Integer,ResAry,Integer.-, 
+  Returns ResAry|nil,Integer,Integer
+]
+Matchset%:next_match[Array,Integer,
+  Returns ResAryFrag|nil,Integer
+]
+
+currently:
+Reg%:mmatch[Array,Integer,  #has to change to take progress soon
+  Returns MatchSet|ResAryFrag|nil
+]  #except subseq and repeat currently want progress
+Progress%:bt_match[Integer.-,   #affects progress, i'm pretty sure
+  Returns ResAry|nil,Integer,Integer  #1st result used only as bool
+]
+MatchSet%:next_match[Array,Integer,  #affects progress?
+  Returns ResAryFrag|nil,Integer
+]
+MatchSet%:initialize[Progress,OBS,Returns MatchSet] #for repeat and subseq only
+
+
+
+ultimately:
+Reg%:mmatch[Progress,  Returns MatchSet|Integer|nil]  #affects progress on success (when integer returned)
+Progress%:bt_match[Integer.-,   Returns Bool]  #affects progress on success
+MatchSet%:next_match[Returns Integer|nil]   #affects progress on success
+(modified progress is the same one as was given to the mmatch that created the matchset)
+MatchSet%:initialize[Progress,OBS,Returns MatchSet] #for every ms class
+          
+
+
+=end
+
+
+#---------------------------------------------
+module Reg
+
+  #---------------------------------------------
+  class MatchFailRec
+    attr_accessor(:undos_inc,:matchsucceed_inc,:position_inc)
+    def initialize
+      @undos_inc=@matchsucceed_inc=@position_inc=0
+    end
+    
+    #position_inc is the number of positions to pop off position stack
+    #to get back to the point before the match of the most recent matchset.
+    #it is also the count by which to adjust @regsidx to get back to the 
+    #corresponding reg which generated the matchset.
+    alias regs_adjust position_inc
+  end
+
+  #---------------------------------------------
+  class Progress
+    attr_reader :matcher, :cursor, :regsidx, :position_stack, :matchset_stack, :matchfail_todo, :variables
+    
+    #for internal use only...
+    attr_writer :undos_stack, :matchfail_todo, :matchsucceed_stack #, :regsidx
+       
+       
+    #@matchset_stack and @matchfail_todo are (nearly) parallel arrays; @matchfail_todo has
+    #one more item in it (at the bottom). each matchfailrec represents the things to undo 
+    #on failure to get back to the corresponding matchset's starting position.
+    
+    #@matchfail_todo is more or less a 2-dimensional array of integers. very many of
+    #those integers in the undos_inc and matchsucceed_inc columns will be zero. it
+    #would be nice to use a sparse vector or matrix instead.
+    
+    
+    #---------------------------------------------
+    def initialize(matcher,cursor)
+      @matcher=matcher
+      @cursor=cursor
+      @regsidx=0
+      @variables={}
+      @undos_stack=[] #recursive list of undo procs and vars defined in this entire match
+      @matchset_stack=[]
+      @position_stack=[@cursor.pos]
+      @matchfail_todo=[MatchFailRec.new]  #list of things to do when match fails.... undo(&adjust variables), matchsucceed, position, (matchset)
+      @matchsucceed_stack=[] #r-list of things to do when entire match succeeds... subst and deferreds
+      
+      assert check_result
+    end
+  
+    #---------------------------------------------
+    def push_matchset(ms)
+      assert MatchSet===ms 
+      @matchset_stack.push ms
+      @matchfail_todo.push MatchFailRec.new
+      #push_match len  #disable... caller wants to do it...
+    end
+    
+    #---------------------------------------------
+    def push_match(inc=0)
+      #matchset_stack should be 1 smaller than matchfail_todo
+      assert @matchfail_todo.size-1==@matchset_stack.size
+
+      @cursor.skip inc  #do nothing if no param given
+      @position_stack.push @cursor.pos  #push the start position of the next match
+      @matchfail_todo.last.position_inc+=1
+      @regsidx+=1
+    end
+    
+    #---------------------------------------------
+    #this method is dangerous! it leaves the object in an inconsistant state.
+    #caller must fixup state by either popping @matchset_stack or pushing a matchfail_todo
+    def backup_stacks
+        assert(@matchfail_todo.size >= 1)
+        discarding=@matchfail_todo.pop
+        #discarding should not ever be a list!
+        @regsidx-=discarding.position_inc #adjust position in matcher
+        assert(@position_stack.size >= discarding.position_inc) #what if position stack is empty here?
+        
+        discarding.position_inc.nonzero? and 
+          @position_stack=@position_stack.slice(0...-discarding.position_inc)
+        
+        #backup undo stack and execute undos
+        process_undos @undos_stack.slice!(-discarding.undos_inc..-1)
+                
+        #backup matchsucceed stack
+        discarding.matchsucceed_inc.nonzero? and 
+           @matchsucceed_stack=@matchsucceed_stack.slice(0...-discarding.matchsucceed_inc)
+        
+        return @matchset_stack.last
+    end
+     
+    #---------------------------------------------
+    def backtrack
+      assert @regsidx != INFINITY
+      assert check_result
+      mat=nil
+      loop do
+        ms=backup_stacks or return 
+        
+        mat=ms.next_match(@cursor.data?, @position_stack.last) and break
+        @matchset_stack.pop or huh
+      end
+      assert( (1..@matcher.max_matches)===@regsidx+1)
+      assert ::Array===mat
+      assert ::Array===mat.first
+
+
+      #back up cursor position 
+      @cursor.pos=@position_stack.last
+      
+      
+      
+      @matchfail_todo.push MatchFailRec.new
+      push_match mat.last
+      
+      assert @regsidx
+      return @regsidx, @cursor.pos-origpos
+    end
+  
+    #---------------------------------------------
+    #lookup something that was already matched, either by
+    #name or index(es).
+    #probably need to take a full path for parameters
+    def backref; huh end
+     
+    #---------------------------------------------
+    def subprogress(cursor=nil,matcher=nil)
+      result=dup
+      result.matchfail_todo=[MatchFailRec.new]
+      result.cursor=
+        if cursor
+          unless Cursor===cursor
+            huh #convert other data to a cursor...
+          end
+          cursor
+        else
+          result.cursor.position       # make a sub-cursor 
+        end
+      
+      result.position_stack=[result.cursor.pos]
+
+      @undo_stack.push result.undo_stack=[]
+      @matchsucceed_stack.push result.matchsucceed_stack=[]
+      @matchfail_todo.last.matchsucceed_inc+=1
+      @matchfail_todo.last.undo_inc+=1
+      
+      if matcher
+        @matcher=matcher#@matcher might be set to soemthing different
+        @regsidx=0
+      end
+      
+      assert result.check_result
+      
+      result
+    end
+    
+    #---------------------------------------------
+    def make_hash
+      huh
+    
+    end
+       
+    #---------------------------------------------
+    def last_match_range
+      @position_stack[-2]...@position_stack[-1]
+    end
+    
+    #---------------------------------------------
+    def top_matchset
+      @matchset_stack.last
+    end
+    
+    #---------------------------------------------
+    def register_variable(name)
+      @variables[name] and return warn( "variable #{name} is already defined")
+      @variables[name]=last_match_range
+      @undos_stack<<name
+      @matchfail_todo.last.undos_inc+=1
+    end
+
+  #---------------------------------------------
+  class Later #inside Progress, so it doesn't conflict with Reg::Later from regreplace.rb
+    def initialize(block,args)
+      @block,@args=block,args
+    end
+    class<<self; 
+      alias [] new; 
+    end
+    
+    def call
+      @block.call( *@args)
+    end
+  end
+
+    #---------------------------------------------
+    def register_undo *args, &block
+      @undos_stack<<Later[block,*args]
+      @matchfail_todo.last.undos_inc+=1
+    end
+    
+    #wannabe in class Array
+  def recursive_each arr,&block
+    arr.each {|item|
+      if item.respond_to? :to_a
+        recursive_each item.to_a, &block
+      else
+        block[item]
+      end
+    }
+  end
+  
+  def recursive_reverse_each arr,&block
+    arr.reverse_each {|item|
+      if item.respond_to? :to_a
+        recursive_reverse_each item.to_a, &block
+      else
+        block[item]
+      end
+    }
+  end
+
+    #---------------------------------------------
+    def process_undos(undos)
+      recursive_reverse_each undos do|undo| 
+        Symbol===undo ? @variables.delete(undo) : undo.call 
+      end
+    end
+
+
+    #---------------------------------------------
+    def register_replace(subst,*args) 
+      @matchsucceed_stack.push Later[subst,args]
+      @matchfail_todo.last.matchsucceed_inc+=1
+    end
+
+    #---------------------------------------------
+    def later(*args,&block)
+      @matchsucceed_stack.push Later[block,args]
+      @matchfail_todo.last.matchsucceed_inc+=1
+    end
+
+    #---------------------------------------------
+    def process_laters
+      recursive_reverse_each(@matchsucceed_stack) {|later| later.call }
+    end
+
+    #---------------------------------------------
+    def origpos
+      @position_stack.first
+    end
+
+    #---------------------------------------------
+    def posinc
+      @cursor.pos-origpos
+    end
+
+
+    #--------------------------
+    $RegTraceEnable=$RegTraceDisable=nil
+    def trace_enabled?
+      @trace||=nil
+      $RegTraceEnable or (!$RegTraceDisable && @trace)
+    end
+
+    #--------------------------
+    #bt, in this case, stands for 'backtracking'.
+    #but the cognoscenti refer to this method as 'bitch-match'.
+    def bt_match(match_steps=@matcher.max_matches)
+      assert @cursor.pos <= @cursor.size
+      assert origpos >= 0
+      assert posinc >= 0
+      assert( (0..match_steps)===@regsidx)
+      assert Integer===@position_stack.first
+      assert check_result
+      loop do #loop over regs to match
+        assert @cursor.pos <= @cursor.size
+        assert posinc >= 0
+        assert( (0..match_steps)===@regsidx)
+
+        if trace_enabled?
+          puts [@matcher, clean_result].map{|i|  i.inspect  }.join(' ')
+          #pp self
+        end
+  
+        assert check_result
+
+        #try a new match of current reg
+        r=@matcher.regs(@regsidx)
+        if r.respond_to? :mmatch #should test for being a Reg::Reg instead
+              # 'mmatch could return 2 items here'
+              m=r.mmatch(@cursor.data?, @cursor.pos)
+              #is a single match or a match set?
+              if m.respond_to? :next_match
+                #it's a set -- start new inner result array
+                #with initial match as first elem
+                push_matchset m
+                mat,matchlen=m.next_match(@cursor.data?,  @cursor.pos)
+                
+                assert mat
+                assert m
+              else
+                mat,matchlen=*m #single match or nil
+                m=nil
+              end
+        else
+          if r===(item=@cursor.read1after)
+            mat=RR[item]
+            matchlen=1
+          end
+        end
+        
+        
+        assert check_result
+
+        unless mat #match fail?
+          assert check_result
+          return to_result,posinc,@regsidx if @matcher.enough_matches? @regsidx
+
+          #doesn't match, try backtracking
+          assert @regsidx
+          backtrack or return nil #bt failed? we fail
+          assert(@cursor.pos<=@cursor.size)
+          assert check_result
+        else  #match succeeded
+          if !m and @matcher.respond_to? :want_gratuitous_btstop? and 
+            @matcher.want_gratuitous_btstop?(@regsidx)
+                push_matchset SingleMatch_MatchSet.new(matchlen)
+          end
+
+          #advance to next reg
+          assert check_result
+          push_match @matcher.update_di(0,matchlen)
+          assert(@cursor.pos<=@cursor.size)
+        end
+
+        assert(@cursor.pos<=@cursor.size)
+
+        assert check_result
+        return to_result,posinc,@regsidx if @regsidx>=match_steps
+        assert( (0..match_steps)===@regsidx)
+
+      end #loop
+
+    end
+
+    #---------------------------------------------
+    #maybe this isn't necessary?
+    #because backtrack is called after it,
+    #and it's doing the same things.... more or less
+    
+    def last_next_match; #(?ary=>@cursor,?start,?resfrag=>...?)
+      #huh #adapt logic from Backtrace
+      assert check_result
+      assert( (0..@matcher.max_matches)===@regsidx)
+      r=backup_stacks
+     
+      di=@cursor.pos=@position_stack.last
+      assert( (0..@matcher.max_matches)===@regsidx)
+      unless r 
+        @matchfail_todo.push MatchFailRec.new
+        assert check_result
+        return nil,nil,@regsidx
+      end
+      #something wrong here....
+
+      #dunno how to do this simply...
+      #assert full_up? if SubseqMatchSet===self
+
+      #@matchset_stack.pop  is called in backtrack but not here, why?
+
+
+      r,diinc=r.next_match(@cursor.data?,@cursor.pos)
+      unless r
+        #might need to return non-nil here, if resfrag isn't exhausted yet
+        assert( (0..@matcher.max_matches)===@regsidx)
+        @matchset_stack.pop
+        assert check_result
+        return nil,nil,@regsidx unless @matcher.enough_matches? @regsidx
+        return to_result, @cursor.pos-@position_stack.first, @regsidx
+      end
+
+      assert diinc
+      assert @cursor.pos+diinc <= @cursor.size
+      @cursor.skip diinc
+      #@regsidx-=matchfail_todo.position_inc #should be done in push_match...
+      @matchfail_todo.push MatchFailRec.new
+      push_match
+      
+      if @regsidx<@matcher.max_matches  #if there are more subregs of this reg to be matched
+        #re-match tail regs
+        assert @cursor.pos <= @cursor.size
+        #di is sometimes bad here, it seems....(fixed now?)
+        assert check_result
+        assert( (0..@matcher.max_matches)===@regsidx)
+        result=bt_match
+        assert check_result
+        return result
+      end
+
+
+
+      assert( (0..@matcher.max_matches)===@regsidx)
+      assert check_result
+      
+      return to_result,@cursor.pos-@position_stack.first,@regsidx
+    end
+
+    #---------------------------------------------
+    def check_result;
+  
+      #since this should be true, a separate @regsidx is unnecessary
+      assert @regsidx==@position_stack.size-1
+  
+      #matchset_stack should be 1 smaller than matchfail_todo
+      assert @matchfail_todo.size-1==@matchset_stack.size
+  
+  
+      #verify correct types in @-variables
+      assert Cursor===@cursor
+      assert @matcher.respond_to?( :update_di)
+      assert @regsidx >=0
+      @matchset_stack.each{|ms| assert MatchSet===ms  }
+      prev_pos=0
+      @position_stack.each{|pos| assert prev_pos<=pos; pos=prev_pos }
+      assert prev_pos<=@cursor.size 
+      
+      vars_copy=@variables.dup
+      @undos_stack.each {|i|
+        case i
+        #every element of @variables should also be a sym in @undos_stack
+          when Symbol: 
+            vars_copy.delete(i) or assert(false)
+            
+          when Later:
+          else assert(false)
+        end
+      }
+      assert vars_copy.empty?   #every var should be accounted for
+  
+      #sum of :undos_inc,:matchsucceed_inc,:position_inc in @matchfail_todo
+      #should be the same as the size of the corresponding stack.
+      uns=mats=poss=0
+      @matchfail_todo.each{|mfr|
+        uns+=mfr.undos_inc
+        mats+=mfr.matchsucceed_inc
+        poss+=mfr.position_inc
+      }
+      assert uns==@undos_stack.size
+      assert              mats==@matchsucceed_stack.size
+       assert             poss+1==@position_stack.size
+     
+      assert succ_stack_ok
+    
+      return true
+    end
+    
+    #---------------------------------------------
+    def succ_stack_ok(stk=@matchsucceed_stack)
+      stk.each{|elem|
+        case elem
+          when Array: succ_stack_ok(elem)
+          when Later: true
+          else
+        end or return
+      }
+      return true
+    end
+    private :succ_stack_ok
+  
+    #---------------------------------------------
+    def clean_result
+      result=[]
+      ms_pos_idx=@position_stack.size - @matchfail_todo.last.position_inc
+      ms_pos_idx=-1
+      result=(0...@position_stack.size-1).map{|i| 
+        if i==ms_pos_idx
+          ms_pos_idx-=1
+          #what if ms_idx too big?
+          ms_pos_idx-=@matchfail_todo[ms_idx].position_inc
+          ms.clean_result
+
+        else
+          @cursor.position{ #retain current pos while Cursor#[]
+            @cursor[@position_stack[i], @position_stack[i+1]-@position_stack[i]] 
+          }
+        end
+      }
+    
+      return result
+    end
+  
+    #---------------------------------------------
+    def to_result;
+      true#ok, i'm cheating
+    end
+
+  end #class Progress
+
+  class SingleMatch_MatchSet < MatchSet
+  #this is somewhat of a hack, and shouldn't be necessary....
+  #it exists because every backtracking stop has to have a 
+  #matchset in it, even the ones that only match one way. 
+  #this class encapsulates matchsets that match only one way.
+  
+  
+    def initialize(len)
+      #@len=len
+    end
+    
+    def next_match(arr,start)
+      #if @len
+      #  result=[arr[start,@len], @len]
+      #  @len=nil
+      #  result
+      #end
+    end
+  
+  
+  end
+
+
+if defined? $MMATCH_PROGRESS  #ultimately, mmatch will take a progress, but until then, disable this
+  #---------------------------------------------
+  class Subseq
+  
+    def mmatch(pr)
+    #in this version, all @regs are not multiple regs
+      pr=pr.subprogress(nil,self)
+      cu=pr.cursor
+      start=cu.pos
+      assert cu.pos<=cu.size
+      cu.pos+@regs.size<=cu.size or return nil
+      @regs.each do |reg|
+        assert cu.pos<cu.size
+        reg===cu.read1 or return nil
+      end
+      return [ [cu.read( start-cu.pos,true)], @regs.size ]
+    end
+    
+  private
+    def mmatch_multiple(pr)
+    #in this version, at least one of @regs is a multiple reg
+      #start==arr.size and huh
+      pr=pr.subprogress(nil,self)
+      cu=pr.cursor
+      start=cu.pos
+      start+itemrange.begin<=cu.size or return nil
+      assert( (0..cu.size).include?( start))
+      result,di,bogus=pr.bt_match
+      result and SubseqMatchSet.new(pr,di)
+    end
+   end
+
+  #---------------------------------------------
+  class Repeat
+    def mmatch(pr)
+      pr=pr.subprogress(nil,self)
+      cu=pr.cursor
+      start=cu.pos
+      start+@times.begin <= cu.size or return nil  #enough room left in input?
+      i=-1
+      (0...@times.end).each do |i|
+        start+i<cu.size or break(i-=1)
+        @reg===cu.read1 or break(i-=1)
+      end
+      i+=1
+      assert(   (0..@times.end)===i)
+      if i==@times.begin
+        return [[cu.read(start-cu.pos,true)], i]
+      end
+      i>@times.begin or return nil
+      return SingleRepeatMatchSet.new(i,-1,@times.begin)
+    end
+    
+  private
+    def mmatch_multiple(pr)
+      pr=pr.subprogress(nil,self)
+      start=cu.pos
+      assert start <= cu.size
+      start+itemrange.begin <= cu.size or return nil  #enough room left in input?
+      r=[[]]
+
+      #first match the minimum number
+      if @times.begin==0 #if we can match nothing
+        cu.eof? and return [r,0] #at end of input? return empty set
+        ri=di=0
+      else
+        cu.eof? and return nil
+        assert @times.begin<INFINITY
+        r,di,ri=pr.bt_match(@times.begin)  #matches @reg @times.begin times
+        r.nil? and return nil
+      end
+      assert ri==@times.begin
+
+      assert !@times.exclude_end?
+      left=@times.end-@times.begin
+
+      #note: left and top could be infinite here...
+
+      #do the optional match iterations
+      #only greedy matching implemented for now
+      #there must be a more efficient algorithm...
+      if left >= 1
+        assert pr.check_result
+        #get remaining matches up to @times.end times
+        rr=pr.make_hash
+        res,di,ri=pr.bt_match   #bt stop at each iteration, this time
+        assert pr.check_result( res)
+        assert @times===pr.regsidx
+        
+        res and return RepeatMatchSet.new(pr,(huh di))
+        assert rr==pr.make_hash
+      end
+
+      #if matchset has no backtracking stops, and 
+      #hence cannot contain more than one actual match,
+      #then just return that match.
+      pr.matchset_stack.empty? ? RepeatMatchSet.new(pr,(huh di)) :
+        [pr.clean_result,(huh di)]
+    end
+  end    
+  
+    #---------------------------------------------
+  class AndMatchSet
+    #the total number of possible different ways to match an AndMatchSet
+    #where several of the branches are actually ambiguous
+    #grows exponentially.
+    #rather than hit every possible match, we'll try to hit
+    #every legal match length at least once.
+    
+    #on next_match,
+    #figure out the alternative(s) that are returning the longest 
+    #matchset currently. those alternatives are returned in
+    #the first match, but at the 2nd and subsequent calls
+    #to next_match, that set of longest alternatives are all
+    #next_matched (rolled back) until they match something shorter.
+    #(or maybe just a different length? Reg::Or isn't greedy, so its
+    #longest match isn't necessarily returned first.)
+    
+    #if any next_match call returns nil (or false), the whole match set
+    #is finished. return nil from next_match now and forever more.
+    
+    
+  
+    def initialize
+      huh
+    end
+  end
+
+  #---------------------------------------------
+  class And
+    
+  private
+    #can't use this until mmatch interface is changed to take a single progress param
+    def mmatch_multiple(progress)
+        #in this version, at least one of @regs is a multiple reg
+      assert( (0..progress.cursor.size).include?( progress.cursor.pos))
+      result,*bogus=progress.bt_match
+      result and AndMatchSet.new(self,result)
+      #need new definition of AndMatchSet...
+      
+      #need to keep track of which alternative(s) was longest, so as to advance
+      #the cursor by that amount. and know which ones to start backtracking in.
+      
+      #cursor needs to be advanced here somewhere, i think.
+    end
+
+  end
+
+  
+else #... not $MMATCH_PROGRESS
+  class Subseq
+
+    def mmatch(arr,start)
+    #in this version, each of @regs is not a multiple reg
+      assert start<=arr.size
+      start+@regs.size<=arr.size or return nil
+      idx=0
+      @regs.each do |reg|
+        assert(start+idx<arr.size)
+        reg===arr[start+idx] or return nil
+        idx+=1
+      end
+      return [RR[arr[start,@regs.size]], @regs.size]
+    end
+
+    def mmatch_multiple(arr,start)
+      #in this version, at least one of @regs is a multiple reg
+      assert( (0..arr.size).include?( start))
+      cu=Cursor::Indexed.new(arr); cu.pos=start
+      pr=Progress.new(self,cu)
+      result,di,bogus=pr.bt_match
+      result and SubseqMatchSet.new(pr,di)
+    end
+  end
+  
+  class ::Cursor
+    class Indexed
+      def data?; @data end
+    end
+  end
+  
+  class Repeat
+    def mmatch(arr,start)
+      i=-1
+      (0...@times.end).each do |i|
+        start+i<arr.size or break(i-=1)
+        @reg===arr[start+i] or break(i-=1)
+      end
+      i+=1
+      assert(   (0..@times.end)===i)
+      if i==@times.begin
+        return [RR[arr[start,i]], i]
+      end
+      i>@times.begin or return nil
+      return SingleRepeatMatchSet.new(i,-1,@times.begin)
+    end
+
+    def mmatch_multiple(arr,start)
+      assert start <= arr.size
+      r=[RR[]]
+
+      cu=Cursor::Indexed.new(arr); cu.pos=start
+      pr=Progress.new(self,cu)
+
+      #first match the minimum number
+      if @times.begin==0 #if we can match nothing
+        arr.size==start and return [r,0] #at end of input? return empty set
+        ri=di=0
+      else
+        arr.size==start and return nil
+        assert @times.begin<INFINITY
+        r,di,ri=pr.bt_match(@times.begin)  #matches @reg @times.begin times
+        r.nil? and return nil
+      end
+      assert ri==@times.begin
+
+      assert !@times.exclude_end?
+      left=@times.end-@times.begin
+
+      #note: left and top could be infinite here...
+
+      #do the optional match iterations
+      #only greedy matching implemented for now
+      #there must be a more efficient algorithm...
+      if left >= 1
+        assert pr.check_result
+        #get remaining matches up to @times.end times
+         #because bt_match could change the rr argument, and 
+        #we might need to return the original in r below
+        res,di,ri=pr.bt_match
+#        assert Backtrace.check_result res  #this is correct, for now (i think) 
+                                           #don't update to progress version
+        assert @times===ri
+        
+        res and return RepeatMatchSet.new(pr,di)
+      end
+
+      #if matchset has no backtracking stops, and 
+      #hence cannot contain more than one actual match,
+      #then just return that match.
+      pr.matchset_stack.empty? ? 
+        [pr.clean_result,di] : RepeatMatchSet.new(pr,di)
+    end
+
+  end
+  
+end # $MMATCH_PROGRESS
+
+
+  
+  #---------------------------------------------
+  class MatchSet
+    #delegate to embedded progress, if any
+    def clean_result
+      huh
+      @progress.clean_result
+    end
+  end
+
+ #--------------------------
+  class RepeatMatchSet < MatchSet
+  
+    attr :progress
+    def initialize(progress,consumed) 
+      @progress=progress
+      #@cnt=@startcnt-stepper
+      #@ary.push 1
+      @consumed=consumed
+      @firstmatch=[progress.clean_result,@consumed]
+      assert( progress.matcher.times===progress.regsidx)
+      assert progress.regsidx
+      #assert(@ri==@firstmatch.first.size)
+    end
+
+    def match_iterations;
+      #assert(@ri==Backtrace.clean_result(@ary).size)
+      progress.regsidx
+    end
+
+    #very nearly identical to SubseqMatchSet#next_match
+    def next_match(arr,idx)
+      #fewer assertions in twin
+      if @firstmatch
+        result,@firstmatch=@firstmatch,nil
+        assert result.first.empty? || ::Array===result.first.first
+        #print "idx=#{idx}, inc=#{result.last}, arr.size=#{arr.size}\n"
+        assert idx+result.last<=arr.size
+        assert(progress.regsidx==result.first.size) 
+        return result
+      end
+      
+      @progress or return #not in twin ... ignore it
+      
+      assert progress.check_result
+
+      i=progress.matchfail_todo.last.position_inc
+=begin extents not used      
+      extents= if i==0
+        []
+      else
+        progress.position_stack[-i..-1]
+      end
+=end
+            #this part's not in twin
+      #'need to check for fewer matches here before rematching last matchset'
+      
+      #what if the match that gets discarded was returned by a matchset
+      #that has more matches in it?
+      #in that case, i is 1 and the body of this if should not be executed...      
+      if progress.regsidx>progress.matcher.times.begin  && i>1
+        huh progress.backup_stacks
+        huh #need to change progress.cursor.pos here too
+        huh #need to save result of backup_stacks
+        
+        #but now i need to undo all other progress state too, if 
+        #the state was created with the match result just popped.
+        #in general, it's not possible to distinguish state with the 
+        #last match from state with the matches that might have preceeded it...
+        #unless I create a backtracking point for each optional iteration
+        #of the repeat matcher.
+        #currently, making a backtracking point implies making a matchset
+        #as well. I'll need a matchset the contains only 1 match.
+        #ok, i think this is working now. no extra code needed here.
+        
+        @consumed-=pos-progress.position_stack.last
+        #assert(@ri==Backtrace.clean_result(@ary).size)
+        assert idx+@consumed<=arr.size
+        assert progress.check_result
+        result= [progress.clean_result, @consumed]
+        assert progress.check_result
+        return result
+      end
+
+
+        assert progress.check_result
+      assert( (0..@progress.matcher.max_matches)===@progress.regsidx)
+      result,di,ri=progress.last_next_match
+      if result and @progress.matcher.enough_matches? ri #condition slightly different in twin
+        result=[progress.clean_result,di]
+        @consumed=di  #not in twin...why?
+        #@progress.regsidx-=1
+        assert ::Array===result.first.first
+        assert idx+result.last<=arr.size
+        assert progress.check_result
+        #assert(@ri==result.first.size)
+        return result
+      end
+
+      assert( (0..@progress.matcher.max_matches)===@progress.regsidx)
+      #assert(@ri==Backtrace.clean_result(@ary).size)
+      assert(progress.check_result)
+      
+
+
+      @progress.matchset_stack.empty? and return @progress=nil  #also checking @ary in twin... ignore it
+        assert @progress.regsidx>0
+        
+      @progress.backtrack or return @progress=nil #@progress never set to nil like this in twin... ignore it
+
+      #this is where the divergence widens. ri is a local in twin
+ 
+        #assert(@ri==Backtrace.clean_result(@ary).size)
+      assert(progress.check_result)
+        mat,di,@ri=@progress.bt_match #mat is @ary in twin
+        mat.nil? and return @progress=nil
+
+        #assert(@ri==Backtrace.clean_result(mat).size)
+        assert @progress.regsidx
+      assert( (0..@progress.matcher.max_matches)===@progress.regsidx)
+
+      result=[@progress.clean_result,di]
+      @consumed=di  #no @consumed in twin
+      assert ::Array===result.first.first
+      assert idx+result.last<=arr.size
+        assert progress.check_result
+        #assert(@ri==result.last.size)
+      return result
+    end
+
+  end
+
+  #---------------------------------------------
+  class SubseqMatchSet < MatchSet
+    
+    def initialize progress,di;
+      @reg,@progress= progress.matcher,progress
+      
+      @orig_pos=progress.cursor.pos-di
+      @firstresult= [progress.clean_result,di]
+    end
+ 
+ #(@reg=>progress.matcher,@matchary=>progress.huh,di=>progress.cursor.pos-@orig_pos)
+ 
+    def next_match(ary,start)
+      if @firstresult
+        @firstresult,result=nil,@firstresult
+        assert ::Array===result.first.first
+        return result
+      end
+
+   
+      result,di,ri=@progress.last_next_match
+      result or return @progress=nil      
+      if result and ri==@reg.max_matches
+        result=[@progress.clean_result,di]
+        assert ::Array===result.first.first
+        return result
+      end
+      
+
+      (@progress and !@progress.matchset_stack.empty?) or return @progress=nil
+      assert @progress.regsidx
+      @progress.backtrack or return @progress=nil
+
+      #need to adjust ri?
+
+      #is this right... dunno...
+      result,di,bogus=@progress.bt_match
+
+
+      if result
+        result=[@progress.clean_result,di]
+        assert ::Array===result.first.first
+        return result
+      end
+    end
+    
+    def match_iterations
+      progress.matcher.max_matches
+    end
+    
+  end
+  #--------------------------
+  class AndMatchSet < SubseqMatchSet
+    #this isn't really right...
+    #on next_match, we need to backtrack the longest alternative(s)
+    #if they're then shorter than the next longest alternative, 
+    #then that (formerly next longest) alternative becomes
+    #the dominating alternative, and determines how much is consumed
+  
+  end
+  #might need Reg::Or tooo....
+
+  class Repeat
+    #--------------------------------------------------------
+    # "enable backtracking stops at each optional iteration"
+    def want_gratuitous_btstop?(steps)
+      @times===steps
+    end
+    
+  end
+
+
+  #---------------------------------------------
+  class Array
+    def ===(other)
+      ::Array===other or return false #need to be more generous eventually
+      progress=Progress.new(self,(Cursor::Indexed.new other))
+      result,di,bogus=progress.bt_match
+      assert di.nil? || di <= other.size
+      return(di==other.size && result)
+    end
+  end
+
+end
+
+#if false  #work-around warnings in cursor
+propNiller=proc do 
+    old_init=instance_method:initialize
+    
+    define_method:initialize do|*args|
+      @positions||=@prop||=nil    
+      old_init.bind(self)[*args]
+    end
+end
+Cursor::Indexed.instance_eval( &propNiller)
+Cursor::Position.instance_eval( &propNiller)
+#end