Info Node: (elisp)Top
This Info file contains edition 2.7 of the GNU Emacs Lisp Reference
Manual, corresponding to GNU Emacs version 21.1.
- Introduction and conventions used.
- Coding Conventions. Coding conventions for Emacs Lisp.
- Lisp Data Types
- Data types of objects 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.
- Hash Tables
- Very fast lookup-tables.
- 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.
- Writing customization declarations.
- Reading files of Lisp code into Lisp.
- Byte Compilation
- Compilation makes programs run faster.
- Advising Functions
- Adding to the definition of a function.
- Tools and tips for debugging Lisp programs.
- Read and Print
- 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 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.
- 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.
- How Abbrev mode works, and its data structures.
- Running and communicating with subprocesses.
- Features for controlling the screen display.
- Customizing the calendar and diary.
- System Interface
- Getting the user id, system type, environment
variables, and other such things.
- Info for users downgrading to Emacs 20.
- GNU Free Documentation License
- The license for this documentation
- Conditions for copying and changing GNU Emacs.
- 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 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:
- 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.
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 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.
- 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
- 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.
- Overlay Type
- How an overlay is represented.
- 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
- `format': Emacs's analogue of `printf'.
- Case Conversion
- 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 Symbols
- 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 buffer-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.
- Named Features
- 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.
- Simple Advice
- A simple example to explain the basics of advice.
- Defining Advice
- Detailed description of `defadvice'.
- Computed Advice
- is to `defadvice' as `fset' is to `defun'.
- Activation of Advice
- Advice doesn't do anything until you activate it.
- Enabling Advice
- You can enable or disable each piece of advice.
- Preactivation is a way of speeding up the
loading of compiled advice.
- Argument Access in Advice
- How advice can access the function's arguments.
- Subr Arguments
- Accessing arguments when advising a primitive.
- Combined Definition
- How advice is implemented.
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
- 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 `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.)
- 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 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.
- 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.
- 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.
- 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 Files
- 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.
- 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.
- Getting resource values from the server.
- Display Feature Testing
- Determining the features of a terminal.
- 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.
- 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
- 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''.
- 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.
- How to specify margins for filling commands.
- 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.
- Text Properties
- Assigning Lisp property lists to text characters.
- Replacing a given character wherever it appears.
- Swapping two portions of a buffer.
- How registers are implemented. Accessing
the text or position stored in a register.
- 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.
- 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.
- 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
- Saving Properties
- Saving text properties in files, and reading
- Lazy Properties
- Computing text properties in a lazy fashion
only when text is examined.
- Not Intervals
- Why text properties do not use
Lisp-visible text intervals.
- 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 speciak keyboards.
- 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.
- 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 Tables. Creating and working with abbrev tables.
- Defining Abbrevs
- Specifying abbreviations and their expansions.
- Abbrev Files. Saving abbrevs in files.
- Abbrev Expansion. Controlling expansion; expansion subroutines.
- Standard Abbrev Tables
- Abbrev tables used by various major modes.
- 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
- Startup 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.
- 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.
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 version 184.108.40.206