/* advance message */
if (!old || old->type || zend_hash_num_elements(&old->hdrs)) {
- (*message) = php_http_message_init(NULL, 0, NULL TSRMLS_CC);
+ (*message) = php_http_message_init(NULL, 0, NULL);
(*message)->parent = old;
if (headers) {
(*headers) = &((*message)->hdrs);
if (php_http_message_body_stream(msg->body)->readfilters.head) {
/* if a read stream filter is attached to the body the caller must also care for the headers */
+ } else if (php_http_message_header(msg, ZEND_STRL("Content-Range"))) {
+ /* don't mess around with a Content-Range message */
} else if ((size = php_http_message_body_size(msg->body))) {
ZVAL_LONG(&h, size);
zend_hash_str_update(&msg->hdrs, "Content-Length", lenof("Content-Length"), &h);
}
} else if ((cl = php_http_message_header_string(msg, ZEND_STRL("Content-Length")))) {
if (!zend_string_equals_literal(cl, "0")) {
+ /* body->size == 0, so get rid of old Content-Length */
zend_hash_str_del(&msg->hdrs, ZEND_STRL("Content-Length"));
}
zend_string_release(cl);
static zval *php_http_message_object_read_prop(zval *object, zval *member, int type, void **cache_slot, zval *rv);
static void php_http_message_object_write_prop(zval *object, zval *member, zval *value, void **cache_slot);
-static HashTable *php_http_message_object_get_props(zval *object);
+
+static inline void php_http_message_object_set_property(php_http_message_object_t *obj, const char *member_str, size_t member_len, zval *value)
+{
+ zval tmp_obj, tmp_member;
+
+ ZVAL_OBJ(&tmp_obj, &obj->zo);
+ ZVAL_STRINGL(&tmp_member, member_str, member_len);
+ zend_std_write_property(&tmp_obj, &tmp_member, value, NULL);
+ zval_ptr_dtor(&tmp_member);
+}
static zend_object_handlers php_http_message_object_handlers;
static HashTable php_http_message_object_prophandlers;
if (Z_TYPE_P(value) != IS_ARRAY && Z_TYPE_P(value) != IS_OBJECT) {
convert_to_array_ex(value);
- } else {
- headers = HASH_OF(value);
}
+ headers = HASH_OF(value);
zend_hash_clean(&obj->message->hdrs);
array_copy(headers, &obj->message->hdrs);
zval_ptr_dtor(value);
}
}
-static void php_http_message_object_prophandler_get_body(php_http_message_object_t *obj, zval *return_value) {
+/*static void php_http_message_object_prophandler_get_body(php_http_message_object_t *obj, zval *return_value) {
if (obj->body) {
RETVAL_OBJECT(&obj->body->zo, 1);
} else {
RETVAL_NULL();
}
-}
+}*/
static void php_http_message_object_prophandler_set_body(php_http_message_object_t *obj, zval *value) {
php_http_message_object_set_body(obj, value);
}
-static void php_http_message_object_prophandler_get_parent_message(php_http_message_object_t *obj, zval *return_value) {
+/*static void php_http_message_object_prophandler_get_parent_message(php_http_message_object_t *obj, zval *return_value) {
if (obj->message->parent) {
RETVAL_OBJECT(&obj->parent->zo, 1);
} else {
RETVAL_NULL();
}
-}
+}*/
static void php_http_message_object_prophandler_set_parent_message(php_http_message_object_t *obj, zval *value) {
- if (Z_TYPE_P(value) == IS_OBJECT && instanceof_function(Z_OBJCE_P(value), php_http_message_class_entry)) {
+ php_http_message_dtor(obj->message->parent);
+ if (instanceof_function(Z_OBJCE_P(value), php_http_message_class_entry)) {
php_http_message_object_t *parent_obj = PHP_HTTP_OBJ(NULL, value);
- if (obj->message->parent) {
- zend_objects_store_del(&obj->parent->zo);
- }
- Z_ADDREF_P(value);
- obj->parent = parent_obj;
obj->message->parent = parent_obj->message;
+ php_http_message_object_set_property(obj, ZEND_STRL("parentMessage"), value);
+ } else {
+ zval znull;
+
+ obj->message->parent = NULL;
+ ZVAL_NULL(&znull);
+ php_http_message_object_set_property(obj, ZEND_STRL("parentMessage"), &znull);
}
}
void php_http_message_object_reverse(zval *zmsg, zval *return_value)
{
- size_t i;
- php_http_message_object_t *obj = PHP_HTTP_OBJ(NULL, zmsg);
+ zval top = *zmsg;
+ php_http_message_object_t *top_obj, *this_obj = PHP_HTTP_OBJ(NULL, zmsg);
- PHP_HTTP_MESSAGE_OBJECT_INIT(obj);
+ PHP_HTTP_MESSAGE_OBJECT_INIT(this_obj);
- /* count */
- i = php_http_message_count(obj->message);
+ /* the original message has not been a parent yet, so add ref */
+ Z_ADDREF_P(zmsg);
- if (i > 1) {
- php_http_message_object_t **objects;
- int last;
+ if (php_http_message_count(this_obj->message) > 1) {
+ zval znull, zparent, zparent_tmp, zthis = *zmsg;
- objects = ecalloc(i, sizeof(**objects));
+ zparent = *zend_read_property(php_http_message_class_entry, zmsg, ZEND_STRL("parentMessage"), 0, &zparent_tmp);
- /* we are the first message */
- objects[0] = obj;
+ while (Z_TYPE(zparent) == IS_OBJECT) {
+ zval zparent_save, zparent_save_tmp;
+ php_http_message_object_t *parent_obj = PHP_HTTP_OBJ(NULL, &zparent);
- /* fetch parents */
- for (i = 1; obj->parent; ++i) {
- objects[i] = obj = obj->parent;
- }
+ /* make sure we're not intermittently cleaned up */
+ Z_DELREF(top);
+ top = zparent;
+ Z_ADDREF(top);
- /* reorder parents */
- for (last = --i; i; --i) {
- objects[i]->message->parent = objects[i-1]->message;
- objects[i]->parent = objects[i-1];
- }
+ zparent_save = *zend_read_property(php_http_message_class_entry, &zparent, ZEND_STRL("parentMessage"), 0, &zparent_save_tmp);
+ Z_TRY_ADDREF(zparent_save);
- objects[0]->message->parent = NULL;
- objects[0]->parent = NULL;
+ parent_obj->message->parent = this_obj->message;
+ php_http_message_object_set_property(parent_obj, ZEND_STRL("parentMessage"), &zthis);
- /* add ref, because we previously have not been a parent message */
- Z_ADDREF_P(zmsg);
- RETVAL_OBJ(&objects[last]->zo);
+ this_obj = parent_obj;
+ zthis = zparent;
+ zparent = zparent_save;
+ Z_TRY_DELREF(zparent_save);
+ }
- efree(objects);
- } else {
- RETURN_ZVAL_FAST(zmsg);
+ /* cleanup top message's parent message */
+ top_obj = PHP_HTTP_OBJ(NULL, zmsg);
+ ZVAL_NULL(&znull);
+ top_obj->message->parent = NULL;
+ php_http_message_object_set_property(top_obj, ZEND_STRL("parentMessage"), &znull);
}
+
+ RETVAL_ZVAL(&top, 0, 0);
}
void php_http_message_object_prepend(zval *this_ptr, zval *prepend, zend_bool top)
php_http_message_object_t *prepend_obj = PHP_HTTP_OBJ(NULL, prepend);
if (!top) {
- save_parent_obj = obj->parent;
save_parent_msg = obj->message->parent;
} else {
/* iterate to the most parent object */
- while (obj->parent) {
- obj = obj->parent;
+ while (obj->message->parent) {
+ zval *zparent, zparent_tmp, this_tmp;
+
+ ZVAL_OBJ(&this_tmp, &obj->zo);
+ zparent = zend_read_property(php_http_message_class_entry, &this_tmp, ZEND_STRL("parentMessage"), 0, &zparent_tmp);
+ obj = PHP_HTTP_OBJ(NULL, zparent);
}
}
/* prepend */
- obj->parent = prepend_obj;
obj->message->parent = prepend_obj->message;
-
- /* add ref */
Z_ADDREF_P(prepend);
+ php_http_message_object_set_property(obj, ZEND_STRL("parentMessage"), prepend);
if (!top) {
- prepend_obj->parent = save_parent_obj;
prepend_obj->message->parent = save_parent_msg;
}
}
-ZEND_RESULT_CODE php_http_message_object_set_body(php_http_message_object_t *msg_obj, zval *zbody)
+static inline php_http_message_body_object_t *php_http_message_object_infer_body(zval *zbody)
{
php_stream *s;
zend_string *body_str;
- php_http_message_body_t *body;
- php_http_message_body_object_t *body_obj;
switch (Z_TYPE_P(zbody)) {
case IS_RESOURCE:
php_stream_from_zval_no_verify(s, zbody);
if (!s) {
php_http_throw(unexpected_val, "The stream is not a valid resource", NULL);
- return FAILURE;
+ return NULL;
}
is_resource:
- body = php_http_message_body_init(NULL, s);
- if (!(body_obj = php_http_message_body_object_new_ex(php_http_message_body_class_entry, body))) {
- php_http_message_body_free(&body);
- return FAILURE;
- }
- break;
+ return php_http_message_body_object_new_ex(php_http_message_body_class_entry,
+ php_http_message_body_init(NULL, s));
+ /* no break */
case IS_OBJECT:
if (instanceof_function(Z_OBJCE_P(zbody), php_http_message_body_class_entry)) {
Z_ADDREF_P(zbody);
- body_obj = PHP_HTTP_OBJ(NULL, zbody);
- break;
+ return PHP_HTTP_OBJ(NULL, zbody);
}
/* no break */
php_stream_write(s, body_str->val, body_str->len);
zend_string_release(body_str);
goto is_resource;
-
}
+}
+ZEND_RESULT_CODE php_http_message_object_set_body(php_http_message_object_t *msg_obj, zval *zbody)
+{
+ zval tmp_body;
+ php_http_message_body_object_t *body_obj = php_http_message_object_infer_body(zbody);
+
+ if (!body_obj) {
+ return FAILURE;
+ }
if (!body_obj->body) {
body_obj->body = php_http_message_body_init(NULL, NULL);
}
- if (msg_obj->body) {
- zend_objects_store_del(&msg_obj->body->zo);
- }
if (msg_obj->message) {
php_http_message_body_free(&msg_obj->message->body);
msg_obj->message->body = php_http_message_body_init(&body_obj->body, NULL);
} else {
msg_obj->message = php_http_message_init(NULL, 0, php_http_message_body_init(&body_obj->body, NULL));
}
- msg_obj->body = body_obj;
+
+ ZVAL_OBJ(&tmp_body, &body_obj->zo);
+ php_http_message_object_set_property(msg_obj, ZEND_STRL("body"), &tmp_body);
+ zval_ptr_dtor(&tmp_body);
return SUCCESS;
}
-ZEND_RESULT_CODE php_http_message_object_init_body_object(php_http_message_object_t *obj)
+ZEND_RESULT_CODE php_http_message_object_init_body_object(php_http_message_object_t *obj, zval *tmp_body)
+{
+ php_http_new_t ctor = (php_http_new_t) php_http_message_body_object_new_ex;
+ php_http_message_body_object_t *body_obj;
+
+ if (SUCCESS == php_http_new((void *) &body_obj, php_http_message_body_class_entry, ctor, NULL, obj->message->body)) {
+ zval tmp;
+
+ if (!tmp_body) {
+ tmp_body = &tmp;
+ }
+
+ //php_http_message_body_addref(obj->message->body);
+ ZVAL_OBJ(tmp_body, &body_obj->zo);
+ php_http_message_object_set_property(obj, ZEND_STRL("body"), tmp_body);
+
+ if (tmp_body == &tmp) {
+ zval_ptr_dtor(tmp_body);
+ }
+
+ return SUCCESS;
+ }
+
+ return FAILURE;
+}
+
+void php_http_message_object_set_parent_message(php_http_message_object_t *obj, php_http_message_t *msg)
+{
+ while (msg) {
+ zval tmp_parent_obj;
+ php_http_message_object_t *parent_obj = php_http_message_object_new_ex(obj->zo.ce, msg->parent);
+
+ ZVAL_OBJ(&tmp_parent_obj, &parent_obj->zo);
+ php_http_message_object_set_property(obj, ZEND_STRL("parentMessage"), &tmp_parent_obj);
+ zval_ptr_dtor(&tmp_parent_obj);
+
+ msg = msg->parent;
+ obj = parent_obj;
+ }
+}
+
+void php_http_message_object_set_message(php_http_message_object_t *obj, php_http_message_t *msg)
{
- php_http_message_body_addref(obj->message->body);
- return php_http_new((void *) &obj->body, php_http_message_body_class_entry, (php_http_new_t) php_http_message_body_object_new_ex, NULL, obj->message->body);
+ php_http_message_dtor(obj->message);
+ obj->message = msg;
+
+ if (msg->parent) {
+ php_http_message_object_set_parent_message(obj, msg->parent);
+ }
}
zend_object *php_http_message_object_new(zend_class_entry *ce)
{
php_http_message_object_t *o;
- o = ecalloc(1, sizeof(php_http_message_object_t) + (ce->default_properties_count - 1) * sizeof(zval));
+ o = ecalloc(1, sizeof(*o) + zend_object_properties_size(ce));
zend_object_std_init(&o->zo, ce);
object_properties_init(&o->zo, ce);
if (msg) {
o->message = msg;
- if (msg->parent) {
- o->parent = php_http_message_object_new_ex(ce, msg->parent);
- }
- o->body = php_http_message_body_object_new_ex(php_http_message_body_class_entry, php_http_message_body_init(&msg->body, NULL));
}
o->zo.handlers = &php_http_message_object_handlers;
efree(o->message);
o->message = NULL;
}
- if (o->parent) {
- zend_objects_store_del(&o->parent->zo);
- o->parent = NULL;
- }
- if (o->body) {
- zend_objects_store_del(&o->body->zo);
- o->body = NULL;
- }
zend_object_std_dtor(object);
}
-static zval *php_http_message_object_read_prop(zval *object, zval *member, int type, void **cache_slot, zval *return_value)
+static zval *php_http_message_object_read_prop(zval *object, zval *member, int type, void **cache_slot, zval *tmp)
{
- php_http_message_object_t *obj = PHP_HTTP_OBJ(NULL, object);
- php_http_message_object_prophandler_t *handler;
+ zval *return_value;
zend_string *member_name = zval_get_string(member);
+ php_http_message_object_prophandler_t *handler = php_http_message_object_get_prophandler(member_name);
- PHP_HTTP_MESSAGE_OBJECT_INIT(obj);
+ if (!handler || !handler->read || type == BP_VAR_R || type == BP_VAR_IS) {
+ return_value = zend_get_std_object_handlers()->read_property(object, member, type, cache_slot, tmp);
- if ((handler = php_http_message_object_get_prophandler(member_name))) {
- if (type == BP_VAR_R) {
- handler->read(obj, return_value);
- } else {
- php_property_proxy_t *proxy = php_property_proxy_init(object, member_name);
- RETVAL_OBJ(&php_property_proxy_object_new_ex(php_property_proxy_get_class_entry(), proxy)->zo);
+ if (handler && handler->read) {
+ php_http_message_object_t *obj = PHP_HTTP_OBJ(NULL, object);
+
+ PHP_HTTP_MESSAGE_OBJECT_INIT(obj);
+ handler->read(obj, tmp);
+
+ zval_ptr_dtor(return_value);
+ ZVAL_COPY_VALUE(return_value, tmp);
}
} else {
- zend_get_std_object_handlers()->read_property(object, member, type, cache_slot, return_value);
+ php_property_proxy_t *proxy;
+ php_property_proxy_object_t *proxy_obj;
+
+ proxy = php_property_proxy_init(object, member_name);
+ proxy_obj = php_property_proxy_object_new_ex(NULL, proxy);
+
+ ZVAL_OBJ(tmp, &proxy_obj->zo);
+ return tmp;
}
zend_string_release(member_name);
PHP_HTTP_MESSAGE_OBJECT_INIT(obj);
- if ((handler = php_http_message_object_get_prophandler(member_name))) {
+ if ((handler = php_http_message_object_get_prophandler(member_name)) && handler->write) {
handler->write(obj, value);
} else {
zend_get_std_object_handlers()->write_property(object, member, value, cache_slot);
zend_string_release(member_name);
}
-static HashTable *php_http_message_object_get_props(zval *object)
+static HashTable *php_http_message_object_get_debug_info(zval *object, int *is_temp)
{
zval tmp;
php_http_message_object_t *obj = PHP_HTTP_OBJ(NULL, object);
size_t ver_len, url_len = 0;
PHP_HTTP_MESSAGE_OBJECT_INIT(obj);
+ *is_temp = 0;
#define UPDATE_PROP(name_str, action_with_tmp) \
do { \
zend_property_info *pi; \
if ((pi = zend_hash_str_find_ptr(&obj->zo.ce->properties_info, name_str, lenof(name_str)))) { \
action_with_tmp; \
- zend_hash_update(props, pi->name, &tmp); \
+ zend_hash_update_ind(props, pi->name, &tmp); \
} \
} while(0)
array_copy(&obj->message->hdrs, Z_ARRVAL(tmp));
);
- UPDATE_PROP("body",
- if (obj->body) {
- ZVAL_OBJECT(&tmp, &obj->body->zo, 1);
- } else {
- ZVAL_NULL(&tmp);
- }
- );
-
- UPDATE_PROP("parentMessage",
- if (obj->message->parent) {
- ZVAL_OBJECT(&tmp, &obj->parent->zo, 1);
- } else {
- ZVAL_NULL(&tmp);
- }
- );
-
return props;
}
msg = php_http_message_parse(NULL, zs_msg->val, zs_msg->len, greedy);
if (!msg && !EG(exception)) {
- php_http_throw(bad_message, "Could not parse message: %.*s", MIN(25, zs_msg->len), zs_msg->len);
+ php_http_throw(bad_message, "Could not parse message: %.*s", MIN(25, zs_msg->len), zs_msg->val);
}
zend_string_release(zs_msg);
}
if (msg) {
- php_http_message_dtor(obj->message);
- obj->message = msg;
- if (obj->message->parent) {
- obj->parent = php_http_message_object_new_ex(obj->zo.ce, obj->message->parent);
- }
+ php_http_message_object_set_message(obj, msg);
}
zend_restore_error_handling(&zeh);
PHP_HTTP_MESSAGE_OBJECT_INIT(obj);
ZEND_END_ARG_INFO();
static PHP_METHOD(HttpMessage, getBody)
{
+ zval *zbody, zbody_tmp;
php_http_message_object_t *obj;
php_http_expect(SUCCESS == zend_parse_parameters_none(), invalid_arg, return);
obj = PHP_HTTP_OBJ(NULL, getThis());
PHP_HTTP_MESSAGE_OBJECT_INIT(obj);
- if (!obj->body) {
- php_http_message_object_init_body_object(obj);
+ zbody = zend_read_property(php_http_message_class_entry, getThis(), ZEND_STRL("body"), 0, &zbody_tmp);
+ if (!zbody || Z_TYPE_P(zbody) != IS_OBJECT) {
+ php_http_message_object_init_body_object(obj, &zbody_tmp);
+ zbody = &zbody_tmp;
}
- if (obj->body) {
- RETVAL_OBJECT(&obj->body->zo, 1);
- }
+
+ RETVAL_ZVAL(zbody, 1, 0);
}
ZEND_BEGIN_ARG_INFO_EX(ai_HttpMessage_setBody, 0, 0, 1)
PHP_HTTP_MESSAGE_OBJECT_INIT(obj);
php_http_message_object_prophandler_set_body(obj, zbody);
}
- RETVAL_ZVAL_FAST(getThis());
+ RETVAL_ZVAL(getThis(), 1, 0);
}
ZEND_BEGIN_ARG_INFO_EX(ai_HttpMessage_addBody, 0, 0, 1)
PHP_HTTP_MESSAGE_OBJECT_INIT(obj);
php_http_message_body_to_callback(new_obj->body, (php_http_pass_callback_t) php_http_message_body_append, obj->message->body, 0, 0);
}
- RETVAL_ZVAL_FAST(getThis());
+ RETVAL_ZVAL(getThis(), 1, 0);
}
ZEND_BEGIN_ARG_INFO_EX(ai_HttpMessage_getHeader, 0, 0, 1)
if ((header = php_http_message_header(obj->message, header_str, header_len))) {
if (!header_ce) {
- RETURN_ZVAL(header, 1, 1);
+ RETURN_ZVAL(header, 1, 0);
} else if (instanceof_function(header_ce, php_http_header_class_entry)) {
+ php_http_object_method_t cb;
zval argv[2];
ZVAL_STRINGL(&argv[0], header_str, header_len);
ZVAL_COPY(&argv[1], header);
object_init_ex(return_value, header_ce);
- php_http_method_call(return_value, ZEND_STRL("__construct"), 2, argv, NULL);
+ php_http_object_method_init(&cb, return_value, ZEND_STRL("__construct"));
+ php_http_object_method_call(&cb, return_value, NULL, 2, argv);
+ php_http_object_method_dtor(&cb);
zval_ptr_dtor(&argv[0]);
zval_ptr_dtor(&argv[1]);
}
efree(name);
}
- RETVAL_ZVAL_FAST(getThis());
+ RETVAL_ZVAL(getThis(), 1, 0);
}
ZEND_BEGIN_ARG_INFO_EX(ai_HttpMessage_setHeaders, 0, 0, 1)
array_join(Z_ARRVAL_P(new_headers), &obj->message->hdrs, 0, ARRAY_JOIN_PRETTIFY|ARRAY_JOIN_STRONLY);
}
}
- RETVAL_ZVAL_FAST(getThis());
+ RETVAL_ZVAL(getThis(), 1, 0);
}
ZEND_BEGIN_ARG_INFO_EX(ai_HttpMessage_addHeader, 0, 0, 2)
}
efree(name);
}
- RETVAL_ZVAL_FAST(getThis());
+ RETVAL_ZVAL(getThis(), 1, 0);
}
ZEND_BEGIN_ARG_INFO_EX(ai_HttpMessage_addHeaders, 0, 0, 1)
array_join(Z_ARRVAL_P(new_headers), &obj->message->hdrs, append, ARRAY_JOIN_STRONLY|ARRAY_JOIN_PRETTIFY);
}
- RETVAL_ZVAL_FAST(getThis());
+ RETVAL_ZVAL(getThis(), 1, 0);
}
ZEND_BEGIN_ARG_INFO_EX(ai_HttpMessage_getType, 0, 0, 0)
php_http_message_set_type(obj->message, type);
}
- RETVAL_ZVAL_FAST(getThis());
+ RETVAL_ZVAL(getThis(), 1, 0);
}
ZEND_BEGIN_ARG_INFO_EX(ai_HttpMessage_getInfo, 0, 0, 0)
php_http_message_set_info(obj->message, &inf);
php_http_info_dtor(&inf);
- RETVAL_ZVAL_FAST(getThis());
+ RETVAL_ZVAL(getThis(), 1, 0);
}
ZEND_BEGIN_ARG_INFO_EX(ai_HttpMessage_getHttpVersion, 0, 0, 0)
obj->message->http.version = version;
- RETVAL_ZVAL_FAST(getThis());
+ RETVAL_ZVAL(getThis(), 1, 0);
}
ZEND_BEGIN_ARG_INFO_EX(ai_HttpMessage_getResponseCode, 0, 0, 0)
obj->message->http.info.response.code = code;
PTR_SET(obj->message->http.info.response.status, estrdup(php_http_env_get_response_status_for_code(code)));
- RETVAL_ZVAL_FAST(getThis());
+ RETVAL_ZVAL(getThis(), 1, 0);
}
ZEND_BEGIN_ARG_INFO_EX(ai_HttpMessage_getResponseStatus, 0, 0, 0)
static PHP_METHOD(HttpMessage, setResponseStatus)
{
char *status;
- int status_len;
+ size_t status_len;
php_http_message_object_t *obj;
php_http_expect(SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &status, &status_len), invalid_arg, return);
}
PTR_SET(obj->message->http.info.response.status, estrndup(status, status_len));
- RETVAL_ZVAL_FAST(getThis());
+ RETVAL_ZVAL(getThis(), 1, 0);
}
ZEND_BEGIN_ARG_INFO_EX(ai_HttpMessage_getRequestMethod, 0, 0, 0)
}
PTR_SET(obj->message->http.info.request.method, estrndup(method, method_len));
- RETVAL_ZVAL_FAST(getThis());
+ RETVAL_ZVAL(getThis(), 1, 0);
}
ZEND_BEGIN_ARG_INFO_EX(ai_HttpMessage_getRequestUrl, 0, 0, 0)
PTR_SET(obj->message->http.info.request.url, url);
}
- RETVAL_ZVAL_FAST(getThis());
+ RETVAL_ZVAL(getThis(), 1, 0);
}
ZEND_BEGIN_ARG_INFO_EX(ai_HttpMessage_getParentMessage, 0, 0, 0)
static PHP_METHOD(HttpMessage, getParentMessage)
{
php_http_message_object_t *obj;
+ zval *zparent, zparent_tmp;
php_http_expect(SUCCESS == zend_parse_parameters_none(), invalid_arg, return);
return;
}
- RETVAL_OBJECT(&obj->parent->zo, 1);
+ zparent = zend_read_property(php_http_message_class_entry, getThis(), ZEND_STRL("parentMessage"), 0, &zparent_tmp);
+ RETVAL_ZVAL(zparent, 1, 0);
}
ZEND_BEGIN_ARG_INFO_EX(ai_HttpMessage___toString, 0, 0, 0)
zend_fcall_info_args_clear(&fcd.fci, 1);
zval_ptr_dtor(&fcd.fcz);
- RETURN_ZVAL_FAST(getThis());
+ RETURN_ZVAL(getThis(), 1, 0);
}
}
}
php_http_message_object_prepend(getThis(), prepend, top);
- RETURN_ZVAL_FAST(getThis());
+ RETURN_ZVAL(getThis(), 1, 0);
}
ZEND_BEGIN_ARG_INFO_EX(ai_HttpMessage_reverse, 0, 0, 0)
}
if (zboundary && boundary) {
+ ZVAL_DEREF(zboundary);
zval_dtor(zboundary);
ZVAL_STR(zboundary, php_http_cs2zs(boundary, strlen(boundary)));
}
if (!Z_ISUNDEF(obj->iterator)) {
php_http_message_object_t *itr = PHP_HTTP_OBJ(NULL, &obj->iterator);
- if (itr->parent) {
- zval tmp;
+ if (itr->message->parent) {
+ zval *zparent, zparent_tmp;
- ZVAL_OBJECT(&tmp, &itr->parent->zo, 1);
+ zparent = zend_read_property(php_http_message_class_entry, getThis(), ZEND_STRL("parentMessage"), 0, &zparent_tmp);
zval_ptr_dtor(&obj->iterator);
- obj->iterator = tmp;
+ obj->iterator = *zparent;
} else {
zval_ptr_dtor(&obj->iterator);
ZVAL_UNDEF(&obj->iterator);
php_http_message_object_t *obj = PHP_HTTP_OBJ(NULL, getThis());
if (!Z_ISUNDEF(obj->iterator)) {
- RETURN_ZVAL_FAST(&obj->iterator);
+ RETURN_ZVAL(&obj->iterator, 1, 0);
}
}
}
php_http_message_object_handlers.free_obj = php_http_message_object_free;
php_http_message_object_handlers.read_property = php_http_message_object_read_prop;
php_http_message_object_handlers.write_property = php_http_message_object_write_prop;
- php_http_message_object_handlers.get_properties = php_http_message_object_get_props;
+ php_http_message_object_handlers.get_debug_info = php_http_message_object_get_debug_info;
php_http_message_object_handlers.get_property_ptr_ptr = NULL;
zend_class_implements(php_http_message_class_entry, 3, spl_ce_Countable, zend_ce_serializable, zend_ce_iterator);
zend_declare_property_long(php_http_message_class_entry, ZEND_STRL("type"), PHP_HTTP_NONE, ZEND_ACC_PROTECTED);
php_http_message_object_add_prophandler(ZEND_STRL("type"), php_http_message_object_prophandler_get_type, php_http_message_object_prophandler_set_type);
zend_declare_property_null(php_http_message_class_entry, ZEND_STRL("body"), ZEND_ACC_PROTECTED);
- php_http_message_object_add_prophandler(ZEND_STRL("body"), php_http_message_object_prophandler_get_body, php_http_message_object_prophandler_set_body);
+ php_http_message_object_add_prophandler(ZEND_STRL("body"), NULL, php_http_message_object_prophandler_set_body);
zend_declare_property_string(php_http_message_class_entry, ZEND_STRL("requestMethod"), "", ZEND_ACC_PROTECTED);
php_http_message_object_add_prophandler(ZEND_STRL("requestMethod"), php_http_message_object_prophandler_get_request_method, php_http_message_object_prophandler_set_request_method);
zend_declare_property_string(php_http_message_class_entry, ZEND_STRL("requestUrl"), "", ZEND_ACC_PROTECTED);
zend_declare_property_null(php_http_message_class_entry, ZEND_STRL("headers"), ZEND_ACC_PROTECTED);
php_http_message_object_add_prophandler(ZEND_STRL("headers"), php_http_message_object_prophandler_get_headers, php_http_message_object_prophandler_set_headers);
zend_declare_property_null(php_http_message_class_entry, ZEND_STRL("parentMessage"), ZEND_ACC_PROTECTED);
- php_http_message_object_add_prophandler(ZEND_STRL("parentMessage"), php_http_message_object_prophandler_get_parent_message, php_http_message_object_prophandler_set_parent_message);
+ php_http_message_object_add_prophandler(ZEND_STRL("parentMessage"), NULL, php_http_message_object_prophandler_set_parent_message);
zend_declare_class_constant_long(php_http_message_class_entry, ZEND_STRL("TYPE_NONE"), PHP_HTTP_NONE);
zend_declare_class_constant_long(php_http_message_class_entry, ZEND_STRL("TYPE_REQUEST"), PHP_HTTP_REQUEST);
projects / m6w6 / ext-http / blobdiff