+# define POOL_SIZE 64
+struct EnvironmentPool
+{
+ int8_t freeIndex;
+ bool allocatedFlags[POOL_SIZE];
+ Environment environments[POOL_SIZE];
+ EnvironmentPool* overflow;
+};
+
+EnvironmentPool* EnvironmentPool_construct();
+void EnvironmentPool_initialize(EnvironmentPool*);
+void EnvironmentPool_deinitialize(EnvironmentPool*);
+void EnvironmentPool_destruct(EnvironmentPool*);
+
+EnvironmentPool* EnvironmentPool_construct()
+{
+ EnvironmentPool* result = malloc(sizeof(EnvironmentPool));
+ EnvironmentPool_initialize(result);
+ return result;
+}
+
+void EnvironmentPool_initialize(EnvironmentPool* self)
+{
+ self->overflow = NULL;
+ self->freeIndex = 0;
+
+ for(size_t i = 0; i < POOL_SIZE; i++)
+ {
+ self->allocatedFlags[i] = false;
+ self->environments[i].live = false;
+ }
+}
+
+void EnvironmentPool_deinitialize(EnvironmentPool* self)
+{
+ // We can assume if this is being called, none of the Environments are live
+ for(int8_t i = 0; i < POOL_SIZE; i++)
+ {
+ if(self->allocatedFlags[i]) Environment_deinitialize(&(self->environments[i]));
+ }
+
+ EnvironmentPool_destruct(self->overflow);
+}
+
+void EnvironmentPool_destruct(EnvironmentPool* self)
+{
+ if(self == NULL) return;
+ EnvironmentPool_deinitialize(self);
+ free(self);
+}
+
+void EnvironmentPool_GC(EnvironmentPool* self)
+{
+ // Unmark all the environments
+ for(EnvironmentPool* current = self; current != NULL; current = current->overflow)
+ {
+ for(int8_t i = 0; i < POOL_SIZE; i++)
+ {
+ current->environments[i].mark = false;
+ }
+ }
+
+ // Mark live enviroments and environments referenced by live environments
+ for(EnvironmentPool* current = self; current != NULL; current = current->overflow)
+ {
+ for(int8_t i = 0; i < POOL_SIZE; i++)
+ {
+ if(current->environments[i].live)
+ {
+ Environment_mark(&(current->environments[i]));
+ }
+ }
+ }
+
+ // TODO We never free pools until the very end--we could free a pool if two pools are empty
+ for(EnvironmentPool* current = self; current != NULL; current = current->overflow)
+ {
+ for(int8_t i = POOL_SIZE - 1; i >= 0; i--)
+ {
+ if(!current->environments[i].mark && current->allocatedFlags[i])
+ {
+ Environment_deinitialize(&(current->environments[i]));
+ current->allocatedFlags[i] = false;
+ current->freeIndex = i;
+ }
+ }
+ }
+}
+
+Environment* EnvironmentPool_allocate(EnvironmentPool* self)
+{
+ for(EnvironmentPool* current = self; current != NULL; current = current->overflow)
+ {
+ for(; current->freeIndex < POOL_SIZE; current->freeIndex++)
+ {
+ if(!current->allocatedFlags[current->freeIndex])
+ {
+ current->allocatedFlags[current->freeIndex] = true;
+ return &(current->environments[current->freeIndex]);
+ }
+ }
+ }
+
+ EnvironmentPool_GC(self);
+
+ EnvironmentPool* previous;
+ for(EnvironmentPool* current = self; current != NULL; current = current->overflow)
+ {
+ for(; current->freeIndex < POOL_SIZE; current->freeIndex++)
+ {
+ if(!current->allocatedFlags[current->freeIndex])
+ {
+ current->allocatedFlags[current->freeIndex] = true;
+ return &(current->environments[current->freeIndex]);
+ }
+ else
+ {
+ previous = current;
+ }
+ }
+ }
+
+ previous->overflow = EnvironmentPool_construct();
+ return EnvironmentPool_allocate(previous->overflow);
+}
+