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.
601 lines
19 KiB
601 lines
19 KiB
/****************************** Module Header ******************************\
|
|
* Module Name: hsplit.c
|
|
*
|
|
* Structure parser - struct field name-offset tabel generator.
|
|
*
|
|
* Copyright (c) 1985-96, Microsoft Corporation
|
|
*
|
|
* 09/05/96 GerardoB Created
|
|
\***************************************************************************/
|
|
#include "hsplit.h"
|
|
|
|
/*
|
|
* Maximum size of tags (gphst) table including possible user defined tags
|
|
*/
|
|
#define HSTAGTABLESIZE (sizeof(ghstPredefined) + ((32 - HST_MASKBITCOUNT) * sizeof(HSTAG)))
|
|
/***************************************************************************\
|
|
* hsAddTag
|
|
*
|
|
\***************************************************************************/
|
|
PHSTAG hsAddTag (char * pszTag, DWORD dwMask)
|
|
{
|
|
PHSTAG phst;
|
|
DWORD dwTagSize;
|
|
|
|
/*
|
|
* Make sure we still have mask bits to uniquely identified this tag
|
|
*/
|
|
if (((dwMask | HST_EXTRACT) == HST_EXTRACT) && (gdwLastTagMask == HST_MAXMASK)) {
|
|
hsLogMsg(HSLM_ERROR, "Too many user defined tags. Max allowed: %d", 32 - HST_MASKBITCOUNT);
|
|
return NULL;
|
|
}
|
|
|
|
/*
|
|
* Create the table the first time around.
|
|
*/
|
|
if (gphst == ghstPredefined) {
|
|
gphst = (PHSTAG) LocalAlloc(LPTR, HSTAGTABLESIZE);
|
|
if (gphst == NULL) {
|
|
hsLogMsg(HSLM_APIERROR, "LocalAlloc");
|
|
hsLogMsg(HSLM_ERROR, "hsAddTag Allocation failed. Size:%#lx", HSTAGTABLESIZE);
|
|
return NULL;
|
|
}
|
|
|
|
CopyMemory(gphst, &ghstPredefined, sizeof(ghstPredefined));
|
|
}
|
|
|
|
/*
|
|
* If the string is in the table, we update the mask.
|
|
*/
|
|
dwTagSize = strlen(pszTag);
|
|
phst = hsFindTagInList(gphst, pszTag, dwTagSize);
|
|
if (phst == NULL) {
|
|
/*
|
|
* New string. Find next available entry in the table
|
|
*/
|
|
phst = gphst;
|
|
while (phst->dwLabelSize != 0) {
|
|
phst++;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Initialize it
|
|
*/
|
|
phst->dwLabelSize = dwTagSize;
|
|
phst->pszLabel = pszTag;
|
|
|
|
/*
|
|
* If generating a mask, use the next available bit in the tag mask
|
|
* else use the one supplied by the caller
|
|
*/
|
|
if ((dwMask | HST_EXTRACT) == HST_EXTRACT) {
|
|
gdwLastTagMask *= 2;
|
|
phst->dwMask = (gdwLastTagMask | dwMask);
|
|
} else {
|
|
phst->dwMask = dwMask;
|
|
}
|
|
|
|
/*
|
|
* Add this tag's mask to the filter mask so lines mark with this tag
|
|
* will be included
|
|
*/
|
|
gdwFilterMask |= (phst->dwMask & HST_USERTAGSMASK);
|
|
|
|
return phst;
|
|
}
|
|
/***************************************************************************\
|
|
* hsIsSwitch
|
|
*
|
|
\***************************************************************************/
|
|
__inline BOOL hsIsSwitch(char c)
|
|
{
|
|
return (c == '/') || (c == '-');
|
|
}
|
|
|
|
/***************************************************************************\
|
|
* hsAddUserDefinedTag
|
|
*
|
|
\***************************************************************************/
|
|
|
|
BOOL hsAddUserDefinedTag(DWORD* pdwMask, int* pargc, char*** pargv)
|
|
{
|
|
DWORD dwRetMask = *pdwMask;
|
|
PHSTAG phst;
|
|
|
|
if (*pargc < 2) {
|
|
return FALSE; // invalid switch
|
|
}
|
|
|
|
/*
|
|
* Allow multiple tags to be specified for one switch
|
|
* i.e., -t tag1 <tag2 tag2....>
|
|
*/
|
|
do {
|
|
(*pargc)--, (*pargv)++;
|
|
|
|
/*
|
|
* Add tag to table
|
|
*/
|
|
phst = hsAddTag(**pargv, *pdwMask);
|
|
if (phst == NULL) {
|
|
return 0;
|
|
}
|
|
|
|
dwRetMask |= phst->dwMask;
|
|
|
|
} while ((*pargc >= 2) && !hsIsSwitch(**(*pargv + 1)));
|
|
|
|
/*
|
|
* save the new mask
|
|
*/
|
|
*pdwMask = dwRetMask;
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
/***************************************************************************\
|
|
* hsAddExtractFile
|
|
*
|
|
\***************************************************************************/
|
|
BOOL hsAddExtractFile(char* pszExtractFile, DWORD dwMask, BOOL bAppend)
|
|
{
|
|
PHSEXTRACT pe;
|
|
|
|
pe = LocalAlloc(LPTR, sizeof(HSEXTRACT));
|
|
|
|
if (pe == NULL) {
|
|
return FALSE;
|
|
}
|
|
pe->pszFile = pszExtractFile;
|
|
pe->dwMask = dwMask;
|
|
|
|
pe->hfile = CreateFile(pszExtractFile, GENERIC_WRITE, 0, NULL,
|
|
(bAppend ? OPEN_EXISTING : CREATE_ALWAYS),
|
|
FILE_ATTRIBUTE_NORMAL, NULL);
|
|
|
|
if (pe->hfile == INVALID_HANDLE_VALUE) {
|
|
hsLogMsg(HSLM_APIERROR | HSLM_NOLINE, "CreateFile failed for file %s",
|
|
pszExtractFile);
|
|
LocalFree(pe);
|
|
return FALSE;
|
|
}
|
|
if (bAppend) {
|
|
if (0xFFFFFFFF == SetFilePointer (pe->hfile, 0, 0, FILE_END)) {
|
|
hsLogMsg(HSLM_APIERROR | HSLM_NOLINE, "SetFilePointer failed for file %s",
|
|
pszExtractFile);
|
|
CloseHandle(pe->hfile);
|
|
LocalFree(pe);
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* link it in the list of extract files
|
|
*/
|
|
pe->pNext = gpExtractFile;
|
|
gpExtractFile = pe;
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
/***************************************************************************\
|
|
* hsProcessParameters
|
|
*
|
|
\***************************************************************************/
|
|
int hsProcessParameters(int argc, LPSTR argv[])
|
|
{
|
|
char c, *p;
|
|
DWORD dwMask;
|
|
int argcParm = argc;
|
|
PHSTAG phst;
|
|
|
|
/*
|
|
* Compatibility. Assume default project the first time this
|
|
* function is called
|
|
*/
|
|
if (!(gdwOptions & HSO_APPENDOUTPUT)) {
|
|
gdwOptions |= HSO_OLDPROJSW_N;
|
|
}
|
|
|
|
/*
|
|
* Loop through parameters.
|
|
*/
|
|
while (--argc) {
|
|
p = *++argv;
|
|
if (hsIsSwitch(*p)) {
|
|
while (c = *++p) {
|
|
switch (toupper(c)) {
|
|
/*
|
|
* Compatibility.
|
|
* Chicago/Nashvilled header.
|
|
*/
|
|
case '4':
|
|
gdwOptions &= ~HSO_OLDPROJSW;
|
|
gdwOptions |= HSO_OLDPROJSW_4;
|
|
break;
|
|
|
|
/*
|
|
* Old bt2 and btb switches to replace internal and
|
|
* both block tags.
|
|
*/
|
|
case 'B':
|
|
p++;
|
|
if (toupper(*p++) != 'T') {
|
|
goto InvalidSwitch;
|
|
}
|
|
if (toupper(*p) == 'B') {
|
|
dwMask = HST_BOTH | HST_USERBOTHBLOCK;
|
|
gdwOptions |= HSO_USERBOTHBLOCK;
|
|
} else if (*p == '2') {
|
|
dwMask = HST_INTERNAL | HST_USERINTERNALBLOCK;
|
|
gdwOptions |= HSO_USERINTERNALBLOCK;
|
|
} else {
|
|
goto InvalidSwitch;
|
|
}
|
|
|
|
if (argc < 3) {
|
|
goto InvalidSwitch;
|
|
}
|
|
|
|
|
|
/*
|
|
* Add these strings as tags and mark them as blocks
|
|
*/
|
|
argc--, argv++;
|
|
phst = hsAddTag(*argv, HST_BEGIN | dwMask);
|
|
if (phst == NULL) {
|
|
return 0;
|
|
}
|
|
|
|
argc--, argv++;
|
|
phst = hsAddTag(*argv, HST_END | dwMask);
|
|
if (phst == NULL) {
|
|
return 0;
|
|
}
|
|
break;
|
|
|
|
/*
|
|
* Tag marker
|
|
*/
|
|
case 'C':
|
|
if (argc < 2) {
|
|
goto InvalidSwitch;
|
|
}
|
|
|
|
argc--, argv++;
|
|
gpszTagMarker = *argv;
|
|
*gszMarkerCharAndEOL = *gpszTagMarker;
|
|
gdwTagMarkerSize = strlen(gpszTagMarker);
|
|
if (gdwTagMarkerSize == 0) {
|
|
goto InvalidSwitch;
|
|
}
|
|
break;
|
|
|
|
/*
|
|
* Compatibility.
|
|
* NT SUR header
|
|
*/
|
|
case 'E':
|
|
gdwOptions &= ~HSO_OLDPROJSW;
|
|
gdwOptions |= HSO_OLDPROJSW_E;
|
|
break;
|
|
|
|
/*
|
|
* Input file
|
|
*/
|
|
case 'I':
|
|
if (argc < 2) {
|
|
goto InvalidSwitch;
|
|
}
|
|
|
|
argc--, argv++;
|
|
gpszInputFile = *argv;
|
|
goto ProcessInputFile;
|
|
break;
|
|
|
|
/*
|
|
* Extract file
|
|
*/
|
|
case 'X':
|
|
{
|
|
char* pszExtractFile;
|
|
BOOL bAppend = FALSE;
|
|
|
|
if (toupper(*(p+1)) == 'A') {
|
|
p++;
|
|
bAppend = TRUE;
|
|
}
|
|
|
|
if (argc < 3) {
|
|
goto InvalidSwitch;
|
|
}
|
|
|
|
argc--, argv++;
|
|
pszExtractFile = *argv;
|
|
|
|
dwMask = HST_EXTRACT;
|
|
if (!hsAddUserDefinedTag(&dwMask, &argc, &argv))
|
|
goto InvalidSwitch;
|
|
|
|
hsAddExtractFile(pszExtractFile, dwMask, bAppend);
|
|
|
|
break;
|
|
}
|
|
|
|
/*
|
|
* Old lt2 and ltb switches to replace internal and
|
|
* both tags.
|
|
*/
|
|
case 'L':
|
|
p++;
|
|
if (toupper(*p++) != 'T') {
|
|
goto InvalidSwitch;
|
|
}
|
|
if (toupper(*p) == 'B') {
|
|
dwMask = HST_BOTH | HST_USERBOTHTAG;
|
|
gdwOptions |= HSO_USERBOTHTAG;
|
|
} else if (*p == '2') {
|
|
dwMask = HST_INTERNAL | HST_USERINTERNALTAG;
|
|
gdwOptions |= HSO_USERINTERNALTAG;
|
|
} else {
|
|
goto InvalidSwitch;
|
|
}
|
|
|
|
if (!hsAddUserDefinedTag(&dwMask, &argc, &argv))
|
|
goto InvalidSwitch;
|
|
|
|
break;
|
|
|
|
/*
|
|
* Compatibility.
|
|
* NT header
|
|
*/
|
|
case 'N':
|
|
gdwOptions &= ~HSO_OLDPROJSW;
|
|
gdwOptions |= HSO_OLDPROJSW_N;
|
|
break;
|
|
|
|
/*
|
|
* Ouput files
|
|
*/
|
|
case 'O':
|
|
if (argc < 3) {
|
|
goto InvalidSwitch;
|
|
}
|
|
|
|
argc--, argv++;
|
|
gpszPublicFile = *argv;
|
|
|
|
argc--, argv++;
|
|
gpszInternalFile = *argv;
|
|
break;
|
|
|
|
/*
|
|
* Compatibility.
|
|
* NT SURPlus header
|
|
*/
|
|
case 'P':
|
|
gdwOptions &= ~HSO_OLDPROJSW;
|
|
gdwOptions |= HSO_OLDPROJSW_P;
|
|
break;
|
|
|
|
/*
|
|
* Split only. Process internal/both tags only. Tags
|
|
* including other tags as well (i.e., internal_NT)
|
|
* are treated as untagged.
|
|
*/
|
|
case 'S':
|
|
gdwOptions |= HSO_SPLITONLY;
|
|
break;
|
|
|
|
/*
|
|
* User defined tags.
|
|
*/
|
|
case 'T':
|
|
switch (toupper(*++p)) {
|
|
/*
|
|
* Include lines mark with this tag
|
|
*/
|
|
case 'A':
|
|
dwMask = 0;
|
|
break;
|
|
/*
|
|
* Ignore lines marked with this tag (i.e, treated
|
|
* as untagged)
|
|
*/
|
|
case 'I':
|
|
dwMask = HST_IGNORE;
|
|
break;
|
|
/*
|
|
* Skip lines marked with this tag (i.e., not
|
|
* included in header files)
|
|
*/
|
|
case 'S':
|
|
dwMask = HST_SKIP;
|
|
break;
|
|
|
|
default:
|
|
goto InvalidSwitch;
|
|
}
|
|
|
|
if (!hsAddUserDefinedTag(&dwMask, &argc, &argv))
|
|
goto InvalidSwitch;
|
|
|
|
break;
|
|
|
|
/*
|
|
* Version
|
|
*/
|
|
case 'V':
|
|
if (argc < 2) {
|
|
goto InvalidSwitch;
|
|
}
|
|
|
|
argc--, argv++;
|
|
if (!hsVersionFromString (*argv, strlen(*argv), &gdwVersion)) {
|
|
goto InvalidSwitch;
|
|
}
|
|
break;
|
|
|
|
/*
|
|
* Unknown tags are to be skipped, as opposed to ignored.
|
|
*/
|
|
case 'U':
|
|
gdwOptions |= HSO_SKIPUNKNOWN;
|
|
break;
|
|
|
|
/*
|
|
* Invalid switch
|
|
*/
|
|
default:
|
|
InvalidSwitch:
|
|
hsLogMsg(HSLM_ERROR | HSLM_NOLINE, "Invalid switch or parameter: %c", c);
|
|
// Fall through
|
|
|
|
/*
|
|
* Help
|
|
*/
|
|
case '?':
|
|
goto PrintHelp;
|
|
|
|
} /* switch (toupper(c)) */
|
|
} /* while (c = *++p) */
|
|
} else { /* hsIsSwitch(*p) { */
|
|
/*
|
|
* No switch specified. Process this input file
|
|
*/
|
|
gpszInputFile = *argv;
|
|
break;
|
|
}
|
|
} /* while (--argc) */
|
|
|
|
ProcessInputFile:
|
|
/*
|
|
* Make sure we got input and ouput files.
|
|
*/
|
|
if ((gpszInputFile == NULL)
|
|
|| (gpszPublicFile == NULL)
|
|
|| (gpszInternalFile == NULL)) {
|
|
|
|
hsLogMsg(HSLM_ERROR | HSLM_NOLINE, "Missing input or ouput file");
|
|
goto PrintHelp;
|
|
}
|
|
|
|
/*
|
|
* Add compatibility tags for default projects (first call only)
|
|
*/
|
|
if ((gdwOptions & HSO_OLDPROJSW) && !(gdwOptions & HSO_APPENDOUTPUT)) {
|
|
if (!(gdwOptions & HSO_OLDPROJSW_4)) {
|
|
phst = hsAddTag(gszNT, 0);
|
|
if (phst == NULL) {
|
|
return 0;
|
|
}
|
|
phst->dwMask |= HST_MAPOLD;
|
|
dwMask = phst->dwMask;
|
|
}
|
|
|
|
if (gdwOptions & HSO_OLDPROJSW_E) {
|
|
hsAddTag(gszCairo, dwMask);
|
|
hsAddTag(gszSur, dwMask);
|
|
hsAddTag(gszWin40, dwMask);
|
|
hsAddTag(gsz35, dwMask);
|
|
|
|
} else if (gdwOptions & HSO_OLDPROJSW_P) {
|
|
hsAddTag(gszWin40, dwMask);
|
|
hsAddTag(gszWin40a, dwMask);
|
|
hsAddTag(gszCairo, dwMask);
|
|
hsAddTag(gszSur, dwMask);
|
|
hsAddTag(gszSurplus, dwMask);
|
|
hsAddTag(gsz35, dwMask);
|
|
|
|
} else if (gdwOptions & HSO_OLDPROJSW_4) {
|
|
gdwOptions |= HSO_INCINTERNAL;
|
|
phst = hsAddTag(gszChicago, 0);
|
|
if (phst == NULL) {
|
|
return 0;
|
|
}
|
|
phst->dwMask |= HST_MAPOLD;
|
|
dwMask = phst->dwMask;
|
|
hsAddTag(gszNashville, dwMask);
|
|
hsAddTag(gszWin40, dwMask);
|
|
hsAddTag(gszWin40a, dwMask);
|
|
|
|
} else if (!(gdwOptions & HSO_APPENDOUTPUT)) {
|
|
gdwOptions |= HSO_OLDPROJSW_N;
|
|
}
|
|
|
|
} /* (gdOptions & HSO_OLDPROJW) */
|
|
|
|
|
|
/*
|
|
* Compatibility. If doing split only, don't include internal tags
|
|
* in public file
|
|
*/
|
|
if (gdwOptions & HSO_SPLITONLY) {
|
|
gdwOptions &= ~HSO_INCINTERNAL;
|
|
}
|
|
|
|
return argcParm - argc;
|
|
|
|
PrintHelp:
|
|
hsLogMsg(HSLM_DEFAULT, "Header Split Utility. Version 2.1");
|
|
hsLogMsg(HSLM_NOLABEL, "Usage: hsplit [options] <-o PublicFile InternalFile> [-i] File1 [-i] File2...");
|
|
hsLogMsg(HSLM_NOLABEL, "\t[-4] Generate chicago/nashville headers");
|
|
hsLogMsg(HSLM_NOLABEL, "\t[-bt2 BeginStr EndStr] Replace begin_internal/end_internal - Obsolete");
|
|
hsLogMsg(HSLM_NOLABEL, "\t[-btb BeginStr EndStr] Replace begin_both/end_both tags - Obsolete");
|
|
hsLogMsg(HSLM_NOLABEL, "\t[-c TagMarker] Replace tag marker. default \";\"");
|
|
hsLogMsg(HSLM_NOLABEL, "\t[-e] Generate NT sur headers");
|
|
hsLogMsg(HSLM_NOLABEL, "\t[[-i] file1 file2 ..] Input files - Required");
|
|
hsLogMsg(HSLM_NOLABEL, "\t[-lt2 str] Replace internal tag - Obsolete");
|
|
hsLogMsg(HSLM_NOLABEL, "\t[-ltb str] Replace both tag - Obsolete");
|
|
hsLogMsg(HSLM_NOLABEL, "\t[-n] Generate NT headers - default");
|
|
hsLogMsg(HSLM_NOLABEL, "\t[-x[a] ExtractHeader ExtractTag] Extract files and tags files");
|
|
hsLogMsg(HSLM_NOLABEL, "\t[-o PublicHeader InternalHeader] Output files - Required");
|
|
hsLogMsg(HSLM_NOLABEL, "\t[-p] Generate NT surplus headers");
|
|
hsLogMsg(HSLM_NOLABEL, "\t[-s] Process internal and both tags only");
|
|
hsLogMsg(HSLM_NOLABEL, "\t[-ta tag1 tag2 ..] Include lines using these tags");
|
|
hsLogMsg(HSLM_NOLABEL, "\t[-ti tag1 tag2 ..] Ignore these tags");
|
|
hsLogMsg(HSLM_NOLABEL, "\t[-ts tag1 tag2 ..] Skip lines using these tags");
|
|
hsLogMsg(HSLM_NOLABEL, "\t[-u] Skip unknown tags. Default: ignore");
|
|
hsLogMsg(HSLM_NOLABEL, "\t[-v] Version number. Default: LATEST_WIN32_WINNT_VERSION");
|
|
hsLogMsg(HSLM_NOLABEL, "\r\nTags Format:");
|
|
hsLogMsg(HSLM_NOLABEL, "\t<TagMarker>[begin/end][_public/internal][[_tag1][_tag2]...][_if_(str)_version | _version]");
|
|
return 0;
|
|
}
|
|
/***************************************************************************\
|
|
* main
|
|
*
|
|
\***************************************************************************/
|
|
int __cdecl main (int argc, char *argv[])
|
|
{
|
|
int argcProcessed;
|
|
|
|
/*
|
|
* Each loop processes one input file
|
|
*/
|
|
do {
|
|
argcProcessed = hsProcessParameters(argc, argv);
|
|
if (argcProcessed == 0) {
|
|
break;
|
|
}
|
|
|
|
if (!hsOpenWorkingFiles()
|
|
|| !hsSplit()) {
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
hsCloseWorkingFiles();
|
|
|
|
gdwOptions |= HSO_APPENDOUTPUT;
|
|
|
|
argc -= argcProcessed;
|
|
argv += argcProcessed;
|
|
|
|
} while (argc > 1);
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
|