17 Miscellaneous Utilities

The MZSCHEME_VERSION preprocessor macro is defined as a string describing the version of Racket. The MZSCHEME_VERSION_MAJOR and MZSCHEME_VERSION_MINOR macros are defined as the major and minor version numbers, respectively.

Returns 1 if the Racket values are equal?.}

Returns the primary equal?-hash key for obj.}

Although the hash table interface uses the type Scheme_Object* for both keys and values, the table functions never inspect values, and they inspect keys only for SCHEME_hash_string hashing. Thus, the actual types of the values (and keys, for SCHEME_hash_ptr tables) can be anything.

The public portion of the Scheme_Hash_Table type is defined roughly as follows:

typedef struct Scheme_Hash_Table {

Scheme_Object so; /* so.type == scheme_hash_table_type */

/* ... */

int size;  /* size of keys and vals arrays */

int count; /* number of mapped keys */

Scheme_Object **keys;

Scheme_Object **vals;

void (*make_hash_indices)(void *v, long *h1, long *h2);

int (*compare)(void *v1, void *v2);

/* ... */

} Scheme_Hash_Table;

The make_hash_indices and compare function pointers can be set to arbitrary hashing and comparison functions (before any mapping is installed into the table). A hash function should fill h1 with a primary hash value and h2 with a secondary hash value; the values are for double-hashing, where the caller takes appropriate modulos. Either h1 or h2 can be NULL if the corresponding hash code is not needed.

To traverse the hash table content, iterate over keys and vals in parallel from 0 to size-1, and ignore keys where the corresponding vals entry is NULL. The count field indicates the number of non-NULL values that will be encountered.

The type argument must be either SCHEME_hash_ptr, SCHEME_hash_string, or SCHEME_hash_weak_ptr. The first two are the same as for hash tables. The last is like SCHEME_hash_ptr, but the keys are weakly held.

The public portion of the Scheme_Bucket_Table type is defined roughly as follows:

typedef struct Scheme_Bucket_Table {

Scheme_Object so; /* so.type == scheme_variable_type */

/* ... */

int size;  /* size of buckets array */

int count; /* number of buckets, >= number of mapped keys */

Scheme_Bucket **buckets;

void (*make_hash_indices)(void *v, long *h1, long *h2);

int (*compare)(void *v1, void *v2);

/* ... */

} Scheme_Bucket_Table;

The make_hash_indices and compare functions are used as for hash tables. Note that SCHEME_hash_weak_ptr supplied as the initial type makes keys weak even if the hash and comparison functions are changed.

See scheme_bucket_from_table for information on buckets.

typedef struct Scheme_Bucket {

Scheme_Object so; /* so.type == scheme_bucket_type */

/* ... */

void *key;

void *val;

} Scheme_Bucket;

Setting val to NULL unmaps the bucket’s key, and key can be NULL in that case as well. If the table holds keys weakly, then key points to a (weak) pointer to the actual key, and the weak pointer’s value can be NULL.