reg 0.4.8 → 0.5.0a0

data/regreplace.rb

@@ -1,114 +0,0 @@
-=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
-  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 later(&block)
-      Later.new(self,block)
-    end
-  end
-  
-  class Later
-    include Reg
-    
-    def initialize(reg,block)
-      @reg,@block=reg,block
-    end
-    
-    def mmatch(progress)
-      progress.later progress,@reg &@block
-      
-      @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
-    a key matcher in a Reg::Hash
-    a value matcher in Reg::Hash
-    a value matcher in Reg::Object
-
-    but a Reg::logical (Or,  for instance) could be in any of above, and a Transform could be within.
-  =end
-
-  class Transform
-    include Reg
-    
-    def initialize(reg,rep)
-      Replace===rep or Replace.make_replace rep
-      @reg,@rep=reg,rep
-    end
-     
-     #this works for transforms in arrays, but what about transforms in 
-     #Reg::Hash or Reg::Object keys? and values? what about tranforms used directly
-     #as matchers (ie, how does a transform respond to ===?) 
-    def mmatch(progress)
-          origpos=progress.cursor.pos
-      result=@reg.mmatch(progress) and 
-        progress.later {
-          Integer===result or fail 'need just int returned from mmatch'
-          progress.cursor[origpos,result]=@rep.replace_with(progress,@reg,origpos,result)
-        }
-      return result
-    end
-  end
-
-=begin  
-  varieties of Reg::Replace:
-  Reg::Backref and Reg::Bound
-  Reg::RepProc
-  Reg::ItemThat... maybe not, but some sort of Deferred
-  Reg::Fixed
-  Object (as if wrapped in Reg::Fixed)
-  Reg::Array and Reg::Subseq?
-  (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::Fixed.)
-  Array (as if Reg::Array? or Reg::Subseq?)
-  Reg::Transform?
-=end
-  module Replace
-    huh
-    def self.make_replace(item)
-      case item
-      when ::Array: huh Reg::Array|Reg::Subseq
-      when Reg::Fixed
-      else huh #like Reg::Fixed
-    end
-    
-    def replace_with
-      huh
-    
-    end
-  
-  end
-end

data/regsugar.rb

@@ -1,230 +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
-this file contains the various 'convenience constructors' which might pollute the
-global namespace. it's optional, but highly recommended.
-
-if you want the tla's only, then don't call Sugar.include! (note that reg.rb calls this,
-so requiring 'reg' gives you global sugar by default). To add the tla's only into
-the current namespace, then load (not require) 'regsugar' in that namespace. example:
-
-  module SomeNamespace
-    require 'reglogic', 'regcore' #.... whatever other parts you need (see reg.rb)
-    load 'regsugar'
-    
-    def m(...)
-      ....
-      Reg[Array,Symbol,/fo+/,3..10]===somevar or raise MyError.new
-      ....
-    end
-  end
-      
-  
-  
-
-=end
-
-require 'forward_to'
-require 'set'
-
-
-
-#tla sugar moved into the related files plus central stuff in regcore.rb
-#(maybe the regcore stuff can move here?,,, but sugar is supposed to be optional...\
-
- 
-#need tlas for Reg::Knows, Reg::Symbol
- 
-module ::Reg
-  class <<self
-    #Reg::Array convenience constructor. see Array#+@ for details.
-    def [](*args)
-      ::Reg::Array.new(*args)
-    end
-  end
-
-  module Sugar    
-    module Array
-      def +@
-        ::Reg::Array.new(*self)
-      end
-      def -@
-        ::Reg::Subseq.new(*self)
-      end
-    end
-    
-    module Hash
-      def +@
-        ::Reg::Hash.new(self)
-      end
-      def -@
-        ::Reg::Object.new(self)
-      end
-    end
-    
-    module Symbol
-      def [](*args)
-        ::Reg::Knows.new(self)[*args]
-      end
-      
-      def **(other)
-        reg ** other
-      end
-      
-      def -@
-        #item_that.respond_to?(self).reg
-        ::Reg::Knows.new(self)
-      end
-    end
-    #i'd like to take String#-@ and #** too...
-    
-    
-    module Regexp
-      #just like the original version of ::Regexp#~ 
-      #(except this takes an optional argument to 
-      #compare against something else.)
-      def cmp(other=$_); 
-        self =~ other 
-      end
-      
-      #~ itself has to be handled in Sugar::include!
-      
-      include ::Reg::Reg
-
-      def matches_class; ::String end
-
-      #creates a Regexp that works with symbols instead of strings
-      def sym; ::Reg::Symbol.new(self) end
-    end
-    
-    module Module
-      include ::Reg::Reg
-    end
-    
-    module Range
-      include ::Reg::Reg
-    end
-  
-    module Set
-      #&|^+- are already defined in Set... resolved by piracy below
-      include ::Reg::Reg   
-      
-      def ===(other)
-        include? other
-      end
-      
-      #need an optimized ~ that returns a Set-like...
-    end
-    
-    
-    module ::Kernel
-      forward_to ::Reg,   :item_that, :item_is, :regproc  #last need a better name
-    end
-
-  
-    class << self
-    
-      @@RegexpPirate=proc{
-        class ::Regexp #doesn't work in Sugar::Regexp cause ~ is already defined in ::Regexp
-          #negates the sense of receiver regexp. returns something that matches everything
-          #that the original didn't, (including all non-Strings!).
-          undef ~
-          alias ~ not
-        end
-      }
-      
-      @@oplookup =    {
-        :"+"      => :"op_plus",
-        :"-"      => :"op_minus",
-        :"+@"     => :"op_plus_self",
-        :"-@"     => :"op_minus_self",
-        :"*"      => :"op_mul",
-        :"**"     => :"op_pow",
-        :"/"      => :"op_div",
-        :"%"      => :"op_mod",
-        :"<<"     => :"op_lshift",
-        :">>"     => :"op_rshift",
-        :"~"      => :"op_tilde",
-        :"<=>"    => :"op_cmp",
-        :"<"      => :"op_lt",
-        :">"      => :"op_gt",
-        :"=="     => :"op_equal",
-        :"<="     => :"op_lt_eq",
-        :">="     => :"op_gt_eq",
-        :"==="    => :"op_case_eq",
-        :"=~"     => :"op_apply",
-        :"|"      => :"op_or",
-        :"&"      => :"op_and",
-        :"^"      => :"op_xor",
-        :"[]"     => :"op_fetch",
-        :"[]="    => :"op_store"
-      }
-
-      
-      def alphabetic_name(meth)
-        @@oplookup[meth] or case meth
-          when /\?$/; :"op_#{meth[0...-1]}_p"
-          when /!$/; :"op_#{meth[0...-1]}_bang"
-          when /=$/; :"op_#{meth[0...-1]}_setter"
-          when /^op_/; :"op_#{meth}"
-          else meth
-        end
-      end
-    
-      def pirate_school(klass,meth,exception)
-      
-        klass=klass.to_s; exception=exception.to_s
-        /^::/===klass or klass="::#{klass}"
-        /^::/===exception or exception="::#{exception}"
-        eval %{
-          class #{klass}
-            setmeth=instance_method :#{meth}
-            undef #{meth}
-            regmeth= ::Reg::Reg.instance_method :#{meth}
-            define_method :#{meth} do |other|
-              #{exception}===other and return setmeth.bind(self).call(other)
-              regmeth.bind(self).call(other)
-            end
-          end
-        }
-      end
-
-      def include!    
-        constants.each{|con| (::Object.const_get con).instance_eval "include Sugar::#{con}" }
-        
-        #take over Regexp#~ to mean 'not' rather than 'compare to $_'
-        #eval needed to avoid "class inside of def" syntax error
-        instance_eval( &@@RegexpPirate)  #boy, that's trick
-        
-        #extend Set's version of certain operators to respect the
-        #reg versions as well. (The type of the rhs determines which
-        #version is used.)
-        [:+, :-, :&, :|, :^ ].each {|opname| 
-          pirate_school ::Set,opname,::Enumerable
-        } if ::Reg::Reg>::Set
-
-        ::Object.const_set :None,::Reg::None if defined? ::Reg::None
-        ::Object.const_set :OB,::Reg::OB if defined? ::Reg::OB
-        ::Object.const_set :OBS,::Reg::OBS if defined? ::Reg::OBS
-      end  
-    end
-
-  end
-end

data/regtest.rb

@@ -1,1078 +0,0 @@
-#!/usr/bin/ruby -w 
-=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
-
-$Debug=true #turn on assertions
-
-require "reg"
-require "regarray"
-require "reglogic"
-require "reghash"
-require "regvar"
-require "assert"
-require 'getoptlong'
-
-#require 'test/unit'  #gets in the way of my debug output
-class TC_Reg #< Test::Unit::TestCase
-class <<self
-
-
-  def randsym
-    as=Symbol.all_symbols
-    as[rand(as.size)]
-  end
-
-  def makelendata(num=20,mask=0b11111111111,mischief=false)
-    result=[]
-    (1..num).each do
-      begin type=rand(11) end until 0 != mask&(1<<type)
-      len=type==0 ? 0 : rand(4)
-
-      result<<case type
-        when 0    then [0]
-        when 1 then [len]+(1..len).map{randsym}
-        when 2 then (1..len).map{randsym}+[-len]
-        when 3 then (1..len).map{randsym}+["infix#{len}"]+(1..len).map{randsym}
-        when 4
-          [:Q] +
-            (1..len).map{randsym}.delete_if {|x|:Q==x} +
-            (1..rand(4)).map{randsym}.delete_if {|x|:Q==x} +
-          [:Q]
-        when 5
-          [:Q] +
-            (1..len).map{randsym}.delete_if {|x|:Q==x} +
-            [:'\\', :Q] +
-            (1..rand(4)).map{randsym}.delete_if {|x|:Q==x} +
-          [:Q]
-
-        when 6
-          [:q]+(1..len).map{randsym}.delete_if {|x|:q==x}+[:q]
-
-        when 7
-          [:begin]+
-            (1..len).map{randsym}.delete_if {|x| :begin==x or :end==x} +
-            (1..rand(4)).map{randsym}.delete_if {|x| :begin==x or :end==x} +
-          [:end]
-
-        when 8
-          [:begin]+
-            (1..len).map{randsym}.delete_if {|x| :begin==x or :end==x} +
-            [:'\\', 0==rand(1) ? :begin : :end] +
-            (1..rand(4)).map{randsym}.delete_if {|x| :begin==x or :end==x} +
-          [:end]
-
-        when 9
-          [:begin]+
-            (1..len).map{randsym}.delete_if {|x| :begin==x or :end==x} +
-            [:begin]+(1..len).map{randsym}.delete_if {|x| :begin==x or :end==x} +[:end]+
-            (1..rand(4)).map{randsym}.delete_if {|x| :begin==x or :end==x} +
-          [:end]
-
-        when 10
-          [:begin]+
-            (1..len).map{randsym}.delete_if {|x| :begin==x or :end==x} +
-            [:'\\', 0==rand(1)? :begin : :end] +
-            (1..rand(4)).map{randsym}.delete_if {|x| :begin==x or :end==x} +
-            [:begin]+(1..len).map{randsym}.delete_if {|x| :begin==x or :end==x} +[:end]+
-            (1..rand(4)).map{randsym}.delete_if {|x| :begin==x or :end==x} +
-          [:end]
-      end
-    end
-    mischief and result.insert(rand(result.size),mischief)
-    return result
-  end
-  
-  def rand_ambig
-    nestlevel=rand(5)+1
-    corepat=rand(1)==0 ? 'OB' : 'Numeric.reg'
-    pat=corepat
-    product=1
-    nestlevel.times { 
-      op=case rand(3)
-           when 0; :*
-           when 1; :+
-           when 2; :-
-         end
-      num=rand(6)+1
-      product*=num
-      pat=["(",pat,")",op,num].join 
-      product>50 and break
-    }
-    
-    pat=eval "+[#{pat}]"
-    $verbose and print "testing #{pat.inspect} with #{product} items\n"
-    assert_eee pat,(1..product).to_a
-  end
-  
-  def test_rand_reg
-    20.times { rand_ambig }
-  end
-
-
-  def test_reg
-eat_unworking=<<'#end unworking'
-     assert_eee +[OB-1+1]===[1]  #the 0*infinity problem
-     assert_eee +[OB-1-2+1]===[1,2]  #the 0*infinity problem
-#end unworking
-
-
-
-     h={}
-     h.default=:b
-     test_hash_matcher Rah(:a=>:b), :matches=>h 
-
-$RegTraceEnable=1 #debugging zone:
-$RegTraceEnable=false#end debug zone
-
-     assert_eee Reg[OB*2*(1..2)*2, OB*2], [:foo]*6
-     assert_eee Reg[(OB+2)*(1..2)+2, OB+2], [:foo]*6
-
-     assert_eee Reg[OB+6,OB+1], [:foo]*7
-     assert_eee Reg[OB+1,OB+1,OB+1], [:foo]*3
-
-     assert_eee( /s/^/t/,'siren')
-     assert_eee( /s/^/t/,'tire')
-     assert_ene( /s/^/t/,'street')
-     assert_ene( /s/^/t/,'and')
-     
-     assert_ene( /s/^/t/^/r/,'siren')
-     assert_eee( /s/^/t/^/r/,'sigh')
-     assert_ene( /s/^/t/^/r/,'tire')
-     assert_eee( /s/^/t/^/r/,'tie')
-     assert_eee( /s/^/t/^/r/,'rye')
-     assert_ene( /s/^/t/^/r/,'stoop')
-     assert_ene( /s/^/t/^/r/,'street')
-     assert_ene( /s/^/t/^/r/,'and')
-
-     assert_ene( +[OBS, -[/s/]^-[/t/,/r/]^-[/i/,/n/,/g/], OBS], 
-       [1,2,3, "a","b","c", 4,5,6] )
-     assert_eee( +[OBS, -[/s/]^-[/t/,/r/]^-[/i/,/n/,/g/], OBS], 
-       [1,2,3, "soup", 4,5,6] )
-     assert_eee( +[OBS, -[/s/]^-[/t/,/r/]^-[/i/,/n/,/g/], OBS], 
-       [1,2,3, "stoop", 4,5,6] )
-     assert_eee( +[OBS, -[/s/]^-[/t/,/r/]^-[/i/,/n/,/g/], OBS], 
-       [1,2,3, "stoop", "rickshaw", 4,5,6] )#backtracking fools ya
-     #assert_eee( +[OBS.l, -[/s/]^-[/t/,/r/]^-[/i/,/n/,/g/], OBS.l], 
-     #  [1,2,3, "stoop", "rickshaw", 4,5,6] )#lazy ought to work
-     assert_ene( +[-[/s/]^-[/t/,/r/]^-[/i/,/n/,/g/]], ["stoop", "rickshaw"])
-     assert_ene( +[OBS, -[/s/]^-[/t/,/r/]^-[/i/,/n/,/g/], OBS], 
-       [1,2,3, "sit", "ran", "gee-gaw",4,5,6])
-     assert_eee( +[OBS, -[/s/]^-[/t/,/r/]^-[/i/,/n/,/g/], OBS], 
-       [1,2,3, "turtle", "rickshaw", 4,5,6] )#works, but backtracking fools ya
-     assert_eee( +[OBS, -[/s/]^-[/t/,/r/]^-[/i/,/n/,/g/], OBS], 
-       [1,2,3, "turtle", "rival", 4,5,6] )
-     assert_eee( +[OBS, -[/s/]^-[/t/,/r/]^-[/i/,/n/,/g/], OBS], 
-       [1,2,3, "ink", "nap", "great, super", 4,5,6] )#works, but backtracking fools ya; it was /s/ that matched
-     assert_eee( +[OBS, -[/s/]^-[/t/,/r/]^-[/i/,/n/,/g/], OBS], 
-       [1,2,3, "ink", "nap", "great", 4,5,6]  )
-
-     assert_eee(  +[], []  )
-     assert_ene(  +[], [:q]  )
-     assert_ene(  +[], [nil]  )
-     assert_eee(  +[:q], [:q]  )
-     assert_eee(  +[-[]], []  )
-     assert_ene(  +[-[]], [:q]  )
-     assert_ene(  +[-[]], [nil]  )
-     assert_eee(  +[-[:q]], [:q]  )
-     assert_eee(  +[-[:q]*1], [:q]  )
-     assert_eee(  +[-[:q, :q]*1], [:q,:q]  )
-     assert_eee(  +[-[:q, :q]*(0..1)], [:q,:q]  )
-     assert_eee(  +[-[:q, :q]*(0..2)], [:q,:q]  )
-     assert_eee(  +[-[:q, :q]*(0..4)], [:q,:q]  )
-     assert_eee(  +[-[:q, :q]*(0..10)], [:q,:q]  )
-     assert_eee(  +[-[:q, :q]-1], [:q,:q]  )
-     assert_eee(  +[:q.reg+1], [:q]  )
-     assert_eee(  +[/q/+1], ['q']  )
-     assert_eee(  +[-[:q]+1], [:q]  )
-     assert_eee(  +[-[:q, :q]+1], [:q,:q]  )
-     assert_eee(  +[-[:q, :q]+0], [:q,:q]  )
-
-
-     lenheadalts=-[0]|-[1,OB]|-[2,OB*2]|-[3,OB*3]|-[4,OB*4]
-     lenheadlist=lenheadalts+1
-
-     lenheaddata=[0,0,0,1,:foo,4,:foo,:bar,:baz,:zork,3,:k,77,88]
-     lenheaddataj=lenheaddata+[:j]
-
-     lentailalts=-[OB,-1]|-[OB*2,-2]|-[OB*3,-3]|-[OB*4,-4]
-     lentaildata=lenheaddata.reverse.map {|x| Integer===x ? -x : x }
-     infixalts=-[OB,"infix1",OB]|-[OB*2,'infix2',OB*2]|
-               -[OB*3,'infix3',OB*3]|-[OB*4,'infix4',OB*4]
-
-
-     qq=-[:q, ~(:q.reg)+0, :q]
-     _QQ=-[:Q, ( ~/^[Q\\]$/.sym | -[:'\\',OB] )+0, :Q]
-
-
-     be=-[:begin, (
-           ~/^(begin|end|\\)$/.sym |
-           -[:'\\',OB] |
-           innerbe=Reg.const
-         )+0, :end]
-     innerbe.set! be
-
-     lh_or_qq=lenheadalts|qq|_QQ
-     lhqqbe=lh_or_qq|be
-
-
-     #most of the examples use the longer, tla form for the outermost reg....
-     #dunno why any more. anyway, here are the basic equivalences between the
-     #operator, tla, and long forms or Reg. 
-     #operator form
-     assert_eee Reg::Array, +[]
-     assert_eee Reg::Subseq, -[]
-     assert_eee Reg::Hash, +{}
-     assert_eee Reg::Object, -{}
-
-     #tla form (square and round brackets)
-     assert_eee Reg::Array, Reg[]
-     assert_eee Reg::Subseq, Res[]
-     assert_eee Reg::Hash, Rah[]
-     assert_eee Reg::Object, Rob[]
-
-     assert_eee Reg::Array, Reg()
-     assert_eee Reg::Subseq, Res()
-     assert_eee Reg::Hash, Rah()
-     assert_eee Reg::Object, Rob()
-
-
-
-
-     assert_eee(  +[qq*1], [:q,:q]  )
-     assert_eee(  +[qq+0], [:q,:q]  )
-
-     assert_eee(  +_QQ, [:Q,:Q]  )
-     assert_eee(  +[_QQ], [:Q,:Q]  )
-     assert_eee(  +[_QQ*1], [:Q,:Q]  )
-     assert_eee(  +[_QQ+0], [:Q,:Q]  )
-
-     assert_eee(  +[be*1], [:begin,:end]  )
-     assert_eee(  +[be+0], [:begin,:end]  )
-
-
-     assert_eee(  +[], []  )
-     assert_ene(  +[], [1]  )
-     assert_eee(  +[-[]], []  )
-     assert_ene(  +[-[]], [1]  )
-     
-
-     assert_ene Reg[-[:foo,:bar]-1], [:bar,:foo]
-     assert_ene Reg[-[:foo,:bar]-1], [:baz,:foo,:bar]
-     assert_ene Reg[-[:foo,:bar]-1], [:foo,:bar,:baz]
-     assert_eee Reg[-[:foo,:bar]-1], [:foo,:bar]
-     assert_ene Reg[-[:foo,:bar]-1], [:foo]
-     assert_ene Reg[-[:foo,:bar]-1], [:bar]
-     assert_ene Reg[-[:foo,:bar]-1], [:baz]
-     assert_eee Reg[-[:foo,:bar]-1], []
-
-
-
-     assert_eee Reg[OB.+], [1]
-     assert_eee Reg[OB.+], [1,2,3]
-     assert_eee Reg[OB.-], [1]
-     assert_ene Reg[OB.-], [1,2,3]
-     assert_ene Reg[:a, OB-1, :b, :b, :b, :b, :b], [:a, 1,1,1,1,1,1, :b, :b, :b, :b, :b]
-     assert_eee Reg[:a, OB-1, :b, :b, :b, :b, :b], [:a, 1, :b, :b, :b, :b, :b]
-     assert_eee Reg[:a, OB-1, :b, :b, :b, :b, :b], [:a, :b, :b, :b, :b, :b]
-     assert_ene Reg[:a, OB-1, :b, :b, :b, :b, :b], [1, :b, :b, :b, :b, :b]
-     assert_ene Reg[:a, OB-1, :b, :b, :b, :b, :b], [:b, :b, :b, :b, :b]
-     assert_ene Reg[:a, OB-1, :b, :b, :b, :b, :b], [:a, 1, :b, :b, :b, :b]
-     assert_ene Reg[:a, OB-1, :b, :b, :b, :b, :b], [:a, :b, :b, :b, :b]
-
-
-
-if defined? NextMatchTests
-     a=[:foo]
-     x=(:foo.reg-1).mmatch a,0
-     assert x.next_match(a,0)==[[[:foo]],1]
-     assert x.next_match(a,0)==[[[]],0]
-     assert x.next_match(a,0)==nil
-     x=(:foo.reg-1).mmatch a,1
-     assert x==[[[]],0]
-
-     a=[:foo]
-     x=(:foo.reg-1-1).mmatch a,0
-     assert x.next_match(a,0)==[[[[:foo]]],1]
-     assert x.next_match(a,0)==[[[]],0]
-     assert x.next_match(a,0)==nil
-
-
-   
-
-
- 
-     a=(1..5).to_a
-     r=OB+1+3
-     x=r.mmatch a,0
-     assert x.next_match(a,0)==[[ [[1, 2, 3]], [[4]], [[5]] ], 5]
-     assert x.next_match(a,0)==[[ [[1, 2]], [[3, 4]], [[5]] ], 5]
-     assert x.next_match(a,0)==[[ [[1, 2]], [[3]], [[4, 5]] ], 5]
-     assert x.next_match(a,0)==[[ [[1, 2]], [[3]], [[4]], [[5]] ], 5]
-     assert x.next_match(a,0)==[[ [[1, 2]], [[3]], [[4]] ], 4]
-     assert x.next_match(a,0)==[[ [[1]], [[2, 3, 4]], [[5]] ], 5]
-     assert x.next_match(a,0)==[[ [[1]], [[2, 3]], [[4, 5]] ], 5]
-     assert x.next_match(a,0)==[[ [[1]], [[2, 3]], [[4]], [[5]] ], 5]
-     assert x.next_match(a,0)==[[ [[1]], [[2, 3]], [[4]] ], 4]
-     assert x.next_match(a,0)==[[ [[1]], [[2]], [[3, 4, 5]] ], 5]
-     assert x.next_match(a,0)==[[ [[1]], [[2]], [[3, 4]], [[5]] ], 5]
-     assert x.next_match(a,0)==[[ [[1]], [[2]], [[3, 4]] ], 4]
-     assert x.next_match(a,0)==[[ [[1]], [[2]], [[3]], [[4, 5]] ], 5]
-     assert x.next_match(a,0)==[[ [[1]], [[2]], [[3]], [[4]], [[5]] ], 5]
-     assert x.next_match(a,0)==[[ [[1]], [[2]], [[3]], [[4]] ], 4]
-     assert x.next_match(a,0)==[[ [[1]], [[2]], [[3]]], 3]
-     assert x.next_match(a,0)==nil
-
-end
-
-
-     assert_ene Reg[OB+1+2+2], [:f]*3
-     assert_ene Reg[OB+2+1+2], [:f]*3
-     assert_eee Reg[OB+1+2+2], [:f]*4
-     assert_eee Reg[OB+2+2+1], [:f]*4
-     assert_eee Reg[OB+2+1+2], [:f]*4
-     assert_ene Reg[OB+2+2+2], [:f]*7
-     assert_eee Reg[OB+2+2+2], [:f]*8
-
-
-
-
-     assert_ene Reg[OB+2+2+3], [:f]*11
-     assert_eee Reg[OB+2+2+3], [:f]*12
-     assert_eee Reg[OB+2+2+3], [:f]*16
-
-     assert_ene Reg[5.reg+1+3+2], [6]+[5]*5
-     assert_ene Reg[5.reg+1+3+2], [5]+[6]+[5]*4
-     assert_ene Reg[5.reg+1+3+2], [5]*2+[6]+[5]*3
-     assert_ene Reg[5.reg+1+3+2], [5]*3+[6]+[5]*2
-     assert_ene Reg[5.reg+1+3+2], [5]*4+[6,5]
-     assert_ene Reg[5.reg+1+3+2], [5]*5+[6]
-
-     assert_eee Reg[OB+1+3+2], [6]+[5]*5
-     assert_eee Reg[OB+1+3+2], [5]+[6]+[5]*4
-     assert_eee Reg[OB+1+3+2], [5]*2+[6]+[5]*3
-     assert_eee Reg[OB+1+3+2], [5]*3+[6]+[5]*2
-     assert_eee Reg[OB+1+3+2], [5]*4+[6,5]
-     assert_eee Reg[OB+1+3+2], [5]*5+[6]
-
-     assert_ene Reg[OB+1+3+2], [6]+[5]*4
-     assert_ene Reg[OB+1+3+2], [5]+[6]+[5]*3
-     assert_ene Reg[OB+1+3+2], [5]*2+[6]+[5]*2
-     assert_ene Reg[OB+1+3+2], [5]*3+[6]+[5]
-     assert_ene Reg[OB+1+3+2], [5]*4+[6]
-
-
-     assert_eee Reg[5.reg+1+3+2], [5]*6
-     assert_ene Reg[5.reg+2+2+2], [5]*8+[6]
-     assert_ene Reg[:foo.reg*(1..2)*(2..3)*(2..3)], [:foo]*3
-
-     assert_eee Reg[:foo.reg*(1..2)*(2..3)*(2..3)], [:foo]*4
-     assert_ene Reg[OB*(1..2)*(2..3)*(2..3)], [:foo]*3
-     assert_eee Reg[OB*(1..2)*(2..3)*(2..3)], [:foo]*4
-     assert_ene Reg[OB*(1..2)*(2..3)+2], [:foo]*3
-     assert_eee Reg[OB*(1..2)*(2..3)+2], [:foo]*4
-     assert_ene Reg[OB+1+2+2], [:foo]*3
-     assert_eee Reg[OB+1+2+2], [:foo]*4
-
-     assert_eee Reg[OB*(1..3)*(2..3)*2], [:foo]*4
-
-
-if defined? NextMatchTests
-
-     a=[:foo]*6
-     x=(OB*2*(1..2)*2).mmatch(a,0)
-     assert x.next_match(a,0)==
-       [[ [[[:foo, :foo]], [[:foo, :foo]]], [[[:foo, :foo]]] ], 6]
-     assert x.next_match(a,0)==
-       [[ [[[:foo, :foo]]], [[[:foo, :foo]], [[:foo, :foo]]] ], 6]
-     assert x.next_match(a,0)==
-       [[ [[[:foo, :foo]]], [[[:foo, :foo]]] ], 4]
-     assert x.next_match(a,0).nil?
-end
-
-#$RegTraceEnable=true
-     assert_eee Reg[OB*2*(1..2)*2], [:foo]*6
-     assert_eee Reg[OB*2*(1..2)*2,OB,OB], [:foo]*6
-     assert_eee Reg[OB*2*(1..2)*2,OB*2], [:foo]*6
-     assert_eee Reg[OB*2*(1..2)*2,OB+2], [:foo]*6
-     assert_eee Reg[OB*2*(1..2)*2, OB-1], [:foo]*6
-     assert_eee Reg[OB*2*(1..2)*2, OB-1], [:foo]*7
-     assert_eee Reg[OB*2*(1..2)*2], [:foo]*8
-     assert_eee Reg[OB*2*(1..2)*2], [:foo]*4
-     assert_eee Reg[OB*(2..3)*(1..2)*2], [:foo]*4
-     assert_eee Reg[OB*(2..3)*(2..3)*(1..2)], [:foo]*4
-     assert_eee Reg[OB*(2..2)*(2..3)*(2..3)], [:foo]*8
-     assert_eee Reg[OB*(2..3)*(2..2)*(2..3)], [:foo]*8
-
-     assert_eee Reg[OB*(2..3)*(2..3)*2], [:foo]*8
-     assert_eee Reg[OB*(2..3)*(2..3)*(2..3)], [:foo]*8
-     assert_ene Reg[:foo.reg*(2..3)*(2..3)*2], [:foo]*7
-
-if defined? NextMatchTests
-     assert(!(Reg[OB*1*(1..2)]===[:f]).first.empty?)
-
-
-     a=[:foo]*4
-     x=(OB*(1..2)+2).mmatch(a,0)
-     assert x.next_match(a,0)==[[ [[:foo, :foo]], [[:foo, :foo]] ], 4]
-     assert x.next_match(a,0)==[[ [[:foo, :foo]], [[:foo]], [[:foo]] ], 4]
-     assert x.next_match(a,0)==[[ [[:foo, :foo]], [[:foo]] ], 3]
-     assert x.next_match(a,0)==[[ [[:foo]], [[:foo, :foo]], [[:foo]] ], 4]
-     assert x.next_match(a,0)==[[ [[:foo]], [[:foo, :foo]] ], 3]
-     assert x.next_match(a,0)==[[ [[:foo]], [[:foo]], [[:foo, :foo]] ], 4]
-     assert x.next_match(a,0)==[[ [[:foo]], [[:foo]], [[:foo]], [[:foo]] ], 4]
-     assert x.next_match(a,0)==[[ [[:foo]], [[:foo]], [[:foo]] ], 3]
-     assert x.next_match(a,0)==[[ [[:foo]], [[:foo]] ], 2]
-     assert x.next_match(a,0)==nil
-end
-     assert_ene Reg[OB*(1..2)+2+2], [:foo]*3
-     assert_eee Reg[OB*(1..2)+2+2], [:foo]*4
-
-if defined? NextMatchTests
-
-     a=(1..9).to_a
-     x=(OB+2+2+2).mmatch a,0
-     assert x.next_match(a,0)===[[ [[[1, 2, 3]], [[4, 5]]], [[[6, 7]], [[8, 9]]] ], 9]
-     assert x.next_match(a,0)===[[ [[[1, 2]], [[3, 4, 5]]], [[[6, 7]], [[8, 9]]] ], 9]
-     assert x.next_match(a,0)===[[ [[[1, 2]], [[3, 4]]], [[[5, 6, 7]], [[8, 9]]] ], 9]
-     assert x.next_match(a,0)===[[ [[[1, 2]], [[3, 4]]], [[[5, 6]], [[7, 8, 9]]] ], 9]
-     assert x.next_match(a,0)===[[ [[[1, 2]], [[3, 4]]], [[[5, 6]], [[7, 8]]]    ], 8]
-     assert x.next_match(a,0)===nil
-end
-
-     assert_eee Reg[OB+2+2+2], [:foo]*8
-     assert_eee Reg[OB+2+2+2, OB], [:foo]*9
-     assert_eee Reg[OB+2+2+2, OB+1], [:foo]*9
-     assert_eee Reg[OB+2+2+2, OB-1], [:foo]*9
-     assert_eee Reg[OB+2+2+2], [:foo]*9
-
-if defined? NextMatchTests
-     a=[:foo]*4
-     x=(OB*2*(1..2)).mmatch(a,2)
-     assert x.next_match(a,2)==[[[[:foo, :foo]]], 2]
-     assert x.next_match(a,2)==nil
-end
-
-     assert_eee( +[OB*(1..2)*2],[:foo]*2)
-
-if defined? NextMatchTests
-     a=[:foo]*3
-     x=(OB*(1..2)*2).mmatch(a,0)
-     assert x.next_match(a,0)==
-       [[ [[:foo, :foo]], [[:foo]] ], 3]
-     assert x.next_match(a,0)==
-       [[ [[:foo]], [[:foo, :foo]] ], 3]
-     assert x.next_match(a,0)==
-       [[ [[:foo]], [[:foo]] ], 2]
-     assert x.next_match(a,0).nil?
-end
-
-     assert_ene Reg[OB*(2..2)*(2..3)*(2..3)], [:foo]*7
-     assert_ene Reg[OB*(2..3)*(2..2)*(2..3)], [:foo]*7
-     assert_ene Reg[OB*(1..3)*(2..3)*2], [:foo]*3
-     assert_ene Reg[OB*(2..3)*(1..3)*2], [:foo]*3
-     assert_ene Reg[OB*(2..3)*(2..3)*(1..2)], [:foo]*3
-
-     assert_ene Reg[OB*(2..3)*(2..3)*2], [:foo]*7
-     assert_ene Reg[OB*(2..3)*(2..3)*(2..3)], [:foo]*7
-     assert_ene Reg[OB+2+2+2], [:foo]*7
-
-
-     assert_eee Reg[OB*2*1*2], [:foo]*4
-     assert_eee Reg[OB*1*(1..2)*2], [:foo]*2
-     assert_eee Reg[OB*2*(1..2)*1], [:foo]*2
-     assert_eee Reg[OB*1*(1..2)*2], [:foo]*3
-     assert_ene Reg[OB*2*(1..2)*1], [:foo]*3
-     assert_eee Reg[OB*1*(1..2)*2], [:foo]*4
-     assert_eee Reg[OB*2*(1..2)*1], [:foo]*4
-
-
-if defined? NextMatchTests
-
-     a=[:foo]*3
-     x=(:foo.reg*(1..2)).mmatch a,0
-     assert x.next_match(a,0)==[[[:foo]*2],2]
-     assert x.next_match(a,0)==[[[:foo]],1]
-     assert x.next_match(a,0)==nil
-
-     x=(:foo.reg*(1..2)).mmatch a,1
-     assert x.next_match(a,0)==[[[:foo]*2],2]
-     assert x.next_match(a,0)==[[[:foo]],1]
-     assert x.next_match(a,0)==nil
-
-     x=(:foo.reg*(1..2)).mmatch a,2
-     assert x==[[[:foo]],1]
-
-     x=(:foo.reg*(1..2)).mmatch a,3
-     assert x.nil?
-
-     x=(:foo.reg*(1..2)*(2..3)).mmatch a,0
-     assert x.next_match(a,0)==[[[[:foo]*2],[[:foo]]], 3]
-     assert x.instance_eval{@ri}==2
-     assert x.next_match(a,0)==[[[[:foo]],[[:foo]*2]], 3]
-     assert x.instance_eval{@ri}==2
-     assert x.next_match(a,0)==[[[[:foo]],[[:foo]],[[:foo]]], 3]
-     assert x.instance_eval{@ri}==3
-     assert x.next_match(a,0)==[[[[:foo]],[[:foo]]], 2]
-     assert x.instance_eval{@ri}==2
-     assert x.next_match(a,0)==nil
-
-     x=(:foo.reg*(1..2)*(2..3)).mmatch a,1
-     assert x.next_match(a,0)==[[[[:foo]],[[:foo]]], 2]
-     assert x.instance_eval{@ri}==2
-     assert x.next_match(a,0)==nil
-
-     x=(:foo.reg*(1..2)*(2..3)).mmatch a,2
-     assert x.nil?
-
-     x=(:foo.reg*(1..2)*(2..3)).mmatch a,3
-     assert x.nil?
-end
-
-     assert((not (:foo.reg*(1..2)*(2..3)*(2..3)).mmatch [:foo]*3,0 ))
-
-
-
-
-     assert_eee Reg[5.reg+2+2], [5]*4
-     assert_eee Reg[5.reg*(1..2)*(1..2)*(1..2)], [5]
-     assert_eee Reg[5.reg*(1..2)*(1..2)*(2..3)], [5]*2
-     assert_eee Reg[5.reg*(1..2)*(2..3)*(2..3)], [5]*4
-     assert_eee Reg[(5.reg+1)*(2..3)*(2..3)], [5]*4
-     assert_eee Reg[(5.reg+1+2)*(2..3)], [5]*4
-     assert_eee Reg[5.reg+1+2+2], [5]*4
-     assert_eee Reg[OB+3+2], [:f]*6
-
-     aaa_patho=-[/^a/]|-[/^.a/, OB]|-[/^..a/, OB*2]
-     assert_ene(  +[aaa_patho], ["aaa"]*200  )
-     assert_eee(  +[aaa_patho+0], ["aaa"]*200  )
-
-
-
-
-     assert_eee Reg[(-[-[:p]*(1..2)])], [:p]
-     assert_eee Reg[(-[-[:p]*(1..2)])], [:p,:p]
-     assert_ene Reg[(-[-[:p]*(1..2)])], [:p,:q]
-     assert_ene Reg[(-[-[:p]*(1..2)])], [:q]
-     assert_ene Reg[(-[-[:p]*(1..2)])], []
-     assert_ene Reg[(-[-[:p]*(1..2)])], [:p,:p, :p]
-
-
-     assert_eee Reg[OB+1], [:foo,:foo]
-     assert_eee Reg[OB+1+1], [:foo,:foo]
-     assert_eee Reg[OB+1+1+1], [:foo,:foo]
-     assert_eee Reg[OB+1+1+1+1], [:foo,:foo]
-
-     assert_ene Reg[OB+2+3], [:f]*5
-     assert_ene Reg[OB+2+2+1], [:f]*3
-
-     assert_eee(+[be], [
-                          :begin, :SubseqMatchSet, :IndexError, :termsig, :"\\", :ll,
-                          :end]
-     )
-     assert_eee(+[be+0], [
-                          :begin, :SubseqMatchSet, :IndexError, :termsig, :"\\", :begin,
-                          :end]
-     )
-     assert_eee(+[be+0], [
-                          :begin, :SubseqMatchSet, :IndexError, :termsig, :"\\", :end,
-                          :end]
-     )
-     assert_eee(+[be+0], [
-                          :begin, :SubseqMatchSet, :IndexError, :termsig, :"\\", 
-                            :begin, :right, :"\\", 
-                              :begin, :f, :call, :safe_level, :"\\", 
-                                :begin, :undefine_finalizer, :test_anonymous, :quote, 
-                          :end]
-     )
-     assert_eee(+[lhqqbe+0], [
-                          :begin, :SubseqMatchSet, :IndexError, :termsig, :"\\", 
-                            :begin, :right, :"\\", 
-                              :begin, :f, :call, :safe_level, :"\\", 
-                                :begin, :undefine_finalizer, :test_anonymous, :quote, 
-                          :end]
-     )
-
-     assert_eee Reg[lhqqbe+0], [
-      :begin, :popen, :"chomp!", :-@, :end, :q, :q,
-      :begin, :begin, :end, :end,
-      :begin, :MINOR_VERSION, :"public_method_defined?", :"\\", :begin, :umask,
-              :debug_print_help, :geteuid, :end,
-      :q, :public_methods, :option_name, :MUTEX, :q,
-      :begin, :verbose=, :binding, :symlink, :lambda,
-              :emacs_editing_mode, :"dst?", :end, 0,
-      :begin, :test_to_s_with_iv, :"\\", :begin, :glob, :each_with_index,
-              :initialize_copy, :begin, :$PROGRAM_NAME, :end,
-              :ELIBACC, :setruid, :"success?", :end,
-      :begin, :__size__, :width, :"\\", :begin, :$-a, :"sort!", :waitpid, :end,
-      :begin, :Stat, :WadlerExample, :chr, :end,
-      :begin, :+, :disable, :abstract,
-              :begin, :__size__, :"symlink?", :"dst?", :end, :ljust, :end,
-      :begin, :debug_method_info, :matchary, :"\\", :begin, :ftype,
-              :thread_list_all, :eof, :begin, :abs, :GroupQueue, :end,
-              :"slice!", :ordering=, :end,
-      :Q, :"\\", :Q, :ELIBMAX, :GetoptLong, :nlink, :Q,
-      :begin, :Fixnum, :waitall, :"enclosed?", :"\\", :begin, :deep_copy,
-              :getpgid, :strftime, :end,
-      :Q, :close_obj, :Q,
-      3, :basic_quote_characters=, :rmdir, :"writable_real?",
-      :begin, :test_hello_11_12, :utc_offset, :freeze,
-              :begin, :kcode, :egid=, :ARGF, :end,
-              :setuid, :lock, :gmtoff, :end,
-      :begin, :$FILENAME, :test_tree_alt_20_49,
-              :begin, :LOCK_SH, :EL3HLT, :end, :end,
-      :Q, :"\\", :Q, :ceil, :remainder, :group_sub, :Q, 0
-     ]
-
-if $Slow ||=false
-     #btracing monsters
-     assert_ene Reg[OB+1+3+2], (1..5).to_a
-     0.upto(5) {|i| assert_ene Reg[OB+1+3+2], [:f]*i }
-     6.upto(16){|i| assert_eee Reg[OB+1+3+2], [:f]*i }
-
-     assert_ene Reg[OB+2+3+2], [:f]*11
-     assert_eee Reg[OB+2+3+2], [:f]*12
-     assert_ene Reg[OB+2+3+3], [:f]*17
-     assert_eee Reg[OB+2+3+3], [:f]*18
-     assert_ene Reg[OB+3+3+3], [:f]*26
-     assert_eee Reg[OB+3+3+3], [:f]*27
-#     assert_ene Reg[OB+4+4+4], [:f]*63 #insane
-#     assert_eee Reg[OB+4+4+4], [:f]*64 #insane
-     assert_ene Reg[OB+2+2+2+2], [:f]*15 
-     assert_eee Reg[OB+2+2+2+2], [:f]*16
-#     assert_ene Reg[OB+2+2+2+2+2+2+2+2], [:foo]*255 #insane
-#     assert_eee Reg[OB+2+2+2+2+2+2+2+2], [:foo]*256 #insane
-
-
-     #assert_eee Reg[OB+10+10], [:f]*100 #waaaay too slow
-     assert_eee Reg[OB+5+5], [:f]*25
-     assert_ene Reg[OB+5+5], [:f]*24
-     assert_eee Reg[OB+6+6], [:f]*36
-     assert_ene Reg[OB+6+6], [:f]*35
-     assert_eee Reg[OB+7+7], [:f]*49 #prolly excessive
-     assert_ene Reg[OB+7+7], [:f]*48 #prolly excessive
-
-     assert_ene Reg[OB+1+2+2+2], [:f]*7
-     assert_eee Reg[OB+1+2+2+2], [:f]*8
-     assert_ene Reg[OB+1+1+2+2+2], [:f]*7
-     assert_eee Reg[OB+1+1+2+2+2], [:f]*8
-     assert_ene Reg[OB+1+1+1+2+2+2], [:f]*7
-     assert_eee Reg[OB+1+1+1+2+2+2], [:f]*8
-
-     assert_ene Reg[OB+1+1+1+1+2+2+2], [:f]*7
-     assert_eee Reg[OB+1+1+1+1+2+2+2], [:f]*8
-
-     r=2..3
-     assert_ene Reg[OB*(1..2)*r*r*r], [:f]*7
-     assert_eee Reg[OB*(1..2)*r*r*r], [:f]*8
-end
-
-     assert_eee Reg[lhqqbe+0], [ :begin, :"\\", :rand, :end ]
- #breakpoint
-     assert_eee( +[be], [:begin, :"\\", :"\\", :end])
-     assert_eee( +[be], [:begin, :"\\", :begin, :end])
-     assert_eee( +[be], [:begin, :"\\", :end, :end])
-     assert_eee( +[be], [:begin, :log, :readline, :"\\", :begin, :lh_or_qq, :test_pretty_print_inspect, :@newline, :end])
-     assert_eee( +[be], [:begin, :lock, :rindex, :begin, :sysopen, :rename, :end, :re_exchange, :on, :end])
-     assert_eee( +[be], [:begin, :lock, :"\\", :"\\", :begin, :rename, :end, :on, :end])
-     assert_eee( +[be], [:begin, :begin, :foo, :end, :end])
-     assert_eee( +[be], makelendata(1,0b11110000000).flatten)
-     assert_eee( +[be], [:begin, :end])
-     assert_eee( +[be], [:begin, :foo, :end])
-     assert_eee( +[be], makelendata(1,0b10000000).flatten)
-     assert_eee Reg[lhqqbe+0], makelendata(1,0b11111110011).flatten
-     assert_eee Reg[lhqqbe+0], makelendata(4,0b11111110011).flatten
-     assert_eee Reg[lhqqbe+0], makelendata(10,0b11111110011).flatten
-     assert_eee Reg[lhqqbe+0], makelendata(20,0b11111110011).flatten
-
-     assert_ene Reg[:foo,OB+1], [:foo]
-     assert_ene Reg[OB+1,:foo], [:foo]
-     assert_eee Reg[OB+1], [:foo]
-
-
-     assert_eee Reg[OB+1+1+1+1+1+1+1+1+1+1+1+1+1+1], [:foo]
-
-     assert_ene Reg[OB+1+1+1+1], []
-     assert_eee Reg[OB+1+1+1+1], [:foo,:foo]
-     assert_ene Reg[OB+2], [:foo]
-     assert_ene Reg[OB+2+2], [:foo]*3
-     assert_ene Reg[OB+2+2+1], [:foo]*3
-     assert_ene Reg[OB+2+1+2], [:foo]*3
-
-
-     assert_eee Reg[-[1,2]|3], [1,2]
-     assert_eee Reg[-[1,2]|3], [3]
-     assert_ene Reg[-[1,2]|3], [4]
-     assert_ene Reg[-[1,2]|3], [2]
-     assert_ene Reg[-[1,2]|3], [1,3]
-
-     assert_eee Reg[lenheadlist], [1, :__id__]
-     assert_eee Reg[(-[0]|-[1,OB]|-[2,OB*2])*1], [2, :p, :stat]
-     assert_eee Reg[(-[2,OB*2])-1], [2, :p, :stat]
-     assert_eee Reg[(-[OB])*(1..2)], [1, :p]
-
-     assert_eee Reg[(-[-[:p]*(1..2)])], [:p]
-     assert_eee Reg[(-[-[:p]])*(1..2)], [:p]
-     assert_eee Reg[(-[-[OB]])*(1..2)], [:p]
-     assert_eee Reg[(-[OB*1])*(1..2)], [:p]
-     assert_eee Reg[(-[1,OB*1])*(1..2)], [1, :p]
-     assert_eee Reg[(-[2,OB*2])*(1..2)], [2, :p, :stat]
-     assert_eee Reg[(-[0]|-[1,OB]|-[2,OB*2])*(1..2)], [2, :p, :stat]
-     assert_eee Reg[(-[0]|-[1,OB]|-[2,OB*2])+1], [2, :p, :stat]
-     assert_eee Reg[lenheadlist], [2, :p, :stat]
-     assert_eee Reg[lenheadlist], [2, :p, :stat, 1, :__id__]
-     assert_eee Reg[lenheadlist], [2, :p, :stat, 0, 1, :__id__, 0, 0]
-     assert_eee Reg[lenheadlist], lenheaddata
-     assert_ene Reg[lenheadlist], lenheaddataj
-     assert_eee( +[lh_or_qq+0], lenheaddata )
-     assert_eee( +[lh_or_qq+0], lenheaddata+[:q, :foo, :bar, :baz, :q] )
-
-     assert_eee Reg[lenheadlist], [0]
-     assert_eee Reg[lenheadlist], makelendata(1,0b11).flatten
-     assert_eee Reg[lenheadlist], makelendata(5,0b11).flatten
-     assert_eee Reg[lenheadlist], makelendata(10,0b11).flatten
-     assert_eee Reg[lenheadlist], makelendata(20,0b11).flatten
-     assert_ene Reg[lenheadlist], makelendata(20,0b11).flatten+[:j]
-     assert_ene Reg[lenheadlist], [:j]+makelendata(20,0b11).flatten+[:j]
-     assert_ene Reg[lenheadlist], [:j]+makelendata(20,0b11).flatten
-
-     assert_ene Reg[lenheadlist], makelendata(20,0b11,:j).flatten
-     assert_eee( +[lh_or_qq+0], makelendata(20,0b11).flatten )
-     assert_eee( +[lh_or_qq+0], makelendata(20,0b1000011).flatten )
-     assert_ene( +[lh_or_qq+0], makelendata(20,0b1000011).flatten+[:j] )
-     assert_ene( +[lh_or_qq+0], [:j]+makelendata(20,0b1000011).flatten+[:j] )
-     assert_ene( +[lh_or_qq+0], [:j]+makelendata(20,0b1000011).flatten )
-
-
-
-     t=(1..2)
-     assert_eee Reg[OB*t*t*t*t], [:foo]*16
-     assert_ene Reg[OB*t*t*t*t], [:foo]*17
-     assert_eee Reg[5.reg*t], [5]
-     assert_eee Reg[5.reg*t*1], [5]
-     assert_eee Reg[5.reg*1*t], [5]
-     assert_eee Reg[5.reg*t*t], [5]
-     assert_eee Reg[5.reg*t*t*t], [5]
-     assert_eee Reg[5.reg*t*t*t*t], [5]
-     assert_eee Reg[5.reg+1+1+1], [5]
-     assert_eee Reg[5.reg+1+1+1+1], [5]
-     assert_eee Reg[OB+1+1+1], [:foo]
-     assert_eee Reg[OB+1+1+1+1], [:foo]
-     assert_eee Reg[OB+2], [:foo]*2
-     assert_eee Reg[OB+2+2], [:foo]*4
-
-
-
-     #btracing monsters:
-     assert_eee Reg[OB*2], [:foo]*2
-     assert_eee Reg[OB*2*2], [:foo]*4
-     assert_eee Reg[OB*2*2*2*2], [:foo]*16
-     assert_eee Reg[OB*2*2*2*2*2*2*2*2], [:foo]*256
-     assert_eee Reg[OB-2-2-2-2-2-2-2-2], [:foo]*256
-
-
-
-     assert_ene Reg[OB-0], [1]
-     assert_eee Reg[OB+0], [1]
-     assert_eee Reg[OB-1], [1]
-     assert_eee Reg[OB+1], [1]
-     assert_eee Reg[OB-2], [1,2]
-     assert_eee Reg[OB+2], [1,2]
-
-     assert_eee Reg[OB], [1]
-     assert_eee Reg[OB*1], [1]
-     assert_eee Reg[OB*2], [1,2]
-     assert_eee Reg[OB*4], [1,2,3,4]
-
-     abcreg=Reg[OBS,:a,:b,:c,OBS]
-     assert_eee abcreg, [:a,:b,:c,7,8,9]
-     assert_eee abcreg, [1,2,3,:a,:b,:c,7,8,9]
-
-     assert_eee abcreg, [1,2,3,:a,:b,:c]
-     assert_eee abcreg, [:a,:b,:c]
-
-     assert_ene abcreg, [1,2,3,:a,:b,:d]
-     assert_ene abcreg, [1,2,3,:a,:d,:c]
-     assert_ene abcreg, [1,2,3,:d,:b,:c]
-
-     assert_ene abcreg, [1,2,3]
-     assert_ene abcreg, [1,2,3,:a]
-     assert_ene abcreg, [1,2,3,:a,:b]
-
-     assert_eee Reg[:a, OB+0, :b, :b, :b, :b, :b], [:a, 1,1,1,1,1,1, :b, :b, :b, :b, :b]
-     assert_eee Reg[:a, OB+0, :b, :b, :b, :b, :b], [:a, 1, :b, :b, :b, :b, :b]
-     assert_eee Reg[:a, OB+0, :b, :b, :b, :b, :b], [:a, :b, :b, :b, :b, :b]
-
-     assert_eee Reg[:a, OB+1, :b, :b, :b, :b, :b], [:a, 1,1,1,1,1,1, :b, :b, :b, :b, :b]
-     assert_eee Reg[:a, OB+1, :b, :b, :b, :b, :b], [:a, 1, :b, :b, :b, :b, :b]
-     assert_ene Reg[:a, OB+1, :b, :b, :b, :b, :b], [:a, :b, :b, :b, :b, :b]
-
-     assert_ene Reg[:a, OB-0, :b, :b, :b, :b, :b], [:a, 1,1,1,1,1,1, :b, :b, :b, :b, :b]
-     assert_ene Reg[:a, OB-0, :b, :b, :b, :b, :b], [:a, 1, :b, :b, :b, :b, :b]
-     assert_eee Reg[:a, OB-0, :b, :b, :b, :b, :b], [:a, :b, :b, :b, :b, :b]
-
-     assert_eee Reg[-[OB*2]], [99, 99]  #di not right in top level
-     assert_eee Reg[-[-[-[-[-[OB*2]]]]]], [99, 99]  #di not right in top level?
-     assert_eee Reg[-[-[-[-[-[OB*1]]]]]], [99]  #di not right in top level?
-     #RR[RR[[RR[RR[RR[RR[99,99]]]]]]]
-     assert_eee Reg[OB*1], [:foo]
-     assert_eee Reg[-[OB]], [88]
-     assert_ene Reg[-[0]], [88]
-     assert_eee Reg[-[0]], [0]
-     assert_eee Reg[-[OB*1]], [:foo]
-     assert_eee Reg[OB*1*1], [:foo]
-     assert_eee Reg[OB*1*1*1*1*1*1*1*1*1*1*1*1*1*1], [:foo]
-     assert_eee Reg[OB-1-1-1-1-1-1-1-1-1-1-1-1-1-1], [:foo]
-     assert_eee Reg[-[2,OB*2]], [2, 99, 99]
-
-     assert_eee Reg::Multiple, -[0]|-[1,2]
-     assert( (-[0]|-[1,2]).respond_to?( :mmatch))
-
-     assert_eee Reg[-[0],OBS], lenheaddataj
-     assert_eee Reg[-[0]|-[1,OB],OBS], lenheaddataj
-     assert_eee Reg[-[0]|-[1,OB]|-[2,OB*2],OBS], lenheaddataj
-     assert_eee Reg[-[0]|-[1,OB]|-[2,OB*2]|-[3,OB*3],OBS], lenheaddataj
-     assert_eee Reg[-[0]|-[1,OB]|-[2,OB*2]|-[3,OB*3]|-[4,OB*4],OBS], lenheaddataj
-
-
-
-     test_hash_matcher Rah(:a=>:b), :matches=>[{:a=>:b}],
-       :unmatches=>[ {:a=>:c}, {} ] #=> false
-
-     h={}
-     h.default=:b
-     test_hash_matcher Rah(:a=>:b), :matches=>h, :unmatches=>{}
-
-     test_hash_matcher Rah(/^(a|b)$/=>33), 
-       :matches=>[{"a"=>33}, {"b"=>33}, {"a"=>33,"b"=>33} ],
-       :unmatches=>[
-         {"a"=>33,"c"=>33},
-         {"b"=>33,"c"=>33}, {"a"=>33,"c"=>133}, {"b"=>33,"c"=>133}, {"a"=>133}, {"b"=>133} ,
-         {"c"=>33}, {"c"=>133}  , {"a"=>33,"b"=>133}, {"a"=>133,"b"=>33}, {"a"=>133,"b"=>133}  
-       ]
-
-=begin disabled.... Reg::Hash#|(Hash) not special anymore
-     assert_eee Rah("a"=>33)|{"b"=>33}, {"a"=>33,"b"=>33}  #=> true
-     assert_eee Rah("a"=>33)|{"b"=>33}, {"a"=>33,"b"=>133}  #=> true
-     assert_ene Rah("a"=>33)|{"b"=>33}, {"a"=>133,"b"=>33}  #=> false
-     assert_ene Rah("a"=>33)|{"b"=>33}, {"a"=>133,"b"=>133}  #=> false
-
-     assert_eee Rah("a"=>33)|{"b"=>33}, {"b"=>33}  #=> true
-=end
-     test_hash_matcher Rah(:a.reg|:b => 44), :matches=>[{:a => 44},{:b => 44}],
-       :unmatches=> [{:a => 144}, {:b => 144}]
-
-     #object matcher tests
-     ob=AnyStruct[:aa=>1,:b=>"foob",:c=>[1,2,3]]
-     assert_eee Rob(:aa=>1), ob
-     assert_eee Rob(:@aa=>1), ob
-     assert_eee Rob(:aa=>1,:b=>/foo/), ob
-     assert_eee Rob(:@aa=>1,:@b=>/foo/), ob
-
-     assert_ene Rob(:aa=>Float), ob
-     assert_ene Rob(:@aa=>Float), ob
-     assert_ene Rob(:aa=>1,:b=>/fu/), ob
-     assert_ene Rob(:@aa=>1,:@b=>/fu/), ob
- 
-     assert_eee Rob(), ob
-     assert_ene Rob(:d=>item_that.size>33), ob
-
-     
-     assert_eee Rob(/aa$/=>1), ob
-     #assert_eee Rob(/@aa/=>1), ob
-     assert_eee Rob(/aa$/=>1,:b=>/foo/), ob
-     #assert_eee Rob(/@aa/=>1,:@b=>/foo/), ob
-
-     assert_ene Rob(/aab$/=>1), ob
-     assert_ene Rob(/aab$/=>1,:b=>/foo/), ob
-
-     assert_ene Rob(/aa$/=>Float), ob
-     #assert_ene Rob(/@aa/=>Float), ob
-     assert_ene Rob(/aa$/=>1,:b=>/fu/), ob
-     #assert_ene Rob(/@aa/=>1,:@b=>/fu/), ob
- 
-     assert_ene Rob(/ddd/=>item_that.size>33), ob
-     
-     assert_eee Rob(/aa$/=>1,:b=>/foo/,:@c=>OB), ob
-     #assert_eee Rob(/@aa/=>1,:@b=>/foo/,OB=>item_that.size<33), ob
-     #assert_eee Rob(/@aa/=>1,:@b=>/foo/,:@c=>Array,OB=>nil), ob
-
-     assert_ene Rob(/a$/=>1,:bb=>/foo/,:@c=>OB), ob
-     #assert_ene Rob(/@a/=>1,:@b=>/foo/,OB=>item_that.size>33), ob
-     #assert_ene Rob(/@a/=>1,:@b=>/foo/,:@c=>Array,OB=>Symbol), ob
-
-#Matches array containing exactly 2 elements; 1st is another array, 2nd is
-#integer:
-     assert_eee( +[Array,Integer], [["ee"],555])
-
-#Like above, but 1st is array of arrays of symbol
-     assert_eee( +[+[+[Symbol+0]+0],Integer], [[[:foo,:bar],[:baz,:bof]], 0])
-
-#Matches array of at least 3 consecutive symbols and nothing else:
-     assert_ene( +[Symbol+3], [:hop]*2)
-     assert_eee( +[Symbol+3], [:hop]*3)
-     assert_eee( +[Symbol+3], [:hop]*4)
-
-#Matches array with at least 3 (consecutive) symbols in it somewhere:
-     assert_eee( +[OBS, Symbol+3, OBS], [Module, nil, 1, "o", :g, [66,77], {888=>999}, :a, :b, :c])
-     assert_eee( +[OBS, Symbol+3, OBS], [Module, nil, 1, :a, :b, :c, "o", :g, [66,77], {888=>999}])
-     assert_ene( +[OBS, Symbol+3, OBS], [Module, nil, 1, :a, :b, "o", :g, [66,77], {888=>999}])
-     assert_eee( +[OBS, Symbol+3, OBS], [:a, :b, :c, Module, nil, 1, "o", :g, [66,77], {888=>999}])
-
-#Matches array of at most 6 strings starting with 'g'
-     assert_eee( +[/^g/-6], [])
-     assert_eee( +[/^g/-6], ["gh"])
-     assert_eee( +[/^g/-6], ["gh","gg"])
-     assert_eee( +[/^g/-6], ["gh","gg", "gf"])
-     assert_eee( +[/^g/-6], ["gh","gg", "gf", "ge"])
-     assert_eee( +[/^g/-6], ["gh","gg", "gf", "ge","gd"])
-     assert_eee( +[/^g/-6], ["gh","gg", "gf", "ge","gd","gc"])
-     assert_ene( +[/^g/-6], ["gh","gg", "gf", "ge","gd","gc","gd"])
-
-#Matches array of between 5 and 9 hashes containing a key :k pointing to
-#something non-nil:
-     h={:k=>true}
-     assert_eee( +h, h)
-     assert_eee( +{:k=>OB}, h)
-     assert_eee( +{:k=>~nil.reg}, h)
-     assert_ene( +[ +{:k=>~nil.reg}*(5..9) ], [h,h,h,h])
-     assert_eee( +[ +{:k=>~nil.reg}*(5..9) ], [h,h,h,h,h])
-     assert_eee( +[ +{:k=>~nil.reg}*(5..9) ], [h,h,h,h,h,h])
-     assert_eee( +[ +{:k=>~nil.reg}*(5..9) ], [h,h,h,h,h,h,h])
-     assert_eee( +[ +{:k=>~nil.reg}*(5..9) ], [h,h,h,h,h,h,h,h])
-     assert_eee( +[ +{:k=>~nil.reg}*(5..9) ], [h,h,h,h,h,h,h,h,h])
-     assert_ene( +[ +{:k=>~nil.reg}*(5..9) ], [h,h,h,h,h,h,h,h,h,h])
-
-#Matches an object with Integer instance variable @k and property (ie method)
-#foobar that returns a string with 'baz' somewhere in it:
-     assert_eee( -{:@k=>Integer, :foobar=>/baz/}, AnyStruct[:k=>5, :foobar=>"kla-baz"])
-
-#Matches array of 6 hashes with 6 as a value of every key, followed by
-#18 objects with an attribute @s which is a String:
-     test_matcher( +[ +{OB=>6}*6 ], :matches=>[[ {:a=>6},{:a=>6,:b=>6},{:a=>6,:b=>6,:c=>6},{:hodd=>6},
-          {:tuber=>6.0}, {:xxx=>6, :e=>6} ]])
-     test_matcher( +[ +{OB=>6}*6, -{:@s=>String}*18 ], 
-       :matches=>[ [ {:a=>6},{:a=>6,:b=>6},{:a=>6,:b=>6,:c=>6},{:hodd=>6},
-                     {:tuber=>6.0}, {:xxx=>6, :e=>6}, *[AnyStruct[:s=>"66"]]*18 ]
-                  ],
-       :unmatches=>[
-         [ {:a=>6},{:a=>6,:b=>6},{:a=>6,:b=>6,:c=>6},{:hodd=>6},
-           {:tuber=>6.0}, {:xxx=>6, :e=>6}, *[AnyStruct[:s=>"66"]]*17 ],
-         [ {:a=>6},{:a=>6,:b=>6},{:a=>6,:b=>6,:c=>6},{:hodd=>6},
-           {:tuber=>6.0}, {:xxx=>6, :e=>6}, *[AnyStruct[:s=>"66"]]*19 ],
-         [ {:a=>6},{:a=>5,:b=>6},{:a=>4,:b=>5,:c=>6},{:hodd=>6},
-           {:tuber=>6.0}, {:xxx=>"t", :e=>6}, *[AnyStruct[:s=>"66"]]*18 ]
-       ]
-     )
-
-     test_hash_matcher( +{OB=>6}, :unmatches=>{} )
-
-     test_hash_matcher +{/fo+/=>8, /ba+r/=>9}, :matches=> {"foo"=>8,"bar"=>9}
-
-     test_matcher +[/fo+/**8, /ba+r/**9], 
-       :matches=> [{"foobar"=>8, "bar"=>9},{"foo"=>8,"bar"=>9}],
-       :unmatches=> {"foobar"=>9, "bar"=>9}
-       
-
-
-     print "\n"
-  end
-
-  def disabled_test_subst
-    #insert ';)' after even elements of an array
-    +[-[ OB>>:even << -[BR[:even],';)'], OB]+0,   OB.-]
-    #be nice to abbreviate this to:
-    #+[-[ OB<<-[BR[],';)'], OB ]+0,   OB.-]
-  end
-
-
-  def assert_eee(left,right,message='assert_eee failed')
-    assert(
-      left===right,
-      message+" left=#{left.inspect}  right=#{right.inspect}"
-    )
-    print ".";$stdout.flush
-  end
-
-  def assert_ene(left,right,message='assert_ene failed')
-    assert(
-     !(left===right),
-     message+" left=#{left.inspect}  right=#{right.inspect}"
-    )
-    print ",";$stdout.flush
-  end
-
-  def test_matcher(mtr, hash)
-    if list=hash[:matches]
-      Array===list or list=[list]
-      list.each_with_index {|data,index| assert_eee mtr, data, "item ##{index} should match" }
-    end
-    
-    if list=hash[:unmatches]
-      Array===list or list=[list]
-      list.each_with_index {|data,index| assert_ene mtr, data, "item ##{index} should not match" }
-    end
-  end
-  
-  def test_hash_matcher (hmtr, hash)
-    test_matcher(hmtr,hash)
-    test_matcher(hmtr.ordered,hash)
-  end
-
-end
-
-class AnyStruct
-  def self.[] *a; new(*a) end
-  def initialize(hash=nil)
-    hash.each_pair{|name,val| set_field(name, val) } if hash
-  end
-
-  def set_field(name,val)
-    class<<self; self; end.instance_eval %{
-      attr_accessor :#{name}    
-    }
-    instance_variable_set "@#{name}", val
-  end
-
-  def method_missing sym, *val
-    sym=sym.to_s
-    if /^(.*)=$/===sym
-      set_field($1, val)
-    end
-  end
-end
-
-end
-     srand;seed=srand #most seeds work, but some don't, due to bugs in makelendata
-
-
-
-     opts=GetoptLong.new(["--seed", "-s", GetoptLong::REQUIRED_ARGUMENT],
-                         ["--verbose","-v",GetoptLong::NO_ARGUMENT])
-     verbose=false
-     opts.each{|opt,arg|
-       opt=='--seed' and seed=arg
-       opt=='--verbose' and $verbose=true       
-     }
-
-     print "random seed is #{seed}\n"
-     srand seed.to_i
-
-
-TC_Reg.test_reg
-#TC_Reg.test_rand_reg   #causes 0*inf too often