mirror of https://github.com/texmacs/doc.git
142 lines
5.5 KiB
Tcl
142 lines
5.5 KiB
Tcl
<TeXmacs|1.99.8>
|
|
|
|
<style|<tuple|tmdoc|english|old-spacing>>
|
|
|
|
<\body>
|
|
<tmdoc-title|Basic data types>
|
|
|
|
In this chapter, we give a rough description of <TeXmacs>'s basic data
|
|
types in <verbatim|Basic>. The description of the exported functions is non
|
|
exhaustive and we refer to the corresponding header files for more
|
|
precision.
|
|
|
|
<section|Memory allocation and data structures in TeXmacs>
|
|
|
|
The file <verbatim|fast_alloc.hpp> declares the <TeXmacs> memory allocation
|
|
routines. These routines are very fast for small sizes, since for each such
|
|
size, <TeXmacs> maintains a linked list of freed objects of that size. No
|
|
garbage collection has been implemented yet.
|
|
|
|
Modulo a few exceptions, all <TeXmacs> composite data structures are based
|
|
on the modules <verbatim|concrete>, <verbatim|abstract>,
|
|
<verbatim|concrete_null> and <verbatim|abstract_null>. Consequently, these
|
|
data structures are pointers to representation classes, which may be
|
|
abstract in the case of <verbatim|abstract> and <verbatim|abstract_null>,
|
|
and which always contain a reference counter. Because of the reference
|
|
counter, the C++ copy operator is very fast. Most of the implemented data
|
|
structures also export a function <verbatim|copy>, which should be used if
|
|
one really wants to physically duplicate an object,
|
|
|
|
For classes constructed using <verbatim|concrete_null> or
|
|
<verbatim|abstract_null>, the pointer to the representation class is
|
|
allowed to be <verbatim|NULL> and we have a default constructor which
|
|
initializes this pointer with <verbatim|NULL>. Instances of these classes
|
|
are tested to be <verbatim|NULL> using the function <verbatim|nil>.
|
|
Examples of such classes are lists, files and widgets.
|
|
|
|
<section|Array-like structures>
|
|
|
|
<TeXmacs> implements three \Parray-like\Q structures:
|
|
|
|
<\itemize>
|
|
<item><verbatim|string> is the string type, which may contain '0'
|
|
characters.
|
|
|
|
<item><verbatim|tree> is the tree type with string labels.
|
|
|
|
<item><verbatim|array\<less\>T\<gtr\>> is the generic array type with
|
|
elements of type <verbatim|T>.
|
|
</itemize>
|
|
|
|
Array-like structures export the following operations:
|
|
|
|
<\itemize>
|
|
<item><verbatim|N> computes the length of an array.
|
|
|
|
<item><verbatim|[]> accesses an element.
|
|
|
|
<item><verbatim|\<less\>\<less\>> is used for appending elements or
|
|
arrays.
|
|
</itemize>
|
|
|
|
For trees <verbatim|t>, we notice that <verbatim|t-\<gtr\>label> yields the
|
|
label of the tree and <verbatim|t-\<gtr\>a> the array of its children. The
|
|
second argument of <verbatim|\<less\>\<less\>> for trees is either a tree
|
|
or an array of trees.
|
|
|
|
The implementation has been made such that the <verbatim|\<less\>\<less\>>
|
|
operation is fast, which is useful when considering arrays as buffers.
|
|
Actually, the allocated space for arrays with more than five elements
|
|
(words for strings) is always a power of two, so that new elements can be
|
|
appended quickly. Notice that GNU malloc also always allocates blocks,
|
|
whose sizes are powers of two. Therefore, we do not waste memory for small
|
|
and large arrays.
|
|
|
|
<section|Lists>
|
|
|
|
Generic lists are implemented by the class <verbatim|list\<less\>T\<gtr\>>.
|
|
The \Pnil\Q list is created using <verbatim|list\<less\>T\<gtr\>()>, an
|
|
atom using <verbatim|list\<less\>T\<gtr\>(T x)> and a general list using
|
|
<verbatim|list\<less\>T\<gtr\>(T x, list\<less\>T\<gtr\> next)>. If
|
|
<verbatim|l> is a list, <verbatim|l-\<gtr\>item> and
|
|
<verbatim|l-\<gtr\>next> correspond to its label and its successor
|
|
respectively (<verbatim|car> and <verbatim|cdr> in lisp). The functions
|
|
<verbatim|nil> and <verbatim|atom> tests whether a list is nil or an atom.
|
|
The function <verbatim|N> computes the length of a list.
|
|
|
|
The type <verbatim|list\<less\>T\<gtr\>> is also denoted by
|
|
<verbatim|path>, because some additional functions are defined for it.
|
|
Indeed, paths are used for accessing descendants in tree like structures.
|
|
For instance, we implemented the function <verbatim|tree subtree (tree t,
|
|
path p)>.
|
|
|
|
<section|Hash tables>
|
|
|
|
The <verbatim|hashmap\<less\>T,U\<gtr\>> class implements hash tables with
|
|
entries in <verbatim|T> and values in <verbatim|U>. A function
|
|
<verbatim|hash> should be implemented for <verbatim|T>. Given a hash table
|
|
<verbatim|H>. We set elements through\
|
|
|
|
<\verbatim>
|
|
\ \ \ \ H(x)=y;
|
|
</verbatim>
|
|
|
|
and access to elements through\
|
|
|
|
<\verbatim>
|
|
\ \ \ \ H[x]
|
|
</verbatim>
|
|
|
|
We also implemented a variant <verbatim|rel_hashmap\<less\>T,U\<gtr\>> of
|
|
hash tables, which also have a list-like structure, which makes them useful
|
|
for implementing recursive environments.
|
|
|
|
<section|Other data structures>
|
|
|
|
<\itemize>
|
|
<item><verbatim|command> implements abstract commands.
|
|
|
|
<item><verbatim|file> implements files.
|
|
|
|
<item><verbatim|iterator\<less\>T\<gtr\>> implements generic iterators.
|
|
|
|
<item><verbatim|rectangles> implements rectangles and lists of
|
|
rectangles.
|
|
|
|
<item><verbatim|space> implements stretchable spaces.
|
|
|
|
<item><verbatim|timer> implements timers.
|
|
</itemize>
|
|
|
|
<tmdoc-copyright|1998--2002|Joris van der Hoeven>
|
|
|
|
<tmdoc-license|Permission is granted to copy, distribute and/or modify this
|
|
document under the terms of the GNU Free Documentation License, Version 1.1
|
|
or any later version published by the Free Software Foundation; with no
|
|
Invariant Sections, with no Front-Cover Texts, and with no Back-Cover
|
|
Texts. A copy of the license is included in the section entitled "GNU Free
|
|
Documentation License".>
|
|
</body>
|
|
|
|
<initial|<\collection>
|
|
</collection>> |