ruby-changes:10975
From: nobu <ko1@a...>
Date: Sun, 22 Feb 2009 23:27:15 +0900 (JST)
Subject: [ruby-changes:10975] Ruby:r22553 (trunk): stripped trailing spaces.
nobu 2009-02-22 23:26:27 +0900 (Sun, 22 Feb 2009) New Revision: 22553 http://svn.ruby-lang.org/cgi-bin/viewvc.cgi?view=rev&revision=22553 Log: stripped trailing spaces. Modified files: trunk/string.c Index: string.c =================================================================== --- string.c (revision 22552) +++ string.c (revision 22553) @@ -57,8 +57,8 @@ #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);\ STR_SET_EMBED_LEN(str, 0);\ @@ -78,7 +78,7 @@ 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 @@ /* * call-seq: * String.new(str="") => new_str - * + * * Returns a new string object containing a copy of <i>str</i>. */ @@ -1000,7 +1000,7 @@ * call-seq: * str.length => integer * str.size => integer - * + * * Returns the character length of <i>str</i>. */ @@ -1016,7 +1016,7 @@ /* * call-seq: * str.bytesize => integer - * + * * Returns the length of <i>str</i> in bytes. */ @@ -1029,9 +1029,9 @@ /* * 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 @@ /* * 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 @@ /* * 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 @@ /* * 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 @@ * 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 @@ /* * 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 @@ /* * 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 @@ * <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 @@ /* * 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 @@ * 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 @@ * 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 @@ /* * 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 @@ /* * 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 @@ * 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 @@ * 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 @@ * call-seq: * str.succ! => str * str.next! => str - * + * * Equivalent to <code>String#succ</code>, but modifies the receiver in * place. */ @@ -2956,20 +2956,20 @@ /* * 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 @@ } 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 @@ * 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 @@ * 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 @@ * 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 @@ /* * 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 @@ * 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 @@ * 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 @@ * 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 @@ char *sp, *cp; int tainted = 0; rb_encoding *str_enc; - + switch (argc) { case 1: RETURN_ENUMERATOR(str, argc, argv); @@ -3730,7 +3730,7 @@ * 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 @@ * 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 @@ /* * 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 @@ /* * 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 @@ /* * call-seq: * str.reverse! => str - * + * * Reverses <i>str</i> in place. */ @@ -3995,10 +3995,10 @@ /* * 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 @@ /* * 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 @@ /* * 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 @@ * call-seq: * str.to_s => str * str.to_str => str - * + * * Returns the receiver. */ @@ -4212,7 +4212,7 @@ /* * 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 @@ /* * 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 @@ /* * 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 @@ /* * 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 @@ /* * 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 @@ /* * 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 @@ /* * 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 @@ /* - * 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 @@ /* * 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 @@ typedef unsigned char *USTR; struct tr { - int gen; + int gen; unsigned int now, max; char *p, *pend; }; @@ -4928,7 +4928,7 @@ 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 @@ /* * 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 @@ /* * 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 @@ } 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.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 @@ /* * 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 @@ /* * 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 @@ /* * 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 @@ } -/* +/* * 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 @@ /* * 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 @@ /* * 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 @@ /* * 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 @@ /* * 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 @@ * "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 @@ * 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 @@ * 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 @@ 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 @@ * 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 @@ * 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 @@ * 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 @@ * 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 @@ * 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 @@ * 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 @@ /* * 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 @@ /* * 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 @@ /* * 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 @@ /* * 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 @@ /* * 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 @@ /* 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 @@ /* * 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 @@ /* * 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 @@ /* * 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 @@ /* * 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 @@ /* * 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 @@ * 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 @@ /* * 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 @@ /* * 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 @@ /* * 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 @@ * 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 @@ * * 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 @@ /* * call-seq: * str.ord => integer - * + * * Return the <code>Integer</code> ordinal of a one-character string. - * + * * "a".ord #=> 97 */ @@ -6512,7 +6512,7 @@ /* * 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 @@ /* * 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 @@ /* * 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 @@ /* * 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 @@ /* * 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 @@ /* * 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 @@ /* * call-seq: * str.start_with?([prefix]+) => true or false - * + * * Returns true if <i>str</i> starts with the prefix given. */ @@ -6832,7 +6832,7 @@ /* * call-seq: * str.end_with?([suffix]+) => true or false - * + * * Returns true if <i>str</i> ends with the suffix given. */ @@ -6887,7 +6887,7 @@ /* * 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 @@ /* * 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 @@ * 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 @@ * $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 @@ /* * call-seq: * sym.inspect => string - * + * * Returns the representation of <i>sym</i> as a symbol literal. - * + * * :fred.inspect #=> ":fred" */ @@ -7018,9 +7018,9 @@ * 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 @@ * 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 -- ML: ruby-changes@q... Info: http://www.atdot.net/~ko1/quickml/