Use size_t as a more appropriate type

Girgias · Girgias · commit f8a4dfe7677a · 2023-03-04T04:29:27.000Z
diff --git a/ext/bcmath/libbcmath/src/add.c b/ext/bcmath/libbcmath/src/add.c
@@ -31,18 +31,19 @@
 
 #include "bcmath.h"
 #include "private.h"
+#include <stddef.h>
 #include <string.h>
 
 
 /* Here is the full add routine that takes care of negative numbers.
    N1 is added to N2 and the result placed into RESULT.  SCALE_MIN
    is the minimum scale for the result. */
 
-void bc_add (bc_num n1, bc_num n2, bc_num *result, int scale_min)
+void bc_add (bc_num n1, bc_num n2, bc_num *result, size_t scale_min)
 {
 	bc_num sum = NULL;
 	int cmp_res;
-	int res_scale;
+	size_t res_scale;
 
 	if (n1->n_sign == n2->n_sign) {
 		sum = _bc_do_add (n1, n2, scale_min);
diff --git a/ext/bcmath/libbcmath/src/bcmath.h b/ext/bcmath/libbcmath/src/bcmath.h
@@ -32,19 +32,21 @@
 #ifndef _BCMATH_H_
 #define _BCMATH_H_
 
+#include <stddef.h>
+
 typedef enum {PLUS, MINUS} sign;
 
 typedef struct bc_struct *bc_num;
 
 typedef struct bc_struct {
-	sign  n_sign;
-	int   n_len;   /* The number of digits before the decimal point. */
-	int   n_scale; /* The number of digits after the decimal point. */
-	int   n_refs;  /* The number of pointers to this number. */
-	char *n_ptr;   /* The pointer to the actual storage.
+	sign   n_sign;
+	size_t n_len;   /* The number of digits before the decimal point. */
+	size_t n_scale; /* The number of digits after the decimal point. */
+	int    n_refs;  /* The number of pointers to this number. */
+	char  *n_ptr;   /* The pointer to the actual storage.
 	                  If NULL, n_value points to the inside of another number
 	                  (bc_multiply...) and should not be "freed." */
-	char *n_value;  /* The number. Not zero char terminated.
+	char  *n_value; /* The number. Not zero char terminated.
 	                   May not point to the same place as n_ptr as
 	                   in the case of leading zeros generated. */
 } bc_struct;
@@ -84,17 +86,17 @@ typedef struct bc_struct {
 
 void bc_init_numbers(void);
 
-bc_num _bc_new_num_ex(int length, int scale, bool persistent);
+bc_num _bc_new_num_ex(size_t length, size_t scale, bool persistent);
 
 void _bc_free_num_ex(bc_num *num, bool persistent);
 
 bc_num bc_copy_num(bc_num num);
 
 void bc_init_num(bc_num *num);
 
-bool bc_str2num(bc_num *num, char *str, int scale);
+bool bc_str2num(bc_num *num, char *str, size_t scale);
 
-zend_string *bc_num2str_ex(bc_num num, int scale);
+zend_string *bc_num2str_ex(bc_num num, size_t scale);
 
 void bc_int2num(bc_num *num, int val);
 
@@ -104,29 +106,29 @@ int bc_compare(bc_num n1, bc_num n2);
 
 bool bc_is_zero(bc_num num);
 
-bool bc_is_zero_for_scale(bc_num num, int scale);
+bool bc_is_zero_for_scale(bc_num num, size_t scale);
 
-bool bc_is_near_zero(bc_num num, int scale);
+bool bc_is_near_zero(bc_num num, size_t scale);
 
 bool bc_is_neg(bc_num num);
 
-void bc_add(bc_num n1, bc_num n2, bc_num *result, int scale_min);
+void bc_add(bc_num n1, bc_num n2, bc_num *result, size_t scale_min);
 
-void bc_sub(bc_num n1, bc_num n2, bc_num *result, int scale_min);
+void bc_sub(bc_num n1, bc_num n2, bc_num *result, size_t scale_min);
 
-void bc_multiply(bc_num n1, bc_num n2, bc_num *prod, int scale);
+void bc_multiply(bc_num n1, bc_num n2, bc_num *prod, size_t scale);
 
 int bc_divide(bc_num n1, bc_num n2, bc_num *quot, int scale);
 
-int bc_modulo(bc_num num1, bc_num num2, bc_num *resul, int scale);
+int bc_modulo(bc_num num1, bc_num num2, bc_num *resul, size_t scale);
 
-int bc_divmod(bc_num num1, bc_num num2, bc_num *quo, bc_num *rem, int scale);
+int bc_divmod(bc_num num1, bc_num num2, bc_num *quo, bc_num *rem, size_t scale);
 
-int bc_raisemod(bc_num base, bc_num expo, bc_num mo, bc_num *result, int scale);
+int bc_raisemod(bc_num base, bc_num expo, bc_num mo, bc_num *result, size_t scale);
 
-void bc_raise(bc_num num1, bc_num num2, bc_num *resul, int scale);
+void bc_raise(bc_num num1, bc_num num2, bc_num *resul, size_t scale);
 
-bool bc_sqrt(bc_num *num, int scale);
+bool bc_sqrt(bc_num *num, size_t scale);
 
 void bc_out_num(bc_num num, int o_base, void (* out_char)(char), bool leading_zero);
 
diff --git a/ext/bcmath/libbcmath/src/compare.c b/ext/bcmath/libbcmath/src/compare.c
@@ -30,6 +30,7 @@
 *************************************************************************/
 
 #include <stdbool.h>
+#include <stddef.h>
 #include "bcmath.h"
 #include "private.h"
 
@@ -41,7 +42,6 @@
 int _bc_do_compare(bc_num n1, bc_num n2, bool use_sign, bool ignore_last)
 {
 	char *n1ptr, *n2ptr;
-	int count;
 
 	/* First, compare signs. */
 	if (use_sign && n1->n_sign != n2->n_sign) {
@@ -73,7 +73,7 @@ int _bc_do_compare(bc_num n1, bc_num n2, bool use_sign, bool ignore_last)
 
 	/* If we get here, they have the same number of integer digits.
 	   check the integer part and the equal length part of the fraction. */
-	count = n1->n_len + MIN (n1->n_scale, n2->n_scale);
+	size_t count = n1->n_len + MIN (n1->n_scale, n2->n_scale);
 	n1ptr = n1->n_value;
 	n2ptr = n2->n_value;
 
diff --git a/ext/bcmath/libbcmath/src/debug.c b/ext/bcmath/libbcmath/src/debug.c
@@ -32,6 +32,7 @@
 #include <stdio.h>
 #include "bcmath.h"
 #include "private.h"
+#include <stddef.h>
 
 /* pn prints the number NUM in base 10. */
 
@@ -49,11 +50,10 @@ void pn(bc_num num)
 
 
 /* pv prints a character array as if it was a string of bcd digits. */
-void pv (char *name, unsigned char *num, int len)
+void pv (char *name, unsigned char *num, size_t len)
 {
-	int i;
 	printf("%s=", name);
-	for (i=0; i<len; i++){
+	for (size_t i = 0; i < len; i++){
 		printf ("%c",BCD_CHAR(num[i]));
 	}
 	printf("\n");
diff --git a/ext/bcmath/libbcmath/src/div.c b/ext/bcmath/libbcmath/src/div.c
@@ -32,6 +32,7 @@
 #include "bcmath.h"
 #include "private.h"
 #include <stdbool.h>
+#include <stddef.h>
 #include "zend_alloc.h"
 
 
@@ -40,7 +41,7 @@
    placed into RESULT.  It is written so that NUM and RESULT can be
    the same pointers.  */
 
-static void _one_mult(unsigned char *num, int size, int digit, unsigned char *result)
+static void _one_mult(unsigned char *num, size_t size, int digit, unsigned char *result)
 {
 	int carry, value;
 	unsigned char *nptr, *rptr;
diff --git a/ext/bcmath/libbcmath/src/divmod.c b/ext/bcmath/libbcmath/src/divmod.c
@@ -30,18 +30,19 @@
 *************************************************************************/
 
 #include "bcmath.h"
+#include <stddef.h>
 
 
 /* Division *and* modulo for numbers.  This computes both NUM1 / NUM2 and
    NUM1 % NUM2  and puts the results in QUOT and REM, except that if QUOT
    is NULL then that store will be omitted.
  */
 
-int bc_divmod(bc_num num1, bc_num num2, bc_num *quot, bc_num *rem, int scale)
+int bc_divmod(bc_num num1, bc_num num2, bc_num *quot, bc_num *rem, size_t scale)
 {
 	bc_num quotient = NULL;
 	bc_num temp;
-	int rscale;
+	size_t rscale;
 
 	/* Check for correct numbers. */
 	if (bc_is_zero (num2)) {
@@ -73,7 +74,7 @@ int bc_divmod(bc_num num1, bc_num num2, bc_num *quot, bc_num *rem, int scale)
 /* Modulo for numbers.  This computes NUM1 % NUM2  and puts the
    result in RESULT.   */
 
-int bc_modulo(bc_num num1, bc_num num2, bc_num *result, int scale)
+int bc_modulo(bc_num num1, bc_num num2, bc_num *result, size_t scale)
 {
 	return bc_divmod(num1, num2, NULL, result, scale);
 }
diff --git a/ext/bcmath/libbcmath/src/doaddsub.c b/ext/bcmath/libbcmath/src/doaddsub.c
@@ -31,19 +31,20 @@
 
 #include "bcmath.h"
 #include "private.h"
+#include <stddef.h>
 
 
 /* Perform addition: N1 is added to N2 and the value is
    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(bc_num n1, bc_num n2, int scale_min)
+bc_num _bc_do_add(bc_num n1, bc_num n2, size_t scale_min)
 {
 	bc_num sum;
-	int sum_scale, sum_digits;
+	size_t sum_scale, sum_digits;
 	char *n1ptr, *n2ptr, *sumptr;
-	int carry, n1bytes, n2bytes;
-	int count;
+	size_t n1bytes, n2bytes;
+	bool carry;
 
 	/* Prepare sum. */
 	sum_scale = MAX (n1->n_scale, n2->n_scale);
@@ -53,7 +54,7 @@ bc_num _bc_do_add(bc_num n1, bc_num n2, int scale_min)
 	/* Zero extra digits made by scale_min. */
 	if (scale_min > sum_scale) {
 		sumptr = (char *) (sum->n_value + sum_scale + sum_digits);
-		for (count = scale_min - sum_scale; count > 0; count--) {
+		for (int count = scale_min - sum_scale; count > 0; count--) {
 			*sumptr++ = 0;
 		}
 	}
@@ -105,16 +106,16 @@ bc_num _bc_do_add(bc_num n1, bc_num n2, int scale_min)
 	while (n1bytes-- > 0) {
 		*sumptr = *n1ptr-- + carry;
 		if (*sumptr > (BASE-1)) {
-			carry = 1;
+			carry = true;
 			*sumptr -= BASE;
 		} else {
-			carry = 0;
+			carry = false;
 		}
 		sumptr--;
 	}
 
 	/* Set final carry. */
-	if (carry == 1) {
+	if (carry) {
 		*sumptr += 1;
 	}
 
@@ -128,11 +129,11 @@ bc_num _bc_do_add(bc_num n1, bc_num n2, int scale_min)
    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(bc_num n1, bc_num n2, int scale_min)
+bc_num _bc_do_sub(bc_num n1, bc_num n2, size_t scale_min)
 {
 	bc_num diff;
 	int diff_scale, diff_len;
-	int min_scale, min_len;
+	size_t min_scale, min_len;
 	char *n1ptr, *n2ptr, *diffptr;
 	int borrow, count, val;
 
diff --git a/ext/bcmath/libbcmath/src/init.c b/ext/bcmath/libbcmath/src/init.c
@@ -31,10 +31,11 @@
 
 #include "bcmath.h"
 #include <stdbool.h>
+#include <stddef.h>
 #include "zend_alloc.h"
 
 /* new_num allocates a number and sets fields to known values. */
-bc_num _bc_new_num_ex(int length, int scale, bool persistent)
+bc_num _bc_new_num_ex(size_t length, size_t scale, bool persistent)
 {
 	bc_num temp;
 	/* PHP Change: malloc() -> pemalloc(), removed free_list code */
diff --git a/ext/bcmath/libbcmath/src/nearzero.c b/ext/bcmath/libbcmath/src/nearzero.c
@@ -30,25 +30,23 @@
 *************************************************************************/
 
 #include <stdbool.h>
+#include <stddef.h>
 #include "bcmath.h"
 
 /* In some places we need to check if the number NUM is almost zero.
    Specifically, all but the last digit is 0 and the last digit is 1.
    Last digit is defined by scale. */
 
-bool bc_is_near_zero(bc_num num, int scale)
+bool bc_is_near_zero(bc_num num, size_t scale)
 {
-	int  count;
-	char *nptr;
-
 	/* Error checking */
 	if (scale > num->n_scale) {
 		scale = num->n_scale;
 	}
 
 	/* Initialize */
-	count = num->n_len + scale;
-	nptr = num->n_value;
+	size_t count = num->n_len + scale;
+	const char *nptr = num->n_value;
 
 	/* The check */
 	while ((count > 0) && (*nptr++ == 0)) {
diff --git a/ext/bcmath/libbcmath/src/num2long.c b/ext/bcmath/libbcmath/src/num2long.c
@@ -30,6 +30,7 @@
 *************************************************************************/
 
 #include "bcmath.h"
+#include <stddef.h>
 
 /* Convert a number NUM to a long.  The function returns only the integer
    part of the number.  For numbers that are too large to represent as
@@ -40,12 +41,11 @@ long bc_num2long(bc_num num)
 {
 	long val;
 	char *nptr;
-	int  index;
 
 	/* Extract the int value, ignore the fraction. */
 	val = 0;
 	nptr = num->n_value;
-	for (index = num->n_len; index > 0; index--) {
+	for (size_t index = num->n_len; index > 0; index--) {
 		char n = *nptr++;
 
 		if (val > LONG_MAX/BASE) {
diff --git a/ext/bcmath/libbcmath/src/num2str.c b/ext/bcmath/libbcmath/src/num2str.c
@@ -30,10 +30,11 @@
 *************************************************************************/
 
 #include "bcmath.h"
+#include <stddef.h>
 #include "zend_string.h"
 
 /* Convert a numbers to a string.  Base 10 only.*/
-zend_string *bc_num2str_ex(bc_num num, int scale)
+zend_string *bc_num2str_ex(bc_num num, size_t scale)
 {
 	zend_string *str;
 	char *sptr;
diff --git a/ext/bcmath/libbcmath/src/private.h b/ext/bcmath/libbcmath/src/private.h
@@ -32,9 +32,10 @@
 /* "Private" routines to bcmath. */
 
 #include <stdbool.h>
+#include <stddef.h>
 
 /* routines */
 int _bc_do_compare (bc_num n1, bc_num n2, bool use_sign, bool ignore_last);
-bc_num _bc_do_add (bc_num n1, bc_num n2, int scale_min);
-bc_num _bc_do_sub (bc_num n1, bc_num n2, int scale_min);
+bc_num _bc_do_add (bc_num n1, bc_num n2, size_t scale_min);
+bc_num _bc_do_sub (bc_num n1, bc_num n2, size_t scale_min);
 void _bc_rm_leading_zeros (bc_num num);
diff --git a/ext/bcmath/libbcmath/src/raise.c b/ext/bcmath/libbcmath/src/raise.c
@@ -31,20 +31,21 @@
 
 #include "bcmath.h"
 #include <stdbool.h>
+#include <stddef.h>
 #include "zend_exceptions.h" /* zend_argument_value_error() */
 
 
 /* Raise NUM1 to the NUM2 power.  The result is placed in RESULT.
    Maximum exponent is LONG_MAX.  If a NUM2 is not an integer,
    only the integer part is used.  */
 
-void bc_raise(bc_num num1, bc_num num2, bc_num *result, int scale)
+void bc_raise(bc_num num1, bc_num num2, bc_num *result, size_t scale)
 {
 	bc_num temp, power;
 	long exponent;
-	int rscale;
-	int pwrscale;
-	int calcscale;
+	size_t rscale;
+	size_t pwrscale;
+	size_t calcscale;
 	bool is_neg;
 
 	/* Check the exponent for scale digits and convert to a long. */
diff --git a/ext/bcmath/libbcmath/src/raisemod.c b/ext/bcmath/libbcmath/src/raisemod.c
diff --git a/ext/bcmath/libbcmath/src/recmul.c b/ext/bcmath/libbcmath/src/recmul.c
diff --git a/ext/bcmath/libbcmath/src/sqrt.c b/ext/bcmath/libbcmath/src/sqrt.c
diff --git a/ext/bcmath/libbcmath/src/str2num.c b/ext/bcmath/libbcmath/src/str2num.c
diff --git a/ext/bcmath/libbcmath/src/sub.c b/ext/bcmath/libbcmath/src/sub.c
diff --git a/ext/bcmath/libbcmath/src/zero.c b/ext/bcmath/libbcmath/src/zero.c
