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.
 
 
 
 
 
 

911 lines
28 KiB

/***********************************************************************
* Microsoft (R) Windows (R) Resource Compiler
*
* Copyright (c) Microsoft Corporation. All rights reserved.
*
* File Comments:
*
*
***********************************************************************/
#include "rc.h"
#include <ddeml.h>
/************************************************************************/
/* Internal constants */
/************************************************************************/
#define GOT_IF 1 /* last nesting command was an if.. */
#define GOT_ELIF 2 /* last nesting command was an if.. */
#define GOT_ELSE 3 /* last nesting command was an else */
#define GOT_ENDIF 4 /* found endif */
#define ELSE_OR_ENDIF 5 /* skip to either #else or #endif */
#define ENDIF_ONLY 6 /* skip to #endif -- #else is an error*/
int ifstack[IFSTACK_SIZE];
/************************************************************************/
/* Local Function Prototypes */
/************************************************************************/
void chk_newline(const wchar_t *);
void in_standard(void);
int incr_ifstack(void);
token_t next_control(void);
unsigned long int pragma(void);
int skipto(int);
void skip_quoted(int);
PWCHAR sysinclude(void);
/************************************************************************/
/* incr_ifstack - Increment the IF nesting stack */
/************************************************************************/
int
incr_ifstack(
void
)
{
if(++Prep_ifstack >= IFSTACK_SIZE) {
fatal(1052);
}
return(Prep_ifstack);
}
/************************************************************************
* SYSINCLUDE - process a system include : #include <foo>
*
* ARGUMENTS - none
*
* RETURNS - none
*
* SIDE EFFECTS - none
*
* DESCRIPTION
* Get the system include file name. Since the name is not a "string",
* the name must be built much the same as the -E option rebuilds the text
* by using the Tokstring expansion for tokens with no expansion already
*
* NOTE : IS THIS ANSI? note we're just reading chars, and not expanding
* any macros. NO, it's not. it must expand the macros.
* TODO : have it call yylex() unless and until it finds a '>' or a newline.
* (probably have to set On_pound_line to have yylex return the newline.)
*
* AUTHOR
* Ralph Ryan Sep. 1982
*
* MODIFICATIONS - none
*
*
************************************************************************/
PWCHAR
sysinclude(
void
)
{
REG int c;
REG WCHAR *p_fname;
p_fname = Reuse_W;
c = skip_cwhite();
if( c == L'\n' ) {
UNGETCH();
error(2012); /* missing name after '<' */
return(NULL);
}
while( c != L'>' && c != L'\n' ) {
*p_fname++ = (WCHAR)c; /* check for buffer overflow ??? */
c = get_non_eof();
}
if( c == L'\n' ) {
UNGETCH();
error(2013); /* missing '>' */
return(NULL);
}
if(p_fname != Reuse_W) {
p_fname--;
while((p_fname >= Reuse_W) && iswspace(*p_fname)) {
p_fname--;
}
p_fname++;
}
*p_fname = L'\0';
return(Reuse_W);
}
/************************************************************************
** preprocess : the scanner found a # which was the first non-white char
** on a line.
************************************************************************/
void
preprocess(
void
)
{
REG WCHAR c;
long eval;
int condition;
token_t deftok;
hln_t identifier;
unsigned long int cp;
if(Macro_depth != 0) { /* # only when not in a macro */
return;
}
switch(CHARMAP(c = skip_cwhite())) {
case LX_ID:
getid(c);
HLN_NAME(identifier) = Reuse_W;
HLN_LENGTH(identifier) = (UINT)Reuse_W_length;
HLN_HASH(identifier) = Reuse_W_hash;
break;
case LX_NL:
UNGETCH();
return;
default:
error(2019, c); /* unknown preprocessor command */
skip_cnew(); /* finds a newline */
return;
}
On_pound_line = TRUE;
start:
switch(deftok = is_pkeyword(HLN_IDENTP_NAME(&identifier))) {
int old_prep;
case P0_DEFINE :
define();
break;
case P0_LINE :
old_prep = Prep;
Prep = FALSE;
yylex();
if(Basic_token != L_CINTEGER) { /* #line needs line number */
error(2005, TS_STR(Basic_token)); /* unknown preprocessor command */
Prep = old_prep;
skip_cnew();
On_pound_line = FALSE;
return;
}
/*
** -1 because there's a newline at the end of this line
** which will be counted later when we find it.
** the #line says the next line is the number we've given
*/
Linenumber = TR_LVALUE(yylval.yy_tree) - 1;
yylex();
Prep = old_prep;
switch(Basic_token) {
case L_STRING:
if( wcscmp(Filename, yylval.yy_string.str_ptr) != 0) {
wcsncpy(Filename,
yylval.yy_string.str_ptr,
sizeof(Filebuff) / sizeof(WCHAR)
);
}
case L_NOTOKEN:
break;
default:
error(2130, TS_STR(Basic_token)); /* #line needs a string */
skip_cnew();
On_pound_line = FALSE;
return;
}
emit_line();
chk_newline(L"#line");
break;
case P0_INCLUDE :
old_prep = Prep;
Prep = FALSE;
InInclude = TRUE;
yylex();
InInclude = FALSE;
Prep = old_prep;
switch(Basic_token) {
case L_LT:
if((sysinclude()) == NULL) {
skip_cnew();
On_pound_line = FALSE;
return;
}
yylval.yy_string.str_ptr = Reuse_W;
break;
case L_STRING:
break;
default:
error(2006, TS_STR(Basic_token)); /* needs file name */
skip_cnew();
On_pound_line = FALSE;
return;
break;
}
wcscpy(Reuse_Include, yylval.yy_string.str_ptr);
chk_newline(L"#include");
if( wcschr(Path_chars, *yylval.yy_string.str_ptr) ||
(wcschr(Path_chars, L':') && (yylval.yy_string.str_ptr[1] == L':'))) {
/*
** we have a string which either has a 1st char which is a path
** delimiter or, if ':' is a path delimiter (DOS), which has
** "<drive letter>:" as the first two characters. Such names
** specify a fully qualified pathnames. Do not append the search
** list, just look it up.
*/
if( ! newinput(yylval.yy_string.str_ptr, MAY_OPEN)) {
fatal(1015, Reuse_W); /* can't find include file */
}
}
else if( (Basic_token != L_STRING) || (! nested_include())) {
in_standard();
}
break;
case P0_IFDEF :
case P0_IFNDEF :
if(CHARMAP(c = skip_cwhite()) != LX_ID) {
fatal(1016);
}
getid(c);
eval = (get_defined()) ? TRUE : FALSE;
chk_newline((deftok == P0_IFDEF) ? L"#ifdef" : L"#ifndef");
if(deftok == P0_IFNDEF) {
eval = ( ! eval );
}
if( eval || ((condition = skipto(ELSE_OR_ENDIF)) == GOT_ELSE) ) {
/*
** expression is TRUE or when we skipped the false part
** we found a #else that will be expanded.
*/
ifstack[incr_ifstack()] = GOT_IF;
} else if(condition == GOT_ELIF) {
/* hash is wrong, but it won't be used */
HLN_NAME(identifier) = L"if"; /* sleazy HACK */
goto start;
}
break;
case P0_IF :
old_prep = Prep;
Prep = FALSE;
InIf = TRUE;
eval = do_constexpr();
InIf = FALSE;
Prep = old_prep;
chk_newline(PPifel_str /* "#if/#elif" */);
if((eval) || ((condition = skipto(ELSE_OR_ENDIF)) == GOT_ELSE) ) {
/*
** expression is TRUE or when we skipped the false part
** we found a #else that will be expanded.
*/
ifstack[incr_ifstack()] = GOT_IF;
if(Eflag && !eval)
emit_line();
} else {
/*
** here the #if's expression was false, so we skipped until we found
** an #elif. we'll restart and fake that we're processing a #if
*/
if(Eflag)
emit_line();
if(condition == GOT_ELIF) {
/* hash is wrong, but it won't be needed */
HLN_NAME(identifier) = L"if"; /* sleazy HACK */
goto start;
}
}
break;
case P0_ELIF :
/*
** here, we have found a #elif. first check to make sure that
** this is not an occurrance of a #elif with no preceding #if.
** (if Prep_ifstack < 0) then there is no preceding #if.
*/
if(Prep_ifstack-- < 0) {
fatal(1018);
}
/*
** now, the preceding #if/#elif was true, and we've
** just found the next #elif. we want to skip all #else's
** and #elif's from here until we find the enclosing #endif
*/
while(skipto(ELSE_OR_ENDIF) != GOT_ENDIF) {
;
}
if(Eflag)
emit_line();
break;
case P0_ELSE : /* the preceding #if/#elif was true */
if((Prep_ifstack < 0) || (ifstack[Prep_ifstack--] != GOT_IF)) {
fatal(1019); /* make sure there was one */
}
chk_newline(PPelse_str /* "#else" */);
skipto(ENDIF_ONLY);
if(Eflag)
emit_line();
break;
case P0_ENDIF : /* only way here is a lonely #endif */
if(Prep_ifstack-- < 0) {
fatal(1020);
}
if(Eflag)
emit_line();
chk_newline(PPendif_str /* "#endif" */);
break;
case P0_PRAGMA :
cp = pragma();
if (cp != 0) {
if (cp == CP_WINUNICODE) {
if (fWarnInvalidCodePage) {
warning(4213);
} else {
fatal(4213);
}
break;
}
if (!IsValidCodePage(cp)) {
if (fWarnInvalidCodePage) {
warning(4214);
} else {
fatal(4214);
}
break;
}
if (cp != uiCodePage) {
if (!io_restart(cp)) {
fatal(1121);
}
uiCodePage = cp; // can't be set until now!
}
}
break;
case P0_UNDEF :
if(CHARMAP(c = skip_cwhite()) != LX_ID) {
warning(4006); /* missing identifier on #undef */
} else {
getid(c);
undefine();
}
chk_newline(L"#undef");
break;
case P0_ERROR:
{
PWCHAR p;
p = Reuse_W;
while((c = get_non_eof()) != LX_EOS) {
if(c == L'\n') {
UNGETCH();
break;
}
*p++ = c;
}
*p = L'\0';
}
error(2188, Reuse_W);
chk_newline(L"#error");
break;
case P0_IDENT:
old_prep = Prep ;
Prep = FALSE;
yylex();
Prep = old_prep;
if(Basic_token != L_STRING) {
warning(4079, TS_STR(Basic_token));
}
chk_newline(L"#error");
break;
case P0_NOTOKEN:
fatal(1021, HLN_IDENTP_NAME(&identifier));
break;
}
On_pound_line = FALSE;
}
/************************************************************************
* SKIPTO - skip code until the end of an undefined block is reached.
*
* ARGUMENTS
* short key - skip to an ELSE or ENDIF or just an ENDIF
*
* RETURNS - none
*
* SIDE EFFECTS
* - throws away input
*
* DESCRIPTION
* The preprocessor is skipping code between failed ifdef, etc. and
* the corresponding ELSE or ENDIF (when key == ELSE_OR_ENDIF).
* Or it is skipping code between a failed ELSE and the ENDIF (when
* key == ENDIF_ONLY).
*
* AUTHOR - Ralph Ryan, Sept. 16, 1982
*
* MODIFICATIONS - none
*
************************************************************************/
int
skipto(
int key
)
{
REG int level;
REG token_t tok;
level = 0;
tok = P0_NOTOKEN;
for(;;) {
/* make sure that IF [ELSE] ENDIF s are balanced */
switch(next_control()) {
case P0_IFDEF:
case P0_IFNDEF:
case P0_IF:
level++;
break;
case P0_ELSE:
tok = P0_ELSE;
/*
** FALLTHROUGH
*/
case P0_ELIF:
/*
** we found a #else or a #elif. these have their only chance
** at being valid if they're at level 0.
** if we're at any other level,
** then this else/elif belongs to some other #if and we skip them.
** if we were looking for an endif, the we have an error.
*/
if(level != 0) {
tok = P0_NOTOKEN;
break;
}
if(key == ENDIF_ONLY) {
fatal(1022); /* expected #endif */
} else if(tok == P0_ELSE) {
chk_newline(PPelse_str /* "#else" */);
return(GOT_ELSE);
} else {
return(GOT_ELIF);
}
break;
case P0_ENDIF:
if(level == 0) {
chk_newline(PPendif_str /* "#endif" */);
return(GOT_ENDIF);
} else {
level--;
}
break;
}
}
}
/*************************************************************************
** in_standard : search for the given file name in the directory list.
** Input : ptr to include file name.
** Output : fatal error if not found.
*************************************************************************/
void
in_standard(
void
)
{
int i;
int stop;
WCHAR *p_dir;
WCHAR *p_file;
WCHAR *p_tmp;
stop = Includes.li_top;
for(i = MAXLIST-1; i >= stop; i--) {
p_file = yylval.yy_string.str_ptr;
if( ((p_dir = Includes.li_defns[i])!=0) &&(wcscmp(p_dir, L"./") != 0) ) {
/*
** there is a directory to prepend and it's not './'
*/
p_tmp = Exp_ptr;
while((*p_tmp++ = *p_dir++) != 0)
;
/*
** above loop increments p_tmp past null.
** this replaces that null with a '/' if needed. Not needed if the
** last character of the directory spec is a path delimiter.
** we then point to the char after the '/'
*/
if(wcschr(Path_chars, p_dir[-2]) == 0) {
p_tmp[-1] = L'/';
} else {
--p_tmp;
}
while((*p_tmp++ = *p_file++) != 0)
;
p_file = Exp_ptr;
}
if(newinput(p_file,MAY_OPEN)) { /* this is the non-error way out */
return;
}
}
fatal(1015, yylval.yy_string.str_ptr); /* can't find include file */
}
/*************************************************************************
** chk_newline : check for whitespace only before a newline.
** eat the newline.
*************************************************************************/
void chk_newline(const wchar_t *cmd)
{
if(skip_cwhite() != L'\n') {
warning(4067, cmd); /* cmd expected newline */
skip_cnew();
} else {
UNGETCH();
}
}
/*************************************************************************
** skip_quoted : skips chars until it finds a char which matches its arg.
*************************************************************************/
void
skip_quoted(
int sc
)
{
REG WCHAR c;
for(;;) {
switch(CHARMAP(c = GETCH())) {
case LX_NL:
warning(4093);
UNGETCH();
return;
break;
case LX_DQUOTE:
case LX_SQUOTE:
if(c == (WCHAR)sc)
return;
break;
case LX_EOS:
if(handle_eos() == BACKSLASH_EOS) {
SKIPCH(); /* might be /" !! */
}
break;
case LX_LEADBYTE:
get_non_eof();
break;
}
}
}
/*************************************************************************
** next_control : find a newline. find a pound sign as the first non-white.
** find an id start char, build an id look it up and return the token.
** this knows about strings/char const and such.
*************************************************************************/
token_t
next_control(
void
)
{
REG WCHAR c;
for(;;) {
c = skip_cwhite();
first_switch:
switch(CHARMAP(c)) {
case LX_NL:
Linenumber++;
// must manually write '\r' with '\n' when writing 16-bit strings
if(Prep) {
myfwrite(L"\r\n", 2 * sizeof(WCHAR), 1, OUTPUTFILE);
}
if((c = skip_cwhite()) == L'#') {
if(LX_IS_IDENT(c = skip_cwhite())) {
/*
** this is the only way to return to the caller.
*/
getid(c);
return(is_pkeyword(Reuse_W)); /* if its predefined */
}
}
goto first_switch;
break;
case LX_DQUOTE:
case LX_SQUOTE:
skip_quoted(c);
break;
case LX_EOS:
if(handle_eos() == BACKSLASH_EOS) {
SKIPCH(); /* might be \" !! */
}
break;
}
}
}
/*************************************************************************
** do_defined : does the work for the defined(id)
** should parens be counted, or just be used as delimiters (ie the
** first open paren matches the first close paren)? If this is ever
** an issue, it really means that there is not a legal identifier
** between the parens, causing an error anyway, but consider:
** #if (defined(2*(x-1))) || 1
** #endif
** It is friendlier to allow compilation to continue
*************************************************************************/
int
do_defined(
PWCHAR p_tmp
)
{
REG UINT c;
REG int value=0;
int paren_level = 0;
/*
** we want to allow:
** #define FOO defined
** #define BAR(a,b) a FOO | b
** #define SNAFOO 0
** #if FOO BAR
** print("BAR is defined");
** #endif
** #if BAR(defined, SNAFOO)
** print("FOO is defined");
** #endif
*/
if(wcscmp(p_tmp,L"defined") != 0) {
return(0);
}
if((!can_get_non_white()) && (Tiny_lexer_nesting == 0)) {
/* NL encountered */
return(value);
}
if((c = CHECKCH())== L'(') { /* assumes no other CHARMAP form of OPAREN */
*Exp_ptr++ = (WCHAR)c;
SKIPCH();
paren_level++;
if((!can_get_non_white()) && (Tiny_lexer_nesting == 0)) {
/* NL encountered */
return(value);
}
}
if(Tiny_lexer_nesting>0) {
if((CHARMAP((WCHAR)(c=CHECKCH()))==LX_MACFORMAL) || (CHARMAP((WCHAR)c)==LX_ID)) {
SKIPCH();
tl_getid((UCHAR)c);
}
} else {
if(LX_IS_IDENT(((WCHAR)(c = CHECKCH())))) {
SKIPCH();
if(Macro_depth >0) {
lex_getid((WCHAR)c);
} else {
getid((WCHAR)c);
}
value = (get_defined()) ? TRUE : FALSE;
} else {
if(paren_level==0) {
error(2003);
} else {
error(2004);
}
}
}
if((CHARMAP(((WCHAR)(c = CHECKCH()))) == LX_WHITE) || (CHARMAP((WCHAR)c) == LX_EOS)) {
if( ! can_get_non_white()) {
return(value);
}
}
if(paren_level) {
if((CHARMAP(((WCHAR)(c = CHECKCH()))) == LX_CPAREN)) {
SKIPCH();
paren_level--;
*Exp_ptr++ = (WCHAR)c;
}
}
if((paren_level > 0) && (Tiny_lexer_nesting == 0)) {
warning(4004);
}
return(value);
}
/*************************************************************************
* NEXTIS - The lexical interface for #if expression parsing.
* If the next token does not match what is wanted, return FALSE.
* otherwise Set Currtok to L_NOTOKEN to force scanning on the next call.
* Return TRUE.
* will leave a newline as next char if it finds one.
*************************************************************************/
int
nextis(
register token_t tok
)
{
if(Currtok != L_NOTOKEN) {
if(tok == Currtok) {
Currtok = L_NOTOKEN; /* use up the token */
return(TRUE);
} else {
return(FALSE);
}
}
switch(yylex()) { /* acquire a new token */
case 0:
break;
case L_CONSTANT:
if( ! IS_INTEGRAL(TR_BTYPE(yylval.yy_tree))) {
fatal(1017);
} else {
Currval = TR_LVALUE(yylval.yy_tree);
}
if(tok == L_CINTEGER) {
return(TRUE);
}
Currtok = L_CINTEGER;
break;
case L_IDENT:
Currval = do_defined(HLN_IDENTP_NAME(&yylval.yy_ident));
if(tok == L_CINTEGER) {
return(TRUE);
}
Currtok = L_CINTEGER;
break;
default:
if(tok == Basic_token) {
return(TRUE);
}
Currtok = Basic_token;
break;
}
return(FALSE);
}
/************************************************************************
** skip_cnew : reads up to and including the next newline.
************************************************************************/
void
skip_cnew(
void
)
{
for(;;) {
switch(CHARMAP(GETCH())) {
case LX_NL:
UNGETCH();
return;
case LX_SLASH:
skip_comment();
break;
case LX_EOS:
handle_eos();
break;
}
}
}
/************************************************************************
** skip_NLonly : reads up to the next newline, disallowing comments
************************************************************************/
void
skip_NLonly(
void
)
{
for(;;) {
switch(CHARMAP(GETCH())) {
case LX_NL:
UNGETCH();
return;
case LX_EOS:
handle_eos();
break;
}
}
}
/************************************************************************
** pragma : handle processing the pragma directive
** called by preprocess() after we have seen the #pragma
** and are ready to handle the keyword which follows.
************************************************************************/
unsigned long
pragma(
void
)
{
WCHAR c;
unsigned long int cp=0;
c = skip_cwhite();
if (c != L'\n') {
getid(c);
_wcsupr(Reuse_W);
if (wcscmp(L"CODE_PAGE", Reuse_W) == 0) {
if ((c = skip_cwhite()) == L'(') {
c = skip_cwhite(); // peek token
if (iswdigit(c)) {
token_t tok;
int old_prep = Prep;
Prep = FALSE;
tok = getnum(c);
Prep = old_prep;
switch(tok) {
default:
case L_CFLOAT:
case L_CDOUBLE:
case L_CLDOUBLE:
case L_FLOAT:
case L_DOUBLE:
break;
case L_CINTEGER:
case L_LONGINT:
case L_CUNSIGNED:
case L_LONGUNSIGNED:
case L_SHORT:
case L_LONG:
case L_SIGNED:
case L_UNSIGNED:
cp = TR_LVALUE(yylval.yy_tree);
break;
}
}
if (cp == 0) {
getid(c);
_wcsupr(Reuse_W);
if (wcscmp(L"DEFAULT", Reuse_W) == 0) {
cp = uiDefaultCodePage;
} else {
error(4212, Reuse_W);
}
}
if ((c = skip_cwhite()) != L')') {
UNGETCH();
error(4211);
}
} else {
UNGETCH();
error(4210);
}
swprintf(Reuse_W, L"#pragma code_page %d\r\n", cp);
myfwrite(Reuse_W, wcslen(Reuse_W) * sizeof(WCHAR), 1, OUTPUTFILE);
}
}
// Skip #pragma statements
while((c = get_non_eof()) != L'\n');
UNGETCH();
return cp;
}