Add spl extension

1 files changed, 349 insertions, 0 deletions

diff --git a/ext/spl/spl_array.c b/ext/spl/spl_array.c
new file mode 100755
index 0000000000..7c68d3c06f
--- /dev/null
+++ b/ext/spl/spl_array.c
@@ -0,0 +1,349 @@
+/*
+   +----------------------------------------------------------------------+
+   | PHP version 4.0                                                      |
+   +----------------------------------------------------------------------+
+   | Copyright (c) 1997, 1998, 1999, 2000, 2001 The PHP Group             |
+   +----------------------------------------------------------------------+
+   | This source file is subject to version 2.02 of the PHP license,      |
+   | that is bundled with this package in the file LICENSE, and is        |
+   | available at through the world-wide-web at                           |
+   | http://www.php.net/license/2_02.txt.                                 |
+   | If you did not receive a copy of the PHP license and are unable to   |
+   | obtain it through the world-wide-web, please send a note to          |
+   | license@php.net so we can mail you a copy immediately.               |
+   +----------------------------------------------------------------------+
+   | Authors: Marcus Boerger <helly@php.net>                              |
+   +----------------------------------------------------------------------+
+ */
+
+#ifdef HAVE_CONFIG_H
+# include "config.h"
+#endif
+
+#include "php.h"
+#include "php_ini.h"
+#include "ext/standard/info.h"
+#include "zend_compile.h"
+#include "zend_execute_locks.h"
+
+#include "php_spl.h"
+#include "spl_functions.h"
+#include "spl_engine.h"
+#include "spl_array.h"
+
+#define DELETE_ZVAL(z) \
+	if ((z)->refcount < 2) { \
+		zval_dtor(z); \
+		FREE_ZVAL(z); /* maybe safe_free_zval_ptr is needed for the uninitialised things */ \
+	}
+
+#define DELETE_RET_ZVAL(z) \
+	if ((z)->refcount < 3) { \
+		zval_dtor(z); \
+		FREE_ZVAL(z); /* maybe safe_free_zval_ptr is needed for the uninitialised things */ \
+	}
+
+#define AI_PTR_2_PTR_PTR(ai) \
+	(ai).ptr_ptr = &((ai).ptr)
+
+/* {{{ spl_array_writer_default stuff */
+typedef struct {
+	zval *obj;
+	zval *idx;
+} spl_array_writer_object;
+
+static zend_class_entry *spl_array_writer_default_get_class(zval *object TSRMLS_DC)
+{
+#ifdef SPL_ARRAY_WRITE
+	return spl_ce_array_writer_default;
+#else
+	return (zend_class_entry *)1; /* force an error here: this ensures not equal */
+#endif
+}
+
+static zend_object_handlers spl_array_writer_default_handlers = {
+	ZEND_OBJECTS_STORE_HANDLERS,
+	
+	NULL,     /* read_property */
+	NULL,     /* write_property */
+	NULL,     /* get_property_ptr */
+	NULL,     /* get_property_zval_ptr */
+	NULL,     /* get */
+	NULL,     /* set */
+	NULL,     /* has_property */
+	NULL,     /* unset_property */
+	NULL,     /* get_properties */
+	NULL,     /* get_method */
+	NULL,     /* call_method */
+	NULL,     /* get_constructor */
+	spl_array_writer_default_get_class,     /* get_class_entry */
+	NULL,     /* get_class_name */
+	NULL      /* compare_objects */
+};
+/* }}} */
+
+/* {{{ spl_array_writer_dtor */
+void spl_array_writer_default_dtor(void *object, zend_object_handle handle TSRMLS_DC)
+{
+	spl_array_writer_object *writer = (spl_array_writer_object*) object;
+
+	if (writer->obj)
+	{
+		writer->obj->refcount--;
+/*		DELETE_ZVAL(writer->obj); */
+	}
+	if (writer->idx)
+	{
+		writer->idx->refcount--;
+		DELETE_ZVAL(writer->idx);
+	}
+	efree(writer);
+}
+/* }}} */
+
+/* {{{ spl_array_writer_default_create */
+zend_object_value spl_array_writer_default_create(zend_class_entry *class_type TSRMLS_DC)
+{
+	zend_object_value retval;
+	spl_array_writer_object *intern;
+
+	intern = ecalloc(sizeof(spl_array_writer_object), 1);
+
+	retval.handle = zend_objects_store_put(intern, spl_array_writer_default_dtor, NULL TSRMLS_CC);
+	retval.handlers = &spl_array_writer_default_handlers;
+
+	return retval;
+}
+/* }}} */
+
+/* {{{ spl_array_writer_default_set */
+void spl_array_writer_default_set(zval *object, zval *newval, zval **retval TSRMLS_DC)
+{
+	zval *obj, *idx;
+	spl_array_writer_object *writer;
+
+	writer = (spl_array_writer_object *) zend_object_store_get_object(object TSRMLS_CC);
+	obj = writer->obj;
+	idx = writer->idx;
+	spl_begin_method_call_arg_ex2(&obj, "set", retval, &idx, &newval, 0, NULL TSRMLS_CC);
+}
+/* }}} */
+
+/* {{{ SPL_CLASS_FUNCTION(array_writer_default, __construct) */
+SPL_CLASS_FUNCTION(array_writer_default, __construct)
+{
+	zval *object = getThis();
+	zval *obj, *idx;
+	spl_array_writer_object *writer;
+
+	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zz", &obj, &idx) == FAILURE) {
+		php_error_docref(NULL TSRMLS_CC, E_ERROR, "Failed to parse parameters");
+		return;
+	}
+	writer = (spl_array_writer_object *) zend_object_store_get_object(object TSRMLS_CC);
+	writer->obj = obj; obj->refcount++;
+	writer->idx = idx; idx->refcount++;
+
+}
+/* }}} */
+
+/* {{{ SPL_CLASS_FUNCTION(array_writer_default, set) */
+SPL_CLASS_FUNCTION(array_writer_default, set)
+{
+	zval *object = getThis();
+	zval *newval;
+
+	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &newval) == FAILURE) {
+		php_error_docref(NULL TSRMLS_CC, E_ERROR, "Failed to parse parameters");
+		return;
+	}
+	spl_array_writer_default_set(object, newval, &return_value TSRMLS_CC);
+}
+/* }}} */
+
+/* {{{ spl_fetch_dimension_address */
+int spl_fetch_dimension_address(znode *result, znode *op1, znode *op2, temp_variable *Ts, int type TSRMLS_DC)
+{
+	zval **container_ptr = spl_get_zval_ptr_ptr(op1, Ts TSRMLS_CC);
+
+	if (spl_is_instance_of(container_ptr, spl_ce_array_read TSRMLS_CC)) {
+		zval **retval = &(T(result->u.var).var.ptr);
+		zval *dim = spl_get_zval_ptr(op2, Ts, &EG(free_op2) TSRMLS_CC);
+		zval *exists;
+
+		/*ALLOC_ZVAL(exists); not needed */
+		spl_begin_method_call_arg_ex1(container_ptr, "exists", &exists, &dim, 0, NULL TSRMLS_CC);
+		if (!i_zend_is_true(exists)) {
+			if (type == BP_VAR_R || type == BP_VAR_RW) {
+				SEPARATE_ZVAL(&dim);
+				convert_to_string_ex(&dim);
+				zend_error(E_NOTICE,"Undefined index:  %s", Z_STRVAL_P(dim));
+				DELETE_ZVAL(dim);
+			}
+			if (type == BP_VAR_R || type == BP_VAR_IS) {
+				DELETE_RET_ZVAL(exists);
+				*retval = &EG(error_zval);
+				(*retval)->refcount++;
+				FREE_OP(Ts, op2, EG(free_op2));
+				SELECTIVE_PZVAL_LOCK(*retval, result);
+				return 0;
+			}
+		}
+		DELETE_RET_ZVAL(exists);
+		if (type == BP_VAR_R || type == BP_VAR_IS) {
+			spl_begin_method_call_arg_ex1(container_ptr, "get", retval, &dim, 0, NULL TSRMLS_CC);
+			(*retval)->refcount--;
+		} else 
+#ifdef SPL_ARRAY_WRITE
+		if (spl_is_instance_of(container_ptr, spl_ce_array_access_ex TSRMLS_CC)) {
+			/* array_access_ex instaces have their own way of creating an access_writer */
+			spl_begin_method_call_arg_ex1(container_ptr, "new_writer", retval, &dim, 0, NULL TSRMLS_CC);
+			T(result->u.var).var.ptr = *retval;
+			AI_PTR_2_PTR_PTR(T(result->u.var).var);
+			SELECTIVE_PZVAL_LOCK(*retval, result);
+		} else if (spl_is_instance_of(container_ptr, spl_ce_array_access TSRMLS_CC)) {
+			/* array_access instances create the default array_writer: array_write */
+			spl_array_writer_object *writer;
+			spl_instanciate(spl_ce_array_writer_default, retval TSRMLS_CC);
+			T(result->u.var).var.ptr = *retval;
+			AI_PTR_2_PTR_PTR(T(result->u.var).var);
+			writer = (spl_array_writer_object *) zend_object_store_get_object(*retval TSRMLS_CC);
+			writer->obj = *container_ptr; writer->obj->refcount++;
+			writer->idx = dim;            writer->idx->refcount++;
+			SELECTIVE_PZVAL_LOCK(*retval, result);
+		} else {
+			zend_error(E_ERROR, "Object must implement spl::array_access for write access");
+			retval = &EG(error_zval_ptr);
+		}
+		SELECTIVE_PZVAL_LOCK(*retval, result);
+#else
+		zend_error(E_ERROR, "SPL compiled withut array write hook");
+#endif
+		FREE_OP(Ts, op2, EG(free_op2));
+		return 0;
+	}
+	return 1;
+}
+/* }}} */
+
+/* {{{ ZEND_EXECUTE_HOOK_FUNCTION(ZEND_FETCH_DIM_R) */
+#ifdef SPL_ARRAY_READ
+ZEND_EXECUTE_HOOK_FUNCTION(ZEND_FETCH_DIM_R)
+{
+	if (!spl_fetch_dimension_address(&EX(opline)->result, &EX(opline)->op1, &EX(opline)->op2, EX(Ts), BP_VAR_R TSRMLS_CC))
+	{
+		if (EX(opline)->extended_value == ZEND_FETCH_ADD_LOCK) {
+			PZVAL_LOCK(*EX_T(EX(opline)->op1.u.var).var.ptr_ptr);
+		}
+		spl_unlock_zval_ptr_ptr(&EX(opline)->op1, EX(Ts) TSRMLS_CC);
+
+		AI_PTR_2_PTR_PTR(EX_T(EX(opline)->result.u.var).var);
+		NEXT_OPCODE();
+	}
+	ZEND_EXECUTE_HOOK_ORIGINAL(ZEND_FETCH_DIM_R);
+}
+#endif
+/* }}} */
+
+/* {{{ ZEND_EXECUTE_HOOK_FUNCTION(ZEND_FETCH_DIM_W) */
+#ifdef SPL_ARRAY_READ
+ZEND_EXECUTE_HOOK_FUNCTION(ZEND_FETCH_DIM_W)
+{
+	if (!spl_fetch_dimension_address(&EX(opline)->result, &EX(opline)->op1, &EX(opline)->op2, EX(Ts), BP_VAR_W TSRMLS_CC))
+	{
+		spl_unlock_zval_ptr_ptr(&EX(opline)->op1, EX(Ts) TSRMLS_CC);
+
+		NEXT_OPCODE();
+	}
+	ZEND_EXECUTE_HOOK_ORIGINAL(ZEND_FETCH_DIM_W);
+}
+#endif
+/* }}} */
+
+/* {{{ ZEND_EXECUTE_HOOK_FUNCTION(ZEND_FETCH_DIM_RW) */
+#ifdef SPL_ARRAY_READ
+ZEND_EXECUTE_HOOK_FUNCTION(ZEND_FETCH_DIM_RW)
+{
+	if (!spl_fetch_dimension_address(&EX(opline)->result, &EX(opline)->op1, &EX(opline)->op2, EX(Ts), BP_VAR_RW TSRMLS_CC))
+	{
+		spl_unlock_zval_ptr_ptr(&EX(opline)->op1, EX(Ts) TSRMLS_CC);
+
+		NEXT_OPCODE();
+	}
+	ZEND_EXECUTE_HOOK_ORIGINAL(ZEND_FETCH_DIM_RW);
+}
+#endif
+/* }}} */
+
+/* {{{ ZEND_EXECUTE_HOOK_FUNCTION(ZEND_ASSIGN) */
+#ifdef SPL_ARRAY_WRITE
+ZEND_EXECUTE_HOOK_FUNCTION(ZEND_ASSIGN)
+{
+	zval **writer = spl_get_zval_ptr_ptr(&EX(opline)->op1, EX(Ts) TSRMLS_CC);
+	zval *newval, *retval, *target;
+	znode *result;
+
+	if (writer && *writer && Z_TYPE_PP(writer) == IS_OBJECT) {
+		/* optimization: do pre checks and only test for handlers in case of
+		 * spl::array_writer_default, for spl::array_writer we must use the 
+		 * long way of calling spl_instance
+		 * if (spl_is_instance_of(writer, spl_ce_array_writer_default TSRMLS_CC))
+		 */
+		if ((*writer)->value.obj.handlers == &spl_array_writer_default_handlers) {
+			newval = spl_get_zval_ptr(&EX(opline)->op2, EX(Ts), &EG(free_op2) TSRMLS_CC);
+			spl_array_writer_default_set(*writer, newval, &retval TSRMLS_CC);
+		} else if (spl_is_instance_of(writer, spl_ce_array_writer TSRMLS_CC)) {
+			newval = spl_get_zval_ptr(&EX(opline)->op2, EX(Ts), &EG(free_op2) TSRMLS_CC);
+			spl_begin_method_call_arg_ex1(writer, "set", &retval, &newval, 0, NULL TSRMLS_CC);
+		} else {
+			ZEND_EXECUTE_HOOK_ORIGINAL(ZEND_ASSIGN);
+		}
+	} else {
+		ZEND_EXECUTE_HOOK_ORIGINAL(ZEND_ASSIGN);
+	}
+	spl_unlock_zval_ptr_ptr(&EX(opline)->op1, EX(Ts) TSRMLS_CC);
+
+	result = &EX(opline)->result;
+	if (result) {
+		if (retval->refcount<2) {
+			if ((*writer)->value.obj.handlers == &spl_array_writer_default_handlers) {
+				spl_array_writer_object *object = (spl_array_writer_object *) zend_object_store_get_object(*writer TSRMLS_CC);
+				target = object->obj;
+			} else {
+				target = *writer;
+			}
+			zend_error(E_WARNING, "Method %s::set() did not return a value, using NULL", Z_OBJCE_P(target)->name);
+			DELETE_ZVAL(retval);
+			DELETE_ZVAL(newval);
+			/* Unfortunately it doesn't work when trying to return newval.
+			 * But anyhow it wouldn't make sense...and confuse reference counting and such.
+			 */
+			retval = &EG(uninitialized_zval);
+		} else {
+			retval->refcount--;
+		}
+		EX_T(EX(opline)->result.u.var).var.ptr = retval;
+		AI_PTR_2_PTR_PTR(EX_T(EX(opline)->result.u.var).var);
+		SELECTIVE_PZVAL_LOCK(retval, result);
+	} else {
+		retval->refcount = 1;
+		DELETE_ZVAL(retval);
+	}
+
+	(*writer)->refcount = 1;
+	DELETE_ZVAL(*writer);
+	FREE_OP(EX(Ts), &EX(opline)->op2, EG(free_op2));
+
+	NEXT_OPCODE();
+}
+#endif
+/* }}} */
+
+/*
+ * Local variables:
+ * tab-width: 4
+ * c-basic-offset: 4
+ * End:
+ * vim600: fdm=marker
+ * vim: noet sw=4 ts=4
+ */