mmap-0.2.5

2 files changed, 505 insertions, 0 deletions

diff --git a/doc/b.rb b/doc/b.rb
new file mode 100755
index 0000000..0839bb3
--- /dev/null
+++ b/doc/b.rb
@@ -0,0 +1,109 @@
+#!/usr/bin/ruby
+
+def yield_or_not(primary)
+   text = primary.sub(/\{\s*\|([^|]+)\|[^}]*\}/, '')
+   if text != primary
+      "def #{text}yield #$1\nend"
+   else
+      "def #{text}end"
+   end
+end
+
+def normalize(text)
+   norm = text.gsub(/\(\(\|([^|]+)\|\)\)/, '<em>\\1</em>')
+   norm.gsub!(/\(\(\{/, '<tt>')
+   norm.gsub!(/\}\)\)/, '</tt>')
+   norm.gsub!(/\(\(<([^|>]+)[^>]*>\)\)/, '<em>\\1</em>')
+   norm.gsub!(/^\s*:\s/, ' * ')
+   norm
+end
+
+def intern_def(text, names, fout)
+   fout.puts "##{normalize(text.join('#'))}" 
+   fout.puts yield_or_not(names[0])
+   if names.size > 1
+      n = names[0].chomp.sub(/\(.*/, '')
+      names[1 .. -1].each do |na|
+	 nd = na.chomp.sub(/\(.*/, '')
+	 if nd != n
+	    fout.puts "#same than <em>#{n}</em>"
+	    fout.puts yield_or_not(na)
+	 end
+      end
+   end
+end
+
+def output_def(text, names, keywords, fout)
+   if ! names.empty?
+      keywords.each do |k|
+	 fout.puts k
+	 intern_def(text, names, fout)
+	 fout.puts "end" if k != ""
+      end
+   end
+end
+
+def loop_file(file, fout)
+   text, keywords, names = [], [""], []
+   comment = false
+   rep, indent, vide = '', -1, nil
+   IO.foreach(file) do |line|
+      if /^#\^/ =~ line
+	 comment = ! comment
+	 next
+      end
+      if comment
+	 fout.puts "# #{normalize(line)}"
+	 next
+      end
+      case line
+      when /^\s*$/
+	 vide = true
+	 text.push line
+      when /^#\^/
+	 comment = ! comment
+      when /^##/
+	 line[0] = ?\s
+	 fout.puts line
+      when /^#\s*(.+?)\s*$/
+	 keyword = $1
+	 output_def(text, names, keywords, fout)
+	 text, names = [], []
+	 keywords = keyword.split(/\s*##\s*/)
+	 if keywords.size == 1
+	    fout.puts keywords[0]
+	    keywords = [""]
+	 end
+      when /^#/
+      when /^---/
+	 name = $'
+	 if vide
+	    output_def(text, names, keywords, fout)
+	    text, names = [], []
+	    rep, indent, vide = '', -1, false
+	 end
+	 names.push name
+      else
+	 vide = false
+	 if line.sub!(/^(\s*): /, '* ')
+	    indent += ($1 <=> rep)
+	    rep = $1
+	 else
+	    line.sub!(/^#{rep}/, '')
+	 end
+	 if indent >= 0
+	    line = ('  ' * indent) + line
+	 else
+	    line.sub!(/\A\s*/, '')
+	 end
+	 text.push line
+      end
+   end
+end
+
+File.open("#{ARGV[0]}.rb", "w") do |fout|
+   loop_file("../#{ARGV[0]}.rd", fout)
+   Dir['*.rd'].each do |file|
+      loop_file(file, fout)
+   end
+end
diff --git a/doc/mmap.rb b/doc/mmap.rb
new file mode 100644
index 0000000..2c585a0
--- /dev/null
+++ b/doc/mmap.rb
@@ -0,0 +1,396 @@
+# The Mmap class implement memory-mapped file objects
+# 
+# Most of these methods have the same syntax than the methods of String
+#
+# === WARNING
+# === The variables $' and $` are not available with gsub! and sub!
+class Mmap
+   include Comparable
+   include Enumerable
+   class << self
+      
+      #disable paging of all pages mapped. <em>flag</em> can be 
+      #<em>Mmap::MCL_CURRENT</em> or <em>Mmap::MCL_FUTURE</em>
+      #
+      def  lockall(flag)
+      end
+      
+      #create a new Mmap object
+      #
+      #* <em>file</em>
+      #
+      #  Pathname of the file, if <em>nil</em> is given an anonymous map
+      #  is created <em>Mmanp::MAP_ANON</em>
+      #
+      #* <em>mode</em>
+      #
+      #  Mode to open the file, it can be "r", "w", "rw", "a"
+      #
+      #* <em>protection</em>
+      #
+      #  specify the nature of the mapping
+      #
+      #  * <em>Mmap::MAP_SHARED</em>
+      #
+      #    Creates a mapping that's shared with all other processes 
+      #    mapping the same areas of the file. 
+      #    The default value is <em>Mmap::MAP_SHARED</em>
+      #
+      #  * <em>Mmap::MAP_PRIVATE</em>
+      #
+      #    Creates a private copy-on-write mapping, so changes to the
+      #    contents of the mmap object will be private to this process
+      #
+      #* <em>options</em>
+      #
+      #  Hash. If one of the options <em>length</em> or <em>offset</em>
+      #  is specified it will not possible to modify the size of
+      #  the mapped file.
+      #
+      #  length:: maps <em>length</em> bytes from the file
+      #
+      #  offset:: the mapping begin at <em>offset</em>
+      #
+      #  advice:: the type of the access (see #madvise)
+      #
+      #
+      def  new(file, mode = "r", protection = Mmap::MAP_SHARED, options = {})
+      end
+      
+      #reenable paging
+      #
+      def  unlockall
+      end
+   end
+   
+   #add <em>count</em> bytes to the file (i.e. pre-extend the file) 
+   #
+   def  extend(count)
+   end
+   
+   #<em>advice</em> can have the value <em>Mmap::MADV_NORMAL</em>,
+   #<em>Mmap::MADV_RANDOM</em>, <em>Mmap::MADV_SEQUENTIAL</em>,
+   #<em>Mmap::MADV_WILLNEED</em>, <em>Mmap::MADV_DONTNEED</em>
+   #
+   def  madvise(advice)
+   end
+   
+   #change the mode, value must be "r", "w" or "rw"
+   #
+   def  mprotect(mode)
+   end
+   
+   #disable paging
+   #
+   def  mlock
+   end
+   
+   #flush the file
+   #
+   def  msync
+   end
+   #same than <em> msync</em>
+   def  flush
+   end
+   
+   #reenable paging
+   #
+   def  munlock
+   end
+   
+   #terminate the association
+   def  munmap
+   end
+   #
+   #=== Other methods with the same syntax than for the class String
+   #
+   #
+   
+   #comparison
+   #
+   def  ==(other) 
+   end
+   
+   #comparison
+   #
+   def  >(other)
+   end
+   
+   #comparison
+   #
+   def  >=(other)
+   end
+   
+   #comparison
+   #
+   def  <(other)
+   end
+   
+   #comparison
+   #
+   def  <=(other)
+   end
+   
+   #used for <em>case</em> comparison
+   #
+   def  ===(other)
+   end
+   
+   #append <em>other</em> to <em>self</em>
+   #
+   def  <<(other)
+   end
+   
+   #return an index of the match 
+   #
+   def  =~(other)
+   end
+   
+   #Element reference - with the following syntax
+   #
+   #self[nth] 
+   #
+   #retrieve the <em>nth</em> character
+   #
+   #self[start..last]
+   #
+   #return a substring from <em>start</em> to <em>last</em>
+   #
+   #self[start, length]
+   #
+   #return a substring of <em>lenght</em> characters from <em>start</em> 
+   #
+   def  [](args)
+   end
+   
+   
+   # Element assignement - with the following syntax
+   #
+   # self[nth] = val
+   #
+   # change the <em>nth</em> character with <em>val</em>
+   #
+   # self[start..last] = val
+   #
+   # change substring from <em>start</em> to <em>last</em> with <em>val</em>
+   #
+   # self[start, len] = val
+   #
+   # replace <em>length</em> characters from <em>start</em> with <em>val</em>.
+   #
+   def  []=(args) 
+   end
+   
+   #comparison : return -1, 0, 1
+   #
+   def  self <=> other 
+   end
+   
+   # only with ruby >= 1.7.1
+   def  casecmp(other)
+   end
+   
+   #append the contents of <em>other</em>
+   #
+   def  concat(other) 
+   end
+   
+   #change the first character to uppercase letter
+   #
+   def  capitalize!
+   end
+   
+   #chop off the last character
+   #
+   def  chop! 
+   end
+   
+   #chop off the  line ending character, specified by <em>rs</em>
+   #
+   def  chomp!(rs = $/) 
+   end
+   
+   #each parameter defines a set of character to count
+   #
+   def  count(o1 [, o2, ...])
+   end
+   
+   #crypt with <em>salt</em> 
+   #
+   def  crypt(salt)
+   end
+   
+   #delete every characters included in <em>str</em>
+   #
+   def  delete!(str) 
+   end
+   
+   #change all uppercase character to lowercase character
+   #
+   def  downcase! 
+   end
+   
+   #iterate on each byte
+   #
+   def  each_byte  
+      yield char
+   end
+   
+   #iterate on each line
+   #
+   def  each(rs = $/)  
+      yield line
+   end
+   #same than <em> each</em>
+   def  each_line(rs = $/)  
+      yield line
+   end
+   
+   #return <em>true</em> if the file is empty
+   #
+   def  empty? 
+   end
+   
+   #freeze the current file 
+   #
+   def  freeze
+   end
+   
+   #return <em>true</em> if the file is frozen
+   #
+   def  frozen 
+   end
+   
+   #global substitution
+   #
+   #str.gsub!(pattern, replacement)        => str or nil
+   #
+   #str.gsub!(pattern) {|match| block }    => str or nil
+   #
+   def  gsub!(pattern, replacement = nil)
+   end
+   
+   #return <em>true</em> if <em>other</em> is found
+   #
+   def  include?(other) 
+   end
+   
+   #return the index of <em>substr</em> 
+   #
+   def  index(substr[, pos])
+   end
+   
+   #insert <em>str</em> at <em>index</em>
+   #
+   def  insert(index, str) >= 1.7.1
+   end
+   
+   #return the size of the file
+   #
+   def  length 
+   end
+
+   #convert <em>pattern</em> to a <em>Regexp</em> and then call
+   #<em>match</em> on <em>self</em>
+   def  match(pattern)
+   end
+   
+   #reverse the content of the file 
+   #
+   def  reverse!
+   end
+   
+   #return the index of the last occurrence of <em>substr</em>
+   #
+   def  rindex(substr[, pos]) 
+   end
+   
+   #return an array of all occurence matched by <em>pattern</em> 
+   #
+   def  scan(pattern)
+   end
+   
+   #iterate through the file, matching the <em>pattern</em>
+   #
+   def  scan(pattern)  
+      yield str
+   end
+   
+   #return the size of the file
+   #
+   def  size 
+   end
+   
+   #same than <em>[]</em>
+   #
+   def  slice
+   end
+   
+   #delete the specified portion of the file
+   #
+   def  slice!
+   end
+   
+   #splits into a list of strings and return this array
+   #
+   def  split([sep[, limit]]) 
+   end
+   
+   #squeezes sequences of the same characters which is included in <em>str</em>
+   #
+   def  squeeze!([str]) 
+   end
+   
+   #removes leading and trailing whitespace
+   #
+   def  strip! 
+   end
+
+   #removes leading whitespace
+   #
+   def  lstrip! 
+   end
+
+   #removes trailing whitespace
+   #
+   def  rstrip! 
+   end
+   
+   #substitution 
+   #
+   #str.sub!(pattern, replacement)        => str or nil
+   #
+   #str.sub!(pattern) {|match| block }    => str or nil
+   #
+   #
+   def  sub!(pattern, replacement = nil)
+   end
+   
+   #return a checksum
+   #
+   def  sum(bits = 16) 
+   end
+   
+   #replaces all lowercase characters to uppercase characters, and vice-versa
+   #
+   def  swapcase! 
+   end
+   
+   #translate the character from <em>search</em> to <em>replace</em> 
+   #
+   def  tr!(search, replace)
+   end
+   
+   #translate the character from <em>search</em> to <em>replace</em>, then
+   #squeeze sequence of the same characters 
+   #
+   def  tr_s!(search, replace) 
+   end
+
+   #replaces all lowercase characters to downcase characters
+   #
+   def upcase! 
+   end
+
+
+end