reg 0.4.6

data/regreplace.rb

@@ -0,0 +1,114 @@
+=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

@@ -0,0 +1,230 @@
+=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
+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

@@ -0,0 +1,1075 @@
+#!/usr/bin/ruby -w 
+=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
+
+$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].to_s 
+      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
+
+
+
+$RegTraceEnable=1 #debugging zone:
+     h={}
+     h.default=:b
+     test_hash_matcher Rah(:a=>:b), :matches=>h 
+
+$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_eee(  +[:q], [:q]  )
+     assert_eee(  +[-[]], []  )
+     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