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.
val zero : tThe target integer 0.
val one : tThe target integer 1.
val minus_one : tThe target integer -1.
val neg : t -> tUnary negation.
val add : t -> t -> tAddition.
val sub : t -> t -> tSubtraction.
val mul : t -> t -> tMultiplication.
val div : t -> t -> tInteger 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 Stdlib.(/).
val unsigned_div : t -> t -> tSame as Targetint.div, except that arguments and result are interpreted as unsigned integers.
val rem : t -> t -> tInteger 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).
If
(Targetint.rem x y)y = 0, Targetint.rem x y raises Division_by_zero.
val unsigned_rem : t -> t -> tSame as Targetint.rem, except that arguments and result are interpreted as unsigned integers.
val succ : t -> tSuccessor.
Targetint.succ x is Targetint.add x Targetint.one.
val pred : t -> tPredecessor.
Targetint.pred x is Targetint.sub x Targetint.one.
val abs : t -> tabs x is the absolute value of x. On min_int this
is min_int itself and thus remains negative.
val size : intThe size in bits of a target native integer.
val max_int : tThe greatest representable target integer, either 231 - 1 on a 32-bit platform, or 263 - 1 on a 64-bit platform.
val min_int : tThe smallest representable target integer, either -231 on a 32-bit platform, or -263 on a 64-bit platform.
val logand : t -> t -> tBitwise logical and.
val logor : t -> t -> tBitwise logical or.
val logxor : t -> t -> tBitwise logical exclusive or.
val lognot : t -> tBitwise logical negation.
val shift_left : t -> int -> tTargetint.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.
val shift_right : t -> int -> tTargetint.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.
val shift_right_logical : t -> int -> tTargetint.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.
val of_int : int -> tConvert the given integer (type int) to a target integer
(type t), module the target word size.
val of_int_exn : int -> tConvert the given integer (type int) to a target integer
(type t). Raises a fatal error if the conversion is not exact.
val to_int : t -> intConvert the given target integer (type t) to an
integer (type int). The high-order bit is lost during
the conversion.
val of_float : float -> tConvert 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].
val to_float : t -> floatConvert the given target integer to a floating-point number.
val of_int32 : int32 -> tConvert the given 32-bit integer (type int32)
to a target integer.
val to_int32 : t -> int32Convert 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.
val of_int64 : int64 -> tConvert the given 64-bit integer (type int64)
to a target integer.
val to_int64 : t -> int64Convert the given target integer to a
64-bit integer (type int64).
val of_string : string -> tConvert 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.
val to_string : t -> stringReturn the string representation of its argument, in decimal.
val compare : t -> t -> intThe comparison function for target integers, with the same specification as
Stdlib.compare. Along with the type t, this function compare
allows the module Targetint to be passed as argument to the functors
Set.Make and Map.Make.
val unsigned_compare : t -> t -> intSame as Targetint.compare, except that arguments are interpreted as unsigned
integers.
val equal : t -> t -> boolThe equal function for target ints.
type repr =
| |
Int32 of |
| |
Int64 of |
val repr : t -> reprThe concrete representation of a native integer.
val print : Format.formatter -> t -> unitPrint a target integer to a formatter.