Made bcmath extension thread safe.

@Made bcmath extension thread safe. (Sander)

12 files changed, 106 insertions, 139 deletions

diff --git a/ext/bcmath/libbcmath/src/bcmath.h b/ext/bcmath/libbcmath/src/bcmath.h
index a6c7627b6b..6833ce4bcf 100644
--- a/ext/bcmath/libbcmath/src/bcmath.h
+++ b/ext/bcmath/libbcmath/src/bcmath.h
@@ -52,6 +52,9 @@ typedef struct bc_struct
 			   in the case of leading zeros generated. */
     } bc_struct;
 
+#include <php.h>
+#include <ext/bcmath/php_bcmath.h>
+
 
 /* The base used in storing the numbers in n_value above.
    Currently this MUST be 10. */
@@ -81,12 +84,6 @@ typedef struct bc_struct
 #endif
 
 
-/* Global numbers. */
-extern bc_num _zero_;
-extern bc_num _one_;
-extern bc_num _two_;
-
-
 /* Function Prototypes */
 
 /* Define the _PROTOTYPE macro if it is needed. */
@@ -99,7 +96,7 @@ extern bc_num _two_;
 #endif
 #endif
 
-_PROTOTYPE(void bc_init_numbers, (void));
+_PROTOTYPE(void bc_init_numbers, (TSRMLS_D));
 
 _PROTOTYPE(bc_num bc_new_num, (int length, int scale));
 
@@ -107,9 +104,9 @@ _PROTOTYPE(void bc_free_num, (bc_num *num));
 
 _PROTOTYPE(bc_num bc_copy_num, (bc_num num));
 
-_PROTOTYPE(void bc_init_num, (bc_num *num));
+_PROTOTYPE(void bc_init_num, (bc_num *num TSRMLS_DC));
 
-_PROTOTYPE(void bc_str2num, (bc_num *num, char *str, int scale));
+_PROTOTYPE(void bc_str2num, (bc_num *num, char *str, int scale TSRMLS_DC));
 
 _PROTOTYPE(char *bc_num2str, (bc_num num));
 
@@ -119,7 +116,7 @@ _PROTOTYPE(long bc_num2long, (bc_num num));
 
 _PROTOTYPE(int bc_compare, (bc_num n1, bc_num n2));
 
-_PROTOTYPE(char bc_is_zero, (bc_num num));
+_PROTOTYPE(char bc_is_zero, (bc_num num TSRMLS_DC));
 
 _PROTOTYPE(char bc_is_near_zero, (bc_num num, int scale));
 
@@ -129,26 +126,26 @@ _PROTOTYPE(void bc_add, (bc_num n1, bc_num n2, bc_num *result, int scale_min));
 
 _PROTOTYPE(void bc_sub, (bc_num n1, bc_num n2, bc_num *result, int scale_min));
 
-_PROTOTYPE(void bc_multiply, (bc_num n1, bc_num n2, bc_num *prod, int scale));
+_PROTOTYPE(void bc_multiply, (bc_num n1, bc_num n2, bc_num *prod, int scale TSRMLS_DC));
 
-_PROTOTYPE(int bc_divide, (bc_num n1, bc_num n2, bc_num *quot, int scale));
+_PROTOTYPE(int bc_divide, (bc_num n1, bc_num n2, bc_num *quot, int scale TSRMLS_DC));
 
 _PROTOTYPE(int bc_modulo, (bc_num num1, bc_num num2, bc_num *result,
-			   int scale));
+			   int scale TSRMLS_DC));
 
 _PROTOTYPE(int bc_divmod, (bc_num num1, bc_num num2, bc_num *quot,
-			   bc_num *rem, int scale));
+			   bc_num *rem, int scale TSRMLS_DC));
 
 _PROTOTYPE(int bc_raisemod, (bc_num base, bc_num expo, bc_num mod,
-			     bc_num *result, int scale));
+			     bc_num *result, int scale TSRMLS_DC));
 
 _PROTOTYPE(void bc_raise, (bc_num num1, bc_num num2, bc_num *result,
-			   int scale));
+			   int scale TSRMLS_DC));
 
-_PROTOTYPE(int bc_sqrt, (bc_num *num, int scale));
+_PROTOTYPE(int bc_sqrt, (bc_num *num, int scale TSRMLS_DC));
 
 _PROTOTYPE(void bc_out_num, (bc_num num, int o_base, void (* out_char)(int),
-			     int leading_zero));
+			     int leading_zero TSRMLS_DC));
 
 /* Prototypes needed for external utility routines. */
 
diff --git a/ext/bcmath/libbcmath/src/debug.c b/ext/bcmath/libbcmath/src/debug.c
index ac1ee4ada7..52e4e044d5 100644
--- a/ext/bcmath/libbcmath/src/debug.c
+++ b/ext/bcmath/libbcmath/src/debug.c
@@ -48,10 +48,9 @@ out_char (int c)
 
 
 void
-pn (num)
-     bc_num num;
+pn (bc_num num TSRMLS_DC)
 {
-  bc_out_num (num, 10, out_char, 0);
+  bc_out_num (num, 10, out_char, 0 TSRMLS_CC);
   out_char ('\n');
 }
 
diff --git a/ext/bcmath/libbcmath/src/div.c b/ext/bcmath/libbcmath/src/div.c
index 62f24dd494..1ad3710128 100644
--- a/ext/bcmath/libbcmath/src/div.c
+++ b/ext/bcmath/libbcmath/src/div.c
@@ -85,9 +85,7 @@ _one_mult (num, size, digit, result)
    by zero is tried.  The algorithm is found in Knuth Vol 2. p237. */
 
 int
-bc_divide (n1, n2, quot, scale)
-     bc_num n1, n2, *quot;
-     int scale;
+bc_divide (bc_num n1, bc_num n2, bc_num *quot, int scale TSRMLS_DC)
 {
   bc_num qval;
   unsigned char *num1, *num2;
@@ -100,7 +98,7 @@ bc_divide (n1, n2, quot, scale)
   unsigned int  norm;
 
   /* Test for divide by zero. */
-  if (bc_is_zero (n2)) return -1;
+  if (bc_is_zero (n2 TSRMLS_CC)) return -1;
 
   /* Test for divide by 1.  If it is we must truncate. */
   if (n2->n_scale == 0)
@@ -261,7 +259,7 @@ bc_divide (n1, n2, quot, scale)
 
   /* Clean up and return the number. */
   qval->n_sign = ( n1->n_sign == n2->n_sign ? PLUS : MINUS );
-  if (bc_is_zero (qval)) qval->n_sign = PLUS;
+  if (bc_is_zero (qval TSRMLS_CC)) qval->n_sign = PLUS;
   _bc_rm_leading_zeros (qval);
   bc_free_num (quot);
   *quot = qval;
diff --git a/ext/bcmath/libbcmath/src/divmod.c b/ext/bcmath/libbcmath/src/divmod.c
index e62817d00b..2949bd10d4 100644
--- a/ext/bcmath/libbcmath/src/divmod.c
+++ b/ext/bcmath/libbcmath/src/divmod.c
@@ -45,26 +45,24 @@
  */
 
 int
-bc_divmod (num1, num2, quot, rem, scale)
-     bc_num num1, num2, *quot, *rem;
-     int scale;
+bc_divmod (bc_num num1, bc_num num2, bc_num *quot, bc_num *rem, int scale TSRMLS_DC)
 {
   bc_num quotient = NULL;
   bc_num temp;
   int rscale;
 
   /* Check for correct numbers. */
-  if (bc_is_zero (num2)) return -1;
+  if (bc_is_zero (num2 TSRMLS_CC)) return -1;
 
   /* Calculate final scale. */
   rscale = MAX (num1->n_scale, num2->n_scale+scale);
-  bc_init_num(&temp);
+  bc_init_num(&temp TSRMLS_CC);
 
   /* Calculate it. */
-  bc_divide (num1, num2, &temp, scale);
+  bc_divide (num1, num2, &temp, scale TSRMLS_CC);
   if (quot)
     quotient = bc_copy_num (temp);
-  bc_multiply (temp, num2, &temp, rscale);
+  bc_multiply (temp, num2, &temp, rscale TSRMLS_CC);
   bc_sub (num1, temp, rem, rscale);
   bc_free_num (&temp);
 
@@ -82,10 +80,8 @@ bc_divmod (num1, num2, quot, rem, scale)
    result in RESULT.   */
 
 int
-bc_modulo (num1, num2, result, scale)
-     bc_num num1, num2, *result;
-     int scale;
+bc_modulo (bc_num num1, bc_num num2, bc_num *result, int scale TSRMLS_DC)
 {
-  return bc_divmod (num1, num2, NULL, result, scale);
+  return bc_divmod (num1, num2, NULL, result, scale TSRMLS_CC);
 }
 
diff --git a/ext/bcmath/libbcmath/src/init.c b/ext/bcmath/libbcmath/src/init.c
index 4ff00b1102..f349d82a7b 100644
--- a/ext/bcmath/libbcmath/src/init.c
+++ b/ext/bcmath/libbcmath/src/init.c
@@ -38,11 +38,6 @@
 #include "bcmath.h"
 #include "private.h"
 
-/* Storage used for special numbers. */
-bc_num _zero_;
-bc_num _one_;
-bc_num _two_;
-
  bc_num _bc_Free_list = NULL;
 
 /* new_num allocates a number and sets fields to known values. */
@@ -103,21 +98,20 @@ bc_free_num (num)
 /* Intitialize the number package! */
 
 void
-bc_init_numbers ()
+bc_init_numbers (TSRMLS_D)
 {
-  _zero_ = bc_new_num (1,0);
-  _one_  = bc_new_num (1,0);
-  _one_->n_value[0] = 1;
-  _two_  = bc_new_num (1,0);
-  _two_->n_value[0] = 2;
+  BCG(_zero_) = bc_new_num (1,0);
+  BCG(_one_)  = bc_new_num (1,0);
+  BCG(_one_)->n_value[0] = 1;
+  BCG(_two_)  = bc_new_num (1,0);
+  BCG(_two_)->n_value[0] = 2;
 }
 
 
 /* Make a copy of a number!  Just increments the reference count! */
 
 bc_num
-bc_copy_num (num)
-     bc_num num;
+bc_copy_num (bc_num num)
 {
   num->n_refs++;
   return num;
@@ -127,9 +121,8 @@ bc_copy_num (num)
 /* Initialize a number NUM by making it a copy of zero. */
 
 void
-bc_init_num (num)
-     bc_num *num;
+bc_init_num (bc_num *num TSRMLS_DC)
 {
-  *num = bc_copy_num (_zero_);
+  *num = bc_copy_num (BCG(_zero_));
 }
 
diff --git a/ext/bcmath/libbcmath/src/output.c b/ext/bcmath/libbcmath/src/output.c
index e41479d2d3..ab49b0e366 100644
--- a/ext/bcmath/libbcmath/src/output.c
+++ b/ext/bcmath/libbcmath/src/output.c
@@ -86,15 +86,11 @@ bc_out_long (val, size, space, out_char)
    as the routine to do the actual output of the characters. */
 
 void
-bc_out_num (num, o_base, out_char, leading_zero)
-     bc_num num;
-     int o_base;
 #ifdef __STDC__
-     void (*out_char)(int);
+bc_out_num (bc_num num, int o_base, void (*out_char)(int), int leading_zero TSRMLS_DC)
 #else
-     void (*out_char)();
+bc_out_num (bc_num num, int o_base, void (*out_char)(), int leading_zero TSRMLS_DC)
 #endif
-     int leading_zero;
 {
   char *nptr;
   int  index, fdigit, pre_space;
@@ -105,7 +101,7 @@ bc_out_num (num, o_base, out_char, leading_zero)
   if (num->n_sign == MINUS) (*out_char) ('-');
 
   /* Output the number. */
-  if (bc_is_zero (num))
+  if (bc_is_zero (num TSRMLS_CC))
     (*out_char) ('0');
   else
     if (o_base == 10)
@@ -118,7 +114,7 @@ bc_out_num (num, o_base, out_char, leading_zero)
 	else
 	  nptr++;
 
-	if (leading_zero && bc_is_zero (num))
+	if (leading_zero && bc_is_zero (num TSRMLS_CC))
 	  (*out_char) ('0');
 
 	/* Now the fraction. */
@@ -132,36 +128,36 @@ bc_out_num (num, o_base, out_char, leading_zero)
     else
       {
 	/* special case ... */
-	if (leading_zero && bc_is_zero (num))
+	if (leading_zero && bc_is_zero (num TSRMLS_CC))
 	  (*out_char) ('0');
 
 	/* The number is some other base. */
 	digits = NULL;
-	bc_init_num (&int_part);
-	bc_divide (num, _one_, &int_part, 0);
-	bc_init_num (&frac_part);
-	bc_init_num (&cur_dig);
-	bc_init_num (&base);
+	bc_init_num (&int_part TSRMLS_CC);
+	bc_divide (num, BCG(_one_), &int_part, 0 TSRMLS_CC);
+	bc_init_num (&frac_part TSRMLS_CC);
+	bc_init_num (&cur_dig TSRMLS_CC);
+	bc_init_num (&base TSRMLS_CC);
 	bc_sub (num, int_part, &frac_part, 0);
 	/* Make the INT_PART and FRAC_PART positive. */
 	int_part->n_sign = PLUS;
 	frac_part->n_sign = PLUS;
 	bc_int2num (&base, o_base);
-	bc_init_num (&max_o_digit);
+	bc_init_num (&max_o_digit TSRMLS_CC);
 	bc_int2num (&max_o_digit, o_base-1);
 
 
 	/* Get the digits of the integer part and push them on a stack. */
-	while (!bc_is_zero (int_part))
+	while (!bc_is_zero (int_part TSRMLS_CC))
 	  {
-	    bc_modulo (int_part, base, &cur_dig, 0);
+	    bc_modulo (int_part, base, &cur_dig, 0 TSRMLS_CC);
 		/* PHP Change:  malloc() -> emalloc() */
 	    temp = (stk_rec *) emalloc (sizeof(stk_rec));
 	    if (temp == NULL) bc_out_of_memory();
 	    temp->digit = bc_num2long (cur_dig);
 	    temp->next = digits;
 	    digits = temp;
-	    bc_divide (int_part, base, &int_part, 0);
+	    bc_divide (int_part, base, &int_part, 0 TSRMLS_CC);
 	  }
 
 	/* Print the digits on the stack. */
@@ -185,9 +181,9 @@ bc_out_num (num, o_base, out_char, leading_zero)
 	  {
 	    (*out_char) ('.');
 	    pre_space = 0;
-	    t_num = bc_copy_num (_one_);
+	    t_num = bc_copy_num (BCG(_one_));
 	    while (t_num->n_len <= num->n_scale) {
-	      bc_multiply (frac_part, base, &frac_part, num->n_scale);
+	      bc_multiply (frac_part, base, &frac_part, num->n_scale TSRMLS_CC);
 	      fdigit = bc_num2long (frac_part);
 	      bc_int2num (&int_part, fdigit);
 	      bc_sub (frac_part, int_part, &frac_part, 0);
@@ -197,7 +193,7 @@ bc_out_num (num, o_base, out_char, leading_zero)
 		bc_out_long (fdigit, max_o_digit->n_len, pre_space, out_char);
 		pre_space = 1;
 	      }
-	      bc_multiply (t_num, base, &t_num, 0);
+	      bc_multiply (t_num, base, &t_num, 0 TSRMLS_CC);
 	    }
 	    bc_free_num (&t_num);
 	  }
diff --git a/ext/bcmath/libbcmath/src/raise.c b/ext/bcmath/libbcmath/src/raise.c
index 5f2f03c208..f2f4f4a1d7 100644
--- a/ext/bcmath/libbcmath/src/raise.c
+++ b/ext/bcmath/libbcmath/src/raise.c
@@ -44,9 +44,7 @@
    only the integer part is used.  */
 
 void
-bc_raise (num1, num2, result, scale)
-     bc_num num1, num2, *result;
-     int scale;
+bc_raise (bc_num num1, bc_num num2, bc_num *result, int scale TSRMLS_DC)
 {
    bc_num temp, power;
    long exponent;
@@ -66,7 +64,7 @@ bc_raise (num1, num2, result, scale)
    if (exponent == 0)
      {
        bc_free_num (result);
-       *result = bc_copy_num (_one_);
+       *result = bc_copy_num (BCG(_one_));
        return;
      }
 
@@ -89,7 +87,7 @@ bc_raise (num1, num2, result, scale)
    while ((exponent & 1) == 0)
      {
        pwrscale = 2*pwrscale;
-       bc_multiply (power, power, &power, pwrscale);
+       bc_multiply (power, power, &power, pwrscale TSRMLS_CC);
        exponent = exponent >> 1;
      }
    temp = bc_copy_num (power);
@@ -100,10 +98,10 @@ bc_raise (num1, num2, result, scale)
    while (exponent > 0)
      {
        pwrscale = 2*pwrscale;
-       bc_multiply (power, power, &power, pwrscale);
+       bc_multiply (power, power, &power, pwrscale TSRMLS_CC);
        if ((exponent & 1) == 1) {
 	 calcscale = pwrscale + calcscale;
-	 bc_multiply (temp, power, &temp, calcscale);
+	 bc_multiply (temp, power, &temp, calcscale TSRMLS_CC);
        }
        exponent = exponent >> 1;
      }
@@ -111,7 +109,7 @@ bc_raise (num1, num2, result, scale)
    /* Assign the value. */
    if (neg)
      {
-       bc_divide (_one_, temp, result, rscale);
+       bc_divide (BCG(_one_), temp, result, rscale TSRMLS_CC);
        bc_free_num (&temp);
      }
    else
diff --git a/ext/bcmath/libbcmath/src/raisemod.c b/ext/bcmath/libbcmath/src/raisemod.c
index cc9dd35a57..3f6edcc2ac 100644
--- a/ext/bcmath/libbcmath/src/raisemod.c
+++ b/ext/bcmath/libbcmath/src/raisemod.c
@@ -43,22 +43,20 @@
    only the integer part is used.  */
 
 int
-bc_raisemod (base, expo, mod, result, scale)
-     bc_num base, expo, mod, *result;
-     int scale;
+bc_raisemod (bc_num base, bc_num expo, bc_num mod, bc_num *result, int scale TSRMLS_DC)
 {
   bc_num power, exponent, parity, temp;
   int rscale;
 
   /* Check for correct numbers. */
-  if (bc_is_zero(mod)) return -1;
+  if (bc_is_zero(mod TSRMLS_CC)) return -1;
   if (bc_is_neg(expo)) return -1;
 
   /* Set initial values.  */
   power = bc_copy_num (base);
   exponent = bc_copy_num (expo);
-  temp = bc_copy_num (_one_);
-  bc_init_num(&parity);
+  temp = bc_copy_num (BCG(_one_));
+  bc_init_num(&parity TSRMLS_CC);
 
   /* Check the base for scale digits. */
   if (base->n_scale != 0)
@@ -68,7 +66,7 @@ bc_raisemod (base, expo, mod, result, scale)
   if (exponent->n_scale != 0)
     {
       bc_rt_warn ("non-zero scale in exponent");
-      bc_divide (exponent, _one_, &exponent, 0); /*truncate */
+      bc_divide (exponent, BCG(_one_), &exponent, 0 TSRMLS_CC); /*truncate */
     }
 
   /* Check the modulus for scale digits. */
@@ -77,17 +75,17 @@ bc_raisemod (base, expo, mod, result, scale)
 
   /* Do the calculation. */
   rscale = MAX(scale, base->n_scale);
-  while ( !bc_is_zero(exponent) )
+  while ( !bc_is_zero(exponent TSRMLS_CC) )
     {
-      (void) bc_divmod (exponent, _two_, &exponent, &parity, 0);
-      if ( !bc_is_zero(parity) )
+      (void) bc_divmod (exponent, BCG(_two_), &exponent, &parity, 0 TSRMLS_CC);
+      if ( !bc_is_zero(parity TSRMLS_CC) )
 	{
-	  bc_multiply (temp, power, &temp, rscale);
-	  (void) bc_modulo (temp, mod, &temp, scale);
+	  bc_multiply (temp, power, &temp, rscale TSRMLS_CC);
+	  (void) bc_modulo (temp, mod, &temp, scale TSRMLS_CC);
 	}
 
-      bc_multiply (power, power, &power, rscale);
-      (void) bc_modulo (power, mod, &power, scale);
+      bc_multiply (power, power, &power, rscale TSRMLS_CC);
+      (void) bc_modulo (power, mod, &power, scale TSRMLS_CC);
     }
 
   /* Assign the value. */
diff --git a/ext/bcmath/libbcmath/src/recmul.c b/ext/bcmath/libbcmath/src/recmul.c
index 73f67af574..f97614c535 100644
--- a/ext/bcmath/libbcmath/src/recmul.c
+++ b/ext/bcmath/libbcmath/src/recmul.c
@@ -176,7 +176,7 @@ _bc_shift_addsub (bc_num accum, bc_num val, int shift, int sub)
 */
 static void
 _bc_rec_mul (bc_num u, int ulen, bc_num v, int vlen, bc_num *prod,
-	     int full_scale)
+	     int full_scale TSRMLS_DC)
 { 
   bc_num u0, u1, v0, v1;
   int u0len, v0len;
@@ -197,14 +197,14 @@ _bc_rec_mul (bc_num u, int ulen, bc_num v, int vlen, bc_num *prod,
 
   /* Split u and v. */
   if (ulen < n) {
-    u1 = bc_copy_num (_zero_);
+    u1 = bc_copy_num (BCG(_zero_));
     u0 = new_sub_num (ulen,0, u->n_value);
   } else {
     u1 = new_sub_num (ulen-n, 0, u->n_value);
     u0 = new_sub_num (n, 0, u->n_value+ulen-n);
   }
   if (vlen < n) {
-    v1 = bc_copy_num (_zero_);
+    v1 = bc_copy_num (BCG(_zero_));
     v0 = new_sub_num (vlen,0, v->n_value);
   } else {
     v1 = new_sub_num (vlen-n, 0, v->n_value);
@@ -217,12 +217,12 @@ _bc_rec_mul (bc_num u, int ulen, bc_num v, int vlen, bc_num *prod,
   _bc_rm_leading_zeros (v0);
   v0len = v0->n_len;
 
-  m1zero = bc_is_zero(u1) || bc_is_zero(v1);
+  m1zero = bc_is_zero(u1 TSRMLS_CC) || bc_is_zero(v1 TSRMLS_CC);
 
   /* Calculate sub results ... */
 
-  bc_init_num(&d1);
-  bc_init_num(&d2);
+  bc_init_num(&d1 TSRMLS_CC);
+  bc_init_num(&d2 TSRMLS_CC);
   bc_sub (u1, u0, &d1, 0);
   d1len = d1->n_len;
   bc_sub (v0, v1, &d2, 0);
@@ -231,19 +231,19 @@ _bc_rec_mul (bc_num u, int ulen, bc_num v, int vlen, bc_num *prod,
 
   /* Do recursive multiplies and shifted adds. */
   if (m1zero)
-    m1 = bc_copy_num (_zero_);
+    m1 = bc_copy_num (BCG(_zero_));
   else
-    _bc_rec_mul (u1, u1->n_len, v1, v1->n_len, &m1, 0);
+    _bc_rec_mul (u1, u1->n_len, v1, v1->n_len, &m1, 0 TSRMLS_CC);
 
-  if (bc_is_zero(d1) || bc_is_zero(d2))
-    m2 = bc_copy_num (_zero_);
+  if (bc_is_zero(d1 TSRMLS_CC) || bc_is_zero(d2 TSRMLS_CC))
+    m2 = bc_copy_num (BCG(_zero_));
   else
-    _bc_rec_mul (d1, d1len, d2, d2len, &m2, 0);
+    _bc_rec_mul (d1, d1len, d2, d2len, &m2, 0 TSRMLS_CC);
 
-  if (bc_is_zero(u0) || bc_is_zero(v0))
-    m3 = bc_copy_num (_zero_);
+  if (bc_is_zero(u0 TSRMLS_CC) || bc_is_zero(v0 TSRMLS_CC))
+    m3 = bc_copy_num (BCG(_zero_));
   else
-    _bc_rec_mul (u0, u0->n_len, v0, v0->n_len, &m3, 0);
+    _bc_rec_mul (u0, u0->n_len, v0, v0->n_len, &m3, 0 TSRMLS_CC);
 
   /* Initialize product */
   prodlen = ulen+vlen+1;
@@ -274,9 +274,7 @@ _bc_rec_mul (bc_num u, int ulen, bc_num v, int vlen, bc_num *prod,
    */
 
 void
-bc_multiply (n1, n2, prod, scale)
-     bc_num n1, n2, *prod;
-     int scale;
+bc_multiply (bc_num n1, bc_num n2, bc_num *prod, int scale TSRMLS_DC)
 {
   bc_num pval; 
   int len1, len2;
@@ -289,7 +287,7 @@ bc_multiply (n1, n2, prod, scale)
   prod_scale = MIN(full_scale,MAX(scale,MAX(n1->n_scale,n2->n_scale)));
 
   /* Do the multiply */
-  _bc_rec_mul (n1, len1, n2, len2, &pval, full_scale);
+  _bc_rec_mul (n1, len1, n2, len2, &pval, full_scale TSRMLS_CC);
 
   /* Assign to prod and clean up the number. */
   pval->n_sign = ( n1->n_sign == n2->n_sign ? PLUS : MINUS );
@@ -297,7 +295,7 @@ bc_multiply (n1, n2, prod, scale)
   pval->n_len = len2 + len1 + 1 - full_scale;
   pval->n_scale = prod_scale;
   _bc_rm_leading_zeros (pval);
-  if (bc_is_zero (pval))
+  if (bc_is_zero (pval TSRMLS_CC))
     pval->n_sign = PLUS;
   bc_free_num (prod);
   *prod = pval;
diff --git a/ext/bcmath/libbcmath/src/sqrt.c b/ext/bcmath/libbcmath/src/sqrt.c
index 34b95b8898..5db5113eb5 100644
--- a/ext/bcmath/libbcmath/src/sqrt.c
+++ b/ext/bcmath/libbcmath/src/sqrt.c
@@ -42,16 +42,14 @@
    after the decimal place. */
 
 int
-bc_sqrt (num, scale)
-     bc_num *num;
-     int scale;
+bc_sqrt (bc_num *num, int scale TSRMLS_DC)
 {
   int rscale, cmp_res, done;
   int cscale;
   bc_num guess, guess1, point5, diff;
 
   /* Initial checks. */
-  cmp_res = bc_compare (*num, _zero_);
+  cmp_res = bc_compare (*num, BCG(_zero_));
   if (cmp_res < 0)
     return 0;		/* error */
   else
@@ -59,23 +57,23 @@ bc_sqrt (num, scale)
       if (cmp_res == 0)
 	{
 	  bc_free_num (num);
-	  *num = bc_copy_num (_zero_);
+	  *num = bc_copy_num (BCG(_zero_));
 	  return 1;
 	}
     }
-  cmp_res = bc_compare (*num, _one_);
+  cmp_res = bc_compare (*num, BCG(_one_));
   if (cmp_res == 0)
     {
       bc_free_num (num);
-      *num = bc_copy_num (_one_);
+      *num = bc_copy_num (BCG(_one_));
       return 1;
     }
 
   /* Initialize the variables. */
   rscale = MAX (scale, (*num)->n_scale);
-  bc_init_num(&guess);
-  bc_init_num(&guess1);
-  bc_init_num(&diff);
+  bc_init_num(&guess TSRMLS_CC);
+  bc_init_num(&guess1 TSRMLS_CC);
+  bc_init_num(&diff TSRMLS_CC);
   point5 = bc_new_num (1,1);
   point5->n_value[1] = 5;
 
@@ -84,7 +82,7 @@ bc_sqrt (num, scale)
   if (cmp_res < 0)
     {
       /* The number is between 0 and 1.  Guess should start at 1. */
-      guess = bc_copy_num (_one_);
+      guess = bc_copy_num (BCG(_one_));
       cscale = (*num)->n_scale;
     }
   else
@@ -93,9 +91,9 @@ bc_sqrt (num, scale)
       bc_int2num (&guess,10);
 
       bc_int2num (&guess1,(*num)->n_len);
-      bc_multiply (guess1, point5, &guess1, 0);
+      bc_multiply (guess1, point5, &guess1, 0 TSRMLS_CC);
       guess1->n_scale = 0;
-      bc_raise (guess, guess1, &guess, 0);
+      bc_raise (guess, guess1, &guess, 0 TSRMLS_CC);
       bc_free_num (&guess1);
       cscale = 3;
     }
@@ -106,9 +104,9 @@ bc_sqrt (num, scale)
     {
       bc_free_num (&guess1);
       guess1 = bc_copy_num (guess);
-      bc_divide (*num, guess, &guess, cscale);
+      bc_divide (*num, guess, &guess, cscale TSRMLS_CC);
       bc_add (guess, guess1, &guess, 0);
-      bc_multiply (guess, point5, &guess, cscale);
+      bc_multiply (guess, point5, &guess, cscale TSRMLS_CC);
       bc_sub (guess, guess1, &diff, cscale+1);
       if (bc_is_near_zero (diff, cscale))
 	{
@@ -121,7 +119,7 @@ bc_sqrt (num, scale)
 
   /* Assign the number and clean up. */
   bc_free_num (num);
-  bc_divide (guess,_one_,num,rscale);
+  bc_divide (guess,BCG(_one_),num,rscale TSRMLS_CC);
   bc_free_num (&guess);
   bc_free_num (&guess1);
   bc_free_num (&point5);
diff --git a/ext/bcmath/libbcmath/src/str2num.c b/ext/bcmath/libbcmath/src/str2num.c
index 210a7d89ea..c484c158e5 100644
--- a/ext/bcmath/libbcmath/src/str2num.c
+++ b/ext/bcmath/libbcmath/src/str2num.c
@@ -41,10 +41,7 @@
 /* Convert strings to bc numbers.  Base 10 only.*/
 
 void
-bc_str2num (num, str, scale)
-     bc_num *num;
-     char *str;
-     int scale;
+bc_str2num (bc_num *num, char *str, int scale TSRMLS_DC)
 {
   int digits, strscale;
   char *ptr, *nptr;
@@ -65,7 +62,7 @@ bc_str2num (num, str, scale)
   while (isdigit((int)*ptr)) ptr++, strscale++;	/* digits */
   if ((*ptr != '\0') || (digits+strscale == 0))
     {
-      *num = bc_copy_num (_zero_);
+      *num = bc_copy_num (BCG(_zero_));
       return;
     }
 
diff --git a/ext/bcmath/libbcmath/src/zero.c b/ext/bcmath/libbcmath/src/zero.c
index dce77ba4aa..4ee249ee71 100644
--- a/ext/bcmath/libbcmath/src/zero.c
+++ b/ext/bcmath/libbcmath/src/zero.c
@@ -41,14 +41,13 @@
 /* In some places we need to check if the number NUM is zero. */
 
 char
-bc_is_zero (num)
-     bc_num num;
+bc_is_zero (bc_num num TSRMLS_DC)
 {
   int  count;
   char *nptr;
 
   /* Quick check. */
-  if (num == _zero_) return TRUE;
+  if (num == BCG(_zero_)) return TRUE;
 
   /* Initialize */
   count = num->n_len + num->n_scale;