Delay variable bindings

Author: iluuu1994

Zend/tests/pattern_matching/is/delayed_binding.phpt

@@ -0,0 +1,50 @@
+--TEST--
+Delayed binding
+--FILE--
+<?php
+
+class Pair {
+    public function __construct(public $a, public $b) {}
+}
+
+var_dump(new Pair(1, 2) is Pair { a: $a, b: $b });
+var_dump($a, $b);
+unset($a, $b);
+
+var_dump(new Pair(1, 2) is Pair { a: $a, b: 3 });
+var_dump($a, $b);
+unset($a, $b);
+
+var_dump(new Pair(new \stdClass(), 2) is Pair { a: $a, b: 2 });
+var_dump($a, $b);
+unset($a, $b);
+
+var_dump(new Pair(new \stdClass(), 2) is Pair { a: $a, b: 3 });
+var_dump($a, $b);
+unset($a, $b);
+
+?>
+--EXPECTF--
+bool(true)
+int(1)
+int(2)
+bool(false)
+
+Warning: Undefined variable $a in %s on line %d
+
+Warning: Undefined variable $b in %s on line %d
+NULL
+NULL
+bool(true)
+
+Warning: Undefined variable $b in %s on line %d
+object(stdClass)#2 (0) {
+}
+NULL
+bool(false)
+
+Warning: Undefined variable $a in %s on line %d
+
+Warning: Undefined variable $b in %s on line %d
+NULL
+NULL

Zend/zend_execute_API.c

@@ -38,6 +38,7 @@
 #include "zend_inheritance.h"
 #include "zend_observer.h"
 #include "zend_call_stack.h"
+#include "zend_pattern_matching.h"
 #ifdef HAVE_SYS_TIME_H
 #include <sys/time.h>
 #endif
@@ -203,6 +204,8 @@ void init_executor(void) /* {{{ */
 	zend_fiber_init();
 	zend_weakrefs_init();
 
+	zend_pm_contexts_free();
+
 	EG(active) = 1;
 }
 /* }}} */

Zend/zend_globals.h

@@ -41,6 +41,7 @@
 #include "zend_arena.h"
 #include "zend_call_stack.h"
 #include "zend_max_execution_timer.h"
+#include "zend_pattern_matching.h"
 
 /* Define ZTS if you want a thread-safe Zend */
 /*#undef ZTS*/
@@ -304,6 +305,9 @@ struct _zend_executor_globals {
 	struct sigaction oldact;
 #endif
 
+	zend_pm_context *pm_context;
+	zend_pm_context pm_context_spare;
+
 	void *reserved[ZEND_MAX_RESERVED_RESOURCES];
 };
 

Zend/zend_pattern_matching.c

@@ -170,15 +170,22 @@ static pm_result match_binding(zval *zv, zend_ast *pattern)
 		return PM_MISMATCH;
 	}
 
-	// FIXME: Delay to the end of pattern matching
-	zend_execute_data *execute_data = EG(current_execute_data);
-	uint32_t var = (uint32_t) pattern->attr;
-	zval *cv = EX_VAR(var);
-	zend_assign_to_variable(cv, zv, IS_CV, EX_USES_STRICT_TYPES());
-	/* Destructor might throw */
-	if (EG(exception)) {
-		return PM_ERROR;
+	zend_pm_context *context = EG(pm_context);
+	zend_pm_bindings *bindings = context->bindings;
+	if (!bindings) {
+		bindings = &context->bindings_spare;
+		context->bindings = bindings;
+	} else if (bindings->num_used == ZEND_PM_BINDINGS_SLOTS) {
+		zend_pm_bindings *new_bindings = emalloc(sizeof(zend_pm_bindings));
+		new_bindings->next = bindings;
+		bindings = new_bindings;
+		context->bindings = bindings;
 	}
+
+	zend_pm_binding *binding = &bindings->list[bindings->num_used++];
+	binding->var = (uint32_t) pattern->attr;
+	ZVAL_COPY(&binding->value, zv);
+
 	return PM_MATCH;
 }
 
@@ -246,7 +253,6 @@ pm_result match_class_const(zval *zv, zend_ast *pattern)
 pm_result zend_pattern_match_ex(zval *zv, zend_ast *pattern)
 {
 	ZVAL_DEREF(zv);
-	// FIXME: Do we need DEINDIRECT too?
 
 	switch (pattern->kind) {
 		case ZEND_AST_TYPE_PATTERN:
@@ -283,7 +289,80 @@ pm_result zend_pattern_match_ex(zval *zv, zend_ast *pattern)
 	}
 }
 
+static void create_context(void)
+{
+	if (!EG(pm_context)) {
+		EG(pm_context) = &EG(pm_context_spare);
+	} else {
+		zend_pm_context *prev = EG(pm_context);
+		EG(pm_context) = emalloc(sizeof(zend_pm_context));
+		EG(pm_context)->prev = prev;
+	}
+}
+
+static void pm_context_free(bool free_values)
+{
+	zend_pm_context *context = EG(pm_context);
+	zend_pm_bindings *bindings = context->bindings;
+
+	EG(pm_context) = context->prev;
+
+	while (bindings) {
+		if (free_values) {
+			for (uint8_t i = 0; i < bindings->num_used; i++) {
+				zval_ptr_dtor(&bindings->list[i].value);
+			}
+		}
+		zend_pm_bindings *next = bindings->next;
+		if (bindings != &context->bindings_spare) {
+			efree(bindings);
+		}
+		bindings = bindings->next;
+		bindings = next;
+	}
+
+	context->bindings = NULL;
+	memset(&context->bindings_spare, 0, sizeof(context->bindings_spare));
+
+	if (context != &EG(pm_context_spare)) {
+		efree(context);
+	} else {
+		memset(context, 0, sizeof(zend_pm_context));
+	}
+}
+
+static void bind_variables(void)
+{
+	zend_pm_context *context = EG(pm_context);
+	zend_pm_bindings *bindings = context->bindings;
+	zend_execute_data *execute_data = EG(current_execute_data);
+	while (bindings) {
+		for (uint32_t i = 0; i < bindings->num_used; i++) {
+			zend_pm_binding *binding = &bindings->list[i];
+			zend_assign_to_variable(EX_VAR(binding->var), &binding->value, IS_CV, EX_USES_STRICT_TYPES());
+		}
+		bindings = bindings->next;
+	}
+}
+
+void zend_pm_contexts_free(void)
+{
+	while (EG(pm_context)) {
+		pm_context_free(false);
+	}
+}
+
 bool zend_pattern_match(zval *zv, zend_ast *pattern)
 {
-	return zend_pattern_match_ex(zv, pattern) == PM_MATCH;
+	// FIXME: Only create context when necessary
+	create_context();
+	pm_result result = zend_pattern_match_ex(zv, pattern);
+	if (result == PM_MATCH) {
+		bind_variables();
+		pm_context_free(true);
+		return true;
+	} else {
+		pm_context_free(true);
+		return false;
+	}
 }

Zend/zend_pattern_matching.h

@@ -19,6 +19,28 @@
 
 #include "zend.h"
 
+#define ZEND_PM_BINDINGS_SLOTS 8
+
+typedef struct {
+	uint32_t var;
+	zval value;
+} zend_pm_binding;
+
+typedef struct _zend_pm_bindings zend_pm_bindings;
+struct _zend_pm_bindings {
+	zend_pm_binding list[ZEND_PM_BINDINGS_SLOTS];
+	zend_pm_bindings *next;
+	uint8_t num_used;
+};
+
+typedef struct _zend_pm_context zend_pm_context;
+typedef struct _zend_pm_context {
+	zend_pm_bindings *bindings;
+	zend_pm_bindings bindings_spare;
+	zend_pm_context *prev;
+} zend_pm_context;
+
 bool zend_pattern_match(zval *zv, zend_ast *pattern);
+void zend_pm_contexts_free(void);
 
 #endif