[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
A Lisp object is a piece of data used and manipulated by Lisp programs. For our purposes, a type or data type is a set of possible objects.
Every object belongs to at least one type. Objects of the same type have similar structures and may usually be used in the same contexts. Types can overlap, and objects can belong to two or more types. Consequently, we can ask whether an object belongs to a particular type, but not for "the" type of an object.
A few fundamental object types are built into Emacs. These, from which all other types are constructed, are called primitive types. Each object belongs to one and only one primitive type. These types include integer, float, cons, symbol, string, vector, hash-table, subr, and byte-code function, plus several special types, such as buffer, that are related to editing. (See section 2.4 Editing Types.)
Each primitive type has a corresponding Lisp function that checks whether an object is a member of that type.
Note that Lisp is unlike many other languages in that Lisp objects are self-typing: the primitive type of the object is implicit in the object itself. For example, if an object is a vector, nothing can treat it as a number; Lisp knows it is a vector, not a number.
In most languages, the programmer must declare the data type of each variable, and the type is known by the compiler but not represented in the data. Such type declarations do not exist in Emacs Lisp. A Lisp variable can have any type of value, and it remembers whatever value you store in it, type and all.
This chapter describes the purpose, printed representation, and read syntax of each of the standard types in GNU Emacs Lisp. Details on how to use these types can be found in later chapters.
2.1 Printed Representation and Read Syntax How Lisp objects are represented as text. 2.2 Comments Comments and their formatting conventions. 2.3 Programming Types Types found in all Lisp systems. 2.4 Editing Types Types specific to Emacs. 2.5 Read Syntax for Circular Objects Read syntax for circular structure. 2.6 Type Predicates Tests related to types. 2.7 Equality Predicates Tests of equality between any two objects.
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
The printed representation of an object is the format of the
output generated by the Lisp printer (the function prin1
) for
that object. The read syntax of an object is the format of the
input accepted by the Lisp reader (the function read
) for that
object. See section 19. Reading and Printing Lisp Objects.
Most objects have more than one possible read syntax. Some types of object have no read syntax, since it may not make sense to enter objects of these types directly in a Lisp program. Except for these cases, the printed representation of an object is also a read syntax for it.
In other languages, an expression is text; it has no other form. In Lisp, an expression is primarily a Lisp object and only secondarily the text that is the object's read syntax. Often there is no need to emphasize this distinction, but you must keep it in the back of your mind, or you will occasionally be very confused.
Every type has a printed representation. Some types have no read
syntax--for example, the buffer type has none. Objects of these types
are printed in hash notation: the characters `#<' followed by
a descriptive string (typically the type name followed by the name of
the object), and closed with a matching `>'. Hash notation cannot
be read at all, so the Lisp reader signals the error
invalid-read-syntax
whenever it encounters `#<'.
(current-buffer) => #<buffer objects.texi> |
When you evaluate an expression interactively, the Lisp interpreter
first reads the textual representation of it, producing a Lisp object,
and then evaluates that object (see section 9. Evaluation). However,
evaluation and reading are separate activities. Reading returns the
Lisp object represented by the text that is read; the object may or may
not be evaluated later. See section 19.3 Input Functions, for a description of
read
, the basic function for reading objects.
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
A comment is text that is written in a program only for the sake of humans that read the program, and that has no effect on the meaning of the program. In Lisp, a semicolon (`;') starts a comment if it is not within a string or character constant. The comment continues to the end of line. The Lisp reader discards comments; they do not become part of the Lisp objects which represent the program within the Lisp system.
The `#@count' construct, which skips the next count characters, is useful for program-generated comments containing binary data. The Emacs Lisp byte compiler uses this in its output files (see section 16. Byte Compilation). It isn't meant for source files, however.
See section D.4 Tips on Writing Comments, for conventions for formatting comments.
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
There are two general categories of types in Emacs Lisp: those having to do with Lisp programming, and those having to do with editing. The former exist in many Lisp implementations, in one form or another. The latter are unique to Emacs Lisp.
2.3.1 Integer Type Numbers without fractional parts. 2.3.2 Floating Point Type Numbers with fractional parts and with a large range. 2.3.3 Character Type The representation of letters, numbers and control characters. 2.3.4 Symbol Type A multi-use object that refers to a function, variable, or property list, and has a unique identity. 2.3.5 Sequence Types Both lists and arrays are classified as sequences. 2.3.6 Cons Cell and List Types Cons cells, and lists (which are made from cons cells). 2.3.7 Array Type Arrays include strings and vectors. 2.3.8 String Type An (efficient) array of characters. 2.3.9 Vector Type One-dimensional arrays. 2.3.10 Char-Table Type One-dimensional sparse arrays indexed by characters. 2.3.11 Bool-Vector Type One-dimensional arrays of t
ornil
.2.3.12 Hash Table Type Super-fast lookup tables. 2.3.13 Function Type A piece of executable code you can call from elsewhere. 2.3.14 Macro Type A method of expanding an expression into another expression, more fundamental but less pretty. 2.3.15 Primitive Function Type A function written in C, callable from Lisp. 2.3.16 Byte-Code Function Type A function written in Lisp, then compiled. 2.3.17 Autoload Type A type used for automatically loading seldom-used functions.
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
The range of values for integers in Emacs Lisp is -134217728 to
134217727 (28 bits; i.e.,
-2**27
to
2**27 - 1)
on most machines. (Some machines may provide a wider range.) It is
important to note that the Emacs Lisp arithmetic functions do not check
for overflow. Thus (1+ 134217727)
is -134217728 on most
machines.
The read syntax for integers is a sequence of (base ten) digits with an optional sign at the beginning and an optional period at the end. The printed representation produced by the Lisp interpreter never has a leading `+' or a final `.'.
-1 ; The integer -1. 1 ; The integer 1. 1. ; Also the integer 1. +1 ; Also the integer 1. 268435457 ; Also the integer 1 on a 28-bit implementation. |
See section 3. Numbers, for more information.
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
Floating point numbers are the computer equivalent of scientific
notation. The precise number of significant figures and the range of
possible exponents is machine-specific; Emacs always uses the C data
type double
to store the value.
The printed representation for floating point numbers requires either a decimal point (with at least one digit following), an exponent, or both. For example, `1500.0', `15e2', `15.0e2', `1.5e3', and `.15e4' are five ways of writing a floating point number whose value is 1500. They are all equivalent.
See section 3. Numbers, for more information.
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
A character in Emacs Lisp is nothing more than an integer. In other words, characters are represented by their character codes. For example, the character A is represented as the integer 65.
Individual characters are not often used in programs. It is far more common to work with strings, which are sequences composed of characters. See section 2.3.8 String Type.
Characters in strings, buffers, and files are currently limited to the range of 0 to 524287--nineteen bits. But not all values in that range are valid character codes. Codes 0 through 127 are ASCII codes; the rest are non-ASCII (see section 33. Non-ASCII Characters). Characters that represent keyboard input have a much wider range, to encode modifier keys such as Control, Meta and Shift.
Since characters are really integers, the printed representation of a character is a decimal number. This is also a possible read syntax for a character, but writing characters that way in Lisp programs is a very bad idea. You should always use the special read syntax formats that Emacs Lisp provides for characters. These syntax formats start with a question mark.
The usual read syntax for alphanumeric characters is a question mark followed by the character; thus, `?A' for the character A, `?B' for the character B, and `?a' for the character a.
For example:
?Q => 81 ?q => 113 |
You can use the same syntax for punctuation characters, but it is often a good idea to add a `\' so that the Emacs commands for editing Lisp code don't get confused. For example, `?\ ' is the way to write the space character. If the character is `\', you must use a second `\' to quote it: `?\\'.
You can express the characters Control-g, backspace, tab, newline, vertical tab, formfeed, return, del, and escape as `?\a', `?\b', `?\t', `?\n', `?\v', `?\f', `?\r', `?\d', and `?\e', respectively. Thus,
?\a => 7 ; C-g ?\b => 8 ; backspace, BS, C-h ?\t => 9 ; tab, TAB, C-i ?\n => 10 ; newline, C-j ?\v => 11 ; vertical tab, C-k ?\f => 12 ; formfeed character, C-l ?\r => 13 ; carriage return, RET, C-m ?\e => 27 ; escape character, ESC, C-[ ?\\ => 92 ; backslash character, \ ?\d => 127 ; delete character, DEL |
These sequences which start with backslash are also known as escape sequences, because backslash plays the role of an escape character; this usage has nothing to do with the character ESC.
Control characters may be represented using yet another read syntax. This consists of a question mark followed by a backslash, caret, and the corresponding non-control character, in either upper or lower case. For example, both `?\^I' and `?\^i' are valid read syntax for the character C-i, the character whose value is 9.
Instead of the `^', you can use `C-'; thus, `?\C-i' is equivalent to `?\^I' and to `?\^i':
?\^I => 9 ?\C-I => 9 |
In strings and buffers, the only control characters allowed are those that exist in ASCII; but for keyboard input purposes, you can turn any character into a control character with `C-'. The character codes for these non-ASCII control characters include the 2**26 bit as well as the code for the corresponding non-control character. Ordinary terminals have no way of generating non-ASCII control characters, but you can generate them straightforwardly using X and other window systems.
For historical reasons, Emacs treats the DEL character as the control equivalent of ?:
?\^? => 127 ?\C-? => 127 |
As a result, it is currently not possible to represent the character Control-?, which is a meaningful input character under X, using `\C-'. It is not easy to change this, as various Lisp files refer to DEL in this way.
For representing control characters to be found in files or strings, we recommend the `^' syntax; for control characters in keyboard input, we prefer the `C-' syntax. Which one you use does not affect the meaning of the program, but may guide the understanding of people who read it.
A meta character is a character typed with the META modifier key. The integer that represents such a character has the 2**27 bit set (which on most machines makes it a negative number). We use high bits for this and other modifiers to make possible a wide range of basic character codes.
In a string, the 2**7 bit attached to an ASCII character indicates a meta character; thus, the meta characters that can fit in a string have codes in the range from 128 to 255, and are the meta versions of the ordinary ASCII characters. (In Emacs versions 18 and older, this convention was used for characters outside of strings as well.)
The read syntax for meta characters uses `\M-'. For example, `?\M-A' stands for M-A. You can use `\M-' together with octal character codes (see below), with `\C-', or with any other syntax for a character. Thus, you can write M-A as `?\M-A', or as `?\M-\101'. Likewise, you can write C-M-b as `?\M-\C-b', `?\C-\M-b', or `?\M-\002'.
The case of a graphic character is indicated by its character code; for example, ASCII distinguishes between the characters `a' and `A'. But ASCII has no way to represent whether a control character is upper case or lower case. Emacs uses the 2**25 bit to indicate that the shift key was used in typing a control character. This distinction is possible only when you use X terminals or other special terminals; ordinary terminals do not report the distinction to the computer in any way. The Lisp syntax for the shift bit is `\S-'; thus, `?\C-\S-o' or `?\C-\S-O' represents the shifted-control-o character.
The X Window System defines three other modifier bits that can be set in a character: hyper, super and alt. The syntaxes for these bits are `\H-', `\s-' and `\A-'. (Case is significant in these prefixes.) Thus, `?\H-\M-\A-x' represents Alt-Hyper-Meta-x. Numerically, the bit values are 2**22 for alt, 2**23 for super and 2**24 for hyper.
Finally, the most general read syntax for a character represents the
character code in either octal or hex. To use octal, write a question
mark followed by a backslash and the octal character code (up to three
octal digits); thus, `?\101' for the character A,
`?\001' for the character C-a, and ?\002
for the
character C-b. Although this syntax can represent any ASCII
character, it is preferred only when the precise octal value is more
important than the ASCII representation.
?\012 => 10 ?\n => 10 ?\C-j => 10 ?\101 => 65 ?A => 65 |
To use hex, write a question mark followed by a backslash, `x',
and the hexadecimal character code. You can use any number of hex
digits, so you can represent any character code in this way.
Thus, `?\x41' for the character A, `?\x1' for the
character C-a, and ?\x8e0
for the Latin-1 character
`a' with grave accent.
A backslash is allowed, and harmless, preceding any character without a special escape meaning; thus, `?\+' is equivalent to `?+'. There is no reason to add a backslash before most characters. However, you should add a backslash before any of the characters `()\|;'`"#.,' to avoid confusing the Emacs commands for editing Lisp code. Also add a backslash before whitespace characters such as space, tab, newline and formfeed. However, it is cleaner to use one of the easily readable escape sequences, such as `\t', instead of an actual whitespace character such as a tab.
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
A symbol in GNU Emacs Lisp is an object with a name. The symbol name serves as the printed representation of the symbol. In ordinary use, the name is unique--no two symbols have the same name.
A symbol can serve as a variable, as a function name, or to hold a property list. Or it may serve only to be distinct from all other Lisp objects, so that its presence in a data structure may be recognized reliably. In a given context, usually only one of these uses is intended. But you can use one symbol in all of these ways, independently.
A symbol whose name starts with a colon (`:') is called a keyword symbol. These symbols automatically act as constants, and are normally used only by comparing an unknown symbol with a few specific alternatives.
A symbol name can contain any characters whatever. Most symbol names are written with letters, digits, and the punctuation characters `-+=*/'. Such names require no special punctuation; the characters of the name suffice as long as the name does not look like a number. (If it does, write a `\' at the beginning of the name to force interpretation as a symbol.) The characters `_~!@$%^&:<>{}?' are less often used but also require no special punctuation. Any other characters may be included in a symbol's name by escaping them with a backslash. In contrast to its use in strings, however, a backslash in the name of a symbol simply quotes the single character that follows the backslash. For example, in a string, `\t' represents a tab character; in the name of a symbol, however, `\t' merely quotes the letter `t'. To have a symbol with a tab character in its name, you must actually use a tab (preceded with a backslash). But it's rare to do such a thing.
Common Lisp note: In Common Lisp, lower case letters are always "folded" to upper case, unless they are explicitly escaped. In Emacs Lisp, upper case and lower case letters are distinct.
Here are several examples of symbol names. Note that the `+' in the fifth example is escaped to prevent it from being read as a number. This is not necessary in the sixth example because the rest of the name makes it invalid as a number.
foo ; A symbol named `foo'. FOO ; A symbol named `FOO', different from `foo'. char-to-string ; A symbol named `char-to-string'. 1+ ; A symbol named `1+' ; (not `+1', which is an integer). \+1 ; A symbol named `+1' ; (not a very readable name). \(*\ 1\ 2\) ; A symbol named `(* 1 2)' (a worse name). +-*/_~!@$%^&=:<>{} ; A symbol named `+-*/_~!@$%^&=:<>{}'. ; These characters need not be escaped. |
Normally the Lisp reader interns all symbols (see section 8.3 Creating and Interning Symbols). To prevent interning, you can write `#:' before the name of the symbol.
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
A sequence is a Lisp object that represents an ordered set of elements. There are two kinds of sequence in Emacs Lisp, lists and arrays. Thus, an object of type list or of type array is also considered a sequence.
Arrays are further subdivided into strings, vectors, char-tables and
bool-vectors. Vectors can hold elements of any type, but string
elements must be characters, and bool-vector elements must be t
or nil
. Char-tables are like vectors except that they are
indexed by any valid character code. The characters in a string can
have text properties like characters in a buffer (see section 32.19 Text Properties), but vectors do not support text properties, even when
their elements happen to be characters.
Lists, strings and the other array types are different, but they have
important similarities. For example, all have a length l, and all
have elements which can be indexed from zero to l minus one.
Several functions, called sequence functions, accept any kind of
sequence. For example, the function elt
can be used to extract
an element of a sequence, given its index. See section 6. Sequences, Arrays, and Vectors.
It is generally impossible to read the same sequence twice, since
sequences are always created anew upon reading. If you read the read
syntax for a sequence twice, you get two sequences with equal contents.
There is one exception: the empty list ()
always stands for the
same object, nil
.
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
A cons cell is an object that consists of two slots, called the CAR slot and the CDR slot. Each slot can hold or refer to any Lisp object. We also say that "the CAR of this cons cell is" whatever object its CAR slot currently holds, and likewise for the CDR.
A note to C programmers: in Lisp, we do not distinguish between "holding" a value and "pointing to" the value, because pointers in Lisp are implicit.
A list is a series of cons cells, linked together so that the CDR slot of each cons cell holds either the next cons cell or the empty list. See section 5. Lists, for functions that work on lists. Because most cons cells are used as part of lists, the phrase list structure has come to refer to any structure made out of cons cells.
The names CAR and CDR derive from the history of Lisp. The
original Lisp implementation ran on an IBM 704 computer which
divided words into two parts, called the "address" part and the
"decrement"; CAR was an instruction to extract the contents of
the address part of a register, and CDR an instruction to extract
the contents of the decrement. By contrast, "cons cells" are named
for the function cons
that creates them, which in turn was named
for its purpose, the construction of cells.
Because cons cells are so central to Lisp, we also have a word for "an object which is not a cons cell". These objects are called atoms.
The read syntax and printed representation for lists are identical, and consist of a left parenthesis, an arbitrary number of elements, and a right parenthesis.
Upon reading, each object inside the parentheses becomes an element
of the list. That is, a cons cell is made for each element. The
CAR slot of the cons cell holds the element, and its CDR
slot refers to the next cons cell of the list, which holds the next
element in the list. The CDR slot of the last cons cell is set to
hold nil
.
A list can be illustrated by a diagram in which the cons cells are
shown as pairs of boxes, like dominoes. (The Lisp reader cannot read
such an illustration; unlike the textual notation, which can be
understood by both humans and computers, the box illustrations can be
understood only by humans.) This picture represents the three-element
list (rose violet buttercup)
:
--- --- --- --- --- --- | | |--> | | |--> | | |--> nil --- --- --- --- --- --- | | | | | | --> rose --> violet --> buttercup |
In this diagram, each box represents a slot that can hold or refer to any Lisp object. Each pair of boxes represents a cons cell. Each arrow represents a reference to a Lisp object, either an atom or another cons cell.
In this example, the first box, which holds the CAR of the first
cons cell, refers to or "holds" rose
(a symbol). The second
box, holding the CDR of the first cons cell, refers to the next
pair of boxes, the second cons cell. The CAR of the second cons
cell is violet
, and its CDR is the third cons cell. The
CDR of the third (and last) cons cell is nil
.
Here is another diagram of the same list, (rose violet
buttercup)
, sketched in a different manner:
--------------- ---------------- ------------------- | car | cdr | | car | cdr | | car | cdr | | rose | o-------->| violet | o-------->| buttercup | nil | | | | | | | | | | --------------- ---------------- ------------------- |
A list with no elements in it is the empty list; it is identical
to the symbol nil
. In other words, nil
is both a symbol
and a list.
Here are examples of lists written in Lisp syntax:
(A 2 "A") ; A list of three elements. () ; A list of no elements (the empty list). nil ; A list of no elements (the empty list). ("A ()") ; A list of one element: the string |
Here is the list (A ())
, or equivalently (A nil)
,
depicted with boxes and arrows:
--- --- --- --- | | |--> | | |--> nil --- --- --- --- | | | | --> A --> nil |
2.3.6.1 Dotted Pair Notation An alternative syntax for lists. 2.3.6.2 Association List Type A specially constructed list.
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
Dotted pair notation is an alternative syntax for cons cells
that represents the CAR and CDR explicitly. In this syntax,
(a . b)
stands for a cons cell whose CAR is
the object a, and whose CDR is the object b. Dotted
pair notation is therefore more general than list syntax. In the dotted
pair notation, the list `(1 2 3)' is written as `(1 . (2 . (3
. nil)))'. For nil
-terminated lists, you can use either
notation, but list notation is usually clearer and more convenient.
When printing a list, the dotted pair notation is only used if the
CDR of a cons cell is not a list.
Here's an example using boxes to illustrate dotted pair notation.
This example shows the pair (rose . violet)
:
--- --- | | |--> violet --- --- | | --> rose |
You can combine dotted pair notation with list notation to represent
conveniently a chain of cons cells with a non-nil
final CDR.
You write a dot after the last element of the list, followed by the
CDR of the final cons cell. For example, (rose violet
. buttercup)
is equivalent to (rose . (violet . buttercup))
.
The object looks like this:
--- --- --- --- | | |--> | | |--> buttercup --- --- --- --- | | | | --> rose --> violet |
The syntax (rose . violet . buttercup)
is invalid because
there is nothing that it could mean. If anything, it would say to put
buttercup
in the CDR of a cons cell whose CDR is already
used for violet
.
The list (rose violet)
is equivalent to (rose . (violet))
,
and looks like this:
--- --- --- --- | | |--> | | |--> nil --- --- --- --- | | | | --> rose --> violet |
Similarly, the three-element list (rose violet buttercup)
is equivalent to (rose . (violet . (buttercup)))
.
It looks like this:
--- --- --- --- --- --- | | |--> | | |--> | | |--> nil --- --- --- --- --- --- | | | | | | --> rose --> violet --> buttercup |
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
An association list or alist is a specially-constructed list whose elements are cons cells. In each element, the CAR is considered a key, and the CDR is considered an associated value. (In some cases, the associated value is stored in the CAR of the CDR.) Association lists are often used as stacks, since it is easy to add or remove associations at the front of the list.
For example,
(setq alist-of-colors '((rose . red) (lily . white) (buttercup . yellow))) |
sets the variable alist-of-colors
to an alist of three elements. In the
first element, rose
is the key and red
is the value.
See section 5.8 Association Lists, for a further explanation of alists and for functions that work on alists. See section 7. Hash Tables, for another kind of lookup table, which is much faster for handling a large number of keys.
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
An array is composed of an arbitrary number of slots for holding or referring to other Lisp objects, arranged in a contiguous block of memory. Accessing any element of an array takes approximately the same amount of time. In contrast, accessing an element of a list requires time proportional to the position of the element in the list. (Elements at the end of a list take longer to access than elements at the beginning of a list.)
Emacs defines four types of array: strings, vectors, bool-vectors, and char-tables.
A string is an array of characters and a vector is an array of
arbitrary objects. A bool-vector can hold only t
or nil
.
These kinds of array may have any length up to the largest integer.
Char-tables are sparse arrays indexed by any valid character code; they
can hold arbitrary objects.
The first element of an array has index zero, the second element has index 1, and so on. This is called zero-origin indexing. For example, an array of four elements has indices 0, 1, 2, and 3. The largest possible index value is one less than the length of the array. Once an array is created, its length is fixed.
All Emacs Lisp arrays are one-dimensional. (Most other programming languages support multidimensional arrays, but they are not essential; you can get the same effect with an array of arrays.) Each type of array has its own read syntax; see the following sections for details.
The array type is contained in the sequence type and contains the string type, the vector type, the bool-vector type, and the char-table type.
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
A string is an array of characters. Strings are used for many purposes in Emacs, as can be expected in a text editor; for example, as the names of Lisp symbols, as messages for the user, and to represent text extracted from buffers. Strings in Lisp are constants: evaluation of a string returns the same string.
See section 4. Strings and Characters, for functions that operate on strings.
2.3.8.1 Syntax for Strings 2.3.8.2 Non-ASCII Characters in Strings 2.3.8.3 Nonprinting Characters in Strings 2.3.8.4 Text Properties in Strings
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
The read syntax for strings is a double-quote, an arbitrary number of
characters, and another double-quote, "like this"
. To include a
double-quote in a string, precede it with a backslash; thus, "\""
is a string containing just a single double-quote character. Likewise,
you can include a backslash by preceding it with another backslash, like
this: "this \\ is a single embedded backslash"
.
The newline character is not special in the read syntax for strings; if you write a new line between the double-quotes, it becomes a character in the string. But an escaped newline--one that is preceded by `\'---does not become part of the string; i.e., the Lisp reader ignores an escaped newline while reading a string. An escaped space `\ ' is likewise ignored.
"It is useful to include newlines in documentation strings, but the newline is \ ignored if escaped." => "It is useful to include newlines in documentation strings, but the newline is ignored if escaped." |
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
You can include a non-ASCII international character in a string constant by writing it literally. There are two text representations for non-ASCII characters in Emacs strings (and in buffers): unibyte and multibyte. If the string constant is read from a multibyte source, such as a multibyte buffer or string, or a file that would be visited as multibyte, then the character is read as a multibyte character, and that makes the string multibyte. If the string constant is read from a unibyte source, then the character is read as unibyte and that makes the string unibyte.
You can also represent a multibyte non-ASCII character with its character code: use a hex escape, `\xnnnnnnn', with as many digits as necessary. (Multibyte non-ASCII character codes are all greater than 256.) Any character which is not a valid hex digit terminates this construct. If the next character in the string could be interpreted as a hex digit, write `\ ' (backslash and space) to terminate the hex escape--for example, `\x8e0\ ' represents one character, `a' with grave accent. `\ ' in a string constant is just like backslash-newline; it does not contribute any character to the string, but it does terminate the preceding hex escape.
Using a multibyte hex escape forces the string to multibyte. You can represent a unibyte non-ASCII character with its character code, which must be in the range from 128 (0200 octal) to 255 (0377 octal). This forces a unibyte string. See section 33.1 Text Representations, for more information about the two text representations.
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
You can use the same backslash escape-sequences in a string constant
as in character literals (but do not use the question mark that begins a
character constant). For example, you can write a string containing the
nonprinting characters tab and C-a, with commas and spaces between
them, like this: "\t, \C-a"
. See section 2.3.3 Character Type, for a
description of the read syntax for characters.
However, not all of the characters you can write with backslash escape-sequences are valid in strings. The only control characters that a string can hold are the ASCII control characters. Strings do not distinguish case in ASCII control characters.
Properly speaking, strings cannot hold meta characters; but when a
string is to be used as a key sequence, there is a special convention
that provides a way to represent meta versions of ASCII characters in a
string. If you use the `\M-' syntax to indicate a meta character
in a string constant, this sets the
2**7
bit of the character in the string. If the string is used in
define-key
or lookup-key
, this numeric code is translated
into the equivalent meta character. See section 2.3.3 Character Type.
Strings cannot hold characters that have the hyper, super, or alt modifiers.
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
A string can hold properties for the characters it contains, in addition to the characters themselves. This enables programs that copy text between strings and buffers to copy the text's properties with no special effort. See section 32.19 Text Properties, for an explanation of what text properties mean. Strings with text properties use a special read and print syntax:
#("characters" property-data...) |
where property-data consists of zero or more elements, in groups of three as follows:
beg end plist |
The elements beg and end are integers, and together specify a range of indices in the string; plist is the property list for that range. For example,
#("foo bar" 0 3 (face bold) 3 4 nil 4 7 (face italic)) |
represents a string whose textual contents are `foo bar', in which
the first three characters have a face
property with value
bold
, and the last three have a face
property with value
italic
. (The fourth character has no text properties, so its
property list is nil
. It is not actually necessary to mention
ranges with nil
as the property list, since any characters not
mentioned in any range will default to having no properties.)
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
A vector is a one-dimensional array of elements of any type. It takes a constant amount of time to access any element of a vector. (In a list, the access time of an element is proportional to the distance of the element from the beginning of the list.)
The printed representation of a vector consists of a left square bracket, the elements, and a right square bracket. This is also the read syntax. Like numbers and strings, vectors are considered constants for evaluation.
[1 "two" (three)] ; A vector of three elements. => [1 "two" (three)] |
See section 6.4 Vectors, for functions that work with vectors.
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
A char-table is a one-dimensional array of elements of any type, indexed by character codes. Char-tables have certain extra features to make them more useful for many jobs that involve assigning information to character codes--for example, a char-table can have a parent to inherit from, a default value, and a small number of extra slots to use for special purposes. A char-table can also specify a single value for a whole character set.
The printed representation of a char-table is like a vector except that there is an extra `#^' at the beginning.
See section 6.6 Char-Tables, for special functions to operate on char-tables. Uses of char-tables include:
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
A bool-vector is a one-dimensional array of elements that
must be t
or nil
.
The printed representation of a bool-vector is like a string, except
that it begins with `#&' followed by the length. The string
constant that follows actually specifies the contents of the bool-vector
as a bitmap--each "character" in the string contains 8 bits, which
specify the next 8 elements of the bool-vector (1 stands for t
,
and 0 for nil
). The least significant bits of the character
correspond to the lowest indices in the bool-vector. If the length is not a
multiple of 8, the printed representation shows extra elements, but
these extras really make no difference.
(make-bool-vector 3 t) => #&3"\007" (make-bool-vector 3 nil) => #&3"\0" ;; These are equal since only the first 3 bits are used. (equal #&3"\377" #&3"\007") => t |
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
A hash table is a very fast kind of lookup table, somewhat like an alist in that it maps keys to corresponding values, but much faster. Hash tables are a new feature in Emacs 21; they have no read syntax, and print using hash notation. See section 7. Hash Tables.
(make-hash-table) => #<hash-table 'eql nil 0/65 0x83af980> |
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
Just as functions in other programming languages are executable,
Lisp function objects are pieces of executable code. However,
functions in Lisp are primarily Lisp objects, and only secondarily the
text which represents them. These Lisp objects are lambda expressions:
lists whose first element is the symbol lambda
(see section 12.2 Lambda Expressions).
In most programming languages, it is impossible to have a function without a name. In Lisp, a function has no intrinsic name. A lambda expression is also called an anonymous function (see section 12.7 Anonymous Functions). A named function in Lisp is actually a symbol with a valid function in its function cell (see section 12.4 Defining Functions).
Most of the time, functions are called when their names are written in
Lisp expressions in Lisp programs. However, you can construct or obtain
a function object at run time and then call it with the primitive
functions funcall
and apply
. See section 12.5 Calling Functions.
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
A Lisp macro is a user-defined construct that extends the Lisp
language. It is represented as an object much like a function, but with
different argument-passing semantics. A Lisp macro has the form of a
list whose first element is the symbol macro
and whose CDR
is a Lisp function object, including the lambda
symbol.
Lisp macro objects are usually defined with the built-in
defmacro
function, but any list that begins with macro
is
a macro as far as Emacs is concerned. See section 13. Macros, for an explanation
of how to write a macro.
Warning: Lisp macros and keyboard macros (see section 21.15 Keyboard Macros) are entirely different things. When we use the word "macro" without qualification, we mean a Lisp macro, not a keyboard macro.
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
A primitive function is a function callable from Lisp but written in the C programming language. Primitive functions are also called subrs or built-in functions. (The word "subr" is derived from "subroutine".) Most primitive functions evaluate all their arguments when they are called. A primitive function that does not evaluate all its arguments is called a special form (see section 9.2.7 Special Forms).
It does not matter to the caller of a function whether the function is primitive. However, this does matter if you try to redefine a primitive with a function written in Lisp. The reason is that the primitive function may be called directly from C code. Calls to the redefined function from Lisp will use the new definition, but calls from C code may still use the built-in definition. Therefore, we discourage redefinition of primitive functions.
The term function refers to all Emacs functions, whether written in Lisp or C. See section 2.3.13 Function Type, for information about the functions written in Lisp.
Primitive functions have no read syntax and print in hash notation with the name of the subroutine.
(symbol-function 'car) ; Access the function cell ; of the symbol. => #<subr car> (subrp (symbol-function 'car)) ; Is this a primitive function? => t ; Yes. |
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
The byte compiler produces byte-code function objects. Internally, a byte-code function object is much like a vector; however, the evaluator handles this data type specially when it appears as a function to be called. See section 16. Byte Compilation, for information about the byte compiler.
The printed representation and read syntax for a byte-code function object is like that for a vector, with an additional `#' before the opening `['.
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
An autoload object is a list whose first element is the symbol
autoload
. It is stored as the function definition of a symbol,
where it serves as a placeholder for the real definition. The autoload
object says that the real definition is found in a file of Lisp code
that should be loaded when necessary. It contains the name of the file,
plus some other information about the real definition.
After the file has been loaded, the symbol should have a new function definition that is not an autoload object. The new definition is then called as if it had been there to begin with. From the user's point of view, the function call works as expected, using the function definition in the loaded file.
An autoload object is usually created with the function
autoload
, which stores the object in the function cell of a
symbol. See section 15.4 Autoload, for more details.
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
The types in the previous section are used for general programming purposes, and most of them are common to most Lisp dialects. Emacs Lisp provides several additional data types for purposes connected with editing.
2.4.1 Buffer Type The basic object of editing. 2.4.2 Marker Type A position in a buffer. 2.4.3 Window Type Buffers are displayed in windows. 2.4.4 Frame Type Windows subdivide frames. 2.4.5 Window Configuration Type Recording the way a frame is subdivided. 2.4.6 Frame Configuration Type Recording the status of all frames. 2.4.7 Process Type A process running on the underlying OS. 2.4.8 Stream Type Receive or send characters. 2.4.9 Keymap Type What function a keystroke invokes. 2.4.10 Overlay Type How an overlay is represented.
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
A buffer is an object that holds text that can be edited (see section 27. Buffers). Most buffers hold the contents of a disk file (see section 25. Files) so they can be edited, but some are used for other purposes. Most buffers are also meant to be seen by the user, and therefore displayed, at some time, in a window (see section 28. Windows). But a buffer need not be displayed in any window.
The contents of a buffer are much like a string, but buffers are not used like strings in Emacs Lisp, and the available operations are different. For example, you can insert text efficiently into an existing buffer, altering the buffer's contents, whereas "inserting" text into a string requires concatenating substrings, and the result is an entirely new string object.
Each buffer has a designated position called point (see section 30. Positions). At any time, one buffer is the current buffer. Most editing commands act on the contents of the current buffer in the neighborhood of point. Many of the standard Emacs functions manipulate or test the characters in the current buffer; a whole chapter in this manual is devoted to describing these functions (see section 32. Text).
Several other data structures are associated with each buffer:
The local keymap and variable list contain entries that individually override global bindings or values. These are used to customize the behavior of programs in different buffers, without actually changing the programs.
A buffer may be indirect, which means it shares the text of another buffer, but presents it differently. See section 27.11 Indirect Buffers.
Buffers have no read syntax. They print in hash notation, showing the buffer name.
(current-buffer) => #<buffer objects.texi> |
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
A marker denotes a position in a specific buffer. Markers therefore have two components: one for the buffer, and one for the position. Changes in the buffer's text automatically relocate the position value as necessary to ensure that the marker always points between the same two characters in the buffer.
Markers have no read syntax. They print in hash notation, giving the current character position and the name of the buffer.
(point-marker) => #<marker at 10779 in objects.texi> |
See section 31. Markers, for information on how to test, create, copy, and move markers.
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
A window describes the portion of the terminal screen that Emacs uses to display a buffer. Every window has one associated buffer, whose contents appear in the window. By contrast, a given buffer may appear in one window, no window, or several windows.
Though many windows may exist simultaneously, at any time one window is designated the selected window. This is the window where the cursor is (usually) displayed when Emacs is ready for a command. The selected window usually displays the current buffer, but this is not necessarily the case.
Windows are grouped on the screen into frames; each window belongs to one and only one frame. See section 2.4.4 Frame Type.
Windows have no read syntax. They print in hash notation, giving the window number and the name of the buffer being displayed. The window numbers exist to identify windows uniquely, since the buffer displayed in any given window can change frequently.
(selected-window) => #<window 1 on objects.texi> |
See section 28. Windows, for a description of the functions that work on windows.
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
A frame is a rectangle on the screen that contains one or more Emacs windows. A frame initially contains a single main window (plus perhaps a minibuffer window) which you can subdivide vertically or horizontally into smaller windows.
Frames have no read syntax. They print in hash notation, giving the frame's title, plus its address in core (useful to identify the frame uniquely).
(selected-frame) => #<frame emacs@psilocin.gnu.org 0xdac80> |
See section 29. Frames, for a description of the functions that work on frames.
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
A window configuration stores information about the positions, sizes, and contents of the windows in a frame, so you can recreate the same arrangement of windows later.
Window configurations do not have a read syntax; their print syntax looks like `#<window-configuration>'. See section 28.17 Window Configurations, for a description of several functions related to window configurations.
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
A frame configuration stores information about the positions,
sizes, and contents of the windows in all frames. It is actually
a list whose CAR is frame-configuration
and whose
CDR is an alist. Each alist element describes one frame,
which appears as the CAR of that element.
See section 29.12 Frame Configurations, for a description of several functions related to frame configurations.
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
The word process usually means a running program. Emacs itself runs in a process of this sort. However, in Emacs Lisp, a process is a Lisp object that designates a subprocess created by the Emacs process. Programs such as shells, GDB, ftp, and compilers, running in subprocesses of Emacs, extend the capabilities of Emacs.
An Emacs subprocess takes textual input from Emacs and returns textual output to Emacs for further manipulation. Emacs can also send signals to the subprocess.
Process objects have no read syntax. They print in hash notation, giving the name of the process:
(process-list) => (#<process shell>) |
See section 37. Processes, for information about functions that create, delete, return information about, send input or signals to, and receive output from processes.
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
A stream is an object that can be used as a source or sink for characters--either to supply characters for input or to accept them as output. Many different types can be used this way: markers, buffers, strings, and functions. Most often, input streams (character sources) obtain characters from the keyboard, a buffer, or a file, and output streams (character sinks) send characters to a buffer, such as a `*Help*' buffer, or to the echo area.
The object nil
, in addition to its other meanings, may be used
as a stream. It stands for the value of the variable
standard-input
or standard-output
. Also, the object
t
as a stream specifies input using the minibuffer
(see section 20. Minibuffers) or output in the echo area (see section 38.4 The Echo Area).
Streams have no special printed representation or read syntax, and print as whatever primitive type they are.
See section 19. Reading and Printing Lisp Objects, for a description of functions related to streams, including parsing and printing functions.
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
A keymap maps keys typed by the user to commands. This mapping
controls how the user's command input is executed. A keymap is actually
a list whose CAR is the symbol keymap
.
See section 22. Keymaps, for information about creating keymaps, handling prefix keys, local as well as global keymaps, and changing key bindings.
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
An overlay specifies properties that apply to a part of a buffer. Each overlay applies to a specified range of the buffer, and contains a property list (a list whose elements are alternating property names and values). Overlay properties are used to present parts of the buffer temporarily in a different display style. Overlays have no read syntax, and print in hash notation, giving the buffer name and range of positions.
See section 38.9 Overlays, for how to create and use overlays.
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
In Emacs 21, to represent shared or circular structure within a complex of Lisp objects, you can use the reader constructs `#n=' and `#n#'.
Use #n=
before an object to label it for later reference;
subsequently, you can use #n#
to refer the same object in
another place. Here, n is some integer. For example, here is how
to make a list in which the first element recurs as the third element:
(#1=(a) b #1#) |
This differs from ordinary syntax such as this
((a) b (a)) |
which would result in a list whose first and third elements look alike but are not the same Lisp object. This shows the difference:
(prog1 nil (setq x '(#1=(a) b #1#))) (eq (nth 0 x) (nth 2 x)) => t (setq x '((a) b (a))) (eq (nth 0 x) (nth 2 x)) => nil |
You can also use the same syntax to make a circular structure, which appears as an "element" within itself. Here is an example:
#1=(a #1#) |
This makes a list whose second element is the list itself. Here's how you can see that it really works:
(prog1 nil (setq x '#1=(a #1#))) (eq x (cadr x)) => t |
The Lisp printer can produce this syntax to record circular and shared
structure in a Lisp object, if you bind the variable print-circle
to a non-nil
value. See section 19.6 Variables Affecting Output.
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
The Emacs Lisp interpreter itself does not perform type checking on the actual arguments passed to functions when they are called. It could not do so, since function arguments in Lisp do not have declared data types, as they do in other programming languages. It is therefore up to the individual function to test whether each actual argument belongs to a type that the function can use.
All built-in functions do check the types of their actual arguments
when appropriate, and signal a wrong-type-argument
error if an
argument is of the wrong type. For example, here is what happens if you
pass an argument to +
that it cannot handle:
(+ 2 'a) error--> Wrong type argument: number-or-marker-p, a |
If you want your program to handle different types differently, you must do explicit type checking. The most common way to check the type of an object is to call a type predicate function. Emacs has a type predicate for each type, as well as some predicates for combinations of types.
A type predicate function takes one argument; it returns t
if
the argument belongs to the appropriate type, and nil
otherwise.
Following a general Lisp convention for predicate functions, most type
predicates' names end with `p'.
Here is an example which uses the predicates listp
to check for
a list and symbolp
to check for a symbol.
(defun add-on (x) (cond ((symbolp x) ;; If X is a symbol, put it on LIST. (setq list (cons x list))) ((listp x) ;; If X is a list, add its elements to LIST. (setq list (append x list))) (t ;; We handle only symbols and lists. (error "Invalid argument %s in add-on" x)))) |
Here is a table of predefined type predicates, in alphabetical order, with references to further information.
atom
arrayp
bool-vector-p
bufferp
byte-code-function-p
case-table-p
char-or-string-p
char-table-p
commandp
consp
display-table-p
floatp
frame-configuration-p
frame-live-p
framep
functionp
integer-or-marker-p
integerp
keymapp
keywordp
listp
markerp
wholenump
nlistp
numberp
number-or-marker-p
overlayp
processp
sequencep
stringp
subrp
symbolp
syntax-table-p
user-variable-p
vectorp
window-configuration-p
window-live-p
windowp
The most general way to check the type of an object is to call the
function type-of
. Recall that each object belongs to one and
only one primitive type; type-of
tells you which one (see section 2. Lisp Data Types). But type-of
knows nothing about non-primitive
types. In most cases, it is more convenient to use type predicates than
type-of
.
symbol
,
integer
, float
, string
, cons
, vector
,
char-table
, bool-vector
, hash-table
, subr
,
compiled-function
, marker
, overlay
, window
,
buffer
, frame
, process
, or
window-configuration
.
(type-of 1) => integer (type-of 'nil) => symbol (type-of '()) ; |
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
Here we describe two functions that test for equality between any two objects. Other functions test equality between objects of specific types, e.g., strings. For these predicates, see the appropriate chapter describing the data type.
t
if object1 and object2 are
the same object, nil
otherwise. The "same object" means that a
change in one will be reflected by the same change in the other.
eq
returns t
if object1 and object2 are
integers with the same value. Also, since symbol names are normally
unique, if the arguments are symbols with the same name, they are
eq
. For other types (e.g., lists, vectors, strings), two
arguments with the same contents or elements are not necessarily
eq
to each other: they are eq
only if they are the same
object.
(eq 'foo 'foo) => t (eq 456 456) => t (eq "asdf" "asdf") => nil (eq '(1 (2 (3))) '(1 (2 (3)))) => nil (setq foo '(1 (2 (3)))) => (1 (2 (3))) (eq foo foo) => t (eq foo '(1 (2 (3)))) => nil (eq [(1 2) 3] [(1 2) 3]) => nil (eq (point-marker) (point-marker)) => nil |
The make-symbol
function returns an uninterned symbol, distinct
from the symbol that is used if you write the name in a Lisp expression.
Distinct symbols with the same name are not eq
. See section 8.3 Creating and Interning Symbols.
(eq (make-symbol "foo") 'foo) => nil |
t
if object1 and object2 have
equal components, nil
otherwise. Whereas eq
tests if its
arguments are the same object, equal
looks inside nonidentical
arguments to see if their elements or contents are the same. So, if two
objects are eq
, they are equal
, but the converse is not
always true.
(equal 'foo 'foo) => t (equal 456 456) => t (equal "asdf" "asdf") => t (eq "asdf" "asdf") => nil (equal '(1 (2 (3))) '(1 (2 (3)))) => t (eq '(1 (2 (3))) '(1 (2 (3)))) => nil (equal [(1 2) 3] [(1 2) 3]) => t (eq [(1 2) 3] [(1 2) 3]) => nil (equal (point-marker) (point-marker)) => t (eq (point-marker) (point-marker)) => nil |
Comparison of strings is case-sensitive, but does not take account of text properties--it compares only the characters in the strings. A unibyte string never equals a multibyte string unless the contents are entirely ASCII (see section 33.1 Text Representations).
(equal "asdf" "ASDF") => nil |
However, two distinct buffers are never considered equal
, even if
their textual contents are the same.
The test for equality is implemented recursively; for example, given
two cons cells x and y, (equal x y)
returns t
if and only if both the expressions below return
t
:
(equal (car x) (car y)) (equal (cdr x) (cdr y)) |
Because of this recursive method, circular lists may therefore cause infinite recursion (leading to an error).
[ << ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |