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

static wi_process_t * _wi_process_init_with_argv(wi_process_t *process, int argc, const char **argv) {	wi_array_t			*array;	wi_string_t			*string;	struct utsname		name;#if defined(HAVE_NXGETLOCALARCHINFO)	const NXArchInfo	*archinfo;	cpu_type_t			cputype;	size_t				cputypesize;#elif defined(HAVE_SYSINFO) && defined(SI_ARCHITECTURE)	char				buffer[SYS_NMLN];#endif		array = wi_array_init_with_argv(wi_array_alloc(), argc, argv);		string = wi_array_first_data(array);		if(string) {		process->path = wi_retain(string);		process->name = wi_retain(wi_string_last_path_component(process->path));	} else {		process->path = wi_retain(WI_STR("unknown"));		process->name = wi_retain(process->path);	}		if(wi_array_count(array) <= 1)		process->arguments = wi_array_init(wi_array_alloc());	else		process->arguments = wi_retain(wi_array_subarray_with_range(array, wi_make_range(1, wi_array_count(array) - 1)));		wi_release(array);		uname(&name);		process->os_name = wi_string_init_with_cstring(wi_string_alloc(), name.sysname);	process->os_release = wi_string_init_with_cstring(wi_string_alloc(), name.release);#if defined(HAVE_NXGETLOCALARCHINFO)	cputypesize = sizeof(cputype);		if(sysctlbyname("sysctl.proc_cputype", &cputype, &cputypesize, NULL, 0) < 0)		cputype = NXGetLocalArchInfo()->cputype;		archinfo = NXGetArchInfoFromCpuType(cputype, CPU_SUBTYPE_MULTIPLE);		if(archinfo)		process->arch = wi_string_init_with_cstring(wi_string_alloc(), archinfo->name);#elif defined(HAVE_SYSINFO) && defined(SI_ARCHITECTURE)	if(sysinfo(SI_ARCHITECTURE, buffer, sizeof(buffer)) >= 0)		process->arch = wi_string_init_with_cstring(wi_string_alloc(), buffer);#endif	if(!process->arch)		process->arch = wi_string_init_with_cstring(wi_string_alloc(), name.machine);	return process;}

static wi_boolean_t _wi_file_copy_directory(wi_string_t *frompath, wi_string_t *topath) {	WI_FTS			*fts;	WI_FTSENT		*p;	wi_string_t		*path, *newpath;	char			*paths[2];	uint32_t		pathlength;	wi_boolean_t	result = true;	paths[0] = (char *) wi_string_cstring(frompath);;	paths[1] = NULL;	fts = wi_fts_open(paths, WI_FTS_LOGICAL | WI_FTS_NOSTAT, NULL);	if(!fts)		return false;		pathlength = wi_string_length(frompath);	while((p = wi_fts_read(fts))) {		path = wi_string_init_with_cstring(wi_string_alloc(), p->fts_path);		newpath = wi_string_init_with_cstring(wi_string_alloc(), p->fts_path + pathlength);		wi_string_insert_string_at_index(newpath, topath, 0);				switch(p->fts_info) {			case WI_FTS_NS:			case WI_FTS_ERR:			case WI_FTS_DNR:				errno = p->fts_errno;				result = false;				break;						case WI_FTS_DC:			case WI_FTS_DP:				break;							case WI_FTS_D:				if(!wi_file_create_directory(newpath, 0777))					result = false;				break;						default:				if(!_wi_file_copy_file(path, newpath))					result = false;				break;		}		wi_release(newpath);		wi_release(path);	}	wi_fts_close(fts);		return result;}

wi_string_t * wi_socket_certificate_hostname(wi_socket_t *socket) {#ifdef HAVE_OPENSSL_SSL_H	X509			*x509;	wi_string_t		*string;	char			hostname[MAXHOSTNAMELEN];	x509 = SSL_get_peer_certificate(socket->ssl);	if(!x509)		return NULL;	X509_NAME_get_text_by_NID(X509_get_subject_name(x509),							  NID_commonName,							  hostname,							  sizeof(hostname));		string = wi_string_init_with_cstring(wi_string_alloc(), hostname);		X509_free(x509);		return wi_autorelease(string);#else	return NULL;#endif}

wi_terminal_buffer_t * wi_terminal_buffer_init_with_terminal(wi_terminal_buffer_t *buffer, wi_terminal_t *terminal) {	buffer->terminal	= terminal;	buffer->textbuffer	= wi_string_init_with_capacity(wi_string_alloc(), _WI_TERMINAL_TEXTBUFFER_CAPACITY);	buffer->linebuffer	= wi_array_init_with_capacity(wi_array_alloc(), _WI_TERMINAL_LINEBUFFER_CAPACITY);		return buffer;}

wi_socket_t * wi_socket_init_with_address(wi_socket_t *_socket, wi_address_t *address, wi_socket_type_t type) {	_socket->address	= wi_copy(address);	_socket->close		= true;	_socket->buffer		= wi_string_init_with_capacity(wi_string_alloc(), WI_SOCKET_BUFFER_SIZE);	_socket->type		= type;	_socket->sd			= socket(wi_address_family(_socket->address), _socket->type, 0);		if(_socket->sd < 0) {		wi_error_set_errno(errno);				wi_release(_socket);				return NULL;	}		if(!_wi_socket_set_option_int(_socket, SOL_SOCKET, SO_REUSEADDR, 1)) {		wi_release(_socket);				return NULL;	}	#ifdef SO_REUSEPORT	if(!_wi_socket_set_option_int(_socket, SOL_SOCKET, SO_REUSEPORT, 1)) {		wi_release(_socket);				return NULL;	}#endif	return _socket;}

wi_string_t * wi_file_read_to_string(wi_file_t *file, wi_string_t *separator) {	wi_string_t		*string, *totalstring = NULL;	wi_uinteger_t	index, length;		_WI_FILE_ASSERT_OPEN(file);		while((string = wi_file_read(file, WI_FILE_BUFFER_SIZE))) {		if(!totalstring)			totalstring = wi_string_init(wi_string_alloc());				index = wi_string_index_of_string(string, separator, 0);				if(index == WI_NOT_FOUND) {			wi_string_append_string(totalstring, string);		} else {			length = wi_string_length(string);						wi_string_delete_characters_from_index(string, index);			wi_string_append_string(totalstring, string);			wi_file_seek(file, wi_file_offset(file) - length + index + 1);						break;		}	}		return wi_autorelease(totalstring);}

wi_array_t * wi_file_directory_contents_at_path(wi_string_t *path) {	wi_array_t		*contents;	wi_string_t		*name;	DIR				*dir;	struct dirent	de, *dep;		dir = opendir(wi_string_cstring(path));		if(!dir) {		wi_error_set_errno(errno);				return NULL;	}		contents = wi_array_init_with_capacity(wi_array_alloc(), 100);		while(readdir_r(dir, &de, &dep) == 0 && dep) {		if(strcmp(dep->d_name, ".") != 0 && strcmp(dep->d_name, "..") != 0) {			name = wi_string_init_with_cstring(wi_string_alloc(), dep->d_name);			wi_array_add_data(contents, name);			wi_release(name);		}	}	closedir(dir);		return wi_autorelease(contents);}

void wd_broadcast(wd_chat_t *chat, uint32_t n, wi_string_t *fmt, ...) {	wi_enumerator_t	*enumerator;	wi_string_t		*string;	wi_array_t		*users;	wd_user_t		*user;	va_list			ap;	va_start(ap, fmt);	string = wi_string_init_with_format_and_arguments(wi_string_alloc(), fmt, ap);	va_end(ap);		users = wd_chat_users(chat);		wi_array_rdlock(users);	enumerator = wi_array_data_enumerator(users);		while((user = wi_enumerator_next_data(enumerator))) {		if(wd_user_state(user) == WD_USER_LOGGED_IN) {			wd_user_lock_socket(user);			wi_socket_write_format(wd_user_socket(user), 0.0, WI_STR("%u %@%c"), n, string, WD_MESSAGE_SEPARATOR);			wd_user_unlock_socket(user);		}	}		wi_array_unlock(users);	wi_release(string);}

wi_boolean_t _wi_settings_set_path(wi_settings_t *settings, uint32_t index, wi_string_t *name, wi_string_t *value) {	wi_string_t		**string = (wi_string_t **) settings->spec[index].setting;		if(*string)		wi_release(*string);	if(wi_string_has_prefix(value, WI_STR("/")))		*string = wi_retain(value);	else if(settings->chroot)		*string = wi_string_init_with_format(wi_string_alloc(), WI_STR("/%@"), value);	else		*string = wi_string_init_with_format(wi_string_alloc(), WI_STR("%@/%@"), wi_root_path, value);	wi_string_normalize_path(*string);		return true;}

static void _wi_log_vlog(int priority, wi_string_t *fmt, va_list ap) {	wi_string_t		*string;	FILE			*fp;	const char		*cstring, *name, *path;	char			date[_WI_LOG_DATE_SIZE];		string = wi_string_init_with_format_and_arguments(wi_string_alloc(), fmt, ap);	cstring = wi_string_cstring(string);	wi_lock_lock(_wi_log_lock);		name = wi_string_cstring(wi_process_name(wi_process()));		_wi_log_date(date);	if(wi_log_stdout || wi_log_stderr)		fprintf(wi_log_stdout ? stdout : stderr, "%s %s[%d]: %s/n", date, name, getpid(), cstring);	else if(wi_log_startup && priority < LOG_INFO)		fprintf(stderr, "%s: %s/n", name, cstring);	else if(wi_log_tool)		fprintf((priority < LOG_INFO) ? stderr : stdout, "%s: %s/n", name, cstring);	if(wi_log_syslog)		syslog(priority, "%s", cstring);	if(wi_log_file && wi_log_path) {		path = wi_string_cstring(wi_full_path(wi_log_path));		fp = fopen(path, "a");		if(fp) {			fprintf(fp, "%s %s[%d]: %s/n", date, name, getpid(), cstring);			fclose(fp);						if(_wi_log_lines > 0 && wi_log_limit > 0) {				if(_wi_log_lines % (int) ((float) wi_log_limit / 10.0f) == 0) {					_wi_log_truncate(path);										_wi_log_lines = wi_log_limit;				}			}						_wi_log_lines++;		} else {			fprintf(stderr, "%s: %s: %s/n", name, path, strerror(errno));		}	}	if(wi_log_callback)		(*wi_log_callback)(string);	if(wi_log_startup && priority == LOG_ERR)		exit(1);	wi_lock_unlock(_wi_log_lock);		wi_release(string);}

wi_string_t * wi_socket_certificate_name(wi_socket_t *socket) {#ifdef HAVE_OPENSSL_SSL_H	X509			*x509 = NULL;	EVP_PKEY		*pkey = NULL;	wi_string_t		*string = NULL;	x509 = SSL_get_peer_certificate(socket->ssl);	if(!x509)		goto end;	pkey = X509_get_pubkey(x509);	if(!pkey)		goto end;		switch(EVP_PKEY_type(pkey->type)) {		case EVP_PKEY_RSA:			string = wi_string_init_with_cstring(wi_string_alloc(), "RSA");			break;		case EVP_PKEY_DSA:			string = wi_string_init_with_cstring(wi_string_alloc(), "DSA");			break;		case EVP_PKEY_DH:			string = wi_string_init_with_cstring(wi_string_alloc(), "DH");			break;		default:			break;	}	end:	if(x509)		X509_free(x509);	if(pkey)		EVP_PKEY_free(pkey);	return wi_autorelease(string);#else	return NULL;#endif}

wi_string_t * wi_string_with_format(wi_string_t *fmt, ...) {	wi_string_t		*string;	va_list			ap;		va_start(ap, fmt);	string = wi_string_init_with_format_and_arguments(wi_string_alloc(), fmt, ap);	va_end(ap);		return wi_autorelease(string);}

static wi_process_t * _wi_process_init_with_argv(wi_process_t *process, int argc, const char **argv) {	wi_array_t			*array;	wi_string_t			*string;	struct utsname		name;#ifdef HAVE_MACH_O_ARCH_H	const NXArchInfo	*arch_info;#endif		array = wi_array_init_with_argv(wi_array_alloc(), argc, argv);		string = wi_array_first_data(array);		if(string) {		process->path = wi_retain(string);		process->name = wi_retain(wi_string_last_path_component(process->path));	} else {		process->path = wi_retain(WI_STR("unknown"));		process->name = wi_retain(process->path);	}		if(wi_array_count(array) <= 1)		process->arguments = wi_array_init(wi_array_alloc());	else		process->arguments = wi_retain(wi_array_subarray_with_range(array, wi_make_range(1, wi_array_count(array) - 1)));		wi_release(array);		uname(&name);		process->os_name = wi_string_init_with_cstring(wi_string_alloc(), name.sysname);	process->os_release = wi_string_init_with_cstring(wi_string_alloc(), name.release);#ifdef HAVE_MACH_O_ARCH_H	arch_info = NXGetArchInfoFromCpuType(NXGetLocalArchInfo()->cputype, CPU_SUBTYPE_MULTIPLE);		process->arch = wi_string_init_with_cstring(wi_string_alloc(), arch_info->name);#else	process->arch = wi_string_init_with_cstring(wi_string_alloc(), name.machine);#endif	return process;}

void wi_test_initialize(void) {    char    *env;        env = getenv("wi_test_name");        if(env) {        _wi_tests_name = wi_string_init_with_utf8_string(wi_string_alloc(), env);                printf("*** wi_test_initialize(): wi_test_name = %s/n", env);    }}

void wd_sreply(wi_socket_t *socket, uint32_t n, wi_string_t *fmt, ...) {	wi_string_t		*string;	va_list			ap;		va_start(ap, fmt);	string = wi_string_init_with_format_and_arguments(wi_string_alloc(), fmt, ap);	va_end(ap);		wi_socket_write_format(socket, 0.0, WI_STR("%u %@%c"), n, string, WD_MESSAGE_SEPARATOR);		wi_release(string);	}

wi_string_t * wi_file_read_to_end_of_file(wi_file_t *file) {	wi_string_t		*string;	char			buffer[WI_FILE_BUFFER_SIZE];	wi_integer_t	bytes;		string = wi_string_init(wi_string_alloc());		while((bytes = wi_file_read_buffer(file, buffer, sizeof(buffer))))		wi_string_append_bytes(string, buffer, bytes);		return wi_autorelease(string);}

void wd_version_init(void) {	wd_version_string			= wi_string_init_with_format(wi_string_alloc(), WI_STR("%s (%u)"), WD_VERSION, WI_REVISION);	wd_protocol_version_string	= wi_string_init_with_cstring(wi_string_alloc(), WD_PROTOCOL_VERSION);#ifdef HAVE_CORESERVICES_CORESERVICES_H	wd_server_version_string	= wi_string_init_with_format(wi_string_alloc(), WI_STR("Wired/%@ (%@; %@; %@) (%s; CoreFoundation %.1f)"),		wd_version_string,		wi_process_os_name(wi_process()),		wi_process_os_release(wi_process()),		wi_process_os_arch(wi_process()),		SSLeay_version(SSLEAY_VERSION),		kCFCoreFoundationVersionNumber);#else	wd_server_version_string	= wi_string_init_with_format(wi_string_alloc(), WI_STR("Wired/%@ (%@; %@; %@) (%s)"),		wd_version_string,		wi_process_os_name(wi_process()),		wi_process_os_release(wi_process()),		wi_process_os_arch(wi_process()),		SSLeay_version(SSLEAY_VERSION));#endif}

void wi_terminal_printf(wi_terminal_t *terminal, wi_string_t *fmt, ...) {	wi_string_t		*string;	va_list			ap;		va_start(ap, fmt);	string = wi_string_init_with_format_and_arguments(wi_string_alloc(), fmt, ap);	va_end(ap);		_wi_terminal_puts(terminal, string);		wi_release(string);}

void wr_printf_block(wi_string_t *fmt, ...) {	wi_string_t		*string;	va_list			ap;	va_start(ap, fmt);	string = wi_string_init_with_format_and_arguments(wi_string_alloc(), fmt, ap);	va_end(ap);	wr_wprintf_block(wr_current_window, WI_STR("%@"), string);		wi_release(string);}

void wr_wprintf(wr_window_t *window, wi_string_t *fmt, ...) {	wi_string_t		*string;	va_list			ap;	va_start(ap, fmt);	string = wi_string_init_with_format_and_arguments(wi_string_alloc(), fmt, ap);	va_end(ap);	wr_wprint(window, string);		wi_release(string);}

void wi_error_set_regex_error(regex_t *regex, int code) {	wi_error_t		*error;	char			string[256];	error = _wi_error_get_error();	error->domain = WI_ERROR_DOMAIN_REGEX;	error->code = code;		regerror(code, regex, string, sizeof(string));	wi_release(error->string);	error->string = wi_string_init_with_cstring(wi_string_alloc(), string);}

static void wi_assert_default_handler(const char *file, unsigned int line, wi_string_t *fmt, ...) {	wi_string_t		*string;	va_list			ap;		va_start(ap, fmt);	string = wi_string_init_with_format_and_arguments(wi_string_alloc(), fmt, ap);	va_end(ap);		wi_log_warn(WI_STR("Assertion failed at %s:%u: %@"), file, line, string);		wi_release(string);		wi_crash();}

wi_array_t * wi_array_init_with_argv(wi_array_t *array, int argc, const char **argv) {	wi_string_t		*string;	int				i;		array = wi_array_init_with_capacity(array, argc);		for(i = 0; i < argc; i++) {		string = wi_string_init_with_cstring(wi_string_alloc(), argv[i]);		wi_array_add_data(array, string);		wi_release(string);	}		return array;}

void wi_error_set_libxml2_error(void) {	wi_error_t		*error;	xmlErrorPtr		xml_error;	xml_error = xmlGetLastError();	error = _wi_get_error();	error->domain = WI_ERROR_DOMAIN_REGEX;	error->code = xml_error->code;		wi_release(error->string);	error->string = wi_string_init_with_cstring(wi_string_alloc(), xml_error->message);	wi_string_delete_surrounding_whitespace(error->string);}

int32_t wi_socket_sendto(wi_socket_t *socket, wi_socket_context_t *context, wi_string_t *fmt, ...) {	wi_string_t		*string;	int				bytes;	va_list			ap;	va_start(ap, fmt);	string = wi_string_init_with_format_and_arguments(wi_string_alloc(), fmt, ap);	va_end(ap);	bytes = wi_socket_sendto_buffer(socket, context, wi_string_cstring(string), wi_string_length(string));		wi_release(string);	return bytes;}

static wi_string_t * _wi_uuid_string(wi_uuid_t *uuid) {	if(!uuid->string) {		uuid->string = wi_string_init_with_format(wi_string_alloc(), WI_STR("%08X-%04X-%04X-%02X%02X-%02X%02X%02X%02X%02X%02X"),			uuid->time_low,			uuid->time_mid,			uuid->time_hi_and_version,			uuid->clock_seq >> 8,			uuid->clock_seq & 0xFF,			uuid->node[0],			uuid->node[1],			uuid->node[2],			uuid->node[3],			uuid->node[4],			uuid->node[5]);	}

void wd_reply(uint32_t n, wi_string_t *fmt, ...) {	wd_user_t		*user = wd_users_user_for_thread();	wi_string_t		*string;	va_list			ap;		va_start(ap, fmt);	string = wi_string_init_with_format_and_arguments(wi_string_alloc(), fmt, ap);	va_end(ap);		wd_user_lock_socket(user);	wi_socket_write_format(wd_user_socket(user), 0.0, WI_STR("%u %@%c"), n, string, WD_MESSAGE_SEPARATOR);	wd_user_unlock_socket(user);		wi_release(string);}

wi_terminal_t * wi_terminal_init(wi_terminal_t *terminal) {	wi_string_t		*type;	const char		*term;		term = getenv("TERM");			if(!term)		term = "vt100";		type = wi_string_init_with_cstring(wi_string_alloc(), term);	terminal = wi_terminal_init_with_type(terminal, type);	wi_release(type);		return terminal;}

wi_integer_t wi_socket_write_format(wi_socket_t *socket, wi_time_interval_t timeout, wi_string_t *fmt, ...) {	wi_string_t		*string;	wi_integer_t	bytes;	va_list			ap;	va_start(ap, fmt);	string = wi_string_init_with_format_and_arguments(wi_string_alloc(), fmt, ap);	va_end(ap);		bytes = wi_socket_write_buffer(socket, timeout, wi_string_cstring(string), wi_string_length(string));		wi_release(string);	return bytes;}

void wr_wprintf_block(wr_window_t *window, wi_string_t *fmt, ...) {	wi_enumerator_t	*enumerator;	wi_string_t		*string, *line;	va_list			ap;	va_start(ap, fmt);	string = wi_string_init_with_format_and_arguments(wi_string_alloc(), fmt, ap);	va_end(ap);	enumerator = wi_array_data_enumerator(wi_string_components_separated_by_string(string, WI_STR("/n")));		while((line = wi_enumerator_next_data(enumerator)))		wr_wprintf(window, WI_STR("   %@"), line);	wi_release(string);}