f", <time>

                        In the POSIX locale, if l is specified and the
                        time is greater than or equal to one hour, the
                        output format shall be:
                                "%dh%dm%02d%.

fs", (int)<time>/3600,
                                        ((int)<time>%3600)/60,
                                        ((int)<time>%60),
                                        <time>-(int)<time>

                        In the POSIX locale, if l is specified and the
                        time is less than one hour, the
                        output format shall be:
                                "%dm%02d%.

fs", ((int)<time>)/60,
                                        ((int)<time>)%60),
                                        <time>-(int)<time>

[[Note: the editors might prefer to use an italic p rather than

.]]
                        In the above three formats,

in the output
                        format represents the optional p specified
                        after the % in TIMEFORMAT. If the optional
                        p is not specified, the precision used
                        shall be sufficiently precise to accommodate
                        the size of the clock tick on the system (for
                        example, if there were 60 clock ticks per
                        second, at least two digits shall follow the
                        radix character). Unless p is specified to be
                        0, the number of digits following the radix
                        character shall be no less than one, even if
                        this always results in a trailing zero. If p
                        is specified to be 0, the radix character shall
                        not be written.

                        All other characters in TIMEFORMAT shall be output
                        without change and a trailing newline shall be added.

4. Change the entire section 2.9.2 Pipelines on P2318-2319,
    L73174-73191 to:
    \fB2.9.2 Pipelines\fP

                A \fIpipeline\fP is an optional '!' reserved word
                followed by a sequence of zero or more commands
                separated by the control operator '|'. A pipeline
                not beginning with '!' shall contain one or more
                commands. When a pipeline contains two or more
                commands, the standard
                output of all but the last command shall be connected
                to the standard input of the next command.

    \fI2.9.2.1 Unadorned Pipeline\fP

                The format for an unadorned pipeline is:

                command [ | pipeline ]

                The standard output of command shall be connected to
                the standard input of the first command in pipeline.
                The standard input, standard output, or both of a
                command shall be considered to be assigned by the
                pipeline before any redirection specified by
                redirection operators that are part of the command (see
                Section 2.7, on page XXX). If the pipeline is not in
                the background (see Section 2.9.3.1, on page XXX), the
                shell shall wait for the last command specified in the
                pipeline to complete, and may also wait for all
                commands to complete.

                \fBExit Status\fP

                The exit status of an unadorned pipeline shall be the
                exit status of the last element of the pipeline.

    \fI2.9.2.2 False Pipeline\fP

                The format for a false pipeline is:
                !

                A false pipeline shall have no effect other than
                setting its exit status.

                Exit Status\fP

                The exit status of a false pipeline shall be 1.

                \fBExamples\fP
                The pipeline:
                \fCW!\fP

                is roughly equivalent to the command:
                \fCWfalse\fP

    \fI2.9.2.3 Negated Pipeline\fP

                The format for a negated pipeline is:

                ! pipeline

                A negated pipeline shall be processed in the same way
                as the given pipeline, except that the exit status of
                the negated pipeline shall be the logical NOT of the
                exit status of the given pipeline.


                \fBExit Status\fP

                If the last element of the pipline returns zero, the
                exit status of the negated pipeline shall be 1; if the
                last element of the pipeline returns greater than zero,
                the exit status of the negated pipeline shall be zero.

                \fBExamples\fP

                The pipeline:

                \fCW! !\fP

                is roughly equivalent to the pipeline:

                \fCWtrue\fP

    \fI2.9.2.4 Shelltime Pipeline\fP

                The format for a shelltime pipeline is:

                \fBtime\fP

                If a pipeline is the \fBtime\fP reserved word, the time
                consumed by the current shell and all completed
                commands run by the current shell shall be output to
                standard error. If set, the TIMEFORMAT
                shell variable (see Section 2.5.3, on page XXX)
                determines the format of the time information.
                Otherwise, in the POSIX locale the output format shall
                be as if the TIMEFORMAT shell variable were set to a
                string containing a concatenation of the string "user",
                a <tab> character, the string "%2lU", a <newline>
                character, the string "sys", a <tab> character, and the
                string "%2lS".

                \fBExit Status\fP

                The exit status of a shelltime pipeline shall be 0.

                \fBExamples\fP

                Enclosing a shelltime pipeline in a brace group allows
                the output to be redirected:

                \fCW{ time;} 2>time_output\fP

                This is necessary because if redirections follow the
                \fBtime\fP reserved word the result is a timed
                pipeline instead of a shelltime pipeline.

    \fI2.9.2.5 Timed Pipeline\fP

                The format for a timed pipeline is:

                \fBtime\fP pipeline

                If a pipeline is preceded by the \fBtime\fP reserved
                word, the time consumed by all elements of the pipeline
                shall be output to standard error. If set, the
                TIMEFORMAT shell variable determines the format
                of the time information. Otherwise, in the POSIX locale
                the output format
                shall be as if the TIMEFORMAT shell variable were
                set to a string containing a concatenation of a
                <newline> character, the string "real", a <tab>
                character, the string "%2lR", a <newline> character,
                the string "user", a <tab> character, the string
                "%2lU", a <newline> character, the string "sys", a
                <tab> character, and the string "%2lS".

                \fBExit Status\fP

                The exit status of a timed pipeline shall be the exit
                status of the specified pipeline.

                \fBExamples\fP

                Enclosing a timed pipeline in a brace group allows
                the timing output to be redirected along with the
                standard error from the pipeline:

                \fCW{ time utility;} 2>utility_stderr+time_output\fP

                Without the brace group, only the standard error of
                the pipeline would be redirected and the timing
                output would go to the shell's standard error.

5. In section 2.9.3.1 on P2319, L73225, change:
        command1 & [command2 & ... ]
    to:
        command1 & [command2 & ] ...

6. In section 2.9.5 on P2324, L73379, change:
        fname() compound-command[io-redirect ...]
   to:
        fname() compound-command [io-redirect ...]

7. In section 2.10.2, change the text of the first paragraph of Rule 1
    on P2325, L73433-73435 from:
        When the \fBTOKEN\fP is exactly a reserved word, the token
        identifier for that reserved word shall result. Otherwise, the
        token \fBWORD\fP shall be returned. Also, if the parser is in
        any state where only a reserved word could be the next correct
        token, proceed as above.
    to:
        When the \fBTOKEN\fP is exactly a reserved word, the token
        identifier for that reserved word shall result unless:
        1. the \fBTOKEN\fP is not in a state where a reserved word is
            allowed as described in Section 2.4., or
        2. the \fBTOKEN\fP is \fBtime\fP and the first character of the
            next \fBTOKEN\fP is a '-' character.
        Otherwise, the token \fBWORD\fP shall be returned.

8. In section 2.10.2, add the token Time by changing P2327,
    L73514-73515 from:
        %token Lbrace Rbrace Bang
        /* '{' '}' '!' */
    to:
        %token Lbrace Rbrace Bang Time
        /* '{' '}' '!' 'time' */

9. In section 2.10.2, change the grammar for pipeline on P2327,
    L73533-73535 from:
        pipeline : pipe_sequence
                        | Bang pipe_sequence
                        ;
    to:
        pipeline : pipe_sequence
                        | Bang linebreak
                        | Bang pipeline
                        | Time linebreak
                        | Time pipeline
                        ;

[[Item 10 now merged into 14.]]

11. Delete the last full paragraph of the DESCRIPTION section of the
    time utility:
        When time is used as part of a pipeline, the times reported are
        unspecified, except when it is the sole command within a
        grouping command (see Section 2.9.4.1, on page 2321) in that
        pipeline. For example, the commands on the left are
        unspecified; those on the right report on utilities a and c,
        respectively:

        time a | b | c {time a; } | b | c
        a | b | time c a | b | (time c)
    from P3232, L107784-107789.

12. Add the following description of the TIMEFORMAT environment variable
    in the ENVIRONMENT VARIABLES section after P3233, L107822:
        TIMEFORMAT
                Determine the time statistics to be written and the
                format used when writing the statistics. The format of
                the TIMEFORMAT environment variable is as specified in
                Shell Variables (see section 2.5.3, on page XXX). The
                TIMEFORMAT environment variable shall be ignored if the
                -p option is specified on the command line.

13. Change the entire STDERR section on P3233, L107828-107837 (note that
    this incorporates the change specified in xcubug2.txt for ERN #184):
        Timing statistics shall be written to standard error.

        If -p is specified, the following format shall be used in the
        POSIX locale:

        "real %f\enuser %f\ensys %f\en", <real seconds>, <user seconds>,
                <system seconds>

        where each floating-point number shall be expressed in
        seconds. The precision used may be less than the default six
        digits of %f, but shall be sufficiently precise to accommodate
        the size of the clock tick on the system (for example, if there
        were 60 clock ticks per second, at least two digits shall
        follow the radix character). The number of digits following
        the radix character shall be no less than one, even if this
        always results in a trailing zero. The implementation may
        append white space and additional information following the
        format shown here, terminated by a <newline>.

        If the -p option is not specified and the TIMEFORMAT
        environment variable is not set, the information specified
        above shall be written, but the format and precision are
        unspecified.

        If the -p option is not specified and the TIMEFORMAT
        environment variable is set, the information specified by the
        TIMEFORMAT environment variable shall determine the statistics
        written and the format used.

        If the -p option is specified or the TIMEFORMAT environment
        variable is set, the implementation may also output a single
        empty line before the specified output.

14. In the APPLICATION USAGE section for time, add the following new
    paragraphs after P3234, L107860:
        Since \fBtime\fP is a reserved word in the shell command
        language, to invoke the \fItime\fP utility from the shell,
        either quote the word "time" or invoke it with an option or the
        "--" end of options indicator to prevent the shell from
        invoking the actions associated with the \fBtime\fP reserved
        word.

        Note that TIMEFORMAT needs to be an environment variable
        (that is, it needs to be exported) to have any effect on the
        \fItime\fP utility, but only needs to be a shell variable
        (it does not need to be exported) to affect \fBtime\fP
        reserved word output.

15. Replace the entire contents of the EXAMPLES section of the time
    utility on P3234, L107862-107866 with:
        The following examples use the \fBtime\fP reserved word or the
        \fItime\fP utility to time one or more elements of a pipeline:
        1. The \fBtime\fP reserved word reports the time used by
            utilities \fBa\fP, \fBb\fP, and \fBc\fP.
                \fCWtime a | b | c\fP

        2. The \fItime\fP utility reports the time used by utility
            \fBa\fP.
                \fCW"time" a | b | c\fP

        3. The \fBtime\fP reserved word reports the time used by
            utility \fBb\fP:
                \fCWa | { time b;} | c\fP

        4. The \fItime\fP utility reports the time used by utility
            \fBb\fP:
                \fCWa | time -p b | c\fP

        5. The \fBtime\fP reserved word reports the time used by
            utilities \fBb\fP and \fBc\fP:
                \fCWa | time b | c\fP

        6. Use the \fBtime\fP reserved word to capture standard error output
            from a utility in one file and the timing statistics for
            the execution of that utility in another file:
                \fCW{ time utility 2>utility_stderr;} 2>time_output\fP

        7. Use the \fItime\fP utility to capture standard error output
            from a utility and the timing statistics from the execution
            of that utility in a file:
                \fCWtime -- utility 2>time_output+utility_stderr\fP
            or
                \fCW2>time_output+utility_stderr time utility\fP

16. In the RATIONALE section for time, change the two bullets on P3234,
    L107871-107875 from: (Note that this change is fixing editorial
    glitches; not the intent of the rationale.)
        * The underlying CPU definitions from the System Interfaces
          volume of POSIX.1-2008 are vague, so the numeric output could
          not be compared accurately between systems or even between
          invocations.
        * The creation of portable benchmark programs was outside the
          scope this volume of POSIX.1-2008.
    to:
        * The underlying CPU definitions from ISO POSIX.1-1990 were
          vague, so the numeric output could not be compared accurately
          between systems or even between invocations.
        * The creation of portable benchmark programs was outside the
          scope of ISO POSIX.2-1993.

17. In the RATIONALE section for time, change the paragraph on P3234,
    L107882-107885 from:
        However, \fItime\fP does fit in the scope of user portability.
        Human judgement can be applied to the analysis of the output,
        and it could be very useful in hands-on debugging of
        applications or in providing subjective measures of system
        performance. Hence it has been included in this volume of
        POSIX.1-200x.
    to:
        However, \fItime\fP did fit in the scope of the user portability
        option. Human judgement can be applied to the analysis of the
        output, and it could be very useful in hands-on debugging of
        applications or in providing subjective measures of system
        performance. Hence it was included in the User Portability
        Utilities option of ISO POSIX.2-1993. It was moved from the
        User Portability Utilities option into the base in this
        standard.

18. In the RATIONALE section for time, change the last two paragraphs
    of the RATIONALE on P3234, L107883-107892 from:
        In the KornShell, \fItime\fP (sic) is a shell reserved word
        that can be used to time an entire pipeline, rather than just a
        simple command. The POSIX definition has been worded to allow
        this implementation. Consideration was given to invalidating
        this approach because of the historical model from the C shell
        and System V shell. However, since the System V \fItime\fP
        utility historically has not produced accurate results in
        pipeline timing (because the constituent processes are not all
        owned by the same parent process, as allowed by POSIX), it did
        not seem worthwhile to break historical KornShell usage.

        The term utility is used, rather than command, to highlight the
        fact that shell compound commands, pipelines, special
        built-ins, and so on, cannot be used directly. However,
        utility includes user application programs and shell scripts,
        not just the standard utilities.
    to:
        In the KornShell, \fBtime\fP is a shell reserved word that can
        be used to time an entire pipeline, rather than just a simple
        command. In versions of this standard before POSIX.1-201x, the
        description of the time utility was intended to be worded to
        allow this implementation. Consideration was given to
        invalidating this approach because of the historical model from
        the C shell and System V shell. However, since the System V
        \fItime\fP utility historically did not produce accurate
        results in pipeline timing (because the constituent processes
        are not all owned by the same parent process, as allowed by
        POSIX), it did not seem worthwhile to break historical
        KornShell usage. But, due to differences in file redirections
        between utilities and shell reserved words, the redirection
        requirements were ambiguous.

        The term utility is used in the description of the \fItime\fP
        utility, rather than command, to highlight the fact that shell
        compound commands, pipelines, special built-ins, and so on,
        cannot be used directly. However, utility includes user
        application programs and shell scripts, not just the standard
        utilities.

        This issue of the standard requires both a \fBtime\fP reserved
        word (see Section 2.9.2.5, on page XXX) that provides timing
        results for compound commands, pipelines, special built-ins,
        and so on) and the \fItime\fP utility described here that times
        one \fIutility\fP.

        The TIMEFORMAT shell variable was invented to control output
        from the \fBtime\fP reserved word (since reserved words don't
        accept options such as the \ftime\fP utility's -p option).
        For consistency, this standard requires that TIMEFORMAT (as
        an environment variable) also controls the output from the
        \fPtime\fP utility, when invoked without -p. If TIMEFORMAT
        is not set and -p is not used, the output format is unspecified.

The following words may be recognized as reserved words on some implementations (when none of the characters are quoted), causing unspecified results:

When used in circumstances where reserved words are recognized (described above), the following words may be recognized as reserved words, in which case the results are unspecified except as described below for time:

When the word time is recognized as a reserved word in circumstances where it would, if it were not a reserved word, be the command name (see [xref to 2.9.1.1]) of a simple command that would execute the time utility in a manner other than one for which [xref to time] states that the results are unspecified, the behavior shall be as specified for the time utility.

Words that are the concatenation of a name and a <colon> (':') are reserved; their use produces unspecified results.

When used in circumstances where reserved words are recognized (described above), all words whose final character is a <colon> (':') are reserved; their use in those circumstances produces unspecified results.

When time is used as part of a pipeline, the times reported are unspecified, except when it is the sole command within a grouping command (see [xref to 2.9.4.1]) in that pipeline. For example, the commands on the left are unspecified; those on the right report on utilities a and c, respectively:

time a | b | c    { time a; } | b | c
a | b | time c    a | b | (time c)

When time is used in any of the following circumstances, via a simple command for which the word time is the command name (see [xref to 2.9.1.1]), and none of the characters in the word time is quoted, the results (including parsing of later words) are unspecified:

• The simple command for which the word time is the command name includes one or more redirections (see [xref to 2.7]) or is (directly) part of a pipeline (see [xref to 2.9.2]).


• The next word that follows time would, if the word time were not present, be recognized as a reserved word (see [xref to 2.4]) or a control operator (see [xref to XBD 3.83]).

Since these limitations only apply when time is executed via a simple command for which the word time is the command name and none of the characters in the word time is quoted, they can be avoided by quoting all or part of the word time, by arranging for the command name not to be time (for example, by having the command name be a word expansion), or by executing time via another utility such as command or env.

The limitations on redirections and pipelines can also be overcome by embedding the simple command within a compound command--most commonly a grouping command (see [xref to 2.9.4.1])--and applying the redirections or piping to the compound command instead.

Note that in no circumstances where the results are specified is it possible to apply different redirections to the time utility than are applied to the utility it invokes.

The following examples (where a and b are assumed to be the names of utilities found by searching PATH) show unspecified usages:

time a arg1 arg2 | b    # part of a pipeline
a | time -p b           # part of a pipeline
time a >/dev/null       # output redirection
</dev/null time a       # input redirection
time while anything...  # reserved word after time
time ( cmd )            # control operator after time
time;                   # control operator after time
time shift              # special built-in utility
time -p cd /            # intrinsic utility

The following examples have specified results and can be used as alternatives for the first four of the above when the time utility as specified here is intended to be invoked:

{ time a arg1 arg2; } | b
t=time; a | $t -p b
command time a >/dev/null
</dev/null \time a

If the utility operand names any of the special built-in utilities in [xref to 2.14], the results are undefined.

If the utility operand names a special built-in utility (see [xref to 2.14]), an intrinsic utility (see [xref to 1.7]), or a function (see [xref to 2.9.5]), the results are unspecified.

This list contained time in early proposals, but it was removed when the time utility was selected for the Shell and Utilities volume of POSIX.1-202x.

Earlier versions of this standard omitted time from this list, so that the time utility could be included without requiring applications to quote all or part of its name (or use other measures) in order to avoid it being treated as a reserved word. However, although the intent was to allow the reserved word implementation (as evidenced by use of time in pipelines being unspecified, and explicit mention in the rationale of the time utility), the conditions under which the behavior was unspecified were insufficient to allow this. In particular, redirection in KornShell does not work in the normal way when time is a reserved word:

time utility 2> time.out

only writes the standard error from utility to time.out; the timing information is written to the shell's standard error, but these versions of the standard required the timing information to be written to time.out. Another issue was that if time is a reserved word, an application cannot define a function with that name, but these versions of the standard required that applications could do so. Hence time has now been added to the list of unspecified reserved words, but with its use as a reserved word limited in order to be compatible with its use as a utility in the cases where the two have traditionally had the same effect (other than possible output format differences).

The restriction on ending a name with a <colon> is to allow future implementations that support named labels for flow control; see the RATIONALE for the break built-in utility.

When used in circumstances where reserved words are recognized, all words whose final character is a <colon> (':') are reserved. The case of a name suffixed with a colon is reserved to allow implementations to support named labels for flow control; see the RATIONALE for the break special built-in utility. Other words ending in <colon> are reserved to provide implementations with a way to add new reserved words while still conforming to this standard.