diff options
Diffstat (limited to 'ext/soap/php_encoding.c')
| -rw-r--r-- | ext/soap/php_encoding.c | 1233 |
1 files changed, 567 insertions, 666 deletions
diff --git a/ext/soap/php_encoding.c b/ext/soap/php_encoding.c index c4ce4476bc..071c0fd3e1 100644 --- a/ext/soap/php_encoding.c +++ b/ext/soap/php_encoding.c @@ -29,16 +29,16 @@ #include "zend_interfaces.h" /* zval type decode */ -static zval *to_zval_double(encodeTypePtr type, xmlNodePtr data TSRMLS_DC); -static zval *to_zval_long(encodeTypePtr type, xmlNodePtr data TSRMLS_DC); -static zval *to_zval_bool(encodeTypePtr type, xmlNodePtr data TSRMLS_DC); -static zval *to_zval_string(encodeTypePtr type, xmlNodePtr data TSRMLS_DC); -static zval *to_zval_stringr(encodeTypePtr type, xmlNodePtr data TSRMLS_DC); -static zval *to_zval_stringc(encodeTypePtr type, xmlNodePtr data TSRMLS_DC); -static zval *to_zval_map(encodeTypePtr type, xmlNodePtr data TSRMLS_DC); -static zval *to_zval_null(encodeTypePtr type, xmlNodePtr data TSRMLS_DC); -static zval *to_zval_base64(encodeTypePtr type, xmlNodePtr data TSRMLS_DC); -static zval *to_zval_hexbin(encodeTypePtr type, xmlNodePtr data TSRMLS_DC); +static zval *to_zval_double(zval* ret, encodeTypePtr type, xmlNodePtr data TSRMLS_DC); +static zval *to_zval_long(zval* ret, encodeTypePtr type, xmlNodePtr data TSRMLS_DC); +static zval *to_zval_bool(zval* ret, encodeTypePtr type, xmlNodePtr data TSRMLS_DC); +static zval *to_zval_string(zval* ret, encodeTypePtr type, xmlNodePtr data TSRMLS_DC); +static zval *to_zval_stringr(zval* ret, encodeTypePtr type, xmlNodePtr data TSRMLS_DC); +static zval *to_zval_stringc(zval* ret, encodeTypePtr type, xmlNodePtr data TSRMLS_DC); +static zval *to_zval_map(zval* ret, encodeTypePtr type, xmlNodePtr data TSRMLS_DC); +static zval *to_zval_null(zval* ret, encodeTypePtr type, xmlNodePtr data TSRMLS_DC); +static zval *to_zval_base64(zval* ret, encodeTypePtr type, xmlNodePtr data TSRMLS_DC); +static zval *to_zval_hexbin(zval* ret, encodeTypePtr type, xmlNodePtr data TSRMLS_DC); static xmlNodePtr to_xml_long(encodeTypePtr type, zval *data, int style, xmlNodePtr parent TSRMLS_DC); static xmlNodePtr to_xml_double(encodeTypePtr type, zval *data, int style, xmlNodePtr parent TSRMLS_DC); @@ -71,17 +71,17 @@ static xmlNodePtr to_xml_gday(encodeTypePtr type, zval *data, int style, xmlNode static xmlNodePtr to_xml_gmonth(encodeTypePtr type, zval *data, int style, xmlNodePtr parent TSRMLS_DC); static xmlNodePtr to_xml_duration(encodeTypePtr type, zval *data, int style, xmlNodePtr parent TSRMLS_DC); -static zval *to_zval_object(encodeTypePtr type, xmlNodePtr data TSRMLS_DC); -static zval *to_zval_array(encodeTypePtr type, xmlNodePtr data TSRMLS_DC); +static zval *to_zval_object(zval *ret, encodeTypePtr type, xmlNodePtr data TSRMLS_DC); +static zval *to_zval_array(zval *ret, encodeTypePtr type, xmlNodePtr data TSRMLS_DC); static xmlNodePtr to_xml_object(encodeTypePtr type, zval *data, int style, xmlNodePtr parent TSRMLS_DC); static xmlNodePtr to_xml_array(encodeTypePtr type, zval *data, int style, xmlNodePtr parent TSRMLS_DC); -static zval *to_zval_any(encodeTypePtr type, xmlNodePtr data TSRMLS_DC); +static zval *to_zval_any(zval *ret, encodeTypePtr type, xmlNodePtr data TSRMLS_DC); static xmlNodePtr to_xml_any(encodeTypePtr type, zval *data, int style, xmlNodePtr parent TSRMLS_DC); /* Try and guess for non-wsdl clients and servers */ -static zval *guess_zval_convert(encodeTypePtr type, xmlNodePtr data TSRMLS_DC); +static zval *guess_zval_convert(zval *ret, encodeTypePtr type, xmlNodePtr data TSRMLS_DC); static xmlNodePtr guess_xml_convert(encodeTypePtr type, zval *data, int style, xmlNodePtr parent TSRMLS_DC); static int is_map(zval *array); @@ -118,16 +118,12 @@ static void set_ns_and_type(xmlNodePtr node, encodeTypePtr type); { \ xmlAttrPtr null; \ if (!xml) { \ - zval *ret; \ - ALLOC_INIT_ZVAL(ret); \ ZVAL_NULL(ret); \ return ret; \ } \ if (xml->properties) { \ null = get_attribute(xml->properties, "nil"); \ if (null) { \ - zval *ret; \ - ALLOC_INIT_ZVAL(ret); \ ZVAL_NULL(ret); \ return ret; \ } \ @@ -151,7 +147,8 @@ encode defaultEncoding[] = { {{IS_STRING, XSD_STRING_STRING, XSD_NAMESPACE, NULL}, to_zval_string, to_xml_string}, {{IS_LONG, XSD_INT_STRING, XSD_NAMESPACE, NULL}, to_zval_long, to_xml_long}, {{IS_DOUBLE, XSD_FLOAT_STRING, XSD_NAMESPACE, NULL}, to_zval_double, to_xml_double}, - {{IS_BOOL, XSD_BOOLEAN_STRING, XSD_NAMESPACE, NULL}, to_zval_bool, to_xml_bool}, + {{IS_FALSE, XSD_BOOLEAN_STRING, XSD_NAMESPACE, NULL}, to_zval_bool, to_xml_bool}, + {{IS_TRUE, XSD_BOOLEAN_STRING, XSD_NAMESPACE, NULL}, to_zval_bool, to_xml_bool}, {{IS_CONSTANT, XSD_STRING_STRING, XSD_NAMESPACE, NULL}, to_zval_string, to_xml_string}, {{IS_ARRAY, SOAP_ENC_ARRAY_STRING, SOAP_1_1_ENC_NAMESPACE, NULL}, to_zval_array, guess_array_map}, {{IS_OBJECT, SOAP_ENC_OBJECT_STRING, SOAP_1_1_ENC_NAMESPACE, NULL}, to_zval_object, to_xml_object}, @@ -275,37 +272,34 @@ void whiteSpace_collapse(xmlChar* str) static encodePtr find_encoder_by_type_name(sdlPtr sdl, const char *type) { if (sdl && sdl->encoders) { - HashPosition pos; - encodePtr *enc; + encodePtr enc; - for (zend_hash_internal_pointer_reset_ex(sdl->encoders, &pos); - zend_hash_get_current_data_ex(sdl->encoders, (void **) &enc, &pos) == SUCCESS; - zend_hash_move_forward_ex(sdl->encoders, &pos)) { - if (strcmp((*enc)->details.type_str, type) == 0) { - return *enc; + ZEND_HASH_FOREACH_PTR(sdl->encoders, enc) { + if (strcmp(enc->details.type_str, type) == 0) { + return enc; } - } + } ZEND_HASH_FOREACH_END(); } return NULL; } static zend_bool soap_check_zval_ref(zval *data, xmlNodePtr node TSRMLS_DC) { - xmlNodePtr *node_ptr; + xmlNodePtr node_ptr; if (SOAP_GLOBAL(ref_map)) { if (Z_TYPE_P(data) == IS_OBJECT) { - data = (zval*)zend_objects_get_address(data TSRMLS_CC); + data = (zval*)Z_OBJ_P(data); } - if (zend_hash_index_find(SOAP_GLOBAL(ref_map), (ulong)data, (void**)&node_ptr) == SUCCESS) { - xmlAttrPtr attr = (*node_ptr)->properties; + if ((node_ptr = zend_hash_index_find_ptr(SOAP_GLOBAL(ref_map), (ulong)data)) != NULL) { + xmlAttrPtr attr = node_ptr->properties; char *id; smart_str prefix = {0}; - if (*node_ptr == node) { + if (node_ptr == node) { return 0; } - xmlNodeSetName(node, (*node_ptr)->name); - xmlSetNs(node, (*node_ptr)->ns); + xmlNodeSetName(node, node_ptr->name); + xmlSetNs(node, node_ptr->ns); if (SOAP_GLOBAL(soap_version) == SOAP_1_1) { while (1) { attr = get_attribute(attr, "id"); @@ -319,14 +313,14 @@ static zend_bool soap_check_zval_ref(zval *data, xmlNodePtr node TSRMLS_DC) { smart_str_appendc(&prefix, '#'); smart_str_appends(&prefix, id); smart_str_0(&prefix); - id = prefix.c; + id = prefix.s->val; } else { SOAP_GLOBAL(cur_uniq_ref)++; smart_str_appendl(&prefix, "#ref", 4); smart_str_append_long(&prefix, SOAP_GLOBAL(cur_uniq_ref)); smart_str_0(&prefix); - id = prefix.c; - xmlSetProp((*node_ptr), BAD_CAST("id"), BAD_CAST(id+1)); + id = prefix.s->val; + xmlSetProp(node_ptr, BAD_CAST("id"), BAD_CAST(id+1)); } xmlSetProp(node, BAD_CAST("href"), BAD_CAST(id)); } else { @@ -336,21 +330,21 @@ static zend_bool soap_check_zval_ref(zval *data, xmlNodePtr node TSRMLS_DC) { smart_str_appendc(&prefix, '#'); smart_str_appends(&prefix, id); smart_str_0(&prefix); - id = prefix.c; + id = prefix.s->val; } else { SOAP_GLOBAL(cur_uniq_ref)++; smart_str_appendl(&prefix, "#ref", 4); smart_str_append_long(&prefix, SOAP_GLOBAL(cur_uniq_ref)); smart_str_0(&prefix); - id = prefix.c; - set_ns_prop((*node_ptr), SOAP_1_2_ENC_NAMESPACE, "id", id+1); + id = prefix.s->val; + set_ns_prop(node_ptr, SOAP_1_2_ENC_NAMESPACE, "id", id+1); } set_ns_prop(node, SOAP_1_2_ENC_NAMESPACE, "ref", id); } smart_str_free(&prefix); return 1; } else { - zend_hash_index_update(SOAP_GLOBAL(ref_map), (ulong)data, (void**)&node, sizeof(xmlNodePtr), NULL); + zend_hash_index_update_ptr(SOAP_GLOBAL(ref_map), (ulong)data, node); } } return 0; @@ -358,32 +352,34 @@ static zend_bool soap_check_zval_ref(zval *data, xmlNodePtr node TSRMLS_DC) { static zval* soap_find_xml_ref(xmlNodePtr node TSRMLS_DC) { - zval **data_ptr; + zval *data_ptr; if (SOAP_GLOBAL(ref_map) && - zend_hash_index_find(SOAP_GLOBAL(ref_map), (ulong)node, (void**)&data_ptr) == SUCCESS) { - Z_SET_ISREF_PP(data_ptr); - Z_ADDREF_PP(data_ptr); - return *data_ptr; + (data_ptr = zend_hash_index_find(SOAP_GLOBAL(ref_map), (ulong)node)) != NULL) { +//??? Z_SET_ISREF_PP(data_ptr); + SEPARATE_ZVAL_TO_MAKE_IS_REF(data_ptr); + Z_ADDREF_P(data_ptr); + return data_ptr; } return NULL; } -static zend_bool soap_check_xml_ref(zval **data, xmlNodePtr node TSRMLS_DC) +static zend_bool soap_check_xml_ref(zval *data, xmlNodePtr node TSRMLS_DC) { - zval **data_ptr; + zval *data_ptr; if (SOAP_GLOBAL(ref_map)) { - if (zend_hash_index_find(SOAP_GLOBAL(ref_map), (ulong)node, (void**)&data_ptr) == SUCCESS) { - if (*data != *data_ptr) { + if ((data_ptr = zend_hash_index_find(SOAP_GLOBAL(ref_map), (ulong)node)) != NULL) { + if (data != data_ptr) { zval_ptr_dtor(data); - *data = *data_ptr; - Z_SET_ISREF_PP(data); - Z_ADDREF_PP(data); + ZVAL_COPY_VALUE(data, data_ptr); +//??? Z_SET_ISREF_PP(data); + SEPARATE_ZVAL_TO_MAKE_IS_REF(data); + Z_ADDREF_P(data); return 1; } } else { - zend_hash_index_update(SOAP_GLOBAL(ref_map), (ulong)node, (void**)data, sizeof(zval*), NULL); + zend_hash_index_update(SOAP_GLOBAL(ref_map), (ulong)node, data); } } return 0; @@ -398,92 +394,81 @@ static xmlNodePtr master_to_xml_int(encodePtr encode, zval *data, int style, xml if (data && Z_TYPE_P(data) == IS_OBJECT && Z_OBJCE_P(data) == soap_var_class_entry) { - zval **ztype, **zdata, **zns, **zstype, **zname, **znamens; + zval *ztype, *zdata, *zns, *zstype, *zname, *znamens; encodePtr enc = NULL; HashTable *ht = Z_OBJPROP_P(data); - if (zend_hash_find(ht, "enc_type", sizeof("enc_type"), (void **)&ztype) == FAILURE) { + if ((ztype = zend_hash_str_find(ht, "enc_type", sizeof("enc_type")-1)) == NULL) { soap_error0(E_ERROR, "Encoding: SoapVar has no 'enc_type' property"); } - if (zend_hash_find(ht, "enc_stype", sizeof("enc_stype"), (void **)&zstype) == SUCCESS) { - if (zend_hash_find(ht, "enc_ns", sizeof("enc_ns"), (void **)&zns) == SUCCESS) { - enc = get_encoder(SOAP_GLOBAL(sdl), Z_STRVAL_PP(zns), Z_STRVAL_PP(zstype)); + if ((zstype = zend_hash_str_find(ht, "enc_stype", sizeof("enc_stype")-1)) != NULL) { + if ((zns = zend_hash_str_find(ht, "enc_ns", sizeof("enc_ns")-1)) != NULL) { + enc = get_encoder(SOAP_GLOBAL(sdl), Z_STRVAL_P(zns), Z_STRVAL_P(zstype)); } else { zns = NULL; - enc = get_encoder_ex(SOAP_GLOBAL(sdl), Z_STRVAL_PP(zstype), Z_STRLEN_PP(zstype)); + enc = get_encoder_ex(SOAP_GLOBAL(sdl), Z_STRVAL_P(zstype), Z_STRLEN_P(zstype)); } if (enc == NULL && SOAP_GLOBAL(typemap)) { - encodePtr *new_enc; smart_str nscat = {0}; if (zns != NULL) { - smart_str_appendl(&nscat, Z_STRVAL_PP(zns), Z_STRLEN_PP(zns)); + smart_str_appendl(&nscat, Z_STRVAL_P(zns), Z_STRLEN_P(zns)); smart_str_appendc(&nscat, ':'); } - smart_str_appendl(&nscat, Z_STRVAL_PP(zstype), Z_STRLEN_PP(zstype)); + smart_str_appendl(&nscat, Z_STRVAL_P(zstype), Z_STRLEN_P(zstype)); smart_str_0(&nscat); - if (zend_hash_find(SOAP_GLOBAL(typemap), nscat.c, nscat.len + 1, (void**)&new_enc) == SUCCESS) { - enc = *new_enc; - } + enc = zend_hash_find_ptr(SOAP_GLOBAL(typemap), nscat.s); smart_str_free(&nscat); } } if (enc == NULL) { - enc = get_conversion(Z_LVAL_P(*ztype)); + enc = get_conversion(Z_LVAL_P(ztype)); } if (enc == NULL) { enc = encode; } - if (zend_hash_find(ht, "enc_value", sizeof("enc_value"), (void **)&zdata) == FAILURE) { - node = master_to_xml(enc, NULL, style, parent TSRMLS_CC); - } else { - node = master_to_xml(enc, *zdata, style, parent TSRMLS_CC); - } + zdata = zend_hash_str_find(ht, "enc_value", sizeof("enc_value")-1); + node = master_to_xml(enc, zdata, style, parent TSRMLS_CC); if (style == SOAP_ENCODED || (SOAP_GLOBAL(sdl) && encode != enc)) { - if (zend_hash_find(ht, "enc_stype", sizeof("enc_stype"), (void **)&zstype) == SUCCESS) { - if (zend_hash_find(ht, "enc_ns", sizeof("enc_ns"), (void **)&zns) == SUCCESS) { - set_ns_and_type_ex(node, Z_STRVAL_PP(zns), Z_STRVAL_PP(zstype)); + if ((ztype = zend_hash_str_find(ht, "enc_stype", sizeof("enc_stype")-1)) != NULL) { + if ((zns = zend_hash_str_find(ht, "enc_ns", sizeof("enc_ns")-1)) != NULL) { + set_ns_and_type_ex(node, Z_STRVAL_P(zns), Z_STRVAL_P(zstype)); } else { - set_ns_and_type_ex(node, NULL, Z_STRVAL_PP(zstype)); + set_ns_and_type_ex(node, NULL, Z_STRVAL_P(zstype)); } } } - if (zend_hash_find(ht, "enc_name", sizeof("enc_name"), (void **)&zname) == SUCCESS) { - xmlNodeSetName(node, BAD_CAST(Z_STRVAL_PP(zname))); + if ((zname = zend_hash_str_find(ht, "enc_name", sizeof("enc_name")-1)) != NULL) { + xmlNodeSetName(node, BAD_CAST(Z_STRVAL_P(zname))); } - if (zend_hash_find(ht, "enc_namens", sizeof("enc_namens"), (void **)&znamens) == SUCCESS) { - xmlNsPtr nsp = encode_add_ns(node, Z_STRVAL_PP(znamens)); + if ((znamens = zend_hash_str_find(ht, "enc_namens", sizeof("enc_namens")-1)) != NULL) { + xmlNsPtr nsp = encode_add_ns(node, Z_STRVAL_P(znamens)); xmlSetNs(node, nsp); } } else { if (check_class_map && SOAP_GLOBAL(class_map) && data && Z_TYPE_P(data) == IS_OBJECT && - !Z_OBJPROP_P(data)->nApplyCount) { + !ZEND_HASH_GET_APPLY_COUNT(Z_OBJPROP_P(data))) { zend_class_entry *ce = Z_OBJCE_P(data); - HashPosition pos; - zval **tmp; - char *type_name = NULL; - uint type_len; - ulong idx; - - for (zend_hash_internal_pointer_reset_ex(SOAP_GLOBAL(class_map), &pos); - zend_hash_get_current_data_ex(SOAP_GLOBAL(class_map), (void **) &tmp, &pos) == SUCCESS; - zend_hash_move_forward_ex(SOAP_GLOBAL(class_map), &pos)) { - if (Z_TYPE_PP(tmp) == IS_STRING && - ce->name_length == Z_STRLEN_PP(tmp) && - zend_binary_strncasecmp(ce->name, ce->name_length, Z_STRVAL_PP(tmp), ce->name_length, ce->name_length) == 0 && - zend_hash_get_current_key_ex(SOAP_GLOBAL(class_map), &type_name, &type_len, &idx, 0, &pos) == HASH_KEY_IS_STRING) { + zval *tmp; + zend_string *type_name; + + ZEND_HASH_FOREACH_STR_KEY_VAL(SOAP_GLOBAL(class_map), type_name, tmp) { + if (Z_TYPE_P(tmp) == IS_STRING && + ce->name->len == Z_STRLEN_P(tmp) && + zend_binary_strncasecmp(ce->name->val, ce->name->len, Z_STRVAL_P(tmp), ce->name->len, ce->name->len) == 0 && + type_name) { /* TODO: namespace isn't stored */ encodePtr enc = NULL; if (SOAP_GLOBAL(sdl)) { - enc = get_encoder(SOAP_GLOBAL(sdl), SOAP_GLOBAL(sdl)->target_ns, type_name); + enc = get_encoder(SOAP_GLOBAL(sdl), SOAP_GLOBAL(sdl)->target_ns, type_name->val); if (!enc) { - enc = find_encoder_by_type_name(SOAP_GLOBAL(sdl), type_name); + enc = find_encoder_by_type_name(SOAP_GLOBAL(sdl), type_name->val); } } if (enc) { @@ -494,7 +479,7 @@ static xmlNodePtr master_to_xml_int(encodePtr encode, zval *data, int style, xml } break; } - } + } ZEND_HASH_FOREACH_END(); } if (encode == NULL) { @@ -502,7 +487,7 @@ static xmlNodePtr master_to_xml_int(encodePtr encode, zval *data, int style, xml } if (SOAP_GLOBAL(typemap) && encode->details.type_str) { smart_str nscat = {0}; - encodePtr *new_enc; + encodePtr new_enc; if (encode->details.ns) { smart_str_appends(&nscat, encode->details.ns); @@ -510,8 +495,8 @@ static xmlNodePtr master_to_xml_int(encodePtr encode, zval *data, int style, xml } smart_str_appends(&nscat, encode->details.type_str); smart_str_0(&nscat); - if (zend_hash_find(SOAP_GLOBAL(typemap), nscat.c, nscat.len + 1, (void**)&new_enc) == SUCCESS) { - encode = *new_enc; + if ((new_enc = zend_hash_find_ptr(SOAP_GLOBAL(typemap), nscat.s)) != NULL) { + encode = new_enc; } smart_str_free(&nscat); } @@ -530,14 +515,12 @@ xmlNodePtr master_to_xml(encodePtr encode, zval *data, int style, xmlNodePtr par return master_to_xml_int(encode, data, style, parent, 1 TSRMLS_CC); } -static zval *master_to_zval_int(encodePtr encode, xmlNodePtr data TSRMLS_DC) +static zval *master_to_zval_int(zval *ret, encodePtr encode, xmlNodePtr data TSRMLS_DC) { - zval *ret = NULL; - if (SOAP_GLOBAL(typemap)) { if (encode->details.type_str) { smart_str nscat = {0}; - encodePtr *new_enc; + encodePtr new_enc; if (encode->details.ns) { smart_str_appends(&nscat, encode->details.ns); @@ -545,15 +528,15 @@ static zval *master_to_zval_int(encodePtr encode, xmlNodePtr data TSRMLS_DC) } smart_str_appends(&nscat, encode->details.type_str); smart_str_0(&nscat); - if (zend_hash_find(SOAP_GLOBAL(typemap), nscat.c, nscat.len + 1, (void**)&new_enc) == SUCCESS) { - encode = *new_enc; + if ((new_enc = zend_hash_find_ptr(SOAP_GLOBAL(typemap), nscat.s)) != NULL) { + encode = new_enc; } smart_str_free(&nscat); } else { xmlAttrPtr type_attr = get_attribute_ex(data->properties,"type", XSI_NAMESPACE); if (type_attr != NULL) { - encodePtr *new_enc; + encodePtr new_enc; xmlNsPtr nsptr; char *ns, *cptype; smart_str nscat = {0}; @@ -568,20 +551,20 @@ static zval *master_to_zval_int(encodePtr encode, xmlNodePtr data TSRMLS_DC) smart_str_0(&nscat); efree(cptype); if (ns) {efree(ns);} - if (zend_hash_find(SOAP_GLOBAL(typemap), nscat.c, nscat.len + 1, (void**)&new_enc) == SUCCESS) { - encode = *new_enc; + if ((new_enc = zend_hash_find_ptr(SOAP_GLOBAL(typemap), nscat.s)) != NULL) { + encode = new_enc; } smart_str_free(&nscat); } } } if (encode->to_zval) { - ret = encode->to_zval(&encode->details, data TSRMLS_CC); + ret = encode->to_zval(ret, &encode->details, data TSRMLS_CC); } return ret; } -zval *master_to_zval(encodePtr encode, xmlNodePtr data TSRMLS_DC) +zval *master_to_zval(zval *ret, encodePtr encode, xmlNodePtr data TSRMLS_DC) { data = check_and_resolve_href(data); @@ -612,22 +595,22 @@ zval *master_to_zval(encodePtr encode, xmlNodePtr data TSRMLS_DC) } } } - return master_to_zval_int(encode, data TSRMLS_CC); + return master_to_zval_int(ret, encode, data TSRMLS_CC); } xmlNodePtr to_xml_user(encodeTypePtr type, zval *data, int style, xmlNodePtr parent TSRMLS_DC) { xmlNodePtr ret = NULL; - zval *return_value; + zval return_value; - if (type && type->map && type->map->to_xml) { - MAKE_STD_ZVAL(return_value); + if (type && type->map && Z_TYPE(type->map->to_xml) != IS_UNDEF) { + ZVAL_NULL(&return_value); - if (call_user_function(EG(function_table), NULL, type->map->to_xml, return_value, 1, &data TSRMLS_CC) == FAILURE) { + if (call_user_function(EG(function_table), NULL, &type->map->to_xml, &return_value, 1, data TSRMLS_CC) == FAILURE) { soap_error0(E_ERROR, "Encoding: Error calling to_xml callback"); } - if (Z_TYPE_P(return_value) == IS_STRING) { - xmlDocPtr doc = soap_xmlParseMemory(Z_STRVAL_P(return_value), Z_STRLEN_P(return_value)); + if (Z_TYPE(return_value) == IS_STRING) { + xmlDocPtr doc = soap_xmlParseMemory(Z_STRVAL(return_value), Z_STRLEN(return_value)); if (doc && doc->children) { ret = xmlDocCopyNode(doc->children, parent->doc, 1); } @@ -646,41 +629,37 @@ xmlNodePtr to_xml_user(encodeTypePtr type, zval *data, int style, xmlNodePtr par return ret; } -zval *to_zval_user(encodeTypePtr type, xmlNodePtr node TSRMLS_DC) +zval *to_zval_user(zval *ret, encodeTypePtr type, xmlNodePtr node TSRMLS_DC) { - zval *return_value; - - if (type && type->map && type->map->to_zval) { + if (type && type->map && Z_TYPE(type->map->to_zval) != IS_UNDEF) { xmlBufferPtr buf; - zval *data; + zval data; xmlNodePtr copy; copy = xmlCopyNode(node, 1); buf = xmlBufferCreate(); xmlNodeDump(buf, NULL, copy, 0, 0); - MAKE_STD_ZVAL(data); - ZVAL_STRING(data, (char*)xmlBufferContent(buf), 1); + ZVAL_STRING(&data, (char*)xmlBufferContent(buf)); xmlBufferFree(buf); xmlFreeNode(copy); - ALLOC_INIT_ZVAL(return_value); + ZVAL_NULL(ret); - if (call_user_function(EG(function_table), NULL, type->map->to_zval, return_value, 1, &data TSRMLS_CC) == FAILURE) { + if (call_user_function(EG(function_table), NULL, &type->map->to_zval, ret, 1, &data TSRMLS_CC) == FAILURE) { soap_error0(E_ERROR, "Encoding: Error calling from_xml callback"); } zval_ptr_dtor(&data); } else { - ALLOC_INIT_ZVAL(return_value); + ZVAL_NULL(ret); } - return return_value; + return ret; } /* TODO: get rid of "bogus".. ither by passing in the already created xmlnode or passing in the node name */ /* String encode/decode */ -static zval *to_zval_string(encodeTypePtr type, xmlNodePtr data TSRMLS_DC) +static zval *to_zval_string(zval *ret, encodeTypePtr type, xmlNodePtr data TSRMLS_DC) { - zval *ret; - MAKE_STD_ZVAL(ret); + ZVAL_NULL(ret); FIND_XML_NULL(data, ret); if (data && data->children) { if (data->children->type == XML_TEXT_NODE && data->children->next == NULL) { @@ -690,17 +669,17 @@ static zval *to_zval_string(encodeTypePtr type, xmlNodePtr data TSRMLS_DC) int n = xmlCharEncOutFunc(SOAP_GLOBAL(encoding), out, in); if (n >= 0) { - ZVAL_STRING(ret, (char*)xmlBufferContent(out), 1); + ZVAL_STRING(ret, (char*)xmlBufferContent(out)); } else { - ZVAL_STRING(ret, (char*)data->children->content, 1); + ZVAL_STRING(ret, (char*)data->children->content); } xmlBufferFree(out); xmlBufferFree(in); } else { - ZVAL_STRING(ret, (char*)data->children->content, 1); + ZVAL_STRING(ret, (char*)data->children->content); } } else if (data->children->type == XML_CDATA_SECTION_NODE && data->children->next == NULL) { - ZVAL_STRING(ret, (char*)data->children->content, 1); + ZVAL_STRING(ret, (char*)data->children->content); } else { soap_error0(E_ERROR, "Encoding: Violation of encoding rules"); } @@ -710,10 +689,9 @@ static zval *to_zval_string(encodeTypePtr type, xmlNodePtr data TSRMLS_DC) return ret; } -static zval *to_zval_stringr(encodeTypePtr type, xmlNodePtr data TSRMLS_DC) +static zval *to_zval_stringr(zval *ret, encodeTypePtr type, xmlNodePtr data TSRMLS_DC) { - zval *ret; - MAKE_STD_ZVAL(ret); + ZVAL_NULL(ret); FIND_XML_NULL(data, ret); if (data && data->children) { if (data->children->type == XML_TEXT_NODE && data->children->next == NULL) { @@ -724,17 +702,17 @@ static zval *to_zval_stringr(encodeTypePtr type, xmlNodePtr data TSRMLS_DC) int n = xmlCharEncOutFunc(SOAP_GLOBAL(encoding), out, in); if (n >= 0) { - ZVAL_STRING(ret, (char*)xmlBufferContent(out), 1); + ZVAL_STRING(ret, (char*)xmlBufferContent(out)); } else { - ZVAL_STRING(ret, (char*)data->children->content, 1); + ZVAL_STRING(ret, (char*)data->children->content); } xmlBufferFree(out); xmlBufferFree(in); } else { - ZVAL_STRING(ret, (char*)data->children->content, 1); + ZVAL_STRING(ret, (char*)data->children->content); } } else if (data->children->type == XML_CDATA_SECTION_NODE && data->children->next == NULL) { - ZVAL_STRING(ret, (char*)data->children->content, 1); + ZVAL_STRING(ret, (char*)data->children->content); } else { soap_error0(E_ERROR, "Encoding: Violation of encoding rules"); } @@ -744,10 +722,9 @@ static zval *to_zval_stringr(encodeTypePtr type, xmlNodePtr data TSRMLS_DC) return ret; } -static zval *to_zval_stringc(encodeTypePtr type, xmlNodePtr data TSRMLS_DC) +static zval *to_zval_stringc(zval *ret, encodeTypePtr type, xmlNodePtr data TSRMLS_DC) { - zval *ret; - MAKE_STD_ZVAL(ret); + ZVAL_NULL(ret); FIND_XML_NULL(data, ret); if (data && data->children) { if (data->children->type == XML_TEXT_NODE && data->children->next == NULL) { @@ -758,17 +735,17 @@ static zval *to_zval_stringc(encodeTypePtr type, xmlNodePtr data TSRMLS_DC) int n = xmlCharEncOutFunc(SOAP_GLOBAL(encoding), out, in); if (n >= 0) { - ZVAL_STRING(ret, (char*)xmlBufferContent(out), 1); + ZVAL_STRING(ret, (char*)xmlBufferContent(out)); } else { - ZVAL_STRING(ret, (char*)data->children->content, 1); + ZVAL_STRING(ret, (char*)data->children->content); } xmlBufferFree(out); xmlBufferFree(in); } else { - ZVAL_STRING(ret, (char*)data->children->content, 1); + ZVAL_STRING(ret, (char*)data->children->content); } } else if (data->children->type == XML_CDATA_SECTION_NODE && data->children->next == NULL) { - ZVAL_STRING(ret, (char*)data->children->content, 1); + ZVAL_STRING(ret, (char*)data->children->content); } else { soap_error0(E_ERROR, "Encoding: Violation of encoding rules"); } @@ -778,28 +755,26 @@ static zval *to_zval_stringc(encodeTypePtr type, xmlNodePtr data TSRMLS_DC) return ret; } -static zval *to_zval_base64(encodeTypePtr type, xmlNodePtr data TSRMLS_DC) +static zval *to_zval_base64(zval *ret, encodeTypePtr type, xmlNodePtr data TSRMLS_DC) { - zval *ret; - char *str; - int str_len; + zend_string *str; - MAKE_STD_ZVAL(ret); + ZVAL_NULL(ret); FIND_XML_NULL(data, ret); if (data && data->children) { if (data->children->type == XML_TEXT_NODE && data->children->next == NULL) { whiteSpace_collapse(data->children->content); - str = (char*)php_base64_decode(data->children->content, strlen((char*)data->children->content), &str_len); + str = php_base64_decode(data->children->content, strlen((char*)data->children->content)); if (!str) { soap_error0(E_ERROR, "Encoding: Violation of encoding rules"); } - ZVAL_STRINGL(ret, str, str_len, 0); + ZVAL_STR(ret, str); } else if (data->children->type == XML_CDATA_SECTION_NODE && data->children->next == NULL) { - str = (char*)php_base64_decode(data->children->content, strlen((char*)data->children->content), &str_len); + str = php_base64_decode(data->children->content, strlen((char*)data->children->content)); if (!str) { soap_error0(E_ERROR, "Encoding: Violation of encoding rules"); } - ZVAL_STRINGL(ret, str, str_len, 0); + ZVAL_STR(ret, str); } else { soap_error0(E_ERROR, "Encoding: Violation of encoding rules"); } @@ -809,14 +784,13 @@ static zval *to_zval_base64(encodeTypePtr type, xmlNodePtr data TSRMLS_DC) return ret; } -static zval *to_zval_hexbin(encodeTypePtr type, xmlNodePtr data TSRMLS_DC) +static zval *to_zval_hexbin(zval *ret, encodeTypePtr type, xmlNodePtr data TSRMLS_DC) { - zval *ret; - unsigned char *str; - int str_len, i, j; + zend_string *str; + int i, j; unsigned char c; - MAKE_STD_ZVAL(ret); + ZVAL_NULL(ret); FIND_XML_NULL(data, ret); if (data && data->children) { if (data->children->type == XML_TEXT_NODE && data->children->next == NULL) { @@ -825,32 +799,31 @@ static zval *to_zval_hexbin(encodeTypePtr type, xmlNodePtr data TSRMLS_DC) soap_error0(E_ERROR, "Encoding: Violation of encoding rules"); return ret; } - str_len = strlen((char*)data->children->content) / 2; - str = emalloc(str_len+1); - for (i = j = 0; i < str_len; i++) { + str = STR_ALLOC(strlen((char*)data->children->content) / 2, 0); + for (i = j = 0; i < str->len; i++) { c = data->children->content[j++]; if (c >= '0' && c <= '9') { - str[i] = (c - '0') << 4; + str->val[i] = (c - '0') << 4; } else if (c >= 'a' && c <= 'f') { - str[i] = (c - 'a' + 10) << 4; + str->val[i] = (c - 'a' + 10) << 4; } else if (c >= 'A' && c <= 'F') { - str[i] = (c - 'A' + 10) << 4; + str->val[i] = (c - 'A' + 10) << 4; } else { soap_error0(E_ERROR, "Encoding: Violation of encoding rules"); } c = data->children->content[j++]; if (c >= '0' && c <= '9') { - str[i] |= c - '0'; + str->val[i] |= c - '0'; } else if (c >= 'a' && c <= 'f') { - str[i] |= c - 'a' + 10; + str->val[i] |= c - 'a' + 10; } else if (c >= 'A' && c <= 'F') { - str[i] |= c - 'A' + 10; + str->val[i] |= c - 'A' + 10; } else { soap_error0(E_ERROR, "Encoding: Violation of encoding rules"); } } - str[str_len] = '\0'; - ZVAL_STRINGL(ret, (char*)str, str_len, 0); + str->val[str->len] = '\0'; + ZVAL_STR(ret, str); } else { ZVAL_EMPTY_STRING(ret); } @@ -948,27 +921,26 @@ static xmlNodePtr to_xml_string(encodeTypePtr type, zval *data, int style, xmlNo static xmlNodePtr to_xml_base64(encodeTypePtr type, zval *data, int style, xmlNodePtr parent TSRMLS_DC) { xmlNodePtr ret, text; - unsigned char *str; - int str_len; + zend_string *str; ret = xmlNewNode(NULL, BAD_CAST("BOGUS")); xmlAddChild(parent, ret); FIND_ZVAL_NULL(data, ret, style); if (Z_TYPE_P(data) == IS_STRING) { - str = php_base64_encode((unsigned char*)Z_STRVAL_P(data), Z_STRLEN_P(data), &str_len); - text = xmlNewTextLen(str, str_len); + str = php_base64_encode((unsigned char*)Z_STRVAL_P(data), Z_STRLEN_P(data)); + text = xmlNewTextLen(BAD_CAST(str->val), str->len); xmlAddChild(ret, text); - efree(str); + STR_RELEASE(str); } else { - zval tmp = *data; - - zval_copy_ctor(&tmp); + zval tmp; + + ZVAL_DUP(&tmp, data); convert_to_string(&tmp); - str = php_base64_encode((unsigned char*)Z_STRVAL(tmp), Z_STRLEN(tmp), &str_len); - text = xmlNewTextLen(str, str_len); + str = php_base64_encode((unsigned char*)Z_STRVAL(tmp), Z_STRLEN(tmp)); + text = xmlNewTextLen(BAD_CAST(str->val), str->len); xmlAddChild(ret, text); - efree(str); + STR_RELEASE(str); zval_dtor(&tmp); } @@ -1017,10 +989,9 @@ static xmlNodePtr to_xml_hexbin(encodeTypePtr type, zval *data, int style, xmlNo return ret; } -static zval *to_zval_double(encodeTypePtr type, xmlNodePtr data TSRMLS_DC) +static zval *to_zval_double(zval *ret, encodeTypePtr type, xmlNodePtr data TSRMLS_DC) { - zval *ret; - MAKE_STD_ZVAL(ret); + ZVAL_NULL(ret); FIND_XML_NULL(data, ret); if (data && data->children) { @@ -1031,12 +1002,10 @@ static zval *to_zval_double(encodeTypePtr type, xmlNodePtr data TSRMLS_DC) whiteSpace_collapse(data->children->content); switch (is_numeric_string((char*)data->children->content, strlen((char*)data->children->content), &lval, &dval, 0)) { case IS_LONG: - Z_TYPE_P(ret) = IS_DOUBLE; - Z_DVAL_P(ret) = lval; + ZVAL_DOUBLE(ret, lval); break; case IS_DOUBLE: - Z_TYPE_P(ret) = IS_DOUBLE; - Z_DVAL_P(ret) = dval; + ZVAL_DOUBLE(ret, dval); break; default: if (strncasecmp((char*)data->children->content, "NaN", sizeof("NaN")-1) == 0) { @@ -1058,10 +1027,9 @@ static zval *to_zval_double(encodeTypePtr type, xmlNodePtr data TSRMLS_DC) return ret; } -static zval *to_zval_long(encodeTypePtr type, xmlNodePtr data TSRMLS_DC) +static zval *to_zval_long(zval *ret, encodeTypePtr type, xmlNodePtr data TSRMLS_DC) { - zval *ret; - MAKE_STD_ZVAL(ret); + ZVAL_NULL(ret); FIND_XML_NULL(data, ret); if (data && data->children) { @@ -1072,12 +1040,12 @@ static zval *to_zval_long(encodeTypePtr type, xmlNodePtr data TSRMLS_DC) whiteSpace_collapse(data->children->content); errno = 0; - switch ((Z_TYPE_P(ret) = is_numeric_string((char*)data->children->content, strlen((char*)data->children->content), &lval, &dval, 0))) { + switch (is_numeric_string((char*)data->children->content, strlen((char*)data->children->content), &lval, &dval, 0)) { case IS_LONG: - Z_LVAL_P(ret) = lval; + ZVAL_LONG(ret, lval); break; case IS_DOUBLE: - Z_DVAL_P(ret) = dval; + ZVAL_DOUBLE(ret, dval); break; default: soap_error0(E_ERROR, "Encoding: Violation of encoding rules"); @@ -1149,10 +1117,9 @@ static xmlNodePtr to_xml_double(encodeTypePtr type, zval *data, int style, xmlNo return ret; } -static zval *to_zval_bool(encodeTypePtr type, xmlNodePtr data TSRMLS_DC) +static zval *to_zval_bool(zval *ret, encodeTypePtr type, xmlNodePtr data TSRMLS_DC) { - zval *ret; - MAKE_STD_ZVAL(ret); + ZVAL_NULL(ret); FIND_XML_NULL(data, ret); if (data && data->children) { @@ -1161,13 +1128,13 @@ static zval *to_zval_bool(encodeTypePtr type, xmlNodePtr data TSRMLS_DC) if (stricmp((char*)data->children->content, "true") == 0 || stricmp((char*)data->children->content, "t") == 0 || strcmp((char*)data->children->content, "1") == 0) { - ZVAL_BOOL(ret, 1); + ZVAL_TRUE(ret); } else if (stricmp((char*)data->children->content, "false") == 0 || stricmp((char*)data->children->content, "f") == 0 || strcmp((char*)data->children->content, "0") == 0) { - ZVAL_BOOL(ret, 0); + ZVAL_FALSE(ret); } else { - ZVAL_STRING(ret, (char*)data->children->content, 1); + ZVAL_STRING(ret, (char*)data->children->content); convert_to_boolean(ret); } } else { @@ -1200,10 +1167,8 @@ static xmlNodePtr to_xml_bool(encodeTypePtr type, zval *data, int style, xmlNode } /* Null encode/decode */ -static zval *to_zval_null(encodeTypePtr type, xmlNodePtr data TSRMLS_DC) +static zval *to_zval_null(zval *ret, encodeTypePtr type, xmlNodePtr data TSRMLS_DC) { - zval *ret; - MAKE_STD_ZVAL(ret); ZVAL_NULL(ret); return ret; } @@ -1231,25 +1196,26 @@ static void set_zval_property(zval* object, char* name, zval* val TSRMLS_DC) EG(scope) = old_scope; } -static zval* get_zval_property(zval* object, char* name TSRMLS_DC) +static zval* get_zval_property(zval* object, char* name, zval *rv TSRMLS_DC) { if (Z_TYPE_P(object) == IS_OBJECT) { - zval member; + zval member, rv; zval *data; zend_class_entry *old_scope; - INIT_PZVAL(&member); - ZVAL_STRING(&member, name, 0); +//??? INIT_PZVAL(&member); +//??? ZVAL_STRING(&member, name, 0); + ZVAL_STRING(&member, name); old_scope = EG(scope); EG(scope) = Z_OBJCE_P(object); - data = Z_OBJ_HT_P(object)->read_property(object, &member, BP_VAR_IS, 0 TSRMLS_CC); - if (data == EG(uninitialized_zval_ptr)) { + data = Z_OBJ_HT_P(object)->read_property(object, &member, BP_VAR_IS, 0, &rv TSRMLS_CC); + if (data == &EG(uninitialized_zval)) { /* Hack for bug #32455 */ zend_property_info *property_info; property_info = zend_get_property_info(Z_OBJCE_P(object), &member, 1 TSRMLS_CC); EG(scope) = old_scope; - if (property_info && zend_hash_quick_exists(Z_OBJPROP_P(object), property_info->name, property_info->name_length+1, property_info->h)) { + if (property_info && zend_hash_exists(Z_OBJPROP_P(object), property_info->name)) { return data; } return NULL; @@ -1257,13 +1223,13 @@ static zval* get_zval_property(zval* object, char* name TSRMLS_DC) EG(scope) = old_scope; return data; } else if (Z_TYPE_P(object) == IS_ARRAY) { - zval **data_ptr; + zval *data_ptr; - if (zend_hash_find(Z_ARRVAL_P(object), name, strlen(name)+1, (void**)&data_ptr) == SUCCESS) { - return *data_ptr; + if ((data_ptr = zend_hash_str_find(Z_ARRVAL_P(object), name, strlen(name))) != NULL) { + return data_ptr; } } - return NULL; + return NULL; } static void unset_zval_property(zval* object, char* name TSRMLS_DC) @@ -1272,48 +1238,49 @@ static void unset_zval_property(zval* object, char* name TSRMLS_DC) zval member; zend_class_entry *old_scope; - INIT_PZVAL(&member); - ZVAL_STRING(&member, name, 0); +//??? INIT_PZVAL(&member); +//??? ZVAL_STRING(&member, name, 0); + ZVAL_STRING(&member, name); old_scope = EG(scope); EG(scope) = Z_OBJCE_P(object); Z_OBJ_HT_P(object)->unset_property(object, &member, 0 TSRMLS_CC); EG(scope) = old_scope; } else if (Z_TYPE_P(object) == IS_ARRAY) { - zend_hash_del(Z_ARRVAL_P(object), name, strlen(name)+1); + zend_hash_str_del(Z_ARRVAL_P(object), name, strlen(name)); } } static void model_to_zval_any(zval *ret, xmlNodePtr node TSRMLS_DC) { + zval rv, arr; zval* any = NULL; char* name = NULL; while (node != NULL) { - if (get_zval_property(ret, (char*)node->name TSRMLS_CC) == NULL) { - zval* val = master_to_zval(get_conversion(XSD_ANYXML), node TSRMLS_CC); + if (get_zval_property(ret, (char*)node->name, &rv TSRMLS_CC) == NULL) { + zval* val = master_to_zval(ret, get_conversion(XSD_ANYXML), node TSRMLS_CC); if (any && Z_TYPE_P(any) != IS_ARRAY) { /* Convert into array */ - zval *arr; - - MAKE_STD_ZVAL(arr); - array_init(arr); + array_init(&arr); if (name) { - add_assoc_zval(arr, name, any); + add_assoc_zval(&arr, name, any); } else { - add_next_index_zval(arr, any); + add_next_index_zval(&arr, any); } - any = arr; + any = &arr; } if (Z_TYPE_P(val) == IS_STRING && *Z_STRVAL_P(val) == '<') { name = NULL; while (node->next != NULL) { - zval* val2 = master_to_zval(get_conversion(XSD_ANYXML), node->next TSRMLS_CC); - if (Z_TYPE_P(val2) != IS_STRING || *Z_STRVAL_P(val) != '<') { + zval val2; + + master_to_zval(&val2, get_conversion(XSD_ANYXML), node->next TSRMLS_CC); + if (Z_TYPE(val2) != IS_STRING || *Z_STRVAL_P(val) != '<') { break; } - add_string_to_string(val, val, val2); + add_string_to_string(val, val, &val2); zval_ptr_dtor(&val2); node = node->next; } @@ -1324,12 +1291,9 @@ static void model_to_zval_any(zval *ret, xmlNodePtr node TSRMLS_DC) if (any == NULL) { if (name) { /* Convert into array */ - zval *arr; - - MAKE_STD_ZVAL(arr); - array_init(arr); - add_assoc_zval(arr, name, val); - any = arr; + array_init(&arr); + add_assoc_zval(&arr, name, val); + any = &arr; name = NULL; } else { any = val; @@ -1337,18 +1301,15 @@ static void model_to_zval_any(zval *ret, xmlNodePtr node TSRMLS_DC) } else { /* Add array element */ if (name) { - zval **el; - if (zend_hash_find(Z_ARRVAL_P(any), name, strlen(name)+1, (void**)&el) == SUCCESS) { - if (Z_TYPE_PP(el) != IS_ARRAY) { + zval *el; + if ((el = zend_hash_str_find(Z_ARRVAL_P(any), name, strlen(name))) != NULL) { + if (Z_TYPE_P(el) != IS_ARRAY) { /* Convert into array */ - zval *arr; - - MAKE_STD_ZVAL(arr); - array_init(arr); - add_next_index_zval(arr, *el); - *el = arr; + array_init(&arr); + add_next_index_zval(&arr, el); + el = &arr; } - add_next_index_zval(*el, val); + add_next_index_zval(el, val); } else { add_assoc_zval(any, name, val); } @@ -1373,7 +1334,7 @@ static void model_to_zval_object(zval *ret, sdlContentModelPtr model, xmlNodePtr xmlNodePtr node = get_node(data->children, model->u.element->name); if (node) { - zval *val; + zval val; xmlNodePtr r_node; r_node = check_and_resolve_href(node); @@ -1381,78 +1342,73 @@ static void model_to_zval_object(zval *ret, sdlContentModelPtr model, xmlNodePtr if (model->u.element->fixed && strcmp(model->u.element->fixed, (char*)r_node->children->content) != 0) { soap_error3(E_ERROR, "Encoding: Element '%s' has fixed value '%s' (value '%s' is not allowed)", model->u.element->name, model->u.element->fixed, r_node->children->content); } - val = master_to_zval(model->u.element->encode, r_node TSRMLS_CC); + master_to_zval(&val, model->u.element->encode, r_node TSRMLS_CC); } else if (model->u.element->fixed) { xmlNodePtr dummy = xmlNewNode(NULL, BAD_CAST("BOGUS")); xmlNodeSetContent(dummy, BAD_CAST(model->u.element->fixed)); - val = master_to_zval(model->u.element->encode, dummy TSRMLS_CC); + master_to_zval(&val, model->u.element->encode, dummy TSRMLS_CC); xmlFreeNode(dummy); } else if (model->u.element->def && !model->u.element->nillable) { xmlNodePtr dummy = xmlNewNode(NULL, BAD_CAST("BOGUS")); xmlNodeSetContent(dummy, BAD_CAST(model->u.element->def)); - val = master_to_zval(model->u.element->encode, dummy TSRMLS_CC); + master_to_zval(&val, model->u.element->encode, dummy TSRMLS_CC); xmlFreeNode(dummy); } else { - val = master_to_zval(model->u.element->encode, r_node TSRMLS_CC); + master_to_zval(&val, model->u.element->encode, r_node TSRMLS_CC); } if ((node = get_node(node->next, model->u.element->name)) != NULL) { - zval *array; + zval array; - MAKE_STD_ZVAL(array); - array_init(array); - add_next_index_zval(array, val); + array_init(&array); + add_next_index_zval(&array, &val); do { if (node && node->children && node->children->content) { if (model->u.element->fixed && strcmp(model->u.element->fixed, (char*)node->children->content) != 0) { soap_error3(E_ERROR, "Encoding: Element '%s' has fixed value '%s' (value '%s' is not allowed)", model->u.element->name, model->u.element->fixed, node->children->content); } - val = master_to_zval(model->u.element->encode, node TSRMLS_CC); + master_to_zval(&val, model->u.element->encode, node TSRMLS_CC); } else if (model->u.element->fixed) { xmlNodePtr dummy = xmlNewNode(NULL, BAD_CAST("BOGUS")); xmlNodeSetContent(dummy, BAD_CAST(model->u.element->fixed)); - val = master_to_zval(model->u.element->encode, dummy TSRMLS_CC); + master_to_zval(&val, model->u.element->encode, dummy TSRMLS_CC); xmlFreeNode(dummy); } else if (model->u.element->def && !model->u.element->nillable) { xmlNodePtr dummy = xmlNewNode(NULL, BAD_CAST("BOGUS")); xmlNodeSetContent(dummy, BAD_CAST(model->u.element->def)); - val = master_to_zval(model->u.element->encode, dummy TSRMLS_CC); + master_to_zval(&val, model->u.element->encode, dummy TSRMLS_CC); xmlFreeNode(dummy); } else { - val = master_to_zval(model->u.element->encode, node TSRMLS_CC); + master_to_zval(&val, model->u.element->encode, node TSRMLS_CC); } - add_next_index_zval(array, val); + add_next_index_zval(&array, &val); } while ((node = get_node(node->next, model->u.element->name)) != NULL); - val = array; - } else if ((Z_TYPE_P(val) != IS_NULL || !model->u.element->nillable) && + ZVAL_COPY_VALUE(&val, &array); + } else if ((Z_TYPE(val) != IS_NULL || !model->u.element->nillable) && (SOAP_GLOBAL(features) & SOAP_SINGLE_ELEMENT_ARRAYS) && (model->max_occurs == -1 || model->max_occurs > 1)) { - zval *array; + zval array; - MAKE_STD_ZVAL(array); - array_init(array); - add_next_index_zval(array, val); - val = array; + array_init(&array); + add_next_index_zval(&array, &val); + ZVAL_COPY_VALUE(&val, &array); } - set_zval_property(ret, model->u.element->name, val TSRMLS_CC); + set_zval_property(ret, model->u.element->name, &val TSRMLS_CC); } } break; case XSD_CONTENT_ALL: case XSD_CONTENT_SEQUENCE: case XSD_CONTENT_CHOICE: { - sdlContentModelPtr *tmp; - HashPosition pos; + sdlContentModelPtr tmp; sdlContentModelPtr any = NULL; - zend_hash_internal_pointer_reset_ex(model->u.content, &pos); - while (zend_hash_get_current_data_ex(model->u.content, (void**)&tmp, &pos) == SUCCESS) { - if ((*tmp)->kind == XSD_CONTENT_ANY) { - any = *tmp; + ZEND_HASH_FOREACH_PTR(model->u.content, tmp) { + if (tmp->kind == XSD_CONTENT_ANY) { + any = tmp; } else { - model_to_zval_object(ret, *tmp, data, sdl TSRMLS_CC); + model_to_zval_object(ret, tmp, data, sdl TSRMLS_CC); } - zend_hash_move_forward_ex(model->u.content, &pos); - } + } ZEND_HASH_FOREACH_END(); if (any) { model_to_zval_any(ret, data->children TSRMLS_CC); } @@ -1467,24 +1423,23 @@ static void model_to_zval_object(zval *ret, sdlContentModelPtr model, xmlNodePtr } /* Struct encode/decode */ -static zval *to_zval_object_ex(encodeTypePtr type, xmlNodePtr data, zend_class_entry *pce TSRMLS_DC) +static zval *to_zval_object_ex(zval *ret, encodeTypePtr type, xmlNodePtr data, zend_class_entry *pce TSRMLS_DC) { - zval *ret; xmlNodePtr trav; sdlPtr sdl; sdlTypePtr sdlType = type->sdl_type; zend_class_entry *ce = ZEND_STANDARD_CLASS_DEF_PTR; - zval *redo_any = NULL; + zval *redo_any = NULL, rv, arr; if (pce) { ce = pce; } else if (SOAP_GLOBAL(class_map) && type->type_str) { - zval **classname; + zval *classname; zend_class_entry *tmp; - if (zend_hash_find(SOAP_GLOBAL(class_map), type->type_str, strlen(type->type_str)+1, (void**)&classname) == SUCCESS && - Z_TYPE_PP(classname) == IS_STRING && - (tmp = zend_fetch_class(Z_STRVAL_PP(classname), Z_STRLEN_PP(classname), ZEND_FETCH_CLASS_AUTO TSRMLS_CC)) != NULL) { + if ((classname = zend_hash_str_find(SOAP_GLOBAL(class_map), type->type_str, strlen(type->type_str))) != NULL && + Z_TYPE_P(classname) == IS_STRING && + (tmp = zend_fetch_class(Z_STR_P(classname), ZEND_FETCH_CLASS_AUTO TSRMLS_CC)) != NULL) { ce = tmp; } } @@ -1502,20 +1457,20 @@ static zval *to_zval_object_ex(encodeTypePtr type, xmlNodePtr data, zend_class_e enc = enc->details.sdl_type->encode; } if (enc) { - zval *base; + zval base; - ALLOC_INIT_ZVAL(ret); - if (soap_check_xml_ref(&ret, data TSRMLS_CC)) { + ZVAL_NULL(ret); + if (soap_check_xml_ref(ret, data TSRMLS_CC)) { return ret; } object_init_ex(ret, ce); - base = master_to_zval_int(enc, data TSRMLS_CC); - set_zval_property(ret, "_", base TSRMLS_CC); + master_to_zval_int(&base, enc, data TSRMLS_CC); + set_zval_property(ret, "_", &base TSRMLS_CC); } else { - ALLOC_INIT_ZVAL(ret); + ZVAL_NULL(ret); FIND_XML_NULL(data, ret); - if (soap_check_xml_ref(&ret, data TSRMLS_CC)) { + if (soap_check_xml_ref(ret, data TSRMLS_CC)) { return ret; } object_init_ex(ret, ce); @@ -1542,34 +1497,34 @@ static zval *to_zval_object_ex(encodeTypePtr type, xmlNodePtr data, zend_class_e (sdlType->encode->details.sdl_type->encode == NULL || (sdlType->encode->details.sdl_type->encode->details.type != IS_ARRAY && sdlType->encode->details.sdl_type->encode->details.type != SOAP_ENC_ARRAY))) { - ret = to_zval_object_ex(&sdlType->encode->details, data, ce TSRMLS_CC); + to_zval_object_ex(ret, &sdlType->encode->details, data, ce TSRMLS_CC); } else { - ret = master_to_zval_int(sdlType->encode, data TSRMLS_CC); + master_to_zval_int(ret, sdlType->encode, data TSRMLS_CC); } - if (soap_check_xml_ref(&ret, data TSRMLS_CC)) { + if (soap_check_xml_ref(ret, data TSRMLS_CC)) { return ret; } - redo_any = get_zval_property(ret, "any" TSRMLS_CC); + redo_any = get_zval_property(ret, "any", &rv TSRMLS_CC); if (Z_TYPE_P(ret) == IS_OBJECT && ce != ZEND_STANDARD_CLASS_DEF_PTR) { - zend_object *zobj = zend_objects_get_address(ret TSRMLS_CC); + zend_object *zobj = Z_OBJ_P(ret); zobj->ce = ce; } } else { - zval *base; + zval base; - ALLOC_INIT_ZVAL(ret); - if (soap_check_xml_ref(&ret, data TSRMLS_CC)) { + ZVAL_NULL(ret); + if (soap_check_xml_ref(ret, data TSRMLS_CC)) { return ret; } object_init_ex(ret, ce); - base = master_to_zval_int(sdlType->encode, data TSRMLS_CC); - set_zval_property(ret, "_", base TSRMLS_CC); + master_to_zval_int(&base, sdlType->encode, data TSRMLS_CC); + set_zval_property(ret, "_", &base TSRMLS_CC); } } else { - ALLOC_INIT_ZVAL(ret); + ZVAL_NULL(ret); FIND_XML_NULL(data, ret); - if (soap_check_xml_ref(&ret, data TSRMLS_CC)) { + if (soap_check_xml_ref(ret, data TSRMLS_CC)) { return ret; } object_init_ex(ret, ce); @@ -1581,7 +1536,7 @@ static zval *to_zval_object_ex(encodeTypePtr type, xmlNodePtr data, zend_class_e } model_to_zval_object(ret, sdlType->model, data, sdl TSRMLS_CC); if (redo_any) { - zval *tmp = get_zval_property(ret, "any" TSRMLS_CC); + zval *tmp = get_zval_property(ret, "any", &rv TSRMLS_CC); if (tmp == NULL) { model_to_zval_any(ret, data->children TSRMLS_CC); @@ -1589,49 +1544,45 @@ static zval *to_zval_object_ex(encodeTypePtr type, xmlNodePtr data, zend_class_e zval_dtor(tmp); efree(tmp); } - zval_ptr_dtor(&redo_any); + zval_ptr_dtor(redo_any); } } if (sdlType->attributes) { - sdlAttributePtr *attr; - HashPosition pos; + sdlAttributePtr attr; - zend_hash_internal_pointer_reset_ex(sdlType->attributes, &pos); - while (zend_hash_get_current_data_ex(sdlType->attributes, (void**)&attr, &pos) == SUCCESS) { - if ((*attr)->name) { - xmlAttrPtr val = get_attribute(data->properties, (*attr)->name); + ZEND_HASH_FOREACH_PTR(sdlType->attributes, attr) { + if (attr->name) { + xmlAttrPtr val = get_attribute(data->properties, attr->name); char *str_val = NULL; if (val && val->children && val->children->content) { str_val = (char*)val->children->content; - if ((*attr)->fixed && strcmp((*attr)->fixed, str_val) != 0) { - soap_error3(E_ERROR, "Encoding: Attribute '%s' has fixed value '%s' (value '%s' is not allowed)", (*attr)->name, (*attr)->fixed, str_val); + if (attr->fixed && strcmp(attr->fixed, str_val) != 0) { + soap_error3(E_ERROR, "Encoding: Attribute '%s' has fixed value '%s' (value '%s' is not allowed)", attr->name, attr->fixed, str_val); } - } else if ((*attr)->fixed) { - str_val = (*attr)->fixed; - } else if ((*attr)->def) { - str_val = (*attr)->def; + } else if (attr->fixed) { + str_val = attr->fixed; + } else if (attr->def) { + str_val = attr->def; } if (str_val) { xmlNodePtr dummy, text; - zval *data; + zval data; dummy = xmlNewNode(NULL, BAD_CAST("BOGUS")); text = xmlNewText(BAD_CAST(str_val)); xmlAddChild(dummy, text); - data = master_to_zval((*attr)->encode, dummy TSRMLS_CC); + master_to_zval(&data, attr->encode, dummy TSRMLS_CC); xmlFreeNode(dummy); - set_zval_property(ret, (*attr)->name, data TSRMLS_CC); + set_zval_property(ret, attr->name, &data TSRMLS_CC); } } - zend_hash_move_forward_ex(sdlType->attributes, &pos); - } + } ZEND_HASH_FOREACH_END(); } } else { - - ALLOC_INIT_ZVAL(ret); + ZVAL_NULL(ret); FIND_XML_NULL(data, ret); - if (soap_check_xml_ref(&ret, data TSRMLS_CC)) { + if (soap_check_xml_ref(ret, data TSRMLS_CC)) { return ret; } @@ -1640,38 +1591,34 @@ static zval *to_zval_object_ex(encodeTypePtr type, xmlNodePtr data, zend_class_e while (trav != NULL) { if (trav->type == XML_ELEMENT_NODE) { - zval *tmpVal; + zval tmpVal, rv; zval *prop; - tmpVal = master_to_zval(NULL, trav TSRMLS_CC); + master_to_zval(&tmpVal, NULL, trav TSRMLS_CC); - prop = get_zval_property(ret, (char*)trav->name TSRMLS_CC); + prop = get_zval_property(ret, (char*)trav->name, &rv TSRMLS_CC); if (!prop) { if (!trav->next || !get_node(trav->next, (char*)trav->name)) { - set_zval_property(ret, (char*)trav->name, tmpVal TSRMLS_CC); + set_zval_property(ret, (char*)trav->name, &tmpVal TSRMLS_CC); } else { - zval *arr; + zval arr; - MAKE_STD_ZVAL(arr); - array_init(arr); - add_next_index_zval(arr, tmpVal); - set_zval_property(ret, (char*)trav->name, arr TSRMLS_CC); + array_init(&arr); + add_next_index_zval(&arr, &tmpVal); + set_zval_property(ret, (char*)trav->name, &arr TSRMLS_CC); } } else { /* Property already exist - make array */ if (Z_TYPE_P(prop) != IS_ARRAY) { /* Convert into array */ - zval *arr; - - MAKE_STD_ZVAL(arr); - array_init(arr); + array_init(&arr); Z_ADDREF_P(prop); - add_next_index_zval(arr, prop); - set_zval_property(ret, (char*)trav->name, arr TSRMLS_CC); - prop = arr; + add_next_index_zval(&arr, prop); + set_zval_property(ret, (char*)trav->name, &arr TSRMLS_CC); + prop = &arr; } /* Add array element */ - add_next_index_zval(prop, tmpVal); + add_next_index_zval(prop, &tmpVal); } } trav = trav->next; @@ -1680,9 +1627,9 @@ static zval *to_zval_object_ex(encodeTypePtr type, xmlNodePtr data, zend_class_e return ret; } -static zval *to_zval_object(encodeTypePtr type, xmlNodePtr data TSRMLS_DC) +static zval *to_zval_object(zval *ret, encodeTypePtr type, xmlNodePtr data TSRMLS_DC) { - return to_zval_object_ex(type, data, NULL TSRMLS_CC); + return to_zval_object_ex(ret, type, data, NULL TSRMLS_CC); } @@ -1693,8 +1640,9 @@ static int model_to_xml_object(xmlNodePtr node, sdlContentModelPtr model, zval * zval *data; xmlNodePtr property; encodePtr enc; + zval rv; - data = get_zval_property(object, model->u.element->name TSRMLS_CC); + data = get_zval_property(object, model->u.element->name, &rv TSRMLS_CC); if (data && Z_TYPE_P(data) == IS_NULL && !model->u.element->nillable && @@ -1708,16 +1656,15 @@ static int model_to_xml_object(xmlNodePtr node, sdlContentModelPtr model, zval * Z_TYPE_P(data) == IS_ARRAY && !is_map(data)) { HashTable *ht = Z_ARRVAL_P(data); - zval **val; + zval *val; - zend_hash_internal_pointer_reset(ht); - while (zend_hash_get_current_data(ht,(void**)&val) == SUCCESS) { - if (Z_TYPE_PP(val) == IS_NULL && model->u.element->nillable) { + ZEND_HASH_FOREACH_VAL(ht, val) { + if (Z_TYPE_P(val) == IS_NULL && model->u.element->nillable) { property = xmlNewNode(NULL, BAD_CAST("BOGUS")); xmlAddChild(node, property); set_xsi_nil(property); } else { - property = master_to_xml(enc, *val, style, node TSRMLS_CC); + property = master_to_xml(enc, val, style, node TSRMLS_CC); if (property->children && property->children->content && model->u.element->fixed && strcmp(model->u.element->fixed, (char*)property->children->content) != 0) { soap_error3(E_ERROR, "Encoding: Element '%s' has fixed value '%s' (value '%s' is not allowed)", model->u.element->name, model->u.element->fixed, property->children->content); @@ -1730,8 +1677,7 @@ static int model_to_xml_object(xmlNodePtr node, sdlContentModelPtr model, zval * xmlNsPtr nsp = encode_add_ns(property, model->u.element->namens); xmlSetNs(property, nsp); } - zend_hash_move_forward(ht); - } + } ZEND_HASH_FOREACH_END(); } else { if (Z_TYPE_P(data) == IS_NULL && model->u.element->nillable) { property = xmlNewNode(NULL, BAD_CAST("BOGUS")); @@ -1780,21 +1726,20 @@ static int model_to_xml_object(xmlNodePtr node, sdlContentModelPtr model, zval * zval *data; xmlNodePtr property; encodePtr enc; + zval rv; - data = get_zval_property(object, "any" TSRMLS_CC); + data = get_zval_property(object, "any", &rv TSRMLS_CC); if (data) { enc = get_conversion(XSD_ANYXML); if ((model->max_occurs == -1 || model->max_occurs > 1) && Z_TYPE_P(data) == IS_ARRAY && !is_map(data)) { HashTable *ht = Z_ARRVAL_P(data); - zval **val; + zval *val; - zend_hash_internal_pointer_reset(ht); - while (zend_hash_get_current_data(ht,(void**)&val) == SUCCESS) { - property = master_to_xml(enc, *val, style, node TSRMLS_CC); - zend_hash_move_forward(ht); - } + ZEND_HASH_FOREACH_VAL(ht, val) { + property = master_to_xml(enc, val, style, node TSRMLS_CC); + } ZEND_HASH_FOREACH_END(); } else { property = master_to_xml(enc, data, style, node TSRMLS_CC); } @@ -1811,36 +1756,30 @@ static int model_to_xml_object(xmlNodePtr node, sdlContentModelPtr model, zval * } case XSD_CONTENT_SEQUENCE: case XSD_CONTENT_ALL: { - sdlContentModelPtr *tmp; - HashPosition pos; + sdlContentModelPtr tmp; - zend_hash_internal_pointer_reset_ex(model->u.content, &pos); - while (zend_hash_get_current_data_ex(model->u.content, (void**)&tmp, &pos) == SUCCESS) { - if (!model_to_xml_object(node, *tmp, object, style, strict && ((*tmp)->min_occurs > 0) TSRMLS_CC)) { - if (!strict || (*tmp)->min_occurs > 0) { + ZEND_HASH_FOREACH_PTR(model->u.content, tmp) { + if (!model_to_xml_object(node, tmp, object, style, strict && (tmp->min_occurs > 0) TSRMLS_CC)) { + if (!strict || tmp->min_occurs > 0) { return 0; } } strict = 1; - zend_hash_move_forward_ex(model->u.content, &pos); - } + } ZEND_HASH_FOREACH_END(); return 1; } case XSD_CONTENT_CHOICE: { - sdlContentModelPtr *tmp; - HashPosition pos; + sdlContentModelPtr tmp; int ret = 0; - zend_hash_internal_pointer_reset_ex(model->u.content, &pos); - while (zend_hash_get_current_data_ex(model->u.content, (void**)&tmp, &pos) == SUCCESS) { - int tmp_ret = model_to_xml_object(node, *tmp, object, style, 0 TSRMLS_CC); + ZEND_HASH_FOREACH_PTR(model->u.content, tmp) { + int tmp_ret = model_to_xml_object(node, tmp, object, style, 0 TSRMLS_CC); if (tmp_ret == 1) { return 1; } else if (tmp_ret != 0) { ret = 1; } - zend_hash_move_forward_ex(model->u.content, &pos); - } + } ZEND_HASH_FOREACH_END(); return ret; } case XSD_CONTENT_GROUP: { @@ -1865,15 +1804,14 @@ static sdlTypePtr model_array_element(sdlContentModelPtr model) case XSD_CONTENT_SEQUENCE: case XSD_CONTENT_ALL: case XSD_CONTENT_CHOICE: { - sdlContentModelPtr *tmp; - HashPosition pos; + sdlContentModelPtr tmp; if (zend_hash_num_elements(model->u.content) != 1) { return NULL; } - zend_hash_internal_pointer_reset_ex(model->u.content, &pos); - zend_hash_get_current_data_ex(model->u.content, (void**)&tmp, &pos); - return model_array_element(*tmp); + ZEND_HASH_FOREACH_PTR(model->u.content, tmp) { + return model_array_element(tmp); + } ZEND_HASH_FOREACH_END(); } case XSD_CONTENT_GROUP: { return model_array_element(model->u.group->model); @@ -1920,7 +1858,8 @@ static xmlNodePtr to_xml_object(encodeTypePtr type, zval *data, int style, xmlNo enc = enc->details.sdl_type->encode; } if (enc) { - zval *tmp = get_zval_property(data, "_" TSRMLS_CC); + zval rv; + zval *tmp = get_zval_property(data, "_", &rv TSRMLS_CC); if (tmp) { xmlParam = master_to_xml(enc, tmp, style, parent TSRMLS_CC); } else if (prop == NULL) { @@ -1940,11 +1879,12 @@ static xmlNodePtr to_xml_object(encodeTypePtr type, zval *data, int style, xmlNo sdlType->encode->details.sdl_type->kind != XSD_TYPEKIND_LIST && sdlType->encode->details.sdl_type->kind != XSD_TYPEKIND_UNION) { - if (prop) prop->nApplyCount++; + if (prop) ZEND_HASH_INC_APPLY_COUNT(prop); xmlParam = master_to_xml(sdlType->encode, data, style, parent TSRMLS_CC); - if (prop) prop->nApplyCount--; + if (prop) ZEND_HASH_DEC_APPLY_COUNT(prop); } else { - zval *tmp = get_zval_property(data, "_" TSRMLS_CC); + zval rv; + zval *tmp = get_zval_property(data, "_", &rv TSRMLS_CC); if (tmp) { xmlParam = master_to_xml(sdlType->encode, tmp, style, parent TSRMLS_CC); @@ -1971,17 +1911,16 @@ static xmlNodePtr to_xml_object(encodeTypePtr type, zval *data, int style, xmlNo sdlType->attributes == NULL && sdlType->model != NULL && (array_el = model_array_element(sdlType->model)) != NULL) { - zval **val; + zval *val; - zend_hash_internal_pointer_reset(prop); - while (zend_hash_get_current_data(prop,(void**)&val) == SUCCESS) { + ZEND_HASH_FOREACH_VAL(prop, val) { xmlNodePtr property; - if (Z_TYPE_PP(val) == IS_NULL && array_el->nillable) { + if (Z_TYPE_P(val) == IS_NULL && array_el->nillable) { property = xmlNewNode(NULL, BAD_CAST("BOGUS")); xmlAddChild(xmlParam, property); set_xsi_nil(property); } else { - property = master_to_xml(array_el->encode, *val, style, xmlParam TSRMLS_CC); + property = master_to_xml(array_el->encode, val, style, xmlParam TSRMLS_CC); } xmlNodeSetName(property, BAD_CAST(array_el->name)); if (style == SOAP_LITERAL && @@ -1990,47 +1929,43 @@ static xmlNodePtr to_xml_object(encodeTypePtr type, zval *data, int style, xmlNo xmlNsPtr nsp = encode_add_ns(property, array_el->namens); xmlSetNs(property, nsp); } - zend_hash_move_forward(prop); - } + } ZEND_HASH_FOREACH_END(); } else if (sdlType->model) { model_to_xml_object(xmlParam, sdlType->model, data, style, 1 TSRMLS_CC); } if (sdlType->attributes) { - sdlAttributePtr *attr; - zval *zattr; - HashPosition pos; - - zend_hash_internal_pointer_reset_ex(sdlType->attributes, &pos); - while (zend_hash_get_current_data_ex(sdlType->attributes, (void**)&attr, &pos) == SUCCESS) { - if ((*attr)->name) { - zattr = get_zval_property(data, (*attr)->name TSRMLS_CC); + sdlAttributePtr attr; + zval *zattr, rv; + + ZEND_HASH_FOREACH_PTR(sdlType->attributes, attr) { + if (attr->name) { + zattr = get_zval_property(data, attr->name, &rv TSRMLS_CC); if (zattr) { xmlNodePtr dummy; - dummy = master_to_xml((*attr)->encode, zattr, SOAP_LITERAL, xmlParam TSRMLS_CC); + dummy = master_to_xml(attr->encode, zattr, SOAP_LITERAL, xmlParam TSRMLS_CC); if (dummy->children && dummy->children->content) { - if ((*attr)->fixed && strcmp((*attr)->fixed, (char*)dummy->children->content) != 0) { - soap_error3(E_ERROR, "Encoding: Attribute '%s' has fixed value '%s' (value '%s' is not allowed)", (*attr)->name, (*attr)->fixed, dummy->children->content); + if (attr->fixed && strcmp(attr->fixed, (char*)dummy->children->content) != 0) { + soap_error3(E_ERROR, "Encoding: Attribute '%s' has fixed value '%s' (value '%s' is not allowed)", attr->name, attr->fixed, dummy->children->content); } /* we need to handle xml: namespace specially, since it is an implicit schema. Otherwise, use form. */ - if ((*attr)->namens && - (!strncmp((*attr)->namens, XML_NAMESPACE, sizeof(XML_NAMESPACE)) || - (*attr)->form == XSD_FORM_QUALIFIED)) { - xmlNsPtr nsp = encode_add_ns(xmlParam, (*attr)->namens); + if (attr->namens && + (!strncmp(attr->namens, XML_NAMESPACE, sizeof(XML_NAMESPACE)) || + attr->form == XSD_FORM_QUALIFIED)) { + xmlNsPtr nsp = encode_add_ns(xmlParam, attr->namens); - xmlSetNsProp(xmlParam, nsp, BAD_CAST((*attr)->name), dummy->children->content); + xmlSetNsProp(xmlParam, nsp, BAD_CAST(attr->name), dummy->children->content); } else { - xmlSetProp(xmlParam, BAD_CAST((*attr)->name), dummy->children->content); + xmlSetProp(xmlParam, BAD_CAST(attr->name), dummy->children->content); } } xmlUnlinkNode(dummy); xmlFreeNode(dummy); } } - zend_hash_move_forward_ex(sdlType->attributes, &pos); - } + } ZEND_HASH_FOREACH_END(); } } if (style == SOAP_ENCODED) { @@ -2049,16 +1984,15 @@ static xmlNodePtr to_xml_object(encodeTypePtr type, zval *data, int style, xmlNo for (;i > 0;i--) { xmlNodePtr property; - zval **zprop; - char *str_key; + zval *zprop; + zend_string *str_key; ulong index; int key_type; - unsigned int str_key_len; - key_type = zend_hash_get_current_key_ex(prop, &str_key, &str_key_len, &index, FALSE, NULL); - zend_hash_get_current_data(prop, (void **)&zprop); + key_type = zend_hash_get_current_key_ex(prop, &str_key, &index, FALSE, &prop->nInternalPointer); + zprop = zend_hash_get_current_data(prop); - property = master_to_xml(get_conversion((*zprop)->type), (*zprop), style, xmlParam TSRMLS_CC); + property = master_to_xml(get_conversion(Z_TYPE_P(zprop)), zprop, style, xmlParam TSRMLS_CC); if (key_type == HASH_KEY_IS_STRING) { const char *prop_name; @@ -2066,9 +2000,9 @@ static xmlNodePtr to_xml_object(encodeTypePtr type, zval *data, int style, xmlNo if (Z_TYPE_P(data) == IS_OBJECT) { const char *class_name; - zend_unmangle_property_name(str_key, str_key_len-1, &class_name, &prop_name); + zend_unmangle_property_name(str_key->val, str_key->len, &class_name, &prop_name); } else { - prop_name = str_key; + prop_name = str_key->val; } if (prop_name) { xmlNodeSetName(property, BAD_CAST(prop_name)); @@ -2209,11 +2143,11 @@ static void add_xml_array_elements(xmlNodePtr xmlParam, int j; if (data && Z_TYPE_P(data) == IS_ARRAY) { - zend_hash_internal_pointer_reset(data->value.ht); + zend_hash_internal_pointer_reset(Z_ARRVAL_P(data)); for (j=0; j<dims[0]; j++) { - zval **zdata; + zval *zdata; - if (zend_hash_get_current_data(data->value.ht, (void **)&zdata) != SUCCESS) { + if ((zdata = zend_hash_get_current_data(Z_ARRVAL_P(data))) == NULL) { zdata = NULL; } if (dimension == 1) { @@ -2221,9 +2155,9 @@ static void add_xml_array_elements(xmlNodePtr xmlParam, if (zdata) { if (enc == NULL) { - xparam = master_to_xml(get_conversion((*zdata)->type), (*zdata), style, xmlParam TSRMLS_CC); + xparam = master_to_xml(get_conversion(Z_TYPE_P(zdata)), zdata, style, xmlParam TSRMLS_CC); } else { - xparam = master_to_xml(enc, (*zdata), style, xmlParam TSRMLS_CC); + xparam = master_to_xml(enc, zdata, style, xmlParam TSRMLS_CC); } } else { xparam = xmlNewNode(NULL, BAD_CAST("BOGUS")); @@ -2240,12 +2174,12 @@ static void add_xml_array_elements(xmlNodePtr xmlParam, } } else { if (zdata) { - add_xml_array_elements(xmlParam, type, enc, ns, dimension-1, dims+1, *zdata, style TSRMLS_CC); + add_xml_array_elements(xmlParam, type, enc, ns, dimension-1, dims+1, zdata, style TSRMLS_CC); } else { add_xml_array_elements(xmlParam, type, enc, ns, dimension-1, dims+1, NULL, style TSRMLS_CC); } } - zend_hash_move_forward(data->value.ht); + zend_hash_move_forward(Z_ARRVAL_P(data)); } } else { for (j=0; j<dims[0]; j++) { @@ -2272,8 +2206,8 @@ static void add_xml_array_elements(xmlNodePtr xmlParam, static inline int array_num_elements(HashTable* ht) { if (ht->nNumUsed && - ht->arData[ht->nNumUsed-1].xData && - ht->arData[ht->nNumUsed-1].nKeyLength == 0) { + Z_TYPE(ht->arData[ht->nNumUsed-1].val) != IS_UNUSED && + ht->arData[ht->nNumUsed-1].key == NULL) { return ht->arData[ht->nNumUsed-1].h - 1; } @@ -2291,8 +2225,9 @@ static xmlNodePtr to_xml_array(encodeTypePtr type, zval *data, int style, xmlNod int dimension = 1; int* dims; int soap_version; - zval *array_copy = NULL; + zval array_copy; + ZVAL_UNDEF(&array_copy); soap_version = SOAP_GLOBAL(soap_version); xmlParam = xmlNewNode(NULL, BAD_CAST("BOGUS")); @@ -2313,11 +2248,9 @@ static xmlNodePtr to_xml_array(encodeTypePtr type, zval *data, int style, xmlNod if (Z_TYPE_P(data) == IS_OBJECT && instanceof_function(Z_OBJCE_P(data), zend_ce_traversable TSRMLS_CC)) { zend_object_iterator *iter; zend_class_entry *ce = Z_OBJCE_P(data); - zval **val; + zval *val; - ALLOC_ZVAL(array_copy); - INIT_PZVAL(array_copy); - array_init(array_copy); + array_init(&array_copy); iter = ce->get_iterator(ce, data, 0 TSRMLS_CC); @@ -2337,7 +2270,7 @@ static xmlNodePtr to_xml_array(encodeTypePtr type, zval *data, int style, xmlNod goto iterator_done; } - iter->funcs->get_current_data(iter, &val TSRMLS_CC); + val = iter->funcs->get_current_data(iter TSRMLS_CC); if (EG(exception)) { goto iterator_done; } @@ -2347,13 +2280,13 @@ static xmlNodePtr to_xml_array(encodeTypePtr type, zval *data, int style, xmlNod if (EG(exception)) { goto iterator_done; } - array_set_zval_key(Z_ARRVAL_P(array_copy), &key, *val); + array_set_zval_key(Z_ARRVAL(array_copy), &key, val); zval_ptr_dtor(val); zval_dtor(&key); } else { - add_next_index_zval(array_copy, *val); + add_next_index_zval(&array_copy, val); } - Z_ADDREF_PP(val); + Z_ADDREF_P(val); iter->funcs->move_forward(iter TSRMLS_CC); if (EG(exception)) { @@ -2364,54 +2297,54 @@ iterator_done: iter->funcs->dtor(iter TSRMLS_CC); if (EG(exception)) { zval_ptr_dtor(&array_copy); - array_copy = NULL; + ZVAL_UNDEF(&array_copy); } else { - data = array_copy; + data = &array_copy; } } if (Z_TYPE_P(data) == IS_ARRAY) { - sdlAttributePtr *arrayType; - sdlExtraAttributePtr *ext; + sdlAttributePtr arrayType; + sdlExtraAttributePtr ext; sdlTypePtr elementType; i = zend_hash_num_elements(Z_ARRVAL_P(data)); if (sdl_type && sdl_type->attributes && - zend_hash_find(sdl_type->attributes, SOAP_1_1_ENC_NAMESPACE":arrayType", - sizeof(SOAP_1_1_ENC_NAMESPACE":arrayType"), - (void **)&arrayType) == SUCCESS && - (*arrayType)->extraAttributes && - zend_hash_find((*arrayType)->extraAttributes, WSDL_NAMESPACE":arrayType", sizeof(WSDL_NAMESPACE":arrayType"), (void **)&ext) == SUCCESS) { + (arrayType = zend_hash_str_find_ptr(sdl_type->attributes, SOAP_1_1_ENC_NAMESPACE":arrayType", + sizeof(SOAP_1_1_ENC_NAMESPACE":arrayType")-1)) != NULL && + arrayType->extraAttributes && + (ext = zend_hash_str_find_ptr(arrayType->extraAttributes, WSDL_NAMESPACE":arrayType", sizeof(WSDL_NAMESPACE":arrayType")-1)) != NULL) { char *value, *end; - zval** el; + zval *el; - value = estrdup((*ext)->val); + value = estrdup(ext->val); end = strrchr(value,'['); if (end) { *end = '\0'; end++; dimension = calc_dimension(end); } - if ((*ext)->ns != NULL) { - enc = get_encoder(SOAP_GLOBAL(sdl), (*ext)->ns, value); - get_type_str(xmlParam, (*ext)->ns, value, &array_type); + if (ext->ns != NULL) { + enc = get_encoder(SOAP_GLOBAL(sdl), ext->ns, value); + get_type_str(xmlParam, ext->ns, value, &array_type); } else { smart_str_appends(&array_type, value); } dims = safe_emalloc(sizeof(int), dimension, 0); dims[0] = i; - el = &data; + //??? el = &data; + el = data; for (i = 1; i < dimension; i++) { - if (el != NULL && Z_TYPE_PP(el) == IS_ARRAY && - zend_hash_num_elements(Z_ARRVAL_PP(el)) > 0) { - zend_hash_internal_pointer_reset(Z_ARRVAL_PP(el)); - zend_hash_get_current_data(Z_ARRVAL_PP(el), (void**)&el); - if (Z_TYPE_PP(el) == IS_ARRAY) { - dims[i] = zend_hash_num_elements(Z_ARRVAL_PP(el)); + if (el != NULL && Z_TYPE_P(el) == IS_ARRAY && + zend_hash_num_elements(Z_ARRVAL_P(el)) > 0) { + zend_hash_internal_pointer_reset(Z_ARRVAL_P(el)); + el = zend_hash_get_current_data(Z_ARRVAL_P(el)); + if (Z_TYPE_P(el) == IS_ARRAY) { + dims[i] = zend_hash_num_elements(Z_ARRVAL_P(el)); } else { dims[i] = 0; } @@ -2428,24 +2361,22 @@ iterator_done: } else if (sdl_type && sdl_type->attributes && - zend_hash_find(sdl_type->attributes, SOAP_1_2_ENC_NAMESPACE":itemType", - sizeof(SOAP_1_2_ENC_NAMESPACE":itemType"), - (void **)&arrayType) == SUCCESS && - (*arrayType)->extraAttributes && - zend_hash_find((*arrayType)->extraAttributes, WSDL_NAMESPACE":itemType", sizeof(WSDL_NAMESPACE":itemType"), (void **)&ext) == SUCCESS) { - if ((*ext)->ns != NULL) { - enc = get_encoder(SOAP_GLOBAL(sdl), (*ext)->ns, (*ext)->val); - get_type_str(xmlParam, (*ext)->ns, (*ext)->val, &array_type); + (arrayType = zend_hash_str_find_ptr(sdl_type->attributes, SOAP_1_2_ENC_NAMESPACE":itemType", + sizeof(SOAP_1_2_ENC_NAMESPACE":itemType")-1)) != NULL && + arrayType->extraAttributes && + (ext = zend_hash_str_find_ptr(arrayType->extraAttributes, WSDL_NAMESPACE":itemType", sizeof(WSDL_NAMESPACE":itemType")-1)) != NULL) { + if (ext->ns != NULL) { + enc = get_encoder(SOAP_GLOBAL(sdl), ext->ns, ext->val); + get_type_str(xmlParam, ext->ns, ext->val, &array_type); } else { - smart_str_appends(&array_type, (*ext)->val); - } - if (zend_hash_find(sdl_type->attributes, SOAP_1_2_ENC_NAMESPACE":arraySize", - sizeof(SOAP_1_2_ENC_NAMESPACE":arraySize"), - (void **)&arrayType) == SUCCESS && - (*arrayType)->extraAttributes && - zend_hash_find((*arrayType)->extraAttributes, WSDL_NAMESPACE":arraySize", sizeof(WSDL_NAMESPACE":arraysize"), (void **)&ext) == SUCCESS) { - dimension = calc_dimension_12((*ext)->val); - dims = get_position_12(dimension, (*ext)->val); + smart_str_appends(&array_type, ext->val); + } + if ((arrayType = zend_hash_str_find_ptr(sdl_type->attributes, SOAP_1_2_ENC_NAMESPACE":arraySize", + sizeof(SOAP_1_2_ENC_NAMESPACE":arraySize")-1)) != NULL && + arrayType->extraAttributes && + (ext = zend_hash_str_find_ptr(arrayType->extraAttributes, WSDL_NAMESPACE":arraySize", sizeof(WSDL_NAMESPACE":arraysize")-1)) != NULL) { + dimension = calc_dimension_12(ext->val); + dims = get_position_12(dimension, ext->val); if (dims[0] == 0) {dims[0] = i;} smart_str_append_long(&array_size, dims[0]); @@ -2460,13 +2391,12 @@ iterator_done: } } else if (sdl_type && sdl_type->attributes && - zend_hash_find(sdl_type->attributes, SOAP_1_2_ENC_NAMESPACE":arraySize", - sizeof(SOAP_1_2_ENC_NAMESPACE":arraySize"), - (void **)&arrayType) == SUCCESS && - (*arrayType)->extraAttributes && - zend_hash_find((*arrayType)->extraAttributes, WSDL_NAMESPACE":arraySize", sizeof(WSDL_NAMESPACE":arraySize"), (void **)&ext) == SUCCESS) { - dimension = calc_dimension_12((*ext)->val); - dims = get_position_12(dimension, (*ext)->val); + (arrayType = zend_hash_str_find_ptr(sdl_type->attributes, SOAP_1_2_ENC_NAMESPACE":arraySize", + sizeof(SOAP_1_2_ENC_NAMESPACE":arraySize")-1)) != NULL && + arrayType->extraAttributes && + (ext = zend_hash_str_find_ptr(arrayType->extraAttributes, WSDL_NAMESPACE":arraySize", sizeof(WSDL_NAMESPACE":arraySize")-1)) != NULL) { + dimension = calc_dimension_12(ext->val); + dims = get_position_12(dimension, ext->val); if (dims[0] == 0) {dims[0] = i;} smart_str_append_long(&array_size, dims[0]); @@ -2478,8 +2408,7 @@ iterator_done: if (sdl_type && sdl_type->elements && zend_hash_num_elements(sdl_type->elements) == 1 && (zend_hash_internal_pointer_reset(sdl_type->elements), - zend_hash_get_current_data(sdl_type->elements, (void**)&elementType) == SUCCESS) && - (elementType = *(sdlTypePtr*)elementType) != NULL && + (elementType = zend_hash_get_current_data_ptr(sdl_type->elements)) != NULL) && elementType->encode && elementType->encode->details.type_str) { element_type = elementType; enc = elementType->encode; @@ -2490,8 +2419,7 @@ iterator_done: } else if (sdl_type && sdl_type->elements && zend_hash_num_elements(sdl_type->elements) == 1 && (zend_hash_internal_pointer_reset(sdl_type->elements), - zend_hash_get_current_data(sdl_type->elements, (void**)&elementType) == SUCCESS) && - (elementType = *(sdlTypePtr*)elementType) != NULL && + (elementType = zend_hash_get_current_data_ptr(sdl_type->elements)) != NULL) && elementType->encode && elementType->encode->details.type_str) { element_type = elementType; @@ -2513,7 +2441,7 @@ iterator_done: if (style == SOAP_ENCODED) { if (soap_version == SOAP_1_1) { smart_str_0(&array_type); - if (strcmp(array_type.c,"xsd:anyType") == 0) { + if (strcmp(array_type.s->val,"xsd:anyType") == 0) { smart_str_free(&array_type); smart_str_appendl(&array_type,"xsd:ur-type",sizeof("xsd:ur-type")-1); } @@ -2521,17 +2449,17 @@ iterator_done: smart_str_append(&array_type, &array_size); smart_str_appendc(&array_type, ']'); smart_str_0(&array_type); - set_ns_prop(xmlParam, SOAP_1_1_ENC_NAMESPACE, "arrayType", array_type.c); + set_ns_prop(xmlParam, SOAP_1_1_ENC_NAMESPACE, "arrayType", array_type.s->val); } else { int i = 0; - while (i < array_size.len) { - if (array_size.c[i] == ',') {array_size.c[i] = ' ';} + while (i < array_size.s->len) { + if (array_size.s->val[i] == ',') {array_size.s->val[i] = ' ';} ++i; } smart_str_0(&array_type); smart_str_0(&array_size); - set_ns_prop(xmlParam, SOAP_1_2_ENC_NAMESPACE, "itemType", array_type.c); - set_ns_prop(xmlParam, SOAP_1_2_ENC_NAMESPACE, "arraySize", array_size.c); + set_ns_prop(xmlParam, SOAP_1_2_ENC_NAMESPACE, "itemType", array_type.s->val); + set_ns_prop(xmlParam, SOAP_1_2_ENC_NAMESPACE, "arraySize", array_size.s->val); } } smart_str_free(&array_type); @@ -2548,16 +2476,13 @@ iterator_done: } } - if (array_copy) { - zval_ptr_dtor(&array_copy); - } + zval_ptr_dtor(&array_copy); return xmlParam; } -static zval *to_zval_array(encodeTypePtr type, xmlNodePtr data TSRMLS_DC) +static zval *to_zval_array(zval *ret, encodeTypePtr type, xmlNodePtr data TSRMLS_DC) { - zval *ret; xmlNodePtr trav; encodePtr enc = NULL; int dimension = 1; @@ -2565,11 +2490,11 @@ static zval *to_zval_array(encodeTypePtr type, xmlNodePtr data TSRMLS_DC) int* pos = NULL; xmlAttrPtr attr; sdlPtr sdl; - sdlAttributePtr *arrayType; - sdlExtraAttributePtr *ext; + sdlAttributePtr arrayType; + sdlExtraAttributePtr ext; sdlTypePtr elementType; - MAKE_STD_ZVAL(ret); + ZVAL_NULL(ret); FIND_XML_NULL(data, ret); sdl = SOAP_GLOBAL(sdl); @@ -2625,20 +2550,19 @@ static zval *to_zval_array(encodeTypePtr type, xmlNodePtr data TSRMLS_DC) } else if (type->sdl_type != NULL && type->sdl_type->attributes != NULL && - zend_hash_find(type->sdl_type->attributes, SOAP_1_1_ENC_NAMESPACE":arrayType", - sizeof(SOAP_1_1_ENC_NAMESPACE":arrayType"), - (void **)&arrayType) == SUCCESS && - (*arrayType)->extraAttributes && - zend_hash_find((*arrayType)->extraAttributes, WSDL_NAMESPACE":arrayType", sizeof(WSDL_NAMESPACE":arrayType"), (void **)&ext) == SUCCESS) { + (arrayType = zend_hash_str_find_ptr(type->sdl_type->attributes, SOAP_1_1_ENC_NAMESPACE":arrayType", + sizeof(SOAP_1_1_ENC_NAMESPACE":arrayType")-1)) != NULL && + arrayType->extraAttributes && + (ext = zend_hash_str_find_ptr(arrayType->extraAttributes, WSDL_NAMESPACE":arrayType", sizeof(WSDL_NAMESPACE":arrayType")-1)) != NULL) { char *type, *end; - type = estrdup((*ext)->val); + type = estrdup(ext->val); end = strrchr(type,'['); if (end) { *end = '\0'; } - if ((*ext)->ns != NULL) { - enc = get_encoder(SOAP_GLOBAL(sdl), (*ext)->ns, type); + if (ext->ns != NULL) { + enc = get_encoder(SOAP_GLOBAL(sdl), ext->ns, type); } efree(type); @@ -2647,50 +2571,45 @@ static zval *to_zval_array(encodeTypePtr type, xmlNodePtr data TSRMLS_DC) } else if (type->sdl_type != NULL && type->sdl_type->attributes != NULL && - zend_hash_find(type->sdl_type->attributes, SOAP_1_2_ENC_NAMESPACE":itemType", - sizeof(SOAP_1_2_ENC_NAMESPACE":itemType"), - (void **)&arrayType) == SUCCESS && - (*arrayType)->extraAttributes && - zend_hash_find((*arrayType)->extraAttributes, WSDL_NAMESPACE":itemType", sizeof(WSDL_NAMESPACE":itemType"), (void **)&ext) == SUCCESS) { - - if ((*ext)->ns != NULL) { - enc = get_encoder(SOAP_GLOBAL(sdl), (*ext)->ns, (*ext)->val); - } - - if (zend_hash_find(type->sdl_type->attributes, SOAP_1_2_ENC_NAMESPACE":arraySize", - sizeof(SOAP_1_2_ENC_NAMESPACE":arraySize"), - (void **)&arrayType) == SUCCESS && - (*arrayType)->extraAttributes && - zend_hash_find((*arrayType)->extraAttributes, WSDL_NAMESPACE":arraySize", sizeof(WSDL_NAMESPACE":arraysize"), (void **)&ext) == SUCCESS) { - dimension = calc_dimension_12((*ext)->val); - dims = get_position_12(dimension, (*ext)->val); + (arrayType = zend_hash_str_find_ptr(type->sdl_type->attributes, SOAP_1_2_ENC_NAMESPACE":itemType", + sizeof(SOAP_1_2_ENC_NAMESPACE":itemType")-1)) != NULL && + arrayType->extraAttributes && + (ext = zend_hash_str_find_ptr(arrayType->extraAttributes, WSDL_NAMESPACE":itemType", sizeof(WSDL_NAMESPACE":itemType")-1)) != NULL) { + + if (ext->ns != NULL) { + enc = get_encoder(SOAP_GLOBAL(sdl), ext->ns, ext->val); + } + + if ((arrayType = zend_hash_str_find_ptr(type->sdl_type->attributes, SOAP_1_2_ENC_NAMESPACE":arraySize", + sizeof(SOAP_1_2_ENC_NAMESPACE":arraySize")-1)) != NULL && + arrayType->extraAttributes && + (ext = zend_hash_str_find_ptr(arrayType->extraAttributes, WSDL_NAMESPACE":arraySize", sizeof(WSDL_NAMESPACE":arraysize")-1)) != NULL) { + dimension = calc_dimension_12(ext->val); + dims = get_position_12(dimension, ext->val); } else { dims = emalloc(sizeof(int)); *dims = 0; } } else if (type->sdl_type != NULL && type->sdl_type->attributes != NULL && - zend_hash_find(type->sdl_type->attributes, SOAP_1_2_ENC_NAMESPACE":arraySize", - sizeof(SOAP_1_2_ENC_NAMESPACE":arraySize"), - (void **)&arrayType) == SUCCESS && - (*arrayType)->extraAttributes && - zend_hash_find((*arrayType)->extraAttributes, WSDL_NAMESPACE":arraySize", sizeof(WSDL_NAMESPACE":arraysize"), (void **)&ext) == SUCCESS) { - - dimension = calc_dimension_12((*ext)->val); - dims = get_position_12(dimension, (*ext)->val); + (arrayType = zend_hash_str_find_ptr(type->sdl_type->attributes, SOAP_1_2_ENC_NAMESPACE":arraySize", + sizeof(SOAP_1_2_ENC_NAMESPACE":arraySize")-1)) != NULL && + arrayType->extraAttributes && + (ext = zend_hash_str_find_ptr(arrayType->extraAttributes, WSDL_NAMESPACE":arraySize", sizeof(WSDL_NAMESPACE":arraysize")-1)) != NULL) { + + dimension = calc_dimension_12(ext->val); + dims = get_position_12(dimension, ext->val); if (type->sdl_type && type->sdl_type->elements && zend_hash_num_elements(type->sdl_type->elements) == 1 && (zend_hash_internal_pointer_reset(type->sdl_type->elements), - zend_hash_get_current_data(type->sdl_type->elements, (void**)&elementType) == SUCCESS) && - (elementType = *(sdlTypePtr*)elementType) != NULL && + (elementType = zend_hash_get_current_data_ptr(type->sdl_type->elements)) != NULL) && elementType->encode) { enc = elementType->encode; } } else if (type->sdl_type && type->sdl_type->elements && zend_hash_num_elements(type->sdl_type->elements) == 1 && (zend_hash_internal_pointer_reset(type->sdl_type->elements), - zend_hash_get_current_data(type->sdl_type->elements, (void**)&elementType) == SUCCESS) && - (elementType = *(sdlTypePtr*)elementType) != NULL && + (elementType = zend_hash_get_current_data_ptr(type->sdl_type->elements)) != NULL) && elementType->encode) { enc = elementType->encode; } @@ -2717,10 +2636,10 @@ static zval *to_zval_array(encodeTypePtr type, xmlNodePtr data TSRMLS_DC) while (trav) { if (trav->type == XML_ELEMENT_NODE) { int i; - zval *tmpVal, *ar; + zval tmpVal, *ar; xmlAttrPtr position = get_attribute(trav->properties,"position"); - tmpVal = master_to_zval(enc, trav TSRMLS_CC); + master_to_zval(&tmpVal, enc, trav TSRMLS_CC); if (position != NULL && position->children && position->children->content) { char* tmp = strrchr((char*)position->children->content, '['); if (tmp == NULL) { @@ -2733,19 +2652,17 @@ static zval *to_zval_array(encodeTypePtr type, xmlNodePtr data TSRMLS_DC) i = 0; ar = ret; while (i < dimension-1) { - zval** ar2; - if (zend_hash_index_find(Z_ARRVAL_P(ar), pos[i], (void**)&ar2) == SUCCESS) { - ar = *ar2; + zval* ar2; + if ((ar2 = zend_hash_index_find(Z_ARRVAL_P(ar), pos[i])) != NULL) { + ar = ar2; } else { - zval *tmpAr; - MAKE_STD_ZVAL(tmpAr); - array_init(tmpAr); - zend_hash_index_update(Z_ARRVAL_P(ar), pos[i], &tmpAr, sizeof(zval*), (void**)&ar2); - ar = *ar2; + zval tmpAr; + array_init(&tmpAr); + ar = zend_hash_index_update(Z_ARRVAL_P(ar), pos[i], &tmpAr); } i++; } - zend_hash_index_update(Z_ARRVAL_P(ar), pos[i], &tmpVal, sizeof(zval *), NULL); + zend_hash_index_update(Z_ARRVAL_P(ar), pos[i], &tmpVal); /* Increment position */ i = dimension; @@ -2782,24 +2699,24 @@ static xmlNodePtr to_xml_map(encodeTypePtr type, zval *data, int style, xmlNodeP if (Z_TYPE_P(data) == IS_ARRAY) { i = zend_hash_num_elements(Z_ARRVAL_P(data)); - zend_hash_internal_pointer_reset(data->value.ht); + zend_hash_internal_pointer_reset(Z_ARRVAL_P(data)); for (;i > 0;i--) { xmlNodePtr xparam, item; xmlNodePtr key; - zval **temp_data; - char *key_val; + zval *temp_data; + zend_string *key_val; ulong int_val; - zend_hash_get_current_data(data->value.ht, (void **)&temp_data); + temp_data = zend_hash_get_current_data(Z_ARRVAL_P(data)); item = xmlNewNode(NULL, BAD_CAST("item")); xmlAddChild(xmlParam, item); key = xmlNewNode(NULL, BAD_CAST("key")); xmlAddChild(item,key); - if (zend_hash_get_current_key(data->value.ht, &key_val, &int_val, FALSE) == HASH_KEY_IS_STRING) { + if (zend_hash_get_current_key(Z_ARRVAL_P(data), &key_val, &int_val, FALSE) == HASH_KEY_IS_STRING) { if (style == SOAP_ENCODED) { set_xsi_type(key, "xsd:string"); } - xmlNodeSetContent(key, BAD_CAST(key_val)); + xmlNodeSetContent(key, BAD_CAST(key_val->val)); } else { smart_str tmp = {0}; smart_str_append_long(&tmp, int_val); @@ -2808,15 +2725,15 @@ static xmlNodePtr to_xml_map(encodeTypePtr type, zval *data, int style, xmlNodeP if (style == SOAP_ENCODED) { set_xsi_type(key, "xsd:int"); } - xmlNodeSetContentLen(key, BAD_CAST(tmp.c), tmp.len); + xmlNodeSetContentLen(key, BAD_CAST(tmp.s->val), tmp.s->len); smart_str_free(&tmp); } - xparam = master_to_xml(get_conversion((*temp_data)->type), (*temp_data), style, item TSRMLS_CC); + xparam = master_to_xml(get_conversion(Z_TYPE_P(temp_data)), temp_data, style, item TSRMLS_CC); xmlNodeSetName(xparam, BAD_CAST("value")); - zend_hash_move_forward(data->value.ht); + zend_hash_move_forward(Z_ARRVAL_P(data)); } } if (style == SOAP_ENCODED) { @@ -2826,12 +2743,12 @@ static xmlNodePtr to_xml_map(encodeTypePtr type, zval *data, int style, xmlNodeP return xmlParam; } -static zval *to_zval_map(encodeTypePtr type, xmlNodePtr data TSRMLS_DC) +static zval *to_zval_map(zval *ret, encodeTypePtr type, xmlNodePtr data TSRMLS_DC) { - zval *ret, *key, *value; + zval key, value; xmlNodePtr trav, item, xmlKey, xmlValue; - MAKE_STD_ZVAL(ret); + ZVAL_NULL(ret); FIND_XML_NULL(data, ret); if (data && data->children) { @@ -2850,13 +2767,13 @@ static zval *to_zval_map(encodeTypePtr type, xmlNodePtr data TSRMLS_DC) soap_error0(E_ERROR, "Encoding: Can't decode apache map, missing value"); } - key = master_to_zval(NULL, xmlKey TSRMLS_CC); - value = master_to_zval(NULL, xmlValue TSRMLS_CC); + master_to_zval(&key, NULL, xmlKey TSRMLS_CC); + master_to_zval(&value, NULL, xmlValue TSRMLS_CC); - if (Z_TYPE_P(key) == IS_STRING) { - zend_symtable_update(Z_ARRVAL_P(ret), Z_STRVAL_P(key), Z_STRLEN_P(key) + 1, &value, sizeof(zval *), NULL); - } else if (Z_TYPE_P(key) == IS_LONG) { - zend_hash_index_update(Z_ARRVAL_P(ret), Z_LVAL_P(key), &value, sizeof(zval *), NULL); + if (Z_TYPE(key) == IS_STRING) { + zend_symtable_update(Z_ARRVAL_P(ret), Z_STR(key), &value); + } else if (Z_TYPE(key) == IS_LONG) { + zend_hash_index_update(Z_ARRVAL_P(ret), Z_LVAL(key), &value); } else { soap_error0(E_ERROR, "Encoding: Can't decode apache map, only Strings or Longs are allowd as keys"); } @@ -2876,7 +2793,7 @@ static xmlNodePtr guess_xml_convert(encodeTypePtr type, zval *data, int style, x xmlNodePtr ret; if (data) { - enc = get_conversion(data->type); + enc = get_conversion(Z_TYPE_P(data)); } else { enc = get_conversion(IS_NULL); } @@ -2889,12 +2806,11 @@ static xmlNodePtr guess_xml_convert(encodeTypePtr type, zval *data, int style, x return ret; } -static zval *guess_zval_convert(encodeTypePtr type, xmlNodePtr data TSRMLS_DC) +static zval *guess_zval_convert(zval *ret, encodeTypePtr type, xmlNodePtr data TSRMLS_DC) { encodePtr enc = NULL; xmlAttrPtr tmpattr; xmlChar *type_name = NULL; - zval *ret; data = check_and_resolve_href(data); @@ -2947,26 +2863,25 @@ static zval *guess_zval_convert(encodeTypePtr type, xmlNodePtr data TSRMLS_DC) } } } - ret = master_to_zval_int(enc, data TSRMLS_CC); + master_to_zval_int(ret, enc, data TSRMLS_CC); if (SOAP_GLOBAL(sdl) && type_name && enc->details.sdl_type) { - zval* soapvar; + zval soapvar; char *ns, *cptype; xmlNsPtr nsptr; - MAKE_STD_ZVAL(soapvar); - object_init_ex(soapvar, soap_var_class_entry); - add_property_long(soapvar, "enc_type", enc->details.type); + object_init_ex(&soapvar, soap_var_class_entry); + add_property_long(&soapvar, "enc_type", enc->details.type); Z_DELREF_P(ret); - add_property_zval(soapvar, "enc_value", ret); + add_property_zval(&soapvar, "enc_value", ret); parse_namespace(type_name, &cptype, &ns); nsptr = xmlSearchNs(data->doc, data, BAD_CAST(ns)); - add_property_string(soapvar, "enc_stype", cptype); + add_property_string(&soapvar, "enc_stype", cptype); if (nsptr) { - add_property_string(soapvar, "enc_ns", (char*)nsptr->href); + add_property_string(&soapvar, "enc_ns", (char*)nsptr->href); } efree(cptype); if (ns) {efree(ns);} - ret = soapvar; + ZVAL_COPY_VALUE(ret, &soapvar); } return ret; } @@ -3083,9 +2998,9 @@ static xmlNodePtr to_xml_gmonth(encodeTypePtr type, zval *data, int style, xmlNo return to_xml_datetime_ex(type, data, "--%m--", style, parent TSRMLS_CC); } -static zval* to_zval_list(encodeTypePtr enc, xmlNodePtr data TSRMLS_DC) { +static zval* to_zval_list(zval *ret, encodeTypePtr enc, xmlNodePtr data TSRMLS_DC) { /*FIXME*/ - return to_zval_stringc(enc, data TSRMLS_CC); + return to_zval_stringc(ret, enc, data TSRMLS_CC); } static xmlNodePtr to_xml_list(encodeTypePtr enc, zval *data, int style, xmlNodePtr parent TSRMLS_DC) { @@ -3093,27 +3008,26 @@ static xmlNodePtr to_xml_list(encodeTypePtr enc, zval *data, int style, xmlNodeP encodePtr list_enc = NULL; if (enc->sdl_type && enc->sdl_type->kind == XSD_TYPEKIND_LIST && enc->sdl_type->elements) { - sdlTypePtr *type; + sdlTypePtr type; - zend_hash_internal_pointer_reset(enc->sdl_type->elements); - if (zend_hash_get_current_data(enc->sdl_type->elements, (void**)&type) == SUCCESS) { - list_enc = (*type)->encode; - } + ZEND_HASH_FOREACH_PTR(enc->sdl_type->elements, type) { + list_enc = type->encode; + break; + } ZEND_HASH_FOREACH_END(); } ret = xmlNewNode(NULL, BAD_CAST("BOGUS")); xmlAddChild(parent, ret); FIND_ZVAL_NULL(data, ret, style); if (Z_TYPE_P(data) == IS_ARRAY) { - zval **tmp; + zval *tmp; smart_str list = {0}; HashTable *ht = Z_ARRVAL_P(data); - zend_hash_internal_pointer_reset(ht); - while (zend_hash_get_current_data(ht, (void**)&tmp) == SUCCESS) { - xmlNodePtr dummy = master_to_xml(list_enc, *tmp, SOAP_LITERAL, ret TSRMLS_CC); + ZEND_HASH_FOREACH_VAL(ht, tmp) { + xmlNodePtr dummy = master_to_xml(list_enc, tmp, SOAP_LITERAL, ret TSRMLS_CC); if (dummy && dummy->children && dummy->children->content) { - if (list.len != 0) { + if (list.s && list.s->len != 0) { smart_str_appendc(&list, ' '); } smart_str_appends(&list, (char*)dummy->children->content); @@ -3122,10 +3036,9 @@ static xmlNodePtr to_xml_list(encodeTypePtr enc, zval *data, int style, xmlNodeP } xmlUnlinkNode(dummy); xmlFreeNode(dummy); - zend_hash_move_forward(ht); - } + } ZEND_HASH_FOREACH_END(); smart_str_0(&list); - xmlNodeSetContentLen(ret, BAD_CAST(list.c), list.len); + xmlNodeSetContentLen(ret, BAD_CAST(list.s->val), list.s->len); smart_str_free(&list); } else { zval tmp = *data; @@ -3149,10 +3062,11 @@ static xmlNodePtr to_xml_list(encodeTypePtr enc, zval *data, int style, xmlNodeP *next = '\0'; next++; } - ZVAL_STRING(&dummy_zval, start, 0); +//??? ZVAL_STRING(&dummy_zval, start, 0); + ZVAL_STRING(&dummy_zval, start); dummy = master_to_xml(list_enc, &dummy_zval, SOAP_LITERAL, ret TSRMLS_CC); if (dummy && dummy->children && dummy->children->content) { - if (list.len != 0) { + if (list.s && list.s->len != 0) { smart_str_appendc(&list, ' '); } smart_str_appends(&list, (char*)dummy->children->content); @@ -3165,7 +3079,7 @@ static xmlNodePtr to_xml_list(encodeTypePtr enc, zval *data, int style, xmlNodeP start = next; } smart_str_0(&list); - xmlNodeSetContentLen(ret, BAD_CAST(list.c), list.len); + xmlNodeSetContentLen(ret, BAD_CAST(list.s->val), list.s->len); smart_str_free(&list); efree(str); if (data == &tmp) {zval_dtor(&tmp);} @@ -3178,9 +3092,9 @@ static xmlNodePtr to_xml_list1(encodeTypePtr enc, zval *data, int style, xmlNode return to_xml_list(enc,data,style, parent TSRMLS_CC); } -static zval* to_zval_union(encodeTypePtr enc, xmlNodePtr data TSRMLS_DC) { +static zval* to_zval_union(zval *ret, encodeTypePtr enc, xmlNodePtr data TSRMLS_DC) { /*FIXME*/ - return to_zval_list(enc, data TSRMLS_CC); + return to_zval_list(ret, enc, data TSRMLS_CC); } static xmlNodePtr to_xml_union(encodeTypePtr enc, zval *data, int style, xmlNodePtr parent TSRMLS_DC) { @@ -3188,14 +3102,13 @@ static xmlNodePtr to_xml_union(encodeTypePtr enc, zval *data, int style, xmlNode return to_xml_list(enc,data,style, parent TSRMLS_CC); } -static zval *to_zval_any(encodeTypePtr type, xmlNodePtr data TSRMLS_DC) +static zval *to_zval_any(zval *ret, encodeTypePtr type, xmlNodePtr data TSRMLS_DC) { xmlBufferPtr buf; - zval *ret; if (SOAP_GLOBAL(sdl) && SOAP_GLOBAL(sdl)->elements && data->name) { smart_str nscat = {0}; - sdlTypePtr *sdl_type; + sdlTypePtr sdl_type; if (data->ns && data->ns->href) { smart_str_appends(&nscat, (char*)data->ns->href); @@ -3204,18 +3117,17 @@ static zval *to_zval_any(encodeTypePtr type, xmlNodePtr data TSRMLS_DC) smart_str_appends(&nscat, (char*)data->name); smart_str_0(&nscat); - if (zend_hash_find(SOAP_GLOBAL(sdl)->elements, nscat.c, nscat.len+1, (void **)&sdl_type) == SUCCESS && - (*sdl_type)->encode) { + if ((sdl_type = zend_hash_find_ptr(SOAP_GLOBAL(sdl)->elements, nscat.s)) != NULL && + sdl_type->encode) { smart_str_free(&nscat); - return master_to_zval_int((*sdl_type)->encode, data TSRMLS_CC); + return master_to_zval_int(ret, sdl_type->encode, data TSRMLS_CC); } smart_str_free(&nscat); } buf = xmlBufferCreate(); xmlNodeDump(buf, NULL, data, 0, 0); - MAKE_STD_ZVAL(ret); - ZVAL_STRING(ret, (char*)xmlBufferContent(buf), 1); + ZVAL_STRING(ret, (char*)xmlBufferContent(buf)); xmlBufferFree(buf); return ret; } @@ -3225,23 +3137,17 @@ static xmlNodePtr to_xml_any(encodeTypePtr type, zval *data, int style, xmlNodeP xmlNodePtr ret = NULL; if (Z_TYPE_P(data) == IS_ARRAY) { - HashPosition pos; - zval **el; + zval *el; encodePtr enc = get_conversion(XSD_ANYXML); - char *name; - uint name_len; - ulong idx; - - for (zend_hash_internal_pointer_reset_ex(Z_ARRVAL_P(data), &pos); - zend_hash_get_current_data_ex(Z_ARRVAL_P(data), (void **) &el, &pos) == SUCCESS; - zend_hash_move_forward_ex(Z_ARRVAL_P(data), &pos)) { - ret = master_to_xml(enc, *el, style, parent TSRMLS_CC); + zend_string *name; + + ZEND_HASH_FOREACH_STR_KEY_VAL(Z_ARRVAL_P(data), name, el) { + ret = master_to_xml(enc, el, style, parent TSRMLS_CC); if (ret && - ret->name != xmlStringTextNoenc && - zend_hash_get_current_key_ex(Z_ARRVAL_P(data), &name, &name_len, &idx, 0, &pos) == HASH_KEY_IS_STRING) { - xmlNodeSetName(ret, BAD_CAST(name)); + ret->name != xmlStringTextNoenc) { + xmlNodeSetName(ret, BAD_CAST(name->val)); } - } + } ZEND_HASH_FOREACH_END(); return ret; } if (Z_TYPE_P(data) == IS_STRING) { @@ -3270,13 +3176,13 @@ static xmlNodePtr to_xml_any(encodeTypePtr type, zval *data, int style, xmlNodeP return ret; } -zval *sdl_guess_convert_zval(encodeTypePtr enc, xmlNodePtr data TSRMLS_DC) +zval *sdl_guess_convert_zval(zval *ret, encodeTypePtr enc, xmlNodePtr data TSRMLS_DC) { sdlTypePtr type; type = enc->sdl_type; if (type == NULL) { - return guess_zval_convert(enc, data TSRMLS_CC); + return guess_zval_convert(ret, enc, data TSRMLS_CC); } /*FIXME: restriction support if (type && type->restrictions && @@ -3310,27 +3216,27 @@ zval *sdl_guess_convert_zval(encodeTypePtr enc, xmlNodePtr data TSRMLS_DC) switch (type->kind) { case XSD_TYPEKIND_SIMPLE: if (type->encode && enc != &type->encode->details) { - return master_to_zval_int(type->encode, data TSRMLS_CC); + return master_to_zval_int(ret, type->encode, data TSRMLS_CC); } else { - return guess_zval_convert(enc, data TSRMLS_CC); + return guess_zval_convert(ret, enc, data TSRMLS_CC); } break; case XSD_TYPEKIND_LIST: - return to_zval_list(enc, data TSRMLS_CC); + return to_zval_list(ret, enc, data TSRMLS_CC); case XSD_TYPEKIND_UNION: - return to_zval_union(enc, data TSRMLS_CC); + return to_zval_union(ret, enc, data TSRMLS_CC); case XSD_TYPEKIND_COMPLEX: case XSD_TYPEKIND_RESTRICTION: case XSD_TYPEKIND_EXTENSION: if (type->encode && (type->encode->details.type == IS_ARRAY || type->encode->details.type == SOAP_ENC_ARRAY)) { - return to_zval_array(enc, data TSRMLS_CC); + return to_zval_array(ret, enc, data TSRMLS_CC); } - return to_zval_object(enc, data TSRMLS_CC); + return to_zval_object(ret, enc, data TSRMLS_CC); default: soap_error0(E_ERROR, "Encoding: Internal Error"); - return guess_zval_convert(enc, data TSRMLS_CC); + return guess_zval_convert(ret, enc, data TSRMLS_CC); } } @@ -3462,7 +3368,7 @@ static void set_ns_and_type_ex(xmlNodePtr node, char *ns, char *type) { smart_str nstype = {0}; get_type_str(node, ns, type, &nstype); - set_xsi_type(node, nstype.c); + set_xsi_type(node, nstype.s->val); smart_str_free(&nstype); } @@ -3519,7 +3425,7 @@ xmlNsPtr encode_add_ns(xmlNodePtr node, const char* ns) xmlChar* prefix; TSRMLS_FETCH(); - if (zend_hash_find(&SOAP_GLOBAL(defEncNs), (char*)ns, strlen(ns) + 1, (void **)&prefix) == SUCCESS) { + if ((prefix = zend_hash_str_find_ptr(&SOAP_GLOBAL(defEncNs), (char*)ns, strlen(ns))) != NULL) { xmlns = xmlNewNs(node->doc->children, BAD_CAST(ns), prefix); } else { smart_str prefix = {0}; @@ -3529,16 +3435,15 @@ xmlNsPtr encode_add_ns(xmlNodePtr node, const char* ns) smart_str_appendl(&prefix, "ns", 2); smart_str_append_long(&prefix, num); smart_str_0(&prefix); - if (xmlSearchNs(node->doc, node, BAD_CAST(prefix.c)) == NULL) { + if (xmlSearchNs(node->doc, node, BAD_CAST(prefix.s->val)) == NULL) { break; } smart_str_free(&prefix); - prefix.c = NULL; - prefix.len = 0; + prefix.s = NULL; num = ++SOAP_GLOBAL(cur_uniq_ns); } - xmlns = xmlNewNs(node->doc->children, BAD_CAST(ns), BAD_CAST(prefix.c)); + xmlns = xmlNewNs(node->doc->children, BAD_CAST(ns), BAD_CAST(prefix.s ? prefix.s->val : "")); smart_str_free(&prefix); } } @@ -3587,14 +3492,14 @@ void encode_finish() encodePtr get_conversion(int encode) { - encodePtr *enc = NULL; + encodePtr enc; TSRMLS_FETCH(); - if (zend_hash_index_find(&SOAP_GLOBAL(defEncIndex), encode, (void **)&enc) == FAILURE) { + if ((enc = zend_hash_index_find_ptr(&SOAP_GLOBAL(defEncIndex), encode)) == NULL) { soap_error0(E_ERROR, "Encoding: Cannot find encoding"); return NULL; } else { - return *enc; + return enc; } } @@ -3604,10 +3509,10 @@ static int is_map(zval *array) zend_hash_internal_pointer_reset(Z_ARRVAL_P(array)); for (i = 0; i < count; i++) { - char *str_index; + zend_string *_str_index; ulong num_index; - if (zend_hash_get_current_key(Z_ARRVAL_P(array), &str_index, &num_index, 0) == HASH_KEY_IS_STRING || + if (zend_hash_get_current_key(Z_ARRVAL_P(array), &_str_index, &num_index, 0) == HASH_KEY_IS_STRING || num_index != i) { return TRUE; } @@ -3620,7 +3525,7 @@ static encodePtr get_array_type(xmlNodePtr node, zval *array, smart_str *type TS { HashTable *ht; int i, count, cur_type, prev_type, different; - zval **tmp; + zval *tmp; char *prev_stype = NULL, *cur_stype = NULL, *prev_ns = NULL, *cur_ns = NULL; if (!array || Z_TYPE_P(array) != IS_ARRAY) { @@ -3635,35 +3540,35 @@ static encodePtr get_array_type(xmlNodePtr node, zval *array, smart_str *type TS zend_hash_internal_pointer_reset(ht); for (i = 0;i < count;i++) { - zend_hash_get_current_data(ht, (void **)&tmp); + tmp = zend_hash_get_current_data(ht); - if (Z_TYPE_PP(tmp) == IS_OBJECT && - Z_OBJCE_PP(tmp) == soap_var_class_entry) { - zval **ztype; + if (Z_TYPE_P(tmp) == IS_OBJECT && + Z_OBJCE_P(tmp) == soap_var_class_entry) { + zval *ztype; - if (zend_hash_find(Z_OBJPROP_PP(tmp), "enc_type", sizeof("enc_type"), (void **)&ztype) == FAILURE) { + if ((ztype = zend_hash_str_find(Z_OBJPROP_P(tmp), "enc_type", sizeof("enc_type")-1)) == NULL) { soap_error0(E_ERROR, "Encoding: SoapVar has no 'enc_type' property"); } - cur_type = Z_LVAL_PP(ztype); + cur_type = Z_LVAL_P(ztype); - if (zend_hash_find(Z_OBJPROP_PP(tmp), "enc_stype", sizeof("enc_stype"), (void **)&ztype) == SUCCESS) { - cur_stype = Z_STRVAL_PP(ztype); + if ((ztype = zend_hash_str_find(Z_OBJPROP_P(tmp), "enc_stype", sizeof("enc_stype")-1)) != NULL) { + cur_stype = Z_STRVAL_P(ztype); } else { cur_stype = NULL; } - if (zend_hash_find(Z_OBJPROP_PP(tmp), "enc_ns", sizeof("enc_ns"), (void **)&ztype) == SUCCESS) { - cur_ns = Z_STRVAL_PP(ztype); + if ((ztype = zend_hash_str_find(Z_OBJPROP_P(tmp), "enc_ns", sizeof("enc_ns")-1)) != NULL) { + cur_ns = Z_STRVAL_P(ztype); } else { cur_ns = NULL; } - } else if (Z_TYPE_PP(tmp) == IS_ARRAY && is_map(*tmp)) { + } else if (Z_TYPE_P(tmp) == IS_ARRAY && is_map(tmp)) { cur_type = APACHE_MAP; cur_stype = NULL; cur_ns = NULL; } else { - cur_type = Z_TYPE_PP(tmp); + cur_type = Z_TYPE_P(tmp); cur_stype = NULL; cur_ns = NULL; } @@ -3707,7 +3612,7 @@ static encodePtr get_array_type(xmlNodePtr node, zval *array, smart_str *type TS smart_str_appends(&array_type, cur_stype); smart_str_0(&array_type); - enc = get_encoder_ex(SOAP_GLOBAL(sdl), array_type.c, array_type.len); + enc = get_encoder_ex(SOAP_GLOBAL(sdl), array_type.s->val, array_type.s->len); smart_str_free(&array_type); return enc; } else { @@ -3743,18 +3648,14 @@ static void delete_mapping(void *data) { soapMappingPtr map = (soapMappingPtr)data; - if (map->to_xml) { - zval_ptr_dtor(&map->to_xml); - } - if (map->to_zval) { - zval_ptr_dtor(&map->to_zval); - } + zval_ptr_dtor(&map->to_xml); + zval_ptr_dtor(&map->to_zval); efree(map); } -void delete_encoder(void *encode) +void delete_encoder(zval *zv) { - encodePtr t = *((encodePtr*)encode); + encodePtr t = Z_PTR_P(zv); if (t->details.ns) { efree(t->details.ns); } @@ -3767,9 +3668,9 @@ void delete_encoder(void *encode) efree(t); } -void delete_encoder_persistent(void *encode) +void delete_encoder_persistent(zval *zv) { - encodePtr t = *((encodePtr*)encode); + encodePtr t = Z_PTR_P(zv); if (t->details.ns) { free(t->details.ns); } |