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.
- Conditions for copying and changing GNU Emacs.
- Introduction and conventions used.
- Types of Lisp Object
- Data types in Emacs Lisp.
- Numbers and arithmetic functions.
- Strings and Characters
- Strings, and functions that work on them.
- 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 represent names, uniquely.
- How Lisp expressions are evaluated.
- Control Structures
- Conditionals, loops, nonlocal exits.
- Using symbols in programs to stand for values.
- A function is a Lisp program
that can be invoked from other functions.
- Macros are a way to extend the Lisp language.
- Reading files of Lisp code into Lisp.
- Byte Compilation
- Compilation makes programs run faster.
- Tools and tips for debugging Lisp programs.
- Converting Lisp objects to text and back.
- Using the minibuffer to read input.
- Command Loop
- How the editor command loop works,
and how you can call its subroutines.
- Defining the bindings from keys to commands.
- Defining pull-down and pop-up menus.
- Dialog Boxes
- Creating dialog boxes.
- Defining major and minor modes.
- Writing and using documentation strings.
- Accessing files.
- Backups and Auto-Saving
- Controlling how backups and auto-save
files are made.
- Creating and using buffer objects.
- Manipulating windows and displaying buffers.
- Making multiple X windows.
- Buffer positions and motion functions.
- Markers represent positions and update
automatically when the text is changed.
- 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.
- How Abbrev mode works, and its data structures.
- Parameters controlling screen usage.
The bell. Waiting for input.
- Extents are regions of text with particular
- Annotations are pixmaps or strings displayed
at particular positions in a buffer.
- Running and communicating with subprocesses.
- System Interface
- Getting the user id, system type, environment
variables, and other such things.
- Functions specific to the X Window System.
- ToolTalk Support
- Interfacing with the ToolTalk message service.
- How Emacs supports different languages and
- 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.
- Information about Emacs 18.
- 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:
- Flaws and a request for help.
- Lisp History
- Emacs Lisp is descended from Maclisp.
- How the manual is formatted.
- The authors, editors, and sponsors of this manual.
- 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 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.
- 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
- 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
- Dotted Pair Notation
- An alternative syntax for lists.
- Association List Type
- A specially constructed list.
- 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.
- 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.
- 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
- Replacing an element in a list.
- Replacing part of the list backbone.
This can be used to remove or add elements.
- Reordering the elements in a list; combining lists.
Sequences, Arrays, and Vectors
- Sequence Functions
- Functions that accept any kind of sequence.
- Characteristics of arrays in Emacs Lisp.
- Array Functions
- Functions specifically for arrays.
- Functions specifically for vectors.
- Symbol Components
- Symbols have names, values, function definitions
and property lists.
- 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.
- Intro Eval
- Evaluation in the scheme of things.
- How to invoke the Lisp interpreter explicitly.
- How various sorts of objects are evaluated.
- Avoiding evaluation (to put constants in
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.
- Functions set up to load files
containing their real definitions.
- Evaluation in textual order.
- `if', `cond'.
- Combining Conditions
- `and', `or', `not'.
- `while' loops.
- Nonlocal Exits
- Jumping out of a sequence.
- Catch and Throw
- Nonlocal exits for the program's own purposes.
- Examples of Catch
- Showing how such nonlocal exits can be written.
- How errors are signaled and handled.
- Arranging to run a cleanup form if an
- 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.
- 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 means where in the program a value
is visible. Comparison with other languages.
- 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
- 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.
- 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
- 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.
- Simple Macro
- A basic example.
- How, when and why macros are expanded.
- Compiling Macros
- How macros are expanded by the compiler.
- Defining Macros
- How to write a macro definition.
- Easier construction of list structure.
- Problems with Macros
- Don't evaluate the macro arguments too many times.
Don't hide the user's variables.
- How Programs Do Loading
- The `load' function and others.
- Setting up a function to autoload.
- Loading a library if it isn't already loaded.
- Repeated Loading
- Precautions about loading a file twice.
- Compilation Functions
- Byte compilation functions.
- Disassembling byte-code; how to read byte-code.
Debugging Lisp Programs
- How the Emacs Lisp debugger is implemented.
- Syntax Errors
- How to find syntax errors.
- Compilation Errors
- How to find errors that show up in
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 Functions
- Functions to read Lisp objects from text.
- Output Streams
- Various data types that can be used as
- Output Functions
- Functions to print Lisp objects as text.
- 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.
- How to invoke and customize completion.
- Yes-or-No Queries
- Asking a question with a simple answer.
- Minibuffer Misc
- Various customization hooks and variables.
- 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 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 for user input or elapsed time.
- 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.
- 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.
- 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.
- Menu Format
- Menubar Format
- 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.
- How to use hooks; how to write code that
- 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 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.
- Putting information into a mode line.
- 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.
- 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 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 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
- 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
- How auto-save files are made; how their
names are chosen.
- `revert-buffer', and how to customize
what it does.
- 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.
- Buffer Basics
- What is a buffer?
- Buffer Names
- Accessing and changing buffer names.
- Buffer File Name
- The buffer file name indicates which file
- 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
- 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.
- 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.
- The special position where editing takes place.
- Changing point.
- Temporary motion and buffer changes.
- Restricting editing to a portion of the buffer.
- 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
- List Motion
- Moving by parsing lists and sexps.
- Skipping Characters
- Skipping characters belonging to a certain set.
- 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
- 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".
- Near Point
- Examining text in the vicinity of point.
- Buffer Contents
- Examining text in a general fashion.
- Adding new text to a buffer.
- Commands for Insertion
- User-level commands to insert text.
- Removing text from a buffer.
- User-Level Deletion
- User-level commands to delete text.
- The Kill Ring
- Where removed text sometimes is saved for
- Undoing changes to the text of a buffer.
- Auto Filling
- How auto-fill mode is implemented to break lines.
- Functions for explicit filling.
- Functions for sorting parts of the buffer.
- Functions to insert or adjust indentation.
- Computing horizontal positions, and using them.
- Case Changes
- Case conversion of parts of the buffer.
- Replacing a given character wherever it appears.
- Inserting or deleting underlining-by-overstrike.
- 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.
- 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.
- Syntax of Regexps
- Rules for writing regular expressions.
- Regexp Example
- Illustrates regular expression syntax.
- 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 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.
- Abbrev TablesCreating and working with abbrev tables.
- Defining Abbrevs
- Specifying abbreviations and their expansions.
- Abbrev FilesSaving abbrevs in files.
- Abbrev ExpansionControlling expansion; expansion subroutines.
- Standard Abbrev Tables
- Abbrev tables used by various major modes.
- Refresh Screen
- Clearing the screen and redrawing everything on it.
- 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.
- Forcing display update and waiting for user.
- How Emacs shows the matching open parenthesis.
- Usual Display
- How control characters are displayed.
- Audible signal to the user.
- Window Systems
- Which window system is being used.
- Intro to Extents
- Creating and Modifying Extents
- Extent Endpoints
- Finding Extents
- Extent Properties
- Detached Extents
- Duplicable Extents
- Extent Replicas
- Extents and Events
- Atomic Extents
- Annotation Basics
- Annotation Primitives
- Margin Primitives
- Annotation Hooks
- 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 run when process run-status changes.
- 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').
- 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 Selections
- Transferring text to and from other X clients.
- X Server
- X Miscellaneous
- Emacs ToolTalk API Summary
- Sending Messages
- Receiving Messages
- 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.
- 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