Index: src/examples/gc_no_raii/bug-repro/assert.c
===================================================================
--- src/examples/gc_no_raii/bug-repro/assert.c	(revision 08a40fd0ac2822ce5d15d21cb33a99415eeaaaed)
+++ src/examples/gc_no_raii/bug-repro/assert.c	(revision 08a40fd0ac2822ce5d15d21cb33a99415eeaaaed)
@@ -0,0 +1,16 @@
+struct gc_object_header{
+ int size;
+};
+
+struct gc_state;
+
+inline _Bool needs_collect(gc_state* state) {
+ return state->used_space > 0;
+}
+
+struct gc_object_header* gc_get_object_for_ref();
+
+inline gc_object_header* gc_get_object_ptr(void* ptr)
+{
+ return 0;
+}
Index: src/examples/gc_no_raii/bug-repro/not_equal.c
===================================================================
--- src/examples/gc_no_raii/bug-repro/not_equal.c	(revision 08a40fd0ac2822ce5d15d21cb33a99415eeaaaed)
+++ src/examples/gc_no_raii/bug-repro/not_equal.c	(revision 08a40fd0ac2822ce5d15d21cb33a99415eeaaaed)
@@ -0,0 +1,10 @@
+
+struct pointer_t
+{
+	void* p;
+};
+
+_Bool operator_not_equal_p(pointer_t* lhs, pointer_t* rhs)
+{
+	return lhs->p == rhs->p;
+}
Index: src/examples/gc_no_raii/out.test
===================================================================
--- src/examples/gc_no_raii/out.test	(revision 08a40fd0ac2822ce5d15d21cb33a99415eeaaaed)
+++ src/examples/gc_no_raii/out.test	(revision 08a40fd0ac2822ce5d15d21cb33a99415eeaaaed)
@@ -0,0 +1,3 @@
+CFA Version 1.0.0 (debug)
+make[1]: *** [debug/gcpointers.o] Error 1
+make: *** [gc-test] Error 2
Index: src/examples/gc_no_raii/src/internal/collector.c
===================================================================
--- src/examples/gc_no_raii/src/internal/collector.c	(revision 6be0cf9f958cd6a2f2ed0607c27023b9a65c146e)
+++ src/examples/gc_no_raii/src/internal/collector.c	(revision 08a40fd0ac2822ce5d15d21cb33a99415eeaaaed)
@@ -2,4 +2,5 @@
 
 #include <stdint.h>
+#include <stdlib.h>
 #include <string.h>
 
@@ -8,5 +9,5 @@
 #include "gc_tools.h"
 #include "state.h"
-#include "memory_pool.h"
+// #include "memory_pool.h"
 
 void* gc_finish_alloc_block(void* block, size_t actual_size, size_t target_size);
@@ -18,5 +19,5 @@
 
 	bool managed = gc_is_managed(target);
-	gc_object_header* obj = gc_get_object_ptr(target->ptr);
+	gc_object_header* obj = gc_get_object_ptr((void*)target->ptr);
 
 	check(gc_is_valide(obj));
@@ -37,39 +38,39 @@
 	check(size < POOL_SIZE_BYTES);
 
-	void* block = nullptr;
+	void* block = NULL;
 	gc_state* gc = gc_get_state();
 
-	if((block = gc_try_allocate(gc, size))) return gc_finish_alloc_block(block, size, target_size);
+	if((intptr_t)(block = gc_try_allocate(gc, size))) return gc_finish_alloc_block(block, size, target_size);
 
 	gc_collect(gc);
 
-	if((block = gc_try_allocate(gc, size))) return gc_finish_alloc_block(block, size, target_size);
+	if((intptr_t)(block = gc_try_allocate(gc, size))) return gc_finish_alloc_block(block, size, target_size);
 
 	gc_allocate_pool(gc);
 
-	if((block = gc_try_allocate(gc, size))) return gc_finish_alloc_block(block, size, target_size);
+	if((intptr_t)(block = gc_try_allocate(gc, size))) return gc_finish_alloc_block(block, size, target_size);
 
 	ofstream_stderr() | "ERROR: allocation in new pool failed" | endl;
 	abort();
 
-	return nullptr;
+	return NULL;
 }
 
 void* gc_finish_alloc_block(void* block, size_t actual_size, size_t target_size)
 {
-	void* data = (void*)(intptr_t(block) + sizeof(object_header));
+	void* data = (void*)(((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(((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(((intptr_t)data) + target_size <= ((intptr_t)block) + actual_size);
 
-	object_header* obj = gc_object_header_placement_ctor(header, actual_size);
+	gc_object_header* obj = gc_object_header_placement_ctor(header, actual_size);
 
 	(void)obj; //remove unsused warning since this is for debug
 	check(obj == get_object_ptr(data));
 
-	gc_register_allocation(get_state(), actual_size);
+	gc_register_allocation(gc_get_state(), actual_size);
 
 	return data;
@@ -78,7 +79,7 @@
 // 	void process_reference(void** ref, std::vector<void**>& worklist)
 // 	{
-// 		check(!gc::get_state().is_in_heap(ref));
+// 		check(!gc::gc_get_state().is_in_heap(ref));
 //
-// 		if(object_header* ptr = get_object_ptr(*ref))
+// 		if(gc_object_header* ptr = get_object_ptr(*ref))
 // 		{
 // 			if(!ptr->is_forwarded)
@@ -98,12 +99,12 @@
 // 	}
 //
-// 	void assign_reference(void** ref, object_header* ptr)
+// 	void assign_reference(void** ref, gc_object_header* ptr)
 // 	{
-// 		void* address = (void*)(intptr_t(ptr) + sizeof(object_header));
+// 		void* address = (void*)(((intptr_t)ptr) + sizeof(gc_object_header));
 //
 // 		write_aligned_ptr(ref, address);
 // 	}
 //
-// 	object_header* copy_object(object_header* ptr)
+// 	gc_object_header* copy_object(gc_object_header* ptr)
 // 	{
 // 		check(!ptr->forward);
@@ -117,5 +118,5 @@
 // 		std::memcpy(new_block, ptr, ptr->size);
 //
-// 		object_header* fwd_ptr = new (new_block) object_header(ptr);
+// 		gc_object_header* fwd_ptr = new (new_block) gc_object_header(ptr);
 //
 // 		ptr->forward = fwd_ptr;
@@ -125,13 +126,13 @@
 // 	}
 //
-// 	void scan_object(object_header* object, std::vector<void**>& worklist)
+// 	void scan_object(gc_object_header* object, std::vector<void**>& worklist)
 // 	{
 // 		gcpointer_base* type = object->type_chain;
 // 		while(type)
 // 		{
-// 			check(intptr_t(type) > intptr_t(object));
-// 			check(intptr_t(type) < intptr_t(intptr_t(object) + object->size));
+// 			check(((intptr_t)type) > ((intptr_t)object));
+// 			check(((intptr_t)type) < ((intptr_t)((intptr_t)object) + object->size));
 //
-// 			check(gc::get_state().is_in_to_space(&type->m_ptr));
+// 			check(gc::gc_get_state().is_in_to_space(&type->m_ptr));
 //
 // 			worklist.push_back(&type->m_ptr);