Changeset 101e0bd

Timestamp:

Sep 15, 2016, 2:57:03 PM (8 years ago)

Author:

Peter A. Buhr <pabuhr@…>

Branches:

ADT, aaron-thesis, arm-eh, ast-experimental, cleanup-dtors, deferred_resn, demangler, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, pthread-emulation, qualifiedEnum, resolv-new, with_gc

Children:

ba7aa2d, fc4a0fa

Parents:

5b639ee (diff), 50c5cf3 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

more refactoring of parser code

Location:

src

Files:

• Parser/DeclarationNode.cc (modified) (3 diffs)
• Parser/parser.cc (deleted)
• examples/gc_no_raii/bug-repro/field.c (modified) (2 diffs)
• examples/gc_no_raii/bug-repro/oddtype.c (added)
• examples/gc_no_raii/src/gcpointers.c (modified) (6 diffs)
• examples/gc_no_raii/src/gcpointers.h (modified) (3 diffs)
• examples/gc_no_raii/src/internal/card_table.h (modified) (4 diffs)
• examples/gc_no_raii/src/internal/collector.c (modified) (6 diffs)
• examples/gc_no_raii/src/internal/collector.h (modified) (1 diff)
• examples/gc_no_raii/src/internal/memory_pool.c (modified) (10 diffs)
• examples/gc_no_raii/src/internal/memory_pool.h (modified) (2 diffs)
• examples/gc_no_raii/src/internal/object_header.c (modified) (11 diffs)
• examples/gc_no_raii/src/internal/object_header.h (modified) (4 diffs)
• examples/gc_no_raii/src/internal/state.c (modified) (7 diffs)
• examples/gc_no_raii/src/internal/state.h (modified) (1 diff)
• examples/gc_no_raii/src/tools/checks.h (modified) (3 diffs)
• examples/gc_no_raii/src/tools/print.c (modified) (1 diff)
• examples/gc_no_raii/src/tools/print.h (modified) (1 diff)
• examples/gc_no_raii/test/badlll.c (modified) (3 diffs)
• tests/avltree/avl_test.c (modified) (1 diff)

src/Parser/DeclarationNode.cc

@@ -10 +10 @@
 // Created On       : Sat May 16 12:34:05 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Mon Sep 12 21:03:18 2016
-// Update Count     : 491
+// Last Modified On : Wed Sep 14 23:13:28 2016
+// Update Count     : 502
 //
 
@@ -383 +383 @@
 }
 
-static void addQualifiersToType( TypeData *&src, TypeData *dst ) {
-        if ( src && dst ) {
-                if ( src->forall && dst->kind == TypeData::Function ) {
-                        if ( dst->forall ) {
-                                dst->forall->appendList( src->forall );
-                        } else {
-                                dst->forall = src->forall;
-                        } // if
-                        src->forall = 0;
-                } // if
-                if ( dst->base ) {
-                        addQualifiersToType( src, dst->base );
-                } else if ( dst->kind == TypeData::Function ) {
-                        dst->base = src;
-                        src = 0;
-                } else {
-                        dst->qualifiers |= src->qualifiers;
-                } // if
-        } // if
-}
-
 void appendError( string & dst, const string & src ) {
         if ( src.empty() ) return;
@@ -445 +424 @@
 } // DeclarationNode::copyStorageClasses
 
+static void addQualifiersToType( TypeData *&src, TypeData *dst ) {
+        if ( src->forall && dst->kind == TypeData::Function ) {
+                if ( dst->forall ) {
+                        dst->forall->appendList( src->forall );
+                } else {
+                        dst->forall = src->forall;
+                } // if
+                src->forall = 0;
+        } // if
+        if ( dst->base ) {
+                addQualifiersToType( src, dst->base );
+        } else if ( dst->kind == TypeData::Function ) {
+                dst->base = src;
+                src = 0;
+        } else {
+                dst->qualifiers |= src->qualifiers;
+        } // if
+} // addQualifiersToType
+
 DeclarationNode *DeclarationNode::addQualifiers( DeclarationNode *q ) {
-        if ( q ) {
-                checkStorageClasses( q );
-                copyStorageClasses( q );
-                if ( q->type ) {
-                        if ( ! type ) {
-                                type = new TypeData;
+        if ( ! q ) return this;
+
+        checkStorageClasses( q );
+        copyStorageClasses( q );
+
+        if ( ! q->type ) { delete q; return this; }
+
+        if ( ! type ) {
+//              type = new TypeData;
+                type = q->type;
+                return this;
+        } // if
+
+        checkQualifiers( q->type, type );
+        addQualifiersToType( q->type, type );
+
+        if ( q->type->forall ) {
+                if ( type->forall ) {
+                        type->forall->appendList( q->type->forall );
+                } else {
+                        if ( type->kind == TypeData::Aggregate ) {
+                                type->aggregate.params = q->type->forall;
+                                // change implicit typedef from TYPEDEFname to TYPEGENname
+                                typedefTable.changeKind( type->aggregate.name, TypedefTable::TG );
                         } else {
-                                checkQualifiers( q->type, type );
+                                type->forall = q->type->forall;
                         } // if
-                        addQualifiersToType( q->type, type );
-                        if ( q->type && q->type->forall ) {
-                                if ( type->forall ) {
-                                        type->forall->appendList( q->type->forall );
-                                } else {
-                                        if ( type->kind == TypeData::Aggregate ) {
-                                                type->aggregate.params = q->type->forall;
-                                                // change implicit typedef from TYPEDEFname to TYPEGENname
-                                                typedefTable.changeKind( type->aggregate.name, TypedefTable::TG );
-                                        } else {
-                                                type->forall = q->type->forall;
-                                        } // if
+                } // if
+                q->type->forall = 0;
+        } // if
+        delete q;
+        return this;
+} // addQualifiers
+
+static void addTypeToType( TypeData *&src, TypeData *&dst ) {
+        if ( src->forall && dst->kind == TypeData::Function ) {
+                if ( dst->forall ) {
+                        dst->forall->appendList( src->forall );
+                } else {
+                        dst->forall = src->forall;
+                } // if
+                src->forall = 0;
+        } // if
+        if ( dst->base ) {
+                addTypeToType( src, dst->base );
+        } else {
+                switch ( dst->kind ) {
+                  case TypeData::Unknown:
+                        src->qualifiers |= dst->qualifiers;
+                        dst = src;
+                        src = 0;
+                        break;
+                  case TypeData::Basic:
+                        dst->qualifiers |= src->qualifiers;
+                        if ( src->kind != TypeData::Unknown ) {
+                                assert( src->kind == TypeData::Basic );
+
+                                if ( dst->basictype == DeclarationNode::NoBasicType ) {
+                                        dst->basictype = src->basictype;
+                                } else if ( src->basictype != DeclarationNode::NoBasicType )
+                                        throw SemanticError( std::string( "conflicting type specifier " ) + DeclarationNode::basicTypeName[ src->basictype ] + " in type: ", src );
+
+                                if ( dst->complextype == DeclarationNode::NoComplexType ) {
+                                        dst->complextype = src->complextype;
+                                } else if ( src->complextype != DeclarationNode::NoComplexType )
+                                        throw SemanticError( std::string( "conflicting type specifier " ) + DeclarationNode::complexTypeName[ src->complextype ] + " in type: ", src );
+
+                                if ( dst->signedness == DeclarationNode::NoSignedness ) {
+                                        dst->signedness = src->signedness;
+                                } else if ( src->signedness != DeclarationNode::NoSignedness )
+                                        throw SemanticError( std::string( "conflicting type specifier " ) + DeclarationNode::signednessName[ src->signedness ] + " in type: ", src );
+
+                                if ( dst->length == DeclarationNode::NoLength ) {
+                                        dst->length = src->length;
+                                } else if ( dst->length == DeclarationNode::Long && src->length == DeclarationNode::Long ) {
+                                        dst->length = DeclarationNode::LongLong;
+                                } else if ( src->length != DeclarationNode::NoLength )
+                                        throw SemanticError( std::string( "conflicting type specifier " ) + DeclarationNode::lengthName[ src->length ] + " in type: ", src );
+                        } // if
+                        break;
+                  default:
+                        switch ( src->kind ) {
+                          case TypeData::Aggregate:
+                          case TypeData::Enum:
+                                dst->base = new TypeData( TypeData::AggregateInst );
+                                dst->base->aggInst.aggregate = src;
+                                if ( src->kind == TypeData::Aggregate ) {
+                                        dst->base->aggInst.params = maybeClone( src->aggregate.actuals );
                                 } // if
-                                q->type->forall = 0;
-                        } // if
-                } // if
-        } // if
-        delete q;
-        return this;
-}
-
-static void addTypeToType( TypeData *&src, TypeData *&dst ) {
-        if ( src && dst ) {
-                if ( src->forall && dst->kind == TypeData::Function ) {
-                        if ( dst->forall ) {
-                                dst->forall->appendList( src->forall );
-                        } else {
-                                dst->forall = src->forall;
-                        } // if
-                        src->forall = 0;
-                } // if
-                if ( dst->base ) {
-                        addTypeToType( src, dst->base );
-                } else {
-                        switch ( dst->kind ) {
-                          case TypeData::Unknown:
-                                src->qualifiers |= dst->qualifiers;
-                                dst = src;
+                                dst->base->qualifiers |= src->qualifiers;
                                 src = 0;
                                 break;
-                          case TypeData::Basic:
-                                dst->qualifiers |= src->qualifiers;
-                                if ( src->kind != TypeData::Unknown ) {
-                                        assert( src->kind == TypeData::Basic );
-
-                                        if ( dst->basictype == DeclarationNode::NoBasicType ) {
-                                                dst->basictype = src->basictype;
-                                        } else if ( src->basictype != DeclarationNode::NoBasicType )
-                                                throw SemanticError( std::string( "conflicting type specifier " ) + DeclarationNode::basicTypeName[ src->basictype ] + " in type: ", src );
-
-                                        if ( dst->complextype == DeclarationNode::NoComplexType ) {
-                                                dst->complextype = src->complextype;
-                                        } else if ( src->complextype != DeclarationNode::NoComplexType )
-                                                throw SemanticError( std::string( "conflicting type specifier " ) + DeclarationNode::complexTypeName[ src->complextype ] + " in type: ", src );
-
-                                        if ( dst->signedness == DeclarationNode::NoSignedness ) {
-                                                dst->signedness = src->signedness;
-                                        } else if ( src->signedness != DeclarationNode::NoSignedness )
-                                                throw SemanticError( std::string( "conflicting type specifier " ) + DeclarationNode::signednessName[ src->signedness ] + " in type: ", src );
-
-                                        if ( dst->length == DeclarationNode::NoLength ) {
-                                                dst->length = src->length;
-                                        } else if ( dst->length == DeclarationNode::Long && src->length == DeclarationNode::Long ) {
-                                                dst->length = DeclarationNode::LongLong;
-                                        } else if ( src->length != DeclarationNode::NoLength )
-                                                throw SemanticError( std::string( "conflicting type specifier " ) + DeclarationNode::lengthName[ src->length ] + " in type: ", src );
+                          default:
+                                if ( dst->forall ) {
+                                        dst->forall->appendList( src->forall );
+                                } else {
+                                        dst->forall = src->forall;
                                 } // if
-                                break;
-                          default:
-                                switch ( src->kind ) {
-                                  case TypeData::Aggregate:
-                                  case TypeData::Enum:
-                                        dst->base = new TypeData( TypeData::AggregateInst );
-                                        dst->base->aggInst.aggregate = src;
-                                        if ( src->kind == TypeData::Aggregate ) {
-                                                dst->base->aggInst.params = maybeClone( src->aggregate.actuals );
-                                        } // if
-                                        dst->base->qualifiers |= src->qualifiers;
-                                        src = 0;
-                                        break;
-                                  default:
-                                        if ( dst->forall ) {
-                                                dst->forall->appendList( src->forall );
-                                        } else {
-                                                dst->forall = src->forall;
-                                        } // if
-                                        src->forall = 0;
-                                        dst->base = src;
-                                        src = 0;
-                                } // switch
+                                src->forall = 0;
+                                dst->base = src;
+                                src = 0;
                         } // switch
-                } // if
+                } // switch
         } // if
 }

src/examples/gc_no_raii/bug-repro/field.c

@@ -62 +62 @@
 {
         struct gc_object_header* object;
-        #if _DEBUG
+        #ifndef NDEBUG
                 intptr_t lower_limit;
                 intptr_t upper_limit;
@@ -71 +71 @@
                 gc_pool_object_iterator* const this,
                 void* start_object
-                #if _DEBUG
+                #ifndef NDEBUG
                         , intptr_t pool_start
                         , intptr_t pool_end

src/examples/gc_no_raii/src/gcpointers.c

@@ -14 +14 @@
                 gc_object_header* obj = gc_get_object_for_ref(gc_get_state(), (void*)this);
                 check(obj);
-                check(gc_obj_is_valide(obj));
-                check(gc_is_managed(this) == gc_is_managed(obj->type_chain) || obj->type_chain == NULL);
+                check(is_valid(obj));
+                check(gc_is_managed(this) == gc_is_managed(obj->type_chain) || !obj->type_chain);
                 this->next = obj->type_chain;
                 obj->type_chain = this;
-                check(obj->is_valide());
+                check(is_valid(obj));
         }
         else
@@ -24 +24 @@
                 gc_object_header* obj = gc_get_object_ptr((void*)this->ptr);
                 check(obj);
-                check(gc_obj_is_valide(obj));
-                check(gc_is_managed(this) == gc_is_managed(obj->root_chain) || obj->root_chain == NULL);
+                check(is_valid(obj));
+                check(!obj->root_chain || this->ptr == obj->root_chain->ptr);
+                check(!obj->root_chain || gc_is_managed(this) == gc_is_managed(obj->root_chain));
                 this->next = obj->root_chain;
                 obj->root_chain = this;
-                check(gc_obj_is_valide(obj));
+                check(is_valid(obj));
         }
 }
@@ -69 +70 @@
 }
 
-gcpointer_t* gcpointer_assign(gcpointer_t* this, gcpointer_t* rhs)
+gcpointer_t ?=?(gcpointer_t* this, gcpointer_t rhs)
 {
-        if(this != rhs)
-        {
-                unregister_ptr(this);
+        unregister_ptr(this);
+        this->ptr = rhs.ptr;
+        register_ptr(this);
 
-                this->ptr = rhs->ptr;
-
-                register_ptr(this);
-        }
-
-        return this;
+        return *this;
 }
 
 //Logical operators
-bool gcpointer_equal(gcpointer_t* this, gcpointer_t* rhs)
+bool gcpointer_equal(const gcpointer_t* this, const gcpointer_t* rhs)
 {
         return this->ptr == rhs->ptr;
 }
 
-bool gcpointer_not_equal(gcpointer_t* this, gcpointer_t* rhs)
+bool gcpointer_not_equal(const gcpointer_t* this, const gcpointer_t* rhs)
 {
         return this->ptr != rhs->ptr;
 }
 
-bool gcpointer_null(gcpointer_t* this)
+bool gcpointer_null(const gcpointer_t* this)
 {
         return this->ptr == (intptr_t)NULL;
 }
+
+#ifndef NDEBUG
+        bool is_valid(const gcpointer_t* this) {
+                if(gcpointer_null(this)) return true;
+
+                gc_object_header* obj = gc_get_object_ptr((void*)this->ptr);
+                check(obj);
+                check(is_valid(obj));
+                check(!obj->root_chain || this->ptr == obj->root_chain->ptr);
+
+                if( !gc_is_managed(this))
+                {
+                        check( !(this->next) || this->ptr == this->next->ptr );
+                }
+
+                return true;
+        }
+#endif
 
 forall(otype T) void ?{}(gcpointer(T)* this) {
@@ -107 +121 @@
 }
 
-forall(otype T) void ?{}(gcpointer(T)* this, gcpointer(T)* other) {
-        (&this->internal) { other->internal };
+forall(otype T) void ?{}(gcpointer(T)* this, gcpointer(T) other) {
+        (&this->internal) { other.internal };
 }
 
@@ -115 +129 @@
 }
 
-// forall(otype T) gcpointer(T) ?=?(gcpointer(T) this, gcpointer(T) rhs);
+forall(otype T) gcpointer(T) ?=?(gcpointer(T)* this, gcpointer(T) rhs) {
+        this->internal = rhs.internal;
+        return *this;
+}
 //
 // forall(otype T) T *?(gcpointer(T) this);
@@ -124 +141 @@
 //
 // //Logical operators
+forall(otype T) int ?!=?(gcpointer(T) this, int zero) {
+        return this.internal.ptr != 0;
+}
 // forall(otype T) int ?!=?(gcpointer(T) this, gcpointer(T) rhs);
 // forall(otype T) int ?==?(gcpointer(T) this, gcpointer(T) rhs);

src/examples/gc_no_raii/src/gcpointers.h

@@ -3 +3 @@
 #include <stdbool.h>
 #include <stdint.h>
+
+forall(dtype T)
+struct gcpointer;
 
 struct gcpointer_t
@@ -14 +17 @@
 void ?{}(gcpointer_t* this, gcpointer_t other);
 void ^?{}(gcpointer_t* this);
-gcpointer_t* ?=?(gcpointer_t this, gcpointer_t rhs);
+gcpointer_t ?=?(gcpointer_t* this, gcpointer_t rhs);
 
 //Logical operators
 bool gcpointer_equal(gcpointer_t* this, gcpointer_t* rhs);
 bool gcpointer_not_equal(gcpointer_t* this, gcpointer_t* rhs);
-bool gcpointer_null(gcpointer_t* this);
+bool gcpointer_null(const gcpointer_t* this);
 
-forall(otype T)
+
+#ifndef NDEBUG
+        bool is_valid(const gcpointer_t* this);
+#endif
+
+forall(dtype T)
 struct gcpointer
 {
@@ -30 +38 @@
 forall(otype T) void ?{}(gcpointer(T)* this);
 forall(otype T) void ?{}(gcpointer(T)* this, void* address);
-forall(otype T) void ?{}(gcpointer(T)* this, gcpointer(T)* other);
+forall(otype T) void ?{}(gcpointer(T)* this, gcpointer(T) other);
 forall(otype T) void ^?{}(gcpointer(T)* this);
-forall(otype T) gcpointer(T) ?=?(gcpointer(T) this, gcpointer(T) rhs);
+forall(otype T) gcpointer(T) ?=?(gcpointer(T)* this, gcpointer(T) rhs);
 
 
-forall(otype T) T *?(gcpointer(T) this);
+// forall(otype T) T *?(gcpointer(T) this);
 forall(otype T) T* get(gcpointer(T)* this);
 
 //Logical operators
+forall(otype T) int ?!=?(gcpointer(T) this, int zero);
 forall(otype T) int ?!=?(gcpointer(T) this, gcpointer(T) rhs);
 forall(otype T) int ?==?(gcpointer(T) this, gcpointer(T) rhs);

src/examples/gc_no_raii/src/internal/card_table.h

@@ -1 +1 @@
 #pragma once
-
-#include <stdlib>
 
 #include "globals.h"
@@ -9 +7 @@
 {
         size_t card = ( ((intptr_t)address) & CARDS_OFFSET_MASK ) >> CARDS_SIZE_EXP;
+        checkf(card < CARDS_COUNT, (const char*)"%lu %lu = (%lx & %lx) >> %lu\n", (size_t)CARDS_COUNT, (size_t)card, (size_t)address, (size_t)CARDS_OFFSET_MASK, (size_t)CARDS_SIZE_EXP);
         check(card < CARDS_COUNT);
         return card;
@@ -19 +18 @@
 };
 
-static inline void ctor(card_table_t* const this)
+static inline void ctor_card(card_table_t* const this)
 {
         this->count = 0;
 }
 
-static inline void dtor(card_table_t* const this)
+static inline void dtor_card(card_table_t* const this)
 {
 
@@ -48 +47 @@
         else
         {
-                check(card == count);
+                check(card == this->count);
                 this->count++;
                 this->cards_start[card] = object;

src/examples/gc_no_raii/src/internal/collector.c

@@ -25 +25 @@
         gc_object_header* obj = gc_get_object_ptr((void*)target->ptr);
 
-        check(gc_is_valide(obj));
+        check(is_valid(obj));
 
         gcpointer_t** prev_next_ptr = managed ? &obj->type_chain : &obj->root_chain;
@@ -38 +38 @@
 void* gc_allocate(size_t target_size)
 {
-        sout | "Allocating " | target_size | " bytes" | endl;
+        // sout | "Allocating " | target_size | " bytes" | endl;
 
         size_t size = gc_compute_size(target_size + sizeof(gc_object_header));
 
-        sout | "Object header size: " | sizeof(gc_object_header) | " bytes" | endl;
-        sout | "Actual allocation size: " | size | " bytes" | endl;
+        // sout | "Object header size: " | sizeof(gc_object_header) | " bytes" | endl;
+        // sout | "Actual allocation size: " | size | " bytes" | endl;
 
         check(size < POOL_SIZE_BYTES);
@@ -60 +60 @@
         if((intptr_t)(block = gc_try_allocate(gc, size))) return gc_finish_alloc_block(block, size, target_size);
 
-        checkf(false, "ERROR: allocation in new pool failed");
+        checkf( (int) 0, "ERROR: allocation in new pool failed");
 
         return NULL;
@@ -67 +67 @@
 void* gc_finish_alloc_block(void* block, size_t actual_size, size_t target_size)
 {
-        void* data = (void*)(((intptr_t)block) + sizeof(gc_object_header));
+        intptr_t data = ((intptr_t)block) + sizeof(gc_object_header);
         void* header = block;
 
-        check(((intptr_t)data) > ((intptr_t)block));
-        check(((intptr_t)data) >= ((intptr_t)header));
-        check(is_aligned(data));
-        check(((intptr_t)data) + target_size <= ((intptr_t)block) + actual_size);
+        check( data > ((intptr_t)block));
+        check( data >= ((intptr_t)header));
+        check( gc_is_aligned( (void*)data ) );
+        check( data + target_size <= ((intptr_t)block) + actual_size );
 
         gc_object_header* obj = placement_ctor(header, actual_size);
 
         (void)obj; //remove unsused warning since this is for debug
-        check(obj == get_object_ptr(data));
+        check(obj == gc_get_object_ptr( (void*)data ));
 
         gc_register_allocation(gc_get_state(), actual_size);
 
-        return data;
+        return (void*)data;
 }
 
@@ -119 +119 @@
         check(!ptr->forward);
         check(!ptr->is_forwarded);
-        check(gc_is_from_space(gc_pool_of(ptr)));
+        check(gc_pool_is_from_space(gc_pool_of(ptr)));
 
         gc_memory_pool* pool = gc_pool_of(ptr)->mirror;
@@ -143 +143 @@
                 check(((intptr_t)field) < ((intptr_t)((intptr_t)object) + object->size));
 
-                check(gc_is_in_to_space(gc_get_state(), &type->ptr));
+                check(gc_is_in_to_space(gc_get_state(), &field->ptr));
 
                 intptr_t* ref = &field->ptr;

src/examples/gc_no_raii/src/internal/collector.h

@@ -1 +1 @@
 #pragma once
 
-#include <stdlib>
+#include <stdlib.h>
 
 #include "tools.h"

src/examples/gc_no_raii/src/internal/memory_pool.c

@@ -1 +1 @@
 #include "memory_pool.h"
 
-#include <stdlib>
+extern "C" {
+        #include <stdlib.h>
+        #include <string.h>
+}
 
+#include "collector.h"
 #include "object_header.h"
 
@@ -15 +19 @@
         card_table_t* new = (card_table_t*)malloc(sizeof(card_table_t));
         this->cards = new;
-        ctor(this->cards);
+        ctor_card(this->cards);
 
         this->end_p = ((uint8_t*)this) + size;
         this->free_p = this->start_p;
 
-        check(gc_pool_of(this) == this);
+        check( gc_pool_of( (void*)this ) == this);
         check(this->cards);
         gc_reset_pool(this);
@@ -27 +31 @@
 void dtor(gc_memory_pool *const this)
 {
-        dtor(this->cards);
+        dtor_card(this->cards);
         free(this->cards);
 }
@@ -34 +38 @@
 {
         this->free_p = this->start_p;
-        #if _DEBUG
-                memset(this->start_p, 0xCD, gc_pool_total_size(this));
+        #ifndef NDEBUG
+                memset(this->start_p, 0xCD, gc_pool_size_total(this));
         #endif
 
@@ -41 +45 @@
         reset(this->cards);
 
-        check(gc_pool_size_left(this) == gc_pool_total_size(this));
+        check(gc_pool_size_left(this) == gc_pool_size_total(this));
 }
 
@@ -58 +62 @@
 }
 
-void ctor(
-                gc_pool_object_iterator* const this,
+void ?{}(       gc_pool_object_iterator* this,
                 struct gc_object_header* start_object
-                #if _DEBUG
+                #ifndef NDEBUG
                         , intptr_t pool_start
                         , intptr_t pool_end
@@ -68 +71 @@
 {
         this->object = start_object;
-        #if _DEBUG
+        #ifndef NDEBUG
                 this->lower_limit = pool_start;
                 this->upper_limit = pool_end;
         #endif
 
-        check( ((intptr_t)start_object) >= lower_limit );
-        check( ((intptr_t)start_object) <= upper_limit );
+        check( ((intptr_t)start_object) >= this->lower_limit );
+        check( ((intptr_t)start_object) <= this->upper_limit );
 }
+
+void ^?{}( gc_pool_object_iterator* this ) {}
 
 gc_pool_object_iterator gc_pool_iterator_for(gc_memory_pool* const this, void* member)
@@ -81 +86 @@
         size_t card = card_of(member);
         intptr_t member_add = (intptr_t)member;
-        void* start_obj;
-        intptr_t start_obj_add;
+        intptr_t start_obj;
 
         do
         {
                 check(card < CARDS_COUNT);
-                start_obj = object_at(this->cards, card);
+                start_obj = (intptr_t)object_at(this->cards, card);
                 check(card != 0 || start_obj);
                 card--;
-                start_obj_add = (intptr_t)start_obj;
         }
-        while(start_obj_add > member_add || start_obj_add != 0);
+        while(start_obj > member_add || !(start_obj));
 
-        check(start_obj);
-        
+        check( start_obj );
+
         struct gc_object_header* start_obj_typed = (struct gc_object_header*)start_obj;
 
-        gc_pool_object_iterator it;
-        ctor( &it,
-                start_obj_typed,
-                #if _DEBUG
+        return (gc_pool_object_iterator) {
+                start_obj_typed
+                #ifndef NDEBUG
                         , (intptr_t)this->start_p
                         , (intptr_t)this->free_p
                 #endif
-        );
-        return it;
+        };
 }
 
@@ -117 +118 @@
 {
         struct gc_object_header* start_obj = (struct gc_object_header*)this->start_p;
-        gc_pool_object_iterator it;
-        ctor( &it,
-                start_obj,
-                #if _DEBUG
+        return (gc_pool_object_iterator) {
+                start_obj
+                #ifndef NDEBUG
                         , (intptr_t)this->start_p
                         , (intptr_t)this->free_p
                 #endif
-        );
-        return it;
+        };
 }
 
 gc_pool_object_iterator end(gc_memory_pool* const this)
 {
-        gc_pool_object_iterator it;
-        ctor( &it,
-                (struct gc_object_header*)this->free_p,
-                #if _DEBUG
+        return (gc_pool_object_iterator) {
+                (struct gc_object_header*)this->free_p
+                #ifndef NDEBUG
                         , (intptr_t)this->start_p
                         , (intptr_t)this->free_p
                 #endif
-        );
-        return it;
+        };
 }
 
@@ -145 +142 @@
         struct gc_object_header* object = it->object;
         intptr_t next_ptr = ((intptr_t)object) + object->size;
-        check(next_ptr > lower_limit);
-        check(next_ptr <= upper_limit);
+        check(next_ptr > it->lower_limit);
+        check(next_ptr <= it->upper_limit);
 
         struct gc_object_header* next_obj = ((struct gc_object_header*)next_ptr);
-        check(next_ptr == upper_limit || is_valide(next_obj));
+        check(next_ptr == it->upper_limit || is_valid(next_obj));
 
         it->object = next_obj;

src/examples/gc_no_raii/src/internal/memory_pool.h

@@ -39 +39 @@
 {
         struct gc_object_header* object;
-        #if _DEBUG
+        #ifndef NDEBUG
                 intptr_t lower_limit;
                 intptr_t upper_limit;
@@ -46 +46 @@
 
 
-void ctor(
-                gc_pool_object_iterator* const this,
+void ?{}(       gc_pool_object_iterator* this,
                 struct gc_object_header* start_object
-                #if _DEBUG
+                #ifndef NDEBUG
                         , intptr_t pool_start
                         , intptr_t pool_end
                 #endif
         );
+
+void ^?{}( gc_pool_object_iterator* this );
 
 bool ?!=?(const gc_pool_object_iterator lhs, const gc_pool_object_iterator rhs);

src/examples/gc_no_raii/src/internal/object_header.c

@@ -3 +3 @@
 #include <stdint.h>
 
+#include "collector.h"
 #include "globals.h"
 #include "gcpointers.h"
@@ -8 +9 @@
 void ctor(gc_object_header* const this, size_t inSize)
 {
-        #if _DEBUG
+        #ifndef NDEBUG
                 this->canary_start = CANARY_VALUE;
         #endif
@@ -18 +19 @@
         this->is_forwarded = false;
 
-        #if _DEBUG
+        #ifndef NDEBUG
                 this->canary_end = CANARY_VALUE;
         #endif
@@ -25 +26 @@
 void copy_ctor(gc_object_header* const this, const gc_object_header* const other)
 {
-        #if _DEBUG
+        #ifndef NDEBUG
                 this->canary_start = CANARY_VALUE;
         #endif
@@ -35 +36 @@
         this->is_forwarded = false;
 
-        #if _DEBUG
+        #ifndef NDEBUG
                 this->canary_end = CANARY_VALUE;
         #endif
@@ -42 +43 @@
         while(root)
         {
-                check(get_object_ptr(root->ptr) == other);
+                check(gc_get_object_ptr( (void*)root->ptr ) == other);
                 root->ptr = ((intptr_t)this) + sizeof(gc_object_header);
 
-                check(get_object_ptr(root->ptr) == this);
+                check(gc_get_object_ptr( (void*)root->ptr ) == this);
                 root = root->next;
         }
@@ -56 +57 @@
 
                 size_t offset = (intptr_t)type - (intptr_t)other;
-                check(offset < size);
+                check(offset < this->size);
 
                 gcpointer_t* member_ptr = (gcpointer_t*)( (intptr_t)this + offset );
@@ -63 +64 @@
 
                 size_t next_offset = type->next ? (intptr_t)type->next - (intptr_t)other : 0;
-                check(next_offset < size);
+                check(next_offset < this->size);
 
                 gcpointer_t* next_ptr = type->next ? (gcpointer_t*)((intptr_t)this + next_offset) : NULL;
@@ -73 +74 @@
         }
 
-        check(is_valide(this));
+        check(is_valid(this));
 }
 
-#if _DEBUG
-        bool is_valide(const gc_object_header* const this)
+#ifndef NDEBUG
+        bool is_valid(const gc_object_header* const this)
         {
-                check(this->canary_start == CANARY_VALUE);
-                check(this->canary_end == CANARY_VALUE);
+                check((intptr_t)this->canary_start == (intptr_t)CANARY_VALUE);
+                check((intptr_t)this->canary_end == (intptr_t)CANARY_VALUE);
 
-                check(this->is_forwarded == (this->forward != nullptr));
+                check(this->is_forwarded == ( (intptr_t)this->forward != (intptr_t)NULL));
 
                 check(this->size < POOL_SIZE_BYTES);
@@ -89 +90 @@
                 while(root)
                 {
-                        check(get_object_ptr(root->ptr) == this);
+                        checkf(gc_get_object_ptr( (void*)root->ptr ) == this, (const char*)"Expected %lX got %lX\n", gc_get_object_ptr( (void*)root->ptr ), this);
 
                         root = root->next;
                 }
 
-                gcpointer_t* type = type_chain;
+                gcpointer_t* type = this->type_chain;
                 while(type)
                 {
                         check((intptr_t)type > (intptr_t)this);
-                        check((intptr_t)type < (intptr_t)((intptr_t)this + size));
+                        check((intptr_t)type < (intptr_t)(((intptr_t)this) + this->size));
 
                         type = type->next;
@@ -105 +106 @@
                 return true;
         }
+        #else
+        #error blarg
 #endif

src/examples/gc_no_raii/src/internal/object_header.h

@@ -7 +7 @@
 #include "tools.h"
 
-#if DEBUG
-        static const long unsigned int CANARY_VALUE = 0xCAFEBABACAFEBABA;
+#ifndef NDEBUG
+        static void* const CANARY_VALUE = (void*)0xCAFEBABACAFEBABA;
 #endif
 
@@ -16 +16 @@
 struct gc_object_header
 {
-        #if DEBUG
+        #ifndef NDEBUG
                 void* canary_start;
         #endif
@@ -26 +26 @@
         bool                    is_forwarded;
 
-        #if DEBUG
+        #ifndef NDEBUG
                 void* canary_end;
         #endif
@@ -47 +47 @@
         return this;
 }
+
+#ifndef NDEBUG
+        bool is_valid(const gc_object_header* const this);
+#endif

src/examples/gc_no_raii/src/internal/state.c

@@ -21 +21 @@
 void gc_state_calc_usage(gc_state *const this);
 
-#if DEBUG
+#ifndef NDEBUG
         bool gc_state_roots_match(gc_state *const this);
         bool gc_state_no_from_space_ref(gc_state *const this);
@@ -76 +76 @@
 gc_object_header* gc_get_object_for_ref(gc_state* state, void* member)
 {
+        volatile int stage = 0;
         intptr_t target = ((intptr_t)member);
         if(!gc_is_in_heap(state, member)) return NULL;
+        stage++;
 
         gc_memory_pool* pool = gc_pool_of(member);
+        stage++;
         gc_pool_object_iterator it = gc_pool_iterator_for(pool, member);
+        stage++;
         gc_pool_object_iterator end = end(pool);
+        stage++;
 
         while(it != end)
         {
                 gc_object_header* object = *it;
+                check(object);
+                check( is_valid(object) );
                 {
                         intptr_t start = ((intptr_t)object);
@@ -94 +101 @@
                         }
                 }
+                stage++;
                 ++it;
         }
 
-        checkf(false, "is_in_heap() and iterator_for() return inconsistent data");
+        checkf( (int) 0, "is_in_heap() and iterator_for() return inconsistent data");
         abort();
         return NULL;
@@ -176 +184 @@
         this->from_code = (~this->from_code) & 0x01;
 
-        #if _DEBUG
+        #ifndef NDEBUG
                 {
                         gc_memory_pool* pool = this->from_space;
@@ -251 +259 @@
 }
 
-#if _DEBUG
+#ifndef NDEBUG
         bool gc_state_roots_match(gc_state* const this)
         {
@@ -265 +273 @@
                                 size += object->size;
 
-                                gcpointer_base* ptr = object->root_chain;
+                                gcpointer_t* ptr = object->root_chain;
                                 while(ptr)
                                 {
-                                        check(get_object_ptr(ptr->m_ptr) == object);
-                                        ptr = ptr->m_next;
+                                        check(gc_get_object_ptr( (void*)ptr->ptr ) == object);
+                                        ptr = ptr->next;
                                 }
                         }
 
-                        check(size + gc_pool_size_used(pool) == gc_pool_size_total(pool));
+                        checkf(size + gc_pool_size_left(pool) == gc_pool_size_total(pool),
+                                (const char*)"expected %lu + %lu == %lu\n",
+                                (size_t)size,
+                                (size_t)gc_pool_size_left(pool),
+                                (size_t)gc_pool_size_total(pool));
 
                         pool = pool->next;
@@ -286 +298 @@
                 while(pool)
                 {
-                        void** potential_ref = (void**)pool->m_start;
-                        while(potential_ref < (void**)pool->m_free)
+                        void** potential_ref = (void**)pool->start_p;
+                        while(potential_ref < (void**)pool->free_p)
                         {
                                 check(!gc_is_in_heap(this, *potential_ref));

src/examples/gc_no_raii/src/internal/state.h

@@ -38 +38 @@
 static inline bool gc_needs_collect(gc_state* state)
 {
-        sout | "Used Space: " | state->used_space | " bytes" | endl;
+        // sout | "Used Space: " | state->used_space | " bytes" | endl;
         return state->used_space * 2 > state->total_space;
 }

src/examples/gc_no_raii/src/tools/checks.h

@@ -1 +1 @@
 #pragma once
 
-#if _DEBUG
+#ifdef NDEBUG
+
+#define check(x)
+
+#define checkf(x, format, ...)
+
+#warning no debug checks
+
+#else
 
 #include <stdlib.h>
@@ -10 +18 @@
                 printf("CHECK failed : %s at %s:%i\n", #x, __FILE__, __LINE__);\
                 abort();\
-        }}while(0)\
+        }}while( (int)0 )\
 
 #define checkf(x, ...) do {\
@@ -17 +25 @@
                 printf(__VA_ARGS__);\
                 abort();\
-        }}while(0)\
-
-#else
-
-#define check(x)
-
-#define checkf(x, format, ...)
+        }}while( (int)0 )\
 
 #endif //NO_CHECKS

src/examples/gc_no_raii/src/tools/print.c

@@ -1 +1 @@
 #include "tools.h"
 
-#if _DEBUG
-        ofstream *sout = ofstream_stdout();
+#ifndef NDEBUG
+        // ofstream *sout = ofstream_stdout();
 #endif

src/examples/gc_no_raii/src/tools/print.h

@@ -1 +1 @@
 #pragma once
 
-#if _DEBUG
-
-#include <fstream>
-
-#define DEBUG_OUT(x) sout | x | endl;
-
-#else
+// #ifndef NDEBUG
+//
+// #include <fstream>
+//
+// #define DEBUG_OUT(x) sout | x | endl;
+//
+// #else
 
 #define DEBUG_OUT(x)
 
-#endif //NO_CHECKS
+// #endif //NO_CHECKS

src/examples/gc_no_raii/test/badlll.c

@@ -1 +1 @@
 #include "gc.h"
+
+#include <stdio.h>
 
 struct List_t
@@ -7 +9 @@
 };
 
-void ?{}(List_t* this);
-List_t* ?=?(List_t* this, List_t* rhs);
-
 typedef gcpointer(List_t) LLL;
 
-#define MAX (1024 * 1024)
+#define MAX (1024 * 1)
 
-// LLL buildLLL(int sz)
-void bla()
+LLL buildLLL(int sz)
 {
-        int i;
-        // LLL ll0;//, lll, llc;
-//
-//      ll0 = gcmalloc();
-//      ll0->val = 0;
-//      lll = ll0;
-//
-//      for (i = 1; i < sz; i++)
-//      {
-//              llc = gcmalloc();
-//              llc->val = i;
-//              lll->next = llc;
-//              lll = llc;
-//      }
-//
-        // return ll0;
+        int i = 0;
+        LLL ll0;
+
+        gcmalloc( &ll0 );
+        List_t* ll0_ptr = get( &ll0 );
+        ll0_ptr->val = i;
+        LLL lll = ll0;
+
+        for (i = 1; i < sz; i++)
+        {
+                LLL llc;
+                gcmalloc( &llc );
+                List_t* llc_ptr = get( &llc );
+                llc_ptr->val = i;
+                List_t* lll_ptr = get( &lll );
+                lll_ptr->next = llc;
+
+                lll = llc;
+        }
+
+        check(is_valid( &ll0.internal ));
+
+        return ll0;
 }
-//
-// void testLLL(LLL lll)
-// {
-//      unsigned char *counted;
-//
-//      counted = (unsigned char *) calloc(MAX, sizeof(unsigned char));
-//      while (lll)
-//      {
-//              counted[lll->val]++;
-//              if (counted[lll->val] > 1)
-//              {
-//                      fprintf(stderr, "ERROR! Encountered %d twice!\n", lll->val);
-//                      exit(1);
-//              }
-//              lll = lll->next;
-//      }
-//
-//      return;
-// }
+
+void testLLL(LLL lll)
+{
+        unsigned char *counted;
+
+        counted = (unsigned char *) calloc(MAX, sizeof(unsigned char));
+        while (lll)
+        {
+                List_t* lll_ptr = get( &lll );
+                counted[lll_ptr->val]++;
+                if (counted[lll_ptr->val] > 1)
+                {
+                        fprintf(stderr, "ERROR! Encountered %d twice!\n", lll_ptr->val);
+                        exit(1);
+                }
+                lll = lll_ptr->next;
+        }
+
+        return;
+}
 
 int main(void)
@@ -58 +64 @@
         LLL mylll;
 
-        // mylll = buildLLL(MAX);
-        //
-        // testLLL(mylll);
+        mylll = buildLLL(MAX);
+
+        testLLL(mylll);
 
         return 0;

src/tests/avltree/avl_test.c

@@ -14 +14 @@
 
   // int -> int
-  tree(int, int) * imap = create(-1, 0);
+  tree(int, int) * imap = create(-1, (int)0);
   insert(&imap, 12, 13);
   insert(&imap, 2, 3);