416 lines
9.8 KiB
C
416 lines
9.8 KiB
C
/*++
|
|
|
|
Copyright (c) 1992 Microsoft Corporation
|
|
|
|
Module Name:
|
|
|
|
hextract.c
|
|
|
|
Abstract:
|
|
|
|
This is the main module for a header the file extractor.
|
|
|
|
Author:
|
|
|
|
Andre Vachon (andreva) 13-Feb-1992
|
|
Mark Lucovsky (markl) 28-Jan-1991
|
|
|
|
Revision History:
|
|
|
|
--*/
|
|
|
|
#include <assert.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <ctype.h>
|
|
#include <common.ver>
|
|
|
|
|
|
//
|
|
// Function declarations
|
|
//
|
|
|
|
int
|
|
ProcessParameters(
|
|
int argc,
|
|
char *argv[]
|
|
);
|
|
|
|
void
|
|
ProcessSourceFile( void );
|
|
|
|
void
|
|
ProcessLine(
|
|
char *s
|
|
);
|
|
|
|
//
|
|
// Global Data
|
|
//
|
|
|
|
unsigned char LineFiltering = 0;
|
|
|
|
char *LineTag;
|
|
char *ExcludeLineTag;
|
|
char *MultiLineTagStart;
|
|
char *MultiLineTagEnd;
|
|
char *CommentDelimiter = "//";
|
|
|
|
char *OutputFileName;
|
|
char *SourceFileName;
|
|
char **SourceFileList;
|
|
|
|
int SourceFileCount;
|
|
FILE *SourceFile, *OutputFile;
|
|
|
|
|
|
#define STRING_BUFFER_SIZE 1024
|
|
char StringBuffer[STRING_BUFFER_SIZE];
|
|
|
|
|
|
#define BUILD_VER_COMMENT "/*++ BUILD Version: "
|
|
#define BUILD_VER_COMMENT_LENGTH (sizeof( BUILD_VER_COMMENT )-1)
|
|
|
|
int OutputVersion = 0;
|
|
|
|
#define szVERSION "1.3"
|
|
|
|
|
|
char const szUsage[] =
|
|
"Microsoft (R) HEXTRACT Version " szVERSION " (NT)\n"
|
|
VER_LEGALCOPYRIGHT_STR ". All rights reserved.\n"
|
|
"\n"
|
|
"Usage: HEXTRACT [options] filename1 [filename2 ...]\n"
|
|
"\n"
|
|
"Options:\n"
|
|
" -f - filtering is turned on:\n"
|
|
" ULONG, UCHAR, USHORT & NTSTATUS are\n"
|
|
" replaced with DWORD, BYTE, WORD & DWORD.\n"
|
|
" -f2 - Same as -f except ULONGLONG and ULONG_PTR\n"
|
|
" isn't converted\n"
|
|
" -o filename - required existing output filename;\n"
|
|
" output is appended to filename\n"
|
|
" -xt string - supplies the tag for excluding one line\n"
|
|
" -lt string - supplies the tag for extracting one line\n"
|
|
" -bt string1 string2 - supplies the starting and ending tags for\n"
|
|
" extracting multiple lines\n"
|
|
" filename1 [filename2 ...] - supplies files from which the definitions\n"
|
|
" are extracted\n"
|
|
"\n"
|
|
"To be parsed properly, the tag strings must be located within a comment\n"
|
|
"delimited by //\n"
|
|
;
|
|
|
|
|
|
int
|
|
__cdecl main( argc, argv )
|
|
int argc;
|
|
char *argv[];
|
|
{
|
|
char achver[BUILD_VER_COMMENT_LENGTH];
|
|
|
|
if (!ProcessParameters(argc, argv) || NULL == OutputFileName) {
|
|
|
|
fprintf(stderr, szUsage);
|
|
return 1;
|
|
}
|
|
|
|
if ( (OutputFile = fopen(OutputFileName,"r+")) == 0) {
|
|
|
|
fprintf(stderr,"HEXTRACT: Unable to open output file %s for update access\n",OutputFileName);
|
|
return 1;
|
|
|
|
}
|
|
|
|
if (fseek(OutputFile, 0L, SEEK_END) == -1) {
|
|
fprintf(stderr, "HEXTRACT: Unable to seek to end of %s\n", OutputFileName);
|
|
return 1;
|
|
}
|
|
|
|
|
|
OutputVersion = 0;
|
|
|
|
#ifdef HEXTRACT_DEBUG
|
|
fprintf(
|
|
stderr,
|
|
"%s\n%s\n%s\n%s\n",
|
|
LineTag,
|
|
ExcludeLineTag,
|
|
MultiLineTagStart,
|
|
MultiLineTagEnd);
|
|
|
|
#endif
|
|
|
|
while ( SourceFileCount-- ) {
|
|
|
|
SourceFileName = *SourceFileList++;
|
|
if ( (SourceFile = fopen(SourceFileName,"r")) == 0) {
|
|
|
|
fprintf(stderr,"HEXTRACT: Unable to open source file %s for read access\n",SourceFileName);
|
|
return 1;
|
|
|
|
}
|
|
|
|
ProcessSourceFile();
|
|
fclose(SourceFile);
|
|
|
|
}
|
|
|
|
if (fseek(OutputFile, 0L, SEEK_SET) == -1) {
|
|
fprintf(stderr, "HEXTRACT: Unable to seek to start of %s\n", OutputFileName);
|
|
return 1;
|
|
}
|
|
if (1 == fread(achver, BUILD_VER_COMMENT_LENGTH, 1, OutputFile) &&
|
|
!strncmp(achver, BUILD_VER_COMMENT, BUILD_VER_COMMENT_LENGTH)) {
|
|
|
|
if (fseek(OutputFile, (long)BUILD_VER_COMMENT_LENGTH, SEEK_SET) == -1) {
|
|
fprintf(stderr, "HEXTRACT: Unable to seek past comments in %s\n", OutputFileName);
|
|
return 1;
|
|
}
|
|
fprintf(OutputFile, "%04d", OutputVersion);
|
|
}
|
|
|
|
if (fseek(OutputFile, 0L, SEEK_END) == -1) {
|
|
fprintf(stderr, "HEXTRACT: Unable to seek to end of %s\n", OutputFileName);
|
|
return 1;
|
|
}
|
|
fclose(OutputFile);
|
|
return( 0 );
|
|
}
|
|
|
|
|
|
int
|
|
ProcessParameters(
|
|
int argc,
|
|
char *argv[]
|
|
)
|
|
{
|
|
char c, *p;
|
|
|
|
while (--argc) {
|
|
|
|
p = *++argv;
|
|
|
|
//
|
|
// if we have a delimiter for a parameter, case throught the valid
|
|
// parameter. Otherwise, the rest of the parameters are the list of
|
|
// input files.
|
|
//
|
|
|
|
if (*p == '/' || *p == '-') {
|
|
|
|
//
|
|
// Switch on all the valid delimiters. If we don't get a valid
|
|
// one, return with an error.
|
|
//
|
|
|
|
c = *++p;
|
|
|
|
switch (toupper( c )) {
|
|
|
|
case 'F':
|
|
|
|
c = *++p;
|
|
if ( (toupper ( c )) == '2')
|
|
LineFiltering = 2;
|
|
else
|
|
LineFiltering = 1;
|
|
|
|
break;
|
|
|
|
case 'O':
|
|
|
|
argc--, argv++;
|
|
OutputFileName = *argv;
|
|
|
|
break;
|
|
|
|
case 'L':
|
|
|
|
c = *++p;
|
|
if ( (toupper ( c )) != 'T')
|
|
return 0;
|
|
argc--, argv++;
|
|
LineTag = *argv;
|
|
|
|
break;
|
|
|
|
case 'B':
|
|
|
|
c = *++p;
|
|
if ( (toupper ( c )) != 'T')
|
|
return 0;
|
|
argc--, argv++;
|
|
MultiLineTagStart = *argv;
|
|
argc--, argv++;
|
|
MultiLineTagEnd = *argv;
|
|
|
|
break;
|
|
|
|
case 'X':
|
|
|
|
c = *++p;
|
|
if ( (toupper ( c )) != 'T')
|
|
return 0;
|
|
argc--, argv++;
|
|
ExcludeLineTag = *argv;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
//
|
|
// Make the assumptionthat we have a valid command line if and
|
|
// only if we have a list of filenames.
|
|
//
|
|
|
|
SourceFileList = argv;
|
|
SourceFileCount = argc;
|
|
|
|
return 1;
|
|
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
void
|
|
ProcessSourceFile( void )
|
|
{
|
|
char *s;
|
|
char *comment;
|
|
char *tag;
|
|
char *test;
|
|
|
|
s = fgets(StringBuffer,STRING_BUFFER_SIZE,SourceFile);
|
|
|
|
if (s) {
|
|
if (!strncmp( s, BUILD_VER_COMMENT, BUILD_VER_COMMENT_LENGTH )) {
|
|
OutputVersion += atoi( s + BUILD_VER_COMMENT_LENGTH );
|
|
}
|
|
}
|
|
|
|
while ( s ) {
|
|
|
|
//
|
|
// Check for a block with delimiters
|
|
//
|
|
|
|
if (NULL != MultiLineTagStart) {
|
|
comment = strstr(s,CommentDelimiter);
|
|
if ( comment ) {
|
|
|
|
tag = strstr(comment,MultiLineTagStart);
|
|
if ( tag ) {
|
|
|
|
//
|
|
// Now that we have found an opening tag, check each
|
|
// following line for the closing tag, and then include it
|
|
// in the ouput.
|
|
//
|
|
|
|
s = fgets(StringBuffer,STRING_BUFFER_SIZE,SourceFile);
|
|
while ( s ) {
|
|
int fProcess = 1;
|
|
|
|
comment = strstr(s,CommentDelimiter);
|
|
if ( comment ) {
|
|
tag = strstr(comment,MultiLineTagEnd);
|
|
if ( tag ) {
|
|
goto bottom;
|
|
}
|
|
if (NULL != ExcludeLineTag &&
|
|
strstr(comment,ExcludeLineTag)) {
|
|
fProcess = 0;
|
|
}
|
|
}
|
|
if (fProcess) {
|
|
ProcessLine(s);
|
|
}
|
|
s = fgets(StringBuffer,STRING_BUFFER_SIZE,SourceFile);
|
|
}
|
|
|
|
fprintf(stderr,
|
|
"HEXTRACT: %s without matching %s in %s\n",
|
|
MultiLineTagStart,
|
|
MultiLineTagEnd,
|
|
OutputFileName);
|
|
|
|
exit(1);
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// Check for a single line to output.
|
|
//
|
|
|
|
if (NULL != LineTag) {
|
|
comment = strstr(s,CommentDelimiter);
|
|
if ( comment ) {
|
|
tag = strstr(comment,LineTag);
|
|
if ( tag ) {
|
|
*comment++ = '\n';
|
|
*comment = '\0';
|
|
ProcessLine(s);
|
|
goto bottom;
|
|
}
|
|
}
|
|
}
|
|
|
|
bottom:
|
|
s = fgets(StringBuffer,STRING_BUFFER_SIZE,SourceFile);
|
|
}
|
|
}
|
|
|
|
void
|
|
ProcessLine(
|
|
char *s
|
|
)
|
|
{
|
|
char *t;
|
|
char *s1;
|
|
|
|
if (LineFiltering) {
|
|
s1 = s;
|
|
|
|
//
|
|
// This should be replaced by a data file describing an input token
|
|
// and an output token which would be used for the filtering.
|
|
//
|
|
|
|
while (t = strstr(s1,"ULONG")) {
|
|
if (LineFiltering == 2) {
|
|
if (!memcmp(t, "ULONGLONG", 9)) {
|
|
s1+=9;
|
|
} else if (!memcmp(t, "ULONG_PTR", 9)) {
|
|
s1+=9;
|
|
} else {
|
|
memcpy(t,"DWORD",5);
|
|
}
|
|
} else {
|
|
memcpy(t,"DWORD",5);
|
|
}
|
|
}
|
|
|
|
while (t = strstr(s,"UCHAR"))
|
|
memcpy(t,"BYTE ",5);
|
|
|
|
while (t = strstr(s,"USHORT"))
|
|
memcpy(t,"WORD ",6);
|
|
|
|
while (t = strstr(s,"NTSTATUS"))
|
|
memcpy(t,"DWORD ",8);
|
|
}
|
|
|
|
fputs(s,OutputFile);
|
|
}
|