1 /*
2 +----------------------------------------------------------------------+
3 | PHP Version 5 |
4 +----------------------------------------------------------------------+
5 | Copyright (c) 1997-2016 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 #include "ext/standard/php_var.h"
28 #include "ext/standard/php_smart_str_public.h"
29 #include "zend_exceptions.h"
30
31 #if HAVE_GMP
32
33 #include <gmp.h>
34
35 /* Needed for gmp_random() */
36 #include "ext/standard/php_rand.h"
37 #include "ext/standard/php_lcg.h"
38 #define GMP_ABS(x) ((x) >= 0 ? (x) : -(x))
39
40 /* {{{ arginfo */
41 ZEND_BEGIN_ARG_INFO_EX(arginfo_gmp_init, 0, 0, 1)
42 ZEND_ARG_INFO(0, number)
43 ZEND_ARG_INFO(0, base)
44 ZEND_END_ARG_INFO()
45
46 ZEND_BEGIN_ARG_INFO_EX(arginfo_gmp_import, 0, 0, 1)
47 ZEND_ARG_INFO(0, data)
48 ZEND_ARG_INFO(0, word_size)
49 ZEND_ARG_INFO(0, options)
50 ZEND_END_ARG_INFO()
51
52 ZEND_BEGIN_ARG_INFO_EX(arginfo_gmp_export, 0, 0, 1)
53 ZEND_ARG_INFO(0, gmpnumber)
54 ZEND_ARG_INFO(0, word_size)
55 ZEND_ARG_INFO(0, options)
56 ZEND_END_ARG_INFO()
57
58 ZEND_BEGIN_ARG_INFO_EX(arginfo_gmp_intval, 0, 0, 1)
59 ZEND_ARG_INFO(0, gmpnumber)
60 ZEND_END_ARG_INFO()
61
62 ZEND_BEGIN_ARG_INFO_EX(arginfo_gmp_strval, 0, 0, 1)
63 ZEND_ARG_INFO(0, gmpnumber)
64 ZEND_ARG_INFO(0, base)
65 ZEND_END_ARG_INFO()
66
67 ZEND_BEGIN_ARG_INFO_EX(arginfo_gmp_unary, 0, 0, 1)
68 ZEND_ARG_INFO(0, a)
69 ZEND_END_ARG_INFO()
70
71 ZEND_BEGIN_ARG_INFO_EX(arginfo_gmp_binary, 0, 0, 2)
72 ZEND_ARG_INFO(0, a)
73 ZEND_ARG_INFO(0, b)
74 ZEND_END_ARG_INFO()
75
76 ZEND_BEGIN_ARG_INFO_EX(arginfo_gmp_div, 0, 0, 2)
77 ZEND_ARG_INFO(0, a)
78 ZEND_ARG_INFO(0, b)
79 ZEND_ARG_INFO(0, round)
80 ZEND_END_ARG_INFO()
81
82 ZEND_BEGIN_ARG_INFO_EX(arginfo_gmp_pow, 0, 0, 2)
83 ZEND_ARG_INFO(0, base)
84 ZEND_ARG_INFO(0, exp)
85 ZEND_END_ARG_INFO()
86
87 ZEND_BEGIN_ARG_INFO_EX(arginfo_gmp_powm, 0, 0, 3)
88 ZEND_ARG_INFO(0, base)
89 ZEND_ARG_INFO(0, exp)
90 ZEND_ARG_INFO(0, mod)
91 ZEND_END_ARG_INFO()
92
93 ZEND_BEGIN_ARG_INFO_EX(arginfo_gmp_root, 0, 0, 2)
94 ZEND_ARG_INFO(0, a)
95 ZEND_ARG_INFO(0, nth)
96 ZEND_END_ARG_INFO()
97
98 ZEND_BEGIN_ARG_INFO_EX(arginfo_gmp_prob_prime, 0, 0, 1)
99 ZEND_ARG_INFO(0, a)
100 ZEND_ARG_INFO(0, reps)
101 ZEND_END_ARG_INFO()
102
103 ZEND_BEGIN_ARG_INFO_EX(arginfo_gmp_random, 0, 0, 0)
104 ZEND_ARG_INFO(0, limiter)
105 ZEND_END_ARG_INFO()
106
107 ZEND_BEGIN_ARG_INFO_EX(arginfo_gmp_random_bits, 0, 0, 1)
108 ZEND_ARG_INFO(0, bits)
109 ZEND_END_ARG_INFO()
110
111 ZEND_BEGIN_ARG_INFO_EX(arginfo_gmp_random_range, 0, 0, 2)
112 ZEND_ARG_INFO(0, min)
113 ZEND_ARG_INFO(0, max)
114 ZEND_END_ARG_INFO()
115
116 ZEND_BEGIN_ARG_INFO_EX(arginfo_gmp_setbit, 0, 0, 2)
117 ZEND_ARG_INFO(0, a)
118 ZEND_ARG_INFO(0, index)
119 ZEND_ARG_INFO(0, set_clear)
120 ZEND_END_ARG_INFO()
121
122 ZEND_BEGIN_ARG_INFO_EX(arginfo_gmp_bit, 0, 0, 2)
123 ZEND_ARG_INFO(0, a)
124 ZEND_ARG_INFO(0, index)
125 ZEND_END_ARG_INFO()
126
127 ZEND_BEGIN_ARG_INFO_EX(arginfo_gmp_scan, 0, 0, 2)
128 ZEND_ARG_INFO(0, a)
129 ZEND_ARG_INFO(0, start)
130 ZEND_END_ARG_INFO()
131
132 /* }}} */
133
134 ZEND_DECLARE_MODULE_GLOBALS(gmp)
135 static ZEND_GINIT_FUNCTION(gmp);
136
137 /* {{{ gmp_functions[]
138 */
139 const zend_function_entry gmp_functions[] = {
140 ZEND_FE(gmp_init, arginfo_gmp_init)
141 ZEND_FE(gmp_import, arginfo_gmp_import)
142 ZEND_FE(gmp_export, arginfo_gmp_export)
143 ZEND_FE(gmp_intval, arginfo_gmp_intval)
144 ZEND_FE(gmp_strval, arginfo_gmp_strval)
145 ZEND_FE(gmp_add, arginfo_gmp_binary)
146 ZEND_FE(gmp_sub, arginfo_gmp_binary)
147 ZEND_FE(gmp_mul, arginfo_gmp_binary)
148 ZEND_FE(gmp_div_qr, arginfo_gmp_div)
149 ZEND_FE(gmp_div_q, arginfo_gmp_div)
150 ZEND_FE(gmp_div_r, arginfo_gmp_div)
151 ZEND_FALIAS(gmp_div, gmp_div_q, arginfo_gmp_div)
152 ZEND_FE(gmp_mod, arginfo_gmp_binary)
153 ZEND_FE(gmp_divexact, arginfo_gmp_binary)
154 ZEND_FE(gmp_neg, arginfo_gmp_unary)
155 ZEND_FE(gmp_abs, arginfo_gmp_unary)
156 ZEND_FE(gmp_fact, arginfo_gmp_unary)
157 ZEND_FE(gmp_sqrt, arginfo_gmp_unary)
158 ZEND_FE(gmp_sqrtrem, arginfo_gmp_unary)
159 ZEND_FE(gmp_root, arginfo_gmp_root)
160 ZEND_FE(gmp_rootrem, arginfo_gmp_root)
161 ZEND_FE(gmp_pow, arginfo_gmp_pow)
162 ZEND_FE(gmp_powm, arginfo_gmp_powm)
163 ZEND_FE(gmp_perfect_square, arginfo_gmp_unary)
164 ZEND_FE(gmp_prob_prime, arginfo_gmp_prob_prime)
165 ZEND_FE(gmp_gcd, arginfo_gmp_binary)
166 ZEND_FE(gmp_gcdext, arginfo_gmp_binary)
167 ZEND_FE(gmp_invert, arginfo_gmp_binary)
168 ZEND_FE(gmp_jacobi, arginfo_gmp_binary)
169 ZEND_FE(gmp_legendre, arginfo_gmp_binary)
170 ZEND_FE(gmp_cmp, arginfo_gmp_binary)
171 ZEND_FE(gmp_sign, arginfo_gmp_unary)
172 ZEND_FE(gmp_random, arginfo_gmp_random)
173 ZEND_FE(gmp_random_bits, arginfo_gmp_random_bits)
174 ZEND_FE(gmp_random_range, arginfo_gmp_random_range)
175 ZEND_FE(gmp_and, arginfo_gmp_binary)
176 ZEND_FE(gmp_or, arginfo_gmp_binary)
177 ZEND_FE(gmp_com, arginfo_gmp_unary)
178 ZEND_FE(gmp_xor, arginfo_gmp_binary)
179 ZEND_FE(gmp_setbit, arginfo_gmp_setbit)
180 ZEND_FE(gmp_clrbit, arginfo_gmp_bit)
181 ZEND_FE(gmp_testbit, arginfo_gmp_bit)
182 ZEND_FE(gmp_scan0, arginfo_gmp_scan)
183 ZEND_FE(gmp_scan1, arginfo_gmp_scan)
184 ZEND_FE(gmp_popcount, arginfo_gmp_unary)
185 ZEND_FE(gmp_hamdist, arginfo_gmp_binary)
186 ZEND_FE(gmp_nextprime, arginfo_gmp_unary)
187 PHP_FE_END
188 };
189 /* }}} */
190
191 /* {{{ gmp_module_entry
192 */
193 zend_module_entry gmp_module_entry = {
194 STANDARD_MODULE_HEADER,
195 "gmp",
196 gmp_functions,
197 ZEND_MODULE_STARTUP_N(gmp),
198 NULL,
199 NULL,
200 ZEND_MODULE_DEACTIVATE_N(gmp),
201 ZEND_MODULE_INFO_N(gmp),
202 NO_VERSION_YET,
203 ZEND_MODULE_GLOBALS(gmp),
204 ZEND_GINIT(gmp),
205 NULL,
206 NULL,
207 STANDARD_MODULE_PROPERTIES_EX
208 };
209 /* }}} */
210
211 #ifdef COMPILE_DL_GMP
212 ZEND_GET_MODULE(gmp)
213 #endif
214
215 zend_class_entry *gmp_ce;
216 static zend_object_handlers gmp_object_handlers;
217
218 typedef struct _gmp_object {
219 zend_object std;
220 mpz_t num;
221 } gmp_object;
222
223 typedef struct _gmp_temp {
224 mpz_t num;
225 zend_bool is_used;
226 } gmp_temp_t;
227
228 #define GMP_ROUND_ZERO 0
229 #define GMP_ROUND_PLUSINF 1
230 #define GMP_ROUND_MINUSINF 2
231
232 #define GMP_MSW_FIRST (1 << 0)
233 #define GMP_LSW_FIRST (1 << 1)
234 #define GMP_LITTLE_ENDIAN (1 << 2)
235 #define GMP_BIG_ENDIAN (1 << 3)
236 #define GMP_NATIVE_ENDIAN (1 << 4)
237
238 #define GMP_42_OR_NEWER \
239 ((__GNU_MP_VERSION >= 5) || (__GNU_MP_VERSION >= 4 && __GNU_MP_VERSION_MINOR >= 2))
240
241 #define GMP_51_OR_NEWER \
242 ((__GNU_MP_VERSION >= 6) || (__GNU_MP_VERSION >= 5 && __GNU_MP_VERSION_MINOR >= 1))
243
244 /* The maximum base for input and output conversions is 62 from GMP 4.2
245 * onwards. */
246 #if GMP_42_OR_NEWER
247 # define MAX_BASE 62
248 #else
249 # define MAX_BASE 36
250 #endif
251
252 #define IS_GMP(zval) \
253 (Z_TYPE_P(zval) == IS_OBJECT && instanceof_function(Z_OBJCE_P(zval), gmp_ce TSRMLS_CC))
254
255 #define GET_GMP_FROM_ZVAL(zval) \
256 (((gmp_object *) zend_object_store_get_object((zval) TSRMLS_CC))->num)
257
258 /* The FETCH_GMP_ZVAL_* family of macros is used to fetch a gmp number
259 * (mpz_ptr) from a zval. If the zval is not a GMP instance, then we
260 * try to convert the value to a temporary gmp number using convert_to_gmp.
261 * This temporary number is stored in the temp argument, which is of type
262 * gmp_temp_t. This temporary value needs to be freed lateron using the
263 * FREE_GMP_TEMP macro.
264 *
265 * If the conversion to a gmp number fails, the macros return false.
266 * The _DEP / _DEP_DEP variants additionally free the temporary values
267 * passed in the last / last two arguments.
268 *
269 * If one zval can sometimes be fetched as a long you have to set the
270 * is_used member of the corresponding gmp_temp_t value to 0, otherwise
271 * the FREE_GMP_TEMP and *_DEP macros will not work properly.
272 *
273 * The three FETCH_GMP_ZVAL_* macros below are mostly copy & paste code
274 * as I couldn't find a way to combine them.
275 */
276
277 #define FREE_GMP_TEMP(temp) \
278 if (temp.is_used) { \
279 mpz_clear(temp.num); \
280 }
281
282 #define FETCH_GMP_ZVAL_DEP_DEP(gmpnumber, zval, temp, dep1, dep2) \
283 if (IS_GMP(zval)) { \
284 gmpnumber = GET_GMP_FROM_ZVAL(zval); \
285 temp.is_used = 0; \
286 } else { \
287 mpz_init(temp.num); \
288 if (convert_to_gmp(temp.num, zval, 0 TSRMLS_CC) == FAILURE) { \
289 mpz_clear(temp.num); \
290 FREE_GMP_TEMP(dep1); \
291 FREE_GMP_TEMP(dep2); \
292 RETURN_FALSE; \
293 } \
294 temp.is_used = 1; \
295 gmpnumber = temp.num; \
296 }
297
298 #define FETCH_GMP_ZVAL_DEP(gmpnumber, zval, temp, dep) \
299 if (IS_GMP(zval)) { \
300 gmpnumber = GET_GMP_FROM_ZVAL(zval); \
301 temp.is_used = 0; \
302 } else { \
303 mpz_init(temp.num); \
304 if (convert_to_gmp(temp.num, zval, 0 TSRMLS_CC) == FAILURE) { \
305 mpz_clear(temp.num); \
306 FREE_GMP_TEMP(dep); \
307 RETURN_FALSE; \
308 } \
309 temp.is_used = 1; \
310 gmpnumber = temp.num; \
311 }
312
313 #define FETCH_GMP_ZVAL(gmpnumber, zval, temp) \
314 if (IS_GMP(zval)) { \
315 gmpnumber = GET_GMP_FROM_ZVAL(zval); \
316 temp.is_used = 0; \
317 } else { \
318 mpz_init(temp.num); \
319 if (convert_to_gmp(temp.num, zval, 0 TSRMLS_CC) == FAILURE) { \
320 mpz_clear(temp.num); \
321 RETURN_FALSE; \
322 } \
323 temp.is_used = 1; \
324 gmpnumber = temp.num; \
325 }
326
327 #define INIT_GMP_RETVAL(gmpnumber) \
328 gmp_create_ex(return_value, &gmpnumber TSRMLS_CC)
329
330 static void gmp_strval(zval *result, mpz_t gmpnum, long base);
331 static int convert_to_gmp(mpz_t gmpnumber, zval *val, int base TSRMLS_DC);
332 static void gmp_cmp(zval *return_value, zval *a_arg, zval *b_arg TSRMLS_DC);
333
334 /*
335 * The gmp_*_op functions provide an implementation for several common types
336 * of GMP functions. The gmp_zval_(unary|binary)_*_op functions have to be manually
337 * passed zvals to work on, whereas the gmp_(unary|binary)_*_op macros already
338 * include parameter parsing.
339 */
340 typedef void (*gmp_unary_op_t)(mpz_ptr, mpz_srcptr);
341 typedef int (*gmp_unary_opl_t)(mpz_srcptr);
342
343 typedef void (*gmp_unary_ui_op_t)(mpz_ptr, unsigned long);
344
345 typedef void (*gmp_binary_op_t)(mpz_ptr, mpz_srcptr, mpz_srcptr);
346 typedef int (*gmp_binary_opl_t)(mpz_srcptr, mpz_srcptr);
347
348 typedef void (*gmp_binary_ui_op_t)(mpz_ptr, mpz_srcptr, unsigned long);
349 typedef void (*gmp_binary_op2_t)(mpz_ptr, mpz_ptr, mpz_srcptr, mpz_srcptr);
350 typedef void (*gmp_binary_ui_op2_t)(mpz_ptr, mpz_ptr, mpz_srcptr, unsigned long);
351
352 static inline void gmp_zval_binary_ui_op(zval *return_value, zval *a_arg, zval *b_arg, gmp_binary_op_t gmp_op, gmp_binary_ui_op_t gmp_ui_op, int check_b_zero TSRMLS_DC);
353 static inline void gmp_zval_binary_ui_op2(zval *return_value, zval *a_arg, zval *b_arg, gmp_binary_op2_t gmp_op, gmp_binary_ui_op2_t gmp_ui_op, int check_b_zero TSRMLS_DC);
354 static inline void gmp_zval_unary_op(zval *return_value, zval *a_arg, gmp_unary_op_t gmp_op TSRMLS_DC);
355 static inline void gmp_zval_unary_ui_op(zval *return_value, zval *a_arg, gmp_unary_ui_op_t gmp_op TSRMLS_DC);
356
357 /* Binary operations */
358 #define gmp_binary_ui_op(op, uop) _gmp_binary_ui_op(INTERNAL_FUNCTION_PARAM_PASSTHRU, op, uop, 0)
359 #define gmp_binary_op(op) _gmp_binary_ui_op(INTERNAL_FUNCTION_PARAM_PASSTHRU, op, NULL, 0)
360 #define gmp_binary_opl(op) _gmp_binary_opl(INTERNAL_FUNCTION_PARAM_PASSTHRU, op)
361 #define gmp_binary_ui_op_no_zero(op, uop) \
362 _gmp_binary_ui_op(INTERNAL_FUNCTION_PARAM_PASSTHRU, op, uop, 1)
363
364 /* Unary operations */
365 #define gmp_unary_op(op) _gmp_unary_op(INTERNAL_FUNCTION_PARAM_PASSTHRU, op)
366 #define gmp_unary_opl(op) _gmp_unary_opl(INTERNAL_FUNCTION_PARAM_PASSTHRU, op)
367 #define gmp_unary_ui_op(op) _gmp_unary_ui_op(INTERNAL_FUNCTION_PARAM_PASSTHRU, op)
368
gmp_get_long(zval * zv)369 static inline long gmp_get_long(zval *zv) /* {{{ */
370 {
371 if (Z_TYPE_P(zv) == IS_LONG) {
372 return Z_LVAL_P(zv);
373 } else {
374 zval tmp_zv;
375 MAKE_COPY_ZVAL(&zv, &tmp_zv);
376 convert_to_long(&tmp_zv);
377 return Z_LVAL(tmp_zv);
378 }
379 }
380 /* }}} */
381
gmp_free_object_storage(gmp_object * intern TSRMLS_DC)382 static void gmp_free_object_storage(gmp_object *intern TSRMLS_DC) /* {{{ */
383 {
384 mpz_clear(intern->num);
385
386 zend_object_std_dtor(&intern->std TSRMLS_CC);
387 efree(intern);
388 }
389 /* }}} */
390
gmp_create_object_ex(zend_class_entry * ce,mpz_ptr * gmpnum_target TSRMLS_DC)391 static inline zend_object_value gmp_create_object_ex(zend_class_entry *ce, mpz_ptr *gmpnum_target TSRMLS_DC) /* {{{ */
392 {
393 zend_object_value retval;
394 gmp_object *intern = emalloc(sizeof(gmp_object));
395
396 zend_object_std_init(&intern->std, ce TSRMLS_CC);
397 object_properties_init(&intern->std, ce);
398
399 mpz_init(intern->num);
400 *gmpnum_target = intern->num;
401
402 retval.handle = zend_objects_store_put(
403 intern, (zend_objects_store_dtor_t) zend_objects_destroy_object,
404 (zend_objects_free_object_storage_t) gmp_free_object_storage,
405 NULL TSRMLS_CC
406 );
407 retval.handlers = &gmp_object_handlers;
408
409 return retval;
410 }
411 /* }}} */
412
gmp_create_object(zend_class_entry * ce TSRMLS_DC)413 static zend_object_value gmp_create_object(zend_class_entry *ce TSRMLS_DC) /* {{{ */
414 {
415 mpz_ptr gmpnum_dummy;
416 return gmp_create_object_ex(ce, &gmpnum_dummy TSRMLS_CC);
417 }
418 /* }}} */
419
gmp_create_ex(zval * target,mpz_ptr * gmpnum_target TSRMLS_DC)420 static inline void gmp_create_ex(zval *target, mpz_ptr *gmpnum_target TSRMLS_DC) /* {{{ */
421 {
422 Z_TYPE_P(target) = IS_OBJECT;
423 Z_OBJVAL_P(target) = gmp_create_object_ex(gmp_ce, gmpnum_target TSRMLS_CC);
424 }
425 /* }}} */
426
gmp_create(mpz_ptr * gmpnum_target TSRMLS_DC)427 static zval *gmp_create(mpz_ptr *gmpnum_target TSRMLS_DC) /* {{{ */
428 {
429 zval *obj;
430 MAKE_STD_ZVAL(obj);
431 gmp_create_ex(obj, gmpnum_target TSRMLS_CC);
432 return obj;
433 }
434 /* }}} */
435
gmp_cast_object(zval * readobj,zval * writeobj,int type TSRMLS_DC)436 static int gmp_cast_object(zval *readobj, zval *writeobj, int type TSRMLS_DC) /* {{{ */
437 {
438 mpz_ptr gmpnum;
439 switch (type) {
440 case IS_STRING:
441 gmpnum = GET_GMP_FROM_ZVAL(readobj);
442 INIT_PZVAL(writeobj);
443 gmp_strval(writeobj, gmpnum, 10);
444 return SUCCESS;
445 case IS_LONG:
446 gmpnum = GET_GMP_FROM_ZVAL(readobj);
447 INIT_PZVAL(writeobj);
448 ZVAL_LONG(writeobj, mpz_get_si(gmpnum));
449 return SUCCESS;
450 case IS_DOUBLE:
451 gmpnum = GET_GMP_FROM_ZVAL(readobj);
452 INIT_PZVAL(writeobj);
453 ZVAL_DOUBLE(writeobj, mpz_get_d(gmpnum));
454 return SUCCESS;
455 default:
456 return FAILURE;
457 }
458 }
459 /* }}} */
460
gmp_get_debug_info(zval * obj,int * is_temp TSRMLS_DC)461 static HashTable *gmp_get_debug_info(zval *obj, int *is_temp TSRMLS_DC) /* {{{ */
462 {
463 HashTable *ht, *props = zend_std_get_properties(obj TSRMLS_CC);
464 mpz_ptr gmpnum = GET_GMP_FROM_ZVAL(obj);
465 zval *zv;
466
467 *is_temp = 1;
468 ALLOC_HASHTABLE(ht);
469 ZEND_INIT_SYMTABLE_EX(ht, zend_hash_num_elements(props) + 1, 0);
470 zend_hash_copy(ht, props, (copy_ctor_func_t) zval_add_ref, NULL, sizeof(zval *));
471
472 MAKE_STD_ZVAL(zv);
473 gmp_strval(zv, gmpnum, 10);
474 zend_hash_update(ht, "num", sizeof("num"), &zv, sizeof(zval *), NULL);
475
476 return ht;
477 }
478 /* }}} */
479
gmp_clone_obj(zval * obj TSRMLS_DC)480 static zend_object_value gmp_clone_obj(zval *obj TSRMLS_DC) /* {{{ */
481 {
482 gmp_object *old_object = zend_object_store_get_object(obj TSRMLS_CC);
483 zend_object_value new_object_val = gmp_create_object(Z_OBJCE_P(obj) TSRMLS_CC);
484 gmp_object *new_object = zend_object_store_get_object_by_handle(
485 new_object_val.handle TSRMLS_CC
486 );
487
488 zend_objects_clone_members(
489 &new_object->std, new_object_val,
490 &old_object->std, Z_OBJ_HANDLE_P(obj) TSRMLS_CC
491 );
492
493 mpz_set(new_object->num, old_object->num);
494
495 return new_object_val;
496 }
497 /* }}} */
498
shift_operator_helper(gmp_binary_ui_op_t op,zval * return_value,zval * op1,zval * op2 TSRMLS_DC)499 static void shift_operator_helper(gmp_binary_ui_op_t op, zval *return_value, zval *op1, zval *op2 TSRMLS_DC) {
500 zval op2_copy;
501 if (Z_TYPE_P(op2) != IS_LONG) {
502 op2_copy = *op2;
503 zval_copy_ctor(&op2_copy);
504 convert_to_long(&op2_copy);
505 op2 = &op2_copy;
506 }
507
508 if (Z_LVAL_P(op2) < 0) {
509 php_error_docref(NULL TSRMLS_CC, E_WARNING, "Shift cannot be negative");
510 RETVAL_FALSE;
511 } else {
512 mpz_ptr gmpnum_op, gmpnum_result;
513 gmp_temp_t temp;
514
515 FETCH_GMP_ZVAL(gmpnum_op, op1, temp);
516 INIT_GMP_RETVAL(gmpnum_result);
517 op(gmpnum_result, gmpnum_op, (unsigned long) Z_LVAL_P(op2));
518 FREE_GMP_TEMP(temp);
519 }
520 }
521
522 #define DO_BINARY_UI_OP_EX(op, uop, check_b_zero) \
523 gmp_zval_binary_ui_op( \
524 result, op1, op2, op, (gmp_binary_ui_op_t) uop, \
525 check_b_zero TSRMLS_CC \
526 ); \
527 return SUCCESS;
528
529 #define DO_BINARY_UI_OP(op) DO_BINARY_UI_OP_EX(op, op ## _ui, 0)
530 #define DO_BINARY_OP(op) DO_BINARY_UI_OP_EX(op, NULL, 0)
531
532 #define DO_UNARY_OP(op) \
533 gmp_zval_unary_op(result, op1, op TSRMLS_CC); \
534 return SUCCESS;
535
gmp_do_operation_ex(zend_uchar opcode,zval * result,zval * op1,zval * op2 TSRMLS_DC)536 static int gmp_do_operation_ex(zend_uchar opcode, zval *result, zval *op1, zval *op2 TSRMLS_DC) /* {{{ */
537 {
538 switch (opcode) {
539 case ZEND_ADD:
540 DO_BINARY_UI_OP(mpz_add);
541 case ZEND_SUB:
542 DO_BINARY_UI_OP(mpz_sub);
543 case ZEND_MUL:
544 DO_BINARY_UI_OP(mpz_mul);
545 case ZEND_POW:
546 shift_operator_helper(mpz_pow_ui, result, op1, op2 TSRMLS_CC);
547 return SUCCESS;
548 case ZEND_DIV:
549 DO_BINARY_UI_OP_EX(mpz_tdiv_q, mpz_tdiv_q_ui, 1);
550 case ZEND_MOD:
551 DO_BINARY_UI_OP_EX(mpz_mod, mpz_mod_ui, 1);
552 case ZEND_SL:
553 shift_operator_helper(mpz_mul_2exp, result, op1, op2 TSRMLS_CC);
554 return SUCCESS;
555 case ZEND_SR:
556 shift_operator_helper(mpz_fdiv_q_2exp, result, op1, op2 TSRMLS_CC);
557 return SUCCESS;
558 case ZEND_BW_OR:
559 DO_BINARY_OP(mpz_ior);
560 case ZEND_BW_AND:
561 DO_BINARY_OP(mpz_and);
562 case ZEND_BW_XOR:
563 DO_BINARY_OP(mpz_xor);
564 case ZEND_BW_NOT:
565 DO_UNARY_OP(mpz_com);
566
567 default:
568 return FAILURE;
569 }
570 }
571 /* }}} */
572
gmp_do_operation(zend_uchar opcode,zval * result,zval * op1,zval * op2 TSRMLS_DC)573 static int gmp_do_operation(zend_uchar opcode, zval *result, zval *op1, zval *op2 TSRMLS_DC) /* {{{ */
574 {
575 zval op1_copy;
576 int retval;
577
578 if (result == op1) {
579 ZVAL_COPY_VALUE(&op1_copy, op1);
580 op1 = &op1_copy;
581 }
582
583 retval = gmp_do_operation_ex(opcode, result, op1, op2 TSRMLS_CC);
584
585 if (retval == SUCCESS && op1 == &op1_copy) {
586 zval_dtor(op1);
587 }
588
589 return retval;
590 }
591 /* }}} */
592
gmp_compare(zval * result,zval * op1,zval * op2 TSRMLS_DC)593 static int gmp_compare(zval *result, zval *op1, zval *op2 TSRMLS_DC) /* {{{ */
594 {
595 gmp_cmp(result, op1, op2 TSRMLS_CC);
596 if (Z_TYPE_P(result) == IS_BOOL) {
597 ZVAL_LONG(result, 1);
598 }
599 return SUCCESS;
600 }
601 /* }}} */
602
gmp_serialize(zval * object,unsigned char ** buffer,zend_uint * buf_len,zend_serialize_data * data TSRMLS_DC)603 static int gmp_serialize(zval *object, unsigned char **buffer, zend_uint *buf_len, zend_serialize_data *data TSRMLS_DC) /* {{{ */
604 {
605 mpz_ptr gmpnum = GET_GMP_FROM_ZVAL(object);
606 smart_str buf = {0};
607 zval zv, *zv_ptr = &zv;
608 php_serialize_data_t serialize_data = (php_serialize_data_t) data;
609
610 PHP_VAR_SERIALIZE_INIT(serialize_data);
611 INIT_PZVAL(zv_ptr);
612
613 gmp_strval(zv_ptr, gmpnum, 10);
614 php_var_serialize(&buf, &zv_ptr, &serialize_data TSRMLS_CC);
615 zval_dtor(zv_ptr);
616
617 Z_ARRVAL_P(zv_ptr) = zend_std_get_properties(object TSRMLS_CC);
618 Z_TYPE_P(zv_ptr) = IS_ARRAY;
619 php_var_serialize(&buf, &zv_ptr, &serialize_data TSRMLS_CC);
620
621 PHP_VAR_SERIALIZE_DESTROY(serialize_data);
622 *buffer = (unsigned char *) buf.c;
623 *buf_len = buf.len;
624
625 return SUCCESS;
626 }
627 /* }}} */
628
gmp_unserialize(zval ** object,zend_class_entry * ce,const unsigned char * buf,zend_uint buf_len,zend_unserialize_data * data TSRMLS_DC)629 static int gmp_unserialize(zval **object, zend_class_entry *ce, const unsigned char *buf, zend_uint buf_len, zend_unserialize_data *data TSRMLS_DC) /* {{{ */
630 {
631 mpz_ptr gmpnum;
632 const unsigned char *p, *max;
633 zval *zv_ptr;
634 int retval = FAILURE;
635 php_unserialize_data_t unserialize_data = (php_unserialize_data_t) data;
636
637 PHP_VAR_UNSERIALIZE_INIT(unserialize_data);
638 gmp_create_ex(*object, &gmpnum TSRMLS_CC);
639
640 p = buf;
641 max = buf + buf_len;
642
643 ALLOC_INIT_ZVAL(zv_ptr);
644 if (!php_var_unserialize(&zv_ptr, &p, max, &unserialize_data TSRMLS_CC)
645 || Z_TYPE_P(zv_ptr) != IS_STRING
646 || convert_to_gmp(gmpnum, zv_ptr, 10 TSRMLS_CC) == FAILURE
647 ) {
648 zend_throw_exception(NULL, "Could not unserialize number", 0 TSRMLS_CC);
649 goto exit;
650 }
651 var_push_dtor_no_addref(&unserialize_data, &zv_ptr);
652
653 ALLOC_INIT_ZVAL(zv_ptr);
654 if (!php_var_unserialize(&zv_ptr, &p, max, &unserialize_data TSRMLS_CC)
655 || Z_TYPE_P(zv_ptr) != IS_ARRAY
656 ) {
657 zend_throw_exception(NULL, "Could not unserialize properties", 0 TSRMLS_CC);
658 goto exit;
659 }
660
661 if (zend_hash_num_elements(Z_ARRVAL_P(zv_ptr)) != 0) {
662 zend_hash_copy(
663 zend_std_get_properties(*object TSRMLS_CC), Z_ARRVAL_P(zv_ptr),
664 (copy_ctor_func_t) zval_add_ref, NULL, sizeof(zval *)
665 );
666 }
667
668 retval = SUCCESS;
669 exit:
670 var_push_dtor_no_addref(&unserialize_data, &zv_ptr);
671 PHP_VAR_UNSERIALIZE_DESTROY(unserialize_data);
672 return retval;
673 }
674 /* }}} */
675
676 /* {{{ ZEND_GINIT_FUNCTION
677 */
ZEND_GINIT_FUNCTION(gmp)678 static ZEND_GINIT_FUNCTION(gmp)
679 {
680 gmp_globals->rand_initialized = 0;
681 }
682 /* }}} */
683
684 /* {{{ ZEND_MINIT_FUNCTION
685 */
ZEND_MINIT_FUNCTION(gmp)686 ZEND_MINIT_FUNCTION(gmp)
687 {
688 zend_class_entry tmp_ce;
689 INIT_CLASS_ENTRY(tmp_ce, "GMP", NULL);
690 gmp_ce = zend_register_internal_class(&tmp_ce TSRMLS_CC);
691 gmp_ce->create_object = gmp_create_object;
692 gmp_ce->serialize = gmp_serialize;
693 gmp_ce->unserialize = gmp_unserialize;
694
695 memcpy(&gmp_object_handlers, zend_get_std_object_handlers(), sizeof(zend_object_handlers));
696 gmp_object_handlers.cast_object = gmp_cast_object;
697 gmp_object_handlers.get_debug_info = gmp_get_debug_info;
698 gmp_object_handlers.clone_obj = gmp_clone_obj;
699 gmp_object_handlers.do_operation = gmp_do_operation;
700 gmp_object_handlers.compare = gmp_compare;
701
702 REGISTER_LONG_CONSTANT("GMP_ROUND_ZERO", GMP_ROUND_ZERO, CONST_CS | CONST_PERSISTENT);
703 REGISTER_LONG_CONSTANT("GMP_ROUND_PLUSINF", GMP_ROUND_PLUSINF, CONST_CS | CONST_PERSISTENT);
704 REGISTER_LONG_CONSTANT("GMP_ROUND_MINUSINF", GMP_ROUND_MINUSINF, CONST_CS | CONST_PERSISTENT);
705 #ifdef mpir_version
706 REGISTER_STRING_CONSTANT("GMP_MPIR_VERSION", (char *)mpir_version, CONST_CS | CONST_PERSISTENT);
707 #endif
708 REGISTER_STRING_CONSTANT("GMP_VERSION", (char *)gmp_version, CONST_CS | CONST_PERSISTENT);
709
710 REGISTER_LONG_CONSTANT("GMP_MSW_FIRST", GMP_MSW_FIRST, CONST_CS | CONST_PERSISTENT);
711 REGISTER_LONG_CONSTANT("GMP_LSW_FIRST", GMP_LSW_FIRST, CONST_CS | CONST_PERSISTENT);
712 REGISTER_LONG_CONSTANT("GMP_LITTLE_ENDIAN", GMP_LITTLE_ENDIAN, CONST_CS | CONST_PERSISTENT);
713 REGISTER_LONG_CONSTANT("GMP_BIG_ENDIAN", GMP_BIG_ENDIAN, CONST_CS | CONST_PERSISTENT);
714 REGISTER_LONG_CONSTANT("GMP_NATIVE_ENDIAN", GMP_NATIVE_ENDIAN, CONST_CS | CONST_PERSISTENT);
715
716 return SUCCESS;
717 }
718 /* }}} */
719
720 /* {{{ ZEND_RSHUTDOWN_FUNCTION
721 */
ZEND_MODULE_DEACTIVATE_D(gmp)722 ZEND_MODULE_DEACTIVATE_D(gmp)
723 {
724 if (GMPG(rand_initialized)) {
725 gmp_randclear(GMPG(rand_state));
726 GMPG(rand_initialized) = 0;
727 }
728
729 return SUCCESS;
730 }
731 /* }}} */
732
733 /* {{{ ZEND_MINFO_FUNCTION
734 */
ZEND_MODULE_INFO_D(gmp)735 ZEND_MODULE_INFO_D(gmp)
736 {
737 php_info_print_table_start();
738 php_info_print_table_row(2, "gmp support", "enabled");
739 #ifdef mpir_version
740 php_info_print_table_row(2, "MPIR version", mpir_version);
741 #else
742 php_info_print_table_row(2, "GMP version", gmp_version);
743 #endif
744 php_info_print_table_end();
745 }
746 /* }}} */
747
748
749 /* {{{ convert_to_gmp
750 * Convert zval to be gmp number */
convert_to_gmp(mpz_t gmpnumber,zval * val,int base TSRMLS_DC)751 static int convert_to_gmp(mpz_t gmpnumber, zval *val, int base TSRMLS_DC)
752 {
753 switch (Z_TYPE_P(val)) {
754 case IS_LONG:
755 case IS_BOOL: {
756 mpz_set_si(gmpnumber, gmp_get_long(val));
757 return SUCCESS;
758 }
759 case IS_STRING: {
760 char *numstr = Z_STRVAL_P(val);
761 int skip_lead = 0;
762 int ret;
763
764 if (Z_STRLEN_P(val) > 2 && numstr[0] == '0') {
765 if ((base == 0 || base == 16) && (numstr[1] == 'x' || numstr[1] == 'X')) {
766 base = 16;
767 skip_lead = 1;
768 } else if ((base == 0 || base == 2) && (numstr[1] == 'b' || numstr[1] == 'B')) {
769 base = 2;
770 skip_lead = 1;
771 }
772 }
773
774 ret = mpz_set_str(gmpnumber, (skip_lead ? &numstr[2] : numstr), base);
775 if (-1 == ret) {
776 php_error_docref(NULL TSRMLS_CC, E_WARNING,
777 "Unable to convert variable to GMP - string is not an integer");
778 return FAILURE;
779 }
780
781 return SUCCESS;
782 }
783 default:
784 php_error_docref(NULL TSRMLS_CC, E_WARNING,
785 "Unable to convert variable to GMP - wrong type");
786 return FAILURE;
787 }
788 }
789 /* }}} */
790
gmp_strval(zval * result,mpz_t gmpnum,long base)791 static void gmp_strval(zval *result, mpz_t gmpnum, long base) /* {{{ */
792 {
793 int num_len;
794 char *out_string;
795
796 num_len = mpz_sizeinbase(gmpnum, abs(base));
797 if (mpz_sgn(gmpnum) < 0) {
798 num_len++;
799 }
800
801 out_string = emalloc(num_len + 1);
802 mpz_get_str(out_string, base, gmpnum);
803
804 /*
805 * From GMP documentation for mpz_sizeinbase():
806 * The returned value will be exact or 1 too big. If base is a power of
807 * 2, the returned value will always be exact.
808 *
809 * So let's check to see if we already have a \0 byte...
810 */
811
812 if (out_string[num_len - 1] == '\0') {
813 num_len--;
814 } else {
815 out_string[num_len] = '\0';
816 }
817
818 ZVAL_STRINGL(result, out_string, num_len, 0);
819 }
820 /* }}} */
821
gmp_cmp(zval * return_value,zval * a_arg,zval * b_arg TSRMLS_DC)822 static void gmp_cmp(zval *return_value, zval *a_arg, zval *b_arg TSRMLS_DC) /* {{{ */
823 {
824 mpz_ptr gmpnum_a, gmpnum_b;
825 gmp_temp_t temp_a, temp_b;
826 zend_bool use_si = 0;
827 long res;
828
829 FETCH_GMP_ZVAL(gmpnum_a, a_arg, temp_a);
830
831 if (Z_TYPE_P(b_arg) == IS_LONG) {
832 use_si = 1;
833 temp_b.is_used = 0;
834 } else {
835 FETCH_GMP_ZVAL_DEP(gmpnum_b, b_arg, temp_b, temp_a);
836 }
837
838 if (use_si) {
839 res = mpz_cmp_si(gmpnum_a, Z_LVAL_P(b_arg));
840 } else {
841 res = mpz_cmp(gmpnum_a, gmpnum_b);
842 }
843
844 FREE_GMP_TEMP(temp_a);
845 FREE_GMP_TEMP(temp_b);
846
847 RETURN_LONG(res);
848 }
849 /* }}} */
850
851 /* {{{ gmp_zval_binary_ui_op
852 Execute GMP binary operation.
853 */
gmp_zval_binary_ui_op(zval * return_value,zval * a_arg,zval * b_arg,gmp_binary_op_t gmp_op,gmp_binary_ui_op_t gmp_ui_op,int check_b_zero TSRMLS_DC)854 static inline void gmp_zval_binary_ui_op(zval *return_value, zval *a_arg, zval *b_arg, gmp_binary_op_t gmp_op, gmp_binary_ui_op_t gmp_ui_op, int check_b_zero TSRMLS_DC)
855 {
856 mpz_ptr gmpnum_a, gmpnum_b, gmpnum_result;
857 int use_ui = 0;
858 gmp_temp_t temp_a, temp_b;
859
860 FETCH_GMP_ZVAL(gmpnum_a, a_arg, temp_a);
861
862 if (gmp_ui_op && Z_TYPE_P(b_arg) == IS_LONG && Z_LVAL_P(b_arg) >= 0) {
863 use_ui = 1;
864 temp_b.is_used = 0;
865 } else {
866 FETCH_GMP_ZVAL_DEP(gmpnum_b, b_arg, temp_b, temp_a);
867 }
868
869 if (check_b_zero) {
870 int b_is_zero = 0;
871 if (use_ui) {
872 b_is_zero = (Z_LVAL_P(b_arg) == 0);
873 } else {
874 b_is_zero = !mpz_cmp_ui(gmpnum_b, 0);
875 }
876
877 if (b_is_zero) {
878 php_error_docref(NULL TSRMLS_CC, E_WARNING, "Zero operand not allowed");
879 FREE_GMP_TEMP(temp_a);
880 FREE_GMP_TEMP(temp_b);
881 RETURN_FALSE;
882 }
883 }
884
885 INIT_GMP_RETVAL(gmpnum_result);
886
887 if (use_ui) {
888 gmp_ui_op(gmpnum_result, gmpnum_a, (unsigned long) Z_LVAL_P(b_arg));
889 } else {
890 gmp_op(gmpnum_result, gmpnum_a, gmpnum_b);
891 }
892
893 FREE_GMP_TEMP(temp_a);
894 FREE_GMP_TEMP(temp_b);
895 }
896 /* }}} */
897
898 /* {{{ gmp_zval_binary_ui_op2
899 Execute GMP binary operation which returns 2 values.
900 */
gmp_zval_binary_ui_op2(zval * return_value,zval * a_arg,zval * b_arg,gmp_binary_op2_t gmp_op,gmp_binary_ui_op2_t gmp_ui_op,int check_b_zero TSRMLS_DC)901 static inline void gmp_zval_binary_ui_op2(zval *return_value, zval *a_arg, zval *b_arg, gmp_binary_op2_t gmp_op, gmp_binary_ui_op2_t gmp_ui_op, int check_b_zero TSRMLS_DC)
902 {
903 mpz_ptr gmpnum_a, gmpnum_b, gmpnum_result1, gmpnum_result2;
904 int use_ui = 0;
905 gmp_temp_t temp_a, temp_b;
906
907 FETCH_GMP_ZVAL(gmpnum_a, a_arg, temp_a);
908
909 if (gmp_ui_op && Z_TYPE_P(b_arg) == IS_LONG && Z_LVAL_P(b_arg) >= 0) {
910 /* use _ui function */
911 use_ui = 1;
912 temp_b.is_used = 0;
913 } else {
914 FETCH_GMP_ZVAL_DEP(gmpnum_b, b_arg, temp_b, temp_a);
915 }
916
917 if (check_b_zero) {
918 int b_is_zero = 0;
919 if (use_ui) {
920 b_is_zero = (Z_LVAL_P(b_arg) == 0);
921 } else {
922 b_is_zero = !mpz_cmp_ui(gmpnum_b, 0);
923 }
924
925 if (b_is_zero) {
926 php_error_docref(NULL TSRMLS_CC, E_WARNING, "Zero operand not allowed");
927 FREE_GMP_TEMP(temp_a);
928 FREE_GMP_TEMP(temp_b);
929 RETURN_FALSE;
930 }
931 }
932
933 array_init(return_value);
934 add_index_zval(return_value, 0, gmp_create(&gmpnum_result1 TSRMLS_CC));
935 add_index_zval(return_value, 1, gmp_create(&gmpnum_result2 TSRMLS_CC));
936
937 if (use_ui) {
938 gmp_ui_op(gmpnum_result1, gmpnum_result2, gmpnum_a, (unsigned long) Z_LVAL_P(b_arg));
939 } else {
940 gmp_op(gmpnum_result1, gmpnum_result2, gmpnum_a, gmpnum_b);
941 }
942
943 FREE_GMP_TEMP(temp_a);
944 FREE_GMP_TEMP(temp_b);
945 }
946 /* }}} */
947
948 /* {{{ _gmp_binary_ui_op
949 */
_gmp_binary_ui_op(INTERNAL_FUNCTION_PARAMETERS,gmp_binary_op_t gmp_op,gmp_binary_ui_op_t gmp_ui_op,int check_b_zero)950 static inline void _gmp_binary_ui_op(INTERNAL_FUNCTION_PARAMETERS, gmp_binary_op_t gmp_op, gmp_binary_ui_op_t gmp_ui_op, int check_b_zero)
951 {
952 zval *a_arg, *b_arg;
953
954 if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zz", &a_arg, &b_arg) == FAILURE){
955 return;
956 }
957
958 gmp_zval_binary_ui_op(return_value, a_arg, b_arg, gmp_op, gmp_ui_op, check_b_zero TSRMLS_CC);
959 }
960 /* }}} */
961
962 /* Unary operations */
963
964 /* {{{ gmp_zval_unary_op
965 */
gmp_zval_unary_op(zval * return_value,zval * a_arg,gmp_unary_op_t gmp_op TSRMLS_DC)966 static inline void gmp_zval_unary_op(zval *return_value, zval *a_arg, gmp_unary_op_t gmp_op TSRMLS_DC)
967 {
968 mpz_ptr gmpnum_a, gmpnum_result;
969 gmp_temp_t temp_a;
970
971 FETCH_GMP_ZVAL(gmpnum_a, a_arg, temp_a);
972
973 INIT_GMP_RETVAL(gmpnum_result);
974 gmp_op(gmpnum_result, gmpnum_a);
975
976 FREE_GMP_TEMP(temp_a);
977 }
978 /* }}} */
979
980 /* {{{ gmp_zval_unary_ui_op
981 */
gmp_zval_unary_ui_op(zval * return_value,zval * a_arg,gmp_unary_ui_op_t gmp_op TSRMLS_DC)982 static inline void gmp_zval_unary_ui_op(zval *return_value, zval *a_arg, gmp_unary_ui_op_t gmp_op TSRMLS_DC)
983 {
984 mpz_ptr gmpnum_result;
985
986 INIT_GMP_RETVAL(gmpnum_result);
987 gmp_op(gmpnum_result, gmp_get_long(a_arg));
988 }
989 /* }}} */
990
991 /* {{{ _gmp_unary_ui_op
992 Execute GMP unary operation.
993 */
_gmp_unary_ui_op(INTERNAL_FUNCTION_PARAMETERS,gmp_unary_ui_op_t gmp_op)994 static inline void _gmp_unary_ui_op(INTERNAL_FUNCTION_PARAMETERS, gmp_unary_ui_op_t gmp_op)
995 {
996 zval *a_arg;
997
998 if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &a_arg) == FAILURE){
999 return;
1000 }
1001
1002 gmp_zval_unary_ui_op(return_value, a_arg, gmp_op TSRMLS_CC);
1003 }
1004 /* }}} */
1005
1006 /* {{{ _gmp_unary_op
1007 */
_gmp_unary_op(INTERNAL_FUNCTION_PARAMETERS,gmp_unary_op_t gmp_op)1008 static inline void _gmp_unary_op(INTERNAL_FUNCTION_PARAMETERS, gmp_unary_op_t gmp_op)
1009 {
1010 zval *a_arg;
1011
1012 if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &a_arg) == FAILURE){
1013 return;
1014 }
1015
1016 gmp_zval_unary_op(return_value, a_arg, gmp_op TSRMLS_CC);
1017 }
1018 /* }}} */
1019
1020 /* {{{ _gmp_unary_opl
1021 */
_gmp_unary_opl(INTERNAL_FUNCTION_PARAMETERS,gmp_unary_opl_t gmp_op)1022 static inline void _gmp_unary_opl(INTERNAL_FUNCTION_PARAMETERS, gmp_unary_opl_t gmp_op)
1023 {
1024 zval *a_arg;
1025 mpz_ptr gmpnum_a;
1026 gmp_temp_t temp_a;
1027
1028 if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &a_arg) == FAILURE){
1029 return;
1030 }
1031
1032 FETCH_GMP_ZVAL(gmpnum_a, a_arg, temp_a);
1033 RETVAL_LONG(gmp_op(gmpnum_a));
1034 FREE_GMP_TEMP(temp_a);
1035 }
1036 /* }}} */
1037
1038 /* {{{ _gmp_binary_opl
1039 */
_gmp_binary_opl(INTERNAL_FUNCTION_PARAMETERS,gmp_binary_opl_t gmp_op)1040 static inline void _gmp_binary_opl(INTERNAL_FUNCTION_PARAMETERS, gmp_binary_opl_t gmp_op)
1041 {
1042 zval *a_arg, *b_arg;
1043 mpz_ptr gmpnum_a, gmpnum_b;
1044 gmp_temp_t temp_a, temp_b;
1045
1046 if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zz", &a_arg, &b_arg) == FAILURE){
1047 return;
1048 }
1049
1050 FETCH_GMP_ZVAL(gmpnum_a, a_arg, temp_a);
1051 FETCH_GMP_ZVAL_DEP(gmpnum_b, b_arg, temp_b, temp_a);
1052
1053 RETVAL_LONG(gmp_op(gmpnum_a, gmpnum_b));
1054
1055 FREE_GMP_TEMP(temp_a);
1056 FREE_GMP_TEMP(temp_b);
1057 }
1058 /* }}} */
1059
1060 /* {{{ proto GMP gmp_init(mixed number [, int base])
1061 Initializes GMP number */
ZEND_FUNCTION(gmp_init)1062 ZEND_FUNCTION(gmp_init)
1063 {
1064 zval *number_arg;
1065 mpz_ptr gmpnumber;
1066 long base = 0;
1067
1068 if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z|l", &number_arg, &base) == FAILURE) {
1069 return;
1070 }
1071
1072 if (base && (base < 2 || base > MAX_BASE)) {
1073 php_error_docref(NULL TSRMLS_CC, E_WARNING, "Bad base for conversion: %ld (should be between 2 and %d)", base, MAX_BASE);
1074 RETURN_FALSE;
1075 }
1076
1077 INIT_GMP_RETVAL(gmpnumber);
1078 if (convert_to_gmp(gmpnumber, number_arg, base TSRMLS_CC) == FAILURE) {
1079 zval_dtor(return_value);
1080 RETURN_FALSE;
1081 }
1082 }
1083 /* }}} */
1084
gmp_import_export_validate(long size,long options,int * order,int * endian TSRMLS_DC)1085 int gmp_import_export_validate(long size, long options, int *order, int *endian TSRMLS_DC)
1086 {
1087 if (size < 1) {
1088 php_error_docref(NULL TSRMLS_CC, E_WARNING,
1089 "Word size must be positive, %ld given", size);
1090 return FAILURE;
1091 }
1092
1093 switch (options & (GMP_LSW_FIRST | GMP_MSW_FIRST)) {
1094 case GMP_LSW_FIRST:
1095 *order = -1;
1096 break;
1097 case GMP_MSW_FIRST:
1098 case 0: /* default */
1099 *order = 1;
1100 break;
1101 default:
1102 php_error_docref(NULL TSRMLS_CC, E_WARNING,
1103 "Invalid options: Conflicting word orders");
1104 return FAILURE;
1105 }
1106
1107 switch (options & (GMP_LITTLE_ENDIAN | GMP_BIG_ENDIAN | GMP_NATIVE_ENDIAN)) {
1108 case GMP_LITTLE_ENDIAN:
1109 *endian = -1;
1110 break;
1111 case GMP_BIG_ENDIAN:
1112 *endian = 1;
1113 break;
1114 case GMP_NATIVE_ENDIAN:
1115 case 0: /* default */
1116 *endian = 0;
1117 break;
1118 default:
1119 php_error_docref(NULL TSRMLS_CC, E_WARNING,
1120 "Invalid options: Conflicting word endianness");
1121 return FAILURE;
1122 }
1123
1124 return SUCCESS;
1125 }
1126
1127 /* {{{ proto GMP gmp_import(string data [, int word_size = 1, int options = GMP_MSW_FIRST | GMP_NATIVE_ENDIAN])
1128 Imports a GMP number from a binary string */
ZEND_FUNCTION(gmp_import)1129 ZEND_FUNCTION(gmp_import)
1130 {
1131 char *data;
1132 int data_len;
1133 long size = 1;
1134 long options = GMP_MSW_FIRST | GMP_NATIVE_ENDIAN;
1135 int order, endian;
1136 mpz_ptr gmpnumber;
1137
1138 if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|ll", &data, &data_len, &size, &options) == FAILURE) {
1139 return;
1140 }
1141
1142 if (gmp_import_export_validate(size, options, &order, &endian TSRMLS_CC) == FAILURE) {
1143 RETURN_FALSE;
1144 }
1145
1146 if ((data_len % size) != 0) {
1147 php_error_docref(NULL TSRMLS_CC, E_WARNING,
1148 "Input length must be a multiple of word size");
1149 RETURN_FALSE;
1150 }
1151
1152 INIT_GMP_RETVAL(gmpnumber);
1153
1154 mpz_import(gmpnumber, data_len / size, order, size, endian, 0, data);
1155 }
1156 /* }}} */
1157
1158 /* {{{ proto string gmp_export(GMP gmpnumber [, int word_size = 1, int options = GMP_MSW_FIRST | GMP_NATIVE_ENDIAN])
1159 Exports a GMP number to a binary string */
ZEND_FUNCTION(gmp_export)1160 ZEND_FUNCTION(gmp_export)
1161 {
1162 zval *gmpnumber_arg;
1163 long size = 1;
1164 long options = GMP_MSW_FIRST | GMP_NATIVE_ENDIAN;
1165 int order, endian;
1166 mpz_ptr gmpnumber;
1167 gmp_temp_t temp_a;
1168
1169 if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z|ll", &gmpnumber_arg, &size, &options) == FAILURE) {
1170 return;
1171 }
1172
1173 if (gmp_import_export_validate(size, options, &order, &endian TSRMLS_CC) == FAILURE) {
1174 RETURN_FALSE;
1175 }
1176
1177 FETCH_GMP_ZVAL(gmpnumber, gmpnumber_arg, temp_a);
1178
1179 if (mpz_sgn(gmpnumber) == 0) {
1180 RETURN_EMPTY_STRING();
1181 } else {
1182 size_t bits_per_word = size * 8;
1183 size_t count = (mpz_sizeinbase(gmpnumber, 2) + bits_per_word - 1) / bits_per_word;
1184 size_t out_len = count * size;
1185
1186 char *out_string = emalloc(out_len + 1);
1187 mpz_export(out_string, NULL, order, size, endian, 0, gmpnumber);
1188 out_string[out_len] = '\0';
1189
1190 RETURN_STRINGL(out_string, out_len, 0);
1191 }
1192
1193 FREE_GMP_TEMP(temp_a);
1194 }
1195 /* }}} */
1196
1197 /* {{{ proto int gmp_intval(mixed gmpnumber)
1198 Gets signed long value of GMP number */
ZEND_FUNCTION(gmp_intval)1199 ZEND_FUNCTION(gmp_intval)
1200 {
1201 zval *gmpnumber_arg;
1202
1203 if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &gmpnumber_arg) == FAILURE){
1204 return;
1205 }
1206
1207 if (IS_GMP(gmpnumber_arg)) {
1208 RETVAL_LONG(mpz_get_si(GET_GMP_FROM_ZVAL(gmpnumber_arg)));
1209 } else {
1210 RETVAL_LONG(gmp_get_long(gmpnumber_arg));
1211 }
1212 }
1213 /* }}} */
1214
1215 /* {{{ proto string gmp_strval(mixed gmpnumber [, int base])
1216 Gets string representation of GMP number */
ZEND_FUNCTION(gmp_strval)1217 ZEND_FUNCTION(gmp_strval)
1218 {
1219 zval *gmpnumber_arg;
1220 long base = 10;
1221 mpz_ptr gmpnum;
1222 gmp_temp_t temp_a;
1223
1224 if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z|l", &gmpnumber_arg, &base) == FAILURE) {
1225 return;
1226 }
1227
1228 #if MAX_BASE == 62
1229 /* Although the maximum base in general in GMP >= 4.2 is 62, mpz_get_str()
1230 * is explicitly limited to -36 when dealing with negative bases. */
1231 if ((base < 2 && base > -2) || base > MAX_BASE || base < -36) {
1232 php_error_docref(NULL TSRMLS_CC, E_WARNING, "Bad base for conversion: %ld (should be between 2 and %d or -2 and -36)", base, MAX_BASE);
1233 #else
1234 if (base < 2 || base > MAX_BASE) {
1235 php_error_docref(NULL TSRMLS_CC, E_WARNING, "Bad base for conversion: %ld (should be between 2 and %d)", base, MAX_BASE);
1236 #endif
1237 RETURN_FALSE;
1238 }
1239
1240 FETCH_GMP_ZVAL(gmpnum, gmpnumber_arg, temp_a);
1241
1242 gmp_strval(return_value, gmpnum, base);
1243
1244 FREE_GMP_TEMP(temp_a);
1245 }
1246 /* }}} */
1247
1248 /* {{{ proto GMP gmp_add(mixed a, mixed b)
1249 Add a and b */
1250 ZEND_FUNCTION(gmp_add)
1251 {
1252 gmp_binary_ui_op(mpz_add, mpz_add_ui);
1253 }
1254 /* }}} */
1255
1256 /* {{{ proto GMP gmp_sub(mixed a, mixed b)
1257 Subtract b from a */
1258 ZEND_FUNCTION(gmp_sub)
1259 {
1260 gmp_binary_ui_op(mpz_sub, mpz_sub_ui);
1261 }
1262 /* }}} */
1263
1264 /* {{{ proto GMP gmp_mul(mixed a, mixed b)
1265 Multiply a and b */
1266 ZEND_FUNCTION(gmp_mul)
1267 {
1268 gmp_binary_ui_op(mpz_mul, mpz_mul_ui);
1269 }
1270 /* }}} */
1271
1272 /* {{{ proto array gmp_div_qr(mixed a, mixed b [, int round])
1273 Divide a by b, returns quotient and reminder */
1274 ZEND_FUNCTION(gmp_div_qr)
1275 {
1276 zval *a_arg, *b_arg;
1277 long round = GMP_ROUND_ZERO;
1278
1279 if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zz|l", &a_arg, &b_arg, &round) == FAILURE) {
1280 return;
1281 }
1282
1283 switch (round) {
1284 case GMP_ROUND_ZERO:
1285 gmp_zval_binary_ui_op2(return_value, a_arg, b_arg, mpz_tdiv_qr, (gmp_binary_ui_op2_t) mpz_tdiv_qr_ui, 1 TSRMLS_CC);
1286 break;
1287 case GMP_ROUND_PLUSINF:
1288 gmp_zval_binary_ui_op2(return_value, a_arg, b_arg, mpz_cdiv_qr, (gmp_binary_ui_op2_t) mpz_cdiv_qr_ui, 1 TSRMLS_CC);
1289 break;
1290 case GMP_ROUND_MINUSINF:
1291 gmp_zval_binary_ui_op2(return_value, a_arg, b_arg, mpz_fdiv_qr, (gmp_binary_ui_op2_t) mpz_fdiv_qr_ui, 1 TSRMLS_CC);
1292 break;
1293 default:
1294 php_error_docref(NULL TSRMLS_CC, E_WARNING, "Invalid rounding mode");
1295 RETURN_FALSE;
1296 }
1297 }
1298 /* }}} */
1299
1300 /* {{{ proto GMP gmp_div_r(mixed a, mixed b [, int round])
1301 Divide a by b, returns reminder only */
1302 ZEND_FUNCTION(gmp_div_r)
1303 {
1304 zval *a_arg, *b_arg;
1305 long round = GMP_ROUND_ZERO;
1306
1307 if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zz|l", &a_arg, &b_arg, &round) == FAILURE) {
1308 return;
1309 }
1310
1311 switch (round) {
1312 case GMP_ROUND_ZERO:
1313 gmp_zval_binary_ui_op(return_value, a_arg, b_arg, mpz_tdiv_r, (gmp_binary_ui_op_t) mpz_tdiv_r_ui, 1 TSRMLS_CC);
1314 break;
1315 case GMP_ROUND_PLUSINF:
1316 gmp_zval_binary_ui_op(return_value, a_arg, b_arg, mpz_cdiv_r, (gmp_binary_ui_op_t) mpz_cdiv_r_ui, 1 TSRMLS_CC);
1317 break;
1318 case GMP_ROUND_MINUSINF:
1319 gmp_zval_binary_ui_op(return_value, a_arg, b_arg, mpz_fdiv_r, (gmp_binary_ui_op_t) mpz_fdiv_r_ui, 1 TSRMLS_CC);
1320 break;
1321 default:
1322 php_error_docref(NULL TSRMLS_CC, E_WARNING, "Invalid rounding mode");
1323 RETURN_FALSE;
1324 }
1325 }
1326 /* }}} */
1327
1328 /* {{{ proto GMP gmp_div_q(mixed a, mixed b [, int round])
1329 Divide a by b, returns quotient only */
1330 ZEND_FUNCTION(gmp_div_q)
1331 {
1332 zval *a_arg, *b_arg;
1333 long round = GMP_ROUND_ZERO;
1334
1335 if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zz|l", &a_arg, &b_arg, &round) == FAILURE) {
1336 return;
1337 }
1338
1339 switch (round) {
1340 case GMP_ROUND_ZERO:
1341 gmp_zval_binary_ui_op(return_value, a_arg, b_arg, mpz_tdiv_q, (gmp_binary_ui_op_t) mpz_tdiv_q_ui, 1 TSRMLS_CC);
1342 break;
1343 case GMP_ROUND_PLUSINF:
1344 gmp_zval_binary_ui_op(return_value, a_arg, b_arg, mpz_cdiv_q, (gmp_binary_ui_op_t) mpz_cdiv_q_ui, 1 TSRMLS_CC);
1345 break;
1346 case GMP_ROUND_MINUSINF:
1347 gmp_zval_binary_ui_op(return_value, a_arg, b_arg, mpz_fdiv_q, (gmp_binary_ui_op_t) mpz_fdiv_q_ui, 1 TSRMLS_CC);
1348 break;
1349 default:
1350 php_error_docref(NULL TSRMLS_CC, E_WARNING, "Invalid rounding mode");
1351 RETURN_FALSE;
1352 }
1353
1354 }
1355 /* }}} */
1356
1357 /* {{{ proto GMP gmp_mod(mixed a, mixed b)
1358 Computes a modulo b */
1359 ZEND_FUNCTION(gmp_mod)
1360 {
1361 gmp_binary_ui_op_no_zero(mpz_mod, (gmp_binary_ui_op_t) mpz_mod_ui);
1362 }
1363 /* }}} */
1364
1365 /* {{{ proto GMP gmp_divexact(mixed a, mixed b)
1366 Divide a by b using exact division algorithm */
1367 ZEND_FUNCTION(gmp_divexact)
1368 {
1369 gmp_binary_ui_op_no_zero(mpz_divexact, NULL);
1370 }
1371 /* }}} */
1372
1373 /* {{{ proto GMP gmp_neg(mixed a)
1374 Negates a number */
1375 ZEND_FUNCTION(gmp_neg)
1376 {
1377 gmp_unary_op(mpz_neg);
1378 }
1379 /* }}} */
1380
1381 /* {{{ proto GMP gmp_abs(mixed a)
1382 Calculates absolute value */
1383 ZEND_FUNCTION(gmp_abs)
1384 {
1385 gmp_unary_op(mpz_abs);
1386 }
1387 /* }}} */
1388
1389 /* {{{ proto GMP gmp_fact(int a)
1390 Calculates factorial function */
1391 ZEND_FUNCTION(gmp_fact)
1392 {
1393 zval *a_arg;
1394
1395 if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &a_arg) == FAILURE){
1396 return;
1397 }
1398
1399 if (IS_GMP(a_arg)) {
1400 mpz_ptr gmpnum_tmp = GET_GMP_FROM_ZVAL(a_arg);
1401 if (mpz_sgn(gmpnum_tmp) < 0) {
1402 php_error_docref(NULL TSRMLS_CC, E_WARNING, "Number has to be greater than or equal to 0");
1403 RETURN_FALSE;
1404 }
1405 } else {
1406 if (gmp_get_long(a_arg) < 0) {
1407 php_error_docref(NULL TSRMLS_CC, E_WARNING, "Number has to be greater than or equal to 0");
1408 RETURN_FALSE;
1409 }
1410 }
1411
1412 gmp_zval_unary_ui_op(return_value, a_arg, mpz_fac_ui TSRMLS_CC);
1413 }
1414 /* }}} */
1415
1416 /* {{{ proto GMP gmp_pow(mixed base, int exp)
1417 Raise base to power exp */
1418 ZEND_FUNCTION(gmp_pow)
1419 {
1420 zval *base_arg;
1421 mpz_ptr gmpnum_result, gmpnum_base;
1422 gmp_temp_t temp_base;
1423 long exp;
1424
1425 if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zl", &base_arg, &exp) == FAILURE) {
1426 return;
1427 }
1428
1429 if (exp < 0) {
1430 php_error_docref(NULL TSRMLS_CC, E_WARNING, "Negative exponent not supported");
1431 RETURN_FALSE;
1432 }
1433
1434 if (Z_TYPE_P(base_arg) == IS_LONG && Z_LVAL_P(base_arg) >= 0) {
1435 INIT_GMP_RETVAL(gmpnum_result);
1436 mpz_ui_pow_ui(gmpnum_result, Z_LVAL_P(base_arg), exp);
1437 } else {
1438 FETCH_GMP_ZVAL(gmpnum_base, base_arg, temp_base);
1439 INIT_GMP_RETVAL(gmpnum_result);
1440 mpz_pow_ui(gmpnum_result, gmpnum_base, exp);
1441 FREE_GMP_TEMP(temp_base);
1442 }
1443 }
1444 /* }}} */
1445
1446 /* {{{ proto GMP gmp_powm(mixed base, mixed exp, mixed mod)
1447 Raise base to power exp and take result modulo mod */
1448 ZEND_FUNCTION(gmp_powm)
1449 {
1450 zval *base_arg, *exp_arg, *mod_arg;
1451 mpz_ptr gmpnum_base, gmpnum_exp, gmpnum_mod, gmpnum_result;
1452 int use_ui = 0;
1453 gmp_temp_t temp_base, temp_exp, temp_mod;
1454
1455 if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zzz", &base_arg, &exp_arg, &mod_arg) == FAILURE){
1456 return;
1457 }
1458
1459 FETCH_GMP_ZVAL(gmpnum_base, base_arg, temp_base);
1460
1461 if (Z_TYPE_P(exp_arg) == IS_LONG && Z_LVAL_P(exp_arg) >= 0) {
1462 use_ui = 1;
1463 temp_exp.is_used = 0;
1464 } else {
1465 FETCH_GMP_ZVAL_DEP(gmpnum_exp, exp_arg, temp_exp, temp_base);
1466 if (mpz_sgn(gmpnum_exp) < 0) {
1467 php_error_docref(NULL TSRMLS_CC, E_WARNING, "Second parameter cannot be less than 0");
1468 FREE_GMP_TEMP(temp_base);
1469 FREE_GMP_TEMP(temp_exp);
1470 RETURN_FALSE;
1471 }
1472 }
1473 FETCH_GMP_ZVAL_DEP_DEP(gmpnum_mod, mod_arg, temp_mod, temp_exp, temp_base);
1474
1475 if (!mpz_cmp_ui(gmpnum_mod, 0)) {
1476 php_error_docref(NULL TSRMLS_CC, E_WARNING, "Modulus may not be zero");
1477 FREE_GMP_TEMP(temp_base);
1478 FREE_GMP_TEMP(temp_exp);
1479 FREE_GMP_TEMP(temp_mod);
1480 RETURN_FALSE;
1481 }
1482
1483 INIT_GMP_RETVAL(gmpnum_result);
1484 if (use_ui) {
1485 mpz_powm_ui(gmpnum_result, gmpnum_base, (unsigned long) Z_LVAL_P(exp_arg), gmpnum_mod);
1486 } else {
1487 mpz_powm(gmpnum_result, gmpnum_base, gmpnum_exp, gmpnum_mod);
1488 FREE_GMP_TEMP(temp_exp);
1489 }
1490
1491 FREE_GMP_TEMP(temp_base);
1492 FREE_GMP_TEMP(temp_mod);
1493 }
1494 /* }}} */
1495
1496 /* {{{ proto GMP gmp_sqrt(mixed a)
1497 Takes integer part of square root of a */
1498 ZEND_FUNCTION(gmp_sqrt)
1499 {
1500 zval *a_arg;
1501 mpz_ptr gmpnum_a, gmpnum_result;
1502 gmp_temp_t temp_a;
1503
1504 if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &a_arg) == FAILURE){
1505 return;
1506 }
1507
1508 FETCH_GMP_ZVAL(gmpnum_a, a_arg, temp_a);
1509
1510 if (mpz_sgn(gmpnum_a) < 0) {
1511 php_error_docref(NULL TSRMLS_CC, E_WARNING, "Number has to be greater than or equal to 0");
1512 FREE_GMP_TEMP(temp_a);
1513 RETURN_FALSE;
1514 }
1515
1516 INIT_GMP_RETVAL(gmpnum_result);
1517 mpz_sqrt(gmpnum_result, gmpnum_a);
1518 FREE_GMP_TEMP(temp_a);
1519 }
1520 /* }}} */
1521
1522 /* {{{ proto array gmp_sqrtrem(mixed a)
1523 Square root with remainder */
1524 ZEND_FUNCTION(gmp_sqrtrem)
1525 {
1526 zval *a_arg;
1527 mpz_ptr gmpnum_a, gmpnum_result1, gmpnum_result2;
1528 gmp_temp_t temp_a;
1529
1530 if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &a_arg) == FAILURE){
1531 return;
1532 }
1533
1534 FETCH_GMP_ZVAL(gmpnum_a, a_arg, temp_a);
1535
1536 if (mpz_sgn(gmpnum_a) < 0) {
1537 php_error_docref(NULL TSRMLS_CC, E_WARNING, "Number has to be greater than or equal to 0");
1538 FREE_GMP_TEMP(temp_a);
1539 RETURN_FALSE;
1540 }
1541
1542 array_init(return_value);
1543 add_index_zval(return_value, 0, gmp_create(&gmpnum_result1 TSRMLS_CC));
1544 add_index_zval(return_value, 1, gmp_create(&gmpnum_result2 TSRMLS_CC));
1545
1546 mpz_sqrtrem(gmpnum_result1, gmpnum_result2, gmpnum_a);
1547 FREE_GMP_TEMP(temp_a);
1548 }
1549 /* }}} */
1550
1551 /* {{{ proto GMP gmp_root(mixed a, int nth)
1552 Takes integer part of nth root */
1553 ZEND_FUNCTION(gmp_root)
1554 {
1555 zval *a_arg;
1556 long nth;
1557 mpz_ptr gmpnum_a, gmpnum_result;
1558 gmp_temp_t temp_a;
1559
1560 if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zl", &a_arg, &nth) == FAILURE) {
1561 return;
1562 }
1563
1564 if (nth <= 0) {
1565 php_error_docref(NULL TSRMLS_CC, E_WARNING, "The root must be positive");
1566 RETURN_FALSE;
1567 }
1568
1569 FETCH_GMP_ZVAL(gmpnum_a, a_arg, temp_a);
1570
1571 if (nth % 2 == 0 && mpz_sgn(gmpnum_a) < 0) {
1572 php_error_docref(NULL TSRMLS_CC, E_WARNING, "Can't take even root of negative number");
1573 FREE_GMP_TEMP(temp_a);
1574 RETURN_FALSE;
1575 }
1576
1577 INIT_GMP_RETVAL(gmpnum_result);
1578 mpz_root(gmpnum_result, gmpnum_a, (unsigned long) nth);
1579 FREE_GMP_TEMP(temp_a);
1580 }
1581 /* }}} */
1582
1583 /* {{{ proto GMP gmp_rootrem(mixed a, int nth)
1584 Calculates integer part of nth root and remainder */
1585 ZEND_FUNCTION(gmp_rootrem)
1586 {
1587 zval *a_arg;
1588 long nth;
1589 mpz_ptr gmpnum_a, gmpnum_result1, gmpnum_result2;
1590 gmp_temp_t temp_a;
1591
1592 if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zl", &a_arg, &nth) == FAILURE) {
1593 return;
1594 }
1595
1596 if (nth <= 0) {
1597 php_error_docref(NULL TSRMLS_CC, E_WARNING, "The root must be positive");
1598 RETURN_FALSE;
1599 }
1600
1601 FETCH_GMP_ZVAL(gmpnum_a, a_arg, temp_a);
1602
1603 if (nth % 2 == 0 && mpz_sgn(gmpnum_a) < 0) {
1604 php_error_docref(NULL TSRMLS_CC, E_WARNING, "Can't take even root of negative number");
1605 FREE_GMP_TEMP(temp_a);
1606 RETURN_FALSE;
1607 }
1608
1609 array_init(return_value);
1610 add_index_zval(return_value, 0, gmp_create(&gmpnum_result1 TSRMLS_CC));
1611 add_index_zval(return_value, 1, gmp_create(&gmpnum_result2 TSRMLS_CC));
1612
1613 #if GMP_51_OR_NEWER
1614 /* mpz_rootrem() is supported since GMP 4.2, but buggy wrt odd roots
1615 * of negative numbers */
1616 mpz_rootrem(gmpnum_result1, gmpnum_result2, gmpnum_a, (unsigned long) nth);
1617 #else
1618 mpz_root(gmpnum_result1, gmpnum_a, (unsigned long) nth);
1619 mpz_pow_ui(gmpnum_result2, gmpnum_result1, (unsigned long) nth);
1620 mpz_sub(gmpnum_result2, gmpnum_a, gmpnum_result2);
1621 #endif
1622
1623 FREE_GMP_TEMP(temp_a);
1624 }
1625 /* }}} */
1626
1627 /* {{{ proto bool gmp_perfect_square(mixed a)
1628 Checks if a is an exact square */
1629 ZEND_FUNCTION(gmp_perfect_square)
1630 {
1631 zval *a_arg;
1632 mpz_ptr gmpnum_a;
1633 gmp_temp_t temp_a;
1634
1635 if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &a_arg) == FAILURE){
1636 return;
1637 }
1638
1639 FETCH_GMP_ZVAL(gmpnum_a, a_arg, temp_a);
1640
1641 RETVAL_BOOL((mpz_perfect_square_p(gmpnum_a) != 0));
1642 FREE_GMP_TEMP(temp_a);
1643 }
1644 /* }}} */
1645
1646 /* {{{ proto int gmp_prob_prime(mixed a[, int reps])
1647 Checks if a is "probably prime" */
1648 ZEND_FUNCTION(gmp_prob_prime)
1649 {
1650 zval *gmpnumber_arg;
1651 mpz_ptr gmpnum_a;
1652 long reps = 10;
1653 gmp_temp_t temp_a;
1654
1655 if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z|l", &gmpnumber_arg, &reps) == FAILURE) {
1656 return;
1657 }
1658
1659 FETCH_GMP_ZVAL(gmpnum_a, gmpnumber_arg, temp_a);
1660
1661 RETVAL_LONG(mpz_probab_prime_p(gmpnum_a, reps));
1662 FREE_GMP_TEMP(temp_a);
1663 }
1664 /* }}} */
1665
1666 /* {{{ proto GMP gmp_gcd(mixed a, mixed b)
1667 Computes greatest common denominator (gcd) of a and b */
1668 ZEND_FUNCTION(gmp_gcd)
1669 {
1670 gmp_binary_ui_op(mpz_gcd, (gmp_binary_ui_op_t) mpz_gcd_ui);
1671 }
1672 /* }}} */
1673
1674 /* {{{ proto array gmp_gcdext(mixed a, mixed b)
1675 Computes G, S, and T, such that AS + BT = G = `gcd' (A, B) */
1676 ZEND_FUNCTION(gmp_gcdext)
1677 {
1678 zval *a_arg, *b_arg;
1679 mpz_ptr gmpnum_a, gmpnum_b, gmpnum_t, gmpnum_s, gmpnum_g;
1680 gmp_temp_t temp_a, temp_b;
1681
1682 if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zz", &a_arg, &b_arg) == FAILURE){
1683 return;
1684 }
1685
1686 FETCH_GMP_ZVAL(gmpnum_a, a_arg, temp_a);
1687 FETCH_GMP_ZVAL_DEP(gmpnum_b, b_arg, temp_b, temp_a);
1688
1689 array_init(return_value);
1690 add_assoc_zval(return_value, "g", gmp_create(&gmpnum_g TSRMLS_CC));
1691 add_assoc_zval(return_value, "s", gmp_create(&gmpnum_s TSRMLS_CC));
1692 add_assoc_zval(return_value, "t", gmp_create(&gmpnum_t TSRMLS_CC));
1693
1694 mpz_gcdext(gmpnum_g, gmpnum_s, gmpnum_t, gmpnum_a, gmpnum_b);
1695 FREE_GMP_TEMP(temp_a);
1696 FREE_GMP_TEMP(temp_b);
1697 }
1698 /* }}} */
1699
1700 /* {{{ proto GMP gmp_invert(mixed a, mixed b)
1701 Computes the inverse of a modulo b */
1702 ZEND_FUNCTION(gmp_invert)
1703 {
1704 zval *a_arg, *b_arg;
1705 mpz_ptr gmpnum_a, gmpnum_b, gmpnum_result;
1706 gmp_temp_t temp_a, temp_b;
1707 int res;
1708
1709 if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zz", &a_arg, &b_arg) == FAILURE){
1710 return;
1711 }
1712
1713 FETCH_GMP_ZVAL(gmpnum_a, a_arg, temp_a);
1714 FETCH_GMP_ZVAL_DEP(gmpnum_b, b_arg, temp_b, temp_a);
1715
1716 INIT_GMP_RETVAL(gmpnum_result);
1717 res = mpz_invert(gmpnum_result, gmpnum_a, gmpnum_b);
1718 FREE_GMP_TEMP(temp_a);
1719 FREE_GMP_TEMP(temp_b);
1720 if (!res) {
1721 zval_dtor(return_value);
1722 RETURN_FALSE;
1723 }
1724 }
1725 /* }}} */
1726
1727 /* {{{ proto int gmp_jacobi(mixed a, mixed b)
1728 Computes Jacobi symbol */
1729 ZEND_FUNCTION(gmp_jacobi)
1730 {
1731 gmp_binary_opl(mpz_jacobi);
1732 }
1733 /* }}} */
1734
1735 /* {{{ proto int gmp_legendre(mixed a, mixed b)
1736 Computes Legendre symbol */
1737 ZEND_FUNCTION(gmp_legendre)
1738 {
1739 gmp_binary_opl(mpz_legendre);
1740 }
1741 /* }}} */
1742
1743 /* {{{ proto int gmp_cmp(mixed a, mixed b)
1744 Compares two numbers */
1745 ZEND_FUNCTION(gmp_cmp)
1746 {
1747 zval *a_arg, *b_arg;
1748
1749 if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zz", &a_arg, &b_arg) == FAILURE){
1750 return;
1751 }
1752
1753 gmp_cmp(return_value, a_arg, b_arg TSRMLS_CC);
1754 }
1755 /* }}} */
1756
1757 /* {{{ proto int gmp_sign(mixed a)
1758 Gets the sign of the number */
1759 ZEND_FUNCTION(gmp_sign)
1760 {
1761 /* Can't use gmp_unary_opl here, because mpz_sgn is a macro */
1762 zval *a_arg;
1763 mpz_ptr gmpnum_a;
1764 gmp_temp_t temp_a;
1765
1766 if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &a_arg) == FAILURE){
1767 return;
1768 }
1769
1770 FETCH_GMP_ZVAL(gmpnum_a, a_arg, temp_a);
1771
1772 RETVAL_LONG(mpz_sgn(gmpnum_a));
1773 FREE_GMP_TEMP(temp_a);
1774 }
1775 /* }}} */
1776
1777 static void gmp_init_random(TSRMLS_D)
1778 {
1779 if (!GMPG(rand_initialized)) {
1780 /* Initialize */
1781 #if GMP_42_OR_NEWER
1782 gmp_randinit_mt(GMPG(rand_state));
1783 #else
1784 gmp_randinit_lc_2exp_size(GMPG(rand_state), 32L);
1785 #endif
1786 /* Seed */
1787 gmp_randseed_ui(GMPG(rand_state), GENERATE_SEED());
1788
1789 GMPG(rand_initialized) = 1;
1790 }
1791 }
1792
1793 /* {{{ proto GMP gmp_random([int limiter])
1794 Gets random number */
1795 ZEND_FUNCTION(gmp_random)
1796 {
1797 long limiter = 20;
1798 mpz_ptr gmpnum_result;
1799
1800 if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|l", &limiter) == FAILURE) {
1801 return;
1802 }
1803
1804 INIT_GMP_RETVAL(gmpnum_result);
1805 gmp_init_random(TSRMLS_C);
1806
1807 #ifdef GMP_LIMB_BITS
1808 mpz_urandomb(gmpnum_result, GMPG(rand_state), GMP_ABS (limiter) * GMP_LIMB_BITS);
1809 #else
1810 mpz_urandomb(gmpnum_result, GMPG(rand_state), GMP_ABS (limiter) * __GMP_BITS_PER_MP_LIMB);
1811 #endif
1812 }
1813 /* }}} */
1814
1815 /* {{{ proto GMP gmp_random_bits(int bits)
1816 Gets a random number in the range 0 to (2 ** n) - 1 */
1817 ZEND_FUNCTION(gmp_random_bits)
1818 {
1819 long bits;
1820 mpz_ptr gmpnum_result;
1821
1822 if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &bits) == FAILURE) {
1823 return;
1824 }
1825
1826 if (bits <= 0) {
1827 php_error_docref(NULL TSRMLS_CC, E_WARNING, "The number of bits must be positive");
1828 RETURN_FALSE;
1829 }
1830
1831 INIT_GMP_RETVAL(gmpnum_result);
1832 gmp_init_random(TSRMLS_C);
1833
1834 mpz_urandomb(gmpnum_result, GMPG(rand_state), bits);
1835 }
1836 /* }}} */
1837
1838 /* {{{ proto GMP gmp_random_range(mixed min, mixed max)
1839 Gets a random number in the range min to max */
1840 ZEND_FUNCTION(gmp_random_range)
1841 {
1842 zval *min_arg, *max_arg;
1843 mpz_ptr gmpnum_min, gmpnum_max, gmpnum_result;
1844 mpz_t gmpnum_range;
1845 gmp_temp_t temp_a, temp_b;
1846
1847 if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zz", &min_arg, &max_arg) == FAILURE) {
1848 return;
1849 }
1850
1851 gmp_init_random(TSRMLS_C);
1852
1853 FETCH_GMP_ZVAL(gmpnum_max, max_arg, temp_a);
1854
1855 if (Z_TYPE_P(min_arg) == IS_LONG && Z_LVAL_P(min_arg) >= 0) {
1856 if (mpz_cmp_ui(gmpnum_max, Z_LVAL_P(min_arg)) <= 0) {
1857 FREE_GMP_TEMP(temp_a);
1858 php_error_docref(NULL TSRMLS_CC, E_WARNING, "The minimum value must be less than the maximum value");
1859 RETURN_FALSE;
1860 }
1861
1862 INIT_GMP_RETVAL(gmpnum_result);
1863 mpz_init(gmpnum_range);
1864
1865 if (Z_LVAL_P(min_arg) != 0) {
1866 mpz_sub_ui(gmpnum_range, gmpnum_max, Z_LVAL_P(min_arg) - 1);
1867 } else {
1868 mpz_add_ui(gmpnum_range, gmpnum_max, 1);
1869 }
1870
1871 mpz_urandomm(gmpnum_result, GMPG(rand_state), gmpnum_range);
1872
1873 if (Z_LVAL_P(min_arg) != 0) {
1874 mpz_add_ui(gmpnum_result, gmpnum_result, Z_LVAL_P(min_arg));
1875 }
1876
1877 mpz_clear(gmpnum_range);
1878 FREE_GMP_TEMP(temp_a);
1879 } else {
1880 FETCH_GMP_ZVAL_DEP(gmpnum_min, min_arg, temp_b, temp_a);
1881
1882 if (mpz_cmp(gmpnum_max, gmpnum_min) <= 0) {
1883 FREE_GMP_TEMP(temp_b);
1884 FREE_GMP_TEMP(temp_a);
1885 php_error_docref(NULL TSRMLS_CC, E_WARNING, "The minimum value must be less than the maximum value");
1886 RETURN_FALSE;
1887 }
1888
1889 INIT_GMP_RETVAL(gmpnum_result);
1890 mpz_init(gmpnum_range);
1891
1892 mpz_sub(gmpnum_range, gmpnum_max, gmpnum_min);
1893 mpz_add_ui(gmpnum_range, gmpnum_range, 1);
1894 mpz_urandomm(gmpnum_result, GMPG(rand_state), gmpnum_range);
1895 mpz_add(gmpnum_result, gmpnum_result, gmpnum_min);
1896
1897 mpz_clear(gmpnum_range);
1898 FREE_GMP_TEMP(temp_b);
1899 FREE_GMP_TEMP(temp_a);
1900 }
1901 }
1902 /* }}} */
1903
1904 /* {{{ proto GMP gmp_and(mixed a, mixed b)
1905 Calculates logical AND of a and b */
1906 ZEND_FUNCTION(gmp_and)
1907 {
1908 gmp_binary_op(mpz_and);
1909 }
1910 /* }}} */
1911
1912 /* {{{ proto GMP gmp_or(mixed a, mixed b)
1913 Calculates logical OR of a and b */
1914 ZEND_FUNCTION(gmp_or)
1915 {
1916 gmp_binary_op(mpz_ior);
1917 }
1918 /* }}} */
1919
1920 /* {{{ proto GMP gmp_com(mixed a)
1921 Calculates one's complement of a */
1922 ZEND_FUNCTION(gmp_com)
1923 {
1924 gmp_unary_op(mpz_com);
1925 }
1926 /* }}} */
1927
1928 /* {{{ proto GMP gmp_nextprime(mixed a)
1929 Finds next prime of a */
1930 ZEND_FUNCTION(gmp_nextprime)
1931 {
1932 gmp_unary_op(mpz_nextprime);
1933 }
1934 /* }}} */
1935
1936 /* {{{ proto GMP gmp_xor(mixed a, mixed b)
1937 Calculates logical exclusive OR of a and b */
1938 ZEND_FUNCTION(gmp_xor)
1939 {
1940 gmp_binary_op(mpz_xor);
1941 }
1942 /* }}} */
1943
1944 /* {{{ proto void gmp_setbit(GMP a, int index[, bool set_clear])
1945 Sets or clear bit in a */
1946 ZEND_FUNCTION(gmp_setbit)
1947 {
1948 zval *a_arg;
1949 long index;
1950 zend_bool set = 1;
1951 mpz_ptr gmpnum_a;
1952
1953 if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "Ol|b", &a_arg, gmp_ce, &index, &set) == FAILURE) {
1954 return;
1955 }
1956
1957 if (index < 0) {
1958 php_error_docref(NULL TSRMLS_CC, E_WARNING, "Index must be greater than or equal to zero");
1959 return;
1960 }
1961
1962 gmpnum_a = GET_GMP_FROM_ZVAL(a_arg);
1963
1964 if (set) {
1965 mpz_setbit(gmpnum_a, index);
1966 } else {
1967 mpz_clrbit(gmpnum_a, index);
1968 }
1969 }
1970 /* }}} */
1971
1972 /* {{{ proto void gmp_clrbit(GMP a, int index)
1973 Clears bit in a */
1974 ZEND_FUNCTION(gmp_clrbit)
1975 {
1976 zval *a_arg;
1977 long index;
1978 mpz_ptr gmpnum_a;
1979
1980 if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "Ol", &a_arg, gmp_ce, &index) == FAILURE){
1981 return;
1982 }
1983
1984 if (index < 0) {
1985 php_error_docref(NULL TSRMLS_CC, E_WARNING, "Index must be greater than or equal to zero");
1986 return;
1987 }
1988
1989 gmpnum_a = GET_GMP_FROM_ZVAL(a_arg);
1990 mpz_clrbit(gmpnum_a, index);
1991 }
1992 /* }}} */
1993
1994 /* {{{ proto bool gmp_testbit(mixed a, int index)
1995 Tests if bit is set in a */
1996 ZEND_FUNCTION(gmp_testbit)
1997 {
1998 zval *a_arg;
1999 long index;
2000 mpz_ptr gmpnum_a;
2001 gmp_temp_t temp_a;
2002
2003 if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zl", &a_arg, &index) == FAILURE){
2004 return;
2005 }
2006
2007 if (index < 0) {
2008 php_error_docref(NULL TSRMLS_CC, E_WARNING, "Index must be greater than or equal to zero");
2009 RETURN_FALSE;
2010 }
2011
2012 FETCH_GMP_ZVAL(gmpnum_a, a_arg, temp_a);
2013 RETVAL_BOOL(mpz_tstbit(gmpnum_a, index));
2014 FREE_GMP_TEMP(temp_a);
2015 }
2016 /* }}} */
2017
2018 /* {{{ proto int gmp_popcount(mixed a)
2019 Calculates the population count of a */
2020 ZEND_FUNCTION(gmp_popcount)
2021 {
2022 gmp_unary_opl((gmp_unary_opl_t) mpz_popcount);
2023 }
2024 /* }}} */
2025
2026 /* {{{ proto int gmp_hamdist(mixed a, mixed b)
2027 Calculates hamming distance between a and b */
2028 ZEND_FUNCTION(gmp_hamdist)
2029 {
2030 gmp_binary_opl((gmp_binary_opl_t) mpz_hamdist);
2031 }
2032 /* }}} */
2033
2034 /* {{{ proto int gmp_scan0(mixed a, int start)
2035 Finds first zero bit */
2036 ZEND_FUNCTION(gmp_scan0)
2037 {
2038 zval *a_arg;
2039 mpz_ptr gmpnum_a;
2040 gmp_temp_t temp_a;
2041 long start;
2042
2043 if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zl", &a_arg, &start) == FAILURE){
2044 return;
2045 }
2046
2047 if (start < 0) {
2048 php_error_docref(NULL TSRMLS_CC, E_WARNING, "Starting index must be greater than or equal to zero");
2049 RETURN_FALSE;
2050 }
2051
2052 FETCH_GMP_ZVAL(gmpnum_a, a_arg, temp_a);
2053
2054 RETVAL_LONG(mpz_scan0(gmpnum_a, start));
2055 FREE_GMP_TEMP(temp_a);
2056 }
2057 /* }}} */
2058
2059 /* {{{ proto int gmp_scan1(mixed a, int start)
2060 Finds first non-zero bit */
2061 ZEND_FUNCTION(gmp_scan1)
2062 {
2063 zval *a_arg;
2064 mpz_ptr gmpnum_a;
2065 gmp_temp_t temp_a;
2066 long start;
2067
2068 if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zl", &a_arg, &start) == FAILURE){
2069 return;
2070 }
2071
2072 if (start < 0) {
2073 php_error_docref(NULL TSRMLS_CC, E_WARNING, "Starting index must be greater than or equal to zero");
2074 RETURN_FALSE;
2075 }
2076
2077 FETCH_GMP_ZVAL(gmpnum_a, a_arg, temp_a);
2078
2079 RETVAL_LONG(mpz_scan1(gmpnum_a, start));
2080 FREE_GMP_TEMP(temp_a);
2081 }
2082 /* }}} */
2083
2084 #endif /* HAVE_GMP */
2085
2086 /*
2087 * Local variables:
2088 * tab-width: 4
2089 * c-basic-offset: 4
2090 * End:
2091 * vim600: noet sw=4 ts=4 fdm=marker
2092 * vim<600: noet sw=4 ts=4
2093 */
2094
