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 cp find lpr and lp mv rmdir cat date jobs ls ps set cd df kill man pwd vi chmod du less and more mkdir rm 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, multicolumn 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.

Sign up to vote on this title
UsefulNot useful