@c This file is used for printing the GNU Emacs Lisp Reference Manual
@c in two volumes. It is a modified version of elisp.texi.
@c Copyright (C) 1990, 1991, 1992, 1993, 1994, 1995, 1998, 1999, 2001,
-@c 2002, 2003, 2004, 2005, 2006, 2007 Free Software Foundation, Inc.
+@c 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011
+@c Free Software Foundation, Inc.
@c %**start of header
@setfilename elisp
@settitle GNU Emacs Lisp Reference Manual: Volume 2
@c Version of the manual and of Emacs.
@c Please remember to update the edition number in README as well.
-@set VERSION 2.9
-@set EMACSVER 22
+@set VERSION 3.0
+@set EMACSVER 23.2.91
+@set DATE July 2009
@dircategory Emacs
@direntry
corresponding to Emacs version @value{EMACSVER}.
Copyright @copyright{} 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1998,
-1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007 Free Software
+1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011 Free Software
Foundation, Inc.
@quotation
Permission is granted to copy, distribute and/or modify this document
-under the terms of the GNU Free Documentation License, Version 1.2 or
+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 are free to copy and modify
-this GNU Manual. Buying copies from GNU Press supports the FSF in
+(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.''
@end quotation
@end copying
@title GNU Emacs Lisp Reference Manual
@subtitle Volume 2
@subtitle For Emacs Version @value{EMACSVER}
-@subtitle Revision @value{VERSION}, June 2007
+@subtitle Revision @value{VERSION}, @value{DATE}
@author by Bil Lewis, Dan LaLiberte, Richard Stallman
@author and the GNU Manual Group
files are made.
* Buffers:: Creating and using buffer objects.
* Windows:: Manipulating windows and displaying buffers.
-* Frames:: Making multiple system-level windows.
+* Frames:: Making multiple system-level windows.
* Positions:: Buffer positions and motion functions.
* Markers:: Markers represent positions and update
automatically when the text is changed.
* Abbrevs:: How Abbrev mode works, and its data structures.
* Processes:: Running and communicating with subprocesses.
-* Display:: Features for controlling the screen display.
+* 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 21.
-* GNU Free Documentation License:: The license for this documentation
+* 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;
* Some Terms:: Explanation of terms we use in this manual.
* nil and t:: How the symbols @code{nil} and @code{t} are used.
* Evaluation Notation:: The format we use for examples of evaluation.
-* Printing Notation:: The format we use for examples that print output.
+* Printing Notation:: The format we use when examples print text.
* Error Messages:: The format we use for examples of errors.
* Buffer Text Notation:: The format we use for buffer contents in examples.
* Format of Descriptions:: Notation for describing functions, variables, etc.
* Character Type:: The representation of letters, numbers and
control characters.
* Symbol Type:: A multi-use object that refers to a function,
- variable, property list, or itself.
+ variable, or property list, and has a unique identity.
* Sequence Type:: Both lists and arrays are classified as sequences.
* Cons Cell Type:: Cons cells, and lists (which are made from cons cells).
* Array Type:: Arrays include strings and vectors.
Cons Cell and List Types
* Box Diagrams:: Drawing pictures of lists.
-* Dotted Pair Notation:: An alternative syntax for lists.
+* Dotted Pair Notation:: A general syntax for cons cells.
* Association List Type:: A specially constructed list.
String Type
* Buffer Type:: The basic object of editing.
* Marker Type:: A position in a buffer.
-* Window Type:: What makes buffers visible.
-* Frame Type:: Windows subdivide frames.
+* Window Type:: Buffers are displayed in windows.
+* Frame Type:: Windows subdivide frames.
+* Terminal Type:: A terminal device displays frames.
* Window Configuration Type:: Recording the way a frame is subdivided.
* Frame Configuration Type:: Recording the status of all frames.
-* Process Type:: A process running on the underlying OS.
+* Process Type:: A subprocess of Emacs running on the underlying OS.
* Stream Type:: Receive or send characters.
* Keymap Type:: What function a keystroke invokes.
* Overlay Type:: How an overlay is represented.
+* Font Type:: Fonts for displaying text.
Numbers
* Integer Basics:: Representation and range of integers.
-* Float Basics:: Representation and range of floating point.
+* Float Basics:: Representation and range of floating point.
* Predicates on Numbers:: Testing for numbers.
* Comparison of Numbers:: Equality and inequality predicates.
-* Numeric Conversions:: Converting float to integer and vice versa.
+* Numeric Conversions:: Converting float to integer and vice versa.
* Arithmetic Operations:: How to add, subtract, multiply and divide.
* Rounding Operations:: Explicitly rounding floating point numbers.
* Bitwise Operations:: Logical and, or, not, shifting.
* Creating Strings:: Functions to allocate new strings.
* Modifying Strings:: Altering the contents of an existing string.
* Text Comparison:: Comparing characters or strings.
-* String Conversion:: Converting characters to strings and vice versa.
+* String Conversion:: Converting to and from characters and strings.
* Formatting Strings:: @code{format}: Emacs's analogue of @code{printf}.
* Case Conversion:: Case conversion functions.
-* Case Tables:: Customizing case conversion.
+* Case Tables:: Customizing case conversion.
Lists
* Creating Hash:: Functions to create hash tables.
* Hash Access:: Reading and writing the hash table contents.
-* Defining Hash:: Defining new comparison methods
+* Defining Hash:: Defining new comparison methods.
* Other Hash:: Miscellaneous.
Symbols
* 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.
+ 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,
* Processing of Errors:: What Emacs does when you report an error.
* Handling Errors:: How you can trap errors and continue execution.
* Error Symbols:: How errors are classified for trapping them.
-* Standard Errors:: List of all error symbols.
Variables
* 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.
-* Frame-Local Variables:: Variable values in effect only in one frame.
-* Future Local Variables:: New kinds of local values we might add some day.
* File Local Variables:: Handling local variable lists in files.
+* 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
@emph{not} be an arbitrary Lisp object.
-* Standard Buffer-Local Variables::
- List of variables buffer-local in all buffers.
Scoping Rules for Variable Bindings
Functions
-* What Is a Function:: Lisp functions vs primitives; terminology.
+* 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.
+* 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.
+* 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
* 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.
+* Unloading:: How to "unload" a library that was loaded.
+* Hooks for Loading:: Providing code to be run when
+ particular libraries are loaded.
Byte Compilation
* 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.
+* Byte-Code Objects:: The data type used for byte-compiled functions.
* Disassembly:: Disassembling byte-code; how to read byte-code.
Advising Emacs Lisp Functions
The Lisp Debugger
* Error Debugging:: Entering the debugger when an error happens.
-* Infinite Loops:: Stopping and debugging a program that doesn't exit.
+* 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.
Edebug
-* Using Edebug:: Introduction to use of Edebug.
-* Instrumenting:: You must instrument your code
- in order to debug it with 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.
+* 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.
+* Edebug Options:: Option variables for customizing Edebug.
+
+Breaks
+
+* Breakpoints:: Breakpoints at stop points.
+* Global Break Condition:: Breaking on an event.
+* Source Breakpoints:: Embedding breakpoints in source code.
+
+The Outside Context
+
+* Checking Whether to Stop::When Edebug decides what to do.
+* Edebug Display Update:: When Edebug updates the display.
+* Edebug Recursive Edit:: When Edebug stops execution.
+
+Edebug and Macros
+
+* Instrumenting Macro Calls::The basic problem.
+* Specification List:: How to specify complex patterns of evaluation.
+* Backtracking:: What Edebug does when matching fails.
+* Specification Examples:: To help understand specifications.
Debugging Invalid Lisp Syntax
* 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.
+* 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.
+* 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.
* Minibuffer Completion:: Invoking the minibuffer with completion.
* Completion Commands:: Minibuffer commands that do completion.
* High-Level Completion:: Convenient special cases of completion
- (reading buffer name, file name, etc.)
-* Reading File Names:: Using completion to read file names.
-* Programmed Completion:: Finding the completions for a given file name.
+ (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.
+* 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.
* Misc Events:: Other events the system can generate.
* Event Examples:: Examples of the lists for mouse events.
* Classifying Events:: Finding the modifier keys in an event symbol.
-* Accessing Events:: Functions to extract info from events.
+ 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.
* Controlling Active Maps:: Each buffer has a local keymap
to override the standard (global) bindings.
A minor mode can also override them.
-* Key Lookup:: How extracting elements from keymaps works.
+* 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:: A keymap can define a menu for X
- or for use from the terminal.
-* Standard Keymaps:: List of standard keymaps.
-
-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.
+* Menu Keymaps:: Defining a menu as a keymap.
Menu Keymaps
* Desktop Save Mode:: How modes can have buffer state saved between
Emacs sessions.
+Hooks
+
+* Running Hooks:: How to run a hook.
+* Setting Hooks:: How to put functions on a hook, or remove them.
+
Major Modes
* Major Mode Basics::
* Major Mode Conventions:: Coding conventions for keymaps, etc.
-* Example Major Modes:: Text mode and Lisp modes.
* Auto Major Mode:: How Emacs chooses the major mode automatically.
* Mode Help:: Finding out how to use a mode.
* Derived Modes:: Defining a new major mode based on another major
* 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::
+* 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.
Multiline Font Lock Constructs
-* Font Lock Multiline:: Marking multiline chunks with a text property
+* Font Lock Multiline:: Marking multiline chunks with a text property.
* Region to Fontify:: Controlling which region gets refontified
after a buffer change.
* Visiting Files:: Reading files into Emacs buffers for editing.
* Saving Buffers:: Writing changed buffers back into files.
-* Reading from Files:: Reading files into other buffers.
+* 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.
* 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.
+* 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
* Testing Accessibility:: Is a given file readable? Writable?
* Kinds of Files:: Is it a directory? A symbolic link?
-* Truenames:: Eliminating symbolic links from a file name.
+* Truenames:: Eliminating symbolic links from a file name.
* File Attributes:: How large is it? Any other names? Etc.
* Locating Files:: How to find a file in standard places.
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.
+* 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.
* Standard File Names:: If your package uses a fixed file name,
how to handle various operating systems simply.
+File Format Conversion
+
+* Format Conversion Overview:: @code{insert-file-contents} and @code{write-region}.
+* Format Conversion Round-Trip:: Using @code{format-alist}.
+* Format Conversion Piecemeal:: Specifying non-paired conversion.
+
Backups and Auto-Saving
* Backup Files:: How backup files are made; how their names
* Buffer Basics:: What is a buffer?
* Current Buffer:: Designating a buffer as current
- so primitives will access its contents.
+ 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.
* 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
* 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.
+* 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:: The display-start position controls which text
- is on-screen in the window.
+* 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.
* 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 Displays:: Creating frames on other displays.
-* Frame Parameters:: Controlling frame size, position, font, etc.
+* 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.
+* 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.
+* 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 puts it underneath the others.
+ 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.
+* 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 windows.
+* 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.
+* Color Names:: Getting the definitions of color names.
* Text Terminal Colors:: Defining colors for text-only terminals.
-* Resources:: Getting resource values from the server.
+* Resources:: Getting resource values from the server.
* Display Feature Testing:: Determining the features of a terminal.
Frame Parameters
* Parameter Access:: How to change a frame's parameters.
-* Initial Parameters:: Specifying frame parameters when you make a frame.
+* Initial Parameters:: Specifying frame parameters when you make a frame.
* Window Frame Parameters:: List of frame parameters for window systems.
* Size and Position:: Changing the size and position of a frame.
* Geometry:: Parsing geometry specifications.
* Buffer Parameters:: Which buffers have been or should be shown.
* Management Parameters:: Communicating with the window manager.
* Cursor Parameters:: Controlling the cursor appearance.
-* Color Parameters:: Colors of various parts of the frame.
+* Font and Color Parameters:: Fonts and colors for the frame text.
Positions
* 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.
+* 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.
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.
+ 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
* Kill Functions:: Functions that kill text.
* Yanking:: How yanking is done.
* Yank Commands:: Commands that access the kill ring.
-* Low-Level Kill Ring:: Functions and variables for kill ring access.
-* Internals of Kill Ring:: Variables that hold kill-ring data.
+* Low-Level Kill Ring:: Functions and variables for kill ring access.
+* Internals of Kill Ring:: Variables that hold kill ring data.
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.
+* Changing Properties:: Setting the properties of a range of text.
+* Property Search:: Searching for where a property changes value.
+* Special Properties:: Particular properties with special meanings.
* Format Properties:: Properties for representing formatting of text.
* Sticky Properties:: How inserted text gets properties from
neighboring text.
-* Saving Properties:: Saving text properties in files, and reading
- them back.
* Lazy Properties:: Computing text properties in a lazy fashion
only when text is examined.
* Clickable Text:: Using text properties to make regions of text
do something when you click on them.
-* Links and Mouse-1:: How to make @key{Mouse-1} follow a link.
* Fields:: The @code{field} property defines
fields within the buffer.
-* Not Intervals:: Why text properties do not use
- Lisp-visible text intervals.
+* Not Intervals:: Why text properties do not use
+ Lisp-visible text intervals.
-Non-ASCII Characters
+Non-@acronym{ASCII} Characters
-* Text Representations:: Unibyte and multibyte representations
+* 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.
-* Chars and Bytes:: More information about multibyte encodings.
-* Splitting Characters:: Converting a character to its byte sequence.
* Scanning Charsets:: Which character sets are used in a buffer?
* Translation of Characters:: Translation tables are used for conversion.
* Coding Systems:: Coding systems are conversions for saving files.
* 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.
+* Search and Replace:: Commands that loop, searching and replacing.
* Standard Regexps:: Useful regexps for finding sentences, pages,...
Regular Expressions
The Match Data
-* Replacing Match:: Replacing a substring that was matched.
+* Replacing Match:: Replacing a substring that was matched.
* Simple Match Data:: Accessing single items of match data,
- such as where a particular subexpression started.
+ such as where a particular subexpression started.
* Entire Match Data:: Accessing the entire match data at once, as a list.
* Saving Match Data:: Saving and restoring the match data.
* 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.
+* 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.
* Low-Level Parsing:: Parsing across a specified region.
* Control Parsing:: Parameters that affect parsing.
-Abbrevs And Abbrev Expansion
+Abbrevs and Abbrev Expansion
* Abbrev Mode:: Setting up Emacs for abbreviation.
* Abbrev Tables:: Creating and working with abbrev tables.
* 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
* 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.
+* 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
-* Proc: Network Processes. Using @code{make-network-process}.
-* Options: Network Options. Further control over network connections.
-* Features: Network Feature Testing.
- Determining which network features work on
+* Network Processes:: Using @code{make-network-process}.
+* Network Options:: Further control over network connections.
+* Network Feature Testing:: Determining which network features work on
the machine you are using.
Packing and Unpacking Byte Arrays
* 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.
+* 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
+* Faces:: A face defines a graphics style
for text characters: font, colors, etc.
* Fringes:: Controlling window fringes.
* Scroll Bars:: Controlling vertical scroll bars.
* 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.
+* 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.
Reporting Warnings
* Warning Basics:: Warnings concepts and functions to report them.
-* Warning Variables:: Variables programs bind to customize their warnings.
+* Warning Variables:: Variables programs bind to customize
+ their warnings.
* Warning Options:: Variables users set to control display of warnings.
Overlays
* Managing Overlays:: Creating and moving overlays.
* Overlay Properties:: How to read and set properties.
- What properties do to the screen display.
+ What properties do to the screen display.
* Finding Overlays:: Searching for overlays.
Faces
* Attribute Functions:: Functions to examine and set face attributes.
* Displaying Faces:: How Emacs combines the faces specified for
a character.
-* Font Selection:: Finding the best available font for a face.
+* 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 @code{display} Property
+* Replacing Specs:: Display specs that replace the text.
* Specified Space:: Displaying one space with a specified width.
* Pixel Specification:: Specifying space width or height in pixels.
* Other Display Specs:: Displaying an image; magnifying text; moving it
Images
+* Image Formats:: Supported image formats.
* Image Descriptors:: How to specify an image for use in @code{: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.
Operating System Interface
-* Starting Up:: Customizing Emacs start-up processing.
+* 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 a string, or
- to calendrical data (or vice versa).
+* 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.
+* 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
+* 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.
+* Session Management:: Saving and restoring state with
+ X Session Management.
Starting Up Emacs
-* Startup Summary:: Sequence of actions Emacs performs at start-up.
-* Init File:: Details on reading the init file (@file{.emacs}).
+* Startup Summary:: Sequence of actions Emacs performs at startup.
+* Init File:: Details on reading the init file.
* Terminal-Specific:: How the terminal-specific Lisp file is read.
* Command-Line Arguments:: How command-line arguments are processed,
and how you can customize them.
Terminal Input
-* Input Modes:: Options for how input is processed.
-* Recording Input:: Saving histories of recent or all input events.
+* Input Modes:: Options for how input is processed.
+* Recording Input:: Saving histories of recent or all input events.
Tips and Conventions
* 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.
+* Comment Tips:: Conventions for writing comments.
* Library Headers:: Standard headers for library packages.
GNU Emacs Internals
@c include compile.texi
@c include advice.texi
+@c This includes edebug.texi.
@c include debugging.texi
@c include streams.texi
@c include minibuf.texi
HCoop / bpt / emacs.git / blobdiff