OADL Format Specifiers

An OADL Format Specifier is a string that contains one or more Format Descriptors, separated by commas. There are three types of Format Descriptors, Format Value Descriptors, Format Flag Descriptors, and Other Format Descriptors. Format Value Descriptors describe values to be printed or read. Format Flag Descriptors describe flags that control how values are printed and read. Other Format Descriptors cause input/output cursor control, literal items, and other commands.

Whitespace is ignored in a Format Specifier outside of embedded literals. Any Format Value Descriptor may be prefixed with an optional Repeat Count, which implies N identical Format Value Descriptors.

The following table describes the possible Format Value Descriptors (FVDs). In this table, the following definitions are used:

• Field Width of opt - a field width may be given. If omitted, it is calculated based on the value to be formatted. If present and the value requires more space to print than the given field width, the field will be filled with the character '*'
• Precision of opt - a precision may be given, consistiing of a dot . followed by an integer. For integral formats, the precision specifies the total number of digits to print. If fewer digits than the precision are given, the integer will be printed with leading 0 padding.
• Exponent Width of opt - an exponent width may be given, which specifies the number of digits of exponent that should be formatted.

The Precision and Exponent Width are ignored for formatted reads.

The case of FVDs is significant only for the l, i, z, e, en, es, g, m, y and v FVDs. For them, a lower-case Descriptor causes the output characters to be entirely lower-case.

For scalar values, each FVD correponds to a single item. For arrays, each FVD corresponds to a column of the array. All items in a column in an array will have the same field width; if the field width is omitted, the maximum field width will be calculated sufficient to hold all items in a column. All rows will be horizontally aligned, even between separate arrays. If this behavior is not desired, the | or S| Format Flag Descriptors may be used.

Output of nested arrays, enclosures, and strings with whitespace will cause a character-graphic box to be drawn around the item. If all of the characters of the output buffer are ASCII, the ASCII characters +-| will be used to draw the box. Otherwise, the following Unicode characters will be used to draw the box:

To disable box output, use the SN# Format Flag Descriptor. To force Unicode box drawing characters to be used, use the SW Format Flag Descriptor.

The following table describes the possible Format Flag Descriptors (FFD):

The following table describes the possible Other Format Descriptors (OFD):

As a historical note, OADL Format Specifiers are very similar to FORTRAN format statements. The differences include:

• OADL supports the formats i, z, e, g, EN, en, M, m, Y, y, V, and v.
• OADL does not support the formats D, H, or P
• The OADL B format is a binary I/O descriptor, not a blank control.
• OADL supports the format flags SB, S#, SU, SV, ST, S$, and their SNx versions.
• OADL supports the alignment flags SL, SC, and SR.
• OADL does not support carriage control, so it is not necessary to prefix formats with 1X.
• OADL always ignores the precision and exponent width fields on read.
• In OADL, forced reversion is indicated by * rather than the FORTRAN "leftmost embedded format" rule.
• In OADL, format type and print value mismatches are not errors; they result in type conversions instead.
• Field width and digits fields can be omitted in OADL formats; e.g. F.8 and E5e2 are both valid format descriptors. For any format descriptor, if the field width is omitted, a field width is calculated to hold exactly the formatted value with no padding spaces. For float formats E, F, G, EN, ES, and Y (and the V format if the formatted value is a floating point number), if the precision is omitted, it is calculated to be sufficient to print the entire precision of the value, or to read an entire whitespace-delimited input value.

The following is the complete BNF description of OADL Format Specifiers:

format          : fmt_item
                | fmt_item ',' format
                ;

opt_int         : INT           // Repeat N times
                |               // No repeat
                ;

fmt_item        : INT rep_item
                | opt_int rep_fmt_char
                | opt_int '(' format ')'
                | non_rep_item
                ;

rep_fmt_char    : prec_fmt_char opt_int opt_digits
                | exp_fmt_char opt_int opt_digits opt_expon
                | 'L' opt_int           // Logical
                | 'A' opt_int           // String
                | 'X'                   // Space
                | 'R'                   // Radix control
                ;

opt_digits      : '.' INT
                |               // No digits
                ;

opt_expon       : 'E' INT
                | 'e' INT
                |               // No exponent
                ;

prec_fmt_char   : 'I' | 'Z' |'O' // Integer formats
                | 'i' | 'z'     // Ext. - lower case radix print
                | 'B'           // Ext. - integer binary (from Fortran 90)
                | 'F'           // Floating point format
                ;

exp_fmt_char    : 'E' | 'G'     // Exponential & Generic
                | 'e' | 'g'     // Extension - print lower-case
                | 'E' 'S' | 'e' 's' // Scientific notation
                | 'E' 'N' | 'e' 'n' // Extension - engineering (from F90)
                | 'Y' | 'y'     // Extension - like printf("%a")
                | 'V' | 'v'     // Extension - print according to var type
                | 'M'           // Extension - monetary float format
                ;

non_rep_item    : '\'' chars '\'' // Literal
                | '"' strchars '"' // Literal
                | ':'           // Terminate if no more items
                | '*'           // Reversion point
                | '$'           // Suppress newline
                | '|'           // Row break
                | advance       // Advance one or more output rows
                | 'S' | 'S' 'N' // Same as SNP,SNV,SNT,SN$,SJ
                | 'S' 'P'       // Add '+' to positive nums
                | 'S' 'S'       // Suppress '+' from positive nums
                | 'S' 'N' 'P'   // Extension - same as SS
                | 'S' 'B'       // Extension - same as printf("% d")
                | 'S' '#'       // Extension - enable box output around arrays
                | 'S' 'N' '#'   // Extension - disable box output around arrays
                | 'S' 'U'       // Extension - treat integers as unsigned
                | 'S' 'N' 'U'   // Extension - disable integers as unsigned
                | 'S' 'V'       // Extension - add type info pre/suf and quotes
                | 'S' 'N' 'V'   // Extension - disable type info pre/suf and quotes
                | 'S' 'T'       // Extension - add thousands separator
                | 'S' 'N' 'T'   // Extension - disable thousands separator
                | 'S' '|'       // Extension - enable auto row break
                | 'S' 'N' '|'   // Extension - disable auto row break
                | 'S' 'L'       // Extension - left-justified in field
                | 'S' 'C'       // Extension - center item in field (ign. field sign)
                | 'S' 'R'       // Extension - return to right-justified formatting
                | 'S' 'F' '\'' ch '\'' // Extension - set monetary fill char
                | 'S' 'I'       // Extension - use international monetary symbol
                | 'S' 'N' 'I'   // Extension - use national monetary symbol
                | 'S' '*'       // Extension - put single-line literals in all rows
                | 'S' 'N' '*'   // Extension - only put literals in first row
                | 'S' 'W'       // Extension - force wide char output (sticky)
                | 'T' INT       // Absolute horizontal position
                | 'T' 'L' INT   // Relative horizontal pos (toward left)
                | 'T' 'R' INT   // Relative horizontal pos (toward right)
                ;

advance         : '/'           // Advance one output row
                | advance '/'   // Advance multiple output rows
                ;

chars           : /* NOTHING */
                | chars CHAR
                | chars '\'' '\''
                ;

strchars        : /* NOTHING */
                | strchars CHAR
                | strchars '\"' '\"'
                ;

Back to Input / Output

Continue to Predefined Symbols

Return to Introduction