dont use NULL macro

Objects/private/primitives/DictObject.cpp

@@ -142,7 +142,7 @@ const tp::Map<std::string, Object*>& DictObject::getItems() const { return items
 
 static auto tm_get = TypeMethod{ .nameid = "get",
 																 .descr = "gets the object",
-																 .args = { { "str key", NULL } },
+																 .args = { { "str key", nullptr } },
 																 .exec =
 																	 [](const TypeMethod* tm) {
 																		 auto const self = (DictObject*) tm->self;
@@ -156,12 +156,12 @@ static auto tm_get = TypeMethod{ .nameid = "get",
 																			 tm->ret.obj = self->getSlotVal(idx);
 																		 }
 																	 },
-																 .ret = { "object", NULL } };
+																 .ret = { "object", nullptr } };
 
 static auto tm_put = TypeMethod{
 	.nameid = "put",
 	.descr = "puts the object into the dictinary",
-	.args = { { "key", NULL }, { "object", NULL } },
+	.args = { { "key", nullptr }, { "object", nullptr } },
 	.exec =
 		[](const TypeMethod* tm) {
 			auto const self = (DictObject*) tm->self;
@@ -180,7 +180,7 @@ static auto tm_remove = TypeMethod{
 	.nameid = "remove",
 	.descr = "remove the object from the dictinary",
 	.args = {
-		{ "key", NULL },
+		{ "key", nullptr },
 	},
 	.exec = [](const TypeMethod* tm) {
 		auto const self = (DictObject*)tm->self;
@@ -194,7 +194,7 @@ static auto tm_remove = TypeMethod{
 	},
 };
 
-struct obj::ObjectType DictObject::TypeData = { .base = NULL,
+struct obj::ObjectType DictObject::TypeData = { .base = nullptr,
 																								.constructor = DictObject::constructor,
 																								.destructor = DictObject::destructor,
 																								.copy = DictObject::copy,

Objects/private/primitives/EnumObject.cpp

@@ -10,7 +10,7 @@ using namespace tp;
 void EnumObject::constructor(EnumObject* self) {
 	self->active = 0;
 	self->nentries = 0;
-	self->entries = NULL;
+	self->entries = nullptr;
 }
 
 void obj::EnumObject::destructor(EnumObject* self) {
@@ -126,7 +126,7 @@ static void load(ArchiverIn& file_self, EnumObject* self) {
 	file_self >> self->active;
 	if (self->active == -1) {
 		self->nentries = 0;
-		self->entries = NULL;
+		self->entries = nullptr;
 		return;
 	}
 	file_self >> self->nentries;
@@ -134,7 +134,7 @@ static void load(ArchiverIn& file_self, EnumObject* self) {
 	file_self.readBytes((tp::int1*) self->entries, self->nentries * ENV_ALNI_SIZE_B);
 }
 
-bool obj::EnumObject::compare(EnumObject* first, EnumObject* second) { return first->entries != NULL && second->entries != NULL && first->active == second->active; }
+bool obj::EnumObject::compare(EnumObject* first, EnumObject* second) { return first->entries != nullptr && second->entries != nullptr && first->active == second->active; }
 
 EnumObject* obj::EnumObject::create(tp::InitialierList<const char*> list) {
 	auto enum_object = (EnumObject*) obj::NDO->create("enum");
@@ -160,7 +160,7 @@ struct ObjectTypeConversions EnumObjectTypeConversions = {
 };
 
 struct obj::ObjectType obj::EnumObject::TypeData = {
-	.base = NULL,
+	.base = nullptr,
 	.constructor = (object_constructor) EnumObject::constructor,
 	.destructor = (object_destructor) EnumObject::destructor,
 	.copy = (object_copy) EnumObject::copy,

Objects/private/primitives/FloatObject.cpp

@@ -57,9 +57,9 @@ struct ObjectTypeAriphmetics FloatObject::TypeAriphm = {
 };
 
 struct obj::ObjectType obj::FloatObject::TypeData = {
-	.base = NULL,
+	.base = nullptr,
 	.constructor = (object_constructor) FloatObject::constructor,
-	.destructor = NULL,
+	.destructor = nullptr,
 	.copy = (object_copy) FloatObject::copy,
 	.size = sizeof(FloatObject),
 	.name = "float",

Objects/private/primitives/IntObject.cpp

@@ -58,9 +58,9 @@ struct ObjectTypeAriphmetics IntObject::TypeAriphm = {
 };
 
 struct obj::ObjectType obj::IntObject::TypeData = {
-	.base = NULL,
+	.base = nullptr,
 	.constructor = IntObject::constructor,
-	.destructor = NULL,
+	.destructor = nullptr,
 	.copy = (object_copy) IntObject::copy,
 	.size = sizeof(IntObject),
 	.name = "int",

Objects/private/primitives/LinkObject.cpp

@@ -20,7 +20,7 @@ LinkObject* LinkObject::create(Object* in) {
 alni LinkObject::save_size(LinkObject* self) { return sizeof(alni); }
 
 void LinkObject::save(LinkObject* self, ArchiverOut& file_self) {
-	if (self->link != NULL) {
+	if (self->link != nullptr) {
 		alni link_object_save_adress = NDO->save(file_self, self->link);
 		file_self << link_object_save_adress;
 	} else {
@@ -35,7 +35,7 @@ void LinkObject::load(ArchiverIn& file_self, LinkObject* self) {
 	file_self >> saved_object_adress;
 
 	if (saved_object_adress == -1) {
-		self->link = NULL;
+		self->link = nullptr;
 	} else {
 		self->link = NDO->load(file_self, saved_object_adress);
 		NDO->refinc(self->link);
@@ -66,7 +66,7 @@ void LinkObject::setLink(Object* obj) {
 	link = obj;
 }
 
-static auto tm_set = TypeMethod{ .nameid = "set", .descr = "sets the link", .args = { { "target", NULL } }, .exec = [](const TypeMethod* tm) {
+static auto tm_set = TypeMethod{ .nameid = "set", .descr = "sets the link", .args = { { "target", nullptr } }, .exec = [](const TypeMethod* tm) {
 																	auto const self = (LinkObject*) tm->self;
 																	auto const target = tm->args[0].obj;
 																	self->setLink(target);
@@ -82,15 +82,15 @@ static auto tm_get = TypeMethod{ .nameid = "get",
 																			 tm->ret.obj = link;
 																		 }
 																	 },
-																 .ret = { "the link", NULL } };
+																 .ret = { "the link", nullptr } };
 
-struct obj::ObjectType LinkObject::TypeData = { .base = NULL,
+struct obj::ObjectType LinkObject::TypeData = { .base = nullptr,
 																								.constructor = LinkObject::constructor,
 																								.destructor = (object_destructor) LinkObject::destructor,
 																								.copy = LinkObject::copy,
 																								.size = sizeof(LinkObject),
 																								.name = "link",
-																								.convesions = NULL,
+																								.convesions = nullptr,
 																								.save_size = (object_save_size) LinkObject::save_size,
 																								.save = (object_save) LinkObject::save,
 																								.load = (object_load) LinkObject::load,

Objects/private/primitives/ListObject.cpp

@@ -106,13 +106,13 @@ void ListObject::popBack() {
 
 const tp::List<Object*>& ListObject::getItems() const { return items; }
 
-struct obj::ObjectType obj::ListObject::TypeData = { .base = NULL,
+struct obj::ObjectType obj::ListObject::TypeData = { .base = nullptr,
 																										 .constructor = ListObject::constructor,
 																										 .destructor = ListObject::destructor,
 																										 .copy = ListObject::copy,
 																										 .size = sizeof(ListObject),
 																										 .name = "list",
-																										 .convesions = NULL,
+																										 .convesions = nullptr,
 																										 .save_size = (object_save_size) save_size,
 																										 .save = (object_save) save,
 																										 .load = (object_load) load,

Objects/private/primitives/MethodObject.cpp

@@ -6,13 +6,13 @@
 using namespace obj;
 
 struct ObjectType MethodObject::TypeData = {
-	.base = NULL,
+	.base = nullptr,
 	.constructor = (object_constructor) MethodObject::constructor,
 	.destructor = (object_destructor) MethodObject::destructor,
 	.copy = (object_copy) MethodObject::copy,
 	.size = sizeof(MethodObject),
 	.name = "method",
-	.convesions = NULL,
+	.convesions = nullptr,
 	.save_size = (object_save_size) MethodObject::save_size,
 	.save = (object_save) MethodObject::save,
 	.load = (object_load) MethodObject::load,

Objects/private/primitives/NullObject.cpp

@@ -5,7 +5,7 @@
 using namespace obj;
 using namespace tp;
 
-obj::NullObject* obj::NdoNull_globalInstance = NULL;
+obj::NullObject* obj::NdoNull_globalInstance = nullptr;
 bool uninit_flag = false;
 
 void NullObject::uninit() {
@@ -16,7 +16,7 @@ void NullObject::uninit() {
 
 void NullObject::destructor(Object* self) { DEBUG_ASSERT(uninit_flag && "Only one the instance of NullObject exists and thus it can't be destroyed"); }
 
-std::string to_string(NullObject* self) { return "NULL"; }
+std::string to_string(NullObject* self) { return "nullptr"; }
 
 alni to_int(NullObject* self) { return 0; }
 
@@ -29,19 +29,19 @@ obj::TypeMethods* tm_construct() {
 }
 
 struct ObjectTypeConversions NullObjectTypeConversions = {
-	.from_int = NULL,
-	.from_float = NULL,
-	.from_string = NULL,
+	.from_int = nullptr,
+	.from_float = nullptr,
+	.from_string = nullptr,
 	.to_string = (object_to_string) to_string,
 	.to_int = (object_to_int) to_int,
 	.to_float = (object_to_float) to_float,
 };
 
 struct ObjectType NullObject::TypeData = {
-	.base = NULL,
-	.constructor = NULL,
+	.base = nullptr,
+	.constructor = nullptr,
 	.destructor = NullObject::destructor,
-	.copy = NULL,
+	.copy = nullptr,
 	.size = sizeof(NullObject),
 	.name = "null",
 	.convesions = &NullObjectTypeConversions,

Objects/private/primitives/Stringobject.cpp

@@ -64,7 +64,7 @@ struct ObjectTypeConversions StringObjectTypeConversions = {
 };
 
 struct obj::ObjectType StringObject::TypeData = {
-	.base = NULL,
+	.base = nullptr,
 	.constructor = StringObject::constructor,
 	.destructor = (object_destructor) StringObject::destructor,
 	.copy = StringObject::copy,

Objects/private/primitives/TypeObject.cpp

@@ -54,7 +54,7 @@ static struct ObjectTypeConversions conversions = {
 };
 
 struct obj::ObjectType TypeObject::TypeData = {
-	.base = NULL,
+	.base = nullptr,
 	//.constructor = (object_constructor) TypeObject::constructor,
 	.size = sizeof(TypeObject),
 	.name = "typeobject",