/**
* non-declaration statement
*/
do_statement () {
if (amatch ("if", 2)) {
doif ();
lastst = STIF;
} else if (amatch ("while", 5)) {
dowhile ();
lastst = STWHILE;
} else if (amatch ("switch", 6)) {
doswitch ();
lastst = STSWITCH;
} else if (amatch ("do", 2)) {
dodo ();
need_semicolon ();
lastst = STDO;
} else if (amatch ("for", 3)) {
dofor ();
lastst = STFOR;
} else if (amatch ("return", 6)) {
doreturn ();
need_semicolon ();
lastst = STRETURN;
} else if (amatch ("break", 5)) {
dobreak ();
need_semicolon ();
lastst = STBREAK;
} else if (amatch ("continue", 8)) {
docont ();
need_semicolon ();
lastst = STCONT;
} else if (match (";"))
;
else if (amatch ("case", 4)) {
docase ();
lastst = statement (NO);
} else if (amatch ("default", 7)) {
dodefault ();
lastst = statement (NO);
} else if (match ("__asm__")) {
doasm ();
lastst = STASM;
} else if (match("#")) {
kill();
} else if (match ("{"))
do_compound (NO);
else {
expression (YES);
/* if (match (":")) {
dolabel ();
lastst = statement (NO);
} else {
*/ need_semicolon ();
lastst = STEXP;
/* }
*/ }
}
int stmt() { int c;
if(istoken('{')) {while(istoken('}')==0) stmt();}
else if(istoken(T_IF)) doif();
else if(istoken(T_DO)) dodo();
else if(istoken(T_WHILE)) dowhile();
else if(istoken(T_GOTO)) {prs("\n jmp @@");name1();prs(symbol);expect(';');}
else if(token==T_ASM) {prs("\n"); c=next();
while(c != '\n') { prc(c); c=next(); }; token=getlex(); }
else if(istoken(T_ASMBLOCK)) {prs("\n"); expect('{'); c=next();
while(c!= '}') { prc(c); c=next(); }; token=getlex(); }
else if(istoken(T_EMIT)) doemit();
else if(istoken(';')) { }
else if(istoken(T_RETURN)){if (token!=';') expr();
prs("\n jmp @@retn"); nreturn++; expect(';'); }
else if(thechar==':') {prs("\n@@"); /*Label*/
prs(symbol); prc(':'); expect(T_NAME); expect(':'); }
else {expr(); expect(';'); } }
int
control(int counter)
/*
* Process #control lines. Simple commands are processed inline,
* while complex commands have their own subroutines.
*
* The counter is used to force out a newline before #line, and
* #pragma commands. This prevents these commands from ending up at
* the end of the previous line if cpp is invoked with the -C option.
*/
{
register int c;
register char *tp;
register 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;
#if OSL_DEBUG_LEVEL > 1
case L_debug: tp = "debug"; break;
case L_nodebug: tp = "nodebug"; break;
#endif
default: hash = L_nogood;
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);
}
}
/*
* 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:
/*
* 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;
}
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;
#endif
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 );
break;
}
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 OLD_PREPROCESSOR
/*
* Ignore the rest of the #control line so you can write
* #if foo
* #endif foo
*/
goto dump_line; /* Take common exit */
#else
if (skipws() != '\n') {
cwarn("Unexpected text in #control line ignored", NULLST);
skipnl();
}
#endif
}
return (counter + 1);
}
int
prep (void) /* Check for preprocessor commands */
{
int b, c;
char *ln;
ln = line;
while (*(++ln) == '#' || *ln == ' ') /* locate first directive character */
;
if ( ! *ln) /* NULL directive */
return (killine ());
/* fprintf(stderr,"prep - line=%s\n",ln); */
if (strcmp2 (ln, "if ") || strcmp2 (ln, "ifdef ") ||
strcmp2 (ln, "ifndef "))
{
/* fprintf(stderr,"prep - calling doif(%s)\n",ln); */
doif (ln);
return (killine ());
}
if (strcmp2 (ln, "else"))
{
doelse ();
return (killine ());
}
if (strcmp2 (ln, "endif"))
{
doendif ();
return (killine ());
}
if (strcmp2 (ln, "elif "))
{
doelif (ln);
return (killine ());
}
if (procsw)
{
if (strcmp2 (ln, "define "))
{
c = getident (ln, 7) + 2; /* get end of identifier */
splittok (ln, c); /* tokenize rest of line */
dodefine (strlen (line), &ln[7] - line); /* store #define info */
/* fprintf(stderr,"PREP (after dodef): line=|%s|\n",line); */
tstdupdef (); /* Check for def duplication and fix */
return (killine ()); /* Discard #define line */
}
if (strcmp2 (ln, "include "))
{
doinclude (&ln[8]); /* open include file */
return (killine ()); /* Discard #include line */
}
if (strcmp2 (ln, "undef "))
{
/* fprintf(stderr,"prep - undef found %s\n",ln); */
doundef (&ln[6]); /* remove undef identifier from def table */
/* fprintf(stderr,"prep - doundef done\n"); */
return (killine ()); /* Discard #undef line */
}
if (strcmp2 (ln, "error "))
{
fprintf (stderr, "User error - %s\n", &ln[6]); /* print error */
return (killine ()); /* Discard #error line */
}
if (strcmp2 (ln, "asm"))
{
for (;;) /* send all following lines through for assembler */
{
getln (0);
if (eflag)
break;
if (findstr (1, line, "#endasm"))
break;
if (cflag)
puts ("#2");
else
printf ("#pragma asm ");
printf ("%s\n", line);
}
if (eflag && cflag) /* error only in Microware mode (no #endasm) */
doerr (18, 1);
return (killine ());
}
if (strcmp2 (ln, "pragma "))
{
dopragma (ln + 7);
return (killine ());
}
if (strcmp2 (ln, "line "))
{
doline (ln + 5);
return (killine ());
}
doerr (17, 1); /* Illegal preprocessor directive */
return (killine ());
}
}
static void
findstages(ASTNode *n, int ctxt)
{
PipeStage *p;
Nodes *r;
if(n == nil) return;
switch(n->t){
case ASTPIPEL:
for(r = n->nl; r != nil; r = r->next)
findstages(r->n, ctxt);
break;
case ASTSTATE:
p = emalloc(sizeof(PipeStage));
p->sym = n->sym;
if(stcur != nil){
p->nvars = stcur->nvars;
if(p->nvars != 0){
p->vars = emalloc(-(-p->nvars & -VARBLOCK) * sizeof(Symbol *));
memcpy(p->vars, stcur->vars, p->nvars * sizeof(Symbol *));
}
}
p->gen = bsnew(-(-p->nvars & -VARBLOCK));
p->kill = bsnew(-(-p->nvars & -VARBLOCK));
p->killp = bsnew(-(-p->nvars & -VARBLOCK));
p->prev = stlist.prev;
p->next = &stlist;
p->prev->next = p;
p->next->prev = p;
stcur = p;
break;
case ASTDECL:
if(stcur == nil){
out:
error(n, "statement outside of stage");
return;
}
if(stcur->nvars % VARBLOCK == 0){
stcur->vars = erealloc(stcur->vars, sizeof(Symbol *), stcur->nvars, VARBLOCK);
stcur->gen = bsgrow(stcur->gen, stcur->nvars + VARBLOCK);
stcur->kill = bsgrow(stcur->kill, stcur->nvars + VARBLOCK);
stcur->killp = bsgrow(stcur->kill, stcur->nvars + VARBLOCK);
}
stcur->vars[stcur->nvars] = n->sym;
n->sym->pipeidx = stcur->nvars;
stcur->nvars++;
break;
case ASTASS:
if(stcur == nil) goto out;
findstages(n->n2, ctxt);
findstages(n->n1, ctxt|LVAL);
break;
case ASTSYMB:
if(stcur == nil) goto out;
if(n->sym->pipeidx < 0) break;
switch(ctxt & (LVAL|PRIME)){
case 0:
if(!bstest(stcur->kill, n->sym->pipeidx))
bsadd(stcur->gen, n->sym->pipeidx);
break;
case LVAL:
if(bstest(stcur->killp, n->sym->pipeidx))
error(n, "conflicting definitions for %s", n->sym->name);
bsadd(stcur->kill, n->sym->pipeidx);
break;
case PRIME:
if(!bstest(stcur->killp, n->sym->pipeidx))
error(n, "primed variable undefined");
break;
case LVAL|PRIME:
if(bstest(stcur->kill, n->sym->pipeidx))
error(n, "conflicting definitions for %s", n->sym->name);
bsadd(stcur->killp, n->sym->pipeidx);
break;
}
break;
case ASTPRIME:
findstages(n->n1, ctxt | PRIME);
break;
case ASTCINT:
case ASTCONST:
break;
case ASTOP:
case ASTTERN:
case ASTIDX:
case ASTMEMB:
findstages(n->n1, ctxt);
findstages(n->n2, ctxt);
findstages(n->n3, ctxt);
findstages(n->n4, ctxt);
break;
case ASTIF:
doif(n, ctxt);
break;
default: error(n, "findstages: unknown %A", n->t);
}
}
ReturnCode control( struct Global *global,
int *counter ) /* Pending newline counter */
{
/*
* Process #control lines. Simple commands are processed inline,
* while complex commands have their own subroutines.
*
* The counter is used to force out a newline before #line, and
* #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 c;
char *tp;
int hash;
char *ep;
ReturnCode ret;
c = skipws( global );
if( c == '\n' || c == EOF_CHAR )
{
(*counter)++;
return(FPP_OK);
}
if( !isdigit(c) )
scanid( global, c ); /* Get #word to tokenbuf */
else
{
unget( global ); /* Hack -- allow #123 as a */
strcpy( global->tokenbuf, "line" ); /* synonym for #line 123 */
}
hash = (global->tokenbuf[1] == EOS) ? L_nogood : (global->tokenbuf[0] + (global->tokenbuf[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_error:
tp = "error";
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;
default:
hash = L_nogood;
case L_nogood:
tp = "";
break;
}
if( !streq( tp, global->tokenbuf ) )
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( global->infile->fp == NULL )
cwarn( global, WARN_CONTROL_LINE_IN_MACRO, global->tokenbuf );
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( ++global->ifptr >= &global->ifstack[BLK_NEST] )
{
cfatal( global, FATAL_TOO_MANY_NESTINGS, global->tokenbuf );
return( FPP_TOO_MANY_NESTED_STATEMENTS );
}
*global->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:
dump_line( global, counter ); /* Ignore rest of line */
return(FPP_OK);
}
}
/*
* Make sure that #line and #pragma are output on a fresh line.
*/
if( *counter > 0 && (hash == L_line || hash == L_pragma) )
{
Putchar( global, '\n' );
(*counter)--;
}
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( global );
global->workp = global->work; /* Save name in work */
while( c != '\n' && c != EOF_CHAR )
{
if( (ret = save( global, c )) )
return(ret);
c = get( global );
}
unget( global );
if( (ret = save( global, EOS )) )
return(ret);
/*
* Split #line argument into <line-number> and <name>
* We subtract 1 as we want the number of the next line.
*/
global->line = atoi(global->work) - 1; /* Reset line number */
for( tp = global->work; isdigit(*tp) || type[(unsigned)*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( global->infile->progname != NULL )
/* Give up the old name if it's allocated. */
free( global->infile->progname );
global->infile->progname = savestring( global, tp );
}
global->wrongline = TRUE; /* Force output later */
break;
case L_include:
ret = doinclude( global );
if( ret )
return(ret);
break;
case L_define:
ret = dodefine( global );
if( ret )
return(ret);
break;
case L_undef:
doundef( global );
break;
case L_else:
if( global->ifptr == &global->ifstack[0] )
{
cerror( global, ERROR_STRING_MUST_BE_IF, global->tokenbuf );
dump_line( global, counter );
return( FPP_OK );
}
else if( (*global->ifptr & ELSE_SEEN) != 0 )
{
cerror( global, ERROR_STRING_MAY_NOT_FOLLOW_ELSE, global->tokenbuf );
dump_line( global, counter );
return( FPP_OK );
}
*global->ifptr |= ELSE_SEEN;
if( (*global->ifptr & WAS_COMPILING) != 0 )
{
if( compiling || (*global->ifptr & TRUE_SEEN) != 0 )
compiling = FALSE;
else
{
compiling = TRUE;
}
}
break;
case L_elif:
if( global->ifptr == &global->ifstack[0] )
{
cerror( global, ERROR_STRING_MUST_BE_IF, global->tokenbuf );
dump_line( global, counter );
return( FPP_OK );
}
else if( (*global->ifptr & ELSE_SEEN) != 0 )
{
cerror( global, ERROR_STRING_MAY_NOT_FOLLOW_ELSE, global->tokenbuf );
dump_line( global, counter );
return( FPP_OK );
}
if( (*global->ifptr & (WAS_COMPILING | TRUE_SEEN)) != WAS_COMPILING )
{
compiling = FALSE; /* Done compiling stuff */
dump_line( global, counter ); /* Skip this clause */
return( FPP_OK );
}
ret = doif( global, L_if );
if( ret )
return(ret);
break;
case L_error:
cerror(global, ERROR_ERROR);
break;
case L_if:
case L_ifdef:
case L_ifndef:
if( ++global->ifptr < &global->ifstack[BLK_NEST] )
{
*global->ifptr = WAS_COMPILING;
ret = doif( global, hash );
if( ret )
return(ret);
break;
}
cfatal( global, FATAL_TOO_MANY_NESTINGS, global->tokenbuf );
return( FPP_TOO_MANY_NESTED_STATEMENTS );
case L_endif:
if( global->ifptr == &global->ifstack[0] )
{
cerror( global, ERROR_STRING_MUST_BE_IF, global->tokenbuf );
dump_line( global, counter );
return(FPP_OK);
}
if( !compiling && (*global->ifptr & WAS_COMPILING) != 0 )
global->wrongline = TRUE;
compiling = ((*global->ifptr & WAS_COMPILING) != 0);
--global->ifptr;
break;
case L_assert:
{
int result;
ret = eval( global, &result );
if(ret)
return(ret);
if( result == 0 )
cerror( global, ERROR_PREPROC_FAILURE );
}
break;
case L_pragma:
/*
* #pragma is provided to pass "options" to later
* passes of the compiler. cpp doesn't have any yet.
*/
Putstring( global, "#pragma " );
while( (c = get( global ) ) != '\n' && c != EOF_CHAR )
Putchar( global, c );
unget( global );
Putchar( global, '\n' );
break;
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.
*/
if( global->warnillegalcpp )
cwarn( global, WARN_ILLEGAL_COMMAND, global->tokenbuf );
Putchar( global, '#' );
Putstring( global, global->tokenbuf );
Putchar( global, ' ' );
while( (c = get( global ) ) != '\n' && c != EOF_CHAR )
Putchar( global, c );
unget( global );
Putchar( global, '\n' );
break;
}
if( hash != L_include )
{
#if OLD_PREPROCESSOR
/*
* Ignore the rest of the #control line so you can write
* #if foo
* #endif foo
*/
dump_line( global, counter ); /* Take common exit */
return( FPP_OK );
#else
if (skipws(global) != '\n')
{
cwarn( global, WARN_UNEXPECTED_TEXT_IGNORED );
skipnl( global );
}
#endif
}
(*counter)++;
return( FPP_OK );
}
