Bug #15452 ยป document-exceptions.patch
| complex.c | ||
|---|---|---|
|
/*
|
||
|
* call-seq:
|
||
|
* Complex(x[, y]) -> numeric
|
||
|
* Complex(x[, y], exception: false) -> numeric
|
||
|
*
|
||
|
* Returns x+i*y;
|
||
|
*
|
||
| ... | ... | |
|
* Complex(nil) #=> TypeError
|
||
|
* Complex(1, nil) #=> TypeError
|
||
|
*
|
||
|
* Complex(1, nil, exception: false) # => nil
|
||
|
* Complex('1+2', exception: false) # => nil
|
||
|
*
|
||
|
* Syntax of string form:
|
||
|
*
|
||
|
* string form = extra spaces , complex , extra spaces ;
|
||
| object.c | ||
|---|---|---|
|
/*
|
||
|
* call-seq:
|
||
|
* Integer(arg, base=0) -> integer
|
||
|
* Integer(arg, base=0, exception: true) -> integer
|
||
|
*
|
||
|
* Converts <i>arg</i> to an <code>Integer</code>.
|
||
|
* Numeric types are converted directly (with floating point numbers
|
||
| ... | ... | |
|
* In any case, strings should be strictly conformed to numeric
|
||
|
* representation. This behavior is different from that of
|
||
|
* <code>String#to_i</code>. Non string values will be converted by first
|
||
|
* trying <code>to_int</code>, then <code>to_i</code>. Passing <code>nil</code>
|
||
|
* raises a TypeError.
|
||
|
* trying <code>to_int</code>, then <code>to_i</code>.
|
||
|
*
|
||
|
* Passing <code>nil</code> raises a TypeError, while passing String that
|
||
|
* does not conform with numeric representation raises an ArgumentError.
|
||
|
* This behavior can be altered by passing <code>exception: false</code>,
|
||
|
* in this case not convertible value will return <code>nil</code>.
|
||
|
*
|
||
|
* Integer(123.999) #=> 123
|
||
|
* Integer("0x1a") #=> 26
|
||
|
* Integer(Time.new) #=> 1204973019
|
||
|
* Integer("0930", 10) #=> 930
|
||
|
* Integer("111", 2) #=> 7
|
||
|
* Integer(nil) #=> TypeError
|
||
|
* Integer(nil) #=> TypeError: can't convert nil into Integer
|
||
|
* Integer("x") #=> ArgumentError: invalid value for Integer(): "x"
|
||
|
*
|
||
|
* Integer("x", exception: false) #=> nil
|
||
|
*
|
||
|
*/
|
||
|
static VALUE
|
||
| ... | ... | |
|
/*
|
||
|
* call-seq:
|
||
|
* Float(arg) -> float
|
||
|
* Float(arg, exception: true) -> float
|
||
|
*
|
||
|
* Returns <i>arg</i> converted to a float. Numeric types are converted
|
||
|
* directly, and with exception to string and nil the rest are converted using <i>arg</i>.to_f.
|
||
|
* Converting a <code>string</code> with invalid characters will result in a <code>ArgumentError</code>.
|
||
|
* Converting <code>nil</code> generates a <code>TypeError</code>.
|
||
|
* Exceptions could be suppressed by passing <code>exception: false</code>.
|
||
|
*
|
||
|
* Float(1) #=> 1.0
|
||
|
* Float("123.456") #=> 123.456
|
||
|
* Float("123.0_badstring") #=> ArgumentError: invalid value for Float(): "123.0_badstring"
|
||
|
* Float(nil) #=> TypeError: can't convert nil into Float
|
||
|
* Float("123.0_badstring", exception: false) #=> nil
|
||
|
*/
|
||
|
static VALUE
|
||
| rational.c | ||
|---|---|---|
|
/*
|
||
|
* call-seq:
|
||
|
* Rational(x, y) -> rational
|
||
|
* Rational(arg) -> rational
|
||
|
* Rational(x, y, exception: true) -> rational
|
||
|
* Rational(arg, exception: true) -> rational
|
||
|
*
|
||
|
* Returns +x/y+ or +arg+ as a Rational.
|
||
|
*
|
||
| ... | ... | |
|
* Rational(nil) #=> TypeError
|
||
|
* Rational(1, nil) #=> TypeError
|
||
|
*
|
||
|
* Rational("10 cents", exception: false) #=> nil
|
||
|
*
|
||
|
* Syntax of the string form:
|
||
|
*
|
||
|
* string form = extra spaces , rational , extra spaces ;
|
||