Targetint - Target processor-native integers.

       Module Targetint
        : sigend

       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.

       Warning: this module is unstable and part of Compiler_libs .

       typet

       The type of target integers.

       valzero : t

       The target integer 0.

       valone : t

       The target integer 1.

       valminus_one : t

       The target integer -1.

       valneg : t->t

       Unary negation.

       valadd : t->t->t

       Addition.

       valsub : t->t->t

       Subtraction.

       valmul : t->t->t

       Multiplication.

       valdiv : 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 (/) .

       valunsigned_div : t->t->t

       Same as Targetint.div , except that arguments and result are interpreted as     unsigned integers.

       valrem : t->t->t

       Integer remainder.  If y is not zero, the result of Targetint.remxy satisfies the following properties:
       Targetint.zero<=Nativeint.remxy<Targetint.absy and x=Targetint.add(Targetint.mul(Targetint.divxy)y)(Targetint.remxy) .  If y=0 , Targetint.remxy raises Division_by_zero .

       valunsigned_rem : t->t->t

       Same as Targetint.rem , except that arguments and result are interpreted as     unsigned integers.

       valsucc : t->t

       Successor.  Targetint.succx is Targetint.addxTargetint.one .

       valpred : t->t

       Predecessor.  Targetint.predx is Targetint.subxTargetint.one .

       valabs : t->tabsx is the absolute value of x . On min_int this is min_int itself and thus remains negative.

       valsize : int

       The size in bits of a target native integer.

       valmax_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.

       valmin_int : t

       The smallest representable target integer, either -2^31 on a  32-bit  platform,  or  -2^63  on  a  64-bit
       platform.

       vallogand : t->t->t

       Bitwise logical and.

       vallogor : t->t->t

       Bitwise logical or.

       vallogxor : t->t->t

       Bitwise logical exclusive or.

       vallognot : t->t

       Bitwise logical negation.

       valshift_left : t->int->tTargetint.shift_leftxy  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.

       valshift_right : t->int->tTargetint.shift_rightxy 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 .

       valshift_right_logical : t->int->tTargetint.shift_right_logicalxy 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 .

       valof_int : int->t

       Convert the given integer (type int ) to a target integer (type t ), module the target word size.

       valof_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.

       valto_int : t->int

       Convert the given target integer (type t ) to an integer (type int ).  The high-order bit is lost  during
       the conversion.

       valof_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 ].

       valto_float : t->float

       Convert the given target integer to a floating-point number.

       valof_int32 : int32->t

       Convert the given 32-bit integer (type int32 ) to a target integer.

       valto_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.

       valof_int64 : int64->t

       Convert the given 64-bit integer (type int64 ) to a target integer.

       valto_int64 : t->int64

       Convert the given target integer to a 64-bit integer (type int64 ).

       valof_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 .

       valto_string : t->string

       Return the string representation of its argument, in decimal.

       valcompare : t->t->int

       The comparison function for target integers, with the same specification as 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 .

       valunsigned_compare : t->t->int

       Same as Targetint.compare , except that arguments are interpreted as unsigned integers.

       valequal : t->t->bool

       The equal function for target ints.

       typerepr =
        | Int32 ofint32
        | Int64 ofint64valrepr : t->repr

       The concrete representation of a native integer.

       valprint : Format.formatter->t->unit

       Print a target integer to a formatter.

OCamldoc                                           2025-06-12                                      Targetint(3o)

       Module   Targetint

       Targetint - Target processor-native integers.