diff options
Diffstat (limited to 'ext/bcmath/bcmath.c')
| -rw-r--r-- | ext/bcmath/bcmath.c | 579 |
1 files changed, 579 insertions, 0 deletions
diff --git a/ext/bcmath/bcmath.c b/ext/bcmath/bcmath.c new file mode 100644 index 0000000..c5fbce9 --- /dev/null +++ b/ext/bcmath/bcmath.c @@ -0,0 +1,579 @@ +/* + +----------------------------------------------------------------------+ + | PHP Version 5 | + +----------------------------------------------------------------------+ + | Copyright (c) 1997-2013 The PHP Group | + +----------------------------------------------------------------------+ + | This source file is subject to version 3.01 of the PHP license, | + | that is bundled with this package in the file LICENSE, and is | + | available through the world-wide-web at the following url: | + | http://www.php.net/license/3_01.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. | + +----------------------------------------------------------------------+ + | Author: Andi Gutmans <andi@zend.com> | + +----------------------------------------------------------------------+ +*/ + +/* $Id$ */ + +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +#include "php.h" + +#if HAVE_BCMATH + +#include "php_ini.h" +#include "ext/standard/info.h" +#include "php_bcmath.h" +#include "libbcmath/src/bcmath.h" + +ZEND_DECLARE_MODULE_GLOBALS(bcmath) +static PHP_GINIT_FUNCTION(bcmath); +static PHP_GSHUTDOWN_FUNCTION(bcmath); + +/* {{{ arginfo */ +ZEND_BEGIN_ARG_INFO_EX(arginfo_bcadd, 0, 0, 2) + ZEND_ARG_INFO(0, left_operand) + ZEND_ARG_INFO(0, right_operand) + ZEND_ARG_INFO(0, scale) +ZEND_END_ARG_INFO() + +ZEND_BEGIN_ARG_INFO_EX(arginfo_bcsub, 0, 0, 2) + ZEND_ARG_INFO(0, left_operand) + ZEND_ARG_INFO(0, right_operand) + ZEND_ARG_INFO(0, scale) +ZEND_END_ARG_INFO() + +ZEND_BEGIN_ARG_INFO_EX(arginfo_bcmul, 0, 0, 2) + ZEND_ARG_INFO(0, left_operand) + ZEND_ARG_INFO(0, right_operand) + ZEND_ARG_INFO(0, scale) +ZEND_END_ARG_INFO() + +ZEND_BEGIN_ARG_INFO_EX(arginfo_bcdiv, 0, 0, 2) + ZEND_ARG_INFO(0, left_operand) + ZEND_ARG_INFO(0, right_operand) + ZEND_ARG_INFO(0, scale) +ZEND_END_ARG_INFO() + +ZEND_BEGIN_ARG_INFO(arginfo_bcmod, 0) + ZEND_ARG_INFO(0, left_operand) + ZEND_ARG_INFO(0, right_operand) +ZEND_END_ARG_INFO() + +ZEND_BEGIN_ARG_INFO_EX(arginfo_bcpowmod, 0, 0, 3) + ZEND_ARG_INFO(0, x) + ZEND_ARG_INFO(0, y) + ZEND_ARG_INFO(0, mod) + ZEND_ARG_INFO(0, scale) +ZEND_END_ARG_INFO() + +ZEND_BEGIN_ARG_INFO_EX(arginfo_bcpow, 0, 0, 2) + ZEND_ARG_INFO(0, x) + ZEND_ARG_INFO(0, y) + ZEND_ARG_INFO(0, scale) +ZEND_END_ARG_INFO() + +ZEND_BEGIN_ARG_INFO_EX(arginfo_bcsqrt, 0, 0, 1) + ZEND_ARG_INFO(0, operand) + ZEND_ARG_INFO(0, scale) +ZEND_END_ARG_INFO() + +ZEND_BEGIN_ARG_INFO_EX(arginfo_bccomp, 0, 0, 2) + ZEND_ARG_INFO(0, left_operand) + ZEND_ARG_INFO(0, right_operand) + ZEND_ARG_INFO(0, scale) +ZEND_END_ARG_INFO() + +ZEND_BEGIN_ARG_INFO(arginfo_bcscale, 0) + ZEND_ARG_INFO(0, scale) +ZEND_END_ARG_INFO() + +/* }}} */ + +const zend_function_entry bcmath_functions[] = { + PHP_FE(bcadd, arginfo_bcadd) + PHP_FE(bcsub, arginfo_bcsub) + PHP_FE(bcmul, arginfo_bcmul) + PHP_FE(bcdiv, arginfo_bcdiv) + PHP_FE(bcmod, arginfo_bcmod) + PHP_FE(bcpow, arginfo_bcpow) + PHP_FE(bcsqrt, arginfo_bcsqrt) + PHP_FE(bcscale, arginfo_bcscale) + PHP_FE(bccomp, arginfo_bccomp) + PHP_FE(bcpowmod, arginfo_bcpowmod) + PHP_FE_END +}; + +zend_module_entry bcmath_module_entry = { + STANDARD_MODULE_HEADER, + "bcmath", + bcmath_functions, + PHP_MINIT(bcmath), + PHP_MSHUTDOWN(bcmath), + NULL, + NULL, + PHP_MINFO(bcmath), + NO_VERSION_YET, + PHP_MODULE_GLOBALS(bcmath), + PHP_GINIT(bcmath), + PHP_GSHUTDOWN(bcmath), + NULL, + STANDARD_MODULE_PROPERTIES_EX +}; + +#ifdef COMPILE_DL_BCMATH +ZEND_GET_MODULE(bcmath) +#endif + +/* {{{ PHP_INI */ +PHP_INI_BEGIN() + STD_PHP_INI_ENTRY("bcmath.scale", "0", PHP_INI_ALL, OnUpdateLongGEZero, bc_precision, zend_bcmath_globals, bcmath_globals) +PHP_INI_END() +/* }}} */ + +/* {{{ PHP_GINIT_FUNCTION + */ +static PHP_GINIT_FUNCTION(bcmath) +{ + bcmath_globals->bc_precision = 0; + bc_init_numbers(TSRMLS_C); +} +/* }}} */ + +/* {{{ PHP_GSHUTDOWN_FUNCTION + */ +static PHP_GSHUTDOWN_FUNCTION(bcmath) +{ + _bc_free_num_ex(&bcmath_globals->_zero_, 1); + _bc_free_num_ex(&bcmath_globals->_one_, 1); + _bc_free_num_ex(&bcmath_globals->_two_, 1); +} +/* }}} */ + +/* {{{ PHP_MINIT_FUNCTION + */ +PHP_MINIT_FUNCTION(bcmath) +{ + REGISTER_INI_ENTRIES(); + + return SUCCESS; +} +/* }}} */ + +/* {{{ PHP_MSHUTDOWN_FUNCTION + */ +PHP_MSHUTDOWN_FUNCTION(bcmath) +{ + UNREGISTER_INI_ENTRIES(); + + return SUCCESS; +} +/* }}} */ + +/* {{{ PHP_MINFO_FUNCTION + */ +PHP_MINFO_FUNCTION(bcmath) +{ + php_info_print_table_start(); + php_info_print_table_row(2, "BCMath support", "enabled"); + php_info_print_table_end(); + DISPLAY_INI_ENTRIES(); +} +/* }}} */ + +/* {{{ php_str2num + Convert to bc_num detecting scale */ +static void php_str2num(bc_num *num, char *str TSRMLS_DC) +{ + char *p; + + if (!(p = strchr(str, '.'))) { + bc_str2num(num, str, 0 TSRMLS_CC); + return; + } + + bc_str2num(num, str, strlen(p+1) TSRMLS_CC); +} +/* }}} */ + +/* {{{ proto string bcadd(string left_operand, string right_operand [, int scale]) + Returns the sum of two arbitrary precision numbers */ +PHP_FUNCTION(bcadd) +{ + char *left, *right; + long scale_param = 0; + bc_num first, second, result; + int left_len, right_len; + int scale = BCG(bc_precision), argc = ZEND_NUM_ARGS(); + + if (zend_parse_parameters(argc TSRMLS_CC, "ss|l", &left, &left_len, &right, &right_len, &scale_param) == FAILURE) { + return; + } + + if (argc == 3) { + scale = (int) ((int)scale_param < 0) ? 0 : scale_param; + } + + bc_init_num(&first TSRMLS_CC); + bc_init_num(&second TSRMLS_CC); + bc_init_num(&result TSRMLS_CC); + php_str2num(&first, left TSRMLS_CC); + php_str2num(&second, right TSRMLS_CC); + bc_add (first, second, &result, scale); + + if (result->n_scale > scale) { + result->n_scale = scale; + } + + 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; + bc_free_num(&first); + bc_free_num(&second); + bc_free_num(&result); + return; +} +/* }}} */ + +/* {{{ proto string bcsub(string left_operand, string right_operand [, int scale]) + Returns the difference between two arbitrary precision numbers */ +PHP_FUNCTION(bcsub) +{ + char *left, *right; + int left_len, right_len; + long scale_param = 0; + bc_num first, second, result; + int scale = BCG(bc_precision), argc = ZEND_NUM_ARGS(); + + if (zend_parse_parameters(argc TSRMLS_CC, "ss|l", &left, &left_len, &right, &right_len, &scale_param) == FAILURE) { + return; + } + + if (argc == 3) { + scale = (int) ((int)scale_param < 0) ? 0 : scale_param; + } + + bc_init_num(&first TSRMLS_CC); + bc_init_num(&second TSRMLS_CC); + bc_init_num(&result TSRMLS_CC); + php_str2num(&first, left TSRMLS_CC); + php_str2num(&second, right TSRMLS_CC); + bc_sub (first, second, &result, scale); + + if (result->n_scale > scale) { + result->n_scale = scale; + } + + 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; + bc_free_num(&first); + bc_free_num(&second); + bc_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(bcmul) +{ + char *left, *right; + int left_len, right_len; + long scale_param = 0; + bc_num first, second, result; + int scale = BCG(bc_precision), argc = ZEND_NUM_ARGS(); + + if (zend_parse_parameters(argc TSRMLS_CC, "ss|l", &left, &left_len, &right, &right_len, &scale_param) == FAILURE) { + return; + } + + if (argc == 3) { + scale = (int) ((int)scale_param < 0) ? 0 : scale_param; + } + + bc_init_num(&first TSRMLS_CC); + bc_init_num(&second TSRMLS_CC); + bc_init_num(&result TSRMLS_CC); + php_str2num(&first, left TSRMLS_CC); + php_str2num(&second, right TSRMLS_CC); + bc_multiply (first, second, &result, scale TSRMLS_CC); + + if (result->n_scale > scale) { + result->n_scale = scale; + } + + 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; + bc_free_num(&first); + bc_free_num(&second); + bc_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(bcdiv) +{ + char *left, *right; + int left_len, right_len; + long scale_param = 0; + bc_num first, second, result; + int scale = BCG(bc_precision), argc = ZEND_NUM_ARGS(); + + if (zend_parse_parameters(argc TSRMLS_CC, "ss|l", &left, &left_len, &right, &right_len, &scale_param) == FAILURE) { + return; + } + + if (argc == 3) { + scale = (int) ((int)scale_param < 0) ? 0 : scale_param; + } + + bc_init_num(&first TSRMLS_CC); + bc_init_num(&second TSRMLS_CC); + bc_init_num(&result TSRMLS_CC); + php_str2num(&first, left TSRMLS_CC); + php_str2num(&second, right TSRMLS_CC); + + switch (bc_divide(first, second, &result, scale TSRMLS_CC)) { + case 0: /* OK */ + if (result->n_scale > scale) { + result->n_scale = scale; + } + 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; + break; + case -1: /* division by zero */ + php_error_docref(NULL TSRMLS_CC, E_WARNING, "Division by zero"); + break; + } + + bc_free_num(&first); + bc_free_num(&second); + bc_free_num(&result); + return; +} +/* }}} */ + +/* {{{ proto string bcmod(string left_operand, string right_operand) + Returns the modulus of the two arbitrary precision operands */ +PHP_FUNCTION(bcmod) +{ + char *left, *right; + int left_len, right_len; + bc_num first, second, result; + + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ss", &left, &left_len, &right, &right_len) == FAILURE) { + return; + } + + bc_init_num(&first TSRMLS_CC); + bc_init_num(&second TSRMLS_CC); + bc_init_num(&result TSRMLS_CC); + bc_str2num(&first, left, 0 TSRMLS_CC); + bc_str2num(&second, 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)); + Z_TYPE_P(return_value) = IS_STRING; + break; + case -1: + php_error_docref(NULL TSRMLS_CC, E_WARNING, "Division by zero"); + break; + } + + bc_free_num(&first); + bc_free_num(&second); + bc_free_num(&result); + return; +} +/* }}} */ + +/* {{{ proto string bcpowmod(string x, string y, string mod [, int scale]) + Returns the value of an arbitrary precision number raised to the power of another reduced by a modulous */ +PHP_FUNCTION(bcpowmod) +{ + char *left, *right, *modulous; + int left_len, right_len, modulous_len; + bc_num first, second, mod, result; + long scale = BCG(bc_precision); + int scale_int; + + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sss|l", &left, &left_len, &right, &right_len, &modulous, &modulous_len, &scale) == FAILURE) { + return; + } + + bc_init_num(&first TSRMLS_CC); + bc_init_num(&second TSRMLS_CC); + bc_init_num(&mod TSRMLS_CC); + bc_init_num(&result TSRMLS_CC); + php_str2num(&first, left TSRMLS_CC); + php_str2num(&second, right TSRMLS_CC); + php_str2num(&mod, modulous TSRMLS_CC); + + scale_int = (int) ((int)scale < 0) ? 0 : scale; + + if (bc_raisemod(first, second, mod, &result, scale_int TSRMLS_CC) != -1) { + if (result->n_scale > scale) { + result->n_scale = scale; + } + 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; + } else { + RETVAL_FALSE; + } + + bc_free_num(&first); + bc_free_num(&second); + bc_free_num(&mod); + bc_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(bcpow) +{ + char *left, *right; + int left_len, right_len; + long scale_param = 0; + bc_num first, second, result; + int scale = BCG(bc_precision), argc = ZEND_NUM_ARGS(); + + if (zend_parse_parameters(argc TSRMLS_CC, "ss|l", &left, &left_len, &right, &right_len, &scale_param) == FAILURE) { + return; + } + + if (argc == 3) { + scale = (int) ((int)scale_param < 0) ? 0 : scale_param; + } + + bc_init_num(&first TSRMLS_CC); + bc_init_num(&second TSRMLS_CC); + bc_init_num(&result TSRMLS_CC); + php_str2num(&first, left TSRMLS_CC); + php_str2num(&second, right TSRMLS_CC); + bc_raise (first, second, &result, scale TSRMLS_CC); + + if (result->n_scale > scale) { + result->n_scale = scale; + } + + 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; + bc_free_num(&first); + bc_free_num(&second); + bc_free_num(&result); + return; +} +/* }}} */ + +/* {{{ proto string bcsqrt(string operand [, int scale]) + Returns the square root of an arbitray precision number */ +PHP_FUNCTION(bcsqrt) +{ + char *left; + int left_len; + long scale_param = 0; + bc_num result; + int scale = BCG(bc_precision), argc = ZEND_NUM_ARGS(); + + if (zend_parse_parameters(argc TSRMLS_CC, "s|l", &left, &left_len, &scale_param) == FAILURE) { + return; + } + + if (argc == 2) { + scale = (int) ((int)scale_param < 0) ? 0 : scale_param; + } + + bc_init_num(&result TSRMLS_CC); + php_str2num(&result, left TSRMLS_CC); + + if (bc_sqrt (&result, scale TSRMLS_CC) != 0) { + if (result->n_scale > scale) { + result->n_scale = scale; + } + 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; + } else { + php_error_docref(NULL TSRMLS_CC, E_WARNING, "Square root of negative number"); + } + + bc_free_num(&result); + return; +} +/* }}} */ + +/* {{{ proto int bccomp(string left_operand, string right_operand [, int scale]) + Compares two arbitrary precision numbers */ +PHP_FUNCTION(bccomp) +{ + char *left, *right; + int left_len, right_len; + long scale_param = 0; + bc_num first, second; + int scale = BCG(bc_precision), argc = ZEND_NUM_ARGS(); + + if (zend_parse_parameters(argc TSRMLS_CC, "ss|l", &left, &left_len, &right, &right_len, &scale_param) == FAILURE) { + return; + } + + if (argc == 3) { + scale = (int) ((int)scale_param < 0) ? 0 : scale_param; + } + + bc_init_num(&first TSRMLS_CC); + bc_init_num(&second TSRMLS_CC); + + bc_str2num(&first, left, scale TSRMLS_CC); + bc_str2num(&second, right, scale TSRMLS_CC); + Z_LVAL_P(return_value) = bc_compare(first, second); + Z_TYPE_P(return_value) = IS_LONG; + + bc_free_num(&first); + bc_free_num(&second); + return; +} +/* }}} */ + +/* {{{ proto bool bcscale(int scale) + Sets default scale parameter for all bc math functions */ +PHP_FUNCTION(bcscale) +{ + long new_scale; + + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &new_scale) == FAILURE) { + return; + } + + BCG(bc_precision) = ((int)new_scale < 0) ? 0 : new_scale; + + RETURN_TRUE; +} +/* }}} */ + + +#endif + +/* + * Local variables: + * tab-width: 4 + * c-basic-offset: 4 + * End: + * vim600: sw=4 ts=4 fdm=marker + * vim<600: sw=4 ts=4 + */ |