Return to emacs.tm CVS log

Up to [Research Unix] / researchv9 / cmd / emacs

Annotation of researchv9/cmd/emacs/emacs.tm, revision 1.1

1.1     ! root        1: .tr ~
        !             2: .\" EMACS_MODES: fill !c
        !             3: .TL 126010-2200 40158-100
        !             4: An Interactive Screen Editor for Unix (Issue 2)
        !             5: .AU "Warren Montgomery" WAM IH 55235 2494 6C-501 85-55235-?
        !             6: .TM ??
        !             7: .SA 1
        !             8: .NR Pt 0
        !             9: .AS 2
        !            10: High speed data communication and display screen terminals make
        !            11: possible a fundamentally different mode of entering and editing text
        !            12: to a computer system.  An interactive screen editor allows a user to
        !            13: enter and edit files, and to see the effects of the editing
        !            14: immediately.
        !            15: .P
        !            16: A good screen editor can improve productivity in several ways.  The
        !            17: need for paper listings, and thus the expense and delay in dealing
        !            18: with them, is greatly reduced with the availability of a screen
        !            19: editor.  The editor can provide a customized environment for
        !            20: particular tasks, such as editing program source or word processing,
        !            21: which can relieve the user of the mechanical parts of the task (such
        !            22: as maintaining proper indentation).  The immediate feedback provided
        !            23: reduces mistakes, and speeds up their detection.  A simple set of editing
        !            24: commands can be used 
        !            25: effectively by relatively unskilled users, because of the feedback
        !            26: obtained by seeing the effects of editing.
        !            27: .P
        !            28: This memorandum describes an interactive screen editor for UNIX\*F
        !            29: .FS
        !            30: Unix is a Trademark of AT&T Bell Laboratories
        !            31: .FE
        !            32: known as EMACS.  The editor is patterned after a very popular screen
        !            33: editor originally developed at the Artificial Intelligence
        !            34: Laboratory M.I.T.  It was developed by the
        !            35: author as a tool for his own work and is currently used by a large
        !            36: number of users in Bell Laboratories.  Emacs is available through
        !            37: the experimental tools facility within Bell Labs, and through the
        !            38: Toolchest package to outside customers.  The editor provides a
        !            39: friendly editing environment with the advantages outlined above,
        !            40: while running in the small address space provided to the UNIX user
        !            41: on the PDP\*F-11/70.  This memorandum describes the commands and
        !            42: editing environment of EMACS, and some experience with its use.
        !            43: It obsoletes the first users manual published in 1980.
        !            44: .FS
        !            45: PDP is a Trademark of Digital Equipment Corporation
        !            46: .FE
        !            47: .AE
        !            48: .MT "TECHNICAL MEMORANDUM"
        !            49: .H 1 "INTRODUCTION"
        !            50: Text editing is the most common task of many computer users.  The
        !            51: creation and modification of programs, data bases, and memoranda
        !            52: occupies much of the time that a user spends with a computer system.
        !            53: The ability to edit programs and recompile them was one of the
        !            54: primary reasons for the success of early time-sharing systems over
        !            55: batch processing systems.
        !            56: .P
        !            57: Many of the text editing tools now in use are based on the editors
        !            58: for the early timesharing systems.  These editors were developed for
        !            59: an environment that included mostly low-speed (110 baud) printing
        !            60: terminals, and expensive computer systems that were not prepared to
        !            61: interact with the user on a character at a time basis.  In such a
        !            62: environment, it was appropriate to minimize the amount of output
        !            63: produced by the editor, and to allow the user to specify a lot of
        !            64: changes to be made by a single editor "command".  Editors such as
        !            65: the standard UNIX\*F editor (ed) are ideal for this environment.
        !            66: .FS
        !            67: Unix is a Trademark of AT&T Bell Laboratories
        !            68: .FE
        !            69: .P
        !            70: In recent years, printing terminals have been repaced by display
        !            71: terminals capable of handling high data rates in many applications.
        !            72: The cost of
        !            73: computing has steadily dropped.  The text editing tools made
        !            74: available to users must evolve to take advantage of these changes. 
        !            75: With a high-speed display terminal, minimizing output is no longer
        !            76: appropriate.  Instead, the display can be used to provide feedback
        !            77: for the user on the results of editing.  The lower cost of
        !            78: computing, and better hardware support for terminals, make character
        !            79: at a time interaction with the computing system feasible.  The EMACS
        !            80: editor described in this report is one attempt to take advantage of
        !            81: these effects in order to provide the user with a simple and
        !            82: powerful editing environment.
        !            83: .P
        !            84: EMACS is a screen editor that can be used to build or to edit files 
        !            85: using a display terminal, such as the hp2621, vt-100, or teletype
        !            86: 5420.  The user
        !            87: interface to this editor is quite simple.  The user is presented
        !            88: with a display of the contents of a portion of the buffer being
        !            89: edited.  This display indicates \fIexactly\fP what is
        !            90: in the area being displayed, including any non-printing characters.
        !            91: The contents of the buffer being edited can be read from or written
        !            92: to a UNIX file.
        !            93: Characters typed by the user will be inserted into the buffer
        !            94: (and reflected in the display) at the point indicated by the
        !            95: terminal's cursor.  This is the primary mechanism for entering and
        !            96: modifying text.
        !            97: .P
        !            98: Control characters and escape sequences can be used to perform other
        !            99: editing functions, such as moving the cursor to a different position
        !           100: in the buffer, deleting text, replacing text, or searching.  Thus
        !           101: there is only one mode of interpretation of characters typed to
        !           102: EMACS, in which either text to be entered or commands can be
        !           103: entered.  This simple interface relieves the user of the need to
        !           104: remember what mode he is in, and prevents the disastrous
        !           105: mistakes that can occur when text to be inserted is evaluated as an
        !           106: editor command.  A simple mechanism is provided to allow a user to
        !           107: insert control and escape characters when needed.
        !           108: .P
        !           109: Although there is a rich vocabulary of commands available,
        !           110: including commands that perform functions tailored to a particular
        !           111: application (such as indenting a C program), the most common way in
        !           112: which EMACS is used to edit is simply to position the cursor
        !           113: over the area to be changed, and enter the changes.  The immediate
        !           114: feedback provided by the visual display appears to be very important
        !           115: to the user.
        !           116: .P
        !           117: This editor was written by the author as an aide to his other work,
        !           118: and patterned after the EMACS editor written for the PDP\*F-10 systems
        !           119: .FS
        !           120: PDP is a Trademark of Digital Equipment Corporation
        !           121: .FE
        !           122: at the M.I.T. Artificial Intelligence Laboratory.  The interface to the
        !           123: user closely follows that provided by the M.I.T. version, because
        !           124: the author was familiar with that version.  The implementation of
        !           125: EMACS for UNIX described in this report was done by the author, and
        !           126: is independent of any other implementations of Emacs.
        !           127: .P
        !           128: The author and his organization are not supporting EMACS.  The
        !           129: author is, however, willing to distribute copies of the software for
        !           130: use within Bell Laboratories, and is interested in comments
        !           131: regarding features or problems with EMACS.  The author will repair
        !           132: problems as time allows, but makes no guarantees to fix problems
        !           133: promptly.
        !           134: .P
        !           135: The remainder of this report contains a user's manual for the EMACS
        !           136: editor, and a discussion of the experience that we have had with
        !           137: EMACS in our department.  EMACS continues to evolve to provide more
        !           138: commands and remove implementation restrictions.  The users manual
        !           139: here describes EMACS version 4.9, which was in use in March, 1985.
        !           140: .P
        !           141: This document is intended to serve the needs of a number of
        !           142: different kinds of readers.  Briefly, here is a guide on how to read
        !           143: it for various kinds of readers.
        !           144: .VL 40
        !           145: .LI "Getting Started as a New User:"
        !           146: Read Chapters 2, 3, and 6.  As you need to, refer to the information
        !           147: in Chapters 4, 5, and 7.
        !           148: .LI "Getting Started as an Experienced User:"
        !           149: Users of other Emacs like editors will probably find the material in
        !           150: chapters 6 to be most useful to start.
        !           151: .LI "Referring to Specific Commands:"
        !           152: All users will find the command and mode descriptions in chapters 4,
        !           153: 5, and 6 to be useful to refer back to specific command
        !           154: descriptions.
        !           155: .LI "Learning about Editors in General:"
        !           156: People interested in the general flavor of emacs and in our
        !           157: experiences with it should read chapters 2 and 8 to get an
        !           158: introduction and to see a discussion of how the features are used.
        !           159: .LE
        !           160: .H 1 "Basic concepts"
        !           161: Before going into the editing commands of EMACS, some basic concepts
        !           162: should be learned.  EMACS operates rather differently from 
        !           163: line oriented editors, and even from other screen oriented editors
        !           164: in the way that it treats the screen and the keyboard.  Some of it's
        !           165: conventions for displaying and inputing characters are not like
        !           166: other Unix tools, primarily because they were originally developed
        !           167: for another environment.
        !           168: .H 2 "The Character Set"
        !           169: EMACS operates on characters from an alphabet of 256 different
        !           170: characters.  These include the 128 ASCII characters that can be entered
        !           171: from a terminal, and 128 "Meta" characters.  A Meta character is
        !           172: entered by preceding it with an escape (ESC key).  
        !           173: .P
        !           174: In this document and in the displays produced by emacs, control
        !           175: characters are indicated by the character '^' followed by the
        !           176: equivalent printable character (usually capitalized).  Thus '^X'
        !           177: represents a control-x, which is typed by hitting the control
        !           178: and 'x' keys simultaneously.  For some
        !           179: unusual non-printing characters, the display is not obvious:
        !           180: .VL 10
        !           181: .LI "^?"
        !           182: Rubout or delete (ASCII 0177)
        !           183: .LI "^@"
        !           184: Null (ASCII 0)
        !           185: .LI "^["
        !           186: Escape (ASCII 033)
        !           187: .LI "^\e"
        !           188: The "fs" character (ASCII 034)
        !           189: .LI "^]"
        !           190: The "gs" character (ASCII 035)
        !           191: .LI "^^"
        !           192: The "rs" character (ASCII 036)
        !           193: .LI "^_"
        !           194: The "us" character (ASCII 037)
        !           195: .LE
        !           196: .P
        !           197: Meta characters are typed to Emacs by hitting the escape character,
        !           198: and then any second character (including a control character.)  They
        !           199: are displayed by emacs as "M-" followed by the equivalent ASCII
        !           200: character.  Thus "M-a" (Meta - a) is the character obtained by typing escape
        !           201: followed by a, and "M-^B" (Meta - control-b) is the character
        !           202: obtained by typing escape followed by control-b.
        !           203: .H 2 "The display"
        !           204: The display screen contains a window showing a view of the buffer
        !           205: being edited, which contains about 20 lines on a typical display
        !           206: terminal.  The terminal cursor is positioned at the
        !           207: point where the editor cursor (the current position where editing is
        !           208: taking place) is in the buffer.  Each line of the buffer
        !           209: (delimited by a newline character) begins at the beginning of a display
        !           210: line.  A line that exceeds the screen width is normally continued on
        !           211: the next screen line.  Whenever a line must be continued on the next
        !           212: screen line an exclamation mark (!) is displayed in the last column
        !           213: of the first screen line.  If the editor is in line number (lnumb)
        !           214: mode, then a line number is printed at the beginning of each line in the buffer.
        !           215: .P
        !           216: Printable characters are displayed normally, while tabs are displayed as
        !           217: white space that fills up the space on the screen until the next
        !           218: position at a multiple of eight.
        !           219: Non printing control characters and meta characters are printed with
        !           220: the conventions outlined above.
        !           221: .SP
        !           222: If you edit a file which contains characters that have the high
        !           223: order (parity) bit set, they will display as "M-" followed by the
        !           224: display of the character.  You will only run into this when trying
        !           225: to edit files containing binary information.
        !           226: .P
        !           227: In addition to the display buffer, several lines of the screen are used
        !           228: for status information and for displaying parameters entered into EMACS,
        !           229: such a file name.  One of these lines known as the status line contains the
        !           230: editor name, editor version, buffer number and name, and file name.  Some
        !           231: of the more recently introduced commands described in this document
        !           232: indicate the version in which they were introduced, so that you can
        !           233: determine whether or not a particular command is in the version that
        !           234: you are running.
        !           235: If the buffer has not been modified since the file was read or written,
        !           236: an '=' will be displayed between the buffer and file names.  Otherwise,
        !           237: a '>' will appear.
        !           238: .P
        !           239: The lines below the status line are used for the time of day display
        !           240: (if time mode is on), and for emacs to prompt for parameters for
        !           241: commands.  Some commands cause the buffer display to be erased in
        !           242: order to display other information in place of the buffer.  The word
        !           243: "Continue?" will be displayed at the bottom of the screen when this
        !           244: happens.  Typing 'y', ' ', or return will bring back the buffer
        !           245: display.  Typing 'n' may allow you to re-execute the command
        !           246: producing the display.
        !           247: .P
        !           248: Figure 1 shows a typical screen during a EMACS session.  The buffer
        !           249: "Main", number 0, is being used to edit a program test.c.  The
        !           250: buffer has been modified since the last write to the file test.c.
        !           251: .DF
        !           252: .ce
        !           253: Figure 1 EMACS screen Display
        !           254: .SP 2
        !           255: 1   #include <stdio.h>
        !           256: 2   /* EMACS_MODES: c, !fill, comcol=43 */
        !           257: 3
        !           258: 4
        !           259: 5   /* This is a c program */
        !           260: 6
        !           261: 7   main()
        !           262: 8   {
        !           263: 9           int i;
        !           264: 10          char c;
        !           265: 11
        !           266: 12          for (i = 0;i > 0; i++) {
        !           267: 13                  printf("i = %d\en",i); /* print i */
        !           268: 14          }
        !           269: 15  }
        !           270: 16
        !           271: 
        !           272: EMACS 4.8  (0) Main > test.c
        !           273: 
        !           274: 
        !           275: .DE
        !           276: .H 2 "The Text in The Buffer"
        !           277: Each buffer that you edit holds a sequence of characters.  Any
        !           278: characters can be present in an emacs buffer, including control and
        !           279: meta characters.  The only limitation is on the number of characters
        !           280: that can be on one line in the buffer.  Normally, emacs treats the
        !           281: buffer just as a sequence of characters.
        !           282: .P
        !           283: One difference between emacs and many editors is that emacs does not
        !           284: treat "newline" characters specially.  Between each pair of adjacent
        !           285: lines of text in the buffer is an invisible "newline" character.  If
        !           286: the cursor is at the end of one line, it is in front of the newline
        !           287: character, and deleting a single character will delete the newline,
        !           288: causing the text in the following line to be joined to the current
        !           289: line.  Newlines can be inserted, deleted, and searched for like any
        !           290: other characters.
        !           291: .P
        !           292: Some emacs commands operate on units of text in the buffer, like
        !           293: words, lines, sentences, pages, etc.  These work on top of the base
        !           294: level which still treats the buffer as a string of
        !           295: characters.
        !           296: .H 2 "Command structure"
        !           297: Unlike most other editors, emacs does not have distinct "modes" for
        !           298: inserting text into the buffer and for entering commands.  Thus
        !           299: there are no commands for inserting text, and no special convention
        !           300: to end a text insertion.  Instead, at any point ordinary characters
        !           301: can be inserted into the buffer simply by typing them, while control
        !           302: and meta characters are used for editing commands.
        !           303: .P
        !           304: Each character that is typed into EMACS is in fact interpreted as a
        !           305: command.  All of the ordinary printing characters insert themselves into the 
        !           306: buffer being edited at the point defined by the cursor.  Thus
        !           307: the command invoked when you type the character 'x' inserts an x
        !           308: into the buffer at the point shown by the cursor.  The control and
        !           309: meta characters are used for various editing functions.
        !           310: .H 2 "Arguments and Parameters"
        !           311: All commands, including the printing characters, take a numeric argument
        !           312: that has some effect on their interpretation.  The default argument
        !           313: given to a command for which no argument is specified is 1.  To
        !           314: specify some other argument to a command, you can enter escape,
        !           315: followed by a sequence of digits, and then the command.
        !           316: You can specify a negative value for an argument by entering escape
        !           317: followed by '-', followed by a sequence of digits.
        !           318: Numbers starting with a 0 are interpreted as
        !           319: octal, while numbers starting with any other digit are decimal.
        !           320: A second
        !           321: way of specifying the argument is to precede the command by one or more 
        !           322: ^U (control-u) characters.  Each ^U multiplies the value of the argument 
        !           323: by 4.  
        !           324: .P
        !           325: For most commands, the effect of the argument is to multiply the
        !           326: number of times that the command is applied.  Thus the sequence ^U^Ux 
        !           327: inserts 16 x's into the buffer at the current location.  The sequence 
        !           328: ESC13^N moves forward 13 lines in the buffer.
        !           329: .P
        !           330: In addition to the numeric argument given to all commands, some
        !           331: commands will prompt the user for additional character string
        !           332: parameters.  The commands that take parameters, and the method of
        !           333: entering parameters are described in the section on file and buffer
        !           334: commands.
        !           335: .H 1 "Basic Emacs Commands"
        !           336: As noted above, every character you type to emacs is interpreted as
        !           337: a command.  This section describes a simple set of commands that
        !           338: will be sufficient for most editing that you do.  Subsequent
        !           339: sections describe more advanced commands that are very useful in
        !           340: certain situations, and other aspects of emacs.
        !           341: .P
        !           342: Emacs has a large number of commands.  Most of them have a mnemonic
        !           343: significance that should be obvious (like ^B for backwards or ^D for
        !           344: delete).  Some, unfortunately, don't have any obvious meaning.  As a
        !           345: general rule, control character commands operate on characters and
        !           346: lines, while the corresponding meta character commands operate on
        !           347: words or sentences.
        !           348: .P
        !           349: The user interface of emacs was designed for touch typists.  A
        !           350: deliberate choice was made to use control and meta characters for
        !           351: commands rather than special keys, such as the function or "arrow"
        !           352: keys on many terminals, since these keys are different on every
        !           353: terminal and generally cannot be reached without taking your fingers
        !           354: off of the home position of the keyboard.  Typically the only
        !           355: difficulty faced by an emacs user in adapting to a new terminal is
        !           356: locating the escape key, which is unfortunately located differently
        !           357: on every terminal.  With a little practice, you will find that your
        !           358: fingers become adept at locating the keys for all of the basic
        !           359: commands with little thought and without having to look at the
        !           360: keyboard.
        !           361: .H 2 "Getting Help or getting out of trouble"
        !           362: Emacs has many self-help features.  The commands listed in this
        !           363: section are useful to know about because they can provide help or
        !           364: remedy mistakes.
        !           365: .VL 10
        !           366: .LI "M-?"
        !           367: Explain.   This command prompts for a character and prints a brief 
        !           368: explanation of what that character does.
        !           369: .LI "M-w"
        !           370: Wall Chart.  This command puts a listing of all commands (including
        !           371: user defined commands), and their help explanations into the
        !           372: current buffer.  This command is a
        !           373: convenient way of producing a "wall chart" of the commands.  The
        !           374: list is inserted into the buffer at the current position, so that
        !           375: normally one would want to execute it in an empty buffer.
        !           376: The appendix to this report contains a current copy of the wall chart.
        !           377: .LI "^L"
        !           378: Refresh.  refresh the display.  Occasionally, some error may cause the
        !           379: display to become garbled.  ^L re-creates it from scratch.  If you
        !           380: give an argument to ^L, it is used to specify how many lines will
        !           381: appear on the screen before the current line.  When invoked with an
        !           382: argument, this command does not re-create the display from scratch.
        !           383: .LI "^G"
        !           384: Abort.  Typing ^G at any point that emacs is asking for input
        !           385: will abort the current command.  This applies at
        !           386: any step (specifying arguments, typing escape, entering parameters
        !           387: that emacs asks for, etc.).  (There are a couple of exceptions
        !           388: related to advanced editing commands, but even with these, typing ^G
        !           389: several times will always get you out with minimal damage).
        !           390: This is a convenient way of aborting anything that you are not sure
        !           391: that you want to complete, and may not know how you started.
        !           392: .LI "M-u"
        !           393: Undo.  This command undoes the effect of the last significant text
        !           394: modifying command that can be undone.  Undo is it's own inverse, so
        !           395: invoking undo twice in a row undoes the result of the undo command. 
        !           396: Significant text modifying commands include all except insertion of
        !           397: individual characters (including newlines), and the open-line (^O)
        !           398: command.
        !           399: .P
        !           400: Almost all commands can be undone, but a few effects of commands
        !           401: can't be undone.  M-u will not undo the
        !           402: effects of reading or writing files, nor can it undo anything done
        !           403: by executing unix commands from emacs.  Undo cannot be used to bring
        !           404: back buffers that may have been inadvertently killed with the ^X^K
        !           405: command (see below).  Undo can undo all other significant text
        !           406: modifications, with the exception that when the last significant text
        !           407: modification was a replace command, only a limited number of
        !           408: replacements can be undone.  If more replacements were done with one
        !           409: command, undo prints a warning error message and if the user
        !           410: specifies then undoes what it can.
        !           411: .LI "^X^C"
        !           412: Quit Emacs.
        !           413: If any buffers have been modified since the last write, EMACS will
        !           414: ask whether or not to write out each such buffer before exiting.
        !           415: EMACS will not ask whether or not to save an empty buffer.
        !           416: .LI "BREAK"
        !           417: Emacs will not respond to your normal interrupt character, but it
        !           418: will respond if you hit the BREAK key on your terminal.  Break
        !           419: causes emacs to stop anything that it was doing at the next
        !           420: convenient point, and displays a message to you listing some
        !           421: options.  When you hit break you can either continue what you were
        !           422: doing, abort what you were doing, exit from emacs, or suspend what
        !           423: you were doing such that you can return to it later if you wish.
        !           424: .LE
        !           425: .H 2 "Simple cursor movement commands"
        !           426: There are many ways to move the cursor around in the buffer without modifying
        !           427: the text in the buffer.  Most of these use their argument to specify
        !           428: how many times the movement is to be repeated.  
        !           429: .VL 10
        !           430: .LI "^F,^B"
        !           431: Move forward or backward one character.  Recall that the end of each
        !           432: line counts as one character, so that ^F at the end of one
        !           433: line will put you at the beginning of the next line.
        !           434: .LI "^N,^P"
        !           435: Move to next or previous line.  Emacs moves to the same character
        !           436: position in the line below (^N) or above (^P) the current line.
        !           437: Note that if the buffer contains tab or control characters, the same
        !           438: character position in the lines in the buffer may display at
        !           439: different points in the screen. 
        !           440: .LI "^A,^E"
        !           441: Move to the beginning (^A) or end (^E) of the current line of the
        !           442: buffer.  Note that these work on one line of the buffer, not one
        !           443: line of the screen. If the current line is longer than will fit on
        !           444: one line of the screen display, these commands will move up or down
        !           445: on the screen to the real beginning or end of the line in the buffer.
        !           446: .LI "M-<,M->"
        !           447: Move the cursor to the beginning or end of the buffer.
        !           448: .LI "M-f,M-b"
        !           449: Move the cursor forward or backward by one word.  In emacs, words
        !           450: are delimited by non-alphabetic or non-numeric characters.  If your
        !           451: terminal is capable of displaying underscored characters, emacs will
        !           452: not consider these characters as separating words.
        !           453: .LI "M- a,M-e"
        !           454: Move the cursor to the beginning or end of the current sentence. 
        !           455: The end of a sentence is defined as a punctuation mark followed by two
        !           456: or more whitespace characters (blanks or newlines).  With an
        !           457: argument, these commands can be used to move forwards or backwards
        !           458: by a specified number of sentences.
        !           459: .LI "^V,M-v"
        !           460: Move to next or previous page.  The cursor is moved forward or
        !           461: backward so that the display will show the text just before or just
        !           462: after the text now in the window on the screen.
        !           463: .LI "M-g"
        !           464: Move the cursor to the line number specified by the argument given
        !           465: to the command.
        !           466: .LE
        !           467: .H 2 "Simple Text Deleting and Moving Commands"
        !           468: Several commands are available to delete text from the buffer.  All of
        !           469: these commands operate on text near the current cursor position.  The 
        !           470: deletion commands are:
        !           471: .VL 10
        !           472: .LI "^D,^H"
        !           473: Delete forwards or backwards from the cursor.  ^H, or backspace
        !           474: deletes the character immediately before the cursor.  ^? or rubout,
        !           475: is a synonym for ^H.  ^D deletes the character on top of the cursor.
        !           476: If given arguments, these commands delete blocks of text forward or
        !           477: backward of the current cursor position.
        !           478: .LI "M-d,M-^?"
        !           479: Delete words forwards or backwards from the cursor.  These two
        !           480: commands delete words (as defined for M-f and M-b).  If the current
        !           481: cursor position is in the middle of a word, M-d will delete from the
        !           482: cursor to the end of the word while M-^? will delete everything
        !           483: before the cursor.
        !           484: .LI "^K"
        !           485: Delete to the end of this line.  If invoked without an argument, ^K 
        !           486: deletes the remaining text on this line (if any).  If no text follows the
        !           487: cursor on the current line, ^K deletes the newline.  With an
        !           488: argument of 0, ^K deletes the text before the cursor on the current
        !           489: line.  With an argument of n greater than zero, it
        !           490: deletes n lines forward from the cursor position.  The text from the
        !           491: cursor up to and including the nth newline  is deleted.  With an
        !           492: argument less than zero, the deletion is backwards from the cursor
        !           493: position.
        !           494: .LI "M-~"
        !           495: (Meta space)
        !           496: The command Meta-space places an invisible mark on the 
        !           497: current cursor position.  This mark can be used in subsequent editing.
        !           498: Each mark is simply a position in the buffer (line number and
        !           499: character within the line.)  Thus if you add or delete text in front
        !           500: of a position where a mark was placed, the mark may not remain on
        !           501: the same character, but stays on the same position.
        !           502: .P
        !           503: Emacs actually maintains 16 different marks, normally allocated as
        !           504: one per buffer.  (Thus if you set marks in different buffers, they
        !           505: are normally independent.)  You can, however, alter this by
        !           506: specifying a mark number as an argument to Meta-space and other
        !           507: commands that work with marks.  This allows you to mark up to 16
        !           508: different positions in one buffer.  The command ^@ (Control-@) is a
        !           509: synonym for Meta-space, but cannot be typed on all keyboards.
        !           510: .LI "^W"
        !           511: The command '^W' deletes the text between the current cursor position and 
        !           512: the mark.  This is a convenient way to delete a well defined block of text.
        !           513: If an argument is specified, it is used to select the mark number
        !           514: The mark can be either before or after the cursor position and
        !           515: achieve the same effect.
        !           516: .LI "^Y"
        !           517: Insert last killed text.  All text that is deleted is saved in a "kill 
        !           518: stack".  The kill stack holds the last 16 deletions.  There is
        !           519: also a limit on the total amount of text that can be held in the
        !           520: kill stack, but you are unlikely to encounter it.
        !           521: ^Y retrieves the most recently deleted text.  The most
        !           522: frequent use of this command is in moving text around.  The procedure 
        !           523: is: kill the text to be moved, move the cursor to where you want it, and 
        !           524: enter ^Y.  Another use of ^Y is to undo an unwanted deletion.  ^Y 
        !           525: leaves the mark at the beginning of the inserted text, and puts the 
        !           526: cursor at the end.  ^Y treats it's argument (if any) as a count for
        !           527: the number of copies of the deleted text to bring back, and not a
        !           528: mark number.  ^Y operates only with the default mark.
        !           529: .LI "M-y"
        !           530: Replace last retrieved text.  This command kills the text between
        !           531: the cursor and the mark and replaces it with the next to last item on
        !           532: the kill stack.  This command can only be used immediately after ^Y,
        !           533: where it changes text that has just been retrieved.  By entering ^Y
        !           534: followed by some number of M-y's, any text in the kill stack can be
        !           535: retrieved.
        !           536: .LI "M-p"
        !           537: Pickup the region of text.  This command picks up the text between
        !           538: the current position and the mark and puts it in the kill stack,
        !           539: without changing the buffer.  This is useful for duplicating blocks
        !           540: of text in the buffer.  An argument can be used to specify which mark
        !           541: to use
        !           542: .LI "^X^X"
        !           543: (Type control-X twice) Exchange the cursor position and the mark. 
        !           544: An argument can be specified to indicate the mark to exchange with.
        !           545: .LE
        !           546: .H 2 "Simple File and buffer Commands"
        !           547: Commands that access files and buffers must ask for the
        !           548: name of the appropriate file or buffer.  All of these commands (and
        !           549: some of the others) ask for the appropriate information at the
        !           550: bottom of the screen.  You can use some of the simple editing
        !           551: commands described here, plus a couple of special commands, to edit
        !           552: a file or buffer name that you enter this way.  The commands that
        !           553: you can use for editing are:
        !           554: .VL 10
        !           555: .LI "^F,^B"
        !           556: Move forward or backward one character
        !           557: .LI "^A,^E
        !           558: Go to beginning or end of line.
        !           559: .LI "^D,^H"
        !           560: Delete forward or backward
        !           561: .LI "^U"
        !           562: Multiply the effect of the next command by 4.
        !           563: .LI "^K"
        !           564: Kill (erase) the whole line
        !           565: .LI "^G"
        !           566: Abort the command asking for information
        !           567: .LI "^X"
        !           568: Enter the current line from the file at the cursor
        !           569: .LI "^Y"
        !           570: Enter the current file name at the cursor
        !           571: .LI "^L"
        !           572: Redisplay the prompt and the string being entered
        !           573: .LI "^T"
        !           574: Transpose the characters before and after the cursor
        !           575: .LI "^Q"
        !           576: Quote the following character (eliminates the special significance
        !           577: of the next character and just sticks it literally in the string
        !           578: being typed.)
        !           579: .LI "return"
        !           580: End the string being typed, and continue editing.  (If the cursor is
        !           581: in the middle of the line, the whole line is given to whatever
        !           582: command asked for it, not just the text before the cursor).
        !           583: .LE
        !           584: .P
        !           585: Most of the file accessing commands are invoked through the ^X command.
        !           586: ^X is a prefix for several useful commands, most of which involve file
        !           587: or buffer access.
        !           588: These commands are invoked by a ^X followed by a second character.
        !           589: .P
        !           590: In the commands that ask for filenames, the normal shell conventions
        !           591: for partially specified names can be used.  Any of the following
        !           592: sequences can be used in a filename and will be substituted
        !           593: properly.
        !           594: .tr ~~
        !           595: .VL 20
        !           596: .LI "$VARIABLE"
        !           597: Substitutes the value of the environment variable $VARIABLE or
        !           598: nothing if VARIABLE is not defined.  Thus you can use path names like
        !           599: $HOME/.profile.
        !           600: .LI "* and ?"
        !           601: These characters can be used to specify incomplete filenames and
        !           602: will be expanded.  If more than one file matches the name given,
        !           603: then emacs will pick only the first one.
        !           604: .LI "~USER"
        !           605: This translates into the home directory of the user USER.  In
        !           606: addition, EMACS always translates the special name ~EMACS into an
        !           607: emacs library directory.  This is a directory where special
        !           608: files needed by emacs are stored and where standard macros are
        !           609: stored (in ~EMACS/macros).
        !           610: .LI "`COMMAND`"
        !           611: This causes COMMAND to be run and substitutes it's standard output.
        !           612: .LE
        !           613: .tr ~ 
        !           614: .P
        !           615: With these preliminaries out of the way, here are some of the
        !           616: commands that work with files and buffers
        !           617: .VL 10
        !           618: .LI "^X^R"
        !           619: Read file.  EMACS will prompt for a file name, which you enter as
        !           620: described above. When the file name for ^X^R has been entered, EMACS
        !           621: will read the specified file into the buffer.
        !           622: .P
        !           623: Many of the commands in this section, including ^X^R, use their
        !           624: argument to specify minor variations on the basic action of the
        !           625: command, rather than specifying a count.  In the normal case, (with
        !           626: the default argument of one), ^X^R clears the buffer before reading.
        !           627: If ^X^R is invoked with an argument that is not 1 (i.e. ^U^X^R) it
        !           628: inserts the file into the buffer at the current cursor position. 
        !           629: If ^X^R is invoked with a negative argument, no error message is
        !           630: produced if the specified file cannot be read.
        !           631: .LI "^X^W"
        !           632: Write file.
        !           633: Normally, if the specified file exists and has two or more links to
        !           634: it, EMACS will ask whether to overwrite the existing copy of the
        !           635: file or to unlink the specified file name and create a new file in
        !           636: its place, leaving the contents of the old file (which may be
        !           637: obtained through the other names it was linked to) unchanged.
        !           638: If emacs fails or the unix system crashes during an attempted write
        !           639: (either ^X^W or ^X^S), the previous contents of the file are saved
        !           640: in a file .EMACS in your current working directory.
        !           641: .P
        !           642: Passing an argument to ^X^W (i.e. ^U^X^W) causes the contents of the
        !           643: current buffer to be appended to the specified file rather than
        !           644: replacing it.
        !           645: .LI "^X^S"
        !           646: Save buffer.  This writes out the buffer to the last file read or written if
        !           647: the file has been modified.  If the buffer was not read from a file,
        !           648: and has never been written to one, such that there is no file name
        !           649: associated with the buffer, emacs will ask for a filename to save
        !           650: the buffer in.
        !           651: .LI "^X^B"
        !           652: Change buffer.  EMACS allows up to 12 named buffers to be edited
        !           653: concurrently.  Each buffer can hold a different file, and has it's
        !           654: own current cursor position.  In emacs you work with one buffer at a
        !           655: time, although you can display two buffers on the screen at the same
        !           656: time.   The ^X^B command asks for the name of a buffer and makes
        !           657: that buffer the current buffer.
        !           658: .P
        !           659: All of the commands that ask for buffer names accept either the text
        !           660: name of the buffer, or the buffer number (shown in parentheses after
        !           661: the editor name on the status line) for a buffer name.  The number
        !           662: is convenient if you
        !           663: don't like typing long names.  Emacs treats two buffer names
        !           664: specially.  For any of the commands that ask for buffer name, if you
        !           665: enter an empty buffer name (by just hitting return in response to
        !           666: the prompt, emacs shows you a display of all of your currently
        !           667: defined buffers, indicating which one is current and which ones have
        !           668: been modified since they were last written.  If you type space
        !           669: or 'y' in response to the prompt that appears after the display,
        !           670: emacs will abort whatever command asked for the buffer name and
        !           671: continue editing.  If you type 'n' in response to the prompt,
        !           672: emacs will ask again for the buffer name, and then complete whatever
        !           673: command asked for the buffer name.  If the buffer
        !           674: name "..." is entered, a new, empty buffer with a unique name is created.
        !           675: .LI "^X^F"
        !           676: Find file.  This command prompts for a file name and switches to a
        !           677: buffer that holds the specified file.  If the specified file has
        !           678: been read into a buffer, the effect of find file is to change to
        !           679: that buffer.  If no buffer holds the specified file, the effect of
        !           680: find file is to create a new buffer and read the specified file into
        !           681: it.  Find file is a convenient way to switch between editing several files.
        !           682: If ^X^F is invoked with a negative argument, no error message is
        !           683: produced if the specified file cannot be found.
        !           684: .LI "^X^K"
        !           685: Kill Buffer.  This command prompts for a buffer name and destroys
        !           686: the specified buffer.  You cannot kill the current buffer this way. 
        !           687: Text in the buffer that is killed is lost and cannot be recovered.
        !           688: .LE
        !           689: .H 2 "Simple Search, Replace, and other commands"
        !           690: Emacs provides several commands that search for text in the buffer,
        !           691: and also commands which allow you to specify global replacements,
        !           692: like change every instance of "football" to "baseball".  The
        !           693: simplest forms of these commands are described here, along with a
        !           694: couple of miscellaneous commands that are useful.  More complex
        !           695: versions of search and replace are described in the subsequent
        !           696: section on advanced editing.
        !           697: .VL 10
        !           698: .LI "^S,^R"
        !           699: Forward and Reverse Search.  These commands allow you to look for
        !           700: text in your buffer.  Emacs will prompt at the bottom of the screen
        !           701: with "Search" or "Reverse Search".  In response to the prompt, you
        !           702: can type in characters, and emacs will begin to look for the next
        !           703: match for what you type, going either forwards (^S) or backwards
        !           704: (^R) from the current position in the buffer.  Emacs will
        !           705: show you the text that matches what you have typed as you type it,
        !           706: by moving the cursor to the text, possibly moving the display window
        !           707: in the buffer if the text you are looking for was not visible.  As
        !           708: you type in the string to look for, you get immediate feedback about
        !           709: what emacs has found.  In addition to typing normal printing
        !           710: characters that become part of the string you are looking for, you
        !           711: can type some special characters to either edit the string you are
        !           712: looking for, or control the search in some other way:
        !           713: .VL 15
        !           714: .LI "^H"
        !           715: This deletes the last character of the search string, and will cause
        !           716: the cursor to go back to whatever matches what is left.
        !           717: .LI "escape"
        !           718: Hitting escape stops the search, leaving the cursor on whatever you
        !           719: last found.
        !           720: .LI "^G: "
        !           721: This quits from the search and goes back to the point in the buffer
        !           722: where you started the search from.
        !           723: .LI "return or newline: "
        !           724: These both cause a newline to become part of the search string.  the
        !           725: newline is displayed as "^J" (which is the control character
        !           726: actually used by unix to indicate "newline") in the search string to
        !           727: allow you to see it.  Thus if you type "^Sthe~end<return>of", emacs
        !           728: will look for a spot where "the~end" appears at the end of one line
        !           729: and "of" appears at the start of the next line
        !           730: .LI "^S or ^R: "
        !           731: These characters control the search.  In general, if you are going
        !           732: forward, and type ^R, or going backwards and type ^S, the search
        !           733: changes direction, starting from the last thing you found.  If you
        !           734: are going forward and type ^S or backwards and type ^R, the search
        !           735: proceeds to the next occurrence (in whatever direction you were
        !           736: going) of the search string.  If you type ^S or ^R as the very first
        !           737: thing after starting a search, emacs takes the \fIlast\fP string
        !           738: that you successfully found with a search and makes it the current
        !           739: search string.  These characters provide a convenient way to
        !           740: navigate when looking for something that occurs many times in the
        !           741: buffer.
        !           742: .LI "^Q: "
        !           743: Typing ^Q "quotes" the next character, making it part of the search
        !           744: string.  This is a way to look for strings that contain control
        !           745: characters.
        !           746: .LI "other control characters: "
        !           747: Typing any other control character causes the search to stop at
        !           748: whatever you found, and then executes the command corresponding to
        !           749: that control character.
        !           750: .LE
        !           751: .P
        !           752: This kind of search is called an incremental search in emacs,
        !           753: because it shows you what you have matched incrementally as you type
        !           754: it.  It is very easy to learn to use.  For incremental search, the
        !           755: search string must \fIexactly\fP match whatever you are looking for. 
        !           756: (There is a more complicated search available that allows some
        !           757: pattern matching, and is described in the advanced commands
        !           758: section.)  Incremental search stops, indicating that it fails if you
        !           759: reach the beginning or end of the buffer.  Normally, search
        !           760: considers upper and lower case letters to be different, however you
        !           761: can override this with "caseless" mode.
        !           762: .LI "M-r"
        !           763: Query replace.  You will be prompted for a From string and a To string.  
        !           764: Each can be edited using the conventions described in the previous
        !           765: section for editing filenames.  In general, Query
        !           766: replace will allow you to replace all of the strings in your buffer
        !           767: from the current cursor position to the end of the buffer that match
        !           768: the From string with the To string.  In the To string, the '&'
        !           769: character can be used to designate replacement with the From string.
        !           770: To get a real '&', prefix it with a '\e'.  To get a real '\e', prefix
        !           771: it with another '\e'.
        !           772: EMACS then searches for the from string, positions the cursor in
        !           773: front of it, and prompts you. You can control the replacement of the
        !           774: item in question by what you type:
        !           775: .VL 15
        !           776: .LI "<space> or y"
        !           777: Replace this occurrence and move on to the next one.
        !           778: .LI "n or ^?"
        !           779: Skip this occurrence and move on to the next.
        !           780: .LI "."
        !           781: Replace this occurrence and exit query replace.
        !           782: .LI "^G"
        !           783: Quit.  (Exit query replace without replacing the current match.)
        !           784: .LI "b"
        !           785: Go back to the previous occurrence of the "To" string.  It won't find
        !           786: one that you have already replaced!
        !           787: .LI "r"
        !           788: Replace the rest without stopping to ask after each, and show the
        !           789: result of the replacement after each.
        !           790: .LI "R"
        !           791: Replace the rest silently.  (i.e. don't show the result after each
        !           792: replacement.)
        !           793: .LI "<ESCAPE>"
        !           794: (Version 4.6) Causes emacs to ask for a new string to replace the "To" string with
        !           795: with.  The current occurrence will be replaced with what you type,
        !           796: and emacs will go on to the next occurrence.
        !           797: .LE 
        !           798: .P
        !           799: Normally, query replace will show all occurrences of the search
        !           800: string.  With an argument (i.e. ^UM-r), it behaves like the
        !           801: substitute command of the ed editor, looking at only the first match
        !           802: of the From string on each line.  Query replace exits when the from
        !           803: string is no longer matched.  '?' prints a summary of the options.
        !           804: As with incremental search, the From string must match exactly to
        !           805: something in the buffer.  There is a more advanced form of query
        !           806: replace that allows pattern matching and is described in the section
        !           807: on advanced commands.
        !           808: .LI "^O"
        !           809: Open up a line.  This command creates one or more empty lines at the 
        !           810: current cursor position.  This is useful for inserting text in the 
        !           811: middle of the buffer, while minimizing the amount of screen refresh 
        !           812: needed.
        !           813: .LI "^T"
        !           814: Transpose the next two characters.  The cursor moves forward one
        !           815: character for each transposition, such giving ^T a count as an
        !           816: argument causes the character in front of the cursor to be dragged
        !           817: forward through the text.
        !           818: .LE
        !           819: .H 1 "Advanced Editing Commands"
        !           820: The commands described in the previous section are sufficient to
        !           821: allow a user to perform most editing tasks efficiently.  The
        !           822: commands in this section for the most part cover special situations,
        !           823: like inserting control characters into files, or provide more
        !           824: efficient ways to to things in certain situations.
        !           825: .H 2 "Inserting 'odd' characters"
        !           826: Because EMACS uses control and escape characters for commands, you
        !           827: cannot directly insert them into the buffer by typing them.  The
        !           828: following three commands are useful for the occasional need to get
        !           829: such characters into a buffer.
        !           830: .VL 10
        !           831: .LI "^Q"
        !           832: Quote the next character(s).  ^Q accepts one or more characters (the
        !           833: number of characters specified by its argument) from the terminal
        !           834: and inserts them "blindly" into the buffer without interpretation.  
        !           835: Only the newline (line feed) character is interpreted.  EMACS strips
        !           836: the parity bit from all characters read from the terminal, so all
        !           837: characters inserted this way have zero parity.
        !           838: .LI "M-q"
        !           839: Quote characters and turn on parity bit.  This acts just like ^Q,
        !           840: however it turns on the parity bit in the character before
        !           841: inserting.  Characters inserted this way will be displayed as meta
        !           842: characters by EMACS.
        !           843: .LI "M-\e"
        !           844: Convert the argument to a character and insert into the buffer. 
        !           845: This command takes its argument and converts it to a character and
        !           846: inserts it.  This provides an easy way to convert from octal or
        !           847: decimal to ASCII, and is occasionally useful for inserting odd
        !           848: characters for which the ASCII code is known.
        !           849: .LE
        !           850: .H 2 "Commands related to Windows"
        !           851: Emacs provides a way to display two buffers on the screen at the
        !           852: same time.  When this is done, the screen is split vertically, and
        !           853: one buffer is displayed in the top half and one in the bottom half. 
        !           854: The status line will show status of the current buffer.
        !           855: .P
        !           856: When emacs displays two buffers like this, only the one that is the
        !           857: current buffer is actively updated.  The display for the other just
        !           858: sits on the screen undisturbed until you return to that buffer.  You
        !           859: can have the same buffer displayed in both windows, however note
        !           860: that the current position is associated with a buffer, not a window,
        !           861: thus if you move the current position in the lower window, when you
        !           862: return to the upper window, the cursor will immediately move to
        !           863: wherever you were in the lower window.  If you have different
        !           864: buffers in the two windows, the current positions in both buffers
        !           865: are independent, as they are with any two buffers.
        !           866: .VL 10
        !           867: .LI "^X2"
        !           868: Enter two window mode.  Emacs will ask for a buffer to show in the
        !           869: second window.  The current buffer becomes the top window, while the
        !           870: buffer that you type in response to the prompt goes in the lower
        !           871: window and becomes the current buffer. 
        !           872: .LI "^X^^"
        !           873: Grow window.  Makes the current window grow by the number of lines
        !           874: specified by the argument to ^X^^.  This command works only when you
        !           875: are in two window mode.  You can use a negative argument to cause
        !           876: the current window to shrink.
        !           877: .P
        !           878: You can also use this command to grow or shrink the buffer display
        !           879: with only one window on the screen.  This can be useful in avoiding
        !           880: long delays when working from a low speed terminal port.
        !           881: .LI "^X1"
        !           882: Return to one window.  The current window grows to fill the screen.
        !           883: .LI "^X^O"
        !           884: Switch windows.  Make the dormant window current and the current
        !           885: window dormant.
        !           886: .LE
        !           887: .H 2 "Advanced Search and Replace Commands"
        !           888: The simple incremental versions of search and replace described
        !           889: above require that you match what you are looking for exactly.  The
        !           890: commands described here allow pattern matching of regular
        !           891: expressions, like those used by the ed editor.  
        !           892: .P
        !           893: The description of regular expressions is to complex to reproduce
        !           894: here.  Refer to the manual for ed for a brief description.  Emacs
        !           895: provides two additional special sequences for regular expressions. 
        !           896: The character sequences "\e<" and "\e>" can be used
        !           897: to match the beginning and end of words.  Thus the string \e<the\e>
        !           898: will match any occurrence of the word "the", but not any word
        !           899: containing the sequence of letters "the", such as "other".
        !           900: .P
        !           901: In constructing regular expressions, it is important to remember
        !           902: that in order to avoid the special significance of a character
        !           903: like '.' or '*', you must prefix it with a backslash '\e'.  If you
        !           904: must have control characters in regular expressions, you can quote
        !           905: them for emacs by typing ^Q before the control character.
        !           906: .P
        !           907: Note also that regular expression searches are constrainted to
        !           908: matching only those things that fit all one one line.
        !           909: .P
        !           910: .VL 10
        !           911: .LI "M-^S"
        !           912: Regular Expression Search.  This will prompt for a
        !           913: regular expression to search for.  You can edit the expression like
        !           914: editing filenames.  You can search forward or backward, either
        !           915: ending at the beginning or end of buffer, or wrapping around (like
        !           916: ed) depending on the argument given to the search command:
        !           917: .VL 10
        !           918: .LI "1"
        !           919: (default) Search forward, wrapping from the end of the buffer to the
        !           920: beginning, and failing only if the buffer contains no match for the
        !           921: given string. 
        !           922: .LI "-1"
        !           923: Search backwards, wrapping around from the beginning to end of the
        !           924: buffer.
        !           925: .LI "> 1"
        !           926: Search forwards, stopping at the end of the buffer.
        !           927: .LI "< -1"
        !           928: Search backwards, stopping at the beginning of the buffer.
        !           929: .LE
        !           930: .P
        !           931: In all cases, you can have emacs repeat the search, looking for the
        !           932: next (or previous) occurrence of the search string by typing ^S or ^R
        !           933: immediately after the regular expression search.  
        !           934: .LI "M-^R"
        !           935: Regular expression query replace.  This is just like
        !           936: query replace, except that a regular expression is allowed in the
        !           937: search string.  You may also use the special character sequence
        !           938: \e<digit>, to specify that the characters matched by the
        !           939: nth subexpression (delimited by \e( and \e)) are to be used in the
        !           940: replacement string.
        !           941: .LE
        !           942: .H 2 "Macros, Keyboard Macros, and Input Files"
        !           943: Emacs provides a number of ways for a user to construct editor
        !           944: programs from sequences of commands.  The macro programming facility
        !           945: is the best way to construct substantial programs, and is described
        !           946: in a companion document.  The commands listed here deal with two
        !           947: other ways of saving a sequence of emacs commands for later use,
        !           948: Input files and Keyboard Macros, and with the commands that load
        !           949: "full" macros into Emacs for your use.
        !           950: .VL 10
        !           951: .LI "^X^I"
        !           952: Re-direct input.  This command directs EMACS to take input from a
        !           953: file.  The file is assumed to contain EMACS commands, and can be
        !           954: created by editing with EMACS, using ^Q to enter control and escape
        !           955: characters.  You can also create an input file by using the commands to
        !           956: create keyboard macros described below, and then saving the
        !           957: resulting keyboard macro file.
        !           958: .P
        !           959: This command can be used to perform a series of
        !           960: commands on the current  buffer, or to set up a standard set of
        !           961: initializations.  Thus the file should contain \fIexactly\fP what
        !           962: you would type from the keyboard to perform whatever task you wish
        !           963: to perform.   Note that if the file contains only printable ASCII text,
        !           964: tabs, and newlines, ^X^I will effectively read the file into the
        !           965: buffer at the  current location.  Note, however, that this is very
        !           966: slow, and much better done with ^X^R.
        !           967: .P
        !           968: A file suitable for executing with ^X^I is known as a keyboard
        !           969: macro, because it is interpreted just as if it had been typed from
        !           970: the keyboard.  The following commands provide a sensible way to
        !           971: create and execute keyboard macros.
        !           972: .LI "^X(
        !           973: Begin Keyboard Macro.
        !           974: This command starts remembering the keystrokes you enter so that
        !           975: they can later be executed as a keyboard macro.
        !           976: .LI "^X)
        !           977: End Keyboard Macro.
        !           978: This command stops remembering keystrokes for a keyboard macro.
        !           979: .LI "^XE
        !           980: Execute Keyboard Macro.
        !           981: This command retrieves and executes the keystrokes typed between
        !           982: ^X( and ^X).  Emacs executes them just like they came from your
        !           983: terminal.  Keyboard macros are saved in the file .emacs_kbd in your
        !           984: home directory.  These are saved between sessions, so that ^XE is
        !           985: in fact the same as invoking ^X^I (Input file) and giving
        !           986: $HOME/.emacs_kbd as the file name to execute.  Note again that you
        !           987: can use ^X( and ^X) to create a keyboard macro, save it for
        !           988: later use by moving the file $HOME/.emacs_kbd to another file, and
        !           989: then invoke it by invoking ^X^I with the name of the file you saved.
        !           990: .LI "^Xd"
        !           991: Define macros.
        !           992: This command treats the current buffer as definitions of new macro
        !           993: commands.  The commands are defined and become available for use. 
        !           994: For a complete description, consult the macro programming manual. 
        !           995: Note that you should not use ^Xd with the file created from a
        !           996: keyboard macro.  The format of "full" macros is different.  Macros
        !           997: are explained in a separate manual.
        !           998: .LI "^X^L"
        !           999: .tr ~~
        !          1000: Load macros.
        !          1001: This command allows you to load "full" macro definitions from a
        !          1002: file.  It is described in the macro programming manual, however even if
        !          1003: you do not program your own macros, you may be interested in using
        !          1004: those defined by others and will use ^X^L to load the resulting
        !          1005: files.  On most systems on which emacs is installed, there is a library
        !          1006: directory of macros available for general use in ~EMACS/macros, and
        !          1007: the file ~EMACS/macros/CATALOG gives a catalog to the available
        !          1008: macros.
        !          1009: .tr ~ 
        !          1010: .LI "^Z"
        !          1011: Exit level.
        !          1012: In an emacs editing session, you may wind up in a nested level of
        !          1013: emacs.  This can happen either by typing "break", and responding "y"
        !          1014: to suspend whatever you were doing and invoke a new command
        !          1015: interpreter, or by invoking a macro that uses the recursive edit
        !          1016: command to allow you to edit something from inside of a macro.  ^Z
        !          1017: exits your current level of emacs, returning to whatever called it.
        !          1018: .P
        !          1019: The ^Z command performs a function similar to ^X^C, and in fact if
        !          1020: you have not invoked a macro that uses the "recursive edit" command,
        !          1021: and have not hit break, both will cause you to exit from emacs.
        !          1022: .LE
        !          1023: .H 2 "Commands that escape to Unix"
        !          1024: There are several commands that interact with unix, allowing you to
        !          1025: run unix commands or send mail from inside of emacs.
        !          1026: .VL 10
        !          1027: .LI "M-!,M-$"
        !          1028: Unix escape.  These two commands implement five different ways to run
        !          1029: unix commands from emacs.  In all cases, the commands prompt for the
        !          1030: name of a unix command to be run and run it.  The command is run
        !          1031: through your normal shell as indicated by $SHELL.  If you enter the
        !          1032: special command name "sh", it runs your normal shell instead of
        !          1033: "sh".  To facilitate writing programs that interact with emacs, the
        !          1034: environment variable "filename" is set to the name of the current
        !          1035: file in emacs when the command is run. The following summarizes the
        !          1036: various flavors:
        !          1037: .VL 8
        !          1038: .LI "M-!"
        !          1039: Run the command, suspending emacs while it runs.
        !          1040: .LI "^UM-!"
        !          1041: Run the command and feed it the contents of your current buffer as
        !          1042: standard input.  When the buffer is exhausted, the command will see
        !          1043: an end of file.
        !          1044: .LI "M-$"
        !          1045: Run the command with standard input from your terminal but standard
        !          1046: output and standard error are captured in the buffer ".exec", which
        !          1047: is created if it doesn't already exist.  (If it does exist, the
        !          1048: command output replaces its current contents).  Normally, output
        !          1049: from the command is also displayed on the terminal as it is
        !          1050: produced, but this can be overridden via the usilent or noecho modes
        !          1051: described in the section on modes. 
        !          1052: This is useful for saving a copy of the error messages produced by a
        !          1053: C compilation of a file being edited, for example.  The file name of
        !          1054: the .exec buffer is set to the command line that produced it.  This
        !          1055: can be useful if you want to re-execute the same command, as you can
        !          1056: make .exec your current buffer, enter M-$, and enter ^Y followed by
        !          1057: newline as the command line.  ^Y gets the old command line back, and
        !          1058: newline will execute it.
        !          1059: .LI "^UM-$"
        !          1060: Run the command and append the output to the buffer ".exec".  This
        !          1061: is just like the above except that the .exec buffer is not cleared
        !          1062: and the output from the command is appended to it.  It also inserts
        !          1063: the command line into the .exec buffer when the command is run.
        !          1064: .LI "M-0M-$"
        !          1065: Start the command as a sub-process in the current buffer.  The
        !          1066: command is run with input and output connected to pipes maintained
        !          1067: by emacs.  Control returns to emacs immediately while the command
        !          1068: runs asynchronously.  Output produced by the command is
        !          1069: asynchronously appended to the buffer as it is produced, and the
        !          1070: mark is set to the end of the output produced by the command.  Input
        !          1071: can be sent to the command in one of two ways:  First, whenever you
        !          1072: enter a newline in this buffer and the mark is on the current line,
        !          1073: emacs will send the text between the mark and your newline to the
        !          1074: sub-process.  This means that if you run a shell in a buffer, you
        !          1075: can interact with it by typing in the buffer just as if it were
        !          1076: running independent of emacs.  When it prints its prompt, the mark
        !          1077: is set to the end of the prompt, and when you hit return, the
        !          1078: current line after the prompt is sent to the shell.  The second way
        !          1079: to send input to the buffer is to use the ^X^T command described
        !          1080: in the next section.  This sends the current region to a buffer.  If that buffer
        !          1081: has a sub-process, the region is sent to the end of the buffer and
        !          1082: also to the sub-process as well.  One use of this feature is to
        !          1083: provide a rapid way to send new function and data declarations to an
        !          1084: interpreted language like LISP.
        !          1085: .P
        !          1086: This feature is new as of emacs 4.9 and has some limitations you
        !          1087: should be aware of.  First, you can have only one sub-process
        !          1088: running at a time.  Running a second one will kill the first one. 
        !          1089: Killing the buffer will also kill the sub-process.  (Note that it
        !          1090: may not kill all of the descendants of the sub-process.)  On
        !          1091: Berkeley unix systems (4.2BSD), this feature is reasonably
        !          1092: inexpensive to use and the response from the command will be quick. 
        !          1093: On System V Unix, there may be some delay between the time at which
        !          1094: output is produced and the time at which it is seen.  Emacs will
        !          1095: always look for output from the process before looking for
        !          1096: characters typed by you at the terminal, however if you are not
        !          1097: typing, it may take some time for emacs to notice command output. 
        !          1098: (On some unix/370 and amdahl unix systems command output is not
        !          1099: noticed until you type at emacs due to a bug in the I/O software on
        !          1100: these systems).  Some commands may not run properly as
        !          1101: sub-processes, depending on what version of the standard I/O
        !          1102: software they were compiled with.  Most interactive programs will,
        !          1103: however, function properly in this mode.  Because of the different
        !          1104: nature of the implementation, this feature may also cause emacs to
        !          1105: consume more CPU time while a sub-process is running.
        !          1106: .LE
        !          1107: .LI "^X^G"
        !          1108: Interrupt sub-process.  If the current buffer has a sub-process running,
        !          1109: this command sends an interrupt signal (SIGINT) to that process,
        !          1110: just as if you had typed your normal interrupt character from the
        !          1111: terminal.  If you give this command an argument, it sends the signal
        !          1112: number corresponding to that argument.  (For example, M-9^X^G would
        !          1113: send a kill signal to the sub-process.)
        !          1114: .LI "M-^M"
        !          1115: Mail.  This command takes the current buffer as unix mail, and sends
        !          1116: it.  The buffer must contain at least one line starting To: , which
        !          1117: specifies the recipients of the mail.  Each recipient is delimited by a
        !          1118: space.  Any number of recipients may be listed in a single line,
        !          1119: however to improve readability, additional To: or Cc: lines may be
        !          1120: used in specifying lists of recipients.
        !          1121: Any errors encountered by mail are printed.  If the environment
        !          1122: variable $MAILER is set, then it is taken as the name of the command
        !          1123: to run to send the mail.  Otherwise, emacs runs "mail".
        !          1124: .LE
        !          1125: .H 2 "Miscellaneous commands"
        !          1126: The remaining commands handle special situations that occur once in
        !          1127: a while.
        !          1128: .VL 10
        !          1129: .LI "^X^T"
        !          1130: Send text to another buffer.
        !          1131: This command sends the text between the mark and the current cursor
        !          1132: position in the current buffer to another buffer.  EMACS prompts for
        !          1133: the name of the other buffer, and the text is inserted into that
        !          1134: buffer at the current cursor position for that buffer.  The current
        !          1135: buffer remains unchanged.  If an argument is given, it selects the
        !          1136: mark to use.  If the target buffer has a sub-process running under
        !          1137: it, then the region is also sent to that process  and is always put
        !          1138: at the end of the buffer. (See the description of M-$ for more
        !          1139: information.)
        !          1140: .LI "M-s"
        !          1141: Statistics
        !          1142: This command displays some statistics about your editing session,
        !          1143: such as how may characters emacs has sent to you and how many
        !          1144: characters you have typed.  The information is normally not of much
        !          1145: interest.
        !          1146: .LI "^X="
        !          1147: Status.  Displays status information (current line, number of lines
        !          1148: in buffer, current character position, number of characters in
        !          1149: buffer, etc.).                                                      
        !          1150: .LI M-/
        !          1151: Begin comment.  This command begins a C program comment by moving to
        !          1152: the appropriate column and putting a /* in the buffer.  The next
        !          1153: newline will close the comment and automatically append a */
        !          1154: .LI "M-_"
        !          1155: Underline word.  This command underlines the following word of text.
        !          1156: Useful for generating underlined text for mm.
        !          1157: .LI "^C"
        !          1158: Capitalize.
        !          1159: This command capitalizes the letter under the cursor and moves the
        !          1160: cursor forward one position.  Lower case alphabetic characters are
        !          1161: converted to upper case, while other letters are unchanged.
        !          1162: .LI "M-c"
        !          1163: Capitalize word.  The letter under the cursor is capitalized, and
        !          1164: the cursor is moved to the beginning of the next word.
        !          1165: .LI "M-l (4.6)
        !          1166: Lower case letter.  The letter under the cursor is capitalized and
        !          1167: the cursor is moved to the right.
        !          1168: .tr ~~
        !          1169: .LI "M-~"
        !          1170: Unmodify Buffer.  This command causes a buffer to be marked as
        !          1171: unmodified even if it has been modified since the last write.  Doing
        !          1172: this will avoid having EMACS ask whether or not to write the buffer
        !          1173: when you exit if you know that you do not want to rewrite the
        !          1174: buffer.  With an argument greater than 1 (i.e. ^UM-~) this command
        !          1175: marks the buffer as modified.  With an argument of zero or a
        !          1176: negative argument, it does not change the state of the buffer but
        !          1177: returns the buffer modified flag as its result.
        !          1178: .tr ~ 
        !          1179: .LI "M-t"
        !          1180: Set terminal type.  Prompts for terminal type and sets the character 
        !          1181: sequences used to display text to be appropriate for that terminal.  
        !          1182: Most common terminal types are supported.
        !          1183: Emacs uses terminal commands for relative and absolute
        !          1184: cursor position, clear screen, clear from the cursor to the end of
        !          1185: line, insert and delete lines, and insert and delete characters. 
        !          1186: The number of characters transmitted for re-display will depend on
        !          1187: which of these functions are available.  Thus EMACS transmits fewer
        !          1188: characters on an adm31, which has all of these functions, than with
        !          1189: an adm3a, which has only cursor positioning and clear screen.  Most
        !          1190: terminals fall between these extremes.
        !          1191: .LI "M-^L"
        !          1192: Redisplay top.  Redisplay the window with the current line at the top. 
        !          1193: This is useful for viewing the lines that follow the current line. 
        !          1194: Note that this does not re-create the entire display, as does ^L, so
        !          1195: it will not correct garbling.
        !          1196: .LI M-"
        !          1197: Auto Fill Buffer.  This command re-adjusts the lines in the buffer
        !          1198: so that each line contains 72 or fewer characters.  The adjustment
        !          1199: is done like nroff (mm) by moving words from one line to another. 
        !          1200: nroff or mm command lines and blank lines are preserved as is.  This
        !          1201: command can be used to improve the way in which an nroff or mm
        !          1202: source file displays, by getting rid of long lines, without
        !          1203: affecting the output.
        !          1204: .LI "M-:"
        !          1205: Remap character (version 4.9). The command M-: allows you to re-map
        !          1206: character commands. 
        !          1207: It prompts for a character (or a meta or ^X sequence) and a command 
        !          1208: (also a character sequence) to put on that character.  This allows you to
        !          1209: re-configure EMACS to your liking.  You can re-map any character you
        !          1210: like, including characters like ^X, escape, and ^U.  Note that the
        !          1211: command string is always interpreted with the default bindings (as
        !          1212: documented in this memo), and not with the bindings set up with
        !          1213: earlier M-: commands.  Thus M-:^A^B followed by M-:^B^A will swap
        !          1214: the ^A and ^B commands, since the command ^A in the second M-:
        !          1215: command refers to the default meaning of ^A, not that established by
        !          1216: the first M-: command.  M-: also changes the behavior of the
        !          1217: control characters used to edit filenames and other string
        !          1218: parameters, but does not change the behavior of some of the
        !          1219: characters that have special meaning in response to prompts issued
        !          1220: by various commands, such as the responses to query replace.
        !          1221: .P
        !          1222: With an argument of 2 or 4 (^UM-:), this command asks for a
        !          1223: character and a macro name to assign to that character.  This allows
        !          1224: you to bind macro commands to characters by their names instead of
        !          1225: their current character binding.
        !          1226: .P
        !          1227: With an argument of 0 (M-0M-:), this command resets all of the
        !          1228: keyboard character bindings to their default values.  This may be
        !          1229: useful in recovering from trouble.
        !          1230: .P
        !          1231: In all cases, the bindings established with this command and through
        !          1232: defining macros apply to both character commands typed from the
        !          1233: keyboard and to characters in keyboard macros and initialization
        !          1234: files.  They do not apply to the character commands executed in the
        !          1235: body of "full" macros.  See the section on macros and the
        !          1236: macro command manual for further information on bindings.
        !          1237: .LI "^X^M"
        !          1238: Set Mode.  This command can be used to set parameters to customize
        !          1239: the behavior of emacs.  For more information on modes, see the next
        !          1240: section.
        !          1241: .LE
        !          1242: .H 1 "Modes"
        !          1243: EMACS has a variety of parameters that can be
        !          1244: changed from commands entered in the terminal.
        !          1245: These are referred to as "modes" in this document and in the
        !          1246: messages printed by emacs.  
        !          1247: There are two types of modes:  on/off
        !          1248: modes and  integer modes.  The '^X^M' command can
        !          1249: be used to display or set these parameters.  '^X^M' will prompt for
        !          1250: the name of the mode to set.  If you enter a return in response to
        !          1251: the prompt, the current mode settings are displayed.  Normally,
        !          1252: emacs will display the value of each integer mode, and the name of
        !          1253: each on/off mode that is currently on.  If you enter return in
        !          1254: response to '^U^X^M', emacs will also display the names of the
        !          1255: on/off that are currently off, indicating for each mode whether it
        !          1256: is on or off.
        !          1257: .P
        !          1258: Modes are set by giving the name of the mode to set in response to '^X^M'.  
        !          1259: If an on/off mode is given, it is turned on if no argument
        !          1260: is given to '^X^M', and turns it off if an argument is specified. 
        !          1261: (Thus '^X^M' turns on, '^U^X^M' turns off).  For an integer mode, the
        !          1262: mode is set to the value of the argument.
        !          1263: .P
        !          1264: The modes and their types are listed in the following sections,  along
        !          1265: with their default values.  For ON/OFF modes, the default is \fBhighlighted\fP.
        !          1266: The modes are grouped into 4 broad categories:
        !          1267: .BL
        !          1268: .LI
        !          1269: Display modes change the information in the buffer is displayed, but
        !          1270: have no effect on it's content.
        !          1271: .LI
        !          1272: Interface modes change the command interface to emacs in minor ways,
        !          1273: but don't really change any of the behavior of the commands.
        !          1274: .LI
        !          1275: Command modes change the way in which some of the commands work.
        !          1276: .LI
        !          1277: Terminal modes change the way that emacs uses the terminal, and
        !          1278: exist mainly to get around special problems caused by certain kinds
        !          1279: of terminals.
        !          1280: .LE
        !          1281: .H 2 "Display modes"
        !          1282: .VL 15
        !          1283: .LI "lnumb"
        !          1284: Line Number Mode (\fBON\fP/OFF)
        !          1285: .br
        !          1286: This mode causes the current line number
        !          1287: to display at the left of each line.
        !          1288: .LI "lnowid"
        !          1289: line number width (INTEGER=4)
        !          1290: .br
        !          1291: This parameter specifies how many character positions are reserved
        !          1292: for the line number when in line number mode
        !          1293: .LI "height"
        !          1294: Display height (INTEGER=<screen_size-4>)
        !          1295: .br
        !          1296: This parameter dictates how many lines from the buffer will be
        !          1297: displayed on the screen.  It is automatically set based on the
        !          1298: terminal type whenever the terminal type is set, and is changed by
        !          1299: the one and two window commands.  This mode and width mode can be
        !          1300: set explicitly to restrict the display to a subset of the entire
        !          1301: terminal screen, or can be used to allow you to use a terminal with
        !          1302: a settable screen size for which emacs does not have the right size
        !          1303: built in.
        !          1304: .LI "width"
        !          1305: Screen Width (INTEGER = <set based on terminal type>)
        !          1306: .br
        !          1307: This mode specifies the width of the display screen.
        !          1308: .LI "tabstop"
        !          1309: Tabstop (INTEGER=8)
        !          1310: .br
        !          1311: This mode is the number of characters per tab that are displayed. 
        !          1312: Displaying a deeply indented c program may look much better if
        !          1313: tabstop is set to something smaller than the eight default.
        !          1314: .LI "backspace"
        !          1315: Backspace Mode (ON/\fBOFF\fP).
        !          1316: .br
        !          1317: Turning on backspace mode causes backspace
        !          1318: characters (^H) to display as moving back one column rather than as
        !          1319: a ^H.  This is very useful for viewing nroff output or manual pages,
        !          1320: but editing the resulting text can be a bit tricky, because it is
        !          1321: impossible to tell whether the character under the cursor is the one
        !          1322: being displayed, one that has been overprinted, or a backspace.
        !          1323: .LI "time"
        !          1324: Time mode (ON/\fBOFF\fP)
        !          1325: .br
        !          1326: When time mode is  on, EMACS will display the
        !          1327: time of day below the mode line (the one that says EMACS and the
        !          1328: buffer name).  The time is updated every time a character is read. 
        !          1329: Using time mode when entering lots of text is expensive.
        !          1330: .LI "display percent (4.5)"
        !          1331: Display cursor as percent of buffer (ON/\fBOFF\fP)
        !          1332: .br
        !          1333: If set, emacs will display the percentage of the current buffer
        !          1334: beyond the current cursor position on th mode line
        !          1335: .LI "7bit_ascii (4.8)"
        !          1336: Display only 7 bit characters (ON/\fBOFF\fP)
        !          1337: This mode controls how characters with the high order bit set are
        !          1338: displayed.  With this mode off, they are displayed as "M-" followed
        !          1339: by the character.  With this mode ON, they are displayed as
        !          1340: highlighted (underlined) characters.  This mode is most useful for
        !          1341: editing files used with Personal Computer word processing systems
        !          1342: which use the high order bit for formatting control.
        !          1343: .LI "leftmargin" (4.9)"
        !          1344: Left most displayed Column (INT=0).
        !          1345: In picture mode (See Section 5.3), emacs automatically scrolls the
        !          1346: window left or right to keep the cursor on the screen.  This mode
        !          1347: allows you to examine or alter this behavior.  The value of
        !          1348: leftmargin is the left
        !          1349: most displayed column.  Setting it will cause the screen to scroll
        !          1350: left or right.  In all cases, if the cursor wanders out of the
        !          1351: window, emacs will pick it's own leftmargin to keep it on the
        !          1352: screen.
        !          1353: .LE
        !          1354: .H 2 "Interface modes"
        !          1355: .VL 15
        !          1356: .LI "save"
        !          1357: Auto Save Mode (ON/\fBOFF\fP)
        !          1358: .br
        !          1359: If auto save mode is on, EMACS will
        !          1360: automatically write the current buffer after savetype characters
        !          1361: have been entered since the last save.  This mode reduces the chance
        !          1362: of disaster in the event of a crash, but can be annoying by causing
        !          1363: a lot of writing.  
        !          1364: .LI "savetype"
        !          1365: Save type ahead (INTEGER=256)
        !          1366: .br
        !          1367: If auto save mode is on, this is the
        !          1368: number of keystrokes between saves.
        !          1369: .LI "verbose"
        !          1370: Verbose mode (\fBON\fP/OFF)
        !          1371: .br
        !          1372: When verbose mode is on, EMACS will prompt
        !          1373: for more input when ^X, ^Q, escape, or ^U are entered.  This makes
        !          1374: it easier to keep track of where you are.
        !          1375: .LI "keepscroll"
        !          1376: scroll keep lines (INTEGER=0)
        !          1377: .br
        !          1378: This parameter specifies how many lines are to be preserved on the
        !          1379: screen when forward page or backward page is invoked.
        !          1380: .LI "caseless"
        !          1381: ignore case in searches 
        !          1382: .br
        !          1383: This mode causes case lower case characters in the search string to
        !          1384: match either case in the buffer on all searches and query replace.
        !          1385: .LI "mailtype"
        !          1386: check mail interval (INT=100)
        !          1387: .br
        !          1388: This parameter determines the number of input characters between
        !          1389: checks of your mailbox ($MAIL).  When emacs discovers something in
        !          1390: your mailbox, a warning is displayed at the bottom of the screen.
        !          1391: .LI "end_newline"
        !          1392: Behavior of ^N at end of buffer (ON/\fBOFF\fP)
        !          1393: .br
        !          1394: This parameter determines whether executing the ^N command in the
        !          1395: last line of the buffer adds a new line to the buffer (mode ON) or
        !          1396: whether it signals an error (mode OFF).
        !          1397: .LI "usilent"
        !          1398: Silent UNIX commands (ON/\fBOFF\fP)
        !          1399: .br
        !          1400: If set, this parameter causes emacs not to display the command name
        !          1401: or output for M-$.  This is useful for invoking a unix command in a
        !          1402: macro and capturing the output without disturbing the display.
        !          1403: .LI "noecho"
        !          1404: Don't echo M-$ output (ON/\fBOFF\fP)
        !          1405: .br
        !          1406: If set, emacs will not echo the output of commands run with M-$ to
        !          1407: the terminal.  The difference between noecho and usilent is that
        !          1408: usilent isolates commands run from emacs from the terminal
        !          1409: completely, so that emacs does not clear the screen and does not
        !          1410: have to redraw it when the command exits.  noecho has no effect at
        !          1411: all on commands run via M-!, but does eliminate the display of
        !          1412: output from M-$.  It is most useful when you wish to run something
        !          1413: that will produce lots of output, capturing the output in .exec.
        !          1414: .LI "eofnl (4.6)"
        !          1415: Write newline at end of file. (\fBON\fP/OFF)
        !          1416: .br
        !          1417: This mode when on causes emacs to append a newline character to any
        !          1418: file written by emacs from a buffer that does not end in a newline. 
        !          1419: Emacs allows you to create files that do not end in newline. 
        !          1420: Unfortunately, many unix tools get confused when reading such a
        !          1421: file.  This mode is on by default, and prevents you from writing a
        !          1422: file that will cause troubles.  For editing files which you do not
        !          1423: want to end in a newline, turn this mode off.
        !          1424: .LI "savelink (4.6)"
        !          1425: Preserve links on write (ON/\fBOFF\fP)
        !          1426: .br
        !          1427: Turning this mode on will cause emacs to automatically
        !          1428: write into the existing file when writing to a file with multiple
        !          1429: links, instead of asking the user what to do in this situation.
        !          1430: .LI "search_newline (4.6)"
        !          1431: Newline ends search (ON/\fBOFF\fP)
        !          1432: .br
        !          1433: Turning this mode on causes incremental search to stop if a newline
        !          1434: or carriage return is typed from the terminal.
        !          1435: .LI "autoload (4.7)"
        !          1436: Automatic macro loading (\fBON\fP/OFF)
        !          1437: .br
        !          1438: This mode controls the automatic loading of macro packages when an
        !          1439: undefined macro is called.  If autoload mode is on and an undefined
        !          1440: macro by the name of <name> is called, emacs will first
        !          1441: attempt to load
        !          1442: .tr ~~
        !          1443: $EMACS_LIB/<name> (resolving the environment variable $EMACS_LIB),
        !          1444: and then try to load ~EMACS/macros/<name>.  If either of these
        !          1445: files exists and defines a macro called <name>, that macro will be
        !          1446: called and execution will continue.  Otherwise, an error message is
        !          1447: produced.  This allows macros to be
        !          1448: loaded incrementally, only when needed.  With the mode off, any
        !          1449: attempt to call an undefined macro results in an error.
        !          1450: .tr ~ 
        !          1451: .LE
        !          1452: .H 2 "Command modes"
        !          1453: .VL 15
        !          1454: .LI "fill"
        !          1455: Auto Fill Mode (\fBON\fP/OFF)
        !          1456: .br
        !          1457: If this mode is on, emacs will
        !          1458: automatically move to the next line whenever the cursor moves to the
        !          1459: end of the line, breaking the line at a word boundary.  This is very
        !          1460: useful for entering text, as no newlines need be entered in the
        !          1461: middle of the text.
        !          1462: .LI "fillcol"
        !          1463: Auto Fill Column (INTEGER=72)
        !          1464: .br
        !          1465: This is the character position beyond which auto fill mode will
        !          1466: cause the line to be broken.
        !          1467: .LI "c"
        !          1468: C Mode (ON/\fBOFF\fP)
        !          1469: .br
        !          1470: This mode automatically indents for a C source
        !          1471: file.  Each line is indented with the number of tabs in the last 
        !          1472: non-comment line plus the net excess { characters over } characters
        !          1473: in the last line.  This mode is particularly useful for entering
        !          1474: c program text.
        !          1475: .P
        !          1476: This mode also changes the behavior of the '}' character, so that
        !          1477: when you type a '}' as the first non-blank character on a line, it
        !          1478: will adjust the indentation automatically to one less than it was. 
        !          1479: Thus you can type the following kind of statement and get it to
        !          1480: indent properly.
        !          1481: .DS
        !          1482: 
        !          1483: if(test) {
        !          1484:         statement;
        !          1485: }
        !          1486: 
        !          1487: .DE
        !          1488: .LI "comcol"
        !          1489: Comment Column (INTEGER=40)
        !          1490: .br
        !          1491: This is the column in which comments
        !          1492: entered via M-/ begin.
        !          1493: .LI rigid_newline
        !          1494: rigidly insert newlines (ON/\fBOFF\fP)
        !          1495: .br
        !          1496: This mode causes any newline to insert a newline into the file. 
        !          1497: With this mode off (the default).  a newline will not insert
        !          1498: anything if the following line is empty, but will simply move to the
        !          1499: next line.
        !          1500: .LI "readonly"
        !          1501: Read only buffer (ON/\fBOFF\fP)
        !          1502: .br
        !          1503: If this mode is turned on, saving the current buffer is disabled. 
        !          1504: ^X^S will complain with an error message, autosaving will not take
        !          1505: place, and emacs will not complain if you try to exit without
        !          1506: writing buffers.
        !          1507: .LI "picture (4.5)"
        !          1508: Tailor editing for two dimensional displays (ON/\fBOFF\fP)
        !          1509: .br
        !          1510: If set, emacs treats the buffer as an "electronic blackboard",
        !          1511: rather than the exact contents of a unix file.  The display shows a
        !          1512: rectangular region of the blackboard through a window.  Characters
        !          1513: beyond the right margin are not displayed, but are indicated by
        !          1514: a '!' in the right margin.  The window is moved left or right to
        !          1515: keep the cursor in the window.  "leftmargin" mode gives you some
        !          1516: explicit control over the window, but in general it is self
        !          1517: adjusting.  If the window is not at the left
        !          1518: edge of the blackboard, then the character offset of the left edge
        !          1519: of the display is given on the mode line, in front of the editor
        !          1520: name.
        !          1521: .P
        !          1522: Picture mode changes the behavior of several basic commands to be
        !          1523: more suitable for two dimensional editing.
        !          1524: .VL 10
        !          1525: .LI "^N/^P"
        !          1526: These move to the same column in the target line, extending the
        !          1527: target line with spaces if necessary.
        !          1528: .LI "^F/^B"
        !          1529: These will not move off the current line.  ^B will stick at the left
        !          1530: margin, while ^F will continue to extend the line to move to the
        !          1531: request column.
        !          1532: .LI "^W/^Y"
        !          1533: These treat the region to be deleted as a rectangle, bounded by the
        !          1534: mark and the cursor position at the corners.  All text in the
        !          1535: rectangle defined by these positions is killed by ^W.  ^Y brings
        !          1536: text back in the same way.  All text deleting commands behave like
        !          1537: ^W, in that the start and end positions of the text region to be
        !          1538: deleted are taken as corners of a rectangle.  When the text region
        !          1539: being deleted is all on one line, behavior is identical to normal
        !          1540: emacs, however deletion across line boundaries via commands like
        !          1541: M-d may not do anything sensible.
        !          1542: .LE
        !          1543: .P
        !          1544: Picture mode is probably most useful with nodelete mode, notabs
        !          1545: mode, and overwrite mode all set.  You can use picture mode without
        !          1546: the others set, but the presence of tabs or control characters in
        !          1547: the buffer may give unexpected results when you navigate in the
        !          1548: file.  This mode is particularly useful for editing fixed format
        !          1549: tables, picture images of "typewriter art" for use with the "gc"
        !          1550: graphics output package, and other two dimensional information.
        !          1551: .LI "overwrite"
        !          1552: Overwrite mode (ON/\fBOFF\fP)
        !          1553: .br
        !          1554: In overwrite mode, text entered will
        !          1555: overwrite text already there.  Text entered when the cursor is at
        !          1556: the end of a line will be inserted as before.  Overwrite mode may be
        !          1557: more natural for some people when making corrections.
        !          1558: .LI "nodelete"
        !          1559: No deletion (ON/\fBOFF\fP)
        !          1560: .br
        !          1561: With this mode set, text deleted in the file is not closed up but
        !          1562: instead is overwritten with spaces.  After any deletion, the cursor
        !          1563: reverts to the first character of the region deleted.  "nodelete"
        !          1564: mode should probably be part of overwrite mode, however overwrite
        !          1565: mode considerably pre-dated it and was left alone for upward
        !          1566: compatibility.
        !          1567: .LI "notabs"
        !          1568: Eliminate tabs (ON/\fBOFF\fP)
        !          1569: .br
        !          1570: With this mode set, emacs does not display tab characters in the
        !          1571: buffer as whitespace, but instead shows them as ^I (control-i),
        !          1572: which is the ASCII code for a tab.  When you enter a tab by typing
        !          1573: ^I or tab, emacs converts it to the proper number of spaces to come
        !          1574: up to the next tabstop column.  Emacs does not convert tabs already
        !          1575: in the file, though there are macros that do this.
        !          1576: .P
        !          1577: The main use of this mode is in creating and editing fixed format
        !          1578: information in picture mode, though it can also be useful in
        !          1579: showing you where tabs are in your buffer.
        !          1580: .LE
        !          1581: .H 2 "Terminal modes"
        !          1582: .VL 15
        !          1583: .LI "nobell"
        !          1584: No Bell (ON/\fBOFF\fP)
        !          1585: .br
        !          1586: Ordinarily, unexpected conditions, such as errors or quitting out
        !          1587: of commands, cause the terminal bell to ring.  On some adm3a
        !          1588: terminals, This causes some kind of disaster to occur.  Turning on
        !          1589: nobell mode prevents EMACS from ringing the terminal bell.
        !          1590: .LI "tspeed"
        !          1591: Terminal Speed (INT=<terminal dependent>)
        !          1592: .br
        !          1593: This parameter is the speed of your terminal in milliseconds per
        !          1594: character.  This parameter is set whenever you enter emacs and is
        !          1595: used in determining how to update the display most efficiently. 
        !          1596: .LI "controlify"
        !          1597: Controlify mode (ON/\fBOFF\fP)
        !          1598: .br
        !          1599: When on, this mode causes a particular character (normally ^^, but
        !          1600: settable to another character with the ctl_char described below), to
        !          1601: act as a prefix specifying that the next character is to be
        !          1602: interpreted as a control character.  This mapping takes place at any
        !          1603: time, not just when entering commands.  Thus the sequence ^X^^s will
        !          1604: be mapped into ^X^S, and cause the save command to be invoked.  The
        !          1605: sequence ^^q^^m typed in response to a request for a file name will
        !          1606: be mapped into ^Q^M, which will be interpreted as asking for a file
        !          1607: name of ^M.  Controlify mode is primarily intended to allow you to
        !          1608: enter characters which cannot be sent transparently from your
        !          1609: terminal to emacs.  The most frequent examples are ^S and ^Q, which
        !          1610: cannot be sent by some terminals and some local area networks. 
        !          1611: By setting controlify mode, you can send these characters with ^^s
        !          1612: and ^^q.
        !          1613: .LI "ctl_char (4.6)"
        !          1614: Controlify Character (INT=30)
        !          1615: .br
        !          1616: This parameter sets the value of the character used when in controlify
        !          1617: mode to indicate that the next keystroke should be interpreted as a
        !          1618: control character.  It is the ascii value of the character to be
        !          1619: used.
        !          1620: .LI "flow_lim (4.6)"
        !          1621: Flow Control Limit (INT=0)
        !          1622: .br
        !          1623: This parameter enables the use of xon/xoff flow control during
        !          1624: output to control the rate of output to the terminal.  Emacs
        !          1625: normally turns xon/xoff flow control off to allow ^S and ^Q to be
        !          1626: passed to emacs to be used in specifying commands.  If flow_lim is
        !          1627: non-zero, then whenever more than flow_lim characters are sent to
        !          1628: the terminal at once, xon/xoff flow control will be temporarily
        !          1629: enabled to allow the terminal to send ^S to request that unix stop
        !          1630: output.  xon/xoff flow control is disabled when output is complete. 
        !          1631: The only effect you will see is that you cannot type ^S or ^Q ahead
        !          1632: while emacs is updating the screen.  Normally, emacs supplies
        !          1633: sufficient padding to allow it to run without xon/xoff flow control,
        !          1634: however for some terminals at high speeds xon/xoff flow control is
        !          1635: required.  In this case only, set flow_lim to a number somewhat
        !          1636: larger than the terminal's character buffer (typically 32, 64, or
        !          1637: 128).  In some cases it may be desirable to set up the terminal to
        !          1638: always use ^S/^Q for flow control.  This can be done by setting
        !          1639: flow_lim to  -1  (escape - ^X^M flowlim).  If you do this, you will
        !          1640: not be able to type ^S or ^Q from the keyboard and must use
        !          1641: controlify mode to do so.
        !          1642: .LE
        !          1643: .H 2 "Specifying Default modes for a File"
        !          1644: You can specify the modes to be used while editing a particular file
        !          1645: by putting the string "EMACS_MODES: " somewhere in the first 10
        !          1646: lines of the file.  The text on the same line following EMACS_MODES:
        !          1647: will be taken as names of modes to set on or off.  A mode name
        !          1648: preceded by '!' will be set off, while mode names just listed will
        !          1649: be set on.  If '=' immediately follows a mode name, then the
        !          1650: characters immediately following the '=' will be taken as the value
        !          1651: for the mode name.  Any text on the line that does not correspond to a mode
        !          1652: name will be ignored.  Thus the line:
        !          1653: .SP
        !          1654: /* EMACS_MODES: !fill c, comcol=43 */
        !          1655: .SP
        !          1656: in a c source file will set c mode on, fill mode off, and set the
        !          1657: column for starting comments to 43.  These modes are
        !          1658: set whenever the file is read, and
        !          1659: whenever you switch buffers.
        !          1660: .H 1 "Getting started"
        !          1661: When EMACS is invoked, it does a number of things to set up for
        !          1662: your editing session,  These include finding out the type of your
        !          1663: terminal, processing an initialization file that allows you to
        !          1664: customize EMACS for your needs, and processing command line
        !          1665: arguments.
        !          1666: .H 2 "Setting your Terminal Type"
        !          1667: Emacs must know what type of terminal
        !          1668: terminal that you are using in order to know the appropriate
        !          1669: control commands to display text on your screen.
        !          1670: The terminal type is taken from the shell variable $TERM.  To make it
        !          1671: work, you must set the value of TERM in your .profile, and export it.
        !          1672: .P
        !          1673: On some systems, there is a utility program called "ttype" which
        !          1674: figures out your terminal type for you.  It works by sending an
        !          1675: escape sequence to your terminal and testing for a response.
        !          1676: Thus the lines:
        !          1677: .SP
        !          1678: export HOME PATH MAIL LOGNAME LOGTTY TERM
        !          1679: .br
        !          1680: TERM=`ttype`
        !          1681: .SP
        !          1682: will set the terminal type correctly if ttype is available, and if
        !          1683: your terminal responds correctly.  If TERM is not set or
        !          1684: is set to an unrecognizable type, EMACS will prompt for terminal
        !          1685: type, however the prompting message may be formated oddly, since
        !          1686: at this point emacs will not know how to control your terminal.
        !          1687: You can also set your terminal type by putting a M-t (Set terminal
        !          1688: type) command in your initialization file, as described in the
        !          1689: following section.
        !          1690: .P
        !          1691: Most terminals commonly used at Bell Labs are acceptable for use
        !          1692: with emacs.  Support for other terminals could easily be added if needed.
        !          1693: If you need support for an unsupported terminal, either consult the
        !          1694: document ~EMACS/term_support for a description of how to do it
        !          1695: yourself, or contact ihnss!warren for details.
        !          1696: .P
        !          1697: There are some special problems with certain terminals or
        !          1698: particular access arrangements connecting your terminal to emacs
        !          1699: that you may run into:
        !          1700: .VL 25 
        !          1701: .LI "adm3a:"
        !          1702: There are two "features" of the adm3a terminals that sometimes cause
        !          1703: trouble in EMACS.  One of the internal switches on that terminal is
        !          1704: labeled space/advance.  That switch must be in the space position for
        !          1705: EMACS to work properly.  A second problem is that many of these
        !          1706: terminals are set up to use one of the "undefined" pins of the
        !          1707: rs-232 interface for some internal diagnostic.  This causes the
        !          1708: terminal to go wild every time it receives a bell character when
        !          1709: connected to a 1200 baud modem (which uses the same pin for
        !          1710: something else).  If this happens to you in EMACS, set nobell mode,
        !          1711: which will prevent EMACS from sending bell characters to your
        !          1712: terminal.  A better and more permanent solution is to modify the
        !          1713: terminal to disconnect
        !          1714: this lead, use a cable that does not carry the undefined signals
        !          1715: between the modem and the terminal.
        !          1716: .LI "TTY5620 or Blit:"
        !          1717: The Blit or Teletype 5620 terminals can be used in a number of
        !          1718: different ways.  The terminal types "blit" and "5620" will work well
        !          1719: on a stand-alone blit or 5620.  The only difficulty is that the
        !          1720: terminal will not transmit ^S and ^Q, requiring you to use
        !          1721: controlify mode to send these characters (as described below). 
        !          1722: Emacs will also run in a layer defined on the terminal.  
        !          1723: Emacs should discover the size of the window automatically, but
        !          1724: will not discover it if you reshape the window while emacs is
        !          1725: running.  The terminal type "layer" will work with the layer terminal
        !          1726: driver on the blit, but is very crude and buggy.  The terminal type
        !          1727: 5620 will work from a layer inside of the TTY 5620, with the above
        !          1728: limitation.  The hp and vitty emulators will work with emacs on both
        !          1729: the blit and 5620.  
        !          1730: .P
        !          1731: There are several improved terminal emulators that work better with
        !          1732: emacs than the standard hp emulator or the straight 5620 layers
        !          1733: terminal.  There is an improved hp emulator that will transmit ^S
        !          1734: and ^Q.  The "netty" terminal emulator is widely available for both
        !          1735: the blit and the 5620.  It works well with emacs, and works with a
        !          1736: macro package that can be loaded into emacs to allow you to
        !          1737: position the cursor with the mouse and to do a certain amount of
        !          1738: cut and paste style editing.  The "emacsterm" emulator is available
        !          1739: for the 5620 in experimental tools, and also works with an emacs
        !          1740: macro package to provide mouse oriented editing.
        !          1741: .LI "VT100 or hp2621B:"
        !          1742: Both of these terminals work fine with emacs when run at low
        !          1743: speeds, but at 9600 baud, these terminals do not keep up with the
        !          1744: flow of characters.  To use either of these terminals at 9600 baud,
        !          1745: you should set  "flow_lim" mode to 32 in emacs, and avoid typing while the
        !          1746: display is being recreated.  In addition, some of the VT100
        !          1747: compatible terminals will not send ^S or ^Q to emacs and must be
        !          1748: used with controlify mode.
        !          1749: .LI "Local Area Networks:"
        !          1750: Some local area networks use ^S and ^Q for flow control, and thus
        !          1751: you will not be able to send these characters directly to emacs. 
        !          1752: You can get around this by using controlify mode as described in
        !          1753: the previous sections.  You can make this less awkward on terminals
        !          1754: with user programmable function keys by setting some of the
        !          1755: function keys to send the character sequences necessary to get ^S
        !          1756: and ^Q.
        !          1757: .LE
        !          1758: .H 2 "Initialization file.
        !          1759: When you start emacs, it consults
        !          1760: initialization file that allows you to initialize the various modes
        !          1761: the way that you want them.  This file is called ".emacs_init" and
        !          1762: should be put in your home directory.  The file is read as a
        !          1763: keyboard macro, and thus should contain \fIexactly\fP what you
        !          1764: would type from the terminal in order to set it up.  Thus the file:
        !          1765: .tr ~~
        !          1766: .SP
        !          1767: .DS
        !          1768: ^U^X^Mfill
        !          1769: ^X^Mc
        !          1770: ^X^L~EMACS/macros/loader
        !          1771: .DE
        !          1772: .SP
        !          1773: sets 'c' mode, unsets fill mode, and loads the loader macro
        !          1774: package.  If you do not have a .emacs_init file, emacs will run the
        !          1775: standard initialization file for your system, which you can examine
        !          1776: by looking at the file ~EMACS/.emacs_init.  It will not run both by
        !          1777: default, but you can call for the default initialization file to be
        !          1778: run from your private file by placing ^X^I~EMACS/.emacs_init in
        !          1779: your initialization file at the point at which you want the system
        !          1780: initialization to be done.
        !          1781: You can also cause initializations to take place by command line
        !          1782: arguments (see below).
        !          1783: .tr ~ 
        !          1784: .H 3 "Command line arguments"
        !          1785: Emacs accepts a number of arguments on the command line that effect
        !          1786: processing.  These are:
        !          1787: .VL 10
        !          1788: .LI "-i"
        !          1789: Emacs interprets the next argument as the name of an initialization file to
        !          1790: run in addition to the standard initialization file (Yours or the system's). 
        !          1791: The specified file is run \fIafter\fP .emacs_init.
        !          1792: .LI ".i"
        !          1793: Emacs interprets the next argument as the name of an initialization file to
        !          1794: run \fIinstead\fP of the standard file.
        !          1795: .LI "+n"
        !          1796: Emacs moves to line n of the specified file after it is read in.
        !          1797: .LI "<filename>
        !          1798: The last argument on the command line should be the name of the
        !          1799: file to be edited.  This file (if present) is read into the buffer
        !          1800: Main.  If no filename is specified, emacs puts you in the buffer Main
        !          1801: with no associated file.
        !          1802: .H 2 "Helpful hints"
        !          1803: This editor is very easy to use, once you know a few of the basic 
        !          1804: commands.  Here are some tips for making the best use of emacs.
        !          1805: .AL
        !          1806: .LI
        !          1807: Learn a few of the basic commands at a time.  You can accomplish a
        !          1808: lot with just the basic commands.
        !          1809: .LI
        !          1810: EMACS tries to be reasonably efficient about the refreshing of the
        !          1811: screen.  Some  sequences, however, will cause lots of text to be 
        !          1812: redisplayed.  While you can insert anything into the middle of a buffer by 
        !          1813: typing it, it is much better to open up some lines by using ^O
        !          1814: where you want to  insert, insert, and then kill unneeded lines.
        !          1815: .LI
        !          1816: Use M-? when in doubt about a command.  The explanations are brief, but 
        !          1817: should be sufficient to tell you what you want to know.
        !          1818: .LI
        !          1819: Like most editors, EMACS maintains a local buffer, so that changes made do
        !          1820: not go into the file until the next write.  Type ^X^S reasonably frequently
        !          1821: so as to avoid being wiped out by machine crashes, editor bugs, or other 
        !          1822: unpredictable events.
        !          1823: .LI
        !          1824: Because EMACS tries to avoid unnecessary refreshing of the screen,
        !          1825: it will get confused if characters are sent to your terminal from
        !          1826: some other program while running EMACS, such as a "background"
        !          1827: program, or by a write command from another user.  If you suspect
        !          1828: that the display does not correspond to the buffer that you are
        !          1829: editing, type ^L to refresh the screen.  After typing ^L, the screen
        !          1830: will match the buffer being edited.
        !          1831: .LE
        !          1832: .H 2 "Limitations of the editor"
        !          1833: There are some limits that you may encounter:
        !          1834: .BL
        !          1835: .LI
        !          1836: Each line can hold at most 512 characters.
        !          1837: .LI
        !          1838: Each buffer can hold a maximum of approximately 15,000 lines.
        !          1839: .LI
        !          1840: You can have at most 12 buffers.
        !          1841: .LI
        !          1842: The kill stack contains 
        !          1843: the 8 most recent deletions, or a total of 256K characters.
        !          1844: .LI
        !          1845: Filenames are limited to 128 characters.
        !          1846: .LE
        !          1847: .H 2 "Recovering from various problems."
        !          1848: Because EMACS puts your terminal in "raw" mode, it does not respond
        !          1849: to interrupt and quit characters the way that most unix programs
        !          1850: do.  If somethings goes wrong with emacs, you can usually stop it
        !          1851: with BREAK (typing ^Z to exit from emacs in response to the
        !          1852: message).  You may have to kill it from another terminal or log
        !          1853: out.
        !          1854: .P
        !          1855: If emacs runs into internal trouble, or if you kill emacs or log
        !          1856: out while running emacs, it will try to save your buffers before
        !          1857: terminating.  The buffers are saved in the files emacs0-emacs11 in
        !          1858: your home directory. You will get mail describing what files are
        !          1859: there from emacs after this happens, though if you do not clean up
        !          1860: these files, they will continue to appear in the message each time
        !          1861: you hang up on or kill an emacs process.
        !          1862: .H 1 "DIRED"
        !          1863: The program DIRED (DIRectory EDitor) is a version of emacs for
        !          1864: editing directories.
        !          1865: DIRED takes an argument which is the name of a directory, and
        !          1866: displays the result of ls -al executed on that directory.  Dired
        !          1867: allows you to edit the resulting buffer using most of the normal
        !          1868: commands.   You may edit it by overwriting the protection mode,
        !          1869: owner, or group fields, or by deleting entries, as discussed below. In
        !          1870: order to facilitate your editing of the fixed format data in the
        !          1871: directory listing, Dired puts you in "overwrite" mode by default, so
        !          1872: that characters that you type overwrite what is there rather than
        !          1873: inserting into it.  
        !          1874: .P
        !          1875: The changes that you indicate this way are not made immediately, but
        !          1876: are indicated by the letters 'D' (file deleted) 'M' (modes modified)
        !          1877: or 'O' (owner or group changed) at the left end of the file entries
        !          1878: modified.  When you try to save the buffer or exit, Dired asks you
        !          1879: if you want to make your changes permanent and then does them.
        !          1880: .P
        !          1881: Most of the usual emacs commands work in Dired just like in Emacs
        !          1882: with a few exceptions:
        !          1883: .VL 15
        !          1884: .LI "^D, ^?, and ^K"
        !          1885: These commands do not delete any text, but simply mark the file
        !          1886: designated on the current line for deletion.
        !          1887: .LI "d or D"
        !          1888: These characters mark the current file for deletion when typed at
        !          1889: the beginning of a line, and otherwise just overwrite what is there.
        !          1890: .LI "u or U"
        !          1891: These characters remove the Deleted mark from files when typed at
        !          1892: the beginning of a line, and otherwise just overwrite what is there.
        !          1893: .LI "e"
        !          1894: When typed at the beginning of a line, this causes dired to examine
        !          1895: the directory entry corresponding to that line.  If the entry is a
        !          1896: file, dired creates a new buffer and reads it in, allowing you to
        !          1897: examine it just like in emacs.  When you enter ^Z, Dired returns you
        !          1898: to the directory.  If the entry is a directory, Dired creates a
        !          1899: buffer and puts a directory listing of that directory in it,
        !          1900: allowing you to edit this just directory.  This feature provides a
        !          1901: very convenient way to scan through a directory structure.
        !          1902: .LE
        !          1903: .P
        !          1904: Ordinarily, the buffer listing for dired is created with a "ls -al"
        !          1905: command.  You can specify additional options for the display by
        !          1906: giving dired an argument beginning with a "-" to specify options. 
        !          1907: Thus "dired~-t~/usr/bin" will invoke dired on /usr/bin with a
        !          1908: listing sorted in time order.
        !          1909: .P
        !          1910: Dired provides a very convenient way to scan through and make
        !          1911: changes to directories.  It is particularly useful for cleaning up
        !          1912: directories that may have files that you have not used for some time
        !          1913: in them.
        !          1914: .P
        !          1915: Dired can be confused if you edit the filename of the entries, or
        !          1916: succeed in inserting or deleting characters in the entries.  It is
        !          1917: not very robust to such failures, and you are advised not to modify
        !          1918: the format of entries.  If you have somehow garbled a buffer with a
        !          1919: directory listing in it, you should probably kill the buffer so that
        !          1920: Dired will not try to update that directory from the garbled listing
        !          1921: when you try to exit.
        !          1922: .H 1 EXPERIENCE
        !          1923: The author originally wrote EMACS in 1979 as an aide to his own work of
        !          1924: programming and memorandum composition.  EMACS has been widely
        !          1925: available inside of Bell Laboratories through the Experimental Tools
        !          1926: facility, and through the author's own distribution efforts.  EMACS
        !          1927: now part of the AT&T Toolchest package and is available commercially
        !          1928: to anyone paying the nominal fee for it.  The following section
        !          1929: describes observations of the author and others on 6 years of
        !          1930: experience with Emacs.
        !          1931: .H 2 "Feature Use"
        !          1932: The most commonly used "feature" of EMACS is simply the ability to
        !          1933: enter text and see the result.  The simple cursor movement commands
        !          1934: appear to be much more frequently used than the more complicated
        !          1935: commands, such as those moving forward or backward by sentences.
        !          1936: .P
        !          1937: The following is a summary of the user reaction to some of the
        !          1938: unique features of EMACS.
        !          1939: .AL
        !          1940: .LI "Multiple Buffers"
        !          1941: .br
        !          1942: The ability to maintain several editing buffers at the same time
        !          1943: is widely used for many purposes.  These include examining several
        !          1944: source files while making modifications, holding source, compiler
        !          1945: output, and program output while debugging, and holding the output
        !          1946: of the spell utility while scanning a document for misspelled words.
        !          1947: The availability of multiple buffers allows the user to manage
        !          1948: several different tasks, such as writing a program, editing a
        !          1949: memorandum, and helping a friend locate a system problem, concurrently.
        !          1950: .LI "Two Window Mode"
        !          1951: .br
        !          1952: Two window mode is less heavily used than some of the other
        !          1953: features, but appears to be quite useful for a variety of tasks. 
        !          1954: These include viewing a buffer containing declarations at the same
        !          1955: time that a program is being entered in the second window, and
        !          1956: viewing the output of the spell program at the same time that the
        !          1957: document is being edited.  The fact that only one of the two
        !          1958: displays is actively maintained does not seem to be a problem, nor
        !          1959: does the limitation of only two display windows.  Few users have
        !          1960: objected to these limitations, though this may only indicate that
        !          1961: users are grateful enough for what Emacs does provide that they have
        !          1962: not run into them.
        !          1963: .LI "Incremental Search"
        !          1964: .br
        !          1965: With a high speed terminal, incremental search seems to be very
        !          1966: effective.  The ability to quickly move from one occurrence of a
        !          1967: string to the next seems to meet most user's needs.  With
        !          1968: significantly less than 9600 baud communication, the amount of
        !          1969: re-display created by incremental search becomes bothersome, and
        !          1970: the regular expression search is preferred.  The fact that
        !          1971: incremental search does not "wrap around", seems to be a significant
        !          1972: problem to many users.
        !          1973: .LI "C mode and Fill mode"
        !          1974: .br
        !          1975: These two modes provide customized facilities for editing certain
        !          1976: kinds of files.  The user reaction to these is mixed.  Some users
        !          1977: make extensive use of these, while others have their own styles for
        !          1978: entering memorandum or program source and do not use these modes. 
        !          1979: They are a very small part of EMACS, and as such are worthwhile even
        !          1980: if they are not extensively used.
        !          1981: .LI "Line Numbers"
        !          1982: .br
        !          1983: The display of the line number (lnumb mode) is one aspect of EMACS
        !          1984: that was not taken from the M.I.T. version.  This appears to be
        !          1985: extremely useful for use with UNIX, primarily because of the
        !          1986: widespread use of line numbers to indicate position within a file. 
        !          1987: Line numbers also serve to provide the user with some feedback as to
        !          1988: what part of the buffer is currently being displayed.
        !          1989: .LI "Macros"
        !          1990: The macro facility was built up over time, and only recently has
        !          1991: become a programming environment capable of being used by a wide
        !          1992: variety of users.  The initial macro language was powerful but
        !          1993: extremely cryptic.  Nevertheless, hundreds of macros were built, ranging from
        !          1994: simple commands that merely combine several basic commands to
        !          1995: self-contained editing systems making use of complex control flow
        !          1996: features.  Some of the more significant ones include a package for
        !          1997: correcting spelling errors, Several packages that compile C code and
        !          1998: step through the error messages, Several mail handling packages, and
        !          1999: Several packages implementing interfaces to mouse-equipped
        !          2000: terminals.
        !          2001: .P
        !          2002: In retrospect, our experience supports the conclusions of Richard
        !          2003: Stallman (The author of the original Emacs), that the "right" way to
        !          2004: build a powerful editor is to build a powerful programming
        !          2005: environment and build the user interface of the editor on top of it.
        !          2006: .LI "Picture Mode"
        !          2007: Picture mode is another feature that was originally unique to this
        !          2008: implementation.  It was inspired by the Two-Dimensional editor
        !          2009: 2ded, and by an electronic debate on whether screen editors should
        !          2010: present the file as a sequence of characters or as a two dimensional
        !          2011: blackboard.  Both are useful abstractions, and it was not difficult
        !          2012: to provide both views given the structure of Emacs.  Picture mode
        !          2013: has been widely used for editing tables and other fixed format
        !          2014: information.  It is also sometimes convenient for mouse based
        !          2015: interfaces.
        !          2016: .LE
        !          2017: .H 2 "Human Interface Observations"
        !          2018: There are several controversial aspects of the interface that emacs
        !          2019: presents to users.
        !          2020: .VL 15
        !          2021: .LI "Modeless Editing:"
        !          2022: The characteristics which most clearly distinguishes emacs style
        !          2023: editors from others is that lack of distinct modes for text
        !          2024: insertion and entering of commands.  This is also the most
        !          2025: controversial feature.  There have been many studies on moded and
        !          2026: modeless editors in the 10 years since the first Emacs editors
        !          2027: got significant use.  Most conclude that in spite of strong
        !          2028: preferences among users for one style or the other, neither is
        !          2029: clearly superior.  Also, in spite of feelings of users of both
        !          2030: modeless and moded editors that doing something in the wrong mode
        !          2031: would be a significant source of errors, the data do not show this as
        !          2032: a large problem.
        !          2033: .P
        !          2034: Our feeling on this issue is that there are different editing styles
        !          2035: for modeless or moded editing.  With a moded editor, you think of
        !          2036: editing as a series of commands, each of which changes the file in
        !          2037: some way.  With modeless editing, you tend to work more in the mode
        !          2038: of marking up a document with a red pencil, by moving to each
        !          2039: problem and re-typing whatever is wrong.  Modeless editing seems
        !          2040: natural in conjunction with a pointing device and menu interface,
        !          2041: and has been used effectively on many personal computer and word
        !          2042: processor editors this way.
        !          2043: .LI "Control Characters"
        !          2044: The use of control characters for editing commands in emacs is an
        !          2045: unavoidable consequence of modeless editing.  A conscious decision
        !          2046: was made in emacs to avoid the use of special keys on the keyboard,
        !          2047: such as function and arrow keys.  The rational for this was to avoid
        !          2048: requiring users to locate such keys, which appear in different
        !          2049: places on every terminal.  The result is that touch typists can use
        !          2050: emacs without ever having to look at the keyboard, which is
        !          2051: difficult if you must locate the special keys.
        !          2052: .P
        !          2053: The interface seems to work quite well for frequent users, however
        !          2054: casual users have trouble remembering which characters do what. 
        !          2055: Many users with programmable function keys on their terminals have
        !          2056: programmed and labeled them to send useful emacs commands.  The
        !          2057: conclusion that can be drawn is that it is nice to be able to touch
        !          2058: type all of the commands, and for many users it is desirable to be
        !          2059: able to use the special function keys on many terminals for editing.
        !          2060: .LE
        !          2061: .H 2 "Performance"
        !          2062: While computer resources are not as expensive as they once were,
        !          2063: they are far from free.  An interactive screen editor such as EMACS
        !          2064: consumes more in computer resources than a conventional editor. 
        !          2065: EMACS was designed to be as efficient as possible, some price must
        !          2066: be paid for the benefits gained.
        !          2067: .P
        !          2068: The Processor time consumption of EMACS is comparable to the UNIX
        !          2069: editor for most "commands", including reading and writing files,
        !          2070: searching, and substitution.  The major discrepancy in performance
        !          2071: comes in entering text.  In entering text, EMACS consumes
        !          2072: about 3 times as much processor time as the UNIX editor. 
        !          2073: .P
        !          2074: If we examine how each editor uses its time, we see that almost all
        !          2075: of the time spent by the UNIX editor is spent in the UNIX operating
        !          2076: system reading characters.  About two thirds of the time spent in
        !          2077: EMACS is spent reading and writing, while the remaining third is
        !          2078: spent re-creating the display.  EMACS uses almost twice as much UNIX
        !          2079: operating system processor time, because it is re-writing the
        !          2080: display after each character is typed, in addition to reading the
        !          2081: characters.  In addition, EMACS spends a significant amount of user
        !          2082: process time figuring out how to most efficiently re-display the
        !          2083: screen.
        !          2084: .P
        !          2085: While EMACS does consume more time editing than does the UNIX
        !          2086: editor, the processor time spent editing does not appear to be a
        !          2087: significant problem.  Measurements of CPU consumption of emacs made
        !          2088: on VAX 11/780, 3B20S, and PDP 11/70 systems each indicate that an
        !          2089: emacs user consumes on average about .01 second of cpu time per
        !          2090: character typed, and about 1% of the processor over the period of an
        !          2091: editing session.  These rates suggest that a substantial number of
        !          2092: users can be accommodated on most systems.
        !          2093: .H 1 CONCLUSIONS
        !          2094: The EMACS editor provides an effective means of using a high-speed
        !          2095: display terminal for text editing.  EMACS provides a variety of
        !          2096: unique features that seem to be very useful in editing.  User
        !          2097: reaction indicates that using EMACS has improved their productivity,
        !          2098: however there are no quantitative measurements of this effect.
        !          2099: .P
        !          2100: EMACS uses more computing resources than the standard UNIX editor,
        !          2101: however the resources utilized do not appear to be a serious
        !          2102: problem.  Emacs has been used effectively on many different machines
        !          2103: without serious difficulties in performance.
        !          2104: .P
        !          2105: EMACS was written by the author as a tool for his own work, but is
        !          2106: available to anyone desiring a copy.  There are no currently known
        !          2107: bugs, however there may be undiscovered problems.  The author is
        !          2108: interested in user reaction to EMACS and in reports of problems,
        !          2109: however, the author's job
        !          2110: does not include supporting EMACS, and thus the author does not
        !          2111: promise any prompt response to suggestions or trouble reports.
        !          2112: .SG UNIX
        !          2113: .SK
        !          2114: .tr ~~
        !          2115: .nr Hu 1
        !          2116: .nr Hc 1
        !          2117: .HU "APPENDIX -- EMACS Command Summary"
        !          2118: .SP 2
        !          2119: .nf
        !          2120: EMACS version 4.9 Date: Thu Mar 28 14:17:56 CST 1985
        !          2121: 
        !          2122: ^@:    sets the mark at the cursor position
        !          2123: ^A:    moves to the beginning of the line
        !          2124: ^B:    moves back one character
        !          2125: ^C:    capitalizes the current character
        !          2126: ^D:    deletes forward one character
        !          2127: ^E:    moves to the end of the line
        !          2128: ^F:    moves forward one character
        !          2129: ^G:    quits from any command in progress
        !          2130: ^H:    deletes backward one character
        !          2131: ^I:    inserts a tab
        !          2132: ^J:    opens a new line and moves to the beginning of it if the
        !          2133:        next line is non-empty, otherwise down one line
        !          2134: ^K:    kills to end of line (with argument, kills multiple lines)
        !          2135: ^L:    refreshes the screen
        !          2136: ^M:    opens a new line and moves to the beginning of it if the
        !          2137:        next line is non-empty, otherwise down one line
        !          2138: ^N:    moves down one line
        !          2139: ^O:    opens up a new line
        !          2140: ^P:    moves up one line
        !          2141: ^Q:    quotes the next character
        !          2142: ^R:    starts a reverse search
        !          2143: ^S:    starts a search
        !          2144: ^T:    transposes the next two characters
        !          2145: ^U:    multiplies the argument by 4
        !          2146: ^V:    moves to the next page
        !          2147: ^W:    kills the current region (between cursor and mark)
        !          2148: ^X:    is a prefix for more single character commands,
        !          2149:        type character or '*' for all
        !          2150: ^Y:    restores last killed text
        !          2151:        (leaves cursor and mark around it)
        !          2152: ^Z:    exits one level
        !          2153: ^[:    makes the next character a meta character
        !          2154: ^]:    makes a local variable of a macro invocation the argument to the
        !          2155:        next command
        !          2156: ^^:    causes the last returned result to become the argument
        !          2157:  :     is self inserting and check for automatic word wrapping
        !          2158: -:     is self inserting unless part of a numeric argument
        !          2159: .:     is self inserting and check for automatic word wrapping
        !          2160: 0:     is self inserting unless part of a numeric argument
        !          2161: 1:     is self inserting unless part of a numeric argument
        !          2162: 2:     is self inserting unless part of a numeric argument
        !          2163: 3:     is self inserting unless part of a numeric argument
        !          2164: 4:     is self inserting unless part of a numeric argument
        !          2165: 5:     is self inserting unless part of a numeric argument
        !          2166: 6:     is self inserting unless part of a numeric argument
        !          2167: 7:     is self inserting unless part of a numeric argument
        !          2168: 8:     is self inserting unless part of a numeric argument
        !          2169: 9:     is self inserting unless part of a numeric argument
        !          2170: }:     is self inserting, and re-adjusts indentation in C mode
        !          2171: ^?:    deletes backward one character
        !          2172: M-^H:  deletes the last word
        !          2173: M-^L:  re-displays with current line at top of page
        !          2174: M-^M:  mails the current buffer
        !          2175: M-^Q:  returns the next input character (in a macro)
        !          2176: M-^R:  regular expression query replace
        !          2177: M-^S:  regular expression search
        !          2178: M-^X:  executes argument 0 as a character command.
        !          2179: M-^Z:  suspends emacs
        !          2180: M-^]:  assigns the result of the next command to a macro local variable
        !          2181: M- :   sets the mark at the cursor position
        !          2182: M-!:   gets and executes a shell command
        !          2183: M-":   auto Fills the whole buffer
        !          2184: M-$:   executes a command, saving the output in buffer .exec
        !          2185: M--:   is self inserting unless part of a numeric argument
        !          2186: M-/:   starts a comment
        !          2187: M-0:   is self inserting unless part of a numeric argument
        !          2188: M-1:   is self inserting unless part of a numeric argument
        !          2189: M-2:   is self inserting unless part of a numeric argument
        !          2190: M-3:   is self inserting unless part of a numeric argument
        !          2191: M-4:   is self inserting unless part of a numeric argument
        !          2192: M-5:   is self inserting unless part of a numeric argument
        !          2193: M-6:   is self inserting unless part of a numeric argument
        !          2194: M-7:   is self inserting unless part of a numeric argument
        !          2195: M-8:   is self inserting unless part of a numeric argument
        !          2196: M-9:   is self inserting unless part of a numeric argument
        !          2197: M-::   maps a character to a command
        !          2198: M-<:   moves to top of file
        !          2199: M->:   moves to bottom of file
        !          2200: M-?:   explains the next character
        !          2201: M-E:   expands an environment variable and returns the result on the kill stack.
        !          2202: M-\:   converts its argument to a character and inserts it
        !          2203: M-_:   underlines the next word
        !          2204: M-a:   moves to beginning of sentence
        !          2205: M-b:   moves back one word
        !          2206: M-c:   capitalizes the next word
        !          2207: M-d:   deletes the next word
        !          2208: M-e:   moves to End of Sentence
        !          2209: M-f:   moves forward one word
        !          2210: M-g:   moves to a specific line (its argument)
        !          2211: M-l:   converts the next letter to lower case
        !          2212: M-m:   displays active modes
        !          2213: M-p:   puts the current region in the kill buffer without killing it
        !          2214: M-q:   quotes the next character and adds the 0200 bit
        !          2215: M-r:   starts query replace
        !          2216: M-s:   gives EMACS statistics
        !          2217: M-t:   prompts for terminal type
        !          2218: M-u:   undoes the last significant text modification
        !          2219: M-v:   moves back one page
        !          2220: M-w:   puts a wall chart of explanations in the buffer
        !          2221: M-x:   calls a macro by name
        !          2222: M-y:   replaces the last restore() with the next text in
        !          2223:        the kill stack.
        !          2224: M-z:   kills emacs with a core dump (for debugging)
        !          2225: M-{:   enters a command sequence (in a macro)
        !          2226: M-}:   exits one level
        !          2227: M-~:   marks a buffer as being unmodified (up to date)
        !          2228: M-^?:  deletes the last word
        !          2229: 
        !          2230: Control-X commands:
        !          2231: 
        !          2232: ^X^A:  accesses the argument list to emacs
        !          2233: ^X^B:  changes Buffers (Change to * lists active buffers)
        !          2234: ^X^C:  exits gracefully
        !          2235:        (after asking whether or not to save the buffer)
        !          2236: ^X^D:  changes the working directory
        !          2237: ^X^E:  calls emacs recursively taking input from the terminal
        !          2238: ^X^F:  edits a file in its own buffer
        !          2239:        (if file has been read into a buffer, moves to it)
        !          2240: ^X^G:  sends an interrupt signal to a sub-process in the current buffer
        !          2241: ^X^I:  re-directs input from a file
        !          2242: ^X^K:  kills a buffer
        !          2243: ^X^L:  loads a file full of macro definitions
        !          2244: ^X^M:  sets mode from argument (prompts for mode name)
        !          2245:        and string if necessary
        !          2246: ^X^N:  changes the buffer or file name
        !          2247: ^X^O:  switches between windows
        !          2248: ^X^Q:  returns the character under the cursor (in a macro)
        !          2249: ^X^R:  reads a new file
        !          2250: ^X^S:  saves the buffer in the current file (if modified)
        !          2251: ^X^T:  prompts for a buffer name and inserts the text between the
        !          2252:        cursor and the mark into the named buffer.
        !          2253: ^X^U:  updates the display and delays for a specified time
        !          2254: ^X^V:  puts the current version on the kill stack.
        !          2255: ^X^W:  writes a new or old file
        !          2256: ^X^X:  exchanges the mark and the cursor
        !          2257: ^X^^:  causes the current window to grow one by line
        !          2258: ^X!:   begins a case statement (in a macro)
        !          2259: ^X#:   reads or writes global variables
        !          2260: ^X%:   exchanges the top of the kill stack with another item
        !          2261: ^X&:   compares two strings
        !          2262: ^X(:   starts a keyboard macro
        !          2263: ^X):   ends a keyboard macro
        !          2264: ^X+:   causes the next entry to the kill stack to append to the previous entry
        !          2265: ^X-:   pops the kill stack
        !          2266: ^X1:   exits two window mode
        !          2267: ^X2:   enters two window mode
        !          2268: ^X<:   pushes a string from the tty or macro text into the kill stack
        !          2269: ^X=:   gives statistics about the buffer
        !          2270: ^X>:   duplicates an item on the kill stack
        !          2271: ^X@:   prompts the user with a string from the kill stack and returns the result.
        !          2272: ^XB:   puts the buffer name into the kill stack
        !          2273: ^XE:   executes the keyboard macro
        !          2274: ^XF:   puts the file name into the stack
        !          2275: ^XL:   makes the next character a meta character
        !          2276: ^XT:   traces the next command.
        !          2277: ^X^:   enters a "while" loop (in a macro)
        !          2278: ^Xd:   defines macros from the current buffer
        !          2279: ^Xg:   moves to a screen position (arg=128*y+x);
        !          2280: ^Xk:   sets the encryption key for file reading and writing
        !          2281: ^Xm:   sets mode from argument (prompts for mode name)
        !          2282:        and string if necessary
        !          2283: ^X|:   begins a conditional execution sequence (in a macro)
        !          2284: ^X~:   performs arithmetic or logical operations (in a macro)
        !          2285: .fi
        !          2286: .SK
        !          2287: .NS ""
        !          2288: All Supervision Lab 5523
        !          2289: .NE
        !          2290: .TC

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.