sdk/lib/stdio/printf.cc - 3p/cheriot-rtos - Git at Google

 /*-
  * Copyright (c) 1986, 1988, 1991, 1993
  *	The Regents of the University of California.  All rights reserved.
  * (c) UNIX System Laboratories, Inc.
  * All or some portions of this file are derived from material licensed
  * to the University of California by American Telephone and Telegraph
  * Co. or Unix System Laboratories, Inc. and are reproduced herein with
  * the permission of UNIX System Laboratories, Inc.
  *
  * 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.
  * 2. 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.
  * 4. Neither the name of the University nor the names of its contributors
  *    may be used to endorse or promote products derived from this software
  *    without specific prior written permission.
  *
  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``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 REGENTS OR CONTRIBUTORS 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.
  *
  *	@(#)subr_prf.c	8.3 (Berkeley) 1/21/94
  */

 /* __FBSDID("$FreeBSD: stable/8/sys/kern/subr_prf.c 210305 2010-07-20 18:55:13Z
  * jkim $"); */

 #include <cdefs.h>
 #include <cheri-builtins.h>
 #include <compartment.h>
 #include <cstdint>
 #include <function_wrapper.hh>
 #include <inttypes.h>
 #include <platform-uart.hh>
 #include <stdarg.h>
 #include <stdio.h>
 #include <string.h>

 /*
  * Definitions snarfed from various parts of the FreeBSD headers:
  */
 namespace
 {
 	__always_inline char toupper(char c)
 	{
 		return ((c)-0x20 * (((c) >= 'a') && ((c) <= 'z')));
 	}

 	static char hex2ascii(uintmax_t in)
 	{
 		return (in < 10) ? '0' + in : 'a' + in - 10;
 	}

 /* Max number conversion buffer length: a u_quad_t in base 2, plus NUL byte. */
 #define MAXNBUF (sizeof(intmax_t) * CHAR_BIT + 1)

 	/*
 	 * Put a NUL-terminated ASCII number (base <= 36) in a buffer in reverse
 	 * order; return an optional length and a pointer to the last character
 	 * written in the buffer (i.e., the first character of the string).
 	 * The buffer pointed to by `nbuf' must have length >= MAXNBUF.
 	 */
 	// FIXME: Using `unsigned` for `num` instead of `uintmax_t` means that we
 	// are going to truncate large numbers, but it avoids needing a library
 	// routine to handle division.
 	static char *
 	ksprintn(char *nbuf, unsigned num, int base, int *lenp, int upper)
 	{
 		char *p, c;

 		p  = nbuf;
 		*p = '\0';
 		do
 		{
 			c    = hex2ascii(num % base);
 			*++p = upper ? toupper(c) : c;
 		} while (num /= base);
 		if (lenp)
 		{
 			*lenp = p - nbuf;
 		}
 		return (p);
 	}

 	/*
 	 * Scaled down version of printf(3).
 	 *
 	 * Two additional formats:
 	 *
 	 * The format %b is supported to decode error registers.
 	 * Its usage is:
 	 *
 	 *	printf("reg=%b\n", regval, "<base><arg>*");
 	 *
 	 * where <base> is the output base expressed as a control character, e.g.
 	 * \10 gives octal; \20 gives hex.  Each arg is a sequence of characters,
 	 * the first of which gives the bit number to be inspected (origin 1), and
 	 * the next characters (up to a control character, i.e. a character <= 32),
 	 * give the name of the register.  Thus:
 	 *
 	 *	kvprintf("reg=%b\n", 3, "\10\2BITTWO\1BITONE\n");
 	 *
 	 * would produce output:
 	 *
 	 *	reg=3<BITTWO,BITONE>
 	 *
 	 * %D  -- Hexdump, takes pointer and separator string:
 	 *		("%6D", ptr, ":")   -> XX:XX:XX:XX:XX:XX
 	 *		("%*D", len, ptr, " " -> XX XX XX XX ...
 	 */
 	__noinline int kvprintf(char const                *fmt,
 	                        FunctionWrapper<void(int)> func,
 	                        void                      *arg,
 	                        int                        radix,
 	                        va_list                    ap)
 	{
 		char           nbuf[MAXNBUF];
 		const char    *p, *percent, *q;
 		unsigned char *up;
 		int            ch, n;
 		uintmax_t      num;
 		int  base, lflag, qflag, tmp, width, ladjust, sharpflag, neg, sign, dot;
 		int  cflag, hflag, jflag, tflag, zflag;
 		int  dwidth, upper;
 		char padc;
 		int  stop = 0, retval = 0;
 		const char *emptyString = "";

 		auto putchar = [&](int c) {
 			func(c);
 			retval++;
 		};

 		if (fmt == nullptr)
 		{
 			fmt = emptyString;
 		}

 		if (radix < 2 || radix > 36)
 		{
 			radix = 10;
 		}

 		for (;;)
 		{
 			padc  = ' ';
 			width = 0;
 			while ((ch = static_cast<unsigned char>(*fmt++)) != '%' || stop)
 			{
 				if (ch == '\0')
 				{
 					return (retval);
 				}
 				putchar(ch);
 			}
 			percent   = fmt - 1;
 			qflag     = 0;
 			lflag     = 0;
 			ladjust   = 0;
 			sharpflag = 0;
 			neg       = 0;
 			sign      = 0;
 			dot       = 0;
 			dwidth    = 0;
 			upper     = 0;
 			cflag     = 0;
 			hflag     = 0;
 			jflag     = 0;
 			tflag     = 0;
 			zflag     = 0;
 		reswitch:
 			switch (ch = static_cast<unsigned char>(*fmt++))
 			{
 				case '.':
 					dot = 1;
 					goto reswitch; // NOLINT
 				case '#':
 					sharpflag = 1;
 					goto reswitch; // NOLINT
 				case '+':
 					sign = 1;
 					goto reswitch; // NOLINT
 				case '-':
 					ladjust = 1;
 					goto reswitch; // NOLINT
 				case '%':
 					putchar(ch);
 					break;
 				case '*':
 					if (!dot)
 					{
 						width = va_arg(ap, int);
 						if (width < 0)
 						{
 							ladjust = !ladjust;
 							width   = -width;
 						}
 					}
 					else
 					{
 						dwidth = va_arg(ap, int);
 					}
 					goto reswitch; // NOLINT
 				case '0':
 					if (!dot)
 					{
 						padc = '0';
 						goto reswitch; // NOLINT
 					}
 				case '1':
 				case '2':
 				case '3':
 				case '4':
 				case '5':
 				case '6':
 				case '7':
 				case '8':
 				case '9':
 					for (n = 0;; ++fmt)
 					{
 						n  = n * 10 + ch - '0';
 						ch = *fmt;
 						if (ch < '0' || ch > '9')
 						{
 							break;
 						}
 					}
 					if (dot)
 					{
 						dwidth = n;
 					}
 					else
 					{
 						width = n;
 					}
 					goto reswitch; // NOLINT
 				case 'b':
 					num = static_cast<unsigned int>(va_arg(ap, int));
 					p   = va_arg(ap, char *);
 					for (q = ksprintn(nbuf, num, *p++, nullptr, 0); *q;)
 					{
 						putchar(*q--);
 					}

 					if (num == 0)
 					{
 						break;
 					}

 					for (tmp = 0; *p;)
 					{
 						n = *p++;
 						if (num & (1 << (n - 1)))
 						{
 							putchar(tmp ? ',' : '<');
 							for (; (n = *p) > ' '; ++p)
 							{
 								putchar(n);
 							}
 							tmp = 1;
 						}
 						else
 						{
 							for (; *p > ' '; ++p)
 							{
 								continue;
 							}
 						}
 					}
 					if (tmp)
 					{
 						putchar('>');
 					}
 					break;
 				case 'c':
 					putchar(va_arg(ap, int));
 					break;
 				case 'D':
 					up = va_arg(ap, unsigned char *);
 					p  = va_arg(ap, char *);
 					if (!width)
 					{
 						width = 16;
 					}
 					while (width--)
 					{
 						putchar(hex2ascii(*up >> 4));
 						putchar(hex2ascii(*up & 0x0f));
 						up++;
 						if (width)
 						{
 							for (q = p; *q; q++)
 							{
 								putchar(*q);
 							}
 						}
 					}
 					break;
 				case 'd':
 				case 'i':
 					base = 10;
 					sign = 1;
 					goto handle_sign; // NOLINT
 				case 'h':
 					if (hflag)
 					{
 						hflag = 0;
 						cflag = 1;
 					}
 					else
 					{
 						hflag = 1;
 					}
 					goto reswitch; // NOLINT
 				case 'j':
 					jflag = 1;
 					goto reswitch; // NOLINT
 				case 'l':
 					if (lflag)
 					{
 						lflag = 0;
 						qflag = 1;
 					}
 					else
 					{
 						lflag = 1;
 					}
 					goto reswitch; // NOLINT
 				case 'n':
 					if (jflag)
 					{
 						*(va_arg(ap, intmax_t *)) = retval;
 					}
 					else if (qflag)
 					{
 						*(va_arg(ap, long long *)) = retval;
 					}
 					else if (lflag)
 					{
 						*(va_arg(ap, long *)) = retval;
 					}
 					else if (zflag)
 					{
 						*(va_arg(ap, size_t *)) = retval;
 					}
 					else if (hflag)
 					{
 						*(va_arg(ap, short *)) = static_cast<short>(retval);
 					}
 					else if (cflag)
 					{
 						*(va_arg(ap, char *)) = retval;
 					}
 					else
 					{
 						*(va_arg(ap, int *)) = retval;
 					}
 					break;
 				case 'o':
 					base = 8;
 					goto handle_nosign; // NOLINT
 				case 'p':
 					base      = 16;
 					sharpflag = (width == 0);
 					sign      = 0;
 					num       = static_cast<size_t>(
                       reinterpret_cast<uintptr_t>(va_arg(ap, void *)));
 					goto number; // NOLINT
 				case 'q':
 					qflag = 1;
 					goto reswitch; // NOLINT
 				case 'r':
 					base = radix;
 					if (sign)
 					{
 						goto handle_sign; // NOLINT
 					}
 					goto handle_nosign; // NOLINT
 				case 's':
 					p = va_arg(ap, char *);
 					if (p == nullptr)
 					{
 						p = emptyString;
 					}
 					if (!dot)
 					{
 						n = strlen(p);
 					}
 					else
 					{
 						for (n = 0; n < dwidth && p[n]; n++)
 						{
 							continue;
 						}
 					}

 					width -= n;

 					if (!ladjust && width > 0)
 					{
 						while (width--)
 						{
 							putchar(padc);
 						}
 					}
 					while (n--)
 					{
 						putchar(*p++);
 					}
 					if (ladjust && width > 0)
 					{
 						while (width--)
 						{
 							putchar(padc);
 						}
 					}
 					break;
 				case 't':
 					tflag = 1;
 					goto reswitch; // NOLINT
 				case 'u':
 					base = 10;
 					goto handle_nosign; // NOLINT
 				case 'X':
 					upper = 1;
 				case 'x':
 					base = 16;
 					goto handle_nosign; // NOLINT
 				case 'y':
 					base = 16;
 					sign = 1;
 					goto handle_sign; // NOLINT
 				case 'z':
 					zflag = 1;
 					goto reswitch; // NOLINT
 				handle_nosign:
 					sign = 0;
 					if (jflag)
 					{
 						num = va_arg(ap, uintmax_t);
 					}
 					else if (qflag)
 					{
 						num = va_arg(ap, unsigned long long);
 					}
 					else if (tflag)
 					{
 						num = va_arg(ap, ptrdiff_t);
 					}
 					else if (lflag)
 					{
 						num = va_arg(ap, unsigned long);
 					}
 					else if (zflag)
 					{
 						num = va_arg(ap, size_t);
 					}
 					else if (hflag)
 					{
 						num = static_cast<unsigned short>(va_arg(ap, int));
 					}
 					else if (cflag)
 					{
 						num = static_cast<unsigned char>(va_arg(ap, int));
 					}
 					else
 					{
 						num = va_arg(ap, unsigned int);
 					}
 					goto number; // NOLINT
 				handle_sign:
 					if (jflag)
 					{
 						num = va_arg(ap, intmax_t);
 					}
 					else if (qflag)
 					{
 						num = va_arg(ap, long long);
 					}
 					else if (tflag)
 					{
 						num = va_arg(ap, ptrdiff_t);
 					}
 					else if (lflag)
 					{
 						num = va_arg(ap, long);
 					}
 					else if (zflag)
 					{
 						num = va_arg(ap, ssize_t);
 					}
 					else if (hflag)
 					{
 						num = static_cast<short>(va_arg(ap, int));
 					}
 					else if (cflag)
 					{
 						num = static_cast<char>(va_arg(ap, int));
 					}
 					else
 					{
 						num = va_arg(ap, int);
 					}
 				number:
 					if (sign && static_cast<intmax_t>(num) < 0)
 					{
 						neg = 1;
 						num = -static_cast<intmax_t>(num);
 					}
 					p   = ksprintn(nbuf, num, base, &n, upper);
 					tmp = 0;
 					if (sharpflag && num != 0)
 					{
 						if (base == 8)
 						{
 							tmp++;
 						}
 						else if (base == 16)
 						{
 							tmp += 2;
 						}
 					}
 					if (neg)
 					{
 						tmp++;
 					}

 					if (!ladjust && padc == '0')
 					{
 						dwidth = width - tmp;
 					}
 					width -= tmp + (dwidth > n ? dwidth : n);
 					dwidth -= n;
 					if (!ladjust)
 					{
 						while (width-- > 0)
 						{
 							putchar(' ');
 						}
 					}
 					if (neg)
 					{
 						putchar('-');
 					}
 					if (sharpflag && num != 0)
 					{
 						if (base == 8)
 						{
 							putchar('0');
 						}
 						else if (base == 16)
 						{
 							putchar('0');
 							putchar('x');
 						}
 					}
 					while (dwidth-- > 0)
 					{
 						putchar('0');
 					}

 					while (*p)
 					{
 						putchar(*p--);
 					}

 					if (ladjust)
 					{
 						while (width-- > 0)
 						{
 							putchar(' ');
 						}
 					}

 					break;
 				default:
 					while (percent < fmt)
 					{
 						putchar(*percent++);
 					}
 					/*
 					 * Since we ignore an formatting argument it is no
 					 * longer safe to obey the remaining formatting
 					 * arguments as the arguments will no longer match
 					 * the format specs.
 					 */
 					stop = 1;
 					break;
 			}
 		}
 	}

 } // namespace

 /*
  * Scaled down version of vsnprintf(3).
  */
 int __cheri_libcall
 vsnprintf(char *str, // NOLINT (clang-tidy spuriously thinks this should be
                      // const, even though it's being written to)
           size_t      size,
           const char *format,
           va_list     ap)
 {
 	struct Buffer
 	{
 		char  *str;
 		size_t remain;
 	} info        = {str, size};
 	auto callback = [&](int ch) {
 		if (info.remain >= 2)
 		{
 			*info.str++ = ch;
 			info.remain--;
 		}
 	};
 	int retval = kvprintf(format, callback, &info, 10, ap);
 	if (info.remain >= 1)
 	{
 		*info.str++ = '\0';
 	}
 	return (retval);
 }

 [[cheri::interrupt_state(disabled)]] int __cheri_libcall
 vfprintf(FILE *stream, const char *fmt, va_list ap)
 {
 	return kvprintf(
 	  fmt,
 	  [=](int ch) { static_cast<volatile Uart *>(stream)->blocking_write(ch); },
 	  nullptr,
 	  10,
 	  ap);
 }

 int __cheri_libcall snprintf(char *str, size_t size, const char *format, ...)
 {
 	int     rv;
 	va_list ap;

 	va_start(ap, format);
 	rv = vsnprintf(str, size, format, ap);
 	va_end(ap);

 	return rv;
 }
	/*-
	* Copyright (c) 1986, 1988, 1991, 1993
	* The Regents of the University of California. All rights reserved.
	* (c) UNIX System Laboratories, Inc.
	* All or some portions of this file are derived from material licensed
	* to the University of California by American Telephone and Telegraph
	* Co. or Unix System Laboratories, Inc. and are reproduced herein with
	* the permission of UNIX System Laboratories, Inc.
	*
	* 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.
	* 2. 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.
	* 4. Neither the name of the University nor the names of its contributors
	* may be used to endorse or promote products derived from this software
	* without specific prior written permission.
	*
	* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``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 REGENTS OR CONTRIBUTORS 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.
	*
	* @(#)subr_prf.c 8.3 (Berkeley) 1/21/94
	*/

	/* __FBSDID("$FreeBSD: stable/8/sys/kern/subr_prf.c 210305 2010-07-20 18:55:13Z
	* jkim $"); */

	#include <cdefs.h>
	#include <cheri-builtins.h>
	#include <compartment.h>
	#include <cstdint>
	#include <function_wrapper.hh>
	#include <inttypes.h>
	#include <platform-uart.hh>
	#include <stdarg.h>
	#include <stdio.h>
	#include <string.h>

	/*
	* Definitions snarfed from various parts of the FreeBSD headers:
	*/
	namespace
	{
	__always_inline char toupper(char c)
	{
	return ((c)-0x20 * (((c) >= 'a') && ((c) <= 'z')));
	}

	static char hex2ascii(uintmax_t in)
	{
	return (in < 10) ? '0' + in : 'a' + in - 10;
	}

	/* Max number conversion buffer length: a u_quad_t in base 2, plus NUL byte. */
	#define MAXNBUF (sizeof(intmax_t) * CHAR_BIT + 1)

	/*
	* Put a NUL-terminated ASCII number (base <= 36) in a buffer in reverse
	* order; return an optional length and a pointer to the last character
	* written in the buffer (i.e., the first character of the string).
	* The buffer pointed to by `nbuf' must have length >= MAXNBUF.
	*/
	// FIXME: Using `unsigned` for `num` instead of `uintmax_t` means that we
	// are going to truncate large numbers, but it avoids needing a library
	// routine to handle division.
	static char *
	ksprintn(char nbuf, unsigned num, int base, int lenp, int upper)
	{
	char *p, c;

	p = nbuf;
	*p = '\0';
	do
	{
	c = hex2ascii(num % base);
	*++p = upper ? toupper(c) : c;
	} while (num /= base);
	if (lenp)
	{
	*lenp = p - nbuf;
	}
	return (p);
	}

	/*
	* Scaled down version of printf(3).
	*
	* Two additional formats:
	*
	* The format %b is supported to decode error registers.
	* Its usage is:
	*
	* printf("reg=%b\n", regval, "<base><arg>*");
	*
	* where <base> is the output base expressed as a control character, e.g.
	* \10 gives octal; \20 gives hex. Each arg is a sequence of characters,
	* the first of which gives the bit number to be inspected (origin 1), and
	* the next characters (up to a control character, i.e. a character <= 32),
	* give the name of the register. Thus:
	*
	* kvprintf("reg=%b\n", 3, "\10\2BITTWO\1BITONE\n");
	*
	* would produce output:
	*
	* reg=3<BITTWO,BITONE>
	*
	* %D -- Hexdump, takes pointer and separator string:
	* ("%6D", ptr, ":") -> XX:XX:XX:XX:XX:XX
	* ("%*D", len, ptr, " " -> XX XX XX XX ...
	*/
	__noinline int kvprintf(char const *fmt,
	FunctionWrapper<void(int)> func,
	void *arg,
	int radix,
	va_list ap)
	{
	char nbuf[MAXNBUF];
	const char p, percent, *q;
	unsigned char *up;
	int ch, n;
	uintmax_t num;
	int base, lflag, qflag, tmp, width, ladjust, sharpflag, neg, sign, dot;
	int cflag, hflag, jflag, tflag, zflag;
	int dwidth, upper;
	char padc;
	int stop = 0, retval = 0;
	const char *emptyString = "";

	auto putchar = [&](int c) {
	func(c);
	retval++;
	};

	if (fmt == nullptr)
	{
	fmt = emptyString;
	}

	if (radix < 2 \|\| radix > 36)
	{
	radix = 10;
	}

	for (;;)
	{
	padc = ' ';
	width = 0;
	while ((ch = static_cast<unsigned char>(*fmt++)) != '%' \|\| stop)
	{
	if (ch == '\0')
	{
	return (retval);
	}
	putchar(ch);
	}
	percent = fmt - 1;
	qflag = 0;
	lflag = 0;
	ladjust = 0;
	sharpflag = 0;
	neg = 0;
	sign = 0;
	dot = 0;
	dwidth = 0;
	upper = 0;
	cflag = 0;
	hflag = 0;
	jflag = 0;
	tflag = 0;
	zflag = 0;
	reswitch:
	switch (ch = static_cast<unsigned char>(*fmt++))
	{
	case '.':
	dot = 1;
	goto reswitch; // NOLINT
	case '#':
	sharpflag = 1;
	goto reswitch; // NOLINT
	case '+':
	sign = 1;
	goto reswitch; // NOLINT
	case '-':
	ladjust = 1;
	goto reswitch; // NOLINT
	case '%':
	putchar(ch);
	break;
	case '*':
	if (!dot)
	{
	width = va_arg(ap, int);
	if (width < 0)
	{
	ladjust = !ladjust;
	width = -width;
	}
	}
	else
	{
	dwidth = va_arg(ap, int);
	}
	goto reswitch; // NOLINT
	case '0':
	if (!dot)
	{
	padc = '0';
	goto reswitch; // NOLINT
	}
	case '1':
	case '2':
	case '3':
	case '4':
	case '5':
	case '6':
	case '7':
	case '8':
	case '9':
	for (n = 0;; ++fmt)
	{
	n = n * 10 + ch - '0';
	ch = *fmt;
	if (ch < '0' \|\| ch > '9')
	{
	break;
	}
	}
	if (dot)
	{
	dwidth = n;
	}
	else
	{
	width = n;
	}
	goto reswitch; // NOLINT
	case 'b':
	num = static_cast<unsigned int>(va_arg(ap, int));
	p = va_arg(ap, char *);
	for (q = ksprintn(nbuf, num, p++, nullptr, 0); q;)
	{
	putchar(*q--);
	}

	if (num == 0)
	{
	break;
	}

	for (tmp = 0; *p;)
	{
	n = *p++;
	if (num & (1 << (n - 1)))
	{
	putchar(tmp ? ',' : '<');
	for (; (n = *p) > ' '; ++p)
	{
	putchar(n);
	}
	tmp = 1;
	}
	else
	{
	for (; *p > ' '; ++p)
	{
	continue;
	}
	}
	}
	if (tmp)
	{
	putchar('>');
	}
	break;
	case 'c':
	putchar(va_arg(ap, int));
	break;
	case 'D':
	up = va_arg(ap, unsigned char *);
	p = va_arg(ap, char *);
	if (!width)
	{
	width = 16;
	}
	while (width--)
	{
	putchar(hex2ascii(*up >> 4));
	putchar(hex2ascii(*up & 0x0f));
	up++;
	if (width)
	{
	for (q = p; *q; q++)
	{
	putchar(*q);
	}
	}
	}
	break;
	case 'd':
	case 'i':
	base = 10;
	sign = 1;
	goto handle_sign; // NOLINT
	case 'h':
	if (hflag)
	{
	hflag = 0;
	cflag = 1;
	}
	else
	{
	hflag = 1;
	}
	goto reswitch; // NOLINT
	case 'j':
	jflag = 1;
	goto reswitch; // NOLINT
	case 'l':
	if (lflag)
	{
	lflag = 0;
	qflag = 1;
	}
	else
	{
	lflag = 1;
	}
	goto reswitch; // NOLINT
	case 'n':
	if (jflag)
	{
	(va_arg(ap, intmax_t )) = retval;
	}
	else if (qflag)
	{
	(va_arg(ap, long long )) = retval;
	}
	else if (lflag)
	{
	(va_arg(ap, long )) = retval;
	}
	else if (zflag)
	{
	(va_arg(ap, size_t )) = retval;
	}
	else if (hflag)
	{
	(va_arg(ap, short )) = static_cast<short>(retval);
	}
	else if (cflag)
	{
	(va_arg(ap, char )) = retval;
	}
	else
	{
	(va_arg(ap, int )) = retval;
	}
	break;
	case 'o':
	base = 8;
	goto handle_nosign; // NOLINT
	case 'p':
	base = 16;
	sharpflag = (width == 0);
	sign = 0;
	num = static_cast<size_t>(
	reinterpret_cast<uintptr_t>(va_arg(ap, void *)));
	goto number; // NOLINT
	case 'q':
	qflag = 1;
	goto reswitch; // NOLINT
	case 'r':
	base = radix;
	if (sign)
	{
	goto handle_sign; // NOLINT
	}
	goto handle_nosign; // NOLINT
	case 's':
	p = va_arg(ap, char *);
	if (p == nullptr)
	{
	p = emptyString;
	}
	if (!dot)
	{
	n = strlen(p);
	}
	else
	{
	for (n = 0; n < dwidth && p[n]; n++)
	{
	continue;
	}
	}

	width -= n;

	if (!ladjust && width > 0)
	{
	while (width--)
	{
	putchar(padc);
	}
	}
	while (n--)
	{
	putchar(*p++);
	}
	if (ladjust && width > 0)
	{
	while (width--)
	{
	putchar(padc);
	}
	}
	break;
	case 't':
	tflag = 1;
	goto reswitch; // NOLINT
	case 'u':
	base = 10;
	goto handle_nosign; // NOLINT
	case 'X':
	upper = 1;
	case 'x':
	base = 16;
	goto handle_nosign; // NOLINT
	case 'y':
	base = 16;
	sign = 1;
	goto handle_sign; // NOLINT
	case 'z':
	zflag = 1;
	goto reswitch; // NOLINT
	handle_nosign:
	sign = 0;
	if (jflag)
	{
	num = va_arg(ap, uintmax_t);
	}
	else if (qflag)
	{
	num = va_arg(ap, unsigned long long);
	}
	else if (tflag)
	{
	num = va_arg(ap, ptrdiff_t);
	}
	else if (lflag)
	{
	num = va_arg(ap, unsigned long);
	}
	else if (zflag)
	{
	num = va_arg(ap, size_t);
	}
	else if (hflag)
	{
	num = static_cast<unsigned short>(va_arg(ap, int));
	}
	else if (cflag)
	{
	num = static_cast<unsigned char>(va_arg(ap, int));
	}
	else
	{
	num = va_arg(ap, unsigned int);
	}
	goto number; // NOLINT
	handle_sign:
	if (jflag)
	{
	num = va_arg(ap, intmax_t);
	}
	else if (qflag)
	{
	num = va_arg(ap, long long);
	}
	else if (tflag)
	{
	num = va_arg(ap, ptrdiff_t);
	}
	else if (lflag)
	{
	num = va_arg(ap, long);
	}
	else if (zflag)
	{
	num = va_arg(ap, ssize_t);
	}
	else if (hflag)
	{
	num = static_cast<short>(va_arg(ap, int));
	}
	else if (cflag)
	{
	num = static_cast<char>(va_arg(ap, int));
	}
	else
	{
	num = va_arg(ap, int);
	}
	number:
	if (sign && static_cast<intmax_t>(num) < 0)
	{
	neg = 1;
	num = -static_cast<intmax_t>(num);
	}
	p = ksprintn(nbuf, num, base, &n, upper);
	tmp = 0;
	if (sharpflag && num != 0)
	{
	if (base == 8)
	{
	tmp++;
	}
	else if (base == 16)
	{
	tmp += 2;
	}
	}
	if (neg)
	{
	tmp++;
	}

	if (!ladjust && padc == '0')
	{
	dwidth = width - tmp;
	}
	width -= tmp + (dwidth > n ? dwidth : n);
	dwidth -= n;
	if (!ladjust)
	{
	while (width-- > 0)
	{
	putchar(' ');
	}
	}
	if (neg)
	{
	putchar('-');
	}
	if (sharpflag && num != 0)
	{
	if (base == 8)
	{
	putchar('0');
	}
	else if (base == 16)
	{
	putchar('0');
	putchar('x');
	}
	}
	while (dwidth-- > 0)
	{
	putchar('0');
	}

	while (*p)
	{
	putchar(*p--);
	}

	if (ladjust)
	{
	while (width-- > 0)
	{
	putchar(' ');
	}
	}

	break;
	default:
	while (percent < fmt)
	{
	putchar(*percent++);
	}
	/*
	* Since we ignore an formatting argument it is no
	* longer safe to obey the remaining formatting
	* arguments as the arguments will no longer match
	* the format specs.
	*/
	stop = 1;
	break;
	}
	}
	}

	} // namespace

	/*
	* Scaled down version of vsnprintf(3).
	*/
	int __cheri_libcall
	vsnprintf(char *str, // NOLINT (clang-tidy spuriously thinks this should be
	// const, even though it's being written to)
	size_t size,
	const char *format,
	va_list ap)
	{
	struct Buffer
	{
	char *str;
	size_t remain;
	} info = {str, size};
	auto callback = [&](int ch) {
	if (info.remain >= 2)
	{
	*info.str++ = ch;
	info.remain--;
	}
	};
	int retval = kvprintf(format, callback, &info, 10, ap);
	if (info.remain >= 1)
	{
	*info.str++ = '\0';
	}
	return (retval);
	}

	[[cheri::interrupt_state(disabled)]] int __cheri_libcall
	vfprintf(FILE stream, const char fmt, va_list ap)
	{
	return kvprintf(
	fmt,
	[=](int ch) { static_cast<volatile Uart *>(stream)->blocking_write(ch); },
	nullptr,
	10,
	ap);
	}

	int __cheri_libcall snprintf(char str, size_t size, const char format, ...)
	{
	int rv;
	va_list ap;

	va_start(ap, format);
	rv = vsnprintf(str, size, format, ap);
	va_end(ap);

	return rv;
	}