if (str <= end)					*str = '%';				++str;				continue;				/* integer number formats - set up the flags and "break" */			case 'o':				base = 8;				break;			case 'X':				flags |= LARGE;			case 'x':				base = 16;				break;			case 'd':			case 'i':				flags |= SIGN;			case 'u':				break;			default:				if (str <= end)					*str = '%';				++str;				if (*fmt) {					if (str <= end)						*str = *fmt;					++str;				} else {					--fmt;				}				continue;		}		if (qualifier == 'L')			num = va_arg(args, long long);		else if (qualifier == 'l') {			num = va_arg(args, unsigned long);			if (flags & SIGN)				num = (signed long) num;		} else if (qualifier == 'Z' || qualifier == 'z') {			num = va_arg(args, size_t);		} else if (qualifier == 'h') {			num = (unsigned short) va_arg(args, int);			if (flags & SIGN)				num = (signed short) num;		} else {			num = va_arg(args, unsigned int);			if (flags & SIGN)				num = (signed int) num;		}		str = number(str, end, num, base,				field_width, precision, flags);	}	if (str <= end)		*str = '\0';	else if (size > 0)		/* don't write out a null byte if the buf size is zero */		*end = '\0';	/* the trailing null byte doesn't count towards the total	* ++str;	*/	return str-buf;}//EXPORT_SYMBOL(vsnprintf);/** * vscnprintf - Format a string and place it in a buffer * @buf: The buffer to place the result into * @size: The size of the buffer, including the trailing null space * @fmt: The format string to use * @args: Arguments for the format string * * The return value is the number of characters which have been written into * the @buf not including the trailing '\0'. If @size is <= 0 the function * returns 0. * * Call this function if you are already dealing with a va_list. * You probably want scnprintf instead. */int vscnprintf(char *buf, size_t size, const char *fmt, va_list args){	int i;	i=vsnprintf(buf,size,fmt,args);	return (i >= size) ? (size - 1) : i;}//EXPORT_SYMBOL(vscnprintf);/** * snprintf - Format a string and place it in a buffer * @buf: The buffer to place the result into * @size: The size of the buffer, including the trailing null space * @fmt: The format string to use * @...: Arguments for the format string * * The return value is the number of characters which would be * generated for the given input, excluding the trailing null, * as per ISO C99.  If the return is greater than or equal to * @size, the resulting string is truncated. */int snprintf(char * buf, size_t size, const char *fmt, ...){	va_list args;	int i;	va_start(args, fmt);	i=vsnprintf(buf,size,fmt,args);	va_end(args);	return i;}//EXPORT_SYMBOL(snprintf);/** * scnprintf - Format a string and place it in a buffer * @buf: The buffer to place the result into * @size: The size of the buffer, including the trailing null space * @fmt: The format string to use * @...: Arguments for the format string * * The return value is the number of characters written into @buf not including * the trailing '\0'. If @size is <= 0 the function returns 0. If the return is * greater than or equal to @size, the resulting string is truncated. */int scnprintf(char * buf, size_t size, const char *fmt, ...){	va_list args;	int i;	va_start(args, fmt);	i = vsnprintf(buf, size, fmt, args);	va_end(args);	return (i >= size) ? (size - 1) : i;}//EXPORT_SYMBOL(scnprintf);/** * vsprintf - Format a string and place it in a buffer * @buf: The buffer to place the result into * @fmt: The format string to use * @args: Arguments for the format string * * The function returns the number of characters written * into @buf. Use vsnprintf or vscnprintf in order to avoid * buffer overflows. * * Call this function if you are already dealing with a va_list. * You probably want sprintf instead. */int vsprintf(char *buf, const char *fmt, va_list args){	return vsnprintf(buf, (~0U)>>1, fmt, args);}//EXPORT_SYMBOL(vsprintf);/** * sprintf - Format a string and place it in a buffer * @buf: The buffer to place the result into * @fmt: The format string to use * @...: Arguments for the format string * * The function returns the number of characters written * into @buf. Use snprintf or scnprintf in order to avoid * buffer overflows. */int sprintf(char * buf, const char *fmt, ...){	va_list args;	int i;	va_start(args, fmt);/*	putc('P');	putc(0x0d);	putc(0x0a);*/		i=vsprintf(buf,fmt,args);/*	putc('E');	putc(0x0d);	putc(0x0a);*/		va_end(args);	return i;}//EXPORT_SYMBOL(sprintf);/** * vsscanf - Unformat a buffer into a list of arguments * @buf:	input buffer * @fmt:	format of buffer * @args:	arguments */int vsscanf(const char * buf, const char * fmt, va_list args){	const char *str = buf;	char *next;	char digit;	int num = 0;	int qualifier;	int base;	int field_width;	int is_sign = 0;	while(*fmt && *str) {		/* skip any white space in format */		/* white space in format matchs any amount of		 * white space, including none, in the input.		 */		if (isspace(*fmt)) {			while (isspace(*fmt))				++fmt;			while (isspace(*str))				++str;		}		/* anything that is not a conversion must match exactly */		if (*fmt != '%' && *fmt) {			if (*fmt++ != *str++)				break;			continue;		}		if (!*fmt)			break;		++fmt;				/* skip this conversion.		 * advance both strings to next white space		 */		if (*fmt == '*') {			while (!isspace(*fmt) && *fmt)				fmt++;			while (!isspace(*str) && *str)				str++;			continue;		}		/* get field width */		field_width = -1;		if (isdigit(*fmt))			field_width = skip_atoi(&fmt);		/* get conversion qualifier */		qualifier = -1;		if (*fmt == 'h' || *fmt == 'l' || *fmt == 'L' ||		    *fmt == 'Z' || *fmt == 'z') {			qualifier = *fmt++;			if (unlikely(qualifier == *fmt)) {				if (qualifier == 'h') {					qualifier = 'H';					fmt++;				} else if (qualifier == 'l') {					qualifier = 'L';					fmt++;				}			}		}		base = 10;		is_sign = 0;		if (!*fmt || !*str)			break;		switch(*fmt++) {		case 'c':		{			char *s = (char *) va_arg(args,char*);			if (field_width == -1)				field_width = 1;			do {				*s++ = *str++;			} while (--field_width > 0 && *str);			num++;		}		continue;		case 's':		{			char *s = (char *) va_arg(args, char *);			if(field_width == -1)				field_width = INT_MAX;			/* first, skip leading white space in buffer */			while (isspace(*str))				str++;			/* now copy until next white space */			while (*str && !isspace(*str) && field_width--) {				*s++ = *str++;			}			*s = '\0';			num++;		}		continue;		case 'n':			/* return number of characters read so far */		{			int *i = (int *)va_arg(args,int*);			*i = str - buf;		}		continue;		case 'o':			base = 8;			break;		case 'x':		case 'X':			base = 16;			break;		case 'i':                        base = 0;		case 'd':			is_sign = 1;		case 'u':			break;		case '%':			/* looking for '%' in str */			if (*str++ != '%') 				return num;			continue;		default:			/* invalid format; stop here */			return num;		}		/* have some sort of integer conversion.		 * first, skip white space in buffer.		 */		while (isspace(*str))			str++;		digit = *str;		if (is_sign && digit == '-')			digit = *(str + 1);		if (!digit                    || (base == 16 && !isxdigit(digit))                    || (base == 10 && !isdigit(digit))                    || (base == 8 && (!isdigit(digit) || digit > '7'))                    || (base == 0 && !isdigit(digit)))				break;		switch(qualifier) {		case 'H':	/* that's 'hh' in format */			if (is_sign) {				signed char *s = (signed char *) va_arg(args,signed char *);				*s = (signed char) simple_strtol(str,&next,base);			} else {				unsigned char *s = (unsigned char *) va_arg(args, unsigned char *);				*s = (unsigned char) simple_strtoul(str, &next, base);			}			break;		case 'h':			if (is_sign) {				short *s = (short *) va_arg(args,short *);				*s = (short) simple_strtol(str,&next,base);			} else {				unsigned short *s = (unsigned short *) va_arg(args, unsigned short *);				*s = (unsigned short) simple_strtoul(str, &next, base);			}			break;		case 'l':			if (is_sign) {				long *l = (long *) va_arg(args,long *);				*l = simple_strtol(str,&next,base);			} else {				unsigned long *l = (unsigned long*) va_arg(args,unsigned long*);				*l = simple_strtoul(str,&next,base);			}			break;		case 'L':			if (is_sign) {				long long *l = (long long*) va_arg(args,long long *);				*l = simple_strtoll(str,&next,base);			} else {				unsigned long long *l = (unsigned long long*) va_arg(args,unsigned long long*);				*l = simple_strtoull(str,&next,base);			}			break;		case 'Z':		case 'z':		{			size_t *s = (size_t*) va_arg(args,size_t*);			*s = (size_t) simple_strtoul(str,&next,base);		}		break;		default:			if (is_sign) {				int *i = (int *) va_arg(args, int*);				*i = (int) simple_strtol(str,&next,base);			} else {				unsigned int *i = (unsigned int*) va_arg(args, unsigned int*);				*i = (unsigned int) simple_strtoul(str,&next,base);			}			break;		}		num++;		if (!next)			break;		str = next;	}	return num;}//EXPORT_SYMBOL(vsscanf);/** * sscanf - Unformat a buffer into a list of arguments * @buf:	input buffer * @fmt:	formatting of buffer * @...:	resulting arguments */int sscanf(const char * buf, const char * fmt, ...){	va_list args;	int i;	va_start(args,fmt);	i = vsscanf(buf,fmt,args);	va_end(args);	return i;}//EXPORT_SYMBOL(sscanf);