mirror of
https://github.com/php/php-src.git
synced 2024-09-23 19:07:26 +00:00
435 lines
11 KiB
C
435 lines
11 KiB
C
/*
|
|
+----------------------------------------------------------------------+
|
|
| PHP version 4.0 |
|
|
+----------------------------------------------------------------------+
|
|
| Copyright (c) 1997, 1998, 1999 The PHP Group |
|
|
+----------------------------------------------------------------------+
|
|
| This source file is subject to version 2.0 of the PHP license, |
|
|
| that is bundled with this package in the file LICENSE, and is |
|
|
| available at through the world-wide-web at |
|
|
| http://www.php.net/license/2_0.txt. |
|
|
| If you did not receive a copy of the PHP license and are unable to |
|
|
| obtain it through the world-wide-web, please send a note to |
|
|
| license@php.net so we can mail you a copy immediately. |
|
|
+----------------------------------------------------------------------+
|
|
| Authors: Andi Gutmans <andi@zend.com> |
|
|
+----------------------------------------------------------------------+
|
|
*/
|
|
|
|
#include "php.h"
|
|
|
|
#if WITH_BCMATH
|
|
|
|
#include "number.h"
|
|
#include "php3_bcmath.h"
|
|
|
|
function_entry bcmath_functions[] = {
|
|
{"bcadd", php3_bcmath_add, NULL},
|
|
{"bcsub", php3_bcmath_sub, NULL},
|
|
{"bcmul", php3_bcmath_mul, NULL},
|
|
{"bcdiv", php3_bcmath_div, NULL},
|
|
{"bcmod", php3_bcmath_mod, NULL},
|
|
{"bcpow", php3_bcmath_pow, NULL},
|
|
{"bcsqrt", php3_bcmath_sqrt, NULL},
|
|
{"bcscale", php3_bcmath_set_scale, NULL},
|
|
{"bccomp", php3_bcmath_comp, NULL},
|
|
{NULL, NULL, NULL}
|
|
};
|
|
|
|
php3_module_entry bcmath_module_entry = {
|
|
"bcmath", bcmath_functions, NULL, NULL, php3_rinit_bcmath, php3_rend_bcmath, NULL, STANDARD_MODULE_PROPERTIES
|
|
};
|
|
|
|
#if COMPILE_DL
|
|
php3_module_entry *get_module() { return &bcmath_module_entry; };
|
|
#endif
|
|
|
|
#ifndef THREAD_SAFE
|
|
static long bc_precision;
|
|
#endif
|
|
|
|
int php3_rinit_bcmath(INIT_FUNC_ARGS)
|
|
{
|
|
init_numbers();
|
|
if (cfg_get_long("bcmath.scale",&bc_precision)==FAILURE) {
|
|
bc_precision=0;
|
|
}
|
|
return SUCCESS;
|
|
}
|
|
|
|
int php3_rend_bcmath(SHUTDOWN_FUNC_ARGS)
|
|
{
|
|
destruct_numbers();
|
|
return SUCCESS;
|
|
}
|
|
|
|
/* {{{ proto string bcadd(string left_operand, string right_operand [, int scale])
|
|
Returns the sum of two arbitrary precision numbers */
|
|
PHP_FUNCTION(bcmath_add)
|
|
{
|
|
pval *left, *right,*scale_param;
|
|
bc_num first, second, result;
|
|
int scale=bc_precision;
|
|
|
|
switch (ARG_COUNT(ht)) {
|
|
case 2:
|
|
if (getParameters(ht, 2, &left, &right) == FAILURE) {
|
|
WRONG_PARAM_COUNT;
|
|
}
|
|
break;
|
|
case 3:
|
|
if (getParameters(ht, 3, &left, &right, &scale_param) == FAILURE) {
|
|
WRONG_PARAM_COUNT;
|
|
}
|
|
convert_to_long(scale_param);
|
|
scale = (int) scale_param->value.lval;
|
|
break;
|
|
default:
|
|
WRONG_PARAM_COUNT;
|
|
break;
|
|
}
|
|
convert_to_string(left);
|
|
convert_to_string(right);
|
|
init_num(&first);
|
|
init_num(&second);
|
|
init_num(&result);
|
|
str2num(&first,left->value.str.val,scale);
|
|
str2num(&second,right->value.str.val,scale);
|
|
bc_add (first,second,&result, scale);
|
|
return_value->value.str.val = num2str(result);
|
|
return_value->value.str.len = strlen(return_value->value.str.val);
|
|
return_value->type = IS_STRING;
|
|
free_num(&first);
|
|
free_num(&second);
|
|
free_num(&result);
|
|
return;
|
|
}
|
|
/* }}} */
|
|
|
|
/* {{{ proto string bcsub(string left_operand, string right_operand [, int scale])
|
|
Returns the difference between two arbitrary precision numbers (subtration) */
|
|
PHP_FUNCTION(bcmath_sub)
|
|
{
|
|
pval *left, *right,*scale_param;
|
|
bc_num first, second, result;
|
|
int scale=bc_precision;
|
|
|
|
switch (ARG_COUNT(ht)) {
|
|
case 2:
|
|
if (getParameters(ht, 2, &left, &right) == FAILURE) {
|
|
WRONG_PARAM_COUNT;
|
|
}
|
|
break;
|
|
case 3:
|
|
if (getParameters(ht, 3, &left, &right, &scale_param) == FAILURE) {
|
|
WRONG_PARAM_COUNT;
|
|
}
|
|
convert_to_long(scale_param);
|
|
scale = (int) scale_param->value.lval;
|
|
break;
|
|
default:
|
|
WRONG_PARAM_COUNT;
|
|
break;
|
|
}
|
|
convert_to_string(left);
|
|
convert_to_string(right);
|
|
init_num(&first);
|
|
init_num(&second);
|
|
init_num(&result);
|
|
str2num(&first,left->value.str.val,scale);
|
|
str2num(&second,right->value.str.val,scale);
|
|
bc_sub (first,second,&result, scale);
|
|
return_value->value.str.val = num2str(result);
|
|
return_value->value.str.len = strlen(return_value->value.str.val);
|
|
return_value->type = IS_STRING;
|
|
free_num(&first);
|
|
free_num(&second);
|
|
free_num(&result);
|
|
return;
|
|
}
|
|
/* }}} */
|
|
|
|
/* {{{ proto string bcmul(string left_operand, string right_operand [, int scale])
|
|
Returns the multiplication of two arbitrary precision numbers */
|
|
PHP_FUNCTION(bcmath_mul)
|
|
{
|
|
pval *left, *right,*scale_param;
|
|
bc_num first, second, result;
|
|
int scale=bc_precision;
|
|
|
|
switch (ARG_COUNT(ht)) {
|
|
case 2:
|
|
if (getParameters(ht, 2, &left, &right) == FAILURE) {
|
|
WRONG_PARAM_COUNT;
|
|
}
|
|
break;
|
|
case 3:
|
|
if (getParameters(ht, 3, &left, &right, &scale_param) == FAILURE) {
|
|
WRONG_PARAM_COUNT;
|
|
}
|
|
convert_to_long(scale_param);
|
|
scale = (int) scale_param->value.lval;
|
|
break;
|
|
default:
|
|
WRONG_PARAM_COUNT;
|
|
break;
|
|
}
|
|
convert_to_string(left);
|
|
convert_to_string(right);
|
|
init_num(&first);
|
|
init_num(&second);
|
|
init_num(&result);
|
|
str2num(&first,left->value.str.val,scale);
|
|
str2num(&second,right->value.str.val,scale);
|
|
bc_multiply (first,second,&result, scale);
|
|
return_value->value.str.val = num2str(result);
|
|
return_value->value.str.len = strlen(return_value->value.str.val);
|
|
return_value->type = IS_STRING;
|
|
free_num(&first);
|
|
free_num(&second);
|
|
free_num(&result);
|
|
return;
|
|
}
|
|
/* }}} */
|
|
|
|
/* {{{ proto string bcdiv(string left_operand, string right_operand [, int scale])
|
|
Returns the quotient of two arbitrary precision numbers (division) */
|
|
PHP_FUNCTION(bcmath_div)
|
|
{
|
|
pval *left, *right,*scale_param;
|
|
bc_num first, second, result;
|
|
int scale=bc_precision;
|
|
|
|
switch (ARG_COUNT(ht)) {
|
|
case 2:
|
|
if (getParameters(ht, 2, &left, &right) == FAILURE) {
|
|
WRONG_PARAM_COUNT;
|
|
}
|
|
break;
|
|
case 3:
|
|
if (getParameters(ht, 3, &left, &right, &scale_param) == FAILURE) {
|
|
WRONG_PARAM_COUNT;
|
|
}
|
|
convert_to_long(scale_param);
|
|
scale = (int) scale_param->value.lval;
|
|
break;
|
|
default:
|
|
WRONG_PARAM_COUNT;
|
|
break;
|
|
}
|
|
convert_to_string(left);
|
|
convert_to_string(right);
|
|
init_num(&first);
|
|
init_num(&second);
|
|
init_num(&result);
|
|
str2num(&first,left->value.str.val,scale);
|
|
str2num(&second,right->value.str.val,scale);
|
|
switch (bc_divide (first,second,&result, scale)) {
|
|
case 0: /* OK */
|
|
return_value->value.str.val = num2str(result);
|
|
return_value->value.str.len = strlen(return_value->value.str.val);
|
|
return_value->type = IS_STRING;
|
|
break;
|
|
case -1: /* division by zero */
|
|
php3_error(E_WARNING,"Division by zero");
|
|
break;
|
|
}
|
|
free_num(&first);
|
|
free_num(&second);
|
|
free_num(&result);
|
|
return;
|
|
}
|
|
/* }}} */
|
|
|
|
/* {{{ proto string bcmod(string left_operand, string right_operand)
|
|
Returns the modulus of the two arbitrary precision operands */
|
|
PHP_FUNCTION(bcmath_mod)
|
|
{
|
|
pval *left, *right;
|
|
bc_num first, second, result;
|
|
|
|
switch (ARG_COUNT(ht)) {
|
|
case 2:
|
|
if (getParameters(ht, 2, &left, &right) == FAILURE) {
|
|
WRONG_PARAM_COUNT;
|
|
}
|
|
break;
|
|
default:
|
|
WRONG_PARAM_COUNT;
|
|
break;
|
|
}
|
|
convert_to_string(left);
|
|
convert_to_string(right);
|
|
init_num(&first);
|
|
init_num(&second);
|
|
init_num(&result);
|
|
str2num(&first,left->value.str.val,0);
|
|
str2num(&second,right->value.str.val,0);
|
|
switch (bc_modulo(first,second,&result, 0)) {
|
|
case 0:
|
|
return_value->value.str.val = num2str(result);
|
|
return_value->value.str.len = strlen(return_value->value.str.val);
|
|
return_value->type = IS_STRING;
|
|
break;
|
|
case -1:
|
|
php3_error(E_WARNING,"Division by zero");
|
|
break;
|
|
}
|
|
free_num(&first);
|
|
free_num(&second);
|
|
free_num(&result);
|
|
return;
|
|
}
|
|
/* }}} */
|
|
|
|
/* {{{ proto string bcpow(string x, string y [, int scale])
|
|
Returns the value of an arbitrary precision number raised to the power of another */
|
|
PHP_FUNCTION(bcmath_pow)
|
|
{
|
|
pval *left, *right,*scale_param;
|
|
bc_num first, second, result;
|
|
int scale=bc_precision;
|
|
|
|
switch (ARG_COUNT(ht)) {
|
|
case 2:
|
|
if (getParameters(ht, 2, &left, &right) == FAILURE) {
|
|
WRONG_PARAM_COUNT;
|
|
}
|
|
break;
|
|
case 3:
|
|
if (getParameters(ht, 3, &left, &right, &scale_param) == FAILURE) {
|
|
WRONG_PARAM_COUNT;
|
|
}
|
|
convert_to_long(scale_param);
|
|
scale = (int) scale_param->value.lval;
|
|
break;
|
|
default:
|
|
WRONG_PARAM_COUNT;
|
|
break;
|
|
}
|
|
convert_to_string(left);
|
|
convert_to_string(right);
|
|
init_num(&first);
|
|
init_num(&second);
|
|
init_num(&result);
|
|
str2num(&first,left->value.str.val,scale);
|
|
str2num(&second,right->value.str.val,scale);
|
|
bc_raise (first,second,&result, scale);
|
|
return_value->value.str.val = num2str(result);
|
|
return_value->value.str.len = strlen(return_value->value.str.val);
|
|
return_value->type = IS_STRING;
|
|
free_num(&first);
|
|
free_num(&second);
|
|
free_num(&result);
|
|
return;
|
|
}
|
|
/* }}} */
|
|
|
|
/* {{{ proto string bcsqrt(string operand [, int scale])
|
|
Returns the square root of an arbitray precision number */
|
|
PHP_FUNCTION(bcmath_sqrt)
|
|
{
|
|
pval *left,*scale_param;
|
|
bc_num result;
|
|
int scale=bc_precision;
|
|
|
|
switch (ARG_COUNT(ht)) {
|
|
case 1:
|
|
if (getParameters(ht, 1, &left) == FAILURE) {
|
|
WRONG_PARAM_COUNT;
|
|
}
|
|
break;
|
|
case 2:
|
|
if (getParameters(ht, 2, &left, &scale_param) == FAILURE) {
|
|
WRONG_PARAM_COUNT;
|
|
}
|
|
convert_to_long(scale_param);
|
|
scale = (int) scale_param->value.lval;
|
|
break;
|
|
default:
|
|
WRONG_PARAM_COUNT;
|
|
break;
|
|
}
|
|
convert_to_string(left);
|
|
init_num(&result);
|
|
str2num(&result,left->value.str.val,scale);
|
|
if (bc_sqrt (&result, scale) != 0) {
|
|
return_value->value.str.val = num2str(result);
|
|
return_value->value.str.len = strlen(return_value->value.str.val);
|
|
return_value->type = IS_STRING;
|
|
} else {
|
|
php3_error(E_WARNING,"Square root of negative number");
|
|
}
|
|
free_num(&result);
|
|
return;
|
|
}
|
|
/* }}} */
|
|
|
|
/* {{{ proto string bccomp(string left_operand, string right_operand [, int scale])
|
|
Compares two arbitrary precision numbers */
|
|
PHP_FUNCTION(bcmath_comp)
|
|
{
|
|
pval *left, *right, *scale_param;
|
|
bc_num first, second;
|
|
int scale=bc_precision;
|
|
|
|
switch (ARG_COUNT(ht)) {
|
|
case 2:
|
|
if (getParameters(ht, 2, &left, &right) == FAILURE) {
|
|
WRONG_PARAM_COUNT;
|
|
}
|
|
break;
|
|
case 3:
|
|
if (getParameters(ht, 3, &left, &right, &scale_param) == FAILURE) {
|
|
WRONG_PARAM_COUNT;
|
|
}
|
|
convert_to_long(scale_param);
|
|
scale = (int) scale_param->value.lval;
|
|
break;
|
|
default:
|
|
WRONG_PARAM_COUNT;
|
|
break;
|
|
}
|
|
|
|
convert_to_string(left);
|
|
convert_to_string(right);
|
|
init_num(&first);
|
|
init_num(&second);
|
|
|
|
str2num(&first,left->value.str.val,scale);
|
|
str2num(&second,right->value.str.val,scale);
|
|
return_value->value.lval = bc_compare(first,second);
|
|
return_value->type = IS_LONG;
|
|
|
|
free_num(&first);
|
|
free_num(&second);
|
|
return;
|
|
}
|
|
/* }}} */
|
|
|
|
/* {{{ proto string bcscale(int scale)
|
|
Sets default scale parameter for all bc math functions */
|
|
PHP_FUNCTION(bcmath_set_scale)
|
|
{
|
|
pval *new_scale;
|
|
|
|
if (ARG_COUNT(ht)!=1 || getParameters(ht, 1, &new_scale)==FAILURE) {
|
|
WRONG_PARAM_COUNT;
|
|
}
|
|
|
|
convert_to_long(new_scale);
|
|
bc_precision = new_scale->value.lval;
|
|
RETURN_TRUE;
|
|
}
|
|
/* }}} */
|
|
|
|
|
|
#endif
|
|
|
|
/*
|
|
* Local variables:
|
|
* tab-width: 4
|
|
* c-basic-offset: 4
|
|
* End:
|
|
*/
|