xref: /PHP-7.1/ext/bcmath/bcmath.c (revision ccd4716e)
1 /*
2    +----------------------------------------------------------------------+
3    | PHP Version 7                                                        |
4    +----------------------------------------------------------------------+
5    | Copyright (c) 1997-2018 The PHP Group                                |
6    +----------------------------------------------------------------------+
7    | This source file is subject to version 3.01 of the PHP license,      |
8    | that is bundled with this package in the file LICENSE, and is        |
9    | available through the world-wide-web at the following url:           |
10    | http://www.php.net/license/3_01.txt                                  |
11    | If you did not receive a copy of the PHP license and are unable to   |
12    | obtain it through the world-wide-web, please send a note to          |
13    | license@php.net so we can mail you a copy immediately.               |
14    +----------------------------------------------------------------------+
15    | Author: Andi Gutmans <andi@zend.com>                                 |
16    +----------------------------------------------------------------------+
17 */
18 
19 /* $Id$ */
20 
21 #ifdef HAVE_CONFIG_H
22 #include "config.h"
23 #endif
24 
25 #include "php.h"
26 
27 #if HAVE_BCMATH
28 
29 #include "php_ini.h"
30 #include "ext/standard/info.h"
31 #include "php_bcmath.h"
32 #include "libbcmath/src/bcmath.h"
33 
34 ZEND_DECLARE_MODULE_GLOBALS(bcmath)
35 static PHP_GINIT_FUNCTION(bcmath);
36 static PHP_GSHUTDOWN_FUNCTION(bcmath);
37 
38 /* {{{ arginfo */
39 ZEND_BEGIN_ARG_INFO_EX(arginfo_bcadd, 0, 0, 2)
40 	ZEND_ARG_INFO(0, left_operand)
41 	ZEND_ARG_INFO(0, right_operand)
42 	ZEND_ARG_INFO(0, scale)
43 ZEND_END_ARG_INFO()
44 
45 ZEND_BEGIN_ARG_INFO_EX(arginfo_bcsub, 0, 0, 2)
46 	ZEND_ARG_INFO(0, left_operand)
47 	ZEND_ARG_INFO(0, right_operand)
48 	ZEND_ARG_INFO(0, scale)
49 ZEND_END_ARG_INFO()
50 
51 ZEND_BEGIN_ARG_INFO_EX(arginfo_bcmul, 0, 0, 2)
52 	ZEND_ARG_INFO(0, left_operand)
53 	ZEND_ARG_INFO(0, right_operand)
54 	ZEND_ARG_INFO(0, scale)
55 ZEND_END_ARG_INFO()
56 
57 ZEND_BEGIN_ARG_INFO_EX(arginfo_bcdiv, 0, 0, 2)
58 	ZEND_ARG_INFO(0, left_operand)
59 	ZEND_ARG_INFO(0, right_operand)
60 	ZEND_ARG_INFO(0, scale)
61 ZEND_END_ARG_INFO()
62 
63 ZEND_BEGIN_ARG_INFO(arginfo_bcmod, 0)
64 	ZEND_ARG_INFO(0, left_operand)
65 	ZEND_ARG_INFO(0, right_operand)
66 ZEND_END_ARG_INFO()
67 
68 ZEND_BEGIN_ARG_INFO_EX(arginfo_bcpowmod, 0, 0, 3)
69 	ZEND_ARG_INFO(0, x)
70 	ZEND_ARG_INFO(0, y)
71 	ZEND_ARG_INFO(0, mod)
72 	ZEND_ARG_INFO(0, scale)
73 ZEND_END_ARG_INFO()
74 
75 ZEND_BEGIN_ARG_INFO_EX(arginfo_bcpow, 0, 0, 2)
76 	ZEND_ARG_INFO(0, x)
77 	ZEND_ARG_INFO(0, y)
78 	ZEND_ARG_INFO(0, scale)
79 ZEND_END_ARG_INFO()
80 
81 ZEND_BEGIN_ARG_INFO_EX(arginfo_bcsqrt, 0, 0, 1)
82 	ZEND_ARG_INFO(0, operand)
83 	ZEND_ARG_INFO(0, scale)
84 ZEND_END_ARG_INFO()
85 
86 ZEND_BEGIN_ARG_INFO_EX(arginfo_bccomp, 0, 0, 2)
87 	ZEND_ARG_INFO(0, left_operand)
88 	ZEND_ARG_INFO(0, right_operand)
89 	ZEND_ARG_INFO(0, scale)
90 ZEND_END_ARG_INFO()
91 
92 ZEND_BEGIN_ARG_INFO(arginfo_bcscale, 0)
93 	ZEND_ARG_INFO(0, scale)
94 ZEND_END_ARG_INFO()
95 
96 /* }}} */
97 
98 const zend_function_entry bcmath_functions[] = {
99 	PHP_FE(bcadd,									arginfo_bcadd)
100 	PHP_FE(bcsub,									arginfo_bcsub)
101 	PHP_FE(bcmul,									arginfo_bcmul)
102 	PHP_FE(bcdiv,									arginfo_bcdiv)
103 	PHP_FE(bcmod,									arginfo_bcmod)
104 	PHP_FE(bcpow,									arginfo_bcpow)
105 	PHP_FE(bcsqrt,									arginfo_bcsqrt)
106 	PHP_FE(bcscale,									arginfo_bcscale)
107 	PHP_FE(bccomp,									arginfo_bccomp)
108 	PHP_FE(bcpowmod,								arginfo_bcpowmod)
109 	PHP_FE_END
110 };
111 
112 zend_module_entry bcmath_module_entry = {
113 	STANDARD_MODULE_HEADER,
114 	"bcmath",
115 	bcmath_functions,
116 	PHP_MINIT(bcmath),
117 	PHP_MSHUTDOWN(bcmath),
118 	NULL,
119 	NULL,
120 	PHP_MINFO(bcmath),
121 	PHP_BCMATH_VERSION,
122 	PHP_MODULE_GLOBALS(bcmath),
123 	PHP_GINIT(bcmath),
124     PHP_GSHUTDOWN(bcmath),
125 	NULL,
126 	STANDARD_MODULE_PROPERTIES_EX
127 };
128 
129 #ifdef COMPILE_DL_BCMATH
130 #ifdef ZTS
131 ZEND_TSRMLS_CACHE_DEFINE()
132 #endif
ZEND_GET_MODULE(bcmath)133 ZEND_GET_MODULE(bcmath)
134 #endif
135 
136 /* {{{ PHP_INI */
137 PHP_INI_BEGIN()
138 	STD_PHP_INI_ENTRY("bcmath.scale", "0", PHP_INI_ALL, OnUpdateLongGEZero, bc_precision, zend_bcmath_globals, bcmath_globals)
139 PHP_INI_END()
140 /* }}} */
141 
142 /* {{{ PHP_GINIT_FUNCTION
143  */
144 static PHP_GINIT_FUNCTION(bcmath)
145 {
146 #if defined(COMPILE_DL_BCMATH) && defined(ZTS)
147 	ZEND_TSRMLS_CACHE_UPDATE();
148 #endif
149 	bcmath_globals->bc_precision = 0;
150 	bc_init_numbers();
151 }
152 /* }}} */
153 
154 /* {{{ PHP_GSHUTDOWN_FUNCTION
155  */
PHP_GSHUTDOWN_FUNCTION(bcmath)156 static PHP_GSHUTDOWN_FUNCTION(bcmath)
157 {
158 	_bc_free_num_ex(&bcmath_globals->_zero_, 1);
159 	_bc_free_num_ex(&bcmath_globals->_one_, 1);
160 	_bc_free_num_ex(&bcmath_globals->_two_, 1);
161 }
162 /* }}} */
163 
164 /* {{{ PHP_MINIT_FUNCTION
165  */
PHP_MINIT_FUNCTION(bcmath)166 PHP_MINIT_FUNCTION(bcmath)
167 {
168 	REGISTER_INI_ENTRIES();
169 
170 	return SUCCESS;
171 }
172 /* }}} */
173 
174 /* {{{ PHP_MSHUTDOWN_FUNCTION
175  */
PHP_MSHUTDOWN_FUNCTION(bcmath)176 PHP_MSHUTDOWN_FUNCTION(bcmath)
177 {
178 	UNREGISTER_INI_ENTRIES();
179 
180 	return SUCCESS;
181 }
182 /* }}} */
183 
184 /* {{{ PHP_MINFO_FUNCTION
185  */
PHP_MINFO_FUNCTION(bcmath)186 PHP_MINFO_FUNCTION(bcmath)
187 {
188 	php_info_print_table_start();
189 	php_info_print_table_row(2, "BCMath support", "enabled");
190 	php_info_print_table_end();
191 	DISPLAY_INI_ENTRIES();
192 }
193 /* }}} */
194 
195 /* {{{ php_str2num
196    Convert to bc_num detecting scale */
php_str2num(bc_num * num,char * str)197 static void php_str2num(bc_num *num, char *str)
198 {
199 	char *p;
200 
201 	if (!(p = strchr(str, '.'))) {
202 		bc_str2num(num, str, 0);
203 		return;
204 	}
205 
206 	bc_str2num(num, str, strlen(p+1));
207 }
208 /* }}} */
209 
210 /* {{{ split_bc_num
211    Convert to bc_num detecting scale */
split_bc_num(bc_num num)212 static bc_num split_bc_num(bc_num num) {
213 	bc_num newnum;
214 	if (num->n_refs >= 1) {
215 		return num;
216 	}
217 	newnum = _bc_new_num_ex(0, 0, 0);
218 	*newnum = *num;
219 	newnum->n_refs = 1;
220 	num->n_refs--;
221 	return newnum;
222 }
223 /* }}} */
224 
225 /* {{{ proto string bcadd(string left_operand, string right_operand [, int scale])
226    Returns the sum of two arbitrary precision numbers */
PHP_FUNCTION(bcadd)227 PHP_FUNCTION(bcadd)
228 {
229 	char *left, *right;
230 	zend_long scale_param = 0;
231 	bc_num first, second, result;
232 	size_t left_len, right_len;
233 	int scale = (int)BCG(bc_precision), argc = ZEND_NUM_ARGS();
234 
235 	if (zend_parse_parameters(argc, "ss|l", &left, &left_len, &right, &right_len, &scale_param) == FAILURE) {
236 		return;
237 	}
238 
239 	if (argc == 3) {
240 		scale = (int) (scale_param < 0 ? 0 : scale_param);
241 	}
242 
243 	bc_init_num(&first);
244 	bc_init_num(&second);
245 	bc_init_num(&result);
246 	php_str2num(&first, left);
247 	php_str2num(&second, right);
248 	bc_add (first, second, &result, scale);
249 
250 	if (result->n_scale > scale) {
251 		result = split_bc_num(result);
252 		result->n_scale = scale;
253 	}
254 
255 	RETVAL_STR(bc_num2str(result));
256 	bc_free_num(&first);
257 	bc_free_num(&second);
258 	bc_free_num(&result);
259 	return;
260 }
261 /* }}} */
262 
263 /* {{{ proto string bcsub(string left_operand, string right_operand [, int scale])
264    Returns the difference between two arbitrary precision numbers */
PHP_FUNCTION(bcsub)265 PHP_FUNCTION(bcsub)
266 {
267 	char *left, *right;
268 	size_t left_len, right_len;
269 	zend_long scale_param = 0;
270 	bc_num first, second, result;
271 	int scale = (int)BCG(bc_precision), argc = ZEND_NUM_ARGS();
272 
273 	if (zend_parse_parameters(argc, "ss|l", &left, &left_len, &right, &right_len, &scale_param) == FAILURE) {
274 		return;
275 	}
276 
277 	if (argc == 3) {
278 		scale = (int) ((int)scale_param < 0 ? 0 : scale_param);
279 	}
280 
281 	bc_init_num(&first);
282 	bc_init_num(&second);
283 	bc_init_num(&result);
284 	php_str2num(&first, left);
285 	php_str2num(&second, right);
286 	bc_sub (first, second, &result, scale);
287 
288 	if (result->n_scale > scale) {
289 		result = split_bc_num(result);
290 		result->n_scale = scale;
291 	}
292 
293 	RETVAL_STR(bc_num2str(result));
294 	bc_free_num(&first);
295 	bc_free_num(&second);
296 	bc_free_num(&result);
297 	return;
298 }
299 /* }}} */
300 
301 /* {{{ proto string bcmul(string left_operand, string right_operand [, int scale])
302    Returns the multiplication of two arbitrary precision numbers */
PHP_FUNCTION(bcmul)303 PHP_FUNCTION(bcmul)
304 {
305 	char *left, *right;
306 	size_t left_len, right_len;
307 	zend_long scale_param = 0;
308 	bc_num first, second, result;
309 	int scale = (int)BCG(bc_precision), argc = ZEND_NUM_ARGS();
310 
311 	if (zend_parse_parameters(argc, "ss|l", &left, &left_len, &right, &right_len, &scale_param) == FAILURE) {
312 		return;
313 	}
314 
315 	if (argc == 3) {
316 		scale = (int) ((int)scale_param < 0 ? 0 : scale_param);
317 	}
318 
319 	bc_init_num(&first);
320 	bc_init_num(&second);
321 	bc_init_num(&result);
322 	php_str2num(&first, left);
323 	php_str2num(&second, right);
324 	bc_multiply (first, second, &result, scale);
325 
326 	if (result->n_scale > scale) {
327 		result = split_bc_num(result);
328 		result->n_scale = scale;
329 	}
330 
331 	RETVAL_STR(bc_num2str(result));
332 	bc_free_num(&first);
333 	bc_free_num(&second);
334 	bc_free_num(&result);
335 	return;
336 }
337 /* }}} */
338 
339 /* {{{ proto string bcdiv(string left_operand, string right_operand [, int scale])
340    Returns the quotient of two arbitrary precision numbers (division) */
PHP_FUNCTION(bcdiv)341 PHP_FUNCTION(bcdiv)
342 {
343 	char *left, *right;
344 	size_t left_len, right_len;
345 	zend_long scale_param = 0;
346 	bc_num first, second, result;
347 	int scale = (int)BCG(bc_precision), argc = ZEND_NUM_ARGS();
348 
349 	if (zend_parse_parameters(argc, "ss|l", &left, &left_len, &right, &right_len, &scale_param) == FAILURE) {
350 		return;
351 	}
352 
353 	if (argc == 3) {
354 		scale = (int) ((int)scale_param < 0 ? 0 : scale_param);
355 	}
356 
357 	bc_init_num(&first);
358 	bc_init_num(&second);
359 	bc_init_num(&result);
360 	php_str2num(&first, left);
361 	php_str2num(&second, right);
362 
363 	switch (bc_divide(first, second, &result, scale)) {
364 		case 0: /* OK */
365 			if (result->n_scale > scale) {
366 				result = split_bc_num(result);
367 				result->n_scale = scale;
368 			}
369 			RETVAL_STR(bc_num2str(result));
370 			break;
371 		case -1: /* division by zero */
372 			php_error_docref(NULL, E_WARNING, "Division by zero");
373 			break;
374 	}
375 
376 	bc_free_num(&first);
377 	bc_free_num(&second);
378 	bc_free_num(&result);
379 	return;
380 }
381 /* }}} */
382 
383 /* {{{ proto string bcmod(string left_operand, string right_operand)
384    Returns the modulus of the two arbitrary precision operands */
PHP_FUNCTION(bcmod)385 PHP_FUNCTION(bcmod)
386 {
387 	char *left, *right;
388 	size_t left_len, right_len;
389 	bc_num first, second, result;
390 
391 	if (zend_parse_parameters(ZEND_NUM_ARGS(), "ss", &left, &left_len, &right, &right_len) == FAILURE) {
392 		return;
393 	}
394 
395 	bc_init_num(&first);
396 	bc_init_num(&second);
397 	bc_init_num(&result);
398 	bc_str2num(&first, left, 0);
399 	bc_str2num(&second, right, 0);
400 
401 	switch (bc_modulo(first, second, &result, 0)) {
402 		case 0:
403 			RETVAL_STR(bc_num2str(result));
404 			break;
405 		case -1:
406 			php_error_docref(NULL, E_WARNING, "Division by zero");
407 			break;
408 	}
409 
410 	bc_free_num(&first);
411 	bc_free_num(&second);
412 	bc_free_num(&result);
413 	return;
414 }
415 /* }}} */
416 
417 /* {{{ proto string bcpowmod(string x, string y, string mod [, int scale])
418    Returns the value of an arbitrary precision number raised to the power of another reduced by a modulous */
PHP_FUNCTION(bcpowmod)419 PHP_FUNCTION(bcpowmod)
420 {
421 	char *left, *right, *modulous;
422 	size_t left_len, right_len, modulous_len;
423 	bc_num first, second, mod, result;
424 	zend_long scale = BCG(bc_precision);
425 	int scale_int;
426 
427 	if (zend_parse_parameters(ZEND_NUM_ARGS(), "sss|l", &left, &left_len, &right, &right_len, &modulous, &modulous_len, &scale) == FAILURE) {
428 		return;
429 	}
430 
431 	bc_init_num(&first);
432 	bc_init_num(&second);
433 	bc_init_num(&mod);
434 	bc_init_num(&result);
435 	php_str2num(&first, left);
436 	php_str2num(&second, right);
437 	php_str2num(&mod, modulous);
438 
439 	scale_int = (int) ((int)scale < 0 ? 0 : scale);
440 
441 	if (bc_raisemod(first, second, mod, &result, scale_int) != -1) {
442 		if (result->n_scale > scale_int) {
443 			result = split_bc_num(result);
444 			result->n_scale = scale_int;
445 		}
446 		RETVAL_STR(bc_num2str(result));
447 	} else {
448 		RETVAL_FALSE;
449 	}
450 
451 	bc_free_num(&first);
452 	bc_free_num(&second);
453 	bc_free_num(&mod);
454 	bc_free_num(&result);
455 	return;
456 }
457 /* }}} */
458 
459 /* {{{ proto string bcpow(string x, string y [, int scale])
460    Returns the value of an arbitrary precision number raised to the power of another */
PHP_FUNCTION(bcpow)461 PHP_FUNCTION(bcpow)
462 {
463 	char *left, *right;
464 	size_t left_len, right_len;
465 	zend_long scale_param = 0;
466 	bc_num first, second, result;
467 	int scale = (int)BCG(bc_precision), argc = ZEND_NUM_ARGS();
468 
469 	if (zend_parse_parameters(argc, "ss|l", &left, &left_len, &right, &right_len, &scale_param) == FAILURE) {
470 		return;
471 	}
472 
473 	if (argc == 3) {
474 		scale = (int) ((int)scale_param < 0 ? 0 : scale_param);
475 	}
476 
477 	bc_init_num(&first);
478 	bc_init_num(&second);
479 	bc_init_num(&result);
480 	php_str2num(&first, left);
481 	php_str2num(&second, right);
482 	bc_raise (first, second, &result, scale);
483 
484 	if (result->n_scale > scale) {
485 		result = split_bc_num(result);
486 		result->n_scale = scale;
487 	}
488 
489 	RETVAL_STR(bc_num2str(result));
490 	bc_free_num(&first);
491 	bc_free_num(&second);
492 	bc_free_num(&result);
493 	return;
494 }
495 /* }}} */
496 
497 /* {{{ proto string bcsqrt(string operand [, int scale])
498    Returns the square root of an arbitray precision number */
PHP_FUNCTION(bcsqrt)499 PHP_FUNCTION(bcsqrt)
500 {
501 	char *left;
502 	size_t left_len;
503 	zend_long scale_param = 0;
504 	bc_num result;
505 	int scale = (int)BCG(bc_precision), argc = ZEND_NUM_ARGS();
506 
507 	if (zend_parse_parameters(argc, "s|l", &left, &left_len, &scale_param) == FAILURE) {
508 		return;
509 	}
510 
511 	if (argc == 2) {
512 		scale = (int) ((int)scale_param < 0 ? 0 : scale_param);
513 	}
514 
515 	bc_init_num(&result);
516 	php_str2num(&result, left);
517 
518 	if (bc_sqrt (&result, scale) != 0) {
519 		if (result->n_scale > scale) {
520 			result = split_bc_num(result);
521 			result->n_scale = scale;
522 		}
523 		RETVAL_STR(bc_num2str(result));
524 	} else {
525 		php_error_docref(NULL, E_WARNING, "Square root of negative number");
526 	}
527 
528 	bc_free_num(&result);
529 	return;
530 }
531 /* }}} */
532 
533 /* {{{ proto int bccomp(string left_operand, string right_operand [, int scale])
534    Compares two arbitrary precision numbers */
PHP_FUNCTION(bccomp)535 PHP_FUNCTION(bccomp)
536 {
537 	char *left, *right;
538 	size_t left_len, right_len;
539 	zend_long scale_param = 0;
540 	bc_num first, second;
541 	int scale = (int)BCG(bc_precision), argc = ZEND_NUM_ARGS();
542 
543 	if (zend_parse_parameters(argc, "ss|l", &left, &left_len, &right, &right_len, &scale_param) == FAILURE) {
544 		return;
545 	}
546 
547 	if (argc == 3) {
548 		scale = (int) ((int)scale_param < 0 ? 0 : scale_param);
549 	}
550 
551 	bc_init_num(&first);
552 	bc_init_num(&second);
553 
554 	bc_str2num(&first, left, scale);
555 	bc_str2num(&second, right, scale);
556 	RETVAL_LONG(bc_compare(first, second));
557 
558 	bc_free_num(&first);
559 	bc_free_num(&second);
560 	return;
561 }
562 /* }}} */
563 
564 /* {{{ proto bool bcscale(int scale)
565    Sets default scale parameter for all bc math functions */
PHP_FUNCTION(bcscale)566 PHP_FUNCTION(bcscale)
567 {
568 	zend_long new_scale;
569 
570 	if (zend_parse_parameters(ZEND_NUM_ARGS(), "l", &new_scale) == FAILURE) {
571 		return;
572 	}
573 
574 	BCG(bc_precision) = ((int)new_scale < 0) ? 0 : new_scale;
575 
576 	RETURN_TRUE;
577 }
578 /* }}} */
579 
580 
581 #endif
582 
583 /*
584  * Local variables:
585  * tab-width: 4
586  * c-basic-offset: 4
587  * End:
588  * vim600: sw=4 ts=4 fdm=marker
589  * vim<600: sw=4 ts=4
590  */
591