autoc 1.1 → 1.2

data/test/test_auto.h

@@ -35,13 +35,20 @@
 #include "test.h"
 
 /***
-**** IntStrMap<int,const char*> (AutoC::HashMap)
+****  <int*> (AutoC::Reference)
+***/
+AUTOC_EXTERN int* IntNew();
+AUTOC_EXTERN int* IntRef(int*);
+AUTOC_EXTERN void IntFree(int*);
+
+/***
+**** IntStrMap<int,const char *> (AutoC::HashMap)
 ***/
 
 typedef struct IntStrMapEntry IntStrMapEntry;
 struct IntStrMapEntry {
     int key;
-    const char* value;
+    const char * value;
     unsigned flags;
 };
 
@@ -85,23 +92,30 @@ struct IntStrMapIt {
     IntStrMapSetIt it;
 };
 
+#define _IntStrMapCtor(self) IntStrMapCtor(&self)
+#define _IntStrMapDtor(self) IntStrMapDtor(&self)
+#define _IntStrMapIdentify(self) IntStrMapIdentify(&self)
+#define _IntStrMapCopy(dst,src) IntStrMapCopy(&dst,&src)
+#define _IntStrMapEqual(lt,rt) IntStrMapEqual(&lt,&rt)
+#define _IntStrMapLess(lt,rt) IntStrMapLess(&lt,&rt)
+
 AUTOC_EXTERN void IntStrMapCtor(IntStrMap*);
 AUTOC_EXTERN void IntStrMapDtor(IntStrMap*);
-AUTOC_EXTERN void IntStrMapCopy(IntStrMap*, IntStrMap*);
-AUTOC_EXTERN int IntStrMapEqual(IntStrMap*, IntStrMap*);
+AUTOC_EXTERN void IntStrMapCopy(IntStrMap*,IntStrMap*);
+AUTOC_EXTERN int IntStrMapEqual(IntStrMap*,IntStrMap*);
 AUTOC_EXTERN size_t IntStrMapIdentify(IntStrMap*);
 AUTOC_EXTERN void IntStrMapPurge(IntStrMap*);
 AUTOC_EXTERN size_t IntStrMapSize(IntStrMap*);
 #define IntStrMapEmpty(self) (IntStrMapSize(self) == 0)
 AUTOC_EXTERN int IntStrMapContainsKey(IntStrMap*, int);
-AUTOC_EXTERN const char* IntStrMapGet(IntStrMap*, int);
-AUTOC_EXTERN int IntStrMapPut(IntStrMap*, int, const char*);
-AUTOC_EXTERN int IntStrMapReplace(IntStrMap*, int, const char*);
+AUTOC_EXTERN const char * IntStrMapGet(IntStrMap*, int);
+AUTOC_EXTERN int IntStrMapPut(IntStrMap*, int, const char *);
+AUTOC_EXTERN int IntStrMapReplace(IntStrMap*, int, const char *);
 AUTOC_EXTERN int IntStrMapRemove(IntStrMap*, int);
 AUTOC_EXTERN void IntStrMapItCtor(IntStrMapIt*, IntStrMap*);
 AUTOC_EXTERN int IntStrMapItMove(IntStrMapIt*);
 AUTOC_EXTERN int IntStrMapItGetKey(IntStrMapIt*);
-AUTOC_EXTERN const char* IntStrMapItGetElement(IntStrMapIt*);
+AUTOC_EXTERN const char * IntStrMapItGetElement(IntStrMapIt*);
 #define IntStrMapItGet(it) IntStrMapItGetElement(it)
 
 /***
@@ -139,10 +153,17 @@ struct IntSetIt {
     IntSetListIt it;
 };
 
+#define _IntSetCtor(self) IntSetCtor(&self)
+#define _IntSetDtor(self) IntSetDtor(&self)
+#define _IntSetIdentify(self) IntSetIdentify(&self)
+#define _IntSetCopy(dst,src) IntSetCopy(&dst,&src)
+#define _IntSetEqual(lt,rt) IntSetEqual(&lt,&rt)
+#define _IntSetLess(lt,rt) IntSetLess(&lt,&rt)
+
 AUTOC_EXTERN void IntSetCtor(IntSet*);
 AUTOC_EXTERN void IntSetDtor(IntSet*);
-AUTOC_EXTERN void IntSetCopy(IntSet*, IntSet*);
-AUTOC_EXTERN int IntSetEqual(IntSet*, IntSet*);
+AUTOC_EXTERN void IntSetCopy(IntSet*,IntSet*);
+AUTOC_EXTERN int IntSetEqual(IntSet*,IntSet*);
 AUTOC_EXTERN size_t IntSetIdentify(IntSet*);
 AUTOC_EXTERN void IntSetPurge(IntSet*);
 AUTOC_EXTERN int IntSetContains(IntSet*, int);
@@ -161,158 +182,197 @@ AUTOC_EXTERN int IntSetItMove(IntSetIt*);
 AUTOC_EXTERN int IntSetItGet(IntSetIt*);
 
 /***
-**** ValueTypeQueue<ValueType> (AutoC::Queue)
+**** ValueTypeVector<ValueType> (AutoC::Vector)
 ***/
 
-typedef struct ValueTypeQueueNode ValueTypeQueueNode;
-typedef struct ValueTypeQueue ValueTypeQueue;
-typedef struct ValueTypeQueueIt ValueTypeQueueIt;
-struct ValueTypeQueue {
-    ValueTypeQueueNode* head_node;
-    ValueTypeQueueNode* tail_node;
-    size_t node_count;
-};
-struct ValueTypeQueueIt {
-    int start, forward;
-    ValueTypeQueue* queue;
-    ValueTypeQueueNode* this_node;
+typedef struct ValueTypeVector ValueTypeVector;
+typedef struct ValueTypeVectorIt ValueTypeVectorIt;
+struct ValueTypeVector {
+    ValueType* values;
+    size_t element_count;
 };
-struct ValueTypeQueueNode {
-    ValueType element;
-    ValueTypeQueueNode* prev_node;
-    ValueTypeQueueNode* next_node;
+struct ValueTypeVectorIt {
+    ValueTypeVector* vector;
+    int index;
+    int forward;
 };
 
-AUTOC_EXTERN void ValueTypeQueueCtor(ValueTypeQueue*);
-AUTOC_EXTERN void ValueTypeQueueDtor(ValueTypeQueue*);
-AUTOC_EXTERN void ValueTypeQueueCopy(ValueTypeQueue*, ValueTypeQueue*);
-AUTOC_EXTERN int ValueTypeQueueEqual(ValueTypeQueue*, ValueTypeQueue*);
-AUTOC_EXTERN size_t ValueTypeQueueIdentify(ValueTypeQueue*);
-AUTOC_EXTERN void ValueTypeQueuePurge(ValueTypeQueue*);
-#define ValueTypeQueuePeek(self) ValueTypeQueuePeekHead(self)
-AUTOC_EXTERN ValueType ValueTypeQueuePeekHead(ValueTypeQueue*);
-AUTOC_EXTERN ValueType ValueTypeQueuePeekTail(ValueTypeQueue*);
-#define ValueTypeQueuePush(self, element) ValueTypeQueuePushTail(self, element)
-AUTOC_EXTERN void ValueTypeQueuePushTail(ValueTypeQueue*, ValueType);
-AUTOC_EXTERN void ValueTypeQueuePushHead(ValueTypeQueue*, ValueType);
-#define ValueTypeQueuePop(self) ValueTypeQueuePopHead(self)
-AUTOC_EXTERN ValueType ValueTypeQueuePopHead(ValueTypeQueue*);
-AUTOC_EXTERN ValueType ValueTypeQueuePopTail(ValueTypeQueue*);
-AUTOC_EXTERN int ValueTypeQueueContains(ValueTypeQueue*, ValueType);
-AUTOC_EXTERN ValueType ValueTypeQueueFind(ValueTypeQueue*, ValueType);
-#define ValueTypeQueueReplace(self, with) ValueTypeQueueReplaceEx(self, with, 1)
-#define ValueTypeQueueReplaceAll(self,  with) ValueTypeQueueReplaceEx(self, with, -1)
-AUTOC_EXTERN int ValueTypeQueueReplaceEx(ValueTypeQueue*, ValueType, int);
-#define ValueTypeQueueRemove(self, what) ValueTypeQueueRemoveEx(self, what, 1)
-#define ValueTypeQueueRemoveAll(self, what) ValueTypeQueueRemoveEx(self, what, -1)
-AUTOC_EXTERN int ValueTypeQueueRemoveEx(ValueTypeQueue*, ValueType, int);
-AUTOC_EXTERN size_t ValueTypeQueueSize(ValueTypeQueue*);
-#define ValueTypeQueueEmpty(self) (ValueTypeQueueSize(self) == 0)
-AUTOC_EXTERN void ValueTypeQueueItCtor(ValueTypeQueueIt*, ValueTypeQueue*);
-#define ValueTypeQueueItCtor(self, type) ValueTypeQueueItCtorEx(self, type, 1)
-AUTOC_EXTERN void ValueTypeQueueItCtorEx(ValueTypeQueueIt*, ValueTypeQueue*, int);
-AUTOC_EXTERN int ValueTypeQueueItMove(ValueTypeQueueIt*);
-AUTOC_EXTERN ValueType ValueTypeQueueItGet(ValueTypeQueueIt*);
+#define _ValueTypeVectorCtor(self,element_count) ValueTypeVectorCtor(&self,element_count)
+#define _ValueTypeVectorDtor(self) ValueTypeVectorDtor(&self)
+#define _ValueTypeVectorIdentify(self) ValueTypeVectorIdentify(&self)
+#define _ValueTypeVectorCopy(dst,src) ValueTypeVectorCopy(&dst,&src)
+#define _ValueTypeVectorEqual(lt,rt) ValueTypeVectorEqual(&lt,&rt)
+#define _ValueTypeVectorLess(lt,rt) ValueTypeVectorLess(&lt,&rt)
+
+AUTOC_EXTERN void ValueTypeVectorCtor(ValueTypeVector*,size_t);
+AUTOC_EXTERN void ValueTypeVectorDtor(ValueTypeVector*);
+AUTOC_EXTERN void ValueTypeVectorCopy(ValueTypeVector*,ValueTypeVector*);
+AUTOC_EXTERN int ValueTypeVectorEqual(ValueTypeVector*,ValueTypeVector*);
+AUTOC_EXTERN size_t ValueTypeVectorIdentify(ValueTypeVector*);
+AUTOC_EXTERN void ValueTypeVectorResize(ValueTypeVector*, size_t);
+AUTOC_INLINE size_t ValueTypeVectorSize(ValueTypeVector* self) {
+    assert(self);
+    return self->element_count;
+}
+AUTOC_INLINE int ValueTypeVectorWithin(ValueTypeVector* self, size_t index) {
+    assert(self);
+    return index < ValueTypeVectorSize(self);
+}
+AUTOC_INLINE ValueType ValueTypeVectorGet(ValueTypeVector* self, size_t index) {
+    ValueType result;
+    assert(self);
+    assert(ValueTypeVectorWithin(self, index));
+    ValueTypeCopy(result,self->values[index]);
+    return result;
+}
+AUTOC_INLINE void ValueTypeVectorSet(ValueTypeVector* self, size_t index, ValueType value) {
+    assert(self);
+    assert(ValueTypeVectorWithin(self, index));
+    ValueTypeDtor(self->values[index]);
+    ValueTypeCopy(self->values[index],value);
+}
+#define ValueTypeVectorItCtor(self, type) ValueTypeVectorItCtorEx(self, type, 1)
+AUTOC_INLINE void ValueTypeVectorItCtorEx(ValueTypeVectorIt* self, ValueTypeVector* vector, int forward) {
+    assert(self);
+    assert(vector);
+    self->vector = vector;
+    self->forward = forward;
+    self->index = forward ? -1 : ValueTypeVectorSize(vector);
+}
+AUTOC_INLINE int ValueTypeVectorItMove(ValueTypeVectorIt* self) {
+    assert(self);
+    if(self->forward) ++self->index;
+    else --self->index;
+    return ValueTypeVectorWithin(self->vector, self->index);
+}
+AUTOC_INLINE ValueType ValueTypeVectorItGet(ValueTypeVectorIt* self) {
+    assert(self);
+    return ValueTypeVectorGet(self->vector, self->index);
+}
+
+AUTOC_EXTERN void ValueTypeVectorSort(ValueTypeVector*);
 
 /***
-**** ValueTypeList<ValueType> (AutoC::List)
+**** ListIntSet<IntSet> (AutoC::List)
 ***/
 
-typedef struct ValueTypeListNode ValueTypeListNode;
-typedef struct ValueTypeList ValueTypeList;
-typedef struct ValueTypeListIt ValueTypeListIt;
-struct ValueTypeList {
-    ValueTypeListNode* head_node;
+typedef struct ListIntSetNode ListIntSetNode;
+typedef struct ListIntSet ListIntSet;
+typedef struct ListIntSetIt ListIntSetIt;
+struct ListIntSet {
+    ListIntSetNode* head_node;
     size_t node_count;
 };
-struct ValueTypeListIt {
+struct ListIntSetIt {
     int start;
-    ValueTypeList* list;
-    ValueTypeListNode* this_node;
-};
-struct ValueTypeListNode {
-    ValueType element;
-    ValueTypeListNode* next_node;
-};
-
-AUTOC_EXTERN void ValueTypeListCtor(ValueTypeList*);
-AUTOC_EXTERN void ValueTypeListDtor(ValueTypeList*);
-AUTOC_EXTERN void ValueTypeListCopy(ValueTypeList*, ValueTypeList*);
-AUTOC_EXTERN int ValueTypeListEqual(ValueTypeList*, ValueTypeList*);
-AUTOC_EXTERN size_t ValueTypeListIdentify(ValueTypeList*);
-AUTOC_EXTERN void ValueTypeListPurge(ValueTypeList*);
-AUTOC_EXTERN ValueType ValueTypeListPeek(ValueTypeList*);
-AUTOC_EXTERN ValueType ValueTypeListPop(ValueTypeList*);
-AUTOC_EXTERN void ValueTypeListPush(ValueTypeList*, ValueType);
-AUTOC_EXTERN int ValueTypeListContains(ValueTypeList*, ValueType);
-AUTOC_EXTERN ValueType ValueTypeListFind(ValueTypeList*, ValueType);
-#define ValueTypeListReplace(self, with) ValueTypeListReplaceEx(self, with, 1)
-#define ValueTypeListReplaceAll(self, with) ValueTypeListReplaceEx(self, with, -1)
-AUTOC_EXTERN int ValueTypeListReplaceEx(ValueTypeList*, ValueType, int);
-#define ValueTypeListRemove(self, what) ValueTypeListRemoveEx(self, what, 1)
-#define ValueTypeListRemoveAll(self, what) ValueTypeListRemoveEx(self, what, -1)
-AUTOC_EXTERN int ValueTypeListRemoveEx(ValueTypeList*, ValueType, int);
-AUTOC_EXTERN size_t ValueTypeListSize(ValueTypeList*);
-#define ValueTypeListEmpty(self) (ValueTypeListSize(self) == 0)
-AUTOC_EXTERN void ValueTypeListItCtor(ValueTypeListIt*, ValueTypeList*);
-AUTOC_EXTERN int ValueTypeListItMove(ValueTypeListIt*);
-AUTOC_EXTERN ValueType ValueTypeListItGet(ValueTypeListIt*);
+    ListIntSet* list;
+    ListIntSetNode* this_node;
+};
+struct ListIntSetNode {
+    IntSet element;
+    ListIntSetNode* next_node;
+};
+
+#define _ListIntSetCtor(self) ListIntSetCtor(&self)
+#define _ListIntSetDtor(self) ListIntSetDtor(&self)
+#define _ListIntSetIdentify(self) ListIntSetIdentify(&self)
+#define _ListIntSetCopy(dst,src) ListIntSetCopy(&dst,&src)
+#define _ListIntSetEqual(lt,rt) ListIntSetEqual(&lt,&rt)
+#define _ListIntSetLess(lt,rt) ListIntSetLess(&lt,&rt)
+
+AUTOC_EXTERN void ListIntSetCtor(ListIntSet*);
+AUTOC_EXTERN void ListIntSetDtor(ListIntSet*);
+AUTOC_EXTERN void ListIntSetCopy(ListIntSet*,ListIntSet*);
+AUTOC_EXTERN int ListIntSetEqual(ListIntSet*,ListIntSet*);
+AUTOC_EXTERN size_t ListIntSetIdentify(ListIntSet*);
+AUTOC_EXTERN void ListIntSetPurge(ListIntSet*);
+AUTOC_EXTERN IntSet ListIntSetPeek(ListIntSet*);
+AUTOC_EXTERN IntSet ListIntSetPop(ListIntSet*);
+AUTOC_EXTERN void ListIntSetPush(ListIntSet*, IntSet);
+AUTOC_EXTERN int ListIntSetContains(ListIntSet*, IntSet);
+AUTOC_EXTERN IntSet ListIntSetFind(ListIntSet*, IntSet);
+#define ListIntSetReplace(self, with) ListIntSetReplaceEx(self, with, 1)
+#define ListIntSetReplaceAll(self, with) ListIntSetReplaceEx(self, with, -1)
+AUTOC_EXTERN int ListIntSetReplaceEx(ListIntSet*, IntSet, int);
+#define ListIntSetRemove(self, what) ListIntSetRemoveEx(self, what, 1)
+#define ListIntSetRemoveAll(self, what) ListIntSetRemoveEx(self, what, -1)
+AUTOC_EXTERN int ListIntSetRemoveEx(ListIntSet*, IntSet, int);
+AUTOC_EXTERN size_t ListIntSetSize(ListIntSet*);
+#define ListIntSetEmpty(self) (ListIntSetSize(self) == 0)
+AUTOC_EXTERN void ListIntSetItCtor(ListIntSetIt*, ListIntSet*);
+AUTOC_EXTERN int ListIntSetItMove(ListIntSetIt*);
+AUTOC_EXTERN IntSet ListIntSetItGet(ListIntSetIt*);
 
 /***
-**** ValueTypeSet<ValueType> (AutoC::HashSet)
+**** PIntVector<int*> (AutoC::Vector)
 ***/
 
-typedef struct ValueTypeSetListNode ValueTypeSetListNode;
-typedef struct ValueTypeSetList ValueTypeSetList;
-typedef struct ValueTypeSetListIt ValueTypeSetListIt;
-struct ValueTypeSetList {
-    ValueTypeSetListNode* head_node;
-    size_t node_count;
-};
-struct ValueTypeSetListIt {
-    int start;
-    ValueTypeSetList* list;
-    ValueTypeSetListNode* this_node;
+typedef struct PIntVector PIntVector;
+typedef struct PIntVectorIt PIntVectorIt;
+struct PIntVector {
+    int** values;
+    size_t element_count;
 };
-struct ValueTypeSetListNode {
-    ValueType element;
-    ValueTypeSetListNode* next_node;
+struct PIntVectorIt {
+    PIntVector* vector;
+    int index;
+    int forward;
 };
 
-typedef struct ValueTypeSet ValueTypeSet;
-typedef struct ValueTypeSetIt ValueTypeSetIt;
-struct ValueTypeSet {
-    ValueTypeSetList* buckets;
-    size_t bucket_count, min_bucket_count;
-    size_t size, min_size, max_size;
-    unsigned min_fill, max_fill, capacity_multiplier; /* ?*1e-2 */
-};
-struct ValueTypeSetIt {
-    ValueTypeSet* set;
-    int bucket_index;
-    ValueTypeSetListIt it;
-};
+#define _PIntVectorCtor(self,element_count) PIntVectorCtor(&self,element_count)
+#define _PIntVectorDtor(self) PIntVectorDtor(&self)
+#define _PIntVectorIdentify(self) PIntVectorIdentify(&self)
+#define _PIntVectorCopy(dst,src) PIntVectorCopy(&dst,&src)
+#define _PIntVectorEqual(lt,rt) PIntVectorEqual(&lt,&rt)
+#define _PIntVectorLess(lt,rt) PIntVectorLess(&lt,&rt)
+
+AUTOC_EXTERN void PIntVectorCtor(PIntVector*,size_t);
+AUTOC_EXTERN void PIntVectorDtor(PIntVector*);
+AUTOC_EXTERN void PIntVectorCopy(PIntVector*,PIntVector*);
+AUTOC_EXTERN int PIntVectorEqual(PIntVector*,PIntVector*);
+AUTOC_EXTERN size_t PIntVectorIdentify(PIntVector*);
+AUTOC_EXTERN void PIntVectorResize(PIntVector*, size_t);
+AUTOC_INLINE size_t PIntVectorSize(PIntVector* self) {
+    assert(self);
+    return self->element_count;
+}
+AUTOC_INLINE int PIntVectorWithin(PIntVector* self, size_t index) {
+    assert(self);
+    return index < PIntVectorSize(self);
+}
+AUTOC_INLINE int* PIntVectorGet(PIntVector* self, size_t index) {
+    int* result;
+    assert(self);
+    assert(PIntVectorWithin(self, index));
+    ((result) = IntRef(self->values[index]));
+    return result;
+}
+AUTOC_INLINE void PIntVectorSet(PIntVector* self, size_t index, int* value) {
+    assert(self);
+    assert(PIntVectorWithin(self, index));
+    IntFree(self->values[index]);
+    ((self->values[index]) = IntRef(value));
+}
+#define PIntVectorItCtor(self, type) PIntVectorItCtorEx(self, type, 1)
+AUTOC_INLINE void PIntVectorItCtorEx(PIntVectorIt* self, PIntVector* vector, int forward) {
+    assert(self);
+    assert(vector);
+    self->vector = vector;
+    self->forward = forward;
+    self->index = forward ? -1 : PIntVectorSize(vector);
+}
+AUTOC_INLINE int PIntVectorItMove(PIntVectorIt* self) {
+    assert(self);
+    if(self->forward) ++self->index;
+    else --self->index;
+    return PIntVectorWithin(self->vector, self->index);
+}
+AUTOC_INLINE int* PIntVectorItGet(PIntVectorIt* self) {
+    assert(self);
+    return PIntVectorGet(self->vector, self->index);
+}
 
-AUTOC_EXTERN void ValueTypeSetCtor(ValueTypeSet*);
-AUTOC_EXTERN void ValueTypeSetDtor(ValueTypeSet*);
-AUTOC_EXTERN void ValueTypeSetCopy(ValueTypeSet*, ValueTypeSet*);
-AUTOC_EXTERN int ValueTypeSetEqual(ValueTypeSet*, ValueTypeSet*);
-AUTOC_EXTERN size_t ValueTypeSetIdentify(ValueTypeSet*);
-AUTOC_EXTERN void ValueTypeSetPurge(ValueTypeSet*);
-AUTOC_EXTERN int ValueTypeSetContains(ValueTypeSet*, ValueType);
-AUTOC_EXTERN ValueType ValueTypeSetGet(ValueTypeSet*, ValueType);
-AUTOC_EXTERN size_t ValueTypeSetSize(ValueTypeSet*);
-#define ValueTypeSetEmpty(self) (ValueTypeSetSize(self) == 0)
-AUTOC_EXTERN int ValueTypeSetPut(ValueTypeSet*, ValueType);
-AUTOC_EXTERN int ValueTypeSetReplace(ValueTypeSet*, ValueType);
-AUTOC_EXTERN int ValueTypeSetRemove(ValueTypeSet*, ValueType);
-AUTOC_EXTERN void ValueTypeSetExclude(ValueTypeSet*, ValueTypeSet*);
-AUTOC_EXTERN void ValueTypeSetRetain(ValueTypeSet*, ValueTypeSet*);
-AUTOC_EXTERN void ValueTypeSetInclude(ValueTypeSet*, ValueTypeSet*);
-AUTOC_EXTERN void ValueTypeSetInvert(ValueTypeSet*, ValueTypeSet*);
-AUTOC_EXTERN void ValueTypeSetItCtor(ValueTypeSetIt*, ValueTypeSet*);
-AUTOC_EXTERN int ValueTypeSetItMove(ValueTypeSetIt*);
-AUTOC_EXTERN ValueType ValueTypeSetItGet(ValueTypeSetIt*);
+AUTOC_EXTERN void PIntVectorSort(PIntVector*);
 
 /***
 **** ValueTypeMap<ValueType,ValueType> (AutoC::HashMap)
@@ -365,10 +425,17 @@ struct ValueTypeMapIt {
     ValueTypeMapSetIt it;
 };
 
+#define _ValueTypeMapCtor(self) ValueTypeMapCtor(&self)
+#define _ValueTypeMapDtor(self) ValueTypeMapDtor(&self)
+#define _ValueTypeMapIdentify(self) ValueTypeMapIdentify(&self)
+#define _ValueTypeMapCopy(dst,src) ValueTypeMapCopy(&dst,&src)
+#define _ValueTypeMapEqual(lt,rt) ValueTypeMapEqual(&lt,&rt)
+#define _ValueTypeMapLess(lt,rt) ValueTypeMapLess(&lt,&rt)
+
 AUTOC_EXTERN void ValueTypeMapCtor(ValueTypeMap*);
 AUTOC_EXTERN void ValueTypeMapDtor(ValueTypeMap*);
-AUTOC_EXTERN void ValueTypeMapCopy(ValueTypeMap*, ValueTypeMap*);
-AUTOC_EXTERN int ValueTypeMapEqual(ValueTypeMap*, ValueTypeMap*);
+AUTOC_EXTERN void ValueTypeMapCopy(ValueTypeMap*,ValueTypeMap*);
+AUTOC_EXTERN int ValueTypeMapEqual(ValueTypeMap*,ValueTypeMap*);
 AUTOC_EXTERN size_t ValueTypeMapIdentify(ValueTypeMap*);
 AUTOC_EXTERN void ValueTypeMapPurge(ValueTypeMap*);
 AUTOC_EXTERN size_t ValueTypeMapSize(ValueTypeMap*);
@@ -385,66 +452,314 @@ AUTOC_EXTERN ValueType ValueTypeMapItGetElement(ValueTypeMapIt*);
 #define ValueTypeMapItGet(it) ValueTypeMapItGetElement(it)
 
 /***
-**** ValueTypeVector<ValueType> (AutoC::Vector)
+**** ValueTypeSet<ValueType> (AutoC::HashSet)
 ***/
 
-typedef struct ValueTypeVector ValueTypeVector;
-typedef struct ValueTypeVectorIt ValueTypeVectorIt;
-struct ValueTypeVector {
-    ValueType* values;
+typedef struct ValueTypeSetListNode ValueTypeSetListNode;
+typedef struct ValueTypeSetList ValueTypeSetList;
+typedef struct ValueTypeSetListIt ValueTypeSetListIt;
+struct ValueTypeSetList {
+    ValueTypeSetListNode* head_node;
+    size_t node_count;
+};
+struct ValueTypeSetListIt {
+    int start;
+    ValueTypeSetList* list;
+    ValueTypeSetListNode* this_node;
+};
+struct ValueTypeSetListNode {
+    ValueType element;
+    ValueTypeSetListNode* next_node;
+};
+
+typedef struct ValueTypeSet ValueTypeSet;
+typedef struct ValueTypeSetIt ValueTypeSetIt;
+struct ValueTypeSet {
+    ValueTypeSetList* buckets;
+    size_t bucket_count, min_bucket_count;
+    size_t size, min_size, max_size;
+    unsigned min_fill, max_fill, capacity_multiplier; /* ?*1e-2 */
+};
+struct ValueTypeSetIt {
+    ValueTypeSet* set;
+    int bucket_index;
+    ValueTypeSetListIt it;
+};
+
+#define _ValueTypeSetCtor(self) ValueTypeSetCtor(&self)
+#define _ValueTypeSetDtor(self) ValueTypeSetDtor(&self)
+#define _ValueTypeSetIdentify(self) ValueTypeSetIdentify(&self)
+#define _ValueTypeSetCopy(dst,src) ValueTypeSetCopy(&dst,&src)
+#define _ValueTypeSetEqual(lt,rt) ValueTypeSetEqual(&lt,&rt)
+#define _ValueTypeSetLess(lt,rt) ValueTypeSetLess(&lt,&rt)
+
+AUTOC_EXTERN void ValueTypeSetCtor(ValueTypeSet*);
+AUTOC_EXTERN void ValueTypeSetDtor(ValueTypeSet*);
+AUTOC_EXTERN void ValueTypeSetCopy(ValueTypeSet*,ValueTypeSet*);
+AUTOC_EXTERN int ValueTypeSetEqual(ValueTypeSet*,ValueTypeSet*);
+AUTOC_EXTERN size_t ValueTypeSetIdentify(ValueTypeSet*);
+AUTOC_EXTERN void ValueTypeSetPurge(ValueTypeSet*);
+AUTOC_EXTERN int ValueTypeSetContains(ValueTypeSet*, ValueType);
+AUTOC_EXTERN ValueType ValueTypeSetGet(ValueTypeSet*, ValueType);
+AUTOC_EXTERN size_t ValueTypeSetSize(ValueTypeSet*);
+#define ValueTypeSetEmpty(self) (ValueTypeSetSize(self) == 0)
+AUTOC_EXTERN int ValueTypeSetPut(ValueTypeSet*, ValueType);
+AUTOC_EXTERN int ValueTypeSetReplace(ValueTypeSet*, ValueType);
+AUTOC_EXTERN int ValueTypeSetRemove(ValueTypeSet*, ValueType);
+AUTOC_EXTERN void ValueTypeSetExclude(ValueTypeSet*, ValueTypeSet*);
+AUTOC_EXTERN void ValueTypeSetRetain(ValueTypeSet*, ValueTypeSet*);
+AUTOC_EXTERN void ValueTypeSetInclude(ValueTypeSet*, ValueTypeSet*);
+AUTOC_EXTERN void ValueTypeSetInvert(ValueTypeSet*, ValueTypeSet*);
+AUTOC_EXTERN void ValueTypeSetItCtor(ValueTypeSetIt*, ValueTypeSet*);
+AUTOC_EXTERN int ValueTypeSetItMove(ValueTypeSetIt*);
+AUTOC_EXTERN ValueType ValueTypeSetItGet(ValueTypeSetIt*);
+
+/***
+****  <ValueType*> (AutoC::Reference)
+***/
+AUTOC_EXTERN ValueType* ValueTypeNew();
+AUTOC_EXTERN ValueType* ValueTypeRef(ValueType*);
+AUTOC_EXTERN void ValueTypeFree(ValueType*);
+
+/***
+**** ValueTypeList<ValueType> (AutoC::List)
+***/
+
+typedef struct ValueTypeListNode ValueTypeListNode;
+typedef struct ValueTypeList ValueTypeList;
+typedef struct ValueTypeListIt ValueTypeListIt;
+struct ValueTypeList {
+    ValueTypeListNode* head_node;
+    size_t node_count;
+};
+struct ValueTypeListIt {
+    int start;
+    ValueTypeList* list;
+    ValueTypeListNode* this_node;
+};
+struct ValueTypeListNode {
+    ValueType element;
+    ValueTypeListNode* next_node;
+};
+
+#define _ValueTypeListCtor(self) ValueTypeListCtor(&self)
+#define _ValueTypeListDtor(self) ValueTypeListDtor(&self)
+#define _ValueTypeListIdentify(self) ValueTypeListIdentify(&self)
+#define _ValueTypeListCopy(dst,src) ValueTypeListCopy(&dst,&src)
+#define _ValueTypeListEqual(lt,rt) ValueTypeListEqual(&lt,&rt)
+#define _ValueTypeListLess(lt,rt) ValueTypeListLess(&lt,&rt)
+
+AUTOC_EXTERN void ValueTypeListCtor(ValueTypeList*);
+AUTOC_EXTERN void ValueTypeListDtor(ValueTypeList*);
+AUTOC_EXTERN void ValueTypeListCopy(ValueTypeList*,ValueTypeList*);
+AUTOC_EXTERN int ValueTypeListEqual(ValueTypeList*,ValueTypeList*);
+AUTOC_EXTERN size_t ValueTypeListIdentify(ValueTypeList*);
+AUTOC_EXTERN void ValueTypeListPurge(ValueTypeList*);
+AUTOC_EXTERN ValueType ValueTypeListPeek(ValueTypeList*);
+AUTOC_EXTERN ValueType ValueTypeListPop(ValueTypeList*);
+AUTOC_EXTERN void ValueTypeListPush(ValueTypeList*, ValueType);
+AUTOC_EXTERN int ValueTypeListContains(ValueTypeList*, ValueType);
+AUTOC_EXTERN ValueType ValueTypeListFind(ValueTypeList*, ValueType);
+#define ValueTypeListReplace(self, with) ValueTypeListReplaceEx(self, with, 1)
+#define ValueTypeListReplaceAll(self, with) ValueTypeListReplaceEx(self, with, -1)
+AUTOC_EXTERN int ValueTypeListReplaceEx(ValueTypeList*, ValueType, int);
+#define ValueTypeListRemove(self, what) ValueTypeListRemoveEx(self, what, 1)
+#define ValueTypeListRemoveAll(self, what) ValueTypeListRemoveEx(self, what, -1)
+AUTOC_EXTERN int ValueTypeListRemoveEx(ValueTypeList*, ValueType, int);
+AUTOC_EXTERN size_t ValueTypeListSize(ValueTypeList*);
+#define ValueTypeListEmpty(self) (ValueTypeListSize(self) == 0)
+AUTOC_EXTERN void ValueTypeListItCtor(ValueTypeListIt*, ValueTypeList*);
+AUTOC_EXTERN int ValueTypeListItMove(ValueTypeListIt*);
+AUTOC_EXTERN ValueType ValueTypeListItGet(ValueTypeListIt*);
+
+/***
+**** ValueTypeQueue<ValueType> (AutoC::Queue)
+***/
+
+typedef struct ValueTypeQueueNode ValueTypeQueueNode;
+typedef struct ValueTypeQueue ValueTypeQueue;
+typedef struct ValueTypeQueueIt ValueTypeQueueIt;
+struct ValueTypeQueue {
+    ValueTypeQueueNode* head_node;
+    ValueTypeQueueNode* tail_node;
+    size_t node_count;
+};
+struct ValueTypeQueueIt {
+    int start, forward;
+    ValueTypeQueue* queue;
+    ValueTypeQueueNode* this_node;
+};
+struct ValueTypeQueueNode {
+    ValueType element;
+    ValueTypeQueueNode* prev_node;
+    ValueTypeQueueNode* next_node;
+};
+
+#define _ValueTypeQueueCtor(self) ValueTypeQueueCtor(&self)
+#define _ValueTypeQueueDtor(self) ValueTypeQueueDtor(&self)
+#define _ValueTypeQueueIdentify(self) ValueTypeQueueIdentify(&self)
+#define _ValueTypeQueueCopy(dst,src) ValueTypeQueueCopy(&dst,&src)
+#define _ValueTypeQueueEqual(lt,rt) ValueTypeQueueEqual(&lt,&rt)
+#define _ValueTypeQueueLess(lt,rt) ValueTypeQueueLess(&lt,&rt)
+
+AUTOC_EXTERN void ValueTypeQueueCtor(ValueTypeQueue*);
+AUTOC_EXTERN void ValueTypeQueueDtor(ValueTypeQueue*);
+AUTOC_EXTERN void ValueTypeQueueCopy(ValueTypeQueue*,ValueTypeQueue*);
+AUTOC_EXTERN int ValueTypeQueueEqual(ValueTypeQueue*,ValueTypeQueue*);
+AUTOC_EXTERN size_t ValueTypeQueueIdentify(ValueTypeQueue*);
+AUTOC_EXTERN void ValueTypeQueuePurge(ValueTypeQueue*);
+#define ValueTypeQueuePeek(self) ValueTypeQueuePeekHead(self)
+AUTOC_EXTERN ValueType ValueTypeQueuePeekHead(ValueTypeQueue*);
+AUTOC_EXTERN ValueType ValueTypeQueuePeekTail(ValueTypeQueue*);
+#define ValueTypeQueuePush(self, element) ValueTypeQueuePushTail(self, element)
+AUTOC_EXTERN void ValueTypeQueuePushTail(ValueTypeQueue*, ValueType);
+AUTOC_EXTERN void ValueTypeQueuePushHead(ValueTypeQueue*, ValueType);
+#define ValueTypeQueuePop(self) ValueTypeQueuePopHead(self)
+AUTOC_EXTERN ValueType ValueTypeQueuePopHead(ValueTypeQueue*);
+AUTOC_EXTERN ValueType ValueTypeQueuePopTail(ValueTypeQueue*);
+AUTOC_EXTERN int ValueTypeQueueContains(ValueTypeQueue*, ValueType);
+AUTOC_EXTERN ValueType ValueTypeQueueFind(ValueTypeQueue*, ValueType);
+#define ValueTypeQueueReplace(self, with) ValueTypeQueueReplaceEx(self, with, 1)
+#define ValueTypeQueueReplaceAll(self,  with) ValueTypeQueueReplaceEx(self, with, -1)
+AUTOC_EXTERN int ValueTypeQueueReplaceEx(ValueTypeQueue*, ValueType, int);
+#define ValueTypeQueueRemove(self, what) ValueTypeQueueRemoveEx(self, what, 1)
+#define ValueTypeQueueRemoveAll(self, what) ValueTypeQueueRemoveEx(self, what, -1)
+AUTOC_EXTERN int ValueTypeQueueRemoveEx(ValueTypeQueue*, ValueType, int);
+AUTOC_EXTERN size_t ValueTypeQueueSize(ValueTypeQueue*);
+#define ValueTypeQueueEmpty(self) (ValueTypeQueueSize(self) == 0)
+AUTOC_EXTERN void ValueTypeQueueItCtor(ValueTypeQueueIt*, ValueTypeQueue*);
+#define ValueTypeQueueItCtor(self, type) ValueTypeQueueItCtorEx(self, type, 1)
+AUTOC_EXTERN void ValueTypeQueueItCtorEx(ValueTypeQueueIt*, ValueTypeQueue*, int);
+AUTOC_EXTERN int ValueTypeQueueItMove(ValueTypeQueueIt*);
+AUTOC_EXTERN ValueType ValueTypeQueueItGet(ValueTypeQueueIt*);
+
+/***
+**** PVectorValue<ValueType*> (AutoC::Vector)
+***/
+
+typedef struct PVectorValue PVectorValue;
+typedef struct PVectorValueIt PVectorValueIt;
+struct PVectorValue {
+    ValueType** values;
     size_t element_count;
 };
-struct ValueTypeVectorIt {
-    ValueTypeVector* vector;
+struct PVectorValueIt {
+    PVectorValue* vector;
     int index;
     int forward;
 };
 
-AUTOC_EXTERN void ValueTypeVectorCtor(ValueTypeVector*, size_t);
-AUTOC_EXTERN void ValueTypeVectorDtor(ValueTypeVector*);
-AUTOC_EXTERN void ValueTypeVectorCopy(ValueTypeVector*, ValueTypeVector*);
-AUTOC_EXTERN int ValueTypeVectorEqual(ValueTypeVector*, ValueTypeVector*);
-AUTOC_EXTERN void ValueTypeVectorResize(ValueTypeVector*, size_t);
-AUTOC_EXTERN size_t ValueTypeVectorIdentify(ValueTypeVector*);
-AUTOC_INLINE size_t ValueTypeVectorSize(ValueTypeVector* self) {
+#define _PVectorValueCtor(self,element_count) PVectorValueCtor(&self,element_count)
+#define _PVectorValueDtor(self) PVectorValueDtor(&self)
+#define _PVectorValueIdentify(self) PVectorValueIdentify(&self)
+#define _PVectorValueCopy(dst,src) PVectorValueCopy(&dst,&src)
+#define _PVectorValueEqual(lt,rt) PVectorValueEqual(&lt,&rt)
+#define _PVectorValueLess(lt,rt) PVectorValueLess(&lt,&rt)
+
+AUTOC_EXTERN void PVectorValueCtor(PVectorValue*,size_t);
+AUTOC_EXTERN void PVectorValueDtor(PVectorValue*);
+AUTOC_EXTERN void PVectorValueCopy(PVectorValue*,PVectorValue*);
+AUTOC_EXTERN int PVectorValueEqual(PVectorValue*,PVectorValue*);
+AUTOC_EXTERN size_t PVectorValueIdentify(PVectorValue*);
+AUTOC_EXTERN void PVectorValueResize(PVectorValue*, size_t);
+AUTOC_INLINE size_t PVectorValueSize(PVectorValue* self) {
     assert(self);
     return self->element_count;
 }
-AUTOC_INLINE int ValueTypeVectorWithin(ValueTypeVector* self, size_t index) {
+AUTOC_INLINE int PVectorValueWithin(PVectorValue* self, size_t index) {
     assert(self);
-    return index < ValueTypeVectorSize(self);
+    return index < PVectorValueSize(self);
 }
-AUTOC_INLINE ValueType ValueTypeVectorGet(ValueTypeVector* self, size_t index) {
-    ValueType result;
+AUTOC_INLINE ValueType* PVectorValueGet(PVectorValue* self, size_t index) {
+    ValueType* result;
     assert(self);
-    assert(ValueTypeVectorWithin(self, index));
-    ValueTypeCopy(result, self->values[index]);
+    assert(PVectorValueWithin(self, index));
+    ((result) = ValueTypeRef(self->values[index]));
     return result;
 }
-AUTOC_INLINE void ValueTypeVectorSet(ValueTypeVector* self, size_t index, ValueType value) {
+AUTOC_INLINE void PVectorValueSet(PVectorValue* self, size_t index, ValueType* value) {
     assert(self);
-    assert(ValueTypeVectorWithin(self, index));
-    ValueTypeDtor(self->values[index]);
-    ValueTypeCopy(self->values[index], value);
+    assert(PVectorValueWithin(self, index));
+    ValueTypeFree(self->values[index]);
+    ((self->values[index]) = ValueTypeRef(value));
 }
-AUTOC_EXTERN void ValueTypeVectorSort(ValueTypeVector*);
-#define ValueTypeVectorItCtor(self, type) ValueTypeVectorItCtorEx(self, type, 1)
-AUTOC_INLINE void ValueTypeVectorItCtorEx(ValueTypeVectorIt* self, ValueTypeVector* vector, int forward) {
+#define PVectorValueItCtor(self, type) PVectorValueItCtorEx(self, type, 1)
+AUTOC_INLINE void PVectorValueItCtorEx(PVectorValueIt* self, PVectorValue* vector, int forward) {
     assert(self);
     assert(vector);
     self->vector = vector;
     self->forward = forward;
-    self->index = forward ? -1 : ValueTypeVectorSize(vector);
+    self->index = forward ? -1 : PVectorValueSize(vector);
 }
-AUTOC_INLINE int ValueTypeVectorItMove(ValueTypeVectorIt* self) {
+AUTOC_INLINE int PVectorValueItMove(PVectorValueIt* self) {
     assert(self);
     if(self->forward) ++self->index;
     else --self->index;
-    return ValueTypeVectorWithin(self->vector, self->index);
+    return PVectorValueWithin(self->vector, self->index);
 }
-AUTOC_INLINE ValueType ValueTypeVectorItGet(ValueTypeVectorIt* self) {
+AUTOC_INLINE ValueType* PVectorValueItGet(PVectorValueIt* self) {
     assert(self);
-    return ValueTypeVectorGet(self->vector, self->index);
+    return PVectorValueGet(self->vector, self->index);
 }
 
+AUTOC_EXTERN void PVectorValueSort(PVectorValue*);
+
+/***
+****  <PVectorValue*> (AutoC::Reference)
+***/
+AUTOC_EXTERN PVectorValue* PVectorValueNew(size_t);
+AUTOC_EXTERN PVectorValue* PVectorValueRef(PVectorValue*);
+AUTOC_EXTERN void PVectorValueFree(PVectorValue*);
+
+/***
+**** ListPVectorValue<PVectorValue*> (AutoC::List)
+***/
+
+typedef struct ListPVectorValueNode ListPVectorValueNode;
+typedef struct ListPVectorValue ListPVectorValue;
+typedef struct ListPVectorValueIt ListPVectorValueIt;
+struct ListPVectorValue {
+    ListPVectorValueNode* head_node;
+    size_t node_count;
+};
+struct ListPVectorValueIt {
+    int start;
+    ListPVectorValue* list;
+    ListPVectorValueNode* this_node;
+};
+struct ListPVectorValueNode {
+    PVectorValue* element;
+    ListPVectorValueNode* next_node;
+};
+
+#define _ListPVectorValueCtor(self) ListPVectorValueCtor(&self)
+#define _ListPVectorValueDtor(self) ListPVectorValueDtor(&self)
+#define _ListPVectorValueIdentify(self) ListPVectorValueIdentify(&self)
+#define _ListPVectorValueCopy(dst,src) ListPVectorValueCopy(&dst,&src)
+#define _ListPVectorValueEqual(lt,rt) ListPVectorValueEqual(&lt,&rt)
+#define _ListPVectorValueLess(lt,rt) ListPVectorValueLess(&lt,&rt)
+
+AUTOC_EXTERN void ListPVectorValueCtor(ListPVectorValue*);
+AUTOC_EXTERN void ListPVectorValueDtor(ListPVectorValue*);
+AUTOC_EXTERN void ListPVectorValueCopy(ListPVectorValue*,ListPVectorValue*);
+AUTOC_EXTERN int ListPVectorValueEqual(ListPVectorValue*,ListPVectorValue*);
+AUTOC_EXTERN size_t ListPVectorValueIdentify(ListPVectorValue*);
+AUTOC_EXTERN void ListPVectorValuePurge(ListPVectorValue*);
+AUTOC_EXTERN PVectorValue* ListPVectorValuePeek(ListPVectorValue*);
+AUTOC_EXTERN PVectorValue* ListPVectorValuePop(ListPVectorValue*);
+AUTOC_EXTERN void ListPVectorValuePush(ListPVectorValue*, PVectorValue*);
+AUTOC_EXTERN int ListPVectorValueContains(ListPVectorValue*, PVectorValue*);
+AUTOC_EXTERN PVectorValue* ListPVectorValueFind(ListPVectorValue*, PVectorValue*);
+#define ListPVectorValueReplace(self, with) ListPVectorValueReplaceEx(self, with, 1)
+#define ListPVectorValueReplaceAll(self, with) ListPVectorValueReplaceEx(self, with, -1)
+AUTOC_EXTERN int ListPVectorValueReplaceEx(ListPVectorValue*, PVectorValue*, int);
+#define ListPVectorValueRemove(self, what) ListPVectorValueRemoveEx(self, what, 1)
+#define ListPVectorValueRemoveAll(self, what) ListPVectorValueRemoveEx(self, what, -1)
+AUTOC_EXTERN int ListPVectorValueRemoveEx(ListPVectorValue*, PVectorValue*, int);
+AUTOC_EXTERN size_t ListPVectorValueSize(ListPVectorValue*);
+#define ListPVectorValueEmpty(self) (ListPVectorValueSize(self) == 0)
+AUTOC_EXTERN void ListPVectorValueItCtor(ListPVectorValueIt*, ListPVectorValue*);
+AUTOC_EXTERN int ListPVectorValueItMove(ListPVectorValueIt*);
+AUTOC_EXTERN PVectorValue* ListPVectorValueItGet(ListPVectorValueIt*);
+
 #endif