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

/* * The only current difference is that POSTGRES needs to escape the backquotes * while everything else does not */void catstr(string *str, char *s){	while(*s)	{		if(!(*s)) return;		switch(*s) {		case '/'':			string_cat(str, "''");			break;		/*		case '"':			string_cat(str, "/"/"");			break;		 */		case '//':			if(mode == SHSQL_POSTGRES)				string_cat(str, "////");			else				string_cat_c(str, *s);			break;		default:			string_cat_c(str, *s);			break;		}		s++;	}}

irom static void trigger_type_to_string(io_trigger_t trigger_type, string_t *string){	switch(trigger_type)	{		case(io_trigger_off):		{			string_cat(string, "off");			break;		}		case(io_trigger_on):		{			string_cat(string, "on");			break;		}		case(io_trigger_down):		{			string_cat(string, "down");			break;		}		case(io_trigger_up):		{			string_cat(string, "up");			break;		}		default:		{			string_cat(string, "error");			break;		}	}}

irom io_error_t io_trigger_pin(string_t *error, int io, int pin, io_trigger_t trigger_type){	const io_info_entry_t *info;	io_data_entry_t *data;	io_config_pin_entry_t *pin_config;	io_data_pin_entry_t *pin_data;	if(io >= io_id_size)	{		if(error)			string_cat(error, "io out of range/n");		return(io_error);	}	info = &io_info[io];	data = &io_data[io];	if(pin >= info->pins)	{		if(error)			string_cat(error, "pin out of range/n");		return(io_error);	}	pin_config = &config.io_config[io][pin];	pin_data = &data->pin[pin];	return(io_trigger_pin_x(error, info, pin_data, pin_config, pin, trigger_type));}

irom static void pin_string_from_flags(string_t *flags, const io_config_pin_entry_t *pin_config){	bool none = true;	if(pin_config->flags.autostart)	{		none = false;		string_cat(flags, " autostart");	}	if(pin_config->flags.repeat)	{		none = false;		string_cat(flags, " repeat");	}	if(pin_config->flags.pullup)	{		none = false;		string_cat(flags, " pullup");	}	if(pin_config->flags.reset_on_read)	{		none = false;		string_cat(flags, " reset-on-read");	}	if(none)		string_cat(flags, " <none>");}

irom static app_action_t application_function_i2c_write(const string_t *src, string_t *dst){	i2c_error_t error;	static uint8_t bytes[32];	int current, out;	for(current = 0; current < (int)sizeof(bytes); current++)	{		if(parse_int(current + 1, src, &out, 16) != parse_ok)			break;		bytes[current] = (uint8_t)(out & 0xff);	}	if((error = i2c_send(i2c_address, current, bytes)) != i2c_error_ok)	{		string_cat(dst, "i2c_write");		i2c_error_format_string(dst, error);		string_cat(dst, "/n");		i2c_reset();		return(app_action_error);	}	string_format(dst, "i2c_write: written %d bytes to %02x/n", current, i2c_address);	return(app_action_normal);}

 char* MakeStringName2(const char* aT1, const char* aT2, const char* aT3) {     size_t size = strlen(aT1) + strlen(aT2) + strlen(aT3);     char* str = (char*)BEHAVIAC_MALLOC_WITHTAG(size + 1, "CRTTIBase");     string_cpy(str, aT1);     string_cat(str, aT2);     string_cat(str, aT3);     return str; }

irom static void io_string_from_i2c_type(string_t *name, io_i2c_t type){	switch(type)	{		case(io_i2c_sda): { string_cat(name, "sda"); break; }		case(io_i2c_scl): { string_cat(name, "scl"); break; }		default: { string_cat(name, "error"); break; }	}}

irom void config_dump(string_t *dst, const config_t *cfg){	string_new(static, ntp_server, 32);	string_clear(&ntp_server);	string_ip(&ntp_server, cfg->ntp.server);	string_format(dst, 			"> config magic: %04x/n"			"> config version: %d/n"			"> wlan client ssid: %s/n"			"> wlan client passwd: %s/n"			"> wlan ap ssid: %s/n"			"> wlan ap passwd: %s/n"			"> wlan ap channel: %d/n"			"> wlan mode: %s mode/n"			"> bridge tcp port: %u/n"			"> bridge tcp timeout: %u/n"			"> command tcp port: %u/n"			"> command tcp timeout: %u/n"			"> ntp server: %s/n"			"> ntp time zone: GMT%c%u/n"			"> display flip timeout: %u/n"			"> display default message: %s/n"			"> status trigger gpio (-1 is disabled): %d/%d/n"			"> wlan association trigger gpio (-1 is disabled): %d/%d/n"			"> flags: ", 		cfg->magic,		cfg->version,		cfg->client_wlan.ssid,		cfg->client_wlan.passwd,		cfg->ap_wlan.ssid,		cfg->ap_wlan.passwd,		cfg->ap_wlan.channel,		cfg->wlan_mode == config_wlan_mode_client ? "client" : "ap",		cfg->bridge.port,		cfg->bridge.timeout,		cfg->command.port,		cfg->command.timeout,		string_to_ptr(&ntp_server),		cfg->ntp.timezone >= 0 ? '+' : '-',		cfg->ntp.timezone >= 0 ? cfg->ntp.timezone : 0 - cfg->ntp.timezone,		cfg->display.flip_timeout,		cfg->display.default_msg,		cfg->status_trigger.io,		cfg->status_trigger.pin,		cfg->assoc_trigger.io,		cfg->assoc_trigger.pin);	config_flags_to_string(dst, 0, 0, cfg->flags);	string_cat(dst, "/n> uart: ");	uart_parameters_to_string(dst, &cfg->uart);	string_cat(dst, "/n> gpios:/n");	io_config_dump(dst, cfg, -1, -1, false);}

gstring *authres_spf(gstring * g){uschar * s;if (!spf_result) return g;g = string_append(g, 2, US";/n/tspf=", spf_result);if (spf_result_guessed)  g = string_cat(g, US" (best guess record for domain)");s = expand_string(US"$sender_address_domain");return s && *s  ? string_append(g, 2, US" smtp.mailfrom=", s)  : string_cat(g, US" smtp.mailfrom=<>");}

irom static app_action_t application_function_i2c_read(const string_t *src, string_t *dst){	int size, current;	i2c_error_t error;	uint8_t bytes[32];	uint32_t start, stop, clocks, spent;	if(parse_int(1, src, &size, 0) != parse_ok)	{		string_cat(dst, "i2c-read: missing byte count/n");		return(app_action_error);	}	if(size > (int)sizeof(bytes))	{		string_format(dst, "i2c-read: read max %d bytes/n", sizeof(bytes));		return(app_action_error);	}	start = system_get_time();	if((error = i2c_receive(i2c_address, size, bytes)) != i2c_error_ok)	{		string_cat(dst, "i2c_read");		i2c_error_format_string(dst, error);		string_cat(dst, "/n");		i2c_reset();		return(app_action_error);	}	stop = system_get_time();	string_format(dst, "> i2c_read: read %d bytes from %02x:", size, i2c_address);	for(current = 0; current < size; current++)		string_format(dst, " %02x", bytes[current]);	string_cat(dst, "/n");	clocks = (size + 1) * 20U;	spent = (stop - start) * 1000U;	string_format(dst, "> transferred %u bytes in %u scl clocks/n", size + 1U, clocks);	string_format(dst, "> time spent: %u microseconds, makes %u kHz i2c bus/n",			spent / 1000U, 1000000U / (spent / clocks));	return(app_action_normal);}

irom static io_error_t io_write_pin_x(string_t *errormsg, const io_info_entry_t *info, io_data_pin_entry_t *pin_data, io_config_pin_entry_t *pin_config, int pin, int value){	io_error_t error;	switch(pin_config->mode)	{		case(io_pin_disabled):		case(io_pin_input_digital):		case(io_pin_input_analog):		case(io_pin_i2c):		case(io_pin_uart):		case(io_pin_error):		case(io_pin_trigger):		{			if(errormsg)				string_cat(errormsg, "cannot write to this pin");			return(io_error);		}		case(io_pin_counter):		case(io_pin_output_digital):		case(io_pin_lcd):		case(io_pin_timer):		case(io_pin_output_analog):		{			if((error = info->write_pin_fn(errormsg, info, pin_data, pin_config, pin, value)) != io_ok)				return(error);			break;		}	}	return(io_ok);}

char *uri2filename(UriUriA *uri){	char *furi_str = uri2string(uri);	char *newfilename = NULL;	if (!furi_str)		return NULL;	string_replace_with_char(furi_str, "//", *DIR_SEPAR_STR);	string_replace_with_char(furi_str, "/", *DIR_SEPAR_STR);#ifdef _WIN32	string_replace_with_char(furi_str, ":", '_');#endif	if (furi_str) {		string_printf(&newfilename, "%s%s", option_values.file_output_directory, furi_str);		if (newfilename[strlen(newfilename)-1] == *DIR_SEPAR_STR)			string_cat(&newfilename, "index.html");	}	string_free(furi_str);	return newfilename;}

irom app_action_t application_function_ota_finish(const string_t *src, string_t *dst){	static uint8_t md5_result[16];	string_new(static, local_md5_string, 34);	string_new(static, remote_md5_string, 34);	app_action_t action;	if((ota_state != state_write) && (ota_state != state_verify))	{		string_cat(dst, "OTA: not active/n");		ota_state = state_inactive;		return(app_action_error);	}	string_clear(&remote_md5_string);	if((parse_string(1, src, &remote_md5_string)) != parse_ok)	{		string_copy(dst, "OTA: missing md5sum string/n");		ota_state = state_inactive;		return(app_action_error);	}	if((string_length(&buffer_4k) > 0) &&			((action = flash_write_verify(src, dst)) != app_action_normal))	{		ota_state = state_inactive;		return(action);	}	if(remote_file_length != received)	{		string_format(dst, "OTA: file size differs: %u != %u/n", remote_file_length, received);		ota_state = state_inactive;		return(app_action_error);	}	string_clear(&local_md5_string);	MD5Final(md5_result, &md5);	string_bin_to_hex(&local_md5_string, md5_result, 16);	string_clear(dst);	if(!string_match_string(&local_md5_string, &remote_md5_string))	{		string_format(dst, "OTA: invalid md5sum: /"%s/" != /"%s/"/n",				string_to_const_ptr(&local_md5_string), string_to_ptr(&remote_md5_string));		ota_state = state_inactive;		return(app_action_error);	}	string_format(dst, "%s %s %s %d %d/n", ota_state == state_verify ? "VERIFY_OK" : "WRITE_OK",			string_to_const_ptr(&local_md5_string),			string_to_const_ptr(&remote_md5_string),			written, skipped);	ota_state = state_successful;	return(app_action_normal);}

int main(){	char *dest = "helo ";	char *tnt = "monk";	string_cat(dest, tnt);	printf("%s/n", dest);}

//Generate a verification key using two null-terminated strings//Concatenates the strings together then hashes them with sha_hashunsigned char *create_v_key(char* data1, char *data2){	char *tmp = string_cat(2,data1,data2); //TODO XOR these instead?	unsigned char* key = sha_hash((unsigned char *)tmp, (long)strlen(tmp));	free(tmp);	return key;}

voidop_add(void){    Var		right, left, ret;    right = pop(); left = pop();    if (left.type != right.type && left.type != LIST) {	var_free(left);  var_free(right);	raise(E_TYPE);    } else if (left.type == NUM) {	left.v.num = left.v.num + right.v.num;	push(left);    } else if (left.type == STR) {	ret.type = STR;	if (left.v.str->ref == 1) {	    ret.v.str = string_cat(left.v.str, right.v.str->str);	} else {	    ret.v.str = string_new(left.v.str->len + right.v.str->len + 1);	    strcpy(ret.v.str->str, left.v.str->str);	    strcpy(ret.v.str->str + left.v.str->len, right.v.str->str);	    ret.v.str->len = left.v.str->len + right.v.str->len;	    var_free(left);	}	var_free(right);	push(ret);    } else if (left.type == LIST) {	ret.type = LIST;	ret.v.list = list_setadd(left.v.list, right);	push(ret);    } else {	var_free(left);  var_free(right);	raise(E_TYPE);    }}

static int sqlite_callback(void *arg, int argc, char **argv, char **azColName){struct strbuf *res = arg;int i;/* For second and subsequent results, insert /n */if (res->string != NULL)  res->string = string_cat(res->string, &res->size, &res->len, US"/n", 1);if (argc > 1)  {  /* For multiple fields, include the field name too */  for (i = 0; i < argc; i++)    {    uschar *value = US((argv[i] != NULL)? argv[i]:"<NULL>");    res->string = lf_quote(US azColName[i], value, Ustrlen(value), res->string,      &res->size, &res->len);    }  }else  {  res->string = string_append(res->string, &res->size, &res->len, 1,    (argv[0] != NULL)? argv[0]:"<NULL>");  }res->string[res->len] = 0;return 0;}

irom static app_action_t application_function_i2c_reset(const string_t *src, string_t *dst){	i2c_error_t error;	if((error = i2c_reset()) != i2c_error_ok)	{		string_cat(dst, "i2c-reset: ");		i2c_error_format_string(dst, error);		string_cat(dst, "/n");		return(app_action_error);	}	string_cat(dst, "i2c_reset: ok/n");	return(app_action_normal);}

void dolines(SQLHSTMT *stmt, SQLSMALLINT ncol, char format){	int j;	long ans;	string *str, *tstr;	char istr[256];	long sb = 0;	SQLLEN si;	str = new_string();	tstr = new_string();	for(;;)	{		ans = SQLFetch(*stmt);		/*		 * I assume error here is EOF...		 */		if((ans != SQL_SUCCESS) && ( ans != SQL_SUCCESS_WITH_INFO))			break;		for(j=0;j<ncol;j++)		{			si = 0;			for(;;)			{				ans = SQLGetData(stmt, j+1, SQL_C_CHAR, istr, 256, &si);				if(ans == SQL_NO_DATA) break;				if(si == SQL_NO_TOTAL)				{					sb += 255;					}				else				{					sb += si;				}				string_cat(tstr, istr);						if(si != SQL_NO_TOTAL) break;			}			dolitem(str, string_s(tstr), (j == ncol - 1), format);			string_clear(tstr);		}		string_cat_c(str, '/n');		if(message_send(mes, str, 0, MES_SERVER_TO_CLIENT) < 0) return;		string_clear(str);	}	string_delete(str);	string_delete(tstr);	return;}

static uschar *rfc2231_to_2047(const uschar * fname, const uschar * charset, int * len){int size = 0, ptr = 0;uschar * val = string_cat(NULL, &size, &ptr, US"=?", 2);uschar c;if (charset)  val = string_cat(val, &size, &ptr, charset, Ustrlen(charset));val = string_cat(val, &size, &ptr, US"?Q?", 3);while ((c = *fname))  if (c == '%' && isxdigit(fname[1]) && isxdigit(fname[2]))    {    val = string_cat(val, &size, &ptr, US"=", 1);    val = string_cat(val, &size, &ptr, ++fname, 2);    fname += 2;    }  else    val = string_cat(val, &size, &ptr, fname++, 1);val = string_cat(val, &size, &ptr, US"?=", 2);val[*len = ptr] = '/0';return val;}

void prepend_pref_path(char * dst, const char * src, int maxlen) {	if (SDL_strlcpy(dst, pref_path, maxlen) >= maxlen) {		fatal("not enough space for pref_path");	}	if (SDL_strlcat(dst, src, maxlen) >= maxlen) {		char * msg = string_cat(src, " too long");		fatal(msg);	}}

irom void i2c_error_format_string(string_t *dst, i2c_error_t error){	string_cat(dst, ": i2c bus error: ");	if(error < i2c_error_size)		string_cat_ptr(dst, error_strings[error]);	else		string_cat(dst, "<unknown error>");	string_cat(dst, " (in bus state: ");	if(state < i2c_state_size)		string_cat_ptr(dst, state_strings[state]);	else		string_format(dst, "<unknown state %d>", state);	string_cat(dst, ")");}

irom static app_action_t ota_start(const string_t *src, string_t *dst, bool verify){	rboot_config rcfg = rboot_get_config();	if(string_size(&buffer_4k) < 0x1000)	{		string_format(dst, "OTA: string write buffer too small: %d/n", string_size(&buffer_4k));		return(app_action_error);	}	if((rcfg.magic != BOOT_CONFIG_MAGIC) || (rcfg.count != 2) || (rcfg.current_rom > 1))	{		string_cat(dst, "OTA: rboot config invalid/n");		return(app_action_error);	}	if(parse_int(1, src, &remote_file_length, 0) != parse_ok)	{		string_cat(dst, "OTA: invalid/missing file length/n");		return(app_action_error);	}	if(wlan_scan_active())	{		string_cat(dst, "OTA: wlan scan active/n");		return(app_action_error);	}	ota_state = verify ? state_verify : state_write;	flash_slot = rcfg.current_rom == 0 ? 1 : 0;	flash_sector = rcfg.roms[flash_slot] / 0x1000;	received = 0;	written = 0;	skipped = 0;	string_clear(&buffer_4k);	string_crc32_init();	MD5Init(&md5);	string_format(dst, "%s %d %d/n", verify ? "VERIFY" : "WRITE", flash_slot, flash_sector);	return(app_action_normal);}

static int	concat_parts(t_printf_part **beginning, char **ret){	t_printf_part	*current;	size_t			len;	current = *beginning;	len = final_string_size(current);	if (!(*ret = (char*)ft_memalloc(sizeof(char) * (len + 1))))		return (-1);	string_cat(*ret, 0);	while (current)	{		string_cat((char*)current->str_ptr, current->str_size);		string_cat(current->nbr_ptr, current->nbr_size);		current = current->next;	}	string_cat(NULL, 0);	return (len);}

irom static app_action_t application_function_i2c_sensor_calibrate(const string_t *src, string_t *dst){	int intin;	i2c_sensor_t sensor;	double factor;	double offset;	if(parse_int(1, src, &intin, 0) != parse_ok)	{		string_cat(dst, "> invalid i2c sensor/n");		return(app_action_error);	}	sensor = (i2c_sensor_t)intin;	if(parse_float(2, src, &factor) != parse_ok)	{		string_cat(dst, "> invalid factor/n");		return(app_action_error);	}	if(parse_float(3, src, &offset) != parse_ok)	{		string_cat(dst, "> invalid offset/n");		return(app_action_error);	}	if(!i2c_sensor_setcal(sensor, factor, offset))	{		string_format(dst, "> invalid i2c sensor: %d/n", (int)sensor);		return(app_action_error);	}	string_format(dst, "> i2c sensor %d calibration set to factor ", (int)sensor);	string_double(dst, config.i2c_sensors.sensor[sensor].calibration.factor, 4, 1e10);	string_cat(dst, ", offset: ");	string_double(dst, config.i2c_sensors.sensor[sensor].calibration.offset, 4, 1e10);	string_cat(dst, "/n");	return(app_action_normal);}

irom static app_action_t application_function_wlan_list(const string_t *src, string_t *dst){	if(wlan_scan_state != ws_finished)	{		string_cat(dst, "wlan scan: no results (yet)/n");		return(app_action_normal);	}	string_copy_string(dst, &buffer_4k);	wlan_scan_state = ws_inactive;	return(app_action_normal);}

irom static app_action_t application_function_wlan_scan(const string_t *src, string_t *dst){	if(wlan_scan_state != ws_inactive)	{		string_cat(dst, "wlan-scan: already scanning/n");		return(app_action_error);	}#if IMAGE_OTA == 1	if(ota_active())	{		string_cat(dst, "wlan-scan: ota active/n");		return(app_action_error);	}#endif	wlan_scan_state = ws_scanning;	wifi_station_scan(0, wlan_scan_done_callback);	string_cat(dst, "wlan scan started, use wlan-list to retrieve the results/n");	return(app_action_normal);}

irom static app_action_t application_function_wlan_mode(const string_t *src, string_t *dst){	if(parse_string(1, src, dst) != parse_ok)	{		string_cat(dst, "wlan-mode: supply mode: client or ap/n");		return(app_action_error);	}	if(string_match(dst, "client"))	{		string_clear(dst);		config.wlan_mode = config_wlan_mode_client;		if(!wlan_init())		{			string_cat(dst, "wlan-mode: invalid mode/n");			return(app_action_error);		}		return(app_action_disconnect);	}	if(string_match(dst, "ap"))	{		string_clear(dst);		config.wlan_mode = config_wlan_mode_ap;		if(!wlan_init())		{			string_cat(dst, "wlan-mode: invalid mode/n");			return(app_action_error);		}		return(app_action_disconnect);	}	string_cat(dst, ": invalid wlan mode/n");	return(app_action_error);}