Moved legacy code into archive, ready for a new rapid(?) prototype.

I may regret doing this!

archive/c/memory/vectorspace.h

@@ -0,0 +1,121 @@
+/**
+ *  vectorspace.h
+ *
+ *  Declarations common to all vector space objects.
+ *
+ *
+ *  (c) 2017 Simon Brooke <simon@journeyman.cc>
+ *  Licensed under GPL version 2.0, or, at your option, any later version.
+ */
+
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdio.h>
+/*
+ * wide characters
+ */
+#include <wchar.h>
+#include <wctype.h>
+
+#include "consspaceobject.h"
+#include "hashmap.h"
+
+#ifndef __vectorspace_h
+#define __vectorspace_h
+
+/*
+ * part of the implementation structure of a namespace.
+ */
+#define HASHTAG "HASH"
+#define HASHTV 1213415752
+
+#define hashmapp(conspoint)((check_tag(conspoint,HASHTV)))
+
+/*
+ * a namespace (i.e. a binding of names to values, implemented as a hashmap)
+ * TODO: but note that a namespace is now essentially a hashmap with a write ACL
+ * whose name is interned.
+ */
+#define NAMESPACETAG "NMSP"
+#define NAMESPACETV 1347636558
+
+#define namespacep(conspoint)(check_tag(conspoint,NAMESPACETV))
+
+/*
+ * a vector of cons pointers.
+ */
+#define VECTORTAG "VECT"
+#define VECTORTV 1413694806
+
+#define vectorp(conspoint)(check_tag(conspoint,VECTORTV))
+
+/**
+ * given a pointer to a vector space object, return the object.
+ */
+#define pointer_to_vso(pointer)((vectorpointp(pointer)? (struct vector_space_object *) pointer2cell(pointer).payload.vectorp.address : (struct vector_space_object *) NULL))
+
+/**
+ * given a vector space object, return its canonical pointer.
+ */
+#define vso_get_vecp(vso)((((vector_space_object)vso)->header.vecp))
+
+struct cons_pointer make_vso( uint32_t tag, uint64_t payload_size );
+
+void free_vso( struct cons_pointer pointer );
+
+/**
+ * the header which forms the start of every vector space object.
+ */
+struct vector_space_header {
+    /** the tag (type) of this vector-space object. */
+    union {
+        /** the tag considered as bytes. */
+        char bytes[TAGLENGTH];
+        /** the tag considered as a number */
+        uint32_t value;
+    } tag;
+    /** back pointer to the vector pointer which uniquely points to this vso */
+    struct cons_pointer vecp;
+    /** the size of my payload, in bytes */
+    uint64_t size;
+};
+
+/**
+ * The payload of a hashmap. The number of buckets is assigned at run-time,
+ * and is stored in n_buckets. Each bucket is something ASSOC can consume:
+ * i.e. either an assoc list or a further hashmap.
+ */
+struct hashmap_payload {
+    struct cons_pointer hash_fn;  /* function for hashing values in this hashmap, or `NIL` to use
+                                     the default hashing function */
+    struct cons_pointer write_acl;  /* it seems to me that it is likely that the
+                                     * principal difference between a hashmap and a
+                                     * namespace is that a hashmap has a write ACL
+                                     * of `NIL`, meaning not writeable by anyone */
+    uint32_t n_buckets;         /* number of hash buckets */
+    uint32_t unused;            /* for word alignment and possible later expansion */
+    struct cons_pointer buckets[];  /* actual hash buckets, which should be `NIL`
+                                     * or assoc lists or (possibly) further hashmaps. */
+};
+
+
+/** a vector_space_object is just a vector_space_header followed by a
+ * lump of bytes; what we deem to be in there is a function of the tag,
+ * and at this stage we don't have a good picture of what these may be.
+ *
+ * \see stack_frame for an example payload;
+ * \see make_empty_frame for an example of how to initialise and use one.
+ */
+struct vector_space_object {
+    /** the header of this object */
+    struct vector_space_header header;
+    /** we'll malloc `size` bytes for payload, `payload` is just the first of these.
+     * \todo this is almost certainly not idiomatic C. */
+    union {
+        /** the payload considered as bytes */
+        char bytes;
+        struct hashmap_payload hashmap;
+    } payload;
+};
+
+#endif