Each function converts, formats, and outputs its arg1 … arguments according to the control string format argument and returns the number of characters output.
printf sends its output to the port
fprintf sends its output to the port port.
string-set!s locations of the non-constant string argument
str to the output characters.
Two extensions of
sprintf return new strings. If the first
#f, then the returned string’s length is as many
characters as specified by the format and data; if the first
argument is a non-negative integer k, then the length of the
returned string is also bounded by k.
The string format contains plain characters which are copied to the output stream, and conversion specifications, each of which results in fetching zero or more of the arguments arg1 …. The results are undefined if there are an insufficient number of arguments for the format. If format is exhausted while some of the arg1 … arguments remain unused, the excess arg1 … arguments are ignored.
The conversion specifications in a format string have the form:
% [ flags ] [ width ] [ . precision ] [ type ] conversion
An output conversion specifications consist of an initial ‘%’ character followed in sequence by:
Left-justify the result in the field. Normally the result is right-justified.
For the signed ‘%d’ and ‘%i’ conversions and all inexact conversions, prefix a plus sign if the value is positive.
For the signed ‘%d’ and ‘%i’ conversions, if the result doesn’t start with a plus or minus sign, prefix it with a space character instead. Since the ‘+’ flag ensures that the result includes a sign, this flag is ignored if both are specified.
For inexact conversions, ‘#’ specifies that the result should always include a decimal point, even if no digits follow it. For the ‘%g’ and ‘%G’ conversions, this also forces trailing zeros after the decimal point to be printed where they would otherwise be elided.
For the ‘%o’ conversion, force the leading digit to be ‘0’, as
if by increasing the precision. For ‘%x’ or ‘%X’, prefix a
leading ‘0x’ or ‘0X’ (respectively) to the result. This
doesn’t do anything useful for the ‘%d’, ‘%i’, or ‘%u’
conversions. Using this flag produces output which can be parsed by the
scanf functions with the ‘%i’ conversion
(see Standard Formatted Input).
Pad the field with zeros instead of spaces. The zeros are placed after any indication of sign or base. This flag is ignored if the ‘-’ flag is also specified, or if a precision is specified for an exact converson.
Alternatively, if the field width is ‘*’, the next argument in the argument list (before the actual value to be printed) is used as the field width. The width value must be an integer. If the value is negative it is as though the ‘-’ flag is set (see above) and the absolute value is used as the field width.
Alternatively, if the precision is ‘.*’, the next argument in the argument list (before the actual value to be printed) is used as the precision. The value must be an integer, and is ignored if negative. If you specify ‘*’ for both the field width and precision, the field width argument precedes the precision argument. The ‘.*’ precision is an enhancement. C library versions may not accept this syntax.
For the ‘%f’, ‘%e’, and ‘%E’ conversions, the precision
specifies how many digits follow the decimal-point character. The
default precision is
6. If the precision is explicitly
the decimal point character is suppressed.
For the ‘%g’ and ‘%G’ conversions, the precision specifies how
many significant digits to print. Significant digits are the first
digit before the decimal point, and all the digits after it. If the
0 or not specified for ‘%g’ or ‘%G’, it is
treated like a value of
1. If the value being printed cannot be
expressed accurately in the specified number of digits, the value is
rounded to the nearest number that fits.
For exact conversions, if a precision is supplied it specifies the minimum number of digits to appear; leading zeros are produced if necessary. If a precision is not supplied, the number is printed with as many digits as necessary. Converting an exact ‘0’ with an explicit precision of zero produces no characters.
Print an integer as an unsigned binary number.
Note: ‘%b’ and ‘%B’ are SLIB extensions.
Print an integer as a signed decimal number. ‘%d’ and ‘%i’
are synonymous for output, but are different when used with
for input (see Standard Formatted Input).
Print an integer as an unsigned octal number.
Print an integer as an unsigned decimal number.
Print an integer as an unsigned hexadecimal number. ‘%x’ prints using the digits ‘0123456789abcdef’. ‘%X’ prints using the digits ‘0123456789ABCDEF’.
Print a floating-point number in fixed-point notation.
Print a floating-point number in exponential notation. ‘%e’ prints ‘e’ between mantissa and exponont. ‘%E’ prints ‘E’ between mantissa and exponont.
Print a floating-point number in either fixed or exponential notation, whichever is more appropriate for its magnitude. Unless an ‘#’ flag has been supplied, trailing zeros after a decimal point will be stripped off. ‘%g’ prints ‘e’ between mantissa and exponont. ‘%G’ prints ‘E’ between mantissa and exponent.
Print a number like ‘%g’, except that an SI prefix is output after the number, which is scaled accordingly. ‘%K’ outputs a dot between number and prefix, ‘%k’ does not.
Print a single character. The ‘-’ flag is the only one which can be specified. It is an error to specify a precision.
Print a string. The ‘-’ flag is the only one which can be specified. A precision specifies the maximum number of characters to output; otherwise all characters in the string are output.
Print a scheme expression. The ‘-’ flag left-justifies the output.
The ‘#’ flag specifies that strings and characters should be quoted
write (which can be read using
output is as
display prints. A precision specifies the maximum
number of characters to output; otherwise as many characters as needed
Note: ‘%a’ and ‘%A’ are SLIB extensions.
Print a literal ‘%’ character. No argument is consumed. It is an error to specify flags, field width, precision, or type modifiers with ‘%%’.