summaryrefslogtreecommitdiff
path: root/rsc/source
diff options
context:
space:
mode:
authorNorbert Thiebaud <nthiebaud@gmail.com>2014-10-04 00:20:18 -0500
committerNorbert Thiebaud <nthiebaud@gmail.com>2014-10-04 08:58:12 -0500
commit0091f937116550a9f5e30bf200f536701cc0b068 (patch)
treedfc9c7d5a2010325d469bf86e4a4fd174863c779 /rsc/source
parent9b401751a8a8b96cfe9f85eefce1173fe4cabe6f (diff)
cosmetic: start bringing rscpp in this century c-wise
Change-Id: I469bc4c518c3ac299a18559cdd3e1b49d34b5ace
Diffstat (limited to 'rsc/source')
-rw-r--r--rsc/source/rscpp/cpp.h167
-rw-r--r--rsc/source/rscpp/cpp2.c719
-rw-r--r--rsc/source/rscpp/cpp3.c489
-rw-r--r--rsc/source/rscpp/cpp4.c735
-rw-r--r--rsc/source/rscpp/cpp5.c562
-rw-r--r--rsc/source/rscpp/cpp6.c1416
6 files changed, 2153 insertions, 1935 deletions
diff --git a/rsc/source/rscpp/cpp.h b/rsc/source/rscpp/cpp.h
index 7f453756e61e..1a9f5c6a9841 100644
--- a/rsc/source/rscpp/cpp.h
+++ b/rsc/source/rscpp/cpp.h
@@ -26,10 +26,10 @@
#endif
/* in cpp1.c: file-pointer auf stdout oder file */
-extern FILE *pCppOut; /* BP */
+extern FILE* pCppOut; /* BP */
#define PUTCHAR( d ) fprintf( pCppOut, "%c", (d) ) /* BP */
#if OSL_DEBUG_LEVEL > 1
-extern FILE *pDefOut; /* ER */
+extern FILE* pDefOut; /* ER */
#ifdef EVALDEFS
#define NEVALBUF 2048
#endif
@@ -164,12 +164,13 @@ extern FILE *pDefOut; /* ER */
* in malloc storage.
*/
-typedef struct defbuf {
- struct defbuf *link; /* Next define in chain */
- char *repl; /* -> replacement */
- int hash; /* Symbol table hash */
- int nargs; /* For define(args) */
- char name[1]; /* #define name */
+typedef struct defbuf
+{
+ struct defbuf* link; /* Next define in chain */
+ char* repl; /* -> replacement */
+ int hash; /* Symbol table hash */
+ int nargs; /* For define(args) */
+ char name[1]; /* #define name */
} DEFBUF;
/*
@@ -177,22 +178,24 @@ typedef struct defbuf {
* and macros being expanded.
*/
-typedef struct fileinfo {
- char *bptr; /* Buffer pointer */
- int line; /* for include or macro */
- FILE *fp; /* File if non-null */
- struct fileinfo *parent; /* Link to includer */
- char *filename; /* File/macro name */
- char *progname; /* From #line statement */
- unsigned int unrecur; /* For macro recursion */
- char buffer[1]; /* current input line */
+typedef struct fileinfo
+{
+ char* bptr; /* Buffer pointer */
+ int line; /* for include or macro */
+ FILE* fp; /* File if non-null */
+ struct fileinfo* parent; /* Link to includer */
+ char* filename; /* File/macro name */
+ char* progname; /* From #line statement */
+ unsigned int unrecur; /* For macro recursion */
+ char buffer[1]; /* current input line */
} FILEINFO;
/*
* The SIZES structure is used to store the values for #if sizeof
*/
-typedef struct sizes {
+typedef struct sizes
+{
short bits; /* If this bit is set, */
int size; /* this is the datum size value */
int psize; /* this is the pointer size */
@@ -204,8 +207,8 @@ typedef struct sizes {
/*
* Error codes.
*/
-#define IO_NORMAL 0
-#define IO_ERROR 1
+#define IO_NORMAL 0
+#define IO_ERROR 1
/*
* Externs
@@ -221,18 +224,18 @@ extern int errors; /* Error counter */
extern int recursion; /* Macro depth counter */
extern char ifstack[BLK_NEST]; /* #if information */
#define compiling ifstack[0]
-extern char *ifptr; /* -> current ifstack item */
-extern char *incdir[NINCLUDE]; /* -i directories */
-extern char **incend; /* -> active end of incdir */
+extern char* ifptr; /* -> current ifstack item */
+extern char* incdir[NINCLUDE]; /* -i directories */
+extern char** incend; /* -> active end of incdir */
extern int cflag; /* -C option (keep comments) */
extern int eflag; /* -E option (ignore errors) */
extern int nflag; /* -N option (no pre-defines) */
extern int rec_recover; /* unwind recursive macros */
-extern char *preset[]; /* Standard predefined symbols */
-extern char *magic[]; /* Magic predefined symbols */
-extern FILEINFO *infile; /* Current input file */
+extern char* preset[]; /* Standard predefined symbols */
+extern char* magic[]; /* Magic predefined symbols */
+extern FILEINFO* infile; /* Current input file */
extern char work[NWORK + 1]; /* #define scratch */
-extern char *workp; /* Free space in work */
+extern char* workp; /* Free space in work */
#if OSL_DEBUG_LEVEL > 1
extern int debug; /* Debug level */
/* ER dump & evaluate #define's */
@@ -260,12 +263,12 @@ int rscpp_main( int argc, char **argv );
#endif
-void InitCpp1(void);
-void InitCpp2(void);
-void InitCpp3(void);
-void InitCpp4(void);
-void InitCpp5(void);
-void InitCpp6(void);
+void InitCpp1( void );
+void InitCpp2( void );
+void InitCpp3( void );
+void InitCpp4( void );
+void InitCpp5( void );
+void InitCpp6( void );
#define HELLO() fprintf( stderr, "[Hello at %s, %d] ", __FILE__, __LINE__ )
@@ -275,8 +278,8 @@ void InitCpp6(void);
/* cpp1.c */
void output( int c );
-void sharp(void);
-void cppmain(void);
+void sharp( void );
+void cppmain( void );
#if OSL_DEBUG_LEVEL > 1
#ifdef EVALDEFS
int outputEval( int c );
@@ -286,79 +289,79 @@ int outputEval( int c );
/* cpp2.c */
int control( int counter );
-void doinclude(void);
-void dodefine(void);
+void doinclude( void );
+void dodefine( void );
void doif( int hash );
-int openinclude( char *, int );
-int hasdirectory(char *, char * );
-int openfile( char * );
+int openinclude( char*, int );
+int hasdirectory( char*, char* );
+int openfile( char* );
/* cpp3.c */
-int openfiles( char *filename );
-void addfile( FILE *fp, char *filename );
-void setincdirs(void);
-int AddInclude( char *pIncStr );
-int getredirection( int argc, char **argv );
-void zap_uc( char *ap );
+int openfiles( char* filename );
+void addfile( FILE* fp, char* filename );
+void setincdirs( void );
+int AddInclude( char* pIncStr );
+int getredirection( int argc, char** argv );
+void zap_uc( char* ap );
-void initdefines(void);
-int dooptions( int argc, char *argv[] );
-int readoptions(char* filename, char*** pfargv);
+void initdefines( void );
+int dooptions( int argc, char* argv[] );
+int readoptions( char* filename, char*** pfargv );
/* cpp4.c */
-void dodefines(void);
-void checkparm( int c, DEFBUF *dp );
-int expcollect(void);
-void expstuff( DEFBUF *dp );
+void dodefines( void );
+void checkparm( int c, DEFBUF* dp );
+int expcollect( void );
+void expstuff( DEFBUF* dp );
-void stparmscan( int delim);
+void stparmscan( int delim );
#if OSL_DEBUG_LEVEL > 1
-void dumpparm( char *why );
+void dumpparm( char* why );
#endif
-void doundef(void);
-void textput( char *text );
+void doundef( void );
+void textput( char* text );
void charput( int c );
-void expand( DEFBUF *tokenp );
+void expand( DEFBUF* tokenp );
/* cpp5.c */
-int eval(void);
-int evallex(int);
-int *evaleval(int *, int, int );
-int evalchar(int);
-int dosizeof(void);
+int eval( void );
+int evallex( int );
+int *evaleval( int*, int, int );
+int evalchar( int );
+int dosizeof( void );
int evalnum( int c );
int bittest( int );
/* cpp6.c */
-void skipnl(void);
-int skipws(void);
+void skipnl( void );
+int skipws( void );
void scanid( int c );
int macroid( int c );
int catenate(void);
int scanstring( int c, void (*outfun)( int c ) );
void scannumber( int c, void (*outfun)( int c ) );
void save( int c );
-char *savestring( char *text );
-FILEINFO *getfile( int bufsize, char *name);
+char* savestring( char* text );
+FILEINFO* getfile( int bufsize, char* name );
char *getmem( int size );
-DEFBUF *lookid( int c );
-DEFBUF *defendel( char *name, int delete );
-void dunpdef( char *why );
-void dumpadef( char *why, DEFBUF *dp);
-int get(void);
-int cget(void);
-void unget(void);
-void ungetstring( char *text );
-void cerror( char *format, char *sarg);
-void cwarn( char *format, char *sarg);
-void cfatal( char *format, char *sarg);
-void cierror( char *format, int n);
-void ciwarn( char *format, int n);
+DEFBUF* lookid( int c );
+DEFBUF* defendel( char* name, int delete );
+void dunpdef( char* why );
+void dumpadef( char* why, DEFBUF* dp );
+int get( void );
+int cget( void );
+void unget( void );
+void ungetstring( char* text );
+void cerror( char* format, char* sarg );
+void cwarn( char* format, char* sarg );
+void cfatal( char* format, char* sarg );
+void cierror( char* format, int n );
+void ciwarn( char* format, int n );
#if OSL_DEBUG_LEVEL > 1
-void dumpdef( char *why );
-void dumpadef( char *why, DEFBUF *dp );
+void dumpdef( char* why );
+void dumpadef( char* why, DEFBUF *dp );
#endif
#endif // INCLUDED_RSC_SOURCE_RSCPP_CPP_H
diff --git a/rsc/source/rscpp/cpp2.c b/rsc/source/rscpp/cpp2.c
index 71db0c359b58..4a564dad205c 100644
--- a/rsc/source/rscpp/cpp2.c
+++ b/rsc/source/rscpp/cpp2.c
@@ -53,9 +53,6 @@ void InitCpp2()
}
-
-int
-control(int counter)
/*
* Process #control lines. Simple commands are processed inline,
* while complex commands have their own subroutines.
@@ -64,232 +61,247 @@ control(int counter)
* #pragma commands. This prevents these commands from ending up at
* the end of the previous line if cpp is invoked with the -C option.
*/
+int control(int counter)
{
- int c;
- char *tp;
- int hash;
- char *ep;
+ int c;
+ char* tp;
+ int hash;
+ char* ep;
- c = skipws();
- if (c == '\n' || c == EOF_CHAR)
- return (counter + 1);
- if (!isdigit(c))
- scanid(c); /* Get #word to token[] */
- else {
- unget(); /* Hack -- allow #123 as a */
- strcpy(token, "line"); /* synonym for #line 123 */
- }
- hash = (token[1] == EOS) ? L_nogood : (token[0] + (token[2] << 1));
- switch (hash) {
- case L_assert: tp = "assert"; break;
- case L_define: tp = "define"; break;
- case L_elif: tp = "elif"; break;
- case L_else: tp = "else"; break;
- case L_endif: tp = "endif"; break;
- case L_if: tp = "if"; break;
- case L_ifdef: tp = "ifdef"; break;
- case L_ifndef: tp = "ifndef"; break;
- case L_include: tp = "include"; break;
- case L_line: tp = "line"; break;
- case L_pragma: tp = "pragma"; break;
- case L_undef: tp = "undef"; break;
- case L_error: tp = "error"; break;
+ c = skipws();
+ if (c == '\n' || c == EOF_CHAR)
+ return (counter + 1);
+ if (!isdigit(c))
+ scanid(c); /* Get #word to token[] */
+ else
+ {
+ unget(); /* Hack -- allow #123 as a */
+ strcpy(token, "line"); /* synonym for #line 123 */
+ }
+ hash = (token[1] == EOS) ? L_nogood : (token[0] + (token[2] << 1));
+ switch (hash)
+ {
+ case L_assert: tp = "assert"; break;
+ case L_define: tp = "define"; break;
+ case L_elif: tp = "elif"; break;
+ case L_else: tp = "else"; break;
+ case L_endif: tp = "endif"; break;
+ case L_if: tp = "if"; break;
+ case L_ifdef: tp = "ifdef"; break;
+ case L_ifndef: tp = "ifndef"; break;
+ case L_include: tp = "include"; break;
+ case L_line: tp = "line"; break;
+ case L_pragma: tp = "pragma"; break;
+ case L_undef: tp = "undef"; break;
+ case L_error: tp = "error"; break;
#if OSL_DEBUG_LEVEL > 1
- case L_debug: tp = "debug"; break;
- case L_nodebug: tp = "nodebug"; break;
+ case L_debug: tp = "debug"; break;
+ case L_nodebug: tp = "nodebug"; break;
#endif
- default: hash = L_nogood;
+ default: hash = L_nogood;
/*fall-through*/
- case L_nogood: tp = ""; break;
- }
- if (!streq(tp, token))
- hash = L_nogood;
- /*
- * hash is set to a unique value corresponding to the
- * control keyword (or L_nogood if we think it's nonsense).
- */
- if (infile->fp == NULL)
- cwarn("Control line \"%s\" within macro expansion", token);
- if (!compiling) { /* Not compiling now */
- switch (hash) {
- case L_if: /* These can't turn */
- case L_ifdef: /* compilation on, but */
- case L_ifndef: /* we must nest #if's */
- if (++ifptr >= &ifstack[BLK_NEST])
- goto if_nest_err;
- *ifptr = 0; /* !WAS_COMPILING */
- case L_line: /* Many */
+ case L_nogood: tp = ""; break;
+ }
+ if (!streq(tp, token))
+ hash = L_nogood;
+ /*
+ * hash is set to a unique value corresponding to the
+ * control keyword (or L_nogood if we think it's nonsense).
+ */
+ if (infile->fp == NULL)
+ cwarn("Control line \"%s\" within macro expansion", token);
+ if (!compiling)
+ { /* Not compiling now */
+ switch (hash)
+ {
+ case L_if: /* These can't turn */
+ case L_ifdef: /* compilation on, but */
+ case L_ifndef: /* we must nest #if's */
+ if (++ifptr >= &ifstack[BLK_NEST])
+ goto if_nest_err;
+ *ifptr = 0; /* !WAS_COMPILING */
+ case L_line: /* Many */
/*
* Are pragma's always processed?
*/
- case L_pragma: /* options */
- case L_include: /* are uninteresting */
- case L_define: /* if we */
- case L_undef: /* aren't */
- case L_assert: /* compiling. */
- case L_error: /* BP 5.3.92, #error */
-dump_line: skipnl(); /* Ignore rest of line */
- return (counter + 1);
- }
+ case L_pragma: /* options */
+ case L_include: /* are uninteresting */
+ case L_define: /* if we */
+ case L_undef: /* aren't */
+ case L_assert: /* compiling. */
+ case L_error: /* BP 5.3.92, #error */
+ dump_line: skipnl(); /* Ignore rest of line */
+ return (counter + 1);
}
+ }
+ /*
+ * Make sure that #line and #pragma are output on a fresh line.
+ */
+ if (counter > 0 && (hash == L_line || hash == L_pragma))
+ {
+ PUTCHAR('\n');
+ counter--;
+ }
+
+ switch (hash)
+ {
+ case L_line:
/*
- * Make sure that #line and #pragma are output on a fresh line.
+ * Parse the line to update the line number and "progname"
+ * field and line number for the next input line.
+ * Set wrongline to force it out later.
*/
- if (counter > 0 && (hash == L_line || hash == L_pragma)) {
- PUTCHAR('\n');
- counter--;
+ c = skipws();
+ workp = work; /* Save name in work */
+ while (c != '\n' && c != EOF_CHAR)
+ {
+ save(c);
+ c = get();
}
- switch (hash) {
- case L_line:
- /*
- * Parse the line to update the line number and "progname"
- * field and line number for the next input line.
- * Set wrongline to force it out later.
- */
- c = skipws();
- workp = work; /* Save name in work */
- while (c != '\n' && c != EOF_CHAR) {
- save(c);
- c = get();
- }
- unget();
- save(EOS);
- /*
- * Split #line argument into <line-number> and <name>
- * We subtract 1 as we want the number of the next line.
- */
- line = atoi(work) - 1; /* Reset line number */
- for (tp = work; isdigit(*tp) || type[(int)*tp] == SPA; tp++)
- ; /* Skip over digits */
- if (*tp != EOS) { /* Got a filename, so: */
- if (*tp == '"' && (ep = strrchr(tp + 1, '"')) != NULL) {
- tp++; /* Skip over left quote */
- *ep = EOS; /* And ignore right one */
- }
- if (infile->progname != NULL) /* Give up the old name */
- free(infile->progname); /* if it's allocated. */
- infile->progname = savestring(tp);
- }
- wrongline = TRUE; /* Force output later */
- break;
-
- case L_include:
- doinclude();
- break;
-
- case L_define:
- dodefine();
- break;
-
- case L_undef:
- doundef();
- break;
-
- case L_else:
- if (ifptr == &ifstack[0])
- goto nest_err;
- else if ((*ifptr & ELSE_SEEN) != 0)
- goto else_seen_err;
- *ifptr |= ELSE_SEEN;
- if ((*ifptr & WAS_COMPILING) != 0) {
- if (compiling || (*ifptr & TRUE_SEEN) != 0)
- compiling = FALSE;
- else {
- compiling = TRUE;
- }
- }
- break;
-
- case L_elif:
- if (ifptr == &ifstack[0])
- goto nest_err;
- else if ((*ifptr & ELSE_SEEN) != 0) {
-else_seen_err: cerror("#%s may not follow #else", token);
- goto dump_line;
+ unget();
+ save(EOS);
+ /*
+ * Split #line argument into <line-number> and <name>
+ * We subtract 1 as we want the number of the next line.
+ */
+ line = atoi(work) - 1; /* Reset line number */
+ for (tp = work; isdigit(*tp) || type[(int)*tp] == SPA; tp++)
+ ; /* Skip over digits */
+ if (*tp != EOS) /* Got a filename, so: */
+ {
+ if (*tp == '"' && (ep = strrchr(tp + 1, '"')) != NULL)
+ {
+ tp++; /* Skip over left quote */
+ *ep = EOS; /* And ignore right one */
}
- if ((*ifptr & (WAS_COMPILING | TRUE_SEEN)) != WAS_COMPILING) {
- compiling = FALSE; /* Done compiling stuff */
- goto dump_line; /* Skip this clause */
+ if (infile->progname != NULL) /* Give up the old name */
+ free(infile->progname); /* if it's allocated. */
+ infile->progname = savestring(tp);
+ }
+ wrongline = TRUE; /* Force output later */
+ break;
+
+ case L_include:
+ doinclude();
+ break;
+
+ case L_define:
+ dodefine();
+ break;
+
+ case L_undef:
+ doundef();
+ break;
+
+ case L_else:
+ if (ifptr == &ifstack[0])
+ goto nest_err;
+ else if ((*ifptr & ELSE_SEEN) != 0)
+ goto else_seen_err;
+ *ifptr |= ELSE_SEEN;
+ if ((*ifptr & WAS_COMPILING) != 0)
+ {
+ if (compiling || (*ifptr & TRUE_SEEN) != 0)
+ compiling = FALSE;
+ else
+ {
+ compiling = TRUE;
}
- doif(L_if);
- break;
+ }
+ break;
- case L_if:
- case L_ifdef:
- case L_ifndef:
- if (++ifptr >= &ifstack[BLK_NEST])
-if_nest_err: cfatal("Too many nested #%s statements", token);
- *ifptr = WAS_COMPILING;
- doif(hash);
- break;
-
- case L_endif:
- if (ifptr == &ifstack[0]) {
-nest_err: cerror("#%s must be in an #if", token);
- goto dump_line;
- }
- if (!compiling && (*ifptr & WAS_COMPILING) != 0)
- wrongline = TRUE;
- compiling = ((*ifptr & WAS_COMPILING) != 0);
- --ifptr;
- break;
-
- case L_assert:
- if (eval() == 0)
- cerror("Preprocessor assertion failure", NULLST);
- break;
-
- case L_pragma:
- /*
- * #pragma is provided to pass "options" to later
- * passes of the compiler. cpp doesn't have any yet.
- */
- fprintf( pCppOut, "#pragma ");
- while ((c = get()) != '\n' && c != EOF_CHAR)
- cput(c);
- unget();
- break;
+ case L_elif:
+ if (ifptr == &ifstack[0])
+ goto nest_err;
+ else if ((*ifptr & ELSE_SEEN) != 0)
+ {
+ else_seen_err: cerror("#%s may not follow #else", token);
+ goto dump_line;
+ }
+ if ((*ifptr & (WAS_COMPILING | TRUE_SEEN)) != WAS_COMPILING)
+ {
+ compiling = FALSE; /* Done compiling stuff */
+ goto dump_line; /* Skip this clause */
+ }
+ doif(L_if);
+ break;
+
+ case L_if:
+ case L_ifdef:
+ case L_ifndef:
+ if (++ifptr >= &ifstack[BLK_NEST])
+ if_nest_err: cfatal("Too many nested #%s statements", token);
+ *ifptr = WAS_COMPILING;
+ doif(hash);
+ break;
+
+ case L_endif:
+ if (ifptr == &ifstack[0])
+ {
+ nest_err: cerror("#%s must be in an #if", token);
+ goto dump_line;
+ }
+ if (!compiling && (*ifptr & WAS_COMPILING) != 0)
+ wrongline = TRUE;
+ compiling = ((*ifptr & WAS_COMPILING) != 0);
+ --ifptr;
+ break;
+
+ case L_assert:
+ if (eval() == 0)
+ cerror("Preprocessor assertion failure", NULLST);
+ break;
+
+ case L_pragma:
+ /*
+ * #pragma is provided to pass "options" to later
+ * passes of the compiler. cpp doesn't have any yet.
+ */
+ fprintf( pCppOut, "#pragma ");
+ while ((c = get()) != '\n' && c != EOF_CHAR)
+ cput(c);
+ unget();
+ break;
#if OSL_DEBUG_LEVEL > 1
- case L_debug:
- if (debug == 0)
- dumpdef("debug set on");
- debug++;
- break;
-
- case L_nodebug:
- debug--;
- break;
+ case L_debug:
+ if (debug == 0)
+ dumpdef("debug set on");
+ debug++;
+ break;
+
+ case L_nodebug:
+ debug--;
+ break;
#endif
- case L_error: /* BP 5.3.92, #error */
+ case L_error: /* BP 5.3.92, #error */
+ fprintf( pCppOut, "cpp: line %u, Error directive: ", line );
+ while ((c = get()) != '\n' && c != EOF_CHAR)
+ cput(c);
+ fprintf( pCppOut, "\n" );
+ exit( 1 );
+
+ default:
+ /*
+ * Undefined #control keyword.
+ * Note: the correct behavior may be to warn and
+ * pass the line to a subsequent compiler pass.
+ * This would allow #asm or similar extensions.
+ */
+ cerror("Illegal # command \"%s\"", token);
+ break;
+ }
+ if (hash != L_include)
+ {
+ if (skipws() != '\n')
{
- fprintf( pCppOut, "cpp: line %u, Error directive: ", line );
- while ((c = get()) != '\n' && c != EOF_CHAR)
- cput(c);
- fprintf( pCppOut, "\n" );
- exit( 1 );
- }
- default:
- /*
- * Undefined #control keyword.
- * Note: the correct behavior may be to warn and
- * pass the line to a subsequent compiler pass.
- * This would allow #asm or similar extensions.
- */
- cerror("Illegal # command \"%s\"", token);
- break;
+ cwarn("Unexpected text in #control line ignored", NULLST);
+ skipnl();
}
- if (hash != L_include) {
- if (skipws() != '\n') {
- cwarn("Unexpected text in #control line ignored", NULLST);
- skipnl();
- }
- }
- return (counter + 1);
+ }
+ return (counter + 1);
}
-FILE_LOCAL
-void doif(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.
@@ -298,41 +310,45 @@ void doif(int hash)
* is always suppressed, so we don't need to evaluate anything. This
* suppresses unnecessary warnings.
*/
+FILE_LOCAL void doif(int hash)
{
- int c;
- int found;
-
- if ((c = skipws()) == '\n' || c == EOF_CHAR) {
- unget();
- goto badif;
- }
- if (hash == L_if) {
- unget();
- found = (eval() != 0); /* Evaluate expr, != 0 is TRUE */
- hash = L_ifdef; /* #if is now like #ifdef */
- }
- else {
- if (type[c] != LET) /* Next non-blank isn't letter */
- goto badif; /* ... is an error */
- found = (lookid(c) != NULL); /* Look for it in symbol table */
- }
- if (found == (hash == L_ifdef)) {
- compiling = TRUE;
- *ifptr |= TRUE_SEEN;
- }
- else {
- compiling = FALSE;
- }
- return;
-
-badif: cerror("#if, #ifdef, or #ifndef without an argument", NULLST);
- skipnl(); /* Prevent an extra */
- unget(); /* Error message */
- return;
+ int c;
+ int found;
+
+ if ((c = skipws()) == '\n' || c == EOF_CHAR)
+ {
+ unget();
+ goto badif;
+ }
+ if (hash == L_if)
+ {
+ unget();
+ found = (eval() != 0); /* Evaluate expr, != 0 is TRUE */
+ hash = L_ifdef; /* #if is now like #ifdef */
+ }
+ else
+ {
+ if (type[c] != LET) /* Next non-blank isn't letter */
+ goto badif; /* ... is an error */
+ found = (lookid(c) != NULL); /* Look for it in symbol table */
+ }
+ if (found == (hash == L_ifdef))
+ {
+ compiling = TRUE;
+ *ifptr |= TRUE_SEEN;
+ }
+ else
+ {
+ compiling = FALSE;
+ }
+ return;
+
+ badif: cerror("#if, #ifdef, or #ifndef without an argument", NULLST);
+ skipnl(); /* Prevent an extra */
+ unget(); /* Error message */
+ return;
}
-FILE_LOCAL
-void doinclude()
/*
* Process the #include control line.
* There are three variations:
@@ -347,47 +363,46 @@ void doinclude()
* Note: the November 12 draft forbids '>' in the #include <file> format.
* This restriction is unnecessary and not implemented.
*/
+FILE_LOCAL void doinclude()
{
- int c;
- int delim;
-
- delim = macroid(skipws());
- if (delim != '<' && delim != '"')
- goto incerr;
- if (delim == '<')
- delim = '>';
- workp = work;
- instring = TRUE; /* Accept all characters */
+ int c;
+ int delim;
+
+ delim = macroid(skipws());
+ if (delim != '<' && delim != '"')
+ goto incerr;
+ if (delim == '<')
+ delim = '>';
+ workp = work;
+ instring = TRUE; /* Accept all characters */
#ifdef CONTROL_COMMENTS_NOT_ALLOWED
- while ((c = get()) != '\n' && c != EOF_CHAR)
- save(c); /* Put it away. */
- unget(); /* Force nl after includee */
- /*
- * The draft is unclear if the following should be done.
- */
- while (--workp >= work && *workp == ' ')
- ; /* Trim blanks from filename */
- if (*workp != delim)
- goto incerr;
+ while ((c = get()) != '\n' && c != EOF_CHAR)
+ save(c); /* Put it away. */
+ unget(); /* Force nl after includee */
+ /*
+ * The draft is unclear if the following should be done.
+ */
+ while (--workp >= work && *workp == ' ')
+ ; /* Trim blanks from filename */
+ if (*workp != delim)
+ goto incerr;
#else
- while ((c = get()) != delim && c != EOF_CHAR)
- save(c);
+ while ((c = get()) != delim && c != EOF_CHAR)
+ save(c);
#endif
- *workp = EOS; /* Terminate filename */
- instring = FALSE;
- if (openinclude(work, (delim == '"')))
- return;
- /*
- * No sense continuing if #include file isn't there.
- */
- cfatal("Cannot open include file \"%s\"", work);
-
-incerr: cerror("#include syntax error", NULLST);
+ *workp = EOS; /* Terminate filename */
+ instring = FALSE;
+ if (openinclude(work, (delim == '"')))
return;
+ /*
+ * No sense continuing if #include file isn't there.
+ */
+ cfatal("Cannot open include file \"%s\"", work);
+
+ incerr: cerror("#include syntax error", NULLST);
+ return;
}
-FILE_LOCAL int
-openinclude(char* filename, int searchlocal)
/*
* Actually open an include file. This routine is only called from
* doinclude() above, but was written as a separate subroutine for
@@ -396,102 +411,112 @@ openinclude(char* filename, int searchlocal)
* active files. Returns TRUE if the file was opened, FALSE
* if openinclude() fails. No error message is printed.
*/
+FILE_LOCAL int openinclude(char* filename, int searchlocal)
{
- char **incptr;
- char tmpname[NFWORK]; /* Filename work area */
+ char** incptr;
+ char tmpname[NFWORK]; /* Filename work area */
- if (searchlocal) {
- /*
- * Look in local directory first
- */
+ if (searchlocal)
+ {
+ /*
+ * Look in local directory first
+ */
#if HOST == SYS_UNIX
- /*
- * Try to open filename relative to the directory of the current
- * source file (as opposed to the current directory). (ARF, SCK).
- */
- if (filename[0] != '/'
- && hasdirectory(infile->filename, tmpname))
- strcat(tmpname, filename);
- else {
- strcpy(tmpname, filename);
- }
-#else
- if (!hasdirectory(filename, tmpname)
- && hasdirectory(infile->filename, tmpname))
- strcat(tmpname, filename);
- else {
- strcpy(tmpname, filename);
- }
-#endif
- if (openfile(tmpname))
- return (TRUE);
- }
/*
- * Look in any directories specified by -I command line
- * arguments, then in the builtin search list.
+ * Try to open filename relative to the directory of the current
+ * source file (as opposed to the current directory). (ARF, SCK).
*/
- for (incptr = incdir; incptr < incend; incptr++) {
- if (strlen(*incptr) + strlen(filename) >= (NFWORK - 1))
- cfatal("Filename work buffer overflow", NULLST);
- else {
+ if (filename[0] != '/' &&
+ hasdirectory(infile->filename, tmpname))
+ {
+ strcat(tmpname, filename);
+ }
+ else
+ {
+ strcpy(tmpname, filename);
+ }
+#else
+ if (!hasdirectory(filename, tmpname) &&
+ hasdirectory(infile->filename, tmpname))
+ {
+ strcat(tmpname, filename);
+ }
+ else
+ {
+ strcpy(tmpname, filename);
+ }
+#endif
+ if (openfile(tmpname))
+ return (TRUE);
+ }
+ /*
+ * Look in any directories specified by -I command line
+ * arguments, then in the builtin search list.
+ */
+ for (incptr = incdir; incptr < incend; incptr++)
+ {
+ if (strlen(*incptr) + strlen(filename) >= (NFWORK - 1))
+ cfatal("Filename work buffer overflow", NULLST);
+ else
+ {
#if HOST == SYS_UNIX
- if (filename[0] == '/')
- strcpy(tmpname, filename);
- else {
- sprintf(tmpname, "%s/%s", *incptr, filename);
- }
+ if (filename[0] == '/')
+ strcpy(tmpname, filename);
+ else
+ sprintf(tmpname, "%s/%s", *incptr, filename);
+
#elif HOST == SYS_UNKNOWN
- if (filename[0] == '\\')
- strcpy(tmpname, filename);
- else {
- sprintf(tmpname, "%s\\%s", *incptr, filename);
- }
+ if (filename[0] == '\\')
+ strcpy(tmpname, filename);
+ else
+ sprintf(tmpname, "%s\\%s", *incptr, filename);
#else
- if (!hasdirectory(filename, tmpname))
- sprintf(tmpname, "%s%s", *incptr, filename);
+ if (!hasdirectory(filename, tmpname))
+ sprintf(tmpname, "%s%s", *incptr, filename);
#endif
- if (openfile(tmpname))
- return (TRUE);
- }
+ if (openfile(tmpname))
+ return (TRUE);
}
- return (FALSE);
+ }
+ return (FALSE);
}
-FILE_LOCAL int
-hasdirectory(char* source, char* result)
/*
* 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.
*/
+FILE_LOCAL int hasdirectory(char* source, char* result)
{
#if HOST == SYS_UNIX
- char *tp;
+ char* tp;
- if ((tp = strrchr(source, '/')) == NULL)
- return (FALSE);
- else {
- strncpy(result, source, tp - source + 1);
- result[tp - source + 1] = EOS;
- return (TRUE);
- }
+ if ((tp = strrchr(source, '/')) == NULL)
+ return (FALSE);
+ else
+ {
+ strncpy(result, source, tp - source + 1);
+ result[tp - source + 1] = EOS;
+ return (TRUE);
+ }
#else
- /*
- * Random DEC operating system (RSTS/E)
- */
- char *tp;
-
- if ((tp = strrchr(source, ']')) == NULL
- && (tp = strrchr(source, ':')) == NULL)
- return (FALSE);
- else {
- strncpy(result, source, tp - source + 1);
- result[tp - source + 1] = EOS;
- return (TRUE);
- }
+ /*
+ * Random DEC operating system (RSTS/E)
+ */
+ char* tp;
+
+ if ((tp = strrchr(source, ']')) == NULL &&
+ (tp = strrchr(source, ':')) == NULL)
+ {
+ return (FALSE);
+ }
+ else
+ {
+ strncpy(result, source, tp - source + 1);
+ result[tp - source + 1] = EOS;
+ return (TRUE);
+ }
#endif
}
-
-
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/rsc/source/rscpp/cpp3.c b/rsc/source/rscpp/cpp3.c
index 124215dbb60a..f663a9f13ab8 100644
--- a/rsc/source/rscpp/cpp3.c
+++ b/rsc/source/rscpp/cpp3.c
@@ -37,31 +37,30 @@ void InitCpp3()
}
-int
-openfile(char* filename)
/*
* Open a file, add it to the linked list of open files.
* This is called only from openfile() above.
*/
+int openfile(char* filename)
{
- FILE *fp;
+ FILE* fp;
- if ((fp = fopen(filename, "r")) == NULL) {
+ if ((fp = fopen(filename, "r")) == NULL)
+ {
#if OSL_DEBUG_LEVEL > 1
- if ( debug || !bDumpDefs )
- perror(filename);
+ if ( debug || !bDumpDefs )
+ perror(filename);
#endif
- return (FALSE);
- }
+ return (FALSE);
+ }
#if OSL_DEBUG_LEVEL > 1
- if (debug)
- fprintf(stderr, "Reading from \"%s\"\n", filename);
+ if (debug)
+ fprintf(stderr, "Reading from \"%s\"\n", filename);
#endif
- addfile(fp, filename);
- return (TRUE);
+ addfile(fp, filename);
+ return (TRUE);
}
-void addfile(FILE* fp, char* filename)
/*
* Initialize tables for this open file. This is called from openfile()
* above (for #include files), and from the entry to cpp to open the main
@@ -69,31 +68,33 @@ void addfile(FILE* fp, char* filename)
* structure which is used to read characters. (getfile() is also called
* to setup a macro replacement.)
*/
+void addfile(FILE* fp, char* filename)
{
- FILEINFO *file;
- file = getfile(NBUFF, filename);
- file->fp = fp; /* Better remember FILE * */
- file->buffer[0] = EOS; /* Initialize for first read */
- line = 1; /* Working on line 1 now */
- wrongline = TRUE; /* Force out initial #line */
+ FILEINFO* file;
+
+ file = getfile(NBUFF, filename);
+ file->fp = fp; /* Better remember FILE * */
+ file->buffer[0] = EOS; /* Initialize for first read */
+ line = 1; /* Working on line 1 now */
+ wrongline = TRUE; /* Force out initial #line */
}
-void setincdirs()
/*
* Append system-specific directories to the include directory list.
* Called only when cpp is started.
*/
+void setincdirs()
{
#ifdef CPP_INCLUDE
- *incend++ = CPP_INCLUDE;
+ *incend++ = CPP_INCLUDE;
#define IS_INCLUDE 1
#else
#define IS_INCLUDE 0
#endif
#if HOST == SYS_UNIX
- *incend++ = "/usr/include";
+ *incend++ = "/usr/include";
#define MAXINCLUDE (NINCLUDE - 1 - IS_INCLUDE)
#endif
@@ -112,17 +113,16 @@ void setincdirs()
*/
#if !defined( WNT ) && ! defined UNX
- extern char *getenv( char *pStr ); /* BP */
+ extern char* getenv( char *pStr ); /* BP */
#endif
- char *pIncGetEnv = NULL; /* Pointer auf INCLUDE */
+ char* pIncGetEnv = NULL; /* Pointer auf INCLUDE */
- if ( ( pIncGetEnv = getenv("INCLUDE") ) != NULL )
- AddInclude( pIncGetEnv );
+ if ( ( pIncGetEnv = getenv("INCLUDE") ) != NULL )
+ AddInclude( pIncGetEnv );
#define MAXINCLUDE (NINCLUDE - 3 - IS_INCLUDE)
#endif
-
}
/* Kontext: Erweiterung des INCLUDE-Services
@@ -135,8 +135,8 @@ void setincdirs()
int AddInclude( char* pIncStr )
{
- char *pIncEnv = NULL; /* Kopie des INCLUDE */
- char *pIncPos; /* wandert zum naechsten */
+ char* pIncEnv = NULL; /* Kopie des INCLUDE */
+ char* pIncPos; /* wandert zum naechsten */
pIncEnv = savestring( pIncStr );
pIncPos = strtok( pIncEnv, ";" );
@@ -151,125 +151,131 @@ int AddInclude( char* pIncStr )
return( 1 );
}
-int
-dooptions(int argc, char** argv)
/*
* dooptions is called to process command line arguments (-Detc).
* It is called only at cpp startup.
*/
+int dooptions(int argc, char** argv)
{
- char *ap;
- DEFBUF *dp;
- int c;
- int i, j;
- char *arg;
- SIZES *sizp; /* For -S */
- int size; /* For -S */
- int isdatum; /* FALSE for -S* */
- int endtest; /* For -S */
-
- for (i = j = 1; i < argc; i++) {
- arg = ap = argv[i];
-
- if (*ap++ != '-' || *ap == EOS)
+ char* ap;
+ DEFBUF* dp;
+ int c;
+ int i, j;
+ char* arg;
+ SIZES* sizp; /* For -S */
+ int size; /* For -S */
+ int isdatum; /* FALSE for -S* */
+ int endtest; /* For -S */
+
+ for (i = j = 1; i < argc; i++)
+ {
+ arg = ap = argv[i];
+
+ if (*ap++ != '-' || *ap == EOS)
+ {
+ argv[j++] = argv[i];
+ }
+ else
+ {
+ c = *ap++; /* Option byte */
+ if (islower(c)) /* Normalize case */
+ c = toupper(c);
+ switch (c) /* Command character */
{
- argv[j++] = argv[i];
- }
- else {
- c = *ap++; /* Option byte */
- if (islower(c)) /* Normalize case */
- c = toupper(c);
- switch (c) { /* Command character */
- case 'C': /* Keep comments */
- cflag = TRUE;
- keepcomments = TRUE;
- break;
-
- case 'D': /* Define symbol */
- /*
- * If the option is just "-Dfoo", make it -Dfoo=1
- */
- while (*ap != EOS && *ap != '=')
+ case 'C': /* Keep comments */
+ cflag = TRUE;
+ keepcomments = TRUE;
+ break;
+
+ case 'D': /* Define symbol */
+ /*
+ * If the option is just "-Dfoo", make it -Dfoo=1
+ */
+ while (*ap != EOS && *ap != '=')
+ ap++;
+ if (*ap == EOS)
+ ap = "1";
+ else
+ *ap++ = EOS;
+ /*
+ * Now, save the word and its definition.
+ */
+ dp = defendel(argv[i] + 2, FALSE);
+ dp->repl = savestring(ap);
+ dp->nargs = DEF_NOARGS;
+ break;
+
+ case 'E': /* Ignore non-fatal */
+ eflag = TRUE; /* errors. */
+ break;
+
+ case 'I': /* Include directory */
+ AddInclude( ap ); /* BP, 11.09.91 */
+ break;
+
+ case 'N': /* No predefineds */
+ nflag++; /* Repeat to undefine */
+ break; /* __LINE__, etc. */
+
+ case 'S':
+ sizp = size_table;
+ if (0 != (isdatum = (*ap != '*'))) /* If it's just -S, */
+ endtest = T_FPTR; /* Stop here */
+ else /* But if it's -S* */
+ {
+ ap++; /* Step over '*' */
+ endtest = 0; /* Stop at end marker */
+ }
+ while (sizp->bits != endtest && *ap != EOS)
+ {
+ if (!isdigit(*ap)) /* Skip to next digit */
+ {
ap++;
- if (*ap == EOS)
- ap = "1";
- else
- *ap++ = EOS;
- /*
- * Now, save the word and its definition.
- */
- dp = defendel(argv[i] + 2, FALSE);
- dp->repl = savestring(ap);
- dp->nargs = DEF_NOARGS;
- break;
-
- case 'E': /* Ignore non-fatal */
- eflag = TRUE; /* errors. */
- break;
-
- case 'I': /* Include directory */
- AddInclude( ap ); /* BP, 11.09.91 */
- break;
-
- case 'N': /* No predefineds */
- nflag++; /* Repeat to undefine */
- break; /* __LINE__, etc. */
-
- case 'S':
- sizp = size_table;
- if (0 != (isdatum = (*ap != '*'))) /* If it's just -S, */
- endtest = T_FPTR; /* Stop here */
- else { /* But if it's -S* */
- ap++; /* Step over '*' */
- endtest = 0; /* Stop at end marker */
+ continue;
}
- while (sizp->bits != endtest && *ap != EOS) {
- if (!isdigit(*ap)) { /* Skip to next digit */
- ap++;
- continue;
- }
- size = 0; /* Compile the value */
- while (isdigit(*ap)) {
- size *= 10;
- size += (*ap++ - '0');
- }
- if (isdatum)
- sizp->size = size; /* Datum size */
- else
- sizp->psize = size; /* Pointer size */
- sizp++;
+ size = 0; /* Compile the value */
+ while (isdigit(*ap))
+ {
+ size *= 10;
+ size += (*ap++ - '0');
}
- if (sizp->bits != endtest)
- cwarn("-S, too few values specified in %s", argv[i]);
- else if (*ap != EOS)
- cwarn("-S, too many values, \"%s\" unused", ap);
- break;
+ if (isdatum)
+ sizp->size = size; /* Datum size */
+ else
+ sizp->psize = size; /* Pointer size */
+ sizp++;
+ }
+ if (sizp->bits != endtest)
+ cwarn("-S, too few values specified in %s", argv[i]);
+ else if (*ap != EOS)
+ cwarn("-S, too many values, \"%s\" unused", ap);
+ break;
- case 'U': /* Undefine symbol */
- if (defendel(ap, TRUE) == NULL)
- cwarn("\"%s\" wasn't defined", ap);
- break;
+ case 'U': /* Undefine symbol */
+ if (defendel(ap, TRUE) == NULL)
+ cwarn("\"%s\" wasn't defined", ap);
+ break;
#if OSL_DEBUG_LEVEL > 1
- case 'X': /* Debug */
- debug = (isdigit(*ap)) ? atoi(ap) : 1;
+ case 'X': /* Debug */
+ debug = (isdigit(*ap)) ? atoi(ap) : 1;
#if (HOST == SYS_UNIX)
- signal(SIGINT, (void (*)(int)) abort); /* Trap "interrupt" */
+ signal(SIGINT, (void (*)(int)) abort); /* Trap "interrupt" */
#endif
- fprintf(stderr, "Debug set to %d\n", debug);
- break;
+ fprintf(stderr, "Debug set to %d\n", debug);
+ break;
#endif
#if OSL_DEBUG_LEVEL > 1
- case 'P': /* #define's dump */
- bDumpDefs = 1;
- fprintf(stderr, "Dump #define's is on\n");
- break;
+ case 'P': /* #define's dump */
+ bDumpDefs = 1;
+ fprintf(stderr, "Dump #define's is on\n");
+ break;
#endif
- default: /* What is this one? */
- cwarn("Unknown option \"%s\"", arg);
- fprintf(stderr, "The following options are valid:\n\
+ default: /* What is this one? */
+ cwarn("Unknown option \"%s\"", arg);
+ fprintf(stderr, "The following options are valid:\n\
-C\t\t\tWrite source file comments to output\n\
-Dsymbol=value\tDefine a symbol with the given (optional) value\n\
-Idirectory\t\tAdd a directory to the #include search list\n\
@@ -277,107 +283,110 @@ dooptions(int argc, char** argv)
-Stext\t\tSpecify sizes for #if sizeof\n\
-Usymbol\t\tUndefine symbol\n");
#if OSL_DEBUG_LEVEL > 1
- fprintf(stderr, " -Xvalue\t\tSet internal debug flag\n");
- fprintf(stderr, " -P\t\t\tdump #define's\n");
+ fprintf(stderr, " -Xvalue\t\tSet internal debug flag\n");
+ fprintf(stderr, " -P\t\t\tdump #define's\n");
#endif
- break;
- } /* Switch on all options */
- } /* If it's a -option */
- } /* For all arguments */
+ break;
+ } /* Switch on all options */
+ } /* If it's a -option */
+ } /* For all arguments */
#if OSL_DEBUG_LEVEL > 1
- if ( (bDumpDefs ? j > 4 : j > 3) ) {
+ if ( (bDumpDefs ? j > 4 : j > 3) )
#else
- if (j > 3) {
+ if (j > 3)
#endif
- cerror(
- "Too many file arguments. Usage: cpp [input [output]]",
+ {
+ cerror( "Too many file arguments. Usage: cpp [input [output]]",
NULLST);
- }
- return (j); /* Return new argc */
+ }
+ return (j); /* Return new argc */
}
-int
-readoptions(char* filename, char*** pfargv)
+int readoptions(char* filename, char*** pfargv)
{
- FILE *fp;
- int c;
- int bInQuotes = 0;
- char optbuff[1024], *poptbuff;
- int fargc=0, back;
- char *fargv[PARALIMIT], **pfa;
-
- pfa=*pfargv=malloc(sizeof(fargv));
-
- poptbuff=&optbuff[0];
- filename++;
- if ((fp = fopen(filename, "r")) == NULL) {
+ FILE* fp;
+ int c;
+ int bInQuotes = 0;
+ char optbuff[1024];
+ char* poptbuff;
+ int fargc=0;
+ int back;
+ char* fargv[PARALIMIT];
+ char** pfa;
+
+ pfa = *pfargv = malloc(sizeof(fargv));
+
+ poptbuff = &optbuff[0];
+ filename++;
+ if ((fp = fopen(filename, "r")) == NULL)
+ {
#if OSL_DEBUG_LEVEL > 1
- if ( debug || !bDumpDefs )
- perror(filename);
+ if ( debug || !bDumpDefs )
+ perror(filename);
#endif
- return (FALSE);
+ return (FALSE);
+ }
+ do
+ {
+ /*
+ * #i27914# double ticks '"' now have a duplicate function:
+ * 1. they define a string ( e.g. -DFOO="baz" )
+ * 2. a string can contain spaces, so -DFOO="baz zum" defines one
+ * argument no two !
+ */
+ c = fgetc(fp);
+ if ( c != ' ' && c != CR && c != NL && c != HT && c != EOF)
+ {
+ *poptbuff++ = (char)c;
+ if( c == '"' )
+ bInQuotes = ~bInQuotes;
}
- do
+ else
{
- /*
- * #i27914# double ticks '"' now have a duplicate function:
- * 1. they define a string ( e.g. -DFOO="baz" )
- * 2. a string can contain spaces, so -DFOO="baz zum" defines one
- * argument no two !
- */
- c=fgetc(fp);
- if ( c != ' ' && c != CR && c != NL && c != HT && c != EOF)
- {
- *poptbuff++=(char)c;
- if( c == '"' )
- bInQuotes = ~bInQuotes;
- }
+ if( c != EOF && bInQuotes )
+ *poptbuff++ = (char)c;
else
{
- if( c != EOF && bInQuotes )
- *poptbuff++=(char)c;
- else
+ *poptbuff = EOS;
+ if (strlen(optbuff)>0)
{
- *poptbuff=EOS;
- if (strlen(optbuff)>0)
- {
- pfa[fargc+1]=strdup(optbuff);
- fargc++;
- pfa[fargc+1]=0;
- poptbuff=&optbuff[0];
- }
+ pfa[fargc + 1] = strdup(optbuff);
+ fargc++;
+ pfa[fargc + 1] = 0;
+ poptbuff = &optbuff[0];
}
}
}
- while ( c != EOF );
+ }
+ while ( c != EOF );
- fclose(fp);
- back=dooptions(fargc+1,pfa);
+ fclose(fp);
+ back=dooptions(fargc+1,pfa);
- return (back);
+ return (back);
}
#if HOST != SYS_UNIX
-FILE_LOCAL void
-zap_uc(char* ap)
+
/*
* Dec operating systems mangle upper-lower case in command lines.
* This routine forces the -D and -U arguments to uppercase.
* It is called only on cpp startup by dooptions().
*/
+FILE_LOCAL void zap_uc(char* ap)
{
- while (*ap != EOS) {
- /*
- * Don't use islower() here so it works with Multinational
- */
- if (*ap >= 'a' && *ap <= 'z')
- *ap = (char)toupper(*ap);
- ap++;
- }
+ while (*ap != EOS)
+ {
+ /*
+ * Don't use islower() here so it works with Multinational
+ */
+ if (*ap >= 'a' && *ap <= 'z')
+ *ap = (char)toupper(*ap);
+ ap++;
+ }
}
#endif
-void initdefines()
/*
* Initialize the built-in #define's. There are two flavors:
* #define decus 1 (static definitions)
@@ -387,51 +396,57 @@ void initdefines()
* Note: the built-in static definitions are suppressed by the -N option.
* __LINE__, __FILE__, and __DATE__ are always present.
*/
+void initdefines()
{
- char **pp;
- char *tp;
- DEFBUF *dp;
- int i;
- time_t tvec;
-
- /*
- * Predefine the built-in symbols. Allow the
- * implementor to pre-define a symbol as "" to
- * eliminate it.
- */
- if (nflag == 0) {
- for (pp = preset; *pp != NULL; pp++) {
- if (*pp[0] != EOS) {
- dp = defendel(*pp, FALSE);
- dp->repl = savestring("1");
- dp->nargs = DEF_NOARGS;
- }
+ char** pp;
+ char* tp;
+ DEFBUF* dp;
+ int i;
+ time_t tvec;
+
+ /*
+ * Predefine the built-in symbols. Allow the
+ * implementor to pre-define a symbol as "" to
+ * eliminate it.
+ */
+ if (nflag == 0)
+ {
+ for (pp = preset; *pp != NULL; pp++)
+ {
+ if (*pp[0] != EOS)
+ {
+ dp = defendel(*pp, FALSE);
+ dp->repl = savestring("1");
+ dp->nargs = DEF_NOARGS;
}
}
+ }
+ /*
+ * The magic pre-defines (__FILE__ and __LINE__ are
+ * initialized with negative argument counts. expand()
+ * notices this and calls the appropriate routine.
+ * DEF_NOARGS is one greater than the first "magic" definition.
+ */
+ if (nflag < 2)
+ {
+ for (pp = magic, i = DEF_NOARGS; *pp != NULL; pp++)
+ {
+ dp = defendel(*pp, FALSE);
+ dp->nargs = --i;
+ }
+#if OK_DATE
/*
- * The magic pre-defines (__FILE__ and __LINE__ are
- * initialized with negative argument counts. expand()
- * notices this and calls the appropriate routine.
- * DEF_NOARGS is one greater than the first "magic" definition.
+ * Define __DATE__ as today's date.
*/
- if (nflag < 2) {
- for (pp = magic, i = DEF_NOARGS; *pp != NULL; pp++) {
- dp = defendel(*pp, FALSE);
- dp->nargs = --i;
- }
-#if OK_DATE
- /*
- * Define __DATE__ as today's date.
- */
- dp = defendel("__DATE__", FALSE);
- dp->repl = tp = getmem(27);
- dp->nargs = DEF_NOARGS;
- time( &tvec);
- *tp++ = '"';
- strcpy(tp, ctime(&tvec));
- tp[24] = '"'; /* Overwrite newline */
+ dp = defendel("__DATE__", FALSE);
+ dp->repl = tp = getmem(27);
+ dp->nargs = DEF_NOARGS;
+ time( &tvec);
+ *tp++ = '"';
+ strcpy(tp, ctime(&tvec));
+ tp[24] = '"'; /* Overwrite newline */
#endif
- }
+ }
}
diff --git a/rsc/source/rscpp/cpp4.c b/rsc/source/rscpp/cpp4.c
index 0925cafdd45f..6240c1b99514 100644
--- a/rsc/source/rscpp/cpp4.c
+++ b/rsc/source/rscpp/cpp4.c
@@ -26,10 +26,10 @@
* parm[], parmp, and parlist[] are used to store #define() argument
* lists. nargs contains the actual number of parameters stored.
*/
-static char parm[NPARMWORK + 1]; /* define param work buffer */
-static char *parmp; /* Free space in parm */
-static char *parlist[LASTPARM]; /* -> start of each parameter */
-static int nargs; /* Parameters for this macro */
+static char parm[NPARMWORK + 1]; /* define param work buffer */
+static char* parmp; /* Free space in parm */
+static char* parlist[LASTPARM]; /* -> start of each parameter */
+static int nargs; /* Parameters for this macro */
void InitCpp4()
{
@@ -43,7 +43,6 @@ void InitCpp4()
}
-void dodefine()
/*
* Called from control when a #define is scanned. This module
* parses formal parameters and the replacement string. When
@@ -81,142 +80,155 @@ void dodefine()
* charput puts a single character in the macro work area (parm[])
* in a manner analogous to textput().
*/
+void dodefine()
{
- int c;
- DEFBUF *dp; /* -> new definition */
- int isredefine; /* TRUE if redefined */
- char *old = 0; /* Remember redefined */
-
- if (type[(c = skipws())] != LET)
- goto bad_define;
- isredefine = FALSE; /* Set if redefining */
- if ((dp = lookid(c)) == NULL) /* If not known now */
- dp = defendel(token, FALSE); /* Save the name */
- else { /* It's known: */
- isredefine = TRUE; /* Remember this fact */
- old = dp->repl; /* Remember replacement */
- dp->repl = NULL; /* No replacement now */
- }
- parlist[0] = parmp = parm; /* Setup parm buffer */
- if ((c = get()) == '(') { /* With arguments? */
- nargs = 0; /* Init formals counter */
- do { /* Collect formal parms */
- if (nargs >= LASTPARM)
- cfatal("Too many arguments for macro", NULLST);
- else if ((c = skipws()) == ')')
- break; /* Got them all */
- else if (type[c] != LET) /* Bad formal syntax */
- goto bad_define;
- scanid(c); /* Get the formal param */
- parlist[nargs++] = parmp; /* Save its start */
- textput(token); /* Save text in parm[] */
- } while ((c = skipws()) == ','); /* Get another argument */
- if (c != ')') /* Must end at ) */
+ int c;
+ DEFBUF* dp; /* -> new definition */
+ int isredefine; /* TRUE if redefined */
+ char* old = 0; /* Remember redefined */
+
+ if (type[(c = skipws())] != LET)
+ goto bad_define;
+ isredefine = FALSE; /* Set if redefining */
+ if ((dp = lookid(c)) == NULL) /* If not known now */
+ dp = defendel(token, FALSE); /* Save the name */
+ else /* It's known: */
+ {
+ isredefine = TRUE; /* Remember this fact */
+ old = dp->repl; /* Remember replacement */
+ dp->repl = NULL; /* No replacement now */
+ }
+ parlist[0] = parmp = parm; /* Setup parm buffer */
+ if ((c = get()) == '(') /* With arguments? */
+ {
+ nargs = 0; /* Init formals counter */
+ do /* Collect formal parms */
+ {
+ if (nargs >= LASTPARM)
+ cfatal("Too many arguments for macro", NULLST);
+ else if ((c = skipws()) == ')')
+ break; /* Got them all */
+ else if (type[c] != LET) /* Bad formal syntax */
goto bad_define;
- c = ' '; /* Will skip to body */
- }
- else {
- /*
- * DEF_NOARGS is needed to distinguish between
- * "#define foo" and "#define foo()".
- */
- nargs = DEF_NOARGS; /* No () parameters */
+ scanid(c); /* Get the formal param */
+ parlist[nargs++] = parmp; /* Save its start */
+ textput(token); /* Save text in parm[] */
}
- if (type[c] == SPA) /* At whitespace? */
- c = skipws(); /* Not any more. */
- workp = work; /* Replacement put here */
- inmacro = TRUE; /* Keep \<newline> now */
- while (c != EOF_CHAR && c != '\n') { /* Compile macro body */
- if (c == '#') { /* Token concatenation? */
- while (workp > work && type[(int)workp[-1]] == SPA)
- --workp; /* Erase leading spaces */
- save(TOK_SEP); /* Stuff a delimiter */
- c = skipws(); /* Eat whitespace */
- if (type[c] == LET) /* Another token here? */
- ; /* Stuff it normally */
- else if (type[c] == DIG) { /* Digit string after? */
- while (type[c] == DIG) { /* Stuff the digits */
- save(c);
- c = get();
- }
- save(TOK_SEP); /* Delimit 2nd token */
- }
- else {
- ciwarn("Strange character after # (%d.)", c);
+ while ((c = skipws()) == ','); /* Get another argument */
+ if (c != ')') /* Must end at ) */
+ goto bad_define;
+ c = ' '; /* Will skip to body */
+ }
+ else
+ {
+ /*
+ * DEF_NOARGS is needed to distinguish between
+ * "#define foo" and "#define foo()".
+ */
+ nargs = DEF_NOARGS; /* No () parameters */
+ }
+ if (type[c] == SPA) /* At whitespace? */
+ c = skipws(); /* Not any more. */
+ workp = work; /* Replacement put here */
+ inmacro = TRUE; /* Keep \<newline> now */
+ while (c != EOF_CHAR && c != '\n') /* Compile macro body */
+ {
+ if (c == '#') /* Token concatenation? */
+ {
+ while (workp > work && type[(int)workp[-1]] == SPA)
+ --workp; /* Erase leading spaces */
+ save(TOK_SEP); /* Stuff a delimiter */
+ c = skipws(); /* Eat whitespace */
+ if (type[c] == LET) /* Another token here? */
+ ; /* Stuff it normally */
+ else if (type[c] == DIG) /* Digit string after? */
+ {
+ while (type[c] == DIG) /* Stuff the digits */
+ {
+ save(c);
+ c = get();
}
- continue;
+ save(TOK_SEP); /* Delimit 2nd token */
}
- switch (type[c]) {
- case LET:
- checkparm(c, dp); /* Might be a formal */
- break;
+ else
+ {
+ ciwarn("Strange character after # (%d.)", c);
+ }
+ continue;
+ }
+ switch (type[c])
+ {
+ case LET:
+ checkparm(c, dp); /* Might be a formal */
+ break;
- case DIG: /* Number in mac. body */
- case DOT: /* Maybe a float number */
- scannumber(c, save); /* Scan it off */
- break;
+ case DIG: /* Number in mac. body */
+ case DOT: /* Maybe a float number */
+ scannumber(c, save); /* Scan it off */
+ break;
- case QUO: /* String in mac. body */
- stparmscan(c);
- break;
+ case QUO: /* String in mac. body */
+ stparmscan(c);
+ break;
- case BSH: /* Backslash */
- save('\\');
- if ((c = get()) == '\n')
- wrongline = TRUE;
- save(c);
- break;
+ case BSH: /* Backslash */
+ save('\\');
+ if ((c = get()) == '\n')
+ wrongline = TRUE;
+ save(c);
+ break;
- case SPA: /* Absorb whitespace */
- /*
- * Note: the "end of comment" marker is passed on
- * to allow comments to separate tokens.
- */
- if (workp[-1] == ' ') /* Absorb multiple */
- break; /* spaces */
- else if (c == '\t')
- c = ' '; /* Normalize tabs */
- /* Fall through to store character */
- default: /* Other character */
- save(c);
- break;
- }
- c = get();
+ case SPA: /* Absorb whitespace */
+ /*
+ * Note: the "end of comment" marker is passed on
+ * to allow comments to separate tokens.
+ */
+ if (workp[-1] == ' ') /* Absorb multiple */
+ break; /* spaces */
+ else if (c == '\t')
+ c = ' '; /* Normalize tabs */
+ /* Fall through to store character */
+ default: /* Other character */
+ save(c);
+ break;
}
- inmacro = FALSE; /* Stop newline hack */
- unget(); /* For control check */
- if (workp > work && workp[-1] == ' ') /* Drop trailing blank */
- workp--;
- *workp = EOS; /* Terminate work */
- dp->repl = savestring(work); /* Save the string */
- dp->nargs = nargs; /* Save arg count */
+ c = get();
+ }
+ inmacro = FALSE; /* Stop newline hack */
+ unget(); /* For control check */
+ if (workp > work && workp[-1] == ' ') /* Drop trailing blank */
+ workp--;
+ *workp = EOS; /* Terminate work */
+ dp->repl = savestring(work); /* Save the string */
+ dp->nargs = nargs; /* Save arg count */
#if OSL_DEBUG_LEVEL > 1
- if (debug)
- dumpadef("macro definition", dp);
- else if (bDumpDefs)
- dumpadef(NULL, dp);
+ if (debug)
+ dumpadef("macro definition", dp);
+ else if (bDumpDefs)
+ dumpadef(NULL, dp);
#endif
- 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)) {
+ 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))
+ {
#ifdef STRICT_UNDEF
- cerror("Redefining defined variable \"%s\"", dp->name);
+ cerror("Redefining defined variable \"%s\"", dp->name);
#else
- cwarn("Redefining defined variable \"%s\"", dp->name);
+ cwarn("Redefining defined variable \"%s\"", dp->name);
#endif
- }
- if (old != NULL) /* We don't need the */
- free(old); /* old definition now. */
}
- return;
-
-bad_define:
- cerror("#define syntax error", NULLST);
- inmacro = FALSE; /* Stop <newline> hack */
+ if (old != NULL) /* We don't need the */
+ free(old); /* old definition now. */
+ }
+ return;
+
+ bad_define:
+ cerror("#define syntax error", NULLST);
+ inmacro = FALSE; /* Stop <newline> hack */
}
-void checkparm(int c, DEFBUF* dp)
/*
* 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
@@ -224,114 +236,122 @@ void checkparm(int c, DEFBUF* dp)
* the output routine. This prevents the macro expander from
* looping if someone writes "#define foo foo".
*/
+void checkparm(int c, DEFBUF* dp)
{
- int i;
- char *cp;
+ int i;
+ char* cp;
- scanid(c); /* Get parm to token[] */
- for (i = 0; i < nargs; i++) { /* For each argument */
- if (streq(parlist[i], token)) { /* If it's known */
+ scanid(c); /* Get parm to token[] */
+ for (i = 0; i < nargs; i++) /* For each argument */
+ {
+ if (streq(parlist[i], token)) /* If it's known */
+ {
#ifdef SOLAR
- save(DEL);
+ save(DEL);
#endif
- save(i + MAC_PARM); /* Save a magic cookie */
- return; /* And exit the search */
- }
+ save(i + MAC_PARM); /* Save a magic cookie */
+ return; /* And exit the search */
}
- if (streq(dp->name, token)) /* Macro name in body? */
- save(DEF_MAGIC); /* Save magic marker */
- for (cp = token; *cp != EOS;) /* And save */
- save(*cp++); /* The token itself */
+ }
+ if (streq(dp->name, token)) /* Macro name in body? */
+ save(DEF_MAGIC); /* Save magic marker */
+ for (cp = token; *cp != EOS;) /* And save */
+ save(*cp++); /* The token itself */
}
-void stparmscan(int delim)
/*
* Normal string parameter scan.
*/
+void stparmscan(int delim)
{
- char *wp;
- int i;
-
- wp = workp; /* Here's where it starts */
- if (!scanstring(delim, save))
- return; /* Exit on scanstring error */
- workp[-1] = EOS; /* Erase trailing quote */
- wp++; /* -> first string content byte */
- for (i = 0; i < nargs; i++) {
- if (streq(parlist[i], wp)) {
+ char* wp;
+ int i;
+
+ wp = workp; /* Here's where it starts */
+ if (!scanstring(delim, save))
+ return; /* Exit on scanstring error */
+ workp[-1] = EOS; /* Erase trailing quote */
+ wp++; /* -> first string content byte */
+ for (i = 0; i < nargs; i++)
+ {
+ if (streq(parlist[i], wp))
+ {
#ifdef SOLAR
- *wp++ = DEL;
- *wp++ = MAC_PARM + PAR_MAC; /* Stuff a magic marker */
- *wp++ = (char)(i + MAC_PARM); /* Make a formal marker */
- *wp = wp[-4]; /* Add on closing quote */
- workp = wp + 1; /* Reset string end */
+ *wp++ = DEL;
+ *wp++ = MAC_PARM + PAR_MAC; /* Stuff a magic marker */
+ *wp++ = (char)(i + MAC_PARM); /* Make a formal marker */
+ *wp = wp[-4]; /* Add on closing quote */
+ workp = wp + 1; /* Reset string end */
#else
- *wp++ = MAC_PARM + PAR_MAC; /* Stuff a magic marker */
- *wp++ = (i + MAC_PARM); /* Make a formal marker */
- *wp = wp[-3]; /* Add on closing quote */
- workp = wp + 1; /* Reset string end */
+ *wp++ = MAC_PARM + PAR_MAC; /* Stuff a magic marker */
+ *wp++ = (i + MAC_PARM); /* Make a formal marker */
+ *wp = wp[-3]; /* Add on closing quote */
+ workp = wp + 1; /* Reset string end */
#endif
- return;
- }
+ return;
}
- workp[-1] = wp[-1]; /* Nope, reset end quote. */
+ }
+ workp[-1] = wp[-1]; /* Nope, reset end quote. */
}
-void doundef()
/*
* Remove the symbol from the defined list.
* Called from the #control processor.
*/
+void doundef()
{
- int c;
-
- if (type[(c = skipws())] != LET)
- cerror("Illegal #undef argument", NULLST);
- else {
- scanid(c); /* Get name to token[] */
- if (defendel(token, TRUE) == NULL) {
+ int c;
+
+ if (type[(c = skipws())] != LET)
+ cerror("Illegal #undef argument", NULLST);
+ else
+ {
+ scanid(c); /* Get name to token[] */
+ if (defendel(token, TRUE) == NULL)
+ {
#ifdef STRICT_UNDEF
- cwarn("Symbol \"%s\" not defined in #undef", token);
+ cwarn("Symbol \"%s\" not defined in #undef", token);
#endif
- }
}
+ }
}
-void textput(char* text)
/*
* Put the string in the parm[] buffer.
*/
+void textput(char* text)
{
- int size;
-
- size = strlen(text) + 1;
- if ((parmp + size) >= &parm[NPARMWORK])
- cfatal("Macro work area overflow", NULLST);
- else {
- strcpy(parmp, text);
- parmp += size;
- }
+ int size;
+
+ size = strlen(text) + 1;
+ if ((parmp + size) >= &parm[NPARMWORK])
+ cfatal("Macro work area overflow", NULLST);
+ else
+ {
+ strcpy(parmp, text);
+ parmp += size;
+ }
}
-void charput(int c)
/*
* Put the byte in the parm[] buffer.
*/
+void charput(int c)
{
- if (parmp >= &parm[NPARMWORK])
- cfatal("Macro work area overflow", NULLST);
- else {
- *parmp++ = (char)c;
- }
+ if (parmp >= &parm[NPARMWORK])
+ cfatal("Macro work area overflow", NULLST);
+ else
+ {
+ *parmp++ = (char)c;
+ }
}
/*
* M a c r o E x p a n s i o n
*/
-static DEFBUF *macro; /* Catches start of infinite macro */
+static DEFBUF* macro; /* Catches start of infinite macro */
-void expand(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
@@ -341,176 +361,197 @@ void expand(DEFBUF* tokenp)
* "pushed back" onto the input stream. (When the get() routine runs
* off the end of the macro line, it will dismiss the macro itself.)
*/
+void expand(DEFBUF* tokenp)
{
- int c;
- FILEINFO *file;
+ int c;
+ FILEINFO* file;
#if OSL_DEBUG_LEVEL > 1
- if (debug)
- dumpadef("expand entry", tokenp);
+ if (debug)
+ dumpadef("expand entry", tokenp);
#endif
- /*
- * If no macro is pending, save the name of this macro
- * for an eventual error message.
- */
- if (recursion++ == 0)
- macro = tokenp;
- else if (recursion == RECURSION_LIMIT) {
- cerror("Recursive macro definition of \"%s\"", tokenp->name);
- fprintf(stderr, "(Defined by \"%s\")\n", macro->name);
- if (rec_recover) {
- do {
- c = get();
- } while (infile != NULL && infile->fp == NULL);
- unget();
- recursion = 0;
- return;
+ /*
+ * If no macro is pending, save the name of this macro
+ * for an eventual error message.
+ */
+ if (recursion++ == 0)
+ macro = tokenp;
+ else if (recursion == RECURSION_LIMIT)
+ {
+ cerror("Recursive macro definition of \"%s\"", tokenp->name);
+ fprintf(stderr, "(Defined by \"%s\")\n", macro->name);
+ if (rec_recover)
+ {
+ do
+ {
+ c = get();
}
+ while (infile != NULL && infile->fp == NULL);
+ unget();
+ recursion = 0;
+ return;
}
- /*
- * Here's a macro to expand.
- */
- nargs = 0; /* Formals counter */
- parmp = parm; /* Setup parm buffer */
- switch (tokenp->nargs) {
- case (-2): /* __LINE__ */
- sprintf(work, "%d", line);
- ungetstring(work);
- break;
-
- case (-3): /* __FILE__ */
- for (file = infile; file != NULL; file = file->parent) {
- if (file->fp != NULL) {
- sprintf(work, "\"%s\"", (file->progname != NULL)
+ }
+ /*
+ * Here's a macro to expand.
+ */
+ nargs = 0; /* Formals counter */
+ parmp = parm; /* Setup parm buffer */
+ switch (tokenp->nargs)
+ {
+ case (-2): /* __LINE__ */
+ sprintf(work, "%d", line);
+ ungetstring(work);
+ break;
+
+ case (-3): /* __FILE__ */
+ for (file = infile; file != NULL; file = file->parent)
+ {
+ if (file->fp != NULL)
+ {
+ sprintf(work, "\"%s\"", (file->progname != NULL)
? file->progname : file->filename);
- ungetstring(work);
- break;
- }
+ ungetstring(work);
+ break;
}
- break;
+ }
+ break;
- default:
+ default:
+ /*
+ * Nothing funny about this macro.
+ */
+ if (tokenp->nargs < 0)
+ cfatal("Bug: Illegal __ macro \"%s\"", tokenp->name);
+ while ((c = skipws()) == '\n') /* Look for (, skipping */
+ wrongline = TRUE; /* spaces and newlines */
+ if (c != '(')
+ {
/*
- * Nothing funny about this macro.
+ * If the programmer writes
+ * #define foo() ...
+ * ...
+ * foo [no ()]
+ * just write foo to the output stream.
*/
- if (tokenp->nargs < 0)
- cfatal("Bug: Illegal __ macro \"%s\"", tokenp->name);
- while ((c = skipws()) == '\n') /* Look for (, skipping */
- wrongline = TRUE; /* spaces and newlines */
- if (c != '(') {
- /*
- * If the programmer writes
- * #define foo() ...
- * ...
- * foo [no ()]
- * just write foo to the output stream.
- */
- unget();
- cwarn("Macro \"%s\" needs arguments", tokenp->name);
- fputs(tokenp->name, pCppOut );
- return;
+ unget();
+ cwarn("Macro \"%s\" needs arguments", tokenp->name);
+ fputs(tokenp->name, pCppOut );
+ return;
+ }
+ else if (expcollect()) /* Collect arguments */
+ {
+ if (tokenp->nargs != nargs) /* Should be an error? */
+ {
+ cwarn("Wrong number of macro arguments for \"%s\"",
+ tokenp->name);
}
- else if (expcollect()) { /* Collect arguments */
- if (tokenp->nargs != nargs) { /* Should be an error? */
- cwarn("Wrong number of macro arguments for \"%s\"",
- tokenp->name);
- }
#if OSL_DEBUG_LEVEL > 1
- if (debug)
- dumpparm("expand");
+ if (debug)
+ dumpparm("expand");
#endif
- } /* Collect arguments */
- case DEF_NOARGS: /* No parameters just stuffs */
- expstuff(tokenp); /* Do actual parameters */
- } /* nargs switch */
+ } /* Collect arguments */
+ case DEF_NOARGS: /* No parameters just stuffs */
+ expstuff(tokenp); /* Do actual parameters */
+ } /* nargs switch */
}
-FILE_LOCAL int
-expcollect()
/*
* Collect the actual parameters for this macro. TRUE if ok.
*/
+FILE_LOCAL int expcollect()
{
- int c;
- int paren; /* For embedded ()'s */
- for (;;) {
- paren = 0; /* Collect next arg. */
- while ((c = skipws()) == '\n') /* Skip over whitespace */
- wrongline = TRUE; /* and newlines. */
- if (c == ')') { /* At end of all args? */
- /*
- * Note that there is a guard byte in parm[]
- * so we don't have to check for overflow here.
- */
- *parmp = EOS; /* Make sure terminated */
- break; /* Exit collection loop */
+ int c;
+ int paren; /* For embedded ()'s */
+ for (;;)
+ {
+ paren = 0; /* Collect next arg. */
+ while ((c = skipws()) == '\n') /* Skip over whitespace */
+ wrongline = TRUE; /* and newlines. */
+ if (c == ')') /* At end of all args? */
+ {
+ /*
+ * Note that there is a guard byte in parm[]
+ * so we don't have to check for overflow here.
+ */
+ *parmp = EOS; /* Make sure terminated */
+ break; /* Exit collection loop */
+ }
+ else if (nargs >= LASTPARM)
+ cfatal("Too many arguments in macro expansion", NULLST);
+ parlist[nargs++] = parmp; /* At start of new arg */
+ for (;; c = cget()) /* Collect arg's bytes */
+ {
+ if (c == EOF_CHAR)
+ {
+ cerror("end of file within macro argument", NULLST);
+ return (FALSE); /* Sorry. */
}
- else if (nargs >= LASTPARM)
- cfatal("Too many arguments in macro expansion", NULLST);
- parlist[nargs++] = parmp; /* At start of new arg */
- for (;; c = cget()) { /* Collect arg's bytes */
- if (c == EOF_CHAR) {
- cerror("end of file within macro argument", NULLST);
- return (FALSE); /* Sorry. */
- }
- else if (c == '\\') { /* Quote next character */
- charput(c); /* Save the \ for later */
- charput(cget()); /* Save the next char. */
- continue; /* And go get another */
- }
- else if (type[c] == QUO) { /* Start of string? */
- scanstring(c, charput); /* Scan it off */
- continue; /* Go get next char */
- }
- else if (c == '(') /* Worry about balance */
- paren++; /* To know about commas */
- else if (c == ')') { /* Other side too */
- if (paren == 0) { /* At the end? */
- unget(); /* Look at it later */
- break; /* Exit arg getter. */
- }
- paren--; /* More to come. */
+ else if (c == '\\') /* Quote next character */
+ {
+ charput(c); /* Save the \ for later */
+ charput(cget()); /* Save the next char. */
+ continue; /* And go get another */
+ }
+ else if (type[c] == QUO) /* Start of string? */
+ {
+ scanstring(c, charput); /* Scan it off */
+ continue; /* Go get next char */
+ }
+ else if (c == '(') /* Worry about balance */
+ paren++; /* To know about commas */
+ else if (c == ')') /* Other side too */
+ {
+ if (paren == 0) /* At the end? */
+ {
+ unget(); /* Look at it later */
+ break; /* Exit arg getter. */
}
- else if (c == ',' && paren == 0) /* Comma delimits args */
- break;
- else if (c == '\n') /* Newline inside arg? */
- wrongline = TRUE; /* We'll need a #line */
- charput(c); /* Store this one */
- } /* Collect an argument */
- charput(EOS); /* Terminate argument */
+ paren--; /* More to come. */
+ }
+ else if (c == ',' && paren == 0) /* Comma delimits args */
+ break;
+ else if (c == '\n') /* Newline inside arg? */
+ wrongline = TRUE; /* We'll need a #line */
+ charput(c); /* Store this one */
+ } /* Collect an argument */
+ charput(EOS); /* Terminate argument */
#if OSL_DEBUG_LEVEL > 1
- if (debug)
+ if (debug)
fprintf( pCppOut, "parm[%d] = \"%s\"\n", nargs, parlist[nargs - 1]);
#endif
- } /* Collect all args. */
- return (TRUE); /* Normal return */
+ } /* Collect all args. */
+ return (TRUE); /* Normal return */
}
-FILE_LOCAL
-void expstuff(DEFBUF* tokenp)
/*
* Stuff the macro body, replacing formal parameters by actual parameters.
*/
+FILE_LOCAL void expstuff(DEFBUF* tokenp)
{
- int c; /* Current character */
- char *inp; /* -> repl string */
- char *defp; /* -> macro output buff */
- int size; /* Actual parm. size */
- char *defend; /* -> output buff end */
- int string_magic; /* String formal hack */
- FILEINFO *file; /* Funny #include */
-
- file = getfile(NBUFF, tokenp->name);
- inp = tokenp->repl; /* -> macro replacement */
- defp = file->buffer; /* -> output buffer */
- defend = defp + (NBUFF - 1); /* Note its end */
- if (inp != NULL) {
- while ((c = (*inp++ & 0xFF)) != EOS) {
+ int c; /* Current character */
+ char* inp; /* -> repl string */
+ char* defp; /* -> macro output buff */
+ int size; /* Actual parm. size */
+ char* defend; /* -> output buff end */
+ int string_magic; /* String formal hack */
+ FILEINFO* file; /* Funny #include */
+
+ file = getfile(NBUFF, tokenp->name);
+ inp = tokenp->repl; /* -> macro replacement */
+ defp = file->buffer; /* -> output buffer */
+ defend = defp + (NBUFF - 1); /* Note its end */
+ if (inp != NULL)
+ {
+ while ((c = (*inp++ & 0xFF)) != EOS)
+ {
#ifdef SOLAR
- if (c == DEL) {
- c = (*inp++ & 0xFF);
+ if (c == DEL)
+ {
+ c = (*inp++ & 0xFF);
#else
- if (c >= MAC_PARM && c <= (MAC_PARM + PAR_MAC)) {
+ if (c >= MAC_PARM && c <= (MAC_PARM + PAR_MAC))
+ {
#endif
string_magic = (c == (MAC_PARM + PAR_MAC));
if (string_magic)
@@ -518,28 +559,34 @@ void expstuff(DEFBUF* tokenp)
/*
* Replace formal parameter by actual parameter string.
*/
- if ((c -= MAC_PARM) < nargs) {
+ if ((c -= MAC_PARM) < nargs)
+ {
size = strlen(parlist[c]);
if ((defp + size) >= defend)
goto nospace;
/*
* Erase the extra set of quotes.
*/
- if (string_magic && defp[-1] == parlist[c][0]) {
+ if (string_magic && defp[-1] == parlist[c][0])
+ {
strcpy(defp-1, parlist[c]);
defp += (size - 2);
}
- else {
+ else
+ {
strcpy(defp, parlist[c]);
defp += size;
}
}
}
- else if (defp >= defend) {
-nospace: cfatal("Out of space in macro \"%s\" arg expansion",
- tokenp->name);
+ else if (defp >= defend)
+ {
+ nospace:
+ cfatal("Out of space in macro \"%s\" arg expansion",
+ tokenp->name);
}
- else {
+ else
+ {
*defp++ = (char)c;
}
}
@@ -549,23 +596,25 @@ nospace: cfatal("Out of space in macro \"%s\" arg expansion",
if (debug > 1)
fprintf( pCppOut, "macroline: \"%s\"\n", file->buffer);
#endif
-}
+ }
#if OSL_DEBUG_LEVEL > 1
-void dumpparm(char* why)
-/*
- * Dump parameter list.
- */
-{
+
+ /*
+ * Dump parameter list.
+ */
+ void dumpparm(char* why)
+ {
int i;
- fprintf( pCppOut, "dump of %d parameters (%" SAL_PRI_SIZET "u bytes total) %s\n",
- nargs, parmp - parm, why);
- for (i = 0; i < nargs; i++) {
- fprintf( pCppOut, "parm[%d] (%d) = \"%s\"\n",
- i + 1, (int)strlen(parlist[i]), parlist[i]);
+ fprintf( pCppOut, "dump of %d parameters (%" SAL_PRI_SIZET "u bytes total) %s\n",
+ nargs, parmp - parm, why);
+ for (i = 0; i < nargs; i++)
+ {
+ fprintf( pCppOut, "parm[%d] (%d) = \"%s\"\n",
+ i + 1, (int)strlen(parlist[i]), parlist[i]);
}
-}
+ }
#endif
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/rsc/source/rscpp/cpp5.c b/rsc/source/rscpp/cpp5.c
index 62d8f4b0f44d..6ccafe02e4f6 100644
--- a/rsc/source/rscpp/cpp5.c
+++ b/rsc/source/rscpp/cpp5.c
@@ -26,7 +26,7 @@
* Evaluate an #if expression.
*/
-static char *opname[] = { /* For debug and error messages */
+static char* opname[] = { /* For debug and error messages */
"end of expression", "val", "id",
"+", "-", "*", "/", "%",
"<<", ">>", "&", "|", "^",
@@ -80,7 +80,8 @@ static char opdope[OP_MAX] = {
#define S_ANDOR 2
#define S_QUEST 1
-typedef struct optab {
+typedef struct optab
+{
char op; /* Operator */
char prec; /* Its precedence */
char skip; /* Short-circuit: TRUE to skip */
@@ -133,7 +134,8 @@ static int evalue; /* Current value from evallex() */
#define S_PFPTR (sizeof (int (*)(void)))
#endif
-typedef struct types {
+typedef struct types
+{
short type; /* This is the bit if */
char *name; /* this is the token word */
} TYPES;
@@ -184,9 +186,6 @@ void InitCpp5()
}
-
-int
-eval()
/*
* Evaluate an expression. Straight-forward operator precedence.
* This is called from control() on encountering an #if statement.
@@ -199,23 +198,26 @@ eval()
* For compatibility with older cpp's, this return returns 1 (TRUE)
* if a syntax error is detected.
*/
+int eval()
{
- int op; /* Current operator */
- int *valp; /* -> value vector */
- OPTAB *opp; /* Operator stack */
- int prec; /* Op precedence */
- int binop; /* Set if binary op. needed */
- int op1; /* Operand from stack */
- int skip; /* For short-circuit testing */
- int value[NEXP]; /* Value stack */
- OPTAB opstack[NEXP]; /* Operand stack */
+ int op; /* Current operator */
+ int* valp; /* -> value vector */
+ OPTAB* opp; /* Operator stack */
+ int prec; /* Op precedence */
+ int binop; /* Set if binary op. needed */
+ int op1; /* Operand from stack */
+ int skip; /* For short-circuit testing */
+ int value[NEXP]; /* Value stack */
+ OPTAB opstack[NEXP]; /* Operand stack */
+
valp = value;
opp = opstack;
opp->op = OP_END; /* Mark bottom of stack */
opp->prec = opdope[OP_END]; /* And its precedence */
opp->skip = 0; /* Not skipping now */
binop = 0;
-again: ;
+
+again:
#ifdef DEBUG_EVAL
fprintf( pCppOut, "In #if at again: skip = %d, binop = %d, line is: %s",
opp->skip, binop, infile->bptr);
@@ -230,129 +232,143 @@ again: ;
fprintf( pCppOut, "op = %s, opdope = %03o, binop = %d, skip = %d\n",
opname[op], opdope[op], binop, opp->skip);
#endif
- if (op == DIG) { /* Value? */
- if (binop != 0) {
- cerror("misplaced constant in #if", NULLST);
- return (1);
+ if (op == DIG) /* Value? */
+ {
+ if (binop != 0)
+ {
+ cerror("misplaced constant in #if", NULLST);
+ return (1);
}
- else if (valp >= &value[NEXP-1]) {
- cerror("#if value stack overflow", NULLST);
- return (1);
+ else if (valp >= &value[NEXP-1])
+ {
+ cerror("#if value stack overflow", NULLST);
+ return (1);
}
- else {
+ else
+ {
#ifdef DEBUG_EVAL
- fprintf( pCppOut, "pushing %d onto value stack[%d]\n",
- evalue, valp - value);
+ fprintf( pCppOut, "pushing %d onto value stack[%d]\n",
+ evalue, valp - value);
#endif
- *valp++ = evalue;
- binop = 1;
+ *valp++ = evalue;
+ binop = 1;
}
goto again;
}
- else if (op > OP_END) {
+ else if (op > OP_END)
+ {
cerror("Illegal #if line", NULLST);
return (1);
}
prec = opdope[op];
- if (binop != (prec & 1)) {
+ if (binop != (prec & 1))
+ {
cerror("Operator %s in incorrect context", opname[op]);
return (1);
}
binop = (prec & 2) >> 1;
- for (;;) {
+ for (;;)
+ {
#ifdef DEBUG_EVAL
fprintf( pCppOut, "op %s, prec %d., stacked op %s, prec %d, skip %d\n",
opname[op], prec, opname[opp->op], opp->prec, opp->skip);
#endif
- if (prec > opp->prec) {
- if (op == OP_LPA)
- prec = OP_RPA_PREC;
- else if (op == OP_QUE)
- prec = OP_QUE_PREC;
- op1 = opp->skip; /* Save skip for test */
- /*
- * Push operator onto op. stack.
- */
- opp++;
- if (opp >= &opstack[NEXP]) {
- cerror("expression stack overflow at op \"%s\"",
- opname[op]);
- return (1);
- }
- opp->op = (char)op;
- opp->prec = (char)prec;
- /*
- * Do the short-circuit stuff here. Short-circuiting
- * stops automagically when operators are evaluated.
- */
- if ((op == OP_ANA && valp[-1] == 0)
- || (op == OP_ORO && valp[-1] != 0))
- opp->skip = S_ANDOR; /* And/or skip starts */
- else if (op == OP_QUE) /* Start of ?: operator */
- opp->skip = (char)((op1 & S_ANDOR) | ((valp[-1] == 0) ? S_QUEST : 0));
- else if (op == OP_COL) { /* : inverts S_QUEST */
- opp->skip = (char)((op1 & S_ANDOR)
- | (((op1 & S_QUEST) != 0) ? 0 : S_QUEST));
- }
- else { /* Other ops leave */
- opp->skip = (char)op1; /* skipping unchanged. */
- }
+ if (prec > opp->prec)
+ {
+ if (op == OP_LPA)
+ prec = OP_RPA_PREC;
+ else if (op == OP_QUE)
+ prec = OP_QUE_PREC;
+ op1 = opp->skip; /* Save skip for test */
+ /*
+ * Push operator onto op. stack.
+ */
+ opp++;
+ if (opp >= &opstack[NEXP])
+ {
+ cerror("expression stack overflow at op \"%s\"",
+ opname[op]);
+ return (1);
+ }
+ opp->op = (char)op;
+ opp->prec = (char)prec;
+ /*
+ * Do the short-circuit stuff here. Short-circuiting
+ * stops automagically when operators are evaluated.
+ */
+ if ((op == OP_ANA && valp[-1] == 0) ||
+ (op == OP_ORO && valp[-1] != 0))
+ {
+ opp->skip = S_ANDOR; /* And/or skip starts */
+ }
+ else if (op == OP_QUE) /* Start of ?: operator */
+ opp->skip = (char)((op1 & S_ANDOR) | ((valp[-1] == 0) ? S_QUEST : 0));
+ else if (op == OP_COL) /* : inverts S_QUEST */
+ {
+ opp->skip = (char)((op1 & S_ANDOR)
+ | (((op1 & S_QUEST) != 0) ? 0 : S_QUEST));
+ }
+ else /* Other ops leave */
+ {
+ opp->skip = (char)op1; /* skipping unchanged. */
+ }
#ifdef DEBUG_EVAL
- fprintf( pCppOut, "stacking %s, valp[-1] == %d at %s",
- opname[op], valp[-1], infile->bptr);
- dumpstack(opstack, opp, value, valp);
+ fprintf( pCppOut, "stacking %s, valp[-1] == %d at %s",
+ opname[op], valp[-1], infile->bptr);
+ dumpstack(opstack, opp, value, valp);
#endif
- goto again;
+ goto again;
}
/*
* Pop operator from op. stack and evaluate it.
* End of stack and '(' are specials.
*/
skip = opp->skip; /* Remember skip value */
- switch ((op1 = opp->op)) { /* Look at stacked op */
- case OP_END: /* Stack end marker */
- if (op == OP_EOE)
- return (valp[-1]); /* Finished ok. */
- goto again; /* Read another op. */
-
- case OP_LPA: /* ( on stack */
- if (op != OP_RPA) { /* Matches ) on input */
- cerror("unbalanced paren's, op is \"%s\"", opname[op]);
- return (1);
- }
- opp--; /* Unstack it */
- /* goto again; -- Fall through */
+ switch ((op1 = opp->op)) /* Look at stacked op */
+ {
+ case OP_END: /* Stack end marker */
+ if (op == OP_EOE)
+ return (valp[-1]); /* Finished ok. */
+ goto again; /* Read another op. */
+
+ case OP_LPA: /* ( on stack */
+ if (op != OP_RPA) /* Matches ) on input */
+ {
+ cerror("unbalanced paren's, op is \"%s\"", opname[op]);
+ return (1);
+ }
+ opp--; /* Unstack it */
+ /* goto again; -- Fall through */
case OP_QUE:
- goto again; /* Evaluate true expr. */
-
- case OP_COL: /* : on stack. */
- opp--; /* Unstack : */
- if (opp->op != OP_QUE) { /* Matches ? on stack? */
- cerror("Misplaced '?' or ':', previous operator is %s",
- opname[(int)opp->op]);
- return (1);
- }
+ goto again; /* Evaluate true expr. */
+
+ case OP_COL: /* : on stack. */
+ opp--; /* Unstack : */
+ if (opp->op != OP_QUE) /* Matches ? on stack? */
+ {
+ cerror("Misplaced '?' or ':', previous operator is %s",
+ opname[(int)opp->op]);
+ return (1);
+ }
/*
* Evaluate op1.
*/
default: /* Others: */
- opp--; /* Unstack the operator */
+ opp--; /* Unstack the operator */
#ifdef DEBUG_EVAL
- fprintf( pCppOut, "Stack before evaluation of %s\n", opname[op1]);
- dumpstack(opstack, opp, value, valp);
+ fprintf( pCppOut, "Stack before evaluation of %s\n", opname[op1]);
+ dumpstack(opstack, opp, value, valp);
#endif
- valp = evaleval(valp, op1, skip);
+ valp = evaleval(valp, op1, skip);
#ifdef DEBUG_EVAL
- fprintf( pCppOut, "Stack after evaluation\n");
- dumpstack(opstack, opp, value, valp);
+ fprintf( pCppOut, "Stack after evaluation\n");
+ dumpstack(opstack, opp, value, valp);
#endif
} /* op1 switch end */
} /* Stack unwind loop */
}
-FILE_LOCAL int
-evallex(int skip)
/*
* Return next eval operator or value. Called from eval(). It
* calls a special-purpose routines for 'char' strings and
@@ -360,46 +376,62 @@ evallex(int skip)
* evalchar called to evaluate 'x'
* evalnum called to evaluate numbers.
*/
+FILE_LOCAL int evallex(int skip)
{
- int c, c1, t;
+ int c;
+ int c1;
+ int t;
-again: do { /* Collect the token */
+again:
+ do /* Collect the token */
+ {
c = skipws();
- if ((c = macroid(c)) == EOF_CHAR || c == '\n') {
- unget();
- return (OP_EOE); /* End of expression */
+ if ((c = macroid(c)) == EOF_CHAR || c == '\n')
+ {
+ unget();
+ return (OP_EOE); /* End of expression */
}
- } while ((t = type[c]) == LET && catenate());
- if (t == INV) { /* Total nonsense */
- if (!skip) {
- if (isascii(c) && isprint(c))
- cierror("illegal character '%c' in #if", c);
- else
- cierror("illegal character (%d decimal) in #if", c);
+ }
+ while ((t = type[c]) == LET && catenate());
+ if (t == INV) /* Total nonsense */
+ {
+ if (!skip)
+ {
+ if (isascii(c) && isprint(c))
+ cierror("illegal character '%c' in #if", c);
+ else
+ cierror("illegal character (%d decimal) in #if", c);
}
return (OP_FAIL);
}
- else if (t == QUO) { /* ' or " */
- if (c == '\'') { /* Character constant */
- evalue = evalchar(skip); /* Somewhat messy */
+ else if (t == QUO) /* ' or " */
+ {
+ if (c == '\'') /* Character constant */
+ {
+ evalue = evalchar(skip); /* Somewhat messy */
#ifdef DEBUG_EVAL
- fprintf( pCppOut, "evalchar returns %d.\n", evalue);
+ fprintf( pCppOut, "evalchar returns %d.\n", evalue);
#endif
- return (DIG); /* Return a value */
+ return (DIG); /* Return a value */
}
cerror("Can't use a string in an #if", NULLST);
return (OP_FAIL);
}
- else if (t == LET) { /* ID must be a macro */
- if (streq(token, "defined")) { /* Or defined name */
+ else if (t == LET) /* ID must be a macro */
+ {
+ if (streq(token, "defined")) /* Or defined name */
+ {
c1 = c = skipws();
if (c == '(') /* Allow defined(name) */
c = skipws();
- if (type[c] == LET) {
+ if (type[c] == LET)
+ {
evalue = (lookid(c) != NULL);
- if (c1 != '(' /* Need to balance */
- || skipws() == ')') /* Did we balance? */
- return (DIG); /* Parsed ok */
+ if (c1 != '(' || /* Need to balance */
+ skipws() == ')') /* Did we balance? */
+ {
+ return (DIG); /* Parsed ok */
+ }
}
cerror("Bad #if ... defined() syntax", NULLST);
return (OP_FAIL);
@@ -419,70 +451,73 @@ again: do { /* Collect the token */
evalue = 0;
return (DIG);
}
- else if (t == DIG) { /* Numbers are harder */
+ else if (t == DIG) /* Numbers are harder */
+ {
evalue = evalnum(c);
#ifdef DEBUG_EVAL
fprintf( pCppOut, "evalnum returns %d.\n", evalue);
#endif
}
- else if (strchr("!=<>&|\\", c) != NULL) {
+ else if (strchr("!=<>&|\\", c) != NULL)
+ {
/*
* Process a possible multi-byte lexeme.
*/
- c1 = cget(); /* Peek at next char */
- switch (c) {
+ c1 = cget(); /* Peek at next char */
+ switch (c)
+ {
case '!':
- if (c1 == '=')
- return (OP_NE);
- break;
+ if (c1 == '=')
+ return (OP_NE);
+ break;
case '=':
- if (c1 != '=') { /* Can't say a=b in #if */
- unget();
- cerror("= not allowed in #if", NULLST);
- return (OP_FAIL);
- }
- return (OP_EQ);
+ if (c1 != '=') /* Can't say a=b in #if */
+ {
+ unget();
+ cerror("= not allowed in #if", NULLST);
+ return (OP_FAIL);
+ }
+ return (OP_EQ);
case '>':
case '<':
- if (c1 == c)
- return ((c == '<') ? OP_ASL : OP_ASR);
- else if (c1 == '=')
- return ((c == '<') ? OP_LE : OP_GE);
- break;
+ if (c1 == c)
+ return ((c == '<') ? OP_ASL : OP_ASR);
+ else if (c1 == '=')
+ return ((c == '<') ? OP_LE : OP_GE);
+ break;
case '|':
case '&':
- if (c1 == c)
- return ((c == '|') ? OP_ORO : OP_ANA);
- break;
+ if (c1 == c)
+ return ((c == '|') ? OP_ORO : OP_ANA);
+ break;
case '\\':
- if (c1 == '\n') /* Multi-line if */
- goto again;
- cerror("Unexpected \\ in #if", NULLST);
- return (OP_FAIL);
+ if (c1 == '\n') /* Multi-line if */
+ goto again;
+ cerror("Unexpected \\ in #if", NULLST);
+ return (OP_FAIL);
}
unget();
}
return (t);
}
-
-FILE_LOCAL int
-dosizeof()
+
/*
* Process the sizeof (basic type) operation in an #if string.
* Sets evalue to the size and returns
* DIG success
* OP_FAIL bad parse or something.
*/
+FILE_LOCAL int dosizeof()
{
- int c;
- TYPES *tp;
- SIZES *sizp;
- short *testp;
- short typecode;
+ int c;
+ TYPES* tp;
+ SIZES* sizp;
+ short* testp;
+ short typecode;
if ((c = skipws()) != '(')
goto nogood;
@@ -490,52 +525,60 @@ dosizeof()
* Scan off the tokens.
*/
typecode = 0;
- while (0 != (c = skipws())) {
+ while (0 != (c = skipws()))
+ {
if ((c = macroid(c)) == EOF_CHAR || c == '\n')
goto nogood; /* End of line is a bug */
- else if (c == '(') { /* thing (*)() func ptr */
- if (skipws() == '*'
- && skipws() == ')') { /* We found (*) */
+ else if (c == '(') /* thing (*)() func ptr */
+ {
+ if (skipws() == '*' && skipws() == ')')
+ { /* We found (*) */
if (skipws() != '(') /* Let () be optional */
unget();
else if (skipws() != ')')
goto nogood;
- typecode |= T_FPTR; /* Function pointer */
+ typecode |= T_FPTR; /* Function pointer */
}
- else { /* Junk is a bug */
+ else /* Junk is a bug */
goto nogood;
- }
}
- else if (type[c] != LET) /* Exit if not a type */
+ else if (type[c] != LET) /* Exit if not a type */
break;
- else if (!catenate()) { /* Maybe combine tokens */
+ else if (!catenate()) /* Maybe combine tokens */
+ {
/*
* Look for this unexpandable token in basic_types.
* The code accepts "int long" as well as "long int"
* which is a minor bug as bugs go (and one shared with
* a lot of C compilers).
*/
- for (tp = basic_types; tp->name != NULLST; tp++) {
+ for (tp = basic_types; tp->name != NULLST; tp++)
+ {
if (streq(token, tp->name))
- break;
+ break;
}
- if (tp->name == NULLST) {
+ if (tp->name == NULLST)
+ {
cerror("#if sizeof, unknown type \"%s\"", token);
return (OP_FAIL);
}
- typecode |= tp->type; /* Or in the type bit */
+ typecode |= tp->type; /* Or in the type bit */
}
}
/*
* We are at the end of the type scan. Chew off '*' if necessary.
*/
- if (c == '*') {
+ if (c == '*')
+ {
typecode |= T_PTR;
c = skipws();
}
- if (c == ')') { /* Last syntax check */
- for (testp = test_table; *testp != 0; testp++) {
- if (!bittest(typecode & *testp)) {
+ if (c == ')') /* Last syntax check */
+ {
+ for (testp = test_table; *testp != 0; testp++)
+ {
+ if (!bittest(typecode & *testp))
+ {
cerror("#if ... sizeof: illegal type combination", NULLST);
return (OP_FAIL);
}
@@ -546,24 +589,28 @@ dosizeof()
* We assume that signed and unsigned don't change the size:
* sizeof (signed int) == (sizeof unsigned int)
*/
- if ((typecode & T_FPTR) != 0) /* Function pointer */
+ if ((typecode & T_FPTR) != 0) /* Function pointer */
typecode = T_FPTR | T_PTR;
- else { /* Var or var * datum */
+ else /* Var or var * datum */
+ {
typecode &= ~(T_SIGNED | T_UNSIGNED);
if ((typecode & (T_SHORT | T_LONG)) != 0)
typecode &= ~T_INT;
}
- if ((typecode & ~T_PTR) == 0) {
+ if ((typecode & ~T_PTR) == 0)
+ {
cerror("#if sizeof() error, no type specified", NULLST);
return (OP_FAIL);
}
/*
* Exactly one bit (and possibly T_PTR) may be set.
*/
- for (sizp = size_table; sizp->bits != 0; sizp++) {
- if ((typecode & ~T_PTR) == sizp->bits) {
+ for (sizp = size_table; sizp->bits != 0; sizp++)
+ {
+ if ((typecode & ~T_PTR) == sizp->bits)
+ {
evalue = ((typecode & T_PTR) != 0)
- ? sizp->psize : sizp->size;
+ ? sizp->psize : sizp->size;
return (DIG);
}
} /* We shouldn't fail */
@@ -571,17 +618,20 @@ dosizeof()
return (OP_FAIL);
}
-nogood: unget();
+ nogood:
+ unget();
cerror("#if ... sizeof() syntax error", NULLST);
return (OP_FAIL);
}
-FILE_LOCAL int
-bittest(int value)
/*
* TRUE if value is zero or exactly one bit is set in value.
*/
+FILE_LOCAL int bittest(int value)
{
+/* whoaa!! really worried about non 2's complement machines...
+ * but not at all about cross-compiling ?
+ */
#if (4096 & ~(-4096)) == 0
return ((value & ~(-value)) == 0);
#else
@@ -592,36 +642,37 @@ bittest(int value)
#endif
}
-FILE_LOCAL int
-evalnum(int c)
/*
* Expand number for #if lexical analysis. Note: evalnum recognizes
* the unsigned suffix, but only returns a signed int value.
*/
+FILE_LOCAL int evalnum(int c)
{
- int value;
- int base;
- int c1;
+ int value;
+ int base;
+ int c1;
if (c != '0')
base = 10;
- else if ((c = cget()) == 'x' || c == 'X') {
+ else if ((c = cget()) == 'x' || c == 'X')
+ {
base = 16;
c = cget();
}
else base = 8;
value = 0;
- for (;;) {
+ for (;;)
+ {
c1 = c;
if (isascii(c) && isupper(c1))
c1 = tolower(c1);
#ifdef EBCDIC
if (c1 <= 'f')
#else
- if (c1 >= 'a')
+ if (c1 >= 'a')
#endif
- c1 -= ('a' - 10);
- else c1 -= '0';
+ c1 -= ('a' - 10);
+ else c1 -= '0';
if (c1 < 0 || c1 >= base)
break;
value *= base;
@@ -634,95 +685,101 @@ evalnum(int c)
return (value);
}
-FILE_LOCAL int
-evalchar(int skip)
/*
* Get a character constant
*/
+FILE_LOCAL int evalchar(int skip)
{
- int c;
- int value;
- int count;
+ int c;
+ int value;
+ int count;
instring = TRUE;
- if ((c = cget()) == '\\') {
- switch ((c = cget())) {
+ if ((c = cget()) == '\\')
+ {
+ switch ((c = cget()))
+ {
case 'a': /* New in Standard */
#if ('a' == '\a' || '\a' == ALERT)
- value = ALERT; /* Use predefined value */
+ value = ALERT; /* Use predefined value */
#else
- value = '\a'; /* Use compiler's value */
+ value = '\a'; /* Use compiler's value */
#endif
- break;
+ break;
case 'b':
- value = '\b';
- break;
+ value = '\b';
+ break;
case 'f':
- value = '\f';
- break;
+ value = '\f';
+ break;
case 'n':
- value = '\n';
- break;
+ value = '\n';
+ break;
case 'r':
- value = '\r';
- break;
+ value = '\r';
+ break;
case 't':
- value = '\t';
- break;
+ value = '\t';
+ break;
case 'v': /* New in Standard */
#if ('v' == '\v' || '\v' == VT)
- value = VT; /* Use predefined value */
+ value = VT; /* Use predefined value */
#else
- value = '\v'; /* Use compiler's value */
+ value = '\v'; /* Use compiler's value */
#endif
- break;
+ break;
case 'x': /* '\xFF' */
- count = 3;
- value = 0;
- while ((((c = get()) >= '0' && c <= '9')
- || (c >= 'a' && c <= 'f')
- || (c >= 'A' && c <= 'F'))
- && (--count >= 0)) {
- value *= 16;
+ count = 3;
+ value = 0;
+ while ((((c = get()) >= '0' && c <= '9') ||
+ (c >= 'a' && c <= 'f') ||
+ (c >= 'A' && c <= 'F')) &&
+ (--count >= 0))
+ {
+ value *= 16;
#ifdef EBCDIC
- value += (c <= '9') ? (c - '0') : ((c & 0xF) + 9);
+ value += (c <= '9') ? (c - '0') : ((c & 0xF) + 9);
#else
- value += (c >= '0') ? (c - '0') : ((c & 0xF) + 9);
+ value += (c >= '0') ? (c - '0') : ((c & 0xF) + 9);
#endif
- }
- unget();
- break;
+ }
+ unget();
+ break;
default:
- if (c >= '0' && c <= '7') {
- count = 3;
- value = 0;
- while (c >= '0' && c <= '7' && --count >= 0) {
- value *= 8;
- value += (c - '0');
- c = get();
+ if (c >= '0' && c <= '7')
+ {
+ count = 3;
+ value = 0;
+ while (c >= '0' && c <= '7' && --count >= 0)
+ {
+ value *= 8;
+ value += (c - '0');
+ c = get();
+ }
+ unget();
}
- unget();
- }
- else value = c;
- break;
+ else value = c;
+ break;
}
}
else if (c == '\'')
value = 0;
- else value = c;
+ else
+ value = c;
/*
* We warn on multi-byte constants and try to hack
* (big|little)endian machines.
*/
- while ((c = get()) != '\'' && c != EOF_CHAR && c != '\n') {
+ while ((c = get()) != '\'' && c != EOF_CHAR && c != '\n')
+ {
if (!skip)
ciwarn("multi-byte constant '%c' isn't portable", c);
value <<= BITS_CHAR;
@@ -732,8 +789,6 @@ evalchar(int skip)
return (value);
}
-FILE_LOCAL int *
-evaleval(int* valp, int op, int skip)
/*
* Apply the argument operator to the data on the value stack.
* One or two values are popped from the value stack and the result
@@ -743,22 +798,25 @@ evaleval(int* valp, int op, int skip)
*
* evaleval() returns the new pointer to the top of the value stack.
*/
+FILE_LOCAL int * evaleval(int* valp, int op, int skip)
{
- int v1, v2 = 0;
+ int v1;
+ int v2 = 0;
if (isbinary(op))
v2 = *--valp;
v1 = *--valp;
#ifdef DEBUG_EVAL
fprintf( pCppOut, "%s op %s", (isbinary(op)) ? "binary" : "unary",
- opname[op]);
+ opname[op]);
if (isbinary(op))
fprintf( pCppOut, ", v2 = %d.", v2);
fprintf( pCppOut, ", v1 = %d.\n", v1);
#endif
- switch (op) {
+ switch (op)
+ {
case OP_EOE:
- break;
+ break;
case OP_ADD:
v1 += v2;
@@ -774,10 +832,12 @@ evaleval(int* valp, int op, int skip)
case OP_DIV:
case OP_MOD:
- if (v2 == 0) {
- if (!skip) {
+ if (v2 == 0)
+ {
+ if (!skip)
+ {
cwarn("%s by zero in #if, zero result assumed",
- (op == OP_DIV) ? "divide" : "mod");
+ (op == OP_DIV) ? "divide" : "mod");
}
v1 = 0;
}
@@ -878,12 +938,14 @@ int value[NEXP]; /* Value stack */
int *valp; /* -> value vector */
{
fprintf( pCppOut, "index op prec skip name -- op stack at %s", infile->bptr);
- while (opp > opstack) {
+ while (opp > opstack)
+ {
fprintf( pCppOut, " [%2d] %2d %03o %d %s\n", opp - opstack,
- opp->op, opp->prec, opp->skip, opname[opp->op]);
+ opp->op, opp->prec, opp->skip, opname[opp->op]);
opp--;
}
- while (--valp >= value) {
+ while (--valp >= value)
+ {
fprintf( pCppOut, "value[%d] = %d\n", (valp - value), *valp);
}
}
diff --git a/rsc/source/rscpp/cpp6.c b/rsc/source/rscpp/cpp6.c
index 45297a25825b..a024e7777516 100644
--- a/rsc/source/rscpp/cpp6.c
+++ b/rsc/source/rscpp/cpp6.c
@@ -185,75 +185,76 @@ void InitCpp6()
-void skipnl()
/*
* Skip to the end of the current input line.
*/
+void skipnl()
{
- int c;
+ int c;
- do { /* Skip to newline */
- c = get();
- } while (c != '\n' && c != EOF_CHAR);
+ do
+ { /* Skip to newline */
+ c = get();
+ }
+ while (c != '\n' && c != EOF_CHAR);
}
-int
-skipws()
/*
* Skip over whitespace
*/
+int skipws()
{
- int c;
+ int c;
- do { /* Skip whitespace */
- c = get();
- } while (type[c] == SPA);
- return (c);
+ do { /* Skip whitespace */
+ c = get();
+ } while (type[c] == SPA);
+ return (c);
}
-void scanid(int c)
/*
* Get the next token (an id) into the token buffer.
* Note: this code is duplicated in lookid().
* Change one, change both.
*/
+void scanid(int c)
{
- char *bp;
-
- if (c == DEF_MAGIC) /* Eat the magic token */
- c = get(); /* undefiner. */
- bp = token;
- do {
- if (bp < &token[IDMAX]) /* token dim is IDMAX+1 */
- *bp++ = (char)c;
- c = get();
- } while (type[c] == LET || type[c] == DIG);
- unget();
- *bp = EOS;
+ char* bp;
+
+ if (c == DEF_MAGIC) /* Eat the magic token */
+ c = get(); /* undefiner. */
+ bp = token;
+ do
+ {
+ if (bp < &token[IDMAX]) /* token dim is IDMAX+1 */
+ *bp++ = (char)c;
+ c = get();
+ }
+ while (type[c] == LET || type[c] == DIG);
+ unget();
+ *bp = EOS;
}
-int
-macroid(int c)
/*
* If c is a letter, scan the id. if it's #defined, expand it and scan
* the next character and try again.
*
* Else, return the character. If type[c] is a LET, the token is in token.
*/
+int macroid(int c)
{
- DEFBUF *dp;
-
- if (infile != NULL && infile->fp != NULL)
- recursion = 0;
- while (type[c] == LET && (dp = lookid(c)) != NULL) {
- expand(dp);
- c = get();
- }
- return (c);
+ DEFBUF* dp;
+
+ if (infile != NULL && infile->fp != NULL)
+ recursion = 0;
+ while (type[c] == LET && (dp = lookid(c)) != NULL)
+ {
+ expand(dp);
+ c = get();
+ }
+ return (c);
}
-int
-catenate()
/*
* A token was just read (via macroid).
* If the next character is TOK_SEP, concatenate the next token
@@ -261,492 +262,531 @@ catenate()
* macroid's argument. If it is not TOK_SEP, unget() the character
* and return FALSE.
*/
+int catenate()
{
- int c;
- char *token1;
-
- if (get() != TOK_SEP) { /* Token concatenation */
- unget();
- return (FALSE);
- }
- else {
- token1 = savestring(token); /* Save first token */
- c = macroid(get()); /* Scan next token */
- switch(type[c]) { /* What was it? */
- case LET: /* An identifier, ... */
- if (strlen(token1) + strlen(token) >= NWORK)
- cfatal("work buffer overflow doing %s #", token1);
- sprintf(work, "%s%s", token1, token);
- break;
+ int c;
+ char* token1;
- case DIG: /* A digit string */
- strcpy(work, token1);
- workp = work + strlen(work);
- do {
- save(c);
- } while ((c = get()) != TOK_SEP);
- /*
- * The trailing TOK_SEP is no longer needed.
- */
- save(EOS);
- break;
-
- default: /* An error, ... */
- if (isprint(c))
- cierror("Strange character '%c' after #", c);
- else
- cierror("Strange character (%d.) after #", c);
- strcpy(work, token1);
- unget();
- break;
+ if (get() != TOK_SEP) /* Token concatenation */
+ {
+ unget();
+ return (FALSE);
+ }
+ else
+ {
+ token1 = savestring(token); /* Save first token */
+ c = macroid(get()); /* Scan next token */
+ switch(type[c]) /* What was it? */
+ {
+ case LET: /* An identifier, ... */
+ if (strlen(token1) + strlen(token) >= NWORK)
+ cfatal("work buffer overflow doing %s #", token1);
+ sprintf(work, "%s%s", token1, token);
+ break;
+
+ case DIG: /* A digit string */
+ strcpy(work, token1);
+ workp = work + strlen(work);
+ do
+ {
+ save(c);
}
+ while ((c = get()) != TOK_SEP);
/*
- * work has the concatenated token and token1 has
- * the first token (no longer needed). Unget the
- * new (concatenated) token after freeing token1.
- * Finally, setup to read the new token.
+ * The trailing TOK_SEP is no longer needed.
*/
- free(token1); /* Free up memory */
- ungetstring(work); /* Unget the new thing, */
- return (TRUE);
+ save(EOS);
+ break;
+
+ default: /* An error, ... */
+ if (isprint(c))
+ cierror("Strange character '%c' after #", c);
+ else
+ cierror("Strange character (%d.) after #", c);
+ strcpy(work, token1);
+ unget();
+ break;
}
+ /*
+ * work has the concatenated token and token1 has
+ * the first token (no longer needed). Unget the
+ * new (concatenated) token after freeing token1.
+ * Finally, setup to read the new token.
+ */
+ free(token1); /* Free up memory */
+ ungetstring(work); /* Unget the new thing, */
+ return (TRUE);
+ }
}
-int
-scanstring(int delim,
-#ifndef _NO_PROTO
-void (*outfun)( int ) /* BP */ /* Output function */
-#else
-void (*outfun)() /* BP */
-#endif
-)
/*
* 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.
*/
+int scanstring(int delim,
+#ifndef _NO_PROTO
+ void (*outfun)( int ) /* BP */ /* Output function */
+#else
+ void (*outfun)() /* BP */
+#endif
+ )
{
- int c;
-
- instring = TRUE; /* Don't strip comments */
- (*outfun)(delim);
- while ((c = get()) != delim
- && c != '\n'
- && c != EOF_CHAR) {
-
- if (c != DEF_MAGIC)
- (*outfun)(c);
- if (c == '\\')
- (*outfun)(get());
- }
- instring = FALSE;
- if (c == delim) {
+ int c;
+
+ instring = TRUE; /* Don't strip comments */
+ (*outfun)(delim);
+ while ((c = get()) != delim &&
+ c != '\n' &&
+ c != EOF_CHAR)
+ {
+ if (c != DEF_MAGIC)
(*outfun)(c);
- return (TRUE);
- }
- else {
- cerror("Unterminated string", NULLST);
- unget();
- return (FALSE);
- }
+ if (c == '\\')
+ (*outfun)(get());
+ }
+ instring = FALSE;
+ if (c == delim)
+ {
+ (*outfun)(c);
+ return (TRUE);
+ }
+ else
+ {
+ cerror("Unterminated string", NULLST);
+ unget();
+ return (FALSE);
+ }
}
-void scannumber(int c,
-#ifndef _NO_PROTO
-void (*outfun)( int ) /* BP */ /* Output/store func */
-#else
-void (*outfun)() /* BP */
-#endif
-)
/*
* Process a number. We know that c is from 0 to 9 or dot.
* Algorithm from Dave Conroy's Decus C.
*/
+void scannumber(int c,
+#ifndef _NO_PROTO
+ void (*outfun)( int ) /* BP */ /* Output/store func */
+#else
+ void (*outfun)() /* BP */
+#endif
+ )
{
- int radix; /* 8, 10, or 16 */
- int expseen; /* 'e' seen in floater */
- int signseen; /* '+' or '-' seen */
- int octal89; /* For bad octal test */
- int dotflag; /* TRUE if '.' was seen */
-
- expseen = FALSE; /* No exponent seen yet */
- signseen = TRUE; /* No +/- allowed yet */
- octal89 = FALSE; /* No bad octal yet */
- radix = 10; /* Assume decimal */
- if ((dotflag = (c == '.')) != FALSE) { /* . something? */
- (*outfun)('.'); /* Always out the dot */
- if (type[(c = get())] != DIG) { /* If not a float numb, */
- unget(); /* Rescan strange char */
- return; /* All done for now */
- }
- } /* End of float test */
- else if (c == '0') { /* Octal or hex? */
- (*outfun)(c); /* Stuff initial zero */
- radix = 8; /* Assume it's octal */
- c = get(); /* Look for an 'x' */
- if (c == 'x' || c == 'X') { /* Did we get one? */
- radix = 16; /* Remember new radix */
- (*outfun)(c); /* Stuff the 'x' */
- c = get(); /* Get next character */
- }
+ int radix; /* 8, 10, or 16 */
+ int expseen; /* 'e' seen in floater */
+ int signseen; /* '+' or '-' seen */
+ int octal89; /* For bad octal test */
+ int dotflag; /* TRUE if '.' was seen */
+
+ expseen = FALSE; /* No exponent seen yet */
+ signseen = TRUE; /* No +/- allowed yet */
+ octal89 = FALSE; /* No bad octal yet */
+ radix = 10; /* Assume decimal */
+ if ((dotflag = (c == '.')) != FALSE) /* . something? */
+ {
+ (*outfun)('.'); /* Always out the dot */
+ if (type[(c = get())] != DIG) /* If not a float numb, */
+ {
+ unget(); /* Rescan strange char */
+ return; /* All done for now */
}
- for (;;) { /* Process curr. char. */
- /*
- * Note that this algorithm accepts "012e4" and "03.4"
- * as legitimate floating-point numbers.
- */
- 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 */
- radix = 10; /* Decimal exponent */
- }
- else if (radix != 16 && c == '.') {
- if (dotflag) /* Saw dot already? */
- break; /* Exit loop, two dots */
- dotflag = 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 */
- }
- else { /* Check the digit */
- switch (c) {
- case '8': case '9': /* Sometimes wrong */
- octal89 = TRUE; /* Do check later */
- case '0': case '1': case '2': case '3':
- case '4': case '5': case '6': case '7':
- break; /* Always ok */
-
- case 'a': case 'b': case 'c': case 'd': case 'e': case 'f':
- case 'A': case 'B': case 'C': case 'D': case 'E': case 'F':
- if (radix == 16) /* Alpha's are ok only */
- break; /* if reading hex. */
- default: /* At number end */
- goto done; /* Break from for loop */
- } /* End of switch */
- } /* End general case */
- (*outfun)(c); /* Accept the character */
- signseen = TRUE; /* Don't read sign now */
- c = get(); /* Read another char */
- } /* End of scan loop */
+ } /* End of float test */
+ else if (c == '0') /* Octal or hex? */
+ {
+ (*outfun)(c); /* Stuff initial zero */
+ radix = 8; /* Assume it's octal */
+ c = get(); /* Look for an 'x' */
+ if (c == 'x' || c == 'X') /* Did we get one? */
+ {
+ radix = 16; /* Remember new radix */
+ (*outfun)(c); /* Stuff the 'x' */
+ c = get(); /* Get next character */
+ }
+ }
+ for (;;) /* Process curr. char. */
+ {
/*
- * When we break out of the scan loop, c contains the first
- * character (maybe) not in the number. If the number is an
- * integer, allow a trailing 'L' for long and/or a trailing 'U'
- * for unsigned. If not those, push the trailing character back
- * on the input stream. Floating point numbers accept a trailing
- * 'L' for "long double".
+ * Note that this algorithm accepts "012e4" and "03.4"
+ * as legitimate floating-point numbers.
*/
-done: if (dotflag || expseen) { /* Floating point? */
- if (c == 'l' || c == 'L') {
- (*outfun)(c);
- get(); /* Ungotten later */
- }
+ 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 */
+ radix = 10; /* Decimal exponent */
}
- else { /* Else it's an integer */
- /*
- * We know that dotflag and expseen are both zero, now:
- * dotflag signals "saw 'L'", and
- * expseen signals "saw 'U'".
- */
- for (;;) {
- switch (c) {
- case 'l':
- case 'L':
- if (dotflag)
- goto nomore;
- dotflag = TRUE;
- break;
-
- case 'u':
- case 'U':
- if (expseen)
- goto nomore;
- expseen = TRUE;
- break;
-
- default:
+ else if (radix != 16 && c == '.')
+ {
+ if (dotflag) /* Saw dot already? */
+ break; /* Exit loop, two dots */
+ dotflag = 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 */
+ }
+ else /* Check the digit */
+ {
+ switch (c)
+ {
+ case '8': case '9': /* Sometimes wrong */
+ octal89 = TRUE; /* Do check later */
+ case '0': case '1': case '2': case '3':
+ case '4': case '5': case '6': case '7':
+ break; /* Always ok */
+
+ case 'a': case 'b': case 'c': case 'd': case 'e': case 'f':
+ case 'A': case 'B': case 'C': case 'D': case 'E': case 'F':
+ if (radix == 16) /* Alpha's are ok only */
+ break; /* if reading hex. */
+ default: /* At number end */
+ goto done; /* Break from for loop */
+ } /* End of switch */
+ } /* End general case */
+ (*outfun)(c); /* Accept the character */
+ signseen = TRUE; /* Don't read sign now */
+ c = get(); /* Read another char */
+ } /* End of scan loop */
+ /*
+ * When we break out of the scan loop, c contains the first
+ * character (maybe) not in the number. If the number is an
+ * integer, allow a trailing 'L' for long and/or a trailing 'U'
+ * for unsigned. If not those, push the trailing character back
+ * on the input stream. Floating point numbers accept a trailing
+ * 'L' for "long double".
+ */
+ done:
+ if (dotflag || expseen) /* Floating point? */
+ {
+ if (c == 'l' || c == 'L')
+ {
+ (*outfun)(c);
+ get(); /* Ungotten later */
+ }
+ }
+ else /* Else it's an integer */
+ {
+ /*
+ * We know that dotflag and expseen are both zero, now:
+ * dotflag signals "saw 'L'", and
+ * expseen signals "saw 'U'".
+ */
+ for (;;)
+ {
+ switch (c)
+ {
+ case 'l':
+ case 'L':
+ if (dotflag)
goto nomore;
- }
- (*outfun)(c); /* Got 'L' or 'U'. */
- c = get(); /* Look at next, too. */
+ dotflag = TRUE;
+ break;
+
+ case 'u':
+ case 'U':
+ if (expseen)
+ goto nomore;
+ expseen = TRUE;
+ break;
+
+ default:
+ goto nomore;
}
+ (*outfun)(c); /* Got 'L' or 'U'. */
+ c = get(); /* Look at next, too. */
}
-nomore: unget(); /* Not part of a number */
- if (octal89 && radix == 8)
- cwarn("Illegal digit in octal number", NULLST);
+ }
+ nomore:
+ unget(); /* Not part of a number */
+ if (octal89 && radix == 8)
+ cwarn("Illegal digit in octal number", NULLST);
}
void save(int c)
{
- if (workp >= &work[NWORK]) {
- work[NWORK-1] = '\0';
- cfatal("Work buffer overflow: %s", work);
- }
- else *workp++ = (char)c;
+ if (workp >= &work[NWORK])
+ {
+ work[NWORK-1] = '\0';
+ cfatal("Work buffer overflow: %s", work);
+ }
+ else
+ *workp++ = (char)c;
}
-char *
-savestring(char* text)
/*
* Store a string into free memory.
*/
+char* savestring(char* text)
{
- char *result;
+ char* result;
- result = getmem(strlen(text) + 1);
- strcpy(result, text);
- return (result);
+ result = getmem(strlen(text) + 1);
+ strcpy(result, text);
+ return (result);
}
-FILEINFO *
-getfile(int bufsize, char* name)
/*
* Common FILEINFO buffer initialization for a new file or macro.
*/
+FILEINFO* getfile(int bufsize, char* name)
{
- FILEINFO *file;
- int size;
-
- size = strlen(name); /* File/macro name */
- file = (FILEINFO *) getmem(sizeof (FILEINFO) + bufsize + size);
- file->parent = infile; /* Chain files together */
- file->fp = NULL; /* No file yet */
- file->filename = savestring(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 */
- file->buffer[0] = EOS; /* Force first read */
- file->line = 0; /* (Not used just yet) */
- if (infile != NULL) /* If #include file */
- infile->line = line; /* Save current line */
- infile = file; /* New current file */
- line = 1; /* Note first line */
- return (file); /* All done. */
+ FILEINFO* file;
+ int size;
+
+ size = strlen(name); /* File/macro name */
+ file = (FILEINFO*) getmem(sizeof (FILEINFO) + bufsize + size);
+ file->parent = infile; /* Chain files together */
+ file->fp = NULL; /* No file yet */
+ file->filename = savestring(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 */
+ file->buffer[0] = EOS; /* Force first read */
+ file->line = 0; /* (Not used just yet) */
+ if (infile != NULL) /* If #include file */
+ infile->line = line; /* Save current line */
+ infile = file; /* New current file */
+ line = 1; /* Note first line */
+ return (file); /* All done. */
}
-char *
-getmem(int size)
/*
* Get a block of free memory.
*/
+char* getmem(int size)
{
- char *result;
+ char* result;
- if ((result = malloc((unsigned) size)) == NULL)
- cfatal("Out of memory", NULLST);
- return (result);
+ if ((result = malloc((unsigned) size)) == NULL)
+ cfatal("Out of memory", NULLST);
+ return (result);
}
-DEFBUF *
-lookid(int c)
/*
* Look for the next token in the symbol table. Returns token in "token".
* If found, returns the table pointer; Else returns NULL.
*/
+DEFBUF* lookid(int c)
{
- int nhash;
- DEFBUF *dp;
- char *np;
- int temp = 0;
- int isrecurse; /* For #define foo foo */
-
- np = token;
- nhash = 0;
- if (0 != (isrecurse = (c == DEF_MAGIC))) /* If recursive macro */
- c = get(); /* hack, skip DEF_MAGIC */
- do {
- if (np < &token[IDMAX]) { /* token dim is IDMAX+1 */
- *np++ = (char)c; /* Store token byte */
- nhash += c; /* Update hash value */
- }
- c = get(); /* And get another byte */
- } while (type[c] == LET || type[c] == DIG);
- unget(); /* Rescan terminator */
- *np = EOS; /* Terminate token */
- if (isrecurse) /* Recursive definition */
- return (NULL); /* undefined just now */
- nhash += (np - token); /* Fix hash value */
- dp = symtab[nhash & SBMASK]; /* Starting bucket */
- while (dp != (DEFBUF *) NULL) { /* Search symbol table */
- if (dp->hash == nhash /* Fast precheck */
- && (temp = strcmp(dp->name, token)) >= 0)
- break;
- dp = dp->link; /* Nope, try next one */
+ int nhash;
+ DEFBUF* dp;
+ char* np;
+ int temp = 0;
+ int isrecurse; /* For #define foo foo */
+
+ np = token;
+ nhash = 0;
+ if (0 != (isrecurse = (c == DEF_MAGIC)))/* If recursive macro */
+ c = get(); /* hack, skip DEF_MAGIC */
+ do
+ {
+ if (np < &token[IDMAX]) /* token dim is IDMAX+1 */
+ {
+ *np++ = (char)c; /* Store token byte */
+ nhash += c; /* Update hash value */
}
- return ((temp == 0) ? dp : NULL);
+ c = get(); /* And get another byte */
+ }
+ while (type[c] == LET || type[c] == DIG);
+ unget(); /* Rescan terminator */
+ *np = EOS; /* Terminate token */
+ if (isrecurse) /* Recursive definition */
+ return (NULL); /* undefined just now */
+ nhash += (np - token); /* Fix hash value */
+ dp = symtab[nhash & SBMASK]; /* Starting bucket */
+ while (dp != (DEFBUF*) NULL) /* Search symbol table */
+ {
+ if (dp->hash == nhash && /* Fast precheck */
+ (temp = strcmp(dp->name, token)) >= 0)
+ {
+ break;
+ }
+ dp = dp->link; /* Nope, try next one */
+ }
+ return ((temp == 0) ? dp : NULL);
}
-DEFBUF *
-defendel(char* name, int delete)
/*
* 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).
*/
+DEFBUF* defendel(char* name, int delete)
{
- DEFBUF *dp;
- DEFBUF **prevp;
- char *np;
- int nhash;
- int temp;
- int size;
-
- for (nhash = 0, np = name; *np != EOS;)
- nhash += *np++;
- size = (np - name);
- nhash += size;
- prevp = &symtab[nhash & SBMASK];
- while ((dp = *prevp) != (DEFBUF *) NULL) {
- if (dp->hash == nhash
- && (temp = strcmp(dp->name, name)) >= 0) {
- if (temp > 0)
- dp = NULL; /* Not found */
- else {
- *prevp = dp->link; /* Found, unlink and */
- if (dp->repl != NULL) /* Free the replacement */
- free(dp->repl); /* if any, and then */
- free((char *) dp); /* Free the symbol */
- dp = NULL;
- }
- break;
+ DEFBUF* dp;
+ DEFBUF** prevp;
+ char* np;
+ int nhash;
+ int temp;
+ int size;
+
+ for (nhash = 0, np = name; *np != EOS;)
+ nhash += *np++;
+ size = (np - name);
+ nhash += size;
+ prevp = &symtab[nhash & SBMASK];
+ while ((dp = *prevp) != (DEFBUF*) NULL)
+ {
+ if (dp->hash == nhash &&
+ (temp = strcmp(dp->name, name)) >= 0)
+ {
+ if (temp > 0)
+ dp = NULL; /* Not found */
+ else
+ {
+ *prevp = dp->link; /* Found, unlink and */
+ if (dp->repl != NULL) /* Free the replacement */
+ free(dp->repl); /* if any, and then */
+ free((char*) dp); /* Free the symbol */
+ dp = NULL;
}
- prevp = &dp->link;
- }
- if (!delete) {
- dp = (DEFBUF *) getmem(sizeof (DEFBUF) + size);
- dp->link = *prevp;
- *prevp = dp;
- dp->hash = nhash;
- dp->repl = NULL;
- dp->nargs = 0;
- strcpy(dp->name, name);
+ break;
}
- return (dp);
+ prevp = &dp->link;
+ }
+ if (!delete)
+ {
+ dp = (DEFBUF*) getmem(sizeof (DEFBUF) + size);
+ dp->link = *prevp;
+ *prevp = dp;
+ dp->hash = nhash;
+ dp->repl = NULL;
+ dp->nargs = 0;
+ strcpy(dp->name, name);
+ }
+ return (dp);
}
#if OSL_DEBUG_LEVEL > 1
-void dumpdef(char *why)
+void dumpdef(char* why)
{
- DEFBUF *dp;
- DEFBUF **syp;
- FILE *pRememberOut = NULL;
-
- if ( bDumpDefs ) /*ER */
+ DEFBUF* dp;
+ DEFBUF** syp;
+ FILE* pRememberOut = NULL;
+
+ if ( bDumpDefs ) /*ER */
+ {
+ pRememberOut = pCppOut;
+ pCppOut = pDefOut;
+ }
+ fprintf( pCppOut, "CPP symbol table dump %s\n", why);
+ for (syp = symtab; syp < &symtab[SBSIZE]; syp++)
+ {
+ if ((dp = *syp) != (DEFBUF*) NULL)
{
- pRememberOut = pCppOut;
- pCppOut = pDefOut;
- }
- fprintf( pCppOut, "CPP symbol table dump %s\n", why);
- for (syp = symtab; syp < &symtab[SBSIZE]; syp++) {
- if ((dp = *syp) != (DEFBUF *) NULL) {
- fprintf( pCppOut, "symtab[%" SAL_PRI_PTRDIFFT "d]\n", (syp - symtab));
- do {
- dumpadef((char *) NULL, dp);
- } while ((dp = dp->link) != (DEFBUF *) NULL);
+ fprintf( pCppOut, "symtab[%" SAL_PRI_PTRDIFFT "d]\n", (syp - symtab));
+ do
+ {
+ dumpadef((char*) NULL, dp);
}
+ while ((dp = dp->link) != (DEFBUF*) NULL);
}
- if ( bDumpDefs )
- {
- fprintf( pCppOut, "\n");
- pCppOut = pRememberOut;
- }
+ }
+ if ( bDumpDefs )
+ {
+ fprintf( pCppOut, "\n");
+ pCppOut = pRememberOut;
+ }
}
-void dumpadef(char *why, DEFBUF *dp)
+void dumpadef(char* why, DEFBUF* dp)
{
- char *cp;
- int c;
- FILE *pRememberOut = NULL;
+ char* cp;
+ int c;
+ FILE* pRememberOut = NULL;
/*ER dump #define's to pDefOut */
- if ( bDumpDefs )
+ if ( bDumpDefs )
+ {
+ pRememberOut = pCppOut;
+ pCppOut = pDefOut;
+ }
+ fprintf( pCppOut, " \"%s\" [%d]", dp->name, dp->nargs);
+ if (why != NULL)
+ fprintf( pCppOut, " (%s)", why);
+ if (dp->repl != NULL)
+ {
+ fprintf( pCppOut, " => ");
+ for (cp = dp->repl; (c = *cp++ & 0xFF) != EOS;)
{
- pRememberOut = pCppOut;
- pCppOut = pDefOut;
- }
- fprintf( pCppOut, " \"%s\" [%d]", dp->name, dp->nargs);
- if (why != NULL)
- fprintf( pCppOut, " (%s)", why);
- if (dp->repl != NULL) {
- fprintf( pCppOut, " => ");
- for (cp = dp->repl; (c = *cp++ & 0xFF) != EOS;) {
#ifdef SOLAR
- if (c == DEL) {
- c = *cp++ & 0xFF;
- if( c == EOS ) break;
- fprintf( pCppOut, "<%%%d>", c - MAC_PARM);
- }
+ if (c == DEL)
+ {
+ c = *cp++ & 0xFF;
+ if( c == EOS ) break;
+ fprintf( pCppOut, "<%%%d>", c - MAC_PARM);
+ }
#else
- if (c >= MAC_PARM && c <= (MAC_PARM + PAR_MAC))
- fprintf( pCppOut, "<%%%d>", c - MAC_PARM);
+ if (c >= MAC_PARM && c <= (MAC_PARM + PAR_MAC))
+ fprintf( pCppOut, "<%%%d>", c - MAC_PARM);
#endif
- else if (isprint(c) || c == '\n' || c == '\t')
- PUTCHAR(c);
- else if (c < ' ')
- fprintf( pCppOut, "<^%c>", c + '@');
- else
- fprintf( pCppOut, "<\\0%o>", c);
- }
+ else if (isprint(c) || c == '\n' || c == '\t')
+ PUTCHAR(c);
+ else if (c < ' ')
+ fprintf( pCppOut, "<^%c>", c + '@');
+ else
+ fprintf( pCppOut, "<\\0%o>", c);
+ }
/*ER evaluate macros to pDefOut */
#ifdef EVALDEFS
- if ( bDumpDefs && !bIsInEval && dp->nargs <= 0 )
+ if ( bDumpDefs && !bIsInEval && dp->nargs <= 0 )
+ {
+ FILEINFO* infileSave = infile;
+ char* tokenSave = savestring( token );
+ char* workSave = savestring( work );
+ int lineSave = line;
+ int wronglineSave = wrongline;
+ int recursionSave = recursion;
+ FILEINFO* file;
+ EVALTYPE valEval;
+
+ bIsInEval = 1;
+ infile = NULL; /* start from scrap */
+ line = 0;
+ wrongline = 0;
+ *token = EOS;
+ *work = EOS;
+ recursion = 0;
+ file = getfile( strlen( dp->repl ), dp->name );
+ strcpy( file->buffer, dp->repl );
+ fprintf( pCppOut, " ===> ");
+ nEvalOff = 0;
+ cppmain(); /* get() frees also *file */
+ valEval = 0;
+ if ( 0 == evaluate( EvalBuf, &valEval ) )
{
- FILEINFO *infileSave = infile;
- char *tokenSave = savestring( token );
- char *workSave = savestring( work );
- int lineSave = line;
- int wronglineSave = wrongline;
- int recursionSave = recursion;
- FILEINFO *file;
- EVALTYPE valEval;
-
- bIsInEval = 1;
- infile = NULL; /* start from scrap */
- line = 0;
- wrongline = 0;
- *token = EOS;
- *work = EOS;
- recursion = 0;
- file = getfile( strlen( dp->repl ), dp->name );
- strcpy( file->buffer, dp->repl );
- fprintf( pCppOut, " ===> ");
- nEvalOff = 0;
- cppmain(); /* get() frees also *file */
- valEval = 0;
- if ( 0 == evaluate( EvalBuf, &valEval ) )
- {
#ifdef EVALFLOATS
- if ( valEval != (EVALTYPE)((long)valEval ) )
- fprintf( pCppOut, " ==eval=> %f", valEval );
- else
+ if ( valEval != (EVALTYPE)((long)valEval ) )
+ fprintf( pCppOut, " ==eval=> %f", valEval );
+ else
#endif
- fprintf( pCppOut, " ==eval=> %ld", (long)valEval );
- }
- recursion = recursionSave;
- wrongline = wronglineSave;
- line = lineSave;
- strcpy( work, workSave );
- free( workSave );
- strcpy( token, tokenSave );
- free( tokenSave );
- infile = infileSave;
- bIsInEval = 0;
+ fprintf( pCppOut, " ==eval=> %ld", (long)valEval );
}
-#endif
- }
- else {
- fprintf( pCppOut, ", no replacement.");
+ recursion = recursionSave;
+ wrongline = wronglineSave;
+ line = lineSave;
+ strcpy( work, workSave );
+ free( workSave );
+ strcpy( token, tokenSave );
+ free( tokenSave );
+ infile = infileSave;
+ bIsInEval = 0;
}
- PUTCHAR('\n');
- if ( bDumpDefs )
- pCppOut = pRememberOut;
+#endif
+ }
+ else
+ {
+ fprintf( pCppOut, ", no replacement.");
+ }
+ PUTCHAR('\n');
+ if ( bDumpDefs )
+ pCppOut = pRememberOut;
}
#endif
@@ -754,269 +794,290 @@ void dumpadef(char *why, DEFBUF *dp)
* G E T
*/
-int
-get()
/*
* Return the next character from a macro or the current file.
* Handle end of file from #include files.
*/
+int get()
{
- int c;
- FILEINFO *file;
- int popped; /* Recursion fixup */
-
- popped = 0;
-get_from_file:
- if ((file = infile) == NULL)
- return (EOF_CHAR);
-newline:
-
+ int c;
+ FILEINFO* file;
+ int popped; /* Recursion fixup */
+
+ popped = 0;
+ get_from_file:
+ if ((file = infile) == NULL)
+ return (EOF_CHAR);
+ newline:
+
+ /*
+ * Read a character from the current input line or macro.
+ * At EOS, either finish the current macro (freeing temp.
+ * storage) or read another line from the current input file.
+ * At EOF, exit the current file (#include) or, at EOF from
+ * the cpp input file, return EOF_CHAR to finish processing.
+ */
+ if ((c = *file->bptr++ & 0xFF) == EOS)
+ {
/*
- * Read a character from the current input line or macro.
- * At EOS, either finish the current macro (freeing temp.
- * storage) or read another line from the current input file.
- * At EOF, exit the current file (#include) or, at EOF from
- * the cpp input file, return EOF_CHAR to finish processing.
+ * Nothing in current line or macro. Get next line (if
+ * input from a file), or do end of file/macro processing.
+ * In the latter case, jump back to restart from the top.
*/
- if ((c = *file->bptr++ & 0xFF) == EOS) {
- /*
- * Nothing in current line or macro. Get next line (if
- * input from a file), or do end of file/macro processing.
- * In the latter case, jump back to restart from the top.
- */
- if (file->fp == NULL) { /* NULL if macro */
- popped++;
- recursion -= file->unrecur;
- if (recursion < 0)
- recursion = 0;
- infile = file->parent; /* Unwind file chain */
- }
- else { /* Else get from a file */
- if ((file->bptr = fgets(file->buffer, NBUFF, file->fp))
- != NULL) {
+ if (file->fp == NULL) /* NULL if macro */
+ {
+ popped++;
+ recursion -= file->unrecur;
+ if (recursion < 0)
+ recursion = 0;
+ infile = file->parent; /* Unwind file chain */
+ }
+ else /* Else get from a file */
+ {
+ if ((file->bptr = fgets(file->buffer, NBUFF, file->fp)) != NULL)
+ {
#if OSL_DEBUG_LEVEL > 1
- if (debug > 1) { /* Dump it to stdout */
- fprintf( pCppOut, "\n#line %d (%s), %s",
- line, file->filename, file->buffer);
- }
-#endif
- goto newline; /* process the line */
+ if (debug > 1) /* Dump it to stdout */
+ {
+ fprintf( pCppOut, "\n#line %d (%s), %s",
+ line, file->filename, file->buffer);
}
- else {
- if( file->fp != stdin )
- fclose(file->fp); /* Close finished file */
- if ((infile = file->parent) != NULL) {
- /*
- * There is an "ungotten" newline in the current
- * infile buffer (set there by doinclude() in
- * cpp1.c). Thus, we know that the mainline code
- * is skipping over blank lines and will do a
- * #line at its convenience.
- */
- wrongline = TRUE; /* Need a #line now */
- }
+#endif
+ goto newline; /* process the line */
+ }
+ else
+ {
+ if( file->fp != stdin )
+ fclose(file->fp); /* Close finished file */
+ if ((infile = file->parent) != NULL)
+ {
+ /*
+ * There is an "ungotten" newline in the current
+ * infile buffer (set there by doinclude() in
+ * cpp1.c). Thus, we know that the mainline code
+ * is skipping over blank lines and will do a
+ * #line at its convenience.
+ */
+ wrongline = TRUE; /* Need a #line now */
}
}
- /*
- * Free up space used by the (finished) file or macro and
- * restart input from the parent file/macro, if any.
- */
- free(file->filename); /* Free name and */
- if (file->progname != NULL) /* if a #line was seen, */
- free(file->progname); /* free it, too. */
- free((char *) file); /* Free file space */
- if (infile == NULL) /* If at end of file */
- return (EOF_CHAR); /* Return end of file */
- line = infile->line; /* Reset line number */
- goto get_from_file; /* Get from the top. */
}
/*
- * Common processing for the new character.
+ * Free up space used by the (finished) file or macro and
+ * restart input from the parent file/macro, if any.
*/
- if (c == DEF_MAGIC && file->fp != NULL) /* Don't allow delete */
- goto newline; /* from a file */
- if (file->parent != NULL) { /* Macro or #include */
- if (popped != 0)
- file->parent->unrecur += popped;
- else {
- recursion -= file->parent->unrecur;
- if (recursion < 0)
- recursion = 0;
- file->parent->unrecur = 0;
- }
+ free(file->filename); /* Free name and */
+ if (file->progname != NULL) /* if a #line was seen, */
+ free(file->progname); /* free it, too. */
+ free((char*) file); /* Free file space */
+ if (infile == NULL) /* If at end of file */
+ return (EOF_CHAR); /* Return end of file */
+ line = infile->line; /* Reset line number */
+ goto get_from_file; /* Get from the top. */
+ }
+ /*
+ * Common processing for the new character.
+ */
+ if (c == DEF_MAGIC && file->fp != NULL) /* Don't allow delete */
+ goto newline; /* from a file */
+ if (file->parent != NULL) /* Macro or #include */
+ {
+ if (popped != 0)
+ file->parent->unrecur += popped;
+ else
+ {
+ recursion -= file->parent->unrecur;
+ if (recursion < 0)
+ recursion = 0;
+ file->parent->unrecur = 0;
}
+ }
#if (HOST == SYS_UNIX)
-/*ER*/ if (c == '\r')
-/*ER*/ return get(); /* DOS fuck */
+ if (c == '\r')
+ return get(); /* DOS fuck */
#endif
- if (c == '\n') /* Maintain current */
- ++line; /* line counter */
- if (instring) /* Strings just return */
- return (c); /* the character. */
- else if (c == '/') { /* Comment? */
- instring = TRUE; /* So get() won't loop */
-/*MM c++ comments */
-/*MM*/ c = get();
-/*MM*/ if ((c != '*') && (c != '/')) { /* Next byte '*'? */
- instring = FALSE; /* Nope, no comment */
- unget(); /* Push the char. back */
- return ('/'); /* Return the slash */
- }
- if (keepcomments) { /* If writing comments */
- PUTCHAR('/'); /* Write out the */
- /* initializer */
-/*MM*/ if( '*' == c )
- PUTCHAR('*');
-/*MM*/ else
-/*MM*/ PUTCHAR('/');
+ if (c == '\n') /* Maintain current */
+ ++line; /* line counter */
+ if (instring) /* Strings just return */
+ return (c); /* the character. */
+ else if (c == '/') /* Comment? */
+ {
+ instring = TRUE; /* So get() won't loop */
+
+ c = get();
+ if ((c != '*') && (c != '/')) /* Next byte '*'? */
+ {
+ instring = FALSE; /* Nope, no comment */
+ unget(); /* Push the char. back */
+ return ('/'); /* Return the slash */
+ }
+ if (keepcomments) /* If writing comments */
+ {
+ PUTCHAR('/'); /* Write out the */
+ /* initializer */
+ if( '*' == c )
+ PUTCHAR('*');
+ else
+ PUTCHAR('/');
+ }
+ if( '*' == c )
+ {
+ for (;;) /* Eat a comment */
+ {
+ c = get();
+ test:
+ if (keepcomments && c != EOF_CHAR)
+ cput(c);
+ switch (c)
+ {
+ case EOF_CHAR:
+ cerror("EOF in comment", NULLST);
+ return (EOF_CHAR);
- }
-/*MM*/ if( '*' == c ){
- for (;;) { /* Eat a comment */
- c = get();
- test: if (keepcomments && c != EOF_CHAR)
- cput(c);
- switch (c) {
- case EOF_CHAR:
- cerror("EOF in comment", NULLST);
- return (EOF_CHAR);
-
- case '/':
- if ((c = get()) != '*') /* Don't let comments */
- goto test; /* Nest. */
+ case '/':
+ if ((c = get()) != '*') /* Don't let comments */
+ goto test; /* Nest. */
#ifdef STRICT_COMMENTS
- cwarn("Nested comments", NULLST);
+ cwarn("Nested comments", NULLST);
#endif
- /* Fall into * stuff */
- case '*':
- if ((c = get()) != '/') /* If comment doesn't */
- goto test; /* end, look at next */
- instring = FALSE; /* End of comment, */
- if (keepcomments) { /* Put out the comment */
- cput(c); /* terminator, too */
- }
- /*
- * A comment is syntactically "whitespace" --
- * however, there are certain strange sequences
- * such as
- * #define foo(x) (something)
- * foo|* comment *|(123)
- * these are '/' ^ ^
- * where just returning space (or COM_SEP) will cause
- * problems. This can be "fixed" by overwriting the
- * '/' in the input line buffer with ' ' (or COM_SEP)
- * but that may mess up an error message.
- * So, we peek ahead -- if the next character is
- * "whitespace" we just get another character, if not,
- * we modify the buffer. All in the name of purity.
- */
- if (*file->bptr == '\n'
- || type[*file->bptr & 0xFF] == SPA)
- goto newline;
- return ((file->bptr[-1] = ' '));
-
- case '\n': /* we'll need a #line */
- if (!keepcomments)
- wrongline = TRUE; /* later... */
- default: /* Anything else is */
- break; /* Just a character */
- } /* End switch */
- } /* End comment loop */
- }
- else{ /* c++ comment */
-/*MM c++ comment*/
- for (;;) { /* Eat a comment */
- c = get();
- if (keepcomments && c != EOF_CHAR)
- cput(c);
- if( EOF_CHAR == c )
- return (EOF_CHAR);
- else if( '\n' == c ){
- instring = FALSE; /* End of comment, */
- return( c );
+ /* Fall into * stuff */
+ case '*':
+ if ((c = get()) != '/') /* If comment doesn't */
+ goto test; /* end, look at next */
+ instring = FALSE; /* End of comment, */
+ if (keepcomments) /* Put out the comment */
+ {
+ cput(c); /* terminator, too */
}
- }
- }
- } /* End if in comment */
- else if (!inmacro && c == '\\') { /* If backslash, peek */
- if ((c = get()) == '\n') { /* for a <nl>. If so, */
- wrongline = TRUE;
- goto newline;
- }
- else { /* Backslash anything */
- unget(); /* Get it later */
- return ('\\'); /* Return the backslash */
- }
+ /*
+ * A comment is syntactically "whitespace" --
+ * however, there are certain strange sequences
+ * such as
+ * #define foo(x) (something)
+ * foo|* comment *|(123)
+ * these are '/' ^ ^
+ * where just returning space (or COM_SEP) will cause
+ * problems. This can be "fixed" by overwriting the
+ * '/' in the input line buffer with ' ' (or COM_SEP)
+ * but that may mess up an error message.
+ * So, we peek ahead -- if the next character is
+ * "whitespace" we just get another character, if not,
+ * we modify the buffer. All in the name of purity.
+ */
+ if (*file->bptr == '\n' || type[*file->bptr & 0xFF] == SPA)
+ goto newline;
+ return ((file->bptr[-1] = ' '));
+
+ case '\n': /* we'll need a #line */
+ if (!keepcomments)
+ wrongline = TRUE; /* later... */
+ default: /* Anything else is */
+ break; /* Just a character */
+ } /* End switch */
+ } /* End comment loop */
}
- else if (c == '\f' || c == VT) /* Form Feed, Vertical */
- c = ' '; /* Tab are whitespace */
- else if (c == 0xef) /* eat up UTF-8 BOM */
+ else /* c++ comment */
{
- if((c = get()) == 0xbb)
+ for (;;) /* Eat a comment */
{
- if((c = get()) == 0xbf)
- {
- c = get();
- return c;
- }
- else
+ c = get();
+ if (keepcomments && c != EOF_CHAR)
+ cput(c);
+ if( EOF_CHAR == c )
+ return (EOF_CHAR);
+ else if( '\n' == c )
{
- unget();
- unget();
- return 0xef;
+ instring = FALSE; /* End of comment, */
+ return( c );
}
}
+ }
+ } /* End if in comment */
+ else if (!inmacro && c == '\\') /* If backslash, peek */
+ {
+ if ((c = get()) == '\n') /* for a <nl>. If so, */
+ {
+ wrongline = TRUE;
+ goto newline;
+ }
+ else /* Backslash anything */
+ {
+ unget(); /* Get it later */
+ return ('\\'); /* Return the backslash */
+ }
+ }
+ else if (c == '\f' || c == VT) /* Form Feed, Vertical */
+ {
+ c = ' '; /* Tab are whitespace */
+ }
+ else if (c == 0xef) /* eat up UTF-8 BOM */
+ {
+ if((c = get()) == 0xbb)
+ {
+ if((c = get()) == 0xbf)
+ {
+ c = get();
+ return c;
+ }
else
{
unget();
+ unget();
return 0xef;
}
}
- return (c); /* Just return the char */
+ else
+ {
+ unget();
+ return 0xef;
+ }
+ }
+ return (c); /* Just return the char */
}
-
-void unget()
+
/*
* Backup the pointer to reread the last character. Fatal error
* (code bug) if we backup too far. unget() may be called,
* without problems, at end of file. Only one character may
* be ungotten. If you need to unget more, call ungetstring().
*/
+void unget()
{
- FILEINFO *file;
-
- if ((file = infile) == NULL)
- return; /* Unget after EOF */
- if (--file->bptr < file->buffer)
- cfatal("Too much pushback", NULLST);
- if (*file->bptr == '\n') /* Ungetting a newline? */
- --line; /* Unget the line number, too */
+ FILEINFO* file;
+
+ if ((file = infile) == NULL)
+ return; /* Unget after EOF */
+ if (--file->bptr < file->buffer)
+ cfatal("Too much pushback", NULLST);
+ if (*file->bptr == '\n') /* Ungetting a newline? */
+ --line; /* Unget the line number, too */
}
-void ungetstring(char* text)
/*
* Push a string back on the input stream. This is done by treating
* the text as if it were a macro.
*/
+void ungetstring(char* text)
{
- FILEINFO *file;
- file = getfile(strlen(text) + 1, "");
- strcpy(file->buffer, text);
+ FILEINFO* file;
+ file = getfile(strlen(text) + 1, "");
+ strcpy(file->buffer, text);
}
-int
-cget()
/*
* Get one character, absorb "funny space" after comments or
* token concatenation
*/
+int cget()
{
- int c;
-
- do {
- c = get();
- } while (c == TOK_SEP);
- return (c);
+ int c;
+
+ do
+ {
+ c = get();
+ }
+ while (c == TOK_SEP);
+ return (c);
}
/*
@@ -1026,84 +1087,87 @@ cget()
* are shorter than char *'s.
*/
-static void domsg(char* severity, char* format, void* arg)
/*
* Print filenames, macro names, and line numbers for error messages.
*/
+static void domsg(char* severity, char* format, void* arg)
{
- char *tp;
- FILEINFO *file;
-
- fprintf(stderr, "%sline %d, %s: ", MSG_PREFIX, line, &severity[1]);
- if (*severity == 'S')
- fprintf(stderr, format, (char *)arg);
+ char* tp;
+ FILEINFO* file;
+
+ fprintf(stderr, "%sline %d, %s: ", MSG_PREFIX, line, &severity[1]);
+ if (*severity == 'S')
+ fprintf(stderr, format, (char*)arg);
+ else
+ fprintf(stderr, format, *((int*)arg) );
+ putc('\n', stderr);
+ if ((file = infile) == NULL)
+ return; /* At end of file */
+ if (file->fp != NULL)
+ {
+ tp = file->buffer; /* Print current file */
+ fprintf(stderr, "%s", tp); /* name, making sure */
+ if (tp[strlen(tp) - 1] != '\n') /* there's a newline */
+ putc('\n', stderr);
+ }
+ while ((file = file->parent) != NULL) /* Print #includes, too */
+ {
+ if (file->fp == NULL)
+ fprintf(stderr, "from macro %s\n", file->filename);
else
- fprintf(stderr, format, *((int *)arg) );
- putc('\n', stderr);
- if ((file = infile) == NULL)
- return; /* At end of file */
- if (file->fp != NULL) {
- tp = file->buffer; /* Print current file */
- fprintf(stderr, "%s", tp); /* name, making sure */
- if (tp[strlen(tp) - 1] != '\n') /* there's a newline */
- putc('\n', stderr);
- }
- while ((file = file->parent) != NULL) { /* Print #includes, too */
- if (file->fp == NULL)
- fprintf(stderr, "from macro %s\n", file->filename);
- else {
- tp = file->buffer;
- fprintf(stderr, "from file %s, line %d:\n%s",
+ {
+ tp = file->buffer;
+ fprintf(stderr, "from file %s, line %d:\n%s",
(file->progname != NULL)
- ? file->progname : file->filename,
+ ? file->progname : file->filename,
file->line, tp);
- if (tp[strlen(tp) - 1] != '\n')
- putc('\n', stderr);
- }
+ if (tp[strlen(tp) - 1] != '\n')
+ putc('\n', stderr);
}
+ }
}
-void cerror(char* format, char* sarg)
/*
* Print a normal error message, string argument.
*/
+void cerror(char* format, char* sarg)
{
- domsg("SError", format, sarg);
- errors++;
+ domsg("SError", format, sarg);
+ errors++;
}
-void cierror(char* format, int narg)
/*
* Print a normal error message, numeric argument.
*/
+void cierror(char* format, int narg)
{
- domsg("IError", format, &narg);
- errors++;
+ domsg("IError", format, &narg);
+ errors++;
}
-void cfatal(char* format, char* sarg)
/*
* A real disaster
*/
+void cfatal(char* format, char* sarg)
{
- domsg("SFatal error", format, sarg);
- exit(IO_ERROR);
+ domsg("SFatal error", format, sarg);
+ exit(IO_ERROR);
}
-void cwarn(char* format, char* sarg)
/*
* A non-fatal error, string argument.
*/
+void cwarn(char* format, char* sarg)
{
- domsg("SWarning", format, sarg);
+ domsg("SWarning", format, sarg);
}
-void ciwarn(char* format, int narg)
/*
* A non-fatal error, numeric argument.
*/
+void ciwarn(char* format, int narg)
{
- domsg("IWarning", format, &narg);
+ domsg("IWarning", format, &narg);
}
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
generated by cgit v1.2.3 (git 2.39.1) at 2024-04-26 06:09:22 +0000