Info Node: (lispref.info)Top

lispref.info: Top

(dir) Copying (dir) Back to Software Index


   This Info file contains the third edition of the XEmacs Lisp
Reference Manual, corresponding to XEmacs version 19.14.

Copying: Conditions for copying and changing XEmacs.
Introduction: Introduction and conventions used.
Lisp Data Types: Data types of objects in XEmacs 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.
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.
Menus: Defining pull-down and pop-up menus.
Dialog Boxes: Creating dialog boxes.
Toolbar: Controlling the toolbar.
Scrollbars: Controlling the scrollbars.
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.
Consoles and Devices: Opening frames on multiple TTY's or X displays.
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.
Extents: Extents are regions of text with particular display characteristics.
Specifiers: How faces and glyphs are specified.
Faces and Window-System Objects: A face is a set of display characteristics specifying how text is to be displayed.
Glyphs: General interface to pixmaps displayed in a buffer or frame.
Annotations: Higher-level interface to glyphs in a buffer.
Display: Parameters controlling screen usage. The bell. Waiting for input.
Hash Tables: Fast data structures for mappings.
Range Tables: Keeping track of ranges of numbers.
Databases: An interface to standard DBM and DB databases.
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.
MULE: Specifics of the Asian-language support.

Appendices

Tips: Advice for writing Lisp programs.
Building XEmacs and Object Allocation: Behind-the-scenes information about XEmacs.
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.
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: XEmacs 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 XEmacs.
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.
Compiled-Function Type: A function written in Lisp, then compiled.
Autoload Type: A type used for automatically loading seldom-used functions.

Cons Cell 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.
Math Functions: Trig, exponential and logarithmic functions.
Random Numbers: Obtaining random integers, predictable or not.

Strings and Characters

Basics: 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.
Predicates for Characters: Testing whether an object is a character.
Character Codes: Each character has an equivalent integer.
Text Comparison: Comparing characters or strings.
String Conversion: Converting characters or strings and vice versa.
Modifying Strings: Changing characters in a string.
String Properties: Additional information attached to strings.
Formatting Strings: `format': XEmacs's analog of `printf'.
Character Case: Case conversion functions.
Char Tables: Mapping from characters to Lisp objects.
Case Tables: Customizing case conversion.

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.
Property Lists: A different way to represent a finite mapping.
Weak Lists: A list with special garbage-collection behavior.

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 XEmacs 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.
Symbol Properties: 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 XEmacs 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 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.
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.

Debugging Lisp Programs

Debugger: How the XEmacs 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 XEmacs 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 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.
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.

Events

Event Types: Events come in different types.
Event Contents: What the contents of each event type are.
Event Predicates: Querying whether an event is of a particular type.
Accessing Mouse Event Positions: Determining where a mouse event occurred, and over what.
Accessing Other Event Info: Accessing non-positional event info.
Working With Events: Creating, copying, and destroying events.
Converting Events: Converting between events, keys, and characters.

Accessing Mouse Event Positions

Frame-Level Event Position Info
Window-Level Event Position Info
Event Text Position Info
Event Glyph Position Info
Event Toolbar Position Info
Other Event Position Info

Reading Input

Key Sequence Input: How to read one key sequence.
Reading One Event: How to read just one event.
Dispatching an Event: What to do with an event once it has been read.
Quoted Character Input: Asking the user to specify a character.
Peeking and Discarding: How to reread or throw away input events.

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.
Key Sequences: How to specify key sequences.
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.
Other Keymap Functions: Miscellaneous keymap functions.

Menus

Menu Format: Format of a menu description.
Menubar Format: How to specify a menubar.
Menubar: Functions for controlling the menubar.
Modifying Menus: Modifying a menu description.
Pop-Up Menus: Functions for specifying pop-up menus.
Menu Filters: Filter functions for the default menubar.
Buffers Menu: The menu that displays the list of buffers.

Dialog Boxes

Dialog Box Format
Dialog Box Functions

Toolbar

Toolbar Intro: An introduction.
Toolbar Descriptor Format: How to create a toolbar.
Specifying the Toolbar: Setting a toolbar.
Other Toolbar Variables: Controlling the size of toolbars.

Scrollbars

Major and Minor Modes

Major Modes: Defining major modes.
Minor Modes: Defining minor modes.
Modeline Format: Customizing the text that appears in the modeline.
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 XEmacs 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.

Modeline Format

Modeline Data: The data structure that controls the modeline.
Modeline Variables: Variables used in that data structure.
%-Constructs: Putting information into a modeline.

Documentation

Documentation Basics: Good style for doc strings. Where to put them. How XEmacs 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 XEmacs 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 XEmacs 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 XEmacs'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.
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 makes the others hide them.
Frame Hooks: Hooks for customizing frame behavior.

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.
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.
Comparing Text: Comparing substrings of buffers.
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.
Maintaining Undo: How to enable and disable undo information. How to control how much information is kept.
Filling: Functions for explicit filling.
Margins: How to specify margins for filling commands.
Auto Filling: How auto-fill mode is implemented to break lines.
Sorting: Functions for sorting parts of the buffer.
Columns: Computing horizontal positions, and using them.
Indentation: Functions to insert or adjust indentation.
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.
Registers: How registers are implemented. Accessing the text or position stored in a register.
Transposition: Swapping two portions of a buffer.
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.

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 XEmacs 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.

Extents

Intro to Extents: Extents are regions over a buffer or string.
Creating and Modifying Extents: Basic extent functions.
Extent Endpoints: Accessing and setting the bounds of an extent.
Finding Extents: Determining which extents are in an object.
Mapping Over Extents: More sophisticated functions for extent scanning.
Extent Properties: Extents have built-in and user-definable properties.
Detached Extents: Extents that are not in a buffer.
Extent Parents: Inheriting properties from another extent.
Duplicable Extents: Extents can be marked to be copied into strings.
Extents and Events: Extents can interact with the keyboard and mouse.
Atomic Extents: Treating a block of text as a single entity.

Specifiers

Introduction to Specifiers: Specifiers provide a clean way for display and other properties to vary (under user control) in a wide variety of contexts.
Specifiers In-Depth: Gory details about specifier innards.
Specifier Instancing: Instancing means obtaining the "value" of a specifier in a particular context.
Specifier Types: Specifiers come in different flavors.
Adding Specifications: Specifications control a specifier's "value" by giving conditions under which a particular value is valid.
Retrieving Specifications: Querying a specifier's specifications.
Specifier Instancing Functions: Functions to instance a specifier.
Specifier Example: Making all this stuff clearer.
Creating Specifiers: Creating specifiers for your own use.
Specifier Validation Functions: Validating the components of a specifier.
Other Specification Functions: Other ways of working with specifications.

Faces and Window-System Objects

Faces: Controlling the way text looks.
Fonts: Controlling the typeface of text.
Colors: Controlling the color of text and pixmaps.

Faces

Merging Faces: How XEmacs decides which face to use for a character.
Basic Face Functions: How to define and examine faces.
Face Properties: How to access and modify a face's properties.
Face Convenience Functions: Convenience functions for accessing particular properties of a face.
Other Face Display Functions: Other functions pertaining to how a a face appears.

Fonts

Font Specifiers: Specifying how a font will appear.
Font Instances: What a font specifier gets instanced as.
Font Instance Names: The name of a font instance.
Font Instance Size: The size of a font instance.
Font Instance Characteristics: Display characteristics of font instances.
Font Convenience Functions: Convenience functions that automatically instance and retrieve the properties of a font specifier.

Colors

Color Specifiers: Specifying how a color will appear.
Color Instances: What a color specifier gets instanced as.
Color Instance Properties: Properties of color instances.
Color Convenience Functions: Convenience functions that automatically instance and retrieve the properties of a color specifier.

Glyphs

Glyph Functions: Functions for working with glyphs.
Images: Graphical images displayed in a frame.
Glyph Types: Each glyph has a particular type.
Mouse Pointer: Controlling the mouse pointer.
Redisplay Glyphs: Glyphs controlling various redisplay functions.
Subwindows: Inserting an externally-controlled subwindow into a buffer.

Glyph Functions

Creating Glyphs: Creating new glyphs.
Glyph Properties: Accessing and modifying a glyph's properties.
Glyph Convenience Functions: Convenience functions for accessing particular properties of a glyph.
Glyph Dimensions: Determining the height, width, etc. of a glyph.

Images

Image Specifiers: Specifying how an image will appear.
Image Instantiator Conversion: Conversion is applied to image instantiators at the time they are added to an image specifier or at the time they are passed to `make-image-instance'.
Image Instances: What an image specifier gets instanced as.

Image Instances

Image Instance Types: Each image instances has a particular type.
Image Instance Functions: Functions for working with image instances.

Annotations

Annotation Basics: Introduction to annotations.
Annotation Primitives: Creating and deleting annotations.
Annotation Properties: Retrieving and changing the characteristics of an annotation.
Margin Primitives: Controlling the size of the margins.
Locating Annotations: Looking for annotations in a buffer.
Annotation Hooks: Hooks called at certain times during an annotation's lifetime.

Hash Tables

Introduction to Hash Tables: Hash tables are fast data structures for implementing simple tables (i.e. finite mappings from keys to values).
Working With Hash Tables: Hash table functions.
Weak Hash Tables: Hash tables with special garbage-collection behavior.

Range Tables

Introduction to Range Tables: Range tables efficiently map ranges of integers to values.
Working With Range Tables: Range table functions.

XEmacs 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.
Blinking: How XEmacs shows the matching open parenthesis.
Usual Display: The usual conventions for displaying nonprinting chars.
Display Tables: How to specify other conventions.
Beeping: Audible signal to the user.

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.
Accepting Output: How to wait until process output arrives.

Operating System Interface

Starting Up: Customizing XEmacs 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 XEmacs without terminal interaction.

Starting Up XEmacs

Start-up Summary: Sequence of actions XEmacs 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 XEmacs

Killing XEmacs: Exiting XEmacs irreversibly.
Suspending XEmacs: Exiting XEmacs reversibly.

X-Windows

X Selections: Transferring text to and from other X clients.
X Server: Information about the X server connected to a particular device.
Resources: Getting resource values from the server.
Server Data: Getting info about the X server.
Grabs: Restricting access to the server by other apps.
X Miscellaneous: Other X-specific functions and variables.

ToolTalk Support

XEmacs ToolTalk API Summary
Sending Messages
Receiving Messages

Internationalization

I18N Levels 1 and 2: Support for different time, date, and currency formats.
I18N Level 3: Support for localized messages.
I18N Level 4: Support for Asian languages.

MULE

Internationalization Terminology: Definition of various internationalization terms.
Charsets: Sets of related characters.
MULE Characters: Working with characters in XEmacs/MULE.
Composite Characters: Making new characters by overstriking other ones.
ISO 2022: An international standard for charsets and encodings.
Coding Systems: Ways of representing a string of chars using integers.
CCL: A special language for writing fast converters.
Category Tables: Subdividing charsets into groups.

Tips

Style Tips: Writing 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.

Building XEmacs and Object Allocation

Building XEmacs: How to preload Lisp libraries into XEmacs.
Pure Storage: A kludge to make preloaded Lisp functions sharable.
Garbage Collection: Reclaiming space for Lisp objects no longer used.

automatically generated by info2www version 1.2