This is Info file ../../info/lispref.info, produced by Makeinfo version 1.68 from the input file lispref.texi. Edition History: GNU Emacs Lisp Reference Manual Second Edition (v2.01), May 1993 GNU Emacs Lisp Reference Manual Further Revised (v2.02), August 1993 Lucid Emacs Lisp Reference Manual (for 19.10) First Edition, March 1994 XEmacs Lisp Programmer's Manual (for 19.12) Second Edition, April 1995 GNU Emacs Lisp Reference Manual v2.4, June 1995 XEmacs Lisp Programmer's Manual (for 19.13) Third Edition, July 1995 XEmacs Lisp Reference Manual (for 19.14 and 20.0) v3.1, March 1996 XEmacs Lisp Reference Manual (for 19.15 and 20.1, 20.2) v3.2, April, May 1997 Copyright (C) 1990, 1991, 1992, 1993, 1994, 1995 Free Software Foundation, Inc. Copyright (C) 1994, 1995 Sun Microsystems, Inc. Copyright (C) 1995, 1996 Ben Wing. Permission is granted to make and distribute verbatim copies of this manual provided the copyright notice and this permission notice are preserved on all copies. Permission is granted to copy and distribute modified versions of this manual under the conditions for verbatim copying, provided that the entire resulting derived work is distributed under the terms of a permission notice identical to this one. Permission is granted to copy and distribute translations of this manual into another language, under the above conditions for modified versions, except that this permission notice may be stated in a translation approved by the Foundation. Permission is granted to copy and distribute modified versions of this manual under the conditions for verbatim copying, provided also that the section entitled "GNU General Public License" is included exactly as in the original, and provided that the entire resulting derived work is distributed under the terms of a permission notice identical to this one. Permission is granted to copy and distribute translations of this manual into another language, under the above conditions for modified versions, except that the section entitled "GNU General Public License" may be included in a translation approved by the Free Software Foundation instead of in the original English.  File: lispref.info, Node: Invisible Text, Next: Selective Display, Prev: The Echo Area, Up: Display Invisible Text ============== You can make characters "invisible", so that they do not appear on the screen, with the `invisible' property. This can be either a text property or a property of an overlay. In the simplest case, any non-`nil' `invisible' property makes a character invisible. This is the default case--if you don't alter the default value of `buffer-invisibility-spec', this is how the `invisibility' property works. This feature is much like selective display (*note Selective Display::.), but more general and cleaner. More generally, you can use the variable `buffer-invisibility-spec' to control which values of the `invisible' property make text invisible. This permits you to classify the text into different subsets in advance, by giving them different `invisible' values, and subsequently make various subsets visible or invisible by changing the value of `buffer-invisibility-spec'. Controlling visibility with `buffer-invisibility-spec' is especially useful in a program to display the list of entries in a data base. It permits the implementation of convenient filtering commands to view just a part of the entries in the data base. Setting this variable is very fast, much faster than scanning all the text in the buffer looking for properties to change. - Variable: buffer-invisibility-spec This variable specifies which kinds of `invisible' properties actually make a character invisible. `t' A character is invisible if its `invisible' property is non-`nil'. This is the default. a list Each element of the list makes certain characters invisible. Ultimately, a character is invisible if any of the elements of this list applies to it. The list can have two kinds of elements: `ATOM' A character is invisible if its `invisible' propery value is ATOM or if it is a list with ATOM as a member. `(ATOM . t)' A character is invisible if its `invisible' propery value is ATOM or if it is a list with ATOM as a member. Moreover, if this character is at the end of a line and is followed by a visible newline, it displays an ellipsis. Ordinarily, commands that operate on text or move point do not care whether the text is invisible. However, the user-level line motion commands explicitly ignore invisible newlines.  File: lispref.info, Node: Selective Display, Next: Overlay Arrow, Prev: Invisible Text, Up: Display Selective Display ================= "Selective display" is a pair of features that hide certain lines on the screen. The first variant, explicit selective display, is designed for use in a Lisp program. The program controls which lines are hidden by altering the text. Outline mode has traditionally used this variant. It has been partially replaced by the invisible text feature (*note Invisible Text::.); there is a new version of Outline mode which uses that instead. In the second variant, the choice of lines to hide is made automatically based on indentation. This variant is designed to be a user-level feature. The way you control explicit selective display is by replacing a newline (control-j) with a carriage return (control-m). The text that was formerly a line following that newline is now invisible. Strictly speaking, it is temporarily no longer a line at all, since only newlines can separate lines; it is now part of the previous line. Selective display does not directly affect editing commands. For example, `C-f' (`forward-char') moves point unhesitatingly into invisible text. However, the replacement of newline characters with carriage return characters affects some editing commands. For example, `next-line' skips invisible lines, since it searches only for newlines. Modes that use selective display can also define commands that take account of the newlines, or that make parts of the text visible or invisible. When you write a selectively displayed buffer into a file, all the control-m's are output as newlines. This means that when you next read in the file, it looks OK, with nothing invisible. The selective display effect is seen only within XEmacs. - Variable: selective-display This buffer-local variable enables selective display. This means that lines, or portions of lines, may be made invisible. * If the value of `selective-display' is `t', then any portion of a line that follows a control-m is not displayed. * If the value of `selective-display' is a positive integer, then lines that start with more than that many columns of indentation are not displayed. When some portion of a buffer is invisible, the vertical movement commands operate as if that portion did not exist, allowing a single `next-line' command to skip any number of invisible lines. However, character movement commands (such as `forward-char') do not skip the invisible portion, and it is possible (if tricky) to insert or delete text in an invisible portion. In the examples below, we show the *display appearance* of the buffer `foo', which changes with the value of `selective-display'. The *contents* of the buffer do not change. (setq selective-display nil) => nil ---------- Buffer: foo ---------- 1 on this column 2on this column 3n this column 3n this column 2on this column 1 on this column ---------- Buffer: foo ---------- (setq selective-display 2) => 2 ---------- Buffer: foo ---------- 1 on this column 2on this column 2on this column 1 on this column ---------- Buffer: foo ---------- - Variable: selective-display-ellipses If this buffer-local variable is non-`nil', then XEmacs displays `...' at the end of a line that is followed by invisible text. This example is a continuation of the previous one. (setq selective-display-ellipses t) => t ---------- Buffer: foo ---------- 1 on this column 2on this column ... 2on this column 1 on this column ---------- Buffer: foo ---------- You can use a display table to substitute other text for the ellipsis (`...'). *Note Display Tables::.  File: lispref.info, Node: Overlay Arrow, Next: Temporary Displays, Prev: Selective Display, Up: Display The Overlay Arrow ================= The "overlay arrow" is useful for directing the user's attention to a particular line in a buffer. For example, in the modes used for interface to debuggers, the overlay arrow indicates the line of code about to be executed. - Variable: overlay-arrow-string This variable holds the string to display to call attention to a particular line, or `nil' if the arrow feature is not in use. Despite its name, the value of this variable can be either a string or a glyph (*note Glyphs::.). - Variable: overlay-arrow-position This variable holds a marker that indicates where to display the overlay arrow. It should point at the beginning of a line. The arrow text appears at the beginning of that line, overlaying any text that would otherwise appear. Since the arrow is usually short, and the line usually begins with indentation, normally nothing significant is overwritten. The overlay string is displayed only in the buffer that this marker points into. Thus, only one buffer can have an overlay arrow at any given time. You can do the same job by creating an extent with a `begin-glyph' property. *Note Extent Properties::.  File: lispref.info, Node: Temporary Displays, Next: Blinking, Prev: Overlay Arrow, Up: Display Temporary Displays ================== Temporary displays are used by commands to put output into a buffer and then present it to the user for perusal rather than for editing. Many of the help commands use this feature. - Special Form: with-output-to-temp-buffer BUFFER-NAME FORMS... This function executes FORMS while arranging to insert any output they print into the buffer named BUFFER-NAME. The buffer is then shown in some window for viewing, displayed but not selected. The string BUFFER-NAME specifies the temporary buffer, which need not already exist. The argument must be a string, not a buffer. The buffer is erased initially (with no questions asked), and it is marked as unmodified after `with-output-to-temp-buffer' exits. `with-output-to-temp-buffer' binds `standard-output' to the temporary buffer, then it evaluates the forms in FORMS. Output using the Lisp output functions within FORMS goes by default to that buffer (but screen display and messages in the echo area, although they are "output" in the general sense of the word, are not affected). *Note Output Functions::. The value of the last form in FORMS is returned. ---------- Buffer: foo ---------- This is the contents of foo. ---------- Buffer: foo ---------- (with-output-to-temp-buffer "foo" (print 20) (print standard-output)) => # ---------- Buffer: foo ---------- 20 # ---------- Buffer: foo ---------- - Variable: temp-buffer-show-function If this variable is non-`nil', `with-output-to-temp-buffer' calls it as a function to do the job of displaying a help buffer. The function gets one argument, which is the buffer it should display. In Emacs versions 18 and earlier, this variable was called `temp-buffer-show-hook'. - Function: momentary-string-display STRING POSITION &optional CHAR MESSAGE This function momentarily displays STRING in the current buffer at POSITION. It has no effect on the undo list or on the buffer's modification status. The momentary display remains until the next input event. If the next input event is CHAR, `momentary-string-display' ignores it and returns. Otherwise, that event remains buffered for subsequent use as input. Thus, typing CHAR will simply remove the string from the display, while typing (say) `C-f' will remove the string from the display and later (presumably) move point forward. The argument CHAR is a space by default. The return value of `momentary-string-display' is not meaningful. You can do the same job in a more general way by creating an extent with a begin-glyph property. *Note Extent Properties::. If MESSAGE is non-`nil', it is displayed in the echo area while STRING is displayed in the buffer. If it is `nil', a default message says to type CHAR to continue. In this example, point is initially located at the beginning of the second line: ---------- Buffer: foo ---------- This is the contents of foo. -!-Second line. ---------- Buffer: foo ---------- (momentary-string-display "**** Important Message! ****" (point) ?\r "Type RET when done reading") => t ---------- Buffer: foo ---------- This is the contents of foo. **** Important Message! ****Second line. ---------- Buffer: foo ---------- ---------- Echo Area ---------- Type RET when done reading ---------- Echo Area ---------- This function works by actually changing the text in the buffer. As a result, if you later undo in this buffer, you will see the message come and go.  File: lispref.info, Node: Blinking, Next: Usual Display, Prev: Temporary Displays, Up: Display Blinking Parentheses ==================== This section describes the mechanism by which XEmacs shows a matching open parenthesis when the user inserts a close parenthesis. - Variable: blink-paren-function The value of this variable should be a function (of no arguments) to be called whenever a character with close parenthesis syntax is inserted. The value of `blink-paren-function' may be `nil', in which case nothing is done. *Please note:* This variable was named `blink-paren-hook' in older Emacs versions, but since it is not called with the standard convention for hooks, it was renamed to `blink-paren-function' in version 19. - Variable: blink-matching-paren If this variable is `nil', then `blink-matching-open' does nothing. - Variable: blink-matching-paren-distance This variable specifies the maximum distance to scan for a matching parenthesis before giving up. - Variable: blink-matching-paren-delay This variable specifies the number of seconds for the cursor to remain at the matching parenthesis. A fraction of a second often gives good results, but the default is 1, which works on all systems. - Function: blink-matching-open This function is the default value of `blink-paren-function'. It assumes that point follows a character with close parenthesis syntax and moves the cursor momentarily to the matching opening character. If that character is not already on the screen, it displays the character's context in the echo area. To avoid long delays, this function does not search farther than `blink-matching-paren-distance' characters. Here is an example of calling this function explicitly. (defun interactive-blink-matching-open () "Indicate momentarily the start of sexp before point." (interactive) (let ((blink-matching-paren-distance (buffer-size)) (blink-matching-paren t)) (blink-matching-open)))  File: lispref.info, Node: Usual Display, Next: Display Tables, Prev: Blinking, Up: Display Usual Display Conventions ========================= The usual display conventions define how to display each character code. You can override these conventions by setting up a display table (*note Display Tables::.). Here are the usual display conventions: * Character codes 32 through 126 map to glyph codes 32 through 126. Normally this means they display as themselves. * Character code 9 is a horizontal tab. It displays as whitespace up to a position determined by `tab-width'. * Character code 10 is a newline. * All other codes in the range 0 through 31, and code 127, display in one of two ways according to the value of `ctl-arrow'. If it is non-`nil', these codes map to sequences of two glyphs, where the first glyph is the ASCII code for `^'. (A display table can specify a glyph to use instead of `^'.) Otherwise, these codes map just like the codes in the range 128 to 255. * Character codes 128 through 255 map to sequences of four glyphs, where the first glyph is the ASCII code for `\', and the others are digit characters representing the code in octal. (A display table can specify a glyph to use instead of `\'.) The usual display conventions apply even when there is a display table, for any character whose entry in the active display table is `nil'. Thus, when you set up a display table, you need only specify the characters for which you want unusual behavior. These variables affect the way certain characters are displayed on the screen. Since they change the number of columns the characters occupy, they also affect the indentation functions. - User Option: ctl-arrow This buffer-local variable controls how control characters are displayed. If it is non-`nil', they are displayed as a caret followed by the character: `^A'. If it is `nil', they are displayed as a backslash followed by three octal digits: `\001'. - Variable: default-ctl-arrow The value of this variable is the default value for `ctl-arrow' in buffers that do not override it. *Note Default Value::. - User Option: tab-width The value of this variable is the spacing between tab stops used for displaying tab characters in Emacs buffers. The default is 8. Note that this feature is completely independent from the user-settable tab stops used by the command `tab-to-tab-stop'. *Note Indent Tabs::.  File: lispref.info, Node: Display Tables, Next: Beeping, Prev: Usual Display, Up: Display Display Tables ============== You can use the "display table" feature to control how all 256 possible character codes display on the screen. This is useful for displaying European languages that have letters not in the ASCII character set. The display table maps each character code into a sequence of "runes", each rune being an image that takes up one character position on the screen. You can also define how to display each rune on your terminal, using the "rune table". * Menu: * Display Table Format:: What a display table consists of. * Active Display Table:: How XEmacs selects a display table to use. * Character Descriptors:: Format of an individual element of a display table.  File: lispref.info, Node: Display Table Format, Next: Active Display Table, Up: Display Tables Display Table Format -------------------- A display table is an array of 256 elements. (In FSF Emacs, a display table is 262 elements. The six extra elements specify the truncation and continuation glyphs, etc. This method is very kludgey, and in XEmacs the variables `truncation-glyph', `continuation-glyph', etc. are used. *Note Truncation::.) - Function: make-display-table This creates and returns a display table. The table initially has `nil' in all elements. The 256 elements correspond to character codes; the Nth element says how to display the character code N. The value should be `nil', a string, a glyph, or a vector of strings and glyphs (*note Character Descriptors::.). If an element is `nil', it says to display that character according to the usual display conventions (*note Usual Display::.). If you use the display table to change the display of newline characters, the whole buffer will be displayed as one long "line." For example, here is how to construct a display table that mimics the effect of setting `ctl-arrow' to a non-`nil' value: (setq disptab (make-display-table)) (let ((i 0)) (while (< i 32) (or (= i ?\t) (= i ?\n) (aset disptab i (concat "^" (char-to-string (+ i 64))))) (setq i (1+ i))) (aset disptab 127 "^?"))  File: lispref.info, Node: Active Display Table, Next: Character Descriptors, Prev: Display Table Format, Up: Display Tables Active Display Table -------------------- The active display table is controlled by the variable `current-display-table'. This is a specifier, which means that you can specify separate values for it in individual buffers, windows, frames, and devices, as well as a global value. It also means that you cannot set this variable using `setq'; use `set-specifier' instead. *Note Specifiers::. (FSF Emacs uses `window-display-table', `buffer-display-table', `standard-display-table', etc. to control the display table. However, specifiers are a cleaner and more powerful way of doing the same thing. FSF Emacs also uses a different format for the contents of a display table, using additional indirection to a "glyph table" and such. Note that "glyph" has a different meaning in XEmacs.) Individual faces can also specify an overriding display table; this is set using `set-face-display-table'. *Note Faces::. If no display table can be determined for a particular window, then XEmacs uses the usual display conventions. *Note Usual Display::.  File: lispref.info, Node: Character Descriptors, Prev: Active Display Table, Up: Display Tables Character Descriptors --------------------- Each element of the display-table vector describes how to display a particular character and is called a "character descriptor". A character descriptor can be: a string Display this particular string wherever the character is to be displayed. a glyph Display this particular glyph wherever the character is to be displayed. a vector The vector may contain strings and/or glyphs. Display the elements of the vector one after another wherever the character is to be displayed. `nil' Display according to the standard interpretation (*note Usual Display::.).  File: lispref.info, Node: Beeping, Prev: Display Tables, Up: Display Beeping ======= You can make XEmacs ring a bell, play a sound, or blink the screen to attract the user's attention. Be conservative about how often you do this; frequent bells can become irritating. Also be careful not to use beeping alone when signaling an error is appropriate. (*Note Errors::.) - Function: ding &optional DONT-TERMINATE SOUND DEVICE This function beeps, or flashes the screen (see `visible-bell' below). It also terminates any keyboard macro currently executing unless DONT-TERMINATE is non-`nil'. If SOUND is specified, it should be a symbol specifying which sound to make. This sound will be played if `visible-bell' is `nil'. (This only works if sound support was compiled into the executable and you are running on the console of a Sun SparcStation, SGI, or HP9000s700. Otherwise you just get a beep.) The optional third argument specifies what device to make the sound on, and defaults to the selected device. - Function: beep &optional DONT-TERMINATE SOUND DEVICE This is a synonym for `ding'. - User Option: visible-bell This variable determines whether XEmacs should flash the screen to represent a bell. Non-`nil' means yes, `nil' means no. On TTY devices, this is effective only if the Termcap entry for the terminal type has the visible bell flag (`vb') set. - Variable: sound-alist This variable holds an alist associating names with sounds. When `beep' or `ding' is called with one of the name symbols, the associated sound will be generated instead of the standard beep. Each element of `sound-alist' is a list describing a sound. The first element of the list is the name of the sound being defined. Subsequent elements of the list are alternating keyword/value pairs: `sound' A string of raw sound data, or the name of another sound to play. The symbol `t' here means use the default X beep. `volume' An integer from 0-100, defaulting to `bell-volume'. `pitch' If using the default X beep, the pitch (Hz) to generate. `duration' If using the default X beep, the duration (milliseconds). For compatibility, elements of `sound-alist' may also be: * `( sound-name . )' * `( sound-name )' You should probably add things to this list by calling the function `load-sound-file'. Caveats: - You can only play audio data if running on the console screen of a Sun SparcStation, SGI, or HP9000s700. - The pitch, duration, and volume options are available everywhere, but many X servers ignore the `pitch' option. The following beep-types are used by XEmacs itself: `auto-save-error' when an auto-save does not succeed `command-error' when the XEmacs command loop catches an error `undefined-key' when you type a key that is undefined `undefined-click' when you use an undefined mouse-click combination `no-completion' during completing-read `y-or-n-p' when you type something other than 'y' or 'n' `yes-or-no-p' when you type something other than 'yes' or 'no' `default' used when nothing else is appropriate. Other lisp packages may use other beep types, but these are the ones that the C kernel of XEmacs uses. - User Option: bell-volume This variable specifies the default volume for sounds, from 0 to 100. - Command: load-default-sounds This function loads and installs some sound files as beep-types. - Command: load-sound-file FILENAME SOUND-NAME &optional VOLUME This function reads in an audio file and adds it to `sound-alist'. The sound file must be in the Sun/NeXT U-LAW format. SOUND-NAME should be a symbol, specifying the name of the sound. If VOLUME is specified, the sound will be played at that volume; otherwise, the value of BELL-VOLUME will be used. - Function: play-sound SOUND &optional VOLUME DEVICE This function plays sound SOUND, which should be a symbol mentioned in `sound-alist'. If VOLUME is specified, it overrides the value (if any) specified in `sound-alist'. DEVICE specifies the device to play the sound on, and defaults to the selected device. - Command: play-sound-file FILE &optional VOLUME DEVICE This function plays the named sound file at volume VOLUME, which defaults to `bell-volume'. DEVICE specifies the device to play the sound on, and defaults to the selected device.  File: lispref.info, Node: Hash Tables, Next: Range Tables, Prev: Display, Up: Top Hash Tables *********** - Function: hashtablep OBJECT This function returns non-`nil' if OBJECT is a hash table. * Menu: * Introduction to Hash Tables:: Hash tables are fast data structures for implementing simple tables (i.e. finite mappings from keys to values). * Working With Hash Tables:: Hash table functions. * Weak Hash Tables:: Hash tables with special garbage-collection behavior.  File: lispref.info, Node: Introduction to Hash Tables, Next: Working With Hash Tables, Up: Hash Tables Introduction to Hash Tables =========================== A hash table is a data structure that provides mappings from arbitrary Lisp objects (called "keys") to other arbitrary Lisp objects (called "values"). There are many ways other than hash tables of implementing the same sort of mapping, e.g. association lists (*note Association Lists::.) and property lists (*note Property Lists::.), but hash tables provide much faster lookup. When you create a hash table, you specify a size, which indicates the expected number of elements that the table will hold. You are not bound by this size, however; hash tables automatically resize themselves if the number of elements becomes too large. (Internally, hash tables are hashed using a modification of the "linear probing" hash table method. This method hashes each key to a particular spot in the hash table, and then scans forward sequentially until a blank entry is found. To look up a key, hash to the appropriate spot, then search forward for the key until either a key is found or a blank entry stops the search. The modification actually used is called "double hashing" and involves moving forward by a fixed increment, whose value is computed from the original hash value, rather than always moving forward by one. This eliminates problems with clustering that can arise from the simple linear probing method. For more information, see `Algorithms' (second edition) by Robert Sedgewick, pp. 236-241.) - Function: make-hashtable SIZE &optional TEST-FUN This function makes a hash table of initial size SIZE. Comparison between keys is normally done with `eql'; i.e. two keys must be the same object to be considered equivalent. However, you can explicitly specify the comparison function using TEST-FUN, which must be one of `eq', `eql', or `equal'. Note that currently, `eq' and `eql' are the same. This will change when bignums are implemented. - Function: copy-hashtable OLD-TABLE This function makes a new hash table which contains the same keys and values as the given table. The keys and values will not themselves be copied. - Function: hashtable-fullness TABLE This function returns number of entries in TABLE.  File: lispref.info, Node: Working With Hash Tables, Next: Weak Hash Tables, Prev: Introduction to Hash Tables, Up: Hash Tables Working With Hash Tables ======================== - Function: puthash KEY VAL TABLE This function hashes KEY to VAL in TABLE. - Function: gethash KEY TABLE &optional DEFAULT This function finds the hash value for KEY in TABLE. If there is no corresponding value, DEFAULT is returned (defaults to `nil'). - Function: remhash KEY TABLE This function removes the hash value for KEY in TABLE. - Function: clrhash TABLE This function flushes TABLE. Afterwards, the hash table will contain no entries. - Function: maphash FUNCTION TABLE This function maps FUNCTION over entries in TABLE, calling it with two args, each key and value in the table.  File: lispref.info, Node: Weak Hash Tables, Prev: Working With Hash Tables, Up: Hash Tables Weak Hash Tables ================ A "weak hash table" is a special variety of hash table whose elements do not count as GC referents. For any key-value pair in such a hash table, if either the key or value (or in some cases, if one particular one of the two) has no references to it outside of weak hash tables (and similar structures such as weak lists), the pair will be removed from the table, and the key and value collected. A non-weak hash table (or any other pointer) would prevent the objects from being collected. Weak hash tables are useful for keeping track of information in a non-obtrusive way, for example to implement caching. If the cache contains objects such as buffers, markers, image instances, etc. that will eventually disappear and get garbage-collected, using a weak hash table ensures that these objects are collected normally rather than remaining around forever, long past their actual period of use. (Otherwise, you'd have to explicitly map over the hash table every so often and remove unnecessary elements.) There are three types of weak hash tables: fully weak hash tables In these hash tables, a pair disappears if either the key or the value is unreferenced outside of the table. key-weak hash tables In these hash tables, a pair disappears if the key is unreferenced outside of the table, regardless of how the value is referenced. value-weak hash tables In these hash tables, a pair disappears if the value is unreferenced outside of the table, regardless of how the key is referenced. Also see *Note Weak Lists::. - Function: make-weak-hashtable SIZE &optional TEST-FUN This function makes a fully weak hash table of initial size SIZE. TEST-FUN is as in `make-hashtable'. - Function: make-key-weak-hashtable SIZE &optional TEST-FUN This function makes a key-weak hash table of initial size SIZE. TEST-FUN is as in `make-hashtable'. - Function: make-value-weak-hashtable SIZE &optional TEST-FUN This function makes a value-weak hash table of initial size SIZE. TEST-FUN is as in `make-hashtable'.  File: lispref.info, Node: Range Tables, Next: Databases, Prev: Hash Tables, Up: Top Range Tables ************ A range table is a table that efficiently associated values with ranges of integers. Note that range tables have a read syntax, like this: #s(range-table data ((-3 2) foo (5 20) bar)) This maps integers in the range (-3, 2) to `foo' and integers in the range (5, 20) to `bar'. - Function: range-table-p OBJECT Return non-`nil' if OBJECT is a range table. * Menu: * Introduction to Range Tables:: Range tables efficiently map ranges of integers to values. * Working With Range Tables:: Range table functions.  File: lispref.info, Node: Introduction to Range Tables, Next: Working With Range Tables, Up: Range Tables Introduction to Range Tables ============================ - Function: make-range-table Make a new, empty range table. - Function: copy-range-table OLD-TABLE Make a new range table which contains the same values for the same ranges as the given table. The values will not themselves be copied.  File: lispref.info, Node: Working With Range Tables, Prev: Introduction to Range Tables, Up: Range Tables Working With Range Tables ========================= - Function: get-range-table POS TABLE &optional DEFAULT This function finds value for position POS in TABLE. If there is no corresponding value, return DEFAULT (defaults to `nil'). - Function: put-range-table START END VAL TABLE This function sets the value for range (START, END) to be VAL in TABLE. - Function: remove-range-table START END TABLE This function removes the value for range (START, END) in TABLE. - Function: clear-range-table TABLE This function flushes TABLE. - Function: map-range-table FUNCTION TABLE This function maps FUNCTION over entries in TABLE, calling it with three args, the beginning and end of the range and the corresponding value.  File: lispref.info, Node: Databases, Next: Processes, Prev: Range Tables, Up: Top Databases ********* - Function: databasep OBJECT This function returns non-`nil' if OBJECT is a database. * Menu: * Connecting to a Database:: * Working With a Database:: * Other Database Functions::  File: lispref.info, Node: Connecting to a Database, Next: Working With a Database, Up: Databases Connecting to a Database ======================== - Function: open-database FILE &optional TYPE SUBTYPE ACCESS MODE This function opens database FILE, using database method TYPE and SUBTYPE, with access rights ACCESS and permissions MODE. ACCESS can be any combination of `r' `w' and `+', for read, write, and creation flags. TYPE can have the value `'dbm' or `'berkeley_db' to select the type of database file to use. (Note: XEmacs may not support both of these types.) For a TYPE of `'dbm', there are no subtypes, so SUBTYPE should by `nil'. For a TYPE of `'berkeley_db', the following subtypes are available: `'hash', `'btree', and `'recno'. See the manpages for the Berkeley DB functions to more information about these types. - Function: close-database OBJ This function closes database OBJ. - Function: database-live-p OBJ This function returns `t' iff OBJ is an active database, else `nil'.  File: lispref.info, Node: Working With a Database, Next: Other Database Functions, Prev: Connecting to a Database, Up: Databases Working With a Database ======================= - Function: get-database KEY DBASE &optional DEFAULT This function finds the value for KEY in DATABASE. If there is no corresponding value, DEFAULT is returned (`nil' if DEFAULT is omitted). - Function: map-database FUNCTION DBASE This function maps FUNCTION over entries in DATABASE, calling it with two args, each key and value in the database. - Function: put-database KEY VAL DBASE &optional REPLACE This function stores KEY and VAL in DATABASE. If optional fourth arg REPLACE is non-`nil', replace any existing entry in the database. - Function: remove-database KEY DBASE This function removes KEY from DATABASE.  File: lispref.info, Node: Other Database Functions, Prev: Working With a Database, Up: Databases Other Database Functions ======================== - Function: database-file-name OBJ This function returns the filename associated with the database OBJ. - Function: database-last-error &optional OBJ This function returns the last error associated with database OBJ. - Function: database-subtype OBJ This function returns the subtype of database OBJ, if any. - Function: database-type OBJ This function returns the type of database OBJ.  File: lispref.info, Node: Processes, Next: System Interface, Prev: Databases, Up: Top Processes ********* In the terminology of operating systems, a "process" is a space in which a program can execute. XEmacs runs in a process. XEmacs Lisp programs can invoke other programs in processes of their own. These are called "subprocesses" or "child processes" of the XEmacs process, which is their "parent process". A subprocess of XEmacs may be "synchronous" or "asynchronous", depending on how it is created. When you create a synchronous subprocess, the Lisp program waits for the subprocess to terminate before continuing execution. When you create an asynchronous subprocess, it can run in parallel with the Lisp program. This kind of subprocess is represented within XEmacs by a Lisp object which is also called a "process". Lisp programs can use this object to communicate with the subprocess or to control it. For example, you can send signals, obtain status information, receive output from the process, or send input to it. - Function: processp OBJECT This function returns `t' if OBJECT is a process, `nil' otherwise. * Menu: * Subprocess Creation:: Functions that start subprocesses. * Synchronous Processes:: Details of using synchronous subprocesses. * MS-DOS Subprocesses:: On MS-DOS, you must indicate text vs binary for data sent to and from a subprocess. * Asynchronous Processes:: Starting up an asynchronous subprocess. * Deleting Processes:: Eliminating an asynchronous subprocess. * Process Information:: Accessing run-status and other attributes. * Input to Processes:: Sending input to an asynchronous subprocess. * Signals to Processes:: Stopping, continuing or interrupting an asynchronous subprocess. * Output from Processes:: Collecting output from an asynchronous subprocess. * Sentinels:: Sentinels run when process run-status changes. * Process Window Size:: Changing the logical window size of a process. * Transaction Queues:: Transaction-based communication with subprocesses. * Network:: Opening network connections.  File: lispref.info, Node: Subprocess Creation, Next: Synchronous Processes, Up: Processes Functions that Create Subprocesses ================================== There are three functions that create a new subprocess in which to run a program. One of them, `start-process', creates an asynchronous process and returns a process object (*note Asynchronous Processes::.). The other two, `call-process' and `call-process-region', create a synchronous process and do not return a process object (*note Synchronous Processes::.). Synchronous and asynchronous processes are explained in following sections. Since the three functions are all called in a similar fashion, their common arguments are described here. In all cases, the function's PROGRAM argument specifies the program to be run. An error is signaled if the file is not found or cannot be executed. If the file name is relative, the variable `exec-path' contains a list of directories to search. Emacs initializes `exec-path' when it starts up, based on the value of the environment variable `PATH'. The standard file name constructs, `~', `.', and `..', are interpreted as usual in `exec-path', but environment variable substitutions (`$HOME', etc.) are not recognized; use `substitute-in-file-name' to perform them (*note File Name Expansion::.). Each of the subprocess-creating functions has a BUFFER-OR-NAME argument which specifies where the standard output from the program will go. If BUFFER-OR-NAME is `nil', that says to discard the output unless a filter function handles it. (*Note Filter Functions::, and *Note Read and Print::.) Normally, you should avoid having multiple processes send output to the same buffer because their output would be intermixed randomly. All three of the subprocess-creating functions have a `&rest' argument, ARGS. The ARGS must all be strings, and they are supplied to PROGRAM as separate command line arguments. Wildcard characters and other shell constructs are not allowed in these strings, since they are passed directly to the specified program. *Please note:* The argument PROGRAM contains only the name of the program; it may not contain any command-line arguments. You must use ARGS to provide those. The subprocess gets its current directory from the value of `default-directory' (*note File Name Expansion::.). The subprocess inherits its environment from XEmacs; but you can specify overrides for it with `process-environment'. *Note System Environment::. - Variable: exec-directory The value of this variable is the name of a directory (a string) that contains programs that come with XEmacs, that are intended for XEmacs to invoke. The program `wakeup' is an example of such a program; the `display-time' command uses it to get a reminder once per minute. - User Option: exec-path The value of this variable is a list of directories to search for programs to run in subprocesses. Each element is either the name of a directory (i.e., a string), or `nil', which stands for the default directory (which is the value of `default-directory'). The value of `exec-path' is used by `call-process' and `start-process' when the PROGRAM argument is not an absolute file name.  File: lispref.info, Node: Synchronous Processes, Next: MS-DOS Subprocesses, Prev: Subprocess Creation, Up: Processes Creating a Synchronous Process ============================== After a "synchronous process" is created, XEmacs waits for the process to terminate before continuing. Starting Dired is an example of this: it runs `ls' in a synchronous process, then modifies the output slightly. Because the process is synchronous, the entire directory listing arrives in the buffer before XEmacs tries to do anything with it. While Emacs waits for the synchronous subprocess to terminate, the user can quit by typing `C-g'. The first `C-g' tries to kill the subprocess with a `SIGINT' signal; but it waits until the subprocess actually terminates before quitting. If during that time the user types another `C-g', that kills the subprocess instantly with `SIGKILL' and quits immediately. *Note Quitting::. The synchronous subprocess functions returned `nil' in version 18. In version 19, they return an indication of how the process terminated. - Function: call-process PROGRAM &optional INFILE DESTINATION DISPLAY &rest ARGS This function calls PROGRAM in a separate process and waits for it to finish. The standard input for the process comes from file INFILE if INFILE is not `nil' and from `/dev/null' otherwise. The argument DESTINATION says where to put the process output. Here are the possibilities: a buffer Insert the output in that buffer, before point. This includes both the standard output stream and the standard error stream of the process. a string Find or create a buffer with that name, then insert the output in that buffer, before point. `t' Insert the output in the current buffer, before point. `nil' Discard the output. 0 Discard the output, and return immediately without waiting for the subprocess to finish. In this case, the process is not truly synchronous, since it can run in parallel with Emacs; but you can think of it as synchronous in that Emacs is essentially finished with the subprocess as soon as this function returns. (REAL-DESTINATION ERROR-DESTINATION) Keep the standard output stream separate from the standard error stream; deal with the ordinary output as specified by REAL-DESTINATION, and dispose of the error output according to ERROR-DESTINATION. The value `nil' means discard it, `t' means mix it with the ordinary output, and a string specifies a file name to redirect error output into. You can't directly specify a buffer to put the error output in; that is too difficult to implement. But you can achieve this result by sending the error output to a temporary file and then inserting the file into a buffer. If DISPLAY is non-`nil', then `call-process' redisplays the buffer as output is inserted. Otherwise the function does no redisplay, and the results become visible on the screen only when XEmacs redisplays that buffer in the normal course of events. The remaining arguments, ARGS, are strings that specify command line arguments for the program. The value returned by `call-process' (unless you told it not to wait) indicates the reason for process termination. A number gives the exit status of the subprocess; 0 means success, and any other value means failure. If the process terminated with a signal, `call-process' returns a string describing the signal. In the examples below, the buffer `foo' is current. (call-process "pwd" nil t) => nil ---------- Buffer: foo ---------- /usr/user/lewis/manual ---------- Buffer: foo ---------- (call-process "grep" nil "bar" nil "lewis" "/etc/passwd") => nil ---------- Buffer: bar ---------- lewis:5LTsHm66CSWKg:398:21:Bil Lewis:/user/lewis:/bin/csh ---------- Buffer: bar ---------- The `insert-directory' function contains a good example of the use of `call-process': (call-process insert-directory-program nil t nil switches (if full-directory-p (concat (file-name-as-directory file) ".") file)) - Function: call-process-region START END PROGRAM &optional DELETE DESTINATION DISPLAY &rest ARGS This function sends the text between START to END as standard input to a process running PROGRAM. It deletes the text sent if DELETE is non-`nil'; this is useful when BUFFER is `t', to insert the output in the current buffer. The arguments DESTINATION and DISPLAY control what to do with the output from the subprocess, and whether to update the display as it comes in. For details, see the description of `call-process', above. If DESTINATION is the integer 0, `call-process-region' discards the output and returns `nil' immediately, without waiting for the subprocess to finish. The remaining arguments, ARGS, are strings that specify command line arguments for the program. The return value of `call-process-region' is just like that of `call-process': `nil' if you told it to return without waiting; otherwise, a number or string which indicates how the subprocess terminated. In the following example, we use `call-process-region' to run the `cat' utility, with standard input being the first five characters in buffer `foo' (the word `input'). `cat' copies its standard input into its standard output. Since the argument DESTINATION is `t', this output is inserted in the current buffer. ---------- Buffer: foo ---------- input-!- ---------- Buffer: foo ---------- (call-process-region 1 6 "cat" nil t) => nil ---------- Buffer: foo ---------- inputinput-!- ---------- Buffer: foo ---------- The `shell-command-on-region' command uses `call-process-region' like this: (call-process-region start end shell-file-name ; Name of program. nil ; Do not delete region. buffer ; Send output to `buffer'. nil ; No redisplay during output. "-c" command) ; Arguments for the shell.