--- /dev/null
+/*
+ * This file is part of the libpayload project.
+ *
+ * It has originally been taken from the HelenOS project
+ * (http://www.helenos.eu), and slightly modified for our purposes.
+ *
+ * Copyright (C) 2001-2004 Jakub Jermar
+ * Copyright (C) 2006 Josef Cejka
+ * Copyright (C) 2008 Uwe Hermann <uwe@hermann-uwe.de>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ * derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, 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 DAMAGE.
+ */
+
+#include <libpayload.h>
+#include <stdarg.h>
+
+/** Structure for specifying output methods for different printf clones. */
+struct printf_spec {
+ /* Output function, returns count of printed characters or EOF. */
+ int (*write) (void *, size_t, void *);
+ /* Support data - output stream specification, its state, locks, ... */
+ void *data;
+};
+
+/** Show prefixes 0x or 0. */
+#define __PRINTF_FLAG_PREFIX 0x00000001
+/** Signed / unsigned number. */
+#define __PRINTF_FLAG_SIGNED 0x00000002
+/** Print leading zeroes. */
+#define __PRINTF_FLAG_ZEROPADDED 0x00000004
+/** Align to left. */
+#define __PRINTF_FLAG_LEFTALIGNED 0x00000010
+/** Always show + sign. */
+#define __PRINTF_FLAG_SHOWPLUS 0x00000020
+/** Print space instead of plus. */
+#define __PRINTF_FLAG_SPACESIGN 0x00000040
+/** Show big characters. */
+#define __PRINTF_FLAG_BIGCHARS 0x00000080
+/** Number has - sign. */
+#define __PRINTF_FLAG_NEGATIVE 0x00000100
+
+/**
+ * Buffer big enough for 64-bit number printed in base 2, sign, prefix and 0
+ * to terminate string (last one is only for better testing end of buffer by
+ * zero-filling subroutine).
+ */
+#define PRINT_NUMBER_BUFFER_SIZE (64 + 5)
+
+/** Enumeration of possible arguments types. */
+typedef enum {
+ PrintfQualifierByte = 0,
+ PrintfQualifierShort,
+ PrintfQualifierInt,
+ PrintfQualifierLong,
+ PrintfQualifierLongLong,
+ PrintfQualifierPointer,
+} qualifier_t;
+
+static char digits_small[] = "0123456789abcdef";
+static char digits_big[] = "0123456789ABCDEF";
+
+/**
+ * Print one or more characters without adding newline.
+ *
+ * @param buf Buffer of >= count bytesi size. NULL pointer is not allowed!
+ * @param count Number of characters to print.
+ * @param ps Output method and its data.
+ * @return Number of characters printed.
+ */
+static int printf_putnchars(const char *buf, size_t count,
+ struct printf_spec *ps)
+{
+ return ps->write((void *)buf, count, ps->data);
+}
+
+/**
+ * Print a string without adding a newline.
+ *
+ * @param str String to print.
+ * @param ps Write function specification and support data.
+ * @return Number of characters printed.
+ */
+static int printf_putstr(const char *str, struct printf_spec *ps)
+{
+ size_t count;
+
+ if (str == NULL) {
+ char *nullstr = "(NULL)";
+ return printf_putnchars(nullstr, strlen(nullstr), ps);
+ }
+
+ count = strlen(str);
+
+ return ps->write((void *)str, count, ps->data);
+}
+
+/**
+ * Print one character.
+ *
+ * @param c Character to be printed.
+ * @param ps Output method.
+ * @return Number of characters printed.
+ */
+static int printf_putchar(int c, struct printf_spec *ps)
+{
+ unsigned char ch = c;
+
+ return ps->write((void *)&ch, 1, ps->data);
+}
+
+/**
+ * Print one formatted character.
+ *
+ * @param c Character to print.
+ * @param width Width modifier.
+ * @param flags Flags that change the way the character is printed.
+ * @return Number of characters printed, negative value on failure.
+ */
+static int print_char(char c, int width, uint64_t flags, struct printf_spec *ps)
+{
+ int counter = 0;
+
+ if (!(flags & __PRINTF_FLAG_LEFTALIGNED)) {
+ while (--width > 0) {
+ if (printf_putchar(' ', ps) > 0)
+ ++counter;
+ }
+ }
+
+ if (printf_putchar(c, ps) > 0)
+ counter++;
+
+ while (--width > 0) {
+ if (printf_putchar(' ', ps) > 0)
+ ++counter;
+ }
+
+ return ++counter;
+}
+
+/**
+ * Print string.
+ *
+ * @param s String to be printed.
+ * @param width Width modifier.
+ * @param precision Precision modifier.
+ * @param flags Flags that modify the way the string is printed.
+ * @return Number of characters printed, negative value on failure.
+ */
+static int print_string(char *s, int width, unsigned int precision,
+ uint64_t flags, struct printf_spec *ps)
+{
+ int counter = 0, retval;
+ size_t size;
+
+ if (s == NULL)
+ return printf_putstr("(NULL)", ps);
+ size = strlen(s);
+ /* Print leading spaces. */
+ if (precision == 0)
+ precision = size;
+ width -= precision;
+
+ if (!(flags & __PRINTF_FLAG_LEFTALIGNED)) {
+ while (width-- > 0) {
+ if (printf_putchar(' ', ps) == 1)
+ counter++;
+ }
+ }
+
+ if ((retval = printf_putnchars(s, MIN(size, precision), ps)) < 0)
+ return -counter;
+ counter += retval;
+
+ while (width-- > 0) {
+ if (printf_putchar(' ', ps) == 1)
+ ++counter;
+ }
+
+ return counter;
+}
+
+/**
+ * Print a number in a given base.
+ *
+ * Print significant digits of a number in given base.
+ *
+ * @param num Number to print.
+ * @param widt Width modifier.h
+ * @param precision Precision modifier.
+ * @param base Base to print the number in (must be between 2 and 16).
+ * @param flags Flags that modify the way the number is printed.
+ * @return Number of characters printed.
+ */
+static int print_number(uint64_t num, int width, int precision, int base,
+ uint64_t flags, struct printf_spec *ps)
+{
+ char *digits = digits_small;
+ char d[PRINT_NUMBER_BUFFER_SIZE];
+ char *ptr = &d[PRINT_NUMBER_BUFFER_SIZE - 1];
+ int size = 0; /* Size of number with all prefixes and signs. */
+ int number_size; /* Size of plain number. */
+ char sgn;
+ int retval;
+ int counter = 0;
+
+ if (flags & __PRINTF_FLAG_BIGCHARS)
+ digits = digits_big;
+
+ *ptr-- = 0; /* Put zero at end of string. */
+
+ if (num == 0) {
+ *ptr-- = '0';
+ size++;
+ } else {
+ do {
+ *ptr-- = digits[num % base];
+ size++;
+ } while (num /= base);
+ }
+
+ number_size = size;
+
+ /*
+ * Collect the sum of all prefixes/signs/... to calculate padding and
+ * leading zeroes.
+ */
+ if (flags & __PRINTF_FLAG_PREFIX) {
+ switch (base) {
+ case 2: /* Binary formating is not standard, but useful. */
+ size += 2;
+ break;
+ case 8:
+ size++;
+ break;
+ case 16:
+ size += 2;
+ break;
+ }
+ }
+
+ sgn = 0;
+ if (flags & __PRINTF_FLAG_SIGNED) {
+ if (flags & __PRINTF_FLAG_NEGATIVE) {
+ sgn = '-';
+ size++;
+ } else if (flags & __PRINTF_FLAG_SHOWPLUS) {
+ sgn = '+';
+ size++;
+ } else if (flags & __PRINTF_FLAG_SPACESIGN) {
+ sgn = ' ';
+ size++;
+ }
+ }
+
+ if (flags & __PRINTF_FLAG_LEFTALIGNED)
+ flags &= ~__PRINTF_FLAG_ZEROPADDED;
+
+ /*
+ * If the number is leftaligned or precision is specified then
+ * zeropadding is ignored.
+ */
+ if (flags & __PRINTF_FLAG_ZEROPADDED) {
+ if ((precision == 0) && (width > size))
+ precision = width - size + number_size;
+ }
+
+ /* Print leading spaces. */
+ if (number_size > precision) {
+ /* Print the whole number not only a part. */
+ precision = number_size;
+ }
+
+ width -= precision + size - number_size;
+
+ if (!(flags & __PRINTF_FLAG_LEFTALIGNED)) {
+ while (width-- > 0) {
+ if (printf_putchar(' ', ps) == 1)
+ counter++;
+ }
+ }
+
+ /* Print sign. */
+ if (sgn) {
+ if (printf_putchar(sgn, ps) == 1)
+ counter++;
+ }
+
+ /* Print prefix. */
+ if (flags & __PRINTF_FLAG_PREFIX) {
+ switch (base) {
+ case 2: /* Binary formating is not standard, but useful. */
+ if (printf_putchar('0', ps) == 1)
+ counter++;
+ if (flags & __PRINTF_FLAG_BIGCHARS) {
+ if (printf_putchar('B', ps) == 1)
+ counter++;
+ } else {
+ if (printf_putchar('b', ps) == 1)
+ counter++;
+ }
+ break;
+ case 8:
+ if (printf_putchar('o', ps) == 1)
+ counter++;
+ break;
+ case 16:
+ if (printf_putchar('0', ps) == 1)
+ counter++;
+ if (flags & __PRINTF_FLAG_BIGCHARS) {
+ if (printf_putchar('X', ps) == 1)
+ counter++;
+ } else {
+ if (printf_putchar('x', ps) == 1)
+ counter++;
+ }
+ break;
+ }
+ }
+
+ /* Print leading zeroes. */
+ precision -= number_size;
+ while (precision-- > 0) {
+ if (printf_putchar('0', ps) == 1)
+ counter++;
+ }
+
+ /* Print number itself. */
+ if ((retval = printf_putstr(++ptr, ps)) > 0)
+ counter += retval;
+
+ /* Print ending spaces. */
+ while (width-- > 0) {
+ if (printf_putchar(' ', ps) == 1)
+ counter++;
+ }
+
+ return counter;
+}
+
+/** Print formatted string.
+ *
+ * Print string formatted according to the fmt parameter and variadic arguments.
+ * Each formatting directive must have the following form:
+ *
+ * \% [ FLAGS ] [ WIDTH ] [ .PRECISION ] [ TYPE ] CONVERSION
+ *
+ * FLAGS:@n
+ * - "#" Force to print prefix.For \%o conversion, the prefix is 0, for
+ * \%x and \%X prefixes are 0x and 0X and for conversion \%b the
+ * prefix is 0b.
+ *
+ * - "-" Align to left.
+ *
+ * - "+" Print positive sign just as negative.
+ *
+ * - " " If the printed number is positive and "+" flag is not set,
+ * print space in place of sign.
+ *
+ * - "0" Print 0 as padding instead of spaces. Zeroes are placed between
+ * sign and the rest of the number. This flag is ignored if "-"
+ * flag is specified.
+ *
+ * WIDTH:@n
+ * - Specify the minimal width of a printed argument. If it is bigger,
+ * width is ignored. If width is specified with a "*" character instead of
+ * number, width is taken from parameter list. And integer parameter is
+ * expected before parameter for processed conversion specification. If
+ * this value is negative its absolute value is taken and the "-" flag is
+ * set.
+ *
+ * PRECISION:@n
+ * - Value precision. For numbers it specifies minimum valid numbers.
+ * Smaller numbers are printed with leading zeroes. Bigger numbers are not
+ * affected. Strings with more than precision characters are cut off. Just
+ * as with width, an "*" can be used used instead of a number. An integer
+ * value is then expected in parameters. When both width and precision are
+ * specified using "*", the first parameter is used for width and the
+ * second one for precision.
+ *
+ * TYPE:@n
+ * - "hh" Signed or unsigned char.@n
+ * - "h" Signed or unsigned short.@n
+ * - "" Signed or unsigned int (default value).@n
+ * - "l" Signed or unsigned long int.@n
+ * - "ll" Signed or unsigned long long int.@n
+ *
+ *
+ * CONVERSION:@n
+ * - % Print percentile character itself.
+ *
+ * - c Print single character.
+ *
+ * - s Print zero terminated string. If a NULL value is passed as
+ * value, "(NULL)" is printed instead.
+ *
+ * - P, p Print value of a pointer. Void * value is expected and it is
+ * printed in hexadecimal notation with prefix (as with \%#X / \%#x
+ * for 32-bit or \%#X / \%#x for 64-bit long pointers).
+ *
+ * - b Print value as unsigned binary number. Prefix is not printed by
+ * default. (Nonstandard extension.)
+ *
+ * - o Print value as unsigned octal number. Prefix is not printed by
+ * default.
+ *
+ * - d, i Print signed decimal number. There is no difference between d
+ * and i conversion.
+ *
+ * - u Print unsigned decimal number.
+ *
+ * - X, x Print hexadecimal number with upper- or lower-case. Prefix is
+ * not printed by default.
+ *
+ * All other characters from fmt except the formatting directives are printed in
+ * verbatim.
+ *
+ * @param fmt Formatting NULL terminated string.
+ * @param ps TODO.
+ * @param ap TODO.
+ * @return Number of characters printed, negative value on failure.
+ */
+static int printf_core(const char *fmt, struct printf_spec *ps, va_list ap)
+{
+ int i = 0; /* Index of the currently processed char from fmt */
+ int j = 0; /* Index to the first not printed nonformating character */
+ int end;
+ int counter; /* Counter of printed characters */
+ int retval; /* Used to store return values from called functions */
+ char c;
+ qualifier_t qualifier; /* Type of argument */
+ int base; /* Base in which a numeric parameter will be printed */
+ uint64_t number; /* Argument value */
+ size_t size; /* Byte size of integer parameter */
+ int width, precision;
+ uint64_t flags;
+
+ counter = 0;
+
+ while ((c = fmt[i])) {
+ /* Control character. */
+ if (c == '%') {
+ /* Print common characters if any processed. */
+ if (i > j) {
+ if ((retval = printf_putnchars(&fmt[j],
+ (size_t) (i - j), ps)) < 0) {
+ counter = -counter;
+ goto out; /* Error */
+ }
+ counter += retval;
+ }
+
+ j = i;
+ /* Parse modifiers. */
+ flags = 0;
+ end = 0;
+
+ do {
+ ++i;
+ switch (c = fmt[i]) {
+ case '#':
+ flags |= __PRINTF_FLAG_PREFIX;
+ break;
+ case '-':
+ flags |= __PRINTF_FLAG_LEFTALIGNED;
+ break;
+ case '+':
+ flags |= __PRINTF_FLAG_SHOWPLUS;
+ break;
+ case ' ':
+ flags |= __PRINTF_FLAG_SPACESIGN;
+ break;
+ case '0':
+ flags |= __PRINTF_FLAG_ZEROPADDED;
+ break;
+ default:
+ end = 1;
+ };
+
+ } while (end == 0);
+
+ /* Width & '*' operator. */
+ width = 0;
+ if (isdigit(fmt[i])) {
+ while (isdigit(fmt[i])) {
+ width *= 10;
+ width += fmt[i++] - '0';
+ }
+ } else if (fmt[i] == '*') {
+ /* Get width value from argument list. */
+ i++;
+ width = (int)va_arg(ap, int);
+ if (width < 0) {
+ /* Negative width sets '-' flag. */
+ width *= -1;
+ flags |= __PRINTF_FLAG_LEFTALIGNED;
+ }
+ }
+
+ /* Precision and '*' operator. */
+ precision = 0;
+ if (fmt[i] == '.') {
+ ++i;
+ if (isdigit(fmt[i])) {
+ while (isdigit(fmt[i])) {
+ precision *= 10;
+ precision += fmt[i++] - '0';
+ }
+ } else if (fmt[i] == '*') {
+ /* Get precision from argument list. */
+ i++;
+ precision = (int)va_arg(ap, int);
+ /* Ignore negative precision. */
+ if (precision < 0)
+ precision = 0;
+ }
+ }
+
+ switch (fmt[i++]) {
+ /** @todo unimplemented qualifiers:
+ * t ptrdiff_t - ISO C 99
+ */
+ case 'h': /* char or short */
+ qualifier = PrintfQualifierShort;
+ if (fmt[i] == 'h') {
+ i++;
+ qualifier = PrintfQualifierByte;
+ }
+ break;
+ case 'l': /* long or long long */
+ qualifier = PrintfQualifierLong;
+ if (fmt[i] == 'l') {
+ i++;
+ qualifier = PrintfQualifierLongLong;
+ }
+ break;
+ default:
+ /* default type */
+ qualifier = PrintfQualifierInt;
+ --i;
+ }
+
+ base = 10;
+
+ switch (c = fmt[i]) {
+ /* String and character conversions */
+ case 's':
+ if ((retval = print_string(va_arg(ap, char *),
+ width, precision, flags, ps)) < 0) {
+ counter = -counter;
+ goto out;
+ };
+ counter += retval;
+ j = i + 1;
+ goto next_char;
+ case 'c':
+ c = va_arg(ap, unsigned int);
+ retval = print_char(c, width, flags, ps);
+ if (retval < 0) {
+ counter = -counter;
+ goto out;
+ };
+ counter += retval;
+ j = i + 1;
+ goto next_char;
+
+ /* Integer values */
+ case 'P': /* pointer */
+ flags |= __PRINTF_FLAG_BIGCHARS;
+ case 'p':
+ flags |= __PRINTF_FLAG_PREFIX;
+ base = 16;
+ qualifier = PrintfQualifierPointer;
+ break;
+ case 'b':
+ base = 2;
+ break;
+ case 'o':
+ base = 8;
+ break;
+ case 'd':
+ case 'i':
+ flags |= __PRINTF_FLAG_SIGNED;
+ case 'u':
+ break;
+ case 'X':
+ flags |= __PRINTF_FLAG_BIGCHARS;
+ case 'x':
+ base = 16;
+ break;
+ case '%': /* percentile itself */
+ j = i;
+ goto next_char;
+ default: /* Bad formatting */
+ /*
+ * Unknown format. Now, j is the index of '%'
+ * so we will print whole bad format sequence.
+ */
+ goto next_char;
+ }
+
+ /* Print integers. */
+ /* Print number. */
+ switch (qualifier) {
+ case PrintfQualifierByte:
+ size = sizeof(unsigned char);
+ number = (uint64_t) va_arg(ap, unsigned int);
+ break;
+ case PrintfQualifierShort:
+ size = sizeof(unsigned short);
+ number = (uint64_t) va_arg(ap, unsigned int);
+ break;
+ case PrintfQualifierInt:
+ size = sizeof(unsigned int);
+ number = (uint64_t) va_arg(ap, unsigned int);
+ break;
+ case PrintfQualifierLong:
+ size = sizeof(unsigned long);
+ number = (uint64_t) va_arg(ap, unsigned long);
+ break;
+ case PrintfQualifierLongLong:
+ size = sizeof(unsigned long long);
+ number = (uint64_t) va_arg(ap, unsigned long long);
+ break;
+ case PrintfQualifierPointer:
+ size = sizeof(void *);
+ number = (uint64_t) (unsigned long)va_arg(ap, void *);
+ break;
+ default: /* Unknown qualifier */
+ counter = -counter;
+ goto out;
+ }
+
+ if (flags & __PRINTF_FLAG_SIGNED) {
+ if (number & (0x1 << (size * 8 - 1))) {
+ flags |= __PRINTF_FLAG_NEGATIVE;
+
+ if (size == sizeof(uint64_t)) {
+ number = -((int64_t) number);
+ } else {
+ number = ~number;
+ number &= ~(0xFFFFFFFFFFFFFFFFll << (size * 8));
+ number++;
+ }
+ }
+ }
+
+ if ((retval = print_number(number, width, precision,
+ base, flags, ps)) < 0) {
+ counter = -counter;
+ goto out;
+ }
+
+ counter += retval;
+ j = i + 1;
+ }
+next_char:
+ ++i;
+ }
+
+ if (i > j) {
+ if ((retval = printf_putnchars(&fmt[j],
+ (u64) (i - j), ps)) < 0) {
+ counter = -counter;
+ goto out; /* Error */
+
+ }
+ counter += retval;
+ }
+
+out:
+ return counter;
+}
+
+int sprintf(char *str, const char *fmt, ...)
+{
+ int ret;
+ va_list args;
+
+ va_start(args, fmt);
+ ret = vsprintf(str, fmt, args);
+ va_end(args);
+
+ return ret;
+}
+
+struct vsnprintf_data {
+ size_t size; /* Total space for string */
+ size_t len; /* Count of currently used characters */
+ char *string; /* Destination string */
+};
+
+/**
+ * Write string to given buffer.
+ *
+ * Write at most data->size characters including trailing zero. According to
+ * C99, snprintf() has to return number of characters that would have been
+ * written if enough space had been available. Hence the return value is not
+ * number of really printed characters but size of the input string.
+ * Number of really used characters is stored in data->len.
+ *
+ * @param str Source string to print.
+ * @param count Size of source string.
+ * @param data Structure with destination string, counter of used space
+ * and total string size.
+ * @return Number of characters to print (not characters really printed!).
+ */
+static int vsnprintf_write(const char *str, size_t count,
+ struct vsnprintf_data *data)
+{
+ size_t i;
+
+ i = data->size - data->len;
+ if (i == 0)
+ return count;
+
+ /* We have only one free byte left in buffer => write trailing zero. */
+ if (i == 1) {
+ data->string[data->size - 1] = 0;
+ data->len = data->size;
+ return count;
+ }
+
+ /*
+ * We have not enough space for whole string with the trailing
+ * zero => print only a part of string.
+ */
+ if (i <= count) {
+ memcpy((void *)(data->string + data->len), (void *)str, i - 1);
+ data->string[data->size - 1] = 0;
+ data->len = data->size;
+ return count;
+ }
+
+ /* Buffer is big enough to print whole string. */
+ memcpy((void *)(data->string + data->len), (void *)str, count);
+ data->len += count;
+ /*
+ * Put trailing zero at end, but not count it into data->len so
+ * it could be rewritten next time.
+ */
+ data->string[data->len] = 0;
+
+ return count;
+}
+
+int vsnprintf(char *str, size_t size, const char *fmt, va_list ap)
+{
+ struct vsnprintf_data data = { size, 0, str };
+ struct printf_spec ps =
+ { (int (*)(void *, size_t, void *))vsnprintf_write, &data };
+
+ /* Print 0 at end of string - fix case that nothing will be printed. */
+ if (size > 0)
+ str[0] = 0;
+
+ /* vsnprintf_write() ensures that str will be terminated by zero. */
+ return printf_core(fmt, &ps, ap);
+}
+
+int vsprintf(char *str, const char *fmt, va_list ap)
+{
+ return vsnprintf(str, (size_t) - 1, fmt, ap);
+}
+
+int printf(const char *fmt, ...)
+{
+ int ret;
+ va_list args;
+
+ va_start(args, fmt);
+ ret = vprintf(fmt, args);
+ va_end(args);
+
+ return ret;
+}
+
+static int vprintf_write(const char *str, size_t count, void *unused)
+{
+ size_t i;
+
+ for (i = 0; i < count; i++)
+ putchar(str[i]);
+
+ return i;
+}
+
+int vprintf(const char *fmt, va_list ap)
+{
+ struct printf_spec ps =
+ { (int (*)(void *, size_t, void *))vprintf_write, NULL };
+
+ return printf_core(fmt, &ps, ap);
+}
projects / coreboot.git / blobdiff