[MHR-36] Refactors and such.

Signed-off-by: Amlal <amlal@zka.com>

3 files changed, 69 insertions, 69 deletions

diff --git a/Kernel/Sources/FS/NewFS.cxx b/Kernel/Sources/FS/NewFS.cxx
index f796dd97..38a417cb 100644
--- a/Kernel/Sources/FS/NewFS.cxx
+++ b/Kernel/Sources/FS/NewFS.cxx
@@ -51,8 +51,8 @@ STATIC MountpointInterface sMountpointInterface;
 /// @param catalog it's catalog
 /// @param theFork the fork itself.
 /// @return the fork
-_Output NewFork* NewFSParser::CreateFork(_Input NewCatalog* catalog,
-										 _Input NewFork&	theFork)
+_Output NFS_FORK_STRUCT* NewFSParser::CreateFork(_Input NFS_CATALOG_STRUCT* catalog,
+										 _Input NFS_FORK_STRUCT&	theFork)
 {
 	if (!sMountpointInterface.GetAddressOf(this->fDriveIndex))
 		return nullptr;
@@ -74,8 +74,8 @@ _Output NewFork* NewFSParser::CreateFork(_Input NewCatalog* catalog,
 		rt_copy_memory((VoidPtr) "fs/newfs-packet", drv->fPacket.fPacketMime,
 					   rt_string_len("fs/newfs-packet"));
 
-		NewFork curFork{0};
-		NewFork prevFork{0};
+		NFS_FORK_STRUCT curFork{0};
+		NFS_FORK_STRUCT prevFork{0};
 		Lba		lbaOfPreviousFork = lba;
 
 		/// do not check for anything. Loop until we get what we want, that is a free fork zone.
@@ -85,7 +85,7 @@ _Output NewFork* NewFSParser::CreateFork(_Input NewCatalog* catalog,
 				break;
 
 			drv->fPacket.fLba			= lba;
-			drv->fPacket.fPacketSize	= sizeof(NewFork);
+			drv->fPacket.fPacketSize	= sizeof(NFS_FORK_STRUCT);
 			drv->fPacket.fPacketContent = &curFork;
 
 			drv->fInput(&drv->fPacket);
@@ -115,7 +115,7 @@ _Output NewFork* NewFSParser::CreateFork(_Input NewCatalog* catalog,
 				if (lba >= kNewFSCatalogStartAddress)
 				{
 					drv->fPacket.fLba			= lbaOfPreviousFork;
-					drv->fPacket.fPacketSize	= sizeof(NewFork);
+					drv->fPacket.fPacketSize	= sizeof(NFS_FORK_STRUCT);
 					drv->fPacket.fPacketContent = &prevFork;
 
 					prevFork.NextSibling = lba;
@@ -132,12 +132,12 @@ _Output NewFork* NewFSParser::CreateFork(_Input NewCatalog* catalog,
 			4; /// this value gives us space for the data offset.
 
 		theFork.Flags			= kNewFSFlagCreated;
-		theFork.DataOffset		= lba - sizeof(NewFork) * cForkPadding;
+		theFork.DataOffset		= lba - sizeof(NFS_FORK_STRUCT) * cForkPadding;
 		theFork.PreviousSibling = lbaOfPreviousFork;
 		theFork.NextSibling		= theFork.DataOffset - theFork.DataSize;
 
 		drv->fPacket.fLba			= lba;
-		drv->fPacket.fPacketSize	= sizeof(NewFork);
+		drv->fPacket.fPacketSize	= sizeof(NFS_FORK_STRUCT);
 		drv->fPacket.fPacketContent = &theFork;
 
 		drv->fOutput(&drv->fPacket);
@@ -158,19 +158,19 @@ _Output NewFork* NewFSParser::CreateFork(_Input NewCatalog* catalog,
 /// @param catalog the catalog.
 /// @param name the fork name.
 /// @return the fork.
-_Output NewFork* NewFSParser::FindFork(_Input NewCatalog* catalog,
+_Output NFS_FORK_STRUCT* NewFSParser::FindFork(_Input NFS_CATALOG_STRUCT* catalog,
 									   _Input const Char* name,
 									   Boolean			  isDataFork)
 {
 	auto	 drv	 = sMountpointInterface.GetAddressOf(this->fDriveIndex);
-	NewFork* theFork = nullptr;
+	NFS_FORK_STRUCT* theFork = nullptr;
 
 	Lba lba = isDataFork ? catalog->DataFork : catalog->ResourceFork;
 
 	while (lba != 0)
 	{
 		drv->fPacket.fLba			= lba;
-		drv->fPacket.fPacketSize	= sizeof(NewFork);
+		drv->fPacket.fPacketSize	= sizeof(NFS_FORK_STRUCT);
 		drv->fPacket.fPacketContent = (VoidPtr)theFork;
 
 		rt_copy_memory((VoidPtr) "fs/newfs-packet", drv->fPacket.fPacketMime, 16);
@@ -211,7 +211,7 @@ _Output NewFork* NewFSParser::FindFork(_Input NewCatalog* catalog,
 /// file.)
 /// @param name
 /// @return catalog pointer.
-_Output NewCatalog* NewFSParser::CreateCatalog(_Input const char* name)
+_Output NFS_CATALOG_STRUCT* NewFSParser::CreateCatalog(_Input const char* name)
 {
 	return this->CreateCatalog(name, 0, kNewFSCatalogKindFile);
 }
@@ -221,7 +221,7 @@ _Output NewCatalog* NewFSParser::CreateCatalog(_Input const char* name)
 /// @param flags the flags of the catalog.
 /// @param kind the catalog kind.
 /// @return catalog pointer.
-_Output NewCatalog* NewFSParser::CreateCatalog(_Input const char*  name,
+_Output NFS_CATALOG_STRUCT* NewFSParser::CreateCatalog(_Input const char*  name,
 											   _Input const Int32& flags,
 											   _Input const Int32& kind)
 {
@@ -240,7 +240,7 @@ _Output NewCatalog* NewFSParser::CreateCatalog(_Input const char*  name,
 		name[rt_string_len(name) - 1] == NewFilesystemHelper::Separator())
 		return nullptr;
 
-	NewCatalog* copyExists = this->FindCatalog(name, outLba);
+	NFS_CATALOG_STRUCT* copyExists = this->FindCatalog(name, outLba);
 
 	if (copyExists)
 	{
@@ -284,7 +284,7 @@ _Output NewCatalog* NewFSParser::CreateCatalog(_Input const char*  name,
 		--indexReverseCopy;
 	}
 
-	NewCatalog* catalog = this->FindCatalog(parentName, outLba);
+	NFS_CATALOG_STRUCT* catalog = this->FindCatalog(parentName, outLba);
 
 	if (catalog && catalog->Kind == kNewFSCatalogKindFile)
 	{
@@ -298,7 +298,7 @@ _Output NewCatalog* NewFSParser::CreateCatalog(_Input const char*  name,
 
 	constexpr SizeT cDefaultForkSize = kNewFSForkSize;
 
-	NewCatalog* catalogChild = new NewCatalog();
+	NFS_CATALOG_STRUCT* catalogChild = new NFS_CATALOG_STRUCT();
 
 	catalogChild->ResourceForkSize = cDefaultForkSize;
 	catalogChild->DataForkSize	   = cDefaultForkSize;
@@ -326,7 +326,7 @@ _Output NewCatalog* NewFSParser::CreateCatalog(_Input const char*  name,
 
 	drive->fInput(&drive->fPacket);
 
-	NewCatalog* nextSibling = (NewCatalog*)catalogBuf;
+	NFS_CATALOG_STRUCT* nextSibling = (NFS_CATALOG_STRUCT*)catalogBuf;
 
 	startFree = nextSibling->NextSibling;
 
@@ -337,7 +337,7 @@ _Output NewCatalog* NewFSParser::CreateCatalog(_Input const char*  name,
 
 	while (drive->fPacket.fPacketGood)
 	{
-		nextSibling = (NewCatalog*)catalogBuf;
+		nextSibling = (NFS_CATALOG_STRUCT*)catalogBuf;
 
 		if (startFree <= kNewFSStartLba)
 		{
@@ -360,7 +360,7 @@ _Output NewCatalog* NewFSParser::CreateCatalog(_Input const char*  name,
 
 			constexpr auto cNewFSCatalogPadding = 4;
 
-			NewPartitionBlock* partBlock = (NewPartitionBlock*)sectorBufPartBlock;
+			NFS_ROOT_PARTITION_BLOCK* partBlock = (NFS_ROOT_PARTITION_BLOCK*)sectorBufPartBlock;
 
 			if (partBlock->FreeCatalog < 1)
 			{
@@ -373,10 +373,10 @@ _Output NewCatalog* NewFSParser::CreateCatalog(_Input const char*  name,
 			catalogChild->ResourceFork = catalogChild->DataFork;
 
 			catalogChild->NextSibling =
-				startFree + (sizeof(NewCatalog) * cNewFSCatalogPadding);
+				startFree + (sizeof(NFS_CATALOG_STRUCT) * cNewFSCatalogPadding);
 
 			drive->fPacket.fPacketContent = catalogChild;
-			drive->fPacket.fPacketSize	  = sizeof(NewCatalog);
+			drive->fPacket.fPacketSize	  = sizeof(NFS_CATALOG_STRUCT);
 			drive->fPacket.fLba			  = startFree;
 
 			drive->fOutput(&drive->fPacket);
@@ -384,7 +384,7 @@ _Output NewCatalog* NewFSParser::CreateCatalog(_Input const char*  name,
 			drive->fPacket.fPacketContent = catalogBuf;
 			drive->fPacket.fPacketSize	  = kNewFSSectorSz;
 			drive->fPacket.fLba =
-				startFree - (sizeof(NewCatalog) * cNewFSCatalogPadding);
+				startFree - (sizeof(NFS_CATALOG_STRUCT) * cNewFSCatalogPadding);
 
 			drive->fInput(&drive->fPacket);
 
@@ -417,7 +417,7 @@ _Output NewCatalog* NewFSParser::CreateCatalog(_Input const char*  name,
 		constexpr auto cNewFSCatalogPadding = 4;
 
 		//// @note that's how we find the next catalog in the partition block.
-		startFree = startFree + (sizeof(NewCatalog) * cNewFSCatalogPadding);
+		startFree = startFree + (sizeof(NFS_CATALOG_STRUCT) * cNewFSCatalogPadding);
 
 		drive->fPacket.fPacketContent = catalogBuf;
 		drive->fPacket.fPacketSize	  = kNewFSSectorSz;
@@ -459,7 +459,7 @@ bool NewFSParser::Format(_Input _Output DriveTrait* drive)
 	/// disk isnt faulty and data has been fetched.
 	if (drive->fPacket.fPacketGood)
 	{
-		NewPartitionBlock* partBlock = (NewPartitionBlock*)sectorBuf;
+		NFS_ROOT_PARTITION_BLOCK* partBlock = (NFS_ROOT_PARTITION_BLOCK*)sectorBuf;
 
 		/// check for an empty partition here.
 		if (partBlock->PartitionName[0] == 0 &&
@@ -485,10 +485,10 @@ bool NewFSParser::Format(_Input _Output DriveTrait* drive)
 			partBlock->Kind			= kNewFSPartitionTypeStandard;
 			partBlock->StartCatalog = kNewFSCatalogStartAddress;
 			partBlock->Flags		= kNewFSPartitionTypeStandard;
-			partBlock->CatalogCount = sectorCount / sizeof(NewCatalog);
+			partBlock->CatalogCount = sectorCount / sizeof(NFS_CATALOG_STRUCT);
 			partBlock->SectorCount	= sectorCount;
 			partBlock->DiskSize		= diskSize;
-			partBlock->FreeCatalog	= sectorCount / sizeof(NewCatalog);
+			partBlock->FreeCatalog	= sectorCount / sizeof(NFS_CATALOG_STRUCT);
 
 			drive->fPacket.fPacketContent = sectorBuf;
 			drive->fPacket.fPacketSize	  = kNewFSSectorSz;
@@ -513,7 +513,7 @@ bool NewFSParser::Format(_Input _Output DriveTrait* drive)
 				// make it bootable when needed.
 				Char bufEpmHdr[kNewFSSectorSz] = {0};
 
-				BootBlockType* epmBoot = (BootBlockType*)bufEpmHdr;
+				BOOT_BLOCK_STRUCT* epmBoot = (BOOT_BLOCK_STRUCT*)bufEpmHdr;
 
 				constexpr auto cFsName	  = "NewFS";
 				constexpr auto cBlockName = "Zeta:";
@@ -551,15 +551,15 @@ bool NewFSParser::Format(_Input _Output DriveTrait* drive)
 /// @param catalog the catalog itself
 /// @param data the data.
 /// @return if the catalog w rote the contents successfully.
-bool NewFSParser::WriteCatalog(_Input _Output NewCatalog* catalog, voidPtr data, SizeT sizeOfData, _Input const char* forkName)
+bool NewFSParser::WriteCatalog(_Input _Output NFS_CATALOG_STRUCT* catalog, voidPtr data, SizeT sizeOfData, _Input const char* forkName)
 {
 	if (sizeOfData > catalog->DataForkSize)
 		return false;
 	if (!sMountpointInterface.GetAddressOf(this->fDriveIndex))
 		return false;
 
-	NewFork* forkData = new NewFork();
-	rt_set_memory(forkData, 0, sizeof(NewFork));
+	NFS_FORK_STRUCT* forkData = new NFS_FORK_STRUCT();
+	rt_set_memory(forkData, 0, sizeof(NFS_FORK_STRUCT));
 
 	auto drive = sMountpointInterface.GetAddressOf(this->fDriveIndex);
 
@@ -574,7 +574,7 @@ bool NewFSParser::WriteCatalog(_Input _Output NewCatalog* catalog, voidPtr data,
 	while (startFork >= kNewFSCatalogStartAddress)
 	{
 		drive->fPacket.fPacketContent = forkData;
-		drive->fPacket.fPacketSize	  = sizeof(NewFork);
+		drive->fPacket.fPacketSize	  = sizeof(NFS_FORK_STRUCT);
 		drive->fPacket.fLba			  = startFork;
 
 		drive->fInput(&drive->fPacket);
@@ -635,7 +635,7 @@ bool NewFSParser::WriteCatalog(_Input _Output NewCatalog* catalog, voidPtr data,
 /// @brief
 /// @param catalogName the catalog name.
 /// @return the newly found catalog.
-_Output NewCatalog* NewFSParser::FindCatalog(_Input const char* catalogName,
+_Output NFS_CATALOG_STRUCT* NewFSParser::FindCatalog(_Input const char* catalogName,
 											 Lba&				outLba)
 {
 	if (!sMountpointInterface.GetAddressOf(this->fDriveIndex))
@@ -643,19 +643,19 @@ _Output NewCatalog* NewFSParser::FindCatalog(_Input const char* catalogName,
 
 	kcout << "newoskrnl: start finding catalog...\r";
 
-	Char* sectorBuf = new Char[sizeof(NewPartitionBlock)];
+	Char* sectorBuf = new Char[sizeof(NFS_ROOT_PARTITION_BLOCK)];
 	auto  drive		= sMountpointInterface.GetAddressOf(this->fDriveIndex);
 
 	rt_copy_memory((VoidPtr) "fs/newfs-packet", drive->fPacket.fPacketMime,
 				   rt_string_len("fs/newfs-packet"));
 
 	drive->fPacket.fPacketContent = sectorBuf;
-	drive->fPacket.fPacketSize	  = sizeof(NewPartitionBlock);
+	drive->fPacket.fPacketSize	  = sizeof(NFS_ROOT_PARTITION_BLOCK);
 	drive->fPacket.fLba			  = kNewFSStartLba;
 
 	drive->fInput(&drive->fPacket);
 
-	NewPartitionBlock* part = (NewPartitionBlock*)sectorBuf;
+	NFS_ROOT_PARTITION_BLOCK* part = (NFS_ROOT_PARTITION_BLOCK*)sectorBuf;
 
 	auto	   startCatalogList	 = part->StartCatalog;
 	const auto cCtartCatalogList = part->StartCatalog;
@@ -664,7 +664,7 @@ _Output NewCatalog* NewFSParser::FindCatalog(_Input const char* catalogName,
 
 	drive->fPacket.fLba			  = startCatalogList;
 	drive->fPacket.fPacketContent = sectorBuf;
-	drive->fPacket.fPacketSize	  = sizeof(NewCatalog);
+	drive->fPacket.fPacketSize	  = sizeof(NFS_CATALOG_STRUCT);
 
 	drive->fInput(&drive->fPacket);
 
@@ -691,7 +691,7 @@ _Output NewCatalog* NewFSParser::FindCatalog(_Input const char* catalogName,
 			--indexReverseCopy;
 		}
 
-		NewCatalog* parentCatalog = this->FindCatalog(parentName, outLba);
+		NFS_CATALOG_STRUCT* parentCatalog = this->FindCatalog(parentName, outLba);
 
 		if (parentCatalog &&
 			!StringBuilder::Equals(parentName, NewFilesystemHelper::Root()))
@@ -712,7 +712,7 @@ _Output NewCatalog* NewFSParser::FindCatalog(_Input const char* catalogName,
 _NewFSSearchThroughCatalogList:
 	while (drive->fPacket.fPacketGood)
 	{
-		NewCatalog* catalog = (NewCatalog*)sectorBuf;
+		NFS_CATALOG_STRUCT* catalog = (NFS_CATALOG_STRUCT*)sectorBuf;
 
 		if (StringBuilder::Equals(catalogName, catalog->Name))
 		{
@@ -722,8 +722,8 @@ _NewFSSearchThroughCatalogList:
 				goto _NewFSContinueSearch;
 			}
 
-			NewCatalog* catalogPtr = new NewCatalog();
-			rt_copy_memory(catalog, catalogPtr, sizeof(NewCatalog));
+			NFS_CATALOG_STRUCT* catalogPtr = new NFS_CATALOG_STRUCT();
+			rt_copy_memory(catalog, catalogPtr, sizeof(NFS_CATALOG_STRUCT));
 
 			kcout << "newoskrnl: found catalog at: " << hex_number(startCatalogList) << endl;
 
@@ -740,7 +740,7 @@ _NewFSSearchThroughCatalogList:
 
 		drive->fPacket.fLba			  = startCatalogList;
 		drive->fPacket.fPacketContent = sectorBuf;
-		drive->fPacket.fPacketSize	  = sizeof(NewCatalog);
+		drive->fPacket.fPacketSize	  = sizeof(NFS_CATALOG_STRUCT);
 
 		drive->fInput(&drive->fPacket);
 	}
@@ -762,7 +762,7 @@ _NewFSSearchThroughCatalogList:
 /// @brief
 /// @param name
 /// @return
-_Output NewCatalog* NewFSParser::GetCatalog(_Input const char* name)
+_Output NFS_CATALOG_STRUCT* NewFSParser::GetCatalog(_Input const char* name)
 {
 	Lba unused = 0;
 	return this->FindCatalog(name, unused);
@@ -771,7 +771,7 @@ _Output NewCatalog* NewFSParser::GetCatalog(_Input const char* name)
 /// @brief
 /// @param catalog
 /// @return
-Boolean NewFSParser::CloseCatalog(_Input _Output NewCatalog* catalog)
+Boolean NewFSParser::CloseCatalog(_Input _Output NFS_CATALOG_STRUCT* catalog)
 {
 	if (!catalog)
 		return false;
@@ -809,21 +809,21 @@ Boolean NewFSParser::RemoveCatalog(_Input const Char* catalogName)
 
 		drive->fPacket.fLba = outLba; // the catalog position.
 		drive->fPacket.fPacketSize =
-			sizeof(NewCatalog);					 // size of catalog. roughly the sector size.
+			sizeof(NFS_CATALOG_STRUCT);					 // size of catalog. roughly the sector size.
 		drive->fPacket.fPacketContent = catalog; // the catalog itself.
 
 		drive->fOutput(&drive->fPacket); // send packet.
 
-		Char partitionBlockBuf[sizeof(NewPartitionBlock)] = {0};
+		Char partitionBlockBuf[sizeof(NFS_ROOT_PARTITION_BLOCK)] = {0};
 
 		drive->fPacket.fLba			  = kNewFSStartLba;
 		drive->fPacket.fPacketContent = partitionBlockBuf;
-		drive->fPacket.fPacketSize	  = sizeof(NewPartitionBlock);
+		drive->fPacket.fPacketSize	  = sizeof(NFS_ROOT_PARTITION_BLOCK);
 
 		drive->fInput(&drive->fPacket);
 
-		NewPartitionBlock* partBlock =
-			reinterpret_cast<NewPartitionBlock*>(partitionBlockBuf);
+		NFS_ROOT_PARTITION_BLOCK* partBlock =
+			reinterpret_cast<NFS_ROOT_PARTITION_BLOCK*>(partitionBlockBuf);
 
 		++partBlock->FreeCatalog;
 		--partBlock->CatalogCount;
@@ -848,7 +848,7 @@ Boolean NewFSParser::RemoveCatalog(_Input const Char* catalogName)
 /// @return
 /***********************************************************************************/
 
-VoidPtr NewFSParser::ReadCatalog(_Input _Output NewCatalog* catalog,
+VoidPtr NewFSParser::ReadCatalog(_Input _Output NFS_CATALOG_STRUCT* catalog,
 								 _Input SizeT				dataSz,
 								 _Input const char*			forkName)
 {
@@ -867,23 +867,23 @@ VoidPtr NewFSParser::ReadCatalog(_Input _Output NewCatalog* catalog,
 	kcout << "newoskrnl: catalog " << catalog->Name
 		  << ", fork: " << hex_number(dataForkLba) << endl;
 
-	Char* sectorBuf = new Char[sizeof(NewFork)];
+	Char* sectorBuf = new Char[sizeof(NFS_FORK_STRUCT)];
 	auto  drive		= sMountpointInterface.GetAddressOf(this->fDriveIndex);
 
 	rt_copy_memory((VoidPtr) "fs/newfs-packet", drive->fPacket.fPacketMime,
 				   rt_string_len("fs/newfs-packet"));
 
-	NewFork* forkData = nullptr;
+	NFS_FORK_STRUCT* forkData = nullptr;
 
 	while (dataForkLba >= kNewFSCatalogStartAddress)
 	{
 		drive->fPacket.fLba			  = dataForkLba;
-		drive->fPacket.fPacketSize	  = sizeof(NewFork);
+		drive->fPacket.fPacketSize	  = sizeof(NFS_FORK_STRUCT);
 		drive->fPacket.fPacketContent = sectorBuf;
 
 		drive->fInput(&drive->fPacket);
 
-		forkData = (NewFork*)sectorBuf;
+		forkData = (NFS_FORK_STRUCT*)sectorBuf;
 
 		kcout << "newoskrnl: name: " << forkData->ForkName << endl;
 
@@ -928,7 +928,7 @@ VoidPtr NewFSParser::ReadCatalog(_Input _Output NewCatalog* catalog,
 /// @return if the seeking was successful.
 /***********************************************************************************/
 
-bool NewFSParser::Seek(_Input _Output NewCatalog* catalog, SizeT off)
+bool NewFSParser::Seek(_Input _Output NFS_CATALOG_STRUCT* catalog, SizeT off)
 {
 	if (!catalog)
 	{
@@ -946,7 +946,7 @@ bool NewFSParser::Seek(_Input _Output NewCatalog* catalog, SizeT off)
 /// @return The position on the file.
 /***********************************************************************************/
 
-SizeT NewFSParser::Tell(_Input _Output NewCatalog* catalog)
+SizeT NewFSParser::Tell(_Input _Output NFS_CATALOG_STRUCT* catalog)
 {
 	if (!catalog)
 	{
@@ -972,16 +972,16 @@ namespace Kernel::Detail
 
 		sMountpointInterface.A().fVerify(&sMountpointInterface.A().fPacket);
 
-		Char partitionBlockBuf[sizeof(NewPartitionBlock)] = {0};
+		Char partitionBlockBuf[sizeof(NFS_ROOT_PARTITION_BLOCK)] = {0};
 
 		sMountpointInterface.A().fPacket.fLba			= kNewFSStartLba;
 		sMountpointInterface.A().fPacket.fPacketContent = partitionBlockBuf;
-		sMountpointInterface.A().fPacket.fPacketSize	= sizeof(NewPartitionBlock);
+		sMountpointInterface.A().fPacket.fPacketSize	= sizeof(NFS_ROOT_PARTITION_BLOCK);
 
 		sMountpointInterface.A().fInput(&sMountpointInterface.A().fPacket);
 
-		NewPartitionBlock* partBlock =
-			reinterpret_cast<NewPartitionBlock*>(partitionBlockBuf);
+		NFS_ROOT_PARTITION_BLOCK* partBlock =
+			reinterpret_cast<NFS_ROOT_PARTITION_BLOCK*>(partitionBlockBuf);
 
 		if (!StringBuilder::Equals(partBlock->Ident, kNewFSIdent))
 		{
diff --git a/Kernel/Sources/FileManager.cxx b/Kernel/Sources/FileManager.cxx
index 6684ce0d..dcdced27 100644
--- a/Kernel/Sources/FileManager.cxx
+++ b/Kernel/Sources/FileManager.cxx
@@ -121,8 +121,8 @@ namespace Kernel
 
 		NEWOS_UNUSED(flags);
 
-		if ((reinterpret_cast<NewCatalog*>(node))->Kind == kNewFSCatalogKindFile)
-			fImpl->WriteCatalog(reinterpret_cast<NewCatalog*>(node), data, size,
+		if ((reinterpret_cast<NFS_CATALOG_STRUCT*>(node))->Kind == kNewFSCatalogKindFile)
+			fImpl->WriteCatalog(reinterpret_cast<NFS_CATALOG_STRUCT*>(node), data, size,
 								name);
 	}
 
@@ -139,8 +139,8 @@ namespace Kernel
 
 		NEWOS_UNUSED(flags);
 
-		if ((reinterpret_cast<NewCatalog*>(node))->Kind == kNewFSCatalogKindFile)
-			return fImpl->ReadCatalog(reinterpret_cast<NewCatalog*>(node), sz,
+		if ((reinterpret_cast<NFS_CATALOG_STRUCT*>(node))->Kind == kNewFSCatalogKindFile)
+			return fImpl->ReadCatalog(reinterpret_cast<NFS_CATALOG_STRUCT*>(node), sz,
 									  name);
 
 		return nullptr;
@@ -157,7 +157,7 @@ namespace Kernel
 		if (!node || off == 0)
 			return false;
 
-		return fImpl->Seek(reinterpret_cast<NewCatalog*>(node), off);
+		return fImpl->Seek(reinterpret_cast<NFS_CATALOG_STRUCT*>(node), off);
 	}
 
 	/// @brief Tell where the catalog is.
@@ -170,7 +170,7 @@ namespace Kernel
 		if (!node)
 			return kNPos;
 
-		return fImpl->Tell(reinterpret_cast<NewCatalog*>(node));
+		return fImpl->Tell(reinterpret_cast<NFS_CATALOG_STRUCT*>(node));
 	}
 
 	/// @brief Rewinds the catalog.
diff --git a/Kernel/Sources/Main.cxx b/Kernel/Sources/Main.cxx
index b0083730..950a8e48 100644
--- a/Kernel/Sources/Main.cxx
+++ b/Kernel/Sources/Main.cxx
@@ -80,7 +80,7 @@ namespace Kernel::Detail
 						catalogDir = fNewFS->GetParser()->CreateCatalog(cDirStr[dirIndx], 0,
 																		kNewFSCatalogKindDir);
 
-						NewFork theFork{0};
+						NFS_FORK_STRUCT theFork{0};
 
 						const Kernel::Char* cSrcName = cFolderInfo;
 
@@ -122,7 +122,7 @@ namespace Kernel::Detail
 					}
 				}
 
-				NewCatalog* catalogDisk =
+				NFS_CATALOG_STRUCT* catalogDisk =
 					this->fNewFS->GetParser()->GetCatalog("\\Mount\\SIM:");
 
 				const Kernel::Char* cSrcName = "DISK-INF";
@@ -134,7 +134,7 @@ namespace Kernel::Detail
 				else
 				{
 					catalogDisk =
-						(NewCatalog*)this->Leak()->CreateAlias("\\Mount\\SIM:");
+						(NFS_CATALOG_STRUCT*)this->Leak()->CreateAlias("\\Mount\\SIM:");
 
 					Kernel::StringView diskFolder(kNewFSSectorSz);
 
@@ -147,7 +147,7 @@ namespace Kernel::Detail
 					diskFolder += Kernel::NewFilesystemHelper::Root();
 					diskFolder += "</p>\r";
 
-					NewFork theDiskFork{0};
+					NFS_FORK_STRUCT theDiskFork{0};
 
 					Kernel::rt_copy_memory((Kernel::VoidPtr)(cSrcName), theDiskFork.ForkName,
 										   Kernel::rt_string_len(cSrcName));