GNU Emacs Lisp 参考文档

Short Contents

Table of Contents

Next: 介绍, Previous: (dir), Up: (dir)

Emacs Lisp

这是GNU Emacs Lisp参考文档的3.0版本，对应于Emacs23.3版本。

由张东亚汉化，汉化版本为0.1。

更新记录：

2011/06/22：启动第二章的翻译，待完成。

2011/07/02：完成第二章的翻译。

2011/08/07：启动第三章的翻译。

2011/09/19：完成第三章的翻译。

2011/11/28：启动第四章的翻译，待完成。

2012/06/23：完成lists.texi的翻译。 Copyright © 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011 Free Software Foundation, Inc.

Permission is granted to copy, distribute and/or modify this document under the terms of the GNU Free Documentation License, Version 1.3 or any later version published by the Free Software Foundation; with the Invariant Sections being “GNU General Public License,” with the Front-Cover texts being “A GNU Manual,” and with the Back-Cover Texts as in (a) below. A copy of the license is included in the section entitled “GNU Free Documentation License.”
(a) The FSF's Back-Cover Text is: “You have the freedom to copy and modify this GNU manual. Buying copies from the FSF supports it in developing GNU and promoting software freedom.”

介绍: 介绍以及惯例
Lisp数据类型: Emacs Lisp中的数据类型。
数字: 数值与算术运算函数。
字符串与字符: 字符串，以及操作字符串的函数。
列表: 列表，cons cell以及相关函数。
Sequences Arrays Vectors: Lists, strings and vectors are called sequences. Certain functions act on any kind of sequence. The description of vectors is here as well.
Hash Tables: Very fast lookup-tables.
Symbols: Symbols represent names, uniquely.
Evaluation: How Lisp expressions are evaluated.
Control Structures: Conditionals, loops, nonlocal exits.
Variables: Using symbols in programs to stand for values.
Functions: A function is a Lisp program that can be invoked from other functions.
Macros: Macros are a way to extend the Lisp language.
Customization: Writing customization declarations.
Loading: Reading files of Lisp code into Lisp.
Byte Compilation: Compilation makes programs run faster.
Advising Functions: Adding to the definition of a function.
Debugging: Tools and tips for debugging Lisp programs.
Read and Print: Converting Lisp objects to text and back.
Minibuffers: Using the minibuffer to read input.
Command Loop: How the editor command loop works, and how you can call its subroutines.
Keymaps: Defining the bindings from keys to commands.
Modes: Defining major and minor modes.
Documentation: Writing and using documentation strings.
Files: Accessing files.
Backups and Auto-Saving: Controlling how backups and auto-save files are made.
Buffers: Creating and using buffer objects.
Windows: Manipulating windows and displaying buffers.
Frames: Making multiple system-level windows.
Positions: Buffer positions and motion functions.
Markers: Markers represent positions and update automatically when the text is changed.
Text: Examining and changing text in buffers.
Non-ASCII Characters: Non-ASCII text in buffers and strings.
Searching and Matching: Searching buffers for strings or regexps.
Syntax Tables: The syntax table controls word and list parsing.
Abbrevs: How Abbrev mode works, and its data structures.
Processes: Running and communicating with subprocesses.
Display: Features for controlling the screen display.
System Interface: Getting the user id, system type, environment variables, and other such things.

Appendices

Antinews: Info for users downgrading to Emacs 22.
GNU Free Documentation License: The license for this documentation.
GPL: Conditions for copying and changing GNU Emacs.
Tips: Advice and coding conventions for Emacs Lisp.
GNU Emacs Internals: Building and dumping Emacs; internal data structures.
Standard Errors: List of all error symbols.
Standard Buffer-Local Variables List of variables buffer-local in all buffers.
Standard Keymaps: List of standard keymaps.
Standard Hooks: List of standard hook variables.
Index: Index including concepts, functions, variables, and other terms.

--- 下列详细章节 --- ---------------------------------

这些章节是上面列出章节的子节，这里列出以便于你可以直接查阅。

惯例

描述信息格式

Lisp数据类型

编程类型

整数类型: 不包含分数部分的数字。
浮点类型: 包含分数部分的数字，具有更大的值域。
字符类型: 字母、数字以及控制字符的表示。
符号类型: 多用途的对象，用于引用函数、变量或者属性表，具有唯一的标识。
序列类型: 表和数组都被归为序列。
Cons Cell类型: Cons cells,和表(由Cons cell组成)。
数组类型: 数据包括字符串和容器。
字符串类型: 有效的字符数组。
容器类型: 一维数组。
字符表类型: 由字符索引的稀松一维数组。
布尔容器类型: 由t或nil组成的一维数组。
哈希表类型: 超快的查找表。
函数类型: 一块被调用的可执行代码。
宏类型: 用于将表达式展开成另外一个更基本但不美观的表达式的方法。
原始函数类型: 由C语言写成的函数，在Lisp程序中调用。
字节码类型: Lisp写成的函数，编译后的对象。
自动加载类型: 自动加载较少使用的函数。

字符类型

Cons Cell和表类型

字符串类型

编辑类型

缓冲区类型: 编辑的基本对象。
标记类型: 缓冲区的一个位置。
窗口类型: 缓冲区在窗口中显示。
框类型: 窗口分割框。
终端类型: 显示框的终端设备。
窗口配置类型: 记录框的分割方式。
框配置类型: 记录所有框的状态。
进程类型: Emacs的子进程，进行在所属OS上。
流类型: 接收或发送字符。
按键映射类型: 按键发生时，哪个函数被调用。
覆盖类型: 覆盖如何表示。
字体类型: 用于显示文本的字体。

数字

字符串与字符

字符串基础: 字符串和字符的基础属性。
字符串判定: 测试对象是否是字符串或字符。
创建字符串: 用于分配字符串的函数。
修改字符串: 替换即有字符串的内容。
文本比较: 字符或字符串比较。
字符串转换: 从字符串或字符中转入转出。
格式化字符串: format：Emacs与printf相似的函数。
大小写转换: 大小写转换函数。
大小写表: 定制大小写转换。

列表

Cons Cells: 如何由cons cell构造列表。
列表相关的判定: 这个对象是列表吗？比如两个列表。
列表元素: 从列表中提取元素。
构造列表: 创建列表结构。
列表变量: 修改存储在变量里的列表。
修改列表: 向既有列表中存储新元素。
集合与列表: 列表可表示一个有限的数学集合。
关联列表: 列表可表示一个有效的关系或映射。
环: 管理有个固定大小的对对象环。

修改既有的列表结构

Sequences, Arrays, and Vectors

Hash Tables

Symbols

Property Lists

Evaluation

Kinds of Forms

Self-Evaluating Forms: Forms that evaluate to themselves.
Symbol Forms: Symbols evaluate as variables.
Classifying Lists: How to distinguish various sorts of list forms.
Function Indirection: When a symbol appears as the car of a list, we find the real function via the symbol.
Function Forms: Forms that call functions.
Macro Forms: Forms that call macros.
Special Forms: "Special forms" are idiosyncratic primitives, most of them extremely important.
Autoloading: Functions set up to load files containing their real definitions.

Control Structures

Nonlocal Exits

Errors

Variables

Global Variables: Variable values that exist permanently, everywhere.
Constant Variables: Certain "variables" have values that never change.
Local Variables: Variable values that exist only temporarily.
Void Variables: Symbols that lack values.
Defining Variables: A definition says a symbol is used as a variable.
Tips for Defining: Things you should think about when you define a variable.
Accessing Variables: Examining values of variables whose names are known only at run time.
Setting Variables: Storing new values in variables.
Variable Scoping: How Lisp chooses among local and global values.
Buffer-Local Variables: Variable values in effect only in one buffer.
File Local Variables: Handling local variable lists in files.
Directory Local Variables: Local variables common to all files in a directory.
Frame-Local Variables: Frame-local bindings for variables.
Variable Aliases: Variables that are aliases for other variables.
Variables with Restricted Values: Non-constant variables whose value can not be an arbitrary Lisp object.

Scoping Rules for Variable Bindings

Buffer-Local Variables

Functions

What Is a Function: Lisp functions vs. primitives; terminology.
Lambda Expressions: How functions are expressed as Lisp objects.
Function Names: A symbol can serve as the name of a function.
Defining Functions: Lisp expressions for defining functions.
Calling Functions: How to use an existing function.
Mapping Functions: Applying a function to each element of a list, etc.
Anonymous Functions: Lambda expressions are functions with no names.
Function Cells: Accessing or setting the function definition of a symbol.
Obsolete Functions: Declaring functions obsolete.
Inline Functions: Defining functions that the compiler will open code.
Declaring Functions: Telling the compiler that a function is defined.
Function Safety: Determining whether a function is safe to call.
Related Topics: Cross-references to specific Lisp primitives that have a special bearing on how functions work.

Lambda Expressions

Macros

Simple Macro: A basic example.
Expansion: How, when and why macros are expanded.
Compiling Macros: How macros are expanded by the compiler.
Defining Macros: How to write a macro definition.
Backquote: Easier construction of list structure.
Problems with Macros: Don't evaluate the macro arguments too many times. Don't hide the user's variables.
Indenting Macros: Specifying how to indent macro calls.

Common Problems Using Macros

Writing Customization Definitions

Customization Types

Loading

How Programs Do Loading: The load function and others.
Load Suffixes: Details about the suffixes that load tries.
Library Search: Finding a library to load.
Loading Non-ASCII: Non-ASCII characters in Emacs Lisp files.
Autoload: Setting up a function to autoload.
Repeated Loading: Precautions about loading a file twice.
Named Features: Loading a library if it isn't already loaded.
Where Defined: Finding which file defined a certain symbol.
Unloading: How to "unload" a library that was loaded.
Hooks for Loading: Providing code to be run when particular libraries are loaded.

Byte Compilation

Speed of Byte-Code: An example of speedup from byte compilation.
Compilation Functions: Byte compilation functions.
Docs and Compilation: Dynamic loading of documentation strings.
Dynamic Loading: Dynamic loading of individual functions.
Eval During Compile: Code to be evaluated when you compile.
Compiler Errors: Handling compiler error messages.
Byte-Code Objects: The data type used for byte-compiled functions.
Disassembly: Disassembling byte-code; how to read byte-code.

Advising Emacs Lisp Functions

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

Debugging Lisp Programs

The Lisp Debugger

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

Edebug

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

Breaks

The Outside Context

Edebug and Macros

Debugging Invalid Lisp Syntax

Reading and Printing Lisp Objects

Streams Intro: Overview of streams, reading and printing.
Input Streams: Various data types that can be used as input streams.
Input Functions: Functions to read Lisp objects from text.
Output Streams: Various data types that can be used as output streams.
Output Functions: Functions to print Lisp objects as text.
Output Variables: Variables that control what the printing functions do.

Minibuffers

Intro to Minibuffers: Basic information about minibuffers.
Text from Minibuffer: How to read a straight text string.
Object from Minibuffer: How to read a Lisp object or expression.
Minibuffer History: Recording previous minibuffer inputs so the user can reuse them.
Initial Input: Specifying initial contents for the minibuffer.
Completion: How to invoke and customize completion.
Yes-or-No Queries: Asking a question with a simple answer.
Multiple Queries: Asking a series of similar questions.
Reading a Password: Reading a password from the terminal.
Minibuffer Commands: Commands used as key bindings in minibuffers.
Minibuffer Contents: How such commands access the minibuffer text.
Minibuffer Windows: Operating on the special minibuffer windows.
Recursive Mini: Whether recursive entry to minibuffer is allowed.
Minibuffer Misc: Various customization hooks and variables.

Completion

Basic Completion: Low-level functions for completing strings.
Minibuffer Completion: Invoking the minibuffer with completion.
Completion Commands: Minibuffer commands that do completion.
High-Level Completion: Convenient special cases of completion (reading buffer name, file name, etc.).
Reading File Names: Using completion to read file names and shell commands.
Completion Styles: Specifying rules for performing completion.
Programmed Completion: Writing your own completion-function.

Command Loop

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

Defining Commands

Input Events

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

Reading Input

Keymaps

Key Sequences: Key sequences as Lisp objects.
Keymap Basics: Basic concepts of keymaps.
Format of Keymaps: What a keymap looks like as a Lisp object.
Creating Keymaps: Functions to create and copy keymaps.
Inheritance and Keymaps: How one keymap can inherit the bindings of another keymap.
Prefix Keys: Defining a key with a keymap as its definition.
Active Keymaps: How Emacs searches the active keymaps for a key binding.
Searching Keymaps: A pseudo-Lisp summary of searching active maps.
Controlling Active Maps: Each buffer has a local keymap to override the standard (global) bindings. A minor mode can also override them.
Key Lookup: Finding a key's binding in one keymap.
Functions for Key Lookup: How to request key lookup.
Changing Key Bindings: Redefining a key in a keymap.
Remapping Commands: A keymap can translate one command to another.
Translation Keymaps: Keymaps for translating sequences of events.
Key Binding Commands: Interactive interfaces for redefining keys.
Scanning Keymaps: Looking through all keymaps, for printing help.
Menu Keymaps: Defining a menu as a keymap.

Menu Keymaps

Defining Menus

Major and Minor Modes

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

Hooks

Major Modes

Major Mode Basics
Major Mode Conventions: Coding conventions for keymaps, etc.
Auto Major Mode: How Emacs chooses the major mode automatically.
Mode Help: Finding out how to use a mode.
Derived Modes: Defining a new major mode based on another major mode.
Generic Modes: Defining a simple major mode that supports comment syntax and Font Lock mode.
Mode Hooks: Hooks run at the end of major mode functions.
Example Major Modes: Text mode and Lisp modes.

Minor Modes

Mode Line Format

Mode Line Basics: Basic ideas of mode line control.
Mode Line Data: The data structure that controls the mode line.
Mode Line Top: The top level variable, mode-line-format.
Mode Line Variables: Variables used in that data structure.
%-Constructs: Putting information into a mode line.
Properties in Mode: Using text properties in the mode line.
Header Lines: Like a mode line, but at the top.
Emulating Mode Line: Formatting text as the mode line would.

Font Lock Mode

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

Multiline Font Lock Constructs

Documentation

Files

Visiting Files: Reading files into Emacs buffers for editing.
Saving Buffers: Writing changed buffers back into files.
Reading from Files: Reading files into buffers without visiting.
Writing to Files: Writing new files from parts of buffers.
File Locks: Locking and unlocking files, to prevent simultaneous editing by two people.
Information about Files: Testing existence, accessibility, size of files.
Changing Files: Renaming files, changing protection, etc.
File Names: Decomposing and expanding file names.
Contents of Directories: Getting a list of the files in a directory.
Create/Delete Dirs: Creating and Deleting Directories.
Magic File Names: Defining "magic" special handling for certain file names.
Format Conversion: Conversion to and from various file formats.

Visiting Files

Information about Files

File Names

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

File Format Conversion

Backups and Auto-Saving

Backup Files

Buffers

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

Windows

Basic Windows: Basic information on using windows.
Splitting Windows: Splitting one window into two windows.
Deleting Windows: Deleting a window gives its space to other windows.
Selecting Windows: The selected window is the one that you edit in.
Cyclic Window Ordering: Moving around the existing windows.
Buffers and Windows: Each window displays the contents of a buffer.
Displaying Buffers: Higher-level functions for displaying a buffer and choosing a window for it.
Choosing Window: How to choose a window for displaying a buffer.
Dedicated Windows: How to avoid displaying another buffer in a specific window.
Window Point: Each window has its own location of point.
Window Start and End: Buffer positions indicating which text is on-screen in a window.
Textual Scrolling: Moving text up and down through the window.
Vertical Scrolling: Moving the contents up and down on the window.
Horizontal Scrolling: Moving the contents sideways on the window.
Size of Window: Accessing the size of a window.
Resizing Windows: Changing the size of a window.
Coordinates and Windows: Converting coordinates to windows.
Window Tree: The layout and sizes of all windows in a frame.
Window Configurations: Saving and restoring the state of the screen.
Window Parameters: Associating additional information with windows.
Window Hooks: Hooks for scrolling, window size changes, redisplay going past a certain point, or window configuration changes.

Frames

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

Frame Parameters

Window Frame Parameters

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

Positions

Motion

Markers

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

Text

Near Point: Examining text in the vicinity of point.
Buffer Contents: Examining text in a general fashion.
Comparing Text: Comparing substrings of buffers.
Insertion: Adding new text to a buffer.
Commands for Insertion: User-level commands to insert text.
Deletion: Removing text from a buffer.
User-Level Deletion: User-level commands to delete text.
The Kill Ring: Where removed text sometimes is saved for later use.
Undo: Undoing changes to the text of a buffer.
Maintaining Undo: How to enable and disable undo information. How to control how much information is kept.
Filling: Functions for explicit filling.
Margins: How to specify margins for filling commands.
Adaptive Fill: Adaptive Fill mode chooses a fill prefix from context.
Auto Filling: How auto-fill mode is implemented to break lines.
Sorting: Functions for sorting parts of the buffer.
Columns: Computing horizontal positions, and using them.
Indentation: Functions to insert or adjust indentation.
Case Changes: Case conversion of parts of the buffer.
Text Properties: Assigning Lisp property lists to text characters.
Substitution: Replacing a given character wherever it appears.
Transposition: Swapping two portions of a buffer.
Registers: How registers are implemented. Accessing the text or position stored in a register.
Base 64: Conversion to or from base 64 encoding.
MD5 Checksum: Compute the MD5 "message digest"/"checksum".
Atomic Changes: Installing several buffer changes "atomically".
Change Hooks: Supplying functions to be run when text is changed.

The Kill Ring

Indentation

Text Properties

Examining Properties: Looking at the properties of one character.
Changing Properties: Setting the properties of a range of text.
Property Search: Searching for where a property changes value.
Special Properties: Particular properties with special meanings.
Format Properties: Properties for representing formatting of text.
Sticky Properties: How inserted text gets properties from neighboring text.
Lazy Properties: Computing text properties in a lazy fashion only when text is examined.
Clickable Text: Using text properties to make regions of text do something when you click on them.
Fields: The field property defines fields within the buffer.
Not Intervals: Why text properties do not use Lisp-visible text intervals.

Non-ASCII Characters

Text Representations: How Emacs represents text.
Converting Representations: Converting unibyte to multibyte and vice versa.
Selecting a Representation: Treating a byte sequence as unibyte or multi.
Character Codes: How unibyte and multibyte relate to codes of individual characters.
Character Properties: Character attributes that define their behavior and handling.
Character Sets: The space of possible character codes is divided into various character sets.
Scanning Charsets: Which character sets are used in a buffer?
Translation of Characters: Translation tables are used for conversion.
Coding Systems: Coding systems are conversions for saving files.
Input Methods: Input methods allow users to enter various non-ASCII characters without special keyboards.
Locales: Interacting with the POSIX locale.

Coding Systems

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

Searching and Matching

String Search: Search for an exact match.
Searching and Case: Case-independent or case-significant searching.
Regular Expressions: Describing classes of strings.
Regexp Search: Searching for a match for a regexp.
POSIX Regexps: Searching POSIX-style for the longest match.
Match Data: Finding out which part of the text matched, after a string or regexp search.
Search and Replace: Commands that loop, searching and replacing.
Standard Regexps: Useful regexps for finding sentences, pages,...

Regular Expressions

Syntax of Regular Expressions

The Match Data

Syntax Tables

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

Syntax Descriptors

Parsing Expressions

Abbrevs and Abbrev Expansion

Abbrev Mode: Setting up Emacs for abbreviation.
Abbrev Tables: Creating and working with abbrev tables.
Defining Abbrevs: Specifying abbreviations and their expansions.
Abbrev Files: Saving abbrevs in files.
Abbrev Expansion: Controlling expansion; expansion subroutines.
Standard Abbrev Tables: Abbrev tables used by various major modes.
Abbrev Properties: How to read and set abbrev properties. Which properties have which effect.
Abbrev Table Properties: How to read and set abbrev table properties. Which properties have which effect.

Processes

Subprocess Creation: Functions that start subprocesses.
Shell Arguments: Quoting an argument to pass it to a shell.
Synchronous Processes: Details of using synchronous subprocesses.
Asynchronous Processes: Starting up an asynchronous subprocess.
Deleting Processes: Eliminating an asynchronous subprocess.
Process Information: Accessing run-status and other attributes.
Input to Processes: Sending input to an asynchronous subprocess.
Signals to Processes: Stopping, continuing or interrupting an asynchronous subprocess.
Output from Processes: Collecting output from an asynchronous subprocess.
Sentinels: Sentinels run when process run-status changes.
Query Before Exit: Whether to query if exiting will kill a process.
System Processes: Accessing other processes running on your system.
Transaction Queues: Transaction-based communication with subprocesses.
Network: Opening network connections.
Network Servers: Network servers let Emacs accept net connections.
Datagrams: UDP network connections.
Low-Level Network: Lower-level but more general function to create connections and servers.
Misc Network: Additional relevant functions for network connections.
Serial Ports: Communicating with serial ports.
Byte Packing: Using bindat to pack and unpack binary data.

Receiving Output from Processes

Low-Level Network Access

Packing and Unpacking Byte Arrays

Emacs Display

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

The Echo Area

Reporting Warnings

Overlays

Faces

Defining Faces: How to define a face with defface.
Face Attributes: What is in a face?
Attribute Functions: Functions to examine and set face attributes.
Displaying Faces: How Emacs combines the faces specified for a character.
Face Remapping: Remapping faces to alternative definitions.
Face Functions: How to define and examine faces.
Auto Faces: Hook for automatic face assignment.
Font Selection: Finding the best available font for a face.
Font Lookup: Looking up the names of available fonts and information about them.
Fontsets: A fontset is a collection of fonts that handle a range of character sets.
Low-Level Font: Lisp representation for character display fonts.

Fringes

The display Property

Images

Image Formats: Supported image formats.
Image Descriptors: How to specify an image for use in :display.
XBM Images: Special features for XBM format.
XPM Images: Special features for XPM format.
GIF Images: Special features for GIF format.
TIFF Images: Special features for TIFF format.
PostScript Images: Special features for PostScript format.
Other Image Types: Various other formats are supported.
Defining Images: Convenient ways to define an image for later use.
Showing Images: Convenient ways to display an image once it is defined.
Image Cache: Internal mechanisms of image display.

Buttons

Abstract Display

Display Tables

Operating System Interface

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

Starting Up Emacs

Getting Out of Emacs

Terminal Input

Tips and Conventions

Coding Conventions: Conventions for clean and robust programs.
Key Binding Conventions: Which keys should be bound by which programs.
Programming Tips: Making Emacs code fit smoothly in Emacs.
Compilation Tips: Making compiled code run fast.
Warning Tips: Turning off compiler warnings.
Documentation Tips: Writing readable documentation strings.
Comment Tips: Conventions for writing comments.
Library Headers: Standard headers for library packages.

GNU Emacs Internals

Object Internals