GNU Info
(slib.info)Standard Formatted Output
Standard Formatted Output
-------------------------
`(require 'printf)'
- Procedure: printf format arg1 ...
- Procedure: fprintf port format arg1 ...
- Procedure: sprintf str format arg1 ...
- Procedure: sprintf #f format arg1 ...
- Procedure: sprintf k format arg1 ...
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 `(current-output-port)'.
`fprintf' sends its output to the port PORT. `sprintf'
`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
argument is `#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:
* Zero or more "flag characters" that modify the normal
behavior of the conversion specification.
`-'
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 (Note: Standard
Formatted Input).
`0'
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.
* An optional decimal integer specifying the "minimum field
width". If the normal conversion produces fewer characters
than this, the field is padded (with spaces or zeros per the
`0' flag) to the specified width. This is a _minimum_ width;
if the normal conversion produces more characters than this,
the field is _not_ truncated.
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.
* An optional "precision" to specify the number of digits to be
written for numeric conversions and the maximum field width
for string conversions. The precision is specified by a
period (`.') followed optionally by a decimal integer (which
defaults to zero if omitted).
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 `0', 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 precision is `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.
* An optional one of `l', `h' or `L', which is ignored for
numeric conversions. It is an error to specify these
modifiers for non-numeric conversions.
* A character that specifies the conversion to be applied.
Exact Conversions
.................
`b', `B'
Print an integer as an unsigned binary number.
_Note:_ `%b' and `%B' are SLIB extensions.
`d', `i'
Print an integer as a signed decimal number. `%d' and `%i'
are synonymous for output, but are different when used with
`scanf' for input (Note: Standard Formatted Input).
`o'
Print an integer as an unsigned octal number.
`u'
Print an integer as an unsigned decimal number.
`x', `X'
Print an integer as an unsigned hexadecimal number. `%x'
prints using the digits `0123456789abcdef'. `%X' prints
using the digits `0123456789ABCDEF'.
Inexact Conversions
...................
`f'
Print a floating-point number in fixed-point notation.
`e', `E'
Print a floating-point number in exponential notation. `%e'
prints `e' between mantissa and exponont. `%E' prints `E'
between mantissa and exponont.
`g', `G'
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.
`k', `K'
Print a number like `%g', except that an SI prefix is output
after the number, which is scaled accordingly. `%K' outputs
a space between number and prefix, `%k' does not.
Other Conversions
.................
`c'
Print a single character. The `-' flag is the only one which
can be specified. It is an error to specify a precision.
`s'
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.
`a', `A'
Print a scheme expression. The `-' flag left-justifies the
output. The `#' flag specifies that strings and characters
should be quoted as by `write' (which can be read using
`read'); otherwise, output is as `display' prints. A
precision specifies the maximum number of characters to
output; otherwise as many characters as needed are output.
_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 `%%'.
automatically generated by info2www version 1.2.2.9