1 files changed, 74 insertions, 74 deletions

diff --git a/byterun/floats.c b/byterun/floats.c
index a81f83e1d..00270e4cb 100644
--- a/byterun/floats.c
+++ b/byterun/floats.c
@@ -30,7 +30,7 @@
 
 #ifdef ARCH_ALIGN_DOUBLE
 
-CAMLexport double Double_val(value val)
+CAMLexport double caml_Double_val(value val)
 {
   union { value v[2]; double d; } buffer;
 
@@ -40,7 +40,7 @@ CAMLexport double Double_val(value val)
   return buffer.d;
 }
 
-CAMLexport void Store_double_val(value val, double dbl)
+CAMLexport void caml_Store_double_val(value val, double dbl)
 {
   union { value v[2]; double d; } buffer;
 
@@ -52,7 +52,7 @@ CAMLexport void Store_double_val(value val, double dbl)
 
 #endif
 
-CAMLexport value copy_double(double d)
+CAMLexport value caml_copy_double(double d)
 {
   value res;
 
@@ -65,7 +65,7 @@ CAMLexport value copy_double(double d)
   return res;
 }
 
-CAMLprim value format_float(value fmt, value arg)
+CAMLprim value caml_format_float(value fmt, value arg)
 {
 #define MAX_DIGITS 350
 /* Max number of decimal digits in a "natural" (not artificially padded)
@@ -106,7 +106,7 @@ CAMLprim value format_float(value fmt, value arg)
   return res;
 }
 
-CAMLprim value float_of_string(value vs)
+CAMLprim value caml_float_of_string(value vs)
 {
   char parse_buffer[64];
   char * buf, * src, * dst, * end;
@@ -126,93 +126,93 @@ CAMLprim value float_of_string(value vs)
   d = strtod((const char *) buf, &end);
   if (buf != parse_buffer) caml_stat_free(buf);
   if (end != dst) caml_failwith("float_of_string");
-  return copy_double(d);
+  return caml_copy_double(d);
 }
 
-CAMLprim value int_of_float(value f)
+CAMLprim value caml_int_of_float(value f)
 {
   return Val_long((long) Double_val(f));
 }
 
-CAMLprim value float_of_int(value n)
+CAMLprim value caml_float_of_int(value n)
 {
-  return copy_double((double) Long_val(n));
+  return caml_copy_double((double) Long_val(n));
 }
 
-CAMLprim value neg_float(value f)
+CAMLprim value caml_neg_float(value f)
 {
-  return copy_double(- Double_val(f));
+  return caml_copy_double(- Double_val(f));
 }
 
-CAMLprim value abs_float(value f)
+CAMLprim value caml_abs_float(value f)
 {
-  return copy_double(fabs(Double_val(f)));
+  return caml_copy_double(fabs(Double_val(f)));
 }
 
-CAMLprim value add_float(value f, value g)
+CAMLprim value caml_add_float(value f, value g)
 {
-  return copy_double(Double_val(f) + Double_val(g));
+  return caml_copy_double(Double_val(f) + Double_val(g));
 }
 
-CAMLprim value sub_float(value f, value g)
+CAMLprim value caml_sub_float(value f, value g)
 {
-  return copy_double(Double_val(f) - Double_val(g));
+  return caml_copy_double(Double_val(f) - Double_val(g));
 }
 
-CAMLprim value mul_float(value f, value g)
+CAMLprim value caml_mul_float(value f, value g)
 {
-  return copy_double(Double_val(f) * Double_val(g));
+  return caml_copy_double(Double_val(f) * Double_val(g));
 }
 
-CAMLprim value div_float(value f, value g)
+CAMLprim value caml_div_float(value f, value g)
 {
-  return copy_double(Double_val(f) / Double_val(g));
+  return caml_copy_double(Double_val(f) / Double_val(g));
 }
 
-CAMLprim value exp_float(value f)
+CAMLprim value caml_exp_float(value f)
 {
-  return copy_double(exp(Double_val(f)));
+  return caml_copy_double(exp(Double_val(f)));
 }
 
-CAMLprim value floor_float(value f)
+CAMLprim value caml_floor_float(value f)
 {
-  return copy_double(floor(Double_val(f)));
+  return caml_copy_double(floor(Double_val(f)));
 }
 
-CAMLprim value fmod_float(value f1, value f2)
+CAMLprim value caml_fmod_float(value f1, value f2)
 {
-  return copy_double(fmod(Double_val(f1), Double_val(f2)));
+  return caml_copy_double(fmod(Double_val(f1), Double_val(f2)));
 }
 
-CAMLprim value frexp_float(value f)
+CAMLprim value caml_frexp_float(value f)
 {
   CAMLparam1 (f);
   CAMLlocal2 (res, mantissa);
   int exponent;
 
-  mantissa = copy_double(frexp (Double_val(f), &exponent));
+  mantissa = caml_copy_double(frexp (Double_val(f), &exponent));
   res = caml_alloc_tuple(2);
   Field(res, 0) = mantissa;
   Field(res, 1) = Val_int(exponent);
   CAMLreturn (res);
 }
 
-CAMLprim value ldexp_float(value f, value i)
+CAMLprim value caml_ldexp_float(value f, value i)
 {
-  return copy_double(ldexp(Double_val(f), Int_val(i)));
+  return caml_copy_double(ldexp(Double_val(f), Int_val(i)));
 }
 
-CAMLprim value log_float(value f)
+CAMLprim value caml_log_float(value f)
 {
-  return copy_double(log(Double_val(f)));
+  return caml_copy_double(log(Double_val(f)));
 }
 
-CAMLprim value log10_float(value f)
+CAMLprim value caml_log10_float(value f)
 {
-  return copy_double(log10(Double_val(f)));
+  return caml_copy_double(log10(Double_val(f)));
 }
 
-CAMLprim value modf_float(value f)
+CAMLprim value caml_modf_float(value f)
 {
 #if __SC__
   _float_eval frem;       /* Problem with Apple's <math.h> */
@@ -222,110 +222,110 @@ CAMLprim value modf_float(value f)
   CAMLparam1 (f);
   CAMLlocal3 (res, quo, rem);
 
-  quo = copy_double(modf (Double_val(f), &frem));
-  rem = copy_double(frem);
+  quo = caml_copy_double(modf (Double_val(f), &frem));
+  rem = caml_copy_double(frem);
   res = caml_alloc_tuple(2);
   Field(res, 0) = quo;
   Field(res, 1) = rem;
   CAMLreturn (res);
 }
 
-CAMLprim value sqrt_float(value f)
+CAMLprim value caml_sqrt_float(value f)
 {
-  return copy_double(sqrt(Double_val(f)));
+  return caml_copy_double(sqrt(Double_val(f)));
 }
 
-CAMLprim value power_float(value f, value g)
+CAMLprim value caml_power_float(value f, value g)
 {
-  return copy_double(pow(Double_val(f), Double_val(g)));
+  return caml_copy_double(pow(Double_val(f), Double_val(g)));
 }
 
-CAMLprim value sin_float(value f)
+CAMLprim value caml_sin_float(value f)
 {
-  return copy_double(sin(Double_val(f)));
+  return caml_copy_double(sin(Double_val(f)));
 }
 
-CAMLprim value sinh_float(value f)
+CAMLprim value caml_sinh_float(value f)
 {
-  return copy_double(sinh(Double_val(f)));
+  return caml_copy_double(sinh(Double_val(f)));
 }
 
-CAMLprim value cos_float(value f)
+CAMLprim value caml_cos_float(value f)
 {
-  return copy_double(cos(Double_val(f)));
+  return caml_copy_double(cos(Double_val(f)));
 }
 
-CAMLprim value cosh_float(value f)
+CAMLprim value caml_cosh_float(value f)
 {
-  return copy_double(cosh(Double_val(f)));
+  return caml_copy_double(cosh(Double_val(f)));
 }
 
-CAMLprim value tan_float(value f)
+CAMLprim value caml_tan_float(value f)
 {
-  return copy_double(tan(Double_val(f)));
+  return caml_copy_double(tan(Double_val(f)));
 }
 
-CAMLprim value tanh_float(value f)
+CAMLprim value caml_tanh_float(value f)
 {
-  return copy_double(tanh(Double_val(f)));
+  return caml_copy_double(tanh(Double_val(f)));
 }
 
-CAMLprim value asin_float(value f)
+CAMLprim value caml_asin_float(value f)
 {
-  return copy_double(asin(Double_val(f)));
+  return caml_copy_double(asin(Double_val(f)));
 }
 
-CAMLprim value acos_float(value f)
+CAMLprim value caml_acos_float(value f)
 {
-  return copy_double(acos(Double_val(f)));
+  return caml_copy_double(acos(Double_val(f)));
 }
 
-CAMLprim value atan_float(value f)
+CAMLprim value caml_atan_float(value f)
 {
-  return copy_double(atan(Double_val(f)));
+  return caml_copy_double(atan(Double_val(f)));
 }
 
-CAMLprim value atan2_float(value f, value g)
+CAMLprim value caml_atan2_float(value f, value g)
 {
-  return copy_double(atan2(Double_val(f), Double_val(g)));
+  return caml_copy_double(atan2(Double_val(f), Double_val(g)));
 }
 
-CAMLprim value ceil_float(value f)
+CAMLprim value caml_ceil_float(value f)
 {
-  return copy_double(ceil(Double_val(f)));
+  return caml_copy_double(ceil(Double_val(f)));
 }
 
-CAMLprim value eq_float(value f, value g)
+CAMLprim value caml_eq_float(value f, value g)
 {
   return Val_bool(Double_val(f) == Double_val(g));
 }
 
-CAMLprim value neq_float(value f, value g)
+CAMLprim value caml_neq_float(value f, value g)
 {
   return Val_bool(Double_val(f) != Double_val(g));
 }
 
-CAMLprim value le_float(value f, value g)
+CAMLprim value caml_le_float(value f, value g)
 {
   return Val_bool(Double_val(f) <= Double_val(g));
 }
 
-CAMLprim value lt_float(value f, value g)
+CAMLprim value caml_lt_float(value f, value g)
 {
   return Val_bool(Double_val(f) < Double_val(g));
 }
 
-CAMLprim value ge_float(value f, value g)
+CAMLprim value caml_ge_float(value f, value g)
 {
   return Val_bool(Double_val(f) >= Double_val(g));
 }
 
-CAMLprim value gt_float(value f, value g)
+CAMLprim value caml_gt_float(value f, value g)
 {
   return Val_bool(Double_val(f) > Double_val(g));
 }
 
-CAMLprim value float_compare(value vf, value vg)
+CAMLprim value caml_float_compare(value vf, value vg)
 {
   double f = Double_val(vf);
   double g = Double_val(vg);
@@ -341,7 +341,7 @@ CAMLprim value float_compare(value vf, value vg)
 
 enum { FP_normal, FP_subnormal, FP_zero, FP_infinite, FP_nan };
 
-CAMLprim value classify_float(value vd)
+CAMLprim value caml_classify_float(value vd)
 {
   /* Cygwin 1.3 has problems with fpclassify (PR#1293), so don't use it */
 #if defined(fpclassify) && !defined(__CYGWIN32__) && !defined(__MINGW32__)
@@ -383,7 +383,7 @@ CAMLprim value classify_float(value vd)
 #endif
 }
 
-/* The init_ieee_float function should initialize floating-point hardware
+/* The [caml_init_ieee_float] function should initialize floating-point hardware
    so that it behaves as much as possible like the IEEE standard.
    In particular, return special numbers like Infinity and NaN instead
    of signalling exceptions.  Currently, everyone is in IEEE mode
@@ -396,7 +396,7 @@ CAMLprim value classify_float(value vd)
 #endif
 #endif
 
-void init_ieee_floats(void)
+void caml_init_ieee_floats(void)
 {
 #if defined(__FreeBSD__) && (__FreeBSD_version < 400017)
   fpsetmask(0);