autoc 1.4 → 2.0.0

data/test/test_auto.h

@@ -1,753 +0,0 @@
-/* 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