OS_Develop/Windows-Server-2003
OS_Develop/Windows-Server-2003
1
0
Fork 0
Code Pull Requests Activity
master
Windows-Server-2003/sdktools/hivepp/p0prepro.c

852 lines
20 KiB
C
Raw Permalink Blame History

/************************************************************************/
/* */
/* RCPP - Resource Compiler Pre-Processor for NT system */
/* */
/* P0PREPRO.C - Main Preprocessor */
/* */
/* 27-Nov-90 w-BrianM Update for NT from PM SDK RCPP */
/* */
/************************************************************************/
#include <stdio.h>
#include <string.h>
#include <ctype.h>
#include "rcpptype.h"
#include "rcppdecl.h"
#include "rcppext.h"
#include "p0defs.h"
#include "charmap.h"
#include "grammar.h"
#include "trees.h"
#include "p1types.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(PCHAR);
void in_standard(void);
int incr_ifstack(void);
token_t next_control(void);
void pragma(void);
int skipto(int);
void skip_quoted(int);
PUCHAR sysinclude(void);
/************************************************************************/
/* incr_ifstack - Increment the IF nesting stack */
/************************************************************************/
int incr_ifstack(void)
{
if(++Prep_ifstack >= IFSTACK_SIZE) {
Msg_Temp = GET_MSG (1052);
SET_MSG (Msg_Text, Msg_Temp);
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
*
*
************************************************************************/
PUCHAR sysinclude(void)
{
REG int c;
REG char *p_fname;
p_fname = Reuse_1;
c = skip_cwhite();
if( c == '\n' ) {
UNGETCH();
Msg_Temp = GET_MSG (2012);
SET_MSG (Msg_Text, Msg_Temp);
error(2012); /* missing name after '<' */
return(NULL);
}
while( c != '>' && c != '\n' ) {
*p_fname++ = (UCHAR)c; /* check for buffer overflow ??? */
c = get_non_eof();
}
if( c == '\n' ) {
UNGETCH();
Msg_Temp = GET_MSG (2013);
SET_MSG (Msg_Text, Msg_Temp);
error(2013); /* missing '>' */
return(NULL);
}
if(p_fname != Reuse_1) {
p_fname--;
while((p_fname >= Reuse_1) && isspace(*p_fname)) {
p_fname--;
}
p_fname++;
}
*p_fname = '\0';
return(Reuse_1);
}
/************************************************************************
** preprocess : the scanner found a # which was the first non-white char
** on a line.
************************************************************************/
void preprocess(void)
{
REG UCHAR c;
long eval;
int condition;
token_t deftok;
hln_t identifier;
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_1;
HLN_LENGTH(identifier) = (UCHAR)Reuse_1_length;
HLN_HASH(identifier) = Reuse_1_hash;
break;
case LX_NL:
UNGETCH();
return;
default:
Msg_Temp = GET_MSG (2019);
SET_MSG (Msg_Text, Msg_Temp, c);
error(2019); /* 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 */
Msg_Temp = GET_MSG (2005);
SET_MSG (Msg_Text, Msg_Temp, TS_STR(Basic_token));
error(2005); /* 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( strcmp(Filename, yylval.yy_string.str_ptr) != 0) {
strncpy(Filename,
yylval.yy_string.str_ptr,
sizeof(Filebuff)
);
}
case L_NOTOKEN:
break;
default:
Msg_Temp = GET_MSG (2130);
SET_MSG (Msg_Text, Msg_Temp, TS_STR(Basic_token));
error(2130); /* #line needs a string */
skip_cnew();
On_pound_line = FALSE;
return;
break;
}
emit_line();
chk_newline("#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;
break; /* error already emitted */
}
yylval.yy_string.str_ptr = Reuse_1;
break;
case L_STRING:
break;
default:
Msg_Temp = GET_MSG (2006);
SET_MSG (Msg_Text, Msg_Temp, TS_STR(Basic_token));
error(2006); /* needs file name */
skip_cnew();
On_pound_line = FALSE;
return;
break;
}
chk_newline("#include");
if( strchr(Path_chars, *yylval.yy_string.str_ptr) ||
(strchr(Path_chars, ':') && (yylval.yy_string.str_ptr[1] == ':'))) {
/*
** 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)) {
Msg_Temp = GET_MSG (1015);
SET_MSG (Msg_Text, Msg_Temp, yylval.yy_string.str_ptr);
fatal (1015); /* 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) {
Msg_Temp = GET_MSG (1016);
SET_MSG (Msg_Text, Msg_Temp);
fatal (1016);
}
getid(c);
eval = (get_defined()) ? TRUE : FALSE;
chk_newline((deftok == P0_IFDEF) ? "#ifdef" : "#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) = "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();
}
/*
** 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
*/
else {
if(Eflag)
emit_line();
if(condition == GOT_ELIF) {
/* hash is wrong, but it won't be needed */
HLN_NAME(identifier) = "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) {
Msg_Temp = GET_MSG (1018);
SET_MSG (Msg_Text, Msg_Temp);
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)) {
Msg_Temp = GET_MSG (1019);
SET_MSG (Msg_Text, Msg_Temp);
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) {
Msg_Temp = GET_MSG (1020);
SET_MSG (Msg_Text, Msg_Temp);
fatal (1020);
}
if(Eflag)
emit_line();
chk_newline(PPendif_str /* "#endif" */);
break;
case P0_PRAGMA :
pragma();
break;
case P0_UNDEF :
if(CHARMAP(c = skip_cwhite()) != LX_ID) {
Msg_Temp = GET_MSG (4006);
SET_MSG (Msg_Text, Msg_Temp);
warning(4006); /* missing identifier on #undef */
}
else {
getid(c);
undefine();
}
chk_newline("#undef");
break;
case P0_ERROR:
{
PUCHAR p;
p = Reuse_1;
while((c = get_non_eof()) != LX_EOS) {
if(c == '\n') {
UNGETCH();
break;
}
*p++ = c;
}
*p = '\0';
}
Msg_Temp = GET_MSG (2188);
SET_MSG (Msg_Text, Msg_Temp, Reuse_1);
error(2188);
chk_newline("#error");
break;
case P0_IDENT:
old_prep = Prep ;
Prep = FALSE;
yylex();
Prep = old_prep;
if(Basic_token != L_STRING) {
Msg_Temp = GET_MSG (4079);
SET_MSG (Msg_Text, Msg_Temp, TS_STR(Basic_token));
warning(4079);
}
chk_newline("#error");
break;
case P0_NOTOKEN:
Msg_Temp = GET_MSG (1021);
SET_MSG (Msg_Text, Msg_Temp, HLN_IDENTP_NAME(&identifier));
fatal (1021);
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) {
Msg_Temp = GET_MSG (1022);
SET_MSG (Msg_Text, Msg_Temp);
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;
char *p_dir;
char *p_file;
char *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) &&(strcmp(p_dir, "./") != 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(strchr(Path_chars, p_dir[-2]) == 0) {
p_tmp[-1] = '/';
}
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;
}
}
Msg_Temp = GET_MSG (1015);
SET_MSG (Msg_Text, Msg_Temp, yylval.yy_string.str_ptr);
fatal (1015); /* can't find include file */
}
/*************************************************************************
** chk_newline : check for whitespace only before a newline.
** eat the newline.
*************************************************************************/
void chk_newline(PCHAR cmd)
{
if(skip_cwhite() != '\n') {
Msg_Temp = GET_MSG (4067);
SET_MSG (Msg_Text, Msg_Temp, cmd);
warning(4067); /* 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 UCHAR c;
for(;;) {
switch(CHARMAP(c = GETCH())) {
case LX_NL:
Msg_Temp = GET_MSG (4093);
SET_MSG (Msg_Text, Msg_Temp);
warning(4093);
UNGETCH();
return;
break;
case LX_DQUOTE:
case LX_SQUOTE:
if(c == (UCHAR)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 UCHAR c;
for(;;) {
c = skip_cwhite();
first_switch:
switch(CHARMAP(c)) {
case LX_NL:
Linenumber++;
if(Prep) {
fputc('\n', OUTPUTFILE);
}
if((c = skip_cwhite()) == '#') {
if(LX_IS_IDENT(c = skip_cwhite())) {
/*
** this is the only way to return to the caller.
*/
getid(c);
return(is_pkeyword(Reuse_1)); /* 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(PUCHAR 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(strcmp(p_tmp,"defined") != 0) {
return(0);
}
if((!can_get_non_white()) && (Tiny_lexer_nesting == 0)) {
/* NL encountered */
return(value);
}
if((c = CHECKCH())== '(') { /* assumes no other CHARMAP form of OPAREN */
*Exp_ptr++ = (UCHAR)c;
SKIPCH();
paren_level++;
if((!can_get_non_white()) && (Tiny_lexer_nesting == 0)) {
/* NL encountered */
return(value);
}
}
if(Tiny_lexer_nesting>0) {
if((CHARMAP(c=CHECKCH())==LX_MACFORMAL) || (CHARMAP(c)==LX_ID)) {
SKIPCH();
tl_getid((UCHAR)c);
}
}
else {
if(LX_IS_IDENT(c = CHECKCH())) {
SKIPCH();
if(Macro_depth >0) {
lex_getid((UCHAR)c);
}
else {
getid((UCHAR)c);
}
value = (get_defined()) ? TRUE : FALSE;
}
else {
if(paren_level==0) {
Msg_Temp = GET_MSG (2003);
SET_MSG (Msg_Text, Msg_Temp);
error(2003);
}
else {
Msg_Temp = GET_MSG (2004);
SET_MSG (Msg_Text, Msg_Temp);
error(2004);
}
}
}
if((CHARMAP(c = CHECKCH()) == LX_WHITE) || (CHARMAP(c) == LX_EOS)) {
if( ! can_get_non_white()) {
return(value);
}
}
if(paren_level) {
if((CHARMAP(c = CHECKCH()) == LX_CPAREN)) {
SKIPCH();
paren_level--;
*Exp_ptr++ = (UCHAR)c;
}
}
if((paren_level > 0) && (Tiny_lexer_nesting == 0)) {
Msg_Temp = GET_MSG (4004);
SET_MSG (Msg_Text, Msg_Temp);
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))) {
Msg_Temp = GET_MSG (1017);
SET_MSG (Msg_Text, Msg_Temp);
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.
************************************************************************/
void pragma(void)
{
if(Prep) {
UCHAR c;
fwrite("#pragma", 7, 1, OUTPUTFILE);
while((c = get_non_eof()) != '\n') {
fputc(c, OUTPUTFILE);
}
UNGETCH();
return;
}
}
View Git Blame Copy Permalink