(lispref.info)Top


Next: Copying Prev: (dir) Up: (dir)

   This Info file contains the second edition of the GNU Emacs Lisp
Reference Manual, corresponding to Lucid GNU Emacs version 19.10.

* Copying
Conditions for copying and changing GNU Emacs.
* Introduction
Introduction and conventions used.
* Types of Lisp Object
Data types 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.
* 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.
* Loading
Reading files of Lisp code into Lisp.
* Byte Compilation
Compilation makes programs run faster.
* Debugging
Tools and tips for debugging Lisp programs.
* Streams
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.
* Menus
Defining pull-down and pop-up menus.
* Dialog Boxes
Creating dialog boxes.
* 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.
* Screens
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.
* 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.
* Display
Parameters controlling screen usage. The bell. Waiting for input.
* Extents
Extents are regions of text with particular display characteristics.
* Annotations
Annotations are pixmaps or strings displayed at particular positions in a buffer.
* Processes
Running and communicating with subprocesses.
* System Interface
Getting the user id, system type, environment variables, and other such things.
* X-Windows
Functions specific to the X Window System.
* ToolTalk Support
Interfacing with the ToolTalk message service.
* Internationalization
How Emacs supports different languages and cultural conventions.
Appendices

* Tips
Advice for writing Lisp programs.
* GNU Emacs Internals
Building and dumping Emacs; internal data structures.
* Standard Errors
List of all error symbols.
* Standard Buffer-Local Variables
List of variables local in all buffers.
* Standard Keymaps
List of standard keymaps.
* Standard Hooks
List of standard hook variables.
* Antinews
Information about Emacs 18.
* Index
Index including concepts, functions, variables, and other terms.
      -- The Detailed Node Listing --

Here are other nodes that are inferiors of those already listed,
mentioned here so you can get to them in one step:

Introduction

* 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 `nil' and `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.
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.
* List Type
Lists gave Lisp its name (not to mention reputation).
* 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.
* Lisp Function Type
A piece of executable code you can call from elsewhere.
* Lisp 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.
* Syntax Table Type
What a character means.
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.
* Transcendental Functions
Trig, exponential and logarithmic functions.
* Random Numbers
Obtaining random integers, predictable or not.
Strings and Characters

* Intro to Strings
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
`format': Emacs's analog of `printf'.
* Character Case
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
`if', `cond'.
* Combining Conditions
`and', `or', `not'.
* Iteration
`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 Names
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 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.
Loading

* How Programs Do Loading
The `load' function and others.
* Autoload
Setting up a function to autoload.
* 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.
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.
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 `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.)
* Programmed Completion
Finding the completions for a given file name.
* 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.
* Lisp Symbol Completion
Completing the name of a symbol.
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 `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 `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.
* 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.
* Key Binding Commands
Interactive interfaces for redefining keys.
* Scanning Keymaps
Looking through all keymaps, for printing help.
Menus

* Menu Format
* Menubar Format
* Menubar
* Modifying Menus
* Pop-Up Menus
* Menu Hooks
* Buffers Menu
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 File Attributes
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
`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 "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.
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.
* Vertical Motion
Implementation of `next-line' and `previous-line'.
* 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.
* Changing 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.
* 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.
* Substitution
Replacing a given character wherever it appears.
* Underlining
Inserting or deleting underlining-by-overstrike.
* Registers
How registers are implemented. Accessing the text or position stored in a register.
The Kill Ring

* Kill Ring Concepts
What text looks like in the kill ring.
* Kill Functions
Functions that kill text.
* 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.
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 TablesCreating and working with abbrev tables.
* Defining Abbrevs
Specifying abbreviations and their expansions.
* Files
Abbrev FilesSaving abbrevs in files.
* Expansion
Abbrev ExpansionControlling expansion; expansion subroutines.
* Standard Abbrev Tables
Abbrev tables used by various major modes.
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.
* Selective Display
Hiding part of the buffer text.
* Overlay Arrow
Display of an arrow to indicate position.
* Temporary Displays
Displays that go away automatically.
* Waiting
Forcing display update and waiting for user.
* Blinking
How Emacs shows the matching open parenthesis.
* Usual Display
How control characters are displayed.
* Beeping
Audible signal to the user.
* Window Systems
Which window system is being used.
Extents

* Intro to Extents
* Creating and Modifying Extents
* Extent Endpoints
* Finding Extents
* Extent Properties
* Detached Extents
* Duplicable Extents
* Extent Replicas
* Extents and Events
* Atomic Extents
Annotations

* Annotation Basics
* Annotation Primitives
* Margin Primitives
* Annotation Hooks
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.
* TCP
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.
* 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

* Start-up Summary
Sequence of actions Emacs performs at start-up.
* Init File
Details on reading the init 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.
X-Windows

* X Selections
Transferring text to and from other X clients.
* X Server
* X Miscellaneous
ToolTalk Support

* Emacs ToolTalk API Summary
* Sending Messages
* Receiving Messages
Internationalization

* I18N Levels 1 and 2
* I18N Level 3
* I18N Level 4
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.

automatically generated by info2www