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

static bool find_module_file(const char* module_name, caValue* filenameOut){    Value module;    set_string(&module, module_name);    int count = list_length(&g_moduleSearchPaths);    for (int i=0; i < count; i++) {        // For each search path we'll check two places.        // Look under searchPath/moduleName.ca        Value searchPath;        copy(g_moduleSearchPaths[i], &searchPath);        circa_join_path(&searchPath, &module);        string_append(&searchPath, ".ca");        if (circa_file_exists(as_cstring(&searchPath))) {            swap(&searchPath, filenameOut);            return true;        }        // Look under searchPath/moduleName/moduleName.ca        copy(g_moduleSearchPaths[i], &searchPath);        circa_join_path(&searchPath, &module);        circa_join_path(&searchPath, &module);        string_append(&searchPath, ".ca");        if (circa_file_exists(as_cstring(&searchPath))) {            swap(&searchPath, filenameOut);            return true;        }    }    return false;}

void cmd_write (uint64_t cluster, uint8_t adcport, uint64_t maxsize, uint8_t speed){	uart_puts_P("Writing.../r/n");	uint16_t maxblocks = maxsize / 512;	uint16_t block = 0;	char c = 0x00;	while(c != 'q')	{		char values[512] = {0x00};		for (uint16_t i = 0; i<=80; ++i)		{			adc_request(adcport);			uint16_t adcvalue = adc_read();			string_append(values, num2str(adcvalue, 10));			string_append(values, "/r/n");			for (uint8_t d = 0; d<=speed; ++d)				_delay_ms(3);			uart_puts(num2str(i, 10));			uart_puts(": ");			uart_puts(num2str(adcvalue, 10));			uart_puts("/r/n");			c = uart_getc();			if (c == 'q') break;		}		fat_write_file(cluster, (unsigned char*)values, block);		++block;		if (block >= maxblocks) break;	}	uart_puts_P("...done/r/n");}

void inicializar_panel(t_tipo_proceso tipo_proceso, char* path){	char* tipo_proceso_str;	if (tipo_proceso == KERNEL)		tipo_proceso_str = "kernel";	else if (tipo_proceso == CPU)		tipo_proceso_str = "cpu";	else		tipo_proceso_str = "?";	proceso_tipo = tipo_proceso;	char* logFile = string_duplicate(path);	string_append(&logFile, tipo_proceso_str);	string_append(&logFile, ".log");	remove(logFile);	logger = log_create(logFile, tipo_proceso_str, true, LOG_LEVEL_INFO);	log_info(logger, "Inicializando panel para %s, en /"%s/"", tipo_proceso_str, logFile);	free(logFile);	kernel_cpus_conectadas = list_create();	kernel_consolas_conectadas = list_create();}

static void build_signature(struct signctx *senv, const char *method, const char *consumerSecret, const char *tokenSecret){	struct signature_param *sp;	const size_t nParams = vector_size(&senv->signatureParams);	uint32_t i;	uint8_t digest[20];	qsort(vector_values(&senv->signatureParams), vector_size(&senv->signatureParams), senv->signatureParams.item_size, bySignatureParamName);	string_append(&senv->signatureSeed, "&", 1);	if (nParams)	{		i = 0;		do		{			sp = (struct signature_param *)vector_value(&senv->signatureParams, i);			string_appendfmt(&senv->signatureSeed, "%s%%3D", sp->name);			string_append_urlencoded_rfc3986(&senv->signatureSeed, sp->value, sp->len);			string_append(&senv->signatureSeed, "%26", 3);		} while (++i != nParams);		string_adjustlen(&senv->signatureSeed, 3);	}	char _k[256];	const size_t keyLen = sprintf(_k, "%s&%s", consumerSecret, tokenSecret);	string_reset(&senv->signatureParamsBuf);	hmac((uint8_t *)_k, keyLen, (uint8_t *)string_data(&senv->signatureSeed), string_len(&senv->signatureSeed), digest);	base64_encode(digest, 20, &senv->signatureParamsBuf, 0);}

void logearOrdenReduce(char* nombre){	t_log_level nivel;	t_log* archivoDeLog;	nivel = LOG_LEVEL_INFO;	archivoDeLog = log_create("LogNodo", "Nodo", 0, nivel);		 char *unaPalabra = string_new();		 string_append(&unaPalabra, "Solicitud de Reduce con el script ");		 string_append(&unaPalabra, nombre);		log_info(archivoDeLog,unaPalabra);		free(unaPalabra);		log_destroy(archivoDeLog);}

//Devuelve un num positivo o Devuelve 0 si hay errorint getCantidadDeCopiasDe1Bloque_ArchivoDB(const bson_t * documento_X, int numBloque){    bson_iter_t punteroDeBusqueda;    bson_iter_t valorEncontrado;    int CantidadDeCopias = 0;    char *claveGenerada = string_new();		string_append(&claveGenerada, "Bloques");    		string_append(&claveGenerada, ".");		string_append(&claveGenerada, string_itoa(numBloque));			string_append(&claveGenerada, ".");		string_append(&claveGenerada, "cantidadDeCopias");    if (documento_X != NULL &&        bson_iter_init (&punteroDeBusqueda, documento_X) &&        bson_iter_find_descendant (&punteroDeBusqueda, claveGenerada, &valorEncontrado) &&        BSON_ITER_HOLDS_INT32 (&valorEncontrado))    {        CantidadDeCopias = bson_iter_int32 (&valorEncontrado);    }    free(claveGenerada);    return CantidadDeCopias;}

static void import_base_rule( void * r_, void * d_ ){    RULE * r = (RULE *)r_;    RULE * ir1;    RULE * ir2;    struct import_base_data * d = (struct import_base_data *)d_;    string qualified_name[ 1 ];    OBJECT * qname;    string_new      ( qualified_name               );    string_append   ( qualified_name, object_str( d->base_name ) );    string_push_back( qualified_name, '.'          );    string_append   ( qualified_name, object_str( r->name ) );    qname = object_new( qualified_name->value );    ir1 = import_rule( r, d->class_module, r->name );    ir2 = import_rule( r, d->class_module, qname );    object_free( qname );    /* Copy 'exported' flag. */    ir1->exported = ir2->exported = r->exported;    /* If we are importing a class method, localize it. */    if ( ( r->module == d->base_module ) || ( r->module->class_module &&        ( r->module->class_module == d->base_module ) ) )    {        rule_localize( ir1, d->class_module );        rule_localize( ir2, d->class_module );    }    string_free( qualified_name );}

caValue* selector_advance(caValue* value, caValue* selectorElement, caValue* error){    if (is_int(selectorElement)) {        int selectorIndex = as_int(selectorElement);        if (!is_list(value)) {            set_error_string(error, "Value is not indexable: ");            string_append_quoted(error, value);            return NULL;        }        if (selectorIndex >= list_length(value)) {            set_error_string(error, "Index ");            string_append(error, selectorIndex);            string_append(error, " is out of range");            return NULL;        }        return get_index(value, selectorIndex);    }    else if (is_string(selectorElement)) {        caValue* field = get_field(value, as_cstring(selectorElement));        if (field == NULL) {            set_error_string(error, "Field not found: ");            string_append(error, selectorElement);            return NULL;        }        return field;    } else {        set_error_string(error, "Unrecognized selector element: ");        string_append_quoted(error, selectorElement);        return NULL;    }}

void join_path(Value* left, Value* right){    const char* leftStr = as_cstring(left);    const char* rightStr = as_cstring(right);    int left_len = (int) strlen(leftStr);    int right_len = (int) strlen(leftStr);    if (string_equals(left, "") || string_equals(left, ".")) {        copy(right, left);        return;    }    if (string_equals(right, ""))        return;    int seperatorCount = 0;    if (left_len > 0 && is_path_seperator(leftStr[left_len-1]))        seperatorCount++;    if (right_len > 0 && is_path_seperator(rightStr[0]))        seperatorCount++;    if (seperatorCount == 2)        string_resize(left, left_len - 1);    else if (seperatorCount == 0)        string_append(left, "/");    string_append(left, right);}

void get_path_relative_to_source(caBlock* relativeTo, Value* relPath, Value* result){    if (relativeTo == NULL) {        copy(relPath, result);        return;    }    // Don't modify absolute paths    if (is_absolute_path(relPath)) {        copy(relPath, result);        return;    }    Value scriptLocation;    get_source_file_location(relativeTo, &scriptLocation);    if (string_equals(&scriptLocation, "") || string_equals(&scriptLocation, ".")) {        set_value(result, relPath);        return;    }    set_value(result, &scriptLocation);    if (!string_equals(relPath,"")) {        string_append(result, "/");        string_append(result, relPath);    }}

void imprimirLista(char* nivel, t_list* rdy, t_list* blk, int cont) {	char* tmp = malloc(20);	char* retorno = malloc(500);	int i;	personaje_t* levantador;	if (list_size(rdy) == 0 || cont < 0) { //Si no hay nadie listo, no se quien esta ejecutando		sprintf(retorno, "Lista de: %s/n/tEjecutando:/n/tListos: /t", nivel);	} else {		levantador = list_get(rdy, cont);		sprintf(retorno, "Lista de: %s/n/tEjecutando: %c/n/tListos: /t", nivel, levantador->name);	}	for (i = 0; i < list_size(rdy); i++) {		levantador = list_get(rdy, i);		sprintf(tmp, "%c -> ", levantador->name);		string_append(&retorno, tmp);	}	sprintf(tmp, "/n/tBloqueados: /t");	string_append(&retorno, tmp);	for (i = 0; i < list_size(blk); i++) {		levantador = list_get(blk, i);		sprintf(tmp, "%c -> ", levantador->name);		string_append(&retorno, tmp);	}	log_info(logger, retorno);	free(tmp);	free(retorno);}

/* * Join tokens in a given list.  If sep is true, a space is put * between tokens.  If false, no separator. */static String *join_tokens(List *arg, bool sep) {    String *s = make_string();    for (int i = 0; i < LIST_LEN(arg); i++) {        Token *tok = LIST_REF(arg, i);        if (sep && STRING_LEN(s) && tok->space)            o1(s, ' ');        switch (tok->toktype) {        case TOKTYPE_IDENT:        case TOKTYPE_CPPNUM:            string_append(s, STRING_BODY(tok->val.str));            break;        case TOKTYPE_PUNCT:            string_append(s, token_to_string(tok));            break;        case TOKTYPE_CHAR: {            // TODO: retain original spelling            o1(s, '/'');            stringize_char(s, tok->val.i, '/'');            string_append(s, "/'");            break;        }        case TOKTYPE_STRING: {            o1(s, '"');            for (char *p = STRING_BODY(tok->val.str); *p; p++)                stringize_char(s, *p, '/"');            string_append(s, "/"");            break;        }        default:            panic("invalid token type: %d", tok->toktype);        }    }    return s;}

static String* create_json(String* content, Project* project, Message* message, List* elements, List* element_types){    Iterator* it;    String* base_url_a = string_new();    base_url_a = get_base_url(base_url_a);    string_appendf(content, "{project:{name: /"%s/"}, ticket:{id: %d, url: /"%s/%s/ticket/%d/",fields:[",            string_rawstr(project->name),            message->id,            string_rawstr(base_url_a),            g_project_code_4_url,            message->id);    string_free(base_url_a);    foreach (it, element_types) {        ElementType* et = it->element;        String* field_a = string_new();        String* name_a = string_new();        String* value_a = string_new();        string_append(name_a, string_rawstr(et->name));        escape_quot(name_a);        string_append(value_a, get_element_value(elements, et));        escape_quot(value_a);        string_appendf(field_a, "{name:/"%s/", value:/"%s/"}",                string_rawstr(name_a),                string_rawstr(value_a));        string_free(name_a);        string_free(value_a);        string_append(content, string_rawstr(field_a));        string_free(field_a);        if (iterator_next(it)) string_append(content, ",");    }

char * posicionToString(t_posicion * posicion){	char * pos = string_new();	string_append(&pos, string_from_format("%d",posicion->posX));	string_append(&pos, ",");	string_append(&pos, string_from_format("%d",posicion->posY));	return pos;}

void nerr_error_traceback (NEOERR *err, NEOSTRING *str){  NEOERR *more;  char buf[1024];  char buf2[1024];  char *err_name;  if (err == STATUS_OK)    return;  if (err == INTERNAL_ERR)  {    string_append (str, "Internal error");    return;  }  more = err;  string_append (str, "Traceback (innermost last):/n");  while (more && more != INTERNAL_ERR)  {    err = more;    more = err->next;    if (err->error != NERR_PASS)    {      NEOERR *r;      if (err->error == 0)      {	err_name = buf;	snprintf (buf, sizeof (buf), "Unknown Error");      }      else      {	r = uListGet (Errors, err->error - 1, (void *)&err_name);	if (r != STATUS_OK)	{	  err_name = buf;	  snprintf (buf, sizeof (buf), "Error %d", err->error);	}      }      snprintf (buf2, sizeof(buf2),	  "  File /"%s/", line %d, in %s()/n%s: %s/n", err->file,	  err->lineno, err->func, err_name, err->desc);      string_append(str, buf2);    }    else    {      snprintf (buf2, sizeof(buf2), "  File /"%s/", line %d, in %s()/n",	  err->file, err->lineno, err->func);      string_append(str, buf2);      if (err->desc[0])      {	snprintf (buf2, sizeof(buf2), "    %s/n", err->desc);	string_append(str, buf2);      }    }  }}

app_action_t application_function_flash_receive(string_t *src, string_t *dst){	unsigned int chunk_offset, chunk_length;	if(string_size(&flash_sector_buffer) < SPI_FLASH_SEC_SIZE)	{		string_format(dst, "ERROR flash-receive: flash sector buffer too small: %d/n", string_size(&flash_sector_buffer));		return(app_action_error);	}	if(parse_uint(1, src, &chunk_offset, 0, ' ') != parse_ok)	{		string_append(dst, "ERROR flash-receive: chunk offset required/n");		return(app_action_error);	}	if(parse_uint(2, src, &chunk_length, 0, ' ') != parse_ok)	{		string_append(dst, "ERROR flash-receive: chunk chunk_length required/n");		return(app_action_error);	}	if((chunk_length == 0) || ((chunk_offset % chunk_length) != 0))	{		string_append(dst, "ERROR: flash-receive: chunk offset should be divisible by chunk size");		return(app_action_error);	}	if((chunk_length == 0) || ((SPI_FLASH_SEC_SIZE % chunk_length) != 0))	{		string_append(dst, "ERROR: flash-receive: chunk length should be divisible by flash sector size");		return(app_action_error);	}	if((chunk_offset + chunk_length) > SPI_FLASH_SEC_SIZE)	{		string_format(dst, "ERROR flash-receive: chunk_length(%u) + chunk_offset(%u) > sector size(%d)/n", chunk_length, chunk_offset, SPI_FLASH_SEC_SIZE);		return(app_action_error);	}	if((flash_sector_buffer_use != fsb_free) && (flash_sector_buffer_use != fsb_config_cache) && (flash_sector_buffer_use != fsb_ota))	{		string_format(dst, "ERROR: flash_send: sector buffer in use: %u/n", flash_sector_buffer_use);		return(app_action_error);	}	flash_sector_buffer_use = fsb_ota;	string_format(dst, "OK flash-receive: sending bytes: %u, from offset: %u, data: @", chunk_length, chunk_offset);	string_splice(dst, -1, &flash_sector_buffer, chunk_offset, chunk_length);	string_append(dst, "/n");	if((chunk_offset + chunk_length) >= SPI_FLASH_SEC_SIZE)		flash_sector_buffer_use = fsb_free;	return(app_action_normal);}

void agregarHeader(char** mensaje){	char* head=string_new();	char* numero=header(string_length(*mensaje));	string_append(&head,numero);	string_append(&head,*mensaje);	*mensaje=string_duplicate(head);	free(numero);	free (head);}

char* path_append( char* base, const char* tail ){	if( !base )		return path_clean( string_clone( tail ), path_is_absolute( tail ) );	base = string_append( base, "/" );	base = string_append( base, tail );	base = path_clean( base, path_is_absolute( base ) );	return base;}

LIST *property_set_create( PARSE *parse, FRAME *frame ){    LIST* properties = lol_get( frame->args, 0 );        LIST* sorted = 0;    LIST* order_sensitive = 0;    LIST* unique;    LIST* tmp;    LIST* val;    string var[1];#if 0    /* Sort all properties which are not order sensitive */    for(tmp = properties; tmp; tmp = tmp->next) {        LIST* g = get_grist(tmp->string);        LIST* att = call_rule("feature.attributes", frame, g, 0);        if (list_in(att, "order-sensitive")) {            order_sensitive = list_new( order_sensitive, tmp->string);        } else {            sorted = list_new( sorted, tmp->string);        }        list_free(att);    }        sorted = list_sort(sorted);    sorted = list_append(sorted, order_sensitive);    unique = list_unique(sorted);#endif    sorted = list_sort(properties);    unique = list_unique(sorted);    string_new(var);    string_append(var, ".ps.");        for(tmp = unique; tmp; tmp = tmp->next) {        string_append(var, tmp->string);        string_push_back(var, '-');    }    val = var_get(var->value);    if (val == 0)     {                  val = call_rule("new", frame,                         list_append(list_new(0, "property-set"), unique), 0);                                var_set(newstr(var->value), list_copy(0, val), VAR_SET);    }    else    {        val = list_copy(0, val);    }        string_free(var);    /* The 'unique' variable is freed in 'call_rule'. */    list_free(sorted);    return val;}

static void test_string_append() {	char *string = string_new();	string_append(&string, "Hello");	string_append(&string, " ");	string_append(&string, "world");	CU_ASSERT_STRING_EQUAL(string, "Hello world");	free(string);}

void term_toString(Value* val, Value* out){    Term* t = as_term_ref(val);    if (t == NULL)        string_append(out, "Term#null");    else {        string_append(out, "Term#");        string_append(out, t->id);    }}

void block_to_string(Value* value, Value* asStr){    Block* block = as_block(value);    if (block == NULL) {        string_append(asStr, "Block#null");    } else {        string_append(asStr, "Block#");        string_append(asStr, block->id);    }}

void CuSuiteSummary(CuSuite* testSuite, char **summary) {	int i;	for (i = 0 ; i < testSuite->count ; ++i)        {            CuTest* testCase = testSuite->list[i];            string_append(summary, testCase->failed ? "F" : ".");        }	string_append(summary, "/n/n");}

bool block_check_invariants_print_result(Block* block, Value* out){    circa::Value result;    block_check_invariants(&result, block);    if (list_length(&result) == 0)        return true;    string_append(out, list_length(&result));    string_append(out, " errors found in block ");    string_append_ptr(out, block);    string_append(out, "/n");    for (int i=0; i < list_length(&result); i++) {        Value* error = list_get(&result,i);        string_append(out, "[");        string_append(out, as_int(list_get(error, 1)));        string_append(out, "]");        string_append(out, as_cstring(list_get(error, 2)));        string_append(out, "/n");    }    string_append(out, "contents:/n");    print_block(block, out);    return false;}

/** * Turns the backtrace into a string that can be displayed * * @param bt * @return */char *arch_debug_bt2string(struct bt *bt){#if defined(__SASC) && defined(DEBUG_RESTRACK)	string str;	char buf[120];	int i;	int last_line = -1;	char *last_file = NULL;	if (!bt) return NULL;	if (!(string_initialize(&str,200)))		return NULL;	/* Load debug infos if not done yet */	arch_debug_load();	string_append(&str,"Backtrace/n");	for (i=0;i<bt->addr_used;i++)	{		ULONG offset = (ULONG)bt->addr[i] - (ULONG)__code_base;		sm_snprintf(buf,sizeof(buf),"/t/t%p (offset %p",bt->addr[i],offset);		string_append(&str,buf);		if (debug_info_count > 0)		{			struct debug_info *di;			int offset = (ULONG)bt->addr[i] - (ULONG)__code_base;			BIN_SEARCH(debug_info_array, 0, debug_info_count-1,					(debug_info_array[m].offset <= offset) ?					(offset < debug_info_array[m+1].offset?0:(1)):(-1),					di);			if (di && (di->filename != last_file || di->line != last_line))			{				string_append(&str,", ");				sm_snprintf(buf,sizeof(buf),"%s/%d",di->filename,di->line);				string_append(&str,buf);				last_file = di->filename;				last_line = di->line;			}		}		string_append(&str,")/n");	}	return str.str;#else	return NULL;#endif}

char* string_join(t_list* chunks, char * separator) {	int i;	char* ret = string_duplicate("");	for(i = 0; i < list_size(chunks); i++) {		if(i) {			string_append(&ret, separator);		}		string_append(&ret, (char*) list_get(chunks, i));	}	return ret;}

void string_append(caValue* left, caValue* right){    ca_assert(is_string(left));    if (is_string(right))        string_append(left, as_cstring(right));    else {        std::string s = to_string(right);        string_append(left, s.c_str());    }}

void string_append_qualified_name(caValue* left, caValue* right){    if (string_eq(left, "")) {        copy(right, left);        return;    }    if (string_eq(right, ""))        return;    string_append(left, ":");    string_append(left, right);}

void format_global_id(Term* term, Value* out){    if (!is_string(out))        set_string(out, "");    if (term == NULL)        string_append(out, "null");    else {        string_append(out, "#");        string_append(out, term->id);    }}