Mercurial > hg > xemacs-beta
annotate man/lispref/lispref.texi @ 5888:a85efdabe237
Call #'read-passwd when requesting a password from the user, tls.c
src/ChangeLog addition:
2015-04-09 Aidan Kehoe <kehoea@parhasard.net>
* tls.c (nss_pk11_password):
* tls.c (gnutls_pk11_password):
* tls.c (openssl_password):
* tls.c (syms_of_tls):
Our read-a-password function is #'read-passwd, not
#'read-password, correct that in this file.
| author | Aidan Kehoe <kehoea@parhasard.net> |
|---|---|
| date | Thu, 09 Apr 2015 14:54:37 +0100 |
| parents | 9fae6227ede5 |
| children |
| rev | line source |
|---|---|
| 428 | 1 \input texinfo @c -*-texinfo-*- |
| 2 @c %**start of header | |
| 3 @setfilename ../../info/lispref.info | |
| 4 @c @smallbook | |
| 5 @settitle XEmacs Lisp Reference Manual | |
| 6 @c %**end of header | |
| 7 | |
| 8 @ifinfo | |
| 9 @dircategory XEmacs Editor | |
| 10 @direntry | |
| 11 * Lispref: (lispref). XEmacs Lisp Reference Manual. | |
| 12 @end direntry | |
| 13 | |
| 14 Edition History: | |
| 15 | |
| 16 GNU Emacs Lisp Reference Manual Second Edition (v2.01), May 1993 | |
| 17 GNU Emacs Lisp Reference Manual Further Revised (v2.02), August 1993 | |
| 18 Lucid Emacs Lisp Reference Manual (for 19.10) First Edition, March 1994 | |
| 19 XEmacs Lisp Programmer's Manual (for 19.12) Second Edition, April 1995 | |
| 20 GNU Emacs Lisp Reference Manual v2.4, June 1995 | |
| 21 XEmacs Lisp Programmer's Manual (for 19.13) Third Edition, July 1995 | |
| 22 XEmacs Lisp Reference Manual (for 19.14 and 20.0) v3.1, March 1996 | |
| 23 XEmacs Lisp Reference Manual (for 19.15 and 20.1, 20.2, 20.3) v3.2, April, May, November 1997 | |
| 24 XEmacs Lisp Reference Manual (for 21.0) v3.3, April 1998 | |
| 25 @c Please REMEMBER to update edition number in *four* places in this file | |
| 26 @c and also in *one* place in intro.texi | |
| 27 | |
| 28 Copyright (C) 1990, 1991, 1992, 1993, 1994, 1995 Free Software Foundation, Inc. | |
| 29 Copyright (C) 1994, 1995 Sun Microsystems, Inc. | |
| 30 Copyright (C) 1995, 1996 Ben Wing. | |
| 31 | |
| 32 | |
| 33 Permission is granted to make and distribute verbatim copies of this | |
| 34 manual provided the copyright notice and this permission notice are | |
| 35 preserved on all copies. | |
| 36 | |
| 37 @ignore | |
| 38 Permission is granted to process this file through TeX and print the | |
| 39 results, provided the printed document carries copying permission notice | |
| 40 identical to this one except for the removal of this paragraph (this | |
| 41 paragraph not being relevant to the printed manual). | |
| 42 | |
| 43 @end ignore | |
| 44 Permission is granted to copy and distribute modified versions of this | |
| 45 manual under the conditions for verbatim copying, provided that the | |
| 46 entire resulting derived work is distributed under the terms of a | |
| 47 permission notice identical to this one. | |
| 48 | |
| 49 Permission is granted to copy and distribute translations of this manual | |
| 50 into another language, under the above conditions for modified versions, | |
| 51 except that this permission notice may be stated in a translation | |
| 52 approved by the Foundation. | |
| 53 | |
| 54 Permission is granted to copy and distribute modified versions of this | |
| 55 manual under the conditions for verbatim copying, provided also that the | |
| 56 section entitled ``GNU General Public License'' is included exactly as | |
| 57 in the original, and provided that the entire resulting derived work is | |
| 58 distributed under the terms of a permission notice identical to this | |
| 59 one. | |
| 60 | |
| 61 Permission is granted to copy and distribute translations of this manual | |
| 62 into another language, under the above conditions for modified versions, | |
| 63 except that the section entitled ``GNU General Public License'' may be | |
| 64 included in a translation approved by the Free Software Foundation | |
| 65 instead of in the original English. | |
| 66 @end ifinfo | |
| 67 | |
| 68 @c Combine indices. | |
| 69 @synindex cp fn | |
| 70 @syncodeindex vr fn | |
| 71 @syncodeindex ky fn | |
| 72 @syncodeindex pg fn | |
| 73 @syncodeindex tp fn | |
| 74 | |
| 75 @setchapternewpage odd | |
| 76 @finalout | |
| 77 | |
| 78 @titlepage | |
| 79 @title XEmacs Lisp Reference Manual | |
| 80 @c The edition number appears in several places in this file | |
| 81 @c and also in the file intro.texi. | |
| 82 @c This manual documents XEmacs 19.14 and 20.0 and was based on the | |
| 83 @c documentation for FSF Emacs 19.29 (v2.4). | |
| 84 @subtitle Version 3.3 (for XEmacs 21.0), April 1998 | |
| 85 | |
| 86 @author by Ben Wing | |
|
5791
9fae6227ede5
Silence texinfo 5.2 warnings, primarily by adding next, prev, and up
Jerry James <james@xemacs.org>
parents:
4905
diff
changeset
|
87 @vskip 12pt |
| 428 | 88 @author Based on the GNU Emacs Lisp Reference Manual |
| 89 @author by Bil Lewis, Dan LaLiberte, Richard Stallman | |
| 90 @author and the GNU Manual Group | |
| 91 @page | |
| 92 @vskip 0pt plus 1filll | |
| 93 Copyright @copyright{} 1990, 1991, 1992, 1993, 1994, 1995 Free Software Foundation, Inc. | |
| 94 Copyright @copyright{} 1994, 1995 Sun Microsystems, Inc. | |
| 95 Copyright @copyright{} 1995, 1996 Ben Wing. | |
| 96 @sp 2 | |
| 97 Version 3.3 @* | |
| 98 Revised for XEmacs Versions 21.0,@* | |
| 99 April 1998.@* | |
| 100 | |
| 101 Permission is granted to make and distribute verbatim copies of this | |
| 102 manual provided the copyright notice and this permission notice are | |
| 103 preserved on all copies. | |
| 104 | |
| 105 Permission is granted to copy and distribute modified versions of this | |
| 106 manual under the conditions for verbatim copying, provided also that the | |
| 107 section entitled ``GNU General Public License'' is included | |
| 108 exactly as in the original, and provided that the entire resulting | |
| 109 derived work is distributed under the terms of a permission notice | |
| 110 identical to this one. | |
| 111 | |
| 112 Permission is granted to copy and distribute translations of this manual | |
| 113 into another language, under the above conditions for modified versions, | |
| 114 except that the section entitled ``GNU General Public License'' may be | |
| 115 included in a translation approved by the Free Software Foundation | |
| 116 instead of in the original English. | |
| 117 | |
| 118 Cover art by Etienne Suvasa. | |
| 119 @end titlepage | |
| 120 @page | |
| 121 | |
| 122 @node Top, Copying, (dir), (dir) | |
| 123 | |
| 124 @ifinfo | |
| 125 This Info file contains the third edition of the XEmacs Lisp | |
| 126 Reference Manual, corresponding to XEmacs version 21.0. | |
| 127 @end ifinfo | |
| 128 | |
| 129 @menu | |
| 130 * Copying:: Conditions for copying and changing XEmacs. | |
| 131 * Introduction:: Introduction and conventions used. | |
| 132 | |
| 693 | 133 * Packaging:: Lisp library administrative infrastructure. |
| 134 | |
| 428 | 135 * Lisp Data Types:: Data types of objects in XEmacs Lisp. |
| 136 * Numbers:: Numbers and arithmetic functions. | |
| 137 * Strings and Characters:: Strings, and functions that work on them. | |
| 138 * Lists:: Lists, cons cells, and related functions. | |
| 139 * Sequences Arrays Vectors:: Lists, strings and vectors are called sequences. | |
| 140 Certain functions act on any kind of sequence. | |
| 141 The description of vectors is here as well. | |
| 142 * Symbols:: Symbols represent names, uniquely. | |
| 143 | |
| 144 * Evaluation:: How Lisp expressions are evaluated. | |
| 145 * Control Structures:: Conditionals, loops, nonlocal exits. | |
| 146 * Variables:: Using symbols in programs to stand for values. | |
| 2492 | 147 |
| 148 * Functions and Commands:: A function is a Lisp program that can be | |
| 149 invoked from other functions. | |
| 150 | |
| 428 | 151 * Macros:: Macros are a way to extend the Lisp language. |
| 152 * Customization:: Writing customization declarations. | |
| 153 | |
| 154 * Loading:: Reading files of Lisp code into Lisp. | |
| 155 * Byte Compilation:: Compilation makes programs run faster. | |
| 156 * Debugging:: Tools and tips for debugging Lisp programs. | |
| 157 | |
| 158 * Read and Print:: Converting Lisp objects to text and back. | |
| 159 * Minibuffers:: Using the minibuffer to read input. | |
| 160 * Command Loop:: How the editor command loop works, | |
| 161 and how you can call its subroutines. | |
| 162 * Keymaps:: Defining the bindings from keys to commands. | |
| 163 * Menus:: Defining pull-down and pop-up menus. | |
| 164 * Dialog Boxes:: Creating dialog boxes. | |
| 165 * Toolbar:: Controlling the toolbar. | |
| 442 | 166 * Gutter:: Controlling the gutter. |
| 428 | 167 * Scrollbars:: Controlling the scrollbars. |
| 168 * Drag and Drop:: Generic API to inter-application communication | |
| 169 via specific protocols. | |
| 170 * Modes:: Defining major and minor modes. | |
| 171 * Documentation:: Writing and using documentation strings. | |
| 172 | |
| 173 * Files:: Accessing files. | |
| 174 * Backups and Auto-Saving:: Controlling how backups and auto-save | |
| 175 files are made. | |
| 176 * Buffers:: Creating and using buffer objects. | |
| 177 * Windows:: Manipulating windows and displaying buffers. | |
| 178 * Frames:: Making multiple X windows. | |
| 179 * Consoles and Devices:: Opening frames on multiple TTY's or X displays. | |
| 180 * Positions:: Buffer positions and motion functions. | |
| 181 * Markers:: Markers represent positions and update | |
| 182 automatically when the text is changed. | |
| 183 | |
| 184 * Text:: Examining and changing text in buffers. | |
| 185 * Searching and Matching:: Searching buffers for strings or regexps. | |
| 186 * Syntax Tables:: The syntax table controls word and list parsing. | |
| 187 * Abbrevs:: How Abbrev mode works, and its data structures. | |
| 188 | |
| 189 * Extents:: Extents are regions of text with particular | |
| 190 display characteristics. | |
| 191 * Specifiers:: How faces and glyphs are specified. | |
| 192 * Faces and Window-System Objects:: | |
| 193 A face is a set of display characteristics | |
| 194 specifying how text is to be displayed. | |
| 195 * Glyphs:: General interface to pixmaps displayed in a | |
| 196 buffer or frame. | |
| 197 * Annotations:: Higher-level interface to glyphs in a buffer. | |
| 198 * Display:: Parameters controlling screen usage. | |
| 199 The bell. Waiting for input. | |
| 200 | |
| 201 * Hash Tables:: Fast data structures for mappings. | |
| 202 * Range Tables:: Keeping track of ranges of numbers. | |
| 203 * Databases:: An interface to standard DBM and DB databases. | |
| 204 | |
| 205 * Processes:: Running and communicating with subprocesses. | |
| 206 * System Interface:: Getting the user id, system type, environment | |
| 207 variables, and other such things. | |
| 208 * X-Windows:: Functions specific to the X Window System. | |
| 209 * ToolTalk Support:: Interfacing with the ToolTalk message service. | |
| 210 * LDAP Support:: Interfacing with the Lightweight Directory | |
| 211 Access Protocol. | |
| 442 | 212 * PostgreSQL Support:: Interfacing to the PostgreSQL libpq library. |
| 428 | 213 * Internationalization:: How Emacs supports different languages and |
| 214 cultural conventions. | |
| 215 * MULE:: Specifics of the Asian-language support. | |
| 216 | |
| 217 Appendices | |
| 218 | |
| 219 * Tips:: Advice for writing Lisp programs. | |
| 220 * Building XEmacs and Object Allocation:: | |
| 221 Behind-the-scenes information about XEmacs. | |
| 222 * Standard Errors:: List of all error symbols. | |
| 223 * Standard Buffer-Local Variables:: List of variables local in all buffers. | |
| 224 * Standard Keymaps:: List of standard keymaps. | |
| 225 * Standard Hooks:: List of standard hook variables. | |
| 226 | |
| 227 * Index:: Index including concepts, functions, variables, | |
| 228 and other terms. | |
| 229 | |
| 230 --- The Detailed Node Listing --- | |
| 231 | |
| 232 Here are other nodes that are inferiors of those already listed, | |
| 233 mentioned here so you can get to them in one step: | |
| 234 | |
| 235 Introduction | |
| 236 | |
| 237 * Caveats:: Flaws and a request for help. | |
| 238 * Lisp History:: XEmacs Lisp is descended from Maclisp. | |
| 239 * Conventions:: How the manual is formatted. | |
| 240 * Acknowledgements:: The authors, editors, and sponsors of this manual. | |
| 241 | |
| 242 Conventions | |
| 243 | |
| 244 * Some Terms:: Explanation of terms we use in this manual. | |
| 245 * nil and t:: How the symbols @code{nil} and @code{t} are used. | |
| 246 * Evaluation Notation:: The format we use for examples of evaluation. | |
| 247 * Printing Notation:: The format we use for examples that print output. | |
| 248 * Error Messages:: The format we use for examples of errors. | |
| 249 * Buffer Text Notation:: The format we use for buffer contents in examples. | |
| 250 * Format of Descriptions:: Notation for describing functions, variables, etc. | |
| 251 | |
| 252 Format of Descriptions | |
| 253 | |
| 444 | 254 * A Sample Function Description:: |
| 255 * A Sample Variable Description:: | |
| 428 | 256 |
| 693 | 257 Packaging |
| 258 | |
| 259 * Package Overview:: Lisp Libraries and Packages. | |
| 260 * Package Terminology:: Basic stuff. | |
| 261 * Building Packages:: Turn packaged source into a tarball. | |
| 262 * Local.rules File:: Tell the XEmacs Packaging System about your host. | |
| 263 * Creating Packages:: Tell the XEmacs Packaging System about your package. | |
| 264 * Issues:: | |
| 265 | |
| 266 Package Overview | |
| 267 | |
| 761 | 268 * The User View:: |
| 269 * The Library Maintainer View:: | |
| 270 * The Package Release Engineer View:: | |
| 693 | 271 |
| 272 The Library Maintainer's View | |
| 273 | |
| 274 * Infrastructure:: Global Makefiles and common rules. | |
| 275 * Control Files:: Package-specific Makefiles and administrative files. | |
| 276 * Obtaining:: Obtaining the XEmacs Packaging System and utilities. | |
| 277 | |
| 278 Creating Packages | |
| 279 | |
| 1648 | 280 * package-info.in:: package-info.in |
| 281 * Makefile:: @file{Makefile} | |
| 693 | 282 * Makefile Targets:: |
| 283 | |
| 428 | 284 Lisp Data Types |
| 285 | |
| 286 * Printed Representation:: How Lisp objects are represented as text. | |
| 287 * Comments:: Comments and their formatting conventions. | |
| 288 * Programming Types:: Types found in all Lisp systems. | |
| 289 * Editing Types:: Types specific to XEmacs. | |
| 290 * Type Predicates:: Tests related to types. | |
| 291 * Equality Predicates:: Tests of equality between any two objects. | |
| 292 | |
| 293 Programming Types | |
| 294 | |
| 295 * Integer Type:: Numbers without fractional parts. | |
| 296 * Floating Point Type:: Numbers with fractional parts and with a large range. | |
| 297 * Character Type:: The representation of letters, numbers and | |
| 298 control characters. | |
| 299 * Sequence Type:: Both lists and arrays are classified as sequences. | |
| 300 * Cons Cell Type:: Cons cells, and lists (which are made from cons cells). | |
| 301 * Array Type:: Arrays include strings and vectors. | |
| 302 * String Type:: An (efficient) array of characters. | |
| 303 * Vector Type:: One-dimensional arrays. | |
| 304 * Symbol Type:: A multi-use object that refers to a function, | |
| 305 variable, property list, or itself. | |
| 306 * Function Type:: A piece of executable code you can call from elsewhere. | |
| 307 * Macro Type:: A method of expanding an expression into another | |
| 308 expression, more fundamental but less pretty. | |
| 309 * Primitive Function Type:: A function written in C, callable from Lisp. | |
| 310 * Compiled-Function Type:: A function written in Lisp, then compiled. | |
| 311 * Autoload Type:: A type used for automatically loading seldom-used | |
| 312 functions. | |
| 313 | |
| 314 Cons Cell Type | |
| 315 | |
| 316 * Dotted Pair Notation:: An alternative syntax for lists. | |
| 317 * Association List Type:: A specially constructed list. | |
| 318 | |
| 319 Editing Types | |
| 320 | |
| 321 * Buffer Type:: The basic object of editing. | |
| 322 * Window Type:: What makes buffers visible. | |
| 440 | 323 * Window Configuration Type:: Save what the screen looks like. |
| 428 | 324 * Marker Type:: A position in a buffer. |
| 325 * Process Type:: A process running on the underlying OS. | |
| 326 * Stream Type:: Receive or send characters. | |
| 327 * Keymap Type:: What function a keystroke invokes. | |
| 328 * Syntax Table Type:: What a character means. | |
| 329 | |
| 330 Numbers | |
| 331 | |
| 332 * Integer Basics:: Representation and range of integers. | |
| 2028 | 333 * Ratio Basics:: Representation and range of rational numbers. |
| 428 | 334 * Float Basics:: Representation and range of floating point. |
| 2028 | 335 * The Bignum Extension:: Arbitrary precision integers, ratios, and floats. |
| 428 | 336 * Predicates on Numbers:: Testing for numbers. |
| 337 * Comparison of Numbers:: Equality and inequality predicates. | |
| 338 * Arithmetic Operations:: How to add, subtract, multiply and divide. | |
| 339 * Bitwise Operations:: Logical and, or, not, shifting. | |
| 340 * Numeric Conversions:: Converting float to integer and vice versa. | |
| 341 * Math Functions:: Trig, exponential and logarithmic functions. | |
| 342 * Random Numbers:: Obtaining random integers, predictable or not. | |
| 343 | |
| 344 Strings and Characters | |
| 345 | |
| 440 | 346 * String Basics:: Basic properties of strings and characters. |
| 428 | 347 * Predicates for Strings:: Testing whether an object is a string or char. |
| 348 * Creating Strings:: Functions to allocate new strings. | |
| 349 * Predicates for Characters:: Testing whether an object is a character. | |
| 350 * Character Codes:: Each character has an equivalent integer. | |
| 351 * Text Comparison:: Comparing characters or strings. | |
| 352 * String Conversion:: Converting characters or strings and vice versa. | |
| 353 * Modifying Strings:: Changing characters in a string. | |
| 354 * String Properties:: Additional information attached to strings. | |
| 355 * Formatting Strings:: @code{format}: XEmacs's analog of @code{printf}. | |
| 356 * Character Case:: Case conversion functions. | |
| 357 * Char Tables:: Mapping from characters to Lisp objects. | |
| 358 * Case Tables:: Customizing case conversion. | |
| 359 | |
| 360 Lists | |
| 361 | |
| 362 * Cons Cells:: How lists are made out of cons cells. | |
| 363 * Lists as Boxes:: Graphical notation to explain lists. | |
| 364 * List-related Predicates:: Is this object a list? Comparing two lists. | |
| 365 * List Elements:: Extracting the pieces of a list. | |
| 366 * Building Lists:: Creating list structure. | |
| 367 * Modifying Lists:: Storing new pieces into an existing list. | |
| 368 * Sets And Lists:: A list can represent a finite mathematical set. | |
| 369 * Association Lists:: A list can represent a finite relation or mapping. | |
| 370 * Property Lists:: A different way to represent a finite mapping. | |
| 371 * Weak Lists:: A list with special garbage-collection behavior. | |
| 372 | |
| 373 Modifying Existing List Structure | |
| 374 | |
| 375 * Setcar:: Replacing an element in a list. | |
| 376 * Setcdr:: Replacing part of the list backbone. | |
| 377 This can be used to remove or add elements. | |
| 378 * Rearrangement:: Reordering the elements in a list; combining lists. | |
| 379 | |
| 380 Sequences, Arrays, and Vectors | |
| 381 | |
| 382 * Sequence Functions:: Functions that accept any kind of sequence. | |
| 383 * Arrays:: Characteristics of arrays in XEmacs Lisp. | |
| 384 * Array Functions:: Functions specifically for arrays. | |
| 385 * Vectors:: Functions specifically for vectors. | |
| 386 | |
| 387 Symbols | |
| 388 | |
| 389 * Symbol Components:: Symbols have names, values, function definitions | |
| 390 and property lists. | |
| 391 * Definitions:: A definition says how a symbol will be used. | |
| 392 * Creating Symbols:: How symbols are kept unique. | |
| 393 * Symbol Properties:: Each symbol has a property list | |
| 394 for recording miscellaneous information. | |
| 395 | |
| 396 Evaluation | |
| 397 | |
| 398 * Intro Eval:: Evaluation in the scheme of things. | |
| 399 * Eval:: How to invoke the Lisp interpreter explicitly. | |
| 400 * Forms:: How various sorts of objects are evaluated. | |
| 444 | 401 * Quoting:: Avoiding evaluation (to put constants in |
| 428 | 402 the program). |
| 403 | |
| 404 Kinds of Forms | |
| 405 | |
| 406 * Self-Evaluating Forms:: Forms that evaluate to themselves. | |
| 407 * Symbol Forms:: Symbols evaluate as variables. | |
| 408 * Classifying Lists:: How to distinguish various sorts of list forms. | |
| 409 * Function Forms:: Forms that call functions. | |
| 410 * Macro Forms:: Forms that call macros. | |
|
4905
755ae5b97edb
Change "special form" to "special operator" in our sources.
Aidan Kehoe <kehoea@parhasard.net>
parents:
2953
diff
changeset
|
411 * Special Operators:: ``Special operators'' are idiosyncratic primitives, |
| 428 | 412 most of them extremely important. |
| 413 * Autoloading:: Functions set up to load files | |
| 414 containing their real definitions. | |
| 415 | |
| 416 Control Structures | |
| 417 | |
| 418 * Sequencing:: Evaluation in textual order. | |
| 419 * Conditionals:: @code{if}, @code{cond}. | |
| 420 * Combining Conditions:: @code{and}, @code{or}, @code{not}. | |
| 421 * Iteration:: @code{while} loops. | |
| 422 * Nonlocal Exits:: Jumping out of a sequence. | |
| 423 | |
| 424 Nonlocal Exits | |
| 425 | |
| 426 * Catch and Throw:: Nonlocal exits for the program's own purposes. | |
| 427 * Examples of Catch:: Showing how such nonlocal exits can be written. | |
| 428 * Errors:: How errors are signaled and handled. | |
| 429 * Cleanups:: Arranging to run a cleanup form if an | |
| 430 error happens. | |
| 431 | |
| 432 Errors | |
| 433 | |
| 434 * Signaling Errors:: How to report an error. | |
| 435 * Processing of Errors:: What XEmacs does when you report an error. | |
| 436 * Handling Errors:: How you can trap errors and continue execution. | |
| 437 * Error Symbols:: How errors are classified for trapping them. | |
| 438 | |
| 439 Variables | |
| 440 | |
| 441 * Global Variables:: Variable values that exist permanently, everywhere. | |
| 442 * Constant Variables:: Certain "variables" have values that never change. | |
| 443 * Local Variables:: Variable values that exist only temporarily. | |
| 444 * Void Variables:: Symbols that lack values. | |
| 445 * Defining Variables:: A definition says a symbol is used as a variable. | |
| 446 * Accessing Variables:: Examining values of variables whose names | |
| 447 are known only at run time. | |
| 448 * Setting Variables:: Storing new values in variables. | |
| 449 * Variable Scoping:: How Lisp chooses among local and global values. | |
| 450 * Buffer-Local Variables:: Variable values in effect only in one buffer. | |
| 451 | |
| 452 Scoping Rules for Variable Bindings | |
| 453 | |
| 444 | 454 * Scope:: Scope means where in the program a value |
| 428 | 455 is visible. Comparison with other languages. |
| 456 * Extent:: Extent means how long in time a value exists. | |
| 457 * Impl of Scope:: Two ways to implement dynamic scoping. | |
| 444 | 458 * Using Scoping:: How to use dynamic scoping carefully and |
| 428 | 459 avoid problems. |
| 460 | |
| 461 Buffer-Local Variables | |
| 462 | |
| 463 * Intro to Buffer-Local:: Introduction and concepts. | |
| 464 * Creating Buffer-Local:: Creating and destroying buffer-local bindings. | |
| 465 * Default Value:: The default value is seen in buffers | |
| 466 that don't have their own local values. | |
| 467 | |
| 468 Functions | |
| 469 | |
| 470 * What Is a Function:: Lisp functions vs primitives; terminology. | |
| 471 * Lambda Expressions:: How functions are expressed as Lisp objects. | |
| 472 * Function Names:: A symbol can serve as the name of a function. | |
| 473 * Defining Functions:: Lisp expressions for defining functions. | |
| 474 * Calling Functions:: How to use an existing function. | |
| 475 * Mapping Functions:: Applying a function to each element of a list, etc. | |
| 444 | 476 * Anonymous Functions:: Lambda-expressions are functions with no names. |
| 428 | 477 * Function Cells:: Accessing or setting the function definition |
| 478 of a symbol. | |
| 479 * Related Topics:: Cross-references to specific Lisp primitives | |
| 444 | 480 that have a special bearing on how |
| 428 | 481 functions work. |
| 482 | |
| 483 Lambda Expressions | |
| 484 | |
| 485 * Lambda Components:: The parts of a lambda expression. | |
| 486 * Simple Lambda:: A simple example. | |
| 487 * Argument List:: Details and special features of argument lists. | |
| 488 * Function Documentation:: How to put documentation in a function. | |
| 489 | |
| 490 Macros | |
| 491 | |
| 492 * Simple Macro:: A basic example. | |
| 493 * Expansion:: How, when and why macros are expanded. | |
| 494 * Compiling Macros:: How macros are expanded by the compiler. | |
| 495 * Defining Macros:: How to write a macro definition. | |
| 496 * Backquote:: Easier construction of list structure. | |
| 497 * Problems with Macros:: Don't evaluate the macro arguments too many times. | |
| 498 Don't hide the user's variables. | |
| 499 | |
| 500 Loading | |
| 501 | |
| 502 * How Programs Do Loading:: The @code{load} function and others. | |
| 503 * Autoload:: Setting up a function to autoload. | |
| 504 * Named Features:: Loading a library if it isn't already loaded. | |
| 505 * Repeated Loading:: Precautions about loading a file twice. | |
| 506 | |
| 507 Byte Compilation | |
| 508 | |
| 446 | 509 * Speed of Byte-Code:: An example of speedup from byte compilation. |
| 510 * Compilation Functions:: Byte compilation functions. | |
| 511 * Docs and Compilation:: Dynamic loading of documentation strings. | |
| 512 * Dynamic Loading:: Dynamic loading of individual functions. | |
| 513 * Eval During Compile:: Code to be evaluated when you compile. | |
| 514 * Compiled-Function Objects:: The data type used for byte-compiled functions. | |
| 515 * Disassembly:: Disassembling byte-code; how to read byte-code. | |
| 516 * Different Behavior:: When compiled code gives different results. | |
| 428 | 517 |
| 518 Debugging Lisp Programs | |
| 519 | |
| 520 * Debugger:: How the XEmacs Lisp debugger is implemented. | |
| 521 * Syntax Errors:: How to find syntax errors. | |
| 444 | 522 * Compilation Errors:: How to find errors that show up in |
| 428 | 523 byte compilation. |
| 524 * Edebug:: A source-level XEmacs Lisp debugger. | |
| 444 | 525 |
| 428 | 526 The Lisp Debugger |
| 527 | |
| 528 * Error Debugging:: Entering the debugger when an error happens. | |
| 529 * Function Debugging:: Entering it when a certain function is called. | |
| 530 * Explicit Debug:: Entering it at a certain point in the program. | |
| 531 * Using Debugger:: What the debugger does; what you see while in it. | |
| 532 * Debugger Commands:: Commands used while in the debugger. | |
| 533 * Invoking the Debugger:: How to call the function @code{debug}. | |
| 534 * Internals of Debugger:: Subroutines of the debugger, and global variables. | |
| 535 | |
| 536 Debugging Invalid Lisp Syntax | |
| 537 | |
| 538 * Excess Open:: How to find a spurious open paren or missing close. | |
| 539 * Excess Close:: How to find a spurious close paren or missing open. | |
| 540 | |
| 541 Reading and Printing Lisp Objects | |
| 542 | |
| 543 * Streams Intro:: Overview of streams, reading and printing. | |
| 444 | 544 * Input Streams:: Various data types that can be used as |
| 428 | 545 input streams. |
| 546 * Input Functions:: Functions to read Lisp objects from text. | |
| 444 | 547 * Output Streams:: Various data types that can be used as |
| 428 | 548 output streams. |
| 549 * Output Functions:: Functions to print Lisp objects as text. | |
| 550 | |
| 551 Minibuffers | |
| 552 | |
| 553 * Intro to Minibuffers:: Basic information about minibuffers. | |
| 554 * Text from Minibuffer:: How to read a straight text string. | |
| 555 * Object from Minibuffer:: How to read a Lisp object or expression. | |
| 556 * Completion:: How to invoke and customize completion. | |
| 557 * Yes-or-No Queries:: Asking a question with a simple answer. | |
| 558 * Minibuffer Misc:: Various customization hooks and variables. | |
| 559 | |
| 560 Completion | |
| 561 | |
| 562 * Basic Completion:: Low-level functions for completing strings. | |
| 563 (These are too low level to use the minibuffer.) | |
| 564 * Minibuffer Completion:: Invoking the minibuffer with completion. | |
| 565 * Completion Commands:: Minibuffer commands that do completion. | |
| 566 * High-Level Completion:: Convenient special cases of completion | |
| 567 (reading buffer name, file name, etc.) | |
| 568 * Reading File Names:: Using completion to read file names. | |
| 569 * Programmed Completion:: Finding the completions for a given file name. | |
| 570 | |
| 571 Command Loop | |
| 572 | |
| 573 * Command Overview:: How the command loop reads commands. | |
| 574 * Defining Commands:: Specifying how a function should read arguments. | |
| 575 * Interactive Call:: Calling a command, so that it will read arguments. | |
| 576 * Command Loop Info:: Variables set by the command loop for you to examine. | |
| 577 * Events:: What input looks like when you read it. | |
| 578 * Reading Input:: How to read input events from the keyboard or mouse. | |
| 579 * Waiting:: Waiting for user input or elapsed time. | |
| 580 * Quitting:: How @kbd{C-g} works. How to catch or defer quitting. | |
| 581 * Prefix Command Arguments:: How the commands to set prefix args work. | |
| 582 * Recursive Editing:: Entering a recursive edit, | |
| 583 and why you usually shouldn't. | |
| 584 * Disabling Commands:: How the command loop handles disabled commands. | |
| 585 * Command History:: How the command history is set up, and how accessed. | |
| 586 * Keyboard Macros:: How keyboard macros are implemented. | |
| 587 | |
| 588 Defining Commands | |
| 589 | |
| 590 * Using Interactive:: General rules for @code{interactive}. | |
| 591 * Interactive Codes:: The standard letter-codes for reading arguments | |
| 592 in various ways. | |
| 593 * Interactive Examples:: Examples of how to read interactive arguments. | |
| 594 | |
| 595 Events | |
| 596 | |
| 597 * Event Types:: Events come in different types. | |
| 598 * Event Contents:: What the contents of each event type are. | |
| 599 * Event Predicates:: Querying whether an event is of a | |
| 600 particular type. | |
| 601 * Accessing Mouse Event Positions:: | |
| 602 Determining where a mouse event occurred, | |
| 603 and over what. | |
| 604 * Accessing Other Event Info:: Accessing non-positional event info. | |
| 605 * Working With Events:: Creating, copying, and destroying events. | |
| 606 * Converting Events:: Converting between events, keys, and | |
| 607 characters. | |
| 608 | |
| 609 Accessing Mouse Event Positions | |
| 610 | |
| 611 * Frame-Level Event Position Info:: | |
| 612 * Window-Level Event Position Info:: | |
| 613 * Event Text Position Info:: | |
| 614 * Event Glyph Position Info:: | |
| 615 * Event Toolbar Position Info:: | |
| 616 * Other Event Position Info:: | |
| 617 | |
| 618 Reading Input | |
| 619 | |
| 620 * Key Sequence Input:: How to read one key sequence. | |
| 621 * Reading One Event:: How to read just one event. | |
| 622 * Dispatching an Event:: What to do with an event once it has been read. | |
| 623 * Quoted Character Input:: Asking the user to specify a character. | |
| 624 * Peeking and Discarding:: How to reread or throw away input events. | |
| 625 | |
| 626 Keymaps | |
| 627 | |
| 628 * Keymap Terminology:: Definitions of terms pertaining to keymaps. | |
| 629 * Format of Keymaps:: What a keymap looks like as a Lisp object. | |
| 630 * Creating Keymaps:: Functions to create and copy keymaps. | |
| 631 * Inheritance and Keymaps:: How one keymap can inherit the bindings | |
| 632 of another keymap. | |
| 633 * Key Sequences:: How to specify key sequences. | |
| 634 * Prefix Keys:: Defining a key with a keymap as its definition. | |
| 635 * Active Keymaps:: Each buffer has a local keymap | |
| 636 to override the standard (global) bindings. | |
| 637 Each minor mode can also override them. | |
| 638 * Key Lookup:: How extracting elements from keymaps works. | |
| 639 * Functions for Key Lookup:: How to request key lookup. | |
| 640 * Changing Key Bindings:: Redefining a key in a keymap. | |
| 641 * Key Binding Commands:: Interactive interfaces for redefining keys. | |
| 642 * Scanning Keymaps:: Looking through all keymaps, for printing help. | |
| 643 * Other Keymap Functions:: Miscellaneous keymap functions. | |
| 644 | |
| 645 Menus | |
| 646 | |
| 647 * Menu Format:: Format of a menu description. | |
| 648 * Menubar Format:: How to specify a menubar. | |
| 649 * Menubar:: Functions for controlling the menubar. | |
| 650 * Modifying Menus:: Modifying a menu description. | |
| 651 * Pop-Up Menus:: Functions for specifying pop-up menus. | |
| 652 * Menu Filters:: Filter functions for the default menubar. | |
| 653 * Buffers Menu:: The menu that displays the list of buffers. | |
| 654 | |
| 655 Dialog Boxes | |
| 656 | |
| 657 * Dialog Box Format:: | |
| 658 * Dialog Box Functions:: | |
| 659 | |
| 660 Toolbar | |
| 661 | |
| 662 * Toolbar Intro:: An introduction. | |
| 663 * Toolbar Descriptor Format:: How to create a toolbar. | |
| 664 * Specifying the Toolbar:: Setting a toolbar. | |
| 665 * Other Toolbar Variables:: Controlling the size of toolbars. | |
| 666 | |
| 442 | 667 Gutter |
| 668 | |
| 428 | 669 Scrollbars |
| 670 | |
| 671 Major and Minor Modes | |
| 672 | |
| 673 * Major Modes:: Defining major modes. | |
| 674 * Minor Modes:: Defining minor modes. | |
| 675 * Modeline Format:: Customizing the text that appears in the modeline. | |
| 444 | 676 * Hooks:: How to use hooks; how to write code that |
| 428 | 677 provides hooks. |
| 678 | |
| 679 Major Modes | |
| 680 | |
| 681 * Major Mode Conventions:: Coding conventions for keymaps, etc. | |
| 682 * Example Major Modes:: Text mode and Lisp modes. | |
| 683 * Auto Major Mode:: How XEmacs chooses the major mode automatically. | |
| 684 * Mode Help:: Finding out how to use a mode. | |
| 685 | |
| 686 Minor Modes | |
| 687 | |
| 688 * Minor Mode Conventions:: Tips for writing a minor mode. | |
| 689 * Keymaps and Minor Modes:: How a minor mode can have its own keymap. | |
| 690 | |
| 691 Modeline Format | |
| 692 | |
| 693 * Modeline Data:: The data structure that controls the modeline. | |
| 694 * Modeline Variables:: Variables used in that data structure. | |
| 695 * %-Constructs:: Putting information into a modeline. | |
| 696 | |
| 697 Documentation | |
| 698 | |
| 699 * Documentation Basics:: Good style for doc strings. | |
| 700 Where to put them. How XEmacs stores them. | |
| 701 * Accessing Documentation:: How Lisp programs can access doc strings. | |
| 702 * Keys in Documentation:: Substituting current key bindings. | |
| 703 * Describing Characters:: Making printable descriptions of | |
| 704 non-printing characters and key sequences. | |
| 705 * Help Functions:: Subroutines used by XEmacs help facilities. | |
| 706 | |
| 707 Files | |
| 708 | |
| 709 * Visiting Files:: Reading files into Emacs buffers for editing. | |
| 710 * Saving Buffers:: Writing changed buffers back into files. | |
| 711 * Reading from Files:: Reading files into other buffers. | |
| 712 * Writing to Files:: Writing new files from parts of buffers. | |
| 713 * File Locks:: Locking and unlocking files, to prevent | |
| 714 simultaneous editing by two people. | |
| 715 * Information about Files:: Testing existence, accessibility, size of files. | |
| 716 * Contents of Directories:: Getting a list of the files in a directory. | |
| 717 * Changing File Attributes:: Renaming files, changing protection, etc. | |
| 718 * File Names:: Decomposing and expanding file names. | |
| 719 | |
| 720 Visiting Files | |
| 721 | |
| 722 * Visiting Functions:: The usual interface functions for visiting. | |
| 723 * Subroutines of Visiting:: Lower-level subroutines that they use. | |
| 724 | |
| 725 Information about Files | |
| 726 | |
| 727 * Testing Accessibility:: Is a given file readable? Writable? | |
| 728 * Kinds of Files:: Is it a directory? A link? | |
| 729 * File Attributes:: How large is it? Any other names? Etc. | |
| 730 | |
| 731 File Names | |
| 732 | |
| 733 * File Name Components:: The directory part of a file name, and the rest. | |
| 734 * Directory Names:: A directory's name as a directory | |
| 735 is different from its name as a file. | |
| 444 | 736 * Relative File Names:: Some file names are relative to a |
| 428 | 737 current directory. |
| 738 * File Name Expansion:: Converting relative file names to absolute ones. | |
| 739 * Unique File Names:: Generating names for temporary files. | |
| 740 * File Name Completion:: Finding the completions for a given file name. | |
| 741 | |
| 742 Backups and Auto-Saving | |
| 743 | |
| 444 | 744 * Backup Files:: How backup files are made; how their names |
| 428 | 745 are chosen. |
| 746 * Auto-Saving:: How auto-save files are made; how their | |
| 747 names are chosen. | |
| 444 | 748 * Reverting:: @code{revert-buffer}, and how to customize |
| 428 | 749 what it does. |
| 750 | |
| 751 Backup Files | |
| 752 | |
| 753 * Making Backups:: How XEmacs makes backup files, and when. | |
| 444 | 754 * Rename or Copy:: Two alternatives: renaming the old file |
| 428 | 755 or copying it. |
| 756 * Numbered Backups:: Keeping multiple backups for each source file. | |
| 757 * Backup Names:: How backup file names are computed; customization. | |
| 758 | |
| 759 Buffers | |
| 760 | |
| 761 * Buffer Basics:: What is a buffer? | |
| 762 * Buffer Names:: Accessing and changing buffer names. | |
| 763 * Buffer File Name:: The buffer file name indicates which file | |
| 764 is visited. | |
| 765 * Buffer Modification:: A buffer is @dfn{modified} if it needs to be saved. | |
| 766 * Modification Time:: Determining whether the visited file was changed | |
| 767 ``behind XEmacs's back''. | |
| 768 * Read Only Buffers:: Modifying text is not allowed in a | |
| 769 read-only buffer. | |
| 770 * The Buffer List:: How to look at all the existing buffers. | |
| 771 * Creating Buffers:: Functions that create buffers. | |
| 772 * Killing Buffers:: Buffers exist until explicitly killed. | |
| 773 * Current Buffer:: Designating a buffer as current | |
| 774 so primitives will access its contents. | |
| 775 | |
| 776 Windows | |
| 777 | |
| 778 * Basic Windows:: Basic information on using windows. | |
| 779 * Splitting Windows:: Splitting one window into two windows. | |
| 780 * Deleting Windows:: Deleting a window gives its space to other windows. | |
| 781 * Selecting Windows:: The selected window is the one that you edit in. | |
| 782 * Cyclic Window Ordering:: Moving around the existing windows. | |
| 783 * Buffers and Windows:: Each window displays the contents of a buffer. | |
| 784 * Displaying Buffers:: Higher-lever functions for displaying a buffer | |
| 785 and choosing a window for it. | |
| 786 * Window Point:: Each window has its own location of point. | |
| 787 * Window Start:: The display-start position controls which text | |
| 444 | 788 is on-screen in the window. |
| 428 | 789 * Vertical Scrolling:: Moving text up and down in the window. |
| 790 * Horizontal Scrolling:: Moving text sideways on the window. | |
| 791 * Size of Window:: Accessing the size of a window. | |
| 792 * Resizing Windows:: Changing the size of a window. | |
| 793 * Window Configurations:: Saving and restoring the state of the screen. | |
| 794 | |
| 795 Frames | |
| 796 | |
| 797 * Creating Frames:: Creating additional frames. | |
| 798 * Frame Properties:: Controlling frame size, position, font, etc. | |
| 799 * Frame Titles:: Automatic updating of frame titles. | |
| 800 * Deleting Frames:: Frames last until explicitly deleted. | |
| 801 * Finding All Frames:: How to examine all existing frames. | |
| 802 * Frames and Windows:: A frame contains windows; | |
| 803 display of text always works through windows. | |
| 804 * Minibuffers and Frames:: How a frame finds the minibuffer to use. | |
| 805 * Input Focus:: Specifying the selected frame. | |
| 806 * Visibility of Frames:: Frames may be visible or invisible, or icons. | |
| 807 * Raising and Lowering:: Raising a frame makes it hide other X windows; | |
| 808 lowering it makes the others hide them. | |
| 809 * Frame Hooks:: Hooks for customizing frame behavior. | |
| 810 | |
| 811 Positions | |
| 812 | |
| 813 * Point:: The special position where editing takes place. | |
| 814 * Motion:: Changing point. | |
| 815 * Excursions:: Temporary motion and buffer changes. | |
| 816 * Narrowing:: Restricting editing to a portion of the buffer. | |
| 817 | |
| 818 Motion | |
| 819 | |
| 820 * Character Motion:: Moving in terms of characters. | |
| 821 * Word Motion:: Moving in terms of words. | |
| 822 * Buffer End Motion:: Moving to the beginning or end of the buffer. | |
| 823 * Text Lines:: Moving in terms of lines of text. | |
| 824 * Screen Lines:: Moving in terms of lines as displayed. | |
| 825 * List Motion:: Moving by parsing lists and sexps. | |
| 826 * Skipping Characters:: Skipping characters belonging to a certain set. | |
| 827 | |
| 828 Markers | |
| 829 | |
| 830 * Overview of Markers:: The components of a marker, and how it relocates. | |
| 831 * Predicates on Markers:: Testing whether an object is a marker. | |
| 832 * Creating Markers:: Making empty markers or markers at certain places. | |
| 833 * Information from Markers:: Finding the marker's buffer or character | |
| 444 | 834 position. |
| 428 | 835 * Changing Markers:: Moving the marker to a new buffer or position. |
| 836 * The Mark:: How ``the mark'' is implemented with a marker. | |
| 837 * The Region:: How to access ``the region''. | |
| 838 | |
| 839 Text | |
| 840 | |
| 841 * Near Point:: Examining text in the vicinity of point. | |
| 842 * Buffer Contents:: Examining text in a general fashion. | |
| 843 * Comparing Text:: Comparing substrings of buffers. | |
| 844 * Insertion:: Adding new text to a buffer. | |
| 845 * Commands for Insertion:: User-level commands to insert text. | |
| 846 * Deletion:: Removing text from a buffer. | |
| 847 * User-Level Deletion:: User-level commands to delete text. | |
| 848 * The Kill Ring:: Where removed text sometimes is saved for later use. | |
| 849 * Undo:: Undoing changes to the text of a buffer. | |
| 850 * Maintaining Undo:: How to enable and disable undo information. | |
| 851 How to control how much information is kept. | |
| 852 * Filling:: Functions for explicit filling. | |
| 853 * Margins:: How to specify margins for filling commands. | |
| 854 * Auto Filling:: How auto-fill mode is implemented to break lines. | |
| 855 * Sorting:: Functions for sorting parts of the buffer. | |
| 856 * Columns:: Computing horizontal positions, and using them. | |
| 857 * Indentation:: Functions to insert or adjust indentation. | |
| 858 * Case Changes:: Case conversion of parts of the buffer. | |
| 859 * Text Properties:: Assigning Lisp property lists to text characters. | |
| 860 * Substitution:: Replacing a given character wherever it appears. | |
| 861 * Registers:: How registers are implemented. Accessing the text or | |
| 862 position stored in a register. | |
| 863 * Transposition:: Swapping two portions of a buffer. | |
| 864 * Change Hooks:: Supplying functions to be run when text is changed. | |
| 444 | 865 |
| 428 | 866 The Kill Ring |
| 867 | |
| 868 * Kill Ring Concepts:: What text looks like in the kill ring. | |
| 869 * Kill Functions:: Functions that kill text. | |
| 870 * Yank Commands:: Commands that access the kill ring. | |
| 871 * Low-Level Kill Ring:: Functions and variables for kill ring access. | |
| 872 * Internals of Kill Ring:: Variables that hold kill-ring data. | |
| 873 | |
| 874 Indentation | |
| 875 | |
| 876 * Primitive Indent:: Functions used to count and insert indentation. | |
| 877 * Mode-Specific Indent:: Customize indentation for different modes. | |
| 878 * Region Indent:: Indent all the lines in a region. | |
| 879 * Relative Indent:: Indent the current line based on previous lines. | |
| 880 * Indent Tabs:: Adjustable, typewriter-like tab stops. | |
| 881 * Motion by Indent:: Move to first non-blank character. | |
| 882 | |
| 883 Searching and Matching | |
| 884 | |
| 885 * String Search:: Search for an exact match. | |
| 886 * Regular Expressions:: Describing classes of strings. | |
| 887 * Regexp Search:: Searching for a match for a regexp. | |
| 888 * Match Data:: Finding out which part of the text matched | |
| 889 various parts of a regexp, after regexp search. | |
| 890 * Saving Match Data:: Saving and restoring this information. | |
| 891 * Standard Regexps:: Useful regexps for finding sentences, pages,... | |
| 892 * Searching and Case:: Case-independent or case-significant searching. | |
| 893 | |
| 894 Regular Expressions | |
| 895 | |
| 896 * Syntax of Regexps:: Rules for writing regular expressions. | |
| 897 * Regexp Example:: Illustrates regular expression syntax. | |
| 898 | |
| 899 Syntax Tables | |
| 900 | |
| 901 * Syntax Descriptors:: How characters are classified. | |
| 902 * Syntax Table Functions:: How to create, examine and alter syntax tables. | |
| 903 * Parsing Expressions:: Parsing balanced expressions | |
| 904 using the syntax table. | |
| 905 * Standard Syntax Tables:: Syntax tables used by various major modes. | |
| 906 * Syntax Table Internals:: How syntax table information is stored. | |
| 907 | |
| 908 Syntax Descriptors | |
| 909 | |
| 910 * Syntax Class Table:: Table of syntax classes. | |
| 911 * Syntax Flags:: Additional flags each character can have. | |
| 912 | |
| 913 Abbrevs And Abbrev Expansion | |
| 914 | |
| 915 * Abbrev Mode:: Setting up XEmacs for abbreviation. | |
| 916 * Tables: Abbrev Tables. Creating and working with abbrev tables. | |
| 917 * Defining Abbrevs:: Specifying abbreviations and their expansions. | |
| 918 * Files: Abbrev Files. Saving abbrevs in files. | |
| 919 * Expansion: Abbrev Expansion. Controlling expansion; expansion subroutines. | |
| 920 * Standard Abbrev Tables:: Abbrev tables used by various major modes. | |
| 921 | |
| 922 Extents | |
| 923 | |
| 924 * Intro to Extents:: Extents are regions over a buffer or string. | |
| 925 * Creating and Modifying Extents:: | |
| 926 Basic extent functions. | |
| 927 * Extent Endpoints:: Accessing and setting the bounds of an extent. | |
| 928 * Finding Extents:: Determining which extents are in an object. | |
| 929 * Mapping Over Extents:: More sophisticated functions for extent scanning. | |
| 930 * Extent Properties:: Extents have built-in and user-definable properties. | |
| 931 * Detached Extents:: Extents that are not in a buffer. | |
| 932 * Extent Parents:: Inheriting properties from another extent. | |
| 933 * Duplicable Extents:: Extents can be marked to be copied into strings. | |
| 934 * Extents and Events:: Extents can interact with the keyboard and mouse. | |
| 935 * Atomic Extents:: Treating a block of text as a single entity. | |
| 936 | |
| 937 Specifiers | |
| 938 | |
| 939 * Introduction to Specifiers:: Specifiers provide a clean way for | |
| 940 display and other properties to vary | |
| 941 (under user control) in a wide variety | |
| 942 of contexts. | |
| 943 * Specifiers In-Depth:: Gory details about specifier innards. | |
| 2953 | 944 * Specifier Instantiation:: Instantiation means obtaining the ``value'' of |
| 428 | 945 a specifier in a particular context. |
| 946 * Specifier Types:: Specifiers come in different flavors. | |
| 947 * Adding Specifications:: Specifications control a specifier's ``value'' | |
| 948 by giving conditions under which a | |
| 949 particular value is valid. | |
| 950 * Retrieving Specifications:: Querying a specifier's specifications. | |
| 2953 | 951 * Specifier Instantiation Functions:: |
| 952 Functions to instantiate a specifier. | |
| 1869 | 953 * Specifier Examples:: Making all this stuff clearer. |
| 428 | 954 * Creating Specifiers:: Creating specifiers for your own use. |
| 955 * Specifier Validation Functions:: | |
| 956 Validating the components of a specifier. | |
| 957 * Other Specification Functions:: | |
| 958 Other ways of working with specifications. | |
| 959 | |
| 960 Faces and Window-System Objects | |
| 961 | |
| 962 * Faces:: Controlling the way text looks. | |
| 963 * Fonts:: Controlling the typeface of text. | |
| 964 * Colors:: Controlling the color of text and pixmaps. | |
| 965 | |
| 966 Faces | |
| 967 | |
| 968 * Merging Faces:: How XEmacs decides which face to use | |
| 969 for a character. | |
| 970 * Basic Face Functions:: How to define and examine faces. | |
| 971 * Face Properties:: How to access and modify a face's properties. | |
| 972 * Face Convenience Functions:: Convenience functions for accessing | |
| 973 particular properties of a face. | |
| 974 * Other Face Display Functions:: Other functions pertaining to how a | |
| 975 a face appears. | |
| 976 | |
| 977 Fonts | |
| 978 | |
| 979 * Font Specifiers:: Specifying how a font will appear. | |
| 2953 | 980 * Font Instances:: What a font specifier gets instantiated as. |
| 428 | 981 * Font Instance Names:: The name of a font instance. |
| 982 * Font Instance Size:: The size of a font instance. | |
| 983 * Font Instance Characteristics:: Display characteristics of font instances. | |
| 984 * Font Convenience Functions:: Convenience functions that automatically | |
| 2953 | 985 instantiate and retrieve the properties |
| 428 | 986 of a font specifier. |
| 987 | |
| 988 Colors | |
| 989 | |
| 990 * Color Specifiers:: Specifying how a color will appear. | |
| 2953 | 991 * Color Instances:: What a color specifier gets instantiated as. |
| 428 | 992 * Color Instance Properties:: Properties of color instances. |
| 993 * Color Convenience Functions:: Convenience functions that automatically | |
| 2953 | 994 instantiate and retrieve the properties |
| 428 | 995 of a color specifier. |
| 996 | |
| 997 Glyphs | |
| 998 | |
| 2182 | 999 * Glyph Intro:: Glyphs are abstract image specifications. |
| 1000 * Images:: Specifying the appearance of glyphs. | |
| 1001 * Using Glyphs:: Creating and displaying glyphs. | |
| 1002 * Manipulating Glyphs:: Getting and setting glyph properties. | |
| 1003 * Glyph Examples:: Examples of how to work with glyphs. | |
| 428 | 1004 |
| 1005 Images | |
| 1006 | |
| 2953 | 1007 * Image Instantiators:: Specifying an image's appearance. |
| 2182 | 1008 * Image Instantiator Conversion:: Lazy realization of graphics. |
| 1009 * Image Instantiator Formats:: A catalog of image descriptors. | |
| 1010 * Image Instances:: Classes of graphical objects. | |
| 1011 | |
| 1012 Image Instances | |
| 1013 | |
| 2953 | 1014 * Image Instance Types:: Each image instance has a particular type. |
| 428 | 1015 * Image Instance Functions:: Functions for working with image instances. |
| 1016 | |
| 2182 | 1017 Using Glyphs |
| 1018 | |
| 1019 * Creating Glyphs:: Creating new glyphs. | |
| 1020 * Buffer Glyphs:: Annotations are glyphs that appear in a buffer. | |
| 1021 * Redisplay Glyphs:: Glyphs controlling various redisplay functions. | |
| 1022 * Frame Glyphs:: Displaying glyphs in GUI components of the frame. | |
| 1023 * External Glyphs:: Icons and mouse pointers for the window system. | |
| 1024 * Native GUI Widgets:: Complex active elements treated as a single glyph. | |
| 1025 * Subwindows:: Externally-controlled subwindows in buffers. | |
| 1026 | |
| 1027 Native GUI Widgets | |
| 1028 | |
| 1029 * Introduction to Widgets:: Native widgets provide tight integration of | |
| 1030 GUI features with the platform GUI. | |
| 1031 * Lisp API to Native Widgets:: Native widgets are glyphs. | |
| 1032 * Layouts:: Specifying composite widgets from Lisp. | |
| 1033 * Primitive Widgets:: Catalogue of available native widgets. | |
| 1034 | |
| 1035 Manipulating Glyphs | |
| 1036 | |
| 1037 * Glyph Properties:: Accessing and modifying a glyph's properties. | |
| 1038 * Glyph Convenience Functions:: Accessing particular properties of a glyph. | |
| 1039 * Glyph Dimensions:: Determining the height, width, etc. of a glyph. | |
| 1040 * Glyph Types:: Each glyph has a particular type. | |
| 1041 | |
| 428 | 1042 Annotations |
| 1043 | |
| 1044 * Annotation Basics:: Introduction to annotations. | |
| 1045 * Annotation Primitives:: Creating and deleting annotations. | |
| 1046 * Annotation Properties:: Retrieving and changing the characteristics | |
| 1047 of an annotation. | |
| 1048 * Margin Primitives:: Controlling the size of the margins. | |
| 1049 * Locating Annotations:: Looking for annotations in a buffer. | |
| 1050 * Annotation Hooks:: Hooks called at certain times during an | |
| 1051 annotation's lifetime. | |
| 1052 | |
| 1053 Hash Tables | |
| 1054 | |
| 1055 * Introduction to Hash Tables:: Hash tables are fast data structures for | |
| 1056 implementing simple tables (i.e. finite | |
| 1057 mappings from keys to values). | |
| 1058 * Working With Hash Tables:: Hash table functions. | |
| 1059 * Weak Hash Tables:: Hash tables with special garbage-collection | |
| 1060 behavior. | |
| 1061 | |
| 1062 Range Tables | |
| 1063 | |
| 1064 * Introduction to Range Tables:: Range tables efficiently map ranges of | |
| 1065 integers to values. | |
| 1066 * Working With Range Tables:: Range table functions. | |
| 1067 | |
| 1068 | |
| 1069 XEmacs Display | |
| 1070 | |
| 1071 * Refresh Screen:: Clearing the screen and redrawing everything on it. | |
| 1072 * Truncation:: Folding or wrapping long text lines. | |
| 1073 * The Echo Area:: Where messages are displayed. | |
| 1074 * Selective Display:: Hiding part of the buffer text. | |
| 1075 * Overlay Arrow:: Display of an arrow to indicate position. | |
| 1076 * Temporary Displays:: Displays that go away automatically. | |
| 1077 * Blinking:: How XEmacs shows the matching open parenthesis. | |
| 1078 * Usual Display:: The usual conventions for displaying nonprinting chars. | |
| 1079 * Display Tables:: How to specify other conventions. | |
| 1080 * Beeping:: Audible signal to the user. | |
| 1081 | |
| 1082 Processes | |
| 1083 | |
| 1084 * Subprocess Creation:: Functions that start subprocesses. | |
| 1085 * Synchronous Processes:: Details of using synchronous subprocesses. | |
| 1086 * Asynchronous Processes:: Starting up an asynchronous subprocess. | |
| 1087 * Deleting Processes:: Eliminating an asynchronous subprocess. | |
| 1088 * Process Information:: Accessing run-status and other attributes. | |
| 1089 * Input to Processes:: Sending input to an asynchronous subprocess. | |
| 1090 * Signals to Processes:: Stopping, continuing or interrupting | |
| 1091 an asynchronous subprocess. | |
| 1092 * Output from Processes:: Collecting output from an asynchronous subprocess. | |
| 1093 * Sentinels:: Sentinels run when process run-status changes. | |
| 1094 * Network:: Opening network connections. | |
| 1095 | |
| 1096 Receiving Output from Processes | |
| 1097 | |
| 1098 * Process Buffers:: If no filter, output is put in a buffer. | |
| 1099 * Filter Functions:: Filter functions accept output from the process. | |
| 1100 * Accepting Output:: How to wait until process output arrives. | |
| 1101 | |
| 1102 Operating System Interface | |
| 1103 | |
| 1104 * Starting Up:: Customizing XEmacs start-up processing. | |
| 1105 * Getting Out:: How exiting works (permanent or temporary). | |
| 1106 * System Environment:: Distinguish the name and kind of system. | |
| 1107 * Terminal Input:: Recording terminal input for debugging. | |
| 1108 * Terminal Output:: Recording terminal output for debugging. | |
| 1109 * Flow Control:: How to turn output flow control on or off. | |
| 1110 * Batch Mode:: Running XEmacs without terminal interaction. | |
| 1111 | |
| 1112 Starting Up XEmacs | |
| 1113 | |
| 1114 * Start-up Summary:: Sequence of actions XEmacs performs at start-up. | |
| 1115 * Init File:: Details on reading the init file (@file{.emacs}). | |
| 1116 * Terminal-Specific:: How the terminal-specific Lisp file is read. | |
| 1117 * Command Line Arguments:: How command line arguments are processed, | |
| 1118 and how you can customize them. | |
| 1119 | |
| 1120 Getting out of XEmacs | |
| 1121 | |
| 1122 * Killing XEmacs:: Exiting XEmacs irreversibly. | |
| 1123 * Suspending XEmacs:: Exiting XEmacs reversibly. | |
| 1124 | |
| 1125 X-Windows | |
| 1126 | |
| 1127 * X Selections:: Transferring text to and from other X clients. | |
| 1128 * X Server:: Information about the X server connected to | |
| 1129 a particular device. | |
| 1130 * Resources:: Getting resource values from the server. | |
| 1131 * Server Data:: Getting info about the X server. | |
| 1132 * Grabs:: Restricting access to the server by other apps. | |
| 1133 * X Miscellaneous:: Other X-specific functions and variables. | |
| 1134 | |
| 1135 ToolTalk Support | |
| 1136 | |
| 1137 * XEmacs ToolTalk API Summary:: | |
| 1138 * Sending Messages:: | |
| 1139 * Receiving Messages:: | |
| 1140 | |
| 1141 LDAP Support | |
| 1142 | |
| 1143 * Building XEmacs with LDAP support:: How to add LDAP support to XEmacs | |
| 1144 * XEmacs LDAP API:: Lisp access to LDAP functions | |
| 1145 * Syntax of Search Filters:: A brief summary of RFC 1558 | |
| 1146 | |
| 1147 XEmacs LDAP API | |
| 1148 | |
| 1149 * LDAP Variables:: Lisp variables related to LDAP | |
| 444 | 1150 * The High-Level LDAP API:: High-level LDAP lisp functions |
| 428 | 1151 * The Low-Level LDAP API:: Low-level LDAP lisp primitives |
| 442 | 1152 * LDAP Internationalization:: I18n variables and functions |
| 428 | 1153 |
| 1154 The Low-Level LDAP API | |
| 1155 | |
| 444 | 1156 * The LDAP Lisp Object:: |
| 1157 * Opening and Closing a LDAP Connection:: | |
| 1158 * Low-level Operations on a LDAP Server:: | |
| 442 | 1159 |
| 1160 LDAP Internationalization | |
| 1161 | |
| 444 | 1162 * LDAP Internationalization Variables:: |
| 1163 * Encoder/Decoder Functions:: | |
| 428 | 1164 |
| 1165 Internationalization | |
| 1166 | |
| 1167 * I18N Levels 1 and 2:: Support for different time, date, and currency formats. | |
| 1168 * I18N Level 3:: Support for localized messages. | |
| 1169 * I18N Level 4:: Support for Asian languages. | |
| 1170 | |
| 1171 MULE | |
| 1172 | |
| 1173 * Internationalization Terminology:: | |
| 1174 Definition of various internationalization terms. | |
| 1175 * Charsets:: Sets of related characters. | |
| 1176 * MULE Characters:: Working with characters in XEmacs/MULE. | |
| 1177 * Composite Characters:: Making new characters by overstriking other ones. | |
| 1178 * ISO 2022:: An international standard for charsets and encodings. | |
| 1179 * Coding Systems:: Ways of representing a string of chars using integers. | |
| 1180 * CCL:: A special language for writing fast converters. | |
| 1181 * Category Tables:: Subdividing charsets into groups. | |
| 1182 | |
| 1183 Tips | |
| 1184 | |
| 1185 * Style Tips:: Writing clean and robust programs. | |
| 1186 * Compilation Tips:: Making compiled code run fast. | |
| 1187 * Documentation Tips:: Writing readable documentation strings. | |
| 1188 * Comment Tips:: Conventions for writing comments. | |
| 1189 * Library Headers:: Standard headers for library packages. | |
| 1190 | |
| 1191 Building XEmacs and Object Allocation | |
| 1192 | |
| 1193 * Building XEmacs:: How to preload Lisp libraries into XEmacs. | |
| 1194 * Garbage Collection:: Reclaiming space for Lisp objects no longer used. | |
| 1195 | |
| 1196 @end menu | |
| 1197 | |
| 1198 @include intro.texi | |
| 693 | 1199 @include packaging.texi |
| 428 | 1200 @include objects.texi |
| 1201 @include numbers.texi | |
| 1202 @include strings.texi | |
| 1203 | |
| 1204 @include lists.texi | |
| 1205 @include sequences.texi | |
| 1206 @include symbols.texi | |
| 1207 @include eval.texi | |
| 1208 | |
| 1209 @include control.texi | |
| 1210 @include variables.texi | |
| 1211 @include functions.texi | |
| 1212 @include macros.texi | |
| 1213 @include customize.texi | |
| 1214 | |
| 1215 @include loading.texi | |
| 1216 @include compile.texi | |
| 1217 @include debugging.texi | |
| 1218 @include streams.texi | |
| 1219 | |
| 1220 @include minibuf.texi | |
| 1221 @include commands.texi | |
| 1222 @include keymaps.texi | |
| 1223 @include menus.texi | |
| 1224 @include dialog.texi | |
| 1225 @include toolbar.texi | |
| 442 | 1226 @include gutter.texi |
| 428 | 1227 @include scrollbars.texi |
| 1228 @include dragndrop.texi | |
| 1229 @include modes.texi | |
| 1230 | |
| 1231 @include help.texi | |
| 1232 @include files.texi | |
| 1233 @include backups.texi | |
| 1234 @include buffers.texi | |
| 1235 | |
| 1236 @include windows.texi | |
| 1237 @include frames.texi | |
| 1238 @include consoles-devices.texi | |
| 1239 @include positions.texi | |
| 1240 @include markers.texi | |
| 1241 @include text.texi | |
| 1242 | |
| 1243 @include searching.texi | |
| 1244 @include syntax.texi | |
| 1245 @include abbrevs.texi | |
| 1246 | |
| 1247 @include extents.texi | |
| 1248 @include specifiers.texi | |
| 1249 @include faces.texi | |
| 1250 @include glyphs.texi | |
| 1251 @include annotations.texi | |
| 1252 @include display.texi | |
| 1253 | |
| 1254 @include hash-tables.texi | |
| 1255 @include range-tables.texi | |
| 1256 @include databases.texi | |
| 1257 | |
| 1258 @include processes.texi | |
| 1259 @include os.texi | |
| 1260 @include x-windows.texi | |
| 1261 @include tooltalk.texi | |
| 1262 @include ldap.texi | |
| 442 | 1263 @include postgresql.texi |
| 428 | 1264 @include internationalization.texi |
| 1265 @include mule.texi | |
| 1266 | |
| 1267 @c MOVE to User's Manual: include calendar.texi | |
| 1268 | |
| 1269 @c MOVE to User's Manual: include misc-modes.texi | |
| 1270 | |
| 1271 @c appendices | |
| 1272 | |
| 1273 @c REMOVE this: include non-hacker.texi | |
| 1274 | |
| 1275 @include tips.texi | |
| 1276 @include building.texi | |
| 1277 @include errors.texi | |
| 1278 @include locals.texi | |
| 1279 @include maps.texi | |
| 1280 @include hooks.texi | |
| 1281 | |
| 1282 @include index.texi | |
| 1283 | |
| 1284 @c Print the tables of contents | |
| 1285 @summarycontents | |
| 1286 @contents | |
| 1287 @c That's all | |
| 1288 | |
| 1289 @bye | |
| 1290 | |
| 1291 | |
| 1292 These words prevent "local variables" above from confusing XEmacs. |