#include "StdAfx.h"
|
#include "MBFile.h"
|
#include <algorithm>
|
#include <vector>
|
|
CMBFile::CMBFile(void)
|
{
|
}
|
|
CMBFile::~CMBFile(void)
|
{
|
}
|
|
const DWORD CMBFile::m_dwBufferSize = 1024;
|
|
// One possible apprach and why it was rejected:
|
// API function MultiByteToWideChar could of been used for UTF-8, but this
|
// means you either end up with two buffers (maybe doubling your memory usage)
|
// or you still have to do some pre-processing.
|
// Also, MultiByteToWideChar does not process non Windows line endings.
|
|
// The approach taken:
|
// After determining the file type, count how many bytes will be needed
|
// for the decoded file (this includes checking for non Windows
|
// line endings). Realloc to the new size and decode the file in place.
|
|
// This class will undergo another rewrite, where I will go more for
|
// readability over efficiency. I think at the moment it probably
|
// suffers from 'premature optimisation'..!
|
HLOCAL CMBFile::Load (CFile *pFile, e_FileType &eFileType,
|
e_FileFormat &eFileFormat, DWORD &dwNewSize)
|
{
|
DWORD dwSize = pFile->GetLength ();
|
HLOCAL hMem = 0;
|
HLOCAL hNewMem = 0;
|
unsigned char *pucText = 0;
|
|
if (eFileType == eAutoFileType)
|
{
|
// This function can throw an exception. It is caught by
|
// CNotepadreDoc::OnOpenDocument.
|
GetFileType (pFile, eFileType, dwSize);
|
}
|
else
|
{
|
// TODO: eFileType and eFileFormat are specified.
|
// Load as the specified type and format.
|
}
|
|
ASSERT (eFileType < eAutoFileType);
|
|
try
|
{
|
hMem = ::LocalAlloc (LMEM_MOVEABLE, dwSize + sizeof (TCHAR));
|
|
if (hMem == 0) AfxThrowMemoryException ();
|
|
pucText = static_cast<unsigned char *> (::LocalLock (hMem));
|
// Call memset so that the trailing zero is set
|
// and to make debugging the loader easier...
|
::memset (pucText, 0, dwSize + sizeof (TCHAR));
|
Read (pFile, pucText, dwSize);
|
dwNewSize = CountBytes (pucText, dwSize, eFileType, eFileFormat);
|
::LocalUnlock (hMem);
|
// realloc to account for any lines that have UNIX or
|
// Macintosh end of line characters
|
hNewMem = ::LocalReAlloc (hMem, dwNewSize + sizeof (TCHAR),
|
LMEM_MOVEABLE);
|
|
if (hNewMem == 0)
|
{
|
// LocalReAlloc failed, so attempt to re-load
|
::LocalFree (hMem);
|
hMem = 0;
|
hNewMem = ::LocalAlloc (LMEM_MOVEABLE, dwNewSize + sizeof (TCHAR));
|
|
if (hNewMem == 0) AfxThrowMemoryException ();
|
|
pucText = static_cast<unsigned char *> (::LocalLock (hNewMem));
|
::memset (pucText, 0, dwNewSize + sizeof (TCHAR));
|
|
if (eFileType == eANSI)
|
pFile->SeekToBegin ();
|
else if (eFileType != eUTF8)
|
pFile->Seek (2, CFile::begin);
|
|
if (eFileType != eUTF8)
|
{
|
// Use original size (file size has not changed!)
|
Read (pFile, pucText, dwSize);
|
}
|
}
|
else
|
{
|
hMem = 0;
|
pucText = static_cast<unsigned char *> (::LocalLock (hNewMem));
|
|
if (dwNewSize > dwSize)
|
{
|
::memset (pucText + dwSize + sizeof (TCHAR), 0,
|
dwNewSize - dwSize);
|
}
|
}
|
}
|
catch (...)
|
{
|
::LocalFree (hMem);
|
hMem = 0;
|
::LocalFree (hNewMem);
|
hNewMem = 0;
|
// Pass exception on to CNotepadreDoc::OnOpenDocument
|
throw;
|
}
|
|
if (eFileType == eUTF8)
|
{
|
pFile->Seek (3, CFile::begin);
|
::memset (pucText, 0, dwNewSize + sizeof (TCHAR));
|
// TO DO: Decode the file in place (move it down the buffer and
|
// place decoded chars at the front of the buffer).
|
LoadUTF8File (pFile, eFileFormat,
|
reinterpret_cast<wchar_t *> (pucText), dwSize);
|
}
|
else
|
{
|
ExpandText (reinterpret_cast<TCHAR *>(pucText), dwSize,
|
dwNewSize / sizeof (TCHAR), eFileType, eFileFormat);
|
}
|
|
::LocalUnlock (hNewMem);
|
return hNewMem;
|
}
|
|
void CMBFile::Save (const TCHAR *pszText, const DWORD dwChars,
|
const e_FileType eFileType, const e_FileFormat eFileFormat, CFile *pFile)
|
{
|
DWORD dwCharCount = dwChars;
|
// Must be an even number greater than 3...
|
unsigned char ucBuffer[m_dwBufferSize];
|
DWORD dwSize = 0;
|
|
SaveHeader (pFile, eFileType);
|
|
while (dwCharCount)
|
{
|
FillBuffer (pszText, dwCharCount, eFileType, eFileFormat, ucBuffer,
|
m_dwBufferSize, dwSize);
|
// Write throws CFileException if it fails
|
pFile->Write (ucBuffer, dwSize);
|
}
|
}
|
|
// All file read operations come through here
|
void CMBFile::Read (CFile *pFile, unsigned char *pucText, const DWORD dwSize)
|
{
|
if (pFile->Read (pucText, dwSize) != dwSize)
|
{
|
AfxThrowArchiveException (CArchiveException::endOfFile);
|
}
|
}
|
|
void CMBFile::GetFileType (CFile *pFile, e_FileType &eFileType,
|
DWORD &dwSize)
|
{
|
// Default to ANSI
|
eFileType = eANSI;
|
dwSize = pFile->GetLength ();
|
|
if (dwSize > 1)
|
{
|
unsigned char ucHeader[2];
|
|
Read (pFile, ucHeader, 2);
|
|
// Check for Unicode
|
if (ucHeader[0] == 0xff && ucHeader[1] == 0xfe)
|
{
|
// A Unicode file must have an even number of bytes
|
if (dwSize % 2 == 0)
|
{
|
eFileType = eUnicode;
|
dwSize -= 2;
|
}
|
else
|
{
|
eFileType = eINVALID;
|
}
|
}
|
// Check for Unicode Big Endian
|
else if (ucHeader[0] == 0xfe && ucHeader[1] == 0xff)
|
{
|
// A Unicode (Big Endian) file must have an even number of bytes
|
if (dwSize % 2 == 0)
|
{
|
eFileType = eUnicodeBigEndian;
|
dwSize -= 2;
|
}
|
else
|
{
|
eFileType = eINVALID;
|
}
|
}
|
// Check for UTF-8
|
else if (ucHeader[0] == 0xef && ucHeader[1] == 0xbb)
|
{
|
// UTF-8 has a three char header
|
if (dwSize > 2)
|
{
|
Read (pFile, ucHeader, 1);
|
|
if (ucHeader[0] == 0xbf)
|
{
|
eFileType = eUTF8;
|
dwSize -= 3;
|
}
|
else
|
{
|
eFileType = eINVALID;
|
}
|
}
|
else
|
{
|
eFileType = eINVALID;
|
}
|
}
|
else
|
{
|
pFile->SeekToBegin ();
|
}
|
}
|
|
if (eFileType == eINVALID)
|
{
|
AfxThrowArchiveException (CArchiveException::badIndex);
|
}
|
|
#ifndef _UNICODE
|
if (eFileType != eANSI)
|
{
|
AfxThrowArchiveException (CArchiveException::badIndex);
|
}
|
#endif
|
}
|
DWORD CMBFile::CountBytes (unsigned char *pucText,
|
const DWORD dwSize, const e_FileType &eFileType, e_FileFormat &eFileFormat)
|
{
|
DWORD dwNewChars = 0;
|
const TCHAR *pszText = reinterpret_cast<const TCHAR *>(pucText);
|
unsigned __int64 ui64Windows = 0;
|
unsigned __int64 ui64UNIX = 0;
|
unsigned __int64 ui64Macintosh = 0;
|
std::vector<__int64> FormatVector;
|
|
// It is more efficient to process each file type separately
|
if (eFileType == eANSI)
|
{
|
dwNewChars = CountCharsANSI (pucText, dwSize, ui64Windows, ui64UNIX,
|
ui64Macintosh);
|
}
|
else if (eFileType == eUnicode)
|
{
|
dwNewChars = CountCharsUnicode (reinterpret_cast<const TCHAR *>
|
(pucText), dwSize / sizeof (TCHAR), ui64Windows, ui64UNIX,
|
ui64Macintosh);
|
}
|
else if (eFileType == eUnicodeBigEndian)
|
{
|
dwNewChars = CountCharsUnicodeBE (reinterpret_cast<TCHAR *>
|
(pucText), dwSize / sizeof (TCHAR), ui64Windows, ui64UNIX,
|
ui64Macintosh);
|
}
|
else
|
{
|
dwNewChars = CountCharsUTF8 (pucText, dwSize, ui64Windows, ui64UNIX,
|
ui64Macintosh);
|
}
|
|
if (eFileFormat == eAutoFileFormat)
|
{
|
FormatVector.push_back (ui64Windows);
|
FormatVector.push_back (ui64UNIX);
|
FormatVector.push_back (ui64Macintosh);
|
std::sort (FormatVector.begin (), FormatVector.end ());
|
|
if (FormatVector[2] == ui64Windows)
|
{
|
eFileFormat = CMBFile::eWindows;
|
}
|
else if (FormatVector[2] == ui64UNIX)
|
{
|
eFileFormat = CMBFile::eUNIX;
|
}
|
else if (FormatVector[2] == ui64Macintosh)
|
{
|
eFileFormat = CMBFile::eMacintosh;
|
}
|
}
|
|
return dwNewChars * sizeof (TCHAR);
|
}
|
|
DWORD CMBFile::CountCharsANSI (const unsigned char *pucText,
|
const DWORD dwChars, unsigned __int64 &ui64Windows,
|
unsigned __int64 &ui64UNIX, unsigned __int64 &ui64Macintosh)
|
{
|
DWORD dwCount = dwChars;
|
DWORD dwNewChars = 0;
|
|
while (dwCount)
|
{
|
if (*pucText == '\r')
|
{
|
if (*(pucText + 1) != '\n')
|
{
|
ui64Macintosh++;
|
dwNewChars++;
|
}
|
else
|
{
|
ui64Windows++;
|
}
|
}
|
else if (*pucText == '\n')
|
{
|
if (dwCount == dwChars || *(pucText - 1) != '\r')
|
{
|
ui64UNIX++;
|
dwNewChars++;
|
}
|
|
// In the case of Windows format \r\n has already been checked
|
}
|
|
pucText++;
|
dwNewChars++;
|
dwCount--;
|
}
|
|
return dwNewChars;
|
}
|
|
DWORD CMBFile::CountCharsUnicode (const TCHAR *pszText,
|
const DWORD dwChars, unsigned __int64 &ui64Windows,
|
unsigned __int64 &ui64UNIX, unsigned __int64 &ui64Macintosh)
|
{
|
DWORD dwCount = dwChars;
|
DWORD dwNewChars = 0;
|
|
while (dwCount)
|
{
|
if (*pszText == '\r')
|
{
|
if (*(pszText + 1) != '\n')
|
{
|
ui64Macintosh++;
|
dwNewChars++;
|
}
|
else
|
{
|
ui64Windows++;
|
}
|
}
|
else if (*pszText == '\n')
|
{
|
if (dwCount == dwChars || *(pszText - 1) != '\r')
|
{
|
ui64UNIX++;
|
dwNewChars++;
|
}
|
|
// In the case of Windows format \r\n has already been checked
|
}
|
|
pszText++;
|
dwNewChars++;
|
dwCount--;
|
}
|
|
return dwNewChars;
|
}
|
|
// Swap bytes at the same time for efficiencies sake
|
DWORD CMBFile::CountCharsUnicodeBE (TCHAR *pszText,
|
const DWORD dwChars, unsigned __int64 &ui64Windows,
|
unsigned __int64 &ui64UNIX, unsigned __int64 &ui64Macintosh)
|
{
|
DWORD dwCount = dwChars;
|
DWORD dwNewChars = 0;
|
|
while (dwCount)
|
{
|
// Flip wide char to little endian
|
*pszText = Swap (*pszText);
|
|
if (*pszText == '\r')
|
{
|
if (Swap (*(pszText + 1)) != '\n')
|
{
|
ui64Macintosh++;
|
dwNewChars++;
|
}
|
else
|
{
|
ui64Windows++;
|
}
|
}
|
else if (*pszText == '\n')
|
{
|
// *(pszText - 1) is already Swapped
|
if (dwCount == dwChars || *(pszText - 1) != '\r')
|
{
|
ui64UNIX++;
|
dwNewChars++;
|
}
|
|
// In the case of Windows format \r\n has already been checked
|
}
|
|
pszText++;
|
dwNewChars++;
|
dwCount--;
|
}
|
|
return dwNewChars;
|
}
|
|
DWORD CMBFile::CountCharsUTF8 (const unsigned char *pucText,
|
const DWORD dwChars, unsigned __int64 &ui64Windows,
|
unsigned __int64 &ui64UNIX, unsigned __int64 &ui64Macintosh)
|
{
|
DWORD dwCount = dwChars;
|
DWORD dwBytes = 0;
|
DWORD dwNewChars = 0;
|
wchar_t wcPrevChar = 0;
|
wchar_t wcChar = 0;
|
|
while (dwCount)
|
{
|
dwBytes = CheckUTF8Char (pucText, dwCount);
|
dwCount -= dwBytes;
|
|
if (dwBytes == 1)
|
{
|
// Only interested in '\r' and '\n'...
|
wcChar = *pucText;
|
}
|
else
|
{
|
// If > 1 char, we don't care about it.
|
wcChar = 0;
|
}
|
|
if (wcPrevChar == '\r')
|
{
|
if (wcChar != '\n')
|
{
|
ui64Macintosh++;
|
dwNewChars++;
|
}
|
else
|
{
|
ui64Windows++;
|
}
|
}
|
else if (wcChar == '\n')
|
{
|
if (wcPrevChar != '\r')
|
{
|
ui64UNIX++;
|
dwNewChars++;
|
}
|
|
// In the case of Windows format \r\n has already been checked
|
}
|
|
pucText += dwBytes;
|
wcPrevChar = wcChar;
|
dwNewChars++;
|
}
|
|
// Check if last character is \r
|
if (wcChar == '\r')
|
{
|
ui64Macintosh++;
|
dwNewChars++;
|
}
|
|
return dwNewChars;
|
}
|
|
inline wchar_t CMBFile::Swap (wchar_t wc)
|
{
|
char *pc = reinterpret_cast<char *> (&wc);
|
char c = *pc;
|
|
*pc++ = *(pc + 1);
|
*pc = c;
|
return wc;
|
}
|
|
// UTF-8 Format:
|
// 0000:0000 -> 0000:007f = 0xxxxxxx
|
// 0000:0080 -> 0000:07ff = 110xxxxx 10xxxxxx
|
// 0000:0800 -> 0000:ffff = 1110xxxx 10xxxxxx 10xxxxxx
|
|
// Counts how many bytes the next UTF-8 uses and returns them.
|
// Checks that there are no obvious data errors in the file
|
DWORD CMBFile::CheckUTF8Char (const unsigned char * pucBytes,
|
const DWORD dwCharsLeft)
|
{
|
DWORD dwBytes = 0;
|
unsigned char ucCountMask = 0x80;
|
|
while (*pucBytes & ucCountMask)
|
{
|
ucCountMask >>= 1;
|
dwBytes++;
|
}
|
|
if (dwBytes == 0)
|
{
|
dwBytes = 1;
|
}
|
else
|
{
|
int i = 0;
|
}
|
|
if (dwBytes > 3 || dwCharsLeft - dwBytes < 0)
|
{
|
// Only support 16 bit unicode, check for unexpected EOF
|
AfxThrowArchiveException (CArchiveException::badIndex);
|
}
|
|
for (DWORD dwIndex = 1; dwIndex < dwBytes; dwIndex++)
|
{
|
if ((pucBytes[dwIndex] & 0xc0) != 0x80)
|
{
|
// Data not as advertised
|
AfxThrowArchiveException (CArchiveException::badIndex);
|
}
|
}
|
|
return dwBytes;
|
}
|
|
DWORD CMBFile::DecodeUTF8Char (const unsigned char * &pucBytes,
|
wchar_t &wcChar)
|
{
|
DWORD dwBytes = 0;
|
unsigned char ucCountMask = 0x80;
|
unsigned char ucHighMask = 0x7f;
|
unsigned char ucBytes[2] = {0, 0};
|
|
while (*pucBytes & ucCountMask)
|
{
|
ucCountMask >>= 1;
|
ucHighMask >>= 1;
|
dwBytes++;
|
}
|
|
if (dwBytes == 0) dwBytes = 1;
|
|
if (dwBytes > 1)
|
{
|
unsigned char ucHighBits = *(pucBytes + dwBytes - 2) << 6;
|
|
ucBytes[0] = *(pucBytes + dwBytes - 1) & 0x3f;
|
ucBytes[0] |= ucHighBits;
|
|
if (dwBytes > 2)
|
{
|
ucBytes[1] = *(pucBytes + dwBytes - 2) & 0x3f;
|
ucBytes[1] >>= 2;
|
ucBytes[1] |= (*pucBytes & ucHighMask) << 4;
|
}
|
else
|
{
|
ucBytes[1] = (*pucBytes & ucHighMask) >> 2;
|
}
|
|
wcChar = *reinterpret_cast<wchar_t *> (ucBytes);
|
pucBytes += dwBytes;
|
}
|
else
|
{
|
wcChar = *pucBytes++;
|
}
|
|
return dwBytes;
|
}
|
|
void CMBFile::LoadUTF8File (CFile *pFile,
|
const e_FileFormat eFileFormat, wchar_t *pszText, const DWORD dwSize)
|
{
|
wchar_t wcPreviousChar = 0;
|
DWORD dwBytesLeft = dwSize;
|
// Must not be less than 3..!
|
unsigned char ucBuffer[m_dwBufferSize];
|
DWORD dwBufferIndex = 0;
|
DWORD dwBytesToLoad = 0;
|
|
while (dwBytesLeft)
|
{
|
dwBytesToLoad = dwBytesLeft > m_dwBufferSize ? m_dwBufferSize :
|
dwBytesLeft;
|
Read (pFile, ucBuffer, dwBytesToLoad);
|
dwBytesLeft -= dwBytesToLoad;
|
dwBufferIndex = 0;
|
|
while (dwBytesToLoad)
|
{
|
if (ucBuffer[dwBufferIndex] & 0x80)
|
{
|
unsigned char ucMask = 0x80;
|
DWORD dwBytes = 0;
|
unsigned char *puc = 0;
|
DWORD dwIndex = 0;
|
wchar_t wcChar = 0;
|
|
// File format has already been checked for validity
|
// so we don't need to check again.
|
while (ucBuffer[dwBufferIndex] & ucMask)
|
{
|
ucMask >>= 1;
|
dwBytes++;
|
}
|
|
if (dwBytes > dwBytesToLoad)
|
{
|
DWORD dwAdditional = dwBytesToLoad;
|
|
// Buffer over-run - reload buffer
|
memcpy (ucBuffer, &ucBuffer[dwBufferIndex], dwAdditional);
|
dwBytesToLoad = dwBytesLeft > m_dwBufferSize ?
|
m_dwBufferSize - dwAdditional : dwBytesLeft;
|
Read (pFile, &ucBuffer[dwAdditional], dwBytesToLoad);
|
dwBytesLeft -= dwBytesToLoad;
|
dwBytesToLoad += dwAdditional;
|
dwBufferIndex = 0;
|
}
|
|
puc = &ucBuffer[dwBufferIndex];
|
|
dwIndex = DecodeUTF8Char( (const unsigned char*&)puc, wcChar );
|
*pszText++ = wcChar;
|
dwBytesToLoad -= dwIndex;
|
dwBufferIndex += dwIndex;
|
}
|
else
|
{
|
// Because we are decoding a character at a time and the
|
// loading of the file is buffered, it is easier to
|
// keep track of the previous character.
|
if (wcPreviousChar == '\r' && ucBuffer[dwBufferIndex] != '\n')
|
{
|
*pszText++ = '\n';
|
}
|
// This means we are one character behind, so we have to check
|
// for the last character being \r outside of this loop.
|
else if (ucBuffer[dwBufferIndex] == '\n' && wcPreviousChar != '\r')
|
{
|
*pszText++ = '\r';
|
}
|
|
*pszText++ = ucBuffer[dwBufferIndex];
|
dwBufferIndex++;
|
dwBytesToLoad--;
|
}
|
|
wcPreviousChar = *(pszText - 1);
|
}
|
}
|
|
// Check for case of Macintosh format ending with \r
|
if (wcPreviousChar == '\r')
|
{
|
*pszText++ = '\n';
|
}
|
}
|
|
void CMBFile::ExpandText (TCHAR *pszText, const DWORD dwSize,
|
const DWORD dwChars, const e_FileType eFileType,
|
const e_FileFormat eFileFormat)
|
{
|
// It is more efficient to process each file type separately
|
if (eFileType == eANSI)
|
{
|
DWORD dwCharCount = dwChars;
|
// use a char * as the file is read as bytes regardless of build type
|
unsigned char *pszRead = (reinterpret_cast<unsigned char *>
|
(pszText)) + dwSize - 1;
|
// build dependant write pointer (TCHAR)
|
TCHAR *pszWrite = pszText + dwChars - 1;
|
|
// Read backwards so that writing out chars
|
// does not write over data yet to be read
|
while (dwCharCount)
|
{
|
if (*pszRead == '\r' && *(pszWrite + 1) != '\n')
|
{
|
*pszWrite-- = '\n';
|
dwCharCount--;
|
*pszWrite-- = *pszRead--;
|
}
|
// Check for running off the beginning of the buffer.
|
// In this case, dwCharCount will be 2.
|
else if (*pszRead == '\n' && (dwCharCount < 3 ||
|
*(pszRead - 1) != '\r'))
|
{
|
*pszWrite-- = *pszRead--;
|
*pszWrite-- = '\r';
|
dwCharCount--;
|
}
|
else
|
{
|
*pszWrite-- = *pszRead--;
|
}
|
|
dwCharCount--;
|
}
|
}
|
else if (eFileType == eUnicode || eFileType == eUnicodeBigEndian)
|
{
|
DWORD dwCharCount = dwChars;
|
TCHAR *pszRead = pszText + dwSize / sizeof (wchar_t) - 1;
|
TCHAR *pszWrite = pszText + dwChars - 1;
|
|
// Read backwards so that writing out chars
|
// does not write over data yet to be read
|
while (dwCharCount)
|
{
|
if (*pszRead == '\r' && *(pszWrite + 1) != '\n')
|
{
|
*pszWrite-- = '\n';
|
dwCharCount--;
|
*pszWrite-- = *pszRead--;
|
}
|
// Check for running off the beginning of the buffer.
|
// In this case, dwCharCount will be 2.
|
else if (*pszRead == '\n' && (dwCharCount < 3 ||
|
*(pszRead - 1) != '\r'))
|
{
|
*pszWrite-- = *pszRead--;
|
*pszWrite-- = '\r';
|
dwCharCount--;
|
}
|
else
|
{
|
*pszWrite-- = *pszRead--;
|
}
|
|
dwCharCount--;
|
}
|
}
|
else
|
{
|
ASSERT (0);
|
}
|
|
ZerosToSpaces (pszText, dwChars);
|
}
|
|
void CMBFile::ZerosToSpaces (TCHAR *pszText, const DWORD dwChars)
|
{
|
for (DWORD c = 0; c < dwChars; c++)
|
{
|
if (!*pszText) *pszText = ' ';
|
|
pszText++;
|
}
|
}
|
|
void CMBFile::SaveHeader (CFile *pFile, const e_FileType eFileType)
|
{
|
if (eFileType == eUnicode)
|
{
|
char szHeader[] = {(char) 0xff, (char) 0xfe};
|
|
// Write throws CFileException if it fails
|
pFile->Write (szHeader, 2);
|
}
|
else if (eFileType == eUnicodeBigEndian)
|
{
|
char szHeader[] = {(char) 0xfe, (char) 0xff};
|
|
// Write throws CFileException if it fails
|
pFile->Write (szHeader, 2);
|
}
|
else if (eFileType == eUTF8)
|
{
|
char szHeader[] = {(char) 0xef, (char) 0xbb, (char) 0xbf};
|
|
// Write throws CFileException if it fails
|
pFile->Write (szHeader, 3);
|
}
|
else if (eFileType != eANSI)
|
{
|
ASSERT (0);
|
}
|
}
|
|
void CMBFile::FillBuffer (const TCHAR * &pszText, DWORD &dwCharCount,
|
const e_FileType eFileType, const e_FileFormat eFileFormat,
|
unsigned char *ucBuffer, const DWORD dwBufferSize, DWORD &dwSize)
|
{
|
DWORD dwBufferIndex = 0;
|
|
dwSize = 0;
|
|
if (eFileType == eANSI)
|
{
|
#ifdef _UNICODE
|
while (dwCharCount && dwBufferIndex < dwBufferSize)
|
{
|
if (!(eFileFormat == eUNIX && *pszText == '\r') &&
|
!(eFileFormat == eMacintosh && *pszText == '\n'))
|
{
|
ucBuffer[dwBufferIndex++] =
|
*reinterpret_cast<const unsigned char *> (pszText);
|
dwSize++;
|
}
|
|
pszText++;
|
dwCharCount--;
|
}
|
#else
|
while (dwCharCount && dwBufferIndex < dwBufferSize)
|
{
|
if (!(eFileFormat == eUNIX && *pszText == '\r') &&
|
!(eFileFormat == eMacintosh && *pszText == '\n'))
|
{
|
ucBuffer[dwBufferIndex++] = *pszText;
|
dwSize++;
|
}
|
|
pszText++;
|
dwCharCount--;
|
}
|
#endif
|
}
|
else if (eFileType == eUnicode)
|
{
|
#ifdef _UNICODE
|
while (dwCharCount && dwBufferIndex < dwBufferSize)
|
{
|
if (!(eFileFormat == eUNIX && *pszText == '\r') &&
|
!(eFileFormat == eMacintosh && *pszText == '\n'))
|
{
|
ucBuffer[dwBufferIndex++] = LOBYTE (*pszText);
|
ucBuffer[dwBufferIndex++] = HIBYTE (*pszText);
|
dwSize += 2;
|
}
|
|
pszText++;
|
dwCharCount--;
|
}
|
#else
|
while (dwCharCount && dwBufferIndex < dwBufferSize)
|
{
|
if (!(eFileFormat == eUNIX && *pszText == '\r') &&
|
!(eFileFormat == eMacintosh && *pszText == '\n'))
|
{
|
ucBuffer[dwBufferIndex++] = *pszText;
|
ucBuffer[dwBufferIndex++] = 0;
|
dwSize += 2;
|
}
|
|
pszText++;
|
dwCharCount--;
|
}
|
#endif
|
}
|
else if (eFileType == eUnicodeBigEndian)
|
{
|
#ifdef _UNICODE
|
while (dwCharCount && dwBufferIndex < dwBufferSize)
|
{
|
if (!(eFileFormat == eUNIX && *pszText == '\r') &&
|
!(eFileFormat == eMacintosh && *pszText == '\n'))
|
{
|
ucBuffer[dwBufferIndex++] = HIBYTE (*pszText);
|
ucBuffer[dwBufferIndex++] = LOBYTE (*pszText);
|
dwSize += 2;
|
}
|
|
pszText++;
|
dwCharCount--;
|
}
|
#else
|
while (dwCharCount && dwBufferIndex < dwBufferSize)
|
{
|
if (!(eFileFormat == eUNIX && *pszText == '\r') &&
|
!(eFileFormat == eMacintosh && *pszText == '\n'))
|
{
|
ucBuffer[dwBufferIndex++] = 0;
|
ucBuffer[dwBufferIndex++] = *pszText;
|
dwSize += 2;
|
}
|
|
pszText++;
|
dwCharCount--;
|
}
|
#endif
|
}
|
else if (eFileType == eUTF8)
|
{
|
wchar_t wc = 0;
|
unsigned char ucHeader = 0;
|
unsigned char ucHigh = 0;
|
unsigned char ucLow = 0;
|
unsigned char ucHighBitsHigh = 0;
|
unsigned char ucHighBitsLow = 0;
|
|
while (dwCharCount && dwBufferIndex < dwBufferSize)
|
{
|
wc = *pszText;
|
|
if (wc > 0x7ff)
|
{
|
// break if buffer will over-run
|
if (dwBufferIndex > dwBufferSize - 3) break;
|
|
ucHeader = 0xe0;
|
ucHigh = HIBYTE (wc);
|
ucLow = LOBYTE (wc);
|
ucHighBitsHigh = ucHigh & 0xf0;
|
ucHighBitsLow = ucLow & 0xc0;
|
|
ucLow &= 0x3f;
|
ucLow |= 0x80;
|
ucHigh <<= 2;
|
ucHigh &= 0x3f;
|
ucHigh |= 0x80;
|
|
if (ucHighBitsLow & 0x80) ucHigh |= 2;
|
if (ucHighBitsLow & 0x40) ucHigh |= 1;
|
if (ucHighBitsHigh & 0x80) ucHeader |= 8;
|
if (ucHighBitsHigh & 0x40) ucHeader |= 4;
|
if (ucHighBitsHigh & 0x20) ucHeader |= 2;
|
if (ucHighBitsHigh & 0x10) ucHeader |= 1;
|
|
ucBuffer[dwBufferIndex++] = ucHeader;
|
ucBuffer[dwBufferIndex++] = ucHigh;
|
ucBuffer[dwBufferIndex++] = ucLow;
|
dwSize += 3;
|
}
|
else if (wc > 0x7f)
|
{
|
// break if buffer will over-run
|
if (dwBufferIndex > dwBufferSize - 2) break;
|
|
ucHigh = HIBYTE (wc);
|
ucLow = LOBYTE (wc);
|
ucHighBitsLow = ucLow & 0xc0;
|
|
ucLow &= 0x3f;
|
ucLow |= 0x80;
|
ucHigh <<= 2;
|
|
if (ucHighBitsLow & 0x80) ucHigh |= 2;
|
if (ucHighBitsLow & 0x40) ucHigh |= 1;
|
|
ucHigh |= 0xc0;
|
|
ucBuffer[dwBufferIndex++] = ucHigh;
|
ucBuffer[dwBufferIndex++] = ucLow;
|
dwSize += 2;
|
}
|
else if (!(eFileFormat == eUNIX && *pszText == '\r') &&
|
!(eFileFormat == eMacintosh && *pszText == '\n'))
|
{
|
ucBuffer[dwBufferIndex++] =
|
*reinterpret_cast<const char *> (pszText);
|
dwSize++;
|
}
|
|
pszText++;
|
dwCharCount--;
|
}
|
}
|
else
|
{
|
ASSERT (0);
|
}
|
}
|
