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.
 
 
 
 
 
 

1250 lines
52 KiB

/*** MkMsg.c - Microsoft Make Messages Utility *******************************
*
* Copyright (c) 1986-1992, Microsoft Corporation. All Rights Reserved.
*
* Purpose:
* MkMsg.Exe is a utility that helps localize messages emitted by a utility by
* padding them and placing them in message segments.
* MkMsg also allows a programmer to associate symbols and Message Id to a
* message text. It does this by producing a C style header file with #defines
* or a Masm style include file with symbol definitions.
*
* Revision History:
* 02-Oct-1996 DS Remove special '\\' handling in RC output.
* 02-Feb-1994 HV Handle lines with only blansk.
* 25-Jan-1994 HV Add -err to generate external error file in the format:
* NUMBER\tMESSAGE
* 24-Jan-1994 HV Allow quoted message
* 21-Jan-1994 HV Nuke Lead Byte Table [[ ... ]], add !codepage directive
* 21-Jan-1994 HV Field separated by white spaces
* 19-Aug-1993 BW Add Lead Byte Table support
* 07-Apr-1993 BW Add -hex, -c options
* 13-Jul-1992 SB Add -msg option
* 16-Apr-1990 SB Add header
* 13-Apr-1990 SB Collated 6 different versions seperately SLM'ed on \\ODIN
* 19-Apr-1989 LN add "\xhh" recognition
* ??-Apr-1986 RN Created by Randy Nevin
*
* Syntax:
* MKMSG [-h cfile] [-x xcfile] [-inc afile] [-msg cfile] [-c cfile]
* [-asm srcfile [-def str] [-min|-max]] [-386] [-hex] txtfile
*
* Notes:
* The Utility takes as input a message file (a .txt file by convention) and
* produces an assembler source file. The lines in the message file have one
* of the formats which are instructions to MkMsg as follows -
*
* 1) "<<NMSG>>" -- use near message segment
* 2) "<<FMSG>>" -- use far message segment
* ----- Obsolete, see 8)
* 3) "[[XX, YY, ZZ]] - Use hex bytes XX, YY, ZZ as lead byte table.
* Lists are cumulative, empty list clears table.
* -----
* 4) "#Anything" -- comment line (ignored by mkmsg)
* 5) "" -- blank line (ignored by mkmsg)
* 6) "Handle<White space>Number<White space>MessageText" -- associate MessageText with
* message Id Number and the symbol Handle
* 7) "Number<White space>MessageText" -- associate MessageText with Id
* Id Number
* 8) "!codepage xxx" -- use this instead of [[ ... ]]
*
* Options:
* The options can be specified in any order. When no options are specified
* then the input is checked for syntactic validity.
*
*
* -h cfile: create a C style header file cfile with
* #define Handle IdNumber
* If -c is also defined, a declaration for __NMSG_TEXT
* and a mcros defining GET_MSG as __NMSG_TEXT is added.
* -msg cfile: create a C style header file cfile with
* array of struct having fields id and str
* -c cfile: create a file like -msg and add a definition
* of a retrieval function
* -x xcfile: create a C style header file xcfile with
* #define Handle MessageText
* -inc afile: create a MASM style include file afile with
* Handle = IdNumber
* -asm srcfile: create a MASM source file srcfile with standard segment
* definitions and messages in near segment (MSG) or far
* segment (FAR_MSG) depending on whether <<NMSG>> or
* <<FMSG>> is specified. The default is <<NMSG>>.
*
* If -min(-max) is specified then the minimum(maximum)
* 0-padding is calculated and placed in srcfile. This
* depends on the total length of the individual messages.
*
* If -def is specified the public symbol str gets declared.
* This is useful if the the object file produced from the
* MASM source produced is part of a library. The linker
* will link in that module from the library only if it
* resolves some external references.
*
* If -hex is specified and no Lead Byte Table is
* present, all MessageText is rendered in printf-style
* hexidecimal (e.g. "error" becomes
* x65\x72\x72\x6f\x72").
*
* if -hex is specified and a Lead Byte Table is present
* even if it is empty), then all Double Byte characters
* are rendering in hexidecimal.
*
* Future Directions:
* 1> Break up main() into smaller routines
* 2> Use mkmsg for handling messages
* 2> Allow use of spaces as separators, -- done. HV.
* 3> Allow specification of the separator
* 4> Provide -? and -help options.
*
*****************************************************************************/
// DEFINEs
// Standard INCLUDEs
#include <stdarg.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include <locale.h>
#include <mbctype.h>
// Project INCLUDEs
// MACROs
// External PROTOTYPEs
// TYPEDEFs
typedef enum { FALSE = 0, TRUE = !0 } BOOL;
typedef struct status {
char *txt;
char *h;
char *rc;
char *x;
char *inc;
char *msg;
char *c;
char *asm;
char *def;
char *err;
int min;
int max;
int use32;
int hex;
} STATUS;
// Global PROTOTYPEs
void __cdecl Error(char *fmt, ...);
int __cdecl main(int argc, char **argv);
void parseCommandLine(unsigned argc, char **argv, STATUS *opt);
void msg_fputs (unsigned char * pch, int, FILE * fp);
int ReadLine (FILE * fp);
BOOL ParseLine(char **ppSymbol, char **ppNumber, char **ppMessage);
BOOL HandleDirectives(void);
void SetCodePage (const char *pszCodePage);
BOOL IsLeadByte(unsigned by);
// WARNING: the following CRT function is undocumented. This call can only
// be used in our internal product (like this one) only. Please
// contact CRT people for more information.
//void __cdecl __setmbctable(unsigned int);
//
// Lead Byte support
//
unsigned char bUseLeadByteTable = FALSE;
typedef struct
{
unsigned uCodePage; // Codepage number
unsigned byLead[12]; // Leadbyte ranges
} CPTABLE;
CPTABLE cpTable[] =
{
{932, {0x81, 0x9f, 0xe0, 0xfc, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}},
{0, {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}} // trailing to end
};
CPTABLE * pCP = NULL;
// Local PROTOTYPEs
// External VARIABLEs
// Initialized VARIABLEs
int cError = 0;
char didnear = 0;
char didfar = 0;
char dir32[] = ".386\n";
char ex[] = "expected escape sequence: %s\n";
char f1[] = "FAR_HDR segment byte public \'FAR_MSG\'\nFAR_HDR ends\n";
char f2[] = "FAR_MSG segment byte public \'FAR_MSG\'\nFAR_MSG ends\n";
char f3[] = "FAR_PAD segment byte public \'FAR_MSG\'\nFAR_PAD ends\n";
char f4[] = "FAR_EPAD segment byte common \'FAR_MSG\'\nFAR_EPAD ends\n";
char f5[] = "FMGROUP group FAR_HDR,FAR_MSG,FAR_PAD,FAR_EPAD\n\n";
char n1[] = "HDR segment byte public \'MSG\'\nHDR ends\n";
char n2[] = "MSG segment byte public \'MSG\'\nMSG ends\n";
char n3[] = "PAD segment byte public \'MSG\'\nPAD ends\n";
char n4[] = "EPAD segment byte common \'MSG\'\nEPAD ends\n";
char n5[] = "DGROUP group HDR,MSG,PAD,EPAD\n\n";
char usage[] = "\nMicrosoft (R) Message Creation Utility Version %s"
"\nCopyright (c) Microsoft Corp %s. All rights reserved.\n"
"\nusage: MKMSG [-h cfile] [-rc rcfile] [-x xcfile] [-msg cfile]\n"
"\t[-c cfile] [-err errfile] [-inc afile]\n"
"\t[-asm srcfile [-def str] [-min|-max]] [-386] [-hex] txtfile\n";
char szVersionNo[] = "1.00.0011";
char szCopyRightYrs[] = "1986-1996";
// Local VARIABLEs
#define MSGSTYLE_COPY 0
#define MSGSTYLE_C_HEX 1
#define MSGSTYLE_ASM_BYTE 2
#define MSGSTYLE_ASM_TEXT 3
#define FALSE 0
#define TRUE (!FALSE)
#define INBUFSIZE 1024
//static char buf[INBUFSIZE]; // line buffer
char *buf; // The real buffer is in ReadLine()
//--------------------------------------------------------------------------
int __cdecl
main(int argc, char **argv)
{
FILE *f; // the input file
FILE *fh = NULL; // -h stream
FILE *frc = NULL; // -rc stream
FILE *fx = NULL; // -x stream
FILE *fc = NULL; // -c stream
FILE *finc = NULL; // -inc stream
FILE *fmsg = NULL; // -msg stream
FILE *fasm = NULL; // -asm stream
FILE *ferr = NULL; // -err stream
int asmstate = 0; // 0=nothing, 1=doing nmsg, 2=doing fmsg
int instring; // db "...
unsigned int nLineCur = 0; // Current line
unsigned int cchLine; // Chars in current line
char *p;
int npad = 0; // cumulative amount of near padding
int fpad = 0; // cumulative amount of far padding
int length;
double factor;
double result;
static STATUS opt; // Command line options
parseCommandLine(argc, argv, &opt);
if ((opt.def || opt.min || opt.max ) && !opt.asm) {
Error( "-def/-min/-max ignored; no -asm file\n" );
opt.min = opt.max = 0;
}
if (opt.min && opt.max) {
Error( "-min and -max are mutually exclusive; -min chosen\n" );
opt.max = 0;
}
if (!(f = fopen( opt.txt, "rb" ))) {
Error( "can't open txtfile %s for binary reading\n", opt.txt );
return( -1 );
}
if (opt.asm && !(fasm = fopen( opt.asm, "w" ))) {
Error( "can't open -asm file %s for writing\n", opt.asm );
return( -1 );
}
if (opt.h && !(fh = fopen( opt.h, "w" ))) {
Error( "can't open -h file %s for writing\n", opt.h );
return( -1 );
}
if (fh && opt.c) {
fprintf (fh, "char * __NMSG_TEXT (unsigned);\n\n");
}
if (opt.rc && !(frc = fopen(opt.rc, "w")))
{
Error("Can't open -rc file %s for writing\n", opt.rc);
return -1;
}
if (opt.rc) {
fprintf(frc, "STRINGTABLE\nBEGIN\n");
}
if (opt.x && !(fx = fopen( opt.x, "w" ))) {
Error( "can't open -x file %s for writing\n", opt.x );
return( -1 );
}
if (opt.inc && !(finc = fopen( opt.inc, "w" ))) {
Error( "can't open -inc file %s for writing\n", opt.inc );
return( -1 );
}
if (opt.msg && !(fmsg = fopen( opt.msg, "w" ))) {
Error( "can't open -msg file %s for writing\n", opt.msg );
return( -1 );
}
if (opt.err && !(ferr = fopen(opt.err, "w")))
{
Error("Can't open -err file %s for writing\n", opt.err);
return -1;
}
if (fmsg) {
fprintf(fmsg, "typedef struct _message {\n"
"\tunsigned\tid;\n"
"\tchar *str;\n"
"} MESSAGE;\n\n");
fprintf(fmsg, "MESSAGE __MSGTAB[] = {\n");
}
if (opt.c && !(fc = fopen( opt.c, "w" ))) {
Error( "can't open -c file %s for writing\n", opt.c );
return( -1 );
}
if (fc) {
fprintf(fc, "#include <stdio.h>\n\n");
fprintf(fc, "typedef struct _message {\n"
"\tunsigned int\tid;\n"
"\tchar *str;\n"
"} MESSAGE;\n\n");
fprintf(fc, "MESSAGE __MSGTAB[] = {\n");
}
while ((cchLine = ReadLine ( f )) != EOF) // process lines
{
nLineCur++;
if (buf[0] == '\0' || buf[0] == '#')
{
continue;
}
else if (HandleDirectives()) // Directive
{
continue;
}
else if (buf[0] == '[' && buf[1] == '[') // Old style leadbyte tbl
{
fprintf(stderr,
"WARNING: Ignore leadbyte table, use !codepage instead: %s\n",
buf);
continue;
}
else if (buf[0] == '<') // <<NMSG>> or <<FMSG>>
{
if (!strcmp( "<<NMSG>>", buf )) // near msgs follow
{
if (asmstate == 0)
{
if (fasm)
{
if (!didnear) {
didnear++;
if (opt.use32)
fprintf( fasm, dir32);
fprintf( fasm, n1 );
fprintf( fasm, n2 );
fprintf( fasm, n3 );
fprintf( fasm, n4 );
fprintf( fasm, n5 );
}
fprintf( fasm,
"MSG segment\n" );
if (opt.def)
{
fprintf( fasm, "\tpublic\t%s\n", opt.def );
fprintf( fasm, "%s\tequ\t$\n", opt.def );
}
asmstate = 1;
} // if (fasm)
} // if (asmstate == 0)
else if (asmstate == 1)
{
Error( "already in nmsg\n" );
}
else if (asmstate == 2 && !opt.use32)
{
if (fasm)
{
fprintf( fasm, "FAR_MSG ends\n\n" );
if (!didnear)
{
didnear++;
fprintf( fasm, n1 );
fprintf( fasm, n2 );
fprintf( fasm, n3 );
fprintf( fasm, n4 );
fprintf( fasm, n5 );
}
fprintf( fasm, "MSG segment\n" );
asmstate = 1;
} // if (fasm)
} // else if (asmstate == 2 ...)
else
{
Error( "internal error\n" );
return( -1 );
}
} // if near msg
else if (!strcmp( "<<FMSG>>", buf ))//far msgs follow
{
if (asmstate == 0)
{
if (fasm)
{
if (!didfar)
{
didfar++;
if (opt.use32)
{
fprintf( fasm, dir32);
fprintf( fasm, n1 );
fprintf( fasm, n2 );
fprintf( fasm, n3 );
fprintf( fasm, n4 );
fprintf( fasm, n5 );
fprintf( fasm, "MSG segment\n" );
}
else
{
fprintf( fasm, f1 );
fprintf( fasm, f2 );
fprintf( fasm, f3 );
fprintf( fasm, f4 );
fprintf( fasm, f5 );
fprintf( fasm, "FAR_MSG segment\n" );
}
} // if (!didfar)
if (opt.def)
{
fprintf( fasm, "\tpublic\t%s\n", opt.def );
fprintf( fasm, "%s\tequ\t$\n", opt.def );
}
asmstate = 2;
} // if (fasm)
} // if (asmstate == 0)
else if (asmstate == 1 && !opt.use32)
{
if (fasm)
{
fprintf( fasm, "MSG ends\n\n" );
if (!didfar)
{
didfar++;
fprintf( fasm, f1 );
fprintf( fasm, f2 );
fprintf( fasm, f3 );
fprintf( fasm, f4 );
fprintf( fasm, f5 );
}
fprintf( fasm, "FAR_MSG segment\n" );
asmstate = 2;
}
} // else if (asmstate == 1 ...)
else if (asmstate == 2)
{
Error( "already in far_msg\n" );
}
else
{
Error( "internal error\n" );
return( -1 );
}
} // far message
else // Not near, not far
{
Error( "ignoring bad line: %s\n", buf );
}
} // if (.. < ) near/far message
else if (buf[0] != '\r' && buf[0] != '\n') // something to do
{
char *pSymbol;
char *pNumber;
char *pMessage;
if (!ParseLine(&pSymbol, &pNumber, &pMessage))
{
fprintf( stderr, "%s(%d): error in line: \"%s\"\n", opt.txt, nLineCur, buf);
continue;
}
if (pSymbol && opt.h)
{
fprintf( fh, "#define\t%s\t%s\n", pSymbol, pNumber );
}
if (opt.rc)
{
fprintf(frc, "\t%s, \"%s\"\n", pNumber, pMessage);
}
if (pSymbol && opt.x)
{
fprintf( fx, "#define\t%s\t\"", pSymbol );
msg_fputs( pMessage
, opt.hex ? MSGSTYLE_C_HEX : MSGSTYLE_COPY
, fx );
putc( '\"', fx );
putc( '\n', fx );
}
if (pSymbol && opt.inc)
{
fprintf( finc, "%s\t=\t%s\n", pSymbol, pNumber);
}
if (opt.msg)
{
fprintf( fmsg, "{%s, \"", pNumber );
msg_fputs( pMessage, opt.hex ? MSGSTYLE_C_HEX : MSGSTYLE_COPY, fmsg );
fprintf( fmsg, "\"}," );
if (opt.hex)
fprintf( fmsg, " // \"%s\"", pMessage );
putc ( '\n', fmsg );
}
if (opt.c)
{
fprintf( fc, "{%s, \"", pNumber );
msg_fputs( pMessage, opt.hex ? MSGSTYLE_C_HEX : MSGSTYLE_COPY, fc );
fprintf( fc, "\"}," );
if (opt.hex)
fprintf( fc, " // \"%s\"", pMessage );
putc ( '\n', fc );
}
if (opt.err)
{
fprintf(ferr, "%s\t\"%s\"\n", pNumber, pMessage);
} // opt.err
if (fasm) // write asmfile
{
if (asmstate == 0)
{
if (!didnear)
{
didnear++;
if (opt.use32)
fprintf( fasm, dir32);
fprintf( fasm, n1 );
fprintf( fasm, n2 );
fprintf( fasm, n3 );
fprintf( fasm, n4 );
fprintf( fasm, n5 );
}
fprintf( fasm, "MSG segment\n" );
if (opt.def)
{
fprintf( fasm, "\tpublic\t%s\n", opt.def );
fprintf( fasm, "%s\tequ\t$\n", opt.def );
}
asmstate = 1;
} // if (asmstate == 0)
fprintf( fasm, "\tdw\t%s\n\tdb\t", pNumber );
instring = 0;
for (p = pMessage, length = 0; *p; p++, length++)
{
// allocate message
if (*p == '\\')
{
// C escape sequence
switch (*++p)
{
case 'r':
case 'n':
case 't':
case 'f':
case 'v':
case 'b':
case '\'':
case '"':
case '\\':
case 'x':
if (instring) {
putc( '"', fasm );
putc( ',', fasm );
instring = 0;
}
if (*p == 'x') {
p++;
if (*p && *(p+1))
fprintf ( fasm, "0%c%ch", *p, *(p+1));
else
puts ("Error in Hex Constant");
p++;
}
else if (*p == 'r')
fprintf( fasm, "13" );
else if (*p == 'n')
fprintf( fasm, "10" );
else if (*p == 't')
fprintf( fasm, "9" );
else if (*p == 'f')
fprintf( fasm, "12" );
else if (*p == 'v')
fprintf( fasm, "11" );
else if (*p == 'b')
fprintf( fasm, "8" );
else if (*p == '\'')
fprintf( fasm, "39" );
else if (*p == '"')
fprintf( fasm, "34" );
else if (*p == '\\')
fprintf( fasm, "92" );
putc( ',', fasm );
break;
case '\0':
//not an error, warning ...
fprintf(stderr, ex, buf);
p--;
break;
default:
if (!instring) {
putc( '"', fasm );
instring = 1;
}
putc( *p, fasm );
break;
} // switch
} //if (*p == '\\')
else if (instring) // keep building string
{
putc( *p, fasm );
if (IsLeadByte(*p))
putc( *++p, fasm );
}
else // start building string
{
putc( '"', fasm );
instring = 1;
putc( *p, fasm );
if (IsLeadByte(*p))
putc( *++p, fasm );
}
} // for
if (instring) // close string
{
putc( '"', fasm );
putc( ',', fasm );
}
putc( '0', fasm );
putc( '\n', fasm );
// calculate padding
// depends on msg length
if (opt.min || opt.max)
{
if (opt.min)
if (length <= 10)
factor = 1.01;
else if (length <= 20)
factor = 0.81;
else if (length <= 30)
factor = 0.61;
else if (length <= 50)
factor = 0.41;
else if (length <= 70)
factor = 0.31;
else
factor = 0.30;
else if (length <= 10)
factor = 2.00;
else if (length <= 20)
factor = 1.00;
else if (length <= 30)
factor = 0.80;
else if (length <= 50)
factor = 0.60;
else if (length <= 70)
factor = 0.40;
else
factor = 0.30;
result = (double)length * factor;
if (asmstate == 1 || opt.use32)
{
npad += (int)result;
if (result > (float)((int)result))
npad++;
}
else if (asmstate == 2)
{
fpad += (int)result;
if (result > (float)((int)result))
fpad++;
}
} // if (opt.min || opt.max)
} // if (fasm)...
} // Something to do
} // while read line
if (fmsg) { // finish up -msg stuff
fprintf(fmsg, "{0, NULL}\n};\n");
}
if (fc) // finish up -c stuff
{
fprintf(fc, "{0, NULL}\n};\n\n");
fprintf(fc, "char * __NMSG_TEXT(\n" );
fprintf(fc, "unsigned msgId\n" );
fprintf(fc, ") {\n" );
fprintf(fc, " MESSAGE *pMsg = __MSGTAB;\n" );
fprintf(fc, "\n" );
fprintf(fc, " for (;pMsg->id; pMsg++) {\n" );
fprintf(fc, " if (pMsg->id == msgId)\n" );
fprintf(fc, " break;\n" );
fprintf(fc, " }\n" );
fprintf(fc, " return pMsg->str;\n" );
fprintf(fc, "}\n" );
} // if (fc)
if (fasm) // finish up asm file
{
if (asmstate == 1 || opt.use32)
fprintf( fasm, "MSG ends\n\n");
else if (asmstate == 2)
fprintf( fasm, "FAR_MSG ends\n\n");
if (npad) { // add near padding
fprintf( fasm, "PAD segment\n\tdb\t%d dup(0)\n", npad );
fprintf( fasm, "PAD ends\n\n" );
}
if (fpad) { // add far padding
fprintf( fasm, "FAR_PAD segment\n\tdb\t%d dup(0)\n", fpad );
fprintf( fasm, "FAR_PAD ends\n\n" );
}
fprintf( fasm, "\tend\n" );
fclose( fasm );
} // if (fasm)
if (fh)
{
if (opt.c)
fprintf (fh, "\n#define GET_MSG(x) __NMSG_TEXT(x)\n");
fclose( fh );
}
if (frc) {
fprintf(frc, "END\n");
fclose( frc );
}
if (fx) fclose( fx );
if (finc) fclose( finc );
if (fmsg) fclose( fmsg );
if (fc) fclose( fc );
if (ferr) fclose( ferr );
fclose( f );
return(cError ? 1 : 0);
} // main()
void
parseCommandLine(
unsigned argc,
char **argv,
STATUS *opt
)
{
// skip argv[0]
argc--; argv++;
while (argc && **argv == '-') // process options
{
if (!strcmp("-err", *argv)) // Create .err file
{
argc--; argv++;
if (!argc)
Error("no -err file given\n");
else if (opt->err)
Error("extra -err for %s ignored\n", *argv);
else
{
opt->err = *argv;
argc--; argv++;
}
} // -err
else if (!strcmp( "-h", *argv )) { // create .h file
argc--; argv++;
if (!argc)
Error( "no -h file given\n" );
else if (opt->h) {
Error( "extra -h file %s ignored\n", *argv );
argc--; argv++;
}
else { // remember -h file
opt->h = *argv;
argc--; argv++;
}
}
else if (!strcmp("-rc", *argv)) { // Create .rc file
argc--; argv++;
if (!argc)
Error("no -rc file given\n");
else if (opt->rc)
Error("extra -rc for %s ignored\n", *argv);
else
{
opt->rc = *argv;
argc--; argv++;
}
}
else if (!strcmp( "-x", *argv )) { // create .h file
argc--; argv++;
if (!argc)
Error( "no -x file given\n" );
else if (opt->x) {
Error( "extra -x file %s ignored\n", *argv );
argc--; argv++;
}
else { // remember -x file
opt->x = *argv;
argc--; argv++;
}
}
else if (!strcmp( "-inc", *argv )) { // create .inc file
argc--; argv++;
if (!argc)
Error( "no -inc file given\n" );
else if (opt->inc) {
Error( "extra -inc file %s ignored\n", *argv );
argc--; argv++;
}
else { // remember -inc file
opt->inc = *argv;
argc--; argv++;
}
}
else if (!strcmp( "-msg", *argv )) { // create .h file with struct
argc--; argv++;
if (!argc)
Error( "no -msg file given\n" );
else if (opt->msg) {
Error( "extra -msg file %s ignored\n", *argv );
argc--; argv++;
}
else { // remember -msg file
opt->msg = *argv;
argc--; argv++;
}
}
else if (!strcmp( "-c", *argv )) { // create .c file with struct and function
argc--; argv++;
if (!argc)
Error( "no -c file given\n" );
else if (opt->c) {
Error( "extra -c file %s ignored\n", *argv );
argc--; argv++;
}
else { // remember -c file
opt->c = *argv;
argc--; argv++;
}
}
else if (!strcmp( "-asm", *argv )) { // create .asm file
argc--; argv++;
if (!argc)
Error( "no -asm file given\n" );
else if (opt->asm) {
Error( "extra -asm file %s ignored\n", *argv );
argc--;
argv++;
}
else { // remember -asm file
opt->asm = *argv;
argc--; argv++;
}
}
else if (!strcmp( "-def", *argv )) {
argc--; argv++;
if (!argc)
Error( "no -def string given\n" );
else {
opt->def = *argv;
argc--; argv++;
}
}
else if (!strcmp( "-min", *argv )) { // minimum padding
argc--; argv++;
if (opt->min)
Error( "redundant -min\n" );
opt->min = 1;
}
else if (!strcmp( "-max", *argv )) { // maximum padding
argc--; argv++;
if (opt->max)
Error( "redundant -max\n" );
opt->max = 1;
}
else if (!strcmp( "-386", *argv)) { // 32-bit segments
argc--; argv++;
if (opt->use32)
Error( "redundant -386\n" );
opt->use32 = 1;
}
else if (!strcmp( "-hex", *argv)) { // hex rendering of text
argc--; argv++;
if (opt->hex)
Error( "redundant -hex\n" );
opt->hex = 1;
}
else {
Error( "unknown option %s ignored\n", *argv );
argc--;
argv++;
}
} // while
if (!argc) { // no arguments
Error( usage, szVersionNo, szCopyRightYrs );
exit( -1 );
}
if (argc != 1) // extra arguments
Error( "ignoring extra arguments\n" );
opt->txt = *argv;
} // ParseCommandLine()
//
// Read One line into global buf
//
int
ReadLine (FILE * fp)
{
int i = 0;
int ch;
static char szBuffer[INBUFSIZE];
while ((ch = getc( fp )) != EOF && ch != '\r' && ch != '\n' && ch != '\x1A')
if (i < INBUFSIZE-1)
szBuffer[i++] = (char)ch;
if (ch == EOF && i == 0)
return EOF;
if (ch == '\r')
getc ( fp ); // Flush line feed
szBuffer[i] = '\0';
// Skip initial space
for (buf = szBuffer; *buf && isspace(*buf); buf++)
i--;
return i;
}
void
__cdecl
Error(
char *fmt,
...
) {
va_list args;
va_start (args, fmt);
vfprintf(stderr, fmt, args);
++cError;
}
///// msg_fputs
//
// Purpose:
//
// Send string to file in the given format.
//
//////////////////////////////////////////////////////////////////////////
void msg_fputs(
unsigned char * pch,
int style,
FILE * fp
) {
char chbuf[8];
unsigned char bInDBCS = FALSE;
static int bPrevWasHex = FALSE;
switch (style)
{
case MSGSTYLE_COPY:
fputs (pch, fp);
break;
case MSGSTYLE_C_HEX:
for (;*pch; pch++) {
// If a lead byte table was specified, we use hex
// only for double-byte characters, and for hex
// digits after hex output. This later is because
// hex constants terminate only when a non-hex digit
// (like a \) is encountered.
//
if (!bUseLeadByteTable
|| bInDBCS || IsLeadByte(*pch)
|| (bPrevWasHex && isxdigit(*pch))) {
sprintf (chbuf, "\\x%2.2x", *pch);
fputs (chbuf, fp);
bInDBCS = bInDBCS ? FALSE : IsLeadByte(*pch);
bPrevWasHex = TRUE;
}
else {
fputc(*pch, fp);
bPrevWasHex = FALSE;
}
}
break;
case MSGSTYLE_ASM_TEXT: // UNDONE
case MSGSTYLE_ASM_BYTE: // UNDONE
break;
}
}
///// SetCodePage
//
// Purpose:
//
// Switch to the specified codepage so that we can recognize a lead
// byte using IsLeadByte().
//
// Parameters:
// const char *pszCodePage: Points to a buffer containing the codepage
// in the the format of ".xxx" where xxx is
// the codepage number.
//
// Note:
// This function replaces the old SetLeadByteTable(), which fills
// the global lead byte table with values the user supplied in the
// message file.
//
///////////////////////////////////////////////////////////////////////////
void
SetCodePage(const char *pszCodePage)
{
unsigned i;
unsigned uCodePage;
if (!setlocale(LC_ALL, pszCodePage)) // Switch to new locale
{
//__setmbctable(atoi(pszCodePage+1)); // Failed, use undoc'ed call
// Failed, use internal codepage table
uCodePage = atoi(pszCodePage+1);
for (i = 0; cpTable[i].uCodePage; i++)
{
if (cpTable[i].uCodePage == uCodePage) // Found
{
pCP = &cpTable[i];
break;
}
} // for
if (0 == cpTable[i].uCodePage)
fprintf(stderr, "WARNING: unknown codepage: %s\n", pszCodePage+1);
}
bUseLeadByteTable = TRUE;
}
#ifdef VERBOSE
#define DB(x) x
#else
#define DB(x)
#endif
BOOL
IsLeadByte(unsigned by)
{
unsigned byIndex;
DB(printf("IsLeadByte(0x%02x) ==> ",by));
if (!bUseLeadByteTable)
{
DB(printf("FALSE\n"));
return FALSE;
}
if (!pCP)
#ifdef NT_BUILD
puts("Codepage support not implemented");
#else
return _ismbblead(by);
#endif
for (byIndex = 0; pCP->byLead[byIndex]; byIndex += 2)
{
if (pCP->byLead[byIndex] <= by && by <= pCP->byLead[byIndex+1])
{
DB(printf("TRUE\n"));
return TRUE;
}
}
DB(printf("FALSE\n"));
return FALSE;
}
///// ParseLine
//
// Purpose:
//
// Break the input line to 3 fields: symbol, number, and message.
// The symbol field is optional: if the first non-blank char in
// the line is a digit, then the symbol field is set to NULL.
//
// Assumption:
// We assume that the input line has the following formats:
// [<White space> SYMBOL] <White space> NUMBER <White space> MESSAGE
// where as the text between the square brackets ([]) is optional.
//
// Parameters:
// char **ppSymbol: Points to the buffer containing the symbol.
// *ppSymbol == NULL if there is no symbol.
// char **ppNumber: Points to the buffer containing the number.
// char **ppMessage: Points to the buffer containing the message.
//
// Use Global:
// buf Contains the line to examine.
//
// Return Value:
// TRUE: The line is a valid line.
// FALSE: The line is not a valid line.
//
///////////////////////////////////////////////////////////////////////////
BOOL
ParseLine(char **ppSymbol, char **ppNumber, char **ppMessage)
{
unsigned char *pBuf = buf;
#define SKIP_BLANKS() for ( ; *pBuf && isspace(*pBuf); pBuf++)
#define SKIP_TO_BLANKS() for ( ; *pBuf && !isspace(*pBuf); pBuf++)
#define CHECK_NULL() if (!*pBuf) return FALSE;
SKIP_BLANKS(); // Skip initial blanks
CHECK_NULL(); // Blank line?
if (!isdigit(*pBuf)) // Symbol?
{
*ppSymbol = pBuf;
SKIP_TO_BLANKS();
CHECK_NULL();
*pBuf++ = '\0';
SKIP_BLANKS();
CHECK_NULL();
}
else
*ppSymbol = NULL;
*ppNumber = pBuf;
SKIP_TO_BLANKS();
CHECK_NULL();
*pBuf++ = '\0';
SKIP_BLANKS();
CHECK_NULL();
*ppMessage = pBuf;
// Handle quoted message: if the message does not begin with quote, it is
// extended to end of line. If it begins with a double quote character,
// then it is extended to the closing quote, or end of line, whichever
// comes first. While scanning for closing quote, we ignore the '\"',
// which is the literal quote character.
if ('\"' == *pBuf) // quoted message
{
*ppMessage = ++pBuf;
while (*pBuf && '\"' != *pBuf)
{
if ('\\' == *pBuf || IsLeadByte(*pBuf))
pBuf++;
if (*pBuf)
pBuf++;
} // while
*pBuf = '\0';
} // if ... quoted message
return TRUE;
}
///// HandleDirectives
//
// Purpose:
//
// Determine if a line contains a directive, then carry out the
// directive's command.
//
// Use Global:
// buf Contains the line to examine.
//
// Return Value:
// TRUE: The line is a directive.
// FALSE: The line is not a directive
//
///////////////////////////////////////////////////////////////////////////
BOOL
HandleDirectives(void)
{
register unsigned char *pBuf = buf;
unsigned char *pEnd;
for ( ; *pBuf && isspace(*pBuf); pBuf++) // Skip leading spaces
;
if (!_strnicmp("!codepage", pBuf, 9)) // Change the codepage
{
for (pBuf += 9; *pBuf && isspace(*pBuf); pBuf++) // Skip spaces
;
*--pBuf = '.';
for (pEnd = pBuf + 1; *pEnd && isdigit(*pEnd); pEnd++)
;
*pEnd = '\0';
SetCodePage(pBuf);
return TRUE;
}
else if ('!' == *pBuf)
{
Error("Unrecognized directive: '%s'\n", pBuf);
return TRUE;
}
return FALSE;
} // HandleDirectives