/* Takes a pointer to posix group and a pointer to an already initialized ZVAL * array container and fills the array with the posix group member data. */ int php_posix_group_to_array(struct group *g, zval *array_group) /* {{{ */ { zval array_members; int count; if (NULL == g) return 0; if (array_group == NULL || Z_TYPE_P(array_group) != IS_ARRAY) return 0; array_init(&array_members); add_assoc_string(array_group, "name", g->gr_name); if (g->gr_passwd) { add_assoc_string(array_group, "passwd", g->gr_passwd); } else { add_assoc_null(array_group, "passwd"); } for (count = 0; g->gr_mem[count] != NULL; count++) { add_next_index_string(&array_members, g->gr_mem[count]); } zend_hash_str_update(Z_ARRVAL_P(array_group), "members", sizeof("members")-1, &array_members); add_assoc_long(array_group, "gid", g->gr_gid); return 1; }
static int full_user_list(struct user_info *uentp, struct fulluserlistarg* arg,int count) { struct user_info userinfo=*uentp; struct userec *lookupuser; zval* element; if (!userinfo.active || !userinfo.pid) { return 0; } if (!HAS_PERM(getCurrentUser(), PERM_SEECLOAK) && userinfo.invisible && strcmp(userinfo.userid, getCurrentUser()->userid)) { /*Haohmaru.99.4.24.让隐身者能看见自己 */ return 0; } if (count+1<arg->start) return COUNT; if (count+1-arg->start>=arg->num) return QUIT; MAKE_STD_ZVAL ( element ); array_init ( element ); add_assoc_bool ( element, "invisible", userinfo.invisible ); add_assoc_long ( element, "pid", userinfo.pid ); add_assoc_bool ( element, "isfriend", isfriend(userinfo.userid) ); add_assoc_string ( element, "userid", userinfo.userid, 1 ); add_assoc_string ( element, "username", userinfo.username, 1 ); if( getuser(userinfo.userid, &lookupuser) == 0 ) lookupuser=NULL; add_assoc_string ( element, "userfrom", HAS_PERM(getCurrentUser(), PERM_SYSOP)? userinfo.from: SHOW_USERIP(lookupuser, userinfo.from), 1 ); add_assoc_string ( element, "mode", ModeType(userinfo.mode), 1 ); add_assoc_long ( element, "idle", (long)(time(0) - userinfo.freshtime)/60 ); zend_hash_index_update(Z_ARRVAL_P(arg->return_value), count+1-arg->start, (void *) &element, sizeof(zval *), NULL); return COUNT; }
static void _php_cal_info(int cal, zval **ret) { zval *months, *smonths; int i; struct cal_entry_t *calendar; calendar = &cal_conversion_table[cal]; array_init(*ret); MAKE_STD_ZVAL(months); MAKE_STD_ZVAL(smonths); array_init(months); array_init(smonths); for (i = 1; i <= calendar->num_months; i++) { add_index_string(months, i, calendar->month_name_long[i], 1); add_index_string(smonths, i, calendar->month_name_short[i], 1); } add_assoc_zval(*ret, "months", months); add_assoc_zval(*ret, "abbrevmonths", smonths); add_assoc_long(*ret, "maxdaysinmonth", calendar->max_days_in_month); add_assoc_string(*ret, "calname", calendar->name, 1); add_assoc_string(*ret, "calsymbol", calendar->symbol, 1); }
/* {{{ 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); } }
static int pdo_dblib_stmt_get_column_meta(pdo_stmt_t *stmt, zend_long colno, zval *return_value) { pdo_dblib_stmt *S = (pdo_dblib_stmt*)stmt->driver_data; pdo_dblib_db_handle *H = S->H; DBTYPEINFO* dbtypeinfo; if(colno >= stmt->column_count || colno < 0) { return FAILURE; } array_init(return_value); dbtypeinfo = dbcoltypeinfo(H->link, colno+1); if(!dbtypeinfo) return FAILURE; add_assoc_long(return_value, "max_length", dbcollen(H->link, colno+1) ); add_assoc_long(return_value, "precision", (int) dbtypeinfo->precision ); add_assoc_long(return_value, "scale", (int) dbtypeinfo->scale ); add_assoc_string(return_value, "column_source", dbcolsource(H->link, colno+1)); add_assoc_string(return_value, "native_type", pdo_dblib_get_field_name(dbcoltype(H->link, colno+1))); add_assoc_long(return_value, "native_type_id", dbcoltype(H->link, colno+1)); add_assoc_long(return_value, "native_usertype_id", dbcolutype(H->link, colno+1)); return 1; }
void wkhtmltox_warning(wkhtmltopdf_converter *c, const char *msg) { zval *warning; MAKE_STD_ZVAL(warning); array_init(warning); add_assoc_string(warning, "status", "warning", 1); add_assoc_string(warning, "message", (char *)msg, 1); add_next_index_zval(wkhtmltox_errorlog, warning); }
static void bbs_make_vote_array(zval * array, struct votebal *vbal) { add_assoc_string(array, "USERID", vbal->userid, 1); add_assoc_string(array, "TITLE", vbal->title, 1); add_assoc_long(array, "DATE", vbal->opendate); if(vbal->type <= 5 && vbal->type >= 1) add_assoc_string(array, "TYPE", vote_type[vbal->type-1], 1); add_assoc_long(array, "MAXDAY", vbal->maxdays); }
void wkhtmltox_error(wkhtmltopdf_converter *c, const char *msg) { zval *error; MAKE_STD_ZVAL(error); array_init(error); add_assoc_string(error, "status", "error", 1); add_assoc_string(error, "message", (char *)msg, 1); add_next_index_zval(wkhtmltox_errorlog, error); }
/** * override __call() * it require two parameters, func_name and args **/ PHP_METHOD(McpackHessianClient, __call) { zend_class_entry *ce; zval *p_this, *args, *params, *result, *method, *tmp; char *func_name, *ret_str = NULL; int func_name_len = 0; size_t return_len = 0, max_len = 1024 * 1024 * 1024; p_this = getThis(); if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, p_this, "Osz", &ce, mcphessian_ce_ptr, &func_name, &func_name_len, &args) == FAILURE) { php_error(E_WARNING, "parse parameters error."); RETURN_NULL(); } // init params MAKE_STD_ZVAL(params); array_init(params); add_assoc_string(params, "jsonrpc", "2.0", 0); add_assoc_string(params, "method", func_name, 0); add_assoc_zval(params, "params", args); add_assoc_string(params, "id", "123456", 0); zval *pack = array2mcpack(params); // post data zval *z_url = zend_read_property(mcphessian_ce_ptr, p_this, ZEND_STRL("url"), 1 TSRMLS_CC); convert_to_string(z_url); char *url = Z_STRVAL_P(z_url); php_stream_context *context = php_stream_context_alloc(); MAKE_STD_ZVAL(method); ZVAL_STRING(method, "POST", 0); php_stream_context_set_option(context, "http", "method", method); php_stream_context_set_option(context, "http", "content", pack); // read data from stream php_stream *stream = php_stream_open_wrapper_ex(url, "rb", REPORT_ERRORS, NULL, context); if (stream) { ret_str = php_stream_get_line(stream, NULL, max_len, &return_len); } else { php_error(E_WARNING, "failed to open stream %s.", url); RETURN_NULL(); } MAKE_STD_ZVAL(tmp); ZVAL_STRINGL(tmp, ret_str, return_len, 0); result = mcpack2array(tmp); php_stream_close(stream); efree(ret_str); // get result from array zval **ret_val; if (zend_hash_exists(Z_ARRVAL_P(result), "result", 7)) { zend_hash_find(Z_ARRVAL_P(result), "result", 7, (void **)&ret_val); RETURN_ZVAL(*ret_val, 1, 0); } else { php_error(E_WARNING, "return value illegal."); RETURN_NULL(); } }
/* {{{ proto array accelerator_get_configuration() Obtain configuration information */ static ZEND_FUNCTION(opcache_get_configuration) { zval directives, version, blacklist; if (zend_parse_parameters_none() == FAILURE) { RETURN_FALSE; } if (!validate_api_restriction()) { RETURN_FALSE; } array_init(return_value); /* directives */ array_init(&directives); add_assoc_bool(&directives, "opcache.enable", ZCG(enabled)); add_assoc_bool(&directives, "opcache.enable_cli", ZCG(accel_directives).enable_cli); add_assoc_bool(&directives, "opcache.use_cwd", ZCG(accel_directives).use_cwd); add_assoc_bool(&directives, "opcache.validate_timestamps", ZCG(accel_directives).validate_timestamps); add_assoc_bool(&directives, "opcache.inherited_hack", ZCG(accel_directives).inherited_hack); add_assoc_bool(&directives, "opcache.dups_fix", ZCG(accel_directives).ignore_dups); add_assoc_bool(&directives, "opcache.revalidate_path", ZCG(accel_directives).revalidate_path); add_assoc_long(&directives, "opcache.log_verbosity_level", ZCG(accel_directives).log_verbosity_level); add_assoc_long(&directives, "opcache.memory_consumption", ZCG(accel_directives).memory_consumption); add_assoc_long(&directives, "opcache.interned_strings_buffer",ZCG(accel_directives).interned_strings_buffer); add_assoc_long(&directives, "opcache.max_accelerated_files", ZCG(accel_directives).max_accelerated_files); add_assoc_double(&directives, "opcache.max_wasted_percentage", ZCG(accel_directives).max_wasted_percentage); add_assoc_long(&directives, "opcache.consistency_checks", ZCG(accel_directives).consistency_checks); add_assoc_long(&directives, "opcache.force_restart_timeout", ZCG(accel_directives).force_restart_timeout); add_assoc_long(&directives, "opcache.revalidate_freq", ZCG(accel_directives).revalidate_freq); add_assoc_string(&directives, "opcache.preferred_memory_model", STRING_NOT_NULL(ZCG(accel_directives).memory_model)); add_assoc_string(&directives, "opcache.blacklist_filename", STRING_NOT_NULL(ZCG(accel_directives).user_blacklist_filename)); add_assoc_long(&directives, "opcache.max_file_size", ZCG(accel_directives).max_file_size); add_assoc_string(&directives, "opcache.error_log", STRING_NOT_NULL(ZCG(accel_directives).error_log)); add_assoc_bool(&directives, "opcache.protect_memory", ZCG(accel_directives).protect_memory); add_assoc_bool(&directives, "opcache.save_comments", ZCG(accel_directives).save_comments); add_assoc_bool(&directives, "opcache.load_comments", ZCG(accel_directives).load_comments); add_assoc_bool(&directives, "opcache.fast_shutdown", ZCG(accel_directives).fast_shutdown); add_assoc_bool(&directives, "opcache.enable_file_override", ZCG(accel_directives).file_override_enabled); add_assoc_long(&directives, "opcache.optimization_level", ZCG(accel_directives).optimization_level); add_assoc_zval(return_value, "directives", &directives); /*version */ array_init(&version); add_assoc_string(&version, "version", ACCELERATOR_VERSION); add_assoc_string(&version, "opcache_product_name", ACCELERATOR_PRODUCT_NAME); add_assoc_zval(return_value, "version", &version); /* blacklist */ array_init(&blacklist); zend_accel_blacklist_apply(&accel_blacklist, add_blacklist_path, &blacklist); add_assoc_zval(return_value, "blacklist", &blacklist); }
/** * Internal function that goes through every property specified in the PHP.ini * file and for each of the properties checks that such property exists in the * data set properties array. If a property exists, then a corresponding value * is added to the array that will be returned to PHP. If a property does not * exist, then a "Switch Data Set" message is returned as the property value * @param returnArray a pointer to the Zend array to store results in. */ void buildArray(zval *returnArray) { char* propertyName; char *valueString; char* methodString; int propertyIndex; int valueCount; int valueIndex; int32_t sigRank; for(propertyIndex = 0; propertyIndex < FIFTYONE_G(ws)->dataSet->requiredPropertyCount; propertyIndex++) { propertyName = (char*)fiftyoneDegreesGetPropertyName( FIFTYONE_G(ws)->dataSet, *(FIFTYONE_G(ws)->dataSet->requiredProperties + propertyIndex)); valueCount = fiftyoneDegreesSetValues(FIFTYONE_G(ws), propertyIndex); if (valueCount == 1) { valueString = (char*)fiftyoneDegreesGetValueName( FIFTYONE_G(ws)->dataSet, *FIFTYONE_G(ws)->values); add_assoc_string(returnArray, propertyName, valueString, 1); } else if (valueCount > 1) { zval* valueArray; ALLOC_INIT_ZVAL(valueArray); array_init(valueArray); add_assoc_zval(returnArray, propertyName, valueArray); for(valueIndex = 0; valueIndex < valueCount; valueIndex++) { valueString = (char*)fiftyoneDegreesGetValueName( FIFTYONE_G(ws)->dataSet, *(FIFTYONE_G(ws)->values + valueIndex)); add_next_index_string(valueArray, valueString, 1); } } } // Add signature rank information. sigRank = fiftyoneDegreesGetSignatureRank(FIFTYONE_G(ws)); // SignatureRank is obsolete and will be removed in future versions. // Use Rank instead. add_assoc_long(returnArray, "SignatureRank", sigRank); add_assoc_long(returnArray, "Rank", sigRank); add_assoc_long(returnArray, "Difference", FIFTYONE_G(ws)->difference); // Add method that was used for detection to the results array. switch(FIFTYONE_G(ws)->method){ case NONE: methodString = "None"; break; case EXACT: methodString = "Exact"; break; case NUMERIC: methodString = "Numeric"; break; case NEAREST: methodString = "Nearest"; break; case CLOSEST: methodString = "Closest"; break; default: methodString = "Unknown"; break; } add_assoc_string(returnArray, "Method", methodString, 1); addDeviceIdToArray(returnArray); }
/**** * add by stiger, template, 摸板 */ static void bbs_make_tmpl_array(zval * array, struct a_template * ptemp, char *board) { add_assoc_string(array, "TITLE", ptemp->tmpl->title, 1); add_assoc_string(array, "TITLE_TMPL", ptemp->tmpl->title_tmpl, 1); add_assoc_long(array, "CONT_NUM", ptemp->tmpl->content_num); if( ptemp->tmpl->filename[0] ){ char path[STRLEN]; setbfile( path, board, ptemp->tmpl->filename ); add_assoc_string(array, "FILENAME", path,1); }else add_assoc_string(array, "FILENAME", ptemp->tmpl->filename,1); }
static void bbs_make_user_vote_array(zval * array, struct ballot *vbal) { if(vbal && vbal->uid[0]){ add_assoc_string(array, "USERID", vbal->uid, 1); add_assoc_long(array, "VOTED", vbal->voted); add_assoc_string(array, "MSG1", vbal->msg[0], 1); add_assoc_string(array, "MSG2", vbal->msg[1], 1); add_assoc_string(array, "MSG3", vbal->msg[2], 1); }else{ add_assoc_string(array, "USERID", "", 1); } }
static void describe_dict_fn (const char * const lang, const char * const name, const char * const desc, const char * const file, void * ud) /* {{{ */ { zval *zdesc = (zval *) ud; array_init(zdesc); add_assoc_string(zdesc, "lang", (char *)lang, 1); add_assoc_string(zdesc, "name", (char *)name, 1); add_assoc_string(zdesc, "desc", (char *)desc, 1); add_assoc_string(zdesc, "file", (char *)file, 1); }
/* {{{ QConfig::GetBatchConf( .. ) */ static PHP_METHOD(QConfig, GetBatchConf) { char *path, *idc; size_t path_len, idc_len; int i; qconf_batch_nodes bnodes; long get_flags = QCONF_WAIT; int ret = 0; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|sl", &path, &path_len, &idc, &idc_len, &get_flags) == FAILURE) { RETURN_NULL(); } init_qconf_batch_nodes(&bnodes); if (QCONF_OK != ret) { RETVAL_NULL(); } if (QCONF_NOWAIT == get_flags) { ret = qconf_aget_batch_conf(path, &bnodes, idc); } else { ret = qconf_get_batch_conf(path, &bnodes, idc); } if (QCONF_OK == ret && (bnodes.count >= 0)) { array_init(return_value); for (i = 0; i < bnodes.count; i++) { #if PHP_VERSION_ID >= 70000 add_assoc_string(return_value, bnodes.nodes[i].key, bnodes.nodes[i].value); #else add_assoc_string(return_value, bnodes.nodes[i].key, bnodes.nodes[i].value, 1); #endif } destroy_qconf_batch_nodes(&bnodes); } else { RETVAL_NULL(); } return; }
void CACHE_COLL::serialize_php(zval *zcolllist) { zval *zcoll; MAKE_STD_ZVAL(zcoll); array_init(zcoll); add_assoc_long(zcoll, (char *)"coll_id", this->coll_id); add_assoc_long(zcoll, (char *)"base_id", this->base_id); add_assoc_string(zcoll, (char *)"name", this->name, true); #if GETPREFS add_assoc_string(zcoll, (char *)"prefs", this->prefs, true); #endif // add_assoc_bool(zcoll, (char *)"registered", this->registered); add_next_index_zval(zcolllist, zcoll); }
static void bbs_make_detail_tmpl_array(zval * array, struct s_content * cont) { add_assoc_string(array, "TEXT", cont->text, 1); add_assoc_long(array, "LENGTH", cont->length); }
int php_posix_passwd_to_array(struct passwd *pw, zval *return_value) /* {{{ */ { if (NULL == pw) return 0; if (NULL == return_value || Z_TYPE_P(return_value) != IS_ARRAY) return 0; add_assoc_string(return_value, "name", pw->pw_name); add_assoc_string(return_value, "passwd", pw->pw_passwd); add_assoc_long (return_value, "uid", pw->pw_uid); add_assoc_long (return_value, "gid", pw->pw_gid); add_assoc_string(return_value, "gecos", pw->pw_gecos); add_assoc_string(return_value, "dir", pw->pw_dir); add_assoc_string(return_value, "shell", pw->pw_shell); return 1; }
/* * plphp_zval_from_tuple * Build a PHP hash from a tuple. */ zval * plphp_zval_from_tuple(HeapTuple tuple, TupleDesc tupdesc) { int i; char *attname = NULL; zval *array; MAKE_STD_ZVAL(array); array_init(array); for (i = 0; i < tupdesc->natts; i++) { char *attdata; /* Get the attribute name */ attname = tupdesc->attrs[i]->attname.data; /* and get its value */ if ((attdata = SPI_getvalue(tuple, tupdesc, i + 1)) != NULL) { /* "true" means strdup the string */ add_assoc_string(array, attname, attdata, true); pfree(attdata); } else add_assoc_null(array, attname); } return array; }
static PHP_METHOD(midgard_key_config_context, list_key_config) { RETVAL_FALSE; zval *zval_object = getThis(); if (zend_parse_parameters_none() == FAILURE) return; MidgardKeyConfigContext *kctx = (MidgardKeyConfigContext *) __php_gobject_ptr(zval_object); array_init (return_value); gint n_cfgs; gchar **cfgs = midgard_key_config_context_list_key_config (kctx, &n_cfgs); if (!cfgs) return; guint i; for (i = 0; i < n_cfgs; i++) { add_assoc_string(return_value, (gchar *)cfgs[i], "", 1); } g_strfreev(cfgs); }
static PHP_METHOD(Hello, addProperties) { zval *obj; obj = getThis(); /*add zval property*/ zval *arr; MAKE_STD_ZVAL(arr); array_init(arr); add_assoc_string(arr, "e", "hello", 1); add_index_string(arr, 1, "hello1111", 1); add_property_zval_ex(obj, "persons", strlen("persons")+1, arr TSRMLS_CC); Z_DELREF_P(arr); /*add double property*/ add_property_double(obj, "d", 10.5); /*add bool property*/ add_property_bool(obj, "b", 1); /*add string property*/ char *str = "hello str"; add_property_string(obj, "str", str, 1); /*add long property*/ add_property_long(obj, "l", 12); }
ZEND_METHOD( appnetServer , getHeader ) { array_init(return_value); aeServer* appserv = APPNET_G( appserv ); int i; int connfd = appserv->worker->connfd; httpHeader* header = &appserv->connlist[connfd].hh; if( header->protocol == HTTP ) { add_assoc_string(return_value, "Protocol" , "HTTP" ); } else if( header->protocol == WEBSOCKET ) { add_assoc_string(return_value, "Protocol" , "WEBSOCKET" ); } else { add_assoc_string(return_value, "Protocol" , "TCP" ); return; } add_assoc_string(return_value, "Method" , header->method ); add_assoc_string(return_value, "Uri" , header->uri ); add_assoc_string(return_value, "Version" , header->version ); for( i = 0 ; i < header->filed_nums ; i++ ) { add_assoc_string(return_value, header->fileds[i].key , header->fileds[i].value ); } }
PHP_METHOD(MongoDB, getReadPreference) { mongo_db *db; PHP_MONGO_GET_DB(getThis()); array_init(return_value); add_assoc_string(return_value, "type", mongo_read_preference_type_to_name(db->read_pref.type), 1); php_mongo_add_tagsets(return_value, &db->read_pref); }
static void bbs_make_detail_vote_array(zval * array, struct votebal *vbal) { int i; char tmp[10]; add_assoc_string(array, "USERID", vbal->userid, 1); add_assoc_string(array, "TITLE", vbal->title, 1); add_assoc_long(array, "DATE", vbal->opendate); if(vbal->type <= 5 && vbal->type >= 1) add_assoc_string(array, "TYPE", vote_type[vbal->type-1], 1); add_assoc_long(array, "MAXDAY", vbal->maxdays); add_assoc_long(array, "MAXTKT", vbal->maxtkt); add_assoc_long(array, "TOTALITEMS", vbal->totalitems); for(i=0; i < vbal->totalitems; i++){ sprintf(tmp,"ITEM%d",i+1); add_assoc_string(array, tmp, vbal->items[i], 1); } }
static void php_enchant_list_dicts_fn( const char * const lang_tag, const char * const provider_name, const char * const provider_desc, const char * const provider_file, void * ud) /* {{{ */ { zval *zdesc = (zval *) ud; zval tmp_array; array_init(&tmp_array); add_assoc_string(&tmp_array, "lang_tag", (char *)lang_tag); add_assoc_string(&tmp_array, "provider_name", (char *)provider_name); add_assoc_string(&tmp_array, "provider_desc", (char *)provider_desc); add_assoc_string(&tmp_array, "provider_file", (char *)provider_file); if (Z_TYPE_P(zdesc) != IS_ARRAY) { array_init(zdesc); } add_next_index_zval(zdesc, &tmp_array); }
/** * Adds a new element to the array with the key Id and the value as the device * Id. * @param returnArray the array being built */ void addDeviceIdToArray(zval *returnArray) { int componentIndex; int bufferLength = FIFTYONE_G(ws)->dataSet->header.components.count * 10; char *buffer = (char *)malloc(bufferLength * sizeof(char)); if (buffer != NULL) { fiftyoneDegreesGetDeviceId(FIFTYONE_G(ws), buffer, bufferLength); add_assoc_string(returnArray, "Id", buffer, 1); free(buffer); } }
PHP_METHOD(MongoCollection, getReadPreference) { mongo_collection *c; PHP_MONGO_GET_COLLECTION(getThis()); array_init(return_value); add_assoc_long(return_value, "type", c->read_pref.type); add_assoc_string(return_value, "type_string", mongo_read_preference_type_to_name(c->read_pref.type), 1); php_mongo_add_tagsets(return_value, &c->read_pref); }
static void add_expr_to_array(zval *expressions, uri_template_expr *expr) { uri_template_var *next; zval *result; zval *vars; char op[2] = {expr->op, 0}; char sep[2] = {expr->sep, 0}; char ifemp[2] = {expr->ifemp, 0}; MAKE_STD_ZVAL(result); array_init(result); add_assoc_string(result, "op", op, 1); add_assoc_string(result, "sep", sep, 1); add_assoc_string(result, "ifemp", ifemp, 1); add_assoc_bool(result, "allow", expr->allow); add_assoc_bool(result, "named", expr->named); add_assoc_bool(result, "error", expr->error); MAKE_STD_ZVAL(vars); array_init_size(vars, expr->vars->count); next = expr->vars->first; while (next != NULL) { zval *var; MAKE_STD_ZVAL(var); array_init(var); add_assoc_string(var, "name", next->name, 1); add_assoc_long(var, "length", next->length); add_assoc_bool(var, "explode", next->explode); add_next_index_zval(vars, var); next = next->next; } add_assoc_zval(result, "vars", vars); add_next_index_zval(expressions, result); }
static int pdo_dblib_stmt_get_column_meta(pdo_stmt_t *stmt, zend_long colno, zval *return_value) { pdo_dblib_stmt *S = (pdo_dblib_stmt*)stmt->driver_data; pdo_dblib_db_handle *H = S->H; DBTYPEINFO* dbtypeinfo; int coltype; if(colno >= stmt->column_count || colno < 0) { return FAILURE; } array_init(return_value); dbtypeinfo = dbcoltypeinfo(H->link, colno+1); if(!dbtypeinfo) return FAILURE; coltype = dbcoltype(H->link, colno+1); add_assoc_long(return_value, "max_length", dbcollen(H->link, colno+1) ); add_assoc_long(return_value, "precision", (int) dbtypeinfo->precision ); add_assoc_long(return_value, "scale", (int) dbtypeinfo->scale ); add_assoc_string(return_value, "column_source", dbcolsource(H->link, colno+1)); add_assoc_string(return_value, "native_type", pdo_dblib_get_field_name(coltype)); add_assoc_long(return_value, "native_type_id", coltype); add_assoc_long(return_value, "native_usertype_id", dbcolutype(H->link, colno+1)); switch (coltype) { case SQLBIT: case SQLINT1: case SQLINT2: case SQLINT4: add_assoc_long(return_value, "pdo_type", PDO_PARAM_INT); break; default: add_assoc_long(return_value, "pdo_type", PDO_PARAM_STR); break; } return 1; }
static void enumerate_providers_fn (const char * const name, const char * const desc, const char * const file, void * ud) /* {{{ */ { zval *zdesc = (zval *) ud; zval tmp_array; array_init(&tmp_array); add_assoc_string(&tmp_array, "name", (char *)name); add_assoc_string(&tmp_array, "desc", (char *)desc); add_assoc_string(&tmp_array, "file", (char *)file); if (Z_TYPE_P(zdesc)!=IS_ARRAY) { array_init(zdesc); } add_next_index_zval(zdesc, &tmp_array); }