Unix shell

Last updated
tcsh and sh shell windows on a Mac OS X Leopard desktop Tcsh ejecutandose en escritorio Mac OSX.png
tcsh and sh shell windows on a Mac OS X Leopard desktop

A Unix shell is a command-line interpreter or shell that provides a command line user interface for Unix-like operating systems. The shell is both an interactive command language and a scripting language, and is used by the operating system to control the execution of the system using shell scripts. [2]

Contents

Users typically interact with a Unix shell using a terminal emulator; however, direct operation via serial hardware connections or Secure Shell are common for server systems. All Unix shells provide filename wildcarding, piping, here documents, command substitution, variables and control structures for condition-testing and iteration.

Concept

Generally, a shell is a program that executes other programs in response to text commands. A sophisticated shell can also change the environment in which other programs execute by passing named variables, a parameter list, or an input source.

In Unix-like operating systems, users typically have many choices of command-line interpreters for interactive sessions. When a user logs into the system interactively, a shell program is automatically executed for the duration of the session. The type of shell, which may be customized for each user, is typically stored in the user's profile, for example in the local passwd file or in a distributed configuration system such as NIS or LDAP; however, the user may execute any other available shell interactively.

On operating systems with a windowing system, such as macOS and desktop Linux distributions, some users may never use the shell directly. On Unix systems, the shell has historically been the implementation language of system startup scripts, including the program that starts a windowing system, configures networking, and many other essential functions. However, some system vendors have replaced the traditional shell-based startup system (init) with different approaches, such as systemd.

Early shells

The first Unix shell was the Thompson shell, sh, written by Ken Thompson at Bell Labs and distributed with Versions 1 through 6 of Unix, from 1971 to 1975. [3] Though rudimentary by modern standards, it introduced many of the basic features common to all later Unix shells, including piping, simple control structures using if and goto, and filename wildcarding. Though not in current use, it is still available as part of some Ancient UNIX systems.

It was modeled after the Multics shell, developed in 1965 by American software engineer Glenda Schroeder. Schroeder's Multics shell was itself modeled after the RUNCOM program Louis Pouzin showed to the Multics Team. The "rc" suffix on some Unix configuration files (for example, ".vimrc"), is a remnant of the RUNCOM ancestry of Unix shells. [1] [4]

The PWB shell or Mashey shell, sh, was an upward-compatible version of the Thompson shell, augmented by John Mashey and others and distributed with the Programmer's Workbench UNIX, circa 1975–1977. It focused on making shell programming practical, especially in large shared computing centers. It added shell variables (precursors of environment variables, including the search path mechanism that evolved into $PATH), user-executable shell scripts, and interrupt-handling. Control structures were extended from if/goto to if/then/else/endif, switch/breaksw/endsw, and while/end/break/continue. As shell programming became widespread, these external commands were incorporated into the shell itself for performance.

But the most widely distributed and influential of the early Unix shells were the Bourne shell and the C shell. Both shells have been used as the coding base and model for many derivative and work-alike shells with extended feature sets. [5]

Bourne shell

The Bourne shell, sh, was a new Unix shell by Stephen Bourne at Bell Labs. [6] Distributed as the shell for UNIX Version 7 in 1979, it introduced the rest of the basic features considered common to all the later Unix shells, including here documents, command substitution, more generic variables and more extensive builtin control structures. The language, including the use of a reversed keyword to mark the end of a block, was influenced by ALGOL 68. [7] Traditionally, the Bourne shell program name is sh and its path in the Unix file system hierarchy is /bin/sh. But a number of compatible work-alikes are also available with various improvements and additional features. On many systems, sh may be a symbolic link or hard link to one of these alternatives:

The POSIX standard specifies its standard shell as a strict subset of the Korn shell, an enhanced version of the Bourne shell. From a user's perspective the Bourne shell was immediately recognized when active by its characteristic default command line prompt character, the dollar sign ($).

C shell

The C shell, csh, was modeled on the C programming language, including the control structures and the expression grammar. It was written by Bill Joy as a graduate student at University of California, Berkeley, and was widely distributed with BSD Unix. [9] [ better source needed ]

The C shell also introduced many features for interactive work, including the history and editing mechanisms, aliases, directory stacks, tilde notation, cdpath, job control and path hashing. On many systems, csh may be a symbolic link or hard link to TENEX C shell (tcsh), an improved version of Joy's original version. Although the interactive features of csh have been copied to most other shells, the language structure has not been widely copied. The only work-alike is Hamilton C shell, written by Nicole Hamilton, first distributed on OS/2 in 1988 and on Windows since 1992. [10]

Configuration files

Shells read configuration files in various circumstances. These files usually contain commands for the shell and are executed when loaded; they are usually used to set important variables used to find executables, like $PATH, and others that control the behavior and appearance of the shell. The table in this section shows the configuration files for popular shells. [11]

Configuration file sh ksh csh tcsh bash zsh
/etc/.loginloginlogin
/etc/csh.cshrcyesyes
/etc/csh.loginloginlogin
~/.tcshrcyes
~/.cshrcyesyes [lower-alpha 1]
~/etc/ksh.kshrcint.
/etc/sh.shrcint. [lower-alpha 2]
$ENV (typically ~/.kshrc) [12] int. [lower-alpha 3] [lower-alpha 4] int.int. [lower-alpha 5]
~/.loginloginlogin
~/.logoutloginlogin
/etc/profileloginloginloginlogin [lower-alpha 6]
~/.profileloginloginlogin [lower-alpha 7] login [lower-alpha 6]
~/.bash_profilelogin [lower-alpha 7]
~/.bash_loginlogin [lower-alpha 7]
~/.bash_logoutlogin
~/.bashrcint.+n/login
/etc/zshenvyes
/etc/zprofilelogin
/etc/zshrcint.
/etc/zloginlogin
/etc/zlogoutlogin
~/.zshenvyes
~/.zprofilelogin
~/.zshrcint.
~/.zloginlogin

Explanation:

  1. only if ~/.tcshrc not found
  2. Newer versions of the Bourne Shell only
  3. Available on systems that support the "User Portability Utilities option"; value of the variable must be an absolute path, and it is ignored "if the user's real and effective user IDs or real and effective group IDs are different." [13]
  4. $ENV is $HOME/.shrc in newer versions of the Bourne Shell
  5. Same behavior as sh, but only if invoked as sh (bash 2+) or, since bash 4.2, also if invoked explicitly in POSIX compatibility mode (with options --posix or -o posix). [14]
  6. 1 2 Only in sh/ksh compatibility mode (when invoked as bash, sh, ksh)
  7. 1 2 3 The first readable file in order of ~/.bash_profile, ~/.bash_login and ~/.profile; and only ~/.profile if invoked as sh or, as of at least Bash 4.2, if invoked explicitly in POSIX compatibility mode (with options --posix or -o posix)

Other shells

Variations on the Unix shell concept that don't derive from Bourne shell or C shell include the following: [15]

See also

Related Research Articles

<span class="mw-page-title-main">Bash (Unix shell)</span> GNU replacement for the Bourne shell

Bash is a Unix shell and command language written by Brian Fox for the GNU Project as a free software replacement for the Bourne shell. First released in 1989, it has been used as the default login shell for most Linux distributions. Bash was one of the first programs Linus Torvalds ported to Linux, alongside GCC. A version is also available for Windows 10 and Windows 11 via the Windows Subsystem for Linux. It is also the default user shell in Solaris 11. Bash was also the default shell in versions of Apple macOS from 10.3 to 10.15, which changed the default shell to zsh, although Bash remains available as an alternative shell.

<span class="mw-page-title-main">KornShell</span> Bourne shell backward compatible Unix shell created by David Korn

KornShell (ksh) is a Unix shell which was developed by David Korn at Bell Labs in the early 1980s and announced at USENIX on July 14, 1983. The initial development was based on Bourne shell source code. Other early contributors were Bell Labs developers Mike Veach and Pat Sullivan, who wrote the Emacs and vi-style line editing modes' code, respectively. KornShell is backward-compatible with the Bourne shell and includes many features of the C shell, inspired by the requests of Bell Labs users.

<span class="mw-page-title-main">Shell script</span> Script written for the shell, or command line interpreter, of an operating system

A shell script is a computer program designed to be run by a Unix shell, a command-line interpreter. The various dialects of shell scripts are considered to be scripting languages. Typical operations performed by shell scripts include file manipulation, program execution, and printing text. A script which sets up the environment, runs the program, and does any necessary cleanup or logging, is called a wrapper.

<span class="mw-page-title-main">Bourne shell</span> Command-line interpreter for operating systems

The Bourne shell (sh) is a shell command-line interpreter for computer operating systems.

<span class="mw-page-title-main">C shell</span> Unix shell

The C shell is a Unix shell created by Bill Joy while he was a graduate student at University of California, Berkeley in the late 1970s. It has been widely distributed, beginning with the 2BSD release of the Berkeley Software Distribution (BSD) which Joy first distributed in 1978. Other early contributors to the ideas or the code were Michael Ubell, Eric Allman, Mike O'Brien and Jim Kulp.

<span class="mw-page-title-main">Z shell</span> Unix shell

The Z shell (Zsh) is a Unix shell that can be used as an interactive login shell and as a command interpreter for shell scripting. Zsh is an extended Bourne shell with many improvements, including some features of Bash, ksh, and tcsh.

Almquist shell is a lightweight Unix shell originally written by Kenneth Almquist in the late 1980s. Initially a clone of the System V.4 variant of the Bourne shell, it replaced the original Bourne shell in the BSD versions of Unix released in the early 1990s.

pwd Directory information command on various operating systems

In Unix-like and some other operating systems, the pwd command writes the full pathname of the current working directory to the standard output.

<span class="mw-page-title-main">Pseudoterminal</span>

In some operating systems, including Unix and Linux, a pseudoterminal, pseudotty, or PTY is a pair of pseudo-device endpoints (files) which establish asynchronous, bidirectional communication (IPC) channel between two or more processes. The master provides means by which a terminal emulator process controls the slave. The slave emulates a hardware text terminal device. PTY are similar to bidirectional pipes.

<span class="mw-page-title-main">Comparison of command shells</span>

A command shell is a command-line interface to interact with and manipulate a computer's operating system.

The PWB shell was a Unix shell.

alias (command) Command in various command line interpreters

In computing, alias is a command in various command-line interpreters (shells), which enables a replacement of a word by another string. It is mainly used for abbreviating a system command, or for adding default arguments to a regularly used command. alias is available in Unix shells, AmigaDOS, 4DOS/4NT, KolibriOS, Windows PowerShell, ReactOS, and the EFI shell. Aliasing functionality in the MS-DOS and Microsoft Windows operating systems is provided by the DOSKey command-line utility.

In computing, a shebang is the character sequence consisting of the characters number sign and exclamation mark at the beginning of a script. It is also called sharp-exclamation, sha-bang, hashbang, pound-bang, or hash-pling.

chsh is a command on Unix-like operating systems that is used to change a login shell. Users can either supply the pathname of the shell that they wish to change to on the command line, or supply no arguments, in which case chsh allows the user to change the shell interactively.

getopts is a built-in Unix shell command for parsing command-line arguments. It is designed to process command line arguments that follow the POSIX Utility Syntax Guidelines, based on the C interface of getopt.

In a Unix shell, the full stop called the dot command (.) is a command that evaluates commands in a computer file in the current execution context. In the C shell, a similar functionality is provided as the source command, and this name is seen in "extended" POSIX shells as well.

The restricted shell is a Unix shell that restricts some of the capabilities available to an interactive user session, or to a shell script, running within it. It is intended to provide an additional layer of security, but is insufficient to allow execution of entirely untrusted software. A restricted mode operation is found in the original Bourne shell and its later counterpart Bash, and in the KornShell. In some cases a restricted shell is used in conjunction with a chroot jail, in a further attempt to limit access to the system as a whole.

In computing, command substitution is a facility that allows a command to be run and its output to be pasted back on the command line as arguments to another command. Command substitution first appeared in the Bourne shell, introduced with Version 7 Unix in 1979, and has remained a characteristic of all later Unix shells. The feature has since been adopted in other programming languages as well, including Perl, PHP, Ruby and Microsoft's Powershell under Windows. It also appears in Microsoft's CMD.EXE in the FOR command and the ( ) command.

<span class="mw-page-title-main">Command-line interface</span> Computer interface that uses text

A command-line interface (CLI) is a means of interacting with a computer program by inputting lines of text called command-lines. Command-line interfaces emerged in the mid-1960s, on computer terminals, as a user-friendly alternative to punched cards.

References

  1. 1 2 Tom Van Vleck (1995-02-05). "Unix and Multics". Multicians.org. Retrieved 2012-08-14.
  2. Bourne, Stephen R. (October 1983). "The Unix Shell". BYTE. p. 187. Retrieved 30 January 2015.
  3. "V6 Thompson Shell Port - History". V6shell.org. Retrieved 2012-08-14.
  4. Louis Pouzin (2000-11-25). "The Origin of the Shell". Multicians.org. Retrieved 2012-08-14.
  5. Nikolai Bezroukov (2015-08-13). "Introduction to the Unix shell history". Softpanorama. Archived from the original on 2022-06-08. Retrieved 2016-08-21.
  6. Bourne, Stephen (2009-03-05). "The A-Z of Programming Languages: Bourne shell, or sh" (Interview). Interviewed by Howard Dahdah. Computerworld . Retrieved 2022-08-16.
  7. "Re: Late Bloomers Revisited" . Retrieved 20 September 2014.
  8. Korn, David G. (October 26, 1994), "ksh - An Extensible High Level Language", Proceedings of the USENIX 1994 Very High Level Languages Symposium, USENIX Association, retrieved February 5, 2015, Instead of inventing a new script language, we built a form entry system by modifying the Bourne shell, adding built-in commands as necessary.
  9. Harley Hahn, Harley Hahn's Guide to Unix and Linux: Unix/Linux Timeline.
  10. "Hamilton C shell for Windows Release Notes 4.0" . Retrieved 20 September 2014.
  11. "Different UNIX Shells". unixnote.com. 2010. Archived from the original on 2016-04-03. Retrieved 2016-08-21.
  12. SCO Unix Group, SCO Unixware 7 documentation, 22 Apr 2004, retrieved 18 Oct 2012.
  13. "Shell Command Language". opengroup.org. Retrieved 15 June 2015.
  14. "Bash Reference Manual: Bash Startup Files". gnu.org. Retrieved 15 June 2015.
  15. "FreeBSD Ports: Shells". Freebsd.org. 2014-03-30. Archived from the original on 2021-01-12. Retrieved 2014-04-05.