Big Integer Support

Author: hikari-no-yume

spec/05-types.md

@@ -58,23 +58,22 @@ The library function `is_bool` (§xx) indicates if a given value has type
 ###The Integer Type
 
 There is one integer type, `int`, for which the name `integer` is a synonym.
-This type is binary, signed, and uses twos-complement representation for
-negative values. The range of values that can be stored is
-implementation-defined; however, the range [-2147483648, 2147483647],
-must be supported. This range must be finite.
+This type is a binary, signed, arbitrary-precision integer. Its range is
+limited only by available memory.
 
-Certain operations on integer values produce a mathematical result that
-cannot be represented as an integer. Examples include the following:
+Implementations MAY choose to implement this type with an underlying native
+integer type and a separate arbitrary-precision integer type, switching between
+the two types as and where appropriate, so long as the observed behaviour is
+identical and the two types are indistinguishable, i.e. they are, for all
+intents and purposes, the same type and are reported as such.
 
--   Incrementing the largest value or decrementing the smallest value.
--   Applying the unary minus to the smallest value.
--   Multiplying, adding, or subtracting two values.
-
-In such cases, the computation is done as though the types of the values were
-`float` with the result having that type.
+Bitwise operations MUST use two's-complement arithmetic, however implementations
+MAY choose not to use a two's-complement underlying representation.
 
 The constants `PHP_INT_SIZE` (§[[6.3](06-constants.md#core-predefined-constants)](#core-predefined-constants)), `PHP_INT_MAX` (§[[6.3](06-constants.md#core-predefined-constants)](#core-predefined-constants)) and `PHP_INT_MIN` (§[[6.3](06-constants.md#core-predefined-constants)](#core-predefined-constants))
-define certain characteristics about type `int`.
+exist for backwards-compatibility reasons, and indicate the native integer
+size of the machine (usually 32-bit or 64-bit). They do not, however, represent
+the actual range and size of the PHP integer type, which is unlimited.
 
 The library function `is_int` (§xx) indicates if a given value has type
 `int`.

spec/06-constants.md

@@ -106,9 +106,9 @@ Constant Name | Description
 `PHP_EOL` | `string`; the end-of-line terminator for this platform.
 `PHP_EXTENSION_DIR` | `string`; The directory to be searched by the library function dl (§xx) when looking for runtime extensions.
 `PHP_EXTRA_VERSION` | `string`; the current PHP extra version.
-`PHP_INT_MAX` | `int`; the maximum representable value for an integer.
-`PHP_INT_MIN` | `int`; the minimum representable value for an integer. 
-`PHP_INT_SIZE` |  `int`; the number of bytes used to represent an integer.
+`PHP_INT_MAX` | `int`; the maximum representable value for a native integer on this platform. (This does not correspond to the maximum size of a PHP integer, unlimited.)
+`PHP_INT_MIN` | `int`; the minimum representable value for a native integer on this platform. (This does not correspond to the maximum size of a PHP integer, which is unlimited.) 
+`PHP_INT_SIZE` |  `int`; the number of bytes used to represent the native integer size of this platform. (This does not correspond to the maximum size of a PHP integer, which is unlimited.)
 `PHP_MAJOR_VERSION` | `int`; the current PHP major version
 `PHP_MANDIR`  | `string`; the installation location of the manual pages.
 `PHP_MAXPATHLEN` |  `int`; the maximum length of a fully qualified filename supported by this build.

spec/08-conversions.md

@@ -42,31 +42,13 @@ If the source type is `bool`, then if the source value is `FALSE`, the
 result value is 0; otherwise, the result value is 1.
 
 If the source type is `float`, for the values `INF`, `-INF`, and `NAN`, the
-result value is zero. For all other values, if the
-precision can be preserved (that is, the float is within the range of an
-integer), the fractional part is rounded towards zero. If the precision cannot
-be preserved, the following conversion algorithm is used, where *X* is
-defined as two to the power of the number of bits in an integer (for example,
-2 to the power of 32, i.e. 4294967296):
-
- 1. We take the floating point remainder (wherein the remainder has the same
-    sign as the dividend) of dividing the float by *X*, rounded towards zero.
- 2. If the remainder is less than zero, it is rounded towards
-    infinity and *X* is added.
- 3. This result is converted to an unsigned integer.
- 4. This result is converted to a signed integer by treating the unsigned
-    integer as a two's complement representation of the signed integer.
-
-Implementations may implement this conversion differently (for example, on some
-architectures there may be hardware support for this specific conversion mode)
-so long as the result is the same.
+result value is zero. For all other values, the fractional part is rounded towards zero.
 
 If the source value is `NULL`, the result value is 0.
 
 If the source is a numeric string or leading-numeric string ([§§](05-types.md#the-string-type))
-having integer format, if the precision can be preserved the result
-value is that string's integer value; otherwise, the result is
-undefined. If the source is a numeric string or leading-numeric string
+having integer format, the result value is that string's integer value.
+If the source is a numeric string or leading-numeric string
 having floating-point format, the string's floating-point value is
 treated as described above for a conversion from `float`. The trailing
 non-numeric characters in leading-numeric strings are ignored.  For any