From 66cc9da65ae9c04ea21ad972db6a5ff289091958 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Branimir=20Karad=C5=BEi=C4=87?= Date: Tue, 24 Apr 2018 20:07:38 -0700 Subject: [PATCH] Updated fcpp. --- 3rdparty/fcpp/cpp.h | 26 +-- 3rdparty/fcpp/cpp1.c | 186 +++++++++--------- 3rdparty/fcpp/cpp2.c | 212 ++++++++++----------- 3rdparty/fcpp/cpp3.c | 97 +++++----- 3rdparty/fcpp/cpp4.c | 214 ++++++++++----------- 3rdparty/fcpp/cpp5.c | 214 ++++++++++----------- 3rdparty/fcpp/cpp6.c | 387 +++++++++++++++++++------------------- 3rdparty/fcpp/cppadd.h | 124 ++++++------ 3rdparty/fcpp/cppdef.h | 58 +++--- 3rdparty/fcpp/fpp.h | 66 ++++--- 3rdparty/fcpp/usecpp.c | 42 ++--- tools/shaderc/shaderc.cpp | 2 +- 12 files changed, 832 insertions(+), 796 deletions(-) diff --git a/3rdparty/fcpp/cpp.h b/3rdparty/fcpp/cpp.h index c8084af7e..b9205bb61 100644 --- a/3rdparty/fcpp/cpp.h +++ b/3rdparty/fcpp/cpp.h @@ -35,16 +35,16 @@ #include #include -#ifndef toupper -#define toupper(c) ((c) + ('A' - 'a')) -#endif /* no toupper */ -#ifndef tolower -#define tolower(c) ((c) + ('a' - 'A')) -#endif /* no tolower */ +#ifndef fpp_toupper +#define fpp_toupper(c) ((c) + ('A' - 'a')) +#endif /* no fpp_toupper */ +#ifndef fpp_tolower +#define fpp_tolower(c) ((c) + ('a' - 'A')) +#endif /* no fpp_tolower */ -#ifndef TRUE -#define TRUE 1 -#define FALSE 0 +#ifndef FPP_TRUE +#define FPP_TRUE 1 +#define FPP_FALSE 0 #endif #ifndef EOS /* @@ -52,7 +52,7 @@ */ #define EOS '\0' /* End of string */ #endif -#define EOF_CHAR 0 /* Returned by get() on eof */ +#define EOF_CHAR 0 /* Returned by fpp_get() on eof */ #define NULLST ((char *) NULL) /* Pointer to nowhere (linted) */ #define DEF_NOARGS (-1) /* #define foo vs #define foo() */ @@ -139,9 +139,9 @@ /* * These bits are set in ifstack[] */ -#define WAS_COMPILING 1 /* TRUE if compile set at entry */ -#define ELSE_SEEN 2 /* TRUE when #else processed */ -#define TRUE_SEEN 4 /* TRUE when #if TRUE processed */ +#define WAS_COMPILING 1 /* FPP_TRUE if compile set at entry */ +#define ELSE_SEEN 2 /* FPP_TRUE when #else processed */ +#define FPP_TRUE_SEEN 4 /* FPP_TRUE when #if FPP_TRUE processed */ /* * Define bits for the basic types and their adjectives diff --git a/3rdparty/fcpp/cpp1.c b/3rdparty/fcpp/cpp1.c index 7f19b9a08..e23e8e570 100644 --- a/3rdparty/fcpp/cpp1.c +++ b/3rdparty/fcpp/cpp1.c @@ -34,9 +34,9 @@ void __stdargs _XCEXIT(long a) { return; } #endif #endif -FILE_LOCAL ReturnCode output(struct Global *, int); /* Output one character */ -FILE_LOCAL void sharp(struct Global *); -INLINE FILE_LOCAL ReturnCode cppmain(struct Global *); +FILE_LOCAL ReturnCode fpp_output(struct Global *, int); /* Output one character */ +FILE_LOCAL void fpp_sharp(struct Global *); +INLINE FILE_LOCAL ReturnCode fpp_cppmain(struct Global *); int fppPreProcess(struct fppTag *tags) { @@ -56,17 +56,17 @@ int fppPreProcess(struct fppTag *tags) global->wrongline=0; global->errors=0; global->recursion=0; - global->rec_recover=TRUE; - global->instring=FALSE; - global->inmacro=FALSE; + global->rec_recover=FPP_TRUE; + global->instring=FPP_FALSE; + global->inmacro=FPP_FALSE; global->workp=NULL; - global->keepcomments = FALSE; /* Write out comments flag */ - global->cflag = FALSE; /* -C option (keep comments) */ - global->eflag = FALSE; /* -E option (never fail) */ + global->keepcomments = FPP_FALSE; /* Write out comments flag */ + global->cflag = FPP_FALSE; /* -C option (keep comments) */ + global->eflag = FPP_FALSE; /* -E option (never fail) */ global->nflag = 0; /* -N option (no predefines) */ - global->wflag = FALSE; /* -W option (write #defines) */ + global->wflag = FPP_FALSE; /* -W option (write #defines) */ - global->ifstack[0]=TRUE; /* #if information */ + global->ifstack[0]=FPP_TRUE; /* #if information */ global->ifptr = global->ifstack; global->incend = global->incdir; @@ -107,45 +107,46 @@ int fppPreProcess(struct fppTag *tags) global->first_file=NULL; global->userdata=NULL; - global->linelines=TRUE; - global->warnillegalcpp = FALSE; - global->outputLINE = TRUE; - global->warnnoinclude = TRUE; - global->showversion = TRUE; - global->showincluded = FALSE; - global->showspace = FALSE; - global->nestcomments = FALSE; - global->warnnestcomments = FALSE; - global->outputfile = TRUE; + global->linelines=FPP_TRUE; + global->warnillegalcpp = FPP_FALSE; + global->outputLINE = FPP_TRUE; + global->warnnoinclude = FPP_TRUE; + global->showversion = FPP_TRUE; + global->showincluded = FPP_FALSE; + global->showspace = FPP_FALSE; + global->nestcomments = FPP_FALSE; + global->warnnestcomments = FPP_FALSE; + global->outputfile = FPP_TRUE; global->included = 0; - global->comment = FALSE; - global->rightconcat = FALSE; + global->comment = FPP_FALSE; + global->rightconcat = FPP_FALSE; global->work[0] = '\0'; global->initialfunc = NULL; + global->allowincludelocal = FPP_TRUE; memset(global->symtab, 0, SBSIZE * sizeof(DEFBUF *)); - ret=initdefines(global); /* O.S. specific def's */ + ret=fpp_initdefines(global); /* O.S. specific def's */ if(ret) return(ret); - dooptions(global, tags); /* Command line -flags */ - ret=addfile(global, stdin, global->work); /* "open" main input file */ + fpp_dooptions(global, tags); /* Command line -flags */ + ret=fpp_addfile(global, stdin, global->work); /* "open" main input file */ global->out = global->outputfile; if(!ret) - ret=cppmain(global); /* Process main file */ + ret=fpp_cppmain(global); /* Process main file */ if ((i = (global->ifptr - global->ifstack)) != 0) { #if OLD_PREPROCESSOR - cwarn(global, ERROR_IFDEF_DEPTH, i); + fpp_cwarn(global, ERROR_IFDEF_DEPTH, i); #else - cerror(global, ERROR_IFDEF_DEPTH, i); + fpp_cerror(global, ERROR_IFDEF_DEPTH, i); #endif } fflush(stdout); // BK - fclose(stdout); - delalldefines(global); + fpp_delalldefines(global); retVal = IO_NORMAL; if (global->errors > 0 && !global->eflag) @@ -158,7 +159,7 @@ int fppPreProcess(struct fppTag *tags) } INLINE FILE_LOCAL -ReturnCode cppmain(struct Global *global) +ReturnCode fpp_cppmain(struct Global *global) { /* * Main process for cpp -- copies tokens from the current input @@ -182,7 +183,7 @@ ReturnCode cppmain(struct Global *global) char define = 0; /* probability of a function define phase in the program */ char prev = 0; /* previous type */ char go = 0; - char include = 0; + unsigned include = 0; char initfunc = 0; /* Initialize for reading tokens */ @@ -203,7 +204,7 @@ ReturnCode cppmain(struct Global *global) } if(global->showversion) - Error(global, VERSION_TEXT); + fpp_Error(global, VERSION_TEXT); /* * Explicitly output a #line at the start of cpp output so @@ -212,10 +213,10 @@ ReturnCode cppmain(struct Global *global) * the name of the first #include file instead. */ if(global->linelines) /* if #line lines are wanted! */ - sharp(global); + fpp_sharp(global); /* * This loop is started "from the top" at the beginning of each line - * wrongline is set TRUE in many places if it is necessary to write + * wrongline is set FPP_TRUE in many places if it is necessary to write * a #line record. (But we don't write them when expanding macros.) * * The counter variable has two different uses: at @@ -231,15 +232,15 @@ ReturnCode cppmain(struct Global *global) include = global->included; while(include--) { - openinclude(global, global->include[(unsigned)include], TRUE); + fpp_openinclude(global, global->include[(unsigned)include], FPP_TRUE); } for (;;) { counter = 0; /* Count empty lines */ for (;;) { /* For each line, ... */ - global->comment = FALSE; /* No comment yet! */ + global->comment = FPP_FALSE; /* No comment yet! */ global->chpos = 0; /* Count whitespaces */ - while (type[(c = get(global))] == SPA) /* Skip leading blanks */ + while (type[(c = fpp_get(global))] == SPA) /* Skip leading blanks */ if(global->showspace) { if(global->chposcomment) { /* A comment was output! */ - Putchar(global, '\n'); + fpp_Putchar(global, '\n'); } else ++counter; /* Do nothing now */ } else if (c == '#') { /* Is 1st non-space '#' */ - global->keepcomments = FALSE; /* Don't pass comments */ - ret = control(global, &counter); /* Yes, do a #command */ + global->keepcomments = FPP_FALSE; /* Don't pass comments */ + ret = fpp_control(global, &counter); /* Yes, do a #command */ if(ret) return(ret); global->keepcomments = (global->cflag && compiling); @@ -263,7 +264,7 @@ ReturnCode cppmain(struct Global *global) else if (c == EOF_CHAR) /* At end of file? */ break; else if (!compiling) { /* #ifdef false? */ - skipnl(global); /* Skip to newline */ + fpp_skipnl(global); /* Skip to newline */ counter++; /* Count it, too. */ } else { break; /* Actual token */ @@ -278,25 +279,25 @@ ReturnCode cppmain(struct Global *global) */ if(global->linelines) { /* if #line lines are wanted! */ if ((global->wrongline && global->infile->fp != NULL) || counter > 4) - sharp(global); /* Output # line number */ + fpp_sharp(global); /* Output # line number */ else { /* If just a few, stuff */ while (--counter >= 0) /* them out ourselves */ - Putchar(global, (int)'\n'); + fpp_Putchar(global, (int)'\n'); } } if(global->showspace) { /* Show all whitespaces! */ global->spacebuf[global->chpos] = '\0'; - Putstring(global, global->spacebuf); + fpp_Putstring(global, global->spacebuf); } /* * Process each token on this line. */ - unget(global); /* Reread the char. */ + fpp_unget(global); /* Reread the char. */ for (;;) { /* For the whole line, */ do { /* Token concat. loop */ - for (global->chpos = counter = 0; type[(c = get(global))] == SPA;) { + for (global->chpos = counter = 0; (type[(c = fpp_get(global))] == SPA);) { #if COMMENT_INVISIBLE if (c != COM_SEP) counter++; @@ -311,15 +312,15 @@ ReturnCode cppmain(struct Global *global) break; /* Exit line loop */ else if (counter > 0) { /* If we got any spaces */ if(!global->showspace) /* We don't output all spaces */ - Putchar(global, (int)' ');/* Output one space */ + fpp_Putchar(global, (int)' ');/* Output one space */ else { global->spacebuf[global->chpos] = '\0'; - Putstring(global, global->spacebuf); /* Output all whitespaces */ + fpp_Putstring(global, global->spacebuf); /* Output all whitespaces */ } } - if((ret=macroid(global, &c))) /* Grab the token */ + if((ret=fpp_macroid(global, &c))) /* Grab the token */ return(ret); - } while (type[c] == LET && catenate(global, &ret) && !ret); + } while (type[c] == LET && fpp_catenate(global, 0, &ret) && !ret); if(ret) /* If the loop was broken because of a fatal error! */ return(ret); @@ -330,7 +331,7 @@ ReturnCode cppmain(struct Global *global) case LET: go =0; /* Quite ordinary token */ - Putstring(global, global->tokenbuf); + fpp_Putstring(global, global->tokenbuf); if(!define) { /* Copy the name */ @@ -342,7 +343,10 @@ ReturnCode cppmain(struct Global *global) case DIG: /* Output a number */ case DOT: /* Dot may begin floats */ go = 0; - ret=scannumber(global, c, (ReturnCode(*)(struct Global *, int))output); + ret=fpp_scannumber(global, c, (ReturnCode(*)(struct Global *, int))fpp_output); + if(ret) + return(ret); + fpp_catenate(global, 1, &ret); /* Check to see if the number is the lhs of a macro concat */ if(ret) return(ret); break; @@ -350,8 +354,8 @@ ReturnCode cppmain(struct Global *global) go = 0; /* Copy it to output */ if(!global->webmode) { - ret=scanstring(global, c, - (ReturnCode(*)(struct Global *, int))output); + ret=fpp_scanstring(global, c, + (ReturnCode(*)(struct Global *, int))fpp_output); if(ret) return(ret); break; @@ -375,7 +379,7 @@ ReturnCode cppmain(struct Global *global) /* * Output the discovered function name to stderr! */ - Error(global, "#> Function defined at line %d: %s <#\n", + fpp_Error(global, "#> Function defined at line %d: %s <#\n", global->line, global->functionname); } @@ -389,9 +393,9 @@ ReturnCode cppmain(struct Global *global) break; } if(a==global->excluded) { - expstuff(global, "__brace__", "{"); - expstuff(global, "__init_func__", global->initialfunc); - initfunc = TRUE; + fpp_expstuff(global, "__brace__", "{"); + fpp_expstuff(global, "__init_func__", global->initialfunc); + initfunc = FPP_TRUE; } } @@ -407,7 +411,7 @@ ReturnCode cppmain(struct Global *global) define = 1; if(initfunc) { - Putchar(global, '}'); + fpp_Putchar(global, '}'); bracelevel--; initfunc=0; } @@ -469,57 +473,57 @@ ReturnCode cppmain(struct Global *global) } define--; /* decrease function probability */ - Putchar(global, c); /* Just output it */ + fpp_Putchar(global, c); /* Just output it */ break; } /* Switch ends */ prev = type[c]; } /* Line for loop */ if (c == '\n') { /* Compiling at EOL? */ - Putchar(global, '\n'); /* Output newline, if */ + fpp_Putchar(global, '\n'); /* Output newline, if */ if (global->infile->fp == NULL) /* Expanding a macro, */ - global->wrongline = TRUE; /* Output # line later */ + global->wrongline = FPP_TRUE; /* Output # line later */ } } /* Continue until EOF */ if(global->showbalance) { if(bracketlevel) { - cwarn(global, WARN_BRACKET_DEPTH, bracketlevel); + fpp_cwarn(global, WARN_BRACKET_DEPTH, bracketlevel); } if(parenlevel) { - cwarn(global, WARN_PAREN_DEPTH, parenlevel); + fpp_cwarn(global, WARN_PAREN_DEPTH, parenlevel); } if(bracelevel) { - cwarn(global, WARN_BRACE_DEPTH, bracelevel); + fpp_cwarn(global, WARN_BRACE_DEPTH, bracelevel); } } if (global->wflag) { - global->out = TRUE; /* enable output */ - outdefines(global); /* Write out #defines */ + global->out = FPP_TRUE; /* enable fpp_output */ + fpp_outdefines(global); /* Write out #defines */ } return(FPP_OK); } FILE_LOCAL -ReturnCode output(struct Global *global, int c) +ReturnCode fpp_output(struct Global *global, int c) { /* - * Output one character to stdout -- output() is passed as an - * argument to scanstring() + * Output one character to stdout -- fpp_output() is passed as an + * argument to fpp_scanstring() */ #if COMMENT_INVISIBLE if (c != TOK_SEP && c != COM_SEP) #else if (c != TOK_SEP) #endif - Putchar(global, c); + fpp_Putchar(global, c); return(FPP_OK); } -void Putchar(struct Global *global, int c) +void fpp_Putchar(struct Global *global, int c) { /* - * Output one character to stdout or to output function! + * Output one character to stdout or to fpp_output function! */ if(!global->out) return; @@ -533,20 +537,20 @@ void Putchar(struct Global *global, int c) #endif } -void Putstring(struct Global *global, char *string) +void fpp_Putstring(struct Global *global, char *string) { /* - * Output a string! One letter at a time to the Putchar routine! + * Output a string! One letter at a time to the fpp_Putchar routine! */ if(!string) return; while(*string) - Putchar(global, *string++); + fpp_Putchar(global, *string++); } -void Putint(struct Global *global, int number) +void fpp_Putint(struct Global *global, int number) { /* * Output the number as a string. @@ -558,12 +562,12 @@ void Putint(struct Global *global, int number) sprintf(buffer, "%d", number); while(*point) - Putchar(global, *point++); + fpp_Putchar(global, *point++); } FILE_LOCAL -void sharp(struct Global *global) +void fpp_sharp(struct Global *global) { /* * Output a line number line. @@ -571,14 +575,14 @@ void sharp(struct Global *global) char *name; if (global->keepcomments) /* Make sure # comes on */ - Putchar(global, '\n'); /* a fresh, new line. */ + fpp_Putchar(global, '\n'); /* a fresh, new line. */ /* printf("#%s %d", LINE_PREFIX, global->line); */ - Putchar(global, '#'); + fpp_Putchar(global, '#'); if(global->outputLINE) - Putstring(global, LINE_PREFIX); - Putchar(global, ' '); - Putint(global, global->line); + fpp_Putstring(global, LINE_PREFIX); + fpp_Putchar(global, ' '); + fpp_Putint(global, global->line); if (global->infile->fp != NULL) { name = (global->infile->progname != NULL) @@ -587,14 +591,14 @@ void sharp(struct Global *global) || (global->sharpfilename != NULL && !streq(name, global->sharpfilename))) { if (global->sharpfilename != NULL) free(global->sharpfilename); - global->sharpfilename = savestring(global, name); + global->sharpfilename = fpp_savestring(global, name); /* printf(" \"%s\"", name); */ - Putstring(global, " \""); - Putstring(global, name); - Putchar(global, '\"'); + fpp_Putstring(global, " \""); + fpp_Putstring(global, name); + fpp_Putchar(global, '\"'); } } - Putchar(global, '\n'); - global->wrongline = FALSE; + fpp_Putchar(global, '\n'); + global->wrongline = FPP_FALSE; return; } diff --git a/3rdparty/fcpp/cpp2.c b/3rdparty/fcpp/cpp2.c index 07597ee64..7e53180ca 100644 --- a/3rdparty/fcpp/cpp2.c +++ b/3rdparty/fcpp/cpp2.c @@ -28,10 +28,10 @@ SOFTWARE. #include #endif -FILE_LOCAL void dump_line(struct Global *, int *); -FILE_LOCAL ReturnCode doif(struct Global *, int); -INLINE FILE_LOCAL ReturnCode doinclude(struct Global *); -INLINE FILE_LOCAL int hasdirectory(char *, char *); +FILE_LOCAL void fpp_dump_line(struct Global *, int *); +FILE_LOCAL ReturnCode fpp_doif(struct Global *, int); +INLINE FILE_LOCAL ReturnCode fpp_doinclude(struct Global *); +INLINE FILE_LOCAL int fpp_hasdirectory(char *, char *); /* @@ -55,7 +55,7 @@ INLINE FILE_LOCAL int hasdirectory(char *, char *); #define L_pragma ('p' + ('a' << 1)) #define L_undef ('u' + ('d' << 1)) -ReturnCode control( struct Global *global, +ReturnCode fpp_control( struct Global *global, int *counter ) /* Pending newline counter */ { /* @@ -73,7 +73,7 @@ ReturnCode control( struct Global *global, char *ep; ReturnCode ret; - c = skipws( global ); + c = fpp_skipws( global ); if( c == '\n' || c == EOF_CHAR ) { @@ -83,10 +83,10 @@ ReturnCode control( struct Global *global, } if( !isdigit(c) ) - scanid( global, c ); /* Get #word to tokenbuf */ + fpp_scanid( global, c ); /* Get #word to tokenbuf */ else { - unget( global ); /* Hack -- allow #123 as a */ + fpp_unget( global ); /* Hack -- allow #123 as a */ strcpy( global->tokenbuf, "line" ); /* synonym for #line 123 */ } @@ -149,7 +149,7 @@ ReturnCode control( struct Global *global, * control keyword (or L_nogood if we think it's nonsense). */ if( global->infile->fp == NULL ) - cwarn( global, WARN_CONTROL_LINE_IN_MACRO, global->tokenbuf ); + fpp_cwarn( global, WARN_CONTROL_LINE_IN_MACRO, global->tokenbuf ); if( !compiling ) { /* Not compiling now */ @@ -160,7 +160,7 @@ ReturnCode control( struct Global *global, case L_ifndef: /* we must nest #if's */ if( ++global->ifptr >= &global->ifstack[BLK_NEST] ) { - cfatal( global, FATAL_TOO_MANY_NESTINGS, global->tokenbuf ); + fpp_cfatal( global, FATAL_TOO_MANY_NESTINGS, global->tokenbuf ); return( FPP_TOO_MANY_NESTED_STATEMENTS ); } @@ -177,7 +177,7 @@ ReturnCode control( struct Global *global, case L_undef: /* aren't */ case L_assert: /* compiling. */ case L_error: - dump_line( global, counter ); /* Ignore rest of line */ + fpp_dump_line( global, counter ); /* Ignore rest of line */ return(FPP_OK); } } @@ -186,7 +186,7 @@ ReturnCode control( struct Global *global, */ if( *counter > 0 && (hash == L_line || hash == L_pragma) ) { - Putchar( global, '\n' ); + fpp_Putchar( global, '\n' ); (*counter)--; } @@ -199,21 +199,21 @@ ReturnCode control( struct Global *global, * field and line number for the next input line. * Set wrongline to force it out later. */ - c = skipws( global ); + c = fpp_skipws( global ); global->workp = global->work; /* Save name in work */ while( c != '\n' && c != EOF_CHAR ) { - if( (ret = save( global, c )) ) + if( (ret = fpp_save( global, c )) ) return(ret); - c = get( global ); + c = fpp_get( global ); } - unget( global ); + fpp_unget( global ); - if( (ret = save( global, EOS )) ) + if( (ret = fpp_save( global, EOS )) ) return(ret); /* @@ -240,42 +240,42 @@ ReturnCode control( struct Global *global, /* Give up the old name if it's allocated. */ free( global->infile->progname ); - global->infile->progname = savestring( global, tp ); + global->infile->progname = fpp_savestring( global, tp ); } - global->wrongline = TRUE; /* Force output later */ + global->wrongline = FPP_TRUE; /* Force output later */ break; case L_include: - ret = doinclude( global ); + ret = fpp_doinclude( global ); if( ret ) return(ret); break; case L_define: - ret = dodefine( global ); + ret = fpp_dodefine( global ); if( ret ) return(ret); break; case L_undef: - doundef( global ); + fpp_doundef( global ); break; case L_else: if( global->ifptr == &global->ifstack[0] ) { - cerror( global, ERROR_STRING_MUST_BE_IF, global->tokenbuf ); + fpp_cerror( global, ERROR_STRING_MUST_BE_IF, global->tokenbuf ); - dump_line( global, counter ); + fpp_dump_line( global, counter ); return( FPP_OK ); } else if( (*global->ifptr & ELSE_SEEN) != 0 ) { - cerror( global, ERROR_STRING_MAY_NOT_FOLLOW_ELSE, global->tokenbuf ); + fpp_cerror( global, ERROR_STRING_MAY_NOT_FOLLOW_ELSE, global->tokenbuf ); - dump_line( global, counter ); + fpp_dump_line( global, counter ); return( FPP_OK ); } @@ -284,11 +284,11 @@ ReturnCode control( struct Global *global, if( (*global->ifptr & WAS_COMPILING) != 0 ) { - if( compiling || (*global->ifptr & TRUE_SEEN) != 0 ) - compiling = FALSE; + if( compiling || (*global->ifptr & FPP_TRUE_SEEN) != 0 ) + compiling = FPP_FALSE; else { - compiling = TRUE; + compiling = FPP_TRUE; } } break; @@ -296,31 +296,31 @@ ReturnCode control( struct Global *global, case L_elif: if( global->ifptr == &global->ifstack[0] ) { - cerror( global, ERROR_STRING_MUST_BE_IF, global->tokenbuf ); + fpp_cerror( global, ERROR_STRING_MUST_BE_IF, global->tokenbuf ); - dump_line( global, counter ); + fpp_dump_line( global, counter ); return( FPP_OK ); } else if( (*global->ifptr & ELSE_SEEN) != 0 ) { - cerror( global, ERROR_STRING_MAY_NOT_FOLLOW_ELSE, global->tokenbuf ); + fpp_cerror( global, ERROR_STRING_MAY_NOT_FOLLOW_ELSE, global->tokenbuf ); - dump_line( global, counter ); + fpp_dump_line( global, counter ); return( FPP_OK ); } - if( (*global->ifptr & (WAS_COMPILING | TRUE_SEEN)) != WAS_COMPILING ) + if( (*global->ifptr & (WAS_COMPILING | FPP_TRUE_SEEN)) != WAS_COMPILING ) { - compiling = FALSE; /* Done compiling stuff */ + compiling = FPP_FALSE; /* Done compiling stuff */ - dump_line( global, counter ); /* Skip this clause */ + fpp_dump_line( global, counter ); /* Skip this clause */ return( FPP_OK ); } - ret = doif( global, L_if ); + ret = fpp_doif( global, L_if ); if( ret ) return(ret); @@ -328,7 +328,7 @@ ReturnCode control( struct Global *global, break; case L_error: - cerror(global, ERROR_ERROR); + fpp_cerror(global, ERROR_ERROR); break; case L_if: @@ -338,7 +338,7 @@ ReturnCode control( struct Global *global, { *global->ifptr = WAS_COMPILING; - ret = doif( global, hash ); + ret = fpp_doif( global, hash ); if( ret ) return(ret); @@ -346,22 +346,22 @@ ReturnCode control( struct Global *global, break; } - cfatal( global, FATAL_TOO_MANY_NESTINGS, global->tokenbuf ); + fpp_cfatal( global, FATAL_TOO_MANY_NESTINGS, global->tokenbuf ); return( FPP_TOO_MANY_NESTED_STATEMENTS ); case L_endif: if( global->ifptr == &global->ifstack[0] ) { - cerror( global, ERROR_STRING_MUST_BE_IF, global->tokenbuf ); + fpp_cerror( global, ERROR_STRING_MUST_BE_IF, global->tokenbuf ); - dump_line( global, counter ); + fpp_dump_line( global, counter ); return(FPP_OK); } if( !compiling && (*global->ifptr & WAS_COMPILING) != 0 ) - global->wrongline = TRUE; + global->wrongline = FPP_TRUE; compiling = ((*global->ifptr & WAS_COMPILING) != 0); @@ -373,13 +373,13 @@ ReturnCode control( struct Global *global, { int result; - ret = eval( global, &result ); + ret = fpp_eval( global, &result ); if(ret) return(ret); if( result == 0 ) - cerror( global, ERROR_PREPROC_FAILURE ); + fpp_cerror( global, ERROR_PREPROC_FAILURE ); } break; @@ -388,14 +388,14 @@ ReturnCode control( struct Global *global, * #pragma is provided to pass "options" to later * passes of the compiler. cpp doesn't have any yet. */ - Putstring( global, "#pragma " ); + fpp_Putstring( global, "#pragma " ); - while( (c = get( global ) ) != '\n' && c != EOF_CHAR ) - Putchar( global, c ); + while( (c = fpp_get( global ) ) != '\n' && c != EOF_CHAR ) + fpp_Putchar( global, c ); - unget( global ); + fpp_unget( global ); - Putchar( global, '\n' ); + fpp_Putchar( global, '\n' ); break; @@ -407,18 +407,18 @@ ReturnCode control( struct Global *global, * This would allow #asm or similar extensions. */ if( global->warnillegalcpp ) - cwarn( global, WARN_ILLEGAL_COMMAND, global->tokenbuf ); + fpp_cwarn( global, WARN_ILLEGAL_COMMAND, global->tokenbuf ); - Putchar( global, '#' ); - Putstring( global, global->tokenbuf ); - Putchar( global, ' ' ); + fpp_Putchar( global, '#' ); + fpp_Putstring( global, global->tokenbuf ); + fpp_Putchar( global, ' ' ); - while( (c = get( global ) ) != '\n' && c != EOF_CHAR ) - Putchar( global, c ); + while( (c = fpp_get( global ) ) != '\n' && c != EOF_CHAR ) + fpp_Putchar( global, c ); - unget( global ); + fpp_unget( global ); - Putchar( global, '\n' ); + fpp_Putchar( global, '\n' ); break; } @@ -431,15 +431,15 @@ ReturnCode control( struct Global *global, * #if foo * #endif foo */ - dump_line( global, counter ); /* Take common exit */ + fpp_dump_line( global, counter ); /* Take common exit */ return( FPP_OK ); #else - if( skipws( global ) != '\n' ) + if( fpp_skipws( global ) != '\n' ) { - cwarn( global, WARN_UNEXPECTED_TEXT_IGNORED ); + fpp_cwarn( global, WARN_UNEXPECTED_TEXT_IGNORED ); - skipnl( global ); + fpp_skipnl( global ); } #endif } @@ -450,21 +450,21 @@ ReturnCode control( struct Global *global, } FILE_LOCAL -void dump_line(struct Global *global, int *counter) +void fpp_dump_line(struct Global *global, int *counter) { - skipnl( global ); /* Ignore rest of line */ + fpp_skipnl( global ); /* Ignore rest of line */ (*counter)++; } FILE_LOCAL -ReturnCode doif(struct Global *global, int hash) +ReturnCode fpp_doif(struct Global *global, int hash) { /* * Process an #if, #ifdef, or #ifndef. The latter two are straightforward, * while #if needs a subroutine of its own to evaluate the expression. * - * doif() is called only if compiling is TRUE. If false, compilation + * fpp_doif() is called only if compiling is FPP_TRUE. If false, compilation * is always supressed, so we don't need to evaluate anything. This * supresses unnecessary warnings. */ @@ -473,16 +473,16 @@ ReturnCode doif(struct Global *global, int hash) int found; ReturnCode ret; - if( (c = skipws( global ) ) == '\n' || c == EOF_CHAR ) + if( (c = fpp_skipws( global ) ) == '\n' || c == EOF_CHAR ) { - unget( global ); + fpp_unget( global ); - cerror( global, ERROR_MISSING_ARGUMENT ); + fpp_cerror( global, ERROR_MISSING_ARGUMENT ); #if !OLD_PREPROCESSOR - skipnl( global ); /* Prevent an extra */ + fpp_skipnl( global ); /* Prevent an extra */ - unget( global ); /* Error message */ + fpp_unget( global ); /* Error message */ #endif return(FPP_OK); @@ -490,14 +490,14 @@ ReturnCode doif(struct Global *global, int hash) if( hash == L_if ) { - unget( global ); + fpp_unget( global ); - ret = eval( global, &found ); + ret = fpp_eval( global, &found ); if( ret ) return( ret ); - found = (found != 0); /* Evaluate expr, != 0 is TRUE */ + found = (found != 0); /* Evaluate expr, != 0 is FPP_TRUE */ hash = L_ifdef; /* #if is now like #ifdef */ } @@ -506,34 +506,34 @@ ReturnCode doif(struct Global *global, int hash) if( type[c] != LET ) { /* Next non-blank isn't letter */ /* ... is an error */ - cerror( global, ERROR_MISSING_ARGUMENT ); + fpp_cerror( global, ERROR_MISSING_ARGUMENT ); #if !OLD_PREPROCESSOR - skipnl( global ); /* Prevent an extra */ + fpp_skipnl( global ); /* Prevent an extra */ - unget( global ); /* Error message */ + fpp_unget( global ); /* Error message */ #endif return(FPP_OK); } - found = ( lookid( global, c ) != NULL ); /* Look for it in symbol table */ + found = ( fpp_lookid( global, c ) != NULL ); /* Look for it in symbol table */ } if( found == (hash == L_ifdef) ) { - compiling = TRUE; + compiling = FPP_TRUE; - *global->ifptr |= TRUE_SEEN; + *global->ifptr |= FPP_TRUE_SEEN; } else - compiling = FALSE; + compiling = FPP_FALSE; return(FPP_OK); } INLINE FILE_LOCAL -ReturnCode doinclude( struct Global *global ) +ReturnCode fpp_doinclude( struct Global *global ) { /* * Process the #include control line. @@ -557,14 +557,14 @@ ReturnCode doinclude( struct Global *global ) int delim; ReturnCode ret; - delim = skipws( global ); + delim = fpp_skipws( global ); - if( (ret = macroid( global, &delim )) ) + if( (ret = fpp_macroid( global, &delim )) ) return(ret); if( delim != '<' && delim != '"' ) { - cerror( global, ERROR_INCLUDE_SYNTAX ); + fpp_cerror( global, ERROR_INCLUDE_SYNTAX ); return( FPP_OK ); } @@ -574,11 +574,11 @@ ReturnCode doinclude( struct Global *global ) global->workp = global->work; - while( (c = get(global)) != '\n' && c != EOF_CHAR ) - if( (ret = save( global, c )) ) /* Put it away. */ + while( (c = fpp_get(global)) != '\n' && c != EOF_CHAR ) + if( (ret = fpp_save( global, c )) ) /* Put it away. */ return( ret ); - unget( global ); /* Force nl after include */ + fpp_unget( global ); /* Force nl after include */ /* * The draft is unclear if the following should be done. @@ -589,21 +589,21 @@ ReturnCode doinclude( struct Global *global ) if( *global->workp != delim ) { - cerror( global, ERROR_INCLUDE_SYNTAX ); + fpp_cerror( global, ERROR_INCLUDE_SYNTAX ); return(FPP_OK); } *global->workp = EOS; /* Terminate filename */ - ret = openinclude( global, global->work, (delim == '"') ); + ret = fpp_openinclude( global, global->work, (delim == '"') ); if( ret && global->warnnoinclude ) { /* * Warn if #include file isn't there. */ - cwarn( global, WARN_CANNOT_OPEN_INCLUDE, global->work ); + fpp_cwarn( global, WARN_CANNOT_OPEN_INCLUDE, global->work ); } return( FPP_OK ); @@ -613,13 +613,13 @@ ReturnCode doinclude( struct Global *global ) ReturnCode MultiAssignLoad( struct Global *global, char *incptr, char *filename, char *tmpname ); #endif -ReturnCode openinclude( struct Global *global, +ReturnCode fpp_openinclude( struct Global *global, char *filename, /* Input file name */ - int searchlocal ) /* TRUE if #include "file" */ + int searchlocal ) /* FPP_TRUE if #include "file" */ { /* * Actually open an include file. This routine is only called from - * doinclude() above, but was written as a separate subroutine for + * fpp_doinclude() above, but was written as a separate subroutine for * programmer convenience. It searches the list of directories * and actually opens the file, linking it into the list of * active files. Returns ReturnCode. No error message is printed. @@ -631,11 +631,11 @@ ReturnCode openinclude( struct Global *global, if( filename[0] == '/' ) { - if( ! openfile( global, filename ) ) + if( ! fpp_openfile( global, filename ) ) return(FPP_OK); } - if( searchlocal ) + if( searchlocal && global->allowincludelocal ) { /* * Look in local directory first. @@ -645,12 +645,12 @@ ReturnCode openinclude( struct Global *global, * discarding the last pathname component of the source file * name then tacking on the #include argument. */ - if( hasdirectory( global->infile->filename, tmpname ) ) + if( fpp_hasdirectory( global->infile->filename, tmpname ) ) strcat( tmpname, filename ); else strcpy( tmpname, filename ); - if( ! openfile( global, tmpname ) ) + if( ! fpp_openfile( global, tmpname ) ) return(FPP_OK); } @@ -664,7 +664,7 @@ ReturnCode openinclude( struct Global *global, if( len + strlen(filename) >= sizeof(tmpname) ) { - cfatal( global, FATAL_FILENAME_BUFFER_OVERFLOW ); + fpp_cfatal( global, FATAL_FILENAME_BUFFER_OVERFLOW ); return( FPP_FILENAME_BUFFER_OVERFLOW ); } @@ -675,7 +675,7 @@ ReturnCode openinclude( struct Global *global, else sprintf( tmpname, "%s%s", *incptr, filename ); - if( !openfile( global, tmpname ) ) + if( !fpp_openfile( global, tmpname ) ) return(FPP_OK); } } @@ -684,25 +684,25 @@ ReturnCode openinclude( struct Global *global, } INLINE FILE_LOCAL -int hasdirectory( char *source, /* Directory to examine */ +int fpp_hasdirectory( char *source, /* Directory to examine */ char *result ) /* Put directory stuff here */ { /* * If a device or directory is found in the source filename string, the * node/device/directory part of the string is copied to result and - * hasdirectory returns TRUE. Else, nothing is copied and it returns FALSE. + * fpp_hasdirectory returns FPP_TRUE. Else, nothing is copied and it returns FPP_FALSE. */ char *tp2; if( (tp2 = strrchr( source, '/' ) ) == NULL ) - return(FALSE); + return(FPP_FALSE); strncpy( result, source, tp2 - source + 1 ); result[tp2 - source + 1] = EOS; - return( TRUE ); + return( FPP_TRUE ); } #ifdef _AMIGA @@ -742,7 +742,7 @@ ReturnCode MultiAssignLoad( struct Global *global, char *incptr, char *filename, // Normally we would pass the lock and filename // to the Load() routine, which would CD to the // directory and Open(filename), but in order to - // satisfy the exisiting openfile() function, we + // satisfy the exisiting fpp_openfile() function, we // bite the bullet and build the complete pathspec // rather than add the standard Load() routine. // @@ -750,7 +750,7 @@ ReturnCode MultiAssignLoad( struct Global *global, char *incptr, char *filename, { AddPart( tmpname, filename, NWORK ); - RtnCode = openfile( global, tmpname ); + RtnCode = fpp_openfile( global, tmpname ); if( ! RtnCode ) break; diff --git a/3rdparty/fcpp/cpp3.c b/3rdparty/fcpp/cpp3.c index 245c7df91..b67d4a29b 100644 --- a/3rdparty/fcpp/cpp3.c +++ b/3rdparty/fcpp/cpp3.c @@ -25,20 +25,25 @@ SOFTWARE. #include "cppdef.h" #include "cpp.h" -ReturnCode openfile(struct Global *global, char *filename) +ReturnCode fpp_openfile(struct Global *global, char *filename) { /* * Open a file, add it to the linked list of open files. - * This is called only from openfile() in cpp2.c. + * This is called only from fpp_openfile() in cpp2.c. */ FILE *fp; ReturnCode ret; - if ((fp = fopen(filename, "r")) == NULL) + if (global->openfile) + fp = global->openfile(filename, "r", global->userdata); + else + fp = fopen(filename, "r"); + + if (fp == NULL) ret=FPP_OPEN_ERROR; else - ret=addfile(global, fp, filename); + ret=fpp_addfile(global, fp, filename); if(!ret && global->depends) { global->depends(filename, global->userdata); @@ -46,51 +51,51 @@ ReturnCode openfile(struct Global *global, char *filename) if(!ret && global->showincluded) { /* no error occured! */ - Error(global, "cpp: included \""); - Error(global, filename); - Error(global, "\"\n"); + fpp_Error(global, "cpp: included \""); + fpp_Error(global, filename); + fpp_Error(global, "\"\n"); } return(ret); } -ReturnCode addfile(struct Global *global, +ReturnCode fpp_addfile(struct Global *global, FILE *fp, /* Open file pointer */ char *filename) /* Name of the file */ { /* - * Initialize tables for this open file. This is called from openfile() + * Initialize tables for this open file. This is called from fpp_openfile() * above (for #include files), and from the entry to cpp to open the main - * input file. It calls a common routine, getfile() to build the FILEINFO - * structure which is used to read characters. (getfile() is also called + * input file. It calls a common routine, fpp_getfile() to build the FILEINFO + * structure which is used to read characters. (fpp_getfile() is also called * to setup a macro replacement.) */ FILEINFO *file; ReturnCode ret; - ret = getfile(global, NBUFF, filename, &file); + ret = fpp_getfile(global, NBUFF, filename, &file); if(ret) return(ret); file->fp = fp; /* Better remember FILE * */ file->buffer[0] = EOS; /* Initialize for first read */ global->line = 1; /* Working on line 1 now */ - global->wrongline = TRUE; /* Force out initial #line */ + global->wrongline = FPP_TRUE; /* Force out initial #line */ return(FPP_OK); } -int dooptions(struct Global *global, struct fppTag *tags) +int fpp_dooptions(struct Global *global, struct fppTag *tags) { /* - * dooptions is called to process command line arguments (-Detc). + * fpp_dooptions is called to process command line arguments (-Detc). * It is called only at cpp startup. */ DEFBUF *dp; - char end=FALSE; /* end of taglist */ + char end=FPP_FALSE; /* end of taglist */ while(tags && !end) { switch(tags->tag) { case FPPTAG_END: - end=TRUE; + end=FPP_TRUE; break; case FPPTAG_INITFUNC: global->initialfunc = (char *) tags->data; @@ -122,7 +127,7 @@ int dooptions(struct Global *global, struct fppTag *tags) case FPPTAG_OUTPUTINCLUDES: global->showincluded = tags->data?1:0; break; - case FPPTAG_IGNOREVERSION: + case FPPTAG_SHOWVERSION: global->showversion = tags->data?1:0; break; case FPPTAG_WARNILLEGALCPP: @@ -133,8 +138,8 @@ int dooptions(struct Global *global, struct fppTag *tags) break; case FPPTAG_KEEPCOMMENTS: if(tags->data) { - global->cflag = TRUE; - global->keepcomments = TRUE; + global->cflag = FPP_TRUE; + global->keepcomments = FPP_TRUE; } break; case FPPTAG_DEFINE: @@ -153,19 +158,19 @@ int dooptions(struct Global *global, struct fppTag *tags) /* * Now, save the word and its definition. */ - dp = defendel(global, symbol, FALSE); + dp = fpp_defendel(global, symbol, FPP_FALSE); if(!dp) return(FPP_OUT_OF_MEMORY); - dp->repl = savestring(global, text); + dp->repl = fpp_savestring(global, text); dp->nargs = DEF_NOARGS; } break; case FPPTAG_IGNORE_NONFATAL: - global->eflag = TRUE; + global->eflag = FPP_TRUE; break; case FPPTAG_INCLUDE_DIR: if (global->incend >= &global->incdir[NINCLUDE]) { - cfatal(global, FATAL_TOO_MANY_INCLUDE_DIRS); + fpp_cfatal(global, FATAL_TOO_MANY_INCLUDE_DIRS); return(FPP_TOO_MANY_INCLUDE_DIRS); } *global->incend++ = (char *)tags->data; @@ -173,7 +178,7 @@ int dooptions(struct Global *global, struct fppTag *tags) case FPPTAG_INCLUDE_FILE: case FPPTAG_INCLUDE_MACRO_FILE: if (global->included >= NINCLUDE) { - cfatal(global, FATAL_TOO_MANY_INCLUDE_FILES); + fpp_cfatal(global, FATAL_TOO_MANY_INCLUDE_FILES); return(FPP_TOO_MANY_INCLUDE_FILES); } global->include[(unsigned)global->included] = (char *)tags->data; @@ -196,7 +201,7 @@ int dooptions(struct Global *global, struct fppTag *tags) { SIZES *sizp; /* For -S */ int size; /* For -S */ - int isdatum; /* FALSE for -S* */ + int isdatum; /* FPP_FALSE for -S* */ int endtest; /* For -S */ char *text=(char *)tags->data; @@ -225,14 +230,14 @@ int dooptions(struct Global *global, struct fppTag *tags) sizp++; } if (sizp->bits != endtest) - cwarn(global, WARN_TOO_FEW_VALUES_TO_SIZEOF, NULL); + fpp_cwarn(global, WARN_TOO_FEW_VALUES_TO_SIZEOF, NULL); else if (*text != EOS) - cwarn(global, WARN_TOO_MANY_VALUES_TO_SIZEOF, NULL); + fpp_cwarn(global, WARN_TOO_MANY_VALUES_TO_SIZEOF, NULL); } break; case FPPTAG_UNDEFINE: - if (defendel(global, (char *)tags->data, TRUE) == NULL) - cwarn(global, WARN_NOT_DEFINED, tags->data); + if (fpp_defendel(global, (char *)tags->data, FPP_TRUE) == NULL) + fpp_cwarn(global, WARN_NOT_DEFINED, tags->data); break; case FPPTAG_OUTPUT_DEFINES: global->wflag++; @@ -265,8 +270,14 @@ int dooptions(struct Global *global, struct fppTag *tags) case FPPTAG_WEBMODE: global->webmode=(tags->data?1:0); break; + case FPPTAG_ALLOW_INCLUDE_LOCAL: + global->allowincludelocal=(tags->data?1:0); + break; + case FPPTAG_FILEOPENFUNC: +// global->openfile = (FILE* (*)(char *,char *))tags->data; + break; default: - cwarn(global, WARN_INTERNAL_ERROR, NULL); + fpp_cwarn(global, WARN_INTERNAL_ERROR, NULL); break; } tags++; @@ -274,7 +285,7 @@ int dooptions(struct Global *global, struct fppTag *tags) return(0); } -ReturnCode initdefines(struct Global *global) +ReturnCode fpp_initdefines(struct Global *global) { /* * Initialize the built-in #define's. There are two flavors: @@ -307,23 +318,23 @@ ReturnCode initdefines(struct Global *global) if (!(global->nflag & NFLAG_BUILTIN)) { for (pp = global->preset; *pp != NULL; pp++) { if (*pp[0] != EOS) { - dp = defendel(global, *pp, FALSE); + dp = fpp_defendel(global, *pp, FPP_FALSE); if(!dp) return(FPP_OUT_OF_MEMORY); - dp->repl = savestring(global, "1"); + dp->repl = fpp_savestring(global, "1"); dp->nargs = DEF_NOARGS; } } } /* * The magic pre-defines (__FILE__ and __LINE__ are - * initialized with negative argument counts. expand() + * initialized with negative argument counts. fpp_expand() * notices this and calls the appropriate routine. * DEF_NOARGS is one greater than the first "magic" definition. */ if (!(global->nflag & NFLAG_PREDEFINE)) { for (pp = global->magic, i = DEF_NOARGS; *pp != NULL; pp++) { - dp = defendel(global, *pp, FALSE); + dp = fpp_defendel(global, *pp, FPP_FALSE); if(!dp) return(FPP_OUT_OF_MEMORY); dp->nargs = --i; @@ -332,7 +343,7 @@ ReturnCode initdefines(struct Global *global) /* * Define __DATE__ as today's date. */ - dp = defendel(global, "__DATE__", FALSE); + dp = fpp_defendel(global, "__DATE__", FPP_FALSE); tp = malloc(14); if(!tp || !dp) return(FPP_OUT_OF_MEMORY); @@ -348,7 +359,7 @@ ReturnCode initdefines(struct Global *global) /* * Define __TIME__ as this moment's time. */ - dp = defendel(global, "__TIME__", FALSE); + dp = fpp_defendel(global, "__TIME__", FPP_FALSE); tp = malloc(11); if(!tp || !dp) return(FPP_OUT_OF_MEMORY); @@ -363,7 +374,7 @@ ReturnCode initdefines(struct Global *global) return(FPP_OK); } -void delbuiltindefines(struct Global *global) +void fpp_delbuiltindefines(struct Global *global) { /* * Delete the built-in #define's. @@ -376,25 +387,25 @@ void delbuiltindefines(struct Global *global) */ if (global->wflag < 2) { for (pp = global->preset; *pp != NULL; pp++) { - defendel(global, *pp, TRUE); + fpp_defendel(global, *pp, FPP_TRUE); } } /* * The magic pre-defines __FILE__ and __LINE__ */ for (pp = global->magic; *pp != NULL; pp++) { - defendel(global, *pp, TRUE); + fpp_defendel(global, *pp, FPP_TRUE); } #if OK_DATE /* * Undefine __DATE__. */ - defendel(global, "__DATE__", TRUE); + fpp_defendel(global, "__DATE__", FPP_TRUE); /* * Undefine __TIME__. */ - defendel(global, "__TIME__", TRUE); + fpp_defendel(global, "__TIME__", FPP_TRUE); #endif return; } diff --git a/3rdparty/fcpp/cpp4.c b/3rdparty/fcpp/cpp4.c index cfa871e6c..c644dddb6 100644 --- a/3rdparty/fcpp/cpp4.c +++ b/3rdparty/fcpp/cpp4.c @@ -24,15 +24,15 @@ SOFTWARE. #include "cppdef.h" #include "cpp.h" -INLINE FILE_LOCAL ReturnCode checkparm(struct Global *, int, DEFBUF *, int); -INLINE FILE_LOCAL ReturnCode stparmscan(struct Global *, int); -INLINE FILE_LOCAL ReturnCode textput(struct Global *, char *); -FILE_LOCAL ReturnCode charput(struct Global *, int); -INLINE FILE_LOCAL ReturnCode expcollect(struct Global *); -INLINE FILE_LOCAL char *doquoting(char *, char *); +INLINE FILE_LOCAL ReturnCode fpp_checkparm(struct Global *, int, DEFBUF *, int); +INLINE FILE_LOCAL ReturnCode fpp_stparmscan(struct Global *, int); +INLINE FILE_LOCAL ReturnCode fpp_textput(struct Global *, char *); +FILE_LOCAL ReturnCode fpp_charput(struct Global *, int); +INLINE FILE_LOCAL ReturnCode fpp_expcollect(struct Global *); +INLINE FILE_LOCAL char *fpp_doquoting(char *, char *); -ReturnCode dodefine(struct Global *global) +ReturnCode fpp_dodefine(struct Global *global) { /* * Called from control when a #define is scanned. This module @@ -61,63 +61,63 @@ ReturnCode dodefine(struct Global *global) * is not. * * The following subroutines are called from define(): - * checkparm called when a token is scanned. It checks through the + * fpp_checkparm called when a token is scanned. It checks through the * array of formal parameters. If a match is found, the * token is replaced by a control byte which will be used * to locate the parameter when the macro is expanded. - * textput puts a string in the macro work area (parm[]), updating + * fpp_textput puts a string in the macro work area (parm[]), updating * parmp to point to the first free byte in parm[]. - * textput() tests for work buffer overflow. - * charput puts a single character in the macro work area (parm[]) - * in a manner analogous to textput(). + * fpp_textput() tests for work buffer overflow. + * fpp_charput puts a single character in the macro work area (parm[]) + * in a manner analogous to fpp_textput(). */ int c; DEFBUF *dp; /* -> new definition */ - int isredefine; /* TRUE if redefined */ + int isredefine; /* FPP_TRUE if redefined */ char *old = NULL; /* Remember redefined */ ReturnCode ret; #if OK_CONCAT int quoting; /* Remember we saw a # */ #endif - if (type[(c = skipws(global))] != LET) { - cerror(global, ERROR_DEFINE_SYNTAX); - global->inmacro = FALSE; /* Stop hack */ + if (type[(c = fpp_skipws(global))] != LET) { + fpp_cerror(global, ERROR_DEFINE_SYNTAX); + global->inmacro = FPP_FALSE; /* Stop hack */ return(FPP_OK); } - isredefine = FALSE; /* Set if redefining */ - if ((dp = lookid(global, c)) == NULL) { /* If not known now */ - dp = defendel(global, global->tokenbuf, FALSE); /* Save the name */ + isredefine = FPP_FALSE; /* Set if redefining */ + if ((dp = fpp_lookid(global, c)) == NULL) { /* If not known now */ + dp = fpp_defendel(global, global->tokenbuf, FPP_FALSE); /* Save the name */ if(!dp) return(FPP_OUT_OF_MEMORY); } else { /* It's known: */ - isredefine = TRUE; /* Remember this fact */ + isredefine = FPP_TRUE; /* Remember this fact */ old = dp->repl; /* Remember replacement */ dp->repl = NULL; /* No replacement now */ } global->parlist[0] = global->parmp = global->parm; /* Setup parm buffer */ - if ((c = get(global)) == '(') { /* With arguments? */ + if ((c = fpp_get(global)) == '(') { /* With arguments? */ global->nargs = 0; /* Init formals counter */ do { /* Collect formal parms */ if (global->nargs >= LASTPARM) { - cfatal(global, FATAL_TOO_MANY_ARGUMENTS_MACRO); + fpp_cfatal(global, FATAL_TOO_MANY_ARGUMENTS_MACRO); return(FPP_TOO_MANY_ARGUMENTS); - } else if ((c = skipws(global)) == ')') + } else if ((c = fpp_skipws(global)) == ')') break; /* Got them all */ else if (type[c] != LET) { /* Bad formal syntax */ - cerror(global, ERROR_DEFINE_SYNTAX); - global->inmacro = FALSE; /* Stop hack */ + fpp_cerror(global, ERROR_DEFINE_SYNTAX); + global->inmacro = FPP_FALSE; /* Stop hack */ return(FPP_OK); } - scanid(global, c); /* Get the formal param */ + fpp_scanid(global, c); /* Get the formal param */ global->parlist[global->nargs++] = global->parmp; /* Save its start */ - ret=textput(global, global->tokenbuf); /* Save text in parm[] */ + ret=fpp_textput(global, global->tokenbuf); /* Save text in parm[] */ if(ret) return(ret); - } while ((c = skipws(global)) == ','); /* Get another argument */ + } while ((c = fpp_skipws(global)) == ','); /* Get another argument */ if (c != ')') { /* Must end at ) */ - cerror(global, ERROR_DEFINE_SYNTAX); - global->inmacro = FALSE; /* Stop hack */ + fpp_cerror(global, ERROR_DEFINE_SYNTAX); + global->inmacro = FPP_FALSE; /* Stop hack */ return(FPP_OK); } c = ' '; /* Will skip to body */ @@ -130,14 +130,14 @@ ReturnCode dodefine(struct Global *global) global->nargs = DEF_NOARGS; /* No () parameters */ } if (type[c] == SPA) /* At whitespace? */ - c = skipws(global); /* Not any more. */ + c = fpp_skipws(global); /* Not any more. */ global->workp = global->work; /* Replacement put here */ - global->inmacro = TRUE; /* Keep \ now */ + global->inmacro = FPP_TRUE; /* Keep \ now */ quoting = 0; /* No # seen yet. */ while (c != EOF_CHAR && c != '\n') { /* Compile macro body */ #if OK_CONCAT if (c == '#') { /* Token concatenation? */ - if ((c = get(global)) != '#') { /* No, not really */ + if ((c = fpp_get(global)) != '#') { /* No, not really */ quoting = 1; /* Maybe quoting op. */ continue; } @@ -145,16 +145,16 @@ ReturnCode dodefine(struct Global *global) --global->workp; /* Erase leading spaces */ // if ((ret=save(global, TOK_SEP))) /* Stuff a delimiter */ // return(ret); - c = skipws(global); /* Eat whitespace */ + c = fpp_skipws(global); /* Eat whitespace */ continue; } #endif switch (type[c]) { case LET: #if OK_CONCAT - ret=checkparm(global, c, dp, quoting); /* Might be a formal */ + ret=fpp_checkparm(global, c, dp, quoting); /* Might be a formal */ #else - ret=checkparm(c, dp); /* Might be a formal */ + ret=fpp_checkparm(c, dp); /* Might be a formal */ #endif if(ret) return(ret); @@ -162,24 +162,24 @@ ReturnCode dodefine(struct Global *global) case DIG: /* Number in mac. body */ case DOT: /* Maybe a float number */ - ret=scannumber(global, c, save); /* Scan it off */ + ret=fpp_scannumber(global, c, fpp_save); /* Scan it off */ if(ret) return(ret); break; case QUO: /* String in mac. body */ - ret=stparmscan(global, c); + ret=fpp_stparmscan(global, c); if(ret) return(ret); break; case BSH: /* Backslash */ - ret=save(global, '\\'); + ret=fpp_save(global, '\\'); if(ret) return(ret); - if ((c = get(global)) == '\n') - global->wrongline = TRUE; - ret=save(global, c); + if ((c = fpp_get(global)) == '\n') + global->wrongline = FPP_TRUE; + ret=fpp_save(global, c); if(ret) return(ret); break; @@ -195,27 +195,27 @@ ReturnCode dodefine(struct Global *global) c = ' '; /* Normalize tabs */ /* Fall through to store character */ default: /* Other character */ - ret=save(global, c); + ret=fpp_save(global, c); if(ret) return(ret); break; } - c = get(global); + c = fpp_get(global); quoting = 0; /* Only when immediately*/ /* preceding a formal */ } - global->inmacro = FALSE; /* Stop newline hack */ - unget(global); /* For control check */ + global->inmacro = FPP_FALSE; /* Stop newline hack */ + fpp_unget(global); /* For control check */ if (global->workp > global->work && global->workp[-1] == ' ') /* Drop trailing blank */ global->workp--; *global->workp = EOS; /* Terminate work */ - dp->repl = savestring(global, global->work); /* Save the string */ + dp->repl = fpp_savestring(global, global->work); /* Save the string */ dp->nargs = global->nargs; /* Save arg count */ if (isredefine) { /* Error if redefined */ if ((old != NULL && dp->repl != NULL && !streq(old, dp->repl)) || (old == NULL && dp->repl != NULL) || (old != NULL && dp->repl == NULL)) { - cerror(global, ERROR_REDEFINE, dp->name); + fpp_cerror(global, ERROR_REDEFINE, dp->name); } if (old != NULL) /* We don't need the */ free(old); /* old definition now. */ @@ -224,7 +224,7 @@ ReturnCode dodefine(struct Global *global) } INLINE FILE_LOCAL -ReturnCode checkparm(struct Global *global, +ReturnCode fpp_checkparm(struct Global *global, int c, DEFBUF *dp, int quoting) /* Preceded by a # ? */ @@ -233,7 +233,7 @@ ReturnCode checkparm(struct Global *global, * Replace this param if it's defined. Note that the macro name is a * possible replacement token. We stuff DEF_MAGIC in front of the token * which is treated as a LETTER by the token scanner and eaten by - * the output routine. This prevents the macro expander from + * the fpp_output routine. This prevents the macro expander from * looping if someone writes "#define foo foo". */ @@ -241,29 +241,29 @@ ReturnCode checkparm(struct Global *global, char *cp; ReturnCode ret=FPP_OK; - scanid(global, c); /* Get parm to tokenbuf */ + fpp_scanid(global, c); /* Get parm to tokenbuf */ for (i = 0; i < global->nargs; i++) { /* For each argument */ if (streq(global->parlist[i], global->tokenbuf)) { /* If it's known */ #if OK_CONCAT if (quoting) { /* Special handling of */ - ret=save(global, QUOTE_PARM); /* #formal inside defn */ + ret=fpp_save(global, QUOTE_PARM); /* #formal inside defn */ if(ret) return(ret); } #endif - ret=save(global, i + MAC_PARM); /* Save a magic cookie */ + ret=fpp_save(global, i + MAC_PARM); /* Save a magic cookie */ return(ret); /* And exit the search */ } } if (streq(dp->name, global->tokenbuf)) /* Macro name in body? */ - ret=save(global, DEF_MAGIC); /* Save magic marker */ - for (cp = global->tokenbuf; *cp != EOS;) /* And save */ - ret=save(global, *cp++); /* The token itself */ + ret=fpp_save(global, DEF_MAGIC); /* Save magic marker */ + for (cp = global->tokenbuf; *cp != EOS;) /* And fpp_save */ + ret=fpp_save(global, *cp++); /* The token itself */ return(ret); } INLINE FILE_LOCAL -ReturnCode stparmscan(struct Global *global, int delim) +ReturnCode fpp_stparmscan(struct Global *global, int delim) { /* * Normal string parameter scan. @@ -274,9 +274,9 @@ ReturnCode stparmscan(struct Global *global, int delim) ReturnCode ret; wp = (unsigned char *)global->workp; /* Here's where it starts */ - ret=scanstring(global, delim, save); + ret=fpp_scanstring(global, delim, fpp_save); if(ret) - return(ret); /* Exit on scanstring error */ + return(ret); /* Exit on fpp_scanstring error */ global->workp[-1] = EOS; /* Erase trailing quote */ wp++; /* -> first string content byte */ for (i = 0; i < global->nargs; i++) { @@ -292,23 +292,23 @@ ReturnCode stparmscan(struct Global *global, int delim) return(FPP_OK); } -void doundef(struct Global *global) +void fpp_doundef(struct Global *global) /* * Remove the symbol from the defined list. * Called from the #control processor. */ { int c; - if (type[(c = skipws(global))] != LET) - cerror(global, ERROR_ILLEGAL_UNDEF); + if (type[(c = fpp_skipws(global))] != LET) + fpp_cerror(global, ERROR_ILLEGAL_UNDEF); else { - scanid(global, c); /* Get name to tokenbuf */ - (void) defendel(global, global->tokenbuf, TRUE); + fpp_scanid(global, c); /* Get name to tokenbuf */ + (void) fpp_defendel(global, global->tokenbuf, FPP_TRUE); } } INLINE FILE_LOCAL -ReturnCode textput(struct Global *global, char *text) +ReturnCode fpp_textput(struct Global *global, char *text) { /* * Put the string in the parm[] buffer. @@ -318,7 +318,7 @@ ReturnCode textput(struct Global *global, char *text) size = strlen(text) + 1; if ((global->parmp + size) >= &global->parm[NPARMWORK]) { - cfatal(global, FATAL_MACRO_AREA_OVERFLOW); + fpp_cfatal(global, FATAL_MACRO_AREA_OVERFLOW); return(FPP_WORK_AREA_OVERFLOW); } else { strcpy(global->parmp, text); @@ -328,14 +328,14 @@ ReturnCode textput(struct Global *global, char *text) } FILE_LOCAL -ReturnCode charput(struct Global *global, int c) +ReturnCode fpp_charput(struct Global *global, int c) { /* * Put the byte in the parm[] buffer. */ if (global->parmp >= &global->parm[NPARMWORK]) { - cfatal(global, FATAL_MACRO_AREA_OVERFLOW); + fpp_cfatal(global, FATAL_MACRO_AREA_OVERFLOW); return(FPP_WORK_AREA_OVERFLOW); } *global->parmp++ = c; @@ -346,15 +346,15 @@ ReturnCode charput(struct Global *global, int c) * M a c r o E x p a n s i o n */ -ReturnCode expand(struct Global *global, DEFBUF *tokenp) +ReturnCode fpp_expand(struct Global *global, DEFBUF *tokenp) { /* * Expand a macro. Called from the cpp mainline routine (via subroutine - * macroid()) when a token is found in the symbol table. It calls - * expcollect() to parse actual parameters, checking for the correct number. + * fpp_macroid()) when a token is found in the symbol table. It calls + * fpp_expcollect() to parse actual parameters, checking for the correct number. * It then creates a "file" containing a single line containing the * macro with actual parameters inserted appropriately. This is - * "pushed back" onto the input stream. (When the get() routine runs + * "pushed back" onto the input stream. (When the fpp_get() routine runs * off the end of the macro line, it will dismiss the macro itself.) */ int c; @@ -368,12 +368,12 @@ ReturnCode expand(struct Global *global, DEFBUF *tokenp) if (global->recursion++ == 0) global->macro = tokenp; else if (global->recursion == RECURSION_LIMIT) { - cerror(global, ERROR_RECURSIVE_MACRO, tokenp->name, global->macro->name); + fpp_cerror(global, ERROR_RECURSIVE_MACRO, tokenp->name, global->macro->name); if (global->rec_recover) { do { - c = get(global); + c = fpp_get(global); } while (global->infile != NULL && global->infile->fp == NULL); - unget(global); + fpp_unget(global); global->recursion = 0; return(FPP_OK); } @@ -396,7 +396,7 @@ ReturnCode expand(struct Global *global, DEFBUF *tokenp) break; } } - ret=ungetstring(global, global->work); + ret=fpp_ungetstring(global, global->work); if(ret) return(ret); break; @@ -406,7 +406,7 @@ ReturnCode expand(struct Global *global, DEFBUF *tokenp) if (file->fp != NULL) { sprintf(global->work, "\"%s\"", (file->progname != NULL) ? file->progname : file->filename); - ret=ungetstring(global, global->work); + ret=fpp_ungetstring(global, global->work); if(ret) return(ret); break; @@ -417,14 +417,14 @@ ReturnCode expand(struct Global *global, DEFBUF *tokenp) case (-4): /* __FUNC__ */ sprintf(global->work, "\"%s\"", global->functionname[0]? global->functionname : ""); - ret=ungetstring(global, global->work); + ret=fpp_ungetstring(global, global->work); if(ret) return(ret); break; case (-5): /* __FUNC_LINE__ */ sprintf(global->work, "%d", global->funcline); - ret=ungetstring(global, global->work); + ret=fpp_ungetstring(global, global->work); if(ret) return(ret); break; @@ -434,11 +434,11 @@ ReturnCode expand(struct Global *global, DEFBUF *tokenp) * Nothing funny about this macro. */ if (tokenp->nargs < 0) { - cfatal(global, FATAL_ILLEGAL_MACRO, tokenp->name); + fpp_cfatal(global, FATAL_ILLEGAL_MACRO, tokenp->name); return(FPP_ILLEGAL_MACRO); } - while ((c = skipws(global)) == '\n') /* Look for (, skipping */ - global->wrongline = TRUE; /* spaces and newlines */ + while ((c = fpp_skipws(global)) == '\n') /* Look for (, skipping */ + global->wrongline = FPP_TRUE; /* spaces and newlines */ if (c != '(') { /* * If the programmer writes @@ -447,27 +447,27 @@ ReturnCode expand(struct Global *global, DEFBUF *tokenp) * foo [no ()] * just write foo to the output stream. */ - unget(global); - cwarn(global, WARN_MACRO_NEEDS_ARGUMENTS, tokenp->name); + fpp_unget(global); + fpp_cwarn(global, WARN_MACRO_NEEDS_ARGUMENTS, tokenp->name); /* fputs(tokenp->name, stdout); */ - Putstring(global, tokenp->name); + fpp_Putstring(global, tokenp->name); return(FPP_OK); - } else if (!(ret=expcollect(global))) { /* Collect arguments */ + } else if (!(ret=fpp_expcollect(global))) { /* Collect arguments */ if (tokenp->nargs != global->nargs) { /* Should be an error? */ - cwarn(global, WARN_WRONG_NUMBER_ARGUMENTS, tokenp->name); + fpp_cwarn(global, WARN_WRONG_NUMBER_ARGUMENTS, tokenp->name); } } else { /* Collect arguments */ return(ret); /* We failed in argument colleting! */ } case DEF_NOARGS: /* No parameters just stuffs */ - ret=expstuff(global, tokenp->name, tokenp->repl); /* expand macro */ + ret=fpp_expstuff(global, tokenp->name, tokenp->repl); /* expand macro */ } /* nargs switch */ return(ret); } INLINE FILE_LOCAL -ReturnCode expcollect(struct Global *global) +ReturnCode fpp_expcollect(struct Global *global) { /* * Collect the actual parameters for this macro. @@ -479,8 +479,8 @@ ReturnCode expcollect(struct Global *global) for (;;) { paren = 0; /* Collect next arg. */ - while ((c = skipws(global)) == '\n')/* Skip over whitespace */ - global->wrongline = TRUE; /* and newlines. */ + while ((c = fpp_skipws(global)) == '\n')/* Skip over whitespace */ + global->wrongline = FPP_TRUE; /* and newlines. */ if (c == ')') { /* At end of all args? */ /* * Note that there is a guard byte in parm[] @@ -490,22 +490,22 @@ ReturnCode expcollect(struct Global *global) break; /* Exit collection loop */ } else if (global->nargs >= LASTPARM) { - cfatal(global, FATAL_TOO_MANY_ARGUMENTS_EXPANSION); + fpp_cfatal(global, FATAL_TOO_MANY_ARGUMENTS_EXPANSION); return(FPP_TOO_MANY_ARGUMENTS); } global->parlist[global->nargs++] = global->parmp; /* At start of new arg */ - for (;; c = cget(global)) { /* Collect arg's bytes */ + for (;; c = fpp_cget(global)) { /* Collect arg's bytes */ if (c == EOF_CHAR) { - cerror(global, ERROR_EOF_IN_ARGUMENT); + fpp_cerror(global, ERROR_EOF_IN_ARGUMENT); return(FPP_EOF_IN_MACRO); /* Sorry. */ } else if (c == '\\') { /* Quote next character */ - charput(global, c); /* Save the \ for later */ - charput(global, cget(global)); /* Save the next char. */ + fpp_charput(global, c); /* Save the \ for later */ + fpp_charput(global, fpp_cget(global)); /* Save the next char. */ continue; /* And go get another */ } else if (type[c] == QUO) { /* Start of string? */ - ret=scanstring(global, c, (ReturnCode (*)(struct Global *, int))charput); /* Scan it off */ + ret=fpp_scanstring(global, c, (ReturnCode (*)(struct Global *, int))fpp_charput); /* Scan it off */ if(ret) return(ret); continue; /* Go get next char */ @@ -514,7 +514,7 @@ ReturnCode expcollect(struct Global *global) paren++; /* To know about commas */ else if (c == ')') { /* Other side too */ if (paren == 0) { /* At the end? */ - unget(global); /* Look at it later */ + fpp_unget(global); /* Look at it later */ break; /* Exit arg getter. */ } paren--; /* More to come. */ @@ -522,10 +522,10 @@ ReturnCode expcollect(struct Global *global) else if (c == ',' && paren == 0) /* Comma delimits args */ break; else if (c == '\n') /* Newline inside arg? */ - global->wrongline = TRUE; /* We'll need a #line */ - charput(global, c); /* Store this one */ + global->wrongline = FPP_TRUE; /* We'll need a #line */ + fpp_charput(global, c); /* Store this one */ } /* Collect an argument */ - charput(global, EOS); /* Terminate argument */ + fpp_charput(global, EOS); /* Terminate argument */ } /* Collect all args. */ return(FPP_OK); /* Normal return */ } @@ -534,7 +534,7 @@ ReturnCode expcollect(struct Global *global) #if OK_CONCAT INLINE FILE_LOCAL -char *doquoting(char *to, char *from) +char *fpp_doquoting(char *to, char *from) { *to++ = '"'; while (*from) { @@ -549,7 +549,7 @@ char *doquoting(char *to, char *from) #endif -ReturnCode expstuff(struct Global *global, +ReturnCode fpp_expstuff(struct Global *global, char *MacroName, char *MacroReplace) { @@ -568,7 +568,7 @@ ReturnCode expstuff(struct Global *global, char quoting; /* Quote macro argument */ #endif - ret = getfile(global, NBUFF, MacroName, &file); + ret = fpp_getfile(global, NBUFF, MacroName, &file); if(ret) return(ret); inp = MacroReplace; /* -> macro replacement */ @@ -599,7 +599,7 @@ ReturnCode expstuff(struct Global *global, } #endif if ((defp + size) >= defend) { - cfatal(global, FATAL_OUT_OF_SPACE_IN_ARGUMENT, MacroName); + fpp_cfatal(global, FATAL_OUT_OF_SPACE_IN_ARGUMENT, MacroName); return(FPP_OUT_OF_SPACE_IN_MACRO_EXPANSION); } /* @@ -611,7 +611,7 @@ ReturnCode expstuff(struct Global *global, } #if OK_CONCAT else if (quoting) - defp = doquoting(defp, global->parlist[c]); + defp = fpp_doquoting(defp, global->parlist[c]); #endif else { strcpy(defp, global->parlist[c]); @@ -620,7 +620,7 @@ else { } } else if (defp >= defend) { - cfatal(global, FATAL_OUT_OF_SPACE_IN_ARGUMENT, MacroName); + fpp_cfatal(global, FATAL_OUT_OF_SPACE_IN_ARGUMENT, MacroName); return(FPP_OUT_OF_SPACE_IN_MACRO_EXPANSION); } else *defp++ = c; diff --git a/3rdparty/fcpp/cpp5.c b/3rdparty/fcpp/cpp5.c index 598960d87..2ca8326ac 100644 --- a/3rdparty/fcpp/cpp5.c +++ b/3rdparty/fcpp/cpp5.c @@ -24,12 +24,12 @@ SOFTWARE. #include "cppdef.h" #include "cpp.h" -INLINE FILE_LOCAL ReturnCode evallex(struct Global *, int, int *); -INLINE FILE_LOCAL ReturnCode dosizeof(struct Global *, int *); -INLINE FILE_LOCAL int bittest(int); -INLINE FILE_LOCAL int evalnum(struct Global *, int); -INLINE FILE_LOCAL int evalchar(struct Global *, int); -INLINE FILE_LOCAL int *evaleval(struct Global *, int *, int, int); +INLINE FILE_LOCAL ReturnCode fpp_evallex(struct Global *, int, int *); +INLINE FILE_LOCAL ReturnCode fpp_dosizeof(struct Global *, int *); +INLINE FILE_LOCAL int fpp_bittest(int); +INLINE FILE_LOCAL int fpp_evalnum(struct Global *, int); +INLINE FILE_LOCAL int fpp_evalchar(struct Global *, int); +INLINE FILE_LOCAL int *fpp_evaleval(struct Global *, int *, int, int); /* * Evaluate an #if expression. @@ -92,7 +92,7 @@ static char opdope[OP_MAX] = { typedef struct optab { char op; /* Operator */ char prec; /* Its precedence */ - char skip; /* Short-circuit: TRUE to skip */ + char skip; /* Short-circuit: FPP_TRUE to skip */ } OPTAB; #ifdef nomacargs @@ -216,18 +216,18 @@ SIZES size_table[] = { #endif /* OK_SIZEOF */ -ReturnCode eval(struct Global *global, int *eval) +ReturnCode fpp_eval(struct Global *global, int *eval) { /* * Evaluate an expression. Straight-forward operator precedence. - * This is called from control() on encountering an #if statement. + * This is called from fpp_control() on encountering an #if statement. * It calls the following routines: - * evallex Lexical analyser -- returns the type and value of + * fpp_evallex Lexical analyser -- returns the type and value of * the next input token. - * evaleval Evaluate the current operator, given the values on + * fpp_evaleval Evaluate the current operator, given the values on * the value stack. Returns a pointer to the (new) * value stack. - * For compatiblity with older cpp's, this return returns 1 (TRUE) + * For compatiblity with older cpp's, this return returns 1 (FPP_TRUE) * if a syntax error is detected. */ int op; /* Current operator */ @@ -240,7 +240,7 @@ ReturnCode eval(struct Global *global, int *eval) int value[NEXP]; /* Value stack */ OPTAB opstack[NEXP]; /* Operand stack */ ReturnCode ret; - char again=TRUE; + char again=FPP_TRUE; valp = value; opp = opstack; @@ -250,7 +250,7 @@ ReturnCode eval(struct Global *global, int *eval) binop = 0; while(again) { - ret=evallex(global, opp->skip, &op); + ret=fpp_evallex(global, opp->skip, &op); if(ret) return(ret); if (op == OP_SUB && binop == 0) @@ -263,27 +263,27 @@ ReturnCode eval(struct Global *global, int *eval) } if (op == DIG) { /* Value? */ if (binop != 0) { - cerror(global, ERROR_MISPLACED_CONSTANT); + fpp_cerror(global, ERROR_MISPLACED_CONSTANT); *eval=1; return(FPP_OK); } else if (valp >= &value[NEXP-1]) { - cerror(global, ERROR_IF_OVERFLOW); + fpp_cerror(global, ERROR_IF_OVERFLOW); *eval=1; return(FPP_OK); } else { *valp++ = global->evalue; binop = 1; } - again=TRUE; + again=FPP_TRUE; continue; } else if (op > OP_END) { - cerror(global, ERROR_ILLEGAL_IF_LINE); + fpp_cerror(global, ERROR_ILLEGAL_IF_LINE); *eval=1; return(FPP_OK); } prec = opdope[op]; if (binop != (prec & 1)) { - cerror(global, ERROR_OPERATOR, opname[op]); + fpp_cerror(global, ERROR_OPERATOR, opname[op]); *eval=1; return(FPP_OK); } @@ -300,7 +300,7 @@ ReturnCode eval(struct Global *global, int *eval) */ opp++; if (opp >= &opstack[NEXP]) { - cerror(global, ERROR_EXPR_OVERFLOW, opname[op]); + fpp_cerror(global, ERROR_EXPR_OVERFLOW, opname[op]); *eval=1; return(FPP_OK); } @@ -323,7 +323,7 @@ ReturnCode eval(struct Global *global, int *eval) else { /* Other ops leave */ opp->skip = op1; /* skipping unchanged. */ } - again=TRUE; + again=FPP_TRUE; continue; } /* @@ -338,11 +338,11 @@ ReturnCode eval(struct Global *global, int *eval) return(FPP_OK); } /* Read another op. */ - again=TRUE; + again=FPP_TRUE; continue; case OP_LPA: /* ( on stack */ if (op != OP_RPA) { /* Matches ) on input */ - cerror(global, ERROR_UNBALANCED_PARENS, opname[op]); + fpp_cerror(global, ERROR_UNBALANCED_PARENS, opname[op]); *eval=1; return(FPP_OK); } @@ -350,12 +350,12 @@ ReturnCode eval(struct Global *global, int *eval) /* -- Fall through */ case OP_QUE: /* Evaluate true expr. */ - again=TRUE; + again=FPP_TRUE; continue; case OP_COL: /* : on stack. */ opp--; /* Unstack : */ if (opp->op != OP_QUE) { /* Matches ? on stack? */ - cerror(global, ERROR_MISPLACED, opname[(unsigned)opp->op]); + fpp_cerror(global, ERROR_MISPLACED, opname[(unsigned)opp->op]); *eval=1; return(FPP_OK); } @@ -364,8 +364,8 @@ ReturnCode eval(struct Global *global, int *eval) */ default: /* Others: */ opp--; /* Unstack the operator */ - valp = evaleval(global, valp, op1, skip); - again=FALSE; + valp = fpp_evaleval(global, valp, op1, skip); + again=FPP_FALSE; } /* op1 switch end */ } while (!again); /* Stack unwind loop */ } @@ -373,16 +373,16 @@ ReturnCode eval(struct Global *global, int *eval) } INLINE FILE_LOCAL -ReturnCode evallex(struct Global *global, - int skip, /* TRUE if short-circuit evaluation */ +ReturnCode fpp_evallex(struct Global *global, + int skip, /* FPP_TRUE if short-circuit evaluation */ int *op) { /* - * Set *op to next eval operator or value. Called from eval(). It + * Set *op to next fpp_eval operator or value. Called from fpp_eval(). It * calls a special-purpose routines for 'char' strings and * numeric values: - * evalchar called to evaluate 'x' - * evalnum called to evaluate numbers. + * fpp_evalchar called to evaluate 'x' + * fpp_evalnum called to evaluate numbers. */ int c, c1, t; @@ -391,55 +391,55 @@ ReturnCode evallex(struct Global *global, do { /* while(loop); */ /* again: */ - loop=FALSE; + loop=FPP_FALSE; do { /* Collect the token */ - c = skipws(global); - if((ret=macroid(global, &c))) + c = fpp_skipws(global); + if((ret=fpp_macroid(global, &c))) return(ret); if (c == EOF_CHAR || c == '\n') { - unget(global); + fpp_unget(global); *op=OP_EOE; /* End of expression */ return(FPP_OK); } - } while ((t = type[c]) == LET && catenate(global, &ret) && !ret); + } while ((t = type[c]) == LET && fpp_catenate(global, 0, &ret) && !ret); if(ret) /* If the loop was broken because of a fatal error! */ return(ret); if (t == INV) { /* Total nonsense */ if (!skip) { if (isascii(c) && isprint(c)) - cerror(global, ERROR_ILLEGAL_CHARACTER, c); + fpp_cerror(global, ERROR_ILLEGAL_CHARACTER, c); else - cerror(global, ERROR_ILLEGAL_CHARACTER2, c); + fpp_cerror(global, ERROR_ILLEGAL_CHARACTER2, c); } return(FPP_ILLEGAL_CHARACTER); } else if (t == QUO) { /* ' or " */ if (c == '\'') { /* Character constant */ - global->evalue = evalchar(global, skip); /* Somewhat messy */ + global->evalue = fpp_evalchar(global, skip); /* Somewhat messy */ *op=DIG; /* Return a value */ return(FPP_OK); } - cerror(global, ERROR_STRING_IN_IF); + fpp_cerror(global, ERROR_STRING_IN_IF); return(FPP_CANT_USE_STRING_IN_IF); } else if (t == LET) { /* ID must be a macro */ if (streq(global->tokenbuf, "defined")) { /* Or defined name */ - c1 = c = skipws(global); + c1 = c = fpp_skipws(global); if (c == '(') /* Allow defined(name) */ - c = skipws(global); + c = fpp_skipws(global); if (type[c] == LET) { - global->evalue = (lookid(global, c) != NULL); + global->evalue = (fpp_lookid(global, c) != NULL); if (c1 != '(' /* Need to balance */ - || skipws(global) == ')') { /* Did we balance? */ + || fpp_skipws(global) == ')') { /* Did we balance? */ *op=DIG; return(FPP_OK); /* Parsed ok */ } } - cerror(global, ERROR_DEFINED_SYNTAX); + fpp_cerror(global, ERROR_DEFINED_SYNTAX); return(FPP_BAD_IF_DEFINED_SYNTAX); } #if OK_SIZEOF else if (streq(global->tokenbuf, "sizeof")) { /* New sizeof hackery */ - ret=dosizeof(global, op); /* Gets own routine */ + ret=fpp_dosizeof(global, op); /* Gets own routine */ return(ret); } #endif @@ -448,13 +448,13 @@ else if (streq(global->tokenbuf, "sizeof")) { /* New sizeof hackery */ return(FPP_OK); } else if (t == DIG) { /* Numbers are harder */ - global->evalue = evalnum(global, c); + global->evalue = fpp_evalnum(global, c); } else if (strchr("!=<>&|\\", c) != NULL) { /* * Process a possible multi-byte lexeme. */ - c1 = cget(global); /* Peek at next char */ + c1 = fpp_cget(global); /* Peek at next char */ switch (c) { case '!': if (c1 == '=') { @@ -465,8 +465,8 @@ else if (streq(global->tokenbuf, "sizeof")) { /* New sizeof hackery */ case '=': if (c1 != '=') { /* Can't say a=b in #if */ - unget(global); - cerror(global, ERROR_ILLEGAL_ASSIGN); + fpp_unget(global); + fpp_cerror(global, ERROR_ILLEGAL_ASSIGN); return (FPP_IF_ERROR); } *op=OP_EQ; @@ -493,14 +493,14 @@ else if (streq(global->tokenbuf, "sizeof")) { /* New sizeof hackery */ case '\\': if (c1 == '\n') { /* Multi-line if */ - loop=TRUE; + loop=FPP_TRUE; break; } - cerror(global, ERROR_ILLEGAL_BACKSLASH); + fpp_cerror(global, ERROR_ILLEGAL_BACKSLASH); return(FPP_IF_ERROR); } if(!loop) - unget(global); + fpp_unget(global); } } while(loop); *op=t; @@ -510,7 +510,7 @@ else if (streq(global->tokenbuf, "sizeof")) { /* New sizeof hackery */ #if OK_SIZEOF INLINE FILE_LOCAL -ReturnCode dosizeof(struct Global *global, int *result) +ReturnCode fpp_dosizeof(struct Global *global, int *result) { /* * Process the sizeof (basic type) operation in an #if string. @@ -525,44 +525,44 @@ ReturnCode dosizeof(struct Global *global, int *result) short typecode; ReturnCode ret; - if ((c = skipws(global)) != '(') { - unget(global); - cerror(global, ERROR_SIZEOF_SYNTAX); + if ((c = fpp_skipws(global)) != '(') { + fpp_unget(global); + fpp_cerror(global, ERROR_SIZEOF_SYNTAX); return(FPP_SIZEOF_ERROR); } /* * Scan off the tokens. */ typecode = 0; - while ((c = skipws(global))) { - if((ret=macroid(global, &c))) + while ((c = fpp_skipws(global))) { + if((ret=fpp_macroid(global, &c))) return(ret); /* (I) return on fail! */ if (c == EOF_CHAR || c == '\n') { /* End of line is a bug */ - unget(global); - cerror(global, ERROR_SIZEOF_SYNTAX); + fpp_unget(global); + fpp_cerror(global, ERROR_SIZEOF_SYNTAX); return(FPP_SIZEOF_ERROR); } else if (c == '(') { /* thing (*)() func ptr */ - if (skipws(global) == '*' - && skipws(global) == ')') { /* We found (*) */ - if (skipws(global) != '(') /* Let () be optional */ - unget(global); - else if (skipws(global) != ')') { - unget(global); - cerror(global, ERROR_SIZEOF_SYNTAX); + if (fpp_skipws(global) == '*' + && fpp_skipws(global) == ')') { /* We found (*) */ + if (fpp_skipws(global) != '(') /* Let () be optional */ + fpp_unget(global); + else if (fpp_skipws(global) != ')') { + fpp_unget(global); + fpp_cerror(global, ERROR_SIZEOF_SYNTAX); return(FPP_SIZEOF_ERROR); } typecode |= T_FPTR; /* Function pointer */ } else { /* Junk is a bug */ - unget(global); - cerror(global, ERROR_SIZEOF_SYNTAX); + fpp_unget(global); + fpp_cerror(global, ERROR_SIZEOF_SYNTAX); return(FPP_SIZEOF_ERROR); } } else if (type[c] != LET) /* Exit if not a type */ break; - else if (!catenate(global, &ret) && !ret) { /* Maybe combine tokens */ + else if (!fpp_catenate(global, 0, &ret) && !ret) { /* Maybe combine tokens */ /* * Look for this unexpandable token in basic_types. * The code accepts "int long" as well as "long int" @@ -574,7 +574,7 @@ ReturnCode dosizeof(struct Global *global, int *result) break; } if (tp->name == NULLST) { - cerror(global, ERROR_SIZEOF_UNKNOWN, global->tokenbuf); + fpp_cerror(global, ERROR_SIZEOF_UNKNOWN, global->tokenbuf); return(FPP_SIZEOF_ERROR); } typecode |= tp->type; /* Or in the type bit */ @@ -586,12 +586,12 @@ ReturnCode dosizeof(struct Global *global, int *result) */ if (c == '*') { typecode |= T_PTR; - c = skipws(global); + c = fpp_skipws(global); } if (c == ')') { /* Last syntax check */ for (testp = test_table; *testp != 0; testp++) { - if (!bittest(typecode & *testp)) { - cerror(global, ERROR_SIZEOF_ILLEGAL_TYPE); + if (!fpp_bittest(typecode & *testp)) { + fpp_cerror(global, ERROR_SIZEOF_ILLEGAL_TYPE); return(FPP_SIZEOF_ERROR); } } @@ -609,7 +609,7 @@ ReturnCode dosizeof(struct Global *global, int *result) typecode &= ~T_INT; } if ((typecode & ~T_PTR) == 0) { - cerror(global, ERROR_SIZEOF_NO_TYPE); + fpp_cerror(global, ERROR_SIZEOF_NO_TYPE); return(FPP_SIZEOF_ERROR); } /* @@ -623,19 +623,19 @@ ReturnCode dosizeof(struct Global *global, int *result) return(FPP_OK); } } /* We shouldn't fail */ - cerror(global, ERROR_SIZEOF_BUG, typecode); + fpp_cerror(global, ERROR_SIZEOF_BUG, typecode); return(FPP_SIZEOF_ERROR); } - unget(global); - cerror(global, ERROR_SIZEOF_SYNTAX); + fpp_unget(global); + fpp_cerror(global, ERROR_SIZEOF_SYNTAX); return(FPP_SIZEOF_ERROR); } INLINE FILE_LOCAL -int bittest(int value) +int fpp_bittest(int value) { /* - * TRUE if value is zero or exactly one bit is set in value. + * FPP_TRUE if value is zero or exactly one bit is set in value. */ #if (4096 & ~(-4096)) == 0 @@ -651,10 +651,10 @@ int bittest(int value) #endif /* OK_SIZEOF */ INLINE FILE_LOCAL -int evalnum(struct Global *global, int c) +int fpp_evalnum(struct Global *global, int c) { /* - * Expand number for #if lexical analysis. Note: evalnum recognizes + * Expand number for #if lexical analysis. Note: fpp_evalnum recognizes * the unsigned suffix, but only returns a signed int value. */ @@ -664,16 +664,16 @@ int evalnum(struct Global *global, int c) if (c != '0') base = 10; - else if ((c = cget(global)) == 'x' || c == 'X') { + else if ((c = fpp_cget(global)) == 'x' || c == 'X') { base = 16; - c = cget(global); + c = fpp_cget(global); } else base = 8; value = 0; for (;;) { c1 = c; if (isascii(c) && isupper(c1)) - c1 = tolower(c1); + c1 = fpp_tolower(c1); if (c1 >= 'a') c1 -= ('a' - 10); else c1 -= '0'; @@ -681,17 +681,17 @@ int evalnum(struct Global *global, int c) break; value *= base; value += c1; - c = cget(global); + c = fpp_cget(global); } if (c == 'u' || c == 'U') /* Unsigned nonsense */ - c = cget(global); - unget(global); + c = fpp_cget(global); + fpp_unget(global); return (value); } INLINE FILE_LOCAL -int evalchar(struct Global *global, - int skip) /* TRUE if short-circuit evaluation */ +int fpp_evalchar(struct Global *global, + int skip) /* FPP_TRUE if short-circuit evaluation */ /* * Get a character constant */ @@ -700,9 +700,9 @@ int evalchar(struct Global *global, int value; int count; - global->instring = TRUE; - if ((c = cget(global)) == '\\') { - switch ((c = cget(global))) { + global->instring = FPP_TRUE; + if ((c = fpp_cget(global)) == '\\') { + switch ((c = fpp_cget(global))) { case 'a': /* New in Standard */ #if ('a' == '\a' || '\a' == ALERT) value = ALERT; /* Use predefined value */ @@ -742,14 +742,14 @@ int evalchar(struct Global *global, case 'x': /* '\xFF' */ count = 3; value = 0; - while ((((c = get(global)) >= '0' && c <= '9') + while ((((c = fpp_get(global)) >= '0' && c <= '9') || (c >= 'a' && c <= 'f') || (c >= 'A' && c <= 'F')) && (--count >= 0)) { value *= 16; value += (c <= '9') ? (c - '0') : ((c & 0xF) + 9); } - unget(global); + fpp_unget(global); break; default: @@ -759,9 +759,9 @@ int evalchar(struct Global *global, while (c >= '0' && c <= '7' && --count >= 0) { value *= 8; value += (c - '0'); - c = get(global); + c = fpp_get(global); } - unget(global); + fpp_unget(global); } else value = c; break; @@ -776,9 +776,9 @@ int evalchar(struct Global *global, #if BIG_ENDIAN count = 0; #endif - while ((c = get(global)) != '\'' && c != EOF_CHAR && c != '\n') { + while ((c = fpp_get(global)) != '\'' && c != EOF_CHAR && c != '\n') { if (!skip) - cwarn(global, WARN_MULTIBYTE_NOT_PORTABLE, c); + fpp_cwarn(global, WARN_MULTIBYTE_NOT_PORTABLE, c); #if BIG_ENDIAN count += BITS_CHAR; value += (c << count); @@ -787,15 +787,15 @@ int evalchar(struct Global *global, value += c; #endif } - global->instring = FALSE; + global->instring = FPP_FALSE; return (value); } INLINE FILE_LOCAL -int *evaleval(struct Global *global, +int *fpp_evaleval(struct Global *global, int *valp, int op, - int skip) /* TRUE if short-circuit evaluation */ + int skip) /* FPP_TRUE if short-circuit evaluation */ { /* * Apply the argument operator to the data on the value stack. @@ -804,7 +804,7 @@ int *evaleval(struct Global *global, * * OP_COL is a special case. * - * evaleval() returns the new pointer to the top of the value stack. + * fpp_evaleval() returns the new pointer to the top of the value stack. */ int v1, v2 = 0; @@ -827,7 +827,7 @@ int *evaleval(struct Global *global, case OP_MOD: if (v2 == 0) { if (!skip) { - cwarn(global, WARN_DIVISION_BY_ZERO, + fpp_cwarn(global, WARN_DIVISION_BY_ZERO, (op == OP_DIV) ? "divide" : "mod"); } v1 = 0; @@ -895,7 +895,7 @@ int *evaleval(struct Global *global, v1 = !v1; break; default: - cerror(global, ERROR_IF_OPERAND, op); + fpp_cerror(global, ERROR_IF_OPERAND, op); v1 = 0; } *valp++ = v1; diff --git a/3rdparty/fcpp/cpp6.c b/3rdparty/fcpp/cpp6.c index fe8278a9a..ddb78867f 100644 --- a/3rdparty/fcpp/cpp6.c +++ b/3rdparty/fcpp/cpp6.c @@ -24,52 +24,52 @@ SOFTWARE. #include "cppdef.h" #include "cpp.h" -INLINE FILE_LOCAL void outadefine(struct Global *, DEFBUF *); -INLINE FILE_LOCAL void domsg(struct Global *, ErrorCode, va_list); +INLINE FILE_LOCAL void fpp_outadefine(struct Global *, DEFBUF *); +INLINE FILE_LOCAL void fpp_domsg(struct Global *, ErrorCode, va_list); /* - * skipnl() skips over input text to the end of the line. - * skipws() skips over "whitespace" (spaces or tabs), but + * fpp_skipnl() skips over input text to the end of the line. + * fpp_skipws() skips over "whitespace" (spaces or tabs), but * not skip over the end of the line. It skips over * TOK_SEP, however (though that shouldn't happen). - * scanid() reads the next token (C identifier) into tokenbuf. + * fpp_scanid() reads the next token (C identifier) into tokenbuf. * The caller has already read the first character of - * the identifier. Unlike macroid(), the token is + * the identifier. Unlike fpp_macroid(), the token is * never expanded. - * macroid() reads the next token (C identifier) into tokenbuf. + * fpp_macroid() reads the next token (C identifier) into tokenbuf. * If it is a #defined macro, it is expanded, and - * macroid() returns TRUE, otherwise, FALSE. - * catenate() Does the dirty work of token concatenation, TRUE if it did. - * scanstring() Reads a string from the input stream, calling + * fpp_macroid() returns FPP_TRUE, otherwise, FPP_FALSE. + * fpp_catenate() Does the dirty work of token concatenation, FPP_TRUE if it did. + * fpp_scanstring() Reads a string from the input stream, calling * a user-supplied function for each character. - * This function may be output() to write the - * string to the output file, or save() to save + * This function may be fpp_output() to write the + * string to the output file, or fpp_save() to fpp_save * the string in the work buffer. - * scannumber() Reads a C numeric constant from the input stream, + * fpp_scannumber() Reads a C numeric constant from the input stream, * calling the user-supplied function for each - * character. (output() or save() as noted above.) - * save() Save one character in the work[] buffer. - * savestring() Saves a string in malloc() memory. - * getfile() Initialize a new FILEINFO structure, called when + * character. (fpp_output() or fpp_save() as noted above.) + * fpp_save() Save one character in the work[] buffer. + * fpp_savestring() Saves a string in malloc() memory. + * fpp_getfile() Initialize a new FILEINFO structure, called when * #include opens a new file, or a macro is to be * expanded. - * Getmem() Get a specified number of bytes from malloc memory. - * output() Write one character to stdout (calling Putchar) -- + * fpp_Getmem() Get a specified number of bytes from malloc memory. + * fpp_output() Write one character to stdout (calling fpp_Putchar) -- * implemented as a function so its address may be - * passed to scanstring() and scannumber(). - * lookid() Scans the next token (identifier) from the input + * passed to fpp_scanstring() and fpp_scannumber(). + * fpp_lookid() Scans the next token (identifier) from the input * stream. Looks for it in the #defined symbol table. * Returns a pointer to the definition, if found, or NULL * if not present. The identifier is stored in tokenbuf. - * defnedel() Define enter/delete subroutine. Updates the + * fpp_defendel() Define enter/delete subroutine. Updates the * symbol table. - * get() Read the next byte from the current input stream, + * fpp_get() Read the next byte from the current input stream, * handling end of (macro/file) input and embedded * comments appropriately. Note that the global - * instring is -- essentially -- a parameter to get(). - * cget() Like get(), but skip over TOK_SEP. - * unget() Push last gotten character back on the input stream. - * cerror() This routine format an print messages to the user. + * instring is -- essentially -- a parameter to fpp_get(). + * fpp_cget() Like fpp_get(), but skip over TOK_SEP. + * fpp_unget() Push last gotten character back on the input stream. + * fpp_cerror() This routine format an print messages to the user. */ /* @@ -121,7 +121,7 @@ char type[256] = { /* Character type codes Hex */ 000, 000, 000, 000, 000, 000, 000, 000, /* 80 .. FF */ }; -void skipnl(struct Global *global) +void fpp_skipnl(struct Global *global) { /* * Skip to the end of the current input line. @@ -129,12 +129,12 @@ void skipnl(struct Global *global) int c; do { /* Skip to newline */ - c = get(global); + c = fpp_get(global); } while (c != '\n' && c != EOF_CHAR); return; } -int skipws(struct Global *global) +int fpp_skipws(struct Global *global) { /* * Skip over whitespace @@ -142,7 +142,7 @@ int skipws(struct Global *global) int c; do { /* Skip whitespace */ - c = get(global); + c = fpp_get(global); #if COMMENT_INVISIBLE } while (type[c] == SPA || c == COM_SEP); #else @@ -151,19 +151,19 @@ int skipws(struct Global *global) return(c); } -void scanid(struct Global *global, +void fpp_scanid(struct Global *global, int c) /* First char of id */ { /* * Get the next token (an id) into the token buffer. - * Note: this code is duplicated in lookid(). + * Note: this code is duplicated in fpp_lookid(). * Change one, change both. */ int ct; if (c == DEF_MAGIC) /* Eat the magic token */ - c = get(global); /* undefiner. */ + c = fpp_get(global); /* undefiner. */ ct = 0; do { @@ -171,14 +171,14 @@ void scanid(struct Global *global, global->tokenbuf = realloc(global->tokenbuf, 1 + (global->tokenbsize *= 2)); global->tokenbuf[ct++] = c; - c = get(global); + c = fpp_get(global); } while (type[c] == LET || type[c] == DIG); - unget(global); + fpp_unget(global); global->tokenbuf[ct] = EOS; } -ReturnCode macroid(struct Global *global, int *c) +ReturnCode fpp_macroid(struct Global *global, int *c) { /* * If c is a letter, scan the id. if it's #defined, expand it and scan @@ -191,51 +191,53 @@ ReturnCode macroid(struct Global *global, int *c) if (global->infile != NULL && global->infile->fp != NULL) global->recursion = 0; - while (type[*c] == LET && (dp = lookid(global, *c)) != NULL) { - if((ret=expand(global, dp))) + while (type[*c] == LET && (dp = fpp_lookid(global, *c)) != NULL) { + if((ret=fpp_expand(global, dp))) return(ret); - *c = get(global); + *c = fpp_get(global); } return(FPP_OK); } -int catenate(struct Global *global, ReturnCode *ret) +int fpp_catenate(struct Global *global, int lhs_number, ReturnCode *ret) { /* - * A token was just read (via macroid). + * A token was just read (via fpp_macroid). * If the next character is TOK_SEP, concatenate the next token - * return TRUE -- which should recall macroid after refreshing - * macroid's argument. If it is not TOK_SEP, unget() the character - * and return FALSE. + * return FPP_TRUE -- which should recall fpp_macroid after refreshing + * fpp_macroid's argument. If it is not TOK_SEP, fpp_unget() the character + * and return FPP_FALSE. */ #if OK_CONCAT int c; - char *token1; + char *token1 = ""; #endif #if OK_CONCAT - if (get(global) != TOK_SEP) { /* Token concatenation */ - unget(global); - return (FALSE); + if (fpp_get(global) != TOK_SEP) { /* Token concatenation */ + fpp_unget(global); + return (FPP_FALSE); } else { - token1 = savestring(global, global->tokenbuf); /* Save first token */ - c=get(global); + if (lhs_number == 0) { /* The lhs number has already been emit */ + token1 = fpp_savestring(global, global->tokenbuf); /* Save first token */ + } + c= fpp_get(global); if(global->rightconcat) { - *ret=macroid(global, &c); /* Scan next token */ + *ret=fpp_macroid(global, &c); /* Scan next token */ if(*ret) - return(FALSE); + return(FPP_FALSE); } /* BK - BUG? Parses token into global->tokenbuf but never uses it. else - lookid(global, c); + fpp_lookid(global, c); */ switch(type[c]) { /* What was it? */ case LET: /* An identifier, ... */ if ((int)strlen(token1) + (int)strlen(global->tokenbuf) >= NWORK) { - cfatal(global, FATAL_WORK_AREA_OVERFLOW, token1); + fpp_cfatal(global, FATAL_WORK_AREA_OVERFLOW, token1); *ret=FPP_WORK_AREA_OVERFLOW; - return(FALSE); + return(FPP_FALSE); } sprintf(global->work, "%s%s", token1, global->tokenbuf); break; @@ -243,20 +245,20 @@ int catenate(struct Global *global, ReturnCode *ret) case DOT: /* Or maybe a float */ strcpy(global->work, token1); global->workp = global->work + strlen(global->work); - *ret=scannumber(global, c, save); + *ret=fpp_scannumber(global, c, fpp_save); if(*ret) - return(FALSE); - *ret=save(global, EOS); + return(FPP_FALSE); + *ret=fpp_save(global, EOS); if(*ret) - return(FALSE); + return(FPP_FALSE); break; default: /* An error, ... */ if (isprint(c)) - cerror(global, ERROR_STRANG_CHARACTER, c); + fpp_cerror(global, ERROR_STRANG_CHARACTER, c); else - cerror(global, ERROR_STRANG_CHARACTER2, c); + fpp_cerror(global, ERROR_STRANG_CHARACTER2, c); strcpy(global->work, token1); - unget(global); + fpp_unget(global); break; } /* @@ -265,18 +267,20 @@ int catenate(struct Global *global, ReturnCode *ret) * new (concatenated) token after freeing token1. * Finally, setup to read the new token. */ - free(token1); /* Free up memory */ - *ret=ungetstring(global, global->work); /* Unget the new thing, */ + if (lhs_number == 0) { + free(token1); /* Free up memory */ + } + *ret=fpp_ungetstring(global, global->work); /* Unget the new thing, */ if(*ret) - return(FALSE); - return(TRUE); + return(FPP_FALSE); + return(FPP_TRUE); } #else - return(FALSE); /* Not supported */ + return(FPP_FALSE); /* Not supported */ #endif } -ReturnCode scanstring(struct Global *global, +ReturnCode fpp_scanstring(struct Global *global, int delim, /* ' or " */ /* Output function: */ ReturnCode (*outfun)(struct Global *, int)) @@ -284,40 +288,40 @@ ReturnCode scanstring(struct Global *global, /* * Scan off a string. Warning if terminated by newline or EOF. * outfun() outputs the character -- to a buffer if in a macro. - * TRUE if ok, FALSE if error. + * FPP_TRUE if ok, FPP_FALSE if error. */ int c; ReturnCode ret; - global->instring = TRUE; /* Don't strip comments */ + global->instring = FPP_TRUE; /* Don't strip comments */ ret=(*outfun)(global, delim); if(ret) return(ret); - while ((c = get(global)) != delim + while ((c = fpp_get(global)) != delim && c != '\n' && c != EOF_CHAR) { ret=(*outfun)(global, c); if(ret) return(ret); if (c == '\\') { - ret=(*outfun)(global, get(global)); + ret=(*outfun)(global, fpp_get(global)); if(ret) return(ret); } } - global->instring = FALSE; + global->instring = FPP_FALSE; if (c == delim) { ret=(*outfun)(global, c); return(ret); } else { - cerror(global, ERROR_UNTERMINATED_STRING); - unget(global); + fpp_cerror(global, ERROR_UNTERMINATED_STRING); + fpp_unget(global); return(FPP_UNTERMINATED_STRING); } } -ReturnCode scannumber(struct Global *global, +ReturnCode fpp_scannumber(struct Global *global, int c, /* First char of number */ /* Output/store func: */ ReturnCode (*outfun)(struct Global *, int)) @@ -331,20 +335,20 @@ ReturnCode scannumber(struct Global *global, int expseen; /* 'e' seen in floater */ int signseen; /* '+' or '-' seen */ int octal89; /* For bad octal test */ - int dotflag; /* TRUE if '.' was seen */ + int dotflag; /* FPP_TRUE if '.' was seen */ ReturnCode ret; - char done=FALSE; + char done=FPP_FALSE; - expseen = FALSE; /* No exponent seen yet */ - signseen = TRUE; /* No +/- allowed yet */ - octal89 = FALSE; /* No bad octal yet */ + expseen = FPP_FALSE; /* No exponent seen yet */ + signseen = FPP_TRUE; /* No +/- allowed yet */ + octal89 = FPP_FALSE; /* No bad octal yet */ radix = 10; /* Assume decimal */ - if ((dotflag = (c == '.')) != FALSE) {/* . something? */ + if ((dotflag = (c == '.')) != FPP_FALSE) {/* . something? */ ret=(*outfun)(global, '.'); /* Always out the dot */ if(ret) return(ret); - if (type[(c = get(global))] != DIG) { /* If not a float numb, */ - unget(global); /* Rescan strange char */ + if (type[(c = fpp_get(global))] != DIG) { /* If not a float numb, */ + fpp_unget(global); /* Rescan strange char */ return(FPP_OK); /* All done for now */ } } /* End of float test */ @@ -353,13 +357,13 @@ ReturnCode scannumber(struct Global *global, if(ret) return(ret); radix = 8; /* Assume it's octal */ - c = get(global); /* Look for an 'x' */ - if (c == 'x' || c == 'X') { /* Did we get one? */ + c = fpp_get(global); /* Look for an 'x' */ + if (c == 'x' || c == 'X') { /* Did we fpp_get one? */ radix = 16; /* Remember new radix */ ret=(*outfun)(global, c); /* Stuff the 'x' */ if(ret) return(ret); - c = get(global); /* Get next character */ + c = fpp_get(global); /* Get next character */ } } while (!done) { /* Process curr. char. */ @@ -370,24 +374,24 @@ ReturnCode scannumber(struct Global *global, if (radix != 16 && (c == 'e' || c == 'E')) { if (expseen) /* Already saw 'E'? */ break; /* Exit loop, bad nbr. */ - expseen = TRUE; /* Set exponent seen */ - signseen = FALSE; /* We can read '+' now */ + expseen = FPP_TRUE; /* Set exponent seen */ + signseen = FPP_FALSE; /* We can read '+' now */ radix = 10; /* Decimal exponent */ } else if (radix != 16 && c == '.') { if (dotflag) /* Saw dot already? */ break; /* Exit loop, two dots */ - dotflag = TRUE; /* Remember the dot */ + dotflag = FPP_TRUE; /* Remember the dot */ radix = 10; /* Decimal fraction */ } else if (c == '+' || c == '-') { /* 1.0e+10 */ if (signseen) /* Sign in wrong place? */ break; /* Exit loop, not nbr. */ - /* signseen = TRUE; */ /* Remember we saw it */ + /* signseen = FPP_TRUE; */ /* Remember we saw it */ } else { /* Check the digit */ switch (c) { case '8': case '9': /* Sometimes wrong */ - octal89 = TRUE; /* Do check later */ + octal89 = FPP_TRUE; /* Do check later */ case '0': case '1': case '2': case '3': case '4': case '5': case '6': case '7': break; /* Always ok */ @@ -397,15 +401,15 @@ ReturnCode scannumber(struct Global *global, if (radix == 16) /* Alpha's are ok only */ break; /* if reading hex. */ default: /* At number end */ - done=TRUE; /* Break from for loop */ + done=FPP_TRUE; /* Break from for loop */ continue; } /* End of switch */ } /* End general case */ ret=(*outfun)(global, c); /* Accept the character */ if(ret) return(ret); - signseen = TRUE; /* Don't read sign now */ - c = get(global); /* Read another char */ + signseen = FPP_TRUE; /* Don't read sign now */ + c = fpp_get(global); /* Read another char */ } /* End of scan loop */ /* * When we break out of the scan loop, c contains the first @@ -421,7 +425,7 @@ ReturnCode scannumber(struct Global *global, ret=(*outfun)(global, c); if(ret) return(ret); - c = get(global); /* Ungotten later */ + c = fpp_get(global); /* Ungotten later */ } } else { /* Else it's an integer */ /* @@ -429,54 +433,54 @@ ReturnCode scannumber(struct Global *global, * dotflag signals "saw 'L'", and * expseen signals "saw 'U'". */ - done=TRUE; + done=FPP_TRUE; while(done) { switch (c) { case 'l': case 'L': if (dotflag) { - done=FALSE; + done=FPP_FALSE; continue; } - dotflag = TRUE; + dotflag = FPP_TRUE; break; case 'u': case 'U': if (expseen) { - done=FALSE; + done=FPP_FALSE; continue; } - expseen = TRUE; + expseen = FPP_TRUE; break; default: - done=FALSE; + done=FPP_FALSE; continue; } ret=(*outfun)(global, c); /* Got 'L' or 'U'. */ if(ret) return(ret); - c = get(global); /* Look at next, too. */ + c = fpp_get(global); /* Look at next, too. */ } } - unget(global); /* Not part of a number */ + fpp_unget(global); /* Not part of a number */ if(!(global->webmode)) { if (octal89 && radix == 8) - cwarn(global, WARN_ILLEGAL_OCTAL); + fpp_cwarn(global, WARN_ILLEGAL_OCTAL); } return(FPP_OK); } -ReturnCode save(struct Global *global, int c) +ReturnCode fpp_save(struct Global *global, int c) { if (global->workp >= &global->work[NWORK]) { - cfatal(global, FATAL_WORK_BUFFER_OVERFLOW); + fpp_cfatal(global, FATAL_WORK_BUFFER_OVERFLOW); return(FPP_WORK_AREA_OVERFLOW); } else *global->workp++ = c; return(FPP_OK); } -char *savestring(struct Global *global, char *text) +char *fpp_savestring(struct Global *global, char *text) { /* * Store a string into free memory. @@ -488,7 +492,7 @@ char *savestring(struct Global *global, char *text) return (result); } -ReturnCode getfile(struct Global *global, +ReturnCode fpp_getfile(struct Global *global, size_t bufsize, /* Line or define buffer size */ char *name, FILEINFO **file) /* File or macro name string */ @@ -511,7 +515,7 @@ ReturnCode getfile(struct Global *global, return(FPP_OUT_OF_MEMORY); (*file)->parent = global->infile; /* Chain files together */ (*file)->fp = NULL; /* No file yet */ - (*file)->filename = savestring(global, name); /* Save file/macro name */ + (*file)->filename = fpp_savestring(global, name); /* Save file/macro name */ (*file)->progname = NULL; /* No #line seen yet */ (*file)->unrecur = 0; /* No macro fixup */ (*file)->bptr = (*file)->buffer; /* Initialize line ptr */ @@ -528,7 +532,7 @@ ReturnCode getfile(struct Global *global, * C P P S y m b o l T a b l e s */ -DEFBUF *lookid(struct Global *global, +DEFBUF *fpp_lookid(struct Global *global, int c) /* First character of token */ { /* @@ -544,16 +548,16 @@ DEFBUF *lookid(struct Global *global, nhash = 0; if ((isrecurse = (c == DEF_MAGIC))) /* If recursive macro */ - c = get(global); /* hack, skip DEF_MAGIC */ + c = fpp_get(global); /* hack, skip DEF_MAGIC */ ct = 0; do { if (ct == global->tokenbsize) global->tokenbuf = realloc(global->tokenbuf, 1 + (global->tokenbsize *= 2)); global->tokenbuf[ct++] = c; /* Store token byte */ nhash += c; /* Update hash value */ - c = get(global); + c = fpp_get(global); } while (type[c] == LET || type[c] == DIG); - unget(global); /* Rescan terminator */ + fpp_unget(global); /* Rescan terminator */ global->tokenbuf[ct] = EOS; /* Terminate token */ if (isrecurse) /* Recursive definition */ return(NULL); /* undefined just now */ @@ -568,15 +572,15 @@ DEFBUF *lookid(struct Global *global, return((temp == 0) ? dp : NULL); } -DEFBUF *defendel(struct Global *global, +DEFBUF *fpp_defendel(struct Global *global, char *name, - int delete) /* TRUE to delete a symbol */ + int delete) /* FPP_TRUE to delete a symbol */ { /* - * Enter this name in the lookup table (delete = FALSE) - * or delete this name (delete = TRUE). - * Returns a pointer to the define block (delete = FALSE) - * Returns NULL if the symbol wasn't defined (delete = TRUE). + * Enter this name in the lookup table (delete = FPP_FALSE) + * or delete this name (delete = FPP_TRUE). + * Returns a pointer to the define block (delete = FPP_FALSE) + * Returns NULL if the symbol wasn't defined (delete = FPP_TRUE). */ DEFBUF *dp; @@ -618,8 +622,7 @@ DEFBUF *defendel(struct Global *global, return(dp); } - -void delalldefines(struct Global *global) +void fpp_delalldefines(struct Global *global) { /* * Delete all the defines in the tables and free memory @@ -642,92 +645,92 @@ void delalldefines(struct Global *global) } -void outdefines(struct Global *global) +void fpp_outdefines(struct Global *global) { DEFBUF *dp; DEFBUF **syp; - delbuiltindefines(global); /* Delete built-in #defines */ + fpp_delbuiltindefines(global); /* Delete built-in #defines */ for (syp = global->symtab; syp < &global->symtab[SBSIZE]; syp++) { if ((dp = *syp) != (DEFBUF *) NULL) { do { - outadefine(global, dp); + fpp_outadefine(global, dp); } while ((dp = dp->link) != (DEFBUF *) NULL); } } } INLINE FILE_LOCAL -void outadefine(struct Global *global, DEFBUF *dp) +void fpp_outadefine(struct Global *global, DEFBUF *dp) { char *cp; int c; /* printf("#define %s", dp->name); */ - Putstring(global, "#define "); - Putstring(global, dp->name); + fpp_Putstring(global, "#define "); + fpp_Putstring(global, dp->name); if (dp->nargs > 0) { int i; - Putchar(global, '('); + fpp_Putchar(global, '('); for (i = 1; i < dp->nargs; i++) { /* printf("__%d,", i); */ - Putstring(global, "__"); - Putint(global, i); - Putchar(global, ','); + fpp_Putstring(global, "__"); + fpp_Putint(global, i); + fpp_Putchar(global, ','); } /* printf("__%d)", i); */ - Putstring(global, "__"); - Putint(global, i); - Putchar(global, ')'); + fpp_Putstring(global, "__"); + fpp_Putint(global, i); + fpp_Putchar(global, ')'); } else if (dp->nargs == 0) { - Putstring(global, "()"); + fpp_Putstring(global, "()"); } if (dp->repl != NULL) { - Putchar(global, '\t'); + fpp_Putchar(global, '\t'); for (cp = dp->repl; (c = *cp++ & 0xFF) != EOS;) { if (c >= MAC_PARM && c < (MAC_PARM + PAR_MAC)) { /* printf("__%d", c - MAC_PARM + 1); */ - Putstring(global, "__"); - Putint(global, c - MAC_PARM + 1); + fpp_Putstring(global, "__"); + fpp_Putint(global, c - MAC_PARM + 1); } else if (isprint(c) || c == '\t' || c == '\n') - Putchar(global, c); + fpp_Putchar(global, c); else switch (c) { case QUOTE_PARM: - Putchar(global, '#'); + fpp_Putchar(global, '#'); break; case DEF_MAGIC: /* Special anti-recursion */ case MAC_PARM + PAR_MAC: /* Special "arg" marker */ break; case COM_SEP: #if COMMENT_INVISIBLE - Putstring(global, "/**/"); + fpp_Putstring(global, "/**/"); #else - Putchar(global, ' '); + fpp_Putchar(global, ' '); #endif break; case TOK_SEP: - Putstring(global, "##"); + fpp_Putstring(global, "##"); break; default: { /* Octal output! */ char buffer[32]; sprintf(buffer, "\\0%o", c); - Putstring(global, buffer); + fpp_Putstring(global, buffer); } } } } - Putchar(global, '\n'); + fpp_Putchar(global, '\n'); } /* * G E T */ -int get(struct Global *global) +int fpp_get(struct Global *global) { /* * Return the next character from a macro or the current file. @@ -783,12 +786,12 @@ int get(struct Global *global) if ((global->infile = file->parent) != NULL) { /* * There is an "ungotten" newline in the current - * infile buffer (set there by doinclude() in + * infile buffer (set there by fpp_doinclude() in * cpp1.c). Thus, we know that the mainline code * is skipping over blank lines and will do a * #line at its convenience. */ - global->wrongline = TRUE; /* Need a #line now */ + global->wrongline = FPP_TRUE; /* Need a #line now */ } } } @@ -825,13 +828,13 @@ int get(struct Global *global) if (global->instring) /* Strings just return */ return (c); /* the character. */ else if (c == '/') { /* Comment? */ - global->instring = TRUE; /* So get() won't loop */ + global->instring = FPP_TRUE; /* So fpp_get() won't loop */ /* Check next byte for '*' and if(cplusplus) also '/' */ - if ( (c = get(global)) != '*' ) + if ( (c = fpp_get(global)) != '*' ) if(!global->cplusplus || (global->cplusplus && c!='/')) { - global->instring = FALSE; /* Nope, no comment */ - unget(global); /* Push the char. back */ + global->instring = FPP_FALSE; /* Nope, no comment */ + fpp_unget(global); /* Push the char. back */ return ('/'); /* Return the slash */ } @@ -839,49 +842,49 @@ int get(struct Global *global) if (global->keepcomments) { /* If writing comments */ - global->comment = TRUE; /* information that a comment has been output */ + global->comment = FPP_TRUE; /* information that a comment has been output */ if(global->showspace) { /* Show all whitespaces! */ global->spacebuf[global->chpos] = '\0'; - Putstring(global, global->spacebuf); + fpp_Putstring(global, global->spacebuf); } if(c=='*') { - Putchar(global, '/'); /* Write out the */ - Putchar(global, '*'); /* initializer */ + fpp_Putchar(global, '/'); /* Write out the */ + fpp_Putchar(global, '*'); /* initializer */ } else { /* C++ style comment */ - Putchar(global, '/'); /* Write out the */ - Putchar(global, '/'); /* initializer */ + fpp_Putchar(global, '/'); /* Write out the */ + fpp_Putchar(global, '/'); /* initializer */ } } if(global->cplusplus && c=='/') { /* Eat C++ comment! */ do { - c=get(global); + c=fpp_get(global); if(global->keepcomments) - Putchar(global, c); + fpp_Putchar(global, c); } while(c!='\n' && c!=EOF_CHAR); /* eat all to EOL or EOF */ - global->instring = FALSE; /* End of comment */ + global->instring = FPP_FALSE; /* End of comment */ return(c); /* Return the end char */ } for (;;) { /* Eat a comment */ - c = get(global); + c = fpp_get(global); test: if (global->keepcomments && c != EOF_CHAR) - Putchar(global, c); + fpp_Putchar(global, c); switch (c) { case EOF_CHAR: - cerror(global, ERROR_EOF_IN_COMMENT); + fpp_cerror(global, ERROR_EOF_IN_COMMENT); return (EOF_CHAR); case '/': if(global->nestcomments || global->warnnestcomments) { - if((c = get(global)) != '*') + if((c = fpp_get(global)) != '*') goto test; if(global->warnnestcomments) { - cwarn(global, WARN_NESTED_COMMENT); + fpp_cwarn(global, WARN_NESTED_COMMENT); } if(global->nestcomments) comments++; @@ -889,16 +892,16 @@ int get(struct Global *global) break; case '*': - if ((c = get(global)) != '/') /* If comment doesn't */ + if ((c = fpp_get(global)) != '/') /* If comment doesn't */ goto test; /* end, look at next */ if (global->keepcomments) { /* Put out the comment */ - Putchar(global, c); /* terminator, too */ + fpp_Putchar(global, c); /* terminator, too */ } if(--comments) /* nested comment, continue! */ break; - global->instring = FALSE; /* End of comment, */ + global->instring = FPP_FALSE; /* End of comment, */ /* * A comment is syntactically "whitespace" -- * however, there are certain strange sequences @@ -928,18 +931,18 @@ int get(struct Global *global) case '\n': /* we'll need a #line */ if (!global->keepcomments) - global->wrongline = TRUE; /* later... */ + global->wrongline = FPP_TRUE; /* later... */ default: /* Anything else is */ break; /* Just a character */ } /* End switch */ } /* End comment loop */ } /* End if in comment */ else if (!global->inmacro && c == '\\') { /* If backslash, peek */ - if ((c = get(global)) == '\n') { /* for a . If so, */ - global->wrongline = TRUE; + if ((c = fpp_get(global)) == '\n') { /* for a . If so, */ + global->wrongline = FPP_TRUE; goto newline; } else { /* Backslash anything */ - unget(global); /* Get it later */ + fpp_unget(global); /* Get it later */ return ('\\'); /* Return the backslash */ } } else if (c == '\f' || c == VT) /* Form Feed, Vertical */ @@ -947,20 +950,20 @@ int get(struct Global *global) return (c); /* Just return the char */ } -void unget(struct Global *global) +void fpp_unget(struct Global *global) { /* * Backup the pointer to reread the last character. Fatal error - * (code bug) if we backup too far. unget() may be called, + * (code bug) if we backup too far. fpp_unget() may be called, * without problems, at end of file. Only one character may - * be ungotten. If you need to unget more, call ungetstring(). + * be ungotten. If you need to unget more, call fpp_ungetstring(). */ FILEINFO *file; if ((file = global->infile) == NULL) return; /* Unget after EOF */ if (--file->bptr < file->buffer) { - cfatal(global, FATAL_TOO_MUCH_PUSHBACK); + fpp_cfatal(global, FATAL_TOO_MUCH_PUSHBACK); /* This happens only if used the wrong way! */ return; } @@ -968,7 +971,7 @@ void unget(struct Global *global) --global->line; /* Unget the line number, too */ } -ReturnCode ungetstring(struct Global *global, char *text) +ReturnCode fpp_ungetstring(struct Global *global, char *text) { /* * Push a string back on the input stream. This is done by treating @@ -978,13 +981,13 @@ ReturnCode ungetstring(struct Global *global, char *text) FILEINFO *file; ReturnCode ret; - ret = getfile(global, strlen(text) + 1, "", &file); + ret = fpp_getfile(global, strlen(text) + 1, "", &file); if(!ret) strcpy(file->buffer, text); return(ret); } -int cget(struct Global *global) +int fpp_cget(struct Global *global) { /* * Get one character, absorb "funny space" after comments or @@ -993,7 +996,7 @@ int cget(struct Global *global) int c; do { - c = get(global); + c = fpp_get(global); #if COMMENT_INVISIBLE } while (c == TOK_SEP || c == COM_SEP); #else @@ -1007,7 +1010,7 @@ int cget(struct Global *global) */ INLINE FILE_LOCAL -void domsg(struct Global *global, +void fpp_domsg(struct Global *global, ErrorCode error, /* error message number */ va_list arg) /* Something for the message */ { @@ -1106,8 +1109,8 @@ void domsg(struct Global *global, for (file = global->infile; file && !file->fp; file = file->parent) ; tp = file ? file->filename : 0; - Error(global, "%s\"%s\", line %d: %s: ", - MSG_PREFIX, tp, global->infile?global->line:(file?file->line:0), severity); + fpp_Error(global, "%s\"%s\", line %d: %s: ", + MSG_PREFIX, tp, global->infile->fp?global->line:file->line, severity); if(global->error) global->error(global->userdata, ErrorMessage[error], arg); #if defined(UNIX) @@ -1117,15 +1120,15 @@ void domsg(struct Global *global, else return; #endif - Error(global, "\n"); + fpp_Error(global, "\n"); if (file) /*OIS*0.92*/ while ((file = file->parent) != NULL) { /* Print #includes, too */ tp = file->parent ? "," : "."; if (file->fp == NULL) - Error(global, " from macro %s%s\n", file->filename, tp); + fpp_Error(global, " from macro %s%s\n", file->filename, tp); else - Error(global, " from file %s, line %d%s\n", + fpp_Error(global, " from file %s, line %d%s\n", (file->progname != NULL) ? file->progname : file->filename, file->line, tp); } @@ -1135,7 +1138,7 @@ void domsg(struct Global *global, global->errors++; } -void cerror(struct Global *global, +void fpp_cerror(struct Global *global, ErrorCode message, ...) /* arguments */ { @@ -1144,10 +1147,10 @@ void cerror(struct Global *global, */ va_list arg; va_start(arg, message); - domsg(global, message, arg); + fpp_domsg(global, message, arg); } -void Error(struct Global *global, char *format, ...) +void fpp_Error(struct Global *global, char *format, ...) { /* * Just get the arguments and send a decent string to the user error diff --git a/3rdparty/fcpp/cppadd.h b/3rdparty/fcpp/cppadd.h index 97494861d..a7ed20045 100644 --- a/3rdparty/fcpp/cppadd.h +++ b/3rdparty/fcpp/cppadd.h @@ -67,7 +67,7 @@ struct Global { int errors; /* cpp error counter */ FILEINFO *infile; /* Current input file */ #if DEBUG - int debug; /* TRUE if debugging now */ + int debug; /* FPP_TRUE if debugging now */ #endif /* * This counter is incremented when a macro expansion is initiated. @@ -83,7 +83,7 @@ struct Global { int rec_recover; /* Unwind recursive macros */ /* - * instring is set TRUE when a string is scanned. It modifies the + * instring is set FPP_TRUE when a string is scanned. It modifies the * behavior of the "get next character" routine, causing all characters * to be passed to the caller (except ). Note especially that * comments and \ are not removed from the source. (This @@ -95,17 +95,17 @@ struct Global { * shouldn't delimit tokens, but we'll worry about that some other * time -- it is more important to prevent infinitly long output lines. * - * instring and inmarcor are parameters to the get() routine which + * instring and inmarcor are parameters to the fpp_get() routine which * were made global for speed. */ - int instring; /* TRUE if scanning string */ - int inmacro; /* TRUE if #defining a macro */ + int instring; /* FPP_TRUE if scanning string */ + int inmacro; /* FPP_TRUE if #defining a macro */ /* * work[] and workp are used to store one piece of text in a temporay * buffer. To initialize storage, set workp = work. To store one - * character, call save(c); (This will fatally exit if there isn't - * room.) To terminate the string, call save(EOS). Note that + * character, call fpp_save(c); (This will fatally exit if there isn't + * room.) To terminate the string, call fpp_save(EOS). Note that * the work buffer is used by several subroutines -- be sure your * data won't be overwritten. The extra byte in the allocation is * needed for string formal replacement. @@ -114,7 +114,7 @@ struct Global { char *workp; /* Work buffer pointer */ /* - * keepcomments is set TRUE by the -C option. If TRUE, comments + * keepcomments is set FPP_TRUE by the -C option. If FPP_TRUE, comments * are written directly to the output stream. This is needed if * the output from cpp is to be passed to lint (which uses commands * embedded in comments). cflag contains the permanent state of the @@ -138,10 +138,10 @@ struct Global { * ifstack[] holds information about nested #if's. It is always * accessed via *ifptr. The information is as follows: * WAS_COMPILING state of compiling flag at outer level. - * ELSE_SEEN set TRUE when #else seen to prevent 2nd #else. - * TRUE_SEEN set TRUE when #if or #elif succeeds - * ifstack[0] holds the compiling flag. It is TRUE if compilation - * is currently enabled. Note that this must be initialized TRUE. + * ELSE_SEEN set FPP_TRUE when #else seen to prevent 2nd #else. + * FPP_TRUE_SEEN set FPP_TRUE when #if or #elif succeeds + * ifstack[0] holds the compiling flag. It is FPP_TRUE if compilation + * is currently enabled. Note that this must be initialized FPP_TRUE. */ char ifstack[BLK_NEST]; /* #if information */ char *ifptr; /* -> current ifstack[] */ @@ -158,7 +158,7 @@ struct Global { */ char *include[NINCLUDE]; char includeshow[NINCLUDE]; /* show it or not! */ - char included; + unsigned included; /* * This is the table used to predefine target machine and operating @@ -176,7 +176,7 @@ struct Global { /* * This is the variable saying if Cpp should remove C++ style comments from - * the output. Default is... TRUE, yes, pronto, do it!!! + * the output. Default is... FPP_TRUE, yes, pronto, do it!!! */ char cplusplus; @@ -197,7 +197,7 @@ struct Global { DEFBUF *symtab[SBSIZE]; /* Symbol table queue headers */ - int evalue; /* Current value from evallex() */ + int evalue; /* Current value from fpp_evallex() */ void (*depends)(char *filename, void *); /* depends function */ @@ -225,7 +225,7 @@ struct Global { char showspace; /* display all whitespaces as they are */ - char comment; /* TRUE if a comment just has been written to output */ + char comment; /* FPP_TRUE if a comment just has been written to output */ char *spacebuf; /* Buffer to store whitespaces in if -H */ @@ -242,7 +242,7 @@ struct Global { char out; /* should we output anything now? */ char rightconcat; /* should the right part of a concatenation be avaluated - before the concat (TRUE) or after (FALSE) */ + before the concat (FPP_TRUE) or after (FPP_FALSE) */ char *initialfunc; /* file to include first in all functions */ char *excludedinit[20]; /* functions (names) excluded from the initfunc */ @@ -251,6 +251,10 @@ struct Global { char outputfunctions; /* output all discovered functions to stderr! */ char webmode; /* WWW process mode */ + + char allowincludelocal; + + FILE* (*openfile)(char *,char *, void *); }; typedef enum { @@ -359,56 +363,56 @@ typedef enum { } ReturnCode; /* Nasty defines to make them appear as three different functions! */ -#define cwarn cerror -#define cfatal cerror +#define fpp_cwarn fpp_cerror +#define fpp_cfatal fpp_cerror /********************************************************************** * PROTOTYPES: *********************************************************************/ int PREFIX fppPreProcess(REG(a0) struct fppTag *); -void Freemem(void *); -void Error(struct Global *, char *, ...); -void Putchar(struct Global *, int); -void Putstring(struct Global *, char *); -void Putint(struct Global *, int); -char *savestring(struct Global *, char *); -ReturnCode addfile(struct Global *, FILE *, char *); -int catenate(struct Global *, ReturnCode *); -void cerror(struct Global *, ErrorCode, ...); -ReturnCode control(struct Global *, int *); -ReturnCode dodefine(struct Global *); -int dooptions(struct Global *, struct fppTag *); -void doundef(struct Global *); -void dumpparm(char *); -ReturnCode expand(struct Global *, DEFBUF *); -int get(struct Global *); -ReturnCode initdefines(struct Global *); -void outdefines(struct Global *); -ReturnCode save(struct Global *, int); -void scanid(struct Global *, int); -ReturnCode scannumber(struct Global *, int, ReturnCode(*)(struct Global *, int)); -ReturnCode scanstring(struct Global *, int, ReturnCode(*)(struct Global *, int)); -void unget(struct Global *); -ReturnCode ungetstring(struct Global *, char *); -ReturnCode eval(struct Global *, int *); +void fpp_Freemem(void *); +void fpp_Error(struct Global *, char *, ...); +void fpp_Putchar(struct Global *, int); +void fpp_Putstring(struct Global *, char *); +void fpp_Putint(struct Global *, int); +char *fpp_savestring(struct Global *, char *); +ReturnCode fpp_addfile(struct Global *, FILE *, char *); +int fpp_catenate(struct Global *, int lhs_number, ReturnCode *); +void fpp_cerror(struct Global *, ErrorCode, ...); +ReturnCode fpp_control(struct Global *, int *); +ReturnCode fpp_dodefine(struct Global *); +int fpp_dooptions(struct Global *, struct fppTag *); +void fpp_doundef(struct Global *); +void fpp_dumpparm(char *); +ReturnCode fpp_expand(struct Global *, DEFBUF *); +int fpp_get(struct Global *); +ReturnCode fpp_initdefines(struct Global *); +void fpp_outdefines(struct Global *); +ReturnCode fpp_save(struct Global *, int); +void fpp_scanid(struct Global *, int); +ReturnCode fpp_scannumber(struct Global *, int, ReturnCode(*)(struct Global *, int)); +ReturnCode fpp_scanstring(struct Global *, int, ReturnCode(*)(struct Global *, int)); +void fpp_unget(struct Global *); +ReturnCode fpp_ungetstring(struct Global *, char *); +ReturnCode fpp_eval(struct Global *, int *); #ifdef DEBUG_EVAL -void dumpstack(OPTAB[NEXP], register OPTAB *, int [NEXP], register int *); +void fpp_dumpstack(OPTAB[NEXP], register OPTAB *, int [NEXP], register int *); #endif -void skipnl(struct Global *); -int skipws(struct Global *); -ReturnCode macroid(struct Global *, int *); -ReturnCode getfile(struct Global *, size_t, char *, FILEINFO **); -DEFBUF *lookid(struct Global *, int ); -DEFBUF *defendel(struct Global *, char *, int); +void fpp_skipnl(struct Global *); +int fpp_skipws(struct Global *); +ReturnCode fpp_macroid(struct Global *, int *); +ReturnCode fpp_getfile(struct Global *, size_t, char *, FILEINFO **); +DEFBUF *fpp_lookid(struct Global *, int ); +DEFBUF *fpp_defendel(struct Global *, char *, int); #if DEBUG -void dumpdef(char *); -void dumpadef(char *, register DEFBUF *); +void fpp_dumpdef(char *); +void fpp_dumpadef(char *, register DEFBUF *); #endif -ReturnCode openfile(struct Global *,char *); -int cget(struct Global *); -void delbuiltindefines(struct Global *); -void delalldefines(struct Global *); -char *Getmem(struct Global *, int); -ReturnCode openinclude(struct Global *, char *, int); -ReturnCode expstuff(struct Global *, char *, char *); +ReturnCode fpp_openfile(struct Global *,char *); +int fpp_cget(struct Global *); +void fpp_delbuiltindefines(struct Global *); +void fpp_delalldefines(struct Global *); +char *fpp_Getmem(struct Global *, int); +ReturnCode fpp_openinclude(struct Global *, char *, int); +ReturnCode fpp_expstuff(struct Global *, char *, char *); diff --git a/3rdparty/fcpp/cppdef.h b/3rdparty/fcpp/cppdef.h index c188a2240..26ba17bfc 100644 --- a/3rdparty/fcpp/cppdef.h +++ b/3rdparty/fcpp/cppdef.h @@ -35,9 +35,9 @@ /* Convert Emacs's conventions for BIG_ENDIAN to cpp's convention. */ #ifdef BIG_ENDIAN #undef BIG_ENDIAN -#define BIG_ENDIAN TRUE +#define BIG_ENDIAN FPP_TRUE #else /* not BIG_ENDIAN */ -#define BIG_ENDIAN FALSE +#define BIG_ENDIAN FPP_FALSE #endif /* BIG_ENDIAN */ /* Emacs uses the names index and rindex and defines them as str(r)chr if nec; @@ -73,12 +73,12 @@ */ /* - * This redundant definition of TRUE and FALSE works around + * This redundant definition of FPP_TRUE and FPP_FALSE works around * a limitation of Decus C. */ -#ifndef TRUE -#define TRUE 1 -#define FALSE 0 +#ifndef FPP_TRUE +#define FPP_TRUE 1 +#define FPP_FALSE 0 #endif /* @@ -134,27 +134,27 @@ * to be marked "static" even though they are referenced * by "extern" statements elsewhere. * - * OK_DOLLAR Should be set TRUE if $ is a valid alphabetic character + * OK_DOLLAR Should be set FPP_TRUE if $ is a valid alphabetic character * in identifiers (default), or zero if $ is invalid. - * Default is TRUE. + * Default is FPP_TRUE. * - * OK_CONCAT Should be set TRUE if # may be used to concatenate + * OK_CONCAT Should be set FPP_TRUE if # may be used to concatenate * tokens in macros (per the Ansi Draft Standard) or - * FALSE for old-style # processing (needed if cpp is + * FPP_FALSE for old-style # processing (needed if cpp is * to process assembler source code). */ -#define OK_CONCAT TRUE +#define OK_CONCAT FPP_TRUE /* - * OK_DATE Predefines the compilation date if set TRUE. + * OK_DATE Predefines the compilation date if set FPP_TRUE. * Not permitted by the Nov. 12, 1984 Draft Standard. */ -#define OK_DATE TRUE +#define OK_DATE FPP_TRUE /* * * OK_SIZEOF Permits sizeof in #if preprocessor expressions. * According to K&R V2 (page 232), this is not allowed. */ -#define OK_SIZEOF TRUE +#define OK_SIZEOF FPP_TRUE /* * S_CHAR etc. Define the sizeof the basic TARGET machine word types. * By default, sizes are set to the values for the HOST @@ -188,9 +188,9 @@ */ #if OLD_PREPROCESSOR -#define OK_DOLLAR FALSE -#define OK_CONCAT FALSE -#define COMMENT_INVISIBLE TRUE +#define OK_DOLLAR FPP_FALSE +#define OK_CONCAT FPP_FALSE +#define COMMENT_INVISIBLE FPP_TRUE #endif /* @@ -209,15 +209,15 @@ #endif /* - * BIG_ENDIAN is set TRUE on machines (such as the IBM 360 series) + * BIG_ENDIAN is set FPP_TRUE on machines (such as the IBM 360 series) * where 'ab' stores 'a' in the high-bits and 'b' in the low-bits. - * It is set FALSE on machines (such as the PDP-11 and Vax-11) + * It is set FPP_FALSE on machines (such as the PDP-11 and Vax-11) * where 'ab' stores 'a' in the low-bits and 'b' in the high-bits. * (Or is it the other way around?) -- Warning: BIG_ENDIAN code is untested. * [I *seems* to be the other way around, according to the code /OIS] */ #ifndef BIG_ENDIAN -#define BIG_ENDIAN FALSE +#define BIG_ENDIAN FPP_FALSE #endif /* @@ -227,27 +227,27 @@ * expansions. This was removed from the Draft Ansi Standard. */ #ifndef COMMENT_INVISIBLE -#define COMMENT_INVISIBLE FALSE +#define COMMENT_INVISIBLE FPP_FALSE #endif /* * OK_DOLLAR enables use of $ as a valid "letter" in identifiers. * This is a permitted extension to the Ansi Standard and is required - * for e.g., VMS, RSX-11M, etc. It should be set FALSE if cpp is + * for e.g., VMS, RSX-11M, etc. It should be set FPP_FALSE if cpp is * used to preprocess assembler source on Unix systems. OLD_PREPROCESSOR - * sets OK_DOLLAR FALSE for that reason. + * sets OK_DOLLAR FPP_FALSE for that reason. */ #ifndef OK_DOLLAR -#define OK_DOLLAR TRUE +#define OK_DOLLAR FPP_TRUE #endif /* * OK_CONCAT enables (one possible implementation of) token concatenation. * If cpp is used to preprocess Unix assembler source, this should be - * set FALSE as the concatenation character, #, is used by the assembler. + * set FPP_FALSE as the concatenation character, #, is used by the assembler. */ #ifndef OK_CONCAT -#define OK_CONCAT TRUE +#define OK_CONCAT FPP_TRUE #endif /* @@ -256,7 +256,7 @@ * by the Draft Ansi Standard. */ #ifndef OK_DATE -#define OK_DATE TRUE +#define OK_DATE FPP_TRUE #endif /* @@ -267,7 +267,7 @@ * This option was added in the PDC process, under no. *OIS*0.92*. */ #ifndef OK_SIZEOF -#define OK_SIZEOF FALSE +#define OK_SIZEOF FPP_FALSE #endif /* @@ -275,7 +275,7 @@ */ #ifndef DEBUG -#define DEBUG FALSE +#define DEBUG FPP_FALSE #endif /* diff --git a/3rdparty/fcpp/fpp.h b/3rdparty/fcpp/fpp.h index fe25ac522..5fdcd23f6 100644 --- a/3rdparty/fcpp/fpp.h +++ b/3rdparty/fcpp/fpp.h @@ -35,18 +35,21 @@ * */ +#ifdef __cplusplus +extern "C" { +#endif struct fppTag { int tag; void *data; }; -#ifndef TRUE -#define TRUE 1 +#ifndef FPP_TRUE +#define FPP_TRUE 1 #endif -#ifndef FALSE -#define FALSE 0 +#ifndef FPP_FALSE +#define FPP_FALSE 0 #endif #define NFLAG_BUILTIN 1 @@ -56,26 +59,26 @@ struct fppTag { #define FPPTAG_END 0 /* To make the preprocessed output keep the comments: */ -#define FPPTAG_KEEPCOMMENTS 1 /* data is TRUE or FALSE */ +#define FPPTAG_KEEPCOMMENTS 1 /* data is FPP_TRUE or FPP_FALSE */ /* To define symbols to the preprocessor: */ #define FPPTAG_DEFINE 2 /* data is the string "symbol" or "symbol=" */ /* To make the preprocessor ignore all non-fatal errors: */ -#define FPPTAG_IGNORE_NONFATAL 3 /* data is TRUE or FALSE */ +#define FPPTAG_IGNORE_NONFATAL 3 /* data is FPP_TRUE or FPP_FALSE */ /* To add an include directory to the include directory list: */ #define FPPTAG_INCLUDE_DIR 4 /* data is directory name ending with a '/' (on amiga a ':' is also valid) */ -/* To define all machine specific built-in #defines, default is TRUE: */ -#define FPPTAG_BUILTINS 5 /* data is TRUE or FALSE */ +/* To define all machine specific built-in #defines, default is FPP_TRUE: */ +#define FPPTAG_BUILTINS 5 /* data is FPP_TRUE or FPP_FALSE */ -/* To define predefines like __LINE__, __DATE__, etc. default is TRUE: */ -#define FPPTAG_PREDEFINES 6 /* data is TRUE or FALSE */ +/* To define predefines like __LINE__, __DATE__, etc. default is FPP_TRUE: */ +#define FPPTAG_PREDEFINES 6 /* data is FPP_TRUE or FPP_FALSE */ /* To make fpp leave C++ comments in the output: */ -#define FPPTAG_IGNORE_CPLUSPLUS 7 /* data is TRUE or FALSE */ +#define FPPTAG_IGNORE_CPLUSPLUS 7 /* data is FPP_TRUE or FPP_FALSE */ /* To define new sizes to #if sizeof: */ #define FPPTAG_SIZEOF_TABLE 8 /* data is sizeof table string */ @@ -84,7 +87,7 @@ struct fppTag { #define FPPTAG_UNDEFINE 9 /* data is symbol name */ /* Output all #defines: */ -#define FPPTAG_OUTPUT_DEFINES 10 /* data is TRUE or FALSE */ +#define FPPTAG_OUTPUT_DEFINES 10 /* data is FPP_TRUE or FPP_FALSE */ /* Initial input file name: */ #define FPPTAG_INPUT_NAME 11 /* data is string */ @@ -98,42 +101,42 @@ struct fppTag { /* User data, sent in the last argument to the input function: */ #define FPPTAG_USERDATA 14 /* data is user data */ -/* Whether to exclude #line instructions in the output, default is FALSE */ -#define FPPTAG_LINE 15 /* data is TRUE or FALSE */ +/* Whether to exclude #line instructions in the output, default is FPP_FALSE */ +#define FPPTAG_LINE 15 /* data is FPP_TRUE or FPP_FALSE */ /* Error function. This is called when FPP finds any warning/error/fatal: */ #define FPPTAG_ERROR 16 /* data is function pointer to a "void (*)(void *, char *, va_list)" */ /* Whether to warn for illegal cpp instructions */ -#define FPPTAG_WARNILLEGALCPP 17 /* data is boolean, default is FALSE */ +#define FPPTAG_WARNILLEGALCPP 17 /* data is boolean, default is FPP_FALSE */ /* Output the 'line' keyword on #line-lines? */ -#define FPPTAG_OUTPUTLINE 18 /* data is boolean, default is TRUE */ +#define FPPTAG_OUTPUTLINE 18 /* data is boolean, default is FPP_TRUE */ -/* Do not output the version information string */ -#define FPPTAG_IGNOREVERSION 19 /* data is boolean, default is FALSE */ +/* Output the version information string */ +#define FPPTAG_SHOWVERSION 19 /* data is boolean, default is FPP_TRUE */ /* Output all included file names to stderr */ -#define FPPTAG_OUTPUTINCLUDES 20 /* data is boolean, default is FALSE */ +#define FPPTAG_OUTPUTINCLUDES 20 /* data is boolean, default is FPP_FALSE */ /* Display warning if there is any brace, bracket or parentheses unbalance */ -#define FPPTAG_OUTPUTBALANCE 21 /* data is boolean, default is FALSE */ +#define FPPTAG_OUTPUTBALANCE 21 /* data is boolean, default is FPP_FALSE */ /* Display all whitespaces in the source */ -#define FPPTAG_OUTPUTSPACE 22 /* data is boolean, default is FALSE */ +#define FPPTAG_OUTPUTSPACE 22 /* data is boolean, default is FPP_FALSE */ /* Allow nested comments */ -#define FPPTAG_NESTED_COMMENTS 23 /* data is boolean, default is FALSE */ +#define FPPTAG_NESTED_COMMENTS 23 /* data is boolean, default is FPP_FALSE */ /* Enable warnings at nested comments */ -#define FPPTAG_WARN_NESTED_COMMENTS 24 /* data is boolean, default is FALSE */ +#define FPPTAG_WARN_NESTED_COMMENTS 24 /* data is boolean, default is FPP_FALSE */ /* Enable warnings at missing includes */ -#define FPPTAG_WARNMISSINCLUDE 25 /* data is boolean, default is TRUE */ +#define FPPTAG_WARNMISSINCLUDE 25 /* data is boolean, default is FPP_TRUE */ /* Output the main file */ -#define FPPTAG_OUTPUTMAIN 26 /* data is boolean, default is TRUE */ +#define FPPTAG_OUTPUTMAIN 26 /* data is boolean, default is FPP_TRUE */ /* Include file */ #define FPPTAG_INCLUDE_FILE 27 /* data is char pointer */ @@ -142,7 +145,7 @@ struct fppTag { #define FPPTAG_INCLUDE_MACRO_FILE 28 /* data is char pointer */ /* Evaluate the right part of a concatenate before the concat */ -#define FPPTAG_RIGHTCONCAT 29 /* data is boolean, default is FALSE */ +#define FPPTAG_RIGHTCONCAT 29 /* data is boolean, default is FPP_FALSE */ /* Include the specified file at the beginning of each function */ #define FPPTAG_INITFUNC 30 /* data is char pointer or NULL */ @@ -159,4 +162,15 @@ struct fppTag { /* Depends function: */ #define FPPTAG_DEPENDS 34 /* data is an depends funtion */ +/* Allow include "X" (rather than ) to search local files, default is FPP_TRUE */ +#define FPPTAG_ALLOW_INCLUDE_LOCAL 35 + +/* Fileopen function. If set, this is called when FPP tries to open a file: */ +#define FPPTAG_FILEOPENFUNC 36 /* data is function pointer to a + "FILE* (*)(char * filename, char * mode, void * userdata)", default is NULL */ + int fppPreProcess(struct fppTag *); + +#ifdef __cplusplus +} // extern "C" +#endif diff --git a/3rdparty/fcpp/usecpp.c b/3rdparty/fcpp/usecpp.c index 3611ed247..0134d3c50 100644 --- a/3rdparty/fcpp/usecpp.c +++ b/3rdparty/fcpp/usecpp.c @@ -128,8 +128,8 @@ FILE_LOCAL char DoString(struct fppTag **, char *); extern long __stack=8000; #endif -FILE_LOCAL char ignore=FALSE; /* if we should ignore strange flags! */ -FILE_LOCAL char display=FALSE; /* display all options in use! */ +FILE_LOCAL char ignore=FPP_FALSE; /* if we should ignore strange flags! */ +FILE_LOCAL char display=FPP_FALSE; /* display all options in use! */ FILE_LOCAL char dontreadprefs; /* set if only the command line is valid */ @@ -369,37 +369,37 @@ int SetOptions(int argc, char **argv, struct fppTag **tagptr) case 'H': /* display all whitespaces */ (*tagptr)->tag = FPPTAG_OUTPUTSPACE; - (*tagptr)->data= (void *)TRUE; + (*tagptr)->data= (void *)FPP_TRUE; (*tagptr)++; break; case 'b': /* display unbalance */ (*tagptr)->tag = FPPTAG_OUTPUTBALANCE; - (*tagptr)->data= (void *)TRUE; + (*tagptr)->data= (void *)FPP_TRUE; (*tagptr)++; break; case 'f': /* output all defined functions! */ (*tagptr)->tag = FPPTAG_DISPLAYFUNCTIONS; - (*tagptr)->data= (void *)TRUE; + (*tagptr)->data= (void *)FPP_TRUE; (*tagptr)++; break; case 'F': /* output all included files! */ (*tagptr)->tag = FPPTAG_OUTPUTINCLUDES; - (*tagptr)->data= (void *)TRUE; + (*tagptr)->data= (void *)FPP_TRUE; (*tagptr)++; break; case 'V': /* do not output version */ - (*tagptr)->tag = FPPTAG_IGNOREVERSION; - (*tagptr)->data= (void *)FALSE; + (*tagptr)->tag = FPPTAG_SHOWVERSION; + (*tagptr)->data= (void *)FPP_FALSE; (*tagptr)++; break; case 'C': /* Keep comments */ (*tagptr)->tag = FPPTAG_KEEPCOMMENTS; - (*tagptr)->data= (void *)TRUE; + (*tagptr)->data= (void *)FPP_TRUE; (*tagptr)++; break; @@ -411,12 +411,12 @@ int SetOptions(int argc, char **argv, struct fppTag **tagptr) case 'd': /* Display all options */ fprintf(stderr, "FOUND -d flag!\n"); - display = TRUE; + display = FPP_TRUE; break; case 'E': /* Ignore non-fatal errors */ (*tagptr)->tag=FPPTAG_IGNORE_NONFATAL; - (*tagptr)->data=(void *)TRUE; + (*tagptr)->data=(void *)FPP_TRUE; (*tagptr)++; break; @@ -445,13 +445,13 @@ int SetOptions(int argc, char **argv, struct fppTag **tagptr) /* Do not output the 'line' keyword */ (*tagptr)->tag=FPPTAG_OUTPUTLINE; } - (*tagptr)->data=(void *)FALSE; + (*tagptr)->data=(void *)FPP_FALSE; (*tagptr)++; break; case 'M': /* Do not warn at missing includes */ (*tagptr)->tag=FPPTAG_WARNMISSINCLUDE; - (*tagptr)->data=(void *)FALSE; + (*tagptr)->data=(void *)FPP_FALSE; (*tagptr)++; break; @@ -466,31 +466,31 @@ int SetOptions(int argc, char **argv, struct fppTag **tagptr) case 'N': /* No machine specific built-ins */ (*tagptr)->tag=FPPTAG_BUILTINS; - (*tagptr)->data=(void *)FALSE; + (*tagptr)->data=(void *)FPP_FALSE; (*tagptr)++; break; case 'B': /* No predefines like __LINE__, etc. */ (*tagptr)->tag=FPPTAG_PREDEFINES; - (*tagptr)->data=(void *)FALSE; + (*tagptr)->data=(void *)FPP_FALSE; (*tagptr)++; break; case 'P': /* No C++ comments */ (*tagptr)->tag=FPPTAG_IGNORE_CPLUSPLUS; - (*tagptr)->data=(void *)TRUE; + (*tagptr)->data=(void *)FPP_TRUE; (*tagptr)++; break; case 'p': /* warn about illegal # - instructions */ (*tagptr)->tag = FPPTAG_WARNILLEGALCPP; - (*tagptr)->data= (void *)TRUE; + (*tagptr)->data= (void *)FPP_TRUE; (*tagptr)++; break; case 'R': (*tagptr)->tag = FPPTAG_RIGHTCONCAT; - (*tagptr)->data= (void *)TRUE; + (*tagptr)->data= (void *)FPP_TRUE; (*tagptr)++; break; @@ -521,18 +521,18 @@ int SetOptions(int argc, char **argv, struct fppTag **tagptr) case 'w': /* Output all #defines but not the main file */ (*tagptr)->tag=FPPTAG_OUTPUTMAIN; - (*tagptr)->data=(void *)FALSE; + (*tagptr)->data=(void *)FPP_FALSE; (*tagptr)++; case 'W': /* Output all #defines */ if(!strncmp(ap, "WW", 2)) { (*tagptr)->tag=FPPTAG_WEBMODE; - (*tagptr)->data=(void *)TRUE; + (*tagptr)->data=(void *)FPP_TRUE; (*tagptr)++; } else { (*tagptr)->tag=FPPTAG_OUTPUT_DEFINES; - (*tagptr)->data=(void *)TRUE; + (*tagptr)->data=(void *)FPP_TRUE; (*tagptr)++; } break; diff --git a/tools/shaderc/shaderc.cpp b/tools/shaderc/shaderc.cpp index f10f42718..6bfc8962a 100644 --- a/tools/shaderc/shaderc.cpp +++ b/tools/shaderc/shaderc.cpp @@ -558,7 +558,7 @@ namespace bgfx m_tagptr->data = (void*)fppError; m_tagptr++; - m_tagptr->tag = FPPTAG_IGNOREVERSION; + m_tagptr->tag = FPPTAG_SHOWVERSION; m_tagptr->data = (void*)0; m_tagptr++;