reg 0.4.8 → 0.5.0a0

data/regprogress.rb

@@ -1,1054 +0,0 @@
-=begin copyright
-    reg - the ruby extended grammar
-    Copyright (C) 2005,2009  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 LoadError #do nothing
-end
-
-require 'sequence'
-require 'sequence/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.move 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 Sequence===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.readahead1)
-            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.move 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 Sequence===@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_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 |i2| i=i2
-        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=Sequence::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 ::Sequence
-    class Indexed
-      def data?; @data end
-    end
-  end
-  
-  class Repeat
-    def mmatch(arr,start)
-      i=-1
-      (0...@times.end).each do |i2| i=i2
-        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=Sequence::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
-      @regs.empty? and return other.empty?
-      progress=Progress.new(self,(Sequence::Indexed.new other))
-      result,di,bogus=progress.bt_match
-      assert di.nil? || di <= other.size
-      return(di==other.size && result)
-    end
-  end
-
-end
-