Changeset 1239


Ignore:
Timestamp:
9/30/2009 9:01:05 AM (5 years ago)
Author:
lowjoel
Message:

Got rid of the SectorSize? and ClusterSize? fields in the FatApi? class, replacing them with the values straight from the BootSector? field. For the rest of the protected fields, place them into properties to allow ABI compatibility.

Location:
trunk/eraser6/Eraser.Util.FileSystem
Files:
6 edited

Legend:

Unmodified
Added
Removed
  • trunk/eraser6/Eraser.Util.FileSystem/Fat12Api.cpp

    r1233 r1239  
    7979                throw gcnew ArgumentException(L"Invalid FAT cluster: cluster is marked bad."); 
    8080            else if (nextCluster >= 0xFF8) 
    81                 return result * ClusterSize; 
     81                return ClusterSizeToSize(result); 
    8282            else 
    8383                cluster = nextCluster; 
  • trunk/eraser6/Eraser.Util.FileSystem/Fat12Or16Api.cpp

    r1238 r1239  
    6666    long long Fat12Or16Api::ClusterToOffset(unsigned cluster) 
    6767    { 
    68         unsigned long long sector = BootSector->ReservedSectorCount +                           //Reserved area 
    69             BootSector->FatCount * BootSector->SectorsPerFat +                                  //FAT area 
    70             (BootSector->RootDirectoryEntryCount * sizeof(::FatDirectoryEntry) / SectorSize) +  //Root directory area 
    71             (static_cast<unsigned long long>(cluster) - 2) * (ClusterSize / SectorSize); 
     68        unsigned long long sector = BootSector->ReservedSectorCount +                       //Reserved area 
     69            BootSector->FatCount * BootSector->SectorsPerFat +                              //FAT area 
     70            (BootSector->RootDirectoryEntryCount * sizeof(::FatDirectoryEntry) /            //Root directory area 
     71                BootSector->BytesPerSector) + 
     72            (static_cast<unsigned long long>(cluster) - 2) * BootSector->SectorsPerCluster; 
    7273        return SectorToOffset(sector); 
    7374    } 
     
    111112            BootSector->ReservedSectorCount +                                                   //Reserved area 
    112113            BootSector->FatCount * BootSector->SectorsPerFat +                                  //FAT area 
    113             (BootSector->RootDirectoryEntryCount * sizeof(::FatDirectoryEntry) / SectorSize)    //Root directory area 
     114            (BootSector->RootDirectoryEntryCount * sizeof(::FatDirectoryEntry) /            //Root directory area 
     115                BootSector->BytesPerSector) 
    114116        ); 
    115         unsigned long long numberOfClusters = availableSectors / (ClusterSize / SectorSize); 
     117        unsigned long long numberOfClusters = availableSectors / BootSector->SectorsPerCluster; 
    116118 
    117119        return numberOfClusters <= 0xFF0; 
  • trunk/eraser6/Eraser.Util.FileSystem/Fat16Api.cpp

    r1227 r1239  
    7878                throw gcnew ArgumentException(L"Invalid FAT cluster: cluster is marked bad."); 
    7979            else if (fatPtr[cluster] >= 0xFFF8) 
    80                 return result * ClusterSize; 
     80                return ClusterSizeToSize(result); 
    8181            else 
    8282                cluster = fatPtr[cluster]; 
  • trunk/eraser6/Eraser.Util.FileSystem/Fat32Api.cpp

    r1238 r1239  
    6565        unsigned long long sector = BootSector->ReservedSectorCount +               //Reserved area 
    6666            BootSector->FatCount * BootSector->Fat32ParameterBlock.SectorsPerFat +  //FAT area 
    67             (static_cast<unsigned long long>(cluster) - 2) * (ClusterSize / SectorSize); 
     67            (static_cast<unsigned long long>(cluster) - 2) *  BootSector->SectorsPerCluster; 
    6868        return SectorToOffset(sector); 
    6969    } 
     
    105105                throw gcnew ArgumentException(L"Invalid FAT cluster: cluster is marked bad."); 
    106106            else if (fatPtr[cluster] >= 0x0FFFFFF8) 
    107                 return result * ClusterSize; 
     107                return ClusterSizeToSize(result); 
    108108            else 
    109109                cluster = fatPtr[cluster]; 
  • trunk/eraser6/Eraser.Util.FileSystem/FatApi.cpp

    r1238 r1239  
    3333    FatApi::FatApi(VolumeInfo^ info) 
    3434    { 
    35         SectorSize = info->SectorSize; 
    36         ClusterSize = info->ClusterSize; 
    37  
    3835        BootSector = new FatBootSector(); 
    3936        memset(BootSector, 0, sizeof(*BootSector)); 
     
    5552    FatApi::FatApi(VolumeInfo^ info, Stream^ stream) 
    5653    { 
    57         SectorSize = info->SectorSize; 
    58         ClusterSize = info->ClusterSize; 
    59  
    6054        BootSector = new FatBootSector(); 
    6155        memset(BootSector, 0, sizeof(*BootSector)); 
     
    8983    unsigned long long FatApi::SectorToOffset(unsigned long long sector) 
    9084    { 
    91         return sector * SectorSize; 
     85        return sector * BootSector->BytesPerSector; 
    9286    } 
    9387 
    9488    unsigned FatApi::SectorSizeToSize(unsigned size) 
    9589    { 
    96         return size * SectorSize; 
     90        return size * BootSector->BytesPerSector; 
    9791    } 
    9892 
    9993    unsigned FatApi::ClusterSizeToSize(unsigned size) 
    10094    { 
    101         return size * ClusterSize; 
     95        return size * (BootSector->BytesPerSector * BootSector->SectorsPerCluster); 
    10296    } 
    10397 
     
    109103        std::vector<char> result; 
    110104        result.reserve(FileSize(cluster)); 
    111         array<Byte>^ buffer = gcnew array<Byte>(ClusterSize); 
     105        array<Byte>^ buffer = gcnew array<Byte>(ClusterSizeToSize(1)); 
    112106 
    113107        do 
    114108        { 
    115109            VolumeStream->Seek(ClusterToOffset(cluster), SeekOrigin::Begin); 
    116             VolumeStream->Read(buffer, 0, ClusterSize); 
    117  
    118             result.insert(result.end(), ClusterSize, 0); 
    119             Marshal::Copy(buffer, 0, static_cast<IntPtr>(&result.back() - ClusterSize + 1), 
    120                 ClusterSize); 
     110            VolumeStream->Read(buffer, 0, buffer->Length); 
     111 
     112            result.insert(result.end(), buffer->Length, 0); 
     113            Marshal::Copy(buffer, 0, static_cast<IntPtr>(&result.back() - buffer->Length + 1), 
     114                buffer->Length); 
    121115        } 
    122116        while ((cluster = GetNextCluster(cluster)) != 0xFFFFFFFF); 
     
    133127                gcnew String(L"allocated file.")); 
    134128 
    135         array<Byte>^ buffer = gcnew array<Byte>(ClusterSize); 
    136         for (size_t i = 0; i < length; i += ClusterSize) 
     129        size_t clusterSize = ClusterSizeToSize(1); 
     130        array<Byte>^ buffer = gcnew array<Byte>(clusterSize); 
     131        for (size_t i = 0; i < length; i += clusterSize) 
    137132        { 
    138133            Marshal::Copy(static_cast<IntPtr>(reinterpret_cast<intptr_t>(static_cast<const char*>(data) + i)), 
    139                 buffer, 0, ClusterSize); 
     134                buffer, 0, clusterSize); 
    140135            VolumeStream->Seek(ClusterToOffset(cluster), SeekOrigin::Begin); 
    141             VolumeStream->Write(buffer, 0, ClusterSize); 
     136            VolumeStream->Write(buffer, 0, clusterSize); 
    142137            cluster = GetNextCluster(cluster); 
    143138        } 
  • trunk/eraser6/Eraser.Util.FileSystem/FatApi.h

    r1238 r1239  
    111111 
    112112    protected: 
    113         IO::Stream^ VolumeStream; 
    114  
    115         unsigned SectorSize;                 // Size of one sector, in bytes 
    116         unsigned ClusterSize;                // Size of one cluster, in bytes 
    117         FatBootSector* BootSector; 
    118         char* Fat; 
     113        /// The stream used to access the volume. 
     114        property IO::Stream^ VolumeStream 
     115        { 
     116            IO::Stream^ get() { return volumeStream; } 
     117        private: 
     118            void set(IO::Stream^ value) { volumeStream = value; } 
     119        } 
     120 
     121        property FatBootSector* BootSector 
     122        { 
     123            FatBootSector* get() { return bootSector; } 
     124        private: 
     125            void set(FatBootSector* value) { bootSector = value; } 
     126        } 
     127 
     128        property char* Fat 
     129        { 
     130            char* get() { return fat; } 
     131            void set(char* value) { fat = value; } 
     132        } 
     133 
     134    private: 
     135        IO::Stream^ volumeStream; 
     136        FatBootSector* bootSector; 
     137        char* fat; 
    119138    }; 
    120139 
     
    230249    protected: 
    231250        /// A pointer to the directory structure. 
    232         ::FatDirectory Directory; 
     251        property ::FatDirectory Directory 
     252        { 
     253            ::FatDirectory get() { return directory; } 
     254            void set(::FatDirectory value) { directory = value; } 
     255        } 
    233256 
    234257        /// The number of entries in the directory 
    235         size_t DirectorySize; 
     258        property size_t DirectorySize 
     259        { 
     260            size_t get() { return directorySize; } 
     261            void set(size_t value) { directorySize = value; } 
     262        } 
    236263 
    237264    private: 
    238265        /// The list of parsed entries in the folder. 
    239266        Collections::Generic::Dictionary<String^, FatDirectoryEntry^>^ Entries; 
     267 
     268        size_t directorySize; 
     269        ::FatDirectory directory; 
    240270    }; 
    241271 
Note: See TracChangeset for help on using the changeset viewer.