Tribblix: manual page: printf.1

PRINTF(1) User Commands PRINTF(1)

NAME

printf - write formatted output

SYNOPSIS

/usr/bin/printf
printf format [argument]...

ksh93
printf format [string...]

DESCRIPTION

/usr/bin/printf
The printf utility writes each string operand to standard output
using format to control the output format.

OPERANDS

/usr/bin/printf
The following operands are supported by /usr/bin/printf:

format
A string describing the format to use to write the
remaining operands. The format operand is used as the
format string described on the formats(7) manual page,
with the following exceptions:

o A SPACE character in the format string, in any
context other than a flag of a conversion
specification, is treated as an ordinary
character that is copied to the output.

o A character in the format string is treated as
a character, not as a SPACE character.

o In addition to the escape sequences described
on the formats(7) manual page (\\, \a, \b, \f,
\n, \r, \t, \v), \ddd, where ddd is a one-,
two- or three-digit octal number, is written
as a byte with the numeric value specified by
the octal number.

o The program does not precede or follow output
from the d or u conversion specifications with
blank characters not specified by the format
operand.

o The program does not precede output from the o
conversion specification with zeros not
specified by the format operand.

o The argument used for the conversion character
(or width or precision parameters, see below)
may be taken from the nnth argument instead of
the next unused argument, by specifying n$
immediately following the % character, or the
* character (for width or precision
arguments). If n$ appears in any conversions
in the format string, then it must be used for
all conversions, including any variable width
or precision specifiers.

o The special character * may be used instead of
a string of decimal digits to indicate a
minimum field width or a precision. In this
case the next available argument is used (or
the nth if the form n$ is used), treating its
value as a decimal string.

o An additional conversion character, b, is
supported as follows. The argument is taken to
be a string that can contain backslash-escape
sequences. The following backslash-escape
sequences are supported:

o the escape sequences listed on the
formats(7) manual page (\\, \a, \b, \f,
\n, \r, \t, \v), which are converted to
the characters they represent

o \0ddd, where ddd is a zero-, one-, two- or
three-digit octal number that is converted
to a byte with the numeric value specified
by the octal number

o \c, which is written and causes printf to
ignore any remaining characters in the
string operand containing it, any
remaining string operands and any
additional characters in the format
operand.
The interpretation of a backslash followed by any other
sequence of characters is unspecified.

Bytes from the converted string are written until the end
of the string or the number of bytes indicated by the
precision specification is reached. If the precision is
omitted, it is taken to be infinite, so all bytes up to
the end of the converted string are written. For each
specification that consumes an argument, the next
argument operand is evaluated and converted to the
appropriate type for the conversion as specified below.
The format operand is reused as often as necessary to
satisfy the argument operands. Any extra c or s
conversion specifications are evaluated as if a null
string argument were supplied; other extra conversion
specifications are evaluated as if a zero argument were
supplied.

When there are more argument operands than format
specifiers, and the format includes n$ position
indicators, then the format is reprocessed from the
beginning as above, but with the argument list starting
from the next argument after the highest nth argument
previously encountered.

If the format operand contains no conversion
specifications and argument operands are present, the
results are unspecified. If a character sequence in the
format operand begins with a % character, but does not
form a valid conversion specification, the behavior is
unspecified.

argument
The strings to be written to standard output, under the
control of format. The argument operands are treated as
strings if the corresponding conversion character is b, c
or s. Otherwise, it is evaluated as a C constant, as
described by the ISO C standard, with the following
extensions:

o A leading plus or minus sign is allowed.

o If the leading character is a single- or
double-quote, the value is the numeric value
in the underlying codeset of the character
following the single- or double-quote.
If an argument operand cannot be completely converted
into an internal value appropriate to the corresponding
conversion specification, a diagnostic message is written
to standard error and the utility does not exit with a
zero exit status, but continues processing any remaining
operands and writes the value accumulated at the time the
error was detected to standard output.

ksh93
The format operands support the full range of ANSI C/C99/XPG6
formatting specifiers as well as additional specifiers:

%b
Each character in the string operand is processed specially, as
follows:

\a
Alert character.

\b
Backspace character.

\c
Terminate output without appending NEWLINE. The
remaining string operands are ignored.

\E
Escape character (ASCII octal 033).

\f
FORM FEED character.

\n
NEWLINE character.

\t
TAB character.

\v
Vertical tab character.

\\
Backslash character.

\0x
The 8-bit character whose ASCII code is the 1-, 2-, or
3-digit octal number x.

%B
Treat the argument as a variable name and output the value
without converting it to a string. This is most useful for
variables of type -b.

%H
Output string with characters <, &, >, ", and non-printable
characters, properly escaped for use in HTML and XML documents.

%P
Treat string as an extended regular expression and convert it
to a shell pattern.

%q
Output string quoted in a manner that it can be read in by the
shell to get back the same string. However, empty strings
resulting from missing string operands are not quoted.

%R
Treat string as an shell pattern expression and convert it to
an extended regular expression.

%T
Treat string as a date/time string and format it. The T can be
preceded by (dformat), where dformat is a date format as
defined by the date(1) command.

%Z
Output a byte whose value is 0.

When performing conversions of string to satisfy a numeric format
specifier, if the first character of string is "or', the value is the
numeric value in the underlying code set of the character following
the "or'. Otherwise, string is treated like a shell arithmetic
expression and evaluated.

If a string operand cannot be completely converted into a value
appropriate for that format specifier, an error occurs, but remaining
string operands continue to be processed.

In addition to the format specifier extensions, the following
extensions of ANSI C/C99/XPG6 are permitted in format specifiers:

o The escape sequences \E and \e expand to the escape
character which is octal 033 in ASCII.

o The escape sequence \cx expands to CTRL-x.

o The escape sequence \C[.name.] expands to the collating
element name.

o The escape sequence \x{hex} expands to the character
corresponding to the hexadecimal value hex.

o The format modifier flag = can be used to center a field
to a specified width. When the output is a terminal, the
character width is used rather than the number of bytes.

o Each of the integral format specifiers can have a third
modifier after width and precision that specifies the base
of the conversion from 2 to 64. In this case, the #
modifier causes base# to be prepended to the value.

o The # modifier can be used with the d specifier when no
base is specified to cause the output to be written in
units of 1000 with a suffix of one of k M G T P E.

o The # modifier can be used with the i specifier to cause
the output to be written in units of 1024 with a suffix of
one of Ki Mi Gi Ti Pi Ei.

If there are more string operands than format specifiers, the format
string is reprocessed from the beginning. If there are fewer string
operands than format specifiers, then string specifiers are treated
as if empty strings were supplied, numeric conversions are treated as
if 0 was supplied, and time conversions are treated as if now was
supplied.

When there are more argument operands than format specifiers, and the
format includes n$ position indicators, then the format is
reprocessed from the beginning as above, but with the argument list
starting from the next argument after the highest nth argument
previously encountered.

/usr/bin/printf is equivalent to ksh93's printf built-in and print
-f, which allows additional options to be specified.

USAGE

/usr/bin/printf
The printf utility, like the printf(3C) function on which it is
based, makes no special provision for dealing with multi-byte
characters when using the %c conversion specification. Applications
should be extremely cautious using either of these features when
there are multi-byte characters in the character set.

The %b conversion specification is not part of the ISO C standard; it
has been added here as a portable way to process backslash escapes
expanded in string operands as provided by the echo utility. See also
the USAGE section of the echo(1) manual page for ways to use printf
as a replacement for all of the traditional versions of the echo
utility.

If an argument cannot be parsed correctly for the corresponding
conversion specification, the printf utility reports an error. Thus,
overflow and extraneous characters at the end of an argument being
used for a numeric conversion are to be reported as errors.

It is not considered an error if an argument operand is not
completely used for a c or s conversion or if a string operand's
first or second character is used to get the numeric value of a
character.

EXAMPLES

/usr/bin/printf

Example 1: Printing a Series of Prompts

The following example alerts the user, then prints and reads a series
of prompts:

example% printf "\aPlease fill in the following: \nName: "
read name
printf "Phone number: "
read phone

Example 2: Printing a Table of Calculations

The following example prints a table of calculations. It reads out a
list of right and wrong answers from a file, calculates the
percentage correctly, and prints them out. The numbers are right-
justified and separated by a single tab character. The percentage is
written to one decimal place of accuracy:

example% while read right wrong ; do
percent=$(echo "scale=1;($right*100)/($right+$wrong)" | bc)
printf "%2d right\t%2d wrong\t(%s%%)\n" \
$right $wrong $percent
done < database_file

Example 3: Printing number strings

The command:

example% printf "%5d%4d\n" 1 21 321 4321 54321

produces:

1 21
3214321
54321 0

The format operand is used three times to print all of the given
strings and that a 0 was supplied by printf to satisfy the last %4d
conversion specification.

Example 4: Tabulating Conversion Errors

The following example tabulates conversion errors.

The printf utility tells the user when conversion errors are detected
while producing numeric output. These results would be expected on an
implementation with 32-bit twos-complement integers when %d is
specified as the format operand:

+-------------------------------------------------------------------+
| Arguments Standard Diagnostic |
|5a 5 printf: 5a not completely converted |
|9999999999 2147483647 printf: 9999999999: Results too large |
|-9999999999 -2147483648 printf: -9999999999: Results too large |
|ABC 0 printf: ABC expected numeric value |
+-------------------------------------------------------------------+

The value shown on standard output is what would be expected as the
return value from the function strtol(3C). A similar correspondence
exists between %u and strtoul(3C), and %e, %f and %g and strtod(3C).

Example 5: Printing Output for a Specific Locale

The following example prints output for a specific locale. In a
locale using the ISO/IEC 646:1991 standard as the underlying codeset,
the command:

example% printf "%d\n" 3 +3 -3 \'3 \"+3 "'-3"

produces:

+----------------------------------+
|3 Numeric value of constant 3 |
|3 Numeric value of constant 3 |
|-3 Numeric value of constant -3 |
|51 Numeric value of the |
| character `3' in the ISO/IEC |
| 646:1991 standard codeset |
|43 Numeric value of the |
| character `+' in the ISO/IEC |
| 646:1991 standard codeset |
|45 Numeric value of the |
| character `-' in the SO/IEC |
| 646:1991 standard codeset |
+----------------------------------+

In a locale with multi-byte characters, the value of a character is
intended to be the value of the equivalent of the wchar_t
representation of the character.

If an argument operand cannot be completely converted into an
internal value appropriate to the corresponding conversion
specification, a diagnostic message is written to standard error and
the utility does exit with a zero exit status, but continues
processing any remaining operands and writes the value accumulated at
the time the error was detected to standard output.

Example 6: Alternative floating point representation 1

The printf utility supports an alternative floating point
representation (see printf(3C) entry for the "%a"/"%A"), which allows
the output of floating-point values in a format that avoids the usual
base16 to base10 rounding errors.

example% printf "%a\n" 2 3.1 NaN

produces:

0x1.0000000000000000000000000000p+01
0x1.8ccccccccccccccccccccccccccdp+01
nan

Example 7: Alternative floating point representation 2

The following example shows two different representations of the same
floating-point value.

example% x=2 ; printf "%f == %a\n" x x

produces:

2.000000 == 0x1.0000000000000000000000000000p+01

Example 8: Output of unicode values

The following command will print the EURO unicode symbol (code-point
0x20ac).

example% LC_ALL=en_US.UTF-8 printf "[20ac]\n"

produces:

<euro>

where "<euro>" represents the EURO currency symbol character.

Example 9: Convert unicode character to unicode code-point value

The following command will print the hexadecimal value of a given
character.

example% export LC_ALL=en_US.UTF-8
example% printf "%x\n" "'<euro>"

where "<euro>" represents the EURO currency symbol character (code-
point 0x20ac).

produces:

20ac

Example 10: Print the numeric value of an ASCII character

example% printf "%d\n" "'A"

produces:

65

Example 11: Print the language-independent date and time format

To print the language-independent date and time format, the following
statement could be used:

example% printf "format" weekday month day hour min

For example,

$ printf format "Sunday" "July" 3 10 2

For American usage, format could be the string:

"%s, %s %d, %d:%.2d\n"

producing the message:

Sunday, July 3, 10:02

Whereas for EU usage, format could be the string:

"%1$s, %3$d. %2$s, %4$d:%5$.2d\n"

Note that the '$' characters must be properly escaped, such as

"%1\$s, %3\$d. %2\$s, %4\$d:%5\$.2d\n" in this case

producing the message:

Sunday, 3. July, 10:02

ENVIRONMENT VARIABLES

See environ(7) for descriptions of the following environment
variables that affect the execution of printf: LANG, LC_ALL,
LC_CTYPE, LC_MESSAGES, LC_NUMERIC, and NLSPATH.

EXIT STATUS

The following exit values are returned:

0
Successful completion.

>0
An error occurred.

ATTRIBUTES

NOTES

Using format specifiers (characters following '%') which are not
listed in the printf(3C) or this manual page will result in undefined
behavior.

Using escape sequences (the character following a backslash ('\'))
which are not listed in the printf(3C) or this manual page will
result in undefined behavior.

Floating-point values follow C99, XPG6 and IEEE 754 standard behavior
and can handle values the same way as the platform's |long double|
datatype.

Floating-point values handle the sign separately which allows signs
for values like NaN (for example, -nan), Infinite (for example, -inf)
and zero (for example, -0.0).

May 11, 2014 PRINTF(1)