elisp.texi 68 KB
Newer Older
Richard M. Stallman's avatar
Richard M. Stallman committed
1 2 3 4 5 6
\input texinfo  @c -*-texinfo-*-
@c %**start of header
@setfilename elisp
@settitle GNU Emacs Lisp Reference Manual
@c %**end of header

7 8
@c Version of the manual and of Emacs.
@c Please remember to update the edition number in README as well.
Richard M. Stallman's avatar
Richard M. Stallman committed
9
@set VERSION  2.9
Chong Yidong's avatar
Chong Yidong committed
10
@set EMACSVER 22.0.99
11

12
@dircategory Emacs
13
@direntry
14
* Elisp: (elisp).       The Emacs Lisp Reference Manual.
15 16
@end direntry

Karl Berry's avatar
Karl Berry committed
17 18 19 20
@c in general, keep the following line commented out, unless doing a
@c copy of this manual that will be published.  the manual should go
@c onto the distribution in the full, 8.5 x 11" size.
@c set smallbook
Karl Berry's avatar
Karl Berry committed
21 22

@ifset smallbook
23
@smallbook
Karl Berry's avatar
Karl Berry committed
24
@end ifset
25 26 27 28 29 30

@c per rms and peterb, use 10pt fonts for the main text, mostly to
@c save on paper cost.  Also, do not declare @setchapternewpage odd,
@c for the same reason. Do this inside @tex for now, so the
@c last-released makeinfo does not complain.
@tex
Karl Berry's avatar
Karl Berry committed
31
@ifset smallbook
32
@fonttextsize 10
Karl Berry's avatar
Karl Berry committed
33 34
@end ifset
\global\hbadness=6666 % don't worry about not-too-underfull boxes
Karl Berry's avatar
Karl Berry committed
35 36
\global\let\urlcolor=\Black % don't print links in grayscale
\global\let\linkcolor=\Black
37
@end tex
Gerd Moellmann's avatar
Gerd Moellmann committed
38 39 40 41 42 43 44 45

@c Combine indices.
@synindex cp fn
@syncodeindex vr fn
@syncodeindex ky fn
@syncodeindex pg fn
@c We use the "type index" to index new functions and variables.
@c @syncodeindex tp fn
46

Karl Berry's avatar
Karl Berry committed
47
@copying
Karl Berry's avatar
Karl Berry committed
48 49
This is edition @value{VERSION} of the GNU Emacs Lisp Reference Manual,@*
corresponding to Emacs version @value{EMACSVER}.
Richard M. Stallman's avatar
Richard M. Stallman committed
50

51
Copyright @copyright{} 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1998,
52 53
1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007  Free Software
Foundation, Inc.
Richard M. Stallman's avatar
Richard M. Stallman committed
54

Karl Berry's avatar
Karl Berry committed
55
@quotation
Gerd Moellmann's avatar
Gerd Moellmann committed
56
Permission is granted to copy, distribute and/or modify this document
57
under the terms of the GNU Free Documentation License, Version 1.2 or
Gerd Moellmann's avatar
Gerd Moellmann committed
58
any later version published by the Free Software Foundation; with the
59 60
Invariant Sections being ``GNU General Public License,'' with the
Front-Cover texts being ``A GNU Manual,'' and with the Back-Cover
Karl Berry's avatar
Karl Berry committed
61
Texts as in (a) below.  A copy of the license is included in the
62
section entitled ``GNU Free Documentation License.''
Gerd Moellmann's avatar
Gerd Moellmann committed
63 64 65 66

(a) The FSF's Back-Cover Text is: ``You have freedom to copy and modify
this GNU Manual, like GNU software.  Copies published by the Free
Software Foundation raise funds for GNU development.''
Karl Berry's avatar
Karl Berry committed
67 68
@end quotation
@end copying
Richard M. Stallman's avatar
Richard M. Stallman committed
69 70 71

@titlepage
@title GNU Emacs Lisp Reference Manual
72
@subtitle For Emacs Version @value{EMACSVER}
Karl Berry's avatar
Karl Berry committed
73
@subtitle Revision @value{VERSION}, April 2007
Richard M. Stallman's avatar
Richard M. Stallman committed
74 75 76 77 78

@author by Bil Lewis, Dan LaLiberte, Richard Stallman
@author and the GNU Manual Group
@page
@vskip 0pt plus 1filll
Karl Berry's avatar
Karl Berry committed
79
@insertcopying
Richard M. Stallman's avatar
Richard M. Stallman committed
80

Karl Berry's avatar
Karl Berry committed
81
@sp 2
Richard M. Stallman's avatar
Richard M. Stallman committed
82
Published by the Free Software Foundation @*
Karl Berry's avatar
Karl Berry committed
83 84 85
51 Franklin St, Fifth Floor @*
Boston, MA 02110-1301 @*
USA @*
Richard M. Stallman's avatar
Richard M. Stallman committed
86
ISBN 1-882114-74-4
Richard M. Stallman's avatar
Richard M. Stallman committed
87

Karl Berry's avatar
Karl Berry committed
88
@sp 2
Richard M. Stallman's avatar
Richard M. Stallman committed
89 90
Cover art by Etienne Suvasa.
@end titlepage
91 92 93 94 95 96


@c Print the tables of contents
@summarycontents
@contents

Richard M. Stallman's avatar
Richard M. Stallman committed
97

98
@ifnottex
Gerd Moellmann's avatar
Gerd Moellmann committed
99
@node Top, Introduction, (dir), (dir)
100
@top Emacs Lisp
Richard M. Stallman's avatar
Richard M. Stallman committed
101

102
This Info file contains edition @value{VERSION} of the GNU Emacs Lisp
103
Reference Manual, corresponding to GNU Emacs version @value{EMACSVER}.
Gerd Moellmann's avatar
Gerd Moellmann committed
104
@end ifnottex
Richard M. Stallman's avatar
Richard M. Stallman committed
105 106 107 108

@menu
* Introduction::            Introduction and conventions used.

109
* Lisp Data Types::         Data types of objects in Emacs Lisp.
Richard M. Stallman's avatar
Richard M. Stallman committed
110 111 112 113 114 115
* 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.
116
* Hash Tables::             Very fast lookup-tables.
Richard M. Stallman's avatar
Richard M. Stallman committed
117 118 119 120 121 122 123 124
* 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.
125
* Customization::           Writing customization declarations.
Richard M. Stallman's avatar
Richard M. Stallman committed
126 127 128

* Loading::                 Reading files of Lisp code into Lisp.
* Byte Compilation::        Compilation makes programs run faster.
129
* Advising Functions::      Adding to the definition of a function.
Richard M. Stallman's avatar
Richard M. Stallman committed
130 131
* Debugging::               Tools and tips for debugging Lisp programs.

132
* Read and Print::          Converting Lisp objects to text and back.
Richard M. Stallman's avatar
Richard M. Stallman committed
133 134 135 136 137 138 139 140 141 142 143 144
* 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.
145
* Frames::		    Making multiple system-level windows.
Richard M. Stallman's avatar
Richard M. Stallman committed
146 147 148 149 150
* 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.
151
* Non-ASCII Characters::    Non-ASCII text in buffers and strings.
Richard M. Stallman's avatar
Richard M. Stallman committed
152 153 154 155 156
* 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.
Phillip Rulon's avatar
Phillip Rulon committed
157
* Display::	            Features for controlling the screen display.
Gerd Moellmann's avatar
Gerd Moellmann committed
158 159
* System Interface::        Getting the user id, system type, environment
                              variables, and other such things.
Richard M. Stallman's avatar
Richard M. Stallman committed
160 161 162

Appendices

163
* Antinews::                Info for users downgrading to Emacs 21.
Werner LEMBERG's avatar
Werner LEMBERG committed
164
* GNU Free Documentation License:: The license for this documentation
Gerd Moellmann's avatar
Gerd Moellmann committed
165
* GPL::                     Conditions for copying and changing GNU Emacs.
166
* Tips::                    Advice and coding conventions for Emacs Lisp.
Richard M. Stallman's avatar
Richard M. Stallman committed
167 168 169
* GNU Emacs Internals::     Building and dumping Emacs;
                              internal data structures.
* Standard Errors::         List of all error symbols.
170 171
* Standard Buffer-Local Variables::
                            List of variables buffer-local in all buffers.
Richard M. Stallman's avatar
Richard M. Stallman committed
172 173 174 175 176 177
* Standard Keymaps::        List of standard keymaps.
* Standard Hooks::          List of standard hook variables.

* Index::                   Index including concepts, functions, variables,
                              and other terms.

178
@ignore
179
* New Symbols::             New functions and variables in Emacs @value{EMACSVER}.
180
@end ignore
181

182 183 184 185 186 187 188 189
@c Do NOT modify the following 3 lines!  They must have this form to
@c be correctly identified by `texinfo-multiple-files-update'.  In
@c particular, the detailed menu header line MUST be identical to the
@c value of `texinfo-master-menu-header'.  See texnfo-upd.el.

@detailmenu
 --- The Detailed Node Listing ---
 ---------------------------------
Richard M. Stallman's avatar
Richard M. Stallman committed
190 191 192 193 194 195 196 197 198

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.
199
* Version Info::            Which Emacs version is running?
Richard M. Stallman's avatar
Richard M. Stallman committed
200 201 202 203 204 205 206 207 208 209 210 211 212 213
* 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

214 215 216 217
* A Sample Function Description::  A description of an imaginary
                                     function, @code{foo}.
* A Sample Variable Description::  A description of an imaginary
                                     variable, @code{electric-future-map}.
Richard M. Stallman's avatar
Richard M. Stallman committed
218 219 220 221 222 223 224

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.
225
* Circular Objects::            Read syntax for circular structure.
Richard M. Stallman's avatar
Richard M. Stallman committed
226 227 228 229 230 231 232 233
* 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
Phillip Rulon's avatar
Phillip Rulon committed
234
                          control characters.
235 236
* Symbol Type::         A multi-use object that refers to a function,
                        variable, property list, or itself.
Richard M. Stallman's avatar
Richard M. Stallman committed
237
* Sequence Type::       Both lists and arrays are classified as sequences.
238
* Cons Cell Type::      Cons cells, and lists (which are made from cons cells).
Richard M. Stallman's avatar
Richard M. Stallman committed
239 240 241
* Array Type::          Arrays include strings and vectors.
* String Type::         An (efficient) array of characters.
* Vector Type::         One-dimensional arrays.
242 243 244
* Char-Table Type::     One-dimensional sparse arrays indexed by characters.
* Bool-Vector Type::    One-dimensional arrays of @code{t} or @code{nil}.
* Hash Table Type::     Super-fast lookup tables.
245 246
* Function Type::       A piece of executable code you can call from elsewhere.
* Macro Type::          A method of expanding an expression into another
Richard M. Stallman's avatar
Richard M. Stallman committed
247 248 249 250
                          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
Phillip Rulon's avatar
Phillip Rulon committed
251
                          functions.
Richard M. Stallman's avatar
Richard M. Stallman committed
252

253 254 255 256 257 258 259 260
Character Type

* Basic Char Syntax::       Syntax for regular characters.
* General Escape Syntax::   How to specify characters by their codes.
* Ctl-Char Syntax::         Syntax for control characters.
* Meta-Char Syntax::        Syntax for meta-characters.
* Other Char Bits::         Syntax for hyper-, super-, and alt-characters.

261
Cons Cell and List Types
Richard M. Stallman's avatar
Richard M. Stallman committed
262

263
* Box Diagrams::            Drawing pictures of lists.
Richard M. Stallman's avatar
Richard M. Stallman committed
264 265 266
* Dotted Pair Notation::    An alternative syntax for lists.
* Association List Type::   A specially constructed list.

267 268 269 270 271 272 273
String Type

* Syntax for Strings::      How to specify Lisp strings.
* Non-ASCII in Strings::    International characters in strings.
* Nonprinting Characters::  Literal unprintable characters in strings.
* Text Props and Strings::  Strings with text properties.

Richard M. Stallman's avatar
Richard M. Stallman committed
274 275 276
Editing Types

* Buffer Type::             The basic object of editing.
277
* Marker Type::             A position in a buffer.
Richard M. Stallman's avatar
Richard M. Stallman committed
278
* Window Type::             What makes buffers visible.
279
* Frame Type::		    Windows subdivide frames.
280 281
* Window Configuration Type::  Recording the way a frame is subdivided.
* Frame Configuration Type::   Recording the status of all frames.
Richard M. Stallman's avatar
Richard M. Stallman committed
282 283 284
* Process Type::            A process running on the underlying OS.
* Stream Type::             Receive or send characters.
* Keymap Type::             What function a keystroke invokes.
285
* Overlay Type::            How an overlay is represented.
Richard M. Stallman's avatar
Richard M. Stallman committed
286 287 288

Numbers

289 290 291 292 293 294 295 296 297 298
* 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.
* Numeric Conversions::	    Converting float to integer and vice versa.
* Arithmetic Operations::   How to add, subtract, multiply and divide.
* Rounding Operations::     Explicitly rounding floating point numbers.
* Bitwise Operations::      Logical and, or, not, shifting.
* Math Functions::          Trig, exponential and logarithmic functions.
* Random Numbers::          Obtaining random integers, predictable or not.
Richard M. Stallman's avatar
Richard M. Stallman committed
299 300 301 302 303 304

Strings and Characters

* String Basics::           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.
305
* Modifying Strings::         Altering the contents of an existing string.
Richard M. Stallman's avatar
Richard M. Stallman committed
306
* Text Comparison::         Comparing characters or strings.
307
* String Conversion::       Converting characters to strings and vice versa.
308
* Formatting Strings::      @code{format}: Emacs's analogue of @code{printf}.
309
* Case Conversion::         Case conversion functions.
310
* Case Tables::		    Customizing case conversion.
Richard M. Stallman's avatar
Richard M. Stallman committed
311 312 313 314 315 316 317

Lists

* Cons Cells::              How lists are made out of cons cells.
* List-related Predicates:: Is this object a list?  Comparing two lists.
* List Elements::           Extracting the pieces of a list.
* Building Lists::          Creating list structure.
318
* List Variables::          Modifying lists stored in variables.
Richard M. Stallman's avatar
Richard M. Stallman committed
319 320 321
* 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.
322
* Rings::                   Managing a fixed-size ring of objects.
Richard M. Stallman's avatar
Richard M. Stallman committed
323 324 325 326 327 328 329 330 331 332 333 334 335

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.
336
* Vectors::                 Special characteristics of Emacs Lisp vectors.
337 338 339 340 341 342 343 344 345 346
* Vector Functions::        Functions specifically for vectors.
* Char-Tables::             How to work with char-tables.
* Bool-Vectors::            How to work with bool-vectors.

Hash Tables

* Creating Hash::           Functions to create hash tables.
* Hash Access::             Reading and writing the hash table contents.
* Defining Hash::           Defining new comparison methods
* Other Hash::              Miscellaneous.
Richard M. Stallman's avatar
Richard M. Stallman committed
347 348 349 350 351 352 353 354 355 356

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.

357 358 359 360 361 362 363
Property Lists

* Plists and Alists::       Comparison of the advantages of property
                              lists and association lists.
* Symbol Plists::           Functions to access symbols' property lists.
* Other Plists::            Accessing property lists stored elsewhere.

Richard M. Stallman's avatar
Richard M. Stallman committed
364 365 366 367
Evaluation

* Intro Eval::              Evaluation in the scheme of things.
* Forms::                   How various sorts of objects are evaluated.
368
* Quoting::                 Avoiding evaluation (to put constants in
Richard M. Stallman's avatar
Richard M. Stallman committed
369
                              the program).
370
* Eval::                    How to invoke the Lisp interpreter explicitly.
Richard M. Stallman's avatar
Richard M. Stallman committed
371 372 373 374 375 376

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.
377 378
* Function Indirection::    When a symbol appears as the car of a list,
			      we find the real function via the symbol.
Richard M. Stallman's avatar
Richard M. Stallman committed
379 380
* Function Forms::          Forms that call functions.
* Macro Forms::             Forms that call macros.
381
* Special Forms::           "Special forms" are idiosyncratic primitives,
Richard M. Stallman's avatar
Richard M. Stallman committed
382 383 384 385 386 387 388
                              most of them extremely important.
* Autoloading::             Functions set up to load files
                              containing their real definitions.

Control Structures

* Sequencing::              Evaluation in textual order.
389
* Conditionals::            @code{if}, @code{cond}, @code{when}, @code{unless}.
Richard M. Stallman's avatar
Richard M. Stallman committed
390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406
* 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.
407
* Error Symbols::           How errors are classified for trapping them.
408
* Standard Errors::         List of all error symbols.
Richard M. Stallman's avatar
Richard M. Stallman committed
409 410 411 412 413 414 415 416

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.
417 418
* Tips for Defining::       Things you should think about when you
                              define a variable.
Richard M. Stallman's avatar
Richard M. Stallman committed
419 420 421 422 423
* 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.
424 425 426
* Frame-Local Variables::   Variable values in effect only in one frame.
* Future Local Variables::  New kinds of local values we might add some day.
* File Local Variables::    Handling local variable lists in files.
427
* Variable Aliases::        Variables that are aliases for other variables.
428 429
* Variables with Restricted Values::  Non-constant variables whose value can
                                        @emph{not} be an arbitrary Lisp object.
430 431
* Standard Buffer-Local Variables::
                            List of variables buffer-local in all buffers.
Richard M. Stallman's avatar
Richard M. Stallman committed
432 433 434

Scoping Rules for Variable Bindings

435
* Scope::                   Scope means where in the program a value
Richard M. Stallman's avatar
Richard M. Stallman committed
436 437 438
                              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.
439
* Using Scoping::           How to use dynamic scoping carefully and
Richard M. Stallman's avatar
Richard M. Stallman committed
440 441 442 443 444 445 446
                              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
447
                              that don't have their own buffer-local values.
Richard M. Stallman's avatar
Richard M. Stallman committed
448 449 450 451 452 453 454 455 456

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.
457
* Anonymous Functions::     Lambda-expressions are functions with no names.
Richard M. Stallman's avatar
Richard M. Stallman committed
458 459
* Function Cells::          Accessing or setting the function definition
                              of a symbol.
460 461 462
* Obsolete Functions::      Declaring functions obsolete.
* Inline Functions::	    Defining functions that the compiler will open code.
* Function Safety::         Determining whether a function is safe to call.
Richard M. Stallman's avatar
Richard M. Stallman committed
463
* Related Topics::          Cross-references to specific Lisp primitives
464
                              that have a special bearing on how
Richard M. Stallman's avatar
Richard M. Stallman committed
465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482
                              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.
483
* Indenting Macros::        Specifying how to indent macro calls.
Richard M. Stallman's avatar
Richard M. Stallman committed
484

485 486 487 488 489 490 491 492 493
Common Problems Using Macros

* Wrong Time::             Do the work in the expansion, not in the macro.
* Argument Evaluation::    The expansion should evaluate each macro arg once.
* Surprising Local Vars::  Local variable bindings in the expansion
                              require special care.
* Eval During Expansion::  Don't evaluate them; put them in the expansion.
* Repeated Expansion::     Avoid depending on how many times expansion is done.

494 495 496 497 498 499 500 501
Writing Customization Definitions

* Common Keywords::         Common keyword arguments for all kinds of
                              customization declarations.
* Group Definitions::       Writing customization group definitions.
* Variable Definitions::    Declaring user options.
* Customization Types::     Specifying the type of a user option.

502 503 504 505 506 507 508 509 510
Customization Types

* Simple Types::            Simple customization types: sexp, integer, number,
                              string, file, directory, alist.
* Composite Types::         Build new types from other types or data.
* Splicing into Lists::     Splice elements into list with @code{:inline}.
* Type Keywords::           Keyword-argument pairs in a customization type.
* Defining New Types::      Give your type a name.

Richard M. Stallman's avatar
Richard M. Stallman committed
511 512 513
Loading

* How Programs Do Loading:: The @code{load} function and others.
514
* Load Suffixes::           Details about the suffixes that @code{load} tries.
515 516
* Library Search::          Finding a library to load.
* Loading Non-ASCII::       Non-@acronym{ASCII} characters in Emacs Lisp files.
Richard M. Stallman's avatar
Richard M. Stallman committed
517 518
* Autoload::                Setting up a function to autoload.
* Repeated Loading::        Precautions about loading a file twice.
519 520
* Named Features::          Loading a library if it isn't already loaded.
* Where Defined::           Finding which file defined a certain symbol.
521
* Unloading::		    How to "unload" a library that was loaded.
522 523
* Hooks for Loading::	    Providing code to be run when
			      particular libraries are loaded.
Richard M. Stallman's avatar
Richard M. Stallman committed
524 525 526

Byte Compilation

527
* Speed of Byte-Code::      An example of speedup from byte compilation.
Richard M. Stallman's avatar
Richard M. Stallman committed
528
* Compilation Functions::   Byte compilation functions.
529 530 531 532 533
* Docs and Compilation::    Dynamic loading of documentation strings.
* Dynamic Loading::         Dynamic loading of individual functions.
* Eval During Compile::     Code to be evaluated when you compile.
* Compiler Errors::         Handling compiler error messages.
* Byte-Code Objects::	    The data type used for byte-compiled functions.
Richard M. Stallman's avatar
Richard M. Stallman committed
534 535
* Disassembly::             Disassembling byte-code; how to read byte-code.

536
Advising Emacs Lisp Functions
537 538 539

* Simple Advice::           A simple example to explain the basics of advice.
* Defining Advice::         Detailed description of @code{defadvice}.
540
* Around-Advice::           Wrapping advice around a function's definition.
541 542 543 544 545
* Computed Advice::         ...is to @code{defadvice} as @code{fset} is to @code{defun}.
* Activation of Advice::    Advice doesn't do anything until you activate it.
* Enabling Advice::         You can enable or disable each piece of advice.
* Preactivation::           Preactivation is a way of speeding up the
                              loading of compiled advice.
546
* Argument Access in Advice:: How advice can access the function's arguments.
547
* Advising Primitives::     Accessing arguments when advising a primitive.
548 549
* Combined Definition::     How advice is implemented.

Richard M. Stallman's avatar
Richard M. Stallman committed
550 551 552
Debugging Lisp Programs

* Debugger::                How the Emacs Lisp debugger is implemented.
553
* Edebug::                  A source-level Emacs Lisp debugger.
Richard M. Stallman's avatar
Richard M. Stallman committed
554
* Syntax Errors::           How to find syntax errors.
555
* Test Coverage::           Ensuring you have tested all branches in your code.
556
* Compilation Errors::      How to find errors that show up in
Richard M. Stallman's avatar
Richard M. Stallman committed
557
                              byte compilation.
558

Richard M. Stallman's avatar
Richard M. Stallman committed
559 560 561
The Lisp Debugger

* Error Debugging::         Entering the debugger when an error happens.
562
* Infinite Loops::	    Stopping and debugging a program that doesn't exit.
Richard M. Stallman's avatar
Richard M. Stallman committed
563 564 565 566 567 568 569
* 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.

570 571 572 573 574 575 576 577
Edebug

* Using Edebug::	    Introduction to use of Edebug.
* Instrumenting::	    You must instrument your code
			      in order to debug it with Edebug.
* Edebug Execution Modes::  Execution modes, stopping more or less often.
* Jumping::		    Commands to jump to a specified place.
* Edebug Misc::		    Miscellaneous commands.
Luc Teirlinck's avatar
Luc Teirlinck committed
578
* Breaks::		    Setting breakpoints to make the program stop.
579 580 581 582 583 584 585 586 587
* Trapping Errors::	    Trapping errors with Edebug.
* Edebug Views::	    Views inside and outside of Edebug.
* Edebug Eval::		    Evaluating expressions within Edebug.
* Eval List::		    Expressions whose values are displayed
			      each time you enter Edebug.
* Printing in Edebug::	    Customization of printing.
* Trace Buffer::	    How to produce trace output in a buffer.
* Coverage Testing::	    How to test evaluation coverage.
* The Outside Context::	    Data that Edebug saves and restores.
Luc Teirlinck's avatar
Luc Teirlinck committed
588
* Edebug and Macros::       Specifying how to handle macro calls.
589 590
* Edebug Options::	    Option variables for customizing Edebug.

Richard M. Stallman's avatar
Richard M. Stallman committed
591 592 593 594 595 596 597 598
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.
599
* Input Streams::           Various data types that can be used as
Richard M. Stallman's avatar
Richard M. Stallman committed
600 601
                              input streams.
* Input Functions::         Functions to read Lisp objects from text.
602
* Output Streams::          Various data types that can be used as
Richard M. Stallman's avatar
Richard M. Stallman committed
603 604
                              output streams.
* Output Functions::        Functions to print Lisp objects as text.
605 606
* Output Variables::        Variables that control what the printing
                              functions do.
Richard M. Stallman's avatar
Richard M. Stallman committed
607 608 609 610 611 612

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.
613 614 615
* Minibuffer History::	    Recording previous minibuffer inputs
			      so the user can reuse them.
* Initial Input::           Specifying initial contents for the minibuffer.
Richard M. Stallman's avatar
Richard M. Stallman committed
616 617
* Completion::              How to invoke and customize completion.
* Yes-or-No Queries::       Asking a question with a simple answer.
618 619
* Multiple Queries::	    Asking a series of similar questions.
* Reading a Password::	    Reading a password from the terminal.
620 621 622 623
* Minibuffer Commands::     Commands used as key bindings in minibuffers.
* Minibuffer Contents::     How such commands access the minibuffer text.
* Minibuffer Windows::      Operating on the special minibuffer windows.
* Recursive Mini::          Whether recursive entry to minibuffer is allowed.
Richard M. Stallman's avatar
Richard M. Stallman committed
624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642
* 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.)
* 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.
* Programmed Completion::   Finding the completions for a given file name.

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.
643
* Adjusting Point::     Adjustment of point after a command.
Richard M. Stallman's avatar
Richard M. Stallman committed
644 645
* Input Events::	What input looks like when you read it.
* Reading Input::       How to read input events from the keyboard or mouse.
646
* Special Events::      Events processed immediately and individually.
Richard M. Stallman's avatar
Richard M. Stallman committed
647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662
* 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.

663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689
Input Events

* Keyboard Events::         Ordinary characters--keys with symbols on them.
* Function Keys::           Function keys--keys with names, not symbols.
* Mouse Events::            Overview of mouse events.
* Click Events::            Pushing and releasing a mouse button.
* Drag Events::             Moving the mouse before releasing the button.
* Button-Down Events::      A button was pushed and not yet released.
* Repeat Events::           Double and triple click (or drag, or down).
* Motion Events::           Just moving the mouse, not pushing a button.
* Focus Events::            Moving the mouse between frames.
* Misc Events::             Other events the system can generate.
* Event Examples::          Examples of the lists for mouse events.
* Classifying Events::      Finding the modifier keys in an event symbol.
* Accessing Events::        Functions to extract info from events.
* Strings of Events::       Special considerations for putting
                              keyboard character events in a string.

Reading Input

* Key Sequence Input::      How to read one key sequence.
* Reading One Event::       How to read just one event.
* Event Mod::               How Emacs modifies events as they are read.
* Invoking the Input Method::   How reading an event uses the input method.
* Quoted Character Input::  Asking the user to specify a character.
* Event Input Misc::        How to reread or throw away input events.

Richard M. Stallman's avatar
Richard M. Stallman committed
690 691
Keymaps

692 693 694 695 696 697 698 699 700 701 702 703 704 705
* Key Sequences::           Key sequences as Lisp objects.
* Keymap Basics::           Basic concepts of 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.
* Active Keymaps::          How Emacs searches the active keymaps
                              for a key binding.
* Searching Keymaps::       A pseudo-Lisp summary of searching active maps.
* Controlling Active Maps:: Each buffer has a local keymap
                               to override the standard (global) bindings.
                               A minor mode can also override them.
* Key Lookup::              How extracting elements from keymaps works.
Richard M. Stallman's avatar
Richard M. Stallman committed
706
* Functions for Key Lookup::    How to request key lookup.
707 708 709 710 711 712 713 714
* Changing Key Bindings::   Redefining a key in a keymap.
* Remapping Commands::      A keymap can translate one command to another.
* Translation Keymaps::     Keymaps for translating sequences of events.
* Key Binding Commands::    Interactive interfaces for redefining keys.
* Scanning Keymaps::        Looking through all keymaps, for printing help.
* Menu Keymaps::            A keymap can define a menu for X
                              or for use from the terminal.
* Standard Keymaps::        List of standard keymaps.
Richard M. Stallman's avatar
Richard M. Stallman committed
715 716 717

Major and Minor Modes

718 719
* Hooks::                   How to use hooks; how to write code that
                              provides hooks.
Richard M. Stallman's avatar
Richard M. Stallman committed
720 721 722
* Major Modes::             Defining major modes.
* Minor Modes::             Defining minor modes.
* Mode Line Format::        Customizing the text that appears in the mode line.
723 724 725 726 727
* Imenu::                   How a mode can provide a menu
                              of definitions in the buffer.
* Font Lock Mode::          How modes can highlight text according to syntax.
* Desktop Save Mode::       How modes can have buffer state saved between
                              Emacs sessions.
Richard M. Stallman's avatar
Richard M. Stallman committed
728

729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760
Menu Keymaps

* Defining Menus::          How to make a keymap that defines a menu.
* Mouse Menus::             How users actuate the menu with the mouse.
* Keyboard Menus::          How users actuate the menu with the keyboard.
* Menu Example::            Making a simple menu.
* Menu Bar::                How to customize the menu bar.
* Tool Bar::                A tool bar is a row of images.
* Modifying Menus::         How to add new items to a menu.

Defining Menus

* Simple Menu Items::       A simple kind of menu key binding,
                              limited in capabilities.
* Extended Menu Items::     More powerful menu item definitions
                              let you specify keywords to enable
                              various features.
* Menu Separators::         Drawing a horizontal line through a menu.
* Alias Menu Items::        Using command aliases in menu items.

Major and Minor Modes

* Hooks::              How to use hooks; how to write code that provides hooks.
* Major Modes::        Defining major modes.
* Minor Modes::        Defining minor modes.
* Mode Line Format::   Customizing the text that appears in the mode line.
* Imenu::              How a mode can provide a menu
                         of definitions in the buffer.
* Font Lock Mode::     How modes can highlight text according to syntax.
* Desktop Save Mode::  How modes can have buffer state saved between
                         Emacs sessions.

Richard M. Stallman's avatar
Richard M. Stallman committed
761 762
Major Modes

763
* Major Mode Basics::
Richard M. Stallman's avatar
Richard M. Stallman committed
764 765 766 767
* 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.
768 769 770 771 772
* Derived Modes::           Defining a new major mode based on another major
                              mode.
* Generic Modes::           Defining a simple major mode that supports
                              comment syntax and Font Lock mode.
* Mode Hooks::              Hooks run at the end of major mode functions.
Richard M. Stallman's avatar
Richard M. Stallman committed
773 774 775 776 777

Minor Modes

* Minor Mode Conventions::  Tips for writing a minor mode.
* Keymaps and Minor Modes:: How a minor mode can have its own keymap.
778
* Defining Minor Modes::    A convenient facility for defining minor modes.
Richard M. Stallman's avatar
Richard M. Stallman committed
779 780 781

Mode Line Format

782
* Mode Line Basics::
Richard M. Stallman's avatar
Richard M. Stallman committed
783 784 785
* 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.
786 787 788
* Properties in Mode::      Using text properties in the mode line.
* Header Lines::            Like a mode line, but at the top.
* Emulating Mode Line::     Formatting text as the mode line would.
Richard M. Stallman's avatar
Richard M. Stallman committed
789

790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812
Font Lock Mode

* Font Lock Basics::        Overview of customizing Font Lock.
* Search-based Fontification::  Fontification based on regexps.
* Customizing Keywords::    Customizing search-based fontification.
* Other Font Lock Variables::   Additional customization facilities.
* Levels of Font Lock::     Each mode can define alternative levels
                              so that the user can select more or less.
* Precalculated Fontification:: How Lisp programs that produce the buffer
                                  contents can also specify how to fontify it.
* Faces for Font Lock::     Special faces specifically for Font Lock.
* Syntactic Font Lock::     Fontification based on syntax tables.
* Setting Syntax Properties::   Defining character syntax based on context
                                  using the Font Lock mechanism.
* Multiline Font Lock::     How to coerce Font Lock into properly
                              highlighting multiline constructs.

Multiline Font Lock Constructs

* Font Lock Multiline::     Marking multiline chunks with a text property
* Region to Fontify::       Controlling which region gets refontified
                              after a buffer change.

Richard M. Stallman's avatar
Richard M. Stallman committed
813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829
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
830 831
                              simultaneous editing by two people.
* Information about Files:: Testing existence, accessibility, size of files.
832 833
* Changing Files::          Renaming files, changing protection, etc.
* File Names::              Decomposing and expanding file names.
834 835 836 837 838
* Contents of Directories:: Getting a list of the files in a directory.
* Create/Delete Dirs::	    Creating and Deleting Directories.
* Magic File Names::	    Defining "magic" special handling
			      for certain file names.
* Format Conversion::       Conversion to and from various file formats.
Richard M. Stallman's avatar
Richard M. Stallman committed
839 840 841 842 843 844 845 846 847

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?
848 849
* Kinds of Files::          Is it a directory?  A symbolic link?
* Truenames::		    Eliminating symbolic links from a file name.
Richard M. Stallman's avatar
Richard M. Stallman committed
850
* File Attributes::         How large is it?  Any other names?  Etc.
851
* Locating Files::          How to find a file in standard places.
Richard M. Stallman's avatar
Richard M. Stallman committed
852 853 854 855

File Names

* File Name Components::    The directory part of a file name, and the rest.
856
* Relative File Names::     Some file names are relative to a
Richard M. Stallman's avatar
Richard M. Stallman committed
857
                              current directory.
858 859
* Directory Names::         A directory's name as a directory
                              is different from its name as a file.
Richard M. Stallman's avatar
Richard M. Stallman committed
860 861 862
* 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.
863 864
* Standard File Names::     If your package uses a fixed file name,
                              how to handle various operating systems simply.
Richard M. Stallman's avatar
Richard M. Stallman committed
865 866 867

Backups and Auto-Saving

868
* Backup Files::            How backup files are made; how their names
Richard M. Stallman's avatar
Richard M. Stallman committed
869 870 871
                              are chosen.
* Auto-Saving::             How auto-save files are made; how their
                              names are chosen.
872
* Reverting::               @code{revert-buffer}, and how to customize
Richard M. Stallman's avatar
Richard M. Stallman committed
873 874 875 876 877
                              what it does.

Backup Files

* Making Backups::          How Emacs makes backup files, and when.
878
* Rename or Copy::          Two alternatives: renaming the old file
Richard M. Stallman's avatar
Richard M. Stallman committed
879 880 881 882 883 884 885
                              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?
886 887
* Current Buffer::          Designating a buffer as current
                              so primitives will access its contents.
Richard M. Stallman's avatar
Richard M. Stallman committed
888 889 890 891 892
* 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
893
                              ``behind Emacs's back''.
Richard M. Stallman's avatar
Richard M. Stallman committed
894 895 896 897 898
* 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.
899 900 901
* Indirect Buffers::        An indirect buffer shares text with some
                              other buffer.
* Buffer Gap::              The gap in the buffer.
Richard M. Stallman's avatar
Richard M. Stallman committed
902 903 904 905 906 907 908 909 910

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.
911
* Displaying Buffers::      Higher-level functions for displaying a buffer
Richard M. Stallman's avatar
Richard M. Stallman committed
912
                              and choosing a window for it.
913
* Choosing Window::	    How to choose a window for displaying a buffer.
Richard M. Stallman's avatar
Richard M. Stallman committed
914 915
* Window Point::            Each window has its own location of point.
* Window Start::            The display-start position controls which text
916
                              is on-screen in the window.
917 918 919
* Textual Scrolling::       Moving text up and down through the window.
* Vertical Scrolling::      Moving the contents up and down on the window.
* Horizontal Scrolling::    Moving the contents sideways on the window.
Richard M. Stallman's avatar
Richard M. Stallman committed
920 921
* Size of Window::          Accessing the size of a window.
* Resizing Windows::        Changing the size of a window.
922
* Coordinates and Windows:: Converting coordinates to windows.
923
* Window Tree::             The layout and sizes of all windows in a frame.
Richard M. Stallman's avatar
Richard M. Stallman committed
924
* Window Configurations::   Saving and restoring the state of the screen.
925 926 927
* Window Hooks::            Hooks for scrolling, window size changes,
                              redisplay going past a certain point,
                              or window configuration changes.
Richard M. Stallman's avatar
Richard M. Stallman committed
928

Karl Heuer's avatar
Karl Heuer committed
929 930 931
Frames

* Creating Frames::	    Creating additional frames.
932
* Multiple Displays::       Creating frames on other displays.
Karl Heuer's avatar
Karl Heuer committed
933 934 935 936 937 938 939 940 941
* Frame Parameters::	    Controlling frame size, position, font, etc.
* Frame Titles::            Automatic updating of frame titles.
* Deleting Frames::	    Frames last until explicitly deleted.
* Finding All Frames::	    How to examine all existing frames.
* Frames and Windows::	    A frame contains windows;
			      display of text always works through windows.
* Minibuffers and Frames::  How a frame finds the minibuffer to use.
* Input Focus::		    Specifying the selected frame.
* Visibility of Frames::    Frames may be visible or invisible, or icons.
942
* Raising and Lowering::    Raising a frame makes it hide other windows;
943
			      lowering it puts it underneath the others.
Karl Heuer's avatar
Karl Heuer committed
944 945 946 947 948
* Frame Configurations::    Saving the state of all frames.
* Mouse Tracking::	    Getting events that say when the mouse moves.
* Mouse Position::	    Asking where the mouse is, or moving it.
* Pop-Up Menus::	    Displaying a menu for the user to select from.
* Dialog Boxes::            Displaying a box to ask yes or no.
949
* Pointer Shape::           Specifying the shape of the mouse pointer.
950
* Window System Selections::Transferring text to and from other windows.
951
* Drag and Drop::               Internals of Drag-and-Drop implementation.
Karl Heuer's avatar
Karl Heuer committed
952
* Color Names::	            Getting the definitions of color names.
953
* Text Terminal Colors::    Defining colors for text-only terminals.
Karl Heuer's avatar
Karl Heuer committed
954
* Resources::		    Getting resource values from the server.
Dave Love's avatar
Dave Love committed
955
* Display Feature Testing:: Determining the features of a terminal.
Karl Heuer's avatar
Karl Heuer committed
956

957 958 959 960 961 962 963 964 965 966 967 968 969 970 971 972 973 974 975 976
Frame Parameters

* Parameter Access::        How to change a frame's parameters.
* Initial Parameters::	    Specifying frame parameters when you make a frame.
* Window Frame Parameters:: List of frame parameters for window systems.
* Size and Position::       Changing the size and position of a frame.
* Geometry::                Parsing geometry specifications.

Window Frame Parameters

* Basic Parameters::        Parameters that are fundamental.
* Position Parameters::     The position of the frame on the screen.
* Size Parameters::         Frame's size.
* Layout Parameters::       Size of parts of the frame, and
                              enabling or disabling some parts.
* Buffer Parameters::       Which buffers have been or should be shown.
* Management Parameters::   Communicating with the window manager.
* Cursor Parameters::       Controlling the cursor appearance.
* Color Parameters::        Colors of various parts of the frame.

Richard M. Stallman's avatar
Richard M. Stallman committed
977 978 979 980 981 982 983 984 985 986 987 988 989 990 991 992 993 994 995 996 997 998
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.
* 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.
999 1000 1001 1002
* Information from Markers::Finding the marker's buffer or character
                              position.
* Marker Insertion Types::  Two ways a marker can relocate when you
                              insert where it points.
1003
* Moving Markers::          Moving the marker to a new buffer or position.
1004 1005
* The Mark::                How "the mark" is implemented with a marker.
* The Region::              How to access "the region".
Richard M. Stallman's avatar
Richard M. Stallman committed
1006 1007 1008 1009 1010

Text

* Near Point::              Examining text in the vicinity of point.
* Buffer Contents::         Examining text in a general fashion.
1011
* Comparing Text::          Comparing substrings of buffers.
Richard M. Stallman's avatar
Richard M. Stallman committed
1012 1013 1014 1015 1016 1017 1018
* 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.
1019 1020
* Maintaining Undo::        How to enable and disable undo information.
			      How to control how much information is kept.
Richard M. Stallman's avatar
Richard M. Stallman committed
1021
* Filling::                 Functions for explicit filling.
Karl Heuer's avatar
Karl Heuer committed
1022
* Margins::                 How to specify margins for filling commands.
1023 1024 1025
* Adaptive Fill::           Adaptive Fill mode chooses a fill prefix
                              from context.
* Auto Filling::            How auto-fill mode is implemented to break lines.
Richard M. Stallman's avatar
Richard M. Stallman committed
1026 1027
* Sorting::                 Functions for sorting parts of the buffer.
* Columns::                 Computing horizontal positions, and using them.
1028
* Indentation::             Functions to insert or adjust indentation.
Richard M. Stallman's avatar
Richard M. Stallman committed
1029
* Case Changes::            Case conversion of parts of the buffer.
Karl Heuer's avatar
Karl Heuer committed
1030
* Text Properties::         Assigning Lisp property lists to text characters.
Richard M. Stallman's avatar
Richard M. Stallman committed
1031
* Substitution::            Replacing a given character wherever it appears.
Karl Heuer's avatar
Karl Heuer committed
1032
* Transposition::           Swapping two portions of a buffer.
Richard M. Stallman's avatar
Richard M. Stallman committed
1033 1034
* Registers::               How registers are implemented.  Accessing
                              the text or position stored in a register.
1035
* Base 64::                 Conversion to or from base 64 encoding.
1036 1037
* MD5 Checksum::            Compute the MD5 "message digest"/"checksum".
* Atomic Changes::          Installing several buffer changes "atomically".
Karl Heuer's avatar
Karl Heuer committed
1038
* Change Hooks::            Supplying functions to be run when text is changed.
1039

Richard M. Stallman's avatar
Richard M. Stallman committed
1040 1041 1042 1043
The Kill Ring

* Kill Ring Concepts::      What text looks like in the kill ring.
* Kill Functions::          Functions that kill text.
1044
* Yanking::                 How yanking is done.
Richard M. Stallman's avatar
Richard M. Stallman committed
1045
* Yank Commands::           Commands that access the kill ring.
Karl Heuer's avatar
Karl Heuer committed
1046
* Low-Level Kill Ring::	    Functions and variables for kill ring access.
Richard M. Stallman's avatar
Richard M. Stallman committed
1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057
* 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.

Karl Heuer's avatar
Karl Heuer committed
1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070
Text Properties

* Examining Properties::    Looking at the properties of one character.
* Changing Properties::	    Setting the properties of a range of text.
* Property Search::	    Searching for where a property changes value.
* Special Properties::	    Particular properties with special meanings.
* Format Properties::       Properties for representing formatting of text.
* Sticky Properties::       How inserted text gets properties from
                              neighboring text.
* Saving Properties::       Saving text properties in files, and reading
                              them back.
* Lazy Properties::         Computing text properties in a lazy fashion
                              only when text is examined.
1071 1072
* Clickable Text::          Using text properties to make regions of text
                              do something when you click on them.
1073
* Links and Mouse-1::       How to make @key{Mouse-1} follow a link.
1074 1075
* Fields::                  The @code{field} property defines
                              fields within the buffer.
Karl Heuer's avatar
Karl Heuer committed
1076 1077 1078
* Not Intervals::	    Why text properties do not use
			      Lisp-visible text intervals.

1079 1080 1081 1082 1083 1084 1085
Non-ASCII Characters

* Text Representations::    Unibyte and multibyte representations
* Converting Representations::  Converting unibyte to multibyte and vice versa.
* Selecting a Representation::  Treating a byte sequence as unibyte or multi.
* Character Codes::         How unibyte and multibyte relate to
                                codes of individual characters.
1086
* Character Sets::          The space of possible character codes
1087 1088 1089 1090 1091 1092 1093
                                is divided into various character sets.
* Chars and Bytes::         More information about multibyte encodings.
* Splitting Characters::    Converting a character to its byte sequence.
* Scanning Charsets::       Which character sets are used in a buffer?
* Translation of Characters::   Translation tables are used for conversion.
* Coding Systems::          Coding systems are conversions for saving files.
* Input Methods::           Input methods allow users to enter various
Richard M. Stallman's avatar
Richard M. Stallman committed
1094
                                non-ASCII characters without special keyboards.
1095 1096
* Locales::                 Interacting with the POSIX locale.

1097 1098 1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110
Coding Systems

* Coding System Basics::    Basic concepts.
* Encoding and I/O::        How file I/O functions handle coding systems.
* Lisp and Coding Systems:: Functions to operate on coding system names.
* User-Chosen Coding Systems::  Asking the user to choose a coding system.
* Default Coding Systems::  Controlling the default choices.
* Specifying Coding Systems::   Requesting a particular coding system
                                    for a single file operation.
* Explicit Encoding::       Encoding or decoding text without doing I/O.
* Terminal I/O Encoding::   Use of encoding for terminal I/O.
* MS-DOS File Types::       How DOS "text" and "binary" files
                                relate to coding systems.

Richard M. Stallman's avatar
Richard M. Stallman committed
1111 1112 1113
Searching and Matching

* String Search::           Search for an exact match.
1114
* Searching and Case::      Case-independent or case-significant searching.
Richard M. Stallman's avatar
Richard M. Stallman committed
1115 1116
* Regular Expressions::     Describing classes of strings.
* Regexp Search::           Searching for a match for a regexp.
1117
* POSIX Regexps::           Searching POSIX-style for the longest match.
1118 1119 1120
* Match Data::              Finding out which part of the text matched,
                              after a string or regexp search.
* Search and Replace::	    Commands that loop, searching and replacing.
1121
* Standard Regexps::        Useful regexps for finding sentences, pages,...
Richard M. Stallman's avatar
Richard M. Stallman committed
1122 1123 1124 1125 1126

Regular Expressions

* Syntax of Regexps::       Rules for writing regular expressions.
* Regexp Example::          Illustrates regular expression syntax.
1127
* Regexp Functions::        Functions for operating on regular expressions.
Richard M. Stallman's avatar
Richard M. Stallman committed
1128

1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142
Syntax of Regular Expressions

* Regexp Special::          Special characters in regular expressions.
* Char Classes::            Character classes used in regular expressions.
* Regexp Backslash::        Backslash-sequences in regular expressions.

The Match Data

* Replacing Match::	    Replacing a substring that was matched.
* Simple Match Data::       Accessing single items of match data,
			      such as where a particular subexpression started.
* Entire Match Data::       Accessing the entire match data at once, as a list.
* Saving Match Data::       Saving and restoring the match data.

Richard M. Stallman's avatar
Richard M. Stallman committed
1143 1144
Syntax Tables

1145
* Syntax Basics::           Basic concepts of syntax tables.
Richard M. Stallman's avatar
Richard M. Stallman committed
1146 1147
* Syntax Descriptors::      How characters are classified.
* Syntax Table Functions::  How to create, examine and alter syntax tables.
1148 1149
* Syntax Properties::       Overriding syntax with text properties.
* Motion and Syntax::	    Moving over characters with certain syntaxes.
Richard M. Stallman's avatar
Richard M. Stallman committed
1150 1151 1152 1153
* 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.
1154
* Categories::              Another way of classifying character syntax.
Richard M. Stallman's avatar
Richard M. Stallman committed
1155 1156 1157 1158 1159 1160

Syntax Descriptors

* Syntax Class Table::      Table of syntax classes.
* Syntax Flags::            Additional flags each character can have.

1161 1162 1163 1164 1165 1166 1167 1168
Parsing Expressions

* Motion via Parsing::      Motion functions that work by parsing.
* Position Parse::          Determining the syntactic state of a position.
* Parser State::            How Emacs represents a syntactic state.
* Low-Level Parsing::       Parsing across a specified region.
* Control Parsing::         Parameters that affect parsing.

Richard M. Stallman's avatar
Richard M. Stallman committed
1169 1170 1171
Abbrevs And Abbrev Expansion

* Abbrev Mode::             Setting up Emacs for abbreviation.
1172
* Abbrev Tables::           Creating and working with abbrev tables.
Richard M. Stallman's avatar
Richard M. Stallman committed
1173
* Defining Abbrevs::        Specifying abbreviations and their expansions.
1174 1175
* Abbrev Files::            Saving abbrevs in files.
* Abbrev Expansion::        Controlling expansion; expansion subroutines.
Richard M. Stallman's avatar
Richard M. Stallman committed
1176 1177 1178 1179 1180
* Standard Abbrev Tables::  Abbrev tables used by various major modes.

Processes

* Subprocess Creation::     Functions that start subprocesses.
1181
* Shell Arguments::         Quoting an argument to pass it to a shell.
Richard M. Stallman's avatar
Richard M. Stallman committed
1182 1183 1184