Return to emacs-16 CVS log

Up to [Apple XNU] / GNUtools / emacs / info

Annotation of GNUtools/emacs/info/emacs-16, revision 1.1

1.1     ! root        1: This is Info file ../info/emacs, produced by Makeinfo-1.49 from the
        !             2: input file emacs.texi.
        !             3: 
        !             4:    This file documents the GNU Emacs editor.
        !             5: 
        !             6:    Copyright (C) 1985, 1986, 1988, 1992 Richard M. Stallman.
        !             7: 
        !             8:    Permission is granted to make and distribute verbatim copies of this
        !             9: manual provided the copyright notice and this permission notice are
        !            10: preserved on all copies.
        !            11: 
        !            12:    Permission is granted to copy and distribute modified versions of
        !            13: this manual under the conditions for verbatim copying, provided also
        !            14: that the sections entitled "The GNU Manifesto", "Distribution" and "GNU
        !            15: General Public License" are included exactly as in the original, and
        !            16: provided that the entire resulting derived work is distributed under the
        !            17: terms of a permission notice identical to this one.
        !            18: 
        !            19:    Permission is granted to copy and distribute translations of this
        !            20: manual into another language, under the above conditions for modified
        !            21: versions, except that the sections entitled "The GNU Manifesto",
        !            22: "Distribution" and "GNU General Public License" may be included in a
        !            23: translation approved by the author instead of in the original English.
        !            24: 
        !            25: 
        !            26: File: emacs,  Node: Glossary,  Next: Key Index,  Prev: Intro,  Up: Top
        !            27: 
        !            28: Glossary
        !            29: ********
        !            30: 
        !            31: Abbrev
        !            32:      An abbrev is a text string which expands into a different text
        !            33:      string when present in the buffer.  For example, you might define
        !            34:      a short word as an abbrev for a long phrase that you want to insert
        !            35:      frequently.  *Note Abbrevs::.
        !            36: 
        !            37: Aborting
        !            38:      Aborting means getting out of a recursive edit (q.v.).  The
        !            39:      commands `C-]' and `M-x top-level' are used for this. *Note
        !            40:      Quitting::.
        !            41: 
        !            42: Auto Fill mode
        !            43:      Auto Fill mode is a minor mode in which text that you insert is
        !            44:      automatically broken into lines of fixed width.  *Note Filling::.
        !            45: 
        !            46: Auto Saving
        !            47:      Auto saving is when Emacs automatically stores the contents of an
        !            48:      Emacs buffer in a specially-named file so that the information will
        !            49:      not be lost if the buffer is lost due to a system error or user
        !            50:      error. *Note Auto Save::.
        !            51: 
        !            52: Backup File
        !            53:      A backup file records the contents that a file had before the
        !            54:      current editing session.  Emacs makes backup files automatically
        !            55:      to help you track down or cancel changes you later regret making. 
        !            56:      *Note Backup::.
        !            57: 
        !            58: Balance Parentheses
        !            59:      Emacs can balance parentheses manually or automatically.  Manual
        !            60:      balancing is done by the commands to move over balanced expressions
        !            61:      (*note Lists::.).  Automatic balancing is done by blinking the
        !            62:      parenthesis that matches one just inserted (*note Matching Parens:
        !            63:      Matching.).
        !            64: 
        !            65: Bind
        !            66:      To bind a key is to change its binding (q.v.).  *Note Rebinding::.
        !            67: 
        !            68: Binding
        !            69:      A key gets its meaning in Emacs by having a binding which is a
        !            70:      command (q.v.), a Lisp function that is run when the key is typed.
        !            71:      *Note Binding: Commands.  Customization often involves rebinding a
        !            72:      character to a different command function.  The bindings of all
        !            73:      keys are recorded in the keymaps (q.v.).  *Note Keymaps::.
        !            74: 
        !            75: Blank Lines
        !            76:      Blank lines are lines that contain only whitespace.  Emacs has
        !            77:      several commands for operating on the blank lines in the buffer.
        !            78: 
        !            79: Buffer
        !            80:      The buffer is the basic editing unit; one buffer corresponds to one
        !            81:      piece of text being edited.  You can have several buffers, but at
        !            82:      any time you are editing only one, the `selected' buffer, though
        !            83:      several can be visible when you are using multiple windows.  *Note
        !            84:      Buffers::.
        !            85: 
        !            86: Buffer Selection History
        !            87:      Emacs keeps a buffer selection history which records how recently
        !            88:      each Emacs buffer has been selected.  This is used for choosing a
        !            89:      buffer to select.  *Note Buffers::.
        !            90: 
        !            91: C-
        !            92:      `C' in the name of a character is an abbreviation for Control.
        !            93:      *Note C-: Characters.
        !            94: 
        !            95: C-M-
        !            96:      `C-M-' in the name of a character is an abbreviation for
        !            97:      Control-Meta.  *Note C-M-: Characters.
        !            98: 
        !            99: Case Conversion
        !           100:      Case conversion means changing text from upper case to lower case
        !           101:      or vice versa.  *Note Case::, for the commands for case conversion.
        !           102: 
        !           103: Characters
        !           104:      Characters form the contents of an Emacs buffer; also, Emacs
        !           105:      commands are invoked by keys (q.v.), which are sequences of one or
        !           106:      more characters.  *Note Characters::.
        !           107: 
        !           108: Command
        !           109:      A command is a Lisp function specially defined to be able to serve
        !           110:      as a key binding in Emacs.  When you type a key (q.v.), its binding
        !           111:      (q.v.) is looked up in the relevant keymaps (q.v.) to find the
        !           112:      command to run.  *Note Commands::.
        !           113: 
        !           114: Command Name
        !           115:      A command name is the name of a Lisp symbol which is a command
        !           116:      (*note Commands::.).  You can invoke any command by its name using
        !           117:      `M-x' (*note M-x::.).
        !           118: 
        !           119: Comments
        !           120:      A comment is text in a program which is intended only for humans
        !           121:      reading the program, and is marked specially so that it will be
        !           122:      ignored when the program is loaded or compiled.  Emacs offers
        !           123:      special commands for creating, aligning and killing comments.
        !           124:      *Note Comments::.
        !           125: 
        !           126: Compilation
        !           127:      Compilation is the process of creating an executable program from
        !           128:      source code.  Emacs has commands for compiling files of Emacs Lisp
        !           129:      code (*note Lisp Libraries::.) and programs in C and other
        !           130:      languages (*note Compilation::.).
        !           131: 
        !           132: Complete Key
        !           133:      A complete key is a character or sequence of characters which,
        !           134:      when typed by the user, fully specifies one action to be performed
        !           135:      by Emacs.  For example, `X' and `Control-f' and `Control-x m' are
        !           136:      keys.  Keys derive their meanings from being bound (q.v.) to
        !           137:      commands (q.v.). Thus, `X' is conventionally bound to a command to
        !           138:      insert `X' in the buffer; `C-x m' is conventionally bound to a
        !           139:      command to begin composing a mail message. *Note Keys::.
        !           140: 
        !           141: Completion
        !           142:      Completion is what Emacs does when it automatically fills out an
        !           143:      abbreviation for a name into the entire name.  Completion is done
        !           144:      for minibuffer (q.v.) arguments when the set of possible valid
        !           145:      inputs is known; for example, on command names, buffer names, and
        !           146:      file names.  Completion occurs when TAB, SPC or RET is typed. 
        !           147:      *Note Completion::.
        !           148: 
        !           149: Continuation Line
        !           150:      When a line of text is longer than the width of the screen, it
        !           151:      takes up more than one screen line when displayed.  We say that the
        !           152:      text line is continued, and all screen lines used for it after the
        !           153:      first are called continuation lines.  *Note Continuation: Basic.
        !           154: 
        !           155: Control-Character
        !           156:      ASCII characters with octal codes 0 through 037, and also code
        !           157:      0177, do not have graphic images assigned to them.  These are the
        !           158:      control characters.  Any control character can be typed by holding
        !           159:      down the CTRL key and typing some other character; some have
        !           160:      special keys on the keyboard.  RET, TAB, ESC, LFD and DEL are all
        !           161:      control characters.  *Note Characters::.
        !           162: 
        !           163: Copyleft
        !           164:      A copyleft is a notice giving the public legal permission to
        !           165:      redistribute a program or other work of art.  Copylefts are used
        !           166:      by leftists to enrich the public just as copyrights are used by
        !           167:      rightists to gain power over the public.
        !           168: 
        !           169: Current Buffer
        !           170:      The current buffer in Emacs is the Emacs buffer on which most
        !           171:      editing commands operate.  You can select any Emacs buffer as the
        !           172:      current one. *Note Buffers::.
        !           173: 
        !           174: Current Line
        !           175:      The line point is on (*note Point::.).
        !           176: 
        !           177: Current Paragraph
        !           178:      The paragraph that point is in.  If point is between paragraphs,
        !           179:      the current paragraph is the one that follows point.  *Note
        !           180:      Paragraphs::.
        !           181: 
        !           182: Current Defun
        !           183:      The defun (q.v.) that point is in.  If point is between defuns, the
        !           184:      current defun is the one that follows point.  *Note Defuns::.
        !           185: 
        !           186: Cursor
        !           187:      The cursor is the rectangle on the screen which indicates the
        !           188:      position called point (q.v.) at which insertion and deletion takes
        !           189:      place. The cursor is on or under the character that follows point.
        !           190:       Often people speak of `the cursor' when, strictly speaking, they
        !           191:      mean `point'.  *Note Cursor: Basic.
        !           192: 
        !           193: Customization
        !           194:      Customization is making minor changes in the way Emacs works.  It
        !           195:      is often done by setting variables (*note Variables::.) or by
        !           196:      rebinding keys (*note Keymaps::.).
        !           197: 
        !           198: Default Argument
        !           199:      The default for an argument is the value that will be assumed if
        !           200:      you do not specify one.  When the minibuffer is used to read an
        !           201:      argument, the default argument is used if you just type RET. *Note
        !           202:      Minibuffer::.
        !           203: 
        !           204: Default Directory
        !           205:      When you specify a file name that does not start with `/' or `~',
        !           206:      it is interpreted relative to the current buffer's default
        !           207:      directory. *Note Default Directory: Minibuffer File.
        !           208: 
        !           209: Defun
        !           210:      A defun is a list at the top level of parenthesis or bracket
        !           211:      structure in a program.  It is so named because most such lists in
        !           212:      Lisp programs are calls to the Lisp function `defun'.  *Note
        !           213:      Defuns::.
        !           214: 
        !           215: DEL
        !           216:      DEL is a character that runs the command to delete one character of
        !           217:      text.  *Note DEL: Basic.
        !           218: 
        !           219: Deletion
        !           220:      Deletion means erasing text without saving it.  Emacs deletes text
        !           221:      only when it is expected not to be worth saving (all whitespace, or
        !           222:      only one character).  The alternative is killing (q.v.). *Note
        !           223:      Deletion: Killing.
        !           224: 
        !           225: Deletion of Files
        !           226:      Deleting a file means erasing it from the file system. *Note Misc
        !           227:      File Ops::.
        !           228: 
        !           229: Deletion of Messages
        !           230:      Deleting a message means flagging it to be eliminated from your
        !           231:      mail file.  This can be undone by undeletion until the mail file
        !           232:      is expunged. *Note Rmail Deletion::.
        !           233: 
        !           234: Deletion of Windows
        !           235:      Deleting a window means eliminating it from the screen.  Other
        !           236:      windows expand to use up the space.  The deleted window can never
        !           237:      come back, but no actual text is thereby lost.  *Note Windows::.
        !           238: 
        !           239: Directory
        !           240:      Files in the Unix file system are grouped into file directories.
        !           241:      *Note Directories: ListDir.
        !           242: 
        !           243: Dired
        !           244:      Dired is the Emacs facility that displays the contents of a file
        !           245:      directory and allows you to "edit the directory", performing
        !           246:      operations on the files in the directory.  *Note Dired::.
        !           247: 
        !           248: Disabled Command
        !           249:      A disabled command is one that you may not run without special
        !           250:      confirmation.  The usual reason for disabling a command is that it
        !           251:      is confusing for beginning users.  *Note Disabling::.
        !           252: 
        !           253: Dribble File
        !           254:      A file into which Emacs writes all the characters that the user
        !           255:      types on the keyboard.  Dribble files are used to make a record for
        !           256:      debugging Emacs bugs.  Emacs does not make a dribble file unless
        !           257:      you tell it to.  *Note Bugs::.
        !           258: 
        !           259: Echo Area
        !           260:      The echo area is the bottom line of the screen, used for echoing
        !           261:      the arguments to commands, for asking questions, and printing brief
        !           262:      messages (including error messages).  *Note Echo Area::.
        !           263: 
        !           264: Echoing
        !           265:      Echoing is acknowledging the receipt of commands by displaying them
        !           266:      (in the echo area).  Emacs never echoes single-character keys;
        !           267:      longer keys echo only if you pause while typing them.
        !           268: 
        !           269: Error
        !           270:      An error occurs when an Emacs command cannot execute in the current
        !           271:      circumstances.  When an error occurs, execution of the command
        !           272:      stops (unless the command has been programmed to do otherwise) and
        !           273:      Emacs reports the error by printing an error message (q.v.). 
        !           274:      Type-ahead is discarded.  Then Emacs is ready to read another
        !           275:      editing command.
        !           276: 
        !           277: Error Messages
        !           278:      Error messages are single lines of output printed by Emacs when the
        !           279:      user asks for something impossible to do (such as, killing text
        !           280:      forward when point is at the end of the buffer).  They appear in
        !           281:      the echo area, accompanied by a beep.
        !           282: 
        !           283: ESC
        !           284:      ESC is a character, used to end incremental searches and as a
        !           285:      prefix for typing Meta characters on keyboards lacking a META key.
        !           286:       Unlike the META key (which, like the SHIFT key, is held down
        !           287:      while another character is typed), the ESC key is pressed once and
        !           288:      applies to the next character typed.
        !           289: 
        !           290: Fill Prefix
        !           291:      The fill prefix is a string that should be expected at the
        !           292:      beginning of each line when filling is done.  It is not regarded
        !           293:      as part of the text to be filled.  *Note Filling::.
        !           294: 
        !           295: Filling
        !           296:      Filling text means moving text from line to line so that all the
        !           297:      lines are approximately the same length.  *Note Filling::.
        !           298: 
        !           299: Global
        !           300:      Global means `independent of the current environment; in effect
        !           301:      throughout Emacs'.  It is the opposite of local (q.v.).  Particular
        !           302:      examples of the use of `global' appear below.
        !           303: 
        !           304: Global Abbrev
        !           305:      A global definition of an abbrev (q.v.) is effective in all major
        !           306:      modes that do not have local (q.v.) definitions for the same
        !           307:      abbrev. *Note Abbrevs::.
        !           308: 
        !           309: Global Keymap
        !           310:      The global keymap (q.v.) contains key bindings that are in effect
        !           311:      except when overridden by local key bindings in a major mode's
        !           312:      local keymap (q.v.).  *Note Keymaps::.
        !           313: 
        !           314: Global Substitution
        !           315:      Global substitution means replacing each occurrence of one string
        !           316:      by another string through a large amount of text.  *Note Replace::.
        !           317: 
        !           318: Global Variable
        !           319:      The global value of a variable (q.v.) takes effect in all buffers
        !           320:      that do not have their own local (q.v.) values for the variable.
        !           321:      *Note Variables::.
        !           322: 
        !           323: Graphic Character
        !           324:      Graphic characters are those assigned pictorial images rather than
        !           325:      just names.  All the non-Meta (q.v.) characters except for the
        !           326:      Control (q.v.) characters are graphic characters.  These include
        !           327:      letters, digits, punctuation, and spaces; they do not include RET
        !           328:      or ESC.  In Emacs, typing a graphic character inserts that
        !           329:      character (in ordinary editing modes).  *Note Basic Editing: Basic.
        !           330: 
        !           331: Grinding
        !           332:      Grinding means adjusting the indentation in a program to fit the
        !           333:      nesting structure.  *Note Grinding: Indentation.
        !           334: 
        !           335: Hardcopy
        !           336:      Hardcopy means printed output.  Emacs has commands for making
        !           337:      printed listings of text in Emacs buffers.  *Note Hardcopy::.
        !           338: 
        !           339: HELP
        !           340:      You can type HELP at any time to ask what options you have, or to
        !           341:      ask what any command does.  HELP is really `Control-h'. *Note
        !           342:      Help::.
        !           343: 
        !           344: Inbox
        !           345:      An inbox is a file in which mail is delivered by the operating
        !           346:      system. Rmail transfers mail from inboxes to mail files (q.v.) in
        !           347:      which the mail is then stored permanently or until explicitly
        !           348:      deleted. *Note Rmail Inbox::.
        !           349: 
        !           350: Indentation
        !           351:      Indentation means blank space at the beginning of a line.  Most
        !           352:      programming languages have conventions for using indentation to
        !           353:      illuminate the structure of the program, and Emacs has special
        !           354:      features to help you set up the correct indentation. *Note
        !           355:      Indentation::.
        !           356: 
        !           357: Insertion
        !           358:      Insertion means copying text into the buffer, either from the
        !           359:      keyboard or from some other place in Emacs.
        !           360: 
        !           361: Justification
        !           362:      Justification means adding extra spaces to lines of text to make
        !           363:      them come exactly to a specified width.  *Note Justification:
        !           364:      Filling.
        !           365: 
        !           366: Keyboard Macros
        !           367:      Keyboard macros are a way of defining new Emacs commands from
        !           368:      sequences of existing ones, with no need to write a Lisp program.
        !           369:      *Note Keyboard Macros::.
        !           370: 
        !           371: Key
        !           372:      A key is a sequence of characters that, when input to Emacs,
        !           373:      specify or begin to specify a single action for Emacs to perform. 
        !           374:      That is, the sequence is not more than a single unit.  If the key
        !           375:      is enough to specify one action, it is a complete key (q.v.); if
        !           376:      it is less than enough, it is a prefix key (q.v.).  *Note Keys::.
        !           377: 
        !           378: Keymap
        !           379:      The keymap is the data structure that records the bindings (q.v.)
        !           380:      of keys to the commands that they run.  For example, the keymap
        !           381:      binds the character `C-n' to the command function `next-line'.
        !           382:      *Note Keymaps::.
        !           383: 
        !           384: Kill Ring
        !           385:      The kill ring is where all text you have killed recently is saved.
        !           386:      You can reinsert any of the killed text still in the ring; this is
        !           387:      called yanking (q.v.).  *Note Yanking::.
        !           388: 
        !           389: Killing
        !           390:      Killing means erasing text and saving it on the kill ring so it
        !           391:      can be yanked (q.v.) later.  Some other systems call this
        !           392:      "cutting". Most Emacs commands to erase text do killing, as
        !           393:      opposed to deletion (q.v.).  *Note Killing::.
        !           394: 
        !           395: Killing Jobs
        !           396:      Killing a job (such as, an invocation of Emacs) means making it
        !           397:      cease to exist.  Any data within it, if not saved in a file, is
        !           398:      lost. *Note Exiting::.
        !           399: 
        !           400: List
        !           401:      A list is, approximately, a text string beginning with an open
        !           402:      parenthesis and ending with the matching close parenthesis.  In C
        !           403:      mode and other non-Lisp modes, groupings surrounded by other kinds
        !           404:      of matched delimiters appropriate to the language, such as braces,
        !           405:      are also considered lists.  Emacs has special commands for many
        !           406:      operations on lists.  *Note Lists::.
        !           407: 
        !           408: Local
        !           409:      Local means `in effect only in a particular context'; the relevant
        !           410:      kind of context is a particular function execution, a particular
        !           411:      buffer, or a particular major mode.  It is the opposite of `global'
        !           412:      (q.v.).  Specific uses of `local' in Emacs terminology appear
        !           413:      below.
        !           414: 
        !           415: Local Abbrev
        !           416:      A local abbrev definition is effective only if a particular major
        !           417:      mode is selected.  In that major mode, it overrides any global
        !           418:      definition for the same abbrev.  *Note Abbrevs::.
        !           419: 
        !           420: Local Keymap
        !           421:      A local keymap is used in a particular major mode; the key bindings
        !           422:      (q.v.) in the current local keymap override global bindings of the
        !           423:      same keys.  *Note Keymaps::.
        !           424: 
        !           425: Local Variable
        !           426:      A local value of a variable (q.v.) applies to only one buffer.
        !           427:      *Note Locals::.
        !           428: 
        !           429: M-
        !           430:      `M-' in the name of a character is an abbreviation for META, one
        !           431:      of the modifier keys that can accompany any character. *Note
        !           432:      Characters::.
        !           433: 
        !           434: M-C-
        !           435:      `M-C-' in the name of a character is an abbreviation for
        !           436:      Control-Meta; it means the same thing as `C-M-'.  If your terminal
        !           437:      lacks a real META key, you type a Control-Meta character by typing
        !           438:      ESC and then typing the corresponding Control character. *Note
        !           439:      C-M-: Characters.
        !           440: 
        !           441: M-x
        !           442:      `M-x' is the key which is used to call an Emacs command by name.
        !           443:      This is how commands that are not bound to keys are called. *Note
        !           444:      M-x::.
        !           445: 
        !           446: Mail
        !           447:      Mail means messages sent from one user to another through the
        !           448:      computer system, to be read at the recipient's convenience.  Emacs
        !           449:      has commands for composing and sending mail, and for reading and
        !           450:      editing the mail you have received.  *Note Sending Mail::.  *Note
        !           451:      Rmail::, for how to read mail.
        !           452: 
        !           453: Mail File
        !           454:      A mail file is a file which is edited using Rmail and in which
        !           455:      Rmail stores mail.  *Note Rmail::.
        !           456: 
        !           457: Major Mode
        !           458:      The major modes are a mutually exclusive set of options each of
        !           459:      which configures Emacs for editing a certain sort of text. 
        !           460:      Ideally, each programming language has its own major mode.  *Note
        !           461:      Major Modes::.
        !           462: 
        !           463: Mark
        !           464:      The mark points to a position in the text.  It specifies one end of
        !           465:      the region (q.v.), point being the other end.  Many commands
        !           466:      operate on all the text from point to the mark.  *Note Mark::.
        !           467: 
        !           468: Mark Ring
        !           469:      The mark ring is used to hold several recent previous locations of
        !           470:      the mark, just in case you want to move back to them.  *Note Mark
        !           471:      Ring::.
        !           472: 
        !           473: Message
        !           474:      See `mail'.
        !           475: 
        !           476: Meta
        !           477:      Meta is the name of a modifier bit which a command character may
        !           478:      have. It is present in a character if the character is typed with
        !           479:      the META key held down.  Such characters are given names that start
        !           480:      with `Meta-'.  For example, `Meta-<' is typed by holding down META
        !           481:      and at the same time typing `<' (which itself is done, on most
        !           482:      terminals, by holding down SHIFT and typing `,'). *Note Meta:
        !           483:      Characters.
        !           484: 
        !           485: Meta Character
        !           486:      A Meta character is one whose character code includes the Meta bit.
        !           487: 
        !           488: Minibuffer
        !           489:      The minibuffer is the window that appears when necessary inside the
        !           490:      echo area (q.v.), used for reading arguments to commands. *Note
        !           491:      Minibuffer::.
        !           492: 
        !           493: Minor Mode
        !           494:      A minor mode is an optional feature of Emacs which can be switched
        !           495:      on or off independently of all other features.  Each minor mode
        !           496:      has a command to turn it on or off.  *Note Minor Modes::.
        !           497: 
        !           498: Mode Line
        !           499:      The mode line is the line at the bottom of each text window (q.v.),
        !           500:      which gives status information on the buffer displayed in that
        !           501:      window. *Note Mode Line::.
        !           502: 
        !           503: Modified Buffer
        !           504:      A buffer (q.v.) is modified if its text has been changed since the
        !           505:      last time the buffer was saved (or since when it was created, if it
        !           506:      has never been saved).  *Note Saving::.
        !           507: 
        !           508: Moving Text
        !           509:      Moving text means erasing it from one place and inserting it in
        !           510:      another.  This is done by killing (q.v.) and then yanking (q.v.).
        !           511:      *Note Killing::.
        !           512: 
        !           513: Named Mark
        !           514:      A named mark is a register (q.v.) in its role of recording a
        !           515:      location in text so that you can move point to that location.
        !           516:      *Note Registers::.
        !           517: 
        !           518: Narrowing
        !           519:      Narrowing means creating a restriction (q.v.) that limits editing
        !           520:      in the current buffer to only a part of the text in the buffer. 
        !           521:      Text outside that part is inaccessible to the user until the
        !           522:      boundaries are widened again, but it is still there, and saving
        !           523:      the file saves it all.  *Note Narrowing::.
        !           524: 
        !           525: Newline
        !           526:      LFD characters in the buffer terminate lines of text and are
        !           527:      called newlines.  *Note Newline: Characters.
        !           528: 
        !           529: Numeric Argument
        !           530:      A numeric argument is a number, specified before a command, to
        !           531:      change the effect of the command.  Often the numeric argument
        !           532:      serves as a repeat count.  *Note Arguments::.
        !           533: 
        !           534: Option
        !           535:      An option is a variable (q.v.) that exists so that you can
        !           536:      customize Emacs by giving it a new value.  *Note Variables::.
        !           537: 
        !           538: Overwrite Mode
        !           539:      Overwrite mode is a minor mode.  When it is enabled, ordinary text
        !           540:      characters replace the existing text after point rather than
        !           541:      pushing it to the right.  *Note Minor Modes::.
        !           542: 
        !           543: Page
        !           544:      A page is a unit of text, delimited by formfeed characters (ASCII
        !           545:      Control-L, code 014) coming at the beginning of a line.  Some Emacs
        !           546:      commands are provided for moving over and operating on pages.
        !           547:      *Note Pages::.
        !           548: 
        !           549: Paragraphs
        !           550:      Paragraphs are the medium-size unit of English text.  There are
        !           551:      special Emacs commands for moving over and operating on paragraphs.
        !           552:      *Note Paragraphs::.
        !           553: 
        !           554: Parsing
        !           555:      We say that Emacs parses words or expressions in the text being
        !           556:      edited.  Really, all it knows how to do is find the other end of a
        !           557:      word or expression.  *Note Syntax::.
        !           558: 
        !           559: Point
        !           560:      Point is the place in the buffer at which insertion and deletion
        !           561:      occur.  Point is considered to be between two characters, not at
        !           562:      one character.  The terminal's cursor (q.v.) indicates the
        !           563:      location of point.  *Note Point: Basic.
        !           564: 
        !           565: Prefix Key
        !           566:      A prefix key is a key (q.v.) whose sole function is to introduce a
        !           567:      set of multi-character keys.  `Control-x' is an example of prefix
        !           568:      key; thus, any two-character sequence starting with `C-x' is also
        !           569:      a legitimate key.  *Note Keys::.
        !           570: 
        !           571: Primary Mail File
        !           572:      Your primary mail file is the file named `RMAIL' in your home
        !           573:      directory, where all mail that you receive is stored by Rmail
        !           574:      unless you make arrangements to do otherwise.  *Note Rmail::.
        !           575: 
        !           576: Prompt
        !           577:      A prompt is text printed to ask the user for input.  Printing a
        !           578:      prompt is called prompting.  Emacs prompts always appear in the
        !           579:      echo area (q.v.).  One kind of prompting happens when the
        !           580:      minibuffer is used to read an argument (*note Minibuffer::.); the
        !           581:      echoing which happens when you pause in the middle of typing a
        !           582:      multicharacter key is also a kind of prompting (*note Echo
        !           583:      Area::.).
        !           584: 
        !           585: Quitting
        !           586:      Quitting means cancelling a partially typed command or a running
        !           587:      command, using `C-g'.  *Note Quitting::.
        !           588: 
        !           589: Quoting
        !           590:      Quoting means depriving a character of its usual special
        !           591:      significance. In Emacs this is usually done with `Control-q'. 
        !           592:      What constitutes special significance depends on the context and
        !           593:      on convention.  For example, an "ordinary" character as an Emacs
        !           594:      command inserts itself; so in this context, a special character is
        !           595:      any character that does not normally insert itself (such as DEL,
        !           596:      for example), and quoting it makes it insert itself as if it were
        !           597:      not special.  Not all contexts allow quoting.  *Note Quoting:
        !           598:      Basic.
        !           599: 
        !           600: Read-only Buffer
        !           601:      A read-only buffer is one whose text you are not allowed to change.
        !           602:      Normally Emacs makes buffers read-only when they contain text which
        !           603:      has a special significance to Emacs; for example, Dired buffers.
        !           604:      Visiting a file that is write protected also makes a read-only
        !           605:      buffer. *Note Buffers::.
        !           606: 
        !           607: Recursive Editing Level
        !           608:      A recursive editing level is a state in which part of the
        !           609:      execution of a command involves asking the user to edit some text.
        !           610:       This text may or may not be the same as the text to which the
        !           611:      command was applied. The mode line indicates recursive editing
        !           612:      levels with square brackets (`[' and `]').  *Note Recursive Edit::.
        !           613: 
        !           614: Redisplay
        !           615:      Redisplay is the process of correcting the image on the screen to
        !           616:      correspond to changes that have been made in the text being edited.
        !           617:      *Note Redisplay: Screen.
        !           618: 
        !           619: Regexp
        !           620:      See `regular expression'.
        !           621: 
        !           622: Region
        !           623:      The region is the text between point (q.v.) and the mark (q.v.).
        !           624:      Many commands operate on the text of the region.  *Note Region:
        !           625:      Mark.
        !           626: 
        !           627: Registers
        !           628:      Registers are named slots in which text or buffer positions or
        !           629:      rectangles can be saved for later use.  *Note Registers::.
        !           630: 
        !           631: Regular Expression
        !           632:      A regular expression is a pattern that can match various text
        !           633:      strings; for example, `l[0-9]+' matches `l' followed by one or more
        !           634:      digits.  *Note Regexps::.
        !           635: 
        !           636: Replacement
        !           637:      See `global substitution'.
        !           638: 
        !           639: Restriction
        !           640:      A buffer's restriction is the amount of text, at the beginning or
        !           641:      the end of the buffer, that is temporarily invisible and
        !           642:      inaccessible. Giving a buffer a nonzero amount of restriction is
        !           643:      called narrowing (q.v.).  *Note Narrowing::.
        !           644: 
        !           645: RET
        !           646:      RET is a character that in Emacs runs the command to insert a
        !           647:      newline into the text.  It is also used to terminate most arguments
        !           648:      read in the minibuffer (q.v.).  *Note Return: Characters.
        !           649: 
        !           650: Saving
        !           651:      Saving a buffer means copying its text into the file that was
        !           652:      visited (q.v.) in that buffer.  This is the way text in files
        !           653:      actually gets changed by your Emacs editing.  *Note Saving::.
        !           654: 
        !           655: Scrolling
        !           656:      Scrolling means shifting the text in the Emacs window so as to see
        !           657:      a different part of the buffer.  *Note Scrolling: Display.
        !           658: 
        !           659: Searching
        !           660:      Searching means moving point to the next occurrence of a specified
        !           661:      string.  *Note Search::.
        !           662: 
        !           663: Selecting
        !           664:      Selecting a buffer means making it the current (q.v.) buffer.
        !           665:      *Note Selecting: Buffers.
        !           666: 
        !           667: Self-documentation
        !           668:      Self-documentation is the feature of Emacs which can tell you what
        !           669:      any command does, or give you a list of all commands related to a
        !           670:      topic you specify.  You ask for self-documentation with the help
        !           671:      character, `C-h'.  *Note Help::.
        !           672: 
        !           673: Sentences
        !           674:      Emacs has commands for moving by or killing by sentences. *Note
        !           675:      Sentences::.
        !           676: 
        !           677: Sexp
        !           678:      A sexp (short for `s-expression') is the basic syntactic unit of
        !           679:      Lisp in its textual form: either a list, or Lisp atom.  Many Emacs
        !           680:      commands operate on sexps.  The term `sexp' is generalized to
        !           681:      languages other than Lisp, to mean a syntactically recognizable
        !           682:      expression. *Note Sexps: Lists.
        !           683: 
        !           684: Simultaneous Editing
        !           685:      Simultaneous editing means two users modifying the same file at
        !           686:      once. Simultaneous editing if not detected can cause one user to
        !           687:      lose his work.  Emacs detects all cases of simultaneous editing
        !           688:      and warns the user to investigate them.  *Note Simultaneous
        !           689:      Editing: Interlocking.
        !           690: 
        !           691: String
        !           692:      A string is a kind of Lisp data object which contains a sequence of
        !           693:      characters.  Many Emacs variables are intended to have strings as
        !           694:      values.  The Lisp syntax for a string consists of the characters in
        !           695:      the string with a `"' before and another `"' after.  A `"' that is
        !           696:      part of the string must be written as `\"' and a `\' that is part
        !           697:      of the string must be written as `\\'.  All other characters,
        !           698:      including newline, can be included just by writing them inside the
        !           699:      string; however, escape sequences as in C, such as `\n' for
        !           700:      newline or `\241' using an octal character code, are allowed as
        !           701:      well.
        !           702: 
        !           703: String Substitution
        !           704:      See `global substitution'.
        !           705: 
        !           706: Syntax Table
        !           707:      The syntax table tells Emacs which characters are part of a word,
        !           708:      which characters balance each other like parentheses, etc. *Note
        !           709:      Syntax::.
        !           710: 
        !           711: Tag Table
        !           712:      A tag table is a file that serves as an index to the function
        !           713:      definitions in one or more other files.  *Note Tags::.
        !           714: 
        !           715: Termscript File
        !           716:      A termscript file contains a record of all characters sent by
        !           717:      Emacs to the terminal.  It is used for tracking down bugs in Emacs
        !           718:      redisplay. Emacs does not make a termscript file unless you tell
        !           719:      it to. *Note Bugs::.
        !           720: 
        !           721: Text
        !           722:      Two meanings (*note Text::.):
        !           723: 
        !           724:         * Data consisting of a sequence of characters, as opposed to
        !           725:           binary numbers, images, graphics commands, executable
        !           726:           programs, and the like. The contents of an Emacs buffer are
        !           727:           always text in this sense.
        !           728: 
        !           729:         * Data consisting of written human language, as opposed to
        !           730:           programs, or following the stylistic conventions of human
        !           731:           language.
        !           732: 
        !           733: Top Level
        !           734:      Top level is the normal state of Emacs, in which you are editing
        !           735:      the text of the file you have visited.  You are at top level
        !           736:      whenever you are not in a recursive editing level (q.v.) or the
        !           737:      minibuffer (q.v.), and not in the middle of a command.  You can
        !           738:      get back to top level by aborting (q.v.) and quitting (q.v.). 
        !           739:      *Note Quitting::.
        !           740: 
        !           741: Transposition
        !           742:      Transposing two units of text means putting each one into the place
        !           743:      formerly occupied by the other.  There are Emacs commands to
        !           744:      transpose two adjacent characters, words, sexps (q.v.) or lines
        !           745:      (*note Transpose::.).
        !           746: 
        !           747: Truncation
        !           748:      Truncating text lines in the display means leaving out any text on
        !           749:      a line that does not fit within the right margin of the window
        !           750:      displaying it.  See also `continuation line'. *Note Truncation:
        !           751:      Basic.
        !           752: 
        !           753: Undoing
        !           754:      Undoing means making your previous editing go in reverse, bringing
        !           755:      back the text that existed earlier in the editing session. *Note
        !           756:      Undo::.
        !           757: 
        !           758: Variable
        !           759:      A variable is an object in Lisp that can store an arbitrary value.
        !           760:      Emacs uses some variables for internal purposes, and has others
        !           761:      (known as `options' (q.v.)) just so that you can set their values
        !           762:      to control the behavior of Emacs.  The variables used in Emacs
        !           763:      that you are likely to be interested in are listed in the
        !           764:      Variables Index in this manual.  *Note Variables::, for
        !           765:      information on variables.
        !           766: 
        !           767: Visiting
        !           768:      Visiting a file means loading its contents into a buffer (q.v.)
        !           769:      where they can be edited.  *Note Visiting::.
        !           770: 
        !           771: Whitespace
        !           772:      Whitespace is any run of consecutive formatting characters (space,
        !           773:      tab, newline, and backspace).
        !           774: 
        !           775: Widening
        !           776:      Widening is removing any restriction (q.v.) on the current buffer;
        !           777:      it is the opposite of narrowing (q.v.).  *Note Narrowing::.
        !           778: 
        !           779: Window
        !           780:      Emacs divides the screen into one or more windows, each of which
        !           781:      can display the contents of one buffer (q.v.) at any time. *Note
        !           782:      Screen::, for basic information on how Emacs uses the screen.
        !           783:      *Note Windows::, for commands to control the use of windows.
        !           784: 
        !           785: Word Abbrev
        !           786:      Synonymous with `abbrev'.
        !           787: 
        !           788: Word Search
        !           789:      Word search is searching for a sequence of words, considering the
        !           790:      punctuation between them as insignificant.  *Note Word Search::.
        !           791: 
        !           792: Yanking
        !           793:      Yanking means reinserting text previously killed.  It can be used
        !           794:      to undo a mistaken kill, or for copying or moving text.  Some other
        !           795:      systems call this "pasting".  *Note Yanking::.
        !           796: 
        !           797: 

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