[Top][All Lists]
[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]
[Emacs-diffs] Changes to emacs/lispref/elisp.texi
|
From: |
Lute Kamstra |
|
Subject: |
[Emacs-diffs] Changes to emacs/lispref/elisp.texi |
|
Date: |
Wed, 11 May 2005 19:25:27 -0400 |
Index: emacs/lispref/elisp.texi
diff -c emacs/lispref/elisp.texi:1.53 emacs/lispref/elisp.texi:1.54
*** emacs/lispref/elisp.texi:1.53 Wed May 11 12:27:49 2005
--- emacs/lispref/elisp.texi Wed May 11 23:25:27 2005
***************
*** 101,107 ****
@menu
* Introduction:: Introduction and conventions used.
- * Standards: Coding Conventions. Coding conventions for Emacs Lisp.
* Lisp Data Types:: Data types of objects in Emacs Lisp.
* Numbers:: Numbers and arithmetic functions.
--- 101,106 ----
***************
*** 184,189 ****
--- 183,189 ----
* Caveats:: Flaws and a request for help.
* Lisp History:: Emacs Lisp is descended from Maclisp.
* Conventions:: How the manual is formatted.
+ * Version Info:: Which Emacs version is running?
* Acknowledgements:: The authors, editors, and sponsors of this manual.
Conventions
***************
*** 196,209 ****
* 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::
--- 196,201 ----
***************
*** 215,220 ****
--- 207,213 ----
* Comments:: Comments and their formatting conventions.
* Programming Types:: Types found in all Lisp systems.
* Editing Types:: Types specific to Emacs.
+ * Circular Objects:: Read syntax for circular structure.
* Type Predicates:: Tests related to types.
* Equality Predicates:: Tests of equality between any two objects.
***************
*** 224,236 ****
* 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.
--- 217,232 ----
* Floating Point Type:: Numbers with fractional parts and with a large range.
* Character Type:: The representation of letters, numbers and
control characters.
+ * Symbol Type:: A multi-use object that refers to a function,
+ variable, property list, or itself.
* 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.
! * Char-Table Type:: One-dimensional sparse arrays indexed by characters.
! * Bool-Vector Type:: One-dimensional arrays of @code{t} or @code{nil}.
! * Hash Table Type:: Super-fast lookup tables.
* 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.
***************
*** 239,255 ****
* Autoload Type:: A type used for automatically loading seldom-used
functions.
! List Type
* Dotted Pair Notation:: An alternative syntax for lists.
* Association List Type:: A specially constructed list.
Editing Types
* Buffer Type:: The basic object of editing.
* Window Type:: What makes buffers visible.
* Window Configuration Type::Save what the screen looks like.
! * Marker Type:: A position in a buffer.
* Process Type:: A process running on the underlying OS.
* Stream Type:: Receive or send characters.
* Keymap Type:: What function a keystroke invokes.
--- 235,254 ----
* Autoload Type:: A type used for automatically loading seldom-used
functions.
! Cons Cell and List Types
+ * Box Diagrams:: Drawing pictures of lists.
* Dotted Pair Notation:: An alternative syntax for lists.
* Association List Type:: A specially constructed list.
Editing Types
* Buffer Type:: The basic object of editing.
+ * Marker Type:: A position in a buffer.
* Window Type:: What makes buffers visible.
+ * Frame Type:: Windows subdivide frames.
* Window Configuration Type::Save what the screen looks like.
! * Frame Configuration Type::Recording the status of all frames.
* Process Type:: A process running on the underlying OS.
* Stream Type:: Receive or send characters.
* Keymap Type:: What function a keystroke invokes.
***************
*** 261,269 ****
* 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.
--- 260,269 ----
* Float Basics:: Representation and range of floating point.
* Predicates on Numbers:: Testing for numbers.
* Comparison of Numbers:: Equality and inequality predicates.
+ * Numeric Conversions:: Converting float to integer and vice
versa.
* Arithmetic Operations:: How to add, subtract, multiply and divide.
+ * Rounding Operations:: Explicitly rounding floating point numbers.
* Bitwise Operations:: Logical and, or, not, shifting.
* Math Functions:: Trig, exponential and logarithmic functions.
* Random Numbers:: Obtaining random integers, predictable or not.
***************
*** 272,281 ****
--- 272,283 ----
* 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.
+ * Modifying Strings:: Altering the contents of an existing string.
* Text Comparison:: Comparing characters or strings.
* String Conversion:: Converting characters or strings and vice versa.
* Formatting Strings:: @code{format}: Emacs's analogue of @code{printf}.
* Case Conversion:: Case conversion functions.
+ * Case Tables:: Customizing case conversion.
Lists
***************
*** 300,305 ****
--- 302,317 ----
* Arrays:: Characteristics of arrays in Emacs Lisp.
* Array Functions:: Functions specifically for arrays.
* Vectors:: Functions specifically for vectors.
+ * Vector Functions:: Functions specifically for vectors.
+ * Char-Tables:: How to work with char-tables.
+ * Bool-Vectors:: How to work with bool-vectors.
+
+ Hash Tables
+
+ * Creating Hash:: Functions to create hash tables.
+ * Hash Access:: Reading and writing the hash table contents.
+ * Defining Hash:: Defining new comparison methods
+ * Other Hash:: Miscellaneous.
Symbols
***************
*** 313,328 ****
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,
--- 325,342 ----
Evaluation
* Intro Eval:: Evaluation in the scheme of things.
* Forms:: How various sorts of objects are evaluated.
* Quoting:: Avoiding evaluation (to put constants in
the program).
+ * Eval:: How to invoke the Lisp interpreter explicitly.
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 Indirection:: When a symbol appears as the car of a list,
+ we find the real function via the symbol.
* Function Forms:: Forms that call functions.
* Macro Forms:: Forms that call macros.
* Special Forms:: ``Special forms'' are idiosyncratic primitives,
***************
*** 333,339 ****
Control Structures
* Sequencing:: Evaluation in textual order.
! * Conditionals:: @code{if}, @code{cond}.
* Combining Conditions:: @code{and}, @code{or}, @code{not}.
* Iteration:: @code{while} loops.
* Nonlocal Exits:: Jumping out of a sequence.
--- 347,353 ----
Control Structures
* Sequencing:: Evaluation in textual order.
! * Conditionals:: @code{if}, @code{cond}, @code{when},
@code{unless}.
* Combining Conditions:: @code{and}, @code{or}, @code{not}.
* Iteration:: @code{while} loops.
* Nonlocal Exits:: Jumping out of a sequence.
***************
*** 360,370 ****
--- 374,392 ----
* 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.
+ * Tips for Defining:: Things you should think about when you
+ define 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.
+ * Frame-Local Variables:: Variable values in effect only in one frame.
+ * Future Local Variables:: New kinds of local values we might add some day.
+ * Variable Aliases:: Variables that are aliases for other variables.
+ * File Local Variables:: Handling local variable lists in files.
+ * Variables with Restricted Values:: Non-constant variables whose value can
+ @emph{not} be an arbitrary Lisp
object.
Scoping Rules for Variable Bindings
***************
*** 393,398 ****
--- 415,423 ----
* Anonymous Functions:: Lambda-expressions are functions with no names.
* Function Cells:: Accessing or setting the function definition
of a symbol.
+ * Obsolete Functions:: Declaring functions obsolete.
+ * Inline Functions:: Defining functions that the compiler will open code.
+ * Function Safety:: Determining whether a function is safe to call.
* Related Topics:: Cross-references to specific Lisp primitives
that have a special bearing on how
functions work.
***************
*** 415,420 ****
--- 440,453 ----
Don't hide the user's variables.
* Indenting Macros:: Specifying how to indent macro calls.
+ Writing Customization Definitions
+
+ * Common Keywords:: Common keyword arguments for all kinds of
+ customization declarations.
+ * Group Definitions:: Writing customization group definitions.
+ * Variable Definitions:: Declaring user options.
+ * Customization Types:: Specifying the type of a user option.
+
Loading
* How Programs Do Loading:: The @code{load} function and others.
***************
*** 430,442 ****
Byte Compilation
* Compilation Functions:: Byte compilation functions.
* Disassembly:: Disassembling byte-code; how to read byte-code.
! Advising Functions
* Simple Advice:: A simple example to explain the basics of advice.
* Defining Advice:: Detailed description of @code{defadvice}.
* Computed Advice:: ...is to @code{defadvice} as @code{fset} is to
@code{defun}.
* Activation of Advice:: Advice doesn't do anything until you activate it.
* Enabling Advice:: You can enable or disable each piece of advice.
--- 463,482 ----
Byte Compilation
+ * Speed of Byte-Code:: An example of speedup from byte compilation.
* Compilation Functions:: Byte compilation functions.
+ * Docs and Compilation:: Dynamic loading of documentation strings.
+ * Dynamic Loading:: Dynamic loading of individual functions.
+ * Eval During Compile:: Code to be evaluated when you compile.
+ * Compiler Errors:: Handling compiler error messages.
+ * Byte-Code Objects:: The data type used for byte-compiled functions.
* Disassembly:: Disassembling byte-code; how to read byte-code.
! Advising Emacs Lisp Functions
* Simple Advice:: A simple example to explain the basics of advice.
* Defining Advice:: Detailed description of @code{defadvice}.
+ * Around-Advice:: Wrapping advice around a function's definition.
* Computed Advice:: ...is to @code{defadvice} as @code{fset} is to
@code{defun}.
* Activation of Advice:: Advice doesn't do anything until you activate it.
* Enabling Advice:: You can enable or disable each piece of advice.
***************
*** 449,462 ****
Debugging Lisp Programs
* Debugger:: How the Emacs Lisp debugger is implemented.
* Syntax Errors:: How to find syntax errors.
* Compilation Errors:: How to find errors that show up in
byte compilation.
- * Edebug:: 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.
--- 489,504 ----
Debugging Lisp Programs
* Debugger:: How the Emacs Lisp debugger is implemented.
+ * Edebug:: A source-level Emacs Lisp debugger.
* Syntax Errors:: How to find syntax errors.
+ * Test Coverage:: Ensuring you have tested all branches in your
code.
* Compilation Errors:: How to find errors that show up in
byte compilation.
The Lisp Debugger
* Error Debugging:: Entering the debugger when an error happens.
+ * Infinite Loops:: Stopping and debugging a program that doesn't exit.
* 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.
***************
*** 464,469 ****
--- 506,532 ----
* Invoking the Debugger:: How to call the function @code{debug}.
* Internals of Debugger:: Subroutines of the debugger, and global variables.
+ Edebug
+
+ * Using Edebug:: Introduction to use of Edebug.
+ * Instrumenting:: You must instrument your code
+ in order to debug it with Edebug.
+ * Edebug Execution Modes:: Execution modes, stopping more or less often.
+ * Jumping:: Commands to jump to a specified place.
+ * Edebug Misc:: Miscellaneous commands.
+ * Breakpoints:: Setting breakpoints to make the program
stop.
+ * Trapping Errors:: Trapping errors with Edebug.
+ * Edebug Views:: Views inside and outside of Edebug.
+ * Edebug Eval:: Evaluating expressions within Edebug.
+ * Eval List:: Expressions whose values are displayed
+ each time you enter Edebug.
+ * Printing in Edebug:: Customization of printing.
+ * Trace Buffer:: How to produce trace output in a buffer.
+ * Coverage Testing:: How to test evaluation coverage.
+ * The Outside Context:: Data that Edebug saves and restores.
+ * Instrumenting Macro Calls:: Specifying how to handle macro calls.
+ * Edebug Options:: Option variables for customizing Edebug.
+
Debugging Invalid Lisp Syntax
* Excess Open:: How to find a spurious open paren or missing
close.
***************
*** 478,491 ****
--- 541,561 ----
* Output Streams:: Various data types that can be used as
output streams.
* Output Functions:: Functions to print Lisp objects as text.
+ * Output Variables:: Variables that control what the printing
+ functions do.
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.
+ * Minibuffer History:: Recording previous minibuffer inputs
+ so the user can reuse them.
+ * Initial Input:: Specifying initial contents for the minibuffer.
* Completion:: How to invoke and customize completion.
* Yes-or-No Queries:: Asking a question with a simple answer.
+ * Multiple Queries:: Asking a series of similar questions.
+ * Reading a Password:: Reading a password from the terminal.
* Minibuffer Misc:: Various customization hooks and variables.
Completion
***************
*** 505,512 ****
--- 575,584 ----
* 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.
+ * Adjusting Point:: Adjustment of point after a command.
* Input Events:: What input looks like when you read it.
* Reading Input:: How to read input events from the keyboard or mouse.
+ * Special Events:: Events processed immediately and individually.
* Waiting:: Waiting for user input or elapsed time.
* Quitting:: How @kbd{C-g} works. How to catch or defer quitting.
* Prefix Command Arguments:: How the commands to set prefix args work.
***************
*** 531,538 ****
* 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.
--- 603,608 ----
***************
*** 542,547 ****
--- 612,619 ----
* Remapping Commands:: Bindings that translate one command to
another.
* Key Binding Commands:: Interactive interfaces for redefining keys.
* Scanning Keymaps:: Looking through all keymaps, for printing
help.
+ * Menu Keymaps:: A keymap can define a menu for X
+ or for use from the terminal.
Major and Minor Modes
***************
*** 600,610 ****
* 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 Files
--- 672,686 ----
* 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.
* Changing Files:: Renaming files, changing protection, etc.
* File Names:: Decomposing and expanding file names.
+ * Contents of Directories:: Getting a list of the files in a directory.
+ * Create/Delete Dirs:: Creating and Deleting Directories.
+ * Magic File Names:: Defining "magic" special handling
+ for certain file names.
+ * Format Conversion:: Conversion to and from various file formats.
Visiting Files
***************
*** 614,632 ****
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
--- 690,711 ----
Information about Files
* Testing Accessibility:: Is a given file readable? Writable?
! * Kinds of Files:: Is it a directory? A symbolic link?
! * Truenames:: Eliminating symbolic links from a file name.
* 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.
* Relative File Names:: Some file names are relative to a
current directory.
+ * Directory Names:: A directory's name as a directory
+ is different from its name as a file.
* 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.
+ * Standard File Names:: If your package uses a fixed file name,
+ how to handle various operating systems simply.
Backups and Auto-Saving
***************
*** 648,653 ****
--- 727,734 ----
Buffers
* Buffer Basics:: What is a buffer?
+ * Current Buffer:: Designating a buffer as current
+ so primitives will access its contents.
* Buffer Names:: Accessing and changing buffer names.
* Buffer File Name:: The buffer file name indicates which file
is visited.
***************
*** 659,666 ****
* 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
--- 740,748 ----
* The Buffer List:: How to look at all the existing buffers.
* Creating Buffers:: Functions that create buffers.
* Killing Buffers:: Buffers exist until explicitly killed.
! * Indirect Buffers:: An indirect buffer shares text with some
! other buffer.
! * Buffer Gap:: The gap in the buffer.
Windows
***************
*** 672,685 ****
* 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
--- 754,773 ----
* 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.
+ * Choosing Window:: How to choose a window for displaying a buffer.
* 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.
! * Textual Scrolling:: Moving text up and down through the window.
! * Vertical Scrolling:: Moving the contents up and down on the window.
! * Horizontal Scrolling:: Moving the contents sideways on the window.
* Size of Window:: Accessing the size of a window.
* Resizing Windows:: Changing the size of a window.
+ * Coordinates and Windows:: Converting coordinates to windows.
* Window Configurations:: Saving and restoring the state of the screen.
+ * Window Hooks:: Hooks for scrolling, window size changes,
+ redisplay going past a certain point,
+ or window configuration changes.
Frames
***************
*** 704,709 ****
--- 792,798 ----
* 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.
+ * Text Terminal Colors:: Defining colors for text-only terminals.
* Resources:: Getting resource values from the server.
* Display Feature Testing:: Determining the features of a terminal.
***************
*** 729,736 ****
* 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.
* 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''.
--- 818,827 ----
* 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.
! * Marker Insertion Types:: Two ways a marker can relocate when you
! insert where it points.
* 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''.
***************
*** 739,744 ****
--- 830,836 ----
* 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.
***************
*** 746,766 ****
* The Kill Ring:: Where removed text sometimes is saved for
later use.
* Undo:: Undoing changes to the text of a buffer.
! * Auto Filling:: How auto-fill mode is implemented to break lines.
* Filling:: Functions for explicit filling.
* Margins:: How to specify margins for filling commands.
* Sorting:: Functions for sorting parts of the buffer.
- * Indentation:: Functions to insert or adjust indentation.
* Columns:: Computing horizontal positions, and using them.
* Case Changes:: Case conversion of parts of the buffer.
* Text Properties:: Assigning Lisp property lists to text characters.
* Substitution:: Replacing a given character wherever it appears.
* Transposition:: Swapping two portions of a buffer.
* Registers:: How registers are implemented. Accessing
the text or position stored in a register.
- * Atomic Changes:: Installing several buffer changes ``atomically''.
* Base 64:: Conversion to or from base 64 encoding.
* MD5 Checksum:: Compute the MD5 ``message digest''/``checksum''.
* Change Hooks:: Supplying functions to be run when text is
changed.
The Kill Ring
--- 838,862 ----
* 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.
+ * Adaptive Fill:: Adaptive Fill mode chooses a fill prefix
+ from context.
+ * 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.
* Transposition:: Swapping two portions of a buffer.
* Registers:: How registers are implemented. Accessing
the text or position stored in a register.
* Base 64:: Conversion to or from base 64 encoding.
* MD5 Checksum:: Compute the MD5 ``message digest''/``checksum''.
+ * Atomic Changes:: Installing several buffer changes ``atomically''.
* Change Hooks:: Supplying functions to be run when text is
changed.
The Kill Ring
***************
*** 796,801 ****
--- 892,898 ----
only when text is examined.
* Clickable Text:: Using text properties to make regions of text
do something when you click on them.
+ * Links and Mouse-1:: How to make @key{Mouse-1} follow a link.
* Fields:: The @code{field} property defines
fields within the buffer.
* Not Intervals:: Why text properties do not use
***************
*** 824,848 ****
* 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
--- 921,951 ----
* String Search:: Search for an exact match.
* Regular Expressions:: Describing classes of strings.
* Regexp Search:: Searching for a match for a regexp.
+ * POSIX Regexps:: Searching POSIX-style for the longest match.
+ * Search and Replace:: Internals of @code{query-replace}.
* Match Data:: Finding out which part of the text matched
various parts of a regexp, after regexp search.
* Searching and Case:: Case-independent or case-significant searching.
+ * Standard Regexps:: Useful regexps for finding sentences, pages,...
Regular Expressions
* Syntax of Regexps:: Rules for writing regular expressions.
* Regexp Example:: Illustrates regular expression syntax.
+ * Regexp Functions:: Functions for operating on regular expressions.
Syntax Tables
+ * Syntax Basics:: Basic concepts of syntax tables.
* Syntax Descriptors:: How characters are classified.
* Syntax Table Functions:: How to create, examine and alter syntax tables.
+ * Syntax Properties:: Overriding syntax with text properties.
+ * Motion and Syntax:: Moving over characters with certain syntaxes.
* 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.
+ * Categories:: Another way of classifying character syntax.
Syntax Descriptors
***************
*** 852,866 ****
Abbrevs And Abbrev Expansion
* Abbrev Mode:: Setting up Emacs 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.
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.
--- 955,970 ----
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.
Processes
* Subprocess Creation:: Functions that start subprocesses.
+ * Shell Arguments:: Quoting an argument to pass it to a shell.
* Synchronous Processes:: Details of using synchronous subprocesses.
* Asynchronous Processes:: Starting up an asynchronous subprocess.
* Deleting Processes:: Eliminating an asynchronous subprocess.
***************
*** 870,876 ****
--- 974,986 ----
an asynchronous subprocess.
* Output from Processes:: Collecting output from an asynchronous subprocess.
* Sentinels:: Sentinels run when process run-status changes.
+ * Query Before Exit:: Whether to query if exiting will kill a process.
+ * Transaction Queues:: Transaction-based communication with subprocesses.
* Network:: Opening network connections.
+ * Network Servers:: Network servers let Emacs accept net connections.
+ * Datagrams:: UDP network connections.
+ * Low-Level Network:: Lower-level but more general function
+ to create connections and servers.
Receiving Output from Processes
***************
*** 879,892 ****
--- 989,1041 ----
* Decoding Output:: Filters can get unibyte or multibyte strings.
* Accepting Output:: How to wait until process output arrives.
+ Emacs Display
+
+ * Refresh Screen:: Clearing the screen and redrawing everything on
it.
+ * Forcing Redisplay:: Forcing redisplay.
+ * Truncation:: Folding or wrapping long text lines.
+ * The Echo Area:: Where messages are displayed.
+ * Warnings:: Displaying warning messages for the user.
+ * Progress:: Informing user about progress of a long operation.
+ * Invisible Text:: Hiding part of the buffer text.
+ * Selective Display:: Hiding part of the buffer text.
+ * Temporary Displays:: Displays that go away automatically.
+ * Overlays:: Use overlays to highlight parts of the buffer.
+ * Width:: How wide a character or string is on the screen.
+ * Line Height:: Controlling the height of lines.
+ * Faces:: A face defines a graphics style
+ for text characters: font, colors, etc.
+ * Fringes:: Controlling window fringes.
+ * Scroll Bars:: Controlling vertical scroll bars.
+ * Pointer Shape:: Controlling the mouse pointer shape.
+ * Display Property:: Enabling special display features.
+ * Images:: Displaying images in Emacs buffers.
+ * Buttons:: Adding clickable buttons to Emacs buffers.
+ * Blinking:: How Emacs shows the matching open parenthesis.
+ * Inverse Video:: Specifying how the screen looks.
+ * Usual Display:: The usual conventions for displaying nonprinting
chars.
+ * Display Tables:: How to specify other conventions.
+ * Beeping:: Audible signal to the user.
+ * Window Systems:: Which window system is being used.
+
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.
+ * User Identification:: Finding the name and user id of the user.
+ * Time of Day:: Getting the current time.
+ * Time Conversion:: Converting a time from numeric form to a string,
or
+ to calendrical data (or vice versa).
+ * Processor Run Time:: Getting the run time used by Emacs.
+ * Time Calculations:: Adding, subtracting, comparing times, etc.
+ * Timers:: Setting a timer to call a function at a certain
time.
* Terminal Input:: Recording terminal input for debugging.
* Terminal Output:: Recording terminal output for debugging.
+ * Sound Output:: Playing sounds on the computer's speaker.
+ * X11 Keysyms:: Operating on key symbols for X Windows
* Batch Mode:: Running Emacs without terminal interaction.
+ * Session Management:: Saving and restoring state with X Session
Management.
Starting Up Emacs
***************
*** 901,936 ****
* Killing Emacs:: Exiting Emacs irreversibly.
* Suspending Emacs:: Exiting Emacs reversibly.
! Emacs Display
! * Refresh Screen:: Clearing the screen and redrawing everything on
it.
! * Truncation:: Folding or wrapping long text lines.
! * The Echo Area:: Where messages are displayed.
! * Warnings:: Displaying warning messages for the user.
! * Selective Display:: Hiding part of the buffer text.
! * Overlay Arrow:: Display of an arrow to indicate position.
! * Temporary Displays:: Displays that go away automatically.
! * Overlays:: Use overlays to highlight parts of the buffer.
! * Width:: How wide a character or string is on the screen.
! * Faces:: A face defines a graphics style
! for text characters: font, colors, etc.
! * Fringes:: Controlling window fringes.
! * Display Property:: Enabling special display features.
! * Images:: Displaying images in Emacs buffers.
! * Blinking:: How Emacs shows the matching open parenthesis.
! * Inverse Video:: Specifying how the screen looks.
! * Usual Display:: The usual conventions for displaying nonprinting
chars.
! * Display Tables:: How to specify other conventions.
! * Beeping:: 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.
Object Internals
--- 1050,1071 ----
* Killing Emacs:: Exiting Emacs irreversibly.
* Suspending Emacs:: Exiting Emacs reversibly.
! 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.
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.
! * Memory Usage:: Info about total size of Lisp objects made so far.
* Writing Emacs Primitives:: Writing C code for Emacs.
+ * Object Internals:: Data formats of buffers, windows, processes.
Object Internals