* hash.c: purged trailing spaces.

git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/branches/ruby_1_8@12655 b2dd03c8-39d4-4d8f-98ff-823fe69b080e

1 files changed, 116 insertions, 116 deletions

diff --git a/hash.c b/hash.c
index e943b0fd91..408bc860a7 100644
--- a/hash.c
+++ b/hash.c
@@ -165,7 +165,7 @@ hash_foreach_iter(key, value, arg)
     int status;
     st_table *tbl;
 
-    tbl = RHASH(arg->hash)->tbl;    
+    tbl = RHASH(arg->hash)->tbl;
     if (key == Qundef) return ST_CONTINUE;
     status = (*arg->func)(key, value, arg->arg);
     if (RHASH(arg->hash)->tbl != tbl) {
@@ -259,7 +259,7 @@ rb_hash_new()
  *     Hash.new                          => hash
  *     Hash.new(obj)                     => aHash
  *     Hash.new {|hash, key| block }     => aHash
- *  
+ *
  *  Returns a new, empty hash. If this hash is subsequently accessed by
  *  a key that doesn't correspond to a hash entry, the value returned
  *  depends on the style of <code>new</code> used to create the hash. In
@@ -269,7 +269,7 @@ rb_hash_new()
  *  called with the hash object and the key, and should return the
  *  default value. It is the block's responsibility to store the value
  *  in the hash if required.
- *     
+ *
  *     h = Hash.new("Go Fish")
  *     h["a"] = 100
  *     h["b"] = 200
@@ -279,14 +279,14 @@ rb_hash_new()
  *     h["c"].upcase!   #=> "GO FISH"
  *     h["d"]           #=> "GO FISH"
  *     h.keys           #=> ["a", "b"]
- *     
+ *
  *     # While this creates a new default object each time
  *     h = Hash.new { |hash, key| hash[key] = "Go Fish: #{key}" }
  *     h["c"]           #=> "Go Fish: c"
  *     h["c"].upcase!   #=> "GO FISH: C"
  *     h["d"]           #=> "Go Fish: d"
  *     h.keys           #=> ["c", "d"]
- *     
+ *
  */
 
 static VALUE
@@ -316,11 +316,11 @@ rb_hash_initialize(argc, argv, hash)
 /*
  *  call-seq:
  *     Hash[ [key =>|, value]* ]   => hash
- *  
+ *
  *  Creates a new hash populated with the given objects. Equivalent to
  *  the literal <code>{ <i>key</i>, <i>value</i>, ... }</code>. Keys and
  *  values occur in pairs, so there must be an even number of arguments.
- *     
+ *
  *     Hash["a", 100, "b", 200]       #=> {"a"=>100, "b"=>200}
  *     Hash["a" => 100, "b" => 200]   #=> {"a"=>100, "b"=>200}
  *     { "a" => 100, "b" => 200 }     #=> {"a"=>100, "b"=>200}
@@ -373,13 +373,13 @@ rb_hash_rehash_i(key, value, tbl)
 /*
  *  call-seq:
  *     hsh.rehash -> hsh
- *  
+ *
  *  Rebuilds the hash based on the current hash values for each key. If
  *  values of key objects have changed since they were inserted, this
  *  method will reindex <i>hsh</i>. If <code>Hash#rehash</code> is
  *  called while an iterator is traversing the hash, an
  *  <code>IndexError</code> will be raised in the iterator.
- *     
+ *
  *     a = [ "a", "b" ]
  *     c = [ "c", "d" ]
  *     h = { a => 100, c => 300 }
@@ -408,15 +408,15 @@ rb_hash_rehash(hash)
 /*
  *  call-seq:
  *     hsh[key]    =>  value
- *  
+ *
  *  Element Reference---Retrieves the <i>value</i> object corresponding
  *  to the <i>key</i> object. If not found, returns the a default value (see
  *  <code>Hash::new</code> for details).
- *     
+ *
  *     h = { "a" => 100, "b" => 200 }
  *     h["a"]   #=> 100
  *     h["c"]   #=> nil
- *     
+ *
  */
 
 VALUE
@@ -435,29 +435,29 @@ rb_hash_aref(hash, key)
  *  call-seq:
  *     hsh.fetch(key [, default] )       => obj
  *     hsh.fetch(key) {| key | block }   => obj
- *  
+ *
  *  Returns a value from the hash for the given key. If the key can't be
  *  found, there are several options: With no other arguments, it will
  *  raise an <code>IndexError</code> exception; if <i>default</i> is
  *  given, then that will be returned; if the optional code block is
  *  specified, then that will be run and its result returned.
- *     
+ *
  *     h = { "a" => 100, "b" => 200 }
  *     h.fetch("a")                            #=> 100
  *     h.fetch("z", "go fish")                 #=> "go fish"
  *     h.fetch("z") { |el| "go fish, #{el}"}   #=> "go fish, z"
- *     
+ *
  *  The following example shows that an exception is raised if the key
  *  is not found and a default value is not supplied.
- *     
+ *
  *     h = { "a" => 100, "b" => 200 }
  *     h.fetch("z")
- *     
+ *
  *  <em>produces:</em>
- *     
+ *
  *     prog.rb:2:in `fetch': key not found (IndexError)
  *      from prog.rb:2
- *     
+ *
  */
 
 static VALUE
@@ -489,19 +489,19 @@ rb_hash_fetch(argc, argv, hash)
 /*
  *  call-seq:
  *     hsh.default(key=nil)   => obj
- *  
+ *
  *  Returns the default value, the value that would be returned by
  *  <i>hsh</i>[<i>key</i>] if <i>key</i> did not exist in <i>hsh</i>.
  *  See also <code>Hash::new</code> and <code>Hash#default=</code>.
- *     
+ *
  *     h = Hash.new                            #=> {}
  *     h.default                               #=> nil
  *     h.default(2)                            #=> nil
- *     
+ *
  *     h = Hash.new("cat")                     #=> {}
  *     h.default                               #=> "cat"
  *     h.default(2)                            #=> "cat"
- *     
+ *
  *     h = Hash.new {|h,k| h[k] = k.to_i*10}   #=> {}
  *     h.default                               #=> 0
  *     h.default(2)                            #=> 20
@@ -526,11 +526,11 @@ rb_hash_default(argc, argv, hash)
 /*
  *  call-seq:
  *     hsh.default = obj     => hsh
- *  
+ *
  *  Sets the default value, the value returned for a key that does not
  *  exist in the hash. It is not possible to set the a default to a
  *  <code>Proc</code> that will be executed on each key lookup.
- *     
+ *
  *     h = { "a" => 100, "b" => 200 }
  *     h.default = "Go fish"
  *     h["a"]     #=> 100
@@ -556,10 +556,10 @@ rb_hash_set_default(hash, ifnone)
 /*
  *  call-seq:
  *     hsh.default_proc -> anObject
- *  
+ *
  *  If <code>Hash::new</code> was invoked with a block, return that
  *  block, otherwise return <code>nil</code>.
- *     
+ *
  *     h = Hash.new {|h,k| h[k] = k*k }   #=> {}
  *     p = h.default_proc                 #=> #<Proc:0x401b3d08@-:1>
  *     a = []                             #=> []
@@ -593,13 +593,13 @@ index_i(key, value, args)
 /*
  *  call-seq:
  *     hsh.index(value)    => key
- *  
+ *
  *  Returns the key for a given value. If not found, returns <code>nil</code>.
- *     
+ *
  *     h = { "a" => 100, "b" => 200 }
  *     h.index(200)   #=> "b"
  *     h.index(999)   #=> nil
- *     
+ *
  */
 
 static VALUE
@@ -620,9 +620,9 @@ rb_hash_index(hash, value)
  *  call-seq:
  *     hsh.indexes(key, ...)    => array
  *     hsh.indices(key, ...)    => array
- *  
+ *
  *  Deprecated in favor of <code>Hash#select</code>.
- *     
+ *
  */
 
 static VALUE
@@ -648,18 +648,18 @@ rb_hash_indexes(argc, argv, hash)
  *  call-seq:
  *     hsh.delete(key)                   => value
  *     hsh.delete(key) {| key | block }  => value
- *  
+ *
  *  Deletes and returns a key-value pair from <i>hsh</i> whose key is
  *  equal to <i>key</i>. If the key is not found, returns the
  *  <em>default value</em>. If the optional code block is given and the
  *  key is not found, pass in the key and return the result of
  *  <i>block</i>.
- *     
+ *
  *     h = { "a" => 100, "b" => 200 }
  *     h.delete("a")                              #=> 100
  *     h.delete("z")                              #=> nil
  *     h.delete("z") { |el| "#{el} not found" }   #=> "z not found"
- *     
+ *
  */
 
 VALUE
@@ -705,11 +705,11 @@ shift_i(key, value, var)
 /*
  *  call-seq:
  *     hsh.shift -> anArray or obj
- *  
+ *
  *  Removes a key-value pair from <i>hsh</i> and returns it as the
  *  two-item array <code>[</code> <i>key, value</i> <code>]</code>, or
  *  the hash's default value if the hash is empty.
- *     
+ *
  *     h = { 1 => "a", 2 => "b", 3 => "c" }
  *     h.shift   #=> [1, "a"]
  *     h         #=> {2=>"b", 3=>"c"}
@@ -750,13 +750,13 @@ delete_if_i(key, value, hash)
 /*
  *  call-seq:
  *     hsh.delete_if {| key, value | block }  -> hsh
- *  
+ *
  *  Deletes every key-value pair from <i>hsh</i> for which <i>block</i>
  *  evaluates to <code>true</code>.
- *     
+ *
  *     h = { "a" => 100, "b" => 200, "c" => 300 }
  *     h.delete_if {|key, value| key >= "b" }   #=> {"a"=>100}
- *     
+ *
  */
 
 VALUE
@@ -771,7 +771,7 @@ rb_hash_delete_if(hash)
 /*
  *  call-seq:
  *     hsh.reject! {| key, value | block }  -> hsh or nil
- *  
+ *
  *  Equivalent to <code>Hash#delete_if</code>, but returns
  *  <code>nil</code> if no changes were made.
  */
@@ -789,11 +789,11 @@ rb_hash_reject_bang(hash)
 /*
  *  call-seq:
  *     hsh.reject {| key, value | block }  -> a_hash
- *  
+ *
  *  Same as <code>Hash#delete_if</code>, but works on (and returns) a
  *  copy of the <i>hsh</i>. Equivalent to
  *  <code><i>hsh</i>.dup.delete_if</code>.
- *     
+ *
  */
 
 static VALUE
@@ -842,11 +842,11 @@ rb_hash_values_at(argc, argv, hash)
 /*
  *  call-seq:
  *     hsh.select {|key, value| block}   => array
- *  
+ *
  *  Returns a new array consisting of <code>[key,value]</code>
  *  pairs for which the block returns true.
  *  Also see <code>Hash.values_at</code>.
- *     
+ *
  *     h = { "a" => 100, "b" => 200, "c" => 300 }
  *     h.select {|k,v| k > "a"}  #=> [["b", 200], ["c", 300]]
  *     h.select {|k,v| v < 200}  #=> [["a", 100]]
@@ -873,12 +873,12 @@ clear_i(key, value, dummy)
 /*
  *  call-seq:
  *     hsh.clear -> hsh
- *  
+ *
  *  Removes all key-value pairs from <i>hsh</i>.
- *     
+ *
  *     h = { "a" => 100, "b" => 200 }   #=> {"a"=>100, "b"=>200}
  *     h.clear                          #=> {}
- *     
+ *
  */
 
 static VALUE
@@ -897,18 +897,18 @@ rb_hash_clear(hash)
  *  call-seq:
  *     hsh[key] = value        => value
  *     hsh.store(key, value)   => value
- *  
+ *
  *  Element Assignment---Associates the value given by
  *  <i>value</i> with the key given by <i>key</i>.
  *  <i>key</i> should not have its value changed while it is in
  *  use as a key (a <code>String</code> passed as a key will be
  *  duplicated and frozen).
- *     
+ *
  *     h = { "a" => 100, "b" => 200 }
  *     h["a"] = 9
  *     h["c"] = 4
  *     h   #=> {"a"=>9, "b"=>200, "c"=>4}
- *     
+ *
  */
 
 VALUE
@@ -939,13 +939,13 @@ replace_i(key, val, hash)
 /*
  *  call-seq:
  *     hsh.replace(other_hash) -> hsh
- *  
+ *
  *  Replaces the contents of <i>hsh</i> with the contents of
  *  <i>other_hash</i>.
- *     
+ *
  *     h = { "a" => 100, "b" => 200 }
  *     h.replace({ "c" => 300, "d" => 400 })   #=> {"c"=>300, "d"=>400}
- *     
+ *
  */
 
 static VALUE
@@ -971,9 +971,9 @@ rb_hash_replace(hash, hash2)
  *  call-seq:
  *     hsh.length    =>  fixnum
  *     hsh.size      =>  fixnum
- *  
+ *
  *  Returns the number of key-value pairs in the hash.
- *     
+ *
  *     h = { "d" => 100, "a" => 200, "v" => 300, "e" => 400 }
  *     h.length        #=> 4
  *     h.delete("a")   #=> 200
@@ -991,11 +991,11 @@ rb_hash_size(hash)
 /*
  *  call-seq:
  *     hsh.empty?    => true or false
- *  
+ *
  *  Returns <code>true</code> if <i>hsh</i> contains no key-value pairs.
- *     
+ *
  *     {}.empty?   #=> true
- *     
+ *
  */
 
 static VALUE
@@ -1019,15 +1019,15 @@ each_value_i(key, value)
 /*
  *  call-seq:
  *     hsh.each_value {| value | block } -> hsh
- *  
+ *
  *  Calls <i>block</i> once for each key in <i>hsh</i>, passing the
  *  value as a parameter.
- *     
+ *
  *     h = { "a" => 100, "b" => 200 }
  *     h.each_value {|value| puts value }
- *     
+ *
  *  <em>produces:</em>
- *     
+ *
  *     100
  *     200
  */
@@ -1052,15 +1052,15 @@ each_key_i(key, value)
 /*
  *  call-seq:
  *     hsh.each_key {| key | block } -> hsh
- *  
+ *
  *  Calls <i>block</i> once for each key in <i>hsh</i>, passing the key
  *  as a parameter.
- *     
+ *
  *     h = { "a" => 100, "b" => 200 }
  *     h.each_key {|key| puts key }
- *     
+ *
  *  <em>produces:</em>
- *     
+ *
  *     a
  *     b
  */
@@ -1084,18 +1084,18 @@ each_pair_i(key, value)
 /*
  *  call-seq:
  *     hsh.each_pair {| key_value_array | block } -> hsh
- *  
+ *
  *  Calls <i>block</i> once for each key in <i>hsh</i>, passing the key
  *  and value as parameters.
- *     
+ *
  *     h = { "a" => 100, "b" => 200 }
  *     h.each_pair {|key, value| puts "#{key} is #{value}" }
- *     
+ *
  *  <em>produces:</em>
- *     
+ *
  *     a is 100
  *     b is 200
- *     
+ *
  */
 
 static VALUE
@@ -1118,21 +1118,21 @@ each_i(key, value)
 /*
  *  call-seq:
  *     hsh.each {| key, value | block } -> hsh
- *  
+ *
  *  Calls <i>block</i> once for each key in <i>hsh</i>, passing the key
  *  and value to the block as a two-element array. Because of the assignment
  *  semantics of block parameters, these elements will be split out if the
  *  block has two formal parameters. Also see <code>Hash.each_pair</code>, which
  *  will be marginally more efficient for blocks with two parameters.
- *     
+ *
  *     h = { "a" => 100, "b" => 200 }
  *     h.each {|key, value| puts "#{key} is #{value}" }
- *     
+ *
  *  <em>produces:</em>
- *     
+ *
  *     a is 100
  *     b is 200
- *     
+ *
  */
 
 static VALUE
@@ -1155,10 +1155,10 @@ to_a_i(key, value, ary)
 /*
  *  call-seq:
  *     hsh.to_a -> array
- *  
+ *
  *  Converts <i>hsh</i> to a nested array of <code>[</code> <i>key,
  *  value</i> <code>]</code> arrays.
- *     
+ *
  *     h = { "c" => 300, "a" => 100, "d" => 400, "c" => 300  }
  *     h.to_a   #=> [["a", 100], ["c", 300], ["d", 400]]
  */
@@ -1178,17 +1178,17 @@ rb_hash_to_a(hash)
 
 /*
  *  call-seq:
- *     hsh.sort                    => array 
- *     hsh.sort {| a, b | block }  => array 
- * 
+ *     hsh.sort                    => array
+ *     hsh.sort {| a, b | block }  => array
+ *
  *  Converts <i>hsh</i> to a nested array of <code>[</code> <i>key,
  *  value</i> <code>]</code> arrays and sorts it, using
  *  <code>Array#sort</code>.
- *     
+ *
  *     h = { "a" => 20, "b" => 30, "c" => 10  }
  *     h.sort                       #=> [["a", 20], ["b", 30], ["c", 10]]
  *     h.sort {|a,b| a[1]<=>b[1]}   #=> [["c", 10], ["a", 20], ["b", 30]]
- *     
+ *
  */
 
 static VALUE
@@ -1262,12 +1262,12 @@ to_s_hash(hash)
 /*
  *  call-seq:
  *     hsh.to_s   => string
- *  
+ *
  *  Converts <i>hsh</i> to a string by converting the hash to an array
  *  of <code>[</code> <i>key, value</i> <code>]</code> pairs and then
  *  converting that array to a string using <code>Array#join</code> with
  *  the default separator.
- *     
+ *
  *     h = { "c" => 300, "a" => 100, "d" => 400, "c" => 300  }
  *     h.to_s   #=> "a100c300d400"
  */
@@ -1306,13 +1306,13 @@ keys_i(key, value, ary)
 /*
  *  call-seq:
  *     hsh.keys    => array
- *  
+ *
  *  Returns a new array populated with the keys from this hash. See also
  *  <code>Hash#values</code>.
- *     
+ *
  *     h = { "a" => 100, "b" => 200, "c" => 300, "d" => 400 }
  *     h.keys   #=> ["a", "b", "c", "d"]
- *     
+ *
  */
 
 static VALUE
@@ -1339,13 +1339,13 @@ values_i(key, value, ary)
 /*
  *  call-seq:
  *     hsh.values    => array
- *  
+ *
  *  Returns a new array populated with the values from <i>hsh</i>. See
  *  also <code>Hash#keys</code>.
- *     
+ *
  *     h = { "a" => 100, "b" => 200, "c" => 300 }
  *     h.values   #=> [100, 200, 300]
- *     
+ *
  */
 
 static VALUE
@@ -1366,13 +1366,13 @@ rb_hash_values(hash)
  *     hsh.include?(key)    => true or false
  *     hsh.key?(key)        => true or false
  *     hsh.member?(key)     => true or false
- *  
+ *
  *  Returns <code>true</code> if the given key is present in <i>hsh</i>.
- *     
+ *
  *     h = { "a" => 100, "b" => 200 }
  *     h.has_key?("a")   #=> true
  *     h.has_key?("z")   #=> false
- *     
+ *
  */
 
 static VALUE
@@ -1402,10 +1402,10 @@ rb_hash_search_value(key, value, data)
  *  call-seq:
  *     hsh.has_value?(value)    => true or false
  *     hsh.value?(value)        => true or false
- *  
+ *
  *  Returns <code>true</code> if the given value is present for some key
  *  in <i>hsh</i>.
- *     
+ *
  *     h = { "a" => 100, "b" => 200 }
  *     h.has_value?(100)   #=> true
  *     h.has_value?(999)   #=> false
@@ -1480,12 +1480,12 @@ hash_equal(hash1, hash2, eql)
 /*
  *  call-seq:
  *     hsh == other_hash    => true or false
- *  
+ *
  *  Equality---Two hashes are equal if they each contain the same number
  *  of keys and if each key-value pair is equal to (according to
  *  <code>Object#==</code>) the corresponding elements in the other
  *  hash.
- *     
+ *
  *     h1 = { "a" => 1, "c" => 2 }
  *     h2 = { 7 => 35, "c" => 2, "a" => 1 }
  *     h3 = { "a" => 1, "c" => 2, 7 => 35 }
@@ -1493,7 +1493,7 @@ hash_equal(hash1, hash2, eql)
  *     h1 == h2   #=> false
  *     h2 == h3   #=> true
  *     h3 == h4   #=> false
- *     
+ *
  */
 
 static VALUE
@@ -1516,13 +1516,13 @@ rb_hash_invert_i(key, value, hash)
 /*
  *  call-seq:
  *     hsh.invert -> aHash
- *  
+ *
  *  Returns a new hash created by using <i>hsh</i>'s values as keys, and
  *  the keys as values.
- *     
+ *
  *     h = { "n" => 100, "m" => 100, "y" => 300, "d" => 200, "a" => 0 }
  *     h.invert   #=> {0=>"a", 100=>"n", 200=>"d", 300=>"y"}
- *     
+ *
  */
 
 static VALUE
@@ -1564,10 +1564,10 @@ rb_hash_update_block_i(key, value, hash)
  *     hsh.update(other_hash)                                 => hsh
  *     hsh.merge!(other_hash){|key, oldval, newval| block}    => hsh
  *     hsh.update(other_hash){|key, oldval, newval| block}    => hsh
- *  
+ *
  *  Adds the contents of <i>other_hash</i> to <i>hsh</i>, overwriting
  *  entries with duplicate keys with those from <i>other_hash</i>.
- *     
+ *
  *     h1 = { "a" => 100, "b" => 200 }
  *     h2 = { "b" => 254, "c" => 300 }
  *     h1.merge!(h2)   #=> {"a"=>100, "b"=>254, "c"=>300}
@@ -1591,16 +1591,16 @@ rb_hash_update(hash1, hash2)
  *  call-seq:
  *     hsh.merge(other_hash)                              -> a_hash
  *     hsh.merge(other_hash){|key, oldval, newval| block} -> a_hash
- *  
+ *
  *  Returns a new hash containing the contents of <i>other_hash</i> and
  *  the contents of <i>hsh</i>, overwriting entries in <i>hsh</i> with
  *  duplicate keys with those from <i>other_hash</i>.
- *     
+ *
  *     h1 = { "a" => 100, "b" => 200 }
  *     h2 = { "b" => 254, "c" => 300 }
  *     h1.merge(h2)   #=> {"a"=>100, "b"=>254, "c"=>300}
  *     h1             #=> {"a"=>100, "b"=>200}
- *     
+ *
  */
 
 static VALUE
@@ -2105,7 +2105,7 @@ env_clear()
 {
     volatile VALUE keys;
     long i;
-    
+
     rb_secure(4);
     keys = env_keys();
 
@@ -2400,15 +2400,15 @@ env_update(env, hash)
  *  arbitrary keys of any object type, not an integer index. The order
  *  in which you traverse a hash by either key or value may seem
  *  arbitrary, and will generally not be in the insertion order.
- *     
+ *
  *  Hashes have a <em>default value</em> that is returned when accessing
  *  keys that do not exist in the hash. By default, that value is
  *  <code>nil</code>.
- *  
+ *
  *  <code>Hash</code> uses <code>key.eql?</code> to test keys for equality.
  *  If you need to use instances of your own classes as keys in a <code>Hash</code>,
  *  it is recommended that you define both the <code>eql?</code> and <code>hash</code>
- *  methods. The <code>hash</code> method must have the property that 
+ *  methods. The <code>hash</code> method must have the property that
  *  <code>a.eql?(b)</code> implies <code>a.hash == b.hash</code>.
  *
  *    class MyClass
@@ -2423,17 +2423,17 @@ env_update(env, hash)
  *        @str.hash
  *      end
  *    end
- *    
+ *
  *    a = MyClass.new("some string")
  *    b = MyClass.new("some string")
  *    a.eql? b  #=> true
- *    
+ *
  *    h = {}
- *    
+ *
  *    h[a] = 1
  *    h[a]      #=> 1
  *    h[b]      #=> 1
- *    
+ *
  *    h[b] = 2
  *    h[a]      #=> 2
  *    h[b]      #=> 2