[Aaru.Filesystems] Introduced constants for module names

Introduces constant fields for respective debug module names, replacing the hardcoded ones.
This is done to standardize the naming convention, reduce redundancy and potentially avoid any typos or name mismatches across the project.
This change makes the code more maintainable and easier to update in case module names need to be changed.

Aaru.Filesystems/Acorn/Acorn.cs

@@ -41,4 +41,5 @@ public sealed partial class AcornADFS : IFilesystem
     public Guid Id => new("BAFC1E50-9C64-4CD3-8400-80628CC27AFA");
     /// <inheritdoc />
     public string Author => Authors.NataliaPortillo;
+    const string MODULE_NAME = "ADFS Plugin";
 }

Aaru.Filesystems/Acorn/Info.cs

@@ -76,8 +76,8 @@ public sealed partial class AcornADFS
             byte          oldChk1 = AcornMapChecksum(sector, 255);
             OldMapSector1 oldMap1 = Marshal.ByteArrayToStructureLittleEndian<OldMapSector1>(sector);
 
-            AaruConsole.DebugWriteLine("ADFS Plugin", "oldMap0.checksum = {0}", oldMap0.checksum);
-            AaruConsole.DebugWriteLine("ADFS Plugin", "oldChk0 = {0}", oldChk0);
+            AaruConsole.DebugWriteLine(MODULE_NAME, "oldMap0.checksum = {0}", oldMap0.checksum);
+            AaruConsole.DebugWriteLine(MODULE_NAME, "oldChk0 = {0}", oldChk0);
 
             // According to documentation map1 MUST start on sector 1. On ADFS-D it starts at 0x100, not on sector 1 (0x400)
             if(oldMap0.checksum == oldChk0 &&
@@ -95,8 +95,8 @@ public sealed partial class AcornADFS
                 oldMap1 = Marshal.ByteArrayToStructureLittleEndian<OldMapSector1>(tmp);
             }
 
-            AaruConsole.DebugWriteLine("ADFS Plugin", "oldMap1.checksum = {0}", oldMap1.checksum);
-            AaruConsole.DebugWriteLine("ADFS Plugin", "oldChk1 = {0}", oldChk1);
+            AaruConsole.DebugWriteLine(MODULE_NAME, "oldMap1.checksum = {0}", oldMap1.checksum);
+            AaruConsole.DebugWriteLine(MODULE_NAME, "oldChk1 = {0}", oldChk1);
 
             if(oldMap0.checksum == oldChk0 &&
                oldMap1.checksum == oldChk1 &&
@@ -125,14 +125,14 @@ public sealed partial class AcornADFS
                 OldDirectory oldRoot = Marshal.ByteArrayToStructureLittleEndian<OldDirectory>(sector);
                 byte         dirChk  = AcornDirectoryChecksum(sector, (int)OLD_DIRECTORY_SIZE - 1);
 
-                AaruConsole.DebugWriteLine("ADFS Plugin", "oldRoot.header.magic at 0x200 = {0}", oldRoot.header.magic);
+                AaruConsole.DebugWriteLine(MODULE_NAME, "oldRoot.header.magic at 0x200 = {0}", oldRoot.header.magic);
 
-                AaruConsole.DebugWriteLine("ADFS Plugin", "oldRoot.tail.magic at 0x200 = {0}", oldRoot.tail.magic);
+                AaruConsole.DebugWriteLine(MODULE_NAME, "oldRoot.tail.magic at 0x200 = {0}", oldRoot.tail.magic);
 
-                AaruConsole.DebugWriteLine("ADFS Plugin", "oldRoot.tail.checkByte at 0x200 = {0}",
+                AaruConsole.DebugWriteLine(MODULE_NAME, "oldRoot.tail.checkByte at 0x200 = {0}",
                                            oldRoot.tail.checkByte);
 
-                AaruConsole.DebugWriteLine("ADFS Plugin", "dirChk at 0x200 = {0}", dirChk);
+                AaruConsole.DebugWriteLine(MODULE_NAME, "dirChk at 0x200 = {0}", dirChk);
 
                 if((oldRoot.header.magic == OLD_DIR_MAGIC && oldRoot.tail.magic == OLD_DIR_MAGIC) ||
                    (oldRoot.header.magic == NEW_DIR_MAGIC && oldRoot.tail.magic == NEW_DIR_MAGIC))
@@ -161,14 +161,14 @@ public sealed partial class AcornADFS
                 oldRoot = Marshal.ByteArrayToStructureLittleEndian<OldDirectory>(sector);
                 dirChk  = AcornDirectoryChecksum(sector, (int)OLD_DIRECTORY_SIZE - 1);
 
-                AaruConsole.DebugWriteLine("ADFS Plugin", "oldRoot.header.magic at 0x400 = {0}", oldRoot.header.magic);
+                AaruConsole.DebugWriteLine(MODULE_NAME, "oldRoot.header.magic at 0x400 = {0}", oldRoot.header.magic);
 
-                AaruConsole.DebugWriteLine("ADFS Plugin", "oldRoot.tail.magic at 0x400 = {0}", oldRoot.tail.magic);
+                AaruConsole.DebugWriteLine(MODULE_NAME, "oldRoot.tail.magic at 0x400 = {0}", oldRoot.tail.magic);
 
-                AaruConsole.DebugWriteLine("ADFS Plugin", "oldRoot.tail.checkByte at 0x400 = {0}",
+                AaruConsole.DebugWriteLine(MODULE_NAME, "oldRoot.tail.checkByte at 0x400 = {0}",
                                            oldRoot.tail.checkByte);
 
-                AaruConsole.DebugWriteLine("ADFS Plugin", "dirChk at 0x400 = {0}", dirChk);
+                AaruConsole.DebugWriteLine(MODULE_NAME, "dirChk at 0x400 = {0}", dirChk);
 
                 if((oldRoot.header.magic == OLD_DIR_MAGIC && oldRoot.tail.magic == OLD_DIR_MAGIC) ||
                    (oldRoot.header.magic == NEW_DIR_MAGIC && oldRoot.tail.magic == NEW_DIR_MAGIC))
@@ -185,8 +185,8 @@ public sealed partial class AcornADFS
             return false;
 
         byte newChk = NewMapChecksum(sector);
-        AaruConsole.DebugWriteLine("ADFS Plugin", "newChk = {0}", newChk);
-        AaruConsole.DebugWriteLine("ADFS Plugin", "map.zoneChecksum = {0}", sector[0]);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "newChk = {0}", newChk);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "map.zoneChecksum = {0}", sector[0]);
 
         sbSector      = BOOT_BLOCK_LOCATION / imagePlugin.Info.SectorSize;
         sectorsToRead = BOOT_BLOCK_SIZE     / imagePlugin.Info.SectorSize;
@@ -210,8 +210,8 @@ public sealed partial class AcornADFS
         for(int i = 0; i < 0x1FF; i++)
             bootChk = (bootChk & 0xFF) + (bootChk >> 8) + bootSector[i];
 
-        AaruConsole.DebugWriteLine("ADFS Plugin", "bootChk = {0}", bootChk);
-        AaruConsole.DebugWriteLine("ADFS Plugin", "bBlock.checksum = {0}", bootSector[0x1FF]);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "bootChk = {0}", bootChk);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "bBlock.checksum = {0}", bootSector[0x1FF]);
 
         if(newChk == sector[0] &&
            newChk != 0)
@@ -227,12 +227,12 @@ public sealed partial class AcornADFS
         else
             return false;
 
-        AaruConsole.DebugWriteLine("ADFS Plugin", "drSb.log2secsize = {0}", drSb.log2secsize);
-        AaruConsole.DebugWriteLine("ADFS Plugin", "drSb.idlen = {0}", drSb.idlen);
-        AaruConsole.DebugWriteLine("ADFS Plugin", "drSb.disc_size_high = {0}", drSb.disc_size_high);
-        AaruConsole.DebugWriteLine("ADFS Plugin", "drSb.disc_size = {0}", drSb.disc_size);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "drSb.log2secsize = {0}", drSb.log2secsize);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "drSb.idlen = {0}", drSb.idlen);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "drSb.disc_size_high = {0}", drSb.disc_size_high);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "drSb.disc_size = {0}", drSb.disc_size);
 
-        AaruConsole.DebugWriteLine("ADFS Plugin", "IsNullOrEmpty(drSb.reserved) = {0}",
+        AaruConsole.DebugWriteLine(MODULE_NAME, "IsNullOrEmpty(drSb.reserved) = {0}",
                                    ArrayHelpers.ArrayIsNullOrEmpty(drSb.reserved));
 
         if(drSb.log2secsize is < 8 or > 10)
@@ -443,8 +443,8 @@ public sealed partial class AcornADFS
             return;
 
         byte newChk = NewMapChecksum(sector);
-        AaruConsole.DebugWriteLine("ADFS Plugin", "newChk = {0}", newChk);
-        AaruConsole.DebugWriteLine("ADFS Plugin", "map.zoneChecksum = {0}", sector[0]);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "newChk = {0}", newChk);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "map.zoneChecksum = {0}", sector[0]);
 
         sbSector      = BOOT_BLOCK_LOCATION / imagePlugin.Info.SectorSize;
         sectorsToRead = BOOT_BLOCK_SIZE     / imagePlugin.Info.SectorSize;
@@ -462,8 +462,8 @@ public sealed partial class AcornADFS
         for(int i = 0; i < 0x1FF; i++)
             bootChk = (bootChk & 0xFF) + (bootChk >> 8) + bootSector[i];
 
-        AaruConsole.DebugWriteLine("ADFS Plugin", "bootChk = {0}", bootChk);
-        AaruConsole.DebugWriteLine("ADFS Plugin", "bBlock.checksum = {0}", bootSector[0x1FF]);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "bootChk = {0}", bootChk);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "bBlock.checksum = {0}", bootSector[0x1FF]);
 
         if(newChk == sector[0] &&
            newChk != 0)
@@ -479,30 +479,30 @@ public sealed partial class AcornADFS
         else
             return;
 
-        AaruConsole.DebugWriteLine("ADFS Plugin", "drSb.log2secsize = {0}", drSb.log2secsize);
-        AaruConsole.DebugWriteLine("ADFS Plugin", "drSb.spt = {0}", drSb.spt);
-        AaruConsole.DebugWriteLine("ADFS Plugin", "drSb.heads = {0}", drSb.heads);
-        AaruConsole.DebugWriteLine("ADFS Plugin", "drSb.density = {0}", drSb.density);
-        AaruConsole.DebugWriteLine("ADFS Plugin", "drSb.idlen = {0}", drSb.idlen);
-        AaruConsole.DebugWriteLine("ADFS Plugin", "drSb.log2bpmb = {0}", drSb.log2bpmb);
-        AaruConsole.DebugWriteLine("ADFS Plugin", "drSb.skew = {0}", drSb.skew);
-        AaruConsole.DebugWriteLine("ADFS Plugin", "drSb.bootoption = {0}", drSb.bootoption);
-        AaruConsole.DebugWriteLine("ADFS Plugin", "drSb.lowsector = {0}", drSb.lowsector);
-        AaruConsole.DebugWriteLine("ADFS Plugin", "drSb.nzones = {0}", drSb.nzones);
-        AaruConsole.DebugWriteLine("ADFS Plugin", "drSb.zone_spare = {0}", drSb.zone_spare);
-        AaruConsole.DebugWriteLine("ADFS Plugin", "drSb.root = {0}", drSb.root);
-        AaruConsole.DebugWriteLine("ADFS Plugin", "drSb.disc_size = {0}", drSb.disc_size);
-        AaruConsole.DebugWriteLine("ADFS Plugin", "drSb.disc_id = {0}", drSb.disc_id);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "drSb.log2secsize = {0}", drSb.log2secsize);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "drSb.spt = {0}", drSb.spt);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "drSb.heads = {0}", drSb.heads);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "drSb.density = {0}", drSb.density);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "drSb.idlen = {0}", drSb.idlen);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "drSb.log2bpmb = {0}", drSb.log2bpmb);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "drSb.skew = {0}", drSb.skew);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "drSb.bootoption = {0}", drSb.bootoption);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "drSb.lowsector = {0}", drSb.lowsector);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "drSb.nzones = {0}", drSb.nzones);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "drSb.zone_spare = {0}", drSb.zone_spare);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "drSb.root = {0}", drSb.root);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "drSb.disc_size = {0}", drSb.disc_size);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "drSb.disc_id = {0}", drSb.disc_id);
 
-        AaruConsole.DebugWriteLine("ADFS Plugin", "drSb.disc_name = {0}",
+        AaruConsole.DebugWriteLine(MODULE_NAME, "drSb.disc_name = {0}",
                                    StringHandlers.CToString(drSb.disc_name, encoding));
 
-        AaruConsole.DebugWriteLine("ADFS Plugin", "drSb.disc_type = {0}", drSb.disc_type);
-        AaruConsole.DebugWriteLine("ADFS Plugin", "drSb.disc_size_high = {0}", drSb.disc_size_high);
-        AaruConsole.DebugWriteLine("ADFS Plugin", "drSb.flags = {0}", drSb.flags);
-        AaruConsole.DebugWriteLine("ADFS Plugin", "drSb.nzones_high = {0}", drSb.nzones_high);
-        AaruConsole.DebugWriteLine("ADFS Plugin", "drSb.format_version = {0}", drSb.format_version);
-        AaruConsole.DebugWriteLine("ADFS Plugin", "drSb.root_size = {0}", drSb.root_size);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "drSb.disc_type = {0}", drSb.disc_type);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "drSb.disc_size_high = {0}", drSb.disc_size_high);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "drSb.flags = {0}", drSb.flags);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "drSb.nzones_high = {0}", drSb.nzones_high);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "drSb.format_version = {0}", drSb.format_version);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "drSb.root_size = {0}", drSb.root_size);
 
         if(drSb.log2secsize is < 8 or > 10)
             return;

Aaru.Filesystems/AmigaDOS/AmigaDOS.cs

@@ -41,4 +41,5 @@ public sealed partial class AmigaDOSPlugin : IFilesystem
     public Guid Id => new("3c882400-208c-427d-a086-9119852a1bc7");
     /// <inheritdoc />
     public string Author => Authors.NataliaPortillo;
+    const string MODULE_NAME = "AmigaDOS plugin";
 }

Aaru.Filesystems/AmigaDOS/Info.cs

@@ -86,8 +86,8 @@ public sealed partial class AmigaDOSPlugin
         sector[4] = sector[5] = sector[6] = sector[7] = 0;
         uint bsum             = AmigaBootChecksum(sector);
 
-        AaruConsole.DebugWriteLine("AmigaDOS plugin", "bblk.checksum = 0x{0:X8}", bblk.checksum);
-        AaruConsole.DebugWriteLine("AmigaDOS plugin", "bsum = 0x{0:X8}", bsum);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "bblk.checksum = 0x{0:X8}", bblk.checksum);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "bsum = 0x{0:X8}", bsum);
 
         ulong bRootPtr = 0;
 
@@ -95,7 +95,7 @@ public sealed partial class AmigaDOSPlugin
         if(bsum == bblk.checksum)
         {
             bRootPtr = bblk.root_ptr + partition.Start;
-            AaruConsole.DebugWriteLine("AmigaDOS plugin", Localization.Bootblock_points_to_0_as_Rootblock, bRootPtr);
+            AaruConsole.DebugWriteLine(MODULE_NAME, Localization.Bootblock_points_to_0_as_Rootblock, bRootPtr);
         }
 
         ulong[] rootPtrs =
@@ -111,7 +111,7 @@ public sealed partial class AmigaDOSPlugin
         // So to handle even number of sectors
         foreach(ulong rootPtr in rootPtrs.Where(rootPtr => rootPtr < partition.End && rootPtr >= partition.Start))
         {
-            AaruConsole.DebugWriteLine("AmigaDOS plugin", Localization.Searching_for_Rootblock_in_sector_0, rootPtr);
+            AaruConsole.DebugWriteLine(MODULE_NAME, Localization.Searching_for_Rootblock_in_sector_0, rootPtr);
 
             errno = imagePlugin.ReadSector(rootPtr, out sector);
 
@@ -119,20 +119,20 @@ public sealed partial class AmigaDOSPlugin
                 continue;
 
             rblk.type = BigEndianBitConverter.ToUInt32(sector, 0x00);
-            AaruConsole.DebugWriteLine("AmigaDOS plugin", "rblk.type = {0}", rblk.type);
+            AaruConsole.DebugWriteLine(MODULE_NAME, "rblk.type = {0}", rblk.type);
 
             if(rblk.type != TYPE_HEADER)
                 continue;
 
             rblk.hashTableSize = BigEndianBitConverter.ToUInt32(sector, 0x0C);
 
-            AaruConsole.DebugWriteLine("AmigaDOS plugin", "rblk.hashTableSize = {0}", rblk.hashTableSize);
+            AaruConsole.DebugWriteLine(MODULE_NAME, "rblk.hashTableSize = {0}", rblk.hashTableSize);
 
             uint blockSize       = (rblk.hashTableSize + 56) * 4;
             uint sectorsPerBlock = (uint)(blockSize / sector.Length);
 
-            AaruConsole.DebugWriteLine("AmigaDOS plugin", "blockSize = {0}", blockSize);
-            AaruConsole.DebugWriteLine("AmigaDOS plugin", "sectorsPerBlock = {0}", sectorsPerBlock);
+            AaruConsole.DebugWriteLine(MODULE_NAME, "blockSize = {0}", blockSize);
+            AaruConsole.DebugWriteLine(MODULE_NAME, "sectorsPerBlock = {0}", sectorsPerBlock);
 
             if(blockSize % sector.Length > 0)
                 sectorsPerBlock++;
@@ -150,11 +150,11 @@ public sealed partial class AmigaDOSPlugin
             sector[20]    = sector[21] = sector[22] = sector[23] = 0;
             uint rsum                  = AmigaChecksum(sector);
 
-            AaruConsole.DebugWriteLine("AmigaDOS plugin", "rblk.checksum = 0x{0:X8}", rblk.checksum);
-            AaruConsole.DebugWriteLine("AmigaDOS plugin", "rsum = 0x{0:X8}", rsum);
+            AaruConsole.DebugWriteLine(MODULE_NAME, "rblk.checksum = 0x{0:X8}", rblk.checksum);
+            AaruConsole.DebugWriteLine(MODULE_NAME, "rsum = 0x{0:X8}", rsum);
 
             rblk.sec_type = BigEndianBitConverter.ToUInt32(sector, sector.Length - 4);
-            AaruConsole.DebugWriteLine("AmigaDOS plugin", "rblk.sec_type = {0}", rblk.sec_type);
+            AaruConsole.DebugWriteLine(MODULE_NAME, "rblk.sec_type = {0}", rblk.sec_type);
 
             if(rblk.sec_type == SUBTYPE_ROOT &&
                rblk.checksum == rsum)
@@ -189,7 +189,7 @@ public sealed partial class AmigaDOSPlugin
         if(bsum == bootBlk.checksum)
         {
             bRootPtr = bootBlk.root_ptr + partition.Start;
-            AaruConsole.DebugWriteLine("AmigaDOS plugin", Localization.Bootblock_points_to_0_as_Rootblock, bRootPtr);
+            AaruConsole.DebugWriteLine(MODULE_NAME, Localization.Bootblock_points_to_0_as_Rootblock, bRootPtr);
         }
 
         ulong[] rootPtrs =
@@ -209,7 +209,7 @@ public sealed partial class AmigaDOSPlugin
         // So to handle even number of sectors
         foreach(ulong rootPtr in rootPtrs.Where(rootPtr => rootPtr < partition.End && rootPtr >= partition.Start))
         {
-            AaruConsole.DebugWriteLine("AmigaDOS plugin", Localization.Searching_for_Rootblock_in_sector_0, rootPtr);
+            AaruConsole.DebugWriteLine(MODULE_NAME, Localization.Searching_for_Rootblock_in_sector_0, rootPtr);
 
             errno = imagePlugin.ReadSector(rootPtr, out rootBlockSector);
 
@@ -217,20 +217,20 @@ public sealed partial class AmigaDOSPlugin
                 continue;
 
             rootBlk.type = BigEndianBitConverter.ToUInt32(rootBlockSector, 0x00);
-            AaruConsole.DebugWriteLine("AmigaDOS plugin", "rootBlk.type = {0}", rootBlk.type);
+            AaruConsole.DebugWriteLine(MODULE_NAME, "rootBlk.type = {0}", rootBlk.type);
 
             if(rootBlk.type != TYPE_HEADER)
                 continue;
 
             rootBlk.hashTableSize = BigEndianBitConverter.ToUInt32(rootBlockSector, 0x0C);
 
-            AaruConsole.DebugWriteLine("AmigaDOS plugin", "rootBlk.hashTableSize = {0}", rootBlk.hashTableSize);
+            AaruConsole.DebugWriteLine(MODULE_NAME, "rootBlk.hashTableSize = {0}", rootBlk.hashTableSize);
 
             blockSize = (rootBlk.hashTableSize + 56) * 4;
             uint sectorsPerBlock = (uint)(blockSize / rootBlockSector.Length);
 
-            AaruConsole.DebugWriteLine("AmigaDOS plugin", "blockSize = {0}", blockSize);
-            AaruConsole.DebugWriteLine("AmigaDOS plugin", "sectorsPerBlock = {0}", sectorsPerBlock);
+            AaruConsole.DebugWriteLine(MODULE_NAME, "blockSize = {0}", blockSize);
+            AaruConsole.DebugWriteLine(MODULE_NAME, "sectorsPerBlock = {0}", sectorsPerBlock);
 
             if(blockSize % rootBlockSector.Length > 0)
                 sectorsPerBlock++;
@@ -248,11 +248,11 @@ public sealed partial class AmigaDOSPlugin
             rootBlockSector[20] = rootBlockSector[21] = rootBlockSector[22] = rootBlockSector[23] = 0;
             uint rsum                                 = AmigaChecksum(rootBlockSector);
 
-            AaruConsole.DebugWriteLine("AmigaDOS plugin", "rootBlk.checksum = 0x{0:X8}", rootBlk.checksum);
-            AaruConsole.DebugWriteLine("AmigaDOS plugin", "rsum = 0x{0:X8}", rsum);
+            AaruConsole.DebugWriteLine(MODULE_NAME, "rootBlk.checksum = 0x{0:X8}", rootBlk.checksum);
+            AaruConsole.DebugWriteLine(MODULE_NAME, "rsum = 0x{0:X8}", rsum);
 
             rootBlk.sec_type = BigEndianBitConverter.ToUInt32(rootBlockSector, rootBlockSector.Length - 4);
-            AaruConsole.DebugWriteLine("AmigaDOS plugin", "rootBlk.sec_type = {0}", rootBlk.sec_type);
+            AaruConsole.DebugWriteLine(MODULE_NAME, "rootBlk.sec_type = {0}", rootBlk.sec_type);
 
             if(rootBlk.sec_type != SUBTYPE_ROOT ||
                rootBlk.checksum != rsum)

Aaru.Filesystems/AppleDOS/AppleDOS.cs

@@ -40,6 +40,7 @@ public sealed partial class AppleDOS : IReadOnlyFilesystem
 {
     // Do not translate
     const string FS_TYPE     = "appledos";
+    const string MODULE_NAME = "Apple DOS plugin";
     bool         _debug;
     IMediaImage  _device;
     Encoding     _encoding;

Aaru.Filesystems/AppleDOS/Super.cs

@@ -52,21 +52,21 @@ public sealed partial class AppleDOS
         if(_device.Info.Sectors != 455 &&
            _device.Info.Sectors != 560)
         {
-            AaruConsole.DebugWriteLine("Apple DOS plugin", Localization.Incorrect_device_size);
+            AaruConsole.DebugWriteLine(MODULE_NAME, Localization.Incorrect_device_size);
 
             return ErrorNumber.InOutError;
         }
 
         if(_start > 0)
         {
-            AaruConsole.DebugWriteLine("Apple DOS plugin", Localization.Partitions_are_not_supported);
+            AaruConsole.DebugWriteLine(MODULE_NAME, Localization.Partitions_are_not_supported);
 
             return ErrorNumber.InOutError;
         }
 
         if(_device.Info.SectorSize != 256)
         {
-            AaruConsole.DebugWriteLine("Apple DOS plugin", Localization.Incorrect_sector_size);
+            AaruConsole.DebugWriteLine(MODULE_NAME, Localization.Incorrect_sector_size);
 
             return ErrorNumber.InOutError;
         }
@@ -89,7 +89,7 @@ public sealed partial class AppleDOS
 
         if(error != ErrorNumber.NoError)
         {
-            AaruConsole.DebugWriteLine("Apple DOS plugin", Localization.Unable_to_read_catalog);
+            AaruConsole.DebugWriteLine(MODULE_NAME, Localization.Unable_to_read_catalog);
 
             return error;
         }
@@ -100,7 +100,7 @@ public sealed partial class AppleDOS
 
         if(error != ErrorNumber.NoError)
         {
-            AaruConsole.DebugWriteLine("Apple DOS plugin", Localization.Unable_cache_all_files);
+            AaruConsole.DebugWriteLine(MODULE_NAME, Localization.Unable_cache_all_files);
 
             return error;
         }

Aaru.Filesystems/AppleMFS/AppleMFS.cs

@@ -39,6 +39,7 @@ namespace Aaru.Filesystems;
 /// <summary>Implements the Apple Macintosh File System</summary>
 public sealed partial class AppleMFS : IReadOnlyFilesystem
 {
+    const string                MODULE_NAME = "Apple MFS plugin";
     bool                        _mounted;
     bool                        _debug;
     IMediaImage                 _device;

Aaru.Filesystems/AppleMFS/Dir.cs

@@ -159,23 +159,23 @@ public sealed partial class AppleMFS
 
                 _filenameToId.Add(lowerFilename, entry.flFlNum);
 
-                AaruConsole.DebugWriteLine("DEBUG (AppleMFS plugin)", "entry.flFlags = {0}", entry.flFlags);
-                AaruConsole.DebugWriteLine("DEBUG (AppleMFS plugin)", "entry.flTyp = {0}", entry.flTyp);
-                AaruConsole.DebugWriteLine("DEBUG (AppleMFS plugin)", "entry.flFlNum = {0}", entry.flFlNum);
-                AaruConsole.DebugWriteLine("DEBUG (AppleMFS plugin)", "entry.flStBlk = {0}", entry.flStBlk);
-                AaruConsole.DebugWriteLine("DEBUG (AppleMFS plugin)", "entry.flLgLen = {0}", entry.flLgLen);
-                AaruConsole.DebugWriteLine("DEBUG (AppleMFS plugin)", "entry.flPyLen = {0}", entry.flPyLen);
-                AaruConsole.DebugWriteLine("DEBUG (AppleMFS plugin)", "entry.flRStBlk = {0}", entry.flRStBlk);
-                AaruConsole.DebugWriteLine("DEBUG (AppleMFS plugin)", "entry.flRLgLen = {0}", entry.flRLgLen);
-                AaruConsole.DebugWriteLine("DEBUG (AppleMFS plugin)", "entry.flRPyLen = {0}", entry.flRPyLen);
+                AaruConsole.DebugWriteLine(MODULE_NAME, "entry.flFlags = {0}", entry.flFlags);
+                AaruConsole.DebugWriteLine(MODULE_NAME, "entry.flTyp = {0}", entry.flTyp);
+                AaruConsole.DebugWriteLine(MODULE_NAME, "entry.flFlNum = {0}", entry.flFlNum);
+                AaruConsole.DebugWriteLine(MODULE_NAME, "entry.flStBlk = {0}", entry.flStBlk);
+                AaruConsole.DebugWriteLine(MODULE_NAME, "entry.flLgLen = {0}", entry.flLgLen);
+                AaruConsole.DebugWriteLine(MODULE_NAME, "entry.flPyLen = {0}", entry.flPyLen);
+                AaruConsole.DebugWriteLine(MODULE_NAME, "entry.flRStBlk = {0}", entry.flRStBlk);
+                AaruConsole.DebugWriteLine(MODULE_NAME, "entry.flRLgLen = {0}", entry.flRLgLen);
+                AaruConsole.DebugWriteLine(MODULE_NAME, "entry.flRPyLen = {0}", entry.flRPyLen);
 
-                AaruConsole.DebugWriteLine("DEBUG (AppleMFS plugin)", "entry.flCrDat = {0}",
+                AaruConsole.DebugWriteLine(MODULE_NAME, "entry.flCrDat = {0}",
                                            DateHandlers.MacToDateTime(entry.flCrDat));
 
-                AaruConsole.DebugWriteLine("DEBUG (AppleMFS plugin)", "entry.flMdDat = {0}",
+                AaruConsole.DebugWriteLine(MODULE_NAME, "entry.flMdDat = {0}",
                                            DateHandlers.MacToDateTime(entry.flMdDat));
 
-                AaruConsole.DebugWriteLine("DEBUG (AppleMFS plugin)", "entry.flNam0 = {0}",
+                AaruConsole.DebugWriteLine(MODULE_NAME, "entry.flNam0 = {0}",
                                            StringHandlers.PascalToString(entry.flNam, _encoding));
             }
 

Aaru.Filesystems/BTRFS/BTRFS.cs

@@ -45,4 +45,5 @@ public sealed partial class BTRFS : IFilesystem
     public Guid Id => new("C904CF15-5222-446B-B7DB-02EAC5D781B3");
     /// <inheritdoc />
     public string Author => Authors.NataliaPortillo;
+    const string MODULE_NAME = "BTRFS Plugin";
 }

Aaru.Filesystems/BTRFS/Info.cs

@@ -72,10 +72,10 @@ public sealed partial class BTRFS
             return false;
         }
 
-        AaruConsole.DebugWriteLine("BTRFS Plugin", "sbSectorOff = {0}", sbSectorOff);
-        AaruConsole.DebugWriteLine("BTRFS Plugin", "sbSectorSize = {0}", sbSectorSize);
-        AaruConsole.DebugWriteLine("BTRFS Plugin", "partition.PartitionStartSector = {0}", partition.Start);
-        AaruConsole.DebugWriteLine("BTRFS Plugin", "btrfsSb.magic = 0x{0:X16}", btrfsSb.magic);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "sbSectorOff = {0}", sbSectorOff);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "sbSectorSize = {0}", sbSectorSize);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "partition.PartitionStartSector = {0}", partition.Start);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "btrfsSb.magic = 0x{0:X16}", btrfsSb.magic);
 
         return btrfsSb.magic == BTRFS_MAGIC;
     }
@@ -98,66 +98,66 @@ public sealed partial class BTRFS
 
         SuperBlock btrfsSb = Marshal.ByteArrayToStructureLittleEndian<SuperBlock>(sector);
 
-        AaruConsole.DebugWriteLine("BTRFS Plugin", "btrfsSb.checksum = {0}", btrfsSb.checksum);
-        AaruConsole.DebugWriteLine("BTRFS Plugin", "btrfsSb.uuid = {0}", btrfsSb.uuid);
-        AaruConsole.DebugWriteLine("BTRFS Plugin", "btrfsSb.pba = {0}", btrfsSb.pba);
-        AaruConsole.DebugWriteLine("BTRFS Plugin", "btrfsSb.flags = {0}", btrfsSb.flags);
-        AaruConsole.DebugWriteLine("BTRFS Plugin", "btrfsSb.magic = {0}", btrfsSb.magic);
-        AaruConsole.DebugWriteLine("BTRFS Plugin", "btrfsSb.generation = {0}", btrfsSb.generation);
-        AaruConsole.DebugWriteLine("BTRFS Plugin", "btrfsSb.root_lba = {0}", btrfsSb.root_lba);
-        AaruConsole.DebugWriteLine("BTRFS Plugin", "btrfsSb.chunk_lba = {0}", btrfsSb.chunk_lba);
-        AaruConsole.DebugWriteLine("BTRFS Plugin", "btrfsSb.log_lba = {0}", btrfsSb.log_lba);
-        AaruConsole.DebugWriteLine("BTRFS Plugin", "btrfsSb.log_root_transid = {0}", btrfsSb.log_root_transid);
-        AaruConsole.DebugWriteLine("BTRFS Plugin", "btrfsSb.total_bytes = {0}", btrfsSb.total_bytes);
-        AaruConsole.DebugWriteLine("BTRFS Plugin", "btrfsSb.bytes_used = {0}", btrfsSb.bytes_used);
-        AaruConsole.DebugWriteLine("BTRFS Plugin", "btrfsSb.root_dir_objectid = {0}", btrfsSb.root_dir_objectid);
-        AaruConsole.DebugWriteLine("BTRFS Plugin", "btrfsSb.num_devices = {0}", btrfsSb.num_devices);
-        AaruConsole.DebugWriteLine("BTRFS Plugin", "btrfsSb.sectorsize = {0}", btrfsSb.sectorsize);
-        AaruConsole.DebugWriteLine("BTRFS Plugin", "btrfsSb.nodesize = {0}", btrfsSb.nodesize);
-        AaruConsole.DebugWriteLine("BTRFS Plugin", "btrfsSb.leafsize = {0}", btrfsSb.leafsize);
-        AaruConsole.DebugWriteLine("BTRFS Plugin", "btrfsSb.stripesize = {0}", btrfsSb.stripesize);
-        AaruConsole.DebugWriteLine("BTRFS Plugin", "btrfsSb.n = {0}", btrfsSb.n);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "btrfsSb.checksum = {0}", btrfsSb.checksum);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "btrfsSb.uuid = {0}", btrfsSb.uuid);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "btrfsSb.pba = {0}", btrfsSb.pba);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "btrfsSb.flags = {0}", btrfsSb.flags);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "btrfsSb.magic = {0}", btrfsSb.magic);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "btrfsSb.generation = {0}", btrfsSb.generation);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "btrfsSb.root_lba = {0}", btrfsSb.root_lba);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "btrfsSb.chunk_lba = {0}", btrfsSb.chunk_lba);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "btrfsSb.log_lba = {0}", btrfsSb.log_lba);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "btrfsSb.log_root_transid = {0}", btrfsSb.log_root_transid);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "btrfsSb.total_bytes = {0}", btrfsSb.total_bytes);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "btrfsSb.bytes_used = {0}", btrfsSb.bytes_used);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "btrfsSb.root_dir_objectid = {0}", btrfsSb.root_dir_objectid);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "btrfsSb.num_devices = {0}", btrfsSb.num_devices);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "btrfsSb.sectorsize = {0}", btrfsSb.sectorsize);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "btrfsSb.nodesize = {0}", btrfsSb.nodesize);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "btrfsSb.leafsize = {0}", btrfsSb.leafsize);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "btrfsSb.stripesize = {0}", btrfsSb.stripesize);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "btrfsSb.n = {0}", btrfsSb.n);
 
-        AaruConsole.DebugWriteLine("BTRFS Plugin", "btrfsSb.chunk_root_generation = {0}",
+        AaruConsole.DebugWriteLine(MODULE_NAME, "btrfsSb.chunk_root_generation = {0}",
                                    btrfsSb.chunk_root_generation);
 
-        AaruConsole.DebugWriteLine("BTRFS Plugin", "btrfsSb.compat_flags = 0x{0:X16}", btrfsSb.compat_flags);
-        AaruConsole.DebugWriteLine("BTRFS Plugin", "btrfsSb.compat_ro_flags = 0x{0:X16}", btrfsSb.compat_ro_flags);
-        AaruConsole.DebugWriteLine("BTRFS Plugin", "btrfsSb.incompat_flags = 0x{0:X16}", btrfsSb.incompat_flags);
-        AaruConsole.DebugWriteLine("BTRFS Plugin", "btrfsSb.csum_type = {0}", btrfsSb.csum_type);
-        AaruConsole.DebugWriteLine("BTRFS Plugin", "btrfsSb.root_level = {0}", btrfsSb.root_level);
-        AaruConsole.DebugWriteLine("BTRFS Plugin", "btrfsSb.chunk_root_level = {0}", btrfsSb.chunk_root_level);
-        AaruConsole.DebugWriteLine("BTRFS Plugin", "btrfsSb.log_root_level = {0}", btrfsSb.log_root_level);
-        AaruConsole.DebugWriteLine("BTRFS Plugin", "btrfsSb.dev_item.id = 0x{0:X16}", btrfsSb.dev_item.id);
-        AaruConsole.DebugWriteLine("BTRFS Plugin", "btrfsSb.dev_item.bytes = {0}", btrfsSb.dev_item.bytes);
-        AaruConsole.DebugWriteLine("BTRFS Plugin", "btrfsSb.dev_item.used = {0}", btrfsSb.dev_item.used);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "btrfsSb.compat_flags = 0x{0:X16}", btrfsSb.compat_flags);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "btrfsSb.compat_ro_flags = 0x{0:X16}", btrfsSb.compat_ro_flags);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "btrfsSb.incompat_flags = 0x{0:X16}", btrfsSb.incompat_flags);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "btrfsSb.csum_type = {0}", btrfsSb.csum_type);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "btrfsSb.root_level = {0}", btrfsSb.root_level);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "btrfsSb.chunk_root_level = {0}", btrfsSb.chunk_root_level);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "btrfsSb.log_root_level = {0}", btrfsSb.log_root_level);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "btrfsSb.dev_item.id = 0x{0:X16}", btrfsSb.dev_item.id);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "btrfsSb.dev_item.bytes = {0}", btrfsSb.dev_item.bytes);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "btrfsSb.dev_item.used = {0}", btrfsSb.dev_item.used);
 
-        AaruConsole.DebugWriteLine("BTRFS Plugin", "btrfsSb.dev_item.optimal_align = {0}",
+        AaruConsole.DebugWriteLine(MODULE_NAME, "btrfsSb.dev_item.optimal_align = {0}",
                                    btrfsSb.dev_item.optimal_align);
 
-        AaruConsole.DebugWriteLine("BTRFS Plugin", "btrfsSb.dev_item.optimal_width = {0}",
+        AaruConsole.DebugWriteLine(MODULE_NAME, "btrfsSb.dev_item.optimal_width = {0}",
                                    btrfsSb.dev_item.optimal_width);
 
-        AaruConsole.DebugWriteLine("BTRFS Plugin", "btrfsSb.dev_item.minimal_size = {0}",
+        AaruConsole.DebugWriteLine(MODULE_NAME, "btrfsSb.dev_item.minimal_size = {0}",
                                    btrfsSb.dev_item.minimal_size);
 
-        AaruConsole.DebugWriteLine("BTRFS Plugin", "btrfsSb.dev_item.type = {0}", btrfsSb.dev_item.type);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "btrfsSb.dev_item.type = {0}", btrfsSb.dev_item.type);
 
-        AaruConsole.DebugWriteLine("BTRFS Plugin", "btrfsSb.dev_item.generation = {0}", btrfsSb.dev_item.generation);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "btrfsSb.dev_item.generation = {0}", btrfsSb.dev_item.generation);
 
-        AaruConsole.DebugWriteLine("BTRFS Plugin", "btrfsSb.dev_item.start_offset = {0}",
+        AaruConsole.DebugWriteLine(MODULE_NAME, "btrfsSb.dev_item.start_offset = {0}",
                                    btrfsSb.dev_item.start_offset);
 
-        AaruConsole.DebugWriteLine("BTRFS Plugin", "btrfsSb.dev_item.dev_group = {0}", btrfsSb.dev_item.dev_group);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "btrfsSb.dev_item.dev_group = {0}", btrfsSb.dev_item.dev_group);
 
-        AaruConsole.DebugWriteLine("BTRFS Plugin", "btrfsSb.dev_item.seek_speed = {0}", btrfsSb.dev_item.seek_speed);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "btrfsSb.dev_item.seek_speed = {0}", btrfsSb.dev_item.seek_speed);
 
-        AaruConsole.DebugWriteLine("BTRFS Plugin", "btrfsSb.dev_item.bandwidth = {0}", btrfsSb.dev_item.bandwidth);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "btrfsSb.dev_item.bandwidth = {0}", btrfsSb.dev_item.bandwidth);
 
-        AaruConsole.DebugWriteLine("BTRFS Plugin", "btrfsSb.dev_item.device_uuid = {0}", btrfsSb.dev_item.device_uuid);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "btrfsSb.dev_item.device_uuid = {0}", btrfsSb.dev_item.device_uuid);
 
-        AaruConsole.DebugWriteLine("BTRFS Plugin", "btrfsSb.dev_item.uuid = {0}", btrfsSb.dev_item.uuid);
-        AaruConsole.DebugWriteLine("BTRFS Plugin", "btrfsSb.label = {0}", btrfsSb.label);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "btrfsSb.dev_item.uuid = {0}", btrfsSb.dev_item.uuid);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "btrfsSb.label = {0}", btrfsSb.label);
 
         sbInformation.AppendLine(Localization.B_tree_filesystem);
         sbInformation.AppendFormat(Localization.UUID_0, btrfsSb.uuid).AppendLine();

Aaru.Filesystems/CPM/CPM.cs

@@ -97,4 +97,6 @@ public sealed partial class CPM : IReadOnlyFilesystem
 
     /// <inheritdoc />
     public Dictionary<string, string> Namespaces => null;
+
+    const string MODULE_NAME = "CP/M Plugin";
 }

Aaru.Filesystems/CPM/Info.cs

@@ -302,7 +302,7 @@ public sealed partial class CPM
                             _workingDefinition.skew = 2;
                             _workingDefinition.sofs = 0;
 
-                            AaruConsole.DebugWriteLine("CP/M Plugin", Localization.Found_Amstrad_superblock);
+                            AaruConsole.DebugWriteLine(MODULE_NAME, Localization.Found_Amstrad_superblock);
                         }
                     }
                 }
@@ -370,7 +370,7 @@ public sealed partial class CPM
                             imagePlugin.ReadSectors(firstDirectorySector + partition.Start, directoryLength,
                                                     out directory);
 
-                            AaruConsole.DebugWriteLine("CP/M Plugin", Localization.Found_CPM_86_hard_disk_superblock);
+                            AaruConsole.DebugWriteLine(MODULE_NAME, Localization.Found_CPM_86_hard_disk_superblock);
 
                             // Build a CP/M disk definition
                             _workingDefinition = new CpmDefinition
@@ -890,7 +890,7 @@ public sealed partial class CPM
                         imagePlugin.ReadSectors(firstDirectorySector86 + partition.Start, directoryLength,
                                                 out directory);
 
-                        AaruConsole.DebugWriteLine("CP/M Plugin", Localization.Found_CPM_86_floppy_identifier);
+                        AaruConsole.DebugWriteLine(MODULE_NAME, Localization.Found_CPM_86_floppy_identifier);
                     }
                 }
             }
@@ -900,7 +900,7 @@ public sealed partial class CPM
             {
                 if(CheckDir(directory))
                 {
-                    AaruConsole.DebugWriteLine("CP/M Plugin", Localization.First_directory_block_seems_correct);
+                    AaruConsole.DebugWriteLine(MODULE_NAME, Localization.First_directory_block_seems_correct);
 
                     return true;
                 }
@@ -912,13 +912,13 @@ public sealed partial class CPM
             if(!_cpmFound)
             {
                 // Load all definitions
-                AaruConsole.DebugWriteLine("CP/M Plugin", Localization.Trying_to_load_definitions);
+                AaruConsole.DebugWriteLine(MODULE_NAME, Localization.Trying_to_load_definitions);
 
                 if(LoadDefinitions()                      &&
                    _definitions?.definitions      != null &&
                    _definitions.definitions.Count > 0)
                 {
-                    AaruConsole.DebugWriteLine("CP/M Plugin", Localization.Trying_all_known_definitions);
+                    AaruConsole.DebugWriteLine(MODULE_NAME, Localization.Trying_all_known_definitions);
 
                     foreach(CpmDefinition def in from def in _definitions.definitions let sectors =
                                                      (ulong)(def.cylinders * def.sides * def.sectorsPerTrack)
@@ -926,7 +926,7 @@ public sealed partial class CPM
                                                        def.bytesPerSector == imagePlugin.Info.SectorSize select def)
                     {
                         // Definition seems to describe current disk, at least, same number of volume sectors and bytes per sector
-                        AaruConsole.DebugWriteLine("CP/M Plugin", Localization.Trying_definition_0, def.comment);
+                        AaruConsole.DebugWriteLine(MODULE_NAME, Localization.Trying_definition_0, def.comment);
                         ulong offset;
 
                         if(def.sofs != 0)
@@ -977,7 +977,7 @@ public sealed partial class CPM
                             else if(string.Compare(def.order, "COLUMBIA",
                                                    StringComparison.InvariantCultureIgnoreCase) == 0)
                             {
-                                AaruConsole.DebugWriteLine("CP/M Plugin",
+                                AaruConsole.DebugWriteLine(MODULE_NAME,
                                                            Localization.
                                                                Dont_know_how_to_handle_COLUMBIA_ordering_not_proceeding_with_this_definition);
 
@@ -988,7 +988,7 @@ public sealed partial class CPM
                             else if(string.Compare(def.order, "EAGLE", StringComparison.InvariantCultureIgnoreCase) ==
                                     0)
                             {
-                                AaruConsole.DebugWriteLine("CP/M Plugin",
+                                AaruConsole.DebugWriteLine(MODULE_NAME,
                                                            Localization.
                                                                Don_know_how_to_handle_EAGLE_ordering_not_proceeding_with_this_definition);
 
@@ -996,7 +996,7 @@ public sealed partial class CPM
                             }
                             else
                             {
-                                AaruConsole.DebugWriteLine("CP/M Plugin",
+                                AaruConsole.DebugWriteLine(MODULE_NAME,
                                                            Localization.
                                                                Unknown_order_type_0_not_proceeding_with_this_definition,
                                                            def.order);
@@ -1024,7 +1024,7 @@ public sealed partial class CPM
                         directory = ms.ToArray();
 
                         if(def.evenOdd)
-                            AaruConsole.DebugWriteLine("CP/M Plugin",
+                            AaruConsole.DebugWriteLine(MODULE_NAME,
                                                        Localization.
                                                            Definition_contains_EVEN_ODD_field_with_unknown_meaning_detection_may_be_wrong);
 
@@ -1036,7 +1036,7 @@ public sealed partial class CPM
                         // Check the directory
                         if(CheckDir(directory))
                         {
-                            AaruConsole.DebugWriteLine("CP/M Plugin", Localization.Definition_0_has_a_correct_directory,
+                            AaruConsole.DebugWriteLine(MODULE_NAME, Localization.Definition_0_has_a_correct_directory,
                                                        def.comment);
 
                             // Build a Disc Parameter Block

Aaru.Filesystems/CPM/Super.cs

@@ -105,7 +105,7 @@ public sealed partial class CPM
                         _workingDefinition.side1.sectorIds.Length + _workingDefinition.side2.sectorIds.Length;
 
                 // TODO: Implement CYLINDERS ordering
-                AaruConsole.DebugWriteLine("CP/M Plugin", Localization.CYLINDERS_ordering_not_yet_implemented);
+                AaruConsole.DebugWriteLine(MODULE_NAME, Localization.CYLINDERS_ordering_not_yet_implemented);
 
                 return ErrorNumber.NotImplemented;
             }
@@ -114,7 +114,7 @@ public sealed partial class CPM
             else if(string.Compare(_workingDefinition.order, "COLUMBIA", StringComparison.InvariantCultureIgnoreCase) ==
                     0)
             {
-                AaruConsole.DebugWriteLine("CP/M Plugin",
+                AaruConsole.DebugWriteLine(MODULE_NAME,
                                            Localization.
                                                Dont_know_how_to_handle_COLUMBIA_ordering_not_proceeding_with_this_definition);
 
@@ -124,7 +124,7 @@ public sealed partial class CPM
             // TODO: Implement EAGLE ordering
             else if(string.Compare(_workingDefinition.order, "EAGLE", StringComparison.InvariantCultureIgnoreCase) == 0)
             {
-                AaruConsole.DebugWriteLine("CP/M Plugin",
+                AaruConsole.DebugWriteLine(MODULE_NAME,
                                            Localization.
                                                Don_know_how_to_handle_EAGLE_ordering_not_proceeding_with_this_definition);
 
@@ -132,7 +132,7 @@ public sealed partial class CPM
             }
             else
             {
-                AaruConsole.DebugWriteLine("CP/M Plugin",
+                AaruConsole.DebugWriteLine(MODULE_NAME,
                                            Localization.Unknown_order_type_0_not_proceeding_with_this_definition,
                                            _workingDefinition.order);
 
@@ -146,7 +146,7 @@ public sealed partial class CPM
         if(_workingDefinition.sides                                                                       == 1 ||
            string.Compare(_workingDefinition.order, "SIDES", StringComparison.InvariantCultureIgnoreCase) == 0)
         {
-            AaruConsole.DebugWriteLine("CP/M Plugin", Localization.Deinterleaving_whole_volume);
+            AaruConsole.DebugWriteLine(MODULE_NAME, Localization.Deinterleaving_whole_volume);
 
             for(int p = 0; p <= (int)(partition.End - partition.Start); p++)
             {
@@ -171,7 +171,7 @@ public sealed partial class CPM
         int                       sectorsPerBlock  = 0;
         Dictionary<ulong, byte[]> allocationBlocks = new();
 
-        AaruConsole.DebugWriteLine("CP/M Plugin", Localization.Creating_allocation_blocks);
+        AaruConsole.DebugWriteLine(MODULE_NAME, Localization.Creating_allocation_blocks);
 
         // For each volume sector
         for(ulong a = 0; a < (ulong)deinterleavedSectors.Count; a++)
@@ -206,7 +206,7 @@ public sealed partial class CPM
                 allocationBlocks.Add(blockNo++, sector);
         }
 
-        AaruConsole.DebugWriteLine("CP/M Plugin", Localization.Reading_directory);
+        AaruConsole.DebugWriteLine(MODULE_NAME, Localization.Reading_directory);
 
         int dirOff;
         int dirSectors = (_dpb.drm + 1) * 32 / _workingDefinition.bytesPerSector;
@@ -245,7 +245,7 @@ public sealed partial class CPM
         _labelUpdateDate   = null;
         _passwordCache     = new Dictionary<string, byte[]>();
 
-        AaruConsole.DebugWriteLine("CP/M Plugin", Localization.Traversing_directory);
+        AaruConsole.DebugWriteLine(MODULE_NAME, Localization.Traversing_directory);
 
         // For each directory entry
         for(int dOff = 0; dOff < directory.Length; dOff += 32)
@@ -720,7 +720,7 @@ public sealed partial class CPM
 
         // Cache all files. As CP/M maximum volume size is 8 Mib
         // this should not be a problem
-        AaruConsole.DebugWriteLine("CP/M Plugin", "Reading files.");
+        AaruConsole.DebugWriteLine(MODULE_NAME, "Reading files.");
         long usedBlocks = 0;
         _fileCache = new Dictionary<string, byte[]>();
 

Aaru.Filesystems/EFS/EFS.cs

@@ -41,4 +41,5 @@ public sealed partial class EFS : IFilesystem
     public Guid Id => new("52A43F90-9AF3-4391-ADFE-65598DEEABAB");
     /// <inheritdoc />
     public string Author => Authors.NataliaPortillo;
+    const string MODULE_NAME = "EFS plugin";
 }

Aaru.Filesystems/EFS/Info.cs

@@ -69,7 +69,7 @@ public sealed partial class EFS
 
             Superblock sb = Marshal.ByteArrayToStructureBigEndian<Superblock>(sbpiece);
 
-            AaruConsole.DebugWriteLine("EFS plugin", Localization.magic_at_0_equals_1_expected_2_or_3, 0x200,
+            AaruConsole.DebugWriteLine(MODULE_NAME, Localization.magic_at_0_equals_1_expected_2_or_3, 0x200,
                                        sb.sb_magic, EFS_MAGIC, EFS_MAGIC_NEW);
 
             if(sb.sb_magic is EFS_MAGIC or EFS_MAGIC_NEW)
@@ -92,7 +92,7 @@ public sealed partial class EFS
 
             Superblock sb = Marshal.ByteArrayToStructureBigEndian<Superblock>(sector);
 
-            AaruConsole.DebugWriteLine("EFS plugin", Localization.magic_at_0_equals_1_expected_2_or_3, 1, sb.sb_magic,
+            AaruConsole.DebugWriteLine(MODULE_NAME, Localization.magic_at_0_equals_1_expected_2_or_3, 1, sb.sb_magic,
                                        EFS_MAGIC, EFS_MAGIC_NEW);
 
             if(sb.sb_magic is EFS_MAGIC or EFS_MAGIC_NEW)
@@ -137,7 +137,7 @@ public sealed partial class EFS
 
             efsSb = Marshal.ByteArrayToStructureBigEndian<Superblock>(sbpiece);
 
-            AaruConsole.DebugWriteLine("EFS plugin", Localization.magic_at_0_X3_equals_1_expected_2_or_3, 0x200,
+            AaruConsole.DebugWriteLine(MODULE_NAME, Localization.magic_at_0_X3_equals_1_expected_2_or_3, 0x200,
                                        efsSb.sb_magic, EFS_MAGIC, EFS_MAGIC_NEW);
         }
         else
@@ -157,7 +157,7 @@ public sealed partial class EFS
 
             efsSb = Marshal.ByteArrayToStructureBigEndian<Superblock>(sector);
 
-            AaruConsole.DebugWriteLine("EFS plugin", Localization.magic_at_0_equals_1_expected_2_or_3, 1,
+            AaruConsole.DebugWriteLine(MODULE_NAME, Localization.magic_at_0_equals_1_expected_2_or_3, 1,
                                        efsSb.sb_magic, EFS_MAGIC, EFS_MAGIC_NEW);
         }
 

Aaru.Filesystems/FAT/BPB.cs

@@ -69,16 +69,16 @@ public sealed partial class FAT
         // Check correct branch for Human68k
         bool humanBranchCorrect = bpbSector[0] == 0x60 && bpbSector[1] >= 0x1C && bpbSector[1] < 0xFE;
 
-        AaruConsole.DebugWriteLine("FAT plugin", "humanClustersCorrect = {0}", humanClustersCorrect);
-        AaruConsole.DebugWriteLine("FAT plugin", "humanOemCorrect = {0}", humanOemCorrect);
-        AaruConsole.DebugWriteLine("FAT plugin", "humanBranchCorrect = {0}", humanBranchCorrect);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "humanClustersCorrect = {0}", humanClustersCorrect);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "humanOemCorrect = {0}", humanOemCorrect);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "humanBranchCorrect = {0}", humanBranchCorrect);
 
         // If all Human68k checks are correct, it is a Human68k FAT16
         bool useHumanBpb = humanClustersCorrect && humanOemCorrect && humanBranchCorrect && expectedClusters > 0;
 
         if(useHumanBpb)
         {
-            AaruConsole.DebugWriteLine("FAT plugin", Localization.Using_Human68k_BPB);
+            AaruConsole.DebugWriteLine(MODULE_NAME, Localization.Using_Human68k_BPB);
 
             fakeBpb.jump        = humanBpb.jump;
             fakeBpb.oem_name    = humanBpb.oem_name;
@@ -186,7 +186,7 @@ public sealed partial class FAT
                fat32Bpb is { spfat: 0, signature: 0x29 } &&
                Encoding.ASCII.GetString(fat32Bpb.fs_type) == "FAT32   ")
             {
-                AaruConsole.DebugWriteLine("FAT plugin", Localization.Using_FAT32_BPB);
+                AaruConsole.DebugWriteLine(MODULE_NAME, Localization.Using_FAT32_BPB);
                 minBootNearJump = 0x58;
 
                 return BpbKind.LongFat32;
@@ -196,7 +196,7 @@ public sealed partial class FAT
                correctSpcFat32Short     &&
                shortFat32Bpb is { fats_no: <= 2, sectors: 0 } and { spfat: 0, signature: 0x28 })
             {
-                AaruConsole.DebugWriteLine("FAT plugin", Localization.Using_short_FAT32_BPB);
+                AaruConsole.DebugWriteLine(MODULE_NAME, Localization.Using_short_FAT32_BPB);
 
                 minBootNearJump = 0x57;
 
@@ -210,7 +210,7 @@ public sealed partial class FAT
                msxBpb.spfat                            > 0                                    &&
                Encoding.ASCII.GetString(msxBpb.vol_id) == "VOL_ID")
             {
-                AaruConsole.DebugWriteLine("FAT plugin", Localization.Using_MSX_BPB);
+                AaruConsole.DebugWriteLine(MODULE_NAME, Localization.Using_MSX_BPB);
                 useMsxBpb = true;
             }
             else if(bitsInBpsApricot == 1                                             &&
@@ -220,7 +220,7 @@ public sealed partial class FAT
                     apricotBpb.mainBPB.spfat   > 0                                    &&
                     apricotBpb.partitionCount  == 0)
             {
-                AaruConsole.DebugWriteLine("FAT plugin", Localization.Using_Apricot_BPB);
+                AaruConsole.DebugWriteLine(MODULE_NAME, Localization.Using_Apricot_BPB);
                 useApricotBpb = true;
             }
             else if(bitsInBpsDos40 == 1                   &&
@@ -234,13 +234,13 @@ public sealed partial class FAT
                     if(ebpb.big_sectors <= partition.End - partition.Start + 1)
                         if(ebpb.signature == 0x29 || andosOemCorrect)
                         {
-                            AaruConsole.DebugWriteLine("FAT plugin", Localization.Using_DOS_4_0_BPB);
+                            AaruConsole.DebugWriteLine(MODULE_NAME, Localization.Using_DOS_4_0_BPB);
                             useExtendedBpb  = true;
                             minBootNearJump = 0x3C;
                         }
                         else
                         {
-                            AaruConsole.DebugWriteLine("FAT plugin", Localization.Using_DOS_3_4_BPB);
+                            AaruConsole.DebugWriteLine(MODULE_NAME, Localization.Using_DOS_3_4_BPB);
                             userShortExtendedBpb = true;
                             minBootNearJump      = 0x29;
                         }
@@ -248,13 +248,13 @@ public sealed partial class FAT
                 else if(ebpb.sectors <= partition.End - partition.Start + 1)
                     if(ebpb.signature == 0x29 || andosOemCorrect)
                     {
-                        AaruConsole.DebugWriteLine("FAT plugin", Localization.Using_DOS_4_0_BPB);
+                        AaruConsole.DebugWriteLine(MODULE_NAME, Localization.Using_DOS_4_0_BPB);
                         useExtendedBpb  = true;
                         minBootNearJump = 0x3C;
                     }
                     else
                     {
-                        AaruConsole.DebugWriteLine("FAT plugin", Localization.Using_DOS_3_4_BPB);
+                        AaruConsole.DebugWriteLine(MODULE_NAME, Localization.Using_DOS_3_4_BPB);
                         userShortExtendedBpb = true;
                         minBootNearJump      = 0x29;
                     }
@@ -269,7 +269,7 @@ public sealed partial class FAT
                    dos33Bpb.big_sectors > 0                &&
                    dos33Bpb.big_sectors <= partition.End - partition.Start + 1)
                 {
-                    AaruConsole.DebugWriteLine("FAT plugin", Localization.Using_DOS_3_3_BPB);
+                    AaruConsole.DebugWriteLine(MODULE_NAME, Localization.Using_DOS_3_3_BPB);
                     useDos33Bpb     = true;
                     minBootNearJump = 0x22;
                 }
@@ -282,12 +282,12 @@ public sealed partial class FAT
                         Encoding.ASCII.GetString(dos33Bpb.oem_name) != "NEXT    ") ||
                        partition.Type is "GEM" or "BGM")
                     {
-                        AaruConsole.DebugWriteLine("FAT plugin", Localization.Using_Atari_BPB);
+                        AaruConsole.DebugWriteLine(MODULE_NAME, Localization.Using_Atari_BPB);
                         useAtariBpb = true;
                     }
                     else
                     {
-                        AaruConsole.DebugWriteLine("FAT plugin", Localization.Using_DOS_3_3_BPB);
+                        AaruConsole.DebugWriteLine(MODULE_NAME, Localization.Using_DOS_3_3_BPB);
                         useDos33Bpb     = true;
                         minBootNearJump = 0x22;
                     }
@@ -296,7 +296,7 @@ public sealed partial class FAT
                     if(dos32Bpb.hsectors                    <= partition.Start &&
                        dos32Bpb.hsectors + dos32Bpb.sectors == dos32Bpb.total_sectors)
                     {
-                        AaruConsole.DebugWriteLine("FAT plugin", Localization.Using_DOS_3_2_BPB);
+                        AaruConsole.DebugWriteLine(MODULE_NAME, Localization.Using_DOS_3_2_BPB);
                         useDos32Bpb     = true;
                         minBootNearJump = 0x1E;
                     }
@@ -306,12 +306,12 @@ public sealed partial class FAT
                            (atariBpb.jump[0]                            == 0xE9 && atariBpb.jump[1] == 0x00 &&
                             Encoding.ASCII.GetString(dos33Bpb.oem_name) != "NEXT    "))
                         {
-                            AaruConsole.DebugWriteLine("FAT plugin", Localization.Using_Atari_BPB);
+                            AaruConsole.DebugWriteLine(MODULE_NAME, Localization.Using_Atari_BPB);
                             useAtariBpb = true;
                         }
                         else
                         {
-                            AaruConsole.DebugWriteLine("FAT plugin", Localization.Using_DOS_3_0_BPB);
+                            AaruConsole.DebugWriteLine(MODULE_NAME, Localization.Using_DOS_3_0_BPB);
                             useDos3Bpb      = true;
                             minBootNearJump = 0x1C;
                         }
@@ -321,12 +321,12 @@ public sealed partial class FAT
                            (atariBpb.jump[0]                            == 0xE9 && atariBpb.jump[1] == 0x00 &&
                             Encoding.ASCII.GetString(dos33Bpb.oem_name) != "NEXT    "))
                         {
-                            AaruConsole.DebugWriteLine("FAT plugin", Localization.Using_Atari_BPB);
+                            AaruConsole.DebugWriteLine(MODULE_NAME, Localization.Using_Atari_BPB);
                             useAtariBpb = true;
                         }
                         else
                         {
-                            AaruConsole.DebugWriteLine("FAT plugin", Localization.Using_DOS_2_0_BPB);
+                            AaruConsole.DebugWriteLine(MODULE_NAME, Localization.Using_DOS_2_0_BPB);
                             useDos2Bpb      = true;
                             minBootNearJump = 0x16;
                         }
@@ -396,7 +396,7 @@ public sealed partial class FAT
                fat1Sector0[1]          == 0xFF &&
                validRootDir)
             {
-                AaruConsole.DebugWriteLine("FAT plugin", Localization.Using_DEC_Rainbow_hardcoded_BPB);
+                AaruConsole.DebugWriteLine(MODULE_NAME, Localization.Using_DEC_Rainbow_hardcoded_BPB);
                 fakeBpb.bps       = 512;
                 fakeBpb.spc       = 1;
                 fakeBpb.rsectors  = 20;
@@ -436,7 +436,7 @@ public sealed partial class FAT
                 case 0xE5:
                     if(imagePlugin.Info is { Sectors: 2002, SectorSize: 128 })
                     {
-                        AaruConsole.DebugWriteLine("FAT plugin", Localization.Using_hardcoded_BPB);
+                        AaruConsole.DebugWriteLine(MODULE_NAME, Localization.Using_hardcoded_BPB);
                         fakeBpb.bps      = 128;
                         fakeBpb.spc      = 4;
                         fakeBpb.rsectors = 1;
@@ -455,7 +455,7 @@ public sealed partial class FAT
                     switch(imagePlugin.Info.Sectors)
                     {
                         case 4004 when imagePlugin.Info.SectorSize == 128:
-                            AaruConsole.DebugWriteLine("FAT plugin", Localization.Using_hardcoded_BPB);
+                            AaruConsole.DebugWriteLine(MODULE_NAME, Localization.Using_hardcoded_BPB);
                             fakeBpb.bps      = 128;
                             fakeBpb.spc      = 4;
                             fakeBpb.rsectors = 4;
@@ -470,7 +470,7 @@ public sealed partial class FAT
 
                             break;
                         case 2002 when imagePlugin.Info.SectorSize == 128:
-                            AaruConsole.DebugWriteLine("FAT plugin", Localization.Using_hardcoded_BPB);
+                            AaruConsole.DebugWriteLine(MODULE_NAME, Localization.Using_hardcoded_BPB);
                             fakeBpb.bps      = 128;
                             fakeBpb.spc      = 4;
                             fakeBpb.rsectors = 4;
@@ -491,7 +491,7 @@ public sealed partial class FAT
                     switch(imagePlugin.Info.Sectors)
                     {
                         case 320 when imagePlugin.Info.SectorSize == 512:
-                            AaruConsole.DebugWriteLine("FAT plugin", Localization.Using_hardcoded_BPB_for_5_25_SSDD);
+                            AaruConsole.DebugWriteLine(MODULE_NAME, Localization.Using_hardcoded_BPB_for_5_25_SSDD);
                             fakeBpb.bps      = 512;
                             fakeBpb.spc      = 1;
                             fakeBpb.rsectors = 1;
@@ -506,7 +506,7 @@ public sealed partial class FAT
 
                             break;
                         case 2002 when imagePlugin.Info.SectorSize == 128:
-                            AaruConsole.DebugWriteLine("FAT plugin", Localization.Using_hardcoded_BPB);
+                            AaruConsole.DebugWriteLine(MODULE_NAME, Localization.Using_hardcoded_BPB);
                             fakeBpb.bps      = 128;
                             fakeBpb.spc      = 4;
                             fakeBpb.rsectors = 1;
@@ -521,7 +521,7 @@ public sealed partial class FAT
 
                             break;
                         case 1232 when imagePlugin.Info.SectorSize == 1024:
-                            AaruConsole.DebugWriteLine("FAT plugin", Localization.Using_hardcoded_BPB);
+                            AaruConsole.DebugWriteLine(MODULE_NAME, Localization.Using_hardcoded_BPB);
                             fakeBpb.bps      = 1024;
                             fakeBpb.spc      = 1;
                             fakeBpb.rsectors = 1;
@@ -536,7 +536,7 @@ public sealed partial class FAT
 
                             break;
                         case 616 when imagePlugin.Info.SectorSize == 1024:
-                            AaruConsole.DebugWriteLine("FAT plugin", Localization.Using_hardcoded_BPB);
+                            AaruConsole.DebugWriteLine(MODULE_NAME, Localization.Using_hardcoded_BPB);
                             fakeBpb.bps      = 1024;
                             fakeBpb.spc      = 1;
                             fakeBpb.rsectors = 1;
@@ -550,7 +550,7 @@ public sealed partial class FAT
 
                             break;
                         case 720 when imagePlugin.Info.SectorSize == 128:
-                            AaruConsole.DebugWriteLine("FAT plugin", Localization.Using_hardcoded_BPB);
+                            AaruConsole.DebugWriteLine(MODULE_NAME, Localization.Using_hardcoded_BPB);
                             fakeBpb.bps      = 128;
                             fakeBpb.spc      = 2;
                             fakeBpb.rsectors = 54;
@@ -565,7 +565,7 @@ public sealed partial class FAT
 
                             break;
                         case 640 when imagePlugin.Info.SectorSize == 512:
-                            AaruConsole.DebugWriteLine("FAT plugin", Localization.Using_hardcoded_BPB_for_5_25_DSDD);
+                            AaruConsole.DebugWriteLine(MODULE_NAME, Localization.Using_hardcoded_BPB_for_5_25_DSDD);
                             fakeBpb.bps      = 512;
                             fakeBpb.spc      = 2;
                             fakeBpb.rsectors = 1;
@@ -585,7 +585,7 @@ public sealed partial class FAT
                 case 0xFF:
                     if(imagePlugin.Info is { Sectors: 640, SectorSize: 512 })
                     {
-                        AaruConsole.DebugWriteLine("FAT plugin", Localization.Using_hardcoded_BPB_for_5_25_DSDD);
+                        AaruConsole.DebugWriteLine(MODULE_NAME, Localization.Using_hardcoded_BPB_for_5_25_DSDD);
                         fakeBpb.bps      = 512;
                         fakeBpb.spc      = 2;
                         fakeBpb.rsectors = 1;

Aaru.Filesystems/FAT/Dir.cs

@@ -257,7 +257,7 @@ public sealed partial class FAT
                 if(name      == "" &&
                    extension == "")
                 {
-                    AaruConsole.DebugWriteLine("FAT filesystem", Localization.Found_empty_filename_in_0, path);
+                    AaruConsole.DebugWriteLine(MODULE_NAME, Localization.Found_empty_filename_in_0, path);
 
                     if(!_debug ||
                        dirent is { size: > 0, start_cluster: 0 })

Aaru.Filesystems/FAT/FAT.cs

@@ -63,6 +63,8 @@ public sealed partial class FAT : IReadOnlyFilesystem
     FileSystemInfo                                                 _statfs;
     bool                                                           _useFirstFat;
     Encoding                                                       _encoding;
+    uint                                                           _fatEntriesPerSector;
+    IMediaImage                                                    _image;
 
     /// <inheritdoc />
     public FileSystem Metadata { get; private set; }
@@ -103,4 +105,6 @@ public sealed partial class FAT : IReadOnlyFilesystem
             "debug", false.ToString()
         }
     };
+
+    const string MODULE_NAME = "FAT plugin";
 }

Aaru.Filesystems/FAT/Info.cs

@@ -87,10 +87,10 @@ public sealed partial class FAT
 
         ulong expectedClusters = humanBpb.bpc > 0 ? partition.Size / humanBpb.bpc : 0;
 
-        AaruConsole.DebugWriteLine("FAT plugin", "Human bpc = {0}", humanBpb.bpc);
-        AaruConsole.DebugWriteLine("FAT plugin", "Human clusters = {0}", humanBpb.clusters);
-        AaruConsole.DebugWriteLine("FAT plugin", "Human big_clusters = {0}", humanBpb.big_clusters);
-        AaruConsole.DebugWriteLine("FAT plugin", "Human expected clusters = {0}", expectedClusters);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "Human bpc = {0}", humanBpb.bpc);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "Human clusters = {0}", humanBpb.clusters);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "Human big_clusters = {0}", humanBpb.big_clusters);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "Human expected clusters = {0}", expectedClusters);
 
         // Check clusters for Human68k are correct
         bool humanClustersCorrect = humanBpb.clusters       == 0 ? humanBpb.big_clusters == expectedClusters
@@ -107,9 +107,9 @@ public sealed partial class FAT
         // Check correct branch for Human68k
         bool humanBranchCorrect = bpbSector[0] == 0x60 && bpbSector[1] >= 0x20 && bpbSector[1] < 0xFE;
 
-        AaruConsole.DebugWriteLine("FAT plugin", "humanClustersCorrect = {0}", humanClustersCorrect);
-        AaruConsole.DebugWriteLine("FAT plugin", "humanOemCorrect = {0}", humanOemCorrect);
-        AaruConsole.DebugWriteLine("FAT plugin", "humanBranchCorrect = {0}", humanBranchCorrect);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "humanClustersCorrect = {0}", humanClustersCorrect);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "humanOemCorrect = {0}", humanOemCorrect);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "humanBranchCorrect = {0}", humanBranchCorrect);
 
         // If all Human68k checks are correct, it is a Human68k FAT16
         if(humanClustersCorrect &&
@@ -152,25 +152,25 @@ public sealed partial class FAT
 
         string oemString = Encoding.ASCII.GetString(dosOem);
 
-        AaruConsole.DebugWriteLine("FAT plugin", "atari_oem_correct = {0}", atariOemCorrect);
-        AaruConsole.DebugWriteLine("FAT plugin", "dos_oem_correct = {0}", dosOemCorrect);
-        AaruConsole.DebugWriteLine("FAT plugin", "bps = {0}", bps);
-        AaruConsole.DebugWriteLine("FAT plugin", "bits in bps = {0}", bitsInBps);
-        AaruConsole.DebugWriteLine("FAT plugin", "spc = {0}", spc);
-        AaruConsole.DebugWriteLine("FAT plugin", "correct_spc = {0}", correctSpc);
-        AaruConsole.DebugWriteLine("FAT plugin", "reserved_secs = {0}", reservedSecs);
-        AaruConsole.DebugWriteLine("FAT plugin", "fats_no = {0}", numberOfFats);
-        AaruConsole.DebugWriteLine("FAT plugin", "root_entries = {0}", rootEntries);
-        AaruConsole.DebugWriteLine("FAT plugin", "sectors = {0}", sectors);
-        AaruConsole.DebugWriteLine("FAT plugin", "media_descriptor = 0x{0:X2}", mediaDescriptor);
-        AaruConsole.DebugWriteLine("FAT plugin", "fat_sectors = {0}", fatSectors);
-        AaruConsole.DebugWriteLine("FAT plugin", "msx_id = \"{0}\"", msxString);
-        AaruConsole.DebugWriteLine("FAT plugin", "big_sectors = {0}", bigSectors);
-        AaruConsole.DebugWriteLine("FAT plugin", "bpb_signature = 0x{0:X2}", bpbSignature);
-        AaruConsole.DebugWriteLine("FAT plugin", "fat32_signature = 0x{0:X2}", fat32Signature);
-        AaruConsole.DebugWriteLine("FAT plugin", "fat32_id = \"{0}\"", fat32String);
-        AaruConsole.DebugWriteLine("FAT plugin", "huge_sectors = {0}", hugeSectors);
-        AaruConsole.DebugWriteLine("FAT plugin", "fat_id = 0x{0:X2}", fatId);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "atari_oem_correct = {0}", atariOemCorrect);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "dos_oem_correct = {0}", dosOemCorrect);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "bps = {0}", bps);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "bits in bps = {0}", bitsInBps);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "spc = {0}", spc);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "correct_spc = {0}", correctSpc);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "reserved_secs = {0}", reservedSecs);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "fats_no = {0}", numberOfFats);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "root_entries = {0}", rootEntries);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "sectors = {0}", sectors);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "media_descriptor = 0x{0:X2}", mediaDescriptor);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "fat_sectors = {0}", fatSectors);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "msx_id = \"{0}\"", msxString);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "big_sectors = {0}", bigSectors);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "bpb_signature = 0x{0:X2}", bpbSignature);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "fat32_signature = 0x{0:X2}", fat32Signature);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "fat32_id = \"{0}\"", fat32String);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "huge_sectors = {0}", hugeSectors);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "fat_id = 0x{0:X2}", fatId);
 
         ushort apricotBps             = BitConverter.ToUInt16(bpbSector, 0x50);
         byte   apricotSpc             = bpbSector[0x52];
@@ -186,15 +186,15 @@ public sealed partial class FAT
         int  bitsInApricotBps  = CountBits.Count(apricotBps);
         byte apricotPartitions = bpbSector[0x0C];
 
-        AaruConsole.DebugWriteLine("FAT plugin", "apricot_bps = {0}", apricotBps);
-        AaruConsole.DebugWriteLine("FAT plugin", "apricot_spc = {0}", apricotSpc);
-        AaruConsole.DebugWriteLine("FAT plugin", "apricot_correct_spc = {0}", apricotCorrectSpc);
-        AaruConsole.DebugWriteLine("FAT plugin", "apricot_reserved_secs = {0}", apricotReservedSecs);
-        AaruConsole.DebugWriteLine("FAT plugin", "apricot_fats_no = {0}", apricotFatsNo);
-        AaruConsole.DebugWriteLine("FAT plugin", "apricot_root_entries = {0}", apricotRootEntries);
-        AaruConsole.DebugWriteLine("FAT plugin", "apricot_sectors = {0}", apricotSectors);
-        AaruConsole.DebugWriteLine("FAT plugin", "apricot_media_descriptor = 0x{0:X2}", apricotMediaDescriptor);
-        AaruConsole.DebugWriteLine("FAT plugin", "apricot_fat_sectors = {0}", apricotFatSectors);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "apricot_bps = {0}", apricotBps);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "apricot_spc = {0}", apricotSpc);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "apricot_correct_spc = {0}", apricotCorrectSpc);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "apricot_reserved_secs = {0}", apricotReservedSecs);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "apricot_fats_no = {0}", apricotFatsNo);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "apricot_root_entries = {0}", apricotRootEntries);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "apricot_sectors = {0}", apricotSectors);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "apricot_media_descriptor = 0x{0:X2}", apricotMediaDescriptor);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "apricot_fat_sectors = {0}", apricotFatSectors);
 
         // This is to support FAT partitions on hybrid ISO/USB images
         if(imagePlugin.Info.MetadataMediaType == MetadataMediaType.OpticalDisc)
@@ -347,7 +347,7 @@ public sealed partial class FAT
         byte   fat3        = fatSector[2];
         ushort fatCluster2 = (ushort)(((fat2 << 8) + fat3) & 0xFFF);
 
-        AaruConsole.DebugWriteLine("FAT plugin", "1st fat cluster 1 = {0:X3}", fatCluster2);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "1st fat cluster 1 = {0:X3}", fatCluster2);
 
         if(fatCluster2 < 0xFF0)
             return false;
@@ -403,7 +403,7 @@ public sealed partial class FAT
            fat2SectorNo == 0)
             return false;
 
-        AaruConsole.DebugWriteLine("FAT plugin", Localization.Second_fat_starts_at_0, fat2SectorNo);
+        AaruConsole.DebugWriteLine(MODULE_NAME, Localization.Second_fat_starts_at_0, fat2SectorNo);
 
         errno = imagePlugin.ReadSector(fat2SectorNo, out byte[] fat2Sector);
 

Aaru.Filesystems/FAT/Super.cs

@@ -47,9 +47,6 @@ namespace Aaru.Filesystems;
 
 public sealed partial class FAT
 {
-    uint        _fatEntriesPerSector;
-    IMediaImage _image;
-
     /// <inheritdoc />
     public ErrorNumber Mount(IMediaImage imagePlugin, Partition partition, Encoding encoding,
                              Dictionary<string, string> options, string @namespace)
@@ -93,7 +90,7 @@ public sealed partial class FAT
             default: return ErrorNumber.InvalidArgument;
         }
 
-        AaruConsole.DebugWriteLine("FAT plugin", Localization.Reading_BPB);
+        AaruConsole.DebugWriteLine(MODULE_NAME, Localization.Reading_BPB);
 
         uint sectorsPerBpb = imagePlugin.Info.SectorSize < 512 ? 512 / imagePlugin.Info.SectorSize : 1;
 
@@ -694,7 +691,7 @@ public sealed partial class FAT
             if(name      == "" &&
                extension == "")
             {
-                AaruConsole.DebugWriteLine("FAT filesystem", Localization.Found_empty_filename_in_root_directory);
+                AaruConsole.DebugWriteLine(MODULE_NAME, Localization.Found_empty_filename_in_root_directory);
 
                 if(!_debug ||
                    entry is { size: > 0, start_cluster: 0 })
@@ -786,7 +783,7 @@ public sealed partial class FAT
 
         if(_fat12)
         {
-            AaruConsole.DebugWriteLine("FAT plugin", Localization.Reading_FAT12);
+            AaruConsole.DebugWriteLine(MODULE_NAME, Localization.Reading_FAT12);
 
             errno = imagePlugin.ReadSectors(_fatFirstSector, _sectorsPerFat, out byte[] fatBytes);
 
@@ -839,14 +836,14 @@ public sealed partial class FAT
         }
         else if(_fat16)
         {
-            AaruConsole.DebugWriteLine("FAT plugin", Localization.Reading_FAT16);
+            AaruConsole.DebugWriteLine(MODULE_NAME, Localization.Reading_FAT16);
 
             errno = imagePlugin.ReadSectors(_fatFirstSector, _sectorsPerFat, out byte[] fatBytes);
 
             if(errno != ErrorNumber.NoError)
                 return errno;
 
-            AaruConsole.DebugWriteLine("FAT plugin", Localization.Casting_FAT);
+            AaruConsole.DebugWriteLine(MODULE_NAME, Localization.Casting_FAT);
             firstFatEntries = MemoryMarshal.Cast<byte, ushort>(fatBytes).ToArray();
 
             errno = imagePlugin.ReadSectors(_fatFirstSector + _sectorsPerFat, _sectorsPerFat, out fatBytes);
@@ -854,7 +851,7 @@ public sealed partial class FAT
             if(errno != ErrorNumber.NoError)
                 return errno;
 
-            AaruConsole.DebugWriteLine("FAT plugin", Localization.Casting_FAT);
+            AaruConsole.DebugWriteLine(MODULE_NAME, Localization.Casting_FAT);
             secondFatEntries = MemoryMarshal.Cast<byte, ushort>(fatBytes).ToArray();
 
             if(firstFatEntries.Any(entry => entry < FAT16_RESERVED && entry > _statfs.Blocks + 2))

Aaru.Filesystems/FATX/FATX.cs

@@ -99,4 +99,6 @@ public sealed partial class XboxFatPlugin : IReadOnlyFilesystem
             "debug", false.ToString()
         }
     };
+
+    const string MODULE_NAME = "Xbox FAT plugin";
 }

Aaru.Filesystems/FATX/Super.cs

@@ -59,7 +59,7 @@ public sealed partial class XboxFatPlugin
         if(imagePlugin.Info.SectorSize < 512)
             return ErrorNumber.InvalidArgument;
 
-        AaruConsole.DebugWriteLine("Xbox FAT plugin", Localization.Reading_superblock);
+        AaruConsole.DebugWriteLine(MODULE_NAME, Localization.Reading_superblock);
 
         ErrorNumber errno = imagePlugin.ReadSector(partition.Start, out byte[] sector);
 
@@ -77,13 +77,13 @@ public sealed partial class XboxFatPlugin
         if(_superblock.magic != FATX_MAGIC)
             return ErrorNumber.InvalidArgument;
 
-        AaruConsole.DebugWriteLine("Xbox FAT plugin",
+        AaruConsole.DebugWriteLine(MODULE_NAME,
                                    _littleEndian ? Localization.Filesystem_is_little_endian
                                        : Localization.Filesystem_is_big_endian);
 
         int logicalSectorsPerPhysicalSectors = partition.Offset == 0 && _littleEndian ? 8 : 1;
 
-        AaruConsole.DebugWriteLine("Xbox FAT plugin", "logicalSectorsPerPhysicalSectors = {0}",
+        AaruConsole.DebugWriteLine(MODULE_NAME, "logicalSectorsPerPhysicalSectors = {0}",
                                    logicalSectorsPerPhysicalSectors);
 
         string volumeLabel = StringHandlers.CToString(_superblock.volumeLabel,
@@ -117,23 +117,23 @@ public sealed partial class XboxFatPlugin
             FreeBlocks = 0 // Requires traversing the FAT
         };
 
-        AaruConsole.DebugWriteLine("Xbox FAT plugin", "XmlFsType.ClusterSize: {0}", Metadata.ClusterSize);
-        AaruConsole.DebugWriteLine("Xbox FAT plugin", "XmlFsType.VolumeName: {0}", Metadata.VolumeName);
-        AaruConsole.DebugWriteLine("Xbox FAT plugin", "XmlFsType.VolumeSerial: {0}", Metadata.VolumeSerial);
-        AaruConsole.DebugWriteLine("Xbox FAT plugin", "stat.Blocks: {0}", _statfs.Blocks);
-        AaruConsole.DebugWriteLine("Xbox FAT plugin", "stat.FilenameLength: {0}", _statfs.FilenameLength);
-        AaruConsole.DebugWriteLine("Xbox FAT plugin", "stat.Id: {0}", _statfs.Id.Serial32);
-        AaruConsole.DebugWriteLine("Xbox FAT plugin", "stat.Type: {0}", _statfs.Type);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "XmlFsType.ClusterSize: {0}", Metadata.ClusterSize);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "XmlFsType.VolumeName: {0}", Metadata.VolumeName);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "XmlFsType.VolumeSerial: {0}", Metadata.VolumeSerial);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "stat.Blocks: {0}", _statfs.Blocks);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "stat.FilenameLength: {0}", _statfs.FilenameLength);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "stat.Id: {0}", _statfs.Id.Serial32);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "stat.Type: {0}", _statfs.Type);
 
         byte[] buffer;
         _fatStartSector = (FAT_START / imagePlugin.Info.SectorSize) + partition.Start;
         uint fatSize;
 
-        AaruConsole.DebugWriteLine("Xbox FAT plugin", "fatStartSector: {0}", _fatStartSector);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "fatStartSector: {0}", _fatStartSector);
 
         if(_statfs.Blocks > MAX_XFAT16_CLUSTERS)
         {
-            AaruConsole.DebugWriteLine("Xbox FAT plugin", Localization.Reading_FAT32);
+            AaruConsole.DebugWriteLine(MODULE_NAME, Localization.Reading_FAT32);
 
             fatSize = (uint)((_statfs.Blocks + 1) * sizeof(uint) / imagePlugin.Info.SectorSize);
 
@@ -147,28 +147,28 @@ public sealed partial class XboxFatPlugin
 
             fatSize = (uint)(fatClusters * 4096 / imagePlugin.Info.SectorSize);
 
-            AaruConsole.DebugWriteLine("Xbox FAT plugin", Localization.FAT_is_0_sectors, fatSize);
+            AaruConsole.DebugWriteLine(MODULE_NAME, Localization.FAT_is_0_sectors, fatSize);
 
             errno = imagePlugin.ReadSectors(_fatStartSector, fatSize, out buffer);
 
             if(errno != ErrorNumber.NoError)
                 return errno;
 
-            AaruConsole.DebugWriteLine("Xbox FAT plugin", Localization.Casting_FAT);
+            AaruConsole.DebugWriteLine(MODULE_NAME, Localization.Casting_FAT);
             _fat32 = MemoryMarshal.Cast<byte, uint>(buffer).ToArray();
 
             if(!_littleEndian)
                 for(int i = 0; i < _fat32.Length; i++)
                     _fat32[i] = Swapping.Swap(_fat32[i]);
 
-            AaruConsole.DebugWriteLine("Xbox FAT plugin", "fat32[0] == FATX32_ID = {0}", _fat32[0] == FATX32_ID);
+            AaruConsole.DebugWriteLine(MODULE_NAME, "fat32[0] == FATX32_ID = {0}", _fat32[0] == FATX32_ID);
 
             if(_fat32[0] != FATX32_ID)
                 return ErrorNumber.InvalidArgument;
         }
         else
         {
-            AaruConsole.DebugWriteLine("Xbox FAT plugin", Localization.Reading_FAT16);
+            AaruConsole.DebugWriteLine(MODULE_NAME, Localization.Reading_FAT16);
 
             fatSize = (uint)((_statfs.Blocks + 1) * sizeof(ushort) / imagePlugin.Info.SectorSize);
 
@@ -182,21 +182,21 @@ public sealed partial class XboxFatPlugin
 
             fatSize = (uint)(fatClusters * 4096 / imagePlugin.Info.SectorSize);
 
-            AaruConsole.DebugWriteLine("Xbox FAT plugin", Localization.FAT_is_0_sectors, fatSize);
+            AaruConsole.DebugWriteLine(MODULE_NAME, Localization.FAT_is_0_sectors, fatSize);
 
             errno = imagePlugin.ReadSectors(_fatStartSector, fatSize, out buffer);
 
             if(errno != ErrorNumber.NoError)
                 return errno;
 
-            AaruConsole.DebugWriteLine("Xbox FAT plugin", Localization.Casting_FAT);
+            AaruConsole.DebugWriteLine(MODULE_NAME, Localization.Casting_FAT);
             _fat16 = MemoryMarshal.Cast<byte, ushort>(buffer).ToArray();
 
             if(!_littleEndian)
                 for(int i = 0; i < _fat16.Length; i++)
                     _fat16[i] = Swapping.Swap(_fat16[i]);
 
-            AaruConsole.DebugWriteLine("Xbox FAT plugin", "fat16[0] == FATX16_ID = {0}", _fat16[0] == FATX16_ID);
+            AaruConsole.DebugWriteLine(MODULE_NAME, "fat16[0] == FATX16_ID = {0}", _fat16[0] == FATX16_ID);
 
             if(_fat16[0] != FATX16_ID)
                 return ErrorNumber.InvalidArgument;
@@ -207,9 +207,9 @@ public sealed partial class XboxFatPlugin
         _firstClusterSector = _fatStartSector + fatSize;
         _bytesPerCluster    = _sectorsPerCluster * imagePlugin.Info.SectorSize;
 
-        AaruConsole.DebugWriteLine("Xbox FAT plugin", "sectorsPerCluster = {0}", _sectorsPerCluster);
-        AaruConsole.DebugWriteLine("Xbox FAT plugin", "bytesPerCluster = {0}", _bytesPerCluster);
-        AaruConsole.DebugWriteLine("Xbox FAT plugin", "firstClusterSector = {0}", _firstClusterSector);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "sectorsPerCluster = {0}", _sectorsPerCluster);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "bytesPerCluster = {0}", _bytesPerCluster);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "firstClusterSector = {0}", _firstClusterSector);
 
         uint[] rootDirectoryClusters = GetClusters(_superblock.rootDirectoryCluster);
 
@@ -218,7 +218,7 @@ public sealed partial class XboxFatPlugin
 
         byte[] rootDirectoryBuffer = new byte[_bytesPerCluster * rootDirectoryClusters.Length];
 
-        AaruConsole.DebugWriteLine("Xbox FAT plugin", Localization.Reading_root_directory);
+        AaruConsole.DebugWriteLine(MODULE_NAME, Localization.Reading_root_directory);
 
         for(int i = 0; i < rootDirectoryClusters.Length; i++)
         {

Aaru.Filesystems/FFS/FFS.cs

@@ -46,4 +46,5 @@ public sealed partial class FFSPlugin : IFilesystem
     public Guid Id => new("CC90D342-05DB-48A8-988C-C1FE000034A3");
     /// <inheritdoc />
     public string Author => Authors.NataliaPortillo;
+    const string MODULE_NAME = "FFS plugin";
 }

Aaru.Filesystems/FFS/Info.cs

@@ -231,45 +231,45 @@ public sealed partial class FFSPlugin
             sb.fs_cstotal.cs_spare[2]    = Swapping.Swap(sb.fs_cstotal.cs_spare[2]);
         }
 
-        AaruConsole.DebugWriteLine("FFS plugin", "sb offset: 0x{0:X8}", sb_offset);
-        AaruConsole.DebugWriteLine("FFS plugin", "fs_rlink: 0x{0:X8}", sb.fs_rlink);
-        AaruConsole.DebugWriteLine("FFS plugin", "fs_sblkno: 0x{0:X8}", sb.fs_sblkno);
-        AaruConsole.DebugWriteLine("FFS plugin", "fs_cblkno: 0x{0:X8}", sb.fs_cblkno);
-        AaruConsole.DebugWriteLine("FFS plugin", "fs_iblkno: 0x{0:X8}", sb.fs_iblkno);
-        AaruConsole.DebugWriteLine("FFS plugin", "fs_dblkno: 0x{0:X8}", sb.fs_dblkno);
-        AaruConsole.DebugWriteLine("FFS plugin", "fs_size: 0x{0:X8}", sb.fs_size);
-        AaruConsole.DebugWriteLine("FFS plugin", "fs_dsize: 0x{0:X8}", sb.fs_dsize);
-        AaruConsole.DebugWriteLine("FFS plugin", "fs_ncg: 0x{0:X8}", sb.fs_ncg);
-        AaruConsole.DebugWriteLine("FFS plugin", "fs_bsize: 0x{0:X8}", sb.fs_bsize);
-        AaruConsole.DebugWriteLine("FFS plugin", "fs_fsize: 0x{0:X8}", sb.fs_fsize);
-        AaruConsole.DebugWriteLine("FFS plugin", "fs_frag: 0x{0:X8}", sb.fs_frag);
-        AaruConsole.DebugWriteLine("FFS plugin", "fs_minfree: 0x{0:X8}", sb.fs_minfree);
-        AaruConsole.DebugWriteLine("FFS plugin", "fs_bmask: 0x{0:X8}", sb.fs_bmask);
-        AaruConsole.DebugWriteLine("FFS plugin", "fs_fmask: 0x{0:X8}", sb.fs_fmask);
-        AaruConsole.DebugWriteLine("FFS plugin", "fs_bshift: 0x{0:X8}", sb.fs_bshift);
-        AaruConsole.DebugWriteLine("FFS plugin", "fs_fshift: 0x{0:X8}", sb.fs_fshift);
-        AaruConsole.DebugWriteLine("FFS plugin", "fs_maxcontig: 0x{0:X8}", sb.fs_maxcontig);
-        AaruConsole.DebugWriteLine("FFS plugin", "fs_maxbpg: 0x{0:X8}", sb.fs_maxbpg);
-        AaruConsole.DebugWriteLine("FFS plugin", "fs_fragshift: 0x{0:X8}", sb.fs_fragshift);
-        AaruConsole.DebugWriteLine("FFS plugin", "fs_fsbtodb: 0x{0:X8}", sb.fs_fsbtodb);
-        AaruConsole.DebugWriteLine("FFS plugin", "fs_sbsize: 0x{0:X8}", sb.fs_sbsize);
-        AaruConsole.DebugWriteLine("FFS plugin", "fs_csmask: 0x{0:X8}", sb.fs_csmask);
-        AaruConsole.DebugWriteLine("FFS plugin", "fs_csshift: 0x{0:X8}", sb.fs_csshift);
-        AaruConsole.DebugWriteLine("FFS plugin", "fs_nindir: 0x{0:X8}", sb.fs_nindir);
-        AaruConsole.DebugWriteLine("FFS plugin", "fs_inopb: 0x{0:X8}", sb.fs_inopb);
-        AaruConsole.DebugWriteLine("FFS plugin", "fs_optim: 0x{0:X8}", sb.fs_optim);
-        AaruConsole.DebugWriteLine("FFS plugin", "fs_id_1: 0x{0:X8}", sb.fs_id_1);
-        AaruConsole.DebugWriteLine("FFS plugin", "fs_id_2: 0x{0:X8}", sb.fs_id_2);
-        AaruConsole.DebugWriteLine("FFS plugin", "fs_csaddr: 0x{0:X8}", sb.fs_csaddr);
-        AaruConsole.DebugWriteLine("FFS plugin", "fs_cssize: 0x{0:X8}", sb.fs_cssize);
-        AaruConsole.DebugWriteLine("FFS plugin", "fs_cgsize: 0x{0:X8}", sb.fs_cgsize);
-        AaruConsole.DebugWriteLine("FFS plugin", "fs_ipg: 0x{0:X8}", sb.fs_ipg);
-        AaruConsole.DebugWriteLine("FFS plugin", "fs_fpg: 0x{0:X8}", sb.fs_fpg);
-        AaruConsole.DebugWriteLine("FFS plugin", "fs_fmod: 0x{0:X2}", sb.fs_fmod);
-        AaruConsole.DebugWriteLine("FFS plugin", "fs_clean: 0x{0:X2}", sb.fs_clean);
-        AaruConsole.DebugWriteLine("FFS plugin", "fs_ronly: 0x{0:X2}", sb.fs_ronly);
-        AaruConsole.DebugWriteLine("FFS plugin", "fs_flags: 0x{0:X2}", sb.fs_flags);
-        AaruConsole.DebugWriteLine("FFS plugin", "fs_magic: 0x{0:X8}", sb.fs_magic);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "sb offset: 0x{0:X8}", sb_offset);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "fs_rlink: 0x{0:X8}", sb.fs_rlink);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "fs_sblkno: 0x{0:X8}", sb.fs_sblkno);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "fs_cblkno: 0x{0:X8}", sb.fs_cblkno);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "fs_iblkno: 0x{0:X8}", sb.fs_iblkno);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "fs_dblkno: 0x{0:X8}", sb.fs_dblkno);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "fs_size: 0x{0:X8}", sb.fs_size);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "fs_dsize: 0x{0:X8}", sb.fs_dsize);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "fs_ncg: 0x{0:X8}", sb.fs_ncg);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "fs_bsize: 0x{0:X8}", sb.fs_bsize);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "fs_fsize: 0x{0:X8}", sb.fs_fsize);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "fs_frag: 0x{0:X8}", sb.fs_frag);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "fs_minfree: 0x{0:X8}", sb.fs_minfree);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "fs_bmask: 0x{0:X8}", sb.fs_bmask);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "fs_fmask: 0x{0:X8}", sb.fs_fmask);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "fs_bshift: 0x{0:X8}", sb.fs_bshift);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "fs_fshift: 0x{0:X8}", sb.fs_fshift);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "fs_maxcontig: 0x{0:X8}", sb.fs_maxcontig);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "fs_maxbpg: 0x{0:X8}", sb.fs_maxbpg);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "fs_fragshift: 0x{0:X8}", sb.fs_fragshift);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "fs_fsbtodb: 0x{0:X8}", sb.fs_fsbtodb);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "fs_sbsize: 0x{0:X8}", sb.fs_sbsize);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "fs_csmask: 0x{0:X8}", sb.fs_csmask);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "fs_csshift: 0x{0:X8}", sb.fs_csshift);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "fs_nindir: 0x{0:X8}", sb.fs_nindir);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "fs_inopb: 0x{0:X8}", sb.fs_inopb);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "fs_optim: 0x{0:X8}", sb.fs_optim);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "fs_id_1: 0x{0:X8}", sb.fs_id_1);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "fs_id_2: 0x{0:X8}", sb.fs_id_2);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "fs_csaddr: 0x{0:X8}", sb.fs_csaddr);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "fs_cssize: 0x{0:X8}", sb.fs_cssize);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "fs_cgsize: 0x{0:X8}", sb.fs_cgsize);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "fs_ipg: 0x{0:X8}", sb.fs_ipg);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "fs_fpg: 0x{0:X8}", sb.fs_fpg);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "fs_fmod: 0x{0:X2}", sb.fs_fmod);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "fs_clean: 0x{0:X2}", sb.fs_clean);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "fs_ronly: 0x{0:X2}", sb.fs_ronly);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "fs_flags: 0x{0:X2}", sb.fs_flags);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "fs_magic: 0x{0:X8}", sb.fs_magic);
 
         if(sb.fs_magic == UFS2_MAGIC)
             fs_type_ufs2 = true;

Aaru.Filesystems/Fossil/Fossil.cs

@@ -41,4 +41,5 @@ public sealed partial class Fossil : IFilesystem
     public Guid Id => new("932BF104-43F6-494F-973C-45EF58A51DA9");
     /// <inheritdoc />
     public string Author => Authors.NataliaPortillo;
+    const string MODULE_NAME = "Fossil plugin";
 }

Aaru.Filesystems/Fossil/Info.cs

@@ -55,7 +55,7 @@ public sealed partial class Fossil
 
         Header hdr = Marshal.ByteArrayToStructureBigEndian<Header>(sector);
 
-        AaruConsole.DebugWriteLine("Fossil plugin", Localization.magic_at_0_expected_1, hdr.magic, FOSSIL_HDR_MAGIC);
+        AaruConsole.DebugWriteLine(MODULE_NAME, Localization.magic_at_0_expected_1, hdr.magic, FOSSIL_HDR_MAGIC);
 
         return hdr.magic == FOSSIL_HDR_MAGIC;
     }
@@ -81,7 +81,7 @@ public sealed partial class Fossil
 
         Header hdr = Marshal.ByteArrayToStructureBigEndian<Header>(sector);
 
-        AaruConsole.DebugWriteLine("Fossil plugin", Localization.magic_at_0_expected_1, hdr.magic, FOSSIL_HDR_MAGIC);
+        AaruConsole.DebugWriteLine(MODULE_NAME, Localization.magic_at_0_expected_1, hdr.magic, FOSSIL_HDR_MAGIC);
 
         var sb = new StringBuilder();
 
@@ -107,7 +107,7 @@ public sealed partial class Fossil
             imagePlugin.ReadSector(sbLocation, out sector);
             SuperBlock fsb = Marshal.ByteArrayToStructureBigEndian<SuperBlock>(sector);
 
-            AaruConsole.DebugWriteLine("Fossil plugin", Localization.magic_0_expected_1, fsb.magic, FOSSIL_SB_MAGIC);
+            AaruConsole.DebugWriteLine(MODULE_NAME, Localization.magic_0_expected_1, fsb.magic, FOSSIL_SB_MAGIC);
 
             if(fsb.magic == FOSSIL_SB_MAGIC)
             {

Aaru.Filesystems/HPOFS/HPOFS.cs

@@ -43,4 +43,5 @@ public sealed partial class HPOFS : IFilesystem
     public Guid Id => new("1b72dcd5-d031-4757-8a9f-8d2fb18c59e2");
     /// <inheritdoc />
     public string Author => Authors.NataliaPortillo;
+    const string MODULE_NAME = "HPOFS Plugin";
 }

Aaru.Filesystems/HPOFS/Info.cs

@@ -98,87 +98,87 @@ public sealed partial class HPOFS
         MediaInformationBlock  mib = Marshal.ByteArrayToStructureBigEndian<MediaInformationBlock>(medInfoSector);
         VolumeInformationBlock vib = Marshal.ByteArrayToStructureBigEndian<VolumeInformationBlock>(volInfoSector);
 
-        AaruConsole.DebugWriteLine("HPOFS Plugin", "bpb.oem_name = \"{0}\"", StringHandlers.CToString(bpb.oem_name));
+        AaruConsole.DebugWriteLine(MODULE_NAME, "bpb.oem_name = \"{0}\"", StringHandlers.CToString(bpb.oem_name));
 
-        AaruConsole.DebugWriteLine("HPOFS Plugin", "bpb.bps = {0}", bpb.bps);
-        AaruConsole.DebugWriteLine("HPOFS Plugin", "bpb.spc = {0}", bpb.spc);
-        AaruConsole.DebugWriteLine("HPOFS Plugin", "bpb.rsectors = {0}", bpb.rsectors);
-        AaruConsole.DebugWriteLine("HPOFS Plugin", "bpb.fats_no = {0}", bpb.fats_no);
-        AaruConsole.DebugWriteLine("HPOFS Plugin", "bpb.root_ent = {0}", bpb.root_ent);
-        AaruConsole.DebugWriteLine("HPOFS Plugin", "bpb.sectors = {0}", bpb.sectors);
-        AaruConsole.DebugWriteLine("HPOFS Plugin", "bpb.media = 0x{0:X2}", bpb.media);
-        AaruConsole.DebugWriteLine("HPOFS Plugin", "bpb.spfat = {0}", bpb.spfat);
-        AaruConsole.DebugWriteLine("HPOFS Plugin", "bpb.sptrk = {0}", bpb.sptrk);
-        AaruConsole.DebugWriteLine("HPOFS Plugin", "bpb.heads = {0}", bpb.heads);
-        AaruConsole.DebugWriteLine("HPOFS Plugin", "bpb.hsectors = {0}", bpb.hsectors);
-        AaruConsole.DebugWriteLine("HPOFS Plugin", "bpb.big_sectors = {0}", bpb.big_sectors);
-        AaruConsole.DebugWriteLine("HPOFS Plugin", "bpb.drive_no = 0x{0:X2}", bpb.drive_no);
-        AaruConsole.DebugWriteLine("HPOFS Plugin", "bpb.nt_flags = {0}", bpb.nt_flags);
-        AaruConsole.DebugWriteLine("HPOFS Plugin", "bpb.signature = 0x{0:X2}", bpb.signature);
-        AaruConsole.DebugWriteLine("HPOFS Plugin", "bpb.serial_no = 0x{0:X8}", bpb.serial_no);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "bpb.bps = {0}", bpb.bps);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "bpb.spc = {0}", bpb.spc);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "bpb.rsectors = {0}", bpb.rsectors);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "bpb.fats_no = {0}", bpb.fats_no);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "bpb.root_ent = {0}", bpb.root_ent);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "bpb.sectors = {0}", bpb.sectors);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "bpb.media = 0x{0:X2}", bpb.media);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "bpb.spfat = {0}", bpb.spfat);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "bpb.sptrk = {0}", bpb.sptrk);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "bpb.heads = {0}", bpb.heads);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "bpb.hsectors = {0}", bpb.hsectors);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "bpb.big_sectors = {0}", bpb.big_sectors);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "bpb.drive_no = 0x{0:X2}", bpb.drive_no);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "bpb.nt_flags = {0}", bpb.nt_flags);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "bpb.signature = 0x{0:X2}", bpb.signature);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "bpb.serial_no = 0x{0:X8}", bpb.serial_no);
 
-        AaruConsole.DebugWriteLine("HPOFS Plugin", "bpb.volume_label = \"{0}\"",
+        AaruConsole.DebugWriteLine(MODULE_NAME, "bpb.volume_label = \"{0}\"",
                                    StringHandlers.SpacePaddedToString(bpb.volume_label));
 
-        AaruConsole.DebugWriteLine("HPOFS Plugin", "bpb.fs_type = \"{0}\"", StringHandlers.CToString(bpb.fs_type));
+        AaruConsole.DebugWriteLine(MODULE_NAME, "bpb.fs_type = \"{0}\"", StringHandlers.CToString(bpb.fs_type));
 
-        AaruConsole.DebugWriteLine("HPOFS Plugin", "bpb.boot_code is empty? = {0}",
+        AaruConsole.DebugWriteLine(MODULE_NAME, "bpb.boot_code is empty? = {0}",
                                    ArrayHelpers.ArrayIsNullOrEmpty(bpb.boot_code));
 
-        AaruConsole.DebugWriteLine("HPOFS Plugin", "bpb.unknown = {0}", bpb.unknown);
-        AaruConsole.DebugWriteLine("HPOFS Plugin", "bpb.unknown2 = {0}", bpb.unknown2);
-        AaruConsole.DebugWriteLine("HPOFS Plugin", "bpb.signature2 = {0}", bpb.signature2);
-        AaruConsole.DebugWriteLine("HPOFS Plugin", "mib.blockId = \"{0}\"", StringHandlers.CToString(mib.blockId));
+        AaruConsole.DebugWriteLine(MODULE_NAME, "bpb.unknown = {0}", bpb.unknown);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "bpb.unknown2 = {0}", bpb.unknown2);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "bpb.signature2 = {0}", bpb.signature2);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "mib.blockId = \"{0}\"", StringHandlers.CToString(mib.blockId));
 
-        AaruConsole.DebugWriteLine("HPOFS Plugin", "mib.volumeLabel = \"{0}\"",
+        AaruConsole.DebugWriteLine(MODULE_NAME, "mib.volumeLabel = \"{0}\"",
                                    StringHandlers.SpacePaddedToString(mib.volumeLabel));
 
-        AaruConsole.DebugWriteLine("HPOFS Plugin", "mib.comment = \"{0}\"",
+        AaruConsole.DebugWriteLine(MODULE_NAME, "mib.comment = \"{0}\"",
                                    StringHandlers.SpacePaddedToString(mib.comment));
 
-        AaruConsole.DebugWriteLine("HPOFS Plugin", "mib.serial = 0x{0:X8}", mib.serial);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "mib.serial = 0x{0:X8}", mib.serial);
 
-        AaruConsole.DebugWriteLine("HPOFS Plugin", "mib.creationTimestamp = {0}",
+        AaruConsole.DebugWriteLine(MODULE_NAME, "mib.creationTimestamp = {0}",
                                    DateHandlers.DosToDateTime(mib.creationDate, mib.creationTime));
 
-        AaruConsole.DebugWriteLine("HPOFS Plugin", "mib.codepageType = {0}", mib.codepageType);
-        AaruConsole.DebugWriteLine("HPOFS Plugin", "mib.codepage = {0}", mib.codepage);
-        AaruConsole.DebugWriteLine("HPOFS Plugin", "mib.rps = {0}", mib.rps);
-        AaruConsole.DebugWriteLine("HPOFS Plugin", "mib.bps = {0}", mib.bps);
-        AaruConsole.DebugWriteLine("HPOFS Plugin", "mib.bpc = {0}", mib.bpc);
-        AaruConsole.DebugWriteLine("HPOFS Plugin", "mib.unknown2 = {0}", mib.unknown2);
-        AaruConsole.DebugWriteLine("HPOFS Plugin", "mib.sectors = {0}", mib.sectors);
-        AaruConsole.DebugWriteLine("HPOFS Plugin", "mib.unknown3 = {0}", mib.unknown3);
-        AaruConsole.DebugWriteLine("HPOFS Plugin", "mib.unknown4 = {0}", mib.unknown4);
-        AaruConsole.DebugWriteLine("HPOFS Plugin", "mib.major = {0}", mib.major);
-        AaruConsole.DebugWriteLine("HPOFS Plugin", "mib.minor = {0}", mib.minor);
-        AaruConsole.DebugWriteLine("HPOFS Plugin", "mib.unknown5 = {0}", mib.unknown5);
-        AaruConsole.DebugWriteLine("HPOFS Plugin", "mib.unknown6 = {0}", mib.unknown6);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "mib.codepageType = {0}", mib.codepageType);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "mib.codepage = {0}", mib.codepage);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "mib.rps = {0}", mib.rps);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "mib.bps = {0}", mib.bps);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "mib.bpc = {0}", mib.bpc);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "mib.unknown2 = {0}", mib.unknown2);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "mib.sectors = {0}", mib.sectors);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "mib.unknown3 = {0}", mib.unknown3);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "mib.unknown4 = {0}", mib.unknown4);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "mib.major = {0}", mib.major);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "mib.minor = {0}", mib.minor);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "mib.unknown5 = {0}", mib.unknown5);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "mib.unknown6 = {0}", mib.unknown6);
 
-        AaruConsole.DebugWriteLine("HPOFS Plugin", "mib.filler is empty? = {0}",
+        AaruConsole.DebugWriteLine(MODULE_NAME, "mib.filler is empty? = {0}",
                                    ArrayHelpers.ArrayIsNullOrEmpty(mib.filler));
 
-        AaruConsole.DebugWriteLine("HPOFS Plugin", "vib.blockId = \"{0}\"", StringHandlers.CToString(vib.blockId));
-        AaruConsole.DebugWriteLine("HPOFS Plugin", "vib.unknown = {0}", vib.unknown);
-        AaruConsole.DebugWriteLine("HPOFS Plugin", "vib.unknown2 = {0}", vib.unknown2);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "vib.blockId = \"{0}\"", StringHandlers.CToString(vib.blockId));
+        AaruConsole.DebugWriteLine(MODULE_NAME, "vib.unknown = {0}", vib.unknown);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "vib.unknown2 = {0}", vib.unknown2);
 
-        AaruConsole.DebugWriteLine("HPOFS Plugin", "vib.unknown3 is empty? = {0}",
+        AaruConsole.DebugWriteLine(MODULE_NAME, "vib.unknown3 is empty? = {0}",
                                    ArrayHelpers.ArrayIsNullOrEmpty(vib.unknown3));
 
-        AaruConsole.DebugWriteLine("HPOFS Plugin", "vib.unknown4 = \"{0}\"",
+        AaruConsole.DebugWriteLine(MODULE_NAME, "vib.unknown4 = \"{0}\"",
                                    StringHandlers.SpacePaddedToString(vib.unknown4));
 
-        AaruConsole.DebugWriteLine("HPOFS Plugin", "vib.owner = \"{0}\"",
+        AaruConsole.DebugWriteLine(MODULE_NAME, "vib.owner = \"{0}\"",
                                    StringHandlers.SpacePaddedToString(vib.owner));
 
-        AaruConsole.DebugWriteLine("HPOFS Plugin", "vib.unknown5 = \"{0}\"",
+        AaruConsole.DebugWriteLine(MODULE_NAME, "vib.unknown5 = \"{0}\"",
                                    StringHandlers.SpacePaddedToString(vib.unknown5));
 
-        AaruConsole.DebugWriteLine("HPOFS Plugin", "vib.unknown6 = {0}", vib.unknown6);
-        AaruConsole.DebugWriteLine("HPOFS Plugin", "vib.percentFull = {0}", vib.percentFull);
-        AaruConsole.DebugWriteLine("HPOFS Plugin", "vib.unknown7 = {0}", vib.unknown7);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "vib.unknown6 = {0}", vib.unknown6);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "vib.percentFull = {0}", vib.percentFull);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "vib.unknown7 = {0}", vib.unknown7);
 
-        AaruConsole.DebugWriteLine("HPOFS Plugin", "vib.filler is empty? = {0}",
+        AaruConsole.DebugWriteLine(MODULE_NAME, "vib.filler is empty? = {0}",
                                    ArrayHelpers.ArrayIsNullOrEmpty(vib.filler));
 
         sb.AppendLine(Localization.HPOFS_Name);

Aaru.Filesystems/ISO9660/File.cs

@@ -179,8 +179,8 @@ public sealed partial class ISO9660
         }
         catch(Exception e)
         {
-            AaruConsole.DebugWriteLine("ISO9660 plugin", Localization.Exception_reading_CD_i_audio_file);
-            AaruConsole.DebugWriteLine("ISO9660 plugin", "{0}", e);
+            AaruConsole.DebugWriteLine(MODULE_NAME, Localization.Exception_reading_CD_i_audio_file);
+            AaruConsole.DebugWriteLine(MODULE_NAME, "{0}", e);
 
             read = 0;
 

Aaru.Filesystems/ISO9660/ISO9660.cs

@@ -104,4 +104,6 @@ public sealed partial class ISO9660 : IReadOnlyFilesystem
             "debug", false.ToString()
         }
     };
+
+    const string MODULE_NAME = "ISO9660 plugin";
 }

Aaru.Filesystems/ISO9660/Info.cs

@@ -76,8 +76,8 @@ public sealed partial class ISO9660
         Array.Copy(vdSector, 0x001 + xaOff, vdMagic, 0, 5);
         Array.Copy(vdSector, 0x009 + xaOff, hsMagic, 0, 5);
 
-        AaruConsole.DebugWriteLine("ISO9660 plugin", "VDMagic = {0}", Encoding.ASCII.GetString(vdMagic));
-        AaruConsole.DebugWriteLine("ISO9660 plugin", "HSMagic = {0}", Encoding.ASCII.GetString(hsMagic));
+        AaruConsole.DebugWriteLine(MODULE_NAME, "VDMagic = {0}", Encoding.ASCII.GetString(vdMagic));
+        AaruConsole.DebugWriteLine(MODULE_NAME, "HSMagic = {0}", Encoding.ASCII.GetString(hsMagic));
 
         return Encoding.ASCII.GetString(vdMagic) == ISO_MAGIC         ||
                Encoding.ASCII.GetString(hsMagic) == HIGH_SIERRA_MAGIC || Encoding.ASCII.GetString(vdMagic) == CDI_MAGIC;
@@ -132,10 +132,10 @@ public sealed partial class ISO9660
 
         while(true)
         {
-            AaruConsole.DebugWriteLine("ISO9660 plugin", Localization.Processing_VD_loop_no_0, counter);
+            AaruConsole.DebugWriteLine(MODULE_NAME, Localization.Processing_VD_loop_no_0, counter);
 
             // Seek to Volume Descriptor
-            AaruConsole.DebugWriteLine("ISO9660 plugin", Localization.Reading_sector_0, 16 + counter + partition.Start);
+            AaruConsole.DebugWriteLine(MODULE_NAME, Localization.Reading_sector_0, 16 + counter + partition.Start);
             errno = imagePlugin.ReadSector(16 + counter + partition.Start, out byte[] vdSectorTmp);
 
             if(errno != ErrorNumber.NoError)
@@ -145,7 +145,7 @@ public sealed partial class ISO9660
             Array.Copy(vdSectorTmp, xaOff, vdSector, 0, vdSector.Length);
 
             byte vdType = vdSector[0 + hsOff]; // Volume Descriptor Type, should be 1 or 2.
-            AaruConsole.DebugWriteLine("ISO9660 plugin", "VDType = {0}", vdType);
+            AaruConsole.DebugWriteLine(MODULE_NAME, "VDType = {0}", vdType);
 
             if(vdType == 255) // Supposedly we are in the PVD.
             {
@@ -216,7 +216,7 @@ public sealed partial class ISO9660
                                svd.escape_sequences[2] == 'E')
                                 jolietvd = svd;
                             else
-                                AaruConsole.WriteLine("ISO9660 plugin",
+                                AaruConsole.WriteLine(MODULE_NAME,
                                                       Localization.Found_unknown_supplementary_volume_descriptor);
                     }
                     else
@@ -713,9 +713,9 @@ public sealed partial class ISO9660
 
             initialEntry.boot_type = (ElToritoEmulation)((byte)initialEntry.boot_type & 0xF);
 
-            AaruConsole.DebugWriteLine("DEBUG (ISO9660 plugin)", "initialEntry.load_rba = {0}", initialEntry.load_rba);
+            AaruConsole.DebugWriteLine(MODULE_NAME, "initialEntry.load_rba = {0}", initialEntry.load_rba);
 
-            AaruConsole.DebugWriteLine("DEBUG (ISO9660 plugin)", "initialEntry.sector_count = {0}",
+            AaruConsole.DebugWriteLine(MODULE_NAME, "initialEntry.sector_count = {0}",
                                        initialEntry.sector_count);
 
             byte[] bootImage = null;

Aaru.Filesystems/ISO9660/Mode2.cs

@@ -71,18 +71,18 @@ public sealed partial class ISO9660
                 switch(data.Length)
                 {
                     case 2048:
-                        AaruConsole.DebugWriteLine("ISO9660 Plugin",
+                        AaruConsole.DebugWriteLine(MODULE_NAME,
                                                    Localization.tor_Sector_0_Cooked_Mode_zero_one_Mode_two_Form_one,
                                                    realSector);
 
                         break;
                     case 2324:
-                        AaruConsole.DebugWriteLine("ISO9660 Plugin", Localization.tor_Sector_0_Cooked_Mode_two_Form_two,
+                        AaruConsole.DebugWriteLine(MODULE_NAME, Localization.tor_Sector_0_Cooked_Mode_two_Form_two,
                                                    realSector);
 
                         break;
                     case 2336:
-                        AaruConsole.DebugWriteLine("ISO9660 Plugin",
+                        AaruConsole.DebugWriteLine(MODULE_NAME,
                                                    Localization.
                                                        tor_Sector_0_Cooked_Mode_two_Form_1_File_Number_2_Channel_Number_3_Submode_4_Coding_Information_5,
                                                    realSector,
@@ -93,16 +93,16 @@ public sealed partial class ISO9660
                     case 2352 when data[0] != 0x00 || data[1] != 0xFF || data[2]  != 0xFF || data[3]  != 0xFF ||
                                    data[4] != 0xFF || data[5] != 0xFF || data[6]  != 0xFF || data[7]  != 0xFF ||
                                    data[8] != 0xFF || data[9] != 0xFF || data[10] != 0xFF || data[11] != 0x00:
-                        AaruConsole.DebugWriteLine("ISO9660 Plugin", Localization.tor_Sector_0_Raw_Audio, realSector);
+                        AaruConsole.DebugWriteLine(MODULE_NAME, Localization.tor_Sector_0_Raw_Audio, realSector);
 
                         break;
                     case 2352 when data[15] != 2:
-                        AaruConsole.DebugWriteLine("ISO9660 Plugin", Localization.tor_Sector_0_1_2_3_Raw_Mode_4,
+                        AaruConsole.DebugWriteLine(MODULE_NAME, Localization.tor_Sector_0_1_2_3_Raw_Mode_4,
                                                    realSector, data[12], data[13], data[14], data[15]);
 
                         break;
                     case 2352:
-                        AaruConsole.DebugWriteLine("ISO9660 Plugin",
+                        AaruConsole.DebugWriteLine(MODULE_NAME,
                                                    Localization.
                                                        tor_Sector_0_1_2_3_Raw_Mode_two_Form_4_File_Number_5_Channel_Number_6_Submode_7_Coding_Information_8,
                                                    realSector, data[12], data[13], data[14],
@@ -146,18 +146,18 @@ public sealed partial class ISO9660
                     switch(data.Length)
                     {
                         case 2048:
-                            AaruConsole.DebugWriteLine("ISO9660 Plugin",
+                            AaruConsole.DebugWriteLine(MODULE_NAME,
                                                        Localization.tor_Sector_0_Cooked_Mode_zero_one_Mode_two_Form_one,
                                                        dstSector);
 
                             break;
                         case 2324:
-                            AaruConsole.DebugWriteLine("ISO9660 Plugin",
+                            AaruConsole.DebugWriteLine(MODULE_NAME,
                                                        Localization.tor_Sector_0_Cooked_Mode_two_Form_two, dstSector);
 
                             break;
                         case 2336:
-                            AaruConsole.DebugWriteLine("ISO9660 Plugin",
+                            AaruConsole.DebugWriteLine(MODULE_NAME,
                                                        Localization.
                                                            tor_Sector_0_Cooked_Mode_two_Form_1_File_Number_2_Channel_Number_3_Submode_4_Coding_Information_5,
                                                        dstSector,
@@ -168,17 +168,17 @@ public sealed partial class ISO9660
                         case 2352 when data[0] != 0x00 || data[1] != 0xFF || data[2]  != 0xFF || data[3]  != 0xFF ||
                                        data[4] != 0xFF || data[5] != 0xFF || data[6]  != 0xFF || data[7]  != 0xFF ||
                                        data[8] != 0xFF || data[9] != 0xFF || data[10] != 0xFF || data[11] != 0x00:
-                            AaruConsole.DebugWriteLine("ISO9660 Plugin", Localization.tor_Sector_0_Raw_Audio,
+                            AaruConsole.DebugWriteLine(MODULE_NAME, Localization.tor_Sector_0_Raw_Audio,
                                                        dstSector);
 
                             break;
                         case 2352 when data[15] != 2:
-                            AaruConsole.DebugWriteLine("ISO9660 Plugin", Localization.tor_Sector_0_1_2_3_Raw_Mode_4,
+                            AaruConsole.DebugWriteLine(MODULE_NAME, Localization.tor_Sector_0_1_2_3_Raw_Mode_4,
                                                        dstSector, data[12], data[13], data[14], data[15]);
 
                             break;
                         case 2352:
-                            AaruConsole.DebugWriteLine("ISO9660 Plugin",
+                            AaruConsole.DebugWriteLine(MODULE_NAME,
                                                        Localization.
                                                            tor_Sector_0_1_2_3_Raw_Mode_two_Form_4_File_Number_5_Channel_Number_6_Submode_7_Coding_Information_8,
                                                        dstSector, data[12], data[13], data[14],

Aaru.Filesystems/ISO9660/Super.cs

@@ -135,10 +135,10 @@ public sealed partial class ISO9660
 
         while(true)
         {
-            AaruConsole.DebugWriteLine("ISO9660 plugin", Localization.Processing_VD_loop_no_0, counter);
+            AaruConsole.DebugWriteLine(MODULE_NAME, Localization.Processing_VD_loop_no_0, counter);
 
             // Seek to Volume Descriptor
-            AaruConsole.DebugWriteLine("ISO9660 plugin", Localization.Reading_sector_0, 16 + counter + partition.Start);
+            AaruConsole.DebugWriteLine(MODULE_NAME, Localization.Reading_sector_0, 16 + counter + partition.Start);
             errno = imagePlugin.ReadSector(16 + counter + partition.Start, out byte[] vdSectorTmp);
 
             if(errno != ErrorNumber.NoError)
@@ -148,7 +148,7 @@ public sealed partial class ISO9660
             Array.Copy(vdSectorTmp, xaOff, vdSector, 0, vdSector.Length);
 
             byte vdType = vdSector[0 + hsOff]; // Volume Descriptor Type, should be 1 or 2.
-            AaruConsole.DebugWriteLine("ISO9660 plugin", "VDType = {0}", vdType);
+            AaruConsole.DebugWriteLine(MODULE_NAME, "VDType = {0}", vdType);
 
             if(vdType == 255) // Supposedly we are in the PVD.
             {
@@ -214,7 +214,7 @@ public sealed partial class ISO9660
                                svd.escape_sequences[2] == 'E')
                                 jolietvd = svd;
                             else
-                                AaruConsole.DebugWriteLine("ISO9660 plugin",
+                                AaruConsole.DebugWriteLine(MODULE_NAME,
                                                            Localization.Found_unknown_supplementary_volume_descriptor);
 
                         if(_debug)
@@ -367,7 +367,7 @@ public sealed partial class ISO9660
             if(_pathTable?.Length > 1 &&
                rootLocation       != _pathTable[0].Extent)
             {
-                AaruConsole.DebugWriteLine("ISO9660 plugin",
+                AaruConsole.DebugWriteLine(MODULE_NAME,
                                            Localization.
                                                Path_table_and_PVD_do_not_point_to_the_same_location_for_the_root_directory);
 
@@ -397,7 +397,7 @@ public sealed partial class ISO9660
 
                 if(pvdWrongRoot)
                 {
-                    AaruConsole.DebugWriteLine("ISO9660 plugin",
+                    AaruConsole.DebugWriteLine(MODULE_NAME,
                                                Localization.
                                                    PVD_does_not_point_to_correct_root_directory_checking_path_table);
 

Aaru.Filesystems/LIF/Info.cs

@@ -53,7 +53,7 @@ public sealed partial class LIF
             return false;
 
         SystemBlock lifSb = Marshal.ByteArrayToStructureBigEndian<SystemBlock>(sector);
-        AaruConsole.DebugWriteLine("LIF plugin", Localization.magic_0_expected_1, lifSb.magic, LIF_MAGIC);
+        AaruConsole.DebugWriteLine(MODULE_NAME, Localization.magic_0_expected_1, lifSb.magic, LIF_MAGIC);
 
         return lifSb.magic == LIF_MAGIC;
     }

Aaru.Filesystems/LIF/LIF.cs

@@ -42,4 +42,5 @@ public sealed partial class LIF : IFilesystem
     public Guid Id => new("41535647-77A5-477B-9206-DA727ACDC704");
     /// <inheritdoc />
     public string Author => Authors.NataliaPortillo;
+    const string MODULE_NAME = "LIF plugin";
 }

Aaru.Filesystems/LisaFS/Extent.cs

@@ -205,57 +205,57 @@ public sealed partial class LisaFS
         if(_printedExtents.Contains(fileId))
             return ErrorNumber.NoError;
 
-        AaruConsole.DebugWriteLine("LisaFS plugin", "ExtentFile[{0}].filenameLen = {1}", fileId, file.filenameLen);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "ExtentFile[{0}].filenameLen = {1}", fileId, file.filenameLen);
 
-        AaruConsole.DebugWriteLine("LisaFS plugin", "ExtentFile[{0}].filename = {1}", fileId,
+        AaruConsole.DebugWriteLine(MODULE_NAME, "ExtentFile[{0}].filename = {1}", fileId,
                                    StringHandlers.CToString(file.filename, _encoding));
 
-        AaruConsole.DebugWriteLine("LisaFS plugin", "ExtentFile[{0}].unknown1 = 0x{1:X4}", fileId, file.unknown1);
-        AaruConsole.DebugWriteLine("LisaFS plugin", "ExtentFile[{0}].file_uid = 0x{1:X16}", fileId, file.file_uid);
-        AaruConsole.DebugWriteLine("LisaFS plugin", "ExtentFile[{0}].unknown2 = 0x{1:X2}", fileId, file.unknown2);
-        AaruConsole.DebugWriteLine("LisaFS plugin", "ExtentFile[{0}].etype = 0x{1:X2}", fileId, file.etype);
-        AaruConsole.DebugWriteLine("LisaFS plugin", "ExtentFile[{0}].ftype = {1}", fileId, file.ftype);
-        AaruConsole.DebugWriteLine("LisaFS plugin", "ExtentFile[{0}].unknown3 = 0x{1:X2}", fileId, file.unknown3);
-        AaruConsole.DebugWriteLine("LisaFS plugin", "ExtentFile[{0}].dtc = {1}", fileId, file.dtc);
-        AaruConsole.DebugWriteLine("LisaFS plugin", "ExtentFile[{0}].dta = {1}", fileId, file.dta);
-        AaruConsole.DebugWriteLine("LisaFS plugin", "ExtentFile[{0}].dtm = {1}", fileId, file.dtm);
-        AaruConsole.DebugWriteLine("LisaFS plugin", "ExtentFile[{0}].dtb = {1}", fileId, file.dtb);
-        AaruConsole.DebugWriteLine("LisaFS plugin", "ExtentFile[{0}].dts = {1}", fileId, file.dts);
-        AaruConsole.DebugWriteLine("LisaFS plugin", "ExtentFile[{0}].serial = {1}", fileId, file.serial);
-        AaruConsole.DebugWriteLine("LisaFS plugin", "ExtentFile[{0}].unknown4 = 0x{1:X2}", fileId, file.unknown4);
-        AaruConsole.DebugWriteLine("LisaFS plugin", "ExtentFile[{0}].locked = {1}", fileId, file.locked       > 0);
-        AaruConsole.DebugWriteLine("LisaFS plugin", "ExtentFile[{0}].protect = {1}", fileId, file.protect     > 0);
-        AaruConsole.DebugWriteLine("LisaFS plugin", "ExtentFile[{0}].master = {1}", fileId, file.master       > 0);
-        AaruConsole.DebugWriteLine("LisaFS plugin", "ExtentFile[{0}].scavenged = {1}", fileId, file.scavenged > 0);
-        AaruConsole.DebugWriteLine("LisaFS plugin", "ExtentFile[{0}].closed = {1}", fileId, file.closed       > 0);
-        AaruConsole.DebugWriteLine("LisaFS plugin", "ExtentFile[{0}].open = {1}", fileId, file.open           > 0);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "ExtentFile[{0}].unknown1 = 0x{1:X4}", fileId, file.unknown1);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "ExtentFile[{0}].file_uid = 0x{1:X16}", fileId, file.file_uid);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "ExtentFile[{0}].unknown2 = 0x{1:X2}", fileId, file.unknown2);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "ExtentFile[{0}].etype = 0x{1:X2}", fileId, file.etype);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "ExtentFile[{0}].ftype = {1}", fileId, file.ftype);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "ExtentFile[{0}].unknown3 = 0x{1:X2}", fileId, file.unknown3);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "ExtentFile[{0}].dtc = {1}", fileId, file.dtc);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "ExtentFile[{0}].dta = {1}", fileId, file.dta);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "ExtentFile[{0}].dtm = {1}", fileId, file.dtm);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "ExtentFile[{0}].dtb = {1}", fileId, file.dtb);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "ExtentFile[{0}].dts = {1}", fileId, file.dts);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "ExtentFile[{0}].serial = {1}", fileId, file.serial);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "ExtentFile[{0}].unknown4 = 0x{1:X2}", fileId, file.unknown4);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "ExtentFile[{0}].locked = {1}", fileId, file.locked       > 0);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "ExtentFile[{0}].protect = {1}", fileId, file.protect     > 0);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "ExtentFile[{0}].master = {1}", fileId, file.master       > 0);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "ExtentFile[{0}].scavenged = {1}", fileId, file.scavenged > 0);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "ExtentFile[{0}].closed = {1}", fileId, file.closed       > 0);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "ExtentFile[{0}].open = {1}", fileId, file.open           > 0);
 
-        AaruConsole.DebugWriteLine("LisaFS plugin",
+        AaruConsole.DebugWriteLine(MODULE_NAME,
                                    "ExtentFile[{0}].unknown5 = 0x{1:X2}{2:X2}{3:X2}{4:X2}{5:X2}{6:X2}{7:X2}{8:X2}{9:X2}" +
                                    "{10:X2}{11:X2}", fileId, file.unknown5[0], file.unknown5[1], file.unknown5[2],
                                    file.unknown5[3], file.unknown5[4], file.unknown5[5], file.unknown5[6],
                                    file.unknown5[7], file.unknown5[8], file.unknown5[9], file.unknown5[10]);
 
-        AaruConsole.DebugWriteLine("LisaFS plugin", "ExtentFile[{0}].release = {1}", fileId, file.release);
-        AaruConsole.DebugWriteLine("LisaFS plugin", "ExtentFile[{0}].build = {1}", fileId, file.build);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "ExtentFile[{0}].release = {1}", fileId, file.release);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "ExtentFile[{0}].build = {1}", fileId, file.build);
 
-        AaruConsole.DebugWriteLine("LisaFS plugin", "ExtentFile[{0}].compatibility = {1}", fileId, file.compatibility);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "ExtentFile[{0}].compatibility = {1}", fileId, file.compatibility);
 
-        AaruConsole.DebugWriteLine("LisaFS plugin", "ExtentFile[{0}].revision = {1}", fileId, file.revision);
-        AaruConsole.DebugWriteLine("LisaFS plugin", "ExtentFile[{0}].unknown6 = 0x{1:X4}", fileId, file.unknown6);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "ExtentFile[{0}].revision = {1}", fileId, file.revision);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "ExtentFile[{0}].unknown6 = 0x{1:X4}", fileId, file.unknown6);
 
-        AaruConsole.DebugWriteLine("LisaFS plugin", "ExtentFile[{0}].password_valid = {1}", fileId,
+        AaruConsole.DebugWriteLine(MODULE_NAME, "ExtentFile[{0}].password_valid = {1}", fileId,
                                    file.password_valid > 0);
 
-        AaruConsole.DebugWriteLine("LisaFS plugin", "ExtentFile[{0}].password = {1}", fileId,
+        AaruConsole.DebugWriteLine(MODULE_NAME, "ExtentFile[{0}].password = {1}", fileId,
                                    _encoding.GetString(file.password));
 
-        AaruConsole.DebugWriteLine("LisaFS plugin", "ExtentFile[{0}].unknown7 = 0x{1:X2}{2:X2}{3:X2}", fileId,
+        AaruConsole.DebugWriteLine(MODULE_NAME, "ExtentFile[{0}].unknown7 = 0x{1:X2}{2:X2}{3:X2}", fileId,
                                    file.unknown7[0], file.unknown7[1], file.unknown7[2]);
 
-        AaruConsole.DebugWriteLine("LisaFS plugin", "ExtentFile[{0}].overhead = {1}", fileId, file.overhead);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "ExtentFile[{0}].overhead = {1}", fileId, file.overhead);
 
-        AaruConsole.DebugWriteLine("LisaFS plugin",
+        AaruConsole.DebugWriteLine(MODULE_NAME,
                                    "ExtentFile[{0}].unknown8 = 0x{1:X2}{2:X2}{3:X2}{4:X2}{5:X2}{6:X2}{7:X2}{8:X2}{9:X2}" +
                                    "{10:X2}{11:X2}{12:X2}{13:X2}{14:X2}{15:X2}{16:X2}", fileId, file.unknown8[0],
                                    file.unknown8[1], file.unknown8[2], file.unknown8[3], file.unknown8[4],
@@ -263,19 +263,19 @@ public sealed partial class LisaFS
                                    file.unknown8[9], file.unknown8[10], file.unknown8[11], file.unknown8[12],
                                    file.unknown8[13], file.unknown8[14], file.unknown8[15]);
 
-        AaruConsole.DebugWriteLine("LisaFS plugin", "ExtentFile[{0}].length = {1}", fileId, file.length);
-        AaruConsole.DebugWriteLine("LisaFS plugin", "ExtentFile[{0}].unknown9 = 0x{1:X8}", fileId, file.unknown9);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "ExtentFile[{0}].length = {1}", fileId, file.length);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "ExtentFile[{0}].unknown9 = 0x{1:X8}", fileId, file.unknown9);
 
         for(int ext = 0; ext < file.extents.Length; ext++)
         {
-            AaruConsole.DebugWriteLine("LisaFS plugin", "ExtentFile[{0}].extents[{1}].start = {2}", fileId, ext,
+            AaruConsole.DebugWriteLine(MODULE_NAME, "ExtentFile[{0}].extents[{1}].start = {2}", fileId, ext,
                                        file.extents[ext].start);
 
-            AaruConsole.DebugWriteLine("LisaFS plugin", "ExtentFile[{0}].extents[{1}].length = {2}", fileId, ext,
+            AaruConsole.DebugWriteLine(MODULE_NAME, "ExtentFile[{0}].extents[{1}].length = {2}", fileId, ext,
                                        file.extents[ext].length);
         }
 
-        AaruConsole.DebugWriteLine("LisaFS plugin", "ExtentFile[{0}].unknown10 = 0x{1:X4}", fileId, file.unknown10);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "ExtentFile[{0}].unknown10 = 0x{1:X4}", fileId, file.unknown10);
 
         _printedExtents.Add(fileId);
 

Aaru.Filesystems/LisaFS/Info.cs

@@ -64,7 +64,7 @@ public sealed partial class LisaFS
 
             DecodeTag(tag, out LisaTag.PriamTag searchTag);
 
-            AaruConsole.DebugWriteLine("LisaFS plugin", Localization.Sector_0_file_ID_1, i, searchTag.FileId);
+            AaruConsole.DebugWriteLine(MODULE_NAME, Localization.Sector_0_file_ID_1, i, searchTag.FileId);
 
             if(beforeMddf       == -1 &&
                searchTag.FileId == FILEID_LOADER_SIGNED)
@@ -88,18 +88,18 @@ public sealed partial class LisaFS
                 datasize                     = BigEndianBitConverter.ToUInt16(sector, 0x7E)
             };
 
-            AaruConsole.DebugWriteLine("LisaFS plugin", Localization.Current_sector_0, i);
-            AaruConsole.DebugWriteLine("LisaFS plugin", "mddf.mddf_block = {0}", infoMddf.mddf_block);
-            AaruConsole.DebugWriteLine("LisaFS plugin", "Disk size = {0} sectors", imagePlugin.Info.Sectors);
-            AaruConsole.DebugWriteLine("LisaFS plugin", "mddf.vol_size = {0} sectors", infoMddf.vol_size);
-            AaruConsole.DebugWriteLine("LisaFS plugin", "mddf.vol_size - 1 = {0}", infoMddf.volsize_minus_one);
+            AaruConsole.DebugWriteLine(MODULE_NAME, Localization.Current_sector_0, i);
+            AaruConsole.DebugWriteLine(MODULE_NAME, "mddf.mddf_block = {0}", infoMddf.mddf_block);
+            AaruConsole.DebugWriteLine(MODULE_NAME, "Disk size = {0} sectors", imagePlugin.Info.Sectors);
+            AaruConsole.DebugWriteLine(MODULE_NAME, "mddf.vol_size = {0} sectors", infoMddf.vol_size);
+            AaruConsole.DebugWriteLine(MODULE_NAME, "mddf.vol_size - 1 = {0}", infoMddf.volsize_minus_one);
 
-            AaruConsole.DebugWriteLine("LisaFS plugin", "mddf.vol_size - mddf.mddf_block -1 = {0}",
+            AaruConsole.DebugWriteLine(MODULE_NAME, "mddf.vol_size - mddf.mddf_block -1 = {0}",
                                        infoMddf.volsize_minus_mddf_minus_one);
 
-            AaruConsole.DebugWriteLine("LisaFS plugin", "Disk sector = {0} bytes", imagePlugin.Info.SectorSize);
-            AaruConsole.DebugWriteLine("LisaFS plugin", "mddf.blocksize = {0} bytes", infoMddf.blocksize);
-            AaruConsole.DebugWriteLine("LisaFS plugin", "mddf.datasize = {0} bytes", infoMddf.datasize);
+            AaruConsole.DebugWriteLine(MODULE_NAME, "Disk sector = {0} bytes", imagePlugin.Info.SectorSize);
+            AaruConsole.DebugWriteLine(MODULE_NAME, "mddf.blocksize = {0} bytes", infoMddf.blocksize);
+            AaruConsole.DebugWriteLine(MODULE_NAME, "mddf.datasize = {0} bytes", infoMddf.datasize);
 
             if(infoMddf.mddf_block != i - beforeMddf)
                 return false;
@@ -153,7 +153,7 @@ public sealed partial class LisaFS
 
             DecodeTag(tag, out LisaTag.PriamTag searchTag);
 
-            AaruConsole.DebugWriteLine("LisaFS plugin", Localization.Sector_0_file_ID_1, i, searchTag.FileId);
+            AaruConsole.DebugWriteLine(MODULE_NAME, Localization.Sector_0_file_ID_1, i, searchTag.FileId);
 
             if(beforeMddf       == -1 &&
                searchTag.FileId == FILEID_LOADER_SIGNED)
@@ -250,45 +250,45 @@ public sealed partial class LisaFS
             infoMddf.vol_sequence                 = BigEndianBitConverter.ToUInt16(sector, 0x136);
             infoMddf.vol_left_mounted             = sector[0x138];
 
-            AaruConsole.DebugWriteLine("LisaFS plugin", "mddf.unknown1 = 0x{0:X2} ({0})", infoMddf.unknown1);
-            AaruConsole.DebugWriteLine("LisaFS plugin", "mddf.unknown2 = 0x{0:X2} ({0})", infoMddf.unknown2);
-            AaruConsole.DebugWriteLine("LisaFS plugin", "mddf.unknown3 = 0x{0:X8} ({0})", infoMddf.unknown3);
-            AaruConsole.DebugWriteLine("LisaFS plugin", "mddf.unknown4 = 0x{0:X4} ({0})", infoMddf.unknown4);
-            AaruConsole.DebugWriteLine("LisaFS plugin", "mddf.unknown5 = 0x{0:X8} ({0})", infoMddf.unknown5);
-            AaruConsole.DebugWriteLine("LisaFS plugin", "mddf.unknown6 = 0x{0:X8} ({0})", infoMddf.unknown6);
-            AaruConsole.DebugWriteLine("LisaFS plugin", "mddf.unknown7 = 0x{0:X8} ({0})", infoMddf.unknown7);
-            AaruConsole.DebugWriteLine("LisaFS plugin", "mddf.unknown9 = 0x{0:X4} ({0})", infoMddf.unknown9);
-            AaruConsole.DebugWriteLine("LisaFS plugin", "mddf.unknown10 = 0x{0:X8} ({0})", infoMddf.unknown10);
-            AaruConsole.DebugWriteLine("LisaFS plugin", "mddf.unknown11 = 0x{0:X8} ({0})", infoMddf.unknown11);
-            AaruConsole.DebugWriteLine("LisaFS plugin", "mddf.unknown12 = 0x{0:X8} ({0})", infoMddf.unknown12);
-            AaruConsole.DebugWriteLine("LisaFS plugin", "mddf.unknown13 = 0x{0:X8} ({0})", infoMddf.unknown13);
-            AaruConsole.DebugWriteLine("LisaFS plugin", "mddf.unknown14 = 0x{0:X8} ({0})", infoMddf.unknown14);
-            AaruConsole.DebugWriteLine("LisaFS plugin", "mddf.unknown15 = 0x{0:X8} ({0})", infoMddf.unknown15);
-            AaruConsole.DebugWriteLine("LisaFS plugin", "mddf.unknown16 = 0x{0:X8} ({0})", infoMddf.unknown16);
-            AaruConsole.DebugWriteLine("LisaFS plugin", "mddf.unknown17 = 0x{0:X4} ({0})", infoMddf.unknown17);
-            AaruConsole.DebugWriteLine("LisaFS plugin", "mddf.unknown18 = 0x{0:X8} ({0})", infoMddf.unknown18);
-            AaruConsole.DebugWriteLine("LisaFS plugin", "mddf.unknown19 = 0x{0:X8} ({0})", infoMddf.unknown19);
-            AaruConsole.DebugWriteLine("LisaFS plugin", "mddf.unknown20 = 0x{0:X8} ({0})", infoMddf.unknown20);
-            AaruConsole.DebugWriteLine("LisaFS plugin", "mddf.unknown21 = 0x{0:X8} ({0})", infoMddf.unknown21);
-            AaruConsole.DebugWriteLine("LisaFS plugin", "mddf.unknown22 = 0x{0:X8} ({0})", infoMddf.unknown22);
-            AaruConsole.DebugWriteLine("LisaFS plugin", "mddf.unknown23 = 0x{0:X8} ({0})", infoMddf.unknown23);
-            AaruConsole.DebugWriteLine("LisaFS plugin", "mddf.unknown24 = 0x{0:X8} ({0})", infoMddf.unknown24);
-            AaruConsole.DebugWriteLine("LisaFS plugin", "mddf.unknown25 = 0x{0:X8} ({0})", infoMddf.unknown25);
-            AaruConsole.DebugWriteLine("LisaFS plugin", "mddf.unknown26 = 0x{0:X8} ({0})", infoMddf.unknown26);
-            AaruConsole.DebugWriteLine("LisaFS plugin", "mddf.unknown27 = 0x{0:X8} ({0})", infoMddf.unknown27);
-            AaruConsole.DebugWriteLine("LisaFS plugin", "mddf.unknown28 = 0x{0:X8} ({0})", infoMddf.unknown28);
-            AaruConsole.DebugWriteLine("LisaFS plugin", "mddf.unknown29 = 0x{0:X8} ({0})", infoMddf.unknown29);
-            AaruConsole.DebugWriteLine("LisaFS plugin", "mddf.unknown30 = 0x{0:X8} ({0})", infoMddf.unknown30);
-            AaruConsole.DebugWriteLine("LisaFS plugin", "mddf.unknown31 = 0x{0:X8} ({0})", infoMddf.unknown31);
-            AaruConsole.DebugWriteLine("LisaFS plugin", "mddf.unknown32 = 0x{0:X8} ({0})", infoMddf.unknown32);
-            AaruConsole.DebugWriteLine("LisaFS plugin", "mddf.unknown33 = 0x{0:X8} ({0})", infoMddf.unknown33);
-            AaruConsole.DebugWriteLine("LisaFS plugin", "mddf.unknown34 = 0x{0:X8} ({0})", infoMddf.unknown34);
-            AaruConsole.DebugWriteLine("LisaFS plugin", "mddf.unknown35 = 0x{0:X8} ({0})", infoMddf.unknown35);
-            AaruConsole.DebugWriteLine("LisaFS plugin", "mddf.unknown36 = 0x{0:X8} ({0})", infoMddf.unknown36);
-            AaruConsole.DebugWriteLine("LisaFS plugin", "mddf.unknown37 = 0x{0:X8} ({0})", infoMddf.unknown37);
-            AaruConsole.DebugWriteLine("LisaFS plugin", "mddf.unknown38 = 0x{0:X8} ({0})", infoMddf.unknown38);
+            AaruConsole.DebugWriteLine(MODULE_NAME, "mddf.unknown1 = 0x{0:X2} ({0})", infoMddf.unknown1);
+            AaruConsole.DebugWriteLine(MODULE_NAME, "mddf.unknown2 = 0x{0:X2} ({0})", infoMddf.unknown2);
+            AaruConsole.DebugWriteLine(MODULE_NAME, "mddf.unknown3 = 0x{0:X8} ({0})", infoMddf.unknown3);
+            AaruConsole.DebugWriteLine(MODULE_NAME, "mddf.unknown4 = 0x{0:X4} ({0})", infoMddf.unknown4);
+            AaruConsole.DebugWriteLine(MODULE_NAME, "mddf.unknown5 = 0x{0:X8} ({0})", infoMddf.unknown5);
+            AaruConsole.DebugWriteLine(MODULE_NAME, "mddf.unknown6 = 0x{0:X8} ({0})", infoMddf.unknown6);
+            AaruConsole.DebugWriteLine(MODULE_NAME, "mddf.unknown7 = 0x{0:X8} ({0})", infoMddf.unknown7);
+            AaruConsole.DebugWriteLine(MODULE_NAME, "mddf.unknown9 = 0x{0:X4} ({0})", infoMddf.unknown9);
+            AaruConsole.DebugWriteLine(MODULE_NAME, "mddf.unknown10 = 0x{0:X8} ({0})", infoMddf.unknown10);
+            AaruConsole.DebugWriteLine(MODULE_NAME, "mddf.unknown11 = 0x{0:X8} ({0})", infoMddf.unknown11);
+            AaruConsole.DebugWriteLine(MODULE_NAME, "mddf.unknown12 = 0x{0:X8} ({0})", infoMddf.unknown12);
+            AaruConsole.DebugWriteLine(MODULE_NAME, "mddf.unknown13 = 0x{0:X8} ({0})", infoMddf.unknown13);
+            AaruConsole.DebugWriteLine(MODULE_NAME, "mddf.unknown14 = 0x{0:X8} ({0})", infoMddf.unknown14);
+            AaruConsole.DebugWriteLine(MODULE_NAME, "mddf.unknown15 = 0x{0:X8} ({0})", infoMddf.unknown15);
+            AaruConsole.DebugWriteLine(MODULE_NAME, "mddf.unknown16 = 0x{0:X8} ({0})", infoMddf.unknown16);
+            AaruConsole.DebugWriteLine(MODULE_NAME, "mddf.unknown17 = 0x{0:X4} ({0})", infoMddf.unknown17);
+            AaruConsole.DebugWriteLine(MODULE_NAME, "mddf.unknown18 = 0x{0:X8} ({0})", infoMddf.unknown18);
+            AaruConsole.DebugWriteLine(MODULE_NAME, "mddf.unknown19 = 0x{0:X8} ({0})", infoMddf.unknown19);
+            AaruConsole.DebugWriteLine(MODULE_NAME, "mddf.unknown20 = 0x{0:X8} ({0})", infoMddf.unknown20);
+            AaruConsole.DebugWriteLine(MODULE_NAME, "mddf.unknown21 = 0x{0:X8} ({0})", infoMddf.unknown21);
+            AaruConsole.DebugWriteLine(MODULE_NAME, "mddf.unknown22 = 0x{0:X8} ({0})", infoMddf.unknown22);
+            AaruConsole.DebugWriteLine(MODULE_NAME, "mddf.unknown23 = 0x{0:X8} ({0})", infoMddf.unknown23);
+            AaruConsole.DebugWriteLine(MODULE_NAME, "mddf.unknown24 = 0x{0:X8} ({0})", infoMddf.unknown24);
+            AaruConsole.DebugWriteLine(MODULE_NAME, "mddf.unknown25 = 0x{0:X8} ({0})", infoMddf.unknown25);
+            AaruConsole.DebugWriteLine(MODULE_NAME, "mddf.unknown26 = 0x{0:X8} ({0})", infoMddf.unknown26);
+            AaruConsole.DebugWriteLine(MODULE_NAME, "mddf.unknown27 = 0x{0:X8} ({0})", infoMddf.unknown27);
+            AaruConsole.DebugWriteLine(MODULE_NAME, "mddf.unknown28 = 0x{0:X8} ({0})", infoMddf.unknown28);
+            AaruConsole.DebugWriteLine(MODULE_NAME, "mddf.unknown29 = 0x{0:X8} ({0})", infoMddf.unknown29);
+            AaruConsole.DebugWriteLine(MODULE_NAME, "mddf.unknown30 = 0x{0:X8} ({0})", infoMddf.unknown30);
+            AaruConsole.DebugWriteLine(MODULE_NAME, "mddf.unknown31 = 0x{0:X8} ({0})", infoMddf.unknown31);
+            AaruConsole.DebugWriteLine(MODULE_NAME, "mddf.unknown32 = 0x{0:X8} ({0})", infoMddf.unknown32);
+            AaruConsole.DebugWriteLine(MODULE_NAME, "mddf.unknown33 = 0x{0:X8} ({0})", infoMddf.unknown33);
+            AaruConsole.DebugWriteLine(MODULE_NAME, "mddf.unknown34 = 0x{0:X8} ({0})", infoMddf.unknown34);
+            AaruConsole.DebugWriteLine(MODULE_NAME, "mddf.unknown35 = 0x{0:X8} ({0})", infoMddf.unknown35);
+            AaruConsole.DebugWriteLine(MODULE_NAME, "mddf.unknown36 = 0x{0:X8} ({0})", infoMddf.unknown36);
+            AaruConsole.DebugWriteLine(MODULE_NAME, "mddf.unknown37 = 0x{0:X8} ({0})", infoMddf.unknown37);
+            AaruConsole.DebugWriteLine(MODULE_NAME, "mddf.unknown38 = 0x{0:X8} ({0})", infoMddf.unknown38);
 
-            AaruConsole.DebugWriteLine("LisaFS plugin", "mddf.unknown_timestamp = 0x{0:X8} ({0}, {1})",
+            AaruConsole.DebugWriteLine(MODULE_NAME, "mddf.unknown_timestamp = 0x{0:X8} ({0}, {1})",
                                        infoMddf.unknown_timestamp,
                                        DateHandlers.LisaToDateTime(infoMddf.unknown_timestamp));
 

Aaru.Filesystems/LisaFS/LisaFS.cs

@@ -97,4 +97,6 @@ public sealed partial class LisaFS : IReadOnlyFilesystem
     /// <summary>Caches the creation times for subdirectories as to not have to traverse the Catalog File on each stat</summary>
     Dictionary<short, DateTime> _directoryDtcCache;
     #endregion Caches
+
+    const string MODULE_NAME = "LisaFS plugin";
 }

Aaru.Filesystems/LisaFS/Super.cs

@@ -57,7 +57,7 @@ public sealed partial class LisaFS
             // However with some effort the code may be modified to ignore them.
             if(_device.Info.ReadableSectorTags?.Contains(SectorTagType.AppleSectorTag) != true)
             {
-                AaruConsole.DebugWriteLine("LisaFS plugin", Localization.Underlying_device_does_not_support_Lisa_tags);
+                AaruConsole.DebugWriteLine(MODULE_NAME, Localization.Underlying_device_does_not_support_Lisa_tags);
 
                 return ErrorNumber.InOutError;
             }
@@ -65,7 +65,7 @@ public sealed partial class LisaFS
             // Minimal LisaOS disk is 3.5" single sided double density, 800 sectors
             if(_device.Info.Sectors < 800)
             {
-                AaruConsole.DebugWriteLine("LisaFS plugin", Localization.Device_is_too_small);
+                AaruConsole.DebugWriteLine(MODULE_NAME, Localization.Device_is_too_small);
 
                 return ErrorNumber.InOutError;
             }
@@ -83,7 +83,7 @@ public sealed partial class LisaFS
 
                 DecodeTag(tag, out LisaTag.PriamTag searchTag);
 
-                AaruConsole.DebugWriteLine("LisaFS plugin", Localization.Sector_0_file_ID_1, i, searchTag.FileId);
+                AaruConsole.DebugWriteLine(MODULE_NAME, Localization.Sector_0_file_ID_1, i, searchTag.FileId);
 
                 if(_volumePrefix    == _device.Info.Sectors &&
                    searchTag.FileId == FILEID_LOADER_SIGNED)
@@ -190,7 +190,7 @@ public sealed partial class LisaFS
                    _mddf.blocksize        < _device.Info.SectorSize                             ||
                    _mddf.datasize         != _device.Info.SectorSize)
                 {
-                    AaruConsole.DebugWriteLine("LisaFS plugin", Localization.Incorrect_MDDF_found);
+                    AaruConsole.DebugWriteLine(MODULE_NAME, Localization.Incorrect_MDDF_found);
 
                     return ErrorNumber.InvalidArgument;
                 }
@@ -199,15 +199,15 @@ public sealed partial class LisaFS
                 switch(_mddf.fsversion)
                 {
                     case LISA_V1:
-                        AaruConsole.DebugWriteLine("LisaFS plugin", Localization.Mounting_LisaFS_v1);
+                        AaruConsole.DebugWriteLine(MODULE_NAME, Localization.Mounting_LisaFS_v1);
 
                         break;
                     case LISA_V2:
-                        AaruConsole.DebugWriteLine("LisaFS plugin", Localization.Mounting_LisaFS_v2);
+                        AaruConsole.DebugWriteLine(MODULE_NAME, Localization.Mounting_LisaFS_v2);
 
                         break;
                     case LISA_V3:
-                        AaruConsole.DebugWriteLine("LisaFS plugin", Localization.Mounting_LisaFS_v3);
+                        AaruConsole.DebugWriteLine(MODULE_NAME, Localization.Mounting_LisaFS_v3);
 
                         break;
                     default:
@@ -257,7 +257,7 @@ public sealed partial class LisaFS
 
                 if(error != ErrorNumber.NoError)
                 {
-                    AaruConsole.DebugWriteLine("LisaFS plugin", Localization.Cannot_read_Catalog_File_error_0,
+                    AaruConsole.DebugWriteLine(MODULE_NAME, Localization.Cannot_read_Catalog_File_error_0,
                                                error.ToString());
 
                     _mounted = false;
@@ -272,7 +272,7 @@ public sealed partial class LisaFS
 
                     if(error != ErrorNumber.NoError)
                     {
-                        AaruConsole.DebugWriteLine("LisaFS plugin", Localization.Unable_to_read_boot_blocks);
+                        AaruConsole.DebugWriteLine(MODULE_NAME, Localization.Unable_to_read_boot_blocks);
                         _mounted = false;
 
                         return error;
@@ -282,7 +282,7 @@ public sealed partial class LisaFS
 
                     if(error != ErrorNumber.NoError)
                     {
-                        AaruConsole.DebugWriteLine("LisaFS plugin", Localization.Unable_to_read_boot_loader);
+                        AaruConsole.DebugWriteLine(MODULE_NAME, Localization.Unable_to_read_boot_loader);
                         _mounted = false;
 
                         return error;
@@ -292,7 +292,7 @@ public sealed partial class LisaFS
 
                     if(error != ErrorNumber.NoError)
                     {
-                        AaruConsole.DebugWriteLine("LisaFS plugin", Localization.Unable_to_read_MDDF);
+                        AaruConsole.DebugWriteLine(MODULE_NAME, Localization.Unable_to_read_MDDF);
                         _mounted = false;
 
                         return error;
@@ -302,7 +302,7 @@ public sealed partial class LisaFS
 
                     if(error != ErrorNumber.NoError)
                     {
-                        AaruConsole.DebugWriteLine("LisaFS plugin", Localization.Unable_to_read_volume_bitmap);
+                        AaruConsole.DebugWriteLine(MODULE_NAME, Localization.Unable_to_read_volume_bitmap);
                         _mounted = false;
 
                         return error;
@@ -312,7 +312,7 @@ public sealed partial class LisaFS
 
                     if(error != ErrorNumber.NoError)
                     {
-                        AaruConsole.DebugWriteLine("LisaFS plugin", Localization.Unable_to_read_S_Records_file);
+                        AaruConsole.DebugWriteLine(MODULE_NAME, Localization.Unable_to_read_S_Records_file);
                         _mounted = false;
 
                         return error;
@@ -345,7 +345,7 @@ public sealed partial class LisaFS
                 return ErrorNumber.NoError;
             }
 
-            AaruConsole.DebugWriteLine("LisaFS plugin", Localization.Not_a_Lisa_filesystem);
+            AaruConsole.DebugWriteLine(MODULE_NAME, Localization.Not_a_Lisa_filesystem);
 
             return ErrorNumber.NotSupported;
         }

Aaru.Filesystems/Locus/Info.cs

@@ -90,7 +90,7 @@ public sealed partial class Locus
 
             Superblock locusSb = Marshal.ByteArrayToStructureLittleEndian<Superblock>(sector);
 
-            AaruConsole.DebugWriteLine("Locus plugin", Localization.magic_at_1_equals_0, locusSb.s_magic, location);
+            AaruConsole.DebugWriteLine(MODULE_NAME, Localization.magic_at_1_equals_0, locusSb.s_magic, location);
 
             if(locusSb.s_magic is LOCUS_MAGIC or LOCUS_CIGAM or LOCUS_MAGIC_OLD or LOCUS_CIGAM_OLD)
                 return true;
@@ -161,27 +161,27 @@ public sealed partial class Locus
         // ReSharper disable once InconsistentNaming
         string s_fpack = StringHandlers.CToString(locusSb.s_fpack, encoding);
 
-        AaruConsole.DebugWriteLine("Locus plugin", "LocusSb.s_magic = 0x{0:X8}", locusSb.s_magic);
-        AaruConsole.DebugWriteLine("Locus plugin", "LocusSb.s_gfs = {0}", locusSb.s_gfs);
-        AaruConsole.DebugWriteLine("Locus plugin", "LocusSb.s_fsize = {0}", locusSb.s_fsize);
-        AaruConsole.DebugWriteLine("Locus plugin", "LocusSb.s_lwm = {0}", locusSb.s_lwm);
-        AaruConsole.DebugWriteLine("Locus plugin", "LocusSb.s_hwm = {0}", locusSb.s_hwm);
-        AaruConsole.DebugWriteLine("Locus plugin", "LocusSb.s_llst = {0}", locusSb.s_llst);
-        AaruConsole.DebugWriteLine("Locus plugin", "LocusSb.s_fstore = {0}", locusSb.s_fstore);
-        AaruConsole.DebugWriteLine("Locus plugin", "LocusSb.s_time = {0}", locusSb.s_time);
-        AaruConsole.DebugWriteLine("Locus plugin", "LocusSb.s_tfree = {0}", locusSb.s_tfree);
-        AaruConsole.DebugWriteLine("Locus plugin", "LocusSb.s_isize = {0}", locusSb.s_isize);
-        AaruConsole.DebugWriteLine("Locus plugin", "LocusSb.s_nfree = {0}", locusSb.s_nfree);
-        AaruConsole.DebugWriteLine("Locus plugin", "LocusSb.s_flags = {0}", locusSb.s_flags);
-        AaruConsole.DebugWriteLine("Locus plugin", "LocusSb.s_tinode = {0}", locusSb.s_tinode);
-        AaruConsole.DebugWriteLine("Locus plugin", "LocusSb.s_lasti = {0}", locusSb.s_lasti);
-        AaruConsole.DebugWriteLine("Locus plugin", "LocusSb.s_nbehind = {0}", locusSb.s_nbehind);
-        AaruConsole.DebugWriteLine("Locus plugin", "LocusSb.s_gfspack = {0}", locusSb.s_gfspack);
-        AaruConsole.DebugWriteLine("Locus plugin", "LocusSb.s_ninode = {0}", locusSb.s_ninode);
-        AaruConsole.DebugWriteLine("Locus plugin", "LocusSb.s_flock = {0}", locusSb.s_flock);
-        AaruConsole.DebugWriteLine("Locus plugin", "LocusSb.s_ilock = {0}", locusSb.s_ilock);
-        AaruConsole.DebugWriteLine("Locus plugin", "LocusSb.s_fmod = {0}", locusSb.s_fmod);
-        AaruConsole.DebugWriteLine("Locus plugin", "LocusSb.s_version = {0}", locusSb.s_version);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "LocusSb.s_magic = 0x{0:X8}", locusSb.s_magic);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "LocusSb.s_gfs = {0}", locusSb.s_gfs);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "LocusSb.s_fsize = {0}", locusSb.s_fsize);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "LocusSb.s_lwm = {0}", locusSb.s_lwm);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "LocusSb.s_hwm = {0}", locusSb.s_hwm);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "LocusSb.s_llst = {0}", locusSb.s_llst);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "LocusSb.s_fstore = {0}", locusSb.s_fstore);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "LocusSb.s_time = {0}", locusSb.s_time);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "LocusSb.s_tfree = {0}", locusSb.s_tfree);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "LocusSb.s_isize = {0}", locusSb.s_isize);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "LocusSb.s_nfree = {0}", locusSb.s_nfree);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "LocusSb.s_flags = {0}", locusSb.s_flags);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "LocusSb.s_tinode = {0}", locusSb.s_tinode);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "LocusSb.s_lasti = {0}", locusSb.s_lasti);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "LocusSb.s_nbehind = {0}", locusSb.s_nbehind);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "LocusSb.s_gfspack = {0}", locusSb.s_gfspack);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "LocusSb.s_ninode = {0}", locusSb.s_ninode);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "LocusSb.s_flock = {0}", locusSb.s_flock);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "LocusSb.s_ilock = {0}", locusSb.s_ilock);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "LocusSb.s_fmod = {0}", locusSb.s_fmod);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "LocusSb.s_version = {0}", locusSb.s_version);
 
         sb.AppendFormat(Localization.Superblock_last_modified_on_0, DateHandlers.UnixToDateTime(locusSb.s_time)).
            AppendLine();

Aaru.Filesystems/Locus/Locus.cs

@@ -65,4 +65,5 @@ public sealed partial class Locus : IFilesystem
     public Guid Id => new("1A70B30A-437D-479A-88E1-D0C9C1797FF4");
     /// <inheritdoc />
     public string Author => Authors.NataliaPortillo;
+    const string MODULE_NAME = "Locus plugin";
 }

Aaru.Filesystems/Nintendo/Info.cs

@@ -181,69 +181,69 @@ public sealed partial class NintendoPlugin
             fields.FourthPartitions = Array.Empty<NintendoPartition>();
         }
 
-        AaruConsole.DebugWriteLine("Nintendo plugin", "discType = {0}", fields.DiscType);
-        AaruConsole.DebugWriteLine("Nintendo plugin", "gameCode = {0}", fields.GameCode);
-        AaruConsole.DebugWriteLine("Nintendo plugin", "regionCode = {0}", fields.RegionCode);
-        AaruConsole.DebugWriteLine("Nintendo plugin", "publisherCode = {0}", fields.PublisherCode);
-        AaruConsole.DebugWriteLine("Nintendo plugin", "discID = {0}", fields.DiscId);
-        AaruConsole.DebugWriteLine("Nintendo plugin", "discNumber = {0}", fields.DiscNumber);
-        AaruConsole.DebugWriteLine("Nintendo plugin", "discVersion = {0}", fields.DiscVersion);
-        AaruConsole.DebugWriteLine("Nintendo plugin", "streaming = {0}", fields.Streaming);
-        AaruConsole.DebugWriteLine("Nintendo plugin", "streamBufferSize = {0}", fields.StreamBufferSize);
-        AaruConsole.DebugWriteLine("Nintendo plugin", "title = \"{0}\"", fields.Title);
-        AaruConsole.DebugWriteLine("Nintendo plugin", "debugOff = 0x{0:X8}", fields.DebugOff);
-        AaruConsole.DebugWriteLine("Nintendo plugin", "debugAddr = 0x{0:X8}", fields.DebugAddr);
-        AaruConsole.DebugWriteLine("Nintendo plugin", "dolOff = 0x{0:X8}", fields.DolOff);
-        AaruConsole.DebugWriteLine("Nintendo plugin", "fstOff = 0x{0:X8}", fields.FstOff);
-        AaruConsole.DebugWriteLine("Nintendo plugin", "fstSize = {0}", fields.FstSize);
-        AaruConsole.DebugWriteLine("Nintendo plugin", "fstMax = {0}", fields.FstMax);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "discType = {0}", fields.DiscType);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "gameCode = {0}", fields.GameCode);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "regionCode = {0}", fields.RegionCode);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "publisherCode = {0}", fields.PublisherCode);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "discID = {0}", fields.DiscId);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "discNumber = {0}", fields.DiscNumber);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "discVersion = {0}", fields.DiscVersion);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "streaming = {0}", fields.Streaming);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "streamBufferSize = {0}", fields.StreamBufferSize);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "title = \"{0}\"", fields.Title);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "debugOff = 0x{0:X8}", fields.DebugOff);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "debugAddr = 0x{0:X8}", fields.DebugAddr);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "dolOff = 0x{0:X8}", fields.DolOff);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "fstOff = 0x{0:X8}", fields.FstOff);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "fstSize = {0}", fields.FstSize);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "fstMax = {0}", fields.FstMax);
 
         for(int i = 0; i < fields.FirstPartitions.Length; i++)
         {
-            AaruConsole.DebugWriteLine("Nintendo plugin", "firstPartitions[{1}].offset = {0}",
+            AaruConsole.DebugWriteLine(MODULE_NAME, "firstPartitions[{1}].offset = {0}",
                                        fields.FirstPartitions[i].Offset, i);
 
-            AaruConsole.DebugWriteLine("Nintendo plugin", "firstPartitions[{1}].type = {0}",
+            AaruConsole.DebugWriteLine(MODULE_NAME, "firstPartitions[{1}].type = {0}",
                                        fields.FirstPartitions[i].Type, i);
         }
 
         for(int i = 0; i < fields.SecondPartitions.Length; i++)
         {
-            AaruConsole.DebugWriteLine("Nintendo plugin", "secondPartitions[{1}].offset = {0}",
+            AaruConsole.DebugWriteLine(MODULE_NAME, "secondPartitions[{1}].offset = {0}",
                                        fields.SecondPartitions[i].Offset, i);
 
-            AaruConsole.DebugWriteLine("Nintendo plugin", "secondPartitions[{1}].type = {0}",
+            AaruConsole.DebugWriteLine(MODULE_NAME, "secondPartitions[{1}].type = {0}",
                                        fields.SecondPartitions[i].Type, i);
         }
 
         for(int i = 0; i < fields.ThirdPartitions.Length; i++)
         {
-            AaruConsole.DebugWriteLine("Nintendo plugin", "thirdPartitions[{1}].offset = {0}",
+            AaruConsole.DebugWriteLine(MODULE_NAME, "thirdPartitions[{1}].offset = {0}",
                                        fields.ThirdPartitions[i].Offset, i);
 
-            AaruConsole.DebugWriteLine("Nintendo plugin", "thirdPartitions[{1}].type = {0}",
+            AaruConsole.DebugWriteLine(MODULE_NAME, "thirdPartitions[{1}].type = {0}",
                                        fields.ThirdPartitions[i].Type, i);
         }
 
         for(int i = 0; i < fields.FourthPartitions.Length; i++)
         {
-            AaruConsole.DebugWriteLine("Nintendo plugin", "fourthPartitions[{1}].offset = {0}",
+            AaruConsole.DebugWriteLine(MODULE_NAME, "fourthPartitions[{1}].offset = {0}",
                                        fields.FourthPartitions[i].Offset, i);
 
-            AaruConsole.DebugWriteLine("Nintendo plugin", "fourthPartitions[{1}].type = {0}",
+            AaruConsole.DebugWriteLine(MODULE_NAME, "fourthPartitions[{1}].type = {0}",
                                        fields.FourthPartitions[i].Type, i);
         }
 
-        AaruConsole.DebugWriteLine("Nintendo plugin", "region = {0}", fields.Region);
-        AaruConsole.DebugWriteLine("Nintendo plugin", "japanAge = {0}", fields.JapanAge);
-        AaruConsole.DebugWriteLine("Nintendo plugin", "usaAge = {0}", fields.UsaAge);
-        AaruConsole.DebugWriteLine("Nintendo plugin", "germanAge = {0}", fields.GermanAge);
-        AaruConsole.DebugWriteLine("Nintendo plugin", "pegiAge = {0}", fields.PegiAge);
-        AaruConsole.DebugWriteLine("Nintendo plugin", "finlandAge = {0}", fields.FinlandAge);
-        AaruConsole.DebugWriteLine("Nintendo plugin", "portugalAge = {0}", fields.PortugalAge);
-        AaruConsole.DebugWriteLine("Nintendo plugin", "ukAge = {0}", fields.UkAge);
-        AaruConsole.DebugWriteLine("Nintendo plugin", "australiaAge = {0}", fields.AustraliaAge);
-        AaruConsole.DebugWriteLine("Nintendo plugin", "koreaAge = {0}", fields.KoreaAge);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "region = {0}", fields.Region);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "japanAge = {0}", fields.JapanAge);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "usaAge = {0}", fields.UsaAge);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "germanAge = {0}", fields.GermanAge);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "pegiAge = {0}", fields.PegiAge);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "finlandAge = {0}", fields.FinlandAge);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "portugalAge = {0}", fields.PortugalAge);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "ukAge = {0}", fields.UkAge);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "australiaAge = {0}", fields.AustraliaAge);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "koreaAge = {0}", fields.KoreaAge);
 
         sbInformation.AppendLine(Localization.Nintendo_optical_filesystem);
 

Aaru.Filesystems/Nintendo/Nintendo.cs

@@ -41,4 +41,5 @@ public sealed partial class NintendoPlugin : IFilesystem
     public Guid Id => new("4675fcb4-4418-4288-9e4a-33d6a4ac1126");
     /// <inheritdoc />
     public string Author => Authors.NataliaPortillo;
+    const string MODULE_NAME = "Nintendo plugin";
 }

Aaru.Filesystems/ODS/Info.cs

@@ -72,7 +72,7 @@ public sealed partial class ODS
         Array.Copy(hbSector, 0x1F0, magicB, 0, 12);
         string magic = Encoding.ASCII.GetString(magicB);
 
-        AaruConsole.DebugWriteLine("Files-11 plugin", Localization.magic_0, magic);
+        AaruConsole.DebugWriteLine(MODULE_NAME, Localization.magic_0, magic);
 
         if(magic is "DECFILE11A  " or "DECFILE11B  ")
             return true;
@@ -92,7 +92,7 @@ public sealed partial class ODS
         Array.Copy(hbSector, 0x3F0, magicB, 0, 12);
         magic = Encoding.ASCII.GetString(magicB);
 
-        AaruConsole.DebugWriteLine("Files-11 plugin", Localization.unaligned_magic_0, magic);
+        AaruConsole.DebugWriteLine(MODULE_NAME, Localization.unaligned_magic_0, magic);
 
         return magic is "DECFILE11A  " or "DECFILE11B  ";
     }

Aaru.Filesystems/ODS/ODS.cs

@@ -54,4 +54,5 @@ public sealed partial class ODS : IFilesystem
     public Guid Id => new("de20633c-8021-4384-aeb0-83b0df14491f");
     /// <inheritdoc />
     public string Author => Authors.NataliaPortillo;
+    const string MODULE_NAME = "Files-11 plugin";
 }

Aaru.Filesystems/ProDOS/Info.cs

@@ -87,31 +87,31 @@ public sealed partial class ProDOSPlugin
         }
 
         ushort prePointer = BitConverter.ToUInt16(rootDirectoryKeyBlock, 0);
-        AaruConsole.DebugWriteLine("ProDOS plugin", "prePointer = {0}", prePointer);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "prePointer = {0}", prePointer);
 
         if(prePointer != 0)
             return false;
 
         byte storageType = (byte)((rootDirectoryKeyBlock[0x04] & STORAGE_TYPE_MASK) >> 4);
-        AaruConsole.DebugWriteLine("ProDOS plugin", "storage_type = {0}", storageType);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "storage_type = {0}", storageType);
 
         if(storageType != ROOT_DIRECTORY_TYPE)
             return false;
 
         byte entryLength = rootDirectoryKeyBlock[0x23];
-        AaruConsole.DebugWriteLine("ProDOS plugin", "entry_length = {0}", entryLength);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "entry_length = {0}", entryLength);
 
         if(entryLength != ENTRY_LENGTH)
             return false;
 
         byte entriesPerBlock = rootDirectoryKeyBlock[0x24];
-        AaruConsole.DebugWriteLine("ProDOS plugin", "entries_per_block = {0}", entriesPerBlock);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "entries_per_block = {0}", entriesPerBlock);
 
         if(entriesPerBlock != ENTRIES_PER_BLOCK)
             return false;
 
         ushort bitMapPointer = BitConverter.ToUInt16(rootDirectoryKeyBlock, 0x27);
-        AaruConsole.DebugWriteLine("ProDOS plugin", "bit_map_pointer = {0}", bitMapPointer);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "bit_map_pointer = {0}", bitMapPointer);
 
         if(bitMapPointer > partition.End)
             return false;
@@ -121,7 +121,7 @@ public sealed partial class ProDOSPlugin
         if(apmFromHddOnCd)
             totalBlocks /= 4;
 
-        AaruConsole.DebugWriteLine("ProDOS plugin", "{0} <= ({1} - {2} + 1)? {3}", totalBlocks, partition.End,
+        AaruConsole.DebugWriteLine(MODULE_NAME, "{0} <= ({1} - {2} + 1)? {3}", totalBlocks, partition.End,
                                    partition.Start, totalBlocks <= partition.End - partition.Start + 1);
 
         return totalBlocks <= partition.End - partition.Start + 1;
@@ -200,11 +200,11 @@ public sealed partial class ProDOSPlugin
             if(year < 1940)
                 year += 100;
 
-            AaruConsole.DebugWriteLine("ProDOS plugin", "temp_timestamp_left = 0x{0:X4}", tempTimestampLeft);
-            AaruConsole.DebugWriteLine("ProDOS plugin", "temp_timestamp_right = 0x{0:X4}", tempTimestampRight);
-            AaruConsole.DebugWriteLine("ProDOS plugin", "temp_timestamp = 0x{0:X8}", tempTimestamp);
+            AaruConsole.DebugWriteLine(MODULE_NAME, "temp_timestamp_left = 0x{0:X4}", tempTimestampLeft);
+            AaruConsole.DebugWriteLine(MODULE_NAME, "temp_timestamp_right = 0x{0:X4}", tempTimestampRight);
+            AaruConsole.DebugWriteLine(MODULE_NAME, "temp_timestamp = 0x{0:X8}", tempTimestamp);
 
-            AaruConsole.DebugWriteLine("ProDOS plugin",
+            AaruConsole.DebugWriteLine(MODULE_NAME,
                                        Localization.Datetime_field_year_0_month_1_day_2_hour_3_minute_4, year, month,
                                        day, hour, minute);
 
@@ -291,7 +291,7 @@ public sealed partial class ProDOSPlugin
 
         // TODO: Fix mask
         if((rootDirectoryKeyBlock.header.access & RESERVED_ATTRIBUTE_MASK) != 0)
-            AaruConsole.DebugWriteLine("ProDOS plugin", Localization.Reserved_attributes_are_set_0,
+            AaruConsole.DebugWriteLine(MODULE_NAME, Localization.Reserved_attributes_are_set_0,
                                        rootDirectoryKeyBlock.header.access);
 
         information = sbInformation.ToString();

Aaru.Filesystems/ProDOS/ProDOS.cs

@@ -46,4 +46,5 @@ public sealed partial class ProDOSPlugin : IFilesystem
     public Guid Id => new("43874265-7B8A-4739-BCF7-07F80D5932BF");
     /// <inheritdoc />
     public string Author => Authors.NataliaPortillo;
+    const string MODULE_NAME = "ProDOS plugin";
 }

Aaru.Filesystems/QNX4/Info.cs

@@ -101,77 +101,77 @@ public sealed partial class QNX4
 
         // Too much useless information
         /*
-        AaruConsole.DebugWriteLine("QNX4 plugin", "qnxSb.rootDir.di_fname = {0}", CurrentEncoding.GetString(qnxSb.rootDir.di_fname));
-        AaruConsole.DebugWriteLine("QNX4 plugin", "qnxSb.rootDir.di_size = {0}", qnxSb.rootDir.di_size);
-        AaruConsole.DebugWriteLine("QNX4 plugin", "qnxSb.rootDir.di_first_xtnt.block = {0}", qnxSb.rootDir.di_first_xtnt.block);
-        AaruConsole.DebugWriteLine("QNX4 plugin", "qnxSb.rootDir.di_first_xtnt.length = {0}", qnxSb.rootDir.di_first_xtnt.length);
-        AaruConsole.DebugWriteLine("QNX4 plugin", "qnxSb.rootDir.di_xblk = {0}", qnxSb.rootDir.di_xblk);
-        AaruConsole.DebugWriteLine("QNX4 plugin", "qnxSb.rootDir.di_ftime = {0}", DateHandlers.UNIXUnsignedToDateTime(qnxSb.rootDir.di_ftime));
-        AaruConsole.DebugWriteLine("QNX4 plugin", "qnxSb.rootDir.di_mtime = {0}", DateHandlers.UNIXUnsignedToDateTime(qnxSb.rootDir.di_mtime));
-        AaruConsole.DebugWriteLine("QNX4 plugin", "qnxSb.rootDir.di_atime = {0}", DateHandlers.UNIXUnsignedToDateTime(qnxSb.rootDir.di_atime));
-        AaruConsole.DebugWriteLine("QNX4 plugin", "qnxSb.rootDir.di_ctime = {0}", DateHandlers.UNIXUnsignedToDateTime(qnxSb.rootDir.di_ctime));
-        AaruConsole.DebugWriteLine("QNX4 plugin", "qnxSb.rootDir.di_num_xtnts = {0}", qnxSb.rootDir.di_num_xtnts);
-        AaruConsole.DebugWriteLine("QNX4 plugin", "qnxSb.rootDir.di_mode = {0}", Convert.ToString(qnxSb.rootDir.di_mode, 8));
-        AaruConsole.DebugWriteLine("QNX4 plugin", "qnxSb.rootDir.di_uid = {0}", qnxSb.rootDir.di_uid);
-        AaruConsole.DebugWriteLine("QNX4 plugin", "qnxSb.rootDir.di_gid = {0}", qnxSb.rootDir.di_gid);
-        AaruConsole.DebugWriteLine("QNX4 plugin", "qnxSb.rootDir.di_nlink = {0}", qnxSb.rootDir.di_nlink);
-        AaruConsole.DebugWriteLine("QNX4 plugin", "qnxSb.rootDir.di_zero = {0}", qnxSb.rootDir.di_zero);
-        AaruConsole.DebugWriteLine("QNX4 plugin", "qnxSb.rootDir.di_type = {0}", qnxSb.rootDir.di_type);
-        AaruConsole.DebugWriteLine("QNX4 plugin", "qnxSb.rootDir.di_status = {0}", qnxSb.rootDir.di_status);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "qnxSb.rootDir.di_fname = {0}", CurrentEncoding.GetString(qnxSb.rootDir.di_fname));
+        AaruConsole.DebugWriteLine(MODULE_NAME, "qnxSb.rootDir.di_size = {0}", qnxSb.rootDir.di_size);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "qnxSb.rootDir.di_first_xtnt.block = {0}", qnxSb.rootDir.di_first_xtnt.block);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "qnxSb.rootDir.di_first_xtnt.length = {0}", qnxSb.rootDir.di_first_xtnt.length);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "qnxSb.rootDir.di_xblk = {0}", qnxSb.rootDir.di_xblk);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "qnxSb.rootDir.di_ftime = {0}", DateHandlers.UNIXUnsignedToDateTime(qnxSb.rootDir.di_ftime));
+        AaruConsole.DebugWriteLine(MODULE_NAME, "qnxSb.rootDir.di_mtime = {0}", DateHandlers.UNIXUnsignedToDateTime(qnxSb.rootDir.di_mtime));
+        AaruConsole.DebugWriteLine(MODULE_NAME, "qnxSb.rootDir.di_atime = {0}", DateHandlers.UNIXUnsignedToDateTime(qnxSb.rootDir.di_atime));
+        AaruConsole.DebugWriteLine(MODULE_NAME, "qnxSb.rootDir.di_ctime = {0}", DateHandlers.UNIXUnsignedToDateTime(qnxSb.rootDir.di_ctime));
+        AaruConsole.DebugWriteLine(MODULE_NAME, "qnxSb.rootDir.di_num_xtnts = {0}", qnxSb.rootDir.di_num_xtnts);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "qnxSb.rootDir.di_mode = {0}", Convert.ToString(qnxSb.rootDir.di_mode, 8));
+        AaruConsole.DebugWriteLine(MODULE_NAME, "qnxSb.rootDir.di_uid = {0}", qnxSb.rootDir.di_uid);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "qnxSb.rootDir.di_gid = {0}", qnxSb.rootDir.di_gid);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "qnxSb.rootDir.di_nlink = {0}", qnxSb.rootDir.di_nlink);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "qnxSb.rootDir.di_zero = {0}", qnxSb.rootDir.di_zero);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "qnxSb.rootDir.di_type = {0}", qnxSb.rootDir.di_type);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "qnxSb.rootDir.di_status = {0}", qnxSb.rootDir.di_status);
 
-        AaruConsole.DebugWriteLine("QNX4 plugin", "qnxSb.inode.di_fname = {0}", CurrentEncoding.GetString(qnxSb.inode.di_fname));
-        AaruConsole.DebugWriteLine("QNX4 plugin", "qnxSb.inode.di_size = {0}", qnxSb.inode.di_size);
-        AaruConsole.DebugWriteLine("QNX4 plugin", "qnxSb.inode.di_first_xtnt.block = {0}", qnxSb.inode.di_first_xtnt.block);
-        AaruConsole.DebugWriteLine("QNX4 plugin", "qnxSb.inode.di_first_xtnt.length = {0}", qnxSb.inode.di_first_xtnt.length);
-        AaruConsole.DebugWriteLine("QNX4 plugin", "qnxSb.inode.di_xblk = {0}", qnxSb.inode.di_xblk);
-        AaruConsole.DebugWriteLine("QNX4 plugin", "qnxSb.inode.di_ftime = {0}", DateHandlers.UNIXUnsignedToDateTime(qnxSb.inode.di_ftime));
-        AaruConsole.DebugWriteLine("QNX4 plugin", "qnxSb.inode.di_mtime = {0}", DateHandlers.UNIXUnsignedToDateTime(qnxSb.inode.di_mtime));
-        AaruConsole.DebugWriteLine("QNX4 plugin", "qnxSb.inode.di_atime = {0}", DateHandlers.UNIXUnsignedToDateTime(qnxSb.inode.di_atime));
-        AaruConsole.DebugWriteLine("QNX4 plugin", "qnxSb.inode.di_ctime = {0}", DateHandlers.UNIXUnsignedToDateTime(qnxSb.inode.di_ctime));
-        AaruConsole.DebugWriteLine("QNX4 plugin", "qnxSb.inode.di_num_xtnts = {0}", qnxSb.inode.di_num_xtnts);
-        AaruConsole.DebugWriteLine("QNX4 plugin", "qnxSb.inode.di_mode = {0}", Convert.ToString(qnxSb.inode.di_mode, 8));
-        AaruConsole.DebugWriteLine("QNX4 plugin", "qnxSb.inode.di_uid = {0}", qnxSb.inode.di_uid);
-        AaruConsole.DebugWriteLine("QNX4 plugin", "qnxSb.inode.di_gid = {0}", qnxSb.inode.di_gid);
-        AaruConsole.DebugWriteLine("QNX4 plugin", "qnxSb.inode.di_nlink = {0}", qnxSb.inode.di_nlink);
-        AaruConsole.DebugWriteLine("QNX4 plugin", "qnxSb.inode.di_zero = {0}", qnxSb.inode.di_zero);
-        AaruConsole.DebugWriteLine("QNX4 plugin", "qnxSb.inode.di_type = {0}", qnxSb.inode.di_type);
-        AaruConsole.DebugWriteLine("QNX4 plugin", "qnxSb.inode.di_status = {0}", qnxSb.inode.di_status);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "qnxSb.inode.di_fname = {0}", CurrentEncoding.GetString(qnxSb.inode.di_fname));
+        AaruConsole.DebugWriteLine(MODULE_NAME, "qnxSb.inode.di_size = {0}", qnxSb.inode.di_size);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "qnxSb.inode.di_first_xtnt.block = {0}", qnxSb.inode.di_first_xtnt.block);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "qnxSb.inode.di_first_xtnt.length = {0}", qnxSb.inode.di_first_xtnt.length);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "qnxSb.inode.di_xblk = {0}", qnxSb.inode.di_xblk);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "qnxSb.inode.di_ftime = {0}", DateHandlers.UNIXUnsignedToDateTime(qnxSb.inode.di_ftime));
+        AaruConsole.DebugWriteLine(MODULE_NAME, "qnxSb.inode.di_mtime = {0}", DateHandlers.UNIXUnsignedToDateTime(qnxSb.inode.di_mtime));
+        AaruConsole.DebugWriteLine(MODULE_NAME, "qnxSb.inode.di_atime = {0}", DateHandlers.UNIXUnsignedToDateTime(qnxSb.inode.di_atime));
+        AaruConsole.DebugWriteLine(MODULE_NAME, "qnxSb.inode.di_ctime = {0}", DateHandlers.UNIXUnsignedToDateTime(qnxSb.inode.di_ctime));
+        AaruConsole.DebugWriteLine(MODULE_NAME, "qnxSb.inode.di_num_xtnts = {0}", qnxSb.inode.di_num_xtnts);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "qnxSb.inode.di_mode = {0}", Convert.ToString(qnxSb.inode.di_mode, 8));
+        AaruConsole.DebugWriteLine(MODULE_NAME, "qnxSb.inode.di_uid = {0}", qnxSb.inode.di_uid);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "qnxSb.inode.di_gid = {0}", qnxSb.inode.di_gid);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "qnxSb.inode.di_nlink = {0}", qnxSb.inode.di_nlink);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "qnxSb.inode.di_zero = {0}", qnxSb.inode.di_zero);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "qnxSb.inode.di_type = {0}", qnxSb.inode.di_type);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "qnxSb.inode.di_status = {0}", qnxSb.inode.di_status);
 
-        AaruConsole.DebugWriteLine("QNX4 plugin", "qnxSb.boot.di_fname = {0}", CurrentEncoding.GetString(qnxSb.boot.di_fname));
-        AaruConsole.DebugWriteLine("QNX4 plugin", "qnxSb.boot.di_size = {0}", qnxSb.boot.di_size);
-        AaruConsole.DebugWriteLine("QNX4 plugin", "qnxSb.boot.di_first_xtnt.block = {0}", qnxSb.boot.di_first_xtnt.block);
-        AaruConsole.DebugWriteLine("QNX4 plugin", "qnxSb.boot.di_first_xtnt.length = {0}", qnxSb.boot.di_first_xtnt.length);
-        AaruConsole.DebugWriteLine("QNX4 plugin", "qnxSb.boot.di_xblk = {0}", qnxSb.boot.di_xblk);
-        AaruConsole.DebugWriteLine("QNX4 plugin", "qnxSb.boot.di_ftime = {0}", DateHandlers.UNIXUnsignedToDateTime(qnxSb.boot.di_ftime));
-        AaruConsole.DebugWriteLine("QNX4 plugin", "qnxSb.boot.di_mtime = {0}", DateHandlers.UNIXUnsignedToDateTime(qnxSb.boot.di_mtime));
-        AaruConsole.DebugWriteLine("QNX4 plugin", "qnxSb.boot.di_atime = {0}", DateHandlers.UNIXUnsignedToDateTime(qnxSb.boot.di_atime));
-        AaruConsole.DebugWriteLine("QNX4 plugin", "qnxSb.boot.di_ctime = {0}", DateHandlers.UNIXUnsignedToDateTime(qnxSb.boot.di_ctime));
-        AaruConsole.DebugWriteLine("QNX4 plugin", "qnxSb.boot.di_num_xtnts = {0}", qnxSb.boot.di_num_xtnts);
-        AaruConsole.DebugWriteLine("QNX4 plugin", "qnxSb.boot.di_mode = {0}", Convert.ToString(qnxSb.boot.di_mode, 8));
-        AaruConsole.DebugWriteLine("QNX4 plugin", "qnxSb.boot.di_uid = {0}", qnxSb.boot.di_uid);
-        AaruConsole.DebugWriteLine("QNX4 plugin", "qnxSb.boot.di_gid = {0}", qnxSb.boot.di_gid);
-        AaruConsole.DebugWriteLine("QNX4 plugin", "qnxSb.boot.di_nlink = {0}", qnxSb.boot.di_nlink);
-        AaruConsole.DebugWriteLine("QNX4 plugin", "qnxSb.boot.di_zero = {0}", qnxSb.boot.di_zero);
-        AaruConsole.DebugWriteLine("QNX4 plugin", "qnxSb.boot.di_type = {0}", qnxSb.boot.di_type);
-        AaruConsole.DebugWriteLine("QNX4 plugin", "qnxSb.boot.di_status = {0}", qnxSb.boot.di_status);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "qnxSb.boot.di_fname = {0}", CurrentEncoding.GetString(qnxSb.boot.di_fname));
+        AaruConsole.DebugWriteLine(MODULE_NAME, "qnxSb.boot.di_size = {0}", qnxSb.boot.di_size);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "qnxSb.boot.di_first_xtnt.block = {0}", qnxSb.boot.di_first_xtnt.block);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "qnxSb.boot.di_first_xtnt.length = {0}", qnxSb.boot.di_first_xtnt.length);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "qnxSb.boot.di_xblk = {0}", qnxSb.boot.di_xblk);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "qnxSb.boot.di_ftime = {0}", DateHandlers.UNIXUnsignedToDateTime(qnxSb.boot.di_ftime));
+        AaruConsole.DebugWriteLine(MODULE_NAME, "qnxSb.boot.di_mtime = {0}", DateHandlers.UNIXUnsignedToDateTime(qnxSb.boot.di_mtime));
+        AaruConsole.DebugWriteLine(MODULE_NAME, "qnxSb.boot.di_atime = {0}", DateHandlers.UNIXUnsignedToDateTime(qnxSb.boot.di_atime));
+        AaruConsole.DebugWriteLine(MODULE_NAME, "qnxSb.boot.di_ctime = {0}", DateHandlers.UNIXUnsignedToDateTime(qnxSb.boot.di_ctime));
+        AaruConsole.DebugWriteLine(MODULE_NAME, "qnxSb.boot.di_num_xtnts = {0}", qnxSb.boot.di_num_xtnts);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "qnxSb.boot.di_mode = {0}", Convert.ToString(qnxSb.boot.di_mode, 8));
+        AaruConsole.DebugWriteLine(MODULE_NAME, "qnxSb.boot.di_uid = {0}", qnxSb.boot.di_uid);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "qnxSb.boot.di_gid = {0}", qnxSb.boot.di_gid);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "qnxSb.boot.di_nlink = {0}", qnxSb.boot.di_nlink);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "qnxSb.boot.di_zero = {0}", qnxSb.boot.di_zero);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "qnxSb.boot.di_type = {0}", qnxSb.boot.di_type);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "qnxSb.boot.di_status = {0}", qnxSb.boot.di_status);
 
-        AaruConsole.DebugWriteLine("QNX4 plugin", "qnxSb.altBoot.di_fname = {0}", CurrentEncoding.GetString(qnxSb.altBoot.di_fname));
-        AaruConsole.DebugWriteLine("QNX4 plugin", "qnxSb.altBoot.di_size = {0}", qnxSb.altBoot.di_size);
-        AaruConsole.DebugWriteLine("QNX4 plugin", "qnxSb.altBoot.di_first_xtnt.block = {0}", qnxSb.altBoot.di_first_xtnt.block);
-        AaruConsole.DebugWriteLine("QNX4 plugin", "qnxSb.altBoot.di_first_xtnt.length = {0}", qnxSb.altBoot.di_first_xtnt.length);
-        AaruConsole.DebugWriteLine("QNX4 plugin", "qnxSb.altBoot.di_xblk = {0}", qnxSb.altBoot.di_xblk);
-        AaruConsole.DebugWriteLine("QNX4 plugin", "qnxSb.altBoot.di_ftime = {0}", DateHandlers.UNIXUnsignedToDateTime(qnxSb.altBoot.di_ftime));
-        AaruConsole.DebugWriteLine("QNX4 plugin", "qnxSb.altBoot.di_mtime = {0}", DateHandlers.UNIXUnsignedToDateTime(qnxSb.altBoot.di_mtime));
-        AaruConsole.DebugWriteLine("QNX4 plugin", "qnxSb.altBoot.di_atime = {0}", DateHandlers.UNIXUnsignedToDateTime(qnxSb.altBoot.di_atime));
-        AaruConsole.DebugWriteLine("QNX4 plugin", "qnxSb.altBoot.di_ctime = {0}", DateHandlers.UNIXUnsignedToDateTime(qnxSb.altBoot.di_ctime));
-        AaruConsole.DebugWriteLine("QNX4 plugin", "qnxSb.altBoot.di_num_xtnts = {0}", qnxSb.altBoot.di_num_xtnts);
-        AaruConsole.DebugWriteLine("QNX4 plugin", "qnxSb.altBoot.di_mode = {0}", Convert.ToString(qnxSb.altBoot.di_mode, 8));
-        AaruConsole.DebugWriteLine("QNX4 plugin", "qnxSb.altBoot.di_uid = {0}", qnxSb.altBoot.di_uid);
-        AaruConsole.DebugWriteLine("QNX4 plugin", "qnxSb.altBoot.di_gid = {0}", qnxSb.altBoot.di_gid);
-        AaruConsole.DebugWriteLine("QNX4 plugin", "qnxSb.altBoot.di_nlink = {0}", qnxSb.altBoot.di_nlink);
-        AaruConsole.DebugWriteLine("QNX4 plugin", "qnxSb.altBoot.di_zero = {0}", qnxSb.altBoot.di_zero);
-        AaruConsole.DebugWriteLine("QNX4 plugin", "qnxSb.altBoot.di_type = {0}", qnxSb.altBoot.di_type);
-        AaruConsole.DebugWriteLine("QNX4 plugin", "qnxSb.altBoot.di_status = {0}", qnxSb.altBoot.di_status);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "qnxSb.altBoot.di_fname = {0}", CurrentEncoding.GetString(qnxSb.altBoot.di_fname));
+        AaruConsole.DebugWriteLine(MODULE_NAME, "qnxSb.altBoot.di_size = {0}", qnxSb.altBoot.di_size);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "qnxSb.altBoot.di_first_xtnt.block = {0}", qnxSb.altBoot.di_first_xtnt.block);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "qnxSb.altBoot.di_first_xtnt.length = {0}", qnxSb.altBoot.di_first_xtnt.length);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "qnxSb.altBoot.di_xblk = {0}", qnxSb.altBoot.di_xblk);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "qnxSb.altBoot.di_ftime = {0}", DateHandlers.UNIXUnsignedToDateTime(qnxSb.altBoot.di_ftime));
+        AaruConsole.DebugWriteLine(MODULE_NAME, "qnxSb.altBoot.di_mtime = {0}", DateHandlers.UNIXUnsignedToDateTime(qnxSb.altBoot.di_mtime));
+        AaruConsole.DebugWriteLine(MODULE_NAME, "qnxSb.altBoot.di_atime = {0}", DateHandlers.UNIXUnsignedToDateTime(qnxSb.altBoot.di_atime));
+        AaruConsole.DebugWriteLine(MODULE_NAME, "qnxSb.altBoot.di_ctime = {0}", DateHandlers.UNIXUnsignedToDateTime(qnxSb.altBoot.di_ctime));
+        AaruConsole.DebugWriteLine(MODULE_NAME, "qnxSb.altBoot.di_num_xtnts = {0}", qnxSb.altBoot.di_num_xtnts);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "qnxSb.altBoot.di_mode = {0}", Convert.ToString(qnxSb.altBoot.di_mode, 8));
+        AaruConsole.DebugWriteLine(MODULE_NAME, "qnxSb.altBoot.di_uid = {0}", qnxSb.altBoot.di_uid);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "qnxSb.altBoot.di_gid = {0}", qnxSb.altBoot.di_gid);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "qnxSb.altBoot.di_nlink = {0}", qnxSb.altBoot.di_nlink);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "qnxSb.altBoot.di_zero = {0}", qnxSb.altBoot.di_zero);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "qnxSb.altBoot.di_type = {0}", qnxSb.altBoot.di_type);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "qnxSb.altBoot.di_status = {0}", qnxSb.altBoot.di_status);
         */
 
         information = Localization.QNX4_filesystem + "\n" +

Aaru.Filesystems/QNX4/QNX4.cs

@@ -43,4 +43,5 @@ public sealed partial class QNX4 : IFilesystem
     public Guid Id => new("E73A63FA-B5B0-48BF-BF82-DA5F0A8170D2");
     /// <inheritdoc />
     public string Author => Authors.NataliaPortillo;
+    const string MODULE_NAME = "QNX4 plugin";
 }

Aaru.Filesystems/RBF/Info.cs

@@ -75,7 +75,7 @@ public sealed partial class RBF : IFilesystem
             IdSector    rbfSb     = Marshal.ByteArrayToStructureBigEndian<IdSector>(sector);
             NewIdSector rbf9000Sb = Marshal.ByteArrayToStructureBigEndian<NewIdSector>(sector);
 
-            AaruConsole.DebugWriteLine("RBF plugin", Localization.magic_at_0_equals_1_or_2_expected_3_or_4, location,
+            AaruConsole.DebugWriteLine(MODULE_NAME, Localization.magic_at_0_equals_1_or_2_expected_3_or_4, location,
                                        rbfSb.dd_sync, rbf9000Sb.rid_sync, RBF_SYNC, RBF_CNYS);
 
             if(rbfSb.dd_sync == RBF_SYNC ||
@@ -122,7 +122,7 @@ public sealed partial class RBF : IFilesystem
             rbfSb     = Marshal.ByteArrayToStructureBigEndian<IdSector>(sector);
             rbf9000Sb = Marshal.ByteArrayToStructureBigEndian<NewIdSector>(sector);
 
-            AaruConsole.DebugWriteLine("RBF plugin", Localization.magic_at_0_equals_1_or_2_expected_3_or_4, location,
+            AaruConsole.DebugWriteLine(MODULE_NAME, Localization.magic_at_0_equals_1_or_2_expected_3_or_4, location,
                                        rbfSb.dd_sync, rbf9000Sb.rid_sync, RBF_SYNC, RBF_CNYS);
 
             if(rbfSb.dd_sync == RBF_SYNC ||

Aaru.Filesystems/RBF/RBF.cs

@@ -41,4 +41,5 @@ public sealed partial class RBF : IFilesystem
     public Guid Id => new("E864E45B-0B52-4D29-A858-7BDFA9199FB2");
     /// <inheritdoc />
     public string Author => Authors.NataliaPortillo;
+    const string MODULE_NAME = "RBF plugin";
 }

Aaru.Filesystems/ReFS/Info.cs

@@ -92,31 +92,31 @@ public sealed partial class ReFS : IFilesystem
 
         VolumeHeader vhdr = Marshal.ByteArrayToStructureLittleEndian<VolumeHeader>(sector);
 
-        AaruConsole.DebugWriteLine("ReFS plugin", "VolumeHeader.jump empty? = {0}",
+        AaruConsole.DebugWriteLine(MODULE_NAME, "VolumeHeader.jump empty? = {0}",
                                    ArrayHelpers.ArrayIsNullOrEmpty(vhdr.jump));
 
-        AaruConsole.DebugWriteLine("ReFS plugin", "VolumeHeader.signature = {0}",
+        AaruConsole.DebugWriteLine(MODULE_NAME, "VolumeHeader.signature = {0}",
                                    StringHandlers.CToString(vhdr.signature));
 
-        AaruConsole.DebugWriteLine("ReFS plugin", "VolumeHeader.mustBeZero empty? = {0}",
+        AaruConsole.DebugWriteLine(MODULE_NAME, "VolumeHeader.mustBeZero empty? = {0}",
                                    ArrayHelpers.ArrayIsNullOrEmpty(vhdr.mustBeZero));
 
-        AaruConsole.DebugWriteLine("ReFS plugin", "VolumeHeader.identifier = {0}",
+        AaruConsole.DebugWriteLine(MODULE_NAME, "VolumeHeader.identifier = {0}",
                                    StringHandlers.CToString(BitConverter.GetBytes(vhdr.identifier)));
 
-        AaruConsole.DebugWriteLine("ReFS plugin", "VolumeHeader.length = {0}", vhdr.length);
-        AaruConsole.DebugWriteLine("ReFS plugin", "VolumeHeader.checksum = 0x{0:X4}", vhdr.checksum);
-        AaruConsole.DebugWriteLine("ReFS plugin", "VolumeHeader.sectors = {0}", vhdr.sectors);
-        AaruConsole.DebugWriteLine("ReFS plugin", "VolumeHeader.bytesPerSector = {0}", vhdr.bytesPerSector);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "VolumeHeader.length = {0}", vhdr.length);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "VolumeHeader.checksum = 0x{0:X4}", vhdr.checksum);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "VolumeHeader.sectors = {0}", vhdr.sectors);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "VolumeHeader.bytesPerSector = {0}", vhdr.bytesPerSector);
 
-        AaruConsole.DebugWriteLine("ReFS plugin", "VolumeHeader.sectorsPerCluster = {0}", vhdr.sectorsPerCluster);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "VolumeHeader.sectorsPerCluster = {0}", vhdr.sectorsPerCluster);
 
-        AaruConsole.DebugWriteLine("ReFS plugin", "VolumeHeader.unknown1 zero? = {0}", vhdr.unknown1 == 0);
-        AaruConsole.DebugWriteLine("ReFS plugin", "VolumeHeader.unknown2 zero? = {0}", vhdr.unknown2 == 0);
-        AaruConsole.DebugWriteLine("ReFS plugin", "VolumeHeader.unknown3 zero? = {0}", vhdr.unknown3 == 0);
-        AaruConsole.DebugWriteLine("ReFS plugin", "VolumeHeader.unknown4 zero? = {0}", vhdr.unknown4 == 0);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "VolumeHeader.unknown1 zero? = {0}", vhdr.unknown1 == 0);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "VolumeHeader.unknown2 zero? = {0}", vhdr.unknown2 == 0);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "VolumeHeader.unknown3 zero? = {0}", vhdr.unknown3 == 0);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "VolumeHeader.unknown4 zero? = {0}", vhdr.unknown4 == 0);
 
-        AaruConsole.DebugWriteLine("ReFS plugin", "VolumeHeader.unknown5 empty? = {0}",
+        AaruConsole.DebugWriteLine(MODULE_NAME, "VolumeHeader.unknown5 empty? = {0}",
                                    ArrayHelpers.ArrayIsNullOrEmpty(vhdr.unknown5));
 
         if(vhdr.identifier != FSRS                           ||

Aaru.Filesystems/ReFS/ReFS.cs

@@ -41,4 +41,5 @@ public sealed partial class ReFS : IFilesystem
     public Guid Id => new("37766C4E-EBF5-4113-A712-B758B756ABD6");
     /// <inheritdoc />
     public string Author => Authors.NataliaPortillo;
+    const string MODULE_NAME = "ReFS plugin";
 }

Aaru.Filesystems/SolarFS/Info.cs

@@ -106,29 +106,29 @@ public sealed partial class SolarFS
         Array.Copy(bpbSector, 0x1B, bpb.unk3, 0, 10);
         bpb.unk4 = BitConverter.ToUInt32(bpbSector, 0x26);
 
-        AaruConsole.DebugWriteLine("SolarFS plugin", "BPB.x86_jump: 0x{0:X2}{1:X2}{2:X2}", bpb.x86_jump[0],
+        AaruConsole.DebugWriteLine(MODULE_NAME, "BPB.x86_jump: 0x{0:X2}{1:X2}{2:X2}", bpb.x86_jump[0],
                                    bpb.x86_jump[1], bpb.x86_jump[2]);
 
-        AaruConsole.DebugWriteLine("SolarFS plugin", "BPB.OEMName: \"{0}\"", bpb.OEMName);
-        AaruConsole.DebugWriteLine("SolarFS plugin", "BPB.bps: {0}", bpb.bps);
-        AaruConsole.DebugWriteLine("SolarFS plugin", "BPB.unk1: 0x{0:X2}", bpb.unk1);
-        AaruConsole.DebugWriteLine("SolarFS plugin", "BPB.unk2: 0x{0:X4}", bpb.unk2);
-        AaruConsole.DebugWriteLine("SolarFS plugin", "BPB.root_ent: {0}", bpb.root_ent);
-        AaruConsole.DebugWriteLine("SolarFS plugin", "BPB.sectors: {0}", bpb.sectors);
-        AaruConsole.DebugWriteLine("SolarFS plugin", "BPB.media: 0x{0:X2}", bpb.media);
-        AaruConsole.DebugWriteLine("SolarFS plugin", "BPB.spfat: {0}", bpb.spfat);
-        AaruConsole.DebugWriteLine("SolarFS plugin", "BPB.sptrk: {0}", bpb.sptrk);
-        AaruConsole.DebugWriteLine("SolarFS plugin", "BPB.heads: {0}", bpb.heads);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "BPB.OEMName: \"{0}\"", bpb.OEMName);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "BPB.bps: {0}", bpb.bps);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "BPB.unk1: 0x{0:X2}", bpb.unk1);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "BPB.unk2: 0x{0:X4}", bpb.unk2);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "BPB.root_ent: {0}", bpb.root_ent);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "BPB.sectors: {0}", bpb.sectors);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "BPB.media: 0x{0:X2}", bpb.media);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "BPB.spfat: {0}", bpb.spfat);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "BPB.sptrk: {0}", bpb.sptrk);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "BPB.heads: {0}", bpb.heads);
 
-        AaruConsole.DebugWriteLine("SolarFS plugin",
+        AaruConsole.DebugWriteLine(MODULE_NAME,
                                    "BPB.unk3: 0x{0:X2}{1:X2}{2:X2}{3:X2}{4:X2}{5:X2}{6:X2}{7:X2}{8:X2}{9:X2}",
                                    bpb.unk3[0], bpb.unk3[1], bpb.unk3[2], bpb.unk3[3], bpb.unk3[4], bpb.unk3[5],
                                    bpb.unk3[6], bpb.unk3[7], bpb.unk3[8], bpb.unk3[9]);
 
-        AaruConsole.DebugWriteLine("SolarFS plugin", "BPB.signature: 0x{0:X2}", bpb.signature);
-        AaruConsole.DebugWriteLine("SolarFS plugin", "BPB.unk4: 0x{0:X8}", bpb.unk4);
-        AaruConsole.DebugWriteLine("SolarFS plugin", "BPB.vol_name: \"{0}\"", bpb.vol_name);
-        AaruConsole.DebugWriteLine("SolarFS plugin", "BPB.fs_type: \"{0}\"", bpb.fs_type);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "BPB.signature: 0x{0:X2}", bpb.signature);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "BPB.unk4: 0x{0:X8}", bpb.unk4);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "BPB.vol_name: \"{0}\"", bpb.vol_name);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "BPB.fs_type: \"{0}\"", bpb.fs_type);
 
         sb.AppendLine(Localization.Solar_OS_filesystem);
         sb.AppendFormat(Localization.Media_descriptor_0, bpb.media).AppendLine();

Aaru.Filesystems/SolarFS/SolarFS.cs

@@ -42,4 +42,5 @@ public sealed partial class SolarFS : IFilesystem
     public Guid Id => new("EA3101C1-E777-4B4F-B5A3-8C57F50F6E65");
     /// <inheritdoc />
     public string Author => Authors.NataliaPortillo;
+    const string MODULE_NAME = "SolarFS plugin";
 }

Aaru.Filesystems/UCSDPascal/Info.cs

@@ -81,16 +81,16 @@ public sealed partial class PascalPlugin
 
         Array.Copy(volBlock, 0x06, volEntry.VolumeName, 0, 8);
 
-        AaruConsole.DebugWriteLine("UCSD Pascal Plugin", "volEntry.firstBlock = {0}", volEntry.FirstBlock);
-        AaruConsole.DebugWriteLine("UCSD Pascal Plugin", "volEntry.lastBlock = {0}", volEntry.LastBlock);
-        AaruConsole.DebugWriteLine("UCSD Pascal Plugin", "volEntry.entryType = {0}", volEntry.EntryType);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "volEntry.firstBlock = {0}", volEntry.FirstBlock);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "volEntry.lastBlock = {0}", volEntry.LastBlock);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "volEntry.entryType = {0}", volEntry.EntryType);
 
-        //            AaruConsole.DebugWriteLine("UCSD Pascal Plugin", "volEntry.volumeName = {0}", volEntry.VolumeName);
-        AaruConsole.DebugWriteLine("UCSD Pascal Plugin", "volEntry.blocks = {0}", volEntry.Blocks);
-        AaruConsole.DebugWriteLine("UCSD Pascal Plugin", "volEntry.files = {0}", volEntry.Files);
-        AaruConsole.DebugWriteLine("UCSD Pascal Plugin", "volEntry.dummy = {0}", volEntry.Dummy);
-        AaruConsole.DebugWriteLine("UCSD Pascal Plugin", "volEntry.lastBoot = {0}", volEntry.LastBoot);
-        AaruConsole.DebugWriteLine("UCSD Pascal Plugin", "volEntry.tail = {0}", volEntry.Tail);
+        //            AaruConsole.DebugWriteLine(MODULE_NAME, "volEntry.volumeName = {0}", volEntry.VolumeName);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "volEntry.blocks = {0}", volEntry.Blocks);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "volEntry.files = {0}", volEntry.Files);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "volEntry.dummy = {0}", volEntry.Dummy);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "volEntry.lastBoot = {0}", volEntry.LastBoot);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "volEntry.tail = {0}", volEntry.Tail);
 
         // First block is always 0 (even is it's sector 2)
         if(volEntry.FirstBlock != 0)

Aaru.Filesystems/UCSDPascal/UCSDPascal.cs

@@ -96,4 +96,6 @@ public sealed partial class PascalPlugin : IReadOnlyFilesystem
             "debug", false.ToString()
         }
     };
+
+    const string MODULE_NAME = "U.C.S.D. Pascal Plugin";
 }

Aaru.Filesystems/UDF/Info.cs

@@ -109,33 +109,33 @@ public sealed partial class UDF
         {
             anchor = Marshal.ByteArrayToStructureLittleEndian<AnchorVolumeDescriptorPointer>(sector);
 
-            AaruConsole.DebugWriteLine("UDF Plugin", "anchor.tag.tagIdentifier = {0}", anchor.tag.tagIdentifier);
+            AaruConsole.DebugWriteLine(MODULE_NAME, "anchor.tag.tagIdentifier = {0}", anchor.tag.tagIdentifier);
 
-            AaruConsole.DebugWriteLine("UDF Plugin", "anchor.tag.descriptorVersion = {0}",
+            AaruConsole.DebugWriteLine(MODULE_NAME, "anchor.tag.descriptorVersion = {0}",
                                        anchor.tag.descriptorVersion);
 
-            AaruConsole.DebugWriteLine("UDF Plugin", "anchor.tag.tagChecksum = 0x{0:X2}", anchor.tag.tagChecksum);
-            AaruConsole.DebugWriteLine("UDF Plugin", "anchor.tag.reserved = {0}", anchor.tag.reserved);
+            AaruConsole.DebugWriteLine(MODULE_NAME, "anchor.tag.tagChecksum = 0x{0:X2}", anchor.tag.tagChecksum);
+            AaruConsole.DebugWriteLine(MODULE_NAME, "anchor.tag.reserved = {0}", anchor.tag.reserved);
 
-            AaruConsole.DebugWriteLine("UDF Plugin", "anchor.tag.tagSerialNumber = {0}", anchor.tag.tagSerialNumber);
+            AaruConsole.DebugWriteLine(MODULE_NAME, "anchor.tag.tagSerialNumber = {0}", anchor.tag.tagSerialNumber);
 
-            AaruConsole.DebugWriteLine("UDF Plugin", "anchor.tag.descriptorCrc = 0x{0:X4}", anchor.tag.descriptorCrc);
+            AaruConsole.DebugWriteLine(MODULE_NAME, "anchor.tag.descriptorCrc = 0x{0:X4}", anchor.tag.descriptorCrc);
 
-            AaruConsole.DebugWriteLine("UDF Plugin", "anchor.tag.descriptorCrcLength = {0}",
+            AaruConsole.DebugWriteLine(MODULE_NAME, "anchor.tag.descriptorCrcLength = {0}",
                                        anchor.tag.descriptorCrcLength);
 
-            AaruConsole.DebugWriteLine("UDF Plugin", "anchor.tag.tagLocation = {0}", anchor.tag.tagLocation);
+            AaruConsole.DebugWriteLine(MODULE_NAME, "anchor.tag.tagLocation = {0}", anchor.tag.tagLocation);
 
-            AaruConsole.DebugWriteLine("UDF Plugin", "anchor.mainVolumeDescriptorSequenceExtent.length = {0}",
+            AaruConsole.DebugWriteLine(MODULE_NAME, "anchor.mainVolumeDescriptorSequenceExtent.length = {0}",
                                        anchor.mainVolumeDescriptorSequenceExtent.length);
 
-            AaruConsole.DebugWriteLine("UDF Plugin", "anchor.mainVolumeDescriptorSequenceExtent.location = {0}",
+            AaruConsole.DebugWriteLine(MODULE_NAME, "anchor.mainVolumeDescriptorSequenceExtent.location = {0}",
                                        anchor.mainVolumeDescriptorSequenceExtent.location);
 
-            AaruConsole.DebugWriteLine("UDF Plugin", "anchor.reserveVolumeDescriptorSequenceExtent.length = {0}",
+            AaruConsole.DebugWriteLine(MODULE_NAME, "anchor.reserveVolumeDescriptorSequenceExtent.length = {0}",
                                        anchor.reserveVolumeDescriptorSequenceExtent.length);
 
-            AaruConsole.DebugWriteLine("UDF Plugin", "anchor.reserveVolumeDescriptorSequenceExtent.location = {0}",
+            AaruConsole.DebugWriteLine(MODULE_NAME, "anchor.reserveVolumeDescriptorSequenceExtent.location = {0}",
                                        anchor.reserveVolumeDescriptorSequenceExtent.location);
 
             if(anchor.tag.tagIdentifier != TagIdentifier.AnchorVolumeDescriptorPointer ||

Aaru.Filesystems/UDF/UDF.cs

@@ -44,4 +44,5 @@ public sealed partial class UDF : IFilesystem
     public Guid Id => new("83976FEC-A91B-464B-9293-56C719461BAB");
     /// <inheritdoc />
     public string Author => Authors.NataliaPortillo;
+    const string MODULE_NAME = "UDF Plugin";
 }

Aaru.Filesystems/UNICOS/Info.cs

@@ -72,7 +72,7 @@ public sealed partial class UNICOS
 
         Superblock unicosSb = Marshal.ByteArrayToStructureBigEndian<Superblock>(sector);
 
-        AaruConsole.DebugWriteLine("UNICOS plugin", Localization.magic_equals_0_expected_1, unicosSb.s_magic,
+        AaruConsole.DebugWriteLine(MODULE_NAME, Localization.magic_equals_0_expected_1, unicosSb.s_magic,
                                    UNICOS_MAGIC);
 
         return unicosSb.s_magic == UNICOS_MAGIC;

Aaru.Filesystems/UNICOS/UNICOS.cs

@@ -49,4 +49,5 @@ public sealed partial class UNICOS : IFilesystem
     public Guid Id => new("61712F04-066C-44D5-A2A0-1E44C66B33F0");
     /// <inheritdoc />
     public string Author => Authors.NataliaPortillo;
+    const string MODULE_NAME = "UNICOS plugin";
 }

Aaru.Filesystems/UNIXBFS/Info.cs

@@ -90,15 +90,15 @@ public sealed partial class BFS
         Array.Copy(bfsSbSector, 0x22, sbStrings, 0, 6);
         bfsSb.s_volume = StringHandlers.CToString(sbStrings, encoding);
 
-        AaruConsole.DebugWriteLine("BFS plugin", "bfs_sb.s_magic: 0x{0:X8}", bfsSb.s_magic);
-        AaruConsole.DebugWriteLine("BFS plugin", "bfs_sb.s_start: 0x{0:X8}", bfsSb.s_start);
-        AaruConsole.DebugWriteLine("BFS plugin", "bfs_sb.s_end: 0x{0:X8}", bfsSb.s_end);
-        AaruConsole.DebugWriteLine("BFS plugin", "bfs_sb.s_from: 0x{0:X8}", bfsSb.s_from);
-        AaruConsole.DebugWriteLine("BFS plugin", "bfs_sb.s_to: 0x{0:X8}", bfsSb.s_to);
-        AaruConsole.DebugWriteLine("BFS plugin", "bfs_sb.s_bfrom: 0x{0:X8}", bfsSb.s_bfrom);
-        AaruConsole.DebugWriteLine("BFS plugin", "bfs_sb.s_bto: 0x{0:X8}", bfsSb.s_bto);
-        AaruConsole.DebugWriteLine("BFS plugin", "bfs_sb.s_fsname: 0x{0}", bfsSb.s_fsname);
-        AaruConsole.DebugWriteLine("BFS plugin", "bfs_sb.s_volume: 0x{0}", bfsSb.s_volume);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "bfs_sb.s_magic: 0x{0:X8}", bfsSb.s_magic);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "bfs_sb.s_start: 0x{0:X8}", bfsSb.s_start);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "bfs_sb.s_end: 0x{0:X8}", bfsSb.s_end);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "bfs_sb.s_from: 0x{0:X8}", bfsSb.s_from);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "bfs_sb.s_to: 0x{0:X8}", bfsSb.s_to);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "bfs_sb.s_bfrom: 0x{0:X8}", bfsSb.s_bfrom);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "bfs_sb.s_bto: 0x{0:X8}", bfsSb.s_bto);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "bfs_sb.s_fsname: 0x{0}", bfsSb.s_fsname);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "bfs_sb.s_volume: 0x{0}", bfsSb.s_volume);
 
         sb.AppendLine(Localization.UNIX_Boot_Filesystem);
 

Aaru.Filesystems/UNIXBFS/UNIXBFS.cs

@@ -42,4 +42,5 @@ public sealed partial class BFS : IFilesystem
     public Guid Id => new("1E6E0DA6-F7E4-494C-80C6-CB5929E96155");
     /// <inheritdoc />
     public string Author => Authors.NataliaPortillo;
+    const string MODULE_NAME = "BFS plugin";
 }

Aaru.Filesystems/XFS/Info.cs

@@ -74,7 +74,7 @@ public sealed partial class XFS
 
                 Superblock xfsSb = Marshal.ByteArrayToStructureBigEndian<Superblock>(sbpiece);
 
-                AaruConsole.DebugWriteLine("XFS plugin", Localization.magic_at_0_X3_equals_1_expected_2, location,
+                AaruConsole.DebugWriteLine(MODULE_NAME, Localization.magic_at_0_X3_equals_1_expected_2, location,
                                            xfsSb.magicnum, XFS_MAGIC);
 
                 if(xfsSb.magicnum == XFS_MAGIC)
@@ -104,7 +104,7 @@ public sealed partial class XFS
 
                 Superblock xfsSb = Marshal.ByteArrayToStructureBigEndian<Superblock>(sector);
 
-                AaruConsole.DebugWriteLine("XFS plugin", Localization.magic_at_0_equals_1_expected_2, location,
+                AaruConsole.DebugWriteLine(MODULE_NAME, Localization.magic_at_0_equals_1_expected_2, location,
                                            xfsSb.magicnum, XFS_MAGIC);
 
                 if(xfsSb.magicnum == XFS_MAGIC)
@@ -152,7 +152,7 @@ public sealed partial class XFS
 
                 xfsSb = Marshal.ByteArrayToStructureBigEndian<Superblock>(sbpiece);
 
-                AaruConsole.DebugWriteLine("XFS plugin", Localization.magic_at_0_X3_equals_1_expected_2, location,
+                AaruConsole.DebugWriteLine(MODULE_NAME, Localization.magic_at_0_X3_equals_1_expected_2, location,
                                            xfsSb.magicnum, XFS_MAGIC);
 
                 if(xfsSb.magicnum == XFS_MAGIC)
@@ -179,7 +179,7 @@ public sealed partial class XFS
 
                 xfsSb = Marshal.ByteArrayToStructureBigEndian<Superblock>(sector);
 
-                AaruConsole.DebugWriteLine("XFS plugin", Localization.magic_at_0_equals_1_expected_2, location,
+                AaruConsole.DebugWriteLine(MODULE_NAME, Localization.magic_at_0_equals_1_expected_2, location,
                                            xfsSb.magicnum, XFS_MAGIC);
 
                 if(xfsSb.magicnum == XFS_MAGIC)

Aaru.Filesystems/XFS/XFS.cs

@@ -41,4 +41,5 @@ public sealed partial class XFS : IFilesystem
     public Guid Id => new("1D8CD8B8-27E6-410F-9973-D16409225FBA");
     /// <inheritdoc />
     public string Author => Authors.NataliaPortillo;
+    const string MODULE_NAME = "XFS plugin";
 }

Aaru.Filesystems/dump/Info.cs

@@ -74,9 +74,9 @@ public sealed partial class dump
         spcl_aix aixHdr = Marshal.ByteArrayToStructureLittleEndian<spcl_aix>(sector);
         s_spcl   newHdr = Marshal.ByteArrayToStructureLittleEndian<s_spcl>(sector);
 
-        AaruConsole.DebugWriteLine("dump(8) plugin", "old magic = 0x{0:X8}", oldHdr.c_magic);
-        AaruConsole.DebugWriteLine("dump(8) plugin", "aix magic = 0x{0:X8}", aixHdr.c_magic);
-        AaruConsole.DebugWriteLine("dump(8) plugin", "new magic = 0x{0:X8}", newHdr.c_magic);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "old magic = 0x{0:X8}", oldHdr.c_magic);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "aix magic = 0x{0:X8}", aixHdr.c_magic);
+        AaruConsole.DebugWriteLine(MODULE_NAME, "new magic = 0x{0:X8}", newHdr.c_magic);
 
         return oldHdr.c_magic == OFS_MAGIC || aixHdr.c_magic is XIX_MAGIC or XIX_CIGAM || newHdr.c_magic == OFS_MAGIC ||
                newHdr.c_magic == NFS_MAGIC || newHdr.c_magic == OFS_CIGAM || newHdr.c_magic == NFS_CIGAM ||

Aaru.Filesystems/dump/dump.cs

@@ -48,4 +48,5 @@ public sealed partial class dump : IFilesystem
     public Guid Id => new("E53B4D28-C858-4800-B092-DDAE80D361B9");
     /// <inheritdoc />
     public string Author => Authors.NataliaPortillo;
+    const string MODULE_NAME = "dump(8) plugin";
 }