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

intany2eucjp (unsigned char *dest, unsigned char *src, unsigned int dest_max){  static unsigned char tmp_dest[BUFSIZ];  int ret;  if (strlen ((const char *) src) >= BUFSIZ)    {      error ("input string too large");      return -1;    }  if (dest_max > BUFSIZ)    {      error	("invalid maximum size of destination/nit should be less than %d.",	 BUFSIZ);      return -1;    }  ret = do_check_and_conv (tmp_dest, src);  if (strlen ((const char *) tmp_dest) >= dest_max)    {      error ("output buffer overflow");      ustrcpy (dest, src);      return -1;    }  ustrcpy (dest, tmp_dest);  return ret;}

int interleaved_two_of_five(struct zint_symbol *symbol, uint8_t source[], int length){ /* Code 2 of 5 Interleaved */	int error_number;	char bars[7], spaces[7], mixed[14], dest[1000];	uint8_t temp[length + 2];	error_number = 0;	if(length > 89) {		strcpy(symbol->errtxt, "Input too long");		return ZERROR_TOO_LONG;	}	error_number = is_sane(NEON, source, length);	if (error_number == ZERROR_INVALID_DATA) {		strcpy(symbol->errtxt, "Invalid characters in data");		return error_number;	}	ustrcpy(temp, (uint8_t *) "");	/* Input must be an even number of characters for Interlaced 2 of 5 to work:	   if an odd number of characters has been entered then add a leading zero */	if (length & 1) {		ustrcpy(temp, (uint8_t *) "0");		length++;	}	uconcat(temp, source);	/* start character */	strcpy(dest, "1111");	for(int i = 0; i < length; i+=2) {		/* look up the bars and the spaces and put them in two strings */		strcpy(bars, "");		lookup(NEON, C25InterTable, temp[i], bars);		strcpy(spaces, "");		lookup(NEON, C25InterTable, temp[i + 1], spaces);		/* then merge (interlace) the strings together */		int k = 0;		for(int j = 0; j <= 4; j++)		{			mixed[k] = bars[j]; k++;			mixed[k] = spaces[j]; k++;		}		mixed[k] = '/0';		concat (dest, mixed);	}	/* Stop character */	concat (dest, "311");	expand(symbol, dest);	ustrcpy(symbol->text, temp);	return error_number;}

EOF_TEXT_EVENT * eof_song_add_text_event(EOF_SONG * sp, unsigned long beat, char * text, unsigned long track, unsigned long flags, char is_temporary){// 	eof_log("eof_song_add_text_event() entered");	if(sp && text && (sp->text_events < EOF_MAX_TEXT_EVENTS) && (beat < sp->beats))	{	//If the maximum number of text events hasn't already been defined, and the specified beat number is valid		sp->text_event[sp->text_events] = malloc(sizeof(EOF_TEXT_EVENT));		if(sp->text_event[sp->text_events])		{			sp->text_event[sp->text_events]->text[0] = '/0';	//Eliminate false positive in Splint			(void) ustrcpy(sp->text_event[sp->text_events]->text, text);			sp->text_event[sp->text_events]->beat = beat;			if(track >= sp->tracks)			{	//If this is an invalid track				track = 0;	//Make this a global text event			}			sp->text_event[sp->text_events]->track = track;			sp->text_event[sp->text_events]->flags = flags;			sp->text_event[sp->text_events]->is_temporary = is_temporary;			sp->beat[beat]->flags |= EOF_BEAT_FLAG_EVENTS;	//Set the events flag for the beat			sp->text_event[sp->text_events]->index = 0;			sp->text_events++;			return sp->text_event[sp->text_events-1];	//Return successfully created text event		}	}	return NULL;	//Return failure}

int industrial_two_of_five(struct zint_symbol *symbol, unsigned char source[], int length){ /* Code 2 of 5 Industrial */	int i, error_number;	char dest[512]; /* 6 + 40 * 10 + 6 + 1 */	error_number = 0;	if(length > 45) {		strcpy(symbol->errtxt, "Input too long");		return ERROR_TOO_LONG;	}	error_number = is_sane(NEON, source, length);	if(error_number == ERROR_INVALID_DATA) {		strcpy(symbol->errtxt, "Invalid character in data");		return error_number;	}	/* start character */	strcpy(dest, "313111");	for(i = 0; i < length; i++) {		lookup(NEON, C25IndustTable, source[i], dest);	}	/* Stop character */	concat (dest, "31113");	expand(symbol, dest);	ustrcpy(symbol->text, source);	return error_number;}

void eof_controller_read_button_names(EOF_CONTROLLER * cp){	int i;	eof_log("eof_controller_read_button_names() entered", 1);	if(!cp)	{		return;	}	for(i = 0; i < EOF_CONTROLLER_MAX_BUTTONS; i++)	{		switch(cp->button[i].type)		{			case EOF_CONTROLLER_BUTTON_TYPE_KEY:			{				(void) ustrcpy(cp->button[i].name, scancode_to_name(cp->button[i].key));				break;			}			case EOF_CONTROLLER_BUTTON_TYPE_JOYBUTTON:			{				(void) snprintf(cp->button[i].name, sizeof(cp->button[i].name) - 1, "Joy %d %s", cp->button[i].joy, joy[cp->button[i].joy].button[cp->button[i].key].name);				break;			}			case EOF_CONTROLLER_BUTTON_TYPE_JOYAXIS:			{				(void) snprintf(cp->button[i].name, sizeof(cp->button[i].name) - 1, "Joy %d %s Axis (%s)", cp->button[i].joy, joy[cp->button[i].joy].stick[cp->button[i].index].axis[cp->button[i].key].name, cp->button[i].d == 0 ? "-" : "+");				break;			}		}	}}

/* * Add a string structure to the symbol. * Coordinates assumed to be from top-center. */int render_plot_add_string(struct zint_symbol *symbol,		unsigned char *text, float x, float y, float fsize, float width,		struct zint_render_string **last_string){	struct zint_render_string *string;#ifndef _MSC_VER	string = malloc(sizeof(struct zint_render_string));#else	string = (struct zint_render_string *)_alloca(sizeof(struct zint_render_string));#endif	string->next = NULL;	string->x = x;	string->y = y;	string->width = width; 	string->fsize = fsize;	string->length = ustrlen(text);#ifndef _MSC_VER	string->text = malloc(sizeof(unsigned char) * (ustrlen(text) + 1));#else	string->text = (unsigned char *)_alloca((ustrlen(text) + 1) * sizeof(unsigned char));#endif	ustrcpy(string->text, text);	if (*last_string)		(*last_string)->next = string;	else		symbol->rendered->strings = string; // First character	*last_string = string;	return 1;}

int logic_two_of_five(struct zint_symbol *symbol, uint8_t source[], int length){ /* Code 2 of 5 Data Logic */	int error_number;	char dest[512]; /* 4 + 80 * 6 + 3 + 1 */	error_number = 0;	if(length > 80) {		strcpy(symbol->errtxt, "Input too long");		return ZERROR_TOO_LONG;	}	error_number = is_sane(NEON, source, length);	if(error_number == ZERROR_INVALID_DATA) {		strcpy(symbol->errtxt, "Invalid characters in data");		return error_number;	}	/* start character */	strcpy(dest, "1111");	for(int i = 0; i < length; i++) {		lookup(NEON, C25MatrixTable, source[i], dest);	}	/* Stop character */	concat (dest, "311");	expand(symbol, dest);	ustrcpy(symbol->text, source);	return error_number;}

void Accelerator::addKeysFromString(const char* string){  char *s, *begin, buf[256];  int backup;  ustrcpy(buf, string);  for (s=buf; *s; ) {    if (*s == '<') {      begin = ++s;      while ((*s) && (*s != '>')) s++;      backup = *s;      *s = 0;      process_one_word(this, begin);      *s = backup;    }    else {      s++;    }  }}

int matrix_two_of_five(struct zint_symbol *symbol, unsigned char source[], int length){ /* Code 2 of 5 Standard (Code 2 of 5 Matrix) */		int i, error_number;	char dest[512]; /* 6 + 80 * 6 + 6 + 1 ~ 512*/	error_number = 0;	if(length > 80) {		strcpy(symbol->errtxt, "Input too long");		return ERROR_TOO_LONG;	}	error_number = is_sane(NEON, source, length);	if(error_number == ERROR_INVALID_DATA) {		strcpy(symbol->errtxt, "Invalid characters in data");		return error_number;	}	/* start character */	strcpy(dest, "411111");	for(i = 0; i < length; i++) {		lookup(NEON, C25MatrixTable, source[i], dest);	}	/* Stop character */	concat (dest, "41111");	expand(symbol, dest);	ustrcpy(symbol->text, source);	return error_number;}

void XlateTableWriteBase::DoItem(XlateEntryData *p, unsigned lvl){	RecString tmp;	tmp.lv = lvl;	tmp.ch = p->c;	tmp.ln = p->l + 1; /* "+ 1" is in MAKEBASE j.b. */	ustrcpy(tmp.sq, p->s);	WriteData((void *)&tmp, 4+ustrlen(tmp.sq));  //4 = 3 char data, + 0 for sq term};

int channel_code(struct zint_symbol *symbol, unsigned char source[], int length) {	/* Channel Code - According to ANSI/AIM BC12-1998 */		int channels, i;	int error_number = 0, range = 0, zeroes;	char hrt[9];	target_value = 0;		if(length > 7) {		strcpy(symbol->errtxt, "Input too long");		return ERROR_TOO_LONG;	}	error_number = is_sane(NEON, source, length);    if(error_number == ERROR_INVALID_DATA1) {		strcpy(symbol->errtxt, "Invalid characters in data");		return error_number;	}		if((symbol->option_2 < 3) || (symbol->option_2 > 8)) { channels = 0; } else { channels = symbol->option_2; }	if(channels == 0) { channels = length + 1; }	if(channels == 2) { channels = 3; }		for(i = 0; i < length; i++) {		target_value *= 10;		target_value += ctoi((char) source[i]);	}		switch(channels) {		case 3: if(target_value > 26) { range = 1; } break;		case 4: if(target_value > 292) { range = 1; } break;		case 5: if(target_value > 3493) { range = 1; } break;		case 6: if(target_value > 44072) { range = 1; } break;		case 7: if(target_value > 576688) { range = 1; } break;		case 8: if(target_value > 7742862) { range = 1; } break;	}	if(range) {		strcpy(symbol->errtxt, "Value out of range");        return ERROR_INVALID_DATA1;	}		for(i = 0; i < 11; i++) { B[i] = 0; S[i] = 0; }		B[0] = S[1] = B[1] = S[2] = B[2] = 1;	value = 0;	NextS(channels,3,channels,channels);		zeroes = channels - 1 - length;	memset(hrt, '0', zeroes);	strcpy(hrt + zeroes, (char *)source);	ustrcpy(symbol->text, (unsigned char *)hrt);		expand(symbol, pattern);		return error_number;}

void upca(struct zint_symbol *symbol, unsigned char source[], char dest[]){ /* Make a UPC A barcode when we haven't been given the check digit */	int length;	char gtin[15];	strcpy(gtin, (char*)source);	length = strlen(gtin);	gtin[length] = upc_check(gtin);	gtin[length + 1] = '/0';	upca_draw(gtin, dest);	ustrcpy(symbol->text, (unsigned char*)gtin);}

void ean8(struct zint_symbol *symbol, unsigned char source[], char dest[]){ /* Make an EAN-8 barcode when we haven't been given the check digit */  /* EAN-8 is basically the same as UPC-A but with fewer digits */	int length;	char gtin[10];	strcpy(gtin, (char*)source);	length = strlen(gtin);	gtin[length] = upc_check(gtin);	gtin[length + 1] = '/0';	upca_draw(gtin, dest);	ustrcpy(symbol->text, (unsigned char*)gtin);}

int ustrcat(wchar *dest, char *src){	int dest_len, src_len;	wchar *uni;	dest_len=ustrlen(dest);	src_len=(int)strlen(src);	uni=new wchar[src_len+1];	ustrcpy(uni,src);	ustrcat(dest,uni);	delete[] uni;	return dest_len+src_len;}

UNCH LookupIntName(UNCH * n){	int u = NumberChars - 1,i,l = 0,c;	if (!n[0]) return '/0';	UNCH n1[50];	ustrcpy(n1,n);	capstr(n1+1);	do {		if (u < l) return '/0';		i = (l+u)/2;		c = ustrcmp(n1,SortedCharNames[i].cname);		if (c < 0) u = i-1; else l = i+1;}	while (c != 0);	return SortedCharNames[i].codept;}

BOOLEAN XlateTable::InsertXlateMode(UNCH mdin, UNCH mdout,												UNCH * seqin,												DupHanType DupWhat,												ostream & s){	XlateTableRec* trc = FindMode(mdin);	XlateEntryData* p = trc->InsertEntry(seqin);	if ((p->s[0] == '/0') || (DupWhat == UpdateEntry)) {		p->t = MODE;		ustrcpy(p->s, seqin);		p->m = mdout;}	else if (((p->t == MODE)||(p->s[0] != '/0')) && (DupWhat == GiveError)) {		ResFile->ResMessage(CONFLICTMSGRESOURCE, s);		return FALSE;		}	return TRUE;}

int ugs1_verify(struct zint_symbol *symbol, uint8_t source[], const unsigned int src_len, uint8_t reduced[]){	/* Only to keep the compiler happy */	char temp[src_len + 5];	int error_number;	error_number = gs1_verify(symbol, source, src_len, temp);	if(error_number != 0) { return error_number; }	if (strlen(temp) < src_len + 5) {		ustrcpy(reduced, (uint8_t*)temp);		return 0;	}	strcpy(symbol->errtxt, "ugs1_verify overflow");	return ZERROR_INVALID_DATA;}

void ean13(struct zint_symbol *symbol, unsigned char source[], char dest[]){	unsigned int length, i, half_way;	char parity[6];	char gtin[15];	strcpy(parity, "");	strcpy(gtin, (char*)source);		/* Add the appropriate check digit */	length = strlen(gtin);	gtin[length] = ean_check(gtin);	gtin[length + 1] = '/0';	/* Get parity for first half of the symbol */	lookup(SODIUM, EAN13Parity, gtin[0], parity);	/* Now get on with the cipher */	half_way = 7;	/* start character */	concat (dest, "111");	length = strlen(gtin);	for(i = 1; i <= length; i++)	{		if (i == half_way)		{			/* middle character - separates manufacturer no. from product no. */			/* also inverses right hand characters */			concat (dest, "11111");		}		if(((i > 1) && (i < 7)) && (parity[i - 2] == 'B'))		{			lookup(NEON, EANsetB, gtin[i], dest);		}		else		{			lookup(NEON, EANsetA, gtin[i], dest);		}	}	/* stop character */	concat (dest, "111");		ustrcpy(symbol->text, (unsigned char*)gtin);}

static uint8_t m2i_delete(path_t *path, cbmdirent_t *dent) {  uint16_t offset;  offset = dent->pvt.m2i.offset;// find_entry  if (load_entry(path->part, offset))    return 255;  /* Ignore the result, we'll have to delete the entry anyway */  ustrcpy(dent->name, ops_scratch + M2I_FATNAME_OFFSET);  fat_delete(path, dent);  ops_scratch[0] = '-';  if (image_write(path->part, offset, ops_scratch, 1, 1))    return 0;  else    return 1;}

void Widget::setTextf(const char *format, ...){  char buf[4096];  // formatted string  if (format) {    va_list ap;    va_start(ap, format);    vsprintf(buf, format, ap);    va_end(ap);  }  // empty string  else {    ustrcpy(buf, empty_string);  }  setText(buf);}

/** * open_existing - open an existing file * @path      : path handle * @dent      : pointer to cbmdirent struct with name of the file * @type      : type of the file (not checked) * @buf       : buffer to be used * @appendflag: Flags if the file should be opened for appending * * This function searches the file name in an M2I file and opens it * either in read or append mode according to appendflag by calling * the appropiate fat_* functions. */static void open_existing(path_t *path, cbmdirent_t *dent, uint8_t type, buffer_t *buf, uint8_t appendflag) {  if (load_entry(path->part, dent->pvt.m2i.offset)) {    set_error(ERROR_FILE_NOT_FOUND);    return;  }  if (parsetype()) {    set_error(ERROR_FILE_NOT_FOUND);    return;  }  ustrcpy(dent->pvt.fat.realname, ops_scratch + M2I_FATNAME_OFFSET);  if (appendflag)    fat_open_write(path, dent, type, buf, 1);  else    fat_open_read(path, dent, buf);}

int itf14(struct zint_symbol *symbol, uint8_t source[], int length){	int error_number, zeroes;	unsigned int count;	char localstr[16];	error_number = 0;	count = 0;	if(length > 13) {		strcpy(symbol->errtxt, "Input too long");		return ZERROR_TOO_LONG;	}	error_number = is_sane(NEON, source, length);	if(error_number == ZERROR_INVALID_DATA) {		strcpy(symbol->errtxt, "Invalid character in data");		return error_number;	}	/* Add leading zeros as required */	zeroes = 13 - length;	for(int i = 0; i < zeroes; i++) {		localstr[i] = '0';	}	strcpy(localstr + zeroes, (char *)source);	/* Calculate the check digit - the same method used for EAN-13 */	for (int i = 12; i >= 0; i--) {		count += ctoi(localstr[i]);		if (!(i & 1)) {			count += 2 * ctoi(localstr[i]);		}	}	localstr[13] = check_digit(count);	localstr[14] = '/0';	error_number = interleaved_two_of_five(symbol, (uint8_t *)localstr, strlen(localstr));	ustrcpy(symbol->text, (uint8_t*)localstr);	return error_number;}

int pharmazentral(struct zint_symbol *symbol, unsigned char source[], int length){ /* Pharmazentral Nummer (PZN) */		int i, error_number, zeroes;	unsigned int count, check_digit;	char localstr[10];		error_number = 0;	count = 0;	if(length > 6) {		strcpy(symbol->errtxt, "Input wrong length");		return ERROR_TOO_LONG;	}	error_number = is_sane(NEON, source, length);    if(error_number == ERROR_INVALID_DATA1) {		strcpy(symbol->errtxt, "Invalid characters in data");		return error_number;	}		localstr[0] = '-';	zeroes = 6 - length + 1;	for(i = 1; i < zeroes; i++)		localstr[i] = '0';	strcpy(localstr + zeroes, (char *)source);		for (i = 1; i < 7; i++) {		count += (i + 1) * ctoi(localstr[i]);	}		check_digit = count%11;	if (check_digit == 11) { check_digit = 0; }	localstr[7] = itoc(check_digit);	localstr[8] = '/0';	if(localstr[7] == 'A') { 		strcpy(symbol->errtxt, "Invalid PZN Data");        return ERROR_INVALID_DATA1;	}	error_number = c39(symbol, (unsigned char *)localstr, strlen(localstr));	ustrcpy(symbol->text, (unsigned char *)"PZN");	uconcat(symbol->text, (unsigned char *)localstr);	return error_number;}

int codabar(struct zint_symbol *symbol, unsigned char source[], int length){   /* The Codabar system consisting of simple substitution */    int i, error_number;    char dest[512];    error_number = 0;    strcpy(dest, "");    if(length > 60) { /* No stack smashing please */        strcpy(symbol->errtxt, "Input too long");        return ERROR_TOO_LONG;    }    to_upper(source);    error_number = is_sane(CALCIUM, source, length);    if(error_number == ERROR_INVALID_DATA1) {        strcpy(symbol->errtxt, "Invalid characters in data");        return error_number;    }    /* Codabar must begin and end with the characters A, B, C or D */    if((source[0] != 'A') && (source[0] != 'B') && (source[0] != 'C') && (source[0] != 'D'))    {        strcpy(symbol->errtxt, "Invalid characters in data");        return ERROR_INVALID_DATA1;    }    if((source[length - 1] != 'A') && (source[length - 1] != 'B') &&            (source[length - 1] != 'C') && (source[length - 1] != 'D'))    {        strcpy(symbol->errtxt, "Invalid characters in data");        return ERROR_INVALID_DATA1;    }    for(i = 0; i < length; i++)    {        lookup(CALCIUM, CodaTable, source[i], dest);    }    expand(symbol, dest);    ustrcpy(symbol->text, source);    return error_number;}

int ugs1_verify(struct zint_symbol *symbol, unsigned char source[], const unsigned int src_len, unsigned char reduced[]){	/* Only to keep the compiler happy */#ifndef _MSC_VER	char temp[src_len + 5];#else        char* temp = (char*)_alloca(src_len + 5);#endif	int error_number;	error_number = gs1_verify(symbol, source, src_len, temp);	if(error_number != 0) { return error_number; }	if (strlen(temp) < src_len + 5) {		ustrcpy(reduced, (unsigned char*)temp);		return 0;	}	strcpy(symbol->errtxt, "ugs1_verify overflow");	return ERROR_INVALID_DATA;}

TileType::TileType(BITMAP *tileBitmap, const char *tileName){	bitmap = tileBitmap;	name = (char*)malloc(ustrsizez(tileName));	ustrcpy(name, tileName);	int x, y;	unsigned long r = 0, g = 0, b = 0;	unsigned long pixels = tileBitmap->w * tileBitmap->h;	// Calculate average color	for (x = 0; x < tileBitmap->w; x++) {		for (y = 0; y < tileBitmap->h; y++) {			int c = getpixel(tileBitmap, x, y);			r += getr(c);			g += getg(c);			b += getb(c);		}	}	color = makecol(r / pixels, g / pixels, b / pixels);}

int ean_14(struct zint_symbol *symbol, unsigned char source[], int length){	/* EAN-14 - A version of EAN-128 */	int i, count, check_digit;	int error_number, zeroes;	unsigned char ean128_equiv[20];	if(length > 13) {		strcpy(symbol->errtxt, "Input wrong length");		return ZINT_ERROR_TOO_LONG;	}	error_number = is_sane(NEON, source, length);	if(error_number == ZINT_ERROR_INVALID_DATA) {		strcpy(symbol->errtxt, "Invalid character in data");		return error_number;	}	zeroes = 13 - length;	strcpy((char*)ean128_equiv, "[01]");	memset(ean128_equiv + 4, '0', zeroes);	ustrcpy(ean128_equiv + 4 + zeroes, source);	count = 0;	for (i = length - 1; i >= 0; i--) {		count += ctoi(source[i]);		if (!(i & 1)) {			count += 2 * ctoi(source[i]);		}	}	check_digit = 10 - (count % 10);	if (check_digit == 10) { check_digit = 0; }	ean128_equiv[17] = itoc(check_digit);	ean128_equiv[18] = '/0';	error_number = ean_128(symbol, ean128_equiv, ustrlen(ean128_equiv));	return error_number;}

int main(int argc, char *argv[]){    initialize();    // Handle a map file passed as argument    if (argc == 2 && exists(argv[1]))    {        PACKFILE *file = pack_fopen(argv[1], F_READ_PACKED);        if (file) {            currentMap->loadFrom(file, tileRepository);            pack_fclose(file);            ustrcpy(map_filename, argv[1]);            update_window_title();        } else {            alert("Invalid map file:", argv[1], NULL, "OK", NULL, 13, 0);        }    }    do_dialog(main_dlg, -1);    clean_up();    return 0;}

int dpleit(struct zint_symbol *symbol, uint8_t source[], int length){ /* Deutshe Post Leitcode */	int error_number;	unsigned int count;	char localstr[16];	int zeroes;	error_number = 0;	count = 0;	if(length > 13) {		strcpy(symbol->errtxt, "Input wrong length");		return ZERROR_TOO_LONG;	}	error_number = is_sane(NEON, source, length);	if(error_number == ZERROR_INVALID_DATA) {		strcpy(symbol->errtxt, "Invalid characters in data");		return error_number;	}	zeroes = 13 - length;	for(int i = 0; i < zeroes; i++)		localstr[i] = '0';	strcpy(localstr + zeroes, (char *)source);	for (int i = 12; i >= 0; i--)	{		count += 4 * ctoi(localstr[i]);		if (i & 1) {			count += 5 * ctoi(localstr[i]);		}	}	localstr[13] = check_digit(count);	localstr[14] = '/0';	error_number = interleaved_two_of_five(symbol, (uint8_t *)localstr, strlen(localstr));	ustrcpy(symbol->text, (uint8_t*)localstr);	return error_number;}