ext/random: Various minor refactorings

UPGRADING.INTERNALS

@@ -58,6 +58,10 @@ PHP 8.6 INTERNALS UPGRADE NOTES
 3. Module changes
 ========================
 
+- ext/random:
+  . The {un}serialize function pointer fields of the php_random_algo struct
+    now have const qualifiers.
+
 - ext/xml:
   . Removed the XML_ExpatVersion() libxml compatibility wrapper,
     as it was unused.

ext/random/engine_mt19937.c

@@ -127,15 +127,15 @@ static inline void mt19937_reload(php_random_status_state_mt19937 *state)
 
 PHPAPI inline void php_random_mt19937_seed32(php_random_status_state_mt19937 *state, uint32_t seed)
 {
-	uint32_t i, prev_state;
+	uint32_t i;
 
 	/* Initialize generator state with seed
 	   See Knuth TAOCP Vol 2, 3rd Ed, p.106 for multiplier.
 	   In previous versions, most significant bits (MSBs) of the seed affect
 	   only MSBs of the state array.  Modified 9 Jan 2002 by Makoto Matsumoto. */
 	state->state[0] = seed;
 	for (i = 1; i < N; i++) {
-		prev_state = state->state[i - 1];
+		uint32_t prev_state = state->state[i - 1];
 		state->state[i] = (1812433253U * (prev_state  ^ (prev_state  >> 30)) + i) & 0xffffffffU;
 	}
 	state->count = i;
@@ -171,9 +171,9 @@ static zend_long range(void *state, zend_long min, zend_long max)
 	}, min, max);
 }
 
-static bool serialize(void *state, HashTable *data)
+static bool serialize(const void *state, HashTable *data)
 {
-	php_random_status_state_mt19937 *s = state;
+	const php_random_status_state_mt19937 *s = state;
 	zval t;
 
 	for (uint32_t i = 0; i < N; i++) {
@@ -188,7 +188,7 @@ static bool serialize(void *state, HashTable *data)
 	return true;
 }
 
-static bool unserialize(void *state, HashTable *data)
+static bool unserialize(void *state, const HashTable *data)
 {
 	php_random_status_state_mt19937 *s = state;
 	zval *t;

ext/random/engine_pcgoneseq128xslrr64.c

@@ -63,9 +63,9 @@ static zend_long range(void *state, zend_long min, zend_long max)
 	}, min, max);
 }
 
-static bool serialize(void *state, HashTable *data)
+static bool serialize(const void *state, HashTable *data)
 {
-	php_random_status_state_pcgoneseq128xslrr64 *s = state;
+	const php_random_status_state_pcgoneseq128xslrr64 *s = state;
 	uint64_t u;
 	zval z;
 
@@ -80,19 +80,18 @@ static bool serialize(void *state, HashTable *data)
 	return true;
 }
 
-static bool unserialize(void *state, HashTable *data)
+static bool unserialize(void *state, const HashTable *data)
 {
 	php_random_status_state_pcgoneseq128xslrr64 *s = state;
 	uint64_t u[2];
-	zval *t;
 
 	/* Verify the expected number of elements, this implicitly ensures that no additional elements are present. */
 	if (zend_hash_num_elements(data) != 2) {
 		return false;
 	}
 
 	for (uint32_t i = 0; i < 2; i++) {
-		t = zend_hash_index_find(data, i);
+		zval *t = zend_hash_index_find(data, i);
 		if (!t || Z_TYPE_P(t) != IS_STRING || Z_STRLEN_P(t) != (2 * sizeof(uint64_t))) {
 			return false;
 		}

ext/random/engine_xoshiro256starstar.c

@@ -118,9 +118,9 @@ static zend_long range(void *state, zend_long min, zend_long max)
 	}, min, max);
 }
 
-static bool serialize(void *state, HashTable *data)
+static bool serialize(const void *state, HashTable *data)
 {
-	php_random_status_state_xoshiro256starstar *s = state;
+	const php_random_status_state_xoshiro256starstar *s = state;
 	zval t;
 
 	for (uint32_t i = 0; i < 4; i++) {
@@ -131,18 +131,17 @@ static bool serialize(void *state, HashTable *data)
 	return true;
 }
 
-static bool unserialize(void *state, HashTable *data)
+static bool unserialize(void *state, const HashTable *data)
 {
 	php_random_status_state_xoshiro256starstar *s = state;
-	zval *t;
 
 	/* Verify the expected number of elements, this implicitly ensures that no additional elements are present. */
 	if (zend_hash_num_elements(data) != 4) {
 		return false;
 	}
 
 	for (uint32_t i = 0; i < 4; i++) {
-		t = zend_hash_index_find(data, i);
+		zval *t = zend_hash_index_find(data, i);
 		if (!t || Z_TYPE_P(t) != IS_STRING || Z_STRLEN_P(t) != (2 * sizeof(uint64_t))) {
 			return false;
 		}

ext/random/php_random.h

@@ -89,8 +89,8 @@ typedef struct _php_random_algo {
 	const size_t state_size;
 	php_random_result (*generate)(void *state);
 	zend_long (*range)(void *state, zend_long min, zend_long max);
-	bool (*serialize)(void *state, HashTable *data);
-	bool (*unserialize)(void *state, HashTable *data);
+	bool (*serialize)(const void *state, HashTable *data);
+	bool (*unserialize)(void *state, const HashTable *data);
 } php_random_algo;
 
 typedef struct _php_random_algo_with_state {
@@ -149,7 +149,7 @@ static inline php_random_randomizer *php_random_randomizer_from_obj(zend_object
 # define Z_RANDOM_RANDOMIZER_P(zval) php_random_randomizer_from_obj(Z_OBJ_P(zval));
 
 PHPAPI void *php_random_status_alloc(const php_random_algo *algo, const bool persistent);
-PHPAPI void *php_random_status_copy(const php_random_algo *algo, void *old_status, void *new_status);
+PHPAPI void *php_random_status_copy(const php_random_algo *algo, const void *old_status, void *new_status);
 PHPAPI void php_random_status_free(void *status, const bool persistent);
 PHPAPI php_random_engine *php_random_engine_common_init(zend_class_entry *ce, const php_random_algo *algo);
 PHPAPI void php_random_engine_common_free_object(zend_object *object);
@@ -169,7 +169,7 @@ static inline php_random_algo_with_state php_random_default_engine(void)
 }
 
 PHPAPI zend_string *php_random_bin2hex_le(const void *ptr, const size_t len);
-PHPAPI bool php_random_hex2bin_le(zend_string *hexstr, void *dest);
+PHPAPI bool php_random_hex2bin_le(const zend_string *hexstr, void *dest);
 
 PHPAPI void php_random_mt19937_seed32(php_random_status_state_mt19937 *state, uint32_t seed);
 PHPAPI void php_random_mt19937_seed_default(php_random_status_state_mt19937 *state);

ext/random/random.c

@@ -240,7 +240,7 @@ PHPAPI void *php_random_status_alloc(const php_random_algo *algo, const bool per
 	return algo->state_size > 0 ? pecalloc(1, algo->state_size, persistent) : NULL;
 }
 
-PHPAPI void *php_random_status_copy(const php_random_algo *algo, void *old_status, void *new_status)
+PHPAPI void *php_random_status_copy(const php_random_algo *algo, const void *old_status, void *new_status)
 {
 	return memcpy(new_status, old_status, algo->state_size);
 }
@@ -354,12 +354,12 @@ PHPAPI zend_string *php_random_bin2hex_le(const void *ptr, const size_t len)
 
 /* {{{ php_random_hex2bin_le */
 /* stolen from standard/string.c */
-PHPAPI bool php_random_hex2bin_le(zend_string *hexstr, void *dest)
+PHPAPI bool php_random_hex2bin_le(const zend_string *hexstr, void *dest)
 {
 	size_t len = hexstr->len >> 1;
-	unsigned char *str = (unsigned char *) hexstr->val, c, l, d;
+	const unsigned char *str = (unsigned char *) ZSTR_VAL(hexstr);
 	unsigned char *ptr = (unsigned char *) dest;
-	int is_letter, i = 0;
+	uint32_t i = 0;
 
 #ifdef WORDS_BIGENDIAN
 	/* force little endian */
@@ -368,9 +368,10 @@ PHPAPI bool php_random_hex2bin_le(zend_string *hexstr, void *dest)
 #else
 	for (size_t j = 0; j < len; j++) {
 #endif
-		c = str[i++];
-		l = c & ~0x20;
-		is_letter = ((uint32_t) ((l - 'A') ^ (l - 'F' - 1))) >> (8 * sizeof(uint32_t) - 1);
+		unsigned char c = str[i++];
+		unsigned char l = c & ~0x20;
+		uint32_t is_letter = ((uint32_t) ((l - 'A') ^ (l - 'F' - 1))) >> (8 * sizeof(uint32_t) - 1);
+		unsigned char d;
 
 		/* basically (c >= '0' && c <= '9') || (l >= 'A' && l <= 'F') */
 		if (EXPECTED((((c ^ '0') - 10) >> (8 * sizeof(uint32_t) - 1)) | is_letter)) {
@@ -461,7 +462,7 @@ PHPAPI zend_long php_mt_rand_range(zend_long min, zend_long max)
  * rand() allows min > max, mt_rand does not */
 PHPAPI zend_long php_mt_rand_common(zend_long min, zend_long max)
 {
-	php_random_status_state_mt19937 *s = php_random_default_status();
+	const php_random_status_state_mt19937 *s = php_random_default_status();
 
 	if (s->mode == MT_RAND_MT19937) {
 		return php_mt_rand_range(min, max);
@@ -523,9 +524,8 @@ PHP_FUNCTION(mt_srand)
 PHP_FUNCTION(mt_rand)
 {
 	zend_long min, max;
-	int argc = ZEND_NUM_ARGS();
 
-	if (argc == 0) {
+	if (ZEND_NUM_ARGS() == 0) {
 		/* genrand_int31 in mt19937ar.c performs a right shift */
 		RETURN_LONG(php_mt_rand() >> 1);
 	}
@@ -561,9 +561,8 @@ PHP_FUNCTION(mt_getrandmax)
 PHP_FUNCTION(rand)
 {
 	zend_long min, max;
-	int argc = ZEND_NUM_ARGS();
 
-	if (argc == 0) {
+	if (ZEND_NUM_ARGS() == 0) {
 		/* genrand_int31 in mt19937ar.c performs a right shift */
 		RETURN_LONG(php_mt_rand() >> 1);
 	}
@@ -632,7 +631,7 @@ PHP_FUNCTION(random_int)
 }
 /* }}} */
 
-static inline void fallback_seed_add(PHP_SHA1_CTX *c, void *p, size_t l){
+static inline void fallback_seed_add(PHP_SHA1_CTX *c, const void *p, size_t l){
 	/* Wrapper around PHP_SHA1Update allowing to pass
 	 * arbitrary pointers without (unsigned char*) casts
 	 * everywhere.

ext/random/randomizer.c

@@ -86,7 +86,7 @@ PHP_METHOD(Random_Randomizer, __construct)
 /* {{{ Generate a float in [0, 1) */
 PHP_METHOD(Random_Randomizer, nextFloat)
 {
-	php_random_randomizer *randomizer = Z_RANDOM_RANDOMIZER_P(ZEND_THIS);
+	const php_random_randomizer *randomizer = Z_RANDOM_RANDOMIZER_P(ZEND_THIS);
 	php_random_algo_with_state engine = randomizer->engine;
 
 	uint64_t result;
@@ -129,7 +129,7 @@ PHP_METHOD(Random_Randomizer, nextFloat)
  */
 PHP_METHOD(Random_Randomizer, getFloat)
 {
-	php_random_randomizer *randomizer = Z_RANDOM_RANDOMIZER_P(ZEND_THIS);
+	const php_random_randomizer *randomizer = Z_RANDOM_RANDOMIZER_P(ZEND_THIS);
 	double min, max;
 	zend_object *bounds = NULL;
 	int bounds_type = 'C' + sizeof("ClosedOpen") - 1;
@@ -152,8 +152,8 @@ PHP_METHOD(Random_Randomizer, getFloat)
 	}
 
 	if (bounds) {
-		zval *case_name = zend_enum_fetch_case_name(bounds);
-		zend_string *bounds_name = Z_STR_P(case_name);
+		const zval *case_name = zend_enum_fetch_case_name(bounds);
+		const zend_string *bounds_name = Z_STR_P(case_name);
 
 		bounds_type = ZSTR_VAL(bounds_name)[0] + ZSTR_LEN(bounds_name);
 	}
@@ -203,7 +203,7 @@ PHP_METHOD(Random_Randomizer, getFloat)
 /* {{{ Generate positive random number */
 PHP_METHOD(Random_Randomizer, nextInt)
 {
-	php_random_randomizer *randomizer = Z_RANDOM_RANDOMIZER_P(ZEND_THIS);
+	const php_random_randomizer *randomizer = Z_RANDOM_RANDOMIZER_P(ZEND_THIS);
 	php_random_algo_with_state engine = randomizer->engine;
 
 	ZEND_PARSE_PARAMETERS_NONE();
@@ -224,7 +224,7 @@ PHP_METHOD(Random_Randomizer, nextInt)
 /* {{{ Generate random number in range */
 PHP_METHOD(Random_Randomizer, getInt)
 {
-	php_random_randomizer *randomizer = Z_RANDOM_RANDOMIZER_P(ZEND_THIS);
+	const php_random_randomizer *randomizer = Z_RANDOM_RANDOMIZER_P(ZEND_THIS);
 	php_random_algo_with_state engine = randomizer->engine;
 
 	uint64_t result;
@@ -267,7 +267,7 @@ PHP_METHOD(Random_Randomizer, getInt)
 /* {{{ Generate random bytes string in ordered length */
 PHP_METHOD(Random_Randomizer, getBytes)
 {
-	php_random_randomizer *randomizer = Z_RANDOM_RANDOMIZER_P(ZEND_THIS);
+	const php_random_randomizer *randomizer = Z_RANDOM_RANDOMIZER_P(ZEND_THIS);
 	php_random_algo_with_state engine = randomizer->engine;
 
 	zend_string *retval;
@@ -342,7 +342,7 @@ PHP_METHOD(Random_Randomizer, getBytes)
 /* {{{ Shuffling array */
 PHP_METHOD(Random_Randomizer, shuffleArray)
 {
-	php_random_randomizer *randomizer = Z_RANDOM_RANDOMIZER_P(ZEND_THIS);
+	const php_random_randomizer *randomizer = Z_RANDOM_RANDOMIZER_P(ZEND_THIS);
 	zval *array;
 
 	ZEND_PARSE_PARAMETERS_START(1, 1)
@@ -359,7 +359,7 @@ PHP_METHOD(Random_Randomizer, shuffleArray)
 /* {{{ Shuffling binary */
 PHP_METHOD(Random_Randomizer, shuffleBytes)
 {
-	php_random_randomizer *randomizer = Z_RANDOM_RANDOMIZER_P(ZEND_THIS);
+	const php_random_randomizer *randomizer = Z_RANDOM_RANDOMIZER_P(ZEND_THIS);
 	zend_string *bytes;
 
 	ZEND_PARSE_PARAMETERS_START(1, 1)
@@ -380,8 +380,8 @@ PHP_METHOD(Random_Randomizer, shuffleBytes)
 /* {{{ Pick keys */
 PHP_METHOD(Random_Randomizer, pickArrayKeys)
 {
-	php_random_randomizer *randomizer = Z_RANDOM_RANDOMIZER_P(ZEND_THIS);
-	zval *input, t;
+	const php_random_randomizer *randomizer = Z_RANDOM_RANDOMIZER_P(ZEND_THIS);
+	zval *input;
 	zend_long num_req;
 
 	ZEND_PARSE_PARAMETERS_START(2, 2);
@@ -401,6 +401,7 @@ PHP_METHOD(Random_Randomizer, pickArrayKeys)
 
 	/* Keep compatibility, But the result is always an array */
 	if (Z_TYPE_P(return_value) != IS_ARRAY) {
+		zval t;
 		ZVAL_COPY_VALUE(&t, return_value);
 		array_init(return_value);
 		zend_hash_next_index_insert(Z_ARRVAL_P(return_value), &t);
@@ -411,7 +412,7 @@ PHP_METHOD(Random_Randomizer, pickArrayKeys)
 /* {{{ Get Random Bytes for String */
 PHP_METHOD(Random_Randomizer, getBytesFromString)
 {
-	php_random_randomizer *randomizer = Z_RANDOM_RANDOMIZER_P(ZEND_THIS);
+	const php_random_randomizer *randomizer = Z_RANDOM_RANDOMIZER_P(ZEND_THIS);
 	php_random_algo_with_state engine = randomizer->engine;
 
 	zend_long user_length;

ext/standard/string.c

@@ -88,20 +88,20 @@ static zend_string *php_hex2bin(const unsigned char *old, const size_t oldlen)
 	for (i = j = 0; i < target_length; i++) {
 		unsigned char c = old[j++];
 		unsigned char l = c & ~0x20;
-		int is_letter = ((unsigned int) ((l - 'A') ^ (l - 'F' - 1))) >> (8 * sizeof(unsigned int) - 1);
+		uint32_t is_letter = ((uint32_t) ((l - 'A') ^ (l - 'F' - 1))) >> (8 * sizeof(uint32_t) - 1);
 		unsigned char d;
 
 		/* basically (c >= '0' && c <= '9') || (l >= 'A' && l <= 'F') */
-		if (EXPECTED((((c ^ '0') - 10) >> (8 * sizeof(unsigned int) - 1)) | is_letter)) {
+		if (EXPECTED((((c ^ '0') - 10) >> (8 * sizeof(uint32_t) - 1)) | is_letter)) {
 			d = (l - 0x10 - 0x27 * is_letter) << 4;
 		} else {
 			zend_string_efree(str);
 			return NULL;
 		}
 		c = old[j++];
 		l = c & ~0x20;
-		is_letter = ((unsigned int) ((l - 'A') ^ (l - 'F' - 1))) >> (8 * sizeof(unsigned int) - 1);
-		if (EXPECTED((((c ^ '0') - 10) >> (8 * sizeof(unsigned int) - 1)) | is_letter)) {
+		is_letter = ((uint32_t) ((l - 'A') ^ (l - 'F' - 1))) >> (8 * sizeof(uint32_t) - 1);
+		if (EXPECTED((((c ^ '0') - 10) >> (8 * sizeof(uint32_t) - 1)) | is_letter)) {
 			d |= l - 0x10 - 0x27 * is_letter;
 		} else {
 			zend_string_efree(str);