Mac OS X Tiger Unleashed

 < Day Day Up > 

Text Editors

Even though you might think that you'll never have a reason to use anything other than a GUI text editor such as Alpha or BBEdit, there are a few arguments to be made for text-only mode editing in a terminal. Among them are that the text-only editors can be used even when the system can't display a GUI interface, and that an editor in a terminal can start much faster than most GUI editors. There's also the advantage that if you have occasion to work on Unix machines other than Mac OS X boxes, the command-line editors are what you will have available.

Finally, at this point, the GUI clients available currently seem to have a bit of a problem figuring out whether they should convert a file that they load into Mac-style text (for newlines) or Unix-style text. The Unix command-line editors are a bit more predictable in preferring Unix-format text. Because of this, if you're working with files in the traditional-Unix side of the system, you're probably safer sticking to the command-line editors.

When it comes to editing text on the Unix side, you'll find that many Unix programs use text files as input, create text files as output, or are configured using commands and variables set up in text files. To change the contents of these files, you'll need to use a text editor.

As a matter of fact, most Unix software doesn't know the difference between a text file and any other file. Unlike in Mac OS, from the point of view of Mac OS X's underlying Unix system, files are files are files. If the user chooses to view some of them as containing text and some as containing programs, that's the user's business. An interesting consequence of this lack of concern about a file's contents is that the operating system is just as happy to allow you to use a text editor to edit the contents of your spreadsheet program itself as it is to enable you to attempt to run your email mailbox. Of course, if you actually have execute permission turned on for your email and try to run it, it's almost certainly going to result in nothing more interesting than a bus error and an immediate exit of the command but the operating system will try to do as you command.

TIP

If you are a programmer, you might find this lack of distinction (yet another example of Unix abstraction at work) to be useful. On occasion, you might find a program that needs a minor change, such as the correction of a misspelling or a change of wording. In these instances, it is sometimes more convenient to simply load the executable file into a text editor and make the correction directly into the binary. This isn't a trick for the faint of heart, but sometimes it's the quick fix you need, and occasionally it's the only fix available for software for which you don't have access to the source.

If you spend much time discussing Unix editors with longtime Unix users, you'll find that there is a disagreement of warlike proportions between the users of the two most common editors: vi and emacs. Although these editors are actually rather complementary in their functions and are both useful tools to have in your toolbox, chances are that you will run into many users who insist that one or the other editor is completely useless. If you listen to them, instead of keeping both tools handy, you'll be depriving yourself of the better solution to at least some tasks.

Many Unix editors have immense power. emacs, for example, not only contains its own built-in programming language but can also function as a complete windowing system, a compiler/debugger interface, a news reader, and many other things. Even with a book of this size, however, there isn't space to do more than address the basics of using these editors. After you've mastered the basics, if you're interested in learning more, we encourage you to stop by your local bookstore or library and choose from among the several books available on each of the major Unix editors.

Quick, Dirty, and Omnipresent: vi

The vi editor is Unix's most universal editor. Some users pronounce it vee-eye, and some pronounce it vye, and a growing contingent claim it's pronounced six, when used on Mac OS X. There seems to be no concrete consensus which pronunciation is correct (but the people who say vye are still wrong). vi isn't an easy editor and it isn't friendly. It is, however, a quick-starting editor with a small memory footprint, which you will find on every Unix machine you encounter, regardless of flavor. vi, although annoying to learn, is frequently the most convenient editor to use for doing things such as making single-line changes to configuration files.

NOTE

Apple now provides vim (vi IMproved) as a vi-replacement. vim provides some useful enhancements that are well beyond the design intent of vi. vi has historically eschewed fancy features such as syntax highlighting and multilevel undo, in favor of speed of use and ubiquity. Although it does have a sophisticated search-and-replace facility, some of vi's strongest points are that it's small, fast, and available everywhere. These features have made vi a favorite of system administrators the world over because they know, with almost certainty, that even if all they have to work with on a machine is a paper-terminal (a thing that's much like a printer with a keyboard no screen, just input on one line, output on the next, repeat…), vi will be there and work just like it does everywhere else. vim doesn't share these characteristics. It's reasonably fast on today's gigahertz processors, but it's about 20 times the size of vi in terms of disk and memory footprint, and it's by no means universally installed on all Unix systems. The improved features available in vim allow it to compete with some of the more complex emacs features, so you might find that it suits your needs as your day-to-day "power" editor, but we also recommend learning to operate comfortably within the vi subset of commands, just in case you ever need to work with the real thing.

When trying to use vi (or vim), there are a number of things you need to know to make it useful.

vi operates in one of two modes: command mode or insert mode. In command mode, you have control over things such as cursor position, deleting characters, and saving files. In command mode, every keyboard character you type will be interpreted as part of a command of some sort. In insert mode, every keyboard key you type is inserted into the file you are editing. This distinction is bound to be confusing at first, but if you use vi, you'll find that its speed makes it a preferred editor for quick changes to files. You will find the Return key included in the explanations here because some commands take effect immediately, and some require you to press Return after you enter them.

Table 13.10 shows some of the most used keys and tasks. If you're just coming to vi for the first time, don't look too long at this table yet; it will just look confusing! Flip past it to the short example of how to use vi and then turn back here and see whether, following the table, you understand what each key press did and why.

Table 13.10. Common Key Presses and the Resultant Actions in vi

Mode

Key(s)/Key Combination(s)

Action

Command

l

Moves right

 

h

Moves left

 

j

Moves to next line

 

k

Moves to previous line

 

Put cursor on character and press x key

Deletes character under cursor

 

Press d key twice

Deletes an entire line, including an empty line

 

A

Enters insert mode at end of current line

 

i

Enters insert mode before the character under the cursor

 

a

Enters insert mode after the character under the cursor

 

:w Return

Saves the file

 

:w <filename> Return

Saves the file to <filename>

 

:q Return

Quits

 

:q! Return

Quits without saving

 

:wq!

Saves file and exit

Insert Mode

Esc key

Switches to command mode

 

Backspace or Delete key

Backspaces or deletes, but only for data entered in current insert mode session on the current line

 

Any printable keyboard

Inserts the character at the cursor character

NOTE

Despite what anyone tells you, vi's not difficult to use; it just looks that way. It looks that way because any way of presenting the separate command and editing interface in a discussion, or at least any way we've ever seen or come up with, looks confusing. Try it. It's not difficult; it will make sense.

Instead of trying to walk through a screenshot-by-screenshot example of using vi, try typing the following example. Remember to compare what you're typing to the commands in Table 15.9, and watch what happens. Although the finer details are not revealed by this example, you will pick up enough to get you started doing useful work, and to get out of any sticky situations you might find yourself in while editing a file.

Try typing the following exactly as it appears here, and observe what happens. Where a new line appears in the text, press Return. Remember that <esc> is the Escape key.

brezup:ray testing $ vi mynewfile iThis is my new file This is line one of my new file This is a test This is line four of my new file<esc>kddkA This is line three of my new file<esc>khhhhhhhhhhhhhhhhhxxxitwo<esc>:wq!

Your machine should respond

"mynewfile" [New file] 4 lines, 119 characters

although you might not be able to see that because the line flashes off the screen pretty quickly. Now look at what you have:

% cat mynewfile This is my new file This is line two of my new file This is line three of my new file This is line four of my new file

Table 13.11 shows the syntax and common options for the vi (vim) command.

Table 13.11. The Syntax and Common Useful Options for vi (vim)

vi

Screen-oriented text editor

ex

Line-oriented screen editor

view

Read-only version of vi

vi [-eFlRrSv] [-c <cmd>] [-t <tag>] [-w <size>] [<file1> <file2> ...]

ex [-eFlRrSsv] [-c <cmd>] [-t <tag>] [-w <size>] [<file1> <file2> ...]

view [-eFlRrSv] [-c <cmd>] [-t <tag>] [-w <size>] [<file1> <file2> ...]

vi/vim is a screen-oriented text editor; ex is a line-oriented editor. vi and ex are different interfaces to the same program. view is equivalent to vi -R, the read-only option to vi.

vim has many more options than vi, but the following are the common ones you'll probably be most interested in:

-e

Starts to edit in ex mode that is, act like the line-mode ex editor. Few people like it when they land in ex; entering q at the prompt gets you out.

-R

Starts editing in read-only mode.

-r <recoveryfile>

Recovers the specified <recoveryfile>. If no file is specified, it lists the files that could be recovered. If no recoverable files with the specified name exist, vi starts editing as if the option has not been issued.

-c <cmd>

Executes <cmd> immediately after starting the edit session. It is especially useful for initial positioning in the file but is not limited to positioning commands.

-t <tag>

Starts editing at the specified <tag>.

-

Specifies that STDIN should be used as the source of the data to edit. Commands come from STDERR.

vi has two modes: command mode and input mode. Command mode is the initial and normal mode. Exiting from input mode (by pressing the Esc key) returns the user to command mode. Pressing the Esc key while in command mode aborts a partial command.

Some commands for moving around in a file:

h

Moves the cursor one character to the left.

l

Moves the cursor one character to the right.

j

Moves the cursor one line down.

k

Moves the cursor one line up.

<arrow keys>

The arrow keys often also function properly for moving around in a file. Most seasoned uses find the h/l/j/k commands faster for navigation.

<num>G

Moves the cursor to the line number specified by <num>. If <num> is not specified, the cursor moves to the last line of the file.

<num><key1>[<key2>...]

If <key1> is a single-key command, acts as though the user had pressed the <key1> <num> times. If pressing <key1> would switch from command to editing mode, collects <key2>...<keyN> until the user presses <esc>; then acts as though the user had typed these keys <num> times in editing mode.

Some commands for inputting text (input mode):

i

Inserts text before the cursor.

a

Appends new text after the cursor.

A

Appends new text at the end of the line where the cursor is.

o

Opens a new line below the line where the cursor is and allows the user to start entering text on the new line.

O

Opens a new line above the line where the cursor is, and allows the user to start entering text on that new line.

Some commands for copying text:

 

yy

Copies the line the cursor is on.

p

Appends the copied line after the line the cursor is on.

Some commands for deleting text:

 

dd

Deletes the line the cursor is on.

<num>dd

Deletes <num> lines, starting with the line the cursor is on.

dw

Deletes the word the cursor is on.

x

Deletes the character the cursor is on.

Some other useful text manipulation:

r<x>

Replaces the character the cursor is on with <x>.

J

Joins the line the cursor is on with the line below.

Some commands for pattern searching:

/<pattern>

Searches forward in the file for <pattern>, starting with the location of the cursor.

?<pattern>

Searches backward in the file for <pattern>, starting with the location of the cursor.

n

Repeats the last / or ? pattern search.

N

Repeats the last / or ? pattern search in reverse.

Some commands to write the file:

 

:w<return>

Writes the file back to the filename originally specified when vi was started.

:w <filename><return>

Writes the file to the filename specified by <filename>.

Some commands to quit editing and exit vi:

:q<return>

Exits vi. Refuses to quit if there are any unsaved modifications, or if the file is read-only.

:q!

Exits vi, even if there are any unsaved modifications.

ZZ

Exits vi, saving changes.

Miscellaneous functionality:

 

:next

Switch editing to the next file specified on the command line.

Everything and the Kitchen Sink: emacs

On the other end of the spectrum from vi's odd syntax and tiny footprint is emacs. In certain circles, it is thought that emacs is an acronym for Emacs Makes a Computer Slow because emacs epitomizes the notion of an "everything" package and has the memory footprint to prove it. Including a windowing system, an email-reading client, a news-reading client, a programming language, and an online help database, to name only a few of its features, emacs can almost certainly do anything you want a plain text editor to do.

NOTE

Don't believe me? emacs also includes an implementation of the aged Eliza psychoanalyst and a Zippy the Pinhead quote generator. Do you really think there's anything that's not in there? If you're creative, you can convince Zippy to have a conversation with Eliza inside emacs. Alternatively, you can play the pong video game, convert text to Morse code, manage your PIM schedule, or automatically insert keywords into your email to cause it to be flagged by the FBI's Carnivore mail-scanner as a possible terrorist threat. Browsing the categorized packages listing by entering Esc-x help<CR> p in a fresh emacs window should get you started on finding a wealth of interesting features you might never have imagined possible in a text editor.

With today's fast machines and nearly unlimited memory, the major complaints against emacs (it's a gargantuan application with a legendary hunger for computer resources hey it's not all bad people write haiku about it too!) aren't a significant impediment to its use.

From the point of view of the average user, emacs has a much more intuitive interface than vi. You're always in insert mode, just as you're used to in GUI-based word processors. Commands are handled by the use of Control+<key> combinations, instead of the use of a separate mode.

To use emacs, there are some basics that you need to know you can get more information from the online tutorial mentioned at the end of this section. In the following list, whenever you see Ctrl+ preceding a character, it means that you need to hold down the Control key and type that character. Whenever you see Esc- preceding a character, it means to press the Esc key and then the character.

  • The emacs editor doesn't have a separate mode for entering commands. You are always either typing a command or typing text no switching between modes for them. This is just like most word processors that you are probably familiar with. To enter text, just type what you want to appear. To enter a command (usually Ctrl+<key> or Esc-x <somecommand>), just type the command as shown.

  • You can position the cursor keys in emacs by using the arrow keys. If you're working across a network connection, the arrow keys might not work, but you can also position the cursor with Ctrl+<key> combinations. Ctrl+f moves the cursor forward. Ctrl+b moves it back. Ctrl+n moves to the next line. Ctrl+p moves up one line.

  • You can delete everything from the cursor to the end of the line with Ctrl+k. A second Ctrl+k deletes the now blank line.

  • Ctrl+g is the emacs "quit what you're doing" command. If you've started typing a command and change your mind, press Ctrl+g to abort.

  • If you use Ctrl+k to delete a line or lines, you can use Ctrl+y to yank it (them) back. You don't have to yank them to the same location from which you deleted them.

  • To save the file you're working on, press Ctrl+x Ctrl+s.

  • To save the file to a new name, press Ctrl+x Ctrl+w <filename> Return.

  • To exit emacs, press Ctrl+x Ctrl+c. If emacs proceeds to ask you about unsaved buffers, it's because you have unsaved work. You can either answer no and save your work, or answer yes to the "quit anyway?" questions and exit without saving.

Beyond the Ctrl+ commands available in emacs, an amazingly extensible set of commands also comes into play if you use the Escape (Esc) key. These commands are usually known as emacs meta commands, even though the machines with the meta key from which the commands draw their name have long since faded into history. These commands, even though they're initiated by pressing the Escape key, are usually abbreviated in the documentation with a leading M for meta. The complete set of these commands is the subject of more than one book, and we recommend that you investigate your library or bookstore options if you really want to understand the inner workings. If you're a puzzle solver, some of the interesting items are documented in Table 15.10. A good place to start on meta commands will be with testing out the emacs online help system. Start emacs by simply typing emacs at the prompt. After it has started, press Esc-x and then type help- and press the spacebar. You will be presented with a list of emacs commands starting with help-, including useful things such as help-for-help a good place to start.

Instead of a quick example like the one we used for vi, we suggest you take the emacs tutorial. To enter the emacs tutorial, all you need to do is start emacs and press Ctrl+h t (hold the Ctrl key, press the h key, release them both, and press the t key). If you type a ? after the Ctrl+h instead of the t, you'll see that there is actually a whole world of alternatives to the t (Ctrl+h i is another good place to look). These alternatives give you access to a range of different types of helpful information. For now, take the tutorial. If you're curious, you can probably spend almost eternity exploring the rest of the options available.

Table 13.12 shows a portion of the command documentation table for emacs as well as a listing of some of the help topics detailing a number of the available meta commands. The synopses of the help topic areas should give you an idea of some of the things that you can do, and some of the information that you can look for in the online documentation. A vastly more detailed list of capabilities can be accessed in emacs itself by typing M-x info and selecting the emacs documentation line. It should be clear even from this highly abridged listing that the complete documentation for emacs is voluminous.

Table 13.12. The Syntax and Some Useful Options for emacs

emacs

Editor

emacs [<command-line switches>] [<file1> <file2>...]

emacs is a powerful editor that can actually do more than edit files. It has an extensive information system, which can be accessed in emacs with the key sequence <Ctrl+h i> (holding down the Control key and h and then i). The information system can be navigated using the arrow keys to move around and pressing the Return key to make a selection.

emacs has an interactive help facility, <Ctrl+h>. The interactive Info information facility, which is a hierarchically organized, (usually) searchable collection of informative topic-related documents, is one type of help available. A help tutorial is available with <Ctrl+h t>. Help Apropos <Ctrl+h a> helps the user find a command given its functionality. Help Character <Ctrl+h c> describes a given character's effect.

The following are emacs options of general interest:

<file>

Edits the specified <file>.

+<number>

Moves the cursor to the line number specified by <number>. (Do not include a space between + and <number>.)

-q

Does not load an init file.

-u <user>

Loads the init file of the specified <user>.

-t <file>

Uses the specified <file> as the terminal instead of using stdin/stdout. This must be the first argument specified in the command line.

-nw

Tells emacs not to use its special X interface. When running under X11, some versions of emacs default to building an interface with a menu, which interacts (some say poorly) with the X11 cursor, allowing it to act a bit more like the traditional point-and-click editors with which you're familiar. This is sometimes convenient, but also can be incredibly annoying at times. If the -nw option is given when invoking emacs in an xterm(1) window, the emacs display is done in that window and emacs won't build its special interface. This must be the first option specified in the command line. This is useful if you're running an X server but want emacs to display in a terminal rather than the X Windows xterm or just plain don't want the special X11 interface.

The following are basic emacs key sequences. Remember that two keys pressed simultaneously have a plus sign between them, and a space indicates pressing them sequentially. Most Unix documentation, including the online man pages and info pages, will document Esc-x as M-x for the Meta key:

Up Arrow

Move cursor up one line.

Left Arrow

Move cursor to the left one character; to end of previous line if at left side of current line.

Right Arrow

Move cursor to the right one character; move to the beginning of the next line if at the right side of the current line.

Down Arrow

Move cursor down one line. Adds a new line to the file if currently on the last line of the file.

Ctrl+p

Move cursor up one line.

Ctrl+b

Move cursor to the left one character; to end of previous line if at left side of current line.

Ctrl+f

Move cursor to the right one character, move to the beginning of the next line if at the right side of the current line.

Ctrl+n

Move cursor down one line. Adds a new line to the file if currently on the last line of the file.

Ctrl+v

Move down one page in file.

Esc-v

Move up one page in file.

Ctrl+l

Move current line to the center of the page.

Ctrl+a

Move cursor to the beginning of the current line.

Ctrl+e

Move cursor to the end of the current line.

Esc-a

Move cursor to the beginning of the current sentence.

Esc-e

Move cursor to the end of the current sentence.

Ctrl+x Ctrl+h

Bring up list of Ctrl+x prefixed commands. (If you do this, you will see that this table is a very abbreviated list!)

Ctrl+x Ctrl+s

Save the file.

Ctrl+x Ctrl+w

Prompt for new name to save file.

Ctrl+x Ctrl+c

Exit emacs.

Ctrl+x Ctrl+f

Prompt to open file.

Ctrl+x Ctrl+b

List current file buffers.

Ctrl+x b

Prompt to switch to another buffer.

Esc-x

Prompt to open file in literal find-file-literally mode no Mac/Unix linefeed interpretation and so on. This is an important option for Mac users wanting to use emacs to convert Mac files to the Unix line-ending style.

Ctrl+x Ctrl+d

List directory in emacs buffer (allows opening files by browsing directory rather than by typing name).

Ctrl+x Ctrl+o

Delete blank lines in file.

Ctrl+x Ctrl+t

Transpose lines.

Ctrl+spacebar

Set mark at the current cursor position.

Ctrl+x Ctrl+l

Downcase region. The region is the area between the cursor, and where the current mark is set.

Ctrl+x Ctrl+u

Upcase region. The region is the area between the cursor, and where the current mark is set.

Ctrl+w

Delete from mark to cursor. Deleted text goes to kill-ring buffer.

Ctrl+s

Enter incremental search mode. Any characters typed after Ctrl+s are searched for. Pressing Ctrl+s again searches for the next instance of the current search term. Use Ctrl+g, a navigation key such as the forward/backward arrows, or Ctrl+f/Ctrl+b to get out of this mode.

Ctrl+r

Enter incremental search mode, searching backward in the file.

Esc-w

Copy from mark to cursor into kill-ring buffer.

Ctrl+k

Delete from cursor to end of line. Place deleted text in kill-ring buffer.

Ctrl+y

Yank top data from kill-ring buffer into the text at the current cursor position.

Ctrl+x 2

Split current window vertically into two editing windows (two full-width windows, half the previous height).

Ctrl+x 3

Split current window horizontally into two editing windows (two full-height windows, half the previous width).

Ctrl+x o

Switch to next editing window in split-window mode.

Ctrl+x 1

Switch to single-window mode, keeping the current window open.

Ctrl+x 0

Remove current editing window, keeping others.

Ctrl+x (

Start recording keyboard macro.

Ctrl+x )

Stop recording keyboard macro.

Ctrl+x e

Execute recorded keyboard macro.

Ctrl+u <####>

Create a numeric argument for the next command.

Ctrl+u <####> <keyseq>

Execute <keyseq> #### times.

Ctrl+x f

Set fill column for word wrap. Requires a numeric argument set with Ctrl+u <####>.

Esc-x fill-region

Word wrap region between cursor and mark.

Ctrl+h Ctrl+h

Bring up menu of help subjects.

Ctrl+h t

Bring up emacs tutorial.

Ctrl+h i

Bring up emacs info-mode manual browser. Browsing through the emacs info through this interface is recommended.

Esc-x info

Bring up emacs info-mode manual browser.

Esc-x apropos

Prompt for command or key sequence to document.

Ctrl+h h

Bring up list of ways to say hello in 34 different languages we told you emacs had everything in it!

The following is a listing of some of the interesting parts of the information system's main menu for emacs. You're supposed to be able to find these and search the subtopics in them by using Esc-x Index-info and entering a search, but there's currently no index distributed for you to search in. Because of this, if you want more information on these topics (there are actually many more than listed here), you'll need to bring up the Info system with Ctrl+h i, navigate (using the down-arrow) to the Emacs section, and then browse the topics included there. We wish we had the space to discuss and document even a fraction of the power that emacs provides, but lacking space, a back-of-the-dustjacket listing of the features we think are most interesting will have to suffice. Think of this listing as a jumping-off place for finding your way to emacs information and a whirlwind tour of some of the options you might never have known were available in a text editor:

Basic Interest

 

Distrib

How to get the latest emacs distribution.

Copying

The GNU General Public License gives you permission to redistribute GNU emacs on certain terms; it also explains that there is no warranty.

Intro

An introduction to emacs concepts.

Glossary

The glossary.

Mac OS

Using emacs in the Mac.

Manifesto

What's GNU? Gnu's Not Unix!

Indexes (Nodes Containing Large Menus)

Key Index

An item for each standard emacs key sequence.

Command Index

An item for each command name.

Variable Index

An item for each documented variable.

Concept Index

An item for each concept.

Option Index

An item for every command-line option.

Important General Concepts

 

Screen

How to interpret what you see on the screen.

User Input

Kinds of input events (characters, buttons, function keys).

Keys

Key sequences: what you type to request one editing action.

Commands

Named functions run by key sequences to do editing.

Entering Emacs

Starting emacs from the shell.

Exiting

Stopping or killing emacs.

Command Arguments

Hairy startup options.

Fundamental Editing Commands and Concepts

Basic

The most basic editing commands.

Minibuffer

Entering arguments that are prompted for.

M-x

Invoking commands by their names.

Help

Commands for asking emacs about its commands.

Important Text-Changing Commands and Concepts

Mark

The mark: how to delimit a region of text.

Killing

Killing text.

Yanking

Recovering killed text. Moving text.

Accumulating Text

Other ways of copying text.

Rectangles

Operating on the text inside a rectangle on the screen.

Search

Finding or replacing occurrences of a string.

Fixit

Commands especially useful for fixing typos.

Major Structures of emacs

 

Files

All about handling files.

Buffers

Multiple buffers; editing several files at once.

Windows

Viewing two pieces of text at once.

Advanced Features

 

Major Modes

Text mode versus Lisp mode versus C mode.

Indentation

Editing the whitespace at the beginnings of lines.

Text

Commands and modes for editing English.

Programs

Commands and modes for editing programs.

Building

Compiling, running, and debugging programs.

Maintaining

Features for maintaining large programs.

Abbrevs

How to define text abbreviations to reduce the number of characters you must type.

Picture

Editing pictures made up of characters using the quarter-plane screen model.

Dired

You can "edit" a directory to manage files in it.

Calendar/Diary

The calendar and diary facilities.

Shell

Executing shell commands from emacs.

Hardcopy

Printing buffers or regions.

PostScript

Printing buffers or regions as PostScript.

Sorting

Sorting lines, paragraphs, or pages within emacs.

Two-Column

Splitting apart columns to edit them in side-by-side windows.

Editing Binary Files

Using Hexl mode to edit binary files.

Saving Emacs

Saving emacs state from one

Sessions

session to the next.

Emulation

Emulating some other editors with emacs.

Hyperlinking

Following links in buffers.

Dissociated Press

Dissociating text for fun.

Amusements

Various games and hacks.

Customization

Modifying the behavior of emacs.

The deeper levels of the documentation include topics covering the following (and many more) useful areas:

The Organization of the Screen

 

Point

The place in the text where editing commands operate.

Echo Area

Short messages appear at the bottom of the screen.

Mode Line

Interpreting the mode line.

Menu Bar

How to use the menu bar.

Basic Editing Commands

 

Inserting Text

Inserting text by simply typing it.

Moving Point

How to move the cursor to the place where you want to change something.

Erasing

Deleting and killing text.

Undo

Undoing recent changes in the text.

Files: Basic Files

Visiting, creating, and saving files.

Continuation Lines

Lines too wide for the screen.

Position Info

What page, line, row, or column is point on?

Arguments

Numeric arguments for repeating a command.

The Minibuffer

 

Minibuffer File

Entering filenames with the minibuffer.

Minibuffer Edit

How to edit in the minibuffer.

Completion

An abbreviation facility for minibuffer input.

Minibuffer History

Reusing recent minibuffer arguments.

Repetition

Re-executing commands that used the minibuffer.

Help

 

Help Summary

Brief list of all Help commands.

Key Help

Asking what a key does in Emacs.

Name Help

Asking about a command, variable, or function name.

Apropos

Asking what pertains to a given topic.

The Mark and the Region

 

Setting Mark

Commands to set the mark.

Transient Mark

How to make emacs highlight the region when there is one.

Using Region

Summary of ways to operate on contents of the region.

Mark Ring

Previous mark positions saved so you can go back there.

Global Mark Ring

Previous mark positions in various buffers.

Deletion and Killing

 

Deletion

Commands for deleting small amounts of text and blank areas.

Killing by Lines

How to kill entire lines of text at one time.

Other Kill Commands

Commands to kill large regions of text and syntactic units such as words and sentences.

Yanking (That Is, Pasting, for Mac Folks)

Kill Ring

Where killed text is stored. Basic yanking.

Appending Kills

Several kills in a row all yanked together.

Earlier Kills

Yanking something killed some time ago.

Controlling the Display

 

Scrolling

Moving text up and down in a window.

Horizontal Scrolling

Moving text left and right in a window.

Follow Mode

Lets two windows scroll as one.

Selective Display

Hiding lines with a lot of indentation.

Searching and Replacement

 

Incremental Search

Search happens as you type the string.

Nonincremental Search

Specify entire string and then search.

Word Search

Search for sequence of words.

Regexp Search

Search for match for a regular expression.

Regexps

Syntax of regular expressions.

Replace

Search and replace some or all matches.

Replacement Commands

 

Unconditional Replace

Replacing all matches for a string.

Regexp Replace

Replacing all matches for a regular expression.

Replacement and Case

How replacements preserve case of letters.

Query Replace

How to use querying.

Commands for Fixing Typos

 

Kill Errors

Commands to kill a batch of recently entered text.

Transpose

Exchanging two characters, words, lines, lists.

Fixing Case

Correcting case of last word entered.

Spelling

Apply spelling checker to a word or a whole buffer.

Using Multiple Buffers

 

Select Buffer

Creating a new buffer or reselecting an old one.

List Buffers

Getting a list of buffers that exist.

Kill Buffer

Killing buffers you no longer need.

Several Buffers

How to go through the list of all buffers and operate variously on several of them.

Multiple Windows

 

Basic Window

Introduction to emacs windows.

Split Window

New windows are made by splitting existing windows.

Other Window

Moving to another window or doing something to it.

Pop Up Window

Finding a file or buffer in another window.

Force Same Window

Forcing certain buffers to appear in the selected window rather than in another window.

Change Window

Deleting windows and changing their sizes.

Major Modes

 

Choosing Modes

How major modes are specified or chosen.

Commands for Human Languages

Words

Moving over and killing words.

Sentences

Moving over and killing sentences.

Paragraphs

Moving over paragraphs.

Pages

Moving over pages.

Filling

Filling or justifying text.

Case

Changing the case of text.

Text Mode

The major modes for editing text files.

Outline Mode

Editing outlines.

TeX Mode

Editing input to the formatter TeX.

Nroff Mode

Editing input to the formatter nroff.

Formatted Text

Editing formatted text directly in WYSIWYG fashion.

Filling (That Is, Automatically Rewrapping) Text

Auto Fill

Auto Fill mode breaks long lines automatically.

Fill Commands

Commands to refill paragraphs and center lines.

Editing Programs

 

Program Modes

Major modes for editing programs.

Defuns

Commands to operate on major top-level parts of a program.

Program Indent

Adjusting indentation to show the nesting.

Comments

Inserting, killing, and aligning comments.

Parentheses

Commands that operate on parentheses.

Documentation

Getting documentation of functions you plan to call.

Hideshow

Displaying blocks selectively.

Symbol Completion

Completion on symbol names of your program or language.

Misc for Programs

Other emacs features useful for editing programs.

C Modes

Special commands of C, C++, Objective-C, Java, and Pike modes.

Fortran

Fortran mode and its special features.

Indentation for Programs

 

Basic Indent

Indenting a single line.

Multi-line Indent

Commands to reindent many lines at once.

Lisp Indent

Specifying how each Lisp function should be indented.

C Indent

Extra features for indenting C and related modes.

Custom C Indent

Controlling indentation style for C and related modes.

Documentation Lookup

 

Info Lookup

Looking up library functions and commands in Info files.

Man Page

Looking up man pages of library functions and commands.

Lisp Doc

Looking up emacs Lisp functions, and so on.

C and Related Modes

 

Motion in C

Commands to move by C statements, and so on.

Electric C

Colon and other chars can automatically reindent.

Hungry Delete

A more powerful DEL command.

Other C Commands

Filling comments, viewing expansion of macros, and other neat features.

Comments in C

Options for customizing comment style.

Fortran Mode

 

Motion: Fortran

Moving point by statements or

Motion.

subprograms.

Indent: Fortran

Indentation commands for Fortran.

Indent.

 

Comments: Fortran

Inserting and aligning comments.

Comments.

 

Autofill: Fortran Autofill

Auto fill minor mode for Fortran.

Columns: Fortran Columns.

Measuring columns for valid Fortran.

Abbrev: Fortran Abbrev.

Built-in abbreviations for Fortran keywords.

Compiling and Testing Programs

 

Compilation

Compiling programs in languages other than Lisp (C, Pascal, and so on).

Compilation Mode

The mode for visiting compiler errors.

Compilation Shell

Customizing your shell properly for use in the compilation buffer.

Debuggers

Running symbolic debuggers for non-Lisp programs.

Executing Lisp

Various modes for editing Lisp programs, with different facilities for running

Lisp Eval

Executing a single Lisp expression in emacs.

Running Debuggers Under emacs

 

Starting GUD

How to start a debugger subprocess.

Debugger Operation

Connection between the debugger and source buffers.

Commands of GUD

Key bindings for common commands.

GUD Customization

Defining your own commands for GUD.

Dired, the Directory Editor

 

Dired Enter

How to invoke Dired.

Dired Navigation

How to move in the Dired buffer.

Dired Deletion

Deleting files with Dired.

Flagging Many Files

Flagging files based on their names.

Marks vs Flags

Flagging for deletion versus marking.

Operating on Files

How to copy, rename, print, compress, and so on. either one file or several files.

Shell Commands in Dired

Running a shell command on the marked files.

Transforming File Names

Using patterns to rename multiple files.

Comparison in Dired

Running diff by way of Dired.

Subdirectories in Dired

Adding subdirectories to the Dired buffer.

Subdirectory Motion

Moving across subdirectories, and up and down.

Dired and Find

Using find to choose the files for Dired.

Customization

 

Minor Modes

Each minor mode is one feature you can turn on independently of any others.

Variables

Many emacs commands examine emacs variables to decide what to do; by setting variables, you can control their functioning.

Keyboard Macros

A keyboard macro records a sequence of keystrokes to be replayed with a single command.

Key Bindings

The keymaps say what command each key runs. By changing them, you can redefine keys.

Keyboard Translations

If your keyboard passes an undesired code for a key, you can tell emacs to substitute another code.

Syntax

The syntax table controls how words and expressions are parsed.

Init File

How to write common customizations in the .emacs file.

Variables

 

Examining

Examining or setting one variable's value.

Easy Customization

Convenient and easy customization of variables.

Hooks

Let you specify programs for parts of emacs to run on particular occasions.

Locals

Per-buffer values of variables.

File Variables

How files can specify variable values.

Keyboard Macros

 

Basic Kbd Macro

Defining and running keyboard macros.

Save Kbd Macro

Giving keyboard macros names; saving them in files.

Kbd Macro Query

Making keyboard macros do different things each time.

Customizing Key Bindings

 

Keymaps

Generalities. The global keymap.

Prefix Keymaps

Keymaps for prefix keys.

Local Keymaps

Major and minor modes have their own keymaps.

Minibuffer Maps

The minibuffer uses its own local keymaps.

Rebinding

How to redefine one key's meaning conveniently.

Init Rebinding

Rebinding keys with your init file, .emacs.

Function Keys

Rebinding terminal function keys.

Named ASCII Chars

Distinguishing <TAB> from Ctrl+i, and so on.

Mouse Buttons

Rebinding mouse buttons in emacs.

Disabling

Disabling a command means confirmation is required before it can be executed. This is done to protect beginners from surprises.

The Init File, ~/.emacs

 

Init Syntax

Syntax of constants in emacs Lisp.

Init Examples

How to do some things with an init file.

Terminal Init

Each terminal type can have an init file.

Find Init

How emacs finds the init file.

Dealing with emacs TRouble

 

DEL Does Not Delete

What to do if <DEL> doesn't delete.

Stuck Recursive

[...] in mode line around the parentheses.

Screen Garbled

Garbage on the screen.

Text Garbled

Garbage in the text.

Unasked-for Search

Spontaneous entry to incremental search.

Memory Full

How to cope when you run out of memory.

Emergency Escape

Emergency escape what to do if emacs stops responding.

Total Frustration

When you are at your wit's end.

Command-Line Options and Arguments

Action Arguments

Arguments to visit files, load libraries, and call functions.

Initial Options

Arguments that take effect while starting emacs.

Command Example

Examples of using command-line arguments.

Environment

Environment variables that emacs uses.

Environment Variables

 

General Variables

Environment variables that all versions of emacs use.

Misc Variables

Certain system-specific variables.

Simple and Quick: nano

If you find vi to be unfriendly and emacs to be overwhelming, you might find nano more suitable. The nano editor (the name is derived from Nano's ANOther editor, according to the man page) is a small, menu-driven windowed editing system. It is a pico clone that is distributed under the GNU license. The pico editor was developed as the editor for the pine email package. Starting with Mac OS X 10.4, nano, rather than pico, is included, and pico is just a link to nano. This change is most likely a license issue.

Being a menu-driven system, nano does not lend itself to documentation tables, so instead we will show you some output samples. It is worthwhile, though, to take a look at the man page. nano can be run with some options that you might find useful. For example, the -B flag causes nano to write a backup of your file whose name ends in ~. You can also set nano settings in a ~/.nanorc control file, which is documented in the nanorc man page.

When you run nano, you will get output that looks like this:

GNU nano 1.2.4 New Buffer [ New File ] ^G Get Help ^O WriteOut ^R Read File ^Y Prev Page ^K Cut Text ^C Cur Pos ^X Exit ^J Justify ^W Where Is ^V Next Page ^U UnCut Txt ^T To Spell

As with the pine email reader, there is a menu at the bottom to help you with using the program. After you've started typing something, the [New File] designation in the status line goes away.

When you decide to save your file, press Ctrl+O to save the file. The status line asks for the filename and the menu changes to include options pertinent to saving a file. Here is a sample of the changes you see in the nano interface:

GNU nano 1.2.4 New Buffer Modified Hi there. This is my nano test file. File Name to Write: nano-test ^G Get Help M-D DOS Format M-A Append M-B Backup File ^T To Files M-O Mac Format M-P Prepend ^C Cancel

As you work with nano, you will probably find its help system to be useful. Here is the top-level help system page, which is useful for understanding other nano help pages:

GNU nano 1.2.4 New Buffer nano help text The nano editor is designed to emulate the functionality and ease-of-use of the UW Pico text editor. There are four main sections of the editor: The top line shows the program version, the current filename being edited, and whether or not the file has been modified. Next is the main editor window showing the file being edited. The status line is the third line from the bottom and shows important messages. The bottom two lines show the most commonly used shortcuts in the editor. The notation for shortcuts is as follows: Control-key sequences are notated with a caret (^) symbol and are entered with the Control (Ctrl) key. Escape-key sequences are notated with the Meta (M) symbol and can be entered using either the Esc, Alt or Meta key depending on your keyboard setup. The following keystrokes are available in the main editor window. Alternative keys are shown in parentheses: ^G (F1) Invoke the help menu ^X (F2) Close currently loaded file/Exit from nano ^Y Prev Page ^X Exit ^V Next Page

     < Day Day Up > 
    Related

    Категории