elisp: Object Internals
E.8 Object Internals
====================
Emacs Lisp provides a rich set of the data types. Some of them, like
cons cells, integers and strings, are common to nearly all Lisp
dialects. Some others, like markers and buffers, are quite special and
needed to provide the basic support to write editor commands in Lisp.
To implement such a variety of object types and provide an efficient way
to pass objects between the subsystems of an interpreter, there is a set
of C data structures and a special type to represent the pointers to all
of them, which is known as “tagged pointer”.
In C, the tagged pointer is an object of type ‘Lisp_Object’. Any
initialized variable of such a type always holds the value of one of the
following basic data types: integer, symbol, string, cons cell, float,
vectorlike or miscellaneous object. Each of these data types has the
corresponding tag value. All tags are enumerated by ‘enum Lisp_Type’
and placed into a 3-bit bitfield of the ‘Lisp_Object’. The rest of the
bits is the value itself. Integers are immediate, i.e., directly
represented by those “value bits”, and all other objects are represented
by the C pointers to a corresponding object allocated from the heap.
Width of the ‘Lisp_Object’ is platform- and configuration-dependent:
usually it’s equal to the width of an underlying platform pointer (i.e.,
32-bit on a 32-bit machine and 64-bit on a 64-bit one), but also there
is a special configuration where ‘Lisp_Object’ is 64-bit but all
pointers are 32-bit. The latter trick was designed to overcome the
limited range of values for Lisp integers on a 32-bit system by using
64-bit ‘long long’ type for ‘Lisp_Object’.
The following C data structures are defined in ‘lisp.h’ to represent
the basic data types beyond integers:
‘struct Lisp_Cons’
Cons cell, an object used to construct lists.
‘struct Lisp_String’
String, the basic object to represent a sequence of characters.
‘struct Lisp_Vector’
Array, a fixed-size set of Lisp objects which may be accessed by an
index.
‘struct Lisp_Symbol’
Symbol, the unique-named entity commonly used as an identifier.
‘struct Lisp_Float’
Floating-point value.
‘union Lisp_Misc’
Miscellaneous kinds of objects which don’t fit into any of the
above.
These types are the first-class citizens of an internal type system.
Since the tag space is limited, all other types are the subtypes of
either ‘Lisp_Vectorlike’ or ‘Lisp_Misc’. Vector subtypes are enumerated
by ‘enum pvec_type’, and nearly all complex objects like windows,
buffers, frames, and processes fall into this category. The rest of
special types, including markers and overlays, are enumerated by ‘enum
Lisp_Misc_Type’ and form the set of subtypes of ‘Lisp_Misc’.
Below there is a description of a few subtypes of ‘Lisp_Vectorlike’.
Buffer object represents the text to display and edit. Window is the
part of display structure which shows the buffer or used as a container
to recursively place other windows on the same frame. (Do not confuse
Emacs Lisp window object with the window as an entity managed by the
user interface system like X; in Emacs terminology, the latter is called
frame.) Finally, process object is used to manage the subprocesses.
Menu
Info Catalog
elisp: Writing Emacs Primitives
elisp: GNU Emacs Internals
elisp: C Integer Types