autoc 1.3 → 1.4

data/test/test_auto.h

@@ -0,0 +1,753 @@
+/* AUTOMATICALLY GENERATED HEADER FILE. DO NOT MODIFY. */
+#ifndef TEST_AUTO_H
+#define TEST_AUTO_H
+#ifndef AUTOC_INLINE
+#if defined(_MSC_VER) || defined(__DMC__)
+#define AUTOC_INLINE AUTOC_STATIC __inline
+#elif defined(__LCC__)
+#define AUTOC_INLINE AUTOC_STATIC /* LCC rejects static __inline */
+#elif __STDC_VERSION__ >= 199901L
+#define AUTOC_INLINE  AUTOC_STATIC inline
+#else
+#define AUTOC_INLINE AUTOC_STATIC
+#endif
+#endif
+#ifndef AUTOC_EXTERN
+#ifdef __cplusplus
+#define AUTOC_EXTERN extern "C"
+#else
+#define AUTOC_EXTERN extern
+#endif
+#endif
+#ifndef AUTOC_STATIC
+#if defined(_MSC_VER)
+#define AUTOC_STATIC __pragma(warning(suppress:4100)) static
+#elif defined(__GNUC__)
+#define AUTOC_STATIC __attribute__((__used__)) static
+#else
+#define AUTOC_STATIC static
+#endif
+#endif
+#include <stddef.h>
+#include <stdlib.h>
+#include <assert.h>
+/***
+**** CharString<char>
+***/
+typedef struct CharStringListNode CharStringListNode;
+typedef struct CharStringList CharStringList;
+typedef struct CharStringListIt CharStringListIt;
+struct CharStringList {
+    CharStringListNode* head_node;
+    size_t node_count;
+};
+struct CharStringListIt {
+    int start;
+    CharStringList* list;
+    CharStringListNode* this_node;
+};
+struct CharStringListNode {
+    char* element;
+    CharStringListNode* next_node;
+};
+typedef struct CharString CharString;
+typedef struct CharStringIt CharStringIt;
+struct CharString {
+    size_t size;
+    union data {
+        char* string;
+        CharStringList list;
+    } data;
+    int is_list;
+};
+struct CharStringIt {
+    CharString* string;
+    int index, forward;
+};
+#define _CharStringCtor(self,chars) CharStringCtor(&self,chars)
+#define _CharStringDtor(self) CharStringDtor(&self)
+#define _CharStringIdentify(self) CharStringIdentify(&self)
+#define _CharStringCopy(dst,src) CharStringCopy(&dst,&src)
+#define _CharStringEqual(lt,rt) CharStringEqual(&lt,&rt)
+#define _CharStringLess(lt,rt) CharStringLess(&lt,&rt)
+#include <string.h>
+#ifdef AUTOC_BUFFER_SIZE
+#define _CharStringBufferSize AUTOC_BUFFER_SIZE
+#else
+#define _CharStringBufferSize 4096 /* Stay in sync with the documentation! */
+#endif
+#define CharStringJoin(self) if(self->is_list) _CharStringJoin(self);
+#define CharStringSplit(self) if(!self->is_list) _CharStringSplit(self);
+AUTOC_EXTERN void _CharStringJoin(CharString*);
+AUTOC_EXTERN void _CharStringSplit(CharString*);
+AUTOC_EXTERN void CharStringCtor(CharString*,const char*);
+AUTOC_EXTERN void CharStringDtor(CharString*);
+AUTOC_EXTERN void CharStringCopy(CharString*,CharString*);
+AUTOC_EXTERN void CharStringCopyRange(CharString*, CharString*, size_t, size_t);
+AUTOC_EXTERN int CharStringEqual(CharString*,CharString*);
+AUTOC_EXTERN size_t CharStringIdentify(CharString*);
+#define CharStringEmpty(self) (CharStringSize(self) == 0)
+AUTOC_INLINE size_t CharStringSize(CharString* self) {
+    assert(self);
+    /* CharStringJoin(self); assuming the changes to the contents are reflected in the size */
+#ifndef NDEBUG
+    /* Type invariants which must hold true */
+    if(!self->is_list) assert(self->size == strlen(self->data.string));
+    /* TODO self->is_list case */
+#endif
+    return self->size;
+}
+AUTOC_INLINE int CharStringWithin(CharString* self, size_t index) {
+    assert(self);
+    /* Omitting excessive call to CharStringJoin() */
+    return index < CharStringSize(self);
+}
+AUTOC_INLINE char CharStringGet(CharString* self, size_t index) {
+    assert(self);
+    assert(CharStringWithin(self, index));
+    CharStringJoin(self);
+    return self->data.string[index];
+}
+AUTOC_INLINE void CharStringSet(CharString* self, size_t index, char value) {
+    assert(self);
+    assert(CharStringWithin(self, index));
+    CharStringJoin(self);
+    self->data.string[index] = value;
+}
+AUTOC_INLINE const char* CharStringChars(CharString* self) {
+    assert(self);
+    CharStringJoin(self);
+    return self->data.string;
+}
+AUTOC_EXTERN int CharStringPushFormat(CharString*, const char*, ...);
+AUTOC_EXTERN void CharStringPushChars(CharString*, const char*);
+AUTOC_EXTERN void CharStringPushString(CharString*, CharString*);
+#define CharStringPushChar(self, c) CharStringPushFormat(self, "%c", (char)(c))
+#define CharStringPushInt(self, i) CharStringPushFormat(self, "%d", (int)(i))
+#define CharStringPushFloat(self, f) CharStringPushFormat(self, "%e", (double)(f))
+#define CharStringPushPtr(self, p) CharStringPushFormat(self, "%p", (void*)(p))
+#define CharStringItCtor(self, type) CharStringItCtorEx(self, type, 1)
+AUTOC_INLINE void CharStringItCtorEx(CharStringIt* self, CharString* string, int forward) {
+    assert(self);
+    assert(string);
+    self->string = string;
+    self->forward = forward;
+    self->index = forward ? -1 : CharStringSize(string);
+}
+AUTOC_INLINE int CharStringItMove(CharStringIt* self) {
+    assert(self);
+    if(self->forward) ++self->index;
+    else --self->index;
+    return CharStringWithin(self->string, self->index);
+}
+AUTOC_INLINE char CharStringItGet(CharStringIt* self) {
+    assert(self);
+    return CharStringGet(self->string, self->index);
+}
+typedef struct {
+    int* value;
+} Value;
+#define ValueCtor(self) _ValueCtor(&self)
+#define ValueCtorEx(self, v) _ValueCtorEx(&self, v)
+#define ValueDtor(self) _ValueDtor(&self)
+#define ValueCopy(dst, src) _ValueCopy(&dst, &src)
+#define ValueEqual(lt, rt) _ValueEqual(&lt, &rt)
+#define ValueLess(lt, rt) _ValueLess(&lt, &rt)
+#define ValueIdentify(self) _ValueIdentify(&self)
+#define ValueGet(self) *(self).value
+#define ValueSet(self, x) *(self).value = (x)
+void _ValueCtor(Value*);
+void _ValueCtorEx(Value*, int);
+void _ValueDtor(Value*);
+void _ValueCopy(Value*, Value*);
+int _ValueEqual(Value*, Value*);
+int _ValueLess(Value*, Value*);
+size_t _ValueIdentify(Value*);
+/***
+**** IntList<int>
+***/
+typedef struct IntListNode IntListNode;
+typedef struct IntList IntList;
+typedef struct IntListIt IntListIt;
+struct IntList {
+    IntListNode* head_node;
+    size_t node_count;
+};
+struct IntListIt {
+    int start;
+    IntList* list;
+    IntListNode* this_node;
+};
+struct IntListNode {
+    int element;
+    IntListNode* next_node;
+};
+#define _IntListCtor(self) IntListCtor(&self)
+#define _IntListDtor(self) IntListDtor(&self)
+#define _IntListIdentify(self) IntListIdentify(&self)
+#define _IntListCopy(dst,src) IntListCopy(&dst,&src)
+#define _IntListEqual(lt,rt) IntListEqual(&lt,&rt)
+#define _IntListLess(lt,rt) IntListLess(&lt,&rt)
+AUTOC_EXTERN void IntListItCtor(IntListIt*, IntList*);
+AUTOC_EXTERN int IntListItMove(IntListIt*);
+AUTOC_EXTERN int IntListItGet(IntListIt*);
+AUTOC_EXTERN void IntListCtor(IntList*);
+AUTOC_EXTERN void IntListDtor(IntList*);
+AUTOC_EXTERN void IntListCopy(IntList*,IntList*);
+AUTOC_EXTERN int IntListEqual(IntList*,IntList*);
+AUTOC_EXTERN size_t IntListIdentify(IntList*);
+AUTOC_EXTERN void IntListPurge(IntList*);
+AUTOC_EXTERN int IntListPeek(IntList*);
+AUTOC_EXTERN int IntListPop(IntList*);
+AUTOC_EXTERN void IntListPush(IntList*, int);
+AUTOC_EXTERN int IntListContains(IntList*, int);
+AUTOC_EXTERN int IntListFind(IntList*, int);
+#define IntListReplace(self, with) IntListReplaceEx(self, with, 1)
+#define IntListReplaceAll(self, with) IntListReplaceEx(self, with, -1)
+AUTOC_EXTERN int IntListReplaceEx(IntList*, int, int);
+#define IntListRemove(self, what) IntListRemoveEx(self, what, 1)
+#define IntListRemoveAll(self, what) IntListRemoveEx(self, what, -1)
+AUTOC_EXTERN int IntListRemoveEx(IntList*, int, int);
+AUTOC_EXTERN size_t IntListSize(IntList*);
+#define IntListEmpty(self) (IntListSize(self) == 0)
+/***
+**** IntTreeSet<int>
+***/
+typedef struct IntTreeSet IntTreeSet;
+typedef struct IntTreeSetNode IntTreeSetNode;
+typedef struct IntTreeSetIt IntTreeSetIt;
+struct IntTreeSet {
+    IntTreeSetNode* root;
+    size_t size;
+};
+struct IntTreeSetIt {
+    int start, ascending;
+    IntTreeSetNode* node;
+};
+struct IntTreeSetNode {
+    int color;
+    IntTreeSetNode* left;
+    IntTreeSetNode* right;
+    IntTreeSetNode* parent;
+    int element;
+};
+#define _IntTreeSetCtor(self) IntTreeSetCtor(&self)
+#define _IntTreeSetDtor(self) IntTreeSetDtor(&self)
+#define _IntTreeSetIdentify(self) IntTreeSetIdentify(&self)
+#define _IntTreeSetCopy(dst,src) IntTreeSetCopy(&dst,&src)
+#define _IntTreeSetEqual(lt,rt) IntTreeSetEqual(&lt,&rt)
+#define _IntTreeSetLess(lt,rt) IntTreeSetLess(&lt,&rt)
+AUTOC_EXTERN void IntTreeSetCtor(IntTreeSet*);
+AUTOC_EXTERN void IntTreeSetDtor(IntTreeSet*);
+AUTOC_EXTERN void IntTreeSetCopy(IntTreeSet*,IntTreeSet*);
+AUTOC_EXTERN int IntTreeSetEqual(IntTreeSet*,IntTreeSet*);
+AUTOC_EXTERN size_t IntTreeSetIdentify(IntTreeSet*);
+AUTOC_EXTERN void IntTreeSetPurge(IntTreeSet*);
+AUTOC_EXTERN int IntTreeSetContains(IntTreeSet*, int);
+AUTOC_EXTERN int IntTreeSetGet(IntTreeSet*, int);
+AUTOC_EXTERN size_t IntTreeSetSize(IntTreeSet*);
+#define IntTreeSetEmpty(self) (IntTreeSetSize(self) == 0)
+AUTOC_EXTERN int IntTreeSetPut(IntTreeSet*, int);
+AUTOC_EXTERN int IntTreeSetReplace(IntTreeSet*, int);
+AUTOC_EXTERN int IntTreeSetRemove(IntTreeSet*, int);
+AUTOC_EXTERN void IntTreeSetExclude(IntTreeSet*, IntTreeSet*);
+AUTOC_EXTERN void IntTreeSetRetain(IntTreeSet*, IntTreeSet*);
+AUTOC_EXTERN void IntTreeSetInclude(IntTreeSet*, IntTreeSet*);
+AUTOC_EXTERN void IntTreeSetInvert(IntTreeSet*, IntTreeSet*);
+AUTOC_EXTERN void IntTreeSetItCtor(IntTreeSetIt*, IntTreeSet*);
+#define IntTreeSetItCtor(self, type) IntTreeSetItCtorEx(self, type, 1)
+AUTOC_EXTERN void IntTreeSetItCtorEx(IntTreeSetIt*, IntTreeSet*, int);
+AUTOC_EXTERN int IntTreeSetItMove(IntTreeSetIt*);
+AUTOC_EXTERN int IntTreeSetItGet(IntTreeSetIt*);
+AUTOC_EXTERN int IntTreeSetPeekLowest(IntTreeSet*);
+AUTOC_EXTERN int IntTreeSetPeekHighest(IntTreeSet*);
+/***
+**** ValueHashSet<Value>
+***/
+typedef struct ValueHashSetListNode ValueHashSetListNode;
+typedef struct ValueHashSetList ValueHashSetList;
+typedef struct ValueHashSetListIt ValueHashSetListIt;
+struct ValueHashSetList {
+    ValueHashSetListNode* head_node;
+    size_t node_count;
+};
+struct ValueHashSetListIt {
+    int start;
+    ValueHashSetList* list;
+    ValueHashSetListNode* this_node;
+};
+struct ValueHashSetListNode {
+    Value element;
+    ValueHashSetListNode* next_node;
+};
+typedef struct ValueHashSet ValueHashSet;
+typedef struct ValueHashSetIt ValueHashSetIt;
+struct ValueHashSet {
+    ValueHashSetList* 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 ValueHashSetIt {
+    ValueHashSet* set;
+    size_t bucket_index;
+    ValueHashSetListIt it;
+};
+#define _ValueHashSetCtor(self) ValueHashSetCtor(&self)
+#define _ValueHashSetDtor(self) ValueHashSetDtor(&self)
+#define _ValueHashSetIdentify(self) ValueHashSetIdentify(&self)
+#define _ValueHashSetCopy(dst,src) ValueHashSetCopy(&dst,&src)
+#define _ValueHashSetEqual(lt,rt) ValueHashSetEqual(&lt,&rt)
+#define _ValueHashSetLess(lt,rt) ValueHashSetLess(&lt,&rt)
+AUTOC_EXTERN void ValueHashSetCtor(ValueHashSet*);
+AUTOC_EXTERN void ValueHashSetDtor(ValueHashSet*);
+AUTOC_EXTERN void ValueHashSetCopy(ValueHashSet*,ValueHashSet*);
+AUTOC_EXTERN int ValueHashSetEqual(ValueHashSet*,ValueHashSet*);
+AUTOC_EXTERN size_t ValueHashSetIdentify(ValueHashSet*);
+AUTOC_EXTERN void ValueHashSetPurge(ValueHashSet*);
+AUTOC_EXTERN int ValueHashSetContains(ValueHashSet*, Value);
+AUTOC_EXTERN Value ValueHashSetGet(ValueHashSet*, Value);
+AUTOC_EXTERN size_t ValueHashSetSize(ValueHashSet*);
+#define ValueHashSetEmpty(self) (ValueHashSetSize(self) == 0)
+AUTOC_EXTERN int ValueHashSetPut(ValueHashSet*, Value);
+AUTOC_EXTERN int ValueHashSetReplace(ValueHashSet*, Value);
+AUTOC_EXTERN int ValueHashSetRemove(ValueHashSet*, Value);
+AUTOC_EXTERN void ValueHashSetExclude(ValueHashSet*, ValueHashSet*);
+AUTOC_EXTERN void ValueHashSetRetain(ValueHashSet*, ValueHashSet*);
+AUTOC_EXTERN void ValueHashSetInclude(ValueHashSet*, ValueHashSet*);
+AUTOC_EXTERN void ValueHashSetInvert(ValueHashSet*, ValueHashSet*);
+AUTOC_EXTERN void ValueHashSetItCtor(ValueHashSetIt*, ValueHashSet*);
+AUTOC_EXTERN int ValueHashSetItMove(ValueHashSetIt*);
+AUTOC_EXTERN Value ValueHashSetItGet(ValueHashSetIt*);
+/***
+**** ValueVector<Value>
+***/
+typedef struct ValueVector ValueVector;
+typedef struct ValueVectorIt ValueVectorIt;
+struct ValueVector {
+    Value* values;
+    size_t element_count;
+};
+struct ValueVectorIt {
+    ValueVector* vector;
+    int index, forward;
+};
+#define _ValueVectorCtor(self,element_count) ValueVectorCtor(&self,element_count)
+#define _ValueVectorDtor(self) ValueVectorDtor(&self)
+#define _ValueVectorIdentify(self) ValueVectorIdentify(&self)
+#define _ValueVectorCopy(dst,src) ValueVectorCopy(&dst,&src)
+#define _ValueVectorEqual(lt,rt) ValueVectorEqual(&lt,&rt)
+#define _ValueVectorLess(lt,rt) ValueVectorLess(&lt,&rt)
+AUTOC_INLINE void ValueVectorItCtor(ValueVectorIt*, ValueVector*);
+#define ValueVectorItCtor(self, type) ValueVectorItCtorEx(self, type, 1)
+AUTOC_INLINE void ValueVectorItCtorEx(ValueVectorIt*, ValueVector*, int);
+AUTOC_INLINE int ValueVectorItMove(ValueVectorIt*);
+AUTOC_INLINE Value ValueVectorItGet(ValueVectorIt*);
+AUTOC_EXTERN void ValueVectorCtor(ValueVector*,size_t);
+AUTOC_EXTERN void ValueVectorDtor(ValueVector*);
+AUTOC_EXTERN void ValueVectorCopy(ValueVector*,ValueVector*);
+/* TODO ValueVectorCopyRange() */
+AUTOC_EXTERN int ValueVectorEqual(ValueVector*,ValueVector*);
+AUTOC_EXTERN size_t ValueVectorIdentify(ValueVector*);
+AUTOC_EXTERN void ValueVectorResize(ValueVector*, size_t);
+AUTOC_INLINE size_t ValueVectorSize(ValueVector* self) {
+    assert(self);
+    return self->element_count;
+}
+AUTOC_INLINE int ValueVectorWithin(ValueVector* self, size_t index) {
+    assert(self);
+    return index < ValueVectorSize(self);
+}
+AUTOC_INLINE Value ValueVectorGet(ValueVector* self, size_t index) {
+    Value result;
+    assert(self);
+    assert(ValueVectorWithin(self, index));
+    ValueCopy(result,self->values[index]);
+    return result;
+}
+AUTOC_INLINE void ValueVectorSet(ValueVector* self, size_t index, Value value) {
+    assert(self);
+    assert(ValueVectorWithin(self, index));
+    ValueDtor(self->values[index]);
+    ValueCopy(self->values[index],value);
+}
+AUTOC_INLINE void ValueVectorItCtorEx(ValueVectorIt* self, ValueVector* vector, int forward) {
+    assert(self);
+    assert(vector);
+    self->vector = vector;
+    self->forward = forward;
+    self->index = forward ? -1 : ValueVectorSize(vector);
+}
+AUTOC_INLINE int ValueVectorItMove(ValueVectorIt* self) {
+    assert(self);
+    if(self->forward) ++self->index;
+    else --self->index;
+    return ValueVectorWithin(self->vector, self->index);
+}
+AUTOC_INLINE Value ValueVectorItGet(ValueVectorIt* self) {
+    assert(self);
+    return ValueVectorGet(self->vector, self->index);
+}
+#define ValueVectorSort(self) ValueVectorSortEx(self, 1)
+AUTOC_EXTERN void ValueVectorSortEx(ValueVector*, int);
+/***
+**** ValueList<Value>
+***/
+typedef struct ValueListNode ValueListNode;
+typedef struct ValueList ValueList;
+typedef struct ValueListIt ValueListIt;
+struct ValueList {
+    ValueListNode* head_node;
+    size_t node_count;
+};
+struct ValueListIt {
+    int start;
+    ValueList* list;
+    ValueListNode* this_node;
+};
+struct ValueListNode {
+    Value element;
+    ValueListNode* next_node;
+};
+#define _ValueListCtor(self) ValueListCtor(&self)
+#define _ValueListDtor(self) ValueListDtor(&self)
+#define _ValueListIdentify(self) ValueListIdentify(&self)
+#define _ValueListCopy(dst,src) ValueListCopy(&dst,&src)
+#define _ValueListEqual(lt,rt) ValueListEqual(&lt,&rt)
+#define _ValueListLess(lt,rt) ValueListLess(&lt,&rt)
+AUTOC_EXTERN void ValueListItCtor(ValueListIt*, ValueList*);
+AUTOC_EXTERN int ValueListItMove(ValueListIt*);
+AUTOC_EXTERN Value ValueListItGet(ValueListIt*);
+AUTOC_EXTERN void ValueListCtor(ValueList*);
+AUTOC_EXTERN void ValueListDtor(ValueList*);
+AUTOC_EXTERN void ValueListCopy(ValueList*,ValueList*);
+AUTOC_EXTERN int ValueListEqual(ValueList*,ValueList*);
+AUTOC_EXTERN size_t ValueListIdentify(ValueList*);
+AUTOC_EXTERN void ValueListPurge(ValueList*);
+AUTOC_EXTERN Value ValueListPeek(ValueList*);
+AUTOC_EXTERN Value ValueListPop(ValueList*);
+AUTOC_EXTERN void ValueListPush(ValueList*, Value);
+AUTOC_EXTERN int ValueListContains(ValueList*, Value);
+AUTOC_EXTERN Value ValueListFind(ValueList*, Value);
+#define ValueListReplace(self, with) ValueListReplaceEx(self, with, 1)
+#define ValueListReplaceAll(self, with) ValueListReplaceEx(self, with, -1)
+AUTOC_EXTERN int ValueListReplaceEx(ValueList*, Value, int);
+#define ValueListRemove(self, what) ValueListRemoveEx(self, what, 1)
+#define ValueListRemoveAll(self, what) ValueListRemoveEx(self, what, -1)
+AUTOC_EXTERN int ValueListRemoveEx(ValueList*, Value, int);
+AUTOC_EXTERN size_t ValueListSize(ValueList*);
+#define ValueListEmpty(self) (ValueListSize(self) == 0)
+/***
+**** IntVector<int>
+***/
+typedef struct IntVector IntVector;
+typedef struct IntVectorIt IntVectorIt;
+struct IntVector {
+    int* values;
+    size_t element_count;
+};
+struct IntVectorIt {
+    IntVector* vector;
+    int index, forward;
+};
+#define _IntVectorCtor(self,element_count) IntVectorCtor(&self,element_count)
+#define _IntVectorDtor(self) IntVectorDtor(&self)
+#define _IntVectorIdentify(self) IntVectorIdentify(&self)
+#define _IntVectorCopy(dst,src) IntVectorCopy(&dst,&src)
+#define _IntVectorEqual(lt,rt) IntVectorEqual(&lt,&rt)
+#define _IntVectorLess(lt,rt) IntVectorLess(&lt,&rt)
+AUTOC_INLINE void IntVectorItCtor(IntVectorIt*, IntVector*);
+#define IntVectorItCtor(self, type) IntVectorItCtorEx(self, type, 1)
+AUTOC_INLINE void IntVectorItCtorEx(IntVectorIt*, IntVector*, int);
+AUTOC_INLINE int IntVectorItMove(IntVectorIt*);
+AUTOC_INLINE int IntVectorItGet(IntVectorIt*);
+AUTOC_EXTERN void IntVectorCtor(IntVector*,size_t);
+AUTOC_EXTERN void IntVectorDtor(IntVector*);
+AUTOC_EXTERN void IntVectorCopy(IntVector*,IntVector*);
+/* TODO IntVectorCopyRange() */
+AUTOC_EXTERN int IntVectorEqual(IntVector*,IntVector*);
+AUTOC_EXTERN size_t IntVectorIdentify(IntVector*);
+AUTOC_EXTERN void IntVectorResize(IntVector*, size_t);
+AUTOC_INLINE size_t IntVectorSize(IntVector* self) {
+    assert(self);
+    return self->element_count;
+}
+AUTOC_INLINE int IntVectorWithin(IntVector* self, size_t index) {
+    assert(self);
+    return index < IntVectorSize(self);
+}
+AUTOC_INLINE int IntVectorGet(IntVector* self, size_t index) {
+    int result;
+    assert(self);
+    assert(IntVectorWithin(self, index));
+    ((result) = (self->values[index]));
+    return result;
+}
+AUTOC_INLINE void IntVectorSet(IntVector* self, size_t index, int value) {
+    assert(self);
+    assert(IntVectorWithin(self, index));
+    ;
+    ((self->values[index]) = (value));
+}
+AUTOC_INLINE void IntVectorItCtorEx(IntVectorIt* self, IntVector* vector, int forward) {
+    assert(self);
+    assert(vector);
+    self->vector = vector;
+    self->forward = forward;
+    self->index = forward ? -1 : IntVectorSize(vector);
+}
+AUTOC_INLINE int IntVectorItMove(IntVectorIt* self) {
+    assert(self);
+    if(self->forward) ++self->index;
+    else --self->index;
+    return IntVectorWithin(self->vector, self->index);
+}
+AUTOC_INLINE int IntVectorItGet(IntVectorIt* self) {
+    assert(self);
+    return IntVectorGet(self->vector, self->index);
+}
+#define IntVectorSort(self) IntVectorSortEx(self, 1)
+AUTOC_EXTERN void IntVectorSortEx(IntVector*, int);
+/***
+**** ValueQueue<Value>
+***/
+typedef struct ValueQueueNode ValueQueueNode;
+typedef struct ValueQueue ValueQueue;
+typedef struct ValueQueueIt ValueQueueIt;
+struct ValueQueue {
+    ValueQueueNode* head_node;
+    ValueQueueNode* tail_node;
+    size_t node_count;
+};
+struct ValueQueueIt {
+    int start, forward;
+    ValueQueue* queue;
+    ValueQueueNode* this_node;
+};
+struct ValueQueueNode {
+    Value element;
+    ValueQueueNode* prev_node;
+    ValueQueueNode* next_node;
+};
+#define _ValueQueueCtor(self) ValueQueueCtor(&self)
+#define _ValueQueueDtor(self) ValueQueueDtor(&self)
+#define _ValueQueueIdentify(self) ValueQueueIdentify(&self)
+#define _ValueQueueCopy(dst,src) ValueQueueCopy(&dst,&src)
+#define _ValueQueueEqual(lt,rt) ValueQueueEqual(&lt,&rt)
+#define _ValueQueueLess(lt,rt) ValueQueueLess(&lt,&rt)
+AUTOC_EXTERN void ValueQueueItCtor(ValueQueueIt*, ValueQueue*);
+#define ValueQueueItCtor(self, type) ValueQueueItCtorEx(self, type, 1)
+AUTOC_EXTERN void ValueQueueItCtorEx(ValueQueueIt*, ValueQueue*, int);
+AUTOC_EXTERN int ValueQueueItMove(ValueQueueIt*);
+AUTOC_EXTERN Value ValueQueueItGet(ValueQueueIt*);
+AUTOC_EXTERN void ValueQueueCtor(ValueQueue*);
+AUTOC_EXTERN void ValueQueueDtor(ValueQueue*);
+AUTOC_EXTERN void ValueQueueCopy(ValueQueue*,ValueQueue*);
+AUTOC_EXTERN int ValueQueueEqual(ValueQueue*,ValueQueue*);
+AUTOC_EXTERN size_t ValueQueueIdentify(ValueQueue*);
+AUTOC_EXTERN void ValueQueuePurge(ValueQueue*);
+#define ValueQueuePeek(self) ValueQueuePeekHead(self)
+AUTOC_EXTERN Value ValueQueuePeekHead(ValueQueue*);
+AUTOC_EXTERN Value ValueQueuePeekTail(ValueQueue*);
+#define ValueQueuePush(self, element) ValueQueuePushTail(self, element)
+AUTOC_EXTERN void ValueQueuePushTail(ValueQueue*, Value);
+AUTOC_EXTERN void ValueQueuePushHead(ValueQueue*, Value);
+#define ValueQueuePop(self) ValueQueuePopHead(self)
+AUTOC_EXTERN Value ValueQueuePopHead(ValueQueue*);
+AUTOC_EXTERN Value ValueQueuePopTail(ValueQueue*);
+AUTOC_EXTERN int ValueQueueContains(ValueQueue*, Value);
+AUTOC_EXTERN Value ValueQueueFind(ValueQueue*, Value);
+#define ValueQueueReplace(self, with) ValueQueueReplaceEx(self, with, 1)
+#define ValueQueueReplaceAll(self,  with) ValueQueueReplaceEx(self, with, -1)
+AUTOC_EXTERN int ValueQueueReplaceEx(ValueQueue*, Value, int);
+#define ValueQueueRemove(self, what) ValueQueueRemoveEx(self, what, 1)
+#define ValueQueueRemoveAll(self, what) ValueQueueRemoveEx(self, what, -1)
+AUTOC_EXTERN int ValueQueueRemoveEx(ValueQueue*, Value, int);
+AUTOC_EXTERN size_t ValueQueueSize(ValueQueue*);
+#define ValueQueueEmpty(self) (ValueQueueSize(self) == 0)
+/***
+**** ValueTreeMap<Value -> Value>
+***/
+typedef struct ValueTreeMapEntry ValueTreeMapEntry;
+struct ValueTreeMapEntry {
+    Value key;
+    Value value;
+    unsigned flags;
+};
+typedef struct ValueTreeMapSet ValueTreeMapSet;
+typedef struct ValueTreeMapSetNode ValueTreeMapSetNode;
+typedef struct ValueTreeMapSetIt ValueTreeMapSetIt;
+struct ValueTreeMapSet {
+    ValueTreeMapSetNode* root;
+    size_t size;
+};
+struct ValueTreeMapSetIt {
+    int start, ascending;
+    ValueTreeMapSetNode* node;
+};
+struct ValueTreeMapSetNode {
+    int color;
+    ValueTreeMapSetNode* left;
+    ValueTreeMapSetNode* right;
+    ValueTreeMapSetNode* parent;
+    ValueTreeMapEntry element;
+};
+typedef struct ValueTreeMap ValueTreeMap;
+typedef struct ValueTreeMapIt ValueTreeMapIt;
+struct ValueTreeMap {
+    ValueTreeMapSet entries;
+};
+struct ValueTreeMapIt {
+    ValueTreeMapSetIt it;
+};
+#define _ValueTreeMapCtor(self) ValueTreeMapCtor(&self)
+#define _ValueTreeMapDtor(self) ValueTreeMapDtor(&self)
+#define _ValueTreeMapIdentify(self) ValueTreeMapIdentify(&self)
+#define _ValueTreeMapCopy(dst,src) ValueTreeMapCopy(&dst,&src)
+#define _ValueTreeMapEqual(lt,rt) ValueTreeMapEqual(&lt,&rt)
+#define _ValueTreeMapLess(lt,rt) ValueTreeMapLess(&lt,&rt)
+AUTOC_EXTERN void ValueTreeMapCtor(ValueTreeMap*);
+AUTOC_EXTERN void ValueTreeMapDtor(ValueTreeMap*);
+AUTOC_EXTERN void ValueTreeMapCopy(ValueTreeMap*,ValueTreeMap*);
+AUTOC_EXTERN int ValueTreeMapEqual(ValueTreeMap*,ValueTreeMap*);
+AUTOC_EXTERN size_t ValueTreeMapIdentify(ValueTreeMap*);
+AUTOC_EXTERN void ValueTreeMapPurge(ValueTreeMap*);
+AUTOC_EXTERN size_t ValueTreeMapSize(ValueTreeMap*);
+#define ValueTreeMapEmpty(self) (ValueTreeMapSize(self) == 0)
+AUTOC_EXTERN int ValueTreeMapContainsKey(ValueTreeMap*, Value);
+AUTOC_EXTERN Value ValueTreeMapGet(ValueTreeMap*, Value);
+AUTOC_EXTERN int ValueTreeMapPut(ValueTreeMap*, Value, Value);
+AUTOC_EXTERN int ValueTreeMapReplace(ValueTreeMap*, Value, Value);
+AUTOC_EXTERN int ValueTreeMapRemove(ValueTreeMap*, Value);
+AUTOC_EXTERN int ValueTreeMapItMove(ValueTreeMapIt*);
+AUTOC_EXTERN Value ValueTreeMapItGetKey(ValueTreeMapIt*);
+AUTOC_EXTERN Value ValueTreeMapItGetElement(ValueTreeMapIt*);
+#define ValueTreeMapItGet(it) ValueTreeMapItGetElement(it)
+AUTOC_EXTERN Value ValueTreeMapPeekLowestKey(ValueTreeMap*);
+AUTOC_EXTERN Value ValueTreeMapPeekLowestElement(ValueTreeMap*);
+AUTOC_EXTERN Value ValueTreeMapPeekHighestKey(ValueTreeMap*);
+AUTOC_EXTERN Value ValueTreeMapPeekHighestElement(ValueTreeMap*);
+#define ValueTreeMapItCtor(self, type) ValueTreeMapItCtorEx(self, type, 1)
+AUTOC_EXTERN void ValueTreeMapItCtorEx(ValueTreeMapIt*, ValueTreeMap*, int);
+/***
+**** ValueHashMap<Value -> Value>
+***/
+typedef struct ValueHashMapEntry ValueHashMapEntry;
+struct ValueHashMapEntry {
+    Value key;
+    Value value;
+    unsigned flags;
+};
+typedef struct ValueHashMapSetListNode ValueHashMapSetListNode;
+typedef struct ValueHashMapSetList ValueHashMapSetList;
+typedef struct ValueHashMapSetListIt ValueHashMapSetListIt;
+struct ValueHashMapSetList {
+    ValueHashMapSetListNode* head_node;
+    size_t node_count;
+};
+struct ValueHashMapSetListIt {
+    int start;
+    ValueHashMapSetList* list;
+    ValueHashMapSetListNode* this_node;
+};
+struct ValueHashMapSetListNode {
+    ValueHashMapEntry element;
+    ValueHashMapSetListNode* next_node;
+};
+typedef struct ValueHashMapSet ValueHashMapSet;
+typedef struct ValueHashMapSetIt ValueHashMapSetIt;
+struct ValueHashMapSet {
+    ValueHashMapSetList* 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 ValueHashMapSetIt {
+    ValueHashMapSet* set;
+    size_t bucket_index;
+    ValueHashMapSetListIt it;
+};
+typedef struct ValueHashMap ValueHashMap;
+typedef struct ValueHashMapIt ValueHashMapIt;
+struct ValueHashMap {
+    ValueHashMapSet entries;
+};
+struct ValueHashMapIt {
+    ValueHashMapSetIt it;
+};
+#define _ValueHashMapCtor(self) ValueHashMapCtor(&self)
+#define _ValueHashMapDtor(self) ValueHashMapDtor(&self)
+#define _ValueHashMapIdentify(self) ValueHashMapIdentify(&self)
+#define _ValueHashMapCopy(dst,src) ValueHashMapCopy(&dst,&src)
+#define _ValueHashMapEqual(lt,rt) ValueHashMapEqual(&lt,&rt)
+#define _ValueHashMapLess(lt,rt) ValueHashMapLess(&lt,&rt)
+AUTOC_EXTERN void ValueHashMapCtor(ValueHashMap*);
+AUTOC_EXTERN void ValueHashMapDtor(ValueHashMap*);
+AUTOC_EXTERN void ValueHashMapCopy(ValueHashMap*,ValueHashMap*);
+AUTOC_EXTERN int ValueHashMapEqual(ValueHashMap*,ValueHashMap*);
+AUTOC_EXTERN size_t ValueHashMapIdentify(ValueHashMap*);
+AUTOC_EXTERN void ValueHashMapPurge(ValueHashMap*);
+AUTOC_EXTERN size_t ValueHashMapSize(ValueHashMap*);
+#define ValueHashMapEmpty(self) (ValueHashMapSize(self) == 0)
+AUTOC_EXTERN int ValueHashMapContainsKey(ValueHashMap*, Value);
+AUTOC_EXTERN Value ValueHashMapGet(ValueHashMap*, Value);
+AUTOC_EXTERN int ValueHashMapPut(ValueHashMap*, Value, Value);
+AUTOC_EXTERN int ValueHashMapReplace(ValueHashMap*, Value, Value);
+AUTOC_EXTERN int ValueHashMapRemove(ValueHashMap*, Value);
+AUTOC_EXTERN int ValueHashMapItMove(ValueHashMapIt*);
+AUTOC_EXTERN Value ValueHashMapItGetKey(ValueHashMapIt*);
+AUTOC_EXTERN Value ValueHashMapItGetElement(ValueHashMapIt*);
+#define ValueHashMapItGet(it) ValueHashMapItGetElement(it)
+AUTOC_EXTERN void ValueHashMapItCtor(ValueHashMapIt*, ValueHashMap*);
+/***
+**** ValueTreeSet<Value>
+***/
+typedef struct ValueTreeSet ValueTreeSet;
+typedef struct ValueTreeSetNode ValueTreeSetNode;
+typedef struct ValueTreeSetIt ValueTreeSetIt;
+struct ValueTreeSet {
+    ValueTreeSetNode* root;
+    size_t size;
+};
+struct ValueTreeSetIt {
+    int start, ascending;
+    ValueTreeSetNode* node;
+};
+struct ValueTreeSetNode {
+    int color;
+    ValueTreeSetNode* left;
+    ValueTreeSetNode* right;
+    ValueTreeSetNode* parent;
+    Value element;
+};
+#define _ValueTreeSetCtor(self) ValueTreeSetCtor(&self)
+#define _ValueTreeSetDtor(self) ValueTreeSetDtor(&self)
+#define _ValueTreeSetIdentify(self) ValueTreeSetIdentify(&self)
+#define _ValueTreeSetCopy(dst,src) ValueTreeSetCopy(&dst,&src)
+#define _ValueTreeSetEqual(lt,rt) ValueTreeSetEqual(&lt,&rt)
+#define _ValueTreeSetLess(lt,rt) ValueTreeSetLess(&lt,&rt)
+AUTOC_EXTERN void ValueTreeSetCtor(ValueTreeSet*);
+AUTOC_EXTERN void ValueTreeSetDtor(ValueTreeSet*);
+AUTOC_EXTERN void ValueTreeSetCopy(ValueTreeSet*,ValueTreeSet*);
+AUTOC_EXTERN int ValueTreeSetEqual(ValueTreeSet*,ValueTreeSet*);
+AUTOC_EXTERN size_t ValueTreeSetIdentify(ValueTreeSet*);
+AUTOC_EXTERN void ValueTreeSetPurge(ValueTreeSet*);
+AUTOC_EXTERN int ValueTreeSetContains(ValueTreeSet*, Value);
+AUTOC_EXTERN Value ValueTreeSetGet(ValueTreeSet*, Value);
+AUTOC_EXTERN size_t ValueTreeSetSize(ValueTreeSet*);
+#define ValueTreeSetEmpty(self) (ValueTreeSetSize(self) == 0)
+AUTOC_EXTERN int ValueTreeSetPut(ValueTreeSet*, Value);
+AUTOC_EXTERN int ValueTreeSetReplace(ValueTreeSet*, Value);
+AUTOC_EXTERN int ValueTreeSetRemove(ValueTreeSet*, Value);
+AUTOC_EXTERN void ValueTreeSetExclude(ValueTreeSet*, ValueTreeSet*);
+AUTOC_EXTERN void ValueTreeSetRetain(ValueTreeSet*, ValueTreeSet*);
+AUTOC_EXTERN void ValueTreeSetInclude(ValueTreeSet*, ValueTreeSet*);
+AUTOC_EXTERN void ValueTreeSetInvert(ValueTreeSet*, ValueTreeSet*);
+AUTOC_EXTERN void ValueTreeSetItCtor(ValueTreeSetIt*, ValueTreeSet*);
+#define ValueTreeSetItCtor(self, type) ValueTreeSetItCtorEx(self, type, 1)
+AUTOC_EXTERN void ValueTreeSetItCtorEx(ValueTreeSetIt*, ValueTreeSet*, int);
+AUTOC_EXTERN int ValueTreeSetItMove(ValueTreeSetIt*);
+AUTOC_EXTERN Value ValueTreeSetItGet(ValueTreeSetIt*);
+AUTOC_EXTERN Value ValueTreeSetPeekLowest(ValueTreeSet*);
+AUTOC_EXTERN Value ValueTreeSetPeekHighest(ValueTreeSet*);
+#endif