module Targetint: sig .. end
Target processor-native integers.
This module provides operations on the type of signed 32-bit integers (on 32-bit target platforms) or signed 64-bit integers (on 64-bit target platforms). This integer type has exactly the same width as that of a pointer type in the C compiler. All arithmetic operations over are taken modulo 232 or 264 depending on the word size of the target architecture.
Warning: this module is unstable and part of compiler-libs.
type t;
The type of target integers.
let zero: t;
The target integer 0.
let one: t;
The target integer 1.
let minus_one: t;
The target integer -1.
let neg: t => t;
Unary negation.
let add: (t, t) => t;
Addition.
let sub: (t, t) => t;
Subtraction.
let mul: (t, t) => t;
Multiplication.
let div: (t, t) => t;
Integer division. Raise Division_by_zero
if the second
argument is zero. This division rounds the real quotient of
its arguments towards zero, as specified for (/)
.
let unsigned_div: (t, t) => t;
Same as Targetint.div
, except that arguments and result are interpreted as unsigned integers.
let rem: (t, t) => t;
Integer remainder. If y
is not zero, the result
of Targetint.rem x y
satisfies the following properties:
Targetint.zero <= Nativeint.rem x y < Targetint.abs y
and
x = Targetint.add (Targetint.mul (Targetint.div x y) y)
(Targetint.rem x y)
.
If y = 0
, Targetint.rem x y
raises Division_by_zero
.
let unsigned_rem: (t, t) => t;
Same as Targetint.rem
, except that arguments and result are interpreted as unsigned integers.
let succ: t => t;
Successor.
Targetint.succ x
is Targetint.add x Targetint.one
.
let pred: t => t;
Predecessor.
Targetint.pred x
is Targetint.sub x Targetint.one
.
let abs: t => t;
Return the absolute value of its argument.
let size: int;
The size in bits of a target native integer.
let max_int: t;
The greatest representable target integer, either 231 - 1 on a 32-bit platform, or 263 - 1 on a 64-bit platform.
let min_int: t;
The smallest representable target integer, either -231 on a 32-bit platform, or -263 on a 64-bit platform.
let logand: (t, t) => t;
Bitwise logical and.
let logor: (t, t) => t;
Bitwise logical or.
let logxor: (t, t) => t;
Bitwise logical exclusive or.
let lognot: t => t;
Bitwise logical negation.
let shift_left: (t, int) => t;
Targetint.shift_left x y
shifts x
to the left by y
bits.
The result is unspecified if y < 0
or y >= bitsize
,
where bitsize
is 32
on a 32-bit platform and
64
on a 64-bit platform.
let shift_right: (t, int) => t;
Targetint.shift_right x y
shifts x
to the right by y
bits.
This is an arithmetic shift: the sign bit of x
is replicated
and inserted in the vacated bits.
The result is unspecified if y < 0
or y >= bitsize
.
let shift_right_logical: (t, int) => t;
Targetint.shift_right_logical x y
shifts x
to the right
by y
bits.
This is a logical shift: zeroes are inserted in the vacated bits
regardless of the sign of x
.
The result is unspecified if y < 0
or y >= bitsize
.
let of_int: int => t;
Convert the given integer (type int
) to a target integer
(type t
), module the target word size.
let of_int_exn: int => t;
Convert the given integer (type int
) to a target integer
(type t
). Raises a fatal error if the conversion is not exact.
let to_int: t => int;
Convert the given target integer (type t
) to an
integer (type int
). The high-order bit is lost during
the conversion.
let of_float: float => t;
Convert the given floating-point number to a target integer,
discarding the fractional part (truncate towards 0).
The result of the conversion is undefined if, after truncation,
the number is outside the range
[Targetint.min_int
, Targetint.max_int
].
let to_float: t => float;
Convert the given target integer to a floating-point number.
let of_int32: int32 => t;
Convert the given 32-bit integer (type int32
)
to a target integer.
let to_int32: t => int32;
Convert the given target integer to a
32-bit integer (type int32
). On 64-bit platforms,
the 64-bit native integer is taken modulo 232,
i.e. the top 32 bits are lost. On 32-bit platforms,
the conversion is exact.
let of_int64: int64 => t;
Convert the given 64-bit integer (type int64
)
to a target integer.
let to_int64: t => int64;
Convert the given target integer to a
64-bit integer (type int64
).
let of_string: string => t;
Convert the given string to a target integer.
The string is read in decimal (by default) or in hexadecimal,
octal or binary if the string begins with 0x
, 0o
or 0b
respectively.
Raise Failure "int_of_string"
if the given string is not
a valid representation of an integer, or if the integer represented
exceeds the range of integers representable in type nativeint
.
let to_string: t => string;
Return the string representation of its argument, in decimal.
let compare: (t, t) => int;
let unsigned_compare: (t, t) => int;
Same as Targetint.compare
, except that arguments are interpreted as unsigned
integers.
let equal: (t, t) => bool;
The equal function for target ints.
type repr =
| |
Int32 of int32 |
| |
Int64 of int64 |
let repr: t => repr;
The concrete representation of a native integer.
let print: (Format.formatter, t) => unit;
Print a target integer to a formatter.