+
+/*
+ Write output to the given stream, as defined by the given format string and
+ 0..n subsequent arguments (the argument stack).
+
+ The format string is written to the given stream verbatim, except for any
+ conversion specifiers included, which start with the letter '%' and are
+ documented below. If the given conversion specifiers require more arguments
+ from the argument stack than provided, behaviour is undefined. Additional
+ arguments not required by conversion specifiers are evaluated but otherwise
+ ignored.
+
+ (The standard specifies the format string is allowed to contain multibyte
+ character sequences as long as it starts and ends in initial shift state,
+ but this is not yet supported by this implementation, which interprets the
+ format string as sequence of char.)
+ TODO: Add multibyte support to printf() functions.
+
+ A conversion specifier consists of:
+ - Zero or more flags (one of the characters "-+ #0").
+ - Optional minimum field width as decimal integer. Default is padding to the
+ left, using spaces. Note that 0 is taken as a flag, not the beginning of a
+ field width. Note also that a small field width will not result in the
+ truncation of a value.
+ - Optional precision (given as ".#" with # being a decimal integer),
+ specifying:
+ - the min. number of digits to appear (diouxX),
+ - the max. number of digits after the decimal point (aAeEfF),
+ - the max. number of significant digits (gG),
+ - the max. number of bytes to be written (s).
+ - behaviour with other conversion specifiers is undefined.
+ - Optional length modifier specifying the size of the argument (one of "hh",
+ "ll", or one of the characters "hljztL").
+ - Conversion specifier character specifying the type of conversion to be
+ applied (and the type of the next argument from the argument stack). One
+ of the characters "diouxXfFeEgGaAcspn%".
+
+ Minimum field width and/or precision may be given as asterisk ('*') instead
+ of a decimal integer. In this case, the next argument from the argument
+ stack is assumed to be an int value specifying the width / precision. A
+ negative field width is interpreted as flag '-' followed by a positive field
+ width. A negative precision is interpreted as if no precision was given.
+
+ FLAGS
+ - Left-justify the conversion result within its field width.
+ + Prefix a '+' on positive signed conversion results. Prefix a '-' on
+ floating conversions resulting in negative zero, or negative values
+ rounding to zero.
+ space Prefix a space on positive signed conversion results, or if a signed
+ conversion results in no characters. If both '+' and ' ' are given,
+ ' ' is ignored.
+ # Use an "alternative form" for
+ - 'o' conversion, increasing precision until the first digit of the
+ result is a zero;
+ - 'x' or 'X' conversion, prefixing "0x" or "0X" to nonzero results;
+ - "aAeEfF" conversions, always printing a decimal point even if no
+ digits are following;
+ - 'g' or 'G' conversions, always printing a decimal point even if no
+ digits are following, and not removing trailing zeroes.
+ - behaviour for other conversions is unspecified.
+ 0 Use leading zeroes instead of spaces for field width padding. If both
+ '-' and '0' are given, '0' is ignored. If a precision is specified for
+ any of the "diouxX" conversions, '0' is ignored. Behaviour is only
+ defined for "diouxXaAeEfFgG".
+
+ LENGTH MODIFIERS
+ hh For "diouxX" conversions, the argument from the argument stack is
+ assumed to be of char width. (It will have been subject to integer
+ promotion but will be converted back.) For 'n' conversions, the argument
+ is assumed to be a pointer to signed char.
+ h For "diouxX" conversions, the argument from the argument stack is
+ assumed to be of short int width. (It will have been subject to integer
+ promotion but will be converted back.) For 'n' conversions, the argument
+ is assumed to be a pointer to short int.
+ l For "diouxX" conversions, the argument from the argument stack is
+ assumed to be of long int width. For 'n' conversions, the argument is
+ assumed to be a pointer to short int. For 'c' conversions, the argument
+ is assumed to be a wint_t. For 's' conversions, the argument is assumed
+ to be a pointer to wchar_t. No effect on "aAeEfFgG" conversions.
+ ll For "diouxX" conversions, the argument from the argument stack is
+ assumed to be of long long int width. For 'n' conversions, the argument
+ is assumed to be a pointer to long long int.
+ j For "diouxX" conversions, the argument from the argument stack is
+ assumed to be of intmax_t width. For 'n' conversions, the argument is
+ assumed to be a pointer to intmax_t.
+ z For "diouxX" conversions, the argument from the argument stack is
+ assumed to be of size_t width. For 'n' conversions, the argument is
+ assumed to be a pointer to size_t.
+ t For "diouxX" conversions, the argument from the argument stack is
+ assumed to be of ptrdiff_t width. For 'n' conversions, the argument is
+ assumed to be a pointer to ptrdiff_t.
+ L For "aAeEfFgG" conversions, the argument from the argument stack is
+ assumed to be a long double.
+ Length modifiers appearing for any conversions not mentioned above will have
+ undefined behaviour.
+ If a length modifier appears with any conversion specifier other than as
+ specified above, the behavior is undefined.
+
+ CONVERSION SPECIFIERS
+ d,i The argument from the argument stack is assumed to be of type int, and
+ is converted to a signed decimal value with a minimum number of digits
+ as specified by the precision (default 1), padded with leading zeroes.
+ A zero value converted with precision zero yields no output.
+ o The argument from the argument stack is assumed to be of type unsigned
+ int, and is converted to an unsigned octal value, other behaviour being
+ as above.
+ u The argument from the argument stack is assumed to be of type unsigned
+ int, and converted to an unsigned decimal value, other behaviour being
+ as above.
+ x,X The argument from the argument stack is assumed to be of type unsigned
+ int, and converted to an unsigned hexadecimal value, using lowercase
+ "abcdef" for 'x' and uppercase "ABCDEF" for 'X' conversion, other
+ behaviour being as above.
+ f,F The argument from the argument stack is assumed to be of type double,
+ and converted to a decimal floating point in decimal-point notation,
+ with the number of digits after the decimal point as specified by the
+ precision (default 6) and the value being rounded appropriately. If
+ precision is zero (and the '#' flag is not given), no decimal point is
+ printed. At least one digit is always printed before the decimal point.
+ For 'f' conversions, an infinity value is printed as either [-]inf or
+ [-]infinity (, depending on the configuration of this implementation. A
+ NaN value is printed as [-]nan. For 'F' conversions uppercase characters
+ are used for these special values. The flags '-', '+' and ' ' apply as
+ usual to these special values, '#' and '0' have no effect.
+ e,E The argument from the argument stack is assumed to be of type double,
+ and converted to a decimal floating point in normalized exponential
+ notation ([?]d.ddd edd). "Normalized" means one nonzero digit before
+ the decimal point, unless the value is zero. The number of digits after
+ the decimal point is specified by the precision (default 6), the value
+ being rounded appropriately. If precision is zero (and the '#' flag is
+ not given), no decimal point is printed. The exponent has at least two
+ digits, and not more than necessary to represent the exponent. If the
+ value is zero, the exponent is zero. The 'e' written to indicate the
+ exponend is uppercase for 'E' conversions.
+ Infinity or NaN values are represented as for 'f' and 'F' conversions,
+ respectively.
+ g,G The argument from the argument stack is assumed to be of type double,
+ and converted according to either 'f' or 'e' format for 'g' conversions,
+ or 'F' or 'E' format for 'G' conversions, respectively, with the actual
+ conversion chosen depending on the value. 'e' / 'E' conversion is chosen
+ if the resulting exponent is < -4 or >= the precision (default 1).
+ Trailing zeroes are removed (unless the '#' flag is given). A decimal
+ point appears only if followed by a digit.
+ Infinity or NaN values are represented as for 'f' and 'F' conversions,
+ respectively.
+ a,A The argument from the argument stack is assumed to be of type double,
+ and converted to a floating point hexadecimal notation ([?]0xh.hhhh pd)
+ with one hexadecimal digit (being nonzero if the value is normalized,
+ and otherwise unspecified) before the decimal point, and the number of
+ digits after the decimal point being specified by the precision. If no
+ precision is given, the default is to print as many digits as nevessary
+ to give an exact representation of the value (if FLT_RADIX is a power of
+ 2). If no precision is given and FLT_RADIX is not a power of 2, the
+ default is to print as many digits to distinguish values of type double
+ (possibly omitting trailing zeroes). (A precision p is sufficient to
+ distinguish values of the source type if 16^p-1 > b^n where b is
+ FLT_RADIX and n is the number of digits in the significand (to base b)
+ of the source type. A smaller p might suffice depending on the
+ implementation's scheme for determining the digit to the left of the
+ decimal point.) The error has the correct sign for the current rounding
+ direction.
+ Unless the '#' flag is given, no decimal-point is given for zero
+ precision.
+ The 'a' conversion uses lowercase "abcdef", "0x" and 'p', the 'A'
+ conversion uppercase "ABCDEF", "0X" and 'P'.
+ The exponent always has at least one digit, and not more than necessary
+ to represent the decimal exponent of 2. If the value is zero, the
+ exponent is zero.
+ Infinity or NaN values are represented as for 'f' and 'F' conversions,
+ respectively.
+ Binary implementations are at liberty to chose the hexadecimal digit to
+ the left of the decimal point so that subsequent digits align to nibble
+ boundaries.
+ c The argument from the argument stack is assumed to be of type int, and
+ converted to a character after the value has been cast to unsigned char.
+ If the 'l' length modifier is given, the argument is assumed to be of
+ type wint_t, and converted as by a "%ls" conversion with no precision
+ and a pointer to a two-element wchar_t array, with the first element
+ being the wint_t argument and the second a '\0' wide character.
+ s The argument from the argument stack is assumed to be a char array (i.e.
+ pointer to char). Characters from that array are printed until a zero
+ byte is encountered or as many bytes as specified by a given precision
+ have been written.
+ If the l length modifier is given, the argument from the argument stack
+ is assumed to be a wchar_t array (i.e. pointer to wchar_t). Wide
+ characters from that array are converted to multibyte characters as by
+ calls to wcrtomb() (using a mbstate_t object initialized to zero prior
+ to the first conversion), up to and including the terminating null wide
+ character. The resulting multibyte character sequence is then printed up
+ to but not including the terminating null character. If a precision is
+ given, it specifies the maximum number of bytes to be written (including
+ shift sequences). If the given precision would require access to a wide
+ character one past the end of the array, the array shall contain a '\0'
+ wide character. In no case is a partial multibyte character written.
+ Redundant shift sequences may result if the multibyte characters have a
+ state-dependent encoding.
+ TODO: Clarify these statements regarding %ls.
+ p The argument from the argument stack is assumed to be a void pointer,
+ and converted to a sequence of printing characters in an implementation-
+ defined manner.
+ This implementation casts the pointer to type intptr_t, and prints the
+ value as if a %#x conversion specifier was given.
+ n The argument from the argument stack is assumed to be a pointer to a
+ signed integer, into which the number of characters written so far by
+ this call to fprintf is stored. The behaviour, should any flags, field
+ widths, or precisions be given is undefined.
+ % A verbatim '%' character is written. No argument is taken from the
+ argument stack.
+
+ Returns the number of characters written if successful, a negative value
+ otherwise.
+*/