/*
================
Lexer::SkipRestOfLine
================
*/
void Lexer::SkipRestOfLine( void ) {
while ( bufPos < bufSize ) {
if ( buffer[bufPos] == '\n' || buffer[bufPos] == '\r' ) {
FinishLine();
return;
}
bufPos++;
}
// End of file
}
void ProcessStatement( void ) {
/*****************************/
/* process an sru statement */
statement *stmt;
statement *sc;
var_rec *parm;
/* create statement */
FinishLine();
stmt = appendStatement( GetParsedLine() );
stmt->typ = SRU.curr_typ;
memcpy( &( stmt->data ), &( SRU.curr ), sizeof( spec ) );
/* depending on type, munge it */
switch( SRU.curr_typ ) {
case( SRU_OTHER ):
/* check for return statements in sru */
if( inSubPgm && ( SRU.flags & RETURN_STMT_PRESENT ) ) {
SRU.subprog->data.sp.ret_stmt = stmt;
SRU.flags &= ~RETURN_STMT_PRESENT;
}
break;
case( SRU_SUBPROG ):
/* make sure to add prototypes to apropriate section */
if( inSubPgm ) {
break;
} else if( !SRU.sections ) {
inSubPgm = TRUE;
}
parm = stmt->data.sp.parm_list;
while( parm != NULL ) {
if( parm->fake ) {
stmt->data.sp.fake = TRUE;
/* only issue a warning for forward definitions so we don't
* issue the same warning twice */
if( SRU.sections->data.sec.primary == ST_FORWARD ) {
Warning( UNKNOWN_TYPE, parm->type.name,
stmt->data.sp.name );
}
break;
}
if( parm->array != NULL ) {
if( parm->array->flags & ARRAY_MULTI_DIM ) {
stmt->data.sp.fake = TRUE;
if( SRU.sections->data.sec.primary == ST_FORWARD ) {
Warning( ERR_MULTI_DIM_PARM, parm->name,
stmt->data.sp.name );
}
} else if( parm->array->flags & ARRAY_RANGE ) {
stmt->data.sp.fake = TRUE;
if( SRU.sections->data.sec.primary == ST_FORWARD ) {
Warning( ERR_INDEX_DEF_PARM, parm->name,
stmt->data.sp.name );
}
}
}
parm = parm->next;
}
SRU.subprog = stmt;
sc = SRU.sections;
if( !inSubPgm && sc && ( sc->data.sec.secondary == ST_PROTOTYPES ) ) {
if( sc->data.sec.primary == ST_FORWARD ) {
stmt->link = SRU.forward_prots;
SRU.forward_prots = stmt;
} else if( sc->data.sec.primary == ST_TYPE ) {
if( !(Options & OPT_GEN_C_CODE) && isConsDes(stmt->data.sp.name) ) {
break;
}
InsertHashValue( SRU.type_prots, stmt->data.sp.name,
strlen( stmt->data.sp.name ), stmt );
stmt->link = SRU.cpp_prots;
SRU.cpp_prots = stmt;
stmt->keep = TRUE;
}
}
break;
case( SRU_VARIABLE ):
/* add global variables to appropriate section */
if( inSubPgm ) {
break;
}
if( SRU.sections->data.sec.primary == ST_SHARED ) {
stmt->link = SRU.shared_vars;
SRU.shared_vars = stmt;
} else {
stmt->link = SRU.obj_vars;
SRU.obj_vars = stmt;
}
stmt->keep = TRUE;
break;
case( SRU_SECTION ):
/* identify two special sections when they come up */
if( inSubPgm ) {
break;
}
stmt->link = SRU.sections;
SRU.sections = stmt;
if( stmt->data.sec.primary == ST_TYPE ) {
if( stmt->data.sec.secondary == ST_PROTOTYPES ) {
SRU.type_sec = stmt;
} else if( stmt->data.sec.secondary == ST_VARIABLES ) {
SRU.var_sec = stmt;
}
}
break;
default:
assert( FALSE );
}
memset( &( SRU.curr ), 0, sizeof( spec ) );
SRU.curr_typ = SRU_OTHER;
}
/*
================
Lexer::ReadToken
================
*/
const Token *Lexer::ReadToken( void ) {
if ( tokPos == -1 )
tokPos = 0;
else if ( tokIsUnread ) {
tokIsUnread = false;
return &token;
}
while ( bufPos < bufSize ) {
// Single line comments
if ( !lineComment.IsEmpty() &&
String::CmpPrefix((const char *)(buffer+bufPos), lineComment.c_str()) == 0 ) {
if ( !(flags & LEXER_FULL_LINES) && tokPos > 0 ) {
FinishToken();
return &token;
}
bufPos += 2;
if ( tokPos > 0 ) {
SkipRestOfLine();
return &token;
}
SkipRestOfLine();
continue;
}
// Multiline comments
else if ( !blockComment[0].IsEmpty() &&
String::CmpPrefix((const char *)(buffer+bufPos), blockComment[0].c_str()) == 0 ) {
if ( !(flags & LEXER_FULL_LINES) && tokPos > 0 ) {
FinishToken();
return &token;
}
bufPos += 2;
int l = line;
SkipToCommentEnd();
// If changed line during comment, finish the line.
if ( (flags & LEXER_FULL_LINES) && l != line && tokPos > 0 ) {
FinishToken();
return &token;
}
continue;
}
switch( buffer[bufPos] ) {
// Ignore whitespaces
case ' ':
case '\t':
SkipWhiteSpaces();
if ( flags & LEXER_FULL_LINES )
AddToToken( ' ' );
else if ( tokPos > 0 ) {
FinishToken();
return &token;
}
continue;
// Newlines
case '\n':
case '\r':
if ( !tokPos ) {
FinishLine();
continue;
}
FinishLine();
return &token;
// Quoted tokens
case '\"':
case '\'':
if ( flags & LEXER_FULL_LINES ) {
ParseQuoted();
continue;
}
if ( tokPos > 0 ) {
FinishToken();
return &token;
}
ParseQuoted();
return &token;
default:
// Check for single char tokens
if ( (flags & LEXER_FULL_LINES) == 0 && !singleTokenChars.IsEmpty() ) {
char c = buffer[bufPos];
const char *chars = singleTokenChars.c_str();
int num = singleTokenChars.Length();
for( int i=0; i<num; i++ ) {
if ( c != chars[i] )
continue;
if ( tokPos == 0 ) {
AddToToken( buffer[bufPos] );
bufPos++;
}
FinishToken();
return &token;
}
}
// Add this char to the token
AddToToken( buffer[bufPos] );
bufPos++;
continue;
}
}
if ( tokPos > 0 ) {
FinishToken();
return &token;
}
line = 0;
return NULL;
}
