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

void wr_draw_transfers(wi_boolean_t force) {	static wi_time_interval_t	update;	wi_enumerator_t				*enumerator;	wi_mutable_string_t			*string;    wi_string_t					*status;	wr_transfer_t				*transfer;	wi_time_interval_t			interval;	wi_uinteger_t				i = 0;		interval = wi_time_interval();		if(!force && interval - update < 1.0)		return;		update = interval;		wi_terminal_set_scroll(wr_terminal, wi_make_range(1 + wi_array_count(wr_transfers),													  wi_terminal_size(wr_terminal).height - 4));		enumerator = wi_array_data_enumerator(wr_transfers);		while((transfer = wi_enumerator_next_data(enumerator))) {		wi_terminal_move(wr_terminal, wi_make_point(0, i + 1));		wi_terminal_clear_line(wr_terminal);				if(transfer->state == WR_TRANSFER_RUNNING && interval - transfer->start_time > 0.0) {			transfer->speed = ((double) transfer->total_transferred - transfer->total_offset) / (interval - transfer->start_time);						status = wi_string_with_format(WI_STR("%@/%@, %@/s"),                                           wr_files_string_for_size(transfer->total_transferred),                                           wr_files_string_for_size(transfer->total_size),                                           wr_files_string_for_size(transfer->speed));		}		else if(transfer->state == WR_TRANSFER_QUEUED) {			status = wi_string_with_format(WI_STR("queued at %u"),                                           transfer->queue);		}		else {			status = wi_string_with_cstring("waiting");		}				string = wi_mutable_string_with_format(WI_STR("%u %3.0f%%  %@"),                                               transfer->tid,                                               transfer->total_size > 0                                               ? 100 * ((double) transfer->total_transferred / (double) transfer->total_size)                                               : 0,                                               transfer->name);				wi_terminal_adjust_string_to_fit_width(wr_terminal, string);		wi_mutable_string_delete_characters_from_index(string, wi_string_length(string) - wi_string_length(status));		wi_mutable_string_append_string(string, status);				wi_terminal_printf(wr_terminal, WI_STR("%@"), string);				i++;	}		wr_terminal_reset_location();}

wi_url_t * wi_url_init_with_string(wi_url_t *url, wi_string_t *string) {	wi_string_t		*userpassword;	wi_range_t		range;		range = wi_string_range_of_string(string, WI_STR("://"), 0);		if(range.location != WI_NOT_FOUND) {		url->scheme = wi_retain(wi_string_substring_to_index(string, range.location));				if(range.location + range.length >= wi_string_length(string))			goto end;		else			string = wi_string_substring_from_index(string, range.location + 3);	}		range = wi_string_range_of_string(string, WI_STR("/"), 0);		if(range.location != WI_NOT_FOUND) {		url->path	= wi_retain(wi_string_substring_from_index(string, range.location));		string		= wi_string_substring_to_index(string, range.location);	}		range = wi_string_range_of_string(string, WI_STR("@"), 0);		if(range.location != WI_NOT_FOUND) {		userpassword = wi_string_substring_to_index(string, range.location);		string = wi_string_substring_from_index(string, range.location + 1);		range = wi_string_range_of_string(userpassword, WI_STR(":"), 0);				if(range.location != WI_NOT_FOUND && range.location != wi_string_length(userpassword) - 1) {			url->user = wi_retain(wi_string_substring_to_index(userpassword, range.location));			url->password = wi_retain(wi_string_substring_from_index(userpassword, range.location + 1));		} else {			url->user = wi_retain(userpassword);		}	}		range = wi_string_range_of_string(string, WI_STR(":"), 0);		if(range.location == WI_NOT_FOUND ||	   range.location + range.length >= wi_string_length(string) ||	   wi_string_contains_string(wi_string_substring_from_index(string, range.location + 1), WI_STR(":"), 0)) {		url->host = wi_copy(string);	} else {		url->host = wi_retain(wi_string_substring_to_index(string, range.location));		url->port = wi_string_uint32(wi_string_substring_from_index(string, range.location + 1));	}	end:	_wi_url_regenerate_string(url);		return url;}

void wr_draw_transfers(wi_boolean_t force) {	static wi_time_interval_t	update;	wi_list_node_t				*node;	wi_string_t					*string, *status;	wr_transfer_t				*transfer;	wi_time_interval_t			interval;	unsigned int				i = 0;		interval = wi_time_interval();		if(!force && interval - update < 1.0)		return;		update = interval;		wi_terminal_set_scroll(wr_terminal, wi_make_range(1 + wi_list_count(wr_transfers),													  wi_terminal_size(wr_terminal).height - 3));		WI_LIST_FOREACH(wr_transfers, node, transfer) {		wi_terminal_move(wr_terminal, wi_make_point(0, i + 1));		wi_terminal_clear_line(wr_terminal);				if(transfer->state == WR_TRANSFER_RUNNING && interval - transfer->start_time > 0.0) {			transfer->speed = ((double) transfer->transferred - transfer->offset) / (interval - transfer->start_time);						status = wi_string_with_format(WI_STR("%@/%@, %@/s"),				wr_files_string_for_size(transfer->transferred),				wr_files_string_for_size(transfer->size),				wr_files_string_for_size(transfer->speed));		}		else if(transfer->state == WR_TRANSFER_QUEUED) {			status = wi_string_with_format(WI_STR("queued at %u"),				transfer->queue);		}		else {			status = wi_string_with_cstring("waiting");		}				string = wi_string_with_format(WI_STR("%u %3.0f%%  %@"),			transfer->tid,			transfer->size > 0				? 100 * ((double) transfer->transferred / (double) transfer->size)				: 0,			transfer->name);				wi_terminal_adjust_string_to_fit_width(wr_terminal, string);		wi_string_delete_characters_from_index(string, wi_string_length(string) - wi_string_length(status));		wi_string_append_string(string, status);				wi_terminal_printf(wr_terminal, WI_STR("%@"), string);				i++;	}

static void wr_command_save(wi_array_t *arguments) {	wi_file_t		*file;	wi_string_t		*path, *login, *password, *port;		path = wi_user_home();	path = wi_string_by_appending_path_component(path, WI_STR(WB_WIREBOT_USER_PATH));	path = wi_string_by_appending_path_component(path, WI_ARRAY(arguments, 0));		file = wi_file_for_writing(path);		if(!file) {		wr_printf_prefix(WI_STR("save: %@: %m"), path);				return;	}		wi_file_write_format(file, WI_STR("charset %@/n"), wi_string_encoding_charset(wr_client_string_encoding));	wi_file_write_format(file, WI_STR("timestamp %@/n"), wr_timestamp_format);	wi_file_write_format(file, WI_STR("nick %@/n"), wr_nick);		if(wi_string_length(wr_status) > 0)		wi_file_write_format(file, WI_STR("status %@/n"), wr_status);		if(wr_icon_path)		wi_file_write_format(file, WI_STR("icon %@/n"), wr_icon_path);		if(wr_connected) {		if(wi_string_length(wi_p7_socket_user_name(wr_p7_socket)) > 0)			login = wi_string_with_format(WI_STR("-l %@"), wi_p7_socket_user_name(wr_p7_socket));		else			login = NULL;				if(wi_string_length(wr_password) > 0)			password = wi_string_with_format(WI_STR("-p %@"), wr_password);		else			password = NULL;				if(wi_address_port(wi_socket_address(wr_socket)) != WR_PORT)			port = wi_string_with_format(WI_STR("-P %u"), wi_address_port(wi_socket_address(wr_socket)));		else			port = NULL;				wi_file_write_format(file, WI_STR("open %#@ %#@ %#@ %@/n"),			login, password, port, wi_address_string(wi_socket_address(wr_socket)));	}		wr_printf_prefix(WI_STR("save: /"%@/" saved"), path);}

void wr_wprint_me(wr_window_t *window, wi_string_t *nick, wi_string_t *chat) {	wi_string_t		*prefix;	const char		*color;	wi_uinteger_t	length;	length = wi_string_length(wr_nick);	if(length > 4)		length = 4;	prefix = wi_string_substring_to_index(wr_nick, length);		if(wi_string_has_prefix(chat, prefix)) {		color = WR_HIGHLIGHT_COLOR;				if(window->status < WR_WINDOW_STATUS_HIGHLIGHT)			window->status = WR_WINDOW_STATUS_HIGHLIGHT; 	} else {		color = NULL;				if(window->status < WR_WINDOW_STATUS_CHAT)			window->status = WR_WINDOW_STATUS_CHAT;	}	wr_wprintf(window, WI_STR("%s*%s %s%@%s %@"),		WR_ME_COLOR,		WR_TERMINATE_COLOR,		color ? color : "",		nick,		color ? WR_TERMINATE_COLOR : "",		chat);}

static void wr_msg_307(wi_array_t *arguments) {	wi_string_t		*message;	wr_user_t		*killer, *victim;	wr_uid_t		killer_uid, victim_uid;	victim_uid = wi_string_uint32(WI_ARRAY(arguments, 0));	killer_uid = wi_string_uint32(WI_ARRAY(arguments, 1));	message = WI_ARRAY(arguments, 2);	victim = wr_chat_user_with_uid(wr_public_chat, victim_uid);	killer = wr_chat_user_with_uid(wr_public_chat, killer_uid);	if(killer && victim) {		if(wi_string_length(message) > 0) {			wr_wprintf_prefix(wr_console_window, WI_STR("%@ was banned by %@: %@"),				wr_user_nick(victim), wr_user_nick(killer), message);		} else {			wr_wprintf_prefix(wr_console_window, WI_STR("%@ was banned by %@"),				wr_user_nick(victim), wr_user_nick(killer));		}	}	if(victim) {		wr_chat_remove_user(wr_public_chat, victim);		wr_draw_divider();	}}

void wr_print_user(wr_user_t *user, wi_uinteger_t max_length) {	const char		*color;	switch(wr_user_color(user)) {		case WR_USER_COLOR_BLACK:		default:			color = wr_user_is_idle(user) ? WR_WHITE_COLOR : WR_BRIGHT_WHITE_COLOR;			break;					case WR_USER_COLOR_RED:		case WR_USER_COLOR_ORANGE:			color = wr_user_is_idle(user) ? WR_RED_COLOR : WR_BRIGHT_RED_COLOR;			break;					case WR_USER_COLOR_GREEN:			color = wr_user_is_idle(user) ? WR_GREEN_COLOR : WR_BRIGHT_GREEN_COLOR;			break;					case WR_USER_COLOR_BLUE:			color = wr_user_is_idle(user) ? WR_BLUE_COLOR : WR_BRIGHT_BLUE_COLOR;			break;					case WR_USER_COLOR_PURPLE:			color = wr_user_is_idle(user) ? WR_MAGENTA_COLOR : WR_BRIGHT_MAGENTA_COLOR;			break;	}		wr_printf_block(WI_STR("%s%@%s%*s%@"),		color,		wr_user_nick(user),		WR_TERMINATE_COLOR,		max_length - wi_string_length(wr_user_nick(user)) + 4,		" ",		wr_user_status(user));}

static wi_p7_message_t * _wi_p7_socket_read_xml_message(wi_p7_socket_t *p7_socket, wi_time_interval_t timeout, wi_string_t *prefix) {	wi_string_t			*string;	wi_p7_message_t		*p7_message;		p7_message = wi_autorelease(wi_p7_message_init(wi_p7_message_alloc(), p7_socket));		while(true) {		string = wi_socket_read_to_string(p7_socket->socket, timeout, WI_STR(">"));				if(!string || wi_string_length(string) == 0)			return NULL;				wi_string_delete_surrounding_whitespace(string);				if(!p7_message->xml_string)			p7_message->xml_string = wi_copy(string);		else			wi_string_append_string(p7_message->xml_string, string);				if(wi_string_has_suffix(string, WI_STR("</p7:message>")) ||		   (wi_string_has_suffix(string, WI_STR("/>")) &&			wi_string_has_prefix(string, WI_STR("<p7:message")))) {			break;		}	}		wi_retain(p7_message->xml_string);		if(prefix)		wi_string_insert_string_at_index(p7_message->xml_string, prefix, 0);	wi_string_delete_surrounding_whitespace(p7_message->xml_string);		return p7_message;}

wi_boolean_t wi_settings_read_file(wi_settings_t *settings, wi_boolean_t chroot) {	wi_file_t		*file;	wi_string_t		*path, *string;	wi_boolean_t	result = true;		path = wi_full_path(wi_settings_config_path);	file = wi_file_for_reading(path);		if(!file) {		wi_log_err(WI_STR("Could not open %@: %s"),			path, strerror(errno));				return false;	}		wi_log_info(WI_STR("Reading %@"), path);	_wi_settings_clear(settings);		settings->file		= path;	settings->line		= 0;	settings->chroot	= chroot;		while((string = wi_file_read_line(file))) {		settings->line++;		if(wi_string_length(string) > 0 && !wi_string_has_prefix(string, WI_STR("#"))) {			if(!_wi_settings_parse_setting(settings, string))				result = false;		}	}	settings->file = NULL;	return result;}

void wr_wprint_say(wr_window_t *window, wi_string_t *nick, wi_string_t *chat) {	wi_string_t		*prefix;	const char		*color;	unsigned int	length;	length = wi_string_length(wr_nick);	if(length > 4)		length = 4;	prefix = wi_string_substring_to_index(wr_nick, length);		if(wi_string_has_prefix(chat, prefix)) {		color = WR_HIGHLIGHT_COLOR;				if(window->status < WR_WINDOW_STATUS_HIGHLIGHT)			window->status = WR_WINDOW_STATUS_HIGHLIGHT;	} else {		color = WR_NICK_COLOR;				if(window->status < WR_WINDOW_STATUS_CHAT)			window->status = WR_WINDOW_STATUS_CHAT;	}			wr_wprintf(window, WI_STR("%s<%s%s%@%s%s>%s %@"),		WR_SAY_COLOR,		WR_END_COLOR,		color,		nick,		WR_END_COLOR,		WR_SAY_COLOR,		WR_END_COLOR,		chat);}

void wi_error_set_libwired_error_with_string(int code, wi_string_t *string) {	wi_string_t		*errorstring;		errorstring = wi_string_init_with_cstring(wi_mutable_string_alloc(), _wi_error_strings[code]);	if(wi_string_length(string) > 0) {		if(wi_string_length(errorstring) > 0)			wi_mutable_string_append_string(errorstring, WI_STR(": "));				wi_mutable_string_append_string(errorstring, string);	}		wi_error_set_error_with_string(WI_ERROR_DOMAIN_LIBWIRED, code, errorstring);		wi_release(errorstring);}

wi_sqlite3_statement_t * wi_sqlite3_prepare_statement(wi_sqlite3_database_t *database, wi_string_t *query, ...) {	wi_sqlite3_statement_t		*statement;	va_list						ap;		statement				= wi_autorelease(wi_runtime_create_instance(_wi_sqlite3_statement_runtime_id, sizeof(wi_sqlite3_statement_t)));	statement->query		= wi_retain(query);		wi_recursive_lock_lock(database->lock);		if(#ifdef HAVE_SQLITE3_PREPARE_V2	   sqlite3_prepare_v2#else	   sqlite3_prepare#endif	   (database->database, wi_string_cstring(query), wi_string_length(query), &statement->statement, NULL) == SQLITE_OK) {		va_start(ap, query);		_wi_sqlite3_bind_statement(statement, ap);		va_end(ap);	} else {		wi_error_set_sqlite3_error_with_description(database->database, wi_description(statement));				statement = NULL;	}		wi_recursive_lock_unlock(database->lock);		return statement;}

wi_boolean_t wt_category_is_valid(wi_string_t *category) {	wi_file_t		*file;	wi_string_t		*string;	wi_boolean_t	result = false;	if(wi_string_length(category) == 0)		return true;	file = wi_file_for_reading(wt_settings.categories);		if(!file) {		wi_log_err(WI_STR("Could not open %@: %m"), wt_settings.categories);				return true;	}		while((string = wi_file_read_config_line(file))) {		if(wi_is_equal(category, string)) {			result = true;						break;		}	}	return result;}

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

static wi_mutable_array_t * _wi_terminal_buffer_lines_for_string(wi_terminal_buffer_t *buffer, wi_string_t *string) {	wi_enumerator_t			*enumerator;	wi_mutable_array_t		*array;	wi_mutable_string_t		*newstring; 	wi_string_t				*line, *subline;	wi_size_t				size;	wi_uinteger_t			index;		array		= wi_array_init(wi_mutable_array_alloc());	size		= wi_terminal_size(buffer->terminal);	enumerator	= wi_array_data_enumerator(wi_string_components_separated_by_string(string, WI_STR("/n")));		while((line = wi_enumerator_next_data(enumerator))) {		if(wi_terminal_width_of_string(buffer->terminal, line) < size.width) {			wi_mutable_array_add_data(array, line);		} else {			newstring = wi_mutable_copy(line);						do {				index		= wi_terminal_index_of_string_for_width(buffer->terminal, newstring, size.width);				subline		= wi_string_substring_to_index(newstring, index);				wi_mutable_array_add_data(array, subline);				wi_mutable_string_delete_characters_to_index(newstring, wi_string_length(subline));			} while(wi_terminal_width_of_string(buffer->terminal, newstring) >= size.width);						wi_mutable_array_add_data(array, newstring);			wi_release(newstring);		}	}		return wi_autorelease(array);}

static wi_array_t * _wi_terminal_buffer_lines_for_string(wi_terminal_buffer_t *buffer, wi_string_t *string) {	wi_array_t		*array, *linearray; 	wi_string_t		*string_copy, *line, *subline;	wi_size_t		size;	uint32_t		i, count, index;		array		= wi_array_init(wi_array_alloc());	size		= wi_terminal_size(buffer->terminal);	linearray	= wi_string_components_separated_by_string(string, WI_STR("/n"));	count		= wi_array_count(linearray);		for(i = 0; i < count; i++) {		line = WI_ARRAY(linearray, i);				if(wi_terminal_width_of_string(buffer->terminal, line) < size.width) {			wi_array_add_data(array, line);		} else {			string_copy = wi_copy(line);						do {				index	= wi_terminal_index_of_string_for_width(buffer->terminal, string_copy, size.width);				subline	= wi_string_substring_to_index(string_copy, index);				wi_array_add_data(array, subline);				wi_string_delete_characters_to_index(string_copy, wi_string_length(subline));			} while(wi_terminal_width_of_string(buffer->terminal, string_copy) >= size.width);						wi_array_add_data(array, string_copy);			wi_release(string_copy);		}	}		return array;}

wi_boolean_t wi_settings_read_file(wi_settings_t *settings) {	wi_file_t		*file;	wi_string_t		*string;		file = wi_file_for_reading(wi_settings_config_path);		if(!file) {		wi_log_err(WI_STR("Could not open %@: %s"),			wi_settings_config_path, strerror(errno));				return false;	}		wi_log_info(WI_STR("Reading %@"), wi_settings_config_path);	_wi_settings_clear(settings);		settings->file		= wi_settings_config_path;	settings->line		= 0;		while((string = wi_file_read_line(file))) {		settings->line++;		if(wi_string_length(string) > 0 && !wi_string_has_prefix(string, WI_STR("#")))			_wi_settings_parse_setting(settings, string);	}	settings->file = NULL;	return true;}

static void wd_cmd_say(wi_array_t *arguments) {	wd_client_t		*client = wd_client();	wi_array_t		*array;	wi_string_t		*string;	wd_chat_t		*chat;	wd_cid_t		cid;	unsigned int	i, count;	cid = wi_string_uint32(WI_ARRAY(arguments, 0));	chat = wd_chat_with_cid(cid);		if(!chat)		return;	if(!wd_chat_contains_client(chat, client))		return;	array = wi_string_components_separated_by_string(WI_ARRAY(arguments, 1), WI_STR("/n/r"));	count = wi_array_count(array);		wd_broadcast_lock();	for(i = 0; i < count; i++) {		string = WI_ARRAY(array, i);				if(wi_string_length(string) > 0) {			wd_broadcast(cid, 300, WI_STR("%u%c%u%c%#@"),						 cid,			WD_FIELD_SEPARATOR,						 client->uid,	WD_FIELD_SEPARATOR,						 string);		}	}	wd_broadcast_unlock();}

wi_boolean_t wi_p7_message_set_date_for_name(wi_p7_message_t *p7_message, wi_date_t *date, wi_string_t *field_name) {	wi_string_t		*string;	unsigned char	*binary;	uint32_t		field_id, field_size;		if(!date)		date = wi_date();		string = wi_date_iso8601_string(date);		if(p7_message->serialization == WI_P7_BINARY) {		field_size = wi_string_length(string) + 1;				if(!_wi_p7_message_get_binary_buffer_for_writing_for_name(p7_message, field_name, 0, &binary, &field_id))			return false;				wi_write_swap_host_to_big_int32(binary, 0, field_id);				memcpy(binary + 4, wi_string_cstring(string), field_size);	} else {		_wi_p7_message_set_xml_field(p7_message, WI_P7_DATE, field_name, string);	}		return true;}

wi_socket_state_t wi_socket_wait(wi_socket_t *socket, wi_time_interval_t timeout) {	if(wi_string_length(socket->buffer) > 0)		return WI_SOCKET_READY;	return wi_socket_wait_descriptor(socket->sd,									 timeout,									 (socket->direction & WI_SOCKET_READ),									 (socket->direction & WI_SOCKET_WRITE));}

wi_boolean_t wi_process_set_hostname(wi_process_t *process, wi_string_t *hostname) {	if(sethostname((char *) wi_string_cstring(hostname), (int)wi_string_length(hostname))) {		wi_error_set_errno(errno);				return false;	}		return true;}

static void wd_transfer_accept_thread(wi_runtime_instance_t *argument) {	wi_pool_t			*pool;	wi_socket_t			*socket = argument;	wi_array_t			*arguments;	wi_string_t			*ip, *string, *command;	wd_transfer_t		*transfer;		pool = wi_pool_init(wi_pool_alloc());		ip = wi_address_string(wi_socket_address(socket));		if(!wi_socket_accept_tls(socket, wd_transfer_socket_tls, 30.0)) {		wi_log_err(WI_STR("Could not accept a connection for %@: %m"), ip);				goto end;	}		if(!wi_socket_set_timeout(socket, 30.0))		wi_log_warn(WI_STR("Could not set timeout for %@: %m"), ip);		string = wi_socket_read_to_string(socket, 5.0, WI_STR(WD_MESSAGE_SEPARATOR_STR));		if(!string || wi_string_length(string) == 0) {		if(!string)			wi_log_warn(WI_STR("Could not read from %@: %m"), ip);				goto end;	}		wi_parse_wired_command(string, &command, &arguments);		if(wi_is_equal(command, WI_STR("TRANSFER")) && wi_array_count(arguments) >= 1) {		transfer = wd_transfers_transfer_with_hash(WI_ARRAY(arguments, 0));				if(!transfer)			goto end;				if(!wi_is_equal(ip, wd_user_ip(transfer->user)))			goto end;				wi_lock_lock(transfer->socket_lock);				if(!transfer->socket) {			transfer->socket = wi_retain(socket);			wi_lock_unlock(transfer->socket_lock);					wd_transfer_loop(transfer);		} else {			wi_lock_unlock(transfer->socket_lock);		}	}end:	wi_socket_close(socket);	wi_release(pool);}

void wi_error_set_libwired_error_with_string(int code, wi_string_t *string) {	wi_error_t		*error;	error = _wi_get_error();	error->domain = WI_ERROR_DOMAIN_LIBWIRED;	error->code = code;		wi_release(error->string);		error->string = wi_string_init_with_cstring(wi_string_alloc(), _wi_error_strings[error->code]);	if(wi_string_length(string) > 0) {		if(wi_string_length(error->string) > 0)			wi_string_append_string(error->string, WI_STR(": "));				wi_string_append_string(error->string, string);	}}

static wi_boolean_t wd_users_get_human_readable_version(wi_string_t *version, wi_string_t **application_name, wi_string_t **application_version, wi_string_t **os_name, wi_string_t **os_version, wi_string_t **arch) {	wi_range_t		range;	wi_uinteger_t	index;		range = wi_make_range(0, wi_string_length(version));	index = wi_string_index_of_string_in_range(version, WI_STR("/"), 0, range);		if(index == WI_NOT_FOUND || index == range.length - 1)		return false;		*application_name = wi_string_substring_with_range(version, wi_make_range(range.location, index - range.location));		range.location = index + 1;	range.length -= index + 1;		index = wi_string_index_of_string_in_range(version, WI_STR(" ("), 0, range);		if(index == WI_NOT_FOUND || index == range.length - 2)		return false;		*application_version = wi_string_substring_with_range(version, wi_make_range(range.location, index - range.location));		range.location = index + 2;	range.length -= index + 2;		index = wi_string_index_of_string_in_range(version, WI_STR("; "), 0, range);		if(index == WI_NOT_FOUND || index == range.length - 2)		return false;		*os_name = wi_string_substring_with_range(version, wi_make_range(range.location, index - range.location));		range.location = index + 2;	range.length -= index + 2;		index = wi_string_index_of_string_in_range(version, WI_STR("; "), 0, range);		if(index == WI_NOT_FOUND || index == range.length - 2)		return false;		*os_version = wi_string_substring_with_range(version, wi_make_range(range.location, index - range.location));		range.location = index + 2;	range.length -= index + 2;		index = wi_string_index_of_string_in_range(version, WI_STR(")"), 0, range);		if(index == WI_NOT_FOUND || index == range.length - 1)		return false;		*arch = wi_string_substring_with_range(version, wi_make_range(range.location, index - range.location));	return true;}

wi_array_t * wi_array_init_with_string(wi_array_t *array, wi_string_t *string, wi_string_t *separator) {	if(wi_string_length(string) == 0) {		array = wi_array_init_with_data(array, WI_STR(""), (void *) NULL);	} else {		wi_release(array);				array = wi_retain(wi_string_components_separated_by_string(string, separator));	}		return array;}

void wt_control_thread(wi_runtime_instance_t *argument) {	wi_pool_t			*pool;	wt_client_t			*client = argument;	wi_string_t			*string;	wi_socket_state_t	state;	wi_uinteger_t		i = 0;		pool = wi_pool_init(wi_pool_alloc());	wt_client_set(client);	while(client->state <= WT_CLIENT_STATE_SAID_HELLO) {		do {			state = wi_socket_wait(client->socket, 0.1);		} while(state == WI_SOCKET_TIMEOUT && client->state <= WT_CLIENT_STATE_SAID_HELLO);		if(client->state > WT_CLIENT_STATE_SAID_HELLO) {			/* invalid state */			break;		}		if(state == WI_SOCKET_ERROR) {			if(wi_error_code() == EINTR) {				/* got a signal */				continue;			} else {				/* error in TCP communication */				wi_log_err(WI_STR("Could not read from %@: %m"), client->ip);				break;			}		}		string = wi_socket_read_to_string(client->socket, 0.0, WI_STR(WT_MESSAGE_SEPARATOR_STR));		if(!string || wi_string_length(string) == 0) {			if(!string)				wi_log_info(WI_STR("Could not read from %@: %m"), client->ip);						break;		}		wt_parse_command(string);				if(++i % 10 == 0)			wi_pool_drain(pool);	}	wi_log_info(WI_STR("Disconnect from %@ after %.2fs"),		client->ip,		wi_time_interval() - client->connect_time);		wi_release(pool);}

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_file_read_config_line(wi_file_t *file) {	wi_string_t		*string;		while((string = wi_file_read_line(file))) {		if(wi_string_length(string) == 0 || wi_string_has_prefix(string, WI_STR("#")))			continue;		return string;	}		return NULL;}

void wr_print_users(void) {	wi_list_node_t  *node;	wr_user_t       *user;	unsigned int    max_length = 0;	WI_LIST_FOREACH(wr_users, node, user)		max_length = WI_MAX(max_length, wi_string_length(user->nick));	wr_printf_prefix(WI_STR("Users currently online:"));	WI_LIST_FOREACH(wr_users, node, user)		wr_print_user(user, max_length);}

void wi_test_system(void) {    wi_array_t  *backtrace;        WI_TEST_ASSERT_TRUE(wi_user_id() >= 0, "");    WI_TEST_ASSERT_TRUE(wi_string_length(wi_user_name()) > 0, "");    WI_TEST_ASSERT_TRUE(wi_string_length(wi_user_home()) > 0, "");    WI_TEST_ASSERT_TRUE(wi_group_id() >= 0, "");    WI_TEST_ASSERT_TRUE(wi_string_length(wi_group_name()) > 0, "");    WI_TEST_ASSERT_TRUE(wi_page_size() > 0, "");        backtrace = wi_backtrace();        if(backtrace) {        WI_TEST_ASSERT_TRUE(wi_array_count(backtrace) > 0, "");        WI_TEST_ASSERT_NOT_EQUALS(wi_string_index_of_string(wi_array_components_joined_by_string(backtrace, WI_STR("/n")),                                                            WI_STR("test"), 0),                                  WI_NOT_FOUND, "");    }        WI_TEST_ASSERT_TRUE(wi_string_length(wi_getenv(WI_STR("HOME"))) > 0, "");}