The UNIX manual is mostly on line and the UNIX `man' command is used to display parts of the manual. Typing
man [command] (CR)
man -q command] (CR)
man [command] > [file] (CR)
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
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.
login (CR) : Logon command.
logout (CR) : Logoff command.
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.
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.
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]'.
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.
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.
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.
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.
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)'}.
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'.
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.
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'.
`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.
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]'.
Email Comments or Questions to hanson@uic.edu