PHP Classes

File: ext/kernel/operators.c

Recommend this page to a friend!
  Classes of Andrew Collington   iWire PHP Raspberry PI GPIO Class   ext/kernel/operators.c   Download  
File: ext/kernel/operators.c
Role: Auxiliary data
Content type: text/plain
Description: Auxiliary data
Class: iWire PHP Raspberry PI GPIO Class
Control a Raspberry PI board using GPIO
Author: By
Last change:
Date: 4 years ago
Size: 23,151 bytes
 

Contents

Class file image Download
/* +------------------------------------------------------------------------+ | Zephir Language | +------------------------------------------------------------------------+ | Copyright (c) 2011-2015 Zephir Team (http://www.zephir-lang.com) | +------------------------------------------------------------------------+ | This source file is subject to the New BSD License that is bundled | | with this package in the file docs/LICENSE.txt. | | | | If you did not receive a copy of the license and are unable to | | obtain it through the world-wide-web, please send an email | | to license@zephir-lang.com so we can send you a copy immediately. | +------------------------------------------------------------------------+ | Authors: Andres Gutierrez <andres@zephir-lang.com> | | Eduar Carvajal <eduar@zephir-lang.com> | | Vladimir Kolesnikov <vladimir@extrememember.com> | +------------------------------------------------------------------------+ */ #ifdef HAVE_CONFIG_H #include "config.h" #endif #include <php.h> #include <ext/standard/php_string.h> #include <ext/standard/php_math.h> #include "php_ext.h" #include "kernel/main.h" #include "kernel/memory.h" #include "kernel/string.h" #include "kernel/operators.h" #include "Zend/zend_operators.h" void zephir_make_printable_zval(zval *expr, zval *expr_copy, int *use_copy){ zend_make_printable_zval(expr, expr_copy, use_copy); if (use_copy) { Z_SET_REFCOUNT_P(expr_copy, 1); Z_UNSET_ISREF_P(expr_copy); } } /** * Performs logical AND function operator */ int zephir_and_function(zval *result, zval *left, zval *right){ int istrue = zend_is_true(left) && zend_is_true(right); ZVAL_BOOL(result, istrue); return SUCCESS; } /** * Appends the content of the right operator to the left operator */ void zephir_concat_self(zval **left, zval *right TSRMLS_DC){ zval left_copy, right_copy; uint length; int use_copy_left = 0, use_copy_right = 0; if (Z_TYPE_P(right) != IS_STRING) { zephir_make_printable_zval(right, &right_copy, &use_copy_right); if (use_copy_right) { right = &right_copy; } } if (Z_TYPE_PP(left) == IS_NULL) { Z_STRVAL_PP(left) = emalloc(Z_STRLEN_P(right) + 1); memcpy(Z_STRVAL_PP(left), Z_STRVAL_P(right), Z_STRLEN_P(right)); Z_STRVAL_PP(left)[Z_STRLEN_P(right)] = 0; Z_STRLEN_PP(left) = Z_STRLEN_P(right); Z_TYPE_PP(left) = IS_STRING; if (use_copy_right) { zval_dtor(&right_copy); } return; } if (Z_TYPE_PP(left) != IS_STRING) { zephir_make_printable_zval(*left, &left_copy, &use_copy_left); if (use_copy_left) { ZEPHIR_CPY_WRT_CTOR(*left, (&left_copy)); } } SEPARATE_ZVAL_IF_NOT_REF(left); length = Z_STRLEN_PP(left) + Z_STRLEN_P(right); Z_STRVAL_PP(left) = str_erealloc(Z_STRVAL_PP(left), length + 1); memcpy(Z_STRVAL_PP(left) + Z_STRLEN_PP(left), Z_STRVAL_P(right), Z_STRLEN_P(right)); Z_STRVAL_PP(left)[length] = 0; Z_STRLEN_PP(left) = length; Z_TYPE_PP(left) = IS_STRING; if (use_copy_left) { zval_dtor(&left_copy); } if (use_copy_right) { zval_dtor(&right_copy); } } /** * Appends the content of the right operator to the left operator */ void zephir_concat_self_str(zval **left, const char *right, int right_length TSRMLS_DC){ zval left_copy; uint length; int use_copy = 0; if (Z_TYPE_PP(left) == IS_NULL) { Z_STRVAL_PP(left) = emalloc(right_length + 1); memcpy(Z_STRVAL_PP(left), right, right_length); Z_STRVAL_PP(left)[right_length] = 0; Z_STRLEN_PP(left) = right_length; Z_TYPE_PP(left) = IS_STRING; return; } if (Z_TYPE_PP(left) != IS_STRING) { zephir_make_printable_zval(*left, &left_copy, &use_copy); if (use_copy) { ZEPHIR_CPY_WRT_CTOR(*left, (&left_copy)); } } SEPARATE_ZVAL_IF_NOT_REF(left); length = Z_STRLEN_PP(left) + right_length; Z_STRVAL_PP(left) = str_erealloc(Z_STRVAL_PP(left), length + 1); memcpy(Z_STRVAL_PP(left) + Z_STRLEN_PP(left), right, right_length); Z_STRVAL_PP(left)[length] = 0; Z_STRLEN_PP(left) = length; Z_TYPE_PP(left) = IS_STRING; if (use_copy) { zval_dtor(&left_copy); } } /** * Appends the content of the right operator to the left operator */ void zephir_concat_self_long(zval **left, const long right TSRMLS_DC) { zval left_copy; uint length; char *right_char; int use_copy = 0, right_length = 0; right_length = zephir_spprintf(&right_char, 0, "%ld", right); if (Z_TYPE_PP(left) == IS_NULL) { Z_STRVAL_PP(left) = emalloc(right_length + 1); if (right_length > 0) { memcpy(Z_STRVAL_PP(left), right_char, right_length); } else { memcpy(Z_STRVAL_PP(left), "", 0); } Z_STRVAL_PP(left)[right_length] = 0; Z_STRLEN_PP(left) = right_length; Z_TYPE_PP(left) = IS_STRING; return; } if (Z_TYPE_PP(left) != IS_STRING) { zephir_make_printable_zval(*left, &left_copy, &use_copy); if (use_copy) { ZEPHIR_CPY_WRT_CTOR(*left, (&left_copy)); } } if (right_length > 0) { SEPARATE_ZVAL_IF_NOT_REF(left); length = Z_STRLEN_PP(left) + right_length; Z_STRVAL_PP(left) = str_erealloc(Z_STRVAL_PP(left), length + 1); memcpy(Z_STRVAL_PP(left) + Z_STRLEN_PP(left), right_char, right_length); Z_STRVAL_PP(left)[length] = 0; Z_STRLEN_PP(left) = length; Z_TYPE_PP(left) = IS_STRING; } if (use_copy) { zval_dtor(&left_copy); } } /** * Appends the content of the right operator to the left operator */ void zephir_concat_self_char(zval **left, unsigned char right TSRMLS_DC) { zval left_copy; int use_copy = 0; if (Z_TYPE_PP(left) == IS_NULL) { Z_STRVAL_PP(left) = emalloc(2); Z_STRVAL_PP(left)[0] = right; Z_STRVAL_PP(left)[1] = 0; Z_STRLEN_PP(left) = 1; Z_TYPE_PP(left) = IS_STRING; return; } if (Z_TYPE_PP(left) != IS_STRING) { zephir_make_printable_zval(*left, &left_copy, &use_copy); if (use_copy) { ZEPHIR_CPY_WRT_CTOR(*left, (&left_copy)); } } SEPARATE_ZVAL_IF_NOT_REF(left); Z_STRLEN_PP(left)++; Z_STRVAL_PP(left) = str_erealloc(Z_STRVAL_PP(left), Z_STRLEN_PP(left) + 1); Z_STRVAL_PP(left)[Z_STRLEN_PP(left) - 1] = right; Z_STRVAL_PP(left)[Z_STRLEN_PP(left)] = 0; Z_TYPE_PP(left) = IS_STRING; if (use_copy) { zval_dtor(&left_copy); } } /** * Natural compare with string operandus on right */ int zephir_compare_strict_string(zval *op1, const char *op2, int op2_length) { switch (Z_TYPE_P(op1)) { case IS_STRING: if (!Z_STRLEN_P(op1) && !op2_length) { return 1; } if (Z_STRLEN_P(op1) != op2_length) { return 0; } return !zend_binary_strcmp(Z_STRVAL_P(op1), Z_STRLEN_P(op1), op2, op2_length); case IS_NULL: return !zend_binary_strcmp("", 0, op2, op2_length); case IS_BOOL: if (!Z_BVAL_P(op1)) { return !zend_binary_strcmp("0", strlen("0"), op2, op2_length); } else { return !zend_binary_strcmp("1", strlen("1"), op2, op2_length); } } return 0; } /** * Natural compare with long operandus on right */ int zephir_compare_strict_long(zval *op1, long op2 TSRMLS_DC) { int bool_result; switch (Z_TYPE_P(op1)) { case IS_LONG: return Z_LVAL_P(op1) == op2; case IS_DOUBLE: return Z_DVAL_P(op1) == (double) op2; case IS_NULL: return 0 == op2; case IS_BOOL: if (Z_BVAL_P(op1)) { return 1 == op2; } else { return 0 == op2; } default: { zval result, op2_tmp; ZVAL_LONG(&op2_tmp, op2); is_equal_function(&result, op1, &op2_tmp TSRMLS_CC); bool_result = Z_BVAL(result); return bool_result; } } return 0; } /** * Natural compare with double operandus on right */ int zephir_compare_strict_double(zval *op1, double op2 TSRMLS_DC) { int bool_result; switch (Z_TYPE_P(op1)) { case IS_LONG: return Z_LVAL_P(op1) == (long) op2; case IS_DOUBLE: return Z_DVAL_P(op1) == op2; case IS_NULL: return 0 == op2; case IS_BOOL: if (Z_BVAL_P(op1)) { return 1 == op2; } else { return 0 == op2; } default: { zval result, op2_tmp; ZVAL_DOUBLE(&op2_tmp, op2); is_equal_function(&result, op1, &op2_tmp TSRMLS_CC); bool_result = Z_BVAL(result); return bool_result; } } return 0; } /** * Natural compare with bool operandus on right */ int zephir_compare_strict_bool(zval *op1, zend_bool op2 TSRMLS_DC) { int bool_result; switch (Z_TYPE_P(op1)) { case IS_LONG: return (Z_LVAL_P(op1) ? 1 : 0) == op2; case IS_DOUBLE: return (Z_DVAL_P(op1) ? 1 : 0) == op2; case IS_NULL: return 0 == op2; case IS_BOOL: if (Z_BVAL_P(op1)) { return 1 == op2; } else { return 0 == op2; } default: { zval result, op2_tmp; ZVAL_BOOL(&op2_tmp, op2); is_equal_function(&result, op1, &op2_tmp TSRMLS_CC); bool_result = Z_BVAL(result); return bool_result; } } return 0; } /** * Do add function keeping ref_count and is_ref */ int zephir_add_function_ex(zval *result, zval *op1, zval *op2 TSRMLS_DC) { int status; int ref_count = Z_REFCOUNT_P(result); int is_ref = Z_ISREF_P(result); status = add_function(result, op1, op2 TSRMLS_CC); Z_SET_REFCOUNT_P(result, ref_count); Z_SET_ISREF_TO_P(result, is_ref); return status; } void zephir_negate(zval *z TSRMLS_DC) { while (1) { switch (Z_TYPE_P(z)) { case IS_LONG: case IS_BOOL: ZVAL_LONG(z, -Z_LVAL_P(z)); return; case IS_DOUBLE: ZVAL_DOUBLE(z, -Z_DVAL_P(z)); return; case IS_NULL: ZVAL_LONG(z, 0); return; default: convert_scalar_to_number(z TSRMLS_CC); assert(Z_TYPE_P(z) == IS_LONG || Z_TYPE_P(z) == IS_DOUBLE); } } } void zephir_convert_to_object(zval *op) { convert_to_object(op); } /** * Cast variables converting they to other types */ void zephir_cast(zval *result, zval *var, zend_uint type){ ZVAL_ZVAL(result, var, 1, 0); switch (type) { case IS_STRING: convert_to_string(result); break; case IS_LONG: convert_to_long(result); break; case IS_DOUBLE: convert_to_double(result); break; /*case IS_BOOL: convert_to_bool(result); break;*/ case IS_ARRAY: if (Z_TYPE_P(result) != IS_ARRAY) { convert_to_array(result); } break; } } /** * Returns the long value of a zval */ long zephir_get_intval_ex(const zval *op) { switch (Z_TYPE_P(op)) { case IS_ARRAY: return zend_hash_num_elements(Z_ARRVAL_P(op)) ? 1 : 0; break; #if PHP_VERSION_ID > 50400 case IS_CALLABLE: #endif case IS_RESOURCE: case IS_OBJECT: return 1; case IS_LONG: return Z_LVAL_P(op); case IS_BOOL: return Z_BVAL_P(op); case IS_DOUBLE: return (long) Z_DVAL_P(op); case IS_STRING: { long long_value = 0; double double_value = 0; zend_uchar type; ASSUME(Z_STRVAL_P(op) != NULL); type = is_numeric_string(Z_STRVAL_P(op), Z_STRLEN_P(op), &long_value, &double_value, 0); if (type == IS_LONG) { return long_value; } if (type == IS_DOUBLE) { return (long) double_value; } return 0; } } return 0; } /** * Returns the long value of a zval */ double zephir_get_doubleval_ex(const zval *op) { int type; long long_value = 0; double double_value = 0; switch (Z_TYPE_P(op)) { case IS_ARRAY: return zend_hash_num_elements(Z_ARRVAL_P(op)) ? (double) 1 : 0; break; #if PHP_VERSION_ID > 50400 case IS_CALLABLE: #endif case IS_RESOURCE: case IS_OBJECT: return (double) 1; case IS_LONG: return (double) Z_LVAL_P(op); case IS_BOOL: return (double) Z_BVAL_P(op); case IS_DOUBLE: return Z_DVAL_P(op); case IS_STRING: if ((type = is_numeric_string(Z_STRVAL_P(op), Z_STRLEN_P(op), &long_value, &double_value, 0))) { if (type == IS_LONG) { return (double) long_value; } else { if (type == IS_DOUBLE) { return double_value; } else { return 0; } } } } return 0; } /** * Returns the long value of a zval */ zend_bool zephir_get_boolval_ex(const zval *op) { int type; long long_value = 0; double double_value = 0; switch (Z_TYPE_P(op)) { case IS_ARRAY: return zend_hash_num_elements(Z_ARRVAL_P(op)) ? (zend_bool) 1 : 0; break; #if PHP_VERSION_ID > 50400 case IS_CALLABLE: #endif case IS_RESOURCE: case IS_OBJECT: return (zend_bool) 1; case IS_LONG: return (Z_LVAL_P(op) ? (zend_bool) 1 : 0); case IS_BOOL: return Z_BVAL_P(op); case IS_DOUBLE: return (Z_DVAL_P(op) ? (zend_bool) 1 : 0); case IS_STRING: if ((type = is_numeric_string(Z_STRVAL_P(op), Z_STRLEN_P(op), &long_value, &double_value, 0))) { if (type == IS_LONG) { return (long_value ? (zend_bool) 1 : 0); } else { if (type == IS_DOUBLE) { return (double_value ? (zend_bool) 1 : 0); } else { return 0; } } } } return 0; } /** * Returns the long value of a zval */ int zephir_is_numeric_ex(const zval *op) { int type; switch (Z_TYPE_P(op)) { case IS_LONG: return 1; case IS_BOOL: return 0; case IS_DOUBLE: return 1; case IS_STRING: if ((type = is_numeric_string(Z_STRVAL_P(op), Z_STRLEN_P(op), NULL, NULL, 0))) { if (type == IS_LONG || type == IS_DOUBLE) { return 1; } } } return 0; } /** * Check if two zvals are equal */ int zephir_is_equal(zval *op1, zval *op2 TSRMLS_DC) { zval result; #if PHP_VERSION_ID < 50400 is_equal_function(&result, op1, op2 TSRMLS_CC); return Z_BVAL(result); #else return fast_equal_function(&result, op1, op2 TSRMLS_CC); #endif } /** * Check if a zval is less than other */ int zephir_less(zval *op1, zval *op2 TSRMLS_DC) { zval result; #if PHP_VERSION_ID < 50400 is_smaller_function(&result, op1, op2 TSRMLS_CC); return Z_BVAL(result); #else return fast_is_smaller_function(&result, op1, op2 TSRMLS_CC); #endif } /** * Check if a zval is less/equal than other */ int zephir_less_equal(zval *op1, zval *op2 TSRMLS_DC) { zval result; is_smaller_or_equal_function(&result, op1, op2 TSRMLS_CC); return Z_BVAL(result); } /** * Check if a zval is less than a long value */ int zephir_less_long(zval *op1, long op2 TSRMLS_DC) { zval result, op2_zval; ZVAL_LONG(&op2_zval, op2); is_smaller_function(&result, op1, &op2_zval TSRMLS_CC); return Z_BVAL(result); } /** * Check if a zval is less than a double value */ int zephir_less_double(zval *op1, double op2 TSRMLS_DC) { zval result, op2_zval; ZVAL_DOUBLE(&op2_zval, op2); is_smaller_function(&result, op1, &op2_zval TSRMLS_CC); return Z_BVAL(result); } int zephir_less_equal_long(zval *op1, long op2 TSRMLS_DC) { zval result, op2_zval; ZVAL_LONG(&op2_zval, op2); is_smaller_or_equal_function(&result, op1, &op2_zval TSRMLS_CC); return Z_BVAL(result); } /** * Check if a zval is greater than other */ int zephir_greater(zval *op1, zval *op2 TSRMLS_DC) { zval result; is_smaller_or_equal_function(&result, op1, op2 TSRMLS_CC); return !Z_BVAL(result); } /** * Check if a zval is greater than a long value */ int zephir_greater_long(zval *op1, long op2 TSRMLS_DC) { zval result, op2_zval; ZVAL_LONG(&op2_zval, op2); is_smaller_or_equal_function(&result, op1, &op2_zval TSRMLS_CC); return !Z_BVAL(result); } /** * Check if a zval is greater than a double value */ int zephir_greater_double(zval *op1, double op2 TSRMLS_DC) { zval result, op2_zval; ZVAL_DOUBLE(&op2_zval, op2); is_smaller_or_equal_function(&result, op1, &op2_zval TSRMLS_CC); return !Z_BVAL(result); } /** * Check if a zval is greater/equal than other */ int zephir_greater_equal(zval *op1, zval *op2 TSRMLS_DC) { zval result; is_smaller_function(&result, op1, op2 TSRMLS_CC); return !Z_BVAL(result); } /** * Check for greater/equal */ int zephir_greater_equal_long(zval *op1, long op2 TSRMLS_DC) { zval result, op2_zval; ZVAL_LONG(&op2_zval, op2); is_smaller_function(&result, op1, &op2_zval TSRMLS_CC); return !Z_BVAL(result); } /** * Check if two zvals are identical */ int zephir_is_identical(zval *op1, zval *op2 TSRMLS_DC) { zval result; is_identical_function(&result, op1, op2 TSRMLS_CC); return Z_BVAL(result); } /** * Do bitwise_and function keeping ref_count and is_ref */ int zephir_bitwise_and_function(zval *result, zval *op1, zval *op2 TSRMLS_DC){ int status; int ref_count = Z_REFCOUNT_P(result); int is_ref = Z_ISREF_P(result); status = bitwise_and_function(result, op1, op2 TSRMLS_CC); Z_SET_REFCOUNT_P(result, ref_count); Z_SET_ISREF_TO_P(result, is_ref); return status; } /** * Do bitwise_or function keeping ref_count and is_ref */ int zephir_bitwise_or_function(zval *result, zval *op1, zval *op2 TSRMLS_DC){ int status; int ref_count = Z_REFCOUNT_P(result); int is_ref = Z_ISREF_P(result); status = bitwise_or_function(result, op1, op2 TSRMLS_CC); Z_SET_REFCOUNT_P(result, ref_count); Z_SET_ISREF_TO_P(result, is_ref); return status; } /** * Do bitwise_xor function keeping ref_count and is_ref */ int zephir_bitwise_xor_function(zval *result, zval *op1, zval *op2 TSRMLS_DC){ int status; int ref_count = Z_REFCOUNT_P(result); int is_ref = Z_ISREF_P(result); status = bitwise_xor_function(result, op1, op2 TSRMLS_CC); Z_SET_REFCOUNT_P(result, ref_count); Z_SET_ISREF_TO_P(result, is_ref); return status; } /** * Do shiftleft function keeping ref_count and is_ref */ int zephir_shift_left_function(zval *result, zval *op1, zval *op2 TSRMLS_DC){ int status; int ref_count = Z_REFCOUNT_P(result); int is_ref = Z_ISREF_P(result); status = shift_left_function(result, op1, op2 TSRMLS_CC); Z_SET_REFCOUNT_P(result, ref_count); Z_SET_ISREF_TO_P(result, is_ref); return status; } /** * Do shiftright function keeping ref_count and is_ref */ int zephir_shift_right_function(zval *result, zval *op1, zval *op2 TSRMLS_DC){ int status; int ref_count = Z_REFCOUNT_P(result); int is_ref = Z_ISREF_P(result); status = shift_right_function(result, op1, op2 TSRMLS_CC); Z_SET_REFCOUNT_P(result, ref_count); Z_SET_ISREF_TO_P(result, is_ref); return status; } /** * Do safe divisions between two longs */ double zephir_safe_div_long_long(long op1, long op2 TSRMLS_DC) { if (!op2) { zend_error(E_WARNING, "Division by zero"); return 0; } return (double) op1 / (double) op2; } /** * Do safe divisions between two long/double */ double zephir_safe_div_long_double(long op1, double op2 TSRMLS_DC) { if (!op2) { zend_error(E_WARNING, "Division by zero"); return 0; } return (double) op1 / op2; } /** * Do safe divisions between two double/long */ double zephir_safe_div_double_long(double op1, long op2 TSRMLS_DC) { if (!op2) { zend_error(E_WARNING, "Division by zero"); return 0; } return op1 / (double) op2; } /** * Do safe divisions between two doubles */ double zephir_safe_div_double_double(double op1, double op2 TSRMLS_DC) { if (!op2) { zend_error(E_WARNING, "Division by zero"); return 0; } return op1 / op2; } /** * Do safe divisions between two zval/long */ double zephir_safe_div_zval_long(zval *op1, long op2 TSRMLS_DC) { if (!op2) { zend_error(E_WARNING, "Division by zero"); return 0; } switch (Z_TYPE_P(op1)) { case IS_ARRAY: case IS_OBJECT: case IS_RESOURCE: zend_error(E_WARNING, "Unsupported operand types"); break; } return ((double) zephir_get_numberval(op1)) / (double) op2; } /** * Do safe divisions between two zval/double */ double zephir_safe_div_zval_double(zval *op1, double op2 TSRMLS_DC) { if (!op2) { zend_error(E_WARNING, "Division by zero"); return 0; } switch (Z_TYPE_P(op1)) { case IS_ARRAY: case IS_OBJECT: case IS_RESOURCE: zend_error(E_WARNING, "Unsupported operand types"); break; } return ((double) zephir_get_numberval(op1)) / op2; } /** * Do safe divisions between two long/zval */ double zephir_safe_div_long_zval(long op1, zval *op2 TSRMLS_DC) { if (!zephir_get_numberval(op2)) { zend_error(E_WARNING, "Division by zero"); return 0; } switch (Z_TYPE_P(op2)) { case IS_ARRAY: case IS_OBJECT: case IS_RESOURCE: zend_error(E_WARNING, "Unsupported operand types"); break; } return (double) op1 / ((double) zephir_get_numberval(op2)); } /** * Do safe divisions between two double/zval */ double zephir_safe_div_double_zval(double op1, zval *op2 TSRMLS_DC) { if (!zephir_get_numberval(op2)) { zend_error(E_WARNING, "Division by zero"); return 0; } switch (Z_TYPE_P(op2)) { case IS_ARRAY: case IS_OBJECT: case IS_RESOURCE: zend_error(E_WARNING, "Unsupported operand types"); break; } return op1 / ((double) zephir_get_numberval(op2)); } /** * Do safe divisions between two longs */ long zephir_safe_mod_long_long(long op1, long op2 TSRMLS_DC) { if (!op2) { zend_error(E_WARNING, "Division by zero"); return 0; } return op1 % op2; } /** * Do safe divisions between two long/double */ long zephir_safe_mod_long_double(long op1, double op2 TSRMLS_DC) { if (!op2) { zend_error(E_WARNING, "Division by zero"); return 0; } return op1 % (long) op2; } /** * Do safe divisions between two double/long */ long zephir_safe_mod_double_long(double op1, long op2 TSRMLS_DC) { if (!op2) { zend_error(E_WARNING, "Division by zero"); return 0; } return (long) op1 % op2; } /** * Do safe divisions between two doubles */ long zephir_safe_mod_double_double(double op1, double op2 TSRMLS_DC) { if (!op2) { zend_error(E_WARNING, "Division by zero"); return 0; } return (long) op1 % (long) op2; } /** * Do safe divisions between two zval/long */ long zephir_safe_mod_zval_long(zval *op1, long op2 TSRMLS_DC) { if (!op2) { zend_error(E_WARNING, "Division by zero"); return 0; } switch (Z_TYPE_P(op1)) { case IS_ARRAY: case IS_OBJECT: case IS_RESOURCE: zend_error(E_WARNING, "Unsupported operand types"); break; } return ((long) zephir_get_numberval(op1)) % (long) op2; } /** * Do safe divisions between two zval/double */ long zephir_safe_mod_zval_double(zval *op1, double op2 TSRMLS_DC) { if (!op2) { zend_error(E_WARNING, "Division by zero"); return 0; } switch (Z_TYPE_P(op1)) { case IS_ARRAY: case IS_OBJECT: case IS_RESOURCE: zend_error(E_WARNING, "Unsupported operand types"); break; } return ((long) zephir_get_numberval(op1)) % (long) op2; } /** * Do safe divisions between two long/zval */ long zephir_safe_mod_long_zval(long op1, zval *op2 TSRMLS_DC) { if (!zephir_get_numberval(op2)) { zend_error(E_WARNING, "Division by zero"); return 0; } switch (Z_TYPE_P(op2)) { case IS_ARRAY: case IS_OBJECT: case IS_RESOURCE: zend_error(E_WARNING, "Unsupported operand types"); break; } return op1 % ((long) zephir_get_numberval(op2)); } /** * Do safe divisions between two double/zval */ long zephir_safe_mod_double_zval(double op1, zval *op2 TSRMLS_DC) { if (!zephir_get_numberval(op2)) { zend_error(E_WARNING, "Division by zero"); return 0; } switch (Z_TYPE_P(op2)) { case IS_ARRAY: case IS_OBJECT: case IS_RESOURCE: zend_error(E_WARNING, "Unsupported operand types"); break; } return (long) op1 % ((long) zephir_get_numberval(op2)); }