/usr/lib/ocaml/compiler-libs/targetint.mli is in ocaml-compiler-libs 4.05.0-10ubuntu1.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 | (**************************************************************************)
(* *)
(* OCaml *)
(* *)
(* Xavier Leroy, projet Cristal, INRIA Rocquencourt *)
(* Nicolas Ojeda Bar, LexiFi *)
(* *)
(* Copyright 2016 Institut National de Recherche en Informatique et *)
(* en Automatique. *)
(* *)
(* All rights reserved. This file is distributed under the terms of *)
(* the GNU Lesser General Public License version 2.1, with the *)
(* special exception on linking described in the file LICENSE. *)
(* *)
(**************************************************************************)
(** 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 2{^32} or 2{^64} depending
on the word size of the target architecture.
*)
type t
(** The type of target integers. *)
val zero : t
(** The target integer 0.*)
val one : t
(** The target integer 1.*)
val minus_one : t
(** The target integer -1.*)
val neg : t -> t
(** Unary negation. *)
val add : t -> t -> t
(** Addition. *)
val sub : t -> t -> t
(** Subtraction. *)
val mul : t -> t -> t
(** Multiplication. *)
val 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 {!Pervasives.(/)}. *)
val 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]. *)
val succ : t -> t
(** Successor.
[Targetint.succ x] is [Targetint.add x Targetint.one]. *)
val pred : t -> t
(** Predecessor.
[Targetint.pred x] is [Targetint.sub x Targetint.one]. *)
val abs : t -> t
(** Return the absolute value of its argument. *)
val size : int
(** The size in bits of a target native integer. *)
val max_int : t
(** The greatest representable target integer,
either 2{^31} - 1 on a 32-bit platform,
or 2{^63} - 1 on a 64-bit platform. *)
val min_int : t
(** The smallest representable target integer,
either -2{^31} on a 32-bit platform,
or -2{^63} on a 64-bit platform. *)
val logand : t -> t -> t
(** Bitwise logical and. *)
val logor : t -> t -> t
(** Bitwise logical or. *)
val logxor : t -> t -> t
(** Bitwise logical exclusive or. *)
val lognot : t -> t
(** Bitwise logical negation *)
val 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. *)
val 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]. *)
val 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]. *)
val of_int : int -> t
(** Convert the given integer (type [int]) to a target integer
(type [t]), module the target word size. *)
val 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. *)
val 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. *)
val 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}\]. *)
val to_float : t -> float
(** Convert the given target integer to a floating-point number. *)
val of_int32 : int32 -> t
(** Convert the given 32-bit integer (type [int32])
to a target integer. *)
val 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 2{^32},
i.e. the top 32 bits are lost. On 32-bit platforms,
the conversion is exact. *)
val of_int64 : int64 -> t
(** Convert the given 64-bit integer (type [int64])
to a target integer. *)
val to_int64 : t -> int64
(** Convert the given target integer to a
64-bit integer (type [int64]). *)
val 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]. *)
val to_string : t -> string
(** Return the string representation of its argument, in decimal. *)
val compare: t -> t -> int
(** The comparison function for target integers, with the same specification as
{!Pervasives.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 equal: t -> t -> bool
(** The equal function for target ints. *)
type repr =
| Int32 of int32
| Int64 of int64
val repr : t -> repr
(** The concrete representation of a native integer. *)
|