Leaked source code of windows server 2003
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.
 
 
 
 
 
 

739 lines
16 KiB

/*
* mrc.c
*
* Makes RCDATA, #defines, and a table of keywords from a set of of tokens
* given as input.
*
* Usage:
* mrc <tokens> <header> <resource> <C table>
*
* <tokens> is the filename of the tokens file (.TOK) which lists out the
* tokens and optionally, lines to put in the other files. The internal
* format of the file is:
*
* goal: ( <BOL> sections <EOL> )*
* sections: comment | seed | token | imbed
* comment: '#' <text>
* seed: 'TOKENS' short_int
* token: C_string value <text>*
* value: token_symbol | short_int | C_char_constant
* imbed: 'IMBED_IN' dest <EOL> imbed_text <BOL> 'END_IMBED'
* dest: '.H' | '.RC' | '.C'
* imbed_text: ( <BOL> <text>* <EOL> )*
* <BOL>: Beginning of line
* <EOL>: End of line
*
* The seed, lets you specify the seed value for the values to be assigned
* to each new token_symbol that is found. As a new token_symbol is found
* it is written out directly to the .H file as a #define line.
*
* The imbedded text is written out the the corresponding .H, .RC, or .C
* file. This makes it possible to maintain just one source file for all
* the generated files. As each imbed is encountered, it is written out
* to the appropriate file.
*
* When the end of the token file is reached, the set of tokens are sorted
* by their corresponding string and then written out to the C file and RC
* file.
*
* <header> is the filename of the header file (.H) which will hold
* generated #defines which correspond to token_symbols and their assigned
* values.
*
* <resource> is the filename of the resource file (.RC) which will hold
* a relocatable binary image of the the token lookup table in a RCDATA
* field. After any imbedded text, it will be written out as:
*
* KEYWORDS RCDATA
* BEGIN
* <binary image of a C long>, <binary image of a C short>, // 1
* :
* <binary image of a C long>, <binary image of a C short>, // n
* <binary image of a long 0>, <binary image of a short 0>,
* <null terminated string>, // 1
* :
* <null terminated string> // n
* END
*
* The C shorts hold the token values. The longs hold offsets from the
* beginning of the image, to the string for that token value. The long 0
* and short 0 denote the end of the look up table and allows the code
* that loads the image to find out how many entries there are in the
* table.
*
* <C table> is the filename of the C file (.C) which will hold the
* declaration a token lookup table. After any imbedded text, it will be
* written out as:
*
* static KEYWORD rgKeyword[] =
* {
* { <C_string>, <token_value> }, // 1
* :
* { <C_string>, <token_value> }, // n
* { NULL, 0 }
* };
*
* Owner: Anthony Xavier V. Francisco
*
* CAVEAT: If the KEYWORD structure in _rtfpars.h is changed, this program
* will be utterly useless and will have to updated accordingly.
*/
#include <windows.h>
// #include <ourtypes.h>
#include <stdio.h>
#include <stdarg.h>
#include <stdlib.h>
enum
{
eTOK,
eH,
eRC,
eC
};
typedef SHORT TOKEN;
typedef struct _keyword
{
CHAR *szKeyword;
TOKEN token;
} KEYWORD;
FILE * file[4]; // Streams for input and output
CHAR * szOpenMode[] = { "r", "w", "w", "w" }; // Stream opening modes
TOKEN sNextToken = 0; // Value for next token
// Table of token strings and their values
KEYWORD rgToken[256];
INT cToken = 0;
// Table of strings and their token values
KEYWORD rgKeyword[256];
INT cKeyword = 0;
// Buffer and pointer used to support MyMalloc()
CHAR rgchBuffer[4096];
CHAR * pchAvail = rgchBuffer;
// A scratch pad string used to store temporary C constant string versions of
// a C string.
CHAR szScratch[128];
/*
* Error
*
* Purpose:
* Print out error messages to stderr with free formatting capabilites
*
* Arguments:
* szFmt printf format string
* ... parameter corresponding to format string
*
* Returns:
* None.
*/
void __cdecl Error( char * szFmt, ... )
{
va_list marker;
va_start( marker, szFmt );
vfprintf( stderr, szFmt, marker );
va_end(marker);
exit(-1);
}
/*
* TrimCRLF
*
* Purpose:
* Take away the trailing '\n' and '\r' from a string
*
* Arguments:
* sz string to be trimmed
*
* Returns:
* None.
*/
void TrimCRLF( CHAR * sz )
{
INT nLen = strlen(sz);
CHAR * pch = &sz[ nLen - 1 ];
while ( nLen && *pch == '\n' || *pch == '\r' )
{
*pch-- = '\0';
--nLen;
}
}
/*
* NSzACmp
*
* Purpose:
* Compares two ASCII strings based on ASCII values
*
* Arguments:
* szA1 Strings to be compared
* szA2
*
* Returns:
* < 0 szA1 < szA2
* 0 szA1 = szA2
* > 0 szA1 > szA2
*/
INT NSzACmp( CHAR * szA1, CHAR * szA2 )
{
while ( *szA1 && ( *szA1 == *szA2 ) )
{
++szA1;
++szA2;
}
return *szA1 - *szA2;
}
/*
* PchGetNextWord
*
* Purpose:
* Collects the group of characters delimitted by whitespace in a
* string.
*
* Arguments:
* szLine Pointer to the string where to look for a word
* szString Where to put the word
*
* Returns:
* Pointer to the character delimiting the end of the word found. If
* none is found, szString will have a length of zero.
*
*/
CHAR * PchGetNextWord( CHAR * szLine, CHAR *szString )
{
while ( *szLine && isspace(*szLine) )
szLine++;
while ( *szLine && !isspace(*szLine) )
*szString++ = *szLine++;
*szString = '\0';
return szLine;
}
/*
* HandleImbed
*
* Purpose:
* Takes care of copying lines to be imbedded into a generated file
*
* Arguments:
* sz String containing the destination for the imbedded
* lines.
*
* Returns:
* None.
*/
void HandleImbed( CHAR * sz )
{
CHAR szLine[128];
CHAR szString[128];
FILE * fileDest;
if ( !NSzACmp( sz, ".H" ) )
fileDest = file[eH];
else if ( !NSzACmp( sz, ".RC" ) )
fileDest = file[eRC];
else if ( !NSzACmp( sz, ".C" ) )
fileDest = file[eC];
else
Error( "Can't imbed into %s\n", sz );
while ( fgets( szLine, sizeof(szLine), file[eTOK] ) )
{
TrimCRLF(szLine);
PchGetNextWord( szLine, szString );
if ( !NSzACmp( szString, "END_IMBED" ) )
break;
fprintf( fileDest, "%s\n", szLine );
}
}
/*
* TranslateQuoted
*
* Purpose:
* Takes as C string constant declaration and makes it into a C string
* with out the escape characters.
*
* Arguments:
* szDest C string constant declaration to converted
*
* Returns:
* None.
*/
void TranslateQuoted( CHAR * szDest )
{
CHAR szSrc[128];
CHAR * pch = &szSrc[1];
// Go through the string until the end of string or matching quote
strcpy( szSrc, szDest );
while ( *pch && *pch != szSrc[0] )
{
switch (*pch)
{
case '\\':
++pch;
switch(*pch)
{
case '\\':
*szDest++ = '\\';
break;
case 'n':
*szDest++ = '\n';
break;
case 'r':
*szDest++ = '\r';
break;
case 't':
*szDest++ = '\t';
break;
default:
*szDest++ = *pch;
break;
}
break;
default:
*szDest++ = *pch;
break;
}
pch++;
}
*szDest = '\0';
}
/*
* CompareKeywords
*
* Purpose:
* Compares to KEYWORD structures to see if their keyword strings
* match.
*
* Arguments:
* pv1 Pointer to a keyword structure
* pv2 Pointer to another keyword structure
*
* Returns:
* 0 strings are the same
* < 0 pv1's string is less than pv2's string
* > 0 pv1's string is greater than pv2's string
*/
int __cdecl CompareKeywords( void const * pv1, void const * pv2 )
{
KEYWORD * pk1 = ( KEYWORD * ) pv1;
KEYWORD * pk2 = ( KEYWORD * ) pv2;
return NSzACmp( pk1->szKeyword, pk2->szKeyword );
}
/*
* MyMalloc
*
* Purpose:
* Simulates malloc() by using a staticly allocated buffer.
*
* Arguments:
* cb Number of bytes to allocate
*
* Returns:
* Pointer to a set of allocated bytes.
*/
CHAR * MyMalloc( INT cb )
{
CHAR * pch;
pch = pchAvail;
pchAvail += cb;
if ( pchAvail - rgchBuffer > sizeof(rgchBuffer) )
Error( "Not enough memory to satisfy %d byte request\n", cb );
return pch;
}
/*
* AddKeyword
*
* Purpose:
* Stores a keyword string and it's corresponding value into a
* KEYWORD structure. Space for the string is allocated.
*
* Arguments:
* pkeyword Pointer to a keyword structure
* szKeyword The string to be stored.
* token The token value for this string
*
* Returns:
* None.
*/
void AddKeyword( KEYWORD * pk, CHAR * szKeyword, TOKEN token )
{
pk->token = token;
pk->szKeyword = ( CHAR * ) MyMalloc( strlen(szKeyword) + 1 );
if ( pk->szKeyword == NULL )
Error( "Not enough memory to store %s\n", szKeyword );
strcpy( pk->szKeyword, szKeyword );
}
/*
* TokenLookup
*
* Purpose:
* Lookup a token symbol in the rgToken table and return the value
* of the token for it. If the token symbol can't be found, add it
* to the table and assign the next available token value.
*
* Arguments:
* sz The symbol to lookup
*
* Returns:
* The token value for the symbol.
*/
TOKEN TokenLookup( CHAR * sz )
{
KEYWORD * pk = rgToken;
while ( pk->szKeyword && NSzACmp( pk->szKeyword, sz ) )
pk++;
if ( pk->szKeyword == NULL )
{
pk = &rgToken[cToken++];
AddKeyword( pk, sz, sNextToken++ );
fprintf( file[eH], "#define %s\t%d\n", sz, pk->token );
}
return pk->token;
}
/*
* MakeByte
*
* Purpose:
* Write out the representation of a byte for an RCDATA statement into
* the RC file.
*
* Arguments:
* b The byte value to be written out.
*
* Returns:
* None.
*/
void MakeByte( BYTE b )
{
fprintf( file[eRC], "\"\\%03o\"", b );
}
/*
* MakeShort
*
* Purpose:
* Write out the binary image of a short as a RCDATA statement into
* the RC file.
*
* Arguments:
* s The short value to be written out.
*
* Returns:
* None.
*/
void MakeShort( SHORT s )
{
BYTE * pb = ( BYTE * ) &s;
INT i;
for ( i = 0; i < sizeof(SHORT); i++ )
{
MakeByte(*pb++);
if ( i + 1 < sizeof(SHORT) )
fprintf( file[eRC], ", " );
}
}
/*
* MakeLong
*
* Purpose:
* Write out the binary image of a long as a RCDATA statement into
* the RC file.
*
* Arguments:
* l The long value to be written out.
*
* Returns:
* None.
*/
void MakeLong( LONG l )
{
BYTE * pb = ( BYTE * ) &l;
INT i;
for ( i = 0; i < sizeof(LONG); i++ )
{
MakeByte(*pb++);
if ( i + 1 < sizeof(LONG) )
fprintf( file[eRC], ", " );
}
}
/*
* SzMakeQuoted
*
* Purpose:
* Create the C constant string declaration version of a string and
* return a pointer to it.
* The created string is kept in a scratchpad which will be
* overwritten each time this function is called.
*
* Arguments:
* sz String to make a C constant string version of
*
* Returns:
* Pointer to a scratchpad containing C constant string version of
* sz
*/
CHAR * SzMakeQuoted( CHAR * sz )
{
CHAR * pch = szScratch;
*pch++ = '"';
while (*sz)
{
switch (*sz)
{
case '\n':
*pch++ = '\\';
*pch++ = 'n';
break;
case '\r':
*pch++ = '\\';
*pch++ = 'r';
break;
case '\t':
*pch++ = '\\';
*pch++ = 't';
break;
case '\\':
*pch++ = '\\';
*pch++ = '\\';
break;
case '"':
*pch++ = '\\';
*pch++ = '"';
break;
default:
if (isprint(*sz))
*pch++ = *sz;
else
Error( "Don't know how to deal with ASCII %d\n", *sz );
break;
}
sz++;
}
*pch++ = '"';
*pch = '\0';
return szScratch;
}
/*
* GenerateTable
*
* Purpose:
* Generates the C table and RCDATA tables
*
* Arguments:
* None.
*
* Returns:
* None.
*/
void GenerateTable(void)
{
KEYWORD * pk;
INT nOffset;
// Sort the keywords
qsort( rgKeyword, cKeyword, sizeof(KEYWORD), CompareKeywords );
// Put the header for the C table
fprintf( file[eC], "static KEYWORD rgKeyword[] =\n{\n" );
// Put the header for the RCDATA
fprintf( file[eRC], "TOKENS RCDATA\nBEGIN\n" );
// Output our keyword table
pk = rgKeyword;
nOffset = sizeof(rgKeyword);
while ( pk->szKeyword != NULL )
{
// Add the string and token to the C file
fprintf( file[eC], "\t{ %s, %d },\n", SzMakeQuoted(pk->szKeyword),
pk->token );
// Add the table entry into the RC file
MakeLong(nOffset);
fprintf( file[eRC], ", " );
MakeShort(pk->token);
fprintf( file[eRC], ", /* %d, %d */\n", nOffset, pk->token );
nOffset += strlen(pk->szKeyword) + 1;
pk++;
}
// Put the NULL entry for the RCDATA
MakeLong(0);
fprintf( file[eRC], ", " );
MakeShort(pk->token);
fprintf( file[eRC], ", /* %d, %d */\n", 0, pk->token );
// Put the NULL entry for the C table and end the table
fprintf( file[eC], "\t{ NULL, 0 }\n};\n" );
// Output our keyword strings
pk = rgKeyword;
while ( pk->szKeyword != NULL )
{
if ( isprint(*pk->szKeyword) )
fprintf( file[eRC], "\"%s\\0\"", pk->szKeyword );
else
{
MakeByte( *pk->szKeyword );
fprintf( file[eRC], ", " );
MakeByte(0);
}
pk++;
if ( pk->szKeyword != NULL )
fprintf( file[eRC],",");
fprintf( file[eRC],"\n");
}
fprintf( file[eRC], "END\n\n" );
}
int __cdecl main( int argc, char * argv[] )
{
INT i;
CHAR szLine[128];
CHAR szString[128];
CHAR szToken[128];
CHAR *pchCurr;
TOKEN token;
// Verify we have enough parameters
if ( argc != 5 )
Error( "usage: %s tokens.TOK header.H resource.RC table.C\n", argv[0] );
// Blank out our buffers
memset( rgToken, 0, sizeof(rgToken) );
memset( rgKeyword, 0, sizeof(rgKeyword) );
memset( rgchBuffer, 0, sizeof(rgchBuffer) );
// Open the files
for ( i = eTOK; i <= eC; i++ )
if ( ( file[i] = fopen( argv[ i + 1 ], szOpenMode[i] ) ) == NULL )
{
perror( argv[ i + 1 ] );
return -1;
}
// Go through every line in the tokens file
while ( fgets( szLine, sizeof(szLine), file[eTOK] ) )
{
TrimCRLF(szLine);
// Skip blank lines
if ( strlen(szLine) == 0 )
continue;
// Skip comments
if ( szLine[0] == '#' )
continue;
// Get the first word
pchCurr = PchGetNextWord( szLine, szString );
// Do we want to imbed some text someplace ?
if ( !NSzACmp( szString, "IMBED_IN" ) )
{
PchGetNextWord( pchCurr, szString );
HandleImbed(szString);
continue;
}
// Do we want to reset the lowest token value ?
if ( !NSzACmp( szString, "TOKENS" ) )
{
PchGetNextWord( pchCurr, szString );
sNextToken = (TOKEN)atoi(szString);
continue;
}
// Are we specifying a string on this line ?
if ( szString[0] == '"' )
{
// Remove the quotes from the string
TranslateQuoted(szString);
// Get the next word to find out what token value should go with
// this string
PchGetNextWord( pchCurr, szToken );
if ( szToken[0] == '\'' )
{
// We have a single character equivalent for this token.
TranslateQuoted(szToken);
token = *szToken;
}
else if ( isdigit(szToken[0]) )
token = (TOKEN)atoi(szToken);
else
token = TokenLookup(szToken);
// Add the token and string pair to our table
AddKeyword( &rgKeyword[cKeyword++], szString, token );
}
}
// Generate the RC data for the RC file
GenerateTable();
// Close the files
for ( i = eTOK; i <= eC; i++ )
fclose(file[i]);
return 0;
}