/*************************************************************************
* *
* CHARTAB.C *
* *
* Copyright (C) Microsoft Corporation 1990-1994 *
* All Rights reserved. *
* *
**************************************************************************
* *
* Module Intent *
* Character table indexing and retrieval. The reasons this module is *
* not put together with ansiusa are: *
* - Like stop words, this involves indexing and retrieval *
* - It is word breaker independent *
* *
**************************************************************************
* *
* Current Owner: Binh Nguyen *
* *
*************************************************************************/
#include <mvopsys.h>
#include <mem.h>
#include <memory.h>
#include <iterror.h>
#include <_mvutil.h>
#include <mvsearch.h>
#include "common.h"
#ifdef _DEBUG
static BYTE NEAR *s_aszModule = __FILE__; // Used by error return functions.
#endif
#define SLASH '/'
#define RETURN '\r'
#define NEWLINE '\n'
#define INBUF_SIZE 256 // Maximum buffer size to store a line
#define BYTE_MAX 256 // Maximum number of characters
#define LIGATURE_BYTES 3 // Number of bytes/ligature
/* External variables */
extern BYTE LigatureTable[];
extern CHARMAP DefaultCMap[];
/*************************************************************************
*
* API FUNCTIONS
* Those functions should be exported in a .DEF file
*************************************************************************/
PUBLIC LPV EXPORT_API FAR PASCAL MVCharTableLoad (HFPB, LSZ, PHRESULT);
PUBLIC LPV EXPORT_API FAR PASCAL MVCharTableGetDefault (PHRESULT);
PUBLIC VOID EXPORT_API FAR PASCAL MVCharTableDispose (LPVOID);
PUBLIC HRESULT EXPORT_API PASCAL FAR MVCharTableFileBuild (HFPB, LPVOID, LSZ);
PUBLIC LPV EXPORT_API FAR PASCAL MVCharTableIndexLoad(HFPB, LSZ, PHRESULT);
/*************************************************************************
*
* INTERNAL PRIVATE FUNCTIONS
* All of them should be declared near
*************************************************************************/
PRIVATE LPB NEAR PASCAL GetNumber (HFPB, LPB, LPB, int FAR *, WORD FAR *);
PRIVATE LPCHARTAB PASCAL NEAR CharTableCreate (int);
PRIVATE VOID PASCAL NEAR StripCRLF (LPB, WORD);
PRIVATE VOID PASCAL NEAR GetWord (LSZ FAR *, LST);
PUBLIC VOID PASCAL FAR FreeHandle2 (HANDLE hd)
{
if (hd) {
_GLOBALUNLOCK(hd);
_GLOBALFREE(hd);
}
}
/*************************************************************************
* @doc EXTERNAL API INDEX
*
* @func LPCHARTAB FAR PASCAL | MVCharTableLoad |
* Open an ASCII file and read in the description of the character
* tables. It then converts them into binary format ready to be used
* The format of the file is:
* Size // How many entries
* char class, normalized value, sorted value, mac display value
* ........
* char class, normalized value, sorted value, mac display value
* Comments are preceded by // and ignored until EOL
* A description of the ligature table, if any, is to followed the
* charmap table
*
* @parm HFPB | hfpbIn |
* Handle to system file or subfile; NULL if file is external.
*
* @parm LSZ | lszFilename |
* DOS filen containing the description of the tables
*
* @parm PHRESULT | phr |
* Error buffer
*
* @rdesc
* The function returns a pointer to the memory block containing
* tables, or NULL if failed. The error buffer will contain
* description for the cause of the failure
*
* @comm About ligature table, there are some assumptions:
* If there is no wcLigature, then the default table is used
* if (wcLigature == 0) no ligature should be used
* if wcLigature != 0, the author provides a ligature table.
*************************************************************************/
PUBLIC LPVOID EXPORT_API FAR PASCAL MVCharTableLoad (HFPB hfpbIn,
LSZ lszFilename, PHRESULT phr)
{
register WORD j; // Scratch index variable
register WORD i; // Scratch index variable
register LPB lpbBuf; // Pointer to input buffer
WORD cbRead; // How many bytes have read (left)
int wcTabEntries; // Number of table entries
int wTmp; // Scratch variable
HFPB hfpb; // Handle of char table file
BOOL fOpenedFile; // TRUE if we have to close the file
BYTE Buffer [INBUF_SIZE]; // Input buffer
LPCMAP lpCMap; // Pointer to character table entries
LPCHARTAB lpCharTab = NULL; // Pointer to general char table struct
int wcLigature;
LPB lpbChar; // Scratch pointer
/* Open subfile if necessary, (and system file if necessary) */
if ((fOpenedFile = FsTypeFromHfpb(hfpb = hfpbIn) != FS_SUBFILE) &&
(hfpb = (HANDLE)FileOpen
(hfpbIn, lszFilename, hfpbIn ? FS_SUBFILE : REGULAR_FILE,
READ, phr)) == 0)
{
SetErrCode (phr, E_FILENOTFOUND);
return NULL;
}
*phr = E_BADFORMAT;
/* Fill in the buffer */
if ((cbRead =
(WORD) FileRead(hfpb, lpbBuf = Buffer, INBUF_SIZE, phr)) == 0 ||
FAILED(*phr))
{
goto ErrorExit;
}
/* Get the table size */
lpbBuf = GetNumber (hfpb, Buffer, lpbBuf, &wcTabEntries, &cbRead);
if (wcTabEntries == 0 || wcTabEntries > BYTE_MAX) {
goto ErrorExit;
}
/* Allocate memory for the character table */
if ((lpCharTab = CharTableCreate (wcTabEntries)) == NULL)
{
SetErrCode (phr, E_OUTOFMEMORY);
if (fOpenedFile)
FileClose (hfpb);
return NULL;
}
lpCMap = (LPCMAP)lpCharTab->lpCMapTab;
lpCharTab->wcTabEntries = (WORD) wcTabEntries;
/* Now read in invidual char table entry */
for (i = (WORD) wcTabEntries; i > 0; i--, lpCMap++) {
if ((lpbBuf = GetNumber (hfpb, Buffer, lpbBuf, &wTmp,
&cbRead)) == NULL) {
/* Missing item */
goto ErrorExit;
}
lpCMap->Class = (WORD) wTmp;
if ((lpbBuf = GetNumber (hfpb, Buffer, lpbBuf, &wTmp,
&cbRead)) == NULL) {
/* Missing item */
goto ErrorExit;
}
lpCMap->SortOrder = (WORD) wTmp;
if ((lpbBuf = GetNumber (hfpb, Buffer, lpbBuf, &wTmp,
&cbRead)) == NULL) {
/* Missing item */
goto ErrorExit;
}
lpCMap->Norm = (BYTE)wTmp;
if ((lpbBuf = GetNumber (hfpb, Buffer, lpbBuf, &wTmp,
&cbRead)) == NULL) {
/* Missing item */
goto ErrorExit;
}
lpCMap->WinCaseSensitiveNorm = (BYTE)wTmp;
if ((lpbBuf = GetNumber (hfpb, Buffer, lpbBuf, &wTmp,
&cbRead)) == NULL) {
/* Missing item */
goto ErrorExit;
}
lpCMap->MacDisplay = (BYTE)wTmp;
if ((lpbBuf = GetNumber (hfpb, Buffer, lpbBuf, &wTmp,
&cbRead)) == NULL) {
/* Missing item */
goto ErrorExit;
}
lpCMap->MacCaseSensitiveNorm = (BYTE)wTmp;
}
/*
* Check for valid table, ie. all reserved characters should not
* be modified
*/
/* Check for valid reserved type */
lpCMap = &(((LPCMAP)lpCharTab->lpCMapTab)[1]);
if (lpCMap->Class != CLASS_TYPE)
goto ErrorExit;
/* Check for ligatures */
if ((lpbBuf = GetNumber (hfpb, Buffer, lpbBuf,
&wcLigature, &cbRead)) == NULL) {
/* No ligature table present, use default */
lpCharTab->wcLigature = DEF_LIGATURE_COUNT;
lpCharTab->fFlag = USE_DEF_LIGATURE;
lpCharTab->lpLigature = LigatureTable;
}
else {
if ((lpCharTab->wcLigature = (WORD) wcLigature) != 0) {
/* Ligature table present */
/* Allocate memory block. Notice that we allocate 3 extra bytes
* They will serve as sentinels for the end of the ligature
* table, thus eliminating the need of having to know beforehand
* what is the size of the table
*/
if ((lpCharTab->hLigature = _GLOBALALLOC (DLLGMEM_ZEROINIT,
LIGATURE_BYTES * (wcLigature + 1))) == 0) {
SetErrCode (phr, E_OUTOFMEMORY);
goto ErrorExit;
}
lpbChar = lpCharTab->lpLigature =
(LPB)_GLOBALLOCK(lpCharTab->hLigature);
/* Read in the entries */
for (i = (WORD) wcLigature; i > 0; i--) {
for (j = LIGATURE_BYTES; j > 0; j--) {
if (lpbBuf = GetNumber (hfpb, Buffer, lpbBuf,
&wTmp, &cbRead)) {
/* Update entry */
*lpbChar ++ = (BYTE)wTmp;
}
else {
/* Missing item */
goto ErrorExit;
}
}
}
lpCharTab->fFlag = LIGATURE_PROVIDED;
}
else
lpCharTab->fFlag = NO_LIGATURE;
}
if (fOpenedFile)
FileClose (hfpb);
return ((LPV)lpCharTab);
ErrorExit:
if (fOpenedFile)
FileClose (hfpb);
MVCharTableDispose (lpCharTab);
return NULL;
}
/*************************************************************************
* @doc API INDEX
*
* @func HRESULT PASCAL FAR | MVCharTableFileBuild |
* Incorporate the character table into the system file
*
* @parm HFPB | hfpbSysFile |
* Handle to system file. It is non-zero, then the system file is
* already open, else the function will open the system file
*
* @parm LPCHARTAB | lpCharTab |
* Pointer to character table information structure
*
* @parm LSZ | lszFilename |
* File name. If hpfbSysFile is 0, the format is:
* dos filename[!charfilename], else it is the name of the character
* file itself
*
* @rdesc ERR_SUCCESS if succeeded, other errors if failed.
*
* @comm About ligature table, there are some assumptions:
* If hLigature == 0 {
* if (wcLigature == 0)
* There is no ligature table
* else
* We use the default ligature table. There is no need
* to write out the table data
* }
* else
* The author provides a ligature table.
*************************************************************************/
PUBLIC HRESULT EXPORT_API PASCAL FAR MVCharTableFileBuild (HFPB hfpbSysFile,
LPCHARTAB lpCharTab, LSZ lszFilename)
{
HFPB hfpbCharTab; // Pointer to final index file info.
BOOL fCreatedFile;
CHARTAB_HDR CharTab_hdr; // Character table header
BYTE Dummy[CHARTAB_HDR_SIZE]; // Dummy buffer to write 0
FILEOFFSET foOffset; // File's offset
FILEOFFSET foStart;
WORD CharTabSize;
WORD CharLigatureSize;
// char szFullFilename[MAX_PATH];
HRESULT hr = S_OK;
if (lpCharTab == NULL || lpCharTab->wcTabEntries == 0)
{
/* Nothing to build */
return E_INVALIDARG;
}
/* If hfpbSysFile != 0, allocate a temp HFPB to use for the system file */
//if (!(fCloseSysFile = (char)(hfpbSysFile == 0))) {
// if ((hfpb = ALLOCTEMPFPB (hfpbSysFile, phr)) == NULL)
// return ERR_FAILED;
//}
if ((fCreatedFile =
FsTypeFromHfpb(hfpbCharTab = hfpbSysFile) != FS_SUBFILE) &&
0 == (hfpbCharTab = FileCreate
(hfpbSysFile, lszFilename,
hfpbSysFile ? FS_SUBFILE : REGULAR_FILE, &hr)))
{
return hr;
}
// If we didn't open the file, we need to find out where the file seek
// pointer is initially so that we only seek relative to that starting
// position (i.e. the caller owns the part of the file that comes before).
foStart = (fCreatedFile ? MakeFo(0,0) :
FileSeek (hfpbCharTab, MakeFo (0, 0), wFSSeekCur, &hr));
if (FAILED(hr))
goto exit01;
/* Write out the CharTab file header */
CharTab_hdr.FileStamp = CHRTAB_STAMP;
CharTab_hdr.version = CHARTABVER;
CharTabSize = lpCharTab->wcTabEntries * sizeof(CHARMAP);
/* the ligature table size:
* - is 0 if we are going to use the default table
* - Is non-0 if the author provides a ligature table
*/
switch (lpCharTab->fFlag)
{
case NO_LIGATURE:
case USE_DEF_LIGATURE:
CharLigatureSize = 0;
break;
default:
CharLigatureSize = lpCharTab->wcLigature * LIGATURE_BYTES;
}
CharTab_hdr.dwTabSize = CharTabSize + CharLigatureSize;
CharTab_hdr.wcTabEntries = lpCharTab->wcTabEntries;
CharTab_hdr.wcLigature = lpCharTab->wcLigature;
CharTab_hdr.fFlag = lpCharTab->fFlag;
MEMSET(Dummy, (BYTE)0, CHARTAB_HDR_SIZE);
/* Write all zero to the header */
if (FileSeekWrite(hfpbCharTab, Dummy, FoAddFo(foStart, foNil),
CHARTAB_HDR_SIZE, &hr) != CHARTAB_HDR_SIZE)
{
goto exit01;
}
if (FileSeekWrite(hfpbCharTab, &CharTab_hdr, FoAddFo(foStart, foNil),
sizeof(CHARTAB_HDR), &hr) != sizeof(CHARTAB_HDR))
{
goto exit01;
}
foOffset = FoAddFo(foStart, MakeFo(CHARTAB_HDR_SIZE,0L));
/* Write out the character table buffer */
if (FileSeekWrite(hfpbCharTab, lpCharTab->lpCMapTab, foOffset,
CharTabSize, &hr) != CharTabSize)
{
goto exit01;
}
if (CharLigatureSize)
{
foOffset = FoAddDw(foOffset,CharTabSize);
/* Write out the ligature table */
if (FileSeekWrite(hfpbCharTab, lpCharTab->lpLigature, foOffset,
CharLigatureSize, &hr) != CharLigatureSize)
{
goto exit01;
}
}
hr = S_OK;
exit01:
// Close file if we created it.
if (fCreatedFile)
FileClose(hfpbCharTab); // Removed fRet= here.
return hr;
}
/*************************************************************************
* @doc INTERNAL
*
* @func VOID PASCAL NEAR | GetWord |
* This function will scan and get a word from the input buffer
*
* @parm LSZ FAR | *lplszBuf |
* Pointer to input buffer. The content will be updated on exit
*
* @parm LST | lstWord |
* Buffer to received parsed word
*************************************************************************/
PRIVATE VOID PASCAL NEAR GetWord (LSZ FAR *lplszBuf, LST lstWord)
{
LST lstWordStart;
LSZ lszBuf = *lplszBuf;
/* Remember the beginning of the word */
lstWordStart = lstWord++;
/* Skip all beginning blanks */
while (*lszBuf == ' ')
lszBuf++;
/* Now keep accumulating the word's characters */
for (;;) {
switch (*lszBuf) {
case 0:
case ' ':
goto exit0;
case '/':
if (*(lszBuf + 1) == '/') {
/* Skip the inline comment */
while (*lszBuf)
lszBuf++;
goto exit0;
}
default:
*lstWord++ = *lszBuf++;
}
}
exit0:
*lplszBuf = lszBuf;
*lstWordStart = (BYTE)(lstWord - lstWordStart - 1);
}
/*************************************************************************
* @doc INTERNAL
*
* @func VOID PASCAL NEAR | StripCRLF |
* This function will change all CR, LF in the input buffer into
* 0, all tabs into blank
*
* @parm LPB | lpbBuf |
* Input buffer
*
* @parm WORD | BufSize |
* Length of the buffer
*************************************************************************/
PRIVATE VOID PASCAL NEAR StripCRLF (LPB lpbBuf, WORD BufSize)
{
for (; BufSize > 0; BufSize --)
{
switch (*lpbBuf)
{
case RETURN:
case NEWLINE:
*lpbBuf = 0;
break;
case '\t':
*lpbBuf = ' ';
break;
}
lpbBuf++;
}
}
/*************************************************************************
* @doc API RETRIEVAL
*
* @func LPCHARTAB FAR PASCAL | MVCharTableIndexLoad |
* This function will load a character table from a
* system file.
*
* @parm HANDLE | hfpbSysFile |
* If non-zero, this is the handle of an already opened system file
*
* @parm LSZ | lszFilename |
* If hpfbSysFile is non-zero, this is the name of the CharTab's subfile
* else this is the combined filename with the format
* "dos_filename[CharTab_filename]"
* If the subfile's name is not specified, the default CharTab's file
* name will be used
*
* @parm PHRESULT | phr |
* Pointer to error buffer
*
* @rdesc If succeeded, the function will return a pointer the loaded
* CharTab, else NULL. The error buffer will contain information
* about the cause of the failure
*
* @comm About ligature table, there are some assumptions:
* If hLigature == 0 {
* if (wcLigature == 0)
* There is no ligature table
* else
* We use the default ligature table. There is no need
* to write out the table data
* }
* else
* The author provides a ligature table.
*************************************************************************/
PUBLIC LPVOID EXPORT_API FAR PASCAL MVCharTableIndexLoad(HFPB hfpbSysFile,
LSZ lszFilename, PHRESULT phr)
{
HANDLE hfpbCharTabFile;
BOOL fOpenedFile;
LPCHARTAB lpCharTab = NULL;
CHARTAB_HDR FAR *lpCharTabHdr;
CHARTAB_HDR CharTabHdr;
FILEOFFSET foStart;
#if _MAC
int MacClipMap[256], i;
LPCMAP lpCMapEntry;
#endif
*phr = S_OK;
lpCharTabHdr = &CharTabHdr;
/* Open subfile, (and system file if necessary) */
if ((fOpenedFile =
FsTypeFromHfpb(hfpbCharTabFile = hfpbSysFile) != FS_SUBFILE) &&
(hfpbCharTabFile = (HANDLE)FileOpen
(hfpbSysFile, lszFilename, hfpbSysFile ? FS_SUBFILE : REGULAR_FILE,
READ, phr)) == 0)
{
exit0:
return (LPV)lpCharTab;
}
// If we didn't open the file, we need to find out where the file seek
// pointer is initially so that we only seek relative to that starting
// position (i.e. the caller owns the part of the file that comes before).
foStart = (fOpenedFile ? MakeFo(0,0) :
FileSeek (hfpbCharTabFile, MakeFo (0, 0), wFSSeekCur, phr));
/* Read in the header file, and make sure that is a CharTab file */
if (FAILED(*phr) ||
FileSeekRead(hfpbCharTabFile, (LPV)lpCharTabHdr, FoAddFo(foStart, foNil),
sizeof(CHARTAB_HDR), phr) != sizeof(CHARTAB_HDR)) {
exit1:
/* Close the subfile if we opened it */
if (fOpenedFile)
FileClose(hfpbCharTabFile);
/* Close the system file if we open it, the handle will be
* released in the process */
goto exit0;
}
/* MAC code. They will be optimized out */
lpCharTabHdr->FileStamp = SWAPWORD(lpCharTabHdr->FileStamp);
lpCharTabHdr->version = SWAPWORD(lpCharTabHdr->version);
lpCharTabHdr->wcTabEntries = SWAPWORD(lpCharTabHdr->wcTabEntries);
lpCharTabHdr->wcLigature = SWAPWORD(lpCharTabHdr->wcLigature);
lpCharTabHdr->fFlag = SWAPWORD(lpCharTabHdr->fFlag);
lpCharTabHdr->dwTabSize = SWAPLONG(lpCharTabHdr->dwTabSize);
/* Check to see if the data read in is valid */
if (lpCharTabHdr->FileStamp != CHRTAB_STAMP)
{ // File stamp
SetErrCode(phr, E_BADVERSION);
goto exit1;
}
/* Allocate memory for the character table. Note that there may be
* some inefficiency im memory usage, since there are 3-bytes per
* ligature entry, and several more for each charmap entry.
*/
if ((lpCharTab = CharTableCreate ((lpCharTabHdr->wcTabEntries +
lpCharTabHdr->wcLigature))) == NULL) {
SetErrCode(phr, E_OUTOFMEMORY);
goto exit1;
}
lpCharTab->wcTabEntries = lpCharTabHdr->wcTabEntries;
lpCharTab->fFlag = lpCharTabHdr->fFlag;
lpCharTab->hLigature = 0;
/* Read in the CharTab bitmap data */
if (FileSeekRead(hfpbCharTabFile,
(LPV)lpCharTab->lpCMapTab, FoAddFo(foStart, MakeFo(CHARTAB_HDR_SIZE,0)),
(WORD)lpCharTabHdr->dwTabSize, phr) !=
(WORD)lpCharTabHdr->dwTabSize)
{
MVCharTableDispose(lpCharTab);
lpCharTab = NULL;
goto exit1;
}
#if _MAC
/* Create the mapping from Mac to Windows. This is to deal with the
* situation people entering data on a Mac and look for that string
*/
lpCMapEntry = (LPCMAP)lpCharTab->lpCMapTab;
for (i = lpCharTab->wcTabEntries; i > 0; i--)
{
// erinfox: swap class
lpCMapEntry[i].Class = SWAPWORD(lpCMapEntry[i].Class);
lpCMapEntry[i].SortOrder = SWAPWORD(lpCMapEntry[i].SortOrder);
if (lpCMapEntry[i].MacDisplay != 0)
{
lpCMapEntry[lpCMapEntry[i].MacDisplay].MacToWin = i;
}
}
/* Change the Mac clipboard mapping. I am using the 256 value.
* The character table hasthe mapping based on the Windows indices
* but since the WinToMap mapping will change all the character
* values to their corresponding Mac, the new values have to be
* used as indices, ie. there is a need to remap the
* MacCaseSensitiveNorm column based on the new Mac indices
*/
MEMSET (MacClipMap, 0, 256);
for ( i = 0; i < lpCharTab->wcTabEntries; i++)
{
MacClipMap[lpCMapEntry[i].MacDisplay] =
lpCMapEntry[i].MacCaseSensitiveNorm;
}
/* Reset the mapping. */
/* Change all 0's to 32 (space) to avoid truncation */
for ( i = 0; i < lpCharTab->wcTabEntries; i++)
{
if ((lpCMapEntry[i].MacCaseSensitiveNorm = MacClipMap[i]) == 0)
lpCMapEntry[i].MacCaseSensitiveNorm = 32;
}
#endif /* _MAC */
/* Look for ligature */
switch (lpCharTab->fFlag) {
case NO_LIGATURE:
break;
case USE_DEF_LIGATURE:
lpCharTab->wcLigature = DEF_LIGATURE_COUNT;
lpCharTab->fFlag = USE_DEF_LIGATURE;
lpCharTab->hLigature = 0;
lpCharTab->lpLigature = LigatureTable;
break;
default:
lpCharTab->lpLigature = (LPB)lpCharTab->lpCMapTab +
lpCharTabHdr->wcTabEntries * sizeof(CHARMAP);
lpCharTab->wcLigature = lpCharTabHdr->wcLigature;
}
goto exit1;
}
/*************************************************************************
* @doc API RETRIEVAL
* @func LPCTAB FAR PASCAL | MVCharTableGetDefault |
* Retrieve the default character mapping table used by MV
* @parm PHRESULT | phr |
* Pointer to error buffer
* @rdesc
* Pointer to character mapping table if successful, NULL otherwise.
* In case of error, phr will contain the error code
*************************************************************************/
PUBLIC LPV EXPORT_API FAR PASCAL MVCharTableGetDefault (PHRESULT phr)
{
LPCHARTAB lpCharTab = NULL;
#if _MAC
int i;
LPCMAP lpCMapEntry;
#endif /* _MAC */
/* Allocate memory for the character table. Note that there may be
* some inefficiency im memory usage, since there are 3-bytes per
* ligature entry, and several more for each charmap entry.
*/
if ((lpCharTab = CharTableCreate (MAX_CHAR_COUNT +
DEF_LIGATURE_COUNT)) == NULL) {
SetErrCode(phr, E_OUTOFMEMORY);
return NULL;
}
lpCharTab->wcTabEntries = MAX_CHAR_COUNT;
lpCharTab->wcLigature = DEF_LIGATURE_COUNT;
lpCharTab->fFlag = USE_DEF_LIGATURE;
lpCharTab->hLigature = 0;
lpCharTab->lpLigature = LigatureTable;
lpCharTab->lpCMapTab = DefaultCMap;
#if _MAC
/* Create the mapping from Mac to Windows. This is to deal with the
* situation people entering data on a Mac and look for that string
*/
lpCMapEntry = (LPCMAP)lpCharTab->lpCMapTab;
for (i = lpCharTab->wcTabEntries; i > 0; i--) {
if (lpCMapEntry[i].MacDisplay != 0) {
lpCMapEntry[lpCMapEntry[i].MacDisplay].MacToWin = i;
}
}
/* Create the clipboard case sensitive column */
#endif /* _MAC */
return(lpCharTab);
}
/*************************************************************************
* @doc API INDEX RETRIEVAL
*
* @func VOID FAR PASCAL | MVCharTableDispose |
* Free all memory associated with the character table
*
* @parm LPCHARTAB | lpCharTab |
* Pointer to character table structure
*************************************************************************/
PUBLIC VOID EXPORT_API FAR PASCAL MVCharTableDispose (LPCHARTAB lpCharTab)
{
HANDLE hBuf;
if (lpCharTab == NULL)
return;
if (hBuf = lpCharTab->hLigature) {
FreeHandle2(hBuf);
lpCharTab->hLigature = NULL;
}
FreeHandle2(lpCharTab->hStruct);
}
/*************************************************************************
* @doc API INDEX RETRIEVAL
*
* @func VOID FAR PASCAL | MVCharTableSetWildcards |
* Change the property of '*' and '?' to CLASS_WILDCARD.
*
* @parm LPCHARTAB | lpCharTab |
* Pointer to character table structure
*************************************************************************/
PUBLIC VOID EXPORT_API FAR PASCAL MVCharTableSetWildcards (LPCHARTAB lpCharTab)
{
if (lpCharTab == NULL)
return;
(lpCharTab->lpCMapTab)['*'].Class = CLASS_WILDCARD;
(lpCharTab->lpCMapTab)['?'].Class = CLASS_WILDCARD;
}
/*************************************************************************
* @doc INTERNAL
*
* @func LPB NEAR PASCAL | GetNumber |
* This function will try to get to a number in an ASCII and then
* retrieve it. It will fill up the input buffer if necessary
*
* @parm HFPB | hfpb |
* Handle of opened file
*
* @parm LPB | Buffer |
* Buffer to store the input data
*
* @parm LPB | lpbBuf |
* Current location pointer into the input buffer
*
* @parm int far * | lpNum |
* Place to store the retrieved number
*
* @parm WORD FAR * | lpcbRead |
* How many bytes are left in the input buffer
*
* @rdesc If succeeded, the function will return the last location
* of the input buffer, else NULL if failed. If succeeded, the
* number is stored in *lpNum, the number of bytes left in the input
* buffer is updated
*************************************************************************/
PRIVATE LPB NEAR PASCAL GetNumber (HFPB hfpb, LPB Buffer, LPB lpbBuf,
int far *lpNum, WORD FAR *lpcbRead)
{
register WORD fSkipComment = 0;
register WORD cbRead = *lpcbRead;
WORD number = 0;
BYTE fGetNum = FALSE;
HRESULT hr;
for (;;) {
/* Check for empty buffer, and read in new data if necessary */
if (cbRead == 0) {
cbRead = (WORD) FileRead(hfpb, lpbBuf = Buffer, INBUF_SIZE, &hr);
if (cbRead == 0 || FAILED(hr)) {
if (fGetNum == FALSE)
lpbBuf = NULL; // Return error
break;
}
}
if (*lpbBuf == RETURN || *lpbBuf == NEWLINE) {
/* EOL, reset variables, exit if we already got a number */
fSkipComment = 0;
if (fGetNum)
break;
}
else if (fSkipComment != 2) {
/* We are not inside a comment, so look for a number */
if (*lpbBuf >= '0' && *lpbBuf <= '9') {
/* Get the number */
number = number * 10 + *lpbBuf - '0';
fGetNum = TRUE;
}
else if (*lpbBuf == SLASH) {
if (fGetNum)
break;
fSkipComment++; // Increment slash count
}
else {
if (fGetNum)
break;
fSkipComment = 0;
}
}
cbRead--;
lpbBuf++;
}
/* Update the variables */
*lpcbRead = cbRead;
*lpNum = number;
return lpbBuf;
}
/*************************************************************************
* @doc INTERNAL
*
* @func LPCHARTAB PASCAL NEAR | CharTableCreate |
* Allocate memory necessary for the character table. The amount
* needed is based on the number of entries
*
* @parm WORD | wcTabEntries |
* Number of entries in the character table
*
*************************************************************************/
PRIVATE LPCHARTAB PASCAL NEAR CharTableCreate (int wcTabEntries)
{
HANDLE hMem;
LPCHARTAB lpCharTab;
/* Allocate memory for the character table */
if ((hMem = _GLOBALALLOC (DLLGMEM_ZEROINIT,
sizeof(CHARTAB) + wcTabEntries * sizeof(CHARMAP))) == NULL) {
return NULL;
}
lpCharTab = (LPCHARTAB)_GLOBALLOCK(hMem);
lpCharTab->lpCMapTab = (LPCMAP)(lpCharTab + 1);
lpCharTab->hStruct = hMem;
return lpCharTab;
}