SH(1P)

📦 version 2017a, in alpine 3.22, alpine 3.23, alpine 3.24, arch rolling, nixpkgs unstable, opensuse-leap 16.0

SH(1P) — like, the whole entire shell, bestie 💅

okay so real talk, this is the sh page from the POSIX Programmer's Manual (that's the 1P in the corner, iykyk) ✨

🌸 PROLOG 🌸

This manual page is part of the POSIX Programmer's Manual. The Linux implementation of this interface may differ (consult the corresponding Linux manual page for details of Linux behavior), or the interface may not be implemented on Linux.

💀 yes bestie, that means what you think it means: Linux might do its own thing here. Go read the Linux page too. No cap.

🎀 NAME 🎀

sh — shell, the standard command language interpreter

✨ SYNOPSIS ✨

sh [-abCefhimnuvx] [-o option]... [+abCefhimnuvx] [+o option]...
    [command_file [argument...]]

sh -c [-abCefhimnuvx] [-o option]... [+abCefhimnuvx] [+o option]...
    command_string [command_name [argument...]]

sh -s [-abCefhimnuvx] [-o option]... [+abCefhimnuvx] [+o option]...
    [argument...]

three whole moods, bestie. pick your vibe.

🦋 DESCRIPTION 🦋

The sh utility is a command language interpreter that shall execute commands read from a command line string, the standard input, or a specified file. The application shall ensure that the commands to be executed are expressed in the language described in Chapter 2, Shell Command Language.

Pathname expansion shall not fail due to the size of a file. 🫶

Shell input and output redirections have an implementation-defined offset maximum that is established in the open file description.

💖 OPTIONS 💖

The sh utility shall conform to the Base Definitions volume of POSIX.1-2017, Section 12.2, Utility Syntax Guidelines, with an extension for support of a leading <plus-sign> ('+') as noted below. ✨

The -a, -b, -C, -e, -f, -m, -n, -o option, -u, -v, and -x options are described as part of the set utility in Section 2.14, Special Built-In Utilities. The option letters derived from the set special built-in shall also be accepted with a leading <plus-sign> ('+') instead of a leading <hyphen-minus> (meaning the reverse case of the option as described in this volume of POSIX.1-2017). 🙈

⭐ so like, +x is the ✨opposite✨ of -x. flip the sign, flip the vibe. that's the whole bit.

The following additional options shall be supported:

  • -c — Read commands from the command_string operand. Set the value of special parameter 0 (see Section 2.5.2, Special Parameters) from the value of the command_name operand and the positional parameters ($1, $2, and so on) in sequence from the remaining argument operands. No commands shall be read from the standard input. 💅
  • -i — Specify that the shell is interactive; see below. An implementation may treat specifying the -i option as an error if the real user ID of the calling process does not equal the effective user ID or if the real group ID does not equal the effective group ID.
  • -s — Read commands from the standard input.

If there are no operands and the -c option is not specified, the -s option shall be assumed. 🎀

If the -i option is present, or if there are no operands and the shell's standard input and standard error are attached to a terminal, the shell is considered to be interactive.

🧚 OPERANDS 🧚

The following operands shall be supported:

  • - — A single <hyphen-minus> shall be treated as the first operand and then ignored. If both '-' and "--" are given as arguments, or if other operands precede the single <hyphen-minus>, the results are undefined. 💀
  • argument — The positional parameters ($1, $2, and so on) shall be set to *argument*s, if any.
  • command_file — The pathname of a file containing commands. If the pathname contains one or more <slash> characters, the implementation attempts to read that file; the file need not be executable. If the pathname does not contain a <slash> character:
    • The implementation shall attempt to read that file from the current working directory; the file need not be executable.
    • If the file is not in the current working directory, the implementation may perform a search for an executable file using the value of PATH, as described in Section 2.9.1.1, Command Search and Execution.

Special parameter 0 (see Section 2.5.2, Special Parameters) shall be set to the value of command_file. If sh is called using a synopsis form that omits command_file, special parameter 0 shall be set to the value of the first argument passed to sh from its parent (for example, argv[0] for a C program), which is normally a pathname used to execute the sh utility. 🦋

  • command_name — A string assigned to special parameter 0 when executing the commands in command_string. If command_name is not specified, special parameter 0 shall be set to the value of the first argument passed to sh from its parent (for example, argv[0] for a C program), which is normally a pathname used to execute the sh utility. 🫶
  • command_string — A string that shall be interpreted by the shell as one or more commands, as if the string were the argument to the system() function defined in the System Interfaces volume of POSIX.1-2017. If the command_string operand is an empty string, sh shall exit with a zero exit status. ✨

🌈 STDIN 🌈

The standard input shall be used only if one of the following is true:

  • The -s option is specified.
  • The -c option is not specified and no operands are specified.
  • The script executes one or more commands that require input from standard input (such as a read command that does not redirect its input).

See the INPUT FILES section. 👀

When the shell is using standard input and it invokes a command that also uses standard input, the shell shall ensure that the standard input file pointer points directly after the command it has read when the command begins execution. It shall not read ahead in such a manner that any characters intended to be read by the invoked command are consumed by the shell (whether interpreted by the shell or not) or that characters that are not read by the invoked command are not seen by the shell. When the command expecting to read standard input is started asynchronously by an interactive shell, it is unspecified whether characters are read by the command or interpreted by the shell.

💀 translation: nobody's allowed to steal anybody else's bytes. no line-jumping in the group chat.

If the standard input to sh is a FIFO or terminal device and is set to non-blocking reads, then sh shall enable blocking reads on standard input. This shall remain in effect when the command completes. 🎀

💜 INPUT FILES 💜

The input file shall be a text file, except that line lengths shall be unlimited. If the input file consists solely of zero or more blank lines and comments, sh shall exit with a zero exit status. ✨

okay bestie that's the setup, keep scrolling, there's so much more 💅

🌈 ENVIRONMENT VARIABLES 🌈

okay bestie, these are the lil variables that change how sh acts. every single one matters, so we're going through them one by one, no skipping 💖

ENV

This one is so specific. When — and only when — an interactive shell is invoked, ENV gets subjected to parameter expansion (see Section 2.6.2, Parameter Expansion) by the shell, and the resulting value is used as a pathname of a file containing shell commands to execute in the current environment. The file does not need to be executable. If the expanded value of ENV is not an absolute pathname, the results are unspecified (aka don't do that 🙈). And ENV shall be ignored if the real and effective user IDs or real and effective group IDs of the process are different.

FCEDIT

When the shell expands this, it determines the default value for the -e editor option's editor option-argument. If FCEDIT is null or unset, ed shall be used as the editor. periodt.

HISTFILE

Determines a pathname naming a command history file. If the HISTFILE variable is not set, the shell may attempt to access or create a file .sh_history in the directory referred to by the HOME environment variable. If the shell cannot obtain both read and write access to, or create, the history file, it shall use an unspecified mechanism that allows the history to operate properly. (References to history "file" in this section shall be understood to mean this unspecified mechanism in such cases.) An implementation may choose to access this variable only when initializing the history file; this initialization shall occur when fc or sh first attempt to retrieve entries from, or add entries to, the file, as the result of commands issued by the user, the file named by the ENV variable, or implementation-defined system start-up files. Implementations may choose to disable the history list mechanism for users with appropriate privileges who do not set HISTFILE; the specific circumstances under which this occurs are implementation-defined. If more than one instance of the shell is using the same history file, it is unspecified how updates to the history file from those shells interact. As entries are deleted from the history file, they shall be deleted oldest first. It is unspecified when history file entries are physically removed from the history file. 😭

HISTSIZE

Determines a decimal number representing the limit to the number of previous commands that are accessible. If this variable is unset, an unspecified default greater than or equal to 128 shall be used. The maximum number of commands in the history list is unspecified, but shall be at least 128. An implementation may choose to access this variable only when initializing the history file, as described under HISTFILE. Therefore, it is unspecified whether changes made to HISTSIZE after the history file has been initialized are effective. 🦋

HOME

Determines the pathname of the user's home directory. The contents of HOME are used in tilde expansion as described in Section 2.6.1, Tilde Expansion. (yes bestie, that's the ~ magic ✨)

LANG

Provides a default value for the internationalization variables that are unset or null. (See the Base Definitions volume of POSIX.1‐2017, Section 8.2, Internationalization Variables for the precedence of internationalization variables used to determine the values of locale categories.)

LC_ALL

If set to a non-empty string value, override the values of all the other internationalization variables. it's giving main character energy fr.

LC_COLLATE

Determines the behavior of range expressions, equivalence classes, and multi-character collating elements within pattern matching.

LC_CTYPE

Determines the locale for the interpretation of sequences of bytes of text data as characters (for example, single-byte as opposed to multi-byte characters in arguments and input files), which characters are defined as letters (character class alpha), and the behavior of character classes within pattern matching.

LC_MESSAGES

Determines the locale that should be used to affect the format and contents of diagnostic messages written to standard error.

MAIL

Determines a pathname of the user's mailbox file for purposes of incoming mail notification. If this variable is set, the shell shall inform the user if the file named by the variable is created or if its modification time has changed. Informing the user shall be accomplished by writing a string of unspecified format to standard error prior to the writing of the next primary prompt string. Such check shall be performed only after the completion of the interval defined by the MAILCHECK variable after the last such check. The user shall be informed only if MAIL is set and MAILPATH is not set. 👑

MAILCHECK

Establishes a decimal integer value that specifies how often (in seconds) the shell shall check for the arrival of mail in the files specified by the MAILPATH or MAIL variables. The default value shall be 600 seconds. If set to zero, the shell shall check before issuing each primary prompt.

MAILPATH

Provides a list of pathnames and optional messages separated by <colon> characters. If this variable is set, the shell shall inform the user if any of the files named by the variable are created or if any of their modification times change. (See the preceding entry for MAIL for descriptions of mail arrival and user informing.) Each pathname can be followed by % and a string that shall be subjected to parameter expansion and written to standard error when the modification time changes. If a % character in the pathname is preceded by a <backslash>, it shall be treated as a literal % in the pathname. The default message is unspecified.

The MAILPATH environment variable takes precedence over the MAIL variable.

NLSPATH

Determines the location of message catalogs for the processing of LC_MESSAGES.

PATH

Establishes a string formatted as described in the Base Definitions volume of POSIX.1‐2017, Chapter 8, Environment Variables, used to effect command interpretation; see Section 2.9.1.1, Command Search and Execution. (this is the one that decides where your commands even live, iconic 💅)

PWD

This variable shall represent an absolute pathname of the current working directory. Assignments to this variable may be ignored.

💀 ASYNCHRONOUS EVENTS 💀

The sh utility shall take the standard action for all signals (see Section 1.4, Utility Description Defaults) with the following exceptions.

If the shell is interactive, SIGINT signals received during command line editing shall be handled as described in the EXTENDED DESCRIPTION, and SIGINT signals received at other times shall be caught but no action performed.

If the shell is interactive:

  • SIGQUIT and SIGTERM signals shall be ignored.
  • If the -m option is in effect, SIGTTIN, SIGTTOU, and SIGTSTP signals shall be ignored.
  • If the -m option is not in effect, it is unspecified whether SIGTTIN, SIGTTOU, and SIGTSTP signals are ignored, set to the default action, or caught. If they are caught, the shell shall, in the signal-catching function, set the signal to the default action and raise the signal (after taking any appropriate steps, such as restoring terminal settings).

The standard actions, and the actions described above for interactive shells, can be overridden by use of the trap special built-in utility (see trap and Section 2.11, Signals and Error Handling). 🔥

✨ STDOUT ✨

See the STDERR section.

🌸 STDERR 🌸

Except as otherwise stated (by the descriptions of any invoked utilities or in interactive mode), standard error shall be used only for diagnostic messages.

🎀 OUTPUT FILES 🎀

None. (literally nothing, that's the whole vibe 🫶)

🦋 EXTENDED DESCRIPTION 🦋

See Chapter 2, Shell Command Language. The functionality described in the rest of the EXTENDED DESCRIPTION section shall be provided on implementations that support the User Portability Utilities option (and the rest of this section is not further shaded for this option).

Command History List

When the sh utility is being used interactively, it shall maintain a list of commands previously entered from the terminal in the file named by the HISTFILE environment variable. The type, size, and internal format of this file are unspecified. Multiple sh processes can share access to the file for a user, if file access permissions allow this; see the description of the HISTFILE environment variable.

Command Line Editing

When sh is being used interactively from a terminal, the current command and the command history (see fc) can be edited using vi-mode command line editing. This mode uses commands, described below, similar to a subset of those described in the vi utility. Implementations may offer other command line editing modes corresponding to other editing utilities.

The command set -o vi shall enable vi-mode editing and place sh into vi insert mode (see Command Line Editing (vi-mode)). This command also shall disable any other editing mode that the implementation may provide. The command set +o vi disables vi-mode editing.

Certain block-mode terminals may be unable to support shell command line editing. If a terminal is unable to provide either edit mode, it need not be possible to set -o vi when using the shell on this terminal.

In the following sections, the characters erase, interrupt, kill, and end-of-file are those set by the stty utility. 🌈

Command Line Editing (vi-mode)

In vi editing mode, there shall be a distinguished line, the edit line. All the editing operations which modify a line affect the edit line. The edit line is always the newest line in the command history buffer.

With vi-mode enabled, sh can be switched between insert mode and command mode.

When in insert mode, an entered character shall be inserted into the command line, except as noted in vi Line Editing Insert Mode. Upon entering sh and after termination of the previous command, sh shall be in insert mode. 💜

Okay so typing an escape character flips sh into command mode (peep vi Line Editing Command Mode for the tea). Once you're in command mode, every character you type is gonna do one of three things: invoke a defined operation, be used as part of a multi-character operation, or just get treated as an error. And a character that isn't recognized as part of an editing command? It terminates whatever specific editing command was going on and alerts the terminal. Rude but valid. 🔔

If sh catches a SIGINT while it's in command mode (whether that came from you typing the interrupt character or from literally anywhere else), it shall terminate command line editing on the current command line, reissue the prompt on the next line of the terminal, and reset the command history (see fc) so that the most recently executed command becomes the previous command — meaning the command that was being edited when it got interrupted does not get re-entered into the history. Sorry bestie, it's gone. 💀

Quick vocab check before we go any further, because these phrases come up a lot:

  • "move the cursor to the beginning of the word" — that means move the cursor to the first character of the current word.
  • "move the cursor to the end of the word" — that means move the cursor to the last character of the current word.
  • "beginning of the command line" — that's the point between the end of the prompt string the shell issued (or the beginning of the terminal line, if there's no prompt string) and the first character of the command text.

vi Line Editing Insert Mode

While you're in insert mode, any character you type gets inserted into the current command line — unless it's one of these special ones, bestie. 🫶

  • <newline> — Execute the current command line. If the current command line isn't empty, this line shall be entered into the command history (see fc).
  • erase — Delete the character previous to the current cursor position and move the cursor back one character. In insert mode, characters shall be erased from both the screen and the buffer when you're backspacing. Bye bye, both places.
  • interrupt — If sh receives a SIGINT signal in insert mode (whether you generated it by typing the interrupt character or by other means), it shall terminate command line editing with the same effects as described for interrupting command mode; see Command Line Editing (vi-mode).
  • kill — Clear all the characters from the input line. Just, all of them. Poof. ✨
  • <control>-V — Insert the next character input, even if that character is otherwise a special insert mode character. This is your escape hatch for typing the weird stuff.
  • <control>-W — Delete the characters from the one preceding the cursor to the preceding word boundary. The word boundary here is whichever is closer to the cursor: the beginning of the line, or a character that's in neither the blank nor the punct character classification of the current locale.
  • end-of-file — Interpreted as the end of input in sh. This interpretation shall occur only at the beginning of an input line. If end-of-file is entered other than at the beginning of the line, the results are unspecified. 👀
  • <ESC> — Place sh into command mode. Vroom.

vi Line Editing Command Mode

So in command mode for the command line editing feature: decimal digits that don't begin with 0 and that come before a command letter shall be remembered. Some commands use these decimal digits as a count number that affects the operation. Cute, right? 🔢

The term motion command represents one of these bad boys:

<space>  0  b  F  l  W  ^  $  ;  E  f  T  w  |  ,  B  e  h  t

Now listen. If the current line is not the edit line, any command that modifies the current line shall cause the content of the current line to replace the content of the edit line, and the current line shall become the edit line. This replacement cannot be undone (see the u and U commands below). The modification you asked for shall then be performed on the edit line. When the current line is the edit line, the modification just gets done directly to the edit line. Simple as that. 💅

Any command that's preceded by a count shall take a count (that's the numeric value of any preceding decimal digits). Unless otherwise noted, this count shall cause the specified operation to repeat by the number of times specified by the count. And also unless otherwise noted, a count that's out of range is considered an error condition and shall alert the terminal — but neither the cursor position nor the command line shall change. So no chaos, just a little beep. 📣

The terms word and bigword are used as defined in the vi description. The term save buffer corresponds to the term unnamed buffer in vi.

These are the commands recognized in command mode:

  • <newline> — Execute the current command line. If the current command line isn't empty, this line shall be entered into the command history (see fc).
  • <control>-L — Redraw the current command line, and position the cursor at the same location on the redrawn line. A lil refresh for the girlies. 🌸
  • # — Insert the character '#' at the beginning of the current command line and treat the resulting edit line as a comment. This line shall be entered into the command history; see fc.
  • = — Display the possible shell word expansions (see Section 2.6, Word Expansions) of the bigword at the current command line position.
Note: This does not modify the content of the current line, and therefore does not cause the current line to become the edit line. Iconic behaviour, honestly.

These expansions shall be displayed on subsequent terminal lines. If the bigword contains none of the characters '?', '*', or '[', an <asterisk> ('*') shall be implicitly assumed at the end. If any directories are matched, these expansions shall have a '/' character appended. After the expansion, the line shall be redrawn, the cursor repositioned at the current cursor position, and sh shall be placed in command mode.

  • \ — Perform pathname expansion (see Section 2.6.6, Pathname Expansion) on the current bigword, up to the largest set of characters that can be matched uniquely. If the bigword contains none of the characters '?', '*', or '[', an <asterisk> ('*') shall be implicitly assumed at the end. This maximal expansion then shall replace the original bigword in the command line, and the cursor shall be placed after this expansion. If the resulting bigword completely and uniquely matches a directory, a '/' character shall be inserted directly after the bigword. If some other file is completely matched, a single <space> shall be inserted after the bigword. After this operation, sh shall be placed in insert mode.
  • * — Perform pathname expansion on the current bigword and insert all expansions into the command to replace the current bigword, with each expansion separated by a single <space>. If at the end of the line, the current cursor position shall be moved to the first column position following the expansions and sh shall be placed in insert mode. Otherwise, the current cursor position shall be the last column position of the first character after the expansions and sh shall be placed in insert mode. If the current bigword contains none of the characters '?', '*', or '[' before the operation, an <asterisk> ('*') shall be implicitly assumed at the end.
  • @letter — Insert the value of the alias named _letter. The symbol letter represents a single alphabetic character from the portable character set; implementations may support additional characters as an extension. If the alias _letter contains other editing commands, these commands shall be performed as part of the insertion. If no alias _letter is enabled, this command shall have no effect. (No alias, no drama. 🧚)
  • [count]~ — Convert, if the current character is a lowercase letter, to the equivalent uppercase letter and vice versa, as prescribed by the current locale. The current cursor position then shall be advanced by one character. If the cursor was positioned on the last character of the line, the case conversion shall occur, but the cursor shall not advance. If the '~' command is preceded by a count, that number of characters shall be converted, and the cursor shall be advanced to the character position after the last character converted. If the count is larger than the number of characters after the cursor, this shall not be considered an error; the cursor shall advance to the last character on the line.
  • [count]. — Repeat the most recent non-motion command, even if it was executed on an earlier command line. If the previous command was preceded by a count, and no count is given on the '.' command, the count from the previous command shall be included as part of the repeated command. If the '.' command is preceded by a count, this shall override any count argument to the previous command. The count specified in the '.' command shall become the count for subsequent '.' commands issued without a count. Yeah, it's a whole thing. 🔁
  • [number]v — Invoke the vi editor to edit the current command line in a temporary file. When the editor exits, the commands in the temporary file shall be executed and placed in the command history. If a number is included, it specifies the command number in the command history to be edited, rather than the current command line.
  • [count]l — (that's ell, bestie)
  • [count]<space> — Move the current cursor position to the next character position. If the cursor was positioned on the last character of the line, the terminal shall be alerted and the cursor shall not be advanced. If the count is larger than the number of characters after the cursor, this shall not be considered an error; the cursor shall advance to the last character on the line.
  • [count]h — Move the current cursor position to the *count*th (default 1) previous character position. If the cursor was positioned on the first character of the line, the terminal shall be alerted and the cursor shall not be moved. If the count is larger than the number of characters before the cursor, this shall not be considered an error; the cursor shall move to the first character on the line.
  • [count]w — hop to the start of the next word. But if your cursor was already parked on the last character of the line? The terminal gets alerted and the cursor does not advance, bestie. And if count is bigger than the number of words left after the cursor — that is not an error, okay, nobody's in trouble — the cursor just lands on the last character of the line. Slay.
  • [count]W — same energy as w but for bigwords. Move to the start of the next bigword. Cursor on the last character of the line → terminal alerted, cursor doesn't advance. count bigger than the bigwords after the cursor → not an error, cursor goes to the last character on the line. 💅
  • [count]e — move to the end of the current word. Already at the end of a word? Then it's giving "move to the end of the next word." Cursor on the last character of the line → terminal alerted, no advancing. count bigger than the words after the cursor → not an error, cursor advances to the last character on the line. 🌸
  • [count]E — the bigword version, obviously. Move to the end of the current bigword; if you're already at the end of a bigword, move to the end of the next one. Cursor on the last character of the line → terminal alerted, cursor stays put. count bigger than the bigwords after the cursor → not an error, cursor advances to the last character on the line. ✨
  • [count]b — backwards girlie behavior: move to the beginning of the current word. At the beginning of a word already? Move to the beginning of the previous word. Cursor on the first character of the line → terminal alerted and the cursor shall not be moved. count bigger than the words before the cursor → not an error, the cursor returns to the first character on the line. 🦋
  • [count]B — bigword edition of b. Move to the beginning of the current bigword; if you're already there, move to the beginning of the previous bigword. Cursor on the first character of the line → terminal alerted, cursor shall not be moved. count bigger than the bigwords preceding the cursor → not an error, cursor returns to the first character on the line. 💖
  • ^ — jump the cursor to the first character on the input line that is not a <blank>. Simple. Iconic. No notes.
  • $ — move to the last character position on the current command line. That's it, that's the whole vibe. 👑
  • 0 — (Zero, babes.) Move to the first character position on the current command line.
  • [count]| — move to the countth character position on the current command line. No number given? Then move to the first position. And the first character position is numbered 1. If count is bigger than the number of characters on the line → not an error, the cursor just gets placed on the last character on the line. 🎀
  • [count]fc — move to the first occurrence of the character 'c' that shows up after the current cursor position. If the cursor was on the last character of the line → terminal alerted, cursor shall not be advanced. If 'c' doesn't occur in the line after the cursor position → terminal alerted and the cursor shall not be moved. No luck, no cursor movement, that's the rule. 💀
  • [count]Fc — same but backwards: move to the first occurrence of the character 'c' that occurs before the current cursor position. Cursor on the first character of the line → terminal alerted, cursor shall not be moved. 'c' not found before the cursor → terminal alerted and the cursor shall not be moved. 😭
  • [count]tc — the sneaky one: move to the character before the first occurrence of the character 'c' that occurs after the current cursor position. Cursor on the last character of the line → terminal alerted, cursor shall not be advanced. 'c' missing after the cursor → terminal alerted and the cursor shall not be moved. 🍓
  • [count]Tc — move to the character after the first occurrence of the character 'c' that occurs before the current cursor position. Cursor on the first character of the line → terminal alerted, cursor shall not be moved. 'c' missing before the cursor → terminal alerted and the cursor shall not be moved. 🌈
  • [count]; — repeat the most recent f, F, t, or T command. Any number argument on that previous command shall be ignored. The errors are exactly the ones described for the repeated command — so whatever that command would've complained about, you get. 🔁
  • [count], — also repeats the most recent f, F, t, or T command, and any number argument on that previous command shall be ignored. The twist: it reverses the direction of that command. Same errors as the repeated command. 🌀
  • a — enter insert mode after the current cursor position. Characters you type get inserted before the next character. Lowkey the most-used one, fr fr.
  • A — enter insert mode after the end of the current command line. That's the whole thing. Periodt.
  • i — enter insert mode at the current cursor position. Characters entered get inserted before the current character.
  • I — enter insert mode at the beginning of the current command line. 🫶
  • R — enter insert mode, replacing characters from the command line beginning at the current cursor position. Destructive girlie behavior, be careful. 🙈
  • [count]cmotion — okay this one's a whole thing, stay with me. Delete the characters between the current cursor position and the cursor position that would result from the specified motion command. Then enter insert mode before the first character following any deleted characters. If count is specified, it shall be applied to the motion command.

A count shall be ignored for the following motion commands:

  • 0
  • ^
  • $
  • c

If the motion command is the character 'c', the current command line shall be cleared and insert mode shall be entered. If the motion command would move the current cursor position toward the beginning of the command line, the character under the current cursor position shall not be deleted. If the motion command would move the current cursor position toward the end of the command line, the character under the current cursor position shall be deleted. If count is larger than the number of characters between the current cursor position and the end of the command line toward which the motion command would move the cursor → not an error; all of the remaining characters in the aforementioned range shall be deleted and insert mode shall be entered. And if the motion command is invalid? Terminal alerted, cursor shall not be moved, and no text shall be deleted. 💅

  • C — delete from the current character to the end of the line, then enter insert mode at the new end-of-line. Chef's kiss. 🔥
  • S — clear the entire edit line and enter insert mode. Fresh start, main character energy.
  • [count]rc — replace the current character with the character 'c'. With a number count, replace the current character and the following count-1 characters. After this command, the current cursor position shall be on the last character that was changed. If count is larger than the number of characters after the cursor → not an error; all of the remaining characters shall be changed. 💜
  • [count]_ — append a <space> after the current character position, and then append the last bigword in the previous input line after that <space>. Then enter insert mode after the last character just appended. With a number count, append the countth bigword in the previous line. ⭐
  • [count]x — delete the character at the current cursor position and place the deleted characters in the save buffer. If the cursor was positioned on the last character of the line, the character shall be deleted and the cursor position shall be moved to the previous character (the new last character). If count is larger than the number of characters after the cursor → not an error; all the characters from the cursor to the end of the line shall be deleted. ✂️
  • [count]X — delete the character before the current cursor position and place the deleted characters in the save buffer. The character under the current cursor position shall not change. If the cursor was positioned on the first character of the line, the terminal shall be alerted and the X command shall have no effect. If the line contained a single character, the X command shall have no effect. If the line contained no characters, the terminal shall be alerted and the cursor shall not be moved. If count is larger than the number of characters before the cursor → not an error; all the characters from before the cursor to the beginning of the line shall be deleted. 🧚
  • [count]dmotion — okay so this deletes every character between where your cursor is rn and wherever that motion command would land you. A count just repeats the motion command that many times, no biggie. BUT if the motion is heading back toward the beginning of the command line, the character sitting under your cursor right now does not get deleted, periodt. If the motion command is literally d, the whole current command line gets wiped clean. And if count is bigger than the number of characters between your cursor and the end of the line in the direction the motion would go? That is NOT an error, bestie — everything left in that range just gets deleted. All the deleted characters land in the save buffer 💾.
  • D — deletes everything from your cursor to the end of the line. Everything deleted goes into the save buffer. Simple, iconic, done ✨.
  • [count]ymotion — yank (aka copy, aka the "I'm not deleting anything I promise" move 💅) the characters from your current cursor position to wherever the motion command lands, straight into the save buffer. count gets applied to the motion command. If the motion would move toward the beginning of the command line, the character under your cursor does not get included in the yanked set. If the motion command is y, the entire current command line gets yanked into the save buffer. Your cursor position stays exactly where it was, untouched. And if count is larger than the characters between your cursor and the end of the line toward which the motion goes, that's not an error — everything remaining in that range gets yanked anyway 🫶.
  • Y — yanks from your cursor to the end of the line into the save buffer. Current character position stays unchanged. Chef's kiss 👑.
  • [count]p — puts a copy of whatever's currently in the save buffer after your cursor position. Your cursor then advances to the last character that got put from the save buffer. count tells you how many copies of the save buffer get put. Repeat behavior, we love to see it 💖.
  • [count]P — same energy but it puts a copy of the save buffer before your cursor position. Cursor moves to the last character put from the save buffer. count = how many copies get put 🌸.
  • u — undoes the last command that changed the edit line. Important caveat though: this does not undo the copy of any command line to the edit line. Read that twice, bestie 👀.
  • U — undoes all the changes made to the edit line. Same caveat: it does not undo the copy of any command line to the edit line 🚫.
  • [count]k and [count]- — sets the current command line to be the *count*th previous command line in the shell command history. No count? Defaults to 1. Cursor goes to the first character of the new command. Now here's the vibe check: if a k or - command would retreat past the maximum number of commands in effect for this shell (this is affected by the HISTSIZE environment variable, iykyk), the terminal gets alerted and the command does absolutely nothing 😭.
  • [count]j and [count]+ — sets the current command line to the *count*th next command line in the shell command history. No count? Defaults to 1. Cursor lands on the first character of the new command. If a j or + advances past the edit line, the current command line gets restored back to the edit line and the terminal gets alerted 📢.
  • [number]G — sets the current command line to the oldest command line stored in the shell command history. With a number number, it sets the current command line to that command line number in the history. If that command line number doesn't exist, the terminal gets alerted and the command line stays unchanged 💀.
  • /pattern<newline> — moves backwards through the command history, searching for the specified pattern, starting from the previous command line. Patterns use the pattern matching notation from Section 2.13, Pattern Matching Notation — except the '^' character has special meaning when it shows up as the first character of pattern. In that case the '^' gets discarded and the characters after it only match at the beginning of a line. Commands in the command history are treated as strings, not as filenames, no cap. If the pattern isn't found, the current command line stays unchanged and the terminal gets alerted. If it is found in a previous line, the current command line gets set to that line and the cursor gets set to the first character of the new command line ✨.

If pattern is empty, the last non-empty pattern given to / or ? gets used. And if there's no previous non-empty pattern at all, the terminal gets alerted and the current command line remains unchanged 🙈.

  • ?pattern<newline> — moves forwards through the command history, searching for the specified pattern, starting from the next command line. Patterns use the pattern matching notation from Section 2.13, Pattern Matching Notation — except the '^' character has special meaning when it appears as the first character of pattern. Then the '^' is discarded and the characters after it only match at the beginning of a line. Commands in the command history are treated as strings, not as filenames. If the pattern isn't found, the current command line stays unchanged and the terminal gets alerted. If it's found in a following line, the current command line gets set to that line and the cursor gets set to the fist character of the new command line.

If pattern is empty, the last non-empty pattern provided to / or ? gets used. If there's no previous non-empty pattern, the terminal gets alerted and the current command line stays unchanged 🦋.

  • n — repeats the most recent / or ? command. No previous / or ?? Terminal gets alerted, current command line stays unchanged 🎀.
  • N — repeats the most recent / or ? command but reversing the direction of the search. No previous / or ?? Terminal gets alerted, current command line stays unchanged 🌈.

💀 EXIT STATUS 💀

Okay bestie, here's what the shell hands back to you:

  • 0 — the script to be executed consisted solely of zero or more blank lines or comments, or both. A vibe, honestly ⭐.
  • 1-125 — a non-interactive shell detected an error other than command_file not found or executable, including but not limited to syntax, redirection, or variable assignment errors. Oops 😬.
  • 126 — a specified command_file could not be executed due to an [ENOEXEC] error (see Section 2.9.1.1, Command Search and Execution, item 2).
  • 127 — a specified command_file could not be found by a non-interactive shell. She's not there, babe 🔍.

Otherwise, the shell shall return the exit status of the last command it invoked or attempted to invoke (see also the exit utility in Section 2.14, Special Built-In Utilities).

🚨 CONSEQUENCES OF ERRORS 🚨

See Section 2.8.1, Consequences of Shell Errors.

The following sections are informative.

🌸 APPLICATION USAGE 🌸

Standard input and standard error are the files that determine whether a shell is interactive when -i is not specified. For example:

sh > file

and:

sh 2> file

create interactive and non-interactive shells, respectively. Both of them accept terminal input, sure — but the results of error conditions are different, as described in Section 2.8.1, Consequences of Shell Errors. In that second example, a redirection error encountered by a special built-in utility aborts the shell. Yeah. Aborts. Gone. 💀

A conforming application must protect its first operand, if it starts with a <plus-sign>, by preceding it with the "--" argument that denotes the end of the options. Protect your operands, bestie 🛡️.

Applications should note that the standard PATH to the shell cannot be assumed to be either /bin/sh or /usr/bin/sh, and should be determined by interrogation of the PATH returned by getconf PATH, making sure the returned pathname is an absolute pathname and not a shell built-in. No assumptions, no cap 👑.

For example, to determine the location of the standard sh utility:

command -v sh

On some implementations this might return:

/usr/xpg4/bin/sh

Furthermore, on systems that support executable scripts (the "#!" construct), it is recommended that applications using executable scripts install them using getconf PATH to determine the shell pathname and update the "#!" script appropriately as it is being installed (for example, with sed). For example:

#
# Installation time script to install correct POSIX shell pathname
#
# Get list of paths to check
#
Sifs=$IFS
Sifs_set=${IFS+y}
IFS=:
set -- $(getconf PATH)
if [ "$Sifs_set" = y ]
then
    IFS=$Sifs
else
    unset IFS
fi
#
# Check each path for 'sh'
#
for i
do
    if [ -x "${i}"/sh ]
    then
        Pshell=${i}/sh
    fi
done
#
# This is the list of scripts to update. They should be of the
# form '${name}.source' and will be transformed to '${name}'.
# Each script should begin:
#
# #!INSTALLSHELLPATH
#
scripts="a b c"
#
# Transform each script
#
for i in ${scripts}
do
    sed -e "s|INSTALLSHELLPATH|${Pshell}|" < ${i}.source > ${i}
done

✨ EXAMPLES ✨

  1. Execute a shell command from a string:
sh -c "cat myfile"
  1. Execute a shell script from a file in the current directory:
sh my_shell_cmds

🧠 RATIONALE (aka the "why is it like this" tea) 🫖

Okay bestie, gather round, because the sh utility and the set special built-in utility share a common set of options. That's the whole vibe there. ✨

The name IFS was originally an abbreviation of ``Input Field Separators''; however, this name is misleading as the IFS characters are actually used as field terminators. One justification for ignoring the contents of IFS upon entry to the script, beyond security considerations, is to assist possible future shell compilers. Allowing IFS to be imported from the environment prevents many optimizations that might otherwise be performed via dataflow analysis of the script itself. No cap. 💅

The text in the STDIN section about non-blocking reads concerns an instance of sh that has been invoked, probably by a C-language program, with standard input that has been opened using the O_NONBLOCK flag; see open() in the System Interfaces volume of POSIX.1‐2017. If the shell did not reset this flag, it would immediately terminate because no input data would be available yet and that would be considered the same as end-of-file. 😭

The options associated with a restricted shell (command name rsh and the -r option) were excluded because the standard developers considered that the implied level of security could not be achieved and they did not want to raise false expectations. 🚫

On systems that support set-user-ID scripts, a historical trapdoor has been to link a script to the name -i. When it is called by a sequence such as:

sh -

or by:

#! usr/bin/sh -

the historical systems have assumed that no option letters follow. Thus, this volume of POSIX.1‐2017 allows the single <hyphen-minus> to mark the end of the options, in addition to the use of the regular -- argument, because it was considered that the older practice was so pervasive. An alternative approach is taken by the KornShell, where real and effective user/group IDs must match for an interactive shell; this behavior is specifically allowed by this volume of POSIX.1‐2017. 👑

Note: There are other problems with set-user-ID scripts that the two approaches described here do not resolve. 💀

The initialization process for the history file can be dependent on the system start-up files, in that they may contain commands that effectively preempt the user's settings of HISTFILE and HISTSIZE. For example, function definition commands are recorded in the history file, unless the set -o nolog option is set. If the system administrator includes function definitions in some system start-up file called before the ENV file, the history file is initialized before the user gets a chance to influence its characteristics. In some historical shells, the history file is initialized just after the ENV file has been processed. Therefore, it is implementation-defined whether changes made to HISTFILE after the history file has been initialized are effective. 🙈

The default messages for the various MAIL-related messages are unspecified because they vary across implementations. Typical messages are:

"you have mail\n"

or:

"you have new mail\n"

It is important that the descriptions of command line editing refer to the same shell as that in POSIX.1‐2008 so that interactive users can also be application programmers without having to deal with programmatic differences in their two environments. It is also essential that the utility name sh be specified because this explicit utility name is too firmly rooted in historical practice of application programs for it to change. 🦋

Consideration was given to mandating a diagnostic message when attempting to set vi-mode on terminals that do not support command line editing. However, it is not historical practice for the shell to be cognizant of all terminal types and thus be able to detect inappropriate terminals in all cases. Implementations are encouraged to supply diagnostics in this case whenever possible, rather than leaving the user in a state where editing commands work incorrectly. 😬

In early proposals, the KornShell-derived emacs mode of command line editing was included, even though the emacs editor itself was not. The community of emacs proponents was adamant that the full emacs editor not be standardized because they were concerned that an attempt to standardize this very powerful environment would encourage vendors to ship strictly conforming versions lacking the extensibility required by the community. The author of the original emacs program also expressed his desire to omit the program. Furthermore, there were a number of historical systems that did not include emacs, or included it without supporting it, but there were very few that did not include and support vi. The shell emacs command line editing mode was finally omitted because it became apparent that the KornShell version and the editor being distributed with the GNU system had diverged in some respects. The author of emacs requested that the POSIX emacs mode either be deleted or have a significant number of unspecified conditions. Although the KornShell author agreed to consider changes to bring the shell into alignment, the standard developers decided to defer specification at that time. At the time, it was assumed that convergence on an acceptable definition would occur for a subsequent draft, but that has not happened, and there appears to be no impetus to do so. In any case, implementations are free to offer additional command line editing modes based on the exact models of editors their users are most comfortable with. 🎀

Early proposals had the following list entry in vi Line Editing Insert Mode:

  • \ — If followed by the erase or kill character, that character shall be inserted into the input line. Otherwise, the <backslash> itself shall be inserted into the input line.

However, this is not actually a feature of sh command line editing insert mode, but one of some historical terminal line drivers. Some conforming implementations continue to do this when the stty iexten flag is set. 🌀

In interactive shells, SIGTERM is ignored so that kill 0 does not kill the shell, and SIGINT is caught so that wait is interruptible. If the shell does not ignore SIGTTIN, SIGTTOU, and SIGTSTP signals when it is interactive and the -m option is not in effect, these signals suspend the shell if it is not a session leader. If it is a session leader, the signals are discarded if they would stop the process, as required by the System Interfaces volume of POSIX.1‐2017, Section 2.4.3, Signal Actions for orphaned process groups. 🔥

🔮 FUTURE DIRECTIONS

None. That's it. Nothing coming. The future is empty, bestie. 🫶

👀 SEE ALSO

  • Section 2.9.1.1, Command Search and Execution, Chapter 2, Shell Command Language, cd, echo, exit, fc, pwd, invalid, set, stty, test, trap, umask, vi
  • The Base Definitions volume of POSIX.1‐2017, Chapter 8, Environment Variables, Section 12.2, Utility Syntax Guidelines
  • The System Interfaces volume of POSIX.1‐2017, dup(), exec, exit(), fork(), open(), pipe(), signal(), system(), ulimit(), umask(), wait()

Portions of this text are reprinted and reproduced in electronic form from IEEE Std 1003.1-2017, Standard for Information Technology -- Portable Operating System Interface (POSIX), The Open Group Base Specifications Issue 7, 2018 Edition, Copyright (C) 2018 by the Institute of Electrical and Electronics Engineers, Inc and The Open Group. In the event of any discrepancy between this version and the original IEEE and The Open Group Standard, the original IEEE and The Open Group Standard is the referee document. The original Standard can be obtained online at http://www.opengroup.org/unix/online.html . 🌈

Any typographical or formatting errors that appear in this page are most likely to have been introduced during the conversion of the source files to man page format. To report such errors, see https://www.kernel.org/doc/man-pages/reporting_bugs.html . 🐛

And that's a wrap on sh(1P), bestie!! This lil masterpiece comes from the IEEE/The Open Group, dated 2017, and you just read the whole thing like the main character you are. Go forth and shell script responsibly, ily, mwah 💖🎀✨

📦 where this page comes from