GNU Emacs Lisp Reference Manual

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.

Appendices

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:

Introduction

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.

Conventions

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

1.3.7.1 A Sample Function Description		A description of an imaginary function, foo.
1.3.7.2 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

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

Cons Cell and List Types

2.3.6.1 Drawing Lists as Box Diagrams		Drawing pictures of lists.
2.3.6.2 Dotted Pair Notation		An alternative syntax for lists.
2.3.6.3 Association List Type		A specially constructed list.

String Type

2.3.8.1 Syntax for Strings		How to specify Lisp strings.
2.3.8.2 Non-ASCII Characters in Strings		International characters in strings.
2.3.8.3 Nonprinting Characters in Strings		Literal unprintable characters in strings.
2.3.8.4 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.

Numbers

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.

Lists

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.

Symbols

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.

Evaluation

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

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

Variables

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.

Functions

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.

Macros

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.

Loading

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.

Edebug

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.

Minibuffers

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.

Completion

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.

Keymaps

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

22.17.1.1 Simple Menu Items		A simple kind of menu key binding, limited in capabilities.
22.17.1.2 Extended Menu Items		More powerful menu item definitions let you specify keywords to enable various features.
22.17.1.3 Menu Separators		Drawing a horizontal line through a menu.
22.17.1.4 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

23.6.10.1 Font Lock Multiline		Marking multiline chunks with a text property
23.6.10.2 Region to Fontify after a Buffer Change		Controlling which region gets refontified after a buffer change.

Documentation

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.

Files

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.

Buffers

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.

Windows

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.

Frames

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

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

Positions

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.

Motion

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.

Markers

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".

Text

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.

Indentation

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

34.3.1.1 Special Characters in Regular Expressions		Special characters in regular expressions.
34.3.1.2 Character Classes		Character classes used in regular expressions.
34.3.1.3 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.

Processes

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.

Overlays

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.

Faces

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.

Fringes

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.

Images

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.

Buttons

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.

mail: