[Top] [Contents] [Index] [Search] [Page Top / Page Bottom] [?]

GNU Emacs Lisp Reference Manual

download this manual file.

This Info file contains edition 2.9 of the GNU Emacs Lisp Reference Manual, corresponding to GNU Emacs version 23.0.50.

1. Introduction    Introduction and conventions used.

2. Lisp Data Types    Data types of objects in Emacs Lisp.
3. Numbers    Numbers and arithmetic functions.
4. Strings and Characters    Strings, and functions that work on them.
5. Lists    Lists, cons cells, and related functions.
6. Sequences, Arrays, and Vectors    Lists, strings and vectors are called sequences. Certain functions act on any kind of sequence. The description of vectors is here as well.
7. Hash Tables    Very fast lookup-tables.
8. Symbols    Symbols represent names, uniquely.

9. Evaluation    How Lisp expressions are evaluated.
10. Control Structures    Conditionals, loops, nonlocal exits.
11. Variables    Using symbols in programs to stand for values.
12. Functions    A function is a Lisp program that can be invoked from other functions.
13. Macros    Macros are a way to extend the Lisp language.
14. Writing Customization Definitions    Writing customization declarations.

15. Loading    Reading files of Lisp code into Lisp.
16. Byte Compilation    Compilation makes programs run faster.
17. Advising Emacs Lisp Functions    Adding to the definition of a function.
18. Debugging Lisp Programs    Tools and tips for debugging Lisp programs.

19. Reading and Printing Lisp Objects    Converting Lisp objects to text and back.
20. Minibuffers    Using the minibuffer to read input.
21. Command Loop    How the editor command loop works, and how you can call its subroutines.
22. Keymaps    Defining the bindings from keys to commands.
23. Major and Minor Modes    Defining major and minor modes.
24. Documentation    Writing and using documentation strings.

25. Files    Accessing files.
26. Backups and Auto-Saving    Controlling how backups and auto-save files are made.
27. Buffers    Creating and using buffer objects.
28. Windows    Manipulating windows and displaying buffers.
29. Frames    Making multiple system-level windows.
30. Positions    Buffer positions and motion functions.
31. Markers    Markers represent positions and update automatically when the text is changed.

32. Text    Examining and changing text in buffers.
33. Non-ASCII Characters    Non-ASCII text in buffers and strings.
34. Searching and Matching    Searching buffers for strings or regexps.
35. Syntax Tables    The syntax table controls word and list parsing.
36. Abbrevs and Abbrev Expansion    How Abbrev mode works, and its data structures.

37. Processes    Running and communicating with subprocesses.
38. Emacs Display    Features for controlling the screen display.
39. Operating System Interface    Getting the user id, system type, environment variables, and other such things.


A. Emacs 21 Antinews    Info for users downgrading to Emacs 21.
B. GNU Free Documentation License    The license for this documentation
C. GNU General Public License    Conditions for copying and changing GNU Emacs.
D. Tips and Conventions    Advice and coding conventions for Emacs Lisp.
E. GNU Emacs Internals    Building and dumping Emacs; internal data structures.
F. Standard Errors    List of all error symbols.
G. Buffer-Local Variables    List of variables buffer-local in all buffers.
H. Standard Keymaps    List of standard keymaps.
I. Standard Hooks    List of standard hook variables.

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:


1.1 Caveats    Flaws and a request for help.
1.2 Lisp History    Emacs Lisp is descended from Maclisp.
1.3 Conventions    How the manual is formatted.
1.4 Version Information    Which Emacs version is running?
1.5 Acknowledgements    The authors, editors, and sponsors of this manual.


1.3.1 Some Terms    Explanation of terms we use in this manual.
1.3.2 nil and t    How the symbols nil and t are used.
1.3.3 Evaluation Notation    The format we use for examples of evaluation.
1.3.4 Printing Notation    The format we use for examples that print output.
1.3.5 Error Messages    The format we use for examples of errors.
1.3.6 Buffer Text Notation    The format we use for buffer contents in examples.
1.3.7 Format of Descriptions    Notation for describing functions, variables, etc.

Format of Descriptions A Sample Function Description    A description of an imaginary function, foo. A Sample Variable Description    A description of an imaginary variable, electric-future-map.

Lisp Data Types

2.1 Printed Representation and Read Syntax    How Lisp objects are represented as text.
2.2 Comments    Comments and their formatting conventions.
2.3 Programming Types    Types found in all Lisp systems.
2.4 Editing Types    Types specific to Emacs.
2.5 Read Syntax for Circular Objects    Read syntax for circular structure.
2.6 Type Predicates    Tests related to types.
2.7 Equality Predicates    Tests of equality between any two objects.

Programming Types

2.3.1 Integer Type    Numbers without fractional parts.
2.3.2 Floating Point Type    Numbers with fractional parts and with a large range.
2.3.3 Character Type    The representation of letters, numbers and control characters.
2.3.4 Symbol Type    A multi-use object that refers to a function, variable, property list, or itself.
2.3.5 Sequence Types    Both lists and arrays are classified as sequences.
2.3.6 Cons Cell and List Types    Cons cells, and lists (which are made from cons cells).
2.3.7 Array Type    Arrays include strings and vectors.
2.3.8 String Type    An (efficient) array of characters.
2.3.9 Vector Type    One-dimensional arrays.
2.3.10 Char-Table Type    One-dimensional sparse arrays indexed by characters.
2.3.11 Bool-Vector Type    One-dimensional arrays of t or nil.
2.3.12 Hash Table Type    Super-fast lookup tables.
2.3.13 Function Type    A piece of executable code you can call from elsewhere.
2.3.14 Macro Type    A method of expanding an expression into another expression, more fundamental but less pretty.
2.3.15 Primitive Function Type    A function written in C, callable from Lisp.
2.3.16 Byte-Code Function Type    A function written in Lisp, then compiled.
2.3.17 Autoload Type    A type used for automatically loading seldom-used functions.

Character Type Basic Char Syntax    Syntax for regular characters. General Escape Syntax    How to specify characters by their codes. Control-Character Syntax    Syntax for control characters. Meta-Character Syntax    Syntax for meta-characters. Other Character Modifier Bits    Syntax for hyper-, super-, and alt-characters.

Cons Cell and List Types Drawing Lists as Box Diagrams    Drawing pictures of lists. Dotted Pair Notation    An alternative syntax for lists. Association List Type    A specially constructed list.

String Type Syntax for Strings    How to specify Lisp strings. Non-ASCII Characters in Strings    International characters in strings. Nonprinting Characters in Strings    Literal unprintable characters in strings. Text Properties in Strings    Strings with text properties.

Editing Types

2.4.1 Buffer Type    The basic object of editing.
2.4.2 Marker Type    A position in a buffer.
2.4.3 Window Type    What makes buffers visible.
2.4.4 Frame Type    Windows subdivide frames.
2.4.5 Window Configuration Type    Recording the way a frame is subdivided.
2.4.6 Frame Configuration Type    Recording the status of all frames.
2.4.7 Process Type    A process running on the underlying OS.
2.4.8 Stream Type    Receive or send characters.
2.4.9 Keymap Type    What function a keystroke invokes.
2.4.10 Overlay Type    How an overlay is represented.


3.1 Integer Basics    Representation and range of integers.
3.2 Floating Point Basics    Representation and range of floating point.
3.3 Type Predicates for Numbers    Testing for numbers.
3.4 Comparison of Numbers    Equality and inequality predicates.
3.5 Numeric Conversions    Converting float to integer and vice versa.
3.6 Arithmetic Operations    How to add, subtract, multiply and divide.
3.7 Rounding Operations    Explicitly rounding floating point numbers.
3.8 Bitwise Operations on Integers    Logical and, or, not, shifting.
3.9 Standard Mathematical Functions    Trig, exponential and logarithmic functions.
3.10 Random Numbers    Obtaining random integers, predictable or not.

Strings and Characters

4.1 String and Character Basics    Basic properties of strings and characters.
4.2 The Predicates for Strings    Testing whether an object is a string or char.
4.3 Creating Strings    Functions to allocate new strings.
4.4 Modifying Strings    Altering the contents of an existing string.
4.5 Comparison of Characters and Strings    Comparing characters or strings.
4.6 Conversion of Characters and Strings    Converting characters to strings and vice versa.
4.7 Formatting Strings    format: Emacs's analogue of printf.
4.8 Case Conversion in Lisp    Case conversion functions.
4.9 The Case Table    Customizing case conversion.


5.1 Lists and Cons Cells    How lists are made out of cons cells.
5.2 Predicates on Lists    Is this object a list? Comparing two lists.
5.3 Accessing Elements of Lists    Extracting the pieces of a list.
5.4 Building Cons Cells and Lists    Creating list structure.
5.5 Modifying List Variables    Modifying lists stored in variables.
5.6 Modifying Existing List Structure    Storing new pieces into an existing list.
5.7 Using Lists as Sets    A list can represent a finite mathematical set.
5.8 Association Lists    A list can represent a finite relation or mapping.
5.9 Managing a Fixed-Size Ring of Objects    Managing a fixed-size ring of objects.

Modifying Existing List Structure

5.6.1 Altering List Elements with setcar    Replacing an element in a list.
5.6.2 Altering the CDR of a List    Replacing part of the list backbone. This can be used to remove or add elements.
5.6.3 Functions that Rearrange Lists    Reordering the elements in a list; combining lists.

Sequences, Arrays, and Vectors

6.1 Sequences    Functions that accept any kind of sequence.
6.2 Arrays    Characteristics of arrays in Emacs Lisp.
6.3 Functions that Operate on Arrays    Functions specifically for arrays.
6.4 Vectors    Special characteristics of Emacs Lisp vectors.
6.5 Functions for Vectors    Functions specifically for vectors.
6.6 Char-Tables    How to work with char-tables.
6.7 Bool-vectors    How to work with bool-vectors.

Hash Tables

7.1 Creating Hash Tables    Functions to create hash tables.
7.2 Hash Table Access    Reading and writing the hash table contents.
7.3 Defining Hash Comparisons    Defining new comparison methods
7.4 Other Hash Table Functions    Miscellaneous.


8.1 Symbol Components    Symbols have names, values, function definitions and property lists.
8.2 Defining Symbols    A definition says how a symbol will be used.
8.3 Creating and Interning Symbols    How symbols are kept unique.
8.4 Property Lists    Each symbol has a property list for recording miscellaneous information.

Property Lists

8.4.1 Property Lists and Association Lists    Comparison of the advantages of property lists and association lists.
8.4.2 Property List Functions for Symbols    Functions to access symbols' property lists.
8.4.3 Property Lists Outside Symbols    Accessing property lists stored elsewhere.


9.1 Introduction to Evaluation    Evaluation in the scheme of things.
9.2 Kinds of Forms    How various sorts of objects are evaluated.
9.3 Quoting    Avoiding evaluation (to put constants in the program).
9.4 Eval    How to invoke the Lisp interpreter explicitly.

Kinds of Forms

9.2.1 Self-Evaluating Forms    Forms that evaluate to themselves.
9.2.2 Symbol Forms    Symbols evaluate as variables.
9.2.3 Classification of List Forms    How to distinguish various sorts of list forms.
9.2.4 Symbol Function Indirection    When a symbol appears as the car of a list, we find the real function via the symbol.
9.2.5 Evaluation of Function Forms    Forms that call functions.
9.2.6 Lisp Macro Evaluation    Forms that call macros.
9.2.7 Special Forms    "Special forms" are idiosyncratic primitives, most of them extremely important.
9.2.8 Autoloading    Functions set up to load files containing their real definitions.

Control Structures

10.1 Sequencing    Evaluation in textual order.
10.2 Conditionals    if, cond, when, unless.
10.3 Constructs for Combining Conditions    and, or, not.
10.4 Iteration    while loops.
10.5 Nonlocal Exits    Jumping out of a sequence.

Nonlocal Exits

10.5.1 Explicit Nonlocal Exits: catch and throw    Nonlocal exits for the program's own purposes.
10.5.2 Examples of catch and throw    Showing how such nonlocal exits can be written.
10.5.3 Errors    How errors are signaled and handled.
10.5.4 Cleaning Up from Nonlocal Exits    Arranging to run a cleanup form if an error happens.

Errors How to Signal an Error    How to report an error. How Emacs Processes Errors    What Emacs does when you report an error. Writing Code to Handle Errors    How you can trap errors and continue execution. Error Symbols and Condition Names    How errors are classified for trapping them.
F. Standard Errors    List of all error symbols.


11.1 Global Variables    Variable values that exist permanently, everywhere.
11.2 Variables that Never Change    Certain "variables" have values that never change.
11.3 Local Variables    Variable values that exist only temporarily.
11.4 When a Variable is "Void"    Symbols that lack values.
11.5 Defining Global Variables    A definition says a symbol is used as a variable.
11.6 Tips for Defining Variables Robustly    Things you should think about when you define a variable.
11.7 Accessing Variable Values    Examining values of variables whose names are known only at run time.
11.8 How to Alter a Variable Value    Storing new values in variables.
11.9 Scoping Rules for Variable Bindings    How Lisp chooses among local and global values.
11.10 Buffer-Local Variables    Variable values in effect only in one buffer.
11.11 Possible Future Local Variables    New kinds of local values we might add some day.
11.12 File Local Variables    Handling local variable lists in files.
11.13 Variable Aliases    Variables that are aliases for other variables.
11.14 Variables with Restricted Values    Non-constant variables whose value can
                                        not be an arbitrary Lisp object.
G. Buffer-Local Variables    List of variables buffer-local in all buffers.

Scoping Rules for Variable Bindings

11.9.1 Scope    Scope means where in the program a value is visible. Comparison with other languages.
11.9.2 Extent    Extent means how long in time a value exists.
11.9.3 Implementation of Dynamic Scoping    Two ways to implement dynamic scoping.
11.9.4 Proper Use of Dynamic Scoping    How to use dynamic scoping carefully and avoid problems.

Buffer-Local Variables

11.10.1 Introduction to Buffer-Local Variables    Introduction and concepts.
11.10.2 Creating and Deleting Buffer-Local Bindings    Creating and destroying buffer-local bindings.
11.10.3 The Default Value of a Buffer-Local Variable    The default value is seen in buffers that don't have their own buffer-local values.


12.1 What Is a Function?    Lisp functions vs primitives; terminology.
12.2 Lambda Expressions    How functions are expressed as Lisp objects.
12.3 Naming a Function    A symbol can serve as the name of a function.
12.4 Defining Functions    Lisp expressions for defining functions.
12.5 Calling Functions    How to use an existing function.
12.6 Mapping Functions    Applying a function to each element of a list, etc.
12.7 Anonymous Functions    Lambda-expressions are functions with no names.
12.8 Accessing Function Cell Contents    Accessing or setting the function definition of a symbol.
12.9 Declaring Functions Obsolete    Declaring functions obsolete.
12.10 Inline Functions    Defining functions that the compiler will open code.
12.12 Determining whether a Function is Safe to Call    Determining whether a function is safe to call.
12.13 Other Topics Related to Functions    Cross-references to specific Lisp primitives that have a special bearing on how functions work.

Lambda Expressions

12.2.1 Components of a Lambda Expression    The parts of a lambda expression.
12.2.2 A Simple Lambda-Expression Example    A simple example.
12.2.3 Other Features of Argument Lists    Details and special features of argument lists.
12.2.4 Documentation Strings of Functions    How to put documentation in a function.


13.1 A Simple Example of a Macro    A basic example.
13.2 Expansion of a Macro Call    How, when and why macros are expanded.
13.3 Macros and Byte Compilation    How macros are expanded by the compiler.
13.4 Defining Macros    How to write a macro definition.
13.5 Backquote    Easier construction of list structure.
13.6 Common Problems Using Macros    Don't evaluate the macro arguments too many times. Don't hide the user's variables.
13.7 Indenting Macros    Specifying how to indent macro calls.

Common Problems Using Macros

13.6.1 Wrong Time    Do the work in the expansion, not in the macro.
13.6.2 Evaluating Macro Arguments Repeatedly    The expansion should evaluate each macro arg once.
13.6.3 Local Variables in Macro Expansions    Local variable bindings in the expansion require special care.
13.6.4 Evaluating Macro Arguments in Expansion    Don't evaluate them; put them in the expansion.
13.6.5 How Many Times is the Macro Expanded?    Avoid depending on how many times expansion is done.

Writing Customization Definitions

14.1 Common Item Keywords    Common keyword arguments for all kinds of customization declarations.
14.2 Defining Customization Groups    Writing customization group definitions.
14.3 Defining Customization Variables    Declaring user options.
14.4 Customization Types    Specifying the type of a user option.

Customization Types

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


15.1 How Programs Do Loading    The load function and others.
15.2 Load Suffixes    Details about the suffixes that load tries.
15.3 Library Search    Finding a library to load.
15.4 Loading Non-ASCII Characters    Non-ASCII characters in Emacs Lisp files.
15.5 Autoload    Setting up a function to autoload.
15.6 Repeated Loading    Precautions about loading a file twice.
15.7 Features    Loading a library if it isn't already loaded.
15.8 Which File Defined a Certain Symbol    Finding which file defined a certain symbol.
15.9 Unloading    How to "unload" a library that was loaded.
15.10 Hooks for Loading    Providing code to be run when particular libraries are loaded.

Byte Compilation

16.1 Performance of Byte-Compiled Code    An example of speedup from byte compilation.
16.2 The Compilation Functions    Byte compilation functions.
16.3 Documentation Strings and Compilation    Dynamic loading of documentation strings.
16.4 Dynamic Loading of Individual Functions    Dynamic loading of individual functions.
16.5 Evaluation During Compilation    Code to be evaluated when you compile.
16.6 Compiler Errors    Handling compiler error messages.
16.7 Byte-Code Function Objects    The data type used for byte-compiled functions.
16.8 Disassembled Byte-Code    Disassembling byte-code; how to read byte-code.

Advising Emacs Lisp Functions

17.1 A Simple Advice Example    A simple example to explain the basics of advice.
17.2 Defining Advice    Detailed description of defadvice.
17.3 Around-Advice    Wrapping advice around a function's definition.
17.4 Computed Advice    ...is to defadvice as fset is to defun.
17.5 Activation of Advice    Advice doesn't do anything until you activate it.
17.6 Enabling and Disabling Advice    You can enable or disable each piece of advice.
17.7 Preactivation    Preactivation is a way of speeding up the loading of compiled advice.
17.8 Argument Access in Advice    How advice can access the function's arguments.
17.9 Advising Primitives    Accessing arguments when advising a primitive.
17.10 The Combined Definition    How advice is implemented.

Debugging Lisp Programs

18.1 The Lisp Debugger    How the Emacs Lisp debugger is implemented.
18.2 Edebug    A source-level Emacs Lisp debugger.
18.3 Debugging Invalid Lisp Syntax    How to find syntax errors.
18.4 Test Coverage    Ensuring you have tested all branches in your code.
18.5 Debugging Problems in Compilation    How to find errors that show up in byte compilation.

The Lisp Debugger

18.1.1 Entering the Debugger on an Error    Entering the debugger when an error happens.
18.1.2 Debugging Infinite Loops    Stopping and debugging a program that doesn't exit.
18.1.3 Entering the Debugger on a Function Call    Entering it when a certain function is called.
18.1.4 Explicit Entry to the Debugger    Entering it at a certain point in the program.
18.1.5 Using the Debugger    What the debugger does; what you see while in it.
18.1.6 Debugger Commands    Commands used while in the debugger.
18.1.7 Invoking the Debugger    How to call the function debug.
18.1.8 Internals of the Debugger    Subroutines of the debugger, and global variables.


18.2.1 Using Edebug    Introduction to use of Edebug.
18.2.2 Instrumenting for Edebug    You must instrument your code in order to debug it with Edebug.
18.2.3 Edebug Execution Modes    Execution modes, stopping more or less often.
18.2.4 Jumping    Commands to jump to a specified place.
18.2.5 Miscellaneous Edebug Commands    Miscellaneous commands.
18.2.6 Breaks    Setting breakpoints to make the program stop.
18.2.7 Trapping Errors    Trapping errors with Edebug.
18.2.8 Edebug Views    Views inside and outside of Edebug.
18.2.9 Evaluation    Evaluating expressions within Edebug.
18.2.10 Evaluation List Buffer    Expressions whose values are displayed each time you enter Edebug.
18.2.11 Printing in Edebug    Customization of printing.
18.2.12 Trace Buffer    How to produce trace output in a buffer.
18.2.13 Coverage Testing    How to test evaluation coverage.
18.2.14 The Outside Context    Data that Edebug saves and restores.
18.2.15 Edebug and Macros    Specifying how to handle macro calls.
18.2.16 Edebug Options    Option variables for customizing Edebug.

Debugging Invalid Lisp Syntax

18.3.1 Excess Open Parentheses    How to find a spurious open paren or missing close.
18.3.2 Excess Close Parentheses    How to find a spurious close paren or missing open.

Reading and Printing Lisp Objects

19.1 Introduction to Reading and Printing    Overview of streams, reading and printing.
19.2 Input Streams    Various data types that can be used as input streams.
19.3 Input Functions    Functions to read Lisp objects from text.
19.4 Output Streams    Various data types that can be used as output streams.
19.5 Output Functions    Functions to print Lisp objects as text.
19.6 Variables Affecting Output    Variables that control what the printing functions do.


20.1 Introduction to Minibuffers    Basic information about minibuffers.
20.2 Reading Text Strings with the Minibuffer    How to read a straight text string.
20.3 Reading Lisp Objects with the Minibuffer    How to read a Lisp object or expression.
20.4 Minibuffer History    Recording previous minibuffer inputs so the user can reuse them.
20.5 Initial Input    Specifying initial contents for the minibuffer.
20.6 Completion    How to invoke and customize completion.
20.7 Yes-or-No Queries    Asking a question with a simple answer.
20.8 Asking Multiple Y-or-N Questions    Asking a series of similar questions.
20.9 Reading a Password    Reading a password from the terminal.
20.10 Minibuffer Commands    Commands used as key bindings in minibuffers.
20.12 Minibuffer Contents    How such commands access the minibuffer text.
20.11 Minibuffer Windows    Operating on the special minibuffer windows.
20.13 Recursive Minibuffers    Whether recursive entry to minibuffer is allowed.
20.14 Minibuffer Miscellany    Various customization hooks and variables.


20.6.1 Basic Completion Functions    Low-level functions for completing strings.
                              (These are too low level to use the minibuffer.)
20.6.2 Completion and the Minibuffer    Invoking the minibuffer with completion.
20.6.3 Minibuffer Commands that Do Completion    Minibuffer commands that do completion.
20.6.4 High-Level Completion Functions    Convenient special cases of completion
                              (reading buffer name, file name, etc.)
20.6.5 Reading File Names    Using completion to read file names.
20.6.6 Programmed Completion    Finding the completions for a given file name.

Command Loop

21.1 Command Loop Overview    How the command loop reads commands.
21.2 Defining Commands    Specifying how a function should read arguments.
21.3 Interactive Call    Calling a command, so that it will read arguments.
21.4 Distinguish Interactive Calls    Making a command distinguish interactive calls.
21.5 Information from the Command Loop    Variables set by the command loop for you to examine.
21.6 Adjusting Point After Commands    Adjustment of point after a command.
21.7 Input Events    What input looks like when you read it.
21.8 Reading Input    How to read input events from the keyboard or mouse.
21.9 Special Events    Events processed immediately and individually.
21.10 Waiting for Elapsed Time or Input    Waiting for user input or elapsed time.
21.11 Quitting    How C-g works. How to catch or defer quitting.
21.12 Prefix Command Arguments    How the commands to set prefix args work.
21.13 Recursive Editing    Entering a recursive edit, and why you usually shouldn't.
21.14 Disabling Commands    How the command loop handles disabled commands.
21.15 Command History    How the command history is set up, and how accessed.
21.16 Keyboard Macros    How keyboard macros are implemented.

Defining Commands

21.2.1 Using interactive    General rules for interactive.
21.2.2 Code Characters for interactive    The standard letter-codes for reading arguments in various ways.
21.2.3 Examples of Using interactive    Examples of how to read interactive arguments.

Input Events

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

Reading Input

21.8.1 Key Sequence Input    How to read one key sequence.
21.8.2 Reading One Event    How to read just one event.
21.8.3 Modifying and Translating Input Events    How Emacs modifies events as they are read.
21.8.4 Invoking the Input Method    How reading an event uses the input method.
21.8.5 Quoted Character Input    Asking the user to specify a character.
21.8.6 Miscellaneous Event Input Features    How to reread or throw away input events.


22.1 Key Sequences    Key sequences as Lisp objects.
22.2 Keymap Basics    Basic concepts of keymaps.
22.3 Format of Keymaps    What a keymap looks like as a Lisp object.
22.4 Creating Keymaps    Functions to create and copy keymaps.
22.5 Inheritance and Keymaps    How one keymap can inherit the bindings of another keymap.
22.6 Prefix Keys    Defining a key with a keymap as its definition.
22.7 Active Keymaps    How Emacs searches the active keymaps for a key binding.
22.8 Searching the Active Keymaps    A pseudo-Lisp summary of searching active maps.
22.9 Controlling the Active Keymaps    Each buffer has a local keymap to override the standard (global) bindings. A minor mode can also override them.
22.10 Key Lookup    How extracting elements from keymaps works.
22.11 Functions for Key Lookup    How to request key lookup.
22.12 Changing Key Bindings    Redefining a key in a keymap.
22.13 Remapping Commands    A keymap can translate one command to another.
22.14 Keymaps for Translating Sequences of Events    Keymaps for translating sequences of events.
22.15 Commands for Binding Keys    Interactive interfaces for redefining keys.
22.16 Scanning Keymaps    Looking through all keymaps, for printing help.
22.17 Menu Keymaps    A keymap can define a menu for X or for use from the terminal.
H. Standard Keymaps    List of standard keymaps.

Major and Minor Modes

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

Menu Keymaps

22.17.1 Defining Menus    How to make a keymap that defines a menu.
22.17.2 Menus and the Mouse    How users actuate the menu with the mouse.
22.17.3 Menus and the Keyboard    How users actuate the menu with the keyboard.
22.17.4 Menu Example    Making a simple menu.
22.17.5 The Menu Bar    How to customize the menu bar.
22.17.6 Tool bars    A tool bar is a row of images.
22.17.7 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

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

Major Modes

23.2.1 Major Mode Basics   
23.2.2 Major Mode Conventions    Coding conventions for keymaps, etc.
23.2.8 Major Mode Examples    Text mode and Lisp modes.
23.2.3 How Emacs Chooses a Major Mode    How Emacs chooses the major mode automatically.
23.2.4 Getting Help about a Major Mode    Finding out how to use a mode.
23.2.5 Defining Derived Modes    Defining a new major mode based on another major mode.
23.2.6 Generic Modes    Defining a simple major mode that supports comment syntax and Font Lock mode.
23.2.7 Mode Hooks    Hooks run at the end of major mode functions.

Minor Modes

23.3.1 Conventions for Writing Minor Modes    Tips for writing a minor mode.
23.3.2 Keymaps and Minor Modes    How a minor mode can have its own keymap.
23.3.3 Defining Minor Modes    A convenient facility for defining minor modes.

Mode Line Format

23.4.1 Mode Line Basics   
23.4.2 The Data Structure of the Mode Line    The data structure that controls the mode line.
23.4.4 Variables Used in the Mode Line    Variables used in that data structure.
23.4.5 %-Constructs in the Mode Line    Putting information into a mode line.
23.4.6 Properties in the Mode Line    Using text properties in the mode line.
23.4.7 Window Header Lines    Like a mode line, but at the top.
23.4.8 Emulating Mode-Line Formatting    Formatting text as the mode line would.

Font Lock Mode

23.6.1 Font Lock Basics    Overview of customizing Font Lock.
23.6.2 Search-based Fontification    Fontification based on regexps.
23.6.3 Customizing Search-Based Fontification    Customizing search-based fontification.
23.6.4 Other Font Lock Variables    Additional customization facilities.
23.6.5 Levels of Font Lock    Each mode can define alternative levels so that the user can select more or less.
23.6.6 Precalculated Fontification    How Lisp programs that produce the buffer contents can also specify how to fontify it.
23.6.7 Faces for Font Lock    Special faces specifically for Font Lock.
23.6.8 Syntactic Font Lock    Fontification based on syntax tables.
23.6.9 Setting Syntax Properties    Defining character syntax based on context using the Font Lock mechanism.
23.6.10 Multiline Font Lock Constructs    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 after a Buffer Change    Controlling which region gets refontified after a buffer change.


24.1 Documentation Basics    Good style for doc strings. Where to put them. How Emacs stores them.
24.2 Access to Documentation Strings    How Lisp programs can access doc strings.
24.3 Substituting Key Bindings in Documentation    Substituting current key bindings.
24.4 Describing Characters for Help Messages    Making printable descriptions of non-printing characters and key sequences.
24.5 Help Functions    Subroutines used by Emacs help facilities.


25.1 Visiting Files    Reading files into Emacs buffers for editing.
25.2 Saving Buffers    Writing changed buffers back into files.
25.3 Reading from Files    Reading files into other buffers.
25.4 Writing to Files    Writing new files from parts of buffers.
25.5 File Locks    Locking and unlocking files, to prevent simultaneous editing by two people.
25.6 Information about Files    Testing existence, accessibility, size of files.
25.7 Changing File Names and Attributes    Renaming files, changing protection, etc.
25.8 File Names    Decomposing and expanding file names.
25.9 Contents of Directories    Getting a list of the files in a directory.
25.10 Creating and Deleting Directories   
25.11 Making Certain File Names "Magic"    Defining "magic" special handling for certain file names.
25.12 File Format Conversion    Conversion to and from various file formats.

Visiting Files

25.1.1 Functions for Visiting Files    The usual interface functions for visiting.
25.1.2 Subroutines of Visiting    Lower-level subroutines that they use.

Information about Files

25.6.1 Testing Accessibility    Is a given file readable? Writable?
25.6.2 Distinguishing Kinds of Files    Is it a directory? A symbolic link?
25.6.3 Truenames    Eliminating symbolic links from a file name.
25.6.4 Other Information about Files    How large is it? Any other names? Etc.
25.6.5 How to Locate Files in Standard Places    How to find a file in standard places.

File Names

25.8.1 File Name Components    The directory part of a file name, and the rest.
25.8.2 Absolute and Relative File Names    Some file names are relative to a current directory.
25.8.3 Directory Names    A directory's name as a directory is different from its name as a file.
25.8.4 Functions that Expand Filenames    Converting relative file names to absolute ones.
25.8.5 Generating Unique File Names    Generating names for temporary files.
25.8.6 File Name Completion    Finding the completions for a given file name.
25.8.7 Standard File Names    If your package uses a fixed file name, how to handle various operating systems simply.

Backups and Auto-Saving

26.1 Backup Files    How backup files are made; how their names are chosen.
26.2 Auto-Saving    How auto-save files are made; how their names are chosen.
26.3 Reverting    revert-buffer, and how to customize what it does.

Backup Files

26.1.1 Making Backup Files    How Emacs makes backup files, and when.
26.1.2 Backup by Renaming or by Copying?    Two alternatives: renaming the old file or copying it.
26.1.3 Making and Deleting Numbered Backup Files    Keeping multiple backups for each source file.
26.1.4 Naming Backup Files    How backup file names are computed; customization.


27.1 Buffer Basics    What is a buffer?
27.2 The Current Buffer    Designating a buffer as current so primitives will access its contents.
27.3 Buffer Names    Accessing and changing buffer names.
27.4 Buffer File Name    The buffer file name indicates which file is visited.
27.5 Buffer Modification    A buffer is modified if it needs to be saved.
27.6 Buffer Modification Time    Determining whether the visited file was changed
                              "behind Emacs's back".
27.7 Read-Only Buffers    Modifying text is not allowed in a read-only buffer.
27.8 The Buffer List    How to look at all the existing buffers.
27.9 Creating Buffers    Functions that create buffers.
27.10 Killing Buffers    Buffers exist until explicitly killed.
27.11 Indirect Buffers    An indirect buffer shares text with some other buffer.
27.12 The Buffer Gap    The gap in the buffer.


28.1 Basic Concepts of Emacs Windows    Basic information on using windows.
28.2 Splitting Windows    Splitting one window into two windows.
28.3 Deleting Windows    Deleting a window gives its space to other windows.
28.4 Selecting Windows    The selected window is the one that you edit in.
28.5 Cyclic Ordering of Windows    Moving around the existing windows.
28.6 Buffers and Windows    Each window displays the contents of a buffer.
28.7 Displaying Buffers in Windows    Higher-level functions for displaying a buffer and choosing a window for it.
28.8 Choosing a Window for Display    How to choose a window for displaying a buffer.
28.9 Windows and Point    Each window has its own location of point.
28.10 The Window Start Position    The display-start position controls which text is on-screen in the window.
28.11 Textual Scrolling    Moving text up and down through the window.
28.12 Vertical Fractional Scrolling    Moving the contents up and down on the window.
28.13 Horizontal Scrolling    Moving the contents sideways on the window.
28.14 The Size of a Window    Accessing the size of a window.
28.15 Changing the Size of a Window    Changing the size of a window.
28.16 Coordinates and Windows    Converting coordinates to windows.
28.17 The Window Tree    The layout and sizes of all windows in a frame.
28.18 Window Configurations    Saving and restoring the state of the screen.
28.19 Hooks for Window Scrolling and Changes    Hooks for scrolling, window size changes, redisplay going past a certain point, or window configuration changes.


29.1 Creating Frames    Creating additional frames.
29.2 Multiple Displays    Creating frames on other displays.
29.3 Frame Parameters    Controlling frame size, position, font, etc.
29.4 Frame Titles    Automatic updating of frame titles.
29.5 Deleting Frames    Frames last until explicitly deleted.
29.6 Finding All Frames    How to examine all existing frames.
29.7 Frames and Windows    A frame contains windows; display of text always works through windows.
29.8 Minibuffers and Frames    How a frame finds the minibuffer to use.
29.9 Input Focus    Specifying the selected frame.
29.10 Visibility of Frames    Frames may be visible or invisible, or icons.
29.11 Raising and Lowering Frames    Raising a frame makes it hide other windows; lowering it puts it underneath the others.
29.12 Frame Configurations    Saving the state of all frames.
29.13 Mouse Tracking    Getting events that say when the mouse moves.
29.14 Mouse Position    Asking where the mouse is, or moving it.
29.15 Pop-Up Menus    Displaying a menu for the user to select from.
29.16 Dialog Boxes    Displaying a box to ask yes or no.
29.17 Pointer Shape    Specifying the shape of the mouse pointer.
29.18 Window System Selections    Transferring text to and from other windows.
29.19 Drag and Drop    Internals of Drag-and-Drop implementation.
29.20 Color Names    Getting the definitions of color names.
29.21 Text Terminal Colors    Defining colors for text-only terminals.
29.22 X Resources    Getting resource values from the server.
29.23 Display Feature Testing    Determining the features of a terminal.

Frame Parameters

29.3.1 Access to Frame Parameters    How to change a frame's parameters.
29.3.2 Initial Frame Parameters    Specifying frame parameters when you make a frame.
29.3.3 Window Frame Parameters    List of frame parameters for window systems.
29.3.4 Frame Size And Position    Changing the size and position of a frame.
29.3.5 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. Window Management Parameters    Communicating with the window manager. Cursor Parameters    Controlling the cursor appearance. Color Parameters    Colors of various parts of the frame.


30.1 Point    The special position where editing takes place.
30.2 Motion    Changing point.
30.3 Excursions    Temporary motion and buffer changes.
30.4 Narrowing    Restricting editing to a portion of the buffer.


30.2.1 Motion by Characters    Moving in terms of characters.
30.2.2 Motion by Words    Moving in terms of words.
30.2.3 Motion to an End of the Buffer    Moving to the beginning or end of the buffer.
30.2.4 Motion by Text Lines    Moving in terms of lines of text.
30.2.5 Motion by Screen Lines    Moving in terms of lines as displayed.
30.2.6 Moving over Balanced Expressions    Moving by parsing lists and sexps.
30.2.7 Skipping Characters    Skipping characters belonging to a certain set.


31.1 Overview of Markers    The components of a marker, and how it relocates.
31.2 Predicates on Markers    Testing whether an object is a marker.
31.3 Functions that Create Markers    Making empty markers or markers at certain places.
31.4 Information from Markers    Finding the marker's buffer or character position.
31.5 Marker Insertion Types    Two ways a marker can relocate when you insert where it points.
31.6 Moving Marker Positions    Moving the marker to a new buffer or position.
31.7 The Mark    How "the mark" is implemented with a marker.
31.8 The Region    How to access "the region".


32.1 Examining Text Near Point    Examining text in the vicinity of point.
32.2 Examining Buffer Contents    Examining text in a general fashion.
32.3 Comparing Text    Comparing substrings of buffers.
32.4 Inserting Text    Adding new text to a buffer.
32.5 User-Level Insertion Commands    User-level commands to insert text.
32.6 Deleting Text    Removing text from a buffer.
32.7 User-Level Deletion Commands    User-level commands to delete text.
32.8 The Kill Ring    Where removed text sometimes is saved for later use.
32.9 Undo    Undoing changes to the text of a buffer.
32.10 Maintaining Undo Lists    How to enable and disable undo information. How to control how much information is kept.
32.11 Filling    Functions for explicit filling.
32.12 Margins for Filling    How to specify margins for filling commands.
32.13 Adaptive Fill Mode    Adaptive Fill mode chooses a fill prefix from context.
32.14 Auto Filling    How auto-fill mode is implemented to break lines.
32.15 Sorting Text    Functions for sorting parts of the buffer.
32.16 Counting Columns    Computing horizontal positions, and using them.
32.17 Indentation    Functions to insert or adjust indentation.
32.18 Case Changes    Case conversion of parts of the buffer.
32.19 Text Properties    Assigning Lisp property lists to text characters.
32.20 Substituting for a Character Code    Replacing a given character wherever it appears.
32.22 Transposition of Text    Swapping two portions of a buffer.
32.21 Registers    How registers are implemented. Accessing the text or position stored in a register.
32.23 Base 64 Encoding    Conversion to or from base 64 encoding.
32.24 MD5 Checksum    Compute the MD5 "message digest"/"checksum".
32.25 Atomic Change Groups    Installing several buffer changes "atomically".
32.26 Change Hooks    Supplying functions to be run when text is changed.

The Kill Ring

32.8.1 Kill Ring Concepts    What text looks like in the kill ring.
32.8.2 Functions for Killing    Functions that kill text.
32.8.3 Yanking    How yanking is done.
32.8.4 Functions for Yanking    Commands that access the kill ring.
32.8.5 Low-Level Kill Ring    Functions and variables for kill ring access.
32.8.6 Internals of the Kill Ring    Variables that hold kill-ring data.


32.17.1 Indentation Primitives    Functions used to count and insert indentation.
32.17.2 Indentation Controlled by Major Mode    Customize indentation for different modes.
32.17.3 Indenting an Entire Region    Indent all the lines in a region.
32.17.4 Indentation Relative to Previous Lines    Indent the current line based on previous lines.
32.17.5 Adjustable "Tab Stops"    Adjustable, typewriter-like tab stops.
32.17.6 Indentation-Based Motion Commands    Move to first non-blank character.

Text Properties

32.19.1 Examining Text Properties    Looking at the properties of one character.
32.19.2 Changing Text Properties    Setting the properties of a range of text.
32.19.3 Text Property Search Functions    Searching for where a property changes value.
32.19.4 Properties with Special Meanings    Particular properties with special meanings.
32.19.5 Formatted Text Properties    Properties for representing formatting of text.
32.19.6 Stickiness of Text Properties    How inserted text gets properties from neighboring text.
32.19.7 Lazy Computation of Text Properties    Computing text properties in a lazy fashion only when text is examined.
32.19.8 Defining Clickable Text    Using text properties to make regions of text do something when you click on them.
32.19.9 Links and Mouse-1    How to make Mouse-1 follow a link.
32.19.10 Defining and Using Fields    The field property defines fields within the buffer.
32.19.11 Why Text Properties are not Intervals    Why text properties do not use Lisp-visible text intervals.

Non-ASCII Characters

33.1 Text Representations    Unibyte and multibyte representations
33.2 Converting Text Representations    Converting unibyte to multibyte and vice versa.
33.3 Selecting a Representation    Treating a byte sequence as unibyte or multi.
33.4 Character Codes    How unibyte and multibyte relate to codes of individual characters.
33.5 Character Sets    The space of possible character codes is divided into various character sets.
33.6 Characters and Bytes    More information about multibyte encodings.
33.7 Splitting Characters    Converting a character to its byte sequence.
33.8 Scanning for Character Sets    Which character sets are used in a buffer?
33.9 Translation of Characters    Translation tables are used for conversion.
33.10 Coding Systems    Coding systems are conversions for saving files.
33.11 Input Methods    Input methods allow users to enter various non-ASCII characters without special keyboards.
33.12 Locales    Interacting with the POSIX locale.

Coding Systems

33.10.1 Basic Concepts of Coding Systems    Basic concepts.
33.10.2 Encoding and I/O    How file I/O functions handle coding systems.
33.10.3 Coding Systems in Lisp    Functions to operate on coding system names.
33.10.4 User-Chosen Coding Systems    Asking the user to choose a coding system.
33.10.5 Default Coding Systems    Controlling the default choices.
33.10.6 Specifying a Coding System for One Operation    Requesting a particular coding system for a single file operation.
33.10.7 Explicit Encoding and Decoding    Encoding or decoding text without doing I/O.
33.10.8 Terminal I/O Encoding    Use of encoding for terminal I/O.
33.10.9 MS-DOS File Types    How DOS "text" and "binary" files relate to coding systems.

Searching and Matching

34.1 Searching for Strings    Search for an exact match.
34.2 Searching and Case    Case-independent or case-significant searching.
34.3 Regular Expressions    Describing classes of strings.
34.4 Regular Expression Searching    Searching for a match for a regexp.
34.5 POSIX Regular Expression Searching    Searching POSIX-style for the longest match.
34.6 The Match Data    Finding out which part of the text matched, after a string or regexp search.
34.7 Search and Replace    Commands that loop, searching and replacing.
34.8 Standard Regular Expressions Used in Editing    Useful regexps for finding sentences, pages,...

Regular Expressions

34.3.1 Syntax of Regular Expressions    Rules for writing regular expressions.
34.3.2 Complex Regexp Example    Illustrates regular expression syntax.
34.3.3 Regular Expression Functions    Functions for operating on regular expressions.

Syntax of Regular Expressions Special Characters in Regular Expressions    Special characters in regular expressions. Character Classes    Character classes used in regular expressions. Backslash Constructs in Regular Expressions    Backslash-sequences in regular expressions.

The Match Data

34.6.1 Replacing the Text that Matched    Replacing a substring that was matched.
34.6.2 Simple Match Data Access    Accessing single items of match data, such as where a particular subexpression started.
34.6.3 Accessing the Entire Match Data    Accessing the entire match data at once, as a list.
34.6.4 Saving and Restoring the Match Data    Saving and restoring the match data.

Syntax Tables

35.1 Syntax Table Concepts    Basic concepts of syntax tables.
35.2 Syntax Descriptors    How characters are classified.
35.3 Syntax Table Functions    How to create, examine and alter syntax tables.
35.4 Syntax Properties    Overriding syntax with text properties.
35.5 Motion and Syntax    Moving over characters with certain syntaxes.
35.6 Parsing Expressions    Parsing balanced expressions using the syntax table.
35.7 Some Standard Syntax Tables    Syntax tables used by various major modes.
35.8 Syntax Table Internals    How syntax table information is stored.
35.9 Categories    Another way of classifying character syntax.

Syntax Descriptors

35.2.1 Table of Syntax Classes    Table of syntax classes.
35.2.2 Syntax Flags    Additional flags each character can have.

Parsing Expressions

35.6.1 Motion Commands Based on Parsing    Motion functions that work by parsing.
35.6.2 Finding the Parse State for a Position    Determining the syntactic state of a position.
35.6.3 Parser State    How Emacs represents a syntactic state.
35.6.4 Low-Level Parsing    Parsing across a specified region.
35.6.5 Parameters to Control Parsing    Parameters that affect parsing.

Abbrevs And Abbrev Expansion

36.1 Setting Up Abbrev Mode    Setting up Emacs for abbreviation.
36.2 Abbrev Tables    Creating and working with abbrev tables.
36.3 Defining Abbrevs    Specifying abbreviations and their expansions.
36.4 Saving Abbrevs in Files    Saving abbrevs in files.
36.5 Looking Up and Expanding Abbreviations    Controlling expansion; expansion subroutines.
36.6 Standard Abbrev Tables    Abbrev tables used by various major modes.


37.1 Functions that Create Subprocesses    Functions that start subprocesses.
37.2 Shell Arguments    Quoting an argument to pass it to a shell.
37.3 Creating a Synchronous Process    Details of using synchronous subprocesses.
37.4 Creating an Asynchronous Process    Starting up an asynchronous subprocess.
37.5 Deleting Processes    Eliminating an asynchronous subprocess.
37.6 Process Information    Accessing run-status and other attributes.
37.7 Sending Input to Processes    Sending input to an asynchronous subprocess.
37.8 Sending Signals to Processes    Stopping, continuing or interrupting an asynchronous subprocess.
37.9 Receiving Output from Processes    Collecting output from an asynchronous subprocess.
37.10 Sentinels: Detecting Process Status Changes    Sentinels run when process run-status changes.
37.11 Querying Before Exit    Whether to query if exiting will kill a process.
37.12 Transaction Queues    Transaction-based communication with subprocesses.
37.13 Network Connections    Opening network connections.
37.14 Network Servers    Network servers let Emacs accept net connections.
37.15 Datagrams    UDP network connections.
37.16 Low-Level Network Access    Lower-level but more general function to create connections and servers.
37.17 Misc Network Facilities    Additional relevant functions for network connections.
37.18 Packing and Unpacking Byte Arrays    Using bindat to pack and unpack binary data.

Receiving Output from Processes

37.9.1 Process Buffers    If no filter, output is put in a buffer.
37.9.2 Process Filter Functions    Filter functions accept output from the process.
37.9.3 Decoding Process Output    Filters can get unibyte or multibyte strings.
37.9.4 Accepting Output from Processes    How to wait until process output arrives.

Low-Level Network Access

37.16.1 make-network-process    Using make-network-process.
37.16.2 Network Options    Further control over network connections.
37.16.3 Testing Availability of Network Features    Determining which network features work on the machine you are using.

Packing and Unpacking Byte Arrays

37.18.1 Describing Data Layout    Describing data layout.
37.18.2 Functions to Unpack and Pack Bytes    Doing the unpacking and packing.
37.18.3 Examples of Byte Unpacking and Packing    Samples of what bindat.el can do for you!

Emacs Display

38.1 Refreshing the Screen    Clearing the screen and redrawing everything on it.
38.2 Forcing Redisplay    Forcing redisplay.
38.3 Truncation    Folding or wrapping long text lines.
38.4 The Echo Area    Displaying messages at the bottom of the screen.
38.5 Reporting Warnings    Displaying warning messages for the user.
38.6 Invisible Text    Hiding part of the buffer text.
38.7 Selective Display    Hiding part of the buffer text (the old way).
38.8 Temporary Displays    Displays that go away automatically.
38.9 Overlays    Use overlays to highlight parts of the buffer.
38.10 Width    How wide a character or string is on the screen.
38.11 Line Height    Controlling the height of lines.
38.12 Faces    A face defines a graphics style for text characters: font, colors, etc.
38.13 Fringes    Controlling window fringes.
38.14 Scroll Bars    Controlling vertical scroll bars.
38.15 The display Property    Enabling special display features.
38.16 Images    Displaying images in Emacs buffers.
38.17 Buttons    Adding clickable buttons to Emacs buffers.
38.18 Abstract Display    Emacs' Widget for Object Collections.
38.19 Blinking Parentheses    How Emacs shows the matching open parenthesis.
38.20 Usual Display Conventions    The usual conventions for displaying nonprinting chars.
38.21 Display Tables    How to specify other conventions.
38.22 Beeping    Audible signal to the user.
38.23 Window Systems    Which window system is being used.

The Echo Area

38.4.1 Displaying Messages in the Echo Area    Explicitly displaying text in the echo area.
38.4.2 Reporting Operation Progress    Informing user about progress of a long operation.
38.4.3 Logging Messages in `*Messages*'    Echo area messages are logged for the user.
38.4.4 Echo Area Customization    Controlling the echo area.

Reporting Warnings

38.5.1 Warning Basics    Warnings concepts and functions to report them.
38.5.2 Warning Variables    Variables programs bind to customize their warnings.
38.5.3 Warning Options    Variables users set to control display of warnings.


38.9.1 Managing Overlays    Creating and moving overlays.
38.9.2 Overlay Properties    How to read and set properties. What properties do to the screen display.
38.9.3 Searching for Overlays    Searching for overlays.


38.12.1 Defining Faces    How to define a face with defface.
38.12.2 Face Attributes    What is in a face?
38.12.3 Face Attribute Functions    Functions to examine and set face attributes.
38.12.4 Displaying Faces    How Emacs combines the faces specified for a character.
38.12.5 Font Selection    Finding the best available font for a face.
38.12.6 Functions for Working with Faces    How to define and examine faces.
38.12.7 Automatic Face Assignment    Hook for automatic face assignment.
38.12.8 Looking Up Fonts    Looking up the names of available fonts and information about them.
38.12.9 Fontsets    A fontset is a collection of fonts that handle a range of character sets.


38.13.1 Fringe Size and Position    Specifying where to put the window fringes.
38.13.2 Fringe Indicators    Displaying indicator icons in the window fringes.
38.13.3 Fringe Cursors    Displaying cursors in the right fringe.
38.13.4 Fringe Bitmaps    Specifying bitmaps for fringe indicators.
38.13.5 Customizing Fringe Bitmaps    Specifying your own bitmaps to use in the fringes.
38.13.6 The Overlay Arrow    Display of an arrow to indicate position.

The display Property

38.15.2 Specified Spaces    Displaying one space with a specified width.
38.15.3 Pixel Specification for Spaces    Specifying space width or height in pixels.
38.15.4 Other Display Specifications    Displaying an image; magnifying text; moving it up or down on the page; adjusting the width of spaces within text.
38.15.5 Displaying in the Margins    Displaying text or images to the side of the main text.


38.16.2 Image Descriptors    How to specify an image for use in :display.
38.16.3 XBM Images    Special features for XBM format.
38.16.4 XPM Images    Special features for XPM format.
38.16.5 GIF Images    Special features for GIF format.
38.16.6 PostScript Images    Special features for PostScript format.
38.16.7 Other Image Types    Various other formats are supported.
38.16.8 Defining Images    Convenient ways to define an image for later use.
38.16.9 Showing Images    Convenient ways to display an image once it is defined.
38.16.10 Image Cache    Internal mechanisms of image display.


38.17.1 Button Properties    Button properties with special meanings.
38.17.2 Button Types    Defining common properties for classes of buttons.
38.17.3 Making Buttons    Adding buttons to Emacs buffers.
38.17.4 Manipulating Buttons    Getting and setting properties of buttons.
38.17.5 Button Buffer Commands    Buffer-wide commands and bindings for buttons.

Abstract Display

38.18.1 Abstract Display Functions    Functions in the Ewoc package.
38.18.2 Abstract Display Example    Example of using Ewoc.

Display Tables

38.21.1 Display Table Format    What a display table consists of.
38.21.2 Active Display Table    How Emacs selects a display table to use.
38.21.3 Glyphs    How to define a glyph, and what glyphs mean.

Operating System Interface

39.1 Starting Up Emacs    Customizing Emacs start-up processing.
39.2 Getting Out of Emacs    How exiting works (permanent or temporary).
39.3 Operating System Environment    Distinguish the name and kind of system.
39.4 User Identification    Finding the name and user id of the user.
39.5 Time of Day    Getting the current time.
39.6 Time Conversion    Converting a time from numeric form to a string, or to calendrical data (or vice versa).
39.7 Parsing and Formatting Times    Converting a time from numeric form to text and vice versa.
39.8 Processor Run time    Getting the run time used by Emacs.
39.9 Time Calculations    Adding, subtracting, comparing times, etc.
39.10 Timers for Delayed Execution    Setting a timer to call a function at a certain time.
39.11 Idle Timers    Setting a timer to call a function when Emacs has been idle for a certain length of time.
39.12 Terminal Input    Accessing and recording terminal input.
39.13 Terminal Output    Controlling and recording terminal output.
39.14 Sound Output    Playing sounds on the computer's speaker.
39.15 Operating on X11 Keysyms    Operating on key symbols for X Windows
39.16 Batch Mode    Running Emacs without terminal interaction.
39.17 Session Management    Saving and restoring state with X Session Management.

Starting Up Emacs

39.1.1 Summary: Sequence of Actions at Startup    Sequence of actions Emacs performs at start-up.
39.1.2 The Init File, `.emacs'    Details on reading the init file (`.emacs').
39.1.3 Terminal-Specific Initialization    How the terminal-specific Lisp file is read.
39.1.4 Command-Line Arguments    How command-line arguments are processed, and how you can customize them.

Getting Out of Emacs

39.2.1 Killing Emacs    Exiting Emacs irreversibly.
39.2.2 Suspending Emacs    Exiting Emacs reversibly.

Terminal Input

39.12.1 Input Modes    Options for how input is processed.
39.12.2 Recording Input    Saving histories of recent or all input events.

Tips and Conventions

D.1 Emacs Lisp Coding Conventions    Conventions for clean and robust programs.
D.2 Key Binding Conventions    Which keys should be bound by which programs.
D.3 Emacs Programming Tips    Making Emacs code fit smoothly in Emacs.
D.4 Tips for Making Compiled Code Fast    Making compiled code run fast.
D.5 Tips for Avoiding Compiler Warnings    Turning off compiler warnings.
D.6 Tips for Documentation Strings    Writing readable documentation strings.
D.7 Tips on Writing Comments    Conventions for writing comments.
D.8 Conventional Headers for Emacs Libraries    Standard headers for library packages.

GNU Emacs Internals

E.1 Building Emacs    How the dumped Emacs is made.
E.2 Pure Storage    A kludge to make preloaded Lisp functions sharable.
E.3 Garbage Collection    Reclaiming space for Lisp objects no longer used.
E.4 Memory Usage    Info about total size of Lisp objects made so far.
E.5 Writing Emacs Primitives    Writing C code for Emacs.
E.6 Object Internals    Data formats of buffers, windows, processes.

Object Internals

E.6.1 Buffer Internals    Components of a buffer structure.
E.6.2 Window Internals    Components of a window structure.
E.6.3 Process Internals    Components of a process structure.