Use "define" instead of "const" for natives macros

src/third_party/fdlibm/fdlibm.js

 // The following is adapted from fdlibm (http://www.netlib.org/fdlibm),
 //
 // ====================================================
 // Copyright (C) 1993-2004 by Sun Microsystems, Inc. All rights reserved.
 //
 // Developed at SunSoft, a Sun Microsystems, Inc. business.
 // Permission to use, copy, modify, and distribute this
 // software is freely granted, provided that this notice
 // is preserved.
 // ====================================================
@@ skipping 18 matching lines @@
 (function() {
   
 "use strict";
 
 %CheckIsBootstrapping();
 
 var GlobalMath = global.Math;
 
 //-------------------------------------------------------------------
 
-const INVPIO2 = kMath[0];
-const PIO2_1  = kMath[1];
-const PIO2_1T = kMath[2];
-const PIO2_2  = kMath[3];
-const PIO2_2T = kMath[4];
-const PIO2_3  = kMath[5];
-const PIO2_3T = kMath[6];
-const PIO4    = kMath[32];
-const PIO4LO  = kMath[33];
+define INVPIO2 = kMath[0];
+define PIO2_1  = kMath[1];
+define PIO2_1T = kMath[2];
+define PIO2_2  = kMath[3];
+define PIO2_2T = kMath[4];
+define PIO2_3  = kMath[5];
+define PIO2_3T = kMath[6];
+define PIO4    = kMath[32];
+define PIO4LO  = kMath[33];
 
 // Compute k and r such that x - k*pi/2 = r where |r| < pi/4. For
 // precision, r is returned as two values y0 and y1 such that r = y0 + y1
 // to more than double precision.
 
 macro REMPIO2(X)
   var n, y0, y1;
   var hx = %_DoubleHi(X);
   var ix = hx & 0x7fffffff;
 
@@ skipping 84 matching lines @@
 //    |  x                                               |
 //
 //  3. ieee_sin(X+Y) = ieee_sin(X) + sin'(X')*Y
 //              ~ ieee_sin(X) + (1-X*X/2)*Y
 //     For better accuracy, let
 //               3      2      2      2      2
 //          r = X *(S2+X *(S3+X *(S4+X *(S5+X *S6))))
 //     then                   3    2
 //          sin(x) = X + (S1*X + (X *(r-Y/2)+Y))
 //
-const S1 = -1.66666666666666324348e-01;
-const S2 = 8.33333333332248946124e-03;
-const S3 = -1.98412698298579493134e-04;
-const S4 = 2.75573137070700676789e-06;
-const S5 = -2.50507602534068634195e-08;
-const S6 = 1.58969099521155010221e-10;
+define S1 = -1.66666666666666324348e-01;
+define S2 = 8.33333333332248946124e-03;
+define S3 = -1.98412698298579493134e-04;
+define S4 = 2.75573137070700676789e-06;
+define S5 = -2.50507602534068634195e-08;
+define S6 = 1.58969099521155010221e-10;
 
 macro RETURN_KERNELSIN(X, Y, SIGN)
   var z = X * X;
   var v = z * X;
   var r = S2 + z * (S3 + z * (S4 + z * (S5 + z * S6)));
   return (X - ((z * (0.5 * Y - v * r) - Y) - v * S1)) SIGN;
 endmacro
 
 // __kernel_cos(X, Y)
 // kernel cos function on [-pi/4, pi/4], pi/4 ~ 0.785398164
@@ skipping 20 matching lines @@
 //     a correction term is necessary in ieee_cos(x) and hence
 //         cos(X+Y) = 1 - (X*X/2 - (r - X*Y))
 //     For better accuracy when x > 0.3, let qx = |x|/4 with
 //     the last 32 bits mask off, and if x > 0.78125, let qx = 0.28125.
 //     Then
 //         cos(X+Y) = (1-qx) - ((X*X/2-qx) - (r-X*Y)).
 //     Note that 1-qx and (X*X/2-qx) is EXACT here, and the
 //     magnitude of the latter is at least a quarter of X*X/2,
 //     thus, reducing the rounding error in the subtraction.
 //
-const C1 = 4.16666666666666019037e-02;
-const C2 = -1.38888888888741095749e-03;
-const C3 = 2.48015872894767294178e-05;
-const C4 = -2.75573143513906633035e-07;
-const C5 = 2.08757232129817482790e-09;
-const C6 = -1.13596475577881948265e-11;
+define C1 = 4.16666666666666019037e-02;
+define C2 = -1.38888888888741095749e-03;
+define C3 = 2.48015872894767294178e-05;
+define C4 = -2.75573143513906633035e-07;
+define C5 = 2.08757232129817482790e-09;
+define C6 = -1.13596475577881948265e-11;
 
 macro RETURN_KERNELCOS(X, Y, SIGN)
   var ix = %_DoubleHi(X) & 0x7fffffff;
   var z = X * X;
   var r = z * (C1 + z * (C2 + z * (C3 + z * (C4 + z * (C5 + z * C6)))));
   if (ix < 0x3fd33333) {  // |x| ~< 0.3
     return (1 - (0.5 * z - (z * r - X * Y))) SIGN;
   } else {
     var qx;
     if (ix > 0x3fe90000) {  // |x| > 0.78125
@@ skipping 219 matching lines @@
 //
 // Note: Assuming log() return accurate answer, the following
 //       algorithm can be used to compute log1p(x) to within a few ULP:
 //
 //              u = 1+x;
 //              if (u==1.0) return x ; else
 //                          return log(u)*(x/(u-1.0));
 //
 //       See HP-15C Advanced Functions Handbook, p.193.
 //
-const LN2_HI    = kMath[34];
-const LN2_LO    = kMath[35];
-const TWO_THIRD = kMath[36];
+define LN2_HI    = kMath[34];
+define LN2_LO    = kMath[35];
+define TWO_THIRD = kMath[36];
 macro KLOG1P(x)
 (kMath[37+x])
 endmacro
 // 2^54
-const TWO54 = 18014398509481984;
+define TWO54 = 18014398509481984;
 
 function MathLog1p(x) {
   x = x * 1;  // Convert to number.
   var hx = %_DoubleHi(x);
   var ax = hx & 0x7fffffff;
   var k = 1;
   var f = x;
   var hu = 1;
   var c = 0;
   var u = x;
@@ skipping 158 matching lines @@
 //      for finite argument, only expm1(0)=0 is exact.
 //
 // Accuracy:
 //      according to an error analysis, the error is always less than
 //      1 ulp (unit in the last place).
 //
 // Misc. info.
 //      For IEEE double 
 //          if x > 7.09782712893383973096e+02 then expm1(x) overflow
 //
-const KEXPM1_OVERFLOW = kMath[44];
-const INVLN2          = kMath[45];
+define KEXPM1_OVERFLOW = kMath[44];
+define INVLN2          = kMath[45];
 macro KEXPM1(x)
 (kMath[46+x])
 endmacro
 
 function MathExpm1(x) {
   x = x * 1;  // Convert to number.
   var y;
   var hi;
   var lo;
   var k;
@@ skipping 101 matching lines @@
 //                                                      2
 //
 //          22       <= x <= lnovft :  sinh(x) := exp(x)/2 
 //          lnovft   <= x <= ln2ovft:  sinh(x) := exp(x/2)/2 * exp(x/2)
 //          ln2ovft  <  x           :  sinh(x) := x*shuge (overflow)
 //
 // Special cases:
 //      sinh(x) is |x| if x is +Infinity, -Infinity, or NaN.
 //      only sinh(0)=0 is exact for finite x.
 //
-const KSINH_OVERFLOW = kMath[51];
-const TWO_M28 = 3.725290298461914e-9;  // 2^-28, empty lower half
-const LOG_MAXD = 709.7822265625;  // 0x40862e42 00000000, empty lower half
+define KSINH_OVERFLOW = kMath[51];
+define TWO_M28 = 3.725290298461914e-9;  // 2^-28, empty lower half
+define LOG_MAXD = 709.7822265625;  // 0x40862e42 00000000, empty lower half
 
 function MathSinh(x) {
   x = x * 1;  // Convert to number.
   var h = (x < 0) ? -0.5 : 0.5;
   // |x| in [0, 22]. return sign(x)*0.5*(E+E/(E+1))
   var ax = $abs(x);
   if (ax < 22) {
     // For |x| < 2^-28, sinh(x) = x
     if (ax < TWO_M28) return x;
     var t = MathExpm1(ax);
@@ skipping 29 matching lines @@
 //          ln2/2    <= x <= 22     :  cosh(x) := -------------------
 //                                                        2
 //          22       <= x <= lnovft :  cosh(x) := exp(x)/2 
 //          lnovft   <= x <= ln2ovft:  cosh(x) := exp(x/2)/2 * exp(x/2)
 //          ln2ovft  <  x           :  cosh(x) := huge*huge (overflow)
 //
 // Special cases:
 //      cosh(x) is |x| if x is +INF, -INF, or NaN.
 //      only cosh(0)=1 is exact for finite x.
 //
-const KCOSH_OVERFLOW = kMath[51];
+define KCOSH_OVERFLOW = kMath[51];
 
 function MathCosh(x) {
   x = x * 1;  // Convert to number.
   var ix = %_DoubleHi(x) & 0x7fffffff;
   // |x| in [0,0.5*log2], return 1+expm1(|x|)^2/(2*exp(|x|))
   if (ix < 0x3fd62e43) {
     var t = MathExpm1($abs(x));
     var w = 1 + t;
     // For |x| < 2^-55, cosh(x) = 1
     if (ix < 0x3c800000) return w;
@@ skipping 37 matching lines @@
 //      [1/log(10)] rounded to 53 bits has error .198 ulps;
 //      log10 is monotonic at all binary break points.
 //
 // Special cases:
 //      log10(x) is NaN if x < 0;
 //      log10(+INF) is +INF; log10(0) is -INF;
 //      log10(NaN) is that NaN;
 //      log10(10**N) = N  for N=0,1,...,22.
 //
 
-const IVLN10 = kMath[52];
-const LOG10_2HI = kMath[53];
-const LOG10_2LO = kMath[54];
+define IVLN10 = kMath[52];
+define LOG10_2HI = kMath[53];
+define LOG10_2LO = kMath[54];
 
 function MathLog10(x) {
   x = x * 1;  // Convert to number.
   var hx = %_DoubleHi(x);
   var lx = %_DoubleLo(x);
   var k = 0;
 
   if (hx < 0x00100000) {
     // x < 2^-1022
     // log10(+/- 0) = -Infinity.
@@ skipping 27 matching lines @@
 // fdlibm does not have an explicit log2 function, but fdlibm's pow
 // function does implement an accurate log2 function as part of the
 // pow implementation.  This extracts the core parts of that as a
 // separate log2 function.
 
 // Method:
 // Compute log2(x) in two pieces:
 // log2(x) = w1 + w2
 // where w1 has 53-24 = 29 bits of trailing zeroes.
 
-const DP_H = kMath[64];
-const DP_L = kMath[65];
+define DP_H = kMath[64];
+define DP_L = kMath[65];
 
 // Polynomial coefficients for (3/2)*(log2(x) - 2*s - 2/3*s^3)
 macro KLOG2(x)
 (kMath[55+x])
 endmacro
 
 // cp = 2/(3*ln(2)). Note that cp_h + cp_l is cp, but with more accuracy.
-const CP = kMath[61];
-const CP_H = kMath[62];
-const CP_L = kMath[63];
+define CP = kMath[61];
+define CP_H = kMath[62];
+define CP_L = kMath[63];
 // 2^53
-const TWO53 = 9007199254740992; 
+define TWO53 = 9007199254740992; 
 
 function MathLog2(x) {
   x = x * 1;  // Convert to number.
   var ax = $abs(x);
   var hx = %_DoubleHi(x);
   var lx = %_DoubleLo(x);
   var ix = hx & 0x7fffffff;
 
   // Handle special cases.
   // log2(+/- 0) = -Infinity
@@ skipping 85 matching lines @@
   "log10", MathLog10,
   "log2", MathLog2,
   "log1p", MathLog1p,
   "expm1", MathExpm1
 ]);
 
 %SetInlineBuiltinFlag(MathSin);
 %SetInlineBuiltinFlag(MathCos);
 
 })();