1 files changed, 253 insertions, 0 deletions
diff --git a/doc/mmap.rd b/doc/mmap.rd
new file mode 100644
index 0000000..622ad89
--- /dev/null
+++ b/doc/mmap.rd
@@ -0,0 +1,253 @@
+=begin
+= Mmap
+
+((<Download|URL:ftp://moulon.inra.fr/pub/ruby/>))
+
+The Mmap class implement memory-mapped file objects
+
+=== WARNING
+=== The variables $' and $` are not available with gsub! and sub!
+
+== SuperClass
+
+Object
+
+== Included Modules
+
+* Comparable
+* Enumerable
+
+== Class Methods
+
+--- lockall(flag)
+      disable paging of all pages mapped. ((|flag|)) can be 
+      ((|Mmap::MCL_CURRENT|)) or ((|Mmap::MCL_FUTURE|))
+
+--- new(file, mode = "r", protection = Mmap::MAP_SHARED, options = {})
+--- new(nil, length, protection = Mmap::MAP_SHARED, options = {})
+      create a new Mmap object
+
+        : ((|file|))
+            Pathname of the file, if ((|nil|)) is given an anonymous map
+            is created ((|Mmanp::MAP_ANON|))
+
+        : ((|mode|))
+            Mode to open the file, it can be "r", "w", "rw", "a"
+
+        : ((|protection|))
+            specify the nature of the mapping
+
+               : ((|Mmap::MAP_SHARED|))
+                   Creates a mapping that's shared with all other processes 
+                   mapping the same areas of the file. 
+                   The default value is ((|Mmap::MAP_SHARED|))
+
+               : ((|Mmap::MAP_PRIVATE|))
+                   Creates a private copy-on-write mapping, so changes to the
+                   contents of the mmap object will be private to this process
+
+        : ((|options|))
+            Hash. If one of the options ((|length|)) or ((|offset|))
+            is specified it will not possible to modify the size of
+            the mapped file.
+
+               : ((|length|))
+                   Maps ((|length|)) bytes from the file
+
+               : ((|offset|))
+                   The mapping begin at ((|offset|))
+
+               : ((|advice|))
+                   The type of the access (see #madvise)
+
+
+--- unlockall
+     reenable paging
+
+== Methods
+
+--- extend(count)
+     add ((|count|)) bytes to the file (i.e. pre-extend the file) 
+
+--- madvise(advice)
+     ((|advice|)) can have the value ((|Mmap::MADV_NORMAL|)),
+     ((|Mmap::MADV_RANDOM|)), ((|Mmap::MADV_SEQUENTIAL|)),
+     ((|Mmap::MADV_WILLNEED|)), ((|Mmap::MADV_DONTNEED|))
+
+--- mprotect(mode)
+     change the mode, value must be "r", "w" or "rw"
+
+--- mlock
+     disable paging
+
+--- msync
+--- flush
+     flush the file
+
+--- munlock
+     reenable paging
+
+--- munmap
+     terminate the association
+
+=== Other methods with the same syntax than for the class String
+
+
+--- self == other 
+    comparison
+
+--- self > other 
+    comparison
+
+--- self >= other 
+    comparison
+
+--- self < other 
+    comparison
+
+--- self <= other 
+    comparison
+
+--- self === other 
+    used for ((|case|)) comparison
+
+--- self << other 
+    append ((|other|)) to ((|self|))
+
+--- self =~ other
+    return an index of the match 
+
+--- self[nth] 
+    retrieve the ((|nth|)) character
+
+--- self[start..last] 
+    return a substring from ((|start|)) to ((|last|))
+
+--- self[start, length]
+    return a substring of ((|lenght|)) characters from ((|start|)) 
+
+--- self[nth] = val 
+    change the ((|nth|)) character with ((|val|))
+
+--- self[start..last] = val 
+    change substring from ((|start|)) to ((|last|)) with ((|val|))
+
+--- self[start, len] = val 
+    replace ((|length|)) characters from ((|start|)) with ((|val|)).
+
+--- self <=> other 
+    comparison : return -1, 0, 1
+
+--- casecmp(other)   >= 1.7.1
+
+--- concat(other) 
+    append the contents of ((|other|))
+
+--- capitalize!
+    change the first character to uppercase letter
+
+--- chop! 
+    chop off the last character
+
+--- chomp!([rs]) 
+    chop off the  line ending character, specified by ((|rs|))
+
+--- count(o1 [, o2, ...])
+    each parameter defines a set of character to count
+
+--- crypt(salt)
+    crypt with ((|salt|)) 
+
+--- delete!(str) 
+    delete every characters included in ((|str|))
+
+--- downcase! 
+    change all uppercase character to lowercase character
+
+--- each_byte {|char|...} 
+    iterate on each byte
+
+--- each([rs]) {|line|...} 
+--- each_line([rs]) {|line|...} 
+    iterate on each line
+
+--- empty? 
+    return ((|true|)) if the file is empty
+
+--- freeze
+    freeze the current file 
+
+--- frozen 
+    return ((|true|)) if the file is frozen
+
+--- gsub!(pattern, replace) 
+    global substitution
+
+--- gsub!(pattern) {|str|...}
+    global substitution
+
+--- include?(other) 
+    return ((|true|)) if ((|other|)) is found
+
+--- index(substr[, pos])
+    return the index of ((|substr|)) 
+
+--- insert(index, str) >= 1.7.1
+    insert ((|str|)) at ((|index|))
+
+--- length 
+    return the size of the file
+
+--- reverse!
+    reverse the content of the file 
+
+--- rindex(substr[, pos]) 
+    return the index of the last occurrence of ((|substr|))
+
+--- scan(pattern)
+    return an array of all occurence matched by ((|pattern|)) 
+
+--- scan(pattern) {|str| ...} 
+    iterate through the file, matching the ((|pattern|))
+
+--- size 
+    return the size of the file
+
+--- slice
+    same than ((|[]|))
+
+--- slice!
+    delete the specified portion of the file
+
+--- split([sep[, limit]]) 
+    splits into a list of strings and return this array
+
+--- squeeze!([str]) 
+    squeezes sequences of the same characters which is included in ((|str|))
+
+--- strip! 
+    removes leading and trailing whitespace
+
+--- sub!(pattern, replace)
+    substitution 
+
+--- sub!(pattern) {|str| ...} 
+    substitution
+
+--- sum([bits]) 
+    return a checksum
+
+--- swapcase! 
+    replaces all lowercase characters to uppercase characters, and vice-versa
+
+--- tr!(search, replace)
+    translate the character from ((|search|)) to ((|replace|)) 
+
+--- tr_s!(search, replace) 
+    translate the character from ((|search|)) to ((|replace|)), then
+    squeeze sequence of the same characters 
+
+--- upcase! 
+    replaces all lowercase characters to downcase characters
+
+=end