Mercurial > emacs
diff lispref/elisp-vol2.texi @ 4781:6cb9d6d6a46d
Initial revision
| author | Melissa Weisshaus <melissa@gnu.org> |
|---|---|
| date | Thu, 23 Sep 1993 21:00:12 +0000 |
| parents | |
| children | 2e2f1c2aad26 |
line wrap: on
line diff
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/lispref/elisp-vol2.texi Thu Sep 23 21:00:12 1993 +0000 @@ -0,0 +1,1025 @@ +\input texinfo @c -*-texinfo-*- +@c %**start of header +@setfilename elisp +@settitle GNU Emacs Lisp Reference Manual: Volume 2 +@smallbook +@c %**end of header + + +@tex +%%%% Experiment with smaller skip before sections and subsections. +%%%% --rjc 30mar92 + +\global\secheadingskip = 17pt plus 6pt minus 3pt +\global\subsecheadingskip = 14pt plus 6pt minus 3pt + +% The defaults are: +% \secheadingskip = 21pt plus 8pt minus 4pt +% \subsecheadingskip = 17pt plus 8pt minus 4pt +@end tex + +@finalout +@c tex +@c \overfullrule=0pt +@c end tex + +@c Start volume 2 chapter numbering on chapter 21; +@c this must be listed as chapno 20. +@tex +\global\chapno=20 +@end tex + +@c ================================================================ +@c Note: I was unable to figure out how to get .aux files copied +@c properly in the time I had. Hence need to copy .aux file before +@c running Tex. --rjc + +@tex + +\message{} +\message{Redefining contents commands...} +\message{} + +% Special @contents command + +% This inputs fixed up table of contents file rather than create new one. +\global\def\contents{% + \startcontents{Table of Contents}% + \input elisp2-toc-ready.toc + \endgroup + \vfill \eject +} + +% Special @summarycontents command +% This inputs fixed up table of contents file rather than create new one. +\global\def\summarycontents{% + \startcontents{Short Contents}% + % + \let\chapentry = \shortchapentry + \let\unnumbchapentry = \shortunnumberedentry + % We want a true roman here for the page numbers. + \secfonts + \let\rm=\shortcontrm \let\bf=\shortcontbf \let\sl=\shortcontsl + \rm + \advance\baselineskip by 1pt % Open it up a little. + \def\secentry ##1##2##3##4{} + \def\unnumbsecentry ##1##2{} + \def\subsecentry ##1##2##3##4##5{} + \def\unnumbsubsecentry ##1##2{} + \def\subsubsecentry ##1##2##3##4##5##6{} + \def\unnumbsubsubsecentry ##1##2{} + \input elisp2-toc-ready.toc + \endgroup + \vfill \eject +} + +\message{} +\message{Formatting special two volume edition...Volume 2...} +\message{} +@end tex +@c ================================================================ + + +@c ==> This `elisp-small.texi' is a `smallbook' version of the manual. + +@c ==== Following are acceptable over and underfull hboxes in TeX ==== + +@c ----- +@c [163] [164] [165] [166]) (loading.texi Chapter 13 [167] [168] [169] +@c Overfull \hbox (20.5428pt too wide) in paragraph at lines 131--131 +@c []@ninett +@c setenv EMAC-SLOAD-PATH .:/user/bil/emacs:/usr/local/lib/emacs/lisp[] +@c ----- +@c (minibuf.texi Chapter 17 [206] [207] [208] [209] [210] [211] [212] [213] +@c [214] [215] +@c Overfull \hbox (2.09094pt too wide) in paragraph at lines 550--560 +@c @texttt map[] @textrm if @textsl require-match @textrm is +@c @texttt nil[]@textrm , or else with the keymap @texttt minibuffer- +@c ----- +@c (locals.texi Appendix @char 68 [533] [534] +@c Underfull \hbox (badness 2512) in paragraph at lines 4--4 +@c []@chaprm Appendix DStandard Buffer-Local + +@c ------------------------------------------------------------------- + +@c +@c Combine indices. +@synindex cp fn +@syncodeindex vr fn +@syncodeindex ky fn +@syncodeindex pg fn +@syncodeindex tp fn +@c oops: texinfo-format-buffer ignores synindex +@c + +@ifinfo +This file documents GNU Emacs Lisp. + +@c The edition number appears in several places in this file +@c and also in the file intro.texi. +This version is newer than edition 2.1 of the GNU Emacs Lisp Reference +Manual. It corresponds to Emacs Version 19.19. +@c Please REMEMBER to update edition number in *four* places in this file +@c and also in *one* place in ==> intro.texi <== +@c huh? i only found three real places where the edition is stated, and +@c one place where it is not stated explicitly ("this info file is newer +@c than the foobar edition"). --mew 13sep93 + +Published by the Free Software Foundation +675 Massachusetts Avenue +Cambridge, MA 02139 USA + +Copyright (C) 1990, 1991, 1992, 1993 Free Software Foundation, Inc. + +Permission is granted to make and distribute verbatim copies of this +manual provided the copyright notice and this permission notice are +preserved on all copies. + +@ignore +Permission is granted to process this file through TeX and print the +results, provided the printed document carries copying permission notice +identical to this one except for the removal of this paragraph (this +paragraph not being relevant to the printed manual). + +@end ignore +Permission is granted to copy and distribute modified versions of this +manual under the conditions for verbatim copying, provided that the +entire resulting derived work is distributed under the terms of a +permission notice identical to this one. + +Permission is granted to copy and distribute translations of this manual +into another language, under the above conditions for modified versions, +except that this permission notice may be stated in a translation +approved by the Foundation. + +Permission is granted to copy and distribute modified versions of this +manual under the conditions for verbatim copying, provided also that the +section entitled ``GNU General Public License'' is included exactly as +in the original, and provided that the entire resulting derived work is +distributed under the terms of a permission notice identical to this +one. + +Permission is granted to copy and distribute translations of this manual +into another language, under the above conditions for modified versions, +except that the section entitled ``GNU General Public License'' may be +included in a translation approved by the Free Software Foundation +instead of in the original English. +@end ifinfo + +@setchapternewpage odd + +@iftex +@shorttitlepage The GNU Emacs Lisp Reference Manual: Volume 2 +@end iftex +@titlepage +@sp 1 +@center @titlefont{The} +@sp 1 +@center @titlefont{GNU Emacs Lisp} +@sp 1 +@center @titlefont{Reference Manual} +@sp 2 +@center GNU Emacs Version 19.19 +@center for Unix Users +@sp 1 +@center Edition 2.1, September 1993 +@sp 2 +@center @titlefont{Volume 2} +@sp 3 +@center by Bil Lewis, Dan LaLiberte, +@center and the GNU Manual Group +@page +@vskip 0pt plus 1filll +Copyright @copyright{} 1990, 1991, 1992, 1993 Free Software Foundation, Inc. + +@sp 2 +Edition 2.1 @* +Revised for Emacs Version 19.19,@* +September, 1993.@* +@sp 2 +ISBN 1-882114-40-X + +@sp 2 +Published by the Free Software Foundation @* +675 Massachusetts Avenue @* +Cambridge, MA 02139 USA + +@sp 1 +Permission is granted to make and distribute verbatim copies of this +manual provided the copyright notice and this permission notice are +preserved on all copies. + +Permission is granted to copy and distribute modified versions of this +manual under the conditions for verbatim copying, provided also that the +section entitled ``GNU General Public License'' is included +exactly as in the original, and provided that the entire resulting +derived work is distributed under the terms of a permission notice +identical to this one. + +Permission is granted to copy and distribute translations of this manual +into another language, under the above conditions for modified versions, +except that the section entitled ``GNU General Public License'' may be +included in a translation approved by the Free Software Foundation +instead of in the original English. + +@sp 2 +Cover art by Etienne Suvasa. +@end titlepage +@page + +@node Top, Copying, (dir), (dir) + +@ifinfo +This Info file contains the edition 2.1 of the GNU Emacs Lisp Reference +Manual, corresponding to GNU Emacs version 19.19. +@end ifinfo + +@menu +* Copying:: Conditions for copying and changing GNU Emacs. +* Introduction:: Introduction and conventions used. + +* Types of Lisp Object:: Data types in Emacs Lisp. +* Numbers:: Numbers and arithmetic functions. +* Strings and Characters:: Strings, and functions that work on them. +* Lists:: Lists, cons cells, and related functions. +* Sequences Arrays Vectors:: Lists, strings and vectors are called sequences. + Certain functions act on any kind of sequence. + The description of vectors is here as well. +* Symbols:: Symbols represent names, uniquely. + +* Evaluation:: How Lisp expressions are evaluated. +* Control Structures:: Conditionals, loops, nonlocal exits. +* Variables:: Using symbols in programs to stand for values. +* Functions:: A function is a Lisp program + that can be invoked from other functions. +* Macros:: Macros are a way to extend the Lisp language. + +* Loading:: Reading files of Lisp code into Lisp. +* Byte Compilation:: Compilation makes programs run faster. +* Debugging:: Tools and tips for debugging Lisp programs. + +* Streams:: Converting Lisp objects to text and back. +* Minibuffers:: Using the minibuffer to read input. +* Command Loop:: How the editor command loop works, + and how you can call its subroutines. +* Keymaps:: Defining the bindings from keys to commands. +* Modes:: Defining major and minor modes. +* Documentation:: Writing and using documentation strings. + +* Files:: Accessing files. +* Backups and Auto-Saving:: Controlling how backups and auto-save + files are made. +* Buffers:: Creating and using buffer objects. +* Windows:: Manipulating windows and displaying buffers. +* Frames:: Making multiple X windows. +* Positions:: Buffer positions and motion functions. +* Markers:: Markers represent positions and update + automatically when the text is changed. + +* Text:: Examining and changing text in buffers. +* Searching and Matching:: Searching buffers for strings or regexps. +* Syntax Tables:: The syntax table controls word and list parsing. +* Abbrevs:: How Abbrev mode works, and its data structures. + +* Processes:: Running and communicating with subprocesses. +* System Interface:: Getting the user id, system type, environment + variables, and other such things. +* Display:: Parameters controlling screen usage. + The bell. Waiting for input. +* Calendar:: Customizing the calendar and diary. + +Appendices + +* Tips:: Advice for writing Lisp programs. +* GNU Emacs Internals:: Building and dumping Emacs; + internal data structures. +* Standard Errors:: List of all error symbols. +* Standard Buffer-Local Variables:: List of variables local in all buffers. +* Standard Keymaps:: List of standard keymaps. +* Standard Hooks:: List of standard hook variables. + +* Antinews:: Information about Emacs 18. + +* Index:: Index including concepts, functions, variables, + and other terms. + + --- The Detailed Node Listing --- + +Here are other nodes that are inferiors of those already listed, +mentioned here so you can get to them in one step: + +Introduction + +* Caveats:: Flaws and a request for help. +* Lisp History:: Emacs Lisp is descended from Maclisp. +* Conventions:: How the manual is formatted. +* Acknowledgements:: The authors, editors, and sponsors of this manual. + +Conventions + +* Some Terms:: Explanation of terms we use in this manual. +* nil and t:: How the symbols @code{nil} and @code{t} are used. +* Evaluation Notation:: The format we use for examples of evaluation. +* Printing Notation:: The format we use for examples that print output. +* Error Messages:: The format we use for examples of errors. +* Buffer Text Notation:: The format we use for buffer contents in examples. +* Format of Descriptions:: Notation for describing functions, variables, etc. + +Format of Descriptions + +* A Sample Function Description:: +* A Sample Variable Description:: + +Lisp Data Types + +* Printed Representation:: How Lisp objects are represented as text. +* Comments:: Comments and their formatting conventions. +* Programming Types:: Types found in all Lisp systems. +* Editing Types:: Types specific to Emacs. +* Type Predicates:: Tests related to types. +* Equality Predicates:: Tests of equality between any two objects. + +Programming Types + +* Integer Type:: Numbers without fractional parts. +* Floating Point Type:: Numbers with fractional parts and with a large range. +* Character Type:: The representation of letters, numbers and + control characters. +* Sequence Type:: Both lists and arrays are classified as sequences. +* List Type:: Lists gave Lisp its name (not to mention reputation). +* Array Type:: Arrays include strings and vectors. +* String Type:: An (efficient) array of characters. +* Vector Type:: One-dimensional arrays. +* Symbol Type:: A multi-use object that refers to a function, + variable, property list, or itself. +* Lisp Function Type:: A piece of executable code you can call from elsewhere. +* Lisp Macro Type:: A method of expanding an expression into another + expression, more fundamental but less pretty. +* Primitive Function Type:: A function written in C, callable from Lisp. +* Byte-Code Type:: A function written in Lisp, then compiled. +* Autoload Type:: A type used for automatically loading seldom-used + functions. + +List Type + +* Dotted Pair Notation:: An alternative syntax for lists. +* Association List Type:: A specially constructed list. + +Editing Types + +* Buffer Type:: The basic object of editing. +* Window Type:: What makes buffers visible. +* Window Configuration Type::Save what the screen looks like. +* Marker Type:: A position in a buffer. +* Process Type:: A process running on the underlying OS. +* Stream Type:: Receive or send characters. +* Keymap Type:: What function a keystroke invokes. +* Syntax Table Type:: What a character means. + +Numbers + +* Integer Basics:: Representation and range of integers. +* Float Basics:: Representation and range of floating point. +* Predicates on Numbers:: Testing for numbers. +* Comparison of Numbers:: Equality and inequality predicates. +* Arithmetic Operations:: How to add, subtract, multiply and divide. +* Bitwise Operations:: Logical and, or, not, shifting. +* Numeric Conversions:: Converting float to integer and vice versa. +* Transcendental Functions:: Trig, exponential and logarithmic functions. +* Random Numbers:: Obtaining random integers, predictable or not. + +Strings and Characters + +* Intro to Strings:: Basic properties of strings and characters. +* Predicates for Strings:: Testing whether an object is a string or char. +* Creating Strings:: Functions to allocate new strings. +* Text Comparison:: Comparing characters or strings. +* String Conversion:: Converting characters or strings and vice versa. +* Formatting Strings:: @code{format}: Emacs's analog of @code{printf}. +* Character Case:: Case conversion functions. + +Lists + +* Cons Cells:: How lists are made out of cons cells. +* Lists as Boxes:: Graphical notation to explain lists. +* List-related Predicates:: Is this object a list? Comparing two lists. +* List Elements:: Extracting the pieces of a list. +* Building Lists:: Creating list structure. +* Modifying Lists:: Storing new pieces into an existing list. +* Sets And Lists:: A list can represent a finite mathematical set. +* Association Lists:: A list can represent a finite relation or mapping. + +Modifying Existing List Structure + +* Setcar:: Replacing an element in a list. +* Setcdr:: Replacing part of the list backbone. + This can be used to remove or add elements. +* Rearrangement:: Reordering the elements in a list; combining lists. + +Sequences, Arrays, and Vectors + +* Sequence Functions:: Functions that accept any kind of sequence. +* Arrays:: Characteristics of arrays in Emacs Lisp. +* Array Functions:: Functions specifically for arrays. +* Vectors:: Functions specifically for vectors. + +Symbols + +* Symbol Components:: Symbols have names, values, function definitions + and property lists. +* Definitions:: A definition says how a symbol will be used. +* Creating Symbols:: How symbols are kept unique. +* Property Lists:: Each symbol has a property list + for recording miscellaneous information. + +Evaluation + +* Intro Eval:: Evaluation in the scheme of things. +* Eval:: How to invoke the Lisp interpreter explicitly. +* Forms:: How various sorts of objects are evaluated. +* Quoting:: Avoiding evaluation (to put constants in + the program). + +Kinds of Forms + +* Self-Evaluating Forms:: Forms that evaluate to themselves. +* Symbol Forms:: Symbols evaluate as variables. +* Classifying Lists:: How to distinguish various sorts of list forms. +* Function Forms:: Forms that call functions. +* Macro Forms:: Forms that call macros. +* Special Forms:: ``Special forms'' are idiosyncratic primitives, + most of them extremely important. +* Autoloading:: Functions set up to load files + containing their real definitions. + +Control Structures + +* Sequencing:: Evaluation in textual order. +* Conditionals:: @code{if}, @code{cond}. +* Combining Conditions:: @code{and}, @code{or}, @code{not}. +* Iteration:: @code{while} loops. +* Nonlocal Exits:: Jumping out of a sequence. + +Nonlocal Exits + +* Catch and Throw:: Nonlocal exits for the program's own purposes. +* Examples of Catch:: Showing how such nonlocal exits can be written. +* Errors:: How errors are signaled and handled. +* Cleanups:: Arranging to run a cleanup form if an + error happens. + +Errors + +* Signaling Errors:: How to report an error. +* Processing of Errors:: What Emacs does when you report an error. +* Handling Errors:: How you can trap errors and continue execution. +* Error Names:: How errors are classified for trapping them. + +Variables + +* Global Variables:: Variable values that exist permanently, everywhere. +* Constant Variables:: Certain "variables" have values that never change. +* Local Variables:: Variable values that exist only temporarily. +* Void Variables:: Symbols that lack values. +* Defining Variables:: A definition says a symbol is used as a variable. +* Accessing Variables:: Examining values of variables whose names + are known only at run time. +* Setting Variables:: Storing new values in variables. +* Variable Scoping:: How Lisp chooses among local and global values. +* Buffer-Local Variables:: Variable values in effect only in one buffer. + +Scoping Rules for Variable Bindings + +* Scope:: Scope means where in the program a value + is visible. Comparison with other languages. +* Extent:: Extent means how long in time a value exists. +* Impl of Scope:: Two ways to implement dynamic scoping. +* Using Scoping:: How to use dynamic scoping carefully and + avoid problems. + +Buffer-Local Variables + +* Intro to Buffer-Local:: Introduction and concepts. +* Creating Buffer-Local:: Creating and destroying buffer-local bindings. +* Default Value:: The default value is seen in buffers + that don't have their own local values. + +Functions + +* What Is a Function:: Lisp functions vs primitives; terminology. +* Lambda Expressions:: How functions are expressed as Lisp objects. +* Function Names:: A symbol can serve as the name of a function. +* Defining Functions:: Lisp expressions for defining functions. +* Calling Functions:: How to use an existing function. +* Mapping Functions:: Applying a function to each element of a list, etc. +* Anonymous Functions:: Lambda-expressions are functions with no names. +* Function Cells:: Accessing or setting the function definition + of a symbol. +* Related Topics:: Cross-references to specific Lisp primitives + that have a special bearing on how + functions work. + +Lambda Expressions + +* Lambda Components:: The parts of a lambda expression. +* Simple Lambda:: A simple example. +* Argument List:: Details and special features of argument lists. +* Function Documentation:: How to put documentation in a function. + +Macros + +* Simple Macro:: A basic example. +* Expansion:: How, when and why macros are expanded. +* Compiling Macros:: How macros are expanded by the compiler. +* Defining Macros:: How to write a macro definition. +* Backquote:: Easier construction of list structure. +* Problems with Macros:: Don't evaluate the macro arguments too many times. + Don't hide the user's variables. + +Loading + +* How Programs Do Loading:: The @code{load} function and others. +* Autoload:: Setting up a function to autoload. +* Features:: Loading a library if it isn't already loaded. +* Repeated Loading:: Precautions about loading a file twice. + +Byte Compilation + +* Compilation Functions:: Byte compilation functions. +* Disassembly:: Disassembling byte-code; how to read byte-code. + +Debugging Lisp Programs + +* Debugger:: How the Emacs Lisp debugger is implemented. +* Syntax Errors:: How to find syntax errors. +* Compilation Errors:: How to find errors that show up in + byte compilation. + +The Lisp Debugger + +* Error Debugging:: Entering the debugger when an error happens. +* Function Debugging:: Entering it when a certain function is called. +* Explicit Debug:: Entering it at a certain point in the program. +* Using Debugger:: What the debugger does; what you see while in it. +* Debugger Commands:: Commands used while in the debugger. +* Invoking the Debugger:: How to call the function @code{debug}. +* Internals of Debugger:: Subroutines of the debugger, and global variables. + +Debugging Invalid Lisp Syntax + +* Excess Open:: How to find a spurious open paren or missing close. +* Excess Close:: How to find a spurious close paren or missing open. + +Reading and Printing Lisp Objects + +* Streams Intro:: Overview of streams, reading and printing. +* Input Streams:: Various data types that can be used as + input streams. +* Input Functions:: Functions to read Lisp objects from text. +* Output Streams:: Various data types that can be used as + output streams. +* Output Functions:: Functions to print Lisp objects as text. + +Minibuffers + +* Intro to Minibuffers:: Basic information about minibuffers. +* Text from Minibuffer:: How to read a straight text string. +* Object from Minibuffer:: How to read a Lisp object or expression. +* Completion:: How to invoke and customize completion. +* Yes-or-No Queries:: Asking a question with a simple answer. +* Minibuffer Misc:: Various customization hooks and variables. + +Completion + +* Basic Completion:: Low-level functions for completing strings. + (These are too low level to use the minibuffer.) +* Programmed Completion:: Finding the completions for a given file name. +* Minibuffer Completion:: Invoking the minibuffer with completion. +* Completion Commands:: Minibuffer commands that do completion. +* High-Level Completion:: Convenient special cases of completion + (reading buffer name, file name, etc.) +* Reading File Names:: Using completion to read file names. +* Lisp Symbol Completion:: Completing the name of a symbol. + +Command Loop + +* Command Overview:: How the command loop reads commands. +* Defining Commands:: Specifying how a function should read arguments. +* Interactive Call:: Calling a command, so that it will read arguments. +* Command Loop Info:: Variables set by the command loop for you to examine. +* Input Events:: What input looks like when you read it. +* Reading Input:: How to read input events from the keyboard or mouse. +* Waiting:: Waiting for user input or elapsed time. +* Quitting:: How @kbd{C-g} works. How to catch or defer quitting. +* Prefix Command Arguments:: How the commands to set prefix args work. +* Recursive Editing:: Entering a recursive edit, + and why you usually shouldn't. +* Disabling Commands:: How the command loop handles disabled commands. +* Command History:: How the command history is set up, and how accessed. +* Keyboard Macros:: How keyboard macros are implemented. + +Defining Commands + +* Using Interactive:: General rules for @code{interactive}. +* Interactive Codes:: The standard letter-codes for reading arguments + in various ways. +* Interactive Examples:: Examples of how to read interactive arguments. + +Keymaps + +* Keymap Terminology:: Definitions of terms pertaining to keymaps. +* Format of Keymaps:: What a keymap looks like as a Lisp object. +* Creating Keymaps:: Functions to create and copy keymaps. +* Inheritance and Keymaps:: How one keymap can inherit the bindings + of another keymap. +* Prefix Keys:: Defining a key with a keymap as its definition. +* Menu Keymaps:: A keymap can define a menu for X windows + or for use from the terminal. +* Active Keymaps:: Each buffer has a local keymap + to override the standard (global) bindings. + Each minor mode can also override them. +* Key Lookup:: How extracting elements from keymaps works. +* Functions for Key Lookup:: How to request key lookup. +* Changing Key Bindings:: Redefining a key in a keymap. +* Key Binding Commands:: Interactive interfaces for redefining keys. +* Scanning Keymaps:: Looking through all keymaps, for printing help. + +Major and Minor Modes + +* Major Modes:: Defining major modes. +* Minor Modes:: Defining minor modes. +* Mode Line Format:: Customizing the text that appears in the mode line. +* Hooks:: How to use hooks; how to write code that + provides hooks. + +Major Modes + +* Major Mode Conventions:: Coding conventions for keymaps, etc. +* Example Major Modes:: Text mode and Lisp modes. +* Auto Major Mode:: How Emacs chooses the major mode automatically. +* Mode Help:: Finding out how to use a mode. + +Minor Modes + +* Minor Mode Conventions:: Tips for writing a minor mode. +* Keymaps and Minor Modes:: How a minor mode can have its own keymap. + +Mode Line Format + +* Mode Line Data:: The data structure that controls the mode line. +* Mode Line Variables:: Variables used in that data structure. +* %-Constructs:: Putting information into a mode line. + +Documentation + +* Documentation Basics:: Good style for doc strings. + Where to put them. How Emacs stores them. +* Accessing Documentation:: How Lisp programs can access doc strings. +* Keys in Documentation:: Substituting current key bindings. +* Describing Characters:: Making printable descriptions of + non-printing characters and key sequences. +* Help Functions:: Subroutines used by Emacs help facilities. + +Files + +* Visiting Files:: Reading files into Emacs buffers for editing. +* Saving Buffers:: Writing changed buffers back into files. +* Reading from Files:: Reading files into other buffers. +* Writing to Files:: Writing new files from parts of buffers. +* File Locks:: Locking and unlocking files, to prevent + simultaneous editing by two people. +* Information about Files:: Testing existence, accessibility, size of files. +* Contents of Directories:: Getting a list of the files in a directory. +* Changing File Attributes:: Renaming files, changing protection, etc. +* File Names:: Decomposing and expanding file names. + +Visiting Files + +* Visiting Functions:: The usual interface functions for visiting. +* Subroutines of Visiting:: Lower-level subroutines that they use. + +Information about Files + +* Testing Accessibility:: Is a given file readable? Writable? +* Kinds of Files:: Is it a directory? A link? +* File Attributes:: How large is it? Any other names? Etc. + +File Names + +* File Name Components:: The directory part of a file name, and the rest. +* Directory Names:: A directory's name as a directory + is different from its name as a file. +* Relative File Names:: Some file names are relative to a + current directory. +* File Name Expansion:: Converting relative file names to absolute ones. +* Unique File Names:: Generating names for temporary files. +* File Name Completion:: Finding the completions for a given file name. + +Backups and Auto-Saving + +* Backup Files:: How backup files are made; how their names + are chosen. +* Auto-Saving:: How auto-save files are made; how their + names are chosen. +* Reverting:: @code{revert-buffer}, and how to customize + what it does. + +Backup Files + +* Making Backups:: How Emacs makes backup files, and when. +* Rename or Copy:: Two alternatives: renaming the old file + or copying it. +* Numbered Backups:: Keeping multiple backups for each source file. +* Backup Names:: How backup file names are computed; customization. + +Buffers + +* Buffer Basics:: What is a buffer? +* Buffer Names:: Accessing and changing buffer names. +* Buffer File Name:: The buffer file name indicates which file + is visited. +* Buffer Modification:: A buffer is @dfn{modified} if it needs to be saved. +* Modification Time:: Determining whether the visited file was changed + ``behind Emacs's back''. +* Read Only Buffers:: Modifying text is not allowed in a + read-only buffer. +* The Buffer List:: How to look at all the existing buffers. +* Creating Buffers:: Functions that create buffers. +* Killing Buffers:: Buffers exist until explicitly killed. +* Current Buffer:: Designating a buffer as current + so primitives will access its contents. + +Windows + +* Basic Windows:: Basic information on using windows. +* Splitting Windows:: Splitting one window into two windows. +* Deleting Windows:: Deleting a window gives its space to other windows. +* Selecting Windows:: The selected window is the one that you edit in. +* Cyclic Window Ordering:: Moving around the existing windows. +* Buffers and Windows:: Each window displays the contents of a buffer. +* Displaying Buffers:: Higher-lever functions for displaying a buffer + and choosing a window for it. +* Window Point:: Each window has its own location of point. +* Window Start:: The display-start position controls which text + is on-screen in the window. +* Vertical Scrolling:: Moving text up and down in the window. +* Horizontal Scrolling:: Moving text sideways on the window. +* Size of Window:: Accessing the size of a window. +* Resizing Windows:: Changing the size of a window. +* Window Configurations:: Saving and restoring the state of the screen. + +Positions + +* Point:: The special position where editing takes place. +* Motion:: Changing point. +* Excursions:: Temporary motion and buffer changes. +* Narrowing:: Restricting editing to a portion of the buffer. + +Motion + +* Character Motion:: Moving in terms of characters. +* Word Motion:: Moving in terms of words. +* Buffer End Motion:: Moving to the beginning or end of the buffer. +* Text Lines:: Moving in terms of lines of text. +* Screen Lines:: Moving in terms of lines as displayed. +* Vertical Motion:: Implementation of @code{next-line} and + @code{previous-line}. +* List Motion:: Moving by parsing lists and sexps. +* Skipping Characters:: Skipping characters belonging to a certain set. + +Markers + +* Overview of Markers:: The components of a marker, and how it relocates. +* Predicates on Markers:: Testing whether an object is a marker. +* Creating Markers:: Making empty markers or markers at certain places. +* Information from Markers:: Finding the marker's buffer or character + position. +* Changing Markers:: Moving the marker to a new buffer or position. +* The Mark:: How ``the mark'' is implemented with a marker. +* The Region:: How to access ``the region''. + +Text + +* Near Point:: Examining text in the vicinity of point. +* Buffer Contents:: Examining text in a general fashion. +* Insertion:: Adding new text to a buffer. +* Commands for Insertion:: User-level commands to insert text. +* Deletion:: Removing text from a buffer. +* User-Level Deletion:: User-level commands to delete text. +* The Kill Ring:: Where removed text sometimes is saved for + later use. +* Undo:: Undoing changes to the text of a buffer. +* Auto Filling:: How auto-fill mode is implemented to break lines. +* Filling:: Functions for explicit filling. +* Sorting:: Functions for sorting parts of the buffer. +* Indentation:: Functions to insert or adjust indentation. +* Columns:: Computing horizontal positions, and using them. +* Case Changes:: Case conversion of parts of the buffer. +* Substitution:: Replacing a given character wherever it appears. +* Underlining:: Inserting or deleting underlining-by-overstrike. +* Registers:: How registers are implemented. Accessing + the text or position stored in a register. + +The Kill Ring + +* Kill Ring Concepts:: What text looks like in the kill ring. +* Kill Functions:: Functions that kill text. +* Yank Commands:: Commands that access the kill ring. +* Low Level Kill Ring:: Functions and variables for kill ring access. +* Internals of Kill Ring:: Variables that hold kill-ring data. + +Indentation + +* Primitive Indent:: Functions used to count and insert indentation. +* Mode-Specific Indent:: Customize indentation for different modes. +* Region Indent:: Indent all the lines in a region. +* Relative Indent:: Indent the current line based on previous lines. +* Indent Tabs:: Adjustable, typewriter-like tab stops. +* Motion by Indent:: Move to first non-blank character. + +Searching and Matching + +* String Search:: Search for an exact match. +* Regular Expressions:: Describing classes of strings. +* Regexp Search:: Searching for a match for a regexp. +* Match Data:: Finding out which part of the text matched + various parts of a regexp, after regexp search. +* Saving Match Data:: Saving and restoring this information. +* Standard Regexps:: Useful regexps for finding sentences, pages,... +* Searching and Case:: Case-independent or case-significant searching. + +Regular Expressions + +* Syntax of Regexps:: Rules for writing regular expressions. +* Regexp Example:: Illustrates regular expression syntax. + +Syntax Tables + +* Syntax Descriptors:: How characters are classified. +* Syntax Table Functions:: How to create, examine and alter syntax tables. +* Parsing Expressions:: Parsing balanced expressions + using the syntax table. +* Standard Syntax Tables:: Syntax tables used by various major modes. +* Syntax Table Internals:: How syntax table information is stored. + +Syntax Descriptors + +* Syntax Class Table:: Table of syntax classes. +* Syntax Flags:: Additional flags each character can have. + +Abbrevs And Abbrev Expansion + +* Abbrev Mode:: Setting up Emacs for abbreviation. +* Tables: Abbrev Tables. Creating and working with abbrev tables. +* Defining Abbrevs:: Specifying abbreviations and their expansions. +* Files: Abbrev Files. Saving abbrevs in files. +* Expansion: Abbrev Expansion. Controlling expansion; expansion subroutines. +* Standard Abbrev Tables:: Abbrev tables used by various major modes. + +Processes + +* Subprocess Creation:: Functions that start subprocesses. +* Synchronous Processes:: Details of using synchronous subprocesses. +* Asynchronous Processes:: Starting up an asynchronous subprocess. +* Deleting Processes:: Eliminating an asynchronous subprocess. +* Process Information:: Accessing run-status and other attributes. +* Input to Processes:: Sending input to an asynchronous subprocess. +* Signals to Processes:: Stopping, continuing or interrupting + an asynchronous subprocess. +* Output from Processes:: Collecting output from an asynchronous subprocess. +* Sentinels:: Sentinels run when process run-status changes. +* TCP:: Opening network connections. + +Receiving Output from Processes + +* Process Buffers:: If no filter, output is put in a buffer. +* Filter Functions:: Filter functions accept output from the process. +* Accepting Output:: How to wait until process output arrives. + +Operating System Interface + +* Starting Up:: Customizing Emacs start-up processing. +* Getting Out:: How exiting works (permanent or temporary). +* System Environment:: Distinguish the name and kind of system. +* Terminal Input:: Recording terminal input for debugging. +* Terminal Output:: Recording terminal output for debugging. +* Flow Control:: How to turn output flow control on or off. +* Batch Mode:: Running Emacs without terminal interaction. + +Starting Up Emacs + +* Start-up Summary:: Sequence of actions Emacs performs at start-up. +* Init File:: Details on reading the init file (@file{.emacs}). +* Terminal-Specific:: How the terminal-specific Lisp file is read. +* Command Line Arguments:: How command line arguments are processed, + and how you can customize them. + +Getting out of Emacs + +* Killing Emacs:: Exiting Emacs irreversibly. +* Suspending Emacs:: Exiting Emacs reversibly. + +Emacs Display + +* Refresh Screen:: Clearing the screen and redrawing everything on it. +* Truncation:: Folding or wrapping long text lines. +* The Echo Area:: Where messages are displayed. +* Selective Display:: Hiding part of the buffer text. +* Overlay Arrow:: Display of an arrow to indicate position. +* Temporary Displays:: Displays that go away automatically. +* Waiting:: Forcing display update and waiting for user. +* Blinking:: How Emacs shows the matching open parenthesis. +* Usual Display:: How control characters are displayed. +* Beeping:: Audible signal to the user. +* Window Systems:: Which window system is being used. + +GNU Emacs Internals + +* Building Emacs:: How to preload Lisp libraries into Emacs. +* Pure Storage:: A kludge to make preloaded Lisp functions sharable. +* Garbage Collection:: Reclaiming space for Lisp objects no longer used. +* Object Internals:: Data formats of buffers, windows, processes. +* Writing Emacs Primitives:: Writing C code for Emacs. + +Object Internals + +* Buffer Internals:: Components of a buffer structure. +* Window Internals:: Components of a window structure. +* Process Internals:: Components of a process structure. +@end menu + +@c ================ Volume 1 ================ + +@c include intro.texi +@c include objects.texi +@c include numbers.texi +@c include strings.texi + +@c include lists.texi +@c include sequences.texi +@c include symbols.texi +@c include eval.texi + +@c include control.texi +@c include variables.texi +@c include functions.texi +@c include macros.texi + +@c include loading.texi +@c include compile.texi +@c include debugging.texi +@c include streams.texi + +@c include minibuf.texi +@c include commands.texi +@c include keymaps.texi +@c include modes.texi + +@c ================ Beginning of Volume 2 ================ + +@include help.texi +@include files.texi +@include backups.texi +@include buffers.texi + +@include windows.texi +@include frames.texi +@include positions.texi +@include markers.texi +@include text.texi + +@include searching.texi +@include syntax.texi +@include abbrevs.texi + +@include processes.texi +@include os.texi +@include display.texi +@include calendar.texi + +@c MOVE to Emacs Manual: include misc-modes.texi + +@c appendices + +@c REMOVE this: include non-hacker.texi + +@include tips.texi +@include internals.texi +@include errors.texi +@include locals.texi +@include maps.texi +@include hooks.texi +@include anti.texi + +@include index-vol2.texi + +@page +@c Print the tables of contents +@summarycontents +@contents +@c That's all + +@bye + + +These words prevent "local variables" above from confusing Emacs.