reg 0.4.6

data/regknows.rb

@@ -0,0 +1,63 @@
+=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 Knows
+    include Reg
+    attr :sym
+    def initialize(sym) @sym=sym end
+  
+    def === (obj)
+      obj.respond_to? @sym
+    end
+
+    def [] *args
+      Args.new(sym,*args)
+    end
+
+    def -@; self end
+
+    def inspect
+      "-:#{sym}"
+    end
+    
+    #(also, the usual [] => new alias)
+    class<< self
+      alias[]new
+    end
+
+    class Args < Knows
+      attr :argsreg
+      
+      def initialize(sym,*argsreg)
+        super sym
+        @argsreg=::Reg[*argsreg]
+      end 
+      
+      def inspect
+        ":#{sym}"+@argsreg.inspect[1..-1]
+      end
+      def ===(obj)
+        super and huh "need some more help here"
+      end
+      def -@; self end
+    end
+
+  end
+  
+end

data/reglogic.rb

@@ -0,0 +1,195 @@
+=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
+
+    #logical negation - returns a new reg that matches everything
+    #that the receiver doesn't.
+    def ~
+      Not.new(self)
+    end
+    alias not ~
+
+    #create a Reg matching either self or other (or both).
+    #(creates a Reg::Or.)
+    #Reg#|'s may be chained; the result is a single large
+    #Reg::Or containing all the subexpressions directly,
+    #rather than a linked list of Reg::Or's.
+    #
+    #if any subRegs of | are vector Regs, the larger | Reg
+    #is considered a vector as well. eats as much
+    #input as the subexpression which matched. unlike other
+    #vector Reg expressions, | is not greedy; instead, the
+    #first alternative which matches is accepted. (subject
+    #to later backtracking, of course.)
+    def |(other)
+      Or.new(self,other)
+    end
+
+    #create a Reg matching self and other. (creates a Reg::And).
+    #Reg#&'s may be chained; the result is a single large
+    #Reg::And containing all the subexpressions directly,
+    #rather than a linked list of Reg::And's.
+    #
+    #if any subRegs of & are vector Regs, the larger & Reg
+    #is considered a vector as well. eats as much
+    #input as the longest subexpression.
+    def &(other)
+      And.new(self,other)
+    end
+
+    #create a Reg matching either self or other, but not both.
+    #(creates a Reg::Xor).
+    #Reg#^'s may be chained; the result is a single large
+    #Reg::Xor containing all the subexpressions directly,
+    #rather than a linked list of Reg::Xor's. (believe it or not,
+    #this has the same semantics.) in an xor chain created this
+    #way, only one of the several alternatives may match. if
+    #2 or more alternatives both match, the larger xor
+    #expression will fail.
+    #
+    #if any subRegs of ^ are vector Regs, the larger ^ Reg
+    #is considered a vector as well. eats as much input as
+    #the (only) subReg which matches.
+    def ^(other)
+      Xor.new(self,other)
+    end  
+  
+  end
+
+
+  #--------------------------
+  class Not
+    include Reg
+    def initialize(reg)
+      @reg=reg
+      maybe_multiples(reg)
+    end
+    def ===(obj)
+      !(@reg===obj)
+    end
+    def ~
+      @reg
+    end
+
+    #deMorgan's methods...
+    def &(reg)
+      if Not===reg
+        ~( ~self | ~reg )
+      else
+        super reg
+      end
+    end
+    def |(reg)
+      if Not===reg
+        ~( ~self & ~reg )
+      else
+        super reg
+      end
+    end
+
+    #mmatch_multiple implementation needed
+
+    def inspect
+      "~("+@reg.inspect+")"
+    end
+
+    def subregs; [@reg] end
+  end
+
+  #--------------------------
+  class Or
+    include Reg
+    attr :regs
+    def initialize(*regs)
+      @regs=regs
+
+      maybe_multiples(*regs)
+    end
+    def ===(obj)
+      @regs.each {|reg| reg===obj and return obj }
+      return false
+    end
+
+    def |(reg)
+      newregs=@regs + ((self.class===reg )? reg.regs : [reg])
+      self.class.new(*newregs)
+    end
+
+
+    def inspect
+      @regs.collect{|r| r.inspect}.join' | '
+    end
+
+    def subregs; @regs end
+  end
+
+  #--------------------------
+  class And
+    include Reg
+    attr :regs
+    def initialize(*regs)
+      @regs=regs
+      maybe_multiples(*regs)
+    end
+    def ===(obj)
+      @regs.each {|reg| @reg===obj or return false }
+      return obj
+    end
+    def &(reg)
+      newregs=@regs + ((self.class===reg)? reg.regs : [reg])
+      self.class.new(*newregs)
+    end
+
+    def inspect
+      @regs.collect{|r| r.inspect}.join' & '
+    end
+
+    def subregs; @regs end
+  end
+
+  #--------------------------
+  class Xor
+    include Reg
+    attr :regs
+    def initialize(*regs)
+      @regs=regs
+      maybe_multiples(*regs)
+    end
+    def ===(obj)
+      @regs.find_all {|reg| reg===obj }.size==1
+    end
+    def ^(reg)
+      newregs=@regs + ((self.class===reg )? reg.regs : [reg])
+      self.class.new(*newregs)
+    end
+
+
+    def inspect
+      @regs.collect{|r| r.inspect}.join' ^ '
+    end
+
+    def subregs; @regs end
+  end
+end

data/reglookab.rb

@@ -0,0 +1,94 @@
+=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 la; LookAhead.new self end
+    def lb; LookBack.new self end
+  end
+
+
+  class LookAhead
+    include Reg
+    include Multiple
+    def initialize(reg)
+      @reg=reg
+    end
+    
+    def mmatch(pr)
+      @reg.mmatch(pr.subprogress pr.cursor.position,@reg)
+    end
+    
+    def itemrange; 0..0 end
+    
+    #most methods should be forwarded to @reg... tbd
+  
+  end
+  
+  
+  class LookBack
+    include Reg
+    include Multiple
+    
+    def initialize(reg)
+      
+      r=reg.itemrange
+      @r=r.last-r.first
+      @reg=reg
+      
+    end
+
+    def itemrange; 0..0 end
+ 
+    def regs
+      [*regs_ary(huh)]
+    end
+
+    def regs_ary(pos,r=@r)
+      [ (OB-r).l, @reg, Position[pos] ] #require unimplemented lazy operator....
+    end 
+
+    def mmatch(pr)
+      cu=pr.cursor
+      ra=@reg.itemrange
+      pos=cu.pos
+      startpos=pos-ra.last
+      r=if startpos<0 
+        huh 'dunno what to do here'
+        foo=ra.first+startpos
+        startpos=0
+        pos-ra.first
+      else
+        @r
+      end
+      reg= +regs_ary(pos,r)
+      cu=cu.position
+      cu.pos=startpos
+      reg.mmatch pr.subprogress(cu,reg)
+      
+      #original pr.cursor position should be unchanged
+      assert pos==cu.pos
+      
+      huh #result should be fixed up to remove evidence of 
+      #the subsequence and all but it's middle element.
+    end
+
+    #most methods should be forwarded to @reg... tbd
+  end
+
+end

data/regold.rb

@@ -0,0 +1,75 @@
+=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
+
+
+#the names defined here are considered obsolete, and will not be supported
+#anymore at some point in the future.
+
+for name in ["And", "Array","Equals", "Fixed", "Hash", "Literal", 
+             "Multiple", "Not", "Object", "Or", "Repeat", 
+             "String", "Subseq", "Symbol", "Xor"] do
+             
+             if Class===::Reg.const_get(name)
+               eval <<-endeval
+                 class ::Reg#{name} < Reg::#{name} 
+                 
+                   def initialize(*args,&block)
+                     @@warned_already ||= !warn("Reg#{name} is obsolete; use Reg::#{name} instead")
+                     super
+                   end
+                 end
+               endeval
+              else
+               eval <<-endeval
+                 module ::Reg#{name}; include Reg::#{name}
+                   def self.included(*args,&block)
+                     @@warned_already ||= !warn("Reg#{name} is obsolete; use Reg::#{name} instead")
+                     super
+                   end
+                 end
+               endeval
+                
+              end
+             
+#  Object.const_set "Reg"+name, (Reg.const_get name)
+end
+
+#need a way to obsolete these...
+Reg::Number=Range
+Reg::Const=Reg::Deferred::Const
+
+#--------------------------
+#an executable Reg... a Proc that responds to ===
+#obsolete: please use item_that instead.
+def proceq(klass=Object,&block)
+  @@proceqWarnedAlready ||= !warn( "proceq is obsolete; please use item_that instead")
+  
+  block.arity.abs==1 or raise ArgumentError.new( "must be 1 arg")
+  class <<block
+    include Reg::Reg
+    def klass=(k) @@klass=k end
+    alias === call
+      #eventually pass (more) params to call
+    def matches_class; @@klass end
+    alias starts_with matches_class
+    alias ends_with matches_class
+  end
+  block.klass=klass
+  block
+end

data/regpath.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
+
+=begin
+path specification:
+each path is relative to the reg it references into.
+
+in order to support named subexpressions, most reg classes that participate
+in paths (the ones listed below) will also take a subreg of the reg as a path
+component. regs that cannot accept a subreg are marked with stars
+
+reg classes participating in paths:   and their respective path component:
+RegString (=Regexp)                   backref integer index **
+RegSymbol                             ditto  **
+RegArray                              integer index
+RegSubseq                             ditto
+RegHash                               hash key (of something that matched) ...value?
+RegObject                             name (as sym) ...return value?
+RegOr                                 integer index
+RegAnd                                ditto
+RegXor                                ditto
+RegNot                                nil only  *
+RegRepeat                             integer index  *
+(not really named) RegProc            1 of above, depending on what it returned
+
+*  doesn't take a subreg of the reg as index
+** doesn't take a subreg and must be end of path (or before -1)
+
+special components:
+-1 means go up one level (like .. in directory paths)
+
+
+
+
+               single  ________fixed
+          _____multiple--------
+    vector-----variable
+               
+
+                 dataclasses
+matchers--v    String     Array               
+Integer        single     single
+String         multiple   single
+Regexp         variable   single
+Reg::Subseq    var(=>any) var(=>any)
+Reg::Array     n/a?       single
+Reg::Hash      n/a        single
+Reg::Repeat    var(=>any) var(=>any)
+Lookahead/back multiple   multiple   (0 really)
+~single        single     single
+~multiple      multiple   multiple
+~vector        multiple   multiple   (0 really; lookahead automatic)
+
+
+others         n/a        single      
+
+
+=end