Renamed a large number of classes and structs to fit the new naming c…

…onvention.

core/__kclasses/bitmap.cpp

@@ -8,15 +8,15 @@
 #include <__kclasses/bitmap.h>
 
 
-bitmapC::bitmapC(void)
+Bitmap::Bitmap(void)
 {
 	preAllocated = 0;
 	preAllocatedSize = 0;
 	bmp.rsrc.bmp = NULL;
 	bmp.rsrc.nBits = 0;
 }
 
-error_t bitmapC::initialize(
+error_t Bitmap::initialize(
 	ubit32 nBits, preallocatedMemoryS preAllocatedMemory
 	)
 {
@@ -63,7 +63,7 @@ error_t bitmapC::initialize(
 	return ERROR_SUCCESS;
 }
 
-void bitmapC::dump(void)
+void Bitmap::dump(void)
 {
 	printf(NOTICE BITMAP"@0x%p: %d bits, %s (%dB), array @0x%p.\n",
 		this,
@@ -73,7 +73,7 @@ void bitmapC::dump(void)
 		bmp.rsrc.bmp);
 }
 
-void bitmapC::merge(bitmapC *b)
+void Bitmap::merge(Bitmap *b)
 {
 	// ORs this bmp with the one passed as an argument.
 	lock();
@@ -90,7 +90,7 @@ void bitmapC::merge(bitmapC *b)
 	unlock();
 }
 
-bitmapC::~bitmapC(void)
+Bitmap::~Bitmap(void)
 {
 	if (!preAllocated && bmp.rsrc.bmp != NULL) {
 		delete bmp.rsrc.bmp;
@@ -100,17 +100,17 @@ bitmapC::~bitmapC(void)
 	preAllocated = 0;
 }
 
-void bitmapC::lock(void)
+void Bitmap::lock(void)
 {
 	bmp.lock.acquire();
 }
 
-void bitmapC::unlock(void)
+void Bitmap::unlock(void)
 {
 	bmp.lock.release();
 }
 
-void bitmapC::set(ubit32 bit)
+void Bitmap::set(ubit32 bit)
 {
 	/* Don't acquire the lock. We expect the user to call lock() before
 	 * calling this method.
@@ -123,7 +123,7 @@ void bitmapC::set(ubit32 bit)
 	};
 }
 
-void bitmapC::unset(ubit32 bit)
+void Bitmap::unset(ubit32 bit)
 {
 	/* Don't acquire the lock. We expect the user to call lock() before
 	 * calling this method.
@@ -136,7 +136,7 @@ void bitmapC::unset(ubit32 bit)
 	};
 }
 
-sarch_t bitmapC::test(ubit32 bit)
+sarch_t Bitmap::test(ubit32 bit)
 {
 	/* Don't acquire the lock. We expect the user to call lock() before
 	 * calling this method.
@@ -150,7 +150,7 @@ sarch_t bitmapC::test(ubit32 bit)
 	return 0;
 }
 
-error_t bitmapC::resizeTo(ubit32 _nBits)
+error_t Bitmap::resizeTo(ubit32 _nBits)
 {
 	uarch_t		bitCapacity, *tmp, *old;
 	sbit8		wasPreAllocated;
@@ -217,7 +217,7 @@ error_t bitmapC::resizeTo(ubit32 _nBits)
 }
 
 #if 0
-error_t bitmapC::resizeTo(ubit32 nBits)
+error_t Bitmap::resizeTo(ubit32 nBits)
 {
 	uarch_t		*tmp, *oldmem;
 	ubit32		currentBits, nIndexes;
@@ -301,7 +301,7 @@ error_t bitmapC::resizeTo(ubit32 nBits)
 }
 #endif
 
-void bitmapC::setSingle(ubit32 bit)
+void Bitmap::setSingle(ubit32 bit)
 {
 	bmp.lock.acquire();
 
@@ -315,7 +315,7 @@ void bitmapC::setSingle(ubit32 bit)
 	bmp.lock.release();
 }
 
-void bitmapC::unsetSingle(ubit32 bit)
+void Bitmap::unsetSingle(ubit32 bit)
 {
 	bmp.lock.acquire();
 
@@ -329,7 +329,7 @@ void bitmapC::unsetSingle(ubit32 bit)
 	bmp.lock.release();
 }
 
-sarch_t bitmapC::testSingle(ubit32 bit)
+sarch_t Bitmap::testSingle(ubit32 bit)
 {
 	sarch_t		ret;
 

core/__kclasses/cachePool.cpp

@@ -38,7 +38,7 @@ void cachePoolC::dump(void)
 	for (cachePoolNodeS *cur = head.rsrc; cur != NULL; cur = cur->next)
 	{
 		printf(NOTICE CACHEPOOL"Node: 0x%p, Item 0x%p, size 0x%p.\n",
-			cur, cur->item, cur->item->objectSize);
+			cur, cur->item, cur->item->sObjectize);
 	};
 
 	head.lock.release();
@@ -66,7 +66,7 @@ status_t cachePoolC::insert(cachePoolNodeS *node)
 	cur = head.rsrc;
 	for (; cur != NULL; )
 	{
-		if (node->item->objectSize < cur->item->objectSize)
+		if (node->item->sObjectize < cur->item->sObjectize)
 		{
 			// If adding before first item in list.
 			if (prev != NULL) {
@@ -83,7 +83,7 @@ status_t cachePoolC::insert(cachePoolNodeS *node)
 			return ERROR_SUCCESS;
 		};
 
-		if (cur->item->objectSize == node->item->objectSize)
+		if (cur->item->sObjectize == node->item->sObjectize)
 		{
 			// Cache already exists. Release lock and exit.
 			head.lock.release();
@@ -122,14 +122,14 @@ void cachePoolC::remove(uarch_t objSize)
 	cur = head.rsrc;
 	for (; cur != NULL; )
 	{
-		if (cur->item->objectSize > objSize)
+		if (cur->item->sObjectize > objSize)
 		{
 			// Cache size doesn't exist.
 			head.lock.release();
 			return;
 		};
 
-		if (cur->item->objectSize == objSize)
+		if (cur->item->sObjectize == objSize)
 		{
 			// If removing first item in list.
 			if (prev == NULL)
@@ -163,7 +163,7 @@ void cachePoolC::remove(uarch_t objSize)
 	head.lock.release();
 }
 
-slamCacheC *cachePoolC::getCache(uarch_t objSize)
+SlamCache *cachePoolC::getCache(uarch_t objSize)
 {
 	cachePoolNodeS		*cur;
 
@@ -174,7 +174,7 @@ slamCacheC *cachePoolC::getCache(uarch_t objSize)
 	cur = head.rsrc;
 	for (; cur != NULL; cur = cur->next)
 	{
-		if (cur->item->objectSize == objSize)
+		if (cur->item->sObjectize == objSize)
 		{
 			head.lock.release();
 			return cur->item;
@@ -186,11 +186,11 @@ slamCacheC *cachePoolC::getCache(uarch_t objSize)
 }
 
 #include <__kclasses/memReservoir.h>
-slamCacheC *cachePoolC::createCache(uarch_t objSize)
+SlamCache *cachePoolC::createCache(uarch_t objSize)
 {
 	cachePoolNodeS	*node;
 	status_t	status;
-	slamCacheC	*ret;
+	SlamCache	*ret;
 
 	objSize = CACHEPOOL_SIZE_ROUNDUP(objSize);
 
@@ -199,7 +199,7 @@ slamCacheC *cachePoolC::createCache(uarch_t objSize)
 		return NULL;
 	};
 
-	node->item = new slamCacheC(objSize);
+	node->item = new SlamCache(objSize);
 
 	if (node->item == NULL)
 	{
@@ -225,8 +225,8 @@ slamCacheC *cachePoolC::createCache(uarch_t objSize)
 	return ret;
 }
 
-void cachePoolC::destroyCache(slamCacheC *cache)
+void cachePoolC::destroyCache(SlamCache *cache)
 {
-	remove(CACHEPOOL_SIZE_ROUNDUP(cache->objectSize));
+	remove(CACHEPOOL_SIZE_ROUNDUP(cache->sObjectize));
 }