ext/hash: Specialize copy function typedef

Girgias · Girgias · commit c26e77c4c57a · 2024-08-23T17:41:33.000+01:00
diff --git a/ext/hash/hash.c b/ext/hash/hash.c
@@ -105,7 +105,7 @@ static struct mhash_bc_entry mhash_to_hash[MHASH_NUM_ALGOS] = {
 PHP_HASH_API const php_hash_ops *php_hash_fetch_ops(zend_string *algo) /* {{{ */
 {
 	zend_string *lower = zend_string_tolower(algo);
-	php_hash_ops *ops = zend_hash_find_ptr(&php_hash_hashtable, lower);
+	const php_hash_ops *ops = zend_hash_find_ptr(&php_hash_hashtable, lower);
 	zend_string_release(lower);
 
 	return ops;
@@ -121,7 +121,7 @@ PHP_HASH_API void php_hash_register_algo(const char *algo, const php_hash_ops *o
 }
 /* }}} */
 
-PHP_HASH_API int php_hash_copy(const void *ops, void *orig_context, void *dest_context) /* {{{ */
+PHP_HASH_API zend_result php_hash_copy(const void *ops, const void *orig_context, void *dest_context) /* {{{ */
 {
 	php_hash_ops *hash_ops = (php_hash_ops *)ops;
 
diff --git a/ext/hash/hash_adler32.c b/ext/hash/hash_adler32.c
@@ -52,7 +52,7 @@ PHP_HASH_API void PHP_ADLER32Final(unsigned char digest[4], PHP_ADLER32_CTX *con
 	context->state = 0;
 }
 
-PHP_HASH_API int PHP_ADLER32Copy(const php_hash_ops *ops, PHP_ADLER32_CTX *orig_context, PHP_ADLER32_CTX *copy_context)
+PHP_HASH_API zend_result PHP_ADLER32Copy(const php_hash_ops *ops, const PHP_ADLER32_CTX *orig_context, PHP_ADLER32_CTX *copy_context)
 {
 	copy_context->state = orig_context->state;
 	return SUCCESS;
diff --git a/ext/hash/hash_crc32.c b/ext/hash/hash_crc32.c
@@ -84,7 +84,7 @@ PHP_HASH_API void PHP_CRC32BEFinal(unsigned char digest[4], PHP_CRC32_CTX *conte
 	context->state = 0;
 }
 
-PHP_HASH_API int PHP_CRC32Copy(const php_hash_ops *ops, PHP_CRC32_CTX *orig_context, PHP_CRC32_CTX *copy_context)
+PHP_HASH_API zend_result PHP_CRC32Copy(const php_hash_ops *ops, const PHP_CRC32_CTX *orig_context, PHP_CRC32_CTX *copy_context)
 {
 	copy_context->state = orig_context->state;
 	return SUCCESS;
diff --git a/ext/hash/hash_murmur.c b/ext/hash/hash_murmur.c
@@ -75,7 +75,7 @@ PHP_HASH_API void PHP_MURMUR3AFinal(unsigned char digest[4], PHP_MURMUR3A_CTX *c
 	digest[3] = (unsigned char)(ctx->h & 0xff);
 }
 
-PHP_HASH_API int PHP_MURMUR3ACopy(const php_hash_ops *ops, PHP_MURMUR3A_CTX *orig_context, PHP_MURMUR3A_CTX *copy_context)
+PHP_HASH_API zend_result PHP_MURMUR3ACopy(const php_hash_ops *ops, const PHP_MURMUR3A_CTX *orig_context, PHP_MURMUR3A_CTX *copy_context)
 {
 	copy_context->h = orig_context->h;
 	copy_context->carry = orig_context->carry;
@@ -154,7 +154,7 @@ PHP_HASH_API void PHP_MURMUR3CFinal(unsigned char digest[16], PHP_MURMUR3C_CTX *
 	digest[15] = (unsigned char)(h[3] & 0xff);
 }
 
-PHP_HASH_API int PHP_MURMUR3CCopy(const php_hash_ops *ops, PHP_MURMUR3C_CTX *orig_context, PHP_MURMUR3C_CTX *copy_context)
+PHP_HASH_API zend_result PHP_MURMUR3CCopy(const php_hash_ops *ops, const PHP_MURMUR3C_CTX *orig_context, PHP_MURMUR3C_CTX *copy_context)
 {
 	memcpy(&copy_context->h, &orig_context->h, sizeof orig_context->h);
 	memcpy(&copy_context->carry, &orig_context->carry, sizeof orig_context->carry);
@@ -231,7 +231,7 @@ PHP_HASH_API void PHP_MURMUR3FFinal(unsigned char digest[16], PHP_MURMUR3F_CTX *
 	digest[15] = (unsigned char)(h[1] & 0xff);
 }
 
-PHP_HASH_API int PHP_MURMUR3FCopy(const php_hash_ops *ops, PHP_MURMUR3F_CTX *orig_context, PHP_MURMUR3F_CTX *copy_context)
+PHP_HASH_API zend_result PHP_MURMUR3FCopy(const php_hash_ops *ops, const PHP_MURMUR3F_CTX *orig_context, PHP_MURMUR3F_CTX *copy_context)
 {
 	memcpy(&copy_context->h, &orig_context->h, sizeof orig_context->h);
 	memcpy(&copy_context->carry, &orig_context->carry, sizeof orig_context->carry);
diff --git a/ext/hash/hash_xxhash.c b/ext/hash/hash_xxhash.c
@@ -69,7 +69,7 @@ PHP_HASH_API void PHP_XXH32Final(unsigned char digest[4], PHP_XXH32_CTX *ctx)
 	XXH32_canonicalFromHash((XXH32_canonical_t*)digest, XXH32_digest(&ctx->s));
 }
 
-PHP_HASH_API int PHP_XXH32Copy(const php_hash_ops *ops, PHP_XXH32_CTX *orig_context, PHP_XXH32_CTX *copy_context)
+PHP_HASH_API zend_result PHP_XXH32Copy(const php_hash_ops *ops, const PHP_XXH32_CTX *orig_context, PHP_XXH32_CTX *copy_context)
 {
 	copy_context->s = orig_context->s;
 	return SUCCESS;
@@ -134,7 +134,7 @@ PHP_HASH_API void PHP_XXH64Final(unsigned char digest[8], PHP_XXH64_CTX *ctx)
 	XXH64_canonicalFromHash((XXH64_canonical_t*)digest, XXH64_digest(&ctx->s));
 }
 
-PHP_HASH_API int PHP_XXH64Copy(const php_hash_ops *ops, PHP_XXH64_CTX *orig_context, PHP_XXH64_CTX *copy_context)
+PHP_HASH_API zend_result PHP_XXH64Copy(const php_hash_ops *ops, const PHP_XXH64_CTX *orig_context, PHP_XXH64_CTX *copy_context)
 {
 	copy_context->s = orig_context->s;
 	return SUCCESS;
@@ -225,7 +225,7 @@ PHP_HASH_API void PHP_XXH3_64_Final(unsigned char digest[8], PHP_XXH3_64_CTX *ct
 	XXH64_canonicalFromHash((XXH64_canonical_t*)digest, XXH3_64bits_digest(&ctx->s));
 }
 
-PHP_HASH_API int PHP_XXH3_64_Copy(const php_hash_ops *ops, PHP_XXH3_64_CTX *orig_context, PHP_XXH3_64_CTX *copy_context)
+PHP_HASH_API zend_result PHP_XXH3_64_Copy(const php_hash_ops *ops, const PHP_XXH3_64_CTX *orig_context, PHP_XXH3_64_CTX *copy_context)
 {
 	copy_context->s = orig_context->s;
 	return SUCCESS;
@@ -275,7 +275,7 @@ PHP_HASH_API void PHP_XXH3_128_Final(unsigned char digest[16], PHP_XXH3_128_CTX
 	XXH128_canonicalFromHash((XXH128_canonical_t*)digest, XXH3_128bits_digest(&ctx->s));
 }
 
-PHP_HASH_API int PHP_XXH3_128_Copy(const php_hash_ops *ops, PHP_XXH3_128_CTX *orig_context, PHP_XXH3_128_CTX *copy_context)
+PHP_HASH_API zend_result PHP_XXH3_128_Copy(const php_hash_ops *ops, const PHP_XXH3_128_CTX *orig_context, PHP_XXH3_128_CTX *copy_context)
 {
 	copy_context->s = orig_context->s;
 	return SUCCESS;
diff --git a/ext/hash/php_hash.h b/ext/hash/php_hash.h
@@ -34,7 +34,7 @@ typedef struct _php_hashcontext_object php_hashcontext_object;
 typedef void (*php_hash_init_func_t)(void *context, HashTable *args);
 typedef void (*php_hash_update_func_t)(void *context, const unsigned char *buf, size_t count);
 typedef void (*php_hash_final_func_t)(unsigned char *digest, void *context);
-typedef int  (*php_hash_copy_func_t)(const void *ops, void *orig_context, void *dest_context);
+typedef zend_result (*php_hash_copy_func_t)(const void *ops, const void *orig_context, void *dest_context);
 typedef int  (*php_hash_serialize_func_t)(const php_hashcontext_object *hash, zend_long *magic, zval *zv);
 typedef int  (*php_hash_unserialize_func_t)(php_hashcontext_object *hash, zend_long magic, const zval *zv);
 
@@ -147,7 +147,7 @@ extern zend_module_entry hash_module_entry;
 extern PHP_HASH_API zend_class_entry *php_hashcontext_ce;
 PHP_HASH_API const php_hash_ops *php_hash_fetch_ops(zend_string *algo);
 PHP_HASH_API void php_hash_register_algo(const char *algo, const php_hash_ops *ops);
-PHP_HASH_API int php_hash_copy(const void *ops, void *orig_context, void *dest_context);
+PHP_HASH_API zend_result php_hash_copy(const void *ops, const void *orig_context, void *dest_context);
 PHP_HASH_API int php_hash_serialize(const php_hashcontext_object *context, zend_long *magic, zval *zv);
 PHP_HASH_API int php_hash_unserialize(php_hashcontext_object *context, zend_long magic, const zval *zv);
 PHP_HASH_API int php_hash_serialize_spec(const php_hashcontext_object *context, zval *zv, const char *spec);
diff --git a/ext/hash/php_hash_adler32.h b/ext/hash/php_hash_adler32.h
@@ -25,6 +25,6 @@ typedef struct {
 PHP_HASH_API void PHP_ADLER32Init(PHP_ADLER32_CTX *context, ZEND_ATTRIBUTE_UNUSED HashTable *args);
 PHP_HASH_API void PHP_ADLER32Update(PHP_ADLER32_CTX *context, const unsigned char *input, size_t len);
 PHP_HASH_API void PHP_ADLER32Final(unsigned char digest[4], PHP_ADLER32_CTX *context);
-PHP_HASH_API int PHP_ADLER32Copy(const php_hash_ops *ops, PHP_ADLER32_CTX *orig_context, PHP_ADLER32_CTX *copy_context);
+PHP_HASH_API zend_result PHP_ADLER32Copy(const php_hash_ops *ops, const PHP_ADLER32_CTX *orig_context, PHP_ADLER32_CTX *copy_context);
 
 #endif
diff --git a/ext/hash/php_hash_crc32.h b/ext/hash/php_hash_crc32.h
@@ -30,6 +30,6 @@ PHP_HASH_API void PHP_CRC32BUpdate(PHP_CRC32_CTX *context, const unsigned char *
 PHP_HASH_API void PHP_CRC32CUpdate(PHP_CRC32_CTX *context, const unsigned char *input, size_t len);
 PHP_HASH_API void PHP_CRC32LEFinal(unsigned char digest[4], PHP_CRC32_CTX *context);
 PHP_HASH_API void PHP_CRC32BEFinal(unsigned char digest[4], PHP_CRC32_CTX *context);
-PHP_HASH_API int PHP_CRC32Copy(const php_hash_ops *ops, PHP_CRC32_CTX *orig_context, PHP_CRC32_CTX *copy_context);
+PHP_HASH_API zend_result PHP_CRC32Copy(const php_hash_ops *ops, const PHP_CRC32_CTX *orig_context, PHP_CRC32_CTX *copy_context);
 
 #endif
diff --git a/ext/hash/php_hash_murmur.h b/ext/hash/php_hash_murmur.h
@@ -27,7 +27,7 @@ typedef struct {
 PHP_HASH_API void PHP_MURMUR3AInit(PHP_MURMUR3A_CTX *ctx, HashTable *args);
 PHP_HASH_API void PHP_MURMUR3AUpdate(PHP_MURMUR3A_CTX *ctx, const unsigned char *in, size_t len);
 PHP_HASH_API void PHP_MURMUR3AFinal(unsigned char digest[4], PHP_MURMUR3A_CTX *ctx);
-PHP_HASH_API int PHP_MURMUR3ACopy(const php_hash_ops *ops, PHP_MURMUR3A_CTX *orig_context, PHP_MURMUR3A_CTX *copy_context);
+PHP_HASH_API zend_result PHP_MURMUR3ACopy(const php_hash_ops *ops, const PHP_MURMUR3A_CTX *orig_context, PHP_MURMUR3A_CTX *copy_context);
 
 typedef struct {
 	uint32_t h[4];
@@ -39,7 +39,7 @@ typedef struct {
 PHP_HASH_API void PHP_MURMUR3CInit(PHP_MURMUR3C_CTX *ctx, HashTable *args);
 PHP_HASH_API void PHP_MURMUR3CUpdate(PHP_MURMUR3C_CTX *ctx, const unsigned char *in, size_t len);
 PHP_HASH_API void PHP_MURMUR3CFinal(unsigned char digest[16], PHP_MURMUR3C_CTX *ctx);
-PHP_HASH_API int PHP_MURMUR3CCopy(const php_hash_ops *ops, PHP_MURMUR3C_CTX *orig_context, PHP_MURMUR3C_CTX *copy_context);
+PHP_HASH_API zend_result PHP_MURMUR3CCopy(const php_hash_ops *ops, const PHP_MURMUR3C_CTX *orig_context, PHP_MURMUR3C_CTX *copy_context);
 
 typedef struct {
 	uint64_t h[2];
@@ -51,7 +51,7 @@ typedef struct {
 PHP_HASH_API void PHP_MURMUR3FInit(PHP_MURMUR3F_CTX *ctx, HashTable *args);
 PHP_HASH_API void PHP_MURMUR3FUpdate(PHP_MURMUR3F_CTX *ctx, const unsigned char *in, size_t len);
 PHP_HASH_API void PHP_MURMUR3FFinal(unsigned char digest[16], PHP_MURMUR3F_CTX *ctx);
-PHP_HASH_API int PHP_MURMUR3FCopy(const php_hash_ops *ops, PHP_MURMUR3F_CTX *orig_context, PHP_MURMUR3F_CTX *copy_context);
+PHP_HASH_API zend_result PHP_MURMUR3FCopy(const php_hash_ops *ops, const PHP_MURMUR3F_CTX *orig_context, PHP_MURMUR3F_CTX *copy_context);
 
 #endif /* PHP_HASH_MURMUR_H */
 
diff --git a/ext/hash/php_hash_xxhash.h b/ext/hash/php_hash_xxhash.h
@@ -28,7 +28,7 @@ typedef struct {
 PHP_HASH_API void PHP_XXH32Init(PHP_XXH32_CTX *ctx, HashTable *args);
 PHP_HASH_API void PHP_XXH32Update(PHP_XXH32_CTX *ctx, const unsigned char *in, size_t len);
 PHP_HASH_API void PHP_XXH32Final(unsigned char digest[4], PHP_XXH32_CTX *ctx);
-PHP_HASH_API int PHP_XXH32Copy(const php_hash_ops *ops, PHP_XXH32_CTX *orig_context, PHP_XXH32_CTX *copy_context);
+PHP_HASH_API zend_result PHP_XXH32Copy(const php_hash_ops *ops, const PHP_XXH32_CTX *orig_context, PHP_XXH32_CTX *copy_context);
 
 typedef struct {
 	XXH64_state_t s;
@@ -38,7 +38,7 @@ typedef struct {
 PHP_HASH_API void PHP_XXH64Init(PHP_XXH64_CTX *ctx, HashTable *args);
 PHP_HASH_API void PHP_XXH64Update(PHP_XXH64_CTX *ctx, const unsigned char *in, size_t len);
 PHP_HASH_API void PHP_XXH64Final(unsigned char digest[8], PHP_XXH64_CTX *ctx);
-PHP_HASH_API int PHP_XXH64Copy(const php_hash_ops *ops, PHP_XXH64_CTX *orig_context, PHP_XXH64_CTX *copy_context);
+PHP_HASH_API zend_result PHP_XXH64Copy(const php_hash_ops *ops, const PHP_XXH64_CTX *orig_context, PHP_XXH64_CTX *copy_context);
 
 #define PHP_XXH3_SECRET_SIZE_MIN XXH3_SECRET_SIZE_MIN
 #define PHP_XXH3_SECRET_SIZE_MAX 256
@@ -60,14 +60,14 @@ typedef PHP_XXH3_CTX PHP_XXH3_64_CTX;
 PHP_HASH_API void PHP_XXH3_64_Init(PHP_XXH3_64_CTX *ctx, HashTable *args);
 PHP_HASH_API void PHP_XXH3_64_Update(PHP_XXH3_64_CTX *ctx, const unsigned char *in, size_t len);
 PHP_HASH_API void PHP_XXH3_64_Final(unsigned char digest[8], PHP_XXH3_64_CTX *ctx);
-PHP_HASH_API int PHP_XXH3_64_Copy(const php_hash_ops *ops, PHP_XXH3_64_CTX *orig_context, PHP_XXH3_64_CTX *copy_context);
+PHP_HASH_API zend_result PHP_XXH3_64_Copy(const php_hash_ops *ops, const PHP_XXH3_64_CTX *orig_context, PHP_XXH3_64_CTX *copy_context);
 
 typedef PHP_XXH3_CTX PHP_XXH3_128_CTX;
 
 PHP_HASH_API void PHP_XXH3_128_Init(PHP_XXH3_128_CTX *ctx, HashTable *args);
 PHP_HASH_API void PHP_XXH3_128_Update(PHP_XXH3_128_CTX *ctx, const unsigned char *in, size_t len);
 PHP_HASH_API void PHP_XXH3_128_Final(unsigned char digest[16], PHP_XXH3_128_CTX *ctx);
-PHP_HASH_API int PHP_XXH3_128_Copy(const php_hash_ops *ops, PHP_XXH3_128_CTX *orig_context, PHP_XXH3_128_CTX *copy_context);
+PHP_HASH_API zend_result PHP_XXH3_128_Copy(const php_hash_ops *ops, const PHP_XXH3_128_CTX *orig_context, PHP_XXH3_128_CTX *copy_context);
 
 #endif /* PHP_HASH_XXHASH_H */
 

Original file line number	Diff line number	Diff line change
`@@ -105,7 +105,7 @@ static struct mhash_bc_entry mhash_to_hash[MHASH_NUM_ALGOS] = {`
`105`	`105`	`PHP_HASH_API const php_hash_ops php_hash_fetch_ops(zend_string algo) /* {{{ */`
`106`	`106`	`{`
`107`	`107`	`zend_string *lower = zend_string_tolower(algo);`
`108`		`- php_hash_ops *ops = zend_hash_find_ptr(&php_hash_hashtable, lower);`
	`108`	`+ const php_hash_ops *ops = zend_hash_find_ptr(&php_hash_hashtable, lower);`
`109`	`109`	`zend_string_release(lower);`
`110`	`110`
`111`	`111`	`return ops;`
`@@ -121,7 +121,7 @@ PHP_HASH_API void php_hash_register_algo(const char algo, const php_hash_ops o`
`121`	`121`	`}`
`122`	`122`	`/* }}} */`
`123`	`123`
`124`		`-PHP_HASH_API int php_hash_copy(const void ops, void orig_context, void dest_context) / {{{ */`
	`124`	`+PHP_HASH_API zend_result php_hash_copy(const void ops, const void orig_context, void dest_context) / {{{ */`
`125`	`125`	`{`
`126`	`126`	`php_hash_ops hash_ops = (php_hash_ops )ops;`
`127`	`127`
Original file line number	Diff line number	Diff line change
`@@ -52,7 +52,7 @@ PHP_HASH_API void PHP_ADLER32Final(unsigned char digest[4], PHP_ADLER32_CTX *con`
`52`	`52`	`context->state = 0;`
`53`	`53`	`}`
`54`	`54`
`55`		`-PHP_HASH_API int PHP_ADLER32Copy(const php_hash_ops ops, PHP_ADLER32_CTX orig_context, PHP_ADLER32_CTX *copy_context)`
	`55`	`+PHP_HASH_API zend_result PHP_ADLER32Copy(const php_hash_ops ops, const PHP_ADLER32_CTX orig_context, PHP_ADLER32_CTX *copy_context)`
`56`	`56`	`{`
`57`	`57`	`copy_context->state = orig_context->state;`
`58`	`58`	`return SUCCESS;`
Original file line number	Diff line number	Diff line change
`@@ -84,7 +84,7 @@ PHP_HASH_API void PHP_CRC32BEFinal(unsigned char digest[4], PHP_CRC32_CTX *conte`
`84`	`84`	`context->state = 0;`
`85`	`85`	`}`
`86`	`86`
`87`		`-PHP_HASH_API int PHP_CRC32Copy(const php_hash_ops ops, PHP_CRC32_CTX orig_context, PHP_CRC32_CTX *copy_context)`
	`87`	`+PHP_HASH_API zend_result PHP_CRC32Copy(const php_hash_ops ops, const PHP_CRC32_CTX orig_context, PHP_CRC32_CTX *copy_context)`
`88`	`88`	`{`
`89`	`89`	`copy_context->state = orig_context->state;`
`90`	`90`	`return SUCCESS;`
Original file line number	Diff line number	Diff line change
`@@ -75,7 +75,7 @@ PHP_HASH_API void PHP_MURMUR3AFinal(unsigned char digest[4], PHP_MURMUR3A_CTX *c`
`75`	`75`	`digest[3] = (unsigned char)(ctx->h & 0xff);`
`76`	`76`	`}`
`77`	`77`
`78`		`-PHP_HASH_API int PHP_MURMUR3ACopy(const php_hash_ops ops, PHP_MURMUR3A_CTX orig_context, PHP_MURMUR3A_CTX *copy_context)`
	`78`	`+PHP_HASH_API zend_result PHP_MURMUR3ACopy(const php_hash_ops ops, const PHP_MURMUR3A_CTX orig_context, PHP_MURMUR3A_CTX *copy_context)`
`79`	`79`	`{`
`80`	`80`	`copy_context->h = orig_context->h;`
`81`	`81`	`copy_context->carry = orig_context->carry;`
`@@ -154,7 +154,7 @@ PHP_HASH_API void PHP_MURMUR3CFinal(unsigned char digest[16], PHP_MURMUR3C_CTX *`
`154`	`154`	`digest[15] = (unsigned char)(h[3] & 0xff);`
`155`	`155`	`}`
`156`	`156`
`157`		`-PHP_HASH_API int PHP_MURMUR3CCopy(const php_hash_ops ops, PHP_MURMUR3C_CTX orig_context, PHP_MURMUR3C_CTX *copy_context)`
	`157`	`+PHP_HASH_API zend_result PHP_MURMUR3CCopy(const php_hash_ops ops, const PHP_MURMUR3C_CTX orig_context, PHP_MURMUR3C_CTX *copy_context)`
`158`	`158`	`{`
`159`	`159`	`memcpy(&copy_context->h, &orig_context->h, sizeof orig_context->h);`
`160`	`160`	`memcpy(&copy_context->carry, &orig_context->carry, sizeof orig_context->carry);`
`@@ -231,7 +231,7 @@ PHP_HASH_API void PHP_MURMUR3FFinal(unsigned char digest[16], PHP_MURMUR3F_CTX *`
`231`	`231`	`digest[15] = (unsigned char)(h[1] & 0xff);`
`232`	`232`	`}`
`233`	`233`
`234`		`-PHP_HASH_API int PHP_MURMUR3FCopy(const php_hash_ops ops, PHP_MURMUR3F_CTX orig_context, PHP_MURMUR3F_CTX *copy_context)`
	`234`	`+PHP_HASH_API zend_result PHP_MURMUR3FCopy(const php_hash_ops ops, const PHP_MURMUR3F_CTX orig_context, PHP_MURMUR3F_CTX *copy_context)`
`235`	`235`	`{`
`236`	`236`	`memcpy(&copy_context->h, &orig_context->h, sizeof orig_context->h);`
`237`	`237`	`memcpy(&copy_context->carry, &orig_context->carry, sizeof orig_context->carry);`
Original file line number	Diff line number	Diff line change
`@@ -69,7 +69,7 @@ PHP_HASH_API void PHP_XXH32Final(unsigned char digest[4], PHP_XXH32_CTX *ctx)`
`69`	`69`	`XXH32_canonicalFromHash((XXH32_canonical_t*)digest, XXH32_digest(&ctx->s));`
`70`	`70`	`}`
`71`	`71`
`72`		`-PHP_HASH_API int PHP_XXH32Copy(const php_hash_ops ops, PHP_XXH32_CTX orig_context, PHP_XXH32_CTX *copy_context)`
	`72`	`+PHP_HASH_API zend_result PHP_XXH32Copy(const php_hash_ops ops, const PHP_XXH32_CTX orig_context, PHP_XXH32_CTX *copy_context)`
`73`	`73`	`{`
`74`	`74`	`copy_context->s = orig_context->s;`
`75`	`75`	`return SUCCESS;`
`@@ -134,7 +134,7 @@ PHP_HASH_API void PHP_XXH64Final(unsigned char digest[8], PHP_XXH64_CTX *ctx)`
`134`	`134`	`XXH64_canonicalFromHash((XXH64_canonical_t*)digest, XXH64_digest(&ctx->s));`
`135`	`135`	`}`
`136`	`136`
`137`		`-PHP_HASH_API int PHP_XXH64Copy(const php_hash_ops ops, PHP_XXH64_CTX orig_context, PHP_XXH64_CTX *copy_context)`
	`137`	`+PHP_HASH_API zend_result PHP_XXH64Copy(const php_hash_ops ops, const PHP_XXH64_CTX orig_context, PHP_XXH64_CTX *copy_context)`
`138`	`138`	`{`
`139`	`139`	`copy_context->s = orig_context->s;`
`140`	`140`	`return SUCCESS;`
`@@ -225,7 +225,7 @@ PHP_HASH_API void PHP_XXH3_64_Final(unsigned char digest[8], PHP_XXH3_64_CTX *ct`
`225`	`225`	`XXH64_canonicalFromHash((XXH64_canonical_t*)digest, XXH3_64bits_digest(&ctx->s));`
`226`	`226`	`}`
`227`	`227`
`228`		`-PHP_HASH_API int PHP_XXH3_64_Copy(const php_hash_ops ops, PHP_XXH3_64_CTX orig_context, PHP_XXH3_64_CTX *copy_context)`
	`228`	`+PHP_HASH_API zend_result PHP_XXH3_64_Copy(const php_hash_ops ops, const PHP_XXH3_64_CTX orig_context, PHP_XXH3_64_CTX *copy_context)`
`229`	`229`	`{`
`230`	`230`	`copy_context->s = orig_context->s;`
`231`	`231`	`return SUCCESS;`
`@@ -275,7 +275,7 @@ PHP_HASH_API void PHP_XXH3_128_Final(unsigned char digest[16], PHP_XXH3_128_CTX`
`275`	`275`	`XXH128_canonicalFromHash((XXH128_canonical_t*)digest, XXH3_128bits_digest(&ctx->s));`
`276`	`276`	`}`
`277`	`277`
`278`		`-PHP_HASH_API int PHP_XXH3_128_Copy(const php_hash_ops ops, PHP_XXH3_128_CTX orig_context, PHP_XXH3_128_CTX *copy_context)`
	`278`	`+PHP_HASH_API zend_result PHP_XXH3_128_Copy(const php_hash_ops ops, const PHP_XXH3_128_CTX orig_context, PHP_XXH3_128_CTX *copy_context)`
`279`	`279`	`{`
`280`	`280`	`copy_context->s = orig_context->s;`
`281`	`281`	`return SUCCESS;`