From 2d778c5eea99a6bc18195955ce65c3bc08bd02b0 Mon Sep 17 00:00:00 2001 From: Alexandre Julliard Date: Tue, 12 Sep 2006 09:04:55 +0200 Subject: [PATCH] wpp: Change the prefix on bison-generated names to avoid the name-prefix directive. --- libs/wpp/ppl.l | 212 ++++++++++++++++++++--------------------- libs/wpp/ppy.y | 28 +++--- libs/wpp/preproc.c | 16 ++-- libs/wpp/wpp.c | 16 ++-- libs/wpp/wpp_private.h | 16 ++-- 5 files changed, 143 insertions(+), 145 deletions(-) diff --git a/libs/wpp/ppl.l b/libs/wpp/ppl.l index d62cf1d8f24..6b251a8b21a 100644 --- a/libs/wpp/ppl.l +++ b/libs/wpp/ppl.l @@ -127,7 +127,7 @@ %option stack %option 8bit never-interactive %option nounput -%option prefix="pp" +%option prefix="ppy_" %x pp_pp %x pp_eol @@ -181,7 +181,7 @@ ul [uUlL]|[uUlL][lL]|[lL][uU]|[lL][lL][uU]|[uU][lL][lL]|[lL][uU][lL] /* * Always update the current character position within a line */ -#define YY_USER_ACTION pp_status.char_number+=ppleng; +#define YY_USER_ACTION pp_status.char_number+=ppy_leng; /* * Buffer management for includes and expansions @@ -328,22 +328,22 @@ includelogicentry_t *pp_includelogiclist = NULL; {ws}*endif{ws}* yy_pp_state(pp_endif); return tENDIF; {ws}*line{ws}* if(yy_top_state() != pp_ignore) {yy_pp_state(pp_line); return tLINE;} else {yy_pp_state(pp_eol);} {ws}+ if(yy_top_state() != pp_ignore) {yy_pp_state(pp_line); return tGCCLINE;} else {yy_pp_state(pp_eol);} -{ws}*[a-z]+ pperror("Invalid preprocessor token '%s'", pptext); +{ws}*[a-z]+ ppy_error("Invalid preprocessor token '%s'", ppy_text); \r?\n newline(1); yy_pop_state(); return tNL; /* This could be the null-token */ \\\r?\n newline(0); -\\\r? pperror("Preprocessor junk '%s'", pptext); -. return *pptext; +\\\r? ppy_error("Preprocessor junk '%s'", ppy_text); +. return *ppy_text; /* * Handle #include and #line */ -[0-9]+ return make_number(10, &pplval, pptext, ppleng); -\< new_string(); add_string(pptext, ppleng); yy_push_state(pp_iqs); -\" new_string(); add_string(pptext, ppleng); yy_push_state(pp_dqs); +[0-9]+ return make_number(10, &ppy_lval, ppy_text, ppy_leng); +\< new_string(); add_string(ppy_text, ppy_leng); yy_push_state(pp_iqs); +\" new_string(); add_string(ppy_text, ppy_leng); yy_push_state(pp_dqs); {ws}+ ; \n newline(1); yy_pop_state(); return tNL; \\\r?\n newline(0); -(\\\r?)|(.) pperror(yy_current_state() == pp_inc ? "Trailing junk in #include" : "Trailing junk in #line"); +(\\\r?)|(.) ppy_error(yy_current_state() == pp_inc ? "Trailing junk in #include" : "Trailing junk in #line"); /* * Ignore all input when a false clause is parsed @@ -360,11 +360,11 @@ includelogicentry_t *pp_includelogiclist = NULL; * Note: tIDENT is handled below. */ -0[0-7]*{ul}? return make_number(8, &pplval, pptext, ppleng); -0[0-7]*[8-9]+{ul}? pperror("Invalid octal digit"); -[1-9][0-9]*{ul}? return make_number(10, &pplval, pptext, ppleng); -0[xX][0-9a-fA-F]+{ul}? return make_number(16, &pplval, pptext, ppleng); -0[xX] pperror("Invalid hex number"); +0[0-7]*{ul}? return make_number(8, &ppy_lval, ppy_text, ppy_leng); +0[0-7]*[8-9]+{ul}? ppy_error("Invalid octal digit"); +[1-9][0-9]*{ul}? return make_number(10, &ppy_lval, ppy_text, ppy_leng); +0[xX][0-9a-fA-F]+{ul}? return make_number(16, &ppy_lval, ppy_text, ppy_leng); +0[xX] ppy_error("Invalid hex number"); defined yy_push_state(pp_defined); return tDEFINED; "<<" return tLSHIFT; ">>" return tRSHIFT; @@ -376,21 +376,21 @@ includelogicentry_t *pp_includelogiclist = NULL; ">=" return tGTE; \n newline(1); yy_pop_state(); return tNL; \\\r?\n newline(0); -\\\r? pperror("Junk in conditional expression"); +\\\r? ppy_error("Junk in conditional expression"); {ws}+ ; -\' new_string(); add_string(pptext, ppleng); yy_push_state(pp_sqs); -\" pperror("String constants not allowed in conditionals"); -. return *pptext; +\' new_string(); add_string(ppy_text, ppy_leng); yy_push_state(pp_sqs); +\" ppy_error("String constants not allowed in conditionals"); +. return *ppy_text; /* * Handle #ifdef, #ifndef and #undef * to get only an untranslated/unexpanded identifier */ -{cident} pplval.cptr = pp_xstrdup(pptext); return tIDENT; +{cident} ppy_lval.cptr = pp_xstrdup(ppy_text); return tIDENT; {ws}+ ; \n newline(1); yy_pop_state(); return tNL; \\\r?\n newline(0); -(\\\r?)|(.) pperror("Identifier expected"); +(\\\r?)|(.) ppy_error("Identifier expected"); /* * Handle #else and #endif. @@ -398,18 +398,18 @@ includelogicentry_t *pp_includelogiclist = NULL; {ws}+ ; \n newline(1); yy_pop_state(); return tNL; \\\r?\n newline(0); -. pperror("Garbage after #else or #endif."); +. ppy_error("Garbage after #else or #endif."); /* * Handle the special 'defined' keyword. * This is necessary to get the identifier prior to any * substitutions. */ -{cident} yy_pop_state(); pplval.cptr = pp_xstrdup(pptext); return tIDENT; +{cident} yy_pop_state(); ppy_lval.cptr = pp_xstrdup(ppy_text); return tIDENT; {ws}+ ; -(\()|(\)) return *pptext; +(\()|(\)) return *ppy_text; \\\r?\n newline(0); -(\\.)|(\n)|(.) pperror("Identifier expected"); +(\\.)|(\n)|(.) ppy_error("Identifier expected"); /* * Handle #error, #warning, #pragma and #ident. @@ -417,17 +417,17 @@ includelogicentry_t *pp_includelogiclist = NULL; * will act appropriately. * Comments are stripped from the literal text. */ -[^/\\\n]+ if(yy_top_state() != pp_ignore) { pplval.cptr = pp_xstrdup(pptext); return tLITERAL; } -\/[^/\\\n*]* if(yy_top_state() != pp_ignore) { pplval.cptr = pp_xstrdup(pptext); return tLITERAL; } -(\\\r?)|(\/[^/*]) if(yy_top_state() != pp_ignore) { pplval.cptr = pp_xstrdup(pptext); return tLITERAL; } +[^/\\\n]+ if(yy_top_state() != pp_ignore) { ppy_lval.cptr = pp_xstrdup(ppy_text); return tLITERAL; } +\/[^/\\\n*]* if(yy_top_state() != pp_ignore) { ppy_lval.cptr = pp_xstrdup(ppy_text); return tLITERAL; } +(\\\r?)|(\/[^/*]) if(yy_top_state() != pp_ignore) { ppy_lval.cptr = pp_xstrdup(ppy_text); return tLITERAL; } \n newline(1); yy_pop_state(); if(yy_current_state() != pp_ignore) { return tNL; } \\\r?\n newline(0); /* * Handle left side of #define */ -{cident}\( pplval.cptr = pp_xstrdup(pptext); pplval.cptr[ppleng-1] = '\0'; yy_pp_state(pp_macro); return tMACRO; -{cident} pplval.cptr = pp_xstrdup(pptext); yy_pp_state(pp_define); return tDEFINE; +{cident}\( ppy_lval.cptr = pp_xstrdup(ppy_text); ppy_lval.cptr[ppy_leng-1] = '\0'; yy_pp_state(pp_macro); return tMACRO; +{cident} ppy_lval.cptr = pp_xstrdup(ppy_text); yy_pp_state(pp_define); return tDEFINE; {ws}+ ; \\\r?\n newline(0); (\\\r?)|(\n)|(.) perror("Identifier expected"); @@ -435,39 +435,39 @@ includelogicentry_t *pp_includelogiclist = NULL; /* * Scan the substitution of a define */ -[^'"/\\\n]+ pplval.cptr = pp_xstrdup(pptext); return tLITERAL; -(\\\r?)|(\/[^/*]) pplval.cptr = pp_xstrdup(pptext); return tLITERAL; -\\\r?\n{ws}+ newline(0); pplval.cptr = pp_xstrdup(" "); return tLITERAL; +[^'"/\\\n]+ ppy_lval.cptr = pp_xstrdup(ppy_text); return tLITERAL; +(\\\r?)|(\/[^/*]) ppy_lval.cptr = pp_xstrdup(ppy_text); return tLITERAL; +\\\r?\n{ws}+ newline(0); ppy_lval.cptr = pp_xstrdup(" "); return tLITERAL; \\\r?\n newline(0); \n newline(1); yy_pop_state(); return tNL; -\' new_string(); add_string(pptext, ppleng); yy_push_state(pp_sqs); -\" new_string(); add_string(pptext, ppleng); yy_push_state(pp_dqs); +\' new_string(); add_string(ppy_text, ppy_leng); yy_push_state(pp_sqs); +\" new_string(); add_string(ppy_text, ppy_leng); yy_push_state(pp_dqs); /* * Scan the definition macro arguments */ \){ws}* yy_pp_state(pp_mbody); return tMACROEND; {ws}+ ; -{cident} pplval.cptr = pp_xstrdup(pptext); return tIDENT; +{cident} ppy_lval.cptr = pp_xstrdup(ppy_text); return tIDENT; , return ','; "..." return tELIPSIS; -(\\\r?)|(\n)|(.)|(\.\.?) pperror("Argument identifier expected"); +(\\\r?)|(\n)|(.)|(\.\.?) ppy_error("Argument identifier expected"); \\\r?\n newline(0); /* * Scan the substitution of a macro */ -[^a-zA-Z0-9'"#/\\\n]+ pplval.cptr = pp_xstrdup(pptext); return tLITERAL; -{cident} pplval.cptr = pp_xstrdup(pptext); return tIDENT; +[^a-zA-Z0-9'"#/\\\n]+ ppy_lval.cptr = pp_xstrdup(ppy_text); return tLITERAL; +{cident} ppy_lval.cptr = pp_xstrdup(ppy_text); return tIDENT; \#\# return tCONCAT; \# return tSTRINGIZE; -[0-9][^'"#/\\\n]* pplval.cptr = pp_xstrdup(pptext); return tLITERAL; -(\\\r?)|(\/[^/*'"#\\\n]*) pplval.cptr = pp_xstrdup(pptext); return tLITERAL; -\\\r?\n{ws}+ newline(0); pplval.cptr = pp_xstrdup(" "); return tLITERAL; +[0-9][^'"#/\\\n]* ppy_lval.cptr = pp_xstrdup(ppy_text); return tLITERAL; +(\\\r?)|(\/[^/*'"#\\\n]*) ppy_lval.cptr = pp_xstrdup(ppy_text); return tLITERAL; +\\\r?\n{ws}+ newline(0); ppy_lval.cptr = pp_xstrdup(" "); return tLITERAL; \\\r?\n newline(0); \n newline(1); yy_pop_state(); return tNL; -\' new_string(); add_string(pptext, ppleng); yy_push_state(pp_sqs); -\" new_string(); add_string(pptext, ppleng); yy_push_state(pp_dqs); +\' new_string(); add_string(ppy_text, ppy_leng); yy_push_state(pp_sqs); +\" new_string(); add_string(ppy_text, ppy_leng); yy_push_state(pp_dqs); /* * Macro expansion text scanning. @@ -488,7 +488,7 @@ includelogicentry_t *pp_includelogiclist = NULL; macexpstackentry_t *mac = pop_macro(); yy_pop_state(); put_buffer(mac->ppp->ident, strlen(mac->ppp->ident)); - put_buffer(pptext, ppleng); + put_buffer(ppy_text, ppy_leng); free_macro(mac); } @@ -498,7 +498,7 @@ includelogicentry_t *pp_includelogiclist = NULL; */ \( { if(++MACROPARENTHESES() > 1) - add_text_to_macro(pptext, ppleng); + add_text_to_macro(ppy_text, ppy_leng); } \) { if(--MACROPARENTHESES() == 0) @@ -507,19 +507,19 @@ includelogicentry_t *pp_includelogiclist = NULL; macro_add_arg(1); } else - add_text_to_macro(pptext, ppleng); + add_text_to_macro(ppy_text, ppy_leng); } , { if(MACROPARENTHESES() > 1) - add_text_to_macro(pptext, ppleng); + add_text_to_macro(ppy_text, ppy_leng); else macro_add_arg(0); } -\" new_string(); add_string(pptext, ppleng); yy_push_state(pp_dqs); -\' new_string(); add_string(pptext, ppleng); yy_push_state(pp_sqs); +\" new_string(); add_string(ppy_text, ppy_leng); yy_push_state(pp_dqs); +\' new_string(); add_string(ppy_text, ppy_leng); yy_push_state(pp_sqs); "/*" yy_push_state(pp_comment); add_text_to_macro(" ", 1); -\n pp_status.line_number++; pp_status.char_number = 1; add_text_to_macro(pptext, ppleng); -([^/(),\\\n"']+)|(\/[^/*(),\\\n'"]*)|(\\\r?)|(.) add_text_to_macro(pptext, ppleng); +\n pp_status.line_number++; pp_status.char_number = 1; add_text_to_macro(ppy_text, ppy_leng); +([^/(),\\\n"']+)|(\/[^/*(),\\\n'"]*)|(\\\r?)|(.) add_text_to_macro(ppy_text, ppy_leng); \\\r?\n newline(0); /* @@ -534,18 +534,18 @@ includelogicentry_t *pp_includelogiclist = NULL; * Remove C++ style comment (almost all start-conditions) */ "//"[^\n]* { - if(pptext[ppleng-1] == '\\') - ppwarning("C++ style comment ends with an escaped newline (escape ignored)"); + if(ppy_text[ppy_leng-1] == '\\') + ppy_warning("C++ style comment ends with an escaped newline (escape ignored)"); } /* * Single, double and <> quoted constants */ -\" pp_incl_state.seen_junk++; new_string(); add_string(pptext, ppleng); yy_push_state(pp_dqs); -\' pp_incl_state.seen_junk++; new_string(); add_string(pptext, ppleng); yy_push_state(pp_sqs); -[^"\\\n]+ add_string(pptext, ppleng); +\" pp_incl_state.seen_junk++; new_string(); add_string(ppy_text, ppy_leng); yy_push_state(pp_dqs); +\' pp_incl_state.seen_junk++; new_string(); add_string(ppy_text, ppy_leng); yy_push_state(pp_sqs); +[^"\\\n]+ add_string(ppy_text, ppy_leng); \" { - add_string(pptext, ppleng); + add_string(ppy_text, ppy_leng); yy_pop_state(); switch(yy_current_state()) { @@ -555,37 +555,37 @@ includelogicentry_t *pp_includelogiclist = NULL; case pp_inc: case RCINCL: if (yy_current_state()==RCINCL) yy_pop_state(); - pplval.cptr = get_string(); + ppy_lval.cptr = get_string(); return tDQSTRING; case pp_line: - pplval.cptr = get_string(); - if (is_c_h_include(pplval.cptr, 1)) pass_data=0; + ppy_lval.cptr = get_string(); + if (is_c_h_include(ppy_lval.cptr, 1)) pass_data=0; else pass_data=1; return tDQSTRING; default: put_string(); } } -[^'\\\n]+ add_string(pptext, ppleng); +[^'\\\n]+ add_string(ppy_text, ppy_leng); \' { - add_string(pptext, ppleng); + add_string(ppy_text, ppy_leng); yy_pop_state(); switch(yy_current_state()) { case pp_if: case pp_define: case pp_mbody: - pplval.cptr = get_string(); + ppy_lval.cptr = get_string(); return tSQSTRING; default: put_string(); } } -[^\>\\\n]+ add_string(pptext, ppleng); +[^\>\\\n]+ add_string(ppy_text, ppy_leng); \> { - add_string(pptext, ppleng); + add_string(ppy_text, ppy_leng); yy_pop_state(); - pplval.cptr = get_string(); + ppy_lval.cptr = get_string(); return tIQSTRING; } \\\r?\n { @@ -608,15 +608,15 @@ includelogicentry_t *pp_includelogiclist = NULL; newline(0); break; default: - add_string(pptext, ppleng); + add_string(ppy_text, ppy_leng); newline(-1); } } -\\. add_string(pptext, ppleng); +\\. add_string(ppy_text, ppy_leng); \n { newline(1); - add_string(pptext, ppleng); - ppwarning("Newline in string constant encounterd (started line %d)", string_start()); + add_string(ppy_text, ppy_leng); + ppy_warning("Newline in string constant encounterd (started line %d)", string_start()); } /* @@ -625,22 +625,22 @@ includelogicentry_t *pp_includelogiclist = NULL; {cident} { pp_entry_t *ppp; pp_incl_state.seen_junk++; - if(!(ppp = pplookup(pptext))) + if(!(ppp = pplookup(ppy_text))) { if(yy_current_state() == pp_inc) - pperror("Expected include filename"); + ppy_error("Expected include filename"); if(yy_current_state() == pp_if) { - pplval.cptr = pp_xstrdup(pptext); + ppy_lval.cptr = pp_xstrdup(ppy_text); return tIDENT; } else { - if((yy_current_state()==INITIAL) && (strcasecmp(pptext,"RCINCLUDE")==0)){ + if((yy_current_state()==INITIAL) && (strcasecmp(ppy_text,"RCINCLUDE")==0)){ yy_push_state(RCINCL); return tRCINCLUDE; } - else put_buffer(pptext, ppleng); + else put_buffer(ppy_text, ppy_leng); } } else if(!ppp->expanding) @@ -661,27 +661,27 @@ includelogicentry_t *pp_includelogiclist = NULL; pp_internal_error(__FILE__, __LINE__, "Invalid define type %d\n", ppp->type); } } - else put_buffer(pptext, ppleng); + else put_buffer(ppy_text, ppy_leng); } /* * Everything else that needs to be passed and * newline and continuation handling */ -[^a-zA-Z_#'"/\\\n \r\t\f\v]+|(\/|\\)[^a-zA-Z_/*'"\\\n \r\t\v\f]* pp_incl_state.seen_junk++; put_buffer(pptext, ppleng); -{ws}+ put_buffer(pptext, ppleng); +[^a-zA-Z_#'"/\\\n \r\t\f\v]+|(\/|\\)[^a-zA-Z_/*'"\\\n \r\t\v\f]* pp_incl_state.seen_junk++; put_buffer(ppy_text, ppy_leng); +{ws}+ put_buffer(ppy_text, ppy_leng); \n newline(1); \\\r?\n newline(0); -\\\r? pp_incl_state.seen_junk++; put_buffer(pptext, ppleng); +\\\r? pp_incl_state.seen_junk++; put_buffer(ppy_text, ppy_leng); /* * Special catcher for macro argmument expansion to prevent * newlines to propagate to the output or admin. */ -(\n)|(.)|(\\\r?(\n|.)) put_buffer(pptext, ppleng); +(\n)|(.)|(\\\r?(\n|.)) put_buffer(ppy_text, ppy_leng); [A-Za-z0-9_\.\\/]+ { - pplval.cptr=pp_xstrdup(pptext); + ppy_lval.cptr=pp_xstrdup(ppy_text); yy_pop_state(); return tRCINCLUDEPATH; } @@ -689,26 +689,26 @@ includelogicentry_t *pp_includelogiclist = NULL; {ws}+ ; \" { - new_string(); add_string(pptext,ppleng);yy_push_state(pp_dqs); + new_string(); add_string(ppy_text,ppy_leng);yy_push_state(pp_dqs); } /* * This is a 'catch-all' rule to discover errors in the scanner * in an orderly manner. */ -<*>. pp_incl_state.seen_junk++; ppwarning("Unmatched text '%c' (0x%02x); please report\n", isprint(*pptext & 0xff) ? *pptext : ' ', *pptext); +<*>. pp_incl_state.seen_junk++; ppy_warning("Unmatched text '%c' (0x%02x); please report\n", isprint(*ppy_text & 0xff) ? *ppy_text : ' ', *ppy_text); <> { YY_BUFFER_STATE b = YY_CURRENT_BUFFER; bufferstackentry_t *bep = pop_buffer(); if((!bep && pp_get_if_depth()) || (bep && pp_get_if_depth() != bep->if_depth)) - ppwarning("Unmatched #if/#endif at end of file"); + ppy_warning("Unmatched #if/#endif at end of file"); if(!bep) { if(YY_START != INITIAL) - pperror("Unexpected end of file during preprocessing"); + ppy_error("Unexpected end of file during preprocessing"); yyterminate(); } else if(bep->should_pop == 2) @@ -717,7 +717,7 @@ includelogicentry_t *pp_includelogiclist = NULL; mac = pop_macro(); expand_macro(mac); } - pp_delete_buffer(b); + ppy__delete_buffer(b); } %% @@ -727,8 +727,8 @@ includelogicentry_t *pp_includelogiclist = NULL; ************************************************************************** */ -#ifndef ppwrap -int ppwrap(void) +#ifndef ppy_wrap +int ppy_wrap(void) { return 1; } @@ -798,7 +798,7 @@ static int make_number(int radix, YYSTYPE *val, const char *str, int len) ext[0] = len > 2 ? toupper(str[len-3]) : ' '; if(!strcmp(ext, "LUL")) - pperror("Invalid constant suffix"); + ppy_error("Invalid constant suffix"); else if(!strcmp(ext, "LLU") || !strcmp(ext, "ULL")) { is_ll++; @@ -937,7 +937,7 @@ static void add_text(const char *str, int len) curdef_alloc += (len + ALLOCBLOCKSIZE-1) & ~(ALLOCBLOCKSIZE-1); curdef_text = pp_xrealloc(curdef_text, curdef_alloc * sizeof(curdef_text[0])); if(curdef_alloc > 65536) - ppwarning("Reallocating macro-expansion buffer larger than 64kB"); + ppy_warning("Reallocating macro-expansion buffer larger than 64kB"); } memcpy(&curdef_text[curdef_idx], str, len); curdef_idx += len; @@ -1053,7 +1053,7 @@ static void expand_macro(macexpstackentry_t *mep) assert(ppp->expanding == 0); if((ppp->nargs >= 0 && nargs != ppp->nargs) || (ppp->nargs < 0 && nargs < -ppp->nargs)) - pperror("Too %s macro arguments (%d)", nargs < abs(ppp->nargs) ? "few" : "many", nargs); + ppy_error("Too %s macro arguments (%d)", nargs < abs(ppp->nargs) ? "few" : "many", nargs); for(n = 0; n < nargs; n++) nnl += mep->nnls[n]; @@ -1122,7 +1122,7 @@ static void new_string(void) { #ifdef DEBUG if(strbuf_idx) - ppwarning("new_string: strbuf_idx != 0"); + ppy_warning("new_string: strbuf_idx != 0"); #endif strbuf_idx = 0; str_startline = pp_status.line_number; @@ -1137,7 +1137,7 @@ static void add_string(const char *str, int len) strbuf_alloc += (len + ALLOCBLOCKSIZE-1) & ~(ALLOCBLOCKSIZE-1); strbuffer = pp_xrealloc(strbuffer, strbuf_alloc * sizeof(strbuffer[0])); if(strbuf_alloc > 65536) - ppwarning("Reallocating string buffer larger than 64kB"); + ppy_warning("Reallocating string buffer larger than 64kB"); } memcpy(&strbuffer[strbuf_idx], str, len); strbuf_idx += len; @@ -1175,7 +1175,7 @@ static int string_start(void) */ static void push_buffer(pp_entry_t *ppp, char *filename, char *incname, int pop) { - if(ppdebug) + if(ppy_debug) printf("push_buffer(%d): %p %p %p %d\n", bufferstackidx, ppp, filename, incname, pop); if(bufferstackidx >= MAXBUFFERSTACK) pp_internal_error(__FILE__, __LINE__, "Buffer stack overflow"); @@ -1197,7 +1197,7 @@ static void push_buffer(pp_entry_t *ppp, char *filename, char *incname, int pop) ppp->expanding = 1; else if(filename) { - /* These will track the pperror to the correct file and line */ + /* These will track the ppy_error to the correct file and line */ pp_status.line_number = 1; pp_status.char_number = 1; pp_status.input = filename; @@ -1228,8 +1228,8 @@ static bufferstackentry_t *pop_buffer(void) ncontinuations = bufferstack[bufferstackidx].ncontinuations; if(!bufferstack[bufferstackidx].should_pop) { - fclose(ppin); - fprintf(ppout, "# %d \"%s\" 2\n", pp_status.line_number, pp_status.input); + fclose(ppy_in); + fprintf(ppy_out, "# %d \"%s\" 2\n", pp_status.line_number, pp_status.input); /* We have EOF, check the include logic */ if(pp_incl_state.state == 2 && !pp_incl_state.seen_junk && pp_incl_state.ppp) @@ -1260,7 +1260,7 @@ static bufferstackentry_t *pop_buffer(void) } } - if(ppdebug) + if(ppy_debug) printf("pop_buffer(%d): %p %p (%d, %d, %d) %p %d\n", bufferstackidx, bufferstack[bufferstackidx].bufferstate, @@ -1271,7 +1271,7 @@ static bufferstackentry_t *pop_buffer(void) bufferstack[bufferstackidx].filename, bufferstack[bufferstackidx].should_pop); - pp_switch_to_buffer(bufferstack[bufferstackidx].bufferstate); + ppy__switch_to_buffer(bufferstack[bufferstackidx].bufferstate); if(bufferstack[bufferstackidx].should_pop) { @@ -1294,7 +1294,7 @@ static bufferstackentry_t *pop_buffer(void) static void push_macro(pp_entry_t *ppp) { if(macexpstackidx >= MAXMACEXPSTACK) - pperror("Too many nested macros"); + ppy_error("Too many nested macros"); macexpstack[macexpstackidx] = pp_xmalloc(sizeof(macexpstack[0][0])); memset( macexpstack[macexpstackidx], 0, sizeof(macexpstack[0][0])); @@ -1416,7 +1416,7 @@ static void put_buffer(const char *s, int len) add_text_to_macro(s, len); else { if(pass_data) - fwrite(s, 1, len, ppout); + fwrite(s, 1, len, ppy_out); } } @@ -1457,13 +1457,13 @@ void pp_do_include(char *fname, int type) n = strlen(fname); if(n <= 2) - pperror("Empty include filename"); + ppy_error("Empty include filename"); /* Undo the effect of the quotation */ fname[n-1] = '\0'; - if((ppin = pp_open_include(fname+1, type ? pp_status.input : NULL, &newpath)) == NULL) - pperror("Unable to open include file %s", fname+1); + if((ppy_in = pp_open_include(fname+1, type ? pp_status.input : NULL, &newpath)) == NULL) + ppy_error("Unable to open include file %s", fname+1); fname[n-1] = *fname; /* Redo the quotes */ push_buffer(NULL, newpath, fname, 0); @@ -1476,9 +1476,9 @@ void pp_do_include(char *fname, int type) if(pp_status.debug) fprintf(stderr, "pp_do_include: %s:%d: include_state=%d, include_ppp='%s', include_ifdepth=%d ,pass_data=%d\n", pp_status.input, pp_status.line_number, pp_incl_state.state, pp_incl_state.ppp, pp_incl_state.ifdepth, pass_data); - pp_switch_to_buffer(pp_create_buffer(ppin, YY_BUF_SIZE)); + ppy__switch_to_buffer(ppy__create_buffer(ppy_in, YY_BUF_SIZE)); - fprintf(ppout, "# 1 \"%s\" 1%s\n", newpath, type ? "" : " 3"); + fprintf(ppy_out, "# 1 \"%s\" 1%s\n", newpath, type ? "" : " 3"); } /* diff --git a/libs/wpp/ppy.y b/libs/wpp/ppy.y index 3d7928a76bb..3209ee2cc36 100644 --- a/libs/wpp/ppy.y +++ b/libs/wpp/ppy.y @@ -123,8 +123,6 @@ static int nmacro_args; %} -%name-prefix="pp" - %union{ int sint; unsigned int uint; @@ -225,7 +223,7 @@ preprocessor break; case if_elsetrue: case if_elsefalse: - pperror("#elif cannot follow #else"); + ppy_error("#elif cannot follow #else"); default: pp_internal_error(__FILE__, __LINE__, "Invalid pp_if_state (%d) in #elif directive", s); } @@ -248,7 +246,7 @@ preprocessor break; case if_elsetrue: case if_elsefalse: - pperror("#else clause already defined"); + ppy_error("#else clause already defined"); default: pp_internal_error(__FILE__, __LINE__, "Invalid pp_if_state (%d) in #else directive", s); } @@ -273,21 +271,21 @@ preprocessor | tMACRO res_arg allmargs tMACROEND opt_mtexts tNL { pp_add_macro($1, macro_args, nmacro_args, $5); } - | tLINE tSINT tDQSTRING tNL { fprintf(ppout, "# %d %s\n", $2 , $3); free($3); } - | tGCCLINE tSINT tDQSTRING tNL { fprintf(ppout, "# %d %s\n", $2 , $3); free($3); } + | tLINE tSINT tDQSTRING tNL { fprintf(ppy_out, "# %d %s\n", $2 , $3); free($3); } + | tGCCLINE tSINT tDQSTRING tNL { fprintf(ppy_out, "# %d %s\n", $2 , $3); free($3); } | tGCCLINE tSINT tDQSTRING tSINT tNL - { fprintf(ppout, "# %d %s %d\n", $2, $3, $4); free($3); } + { fprintf(ppy_out, "# %d %s %d\n", $2, $3, $4); free($3); } | tGCCLINE tSINT tDQSTRING tSINT tSINT tNL - { fprintf(ppout, "# %d %s %d %d\n", $2 ,$3, $4, $5); free($3); } + { fprintf(ppy_out, "# %d %s %d %d\n", $2 ,$3, $4, $5); free($3); } | tGCCLINE tSINT tDQSTRING tSINT tSINT tSINT tNL - { fprintf(ppout, "# %d %s %d %d %d\n", $2 ,$3 ,$4 ,$5, $6); free($3); } + { fprintf(ppy_out, "# %d %s %d %d %d\n", $2 ,$3 ,$4 ,$5, $6); free($3); } | tGCCLINE tSINT tDQSTRING tSINT tSINT tSINT tSINT tNL - { fprintf(ppout, "# %d %s %d %d %d %d\n", $2 ,$3 ,$4 ,$5, $6, $7); free($3); } + { fprintf(ppy_out, "# %d %s %d %d %d %d\n", $2 ,$3 ,$4 ,$5, $6, $7); free($3); } | tGCCLINE tNL /* The null-token */ - | tERROR opt_text tNL { pperror("#error directive: '%s'", $2); if($2) free($2); } - | tWARNING opt_text tNL { ppwarning("#warning directive: '%s'", $2); if($2) free($2); } - | tPRAGMA opt_text tNL { fprintf(ppout, "#pragma %s\n", $2 ? $2 : ""); if ($2) free($2); } - | tPPIDENT opt_text tNL { if(pp_status.pedantic) ppwarning("#ident ignored (arg: '%s')", $2); if($2) free($2); } + | tERROR opt_text tNL { ppy_error("#error directive: '%s'", $2); if($2) free($2); } + | tWARNING opt_text tNL { ppy_warning("#warning directive: '%s'", $2); if($2) free($2); } + | tPRAGMA opt_text tNL { fprintf(ppy_out, "#pragma %s\n", $2 ? $2 : ""); if ($2) free($2); } + | tPPIDENT opt_text tNL { if(pp_status.pedantic) ppy_warning("#ident ignored (arg: '%s')", $2); if($2) free($2); } | tRCINCLUDE tRCINCLUDEPATH { int nl=strlen($2) +3; char *fn=pp_xmalloc(nl); @@ -347,7 +345,7 @@ mtext : tLITERAL { $$ = new_mtext($1, 0, exp_text); } | tSTRINGIZE tIDENT { int mat = marg_index($2); if(mat < 0) - pperror("Stringification identifier must be an argument parameter"); + ppy_error("Stringification identifier must be an argument parameter"); $$ = new_mtext(NULL, mat, exp_stringize); } | tIDENT { diff --git a/libs/wpp/preproc.c b/libs/wpp/preproc.c index 4450afa4160..c1fa3fc6ec7 100644 --- a/libs/wpp/preproc.c +++ b/libs/wpp/preproc.c @@ -203,7 +203,7 @@ void pp_del_define(const char *name) if((ppp = pplookup(name)) == NULL) { if(pp_status.pedantic) - ppwarning("%s was not defined", name); + ppy_warning("%s was not defined", name); return; } @@ -223,7 +223,7 @@ pp_entry_t *pp_add_define(char *def, char *text) if((ppp = pplookup(def)) != NULL) { if(pp_status.pedantic) - ppwarning("Redefinition of %s\n\tPrevious definition: %s:%d", def, ppp->filename, ppp->linenumber); + ppy_warning("Redefinition of %s\n\tPrevious definition: %s:%d", def, ppp->filename, ppp->linenumber); pp_del_define(def); } ppp = pp_xmalloc(sizeof(pp_entry_t)); @@ -265,7 +265,7 @@ pp_entry_t *pp_add_macro(char *id, marg_t *args[], int nargs, mtext_t *exp) if((ppp = pplookup(id)) != NULL) { if(pp_status.pedantic) - ppwarning("Redefinition of %s\n\tPrevious definition: %s:%d", id, ppp->filename, ppp->linenumber); + ppy_warning("Redefinition of %s\n\tPrevious definition: %s:%d", id, ppp->filename, ppp->linenumber); pp_del_define(id); } ppp = pp_xmalloc(sizeof(pp_entry_t)); @@ -524,7 +524,7 @@ void pp_push_if(pp_if_state_t s) pp_if_state_t pp_pop_if(void) { if(if_stack_idx <= 0) - pperror("#{endif,else,elif} without #{if,ifdef,ifndef} (#if-stack underflow)"); + ppy_error("#{endif,else,elif} without #{if,ifdef,ifndef} (#if-stack underflow)"); switch(pp_if_state()) { @@ -606,21 +606,21 @@ static void generic_msg(const char *s, const char *t, const char *n, va_list ap) fprintf(stderr, "\n"); } -int pperror(const char *s, ...) +int ppy_error(const char *s, ...) { va_list ap; va_start(ap, s); - generic_msg(s, "Error", pptext, ap); + generic_msg(s, "Error", ppy_text, ap); va_end(ap); exit(1); return 1; } -int ppwarning(const char *s, ...) +int ppy_warning(const char *s, ...) { va_list ap; va_start(ap, s); - generic_msg(s, "Warning", pptext, ap); + generic_msg(s, "Warning", ppy_text, ap); va_end(ap); return 0; } diff --git a/libs/wpp/wpp.c b/libs/wpp/wpp.c index 8e3426451fc..59429c74725 100644 --- a/libs/wpp/wpp.c +++ b/libs/wpp/wpp.c @@ -28,7 +28,7 @@ #include "wpp_private.h" #include "wine/wpp.h" -int ppdebug, pp_flex_debug; +int ppy_debug, pp_flex_debug; struct define { @@ -126,7 +126,7 @@ void wpp_add_cmdline_define( const char *value ) void wpp_set_debug( int lex_debug, int parser_debug, int msg_debug ) { pp_flex_debug = lex_debug; - ppdebug = parser_debug; + ppy_debug = parser_debug; pp_status.debug = msg_debug; } @@ -149,8 +149,8 @@ int wpp_parse( const char *input, FILE *output ) add_cmdline_defines(); add_special_defines(); - if (!input) ppin = stdin; - else if (!(ppin = fopen(input, "rt"))) + if (!input) ppy_in = stdin; + else if (!(ppy_in = fopen(input, "rt"))) { fprintf(stderr,"Could not open %s\n", input); exit(2); @@ -158,12 +158,12 @@ int wpp_parse( const char *input, FILE *output ) pp_status.input = input; - ppout = output; - fprintf(ppout, "# 1 \"%s\" 1\n", input ? input : ""); + ppy_out = output; + fprintf(ppy_out, "# 1 \"%s\" 1\n", input ? input : ""); - ret = ppparse(); + ret = ppy_parse(); - if (input) fclose(ppin); + if (input) fclose(ppy_in); pp_pop_define_state(); return ret; } diff --git a/libs/wpp/wpp_private.h b/libs/wpp/wpp_private.h index 06f170b7937..ff0fae7a2f5 100644 --- a/libs/wpp/wpp_private.h +++ b/libs/wpp/wpp_private.h @@ -217,8 +217,8 @@ int pp_get_if_depth(void); #define __attribute__(x) /*nothing*/ #endif -int pperror(const char *s, ...) __attribute__((format (printf, 1, 2))); -int ppwarning(const char *s, ...) __attribute__((format (printf, 1, 2))); +int ppy_error(const char *s, ...) __attribute__((format (printf, 1, 2))); +int ppy_warning(const char *s, ...) __attribute__((format (printf, 1, 2))); void pp_internal_error(const char *file, int line, const char *s, ...) __attribute__((format (printf, 3, 4))); /* current preprocessor state */ @@ -239,11 +239,11 @@ extern includelogicentry_t *pp_includelogiclist; /* * From ppl.l */ -extern FILE *ppin; -extern FILE *ppout; -extern char *pptext; +extern FILE *ppy_in; +extern FILE *ppy_out; +extern char *ppy_text; extern int pp_flex_debug; -int pplex(void); +int ppy_lex(void); void pp_do_include(char *fname, int type); void pp_push_ignore_state(void); @@ -253,7 +253,7 @@ void pp_pop_ignore_state(void); /* * From ppy.y */ -int ppparse(void); -extern int ppdebug; +int ppy_parse(void); +extern int ppy_debug; #endif /* __WINE_WPP_PRIVATE_H */