[-]m.nnnnnne+xx
    
with one digit before the decimal point. The default number of digits after the decimal
    point is six, but this can be changed with a precision field. The "double" value
    is rounded to the correct number of decimal places. The exponent always contains two
    digits. 
  
same as "%e" format, except that the 'E' will be in upper case instead of
    lower. 
  
"double" argument is output in conventional form, i.e. 
[-]mmmm.nnnnnn
    
The default number of digits after the decimal point is six, but this can be changed
    with a precision field. If a decimal point appears, at least one digit appears before it.
    The "double" value is rounded to the correct number of decimal places. 
  
"double" argument is output in scientific or standard format. Scientific
    notation is only used if the exponent resulting from the conversion is less than -4 or
    greater than the precision; otherwise standard representation is used. With scientific
    notation, the 'e' to mark the exponent is in lower case. The precision is taken to mean
    the number of significant digits required (not necessarily the number of decimal places).
    Trailing zeros are removed from the result, and a decimal point only appears if it is
    followed by a digit. 
  
same as "%g" format, except that the 'E' to mark the exponent in scientific
    notation is in upper case. 
  
same as "%d". 
  
"(int *)" argument is taken to point to integer. "printf" assigns
    this integer the number of characters that have been written to the output stream so far
    by this call to "printf". No output is written for this placeholder. 
  
"int" argument is output as an unsigned integer written with octal digits.
    This will not have a leading zero, unless the # "modifier" is used (see below). 
  
corresponding argument is assumed to be "(const void *)" value. The value of
    the pointer is converted to a sequence of printable characters in an
    implementation-defined manner. NS mode C displays the value of the pointer as an octal
    integer. 
  
"(const char *)" argument is taken as pointer to ASCII string. Characters in
    this string will be output until a '\0' character is found or the number of characters
    indicated by the precision field has been printed. 
  
"int" argument is output as an unsigned decimal integer. 
  
"int" argument is output as an unsigned integer written with hexadecimal
    digits, using the letters 'a' to 'f' for hex digits greater than 9. This will not have a
    leading '0x' unless the # "modifier" is used (see below). 
  
same as "%x" except that the letters 'A' to 'F' are used for hex digits
    greater than 9. 
  
same as "%d" except that "int" argument is converted to
    "short" before formatting and printing. Since "short" is the same as
    "int" on the DPS-8, this is the same as "%d". 
  
same as "%hd". 
  
same as "%o" except that the "int" argument is converted to
    "unsigned short" before formatting and printing. Since "unsigned
    short" is the same as "unsigned" on the DPS-8, this is the same as
    "%o". 
  
same as "%u" except that the "int" argument is converted to
    "unsigned short" before formatting and printing. Since "unsigned
    short" is the same as "unsigned" on the DPS-8, this is the same as
    "%u". 
  
same as "%x" except that the "int" argument is converted to
    "unsigned short" before formatting and printing. Since "unsigned
    short" is the same as "unsigned" on the DPS-8, this is the same as
    "%x". 
  
same as "%X" except that the "int" argument is converted to
    "unsigned short" before formatting and printing. Since "unsigned
    short" is the same as "unsigned" on the DPS-8, this is the same as
    "%X". 
  
same as "%d" except argument is "long" integer. Since
    "long" is the same as "int" on the DPS-8, this is the same as
    "%d". However, the compiler will warn you if you specify "%ld" but
    pass a normal "int", or specify "%d" but pass a "long".
    Similar warnings are issued for all the other "%l" placeholders described below.
  
same as "%ld". 
  
same as "%o" except argument is "unsigned long" integer. Since
    "unsigned long" is the same as "unsigned" on the DPS-8, this is
    equivalent to "%o". 
  
same as "%u" except argument is "unsigned long" integer. Since
    "unsigned long" is the same as "unsigned" on the DPS-8, this is
    equivalent to "%u". 
  
same as "%x" except argument is "unsigned long" integer. Since
    "unsigned long" is the same as "unsigned" on the DPS-8, this is
    equivalent to "%x". 
  
same as "%X" except argument is "unsigned long" integer. Since
    "unsigned long" is the same as "unsigned" on the DPS-8, this is
    equivalent to "%X". 
  
same as "%e" except argument is "long double". Since "long
    double" is the same as "double" on the DPS-8, this is the same as
    "%e". 
  
same as "%E" except argument is "long double". Since "long
    double" is the same as "double" on the DPS-8, this is the same as
    "%E". 
  
same as "%f" except argument is "long double". Since "long
    double" is the same as "double" on the DPS-8, this is the same as
    "%f". 
  
same as "%g" except argument is "long double". Since "long
    double" is the same as "double" on the DPS-8, this is the same as
    "%g". 
  
same as "%G" except argument is "long double". Since "long
    double" is the same as "double" on the DPS-8, this is the same as
    "%G". 
The types that have just been listed are recognized by the ANSI standard. In addition
to these, this version of C supports a number of extensions. 
  
"(const char *)" argument taken as pointer to an ASCII string. The string is
    printed out using escape sequences for all non-printable characters. Escape sequences are
    also used for special characters like the backslash, single, and double quotes. The format
    is such that the output could be a valid ASCII string literal if it were enclosed in
    double quotes. If you specify the '-' modifier, output will be left-justified; otherwise,
    it will be right-justified. If you specify the '+' modifier, '\0' characters will not be
    considered to be the end of the string; in this case, a precision must be specified to
    tell "printf" how many characters to print. 
  
"int" argument is taken to contain BCD characters. These are output as their
    ASCII equivalents; letters are output in lower case. If you specify a precision of zero,
    PRINTF will strip off high order zeroes at the beginning of the argument word and
    interpret the rest as BCD characters. If you specify a width, the precision is
    automatically set to the same value. If you do not specify either a precision or width,
    the default is "%6.0_c". 
  
is the same as "%_c", except that letters are output in upper case. 
  
"double" argument is output in scientific notation. This is almost like
    "%e", except that the width field takes precedence over the precision. Thus if
    the requested width is too small to provide the requested precision, a smaller precision
    will be used. 
  
same as "%_e" format except that the 'E' for the exponent will be in upper
    case instead of lower. 
  
"double" argument is output in "optimal" format. If the specified
    width is sufficient to hold the value with the requested precision in standard format
    (nnn.nnn), the value will be printed in standard format. If the width is not sufficient,
    "printf" will use either standard format or scientific notation, whichever
    provides the requested precision with the fewer characters. If no width or precision is
    specified, the number will be output with the greatest available precision. If a width is
    specified, but not a precision, the number will be rounded to the appropriate width. If
    the fractional part of the number is zero, no zeros will be printed after the decimal
    place. Thus there is a difference between 
1.000000
    
The first number is a true 1.0. The second is not 1.0, but has a fractional part that
    is too small to show in the given precision. When scientific notation is used, the 'e' to
    mark the exponent is in lower case. 
  
same as "%_f", except that when scientific notation is used, the 'E' to mark
    the exponent is in upper case. 
  
same as "%_f" format, except that the precision is interpreted as the number
    of significant digits, not the number of decimal places. This means that very small
    numbers will be printed in scientific notation instead of rounded to a .000000 form. When
    scientific notation is used, the 'e' to mark the exponent is in lower case. 
  
same as "%_g" format, except that when scientific notation is used, the 'E' to
    mark the exponent is in upper case. 
  
"(void *)" argument is taken as a BCD pointer. See "expl
    nsc lib _bcdptr" for more on BCD pointers. If only a width is specified, the
    string will be assumed to have that number of BCD characters, and the corresponding ASCII
    characters are output (with letters in lower case and trailing blanks removed). If a width
    and a precision field are specified, the precision is taken to be the number of BCD
    characters in the string and the width is the size of the output field. If no width is
    given, the default is six. Trailing blanks are stripped, unless the '#' modifier is
    specified. By default, the output is right-justified; if the modifier '-' is given, the
    output will be left-justified. 
  
same as "%_s" except that letters are output in upper case. 
  
has two corresponding arguments: a "const char *" format string in the same
    format as a normal "printf" format string; and a "va_list" argument,
    as declared in <stdarg.h>. The "va_list" argument is presumed to indicate
    all or part of a variable argument list (i.e. the argument has been set up with
    "va_start"). The arguments remaining in this variable argument list are
    formatted and output according to the given format string. For more information on
    variable argument lists, see "expl nsc include stdarg".
The Modifiers Field
The modifiers field consists of zero or more characters that indicate how output should
be padded (e.g. whether numbers are preceded by blanks or leading zeros), and whether or
not '+' or '-' signs are printed. Below we list the possible "modifier"
characters. 
  
- (minus)
  
indicates that values should be left-justified in the output field. The default action
    is to right-justify them. 
  
+ (plus)
  
is relevant only for signed numeric output values and "%_a". This
    "modifier" character tells "printf" to put a sign in front of the
    number, whether or not it is negative. Thus negative numbers will be preceded by '-' while
    zero and positive numbers will be preceded by '+'. The default is to add the sign only if
    the number is negative. See the description of "%_a" for
    the effect of '+' with that placeholder. 
  
  (blank)
  
is relevant only for signed numeric output values. This "modifier" character
    tells "printf" to put a sign in front of numbers only if they are negative. If
    the number is non-negative, "printf" will put in a blank instead of a sign. The
    default is not to put a blank in front of non-negative number. If both '+' and ' '
    are specified as "modifier" characters, the '+' overrides the ' '. 
  
# (sharp)
  
is relevant only for some output types. 
If "type" is 'o', all non-zero
    values will have a leading 0; normally, octal output has no leading zero. 
    
If "type" is 'x' or 'X', all non-zero values will have a leading 0x or 0X
    respectively; normally, such prefixes are omitted. 
    
If "type" is 'e', 'E' or 'f', "printf" will always print out a
    decimal point (normally, the decimal point is omitted if the number has no fractional
    part). 
    
If "type" is '_f', trailing zeros are printed after a decimal point, even if
    the fractional part of the number is zero. 
    
If "type" is 'g' or 'G', "printf" will always print out a decimal
    point and trailing zeros will not be removed; usually 'g' and 'G' remove trailing zeros. 
    
If "type" is '_s' or '_S', trailing blanks are not trimmed. 
    
If "type" is '_a', the output is enclosed in double quotes. 
The Width Field
The width field is a non-negative decimal integer giving the minimum number of
characters to be printed. If the output value is shorter than the given width, it is
padded to the appropriate width by putting blanks on the right (or on the left, if the '-'
"modifier" character is specified). 
With numeric placeholders, the number in the width field may have a leading 0. With
this, the output value will be expanded with zeros to give the number the specified width.
For example, with "%05d" the value -1 will be printed as "-0001". 
The width field can also be the character '*', in which case "printf" will
take the next argument in the argument list and take that as the width value. For example,
printf("%*d",4,X);
prints the value of X with a width of 4. Note that the width value is obtained from the
argument list BEFORE the output value is obtained. 
The width field specifies the MINIMUM number of characters to be output. If more
characters are needed, the output will be wider than width (unless the precision value
dictates otherwise). 
The Precision Field
The precision field is a dot '.' followed by a non-negative decimal integer. Its
meaning depends on the "type" field as given below. 
  
If the "type" is 'd', 'o', 'u', 'x' or 'X', the precision number is the
    smallest number of digits that may appear in the output value. If necessary, the number
    will be padded on the left with leading zeros. If the precision number is 0 or the field
    is just a '.' with no number following, an output value of 0 will result in no characters
    being printed. 
  
If the "type" is 'e', 'E', or 'f', the precision number is the number of
    digits printed after the decimal point. If the precision number is 0 or the field is just
    a '.' with no number following, no decimal point is printed. 
  
If the "type" is 'g' or 'G', the precision number is the maximum number of
    significant digits to be printed. If no precision field is specified, six significant
    digits are printed. 
  
If the "type" is 's', the precision number gives the maximum number of
    characters to be printed. 
  
If the "type" is an 'h', 'l' or 'L' type, the precision field has the same
    effect as it has for the type without the 'h', 'l' or 'L'. 
  
If the "type" is "_e", "_E", "_f", or
    "_F", the precision number is the number of digits printed after the decimal
    point. If no precision is specified, the width will dictate the precision. If no width is
    specified either, the value will be printed to full precision. 
  
If the "type" is "_g" or "_G", the precision is the
    maximum number of significant digits to be printed. If no precision field is specified,
    all significant digits are printed. 
The precision field can also be the character '*', in which case "printf"
will take the next argument in the argument list and take that as the precision value. For
example, 
printf("%*.*f",8,3,Y);
prints the value of Y with a width of 8 and a precision of 3. 
Fill Characters
As a non-ANSI extension, all placeholders may specify a "fill character" by
putting ",F" in front of the type designator (where F is any character). In any
situation where "printf" would normally fill out a field with blanks, the fill
character will be used instead. For example, with 
printf("%5,#d",20);
the output would be 
###20
The "#" after the comma is used as a fill character. 
As with width and precision, the fill field can also be the character '*', in which
case "printf" will take the next argument in the argument list and take that as
the fill value. For example, 
printf("%,*d",'*',20);
will fill with asterisks. If you want to fill with asterisks, you have to take this
approach. 
Defaults
Below we list the defaults when width and/or precision fields are omitted. 
"%1c"     "%1.1d"    "%11.6e"   "%11.6E"
"%8.6f"   "%1.6g"    "%1.6G"    "%1.1o"
"%0s"     "%1.1x"    "%1.1X"    "%1.1ld"
"%1.1lo"  "%1.1lx"   "%1.1lX"   "%6.6Le"
"%6.6LE"  "%6.6Lf"   "%6.6Lg"   "%6.6LG"
Examples:
#include <stdio.h>
int i = 3, j = -1, k = 4;
char *s = "string";
float x = 3.14159265;
printf("j = %.*d, %.3s x = %10.*f",i,j,s,k,x);
/* prints:  j = -001, str x =     3.1416 */
In the next examples, we use the letter 'b' to show where spaces are printed out. In
all cases, the value printed is the integer -1. 
Format     Output
 %5d       bbb-1
 %05d      -0001
 %5.5d     -00001 (precision requires 5 sig. digits)
 %5,0d     000-1  (zero is fill character)
Notes:
The "printf" function does almost no validity checking on the format string.
Therefore, if you specify an invalid format, you will probably get invalid output without
any diagnostic message. You may also get more serious errors (e.g. memory faults). 
Most users will find that "%g" is the best format for printing out single
floating point numbers, since it tries to choose the most readable format. For columns of
floating point numbers, "%_f" is usually better than "%f" because
"%_f" makes more of an effort to provide the precise width requested (or as
close as possible to that width). 
See Also:
expl nsc lib fprintf 
expl nsc lib scanf 
expl nsc lib sprintf