static int le_wddx;
typedef struct {
- zval *data;
+ zval data;
enum {
ST_ARRAY,
ST_BOOLEAN,
if (stack->elements) {
for (i = 0; i < stack->top; i++) {
- if (((st_entry *)stack->elements[i])->data) {
- zval_ptr_dtor(&((st_entry *)stack->elements[i])->data);
- }
+ zval_ptr_dtor(&((st_entry *)stack->elements[i])->data);
if (((st_entry *)stack->elements[i])->varname) {
efree(((st_entry *)stack->elements[i])->varname);
}
/* {{{ release_wddx_packet_rsrc
*/
-static void release_wddx_packet_rsrc(zend_rsrc_list_entry *rsrc TSRMLS_DC)
+static void release_wddx_packet_rsrc(zend_resource *rsrc TSRMLS_DC)
{
smart_str *str = (smart_str *)rsrc->ptr;
smart_str_free(str);
PS_SERIALIZER_ENCODE_FUNC(wddx)
{
wddx_packet *packet;
+ zend_string *str;
PS_ENCODE_VARS;
packet = php_wddx_constructor();
php_wddx_add_chunk_static(packet, WDDX_STRUCT_S);
PS_ENCODE_LOOP(
- php_wddx_serialize_var(packet, *struc, key, key_length TSRMLS_CC);
+ php_wddx_serialize_var(packet, struc, key TSRMLS_CC);
);
php_wddx_add_chunk_static(packet, WDDX_STRUCT_E);
php_wddx_packet_end(packet);
- *newstr = php_wddx_gather(packet);
+ str = STR_COPY(packet->s);
php_wddx_destructor(packet);
-
- if (newlen) {
- *newlen = strlen(*newstr);
- }
- return SUCCESS;
+ return str;
}
/* }}} */
*/
PS_SERIALIZER_DECODE_FUNC(wddx)
{
- zval *retval;
- zval **ent;
- char *key;
- uint key_length;
- char tmp[128];
+ zval retval;
+ zval *ent;
+ zend_string *key;
ulong idx;
- int hash_type;
int ret;
if (vallen == 0) {
return SUCCESS;
}
- MAKE_STD_ZVAL(retval);
-
- if ((ret = php_wddx_deserialize_ex((char *)val, vallen, retval)) == SUCCESS) {
-
- for (zend_hash_internal_pointer_reset(Z_ARRVAL_P(retval));
- zend_hash_get_current_data(Z_ARRVAL_P(retval), (void **) &ent) == SUCCESS;
- zend_hash_move_forward(Z_ARRVAL_P(retval))) {
- hash_type = zend_hash_get_current_key_ex(Z_ARRVAL_P(retval), &key, &key_length, &idx, 0, NULL);
-
- switch (hash_type) {
- case HASH_KEY_IS_LONG:
- key_length = slprintf(tmp, sizeof(tmp), "%ld", idx) + 1;
- key = tmp;
- /* fallthru */
- case HASH_KEY_IS_STRING:
- php_set_session_var(key, key_length-1, *ent, NULL TSRMLS_CC);
- PS_ADD_VAR(key);
+ if ((ret = php_wddx_deserialize_ex(val, vallen, &retval)) == SUCCESS) {
+ ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL(retval), idx, key, ent) {
+ if (key == NULL) {
+ key = STR_ALLOC(MAX_LENGTH_OF_LONG, 0);
+ key->len = snprintf(key->val, key->len + 1, "%ld", idx);
}
- }
+ php_set_session_var(key, ent, NULL TSRMLS_CC);
+ PS_ADD_VAR(key);
+ } ZEND_HASH_FOREACH_END();
}
zval_ptr_dtor(&retval);
php_wddx_add_chunk_static(packet, WDDX_STRING_S);
if (Z_STRLEN_P(var) > 0) {
- char *buf;
- size_t buf_len;
+ zend_string *buf;
- buf = php_escape_html_entities(Z_STRVAL_P(var), Z_STRLEN_P(var), &buf_len, 0, ENT_QUOTES, NULL TSRMLS_CC);
+ buf = php_escape_html_entities(Z_STRVAL_P(var), Z_STRLEN_P(var), 0, ENT_QUOTES, NULL TSRMLS_CC);
- php_wddx_add_chunk_ex(packet, buf, buf_len);
+ php_wddx_add_chunk_ex(packet, buf->val, buf->len);
- efree(buf);
+ STR_RELEASE(buf);
}
php_wddx_add_chunk_static(packet, WDDX_STRING_E);
}
char tmp_buf[WDDX_BUF_LEN];
zval tmp;
- tmp = *var;
- zval_copy_ctor(&tmp);
+ ZVAL_DUP(&tmp, var);
convert_to_string(&tmp);
snprintf(tmp_buf, sizeof(tmp_buf), WDDX_NUMBER, Z_STRVAL(tmp));
- zval_dtor(&tmp);
+ zval_ptr_dtor(&tmp);
- php_wddx_add_chunk(packet, tmp_buf);
+ php_wddx_add_chunk(packet, tmp_buf);
}
/* }}} */
*/
static void php_wddx_serialize_boolean(wddx_packet *packet, zval *var)
{
- php_wddx_add_chunk(packet, Z_LVAL_P(var) ? WDDX_BOOLEAN_TRUE : WDDX_BOOLEAN_FALSE);
+ php_wddx_add_chunk(packet, Z_TYPE_P(var) == IS_TRUE ? WDDX_BOOLEAN_TRUE : WDDX_BOOLEAN_FALSE);
}
/* }}} */
static void php_wddx_serialize_object(wddx_packet *packet, zval *obj)
{
/* OBJECTS_FIXME */
- zval **ent, *fname, **varname;
- zval *retval = NULL;
- const char *key;
+ zval *ent, fname, *varname;
+ zval retval;
+ zend_string *key;
ulong idx;
char tmp_buf[WDDX_BUF_LEN];
HashTable *objhash, *sleephash;
TSRMLS_FETCH();
- MAKE_STD_ZVAL(fname);
- ZVAL_STRING(fname, "__sleep", 1);
-
+ ZVAL_STRING(&fname, "__sleep");
/*
* We try to call __sleep() method on object. It's supposed to return an
* array of property names to be serialized.
*/
- if (call_user_function_ex(CG(function_table), &obj, fname, &retval, 0, 0, 1, NULL TSRMLS_CC) == SUCCESS) {
- if (retval && (sleephash = HASH_OF(retval))) {
+ if (call_user_function_ex(CG(function_table), obj, &fname, &retval, 0, 0, 1, NULL TSRMLS_CC) == SUCCESS) {
+ if (!Z_ISUNDEF(retval) && (sleephash = HASH_OF(&retval))) {
PHP_CLASS_ATTRIBUTES;
PHP_SET_CLASS_ATTRIBUTES(obj);
snprintf(tmp_buf, WDDX_BUF_LEN, WDDX_VAR_S, PHP_CLASS_NAME_VAR);
php_wddx_add_chunk(packet, tmp_buf);
php_wddx_add_chunk_static(packet, WDDX_STRING_S);
- php_wddx_add_chunk_ex(packet, class_name, name_len);
+ php_wddx_add_chunk_ex(packet, class_name->val, class_name->len);
php_wddx_add_chunk_static(packet, WDDX_STRING_E);
php_wddx_add_chunk_static(packet, WDDX_VAR_E);
objhash = HASH_OF(obj);
- for (zend_hash_internal_pointer_reset(sleephash);
- zend_hash_get_current_data(sleephash, (void **)&varname) == SUCCESS;
- zend_hash_move_forward(sleephash)) {
- if (Z_TYPE_PP(varname) != IS_STRING) {
+ ZEND_HASH_FOREACH_VAL(sleephash, varname) {
+ if (Z_TYPE_P(varname) != IS_STRING) {
php_error_docref(NULL TSRMLS_CC, E_NOTICE, "__sleep should return an array only containing the names of instance-variables to serialize.");
continue;
}
- if (zend_hash_find(objhash, Z_STRVAL_PP(varname), Z_STRLEN_PP(varname)+1, (void **)&ent) == SUCCESS) {
- php_wddx_serialize_var(packet, *ent, Z_STRVAL_PP(varname), Z_STRLEN_PP(varname) TSRMLS_CC);
+ if ((ent = zend_hash_find(objhash, Z_STR_P(varname))) != NULL) {
+ php_wddx_serialize_var(packet, ent, Z_STR_P(varname) TSRMLS_CC);
}
- }
+ } ZEND_HASH_FOREACH_END();
php_wddx_add_chunk_static(packet, WDDX_STRUCT_E);
}
} else {
- uint key_len;
-
PHP_CLASS_ATTRIBUTES;
PHP_SET_CLASS_ATTRIBUTES(obj);
snprintf(tmp_buf, WDDX_BUF_LEN, WDDX_VAR_S, PHP_CLASS_NAME_VAR);
php_wddx_add_chunk(packet, tmp_buf);
php_wddx_add_chunk_static(packet, WDDX_STRING_S);
- php_wddx_add_chunk_ex(packet, class_name, name_len);
+ php_wddx_add_chunk_ex(packet, class_name->val, class_name->len);
php_wddx_add_chunk_static(packet, WDDX_STRING_E);
php_wddx_add_chunk_static(packet, WDDX_VAR_E);
PHP_CLEANUP_CLASS_ATTRIBUTES();
objhash = HASH_OF(obj);
- for (zend_hash_internal_pointer_reset(objhash);
- zend_hash_get_current_data(objhash, (void**)&ent) == SUCCESS;
- zend_hash_move_forward(objhash)) {
- if (*ent == obj) {
+ ZEND_HASH_FOREACH_KEY_VAL(objhash, idx, key, ent) {
+ if (ent == obj) {
continue;
}
-
- if (zend_hash_get_current_key_ex(objhash, &key, &key_len, &idx, 0, NULL) == HASH_KEY_IS_STRING) {
+ if (key) {
const char *class_name, *prop_name;
+ zend_string *tmp;
- zend_unmangle_property_name(key, key_len-1, &class_name, &prop_name);
- php_wddx_serialize_var(packet, *ent, prop_name, strlen(prop_name)+1 TSRMLS_CC);
+ zend_unmangle_property_name(key->val, key->len, &class_name, &prop_name);
+ tmp = STR_INIT(prop_name, strlen(prop_name), 0);
+ php_wddx_serialize_var(packet, ent, tmp TSRMLS_CC);
+ STR_RELEASE(tmp);
} else {
- key_len = slprintf(tmp_buf, sizeof(tmp_buf), "%ld", idx);
- php_wddx_serialize_var(packet, *ent, tmp_buf, key_len TSRMLS_CC);
+ key = STR_ALLOC(MAX_LENGTH_OF_LONG, 0);
+ key->len = snprintf(key->val, key->len + 1, "%ld", idx);
+ php_wddx_serialize_var(packet, ent, key TSRMLS_CC);
+ STR_RELEASE(key);
}
- }
+ } ZEND_HASH_FOREACH_END();
php_wddx_add_chunk_static(packet, WDDX_STRUCT_E);
}
- zval_dtor(fname);
- FREE_ZVAL(fname);
-
- if (retval) {
- zval_ptr_dtor(&retval);
- }
+ zval_ptr_dtor(&fname);
+ zval_ptr_dtor(&retval);
}
/* }}} */
*/
static void php_wddx_serialize_array(wddx_packet *packet, zval *arr)
{
- zval **ent;
- char *key;
- uint key_len;
- int is_struct = 0, ent_type;
+ zval *ent;
+ zend_string *key;
+ int is_struct = 0;
ulong idx;
HashTable *target_hash;
char tmp_buf[WDDX_BUF_LEN];
ulong ind = 0;
- int type;
TSRMLS_FETCH();
target_hash = HASH_OF(arr);
-
- for (zend_hash_internal_pointer_reset(target_hash);
- zend_hash_get_current_data(target_hash, (void**)&ent) == SUCCESS;
- zend_hash_move_forward(target_hash)) {
-
- type = zend_hash_get_current_key(target_hash, &key, &idx, 0);
-
- if (type == HASH_KEY_IS_STRING) {
+ ZEND_HASH_FOREACH_KEY(target_hash, idx, key) {
+ if (key) {
is_struct = 1;
break;
}
is_struct = 1;
break;
}
-
ind++;
- }
+ } ZEND_HASH_FOREACH_END();
if (is_struct) {
php_wddx_add_chunk_static(packet, WDDX_STRUCT_S);
php_wddx_add_chunk(packet, tmp_buf);
}
- for (zend_hash_internal_pointer_reset(target_hash);
- zend_hash_get_current_data(target_hash, (void**)&ent) == SUCCESS;
- zend_hash_move_forward(target_hash)) {
- if (*ent == arr) {
+ ZEND_HASH_FOREACH_KEY_VAL(target_hash, idx, key, ent) {
+ if (ent == arr) {
continue;
}
if (is_struct) {
- ent_type = zend_hash_get_current_key_ex(target_hash, &key, &key_len, &idx, 0, NULL);
-
- if (ent_type == HASH_KEY_IS_STRING) {
- php_wddx_serialize_var(packet, *ent, key, key_len TSRMLS_CC);
+ if (key) {
+ php_wddx_serialize_var(packet, ent, key TSRMLS_CC);
} else {
- key_len = slprintf(tmp_buf, sizeof(tmp_buf), "%ld", idx);
- php_wddx_serialize_var(packet, *ent, tmp_buf, key_len TSRMLS_CC);
+ key = STR_ALLOC(MAX_LENGTH_OF_LONG, 0);
+ key->len = snprintf(key->val, key->len + 1, "%ld", idx);
+ php_wddx_serialize_var(packet, ent, key TSRMLS_CC);
+ STR_RELEASE(key);
}
} else {
- php_wddx_serialize_var(packet, *ent, NULL, 0 TSRMLS_CC);
+ php_wddx_serialize_var(packet, ent, NULL TSRMLS_CC);
}
- }
+ } ZEND_HASH_FOREACH_END();
if (is_struct) {
php_wddx_add_chunk_static(packet, WDDX_STRUCT_E);
/* {{{ php_wddx_serialize_var
*/
-void php_wddx_serialize_var(wddx_packet *packet, zval *var, char *name, int name_len TSRMLS_DC)
+void php_wddx_serialize_var(wddx_packet *packet, zval *var, zend_string *name TSRMLS_DC)
{
HashTable *ht;
if (name) {
- size_t name_esc_len;
- char *tmp_buf, *name_esc;
+ char *tmp_buf;
+ zend_string *name_esc;
- name_esc = php_escape_html_entities(name, name_len, &name_esc_len, 0, ENT_QUOTES, NULL TSRMLS_CC);
- tmp_buf = emalloc(name_esc_len + sizeof(WDDX_VAR_S));
- snprintf(tmp_buf, name_esc_len + sizeof(WDDX_VAR_S), WDDX_VAR_S, name_esc);
+ name_esc = php_escape_html_entities(name->val, name->len, 0, ENT_QUOTES, NULL TSRMLS_CC);
+ tmp_buf = emalloc(name_esc->len + sizeof(WDDX_VAR_S));
+ snprintf(tmp_buf, name_esc->len + sizeof(WDDX_VAR_S), WDDX_VAR_S, name_esc->val);
php_wddx_add_chunk(packet, tmp_buf);
efree(tmp_buf);
- efree(name_esc);
+ STR_RELEASE(name_esc);
}
- switch(Z_TYPE_P(var)) {
+ switch (Z_TYPE_P(var)) {
case IS_STRING:
php_wddx_serialize_string(packet, var TSRMLS_CC);
break;
php_wddx_serialize_number(packet, var);
break;
- case IS_BOOL:
+ case IS_TRUE:
+ case IS_FALSE:
php_wddx_serialize_boolean(packet, var);
break;
case IS_ARRAY:
ht = Z_ARRVAL_P(var);
- if (ht->nApplyCount > 1) {
+ if (ht->u.v.nApplyCount > 1) {
php_error_docref(NULL TSRMLS_CC, E_RECOVERABLE_ERROR, "WDDX doesn't support circular references");
return;
}
- ht->nApplyCount++;
+ ht->u.v.nApplyCount++;
php_wddx_serialize_array(packet, var);
- ht->nApplyCount--;
+ ht->u.v.nApplyCount--;
break;
case IS_OBJECT:
ht = Z_OBJPROP_P(var);
- if (ht->nApplyCount > 1) {
+ if (ht->u.v.nApplyCount > 1) {
php_error_docref(NULL TSRMLS_CC, E_RECOVERABLE_ERROR, "WDDX doesn't support circular references");
return;
}
- ht->nApplyCount++;
+ ht->u.v.nApplyCount++;
php_wddx_serialize_object(packet, var);
- ht->nApplyCount--;
+ ht->u.v.nApplyCount--;
break;
}
*/
static void php_wddx_add_var(wddx_packet *packet, zval *name_var)
{
- zval **val;
+ zval *val;
HashTable *target_hash;
TSRMLS_FETCH();
if (!EG(active_symbol_table)) {
zend_rebuild_symbol_table(TSRMLS_C);
}
- if (zend_hash_find(EG(active_symbol_table), Z_STRVAL_P(name_var),
- Z_STRLEN_P(name_var)+1, (void**)&val) != FAILURE) {
- php_wddx_serialize_var(packet, *val, Z_STRVAL_P(name_var), Z_STRLEN_P(name_var) TSRMLS_CC);
+ if ((val = zend_hash_find(&EG(active_symbol_table)->ht, Z_STR_P(name_var))) != NULL) {
+ php_wddx_serialize_var(packet, val, Z_STR_P(name_var) TSRMLS_CC);
}
} else if (Z_TYPE_P(name_var) == IS_ARRAY || Z_TYPE_P(name_var) == IS_OBJECT) {
int is_array = Z_TYPE_P(name_var) == IS_ARRAY;
target_hash = HASH_OF(name_var);
- if (is_array && target_hash->nApplyCount > 1) {
+ if (is_array && target_hash->u.v.nApplyCount > 1) {
php_error_docref(NULL TSRMLS_CC, E_WARNING, "recursion detected");
return;
}
- zend_hash_internal_pointer_reset(target_hash);
-
- while(zend_hash_get_current_data(target_hash, (void**)&val) == SUCCESS) {
+ ZEND_HASH_FOREACH_VAL(target_hash, val) {
if (is_array) {
- target_hash->nApplyCount++;
+ target_hash->u.v.nApplyCount++;
}
- php_wddx_add_var(packet, *val);
+ php_wddx_add_var(packet, val);
if (is_array) {
- target_hash->nApplyCount--;
+ target_hash->u.v.nApplyCount--;
}
- zend_hash_move_forward(target_hash);
- }
+ } ZEND_HASH_FOREACH_END();
}
}
/* }}} */
st_entry ent;
wddx_stack *stack = (wddx_stack *)user_data;
- if (!strcmp(name, EL_PACKET)) {
+ if (!strcmp((char *)name, EL_PACKET)) {
int i;
if (atts) for (i=0; atts[i]; i++) {
- if (!strcmp(atts[i], EL_VERSION)) {
+ if (!strcmp((char *)atts[i], EL_VERSION)) {
/* nothing for now */
}
}
- } else if (!strcmp(name, EL_STRING)) {
+ } else if (!strcmp((char *)name, EL_STRING)) {
ent.type = ST_STRING;
SET_STACK_VARNAME;
- ALLOC_ZVAL(ent.data);
- INIT_PZVAL(ent.data);
- Z_TYPE_P(ent.data) = IS_STRING;
- Z_STRVAL_P(ent.data) = STR_EMPTY_ALLOC();
- Z_STRLEN_P(ent.data) = 0;
+ ZVAL_STR(&ent.data, STR_EMPTY_ALLOC());
wddx_stack_push((wddx_stack *)stack, &ent, sizeof(st_entry));
- } else if (!strcmp(name, EL_BINARY)) {
+ } else if (!strcmp((char *)name, EL_BINARY)) {
ent.type = ST_BINARY;
SET_STACK_VARNAME;
- ALLOC_ZVAL(ent.data);
- INIT_PZVAL(ent.data);
- Z_TYPE_P(ent.data) = IS_STRING;
- Z_STRVAL_P(ent.data) = STR_EMPTY_ALLOC();
- Z_STRLEN_P(ent.data) = 0;
+ ZVAL_STR(&ent.data, STR_EMPTY_ALLOC());
wddx_stack_push((wddx_stack *)stack, &ent, sizeof(st_entry));
- } else if (!strcmp(name, EL_CHAR)) {
+ } else if (!strcmp((char *)name, EL_CHAR)) {
int i;
if (atts) for (i = 0; atts[i]; i++) {
- if (!strcmp(atts[i], EL_CHAR_CODE) && atts[++i] && atts[i][0]) {
+ if (!strcmp((char *)atts[i], EL_CHAR_CODE) && atts[++i] && atts[i][0]) {
char tmp_buf[2];
- snprintf(tmp_buf, sizeof(tmp_buf), "%c", (char)strtol(atts[i], NULL, 16));
+ snprintf(tmp_buf, sizeof(tmp_buf), "%c", (char)strtol((char *)atts[i], NULL, 16));
php_wddx_process_data(user_data, tmp_buf, strlen(tmp_buf));
break;
}
}
- } else if (!strcmp(name, EL_NUMBER)) {
+ } else if (!strcmp((char *)name, EL_NUMBER)) {
ent.type = ST_NUMBER;
SET_STACK_VARNAME;
- ALLOC_ZVAL(ent.data);
- INIT_PZVAL(ent.data);
- Z_TYPE_P(ent.data) = IS_LONG;
- Z_LVAL_P(ent.data) = 0;
+ ZVAL_LONG(&ent.data, 0);
wddx_stack_push((wddx_stack *)stack, &ent, sizeof(st_entry));
- } else if (!strcmp(name, EL_BOOLEAN)) {
+ } else if (!strcmp((char *)name, EL_BOOLEAN)) {
int i;
if (atts) for (i = 0; atts[i]; i++) {
- if (!strcmp(atts[i], EL_VALUE) && atts[++i] && atts[i][0]) {
+ if (!strcmp((char *)atts[i], EL_VALUE) && atts[++i] && atts[i][0]) {
ent.type = ST_BOOLEAN;
SET_STACK_VARNAME;
- ALLOC_ZVAL(ent.data);
- INIT_PZVAL(ent.data);
- Z_TYPE_P(ent.data) = IS_BOOL;
+ ZVAL_TRUE(&ent.data);
wddx_stack_push((wddx_stack *)stack, &ent, sizeof(st_entry));
- php_wddx_process_data(user_data, atts[i], strlen(atts[i]));
+ php_wddx_process_data(user_data, atts[i], strlen((char *)atts[i]));
break;
}
}
- } else if (!strcmp(name, EL_NULL)) {
+ } else if (!strcmp((char *)name, EL_NULL)) {
ent.type = ST_NULL;
SET_STACK_VARNAME;
- ALLOC_ZVAL(ent.data);
- INIT_PZVAL(ent.data);
- ZVAL_NULL(ent.data);
+ ZVAL_NULL(&ent.data);
wddx_stack_push((wddx_stack *)stack, &ent, sizeof(st_entry));
- } else if (!strcmp(name, EL_ARRAY)) {
+ } else if (!strcmp((char *)name, EL_ARRAY)) {
ent.type = ST_ARRAY;
SET_STACK_VARNAME;
- ALLOC_ZVAL(ent.data);
- array_init(ent.data);
- INIT_PZVAL(ent.data);
+ array_init(&ent.data);
wddx_stack_push((wddx_stack *)stack, &ent, sizeof(st_entry));
- } else if (!strcmp(name, EL_STRUCT)) {
+ } else if (!strcmp((char *)name, EL_STRUCT)) {
ent.type = ST_STRUCT;
SET_STACK_VARNAME;
-
- ALLOC_ZVAL(ent.data);
- array_init(ent.data);
- INIT_PZVAL(ent.data);
+ array_init(&ent.data);
wddx_stack_push((wddx_stack *)stack, &ent, sizeof(st_entry));
- } else if (!strcmp(name, EL_VAR)) {
+ } else if (!strcmp((char *)name, EL_VAR)) {
int i;
if (atts) for (i = 0; atts[i]; i++) {
- if (!strcmp(atts[i], EL_NAME) && atts[++i] && atts[i][0]) {
+ if (!strcmp((char *)atts[i], EL_NAME) && atts[++i] && atts[i][0]) {
stack->varname = estrdup(atts[i]);
break;
}
}
- } else if (!strcmp(name, EL_RECORDSET)) {
+ } else if (!strcmp((char *)name, EL_RECORDSET)) {
int i;
ent.type = ST_RECORDSET;
SET_STACK_VARNAME;
- MAKE_STD_ZVAL(ent.data);
- array_init(ent.data);
+ array_init(&ent.data);
if (atts) for (i = 0; atts[i]; i++) {
- if (!strcmp(atts[i], "fieldNames") && atts[++i] && atts[i][0]) {
- zval *tmp;
+ if (!strcmp((char *)atts[i], "fieldNames") && atts[++i] && atts[i][0]) {
+ zval tmp;
char *key;
char *p1, *p2, *endp;
p1 = (char *)atts[i];
while ((p2 = php_memnstr(p1, ",", sizeof(",")-1, endp)) != NULL) {
key = estrndup(p1, p2 - p1);
- MAKE_STD_ZVAL(tmp);
- array_init(tmp);
- add_assoc_zval_ex(ent.data, key, p2 - p1 + 1, tmp);
+ array_init(&tmp);
+ add_assoc_zval_ex(&ent.data, key, p2 - p1 + 1, &tmp);
p1 = p2 + sizeof(",")-1;
efree(key);
}
if (p1 <= endp) {
- MAKE_STD_ZVAL(tmp);
- array_init(tmp);
- add_assoc_zval_ex(ent.data, p1, endp - p1 + 1, tmp);
+ array_init(&tmp);
+ add_assoc_zval_ex(&ent.data, p1, endp - p1 + 1, &tmp);
}
break;
}
wddx_stack_push((wddx_stack *)stack, &ent, sizeof(st_entry));
- } else if (!strcmp(name, EL_FIELD)) {
+ } else if (!strcmp((char *)name, EL_FIELD)) {
int i;
st_entry ent;
ent.type = ST_FIELD;
ent.varname = NULL;
- ent.data = NULL;
+ ZVAL_UNDEF(&ent.data);
if (atts) for (i = 0; atts[i]; i++) {
- if (!strcmp(atts[i], EL_NAME) && atts[++i] && atts[i][0]) {
+ if (!strcmp((char *)atts[i], EL_NAME) && atts[++i] && atts[i][0]) {
st_entry *recordset;
- zval **field;
+ zval *field;
if (wddx_stack_top(stack, (void**)&recordset) == SUCCESS &&
recordset->type == ST_RECORDSET &&
- zend_hash_find(Z_ARRVAL_P(recordset->data), (char*)atts[i], strlen(atts[i])+1, (void**)&field) == SUCCESS) {
- ent.data = *field;
+ (field = zend_hash_str_find(Z_ARRVAL(recordset->data), (char*)atts[i], strlen(atts[i]))) != NULL) {
+ ZVAL_COPY_VALUE(&ent.data, field);
}
break;
}
wddx_stack_push((wddx_stack *)stack, &ent, sizeof(st_entry));
- } else if (!strcmp(name, EL_DATETIME)) {
+ } else if (!strcmp((char *)name, EL_DATETIME)) {
ent.type = ST_DATETIME;
SET_STACK_VARNAME;
- ALLOC_ZVAL(ent.data);
- INIT_PZVAL(ent.data);
- Z_TYPE_P(ent.data) = IS_LONG;
+ ZVAL_LONG(&ent.data, 0);
wddx_stack_push((wddx_stack *)stack, &ent, sizeof(st_entry));
}
}
st_entry *ent1, *ent2;
wddx_stack *stack = (wddx_stack *)user_data;
HashTable *target_hash;
- zend_class_entry **pce;
- zval *obj;
- zval *tmp;
+ zend_class_entry *pce;
+ zval obj;
TSRMLS_FETCH();
/* OBJECTS_FIXME */
return;
}
- if (!strcmp(name, EL_STRING) || !strcmp(name, EL_NUMBER) ||
- !strcmp(name, EL_BOOLEAN) || !strcmp(name, EL_NULL) ||
- !strcmp(name, EL_ARRAY) || !strcmp(name, EL_STRUCT) ||
- !strcmp(name, EL_RECORDSET) || !strcmp(name, EL_BINARY) ||
- !strcmp(name, EL_DATETIME)) {
+ if (!strcmp((char *)name, EL_STRING) || !strcmp((char *)name, EL_NUMBER) ||
+ !strcmp((char *)name, EL_BOOLEAN) || !strcmp((char *)name, EL_NULL) ||
+ !strcmp((char *)name, EL_ARRAY) || !strcmp((char *)name, EL_STRUCT) ||
+ !strcmp((char *)name, EL_RECORDSET) || !strcmp((char *)name, EL_BINARY) ||
+ !strcmp((char *)name, EL_DATETIME)) {
wddx_stack_top(stack, (void**)&ent1);
- if (!strcmp(name, EL_BINARY)) {
- int new_len=0;
- unsigned char *new_str;
+ if (!strcmp((char *)name, EL_BINARY)) {
+ zend_string *new_str;
- new_str = php_base64_decode(Z_STRVAL_P(ent1->data), Z_STRLEN_P(ent1->data), &new_len);
- STR_FREE(Z_STRVAL_P(ent1->data));
- Z_STRVAL_P(ent1->data) = new_str;
- Z_STRLEN_P(ent1->data) = new_len;
+ new_str = php_base64_decode(Z_STRVAL(ent1->data), Z_STRLEN(ent1->data));
+ zval_ptr_dtor(&ent1->data);
+ ZVAL_STR(&ent1->data, new_str);
}
/* Call __wakeup() method on the object. */
- if (Z_TYPE_P(ent1->data) == IS_OBJECT) {
- zval *fname, *retval = NULL;
+ if (Z_TYPE(ent1->data) == IS_OBJECT) {
+ zval fname, retval;
- MAKE_STD_ZVAL(fname);
- ZVAL_STRING(fname, "__wakeup", 1);
+ ZVAL_STRING(&fname, "__wakeup");
- call_user_function_ex(NULL, &ent1->data, fname, &retval, 0, 0, 0, NULL TSRMLS_CC);
+ call_user_function_ex(NULL, &ent1->data, &fname, &retval, 0, 0, 0, NULL TSRMLS_CC);
- zval_dtor(fname);
- FREE_ZVAL(fname);
- if (retval) {
- zval_ptr_dtor(&retval);
- }
+ zval_ptr_dtor(&fname);
+ zval_ptr_dtor(&retval);
}
if (stack->top > 1) {
wddx_stack_top(stack, (void**)&ent2);
/* if non-existent field */
- if (ent2->type == ST_FIELD && ent2->data == NULL) {
+ if (ent2->type == ST_FIELD && Z_ISUNDEF(ent2->data)) {
zval_ptr_dtor(&ent1->data);
efree(ent1);
return;
}
- if (Z_TYPE_P(ent2->data) == IS_ARRAY || Z_TYPE_P(ent2->data) == IS_OBJECT) {
- target_hash = HASH_OF(ent2->data);
+ if (Z_TYPE(ent2->data) == IS_ARRAY || Z_TYPE(ent2->data) == IS_OBJECT) {
+ target_hash = HASH_OF(&ent2->data);
if (ent1->varname) {
if (!strcmp(ent1->varname, PHP_CLASS_NAME_VAR) &&
- Z_TYPE_P(ent1->data) == IS_STRING && Z_STRLEN_P(ent1->data)) {
+ Z_TYPE(ent1->data) == IS_STRING && Z_STRLEN(ent1->data)) {
zend_bool incomplete_class = 0;
- zend_str_tolower(Z_STRVAL_P(ent1->data), Z_STRLEN_P(ent1->data));
- if (zend_hash_find(EG(class_table), Z_STRVAL_P(ent1->data),
- Z_STRLEN_P(ent1->data)+1, (void **) &pce)==FAILURE) {
+ zend_str_tolower(Z_STRVAL(ent1->data), Z_STRLEN(ent1->data));
+ if ((pce = zend_hash_find(EG(class_table), Z_STR(ent1->data))) == NULL) {
incomplete_class = 1;
- pce = &PHP_IC_ENTRY;
+ pce = PHP_IC_ENTRY;
}
/* Initialize target object */
- MAKE_STD_ZVAL(obj);
- object_init_ex(obj, *pce);
+ object_init_ex(&obj, pce);
/* Merge current hashtable with object's default properties */
- zend_hash_merge(Z_OBJPROP_P(obj),
- Z_ARRVAL_P(ent2->data),
- (void (*)(void *)) zval_add_ref,
- (void *) &tmp, sizeof(zval *), 0);
+ zend_hash_merge(Z_OBJPROP(obj),
+ Z_ARRVAL(ent2->data),
+ zval_add_ref, 0);
if (incomplete_class) {
- php_store_class_name(obj, Z_STRVAL_P(ent1->data), Z_STRLEN_P(ent1->data));
+ php_store_class_name(&obj, Z_STRVAL(ent1->data), Z_STRLEN(ent1->data));
}
/* Clean up old array entry */
zval_ptr_dtor(&ent2->data);
/* Set stack entry to point to the newly created object */
- ent2->data = obj;
+ ZVAL_COPY_VALUE(&ent2->data, &obj);
/* Clean up class name var entry */
zval_ptr_dtor(&ent1->data);
- } else if (Z_TYPE_P(ent2->data) == IS_OBJECT) {
+ } else if (Z_TYPE(ent2->data) == IS_OBJECT) {
zend_class_entry *old_scope = EG(scope);
- EG(scope) = Z_OBJCE_P(ent2->data);
- Z_DELREF_P(ent1->data);
- add_property_zval(ent2->data, ent1->varname, ent1->data);
+ EG(scope) = Z_OBJCE(ent2->data);
+ zval_ptr_dtor(&ent1->data);
+ add_property_zval(&ent2->data, ent1->varname, &ent1->data);
EG(scope) = old_scope;
} else {
- zend_symtable_update(target_hash, ent1->varname, strlen(ent1->varname)+1, &ent1->data, sizeof(zval *), NULL);
+ zend_symtable_str_update(target_hash, ent1->varname, strlen(ent1->varname), &ent1->data);
}
efree(ent1->varname);
} else {
- zend_hash_next_index_insert(target_hash, &ent1->data, sizeof(zval *), NULL);
+ zend_hash_next_index_insert(target_hash, &ent1->data);
}
}
efree(ent1);
} else {
stack->done = 1;
}
- } else if (!strcmp(name, EL_VAR) && stack->varname) {
+ } else if (!strcmp((char *)name, EL_VAR) && stack->varname) {
efree(stack->varname);
- } else if (!strcmp(name, EL_FIELD)) {
+ } else if (!strcmp((char *)name, EL_FIELD)) {
st_entry *ent;
wddx_stack_top(stack, (void **)&ent);
efree(ent);
if (!wddx_stack_is_empty(stack) && !stack->done) {
wddx_stack_top(stack, (void**)&ent);
- switch (Z_TYPE_P(ent)) {
- case ST_STRING:
- if (Z_STRLEN_P(ent->data) == 0) {
- STR_FREE(Z_STRVAL_P(ent->data));
- Z_STRVAL_P(ent->data) = estrndup(s, len);
- Z_STRLEN_P(ent->data) = len;
- } else {
- Z_STRVAL_P(ent->data) = erealloc(Z_STRVAL_P(ent->data), Z_STRLEN_P(ent->data) + len + 1);
- memcpy(Z_STRVAL_P(ent->data) + Z_STRLEN_P(ent->data), s, len);
- Z_STRLEN_P(ent->data) += len;
- Z_STRVAL_P(ent->data)[Z_STRLEN_P(ent->data)] = '\0';
- }
- break;
-
+ switch (ent->type) {
case ST_BINARY:
- if (Z_STRLEN_P(ent->data) == 0) {
- STR_FREE(Z_STRVAL_P(ent->data));
- Z_STRVAL_P(ent->data) = estrndup(s, len + 1);
+ case ST_STRING:
+ if (Z_STRLEN(ent->data) == 0) {
+ zval_ptr_dtor(&ent->data);
+ ZVAL_STRINGL(&ent->data, (char *)s, len);
} else {
- Z_STRVAL_P(ent->data) = erealloc(Z_STRVAL_P(ent->data), Z_STRLEN_P(ent->data) + len + 1);
- memcpy(Z_STRVAL_P(ent->data) + Z_STRLEN_P(ent->data), s, len);
+ Z_STR(ent->data) = STR_REALLOC(Z_STR(ent->data), Z_STRLEN(ent->data) + len, 0);
+ memcpy(Z_STRVAL(ent->data) + Z_STRLEN(ent->data) - len, (char *)s, len);
+ Z_STRVAL(ent->data)[Z_STRLEN(ent->data)] = '\0';
}
- Z_STRLEN_P(ent->data) += len;
- Z_STRVAL_P(ent->data)[Z_STRLEN_P(ent->data)] = '\0';
break;
-
case ST_NUMBER:
- Z_TYPE_P(ent->data) = IS_STRING;
- Z_STRLEN_P(ent->data) = len;
- Z_STRVAL_P(ent->data) = estrndup(s, len);
- convert_scalar_to_number(ent->data TSRMLS_CC);
+ ZVAL_STRINGL(&ent->data, (char *)s, len);
+ convert_scalar_to_number(&ent->data TSRMLS_CC);
break;
case ST_BOOLEAN:
- if (!strcmp(s, "true")) {
- Z_LVAL_P(ent->data) = 1;
- } else if (!strcmp(s, "false")) {
- Z_LVAL_P(ent->data) = 0;
+ if (!strcmp((char *)s, "true")) {
+ Z_LVAL(ent->data) = 1;
+ } else if (!strcmp((char *)s, "false")) {
+ Z_LVAL(ent->data) = 0;
} else {
stack->top--;
zval_ptr_dtor(&ent->data);
char *tmp;
tmp = emalloc(len + 1);
- memcpy(tmp, s, len);
+ memcpy(tmp, (char *)s, len);
tmp[len] = '\0';
- Z_LVAL_P(ent->data) = php_parse_date(tmp, NULL);
+ Z_LVAL(ent->data) = php_parse_date(tmp, NULL);
/* date out of range < 1969 or > 2038 */
- if (Z_LVAL_P(ent->data) == -1) {
- Z_TYPE_P(ent->data) = IS_STRING;
- Z_STRLEN_P(ent->data) = len;
- Z_STRVAL_P(ent->data) = estrndup(s, len);
+ if (Z_LVAL(ent->data) == -1) {
+ ZVAL_STRINGL(&ent->data, (char *)s, len);
}
efree(tmp);
}
if (stack.top == 1) {
wddx_stack_top(&stack, (void**)&ent);
- *return_value = *(ent->data);
- zval_copy_ctor(return_value);
+ ZVAL_COPY(return_value, &ent->data);
retval = SUCCESS;
} else {
retval = FAILURE;
packet = php_wddx_constructor();
php_wddx_packet_start(packet, comment, comment_len);
- php_wddx_serialize_var(packet, var, NULL, 0 TSRMLS_CC);
+ php_wddx_serialize_var(packet, var, NULL TSRMLS_CC);
php_wddx_packet_end(packet);
- ZVAL_STRINGL(return_value, packet->c, packet->len, 1);
- smart_str_free(packet);
- efree(packet);
+ RETVAL_STR(STR_COPY(packet->s));
+ php_wddx_destructor(packet);
}
/* }}} */
{
int num_args, i;
wddx_packet *packet;
- zval ***args = NULL;
+ zval *args = NULL;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "+", &args, &num_args) == FAILURE) {
return;
php_wddx_add_chunk_static(packet, WDDX_STRUCT_S);
for (i=0; i<num_args; i++) {
- if (Z_TYPE_PP(args[i]) != IS_ARRAY && Z_TYPE_PP(args[i]) != IS_OBJECT) {
- convert_to_string_ex(args[i]);
+ if (Z_TYPE(args[i]) != IS_ARRAY && Z_TYPE(args[i]) != IS_OBJECT) {
+ convert_to_string_ex(&args[i]);
}
- php_wddx_add_var(packet, *args[i]);
+ php_wddx_add_var(packet, &args[i]);
}
php_wddx_add_chunk_static(packet, WDDX_STRUCT_E);
php_wddx_packet_end(packet);
- efree(args);
-
- ZVAL_STRINGL(return_value, packet->c, packet->len, 1);
- smart_str_free(packet);
- efree(packet);
+ RETVAL_STR(STR_COPY(packet->s));
+ php_wddx_destructor(packet);
}
/* }}} */
{
smart_str *packet;
- packet = (smart_str *)emalloc(sizeof(smart_str));
- packet->c = NULL;
+ packet = ecalloc(1, sizeof(smart_str));
return packet;
}
return;
}
- ZEND_FETCH_RESOURCE(packet, wddx_packet *, &packet_id, -1, "WDDX packet ID", le_wddx);
+ ZEND_FETCH_RESOURCE(packet, wddx_packet *, packet_id, -1, "WDDX packet ID", le_wddx);
php_wddx_add_chunk_static(packet, WDDX_STRUCT_E);
php_wddx_packet_end(packet);
- ZVAL_STRINGL(return_value, packet->c, packet->len, 1);
+ RETVAL_STR(STR_COPY(packet->s));
- zend_list_delete(Z_LVAL_P(packet_id));
+ zend_list_delete(Z_RES_P(packet_id));
}
/* }}} */
PHP_FUNCTION(wddx_add_vars)
{
int num_args, i;
- zval ***args = NULL;
+ zval *args = NULL;
zval *packet_id;
wddx_packet *packet = NULL;
return;
}
- if (!ZEND_FETCH_RESOURCE_NO_RETURN(packet, wddx_packet *, &packet_id, -1, "WDDX packet ID", le_wddx)) {
- efree(args);
+ if (!ZEND_FETCH_RESOURCE_NO_RETURN(packet, wddx_packet *, packet_id, -1, "WDDX packet ID", le_wddx)) {
RETURN_FALSE;
}
if (!packet) {
- efree(args);
RETURN_FALSE;
}
for (i=0; i<num_args; i++) {
- if (Z_TYPE_PP(args[i]) != IS_ARRAY && Z_TYPE_PP(args[i]) != IS_OBJECT) {
- convert_to_string_ex(args[i]);
+ if (Z_TYPE(args[i]) != IS_ARRAY && Z_TYPE(args[i]) != IS_OBJECT) {
+ convert_to_string_ex(&args[i]);
}
- php_wddx_add_var(packet, (*args[i]));
+ php_wddx_add_var(packet, &args[i]);
}
- efree(args);
RETURN_TRUE;
}
/* }}} */
PHP_FUNCTION(wddx_deserialize)
{
zval *packet;
- char *payload;
- int payload_len;
php_stream *stream = NULL;
+ zend_string *payload = NULL;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &packet) == FAILURE) {
return;
}
if (Z_TYPE_P(packet) == IS_STRING) {
- payload = Z_STRVAL_P(packet);
- payload_len = Z_STRLEN_P(packet);
+ payload = Z_STR_P(packet);
} else if (Z_TYPE_P(packet) == IS_RESOURCE) {
- php_stream_from_zval(stream, &packet);
+ php_stream_from_zval(stream, packet);
if (stream) {
- payload_len = php_stream_copy_to_mem(stream, &payload, PHP_STREAM_COPY_ALL, 0);
+ payload = php_stream_copy_to_mem(stream, PHP_STREAM_COPY_ALL, 0);
}
} else {
php_error_docref(NULL TSRMLS_CC, E_WARNING, "Expecting parameter 1 to be a string or a stream");
return;
}
- if (payload_len == 0) {
+ if (payload == NULL) {
return;
}
- php_wddx_deserialize_ex(payload, payload_len, return_value);
+ php_wddx_deserialize_ex(payload->val, payload->len, return_value);
if (stream) {
- pefree(payload, 0);
+ efree(payload);
}
}
/* }}} */
projects / php / commitdiff