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

/* {{{ MongoCursor->getCursorInfo: Return information about the current query (by @crodas) */PHP_METHOD(MongoCursor, info){  mongo_cursor *cursor = (mongo_cursor*)zend_object_store_get_object(getThis() TSRMLS_CC);  MONGO_CHECK_INITIALIZED(cursor->link, MongoCursor);  array_init(return_value);  add_assoc_string(return_value, "ns", cursor->ns, 1);  add_assoc_long(return_value, "limit", cursor->limit);  add_assoc_long(return_value, "batchSize", cursor->batch_size);  add_assoc_long(return_value, "skip", cursor->skip);  if (cursor->query) {    add_assoc_zval(return_value, "query", cursor->query);    zval_add_ref(&cursor->query);  } else {    add_assoc_null(return_value, "query");  }  if (cursor->fields) {    add_assoc_zval(return_value, "fields", cursor->fields);    zval_add_ref(&cursor->fields);  } else {    add_assoc_null(return_value, "fields");  }      add_assoc_bool(return_value, "started_iterating", cursor->started_iterating);  if (cursor->started_iterating) {    add_assoc_long(return_value, "id", (long)cursor->cursor_id);    add_assoc_long(return_value, "at", cursor->at);    add_assoc_long(return_value, "numReturned", cursor->num);    add_assoc_string(return_value, "server", cursor->server->label, 1);  }}

skyray_process_watcher_t * skyray_process_watcher_new(skyray_reactor_t *reactor, zval *zprocess, zval *handler){    zval object;    skyray_process_watcher_t *intern;    skyray_process_t *process = skyray_process_from_obj(Z_OBJ_P(zprocess));    if (process->watcher) {        zend_throw_exception_ex(skyray_ce_InvalidParamException, 0, "The process is already under watching, unable to watch again");        return NULL;    }    object_init_ex(&object, skyray_ce_ProcessWatcher);    zend_update_property(skyray_ce_ProcessWatcherHandler, handler, ZEND_STRL("watcher"), &object);    intern = skyray_process_watcher_from_obj(Z_OBJ(object));    intern->process = process;    intern->handler = Z_OBJ_P(handler);    zval_add_ref(handler);    zval_add_ref(zprocess);    process->watcher = intern;    if (skyray_sigchld_count < 0) {        uv_signal_init(&reactor->loop, &skyray_sigchld);        skyray_sigchld_count = 0;    }    if (skyray_sigchld_count == 0) {        uv_signal_start(&skyray_sigchld, signal_cb, SIGCHLD);    }    skyray_sigchld_count ++;    return intern;}

/* {{{ MongoDBRef::create() * * DB refs are of the form: * array( '$ref' => <collection>, '$id' => <id>[, $db => <dbname>] ) */PHP_METHOD(MongoDBRef, create){	zval *zns, *zid, *zdb = 0;	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zz|z", &zns, &zid, &zdb) == FAILURE) {		return;	}	array_init(return_value);	/* add collection name */	convert_to_string(zns);	add_assoc_zval(return_value, "$ref", zns);	zval_add_ref(&zns);	/* add id field */	add_assoc_zval(return_value, "$id", zid);	zval_add_ref(&zid);	/* if we got a database name, add that, too */	if (zdb) {		convert_to_string(zdb);		add_assoc_zval(return_value, "$db", zdb);		zval_add_ref(&zdb);	}}

PHP_METHOD(MongoDB, execute){	zval *code = NULL, *args = NULL, *options = NULL, *zdata;	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z|aa", &code, &args, &options) == FAILURE) {		return;	}	/* turn the first argument into MongoCode */	if (Z_TYPE_P(code) != IS_OBJECT ||		Z_OBJCE_P(code) != mongo_ce_Code) {		if (Z_TYPE_P(code) == IS_STRING) {			zval *obj;			MAKE_STD_ZVAL(obj);			object_init_ex(obj, mongo_ce_Code);			MONGO_METHOD1(MongoCode, __construct, return_value, obj, code);			code = obj;		} else { /* This is broken code */			php_error_docref(NULL TSRMLS_CC, E_ERROR, "The argument is neither an object of MongoCode or a string");			return;		}	} else {		zval_add_ref(&code);	}	if (!args) {		MAKE_STD_ZVAL(args);		array_init(args);	} else {		zval_add_ref(&args);	}	/* create { $eval : code, args : [] } */	MAKE_STD_ZVAL(zdata);	array_init(zdata);	add_assoc_zval(zdata, "$eval", code);	add_assoc_zval(zdata, "args", args);	/* Check whether we have nolock as an option */	if (options) {		zval **nolock;		if (zend_hash_find(HASH_P(options), "nolock", strlen("nolock") + 1, (void**) &nolock) == SUCCESS) {			convert_to_boolean_ex(nolock);			zval_add_ref(nolock);			add_assoc_zval(zdata, "nolock", *nolock);		}	}	MONGO_METHOD1(MongoDB, command, return_value, getThis(), zdata);	zval_ptr_dtor(&zdata);}

PHP_METHOD(swoole_http_server, on){    zval *callback;    zval *event_name;    swServer *serv;    if (SwooleGS->start > 0)    {        php_error_docref(NULL TSRMLS_CC, E_WARNING, "Server is running. Unable to set event callback now.");        RETURN_FALSE;    }    if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zz", &event_name, &callback) == FAILURE)    {        return;    }    SWOOLE_GET_SERVER(getThis(), serv);    char *func_name = NULL;    if (!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);    if (strncasecmp("request", Z_STRVAL_P(event_name), Z_STRLEN_P(event_name)) == 0)    {        zval_add_ref(&callback);        php_sw_http_server_callbacks[0] = callback;    }    else if (strncasecmp("message", Z_STRVAL_P(event_name), Z_STRLEN_P(event_name)) == 0)    {        zval_add_ref(&callback);        php_sw_http_server_callbacks[1] = callback;    }    else if (strncasecmp("handshake", Z_STRVAL_P(event_name), Z_STRLEN_P(event_name)) == 0)    {        zval_add_ref(&callback);        php_sw_http_server_callbacks[2] = callback;    }    else if (strncasecmp("open", Z_STRVAL_P(event_name), Z_STRLEN_P(event_name)) == 0)    {        zval_add_ref(&callback);        php_sw_http_server_callbacks[3] = callback;    }    else    {        zend_call_method_with_2_params(&getThis(), swoole_server_class_entry_ptr, NULL, "on", &return_value, event_name, callback);    }}

void php_functional_append_array_value(int hash_key_type, zval **return_value, zval **value, char *string_key, uint string_key_len, int int_key){	zval_add_ref(return_value);	zval_add_ref(value);	switch (hash_key_type) {		case HASH_KEY_IS_LONG:			zend_hash_index_update(Z_ARRVAL_PP(return_value), int_key, (void *)value, sizeof(zval *), NULL);			break;		case HASH_KEY_IS_STRING:			zend_hash_update(Z_ARRVAL_PP(return_value), string_key, string_key_len, (void *)value, sizeof(zval *), NULL);			break;	}}

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);}

static void json_path_append_zval(json_path_object *intern, json_path *path, zval *zv){    if (path->collection_stack.len > 0) {        json_path_stack_elem *stack_elem = simple_vector_get_last(            &intern->path_stack, json_path_stack_elem);        zval *outer_zv = *simple_vector_get_last(            &path->collection_stack, zval *);        zval_add_ref(&zv);        if (stack_elem->type == TYPE_ARRAY) {            add_next_index_zval(outer_zv, zv);        } else {            if (intern->objects_as_arrays) {                add_assoc_zval_ex(outer_zv, stack_elem->key,                    stack_elem->key_len+1, zv);            } else {                add_property_zval_ex(outer_zv,                     (stack_elem->key_len ? stack_elem->key : "_empty_"),                    (stack_elem->key_len ? stack_elem->key_len+1 : sizeof("_empty_")),                    zv);                Z_DELREF_P(zv);            }        }    }

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);}

/** * Replaces the PHP callback on an event. *  * @param  callback * @return void */PHP_METHOD(Event, setCallback){	event_object *obj;	dCALLBACK;		if(zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &callback) != SUCCESS) {		return;	}		CHECK_CALLBACK;		obj = (event_object *)zend_object_store_get_object(getThis() TSRMLS_CC);		/* TODO: Remove? */	assert(obj->callback);		/* Destroy existing callback reference */	if(obj->callback)	{		zval_ptr_dtor(&obj->callback);	}		zval_add_ref(&callback);	obj->callback = callback;}

/* {{{ proto MongoCollection MongoDB::dropCollection(string|MongoCollection collection)   Drops a collection and returns the database's response */PHP_METHOD(MongoDB, dropCollection){	zval *collection;	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &collection) == FAILURE) {		return;	}	if (Z_TYPE_P(collection) == IS_STRING) {		collection = php_mongo_db_selectcollection(getThis(), Z_STRVAL_P(collection), Z_STRLEN_P(collection) TSRMLS_CC);		if (!collection) {			/* An exception is set in this case */			return;		}	} else if (Z_TYPE_P(collection) == IS_OBJECT && Z_OBJCE_P(collection) == mongo_ce_Collection) {		zval_add_ref(&collection);	} else {		php_error_docref(NULL TSRMLS_CC, E_WARNING, "expects parameter 1 to be an string or MongoCollection");		return;	}	php_mongocollection_drop(collection, return_value TSRMLS_CC);	zval_ptr_dtor(&collection);}

/* {{{ MongoDB::__construct */PHP_METHOD(MongoDB, __construct) {  zval *zlink;  char *name;  int name_len;  mongo_db *db;  mongo_link *link;  if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "Os", &zlink, mongo_ce_Mongo, &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);  db->slave_okay = link->slave_okay;  MAKE_STD_ZVAL(db->name);  ZVAL_STRING(db->name, name, 1);}

static PHP_METHOD(swoole_process, signal){    zval *callback = NULL;    long signo = 0;    if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "lz", &signo, &callback) == FAILURE)    {        return;    }    if (!SWOOLE_G(cli))    {        php_error_docref(NULL TSRMLS_CC, E_ERROR, "cannot use swoole_process::signal here.");        RETURN_FALSE;    }    if (SwooleGS->start)    {        if (signo == SIGTERM || signo == SIGALRM)        {            php_error_docref(NULL TSRMLS_CC, E_WARNING, "cannot use swoole_process::signal in swoole_server.");            RETURN_FALSE;        }    }    if (callback == NULL || ZVAL_IS_NULL(callback))    {        php_error_docref(NULL TSRMLS_CC, E_WARNING, "no callback.");        RETURN_FALSE;    }    char *func_name;    if (!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);    zval_add_ref(&callback);    signal_callback[signo] = callback;#if PHP_MAJOR_VERSION >= 5 && PHP_MINOR_VERSION >= 4    SwooleG.use_signalfd = 1;#else    SwooleG.use_signalfd = 0;#endif    php_swoole_check_reactor();    /**     * for swSignalfd_setup     */    SwooleG.main_reactor->check_signalfd = 1;    swSignal_add(signo, php_swoole_onSignal);    RETURN_TRUE;}

SKYRAY_METHOD(stream_client, createPipe){    zend_bool duplex = 0;    zval stream1, stream2;    int fds[2];    int sockret;    if (zend_parse_parameters(ZEND_NUM_ARGS(), "|b", &duplex) == FAILURE) {        return;    }    if (duplex) {        sockret = socketpair(AF_UNIX, SOCK_STREAM, 0, fds);    } else {        sockret = pipe(fds);    }    if (sockret == -1) {        RETURN_FALSE;    }    array_init(return_value);    object_init_ex(&stream1, skyray_ce_Stream);    object_init_ex(&stream2, skyray_ce_Stream);    skyray_stream_t * intern1 = skyray_stream_from_obj(Z_OBJ_P(&stream1));    skyray_stream_t * intern2 = skyray_stream_from_obj(Z_OBJ_P(&stream2));    skyray_stream_init_blocking(intern1, SR_PIPE, fds[0], NULL);    skyray_stream_init_blocking(intern2, SR_PIPE, fds[1], NULL);    if (duplex) {        skyray_stream_on_opened(intern1, SR_READABLE | SR_WRITABLE);        skyray_stream_on_opened(intern2, SR_READABLE | SR_WRITABLE);    } else {        skyray_stream_on_opened(intern1, SR_READABLE);        skyray_stream_on_opened(intern2, SR_WRITABLE);    }    add_index_zval(return_value, 0, &stream1);    add_index_zval(return_value, 1, &stream2);    zval_add_ref(&stream1);    zval_add_ref(&stream2);}

PHP_METHOD(swoole_http_server, on){    zval *callback;    char *event_name;    swServer *serv;    int len;    if (SwooleGS->start > 0)    {        php_error_docref(NULL TSRMLS_CC, E_WARNING, "Server is running. Unable to set event callback now.");        RETURN_FALSE;    }    if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sz", &event_name, &len, &callback) == FAILURE)    {        return;    }    SWOOLE_GET_SERVER(getThis(), serv);    char *func_name = NULL;    if (!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);    if (strncasecmp("request", event_name, len) == 0)    {        zval_add_ref(&callback);        php_sw_http_server_callbacks[0] = callback;    }    else if (strncasecmp("message", event_name, len) == 0)    {        zval_add_ref(&callback);        php_sw_http_server_callbacks[1] = callback;    }    else    {        php_error_docref(NULL TSRMLS_CC, E_ERROR, "Unknown event types[%s]", event_name);        RETURN_FALSE;    }}

/* {{{ proto void /Glib/Source->__construct()        Creates a new source and implicitly calls start on it, so you don't have to call start   */PHP_METHOD(GlibSource, __construct){	if (zend_parse_parameters_none_throw() == FAILURE) {		return;	}	// we put the zval in the php_glib_source and shake it all up	glib_source_object * source_object = Z_GLIB_SOURCE_P(getThis());	source_object->source = g_source_new(&php_glib_source_funcs, sizeof(GPhpSource));	source_object->source = g_source_ref(source_object->source);	source_object->is_php_source = TRUE;	GPhpSource *gsource = (GPhpSource *)source_object->source;	// copy our zval into our internal struct, return with getContext	ZVAL_COPY(&gsource->source_zval, getThis());	zval_add_ref(&gsource->source_zval);	zval_add_ref(&gsource->source_zval);}

/** public function ION/Process/IPC::create(mixed $ctx1 = null, mixed $ctx2 = null) : ION/IPC[] */CLASS_METHOD(ION_Process_IPC, create) {    zval one;    zval two;    zval * ctx1 = NULL;    zval * ctx2 = NULL;    ZEND_PARSE_PARAMETERS_START(0, 2)        Z_PARAM_OPTIONAL        Z_PARAM_ZVAL(ctx1)        Z_PARAM_ZVAL(ctx2)    ZEND_PARSE_PARAMETERS_END_EX(PION_ZPP_THROW);    if(ion_ipc_create(&one, &two, ctx1, ctx2, ION_IPC_CTX_RELEASE) == FAILURE) {        zend_throw_exception(ion_ce_ION_RuntimeException, ERR_ION_PROCESS_IPC_FAIL, 0);        return;    }    zval_add_ref(ctx1);    zval_add_ref(ctx2);    array_init(return_value);    add_next_index_zval(return_value, &one);    add_next_index_zval(return_value, &two);}

extern void xslt_assign_handler(struct xslt_function **func, zval **zfunc){    char error[] = "Invalid function passed to %s";    *func = emalloc(sizeof(struct xslt_function));    if (Z_TYPE_PP(zfunc) == IS_STRING) {        (*func)->obj = NULL;        zval_add_ref(zfunc);        (*func)->func = *zfunc;    }    else if (Z_TYPE_PP(zfunc) == IS_ARRAY) {        zval **obj;        zval **function;        if (zend_hash_index_find(Z_ARRVAL_PP(zfunc), 0, (void **) &obj) == FAILURE) {            efree(*func);            php_error(E_WARNING, error, get_active_function_name());            return;        }        if (zend_hash_index_find(Z_ARRVAL_PP(zfunc), 1, (void **) &function) == FAILURE) {            efree(*func);            php_error(E_WARNING, error, get_active_function_name());            return;        }        zval_add_ref(obj);        zval_add_ref(function);        (*func)->obj  = *obj;        (*func)->func = *function;    }    else {        efree(*func);        php_error(E_WARNING, error, get_active_function_name());    }}

/* {{{ META_API zval* meta_token_zval(TOKEN*) * Get the zval representation of a token */META_API zval* meta_token_zval(TOKEN *token) {    zval* tok_repr;    MAKE_STD_ZVAL(tok_repr);    array_init_size(tok_repr, 8);/* 8 instead of 5, so zend_hash_init doesn't need to round up */    add_assoc_long(tok_repr, "major", token->major);    add_assoc_bool(tok_repr, "dirty", token->dirty);    add_assoc_long(tok_repr, "start_line", token->start_line);    add_assoc_long(tok_repr, "end_line", token->end_line);    if(NULL != TOKEN_MINOR(token)) {        zval_add_ref(&token->minor);        add_assoc_zval(tok_repr, "minor", token->minor);    }    else {        add_assoc_null(tok_repr, "minor");    }    return tok_repr;}

/* {{{ 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);}

// Add a key-value pair to the hashtable of connection options.void conn_string_parser::add_key_value_pair( const char* value, int len TSRMLS_DC ){    zval_auto_ptr value_z;    ALLOC_INIT_ZVAL( value_z );    if( len == 0 ) {            ZVAL_STRINGL( value_z, "", 0, 1 /*dup*/ );    }    else {        ZVAL_STRINGL( value_z, const_cast<char*>( value ), len, 1 /*dup*/ );    }                    core::sqlsrv_zend_hash_index_update( *ctx, this->conn_options_ht, this->current_key, (void**)&value_z,                                          sizeof(zval*) TSRMLS_CC );    zval_add_ref( &value_z );   }

/* {{{ MongoCursor->hint */PHP_METHOD(MongoCursor, hint) {  zval *zfields, *query;  mongo_cursor *cursor = (mongo_cursor*)zend_object_store_get_object(getThis() TSRMLS_CC);  MONGO_CHECK_INITIALIZED(cursor->link, MongoCursor);  if (cursor->started_iterating) {    zend_throw_exception(mongo_ce_CursorException, "cannot modify cursor after beginning iteration.", 0 TSRMLS_CC);    return;  }  if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &zfields) == FAILURE ||      IS_SCALAR_P(zfields)) {    return;  }  query = cursor->query;  zval_add_ref(&zfields);  add_assoc_zval(query, "$hint", zfields);  RETURN_ZVAL(getThis(), 1, 0);}

void cpSettitle(char *title_name) {//    assert(MAX_TITLE_LENGTH > strlen(title) + 5);    char title[MAX_TITLE_LENGTH + 5] = {0};    strcat(title, "pool_");    strcat(title, title_name);#if PHP_MAJOR_VERSION == 5 && PHP_MINOR_VERSION > 4    zval *name_ptr, name;    name_ptr = &name;    ZVAL_STRING(name_ptr, title, 1);    zval_add_ref(&name_ptr);    zval *retval;    zval **args[1];    args[0] = &name_ptr;    zval *function;    MAKE_STD_ZVAL(function);    ZVAL_STRING(function, "cli_set_process_title", 1);    if (call_user_function_ex(EG(function_table), NULL, function, &retval, 1, args, 0, NULL TSRMLS_CC) == FAILURE)    {        return;    }    zval_ptr_dtor(&function);    if (retval)    {        zval_ptr_dtor(&retval);    }#else    bzero(sapi_module.executable_location, MAX_TITLE_LENGTH);    memcpy(sapi_module.executable_location, title, strlen(title));#endif}

/* {{{ MongoCode::__construct(string code[, array scope]) * Creates a new MongoCode object */PHP_METHOD(MongoCode, __construct){	char *code;	int code_len;	zval *zcope = 0;	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|a", &code, &code_len, &zcope) == FAILURE) {		return;	}	zend_update_property_stringl(mongo_ce_Code, getThis(), "code", strlen("code"), code, code_len TSRMLS_CC);	if (!zcope) {		MAKE_STD_ZVAL(zcope);		array_init(zcope);	} else {		zval_add_ref(&zcope);	}	zend_update_property(mongo_ce_Code, getThis(), "scope", strlen("scope"), zcope TSRMLS_CC);	/* get rid of extra ref */	zval_ptr_dtor(&zcope);}