W3cubDocs

/Elisp

Char-Tables

A char-table is much like a vector, except that it is indexed by character codes. Any valid character code, without modifiers, can be used as an index in a char-table. You can access a char-table’s elements with aref and aset, as with any array. In addition, a char-table can have extra slots to hold additional data not associated with particular character codes. Like vectors, char-tables are constants when evaluated, and can hold elements of any type.

Each char-table has a subtype, a symbol, which serves two purposes:

The subtype provides an easy way to tell what the char-table is for. For instance, display tables are char-tables with display-table as the subtype, and syntax tables are char-tables with syntax-table as the subtype. The subtype can be queried using the function char-table-subtype, described below.
The subtype controls the number of extra slots in the char-table. This number is specified by the subtype’s char-table-extra-slots symbol property (see Symbol Properties), whose value should be an integer between 0 and 10. If the subtype has no such symbol property, the char-table has no extra slots.

A char-table can have a parent, which is another char-table. If it does, then whenever the char-table specifies nil for a particular character c, it inherits the value specified in the parent. In other words, (aref char-table c) returns the value from the parent of char-table if char-table itself specifies nil.

A char-table can also have a default value. If so, then (aref char-table c) returns the default value whenever the char-table does not specify any other non-nil value.

Function: make-char-table subtype &optional init

Return a newly-created char-table, with subtype subtype (a symbol). Each element is initialized to init, which defaults to nil. You cannot alter the subtype of a char-table after the char-table is created.

There is no argument to specify the length of the char-table, because all char-tables have room for any valid character code as an index.

If subtype has the char-table-extra-slots symbol property, that specifies the number of extra slots in the char-table. This should be an integer between 0 and 10; otherwise, make-char-table raises an error. If subtype has no char-table-extra-slots symbol property (see Property Lists), the char-table has no extra slots.

Function: char-table-p object: This function returns t if object is a char-table, and nil otherwise.

Function: char-table-subtype char-table: This function returns the subtype symbol of char-table.

There is no special function to access default values in a char-table. To do that, use char-table-range (see below).

Function: char-table-parent char-table: This function returns the parent of char-table. The parent is always either nil or another char-table.

Function: set-char-table-parent char-table new-parent: This function sets the parent of char-table to new-parent.

Function: char-table-extra-slot char-table n: This function returns the contents of extra slot n (zero based) of char-table. The number of extra slots in a char-table is determined by its subtype.

Function: set-char-table-extra-slot char-table n value: This function stores value in extra slot n (zero based) of char-table.

A char-table can specify an element value for a single character code; it can also specify a value for an entire character set.

Function: char-table-range char-table range

This returns the value specified in char-table for a range of characters range. Here are the possibilities for range:

nil: Refers to the default value.
char: Refers to the element for character char (supposing char is a valid character code).
(from . to): A cons cell refers to all the characters in the inclusive range ‘[from..to]’.

Function: set-char-table-range char-table range value

This function sets the value in char-table for a range of characters range. Here are the possibilities for range:

nil: Refers to the default value.
t: Refers to the whole range of character codes.
char: Refers to the element for character char (supposing char is a valid character code).
(from . to): A cons cell refers to all the characters in the inclusive range ‘[from..to]’.

Function: map-char-table function char-table

This function calls its argument function for each element of char-table that has a non-nil value. The call to function is with two arguments, a key and a value. The key is a possible range argument for char-table-range—either a valid character or a cons cell (from . to), specifying a range of characters that share the same value. The value is what (char-table-range char-table key) returns.

Overall, the key-value pairs passed to function describe all the values stored in char-table.

The return value is always nil; to make calls to map-char-table useful, function should have side effects. For example, here is how to examine the elements of the syntax table:

(let (accumulator)
   (map-char-table
    (lambda (key value)
      (setq accumulator
            (cons (list
                   (if (consp key)
                       (list (car key) (cdr key))
                     key)
                   value)
                  accumulator)))
    (syntax-table))
   accumulator)
⇒
(((2597602 4194303) (2)) ((2597523 2597601) (3))
 ... (65379 (5 . 65378)) (65378 (4 . 65379)) (65377 (1))
 ... (12 (0)) (11 (3)) (10 (12)) (9 (0)) ((0 8) (3)))