csh - Command shell
csh [ -c ] [ command ]
Csh is a command interpreter. Without any arguments, csh goes through a normal startup procedure, eventually giving you a command line where you can enter more commands.
If csh is invoked with a command argument, it processes that command and exits when finished. If the -c flag is included, csh processes the command, but does not exit. If only -c is given, the shell immediately presents a command line for entering commands (it does not run your login script, described later).
Csh is the central program from which all other programs can be
accessed. It is often called a command interpreter, acting as a liaison
between you and the system. To instruct the system to perform a task,
you enter your request on a command line. The shell processes the
command line to carry out your request by means of a built-in shell
function, or by selecting a program external to the shell to complete
the request. The shell contains many internal functions for use in the
shell environment. There are even more external programs that
can be called upon from the shell. After a command line is processed,
the shell prompts you for additional commands until you’re ready to
quit.
The shell can also process a series (or batch) of commands contained in a file, as if they had been entered by hand on the command line. Files containing shell commands are called shell scripts. Scripts use special features to control the execution of commands in a way that reduces arduous tasks into simple, automated procedures. More on scripts later.
Executing a built-in or external command from the shell is simple —
just type in the command’s name. While typing in a command line,
various editing keystrokes are available:
cancel what you’ve entered so far
rubout the character left of the cursor
rubout the word left of the cursor
The shell maintains a history of the 20 most recently entered commands.
You can scroll through command lines entered and repeat one by pressing
Control-P (for previous) to move backward in time toward the
oldest command lines. Pressing Control-N (for next) moves forward
to the most recent command lines.
The shell also recognizes the exclamation point (!) character at the beginning of each line as a way of referencing specific history lines.
Selects the last entered command line.
Selects a command line by the number associated with #.
Selects the most recent command line that begins with a pattern of text.
In many cases, you may need to give extra information, or arguments, to
a command. To help the shell determine which items are commands and
arguments, separate them with space characters.
To specify a single argument that may contain spaces within it, enclose the argument in quotation marks. Example:
echo "This is one argument"
The shell ignores most control characters entered on the command line. To insert a control character, use a caret before the corresponding letter (e.g., “^G” for Control-G).
If you need to enter a quotation mark or caret in an argument, prefix it with a backslash “\” character. Likewise, to enter a backslash, prefix it with a backslash (in other words, two backslash characters make one). Examples:
echo "\"Wow!\" she exclaimed." echo "Here is a caret: \^" echo "Here is a backslash: \\"
Using a backslash to insert special characters is known as escaping. There are other characters the shell recognizes as having special meanings, such as the dollar sign ($), tilde (~), period (.), and asterisk (*). These are discussed later.
The shell has many built-in commands. They are listed below along with the
arguments they require. Optional arguments are shown between [ brackets ].
Arguments shown with “…” following means “one or more of the same”.
Adds source file(s) onto the end of the target file. If one file argument is given, the file must reside outside of the current directory and will be appended to a file in the current directory with the same name. If more than one argument is given, the final argument is the target file, and all others are appended onto it.
Substitutes a command name with a new name (and any additional arguments). The new replacement arguments may contain the following special characters: !^ (inserts the first argument from the command line here), !$ (inserts the last argument here), and !* (inserts all arguments here). Entering alias without any arguments displays a list of the current aliases.
Short for “concatenate”. Cat is normally used to display the contents of a file, but is also useful for redirecting a file to other files or devices (e.g. a printer).
Changes the current working directory. If the argument is omitted, the current directory becomes your $home directory.
Clears the screen.
Copies a file. If only one file is given, it must reside outside of the current directory, and is copied to a file of the same name within the current directory. If more than one argument is given, the source files are copied onto the target file. If the target is a directory, the files are copied into the directory, retaining their names.
Echoes any arguments that follow. If the -n option is given, no newline is printed after the final argument. To redirect output from echo to a file, include >file as the last argument. To append output to an existing file, use >>file.
This replaces the current shell with a new command interpreter. If called from a shell script, the script is terminated.
Tells the shell to quit and return to the calling process. Typing Control-D is recognized as the exit command, too. The optional number argument useful for returning a result code to the calling process (default is zero).
Displays the 20 most recent command lines.
Conditional test to execute commands. This is normally used within shell scripts and is discussed later.
Terminate connection immediately.
Makes a subdirectory.
Moves a file from one place to another. It works identically to cp, except it deletes the source file after copying it to the target. It is also used to rename a file if both src and targ reside in the same directory.
Prints out the name of the current Working Directory.
Reads input from the user and assigns it to a variable.
Removes files and empty directories.
Sets shell variables to specified values. Set without arguments displays the currently set variables.
Shifts the arguments in the command line down by removing the first argument. Without arguments, shift affects argv (see the discussion on variables later for details). By including an optional variable name, that variable is affected. This command is typically used by shell scripts for argument parsing.
Executes shell commands from a text file.
Removes aliases.
Removes variables.
Many more commands can be called up from disk by the shell. One such command is ls, which lists the contents of a directory. To see the names of all the disk-based commands, enter:
ls $path
Entering a command without any arguments usually displays a line of “usage” information. You can get more information about a command by using the man command (short for “manual”). Man requires the name of the item you want more help on as an argument. It prints out nicely formatted pages from the online manual. (Try the “man man” command — it lets man tell you more about itself).
The shell watches certain requests to make sure the user has the
required access permissions. There are four types of file access:
reading from a file, writing to or creating a file, destroying a file,
and executing a file. Under ProLine, access permissions are specified
for the entire contents of a single directory level, rather than on a
file-by-file basis. (See dstat for more details).
If you’re using the system from the local console, you can redirect the
output from the shell and other programs to a printer attached to the
computer. To do this, include >.printer as the final argument to a
command line. This tells the shell to turn on printer output. It’s only
good for one command, so there is no additional command to turn it off;
it will do so when it wants another command from you.
Example:
echo This is a test >.printer
Another form of output redirection is to send output into a file, rather than to the console or printer. The syntax is similar to >.printer.
Example:
man csh >temp
In this case, it is man’s job to handle redirecting its output into the file called “temp” (or whatever name you provide). Unfortunately, not all programs on the system provide this ability. Check with man to see if a certain command provides file output redirection.
The shell looks at the arguments you give to see if any start with
special characters that reference directories. These characters are one
or two periods (.), and the tilde (~).
When the shell encounters a single period, it replaces it with the path to the current working directory. If it sees two periods, it replaces them with the name of the parent directory of the current working directory. In other words, two periods means to step back one directory level. So, if a single periods refers to $/usr/jholt, then two periods refer to $/usr.
The tilde (~) is directory shorthand for referencing home directories. To access a file in your home directory called stuff when the current directory is not your home, use “~/file”. The shell sees “~/” and knows that you’re referencing your home directory (which is shorthand for “$/usr/yourloginname/file”). By introducing the login name of another user between ~ and /, you reference that user’s home directory. For example, “~jsbach/sonata” is short for $/usr/jsbach/sonata.
Shell variables are short names given to command line items that are
cumbersome or hard to remember. The shell comes with a number of
preset variables containing useful information. To obtain the value of a
variable, a dollar sign ($) is placed before its name (e.g. $path)
Variables the shell defines for you are:
Directory in which ProLine resides on the local file system. Since one ProLine system may have a startup prefix that is different from another ProLine, the $/ variable allows ProLine systems to work consistently in the shell from one system to the next.
Contains the count (+1) of the arguments passed to a shell script.
Contains the shell script’s name and arguments passed.
The system caller ID number.
The current working directory.
The current date and time in the standard ProLine date format:
Sat, 18 Apr 92 10:22:19 PDT
The name of the editor used to edit text files on ProLine.
If set, any errors in a shell script cause the script to halt. By unsetting this variable, errors will allow a script to continue processing.
Your group-ID number.
Your home directory.
The name of the host system.
Your login name.
The path to your mailbox file.
Your first and last name.
A list of paths to directories containing external command files.
Your shell prompt.
Path to the shell program.
The number of nested shell levels.
The result of the last command.
The current day of the week, date, month, year, hours, minutes, seconds,
and day of week number in this format:
Sat 18 04 92 10 22 19 6
Month values are 01 for Jan up to 12 for Dec.
Day of week values are 0 for Sun up to 6 for Sat.
All numeric values (except for day of the week number) are padded with
zeroes to fill out to two digits.
Path to a directory for temporary file storage (usually a RAM disk or fast hard disk volume).
Contains “modem” or “console” depending on how you logged in — remotely or locally.
Your user-ID number.
The shell’s version information.
You can access individual words within a variable by including a
subscript after the variable’s name. For example, to access the first
word of the $time variable (the day of the week), use $time[0]. To
access the hours, use $time[4]. To access arguments passed to a script
from within the script, use $argv[x] as appropriate.
The shell always expands variables to the values they contain, even when
placed inside quotation marks. To cause the shell to pass a dollar sign
and a word through unexpanded, prefix it with a backslash. (e.g.
“\$time”). Consider the following:
alias bye "echo Login: $date[4]^MLogout: \$date[4]; logout"
In this alias definition, “bye” is defined with an echo command that includes the $date variable in two places. The first instance is not escaped by a backslash, and therefore when this alias command is executed, the current time is inserted. The second instance of $date is escaped by a backslash, and therefore the word “$date” is literally inserted into the definition. When the bye alias is actually used, only then would the second instance of $date be recognized (since the backslash would not be present), and the current time inserted. As a result, the bye alias displays both the login and logout times before disconnecting.
The same is true when assigning variables to a variable. If you want your shell prompt to display the current working directory, use:
set prompt="\$cwd> "
If the $cwd variable reference had not been escaped with a backslash, this command would assign the prompt variable a value containing the current working directory at the time when set was issued. The prompt would never change even as new directories were chosen.
You can instruct the shell to execute more than just one command at a time
by entering command sequences separated by semicolons (;) on the same
line. But, if you need to execute many, often repeated command
sequences, it is best to put them into a shell script.
A shell script contains any commands you would enter on the command line. Once created using any text editor, you can execute the script by using the source command. (To make a script executable without having to use source, change its file type to CMD with the setfile command).
When first launched, csh sets up an internal environment which can
be further customized through various initialization scripts.
If it exists, csh invokes a system-wide initialization
script $/etc/cshrc. This script is set up by the administrator to
perform various sign-on tasks, like reporting new system bulletins
(news), reporting mail, and finally invoking the user’s personal
login script (discussed next).
When interactive subshells are launched without arguments, csh does not execute $/etc/cshrc nor the user’s login script, but will attempt to execute the user’s personal cshrc file, if it exists in the home directory.
The system-wide startup script, cshrc, is expected to reside in $/etc
or the configured temporary files directory ($tmpdir), which might be a
high-speed RAM disk. If the system-wide cshrc does not exist, csh
attempts to execute the user’s login script during a login session.
Each user has a special script of startup commands. The script is
called login (~/login). This file can
contain a variety of shell commands, and can be modified as desired,
allowing a unique and personal entry into the system for each session.
Once the login script has done its job, the
shell may prompt for further commands, but typically login
invokes the user’s personal cshrc file.
The login script is derived originally from the default script ($/etc/default/login) when an account is first created.
The personal cshrc file (~/cshrc), contains commands that are used
to install aliases and set variables such that each shell is set up
as the user desires. This script is normally launched by a command
in the user’s ~/login script, but is automatically run whenever
csh invokes an interactive subshell.
To control execution of script commands, use the if directive. If,
and its partners else and endif, are used to test certain conditions
and execute only the commands which should be processed based on the
results of those conditions. The condition is determined by the
logical expression given to if.
An example:
if $a = $b then echo TRUE else echo FALSE
Another example:
if $time[0] = "Sun" and -f workfile then echo It is Sunday AND the workfile exists! else echo EITHER it is not Sunday echo OR the workfile does not exist. endif
For more details on if statements, see the if(C) manual entry.
$/sys/modules/parse live on a RAM disk.