filecach.c

windows环境下的一套汉字处理引擎,可以对汉字进行相应的处理

/**************************************************************************
    Name:
	FileCach.c
    Module:
	WSENGINE.DLL
    Created By:
	Wang Zhidong
    Date:
	1993.9 - 1995.1
    Version:
	1.10
    Exports:
	WseBuildFileCache
	WseReadFileCache
	WseReleaseFileCache

    Description:
	1.  hCache WseBuildFileCache (szFile, lStart, lLen)
	Function:   Create a Cache Image for a File.
	Params: szFile	LPSTR,	File name.
		lStart	long,	Start point of the file to be cache.
		lLen	long,	Length of data of the file to be cache.
	Return: The Handle of the File cache.
	Note:	Call WseReleaseFileCache to remove the handle when all done.

	2.  bRet WseReadFileCache (hCache, lOffset, wSize, lpBuffer)
	Function:   Read datas from a file cache.
	Params: hCache	HANDLE, A Handle of the file cache return by
				WseBuildFileCache.
		lOffset long,	The Start point of the cache.
		wSize	unsigned, the size of data to be read.
		lpBuffer LPSTR, Point to the Buffer.
	Return: TRUE if secceed.

	3.  bRet WseReleaseFileCache (hCache);
	Function:   Release the Handle of file cache.
	Params: hCache	HANDLE, A Handle of the file cache.
	Return: TRUE if secceed.
***********************************************************************/
#include <windows.h>
#include <mate.h>

#define GMEMBLOCKFLAG (GMEM_MOVEABLE | GMEM_DISCARDABLE | GMEM_SHARE)

#define BLOCKSIZE    8192
#define CACHELABEL   0x4346

typedef struct {
    WORD     Label;
    OFSTRUCT OF;
    long     Offset;
    long     Length;
    unsigned Blocks;
    HANDLE   MemBlock[];
} WSEFILECACHE;
typedef WSEFILECACHE NEAR *PWSEFILECACHE;
typedef WSEFILECACHE FAR *FPWSEFILECACHE;

LPSTR	 LockMyBlock (FPWSEFILECACHE, unsigned, long);

HANDLE WINAPI WseBuildFileCache (LPSTR szFile, long lStart, long lLen)
{
    unsigned Blocks;
    HANDLE   hMem;
    HFILE	 hFile;
    FPWSEFILECACHE lpfc;

    Blocks = (lLen + BLOCKSIZE - 1)/BLOCKSIZE;
    hMem = GlobalAlloc (GHND | GMEM_SHARE,
						Blocks*sizeof(HANDLE)+sizeof(WSEFILECACHE));

    if (!hMem)
		return NULL;

    lpfc = (FPWSEFILECACHE)GlobalLock (hMem);
    if (!lpfc)
		{
		GlobalFree (hMem);
		return NULL;
		}

    hFile = OpenFile (szFile, &lpfc->OF, OF_READ);
    if (hFile == HFILE_ERROR ||
		_llseek (hFile, 0L, SEEK_END) < lStart+lLen)
		{
		if (hFile != HFILE_ERROR)
		    _lclose (hFile);
		GlobalUnlock (hMem);
		GlobalFree   (hMem);
		return NULL;
		}

    lpfc->Label     = CACHELABEL;
    lpfc->Offset    = lStart;
    lpfc->Length    = lLen;
    lpfc->Blocks    = Blocks;

    _lclose (hFile);
    GlobalUnlock (hMem);
    return (HANDLE)(hMem);
}

LPSTR	LockMyBlock (FPWSEFILECACHE lpfc, unsigned block, long lOffset)
{
    HANDLE  hMem;
    HFILE	hFile;
    LPSTR   lpdata;

    hMem = lpfc->MemBlock[block];
    if (!hMem || !(lpdata = GlobalLock (hMem)))
	{
	if (!hMem)
	    {
	    lpfc->MemBlock[block] =
	    hMem = GlobalAlloc (GMEMBLOCKFLAG, BLOCKSIZE);
	    }
	else
	    {
	    lpfc->MemBlock[block] =
	    hMem = GlobalReAlloc (hMem, BLOCKSIZE, GMEMBLOCKFLAG);
	    }

	if (!hMem)
	    return NULL;

	lpdata = GlobalLock (hMem);
	if ((hFile = OpenFile (NULL, &(lpfc->OF), OF_REOPEN | OF_READ))==HFILE_ERROR)
	    {
	    GlobalUnlock (hMem);
	    return NULL;
	    }
	if (lOffset)
	    _llseek (hFile, lOffset, SEEK_SET);
	_lread (hFile, lpdata, BLOCKSIZE);
	_lclose (hFile);
	}
    return lpdata;
}

BOOL WINAPI WseReadFileCache (hCache, lOffset, wSize, lpBuffer)
HANDLE	hCache;
long	lOffset;
unsigned wSize;
LPSTR	lpBuffer;
{
    FPWSEFILECACHE lpfc;
    LPSTR	  lps;
    unsigned	block, off;

    lpfc = (FPWSEFILECACHE)GlobalLock (hCache);
    if (!lpfc || lpfc->Label != CACHELABEL || lOffset+(long)wSize > lpfc->Length)
		{
		GlobalUnlock (hCache);
		return FALSE;
		}
    block = lOffset / BLOCKSIZE;
    off   = lOffset % BLOCKSIZE;
    lOffset -= off;
    lOffset += lpfc->Offset;

    while (off+wSize >= BLOCKSIZE)
	{
	lps = LockMyBlock (lpfc, block, lOffset);
	WseRepMovsb (lpBuffer, lps+off, BLOCKSIZE-off);
	GlobalUnlock (lpfc->MemBlock[block]);

	lpBuffer += BLOCKSIZE-off;
	wSize	 -= BLOCKSIZE-off;
	off	  = 0;

	lOffset += BLOCKSIZE;
	block++;
	}
    if (wSize)
	{
	lps = LockMyBlock (lpfc, block, lOffset);
	WseRepMovsb (lpBuffer, lps+off, wSize);
	GlobalUnlock (lpfc->MemBlock[block]);
	}
    GlobalUnlock (hCache);
    return TRUE;
}

BOOL WINAPI WseReleaseFileCache (HANDLE hCache)
{
    FPWSEFILECACHE   lpfc;
    int i;

    if (!(lpfc = (FPWSEFILECACHE)GlobalLock (hCache)))
	return FALSE;

    if (lpfc->Label != CACHELABEL)
	return FALSE;

    for (i = 0; i < (int)lpfc->Blocks; i++)
		{
		if (lpfc->MemBlock[i])
		    GlobalFree (lpfc->MemBlock[i]);
		}
    return TRUE;
}