DATA TYPES

All data nodes are effectively cons cells consisting of two pointers and one or two bytes of identification flags (9 or 10 bytes per cell). Node space is managed and garbage collected by XLISP. Array and string storage is either allocated by the C runtime or managed and garbaged collected by XLISP (compilation option). If C does the allocation, memory fragmentation can occur. Fragmentation can be eliminated by saving the image and restarting XLISP-PLUS.

• NIL
  Unlike the original XLISP, NIL is a symbol (although not in the *obarray*), to allowing setting its properties.

• lists
  Either NIL or a CDR-linked list of cons cells, terminated by a symbol (typically NIL). Circular lists are allowable, but can cause problems with some functions so they must be used with care.

• arrays
  The CDR field of an array points to the dynamically allocated data array, while the CAR contains the integer length of the array. Elements in the data array are pointers to other cells [Size limited to about 16360].

• character strings
  Implemented like arrays, except string array is byte indexed and contains the actual characters. Note that unlike the underlying C, the null character (value 0) is valid. [Size limited to about 65500]

• symbols
  Implemented as a 4 element array. The elements are value cell, function cell, property list, and print name (a character string node). Print names are limited to 100 characters. There are also flags for constant and special. Values bound to special symbols (declared with DEFVAR or DEFPARAMETER) are always dynamically bound, rather than being lexically bound.

• fixnums (integers)
  Small integers (> -129 and <256) are statically allocated and are thus always EQ integers of the same value. The CAR field is used to hold the value, which is a 32 bit signed integer.

• ratios
  The CAR field is used to hold the numerator while the CDR field is used to hold the denominator. The numerator is a 32 bit signed value while the denominator is a 31 bit positive value.

• characters
  All characters are statically allocated and are thus EQ characters of the same value. The CAR field is used to hold the value. In XLISP characters are "unsigned" and thus range in value from 0 to 255.

• flonums (floating point numbers)
  The CAR and CDR fields hold the value, which is typically a 64 bit IEEE floating point number.

• complex numbers
  Part of the math extension compilation option. Internally implemented as an array of the real and imaginary parts. The parts can be either both fixnums or both flonums. Any function which would return an fixnum complex number with a zero imaginary part returns just the fixnum.

• objects
  Implemented as an array of instance variable count plus one elements. The first element is the object's class, while the remaining arguments are the instance variables.

• streams (file)
  The CAR and CDR fields are used in a system dependent way as a file pointer.

• streams (unnamed -- string)
  Implemented as a tconc-style list of characters.

• subrs (built-in functions)
  The CAR field points to the actual code to execute, while the CDR field is an internal pointer to the name of the function.

• fsubrs (special forms)
  Same implementation as subrs.

• closures (user defined functions)
  Implemented as an array of 11 elements:

  1. name symbol or NIL

  2. 'lambda or 'macro

  3. list of required arguments

  4. optional arguments as list of (<arg> <init> <specified-p>) triples.

  5. &rest argument

  6. &key arguments as list of (<key> <arg> <init> <specified-p>) quadruples.

  7. &aux arguments as list of (<arg> <init>) pairs.

  8. function body

  9. value environment (see page 86 for format)

  10. function environment

  11. argument list (unprocessed)

• structures
  Implemented as an array with first element being a pointer to the structure name string, and the remaining elements being the structure elements.

• hash-tables
  Implemented as a structure of varying length with no generalized accessing functions, but with a special print function (print functions not available for standard structures).

• random-states
  Implemented as a structure with a single element which is the random state (here a fixnum, but could change without impacting xlisp programs).

• packages
  Implemented using a structure. Packages must only be manipulated with the functions provided.