nError -> dwErrCode

1 files changed, 73 insertions, 73 deletions

diff --git a/src/SFileReadFile.cpp b/src/SFileReadFile.cpp
index 192d212..34edc06 100644
--- a/src/SFileReadFile.cpp
+++ b/src/SFileReadFile.cpp
@@ -21,7 +21,7 @@
 //  dwByteOffset  - Position of sector in the file (relative to file begin)
 //  dwBytesToRead - Number of bytes to read. Must be multiplier of sector size.
 //  pdwBytesRead  - Stored number of bytes loaded
-static int ReadMpqSectors(TMPQFile * hf, LPBYTE pbBuffer, DWORD dwByteOffset, DWORD dwBytesToRead, LPDWORD pdwBytesRead)
+static DWORD ReadMpqSectors(TMPQFile * hf, LPBYTE pbBuffer, DWORD dwByteOffset, DWORD dwBytesToRead, LPDWORD pdwBytesRead)
 {
     ULONGLONG RawFilePos;
     TMPQArchive * ha = hf->ha;
@@ -35,7 +35,7 @@ static int ReadMpqSectors(TMPQFile * hf, LPBYTE pbBuffer, DWORD dwByteOffset, DW
     DWORD dwSectorIndex = dwByteOffset / ha->dwSectorSize;
     DWORD dwSectorsDone = 0;
     DWORD dwBytesRead = 0;
-    int nError = ERROR_SUCCESS;
+    DWORD dwErrCode = ERROR_SUCCESS;
 
     // Note that dwByteOffset must be aligned to size of one sector
     // Note that dwBytesToRead must be a multiplier of one sector size
@@ -53,9 +53,9 @@ static int ReadMpqSectors(TMPQFile * hf, LPBYTE pbBuffer, DWORD dwByteOffset, DW
         // If the sector positions are not loaded yet, do it
         if(hf->SectorOffsets == NULL)
         {
-            nError = AllocateSectorOffsets(hf, true);
-            if(nError != ERROR_SUCCESS || hf->SectorOffsets == NULL)
-                return nError;
+            dwErrCode = AllocateSectorOffsets(hf, true);
+            if(dwErrCode != ERROR_SUCCESS || hf->SectorOffsets == NULL)
+                return dwErrCode;
         }
 
         // If the sector checksums are not loaded yet, load them now.
@@ -76,9 +76,9 @@ static int ReadMpqSectors(TMPQFile * hf, LPBYTE pbBuffer, DWORD dwByteOffset, DW
         // Only do it if the MPQ is of format 4.0
 //      if(ha->pHeader->wFormatVersion >= MPQ_FORMAT_VERSION_4 && ha->pHeader->dwRawChunkSize != 0)
 //      {
-//          nError = AllocateRawMD5s(hf, true);
-//          if(nError != ERROR_SUCCESS)
-//              return nError;
+//          dwErrCode = AllocateRawMD5s(hf, true);
+//          if(dwErrCode != ERROR_SUCCESS)
+//              return dwErrCode;
 //      }
 
         // Assign the temporary buffer as target for read operation
@@ -126,7 +126,7 @@ static int ReadMpqSectors(TMPQFile * hf, LPBYTE pbBuffer, DWORD dwByteOffset, DW
                     hf->dwFileKey = DetectFileKeyByContent(pbInSector, dwBytesInThisSector, hf->dwDataSize);
                     if(hf->dwFileKey == 0)
                     {
-                        nError = ERROR_UNKNOWN_FILE_KEY;
+                        dwErrCode = ERROR_UNKNOWN_FILE_KEY;
                         break;
                     }
                 }
@@ -148,7 +148,7 @@ static int ReadMpqSectors(TMPQFile * hf, LPBYTE pbBuffer, DWORD dwByteOffset, DW
                     dwAdlerValue = adler32(0, pbInSector, dwRawBytesInThisSector);
                     if(dwAdlerValue != dwAdlerExpected)
                     {
-                        nError = ERROR_CHECKSUM_ERROR;
+                        dwErrCode = ERROR_CHECKSUM_ERROR;
                         break;
                     }
                 }
@@ -185,7 +185,7 @@ static int ReadMpqSectors(TMPQFile * hf, LPBYTE pbBuffer, DWORD dwByteOffset, DW
                 // Did the decompression fail ?
                 if(nResult == 0)
                 {
-                    nError = ERROR_FILE_CORRUPT;
+                    dwErrCode = ERROR_FILE_CORRUPT;
                     break;
                 }
             }
@@ -206,7 +206,7 @@ static int ReadMpqSectors(TMPQFile * hf, LPBYTE pbBuffer, DWORD dwByteOffset, DW
     }
     else
     {
-        nError = GetLastError();
+        dwErrCode = GetLastError();
     }
 
     // Free all used buffers
@@ -215,24 +215,24 @@ static int ReadMpqSectors(TMPQFile * hf, LPBYTE pbBuffer, DWORD dwByteOffset, DW
 
     // Give the caller thenumber of bytes read
     *pdwBytesRead = dwBytesRead;
-    return nError;
+    return dwErrCode;
 }
 
-static int ReadMpqFileSingleUnit(TMPQFile * hf, void * pvBuffer, DWORD dwFilePos, DWORD dwToRead, LPDWORD pdwBytesRead)
+static DWORD ReadMpqFileSingleUnit(TMPQFile * hf, void * pvBuffer, DWORD dwFilePos, DWORD dwToRead, LPDWORD pdwBytesRead)
 {
     ULONGLONG RawFilePos = hf->RawFilePos;
     TMPQArchive * ha = hf->ha;
     TFileEntry * pFileEntry = hf->pFileEntry;
     LPBYTE pbCompressed = NULL;
     LPBYTE pbRawData;
-    int nError = ERROR_SUCCESS;
+    DWORD dwErrCode = ERROR_SUCCESS;
 
     // If the file buffer is not allocated yet, do it.
     if(hf->pbFileSector == NULL)
     {
-        nError = AllocateSectorBuffer(hf);
-        if(nError != ERROR_SUCCESS || hf->pbFileSector == NULL)
-            return nError;
+        dwErrCode = AllocateSectorBuffer(hf);
+        if(dwErrCode != ERROR_SUCCESS || hf->pbFileSector == NULL)
+            return dwErrCode;
     }
 
     // If the file is a patch file, adjust raw data offset
@@ -308,7 +308,7 @@ static int ReadMpqFileSingleUnit(TMPQFile * hf, void * pvBuffer, DWORD dwFilePos
             else if(pFileEntry->dwFlags & MPQ_FILE_IMPLODE)
                 nResult = SCompExplode(hf->pbFileSector, &cbOutBuffer, pbRawData, cbInBuffer);
 
-            nError = (nResult != 0) ? ERROR_SUCCESS : ERROR_FILE_CORRUPT;
+            dwErrCode = (nResult != 0) ? ERROR_SUCCESS : ERROR_FILE_CORRUPT;
         }
         else
         {
@@ -326,7 +326,7 @@ static int ReadMpqFileSingleUnit(TMPQFile * hf, void * pvBuffer, DWORD dwFilePos
 
     // At this moment, we have the file loaded into the file buffer.
     // Copy as much as the caller wants
-    if(nError == ERROR_SUCCESS && hf->dwSectorOffs == 0)
+    if(dwErrCode == ERROR_SUCCESS && hf->dwSectorOffs == 0)
     {
         // File position is greater or equal to file size ?
         if(dwFilePos >= hf->dwDataSize)
@@ -347,17 +347,17 @@ static int ReadMpqFileSingleUnit(TMPQFile * hf, void * pvBuffer, DWORD dwFilePos
     }
 
     // An error, sorry
-    return nError;
+    return dwErrCode;
 }
 
-static int ReadMpkFileSingleUnit(TMPQFile * hf, void * pvBuffer, DWORD dwFilePos, DWORD dwToRead, LPDWORD pdwBytesRead)
+static DWORD ReadMpkFileSingleUnit(TMPQFile * hf, void * pvBuffer, DWORD dwFilePos, DWORD dwToRead, LPDWORD pdwBytesRead)
 {
     ULONGLONG RawFilePos = hf->RawFilePos + 0x0C;   // For some reason, MPK files start at position (hf->RawFilePos + 0x0C)
     TMPQArchive * ha = hf->ha;
     TFileEntry * pFileEntry = hf->pFileEntry;
     LPBYTE pbCompressed = NULL;
     LPBYTE pbRawData = hf->pbFileSector;
-    int nError = ERROR_SUCCESS;
+    DWORD dwErrCode = ERROR_SUCCESS;
 
     // We do not support patch files in MPK archives
     assert(hf->pPatchInfo == NULL);
@@ -365,9 +365,9 @@ static int ReadMpkFileSingleUnit(TMPQFile * hf, void * pvBuffer, DWORD dwFilePos
     // If the file buffer is not allocated yet, do it.
     if(hf->pbFileSector == NULL)
     {
-        nError = AllocateSectorBuffer(hf);
-        if(nError != ERROR_SUCCESS || hf->pbFileSector == NULL)
-            return nError;
+        dwErrCode = AllocateSectorBuffer(hf);
+        if(dwErrCode != ERROR_SUCCESS || hf->pbFileSector == NULL)
+            return dwErrCode;
         pbRawData = hf->pbFileSector;
     }
 
@@ -404,7 +404,7 @@ static int ReadMpkFileSingleUnit(TMPQFile * hf, void * pvBuffer, DWORD dwFilePos
 
             hf->dwCompression0 = pbRawData[0];
             if(!SCompDecompressMpk(hf->pbFileSector, &cbOutBuffer, pbRawData, (int)pFileEntry->dwCmpSize))
-                nError = ERROR_FILE_CORRUPT;
+                dwErrCode = ERROR_FILE_CORRUPT;
         }
         else
         {
@@ -422,7 +422,7 @@ static int ReadMpkFileSingleUnit(TMPQFile * hf, void * pvBuffer, DWORD dwFilePos
 
     // At this moment, we have the file loaded into the file buffer.
     // Copy as much as the caller wants
-    if(nError == ERROR_SUCCESS && hf->dwSectorOffs == 0)
+    if(dwErrCode == ERROR_SUCCESS && hf->dwSectorOffs == 0)
     {
         // File position is greater or equal to file size ?
         if(dwFilePos >= hf->dwDataSize)
@@ -448,7 +448,7 @@ static int ReadMpkFileSingleUnit(TMPQFile * hf, void * pvBuffer, DWORD dwFilePos
 }
 
 
-static int ReadMpqFileSectorFile(TMPQFile * hf, void * pvBuffer, DWORD dwFilePos, DWORD dwBytesToRead, LPDWORD pdwBytesRead)
+static DWORD ReadMpqFileSectorFile(TMPQFile * hf, void * pvBuffer, DWORD dwFilePos, DWORD dwBytesToRead, LPDWORD pdwBytesRead)
 {
     TMPQArchive * ha = hf->ha;
     LPBYTE pbBuffer = (BYTE *)pvBuffer;
@@ -456,7 +456,7 @@ static int ReadMpqFileSectorFile(TMPQFile * hf, void * pvBuffer, DWORD dwFilePos
     DWORD dwSectorSizeMask = ha->dwSectorSize - 1;      // Mask for block size, usually 0x0FFF
     DWORD dwFileSectorPos;                              // File offset of the loaded sector
     DWORD dwBytesRead;                                  // Number of bytes read (temporary variable)
-    int nError;
+    DWORD dwErrCode;
 
     // If the file position is at or beyond end of file, do nothing
     if(dwFilePos >= hf->dwDataSize)
@@ -475,9 +475,9 @@ static int ReadMpqFileSectorFile(TMPQFile * hf, void * pvBuffer, DWORD dwFilePos
     // If the file sector buffer is not allocated yet, do it now
     if(hf->pbFileSector == NULL)
     {
-        nError = AllocateSectorBuffer(hf);
-        if(nError != ERROR_SUCCESS || hf->pbFileSector == NULL)
-            return nError;
+        dwErrCode = AllocateSectorBuffer(hf);
+        if(dwErrCode != ERROR_SUCCESS || hf->pbFileSector == NULL)
+            return dwErrCode;
     }
 
     // Load the first (incomplete) file sector
@@ -491,9 +491,9 @@ static int ReadMpqFileSectorFile(TMPQFile * hf, void * pvBuffer, DWORD dwFilePos
         if(hf->dwSectorOffs != dwFileSectorPos)
         {
             // Load one MPQ sector into archive buffer
-            nError = ReadMpqSectors(hf, hf->pbFileSector, dwFileSectorPos, ha->dwSectorSize, &dwBytesInSector);
-            if(nError != ERROR_SUCCESS)
-                return nError;
+            dwErrCode = ReadMpqSectors(hf, hf->pbFileSector, dwFileSectorPos, ha->dwSectorSize, &dwBytesInSector);
+            if(dwErrCode != ERROR_SUCCESS)
+                return dwErrCode;
 
             // Remember that the data loaded to the sector have new file offset
             hf->dwSectorOffs = dwFileSectorPos;
@@ -525,9 +525,9 @@ static int ReadMpqFileSectorFile(TMPQFile * hf, void * pvBuffer, DWORD dwFilePos
         DWORD dwBlockBytes = dwBytesToRead & ~dwSectorSizeMask;
 
         // Load all sectors to the output buffer
-        nError = ReadMpqSectors(hf, pbBuffer, dwFileSectorPos, dwBlockBytes, &dwBytesRead);
-        if(nError != ERROR_SUCCESS)
-            return nError;
+        dwErrCode = ReadMpqSectors(hf, pbBuffer, dwFileSectorPos, dwBlockBytes, &dwBytesRead);
+        if(dwErrCode != ERROR_SUCCESS)
+            return dwErrCode;
 
         // Update pointers
         dwTotalBytesRead += dwBytesRead;
@@ -545,9 +545,9 @@ static int ReadMpqFileSectorFile(TMPQFile * hf, void * pvBuffer, DWORD dwFilePos
         if(hf->dwSectorOffs != dwFileSectorPos)
         {
             // Load one MPQ sector into archive buffer
-            nError = ReadMpqSectors(hf, hf->pbFileSector, dwFileSectorPos, ha->dwSectorSize, &dwBytesRead);
-            if(nError != ERROR_SUCCESS)
-                return nError;
+            dwErrCode = ReadMpqSectors(hf, hf->pbFileSector, dwFileSectorPos, ha->dwSectorSize, &dwBytesRead);
+            if(dwErrCode != ERROR_SUCCESS)
+                return dwErrCode;
 
             // Remember that the data loaded to the sector have new file offset
             hf->dwSectorOffs = dwFileSectorPos;
@@ -569,33 +569,33 @@ static int ReadMpqFileSectorFile(TMPQFile * hf, void * pvBuffer, DWORD dwFilePos
     return ERROR_SUCCESS;
 }
 
-static int ReadMpqFilePatchFile(TMPQFile * hf, void * pvBuffer, DWORD dwFilePos, DWORD dwToRead, LPDWORD pdwBytesRead)
+static DWORD ReadMpqFilePatchFile(TMPQFile * hf, void * pvBuffer, DWORD dwFilePos, DWORD dwToRead, LPDWORD pdwBytesRead)
 {
     TMPQPatcher Patcher;
     DWORD dwBytesToRead = dwToRead;
     DWORD dwBytesRead = 0;
-    int nError = ERROR_SUCCESS;
+    DWORD dwErrCode = ERROR_SUCCESS;
 
     // Make sure that the patch file is loaded completely
-    if(nError == ERROR_SUCCESS && hf->pbFileData == NULL)
+    if(dwErrCode == ERROR_SUCCESS && hf->pbFileData == NULL)
     {
         // Initialize patching process and allocate data
-        nError = Patch_InitPatcher(&Patcher, hf);
-        if(nError != ERROR_SUCCESS)
-            return nError;
+        dwErrCode = Patch_InitPatcher(&Patcher, hf);
+        if(dwErrCode != ERROR_SUCCESS)
+            return dwErrCode;
 
         // Set the current data size
         Patcher.cbFileData = hf->pFileEntry->dwFileSize;
 
         // Initialize the patcher object with initial file data
         if(hf->pFileEntry->dwFlags & MPQ_FILE_SINGLE_UNIT)
-            nError = ReadMpqFileSingleUnit(hf, Patcher.pbFileData1, 0, Patcher.cbFileData, &dwBytesRead);
+            dwErrCode = ReadMpqFileSingleUnit(hf, Patcher.pbFileData1, 0, Patcher.cbFileData, &dwBytesRead);
         else
-            nError = ReadMpqFileSectorFile(hf, Patcher.pbFileData1, 0, Patcher.cbFileData, &dwBytesRead);
+            dwErrCode = ReadMpqFileSectorFile(hf, Patcher.pbFileData1, 0, Patcher.cbFileData, &dwBytesRead);
 
         // Perform the patching process
-        if(nError == ERROR_SUCCESS)
-            nError = Patch_Process(&Patcher, hf);
+        if(dwErrCode == ERROR_SUCCESS)
+            dwErrCode = Patch_Process(&Patcher, hf);
 
         // Finalize the patcher structure
         Patch_Finalize(&Patcher);
@@ -603,7 +603,7 @@ static int ReadMpqFilePatchFile(TMPQFile * hf, void * pvBuffer, DWORD dwFilePos,
     }
 
     // If there is something to read, do it
-    if(nError == ERROR_SUCCESS)
+    if(dwErrCode == ERROR_SUCCESS)
     {
         if(dwFilePos < hf->cbFileData)
         {
@@ -617,21 +617,21 @@ static int ReadMpqFilePatchFile(TMPQFile * hf, void * pvBuffer, DWORD dwFilePos,
         }
 
         // Set the proper error code
-        nError = (dwBytesRead == dwBytesToRead) ? ERROR_SUCCESS : ERROR_HANDLE_EOF;
+        dwErrCode = (dwBytesRead == dwBytesToRead) ? ERROR_SUCCESS : ERROR_HANDLE_EOF;
     }
 
     // Give the result to the caller
     if(pdwBytesRead != NULL)
         *pdwBytesRead = dwBytesRead;
-    return nError;
+    return dwErrCode;
 }
 
-static int ReadMpqFileLocalFile(TMPQFile * hf, void * pvBuffer, DWORD dwFilePos, DWORD dwToRead, LPDWORD pdwBytesRead)
+static DWORD ReadMpqFileLocalFile(TMPQFile * hf, void * pvBuffer, DWORD dwFilePos, DWORD dwToRead, LPDWORD pdwBytesRead)
 {
     ULONGLONG FilePosition1 = dwFilePos;
     ULONGLONG FilePosition2;
     DWORD dwBytesRead = 0;
-    int nError = ERROR_SUCCESS;
+    DWORD dwErrCode = ERROR_SUCCESS;
 
     assert(hf->pStream != NULL);
 
@@ -643,7 +643,7 @@ static int ReadMpqFileLocalFile(TMPQFile * hf, void * pvBuffer, DWORD dwFilePos,
     if(!FileStream_Read(hf->pStream, &FilePosition1, pvBuffer, dwToRead))
     {
         // If not all bytes have been read, then return the number of bytes read
-        if((nError = GetLastError()) == ERROR_HANDLE_EOF)
+        if((dwErrCode = GetLastError()) == ERROR_HANDLE_EOF)
         {
             FileStream_GetPos(hf->pStream, &FilePosition2);
             dwBytesRead = (DWORD)(FilePosition2 - FilePosition1);
@@ -655,7 +655,7 @@ static int ReadMpqFileLocalFile(TMPQFile * hf, void * pvBuffer, DWORD dwFilePos,
     }
 
     *pdwBytesRead = dwBytesRead;
-    return nError;
+    return dwErrCode;
 }
 
 //-----------------------------------------------------------------------------
@@ -665,7 +665,7 @@ bool WINAPI SFileReadFile(HANDLE hFile, void * pvBuffer, DWORD dwToRead, LPDWORD
 {
     TMPQFile * hf = (TMPQFile *)hFile;
     DWORD dwBytesRead = 0;                      // Number of bytes read
-    int nError = ERROR_SUCCESS;
+    DWORD dwErrCode = ERROR_SUCCESS;
 
     // Always zero the result
     if(pdwRead != NULL)
@@ -688,10 +688,10 @@ bool WINAPI SFileReadFile(HANDLE hFile, void * pvBuffer, DWORD dwToRead, LPDWORD
     // If we didn't load the patch info yet, do it now
     if(hf->pFileEntry != NULL && (hf->pFileEntry->dwFlags & MPQ_FILE_PATCH_FILE) && hf->pPatchInfo == NULL)
     {
-        nError = AllocatePatchInfo(hf, true);
-        if(nError != ERROR_SUCCESS || hf->pPatchInfo == NULL)
+        dwErrCode = AllocatePatchInfo(hf, true);
+        if(dwErrCode != ERROR_SUCCESS || hf->pPatchInfo == NULL)
         {
-            SetLastError(nError);
+            SetLastError(dwErrCode);
             return false;
         }
     }
@@ -702,31 +702,31 @@ bool WINAPI SFileReadFile(HANDLE hFile, void * pvBuffer, DWORD dwToRead, LPDWORD
     // If the file is local file, read the data directly from the stream
     if(hf->pStream != NULL)
     {
-        nError = ReadMpqFileLocalFile(hf, pvBuffer, hf->dwFilePos, dwToRead, &dwBytesRead);
+        dwErrCode = ReadMpqFileLocalFile(hf, pvBuffer, hf->dwFilePos, dwToRead, &dwBytesRead);
     }
 
     // If the file is a patch file, we have to read it special way
     else if(hf->hfPatch != NULL && (hf->pFileEntry->dwFlags & MPQ_FILE_PATCH_FILE) == 0)
     {
-        nError = ReadMpqFilePatchFile(hf, pvBuffer, hf->dwFilePos, dwToRead, &dwBytesRead);
+        dwErrCode = ReadMpqFilePatchFile(hf, pvBuffer, hf->dwFilePos, dwToRead, &dwBytesRead);
     }
 
     // If the archive is a MPK archive, we need special way to read the file
     else if(hf->ha->dwSubType == MPQ_SUBTYPE_MPK)
     {
-        nError = ReadMpkFileSingleUnit(hf, pvBuffer, hf->dwFilePos, dwToRead, &dwBytesRead);
+        dwErrCode = ReadMpkFileSingleUnit(hf, pvBuffer, hf->dwFilePos, dwToRead, &dwBytesRead);
     }
 
     // If the file is single unit file, redirect it to read file
     else if(hf->pFileEntry->dwFlags & MPQ_FILE_SINGLE_UNIT)
     {
-        nError = ReadMpqFileSingleUnit(hf, pvBuffer, hf->dwFilePos, dwToRead, &dwBytesRead);
+        dwErrCode = ReadMpqFileSingleUnit(hf, pvBuffer, hf->dwFilePos, dwToRead, &dwBytesRead);
     }
 
     // Otherwise read it as sector based MPQ file
     else
     {
-        nError = ReadMpqFileSectorFile(hf, pvBuffer, hf->dwFilePos, dwToRead, &dwBytesRead);
+        dwErrCode = ReadMpqFileSectorFile(hf, pvBuffer, hf->dwFilePos, dwToRead, &dwBytesRead);
     }
 
     // Increment the file position
@@ -738,13 +738,13 @@ bool WINAPI SFileReadFile(HANDLE hFile, void * pvBuffer, DWORD dwToRead, LPDWORD
 
     // If the read operation succeeded, but not full number of bytes was read,
     // set the last error to ERROR_HANDLE_EOF
-    if(nError == ERROR_SUCCESS && (dwBytesRead < dwToRead))
-        nError = ERROR_HANDLE_EOF;
+    if(dwErrCode == ERROR_SUCCESS && (dwBytesRead < dwToRead))
+        dwErrCode = ERROR_HANDLE_EOF;
 
     // If something failed, set the last error value
-    if(nError != ERROR_SUCCESS)
-        SetLastError(nError);
-    return (nError == ERROR_SUCCESS);
+    if(dwErrCode != ERROR_SUCCESS)
+        SetLastError(dwErrCode);
+    return (dwErrCode == ERROR_SUCCESS);
 }
 
 //-----------------------------------------------------------------------------