Unix Command Dictionary (Hanson)

Table of Contents
• UNIX Log In and Out Commands.
• UNIX Information Commands.
• UNIX C Language Commands.
• UNIX makefile Commands.
• UNIX Directory Commands.
• UNIX File Commands.
• UNIX Pipe and Redirection Commands.
• UNIX Mail Commands.
• UNIX Control-Key Commands.
• UNIX Terminal Environment Commands.
• UNIX Process Commands.
• UNIX Editor Commands.
• The ex Editor.
• The vi Editor.

UNIX Command Dictionaries

The UNIX manual is mostly on line and the UNIX `man' command is used to display
parts of the manual. Typing

man [command] (CR)

will yield information in an almost readable format during a IBM Telnet session. The
problem is that you have both UNIX and CMS paging the output. You respond to the
UNIX paging prompt `:' with a `(CR)' return for a new page, `d (CR)' for a short new
page, u (CR)' for a short page up (back), or `q (CR)' to quit. For the CMS paging
prompt `holding', respond with the designated `Clear-key'. If you are using IBM
Telnet, then `man [command]' usually produces poor output for the head of the
display. The version `man -blou [command] (CR)' should remove underscoring and
other backspacing for printing at UIC, but does not work completely. For a quick
overview of a command try the `-q' quick option:

man -q command] (CR)

Alternatively,

man [command] > [file] (CR)

is useful for redirecting the output to a file that can later be transfer back to CMS for
printing (e.g. by `printdoc'). The UNIX no paging `-r' option does not work in a CMS
session, so the CMS user has to press both the `Return-key' for a new UNIX `man'
page or the `Clear-key' for a new CMS page depending on the odd UNIX prompt or
the CMS ``HOLDING'' prompt, respectively.

This abridged UNIX dictionary is only intended to be a short enough list to get you
started without being bewildered by the enormous UNIX manuals, but with enough
commands to be able to do something useful. For more information use the `man'
command or refer to some of the UNIX texts. UNIX is a trademark of Bell
Laboratories.

The format is

[command] [generic operand] : [Definition.]

along with a carriage return `(CR)' for each command. DO NOT FORGET that
almost all UNIX commands must be in lower case. Do not attempt to learn all of this
at once, but read some of it and try it out at an actual computer session.

Return to TABLE OF CONTENTS?

UNIX Log In and Out Commands:

login (CR) : Logon command.

logout (CR) : Logoff command.

Return to TABLE OF CONTENTS?

UNIX Information Commands

man [-option] [command] (CR) : Manual or UNIX help command. The usual
quit sequence `q (CR)' can be used to quit long UNIX `man' listings, `(CR)' is
used for new `man' pages. During a IBM Telnet session the `Clear-key' is
needed for new CMS pages that are not the same as the `man' pages.
Otherwise `d', `q' or `Ctrl-c' should work for UNIX like access.

finger [user] (CR) : Displays system biography on user `[user]'.

whereis [name] (CR) : Locates source for program or command; e.g.

`whereis kermit'.

which [name] (CR) : Tell which version of a program or command will be

used in your session in case of multiple copies; e.g. `which cc'.

whatis [command] (CR) : Describes the command [command].

who am i (CR) : Displays current user id and access.

who (CR) : Displays currently logged in users.

 Return to TABLE OF CONTENTS?

UNIX C Language Commands

cc -o run [file].c (CR) : Compiles source [file].c, using the standard C

compiler `scc2.0' and producing an executable named run. In place of `cc', use
`scc3.0' or `scc' for the latest version of standard C or `pcc' for portable C.

cc -c [file].c (CR) : Compiles source [file].c, using the standard C compiler

`scc2.0' and producing an object file named [file].o.

cc -hnoopt -o run [file].c (CR) : Compiles source [file].c, using the standard
C compiler `scc3.0' and producing an executable file named run without scalar
optimization or vector optimization while `hopt' enables scalar and vector
optimization, Some other optimization related options are `-hinline' for
inlining while `-hnone' is the default no inlining, `-hnovector' for no vector
(vector is the default), and `-h listing' for a pseudo-assembler (CAL) listing.
Some standard C options are `-htask3' for automatic parallelization
(autotasking in crayese) and `-hvector3' for more powerful vector
restructuring. Other `-h' suboptions are `ivdep' for ignore vector dependence,
`-hreport=isvf' generates messages about inlining (i), scalar optimization (s)
and vector optimization (v), and `-hreport=isvf' writes same messages to
`[file].v'. A commonly used form will be

cc -o run -h report=isvf [file].c (CR)

See `man cc' or `docview' for more information.

#define fortran : Form of C header statement to permit the call to a fortran

subroutine from a C program. For example:

#include <stdio.h>
#include <fortran.h>
#define fortran
main()
{
fortran void SUB();
float x = 3.14, y;
SUB(&x, &y);
printf("SUB answer: y = %f for x = %f\n", x, y);
}

#pragma _CRI [directive] : Form of C compiler directive placed within the C

code, where some example directives are `ivdep' for ignoring vector
dependence, `novector' for turning off the default vectorization, `vector' for
turning it back on, `inline' for procedure inline optimization, `shortloop',
`noreduction', `getcpus [p]', `relcpus', `parallel ........', and `end parallel'. See
`vector directives' for instance in `docview' for more information and
examples.

Return to TABLE OF CONTENTS?

 UNIX makefile Commands

make [-options] [step-name] (CR) : Makes the files [files] according to the
template in the `makefile'. See the examples `makefile *' on the `getdisk
hanson' disk in CMS, e.g., the file `makefile.unicos_2':

# Use ``make -f make.unicos_2 mrun>& pgm.l &;

run<data>out''.
SOURCES = pgm.f
OBJECTS = pgm.o
FLAGS = -em
mrun : $(OBJECTS)
segldr -o run $(OBJECTS)

.f.o : cft77 $(FLAGS) $*.f

{CAUTION: The commands, like `segldr' or `cft77', must be preceded by a
`Tab-key' tab as a delimiter, but the tab will not be visible in the UNIX
listing.}

fmgen -m [make-name] -c cft77 -f [-flag] -o [executable] [source].f (CR) :

Automatically generates a makefile for compiling under the `cft77' compiler
and loading up the executable file named `[executable]'. Invoke with `make -f
[make-name] [executable](CR)' and the execute `[executable]'. Also produces
steps for profiling, flow-traces, performance traces, and clean-up, in the
heavily documented makefile. For example, `make -c cft77 -f -em -o run
pgm.f (CR)' produces a makefile named `makefile', executable named `run',
an information listing named `[name in program statement].l' with loops
marked by optimization type, etc.; the making is done with `make run (CR)'.
Caution: the makefile only uses the source name only when that coincides
with the name used in the Fortran `program' statement and only one type of
`cft77' flag can be used. These flaws can be corrected by editing the resulting
makefile `[make-name]'.

Return to TABLE OF CONTENTS?

UNIX Directory Commands

mkdir [name] (CR) : Makes a directory or file group name [name]; e.g.
`mkdir dirpgm (CR)' make the directory called `dirpgm'.

pushd [name] (CR) : Pushes from the working directory to the directory
[name] keeping the sequence of directories in a buffer for `popd'.

popd (CR) Pops back up to the prior directory, if `pushd' was used before. For
this reason, `pushd' and `popd' are more useful than the regular change
directory command `cd'.

cd [directory] (CR) : Changes the working directory to the directory

[directory]; you can change it back with `cd(CR)' using your own login id; `cd
$HOME (CR)' returns the shell back to your home directory. `.' denotes the
current directory and `..' denotes the root or parent directory.
cd ~[user] (CR) : Changes working directory to that of login id `[user]'.

cd $TMP (CR) : changes to your temporary directory; same as `cd $TMP

(CR)'.

pwd (CR) : Displays working directory; `echo $HOME (CR)' displays the
home directory.

ls [directory] (CR) : displays the contents of the directory `[directory]'.

mv [file1] ... [fileN] [directory] (CR) : moves `[file1]', ..., `[fileN]' to

directory `[directory]'; e.g. `mv addtwo.* diradd' moves all files with prefix
`addtwo.' to the directory `diradd' which must already exist from a prior 'mkdir
diradd' command. This format works for `cp' also.

cp [file1] [directory]/[file2] (CR) : copies [file1] into [file2] in directory

[directory]. `cp [file] . (CR)' copies a file to the current directory using the
original name. This format works for `mv' also.

rmdir (CR) : Removes or erases empty directory. You must first use `rm *' to
empty the file.

Return to TABLE OF CONTENTS?

UNIX File Commands

ls (CR) : Lists sets or files of current user id or current directory.

ls ~[user] (CR) : Lists files or directories under user/account id `[user]'. Also

`ls ~/[directory] (CR)' will list the contents of the directory `[directory]' on
the same account.

ls [string].* (CR) : Lists all current files with prefix [name]. Examples of
other forms are `ls *[string] (CR)' or `ls *[string]* (CR)' or `ls
*[string1]*[string2]*'.

cat [file1] ... [fileN] (CR) : Lists content of N (N .le. 1) argument files
catenated. Use `cat [file1] ... [fileN] > [fileM] (CR),' to catenate and store the
N files in `[fileM]'.

more [file] (CR) : Displays file in half pages of 11 lines; use `q (CR)' for
quitting; use `d' for 11 more lines or `u' to go back up 11 more lines; similarly,
`f' and `b' produce full pages forward and backwards, respectively; while
`/[string]?[string]

Caution: works poorly with TELNET from CMS. Use `cat [file] (CR)'
with the CMS Clear-key instead.

cp [file1] [file2] (CR) : Copies file `[file1]' into file `[file2]'.

 rm [file1] (CR) : Erases file `[file1]'; can take several file arguments, with
the system asking if you really want to do it, `y' for yes and `n' for no
target file `[file2]' already exists to avoid unintentional. {The query can be
removed in any session by the command `unalias rm (CR)' or
permanently by editing the C-shell resource configuration file `.cshrc'.}

mv [file1] [file2] (CR) : Renames file `[file1'] as file `[file2]', i.e., moves one
file to another.

grep `[str]' [file1] (CR) : Searches for string [str] in file [file1]. ``cat [file1]
[file2] | grep `[string]' (CR)'' searches for the pattern `[string]' in the
catenated files. Note the different string pattern, with the standard single
quote used within the command to enclose the target string when it is more
than one word.

diff [file1] [file2] (CR) : Displays the difference between files `[file1]' and
`[file2]'.

chmod [mode] [file] (CR) : Changes the read, write and execute
permissions for the file (or files) `[file]' according to the `[mode]' which
has form `[[who] [operator] [permission]]'; `[who]' is `u' for the user, `g'
for the defined group', `o' for others and `a' = `ugo' for all; `[operator]' is
`+' to add and `-' for remove; `[permission]' is `r' for read, `w' for write
and `x' for execute; current permissions are displayed with the default
long list command `ls [file] (CR)' in the first field or the sample forms
`drwxrwxr-x' or `-rwxr--r--' with the first character denoting a directory
if `d' is present, a `--' denotes no permission, with each remaining subfield
of three denoting the user, group and others, respectively; for example
`chmod go-wx *' removes write and execute permissions in the current
directory for all but the user, `chmod u+w [file]' adds write permission to
only the user; the user may be queried about removing protection for his
own files.

Return to TABLE OF CONTENTS?

UNIX Pipe and Redirection Commands

The commands in this subsection embody some of the powerful advantages of

UNIX.

alias [command nickname] `[command definition]' (CR) : Makes alias for

commands to save typing. The quotes around the definition are not
required for single words, but only when the definition contains delimiters
like blanks. If used a lot, put the `alias' in the group account `.cshrc' file
and execute by `source .cshrc}. {`csh' is the UNIX C-shell, one of the
UNIX operating sub-systems, and `rc' stands for resource configuration.}

[command] > [file] (CR) : Redirects standard output of command

[command] to file [file]. E.g., `cat [fn1] [fn2] > [fn3] (CR)', catenating two
files into a third file.
[command] > & [file] (CR) : Redirects standard and diagnostic or error
output of [command] to file [file]. E.g., `run > & [output] (CR)', puts
compiled listing and errors into the file pgm.l when pgm.f is compiled.

[command] >> [file] (CR) : Redirects standard output of `[command]'

and appends it to `[file]'. E.g., `run < [data] >> [output] (CR)', catenates
the new output with the current file `[output]'.

[cmd1] | [cmd2] (CR) : Pipes output of command `[cmd1]' to input of

command `[cmd2]'. E.g., `ls -l | grep `Jan 31' (CR)' lists only those files
last changed on January 31. Caution: the string `Jan 31' must be enclosed
in single quotes, but the quotes are optional for single words without
delimiters.

[command] & (CR) : Executes `[command]' in the background, so you

can work at something else in your session. E.g., `run < [data] > [output]
& (CR)', execute `run' and stores results into the file `[output]'.

history (CR) : Lists the history of the most recent commands entered.

![number] (CR) : Repeats execution of the command numbered

`[number]' in the `history' listing.

![string] (CR) : Repeats execution of the last command beginning with the
pattern [string] in the `history' listing.

![string]:p (CR) : Repeats listing of the last command beginning with the
pattern `[string]' in the `history' listing, but does not execute it. You can
return (CR) to execute or you can modify it by the command that follows
immediately below.

^[str1]^[str2] (CR) : Replaces string `[str1]' with `[str2]' in the previous

command and executes the modified command.

Return to TABLE OF CONTENTS?

UNIX Mail Commands

mail (CR) : Shows user`s mail; use the subcommand `t [N](CR)' to list
message number `[N]' , `s [N] mbox (CR)' to append message `[N]' to your
mailbox `mbox' file or `s [N] [file](CR)' to append `[N]' to another file; `e
[N] (CR)' to edit number [N] or look at a long file with `ex' {see Section on
`EX' below}; `v [N] (CR)' to edit number [N] or look at a long file with
`vi'; `d [N] (CR)' deletes {your own mail!} `[N]'; `m [user] (CR)' permits
you to send mail to another account `[user]'; a `~m [N] (CR)' inside the
message after entering a subject, permits you to forward message `[N]' to
`[user]', `\d (CR)' to end the new message {see the send form below;`x'
quits `mail' without deleting {use this when you run into problems}; and
`q (CR)' to quit.
mail [user] (CR) : Sends mail to user `[user]'; the text is entered
immediately in the current blank space; carriage return to enter each
line; enter a file with a `~r[filename] (CR)'; route a copy to user `[userid]'
by `~c[userid] (CR)'; enter the `ex' line editor with `~e (CR)' or `vi' visual
editor with `~v (CR)' (see Sections on EX and on VI) to make changes on
entered lines, exiting `ex' with a `wq (CR)' or `vi' with a `:wq' (CR)'; exit
`mail' by entering `\d (CR)'. {A bug in the current version of Telnet does
not allow you to send a copy using the `cc:' entry. However, ending with
the ``hack'' `\d [user_cc] (CR)' should get a copy to user `[user_cc]'.}
UNIX users should not encounter IBM Telnet problems.

mail [userid]@uicvm.cc.uic.edu < [filename] (CR) : Sends the UNIX file

`[filename]' to user `[userid]' at UICVM, i.e., to `[userid]'`s CMS, as with
CMS SENDFILE.

mail [name]@[machine].[dept].uic.edu < [filename] (CR) : Sends the

UNIX file `[filename]' to user `[name]' on some UNIX or other machine.

from (CR) : Tells who the mail is from.

Return to TABLE OF CONTENTS?

UNIX Control-Key Commands

Ctrl-h : Erase or backspace over character; note the CTRL-key and h-key
must be simultaneously pressed.

Ctrl-c : Interrupt or break character; stops printing and returns to

UNIX. {Caution: for a IBM TELNET session, should use \c (CR), but this
masked interrupt will not work during long listings due to interference of
the CMS `Clear-key' in IBM Telnet sessions.}

Ctrl-s : Stop character {else or IBM Telnet use ` \s (CR)'}.

Ctrl-q : Quiet character {else for IBM Telnet use `\q (CR)'}.

Ctrl-u : Kill character {else for IBM Telnet use `\u (CR)'}.

Ctrl-w : Word erase character {else for IBM Telnet use `\w (CR)'}.

Return to TABLE OF CONTENTS?

UNIX Terminal Environment Commands

printenv (CR) : Print out environment meta parameters such as defaults,

terminal types and key assignments, eg., SHELL, PATH, TERM, NCPUS,
HOME, TMP, AFS, and AFSTMP.
setenv TERM vt100 (CR) : Sets `TERM' variable to type `vt100', which
should be the default and can be checked by using `printenv', else use
`h19b' or your correct terminal emulation if recognizable by the remote
host. The recognizable terminal type are in the alphabetized
subdirectories of `/usr/lib/terminfo', e.g., `v' directory contains vt100
listings. Caution: `YTERM' is ideal for PC to CMS communication, but
does not have a terminal type that is recognizable by UNIX systems
('vt100' may sometimes work as a substitute, but `unknown' type means a
poor line edit session).

setenv TERMCAP vt100 (CR) : Sets `TERMCAP' variable to type

`vt100', else use `h19b' etc. You can put customized terminal
configuration in the file `.termcap' and enable it with the command
`setenv TERMCAP $HOME.termcap' either in your shell or in your
'.login' file.

tset -m :h19b (CR) : Sets terminal type to Heathkit or Zenith type `h19b'.
WARNING: Several terminal commands are given here, because you might
have to try several before you find one that works. Note that one of the
biggest problems in working with advanced, remote computers is
COMMUNICATION and that much of this local guide is intended to solve
communication problems.

stty erase \[key](CR) : Set or reset the terminal (`tty') erase key to `[key]'.

stty all (CR) : Display usual Control characters; with arguments can be
use to set terminal communication variables; also try `stty everything'.

Return to TABLE OF CONTENTS?

UNIX Process Commands

jobs - l (CR) : Display a simple single line with currently active job status.

ps (CR) : Display current process ids (``pid'') needed for killing.

ps t[N] (CR) : Displays ``pid'' for terminal or tty [N].

kill -9 [pid] (CR) : Means a ``sure kill'' of ``pid'' [pid]; this becomes
necessary when you lose control of a process or have a session aborted.
CAUTION: Aborted sessions are not uncommon so it is helpful to develop
skills of a super process (program) killer.

Return to TABLE OF CONTENTS?

UNIX Editor Commands

ex [file] (CR) : `EX' line editor. This is the preferred editor for LINE
EDIT MODE with TELNET. `:' is the `ex' prompt. `ex [file1] ... [fileN]
 (CR)' is the form used for multiple files with the `n' command used to go
to the next file, rather than `q' to quit. Ex can also be used in vi with ':' as
a prefix, when vi works. `ed' is another line editor with less availability.
More details on `ex' are given in the next section.

vi [file] (CR) : Invokes the UNIX full screen editor `vi' to edit file [file];
this visual editor has a large set of subcommands. Warning: the `vi'
command will NOT work properly with the LINE MODE of CMS TELNET
and YOU WILL LIKELY GET IN A STUCK SESSION IF YOU TRY IT.
(Try to get access to a UNIX system or PC Telnet systems, such as those in
the 2249f SEL PC Lab.)

vi -r [file] (CR) : Form of `vi' used to recover `[file]' after aborted session.
Similarly, `ex -r [file] (CR)' is for an aborted `ex' session.

view [file] (CR) : This is the read only form of `vi'.

Return to TABLE OF CONTENTS?

ex Editor
`Ex' is the UNIX line editor (`ed' is another UNIX line editor) and `vi' is the full
screen editor that is disabled by IBM TELNET. The prompt is `:', but the user
enters input at the bottom of the screen with IBM TELNET line mode. In `ex' `.'
means the current line, `$' means the last line, and `%' means the whole range of
lines `1,$'. `[L1],[L2]' denotes the range from line `[L1]' to line `[L2]'. The user
may want to do major editing on the CMS multi-line editor XEDIT and send the
file using the FTP file transfer protocol. Some students may have had experience
with this editor (or the similar `ed' editor) from EECS courses. These `ex'
commands can be used within the `vi' editor by typing a colon `:' in front of the
`ex' command, which is another reason for learning `ex' with `vi' when you have
an account where `vi' can be used.

0a (CR) : This form of the append subcommand puts you in input mode
starting with line 1, new lines are entered following a `(CR)', and input
mode is ended with a solitary or sole `.' on a line with an immediate
`(CR)', i.e., `.(CR)'. This is not the usual method for opening a new file,
but the usual way does not work correctly with the IBM Telnet and CMS
pass through.

q! (CR) : Quit or abort `ex' without saving. Use, especially, in an

emergency when your edit session seems hopeless, and you want to start
over at the beginning.

w [file] (CR) : Save (write) or resave into the new file [file], but do not
end. If no [file] is specified, then the current file is resaved.
w! [file] (CR) : Resave (rewrite) into an old file [file], but do not end. `Ex'
will not write over an existing non-current file with the `w' command
without the `!'.

wq (CR) : Save and quit ex.

w|n (CR) : When `ex' is used on more than one file, writes the current file
and makes `ex' go to the next file. `|' puts two `ex' commands together.

nu (CR) : Number current line.

set number (CR) : Number all lines; line numbers are needed for effective
use or `ex'; by putting this and other commands in your `.exrc' Ex
Resource Configuration file, the command will be operative until it is
changed.

set list (CR) : Show carriage control characters, such as End-Of-Line ($ =

EOL).

/[string] (CR) : Search forward for pattern [string].

?[string] (CR) : Search backward for pattern [string].

[L1],[L2] p (CR) or [L1],[L2] l (CR) : Prints or lists (listing control

characters) lines [L1] to [L2]. `% (CR)' lists the whole range of lines, and
`.,$ (CR)' lists the current line to the last line.

$ (CR) : Prints last line.

\d (CR) : Scrolls lines {In UNIX, use `Ctrl-d'}.

[L1],[L1]+[N] p (CR) : Prints lines [L1] to [L1]+[N].

[L1],[L2] d (CR) : Deletes lines [L1] to [L2].

[L1] i (CR) : Insert at line [L1]. End with a lone `.(CR)' after the last
input line. Does not work on an empty file.

[L1] a (CR) : Append after line [L1]. End with a lone `.(CR)' after the last
input line. Does not work on an empty file.

[L1] o (CR) : The UNIX open command does not work correctly with
IBM TELNET because the usual end commands do not work properly.
End with a line `.(CR)'.

[L1] c (CR) : Change line [L1]; end with `.(CR) alone.

[L1],[L2] co [L3] (CR) : Copy lines [L1] to [L2] to after line [L3].

[L1],[L2] m [L3] (CR) : Move lines [L1] to [L2] to after line [L3].
 [L1],[L2] t [L3] (CR) : Take {copy} lines [L1] to [L2] to [L3]; destination
[L3] can not be in ([L1] to [L2]-1).

[L1],[L2] g/[string]/[commands] (CR) : Globally search for all

occurrences of pattern [string] in lines [L1] to [L2] (or current line only if
no lines are given), and execute commands [commands] on matching
lines.

[L1],[L2] s/[string1]/[string2]/g (CR) : Substitute [string2] for all [string1]

in lines [L1] to [L2] (or current line only if no lines are given). If `gp' is
used in place of `g' then print change(s).

[L1],[L2] & (CR) : Repeat prior substitution command.

g/[string1]/s/{/}[string2]/gp (CR) : Globally substitute [string2] for each

[string1] in all lines and print changes; works globally; use `?' in place of
`/' if [string*] contains a `/'.

[L] r [file] (CR) : Read in or append file [file] at line [L].

u (CR) : Undo most recent substitution.

[L1],[L2] ya [buffer] (CR) : Yank lines [L1] to [L2] to named buffer

[buffer]. See `pu'.

[L1],[L2] d [buffer] (CR) : Delete and yank lines [L1] to [L2] to named
buffer [buffer]. See `pu'.

[L3] pu [buffer] (CR) : Put lines from named buffer [buffer] after line
[L3]. See `ya'.

g/^$/d (CR) : Delete all null lines.

s/A\/B/A\/C/g (CR) : Illustrates the use of `\' to change a string containing

the `/' delimiter to change `A/B' to `A/C' globally.

Return to TABLE OF CONTENTS?

vi Editor
The UNIX full screen editor `vi' is a tightly designed editing system in which
almost every letter has a function and the function is stronger for upper than
lower case. However, a letter and its actual function are usually closely related. It
is important to remember that the `(Esc)' escape key ends most functions and a
`(Esc), (Esc)' double application certainly ends the function with the ring of a
bell. The subcommand `u' undoes the last function (presumably an error). Use
`:q! (CR)' to end with out saving, especially in hopeless situations. Use `:wq (CR)'
to resave and end {`ZZ' also resaves and ends, but will not resave if the file has
been saved in another file and no further changes have been made}, or `:w (CR)'
to only resave. The character `:' prompts the UNIX line editor `ex' which you can
think of as being embedded in `vi'. Some of the above critical `vi' subcommands
are repeated below with others. Most `vi' subcommands are not displayed when
used and do not take a carriage return `(CR)'. The fact that most keys have a
meaning both as single characters and as concatenations of several characters
has many benefits, but has disadvantages in that mistakes can turn out to be
catastrophic. {Remember that `(Esc), (Esc), u' key sequence!} {WARNING: `VI' is
disabled during an IBM Telnet session.}

(Esc) : End a command; especially used with insert `i', append `a' or
replace 'R'.

(Esc), (Esc) : Ensured end of a command with bell; press the Escape-key
twice; use it.

u : Undoes last command; usually used after `(Esc)' or `(Esc), (Esc)'; if

undoing is worse then repeat `u' again to undo the undoing.

:set all (CR) : Display all vi options. Use this ex command when your
initial vi session is poor. Customized options are placed in the `.exrc' ex
resource configuration profile.

:w (CR) : Save or resave the default file being edited, but do not end.

:w [file] (CR) : Save into a new file [file], but do not end.

:w! [file] (CR) : Save or resave into an existing file [file], but do not end.

:q (CR) : Quit vi without saving, provided no changes have been made

since the last save.

:q! (CR) : Quit vi without saving, living the file as it was in the last save.

:wq (CR) : Save the default file being edited, and quit.

ZZ : Save the edited file, provided not changes have been made since the
last save of the edited file to any file, and quit `vi'. {Warning: if you just
saved the edited file into any other file, the file will NOT be resaved. `:wq
(CR) is much safer to use.}

h or j or k or l : The arrow keys, such that

k = up
^
|
h = left <-- --> right = l
|
v
j = down
each take a number prefix that moves the cursor that many times.
(CR) : moves cursor a line forward; `+' also does.

-- : Moves cursor a line backward.

[N] (CR) : Moves cursor [N] lines forwards.

[N]-- : Moves cursor [N] lines backwards.

Ctrl-f : Moves cursor a page forward.

Ctrl-b : Moves cursor a page backward.

Ctrl-d : Moves cursor a half page down.

Ctrl-u : Moves cursor a half page up.

[L]G : Go to line [L]. `1G' moves the cursor to the beginning of the file
(BOF).

G : Go to the last line just before the end of file (EOF) mark. `$G' does
the same thing.

0 : Go to beginning of the line (BOL).

^ : Go to beginning of the nonblank part of the line (BOL).

~ : Got to first nonblank character on a line.

$ : Go to end of the line (EOL).

[N]| : Go to column [N] of the current line.

% : Find the matching parenthesis.

/[string] (CR) : Find the next occurrence of `[string]' forwards. Use `n' to
repeat, or `N' to search backwards.

?[string] (CR) : Find the next occurrence of` [string]' backwards.

n : Repeat last `/[string] (CR)' or `?[string] (CR)'; think of the file as

being wrapped around from end to beginning, so that when you return to
the start you know that you have found all occurrences.

N : Repeat last `/[string] (CR)' or `?[string] (CR)', but in reverse.

. : Repeat last change. This is best used along with the repeat search `n' or
`N'.

i[string](Esc) : Insert a string `[string]' before current character at the

cursor; the subcommand `i' itself and other subcommands are not
displayed; a `(CR)' in the string during the insert is used to continue input
on additional lines; end with the escape key `(Esc)' or `(Esc), (Esc)'.

o[string](Esc) : Opens a new line below the current line for insertion of
string `[string]'; end with `(Esc)' or `(Esc), (Esc)'; use for POWER
TYPING input for an old or new file; `O[string](Esc)' opens a new line
above the current line for insertion.

I[string](Esc) : Insert a string at the beginning of the current line (BOL),

else is like insert `i';a `(CR)' in the string during the insert is used to
continue input on additional lines; end with `(Esc)' or `(Esc), (Esc)'.

J : Joins next line to current line.

a[string](Esc) : Appends a string `[string]' following the current character

at the cursor, else it works like insert `i'; use `(CR)' in the string to
continue input onto new lines; end with `(Esc)'; also use for POWER
TYPING.

A[string](Esc) : Appends a string `[string]' at the end of a line (EOL),

works like `i' or `a'; use `(CR)' in the string to continue input onto new
lines; end with `(Esc)'; also use for POWER TYPING.

r[C](SPACE) : Replace a single character over the cursor by the single

character [C]; finalize with the Space-bar.

R[string](Esc) : Replace a string of characters by `[string]' in until `(Esc)'

is typed to end.

s[string](Esc) : Substitutes the string `[string]' for the single character at

the cursor. The multiple form `[N]s[string](Esc)' substitutes `[string]' for
the `[N]' characters starting at the cursor.

x : Delete the current character at the cursor.

d(SPACE) : Deletes a single character. `[N]d(SPACE)' deletes `[N]'

characters.

dd : Deletes the current line. `[N]dd' deletes `[N]' lines.

D : Deletes from the cursor to the end of line (EOL).

dw : Deletes the current word; `[N]dw' deletes `[N]' words.

w : Move cursor to the beginning of the next word. `[N]w' moves the
cursor `[N]' words forward. `[N]b' moves it `[N]' words backward. `[N]e'
moves it to the end of the word.

[N]y(SPACE) : Yanks `[N]' characters starting at the cursor and puts

them into the default buffer. `[N]yy' yanks `[N]' lines.
 p : Puts the current contents of the default buffer after the cursor if
characters or after the current line if lines. Helpful to use right after a
character yank `y' or a character delete `d' or a line yank `yy' or a line
delete `dd', along with a search `/[string](CR)' or repeat search `n'. and a
repeat change `.'. `P' puts the contents of the default buffer before the
current line.

"b[N]Y : Yank [N] lines starting with the current line to the buffer labeled
b; the double quote {"} is used to avoid an id conflict with subcommand
names; any letter other than `x' can be used to name the buffer; safer
than the line yank `yy' because it is very easy to accidentally change the
default buffer.

"b[N]dd : Deletes [N] lines starting with the current line to the buffer
labeled `b'.

"bp : Put back lines from the buffer labeled `b' after or below the cursor;
use after a yank or delete to a labeled buffer to move groups of lines from
one location to another.

"bP : Put back lines from the buffer labeled `b' before or above the
cursor; use after a yank or delete to a labeled buffer to move groups of
lines from one location to another.

Some `ex' editor commands that are useful in `vi' follow the `:' prompt. See the
previous section on `ex' for more commands.

:nu (CR) : Number current line.

:[L1],[L2] d (CR) : Deletes lines `[L1]' to `[L2]'.

:[L1],[L2] m [L3] (CR) : Move lines `[L1]' to `[L2]' to after line `[L3]'.

:[L1],[L2] t [L3] (CR) : Take [copy] lines `[L1]' to `[L2]` to `[L3]';

destination `[L3]' can not be in `[L1]' to `[L2]-1'.

:[L1],[L2]s/[string1]/[string2]/g (CR) : Substitute `[string2]' for all

`[string1]' in lines `[L1]' to `[L2]' only.

:s/[string1]/[string2]/gp (CR) : Substitute `[string2]' for all `[string1]' in

current line only and print change(s).

:g/[string1]/s/{/}[string2]/gp (CR) : Globally substitute `[string2]' for each

`[string1]' in all lines and print changes; works globally; use `?' in place of
`/' if `[string*]' contains a `/'.

:[L]r [file] (CR) : Append file [file] at line `[L]'.

Return to TABLE OF CONTENTS?

Web Source: http://www.math.uic.edu/~hanson/UNIX/UnixDictionary.html
Email Comments or Questions to hanson@uic.edu
 Skip to content

• Home
• Menus
• Glossary
• Help

Text size:

Search: Knowledge Base IU using

Include archived documents

Search results per page

Introduction to Unix commands

This is a very brief introduction to some useful Unix commands, including
examples of how to use each command. For more extensive information
about any of these commands, use the man command as described below.
Sources for more information appear at the end of this document.

Commands

cal cat cd chmod

cp date df du

find jobs kill less and more

lpr and lp ls man mkdir

mv ps pwd rm

rmdir set vi w and who

cal

This command will print a calendar for a specified month and/or year.
To show this month's calendar, enter:

cal

To show a twelve-month calendar for 2008, enter:

cal 2008

To show a calendar for just the month of June 1970, enter:

cal 6 1970

cat

This command outputs the contents of a text file. You can use it to read brief
files or to concatenate files together.

To append file1 onto the end of file2, enter:

cat file1 >> file2

To view the contents of a file named myfile, enter:

cat myfile

Because cat displays text without pausing, its output may quickly scroll off
your screen. Use the less command (described below) or an editor for
reading longer text files.

For more, see In Unix, how do I combine several text files into a single file?

cd

This command changes your current directory location. By default, your Unix
login session begins in your home directory.

To switch to a subdirectory (of the current directory) named myfiles, enter:

cd myfiles

To switch to a directory named /home/dvader/empire_docs, enter:

cd /home/dvader/empire_docs

To move to the parent directory of the current directory, enter:

cd ..

To move to the root directory, enter:

cd /

To return to your home directory, enter:

cd

chmod

This command changes the permission information associated with a file.

Every file (including directories, which Unix treats as files) on a Unix system
is stored with records indicating who has permission to read, write, or
execute the file, abbreviated as r, w, and x. These permissions are broken
down for three categories of user: first, the owner of the file; second, a group
with which both the user and the file may be associated; and third, all other
users. These categories are abbreviated as u for owner (or user), g for
group, and o for other.

To allow yourself to execute a file that you own named myfile, enter:

chmod u+x myfile

To allow anyone who has access to the directory in which myfile is stored
to read or execute myfile, enter:

chmod o+rx myfile

You can view the permission settings of a file using the ls command,
described below.

Note: Be careful with the chmod command. If you tamper with the directory
permissions of your home directory, for example, you could lock yourself out
or allow others unrestricted access to your account and its contents.

For more, see In Unix, how do I change the permissions for a file?

cp

This command copies a file, preserving the original and creating an identical
copy. If you already have a file with the new name, cp will overwrite and
destroy the duplicate. For this reason, it's safest to always add -i after
the cp command, to force the system to ask for your approval before it
destroys any files. The general syntax for cp is:
cp -i oldfile newfile

To copy a file named meeting1 in the directory /home/dvader/notes to

your current directory, enter:

cp -i /home/dvader/notes/meeting1 .

The . (period) indicates the current directory as destination, and the -i

ensures that if there is another file named meeting1 in the current directory,
you will not overwrite it by accident.

To copy a file named oldfile in the current directory to the new name
newfile in the mystuff subdirectory of your home directory, enter:

cp -i oldfile ~/mystuff/newfile

The ~ character (tilde) is interpreted as the path of your home directory.

Note: You must have permission to read a file in order to copy it.

date

The date command displays the current day, date, time, and year.

To see this information, enter:

date

df

This command reports file system disk usage (i.e., the amount of space
taken up on mounted file systems). For each mounted file system, df
reports the file system device, the number of blocks used, the number of
blocks available, and the directory where the file system is mounted.

To find out how much disk space is used on each file system, enter the
following command:

df

If the df command is not configured to show blocks in kilobytes by default,

you can issue the following command:

df -k

du
This command reports disk usage (i.e., the amount of space taken up by a
group of files). The du command descends all subdirectories from the
directory in which you enter the command, reporting the size of their
contents, and finally reporting a total size for all the files it finds.

To find out how much disk space your files take up, switch to your home
directory with the cd command, and enter:

du

The numbers reported are the sizes of the files; on different systems, these
sizes will be in units of either 512 byte blocks or kilobytes. To learn which is
the case, use the man command, described below. On most systems, du -k
will give sizes in kilobytes.

find

The find command lists all of the files within a directory and its
subdirectories that match a set of conditions. This command is most
commonly used to find all of the files that have a certain name.

To find all of the files named myfile.txt in your current directory and all of
its subdirectories, enter:

find . -name myfile.txt -print

To look in your current directory and its subdirectories for all of the files that
end in the extension .txt , enter:

find . -name "*.txt" -print

In these examples, the . (period) represents your current directory. It can

be replaced by the full pathname of another directory to search. For
instance, to search for files named myfile.txt in the directory
/home/user/myusername and its subdirectories, enter:

find /home/user/myusername/ -name myfile.txt -print

On some systems, omitting the final / (slash) after the directory name can
cause find to fail to return any results.

As a shortcut for searching in your home directory, enter:

find "$HOME/" -name myfile.txt -print

For more, see In Unix, what is the find command, and how do I use it to
search through directories for files?

jobs

This command reports any programs that you suspended and still have
running or waiting in the background (if you had pressed Ctrl-z to suspend
an editing session, for example). For a list of suspended jobs, enter:

jobs

Each job will be listed with a number; to resume a job, enter % (percent
sign) followed by the number of the job. To restart job number two, for
example, enter:

%2

This command is only available in the csh, bash, tcsh, and ksh shells.

kill

Use this command as a last resort to destroy any jobs or programs that you
suspended and are unable to restart. Use the jobs command to see a list of
suspended jobs. To kill suspended job number three, for example, enter:

kill %3

Now check the jobs command again. If the job has not been cancelled,
harsher measures may be necessary. Enter:

kill -9 %3

less and more

Both less and more display the contents of a file one screen at a time,
waiting for you to press the Spacebar between screens. This lets you read
text without it scrolling quickly off your screen. The less utility is generally
more flexible and powerful than more, but more is available on all Unix
systems while less may not be.

To read the contents of a file named textfile in the current directory,

enter:

less textfile
The less utility is often used for reading the output of other commands. For
example, to read the output of the ls command one screen at a time, enter:

ls -la | less

In both examples, you could substitute more for less with similar results. To
exit either less or more, press q . To exit less after viewing the file, press
q .

Note: Do not use less or more with executables (binary files), such as
output files produced by compilers. Doing so will display garbage and may
lock up your terminal.

lpr and lp

These commands print a file on a printer connected to the computer

network. The lpr command is used on BSD systems, and the lp command
is used in System V. Both commands may be used on the UITS systems.

To print a file named myfile on a printer named lp1 with lpr, enter:

lpr -Plp1 myfile

To print the same file to the same printer with lp, enter:

lp -dlp1 myfile

Note: Do not print to a printer whose name or location is unfamiliar to you.

For more, see In Unix, how do I print files and list or remove print jobs?

ls

This command will list the files stored in a directory. To see a brief, multi-
column list of the files in the current directory, enter:

ls

To also see "dot" files (configuration files that begin with a period, such as
.login ), enter:

ls -a

To see the file permissions, owners, and sizes of all files, enter:
ls -la

If the listing is long and scrolls off your screen before you can read it,
combine ls with the less utility, for example:

ls -la | less

For more, see In Unix, how do I list the files in a directory?

man

This command displays the manual page for a particular command. If you
are unsure how to use a command or want to find out all its options, you
might want to try using man to view the manual page.

For example, to learn more about the ls command, enter:

man ls

To learn more about man, enter:

man man

If you are not sure of the exact command name, you can use man with the
-k option to help you find the command you need. To see one line
summaries of each reference page that contains the keyword you specify,
enter:

man -k keyword

Replace keyword in the above example with the keyword which you want to
reference. Also see In Unix, what is the man command, and how do I use it
to read manual pages?

mkdir

This command will make a new subdirectory.

To create a subdirectory named mystuff in the current directory, enter:

mkdir mystuff

To create a subdirectory named morestuff in the existing directory named

/tmp, enter:
mkdir /tmp/morestuff

Note: To make a subdirectory in a particular directory, you must have

permission to write to that directory.

mv

This command will move a file. You can use mv not only to change the
directory location of a file, but also to rename files. Unlike the cp command,
mv will not preserve the original file.

Note: As with the cp command, you should always use -i to make sure
you do not overwrite an existing file.

To rename a file named oldname in the current directory to the new name
newname, enter:

mv -i oldname newname

To move a file named hw1 from a subdirectory named newhw to another

subdirectory named oldhw (both subdirectories of the current directory),
enter:

mv -i newhw/hw1 oldhw

If, in this last operation, you also wanted to give the file a new name, such as
firsthw, you would enter:

mv -i newhw/hw1 oldhw/firsthw

ps

The ps command displays information about programs (i.e., processes) that

are currently running. Entered without arguments, it lists basic information
about interactive processes you own. However, it also has many options for
determining what processes to display, as well as the amount of information
about each. Like lp and lpr, the options available differ between BSD and
System V implementations. For example, to view detailed information about
all running processes, in a BSD system, you would use ps with the following
arguments:

ps -alxww

To display similar information in System V, use the arguments:

ps -elf
For more information about ps refer to the ps man page on your system.
Also see In Unix, what do the output fields of the ps command mean?

pwd

This command reports the current directory path. Enter the command by
itself:

pwd

For more, see In Unix, how do I determine my current working directory?

rm

This command will remove (destroy) a file. You should enter this command
with the -i option, so that you'll be asked to confirm each file deletion. To
remove a file named junk, enter:

rm -i junk

Note: Using rm will remove a file permanently, so be sure you really want to
delete a file before you use rm.

To remove a non-empty subdirectory, rm accepts the -r option. On most

systems this will prompt you to confirm the removal of each file. This
behavior can be prevented by adding the -f option. To remove an entire
subdirectory named oldstuff and all of its contents, enter:

rm -rf oldstuff

Note: Using this command will cause rm to descend into each subdirectory
within the specified subdirectory and remove all files without prompting you.
Use this command with caution, as it is very easy to accidently delete
important files. As a precaution, use the ls command to list the files within
the subdirectory you wish to remove. To browse through a subdirectory
named oldstuff, enter:

ls -R oldstuff | less

rmdir

This command will remove a subdirectory. To remove a subdirectory named

oldstuff, enter:
rmdir oldstuff

Note: The directory you specify for removal must be empty. To clean it out,
switch to the directory and use the ls and rm commands to inspect and
delete files.

set

This command displays or changes various settings and options associated

with your Unix session.

To see the status of all settings, enter the command without options:

set

If the output scrolls off your screen, combine set with less:

set | less

The syntax used for changing settings is different for the various kinds of
Unix shells; see the man entries for set and the references listed at the end
of this document for more information.

vi

This command starts the vi text editor. To edit a file named myfile in the
current directory, enter:

vi myfile

The vi editor works fairly differently from other text editors. If you have not
used it before, you should probably look at a tutorial, such as How do I use
the vi text editor? Another helpful document for getting started with vi is A
quick reference list of vi editor commands.

The very least you need to know to start using vi is that in order to enter text,
you need to switch the program from command mode to insert mode by
pressing i . To navigate around the document with the cursor keys, you
must switch back to command mode by pressing Esc. To execute any of the
following commands, you must switch from command mode to ex mode by
pressing : (the colon key): Enter w to save; wq to save and quit;
q! to quit without saving.
w and who

The w and who commands are similar programs that list all users logged into
the computer. If you use w, you also get a list of what they are doing. If you
use who, you also get the IP numbers or computer names of the terminals
they are using.

Also see:

• In Unix, how do I remove files with names that contain strange

characters, such as spaces, semicolons, and backslashes?
• In Unix, how do I change my password?
• In Unix, what is a symbolic link, and how do I create one?
• In Unix, how do I change the permissions for a file?
• In Unix, how do I list the files in a directory?
• In Unix, what startup and termination files do the various shells use?
• In Unix, where can I get information on differences between the
various shells?
• In Unix, how do I undelete a file?
• What books are available for Unix, and where can I find them?
• In Unix, how do I get a printed copy of a manual page?
• In Unix, how can I find the correct path to an executable file?
• In Unix, how do I set my default (preferred) editor?
• In Unix, what is the find command, and how do I use it to search
through directories for files?
• For Unix, where can I find online tutorials?
• In Pine, how do I access Unix commands?
• In Unix, how can I split large files into a number of smaller files?
• In Unix, how do I combine several text files into a single file?
• In Unix, what is chsh, and how do I use it to change my shell?

This is document afsk in domain all.

Last modified on February 22, 2008.