Changes in / [101e0bd:5b639ee]

Location:

src

Files:

• Parser/DeclarationNode.cc (modified) (3 diffs)
• Parser/parser.cc (added)
• examples/gc_no_raii/bug-repro/field.c (modified) (2 diffs)
• examples/gc_no_raii/bug-repro/oddtype.c (deleted)
• 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 : Wed Sep 14 23:13:28 2016
-// Update Count     : 502
+// Last Modified On : Mon Sep 12 21:03:18 2016
+// Update Count     : 491
 //
 
@@ -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;
@@ -424 +445 @@
 } // DeclarationNode::copyStorageClasses
 
-static void addQualifiersToType( TypeData *&src, TypeData *dst ) {
-        if ( src->forall && dst->kind == TypeData::Function ) {
-                if ( dst->forall ) {
-                        dst->forall->appendList( src->forall );
+DeclarationNode *DeclarationNode::addQualifiers( DeclarationNode *q ) {
+        if ( q ) {
+                checkStorageClasses( q );
+                copyStorageClasses( q );
+                if ( q->type ) {
+                        if ( ! type ) {
+                                type = new TypeData;
+                        } else {
+                                checkQualifiers( q->type, type );
+                        } // 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
+                } // 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 {
-                        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 ) 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 {
-                                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
-                                dst->base->qualifiers |= src->qualifiers;
+                        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:
-                                if ( dst->forall ) {
-                                        dst->forall->appendList( src->forall );
-                                } else {
-                                        dst->forall = src->forall;
-                                } // if
-                                src->forall = 0;
-                                dst->base = src;
-                                src = 0;
+                                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
                         } // switch
-                } // switch
+                } // if
         } // if
 }

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

@@ -62 +62 @@
 {
         struct gc_object_header* object;
-        #ifndef NDEBUG
+        #if _DEBUG
                 intptr_t lower_limit;
                 intptr_t upper_limit;
@@ -71 +71 @@
                 gc_pool_object_iterator* const this,
                 void* start_object
-                #ifndef NDEBUG
+                #if _DEBUG
                         , 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(is_valid(obj));
-                check(gc_is_managed(this) == gc_is_managed(obj->type_chain) || !obj->type_chain);
+                check(gc_obj_is_valide(obj));
+                check(gc_is_managed(this) == gc_is_managed(obj->type_chain) || obj->type_chain == NULL);
                 this->next = obj->type_chain;
                 obj->type_chain = this;
-                check(is_valid(obj));
+                check(obj->is_valide());
         }
         else
@@ -24 +24 @@
                 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);
-                check(!obj->root_chain || gc_is_managed(this) == gc_is_managed(obj->root_chain));
+                check(gc_obj_is_valide(obj));
+                check(gc_is_managed(this) == gc_is_managed(obj->root_chain) || obj->root_chain == NULL);
                 this->next = obj->root_chain;
                 obj->root_chain = this;
-                check(is_valid(obj));
+                check(gc_obj_is_valide(obj));
         }
 }
@@ -70 +69 @@
 }
 
-gcpointer_t ?=?(gcpointer_t* this, gcpointer_t rhs)
+gcpointer_t* gcpointer_assign(gcpointer_t* this, gcpointer_t* rhs)
 {
-        unregister_ptr(this);
-        this->ptr = rhs.ptr;
-        register_ptr(this);
+        if(this != rhs)
+        {
+                unregister_ptr(this);
 
-        return *this;
+                this->ptr = rhs->ptr;
+
+                register_ptr(this);
+        }
+
+        return this;
 }
 
 //Logical operators
-bool gcpointer_equal(const gcpointer_t* this, const gcpointer_t* rhs)
+bool gcpointer_equal(gcpointer_t* this, gcpointer_t* rhs)
 {
         return this->ptr == rhs->ptr;
 }
 
-bool gcpointer_not_equal(const gcpointer_t* this, const gcpointer_t* rhs)
+bool gcpointer_not_equal(gcpointer_t* this, gcpointer_t* rhs)
 {
         return this->ptr != rhs->ptr;
 }
 
-bool gcpointer_null(const gcpointer_t* this)
+bool gcpointer_null(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) {
@@ -121 +107 @@
 }
 
-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 };
 }
 
@@ -129 +115 @@
 }
 
-forall(otype T) gcpointer(T) ?=?(gcpointer(T)* this, gcpointer(T) rhs) {
-        this->internal = rhs.internal;
-        return *this;
-}
+// forall(otype T) gcpointer(T) ?=?(gcpointer(T) this, gcpointer(T) rhs);
 //
 // forall(otype T) T *?(gcpointer(T) this);
@@ -141 +124 @@
 //
 // //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
@@ -17 +14 @@
 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(const gcpointer_t* this);
+bool gcpointer_null(gcpointer_t* this);
 
-
-#ifndef NDEBUG
-        bool is_valid(const gcpointer_t* this);
-#endif
-
-forall(dtype T)
+forall(otype T)
 struct gcpointer
 {
@@ -38 +30 @@
 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"
@@ -7 +9 @@
 {
         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;
@@ -18 +19 @@
 };
 
-static inline void ctor_card(card_table_t* const this)
+static inline void ctor(card_table_t* const this)
 {
         this->count = 0;
 }
 
-static inline void dtor_card(card_table_t* const this)
+static inline void dtor(card_table_t* const this)
 {
 
@@ -47 +48 @@
         else
         {
-                check(card == this->count);
+                check(card == 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(is_valid(obj));
+        check(gc_is_valide(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( (int) 0, "ERROR: allocation in new pool failed");
+        checkf(false, "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)
 {
-        intptr_t data = ((intptr_t)block) + sizeof(gc_object_header);
+        void* data = (void*)(((intptr_t)block) + sizeof(gc_object_header));
         void* header = block;
 
-        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 );
+        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);
 
         gc_object_header* obj = placement_ctor(header, actual_size);
 
         (void)obj; //remove unsused warning since this is for debug
-        check(obj == gc_get_object_ptr( (void*)data ));
+        check(obj == get_object_ptr(data));
 
         gc_register_allocation(gc_get_state(), actual_size);
 
-        return (void*)data;
+        return data;
 }
 
@@ -119 +119 @@
         check(!ptr->forward);
         check(!ptr->is_forwarded);
-        check(gc_pool_is_from_space(gc_pool_of(ptr)));
+        check(gc_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(), &field->ptr));
+                check(gc_is_in_to_space(gc_get_state(), &type->ptr));
 
                 intptr_t* ref = &field->ptr;

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

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

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

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

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

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

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

@@ -7 +7 @@
 #include "tools.h"
 
-#ifndef NDEBUG
-        static void* const CANARY_VALUE = (void*)0xCAFEBABACAFEBABA;
+#if DEBUG
+        static const long unsigned int CANARY_VALUE = 0xCAFEBABACAFEBABA;
 #endif
 
@@ -16 +16 @@
 struct gc_object_header
 {
-        #ifndef NDEBUG
+        #if DEBUG
                 void* canary_start;
         #endif
@@ -26 +26 @@
         bool                    is_forwarded;
 
-        #ifndef NDEBUG
+        #if DEBUG
                 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);
 
-#ifndef NDEBUG
+#if DEBUG
         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);
@@ -101 +94 @@
                         }
                 }
-                stage++;
                 ++it;
         }
 
-        checkf( (int) 0, "is_in_heap() and iterator_for() return inconsistent data");
+        checkf(false, "is_in_heap() and iterator_for() return inconsistent data");
         abort();
         return NULL;
@@ -184 +176 @@
         this->from_code = (~this->from_code) & 0x01;
 
-        #ifndef NDEBUG
+        #if _DEBUG
                 {
                         gc_memory_pool* pool = this->from_space;
@@ -259 +251 @@
 }
 
-#ifndef NDEBUG
+#if _DEBUG
         bool gc_state_roots_match(gc_state* const this)
         {
@@ -273 +265 @@
                                 size += object->size;
 
-                                gcpointer_t* ptr = object->root_chain;
+                                gcpointer_base* ptr = object->root_chain;
                                 while(ptr)
                                 {
-                                        check(gc_get_object_ptr( (void*)ptr->ptr ) == object);
-                                        ptr = ptr->next;
+                                        check(get_object_ptr(ptr->m_ptr) == object);
+                                        ptr = ptr->m_next;
                                 }
                         }
 
-                        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));
+                        check(size + gc_pool_size_used(pool) == gc_pool_size_total(pool));
 
                         pool = pool->next;
@@ -298 +286 @@
                 while(pool)
                 {
-                        void** potential_ref = (void**)pool->start_p;
-                        while(potential_ref < (void**)pool->free_p)
+                        void** potential_ref = (void**)pool->m_start;
+                        while(potential_ref < (void**)pool->m_free)
                         {
                                 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
 
-#ifdef NDEBUG
-
-#define check(x)
-
-#define checkf(x, format, ...)
-
-#warning no debug checks
-
-#else
+#if _DEBUG
 
 #include <stdlib.h>
@@ -18 +10 @@
                 printf("CHECK failed : %s at %s:%i\n", #x, __FILE__, __LINE__);\
                 abort();\
-        }}while( (int)0 )\
+        }}while(0)\
 
 #define checkf(x, ...) do {\
@@ -25 +17 @@
                 printf(__VA_ARGS__);\
                 abort();\
-        }}while( (int)0 )\
+        }}while(0)\
+
+#else
+
+#define check(x)
+
+#define checkf(x, format, ...)
 
 #endif //NO_CHECKS

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

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

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

@@ -1 +1 @@
 #pragma once
 
-// #ifndef NDEBUG
-//
-// #include <fstream>
-//
-// #define DEBUG_OUT(x) sout | x | endl;
-//
-// #else
+#if _DEBUG
+
+#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
@@ -9 +7 @@
 };
 
+void ?{}(List_t* this);
+List_t* ?=?(List_t* this, List_t* rhs);
+
 typedef gcpointer(List_t) LLL;
 
-#define MAX (1024 * 1)
+#define MAX (1024 * 1024)
 
-LLL buildLLL(int sz)
+// LLL buildLLL(int sz)
+void bla()
 {
-        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;
+        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;
 }
-
-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;
-}
+//
+// 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;
+// }
 
 int main(void)
@@ -64 +58 @@
         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, (int)0);
+  tree(int, int) * imap = create(-1, 0);
   insert(&imap, 12, 13);
   insert(&imap, 2, 3);