Update to compatibility with latest master

bwoebi · bwoebi · commit c2a7a597ac22 · 2026-04-17T20:01:51.000+02:00
Signed-off-by: Bob Weinand &lt;bob.weinand@datadoghq.com&gt;
diff --git a/ext/compat_string.c b/ext/compat_string.c
@@ -84,7 +84,8 @@ zend_string *ddtrace_convert_to_str(const zval *op) {
         case IS_STRING:
             return zend_string_copy(Z_STR_P(op));
 
-            EMPTY_SWITCH_DEFAULT_CASE()
+        default:
+            ZEND_UNREACHABLE();
     }
 }
 
diff --git a/ext/engine_hooks.h b/ext/engine_hooks.h
@@ -42,7 +42,10 @@ typedef struct ddtrace_error_handling ddtrace_error_handling;
 
 struct ddtrace_sandbox_backup {
     ddtrace_error_handling eh;
-    zend_object *exception, *prev_exception;
+    zend_object *exception;
+#if PHP_VERSION_ID < 80600
+    zend_object *prev_exception;
+#endif
 };
 typedef struct ddtrace_sandbox_backup ddtrace_sandbox_backup;
 
@@ -70,12 +73,19 @@ inline void ddtrace_maybe_clear_exception(void) {
 }
 
 inline ddtrace_sandbox_backup ddtrace_sandbox_begin(void) {
-    ddtrace_sandbox_backup backup = {.exception = NULL, .prev_exception = NULL};
+    ddtrace_sandbox_backup backup = {
+        .exception = NULL,
+#if PHP_VERSION_ID < 80600
+        .prev_exception = NULL,
+#endif
+    };
     if (EG(exception)) {
         backup.exception = EG(exception);
-        backup.prev_exception = EG(prev_exception);
         EG(exception) = NULL;
+#if PHP_VERSION_ID < 80600
+        backup.prev_exception = EG(prev_exception);
         EG(prev_exception) = NULL;
+#endif
     }
     ddtrace_backup_error_handling(&backup.eh, EH_THROW);
     return backup;
@@ -87,7 +97,9 @@ inline void ddtrace_sandbox_end(ddtrace_sandbox_backup *backup) {
 
     if (backup->exception) {
         EG(exception) = backup->exception;
+#if PHP_VERSION_ID < 80600
         EG(prev_exception) = backup->prev_exception;
+#endif
         zend_throw_exception_internal(NULL);
     }
 }
diff --git a/ext/handlers_kafka.c b/ext/handlers_kafka.c
@@ -70,7 +70,7 @@ ZEND_FUNCTION(ddtrace_kafka_produce) {
     zval function_name;
     ZVAL_STRING(&function_name, "producev");
     call_user_function(NULL, getThis(), &function_name, return_value, 6 + opaque_param, args);
-    zval_dtor(&function_name);
+    zval_ptr_dtor_nogc(&function_name);
 
     zend_string_release(Z_STR(args[2]));
     zend_string_release(Z_STR(args[3]));
diff --git a/ext/hook/uhook_legacy.c b/ext/hook/uhook_legacy.c
@@ -296,7 +296,7 @@ static bool _parse_config_array(zval *config_array, zval **prehook, zval **posth
                 return false;
             }
         } else if (strcmp("recurse", ZSTR_VAL(key)) == 0) {
-            *allow_recursion = zval_is_true(value);
+            *allow_recursion = zend_is_true(value);
         } else {
             LOG_LINE_ONCE(WARN, "Unknown option '%s' in config_array", ZSTR_VAL(key));
             return false;
diff --git a/ext/serializer.c b/ext/serializer.c
@@ -1225,10 +1225,10 @@ static bool should_track_error(zend_object *exception, ddtrace_span_data *span)
     zend_array *meta = ddtrace_property_array(&span->property_meta);
 
     // Check if error should be ignored or tracking is disabled
-    if ((zv = zend_hash_str_find(meta, ZEND_STRL("error.ignored"))) && zval_is_true(zv)) {
+    if ((zv = zend_hash_str_find(meta, ZEND_STRL("error.ignored"))) && zend_is_true(zv)) {
         return false;
     }
-    if ((zv = zend_hash_str_find(meta, ZEND_STRL("track_error"))) && !zval_is_true(zv)) {
+    if ((zv = zend_hash_str_find(meta, ZEND_STRL("track_error"))) && !zend_is_true(zv)) {
         return false;
     }
     return true;
diff --git a/zend_abstract_interface/config/config_decode.c b/zend_abstract_interface/config/config_decode.c
@@ -257,7 +257,7 @@ static bool zai_config_decode_json(zai_str value, zval *decoded_value, bool pers
         if (persistent) {
             zval_internal_ptr_dtor(decoded_value);
         } else {
-            zval_dtor(decoded_value);
+            zval_ptr_dtor_nogc(decoded_value);
         }
         ZVAL_NULL(decoded_value);
         return false;
diff --git a/zend_abstract_interface/config/config_ini.c b/zend_abstract_interface/config/config_ini.c
@@ -216,12 +216,12 @@ static ZEND_INI_MH(ZaiConfigOnUpdateIni) {
     }
 
     if (!zai_config_is_initialized()) {
-        zval_dtor(&new_zv);
+        zval_ptr_dtor_nogc(&new_zv);
         return SUCCESS;
     }
 
     if (memoized->ini_change && !memoized->ini_change(zai_config_get_value(id), &new_zv, new_value)) {
-        zval_dtor(&new_zv);
+        zval_ptr_dtor_nogc(&new_zv);
         return FAILURE;
     }
 
@@ -251,7 +251,7 @@ static ZEND_INI_MH(ZaiConfigOnUpdateIni) {
     }
 
     zai_config_replace_runtime_config(id, &new_zv);
-    zval_dtor(&new_zv);
+    zval_ptr_dtor_nogc(&new_zv);
     return SUCCESS;
 }
 
diff --git a/zend_abstract_interface/interceptor/tests/resolver.cc b/zend_abstract_interface/interceptor/tests/resolver.cc
@@ -191,7 +191,7 @@ INTERCEPTOR_TEST_CASE("runtime class_alias resolving", {
 INTERCEPTOR_TEST_CASE("ensure runtime post-declare resolving does not impact error", {
     int orig_resolved = zend_hash_num_elements(&zai_hook_resolved);
     INSTALL_CLASS_HOOK("Inherited", "bar");
-    CALL_FN("failDeclare", REQUIRE(zval_is_true(&result)););
+    CALL_FN("failDeclare", REQUIRE(zend_is_true(&result)););
     REQUIRE(zend_hash_num_elements(&zai_hook_resolved) == orig_resolved);
 });
 #endif
diff --git a/zend_abstract_interface/json/json.c b/zend_abstract_interface/json/json.c
@@ -4,6 +4,15 @@ typedef unsigned char php_json_ctype;
 
 typedef int php_json_error_code;
 
+#if PHP_VERSION_ID >= 80600
+typedef struct _php_json_error_location {
+    size_t first_column;
+    size_t first_line;
+    size_t last_column;
+    size_t last_line;
+} php_json_error_location;
+#endif
+
 typedef struct _php_json_scanner {
     php_json_ctype *cursor;         /* cursor position */
     php_json_ctype *token;          /* token position */
@@ -17,6 +26,9 @@ typedef struct _php_json_scanner {
     int state;                      /* condition state */
     int options;                    /* options */
     php_json_error_code errcode;    /* error type if there is an error */
+#if PHP_VERSION_ID >= 80600
+    php_json_error_location errloc; /* error location */
+#endif
 #if PHP_VERSION_ID >= 70200
     int utf8_invalid;               /* whether utf8 is invalid */
     int utf8_invalid_count;         /* number of extra character for invalid utf8 */
@@ -59,6 +71,9 @@ struct _php_json_parser {
     int depth;
     int max_depth;
     php_json_parser_methods methods;
+#if PHP_VERSION_ID >= 80600
+    struct _php_json_parser_location *location;
+#endif
 };
 
 #if PHP_VERSION_ID < 70100
diff --git a/zend_abstract_interface/sandbox/sandbox.h b/zend_abstract_interface/sandbox/sandbox.h
@@ -157,10 +157,12 @@ void zai_sandbox_error_state_restore(zai_error_state *es);
 inline void zai_sandbox_exception_state_backup(zai_exception_state *es) {
     if (UNEXPECTED(EG(exception) != NULL)) {
         es->exception = EG(exception);
-        es->prev_exception = EG(prev_exception);
-        es->opline_before_exception = EG(opline_before_exception);
         EG(exception) = NULL;
+#if PHP_VERSION_ID < 80600
+        es->prev_exception = EG(prev_exception);
         EG(prev_exception) = NULL;
+#endif
+        es->opline_before_exception = EG(opline_before_exception);
     } else {
         es->exception = NULL;
         es->prev_exception = NULL;
@@ -174,7 +176,9 @@ inline void zai_sandbox_exception_state_restore(zai_exception_state *es) {
 
     if (es->exception) {
         EG(exception) = es->exception;
+#if PHP_VERSION_ID < 80600
         EG(prev_exception) = es->prev_exception;
+#endif
         if (EG(current_execute_data)) {
             // ensure that we continue handling an exception if we were handling one before the sandbox call
             EG(current_execute_data)->opline = EG(exception_op);
diff --git a/zend_abstract_interface/uri_normalization/tests/uri_normalization.cc b/zend_abstract_interface/uri_normalization/tests/uri_normalization.cc
@@ -25,8 +25,8 @@ extern "C" {
                                                       \
     zend_string_release(path_str);                    \
     zend_string_release(res);                         \
-    zval_dtor(&mapping);                              \
-    zval_dtor(&fragment_regex);                       \
+    zval_ptr_dtor_nogc(&mapping);                              \
+    zval_ptr_dtor_nogc(&fragment_regex);                       \
 }
 
 #define TEST_URI_NORMALIZATION(description, path, output, ...) \
@@ -117,7 +117,7 @@ TEST_URI_NORMALIZATION("pattern mapping & fragment regexes: working with full UR
                                                       \
     if (regex) { zend_string_release(regex); }        \
     zend_string_release(res);                         \
-    zval_dtor(&whitelist);                            \
+    zval_ptr_dtor_nogc(&whitelist);                            \
 }
 
 #define TEST_QUERY_STRING(description, query_string, output, ...) \

Original file line number	Diff line number	Diff line change
`@@ -84,7 +84,8 @@ zend_string ddtrace_convert_to_str(const zval op) {`
`84`	`84`	`case IS_STRING:`
`85`	`85`	`return zend_string_copy(Z_STR_P(op));`
`86`	`86`
`87`		`- EMPTY_SWITCH_DEFAULT_CASE()`
	`87`	`+ default:`
	`88`	`+ ZEND_UNREACHABLE();`
`88`	`89`	`}`
`89`	`90`	`}`
`90`	`91`
Original file line number	Diff line number	Diff line change
`@@ -296,7 +296,7 @@ static bool _parse_config_array(zval config_array, zval prehook, zval *posth`
`296`	`296`	`return false;`
`297`	`297`	`}`
`298`	`298`	`} else if (strcmp("recurse", ZSTR_VAL(key)) == 0) {`
`299`		`- *allow_recursion = zval_is_true(value);`
	`299`	`+ *allow_recursion = zend_is_true(value);`
`300`	`300`	`} else {`
`301`	`301`	`LOG_LINE_ONCE(WARN, "Unknown option '%s' in config_array", ZSTR_VAL(key));`
`302`	`302`	`return false;`
Original file line number	Diff line number	Diff line change
`@@ -1225,10 +1225,10 @@ static bool should_track_error(zend_object exception, ddtrace_span_data span)`
`1225`	`1225`	`zend_array *meta = ddtrace_property_array(&span->property_meta);`
`1226`	`1226`
`1227`	`1227`	`// Check if error should be ignored or tracking is disabled`
`1228`		`- if ((zv = zend_hash_str_find(meta, ZEND_STRL("error.ignored"))) && zval_is_true(zv)) {`
	`1228`	`+ if ((zv = zend_hash_str_find(meta, ZEND_STRL("error.ignored"))) && zend_is_true(zv)) {`
`1229`	`1229`	`return false;`
`1230`	`1230`	`}`
`1231`		`- if ((zv = zend_hash_str_find(meta, ZEND_STRL("track_error"))) && !zval_is_true(zv)) {`
	`1231`	`+ if ((zv = zend_hash_str_find(meta, ZEND_STRL("track_error"))) && !zend_is_true(zv)) {`
`1232`	`1232`	`return false;`
`1233`	`1233`	`}`
`1234`	`1234`	`return true;`
Original file line number	Diff line number	Diff line change
`@@ -257,7 +257,7 @@ static bool zai_config_decode_json(zai_str value, zval *decoded_value, bool pers`
`257`	`257`	`if (persistent) {`
`258`	`258`	`zval_internal_ptr_dtor(decoded_value);`
`259`	`259`	`} else {`
`260`		`- zval_dtor(decoded_value);`
	`260`	`+ zval_ptr_dtor_nogc(decoded_value);`
`261`	`261`	`}`
`262`	`262`	`ZVAL_NULL(decoded_value);`
`263`	`263`	`return false;`
Original file line number	Diff line number	Diff line change
`@@ -216,12 +216,12 @@ static ZEND_INI_MH(ZaiConfigOnUpdateIni) {`
`216`	`216`	`}`
`217`	`217`
`218`	`218`	`if (!zai_config_is_initialized()) {`
`219`		`- zval_dtor(&new_zv);`
	`219`	`+ zval_ptr_dtor_nogc(&new_zv);`
`220`	`220`	`return SUCCESS;`
`221`	`221`	`}`
`222`	`222`
`223`	`223`	`if (memoized->ini_change && !memoized->ini_change(zai_config_get_value(id), &new_zv, new_value)) {`
`224`		`- zval_dtor(&new_zv);`
	`224`	`+ zval_ptr_dtor_nogc(&new_zv);`
`225`	`225`	`return FAILURE;`
`226`	`226`	`}`
`227`	`227`
`@@ -251,7 +251,7 @@ static ZEND_INI_MH(ZaiConfigOnUpdateIni) {`
`251`	`251`	`}`
`252`	`252`
`253`	`253`	`zai_config_replace_runtime_config(id, &new_zv);`
`254`		`- zval_dtor(&new_zv);`
	`254`	`+ zval_ptr_dtor_nogc(&new_zv);`
`255`	`255`	`return SUCCESS;`
`256`	`256`	`}`
`257`	`257`