reg 0.4.6

data/regbackref.rb

@@ -0,0 +1,126 @@
+=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
+require 'pp'
+require 'regdeferred'
+
+module Reg
+
+=begin  
+  #----------------------------------
+  module Block
+#    include Formula
+
+    attr_writer :klass #for internal use only
+
+    def eeee(val)
+      @klass and @klass===val || return
+      begin call(val)
+      rescue: false
+      end
+    end
+    alias === eeee #does nothing in includers.... why?
+    alias formula_value eeee 
+
+    
+    def mixmod; ItemThatLike end
+    def reg; extend Reg end
+  end
+  #----------------------------------
+  module ItemThatLike
+    def eee(item)
+      begin formula_value item
+      rescue: false
+      end
+    end
+    alias === eee #this doesn't work!!! WHY????
+    #there's no way to define the method === in this
+    #module and have it be defined in class ItemThat.
+    #mixmod and reg don't have this problem. this must
+    #be a bug. for now, I work around it with clever 
+    #alias/undefing in places that include/extend ItemThatLike
+    #(seemingly, this is only a problem when including, not extending... dunno why)
+    #this bug may be gone now; need to try to get rid of weird eee stuff.
+    
+    def mixmod; ItemThatLike end
+    def reg; extend Reg end
+  end
+  #----------------------------------
+  class ItemThat 
+    include BlankSlate
+    restore :inspect,:extend
+    include Formula
+    include ItemThatLike
+    alias === eee
+    undef eee
+    def initialize(klass=nil)
+      @klass=klass
+    end
+    
+    def formula_value(val,*rest)
+      #the exception raised here should be (eventually) caught by 
+      #the handler in ItemThatLike#eee. calling ItemThat#formula_value isn't
+      #really legitimate otherwise.
+      @klass and @klass===val || fail("item_that constraint mismatch")
+    
+      val
+    end
+    
+  end
+=end
+  #----------------------------------
+  module BackrefLike
+    def mmatch(ary,idx)
+      huh #need info thats not_in ary or idx
+    end
+    
+    def mixmod; BackrefLike end
+  end
+  #----------------------------------
+  class Backref 
+    include BlankSlate
+    restore :inspect,:extend
+    include Formula
+    include BackrefLike
+    def initialize(name,*path)
+      #complex paths not handled yet
+      raise ParameterError.new unless path.empty? and Reg|Symbol===name
+      @name=name
+    end
+    
+    def formula_value(*ctx)
+      progress=ctx[1]
+      progress.variables[@name]
+    end
+    
+    class<<self
+      alias [] new
+    end
+  end
+
+
+  #----------------------------------
+  module BRLike
+    include BackrefLike
+    include Reg
+    def mixmod; BRLike end
+  end
+  class BR < Backref
+    include BRLike
+  end
+end

data/regbind.rb

@@ -0,0 +1,74 @@
+=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
+    def bind(name=self)
+      Bound.new(name,self)
+    end
+    alias << bind
+    
+    def side_effect(&block); SideEffect.new(self,&block) end
+    def undo(&block); Undo.new(self,&block) end
+  end
+  
+  #-------------------------------------
+  class Bound
+    include Reg
+    def initialize(name,reg)
+      @name,@reg=name,reg
+    end
+  
+  
+    def mmatch(progress)
+      result=@reg.mmatch(progress) and 
+        progress.register_var(@name,@reg)
+      return result
+    end
+  end
+
+  #-------------------------------------
+  class SideEffect
+    include Reg
+  
+    def initialize(reg,&block)
+      @reg,@block=reg,block
+    end
+  
+    def mmatch(progress)
+      result=@reg.mmatch(progress) and 
+        @block.call(progress)
+      return result
+    end
+  end
+  
+  #------------------------------------
+  class Undo
+    include Reg
+  
+    def initialize(reg,&block)
+      @reg,@block=reg,block
+    end
+  
+    def mmatch(progress)
+      result=@reg.mmatch(progress) and 
+        progress.register_undo(@block)
+      return result
+    end
+  end
+end

data/regcase.rb

@@ -0,0 +1,78 @@
+=begin copyright
+    reg - the ruby extended grammar
+    Copyright (C) 2005  Caleb Clausen
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+=end
+module Reg
+  class Case
+    def initialize(*args)
+      if args.size==1 and Hash===args.first 
+        scalars=[]; sets=[]
+        matchers=[];
+        
+        args.first.each{|k,v|
+           if Reg.interesting_matcher? k
+            matchers<<k.reg**v
+          elsif Set===k
+            sets<<k.reg**v
+          else
+            scalars<<k.reg**v
+          end        
+        }
+        args=scalars+sets+matchers
+      end
+      
+      @others=others_given=nil
+      @pairlist=args.delete_if{|a|
+          if !(Pair===a)
+            warn "ignoring non-Reg::Pair in Reg::Case: #{a}"
+            true
+          elsif OB==a.left
+            others_given and warn 'more than one default specified'
+            others_given=true
+            @others=v
+          end  
+      }
+    end
+  
+    def ===(other)
+      @pairlist.each{|pair|
+        pair.left===other and pair.right===other || return
+      }
+      @others===other
+    end
+  
+    #hash-based optimization of scalars and sets is possible here
+    
+    def previous_matchers(val,*)
+      val #by default, do nothing
+    end
+    
+    def previous_matchers_ordered(val,index,other)
+      val,index=*args
+      (0..index).each{|i|
+        pair=@pairlist[i]
+        
+        pair.left===other and pair.right===other || return
+      }
+      
+    end
+  
+  end
+  
+  Rac=Case #tla of case
+  assign_TLA :Rac=>:Case
+end

data/regcore.rb

@@ -0,0 +1,379 @@
+=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
+
+require 'trace.rb'
+
+module Reg  #namespace
+
+
+
+
+  INFINITY= ( 
+    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
+  )
+  #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"
+            
+
+  #--------------------------
+  #abstact ancestor of all reg classes
+  module Reg
+  
+    #=== must be defined in the includer for the appropriate types
+    #and some others:
+    #itemrange
+    #scalar?, vector?, multiple?, variable?, multilength?, fixed?
+    #starts_with
+    #ends_with
+    #breakdown
+    #what else?
+    
+    #--------------------------
+    def =~(other) 
+      self===other
+    end
+    
+    #--------------------------
+    #low-precedence method call
+    def <=>(other)
+      send other
+    end
+    
+    #--------------------------
+    alias pristine_inspect inspect
+    def pp_inspect 
+      pp pristine_inspect
+    end
+
+
+    #--------------------------
+    #makes a Reg object literal (aliased to +@ by default)
+    def lit
+      Literal.new(self)
+    end
+    def +@; lit end
+
+    #--------------------------
+    #makes a version of self suitable for use in Reg matching
+    #expressions. in subclasses of Reg this just returns self.
+    def reg; self end
+
+    #--------------------------
+    #returns a (vector) Reg that will match a list of self
+    #separated by other. watch out if other and self might
+    #match the same thing(s).
+    def sep other; -[self,-[other,self]+0]; end
+
+    #--------------------------
+    #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
+    
+    #--------------------------
+    #set a breakpoint when matches against a Reg
+    #are made. of dubious value to those unfamiliar
+    #with Reg::Array source code.
+    def bp #:nodoc: all
+      class <<self #:nodoc:
+        alias_method :unbroken___eee, :===     #:nodoc:
+        alias_method :unbroken___mmatch,
+           method_defined?(:mmatch) ? :mmatch : :fail #:nodoc:
+        def ===(other)  #:nodoc:
+          defined? DEBUGGER__ and Process.kill("INT",0)
+          unbroken___eee other
+        end
+
+        def mmatch(arr,start)  #:nodoc:
+          defined? DEBUGGER__ and Process.kill("INT",0)
+          unbroken___mmatch arr,start
+        end
+      end
+      self
+    end
+
+    #--------------------------
+    #return a list of sub Regs of this Reg (if any)
+    def subregs
+      []
+    end
+
+    #--------------------------
+    #a simple reg that always starts this reg
+    def starts_with
+      self
+    end
+
+    #--------------------------
+    #a simple reg that always ends this reg
+    def ends_with
+      self
+    end
+
+    #--------------------------
+    def Reg.interesting_matcher?(mat) #a hack
+      case mat
+        when ItemThatLike,BackrefLike,Module,Set,Regexp,Range,::Reg::Reg: true
+        #when Symbol,Pathname: false
+        else
+          /^#<UnboundMethod: .*\(Kernel\)#===>$/===mat.method(:===).unbind.inspect and return false
+          
+          eee_call=nil
+          result=!trace(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__
+          assert eee_call[0] == __FILE__
+          assert eee_call[1] == line
+          assert eee_call[2] == :===
+          assert eee_call[3].class == Binding
+          assert Module===eee_call[4].class
+          return eee_call[4]!=Kernel && result
+      end
+    end
+    
+    #--------------------------
+    def interesting_matcher?(mat=self)
+      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
+
+  
+
+    #--------------------------
+=begin seems risky... disabled til I know why i want it
+    def coerce(other)
+      if Reg===other
+        [other,self]
+      else
+        [other.reg,self]
+      end
+    end
+=end
+    #--------------------------
+    def mmatch(ary,idx)
+      assert idx<=ary.size
+      idx==ary.size and return nil
+      self===ary[idx] and [[[ary[idx]]],1]
+    end
+
+    protected
+    #--------------------------
+    def maybe_multiples(*regs)
+      regs.each{|reg|
+        reg.respond_to? :maybe_multiple and
+          reg.maybe_multiple(self)
+      }
+    end
+
+      #--------------------------
+          
+        #eventually, this will be a list of all tla mappings
+        RegMethods=proc do
+          @@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[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 
+              long=long_args.shift
+              noconst=long_args.shift  #unfold noconst from long if folded
+            else
+              long=long_args
+            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
+          end
+        end
+        def self.included(mod)
+          (class<<mod;self;end).instance_eval( &RegMethods    )
+        end
+ 
+    TLA_pirate= proc {         @@TLAs.each{|k,v| Reg.TLA_aliases k,v,self}       }
+      
+
+  end
+  TLA_pirate= Reg::TLA_pirate
+  #the tlas (and where they're found):
+  
+  #Rob,Rah,Rap (reghash.rb)
+  #Reg,Res,  (regarray.rb)
+  #Rac,      (regcase.rb)
+  #Rip       (right here, regcore.rb)-----v
+  
+  
+  #--------------------------
+  class Wrapper
+  
+    include Reg
+    def initialize(o)
+      @o=o
+    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
+  
+  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)
+    def ===(other)
+      @o===other
+    end
+  end
+
+
+  #--------------------------
+  class Equals < Wrapper #like Reg::Fixed, but == instead of ===
+    def ===(other)
+      @o==other
+    end
+  end
+
+  #--------------------------
+  class Literal < Equals #a literalized Reg
+    def reg; @o end
+    def lit; Literal.new self end
+    def unlit; @o end
+    
+    def formula_value(*ctx)
+      @o
+    end
+  end
+
+  #--------------------------
+  class ::Object
+    #turns any object into a matcher which matches the same 
+    #thing that the object matches, except it's also a Reg::Reg,
+    #and thus respects reg's meanings of: +,*,>>,&,~, etc
+    #the generic case creates a wrapper Reg around any object whose ===
+    #forwards to the wrapped object's ===. the original object is
+    #unchanged.
+    def reg
+      Fixed.new(self)
+    end
+
+    # 
+    def lit
+      self
+    end
+    
+    #just like ===, but receiver and argument are switched.
+    #for those situations where you just have to put the item
+    #to match to the left, and the pattern on the right.
+    def matches pattern
+      pattern===self
+    end
+  end
+
+  #--------------------------
+  String=::Regexp
+
+  #--------------------------
+  class Symbol
+    include Reg
+
+    def initialize(rex)
+      @rex=rex
+    end
+
+    def matches_class; ::Symbol end
+
+    def ===(other)
+      ::Symbol===other and m=@rex.match(other.to_s) and m[0]
+    end
+
+    def inspect
+      @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
+
+
+      assign_TLA true, :Rip=>:Interpret
+  end
+
+
+  
+end