Bash – Differences between reserved word and command `time` on shell builtin, function, pipeline and command list

bashtime-utility

In the Bash Reference Manual,

The use of time as a reserved word permits the timing of shell builtins, shell functions, and pipelines. An external
time command cannot time these easily.

Could you explain why the quote says that?

Is this because of the difference between a reserved word and a
command, not just limited to the case of time? For example, how does the bash shell
parse or interpret them differently?

Or is this only limited to the case of time?

In the following examples,

why does the external time work on a shell builtin, and a
pipeline, while the quote say it "cannot time these easily"?

External time on a shell builtin:

$ /usr/bin/time echo hello
hello
0.00user 0.00system 0:00.00elapsed 0%CPU (0avgtext+0avgdata 1676maxresident)k
0inputs+0outputs (0major+78minor)pagefaults 0swaps

External time on a pipeline:

$ /usr/bin/time sleep 10 | sleep 5
0.00user 0.00system 0:10.00elapsed 0%CPU (0avgtext+0avgdata 1776maxresident)k
0inputs+0outputs (0major+79minor)pagefaults 0swaps

In the following example, why does the external time on a shell
function fail? What does its error output mean?

$ function mytest () { sleep 10; }

$ /usr/bin/time mytest
/usr/bin/time: cannot run mytest: No such file or directory
Command exited with non-zero status 127
0.00user 0.00system 0:00.03elapsed 0%CPU (0avgtext+0avgdata 1252maxresident)k
32inputs+0outputs (0major+30minor)pagefaults 0swaps

It seems that the quote does not just apply to timing shell builtins,
shell functions, and pipelines, but also to timing a group of
commands:
```
$ time { echo hello; sleep 3; echo tim; }
hello
tim

real    0m3.002s
user    0m0.000s
sys 0m0.000s


$ /usr/bin/time { echo hello; sleep 3; echo tim; }
bash: syntax error near unexpected token `}'
```
Why does the shell say "bash: syntax error near unexpected token
}" in the case for command /usr/bin/time?

Best Answer

In bash, time is a reserved word, so the shell can parse it the own way and apply rules for it.

Here is the code show how bash parse line start with time reserved word:

static int
time_command_acceptable ()
{
#if defined (COMMAND_TIMING)
  int i;

  if (posixly_correct && shell_compatibility_level > 41)
    {
      /* Quick check of the rest of the line to find the next token.  If it
     begins with a `-', Posix says to not return `time' as the token.
     This was interp 267. */
      i = shell_input_line_index;
      while (i < shell_input_line_len && (shell_input_line[i] == ' ' || shell_input_line[i] == '\t'))
        i++;
      if (shell_input_line[i] == '-')
    return 0;
    }

  switch (last_read_token)
    {
    case 0:
    case ';':
    case '\n':
    case AND_AND:
    case OR_OR:
    case '&':
    case WHILE:
    case DO:
    case UNTIL:
    case IF:
    case THEN:
    case ELIF:
    case ELSE:
    case '{':       /* } */
    case '(':       /* )( */
    case ')':       /* only valid in case statement */
    case BANG:      /* ! time pipeline */
    case TIME:      /* time time pipeline */
    case TIMEOPT:   /* time -p time pipeline */
    case TIMEIGN:   /* time -p -- ... */
      return 1;
    default:
      return 0;
    }
#else
  return 0;
#endif /* COMMAND_TIMING */
}

You see, time can be followed by most others bash reserved words.

In case of external command, the normal rule was applied, { was considered input of /usr/bin/time. } alone is invalid token, and bash raise the error.

In:

/usr/bin/time echo hello

external time did not call the shell builtin echo but the external echo command.

A strace verifies that:

$ strace -fe execve /usr/bin/time echo 1
execve("/usr/bin/time", ["/usr/bin/time", "echo", "1"], [/* 64 vars */]) = 0
Process 25161 attached
....
[pid 25161] execve("/usr/bin/echo", ["echo", "1"], [/* 64 vars */]) = -1 ENOENT (No such file or directory)
[pid 25161] execve("/bin/echo", ["echo", "1"], [/* 64 vars */]) = 0
1
[pid 25161] +++ exited with 0 +++
....

Here external time lookup your PATH variable to find the command executable. That also explain in case of using a function, you got No such file or directory becasue there's no command named mytest in your PATH.

Related Solutions

Bash – Why does using `yes` on bash pipelines not cause infinite loops

When true exits, the read side of the pipe is closed, but yes continues trying to write to the write side. This condition is called a "broken pipe", and it causes the kernel to send a SIGPIPE signal to yes. Since yes does nothing special about this signal, it will be killed. If it ignored the signal, its write call would fail with error code EPIPE. Programs that do that have to be prepared to notice EPIPE and stop writing, or they will go into an infinite loop.

If you do strace yes | true¹ you can see the kernel preparing for both possibilities:

write(1, "y\ny\ny\ny\ny\ny\ny\ny\ny\ny\ny\ny\n"..., 4096) = -1 EPIPE (Broken pipe)
--- SIGPIPE {si_signo=SIGPIPE, si_code=SI_USER, si_pid=17556, si_uid=1000} ---
+++ killed by SIGPIPE +++

strace is watching events via the debugger API, which first tells it about the system call returning with an error, and then about the signal. From yes's perspective, though, the signal happens first. (Technically, the signal is delivered after the kernel returns control to user space, but before any more machine instructions are executed, so the write "wrapper" function in the C library does not get a chance to set errno and return to the application.)

¹ Sadly, strace is Linux-specific. Most modern Unixes have some command that does something similar, but it often has a different name, it probably doesn't decode syscall arguments as thoroughly, and sometimes it only works for root.

Bash – Differences between keyword, reserved word, and builtin

Keyword, reserved word, and builtin are all the "first word" of a Simple command. Could be placed in two groups: Keyword and Builtin. The two are mutually exclusive. A word (token) can be either a Keyword or a builtin, but not both.

Why the "first word"

From the POSIX definition of "Simple command"(emphasis mine):

A "simple command" is a sequence of optional variable assignments and redirections, in any sequence, optionally followed by words and redirections, terminated by a control operator.

2.- The words that are not variable assignments or redirections shall be expanded. If any fields remain following their expansion, the first field shall be considered the command name and remaining fields are the arguments for the command.

After that "first word" has been identified, and after is has been expanded (by an alias, for example) the final word is "the command", there could be only one command in each line. That command word could be a Built-in or a keyword.

Keyword

Yes, a keyword is a "reserved word". Load "man bash" and search for keyword. (or just execute this command: LESS=+/'keyword' man bash. The first hit on search say this:

keyword Shell reserved words.

It happens in the completion section, but is quite clear.

Reserved Words

In POSIX, there is this definition of "Reserved Words" and some description of what Reserved Words do.

But the bash manual has a better working definition.
Search for "RESERVED WORDS" (LESS=+/'RESERVED WORDS' man bash) and find this:

RESERVED WORDS Reserved words are words that have a special meaning to the shell.
The following words are recognized as reserved when unquoted and either the first word of a simple command or the third word of a case or for command:
! case  do done elif else esac fi for function if
in select then until while { } time [[ ]]

Builtin

It is not defined in the bash manual, but it is quite simple:

It is a command that has been implemented inside the shell for UN-avoidable needs of the shell (cd, pwd, eval), or speed in general or to avoid conflicting interpretations of external utilities in some cases.

Time is a keyword.

why is time not a builtin but a keyword?

To allow the existence of a command as the second word.

It is similar as how an if ... then .... fi allow the inclusion of commands (even compound commands) after the first key-word if. Or while or case, etc.