[deliverable/linux.git] / drivers / acpi / acpica / utprint.c

/******************************************************************************
 *
 * Module Name: utprint - Formatted printing routines
 *
 *****************************************************************************/

/*
 * Copyright (C) 2000 - 2015, Intel Corp.
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions, and the following disclaimer,
 *    without modification.
 * 2. Redistributions in binary form must reproduce at minimum a disclaimer
 *    substantially similar to the "NO WARRANTY" disclaimer below
 *    ("Disclaimer") and any redistribution must be conditioned upon
 *    including a substantially similar Disclaimer requirement for further
 *    binary redistribution.
 * 3. Neither the names of the above-listed copyright holders nor the names
 *    of any contributors may be used to endorse or promote products derived
 *    from this software without specific prior written permission.
 *
 * Alternatively, this software may be distributed under the terms of the
 * GNU General Public License ("GPL") version 2 as published by the Free
 * Software Foundation.
 *
 * NO WARRANTY
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
 * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGES.
 */

#include <acpi/acpi.h>
#include "accommon.h"

#define _COMPONENT          ACPI_UTILITIES
ACPI_MODULE_NAME("utprint")

#define ACPI_FORMAT_SIGN            0x01
#define ACPI_FORMAT_SIGN_PLUS       0x02
#define ACPI_FORMAT_SIGN_PLUS_SPACE 0x04
#define ACPI_FORMAT_ZERO            0x08
#define ACPI_FORMAT_LEFT            0x10
#define ACPI_FORMAT_UPPER           0x20
#define ACPI_FORMAT_PREFIX          0x40
/* Local prototypes */
static acpi_size
acpi_ut_bound_string_length(const char *string, acpi_size count);

static char *acpi_ut_bound_string_output(char *string, const char *end, char c);

static char *acpi_ut_format_number(char *string,
				   char *end,
				   u64 number,
				   u8 base, s32 width, s32 precision, u8 type);

static char *acpi_ut_put_number(char *string, u64 number, u8 base, u8 upper);

/* Module globals */

static const char acpi_gbl_lower_hex_digits[] = "0123456789abcdef";
static const char acpi_gbl_upper_hex_digits[] = "0123456789ABCDEF";

/*******************************************************************************
 *
 * FUNCTION:    acpi_ut_bound_string_length
 *
 * PARAMETERS:  string              - String with boundary
 *              count               - Boundary of the string
 *
 * RETURN:      Length of the string. Less than or equal to Count.
 *
 * DESCRIPTION: Calculate the length of a string with boundary.
 *
 ******************************************************************************/

static acpi_size
acpi_ut_bound_string_length(const char *string, acpi_size count)
{
	u32 length = 0;

	while (*string && count) {
		length++;
		string++;
		count--;
	}

	return (length);
}

/*******************************************************************************
 *
 * FUNCTION:    acpi_ut_bound_string_output
 *
 * PARAMETERS:  string              - String with boundary
 *              end                 - Boundary of the string
 *              c                   - Character to be output to the string
 *
 * RETURN:      Updated position for next valid character
 *
 * DESCRIPTION: Output a character into a string with boundary check.
 *
 ******************************************************************************/

static char *acpi_ut_bound_string_output(char *string, const char *end, char c)
{

	if (string < end) {
		*string = c;
	}

	++string;
	return (string);
}

/*******************************************************************************
 *
 * FUNCTION:    acpi_ut_put_number
 *
 * PARAMETERS:  string              - Buffer to hold reverse-ordered string
 *              number              - Integer to be converted
 *              base                - Base of the integer
 *              upper               - Whether or not using upper cased digits
 *
 * RETURN:      Updated position for next valid character
 *
 * DESCRIPTION: Convert an integer into a string, note that, the string holds a
 *              reversed ordered number without the trailing zero.
 *
 ******************************************************************************/

static char *acpi_ut_put_number(char *string, u64 number, u8 base, u8 upper)
{
	const char *digits;
	u64 digit_index;
	char *pos;

	pos = string;
	digits = upper ? acpi_gbl_upper_hex_digits : acpi_gbl_lower_hex_digits;

	if (number == 0) {
		*(pos++) = '0';
	} else {
		while (number) {
			(void)acpi_ut_divide(number, base, &number,
					     &digit_index);
			*(pos++) = digits[digit_index];
		}
	}

	/* *(Pos++) = '0'; */
	return (pos);
}

/*******************************************************************************
 *
 * FUNCTION:    acpi_ut_scan_number
 *
 * PARAMETERS:  string              - String buffer
 *              number_ptr          - Where the number is returned
 *
 * RETURN:      Updated position for next valid character
 *
 * DESCRIPTION: Scan a string for a decimal integer.
 *
 ******************************************************************************/

const char *acpi_ut_scan_number(const char *string, u64 *number_ptr)
{
	u64 number = 0;

	while (isdigit((int)*string)) {
		number *= 10;
		number += *(string++) - '0';
	}

	*number_ptr = number;
	return (string);
}

/*******************************************************************************
 *
 * FUNCTION:    acpi_ut_print_number
 *
 * PARAMETERS:  string              - String buffer
 *              number              - The number to be converted
 *
 * RETURN:      Updated position for next valid character
 *
 * DESCRIPTION: Print a decimal integer into a string.
 *
 ******************************************************************************/

const char *acpi_ut_print_number(char *string, u64 number)
{
	char ascii_string[20];
	const char *pos1;
	char *pos2;

	pos1 = acpi_ut_put_number(ascii_string, number, 10, FALSE);
	pos2 = string;

	while (pos1 != ascii_string) {
		*(pos2++) = *(--pos1);
	}

	*pos2 = 0;
	return (string);
}

/*******************************************************************************
 *
 * FUNCTION:    acpi_ut_format_number
 *
 * PARAMETERS:  string              - String buffer with boundary
 *              end                 - Boundary of the string
 *              number              - The number to be converted
 *              base                - Base of the integer
 *              width               - Field width
 *              precision           - Precision of the integer
 *              type                - Special printing flags
 *
 * RETURN:      Updated position for next valid character
 *
 * DESCRIPTION: Print an integer into a string with any base and any precision.
 *
 ******************************************************************************/

static char *acpi_ut_format_number(char *string,
				   char *end,
				   u64 number,
				   u8 base, s32 width, s32 precision, u8 type)
{
	char *pos;
	char sign;
	char zero;
	u8 need_prefix;
	u8 upper;
	s32 i;
	char reversed_string[66];

	/* Parameter validation */

	if (base < 2 || base > 16) {
		return (NULL);
	}

	if (type & ACPI_FORMAT_LEFT) {
		type &= ~ACPI_FORMAT_ZERO;
	}

	need_prefix = ((type & ACPI_FORMAT_PREFIX)
		       && base != 10) ? TRUE : FALSE;
	upper = (type & ACPI_FORMAT_UPPER) ? TRUE : FALSE;
	zero = (type & ACPI_FORMAT_ZERO) ? '0' : ' ';

	/* Calculate size according to sign and prefix */

	sign = '\0';
	if (type & ACPI_FORMAT_SIGN) {
		if ((s64) number < 0) {
			sign = '-';
			number = -(s64) number;
			width--;
		} else if (type & ACPI_FORMAT_SIGN_PLUS) {
			sign = '+';
			width--;
		} else if (type & ACPI_FORMAT_SIGN_PLUS_SPACE) {
			sign = ' ';
			width--;
		}
	}
	if (need_prefix) {
		width--;
		if (base == 16) {
			width--;
		}
	}

	/* Generate full string in reverse order */

	pos = acpi_ut_put_number(reversed_string, number, base, upper);
	i = ACPI_PTR_DIFF(pos, reversed_string);

	/* Printing 100 using %2d gives "100", not "00" */

	if (i > precision) {
		precision = i;
	}

	width -= precision;

	/* Output the string */

	if (!(type & (ACPI_FORMAT_ZERO | ACPI_FORMAT_LEFT))) {
		while (--width >= 0) {
			string = acpi_ut_bound_string_output(string, end, ' ');
		}
	}
	if (sign) {
		string = acpi_ut_bound_string_output(string, end, sign);
	}
	if (need_prefix) {
		string = acpi_ut_bound_string_output(string, end, '0');
		if (base == 16) {
			string = acpi_ut_bound_string_output(string, end,
							     upper ? 'X' : 'x');
		}
	}
	if (!(type & ACPI_FORMAT_LEFT)) {
		while (--width >= 0) {
			string = acpi_ut_bound_string_output(string, end, zero);
		}
	}

	while (i <= --precision) {
		string = acpi_ut_bound_string_output(string, end, '0');
	}
	while (--i >= 0) {
		string = acpi_ut_bound_string_output(string, end,
						     reversed_string[i]);
	}
	while (--width >= 0) {
		string = acpi_ut_bound_string_output(string, end, ' ');
	}

	return (string);
}

/*******************************************************************************
 *
 * FUNCTION:    acpi_ut_vsnprintf
 *
 * PARAMETERS:  string              - String with boundary
 *              size                - Boundary of the string
 *              format              - Standard printf format
 *              args                - Argument list
 *
 * RETURN:      Number of bytes actually written.
 *
 * DESCRIPTION: Formatted output to a string using argument list pointer.
 *
 ******************************************************************************/

int
acpi_ut_vsnprintf(char *string,
		  acpi_size size, const char *format, va_list args)
{
	u8 base;
	u8 type;
	s32 width;
	s32 precision;
	char qualifier;
	u64 number;
	char *pos;
	char *end;
	char c;
	const char *s;
	const void *p;
	s32 length;
	int i;

	pos = string;
	end = string + size;

	for (; *format; ++format) {
		if (*format != '%') {
			pos = acpi_ut_bound_string_output(pos, end, *format);
			continue;
		}

		type = 0;
		base = 10;

		/* Process sign */

		do {
			++format;
			if (*format == '#') {
				type |= ACPI_FORMAT_PREFIX;
			} else if (*format == '0') {
				type |= ACPI_FORMAT_ZERO;
			} else if (*format == '+') {
				type |= ACPI_FORMAT_SIGN_PLUS;
			} else if (*format == ' ') {
				type |= ACPI_FORMAT_SIGN_PLUS_SPACE;
			} else if (*format == '-') {
				type |= ACPI_FORMAT_LEFT;
			} else {
				break;
			}
		} while (1);

		/* Process width */

		width = -1;
		if (isdigit((int)*format)) {
			format = acpi_ut_scan_number(format, &number);
			width = (s32) number;
		} else if (*format == '*') {
			++format;
			width = va_arg(args, int);
			if (width < 0) {
				width = -width;
				type |= ACPI_FORMAT_LEFT;
			}
		}

		/* Process precision */

		precision = -1;
		if (*format == '.') {
			++format;
			if (isdigit((int)*format)) {
				format = acpi_ut_scan_number(format, &number);
				precision = (s32) number;
			} else if (*format == '*') {
				++format;
				precision = va_arg(args, int);
			}
			if (precision < 0) {
				precision = 0;
			}
		}

		/* Process qualifier */

		qualifier = -1;
		if (*format == 'h' || *format == 'l' || *format == 'L') {
			qualifier = *format;
			++format;

			if (qualifier == 'l' && *format == 'l') {
				qualifier = 'L';
				++format;
			}
		}

		switch (*format) {
		case '%':

			pos = acpi_ut_bound_string_output(pos, end, '%');
			continue;

		case 'c':

			if (!(type & ACPI_FORMAT_LEFT)) {
				while (--width > 0) {
					pos =
					    acpi_ut_bound_string_output(pos,
									end,
									' ');
				}
			}

			c = (char)va_arg(args, int);
			pos = acpi_ut_bound_string_output(pos, end, c);

			while (--width > 0) {
				pos =
				    acpi_ut_bound_string_output(pos, end, ' ');
			}
			continue;

		case 's':

			s = va_arg(args, char *);
			if (!s) {
				s = "<NULL>";
			}
			length = acpi_ut_bound_string_length(s, precision);
			if (!(type & ACPI_FORMAT_LEFT)) {
				while (length < width--) {
					pos =
					    acpi_ut_bound_string_output(pos,
									end,
									' ');
				}
			}
			for (i = 0; i < length; ++i) {
				pos = acpi_ut_bound_string_output(pos, end, *s);
				++s;
			}
			while (length < width--) {
				pos =
				    acpi_ut_bound_string_output(pos, end, ' ');
			}
			continue;

		case 'o':

			base = 8;
			break;

		case 'X':

			type |= ACPI_FORMAT_UPPER;

		case 'x':

			base = 16;
			break;

		case 'd':
		case 'i':

			type |= ACPI_FORMAT_SIGN;

		case 'u':

			break;

		case 'p':

			if (width == -1) {
				width = 2 * sizeof(void *);
				type |= ACPI_FORMAT_ZERO;
			}

			p = va_arg(args, void *);
			pos = acpi_ut_format_number(pos, end,
						    ACPI_TO_INTEGER(p), 16,
						    width, precision, type);
			continue;

		default:

			pos = acpi_ut_bound_string_output(pos, end, '%');
			if (*format) {
				pos =
				    acpi_ut_bound_string_output(pos, end,
								*format);
			} else {
				--format;
			}
			continue;
		}

		if (qualifier == 'L') {
			number = va_arg(args, u64);
			if (type & ACPI_FORMAT_SIGN) {
				number = (s64) number;
			}
		} else if (qualifier == 'l') {
			number = va_arg(args, unsigned long);
			if (type & ACPI_FORMAT_SIGN) {
				number = (s32) number;
			}
		} else if (qualifier == 'h') {
			number = (u16)va_arg(args, int);
			if (type & ACPI_FORMAT_SIGN) {
				number = (s16) number;
			}
		} else {
			number = va_arg(args, unsigned int);
			if (type & ACPI_FORMAT_SIGN) {
				number = (signed int)number;
			}
		}

		pos = acpi_ut_format_number(pos, end, number, base,
					    width, precision, type);
	}

	if (size > 0) {
		if (pos < end) {
			*pos = '\0';
		} else {
			end[-1] = '\0';
		}
	}

	return (ACPI_PTR_DIFF(pos, string));
}

/*******************************************************************************
 *
 * FUNCTION:    acpi_ut_snprintf
 *
 * PARAMETERS:  string              - String with boundary
 *              size                - Boundary of the string
 *              Format, ...         - Standard printf format
 *
 * RETURN:      Number of bytes actually written.
 *
 * DESCRIPTION: Formatted output to a string.
 *
 ******************************************************************************/

int acpi_ut_snprintf(char *string, acpi_size size, const char *format, ...)
{
	va_list args;
	int length;

	va_start(args, format);
	length = acpi_ut_vsnprintf(string, size, format, args);
	va_end(args);

	return (length);
}

#ifdef ACPI_APPLICATION
/*******************************************************************************
 *
 * FUNCTION:    acpi_ut_file_vprintf
 *
 * PARAMETERS:  file                - File descriptor
 *              format              - Standard printf format
 *              args                - Argument list
 *
 * RETURN:      Number of bytes actually written.
 *
 * DESCRIPTION: Formatted output to a file using argument list pointer.
 *
 ******************************************************************************/

int acpi_ut_file_vprintf(ACPI_FILE file, const char *format, va_list args)
{
	acpi_cpu_flags flags;
	int length;

	flags = acpi_os_acquire_lock(acpi_gbl_print_lock);
	length = acpi_ut_vsnprintf(acpi_gbl_print_buffer,
				   sizeof(acpi_gbl_print_buffer), format, args);

	(void)acpi_os_write_file(file, acpi_gbl_print_buffer, length, 1);
	acpi_os_release_lock(acpi_gbl_print_lock, flags);

	return (length);
}

/*******************************************************************************
 *
 * FUNCTION:    acpi_ut_file_printf
 *
 * PARAMETERS:  file                - File descriptor
 *              Format, ...         - Standard printf format
 *
 * RETURN:      Number of bytes actually written.
 *
 * DESCRIPTION: Formatted output to a file.
 *
 ******************************************************************************/

int acpi_ut_file_printf(ACPI_FILE file, const char *format, ...)
{
	va_list args;
	int length;

	va_start(args, format);
	length = acpi_ut_file_vprintf(file, format, args);
	va_end(args);

	return (length);
}
#endif
Commit	Line	Data
80a648c1 LZ	1	/******************************************************************************
	2	*
	3	* Module Name: utprint - Formatted printing routines
	4	*
	5	*****************************************************************************/
	6
	7	/*
82a80941	8	* Copyright (C) 2000 - 2015, Intel Corp.
80a648c1 LZ	9	* All rights reserved.
	10	*
	11	* Redistribution and use in source and binary forms, with or without
	12	* modification, are permitted provided that the following conditions
	13	* are met:
	14	* 1. Redistributions of source code must retain the above copyright
	15	* notice, this list of conditions, and the following disclaimer,
	16	* without modification.
	17	* 2. Redistributions in binary form must reproduce at minimum a disclaimer
	18	* substantially similar to the "NO WARRANTY" disclaimer below
	19	* ("Disclaimer") and any redistribution must be conditioned upon
	20	* including a substantially similar Disclaimer requirement for further
	21	* binary redistribution.
	22	* 3. Neither the names of the above-listed copyright holders nor the names
	23	* of any contributors may be used to endorse or promote products derived
	24	* from this software without specific prior written permission.
	25	*
	26	* Alternatively, this software may be distributed under the terms of the
	27	* GNU General Public License ("GPL") version 2 as published by the Free
	28	* Software Foundation.
	29	*
	30	* NO WARRANTY
	31	* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
	32	* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
	33	* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
	34	* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
	35	* HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
	36	* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
	37	* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
	38	* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
	39	* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
	40	* IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
	41	* POSSIBILITY OF SUCH DAMAGES.
	42	*/
	43
	44	#include <acpi/acpi.h>
	45	#include "accommon.h"
	46
	47	#define _COMPONENT ACPI_UTILITIES
	48	ACPI_MODULE_NAME("utprint")
	49
	50	#define ACPI_FORMAT_SIGN 0x01
	51	#define ACPI_FORMAT_SIGN_PLUS 0x02
	52	#define ACPI_FORMAT_SIGN_PLUS_SPACE 0x04
	53	#define ACPI_FORMAT_ZERO 0x08
	54	#define ACPI_FORMAT_LEFT 0x10
	55	#define ACPI_FORMAT_UPPER 0x20
	56	#define ACPI_FORMAT_PREFIX 0x40
	57	/* Local prototypes */
	58	static acpi_size
	59	acpi_ut_bound_string_length(const char *string, acpi_size count);
	60
	61	static char acpi_ut_bound_string_output(char string, const char *end, char c);
	62
	63	static char acpi_ut_format_number(char string,
	64	char *end,
	65	u64 number,
	66	u8 base, s32 width, s32 precision, u8 type);
	67
	68	static char acpi_ut_put_number(char string, u64 number, u8 base, u8 upper);
	69
ff2389fe BM	70	/* Module globals */
	71
	72	static const char acpi_gbl_lower_hex_digits[] = "0123456789abcdef";
	73	static const char acpi_gbl_upper_hex_digits[] = "0123456789ABCDEF";
	74
80a648c1 LZ	75	/*******************************************************************************
	76	*
	77	* FUNCTION: acpi_ut_bound_string_length
	78	*
	79	* PARAMETERS: string - String with boundary
	80	* count - Boundary of the string
	81	*
ff2389fe	82	* RETURN: Length of the string. Less than or equal to Count.
80a648c1 LZ	83	*
	84	* DESCRIPTION: Calculate the length of a string with boundary.
	85	*
	86	******************************************************************************/
	87
	88	static acpi_size
	89	acpi_ut_bound_string_length(const char *string, acpi_size count)
	90	{
	91	u32 length = 0;
	92
	93	while (*string && count) {
	94	length++;
	95	string++;
	96	count--;
	97	}
	98
	99	return (length);
	100	}
	101
	102	/*******************************************************************************
	103	*
	104	* FUNCTION: acpi_ut_bound_string_output
	105	*
	106	* PARAMETERS: string - String with boundary
	107	* end - Boundary of the string
	108	* c - Character to be output to the string
	109	*
	110	* RETURN: Updated position for next valid character
	111	*
	112	* DESCRIPTION: Output a character into a string with boundary check.
	113	*
	114	******************************************************************************/
	115
	116	static char acpi_ut_bound_string_output(char string, const char *end, char c)
	117	{
	118
	119	if (string < end) {
	120	*string = c;
	121	}
80a648c1	122
ff2389fe	123	++string;
80a648c1 LZ	124	return (string);
	125	}
	126
	127	/*******************************************************************************
	128	*
	129	* FUNCTION: acpi_ut_put_number
	130	*
	131	* PARAMETERS: string - Buffer to hold reverse-ordered string
	132	* number - Integer to be converted
	133	* base - Base of the integer
	134	* upper - Whether or not using upper cased digits
	135	*
	136	* RETURN: Updated position for next valid character
	137	*
	138	* DESCRIPTION: Convert an integer into a string, note that, the string holds a
	139	* reversed ordered number without the trailing zero.
	140	*
	141	******************************************************************************/
	142
	143	static char acpi_ut_put_number(char string, u64 number, u8 base, u8 upper)
	144	{
80a648c1 LZ	145	const char *digits;
	146	u64 digit_index;
	147	char *pos;
	148
	149	pos = string;
ff2389fe	150	digits = upper ? acpi_gbl_upper_hex_digits : acpi_gbl_lower_hex_digits;
80a648c1 LZ	151
	152	if (number == 0) {
	153	*(pos++) = '0';
	154	} else {
	155	while (number) {
	156	(void)acpi_ut_divide(number, base, &number,
	157	&digit_index);
	158	*(pos++) = digits[digit_index];
	159	}
	160	}
80a648c1	161
ff2389fe	162	/* (Pos++) = '0'; /
80a648c1 LZ	163	return (pos);
	164	}
	165
	166	/*******************************************************************************
	167	*
	168	* FUNCTION: acpi_ut_scan_number
	169	*
	170	* PARAMETERS: string - String buffer
	171	* number_ptr - Where the number is returned
	172	*
	173	* RETURN: Updated position for next valid character
	174	*
	175	* DESCRIPTION: Scan a string for a decimal integer.
	176	*
	177	******************************************************************************/
	178
	179	const char acpi_ut_scan_number(const char string, u64 *number_ptr)
	180	{
	181	u64 number = 0;
	182
4fa4616e	183	while (isdigit((int)*string)) {
80a648c1 LZ	184	number *= 10;
	185	number += *(string++) - '0';
	186	}
80a648c1	187
ff2389fe	188	*number_ptr = number;
80a648c1 LZ	189	return (string);
	190	}
	191
	192	/*******************************************************************************
	193	*
	194	* FUNCTION: acpi_ut_print_number
	195	*
	196	* PARAMETERS: string - String buffer
	197	* number - The number to be converted
	198	*
	199	* RETURN: Updated position for next valid character
	200	*
	201	* DESCRIPTION: Print a decimal integer into a string.
	202	*
	203	******************************************************************************/
	204
	205	const char acpi_ut_print_number(char string, u64 number)
	206	{
	207	char ascii_string[20];
	208	const char *pos1;
	209	char *pos2;
	210
	211	pos1 = acpi_ut_put_number(ascii_string, number, 10, FALSE);
	212	pos2 = string;
	213
	214	while (pos1 != ascii_string) {
	215	(pos2++) = (--pos1);
	216	}
80a648c1	217
ff2389fe	218	*pos2 = 0;
80a648c1 LZ	219	return (string);
	220	}
	221
	222	/*******************************************************************************
	223	*
	224	* FUNCTION: acpi_ut_format_number
	225	*
	226	* PARAMETERS: string - String buffer with boundary
	227	* end - Boundary of the string
	228	* number - The number to be converted
	229	* base - Base of the integer
	230	* width - Field width
	231	* precision - Precision of the integer
	232	* type - Special printing flags
	233	*
	234	* RETURN: Updated position for next valid character
	235	*
	236	* DESCRIPTION: Print an integer into a string with any base and any precision.
	237	*
	238	******************************************************************************/
	239
	240	static char acpi_ut_format_number(char string,
	241	char *end,
	242	u64 number,
	243	u8 base, s32 width, s32 precision, u8 type)
	244	{
8884de6a	245	char *pos;
80a648c1 LZ	246	char sign;
	247	char zero;
	248	u8 need_prefix;
	249	u8 upper;
	250	s32 i;
	251	char reversed_string[66];
	252
ff2389fe	253	/* Parameter validation */
80a648c1 LZ	254
80a648c1 LZ	255	if (base < 2 \|\| base > 16) {
ff2389fe	256	return (NULL);
80a648c1	257	}
ff2389fe	258
80a648c1 LZ	259	if (type & ACPI_FORMAT_LEFT) {
	260	type &= ~ACPI_FORMAT_ZERO;
	261	}
	262
	263	need_prefix = ((type & ACPI_FORMAT_PREFIX)
	264	&& base != 10) ? TRUE : FALSE;
	265	upper = (type & ACPI_FORMAT_UPPER) ? TRUE : FALSE;
	266	zero = (type & ACPI_FORMAT_ZERO) ? '0' : ' ';
	267
	268	/* Calculate size according to sign and prefix */
	269
	270	sign = '\0';
	271	if (type & ACPI_FORMAT_SIGN) {
	272	if ((s64) number < 0) {
	273	sign = '-';
	274	number = -(s64) number;
	275	width--;
	276	} else if (type & ACPI_FORMAT_SIGN_PLUS) {
	277	sign = '+';
	278	width--;
	279	} else if (type & ACPI_FORMAT_SIGN_PLUS_SPACE) {
	280	sign = ' ';
	281	width--;
	282	}
	283	}
	284	if (need_prefix) {
	285	width--;
	286	if (base == 16) {
	287	width--;
	288	}
	289	}
	290
	291	/* Generate full string in reverse order */
	292
8884de6a BM	293	pos = acpi_ut_put_number(reversed_string, number, base, upper);
8884de6a BM	294	i = ACPI_PTR_DIFF(pos, reversed_string);
80a648c1 LZ	295
	296	/* Printing 100 using %2d gives "100", not "00" */
	297
	298	if (i > precision) {
	299	precision = i;
	300	}
ff2389fe	301
80a648c1 LZ	302	width -= precision;
	303
	304	/* Output the string */
	305
	306	if (!(type & (ACPI_FORMAT_ZERO \| ACPI_FORMAT_LEFT))) {
	307	while (--width >= 0) {
	308	string = acpi_ut_bound_string_output(string, end, ' ');
	309	}
	310	}
	311	if (sign) {
	312	string = acpi_ut_bound_string_output(string, end, sign);
	313	}
	314	if (need_prefix) {
	315	string = acpi_ut_bound_string_output(string, end, '0');
	316	if (base == 16) {
	317	string = acpi_ut_bound_string_output(string, end,
	318	upper ? 'X' : 'x');
	319	}
	320	}
	321	if (!(type & ACPI_FORMAT_LEFT)) {
	322	while (--width >= 0) {
	323	string = acpi_ut_bound_string_output(string, end, zero);
	324	}
	325	}
ff2389fe	326
80a648c1 LZ	327	while (i <= --precision) {
	328	string = acpi_ut_bound_string_output(string, end, '0');
	329	}
	330	while (--i >= 0) {
	331	string = acpi_ut_bound_string_output(string, end,
	332	reversed_string[i]);
	333	}
	334	while (--width >= 0) {
	335	string = acpi_ut_bound_string_output(string, end, ' ');
	336	}
	337
	338	return (string);
	339	}
	340
	341	/*******************************************************************************
	342	*
	343	* FUNCTION: acpi_ut_vsnprintf
	344	*
	345	* PARAMETERS: string - String with boundary
	346	* size - Boundary of the string
	347	* format - Standard printf format
	348	* args - Argument list
	349	*
ff2389fe	350	* RETURN: Number of bytes actually written.
80a648c1 LZ	351	*
	352	* DESCRIPTION: Formatted output to a string using argument list pointer.
	353	*
	354	******************************************************************************/
	355
	356	int
	357	acpi_ut_vsnprintf(char *string,
	358	acpi_size size, const char *format, va_list args)
	359	{
cef9aaa7 LZ	360	u8 base;
	361	u8 type;
	362	s32 width;
	363	s32 precision;
	364	char qualifier;
80a648c1 LZ	365	u64 number;
	366	char *pos;
	367	char *end;
	368	char c;
	369	const char *s;
	370	const void *p;
	371	s32 length;
	372	int i;
	373
	374	pos = string;
	375	end = string + size;
	376
	377	for (; *format; ++format) {
	378	if (*format != '%') {
	379	pos = acpi_ut_bound_string_output(pos, end, *format);
	380	continue;
	381	}
	382
cef9aaa7 LZ	383	type = 0;
	384	base = 10;
	385
80a648c1 LZ	386	/* Process sign */
	387
	388	do {
	389	++format;
	390	if (*format == '#') {
	391	type \|= ACPI_FORMAT_PREFIX;
	392	} else if (*format == '0') {
	393	type \|= ACPI_FORMAT_ZERO;
	394	} else if (*format == '+') {
	395	type \|= ACPI_FORMAT_SIGN_PLUS;
	396	} else if (*format == ' ') {
	397	type \|= ACPI_FORMAT_SIGN_PLUS_SPACE;
	398	} else if (*format == '-') {
	399	type \|= ACPI_FORMAT_LEFT;
	400	} else {
	401	break;
	402	}
	403	} while (1);
	404
	405	/* Process width */
	406
3589b8b8	407	width = -1;
4fa4616e	408	if (isdigit((int)*format)) {
80a648c1 LZ	409	format = acpi_ut_scan_number(format, &number);
	410	width = (s32) number;
	411	} else if (format == '') {
	412	++format;
	413	width = va_arg(args, int);
	414	if (width < 0) {
	415	width = -width;
	416	type \|= ACPI_FORMAT_LEFT;
	417	}
	418	}
	419
	420	/* Process precision */
	421
3589b8b8	422	precision = -1;
80a648c1 LZ	423	if (*format == '.') {
80a648c1 LZ	424	++format;
4fa4616e	425	if (isdigit((int)*format)) {
80a648c1 LZ	426	format = acpi_ut_scan_number(format, &number);
	427	precision = (s32) number;
	428	} else if (format == '') {
	429	++format;
	430	precision = va_arg(args, int);
	431	}
	432	if (precision < 0) {
	433	precision = 0;
	434	}
	435	}
	436
	437	/* Process qualifier */
	438
3589b8b8	439	qualifier = -1;
80a648c1 LZ	440	if (format == 'h' \|\| format == 'l' \|\| *format == 'L') {
	441	qualifier = *format;
	442	++format;
ff2389fe	443
80a648c1 LZ	444	if (qualifier == 'l' && *format == 'l') {
	445	qualifier = 'L';
	446	++format;
	447	}
	448	}
	449
	450	switch (*format) {
	451	case '%':
	452
	453	pos = acpi_ut_bound_string_output(pos, end, '%');
	454	continue;
	455
	456	case 'c':
	457
	458	if (!(type & ACPI_FORMAT_LEFT)) {
	459	while (--width > 0) {
	460	pos =
	461	acpi_ut_bound_string_output(pos,
	462	end,
	463	' ');
	464	}
	465	}
ff2389fe	466
80a648c1 LZ	467	c = (char)va_arg(args, int);
80a648c1 LZ	468	pos = acpi_ut_bound_string_output(pos, end, c);
ff2389fe	469
80a648c1 LZ	470	while (--width > 0) {
	471	pos =
	472	acpi_ut_bound_string_output(pos, end, ' ');
	473	}
	474	continue;
	475
	476	case 's':
	477
	478	s = va_arg(args, char *);
	479	if (!s) {
	480	s = "<NULL>";
	481	}
	482	length = acpi_ut_bound_string_length(s, precision);
	483	if (!(type & ACPI_FORMAT_LEFT)) {
	484	while (length < width--) {
	485	pos =
	486	acpi_ut_bound_string_output(pos,
	487	end,
	488	' ');
	489	}
	490	}
	491	for (i = 0; i < length; ++i) {
	492	pos = acpi_ut_bound_string_output(pos, end, *s);
	493	++s;
	494	}
	495	while (length < width--) {
	496	pos =
	497	acpi_ut_bound_string_output(pos, end, ' ');
	498	}
	499	continue;
	500
	501	case 'o':
	502
	503	base = 8;
	504	break;
	505
	506	case 'X':
	507
	508	type \|= ACPI_FORMAT_UPPER;
	509
	510	case 'x':
	511
	512	base = 16;
	513	break;
	514
	515	case 'd':
	516	case 'i':
	517
	518	type \|= ACPI_FORMAT_SIGN;
	519
	520	case 'u':
	521
	522	break;
	523
	524	case 'p':
	525
	526	if (width == -1) {
	527	width = 2 * sizeof(void *);
	528	type \|= ACPI_FORMAT_ZERO;
	529	}
ff2389fe	530
80a648c1 LZ	531	p = va_arg(args, void *);
80a648c1 LZ	532	pos = acpi_ut_format_number(pos, end,
ff2389fe BM	533	ACPI_TO_INTEGER(p), 16,
ff2389fe BM	534	width, precision, type);
80a648c1 LZ	535	continue;
	536
	537	default:
	538
	539	pos = acpi_ut_bound_string_output(pos, end, '%');
	540	if (*format) {
	541	pos =
	542	acpi_ut_bound_string_output(pos, end,
	543	*format);
	544	} else {
	545	--format;
	546	}
	547	continue;
	548	}
	549
	550	if (qualifier == 'L') {
	551	number = va_arg(args, u64);
	552	if (type & ACPI_FORMAT_SIGN) {
	553	number = (s64) number;
	554	}
	555	} else if (qualifier == 'l') {
	556	number = va_arg(args, unsigned long);
	557	if (type & ACPI_FORMAT_SIGN) {
	558	number = (s32) number;
	559	}
	560	} else if (qualifier == 'h') {
	561	number = (u16)va_arg(args, int);
	562	if (type & ACPI_FORMAT_SIGN) {
	563	number = (s16) number;
	564	}
	565	} else {
	566	number = va_arg(args, unsigned int);
	567	if (type & ACPI_FORMAT_SIGN) {
	568	number = (signed int)number;
	569	}
	570	}
ff2389fe	571
80a648c1 LZ	572	pos = acpi_ut_format_number(pos, end, number, base,
	573	width, precision, type);
	574	}
	575
	576	if (size > 0) {
	577	if (pos < end) {
	578	*pos = '\0';
	579	} else {
	580	end[-1] = '\0';
	581	}
	582	}
	583
	584	return (ACPI_PTR_DIFF(pos, string));
	585	}
	586
	587	/*******************************************************************************
	588	*
	589	* FUNCTION: acpi_ut_snprintf
	590	*
	591	* PARAMETERS: string - String with boundary
	592	* size - Boundary of the string
	593	* Format, ... - Standard printf format
	594	*
ff2389fe	595	* RETURN: Number of bytes actually written.
80a648c1 LZ	596	*
	597	* DESCRIPTION: Formatted output to a string.
	598	*
	599	******************************************************************************/
	600
	601	int acpi_ut_snprintf(char string, acpi_size size, const char format, ...)
	602	{
	603	va_list args;
	604	int length;
	605
	606	va_start(args, format);
	607	length = acpi_ut_vsnprintf(string, size, format, args);
	608	va_end(args);
	609
	610	return (length);
	611	}
	612
	613	#ifdef ACPI_APPLICATION
	614	/*******************************************************************************
	615	*
	616	* FUNCTION: acpi_ut_file_vprintf
	617	*
	618	* PARAMETERS: file - File descriptor
	619	* format - Standard printf format
	620	* args - Argument list
	621	*
ff2389fe	622	* RETURN: Number of bytes actually written.
80a648c1 LZ	623	*
	624	* DESCRIPTION: Formatted output to a file using argument list pointer.
	625	*
	626	******************************************************************************/
	627
	628	int acpi_ut_file_vprintf(ACPI_FILE file, const char *format, va_list args)
	629	{
	630	acpi_cpu_flags flags;
	631	int length;
	632
	633	flags = acpi_os_acquire_lock(acpi_gbl_print_lock);
	634	length = acpi_ut_vsnprintf(acpi_gbl_print_buffer,
	635	sizeof(acpi_gbl_print_buffer), format, args);
ff2389fe	636
80a648c1 LZ	637	(void)acpi_os_write_file(file, acpi_gbl_print_buffer, length, 1);
	638	acpi_os_release_lock(acpi_gbl_print_lock, flags);
	639
	640	return (length);
	641	}
	642
	643	/*******************************************************************************
	644	*
	645	* FUNCTION: acpi_ut_file_printf
	646	*
	647	* PARAMETERS: file - File descriptor
	648	* Format, ... - Standard printf format
	649	*
ff2389fe	650	* RETURN: Number of bytes actually written.
80a648c1 LZ	651	*
	652	* DESCRIPTION: Formatted output to a file.
	653	*
	654	******************************************************************************/
	655
	656	int acpi_ut_file_printf(ACPI_FILE file, const char *format, ...)
	657	{
	658	va_list args;
	659	int length;
	660
	661	va_start(args, format);
	662	length = acpi_ut_file_vprintf(file, format, args);
	663	va_end(args);
	664
	665	return (length);
	666	}
	667	#endif