stripped trailing spaces.

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

1 files changed, 202 insertions, 202 deletions

diff --git a/string.c b/string.c
index 4c3f53a68b..8460b8e5a0 100644
--- a/string.c
+++ b/string.c
@@ -57,7 +57,7 @@ VALUE rb_cSymbol;
 #define STR_UNSET_NOCAPA(s) do {\
     if (FL_TEST(s,STR_NOEMBED)) FL_UNSET(s,(ELTS_SHARED|STR_ASSOC));\
 } while (0)
-				    
+
 
 #define STR_SET_NOEMBED(str) do {\
     FL_SET(str, STR_NOEMBED);\
@@ -78,7 +78,7 @@ VALUE rb_cSymbol;
     else {\
 	RSTRING(str)->as.heap.len = (n);\
     }\
-} while (0) 
+} while (0)
 
 #define STR_DEC_LEN(str) do {\
     if (STR_EMBED_P(str)) {\
@@ -837,7 +837,7 @@ rb_str_resurrect(VALUE str)
 /*
  *  call-seq:
  *     String.new(str="")   => new_str
- *  
+ *
  *  Returns a new string object containing a copy of <i>str</i>.
  */
 
@@ -1000,7 +1000,7 @@ str_strlen(VALUE str, rb_encoding *enc)
  *  call-seq:
  *     str.length   => integer
  *     str.size     => integer
- *  
+ *
  *  Returns the character length of <i>str</i>.
  */
 
@@ -1016,7 +1016,7 @@ rb_str_length(VALUE str)
 /*
  *  call-seq:
  *     str.bytesize  => integer
- *  
+ *
  *  Returns the length of <i>str</i> in bytes.
  */
 
@@ -1029,9 +1029,9 @@ rb_str_bytesize(VALUE str)
 /*
  *  call-seq:
  *     str.empty?   => true or false
- *  
+ *
  *  Returns <code>true</code> if <i>str</i> has a length of zero.
- *     
+ *
  *     "hello".empty?   #=> false
  *     "".empty?        #=> true
  */
@@ -1047,10 +1047,10 @@ rb_str_empty(VALUE str)
 /*
  *  call-seq:
  *     str + other_str   => new_str
- *  
+ *
  *  Concatenation---Returns a new <code>String</code> containing
  *  <i>other_str</i> concatenated to <i>str</i>.
- *     
+ *
  *     "Hello from " + self.to_s   #=> "Hello from main"
  */
 
@@ -1078,10 +1078,10 @@ rb_str_plus(VALUE str1, VALUE str2)
 /*
  *  call-seq:
  *     str * integer   => new_str
- *  
+ *
  *  Copy---Returns a new <code>String</code> containing <i>integer</i> copies of
  *  the receiver.
- *     
+ *
  *     "Ho! " * 3   #=> "Ho! Ho! Ho! "
  */
 
@@ -1119,13 +1119,13 @@ rb_str_times(VALUE str, VALUE times)
 /*
  *  call-seq:
  *     str % arg   => new_str
- *  
+ *
  *  Format---Uses <i>str</i> as a format specification, and returns the result
  *  of applying it to <i>arg</i>. If the format specification contains more than
  *  one substitution, then <i>arg</i> must be an <code>Array</code> containing
  *  the values to be substituted. See <code>Kernel::sprintf</code> for details
  *  of the format string.
- *     
+ *
  *     "%05d" % 123                              #=> "00123"
  *     "%-5s: %08x" % [ "ID", self.object_id ]   #=> "ID   : 200e14d6"
  */
@@ -1865,11 +1865,11 @@ rb_str_append(VALUE str, VALUE str2)
  *     str.concat(integer)  => str
  *     str << obj           => str
  *     str.concat(obj)      => str
- *  
+ *
  *  Append---Concatenates the given object to <i>str</i>. If the object is a
  *  <code>Integer</code>, it is considered as a codepoint, and is converted
  *  to a character before concatenation.
- *     
+ *
  *     a = "hello "
  *     a << "world"   #=> "hello world"
  *     a.concat(33)   #=> "hello world!"
@@ -2226,7 +2226,7 @@ rb_str_cmp(VALUE str1, VALUE str2)
 /*
  *  call-seq:
  *     str == obj   => true or false
- *  
+ *
  *  Equality---If <i>obj</i> is not a <code>String</code>, returns
  *  <code>false</code>. Otherwise, returns <code>true</code> if <i>str</i>
  *  <code><=></code> <i>obj</i> returns zero.
@@ -2276,7 +2276,7 @@ rb_str_eql(VALUE str1, VALUE str2)
 /*
  *  call-seq:
  *     str <=> other_str   => -1, 0, +1
- *  
+ *
  *  Comparison---Returns -1 if <i>other_str</i> is greater than, 0 if
  *  <i>other_str</i> is equal to, and +1 if <i>other_str</i> is less than
  *  <i>str</i>. If the strings are of different lengths, and the strings are
@@ -2289,7 +2289,7 @@ rb_str_eql(VALUE str1, VALUE str2)
  *  <code><=</code>, <code>></code>, <code>>=</code>, and <code>between?</code>,
  *  included from module <code>Comparable</code>.  The method
  *  <code>String#==</code> does not use <code>Comparable#==</code>.
- *     
+ *
  *     "abcdef" <=> "abcde"     #=> 1
  *     "abcdef" <=> "abcdef"    #=> 0
  *     "abcdef" <=> "abcdefg"   #=> -1
@@ -2327,9 +2327,9 @@ rb_str_cmp_m(VALUE str1, VALUE str2)
 /*
  *  call-seq:
  *     str.casecmp(other_str)   => -1, 0, +1
- *  
+ *
  *  Case-insensitive version of <code>String#<=></code>.
- *     
+ *
  *     "abcdef".casecmp("abcde")     #=> 1
  *     "aBcDeF".casecmp("abcdef")    #=> 0
  *     "abcdef".casecmp("abcdefg")   #=> -1
@@ -2442,12 +2442,12 @@ rb_str_index(VALUE str, VALUE sub, long offset)
  *  call-seq:
  *     str.index(substring [, offset])   => fixnum or nil
  *     str.index(regexp [, offset])      => fixnum or nil
- *  
+ *
  *  Returns the index of the first occurrence of the given <i>substring</i> or
  *  pattern (<i>regexp</i>) in <i>str</i>. Returns <code>nil</code> if not
  *  found. If the second parameter is present, it specifies the position in the
  *  string to begin the search.
- *     
+ *
  *     "hello".index('e')             #=> 1
  *     "hello".index('lo')            #=> 3
  *     "hello".index('a')             #=> nil
@@ -2552,13 +2552,13 @@ rb_str_rindex(VALUE str, VALUE sub, long pos)
  *  call-seq:
  *     str.rindex(substring [, fixnum])   => fixnum or nil
  *     str.rindex(regexp [, fixnum])   => fixnum or nil
- *  
+ *
  *  Returns the index of the last occurrence of the given <i>substring</i> or
  *  pattern (<i>regexp</i>) in <i>str</i>. Returns <code>nil</code> if not
  *  found. If the second parameter is present, it specifies the position in the
  *  string to end the search---characters beyond this point will not be
  *  considered.
- *     
+ *
  *     "hello".rindex('e')             #=> 1
  *     "hello".rindex('l')             #=> 3
  *     "hello".rindex('a')             #=> nil
@@ -2627,13 +2627,13 @@ rb_str_rindex_m(int argc, VALUE *argv, VALUE str)
 /*
  *  call-seq:
  *     str =~ obj   => fixnum or nil
- *  
+ *
  *  Match---If <i>obj</i> is a <code>Regexp</code>, use it as a pattern to match
- *  against <i>str</i>,and returns the position the match starts, or 
+ *  against <i>str</i>,and returns the position the match starts, or
  *  <code>nil</code> if there is no match. Otherwise, invokes
  *  <i>obj.=~</i>, passing <i>str</i> as an argument. The default
  *  <code>=~</code> in <code>Object</code> returns <code>false</code>.
- *     
+ *
  *     "cat o' 9 tails" =~ /\d/   #=> 7
  *     "cat o' 9 tails" =~ 9      #=> nil
  */
@@ -2660,28 +2660,28 @@ static VALUE get_pat(VALUE, int);
 /*
  *  call-seq:
  *     str.match(pattern)   => matchdata or nil
- *  
+ *
  *  Converts <i>pattern</i> to a <code>Regexp</code> (if it isn't already one),
  *  then invokes its <code>match</code> method on <i>str</i>.  If the second
  *  parameter is present, it specifies the position in the string to begin the
  *  search.
- *     
+ *
  *     'hello'.match('(.)\1')      #=> #<MatchData "ll" 1:"l">
  *     'hello'.match('(.)\1')[0]   #=> "ll"
  *     'hello'.match(/(.)\1/)[0]   #=> "ll"
  *     'hello'.match('xx')         #=> nil
- *     
+ *
  *  If a block is given, invoke the block with MatchData if match succeed, so
  *  that you can write
- *     
+ *
  *     str.match(pat) {|m| ...}
- *     
+ *
  *  instead of
- *      
+ *
  *     if m = str.match(pat)
  *       ...
  *     end
- *      
+ *
  *  The return value is a value from block execution in this case.
  */
 
@@ -2840,7 +2840,7 @@ enc_succ_alnum_char(char *p, int len, rb_encoding *enc, char *carry)
  *  call-seq:
  *     str.succ   => new_str
  *     str.next   => new_str
- *  
+ *
  *  Returns the successor to <i>str</i>. The successor is calculated by
  *  incrementing characters starting from the rightmost alphanumeric (or
  *  the rightmost character if there are no alphanumerics) in the
@@ -2848,11 +2848,11 @@ enc_succ_alnum_char(char *p, int len, rb_encoding *enc, char *carry)
  *  incrementing a letter results in another letter of the same case.
  *  Incrementing nonalphanumerics uses the underlying character set's
  *  collating sequence.
- *     
+ *
  *  If the increment generates a ``carry,'' the character to the left of
  *  it is incremented. This process repeats until there is no carry,
  *  adding an additional character if necessary.
- *     
+ *
  *     "abcd".succ        #=> "abce"
  *     "THX1138".succ     #=> "THX1139"
  *     "<<koala>>".succ   #=> "<<koalb>>"
@@ -2939,7 +2939,7 @@ rb_str_succ(VALUE orig)
  *  call-seq:
  *     str.succ!   => str
  *     str.next!   => str
- *  
+ *
  *  Equivalent to <code>String#succ</code>, but modifies the receiver in
  *  place.
  */
@@ -2956,20 +2956,20 @@ rb_str_succ_bang(VALUE str)
 /*
  *  call-seq:
  *     str.upto(other_str, exclusive=false) {|s| block }   => str
- *  
+ *
  *  Iterates through successive values, starting at <i>str</i> and
  *  ending at <i>other_str</i> inclusive, passing each value in turn to
  *  the block. The <code>String#succ</code> method is used to generate
  *  each value.  If optional second argument exclusive is omitted or is <code>false</code>,
  *  the last value will be included; otherwise it will be excluded.
- *     
+ *
  *     "a8".upto("b6") {|s| print s, ' ' }
  *     for s in "a8".."b6"
  *       print s, ' '
  *     end
- *     
+ *
  *  <em>produces:</em>
- *     
+ *
  *     a8 a9 b0 b1 b2 b3 b4 b5 b6
  *     a8 a9 b0 b1 b2 b3 b4 b5 b6
  */
@@ -3005,7 +3005,7 @@ rb_str_upto(int argc, VALUE *argv, VALUE beg)
     }
     n = rb_str_cmp(beg, end);
     if (n > 0 || (excl && n == 0)) return beg;
-	
+
     after_end = rb_funcall(end, succ, 0, 0);
     current = beg;
     while (!rb_str_equal(current, after_end)) {
@@ -3090,7 +3090,7 @@ rb_str_aref(VALUE str, VALUE indx)
  *     str.slice(regexp)           => new_str or nil
  *     str.slice(regexp, fixnum)   => new_str or nil
  *     str.slice(other_str)        => new_str or nil
- *  
+ *
  *  Element Reference---If passed a single <code>Fixnum</code>, returns a
  *  substring of one character at that position. If passed two <code>Fixnum</code>
  *  objects, returns a substring starting at the offset given by the first, and
@@ -3099,14 +3099,14 @@ rb_str_aref(VALUE str, VALUE indx)
  *  an offset is negative, it is counted from the end of <i>str</i>. Returns
  *  <code>nil</code> if the initial offset falls outside the string, the length
  *  is negative, or the beginning of the range is greater than the end.
- *     
+ *
  *  If a <code>Regexp</code> is supplied, the matching portion of <i>str</i> is
  *  returned. If a numeric parameter follows the regular expression, that
  *  component of the <code>MatchData</code> is returned instead. If a
  *  <code>String</code> is given, that string is returned if it occurs in
  *  <i>str</i>. In both cases, <code>nil</code> is returned if there is no
  *  match.
- *     
+ *
  *     a = "hello there"
  *     a[1]                   #=> "e"
  *     a[1,3]                 #=> "ell"
@@ -3331,7 +3331,7 @@ rb_str_aset(VALUE str, VALUE indx, VALUE val)
  *     str[regexp] = new_str
  *     str[regexp, fixnum] = new_str
  *     str[other_str] = new_str
- *  
+ *
  *  Element Assignment---Replaces some or all of the content of <i>str</i>. The
  *  portion of the string affected is determined using the same criteria as
  *  <code>String#[]</code>. If the replacement string is not the same length as
@@ -3368,13 +3368,13 @@ rb_str_aset_m(int argc, VALUE *argv, VALUE str)
 /*
  *  call-seq:
  *     str.insert(index, other_str)   => str
- *  
+ *
  *  Inserts <i>other_str</i> before the character at the given
  *  <i>index</i>, modifying <i>str</i>. Negative indices count from the
  *  end of the string, and insert <em>after</em> the given character.
  *  The intent is insert <i>aString</i> so that it starts at the given
  *  <i>index</i>.
- *     
+ *
  *     "abcd".insert(0, 'X')    #=> "Xabcd"
  *     "abcd".insert(3, 'X')    #=> "abcXd"
  *     "abcd".insert(4, 'X')    #=> "abcdX"
@@ -3405,10 +3405,10 @@ rb_str_insert(VALUE str, VALUE idx, VALUE str2)
  *     str.slice!(range)            => new_str or nil
  *     str.slice!(regexp)           => new_str or nil
  *     str.slice!(other_str)        => new_str or nil
- *  
+ *
  *  Deletes the specified portion from <i>str</i>, and returns the portion
  *  deleted.
- *     
+ *
  *     string = "this is a string"
  *     string.slice!(2)        #=> "i"
  *     string.slice!(3..6)     #=> " is "
@@ -3471,7 +3471,7 @@ get_pat(VALUE pat, int quote)
  *  call-seq:
  *     str.sub!(pattern, replacement)          => str or nil
  *     str.sub!(pattern) {|match| block }      => str or nil
- *  
+ *
  *  Performs the substitutions of <code>String#sub</code> in place,
  *  returning <i>str</i>, or <code>nil</code> if no substitutions were
  *  performed.
@@ -3578,27 +3578,27 @@ rb_str_sub_bang(int argc, VALUE *argv, VALUE str)
  *  call-seq:
  *     str.sub(pattern, replacement)         => new_str
  *     str.sub(pattern) {|match| block }     => new_str
- *  
+ *
  *  Returns a copy of <i>str</i> with the <em>first</em> occurrence of
  *  <i>pattern</i> replaced with either <i>replacement</i> or the value of the
  *  block. The <i>pattern</i> will typically be a <code>Regexp</code>; if it is
  *  a <code>String</code> then no regular expression metacharacters will be
  *  interpreted (that is <code>/\d/</code> will match a digit, but
  *  <code>'\d'</code> will match a backslash followed by a 'd').
- *     
+ *
  *  If the method call specifies <i>replacement</i>, special variables such as
  *  <code>$&</code> will not be useful, as substitution into the string occurs
  *  before the pattern match starts. However, the sequences <code>\1</code>,
  *  <code>\2</code>, <code>\k<group_name></code>, etc., may be used.
- *     
+ *
  *  In the block form, the current match string is passed in as a parameter, and
  *  variables such as <code>$1</code>, <code>$2</code>, <code>$`</code>,
  *  <code>$&</code>, and <code>$'</code> will be set appropriately. The value
  *  returned by the block will be substituted for the match on each call.
- *     
+ *
  *  The result inherits any tainting in the original string or any supplied
  *  replacement string.
- *     
+ *
  *     "hello".sub(/[aeiou]/, '*')                  #=> "h*llo"
  *     "hello".sub(/([aeiou])/, '<\1>')             #=> "h<e>llo"
  *     "hello".sub(/./) {|s| s[0].ord.to_s + ' ' }  #=> "104 ello"
@@ -3625,7 +3625,7 @@ str_gsub(int argc, VALUE *argv, VALUE str, int bang)
     char *sp, *cp;
     int tainted = 0;
     rb_encoding *str_enc;
-    
+
     switch (argc) {
       case 1:
 	RETURN_ENUMERATOR(str, argc, argv);
@@ -3730,7 +3730,7 @@ str_gsub(int argc, VALUE *argv, VALUE str, int bang)
  *  call-seq:
  *     str.gsub!(pattern, replacement)        => str or nil
  *     str.gsub!(pattern) {|match| block }    => str or nil
- *  
+ *
  *  Performs the substitutions of <code>String#gsub</code> in place, returning
  *  <i>str</i>, or <code>nil</code> if no substitutions were performed.
  */
@@ -3746,29 +3746,29 @@ rb_str_gsub_bang(int argc, VALUE *argv, VALUE str)
  *  call-seq:
  *     str.gsub(pattern, replacement)       => new_str
  *     str.gsub(pattern) {|match| block }   => new_str
- *  
+ *
  *  Returns a copy of <i>str</i> with <em>all</em> occurrences of <i>pattern</i>
  *  replaced with either <i>replacement</i> or the value of the block. The
  *  <i>pattern</i> will typically be a <code>Regexp</code>; if it is a
  *  <code>String</code> then no regular expression metacharacters will be
  *  interpreted (that is <code>/\d/</code> will match a digit, but
  *  <code>'\d'</code> will match a backslash followed by a 'd').
- *     
+ *
  *  If a string is used as the replacement, special variables from the match
  *  (such as <code>$&</code> and <code>$1</code>) cannot be substituted into it,
  *  as substitution into the string occurs before the pattern match
  *  starts. However, the sequences <code>\1</code>, <code>\2</code>,
  *  <code>\k<group_name></code>, and so on may be used to interpolate
  *  successive groups in the match.
- *     
+ *
  *  In the block form, the current match string is passed in as a parameter, and
  *  variables such as <code>$1</code>, <code>$2</code>, <code>$`</code>,
  *  <code>$&</code>, and <code>$'</code> will be set appropriately. The value
  *  returned by the block will be substituted for the match on each call.
- *     
+ *
  *  The result inherits any tainting in the original string or any supplied
  *  replacement string.
- *     
+ *
  *     "hello".gsub(/[aeiou]/, '*')                  #=> "h*ll*"
  *     "hello".gsub(/([aeiou])/, '<\1>')             #=> "h<e>ll<o>"
  *     "hello".gsub(/./) {|s| s[0].ord.to_s + ' '}   #=> "104 101 108 108 111 "
@@ -3785,10 +3785,10 @@ rb_str_gsub(int argc, VALUE *argv, VALUE str)
 /*
  *  call-seq:
  *     str.replace(other_str)   => str
- *  
+ *
  *  Replaces the contents and taintedness of <i>str</i> with the corresponding
  *  values in <i>other_str</i>.
- *     
+ *
  *     s = "hello"         #=> "hello"
  *     s.replace "world"   #=> "world"
  */
@@ -3908,9 +3908,9 @@ rb_str_setbyte(VALUE str, VALUE index, VALUE value)
 /*
  *  call-seq:
  *     str.reverse   => new_str
- *  
+ *
  *  Returns a new string with the characters from <i>str</i> in reverse order.
- *     
+ *
  *     "stressed".reverse   #=> "desserts"
  */
 
@@ -3964,7 +3964,7 @@ rb_str_reverse(VALUE str)
 /*
  *  call-seq:
  *     str.reverse!   => str
- *  
+ *
  *  Reverses <i>str</i> in place.
  */
 
@@ -3995,10 +3995,10 @@ rb_str_reverse_bang(VALUE str)
 /*
  *  call-seq:
  *     str.include? other_str   => true or false
- *  
+ *
  *  Returns <code>true</code> if <i>str</i> contains the given string or
  *  character.
- *     
+ *
  *     "hello".include? "lo"   #=> true
  *     "hello".include? "ol"   #=> false
  *     "hello".include? ?h     #=> true
@@ -4020,13 +4020,13 @@ rb_str_include(VALUE str, VALUE arg)
 /*
  *  call-seq:
  *     str.to_i(base=10)   => integer
- *  
+ *
  *  Returns the result of interpreting leading characters in <i>str</i> as an
  *  integer base <i>base</i> (between 2 and 36). Extraneous characters past the
  *  end of a valid number are ignored. If there is not a valid number at the
  *  start of <i>str</i>, <code>0</code> is returned. This method never raises an
  *  exception.
- *     
+ *
  *     "12345".to_i             #=> 12345
  *     "99 red balloons".to_i   #=> 99
  *     "0a".to_i                #=> 0
@@ -4060,12 +4060,12 @@ rb_str_to_i(int argc, VALUE *argv, VALUE str)
 /*
  *  call-seq:
  *     str.to_f   => float
- *  
+ *
  *  Returns the result of interpreting leading characters in <i>str</i> as a
  *  floating point number. Extraneous characters past the end of a valid number
  *  are ignored. If there is not a valid number at the start of <i>str</i>,
  *  <code>0.0</code> is returned. This method never raises an exception.
- *     
+ *
  *     "123.45e1".to_f        #=> 1234.5
  *     "45.67 degrees".to_f   #=> 45.67
  *     "thx1138".to_f         #=> 0.0
@@ -4082,7 +4082,7 @@ rb_str_to_f(VALUE str)
  *  call-seq:
  *     str.to_s     => str
  *     str.to_str   => str
- *  
+ *
  *  Returns the receiver.
  */
 
@@ -4212,7 +4212,7 @@ rb_str_inspect(VALUE str)
 /*
  *  call-seq:
  *     str.dump   => new_str
- *  
+ *
  *  Produces a version of <i>str</i> with all nonprinting characters replaced by
  *  <code>\nnn</code> notation and all special characters escaped.
  */
@@ -4362,7 +4362,7 @@ rb_str_check_dummy_enc(rb_encoding *enc)
 /*
  *  call-seq:
  *     str.upcase!   => str or nil
- *  
+ *
  *  Upcases the contents of <i>str</i>, returning <code>nil</code> if no changes
  *  were made.
  *  Note: case replacement is effective only in ASCII region.
@@ -4423,12 +4423,12 @@ rb_str_upcase_bang(VALUE str)
 /*
  *  call-seq:
  *     str.upcase   => new_str
- *  
+ *
  *  Returns a copy of <i>str</i> with all lowercase letters replaced with their
  *  uppercase counterparts. The operation is locale insensitive---only
  *  characters ``a'' to ``z'' are affected.
  *  Note: case replacement is effective only in ASCII region.
- *     
+ *
  *     "hEllO".upcase   #=> "HELLO"
  */
 
@@ -4444,7 +4444,7 @@ rb_str_upcase(VALUE str)
 /*
  *  call-seq:
  *     str.downcase!   => str or nil
- *  
+ *
  *  Downcases the contents of <i>str</i>, returning <code>nil</code> if no
  *  changes were made.
  *  Note: case replacement is effective only in ASCII region.
@@ -4505,12 +4505,12 @@ rb_str_downcase_bang(VALUE str)
 /*
  *  call-seq:
  *     str.downcase   => new_str
- *  
+ *
  *  Returns a copy of <i>str</i> with all uppercase letters replaced with their
  *  lowercase counterparts. The operation is locale insensitive---only
  *  characters ``A'' to ``Z'' are affected.
  *  Note: case replacement is effective only in ASCII region.
- *     
+ *
  *     "hEllO".downcase   #=> "hello"
  */
 
@@ -4526,11 +4526,11 @@ rb_str_downcase(VALUE str)
 /*
  *  call-seq:
  *     str.capitalize!   => str or nil
- *  
+ *
  *  Modifies <i>str</i> by converting the first character to uppercase and the
  *  remainder to lowercase. Returns <code>nil</code> if no changes are made.
  *  Note: case conversion is effective only in ASCII region.
- *     
+ *
  *     a = "hello"
  *     a.capitalize!   #=> "Hello"
  *     a               #=> "Hello"
@@ -4574,11 +4574,11 @@ rb_str_capitalize_bang(VALUE str)
 /*
  *  call-seq:
  *     str.capitalize   => new_str
- *  
+ *
  *  Returns a copy of <i>str</i> with the first character converted to uppercase
  *  and the remainder to lowercase.
  *  Note: case conversion is effective only in ASCII region.
- *     
+ *
  *     "hello".capitalize    #=> "Hello"
  *     "HELLO".capitalize    #=> "Hello"
  *     "123ABC".capitalize   #=> "123abc"
@@ -4594,9 +4594,9 @@ rb_str_capitalize(VALUE str)
 
 
 /*
- *  call-seq: 
+ *  call-seq:
 *     str.swapcase!   => str or nil
- *  
+ *
  *  Equivalent to <code>String#swapcase</code>, but modifies the receiver in
  *  place, returning <i>str</i>, or <code>nil</code> if no changes were made.
  *  Note: case conversion is effective only in ASCII region.
@@ -4637,11 +4637,11 @@ rb_str_swapcase_bang(VALUE str)
 /*
  *  call-seq:
  *     str.swapcase   => new_str
- *  
+ *
  *  Returns a copy of <i>str</i> with uppercase alphabetic characters converted
  *  to lowercase and lowercase characters converted to uppercase.
  *  Note: case conversion is effective only in ASCII region.
- *     
+ *
  *     "Hello".swapcase          #=> "hELLO"
  *     "cYbEr_PuNk11".swapcase   #=> "CyBeR_pUnK11"
  */
@@ -4657,7 +4657,7 @@ rb_str_swapcase(VALUE str)
 typedef unsigned char *USTR;
 
 struct tr {
-    int gen; 
+    int gen;
     unsigned int now, max;
     char *p, *pend;
 };
@@ -4928,7 +4928,7 @@ tr_trans(VALUE str, VALUE src, VALUE repl, int sflag)
 	STR_SET_NOEMBED(str);
 	RSTRING(str)->as.heap.aux.capa = max;
     }
-    
+
     if (modify) {
 	if (cr != ENC_CODERANGE_BROKEN)
 	    ENC_CODERANGE_SET(str, cr);
@@ -4942,7 +4942,7 @@ tr_trans(VALUE str, VALUE src, VALUE repl, int sflag)
 /*
  *  call-seq:
  *     str.tr!(from_str, to_str)   => str or nil
- *  
+ *
  *  Translates <i>str</i> in place, using the same rules as
  *  <code>String#tr</code>. Returns <i>str</i>, or <code>nil</code> if no
  *  changes were made.
@@ -4958,14 +4958,14 @@ rb_str_tr_bang(VALUE str, VALUE src, VALUE repl)
 /*
  *  call-seq:
  *     str.tr(from_str, to_str)   => new_str
- *  
+ *
  *  Returns a copy of <i>str</i> with the characters in <i>from_str</i> replaced
  *  by the corresponding characters in <i>to_str</i>. If <i>to_str</i> is
  *  shorter than <i>from_str</i>, it is padded with its last character. Both
  *  strings may use the c1--c2 notation to denote ranges of characters, and
  *  <i>from_str</i> may start with a <code>^</code>, which denotes all
  *  characters except those listed.
- *     
+ *
  *     "hello".tr('aeiou', '*')    #=> "h*ll*"
  *     "hello".tr('^aeiou', '*')   #=> "*e**o"
  *     "hello".tr('el', 'ip')      #=> "hippo"
@@ -4981,7 +4981,7 @@ rb_str_tr(VALUE str, VALUE src, VALUE repl)
 }
 
 static void
-tr_setup_table(VALUE str, char stable[256], int first, 
+tr_setup_table(VALUE str, char stable[256], int first,
 	       VALUE *tablep, VALUE *ctablep, rb_encoding *enc)
 {
     const unsigned int errc = -1;
@@ -4993,7 +4993,7 @@ tr_setup_table(VALUE str, char stable[256], int first,
 
     tr.p = RSTRING_PTR(str); tr.pend = tr.p + RSTRING_LEN(str);
     tr.gen = tr.now = tr.max = 0;
-    
+
     if (RSTRING_LEN(str) > 1 && rb_enc_ascget(tr.p, tr.pend, &l, enc) == '^') {
 	cflag = 1;
 	tr.p += l;
@@ -5057,7 +5057,7 @@ tr_find(unsigned int c, char table[256], VALUE del, VALUE nodel)
 /*
  *  call-seq:
  *     str.delete!([other_str]+)   => str or nil
- *  
+ *
  *  Performs a <code>delete</code> operation in place, returning <i>str</i>, or
  *  <code>nil</code> if <i>str</i> was not modified.
  */
@@ -5127,11 +5127,11 @@ rb_str_delete_bang(int argc, VALUE *argv, VALUE str)
 /*
  *  call-seq:
  *     str.delete([other_str]+)   => new_str
- *  
+ *
  *  Returns a copy of <i>str</i> with all characters in the intersection of its
  *  arguments deleted. Uses the same rules for building the set of characters as
  *  <code>String#count</code>.
- *     
+ *
  *     "hello".delete "l","lo"        #=> "heo"
  *     "hello".delete "lo"            #=> "he"
  *     "hello".delete "aeiou", "^e"   #=> "hell"
@@ -5150,7 +5150,7 @@ rb_str_delete(int argc, VALUE *argv, VALUE str)
 /*
  *  call-seq:
  *     str.squeeze!([other_str]*)   => str or nil
- *  
+ *
  *  Squeezes <i>str</i> in place, returning either <i>str</i>, or
  *  <code>nil</code> if no changes were made.
  */
@@ -5231,16 +5231,16 @@ rb_str_squeeze_bang(int argc, VALUE *argv, VALUE str)
 }
 
 
-/* 
+/*
  *  call-seq:
  *     str.squeeze([other_str]*)    => new_str
- *  
+ *
  *  Builds a set of characters from the <i>other_str</i> parameter(s) using the
  *  procedure described for <code>String#count</code>. Returns a new string
  *  where runs of the same character that occur in this set are replaced by a
  *  single character. If no arguments are given, all runs of identical
  *  characters are replaced by a single character.
- *     
+ *
  *     "yellow moon".squeeze                  #=> "yelow mon"
  *     "  now   is  the".squeeze(" ")         #=> " now is the"
  *     "putters shoot balls".squeeze("m-z")   #=> "puters shot balls"
@@ -5258,7 +5258,7 @@ rb_str_squeeze(int argc, VALUE *argv, VALUE str)
 /*
  *  call-seq:
  *     str.tr_s!(from_str, to_str)   => str or nil
- *  
+ *
  *  Performs <code>String#tr_s</code> processing on <i>str</i> in place,
  *  returning <i>str</i>, or <code>nil</code> if no changes were made.
  */
@@ -5273,11 +5273,11 @@ rb_str_tr_s_bang(VALUE str, VALUE src, VALUE repl)
 /*
  *  call-seq:
  *     str.tr_s(from_str, to_str)   => new_str
- *  
+ *
  *  Processes a copy of <i>str</i> as described under <code>String#tr</code>,
  *  then removes duplicate characters in regions that were affected by the
  *  translation.
- *     
+ *
  *     "hello".tr_s('l', 'r')     #=> "hero"
  *     "hello".tr_s('el', '*')    #=> "h*o"
  *     "hello".tr_s('el', 'hx')   #=> "hhxo"
@@ -5295,12 +5295,12 @@ rb_str_tr_s(VALUE str, VALUE src, VALUE repl)
 /*
  *  call-seq:
  *     str.count([other_str]+)   => fixnum
- *  
+ *
  *  Each <i>other_str</i> parameter defines a set of characters to count.  The
  *  intersection of these sets defines the characters to count in
  *  <i>str</i>. Any <i>other_str</i> that starts with a caret (^) is
  *  negated. The sequence c1--c2 means all characters between c1 and c2.
- *     
+ *
  *     a = "hello world"
  *     a.count "lo"            #=> 5
  *     a.count "lo", "o"       #=> 2
@@ -5363,31 +5363,31 @@ rb_str_count(int argc, VALUE *argv, VALUE str)
 /*
  *  call-seq:
  *     str.split(pattern=$;, [limit])   => anArray
- *  
+ *
  *  Divides <i>str</i> into substrings based on a delimiter, returning an array
  *  of these substrings.
- *     
+ *
  *  If <i>pattern</i> is a <code>String</code>, then its contents are used as
  *  the delimiter when splitting <i>str</i>. If <i>pattern</i> is a single
  *  space, <i>str</i> is split on whitespace, with leading whitespace and runs
  *  of contiguous whitespace characters ignored.
- *     
+ *
  *  If <i>pattern</i> is a <code>Regexp</code>, <i>str</i> is divided where the
  *  pattern matches. Whenever the pattern matches a zero-length string,
  *  <i>str</i> is split into individual characters. If <i>pattern</i> contains
  *  groups, the respective matches will be returned in the array as well.
- *     
+ *
  *  If <i>pattern</i> is omitted, the value of <code>$;</code> is used.  If
  *  <code>$;</code> is <code>nil</code> (which is the default), <i>str</i> is
  *  split on whitespace as if ` ' were specified.
- *     
+ *
  *  If the <i>limit</i> parameter is omitted, trailing null fields are
  *  suppressed. If <i>limit</i> is a positive number, at most that number of
  *  fields will be returned (if <i>limit</i> is <code>1</code>, the entire
  *  string is returned as the only entry in an array). If negative, there is no
  *  limit to the number of fields returned, and trailing null fields are not
  *  suppressed.
- *     
+ *
  *     " now's  the time".split        #=> ["now's", "the", "time"]
  *     " now's  the time".split(' ')   #=> ["now's", "the", "time"]
  *     " now's  the time".split(/ /)   #=> ["", "now's", "", "the", "time"]
@@ -5395,7 +5395,7 @@ rb_str_count(int argc, VALUE *argv, VALUE str)
  *     "hello".split(//)               #=> ["h", "e", "l", "l", "o"]
  *     "hello".split(//, 3)            #=> ["h", "e", "llo"]
  *     "hi mom".split(%r{\s*})         #=> ["h", "i", "m", "o", "m"]
- *     
+ *
  *     "mellow yellow".split("ello")   #=> ["m", "w y", "w"]
  *     "1,2,,3,4,,".split(',')         #=> ["1", "2", "", "3", "4"]
  *     "1,2,,3,4,,".split(',', 4)      #=> ["1", "2", "", "3,4,,"]
@@ -5604,10 +5604,10 @@ rb_str_split(VALUE str, const char *sep0)
  *  call-seq:
  *     str.lines(separator=$/)   => anEnumerator
  *     str.lines(separator=$/) {|substr| block }        => str
- *  
+ *
  *  Returns an enumerator that gives each line in the string.  If a block is
  *  given, it iterates over each line in the string.
- *     
+ *
  *     "foo\nbar\n".lines.to_a   #=> ["foo\n", "bar\n"]
  *     "foo\nb ar".lines.sort    #=> ["b ar", "foo\n"]
  */
@@ -5616,21 +5616,21 @@ rb_str_split(VALUE str, const char *sep0)
  *  Document-method: each_line
  *  call-seq:
  *     str.each_line(separator=$/) {|substr| block }   => str
- *  
+ *
  *  Splits <i>str</i> using the supplied parameter as the record separator
  *  (<code>$/</code> by default), passing each substring in turn to the supplied
  *  block. If a zero-length record separator is supplied, the string is split
  *  into paragraphs delimited by multiple successive newlines.
- *     
+ *
  *     print "Example one\n"
  *     "hello\nworld".each {|s| p s}
  *     print "Example two\n"
  *     "hello\nworld".each('l') {|s| p s}
  *     print "Example three\n"
  *     "hello\n\n\nworld".each('') {|s| p s}
- *     
+ *
  *  <em>produces:</em>
- *     
+ *
  *     Example one
  *     "hello\n"
  *     "world"
@@ -5651,7 +5651,7 @@ rb_str_each_line(int argc, VALUE *argv, VALUE str)
     VALUE rs;
     unsigned int newline;
     char *p, *pend, *s, *ptr;
-    long len, rslen; 
+    long len, rslen;
     VALUE line;
     int n;
     VALUE orig = str;
@@ -5748,10 +5748,10 @@ rb_str_each_line(int argc, VALUE *argv, VALUE str)
  *  call-seq:
  *     str.bytes   => anEnumerator
  *     str.bytes {|fixnum| block }    => str
- *  
+ *
  *  Returns an enumerator that gives each byte in the string.  If a block is
  *  given, it iterates over each byte in the string.
- *     
+ *
  *     "hello".bytes.to_a        #=> [104, 101, 108, 108, 111]
  */
 
@@ -5759,13 +5759,13 @@ rb_str_each_line(int argc, VALUE *argv, VALUE str)
  *  Document-method: each_byte
  *  call-seq:
  *     str.each_byte {|fixnum| block }    => str
- *  
+ *
  *  Passes each byte in <i>str</i> to the given block.
- *     
+ *
  *     "hello".each_byte {|c| print c, ' ' }
- *     
+ *
  *  <em>produces:</em>
- *     
+ *
  *     104 101 108 108 111
  */
 
@@ -5787,10 +5787,10 @@ rb_str_each_byte(VALUE str)
  *  call-seq:
  *     str.chars                   => anEnumerator
  *     str.chars {|substr| block } => str
- *  
+ *
  *  Returns an enumerator that gives each character in the string.
  *  If a block is given, it iterates over each character in the string.
- *     
+ *
  *     "foo".chars.to_a   #=> ["f","o","o"]
  */
 
@@ -5798,14 +5798,14 @@ rb_str_each_byte(VALUE str)
  *  Document-method: each_char
  *  call-seq:
  *     str.each_char {|cstr| block }    => str
- *  
+ *
  *  Passes each character in <i>str</i> to the given block.
- *     
+ *
  *     "hello".each_char {|c| print c, ' ' }
- *     
+ *
  *  <em>produces:</em>
- *     
- *     h e l l o 
+ *
+ *     h e l l o
  */
 
 static VALUE
@@ -5832,12 +5832,12 @@ rb_str_each_char(VALUE str)
  *  call-seq:
  *     str.codepoints                   => anEnumerator
  *     str.codepoints {|fixnum| block } => str
- *  
+ *
  *  Returns an enumerator that gives the <code>Integer</code> ordinal
  *  of each character in the string, also known as a <i>codepoint</i>
  *  when applied to Unicode strings. If a block is given, it iterates
  *  over each character in the string.
- *     
+ *
  *     "foo\u0635".codepoints.to_a   #=> [102, 111, 111, 1589]
  */
 
@@ -5845,15 +5845,15 @@ rb_str_each_char(VALUE str)
  *  Document-method: each_codepoint
  *  call-seq:
  *     str.each_codepoint {|integer| block }    => str
- *  
+ *
  *  Passes the <code>Integer</code> ordinal of each character in <i>str</i>,
  *  also known as a <i>codepoint</i> when applied to Unicode strings to the
  *  given block.
- *     
+ *
  *     "hello\u0639".each_codepoint {|c| print c, ' ' }
- *     
+ *
  *  <em>produces:</em>
- *     
+ *
  *     104 101 108 108 111 1593
  */
 
@@ -5901,7 +5901,7 @@ chopped_length(VALUE str)
 /*
  *  call-seq:
  *     str.chop!   => str or nil
- *  
+ *
  *  Processes <i>str</i> as for <code>String#chop</code>, returning <i>str</i>,
  *  or <code>nil</code> if <i>str</i> is the empty string.  See also
  *  <code>String#chomp!</code>.
@@ -5925,13 +5925,13 @@ rb_str_chop_bang(VALUE str)
 /*
  *  call-seq:
  *     str.chop   => new_str
- *  
+ *
  *  Returns a new <code>String</code> with the last character removed.  If the
  *  string ends with <code>\r\n</code>, both characters are removed. Applying
  *  <code>chop</code> to an empty string returns an empty
  *  string. <code>String#chomp</code> is often a safer alternative, as it leaves
  *  the string unchanged if it doesn't end in a record separator.
- *     
+ *
  *     "string\r\n".chop   #=> "string"
  *     "string\n\r".chop   #=> "string\n"
  *     "string\n".chop     #=> "string"
@@ -5952,7 +5952,7 @@ rb_str_chop(VALUE str)
 /*
  *  call-seq:
  *     str.chomp!(separator=$/)   => str or nil
- *  
+ *
  *  Modifies <i>str</i> in place as described for <code>String#chomp</code>,
  *  returning <i>str</i>, or <code>nil</code> if no modifications were made.
  */
@@ -6060,13 +6060,13 @@ rb_str_chomp_bang(int argc, VALUE *argv, VALUE str)
 /*
  *  call-seq:
  *     str.chomp(separator=$/)   => new_str
- *  
+ *
  *  Returns a new <code>String</code> with the given record separator removed
  *  from the end of <i>str</i> (if present). If <code>$/</code> has not been
  *  changed from the default Ruby record separator, then <code>chomp</code> also
  *  removes carriage return characters (that is it will remove <code>\n</code>,
  *  <code>\r</code>, and <code>\r\n</code>).
- *     
+ *
  *     "hello".chomp            #=> "hello"
  *     "hello\n".chomp          #=> "hello"
  *     "hello\r\n".chomp        #=> "hello"
@@ -6087,11 +6087,11 @@ rb_str_chomp(int argc, VALUE *argv, VALUE str)
 /*
  *  call-seq:
  *     str.lstrip!   => self or nil
- *  
+ *
  *  Removes leading whitespace from <i>str</i>, returning <code>nil</code> if no
  *  change was made. See also <code>String#rstrip!</code> and
  *  <code>String#strip!</code>.
- *     
+ *
  *     "  hello  ".lstrip   #=> "hello  "
  *     "hello".lstrip!      #=> nil
  */
@@ -6110,7 +6110,7 @@ rb_str_lstrip_bang(VALUE str)
     /* remove spaces at head */
     while (s < e) {
 	unsigned int cc = rb_enc_codepoint(s, e, enc);
-	
+
 	if (!rb_enc_isspace(cc, enc)) break;
 	s += rb_enc_codelen(cc, enc);
     }
@@ -6128,10 +6128,10 @@ rb_str_lstrip_bang(VALUE str)
 /*
  *  call-seq:
  *     str.lstrip   => new_str
- *  
+ *
  *  Returns a copy of <i>str</i> with leading whitespace removed. See also
  *  <code>String#rstrip</code> and <code>String#strip</code>.
- *     
+ *
  *     "  hello  ".lstrip   #=> "hello  "
  *     "hello".lstrip       #=> "hello"
  */
@@ -6148,11 +6148,11 @@ rb_str_lstrip(VALUE str)
 /*
  *  call-seq:
  *     str.rstrip!   => self or nil
- *  
+ *
  *  Removes trailing whitespace from <i>str</i>, returning <code>nil</code> if
  *  no change was made. See also <code>String#lstrip!</code> and
  *  <code>String#strip!</code>.
- *     
+ *
  *     "  hello  ".rstrip   #=> "  hello"
  *     "hello".rstrip!      #=> nil
  */
@@ -6197,10 +6197,10 @@ rb_str_rstrip_bang(VALUE str)
 /*
  *  call-seq:
  *     str.rstrip   => new_str
- *  
+ *
  *  Returns a copy of <i>str</i> with trailing whitespace removed. See also
  *  <code>String#lstrip</code> and <code>String#strip</code>.
- *     
+ *
  *     "  hello  ".rstrip   #=> "  hello"
  *     "hello".rstrip       #=> "hello"
  */
@@ -6217,7 +6217,7 @@ rb_str_rstrip(VALUE str)
 /*
  *  call-seq:
  *     str.strip!   => str or nil
- *  
+ *
  *  Removes leading and trailing whitespace from <i>str</i>. Returns
  *  <code>nil</code> if <i>str</i> was not altered.
  */
@@ -6236,9 +6236,9 @@ rb_str_strip_bang(VALUE str)
 /*
  *  call-seq:
  *     str.strip   => new_str
- *  
+ *
  *  Returns a copy of <i>str</i> with leading and trailing whitespace removed.
- *     
+ *
  *     "    hello    ".strip   #=> "hello"
  *     "\tgoodbye\r\n".strip   #=> "goodbye"
  */
@@ -6293,29 +6293,29 @@ scan_once(VALUE str, VALUE pat, long *start)
  *  call-seq:
  *     str.scan(pattern)                         => array
  *     str.scan(pattern) {|match, ...| block }   => str
- *  
+ *
  *  Both forms iterate through <i>str</i>, matching the pattern (which may be a
  *  <code>Regexp</code> or a <code>String</code>). For each match, a result is
  *  generated and either added to the result array or passed to the block. If
  *  the pattern contains no groups, each individual result consists of the
  *  matched string, <code>$&</code>.  If the pattern contains groups, each
  *  individual result is itself an array containing one entry per group.
- *     
+ *
  *     a = "cruel world"
  *     a.scan(/\w+/)        #=> ["cruel", "world"]
  *     a.scan(/.../)        #=> ["cru", "el ", "wor"]
  *     a.scan(/(...)/)      #=> [["cru"], ["el "], ["wor"]]
  *     a.scan(/(..)(..)/)   #=> [["cr", "ue"], ["l ", "wo"]]
- *     
+ *
  *  And the block form:
- *     
+ *
  *     a.scan(/\w+/) {|w| print "<<#{w}>> " }
  *     print "\n"
  *     a.scan(/(.)(.)/) {|x,y| print y, x }
  *     print "\n"
- *     
+ *
  *  <em>produces:</em>
- *     
+ *
  *     <<cruel>> <<world>>
  *     rceu lowlr
  */
@@ -6355,11 +6355,11 @@ rb_str_scan(VALUE str, VALUE pat)
 /*
  *  call-seq:
  *     str.hex   => integer
- *  
+ *
  *  Treats leading characters from <i>str</i> as a string of hexadecimal digits
  *  (with an optional sign and an optional <code>0x</code>) and returns the
  *  corresponding number. Zero is returned on error.
- *     
+ *
  *     "0x0a".hex     #=> 10
  *     "-1234".hex    #=> -4660
  *     "0".hex        #=> 0
@@ -6381,11 +6381,11 @@ rb_str_hex(VALUE str)
 /*
  *  call-seq:
  *     str.oct   => integer
- *  
+ *
  *  Treats leading characters of <i>str</i> as a string of octal digits (with an
  *  optional sign) and returns the corresponding number.  Returns 0 if the
  *  conversion fails.
- *     
+ *
  *     "123".oct       #=> 83
  *     "-377".oct      #=> -255
  *     "bad".oct       #=> 0
@@ -6407,7 +6407,7 @@ rb_str_oct(VALUE str)
 /*
  *  call-seq:
  *     str.crypt(other_str)   => new_str
- *  
+ *
  *  Applies a one-way cryptographic hash to <i>str</i> by invoking the standard
  *  library function <code>crypt</code>. The argument is the salt string, which
  *  should be two characters long, each character drawn from
@@ -6450,10 +6450,10 @@ rb_str_crypt(VALUE str, VALUE salt)
  *  call-seq:
  *     str.intern   => symbol
  *     str.to_sym   => symbol
- *  
+ *
  *  Returns the <code>Symbol</code> corresponding to <i>str</i>, creating the
  *  symbol if it did not previously exist. See <code>Symbol#id2name</code>.
- *     
+ *
  *     "Koala".intern         #=> :Koala
  *     s = 'cat'.to_sym       #=> :cat
  *     s == :cat              #=> true
@@ -6462,7 +6462,7 @@ rb_str_crypt(VALUE str, VALUE salt)
  *
  *  This can also be used to create symbols that cannot be represented using the
  *  <code>:xxx</code> notation.
- *     
+ *
  *     'cat and dog'.to_sym   #=> :"cat and dog"
  */
 
@@ -6495,9 +6495,9 @@ rb_str_intern(VALUE s)
 /*
  *  call-seq:
  *     str.ord   => integer
- *  
+ *
  *  Return the <code>Integer</code> ordinal of a one-character string.
- *     
+ *
  *     "a".ord         #=> 97
  */
 
@@ -6512,7 +6512,7 @@ rb_str_ord(VALUE s)
 /*
  *  call-seq:
  *     str.sum(n=16)   => integer
- *  
+ *
  *  Returns a basic <em>n</em>-bit checksum of the characters in <i>str</i>,
  *  where <em>n</em> is the optional <code>Fixnum</code> parameter, defaulting
  *  to 16. The result is simply the sum of the binary value of each character in
@@ -6659,11 +6659,11 @@ rb_str_justify(int argc, VALUE *argv, VALUE str, char jflag)
 /*
  *  call-seq:
  *     str.ljust(integer, padstr=' ')   => new_str
- *  
+ *
  *  If <i>integer</i> is greater than the length of <i>str</i>, returns a new
  *  <code>String</code> of length <i>integer</i> with <i>str</i> left justified
  *  and padded with <i>padstr</i>; otherwise, returns <i>str</i>.
- *     
+ *
  *     "hello".ljust(4)            #=> "hello"
  *     "hello".ljust(20)           #=> "hello               "
  *     "hello".ljust(20, '1234')   #=> "hello123412341234123"
@@ -6679,11 +6679,11 @@ rb_str_ljust(int argc, VALUE *argv, VALUE str)
 /*
  *  call-seq:
  *     str.rjust(integer, padstr=' ')   => new_str
- *  
+ *
  *  If <i>integer</i> is greater than the length of <i>str</i>, returns a new
  *  <code>String</code> of length <i>integer</i> with <i>str</i> right justified
  *  and padded with <i>padstr</i>; otherwise, returns <i>str</i>.
- *     
+ *
  *     "hello".rjust(4)            #=> "hello"
  *     "hello".rjust(20)           #=> "               hello"
  *     "hello".rjust(20, '1234')   #=> "123412341234123hello"
@@ -6699,11 +6699,11 @@ rb_str_rjust(int argc, VALUE *argv, VALUE str)
 /*
  *  call-seq:
  *     str.center(integer, padstr)   => new_str
- *  
+ *
  *  If <i>integer</i> is greater than the length of <i>str</i>, returns a new
  *  <code>String</code> of length <i>integer</i> with <i>str</i> centered and
  *  padded with <i>padstr</i>; otherwise, returns <i>str</i>.
- *     
+ *
  *     "hello".center(4)         #=> "hello"
  *     "hello".center(20)        #=> "       hello        "
  *     "hello".center(20, '123') #=> "1231231hello12312312"
@@ -6718,11 +6718,11 @@ rb_str_center(int argc, VALUE *argv, VALUE str)
 /*
  *  call-seq:
  *     str.partition(sep)              => [head, sep, tail]
- *  
+ *
  *  Searches the string for <i>sep</i> and returns the part before
  *  it, the <i>sep</i>, and the part after it.  If <i>sep</i> is not found,
  *  returns <i>str</i> and two empty strings.
- *     
+ *
  *     "hello".partition("l")         #=> ["he", "l", "lo"]
  *     "hello".partition("x")         #=> ["hello", "", ""]
  */
@@ -6764,12 +6764,12 @@ rb_str_partition(VALUE str, VALUE sep)
 /*
  *  call-seq:
  *     str.rpartition(sep)            => [head, sep, tail]
- *  
+ *
  *  Searches <i>sep</i> in the string from the end of the string, and
  *  returns the part before it, the <i>sep</i>, and the part after it.
  *  If <i>sep</i> is not found, returns two empty strings and
  *  <i>str</i>.
- *     
+ *
  *     "hello".rpartition("l")         #=> ["hel", "l", "o"]
  *     "hello".rpartition("x")         #=> ["", "", "hello"]
  */
@@ -6809,7 +6809,7 @@ rb_str_rpartition(VALUE str, VALUE sep)
 /*
  *  call-seq:
  *     str.start_with?([prefix]+)   => true or false
- *  
+ *
  *  Returns true if <i>str</i> starts with the prefix given.
  */
 
@@ -6832,7 +6832,7 @@ rb_str_start_with(int argc, VALUE *argv, VALUE str)
 /*
  *  call-seq:
  *     str.end_with?([suffix]+)   => true or false
- *  
+ *
  *  Returns true if <i>str</i> ends with the suffix given.
  */
 
@@ -6887,7 +6887,7 @@ rb_str_force_encoding(VALUE str, VALUE enc)
 /*
  *  call-seq:
  *     str.valid_encoding?  => true or false
- *  
+ *
  *  Returns true for a string which encoded correctly.
  *
  *    "\xc2\xa1".force_encoding("UTF-8").valid_encoding? => true
@@ -6906,7 +6906,7 @@ rb_str_valid_encoding_p(VALUE str)
 /*
  *  call-seq:
  *     str.ascii_only?  => true or false
- *  
+ *
  *  Returns true for a string which has only ASCII characters.
  *
  *    "abc".force_encoding("UTF-8").ascii_only? => true
@@ -6935,7 +6935,7 @@ rb_str_is_ascii_only_p(VALUE str)
  *  one context, a method in another, and a class in a third, the
  *  <code>Symbol</code> <code>:Fred</code> will be the same object in
  *  all three contexts.
- *     
+ *
  *     module One
  *       class Fred
  *       end
@@ -6951,16 +6951,16 @@ rb_str_is_ascii_only_p(VALUE str)
  *     $f1.object_id   #=> 2514190
  *     $f2.object_id   #=> 2514190
  *     $f3.object_id   #=> 2514190
- *     
+ *
  */
 
 
 /*
  *  call-seq:
  *     sym == obj   => true or false
- *  
+ *
  *  Equality---If <i>sym</i> and <i>obj</i> are exactly the same
- *  symbol, returns <code>true</code>. 
+ *  symbol, returns <code>true</code>.
  */
 
 static VALUE
@@ -6986,9 +6986,9 @@ sym_printable(const char *s, const char *send, rb_encoding *enc)
 /*
  *  call-seq:
  *     sym.inspect    => string
- *  
+ *
  *  Returns the representation of <i>sym</i> as a symbol literal.
- *     
+ *
  *     :fred.inspect   #=> ":fred"
  */
 
@@ -7018,9 +7018,9 @@ sym_inspect(VALUE sym)
  *  call-seq:
  *     sym.id2name   => string
  *     sym.to_s      => string
- *  
+ *
  *  Returns the name or string corresponding to <i>sym</i>.
- *     
+ *
  *     :fred.id2name   #=> "fred"
  */
 
@@ -7208,13 +7208,13 @@ rb_to_id(VALUE name)
  *  A <code>String</code> object holds and manipulates an arbitrary sequence of
  *  bytes, typically representing characters. String objects may be created
  *  using <code>String::new</code> or as literals.
- *     
+ *
  *  Because of aliasing issues, users of strings should be aware of the methods
  *  that modify the contents of a <code>String</code> object.  Typically,
  *  methods with names ending in ``!'' modify their receiver, while those
  *  without a ``!'' return a new <code>String</code>.  However, there are
  *  exceptions, such as <code>String#[]=</code>.
- *     
+ *
  */
 
 void