Subversion Repositories Kolibri OS

/******************************************************************************

 *

 * 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 

#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 = "";

			}

			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