stripped trailing spaces.

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

1 files changed, 44 insertions, 44 deletions

diff --git a/range.c b/range.c
index 4c9fa869f7..6e0af8679e 100644
--- a/range.c
+++ b/range.c
@@ -44,7 +44,7 @@ range_init(VALUE range, VALUE beg, VALUE end, int exclude_end)
 
     args[0] = beg;
     args[1] = end;
-    
+
     if (!FIXNUM_P(beg) || !FIXNUM_P(end)) {
 	VALUE v;
 
@@ -70,7 +70,7 @@ rb_range_new(VALUE beg, VALUE end, int exclude_end)
 /*
  *  call-seq:
  *     Range.new(start, end, exclusive=false)    => range
- *  
+ *
  *  Constructs a range using the given <i>start</i> and <i>end</i>. If the third
  *  parameter is omitted or is <code>false</code>, the <i>range</i> will include
  *  the end object; otherwise, it will be excluded.
@@ -80,7 +80,7 @@ static VALUE
 range_initialize(int argc, VALUE *argv, VALUE range)
 {
     VALUE beg, end, flags;
-    
+
     rb_scan_args(argc, argv, "21", &beg, &end, &flags);
     /* Ranges are immutable, so that they should be initialized only once. */
     if (RANGE_EXCL(range) != Qnil) {
@@ -95,7 +95,7 @@ range_initialize(int argc, VALUE *argv, VALUE range)
 /*
  *  call-seq:
  *     rng.exclude_end?    => true or false
- *  
+ *
  *  Returns <code>true</code> if <i>rng</i> excludes its end value.
  */
 
@@ -109,15 +109,15 @@ range_exclude_end_p(VALUE range)
 /*
  *  call-seq:
  *     rng == obj    => true or false
- *  
+ *
  *  Returns <code>true</code> only if <i>obj</i> is a Range, has equivalent
  *  beginning and end items (by comparing them with <code>==</code>), and has
  *  the same #exclude_end? setting as <i>rng</t>.
- *     
+ *
  *    (0..2) == (0..2)            #=> true
  *    (0..2) == Range.new(0,2)    #=> true
  *    (0..2) == (0...2)           #=> false
- *     
+ *
  */
 
 static VALUE
@@ -171,15 +171,15 @@ r_le(VALUE a, VALUE b)
 /*
  *  call-seq:
  *     rng.eql?(obj)    => true or false
- *  
+ *
  *  Returns <code>true</code> only if <i>obj</i> is a Range, has equivalent
  *  beginning and end items (by comparing them with #eql?), and has the same
  *  #exclude_end? setting as <i>rng</i>.
- *     
+ *
  *    (0..2) == (0..2)            #=> true
  *    (0..2) == Range.new(0,2)    #=> true
  *    (0..2) == (0...2)           #=> false
- *     
+ *
  */
 
 static VALUE
@@ -274,19 +274,19 @@ extern int ruby_float_step(VALUE from, VALUE to, VALUE step, int excl);
 /*
  *  call-seq:
  *     rng.step(n=1) {| obj | block }    => rng
- *  
+ *
  *  Iterates over <i>rng</i>, passing each <i>n</i>th element to the block. If
  *  the range contains numbers, <i>n</i> is added for each iteration.  Otherwise
  *  <code>step</code> invokes <code>succ</code> to iterate through range
  *  elements. The following code uses class <code>Xs</code>, which is defined
  *  in the class-level documentation.
- *     
+ *
  *     range = Xs.new(1)..Xs.new(10)
  *     range.step(2) {|x| puts x}
  *     range.step(3) {|x| puts x}
- *     
+ *
  *  <em>produces:</em>
- *     
+ *
  *      1 x
  *      3 xxx
  *      5 xxxxx
@@ -330,7 +330,7 @@ range_step(int argc, VALUE *argv, VALUE range)
 
 	if (!EXCL(range))
 	    end += 1;
-	i = FIX2LONG(b);	
+	i = FIX2LONG(b);
 	while (i < end) {
 	    rb_yield(LONG2NUM(i));
 	    if (i + unit < i) break;
@@ -392,18 +392,18 @@ each_i(VALUE v, void *arg)
 /*
  *  call-seq:
  *     rng.each {| i | block } => rng
- *  
+ *
  *  Iterates over the elements <i>rng</i>, passing each in turn to the
  *  block. You can only iterate if the start object of the range
  *  supports the +succ+ method (which means that you can't iterate over
  *  ranges of +Float+ objects).
- *     
+ *
  *     (10..15).each do |n|
  *        print n, ' '
  *     end
- *     
+ *
  *  <em>produces:</em>
- *     
+ *
  *     10 11 12 13 14 15
  */
 
@@ -447,7 +447,7 @@ range_each(VALUE range)
 /*
  *  call-seq:
  *     rng.begin    => obj
- *  
+ *
  *  Returns the first object in <i>rng</i>.
  */
 
@@ -461,9 +461,9 @@ range_begin(VALUE range)
 /*
  *  call-seq:
  *     rng.end    => obj
- *  
+ *
  *  Returns the object that defines the end of <i>rng</i>.
- *     
+ *
  *     (1..10).end    #=> 10
  *     (1...10).end   #=> 10
  */
@@ -494,7 +494,7 @@ first_i(VALUE i, VALUE *ary)
  *  call-seq:
  *     rng.first    => obj
  *     rng.first(n) => an_array
- *  
+ *
  *  Returns the first object in <i>rng</i>, or the first +n+ elements.
  */
 
@@ -518,7 +518,7 @@ range_first(int argc, VALUE *argv, VALUE range)
  *  call-seq:
  *     rng.last    => obj
  *     rng.last(n) => an_array
- *  
+ *
  *  Returns the last object in <i>rng</i>, or the last +n+ elements.
  */
 
@@ -528,7 +528,7 @@ range_last(int argc, VALUE *argv, VALUE range)
     VALUE rb_ary_last(int, VALUE *, VALUE);
 
     if (argc == 0) return RANGE_END(range);
-    return rb_ary_last(argc, argv, rb_Array(range)); 
+    return rb_ary_last(argc, argv, rb_Array(range));
 }
 
 
@@ -536,11 +536,11 @@ range_last(int argc, VALUE *argv, VALUE range)
  *  call-seq:
  *     rng.min                    => obj
  *     rng.min {| a,b | block }   => obj
- *  
+ *
  *  Returns the minimum value in <i>rng</i>. The second uses
  *  the block to compare values.  Returns nil if the first
  *  value in range is larger than the last value.
- *     
+ *
  */
 
 
@@ -565,11 +565,11 @@ range_min(VALUE range)
  *  call-seq:
  *     rng.max                    => obj
  *     rng.max {| a,b | block }   => obj
- *  
+ *
  *  Returns the maximum value in <i>rng</i>. The second uses
  *  the block to compare values.  Returns nil if the first
  *  value in range is larger than the last value.
- *     
+ *
  */
 
 static VALUE
@@ -698,7 +698,7 @@ inspect_range(VALUE range, VALUE dummy, int recur)
  * call-seq:
  *   rng.inspect  => string
  *
- * Convert this range object to a printable form (using 
+ * Convert this range object to a printable form (using
  * <code>inspect</code> to convert the start and end
  * objects).
  */
@@ -713,20 +713,20 @@ range_inspect(VALUE range)
 /*
  *  call-seq:
  *     rng === obj       =>  true or false
- *  
+ *
  *  Returns <code>true</code> if <i>obj</i> is an element of
  *  <i>rng</i>, <code>false</code> otherwise. Conveniently,
  *  <code>===</code> is the comparison operator used by
  *  <code>case</code> statements.
- *     
+ *
  *     case 79
  *     when 1..50   then   print "low\n"
  *     when 51..75  then   print "medium\n"
  *     when 76..100 then   print "high\n"
  *     end
- *     
+ *
  *  <em>produces:</em>
- *     
+ *
  *     high
  */
 
@@ -741,11 +741,11 @@ range_eqq(VALUE range, VALUE val)
  *  call-seq:
  *     rng.member?(val)  =>  true or false
  *     rng.include?(val) =>  true or false
- *  
+ *
  *  Returns <code>true</code> if <i>obj</i> is an element of
  *  <i>rng</i>, <code>false</code> otherwise.  If beg and end are
  *  numeric, comparison is done according magnitude of values.
- *     
+ *
  *     ("a".."z").include?("g")  # => true
  *     ("a".."z").include?("A")  # => false
  */
@@ -801,11 +801,11 @@ range_include(VALUE range, VALUE val)
 /*
  *  call-seq:
  *     rng.cover?(val)  =>  true or false
- *  
+ *
  *  Returns <code>true</code> if <i>obj</i> is between beg and end,
  *  i.e <code>beg <= obj <= end</code> (or <i>end</i> exclusive when
  *  <code>exclude_end?</code> is true).
- *     
+ *
  *     ("a".."z").cover?("c")    #=> true
  *     ("a".."z").cover?("5")    #=> false
  */
@@ -874,17 +874,17 @@ range_alloc(VALUE klass)
  *  run from the start to the end inclusively. Those created using
  *  <code>...</code> exclude the end value. When used as an iterator,
  *  ranges return each value in the sequence.
- *     
+ *
  *     (-1..-5).to_a      #=> []
  *     (-5..-1).to_a      #=> [-5, -4, -3, -2, -1]
  *     ('a'..'e').to_a    #=> ["a", "b", "c", "d", "e"]
  *     ('a'...'e').to_a   #=> ["a", "b", "c", "d"]
- *     
+ *
  *  Ranges can be constructed using objects of any type, as long as the
  *  objects can be compared using their <code><=></code> operator and
  *  they support the <code>succ</code> method to return the next object
  *  in sequence.
- *     
+ *
  *     class Xs                # represent a string of 'x's
  *       include Comparable
  *       attr :length
@@ -904,18 +904,18 @@ range_alloc(VALUE klass)
  *         'x' * @length
  *       end
  *     end
- *     
+ *
  *     r = Xs.new(3)..Xs.new(6)   #=> xxx..xxxxxx
  *     r.to_a                     #=> [xxx, xxxx, xxxxx, xxxxxx]
  *     r.member?(Xs.new(5))       #=> true
- *     
+ *
  *  In the previous code example, class <code>Xs</code> includes the
  *  <code>Comparable</code> module. This is because
  *  <code>Enumerable#member?</code> checks for equality using
  *  <code>==</code>. Including <code>Comparable</code> ensures that the
  *  <code>==</code> method is defined in terms of the <code><=></code>
  *  method implemented in <code>Xs</code>.
- *     
+ *
  */
 
 void