forked from ocaml/ocaml
-
Notifications
You must be signed in to change notification settings - Fork 0
/
targetint.mli
188 lines (148 loc) · 6.49 KB
/
targetint.mli
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. *)