reg 0.4.8 → 0.5.0a0

data/{regcore.rb → lib/regcore.rb}

@@ -1,6 +1,6 @@
 =begin copyright
     reg - the ruby extended grammar
-    Copyright (C) 2005,2009  Caleb Clausen
+    Copyright (C) 2005, 2016  Caleb Clausen
 
     This library is free software; you can redistribute it and/or
     modify it under the terms of the GNU Lesser General Public
@@ -17,31 +17,43 @@
     Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 =end
 
-require 'trace.rb'
-
-module Reg  #namespace
+require 'trace_during.rb'
 
 
 
 
-  INFINITY= ( 
+  Infinity= begin
     result= [ Float::MAX**Float::MAX, Float::MAX**2,  Float::MAX*2].max
-    result.infinite? ? result : 
-      begin result=1.0/0
-      rescue; Float::MAX  #maybe 1.0/0 doesn't work on some systems?
-      end
-  )
+    result.infinite? ? result : result=1.0/0
+  rescue; Float::MAX  #maybe 1.0/0 doesn't work on some systems?
+  end unless defined? Infinity
+  
   #there's also this way: 999999999999999999999999999999999999999999999999e999999999999999999999999999999
   #but stuff like that sometimes returns zero, so it doesn't seem as reliable.
   #(plus it generates a warning)
             
-  INFINITY>1_000_000 or raise 'INFINITY is too small'
-  INFINITY.to_f.infinite? or warn "INFINITY is merely very large, not infinite"
+  #Infinity>1_000_000 or raise 'Infinity is too small'
+  Infinity.to_f.infinite? or raise "Infinity is merely very large, not infinite"
+  
+  NaN=[(Infinity*0 rescue nil), (0.0/0.0 rescue nil)].find{|x| x.nan?} or warn "oops, NaN is not set right (probably nil)..."
+
+  #Infinity is the approved capitalization. 
+  #INFINITY is the older form, still supported for now
+  INFINITY= Infinity  unless defined? INFINITY
             
+module Reg  #namespace
+  class <<self
+    #Reg::Array convenience constructor. see Array#+@ for details.
+    def [](*args)
+      ::Reg::Array.new(*args)
+    end
+  end
 
   #--------------------------
   #abstact ancestor of all reg classes
-  module Reg
+  module Reg  
+  
+  
   
     #=== must be defined in the includer for the appropriate types
     #and some others:
@@ -55,13 +67,17 @@ module Reg  #namespace
     #--------------------------
     def =~(other) 
       self===other
+    rescue #this is rediculuous; === should never raise an exception
+      false #I think the fix to Range#=== below elminates the need for this kind of thing
     end
     
+=begin    
     #--------------------------
     #low-precedence method call
     def <=>(other)
       send other
     end
+=end
     
     #--------------------------
     alias pristine_inspect inspect
@@ -69,6 +85,11 @@ module Reg  #namespace
       pp pristine_inspect
     end
 
+    #--------------------------
+    def to_s
+      inspect
+    end
+
 
     #--------------------------
     #makes a Reg object literal (aliased to +@ by default)
@@ -87,13 +108,32 @@ module Reg  #namespace
     #separated by other. watch out if other and self might
     #match the same thing(s).
     def sep other; -[self,-[other,self]+0]; end
+    #...or -[self.-, other.reg|Reg::Position[-0.0]].*
 
     #--------------------------
     #returns a (vector) Reg that will match a list of stuff
     #separated by self. somewhat analogous to Regexp#split,
     #but returns the separators as well.
-    def splitter; (~self+0).sep self; end
+    def splitter; OBS.l.sep self; end
     
+    #split the input into records using self as a separator expression.
+    #block, if given will be invoked with each record. with no block,
+    #an array of records is returned.
+    def split(input,&block)
+      unless block
+        result=[]
+        block=proc{|x| result<<x}
+      end
+      
+      huh #convert input to cursor if it isn't already
+      
+      while input.skip_until(self)
+        block.call $`  #`
+      end
+      return result
+    end
+
+=begin
     #--------------------------
     #set a breakpoint when matches against a Reg
     #are made. of dubious value to those unfamiliar
@@ -104,17 +144,38 @@ module Reg  #namespace
         alias_method :unbroken___mmatch,
            method_defined?(:mmatch) ? :mmatch : :fail #:nodoc:
         def ===(other)  #:nodoc:
-          defined? DEBUGGER__ and Process.kill("INT",0)
+          (defined? DEBUGGER__ or defined? Debugger) and Process.kill("INT",0)
           unbroken___eee other
+        rescue
+          false
         end
 
-        def mmatch(arr,start)  #:nodoc:
-          defined? DEBUGGER__ and Process.kill("INT",0)
-          unbroken___mmatch arr,start
+        def mmatch(*xx)  #:nodoc:
+          (defined? DEBUGGER__ or defined? Debugger) and Process.kill("INT",0)
+          unbroken___mmatch(*xx)
         end
       end
       self
     end
+=end    
+
+    #--------------------------
+    #makes matcher greedy. on by default
+    def g; self end
+    
+    #--------------------------
+    #makes matcher lazy.
+    def l; abstract end
+    
+
+    #--------------------------
+    #*,+,-  are defined in regarray.rb
+    #~,&,|,^ are defined in reglogic.rb
+    #** is in reghash.rb
+    #bind,side_effect,undo in regbind.rb
+    #>> and finally in regreplace.rb
+    #la,lb in reglookab.rb
+    #+[],-[],+{},-{},-:symbol in regsugar.rb
 
     #--------------------------
     #return a list of sub Regs of this Reg (if any)
@@ -135,22 +196,36 @@ module Reg  #namespace
     end
 
     #--------------------------
+    #is the parameter an interesting matcher?
+    #interesting matchers have an implementation of === that's
+    #different form their ==. unfortunately, that's not easy to 
+    #test in ruby. 
+    #this algorithm isn't perfect, but it's pretty good.
+    #in other words, very rarely, the method will fail and LIE to you.
+    #it should work >99%, of the time I think. 
     def Reg.interesting_matcher?(mat) #a hack
       case mat
+        when Integer,Float,Symbol,true,false,nil,Method,UnboundMethod; false
         when ItemThatLike,BackrefLike,Module,Set,Regexp,Range,::Reg::Reg; true
-        #when Symbol,Pathname: false
+        #when Symbol,Pathname; false
         else
           /^#<UnboundMethod: .*\(Kernel\)#===>$/===mat.method(:===).unbind.inspect and return false
+          assert( /^#<UnboundMethod: .*\(?(#<)?[A-Z:][A-Za-z_:0-9]+\>?\)?#===>$/===mat.method(:===).unbind.inspect )
+          
+          #in case there's an object that redefined ===, then defined it back to
+          #== later in the inheiritance chain
+          #or, someone might write: def === other; self==other end
+          #out of ignorance that it's unnecessary
           
           eee_call=nil
-          result=!trace(proc do|event,*stuff| 
+          result=!trace_during(proc do|event,*stuff| 
             if /call$/===event
               eee_call=stuff
               
                 #attempt to remain debuggable while restoring the old trace func
               set_trace_func((defined? DEBUGGER__ and (DEBUGGER__.context.method:trace_func).to_proc))              
             end
-          end){mat===mat}; line=__LINE__
+          end){mat===mat rescue false}; line=__LINE__
           assert eee_call[0] == __FILE__
           assert eee_call[1] == line
           assert eee_call[2] == :===
@@ -165,14 +240,6 @@ module Reg  #namespace
       Reg.interesting_matcher? mat
     end
 
-    #--------------------------
-    #*,+,-  are defined in regarray.rb
-    #~,&,|,^ are defined in reglogic.rb
-    #** is in reghash.rb
-    #<< and side_effect,undo in regbind.rb
-    #>> and later in regreplace.rb
-    #la,lb in reglookab.rb
-
   
 
     #--------------------------
@@ -185,38 +252,36 @@ module Reg  #namespace
       end
     end
 =end
+
     #--------------------------
     def mmatch(ary,idx)
       assert idx<=ary.size
       idx==ary.size and return nil
-      self===ary[idx] and [[[ary[idx]]],1]
+      (self===ary[idx] rescue false) and [[[ary[idx]]],1]
     end
 
     protected
-    #--------------------------
-    def maybe_multiples(*regs)
-      regs.each{|reg|
-        reg.respond_to? :maybe_multiple and
-          reg.maybe_multiple(self)
-      }
-    end
 
       #--------------------------
           
+=begin
         #eventually, this will be a list of all tla mappings
-        ::Reg::TLAs=Hash.new{|h,k| h[k]={} }
-        RegMethods=proc do
+        #RegMethods=proc do
+        module_function
+#        class<<self
+          @@TLAs={}
           define_method :assign_TLA do |*args|
             hash=args.pop   #extract hash from args
             noconst,*bogus=*args #peel noconst off front of args 
             hash.each{|k,v| 
-              v=TLAs[self][k]= noconst ? [v,true] : v #fold noconst into v (longname) and store in ::Reg::TLAs
+              v=@@TLAs[k]= noconst ? [v,true] : v #fold noconst into v (longname) and store in @@TLAs
               TLA_aliases k,v  #always alias the TLA into ::Reg namespace
             }
           end
           
           
           alias_method :assign_TLAs, :assign_TLA
+
           define_method :TLA_aliases do |short,long_args,*rest| myself=rest.first||::Object
             long=nil
             if ::Array===long_args 
@@ -227,19 +292,23 @@ module Reg  #namespace
             end
             myself.const_set(short,::Reg::const_get(long)) unless noconst #alias the constant name
             
-            long=(::Reg.const_get long)  #convert long from symbol to a module or class
-            myself.send:define_method, short do|*args| long.new( *args) end    #forward short name to long
+            #long=(::Reg.const_get long)  #convert long from symbol to a module or class
+            myself.instance_eval %{
+              private
+              def #{short}(*args) #{long}.new( *args) end    #forward short name to long
+            }
           end
-        end
-        def self.included(mod)
-          (class<<mod;self;end).instance_eval( &RegMethods    )
-        end
+ #       end
+ #       def self.included(mod)
+         # (class<<mod;self;end).instance_eval( &RegMethods    )
+ #       end
  
-    TLA_pirate= proc {         ::Reg::TLAs[self].each{|k,v| Reg.TLA_aliases k,v,self}       }
+    TLA_pirate= proc {         @@TLAs.each{|k,v| Reg.TLA_aliases k,v,self}       }
+=end    
+    
       
-
   end
-  TLA_pirate= Reg::TLA_pirate
+#  TLA_pirate= Reg::TLA_pirate
   #the tlas (and where they're found):
   
   #Rob,Rah,Rap (reghash.rb)
@@ -247,33 +316,50 @@ module Reg  #namespace
   #Rac,      (regcase.rb)
   #Rip       (right here, regcore.rb)-----v
   
+  #p :TLA_stuff_defined
+  
+  #forward decl
+  module Composite; end
+  module CausesBacktracking; end
+  
+  
   
   #--------------------------
-  class Wrapper
+  class Wrapper 
   
     include Reg
-    def initialize(o)
+    def initialize(o=nil)
       @o=o
+      #super
     end
 
-    def matches_class; @o.class end
     def lit; @o end
     alias unwrap lit
 
-    def inspect
-      "(#{@o.inspect}).reg"
-    end
-    
-    def ===x; raise NoMethodError.new( "Reg::Wrapper") end
+    def ===x; raise NoMethodError.new( "Reg::Wrapper is abstract") end
   
   end
   
   
   #--------------------------
   class Fixed < Wrapper #matches like a plain object, but responds to Reg#|, etc
-  #but still behaves in a match just like the unadorned obj (uses === to match)
+  #but still behaves in a match just like the unadorned obj (uses wrapee's === to match)
+    def inspect
+      if Reg===@o
+      "Reg::Fixed.new("+@o.inspect+")"
+      else
+      "(#{@o.inspect}).reg"
+      end
+    end
+    
     def ===(other)
       @o===other
+    rescue #shouldn't be needed
+      false
+    end
+    
+    def matches_class
+      huh
     end
   end
 
@@ -283,10 +369,15 @@ module Reg  #namespace
     def ===(other)
       @o==other
     end
+    
+    def inspect; huh end
+
+    def matches_class; @o.class end
   end
 
   #--------------------------
   class Literal < Equals #a literalized Reg
+    #literal is really the same as const... the 2 classes should be merged
     def reg; @o end
     def lit; Literal.new self end
     def unlit; @o end
@@ -294,6 +385,8 @@ module Reg  #namespace
     def formula_value(*ctx)
       @o
     end
+
+    def inspect; huh end
   end
 
   #--------------------------
@@ -307,10 +400,13 @@ module Reg  #namespace
     def reg
       Fixed.new(self)
     end
+    def to_reg; reg end
 
-    # 
+    # return a literal version of the object... one whose === has been
+    # forced to be the same as ==, regardless of whether it's usually
+    # a matcher or not.
     def lit
-      self
+      self #implementation needs some more work...
     end
     
     #just like ===, but receiver and argument are switched.
@@ -318,6 +414,8 @@ module Reg  #namespace
     #to match to the left, and the pattern on the right.
     def matches pattern
       pattern===self
+    rescue #shouldn't be needed
+      false
     end
   end
 
@@ -330,6 +428,7 @@ module Reg  #namespace
 
     def initialize(rex)
       @rex=rex
+#      super
     end
 
     def matches_class; ::Symbol end
@@ -342,37 +441,49 @@ module Reg  #namespace
       @rex.inspect+'.sym'
     end
   end
-  
-    #a dynamically created Reg
-    def (::Reg).regproc klass=::Object,&block
-      class <<block
-        include Interpret
-      end
-      block.klass=klass
-      block
-    end
-
-
 
   #--------------------------
-  module Interpret  #a Reg whose makeup isn't determined until runtime.
-      include Reg
-      def klass=(k) @@klass=k end
-      def ===(other)
-        @@klass===other || return
-        r=call
-           #eventually pass params to call
-        Reg::Multiple===r and raise  'this oughtta work, but doesn`t yet'
-        r===other
-      end
-      def matches_class; @@klass end
-      alias starts_with matches_class
-      alias ends_with matches_class
+  #a dynamically created Reg
+  def (::Reg).regproc klass=::Object,&block
+    Interpret.new(&block)
+  end
 
+  class Interpret  #a Reg whose makeup isn't determined until matchtime.
+    include Reg
+    
+    def initialize(&matchercode)
+      @matchercode=matchercode
+      super
+    end
 
-      assign_TLA true, :Rip=>:Interpret
+    def ===(other)
+      mtr=@matchercode.call(Progress.new(self,::Sequence::SingleItem.new(other)))
+      mtr===other rescue false
+         #eventually pass more params to call?
+    end
+    
+    def mmatch(progress)
+      @matchercode.call(progress).mmatch(progress)
+    end
+    
+    #assign_TLA true, :Rip=>:Interpret
   end
 
 
   
 end
+
+
+#workaround potential error in class Range. 
+#ruby 1.9 appearently fixes this
+begin
+  ("a"..."b")===4
+rescue Exception
+  class Range
+    #dammit, === should never raise an exception
+    unsafe_eee = instance_method :===
+    define_method(:===) {|other|
+      unsafe_eee.bind(self)[other] rescue false
+    }
+  end
+end