Unix Power Tools 2ND Edition

This edition slants the blend of options and commands toward the POSIX utilities, including the GNU versions. It thoroughly covers the bash and tcsh shells, including emphasis on the core concepts of sh and csh that will help you use all Unix shells. Plus, there is more emphasis on Perl. You'll find articles abstracted from other O'Reilly books, new information that highlights program "tricks" and "gotchas", tips posted to the Net over the years, and other accumulated wisdom.

The CD-ROM includes all of the scripts and aliases from the book, plus perl, GNU emacs, netpbm (graphics manipulation utilities), ispell, screen, the sc spreadsheet, and about 60 other freeware programs. In addition to the source code, all the software is pre-compiled for Sun4, Digital Unix, IBM AIX, HP/UX, Red Hat Linux, Solaris, and SCO Unix.

 Table of Contents

Preface

Chapter 1.  Introduction 
   1.01 What's Special About UNIX? 
   1.02 Who Listens to What You Type? 
   1.03 Programs Are Designed to Work Together 
   1.04 Using Pipes to Create a New Tool 
   1.05 Anyone Can Program the Shell 
   1.06 Power Tools for Editing 
   1.07 Power Grows on You 
   1.08 There Are Many Shells 
   1.09 Which Shell Am I Running? 
   1.10 Internal and External Commands 
   1.11 How the Shell Executes Other Commands 
   1.12 What Makes a Shell Script? 
   1.13 Why Fundamentals Are Important 
   1.14 The Kernel and Daemons 
   1.15 Filenames 
   1.16 Wildcards 
   1.17 Filename Extensions 
   1.18 Who Handles Wildcards? 
   1.19 The Tree Structure of the Filesystem 
   1.20 Your Home Directory 
   1.21 Making Pathnames 
   1.22 How UNIX Keeps Track of Files: Inodes 
   1.23 File Access Permissions 
   1.24 The Superuser (Root) 
   1.25 Access to Directories 
   1.26 What a Multiuser System Can Do for You 
   1.27 How Background Processing Works 
   1.28 Some Gotchas with Background Processing 
   1.29 When Is a File Not a File? 
   1.30 Redirecting Input and Output 
   1.31 The X Window System 
   1.32 One Big Hole 
   1.33 UNIX Networking and Communications 
   1.34 What's Wrong with UNIX 

PART One: Making Yourself at Home 

Chapter 2.  Logging In 
   2.01 Customizing the Shell 
   2.02 Shell Setup Files--Which, Where, and Why 
   2.03 What Goes in Shell Setup Files? 
   2.04 Tip for Changing Account Setup: Keep a Shell Ready 
   2.05 Tips for Speeding up Slow Logins 
   2.06 Use Absolute Pathnames in Shell Setup Files 
   2.07 C Shell Setup Files Aren't Read When You Want Them to Be? 
   2.08 Identifying Login Shells 
   2.09 Speeding Up Your C Shell with set prompt Test 
   2.10 Gotchas in set prompt Test 
   2.11 Faster ksh and bash Startup with $- Test 
   2.12 Automatic Setups for Different Terminals 
   2.13 A .cshrc.$HOST File for Per Host Setup 
   2.14 motd.diff: Show New Lines in Login Messages 
   2.15 Unclutter Logins: Show Login Messages Just Once 
   2.16 Approved Shells: Using Unapproved Login Shell 
Chapter 3.  Logging Out 
   3.01 Running Commands When You Log Out 
   3.02 Running Commands at Bourne/Korn Shell Logout 
   3.03 Electronic Fortune Cookies 
   3.04 Automatic File Cleanup 
   3.05 Stop Accidental C Shell Logouts 
   3.06 Stop Accidental Bourne Shell Logouts 
   3.07 Detaching a Session with screen 
   3.08 What tty Am I On? 
Chapter 4.  Organizing Your Home Directory 
   4.01 What? Me, Organized? 
   4.02 A bin Directory for Your Programs and Scripts 
   4.03 Organizing Nonexecutable Scripts 
   4.04 Directories for Emacs Hacks 
   4.05 Private (Personal) Directories 
   4.06 Naming Files 
   4.07 Make More Directories! 
   4.08 Making Directories Made Easier 
   4.09 Setting Up vi with the .exrc File 
   4.10 Find All Command Versions with whereiz 
Chapter 5.  Setting Up Your Terminal 
   5.01 There's a Lot to Know About Terminals 
   5.02 The Idea of a Terminal Database 
   5.03 Setting the Terminal Type When You Log In 
   5.04 Setting the TERMCAP Variable with tset 
   5.05 Querying Your Terminal Type: qterm 
   5.06 Checklist: Terminal Hangs When I Log In 
   5.07 What termcap and terminfo Do and Don't Control 
   5.08 Terminal Escape Sequences 
   5.09 Setting Your Erase, Kill, and Interrupt Characters 
   5.10 Finding What Terminal Names You Can Use 
   5.11 Initializing the Terminal with tset 
   5.12 Initializing the Terminal with tput 
Chapter 6.  Shell and Environment Variables 
   6.01 What Environment Variables Are Good For 
   6.02 Parent-Child Relationships 
   6.03 Predefined Environment Variables 
   6.04 The PATH Environment Variable 
   6.05 PATH and path 
   6.06 The TZ Environment Variable 
   6.07 What Time Is It in Japan? 
   6.08 Shell Variables 
   6.09 Special C Shell Variables 
   6.10 Running a Command with a Different Environment 
Chapter 7.  Setting Your Shell Prompt 
   7.01 Why Change Your Prompt? 
   7.02 Basics of Setting the Prompt 
   7.03 C Shell Prompt Causes Problems in vi, rsh, etc. 
   7.04 Faster Prompt Setting with Built-Ins 
   7.05 Multiline Shell Prompts 
   7.06 Session Information in Your Terminal's Status Line 
   7.07 A "Menu Prompt" for Naive Users 
   7.08 Highlighting in Shell Prompts 
   7.09 Show Subshell Level with $SHLVL 
   7.10 What Good Is a Blank Shell Prompt? 
   7.11 dirs in Your Prompt: Better than $cwd 
   7.12 External Commands Send Signals to Set Variables 
   7.13 Pre-Prompt Commands in bash 

PART Two: Let the Computer Do the Dirty Work

Chapter 8.  How the Shell Interprets What You Type
   8.01 What the Shell Does 
   8.02 Introduction to bash 
   8.03 Introduction to tcsh 
   8.04 Command Evaluation and Accidentally Overwriting Files
   8.05 Command-Line Evaluation 
   8.06 Output Command-Line Arguments 
   8.07 Setting Your Search Path 
   8.08 A Directory for Commands You Shouldn't Run 
   8.09 Wildcards Inside of Aliases 
   8.10 eval: When You Need Another Chance 
   8.11 Which One Will bash Use? 
   8.12 Which One Will the C Shell Use? 
   8.13 Is It "2>&1 > file" or "> file 2>&1"?  Why? 
   8.14 Bourne Shell Quoting 
   8.15 Differences Between Bourne and C Shell Quoting 
   8.16 Quoting Handles Special Characters in Filenames 
   8.17 verbose and echo Variables Show Quoting 
   8.18 Here Documents 
   8.19 "Special" Characters and Operators 
   8.20 How Many Backslashes? 
Chapter 9.  Saving Time on the Command Line
   9.01 What's Special About the UNIX Command Line 
   9.02 Fix a Line Faster with Line-Kill and Word-Erase 
   9.03 Reprinting Your Command Line with CTRL-r 
   9.04 Use Wildcards to Create Files? 
   9.05 Build Strings with {\ } 
   9.06 String Editing (Colon) Operators 
   9.07 String Editing in ksh and bash 
   9.08 Filename Completion: Faster Filename Typing 
   9.09 Don't Match Useless Files in Filename Completion 
   9.10 Filename Completion Isn't Always the Answer 
   9.11 Repeating a Command with a foreach Loop 
   9.12 The Bourne Shell for Loop 
   9.13 Multiline Commands, Secondary Prompts 
   9.14 Using Here Documents for Form Letters, etc. 
   9.15 Throwaway Scripts for Complicated Commands 
   9.16 Command Substitution 
   9.17 Handling Lots of Text with Temporary Files 
   9.18 Process Substitution 
   9.19 For the Impatient: Type-Ahead 
   9.20 Too Many Files for the Command Line 
   9.21 Handle Too-Long Command Lines with xargs 
   9.22 xargs: Problems with Spaces and Newlines 
   9.23 Workaround for "Arguments Too Long" Error 
   9.24 Get File List by Editing Output of ls -l, grep, etc. 
   9.25 The C Shell repeat Command 
   9.26 Expect 
Chapter 10.  Aliases 
   10.01 Creating Custom Commands 
   10.02 Aliases for Common Commands 
   10.03 C Shell Aliases with Command-Line Arguments 
   10.04 Aliases in ksh and bash 
   10.05 Sourceable Scripts 
   10.06 Avoiding C Shell Alias Loops 
   10.07 How to Put if-then-else in a C Shell Alias 
   10.08 Fix Quoting in csh Aliases with makealias and quote 
   10.09 Shell Functions 
   10.10 Simulated Bourne Shell Functions and Aliases 
Chapter 11.  The Lessons of History 
   11.01 The Lessons of History 
   11.02 History in a Nutshell 
   11.03 My Favorite Is !$ 
   11.04 My Favorite Is !:nx 
   11.05 My Favorite Is ^ 
   11.06 Using !$ for Safety with Wildcards 
   11.07 History Substitutions 
   11.08 Repeating a Cycle of Commands 
   11.09 Running a Series of Commands on a File 
   11.10 Check Your History First with :p 
   11.11 Picking Up Where You Left Off 
   11.12 Pass History to Another Shell 
   11.13 Shell Command-Line Editing 
   11.14 More Ways to Do Interactive History Editing 
   11.15 Changing C Shell History Characters with histchars 
   11.16 Instead of Changing History Characters 
Chapter 12.  Job Control 
   12.01 Job Control: Work Faster, Stop Runaway Jobs 
   12.02 Other Ways to Refer to Jobs 
   12.03 The "Current Job" Isn't Always What You Expect 
   12.04 Job Control and autowrite: Real Time Savers! 
   12.05 System Overloaded? Try Stopping Some Jobs 
   12.06 Notification When Jobs Change State 
   12.07 Stop Background Output with stty tostop 
   12.08 Job Control in a Nutshell 
   12.09 Running Multiple Shell Sessions with screen 
Chapter 13.  Redirecting Input and Output 
   13.01 Using Standard Input and Output 
   13.02 One Argument with a cat Isn't Enough 
   13.03 Send (only) Standard Error Down a Pipe 
   13.04 Problems Piping to a Pager 
   13.05 Redirection in C Shell: Capture Errors, Too? 
   13.06 Safe I/O Redirection with noclobber 
   13.07 The (\) Subshell Operators 
   13.08 Using {\list\} to Group Bourne Shell Commands 
   13.09 Send Output Two or More Places with tee 
   13.10 How to tee Several Commands Into One File 
   13.11 tpipe--Redirecting stdout to More than One Place 
   13.12 Writing to Multiple Terminals for Demonstrations 
   13.13 The "Filename" - 
   13.14 What Can You Do with an Empty File? 
   13.15 What to Do with a Full Bit Bucket :-)
   13.16 Store and Show Errors with logerrs 

PART Three: Working with the Filesystem 

Chapter 14.  Moving Around in a Hurry 
   14.01 Getting Around the Filesystem 
   14.02 Using Relative and Absolute Pathnames 
   14.03 What Good Is a Current Directory? 
   14.04 How Does UNIX Find Your Current Directory? 
   14.05 Saving Time When You Change Directories: cdpath 
   14.06 The Shells' pushd and popd Commands 
   14.07 Nice Aliases for pushd 
   14.08 Quick cds with Aliases 
   14.09 cd by Directory Initials 
   14.10 Variables Help You Find Directories and Files 
   14.11 Finding (Anyone's) Home Directory, Quickly 
   14.12 Marking Your Place with a Shell Variable 
   14.13 Which Directory Am I in, Really? 
   14.14 Automatic Setup When You Enter/Exit a Directory 
Chapter 15.  Wildcards 
   15.01 File Naming Wildcards 
   15.02 Filename Wildcards in a Nutshell 
   15.03 Adding { } Operators to Korn (and Bourne) Shells 
   15.04 What if a Wildcard Doesn't Match? 
   15.05 Matching All "Dot Files" with Wildcards 
   15.06 Maybe You Shouldn't Use Wildcards in Pathnames 
   15.07 Getting a List of Matching Files with grep -l 
   15.08 Getting a List of Non-Matching Files with grep -c 
   15.09 nom: List Files that Don't Match a Wildcard 
   15.10 Wildcards that Match Only Directories 
Chapter 16.  Where Did I Put That? 
   16.01 Everything but the find Command 
   16.02 Finding Oldest or Newest Files with ls -t and ls -u 
   16.03 Reordering ls Listings 
   16.04 List All Subdirectories with ls -R 
   16.05 The Three UNIX File Times 
   16.06 clf, cls: "Compressed" ls Listings 
   16.07 ls Shortcuts: ll, lf, lg, etc. 
   16.08 The ls -d Option 
   16.09 An Alias to List Recently Changed Files 
   16.10 findcmd: Find a Command in Your Search Path 
   16.11 Showing Hidden Files with ls -A and -a 
   16.12 Useful ls Aliases 
   16.13 Can't Access a File? Look for Spaces in the Name 
   16.14 Showing Non-Printable Characters in Filenames 
   16.15 Script with a :-) for UNIX Converts: dir, ..., ... 
   16.16 Picking a Unique Filename Automatically 
   16.17 Getting Directory Name from a File's Pathname 
   16.18 Listing Files You've Created/Edited Today 
   16.19 stree: Simple Directory Tree 
   16.20 The vtree Visual Directory Tree Programs 
   16.21 Finding All Directories with the Same Name 
   16.22 Comparing Two Directory Trees with dircmp 
   16.23 Comparing Filenames in Two Directory Trees 
   16.24 Counting Files by Types 
   16.25 Listing Files by Age and Size 
   16.26 Finding Text Files with findtext 
   16.27 newer: Print the Name of the Newest File 
   16.28 oldlinks: Find Unconnected Symbolic Links 
   16.29 sls: Super ls with Format You Can Choose 
Chapter 17.  Finding Files with find 
   17.01 The find Command Is Great
   17.02 Delving Through a Deep Directory Tree 
   17.03 Don't Forget -print 
   17.04 Looking for Files with Particular Names 
   17.05 Searching for Old Files 
   17.06 Be an Expert on find Search Operators 
   17.07 The Times that find Finds 
   17.08 Exact File Time Comparisons 
   17.09 Problems with -newer 
   17.10 Running Commands on What You Find 
   17.11 Using -exec to Create Custom Tests 
   17.12 Finding Many Things with One Command 
   17.13 Searching for Files by Type 
   17.14 Searching for Files by Size 
   17.15 Searching for Files by Permission 
   17.16 Searching by Owner and Group 
   17.17 Duplicating a Directory Tree
   17.18 Using "Fast find" 
   17.19 Finding Files (Much) Faster with a find Database 
   17.20 grepping a Directory Tree (and a Gotcha) 
   17.21 lookfor: Which File Has that Word? 
   17.22 Finding the Links to a File 
   17.23 Finding Files with -prune 
   17.24 Skipping Some Parts of a Tree in find
   17.25 Keeping find From Searching Networked Filesystems
Chapter 18.  Linking, Renaming, and Copying Files
   18.01 What's So Complicated About Copying Files? 
   18.02 What's Really in a Directory 
   18.03 Files with Two or More Names 
   18.04 More About Links 
   18.05 Creating and Removing Links 
   18.06 Stale Symbolic Links 
   18.07 Linking Directories 
   18.08 Showing the Actual Filenames for Symbolic Links 
   18.09 Renaming, Copying, or Comparing a Set of Files 
   18.10 There's More than One Way to Do It 
   18.11 Renaming Files with ren 
   18.12 Renaming a List of Files Interactively 
   18.13 One More Way to Do It 
   18.14 Relinking Multiple Symbolic Links 
   18.15 Copying Directory Trees with cp -r 
   18.16 Copying Directory Trees with (tar | tar) 
Chapter 19.  Creating and Reading Archives 
   19.01 Packing Up and Moving 
   19.02 Introduction to Shell Archives 
   19.03 unshar: Unarchive a Shell Archive 
   19.04 A Simple Version of unshar 
   19.05 Using tar to Create and Unpack Archives 
   19.06 GNU tar Sampler 
   19.07 Extracting Files from a Compressed Archive 
   19.08 Problems with Verbose tar 
   19.09 A System V Tape Archiver: cpio 
Chapter 20.  Backing Up Files 
   20.01 tar in a Nutshell 
   20.02 Make Your Own Backups 
   20.03 How to Make Backups with a Local Tape Drive 
   20.04 Restoring Files from Tape with tar 
   20.05 Using tar to a Remote Tape Drive 
   20.06 Writing a Tape Drive on a Remote Machine 
   20.07 Creating a Timestamp File for Selective Backups 
   20.08 Telling tar Which Files to Exclude or Include 
   20.09 When a Program Doesn't Understand Wildcards 
   20.10 Avoid Absolute Paths with tar 
   20.11 Getting tar's Arguments in the Right Order 
   20.12 Protecting Files with SCCS or RCS 
   20.13 SCCS Basics 
   20.14 RCS Basics 
   20.15 List RCS Revision Numbers with rcsrevs 
Chapter 21.  More About Managing Files 
   21.01 A Grab-Bag 
   21.02 A Better Place for Temporary Files: /\tmp 
   21.03 Unique Names for Temporary Files 
   21.04 Why Both /\tmp and /usr/\tmp? 
   21.05 What Good Is a File's Last Access Time? 
   21.06 A File's Inode Change (not "Creation"!) Time 
   21.07 Setting File Modification Time with touch 
   21.08 The MAILCHECK and mail Variables Check More than Mail
   21.09 Keep File Printouts Up-to-Date Automatically with make
   21.10 Keep a Directory Listing at Top of the Screen: dirtop 
   21.11 Safer Removing, Moving, and Copying 
   21.12 Copying Files to a Directory 
   21.13 Read an Inode with stat 
   21.14 Automatically Appending the Date to a Filename 
Chapter 22.  File Security, Ownership, and Sharing
   22.01 Introduction to File Ownership and Security 
   22.02 Tutorial on File and Directory Permissions 
   22.03 Who Will Own a New File? 
   22.04 Setting an Exact umask 
   22.05 Group Permissions in a Directory with the setgid Bit 
   22.06 Protecting Files with the Sticky Bit 
   22.07 Using chmod to Change File Permission 
   22.08 The Handy chmod = Operator 
   22.09 Protect Important Files: Make Them Unwritable 
   22.10 cx, cw, c-w: Quick File Permission Changes 
   22.11 A Loophole: Modifying Files Without Write Access 
   22.12 A Directory that People Can Access but Can't List 
   22.13 Groups and Group Ownership 
   22.14 Add Users to a Group to Deny Permission 
   22.15 Juggling Permissions 
   22.16 Copying Permissions with cpmod 
   22.17 Ways of Improving the Security of crypt 
   22.18 Clear Your Terminal for Security, to Stop Burn-in 
   22.19 Shell Scripts Must be Readable and (Usually) Executable
   22.20 Why Can't You Change File Ownership Under BSD UNIX?
   22.21 How to Change File Ownership Without chown 
   22.22 The su Command Isn't Just for the Superuser 
Chapter 23.  Removing Files 
   23.01 The Cycle of Creation and Destruction 
   23.02 rm and Its Dangers 
   23.03 Tricks for Making rm Safer 
   23.04 Answer "Yes" or "No" Forever with yes 
   23.05 Remove Some, Leave Some 
   23.06 A Faster Way to Remove Files Interactively 
   23.07 Safer File Deletion in Some Directories 
   23.08 Safe Delete: Pros and Cons 
   23.09 delete: Protecting Files from Accidental Deletion 
   23.10 Deletion with Prejudice: rm -f 
   23.11 Deleting Files with Odd Names 
   23.12 Using Wildcards to Delete Files with Strange Names 
   23.13 Deleting Files with the Null Name 
   23.14 Handling a Filename Starting with a Dash (-) 
   23.15 Using unlink to Remove a File with a Strange Name 
   23.16 Removing a Strange File by its I-number 
   23.17 Problems Deleting Directories 
   23.18 How Making and Deleting Directories Works 
   23.19 Deleting (BSD) Manual Pages that Aren't Read 
   23.20 Deleting Stale Files 
   23.21 Removing Every File but One 
   23.22 Using find to Clear Out Unneeded Files 
Chapter 24.  Other Ways to Get Disk Space 
   24.01 Instead of Removing a File, Empty It 
   24.02 Save Space with "Bit Bucket" Log Files and Mailboxes
   24.03 Unlinking Open Files Isn't a Good Idea 
   24.04 Save Space with a Link 
   24.05 Limiting File Sizes 
   24.06 Save Space with Tab Characters 
   24.07 Compressing Files to Save Space 
   24.08 Save Space: tar and compress a Directory Tree 
   24.09 How Much Disk Space? 
   24.10 zloop: Run a Command on Compressed Files 
   24.11 Edit Compressed Files with zvi, zex, and zed 
   24.12 Compressing a Directory Tree: Fine-Tuning 
   24.13 Save Space in Executable Files with strip 
   24.14 Don't Use strip Carelessly 
   24.15 Trimming a Directory 
   24.16 Trimming a Huge Directory 
   24.17 Disk Quotas 
   24.18 Huge Files Might Not Take a Lot of Disk Space 

PART Four: Looking Inside Files 

Chapter 25.  Showing What's in a File 
   25.01 Cracking the Nut 
   25.02 Four Ways to Skin a cat 
   25.03 Using more to Page Through Files 
   25.04 The "less" Pager: More than "more" 
   25.05 Page Through Compressed, RCS, Unprintable Files 
   25.06 What's in That White Space? 
   25.07 Show Non-Printing Characters with cat -v or od -c 
   25.08 Finding File Types 
   25.09 Adding and Deleting White Space 
   25.10 Squash Extra Blank Lines 
   25.11 crush: A cat that Skips all Blank Lines 
   25.12 Double Space, Triple Space ... 
   25.13 pushin: Squeeze Out Extra White Space 
   25.14 How to Look at the End of a File: tail 
   25.15 Finer Control on tail 
   25.16 How to Look at a File as It Grows 
   25.17 An Alias in Case You Don't Have tail 
   25.18 Watching Several Files Grow 
   25.19 Reverse Lines in Long Files with flip 
   25.20 Printing the Top of a File 
   25.21 Numbering Lines 
Chapter 26.  Regular Expressions (Pattern Matching)
   26.01 That's an Expression 
   26.02 Don't Confuse Regular Expressions with Wildcards 
   26.03 Understanding Expressions 
   26.04 Using Metacharacters in Regular Expressions 
   26.05 Getting Regular Expressions Right 
   26.06 Just What Does a Regular Expression Match? 
   26.07 Limiting the Extent of a Match 
   26.08 I Never Meta Character I Didn't Like 
   26.09 Valid Metacharacters for Different UNIX Programs 
   26.10 Pattern Matching Quick Reference with Examples 
Chapter 27.  Searching Through Files 
   27.01 Different Versions of grep 
   27.02 Searching for Text with grep 
   27.03 Finding Text That Doesn't Match 
   27.04 Finding a Pattern Only When It's a Word 
   27.05 Extended Searching for Text with egrep 
   27.06 Fast grep Isn't 
   27.07 grepping for a List of Patterns 
   27.08 glimpse and agrep 
   27.09 New greps Are Much Faster 
   27.10 Search RCS Files with rcsgrep 
   27.11 A Multiline Context grep Using sed 
   27.12 Make Custom grep Commands (etc.) with perl 
   27.13 More grep-like Programs Written in Perl 
   27.14 Compound Searches 
   27.15 Narrowing a Search Quickly 
   27.16 Faking Case-Insensitive Searches 
   27.17 Finding a Character in a Column 
   27.18 Fast Searches and Spelling Checks with "look" 
   27.19 Finding Words Inside Binary Files 
   27.20 A Highlighting grep 
Chapter 28.  Comparing Files 
   28.01 Checking Differences with diff 
   28.02 Comparing Three Different Versions with diff3 
   28.03 Context diffs 
   28.04 Side-by-Side diffs: sdiff 
   28.05 Comparing Files Alongside One Another 
   28.06 Choosing Sides with sdiff 
   28.07 diff for Very Long Files: bdiff 
   28.08 More Friendly diff Output 
   28.09 ex Scripts Built by diff 
   28.10 Problems with diff and Tabstops 
   28.11 cmp and diff 
   28.12 Comparing Two Files with comm 
   28.13 make Isn't Just for Programmers! 
   28.14 Even More Uses for make 
   28.15 Show Changes in a troff File with diffmk 
Chapter 29.  Spell Checking, Word Counting, and Textual Analysis
   29.01 The UNIX spell Command 
   29.02 Check Spelling Interactively with ispell 
   29.03 How Do I Spell That Word? 
   29.04 Inside spell 
   29.05 Adding Words to ispell's Dictionary 
   29.06 Counting Lines, Words, and Characters: wc 
   29.07 Count How Many Times Each Word Is Used 
   29.08 Find a a Doubled Word 
   29.09 Looking for Closure 
   29.10 Just the Words, Please 

PART Five: Text Editing 

Chapter 30.  vi Tips and Tricks 
   30.01 The vi and ex Editors: Why So Much Material? 
   30.02 What We Cover 
   30.03 Mice vs. vi 
   30.04 Editing Multiple Files with vi 
   30.05 Edits Between Files 
   30.06 Local Settings for vi and ex 
   30.07 Using Buffers to Move or Copy Text 
   30.08 Get Back What You Deleted with Numbered Buffers 
   30.09 Using Search Patterns and Global Commands 
   30.10 Confirming Substitutions in ex and vi 
   30.11 Keep Your Original File, Write to a New File 
   30.12 Saving Part of a File 
   30.13 Appending to an Existing File 
   30.14 Moving Blocks of Text by Patterns 
   30.15 Useful Global Commands (with Pattern Matches) 
   30.16 Counting Occurrences; Stopping Search Wraps 
   30.17 Capitalizing Every Word on a Line 
   30.18 Setting vi Options Automatically for Individual Files
   30.19 Modelines: Bug or Feature? 
   30.20 Multiple Editor Setup Files; Starting with a Search 
   30.21 Per File Setups in Separate Files 
   30.22 Filtering Text Through a UNIX Command 
   30.23 Safer vi Filter-Throughs 
   30.24 vi/ex File Recovery vs. Networked Filesystems 
   30.25 vi -r May not Write Recovered Buffer When You Exit 
   30.26 Shell Escapes
   30.27 vi Compound Searches 
   30.28 Keep Track of Functions and Included Files
   30.29 Setting Multiple tags Files 
   30.30 vi Outsmarts Dual-Function Function Keys 
   30.31 vi Word Abbreviation 
   30.32 Using vi Abbreviations as Commands
   30.33 Fixing Typos with vi Abbreviations 
   30.34 vi Line Commands vs. Character Commands 
   30.35 Out of Temporary Space? Use Another Directory 
   30.36 The ex Open Mode Can Be Handy 
   30.37 Neatening Lines 
   30.38 Finding Your Place with Undo 
Chapter 31.  Creating Custom Commands in vi 
   31.01 Why Type More Than You Have To? 
   31.02 Save Time and Typing with the vi map Commands 
   31.03 What You Lose When You Use map! 
   31.04 vi @-Functions 
   31.05 Keymaps for Pasting into a Window Running vi 
   31.06 Protecting Keys from Interpretation by ex 
   31.07 Maps for Repeated Edits 
   31.08 More Examples of Mapping Keys in vi 
   31.09 Good Stuff for Your .exrc File 
   31.10 Repeating a vi Keymap 
   31.11 Typing in Uppercase Without CAPS LOCK 
   31.12 Text-Input Mode Cursor Motion with No Arrow Keys 
   31.13 Making Cursor Keys Work in vi Text-input Mode 
   31.14 Don't Lose Important Functions with vi Maps: Use noremap
   31.15 Fooling vi into Allowing Complex Macros 
   31.16 vi Macro for Splitting Long Lines 
Chapter 32.  GNU Emacs 
   32.01 Emacs: The Other Editor 
   32.02 Emacs Features: A Laundry List 
   32.03 Customizations and How to Avoid Them 
   32.04 Backup and Auto-Save Files 
   32.05 Putting Emacs in Overwrite Mode 
   32.06 Command Completion 
   32.07 Mike's Favorite Time Savers 
   32.08 Rational Searches 
   32.09 Unset PWD Before Using Emacs 
   32.10 Inserting Binary Characters into Files 
   32.11 Using Word Abbreviation Mode 
   32.12 Getting Around Emacs Flow Control Problems 
   32.13 An Absurd Amusement 
Chapter 33.  Batch Editing 
   33.01 Why Line Editors Aren't Dinosaurs 
   33.02 Writing Editing Scripts 
   33.03 Line Addressing 
   33.04 Useful ex Commands 
   33.05 Running Editing Scripts Within vi 
   33.06 Change Many Files by Editing Just One 
   33.07 ed/ex Batch Edits: Avoid Errors When No Match 
   33.08 Batch Editing Gotcha: Editors Bomb on Big Files 
   33.09 patch: Generalized Updating of Files that Differ 
   33.10 Quick Globals from the Command Line with qsubst 
   33.11 Quick Reference: awk 
   33.12 Versions of awk 
Chapter 34.  The sed Stream Editor 
   34.01 Two Things You Must Know About sed 
   34.02 Invoking sed 
   34.03 Testing and Using a sed Script: checksed, runsed 
   34.04 sed Addressing Basics 
   34.05 Order of Commands in a Script 
   34.06 One Thing at a Time 
   34.07 Delimiting a Regular Expression 
   34.08 Newlines in a sed Replacement 
   34.09 Referencing the Search String in a Replacement 
   34.10 Referencing Portions of a Search String 
   34.11 Search & Replacement: One Match Among Many 
   34.12 Transformations on Text 
   34.13 Hold Space: The Set-Aside Buffer 
   34.14 Transforming Part of a Line 
   34.15 Making Edits Across Line Boundaries 
   34.16 The Deliberate Scrivener 
   34.17 Searching for Patterns Split Across Lines 
   34.18 Multiline Delete 
   34.19 Making Edits Everywhere Except... 
   34.20 The sed Test Command 
   34.21 Uses of the sed Quit Command 
   34.22 Dangers of the sed Quit Command 
   34.23 sed Newlines, Quoting, and Backslashes in a Shell Script
   34.24 Quick Reference: sed 
Chapter 35.  You Can't Quite Call This Editing 
   35.01 And Why Not? 
   35.02 Neatening Text with fmt 
   35.03 Alternatives to fmt 
   35.04 recomment: Clean Up Program Comment Blocks 
   35.05 Remove Mail/News Headers with behead 
   35.06 Low-Level File Butchery with dd 
   35.07 offset: Indent Text 
   35.08 Centering Lines in a File 
   35.09 Splitting Files at Fixed Points: split 
   35.10 Splitting Files by Context: csplit 
   35.11 Hacking on Characters with tr 
   35.12 Converting Between ASCII and EBCDIC 
   35.13 Other Conversions with dd 
   35.14 Cutting Columns or Fields with cut 
   35.15 Cutting Columns with colrm 
   35.16 Make Columns Automatically with cols 
   35.17 Making Text in Columns with pr 
   35.18 Pasting Things in Columns 
   35.19 Joining Lines with join 
   35.20 Quick Reference: uniq 
   35.21 Using IFS to Split Strings 
   35.22 Straightening Jagged Columns 
   35.23 Rotating Text 
Chapter 36.  Sorting 
   36.01 Putting Things in Order 
   36.02 Sort Fields: How sort Sorts 
   36.03 Changing the Field Delimiter 
   36.04 Confusion with White Space Field Delimiters 
   36.05 Alphabetic and Numeric Sorting 
   36.06 Miscellaneous sort Hints 
   36.07 Sorting Multiline Entries 
   36.08 lensort: Sort Lines by Length 
   36.09 Sorting a List of People by Last Name 
Chapter 37.  Perl, a Pathologically Eclectic Rubbish Lister
   37.01 What We Do and Don't Tell You About Perl 
   37.02 Why Learn Perl? #1 
   37.03 Three Great Virtues of a Programmer 
   37.04 Why Learn Perl? #2 
   37.05 And Now, Perl 5 

PART Six: Managing Processes 

Chapter 38.  Starting, Stopping, and Killing Processes
   38.01 What's in This Chapter 
   38.02 fork and exec 
   38.03 Managing Processes: Overall Concepts 
   38.04 Subshells 
   38.05 The ps Command 
   38.06 The Controlling Terminal 
   38.07 Why ps Prints Some Commands in Parentheses 
   38.08 What Are Signals? 
   38.09 Killing Foreground Jobs 
   38.10 Destroying Processes with kill 
   38.11 Printer Queue Watcher: A Restartable Daemon Shell Script
   38.12 Killing All Your Processes 
   38.13 Interactively Kill Processes Matching a Pattern 
   38.14 Processes Out of Control?  Just STOP Them 
   38.15 Cleaning Up an Unkillable Process 
   38.16 Why You Can't Kill a Zombie 
   38.17 Automatically Kill Background Processes on Logout in csh
   38.18 nohup 
Chapter 39.  Time and Performance 
   39.01 Which Time Is It? 
   39.02 Timing Programs 
   39.03 The csh time variable 
   39.04 Average Command Runtimes with runtime 
   39.05 Why Is the System So Slow? 
   39.06 lastcomm: What Commands Are Running
   39.07 Checking System Load: uptime 
   39.08 A Big Environment Can Slow You Down 
   39.09 Know When to Be "nice" to Other Users... and When Not to
   39.10 A nice Gotcha 
   39.11 Changing a Job's Priority Under BSD UNIX 
   39.12 What Makes Your Computer Slow? How Do You Fix It?
Chapter 40.  Delayed Execution 
   40.01 Off-Peak Job Submission 
   40.02 Waiting a Little While: sleep 
   40.03 The at Command 
   40.04 Choosing the Shell Run (We Hope) by at 
   40.05 Avoiding Other at and cron Jobs 
   40.06 System V.4 Batch Queues 
   40.07 Making Your at Jobs Quiet 
   40.08 Automatically Restarting at Jobs 
   40.09 Checking and Removing Jobs 
   40.10 nextday, nextweekday: Tomorrow or Next Weekday 
   40.11 Send Yourself Reminder Mail 
   40.12 Periodic Program Execution: The cron Facility 
   40.13 Adding crontab Entries 
   40.14 Including Standard Input Within a cron Entry 
   40.15 crontab Script Makes crontab Editing Easier/Safer 

PART Seven: Terminals and Printers 

Chapter 41.  Terminal and Serial Line Settings 
   41.01 Delving a Little Deeper 
   41.02 stty and All That Stuff 
   41.03 Find Out Terminal Settings with stty 
   41.04 How UNIX Handles TAB Characters 
   41.05 Why Some Systems Backspace over Prompts 
   41.06 Using sleep to Keep Port Settings 
   41.07 Reading Verrrry Long Lines from the Terminal 
   41.08 ptys and Window Systems 
   41.09 Commands to Adjust Your Terminal 
   41.10 Using terminfo Capabilities in Shell Programs 
   41.11 How termcap and terminfo Describe Terminals 
   41.12 Your Terminal's Special Keys
Chapter 42.  Problems with Terminals 
   42.01 Making Sense Out of the Terminal Mess 
   42.02 Fixing a Hung Terminal or Job 
   42.03 Why Changing TERM Sometimes Doesn't Work 
   42.04 Checklist for Resetting a Messed Up Terminal 
   42.05 Checklist: Screen Size Messed Up? 
   42.06 Screen Size Testing Files 
   42.07 termtest: Send Repeated Characters to Terminal 
   42.08 Errors Erased Too Soon? Try These Workarounds 
Chapter 43.  Printing 
   43.01 Introduction to Printing 
   43.02 Introduction to Printing on UNIX 
   43.03 Printer Control with lpc 
   43.04 Using Different Printers 
   43.05 Using Symbolic Links for Spooling 
   43.06 Printing to a Terminal Printer 
   43.07 Quick-and-Dirty Formatting Before Printing 
   43.08 Fixing Margins with pr and fold 
   43.09 Indenting Text for Printing 
   43.10 Filename Headers Above Files Without pr 
   43.11 Big Letters: banner 
   43.12 Typesetting Overview 
   43.13 The Text Formatters nroff, troff, ditroff, ... 
   43.14 nroff\/\troff and Macro Packages 
   43.15 From a Source File to the Printer 
   43.16 groff 
   43.17 Don't Have nroff?  Try gnroff or awf 
   43.18 How nroff Makes Bold and Underline; How to Remove It
   43.19 Removing Leading Tabs and Other Trivia 
   43.20 Displaying a troff Macro Definition 
   43.21 Preprocessing troff Input with sed 
   43.22 Converting Text Files to PostScript 
   43.23 psselect: Print Some Pages from a PostScript file 
   43.24 Other PostScript Utilities 
   43.25 The Portable Bitmap Package 

PART Eight: Shell Programming 

Chapter 44.  Shell Programming for the Uninitiated
   44.01 Everyone Should Learn Some Shell Programming 
   44.02 Writing a Simple Shell Program 
   44.03 What's a Shell, Anyway? 
   44.04 Testing How Your System Executes Files 
   44.05 Test String Values with Bourne Shell case 
   44.06 Pattern Matching in case Statements 
   44.07 Exit Status of UNIX Processes 
   44.08 Test Exit Status with the if Statement 
   44.09 Testing Your Success 
   44.10 Loops That Test Exit Status 
   44.11 Set Exit Status of a Shell (Script) 
   44.12 Trapping Exits Caused by Interrupts 
   44.13 read: Reading from the Keyboard 
   44.14 Putting awk, sed, etc., Inside Shell Scripts 
   44.15 Handling Command-Line Arguments in Shell Scripts 
   44.16 Handling Command-Line Arguments with a for Loop 
   44.17 Handling Arguments with while and shift 
   44.18 Standard Command-Line Parsing 
   44.19 The Bourne Shell set Command 
   44.20 test: Testing Files and Strings 
   44.21 Picking a Name for a New Command 
   44.22 Finding a Program Name; Multiple Program Names 
   44.23 Reading Files with the . and source Commands 
Chapter 45.  Shell Programming for the Initiated
   45.01 Beyond the Basics 
   45.02 The Story of  : #  #! 
   45.03 Don't Need a Shell for Your Script?  Don't Use One 
   45.04 Fun with #! 
   45.05 A File That Shows Itself... and What #! Does 
   45.06 Making Sure Your Script Runs with Bourne Shell, Without #! 
   45.07 The exec Command 
   45.08 Handling Signals to Child Processes 
   45.09 The Unappreciated Bourne Shell "\:\" Operator 
   45.10 Removing a File Once It's Opened--for Security
   45.11 The Multipurpose jot Command 
   45.12 Parameter Substitution 
   45.13 Save Disk Space and Programming
   45.14 Finding the Last Command-Line Argument 
   45.15 How to Unset all Command-Line Parameters 
   45.16 Standard Input to a for Loop 
   45.17 Making a for Loop with Multiple Variables 
   45.18 Using basename and dirname 
   45.19 A while Loop with Several Loop Control Commands 
   45.20 Overview: Open Files and File Descriptors 
   45.21 n>&m: Swap Standard Output and Standard Error 
   45.22 Handling Files Line-by-Line 
   45.23 The Ins and Outs of Redirected I/O Loops 
   45.24 A Shell Can Read a Script from its Standard Input, But...
   45.25 Shell Scripts On-the-Fly from Standard Input 
   45.26 Quoted hereis Document Terminators: sh vs. csh 
   45.27 Turn Off echo for "Secret" Answers 
   45.28 Quick Reference: expr 
   45.29 Testing Characters in a String with expr 
   45.30 Grabbing Parts of a String 
   45.31 Nested Command Substitution 
   45.32 A Better read Command: grabchars 
   45.33 Testing Two Strings with One case Statement 
   45.34 Arrays in the Bourne Shell 
   45.35 Using a Control Character in a Script 
   45.36 Shell Lockfile 
Chapter 46.  Shell Script Debugging and Gotchas
   46.01 Tips for Debugging Shell Scripts 
   46.02 Quoting Trouble?  Think, Then Use echo 
   46.03 Bourne Shell Debugger Shows a Shell Variable 
   46.04 Stop Syntax Errors in Numeric Tests 
   46.05 Stop Syntax Errors in String Tests 
   46.06 Watch Out for Bourne Shell -e Bug 
   46.07 Quoting and Command-Line Parameters 
   46.08 Test Built-In Commands for Failure 
   46.09 If Command Doesn't Return a Status, Test the Error Messages
   46.10 A Portable echo Command 
Chapter 47.  C Shell Programming...NOT 
   47.01 Why Not? 
   47.02 C Shell Programming Considered Harmful 
   47.03 Conditional Statements with if 
   47.04 C Shell Variable Operators and Expressions 
   47.05 Using C Shell Arrays 
   47.06 Quick Reference: C Shell switch Statement 

PART Nine: Miscellaneous 

Chapter 48.  Office Automation 
   48.01 Well, What Else Could We Call It? 
   48.02 Online Phone and Address Lists 
   48.03 A Scratchpad on Your Screen 
   48.04 Automatic Reminders and More: calendar 
   48.05 leave: A Maddening Aid to Quitting on Time 
   48.06 Get Calendar for Any Month or Year: cal 
   48.07 cal That Marks Today's Date 
   48.08 Calendar for 132-Column Terminals or Printers 
   48.09 PostScript Calendars with pcal 
   48.10 Working with Names and Addresses 
   48.11 The index Database Program 
   48.12 Using index with a Filter 
Chapter 49.  Working with Numbers 
   49.01 bc: Simple Math at the Shell Prompt 
   49.02 bc: Hexadecimal or Binary Conversion 
   49.03 Gotchas in Base Conversion 
   49.04 bc's Sine and Cosine Are in Radians 
   49.05 Base Conversion Using cvtbase 
   49.06 Quick Arithmetic with expr 
   49.07 Total a Column with addup 
   49.08 It's Great to Have a Spreadsheet 
   49.09 Business Graphics with ipl 
Chapter 50.  Help--Online Documentation
   50.01 UNIX Online Documentation 
   50.02 The apropos Command 
   50.03 apropos on Systems Without apropos 
   50.04 whatis: One-Line Command Summaries 
   50.05 whereis: Finding Where a Command Is Located 
   50.06 Searching Online Manual Pages 
   50.07 How UNIX Systems Remember Their Name 
   50.08 Which Version Am I Using? 
   50.09 Reading a Permuted Index 
   50.10 Make Your Own Man Pages Without Learning troff
   50.11 Writing a Simple Man Page with the -man Macros 
   50.12 Common UNIX Error Messages 
Chapter 51.  Miscellaneous Useful Programs and Curiosities
   51.01 We Are Finally Getting to the Bottom of the Bucket 
   51.02 How UNIX Keeps Time 
   51.03 ASCII Characters: Listing and Getting Values 
   51.04 Who's On? 
   51.05 Copy What You Do with script 
   51.06 Cleaning script Files 
   51.07 When You Get Impatient 
   51.08 Type Bang Splat.  Don't Forget the Rabbit Ears 
   51.09 Making a "Login" Shell 
   51.10 The date Command 
   51.11 Making an Arbitrary-Size File for Testing 
   51.12 You Don't Have Enough Smileys? 
Chapter 52.  What's on the Disc 
   52.01 Introduction 
   52.02 Where Does Free Software End and UNIX Begin? 
   52.03 Shrink-Wrapped Software for UNIX 
   52.04 Quick Descriptions of What's on the Disc 
   52.05 Using the Power Tools CD-ROM 
   52.06 Don't Have a CD-ROM Drive? 
   52.07 Other Ways to Get the Software 
   52.08 Building Programs from Source Code 
   52.09 Software Support from RTR 
Chapter 53.  Glossary 

Index