Command Line Interface
Volume Number: 16 (2000)
Issue Number: 10
Column Tag: Mac OS X
An Intro to Mac OS X's Command Line Interface
by Andrew C. Stone
Back in the mid to late eighties, DOS was king and PC users would make fun of the "MacInToy" simply because it had no expert command line interface (CLI). Of course, this was before the PC world ditched their own command line interface in favor of an uglied-down graphical user interface that poorly copied the Macintosh's finely detailed GUI. Being an old Unix weenie from the academic Computer Science scene, I can understand the argument that the command line is an extremely powerful tool for expert users and programmers. Of course I also understand that it needs to be hidden from the casual user, lest they type "rm -rf /" as root and totally erase their hard disk!
And now, the CLI is just one more compelling feature of Mac OS X. OS X is based on Darwin, Apple's version of the open source FreeBSD 3.x combined with the Carnegie Melon University Mach 3.x kernel. The command line and all the standard Unix utilities are part and parcel of the developer distribution. While it is still not clear what will or won't ship to the end user in the final OS X, DP4 gives you Terminal.app (/System/Administration/Terminal.app) to provide a "shell" allowing you to type commands directly to the computer for both interactive and batch processing. This article is an introduction into the use of the command line, and I hope to provide enough information to convince unrepentent GUI freaks that a CLI is indeed useful, and share some cool tricks, tips and information on where to go to learn more.
She Sells C-shells
Once upon a time, there was just the c-shell, /bin/csh. However, Unix hackers love to cram more and more features into any one given program, so now there are several shell programs to pick from, including: tcsh, csh, zsh and bash. When you double-click Terminal.app to launch a shell, Terminal uses your default shell as the command line interface. In a standard installation, the default shell is tcsh. Your default shell is stored in NetInfo, and can be set by editing the User in /System/Administration/NetworkManager.app. Click on "Users", then select a user, then edit the shell field to the complete path of your desired default shell. You can always switch shells on the fly by just typing the name of new shell. Each shell has its strengths and supporters - you might play around to see which one you prefer. I use bash whenever I need to be able to include newlines (returns) in a command - and it handles filenames with embedded spaces rather well. Each of the various shells share a lot in common, but syntax does vary from shell to shell, so I'll just use the most basic examples here which at least apply to csh. In any regard, launch Terminal.app so you can start to play!
Man - the manual pages
One of the Unix shell's most useful features is the builtin manual pages, which document all the commands. Before we learn about "man", a short discussion of why Unix uses such cryptic and abbreviated names is in order! If you have some familiarity with DOS, you'll know that to copy a file, you type:
copy <FILE_1> <FILE_2>
The same command in Unix is "cp". It seems early Unix programmers hated to type and loved lacunae - and you'll learn Unix shell programming faster if you can uncover the mnemonic embedded in each command. For example, csh = C shell; mv = move; ln = link; ls = list; mkdir = make directory; etc. But the cool thing is that you don't have to remember much to use Unix because the man pages detail the use of every Unix command. For example, to learn about the manual pages, type:
man man
You'll see something like:
MAN(1) System Reference Manual MAN(1)
NAME
man - display the on-line manual pages
SYNOPSIS
man [-achw] [-C file] [-M path] [-m path] [section] name ...
DESCRIPTION
The man utility displays the BSD Unix manual pages
entitled name.
The options are as follows:
-a Display all of the manual pages for a
specified section and name combination.
(Normally, only the first manual page found is displayed.)
....
When you can't remember the command that you want to learn about, you can always try the apropos command, which searches the man pages' names for the given word. For example, typing
apropos directory
gives back a list of Unix commands whose description includes "directory" (directory is the Unix term for folder).
DirHandle(3) - supply object methods for directory handles
FindBin(3) - Locate directory of original perl script
Tcl_TranslateFileName(3) - convert file name to native form and replace tilde
with home directory
basename(1), dirname(1) - return filename or directory
portion of pathname
cd(1) - change working directory
cd(n) - Change working directory
chdir(2), fchdir(2) - change current working directory
chroot(2) - change root directory
chroot(8) - change root directory
dir(5), dirent(5) - directory file format
directory(3), opendir(3), readdir(3), telldir(3), seekdir(3), rewinddir(3),
closedir(3), dirfd(3) - directory operations
ditto(8) - copy source directories to destination
directory
getcwd(3) - get pathname of current working directory
getcwd(3), getwd(3) - get working directory pathname
getdirentries(2) - get directory entries in a filesystem
independent format
ls(1) - list directory contents
mkdir(2) - make a directory file
mtree(8) - map a directory hierarchy
nifind(1) - find a directory in the NetInfo hierarchy
pax(1) - read and write file archives and copy
directory hierarchies
pwd(1) - return working directory name
pwd(n) - Return the current working directory
remove(3) - remove directory entry
rm(1) - remove directory entries
rmdir(2) - remove a directory file
scandir(3), alphasort(3) - scan a directory
unlink(2) - remove directory entry
whois(1) - Internet user name directory service
Apropos reveals the rich set of commands available to both the command line user and C programmer . The number following the command indicates which man subdirectory should be consulted. To read about a man page in a particular subsection, for example, scandir(3), you'd type:
man 3 scandir
If you just typed that in, you'll notice that it's actually a C language prototype, and not really available as a command line call! If the subdirectory is 1, it's a shell command; otherwise it's a C function. Still, most standard C library functions are exposed as callable binary programs or shell scripts.
Anatomy of a Shell Command
After looking at a few Unix man pages, you'll notice that a consistent style is used to make it easy to grasp the functionality and options of a command. The simplest example is a command which takes no flags or arguments, for example:
date
A flag modifies how the command works and is represented by a letter or digit which follows a "-" (dash) or another flag. Arguments are input to the command, such as filenames or folders:
cp -rf /bin/cat /tmp/catty
- - ---- -----
command flags argument 1 argument 2
The man page presents a synopsis of the command in a standardized notation to express when a flag or argument is optional and/or repeatable. Let's look at the first example of the synopsis of "man" to learn how to decode the notation:
man [-achw] [-C file] [-M path] [-m path] [section] name ...
Anything enclosed within "[" and "]" represents optional flags and arguments. For example you could include -a or -c or -ac or -ca or -achw as valid flags to the man command.
When a word follows a flag, you must provide an argument if you use that flag. For example [-M path] means that if you use the optional -M flag, you must follow it with a full path name.
If you see ellipses, such as at the end of the synopsis, it means you can provide any number of additional names as arguments to the command.
All of the flags and arguments are described in the body of the man page for the command. Also, at the end of the man page is a section which gives additional related commands. For instance, on man's man page, you would find:
SEE ALSO
apropos(1), whatis(1), whereis(1), man.conf(5), mdoc(7), mdoc.samples(7)
Do a "man" on some of these to keep learning more.
Less Typing, More Power
Power users, who are always looking for ways to maximize the amount accomplished with a minimal amount of typing, use initialization files to personalize their shells. Initialization files contain environmental variables, aliases, and other customizations, such as a clever shell prompt. Each shell program looks for a different initialization file; for example, csh uses ~/.cshrc and bash uses ~/.bashrc. Extra Credit: using man, find the name of the initialization file for tsch!
Aliases are short cuts to make complex commands that you use available with just a few typed characters. For example, let's say you always want to see your directory files listed in reverse order of the time created, that is, with the newest files listed at the top with the long listing:
ls -lt
You could add this line to your ~/.cshrc file:
alias lt "ls -lt"
Next time you start a c shell (or type the command "source ~/.cshrc" to reread the initialization file), when you type "lt", you'll get the equivalent of typing "ls -lt". People love to put gnarly prompt creation commands in their init files, and this example is about as scary as they get:
alias cd 'cd \!*; set currDir = 'basename $cwd'; set currDir = 'echo "<${host}:"$currDir
" ! >"'; set prompt = "${currDir} "'
cd $cwd
This produces a lovely, palatable prompt which tells you which machine you are on, which directory you are in, and the number of the current command, for example:
<hermione:Developer 24 >
Which leads us to a discussion of typing less through use of history and command substitution. Your "history" is a record of the commands you've issued. Type
history
to see a numbered list of the commands you have typed recently:
1 cd
2 cd Library/Preferences/
3 rm ApplicationCacheTheFinalChapter
4 ps -axw | grep Mail
5 man man
6 apropos link
7 apropos time
8 apropos link
9 apropos directory
To repeat a previous command, for example, "man man", simply type:
!5
!5 is pronounced "BANG-5" in Unix. A "*" is "splat". A "|" is a pipe, although French Surrealist painter Renð Magritte would say, "Ce n'est pas un pipe"!
To repeat the last command issued, type:
!!
To refer to the last argument of the last command, use"!$". For example:
cat !$
displays the contents of the last file you referenced in your last command.
In some shells, you can use your up and down arrow keys to repeat commands issued before.
Because many shell commands operate on files, and because typing file names is tedious and prone to error, you have various shortcut options.
Most shells have builtin "escape completion" which will complete the names of files and folders if you type the first few unique characters and then type your escape completion key (this might be "ESC" or F5 or even TAB in some shells). The vanilla C shell has this turned off by default, but you can add the following line to your .cshrc file to enable escape completion:
set filec
As of DP4, the default shell is tsch, which has escape completion on. Type two escapes if one escape doesn't complete anything.
And, for you GUI junkies, OS X lets you drag and drop files or folders from the Finder onto shells, instead of laboriously typing out entire path names. You'll even get the correct escape codes for spaces, or perhaps the whole path will be correctly quoted. Because the shell interprets "words" (alphanumberic strings separated by spaces or tabs), you need to use to either "escape" the characters with a backslash:
cd /Mac\ OS\ X
or type it with quotes:
cd "/Mac OS X"
Bulk Processing and Iterations
Where a CLI has it all over a GUI is when you need to perform some boring, repetitve task on a bunch of files. For example, suppose you want to change the path extension of a whole folder full of files, say from ".TIF" to ".tiff" You can't do this in a GUI without an additional program, but in the C shell, you can use a simple looping shell command, using the "foreach" statement. Type:
foreach i ( *.TIF )
At this point, you enter an interactive subshell with a new prompt, " ? ". You can type any number of commands for sequential processing, referring to the current file as $i, and the "root" of that file ($i:r), ie, the filename's full path removing it's path extension. See "man cshrc" for more info on referring to parts of a file path. Finally, when you are finished issuing commands, type end and computation begins.
? echo $i // which file are we on? We'll print it out
? mv $i $i:r.tiff // move that file to the same name, less extension, plus .tiff
? end // this terminates the loop and begins processing
Plumbing: Input, Output and Pipes
Unix is designed for hooking up the output from one process to the input of another. This is done through two basic mechanisms: redirection of standard input/standard output and pipes.
The less than symbol, "<", means take input from whatever is producing output on the right hand side of the "<". For example, you can use the command line "mail" to send ascii files:
mail harry@stone.com < /etc/hostconfig
You can use I/O redirection whenever a command expects standard input (stdin) or produces standard output (stdout). When a process expects a feed of input, then you must rely on the chaining of processes through pipes. Pipes can be used effectively with gnutar to copy large trees of files to new locations:
(/usr/bin/gnutar chf - Stone_CD) | (cd /BackUp; /usr/bin/gnutar xf -)
Note how you can also stage commands by separating them with a ";". Here, we are creating a new "tar" archive, changing to a new directory, and then unarchiving it to standard out, thus copying the original hierarchy of files to this new location.
Once you get the hang of Unix, you'll find that you can do all sorts of tasks. For example, the age old bean counting task of counting lines of code can be done trivially using the powerful and confusing "find" piped to the meta-command "xargs" which calls the word count program "wc". Assuming you have changed directory to the top level of your source code, type:
find . -name '*.[hmc]' | xargs wc -l
which translates to: beginning at the top level in this current directory, recursively find all files which end in either .h, .c or .m, and use each file found as the input to the word counting program, with the option of counting only lines (not words or characters), with the bonus of providing a grand total of lines. What may look like jibberish will soon become recognizable and habitual!
And, for authors paid by the word and to honor the oft times obfuscated nature of Unix, here's an alias for your initialization file:
alias wordcount
(cat !* | tr -s ' .,;:?!()[]"' '\012' | cat -n | tail -1 | awk '{print $1}')
and you would use it in a source directory by typing:
wordcount *.[hmc]
To go "deeper" you just add on more arguments:
wordcount *.[hmc] */*[hmc] */*/*[hmc]
Conclusion
It takes years to learn Unix completely, but only moments to learn enough to be useful. The online man pages allow a quick refresher course in any command and are an excellent lifetime teaching tool. The shell is a power user's friend and can expand the capabilities and productivity of OS X. Granted that it is not for everyone, but for those who dare, it's a true bonus!
Andrew Stone <andrew@stone.com> is founder of Stone Design Corp <http://www.stone.com/> and has spent 12 years writing Cocoa software in its various incarnations.
