boolean IoSuppOpenSrc( // OPEN A SOURCE FILE (PRIMARY,HEADER)
const char *file_name, // - supplied file name
enum file_type typ ) // - type of search path to use
{
struct path_descr fd; // - descriptor for file name
#ifdef OPT_BR
if( NULL != file_name
&& file_name[0] != '\0' ) {
TOKEN_LOCN locn;
switch( typ ) {
case FT_SRC :
case FT_HEADER :
case FT_LIBRARY :
SrcFileGetTokenLocn( &locn );
BrinfIncludeSource( file_name, &locn );
break;
}
}
#endif
splitFileName( file_name, &fd );
if( doIoSuppOpenSrc( &fd, typ ) ) return TRUE;
#if !defined(__DOS__)
if( !CompFlags.check_truncated_fnames ) return FALSE;
if( strlen( fd.fnm ) <= 8 ) return FALSE;
fd.fnm[8] = '\0';
if( doIoSuppOpenSrc( &fd, typ ) ) return TRUE;
#endif
return FALSE;
}
static void setMsgLocation // SET LOCATION FOR MESSAGE
( CTX context ) // - current context
{
switch( context ) {
case CTX_FINI :
case CTX_FUNC_GEN :
case CTX_CG_FUNC :
case CTX_CG_OPT :
case CTX_ENDFILE :
if( CompFlags.ew_switch_used ) {
// drops thru
case CTX_INIT :
case CTX_CMDLN_ENV :
case CTX_CMDLN_PGM :
case CTX_CMDLN_VALID :
err_locn.src_file = NULL;
break;
}
// drops thru
case CTX_FORCED_INCS :
case CTX_SOURCE :
if( err_locn.src_file == NULL ) {
if( SrcFilesOpen() ) {
SrcFileGetTokenLocn( &err_locn );
} else {
err_locn.line = SrcLineCount;
err_locn.column = 0;
err_locn.src_file = SrcFileCurrent();
}
}
break;
}
}
void BrinfSrcMacReference // MACRO REFERENCE
( MACVALUE const * val ) // - reference value
{
TOKEN_LOCN temporary; // - current token location
SrcFileGetTokenLocn( &temporary );
queue( IC_BR_REF_MACRO, val, &temporary );
}
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 *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 );
}
void SymbolLocnDefine( // DEFINE LOCATION SYMBOL
TOKEN_LOCN *sym_locn, // - symbol location (NULL for current source file)
SYMBOL sym ) // - the symbol
{
SYM_TOKEN_LOCN *locn = NULL;
if( sym_locn != NULL && sym_locn->src_file != NULL ) {
locn = SymbolLocnAlloc( &sym->locn );
locn->tl = *sym_locn;
sym->flag2 |= SF2_TOKEN_LOCN;
} else {
DbgVerify( sym_locn == NULL
, "SymbolLocnDefine -- bad location" );
if( SrcFilesOpen() ) {
locn = SymbolLocnAlloc( &sym->locn );
SrcFileGetTokenLocn( &locn->tl );
sym->flag2 |= SF2_TOKEN_LOCN;
}
}
}
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 );
}
