1 : /*
2 : +----------------------------------------------------------------------+
3 : | PHP Version 5 |
4 : +----------------------------------------------------------------------+
5 : | Copyright (c) 1997-2009 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: Stanislav Malyshev <stas@php.net> |
16 : +----------------------------------------------------------------------+
17 : */
18 :
19 : #ifdef HAVE_CONFIG_H
20 : #include "config.h"
21 : #endif
22 :
23 : #include "php.h"
24 : #include "php_ini.h"
25 : #include "php_gmp.h"
26 : #include "ext/standard/info.h"
27 :
28 : #if HAVE_GMP
29 :
30 : #include <gmp.h>
31 :
32 : /* Needed for gmp_random() */
33 : #include "ext/standard/php_rand.h"
34 : #include "ext/standard/php_lcg.h"
35 : #define GMP_ABS(x) ((x) >= 0 ? (x) : -(x))
36 :
37 : /* True global resources - no need for thread safety here */
38 : static int le_gmp;
39 :
40 : /* {{{ arginfo */
41 : static
42 : ZEND_BEGIN_ARG_INFO_EX(arginfo_gmp_init, 0, 0, 1)
43 : ZEND_ARG_INFO(0, number)
44 : ZEND_ARG_INFO(0, base)
45 : ZEND_END_ARG_INFO()
46 :
47 : static
48 : ZEND_BEGIN_ARG_INFO(arginfo_gmp_intval, 0)
49 : ZEND_ARG_INFO(0, gmpnumber)
50 : ZEND_END_ARG_INFO()
51 :
52 : static
53 : ZEND_BEGIN_ARG_INFO_EX(arginfo_gmp_strval, 0, 0, 1)
54 : ZEND_ARG_INFO(0, gmpnumber)
55 : ZEND_ARG_INFO(0, base)
56 : ZEND_END_ARG_INFO()
57 :
58 : static
59 : ZEND_BEGIN_ARG_INFO(arginfo_gmp_add, 0)
60 : ZEND_ARG_INFO(0, a)
61 : ZEND_ARG_INFO(0, b)
62 : ZEND_END_ARG_INFO()
63 :
64 : static
65 : ZEND_BEGIN_ARG_INFO(arginfo_gmp_sub, 0)
66 : ZEND_ARG_INFO(0, a)
67 : ZEND_ARG_INFO(0, b)
68 : ZEND_END_ARG_INFO()
69 :
70 : static
71 : ZEND_BEGIN_ARG_INFO(arginfo_gmp_mul, 0)
72 : ZEND_ARG_INFO(0, a)
73 : ZEND_ARG_INFO(0, b)
74 : ZEND_END_ARG_INFO()
75 :
76 : static
77 : ZEND_BEGIN_ARG_INFO_EX(arginfo_gmp_div_qr, 0, 0, 2)
78 : ZEND_ARG_INFO(0, a)
79 : ZEND_ARG_INFO(0, b)
80 : ZEND_ARG_INFO(0, round)
81 : ZEND_END_ARG_INFO()
82 :
83 : static
84 : ZEND_BEGIN_ARG_INFO_EX(arginfo_gmp_div_r, 0, 0, 2)
85 : ZEND_ARG_INFO(0, a)
86 : ZEND_ARG_INFO(0, b)
87 : ZEND_ARG_INFO(0, round)
88 : ZEND_END_ARG_INFO()
89 :
90 : static
91 : ZEND_BEGIN_ARG_INFO_EX(arginfo_gmp_div_q, 0, 0, 2)
92 : ZEND_ARG_INFO(0, a)
93 : ZEND_ARG_INFO(0, b)
94 : ZEND_ARG_INFO(0, round)
95 : ZEND_END_ARG_INFO()
96 :
97 : static
98 : ZEND_BEGIN_ARG_INFO(arginfo_gmp_mod, 0)
99 : ZEND_ARG_INFO(0, a)
100 : ZEND_ARG_INFO(0, b)
101 : ZEND_END_ARG_INFO()
102 :
103 : static
104 : ZEND_BEGIN_ARG_INFO(arginfo_gmp_divexact, 0)
105 : ZEND_ARG_INFO(0, a)
106 : ZEND_ARG_INFO(0, b)
107 : ZEND_END_ARG_INFO()
108 :
109 : static
110 : ZEND_BEGIN_ARG_INFO(arginfo_gmp_neg, 0)
111 : ZEND_ARG_INFO(0, a)
112 : ZEND_END_ARG_INFO()
113 :
114 : static
115 : ZEND_BEGIN_ARG_INFO(arginfo_gmp_abs, 0)
116 : ZEND_ARG_INFO(0, a)
117 : ZEND_END_ARG_INFO()
118 :
119 : static
120 : ZEND_BEGIN_ARG_INFO(arginfo_gmp_fact, 0)
121 : ZEND_ARG_INFO(0, a)
122 : ZEND_END_ARG_INFO()
123 :
124 : static
125 : ZEND_BEGIN_ARG_INFO(arginfo_gmp_pow, 0)
126 : ZEND_ARG_INFO(0, base)
127 : ZEND_ARG_INFO(0, exp)
128 : ZEND_END_ARG_INFO()
129 :
130 : static
131 : ZEND_BEGIN_ARG_INFO(arginfo_gmp_powm, 0)
132 : ZEND_ARG_INFO(0, base)
133 : ZEND_ARG_INFO(0, exp)
134 : ZEND_ARG_INFO(0, mod)
135 : ZEND_END_ARG_INFO()
136 :
137 : static
138 : ZEND_BEGIN_ARG_INFO(arginfo_gmp_sqrt, 0)
139 : ZEND_ARG_INFO(0, a)
140 : ZEND_END_ARG_INFO()
141 :
142 : static
143 : ZEND_BEGIN_ARG_INFO(arginfo_gmp_sqrtrem, 0)
144 : ZEND_ARG_INFO(0, a)
145 : ZEND_END_ARG_INFO()
146 :
147 : static
148 : ZEND_BEGIN_ARG_INFO(arginfo_gmp_perfect_square, 0)
149 : ZEND_ARG_INFO(0, a)
150 : ZEND_END_ARG_INFO()
151 :
152 : static
153 : ZEND_BEGIN_ARG_INFO_EX(arginfo_gmp_prob_prime, 0, 0, 1)
154 : ZEND_ARG_INFO(0, a)
155 : ZEND_ARG_INFO(0, reps)
156 : ZEND_END_ARG_INFO()
157 :
158 : static
159 : ZEND_BEGIN_ARG_INFO(arginfo_gmp_gcd, 0)
160 : ZEND_ARG_INFO(0, a)
161 : ZEND_ARG_INFO(0, b)
162 : ZEND_END_ARG_INFO()
163 :
164 : static
165 : ZEND_BEGIN_ARG_INFO(arginfo_gmp_gcdext, 0)
166 : ZEND_ARG_INFO(0, a)
167 : ZEND_ARG_INFO(0, b)
168 : ZEND_END_ARG_INFO()
169 :
170 : static
171 : ZEND_BEGIN_ARG_INFO(arginfo_gmp_invert, 0)
172 : ZEND_ARG_INFO(0, a)
173 : ZEND_ARG_INFO(0, b)
174 : ZEND_END_ARG_INFO()
175 :
176 : static
177 : ZEND_BEGIN_ARG_INFO(arginfo_gmp_jacobi, 0)
178 : ZEND_ARG_INFO(0, a)
179 : ZEND_ARG_INFO(0, b)
180 : ZEND_END_ARG_INFO()
181 :
182 : static
183 : ZEND_BEGIN_ARG_INFO(arginfo_gmp_legendre, 0)
184 : ZEND_ARG_INFO(0, a)
185 : ZEND_ARG_INFO(0, b)
186 : ZEND_END_ARG_INFO()
187 :
188 : static
189 : ZEND_BEGIN_ARG_INFO(arginfo_gmp_cmp, 0)
190 : ZEND_ARG_INFO(0, a)
191 : ZEND_ARG_INFO(0, b)
192 : ZEND_END_ARG_INFO()
193 :
194 : static
195 : ZEND_BEGIN_ARG_INFO(arginfo_gmp_sign, 0)
196 : ZEND_ARG_INFO(0, a)
197 : ZEND_END_ARG_INFO()
198 :
199 : static
200 : ZEND_BEGIN_ARG_INFO_EX(arginfo_gmp_random, 0, 0, 0)
201 : ZEND_ARG_INFO(0, limiter)
202 : ZEND_END_ARG_INFO()
203 :
204 : static
205 : ZEND_BEGIN_ARG_INFO(arginfo_gmp_and, 0)
206 : ZEND_ARG_INFO(0, a)
207 : ZEND_ARG_INFO(0, b)
208 : ZEND_END_ARG_INFO()
209 :
210 : static
211 : ZEND_BEGIN_ARG_INFO(arginfo_gmp_or, 0)
212 : ZEND_ARG_INFO(0, a)
213 : ZEND_ARG_INFO(0, b)
214 : ZEND_END_ARG_INFO()
215 :
216 : static
217 : ZEND_BEGIN_ARG_INFO(arginfo_gmp_com, 0)
218 : ZEND_ARG_INFO(0, a)
219 : ZEND_END_ARG_INFO()
220 :
221 : static
222 : ZEND_BEGIN_ARG_INFO(arginfo_gmp_xor, 0)
223 : ZEND_ARG_INFO(0, a)
224 : ZEND_ARG_INFO(0, b)
225 : ZEND_END_ARG_INFO()
226 :
227 : static
228 : ZEND_BEGIN_ARG_INFO_EX(arginfo_gmp_setbit, 0, 0, 2)
229 : ZEND_ARG_INFO(1, a)
230 : ZEND_ARG_INFO(0, index)
231 : ZEND_ARG_INFO(0, set_clear)
232 : ZEND_END_ARG_INFO()
233 :
234 : static
235 : ZEND_BEGIN_ARG_INFO(arginfo_gmp_clrbit, 0)
236 : ZEND_ARG_INFO(1, a)
237 : ZEND_ARG_INFO(0, index)
238 : ZEND_END_ARG_INFO()
239 :
240 : static
241 : ZEND_BEGIN_ARG_INFO(arginfo_gmp_popcount, 0)
242 : ZEND_ARG_INFO(0, a)
243 : ZEND_END_ARG_INFO()
244 :
245 : static
246 : ZEND_BEGIN_ARG_INFO(arginfo_gmp_hamdist, 0)
247 : ZEND_ARG_INFO(0, a)
248 : ZEND_ARG_INFO(0, b)
249 : ZEND_END_ARG_INFO()
250 :
251 : static
252 : ZEND_BEGIN_ARG_INFO(arginfo_gmp_scan0, 0)
253 : ZEND_ARG_INFO(0, a)
254 : ZEND_ARG_INFO(0, start)
255 : ZEND_END_ARG_INFO()
256 :
257 : static
258 : ZEND_BEGIN_ARG_INFO(arginfo_gmp_scan1, 0)
259 : ZEND_ARG_INFO(0, a)
260 : ZEND_ARG_INFO(0, start)
261 : ZEND_END_ARG_INFO()
262 :
263 : static
264 : ZEND_BEGIN_ARG_INFO(arginfo_gmp_nextprime, 0)
265 : ZEND_ARG_INFO(0, a)
266 : ZEND_END_ARG_INFO()
267 :
268 : /* }}} */
269 :
270 : ZEND_DECLARE_MODULE_GLOBALS(gmp)
271 : static ZEND_GINIT_FUNCTION(gmp);
272 :
273 : /* {{{ gmp_functions[]
274 : */
275 : zend_function_entry gmp_functions[] = {
276 : ZEND_FE(gmp_init, arginfo_gmp_init)
277 : ZEND_FE(gmp_intval, arginfo_gmp_intval)
278 : ZEND_FE(gmp_strval, arginfo_gmp_strval)
279 : ZEND_FE(gmp_add, arginfo_gmp_add)
280 : ZEND_FE(gmp_sub, arginfo_gmp_sub)
281 : ZEND_FE(gmp_mul, arginfo_gmp_mul)
282 : ZEND_FE(gmp_div_qr, arginfo_gmp_div_qr)
283 : ZEND_FE(gmp_div_q, arginfo_gmp_div_q)
284 : ZEND_FE(gmp_div_r, arginfo_gmp_div_r)
285 : ZEND_FALIAS(gmp_div, gmp_div_q, arginfo_gmp_div_q)
286 : ZEND_FE(gmp_mod, arginfo_gmp_mod)
287 : ZEND_FE(gmp_divexact, arginfo_gmp_divexact)
288 : ZEND_FE(gmp_neg, arginfo_gmp_neg)
289 : ZEND_FE(gmp_abs, arginfo_gmp_abs)
290 : ZEND_FE(gmp_fact, arginfo_gmp_fact)
291 : ZEND_FE(gmp_sqrt, arginfo_gmp_sqrt)
292 : ZEND_FE(gmp_sqrtrem, arginfo_gmp_sqrtrem)
293 : ZEND_FE(gmp_pow, arginfo_gmp_pow)
294 : ZEND_FE(gmp_powm, arginfo_gmp_powm)
295 : ZEND_FE(gmp_perfect_square, arginfo_gmp_perfect_square)
296 : ZEND_FE(gmp_prob_prime, arginfo_gmp_prob_prime)
297 : ZEND_FE(gmp_gcd, arginfo_gmp_gcd)
298 : ZEND_FE(gmp_gcdext, arginfo_gmp_gcdext)
299 : ZEND_FE(gmp_invert, arginfo_gmp_invert)
300 : ZEND_FE(gmp_jacobi, arginfo_gmp_jacobi)
301 : ZEND_FE(gmp_legendre, arginfo_gmp_legendre)
302 : ZEND_FE(gmp_cmp, arginfo_gmp_cmp)
303 : ZEND_FE(gmp_sign, arginfo_gmp_sign)
304 : ZEND_FE(gmp_random, arginfo_gmp_random)
305 : ZEND_FE(gmp_and, arginfo_gmp_and)
306 : ZEND_FE(gmp_or, arginfo_gmp_or)
307 : ZEND_FE(gmp_com, arginfo_gmp_com)
308 : ZEND_FE(gmp_xor, arginfo_gmp_xor)
309 : ZEND_FE(gmp_setbit, arginfo_gmp_setbit)
310 : ZEND_FE(gmp_clrbit, arginfo_gmp_clrbit)
311 : ZEND_FE(gmp_scan0, arginfo_gmp_scan0)
312 : ZEND_FE(gmp_scan1, arginfo_gmp_scan1)
313 : ZEND_FE(gmp_popcount, arginfo_gmp_popcount)
314 : ZEND_FE(gmp_hamdist, arginfo_gmp_hamdist)
315 : ZEND_FE(gmp_nextprime, arginfo_gmp_nextprime)
316 : {NULL, NULL, NULL} /* Must be the last line in gmp_functions[] */
317 : };
318 : /* }}} */
319 :
320 : /* {{{ gmp_module_entry
321 : */
322 : zend_module_entry gmp_module_entry = {
323 : STANDARD_MODULE_HEADER,
324 : "gmp",
325 : gmp_functions,
326 : ZEND_MODULE_STARTUP_N(gmp),
327 : NULL,
328 : NULL,
329 : ZEND_MODULE_DEACTIVATE_N(gmp),
330 : ZEND_MODULE_INFO_N(gmp),
331 : NO_VERSION_YET,
332 : ZEND_MODULE_GLOBALS(gmp),
333 : ZEND_GINIT(gmp),
334 : NULL,
335 : NULL,
336 : STANDARD_MODULE_PROPERTIES_EX
337 : };
338 : /* }}} */
339 :
340 : #ifdef COMPILE_DL_GMP
341 : ZEND_GET_MODULE(gmp)
342 : #endif
343 :
344 : static void _php_gmpnum_free(zend_rsrc_list_entry *rsrc TSRMLS_DC);
345 :
346 : #define GMP_RESOURCE_NAME "GMP integer"
347 :
348 : #define GMP_ROUND_ZERO 0
349 : #define GMP_ROUND_PLUSINF 1
350 : #define GMP_ROUND_MINUSINF 2
351 :
352 : /* {{{ gmp_emalloc
353 : */
354 : static void *gmp_emalloc(size_t size)
355 2754 : {
356 2754 : return emalloc(size);
357 : }
358 : /* }}} */
359 :
360 : /* {{{ gmp_erealloc
361 : */
362 : static void *gmp_erealloc(void *ptr, size_t old_size, size_t new_size)
363 1215 : {
364 1215 : return erealloc(ptr, new_size);
365 : }
366 : /* }}} */
367 :
368 : /* {{{ gmp_efree
369 : */
370 : static void gmp_efree(void *ptr, size_t size)
371 2754 : {
372 2754 : efree(ptr);
373 2754 : }
374 : /* }}} */
375 :
376 : /* {{{ ZEND_GINIT_FUNCTION
377 : */
378 : static ZEND_GINIT_FUNCTION(gmp)
379 13565 : {
380 13565 : gmp_globals->rand_initialized = 0;
381 13565 : }
382 : /* }}} */
383 :
384 : /* {{{ ZEND_MINIT_FUNCTION
385 : */
386 : ZEND_MODULE_STARTUP_D(gmp)
387 13565 : {
388 13565 : le_gmp = zend_register_list_destructors_ex(_php_gmpnum_free, NULL, GMP_RESOURCE_NAME, module_number);
389 13565 : REGISTER_LONG_CONSTANT("GMP_ROUND_ZERO", GMP_ROUND_ZERO, CONST_CS | CONST_PERSISTENT);
390 13565 : REGISTER_LONG_CONSTANT("GMP_ROUND_PLUSINF", GMP_ROUND_PLUSINF, CONST_CS | CONST_PERSISTENT);
391 13565 : REGISTER_LONG_CONSTANT("GMP_ROUND_MINUSINF", GMP_ROUND_MINUSINF, CONST_CS | CONST_PERSISTENT);
392 13565 : REGISTER_STRING_CONSTANT("GMP_VERSION", (char *)gmp_version, CONST_CS | CONST_PERSISTENT);
393 :
394 13565 : mp_set_memory_functions(gmp_emalloc, gmp_erealloc, gmp_efree);
395 :
396 13565 : return SUCCESS;
397 : }
398 : /* }}} */
399 :
400 : /* {{{ ZEND_RSHUTDOWN_FUNCTION
401 : */
402 : ZEND_MODULE_DEACTIVATE_D(gmp)
403 13584 : {
404 13584 : if (GMPG(rand_initialized)) {
405 1 : gmp_randclear(GMPG(rand_state));
406 1 : GMPG(rand_initialized) = 0;
407 : }
408 :
409 13584 : return SUCCESS;
410 : }
411 : /* }}} */
412 :
413 : /* {{{ ZEND_MINFO_FUNCTION
414 : */
415 : ZEND_MODULE_INFO_D(gmp)
416 6 : {
417 6 : php_info_print_table_start();
418 6 : php_info_print_table_row(2, "gmp support", "enabled");
419 6 : php_info_print_table_row(2, "GMP version", gmp_version);
420 6 : php_info_print_table_end();
421 6 : }
422 : /* }}} */
423 :
424 : /* Fetch zval to be GMP number.
425 : Initially, zval can be also number or string */
426 : #define FETCH_GMP_ZVAL(gmpnumber, zval) \
427 : if (Z_TYPE_PP(zval) == IS_RESOURCE) { \
428 : ZEND_FETCH_RESOURCE(gmpnumber, mpz_t *, zval, -1, GMP_RESOURCE_NAME, le_gmp);\
429 : } else {\
430 : if (convert_to_gmp(&gmpnumber, zval, 0 TSRMLS_CC) == FAILURE) {\
431 : RETURN_FALSE;\
432 : }\
433 : ZEND_REGISTER_RESOURCE(NULL, gmpnumber, le_gmp);\
434 : }
435 :
436 : /* create a new initialized GMP number */
437 : #define INIT_GMP_NUM(gmpnumber) { gmpnumber=emalloc(sizeof(mpz_t)); mpz_init(*gmpnumber); }
438 : #define FREE_GMP_NUM(gmpnumber) { mpz_clear(*gmpnumber); efree(gmpnumber); }
439 :
440 : /* {{{ convert_to_gmp
441 : * Convert zval to be gmp number */
442 : static int convert_to_gmp(mpz_t * *gmpnumber, zval **val, int base TSRMLS_DC)
443 1569 : {
444 1569 : int ret = 0;
445 1569 : int skip_lead = 0;
446 :
447 1569 : *gmpnumber = emalloc(sizeof(mpz_t));
448 :
449 1569 : switch (Z_TYPE_PP(val)) {
450 : case IS_LONG:
451 : case IS_BOOL:
452 : case IS_CONSTANT:
453 : {
454 1337 : convert_to_long_ex(val);
455 1337 : mpz_init_set_si(**gmpnumber, Z_LVAL_PP(val));
456 : }
457 1337 : break;
458 : case IS_STRING:
459 : {
460 171 : char *numstr = Z_STRVAL_PP(val);
461 :
462 171 : if (Z_STRLEN_PP(val) > 2) {
463 141 : if (numstr[0] == '0') {
464 11 : if (numstr[1] == 'x' || numstr[1] == 'X') {
465 2 : base = 16;
466 2 : skip_lead = 1;
467 7 : } else if (base != 16 && (numstr[1] == 'b' || numstr[1] == 'B')) {
468 2 : base = 2;
469 2 : skip_lead = 1;
470 : }
471 : }
472 : }
473 171 : ret = mpz_init_set_str(**gmpnumber, (skip_lead ? &numstr[2] : numstr), base);
474 : }
475 171 : break;
476 : default:
477 61 : php_error_docref(NULL TSRMLS_CC, E_WARNING,"Unable to convert variable to GMP - wrong type");
478 61 : efree(*gmpnumber);
479 61 : return FAILURE;
480 : }
481 :
482 1508 : if (ret) {
483 20 : FREE_GMP_NUM(*gmpnumber);
484 20 : return FAILURE;
485 : }
486 :
487 1488 : return SUCCESS;
488 : }
489 : /* }}} */
490 :
491 : /* {{{ typedefs
492 : */
493 : typedef void (*gmp_unary_op_t)(mpz_ptr, mpz_srcptr);
494 : typedef int (*gmp_unary_opl_t)(mpz_srcptr);
495 :
496 : typedef void (*gmp_unary_ui_op_t)(mpz_ptr, unsigned long);
497 :
498 : typedef void (*gmp_binary_op_t)(mpz_ptr, mpz_srcptr, mpz_srcptr);
499 : typedef int (*gmp_binary_opl_t)(mpz_srcptr, mpz_srcptr);
500 :
501 : typedef unsigned long (*gmp_binary_ui_op_t)(mpz_ptr, mpz_srcptr, unsigned long);
502 : typedef void (*gmp_binary_op2_t)(mpz_ptr, mpz_ptr, mpz_srcptr, mpz_srcptr);
503 : typedef unsigned long (*gmp_binary_ui_op2_t)(mpz_ptr, mpz_ptr, mpz_srcptr, unsigned long);
504 : /* }}} */
505 :
506 : #define gmp_zval_binary_ui_op(r, a, b, o, u) gmp_zval_binary_ui_op_ex(r, a, b, o, u, 0, 0 TSRMLS_CC)
507 : #define gmp_zval_binary_ui_op2(r, a, b, o, u) gmp_zval_binary_ui_op2_ex(r, a, b, o, u, 0, 0 TSRMLS_CC)
508 :
509 : #define gmp_binary_ui_op(op, uop) _gmp_binary_ui_op(INTERNAL_FUNCTION_PARAM_PASSTHRU, op, uop)
510 : #define gmp_binary_op(op) _gmp_binary_ui_op(INTERNAL_FUNCTION_PARAM_PASSTHRU, op, NULL)
511 : #define gmp_binary_opl(op) _gmp_binary_opl(INTERNAL_FUNCTION_PARAM_PASSTHRU, op)
512 :
513 : /* Unary operations */
514 : #define gmp_unary_op(op) _gmp_unary_op(INTERNAL_FUNCTION_PARAM_PASSTHRU, op)
515 : #define gmp_unary_opl(op) _gmp_unary_opl(INTERNAL_FUNCTION_PARAM_PASSTHRU, op)
516 : #define gmp_unary_ui_op(op) _gmp_unary_ui_op(INTERNAL_FUNCTION_PARAM_PASSTHRU, op)
517 :
518 : /* {{{ gmp_zval_binary_ui_op_ex
519 : Execute GMP binary operation.
520 : May return GMP resource or long if operation allows this
521 : */
522 : static inline void gmp_zval_binary_ui_op_ex(zval *return_value, zval **a_arg, zval **b_arg, gmp_binary_op_t gmp_op, gmp_binary_ui_op_t gmp_ui_op, int allow_ui_return, int check_b_zero TSRMLS_DC)
523 1082 : {
524 : mpz_t *gmpnum_a, *gmpnum_b, *gmpnum_result;
525 1082 : unsigned long long_result = 0;
526 1082 : int use_ui = 0;
527 :
528 1082 : FETCH_GMP_ZVAL(gmpnum_a, a_arg);
529 :
530 1108 : if (gmp_ui_op && Z_TYPE_PP(b_arg) == IS_LONG && Z_LVAL_PP(b_arg) >= 0) {
531 41 : use_ui = 1;
532 : } else {
533 1026 : FETCH_GMP_ZVAL(gmpnum_b, b_arg);
534 : }
535 :
536 1064 : if(check_b_zero) {
537 23 : int b_is_zero = 0;
538 23 : if(use_ui) {
539 21 : b_is_zero = (Z_LVAL_PP(b_arg) == 0);
540 : } else {
541 2 : b_is_zero = !mpz_cmp_ui(*gmpnum_b, 0);
542 : }
543 :
544 23 : if(b_is_zero) {
545 4 : php_error_docref(NULL TSRMLS_CC, E_WARNING, "Zero operand not allowed");
546 4 : RETURN_FALSE;
547 : }
548 : }
549 :
550 1060 : INIT_GMP_NUM(gmpnum_result);
551 :
552 1097 : if (use_ui && gmp_ui_op) {
553 37 : if (allow_ui_return) {
554 15 : long_result = gmp_ui_op(*gmpnum_result, *gmpnum_a, (unsigned long)Z_LVAL_PP(b_arg));
555 : } else {
556 22 : gmp_ui_op(*gmpnum_result, *gmpnum_a, (unsigned long)Z_LVAL_PP(b_arg));
557 : }
558 : } else {
559 1023 : gmp_op(*gmpnum_result, *gmpnum_a, *gmpnum_b);
560 : }
561 :
562 1060 : if (use_ui && allow_ui_return) {
563 15 : FREE_GMP_NUM(gmpnum_result);
564 15 : RETURN_LONG((long)long_result);
565 : } else {
566 1045 : ZEND_REGISTER_RESOURCE(return_value, gmpnum_result, le_gmp);
567 : }
568 : }
569 : /* }}} */
570 :
571 : /* {{{ gmp_zval_binary_ui_op2_ex
572 : Execute GMP binary operation which returns 2 values.
573 : May return GMP resources or longs if operation allows this.
574 : */
575 : static inline void gmp_zval_binary_ui_op2_ex(zval *return_value, zval **a_arg, zval **b_arg, gmp_binary_op2_t gmp_op, gmp_binary_ui_op2_t gmp_ui_op, int allow_ui_return, int check_b_zero TSRMLS_DC)
576 12 : {
577 : mpz_t *gmpnum_a, *gmpnum_b, *gmpnum_result1, *gmpnum_result2;
578 : zval r;
579 12 : int use_ui = 0;
580 12 : unsigned long long_result = 0;
581 :
582 12 : FETCH_GMP_ZVAL(gmpnum_a, a_arg);
583 :
584 20 : if (gmp_ui_op && Z_TYPE_PP(b_arg) == IS_LONG && Z_LVAL_PP(b_arg) >= 0) {
585 : /* use _ui function */
586 10 : use_ui = 1;
587 : } else {
588 0 : FETCH_GMP_ZVAL(gmpnum_b, b_arg);
589 : }
590 :
591 10 : if(check_b_zero) {
592 10 : int b_is_zero = 0;
593 10 : if(use_ui) {
594 10 : b_is_zero = (Z_LVAL_PP(b_arg) == 0);
595 : } else {
596 0 : b_is_zero = !mpz_cmp_ui(*gmpnum_b, 0);
597 : }
598 :
599 10 : if(b_is_zero) {
600 2 : php_error_docref(NULL TSRMLS_CC, E_WARNING, "Zero operand not allowed");
601 2 : RETURN_FALSE;
602 : }
603 : }
604 :
605 8 : INIT_GMP_NUM(gmpnum_result1);
606 8 : INIT_GMP_NUM(gmpnum_result2);
607 :
608 16 : if (use_ui && gmp_ui_op) {
609 8 : if (allow_ui_return) {
610 0 : long_result = gmp_ui_op(*gmpnum_result1, *gmpnum_result2, *gmpnum_a, (unsigned long)Z_LVAL_PP(b_arg));
611 : } else {
612 8 : gmp_ui_op(*gmpnum_result1, *gmpnum_result2, *gmpnum_a, (unsigned long)Z_LVAL_PP(b_arg));
613 : }
614 : } else {
615 0 : gmp_op(*gmpnum_result1, *gmpnum_result2, *gmpnum_a, *gmpnum_b);
616 : }
617 :
618 8 : array_init(return_value);
619 8 : ZEND_REGISTER_RESOURCE(&r, gmpnum_result1, le_gmp);
620 8 : add_index_resource(return_value, 0, Z_LVAL(r));
621 8 : if (use_ui && allow_ui_return) {
622 0 : mpz_clear(*gmpnum_result2);
623 0 : add_index_long(return_value, 1, long_result);
624 : } else {
625 8 : ZEND_REGISTER_RESOURCE(&r, gmpnum_result2, le_gmp);
626 8 : add_index_resource(return_value, 1, Z_LVAL(r));
627 : }
628 : }
629 : /* }}} */
630 :
631 : /* {{{ _gmp_binary_ui_op
632 : */
633 : static inline void _gmp_binary_ui_op(INTERNAL_FUNCTION_PARAMETERS, gmp_binary_op_t gmp_op, gmp_binary_ui_op_t gmp_ui_op)
634 1049 : {
635 : zval **a_arg, **b_arg;
636 :
637 1049 : if (ZEND_NUM_ARGS() != 2 || zend_get_parameters_ex(2, &a_arg, &b_arg) == FAILURE){
638 7 : WRONG_PARAM_COUNT;
639 : }
640 :
641 1042 : gmp_zval_binary_ui_op(return_value, a_arg, b_arg, gmp_op, gmp_ui_op);
642 : }
643 : /* }}} */
644 :
645 : /* Unary operations */
646 :
647 : /* {{{ gmp_zval_unary_op
648 : */
649 : static inline void gmp_zval_unary_op(zval *return_value, zval **a_arg, gmp_unary_op_t gmp_op TSRMLS_DC)
650 37 : {
651 : mpz_t *gmpnum_a, *gmpnum_result;
652 :
653 37 : FETCH_GMP_ZVAL(gmpnum_a, a_arg);
654 :
655 25 : INIT_GMP_NUM(gmpnum_result);
656 25 : gmp_op(*gmpnum_result, *gmpnum_a);
657 :
658 25 : ZEND_REGISTER_RESOURCE(return_value, gmpnum_result, le_gmp);
659 : }
660 : /* }}} */
661 :
662 : /* {{{ gmp_zval_unary_ui_op
663 : */
664 : static inline void gmp_zval_unary_ui_op(zval *return_value, zval **a_arg, gmp_unary_ui_op_t gmp_op)
665 11 : {
666 : mpz_t *gmpnum_result;
667 :
668 11 : convert_to_long_ex(a_arg);
669 :
670 11 : INIT_GMP_NUM(gmpnum_result);
671 11 : gmp_op(*gmpnum_result, Z_LVAL_PP(a_arg));
672 :
673 11 : ZEND_REGISTER_RESOURCE(return_value, gmpnum_result, le_gmp);
674 11 : }
675 : /* }}} */
676 :
677 : /* {{{ _gmp_unary_ui_op
678 : Execute GMP unary operation.
679 : */
680 : static inline void _gmp_unary_ui_op(INTERNAL_FUNCTION_PARAMETERS, gmp_unary_ui_op_t gmp_op)
681 0 : {
682 : zval **a_arg;
683 :
684 0 : if (ZEND_NUM_ARGS() != 1 || zend_get_parameters_ex(1, &a_arg) == FAILURE){
685 0 : WRONG_PARAM_COUNT;
686 : }
687 :
688 0 : gmp_zval_unary_ui_op(return_value, a_arg, gmp_op);
689 : }
690 : /* }}} */
691 :
692 : /* {{{ _gmp_unary_op
693 : */
694 : static inline void _gmp_unary_op(INTERNAL_FUNCTION_PARAMETERS, gmp_unary_op_t gmp_op)
695 42 : {
696 : zval **a_arg;
697 :
698 42 : if (ZEND_NUM_ARGS() != 1 || zend_get_parameters_ex(1, &a_arg) == FAILURE){
699 5 : WRONG_PARAM_COUNT;
700 : }
701 :
702 37 : gmp_zval_unary_op(return_value, a_arg, gmp_op TSRMLS_CC);
703 : }
704 : /* }}} */
705 :
706 : /* {{{ _gmp_unary_opl
707 : */
708 : static inline void _gmp_unary_opl(INTERNAL_FUNCTION_PARAMETERS, gmp_unary_opl_t gmp_op)
709 0 : {
710 : zval **a_arg;
711 : mpz_t *gmpnum_a;
712 :
713 0 : if (ZEND_NUM_ARGS() != 1 || zend_get_parameters_ex(1, &a_arg) == FAILURE){
714 0 : WRONG_PARAM_COUNT;
715 : }
716 :
717 0 : FETCH_GMP_ZVAL(gmpnum_a, a_arg);
718 :
719 0 : RETURN_LONG(gmp_op(*gmpnum_a));
720 : }
721 : /* }}} */
722 :
723 : /* {{{ _gmp_binary_opl
724 : */
725 : static inline void _gmp_binary_opl(INTERNAL_FUNCTION_PARAMETERS, gmp_binary_opl_t gmp_op)
726 46 : {
727 : zval **a_arg, **b_arg;
728 : mpz_t *gmpnum_a, *gmpnum_b;
729 :
730 46 : if (ZEND_NUM_ARGS() != 2 || zend_get_parameters_ex(2, &a_arg, &b_arg) == FAILURE){
731 6 : WRONG_PARAM_COUNT;
732 : }
733 :
734 40 : FETCH_GMP_ZVAL(gmpnum_a, a_arg);
735 36 : FETCH_GMP_ZVAL(gmpnum_b, a_arg);
736 :
737 36 : RETURN_LONG(gmp_op(*gmpnum_a, *gmpnum_b));
738 : }
739 : /* }}} */
740 :
741 : /* {{{ proto resource gmp_init(mixed number [, int base])
742 : Initializes GMP number */
743 : ZEND_FUNCTION(gmp_init)
744 96 : {
745 : zval **number_arg, **base_arg;
746 : mpz_t * gmpnumber;
747 : int argc;
748 96 : int base=0;
749 :
750 96 : argc = ZEND_NUM_ARGS();
751 96 : if (argc < 1 || argc > 2 || zend_get_parameters_ex(argc, &number_arg, &base_arg) == FAILURE){
752 3 : WRONG_PARAM_COUNT;
753 : }
754 :
755 93 : if (argc == 2) {
756 11 : convert_to_long_ex(base_arg);
757 11 : base = Z_LVAL_PP(base_arg);
758 11 : if (base < 2 || base > 36) {
759 1 : php_error_docref(NULL TSRMLS_CC, E_WARNING, "Bad base for conversion: %d (should be between 2 and 36)", base);
760 1 : RETURN_FALSE;
761 : }
762 : }
763 :
764 92 : if (convert_to_gmp(&gmpnumber, number_arg, base TSRMLS_CC) == FAILURE) {
765 5 : RETURN_FALSE;
766 : }
767 :
768 : /* Write your own code here to handle argument number. */
769 87 : ZEND_REGISTER_RESOURCE(return_value, gmpnumber, le_gmp);
770 : }
771 : /* }}} */
772 :
773 : /* {{{ proto int gmp_intval(resource gmpnumber)
774 : Gets signed long value of GMP number */
775 : ZEND_FUNCTION(gmp_intval)
776 19 : {
777 : zval **gmpnumber_arg;
778 : mpz_t * gmpnum;
779 :
780 19 : if (ZEND_NUM_ARGS() != 1 || zend_get_parameters_ex(1, &gmpnumber_arg) == FAILURE){
781 1 : WRONG_PARAM_COUNT;
782 : }
783 :
784 18 : if (Z_TYPE_PP(gmpnumber_arg) == IS_RESOURCE) {
785 8 : ZEND_FETCH_RESOURCE(gmpnum, mpz_t *, gmpnumber_arg, -1, GMP_RESOURCE_NAME, le_gmp);
786 7 : RETVAL_LONG(mpz_get_si(*gmpnum));
787 : } else {
788 10 : convert_to_long_ex(gmpnumber_arg);
789 10 : RETVAL_LONG(Z_LVAL_PP(gmpnumber_arg));
790 : }
791 : }
792 : /* }}} */
793 :
794 : /* {{{ proto string gmp_strval(resource gmpnumber [, int base])
795 : Gets string representation of GMP number */
796 : ZEND_FUNCTION(gmp_strval)
797 297 : {
798 : zval **gmpnumber_arg, **base_arg;
799 297 : int base=10, num_len, argc;
800 : mpz_t * gmpnum;
801 : char *out_string;
802 :
803 297 : argc = ZEND_NUM_ARGS();
804 297 : if (argc < 1 || argc > 2 || zend_get_parameters_ex(argc, &gmpnumber_arg, &base_arg) == FAILURE){
805 1 : WRONG_PARAM_COUNT;
806 : }
807 :
808 296 : FETCH_GMP_ZVAL(gmpnum, gmpnumber_arg);
809 :
810 280 : switch (argc) {
811 : case 2:
812 7 : convert_to_long_ex(base_arg);
813 7 : base = Z_LVAL_PP(base_arg);
814 7 : break;
815 : case 1:
816 273 : base = 10;
817 : break;
818 : }
819 :
820 280 : if (base < 2 || base > 36) {
821 5 : php_error_docref(NULL TSRMLS_CC, E_WARNING, "Bad base for conversion: %d", base);
822 5 : RETURN_FALSE;
823 : }
824 :
825 275 : num_len = mpz_sizeinbase(*gmpnum, base);
826 275 : out_string = emalloc(num_len+2);
827 275 : if (mpz_sgn(*gmpnum) < 0) {
828 31 : num_len++;
829 : }
830 275 : mpz_get_str(out_string, base, *gmpnum);
831 :
832 : /*
833 : From GMP documentation for mpz_sizeinbase():
834 : The returned value will be exact or 1 too big. If base is a power of
835 : 2, the returned value will always be exact.
836 :
837 : So let's check to see if we already have a \0 byte...
838 : */
839 :
840 275 : if (out_string[num_len-1] == '\0') {
841 35 : num_len--;
842 : } else {
843 240 : out_string[num_len] = '\0';
844 : }
845 275 : RETVAL_STRINGL(out_string, num_len, 0);
846 : }
847 : /* }}} */
848 :
849 : /* {{{ proto resource gmp_add(resource a, resource b)
850 : Add a and b */
851 : ZEND_FUNCTION(gmp_add)
852 15 : {
853 15 : gmp_binary_ui_op(mpz_add, (gmp_binary_ui_op_t)mpz_add_ui);
854 15 : }
855 : /* }}} */
856 :
857 : /* {{{ proto resource gmp_sub(resource a, resource b)
858 : Subtract b from a */
859 : ZEND_FUNCTION(gmp_sub)
860 9 : {
861 9 : gmp_binary_ui_op(mpz_sub, (gmp_binary_ui_op_t)mpz_sub_ui);
862 9 : }
863 : /* }}} */
864 :
865 : /* {{{ proto resource gmp_mul(resource a, resource b)
866 : Multiply a and b */
867 : ZEND_FUNCTION(gmp_mul)
868 999 : {
869 999 : gmp_binary_ui_op(mpz_mul, (gmp_binary_ui_op_t)mpz_mul_ui);
870 999 : }
871 : /* }}} */
872 :
873 : /* {{{ proto array gmp_div_qr(resource a, resource b [, int round])
874 : Divide a by b, returns quotient and reminder */
875 : ZEND_FUNCTION(gmp_div_qr)
876 15 : {
877 : zval **a_arg, **b_arg, **round_arg;
878 15 : int round = GMP_ROUND_ZERO, argc;
879 :
880 15 : argc = ZEND_NUM_ARGS();
881 15 : if (argc < 2 || argc > 3 || zend_get_parameters_ex(argc, &a_arg, &b_arg, &round_arg) == FAILURE){
882 2 : WRONG_PARAM_COUNT;
883 : }
884 :
885 13 : switch (argc) {
886 : case 3:
887 6 : convert_to_long_ex(round_arg);
888 6 : round = Z_LVAL_PP(round_arg);
889 6 : break;
890 : case 2:
891 7 : round = GMP_ROUND_ZERO;
892 : break;
893 : }
894 :
895 13 : switch (round) {
896 : case GMP_ROUND_ZERO:
897 8 : gmp_zval_binary_ui_op2_ex(return_value, a_arg, b_arg, mpz_tdiv_qr, (gmp_binary_ui_op2_t)mpz_tdiv_qr_ui, 0, 1 TSRMLS_CC);
898 8 : break;
899 : case GMP_ROUND_PLUSINF:
900 2 : gmp_zval_binary_ui_op2_ex(return_value, a_arg, b_arg, mpz_cdiv_qr, (gmp_binary_ui_op2_t)mpz_cdiv_qr_ui, 0, 1 TSRMLS_CC);
901 2 : break;
902 : case GMP_ROUND_MINUSINF:
903 2 : gmp_zval_binary_ui_op2_ex(return_value, a_arg, b_arg, mpz_fdiv_qr, (gmp_binary_ui_op2_t)mpz_fdiv_qr_ui, 0, 1 TSRMLS_CC);
904 : break;
905 : }
906 :
907 : }
908 : /* }}} */
909 :
910 : /* {{{ proto resource gmp_div_r(resource a, resource b [, int round])
911 : Divide a by b, returns reminder only */
912 : ZEND_FUNCTION(gmp_div_r)
913 14 : {
914 : zval **a_arg, **b_arg, **round_arg;
915 14 : int round = GMP_ROUND_ZERO, argc;
916 :
917 14 : argc = ZEND_NUM_ARGS();
918 14 : if (argc < 2 || argc > 3 || zend_get_parameters_ex(argc, &a_arg, &b_arg, &round_arg) == FAILURE){
919 2 : WRONG_PARAM_COUNT;
920 : }
921 :
922 12 : switch (argc) {
923 : case 3:
924 6 : convert_to_long_ex(round_arg);
925 6 : round = Z_LVAL_PP(round_arg);
926 6 : break;
927 : case 2:
928 6 : round = GMP_ROUND_ZERO;
929 : break;
930 : }
931 :
932 12 : switch (round) {
933 : case GMP_ROUND_ZERO:
934 7 : gmp_zval_binary_ui_op_ex(return_value, a_arg, b_arg, mpz_tdiv_r, (gmp_binary_ui_op_t)mpz_tdiv_r_ui, 1, 1 TSRMLS_CC);
935 7 : break;
936 : case GMP_ROUND_PLUSINF:
937 2 : gmp_zval_binary_ui_op_ex(return_value, a_arg, b_arg, mpz_cdiv_r, (gmp_binary_ui_op_t)mpz_cdiv_r_ui, 1, 1 TSRMLS_CC);
938 2 : break;
939 : case GMP_ROUND_MINUSINF:
940 2 : gmp_zval_binary_ui_op_ex(return_value, a_arg, b_arg, mpz_fdiv_r, (gmp_binary_ui_op_t)mpz_fdiv_r_ui, 1, 1 TSRMLS_CC);
941 : break;
942 : }
943 : }
944 : /* }}} */
945 :
946 : /* {{{ proto resource gmp_div_q(resource a, resource b [, int round])
947 : Divide a by b, returns quotient only */
948 : ZEND_FUNCTION(gmp_div_q)
949 15 : {
950 : zval **a_arg, **b_arg, **round_arg;
951 15 : int round = GMP_ROUND_ZERO, argc;
952 :
953 15 : argc = ZEND_NUM_ARGS();
954 15 : if (argc < 2 || argc > 3 || zend_get_parameters_ex(argc, &a_arg, &b_arg, &round_arg) == FAILURE){
955 2 : WRONG_PARAM_COUNT;
956 : }
957 :
958 13 : switch (argc) {
959 : case 3:
960 6 : convert_to_long_ex(round_arg);
961 6 : round = Z_LVAL_PP(round_arg);
962 6 : break;
963 : case 2:
964 7 : round = GMP_ROUND_ZERO;
965 : break;
966 : }
967 :
968 13 : switch (round) {
969 : case GMP_ROUND_ZERO:
970 8 : gmp_zval_binary_ui_op_ex(return_value, a_arg, b_arg, mpz_tdiv_q, (gmp_binary_ui_op_t)mpz_tdiv_q_ui, 0, 1 TSRMLS_CC);
971 8 : break;
972 : case GMP_ROUND_PLUSINF:
973 2 : gmp_zval_binary_ui_op_ex(return_value, a_arg, b_arg, mpz_cdiv_q, (gmp_binary_ui_op_t)mpz_cdiv_q_ui, 0, 1 TSRMLS_CC);
974 2 : break;
975 : case GMP_ROUND_MINUSINF:
976 2 : gmp_zval_binary_ui_op_ex(return_value, a_arg, b_arg, mpz_fdiv_q, (gmp_binary_ui_op_t)mpz_fdiv_q_ui, 0, 1 TSRMLS_CC);
977 : break;
978 : }
979 :
980 : }
981 : /* }}} */
982 :
983 : /* {{{ proto resource gmp_mod(resource a, resource b)
984 : Computes a modulo b */
985 : ZEND_FUNCTION(gmp_mod)
986 8 : {
987 : zval **a_arg, **b_arg;
988 :
989 8 : if (ZEND_NUM_ARGS() != 2 || zend_get_parameters_ex(2, &a_arg, &b_arg) == FAILURE){
990 2 : WRONG_PARAM_COUNT;
991 : }
992 :
993 6 : gmp_zval_binary_ui_op_ex(return_value, a_arg, b_arg, mpz_mod, (gmp_binary_ui_op_t)mpz_mod_ui, 1, 1 TSRMLS_CC);
994 : }
995 : /* }}} */
996 :
997 : /* {{{ proto resource gmp_divexact(resource a, resource b)
998 : Divide a by b using exact division algorithm */
999 : ZEND_FUNCTION(gmp_divexact)
1000 0 : {
1001 : zval **a_arg, **b_arg;
1002 :
1003 0 : if (ZEND_NUM_ARGS() != 2 || zend_get_parameters_ex(2, &a_arg, &b_arg) == FAILURE){
1004 0 : WRONG_PARAM_COUNT;
1005 : }
1006 :
1007 0 : gmp_zval_binary_ui_op_ex(return_value, a_arg, b_arg, mpz_divexact, NULL, 0, 1 TSRMLS_CC);
1008 : }
1009 : /* }}} */
1010 :
1011 : /* {{{ proto resource gmp_neg(resource a)
1012 : Negates a number */
1013 : ZEND_FUNCTION(gmp_neg)
1014 11 : {
1015 11 : gmp_unary_op(mpz_neg);
1016 11 : }
1017 : /* }}} */
1018 :
1019 : /* {{{ proto resource gmp_abs(resource a)
1020 : Calculates absolute value */
1021 : ZEND_FUNCTION(gmp_abs)
1022 12 : {
1023 12 : gmp_unary_op(mpz_abs);
1024 12 : }
1025 : /* }}} */
1026 :
1027 : /* {{{ proto resource gmp_fact(int a)
1028 : Calculates factorial function */
1029 : ZEND_FUNCTION(gmp_fact)
1030 16 : {
1031 : zval **a_arg;
1032 : mpz_t *gmpnum_tmp;
1033 :
1034 16 : if (ZEND_NUM_ARGS() != 1 || zend_get_parameters_ex(1, &a_arg) == FAILURE){
1035 2 : WRONG_PARAM_COUNT;
1036 : }
1037 :
1038 14 : if (Z_TYPE_PP(a_arg) == IS_RESOURCE) {
1039 2 : FETCH_GMP_ZVAL(gmpnum_tmp, a_arg);
1040 2 : if (mpz_sgn(*gmpnum_tmp) < 0) {
1041 1 : php_error_docref(NULL TSRMLS_CC, E_WARNING,"Number has to be greater than or equal to 0");
1042 1 : RETURN_FALSE;
1043 : }
1044 : } else {
1045 12 : convert_to_long_ex(a_arg);
1046 12 : if (Z_LVAL_PP(a_arg) < 0) {
1047 2 : php_error_docref(NULL TSRMLS_CC, E_WARNING,"Number has to be greater than or equal to 0");
1048 2 : RETURN_FALSE;
1049 : }
1050 : }
1051 :
1052 11 : gmp_zval_unary_ui_op(return_value, a_arg, mpz_fac_ui);
1053 : }
1054 : /* }}} */
1055 :
1056 : /* {{{ proto resource gmp_pow(resource base, int exp)
1057 : Raise base to power exp */
1058 : ZEND_FUNCTION(gmp_pow)
1059 18 : {
1060 : zval **base_arg, **exp_arg;
1061 : mpz_t *gmpnum_result, *gmpnum_base;
1062 18 : int use_ui = 0;
1063 :
1064 18 : if (ZEND_NUM_ARGS() != 2 || zend_get_parameters_ex(2, &base_arg, &exp_arg) == FAILURE){
1065 3 : WRONG_PARAM_COUNT;
1066 : }
1067 :
1068 20 : if (Z_TYPE_PP(base_arg) == IS_LONG && Z_LVAL_PP(base_arg) >= 0) {
1069 5 : use_ui = 1;
1070 : } else {
1071 10 : FETCH_GMP_ZVAL(gmpnum_base, base_arg);
1072 : }
1073 :
1074 13 : convert_to_long_ex(exp_arg);
1075 :
1076 13 : if (Z_LVAL_PP(exp_arg) < 0) {
1077 2 : php_error_docref(NULL TSRMLS_CC, E_WARNING,"Negative exponent not supported");
1078 2 : RETURN_FALSE;
1079 : }
1080 :
1081 11 : INIT_GMP_NUM(gmpnum_result);
1082 11 : if (use_ui) {
1083 4 : mpz_ui_pow_ui(*gmpnum_result, Z_LVAL_PP(base_arg), Z_LVAL_PP(exp_arg));
1084 : } else {
1085 7 : mpz_pow_ui(*gmpnum_result, *gmpnum_base, Z_LVAL_PP(exp_arg));
1086 : }
1087 :
1088 11 : ZEND_REGISTER_RESOURCE(return_value, gmpnum_result, le_gmp);
1089 : }
1090 : /* }}} */
1091 :
1092 : /* {{{ proto resource gmp_powm(resource base, resource exp, resource mod)
1093 : Raise base to power exp and take result modulo mod */
1094 : ZEND_FUNCTION(gmp_powm)
1095 18 : {
1096 : zval **base_arg, **exp_arg, **mod_arg;
1097 : mpz_t *gmpnum_base, *gmpnum_exp, *gmpnum_mod, *gmpnum_result;
1098 18 : int use_ui = 0;
1099 :
1100 18 : if (ZEND_NUM_ARGS() != 3 || zend_get_parameters_ex(3, &base_arg, &exp_arg, &mod_arg) == FAILURE){
1101 3 : WRONG_PARAM_COUNT;
1102 : }
1103 :
1104 15 : FETCH_GMP_ZVAL(gmpnum_base, base_arg);
1105 :
1106 20 : if (Z_TYPE_PP(exp_arg) == IS_LONG && Z_LVAL_PP(exp_arg) >= 0) {
1107 7 : use_ui = 1;
1108 : } else {
1109 6 : FETCH_GMP_ZVAL(gmpnum_exp, exp_arg);
1110 5 : if (mpz_sgn(*gmpnum_exp) < 0) {
1111 1 : php_error_docref(NULL TSRMLS_CC, E_WARNING,"Second parameter cannot be less than 0");
1112 1 : RETURN_FALSE;
1113 : }
1114 : }
1115 11 : FETCH_GMP_ZVAL(gmpnum_mod, mod_arg);
1116 :
1117 10 : if (!mpz_cmp_ui(*gmpnum_mod, 0)) {
1118 0 : RETURN_FALSE;
1119 : }
1120 :
1121 10 : INIT_GMP_NUM(gmpnum_result);
1122 10 : if (use_ui) {
1123 7 : mpz_powm_ui(*gmpnum_result, *gmpnum_base, (unsigned long)Z_LVAL_PP(exp_arg), *gmpnum_mod);
1124 : } else {
1125 3 : mpz_powm(*gmpnum_result, *gmpnum_base, *gmpnum_exp, *gmpnum_mod);
1126 : }
1127 :
1128 10 : ZEND_REGISTER_RESOURCE(return_value, gmpnum_result, le_gmp);
1129 :
1130 : }
1131 : /* }}} */
1132 :
1133 : /* {{{ proto resource gmp_sqrt(resource a)
1134 : Takes integer part of square root of a */
1135 : ZEND_FUNCTION(gmp_sqrt)
1136 11 : {
1137 : zval **a_arg;
1138 : mpz_t *gmpnum_a, *gmpnum_result;
1139 :
1140 11 : if (ZEND_NUM_ARGS() != 1 || zend_get_parameters_ex(1, &a_arg) == FAILURE){
1141 2 : WRONG_PARAM_COUNT;
1142 : }
1143 :
1144 9 : FETCH_GMP_ZVAL(gmpnum_a, a_arg);
1145 :
1146 8 : if (mpz_sgn(*gmpnum_a) < 0) {
1147 3 : php_error_docref(NULL TSRMLS_CC, E_WARNING,"Number has to be greater than or equal to 0");
1148 3 : RETURN_FALSE;
1149 : }
1150 :
1151 5 : INIT_GMP_NUM(gmpnum_result);
1152 5 : mpz_sqrt(*gmpnum_result, *gmpnum_a);
1153 :
1154 5 : ZEND_REGISTER_RESOURCE(return_value, gmpnum_result, le_gmp);
1155 : }
1156 : /* }}} */
1157 :
1158 : /* {{{ proto array gmp_sqrtrem(resource a)
1159 : Square root with remainder */
1160 : ZEND_FUNCTION(gmp_sqrtrem)
1161 13 : {
1162 : zval **a_arg;
1163 : mpz_t *gmpnum_a, *gmpnum_result1, *gmpnum_result2;
1164 : zval r;
1165 :
1166 13 : if (ZEND_NUM_ARGS() != 1 || zend_get_parameters_ex(1, &a_arg) == FAILURE){
1167 1 : WRONG_PARAM_COUNT;
1168 : }
1169 :
1170 12 : FETCH_GMP_ZVAL(gmpnum_a, a_arg);
1171 :
1172 11 : if (mpz_sgn(*gmpnum_a) < 0) {
1173 2 : php_error_docref(NULL TSRMLS_CC, E_WARNING,"Number has to be greater than or equal to 0");
1174 2 : RETURN_FALSE;
1175 : }
1176 :
1177 9 : INIT_GMP_NUM(gmpnum_result1);
1178 9 : INIT_GMP_NUM(gmpnum_result2);
1179 :
1180 9 : mpz_sqrtrem(*gmpnum_result1, *gmpnum_result2, *gmpnum_a);
1181 :
1182 9 : array_init(return_value);
1183 9 : ZEND_REGISTER_RESOURCE(&r, gmpnum_result1, le_gmp);
1184 9 : add_index_resource(return_value, 0, Z_LVAL(r));
1185 9 : ZEND_REGISTER_RESOURCE(&r, gmpnum_result2, le_gmp);
1186 9 : add_index_resource(return_value, 1, Z_LVAL(r));
1187 : }
1188 : /* }}} */
1189 :
1190 : /* {{{ proto bool gmp_perfect_square(resource a)
1191 : Checks if a is an exact square */
1192 : ZEND_FUNCTION(gmp_perfect_square)
1193 13 : {
1194 : zval **a_arg;
1195 : mpz_t *gmpnum_a;
1196 :
1197 13 : if (ZEND_NUM_ARGS() != 1 || zend_get_parameters_ex(1, &a_arg) == FAILURE){
1198 1 : WRONG_PARAM_COUNT;
1199 : }
1200 :
1201 12 : FETCH_GMP_ZVAL(gmpnum_a, a_arg);
1202 :
1203 11 : RETURN_BOOL((mpz_perfect_square_p(*gmpnum_a)!=0));
1204 : }
1205 : /* }}} */
1206 :
1207 : /* {{{ proto int gmp_prob_prime(resource a[, int reps])
1208 : Checks if a is "probably prime" */
1209 : ZEND_FUNCTION(gmp_prob_prime)
1210 40 : {
1211 : zval **gmpnumber_arg, **reps_arg;
1212 : mpz_t *gmpnum_a;
1213 40 : int argc, reps = 10;
1214 :
1215 40 : argc = ZEND_NUM_ARGS();
1216 40 : if (argc < 1 || argc > 2 || zend_get_parameters_ex(argc, &gmpnumber_arg, &reps_arg) == FAILURE){
1217 1 : WRONG_PARAM_COUNT;
1218 : }
1219 :
1220 39 : FETCH_GMP_ZVAL(gmpnum_a, gmpnumber_arg);
1221 :
1222 38 : switch (argc) {
1223 : case 2:
1224 26 : convert_to_long_ex(reps_arg);
1225 26 : reps = Z_LVAL_PP(reps_arg);
1226 26 : break;
1227 : case 1:
1228 12 : reps = 10;
1229 : break;
1230 : }
1231 :
1232 38 : RETURN_LONG(mpz_probab_prime_p(*gmpnum_a, reps));
1233 : }
1234 : /* }}} */
1235 :
1236 : /* {{{ proto resource gmp_gcd(resource a, resource b)
1237 : Computes greatest common denominator (gcd) of a and b */
1238 : ZEND_FUNCTION(gmp_gcd)
1239 14 : {
1240 : zval **a_arg, **b_arg;
1241 :
1242 14 : if (ZEND_NUM_ARGS() != 2 || zend_get_parameters_ex(2, &a_arg, &b_arg) == FAILURE){
1243 3 : WRONG_PARAM_COUNT;
1244 : }
1245 :
1246 11 : gmp_zval_binary_ui_op_ex(return_value, a_arg, b_arg, mpz_gcd, (gmp_binary_ui_op_t)mpz_gcd_ui, 1, 0 TSRMLS_CC);
1247 : }
1248 : /* }}} */
1249 :
1250 : /* {{{ proto array gmp_gcdext(resource a, resource b)
1251 : Computes G, S, and T, such that AS + BT = G = `gcd' (A, B) */
1252 : ZEND_FUNCTION(gmp_gcdext)
1253 15 : {
1254 : zval **a_arg, **b_arg;
1255 : mpz_t *gmpnum_a, *gmpnum_b, *gmpnum_t, *gmpnum_s, *gmpnum_g;
1256 : zval r;
1257 :
1258 15 : if (ZEND_NUM_ARGS() != 2 || zend_get_parameters_ex(2, &a_arg, &b_arg) == FAILURE){
1259 3 : WRONG_PARAM_COUNT;
1260 : }
1261 :
1262 12 : FETCH_GMP_ZVAL(gmpnum_a, a_arg);
1263 11 : FETCH_GMP_ZVAL(gmpnum_b, b_arg);
1264 :
1265 10 : INIT_GMP_NUM(gmpnum_g);
1266 10 : INIT_GMP_NUM(gmpnum_s);
1267 10 : INIT_GMP_NUM(gmpnum_t);
1268 :
1269 10 : mpz_gcdext(*gmpnum_g, *gmpnum_s, *gmpnum_t, *gmpnum_a, *gmpnum_b);
1270 :
1271 10 : array_init(return_value);
1272 :
1273 10 : ZEND_REGISTER_RESOURCE(&r, gmpnum_g, le_gmp);
1274 10 : add_assoc_resource(return_value, "g", Z_LVAL(r));
1275 10 : ZEND_REGISTER_RESOURCE(&r, gmpnum_s, le_gmp);
1276 10 : add_assoc_resource(return_value, "s", Z_LVAL(r));
1277 10 : ZEND_REGISTER_RESOURCE(&r, gmpnum_t, le_gmp);
1278 10 : add_assoc_resource(return_value, "t", Z_LVAL(r));
1279 : }
1280 : /* }}} */
1281 :
1282 : /* {{{ proto resource gmp_invert(resource a, resource b)
1283 : Computes the inverse of a modulo b */
1284 : ZEND_FUNCTION(gmp_invert)
1285 14 : {
1286 : zval **a_arg, **b_arg;
1287 : mpz_t *gmpnum_a, *gmpnum_b, *gmpnum_result;
1288 :
1289 14 : if (ZEND_NUM_ARGS() != 2 || zend_get_parameters_ex(2, &a_arg, &b_arg) == FAILURE){
1290 2 : WRONG_PARAM_COUNT;
1291 : }
1292 :
1293 12 : FETCH_GMP_ZVAL(gmpnum_a, a_arg);
1294 10 : FETCH_GMP_ZVAL(gmpnum_b, b_arg);
1295 :
1296 9 : INIT_GMP_NUM(gmpnum_result);
1297 9 : if (mpz_invert(*gmpnum_result, *gmpnum_a, *gmpnum_b)) {
1298 4 : ZEND_REGISTER_RESOURCE(return_value, gmpnum_result, le_gmp);
1299 : } else {
1300 5 : FREE_GMP_NUM(gmpnum_result);
1301 5 : RETURN_FALSE;
1302 : }
1303 : }
1304 : /* }}} */
1305 :
1306 : /* {{{ proto int gmp_jacobi(resource a, resource b)
1307 : Computes Jacobi symbol */
1308 : ZEND_FUNCTION(gmp_jacobi)
1309 23 : {
1310 23 : gmp_binary_opl(mpz_jacobi);
1311 23 : }
1312 : /* }}} */
1313 :
1314 : /* {{{ proto int gmp_legendre(resource a, resource b)
1315 : Computes Legendre symbol */
1316 : ZEND_FUNCTION(gmp_legendre)
1317 23 : {
1318 23 : gmp_binary_opl(mpz_legendre);
1319 23 : }
1320 : /* }}} */
1321 :
1322 : /* {{{ proto int gmp_cmp(resource a, resource b)
1323 : Compares two numbers */
1324 : ZEND_FUNCTION(gmp_cmp)
1325 12 : {
1326 : zval **a_arg, **b_arg;
1327 : mpz_t *gmpnum_a, *gmpnum_b;
1328 12 : int use_si = 0, res;
1329 :
1330 12 : if (ZEND_NUM_ARGS() != 2 || zend_get_parameters_ex(2, &a_arg, &b_arg) == FAILURE){
1331 3 : WRONG_PARAM_COUNT;
1332 : }
1333 :
1334 9 : FETCH_GMP_ZVAL(gmpnum_a, a_arg);
1335 :
1336 8 : if (Z_TYPE_PP(b_arg) == IS_LONG) {
1337 4 : use_si = 1;
1338 : } else {
1339 4 : FETCH_GMP_ZVAL(gmpnum_b, b_arg);
1340 : }
1341 :
1342 8 : if (use_si) {
1343 4 : res = mpz_cmp_si(*gmpnum_a, Z_LVAL_PP(b_arg));
1344 : } else {
1345 4 : res = mpz_cmp(*gmpnum_a, *gmpnum_b);
1346 : }
1347 :
1348 8 : RETURN_LONG(res);
1349 : }
1350 : /* }}} */
1351 :
1352 : /* {{{ proto int gmp_sign(resource a)
1353 : Gets the sign of the number */
1354 : ZEND_FUNCTION(gmp_sign)
1355 10 : {
1356 : zval **a_arg;
1357 : mpz_t *gmpnum_a;
1358 :
1359 10 : if (ZEND_NUM_ARGS() != 1 || zend_get_parameters_ex(1, &a_arg) == FAILURE){
1360 2 : WRONG_PARAM_COUNT;
1361 : }
1362 :
1363 8 : FETCH_GMP_ZVAL(gmpnum_a, a_arg);
1364 :
1365 6 : RETURN_LONG(mpz_sgn(*gmpnum_a));
1366 : }
1367 : /* }}} */
1368 :
1369 : /* {{{ proto resource gmp_random([int limiter])
1370 : Gets random number */
1371 : ZEND_FUNCTION(gmp_random)
1372 10 : {
1373 : zval **limiter_arg;
1374 : int limiter, argc;
1375 : mpz_t *gmpnum_result;
1376 :
1377 10 : argc = ZEND_NUM_ARGS();
1378 :
1379 10 : if (argc == 0) {
1380 1 : limiter = 20;
1381 17 : } else if (argc == 1 && zend_get_parameters_ex(1, &limiter_arg) == SUCCESS) {
1382 8 : convert_to_long_ex(limiter_arg);
1383 8 : limiter = Z_LVAL_PP(limiter_arg);
1384 : } else {
1385 1 : WRONG_PARAM_COUNT;
1386 : }
1387 :
1388 9 : INIT_GMP_NUM(gmpnum_result);
1389 :
1390 9 : if (!GMPG(rand_initialized)) {
1391 : /* Initialize */
1392 1 : gmp_randinit_lc_2exp_size(GMPG(rand_state), 32L);
1393 :
1394 : /* Seed */
1395 1 : gmp_randseed_ui(GMPG(rand_state), GENERATE_SEED());
1396 :
1397 1 : GMPG(rand_initialized) = 1;
1398 : }
1399 9 : mpz_urandomb(*gmpnum_result, GMPG(rand_state), GMP_ABS (limiter) * __GMP_BITS_PER_MP_LIMB);
1400 :
1401 9 : ZEND_REGISTER_RESOURCE(return_value, gmpnum_result, le_gmp);
1402 : }
1403 : /* }}} */
1404 :
1405 : /* {{{ proto resource gmp_and(resource a, resource b)
1406 : Calculates logical AND of a and b */
1407 : ZEND_FUNCTION(gmp_and)
1408 13 : {
1409 13 : gmp_binary_op(mpz_and);
1410 13 : }
1411 : /* }}} */
1412 :
1413 : /* {{{ proto resource gmp_or(resource a, resource b)
1414 : Calculates logical OR of a and b */
1415 : ZEND_FUNCTION(gmp_or)
1416 13 : {
1417 13 : gmp_binary_op(mpz_ior);
1418 13 : }
1419 : /* }}} */
1420 :
1421 : /* {{{ proto resource gmp_com(resource a)
1422 : Calculates one's complement of a */
1423 : ZEND_FUNCTION(gmp_com)
1424 11 : {
1425 11 : gmp_unary_op(mpz_com);
1426 11 : }
1427 : /* }}} */
1428 :
1429 : /* {{{ proto resource gmp_nextprime(resource a)
1430 : Finds next prime of a */
1431 : ZEND_FUNCTION(gmp_nextprime)
1432 8 : {
1433 8 : gmp_unary_op(mpz_nextprime);
1434 8 : }
1435 : /* }}} */
1436 :
1437 : /* {{{ proto resource gmp_xor(resource a, resource b)
1438 : Calculates logical exclusive OR of a and b */
1439 : ZEND_FUNCTION(gmp_xor)
1440 13 : {
1441 : /* use formula: a^b = (a|b)&^(a&b) */
1442 : zval **a_arg, **b_arg;
1443 : mpz_t *gmpnum_a, *gmpnum_b, *gmpnum_result, *gmpnum_t;
1444 :
1445 13 : if (ZEND_NUM_ARGS() != 2 || zend_get_parameters_ex(2, &a_arg, &b_arg) == FAILURE){
1446 2 : WRONG_PARAM_COUNT;
1447 : }
1448 :
1449 11 : FETCH_GMP_ZVAL(gmpnum_a, a_arg);
1450 8 : FETCH_GMP_ZVAL(gmpnum_b, b_arg);
1451 :
1452 7 : INIT_GMP_NUM(gmpnum_result);
1453 7 : INIT_GMP_NUM(gmpnum_t);
1454 :
1455 7 : mpz_and(*gmpnum_t, *gmpnum_a, *gmpnum_b);
1456 7 : mpz_com(*gmpnum_t, *gmpnum_t);
1457 :
1458 7 : mpz_ior(*gmpnum_result, *gmpnum_a, *gmpnum_b);
1459 7 : mpz_and(*gmpnum_result, *gmpnum_result, *gmpnum_t);
1460 :
1461 7 : FREE_GMP_NUM(gmpnum_t);
1462 :
1463 7 : ZEND_REGISTER_RESOURCE(return_value, gmpnum_result, le_gmp);
1464 : }
1465 : /* }}} */
1466 :
1467 : /* {{{ proto void gmp_setbit(resource &a, int index[, bool set_clear])
1468 : Sets or clear bit in a */
1469 : ZEND_FUNCTION(gmp_setbit)
1470 12 : {
1471 : zval **a_arg, **ind_arg, **set_c_arg;
1472 12 : int argc, index, set = 1;
1473 : mpz_t *gmpnum_a;
1474 :
1475 12 : argc = ZEND_NUM_ARGS();
1476 12 : if (argc < 2 || argc > 3 || zend_get_parameters_ex(argc, &a_arg, &ind_arg, &set_c_arg) == FAILURE){
1477 2 : WRONG_PARAM_COUNT;
1478 : }
1479 :
1480 10 : ZEND_FETCH_RESOURCE(gmpnum_a, mpz_t *, a_arg, -1, GMP_RESOURCE_NAME, le_gmp);
1481 :
1482 7 : convert_to_long_ex(ind_arg);
1483 7 : index = Z_LVAL_PP(ind_arg);
1484 :
1485 7 : switch (argc) {
1486 : case 3:
1487 6 : convert_to_long_ex(set_c_arg);
1488 6 : set = Z_LVAL_PP(set_c_arg);
1489 6 : break;
1490 : case 2:
1491 1 : set = 1;
1492 : break;
1493 : }
1494 :
1495 7 : if (index < 0) {
1496 1 : php_error_docref(NULL TSRMLS_CC, E_WARNING, "Index must be greater than or equal to zero");
1497 1 : return;
1498 : }
1499 :
1500 6 : if (set) {
1501 4 : mpz_setbit(*gmpnum_a, index);
1502 : } else {
1503 2 : mpz_clrbit(*gmpnum_a, index);
1504 : }
1505 : }
1506 : /* }}} */
1507 :
1508 : /* {{{ proto void gmp_clrbit(resource &a, int index)
1509 : Clears bit in a */
1510 : ZEND_FUNCTION(gmp_clrbit)
1511 11 : {
1512 : zval **a_arg, **ind_arg;
1513 : int index;
1514 : mpz_t *gmpnum_a;
1515 :
1516 11 : if (ZEND_NUM_ARGS() != 2 || zend_get_parameters_ex(2, &a_arg, &ind_arg) == FAILURE){
1517 3 : WRONG_PARAM_COUNT;
1518 : }
1519 :
1520 8 : ZEND_FETCH_RESOURCE(gmpnum_a, mpz_t *, a_arg, -1, GMP_RESOURCE_NAME, le_gmp);
1521 :
1522 7 : convert_to_long_ex(ind_arg);
1523 7 : index = Z_LVAL_PP(ind_arg);
1524 :
1525 7 : if (index < 0) {
1526 2 : php_error_docref(NULL TSRMLS_CC, E_WARNING, "Index must be greater than or equal to zero");
1527 2 : return;
1528 : }
1529 :
1530 5 : mpz_clrbit(*gmpnum_a, index);
1531 : }
1532 : /* }}} */
1533 :
1534 : /* {{{ proto int gmp_popcount(resource a)
1535 : Calculates the population count of a */
1536 : ZEND_FUNCTION(gmp_popcount)
1537 8 : {
1538 : zval **a_arg;
1539 : mpz_t *gmpnum_a;
1540 :
1541 8 : if (ZEND_NUM_ARGS() != 1 || zend_get_parameters_ex(1, &a_arg) == FAILURE){
1542 1 : WRONG_PARAM_COUNT;
1543 : }
1544 :
1545 7 : FETCH_GMP_ZVAL(gmpnum_a, a_arg);
1546 :
1547 6 : RETURN_LONG(mpz_popcount(*gmpnum_a));
1548 : }
1549 : /* }}} */
1550 :
1551 : /* {{{ proto int gmp_hamdist(resource a, resource b)
1552 : Calculates hamming distance between a and b */
1553 : ZEND_FUNCTION(gmp_hamdist)
1554 12 : {
1555 : zval **a_arg, **b_arg;
1556 : mpz_t *gmpnum_a, *gmpnum_b;
1557 :
1558 12 : if (ZEND_NUM_ARGS() != 2 || zend_get_parameters_ex(2, &a_arg, &b_arg) == FAILURE){
1559 2 : WRONG_PARAM_COUNT;
1560 : }
1561 :
1562 10 : FETCH_GMP_ZVAL(gmpnum_a, a_arg);
1563 8 : FETCH_GMP_ZVAL(gmpnum_b, b_arg);
1564 :
1565 7 : RETURN_LONG(mpz_hamdist(*gmpnum_a, *gmpnum_b));
1566 : }
1567 : /* }}} */
1568 :
1569 : /* {{{ proto int gmp_scan0(resource a, int start)
1570 : Finds first zero bit */
1571 : ZEND_FUNCTION(gmp_scan0)
1572 9 : {
1573 : zval **a_arg, **start_arg;
1574 : mpz_t *gmpnum_a;
1575 :
1576 9 : if (ZEND_NUM_ARGS() != 2 || zend_get_parameters_ex(2, &a_arg, &start_arg) == FAILURE){
1577 2 : WRONG_PARAM_COUNT;
1578 : }
1579 :
1580 7 : FETCH_GMP_ZVAL(gmpnum_a, a_arg);
1581 6 : convert_to_long_ex(start_arg);
1582 :
1583 6 : if (Z_LVAL_PP(start_arg) < 0) {
1584 1 : php_error_docref(NULL TSRMLS_CC, E_WARNING, "Starting index must be greater than or equal to zero");
1585 1 : RETURN_FALSE;
1586 : }
1587 :
1588 5 : RETURN_LONG(mpz_scan0(*gmpnum_a, Z_LVAL_PP(start_arg)));
1589 : }
1590 : /* }}} */
1591 :
1592 : /* {{{ proto int gmp_scan1(resource a, int start)
1593 : Finds first non-zero bit */
1594 : ZEND_FUNCTION(gmp_scan1)
1595 9 : {
1596 : zval **a_arg, **start_arg;
1597 : mpz_t *gmpnum_a;
1598 :
1599 9 : if (ZEND_NUM_ARGS() != 2 || zend_get_parameters_ex(2, &a_arg, &start_arg) == FAILURE){
1600 2 : WRONG_PARAM_COUNT;
1601 : }
1602 :
1603 7 : FETCH_GMP_ZVAL(gmpnum_a, a_arg);
1604 6 : convert_to_long_ex(start_arg);
1605 :
1606 6 : if (Z_LVAL_PP(start_arg) < 0) {
1607 1 : php_error_docref(NULL TSRMLS_CC, E_WARNING, "Starting index must be greater than or equal to zero");
1608 1 : RETURN_FALSE;
1609 : }
1610 :
1611 5 : RETURN_LONG(mpz_scan1(*gmpnum_a, Z_LVAL_PP(start_arg)));
1612 : }
1613 : /* }}} */
1614 :
1615 : /* {{{ _php_gmpnum_free
1616 : */
1617 : static void _php_gmpnum_free(zend_rsrc_list_entry *rsrc TSRMLS_DC)
1618 2679 : {
1619 2679 : mpz_t *gmpnum = (mpz_t *)rsrc->ptr;
1620 :
1621 2679 : FREE_GMP_NUM(gmpnum);
1622 2679 : }
1623 : /* }}} */
1624 :
1625 : #endif /* HAVE_GMP */
1626 :
1627 : /*
1628 : * Local variables:
1629 : * tab-width: 4
1630 : * c-basic-offset: 4
1631 : * End:
1632 : * vim600: noet sw=4 ts=4 fdm=marker
1633 : * vim<600: noet sw=4 ts=4
1634 : */
|
