- 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.
- Customization
- Writing customization declarations.
- 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.
- Drag and Drop
- Generic API to inter-application communication
via specific protocols.
- 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.
- LDAP Support
- Interfacing with the Lightweight Directory
Access Protocol.
- 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 Properties
- 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
-
LDAP Support
- Building XEmacs with LDAP support
- How to add LDAP support to XEmacs
- XEmacs LDAP API
- Lisp access to LDAP functions
- Syntax of Search Filters
- A brief summary of RFC 1558
XEmacs LDAP API
- LDAP Variables
- Lisp variables related to LDAP
- The High-Level LDAP API
- High-level LDAP lisp functions
- The Low-Level LDAP API
- Low-level LDAP lisp primitives
The Low-Level LDAP API
- The LDAP Lisp Object
-
- Opening and Closing a LDAP Connection
-
- Searching on a LDAP Server (Low-level)
-
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.