diff --git a/0001-Don-t-ignore-.-configure-it-s-a-real-git-file.patch b/0001-Don-t-ignore-.-configure-it-s-a-real-git-file.patch index 9b1aa04..5457965 100644 --- a/0001-Don-t-ignore-.-configure-it-s-a-real-git-file.patch +++ b/0001-Don-t-ignore-.-configure-it-s-a-real-git-file.patch @@ -1,7 +1,7 @@ -From b82c357ec2006551276ec850537eead05f231c65 Mon Sep 17 00:00:00 2001 +From ccc1bf226619608230dc94b26377756719cf7b20 Mon Sep 17 00:00:00 2001 From: "Richard W.M. Jones" Date: Tue, 24 Jun 2014 22:29:38 +0100 -Subject: [PATCH 01/10] Don't ignore ./configure, it's a real git file. +Subject: [PATCH 01/11] Don't ignore ./configure, it's a real git file. --- .gitignore | 1 - diff --git a/0002-Ensure-empty-compilerlibs-directory-is-created-by-gi.patch b/0002-Ensure-empty-compilerlibs-directory-is-created-by-gi.patch index 9b6f261..310f51c 100644 --- a/0002-Ensure-empty-compilerlibs-directory-is-created-by-gi.patch +++ b/0002-Ensure-empty-compilerlibs-directory-is-created-by-gi.patch @@ -1,7 +1,7 @@ -From 5bdd0491e1416bb33050ebd87a3fab3a23c8af97 Mon Sep 17 00:00:00 2001 +From 0e3b6450f6ab803442a809b6da41d5d5c5da650f Mon Sep 17 00:00:00 2001 From: "Richard W.M. Jones" Date: Thu, 7 Jun 2012 15:36:16 +0100 -Subject: [PATCH 02/10] Ensure empty compilerlibs/ directory is created by git. +Subject: [PATCH 02/11] Ensure empty compilerlibs/ directory is created by git. This directory exists in the OCaml tarball, but is empty. As a result, git ignores it unless we put a dummy file in it. diff --git a/0003-Don-t-add-rpaths-to-libraries.patch b/0003-Don-t-add-rpaths-to-libraries.patch index aabcc00..09ad172 100644 --- a/0003-Don-t-add-rpaths-to-libraries.patch +++ b/0003-Don-t-add-rpaths-to-libraries.patch @@ -1,7 +1,7 @@ -From 80e6085da156af1c6f64f05be3b02b63b8ed6d8d Mon Sep 17 00:00:00 2001 +From 79f0f91e3e4abbfbd3564c11ea72e53310236afc Mon Sep 17 00:00:00 2001 From: "Richard W.M. Jones" Date: Tue, 24 Jun 2014 10:00:15 +0100 -Subject: [PATCH 03/10] Don't add rpaths to libraries. +Subject: [PATCH 03/11] Don't add rpaths to libraries. --- tools/Makefile.shared | 6 +++--- diff --git a/0004-ocamlbyteinfo-ocamlplugininfo-Useful-utilities-from-.patch b/0004-ocamlbyteinfo-ocamlplugininfo-Useful-utilities-from-.patch index 8f6575f..f970b0c 100644 --- a/0004-ocamlbyteinfo-ocamlplugininfo-Useful-utilities-from-.patch +++ b/0004-ocamlbyteinfo-ocamlplugininfo-Useful-utilities-from-.patch @@ -1,7 +1,7 @@ -From 9d21ab16494b43872ab6a5a359ff2e327ed8486c Mon Sep 17 00:00:00 2001 +From 11b377aee2811891635982a5590fef62f12645b6 Mon Sep 17 00:00:00 2001 From: "Richard W.M. Jones" Date: Tue, 29 May 2012 20:40:36 +0100 -Subject: [PATCH 04/10] ocamlbyteinfo, ocamlplugininfo: Useful utilities from +Subject: [PATCH 04/11] ocamlbyteinfo, ocamlplugininfo: Useful utilities from Debian, sent upstream. See: diff --git a/0005-configure-Allow-user-defined-C-compiler-flags.patch b/0005-configure-Allow-user-defined-C-compiler-flags.patch index 2d94ac6..5220db3 100644 --- a/0005-configure-Allow-user-defined-C-compiler-flags.patch +++ b/0005-configure-Allow-user-defined-C-compiler-flags.patch @@ -1,7 +1,7 @@ -From 1560523eee4445a28f10f872f8d4b0210c0c4f4b Mon Sep 17 00:00:00 2001 +From 5308c47681201ef3beef3e543ab877f81aa08784 Mon Sep 17 00:00:00 2001 From: "Richard W.M. Jones" Date: Tue, 29 May 2012 20:44:18 +0100 -Subject: [PATCH 05/10] configure: Allow user defined C compiler flags. +Subject: [PATCH 05/11] configure: Allow user defined C compiler flags. --- configure | 4 ++++ diff --git a/0006-Add-support-for-ppc64.patch b/0006-Add-support-for-ppc64.patch index e9d9b0e..900c625 100644 --- a/0006-Add-support-for-ppc64.patch +++ b/0006-Add-support-for-ppc64.patch @@ -1,7 +1,7 @@ -From 39da8f7124a972e1b7c96af9ca69f9aff7532110 Mon Sep 17 00:00:00 2001 +From b97622b54339f810bdca378ba7e58e5ad3152330 Mon Sep 17 00:00:00 2001 From: "Richard W.M. Jones" Date: Tue, 29 May 2012 20:47:07 +0100 -Subject: [PATCH 06/10] Add support for ppc64. +Subject: [PATCH 06/11] Add support for ppc64. Note (1): This patch was rejected upstream because they don't have appropriate hardware for testing. diff --git a/0007-Add-support-for-ppc64le.patch b/0007-Add-support-for-ppc64le.patch index 478ae86..d0f2029 100644 --- a/0007-Add-support-for-ppc64le.patch +++ b/0007-Add-support-for-ppc64le.patch @@ -1,7 +1,7 @@ -From 81f0522871559e17591efaac09d4b7b9d9b5dc50 Mon Sep 17 00:00:00 2001 +From 6e3ca14f2d4dba2612eff59126140cde0d04394f Mon Sep 17 00:00:00 2001 From: Michel Normand Date: Tue, 18 Mar 2014 09:15:47 -0400 -Subject: [PATCH 07/10] Add support for ppc64le. +Subject: [PATCH 07/11] Add support for ppc64le. Signed-off-by: Michel Normand --- diff --git a/0008-arm-arm64-Mark-stack-as-non-executable.patch b/0008-arm-arm64-Mark-stack-as-non-executable.patch index 97eefe4..75403ae 100644 --- a/0008-arm-arm64-Mark-stack-as-non-executable.patch +++ b/0008-arm-arm64-Mark-stack-as-non-executable.patch @@ -1,7 +1,7 @@ -From 3a69252da94db29ea343ef9f5c1a84685cb60eee Mon Sep 17 00:00:00 2001 +From a2a1e564bbe995f44de2023893f6dea51668b51e Mon Sep 17 00:00:00 2001 From: "Richard W.M. Jones" Date: Sat, 10 May 2014 03:20:35 -0400 -Subject: [PATCH 08/10] arm, arm64: Mark stack as non-executable. +Subject: [PATCH 08/11] arm, arm64: Mark stack as non-executable. The same fix as this one, which was only fully applied to i686 & x86-64: diff --git a/0009-arg-Add-no_arg-and-get_arg-helper-functions.patch b/0009-arg-Add-no_arg-and-get_arg-helper-functions.patch index e3cc200..3a5d1d6 100644 --- a/0009-arg-Add-no_arg-and-get_arg-helper-functions.patch +++ b/0009-arg-Add-no_arg-and-get_arg-helper-functions.patch @@ -1,7 +1,7 @@ -From 8903821937e38fc62571a6e42b699ab4d46b611e Mon Sep 17 00:00:00 2001 +From 9e70610b08939bef354be508eb8eec6a498ec663 Mon Sep 17 00:00:00 2001 From: "Richard W.M. Jones" Date: Tue, 1 Apr 2014 11:17:07 +0100 -Subject: [PATCH 09/10] arg: Add no_arg and get_arg helper functions. +Subject: [PATCH 09/11] arg: Add no_arg and get_arg helper functions. The no_arg function in this patch is a no-op. It will do something useful in the followups. diff --git a/0010-arg-Allow-flags-such-as-flag-arg-as-well-as-flag-arg.patch b/0010-arg-Allow-flags-such-as-flag-arg-as-well-as-flag-arg.patch index b8bf7d9..6b4436f 100644 --- a/0010-arg-Allow-flags-such-as-flag-arg-as-well-as-flag-arg.patch +++ b/0010-arg-Allow-flags-such-as-flag-arg-as-well-as-flag-arg.patch @@ -1,7 +1,7 @@ -From 485f2f45afcfbfe4046169dea1f971a8124e0fcf Mon Sep 17 00:00:00 2001 +From 40e1fd09162cccabe79013c9f663c1b970dee771 Mon Sep 17 00:00:00 2001 From: "Richard W.M. Jones" Date: Tue, 1 Apr 2014 11:21:40 +0100 -Subject: [PATCH 10/10] arg: Allow flags such as --flag=arg as well as --flag +Subject: [PATCH 10/11] arg: Allow flags such as --flag=arg as well as --flag arg. Allow flags to be followed directly by their argument, separated by an '=' diff --git a/0011-PR-6517-use-ISO-C99-types-u-int-32-64-_t-in-preferen.patch b/0011-PR-6517-use-ISO-C99-types-u-int-32-64-_t-in-preferen.patch new file mode 100644 index 0000000..ee4c3db --- /dev/null +++ b/0011-PR-6517-use-ISO-C99-types-u-int-32-64-_t-in-preferen.patch @@ -0,0 +1,1963 @@ +From 2c490afbb343fb84930890ec552b876e6481cf0a Mon Sep 17 00:00:00 2001 +From: Xavier Leroy +Date: Wed, 27 Aug 2014 09:58:33 +0000 +Subject: [PATCH 11/11] 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 ++#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; + } + +-static int64 I64_div(int64 x, int64 y) ++static int64_t I64_div(int64_t x, int64_t y) + { +- int64 q, r; +- int32 sign; ++ int64_t q, r; ++ int32_t sign; + + sign = x.h ^ y.h; +- if ((int32) x.h < 0) x = I64_neg(x); +- if ((int32) y.h < 0) y = I64_neg(y); ++ if ((int32_t) x.h < 0) x = I64_neg(x); ++ if ((int32_t) y.h < 0) y = I64_neg(y); + I64_udivmod(x, y, &q, &r); + if (sign < 0) q = I64_neg(q); + return q; + } + +-static int64 I64_mod(int64 x, int64 y) ++static int64_t I64_mod(int64_t x, int64_t y) + { +- int64 q, r; +- int32 sign; ++ int64_t q, r; ++ int32_t sign; + + sign = x.h; +- if ((int32) x.h < 0) x = I64_neg(x); +- if ((int32) y.h < 0) y = I64_neg(y); ++ if ((int32_t) x.h < 0) x = I64_neg(x); ++ if ((int32_t) y.h < 0) y = I64_neg(y); + I64_udivmod(x, y, &q, &r); + if (sign < 0) r = I64_neg(r); + return r; +@@ -230,49 +230,49 @@ static int64 I64_mod(int64 x, int64 y) + + /* Coercions */ + +-static int64 I64_of_int32(int32 x) ++static int64_t I64_of_int32(int32_t x) + { +- int64 res; ++ int64_t res; + res.l = x; + res.h = x >> 31; + return res; + } + +-#define I64_to_int32(x) ((int32) (x).l) ++#define I64_to_int32(x) ((int32_t) (x).l) + + /* Note: we assume sizeof(intnat) = 4 here, which is true otherwise + autoconfiguration would have selected native 64-bit integers */ + #define I64_of_intnat I64_of_int32 + #define I64_to_intnat I64_to_int32 + +-static double I64_to_double(int64 x) ++static double I64_to_double(int64_t x) + { + double res; +- int32 sign = x.h; ++ int32_t sign = x.h; + if (sign < 0) x = I64_neg(x); + res = ldexp((double) x.h, 32) + x.l; + if (sign < 0) res = -res; + return res; + } + +-static int64 I64_of_double(double f) ++static int64_t I64_of_double(double f) + { +- int64 res; ++ int64_t res; + double frac, integ; + int neg; + + neg = (f < 0); + f = fabs(f); + frac = modf(ldexp(f, -32), &integ); +- res.h = (uint32) integ; +- res.l = (uint32) ldexp(frac, 32); ++ res.h = (uint32_t) integ; ++ res.l = (uint32_t) ldexp(frac, 32); + if (neg) res = I64_neg(res); + return res; + } + +-static int64 I64_bswap(int64 x) ++static int64_t I64_bswap(int64_t x) + { +- int64 res; ++ int64_t res; + res.h = (((x.l & 0x000000FF) << 24) | + ((x.l & 0x0000FF00) << 8) | + ((x.l & 0x00FF0000) >> 8) | +diff --git a/byterun/int64_format.h b/byterun/int64_format.h +index b0de527..aa8f1ab 100644 +--- a/byterun/int64_format.h ++++ b/byterun/int64_format.h +@@ -17,7 +17,7 @@ + #ifndef CAML_INT64_FORMAT_H + #define CAML_INT64_FORMAT_H + +-static void I64_format(char * buffer, char * fmt, int64 x) ++static void I64_format(char * buffer, char * fmt, int64_t x) + { + static char conv_lower[] = "0123456789abcdef"; + static char conv_upper[] = "0123456789ABCDEF"; +@@ -26,7 +26,7 @@ static void I64_format(char * buffer, char * fmt, int64 x) + int base, width, sign, i, rawlen; + char * cvtbl; + char * p, * r; +- int64 wbase, digit; ++ int64_t wbase, digit; + + /* Parsing of format */ + justify = '+'; +diff --git a/byterun/int64_native.h b/byterun/int64_native.h +index e9ffe67..b6716ad 100644 +--- a/byterun/int64_native.h ++++ b/byterun/int64_native.h +@@ -18,36 +18,36 @@ + #ifndef CAML_INT64_NATIVE_H + #define CAML_INT64_NATIVE_H + +-#define I64_literal(hi,lo) ((int64)(hi) << 32 | (lo)) +-#define I64_split(x,hi,lo) (hi = (uint32)((x)>>32), lo = (uint32)(x)) ++#define I64_literal(hi,lo) ((int64_t)(hi) << 32 | (lo)) ++#define I64_split(x,hi,lo) (hi = (uint32_t)((x)>>32), lo = (uint32_t)(x)) + #define I64_compare(x,y) (((x) > (y)) - ((x) < (y))) +-#define I64_ult(x,y) ((uint64)(x) < (uint64)(y)) ++#define I64_ult(x,y) ((uint64_t)(x) < (uint64_t)(y)) + #define I64_neg(x) (-(x)) + #define I64_add(x,y) ((x) + (y)) + #define I64_sub(x,y) ((x) - (y)) + #define I64_mul(x,y) ((x) * (y)) + #define I64_is_zero(x) ((x) == 0) + #define I64_is_negative(x) ((x) < 0) +-#define I64_is_min_int(x) ((x) == ((int64)1 << 63)) ++#define I64_is_min_int(x) ((x) == ((int64_t)1 << 63)) + #define I64_is_minus_one(x) ((x) == -1) + + #define I64_div(x,y) ((x) / (y)) + #define I64_mod(x,y) ((x) % (y)) + #define I64_udivmod(x,y,quo,rem) \ +- (*(rem) = (uint64)(x) % (uint64)(y), \ +- *(quo) = (uint64)(x) / (uint64)(y)) ++ (*(rem) = (uint64_t)(x) % (uint64_t)(y), \ ++ *(quo) = (uint64_t)(x) / (uint64_t)(y)) + #define I64_and(x,y) ((x) & (y)) + #define I64_or(x,y) ((x) | (y)) + #define I64_xor(x,y) ((x) ^ (y)) + #define I64_lsl(x,y) ((x) << (y)) + #define I64_asr(x,y) ((x) >> (y)) +-#define I64_lsr(x,y) ((uint64)(x) >> (y)) ++#define I64_lsr(x,y) ((uint64_t)(x) >> (y)) + #define I64_to_intnat(x) ((intnat) (x)) + #define I64_of_intnat(x) ((intnat) (x)) +-#define I64_to_int32(x) ((int32) (x)) +-#define I64_of_int32(x) ((int64) (x)) ++#define I64_to_int32(x) ((int32_t) (x)) ++#define I64_of_int32(x) ((int64_t) (x)) + #define I64_to_double(x) ((double)(x)) +-#define I64_of_double(x) ((int64)(x)) ++#define I64_of_double(x) ((int64_t)(x)) + + #define I64_bswap(x) ((((x) & 0x00000000000000FFULL) << 56) | \ + (((x) & 0x000000000000FF00ULL) << 40) | \ +diff --git a/byterun/intern.c b/byterun/intern.c +index e0fcc5d..638ff72 100644 +--- a/byterun/intern.c ++++ b/byterun/intern.c +@@ -553,7 +553,7 @@ static void intern_add_to_heap(mlsize_t whsize) + + value caml_input_val(struct channel *chan) + { +- uint32 magic; ++ uint32_t magic; + mlsize_t block_len, num_objects, whsize; + char * block; + value res; +@@ -663,7 +663,7 @@ static value input_val_from_block(void) + + CAMLexport value caml_input_value_from_malloc(char * data, intnat ofs) + { +- uint32 magic; ++ uint32_t magic; + value obj; + + intern_input = (unsigned char *) data; +@@ -681,7 +681,7 @@ CAMLexport value caml_input_value_from_malloc(char * data, intnat ofs) + + CAMLexport value caml_input_value_from_block(char * data, intnat len) + { +- uint32 magic; ++ uint32_t magic; + mlsize_t block_len; + value obj; + +@@ -700,7 +700,7 @@ CAMLexport value caml_input_value_from_block(char * data, intnat len) + + CAMLprim value caml_marshal_data_size(value buff, value ofs) + { +- uint32 magic; ++ uint32_t magic; + mlsize_t block_len; + + intern_src = &Byte_u(buff, Long_val(ofs)); +@@ -771,26 +771,26 @@ CAMLexport int caml_deserialize_sint_2(void) + return read16s(); + } + +-CAMLexport uint32 caml_deserialize_uint_4(void) ++CAMLexport uint32_t caml_deserialize_uint_4(void) + { + return read32u(); + } + +-CAMLexport int32 caml_deserialize_sint_4(void) ++CAMLexport int32_t caml_deserialize_sint_4(void) + { + return read32s(); + } + +-CAMLexport uint64 caml_deserialize_uint_8(void) ++CAMLexport uint64_t caml_deserialize_uint_8(void) + { +- uint64 i; ++ uint64_t i; + caml_deserialize_block_8(&i, 1); + return i; + } + +-CAMLexport int64 caml_deserialize_sint_8(void) ++CAMLexport int64_t caml_deserialize_sint_8(void) + { +- int64 i; ++ int64_t i; + caml_deserialize_block_8(&i, 1); + return i; + } +diff --git a/byterun/interp.c b/byterun/interp.c +index 9b682ba..e22b28b 100644 +--- a/byterun/interp.c ++++ b/byterun/interp.c +@@ -793,7 +793,7 @@ value caml_interprete(code_t prog, asize_t prog_size) + if (accu == Val_false) pc += *pc; else pc++; + Next; + Instruct(SWITCH): { +- uint32 sizes = *pc++; ++ uint32_t sizes = *pc++; + if (Is_block(accu)) { + intnat index = Tag_val(accu); + Assert ((uintnat) index < (sizes >> 16)); +diff --git a/byterun/intext.h b/byterun/intext.h +index f7aa655..2c108a4 100644 +--- a/byterun/intext.h ++++ b/byterun/intext.h +@@ -119,8 +119,8 @@ CAMLextern value caml_input_value_from_block(char * data, intnat len); + + CAMLextern void caml_serialize_int_1(int i); + CAMLextern void caml_serialize_int_2(int i); +-CAMLextern void caml_serialize_int_4(int32 i); +-CAMLextern void caml_serialize_int_8(int64 i); ++CAMLextern void caml_serialize_int_4(int32_t i); ++CAMLextern void caml_serialize_int_8(int64_t i); + CAMLextern void caml_serialize_float_4(float f); + CAMLextern void caml_serialize_float_8(double f); + CAMLextern void caml_serialize_block_1(void * data, intnat len); +@@ -133,10 +133,10 @@ CAMLextern int caml_deserialize_uint_1(void); + CAMLextern int caml_deserialize_sint_1(void); + CAMLextern int caml_deserialize_uint_2(void); + CAMLextern int caml_deserialize_sint_2(void); +-CAMLextern uint32 caml_deserialize_uint_4(void); +-CAMLextern int32 caml_deserialize_sint_4(void); +-CAMLextern uint64 caml_deserialize_uint_8(void); +-CAMLextern int64 caml_deserialize_sint_8(void); ++CAMLextern uint32_t caml_deserialize_uint_4(void); ++CAMLextern int32_t caml_deserialize_sint_4(void); ++CAMLextern uint64_t caml_deserialize_uint_8(void); ++CAMLextern int64_t caml_deserialize_sint_8(void); + CAMLextern float caml_deserialize_float_4(void); + CAMLextern double caml_deserialize_float_8(void); + CAMLextern void caml_deserialize_block_1(void * data, intnat len); +diff --git a/byterun/ints.c b/byterun/ints.c +index d762c76..056e82a 100644 +--- a/byterun/ints.c ++++ b/byterun/ints.c +@@ -172,8 +172,8 @@ CAMLprim value caml_format_int(value fmt, value arg) + + static int int32_cmp(value v1, value v2) + { +- int32 i1 = Int32_val(v1); +- int32 i2 = Int32_val(v2); ++ int32_t i1 = Int32_val(v1); ++ int32_t i2 = Int32_val(v2); + return (i1 > i2) - (i1 < i2); + } + +@@ -191,7 +191,7 @@ static void int32_serialize(value v, uintnat * wsize_32, + + static uintnat int32_deserialize(void * dst) + { +- *((int32 *) dst) = caml_deserialize_sint_4(); ++ *((int32_t *) dst) = caml_deserialize_sint_4(); + return 4; + } + +@@ -205,7 +205,7 @@ CAMLexport struct custom_operations caml_int32_ops = { + custom_compare_ext_default + }; + +-CAMLexport value caml_copy_int32(int32 i) ++CAMLexport value caml_copy_int32(int32_t i) + { + value res = caml_alloc_custom(&caml_int32_ops, 4, 0, 1); + Int32_val(res) = i; +@@ -226,8 +226,8 @@ CAMLprim value caml_int32_mul(value v1, value v2) + + CAMLprim value caml_int32_div(value v1, value v2) + { +- int32 dividend = Int32_val(v1); +- int32 divisor = Int32_val(v2); ++ int32_t dividend = Int32_val(v1); ++ int32_t divisor = Int32_val(v2); + if (divisor == 0) caml_raise_zero_divide(); + /* PR#4740: on some processors, division crashes on overflow. + Implement the same behavior as for type "int". */ +@@ -237,8 +237,8 @@ CAMLprim value caml_int32_div(value v1, value v2) + + CAMLprim value caml_int32_mod(value v1, value v2) + { +- int32 dividend = Int32_val(v1); +- int32 divisor = Int32_val(v2); ++ int32_t dividend = Int32_val(v1); ++ int32_t divisor = Int32_val(v2); + if (divisor == 0) caml_raise_zero_divide(); + /* PR#4740: on some processors, modulus crashes if division overflows. + Implement the same behavior as for type "int". */ +@@ -262,9 +262,9 @@ CAMLprim value caml_int32_shift_right(value v1, value v2) + { return caml_copy_int32(Int32_val(v1) >> Int_val(v2)); } + + CAMLprim value caml_int32_shift_right_unsigned(value v1, value v2) +-{ return caml_copy_int32((uint32)Int32_val(v1) >> Int_val(v2)); } ++{ return caml_copy_int32((uint32_t)Int32_val(v1) >> Int_val(v2)); } + +-static int32 caml_swap32(int32 x) ++static int32_t caml_swap32(int32_t x) + { + return (((x & 0x000000FF) << 24) | + ((x & 0x0000FF00) << 8) | +@@ -285,15 +285,15 @@ CAMLprim value caml_int32_to_int(value v) + { return Val_long(Int32_val(v)); } + + CAMLprim value caml_int32_of_float(value v) +-{ return caml_copy_int32((int32)(Double_val(v))); } ++{ return caml_copy_int32((int32_t)(Double_val(v))); } + + CAMLprim value caml_int32_to_float(value v) + { return caml_copy_double((double)(Int32_val(v))); } + + CAMLprim value caml_int32_compare(value v1, value v2) + { +- int32 i1 = Int32_val(v1); +- int32 i2 = Int32_val(v2); ++ int32_t i1 = Int32_val(v1); ++ int32_t i2 = Int32_val(v2); + int res = (i1 > i2) - (i1 < i2); + return Val_int(res); + } +@@ -313,14 +313,14 @@ CAMLprim value caml_int32_of_string(value s) + + CAMLprim value caml_int32_bits_of_float(value vd) + { +- union { float d; int32 i; } u; ++ union { float d; int32_t i; } u; + u.d = Double_val(vd); + return caml_copy_int32(u.i); + } + + CAMLprim value caml_int32_float_of_bits(value vi) + { +- union { float d; int32 i; } u; ++ union { float d; int32_t i; } u; + u.i = Int32_val(vi); + return caml_copy_double(u.d); + } +@@ -329,11 +329,11 @@ CAMLprim value caml_int32_float_of_bits(value vi) + + #ifdef ARCH_ALIGN_INT64 + +-CAMLexport int64 caml_Int64_val(value v) ++CAMLexport int64_t caml_Int64_val(value v) + { +- union { int32 i[2]; int64 j; } buffer; +- buffer.i[0] = ((int32 *) Data_custom_val(v))[0]; +- buffer.i[1] = ((int32 *) Data_custom_val(v))[1]; ++ union { int32_t i[2]; int64_t j; } buffer; ++ buffer.i[0] = ((int32_t *) Data_custom_val(v))[0]; ++ buffer.i[1] = ((int32_t *) Data_custom_val(v))[1]; + return buffer.j; + } + +@@ -341,15 +341,15 @@ CAMLexport int64 caml_Int64_val(value v) + + static int int64_cmp(value v1, value v2) + { +- int64 i1 = Int64_val(v1); +- int64 i2 = Int64_val(v2); ++ int64_t i1 = Int64_val(v1); ++ int64_t i2 = Int64_val(v2); + return (i1 > i2) - (i1 < i2); + } + + static intnat int64_hash(value v) + { +- int64 x = Int64_val(v); +- uint32 lo = (uint32) x, hi = (uint32) (x >> 32); ++ int64_t x = Int64_val(v); ++ uint32_t lo = (uint32_t) x, hi = (uint32_t) (x >> 32); + return hi ^ lo; + } + +@@ -363,12 +363,12 @@ static void int64_serialize(value v, uintnat * wsize_32, + static uintnat int64_deserialize(void * dst) + { + #ifndef ARCH_ALIGN_INT64 +- *((int64 *) dst) = caml_deserialize_sint_8(); ++ *((int64_t *) dst) = caml_deserialize_sint_8(); + #else +- union { int32 i[2]; int64 j; } buffer; ++ union { int32_t i[2]; int64_t j; } buffer; + buffer.j = caml_deserialize_sint_8(); +- ((int32 *) dst)[0] = buffer.i[0]; +- ((int32 *) dst)[1] = buffer.i[1]; ++ ((int32_t *) dst)[0] = buffer.i[0]; ++ ((int32_t *) dst)[1] = buffer.i[1]; + #endif + return 8; + } +@@ -383,16 +383,16 @@ CAMLexport struct custom_operations caml_int64_ops = { + custom_compare_ext_default + }; + +-CAMLexport value caml_copy_int64(int64 i) ++CAMLexport value caml_copy_int64(int64_t i) + { + value res = caml_alloc_custom(&caml_int64_ops, 8, 0, 1); + #ifndef ARCH_ALIGN_INT64 + Int64_val(res) = i; + #else +- union { int32 i[2]; int64 j; } buffer; ++ union { int32_t i[2]; int64_t j; } buffer; + buffer.j = i; +- ((int32 *) Data_custom_val(res))[0] = buffer.i[0]; +- ((int32 *) Data_custom_val(res))[1] = buffer.i[1]; ++ ((int32_t *) Data_custom_val(res))[0] = buffer.i[0]; ++ ((int32_t *) Data_custom_val(res))[1] = buffer.i[1]; + #endif + return res; + } +@@ -413,23 +413,23 @@ CAMLprim value caml_int64_mul(value v1, value v2) + + CAMLprim value caml_int64_div(value v1, value v2) + { +- int64 dividend = Int64_val(v1); +- int64 divisor = Int64_val(v2); ++ int64_t dividend = Int64_val(v1); ++ int64_t divisor = Int64_val(v2); + if (divisor == 0) caml_raise_zero_divide(); + /* PR#4740: on some processors, division crashes on overflow. + Implement the same behavior as for type "int". */ +- if (dividend == ((int64)1 << 63) && divisor == -1) return v1; ++ if (dividend == ((int64_t)1 << 63) && divisor == -1) return v1; + return caml_copy_int64(Int64_val(v1) / divisor); + } + + CAMLprim value caml_int64_mod(value v1, value v2) + { +- int64 dividend = Int64_val(v1); +- int64 divisor = Int64_val(v2); ++ int64_t dividend = Int64_val(v1); ++ int64_t divisor = Int64_val(v2); + if (divisor == 0) caml_raise_zero_divide(); + /* PR#4740: on some processors, division crashes on overflow. + Implement the same behavior as for type "int". */ +- if (dividend == ((int64)1 << 63) && divisor == -1) return caml_copy_int64(0); ++ if (dividend == ((int64_t)1 << 63) && divisor == -1) return caml_copy_int64(0); + return caml_copy_int64(Int64_val(v1) % divisor); + } + +@@ -449,7 +449,7 @@ CAMLprim value caml_int64_shift_right(value v1, value v2) + { return caml_copy_int64(Int64_val(v1) >> Int_val(v2)); } + + CAMLprim value caml_int64_shift_right_unsigned(value v1, value v2) +-{ return caml_copy_int64((uint64) (Int64_val(v1)) >> Int_val(v2)); } ++{ return caml_copy_int64((uint64_t) (Int64_val(v1)) >> Int_val(v2)); } + + #ifdef ARCH_SIXTYFOUR + static value caml_swap64(value x) +@@ -470,7 +470,7 @@ value caml_int64_direct_bswap(value v) + + CAMLprim value caml_int64_bswap(value v) + { +- int64 x = Int64_val(v); ++ int64_t x = Int64_val(v); + return caml_copy_int64 + (((x & 0x00000000000000FFULL) << 56) | + ((x & 0x000000000000FF00ULL) << 40) | +@@ -483,33 +483,33 @@ CAMLprim value caml_int64_bswap(value v) + } + + CAMLprim value caml_int64_of_int(value v) +-{ return caml_copy_int64((int64) (Long_val(v))); } ++{ return caml_copy_int64((int64_t) (Long_val(v))); } + + CAMLprim value caml_int64_to_int(value v) + { return Val_long((intnat) (Int64_val(v))); } + + CAMLprim value caml_int64_of_float(value v) +-{ return caml_copy_int64((int64) (Double_val(v))); } ++{ return caml_copy_int64((int64_t) (Double_val(v))); } + + CAMLprim value caml_int64_to_float(value v) + { return caml_copy_double((double) (Int64_val(v))); } + + CAMLprim value caml_int64_of_int32(value v) +-{ return caml_copy_int64((int64) (Int32_val(v))); } ++{ return caml_copy_int64((int64_t) (Int32_val(v))); } + + CAMLprim value caml_int64_to_int32(value v) +-{ return caml_copy_int32((int32) (Int64_val(v))); } ++{ return caml_copy_int32((int32_t) (Int64_val(v))); } + + CAMLprim value caml_int64_of_nativeint(value v) +-{ return caml_copy_int64((int64) (Nativeint_val(v))); } ++{ return caml_copy_int64((int64_t) (Nativeint_val(v))); } + + CAMLprim value caml_int64_to_nativeint(value v) + { return caml_copy_nativeint((intnat) (Int64_val(v))); } + + CAMLprim value caml_int64_compare(value v1, value v2) + { +- int64 i1 = Int64_val(v1); +- int64 i2 = Int64_val(v2); ++ int64_t i1 = Int64_val(v1); ++ int64_t i2 = Int64_val(v2); + return Val_int((i1 > i2) - (i1 < i2)); + } + +@@ -524,11 +524,11 @@ CAMLprim value caml_int64_format(value fmt, value arg) + CAMLprim value caml_int64_of_string(value s) + { + char * p; +- uint64 res, threshold; ++ uint64_t res, threshold; + int sign, base, d; + + p = parse_sign_and_base(String_val(s), &base, &sign); +- threshold = ((uint64) -1) / base; ++ threshold = ((uint64_t) -1) / base; + d = parse_digit(*p); + if (d < 0 || d >= base) caml_failwith("int_of_string"); + res = d; +@@ -541,7 +541,7 @@ CAMLprim value caml_int64_of_string(value s) + if (res > threshold) caml_failwith("int_of_string"); + res = base * res + d; + /* Detect overflow in addition (base * res) + d */ +- if (res < (uint64) d) caml_failwith("int_of_string"); ++ if (res < (uint64_t) d) caml_failwith("int_of_string"); + } + if (p != String_val(s) + caml_string_length(s)){ + caml_failwith("int_of_string"); +@@ -549,9 +549,9 @@ CAMLprim value caml_int64_of_string(value s) + if (base == 10) { + /* Signed representation expected, allow -2^63 to 2^63 - 1 only */ + if (sign >= 0) { +- if (res >= (uint64)1 << 63) caml_failwith("int_of_string"); ++ if (res >= (uint64_t)1 << 63) caml_failwith("int_of_string"); + } else { +- if (res > (uint64)1 << 63) caml_failwith("int_of_string"); ++ if (res > (uint64_t)1 << 63) caml_failwith("int_of_string"); + } + } + if (sign < 0) res = - res; +@@ -560,20 +560,20 @@ CAMLprim value caml_int64_of_string(value s) + + CAMLprim value caml_int64_bits_of_float(value vd) + { +- union { double d; int64 i; int32 h[2]; } u; ++ union { double d; int64_t i; int32_t h[2]; } u; + u.d = Double_val(vd); + #if defined(__arm__) && !defined(__ARM_EABI__) +- { int32 t = u.h[0]; u.h[0] = u.h[1]; u.h[1] = t; } ++ { int32_t t = u.h[0]; u.h[0] = u.h[1]; u.h[1] = t; } + #endif + return caml_copy_int64(u.i); + } + + CAMLprim value caml_int64_float_of_bits(value vi) + { +- union { double d; int64 i; int32 h[2]; } u; ++ union { double d; int64_t i; int32_t h[2]; } u; + u.i = Int64_val(vi); + #if defined(__arm__) && !defined(__ARM_EABI__) +- { int32 t = u.h[0]; u.h[0] = u.h[1]; u.h[1] = t; } ++ { int32_t t = u.h[0]; u.h[0] = u.h[1]; u.h[1] = t; } + #endif + return caml_copy_double(u.d); + } +@@ -606,7 +606,7 @@ static void nativeint_serialize(value v, uintnat * wsize_32, + #ifdef ARCH_SIXTYFOUR + if (l >= -((intnat)1 << 31) && l < ((intnat)1 << 31)) { + caml_serialize_int_1(1); +- caml_serialize_int_4((int32) l); ++ caml_serialize_int_4((int32_t) l); + } else { + caml_serialize_int_1(2); + caml_serialize_int_8(l); +diff --git a/byterun/io.c b/byterun/io.c +index 5f04a96..bedc0f0 100644 +--- a/byterun/io.c ++++ b/byterun/io.c +@@ -207,7 +207,7 @@ CAMLexport void caml_flush(struct channel *channel) + + /* Output data */ + +-CAMLexport void caml_putword(struct channel *channel, uint32 w) ++CAMLexport void caml_putword(struct channel *channel, uint32_t w) + { + if (! caml_channel_binary_mode(channel)) + caml_failwith("output_binary_int: not a binary channel"); +@@ -303,10 +303,10 @@ CAMLexport unsigned char caml_refill(struct channel *channel) + return (unsigned char)(channel->buff[0]); + } + +-CAMLexport uint32 caml_getword(struct channel *channel) ++CAMLexport uint32_t caml_getword(struct channel *channel) + { + int i; +- uint32 res; ++ uint32_t res; + + if (! caml_channel_binary_mode(channel)) + caml_failwith("input_binary_int: not a binary channel"); +diff --git a/byterun/io.h b/byterun/io.h +index 64a8bf5..5a9c037 100644 +--- a/byterun/io.h ++++ b/byterun/io.h +@@ -78,12 +78,12 @@ CAMLextern value caml_alloc_channel(struct channel *chan); + + CAMLextern int caml_flush_partial (struct channel *); + CAMLextern void caml_flush (struct channel *); +-CAMLextern void caml_putword (struct channel *, uint32); ++CAMLextern void caml_putword (struct channel *, uint32_t); + CAMLextern int caml_putblock (struct channel *, char *, intnat); + CAMLextern void caml_really_putblock (struct channel *, char *, intnat); + + CAMLextern unsigned char caml_refill (struct channel *); +-CAMLextern uint32 caml_getword (struct channel *); ++CAMLextern uint32_t caml_getword (struct channel *); + CAMLextern int caml_getblock (struct channel *, char *, intnat); + CAMLextern int caml_really_getblock (struct channel *, char *, intnat); + +@@ -107,7 +107,7 @@ CAMLextern struct channel * caml_all_opened_channels; + #define Unlock_exn() \ + if (caml_channel_mutex_unlock_exn != NULL) (*caml_channel_mutex_unlock_exn)() + +-/* Conversion between file_offset and int64 */ ++/* Conversion between file_offset and int64_t */ + + #define Val_file_offset(fofs) caml_copy_int64(fofs) + #define File_offset_val(v) ((file_offset) Int64_val(v)) +diff --git a/byterun/md5.c b/byterun/md5.c +index 10ac76a..2dc90a2 100644 +--- a/byterun/md5.c ++++ b/byterun/md5.c +@@ -97,11 +97,11 @@ CAMLexport void caml_md5_block(unsigned char digest[16], + #else + static void byteReverse(unsigned char * buf, unsigned longs) + { +- uint32 t; ++ uint32_t t; + do { +- t = (uint32) ((unsigned) buf[3] << 8 | buf[2]) << 16 | ++ t = (uint32_t) ((unsigned) buf[3] << 8 | buf[2]) << 16 | + ((unsigned) buf[1] << 8 | buf[0]); +- *(uint32 *) buf = t; ++ *(uint32_t *) buf = t; + buf += 4; + } while (--longs); + } +@@ -129,12 +129,12 @@ CAMLexport void caml_MD5Init(struct MD5Context *ctx) + CAMLexport void caml_MD5Update(struct MD5Context *ctx, unsigned char *buf, + uintnat len) + { +- uint32 t; ++ uint32_t t; + + /* Update bitcount */ + + t = ctx->bits[0]; +- if ((ctx->bits[0] = t + ((uint32) len << 3)) < t) ++ if ((ctx->bits[0] = t + ((uint32_t) len << 3)) < t) + ctx->bits[1]++; /* Carry from low to high */ + ctx->bits[1] += len >> 29; + +@@ -152,7 +152,7 @@ CAMLexport void caml_MD5Update(struct MD5Context *ctx, unsigned char *buf, + } + memcpy(p, buf, t); + byteReverse(ctx->in, 16); +- caml_MD5Transform(ctx->buf, (uint32 *) ctx->in); ++ caml_MD5Transform(ctx->buf, (uint32_t *) ctx->in); + buf += t; + len -= t; + } +@@ -161,7 +161,7 @@ CAMLexport void caml_MD5Update(struct MD5Context *ctx, unsigned char *buf, + while (len >= 64) { + memcpy(ctx->in, buf, 64); + byteReverse(ctx->in, 16); +- caml_MD5Transform(ctx->buf, (uint32 *) ctx->in); ++ caml_MD5Transform(ctx->buf, (uint32_t *) ctx->in); + buf += 64; + len -= 64; + } +@@ -196,7 +196,7 @@ CAMLexport void caml_MD5Final(unsigned char *digest, struct MD5Context *ctx) + /* Two lots of padding: Pad the first block to 64 bytes */ + memset(p, 0, count); + byteReverse(ctx->in, 16); +- caml_MD5Transform(ctx->buf, (uint32 *) ctx->in); ++ caml_MD5Transform(ctx->buf, (uint32_t *) ctx->in); + + /* Now fill the next block with 56 bytes */ + memset(ctx->in, 0, 56); +@@ -207,10 +207,10 @@ CAMLexport void caml_MD5Final(unsigned char *digest, struct MD5Context *ctx) + byteReverse(ctx->in, 14); + + /* Append length in bits and transform */ +- ((uint32 *) ctx->in)[14] = ctx->bits[0]; +- ((uint32 *) ctx->in)[15] = ctx->bits[1]; ++ ((uint32_t *) ctx->in)[14] = ctx->bits[0]; ++ ((uint32_t *) ctx->in)[15] = ctx->bits[1]; + +- caml_MD5Transform(ctx->buf, (uint32 *) ctx->in); ++ caml_MD5Transform(ctx->buf, (uint32_t *) ctx->in); + byteReverse((unsigned char *) ctx->buf, 4); + memcpy(digest, ctx->buf, 16); + memset(ctx, 0, sizeof(*ctx)); /* In case it's sensitive */ +@@ -233,9 +233,9 @@ CAMLexport void caml_MD5Final(unsigned char *digest, struct MD5Context *ctx) + * reflect the addition of 16 longwords of new data. caml_MD5Update blocks + * the data and converts bytes into longwords for this routine. + */ +-CAMLexport void caml_MD5Transform(uint32 *buf, uint32 *in) ++CAMLexport void caml_MD5Transform(uint32_t *buf, uint32_t *in) + { +- register uint32 a, b, c, d; ++ register uint32_t a, b, c, d; + + a = buf[0]; + b = buf[1]; +diff --git a/byterun/md5.h b/byterun/md5.h +index d8aff09..f63667d 100644 +--- a/byterun/md5.h ++++ b/byterun/md5.h +@@ -26,8 +26,8 @@ CAMLextern void caml_md5_block(unsigned char digest[16], + void * data, uintnat len); + + struct MD5Context { +- uint32 buf[4]; +- uint32 bits[2]; ++ uint32_t buf[4]; ++ uint32_t bits[2]; + unsigned char in[64]; + }; + +@@ -35,7 +35,7 @@ CAMLextern void caml_MD5Init (struct MD5Context *context); + CAMLextern void caml_MD5Update (struct MD5Context *context, unsigned char *buf, + uintnat len); + CAMLextern void caml_MD5Final (unsigned char *digest, struct MD5Context *ctx); +-CAMLextern void caml_MD5Transform (uint32 *buf, uint32 *in); ++CAMLextern void caml_MD5Transform (uint32_t *buf, uint32_t *in); + + + #endif /* CAML_MD5_H */ +diff --git a/byterun/mlvalues.h b/byterun/mlvalues.h +index 268bcfe..a08948e 100644 +--- a/byterun/mlvalues.h ++++ b/byterun/mlvalues.h +@@ -38,8 +38,8 @@ extern "C" { + bp: Pointer to the first byte of a block. (a char *) + op: Pointer to the first field of a block. (a value *) + hp: Pointer to the header of a block. (a char *) +- int32: Four bytes on all architectures. +- int64: Eight bytes on all architectures. ++ int32_t: Four bytes on all architectures. ++ int64_t: Eight bytes on all architectures. + + Remark: A block size is always a multiple of the word size, and at least + one word plus the header. +@@ -161,7 +161,7 @@ bits 63 10 9 8 7 0 + /* Fields are numbered from 0. */ + #define Field(x, i) (((value *)(x)) [i]) /* Also an l-value. */ + +-typedef int32 opcode_t; ++typedef int32_t opcode_t; + typedef opcode_t * code_t; + + /* NOTE: [Forward_tag] and [Infix_tag] must be just under +@@ -262,12 +262,12 @@ struct custom_operations; /* defined in [custom.h] */ + + /* Int32.t, Int64.t and Nativeint.t are represented as custom blocks. */ + +-#define Int32_val(v) (*((int32 *) Data_custom_val(v))) ++#define Int32_val(v) (*((int32_t *) Data_custom_val(v))) + #define Nativeint_val(v) (*((intnat *) Data_custom_val(v))) + #ifndef ARCH_ALIGN_INT64 +-#define Int64_val(v) (*((int64 *) Data_custom_val(v))) ++#define Int64_val(v) (*((int64_t *) Data_custom_val(v))) + #else +-CAMLextern int64 caml_Int64_val(value v); ++CAMLextern int64_t caml_Int64_val(value v); + #define Int64_val(v) caml_Int64_val(v) + #endif + +diff --git a/byterun/startup.c b/byterun/startup.c +index 3697220..ab926ef 100644 +--- a/byterun/startup.c ++++ b/byterun/startup.c +@@ -79,7 +79,7 @@ static void init_atoms(void) + + /* Read the trailer of a bytecode file */ + +-static void fixup_endianness_trailer(uint32 * p) ++static void fixup_endianness_trailer(uint32_t * p) + { + #ifndef ARCH_BIG_ENDIAN + Reverse_32(p, p); +@@ -153,7 +153,7 @@ void caml_read_section_descriptors(int fd, struct exec_trailer *trail) + Return the length of the section data in bytes, or -1 if no section + found with that name. */ + +-int32 caml_seek_optional_section(int fd, struct exec_trailer *trail, char *name) ++int32_t caml_seek_optional_section(int fd, struct exec_trailer *trail, char *name) + { + long ofs; + int i; +@@ -172,9 +172,9 @@ int32 caml_seek_optional_section(int fd, struct exec_trailer *trail, char *name) + /* Position fd at the beginning of the section having the given name. + Return the length of the section data in bytes. */ + +-int32 caml_seek_section(int fd, struct exec_trailer *trail, char *name) ++int32_t caml_seek_section(int fd, struct exec_trailer *trail, char *name) + { +- int32 len = caml_seek_optional_section(fd, trail, name); ++ int32_t len = caml_seek_optional_section(fd, trail, name); + if (len == -1) + caml_fatal_error_arg("Fatal_error: section `%s' is missing\n", name); + return len; +@@ -185,7 +185,7 @@ int32 caml_seek_section(int fd, struct exec_trailer *trail, char *name) + + static char * read_section(int fd, struct exec_trailer *trail, char *name) + { +- int32 len; ++ int32_t len; + char * data; + + len = caml_seek_optional_section(fd, trail, name); +diff --git a/byterun/startup.h b/byterun/startup.h +index 3dda64b..3268d88 100644 +--- a/byterun/startup.h ++++ b/byterun/startup.h +@@ -30,9 +30,9 @@ enum { FILE_NOT_FOUND = -1, BAD_BYTECODE = -2 }; + extern int caml_attempt_open(char **name, struct exec_trailer *trail, + int do_open_script); + extern void caml_read_section_descriptors(int fd, struct exec_trailer *trail); +-extern int32 caml_seek_optional_section(int fd, struct exec_trailer *trail, ++extern int32_t caml_seek_optional_section(int fd, struct exec_trailer *trail, + char *name); +-extern int32 caml_seek_section(int fd, struct exec_trailer *trail, char *name); ++extern int32_t caml_seek_section(int fd, struct exec_trailer *trail, char *name); + + + #endif /* CAML_STARTUP_H */ +diff --git a/byterun/str.c b/byterun/str.c +index 6effa91..9c7baa1 100644 +--- a/byterun/str.c ++++ b/byterun/str.c +@@ -101,7 +101,7 @@ CAMLprim value caml_string_get32(value str, value index) + + CAMLprim value caml_string_get64(value str, value index) + { +- uint64 res; ++ uint64_t res; + unsigned char b1, b2, b3, b4, b5, b6, b7, b8; + intnat idx = Long_val(index); + if (idx < 0 || idx + 7 >= caml_string_length(str)) caml_array_bound_error(); +@@ -114,15 +114,15 @@ CAMLprim value caml_string_get64(value str, value index) + b7 = Byte_u(str, idx + 6); + b8 = Byte_u(str, idx + 7); + #ifdef ARCH_BIG_ENDIAN +- res = (uint64) b1 << 56 | (uint64) b2 << 48 +- | (uint64) b3 << 40 | (uint64) b4 << 32 +- | (uint64) b5 << 24 | (uint64) b6 << 16 +- | (uint64) b7 << 8 | (uint64) b8; ++ res = (uint64_t) b1 << 56 | (uint64_t) b2 << 48 ++ | (uint64_t) b3 << 40 | (uint64_t) b4 << 32 ++ | (uint64_t) b5 << 24 | (uint64_t) b6 << 16 ++ | (uint64_t) b7 << 8 | (uint64_t) b8; + #else +- res = (uint64) b8 << 56 | (uint64) b7 << 48 +- | (uint64) b6 << 40 | (uint64) b5 << 32 +- | (uint64) b4 << 24 | (uint64) b3 << 16 +- | (uint64) b2 << 8 | (uint64) b1; ++ res = (uint64_t) b8 << 56 | (uint64_t) b7 << 48 ++ | (uint64_t) b6 << 40 | (uint64_t) b5 << 32 ++ | (uint64_t) b4 << 24 | (uint64_t) b3 << 16 ++ | (uint64_t) b2 << 8 | (uint64_t) b1; + #endif + return caml_copy_int64(res); + } +@@ -174,7 +174,7 @@ CAMLprim value caml_string_set32(value str, value index, value newval) + CAMLprim value caml_string_set64(value str, value index, value newval) + { + unsigned char b1, b2, b3, b4, b5, b6, b7, b8; +- int64 val; ++ int64_t val; + intnat idx = Long_val(index); + if (idx < 0 || idx + 7 >= caml_string_length(str)) caml_array_bound_error(); + val = Int64_val(newval); +diff --git a/config/auto-aux/int64align.c b/config/auto-aux/int64align.c +index 5795e48..c143986 100644 +--- a/config/auto-aux/int64align.c ++++ b/config/auto-aux/int64align.c +@@ -17,18 +17,18 @@ + #include "m.h" + + #if defined(ARCH_INT64_TYPE) +-typedef ARCH_INT64_TYPE int64; ++typedef ARCH_INT64_TYPE int64_t; + #elif SIZEOF_LONG == 8 +-typedef long int64; ++typedef long int64_t; + #elif SIZEOF_LONGLONG == 8 +-typedef long long int64; ++typedef long long int64_t; + #else + #error "No 64-bit integer type available" + #endif + +-int64 foo; ++int64_t foo; + +-void access_int64(int64 *p) ++void access_int64(int64_t *p) + { + foo = *p; + } +@@ -49,8 +49,8 @@ int main(void) + signal(SIGBUS, sig_handler); + #endif + if(setjmp(failure) == 0) { +- access_int64((int64 *) n); +- access_int64((int64 *) (n+1)); ++ access_int64((int64_t *) n); ++ access_int64((int64_t *) (n+1)); + res = 0; + } else { + res = 1; +diff --git a/config/s-nt.h b/config/s-nt.h +index 6df440b..603b050 100644 +--- a/config/s-nt.h ++++ b/config/s-nt.h +@@ -15,6 +15,9 @@ + + #define OCAML_OS_TYPE "Win32" + ++#ifdef __MINGW32__ ++#define HAS_STDINT_H ++#endif + #undef BSD_SIGNALS + #define HAS_STRERROR + #define HAS_SOCKETS +diff --git a/configure b/configure +index 0bf4ebd..8a9be78 100755 +--- a/configure ++++ b/configure +@@ -615,26 +615,6 @@ case "$target" in + esac + esac + +-# Check semantics of division and modulus +- +-sh ./runtest divmod.c +-case $? in +- 0) inf "Native division and modulus have round-towards-zero semantics," \ +- "will use them." +- echo "#undef NONSTANDARD_DIV_MOD" >> m.h;; +- 1) inf "Native division and modulus do not have round-towards-zero" +- "semantics, will use software emulation." +- echo "#define NONSTANDARD_DIV_MOD" >> m.h;; +- *) case $target in +- *-*-mingw*) inf "Native division and modulus have round-towards-zero" \ +- "semantics, will use them." +- echo "#undef NONSTANDARD_DIV_MOD" >> m.h;; +- *) wrn "Something went wrong while checking native division and modulus"\ +- "please report it at http://http://caml.inria.fr/mantis/" +- echo "#define NONSTANDARD_DIV_MOD" >> m.h;; +- esac;; +-esac +- + # Shared library support + + shared_libraries_supported=false +@@ -1085,6 +1065,11 @@ if sh ./hasgot -i sys/types.h -i sys/socket.h -i netinet/in.h \ + echo "#define HAS_IPV6" >> s.h + fi + ++if sh ./hasgot -i stdint.h; then ++ inf "stdint.h found." ++ echo "#define HAS_STDINT_H" >> s.h ++fi ++ + if sh ./hasgot -i unistd.h; then + inf "unistd.h found." + echo "#define HAS_UNISTD" >> s.h +diff --git a/otherlibs/bigarray/bigarray_stubs.c b/otherlibs/bigarray/bigarray_stubs.c +index 7e63cbf..f2ccb92 100644 +--- a/otherlibs/bigarray/bigarray_stubs.c ++++ b/otherlibs/bigarray/bigarray_stubs.c +@@ -279,9 +279,9 @@ value caml_ba_get_N(value vb, value * vind, int nind) + case CAML_BA_UINT16: + return Val_int(((uint16 *) b->data)[offset]); + case CAML_BA_INT32: +- return caml_copy_int32(((int32 *) b->data)[offset]); ++ return caml_copy_int32(((int32_t *) b->data)[offset]); + case CAML_BA_INT64: +- return caml_copy_int64(((int64 *) b->data)[offset]); ++ return caml_copy_int64(((int64_t *) b->data)[offset]); + case CAML_BA_NATIVE_INT: + return caml_copy_nativeint(((intnat *) b->data)[offset]); + case CAML_BA_CAML_INT: +@@ -388,7 +388,7 @@ CAMLprim value caml_ba_uint8_get32(value vb, value vind) + + CAMLprim value caml_ba_uint8_get64(value vb, value vind) + { +- uint64 res; ++ uint64_t res; + unsigned char b1, b2, b3, b4, b5, b6, b7, b8; + intnat idx = Long_val(vind); + struct caml_ba_array * b = Caml_ba_array_val(vb); +@@ -402,15 +402,15 @@ CAMLprim value caml_ba_uint8_get64(value vb, value vind) + b7 = ((unsigned char*) b->data)[idx+6]; + b8 = ((unsigned char*) b->data)[idx+7]; + #ifdef ARCH_BIG_ENDIAN +- res = (uint64) b1 << 56 | (uint64) b2 << 48 +- | (uint64) b3 << 40 | (uint64) b4 << 32 +- | (uint64) b5 << 24 | (uint64) b6 << 16 +- | (uint64) b7 << 8 | (uint64) b8; ++ res = (uint64_t) b1 << 56 | (uint64_t) b2 << 48 ++ | (uint64_t) b3 << 40 | (uint64_t) b4 << 32 ++ | (uint64_t) b5 << 24 | (uint64_t) b6 << 16 ++ | (uint64_t) b7 << 8 | (uint64_t) b8; + #else +- res = (uint64) b8 << 56 | (uint64) b7 << 48 +- | (uint64) b6 << 40 | (uint64) b5 << 32 +- | (uint64) b4 << 24 | (uint64) b3 << 16 +- | (uint64) b2 << 8 | (uint64) b1; ++ res = (uint64_t) b8 << 56 | (uint64_t) b7 << 48 ++ | (uint64_t) b6 << 40 | (uint64_t) b5 << 32 ++ | (uint64_t) b4 << 24 | (uint64_t) b3 << 16 ++ | (uint64_t) b2 << 8 | (uint64_t) b1; + #endif + return caml_copy_int64(res); + } +@@ -447,9 +447,9 @@ static value caml_ba_set_aux(value vb, value * vind, intnat nind, value newval) + case CAML_BA_UINT16: + ((int16 *) b->data)[offset] = Int_val(newval); break; + case CAML_BA_INT32: +- ((int32 *) b->data)[offset] = Int32_val(newval); break; ++ ((int32_t *) b->data)[offset] = Int32_val(newval); break; + case CAML_BA_INT64: +- ((int64 *) b->data)[offset] = Int64_val(newval); break; ++ ((int64_t *) b->data)[offset] = Int64_val(newval); break; + case CAML_BA_NATIVE_INT: + ((intnat *) b->data)[offset] = Nativeint_val(newval); break; + case CAML_BA_CAML_INT: +@@ -577,7 +577,7 @@ CAMLprim value caml_ba_uint8_set64(value vb, value vind, value newval) + { + unsigned char b1, b2, b3, b4, b5, b6, b7, b8; + intnat idx = Long_val(vind); +- int64 val; ++ int64_t val; + struct caml_ba_array * b = Caml_ba_array_val(vb); + if (idx < 0 || idx >= b->dim[0] - 7) caml_array_bound_error(); + val = Int64_val(newval); +@@ -760,9 +760,9 @@ static int caml_ba_compare(value v1, value v2) + case CAML_BA_UINT16: + DO_INTEGER_COMPARISON(uint16); + case CAML_BA_INT32: +- DO_INTEGER_COMPARISON(int32); ++ DO_INTEGER_COMPARISON(int32_t); + case CAML_BA_INT64: +- DO_INTEGER_COMPARISON(int64); ++ DO_INTEGER_COMPARISON(int64_t); + case CAML_BA_CAML_INT: + case CAML_BA_NATIVE_INT: + DO_INTEGER_COMPARISON(intnat); +@@ -780,7 +780,7 @@ static intnat caml_ba_hash(value v) + { + struct caml_ba_array * b = Caml_ba_array_val(v); + intnat num_elts, n; +- uint32 h, w; ++ uint32_t h, w; + int i; + + num_elts = 1; +@@ -820,7 +820,7 @@ static intnat caml_ba_hash(value v) + } + case CAML_BA_INT32: + { +- uint32 * p = b->data; ++ uint32_t * p = b->data; + if (num_elts > 64) num_elts = 64; + for (n = 0; n < num_elts; n++, p++) h = caml_hash_mix_uint32(h, *p); + break; +@@ -835,7 +835,7 @@ static intnat caml_ba_hash(value v) + } + case CAML_BA_INT64: + { +- int64 * p = b->data; ++ int64_t * p = b->data; + if (num_elts > 32) num_elts = 32; + for (n = 0; n < num_elts; n++, p++) h = caml_hash_mix_int64(h, *p); + break; +@@ -878,7 +878,7 @@ static void caml_ba_serialize_longarray(void * data, + } else { + caml_serialize_int_1(0); + for (n = 0, p = data; n < num_elts; n++, p++) +- caml_serialize_int_4((int32) *p); ++ caml_serialize_int_4((int32_t) *p); + } + #else + caml_serialize_int_1(0); +@@ -1181,14 +1181,14 @@ CAMLprim value caml_ba_fill(value vb, value vinit) + break; + } + case CAML_BA_INT32: { +- int32 init = Int32_val(vinit); +- int32 * p; ++ int32_t init = Int32_val(vinit); ++ int32_t * p; + for (p = b->data; num_elts > 0; p++, num_elts--) *p = init; + break; + } + case CAML_BA_INT64: { +- int64 init = Int64_val(vinit); +- int64 * p; ++ int64_t init = Int64_val(vinit); ++ int64_t * p; + for (p = b->data; num_elts > 0; p++, num_elts--) *p = init; + break; + } +diff --git a/otherlibs/num/nat_stubs.c b/otherlibs/num/nat_stubs.c +index 9a62759..d718a05 100644 +--- a/otherlibs/num/nat_stubs.c ++++ b/otherlibs/num/nat_stubs.c +@@ -347,9 +347,9 @@ static void serialize_nat(value nat, + if (len >= ((mlsize_t)1 << 32)) + failwith("output_value: nat too big"); + #endif +- serialize_int_4((int32) len); ++ serialize_int_4((int32_t) len); + #if defined(ARCH_SIXTYFOUR) && defined(ARCH_BIG_ENDIAN) +- { int32 * p; ++ { int32_t * p; + mlsize_t i; + for (i = len, p = Data_custom_val(nat); i > 0; i -= 2, p += 2) { + serialize_int_4(p[1]); /* low 32 bits of 64-bit digit */ +@@ -369,7 +369,7 @@ static uintnat deserialize_nat(void * dst) + + len = deserialize_uint_4(); + #if defined(ARCH_SIXTYFOUR) && defined(ARCH_BIG_ENDIAN) +- { uint32 * p; ++ { uint32_t * p; + mlsize_t i; + for (i = len, p = dst; i > 1; i -= 2, p += 2) { + p[1] = deserialize_uint_4(); /* low 32 bits of 64-bit digit */ +@@ -385,7 +385,7 @@ static uintnat deserialize_nat(void * dst) + deserialize_block_4(dst, len); + #if defined(ARCH_SIXTYFOUR) + if (len & 1){ +- ((uint32 *) dst)[len] = 0; ++ ((uint32_t *) dst)[len] = 0; + ++ len; + } + #endif +@@ -396,7 +396,7 @@ static uintnat deserialize_nat(void * dst) + static intnat hash_nat(value v) + { + bngsize len, i; +- uint32 h; ++ uint32_t h; + + len = bng_num_digits(&Digit_val(v,0), Wosize_val(v) - 1); + h = 0; +@@ -406,10 +406,10 @@ static intnat hash_nat(value v) + /* Mix the two 32-bit halves as if we were on a 32-bit platform, + namely low 32 bits first, then high 32 bits. + Also, ignore final 32 bits if they are zero. */ +- h = caml_hash_mix_uint32(h, (uint32) d); ++ h = caml_hash_mix_uint32(h, (uint32_t) d); + d = d >> 32; + if (d == 0 && i + 1 == len) break; +- h = caml_hash_mix_uint32(h, (uint32) d); ++ h = caml_hash_mix_uint32(h, (uint32_t) d); + #else + h = caml_hash_mix_uint32(h, d); + #endif +diff --git a/otherlibs/unix/addrofstr.c b/otherlibs/unix/addrofstr.c +index e17841f..a2830ba 100644 +--- a/otherlibs/unix/addrofstr.c ++++ b/otherlibs/unix/addrofstr.c +@@ -73,7 +73,7 @@ CAMLprim value unix_inet_addr_of_string(value s) + #else + struct in_addr address; + address.s_addr = inet_addr(String_val(s)); +- if (address.s_addr == (uint32) -1) failwith("inet_addr_of_string"); ++ if (address.s_addr == (uint32_t) -1) failwith("inet_addr_of_string"); + return alloc_inet_addr(&address); + #endif + } +diff --git a/stdlib/header.c b/stdlib/header.c +index cb3d995..93cdfeb 100644 +--- a/stdlib/header.c ++++ b/stdlib/header.c +@@ -133,7 +133,7 @@ static char * read_runtime_path(int fd) + char buffer[TRAILER_SIZE]; + static char runtime_path[MAXPATHLEN]; + int num_sections, i; +- uint32 path_size; ++ uint32_t path_size; + long ofs; + + lseek(fd, (long) -TRAILER_SIZE, SEEK_END); +-- +2.0.4 + diff --git a/ocaml.spec b/ocaml.spec index 2bab807..fdea837 100644 --- a/ocaml.spec +++ b/ocaml.spec @@ -15,12 +15,9 @@ %global natdynlink 0 %endif -%global gitcommit c48fc015a97826df3b39aefee8e96b1d20990ef5 -%global shortcommit c48fc015 - Name: ocaml Version: 4.02.0 -Release: 0.11.git%{shortcommit}%{?dist} +Release: 1%{?dist} Summary: OCaml compiler and programming environment @@ -28,10 +25,10 @@ License: QPL and (LGPLv2+ with exceptions) URL: http://www.ocaml.org -Source0: https://github.com/ocaml/%{name}/archive/%{gitcommit}/%{name}-%{gitcommit}.tar.gz -Source1: http://caml.inria.fr/pub/distrib/ocaml-4.02/ocaml-4.02beta-refman-html.tar.gz -Source2: http://caml.inria.fr/pub/distrib/ocaml-4.02/ocaml-4.02beta-refman.pdf -Source3: http://caml.inria.fr/pub/distrib/ocaml-4.02/ocaml-4.02beta-refman.info.tar.gz +Source0: http://caml.inria.fr/pub/distrib/ocaml-4.02/%{name}-%{version}.tar.gz +Source1: http://caml.inria.fr/pub/distrib/ocaml-4.02/ocaml-4.02-refman-html.tar.gz +Source2: http://caml.inria.fr/pub/distrib/ocaml-4.02/ocaml-4.02-refman.pdf +Source3: http://caml.inria.fr/pub/distrib/ocaml-4.02/ocaml-4.02-refman.info.tar.gz # IMPORTANT NOTE: # @@ -58,6 +55,7 @@ Patch0007: 0007-Add-support-for-ppc64le.patch Patch0008: 0008-arm-arm64-Mark-stack-as-non-executable.patch Patch0009: 0009-arg-Add-no_arg-and-get_arg-helper-functions.patch Patch0010: 0010-arg-Allow-flags-such-as-flag-arg-as-well-as-flag-arg.patch +Patch0011: 0011-PR-6517-use-ISO-C99-types-u-int-32-64-_t-in-preferen.patch # Add BFD support so that ocamlobjinfo supports *.cmxs format (RHBZ#1113735). BuildRequires: binutils-devel @@ -190,9 +188,9 @@ may not be portable between versions. %prep -%setup -q -T -b 0 -n %{name}-%{gitcommit} -%setup -q -T -D -a 1 -n %{name}-%{gitcommit} -%setup -q -T -D -a 3 -n %{name}-%{gitcommit} +%setup -q -T -b 0 -n %{name}-%{version} +%setup -q -T -D -a 1 -n %{name}-%{version} +%setup -q -T -D -a 3 -n %{name}-%{version} cp %{SOURCE2} refman.pdf git init @@ -420,6 +418,11 @@ fi %changelog +* Sat Aug 30 2014 Richard W.M. Jones - 4.02.0-1 +- New upstream OCaml 4.02.0 final. +- Add patch for ocaml-camlimages + (see http://caml.inria.fr/mantis/view.php?id=6517) + * Fri Aug 22 2014 Richard W.M. Jones - 4.02.0-0.11.gitc48fc015 - Rebase on top of OCaml 4.02+rc1 (same as git commit c48fc015). diff --git a/sources b/sources index 963f467..381efef 100644 --- a/sources +++ b/sources @@ -1,4 +1,4 @@ -c308e831a1c5d6b3024bb339fcee72f4 ocaml-4.02beta-refman-html.tar.gz -672044269cea28b661fca5c0edadc195 ocaml-4.02beta-refman.info.tar.gz -d05fc06025d7bad2a969a659f6de1c83 ocaml-4.02beta-refman.pdf -efb11f942c57b77ff587defc4a9fcdb4 ocaml-c48fc015a97826df3b39aefee8e96b1d20990ef5.tar.gz +8bba7e7d872083af1723dd450e07a5f4 ocaml-4.02.0.tar.gz +20b691d71d36df69f9cb16ab4521ed49 ocaml-4.02-refman-html.tar.gz +265b7db123e925e8b7b70ca2266b4206 ocaml-4.02-refman.info.tar.gz +1d683029a6ef48e34cc24eb1982cdd05 ocaml-4.02-refman.pdf