From 6156d208e6cc6e28a964be5dd34585bd54f6eadf Mon Sep 17 00:00:00 2001

From: Xavier Leroy <xavier.leroy@inria.fr>

Date: Wed, 27 Aug 2014 09:58:33 +0000

Subject: [PATCH 11/12] PR#6517: use ISO C99 types {,u}int{32,64}_t in

 preference to our homegrown types {,u}int{32,64}.

git-svn-id: http://caml.inria.fr/svn/ocaml/trunk@15131 f963ae5c-01c2-4b8c-9fe0-0dff7051ff02

----------------------------------------------------------------------

For Fedora:

This commit was cherry picked from upstream

commit b868c05ec91a7ee193010a421de768a3b1a80952 (SVN 15131).

See also:

http://caml.inria.fr/mantis/view.php?id=6517

---

 asmrun/backtrace.c                  |   6 +-

 byterun/alloc.h                     |   4 +-

 byterun/backtrace.c                 |   2 +-

 byterun/config.h                    |  35 +++++++----

 byterun/debugger.h                  |  28 ++++-----

 byterun/exec.h                      |   4 +-

 byterun/extern.c                    |   4 +-

 byterun/fix_code.c                  |   8 +--

 byterun/floats.c                    |   6 +-

 byterun/globroots.c                 |   4 +-

 byterun/hash.c                      |  44 +++++++-------

 byterun/hash.h                      |  12 ++--

 byterun/int64_emul.h                | 114 ++++++++++++++++++------------------

 byterun/int64_format.h              |   4 +-

 byterun/int64_native.h              |  20 +++----

 byterun/intern.c                    |  20 +++----

 byterun/interp.c                    |   2 +-

 byterun/intext.h                    |  12 ++--

 byterun/ints.c                      | 112 +++++++++++++++++------------------

 byterun/io.c                        |   6 +-

 byterun/io.h                        |   6 +-

 byterun/md5.c                       |  26 ++++----

 byterun/md5.h                       |   6 +-

 byterun/mlvalues.h                  |  12 ++--

 byterun/startup.c                   |  10 ++--

 byterun/startup.h                   |   4 +-

 byterun/str.c                       |  20 +++----

 config/auto-aux/int64align.c        |  14 ++---

 config/s-nt.h                       |   3 +

 configure                           |  25 ++------

 otherlibs/bigarray/bigarray_stubs.c |  48 +++++++--------

 otherlibs/num/nat_stubs.c           |  14 ++---

 otherlibs/unix/addrofstr.c          |   2 +-

 stdlib/header.c                     |   2 +-

 34 files changed, 319 insertions(+), 320 deletions(-)

diff --git a/asmrun/backtrace.c b/asmrun/backtrace.c

index c72a237..773e22c 100644

--- a/asmrun/backtrace.c

+++ b/asmrun/backtrace.c

@@ -217,7 +217,7 @@ static void extract_location_info(frame_descr * d,

                                   /*out*/ struct loc_info * li)

 {

   uintnat infoptr;

-  uint32 info1, info2;

+  uint32_t info1, info2;

   /* If no debugging information available, print nothing.

      When everything is compiled with -g, this corresponds to

@@ -232,8 +232,8 @@ static void extract_location_info(frame_descr * d,

              sizeof(char *) + sizeof(short) + sizeof(short) +

              sizeof(short) * d->num_live + sizeof(frame_descr *) - 1)

             & -sizeof(frame_descr *);

-  info1 = ((uint32 *)infoptr)[0];

-  info2 = ((uint32 *)infoptr)[1];

+  info1 = ((uint32_t *)infoptr)[0];

+  info2 = ((uint32_t *)infoptr)[1];

   /* Format of the two info words:

        llllllllllllllllllll aaaaaaaa bbbbbbbbbb nnnnnnnnnnnnnnnnnnnnnnnn kk

                           44       36         26                       2  0

diff --git a/byterun/alloc.h b/byterun/alloc.h

index f00a7ef..2a640eb 100644

--- a/byterun/alloc.h

+++ b/byterun/alloc.h

@@ -32,8 +32,8 @@ CAMLextern value caml_alloc_string (mlsize_t);  /* size in bytes */

 CAMLextern value caml_copy_string (char const *);

 CAMLextern value caml_copy_string_array (char const **);

 CAMLextern value caml_copy_double (double);

-CAMLextern value caml_copy_int32 (int32);       /* defined in [ints.c] */

-CAMLextern value caml_copy_int64 (int64);       /* defined in [ints.c] */

+CAMLextern value caml_copy_int32 (int32_t);       /* defined in [ints.c] */

+CAMLextern value caml_copy_int64 (int64_t);       /* defined in [ints.c] */

 CAMLextern value caml_copy_nativeint (intnat);  /* defined in [ints.c] */

 CAMLextern value caml_alloc_array (value (*funct) (char const *),

                                    char const ** array);

diff --git a/byterun/backtrace.c b/byterun/backtrace.c

index 76e3ddf..6ed56c8 100644

--- a/byterun/backtrace.c

+++ b/byterun/backtrace.c

@@ -229,7 +229,7 @@ static void read_debug_info(void)

   int fd;

   struct exec_trailer trail;

   struct channel * chan;

-  uint32 num_events, orig, i;

+  uint32_t num_events, orig, i;

   intnat j;

   value evl, l, ev_start;

diff --git a/byterun/config.h b/byterun/config.h

index f775988..6c86d16 100644

--- a/byterun/config.h

+++ b/byterun/config.h

@@ -25,24 +25,30 @@

 #include "compatibility.h"

 #endif

-/* Types for 32-bit integers, 64-bit integers,

+#ifdef HAS_STDINT_H

+#include <stdint.h>

+#endif

+

+/* Types for 32-bit integers, 64-bit integers, and

    native integers (as wide as a pointer type) */

+#ifndef ARCH_INT32_TYPE

 #if SIZEOF_INT == 4

-typedef int int32;

-typedef unsigned int uint32;

+#define ARCH_INT32_TYPE int

+#define ARCH_UINT32_TYPE unsigned int

 #define ARCH_INT32_PRINTF_FORMAT ""

 #elif SIZEOF_LONG == 4

-typedef long int32;

-typedef unsigned long uint32;

+#define ARCH_INT32_TYPE long

+#define ARCH_UINT32_TYPE unsigned long

 #define ARCH_INT32_PRINTF_FORMAT "l"

 #elif SIZEOF_SHORT == 4

-typedef short int32;

-typedef unsigned short uint32;

+#define ARCH_INT32_TYPE short

+#define ARCH_UINT32_TYPE unsigned short

 #define ARCH_INT32_PRINTF_FORMAT ""

 #else

 #error "No 32-bit integer type available"

 #endif

+#endif

 #ifndef ARCH_INT64_TYPE

 #if SIZEOF_LONGLONG == 8

@@ -58,8 +64,13 @@ typedef unsigned short uint32;

 #endif

 #endif

-typedef ARCH_INT64_TYPE int64;

-typedef ARCH_UINT64_TYPE uint64;

+#ifndef HAS_STDINT_H

+/* Not a C99 compiler, typically MSVC.  Define the C99 types we use. */

+typedef ARCH_INT32_TYPE int32_t;

+typedef ARCH_UINT32_TYPE uint32_t;

+typedef ARCH_INT64_TYPE int64_t;

+typedef ARCH_UINT64_TYPE uint64_t;

+#endif

 #if SIZEOF_PTR == SIZEOF_LONG

 /* Standard models: ILP32 or I32LP64 */

@@ -72,9 +83,9 @@ typedef int intnat;

 typedef unsigned int uintnat;

 #define ARCH_INTNAT_PRINTF_FORMAT ""

 #elif SIZEOF_PTR == 8

-/* Win64 model: IL32LLP64 */

-typedef int64 intnat;

-typedef uint64 uintnat;

+/* Win64 model: IL32P64 */

+typedef int64_t intnat;

+typedef uint64_t uintnat;

 #define ARCH_INTNAT_PRINTF_FORMAT ARCH_INT64_PRINTF_FORMAT

 #else

 #error "No integer type available to represent pointers"

diff --git a/byterun/debugger.h b/byterun/debugger.h

index b5079eb..e68ef75 100644

--- a/byterun/debugger.h

+++ b/byterun/debugger.h

@@ -37,17 +37,17 @@ void caml_debugger_cleanup_fork (void);

 /* Requests from the debugger to the runtime system */

 enum debugger_request {

-  REQ_SET_EVENT = 'e',          /* uint32 pos */

+  REQ_SET_EVENT = 'e',          /* uint32_t pos */

   /* Set an event on the instruction at position pos */

-  REQ_SET_BREAKPOINT = 'B',     /* uint32 pos, (char k) */

+  REQ_SET_BREAKPOINT = 'B',     /* uint32_t pos, (char k) */

   /* Set a breakpoint at position pos */

   /* In profiling mode, the breakpoint kind is set to k */

-  REQ_RESET_INSTR = 'i',        /* uint32 pos */

+  REQ_RESET_INSTR = 'i',        /* uint32_t pos */

   /* Clear an event or breapoint at position pos, restores initial instr. */

   REQ_CHECKPOINT = 'c',         /* no args */

   /* Checkpoint the runtime system by forking a child process.

      Reply is pid of child process or -1 if checkpoint failed. */

-  REQ_GO = 'g',                 /* uint32 n */

+  REQ_GO = 'g',                 /* uint32_t n */

   /* Run the program for n events.

      Reply is one of debugger_reply described below. */

   REQ_STOP = 's',               /* no args */

@@ -59,38 +59,38 @@ enum debugger_request {

      Reply is stack offset and current pc. */

   REQ_GET_FRAME = 'f',          /* no args */

   /* Return current frame location (stack offset + current pc). */

-  REQ_SET_FRAME = 'S',          /* uint32 stack_offset */

+  REQ_SET_FRAME = 'S',          /* uint32_t stack_offset */

   /* Set current frame to given stack offset. No reply. */

-  REQ_UP_FRAME = 'U',           /* uint32 n */

+  REQ_UP_FRAME = 'U',           /* uint32_t n */

   /* Move one frame up. Argument n is size of current frame (in words).

      Reply is stack offset and current pc, or -1 if top of stack reached. */

-  REQ_SET_TRAP_BARRIER = 'b',   /* uint32 offset */

+  REQ_SET_TRAP_BARRIER = 'b',   /* uint32_t offset */

   /* Set the trap barrier at the given offset. */

-  REQ_GET_LOCAL = 'L',          /* uint32 slot_number */

+  REQ_GET_LOCAL = 'L',          /* uint32_t slot_number */

   /* Return the local variable at the given slot in the current frame.

      Reply is one value. */

-  REQ_GET_ENVIRONMENT = 'E',    /* uint32 slot_number */

+  REQ_GET_ENVIRONMENT = 'E',    /* uint32_t slot_number */

   /* Return the local variable at the given slot in the heap environment

      of the current frame. Reply is one value. */

-  REQ_GET_GLOBAL = 'G',         /* uint32 global_number */

+  REQ_GET_GLOBAL = 'G',         /* uint32_t global_number */

   /* Return the specified global variable. Reply is one value. */

   REQ_GET_ACCU = 'A',           /* no args */

   /* Return the current contents of the accumulator. Reply is one value. */

   REQ_GET_HEADER = 'H',         /* mlvalue v */

   /* As REQ_GET_OBJ, but sends only the header. */

-  REQ_GET_FIELD = 'F',          /* mlvalue v, uint32 fieldnum */

+  REQ_GET_FIELD = 'F',          /* mlvalue v, uint32_t fieldnum */

   /* As REQ_GET_OBJ, but sends only one field. */

   REQ_MARSHAL_OBJ = 'M',        /* mlvalue v */

   /* Send a copy of the data structure rooted at v, using the same

      format as [caml_output_value]. */

   REQ_GET_CLOSURE_CODE = 'C',   /* mlvalue v */

   /* Send the code address of the given closure.

-     Reply is one uint32. */

-  REQ_SET_FORK_MODE = 'K'       /* uint32 m */

+     Reply is one uint32_t. */

+  REQ_SET_FORK_MODE = 'K'       /* uint32_t m */

   /* Set whether to follow the child (m=0) or the parent on fork. */

 };

-/* Replies to a REQ_GO request. All replies are followed by three uint32:

+/* Replies to a REQ_GO request. All replies are followed by three uint32_t:

    - the value of the event counter

    - the position of the stack

    - the current pc. */

diff --git a/byterun/exec.h b/byterun/exec.h

index a58bcf8..7e084ac 100644

--- a/byterun/exec.h

+++ b/byterun/exec.h

@@ -39,13 +39,13 @@

 struct section_descriptor {

   char name[4];                 /* Section name */

-  uint32 len;                   /* Length of data in bytes */

+  uint32_t len;                   /* Length of data in bytes */

 };

 /* Structure of the trailer. */

 struct exec_trailer {

-  uint32 num_sections;          /* Number of sections */

+  uint32_t num_sections;          /* Number of sections */

   char magic[12];               /* The magic number */

   struct section_descriptor * section; /* Not part of file */

 };

diff --git a/byterun/extern.c b/byterun/extern.c

index 33fa89a..e67d7a3 100644

--- a/byterun/extern.c

+++ b/byterun/extern.c

@@ -720,7 +720,7 @@ CAMLexport void caml_serialize_int_2(int i)

   extern_ptr += 2;

 }

-CAMLexport void caml_serialize_int_4(int32 i)

+CAMLexport void caml_serialize_int_4(int32_t i)

 {

   if (extern_ptr + 4 > extern_limit) grow_extern_output(4);

   extern_ptr[0] = i >> 24;

@@ -730,7 +730,7 @@ CAMLexport void caml_serialize_int_4(int32 i)

   extern_ptr += 4;

 }

-CAMLexport void caml_serialize_int_8(int64 i)

+CAMLexport void caml_serialize_int_8(int64_t i)

 {

   caml_serialize_block_8(&i, 1);

 }

diff --git a/byterun/fix_code.c b/byterun/fix_code.c

index 3380dc9..4fa0275 100644

--- a/byterun/fix_code.c

+++ b/byterun/fix_code.c

@@ -134,12 +134,12 @@ void caml_thread_code (code_t code, asize_t len)

     }

     *p++ = (opcode_t)(caml_instr_table[instr] - caml_instr_base);

     if (instr == SWITCH) {

-      uint32 sizes = *p++;

-      uint32 const_size = sizes & 0xFFFF;

-      uint32 block_size = sizes >> 16;

+      uint32_t sizes = *p++;

+      uint32_t const_size = sizes & 0xFFFF;

+      uint32_t block_size = sizes >> 16;

       p += const_size + block_size;

     } else if (instr == CLOSUREREC) {

-      uint32 nfuncs = *p++;

+      uint32_t nfuncs = *p++;

       p++;                      /* skip nvars */

       p += nfuncs;

     } else {

diff --git a/byterun/floats.c b/byterun/floats.c

index 7ff6d89..d8fdd05 100644

--- a/byterun/floats.c

+++ b/byterun/floats.c

@@ -378,9 +378,9 @@ CAMLprim value caml_log1p_float(value f)

 union double_as_two_int32 {

     double d;

 #if defined(ARCH_BIG_ENDIAN) || (defined(__arm__) && !defined(__ARM_EABI__))

-    struct { uint32 h; uint32 l; } i;

+    struct { uint32_t h; uint32_t l; } i;

 #else

-    struct { uint32 l; uint32 h; } i;

+    struct { uint32_t l; uint32_t h; } i;

 #endif

 };

@@ -467,7 +467,7 @@ CAMLprim value caml_classify_float(value vd)

   }

 #else

   union double_as_two_int32 u;

-  uint32 h, l;

+  uint32_t h, l;

   u.d = Double_val(vd);

   h = u.i.h;  l = u.i.l;

diff --git a/byterun/globroots.c b/byterun/globroots.c

index ded393e..d9111ee 100644

--- a/byterun/globroots.c

+++ b/byterun/globroots.c

@@ -43,11 +43,11 @@ struct global_root_list {

    (i.e. 2 * (NUM_LEVELS - 1)).  Moreover, the congruential PRNG

    is faster and guaranteed to be deterministic (to reproduce bugs). */

-static uint32 random_seed = 0;

+static uint32_t random_seed = 0;

 static int random_level(void)

 {

-  uint32 r;

+  uint32_t r;

   int level = 0;

   /* Linear congruence with modulus = 2^32, multiplier = 69069

diff --git a/byterun/hash.c b/byterun/hash.c

index f896426..12912d3 100644

--- a/byterun/hash.c

+++ b/byterun/hash.c

@@ -41,7 +41,7 @@

   h *= 0xc2b2ae35; \

   h ^= h >> 16;

-CAMLexport uint32 caml_hash_mix_uint32(uint32 h, uint32 d)

+CAMLexport uint32_t caml_hash_mix_uint32(uint32_t h, uint32_t d)

 {

   MIX(h, d);

   return h;

@@ -49,17 +49,17 @@ CAMLexport uint32 caml_hash_mix_uint32(uint32 h, uint32 d)

 /* Mix a platform-native integer. */

-CAMLexport uint32 caml_hash_mix_intnat(uint32 h, intnat d)

+CAMLexport uint32_t caml_hash_mix_intnat(uint32_t h, intnat d)

 {

-  uint32 n;

+  uint32_t n;

 #ifdef ARCH_SIXTYFOUR

   /* Mix the low 32 bits and the high 32 bits, in a way that preserves

-     32/64 compatibility: we want n = (uint32) d

+     32/64 compatibility: we want n = (uint32_t) d

      if d is in the range [-2^31, 2^31-1]. */

   n = (d >> 32) ^ (d >> 63) ^ d;

   /* If 0 <= d < 2^31:   d >> 32 = 0     d >> 63 = 0

      If -2^31 <= d < 0:  d >> 32 = -1    d >> 63 = -1

-     In both cases, n = (uint32) d.  */

+     In both cases, n = (uint32_t) d.  */

 #else

   n = d;

 #endif

@@ -69,9 +69,9 @@ CAMLexport uint32 caml_hash_mix_intnat(uint32 h, intnat d)

 /* Mix a 64-bit integer. */

-CAMLexport uint32 caml_hash_mix_int64(uint32 h, int64 d)

+CAMLexport uint32_t caml_hash_mix_int64(uint32_t h, int64_t d)

 {

-  uint32 hi = (uint32) (d >> 32), lo = (uint32) d;

+  uint32_t hi = (uint32_t) (d >> 32), lo = (uint32_t) d;

   MIX(h, lo);

   MIX(h, hi);

   return h;

@@ -82,17 +82,17 @@ CAMLexport uint32 caml_hash_mix_int64(uint32 h, int64 d)

    Treats all NaNs identically.

 */

-CAMLexport uint32 caml_hash_mix_double(uint32 hash, double d)

+CAMLexport uint32_t caml_hash_mix_double(uint32_t hash, double d)

 {

   union {

     double d;

 #if defined(ARCH_BIG_ENDIAN) || (defined(__arm__) && !defined(__ARM_EABI__))

-    struct { uint32 h; uint32 l; } i;

+    struct { uint32_t h; uint32_t l; } i;

 #else

-    struct { uint32 l; uint32 h; } i;

+    struct { uint32_t l; uint32_t h; } i;

 #endif

   } u;

-  uint32 h, l;

+  uint32_t h, l;

   /* Convert to two 32-bit halves */

   u.d = d;

   h = u.i.h; l = u.i.l;

@@ -115,14 +115,14 @@ CAMLexport uint32 caml_hash_mix_double(uint32 hash, double d)

    Treats all NaNs identically.

 */

-CAMLexport uint32 caml_hash_mix_float(uint32 hash, float d)

+CAMLexport uint32_t caml_hash_mix_float(uint32_t hash, float d)

 {

   union {

     float f;

-    uint32 i;

+    uint32_t i;

   } u;

-  uint32 n;

-  /* Convert to int32 */

+  uint32_t n;

+  /* Convert to int32_t */

   u.f = d;  n = u.i;

   /* Normalize NaNs */

   if ((n & 0x7F800000) == 0x7F800000 && (n & 0x007FFFFF) != 0) {

@@ -138,11 +138,11 @@ CAMLexport uint32 caml_hash_mix_float(uint32 hash, float d)

 /* Mix an OCaml string */

-CAMLexport uint32 caml_hash_mix_string(uint32 h, value s)

+CAMLexport uint32_t caml_hash_mix_string(uint32_t h, value s)

 {

   mlsize_t len = caml_string_length(s);

   mlsize_t i;

-  uint32 w;

+  uint32_t w;

   /* Mix by 32-bit blocks (little-endian) */

   for (i = 0; i + 4 <= len; i += 4) {

@@ -152,7 +152,7 @@ CAMLexport uint32 caml_hash_mix_string(uint32 h, value s)

         | (Byte_u(s, i+2) << 16)

         | (Byte_u(s, i+3) << 24);

 #else

-    w = *((uint32 *) &Byte_u(s, i));

+    w = *((uint32_t *) &Byte_u(s, i));

 #endif

     MIX(h, w);

   }

@@ -166,7 +166,7 @@ CAMLexport uint32 caml_hash_mix_string(uint32 h, value s)

   default: /*skip*/;     /* len & 3 == 0, no extra bytes, do nothing */

   }

   /* Finally, mix in the length.  Ignore the upper 32 bits, generally 0. */

-  h ^= (uint32) len;

+  h ^= (uint32_t) len;

   return h;

 }

@@ -184,7 +184,7 @@ CAMLprim value caml_hash(value count, value limit, value seed, value obj)

   intnat wr;                    /* One past position of last value in queue */

   intnat sz;                    /* Max number of values to put in queue */

   intnat num;                   /* Max number of meaningful values to see */

-  uint32 h;                     /* Rolling hash */

+  uint32_t h;                     /* Rolling hash */

   value v;

   mlsize_t i, len;

@@ -245,7 +245,7 @@ CAMLprim value caml_hash(value count, value limit, value seed, value obj)

         /* If no hashing function provided, do nothing. */

         /* Only use low 32 bits of custom hash, for 32/64 compatibility */

         if (Custom_ops_val(v)->hash != NULL) {

-          uint32 n = (uint32) Custom_ops_val(v)->hash(v);

+          uint32_t n = (uint32_t) Custom_ops_val(v)->hash(v);

           h = caml_hash_mix_uint32(h, n);

           num--;

         }

@@ -408,5 +408,5 @@ CAMLexport value caml_hash_variant(char const * tag)

 #endif

   /* Force sign extension of bit 31 for compatibility between 32 and 64-bit

      platforms */

-  return (int32) accu;

+  return (int32_t) accu;

 }

diff --git a/byterun/hash.h b/byterun/hash.h

index 436a8bb..6561397 100644

--- a/byterun/hash.h

+++ b/byterun/hash.h

@@ -18,12 +18,12 @@

 #include "mlvalues.h"

-CAMLextern uint32 caml_hash_mix_uint32(uint32 h, uint32 d);

-CAMLextern uint32 caml_hash_mix_intnat(uint32 h, intnat d);

-CAMLextern uint32 caml_hash_mix_int64(uint32 h, int64 d);

-CAMLextern uint32 caml_hash_mix_double(uint32 h, double d);

-CAMLextern uint32 caml_hash_mix_float(uint32 h, float d);

-CAMLextern uint32 caml_hash_mix_string(uint32 h, value s);

+CAMLextern uint32_t caml_hash_mix_uint32(uint32_t h, uint32_t d);

+CAMLextern uint32_t caml_hash_mix_intnat(uint32_t h, intnat d);

+CAMLextern uint32_t caml_hash_mix_int64(uint32_t h, int64_t d);

+CAMLextern uint32_t caml_hash_mix_double(uint32_t h, double d);

+CAMLextern uint32_t caml_hash_mix_float(uint32_t h, float d);

+CAMLextern uint32_t caml_hash_mix_string(uint32_t h, value s);

 #endif

diff --git a/byterun/int64_emul.h b/byterun/int64_emul.h

index ba7904a..2554df1 100644

--- a/byterun/int64_emul.h

+++ b/byterun/int64_emul.h

@@ -28,7 +28,7 @@

 #define I64_split(x,hi,lo) (hi = (x).h, lo = (x).l)

 /* Unsigned comparison */

-static int I64_ucompare(uint64 x, uint64 y)

+static int I64_ucompare(uint64_t x, uint64_t y)

 {

   if (x.h > y.h) return 1;

   if (x.h < y.h) return -1;

@@ -40,19 +40,19 @@ static int I64_ucompare(uint64 x, uint64 y)

 #define I64_ult(x, y) (I64_ucompare(x, y) < 0)

 /* Signed comparison */

-static int I64_compare(int64 x, int64 y)

+static int I64_compare(int64_t x, int64_t y)

 {

-  if ((int32)x.h > (int32)y.h) return 1;

-  if ((int32)x.h < (int32)y.h) return -1;

+  if ((int32_t)x.h > (int32_t)y.h) return 1;

+  if ((int32_t)x.h < (int32_t)y.h) return -1;

   if (x.l > y.l) return 1;

   if (x.l < y.l) return -1;

   return 0;

 }

 /* Negation */

-static int64 I64_neg(int64 x)

+static int64_t I64_neg(int64_t x)

 {

-  int64 res;

+  int64_t res;

   res.l = -x.l;

   res.h = ~x.h;

   if (res.l == 0) res.h++;

@@ -60,9 +60,9 @@ static int64 I64_neg(int64 x)

 }

 /* Addition */

-static int64 I64_add(int64 x, int64 y)

+static int64_t I64_add(int64_t x, int64_t y)

 {

-  int64 res;

+  int64_t res;

   res.l = x.l + y.l;

   res.h = x.h + y.h;

   if (res.l < x.l) res.h++;

@@ -70,9 +70,9 @@ static int64 I64_add(int64 x, int64 y)

 }

 /* Subtraction */

-static int64 I64_sub(int64 x, int64 y)

+static int64_t I64_sub(int64_t x, int64_t y)

 {

-  int64 res;

+  int64_t res;

   res.l = x.l - y.l;

   res.h = x.h - y.h;

   if (x.l < y.l) res.h--;

@@ -80,13 +80,13 @@ static int64 I64_sub(int64 x, int64 y)

 }

 /* Multiplication */

-static int64 I64_mul(int64 x, int64 y)

+static int64_t I64_mul(int64_t x, int64_t y)

 {

-  int64 res;

-  uint32 prod00 = (x.l & 0xFFFF) * (y.l & 0xFFFF);

-  uint32 prod10 = (x.l >> 16) * (y.l & 0xFFFF);

-  uint32 prod01 = (x.l & 0xFFFF) * (y.l >> 16);

-  uint32 prod11 = (x.l >> 16) * (y.l >> 16);

+  int64_t res;

+  uint32_t prod00 = (x.l & 0xFFFF) * (y.l & 0xFFFF);

+  uint32_t prod10 = (x.l >> 16) * (y.l & 0xFFFF);

+  uint32_t prod01 = (x.l & 0xFFFF) * (y.l >> 16);

+  uint32_t prod11 = (x.l >> 16) * (y.l >> 16);

   res.l = prod00;

   res.h = prod11 + (prod01 >> 16) + (prod10 >> 16);

   prod01 = prod01 << 16; res.l += prod01; if (res.l < prod01) res.h++;

@@ -96,39 +96,39 @@ static int64 I64_mul(int64 x, int64 y)

 }

 #define I64_is_zero(x) (((x).l | (x).h) == 0)

-#define I64_is_negative(x) ((int32) (x).h < 0)

+#define I64_is_negative(x) ((int32_t) (x).h < 0)

 #define I64_is_min_int(x) ((x).l == 0 && (x).h == 0x80000000U)

 #define I64_is_minus_one(x) (((x).l & (x).h) == 0xFFFFFFFFU)

 /* Bitwise operations */

-static int64 I64_and(int64 x, int64 y)

+static int64_t I64_and(int64_t x, int64_t y)

 {

-  int64 res;

+  int64_t res;

   res.l = x.l & y.l;

   res.h = x.h & y.h;

   return res;

 }

-static int64 I64_or(int64 x, int64 y)

+static int64_t I64_or(int64_t x, int64_t y)

 {

-  int64 res;

+  int64_t res;

   res.l = x.l | y.l;

   res.h = x.h | y.h;

   return res;

 }

-static int64 I64_xor(int64 x, int64 y)

+static int64_t I64_xor(int64_t x, int64_t y)

 {

-  int64 res;

+  int64_t res;

   res.l = x.l ^ y.l;

   res.h = x.h ^ y.h;

   return res;

 }

 /* Shifts */

-static int64 I64_lsl(int64 x, int s)

+static int64_t I64_lsl(int64_t x, int s)

 {

-  int64 res;

+  int64_t res;

   s = s & 63;

   if (s == 0) return x;

   if (s < 32) {

@@ -141,9 +141,9 @@ static int64 I64_lsl(int64 x, int s)

   return res;

 }

-static int64 I64_lsr(int64 x, int s)

+static int64_t I64_lsr(int64_t x, int s)

 {

-  int64 res;

+  int64_t res;

   s = s & 63;

   if (s == 0) return x;

   if (s < 32) {

@@ -156,17 +156,17 @@ static int64 I64_lsr(int64 x, int s)

   return res;

 }

-static int64 I64_asr(int64 x, int s)

+static int64_t I64_asr(int64_t x, int s)

 {

-  int64 res;

+  int64_t res;

   s = s & 63;

   if (s == 0) return x;

   if (s < 32) {

     res.l = (x.l >> s) | (x.h << (32 - s));

-    res.h = (int32) x.h >> s;

+    res.h = (int32_t) x.h >> s;

   } else {

-    res.l = (int32) x.h >> (s - 32);

-    res.h = (int32) x.h >> 31;

+    res.l = (int32_t) x.h >> (s - 32);

+    res.h = (int32_t) x.h >> 31;

   }

   return res;

 }

@@ -176,15 +176,15 @@ static int64 I64_asr(int64 x, int s)

 #define I64_SHL1(x) x.h = (x.h << 1) | (x.l >> 31); x.l <<= 1

 #define I64_SHR1(x) x.l = (x.l >> 1) | (x.h << 31); x.h >>= 1

-static void I64_udivmod(uint64 modulus, uint64 divisor,

-                        uint64 * quo, uint64 * mod)

+static void I64_udivmod(uint64_t modulus, uint64_t divisor,

+                        uint64_t * quo, uint64_t * mod)

 {

-  int64 quotient, mask;

+  int64_t quotient, mask;

   int cmp;

   quotient.h = 0; quotient.l = 0;

   mask.h = 0; mask.l = 1;

-  while ((int32) divisor.h >= 0) {

+  while ((int32_t) divisor.h >= 0) {

     cmp = I64_ucompare(divisor, modulus);

     I64_SHL1(divisor);

     I64_SHL1(mask);

@@ -202,27 +202,27 @@ static void I64_udivmod(uint64 modulus, uint64 divisor,

   *mod = modulus;

 }