自学教程：C++ zend_update_property_long函数代码示例

void php_mongo_db_construct(zval *z_client, zval *zlink, char *name, int name_len TSRMLS_DC){	mongo_db *db;	mongoclient *link;	if (!php_mongo_db_is_valid_dbname(name, name_len TSRMLS_CC)) {		return;	}	db = (mongo_db*)zend_object_store_get_object(z_client TSRMLS_CC);	db->link = zlink;	zval_add_ref(&db->link);	link = (mongoclient*)zend_object_store_get_object(zlink TSRMLS_CC);	if (!(link->servers)) {		zend_throw_exception(mongo_ce_Exception, "The MongoDB object has not been correctly initialized by its constructor", 0 TSRMLS_CC);		return;	}	if (link->servers->options.default_w != -1) {		zend_update_property_long(mongo_ce_DB, z_client, "w", strlen("w"), link->servers->options.default_w TSRMLS_CC);	} else if (link->servers->options.default_wstring != NULL) {		zend_update_property_string(mongo_ce_DB, z_client, "w", strlen("w"), link->servers->options.default_wstring TSRMLS_CC);	}	if (link->servers->options.default_wtimeout != -1) {		zend_update_property_long(mongo_ce_DB, z_client, "wtimeout", strlen("wtimeout"), link->servers->options.default_wtimeout TSRMLS_CC);	}	mongo_read_preference_copy(&link->servers->read_pref, &db->read_pref);	MAKE_STD_ZVAL(db->name);	ZVAL_STRING(db->name, name, 1);}

/* {{{ proto AMQPDecimal::__construct(int $e, int $n) */static PHP_METHOD(amqp_decimal_class, __construct){    PHP5to7_param_long_type_t exponent, significand;	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ll", &exponent, &significand) == FAILURE) {		return;	}	if (exponent < AMQP_DECIMAL_EXPONENT_MIN) {		zend_throw_exception_ex(amqp_value_exception_class_entry, 0 TSRMLS_CC, "Decimal exponent value must be unsigned.");		return;	}	if (exponent > AMQP_DECIMAL_EXPONENT_MAX) {		zend_throw_exception_ex(amqp_value_exception_class_entry, 0 TSRMLS_CC, "Decimal exponent value must be less than %u.", AMQP_DECIMAL_EXPONENT_MAX);		return;	}    if (significand < AMQP_DECIMAL_SIGNIFICAND_MIN) {        zend_throw_exception_ex(amqp_value_exception_class_entry, 0 TSRMLS_CC, "Decimal significand value must be unsigned.");        return;    }    if (significand > AMQP_DECIMAL_SIGNIFICAND_MAX) {        zend_throw_exception_ex(amqp_value_exception_class_entry, 0 TSRMLS_CC, "Decimal significand value must be less than %u.", AMQP_DECIMAL_SIGNIFICAND_MAX);        return;    }    zend_update_property_long(this_ce, getThis(), ZEND_STRL("exponent"), exponent TSRMLS_CC);    zend_update_property_long(this_ce, getThis(), ZEND_STRL("significand"), significand TSRMLS_CC);}

static zend_object *zend_default_exception_new_ex(zend_class_entry *class_type, int skip_top_traces) /* {{{ */{	zval obj;	zend_object *object;	zval trace;	zend_class_entry *base_ce;	zend_string *filename;	Z_OBJ(obj) = object = zend_objects_new(class_type);	Z_OBJ_HT(obj) = &default_exception_handlers;	object_properties_init(object, class_type);	if (EG(current_execute_data)) {		zend_fetch_debug_backtrace(&trace, skip_top_traces, 0, 0);	} else {		array_init(&trace);	}	Z_SET_REFCOUNT(trace, 0);	base_ce = i_get_exception_base(&obj);	if (EXPECTED(class_type != zend_ce_parse_error || !(filename = zend_get_compiled_filename()))) {		zend_update_property_string(base_ce, &obj, "file", sizeof("file")-1, zend_get_executed_filename());		zend_update_property_long(base_ce, &obj, "line", sizeof("line")-1, zend_get_executed_lineno());	} else {		zend_update_property_str(base_ce, &obj, "file", sizeof("file")-1, filename);		zend_update_property_long(base_ce, &obj, "line", sizeof("line")-1, zend_get_compiled_lineno());	}	zend_update_property(base_ce, &obj, "trace", sizeof("trace")-1, &trace);	return object;}

static PHP_METHOD(swoole_process, useQueue){    long msgkey = 0;    long mode = 2;    if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|ll", &msgkey, &mode) == FAILURE)    {        RETURN_FALSE;    }    swWorker *process = swoole_get_object(getThis());    if (msgkey <= 0)    {#if PHP_MAJOR_VERSION >= 7        msgkey = ftok(zend_get_executed_filename(), 0);#else        msgkey = ftok(zend_get_executed_filename(TSRMLS_C), 0);#endif    }    swMsgQueue *queue = emalloc(sizeof(swMsgQueue));    if (swMsgQueue_create(queue, 1, msgkey, 0) < 0)    {        RETURN_FALSE;    }    queue->remove = 0;    process->queue = queue;    process->ipc_mode = mode;    zend_update_property_long(swoole_process_class_entry_ptr, getThis(), ZEND_STRL("msgQueueId"), queue->msg_id TSRMLS_CC);    zend_update_property_long(swoole_process_class_entry_ptr, getThis(), ZEND_STRL("msgQueueKey"), msgkey TSRMLS_CC);    RETURN_TRUE;}

int swoole_websocket_onMessage(swEventData *req){#if PHP_MAJOR_VERSION < 7    TSRMLS_FETCH_FROM_CTX(sw_thread_ctx ? sw_thread_ctx : NULL);#endif    int fd = req->info.fd;    zval *zdata;    SW_MAKE_STD_ZVAL(zdata);    zdata = php_swoole_get_recv_data(zdata, req TSRMLS_CC);    char *buf = Z_STRVAL_P(zdata);    long finish = buf[0] ? 1 : 0;    long opcode = buf[1] ? 1 : 0;    zval *zframe;    SW_MAKE_STD_ZVAL(zframe);    object_init_ex(zframe, swoole_websocket_frame_class_entry_ptr);    zend_update_property_long(swoole_websocket_frame_class_entry_ptr, zframe, ZEND_STRL("fd"), fd TSRMLS_CC);    zend_update_property_long(swoole_websocket_frame_class_entry_ptr, zframe, ZEND_STRL("finish"), finish TSRMLS_CC);    zend_update_property_long(swoole_websocket_frame_class_entry_ptr, zframe, ZEND_STRL("opcode"), opcode TSRMLS_CC);    zend_update_property_stringl(swoole_websocket_frame_class_entry_ptr, zframe, ZEND_STRL("data"), buf + 2, (Z_STRLEN_P(zdata) - 2) TSRMLS_CC);    swServer *serv = SwooleG.serv;    zval *zserv = (zval *) serv->ptr2;    zval **args[2];    args[0] = &zserv;    args[1] = &zframe;    zval *retval = NULL;    if (sw_call_user_function_ex(EG(function_table), NULL, websocket_callbacks[WEBSOCKET_CALLBACK_onMessage], &retval, 2,            args, 0, NULL TSRMLS_CC) == FAILURE)    {        php_error_docref(NULL TSRMLS_CC, E_WARNING, "onMessage handler error");    }    if (EG(exception))    {        zend_exception_error(EG(exception), E_ERROR TSRMLS_CC);    }    if (retval)    {        sw_zval_ptr_dtor(&retval);    }    sw_zval_ptr_dtor(&zdata);    sw_zval_ptr_dtor(&zframe);    return SW_OK;}

int swoole_websocket_onMessage(swEventData *req){#if PHP_MAJOR_VERSION < 7    TSRMLS_FETCH_FROM_CTX(sw_thread_ctx ? sw_thread_ctx : NULL);#endif    int fd = req->info.fd;    zval *zdata;    SW_MAKE_STD_ZVAL(zdata);    char frame_header[2];    php_swoole_get_recv_data(zdata, req, frame_header, 2);    long finish = frame_header[0] ? 1 : 0;    long opcode = frame_header[1];    zval *zframe;    SW_MAKE_STD_ZVAL(zframe);    object_init_ex(zframe, swoole_websocket_frame_class_entry_ptr);    zend_update_property_long(swoole_websocket_frame_class_entry_ptr, zframe, ZEND_STRL("fd"), fd TSRMLS_CC);    zend_update_property_bool(swoole_websocket_frame_class_entry_ptr, zframe, ZEND_STRL("finish"), finish TSRMLS_CC);    zend_update_property_long(swoole_websocket_frame_class_entry_ptr, zframe, ZEND_STRL("opcode"), opcode TSRMLS_CC);    zend_update_property(swoole_websocket_frame_class_entry_ptr, zframe, ZEND_STRL("data"), zdata TSRMLS_CC);    swServer *serv = SwooleG.serv;    zval *zserv = (zval *) serv->ptr2;    zval **args[2];    args[0] = &zserv;    args[1] = &zframe;    zval *retval = NULL;    zval *zcallback = php_swoole_server_get_callback(serv, req->info.from_fd, SW_SERVER_CB_onMessage);    if (sw_call_user_function_ex(EG(function_table), NULL, zcallback, &retval, 2, args, 0, NULL TSRMLS_CC) == FAILURE)    {        php_error_docref(NULL TSRMLS_CC, E_WARNING, "onMessage handler error");    }    if (EG(exception))    {        zend_exception_error(EG(exception), E_ERROR TSRMLS_CC);    }    if (retval)    {        sw_zval_ptr_dtor(&retval);    }    sw_zval_ptr_dtor(&zdata);    sw_zval_ptr_dtor(&zframe);    return SW_OK;}

PHP_METHOD(MongoCollection, __construct) {  zval *parent, *name, *zns, *w, *wtimeout;  mongo_collection *c;  mongo_db *db;  char *ns, *name_str;  int name_len;  if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "Os", &parent, mongo_ce_DB, &name_str, &name_len) == FAILURE) {    zval *object = getThis();    ZVAL_NULL(object);    return;  }  // check for empty collection name  if (name_len == 0) {#if ZEND_MODULE_API_NO >= 20060613    zend_throw_exception_ex(zend_exception_get_default(TSRMLS_C), 0 TSRMLS_CC, "MongoDB::__construct(): invalid name %s", name_str);#else    zend_throw_exception_ex(zend_exception_get_default(), 0 TSRMLS_CC, "MongoDB::__construct(): invalid name %s", name_str);#endif /* ZEND_MODULE_API_NO >= 20060613 */    return;  }  c = (mongo_collection*)zend_object_store_get_object(getThis() TSRMLS_CC);  PHP_MONGO_GET_DB(parent);  c->link = db->link;  zval_add_ref(&db->link);  c->parent = parent;  zval_add_ref(&parent);  MAKE_STD_ZVAL(name);  ZVAL_STRINGL(name, name_str, name_len, 1);  c->name = name;  spprintf(&ns, 0, "%s.%s", Z_STRVAL_P(db->name), Z_STRVAL_P(name));  MAKE_STD_ZVAL(zns);  ZVAL_STRING(zns, ns, 0);  c->ns = zns;  mongo_read_preference_copy(&db->read_pref, &c->read_pref);  w = zend_read_property(mongo_ce_DB, parent, "w", strlen("w"), NOISY TSRMLS_CC);  zend_update_property_long(mongo_ce_Collection, getThis(), "w", strlen("w"), Z_LVAL_P(w) TSRMLS_CC);  wtimeout = zend_read_property(mongo_ce_DB, parent, "wtimeout", strlen("wtimeout"), NOISY TSRMLS_CC);  zend_update_property_long(mongo_ce_Collection, getThis(), "wtimeout", strlen("wtimeout"), Z_LVAL_P(wtimeout) TSRMLS_CC);}

/**{{{ proto Mylogs::logInit*/PHP_METHOD(Mylogs, logInit) {	long level, maxNum, maxSize;	char  *logPath, *fileName;	int logPath_len, fileName_len;	zval *instance = _getInstance();	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "lllss", &level, &maxNum, &maxSize, &logPath, &logPath_len, &fileName, &fileName_len) == FAILURE)		return;	zend_update_property_long(mylogs_ce, instance, ZEND_STRL(MYLOGS_LEVEL), level TSRMLS_CC);	zend_update_property_long(mylogs_ce, instance, ZEND_STRL(MYLOGS_MAXFILE_NUM), maxNum TSRMLS_CC);	zend_update_property_long(mylogs_ce, instance, ZEND_STRL(MYLOGS_MAXFILE_SIZE), maxSize TSRMLS_CC);	zend_update_property_string(mylogs_ce, instance, ZEND_STRL(MYLOGS_PATH), logPath TSRMLS_CC);	zend_update_property_string(mylogs_ce, instance, ZEND_STRL(MYLOGS_FILE_NAME), fileName TSRMLS_CC);	RETURN_TRUE;}

void php_mongo_mongodate_populate(zval *mongodate_object, long sec, long usec TSRMLS_DC){	mongo_date *date;	int64_t internal_date = 0;	internal_date += usec / 1000;	internal_date += (sec * 1000);	usec = (usec / 1000) * 1000;		zend_update_property_long(mongo_ce_Date, mongodate_object, "usec", strlen("usec"), usec TSRMLS_CC);	zend_update_property_long(mongo_ce_Date, mongodate_object, "sec", strlen("sec"), sec TSRMLS_CC);	date = (mongo_date*) zend_object_store_get_object(mongodate_object TSRMLS_CC);	date->datetime = internal_date;}

/* {{{ proto Exception|Error::__construct(string message, int code [, Throwable previous])   Exception constructor */ZEND_METHOD(exception, __construct){	zend_string *message = NULL;	zend_long   code = 0;	zval  *object, *previous = NULL;	zend_class_entry *base_ce;	int    argc = ZEND_NUM_ARGS();	object = getThis();	base_ce = i_get_exception_base(object);	if (zend_parse_parameters_ex(ZEND_PARSE_PARAMS_QUIET, argc, "|SlO!", &message, &code, &previous, zend_ce_throwable) == FAILURE) {		zend_class_entry *ce;		if (execute_data->called_scope) {			ce = execute_data->called_scope;		} else {			ce = base_ce;		}		zend_throw_error(NULL, "Wrong parameters for %s([string $message [, long $code [, Throwable $previous = NULL]]])", ZSTR_VAL(ce->name));		return;	}	if (message) {		zend_update_property_str(base_ce, object, "message", sizeof("message")-1, message);	}	if (code) {		zend_update_property_long(base_ce, object, "code", sizeof("code")-1, code);	}	if (previous) {		zend_update_property(base_ce, object, "previous", sizeof("previous")-1, previous);	}}

PHP_METHOD(Money, __construct){	long amount;	zval *currency, *currency_obj;	if (zend_parse_parameters(ZEND_NUM_ARGS(), "lz", &amount, &currency) == FAILURE) {		return;	}	switch(Z_TYPE_P(currency)) {		case IS_OBJECT:			if (!instanceof_function(currency_ce, Z_OBJCE_P(currency))) {				zend_throw_exception(spl_ce_InvalidArgumentException, "Invalid currency object", 0);				return;			}		break;		case IS_STRING:			ALLOC_INIT_ZVAL(currency_obj);			object_init_ex(currency_obj, currency_ce);			zend_update_property_stringl(currency_ce, currency_obj, CURRENCY_PROP_CURRENCYCODE_WS, Z_STRVAL_P(currency), Z_STRLEN_P(currency));			currency = currency_obj;			Z_DELREF_P(currency);		break;		default:			zend_throw_exception(spl_ce_InvalidArgumentException, "Invalid currency value", 0);			return;	}	zend_update_property_long(Z_OBJCE_P(getThis()), getThis(), MONEY_PROP_AMOUNT_WS, amount);	zend_update_property(Z_OBJCE_P(getThis()), getThis(), MONEY_PROP_CURRENCY_WS, currency);}

static PHP_METHOD(swoole_buffer, clear){    swString *buffer = swoole_get_object(getThis());    buffer->length = 0;    buffer->offset = 0;    zend_update_property_long(swoole_buffer_class_entry_ptr, getThis(), ZEND_STRL("length"), 0 TSRMLS_CC);}

staticPHP_METHOD(MsgqueForPhp_MqDumpS, __destruct){  SETUP_dump;  MqDumpDelete(&dump);  zend_update_property_long(NS(MqDumpS), getThis(), ID(__ctx), 0L TSRMLS_CC);}

/** * Throws a zval object as exception */void zephir_throw_exception_debug(zval *object, const char *file, zend_uint line){	zend_class_entry *default_exception_ce;	int ZEPHIR_LAST_CALL_STATUS = 0;	zval curline;	zval object_copy;	ZVAL_UNDEF(&curline);	ZEPHIR_MM_GROW();	if (Z_TYPE_P(object) != IS_OBJECT) {		ZVAL_COPY_VALUE(&object_copy, object);		object_init_ex(object, zend_exception_get_default());		ZEPHIR_CALL_METHOD(NULL, object, "__construct", NULL, 0, &object_copy);		zval_ptr_dtor(&object_copy);	}	Z_ADDREF_P(object);	if (line > 0) {		ZEPHIR_CALL_METHOD(&curline, object, "getline", NULL, 0);		zephir_check_call_status();		if (ZEPHIR_IS_LONG(&curline, 0)) {			default_exception_ce = zend_exception_get_default();			zend_update_property_string(default_exception_ce, object, SL("file"), file);			zend_update_property_long(default_exception_ce, object, SL("line"), line);		}	}	if (ZEPHIR_LAST_CALL_STATUS != FAILURE) {		zend_throw_exception_object(object);	}	ZEPHIR_MM_RESTORE();}

static PHP_METHOD(swoole_process, __construct){    zend_bool redirect_stdin_and_stdout = 0;    long create_pipe = 1;    zval *callback;    if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z|bl", &callback, &redirect_stdin_and_stdout, &create_pipe) == FAILURE)    {        RETURN_FALSE;    }    char *func_name = NULL;    if (!sw_zend_is_callable(callback, 0, &func_name TSRMLS_CC))    {        php_error_docref(NULL TSRMLS_CC, E_ERROR, "function '%s' is not callable", func_name);        efree(func_name);        RETURN_FALSE;    }    efree(func_name);    swWorker *process = emalloc(sizeof(swWorker));    bzero(process, sizeof(swWorker));    process->id = php_swoole_worker_round_id++;    if (php_swoole_worker_round_id == 0)    {        php_swoole_worker_round_id = 1;    }    if (redirect_stdin_and_stdout)    {        process->redirect_stdin = 1;        process->redirect_stdout = 1;        process->redirect_stderr = 1;        create_pipe = 1;    }    if (create_pipe > 0)    {        swPipe *_pipe = emalloc(sizeof(swWorker));        int socket_type = create_pipe == 1 ? SOCK_STREAM : SOCK_DGRAM;        if (swPipeUnsock_create(_pipe, 1, socket_type) < 0)        {            RETURN_FALSE;        }        process->pipe_object = _pipe;        process->pipe_master = _pipe->getFd(_pipe, SW_PIPE_MASTER);        process->pipe_worker = _pipe->getFd(_pipe, SW_PIPE_WORKER);        process->pipe = process->pipe_master;        zend_update_property_long(swoole_process_class_entry_ptr, getThis(), ZEND_STRL("pipe"), process->pipe_master TSRMLS_CC);    }    swoole_set_object(getThis(), process);    zend_update_property(swoole_process_class_entry_ptr, getThis(), ZEND_STRL("callback"), callback TSRMLS_CC);}

/* Timestamp is 4 bytes of seconds since epoch and 4 bytes of increment. */PHP_METHOD(MongoTimestamp, __construct){    long sec = 0, inc = 0;    if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|ll", &sec, &inc) == FAILURE) {        return;    }    if (ZEND_NUM_ARGS() == 0) {        sec = time(0);    }    if (ZEND_NUM_ARGS() <= 1 && !inc) {        inc = MonGlo(ts_inc)++;    }    zend_update_property_long(mongo_ce_Timestamp, getThis(), "sec", strlen("sec"), sec TSRMLS_CC);    zend_update_property_long(mongo_ce_Timestamp, getThis(), "inc", strlen("inc"), inc TSRMLS_CC);}

PHP_METHOD(pdo_connect_pool_PDOStatement, next){    zval *pos;    zend_class_entry *ce;    ce = Z_OBJCE_P(getThis());    pos = cp_zend_read_property(ce, getThis(), "pos", sizeof ("pos") - 1, 0 TSRMLS_DC);    zend_update_property_long(ce, getThis(), "pos", sizeof ("pos") - 1, ++Z_LVAL_P(pos) TSRMLS_CC);}

/* {{{ MongoDB::__construct */PHP_METHOD(MongoDB, __construct) {    zval *zlink;    char *name;    int name_len;    mongo_db *db;    mongoclient *link;    if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "Os", &zlink, mongo_ce_MongoClient, &name, &name_len) == FAILURE) {        zval *object = getThis();        ZVAL_NULL(object);        return;    }    if (0 == name_len ||            0 != strchr(name, ' ') || 0 != strchr(name, '.') || 0 != strchr(name, '//') ||            0 != strchr(name, '/') || 0 != strchr(name, '$')) {#if ZEND_MODULE_API_NO >= 20060613        zend_throw_exception_ex(zend_exception_get_default(TSRMLS_C), 0 TSRMLS_CC, "MongoDB::__construct(): invalid name %s", name);#else        zend_throw_exception_ex(zend_exception_get_default(), 0 TSRMLS_CC, "MongoDB::__construct(): invalid name %s", name);#endif /* ZEND_MODULE_API_NO >= 20060613 */        return;    }    db = (mongo_db*)zend_object_store_get_object(getThis() TSRMLS_CC);    db->link = zlink;    zval_add_ref(&db->link);    PHP_MONGO_GET_LINK(zlink);    if (link->servers->options.default_w != -1) {        zend_update_property_long(mongo_ce_DB, getThis(), "w", strlen("w"), link->servers->options.default_w TSRMLS_CC);    } else if (link->servers->options.default_wstring != NULL) {        zend_update_property_string(mongo_ce_DB, getThis(), "w", strlen("w"), link->servers->options.default_wstring TSRMLS_CC);    }    if (link->servers->options.default_wtimeout != -1) {        zend_update_property_long(mongo_ce_DB, getThis(), "wtimeout", strlen("wtimeout"), link->servers->options.default_wtimeout TSRMLS_CC);    }    mongo_read_preference_copy(&link->servers->read_pref, &db->read_pref);    MAKE_STD_ZVAL(db->name);    ZVAL_STRING(db->name, name, 1);}

/* {{{ proto void Riak/BucketProperties->__construct(int $nVal, bool $allowMult)Creates a new RiakBucketProperties */PHP_METHOD(RiakBucketProperties, __construct){	long nVal;	zend_bool allowMult;	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "lb", &nVal, &allowMult) == FAILURE) {		return;	}	zend_update_property_long(riak_bucket_properties_ce, getThis(), "nVal", sizeof("nVal")-1, nVal TSRMLS_CC);	zend_update_property_bool(riak_bucket_properties_ce, getThis(), "allowMult", sizeof("allowMult")-1, allowMult TSRMLS_CC);}

void NS(MqBufferS_New) (zval *return_value, MQ_BUF buf TSRMLS_DC){    // convert to an object instance    if (object_init_ex(return_value, NS(MqBufferS)) == FAILURE) {        RaiseError("unable to create an 'MqBufferS' instance.");        return;    }    // link 'buf' with the object instance    zend_update_property_long(NS(MqBufferS), return_value, ID(__buf), (long) buf TSRMLS_CC);    return;}

static int coro_exit_handler(zend_execute_data *execute_data){    zval ex;    zend_object *obj;    zend_long flags = 0;    if (sw_get_current_cid() != -1)    {        flags |= SW_EXIT_IN_COROUTINE;    }    if (SwooleG.serv && SwooleG.serv->gs->start)    {        flags |= SW_EXIT_IN_SERVER;    }    if (flags)    {        const zend_op *opline = EX(opline);        zval _exit_status;        zval *exit_status = NULL;        if (opline->op1_type != IS_UNUSED)        {            if (opline->op1_type == IS_CONST)            {                // see: https://github.com/php/php-src/commit/e70618aff6f447a298605d07648f2ce9e5a284f5#ifdef EX_CONSTANT                exit_status = EX_CONSTANT(opline->op1);#else                exit_status = RT_CONSTANT(opline, opline->op1);#endif            }            else            {                exit_status = EX_VAR(opline->op1.var);            }            if (Z_ISREF_P(exit_status))            {                exit_status = Z_REFVAL_P(exit_status);            }        }        else        {            exit_status = &_exit_status;            ZVAL_NULL(exit_status);        }        obj = zend_throw_error_exception(swoole_exit_exception_class_entry_ptr, "swoole exit.", 0, E_ERROR TSRMLS_CC);        ZVAL_OBJ(&ex, obj);        zend_update_property_long(swoole_exit_exception_class_entry_ptr, &ex, ZEND_STRL("flags"), flags);        Z_TRY_ADDREF_P(exit_status);        zend_update_property(swoole_exit_exception_class_entry_ptr, &ex, ZEND_STRL("status"), exit_status);    }    return ZEND_USER_OPCODE_DISPATCH;}

/* {{{ MongoBinData::__construct() */PHP_METHOD(MongoBinData, __construct){	char *bin;	long bin_len, type = PHP_MONGO_BIN_GENERIC;	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|l", &bin, &bin_len, &type) == FAILURE) {		return;	}	zend_update_property_stringl(mongo_ce_BinData, getThis(), "bin", strlen("bin"), bin, bin_len TSRMLS_CC);	zend_update_property_long(mongo_ce_BinData, getThis(), "type", strlen("type"), type TSRMLS_CC);}

static PHP_METHOD(Hello, updateProperties) {    zval *obj;    obj = getThis();    zend_update_property_string(hello_ce, obj, "name", sizeof("name") -1, "name-update" TSRMLS_CC);//更新属性值, $this->name = name    zend_update_property_long(hello_ce, obj, "age", sizeof("age") -1, 10 TSRMLS_CC); //this->age = age    zend_update_property_string(hello_ce, obj, "last_name", sizeof("last_name") -1, "leon-update" TSRMLS_CC);//this->last_name = "leon"    zend_update_property_null(hello_ce, obj, "first_name", sizeof("first_name") - 1 TSRMLS_CC); //this->first_name = null;    zend_update_property_bool(hello_ce, obj, "sex", sizeof("sex") -1, 0 TSRMLS_CC); //this->sex = true    zend_update_property_double(hello_ce, obj, "score", sizeof("score") -1, 15.50 TSRMLS_CC); //this->score = 12.50}

static PHP_METHOD(swoole_http2_client_coro, __construct){    char *host;    zend_size_t host_len;    long port = 80;    zend_bool ssl = SW_FALSE;    if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|lb", &host, &host_len, &port, &ssl) == FAILURE)    {        return;    }    if (host_len <= 0)    {        zend_throw_exception(swoole_exception_class_entry_ptr, "host is empty.", SW_ERROR_INVALID_PARAMS TSRMLS_CC);        RETURN_FALSE;    }    http2_client_property *hcc;    hcc = (http2_client_property*) emalloc(sizeof(http2_client_property));    bzero(hcc, sizeof(http2_client_property));    swoole_set_property(getThis(), HTTP2_CLIENT_CORO_PROPERTY, hcc);    php_context *context = emalloc(sizeof(php_context));    swoole_set_property(getThis(), HTTP2_CLIENT_CORO_CONTEXT, context);    context->onTimeout = NULL;#if PHP_MAJOR_VERSION < 7    context->coro_params = getThis();#else    context->coro_params = *getThis();#endif    hcc->streams = swHashMap_new(8, http2_client_stream_free);    hcc->stream_id = 1;    long type = SW_FLAG_ASYNC | SW_SOCK_TCP;    if (ssl)    {#ifdef SW_USE_OPENSSL        type |= SW_SOCK_SSL;        hcc->ssl = 1;#else        swoole_php_fatal_error(E_ERROR, "require openssl library.");#endif    }    zend_update_property_long(swoole_http2_client_coro_class_entry_ptr, getThis(), ZEND_STRL("type"), type TSRMLS_CC);    hcc->host = estrndup(host, host_len);    hcc->host_len = host_len;    hcc->port = port;}

zend_object * pion_exception_new(zend_class_entry * exception_ce, const char * message, long code) {    zval ex;//    A(ex);    object_init_ex(&ex, exception_ce);//    zend_objects_new();    if (message) {        zend_update_property_string(exception_ce, &ex, "message", sizeof("message")-1, message);    }    if (code) {        zend_update_property_long(exception_ce, &ex, "code", sizeof("code")-1, code);    }    return Z_OBJ(ex);}

/* {{{ bool MongoDB::setWriteConcern(mixed w [, int wtimeout]) * Set the MongoDB write concern, which will be inherited by constructed * MongoCollection objects. */PHP_METHOD(MongoDB, setWriteConcern){	zval *write_concern;	long  wtimeout;	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z|l", &write_concern, &wtimeout) == FAILURE) {		return;	}	if (Z_TYPE_P(write_concern) == IS_LONG) {		zend_update_property_long(mongo_ce_DB, getThis(), "w", strlen("w"), Z_LVAL_P(write_concern) TSRMLS_CC);	} else if (Z_TYPE_P(write_concern) == IS_STRING) {		zend_update_property_stringl(mongo_ce_DB, getThis(), "w", strlen("w"), Z_STRVAL_P(write_concern), Z_STRLEN_P(write_concern) TSRMLS_CC);	} else {		php_error_docref(NULL TSRMLS_CC, E_WARNING, "expects parameter 1 to be an string or integer, %s given", zend_get_type_by_const(Z_TYPE_P(write_concern)));		RETURN_FALSE;	}	if (ZEND_NUM_ARGS() > 1) {		zend_update_property_long(mongo_ce_DB, getThis(), "wtimeout", strlen("wtimeout"), wtimeout TSRMLS_CC);	}	RETURN_TRUE;}