reg 0.4.8 → 0.5.0a0

data/regbackref.rb

@@ -1,126 +0,0 @@
-=begin copyright
-    reg - the ruby extended grammar
-    Copyright (C) 2005  Caleb Clausen
-
-    This library is free software; you can redistribute it and/or
-    modify it under the terms of the GNU Lesser General Public
-    License as published by the Free Software Foundation; either
-    version 2.1 of the License, or (at your option) any later version.
-
-    This library is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-    Lesser General Public License for more details.
-
-    You should have received a copy of the GNU Lesser General Public
-    License along with this library; if not, write to the Free Software
-    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-=end
-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

@@ -1,74 +0,0 @@
-=begin copyright
-    reg - the ruby extended grammar
-    Copyright (C) 2005  Caleb Clausen
-
-    This library is free software; you can redistribute it and/or
-    modify it under the terms of the GNU Lesser General Public
-    License as published by the Free Software Foundation; either
-    version 2.1 of the License, or (at your option) any later version.
-
-    This library is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-    Lesser General Public License for more details.
-
-    You should have received a copy of the GNU Lesser General Public
-    License along with this library; if not, write to the Free Software
-    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-=end
-module Reg
-  module Reg
-    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/reggrid.csv

@@ -1 +0,0 @@
-Methods/classes	Reg	Or	And	Xor	Not	Hash	OrderedHash	Object	OrderedObject	Array	Fixed	Equals	Literal	Multiple	Interpreter	Subseq	Repeat	LookAhead	LookBack	Regexp	Module	Set	Range	Pair	Position
-		
+		
 	

data/reghash.rb

@@ -1,318 +0,0 @@
-
-=begin copyright
-    reg - the ruby extended grammar
-    Copyright (C) 2005  Caleb Clausen
-
-    This library is free software; you can redistribute it and/or
-    modify it under the terms of the GNU Lesser General Public
-    License as published by the Free Software Foundation; either
-    version 2.1 of the License, or (at your option) any later version.
-
-    This library is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-    Lesser General Public License for more details.
-
-    You should have received a copy of the GNU Lesser General Public
-    License along with this library; if not, write to the Free Software
-    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-=end
-
-
-require 'forward_to'
-
-
-
-module Reg
-
-  class Hash
-    include Reg
-    attr :others
-    
-    def initialize(hashdat=nil)
-      @matchers={}
-      @literals={}
-      @others=nil
-      hashdat or return 
-      hashdat.key?(OB) and @others=hashdat.delete(OB) 
-      hashdat.each {|key,val| 
-        if Reg.interesting_matcher? key
-          Fixed===key and key=key.unwrap
-          @matchers[key]=val
-        else
-          Equals===key and key=key.unwrap
-          @literals[key]=val
-        end
-      }    
-    end
-
-    def Hash.[](*args); new(*args); end
-
-    def matches_class; ::Hash end
-    
-    def ordered
-      pairs=[]
-      @literals.each{|k,v| pairs<< Pair[k,v] }
-      @matchers.each{|k,v| pairs<< Pair[k,v] }
-      pairs<<Pair[OB,@others] if @others
-      return +pairs
-    end
-
-    def subregs;
-      @literals.keys + @literals.values +
-      @matchers.keys + @matchers.values + 
-      (@others==nil ? [OB,@others] : [])
-    end
-    
-    def inspect
-      result=[]
-      result<<@literals.inspect.sub(/.(.*)./, "\\1") unless @literals.empty?
-      result<<@matchers.inspect.sub(/.(.*)./, "\\1") unless @matchers.empty?
-      result<<"OB=>#{@others.inspect}"  if defined? @others and @others!=nil
-      return "+{#{result.join(", ")}}"
-    end
-    
-    def -@ #make object matcher
-      Rob(@literals.merge(@matchers).merge(OB=>@others))
-    end
-    
-    def ===(other)
-      matchedliterals={}
-      matchedmatchers={}
-      other.each_pair{|key,val|
-        #literals get a chance first
-        @literals.key? key and 
-          if (@literals[key]===val)
-            matchedliterals[key]=true
-            next
-          else
-            return
-          end 
-        
-        #now try more general matchers
-        saw_matcher=nil
-        @matchers.each_pair{|mkey,mval|
-          if mkey===key
-            return unless (mval===val)
-            saw_matcher=matchedmatchers[mkey]=true
-            break 
-          end
-        }
-        
-        
-        #last of all, try the catchall
-        saw_matcher or @others===val or return
-      }
-      @literals.each_pair{|k,v| matchedliterals[k] or v==(other.default k) or return }
-      @matchers.each_pair{|k,v| matchedmatchers[k] or v===other.default or return }      
-      other.empty? and @literals.empty? and @matchers.empty? and return @others===other.default
-      return true
-    end
-
- #tla of +{}
-assign_TLAs :Rah=>:Hash
-   
-  end
-  
-  #--------------------------
-  class OrderedHash
-    include Reg
-    def initialize(*args)
-      @keys=[]
-      @vals=[]
-      @others=nil
-      args.each{|a|
-        if Pair===a
-          l,r=a.left,a.right
-          Fixed===l and l=l.unwrap
-          if l==OB
-            @others=r
-          else
-            @keys<<l
-            @vals<<r
-          end
-        else
-          @keys<<a
-          @vals<<OB
-        end
-      }
-    end
-  
-    def ===(other)
-      matched=0
-      saw1=nil
-      other.each_pair do |ko,vo|
-        saw1=nil
-        @vals.each_index do|i| 
-            kr,vr=@keys[i],@vals[i]
-            if kr===ko 
-              vr===vo or return
-              saw1=matched |= 1<<i
-              break
-            end 
-        end
-        saw1 or (@others===vo or return)
-      end
-      @vals.each_index {|i|
-        unless (matched&(1<<i)).nonzero?
-          @vals[i]===other.default((@keys[i] unless Reg::interesting_matcher? @keys[i])) or return
-        end
-      }
-      other.empty? and @vals.empty? and  return @others===other.default
-#      @subhashes.each do|subhash|
-#        subhash===other or return false
-#      end
-      return other||true #huh need more complex result?      
-    end
-    
-    def self.[](*args); new(*args); end
-
-    def matches_class; ::Hash end
-    
-    def &; huh end
-    def inspect; 
-      "+[#{
-        map{|k,v| k.inspect+ ((Reg===k)? "" : ".reg") +
-                    "**"+v.inspect unless OB==k && nil==v
-        }.compact.join ", "
-      }]"
-    end
-    def subregs; huh end
-    
-    def each
-      @keys.each_index{|i|
-        yield @keys[i],@vals[i]
-      }
-      yield OB,@others
-    end
-    include Enumerable
-    
-    
-    def to_ruby
-      result= "def self.===(a_hash)\n"
-      result<<"  a_hash.each_pair{|k,v|\n"
-      result<<"    case k\n"
-      @keys.each_index{|i|
-        result<<"    when #{@keys[i]}: #{vals[i]}\n"
-      }
-      result<<"    else #{@other}\n" +
-              "    end===v or break\n" +
-              "  }\n" +
-              "end\n"
-      
-      return result
-    end
-  end
-
-  #--------------------------
-  class Object < Hash
-  #decending from Hash isn't particularly useful here
-  #it looks like everything (but &) is overridden, anyway
-
-    def initialize(*args)
-      hash= (::Hash===args.last ? args.pop : {})
-      @vars={}; @meths={}; @meth_matchers={}
-      hash.each_pair{|item,val|
-        if ::String===item or ::Symbol===item
-          item=item.to_s
-          (/^@@?/===item ? @vars : @meths)[item.to_sym]=val
-        else 
-          @meth_matchers[item]=val
-        end
-      }
-      @meths[:class]=args.shift if (Module===args.first)
-    end
-    def self.[](*args) new(*args); end
-
-
-    def inspect
-        "-{"+@vars.inspect.sub( /^.(.*).$/, '\\1') + 
-            @meths.inspect.sub(/^.(.*).$/, '\\1') + 
-            @meth_matchers.inspect.sub(/^.(.*).$/, '\\1') + "}"
-
-    end
-
-    def matches_class
-      @meths[:class] or Object
-    end
-
-    def -@ #make object matcher
-      self
-    end
-
-    def ===(other)
-      seenmeths=[];seenvars=[];seenmats=[]
-      @meths.each_pair{|name,val|
-        val===other.send(name) or return
-        seenmeths<<name
-      }
-      @vars.each_pair{|name,val|
-        val===other.instance_eval(name.to_s) or return
-        seenvars<<name
-      }
-      @meth_matchers.empty? or other.public_methods.each {|meth|
-        @meth_matchers.each_pair{|name, val| 
-          if name===meth 
-            val===other.send(meth) || return
-            seenmats<< name
-          end
-        }
-      }
-      @meths.keys.-(seenmeths).empty? or return
-      @vars.keys.-(seenvars).empty? or return
-      @meth_matchers.keys.-(seenmats).empty? or return
-      
-
-      return other || true
-      
-    rescue
-      return false
-    end
-
-  #tla of -{}
-  assign_TLAs :Rob=>:Object
-
-
-  end
-  
-  
-  #OrderedObject not even attempted yet
-  
-  module Reg
-    def **(other)
-      Pair[self,other]
-    end
-    alias has **
-  end
-
-  class Pair
-    include Reg
-    class<<self; alias [] new; end
-    
-    attr_reader :left,:right
-    
-    def initialize(l,r)
-      @left,@right=l,r
-    end
-
-if false    #not sure if i know what i want here...
-    def hash_cmp(hash,k,v)
-      @left
-    end
-    
-    def obj_cmp
-    end
-end  
-    #tla of **
-    assign_TLAs :Rap=>:Pair
-
-
-    
-  end
-
-
-
-end
-
-
-