Changed const bc_num back to bc_num

Author: SakiTakamachi

ext/bcmath/bcmath.c

@@ -1019,7 +1019,7 @@ static void bcmath_number_register_class(void)
 }
 
 static zend_always_inline void bcmath_number_add_internal(
-	const bc_num n1, const bc_num n2, bc_num *ret,
+	bc_num n1, bc_num n2, bc_num *ret,
 	size_t n1_full_scale, size_t n2_full_scale, size_t *scale, bool auto_scale
 ) {
 	if (auto_scale) {
@@ -1031,7 +1031,7 @@ static zend_always_inline void bcmath_number_add_internal(
 }
 
 static zend_always_inline void bcmath_number_sub_internal(
-	const bc_num n1, const bc_num n2, bc_num *ret,
+	bc_num n1, bc_num n2, bc_num *ret,
 	size_t n1_full_scale, size_t n2_full_scale, size_t *scale, bool auto_scale
 ) {
 	if (auto_scale) {
@@ -1043,7 +1043,7 @@ static zend_always_inline void bcmath_number_sub_internal(
 }
 
 static zend_always_inline zend_result bcmath_number_mul_internal(
-	const bc_num n1, const bc_num n2, bc_num *ret,
+	bc_num n1, bc_num n2, bc_num *ret,
 	size_t n1_full_scale, size_t n2_full_scale, size_t *scale, bool auto_scale
 ) {
 	if (auto_scale) {
@@ -1060,7 +1060,7 @@ static zend_always_inline zend_result bcmath_number_mul_internal(
 }
 
 static zend_always_inline zend_result bcmath_number_div_internal(
-	const bc_num n1, const bc_num n2, bc_num *ret,
+	bc_num n1, bc_num n2, bc_num *ret,
 	size_t n1_full_scale, size_t *scale, bool auto_scale
 ) {
 	if (auto_scale) {
@@ -1083,7 +1083,7 @@ static zend_always_inline zend_result bcmath_number_div_internal(
 }
 
 static zend_always_inline zend_result bcmath_number_mod_internal(
-	const bc_num n1, const bc_num n2, bc_num *ret,
+	bc_num n1, bc_num n2, bc_num *ret,
 	size_t n1_full_scale, size_t n2_full_scale, size_t *scale, bool auto_scale
 ) {
 	if (auto_scale) {

ext/bcmath/libbcmath/src/add.c

@@ -39,7 +39,7 @@
    N1 is added to N2 and the result placed into RESULT.  SCALE_MIN
    is the minimum scale for the result. */
 
-bc_num bc_add(const bc_num n1, const bc_num n2, size_t scale_min)
+bc_num bc_add(bc_num n1, bc_num n2, size_t scale_min)
 {
 	bc_num sum = NULL;
 

ext/bcmath/libbcmath/src/compare.c

@@ -39,7 +39,7 @@
    than N2 and +1 if N1 is greater than N2.  If USE_SIGN is false, just
    compare the magnitudes. */
 
-bcmath_compare_result _bc_do_compare(const bc_num n1, const bc_num n2, size_t scale, bool use_sign)
+bcmath_compare_result _bc_do_compare(bc_num n1, bc_num n2, size_t scale, bool use_sign)
 {
 	/* First, compare signs. */
 	if (use_sign && n1->n_sign != n2->n_sign) {
@@ -149,7 +149,7 @@ bcmath_compare_result _bc_do_compare(const bc_num n1, const bc_num n2, size_t sc
 
 
 /* This is the "user callable" routine to compare numbers N1 and N2. */
-bcmath_compare_result bc_compare(const bc_num n1, const bc_num n2, size_t scale)
+bcmath_compare_result bc_compare(bc_num n1, bc_num n2, size_t scale)
 {
 	return _bc_do_compare(n1, n2, scale, true);
 }

ext/bcmath/libbcmath/src/div.c

@@ -300,7 +300,7 @@ static void bc_do_div(
 	}
 }
 
-static inline void bc_divide_by_one(const bc_num numerator, bc_num *quot, size_t quot_scale)
+static inline void bc_divide_by_one(bc_num numerator, bc_num *quot, size_t quot_scale)
 {
 	quot_scale = MIN(numerator->n_scale, quot_scale);
 	*quot = bc_new_num_nonzeroed(numerator->n_len, quot_scale);
@@ -332,7 +332,7 @@ static inline void bc_divide_by_pow_10(
 	}
 }
 
-bool bc_divide(const bc_num numerator, const bc_num divisor, bc_num *quot, size_t scale)
+bool bc_divide(bc_num numerator, bc_num divisor, bc_num *quot, size_t scale)
 {
 	/* divide by zero */
 	if (bc_is_zero(divisor)) {

ext/bcmath/libbcmath/src/divmod.c

@@ -41,7 +41,7 @@
    true otherwise for success.
  */
 
-bool bc_divmod(const bc_num num1, const bc_num num2, bc_num *quot, bc_num *rem, size_t scale)
+bool bc_divmod(bc_num num1, bc_num num2, bc_num *quot, bc_num *rem, size_t scale)
 {
 	bc_num quotient = NULL;
 	bc_num temp;
@@ -84,7 +84,7 @@ bool bc_divmod(const bc_num num1, const bc_num num2, bc_num *quot, bc_num *rem,
 /* Modulo for numbers.  This computes NUM1 % NUM2  and puts the
    result in RESULT.   */
 
-bool bc_modulo(const bc_num num1, const bc_num num2, bc_num *result, size_t scale)
+bool bc_modulo(bc_num num1, bc_num num2, bc_num *result, size_t scale)
 {
 	return bc_divmod(num1, num2, NULL, result, scale);
 }

ext/bcmath/libbcmath/src/doaddsub.c

@@ -38,7 +38,7 @@
    returned.  The signs of N1 and N2 are ignored.
    SCALE_MIN is to set the minimum scale of the result. */
 
-bc_num _bc_do_add(const bc_num n1, const bc_num n2)
+bc_num _bc_do_add(bc_num n1, bc_num n2)
 {
 	bc_num sum;
 	size_t sum_len = MAX(n1->n_len, n2->n_len) + 1;
@@ -169,7 +169,7 @@ bc_num _bc_do_add(const bc_num n1, const bc_num n2)
    returned.  The signs of N1 and N2 are ignored.  Also, N1 is
    assumed to be larger than N2.  SCALE_MIN is the minimum scale
    of the result. */
-bc_num _bc_do_sub(const bc_num n1, const bc_num n2)
+bc_num _bc_do_sub(bc_num n1, bc_num n2)
 {
 	bc_num diff;
 	/* The caller is guaranteed that n1 is always large. */

ext/bcmath/libbcmath/src/floor_or_ceil.c

@@ -18,7 +18,7 @@
 #include "private.h"
 #include <stddef.h>
 
-bc_num bc_floor_or_ceil(const bc_num num, bool is_floor)
+bc_num bc_floor_or_ceil(bc_num num, bool is_floor)
 {
 	/*  Initialize result */
 	bc_num result = bc_new_num(num->n_len, 0);

ext/bcmath/libbcmath/src/private.h

@@ -81,9 +81,9 @@ static const BC_VECTOR BC_POW_10_LUT[9] = {
 
 
 /* routines */
-bcmath_compare_result _bc_do_compare (const bc_num n1, const bc_num n2, size_t scale, bool use_sign);
-bc_num _bc_do_add (const bc_num n1, const bc_num n2);
-bc_num _bc_do_sub (const bc_num n1, const bc_num n2);
+bcmath_compare_result _bc_do_compare (bc_num n1, bc_num n2, size_t scale, bool use_sign);
+bc_num _bc_do_add (bc_num n1, bc_num n2);
+bc_num _bc_do_sub (bc_num n1, bc_num n2);
 void _bc_rm_leading_zeros (bc_num num);
 
 #endif

ext/bcmath/libbcmath/src/recmul.c

@@ -52,7 +52,7 @@ static inline void bc_mul_carry_calc(BC_VECTOR *prod_vector, size_t prod_arr_siz
  * If the n_values of n1 and n2 are both 4 (32-bit) or 8 (64-bit) digits or less,
  * the calculation will be performed at high speed without using an array.
  */
-static inline void bc_fast_mul(const bc_num n1, size_t n1len, const bc_num n2, size_t n2len, bc_num *prod)
+static inline void bc_fast_mul(bc_num n1, size_t n1len, bc_num n2, size_t n2len, bc_num *prod)
 {
 	const char *n1end = n1->n_value + n1len - 1;
 	const char *n2end = n2->n_value + n2len - 1;
@@ -76,7 +76,7 @@ static inline void bc_fast_mul(const bc_num n1, size_t n1len, const bc_num n2, s
  * Equivalent of bc_fast_mul for small numbers to perform computations
  * without using array.
  */
-static inline void bc_fast_square(const bc_num n1, size_t n1len, bc_num *prod)
+static inline void bc_fast_square(bc_num n1, size_t n1len, bc_num *prod)
 {
 	const char *n1end = n1->n_value + n1len - 1;
 
@@ -119,7 +119,7 @@ static inline void bc_mul_finish_from_vector(BC_VECTOR *prod_vector, size_t prod
  * Multiply and add these groups of numbers to perform multiplication fast.
  * How much to shift the digits when adding values can be calculated from the index of the array.
  */
-static void bc_standard_mul(const bc_num n1, size_t n1len, const bc_num n2, size_t n2len, bc_num *prod)
+static void bc_standard_mul(bc_num n1, size_t n1len, bc_num n2, size_t n2len, bc_num *prod)
 {
 	size_t i;
 	const char *n1end = n1->n_value + n1len - 1;
@@ -181,7 +181,7 @@ static void bc_standard_mul(const bc_num n1, size_t n1len, const bc_num n2, size
 }
 
 /** This is bc_standard_mul implementation for square */
-static void bc_standard_square(const bc_num n1, size_t n1len, bc_num *prod)
+static void bc_standard_square(bc_num n1, size_t n1len, bc_num *prod)
 {
 	size_t i;
 	const char *n1end = n1->n_value + n1len - 1;

ext/bcmath/libbcmath/src/round.c

@@ -19,7 +19,7 @@
 #include <stddef.h>
 
 /* Returns the scale of the value after rounding. */
-size_t bc_round(const bc_num num, zend_long precision, zend_long mode, bc_num *result)
+size_t bc_round(bc_num num, zend_long precision, zend_long mode, bc_num *result)
 {
 	/* clear result */
 	bc_free_num(result);