You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1403 lines
40 KiB
1403 lines
40 KiB
/****************************** Module Header ******************************\
|
|
* Module Name: hsparse.c
|
|
*
|
|
* Copyright (c) 1985-96, Microsoft Corporation
|
|
*
|
|
* 09/05/96 GerardoB Created
|
|
\***************************************************************************/
|
|
#include "hsplit.h"
|
|
/***************************************************************************\
|
|
* Globals
|
|
\***************************************************************************/
|
|
/*
|
|
* #if - #endif strings
|
|
* Compatibility: no space after #if and ( -- breaks wcshdr.exe
|
|
*/
|
|
static char gszIfStart [] = "\r\n#if(" ;
|
|
static char gszIfStop [] = ")";
|
|
static char gszDefCompOperator [] = ">=";
|
|
static char gszLessThan [] = "<";
|
|
static char gszEndStart [] = "\r\n#endif /* ";
|
|
static char gszEndStop [] = " */";
|
|
|
|
static char gszNewLine [] = "\r\n";
|
|
/*********************************************************************
|
|
* hsWriteNewLine
|
|
\***************************************************************************/
|
|
__inline BOOL hsWriteNewLine (DWORD dwMask)
|
|
{
|
|
return hsWriteHeaderFiles(gszNewLine, sizeof(gszNewLine)-1, dwMask);
|
|
}
|
|
/***************************************************************************\
|
|
* hsFindFirstSubTag
|
|
\***************************************************************************/
|
|
char * hsFindFirstSubTag(char * pmap)
|
|
{
|
|
/*
|
|
* pmap points to the beginning of the tag marker. So skip it
|
|
* and any spaces after it
|
|
*/
|
|
pmap += gdwTagMarkerSize;
|
|
while (pmap < gpmapEnd) {
|
|
if (*pmap == ' ') {
|
|
pmap++;
|
|
} else {
|
|
return pmap;
|
|
}
|
|
}
|
|
|
|
hsLogMsg(HSLM_EOFERROR, "hsFindFirstSubTag");
|
|
return NULL;
|
|
}
|
|
/*********************************************************************
|
|
* hsFindFirstCharInString
|
|
*
|
|
* Finds the first occurrence of any character in psz
|
|
\***************************************************************************/
|
|
char * hsFindFirstCharInString (char * pmap, char * psz)
|
|
{
|
|
char * pszNext;
|
|
|
|
while (pmap < gpmapEnd) {
|
|
/*
|
|
* Compare current char to all chars in psz
|
|
*/
|
|
pszNext = psz;
|
|
do {
|
|
if (*pmap == *pszNext++) {
|
|
return pmap;
|
|
}
|
|
} while (*pszNext != '\0');
|
|
|
|
pmap++;
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
/*********************************************************************
|
|
* hsFindEndOfString
|
|
\***************************************************************************/
|
|
__inline char * hsFindEndOfString (char * pmap)
|
|
{
|
|
return hsFindFirstCharInString(pmap, " " "\r");
|
|
}
|
|
/***************************************************************************\
|
|
* hsIsString
|
|
\***************************************************************************/
|
|
BOOL hsIsString (char * pmap, char * psz)
|
|
{
|
|
while (*psz != '\0') {
|
|
if (pmap >= gpmapEnd) {
|
|
return FALSE;
|
|
}
|
|
if (*pmap++ != *psz++) {
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
/***************************************************************************\
|
|
* hsFindTagMarker
|
|
\***************************************************************************/
|
|
char * hsFindTagMarker(char * pmap, char ** ppmapLineStart)
|
|
{
|
|
char * pmapMarker;
|
|
|
|
while (pmap < gpmapEnd) {
|
|
/*
|
|
* If this is the first character of the marker
|
|
*/
|
|
if (*pmap == *gpszTagMarker) {
|
|
/*
|
|
* If this is the marker, find the last one in this line
|
|
*/
|
|
if (hsIsString(pmap + 1, gpszTagMarker + 1)) {
|
|
pmapMarker = pmap++;
|
|
do {
|
|
/*
|
|
* Find the EOL or the first char of the next marker
|
|
*/
|
|
pmap = hsFindFirstCharInString(pmap, gszMarkerCharAndEOL);
|
|
/*
|
|
* If EOL or end of map, return
|
|
*/
|
|
if ((pmap == NULL) || (*pmap != *gpszTagMarker)) {
|
|
return pmapMarker;
|
|
}
|
|
/*
|
|
* If this is the marker, update pmapMarker
|
|
*/
|
|
if (hsIsString(pmap + 1, gpszTagMarker + 1)) {
|
|
pmapMarker = pmap;
|
|
}
|
|
/*
|
|
* It wasn't a marker, keep looking for EOL
|
|
*/
|
|
pmap++;
|
|
} while (TRUE);
|
|
} else {
|
|
/*
|
|
* This wasn't the marker, continue parsing
|
|
*/
|
|
pmap++;
|
|
continue;
|
|
}
|
|
} /* if (*pmap == *gpszTagMarker) */
|
|
|
|
/*
|
|
* If this is the end of a line, update *ppmapLineStart and
|
|
* gdwLineNumber. The line begins before the EOL
|
|
*/
|
|
if (*pmap++ == '\r') {
|
|
if (pmap >= gpmapEnd) {
|
|
hsLogMsg(HSLM_EOFERROR, "hsFindTagMarker");
|
|
return NULL;
|
|
}
|
|
if (*pmap++ != '\n') {
|
|
hsLogMsg(HSLM_ERROR, "Missing \\n after \\r");
|
|
return FALSE;
|
|
}
|
|
*ppmapLineStart = pmap - 2;
|
|
gdwLineNumber++;
|
|
continue;
|
|
}
|
|
} /* while (pmap < pmapEnd) */
|
|
|
|
return NULL;
|
|
}
|
|
/***************************************************************************\
|
|
* hsSkipTag
|
|
\***************************************************************************/
|
|
char * hsSkipTag(char * pmap)
|
|
{
|
|
|
|
while (pmap < gpmapEnd) {
|
|
switch (*pmap) {
|
|
case '_':
|
|
case ' ':
|
|
case '\r':
|
|
return pmap;
|
|
|
|
default:
|
|
pmap++;
|
|
}
|
|
}
|
|
|
|
hsLogMsg(HSLM_EOFERROR, "hsSkipTag");
|
|
return NULL;
|
|
}
|
|
/***************************************************************************\
|
|
* hsSkipEmptyLines
|
|
* If there are multiple empty lines, skip all but one
|
|
\***************************************************************************/
|
|
char * hsSkipEmptyLines(char * pmap)
|
|
{
|
|
char * pmapCurrentLine, *pmapLastEmptyLine;
|
|
|
|
pmapCurrentLine = pmapLastEmptyLine = pmap;
|
|
pmap++;
|
|
while (pmap < gpmapEnd) {
|
|
switch (*pmap) {
|
|
case '\r':
|
|
gdwLineNumber++;
|
|
pmapLastEmptyLine = pmapCurrentLine;
|
|
pmapCurrentLine = pmap;
|
|
|
|
case '\n':
|
|
case ' ':
|
|
pmap++;
|
|
break;
|
|
|
|
default:
|
|
/*
|
|
* If we've found more than one line,
|
|
* adjust line number since we're not skipping
|
|
* the last line we found
|
|
*/
|
|
if (pmapCurrentLine != pmapLastEmptyLine) {
|
|
gdwLineNumber--;
|
|
}
|
|
return pmapLastEmptyLine;
|
|
}
|
|
}
|
|
|
|
return gpmapEnd;
|
|
|
|
}
|
|
/***************************************************************************\
|
|
* hsIsEmpty
|
|
* Returns TRUE if there is nothing but spaces and \r\n
|
|
\***************************************************************************/
|
|
BOOL hsIsEmpty(char * pmap, char * pmapEnd)
|
|
{
|
|
while (pmap < pmapEnd) {
|
|
switch (*pmap++) {
|
|
case '\n':
|
|
case '\r':
|
|
case ' ':
|
|
break;
|
|
|
|
default:
|
|
return FALSE;
|
|
}
|
|
}
|
|
return TRUE;
|
|
}
|
|
/***************************************************************************\
|
|
* hsLastRealChar
|
|
* Returns a pointer past the last non-space non-line-break char.
|
|
* If there are multiple empty lines, returns a pointer past the last line break
|
|
\***************************************************************************/
|
|
char * hsLastRealChar(char * pmapLinesStart, char * pmap)
|
|
{
|
|
|
|
char * pmapCurrentLine, *pmapLastEmptyLine;
|
|
|
|
pmap--;
|
|
pmapCurrentLine = pmapLastEmptyLine = NULL;
|
|
while (pmapLinesStart < pmap) {
|
|
switch (*pmap) {
|
|
case '\n':
|
|
pmapLastEmptyLine = pmapCurrentLine;
|
|
pmapCurrentLine = pmap;
|
|
case '\r':
|
|
case ' ':
|
|
pmap--;
|
|
break;
|
|
|
|
default:
|
|
goto FoundIt;
|
|
}
|
|
}
|
|
|
|
FoundIt:
|
|
/*
|
|
* If we found multiple lines or spaces,
|
|
* then return a pointer to the last empty line
|
|
* else if we didn't reach pmapLinesStart, we're at the last real char
|
|
* else we're on an empty line
|
|
*/
|
|
if (pmapLastEmptyLine != pmapCurrentLine) {
|
|
if (pmapLastEmptyLine != NULL) {
|
|
return pmapLastEmptyLine + 1;
|
|
} else {
|
|
return pmapCurrentLine + 1;
|
|
}
|
|
} else if (pmap > pmapLinesStart) {
|
|
return pmap + 1;
|
|
} else {
|
|
return pmapLinesStart;
|
|
}
|
|
|
|
}
|
|
/***************************************************************************\
|
|
* hsFindEOL
|
|
*
|
|
\***************************************************************************/
|
|
char * hsFindEOL(char * pmap)
|
|
{
|
|
while (pmap < gpmapEnd) {
|
|
if (*pmap++ == '\r') {
|
|
if (pmap >= gpmapEnd) {
|
|
hsLogMsg(HSLM_EOFERROR, "hsFindEOL");
|
|
return NULL;
|
|
}
|
|
if (*pmap != '\n') {
|
|
hsLogMsg(HSLM_ERROR, "Missing \\n after \\r");
|
|
return NULL;
|
|
}
|
|
gdwLineNumber++;
|
|
return pmap - 1;
|
|
}
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
/***************************************************************************\
|
|
* hsFindTagInList
|
|
*
|
|
\***************************************************************************/
|
|
PHSTAG hsFindTagInList (PHSTAG phst, char * pmapTag, DWORD dwTagSize)
|
|
{
|
|
|
|
while (phst->dwLabelSize != 0) {
|
|
|
|
if ((phst->dwLabelSize == dwTagSize)
|
|
&& !_strnicmp(phst->pszLabel, pmapTag, dwTagSize)) {
|
|
|
|
return phst;
|
|
}
|
|
phst++;
|
|
}
|
|
|
|
return NULL;
|
|
|
|
}
|
|
/***************************************************************************\
|
|
* hsSkipBlockTagIfPresent
|
|
*
|
|
\***************************************************************************/
|
|
char * hsSkipBlockTagIfPresent (char * pmap, DWORD * pdwMask)
|
|
{
|
|
static char gszBegin [] = "begin";
|
|
static char gszEnd [] = "end";
|
|
|
|
char * pmapTag;
|
|
DWORD dwTagSize;
|
|
PHSTAG phst;
|
|
|
|
/*
|
|
* Remember the beginning of the tag
|
|
*/
|
|
pmapTag = pmap;
|
|
|
|
/*
|
|
* Compatibility. Deal with old lt? and bt? switches.
|
|
* If the whole tag was added to the tag list, get the flags
|
|
* and stop parsing.
|
|
*/
|
|
if (gdwOptions & (HSO_USERBLOCK | HSO_USERHEADERTAG)) {
|
|
pmap = hsFindEndOfString(pmap);
|
|
if ((pmap != NULL) && (pmap != pmapTag)) {
|
|
phst = hsFindTagInList (gphst, pmapTag, (DWORD)(pmap - pmapTag));
|
|
if (phst != NULL) {
|
|
*pdwMask |= phst->dwMask;
|
|
return pmap;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Didn't find the string in the table so restore pmap and continue
|
|
*/
|
|
pmap = pmapTag;
|
|
}
|
|
|
|
|
|
/*
|
|
* Find the end of the current tag
|
|
*/
|
|
pmap = hsSkipTag(pmap);
|
|
if ((pmap == NULL) || (pmap == pmapTag)) {
|
|
return pmap;
|
|
}
|
|
|
|
dwTagSize = (DWORD)(pmap - pmapTag);
|
|
|
|
/*
|
|
* If at separator, skip so the caller won't have to deal with it
|
|
*/
|
|
if (*pmap == '_') {
|
|
pmap++;
|
|
}
|
|
|
|
/*
|
|
* begin tag
|
|
*/
|
|
if ((HSCSZSIZE(gszBegin) == dwTagSize)
|
|
&& !_strnicmp(gszBegin, pmapTag, dwTagSize)) {
|
|
|
|
*pdwMask |= HST_BEGIN;
|
|
return pmap;
|
|
}
|
|
|
|
/*
|
|
* end tag
|
|
*/
|
|
if ((HSCSZSIZE(gszEnd) == dwTagSize)
|
|
&& !_strnicmp(gszEnd, pmapTag, dwTagSize)) {
|
|
|
|
*pdwMask |= HST_END;
|
|
return pmap;
|
|
}
|
|
|
|
return pmapTag;
|
|
|
|
}
|
|
/***************************************************************************\
|
|
* hsPopBlock
|
|
*
|
|
\***************************************************************************/
|
|
BOOL hsPopBlock (void)
|
|
{
|
|
/*
|
|
* Check for underflow
|
|
*/
|
|
if (gphsbStackTop <= ghsbStack) {
|
|
hsLogMsg(HSLM_ERROR, "Block stack underflow!");
|
|
return FALSE;
|
|
}
|
|
|
|
if (gphsbStackTop->pszifLabel != NULL) {
|
|
LocalFree(gphsbStackTop->pszifLabel);
|
|
}
|
|
|
|
gphsbStackTop--;
|
|
|
|
return TRUE;
|
|
}
|
|
/***************************************************************************\
|
|
* hsPushBlock
|
|
*
|
|
\***************************************************************************/
|
|
BOOL hsPushBlock(void)
|
|
{
|
|
/*
|
|
* Make sure we got room in the block stack
|
|
*/
|
|
if (gphsbStackTop >= HSBSTACKLIMIT) {
|
|
hsLogMsg(HSLM_ERROR, "Too many nested blocks. Artificial limit:%#lx", HSBSTACKSIZE);
|
|
return FALSE;
|
|
}
|
|
|
|
/*
|
|
* Grow the stack and initialize the new entry
|
|
*/
|
|
gphsbStackTop++;
|
|
ZeroMemory(gphsbStackTop, sizeof(*gphsbStackTop));
|
|
gphsbStackTop->dwLineNumber = gdwLineNumber;
|
|
|
|
/*
|
|
* propagate the mask
|
|
*/
|
|
gphsbStackTop->dwMask |= (gphsbStackTop - 1)->dwMask;
|
|
|
|
return TRUE;
|
|
}
|
|
/***************************************************************************\
|
|
* hsSkipBlock
|
|
*
|
|
\***************************************************************************/
|
|
char * hsSkipBlock(char * pmap)
|
|
{
|
|
char * pmapLineStart;
|
|
DWORD dwMask;
|
|
|
|
while (pmap < gpmapEnd) {
|
|
/*
|
|
* Find the next marker (; by default)
|
|
*/
|
|
pmap = hsFindTagMarker(pmap, &pmapLineStart);
|
|
if (pmap == NULL) {
|
|
return NULL;
|
|
}
|
|
|
|
/*
|
|
* Skip the marker and any spaces after it
|
|
*/
|
|
pmap = hsFindFirstSubTag(pmap);
|
|
if (pmap == NULL) {
|
|
return NULL;
|
|
}
|
|
|
|
/*
|
|
* Check if this is the beginning-end of a block
|
|
*/
|
|
dwMask = 0;
|
|
pmap = hsSkipBlockTagIfPresent(pmap, &dwMask);
|
|
if (pmap == NULL) {
|
|
return NULL;
|
|
}
|
|
|
|
/*
|
|
* If it found the beginning of another block, push it in the
|
|
* the stack and skip it.
|
|
*/
|
|
if (dwMask & HST_BEGIN) {
|
|
if (!hsPushBlock()) {
|
|
return NULL;
|
|
}
|
|
pmap = hsSkipBlock(pmap);
|
|
if (pmap == NULL) {
|
|
return NULL;
|
|
}
|
|
} else if (dwMask & HST_END) {
|
|
/*
|
|
* It found the end of the block; pop it out of the stack
|
|
* and return the beginning of the next line
|
|
*/
|
|
if (!hsPopBlock()) {
|
|
return NULL;
|
|
}
|
|
return hsFindEOL(pmap);
|
|
}
|
|
|
|
/*
|
|
* It wasn't a block tag so keep going
|
|
*/
|
|
pmap++;
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
/***************************************************************************\
|
|
* hsBuildifString
|
|
*
|
|
\***************************************************************************/
|
|
BOOL hsBuildifString(char * pString, DWORD dwStringSize, char * pCompOperator, DWORD dwCompOperatorSize)
|
|
{
|
|
char * psz;
|
|
|
|
/*
|
|
* Use default operator if none was provided.
|
|
*/
|
|
if (pCompOperator == NULL) {
|
|
pCompOperator = gszDefCompOperator;
|
|
dwCompOperatorSize = HSCSZSIZE(gszDefCompOperator);
|
|
}
|
|
|
|
/*
|
|
* Make a NULL terminated copy. Allocate enough space for the
|
|
* "label CompOperator version" string: 2 spaces + 10 digits (0xl#) +
|
|
* null termination
|
|
*/
|
|
psz = (char *) LocalAlloc(LPTR, dwStringSize + dwCompOperatorSize + 13);
|
|
if (psz == NULL) {
|
|
hsLogMsg(HSLM_APIERROR, "LocalAlloc");
|
|
hsLogMsg(HSLM_ERROR, "hsBuildifString allocation failed. Size:%#lx", dwStringSize+ dwCompOperatorSize + 13);
|
|
return FALSE;
|
|
}
|
|
|
|
/*
|
|
* Save it in the stack.
|
|
*/
|
|
gphsbStackTop->pszifLabel = psz;
|
|
|
|
/*
|
|
* Build the string (the right side of the comparison (version) will
|
|
* be added later when available.
|
|
*/
|
|
strncpy(psz, pString, dwStringSize);
|
|
psz += dwStringSize;
|
|
*psz++ = ' ';
|
|
strncpy(psz, pCompOperator, dwCompOperatorSize);
|
|
psz += dwCompOperatorSize;
|
|
*psz++ = ' ';
|
|
|
|
return TRUE;
|
|
}
|
|
/***************************************************************************\
|
|
* hsParseAndBuildifString
|
|
*
|
|
\***************************************************************************/
|
|
char * hsParseAndBuildifString(char * pmap, BOOL fSkip)
|
|
{
|
|
BOOL fEnclosed;
|
|
char * pmapTag, * pCompOperator;
|
|
DWORD dwTagSize, dwCompOperatorSize;
|
|
|
|
/*
|
|
* Skip the tag concatenator (_)
|
|
*/
|
|
if (*pmap++ != '_') {
|
|
hsLogMsg(HSLM_ERROR, "Expected '_' after if tag");
|
|
return NULL;
|
|
}
|
|
|
|
if (pmap >= gpmapEnd) {
|
|
hsLogMsg(HSLM_EOFERROR, "hsParseAndBuildifString");
|
|
return NULL;
|
|
}
|
|
|
|
/*
|
|
* Find the end of the string. If it starts wiht '(', then the string
|
|
* is enclosed in parens. This is for strings that use _ (like _WIN32_WINDOWS)
|
|
*/
|
|
pmapTag = pmap;
|
|
fEnclosed = (*pmap == '(');
|
|
if (fEnclosed) {
|
|
pmapTag = ++pmap;
|
|
pmap = hsFindFirstCharInString(pmap, ")" " " "\r");
|
|
if ((pmap == NULL) || (*pmap != ')')) {
|
|
hsLogMsg(HSLM_ERROR, "Expected ')' after if_(");
|
|
return NULL;
|
|
}
|
|
} else {
|
|
pmap = hsSkipTag(pmap);
|
|
if ((pmap == NULL) || (pmap == pmapTag)) {
|
|
hsLogMsg(HSLM_ERROR, "Expected string after if_");
|
|
return NULL;
|
|
}
|
|
}
|
|
dwTagSize = (DWORD)(pmap - pmapTag);
|
|
|
|
|
|
/*
|
|
* Skip the ')'
|
|
*/
|
|
if (fEnclosed) {
|
|
pmap++;
|
|
if (pmap >= gpmapEnd) {
|
|
hsLogMsg(HSLM_EOFERROR, "hsParseAndBuildifString");
|
|
return NULL;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* If a comparison operator follows, use it
|
|
*/
|
|
if ((pmap + 1 < gpmapEnd) && (*pmap == '_')) {
|
|
switch (*(pmap + 1)) {
|
|
case '=':
|
|
case '>':
|
|
case '<':
|
|
pCompOperator = ++pmap;
|
|
pmap = hsSkipTag(pmap);
|
|
if ((pmap == NULL) || (pmap == pCompOperator)) {
|
|
hsLogMsg(HSLM_EOFERROR, "hsParseAndBuildifString");
|
|
return NULL;
|
|
}
|
|
dwCompOperatorSize = (DWORD)(pmap - pCompOperator);
|
|
break;
|
|
|
|
default:
|
|
pCompOperator = NULL;
|
|
break;
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
* Build the stirng a copy it into the block stack
|
|
*/
|
|
if (!fSkip) {
|
|
if (!hsBuildifString(pmapTag, (DWORD)dwTagSize, pCompOperator, (DWORD)dwCompOperatorSize)) {
|
|
return NULL;
|
|
}
|
|
}
|
|
|
|
return pmap;
|
|
|
|
}
|
|
/***************************************************************************\
|
|
* hsMapOldTag
|
|
*
|
|
\***************************************************************************/
|
|
BOOL hsMapOldTag(char * pmapTag, DWORD dwTagSize, DWORD * pdwTagMask, DWORD * pdwVersion)
|
|
{
|
|
static char gszifWinver [] = "WINVER";
|
|
static char gszif_WIN32_WINDOWS [] = "_WIN32_WINDOWS";
|
|
static char gszif_WIN32_WINNT [] = "_WIN32_WINNT";
|
|
|
|
char * pszLabel;
|
|
UINT uSize;
|
|
|
|
/*
|
|
* Old tags must have a block or header bit set. Otherwise, they
|
|
* should be ignored
|
|
*/
|
|
if (!(*pdwTagMask & (HST_BOTH | HST_BLOCK))) {
|
|
*pdwTagMask |= HST_IGNORE;
|
|
return TRUE;
|
|
}
|
|
|
|
/*
|
|
* No mapping needed if at the end of a block or HST_SKIP is the only
|
|
* additional flag set.
|
|
*/
|
|
if ((*pdwTagMask & HST_END)
|
|
|| ((*pdwTagMask & ~(HST_BLOCK | HST_USERBLOCK | HST_BOTH | HST_USERHEADERTAG))
|
|
== (HST_SKIP | HST_MAPOLD))) {
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
/*
|
|
* winver maps to if_winver
|
|
*/
|
|
if (*pdwTagMask & HST_WINVER) {
|
|
|
|
/*
|
|
* Compatibility
|
|
*/
|
|
if (!(gdwOptions & HSO_OLDPROJSW_4)
|
|
&& (*pdwTagMask & HST_INTERNAL)
|
|
&& !(gdwOptions & HSO_OLDPROJSW_E)) {
|
|
|
|
*pdwTagMask |= HST_SKIP;
|
|
return TRUE;
|
|
}
|
|
|
|
pszLabel = gszifWinver;
|
|
uSize = HSCSZSIZE(gszifWinver);
|
|
goto AddIf;
|
|
}
|
|
|
|
/*
|
|
* nashville maps to if_(_WIN32_WINDOWS)_40a
|
|
*/
|
|
if ((dwTagSize == HSCSZSIZE(gszNashville)) && !_strnicmp(pmapTag, gszNashville, dwTagSize)) {
|
|
|
|
*pdwVersion = 0x40a;
|
|
pszLabel = gszif_WIN32_WINDOWS;
|
|
uSize = HSCSZSIZE(gszif_WIN32_WINDOWS);
|
|
goto AddIf;
|
|
}
|
|
/*
|
|
* sur and surplus map to if_(_WIN32_WINNT)_400 if public
|
|
*/
|
|
if ((dwTagSize == HSCSZSIZE(gszSur)) && !_strnicmp(pmapTag, gszSur, dwTagSize)
|
|
|| (dwTagSize == HSCSZSIZE(gszSurplus)) && !_strnicmp(pmapTag, gszSurplus, dwTagSize)) {
|
|
|
|
if (*pdwTagMask & HST_INTERNAL) {
|
|
return TRUE;
|
|
}
|
|
|
|
*pdwVersion = 0x400;
|
|
pszLabel = gszif_WIN32_WINNT;
|
|
uSize = HSCSZSIZE(gszif_WIN32_WINNT);
|
|
goto AddIf;
|
|
}
|
|
/*
|
|
* 35 is excluded when building for old switch e and p
|
|
*/
|
|
if ((dwTagSize == HSCSZSIZE(gsz35)) && !_strnicmp(pmapTag, gsz35, dwTagSize)) {
|
|
|
|
*pdwTagMask |= HST_SKIP;
|
|
return TRUE;
|
|
}
|
|
|
|
return TRUE;
|
|
|
|
AddIf:
|
|
*pdwTagMask |= HST_IF;
|
|
/*
|
|
* If we're not in a block, push one to save the string
|
|
*/
|
|
if (!(*pdwTagMask & HST_BEGIN)) {
|
|
if (!hsPushBlock()) {
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
if (!hsBuildifString(pszLabel, uSize, NULL, 0)) {
|
|
return FALSE;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
/***************************************************************************\
|
|
* hsParseTag
|
|
*
|
|
\***************************************************************************/
|
|
DWORD hsParseTag(char * pmap, DWORD * pdwVersion)
|
|
{
|
|
char * pmapTag;
|
|
DWORD dwTagMask = HST_DEFAULT;
|
|
DWORD dwTagSize;
|
|
PHSTAG phst;
|
|
|
|
*pdwVersion = 0;
|
|
|
|
/*
|
|
* Skip the marker and any spaces after it
|
|
*/
|
|
pmap = hsFindFirstSubTag(pmap);
|
|
if (pmap == NULL) {
|
|
return HST_DEFAULT;
|
|
}
|
|
|
|
/*
|
|
* Check for begin-end of block
|
|
*/
|
|
pmap = hsSkipBlockTagIfPresent(pmap, &dwTagMask);
|
|
if (pmap == NULL) {
|
|
return HST_DEFAULT;
|
|
}
|
|
|
|
/*
|
|
* If this the beginning of a block, push in the stack
|
|
* skip the tag concatenator (_)
|
|
*/
|
|
if (dwTagMask & HST_BEGIN) {
|
|
if (!hsPushBlock()) {
|
|
return HST_ERROR;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Build tag mask. Tags are concatenated by underscores (_); each
|
|
* iteration of this loop processes one "sub-tag"
|
|
*/
|
|
do {
|
|
/*
|
|
* Find current tag end. Bail if at last one.
|
|
*/
|
|
pmapTag = pmap;
|
|
pmap = hsSkipTag(pmap);
|
|
if ((pmap == NULL) || (pmap == pmapTag)) {
|
|
break;
|
|
}
|
|
|
|
/*
|
|
* Look up the tag
|
|
*/
|
|
dwTagSize = (DWORD)(pmap - pmapTag);
|
|
phst = hsFindTagInList (gphst, pmapTag, dwTagSize);
|
|
if (phst != NULL) {
|
|
dwTagMask |= phst->dwMask;
|
|
/*
|
|
* Compatibility
|
|
* If this is an old tag, map it.
|
|
* No mapping needed if doing split only (tag is going to be
|
|
* ignored)
|
|
*/
|
|
if ((dwTagMask & HST_MAPOLD)
|
|
&& !(gdwOptions & HSO_SPLITONLY)) {
|
|
|
|
if (!hsMapOldTag(pmapTag, dwTagSize, &dwTagMask, pdwVersion)) {
|
|
return HST_ERROR;
|
|
}
|
|
|
|
} else {
|
|
/*
|
|
* If this is an if tag, copy the block string
|
|
*/
|
|
if (phst->dwMask & HST_IF) {
|
|
BOOL fEndBlock;
|
|
/*
|
|
* If not in a block, push a fake one in to save the string
|
|
*/
|
|
if (!(dwTagMask & HST_BLOCK)) {
|
|
if (!hsPushBlock()) {
|
|
return HST_ERROR;
|
|
}
|
|
}
|
|
/*
|
|
* If we're at the end of a block, we want to skip
|
|
* the if string (already taken care of at begin tag)
|
|
*/
|
|
fEndBlock = (dwTagMask & HST_END);
|
|
if (fEndBlock) {
|
|
dwTagMask &= ~HST_IF;
|
|
}
|
|
pmap = hsParseAndBuildifString(pmap, fEndBlock);
|
|
if (pmap == NULL) {
|
|
return HST_ERROR;
|
|
}
|
|
}
|
|
} /* if ((dwTagMask & HST_MAPOLD)... */
|
|
} else {
|
|
/*
|
|
* If this is not the version number, then this is an unkown tag
|
|
*/
|
|
if (!hsVersionFromString (pmapTag, dwTagSize, pdwVersion)) {
|
|
dwTagMask |= HST_UNKNOWN;
|
|
}
|
|
} /* if (phst != NULL) */
|
|
|
|
} while (*pmap++ == '_');
|
|
|
|
/*
|
|
* Bail if we didn't find any tags
|
|
*/
|
|
if (dwTagMask == HST_DEFAULT) {
|
|
return HST_DEFAULT;
|
|
}
|
|
|
|
/*
|
|
* Unknown tags are to be skipped or ignored
|
|
*/
|
|
if (dwTagMask & HST_UNKNOWN) {
|
|
if (gdwOptions & HSO_SKIPUNKNOWN) {
|
|
dwTagMask |= HST_SKIP;
|
|
} else {
|
|
goto IgnoreTag;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Ignore the tag if marked as such
|
|
*/
|
|
if (dwTagMask & HST_IGNORE) {
|
|
goto IgnoreTag;
|
|
}
|
|
|
|
/*
|
|
* Compatibility hack. public_winver_40a is not included for old -n and
|
|
* it's internal for old -e. 400 is goes to both headers for -n
|
|
*/
|
|
if (dwTagMask & HST_WINVER) {
|
|
if (*pdwVersion == 0x40a) {
|
|
if (gdwOptions & HSO_OLDPROJSW_E) {
|
|
dwTagMask |= HST_INTERNAL;
|
|
dwTagMask &= ~HST_PUBLIC;
|
|
} else if (gdwOptions & HSO_OLDPROJSW_N) {
|
|
dwTagMask |= HST_SKIP;
|
|
}
|
|
} else if ((*pdwVersion == 0x400)
|
|
&& (gdwOptions & HSO_OLDPROJSW_N)) {
|
|
|
|
dwTagMask |= HST_INTERNALNOTCOMP | HST_BOTH;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* if using old lt2, ltb, bt2 or btb switches,
|
|
* then both/internal tag/block must be skipped
|
|
*/
|
|
if ((gdwOptions & (HSO_USERBLOCK | HSO_USERHEADERTAG))
|
|
&& !(dwTagMask & ~(HST_BLOCK | HST_BOTH))) {
|
|
|
|
if ((gdwOptions & HSO_USERINTERNALBLOCK)
|
|
&& ((dwTagMask == (HST_BEGIN | HST_INTERNAL))
|
|
|| (dwTagMask == (HST_END | HST_INTERNAL)))) {
|
|
|
|
dwTagMask &= HST_BLOCK;
|
|
dwTagMask |= HST_SKIP;
|
|
|
|
} else if ((gdwOptions & HSO_USERBOTHBLOCK)
|
|
&& ((dwTagMask == (HST_BEGIN | HST_BOTH))
|
|
|| (dwTagMask == (HST_END | HST_BOTH)))) {
|
|
|
|
dwTagMask &= HST_BLOCK;
|
|
dwTagMask |= HST_SKIP;
|
|
|
|
} else if ((gdwOptions & HSO_USERINTERNALTAG)
|
|
&& (dwTagMask == HST_INTERNAL)) {
|
|
|
|
dwTagMask = HST_SKIP;
|
|
|
|
} else if ((gdwOptions & HSO_USERBOTHTAG)
|
|
&& (dwTagMask == HST_BOTH)) {
|
|
|
|
dwTagMask = HST_SKIP;
|
|
}
|
|
} /* if ((gdwOptions & (HSO_USERBLOCK | HSO_USERHEADERTAG))... */
|
|
|
|
|
|
/*
|
|
* If doing split only, anything other than both/internal is treated
|
|
* as untagged. If we pushed a block, pop it out as it will be ignored
|
|
*/
|
|
if (gdwOptions & HSO_SPLITONLY) {
|
|
if (dwTagMask & ~(HST_BLOCK | HST_USERBLOCK | HST_BOTH | HST_USERHEADERTAG)) {
|
|
goto IgnoreTag;
|
|
}
|
|
*pdwVersion = 0;
|
|
}
|
|
|
|
|
|
/*
|
|
* If this is the beginning of a block, save the mask in the block stack
|
|
*/
|
|
if (dwTagMask & HST_BEGIN) {
|
|
gphsbStackTop->dwMask |= dwTagMask;
|
|
}
|
|
|
|
return dwTagMask;
|
|
|
|
|
|
IgnoreTag:
|
|
/*
|
|
* If a block was pushed, pop it out.
|
|
*/
|
|
if (dwTagMask & HST_BEGIN) {
|
|
if (!hsPopBlock()) {
|
|
return HST_ERROR;
|
|
}
|
|
}
|
|
|
|
*pdwVersion = 0;
|
|
return HST_DEFAULT;
|
|
|
|
}
|
|
/***************************************************************************\
|
|
* hsBeginEndBlock
|
|
*
|
|
\***************************************************************************/
|
|
BOOL hsBeginEndBlock (DWORD dwMask, DWORD dwVersion)
|
|
{
|
|
|
|
char * psz;
|
|
UINT uPasses;
|
|
|
|
/*
|
|
* Compatibility. If writting this block to the internal header
|
|
* using the not comp (ie., from >= to <), then do two passes
|
|
* writing one header each time.
|
|
*/
|
|
if (dwMask & HST_INTERNALNOTCOMP) {
|
|
uPasses = 2;
|
|
if (dwMask & HST_BEGIN) {
|
|
/*
|
|
* Write public header first
|
|
*/
|
|
dwMask &= ~HST_INTERNAL;
|
|
} else {
|
|
/*
|
|
* Write internal header first
|
|
*/
|
|
dwMask &= ~HST_PUBLIC;
|
|
}
|
|
} else {
|
|
uPasses = 1;
|
|
}
|
|
|
|
/*
|
|
* Add version to the string
|
|
*/
|
|
if (dwMask & HST_BEGIN) {
|
|
|
|
/*
|
|
* Beginning of block or if
|
|
* If there is no if string, done
|
|
*/
|
|
if (gphsbStackTop->pszifLabel == NULL) {
|
|
return TRUE;
|
|
}
|
|
|
|
/*
|
|
* Something is fishy is dwVersion is 0
|
|
*/
|
|
if (dwVersion == 0) {
|
|
hsLogMsg(HSLM_ERROR, "if tag without version");
|
|
return FALSE;
|
|
}
|
|
sprintf(gphsbStackTop->pszifLabel + strlen(gphsbStackTop->pszifLabel),
|
|
"%#06lx", dwVersion);
|
|
|
|
}
|
|
|
|
|
|
/*
|
|
* Write headers
|
|
*/
|
|
do {
|
|
if (dwMask & HST_BEGIN) {
|
|
|
|
/*
|
|
* Write #if to output file
|
|
*/
|
|
if (!hsWriteHeaderFiles(gszIfStart, HSCSZSIZE(gszIfStart), dwMask)
|
|
|| !hsWriteHeaderFiles(gphsbStackTop->pszifLabel, lstrlen(gphsbStackTop->pszifLabel), dwMask)
|
|
|| !hsWriteHeaderFiles(gszIfStop, HSCSZSIZE(gszIfStop), dwMask)) {
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
} else {
|
|
/*
|
|
* End of block or if
|
|
* If there is an if string, Write #endif to output file
|
|
*/
|
|
if (gphsbStackTop->pszifLabel != NULL) {
|
|
|
|
if (!hsWriteHeaderFiles(gszEndStart, HSCSZSIZE(gszEndStart), dwMask)
|
|
|| !hsWriteHeaderFiles(gphsbStackTop->pszifLabel, lstrlen(gphsbStackTop->pszifLabel), dwMask)
|
|
|| !hsWriteHeaderFiles(gszEndStop, HSCSZSIZE(gszEndStop), dwMask)) {
|
|
|
|
return FALSE;
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
* If doing a second pass, fix the mask and the string
|
|
*/
|
|
if (uPasses > 1) {
|
|
psz = gphsbStackTop->pszifLabel;
|
|
if (dwMask & HST_BEGIN) {
|
|
/*
|
|
* Write internal header now
|
|
*/
|
|
dwMask &= ~HST_PUBLIC;
|
|
dwMask |= HST_INTERNAL;
|
|
|
|
/*
|
|
* From >= to <
|
|
*/
|
|
while (*psz != '>') {
|
|
psz++;
|
|
}
|
|
*psz++ = '<';
|
|
*psz = ' ';
|
|
} else {
|
|
/*
|
|
* Write public header now
|
|
*/
|
|
dwMask &= ~HST_INTERNAL;
|
|
dwMask |= HST_PUBLIC;
|
|
/*
|
|
* From < to >=
|
|
*/
|
|
while (*psz != '<') {
|
|
psz++;
|
|
}
|
|
*psz++ = '>';
|
|
*psz = '=';
|
|
}
|
|
}
|
|
|
|
} while (--uPasses != 0);
|
|
|
|
|
|
/*
|
|
* Clean up the block if at the end
|
|
*/
|
|
if (dwMask & HST_END) {
|
|
if (!hsPopBlock()) {
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
|
|
return TRUE;
|
|
}
|
|
/***************************************************************************\
|
|
* hsSplit
|
|
*
|
|
\***************************************************************************/
|
|
BOOL hsSplit (void)
|
|
{
|
|
BOOL fSkip;
|
|
char * pmap, *pmapLineStart, *pmapLastLineStart, *pmapMarker, *pmapLastChar;
|
|
DWORD dwMask, dwVersion, dwPreviousMask, dwLastMask;
|
|
|
|
/*
|
|
* Initialize block stack top, map pointer, etc
|
|
*/
|
|
ZeroMemory(gphsbStackTop, sizeof(*gphsbStackTop));
|
|
dwLastMask = 0;
|
|
pmap = pmapLineStart = pmapLastLineStart = gpmapStart;
|
|
gdwLineNumber = 1;
|
|
|
|
while (pmap < gpmapEnd) {
|
|
/*
|
|
* Find the marker and the line it is on
|
|
*/
|
|
pmap = hsFindTagMarker(pmap, &pmapLineStart);
|
|
if (pmap == NULL) {
|
|
break;
|
|
}
|
|
|
|
/*
|
|
* Parse the tag
|
|
*/
|
|
dwMask = hsParseTag(pmap, &dwVersion);
|
|
if (dwMask & HST_ERROR) {
|
|
return FALSE;
|
|
}
|
|
|
|
/*
|
|
* If this wasn't a tag (just the tag marker), continue
|
|
*/
|
|
if ((dwMask == HST_DEFAULT) && (dwVersion == 0)) {
|
|
pmap++;
|
|
continue;
|
|
}
|
|
|
|
/*
|
|
* Write any previous non-empty (untagged) lines.
|
|
* If we're about to start a block, make sure to use the right mask.
|
|
*/
|
|
dwPreviousMask = ((dwMask & (HST_BEGIN | HST_IF)) ? (gphsbStackTop - 1)->dwMask : gphsbStackTop->dwMask);
|
|
pmapLastChar = hsLastRealChar(pmapLastLineStart, pmapLineStart);
|
|
if (pmapLastLineStart < pmapLastChar) {
|
|
/*
|
|
* Empty lines between internal (block) tags go to the internal file
|
|
*/
|
|
if (!(dwPreviousMask & HST_BOTH)
|
|
&& ((dwMask & HST_BOTH) == HST_INTERNAL)
|
|
&& ((dwLastMask & HST_BOTH) == HST_INTERNAL)
|
|
&& hsIsEmpty(pmapLastLineStart, pmapLastChar)) {
|
|
|
|
dwPreviousMask |= HST_INTERNAL;
|
|
}
|
|
|
|
if (!hsWriteHeaderFiles(pmapLastLineStart, (DWORD)(pmapLastChar - pmapLastLineStart), dwPreviousMask)) {
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Determine if this tag is to be skipped.
|
|
* If we're at the END tag, then we include it since the block was
|
|
* already included.
|
|
* If gdwFilterMask contains any user-defined tags, then they must
|
|
* be present or the block is to be skipped -- note that this only
|
|
* applies for not HST_SKIP | HST_IGNORE blocks.
|
|
*/
|
|
|
|
fSkip = (!(dwMask & HST_END)
|
|
&& ((dwMask & HST_SKIP)
|
|
|| (gdwVersion < dwVersion)
|
|
|| ((gdwFilterMask & HST_USERTAGSMASK)
|
|
&& ((gdwFilterMask & dwMask & HST_USERTAGSMASK) != (dwMask & HST_USERTAGSMASK)))));
|
|
|
|
|
|
/*
|
|
* If it is to be skipped, do it
|
|
*/
|
|
if (fSkip) {
|
|
/*
|
|
* If it's a block, skip the marker and the skip the block
|
|
* Otherwise, skip the current line
|
|
*/
|
|
if (dwMask & HST_BEGIN) {
|
|
pmap = hsSkipBlock(++pmap);
|
|
} else {
|
|
/*
|
|
* If this was an if tag with no begin-end block, pop
|
|
* the fake block out of the stack.
|
|
*/
|
|
if (dwMask & HST_IF) {
|
|
if (!hsPopBlock()) {
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Go to the beginning of the next line.
|
|
*/
|
|
pmap = hsFindEOL(pmap);
|
|
}
|
|
if (pmap == NULL) {
|
|
return TRUE;
|
|
}
|
|
|
|
goto SkipEmptyLines;
|
|
}
|
|
|
|
/*
|
|
* remember the marker position and the tag
|
|
*/
|
|
pmapMarker = pmap;
|
|
dwLastMask = dwMask;
|
|
|
|
/*
|
|
* For old switch 4, internal tags go into the public header
|
|
*/
|
|
if ((gdwOptions & HSO_INCINTERNAL) && ((dwMask & HST_BOTH) == HST_INTERNAL)) {
|
|
dwMask |= HST_INCINTERNAL;
|
|
if (dwMask & HST_BEGIN) {
|
|
gphsbStackTop->dwMask |= HST_INCINTERNAL;
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
* If this is the end of a block, write the #endif statement
|
|
* else, if this is the beginning of a block or an if tag, add the
|
|
* #if statement.
|
|
*/
|
|
if (dwMask & HST_END) {
|
|
if (!hsBeginEndBlock(dwMask, dwVersion)) {
|
|
return FALSE;
|
|
}
|
|
} else if (dwMask & (HST_BEGIN | HST_IF)) {
|
|
if (!hsBeginEndBlock(dwMask | HST_BEGIN, dwVersion)) {
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
//
|
|
// Later: If we're inside a block and find a tag the needs to go to a file
|
|
// that doesn't have the ifdef, then we might want to add it to that file.
|
|
// Few issues: more than one nesting. if add #if.. make sure to add #endif when
|
|
// block ends. Also hsBeginEnd doesn't expect to get called more than once
|
|
// per block. It would append the version twice.
|
|
//
|
|
// else if ((gphsbStackTop->pszifLabel != NULL)
|
|
// && ((gphsbStackTop->dwMask & HST_BOTH) != (dwMask & HST_BOTH))) {
|
|
//
|
|
// if ((gphsbStackTop->dwMask & HST_BOTH) == HST_INTERNAL) {
|
|
// hsLogMsg(HSLM_DEFAULT, "Public. Line:%d Block line:%d", gdwLineNumber, gphsbStackTop->dwLineNumber);
|
|
// } else if (!(gphsbStackTop->dwMask & HST_INTERNAL)
|
|
// && ((dwMask & HST_BOTH) == HST_INTERNAL)) {
|
|
// hsLogMsg(HSLM_DEFAULT, "Internal. Line:%d Block line:%d", gdwLineNumber, gphsbStackTop->dwLineNumber);
|
|
// }
|
|
// }
|
|
|
|
/*
|
|
* Write the line up to the tag marker
|
|
* If the line begins with the tag marker, then there is nothing to write
|
|
* Compatibility: Don't copy any trailing spaces (breaks mc.exe).
|
|
*/
|
|
if (pmapLineStart + 2 < pmapMarker) {
|
|
pmapLastChar = hsLastRealChar(pmapLineStart, pmapMarker);
|
|
if (pmapLineStart < pmapLastChar) {
|
|
if (!hsWriteHeaderFiles(pmapLineStart, (DWORD)(pmapLastChar - pmapLineStart), dwMask)) {
|
|
return FALSE;
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
* If this is an if tag without a begin-end block,
|
|
* write the #endif statement
|
|
*/
|
|
if ((dwMask & HST_IF) && !(dwMask & HST_BLOCK)) {
|
|
if (!hsBeginEndBlock(dwMask | HST_END, dwVersion)) {
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Skip the tag (go to the beginning of the next line)
|
|
*/
|
|
pmap = hsFindEOL(pmapMarker);
|
|
if (pmap == NULL) {
|
|
return TRUE;
|
|
}
|
|
|
|
/*
|
|
* If including internal tags in the public header, add the tag
|
|
* as a comment.
|
|
*/
|
|
if (dwMask & HST_INCINTERNAL) {
|
|
/*
|
|
* Start a new line if at the end of a block
|
|
*/
|
|
if (dwMask & HST_END) {
|
|
if (!hsWriteNewLine(dwMask)) {
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
if (!hsWriteHeaderFiles(" // ", 4, dwMask)
|
|
|| !hsWriteHeaderFiles(pmapMarker, (DWORD)(pmap - pmapMarker), dwMask)) {
|
|
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
SkipEmptyLines:
|
|
/*
|
|
* Update line pointers and move past beginning of new line
|
|
*/
|
|
pmapLastLineStart = pmapLineStart = hsSkipEmptyLines(pmap);
|
|
pmap = pmapLastLineStart + 2;
|
|
} /* while (pmap < gpmapEnd) */
|
|
|
|
|
|
/*
|
|
* This is not good if we were inside a block
|
|
*/
|
|
if (gphsbStackTop > ghsbStack) {
|
|
hsLogMsg(HSLM_ERROR, "Missing end block");
|
|
hsLogMsg(HSLM_ERROR | HSLM_NOLINE, "Last block Line: %d. if Label:'%s'. Mask: %#lx",
|
|
gphsbStackTop->dwLineNumber, gphsbStackTop->pszifLabel, gphsbStackTop->dwMask);
|
|
return FALSE;
|
|
}
|
|
|
|
/*
|
|
* Write last (untagged) lines to public header.
|
|
*/
|
|
if (pmapLastLineStart < gpmapEnd) {
|
|
if (!hsWriteHeaderFiles(pmapLastLineStart, (DWORD)(gpmapEnd - pmapLastLineStart), HST_DEFAULT)) {
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Terminate the last line
|
|
*/
|
|
if (!hsWriteNewLine(HST_BOTH)) {
|
|
return FALSE;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|