REWRITE *RewritePackageClassTemplateMember( REWRITE *r, TOKEN_LOCN *locn )
/************************************************************************/
{
unsigned brace_depth;
bool first_time;
TOKEN_LOCN start_locn;
SrcFileGetTokenLocn( &start_locn );
brace_depth = 0;
first_time = TRUE;
for(;;) {
if( CurToken == T_EOF ) {
templateError( r, &start_locn );
break;
}
if( ! first_time ) {
/* already been saved by YYDRIVER */
saveToken( r, locn );
}
first_time = FALSE;
switch( CurToken ) {
case T_RIGHT_BRACE:
case T_ALT_RIGHT_BRACE:
if( brace_depth == 0 ) {
return( templateError( r, &start_locn ) );
}
--brace_depth;
if( brace_depth == 0 ) {
NextToken();
if( CurToken == T_SEMI_COLON ) {
saveToken( r, locn );
NextToken();
}
return( r );
}
break;
case T_LEFT_BRACE:
case T_ALT_LEFT_BRACE:
++brace_depth;
break;
case T_SEMI_COLON:
if( brace_depth == 0 ) {
NextToken();
return( r );
}
break;
default:
break;
}
NextToken();
}
return( NULL );
}
REWRITE *RewritePackageToken( void )
/**********************************/
{
REWRITE *r;
TOKEN_LOCN locn;
r = newREWRITE( T_EOF, &locn );
if( CurToken != T_EOF ) {
if( CurToken == T_SAVED_ID ) {
saveToken( r, &locn );
NextToken();
}
saveToken( r, &locn );
}
return( r );
}
void RewriteRecordToken( REWRITE *r, TOKEN_LOCN *locn )
/*****************************************************/
{
if( CurToken != T_EOF ) {
saveToken( r, locn );
}
}
/*------------------------------------------------------------------------------
| MSStringParserData::processSkip |
| |
| Parse the remaining string data as if a token was specified,except in this |
| case the token does not exist. If this is a reparse_ of a skip,do not save |
| the skip marker in the token list. |
------------------------------------------------------------------------------*/
MSStringParserData& MSStringParserData::processSkip(MSBoolean reparse_)
{
reparseLastToken();
_lastToken=0;
_lastSkip=MSTrue;
if (!reparse_) saveToken(0);
return *this;
}
/*------------------------------------------------------------------------------
| MSStringParserData::processToken |
| |
| Parse the remaining string data into the token. If this is a token reparse |
| then do not save the token(since it will not be parsed again). |
------------------------------------------------------------------------------*/
MSStringParserData& MSStringParserData::processToken(MSString &aToken_,MSBoolean reparse_)
{
reparseLastToken();
if (_currentPosition>=_parseText.length()) aToken_=emptyString;
else aToken_=_parseText.subString(_currentPosition);
_lastToken=&aToken_;
_lastSkip=MSFalse;
if (reparse_==MSFalse) saveToken(_lastToken);
return *this;
}
REWRITE *RewritePackageMemInit( PTREE multi )
/*******************************************/
{
REWRITE *r;
unsigned paren_depth;
unsigned brace_depth;
TOKEN_LOCN locn;
TOKEN_LOCN start_locn;
SrcFileGetTokenLocn( &start_locn );
r = newREWRITE( T_RIGHT_BRACE, &locn );
captureMulti( r, multi, &locn );
brace_depth = 0;
paren_depth = 0;
for(;;) {
if( CurToken == T_EOF ) {
memInitError( r, &start_locn );
break;
}
saveToken( r, &locn );
switch( CurToken ) {
case T_LEFT_PAREN:
++paren_depth;
break;
case T_RIGHT_PAREN:
if( paren_depth == 0 ) {
return( memInitError( r, &start_locn ) );
}
--paren_depth;
break;
case T_RIGHT_BRACE:
case T_ALT_RIGHT_BRACE:
if( brace_depth == 0 ) {
return( memInitError( r, &start_locn ) );
}
--brace_depth;
break;
case T_LEFT_BRACE:
case T_ALT_LEFT_BRACE:
if( paren_depth == 0 ) {
return( r );
}
++brace_depth;
break;
default:
break;
}
NextToken();
}
return( NULL );
}
static PTREE recoverToken( PTREE tree )
{
switch( tree->op ) {
case PT_INT_CONSTANT:
case PT_FLOATING_CONSTANT:
/* these cases are not possible in correct C++ programs */
/* Buffer and ConstType should still be set */
CurToken = T_CONSTANT;
break;
case PT_ID:
CurToken = T_SAVED_ID;
SavedId = tree->u.id.name;
break;
case PT_UNARY:
case PT_BINARY:
switch( tree->cgop ) {
case CO_INDIRECT:
CurToken = T_TIMES;
break;
case CO_COLON_COLON:
CurToken = T_COLON_COLON;
break;
case CO_OPERATOR:
CurToken = T_OPERATOR;
break;
case CO_TILDE:
CurToken = T_TILDE;
break;
case CO_NEW:
CurToken = T_NEW;
break;
case CO_DELETE:
CurToken = T_DELETE;
break;
case CO_STORAGE:
return( tree );
default:
DbgStmt( CFatal( "recoverToken: unknown tree cgop" ) );
return( tree );
}
break;
default:
DbgStmt( CFatal( "recoverToken: unknown tree cgop" ) );
return( tree );
}
saveToken( currRewrite, currLocn );
return( tree );
}
bool TokenScanner::hasMoreTokens() {
std::string token = nextToken();
saveToken(token);
return !token.empty();
}
REWRITE *RewritePackagePassThrough( REWRITE *r )
/****************************************/
{
REWRITE *dummy;
unsigned paren_depth;
unsigned brace_depth;
TOKEN_LOCN locn;
TOKEN_LOCN start_locn;
DbgAssert( CurToken == T_EQUAL );
NextToken();
SrcFileGetTokenLocn( &start_locn );
dummy = newREWRITE( T_DEFARG_END, &locn );
brace_depth = 0;
paren_depth = 0;
for(;;) {
if( CurToken == T_EOF ) {
defArgError( r, &start_locn );
break;
}
switch( CurToken ) {
case T_LEFT_PAREN:
++paren_depth;
break;
case T_RIGHT_BRACE:
case T_ALT_RIGHT_BRACE:
if( brace_depth == 0 ) {
return( defArgError( r, &start_locn ) );
}
--brace_depth;
break;
case T_LEFT_BRACE:
case T_ALT_LEFT_BRACE:
if( paren_depth == 0 ) {
return( defArgError( r, &start_locn ) );
}
++brace_depth;
break;
case T_RIGHT_PAREN :
if( paren_depth == 0 ) {
if( brace_depth != 0 ) {
return( defArgError( r, &start_locn ) );
}
UndoNextToken();
return( dummy );
}
--paren_depth;
break;
case T_COMMA :
case T_DOT_DOT_DOT:
if( brace_depth == 0 && paren_depth == 0 ) {
UndoNextToken();
return( dummy );
}
break;
default:
break;
}
saveToken( r, &locn );
NextToken();
}
return( NULL );
}
REWRITE *RewritePackageTemplateArgument( void )
/******************************************/
{
REWRITE *r;
unsigned angle_depth;
unsigned brace_depth;
unsigned bracket_depth;
unsigned paren_depth;
TOKEN_LOCN locn;
TOKEN_LOCN start_locn;
SrcFileGetTokenLocn( &start_locn );
r = newREWRITE( T_DEFARG_END, &locn );
angle_depth = brace_depth = bracket_depth = paren_depth = 0;
for(;;) {
if( CurToken == T_EOF ) {
defArgError( r, &start_locn );
break;
}
switch( CurToken ) {
case T_LEFT_BRACE:
case T_ALT_LEFT_BRACE:
++brace_depth;
break;
case T_LEFT_BRACKET:
case T_ALT_LEFT_BRACKET:
++bracket_depth;
break;
case T_LEFT_PAREN:
++paren_depth;
break;
case T_RIGHT_BRACE:
case T_ALT_RIGHT_BRACE:
if( brace_depth == 0 ) {
return( defArgError( r, &start_locn ) );
}
--brace_depth;
break;
case T_RIGHT_BRACKET:
case T_ALT_RIGHT_BRACKET:
if( bracket_depth == 0 ) {
return( defArgError( r, &start_locn ) );
}
--bracket_depth;
break;
case T_RIGHT_PAREN:
if( paren_depth == 0 ) {
return( defArgError( r, &start_locn ) );
}
--paren_depth;
break;
case T_LT:
/* for non-type template arguments this should always be
* parsed as less-than */
if( ( brace_depth == 0 ) && ( bracket_depth == 0 )
&& ( paren_depth == 0 ) ) {
++angle_depth;
}
break;
case T_COMMA:
case T_GT:
if( ( brace_depth == 0 ) && ( bracket_depth == 0 )
&& ( paren_depth == 0 ) ) {
if( angle_depth == 0 ) {
return( r );
}
else if( CurToken == T_GT ) {
--angle_depth;
}
}
break;
case T_RSHIFT:
// see Right Angle Brackets (N1757/05-0017)
if( CompFlags.enable_std0x
&& ( brace_depth == 0 ) && ( bracket_depth == 0 )
&& ( paren_depth == 0 ) ) {
if( angle_depth == 1 ) {
CurToken = T_GT;
saveToken( r, &locn );
return( r );
} else if( angle_depth == 0 ) {
return( r );
} else {
angle_depth -= 2;
}
}
break;
default:
break;
}
saveToken( r, &locn );
NextToken();
}
return( NULL );
}
REWRITE *RewritePackageFunction( PTREE multi )
/********************************************/
{
ppctl_t old_ppctl;
bool skip_first;
REWRITE *r;
unsigned depth;
unsigned asm_depth;
TOKEN_LOCN locn;
TOKEN_LOCN *plocn;
skip_first = FALSE;
r = ParseGetRecordingInProgress( &plocn );
if( r == NULL ) {
plocn = &locn;
r = newREWRITE( T_RIGHT_BRACE, &locn );
} else {
skip_first = TRUE;
}
captureMulti( r, multi, plocn );
old_ppctl = PPControl;
asm_depth = 0;
depth = 1; /* we've seen one '{' */
while( CurToken != T_EOF ) {
DbgAssert( depth != 0 );
switch( CurToken ) {
case T_NULL:
DbgAssert( asm_depth != 0 );
PPCTL_DISABLE_EOL();
if( depth == asm_depth ) {
PPCTL_DISABLE_ASM();
asm_depth = 0;
}
break;
case T___ASM:
if( asm_depth == 0 ) {
PPCTL_ENABLE_EOL();
PPCTL_ENABLE_ASM();
asm_depth = depth;
}
break;
case T_SEMI_COLON:
break;
case T_LEFT_BRACE:
case T_ALT_LEFT_BRACE:
++depth;
break;
case T_RIGHT_BRACE:
case T_ALT_RIGHT_BRACE:
--depth;
if( depth == asm_depth ) {
PPCTL_DISABLE_EOL();
PPCTL_DISABLE_ASM();
asm_depth = 0;
}
break;
default:
break;
}
if( ! skip_first ) {
saveToken( r, plocn );
}
skip_first = FALSE;
if( depth == 0 )
break;
NextToken();
if( PPControl & PPCTL_ASM ) {
PPCTL_ENABLE_EOL();
}
}
PPControl = old_ppctl;
return( r );
}
std::string Parser::peekToken()
{
std::string token = getToken();
saveToken(token);
return token;
}
