\input texinfo @c -*-texinfo-*-@c %**start of header@setfilename elisp@settitle GNU Emacs Lisp Reference Manual@c %**end of header@c Versino of the manual.@set VERSION 2.9@dircategory Emacs@direntry* Elisp: (elisp). The Emacs Lisp Reference Manual.@end direntry@smallbook@setchapternewpage odd@finalout@c Combine indices.@synindex cp fn@syncodeindex vr fn@syncodeindex ky fn@syncodeindex pg fn@c We use the "type index" to index new functions and variables.@c @syncodeindex tp fn@ifnottexThis Info file contains edition @value{VERSION} of the GNU Emacs LispReference Manual, corresponding to Emacs version 21.3.@c Please REMEMBER to update edition number in *four* places in this file@c and also in *one* place in intro.texi and *one* in README.Published by the Free Software Foundation59 Temple Place, Suite 330Boston, MA 02111-1307 USACopyright (C) 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1998, 1999,@* 2000, 2002 Free Software Foundation, Inc.Permission is granted to copy, distribute and/or modify this documentunder the terms of the GNU Free Documentation License, Version 1.1 orany later version published by the Free Software Foundation; with theInvariant 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 copyof the license is included in the section entitled ``GNU FreeDocumentation License''.(a) The FSF's Back-Cover Text is: ``You have freedom to copy and modifythis GNU Manual, like GNU software. Copies published by the FreeSoftware Foundation raise funds for GNU development.''@end ifnottex@titlepage@title GNU Emacs Lisp Reference Manual@subtitle For Emacs Version 21@c The edition number appears in several places in this file@c and also in the file intro.texi.@subtitle Revision @value{VERSION}, January 2002@author by Bil Lewis, Dan LaLiberte, Richard Stallman@author and the GNU Manual Group@page@vskip 0pt plus 1filllCopyright @copyright{} 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1998,@*1999, 2000, 2002 Free Software Foundation, Inc.@sp 2Edition @value{VERSION} @*Revised for Emacs Version 21.3,@*January 2002.@*@sp 2ISBN 1-882114-73-6@sp 2Published by the Free Software Foundation @*59 Temple Place, Suite 330@*Boston, MA 02111-1307 USAPermission is granted to copy, distribute and/or modify this documentunder the terms of the GNU Free Documentation License, Version 1.1 orany later version published by the Free Software Foundation; with theInvariant Sections being ``Copying'', with the Front-Cover texts being``A GNU Manual'', and with the Back-Cover Texts as in (a) below. A copyof the license is included in the section entitled ``GNU FreeDocumentation License''.(a) The FSF's Back-Cover Text is: ``You have freedom to copy and modifythis GNU Manual, like GNU software. Copies published by the FreeSoftware Foundation raise funds for GNU development.''Cover art by Etienne Suvasa.@end titlepage@page@node Top, Introduction, (dir), (dir)@ifnottexThis Info file contains edition @value{VERSION} of the GNU Emacs LispReference Manual, corresponding to GNU Emacs version 21.3.@end ifnottex@menu* Introduction:: Introduction and conventions used.* Standards: Coding Conventions. Coding conventions for Emacs Lisp.* Lisp Data Types:: Data types of objects in Emacs Lisp.* Numbers:: Numbers and arithmetic functions.* Strings and Characters:: Strings, and functions that work on them.* Lists:: Lists, cons cells, and related functions.* Sequences Arrays Vectors:: Lists, strings and vectors are called sequences. Certain functions act on any kind of sequence. The description of vectors is here as well.* 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 X 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.* Calendar:: Customizing the calendar and diary.* System Interface:: Getting the user id, system type, environment variables, and other such things.Appendices* Antinews:: Info for users downgrading to Emacs 20.* 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.* New Symbols:: New functions and variables in Emacs 21. --- 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* Caveats:: Flaws and a request for help.* Lisp History:: Emacs Lisp is descended from Maclisp.* Conventions:: How the manual is formatted.* Acknowledgements:: The authors, editors, and sponsors of this manual.Conventions* Some Terms:: Explanation of terms we use in this manual.* nil and t:: How the symbols @code{nil} and @code{t} are used.* Evaluation Notation:: The format we use for examples of evaluation.* Printing Notation:: The format we use for examples that print output.* Error Messages:: The format we use for examples of errors.* Buffer Text Notation:: The format we use for buffer contents in examples.* Format of Descriptions:: Notation for describing functions, variables, etc.Tips and Conventions* Coding Conventions:: Conventions for clean and robust programs.* Compilation Tips:: Making compiled code run fast.* Documentation Tips:: Writing readable documentation strings.* Comment Tips:: Conventions for writing comments.* Library Headers:: Standard headers for library packages.Format of Descriptions* A Sample Function Description::* A Sample Variable Description::Lisp Data Types* Printed Representation:: How Lisp objects are represented as text.* Comments:: Comments and their formatting conventions.* Programming Types:: Types found in all Lisp systems.* Editing Types:: Types specific to Emacs.* Type Predicates:: Tests related to types.* Equality Predicates:: Tests of equality between any two objects.Programming Types* Integer Type:: Numbers without fractional parts.* Floating Point Type:: Numbers with fractional parts and with a large range.* Character Type:: The representation of letters, numbers and control characters.* 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.* String Type:: An (efficient) array of characters.* Vector Type:: One-dimensional arrays.* Symbol Type:: A multi-use object that refers to a function, variable, property list, or itself.* Function Type:: A piece of executable code you can call from elsewhere.* Macro Type:: A method of expanding an expression into another expression, more fundamental but less pretty.* Primitive Function Type:: A function written in C, callable from Lisp.* Byte-Code Type:: A function written in Lisp, then compiled.* Autoload Type:: A type used for automatically loading seldom-used functions.List Type* Dotted Pair Notation:: An alternative syntax for lists.* Association List Type:: A specially constructed list.Editing Types* Buffer Type:: The basic object of editing.* Window Type:: What makes buffers visible.* Window Configuration Type::Save what the screen looks like.* Marker Type:: A position in a buffer.* Process Type:: A process 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.Numbers* Integer Basics:: Representation and range of integers.* Float Basics:: Representation and range of floating point.* Predicates on Numbers:: Testing for numbers.* Comparison of Numbers:: Equality and inequality predicates.* Arithmetic Operations:: How to add, subtract, multiply and divide.* Bitwise Operations:: Logical and, or, not, shifting.* Numeric Conversions:: Converting float to integer and vice versa.* Math Functions:: Trig, exponential and logarithmic functions.* Random Numbers:: Obtaining random integers, predictable or not.Strings and Characters* String Basics:: Basic properties of strings and characters.* Predicates for Strings:: Testing whether an object is a string or char.* Creating Strings:: Functions to allocate new strings.* Text Comparison:: Comparing characters or strings.* String Conversion:: Converting characters or strings and vice versa.* Formatting Strings:: @code{format}: Emacs's analogue of @code{printf}.* Case Conversion:: Case conversion functions.Lists* Cons Cells:: How lists are made out of cons cells.* Lists as Boxes:: Graphical notation to explain lists.* List-related Predicates:: Is this object a list? Comparing two lists.* List Elements:: Extracting the pieces of a list.* Building Lists:: Creating list structure.* Modifying Lists:: Storing new pieces into an existing list.* Sets And Lists:: A list can represent a finite mathematical set.* Association Lists:: A list can represent a finite relation or mapping.Modifying Existing List Structure* Setcar:: Replacing an element in a list.* Setcdr:: Replacing part of the list backbone. This can be used to remove or add elements.* Rearrangement:: Reordering the elements in a list; combining lists.Sequences, Arrays, and Vectors* Sequence Functions:: Functions that accept any kind of sequence.* Arrays:: Characteristics of arrays in Emacs Lisp.* Array Functions:: Functions specifically for arrays.* Vectors:: Functions specifically for vectors.Symbols* Symbol Components:: Symbols have names, values, function definitions and property lists.* Definitions:: A definition says how a symbol will be used.* Creating Symbols:: How symbols are kept unique.* Property Lists:: Each symbol has a property list for recording miscellaneous information.Evaluation* Intro Eval:: Evaluation in the scheme of things.* Eval:: How to invoke the Lisp interpreter explicitly.* Forms:: How various sorts of objects are evaluated.* Quoting:: Avoiding evaluation (to put constants in the program).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 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* Sequencing:: Evaluation in textual order.* Conditionals:: @code{if}, @code{cond}.* Combining Conditions:: @code{and}, @code{or}, @code{not}.* Iteration:: @code{while} loops.* Nonlocal Exits:: Jumping out of a sequence.Nonlocal Exits* Catch and Throw:: Nonlocal exits for the program's own purposes.* Examples of Catch:: Showing how such nonlocal exits can be written.* Errors:: How errors are signaled and handled.* Cleanups:: Arranging to run a cleanup form if an error happens.Errors* Signaling Errors:: How to report an error.* Processing of Errors:: What Emacs does when you report an error.* Handling Errors:: How you can trap errors and continue execution.* Error Symbols:: How errors are classified for trapping them.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.* 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.Scoping Rules for Variable Bindings* Scope:: Scope means where in the program a value is visible. Comparison with other languages.* Extent:: Extent means how long in time a value exists.* Impl of Scope:: Two ways to implement dynamic scoping.* Using Scoping:: How to use dynamic scoping carefully and avoid problems.Buffer-Local Variables* Intro to Buffer-Local:: Introduction and concepts.* Creating Buffer-Local:: Creating and destroying buffer-local bindings.* Default Value:: The default value is seen in buffers that don't have their own buffer-local values.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.* Related Topics:: Cross-references to specific Lisp primitives that have a special bearing on how functions work.Lambda Expressions* Lambda Components:: The parts of a lambda expression.* Simple Lambda:: A simple example.* Argument List:: Details and special features of argument lists.* Function Documentation:: How to put documentation in a function.Macros* Simple Macro:: A basic example.* Expansion:: How, when and why macros are expanded.* Compiling Macros:: How macros are expanded by the compiler.* Defining Macros:: How to write a macro definition.* Backquote:: Easier construction of list structure.* Problems with Macros:: Don't evaluate the macro arguments too many times. Don't hide the user's variables.* Indenting Macros:: Specifying how to indent macro calls.Loading* How Programs Do Loading:: The @code{load} function and others.* Autoload:: Setting up a function to autoload.* Named Features:: Loading a library if it isn't already loaded.* Repeated Loading:: Precautions about loading a file twice.Byte Compilation* Compilation Functions:: Byte compilation functions.* Disassembly:: Disassembling byte-code; how to read byte-code.Advising Functions* Simple Advice:: A simple example to explain the basics of advice.* Defining Advice:: Detailed description of @code{defadvice}.* Computed Advice:: ...is to @code{defadvice} as @code{fset} is to @code{defun}.* Activation of Advice:: Advice doesn't do anything until you activate it.* Enabling Advice:: You can enable or disable each piece of advice.* Preactivation:: Preactivation is a way of speeding up the loading of compiled advice.* 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* Debugger:: How the Emacs Lisp debugger is implemented.* Syntax Errors:: How to find syntax errors.* Compilation Errors:: How to find errors that show up in byte compilation.* Edebug:: A source-level Emacs Lisp debugger.The Lisp Debugger* Error Debugging:: Entering the debugger when an error happens.* Function Debugging:: Entering it when a certain function is called.* Explicit Debug:: Entering it at a certain point in the program.* Using Debugger:: What the debugger does; what you see while in it.* Debugger Commands:: Commands used while in the debugger.* Invoking the Debugger:: How to call the function @code{debug}.* Internals of Debugger:: Subroutines of the debugger, and global variables.Debugging Invalid Lisp Syntax* Excess Open:: How to find a spurious open paren or missing close.* Excess Close:: How to find a spurious close paren or missing open.Reading and Printing Lisp Objects* Streams Intro:: Overview of streams, reading and printing.* 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.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.* Completion:: How to invoke and customize completion.* Yes-or-No Queries:: Asking a question with a simple answer.* Minibuffer Misc:: Various customization hooks and variables.Completion* Basic Completion:: Low-level functions for completing strings. (These are too low level to use the minibuffer.)* Minibuffer Completion:: Invoking the minibuffer with completion.* Completion Commands:: Minibuffer commands that do completion.* High-Level Completion:: Convenient special cases of completion (reading buffer name, file name, etc.)* Reading File Names:: Using completion to read file names.* Programmed Completion:: Finding the completions for a given file name.Command Loop* Command Overview:: How the command loop reads commands.* Defining Commands:: Specifying how a function should read arguments.* Interactive Call:: Calling a command, so that it will read arguments.* Command Loop Info:: Variables set by the command loop for you to examine.* Input Events:: What input looks like when you read it.* Reading Input:: How to read input events from the keyboard or mouse.* Waiting:: Waiting for user input or elapsed time.* Quitting:: How @kbd{C-g} works. How to catch or defer quitting.* Prefix Command Arguments:: How the commands to set prefix args work.* Recursive Editing:: Entering a recursive edit, and why you usually shouldn't.* Disabling Commands:: How the command loop handles disabled commands.* Command History:: How the command history is set up, and how accessed.* Keyboard Macros:: How keyboard macros are implemented.Defining Commands* Using Interactive:: General rules for @code{interactive}.* Interactive Codes:: The standard letter-codes for reading arguments in various ways.* Interactive Examples:: Examples of how to read interactive arguments.Keymaps* Keymap Terminology:: Definitions of terms pertaining to 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.* Menu Keymaps:: A keymap can define a menu for X or for use from the terminal.* Active Keymaps:: Each buffer has a local keymap to override the standard (global) bindings. Each minor mode can also override them.* Key Lookup:: How extracting elements from keymaps works.* Functions for Key Lookup:: How to request key lookup.* Changing Key Bindings:: Redefining a key in a keymap.* Remapping Commands:: Bindings that translate one command to another.* Key Binding Commands:: Interactive interfaces for redefining keys.* Scanning Keymaps:: Looking through all keymaps, for printing help.Major and Minor Modes* Major Modes:: Defining major modes.* Minor Modes:: Defining minor modes.* Mode Line Format:: Customizing the text that appears in the mode line.* Hooks:: How to use hooks; how to write code that provides hooks.Major Modes* 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.Minor Modes* Minor Mode Conventions:: Tips for writing a minor mode.* Keymaps and Minor Modes:: How a minor mode can have its own keymap.Mode Line Format* Mode Line Data:: The data structure that controls the mode line.* Mode Line Variables:: Variables used in that data structure.* %-Constructs:: Putting information into a mode line.Documentation* Documentation Basics:: Good style for doc strings. Where to put them. How Emacs stores them.* Accessing Documentation:: How Lisp programs can access doc strings.* Keys in Documentation:: Substituting current key bindings.* Describing Characters:: Making printable descriptions of non-printing characters and key sequences.* Help Functions:: Subroutines used by Emacs help facilities.Files* Visiting Files:: Reading files into Emacs buffers for editing.* Saving Buffers:: Writing changed buffers back into files.* Reading from Files:: Reading files into other buffers.* Writing to Files:: Writing new files from parts of buffers.* File Locks:: Locking and unlocking files, to prevent simultaneous editing by two people.* Information about Files:: Testing existence, accessibility, size of files.* Contents of Directories:: Getting a list of the files in a directory.* Changing Files:: Renaming files, changing protection, etc.* File Names:: Decomposing and expanding file names.Visiting Files* Visiting Functions:: The usual interface functions for visiting.* Subroutines of Visiting:: Lower-level subroutines that they use.Information about Files* Testing Accessibility:: Is a given file readable? Writable?* Kinds of Files:: Is it a directory? A link?* File Attributes:: How large is it? Any other names? Etc.File Names* File Name Components:: The directory part of a file name, and the rest.* Directory Names:: A directory's name as a directory is different from its name as a file.* Relative File Names:: Some file names are relative to a current directory.* 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.Backups and Auto-Saving* Backup Files:: How backup files are made; how their names are chosen.* Auto-Saving:: How auto-save files are made; how their names are chosen.* Reverting:: @code{revert-buffer}, and how to customize what it does.Backup Files* Making Backups:: How Emacs makes backup files, and when.* Rename or Copy:: Two alternatives: renaming the old file or copying it.* Numbered Backups:: Keeping multiple backups for each source file.* Backup Names:: How backup file names are computed; customization.Buffers* Buffer Basics:: What is a buffer?* Buffer Names:: Accessing and changing buffer names.* Buffer File Name:: The buffer file name indicates which file is visited.* Buffer Modification:: A buffer is @dfn{modified} if it needs to be saved.* Modification Time:: Determining whether the visited file was changed ``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.* Current Buffer:: Designating a buffer as current so primitives will access its contents.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-lever functions for displaying a buffer and choosing a window for it.* 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.* Vertical Scrolling:: Moving text up and down in the window.* Horizontal Scrolling:: Moving text sideways on the window.* Size of Window:: Accessing the size of a window.* Resizing Windows:: Changing the size of a window.* Window Configurations:: Saving and restoring the state of the screen.Frames* Creating Frames:: Creating additional frames.* Multiple Displays:: Creating frames on other X displays.* Frame Parameters:: Controlling frame size, position, font, etc.* Frame Titles:: Automatic updating of frame titles.* Deleting Frames:: Frames last until explicitly deleted.* Finding All Frames:: How to examine all existing frames.* Frames and Windows:: A frame contains windows; display of text always works through windows.* Minibuffers and Frames:: How a frame finds the minibuffer to use.* Input Focus:: Specifying the selected frame.* Visibility of Frames:: Frames may be visible or invisible, or icons.* Raising and Lowering:: Raising a frame makes it hide other X windows; lowering it puts it underneath the others.* 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 Shapes:: Specifying the shape of the mouse pointer.* Window System Selections::Transferring text to and from other windows.* Color Names:: Getting the definitions of color names.* Resources:: Getting resource values from the server.* Display Feature Testing:: Determining the features of a terminal.Positions* Point:: The special position where editing takes place.* Motion:: Changing point.* Excursions:: Temporary motion and buffer changes.* Narrowing:: Restricting editing to a portion of the buffer.Motion* Character Motion:: Moving in terms of characters.* Word Motion:: Moving in terms of words.* Buffer End Motion:: Moving to the beginning or end of the buffer.* Text Lines:: Moving in terms of lines of text.* Screen Lines:: Moving in terms of lines as displayed.* List Motion:: Moving by parsing lists and sexps.* Skipping Characters:: Skipping characters belonging to a certain set.Markers* Overview of Markers:: The components of a marker, and how it relocates.* Predicates on Markers:: Testing whether an object is a marker.* Creating Markers:: Making empty markers or markers at certain places.* Information from Markers:: Finding the marker's buffer or character position.* 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.* 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.* Auto Filling:: How auto-fill mode is implemented to break lines.* Filling:: Functions for explicit filling.* Margins:: How to specify margins for filling commands.* Sorting:: Functions for sorting parts of the buffer.* Indentation:: Functions to insert or adjust indentation.* Columns:: Computing horizontal positions, and using them.* 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.* Atomic Changes:: Installing several buffer changes ``atomically''.* Base 64:: Conversion to or from base 64 encoding.* MD5 Checksum:: Compute the MD5 ``message digest''/``checksum''.* Change Hooks:: Supplying functions to be run when text is changed.The Kill Ring* Kill Ring Concepts:: What text looks like in the kill ring.* 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.Indentation* Primitive Indent:: Functions used to count and insert indentation.* Mode-Specific Indent:: Customize indentation for different modes.* Region Indent:: Indent all the lines in a region.* Relative Indent:: Indent the current line based on previous lines.* Indent Tabs:: Adjustable, typewriter-like tab stops.* Motion by Indent:: Move to first non-blank character.Text Properties* Examining Properties:: Looking at the properties of one character.* Changing Properties:: Setting the properties of a range of text.* Property Search:: Searching for where a property changes value.* Special Properties:: Particular properties with special meanings.* Format Properties:: Properties for representing formatting of text.* Sticky Properties:: How inserted text gets properties from neighboring text.* Saving Properties:: Saving text properties in files, and reading them back.* Lazy Properties:: Computing text properties in a lazy fashion only when text is examined.* Clickable Text:: Using text properties to make regions of text do something when you click on them.* Fields:: The @code{field} property defines fields within the buffer.* Not Intervals:: Why text properties do not use Lisp-visible text intervals.Non-ASCII Characters* Text Representations:: Unibyte and multibyte representations* Converting Representations:: Converting unibyte to multibyte and vice versa.* Selecting a Representation:: Treating a byte sequence as unibyte or multi.* Character Codes:: How unibyte and multibyte relate to codes of individual characters.* Character Sets:: The space of possible characters 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.* Input Methods:: Input methods allow users to enter various non-ASCII characters without special keyboards.* Locales:: Interacting with the POSIX locale.Searching and Matching* String Search:: Search for an exact match.* Regular Expressions:: Describing classes of strings.* Regexp Search:: Searching for a match for a regexp.* Match Data:: Finding out which part of the text matched various parts of a regexp, after regexp search.* Saving Match Data:: Saving and restoring this information.* Standard Regexps:: Useful regexps for finding sentences, pages,...* Searching and Case:: Case-independent or case-significant searching.Regular Expressions* Syntax of Regexps:: Rules for writing regular expressions.* Regexp Example:: Illustrates regular expression syntax.Syntax Tables* Syntax Descriptors:: How characters are classified.* Syntax Table Functions:: How to create, examine and alter syntax tables.* 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.Syntax Descriptors* Syntax Class Table:: Table of syntax classes.* Syntax Flags:: Additional flags each character can have.Abbrevs And Abbrev Expansion* Abbrev Mode:: Setting up Emacs for abbreviation.* Tables: Abbrev Tables. Creating and working with abbrev tables.* Defining Abbrevs:: Specifying abbreviations and their expansions.* Files: Abbrev Files. Saving abbrevs in files.* Expansion: Abbrev Expansion. Controlling expansion; expansion subroutines.* Standard Abbrev Tables:: Abbrev tables used by various major modes.Processes* Subprocess Creation:: Functions that start subprocesses.* 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.* Network:: Opening network connections.Receiving Output from Processes* Process Buffers:: If no filter, output is put in a buffer.* Filter Functions:: Filter functions accept output from the process.* Decoding Output:: Filters can get unibyte or multibyte strings.* Accepting Output:: How to wait until process output arrives.Operating System Interface* Starting Up:: Customizing Emacs start-up processing.* Getting Out:: How exiting works (permanent or temporary).* System Environment:: Distinguish the name and kind of system.* Terminal Input:: Recording terminal input for debugging.* Terminal Output:: Recording terminal output for debugging.* Flow Control:: How to turn output flow control on or off.* Batch Mode:: Running Emacs without terminal interaction.Starting Up Emacs* Startup Summary:: Sequence of actions Emacs performs at start-up.* Init File:: Details on reading the init file (@file{.emacs}).* 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.Getting out of Emacs* Killing Emacs:: Exiting Emacs irreversibly.* Suspending Emacs:: Exiting Emacs reversibly.Emacs Display* Refresh Screen:: Clearing the screen and redrawing everything on it.* Truncation:: Folding or wrapping long text lines.* The Echo Area:: Where messages are displayed.* Warnings:: Displaying warning messages for the user.* Selective Display:: Hiding part of the buffer text.* Overlay Arrow:: Display of an arrow to indicate position.* 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.* Faces:: A face defines a graphics style for text characters: font, colors, etc.* Fringes:: Controlling window fringes.* Display Property:: Enabling special display features.* Images:: Displaying images in Emacs buffers.* Blinking:: How Emacs shows the matching open parenthesis.* Inverse Video:: Specifying how the screen looks.* 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.GNU Emacs Internals* Building Emacs:: How to preload Lisp libraries into Emacs.* Pure Storage:: A kludge to make preloaded Lisp functions sharable.* Garbage Collection:: Reclaiming space for Lisp objects no longer used.* Object Internals:: Data formats of buffers, windows, processes.* Writing Emacs Primitives:: Writing C code for Emacs.Object Internals* Buffer Internals:: Components of a buffer structure.* Window Internals:: Components of a window structure.* Process Internals:: Components of a process structure.@end menu@include intro.texi@include objects.texi@include numbers.texi@include strings.texi@include lists.texi@include sequences.texi@include hash.texi@include symbols.texi@include eval.texi@include control.texi@include variables.texi@include functions.texi@include macros.texi@include customize.texi@include loading.texi@include compile.texi@include advice.texi@include debugging.texi@include streams.texi@include minibuf.texi@include commands.texi@include keymaps.texi@include modes.texi@include help.texi@include files.texi@include backups.texi@include buffers.texi@include windows.texi@include frames.texi@include positions.texi@include markers.texi@include text.texi@include nonascii.texi@include searching.texi@include syntax.texi@include abbrevs.texi@include processes.texi@include display.texi@include calendar.texi@include os.texi@c MOVE to Emacs Manual: include misc-modes.texi@c appendices@c REMOVE this: include non-hacker.texi@include anti.texi@include doclicense.texi@include gpl.texi@include tips.texi@include internals.texi@include errors.texi@include locals.texi@include maps.texi@include hooks.texi@include index.texi@node New Symbols, , Index, Top@unnumbered New Symbols Since the Previous Edition@printindex tp@c Print the tables of contents@summarycontents@contents@c That's all@byeThese words prevent "local variables" above from confusing Emacs.@ignore arch-tag: f7e9a219-a0e1-4776-b631-08eaa1d49b34@end ignore