ext/rpc/com should work now, but there's still lots of work left.

1 files changed, 206 insertions, 226 deletions

diff --git a/ext/rpc/com/variant.c b/ext/rpc/com/variant.c
index e06dd23e9e..a827cde602 100644
--- a/ext/rpc/com/variant.c
+++ b/ext/rpc/com/variant.c
@@ -13,6 +13,7 @@
    | license@php.net so we can mail you a copy immediately.               |
    +----------------------------------------------------------------------+
    | Author: Harald Radi <h.radi@nme.at>                                  |
+   |         Alan Brown   <abrown@pobox.com>                              |
    +----------------------------------------------------------------------+
  */
 
@@ -29,25 +30,52 @@
 #include "php.h"
 #include "php_ini.h"
 #include "ext/standard/info.h"
-#include "php_VARIANT.h"
+#include "conversion.h"
+#include "variant.h"
 
 #include <unknwn.h> 
 
-static int do_VARIANT_propset(VARIANT *var_arg, pval *arg_property, pval *value TSRMLS_DC);
-static int php_VARIANT_set_property_handler(zend_property_reference *property_reference, pval *value);
-static pval php_VARIANT_get_property_handler(zend_property_reference *property_reference);
-static void php_VARIANT_call_function_handler(INTERNAL_FUNCTION_PARAMETERS, zend_property_reference *property_reference);
-static void php_VARIANT_destructor(zend_rsrc_list_entry *rsrc TSRMLS_DC);
-static void php_register_VARIANT_class(TSRMLS_D);
-
-static int le_variant;
-static int codepage;
-static zend_class_entry VARIANT_class_entry;
-
-
-void php_VARIANT_init(int module_number TSRMLS_DC)
+static zend_object_value variant_objects_new(zend_class_entry * TSRMLS_DC);
+static void variant_objects_delete(void *, zend_object_handle TSRMLS_DC);
+
+/* object handler */
+static zval* variant_read(zval *, zval *, int  TSRMLS_DC);
+static void variant_write(zval *, zval *, zval * TSRMLS_DC);
+static union _zend_function* variant_get_constructor(zval * TSRMLS_DC);
+static zend_class_entry* variant_get_class_entry(zval * TSRMLS_DC);
+/**/
+
+static HashTable types;
+static zend_class_entry *variant_class_entry;
+static zend_function *variant_ctor;
+static zend_object_handlers variant_handlers = {
+	ZEND_OBJECTS_STORE_HANDLERS,
+
+	variant_read,
+	variant_write,
+	NULL,
+	NULL,
+	NULL,
+	NULL,
+	NULL,
+	NULL,
+	NULL,
+	NULL,
+	NULL,
+	NULL,
+	NULL,
+	variant_get_constructor,
+	variant_get_class_entry,
+	NULL,
+	NULL
+};
+
+/**/
+void php_variant_init(int module_number TSRMLS_DC)
 {
-	le_variant = zend_register_list_destructors_ex(php_VARIANT_destructor, NULL, "VARIANT", module_number);
+	zend_internal_function *zif;
+	zend_class_entry ce;
+	int type;
 
 	/* variant datatypes */
 	REGISTER_LONG_CONSTANT("VT_NULL", VT_NULL, CONST_CS | CONST_PERSISTENT);
@@ -84,259 +112,211 @@ void php_VARIANT_init(int module_number TSRMLS_DC)
 #ifdef CP_SYMBOL
 	REGISTER_LONG_CONSTANT("CP_SYMBOL", CP_SYMBOL, CONST_CS | CONST_PERSISTENT);
 #else
-#	error	"CP_SYMBOL undefined"
+#error "CP_SYMBOL undefined"
 #endif
 #ifdef CP_THREAD_ACP
 	REGISTER_LONG_CONSTANT("CP_THREAD_ACP", CP_THREAD_ACP, CONST_CS | CONST_PERSISTENT);
 #else
-#	error	"CP_THREAD_ACP undefined"
+#error "CP_THREAD_ACP undefined"
 #endif
 
-	php_register_VARIANT_class(TSRMLS_C);
+	INIT_CLASS_ENTRY(ce, "variant", NULL);
+	ce.create_object = variant_objects_new;
+	variant_class_entry = zend_register_internal_class(&ce TSRMLS_CC);
+
+	zif = (zend_internal_function *) emalloc(sizeof(zend_internal_function));
+
+	zif->type = ZEND_INTERNAL_FUNCTION;
+	zif->function_name = variant_class_entry->name;
+	zif->scope = variant_class_entry;
+	zif->arg_types = NULL;
+	zif->handler = ZEND_FN(variant_load);
+
+	/* add new constructor to the method table */
+	zend_hash_add(&(variant_class_entry->function_table), variant_class_entry->name,
+					variant_class_entry->name_length + 1, zif, sizeof(zend_function), &variant_ctor);
+	efree(zif);
+
+	zend_hash_init(&types, 0, NULL, NULL, TRUE);
+
+	type = VT_UI1;
+	zend_hash_add(&types, "bVal",		5,  (void *) &type, sizeof(int), NULL);
+	type = VT_UI2;
+	zend_hash_add(&types, "uiVal",		6,  (void *) &type, sizeof(int), NULL);
+	type = VT_UI4;
+	zend_hash_add(&types, "ulVal",		6,  (void *) &type, sizeof(int), NULL);
+	type = VT_UINT;
+	zend_hash_add(&types, "uintVal",	8,  (void *) &type, sizeof(int), NULL);
+	type = VT_I1;
+	zend_hash_add(&types, "cVal",		5,  (void *) &type, sizeof(int), NULL);
+	type = VT_I2;
+	zend_hash_add(&types, "iVal",		5,  (void *) &type, sizeof(int), NULL);
+	type = VT_I4;
+	zend_hash_add(&types, "lVal",		5,  (void *) &type, sizeof(int), NULL);
+	type = VT_INT;
+	zend_hash_add(&types, "intVal",		7,  (void *) &type, sizeof(int), NULL);
+	type = VT_R4;
+	zend_hash_add(&types, "fltVal",		7,  (void *) &type, sizeof(int), NULL);
+	type = VT_R8;
+	zend_hash_add(&types, "dblVal",		7,  (void *) &type, sizeof(int), NULL);
+	type = VT_BOOL;
+	zend_hash_add(&types, "boolVal",	8,  (void *) &type, sizeof(int), NULL);
+	type = VT_ERROR;
+	zend_hash_add(&types, "scode",		6,  (void *) &type, sizeof(int), NULL);
+	type = VT_CY;
+	zend_hash_add(&types, "cyVal",		6,  (void *) &type, sizeof(int), NULL);
+	type = VT_DATE;
+	zend_hash_add(&types, "date",		5,  (void *) &type, sizeof(int), NULL);
+	type = VT_BSTR;
+	zend_hash_add(&types, "bstrVal",	8,  (void *) &type, sizeof(int), NULL);
+	type = VT_UNKNOWN;
+	zend_hash_add(&types, "punkVal",	8,  (void *) &type, sizeof(int), NULL);
+	type = VT_DISPATCH;
+	zend_hash_add(&types, "pdispVal",	9,  (void *) &type, sizeof(int), NULL);
+	type = VT_ARRAY;
+	zend_hash_add(&types, "parray",		7,  (void *) &type, sizeof(int), NULL);
+	type = VT_BYREF;
+	zend_hash_add(&types, "byref",		6,  (void *) &type, sizeof(int), NULL);
+	type = VT_BYREF|VT_UI1;
+	zend_hash_add(&types, "pbVal",		6,  (void *) &type, sizeof(int), NULL);
+	type = VT_BYREF|VT_UI2;
+	zend_hash_add(&types, "puiVal",		7,  (void *) &type, sizeof(int), NULL);
+	type = VT_BYREF|VT_UI4;
+	zend_hash_add(&types, "pulVal",		7,  (void *) &type, sizeof(int), NULL);
+	type = VT_BYREF|VT_UINT;
+	zend_hash_add(&types, "puintVal",	9,  (void *) &type, sizeof(int), NULL);
+	type = VT_BYREF|VT_I1;
+	zend_hash_add(&types, "pcVal",		6,  (void *) &type, sizeof(int), NULL);
+	type = VT_BYREF|VT_I2;
+	zend_hash_add(&types, "piVal",		6,  (void *) &type, sizeof(int), NULL);
+	type = VT_BYREF|VT_I4;
+	zend_hash_add(&types, "plVal",		6,  (void *) &type, sizeof(int), NULL);
+	type = VT_BYREF|VT_INT;
+	zend_hash_add(&types, "pintVal",	8,  (void *) &type, sizeof(int), NULL);
+	type = VT_BYREF|VT_R4;
+	zend_hash_add(&types, "pfltVal",	8,  (void *) &type, sizeof(int), NULL);
+	type = VT_BYREF|VT_R8;
+	zend_hash_add(&types, "pdblVal",	8,  (void *) &type, sizeof(int), NULL);
+	type = VT_BYREF|VT_BOOL;
+	zend_hash_add(&types, "pboolVal",	9,  (void *) &type, sizeof(int), NULL);
+	type = VT_BYREF|VT_ERROR;
+	zend_hash_add(&types, "pscode",		7,  (void *) &type, sizeof(int), NULL);
+	type = VT_BYREF|VT_CY;
+	zend_hash_add(&types, "pcyVal",		7,  (void *) &type, sizeof(int), NULL);
+	type = VT_BYREF|VT_DATE;
+	zend_hash_add(&types, "pdate",		6,  (void *) &type, sizeof(int), NULL);
+	type = VT_BYREF|VT_BSTR;
+	zend_hash_add(&types, "pbstrVal",	9,  (void *) &type, sizeof(int), NULL);
+	type = VT_BYREF|VT_DECIMAL;
+	zend_hash_add(&types, "pdecVal",	8,  (void *) &type, sizeof(int), NULL);
+	type = VT_BYREF|VT_UNKNOWN;
+	zend_hash_add(&types, "ppunkVal",	9,  (void *) &type, sizeof(int), NULL);
+	type = VT_BYREF|VT_DISPATCH;
+	zend_hash_add(&types, "ppdispVal",	10, (void *) &type, sizeof(int), NULL);
+	type = VT_BYREF|VT_ARRAY;
+	zend_hash_add(&types, "pparray",	8,  (void *) &type, sizeof(int), NULL);
+	type = VT_BYREF|VT_VARIANT;
+	zend_hash_add(&types, "pvarVal",	8,  (void *) &type, sizeof(int), NULL);
 }
 
-
-PHPAPI int php_VARIANT_get_le_variant()
+void php_variant_shutdown(TSRMLS_D)
 {
-	return le_variant;
+	zend_hash_destroy(&types);
 }
 
-
-static void php_VARIANT_call_function_handler(INTERNAL_FUNCTION_PARAMETERS, zend_property_reference *property_reference)
+static zend_object_value variant_objects_new(zend_class_entry *ce TSRMLS_DC)
 {
-	pval *object = property_reference->object;
-	zend_overloaded_element *function_name = (zend_overloaded_element *) property_reference->elements_list->tail->data;
-	VARIANT *pVar;
-
-	if ((zend_llist_count(property_reference->elements_list)==1) && !strcmp(Z_STRVAL(function_name->element), "variant")) {
-		/* constructor */
-		pval *object_handle, *data, *type, *code_page;
-
-		ALLOC_VARIANT(pVar);
-		VariantInit(pVar);
-
-		switch (ZEND_NUM_ARGS()) {
-			case 0:
-				/* nothing to do */
-				break;
-			case 1:
-				zend_get_parameters(ht, 1, &data);
-				php_pval_to_variant(data, pVar, codepage TSRMLS_CC);
-				codepage = CP_ACP;
-				break;
-			case 2:
-				zend_get_parameters(ht, 2, &data, &type);
-				php_pval_to_variant_ex(data, pVar, type, codepage TSRMLS_CC);
-				codepage = CP_ACP;
-				break;
-			case 3:
-				zend_get_parameters(ht, 3, &data, &type, &code_page);
-				php_pval_to_variant_ex(data, pVar, type, codepage TSRMLS_CC);
-				convert_to_long(code_page);
-				codepage = Z_LVAL_P(code_page);
-				break;
-			default:
-				ZEND_WRONG_PARAM_COUNT();
-				break;
-		}
+	zend_object_value *zov;
+	variantval *var;
 
-		RETVAL_LONG(zend_list_insert(pVar, IS_VARIANT));
-
-		if (!zend_is_true(return_value)) {
-			ZVAL_FALSE(object);
-			return;
-		}
+	ALLOC_VARIANT(var);
+	
+	/* set up the object value struct */
+	zov = (zend_object_value*) emalloc(sizeof(zend_object_value));
+	zov->handlers = &variant_handlers;
+	zov->handle = zend_objects_store_put(var, variant_objects_delete, NULL TSRMLS_CC);
 
-		ALLOC_ZVAL(object_handle);
-		*object_handle = *return_value;
-		pval_copy_constructor(object_handle);
-		INIT_PZVAL(object_handle);
-		zend_hash_index_update(Z_OBJPROP_P(object), 0, &object_handle, sizeof(pval *), NULL);
-		zval_dtor(&function_name->element);
-	}
+	return *zov;
 }
 
+static void variant_objects_delete(void *object, zend_object_handle handle TSRMLS_DC)
+{
+	FREE_VARIANT((variantval *)object);
+}
 
-static pval php_VARIANT_get_property_handler(zend_property_reference *property_reference)
+static zval* variant_read(zval *object, zval *member, int type TSRMLS_DC)
 {
-	zend_overloaded_element *overloaded_property;
-	int type;
-	pval result, **var_handle, *object = property_reference->object;
-	VARIANT *var_arg;
-	TSRMLS_FETCH();
+	variantval *var;
+	zval *result;
 
+	ALLOC_ZVAL(result);
 
-	/* fetch the VARIANT structure */
-	zend_hash_index_find(Z_OBJPROP_P(object), 0, (void **) &var_handle);
-	var_arg = zend_list_find(Z_LVAL_PP(var_handle), &type);
+	if ((var = zend_object_store_get_object(object TSRMLS_CC)) == NULL) {
+		/* exception */
+	}
 
-	if (!var_arg || (type != IS_VARIANT)) {
-		ZVAL_FALSE(&result);
+	if (!strcmp(Z_STRVAL_P(member), "value")) {
+		/* var_arg can't be an idispatch, so we don't care for the implicit AddRef() call here */
+		php_variant_to_zval(var->var, result, var->codepage);
+	} else if (!strcmp(Z_STRVAL_P(member), "type")) {
+		ZVAL_LONG(result, V_VT(var->var));
 	} else {
-		overloaded_property = (zend_overloaded_element *) property_reference->elements_list->head->data;
-		switch (Z_TYPE_P(overloaded_property)) {
-			case OE_IS_ARRAY:
-				ZVAL_FALSE(&result);
-				break;
-
-			case OE_IS_OBJECT:
-				if (!strcmp(Z_STRVAL(overloaded_property->element), "value")) {
-					// var_arg can't be an idispatch, so we don't care for the implicit AddRef() call here
-					php_variant_to_pval(var_arg, &result, codepage TSRMLS_CC);
-				} else if (!strcmp(Z_STRVAL(overloaded_property->element), "type")) {
-					ZVAL_LONG(&result, V_VT(var_arg))
-				} else {
-					ZVAL_FALSE(&result);
-					php_error(E_WARNING, "Unknown member.");
-				}
-				break;
-			case OE_IS_METHOD:
-				ZVAL_FALSE(&result);
-				php_error(E_WARNING, "Unknown method.");
-				break;
-
-				zval_dtor(&overloaded_property->element);
-		}
+		ZVAL_FALSE(result);
+		php_error(E_WARNING, "Unknown member.");
 	}
 
 	return result;
 }
 
-
-static int php_VARIANT_set_property_handler(zend_property_reference *property_reference, pval *value)
+static void variant_write(zval *object, zval *member, zval *value TSRMLS_DC)
 {
-	zend_overloaded_element *overloaded_property;
-	int type;
-	pval **var_handle, *object = property_reference->object;
-	VARIANT *var_arg;
-	TSRMLS_FETCH();
+	int *type;
+	variantval *var;
 
-
-	/* fetch the VARIANT structure */
-	zend_hash_index_find(Z_OBJPROP_P(object), 0, (void **) &var_handle);
-	var_arg = zend_list_find(Z_LVAL_PP(var_handle), &type);
-
-	if (!var_arg || (type != IS_VARIANT)) {
-		return FAILURE;
+	if ((var = zend_object_store_get_object(object TSRMLS_CC)) == NULL) {
+		/* exception */
 	}
 
-	overloaded_property = (zend_overloaded_element *) property_reference->elements_list->head->data;
-	do_VARIANT_propset(var_arg, &overloaded_property->element, value TSRMLS_CC);
-	zval_dtor(&overloaded_property->element);
-	return SUCCESS;
-}
-
-
-static int do_VARIANT_propset(VARIANT *var_arg, pval *arg_property, pval *value TSRMLS_DC)
-{
-	int type;
-
-	if (!strcmp(Z_STRVAL_P(arg_property), "value")) {
-		php_pval_to_variant(value, var_arg, codepage TSRMLS_CC);
-
-		return SUCCESS;
-	} else if (!strcmp(Z_STRVAL_P(arg_property), "bVal")) {
-		type = VT_UI1;
-	} else if (!strcmp(Z_STRVAL_P(arg_property), "iVal")) { 
-		type = VT_I2;
-	} else if (!strcmp(Z_STRVAL_P(arg_property), "lVal")) {
-		type = VT_I4;
-	} else if (!strcmp(Z_STRVAL_P(arg_property), "fltVal")) {
-		type = VT_R4;
-	} else if (!strcmp(Z_STRVAL_P(arg_property), "dblVal")) {
-		type = VT_R8;
-	} else if (!strcmp(Z_STRVAL_P(arg_property), "boolVal")) {
-		type = VT_BOOL;
-	} else if (!strcmp(Z_STRVAL_P(arg_property), "scode")) {
-		type = VT_ERROR;
-	} else if (!strcmp(Z_STRVAL_P(arg_property), "cyVal")) {
-		type = VT_CY;
-	} else if (!strcmp(Z_STRVAL_P(arg_property), "date")) {
-		type = VT_DATE;
-	} else if (!strcmp(Z_STRVAL_P(arg_property), "bstrVal")) {
-		type = VT_BSTR;
-	} else if (!strcmp(Z_STRVAL_P(arg_property), "pdecVal")) {
-		type = VT_DECIMAL|VT_BYREF;
-	} else if (!strcmp(Z_STRVAL_P(arg_property), "punkVal")) {
-		type = VT_UNKNOWN;
-	} else if (!strcmp(Z_STRVAL_P(arg_property), "pdispVal")) {
-		type = VT_DISPATCH;
-	} else if (!strcmp(Z_STRVAL_P(arg_property), "parray")) {
-		type = VT_ARRAY;
-	} else if (!strcmp(Z_STRVAL_P(arg_property), "pbVal")) {
-		type = VT_UI1|VT_BYREF;
-	} else if (!strcmp(Z_STRVAL_P(arg_property), "piVal")) {
-		type = VT_I2|VT_BYREF;
-	} else if (!strcmp(Z_STRVAL_P(arg_property), "plVal")) {
-		type = VT_I4|VT_BYREF;
-	} else if (!strcmp(Z_STRVAL_P(arg_property), "pfltVal")) {
-		type = VT_R4|VT_BYREF;
-	} else if (!strcmp(Z_STRVAL_P(arg_property), "pdblVal")) {
-		type = VT_R8|VT_BYREF;
-	} else if (!strcmp(Z_STRVAL_P(arg_property), "pboolVal")) {
-		type = VT_BOOL|VT_BYREF;
-	} else if (!strcmp(Z_STRVAL_P(arg_property), "pscode")) {
-		type = VT_ERROR|VT_BYREF;
-	} else if (!strcmp(Z_STRVAL_P(arg_property), "pcyVal")) {
-		type = VT_CY|VT_BYREF;
-	} else if (!strcmp(Z_STRVAL_P(arg_property), "pdate")) {
-		type = VT_DATE|VT_BYREF;
-	} else if (!strcmp(Z_STRVAL_P(arg_property), "pbstrVal")) {
-		type = VT_BSTR|VT_BYREF;
-	} else if (!strcmp(Z_STRVAL_P(arg_property), "ppunkVal")) {
-		type = VT_UNKNOWN|VT_BYREF;
-	} else if (!strcmp(Z_STRVAL_P(arg_property), "ppdispVal")) {
-		type = VT_DISPATCH|VT_BYREF;
-	} else if (!strcmp(Z_STRVAL_P(arg_property), "pparray")) {
-		type = VT_ARRAY|VT_BYREF;
-	} else if (!strcmp(Z_STRVAL_P(arg_property), "pvarVal")) {
-		type = VT_VARIANT|VT_BYREF;
-	} else if (!strcmp(Z_STRVAL_P(arg_property), "byref")) {
-		type = VT_BYREF;
-	} else if (!strcmp(Z_STRVAL_P(arg_property), "cVal")) {
-		type = VT_I1;
-	} else if (!strcmp(Z_STRVAL_P(arg_property), "uiVal")) {
-		type = VT_UI2;
-	} else if (!strcmp(Z_STRVAL_P(arg_property), "ulVal")) {
-		type = VT_UI4;
-	} else if (!strcmp(Z_STRVAL_P(arg_property), "intVal")) {
-		type = VT_INT;
-	} else if (!strcmp(Z_STRVAL_P(arg_property), "uintVal")) {
-		type = VT_UINT|VT_BYREF;
-	} else if (!strcmp(Z_STRVAL_P(arg_property), "pcVal")) {
-		type = VT_I1|VT_BYREF;
-	} else if (!strcmp(Z_STRVAL_P(arg_property), "puiVal")) {
-		type = VT_UI2|VT_BYREF;
-	} else if (!strcmp(Z_STRVAL_P(arg_property), "pulVal")) {
-		type = VT_UI4|VT_BYREF;
-	} else if (!strcmp(Z_STRVAL_P(arg_property), "pintVal")) {
-		type = VT_INT|VT_BYREF;
-	} else if (!strcmp(Z_STRVAL_P(arg_property), "puintVal")) {
-		type = VT_UINT|VT_BYREF;
+	if (!strcmp(Z_STRVAL_P(member), "value")) {
+		php_zval_to_variant(value, var->var, var->codepage);
+	} else if (zend_hash_find(&types, Z_STRVAL_P(member), Z_STRLEN_P(member) + 1, (void **) &type) == SUCCESS) {
+		php_zval_to_variant_ex(value, var->var, *type, var->codepage);
 	} else {
 		php_error(E_WARNING, "Unknown member.");
-		return FAILURE;
 	}
-
-	php_pval_to_variant_ex2(value, var_arg, type, codepage TSRMLS_CC);
-
-	return SUCCESS;
 }
 
+static union _zend_function* variant_get_constructor(zval *object TSRMLS_DC)
+{
+	return variant_ctor;
+}
 
-static void php_VARIANT_destructor(zend_rsrc_list_entry *rsrc TSRMLS_DC)
+static zend_class_entry* variant_get_class_entry(zval *object TSRMLS_DC)
 {
-	FREE_VARIANT(rsrc->ptr);
+	return variant_class_entry;
 }
 
-static void php_register_VARIANT_class(TSRMLS_D)
+/**/
+/* constructor */
+ZEND_FUNCTION(variant_load)
 {
-	INIT_OVERLOADED_CLASS_ENTRY(VARIANT_class_entry, "VARIANT", NULL,
-								php_VARIANT_call_function_handler,
-								php_VARIANT_get_property_handler,
-								php_VARIANT_set_property_handler);
+	zval *value = NULL, *object = getThis();
+	variantval *var;
+	long type = 0;
+
+	if (!object || ((var = zend_object_store_get_object(object TSRMLS_CC)) == NULL)) {
+		/*TODO exception */
+	}
+
+	zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|zll", &value, &type, &(var->codepage));
 
-	zend_register_internal_class(&VARIANT_class_entry TSRMLS_CC);
+	if (value) {
+		if (type) {
+			php_zval_to_variant_ex(value, var->var, type, var->codepage);
+		} else {
+			php_zval_to_variant(value, var->var, var->codepage);
+		}
+	}
 }
 
 #endif /* PHP_WIN32 */