rwdaddresses 0.8

data/ev/ruby.rb

@@ -0,0 +1,819 @@
+require "cgi"
+require "rbconfig"
+require "thread"
+
+Thread.abort_on_exception	= true
+
+$DEBUG	= ($DEBUG or ENV["RUBYDEBUG"] or false)
+
+#tekens	= '\w\~\@\#\$\%\^\&\*\-\+'
+tekens		= '^\s\r\n\`\!\(\)\[\]\{\}\<\>\,\.\/\?\\\|\=\;\:\"'
+
+#tekens11	= '\w'
+tekens11	= tekens + "'"
+
+tekens21	= tekens + "'"
+tekens22	= tekens
+tekens23	= tekens + "'"
+
+tekens31	= '\w\s\r\n'
+
+RegExpStringWord	= "([#{tekens11}]+)"									; RegExpWord	= Regexp.new(RegExpStringWord)
+RegExpStringWord2	= "([#{tekens21}]([#{tekens22}]*[#{tekens23}])?)"					; RegExpWord2	= Regexp.new(RegExpStringWord2)
+RegExpStringText	= "([#{tekens31}]+)"									; RegExpText	= Regexp.new(RegExpStringText)
+RegExpStringFile	= '(\w[\w\.\-]*)'									; RegExpFile	= Regexp.new(RegExpStringFile)
+RegExpStringEmail	= '([\w\-\.]+@[\w\-\.]+)'								; RegExpEmail	= Regexp.new(RegExpStringEmail)
+RegExpStringURL		= '(\w+:\/\/[\w\.\-]+(:\d*)?\/[\w\.\-\/\#\?\=\%]*)'					; RegExpURL	= Regexp.new(RegExpStringURL)
+RegExpStringPrint	= '([\w \t\r\n\`\~\!\@\#\$\%\^\&\*\(\)\-\+\=\[\]\{\}\;\:\'\"\,\.\/\<\>\?\\\|]+)'	; RegExpPrint	= Regexp.new(RegExpStringPrint)
+RegExpStringDiff	= '(^[\-\+]([^\-\+].*)?)'								; RegExpDiff	= Regexp.new(RegExpStringDiff)
+
+module Enumerable
+  def deep_dup
+    Marshal::load(Marshal::dump(dup))
+  end
+
+  def deep_clone
+    Marshal::load(Marshal::dump(clone))
+  end
+end
+
+class Thread
+  def self.background(*args)
+    new(*args) do |*args|
+      Thread.pass
+
+      yield(*args)
+    end
+  end
+end
+
+class Object
+  alias deep_dup :dup
+  alias deep_clone :clone
+
+  def to_fs
+    to_s
+  end
+
+  def ids
+    id
+  end
+end
+
+class Numeric
+  def to_fs
+    to_f
+  end
+end
+
+class Integer
+  def oct
+    n	= self
+    res	= []
+
+    while n > 8
+      n, x	= n.divmod(8)
+      res << x
+    end
+    res << n
+
+    res.reverse.join("")
+  end
+end
+
+class String
+  def chomp!(dummy=nil)
+    self.gsub!(/[\r\n]*\z/, "")
+  end
+
+  def chomp(dummy=nil)
+    self.gsub(/[\r\n]*\z/, "")
+  end
+
+  def lf
+    self.gsub(/\r*\n/, "\n").gsub(/\n\z/, "") + "\n"
+  end
+
+  def crlf
+    self.gsub(/\r*\n/, "\r\n").gsub(/\r\n\z/, "") + "\r\n"
+  end
+
+  def strip
+    self.stripbefore.stripafter
+  end
+
+  def stripbefore
+    self.gsub(/\A[[:blank:]\r\n]*/, "")
+  end
+
+  def stripafter
+    self.gsub(/[[:blank:]\r\n]*\z/, "")
+  end
+
+  def compress
+    self.gsub(/[[:blank:]\r\n]+/, " ").strip
+  end
+
+  def compressspaces
+    self.gsub(/[[:blank:]]+/, " ")
+  end
+
+  def compressperline
+    res	= self.split(/\n/)
+    res.collect!{|line| line.compress}
+    res.delete_if{|line| line.empty?}
+    res.join("\n")
+  end
+
+  def numeric?
+    d, a, n	= [self].to_par
+
+    not n.empty?
+  end
+
+  def exec(input=nil, output=true)
+    res	= []
+
+    IO.popen(self, "w+") do |f|
+      f.puts input	unless input.nil?
+      f.close_write
+
+      res	= f.readlines if output
+    end
+
+    res.join("")
+  end
+
+  def eval
+    Kernel::eval(self)
+  end
+
+  def speak
+    require "drb"
+
+    DRb.start_service
+    DRbObject.new(nil, "druby://localhost:3100").speak(self)
+  end
+
+  def splitblocks(*delimiters)
+    begindelimiters	= []
+    enddelimiters	= []
+
+    delimiters.each do |k, v|
+      begindelimiters	<< k.downcase
+      enddelimiters	<< v.downcase
+    end
+
+    bd	= begindelimiters.collect	{|s| Regexp.escape(s)}
+    ed	= enddelimiters.collect		{|s| Regexp.escape(s)}
+
+    be	= bd.join("|")
+    ee	= ed.join("|")
+
+    res		= []
+    type	= 0
+    tmp		= ""
+    bs		= ""
+    es		= ""
+
+    self.split(/(#{ee}|#{be})/i).each do |s|
+      if type == 0
+        if begindelimiters.include?(s.downcase)
+          i	= begindelimiters.index(s.downcase)
+          type	= i+1
+          tmp	= s
+          bs	= s.downcase
+          es	= enddelimiters[i]
+        else
+          res << [0, s]	unless s.empty?
+        end
+      else
+        if s.downcase == es
+          res << [type, tmp + s]
+          type	= 0
+          tmp	= ""
+          bs	= ""
+          es	= ""
+        else
+          if s.downcase == bs
+            res << [0, tmp]
+            tmp	= s
+          else
+            tmp	= tmp + s
+          end
+        end
+      end
+    end
+
+    res << [0, tmp]	unless tmp.empty?
+
+    return res
+  end
+
+  def splitwords(tokens=[])
+    tokens	= [tokens]	unless tokens.kind_of?(Array)
+    res		= []
+
+    self.splitblocks(["'", "'"], ['"', '"']).each do |type, s|
+      case type
+      when 0
+        tokens.each do |token|
+          token2	= token
+          token2	= Regexp.escape(token2)	if token2.kind_of?(String)
+          s.gsub!(/#{token2}/, " #{token} ")
+        end
+        s.split().each do |w|
+          res << w
+        end
+      when 1, 2
+        res << s[1..-2]
+      end
+    end
+
+    return res
+  end
+
+  def uncomment
+    res	= []
+
+    self.splitblocks(["'", "'"], ['"', '"'], ["#", "\n"]).each do |type, s|
+      case type
+      when 0, 1, 2	then	res << s
+      when 3		then	res << "\n"
+      end
+    end
+
+    res.join("")
+  end
+
+  def noquotes
+    self.sub(/\A['"]/, "").sub(/['"]\z/, "")
+  end
+
+  def to_html(eolconversion=true)
+    s	= CGI.escapeHTML(self)
+
+    s.gsub!(/\"/, "\&#34;")
+    s.gsub!(/\'/, "\&#180;")
+
+    if eolconversion
+      s.gsub!(/\n/ , "<br>")
+    end
+
+    s
+  end
+
+  def from_html(eolconversion=true)
+    s	= self
+
+    s.gsub!(/&#34;/ , "\"")
+    s.gsub!(/&#180;/, "\'")
+
+    s	= CGI.unescapeHTML(self)
+
+    if eolconversion
+      s.gsub!(/<br>/, "\n")
+    end
+
+    s
+  end
+
+  def to_fs
+    if numeric?
+      to_f
+    else
+      to_s
+    end
+  end
+end
+
+class Array
+  def chomp!
+    self.collect!{|s| s.chomp}
+  end
+
+  def chomp
+    self.collect{|s| s.chomp}
+  end
+
+  def compress
+    self.collect{|s| s.compress}
+  end
+
+  def uncomment
+    self.join("\0").uncomment.split("\0")
+  end
+
+  def strip
+    self.collect{|s| s.strip}
+  end
+
+  def sum
+    res	= 0
+    self.each do |n|
+      res += n
+    end
+    res
+  end
+
+  def product
+    res	= 1
+    self.each do |n|
+      res *= n
+    end
+    res
+  end
+
+  def joinwords(sep=" ", quote='"')
+    self.collect do |s|
+      s	= quote + s + quote	if s =~ /[[:blank:]]/
+      s
+    end.join(sep)
+  end
+
+  def domino(tabellen, kolom=nil, onlymatchinglines=false)
+    links	= self
+    res		= []
+    res		= self.dup	unless onlymatchinglines
+
+    tabellen.each do |rechts|
+      tmp	= []
+
+      links.each do |l|
+        if kolom.nil? or l.length == kolom
+          rechts.each do |r|
+            tmp << l + r[1..-1]	if l[-1] == r[0]
+          end
+        end
+      end
+
+      links	= tmp
+      res.concat(tmp)
+    end
+
+    res	= res.sort.uniq
+  end
+
+  def dominoloop(tabellen)
+    lres	= []
+    res		= self.dup
+    kolom	= 2
+
+    while lres.length != res.length do
+      lres	= res.dup
+      res	= res.domino(tabellen, kolom)
+
+      res.each do |line|
+        line << "*"	if (line.length != line.uniq.length and line[-1] != "*")
+      end
+
+      $stderr.print "#{100*(res.length)/(lres.length)}% "
+
+      kolom += 1
+    end
+
+    $stderr.puts ""
+
+    return res
+  end
+
+  def buildtree
+    self.dominoloop([self])
+  end
+
+  def subset(fields, values, results, exact=true, emptyline=nil, joinwith=nil)
+    fields	= [fields]		unless fields.kind_of? Array
+    values	= [values]		unless values.kind_of? Array
+    results	= [results]		unless results.kind_of? Array
+    emptyline	= emptyline.downcase	unless emptyline.nil?
+    res		= self.dup
+    res.delete_if {true}
+
+    self.each do |l|
+      ok	= true
+
+      case l.class.to_s
+      when "String"
+        c		= l.splitwords
+        correction	= 1
+        joinwith	= " "	if joinwith.nil?
+      when "Array"
+        c		= l
+        correction	= 0
+      end
+
+      #catch :stop do
+        values2	= values.dup
+        fields.each do |f|
+          v	= values2.shift
+          v	= v.downcase	unless v.nil?
+          if emptyline.nil? or (not v == emptyline)
+            if exact
+              unless (v.nil? or c[f-correction].downcase == v)
+                ok	= false
+                #throw :stop
+              end
+            else
+              unless (v.nil? or c[f-correction].downcase.include?(v))
+                ok	= false
+                #throw :stop
+              end
+            end
+          end
+        end
+      #end
+
+      if ok
+        res2	= []
+        results.each do |n|
+          res2 << c[n-1]
+        end
+        res2	= res2.join(joinwith)	unless joinwith.nil?
+        res << res2
+      end
+    end
+
+    return res
+  end
+
+  def format(format)
+    res		= []
+
+    [format.length, self.length].min.times do |n|
+      case format[n].chr
+      when "i"	then res << self[n].to_i
+      when "s"	then res << self[n].to_s
+      when "x"	then res << self[n]
+      end
+    end
+
+    res
+  end
+
+  def to_i
+    collect{|c| c.to_i}
+  end
+
+  def to_par
+    dash	= self.dup
+    alpha	= self.dup
+    numeric	= self.dup
+
+    dash.delete_if do |s|
+      not (s =~ /\A-/) or
+      (s =~ /\A-?[[:digit:]\.]+\z/) or
+      (s =~ /^-+$/)
+    end
+
+    alpha.delete_if do |s|
+      ((s =~ /\A-/) or
+       (s =~ /\A-?[[:digit:]\.]+\z/)) and
+      not ((s =~ /^\.+$/) or (s =~ /^-+$/))
+    end
+
+    numeric.delete_if do |s|
+      not (s =~ /\A-?[[:digit:]\.]+\z/) or
+      (s =~ /^\.+$/)
+    end
+
+    raise "Oops!"	if dash.length + alpha.length + numeric.length != length
+
+    return dash, alpha, numeric
+  end
+
+  def self.file(file)
+    res	= new
+
+    File.open(file) do |f|
+      f.readlines.uncomment.chomp.each do |line|
+        res << line
+      end
+    end
+
+    res
+  end
+
+  def numsort
+    sort do |a, b|
+      a2	= a.to_fs
+      b2	= b.to_fs
+
+      if a2.class != b2.class
+        a2	= a
+        b2	= b
+      end
+
+      a2 <=> b2
+    end
+  end
+
+  def to_fs
+    collect{|s| s.to_fs}
+  end
+
+  def chaos
+    res	= self.dup
+
+    (length^2).times do
+      a	= rand(length)
+      b	= rand(length)
+
+      res[a], res[b]	= res[b], res[a]
+    end
+
+    res
+  end
+
+  def any
+    if empty?
+      nil
+    else
+      self[rand(self.length)]
+    end
+  end
+
+  def minmax
+    min, value, max	= self
+    [min, [value, max].min].max
+  end
+
+  def ids
+    collect{|e| e.ids}
+  end
+end
+
+class Hash
+  def save(file, append=false)
+    org	= {}
+    org	= Hash.file(file)	if (append and File.file?(file))
+
+    self.sort.each do |k, v|
+      org[k]	= v
+    end
+
+    File.open(file, "w") do |f|
+      org.sort.each do |k, v|
+        f.puts "%s\t= %s" % [k, v]
+      end
+    end
+  end
+
+  def subset(fields, values, results=nil, exact=true, emptyline=nil, joinwith=nil)
+    fields	= [fields]		unless fields.kind_of? Array
+    values	= [values]		unless values.kind_of? Array
+    results	= [results]		unless results.kind_of? Array
+    emptyline	= emptyline.downcase	unless emptyline.nil?
+    res		= self.dup
+    res.delete_if {true}
+
+    self.each do |k, l|
+      ok	= true
+
+      case l.class.to_s
+      when "String"
+        c		= l.splitwords
+        correction	= 1
+        joinwith	= " "	if joinwith.nil?
+      when "Array"
+        c		= l
+        correction	= 0
+      end
+
+      #catch :stop do
+        values2	= values.dup
+        fields.each do |f|
+          v	= values2.shift
+          v	= v.downcase	unless v.nil?
+          if emptyline.nil? or (not v == emptyline)
+            if exact
+              unless (v.nil? or c[f-correction].downcase == v)
+                ok	= false
+                #throw :stop
+              end
+            else
+              unless (v.nil? or c[f-correction].downcase.include?(v))
+                ok	= false
+                #throw :stop
+              end
+            end
+          end
+        end
+      #end
+
+      if ok
+        res2	= []
+        if results == [nil]
+          res2	= c
+        else
+          results.each do |n|
+            res2 << c[n-correction]
+          end
+        end
+        res2	= res2.join(joinwith)	unless joinwith.nil?
+        res[k]	= res2
+      end
+    end
+
+    return res
+  end
+
+  def to_i
+    collect{|k, v| v.to_i}
+  end
+
+  def self.file(file)
+    res	= new
+
+    File.open(file) do |f|
+      #f.readlines.chomp.each do |line|
+      while line = f.gets do
+        line.chomp!
+
+        unless line.empty?
+          k, v	= line.split(/\s*=\s*/, 2)
+          res[k]	= v
+        end
+      end
+    end
+
+    res
+  end
+
+  def ids
+    collect{|k, v| [k, v].ids}
+  end
+end
+
+def id2ref(id)
+  ObjectSpace._id2ref(id)
+end
+
+def after(seconds, *args)
+  if not seconds.nil? and not seconds.zero?
+    Thread.new(*args) do |*args2|
+      sleep seconds
+      yield(*args2)
+    end
+  end
+end
+
+def every(seconds, *args)
+  if not seconds.nil? and not seconds.zero?
+    Thread.new(*args) do |*args2|
+      loop do
+        sleep seconds
+        yield(*args2)
+      end
+    end
+  end
+end
+
+def evtimeout(seconds)
+  begin
+    timeout(seconds) do
+      yield
+    end
+  rescue TimeoutError
+  end
+end
+
+def evtimeoutretry(seconds)
+  ok	= false
+
+  while not ok
+    evtimeout(seconds) do
+      yield
+      ok	= true
+    end
+  end
+end
+
+def trap(signal)
+  Kernel::trap(signal) do
+    yield
+  end
+
+	# Seems pointless, but it's for catching ^C under Windows...
+
+  every(1)	{}	if windows?
+end
+
+def linux?
+  not windows? and not cygwin?
+end
+
+def windows?
+  not (target_os.downcase =~ /32/).nil?
+end
+
+def cygwin?
+  not (target_os.downcase =~ /cyg/).nil?
+end
+
+def target_os
+  Config::CONFIG["target_os"] or ""
+end
+
+def user
+  ENV["USER"] or ENV["USERNAME"]
+end
+
+def home
+  (ENV["HOME"] or ENV["USERPROFILE"] or (File.directory?("h:/") ? "h:" : "c:")).gsub(/\\/, "/")
+end
+
+def temp
+  (ENV["TMPDIR"] or ENV["TMP"] or ENV["TEMP"] or "/tmp").gsub(/\\/, "/")
+end
+
+def stdtmp
+  $stderr = $stdout = File.new("#{temp}/ruby.#{Process.pid}.log", "a")	unless ARGV.include?("--rwd-exit")
+end
+
+$nobm	= false
+
+def nobm
+  $nobm	= true
+end
+
+def bm(label="")
+  if $nobm
+    if block_given?
+      return yield
+    else
+      return nil
+    end
+  end
+
+  label	= label.to_s
+  res	= nil
+
+  $bm_mutex	= ($bm_mutex or Mutex.new)
+
+  $bm_mutex.synchronize do
+    if $bm.nil?
+      require "ev/bm"
+
+      $bm		= {}
+
+      at_exit do
+	format1	= "%10s %10s %10s %10s %10s %10s %10s"
+	format2	= "%10s %10.6f %10.6f %10.6f %10.6f %10.6f %10d"
+
+	$stderr.puts format1 % ["LABEL", "USERCPU", "SYSCPU", "CUSERCPU", "CSYSCPU", "ELAPSED", "TIMES"]
+	$bm.sort{|a, b| [a[1], a[0]] <=> [b[1], b[0]]}.each do |k, v|
+	  $stderr.puts format2 % [k, *v]
+	end
+      end
+    end
+
+    $bm[label] = [0.0]*5 + [0]	unless $bm.include?(label)
+  end
+
+  if block_given?
+    bm	= Benchmark.measure{res = yield}
+    bma	= bm.to_a	# [dummy label, user CPU time, system CPU time, childrens user CPU time, childrens system CPU time, elapsed real time]
+
+    $bm_mutex.synchronize do
+      0.upto(4) do |n|
+        $bm[label][n] += bma[n+1]
+      end
+
+      $bm[label][5] += 1
+    end
+  end
+
+  res
+end
+
+def trace
+  res	=nil
+
+  set_trace_func lambda { |event, file, line, id, binding, classname|
+    $stderr.printf "%8s %s:%-2d %10s %8s\n", event, file, line, id, classname
+  }
+
+  if block_given?
+    res	= yield
+
+    notrace
+  end
+
+  res
+end
+
+def notrace
+  set_trace_func nil
+end
+
+def lambda_cached(&block)
+  hash	= {}
+  lambda do |*args|
+    res	= hash[args]
+    if res.nil?
+      res		= block.call(*args)
+      hash[args]	= res
+    end
+    res
+  end
+end