ReceiveTempSMS
/
Sweden-Number
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

wpp: Change the prefix on bison-generated names to avoid the name-prefix directive.

This commit is contained in:
Alexandre Julliard 2006-09-12 09:04:55 +02:00
parent 1be6e9a6b1
commit 2d778c5eea
5 changed files with 143 additions and 145 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

212
libs/wpp/ppl.l
View File

@ -127,7 +127,7 @@
%option stack %option stack
%option 8bit never-interactive %option 8bit never-interactive
%option nounput %option nounput
%option prefix="pp" %option prefix="ppy_"
%x pp_pp %x pp_pp
%x pp_eol %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 * 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 * Buffer management for includes and expansions
@ -328,22 +328,22 @@ includelogicentry_t *pp_includelogiclist = NULL;
<pp_pp>{ws}*endif{ws}* yy_pp_state(pp_endif); return tENDIF; <pp_pp>{ws}*endif{ws}* yy_pp_state(pp_endif); return tENDIF;
<pp_pp>{ws}*line{ws}* if(yy_top_state() != pp_ignore) {yy_pp_state(pp_line); return tLINE;} else {yy_pp_state(pp_eol);} <pp_pp>{ws}*line{ws}* if(yy_top_state() != pp_ignore) {yy_pp_state(pp_line); return tLINE;} else {yy_pp_state(pp_eol);}
<pp_pp>{ws}+ if(yy_top_state() != pp_ignore) {yy_pp_state(pp_line); return tGCCLINE;} else {yy_pp_state(pp_eol);} <pp_pp>{ws}+ if(yy_top_state() != pp_ignore) {yy_pp_state(pp_line); return tGCCLINE;} else {yy_pp_state(pp_eol);}
<pp_pp>{ws}*[a-z]+ pperror("Invalid preprocessor token '%s'", pptext); <pp_pp>{ws}*[a-z]+ ppy_error("Invalid preprocessor token '%s'", ppy_text);
<pp_pp>\r?\n newline(1); yy_pop_state(); return tNL; /* This could be the null-token */ <pp_pp>\r?\n newline(1); yy_pop_state(); return tNL; /* This could be the null-token */
<pp_pp>\\\r?\n newline(0); <pp_pp>\\\r?\n newline(0);
<pp_pp>\\\r? pperror("Preprocessor junk '%s'", pptext); <pp_pp>\\\r? ppy_error("Preprocessor junk '%s'", ppy_text);
<pp_pp>. return *pptext; <pp_pp>. return *ppy_text;
/* /*
* Handle #include and #line * Handle #include and #line
*/ */
<pp_line>[0-9]+ return make_number(10, &pplval, pptext, ppleng); <pp_line>[0-9]+ return make_number(10, &ppy_lval, ppy_text, ppy_leng);
<pp_inc>\< new_string(); add_string(pptext, ppleng); yy_push_state(pp_iqs); <pp_inc>\< new_string(); add_string(ppy_text, ppy_leng); yy_push_state(pp_iqs);
<pp_inc,pp_line>\" new_string(); add_string(pptext, ppleng); yy_push_state(pp_dqs); <pp_inc,pp_line>\" new_string(); add_string(ppy_text, ppy_leng); yy_push_state(pp_dqs);
<pp_inc,pp_line>{ws}+ ; <pp_inc,pp_line>{ws}+ ;
<pp_inc,pp_line>\n newline(1); yy_pop_state(); return tNL; <pp_inc,pp_line>\n newline(1); yy_pop_state(); return tNL;
<pp_inc,pp_line>\\\r?\n newline(0); <pp_inc,pp_line>\\\r?\n newline(0);
<pp_inc,pp_line>(\\\r?)|(.) pperror(yy_current_state() == pp_inc ? "Trailing junk in #include" : "Trailing junk in #line"); <pp_inc,pp_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 * Ignore all input when a false clause is parsed
@ -360,11 +360,11 @@ includelogicentry_t *pp_includelogiclist = NULL;
* Note: tIDENT is handled below. * Note: tIDENT is handled below.
*/ */
<pp_if>0[0-7]*{ul}? return make_number(8, &pplval, pptext, ppleng); <pp_if>0[0-7]*{ul}? return make_number(8, &ppy_lval, ppy_text, ppy_leng);
<pp_if>0[0-7]*[8-9]+{ul}? pperror("Invalid octal digit"); <pp_if>0[0-7]*[8-9]+{ul}? ppy_error("Invalid octal digit");
<pp_if>[1-9][0-9]*{ul}? return make_number(10, &pplval, pptext, ppleng); <pp_if>[1-9][0-9]*{ul}? return make_number(10, &ppy_lval, ppy_text, ppy_leng);
<pp_if>0[xX][0-9a-fA-F]+{ul}? return make_number(16, &pplval, pptext, ppleng); <pp_if>0[xX][0-9a-fA-F]+{ul}? return make_number(16, &ppy_lval, ppy_text, ppy_leng);
<pp_if>0[xX] pperror("Invalid hex number"); <pp_if>0[xX] ppy_error("Invalid hex number");
<pp_if>defined yy_push_state(pp_defined); return tDEFINED; <pp_if>defined yy_push_state(pp_defined); return tDEFINED;
<pp_if>"<<" return tLSHIFT; <pp_if>"<<" return tLSHIFT;
<pp_if>">>" return tRSHIFT; <pp_if>">>" return tRSHIFT;
@ -376,21 +376,21 @@ includelogicentry_t *pp_includelogiclist = NULL;
<pp_if>">=" return tGTE; <pp_if>">=" return tGTE;
<pp_if>\n newline(1); yy_pop_state(); return tNL; <pp_if>\n newline(1); yy_pop_state(); return tNL;
<pp_if>\\\r?\n newline(0); <pp_if>\\\r?\n newline(0);
<pp_if>\\\r? pperror("Junk in conditional expression"); <pp_if>\\\r? ppy_error("Junk in conditional expression");
<pp_if>{ws}+ ; <pp_if>{ws}+ ;
<pp_if>\' new_string(); add_string(pptext, ppleng); yy_push_state(pp_sqs); <pp_if>\' new_string(); add_string(ppy_text, ppy_leng); yy_push_state(pp_sqs);
<pp_if>\" pperror("String constants not allowed in conditionals"); <pp_if>\" ppy_error("String constants not allowed in conditionals");
<pp_if>. return *pptext; <pp_if>. return *ppy_text;
/* /*
* Handle #ifdef, #ifndef and #undef * Handle #ifdef, #ifndef and #undef
* to get only an untranslated/unexpanded identifier * to get only an untranslated/unexpanded identifier
*/ */
<pp_ifd>{cident} pplval.cptr = pp_xstrdup(pptext); return tIDENT; <pp_ifd>{cident} ppy_lval.cptr = pp_xstrdup(ppy_text); return tIDENT;
<pp_ifd>{ws}+ ; <pp_ifd>{ws}+ ;
<pp_ifd>\n newline(1); yy_pop_state(); return tNL; <pp_ifd>\n newline(1); yy_pop_state(); return tNL;
<pp_ifd>\\\r?\n newline(0); <pp_ifd>\\\r?\n newline(0);
<pp_ifd>(\\\r?)|(.) pperror("Identifier expected"); <pp_ifd>(\\\r?)|(.) ppy_error("Identifier expected");
/* /*
* Handle #else and #endif. * Handle #else and #endif.
@ -398,18 +398,18 @@ includelogicentry_t *pp_includelogiclist = NULL;
<pp_endif>{ws}+ ; <pp_endif>{ws}+ ;
<pp_endif>\n newline(1); yy_pop_state(); return tNL; <pp_endif>\n newline(1); yy_pop_state(); return tNL;
<pp_endif>\\\r?\n newline(0); <pp_endif>\\\r?\n newline(0);
<pp_endif>. pperror("Garbage after #else or #endif."); <pp_endif>. ppy_error("Garbage after #else or #endif.");
/* /*
* Handle the special 'defined' keyword. * Handle the special 'defined' keyword.
* This is necessary to get the identifier prior to any * This is necessary to get the identifier prior to any
* substitutions. * substitutions.
*/ */
<pp_defined>{cident} yy_pop_state(); pplval.cptr = pp_xstrdup(pptext); return tIDENT; <pp_defined>{cident} yy_pop_state(); ppy_lval.cptr = pp_xstrdup(ppy_text); return tIDENT;
<pp_defined>{ws}+ ; <pp_defined>{ws}+ ;
<pp_defined>(\()|(\)) return *pptext; <pp_defined>(\()|(\)) return *ppy_text;
<pp_defined>\\\r?\n newline(0); <pp_defined>\\\r?\n newline(0);
<pp_defined>(\\.)|(\n)|(.) pperror("Identifier expected"); <pp_defined>(\\.)|(\n)|(.) ppy_error("Identifier expected");
/* /*
* Handle #error, #warning, #pragma and #ident. * Handle #error, #warning, #pragma and #ident.
@ -417,17 +417,17 @@ includelogicentry_t *pp_includelogiclist = NULL;
* will act appropriately. * will act appropriately.
* Comments are stripped from the literal text. * Comments are stripped from the literal text.
*/ */
<pp_eol>[^/\\\n]+ if(yy_top_state() != pp_ignore) { pplval.cptr = pp_xstrdup(pptext); return tLITERAL; } <pp_eol>[^/\\\n]+ if(yy_top_state() != pp_ignore) { ppy_lval.cptr = pp_xstrdup(ppy_text); return tLITERAL; }
<pp_eol>\/[^/\\\n*]* if(yy_top_state() != pp_ignore) { pplval.cptr = pp_xstrdup(pptext); return tLITERAL; } <pp_eol>\/[^/\\\n*]* if(yy_top_state() != pp_ignore) { ppy_lval.cptr = pp_xstrdup(ppy_text); return tLITERAL; }
<pp_eol>(\\\r?)|(\/[^/*]) if(yy_top_state() != pp_ignore) { pplval.cptr = pp_xstrdup(pptext); return tLITERAL; } <pp_eol>(\\\r?)|(\/[^/*]) if(yy_top_state() != pp_ignore) { ppy_lval.cptr = pp_xstrdup(ppy_text); return tLITERAL; }
<pp_eol>\n newline(1); yy_pop_state(); if(yy_current_state() != pp_ignore) { return tNL; } <pp_eol>\n newline(1); yy_pop_state(); if(yy_current_state() != pp_ignore) { return tNL; }
<pp_eol>\\\r?\n newline(0); <pp_eol>\\\r?\n newline(0);
/* /*
* Handle left side of #define * Handle left side of #define
*/ */
<pp_def>{cident}\( pplval.cptr = pp_xstrdup(pptext); pplval.cptr[ppleng-1] = '\0'; yy_pp_state(pp_macro); return tMACRO; <pp_def>{cident}\( ppy_lval.cptr = pp_xstrdup(ppy_text); ppy_lval.cptr[ppy_leng-1] = '\0'; yy_pp_state(pp_macro); return tMACRO;
<pp_def>{cident} pplval.cptr = pp_xstrdup(pptext); yy_pp_state(pp_define); return tDEFINE; <pp_def>{cident} ppy_lval.cptr = pp_xstrdup(ppy_text); yy_pp_state(pp_define); return tDEFINE;
<pp_def>{ws}+ ; <pp_def>{ws}+ ;
<pp_def>\\\r?\n newline(0); <pp_def>\\\r?\n newline(0);
<pp_def>(\\\r?)|(\n)|(.) perror("Identifier expected"); <pp_def>(\\\r?)|(\n)|(.) perror("Identifier expected");
@ -435,39 +435,39 @@ includelogicentry_t *pp_includelogiclist = NULL;
/* /*
* Scan the substitution of a define * Scan the substitution of a define
*/ */
<pp_define>[^'"/\\\n]+ pplval.cptr = pp_xstrdup(pptext); return tLITERAL; <pp_define>[^'"/\\\n]+ ppy_lval.cptr = pp_xstrdup(ppy_text); return tLITERAL;
<pp_define>(\\\r?)|(\/[^/*]) pplval.cptr = pp_xstrdup(pptext); return tLITERAL; <pp_define>(\\\r?)|(\/[^/*]) ppy_lval.cptr = pp_xstrdup(ppy_text); return tLITERAL;
<pp_define>\\\r?\n{ws}+ newline(0); pplval.cptr = pp_xstrdup(" "); return tLITERAL; <pp_define>\\\r?\n{ws}+ newline(0); ppy_lval.cptr = pp_xstrdup(" "); return tLITERAL;
<pp_define>\\\r?\n newline(0); <pp_define>\\\r?\n newline(0);
<pp_define>\n newline(1); yy_pop_state(); return tNL; <pp_define>\n newline(1); yy_pop_state(); return tNL;
<pp_define>\' new_string(); add_string(pptext, ppleng); yy_push_state(pp_sqs); <pp_define>\' new_string(); add_string(ppy_text, ppy_leng); yy_push_state(pp_sqs);
<pp_define>\" new_string(); add_string(pptext, ppleng); yy_push_state(pp_dqs); <pp_define>\" new_string(); add_string(ppy_text, ppy_leng); yy_push_state(pp_dqs);
/* /*
* Scan the definition macro arguments * Scan the definition macro arguments
*/ */
<pp_macro>\){ws}* yy_pp_state(pp_mbody); return tMACROEND; <pp_macro>\){ws}* yy_pp_state(pp_mbody); return tMACROEND;
<pp_macro>{ws}+ ; <pp_macro>{ws}+ ;
<pp_macro>{cident} pplval.cptr = pp_xstrdup(pptext); return tIDENT; <pp_macro>{cident} ppy_lval.cptr = pp_xstrdup(ppy_text); return tIDENT;
<pp_macro>, return ','; <pp_macro>, return ',';
<pp_macro>"..." return tELIPSIS; <pp_macro>"..." return tELIPSIS;
<pp_macro>(\\\r?)|(\n)|(.)|(\.\.?) pperror("Argument identifier expected"); <pp_macro>(\\\r?)|(\n)|(.)|(\.\.?) ppy_error("Argument identifier expected");
<pp_macro>\\\r?\n newline(0); <pp_macro>\\\r?\n newline(0);
/* /*
* Scan the substitution of a macro * Scan the substitution of a macro
*/ */
<pp_mbody>[^a-zA-Z0-9'"#/\\\n]+ pplval.cptr = pp_xstrdup(pptext); return tLITERAL; <pp_mbody>[^a-zA-Z0-9'"#/\\\n]+ ppy_lval.cptr = pp_xstrdup(ppy_text); return tLITERAL;
<pp_mbody>{cident} pplval.cptr = pp_xstrdup(pptext); return tIDENT; <pp_mbody>{cident} ppy_lval.cptr = pp_xstrdup(ppy_text); return tIDENT;
<pp_mbody>\#\# return tCONCAT; <pp_mbody>\#\# return tCONCAT;
<pp_mbody>\# return tSTRINGIZE; <pp_mbody>\# return tSTRINGIZE;
<pp_mbody>[0-9][^'"#/\\\n]* pplval.cptr = pp_xstrdup(pptext); return tLITERAL; <pp_mbody>[0-9][^'"#/\\\n]* ppy_lval.cptr = pp_xstrdup(ppy_text); return tLITERAL;
<pp_mbody>(\\\r?)|(\/[^/*'"#\\\n]*) pplval.cptr = pp_xstrdup(pptext); return tLITERAL; <pp_mbody>(\\\r?)|(\/[^/*'"#\\\n]*) ppy_lval.cptr = pp_xstrdup(ppy_text); return tLITERAL;
<pp_mbody>\\\r?\n{ws}+ newline(0); pplval.cptr = pp_xstrdup(" "); return tLITERAL; <pp_mbody>\\\r?\n{ws}+ newline(0); ppy_lval.cptr = pp_xstrdup(" "); return tLITERAL;
<pp_mbody>\\\r?\n newline(0); <pp_mbody>\\\r?\n newline(0);
<pp_mbody>\n newline(1); yy_pop_state(); return tNL; <pp_mbody>\n newline(1); yy_pop_state(); return tNL;
<pp_mbody>\' new_string(); add_string(pptext, ppleng); yy_push_state(pp_sqs); <pp_mbody>\' new_string(); add_string(ppy_text, ppy_leng); yy_push_state(pp_sqs);
<pp_mbody>\" new_string(); add_string(pptext, ppleng); yy_push_state(pp_dqs); <pp_mbody>\" new_string(); add_string(ppy_text, ppy_leng); yy_push_state(pp_dqs);
/* /*
* Macro expansion text scanning. * Macro expansion text scanning.
@ -488,7 +488,7 @@ includelogicentry_t *pp_includelogiclist = NULL;
macexpstackentry_t *mac = pop_macro(); macexpstackentry_t *mac = pop_macro();
yy_pop_state(); yy_pop_state();
put_buffer(mac->ppp->ident, strlen(mac->ppp->ident)); put_buffer(mac->ppp->ident, strlen(mac->ppp->ident));
put_buffer(pptext, ppleng); put_buffer(ppy_text, ppy_leng);
free_macro(mac); free_macro(mac);
} }
@ -498,7 +498,7 @@ includelogicentry_t *pp_includelogiclist = NULL;
*/ */
<pp_macscan>\( { <pp_macscan>\( {
if(++MACROPARENTHESES() > 1) if(++MACROPARENTHESES() > 1)
add_text_to_macro(pptext, ppleng); add_text_to_macro(ppy_text, ppy_leng);
} }
<pp_macscan>\) { <pp_macscan>\) {
if(--MACROPARENTHESES() == 0) if(--MACROPARENTHESES() == 0)
@ -507,19 +507,19 @@ includelogicentry_t *pp_includelogiclist = NULL;
macro_add_arg(1); macro_add_arg(1);
} }
else else
add_text_to_macro(pptext, ppleng); add_text_to_macro(ppy_text, ppy_leng);
} }
<pp_macscan>, { <pp_macscan>, {
if(MACROPARENTHESES() > 1) if(MACROPARENTHESES() > 1)
add_text_to_macro(pptext, ppleng); add_text_to_macro(ppy_text, ppy_leng);
else else
macro_add_arg(0); macro_add_arg(0);
} }
<pp_macscan>\" new_string(); add_string(pptext, ppleng); yy_push_state(pp_dqs); <pp_macscan>\" new_string(); add_string(ppy_text, ppy_leng); yy_push_state(pp_dqs);
<pp_macscan>\' new_string(); add_string(pptext, ppleng); yy_push_state(pp_sqs); <pp_macscan>\' new_string(); add_string(ppy_text, ppy_leng); yy_push_state(pp_sqs);
<pp_macscan>"/*" yy_push_state(pp_comment); add_text_to_macro(" ", 1); <pp_macscan>"/*" yy_push_state(pp_comment); add_text_to_macro(" ", 1);
<pp_macscan>\n pp_status.line_number++; pp_status.char_number = 1; add_text_to_macro(pptext, ppleng); <pp_macscan>\n pp_status.line_number++; pp_status.char_number = 1; add_text_to_macro(ppy_text, ppy_leng);
<pp_macscan>([^/(),\\\n"']+)|(\/[^/*(),\\\n'"]*)|(\\\r?)|(.) add_text_to_macro(pptext, ppleng); <pp_macscan>([^/(),\\\n"']+)|(\/[^/*(),\\\n'"]*)|(\\\r?)|(.) add_text_to_macro(ppy_text, ppy_leng);
<pp_macscan>\\\r?\n newline(0); <pp_macscan>\\\r?\n newline(0);
/* /*
@ -534,18 +534,18 @@ includelogicentry_t *pp_includelogiclist = NULL;
* Remove C++ style comment (almost all start-conditions) * Remove C++ style comment (almost all start-conditions)
*/ */
<INITIAL,pp_pp,pp_ignore,pp_eol,pp_inc,pp_if,pp_ifd,pp_endif,pp_defined,pp_def,pp_define,pp_macro,pp_mbody,pp_macscan,RCINCL>"//"[^\n]* { <INITIAL,pp_pp,pp_ignore,pp_eol,pp_inc,pp_if,pp_ifd,pp_endif,pp_defined,pp_def,pp_define,pp_macro,pp_mbody,pp_macscan,RCINCL>"//"[^\n]* {
if(pptext[ppleng-1] == '\\') if(ppy_text[ppy_leng-1] == '\\')
ppwarning("C++ style comment ends with an escaped newline (escape ignored)"); ppy_warning("C++ style comment ends with an escaped newline (escape ignored)");
} }
/* /*
* Single, double and <> quoted constants * Single, double and <> quoted constants
*/ */
<INITIAL,pp_macexp>\" pp_incl_state.seen_junk++; new_string(); add_string(pptext, ppleng); yy_push_state(pp_dqs); <INITIAL,pp_macexp>\" pp_incl_state.seen_junk++; new_string(); add_string(ppy_text, ppy_leng); yy_push_state(pp_dqs);
<INITIAL,pp_macexp>\' pp_incl_state.seen_junk++; new_string(); add_string(pptext, ppleng); yy_push_state(pp_sqs); <INITIAL,pp_macexp>\' pp_incl_state.seen_junk++; new_string(); add_string(ppy_text, ppy_leng); yy_push_state(pp_sqs);
<pp_dqs>[^"\\\n]+ add_string(pptext, ppleng); <pp_dqs>[^"\\\n]+ add_string(ppy_text, ppy_leng);
<pp_dqs>\" { <pp_dqs>\" {
add_string(pptext, ppleng); add_string(ppy_text, ppy_leng);
yy_pop_state(); yy_pop_state();
switch(yy_current_state()) switch(yy_current_state())
{ {
@ -555,37 +555,37 @@ includelogicentry_t *pp_includelogiclist = NULL;
case pp_inc: case pp_inc:
case RCINCL: case RCINCL:
if (yy_current_state()==RCINCL) yy_pop_state(); if (yy_current_state()==RCINCL) yy_pop_state();
pplval.cptr = get_string(); ppy_lval.cptr = get_string();
return tDQSTRING; return tDQSTRING;
case pp_line: case pp_line:
pplval.cptr = get_string(); ppy_lval.cptr = get_string();
if (is_c_h_include(pplval.cptr, 1)) pass_data=0; if (is_c_h_include(ppy_lval.cptr, 1)) pass_data=0;
else pass_data=1; else pass_data=1;
return tDQSTRING; return tDQSTRING;
default: default:
put_string(); put_string();
} }
} }
<pp_sqs>[^'\\\n]+ add_string(pptext, ppleng); <pp_sqs>[^'\\\n]+ add_string(ppy_text, ppy_leng);
<pp_sqs>\' { <pp_sqs>\' {
add_string(pptext, ppleng); add_string(ppy_text, ppy_leng);
yy_pop_state(); yy_pop_state();
switch(yy_current_state()) switch(yy_current_state())
{ {
case pp_if: case pp_if:
case pp_define: case pp_define:
case pp_mbody: case pp_mbody:
pplval.cptr = get_string(); ppy_lval.cptr = get_string();
return tSQSTRING; return tSQSTRING;
default: default:
put_string(); put_string();
} }
} }
<pp_iqs>[^\>\\\n]+ add_string(pptext, ppleng); <pp_iqs>[^\>\\\n]+ add_string(ppy_text, ppy_leng);
<pp_iqs>\> { <pp_iqs>\> {
add_string(pptext, ppleng); add_string(ppy_text, ppy_leng);
yy_pop_state(); yy_pop_state();
pplval.cptr = get_string(); ppy_lval.cptr = get_string();
return tIQSTRING; return tIQSTRING;
} }
<pp_dqs>\\\r?\n { <pp_dqs>\\\r?\n {
@ -608,15 +608,15 @@ includelogicentry_t *pp_includelogiclist = NULL;
newline(0); newline(0);
break; break;
default: default:
add_string(pptext, ppleng); add_string(ppy_text, ppy_leng);
newline(-1); newline(-1);
} }
} }
<pp_iqs,pp_dqs,pp_sqs>\\. add_string(pptext, ppleng); <pp_iqs,pp_dqs,pp_sqs>\\. add_string(ppy_text, ppy_leng);
<pp_iqs,pp_dqs,pp_sqs>\n { <pp_iqs,pp_dqs,pp_sqs>\n {
newline(1); newline(1);
add_string(pptext, ppleng); add_string(ppy_text, ppy_leng);
ppwarning("Newline in string constant encounterd (started line %d)", string_start()); ppy_warning("Newline in string constant encounterd (started line %d)", string_start());
} }
/* /*
@ -625,22 +625,22 @@ includelogicentry_t *pp_includelogiclist = NULL;
<INITIAL,pp_if,pp_inc,pp_macexp>{cident} { <INITIAL,pp_if,pp_inc,pp_macexp>{cident} {
pp_entry_t *ppp; pp_entry_t *ppp;
pp_incl_state.seen_junk++; pp_incl_state.seen_junk++;
if(!(ppp = pplookup(pptext))) if(!(ppp = pplookup(ppy_text)))
{ {
if(yy_current_state() == pp_inc) if(yy_current_state() == pp_inc)
pperror("Expected include filename"); ppy_error("Expected include filename");
if(yy_current_state() == pp_if) if(yy_current_state() == pp_if)
{ {
pplval.cptr = pp_xstrdup(pptext); ppy_lval.cptr = pp_xstrdup(ppy_text);
return tIDENT; return tIDENT;
} }
else { else {
if((yy_current_state()==INITIAL) && (strcasecmp(pptext,"RCINCLUDE")==0)){ if((yy_current_state()==INITIAL) && (strcasecmp(ppy_text,"RCINCLUDE")==0)){
yy_push_state(RCINCL); yy_push_state(RCINCL);
return tRCINCLUDE; return tRCINCLUDE;
} }
else put_buffer(pptext, ppleng); else put_buffer(ppy_text, ppy_leng);
} }
} }
else if(!ppp->expanding) 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); 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 * Everything else that needs to be passed and
* newline and continuation handling * newline and continuation handling
*/ */
<INITIAL,pp_macexp>[^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); <INITIAL,pp_macexp>[^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);
<INITIAL,pp_macexp>{ws}+ put_buffer(pptext, ppleng); <INITIAL,pp_macexp>{ws}+ put_buffer(ppy_text, ppy_leng);
<INITIAL>\n newline(1); <INITIAL>\n newline(1);
<INITIAL>\\\r?\n newline(0); <INITIAL>\\\r?\n newline(0);
<INITIAL>\\\r? pp_incl_state.seen_junk++; put_buffer(pptext, ppleng); <INITIAL>\\\r? pp_incl_state.seen_junk++; put_buffer(ppy_text, ppy_leng);
/* /*
* Special catcher for macro argmument expansion to prevent * Special catcher for macro argmument expansion to prevent
* newlines to propagate to the output or admin. * newlines to propagate to the output or admin.
*/ */
<pp_macexp>(\n)|(.)|(\\\r?(\n|.)) put_buffer(pptext, ppleng); <pp_macexp>(\n)|(.)|(\\\r?(\n|.)) put_buffer(ppy_text, ppy_leng);
<RCINCL>[A-Za-z0-9_\.\\/]+ { <RCINCL>[A-Za-z0-9_\.\\/]+ {
pplval.cptr=pp_xstrdup(pptext); ppy_lval.cptr=pp_xstrdup(ppy_text);
yy_pop_state(); yy_pop_state();
return tRCINCLUDEPATH; return tRCINCLUDEPATH;
} }
@ -689,26 +689,26 @@ includelogicentry_t *pp_includelogiclist = NULL;
<RCINCL>{ws}+ ; <RCINCL>{ws}+ ;
<RCINCL>\" { <RCINCL>\" {
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 * This is a 'catch-all' rule to discover errors in the scanner
* in an orderly manner. * 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);
<<EOF>> { <<EOF>> {
YY_BUFFER_STATE b = YY_CURRENT_BUFFER; YY_BUFFER_STATE b = YY_CURRENT_BUFFER;
bufferstackentry_t *bep = pop_buffer(); bufferstackentry_t *bep = pop_buffer();
if((!bep && pp_get_if_depth()) || (bep && pp_get_if_depth() != bep->if_depth)) 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(!bep)
{ {
if(YY_START != INITIAL) if(YY_START != INITIAL)
pperror("Unexpected end of file during preprocessing"); ppy_error("Unexpected end of file during preprocessing");
yyterminate(); yyterminate();
} }
else if(bep->should_pop == 2) else if(bep->should_pop == 2)
@ -717,7 +717,7 @@ includelogicentry_t *pp_includelogiclist = NULL;
mac = pop_macro(); mac = pop_macro();
expand_macro(mac); expand_macro(mac);
} }
pp_delete_buffer(b); ppy__delete_buffer(b);
} }
%% %%
@ -727,8 +727,8 @@ includelogicentry_t *pp_includelogiclist = NULL;
************************************************************************** **************************************************************************
*/ */
#ifndef ppwrap #ifndef ppy_wrap
int ppwrap(void) int ppy_wrap(void)
{ {
return 1; 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]) : ' '; ext[0] = len > 2 ? toupper(str[len-3]) : ' ';
if(!strcmp(ext, "LUL")) if(!strcmp(ext, "LUL"))
pperror("Invalid constant suffix"); ppy_error("Invalid constant suffix");
else if(!strcmp(ext, "LLU") || !strcmp(ext, "ULL")) else if(!strcmp(ext, "LLU") || !strcmp(ext, "ULL"))
{ {
is_ll++; is_ll++;
@ -937,7 +937,7 @@ static void add_text(const char *str, int len)
curdef_alloc += (len + ALLOCBLOCKSIZE-1) & ~(ALLOCBLOCKSIZE-1); curdef_alloc += (len + ALLOCBLOCKSIZE-1) & ~(ALLOCBLOCKSIZE-1);
curdef_text = pp_xrealloc(curdef_text, curdef_alloc * sizeof(curdef_text[0])); curdef_text = pp_xrealloc(curdef_text, curdef_alloc * sizeof(curdef_text[0]));
if(curdef_alloc > 65536) 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); memcpy(&curdef_text[curdef_idx], str, len);
curdef_idx += len; curdef_idx += len;
@ -1053,7 +1053,7 @@ static void expand_macro(macexpstackentry_t *mep)
assert(ppp->expanding == 0); assert(ppp->expanding == 0);
if((ppp->nargs >= 0 && nargs != ppp->nargs) || (ppp->nargs < 0 && nargs < -ppp->nargs)) 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++) for(n = 0; n < nargs; n++)
nnl += mep->nnls[n]; nnl += mep->nnls[n];
@ -1122,7 +1122,7 @@ static void new_string(void)
{ {
#ifdef DEBUG #ifdef DEBUG
if(strbuf_idx) if(strbuf_idx)
ppwarning("new_string: strbuf_idx != 0"); ppy_warning("new_string: strbuf_idx != 0");
#endif #endif
strbuf_idx = 0; strbuf_idx = 0;
str_startline = pp_status.line_number; 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); strbuf_alloc += (len + ALLOCBLOCKSIZE-1) & ~(ALLOCBLOCKSIZE-1);
strbuffer = pp_xrealloc(strbuffer, strbuf_alloc * sizeof(strbuffer[0])); strbuffer = pp_xrealloc(strbuffer, strbuf_alloc * sizeof(strbuffer[0]));
if(strbuf_alloc > 65536) 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); memcpy(&strbuffer[strbuf_idx], str, len);
strbuf_idx += 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) 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); printf("push_buffer(%d): %p %p %p %d\n", bufferstackidx, ppp, filename, incname, pop);
if(bufferstackidx >= MAXBUFFERSTACK) if(bufferstackidx >= MAXBUFFERSTACK)
pp_internal_error(__FILE__, __LINE__, "Buffer stack overflow"); 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; ppp->expanding = 1;
else if(filename) 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.line_number = 1;
pp_status.char_number = 1; pp_status.char_number = 1;
pp_status.input = filename; pp_status.input = filename;
@ -1228,8 +1228,8 @@ static bufferstackentry_t *pop_buffer(void)
ncontinuations = bufferstack[bufferstackidx].ncontinuations; ncontinuations = bufferstack[bufferstackidx].ncontinuations;
if(!bufferstack[bufferstackidx].should_pop) if(!bufferstack[bufferstackidx].should_pop)
{ {
fclose(ppin); fclose(ppy_in);
fprintf(ppout, "# %d \"%s\" 2\n", pp_status.line_number, pp_status.input); fprintf(ppy_out, "# %d \"%s\" 2\n", pp_status.line_number, pp_status.input);
/* We have EOF, check the include logic */ /* We have EOF, check the include logic */
if(pp_incl_state.state == 2 && !pp_incl_state.seen_junk && pp_incl_state.ppp) 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", printf("pop_buffer(%d): %p %p (%d, %d, %d) %p %d\n",
bufferstackidx, bufferstackidx,
bufferstack[bufferstackidx].bufferstate, bufferstack[bufferstackidx].bufferstate,
@ -1271,7 +1271,7 @@ static bufferstackentry_t *pop_buffer(void)
bufferstack[bufferstackidx].filename, bufferstack[bufferstackidx].filename,
bufferstack[bufferstackidx].should_pop); bufferstack[bufferstackidx].should_pop);
pp_switch_to_buffer(bufferstack[bufferstackidx].bufferstate); ppy__switch_to_buffer(bufferstack[bufferstackidx].bufferstate);
if(bufferstack[bufferstackidx].should_pop) if(bufferstack[bufferstackidx].should_pop)
{ {
@ -1294,7 +1294,7 @@ static bufferstackentry_t *pop_buffer(void)
static void push_macro(pp_entry_t *ppp) static void push_macro(pp_entry_t *ppp)
{ {
if(macexpstackidx >= MAXMACEXPSTACK) if(macexpstackidx >= MAXMACEXPSTACK)
pperror("Too many nested macros"); ppy_error("Too many nested macros");
macexpstack[macexpstackidx] = pp_xmalloc(sizeof(macexpstack[0][0])); macexpstack[macexpstackidx] = pp_xmalloc(sizeof(macexpstack[0][0]));
memset( macexpstack[macexpstackidx], 0, 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); add_text_to_macro(s, len);
else { else {
if(pass_data) 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); n = strlen(fname);
if(n <= 2) if(n <= 2)
pperror("Empty include filename"); ppy_error("Empty include filename");
/* Undo the effect of the quotation */ /* Undo the effect of the quotation */
fname[n-1] = '\0'; fname[n-1] = '\0';
if((ppin = pp_open_include(fname+1, type ? pp_status.input : NULL, &newpath)) == NULL) if((ppy_in = pp_open_include(fname+1, type ? pp_status.input : NULL, &newpath)) == NULL)
pperror("Unable to open include file %s", fname+1); ppy_error("Unable to open include file %s", fname+1);
fname[n-1] = *fname; /* Redo the quotes */ fname[n-1] = *fname; /* Redo the quotes */
push_buffer(NULL, newpath, fname, 0); push_buffer(NULL, newpath, fname, 0);
@ -1476,9 +1476,9 @@ void pp_do_include(char *fname, int type)
if(pp_status.debug) if(pp_status.debug)
fprintf(stderr, "pp_do_include: %s:%d: include_state=%d, include_ppp='%s', include_ifdepth=%d ,pass_data=%d\n", 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_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");
} }
/* /*

28
libs/wpp/ppy.y
View File

@ -123,8 +123,6 @@ static int nmacro_args;
%} %}
%name-prefix="pp"
%union{ %union{
int sint; int sint;
unsigned int uint; unsigned int uint;
@ -225,7 +223,7 @@ preprocessor
break; break;
case if_elsetrue: case if_elsetrue:
case if_elsefalse: case if_elsefalse:
pperror("#elif cannot follow #else"); ppy_error("#elif cannot follow #else");
default: default:
pp_internal_error(__FILE__, __LINE__, "Invalid pp_if_state (%d) in #elif directive", s); pp_internal_error(__FILE__, __LINE__, "Invalid pp_if_state (%d) in #elif directive", s);
} }
@ -248,7 +246,7 @@ preprocessor
break; break;
case if_elsetrue: case if_elsetrue:
case if_elsefalse: case if_elsefalse:
pperror("#else clause already defined"); ppy_error("#else clause already defined");
default: default:
pp_internal_error(__FILE__, __LINE__, "Invalid pp_if_state (%d) in #else directive", s); 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 { | tMACRO res_arg allmargs tMACROEND opt_mtexts tNL {
pp_add_macro($1, macro_args, nmacro_args, $5); pp_add_macro($1, macro_args, nmacro_args, $5);
} }
| tLINE 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(ppout, "# %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 | 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 | 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 | 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 | 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 */ | tGCCLINE tNL /* The null-token */
| tERROR opt_text tNL { pperror("#error directive: '%s'", $2); if($2) free($2); } | tERROR opt_text tNL { ppy_error("#error directive: '%s'", $2); if($2) free($2); }
| tWARNING opt_text tNL { ppwarning("#warning 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(ppout, "#pragma %s\n", $2 ? $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) ppwarning("#ident ignored (arg: '%s')", $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 { | tRCINCLUDE tRCINCLUDEPATH {
int nl=strlen($2) +3; int nl=strlen($2) +3;
char *fn=pp_xmalloc(nl); char *fn=pp_xmalloc(nl);
@ -347,7 +345,7 @@ mtext : tLITERAL { $$ = new_mtext($1, 0, exp_text); }
| tSTRINGIZE tIDENT { | tSTRINGIZE tIDENT {
int mat = marg_index($2); int mat = marg_index($2);
if(mat < 0) 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); $$ = new_mtext(NULL, mat, exp_stringize);
} }
| tIDENT { | tIDENT {

16
libs/wpp/preproc.c
View File

@ -203,7 +203,7 @@ void pp_del_define(const char *name)
if((ppp = pplookup(name)) == NULL) if((ppp = pplookup(name)) == NULL)
{ {
if(pp_status.pedantic) if(pp_status.pedantic)
ppwarning("%s was not defined", name); ppy_warning("%s was not defined", name);
return; return;
} }
@ -223,7 +223,7 @@ pp_entry_t *pp_add_define(char *def, char *text)
if((ppp = pplookup(def)) != NULL) if((ppp = pplookup(def)) != NULL)
{ {
if(pp_status.pedantic) 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); pp_del_define(def);
} }
ppp = pp_xmalloc(sizeof(pp_entry_t)); 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((ppp = pplookup(id)) != NULL)
{ {
if(pp_status.pedantic) 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); pp_del_define(id);
} }
ppp = pp_xmalloc(sizeof(pp_entry_t)); 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) pp_if_state_t pp_pop_if(void)
{ {
if(if_stack_idx <= 0) 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()) 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"); fprintf(stderr, "\n");
} }
int pperror(const char *s, ...) int ppy_error(const char *s, ...)
{ {
va_list ap; va_list ap;
va_start(ap, s); va_start(ap, s);
generic_msg(s, "Error", pptext, ap); generic_msg(s, "Error", ppy_text, ap);
va_end(ap); va_end(ap);
exit(1); exit(1);
return 1; return 1;
} }
int ppwarning(const char *s, ...) int ppy_warning(const char *s, ...)
{ {
va_list ap; va_list ap;
va_start(ap, s); va_start(ap, s);
generic_msg(s, "Warning", pptext, ap); generic_msg(s, "Warning", ppy_text, ap);
va_end(ap); va_end(ap);
return 0; return 0;
} }

16
libs/wpp/wpp.c
View File

@ -28,7 +28,7 @@
#include "wpp_private.h" #include "wpp_private.h"
#include "wine/wpp.h" #include "wine/wpp.h"
int ppdebug, pp_flex_debug; int ppy_debug, pp_flex_debug;
struct define 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 ) void wpp_set_debug( int lex_debug, int parser_debug, int msg_debug )
{ {
pp_flex_debug = lex_debug; pp_flex_debug = lex_debug;
ppdebug = parser_debug; ppy_debug = parser_debug;
pp_status.debug = msg_debug; pp_status.debug = msg_debug;
} }
@ -149,8 +149,8 @@ int wpp_parse( const char *input, FILE *output )
add_cmdline_defines(); add_cmdline_defines();
add_special_defines(); add_special_defines();
if (!input) ppin = stdin; if (!input) ppy_in = stdin;
else if (!(ppin = fopen(input, "rt"))) else if (!(ppy_in = fopen(input, "rt")))
{ {
fprintf(stderr,"Could not open %s\n", input); fprintf(stderr,"Could not open %s\n", input);
exit(2); exit(2);
@ -158,12 +158,12 @@ int wpp_parse( const char *input, FILE *output )
pp_status.input = input; pp_status.input = input;
ppout = output; ppy_out = output;
fprintf(ppout, "# 1 \"%s\" 1\n", input ? input : ""); 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(); pp_pop_define_state();
return ret; return ret;
} }

16
libs/wpp/wpp_private.h
View File

@ -217,8 +217,8 @@ int pp_get_if_depth(void);
#define __attribute__(x) /*nothing*/ #define __attribute__(x) /*nothing*/
#endif #endif
int pperror(const char *s, ...) __attribute__((format (printf, 1, 2))); int ppy_error(const char *s, ...) __attribute__((format (printf, 1, 2)));
int ppwarning(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))); void pp_internal_error(const char *file, int line, const char *s, ...) __attribute__((format (printf, 3, 4)));
/* current preprocessor state */ /* current preprocessor state */
@ -239,11 +239,11 @@ extern includelogicentry_t *pp_includelogiclist;
/* /*
* From ppl.l * From ppl.l
*/ */
extern FILE *ppin; extern FILE *ppy_in;
extern FILE *ppout; extern FILE *ppy_out;
extern char *pptext; extern char *ppy_text;
extern int pp_flex_debug; extern int pp_flex_debug;
int pplex(void); int ppy_lex(void);
void pp_do_include(char *fname, int type); void pp_do_include(char *fname, int type);
void pp_push_ignore_state(void); void pp_push_ignore_state(void);
@ -253,7 +253,7 @@ void pp_pop_ignore_state(void);
/* /*
* From ppy.y * From ppy.y
*/ */
int ppparse(void); int ppy_parse(void);
extern int ppdebug; extern int ppy_debug;
#endif /* __WINE_WPP_PRIVATE_H */ #endif /* __WINE_WPP_PRIVATE_H */