Mirrors
/
php
mirror of https://github.com/php/php-src
3
0
Fork 0
Code Releases Activity
Browse Source

Made bcmath extension thread safe. 

@Made bcmath extension thread safe. (Sander)
experimental/threaded
Sander Roobol 24 years ago
parent
64a75d6d77
commit
f200f739d8
14 changed files with 185 additions and 201 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 120
      ext/bcmath/bcmath.c
  2. 33
      ext/bcmath/libbcmath/src/bcmath.h
  3. 5
      ext/bcmath/libbcmath/src/debug.c
  4. 8
      ext/bcmath/libbcmath/src/div.c
  5. 18
      ext/bcmath/libbcmath/src/divmod.c
  6. 25
      ext/bcmath/libbcmath/src/init.c
  7. 38
      ext/bcmath/libbcmath/src/output.c
  8. 14
      ext/bcmath/libbcmath/src/raise.c
  9. 26
      ext/bcmath/libbcmath/src/raisemod.c
  10. 36
      ext/bcmath/libbcmath/src/recmul.c
  11. 30
      ext/bcmath/libbcmath/src/sqrt.c
  12. 7
      ext/bcmath/libbcmath/src/str2num.c
  13. 5
      ext/bcmath/libbcmath/src/zero.c
  14. 21
      ext/bcmath/php_bcmath.h

120
ext/bcmath/bcmath.c
View File

@ -30,6 +30,8 @@
#include "php_bcmath.h"
#include "libbcmath/src/bcmath.h"
ZEND_DECLARE_MODULE_GLOBALS(bcmath);
function_entry bcmath_functions[] = {
PHP_FE(bcadd, NULL)
PHP_FE(bcsub, NULL)
@ -47,7 +49,11 @@ zend_module_entry bcmath_module_entry = {
STANDARD_MODULE_HEADER,
"bcmath",
bcmath_functions,
#if ZTS
PHP_MODULE_STARTUP_N(bcmath),
#else
NULL,
#endif
NULL,
PHP_RINIT(bcmath),
PHP_RSHUTDOWN(bcmath),
@ -64,32 +70,22 @@ ZEND_GET_MODULE(bcmath)
static long bc_precision;
#endif
/* Storage used for special numbers. */
extern bc_num _zero_;
extern bc_num _one_;
extern bc_num _two_;
/* Make a copy of a number! Just increments the reference count! */
bc_num copy_num (bc_num num)
#if ZTS
PHP_MODULE_STARTUP_D(bcmath)
{
num->n_refs++;
return num;
}
zend_bcmath_globals *bcmath_globals;
/* Initialize a number NUM by making it a copy of zero. */
void init_num (bc_num *num)
{
*num = copy_num (_zero_);
ts_allocate_id(&bcmath_globals_id, sizeof(zend_bcmath_globals), NULL, NULL);
bcmath_globals = ts_resource(bcmath_globals_id);
return SUCCESS;
}
#endif
PHP_RSHUTDOWN_FUNCTION(bcmath)
{
bc_free_num(&_zero_);
bc_free_num(&_one_);
bc_free_num(&_two_);
bc_free_num(&BCG(_zero_));
bc_free_num(&BCG(_one_));
bc_free_num(&BCG(_two_));
return SUCCESS;
}
@ -101,7 +97,7 @@ PHP_RINIT_FUNCTION(bcmath)
bc_precision=0;
}
bc_init_numbers();
bc_init_numbers(TSRMLS_C);
return SUCCESS;
}
@ -141,11 +137,11 @@ PHP_FUNCTION(bcadd)
}
convert_to_string_ex(left);
convert_to_string_ex(right);
bc_init_num(&first);
bc_init_num(&second);
bc_init_num(&result);
bc_str2num(&first, Z_STRVAL_PP(left), scale);
bc_str2num(&second, Z_STRVAL_PP(right), scale);
bc_init_num(&first TSRMLS_CC);
bc_init_num(&second TSRMLS_CC);
bc_init_num(&result TSRMLS_CC);
bc_str2num(&first, Z_STRVAL_PP(left), scale TSRMLS_CC);
bc_str2num(&second, Z_STRVAL_PP(right), scale TSRMLS_CC);
bc_add (first, second, &result, scale);
Z_STRVAL_P(return_value) = bc_num2str(result);
Z_STRLEN_P(return_value) = strlen(Z_STRVAL_P(return_value));
@ -184,11 +180,11 @@ PHP_FUNCTION(bcsub)
}
convert_to_string_ex(left);
convert_to_string_ex(right);
bc_init_num(&first);
bc_init_num(&second);
bc_init_num(&result);
bc_str2num(&first, Z_STRVAL_PP(left), scale);
bc_str2num(&second, Z_STRVAL_PP(right), scale);
bc_init_num(&first TSRMLS_CC);
bc_init_num(&second TSRMLS_CC);
bc_init_num(&result TSRMLS_CC);
bc_str2num(&first, Z_STRVAL_PP(left), scale TSRMLS_CC);
bc_str2num(&second, Z_STRVAL_PP(right), scale TSRMLS_CC);
bc_sub (first, second, &result, scale);
Z_STRVAL_P(return_value) = bc_num2str(result);
Z_STRLEN_P(return_value) = strlen(Z_STRVAL_P(return_value));
@ -227,12 +223,12 @@ PHP_FUNCTION(bcmul)
}
convert_to_string_ex(left);
convert_to_string_ex(right);
bc_init_num(&first);
bc_init_num(&second);
bc_init_num(&result);
bc_str2num(&first, Z_STRVAL_PP(left), scale);
bc_str2num(&second, Z_STRVAL_PP(right), scale);
bc_multiply (first, second, &result, scale);
bc_init_num(&first TSRMLS_CC);
bc_init_num(&second TSRMLS_CC);
bc_init_num(&result TSRMLS_CC);
bc_str2num(&first, Z_STRVAL_PP(left), scale TSRMLS_CC);
bc_str2num(&second, Z_STRVAL_PP(right), scale TSRMLS_CC);
bc_multiply (first, second, &result, scale TSRMLS_CC);
Z_STRVAL_P(return_value) = bc_num2str(result);
Z_STRLEN_P(return_value) = strlen(Z_STRVAL_P(return_value));
Z_TYPE_P(return_value) = IS_STRING;
@ -270,12 +266,12 @@ PHP_FUNCTION(bcdiv)
}
convert_to_string_ex(left);
convert_to_string_ex(right);
bc_init_num(&first);
bc_init_num(&second);
bc_init_num(&result);
bc_str2num(&first, Z_STRVAL_PP(left), scale);
bc_str2num(&second, Z_STRVAL_PP(right), scale);
switch (bc_divide (first, second, &result, scale)) {
bc_init_num(&first TSRMLS_CC);
bc_init_num(&second TSRMLS_CC);
bc_init_num(&result TSRMLS_CC);
bc_str2num(&first, Z_STRVAL_PP(left), scale TSRMLS_CC);
bc_str2num(&second, Z_STRVAL_PP(right), scale TSRMLS_CC);
switch (bc_divide (first, second, &result, scale TSRMLS_CC)) {
case 0: /* OK */
Z_STRVAL_P(return_value) = bc_num2str(result);
Z_STRLEN_P(return_value) = strlen(Z_STRVAL_P(return_value));
@ -311,12 +307,12 @@ PHP_FUNCTION(bcmod)
}
convert_to_string_ex(left);
convert_to_string_ex(right);
bc_init_num(&first);
bc_init_num(&second);
bc_init_num(&result);
bc_str2num(&first, Z_STRVAL_PP(left), 0);
bc_str2num(&second, Z_STRVAL_PP(right), 0);
switch (bc_modulo(first, second, &result, 0)) {
bc_init_num(&first TSRMLS_CC);
bc_init_num(&second TSRMLS_CC);
bc_init_num(&result TSRMLS_CC);
bc_str2num(&first, Z_STRVAL_PP(left), 0 TSRMLS_CC);
bc_str2num(&second, Z_STRVAL_PP(right), 0 TSRMLS_CC);
switch (bc_modulo(first, second, &result, 0 TSRMLS_CC)) {
case 0:
Z_STRVAL_P(return_value) = bc_num2str(result);
Z_STRLEN_P(return_value) = strlen(Z_STRVAL_P(return_value));
@ -360,12 +356,12 @@ PHP_FUNCTION(bcpow)
}
convert_to_string_ex(left);
convert_to_string_ex(right);
bc_init_num(&first);
bc_init_num(&second);
bc_init_num(&result);
bc_str2num(&first, Z_STRVAL_PP(left), scale);
bc_str2num(&second, Z_STRVAL_PP(right), scale);
bc_raise (first, second, &result, scale);
bc_init_num(&first TSRMLS_CC);
bc_init_num(&second TSRMLS_CC);
bc_init_num(&result TSRMLS_CC);
bc_str2num(&first, Z_STRVAL_PP(left), scale TSRMLS_CC);
bc_str2num(&second, Z_STRVAL_PP(right), scale TSRMLS_CC);
bc_raise (first, second, &result, scale TSRMLS_CC);
Z_STRVAL_P(return_value) = bc_num2str(result);
Z_STRLEN_P(return_value) = strlen(Z_STRVAL_P(return_value));
Z_TYPE_P(return_value) = IS_STRING;
@ -402,9 +398,9 @@ PHP_FUNCTION(bcsqrt)
break;
}
convert_to_string_ex(left);
bc_init_num(&result);
bc_str2num(&result, Z_STRVAL_PP(left), scale);
if (bc_sqrt (&result, scale) != 0) {
bc_init_num(&result TSRMLS_CC);
bc_str2num(&result, Z_STRVAL_PP(left), scale TSRMLS_CC);
if (bc_sqrt (&result, scale TSRMLS_CC) != 0) {
Z_STRVAL_P(return_value) = bc_num2str(result);
Z_STRLEN_P(return_value) = strlen(Z_STRVAL_P(return_value));
Z_TYPE_P(return_value) = IS_STRING;
@ -444,11 +440,11 @@ PHP_FUNCTION(bccomp)
convert_to_string_ex(left);
convert_to_string_ex(right);
bc_init_num(&first);
bc_init_num(&second);
bc_init_num(&first TSRMLS_CC);
bc_init_num(&second TSRMLS_CC);
bc_str2num(&first, Z_STRVAL_PP(left), scale);
bc_str2num(&second, Z_STRVAL_PP(right), scale);
bc_str2num(&first, Z_STRVAL_PP(left), scale TSRMLS_CC);
bc_str2num(&second, Z_STRVAL_PP(right), scale TSRMLS_CC);
Z_LVAL_P(return_value) = bc_compare(first, second);
Z_TYPE_P(return_value) = IS_LONG;

33
ext/bcmath/libbcmath/src/bcmath.h
View File

@ -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. */

5
ext/bcmath/libbcmath/src/debug.c
View File

@ -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');
}

8
ext/bcmath/libbcmath/src/div.c
View File

@ -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;

18
ext/bcmath/libbcmath/src/divmod.c
View File

@ -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);
}

25
ext/bcmath/libbcmath/src/init.c
View File

@ -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_));
}

38
ext/bcmath/libbcmath/src/output.c
View File

@ -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);
}

14
ext/bcmath/libbcmath/src/raise.c
View File

@ -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

26
ext/bcmath/libbcmath/src/raisemod.c
View File

@ -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. */

36
ext/bcmath/libbcmath/src/recmul.c
View File

@ -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;

30
ext/bcmath/libbcmath/src/sqrt.c
View File

@ -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);

7
ext/bcmath/libbcmath/src/str2num.c
View File

@ -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;
}

5
ext/bcmath/libbcmath/src/zero.c
View File

@ -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;

21
ext/bcmath/php_bcmath.h
View File

@ -23,9 +23,30 @@
#if WITH_BCMATH
#include "libbcmath/src/bcmath.h"
ZEND_BEGIN_MODULE_GLOBALS(bcmath)
bc_num _zero_;
bc_num _one_;
bc_num _two_;
ZEND_END_MODULE_GLOBALS(bcmath)
#if ZTS
# define BCG(v) TSRMG(bcmath_globals_id, zend_bcmath_globals *, v)
extern int bcmath_globals_id;
#else
# define BCG(v) (bcmath_globals.v)
extern zend_bcmath_globals bcmath_globals;
#endif
#define BC
extern zend_module_entry bcmath_module_entry;
#define phpext_bcmath_ptr &bcmath_module_entry
#if ZTS
PHP_MINIT_FUNCTION(bcmath);
#endif
PHP_RINIT_FUNCTION(bcmath);
PHP_RSHUTDOWN_FUNCTION(bcmath);
PHP_MINFO_FUNCTION(bcmath);

Write Preview
Loading…
Cancel
Save