able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/inetsrv/intlwb/thai2/sth/nlglib.h
CryptoAlgo Inc b3cac27891 Add source files
2020-09-26 16:20:57 +08:00

798 lines
23 KiB
C
Raw Permalink Blame History

/****************************** Module Header ******************************\
* Module Name: NLGLib.h
*
* Copyright (c) 1997, Microsoft Corporation
*
* History:
1/26/98 DougP prefix dbgMalloc, dbgFree, and dbgRealloc with CMN_
whack defs of malloc, free, and realloc
\***************************************************************************/
#ifndef _NLGLIB_H_
#define _NLGLIB_H_
#ifdef __cplusplus
extern "C" {
#endif
#include <stdio.h> // For the definition of FILE
// Mapped file stuff
//
typedef struct _TAG_MFILE {
HANDLE hFile;
HANDLE hFileMap;
DWORD cbSize1;
DWORD cbSize2;
PVOID pvMap;
BOOL fSrcUnicode;
BOOL fDstUnicode;
union {
WCHAR * pwsz;
CHAR * psz;
};
UINT uCodePage; // codepage for conversions
} MFILE, *PMFILE;
// ----------------------------------------------------------------------
// misc.c
// ----------------------------------------------------------------------
#ifdef _UNICODE
#define OpenMapFile OpenMapFileW
#define OpenDataFile OpenDataFileW
#define OpenOutFile OpenOutFileW
#else
#define OpenMapFile OpenMapFileA
#endif
BOOL WINAPI ResetMap(PMFILE pmf);
BOOL WINAPI CloseMapFile(PMFILE pmf);
PMFILE WINAPI OpenMapFileA(const char *pszFileName);
PVOID WINAPI GetMapLine(PVOID pv0, DWORD cbMac, PMFILE pmf);
BOOL WINAPI NextMapLine(PMFILE pmf);
PMFILE WINAPI OpenMapFileWorker(const WCHAR * pwszFileName, BOOL fDstUnicode);
#define OpenMapFileW(pwszFileName) OpenMapFileWorker(pwszFileName, TRUE)
#define OpenDataFileW(pwszFileName) OpenMapFileWorker(pwszFileName, TRUE)
#define OpenOutFileW(pwszFileName) OpenMapFileWorker(pwszFileName, TRUE)
// Inverse Probability Log (IPL) stuff
//
typedef BYTE IPL;
#define IPL_UNKNOWN 0xFF
// All ipl values must be strictly less than this.
// This corresponds to a probability of 1 in 4 billion, so
// it supports a corpus of 4 billion items (chars, words, sentences, etc.)
//
#define IPL_LIMIT 32
// Multiplier is used to boost precision of low ipls
//
#define IPL_MULTIPLIER 8 // 256 divided by 32 = 8
#define Ipl2Freq( ipl, cTotalFreq) ((cTotalFreq) >> (ipl))
IPL WINAPI Freq2Ipl( double );
DWORD WINAPI GetCRC32( IN BYTE *pb, IN DWORD cb);
WORD WINAPI GetCRC16( IN BYTE *pb, IN DWORD cb);
// ----------------------------------------------------------------------
// mapsort.c
// ----------------------------------------------------------------------
// Sort and Unique stuff
//
#ifdef _UNICODE
#define MapSort MapSortW
#define MapUnique MapUniqueW
#define Member MemberW
#define RecordString RecordStringW
#else // _UNICODE not defined
#define MapSort MapSortA
#define MapUnique MapUniqueA
#endif // _UNICODE
BOOL WINAPI MapSortW( CONST WCHAR * pszFileName);
BOOL WINAPI MapSortA( CHAR * pszFileName);
BOOL WINAPI MapUniqueW( CONST WCHAR * pwszFileName);
BOOL WINAPI MapUniqueA( CHAR * pszFileName);
// ----------------------------------------------------------------------
// mcodes.c
// ----------------------------------------------------------------------
// WARNING WARNING WARNING
// cpheme creation mode - should be consistent with T-Hammer
#define CPHEME_MODE_STRICT 0x0001
#define CPHEME_MODE_DUPLICATE 0x0002
#define STEM_ATTR_COMPV 0x0010
typedef struct _tagMETABASES {
WCHAR wcOphemeBase;
WCHAR wcMinTrieChar;
WCHAR wcStemBase;
WCHAR wcFcnBase;
WCHAR wcSelBase;
} METABASE, *PMETABASE;
// Stem/Morph Code file stuff
//
void WINAPI ReadBases( METABASE *pMetaBases );
void WINAPI WriteBases( METABASE *pMetaBases );
void WINAPI
WriteFcnCodes(
WCHAR **ppwzMorphs,
DWORD cMorphs,
PWORD pwSelections);
void WINAPI
WriteCodesBin(
CONST WCHAR *pwzFileName,
WCHAR **ppwzMorphs,
DWORD cMorphs,
WCHAR **ppwzAttr1,
WCHAR **ppwzAttr2,
PWORD pwAttributes);
BOOL WINAPI
GetCodes(
WCHAR *wszCodesFile,
WCHAR **ppwszBuffer,
WCHAR **ppwszCodes,
DWORD *pcCodes,
DWORD cCodesMac);
BOOL WINAPI
GetCodesUnsorted(
WCHAR *wszCodesFile,
WCHAR **ppwszBuffer,
WCHAR **ppwszCodes,
DWORD *pcCodes,
DWORD cCodesMac);
BOOL WINAPI
GetCodeAttributes(
WCHAR *wszCodesFile,
WCHAR **ppwszCodes,
DWORD cCodes,
WCHAR **ppwszBuffer,
WCHAR **ppwszAttr1,
WCHAR **ppwszAttr2,
WORD *pwAttrFlags);
BOOL WINAPI
LoadMCatMappingTable(
WCHAR *wszCodesFile,
WCHAR **ppwszCodes,
DWORD cCodes,
WCHAR **ppwszTBits,
DWORD cTBits,
WORD *pwTBitToMCat,
WORD *pwSubMToMCat);
BOOL WINAPI
MCatFromTBit(
DWORD iTBit,
DWORD *piMCat,
WORD *pwTBitToMCat,
DWORD cTBits);
BOOL WINAPI
MCatFromSubM(
DWORD iSubM,
DWORD *piMCat,
WORD *pwSubMToMCat,
DWORD cCodes);
BOOL WINAPI
EnumSubMFromMCat(
DWORD iMCat,
DWORD *piSubM,
WORD *pwSubMToMCat,
DWORD cCodes);
// ----------------------------------------------------------------------
// ctplus0.c
// ----------------------------------------------------------------------
// Character type routines
BYTE WINAPI
GetCharType(WCHAR wc );
// ----------------------------------------------------------------------
// fileio.c
// ----------------------------------------------------------------------
// File I/O Wrappers
//
HANDLE WINAPI ThCreate( CONST WCHAR * );
HANDLE WINAPI ThOpen( CONST WCHAR * );
UINT WINAPI ThRead( HANDLE , LPVOID , UINT );
UINT WINAPI ThWrite( HANDLE, LPCVOID , UINT );
// CRT Unicode routines
//
int WINAPI UStrCmp(const WCHAR *pwsz1, const WCHAR *pwsz2);
DWORD WINAPI MemberW(WCHAR * ,WCHAR **, DWORD);
DWORD WINAPI RecordString(WCHAR *, WCHAR **, WCHAR *, DWORD *, DWORD *);
void WINAPI PutLine(const WCHAR *, FILE *);
WCHAR * WINAPI GetLine(WCHAR *, int , FILE *);
#define PrimeHash(wOld, wNew, cBitsMax) (((wOld) + (wNew))*hashPrime[cBitsMax]&hashMask[cBitsMax])
extern const unsigned int hashPrime[];
extern const unsigned int hashMask[];
// #include "ctplus0.h"
//-----------------------------------------------------------+
// memory allocation:
// In the debug version, we compile in the debugging memory
// allocator and aim our allocation macros at it.
// In retail, the macros just use LocalAlloc
//-----------------------------------------------------------+
#if defined(_DEBUG)
void * WINAPI dbgMalloc(size_t cb);
void * WINAPI dbgCalloc(size_t c, size_t cb);
void * WINAPI dbgFree(void* pv);
void * WINAPI dbgRealloc(void* pv, size_t cb);
void * WINAPI dbgMallocCore(size_t cb, BOOL fTrackUsage);
void * WINAPI dbgFreeCore(void* pv, BOOL fTrackUsage);
void * WINAPI dbgReallocCore(void* pv, size_t cb, BOOL fTrackUsage);
#if 0
#define malloc dbgMalloc
#define free dbgFree
#define realloc dbgRealloc
#define calloc dbgCalloc
#endif
//DWORD WINAPI dbGlobalSize(HANDLE);
//HANDLE WINAPI dbGlobalAlloc(UINT, DWORD);
//HANDLE WINAPI dbGlobalFree(HANDLE);
//HANDLE WINAPI dbGlobalReAlloc(HANDLE, DWORD, UINT);
#if defined(ENABLE_DBG_HANDLES)
HANDLE WINAPI dbGlobalHandle(LPCVOID);
BOOL WINAPI dbGlobalUnlock(HANDLE);
LPVOID WINAPI dbGlobalLock(HANDLE);
#endif // ENABLE_DBG_HANDLES
#define dbHeapInit InitDebugMem
// it is a good idea (essential if you're MT) to call these before any mem allocs
void WINAPI InitDebugMem(void);
// and this after all mem allocs
BOOL WINAPI FiniDebugMem(void); // returns true if not all memory released
// these are alternative entrypoints
BOOL WINAPI fNLGNewMemory( PVOID *ppv, ULONG cbSize);
DWORD WINAPI NLGMemorySize(PVOID pvMem);
BOOL WINAPI fNLGResizeMemory(PVOID *ppv, ULONG cbNew);
VOID WINAPI NLGFreeMemory(PVOID pv);
BOOL WINAPI fNLGHeapDestroy( VOID );
#else // NOT (DEBUG)
#define InitDebugMem() ((void)0)
#define FiniDebugMem() (FALSE)
#define dbgMalloc(cb) LocalAlloc( LMEM_FIXED, cb )
void * WINAPI dbgCalloc(size_t c, size_t cb);
#define dbgFree(pv) LocalFree( pv )
#define dbgRealloc(pv, cb) LocalReAlloc(pv, cb, LMEM_MOVEABLE)
#define fNLGHeapDestroy( ) TRUE
// When fNLGNewMemory fails the passed in ptr will be side-effected to NULL
#define fNLGNewMemory( ppv, cbSize) ((*(ppv) = LocalAlloc( LMEM_FIXED, cbSize )) != NULL)
#define NLGFreeMemory( pv) LocalFree( pv )
#endif // (DEBUG)
/*************************************************
Lexical Table functions
implementation in lextable.c
*************************************************/
#define Lex_UpperFlag 0x01 /* upper case */
#define Lex_LowerFlag 0x02 /* lower case */
#define Lex_DigitFlag 0x04 /* decimal digits */
#define Lex_SpaceFlag 0x08 /* spacing characters */
#define Lex_PunctFlag 0x10 /* punctuation characters */
#define Lex_ControlFlag 0x20 /* control characters */
#define Lex_LexiconFlag 0x40
#define Lex_VowelFlag 0x80
#define NTRANSTAB 256
extern const BYTE Lex_rgchKey[NTRANSTAB];
extern const BYTE Lex_rgFlags[NTRANSTAB];
#define INUPPERPAGES(ch) (ch & 0xff00) // this is the same as ch > 0x00ff
// don't count on any of the above constants - use these functions below
// The speller uses this to make equivalent classes
WCHAR WINAPI fwcUpperKey(const WCHAR wc);
BOOL WINAPI IsUpperPunct(const WCHAR ch);
__inline WCHAR WINAPI CMN_Key(const WCHAR ch)
{
#if defined(_VIET_)
// When we are ready for merge we should add these data to core Lex_rgFlgas.
if (INUPPERPAGES(ch))
{
if ( (ch == 0x0102) ||
(ch == 0x0110) ||
(ch == 0x01A0) ||
(ch == 0x01AF) )
{
return (ch + 1);
}
return fwcUpperKey(ch);
}
else if ( (ch == 0x00D0) ) // This seem very weird that we map it like this in NT.
{
return 0x0111;
}
else if ( (ch == 0x00C3) )
{
return 0x0103;
}
else if ( (ch == 0x00D5) )
{
return 0x01A1;
}
else if ( (ch == 0x00DD) )
{
return 0x01B0;
}
else if ( (ch == 0x00D4) ||
(ch == 0x00CA) ||
(ch == 0x00C2) )
{
return (ch + 0x0020);
}
else if ( (ch == 0x00f4) || // These are special case there are no key that should map to these characters.
(ch == 0x00ea) ||
(ch == 0x00e2) )
{
return ch;
}
else
{
return ((WCHAR) Lex_rgchKey[(UCHAR) ch]);
}
#else
return (WCHAR) (INUPPERPAGES(ch) ?
fwcUpperKey(ch) :
(WCHAR) Lex_rgchKey[(UCHAR) ch]);
#endif
}
__inline BOOL WINAPI CMN_IsCharUpperW(WCHAR ch)
{
#if defined(_VIET_)
// When we are ready for merge we should add these data to core Lex_rgFlgas.
if ( (ch == 0x0111) ||
(ch == 0x0103) ||
(ch == 0x01A1) ||
(ch == 0x01B0) )
{
return FALSE;
}
else if ( (ch == 0x0102) ||
(ch == 0x0110) ||
(ch == 0x01A0) ||
(ch == 0x01AF) ||
(ch == 0x00D4) ||
(ch == 0x00CA) ||
(ch == 0x00D0) ||
(ch == 0x00C3) ||
(ch == 0x00D5) ||
(ch == 0x00DD) ||
(ch == 0x00C2) )
{
return TRUE;
}
else if (INUPPERPAGES(ch))
{
return FALSE;
}
else
{
return Lex_rgFlags[(UCHAR) ch] & Lex_UpperFlag;
}
#else
return INUPPERPAGES(ch) ? FALSE : Lex_rgFlags[(UCHAR) ch] & Lex_UpperFlag;
#endif
}
__inline BOOL WINAPI CMN_IsCharLowerW(WCHAR ch)
{
#if defined(_VIET_)
// When we are ready for merge we should add these data to core Lex_rgFlgas.
if ( (ch == 0x0111) ||
(ch == 0x0103) ||
(ch == 0x01A1) ||
(ch == 0x01B0) )
{
return TRUE;
}
else if ( (ch == 0x0102) ||
(ch == 0x0110) ||
(ch == 0x01A0) ||
(ch == 0x01AF) ||
(ch == 0x00D4) ||
(ch == 0x00CA) ||
(ch == 0x00D0) ||
(ch == 0x00C3) ||
(ch == 0x00D5) ||
(ch == 0x00DD) ||
(ch == 0x00C2) )
{
return FALSE;
}
else if (INUPPERPAGES(ch))
{
return FALSE;
}
else
{
return Lex_rgFlags[(UCHAR) ch] & Lex_LowerFlag;
}
#else
return INUPPERPAGES(ch) ? FALSE : Lex_rgFlags[(UCHAR) ch] & Lex_LowerFlag;
#endif
}
__inline BOOL WINAPI CMN_IsCharAlphaW(WCHAR ch)
{
return INUPPERPAGES(ch) ? !IsUpperPunct(ch) : Lex_rgFlags[(UCHAR) ch] & (Lex_LowerFlag | Lex_UpperFlag);
}
__inline BOOL WINAPI CMN_IsCharAlphaNumericW(WCHAR ch)
{
return INUPPERPAGES(ch) ? !IsUpperPunct(ch) : Lex_rgFlags[(UCHAR) ch] & (Lex_LowerFlag | Lex_UpperFlag | Lex_DigitFlag);
}
__inline BOOL WINAPI CMN_IsCharDigitW(WCHAR ch)
{
return INUPPERPAGES(ch) ? FALSE : Lex_rgFlags[(UCHAR) ch] & Lex_DigitFlag;
}
__inline BOOL WINAPI CMN_IsCharStrictDigitW(WCHAR ch)
{ // only allows digits 0-9 - no superscripts, no fractions
return (
INUPPERPAGES(ch) ?
FALSE :
(Lex_rgFlags[(UCHAR) ch] & (Lex_DigitFlag | Lex_PunctFlag)) ==
Lex_DigitFlag
);
}
BOOL WINAPI IsUpperSpace(WCHAR ch);
__inline BOOL WINAPI CMN_IsCharSpaceW(WCHAR ch)
{
return INUPPERPAGES(ch) ?
IsUpperSpace(ch) :
Lex_rgFlags[(UCHAR) ch] & Lex_SpaceFlag;
}
__inline BOOL WINAPI CMN_IsCharPunctW(WCHAR ch)
{
return INUPPERPAGES(ch) ? IsUpperPunct(ch) : Lex_rgFlags[(UCHAR) ch] & Lex_PunctFlag;
}
__inline BOOL WINAPI CMN_IsCharPrintW(WCHAR ch)
{
return INUPPERPAGES(ch) ?
!CMN_IsCharSpaceW(ch) :
Lex_rgFlags[(UCHAR) ch] &
(Lex_PunctFlag | Lex_UpperFlag | Lex_LowerFlag | Lex_DigitFlag);
}
__inline BOOL WINAPI CMN_IsCharInLexiconW(WCHAR ch)
{
return INUPPERPAGES(ch) ?
(!IsUpperPunct(ch) || ch == 0x2019 || ch == 0x2018) :
Lex_rgFlags[(UCHAR) ch] & Lex_LexiconFlag;
}
__inline BOOL WINAPI CMN_IsCharVowelW(WCHAR ch)
{
return INUPPERPAGES(ch) ? FALSE : Lex_rgFlags[(UCHAR) ch] & Lex_VowelFlag;
}
__inline BOOL WINAPI CMN_IsCharGraphW(WCHAR ch)
{
return INUPPERPAGES(ch) ?
TRUE :
Lex_rgFlags[(UCHAR) ch] &
(Lex_LowerFlag |
Lex_UpperFlag |
Lex_DigitFlag |
Lex_PunctFlag);
}
// Some punctuation flags
#define Lex_PunctLead 0x01 /* leading punctuation */
#define Lex_PunctJoin 0x02 /* joining punctuation */
#define Lex_PunctTrail 0x04 /* trailing punctuation */
// reuse Lex_SpaceFlag here
extern const BYTE Lex_rgPunctFlags[NTRANSTAB];
__inline BOOL WINAPI CMN_IsLeadPunctW(WCHAR ch)
{
return INUPPERPAGES(ch) ?
(ch == 0x201c || ch == 0x2018) :
(Lex_rgPunctFlags[(UCHAR) ch] & Lex_PunctLead);
}
__inline BOOL WINAPI CMN_IsJoinPunctW(WCHAR ch)
{
return INUPPERPAGES(ch) ? FALSE : Lex_rgPunctFlags[(UCHAR) ch] & Lex_PunctJoin;
}
__inline BOOL WINAPI CMN_IsTrailPunctW(WCHAR ch)
{
return INUPPERPAGES(ch) ?
(ch == 0x201d || ch == 0x2019) :
(Lex_rgPunctFlags[(UCHAR) ch] & Lex_PunctTrail);
}
BOOL WINAPI IsUpperWordDelim(WCHAR ch);
__inline BOOL WINAPI CMN_IsCharWordDelimW(WCHAR ch)
{
return INUPPERPAGES(ch) ?
IsUpperWordDelim(ch) :
Lex_rgPunctFlags[(UCHAR) ch] & Lex_SpaceFlag;
}
// implementation in lexfuncs.c
WCHAR WINAPI CMN_CharUpperW(const WCHAR ch);
WCHAR WINAPI CMN_CharLowerW(const WCHAR ch);
BOOL WINAPI CMN_IsStringEqualNoCaseW(const WCHAR *pwz1, const WCHAR *pwz2);
BOOL WINAPI CMN_IsStringEqualNoCaseNumW(const WCHAR *pwz1, const WCHAR *pwz2, int cch);
DWORD WINAPI CMN_CharUpperBuffW(WCHAR *pwz, DWORD cchLength);
DWORD WINAPI CMN_CharLowerBuffW(WCHAR *pwz, DWORD cchLength);
int WINAPI CMN_CompareStringNoCaseW(const WCHAR *pwz1, const WCHAR *pwz2);
int WINAPI CMN_CompareStringNoCaseNumW(const WCHAR *pwz1, const WCHAR *pwz2, int cch);
// note that this version does not set errno on errors
long WINAPI CMN_wcstol( const wchar_t *nptr, const wchar_t * *endptr, int base );
__inline int WINAPI CMN_wtoi( const wchar_t *string )
{
return CMN_wcstol(string, NULL, 10);
}
__inline wchar_t * WINAPI CMN_wcsupr( wchar_t *string )
{
CMN_CharUpperBuffW(string, wcslen(string));
return string;
}
__inline wchar_t * WINAPI CMN_wcslwr( wchar_t *string )
{
CMN_CharLowerBuffW(string, wcslen(string));
return string;
}
////////////////////
// debug.c
/////////////////////
#if defined(_DEBUG)
extern void WINAPI DebugAssert(LPCTSTR, LPCTSTR, UINT);
extern void WINAPI SetAssertOptions(DWORD);
#else // _DEBUG
#define DebugAssert(a, b, c)
#define SetAssertOptions(a)
#endif // _DEBUG defined
/****************************************************************
These are versions of some WINAPI functions that normally don't work
on win95 with Unicode (not supported). They have the same arguments
as the API functions
If UNICODE is not defined, they become the A versions
If UNICODE is defined and x86, they become our W version
If UNICODE is defined and not x86, they become API W version
****************************************************************/
#include <sys/stat.h> // this needs to be before the redefs we do below
#include <stdlib.h> // as does this
// want to do these substitutions regardless
#define IsCharLowerW CMN_IsCharLowerW
#define IsCharUpperW CMN_IsCharUpperW
#define IsCharAlphaW CMN_IsCharAlphaW
#define IsCharAlphaNumericW CMN_IsCharAlphaNumericW
#define CharUpperBuffW CMN_CharUpperBuffW
#define CharLowerBuffW CMN_CharLowerBuffW
#define _wcsicmp CMN_CompareStringNoCaseW
#define _wcsnicmp CMN_CompareStringNoCaseNumW
#define towupper CMN_CharUpperW
#define towlower CMN_CharLowerW
#define wcstol CMN_wcstol
#define _wtoi CMN_wtoi
#define _wcsupr CMN_wcsupr
#define _wcslwr CMN_wcslwr
#undef iswdigit
#define iswdigit CMN_IsCharDigitW
#undef iswspace
#define iswspace CMN_IsCharSpaceW
#undef iswpunct
#define iswpunct CMN_IsCharPunctW
#undef iswprint
#define iswprint CMN_IsCharPrintW
#undef iswalpha
#define iswalpha CMN_IsCharAlphaW
#undef iswalnum
#define iswalnum CMN_IsCharAlphaNumericW
#undef iswgraph
#define iswgraph CMN_IsCharGraphW
#undef iswupper
#define iswupper CMN_IsCharUpperW
#undef iswlower
#define iswlower CMN_IsCharLowerW
// function defs for our versions
int WINAPI CMN_LoadStringW(HINSTANCE hModule, UINT uiId, WCHAR * wszString, int cchStringMax);
int WINAPI CMN_LoadStringWEx(HINSTANCE hModule, UINT uiId, WCHAR * wszString, int cchStringMax, LANGID lid);
// these two functions replace the associated RTL functions - however
// they can't be just replaced - as they use a third argument to maintain state
// instead of static variables within the function.
// Use these the same as the RTL functions, but declare TCHAR *pnexttoken before use
// and pass its address as the third parameter
wchar_t * WINAPI CMN_wcstok (wchar_t * string, const wchar_t * control, wchar_t **pnextoken);
char * WINAPI CMN_strtok (char * string, const char * control, char **pnextoken);
#if defined(UNICODE)
#define CMN_tcstok CMN_wcstok
#else
#define CMN_tcstok CMN_strtok
#endif
#if defined(_M_IX86) && !defined(WINCE) && !defined(NTONLY)
#define CreateFileW CMN_CreateFileW
#define LoadLibraryW CMN_LoadLibraryW
#define GetModuleFileNameW CMN_GetModuleFileNameW
#define GetFileAttributesW CMN_GetFileAttributesW
// FindResourceW works in win95
// as does FindResourceExW
//#define PostMessageW ERR_Does_not_work_in_w95 // no easy replacement for this one
#define FindWindowW ERR_No_w95_equiv_yet
#define lstrcpynW CMN_lstrcpynW
#define lstrcatW CMN_lstrcatW
#define lstrcmpiW CMN_lstrcmpiW
#define lstrcpyW CMN_lstrcpyW
#define lstrlenW CMN_lstrlenW
#define lstrcmpW CMN_lstrcmpW
#define wsprintfW swprintf
#define _wstat CMN_wstat
#define CharNextW CMN_CharNextW
#define LoadStringW CMN_LoadStringW
#define _wfopen CMN_wfopen
HANDLE WINAPI
CMN_CreateFileW (
PCWSTR pwzFileName, // pointer to name of the file
DWORD dwDesiredAccess, // access (read-write) mode
DWORD dwShareMode, // share mode
LPSECURITY_ATTRIBUTES pSecurityAttributes, // pointer to security descriptor
DWORD dwCreationDistribution, // how to create
DWORD dwFlagsAndAttributes, // file attributes
HANDLE hTemplateFile); // handle to file with attributes to copy
HINSTANCE WINAPI CMN_LoadLibraryW(const WCHAR *pwszLibraryFileName);
DWORD WINAPI CMN_GetModuleFileNameW( HINSTANCE hModule, // handle to module to find filename for
WCHAR *lpFilename, // pointer to buffer to receive module path
DWORD nSize); // size of buffer, in characters
DWORD WINAPI CMN_GetFileAttributesW(const WCHAR *lpFileName); // address of the name of a file or directory
// note: Even though WINAPI returns WCHAR *, I define this as returning void
void WINAPI CMN_lstrcpynW( WCHAR *lpString1, // address of target buffer
const WCHAR *lpString2, // address of source string
int iMaxLength); // number of bytes or characters to copy
#define CMN_lstrcmpiW _wcsicmp // just use c-runtime for now
#define CMN_lstrcpyW wcscpy
#define CMN_lstrcatW wcscat
#define CMN_lstrlenW(pwz) ((int) wcslen(pwz))
#define CMN_lstrcmpW wcscmp
#define CMN_CharNextW(pwz) (pwz + 1)
FILE *WINAPI CMN_wfopen(const WCHAR *pwzFileName, const WCHAR *pwzUnimode);
int WINAPI CMN_wstat(const WCHAR *pwzPath, struct _stat *pStatBuffer);
#else // there is no win95 - and it must be NT
#define CMN_CreateFileW CreateFileW
#define CMN_LoadLibraryW LoadLibraryW
#define CMN_GetModuleFileNameW GetModuleFileNameW
#define CMN_GetFileAttributesW GetFileAttributesW
#define CMN_lstrcpynW lstrcpynW
#define CMN_lstrcmpiW lstrcmpiW
#define CMN_lstrcpyW lstrcpyW
#define CMN_lstrcatW lstrcatW
#define CMN_lstrcmpW lstrcmpW
#define CMN_wfopen _wfopen
#define CMN_wstat _wstat
#define CMN_CharNextW CharNextW
#endif
// Outputs Readable Error String to the Debug Output
#if defined (_DEBUG)
void WINAPI CMN_OutputSystemErrA(const char *pszMsg, const char *pszComponent);
void WINAPI CMN_OutputSystemErrW(const WCHAR *pwzMsg, const WCHAR *pwzComponent);
void WINAPI CMN_OutputErrA(DWORD dwErr, const char *pszMsg, const char *pszComponent);
void WINAPI CMN_OutputErrW(DWORD dwErr, const WCHAR *pwzMsg, const WCHAR *pwzComponent);
# if defined (UNICODE)
# define CMN_OutputSystemErr CMN_OutputSystemErrW
# define CMN_OutputErr CMN_OutputErrW
# else
# define CMN_OutputSystemErr CMN_OutputSystemErrA
# define CMN_OutputErr CMN_OutputErrA
# endif
#else //!_DEBUG
# define CMN_OutputSystemErr(x, y)
# define CMN_OutputSystemErrA(x, y)
# define CMN_OutputSystemErrW(x, y)
# define CMN_OutputErr(n, x, y)
# define CMN_OutputErrA(n, x, y)
# define CMN_OutputErrW(n, x, y)
#endif
///////////////////////
// LexWin95.c
///////////////////////
#define LoadLibraryW2A CMN_LoadLibraryW
#define CreateFileW2A CMN_CreateFileW
// Add anything new here, within the extern "C" clause
#ifdef __cplusplus
} // ends the extern "C" clause
// here's some C++ specific stuff
inline BOOL IsMapFileUnicode(PMFILE pmf, BOOL fDefault=TRUE)
{
if (pmf->hFileMap)
return pmf->fSrcUnicode;
// must be zero length, set and return default
return pmf->fSrcUnicode = fDefault;
}
inline void MapFileCodePage(PMFILE pmf, UINT uCP)
{
pmf->uCodePage = uCP;
}
#if defined(CPPMEMORY)
inline void * _cdecl operator new (size_t size)
{
#if defined(DEBUG)
return dbgMalloc(size);
#else
return LocalAlloc( LMEM_FIXED, size );
#endif
}
inline void _cdecl operator delete(void *pMem)
{
if (!pMem)
return;
#if defined(DEBUG)
dbgFree(pMem);
#else
LocalFree(pMem);
#endif
}
#endif // CPPMEMORY
#endif // __cplusplus
#endif // _NLGLIB_H_
Reference in a new issue View git blame Copy permalink