msg.c

来自「开放源码的编译器open watcom 1.6.0版的源代码」· C语言 代码 · 共 659 行 · 第 1/2 页

static int UseArgInfo( void )
/***************************/
{
    return( MsgArgInfo.index >= 0 );
}

static void IncremIndex( void )
/*****************************/
{
    MsgArgInfo.index++;
}

extern void Locator( char *filename, char *mem, unsigned rec )
/************************************************************/
{
    LocFile = filename;
    LocMem = mem;
    LocRec = rec;
}

static void LocateFile( unsigned num )
/************************************/
{
    unsigned    rec;

    if( num & LOC ) {
        if( num & (LOC_REC & ~LOC) ) {
            rec = RecNum;
        } else {
            rec = 0;
        }
        if( CurrMod == NULL ) {
            if( CmdFile == NULL ) {
                Locator( NULL, NULL, 0 );
            } else {
                Locator( CmdFile->name, NULL, 0 );
            }
         } else {
            Locator( CurrMod->f.source->file->name, CurrMod->name, rec );
        }
    }
}

extern unsigned CalcMsgNum( unsigned num )
/****************************************/
// map the internal enum onto the value that the user sees.
{
    unsigned    class;

    class = (num & CLASS_MSK) >> NUM_SHIFT;
    class = (class + 1) / 2;
    return class * 1000 + (num & NUM_MSK);
}

/* Here's the deal with _DLLHOST: If linker is "DLL style", the
 * message output is different. It is tailored to the IDE, and
 * it helps the IDE to invoke online help for error messages and
 * link to symbols associated with the errors/warnings. In
 * non-DLL mode, a message will contain a prefix (a string such
 * as "Warning! W1014: " and the actual error message; in DLL mode,
 * this prefix is handled differently and in other code. For map
 * files however, we always want the prefix logged. Hence all the
 * hoops we jump through.
 */

static void MessageFini( unsigned num, char *buff, unsigned len,
    char *prefix, unsigned prefixlen, bool waserror )
/**************************************************************/
{
    if( num & OUT_TERM ) {
        if( !(LinkFlags & QUIET_FLAG) ) {
            WLPrtBanner();
            WriteInfoStdOut( buff, num, CurrSymName );
        } else if( (num & CLASS_MSK) != (CLASS_MSK & INF)) {
            WriteInfoStdOut( buff, num, CurrSymName );
        }
    }
    if( (num & OUT_MAP) && (MapFile != NIL_HANDLE) ) {
#if defined( _DLLHOST )
        BufWrite( prefix, prefixlen );
#endif
        BufWrite( buff, len );
        WriteMapNL( 1 );
    }
    if( (num & CLASS_MSK) == (FTL&~OUT_MSK) ) Suicide();
    if( waserror && LinkFlags & MAX_ERRORS_FLAG ) {
        MaxErrors--;
        if( MaxErrors == 0 ) {
            LnkMsg( FTL+MSG_TOO_MANY_ERRORS, NULL );
        }
    }
}

extern void LnkMsg(
    unsigned    num,    // A message number + control flags
    char        *types, // Conversion qualifiers
    ... )               // Arguments to interpolate into message
/**************************************************
 * report a linker message
 *
 * num   selects a message containing substitutions; both printf and %digit
 * types is either NULL or the order of interpolated arguments.
 */
{
    va_list     args;
    int         which_file = 0;
    unsigned    len;
    unsigned    prefixlen;
    unsigned    class;
    bool        waserror;
    char        rc_buff[ RESOURCE_MAX_SIZE ];
    char        buff[ MAX_MSG_SIZE ];
    char        prefix[ MAX_MSG_SIZE ];

    if( !TestBit( MsgFlags, num & NUM_MSK ) )
        return;
    CurrSymName = NULL;
    LocateFile( num );
    len = 0;
    prefixlen = 0;
    waserror = FALSE;
    class = num & CLASS_MSK;
    if( class == (YELL & CLASS_MSK) ) {
        waserror = TRUE;        /* yells are counted as errors for limits */
    } else if( class >= (MILD_ERR & CLASS_MSK) ) {
        waserror = TRUE;
        if( class >= (ERR & CLASS_MSK) ) {
            LinkState |= LINK_ERROR;
        }
    }
    if( class >= (WRN & CLASS_MSK) ) {
        if( class == (WRN & CLASS_MSK) ) {
            Msg_Get( MSG_WARNING, rc_buff );
        } else {
            Msg_Get( MSG_ERROR, rc_buff );
        }
#if !defined( _DLLHOST )
        len = FmtStr( buff, MAX_MSG_SIZE - len, rc_buff, CalcMsgNum( num ));
#else
        prefixlen = FmtStr( prefix, MAX_MSG_SIZE, rc_buff, CalcMsgNum( num ));
#endif
    }
    if( LocFile != NULL ) {
        which_file += 1;
    }
    if( LocMem != NULL ) {
        which_file += 2;
    }
    if( LocRec != 0 ) {
        which_file += 4;
    }
    if( which_file != 0 ) {
        if( Token.how == SYSTEM ) {
            Msg_Get( MSG_SYS_BLK, rc_buff );
            which_file = 1;
        } else if( Token.how == ENVIRONMENT ) {
            Msg_Get( MSG_ENVIRON, rc_buff );
            which_file = 1;
        } else {
            Msg_Get( MSG_FILE_REC_NAME_0 + which_file - 1, rc_buff );
        }
        FileOrder( rc_buff, which_file );
        len += FmtStr( &buff[len], MAX_MSG_SIZE - len, rc_buff );
        if( num & LINE ) {
            if( Token.how != SYSTEM && Token.how != ENVIRONMENT ) {
                Msg_Get( MSG_LINE, rc_buff );
                Msg_Do_Put_Args( rc_buff, &MsgArgInfo, "d", Token.line );
                len += FmtStr( &buff[len], MAX_MSG_SIZE - len, rc_buff );
            }
        }
        LocFile = NULL;
        LocMem = NULL;
        LocRec = 0;
    }

    va_start( args, types );
    Msg_Get( num & NUM_MSK, rc_buff );
    Msg_Put_Args( rc_buff, &MsgArgInfo, types, &args );
    va_end( args );
    len += FmtStr( &buff[len], MAX_MSG_SIZE - len, rc_buff );
    MessageFini( num, buff, len, prefix, prefixlen, waserror );
}

static void HandleRcMsg( unsigned num, va_list *args )
/****************************************************/
/* getting an error message from resource compiler code */
{
    unsigned    len;
    unsigned    prefixlen;
    char        rc_buff[RESOURCE_MAX_SIZE];
    char        buff[ MAX_MSG_SIZE ];
    char        prefix[ MAX_MSG_SIZE ];

    num |= ERR;
    len = 0;
    prefixlen = 0;
    LinkState |= LINK_ERROR;
    CurrSymName = NULL;
    Msg_Get( MSG_ERROR, rc_buff );
#if !defined( _DLLHOST )
    len = FmtStr( buff, MAX_MSG_SIZE - len, rc_buff, CalcMsgNum( num ));
#else
    prefixlen = FmtStr( prefix, MAX_MSG_SIZE, rc_buff, CalcMsgNum( num ));
#endif
    Msg_Get( num & NUM_MSK, rc_buff );
    len += DoFmtStr( &buff[len], MAX_MSG_SIZE - len, rc_buff, args );
    MessageFini( num, buff, len, prefix, prefixlen, TRUE );
}

extern void RcWarning( unsigned num, ... )
/****************************************/
{
    va_list args;

    va_start( args, num );
    HandleRcMsg( num, &args );
}

extern void RcError( unsigned num, ... )
/**************************************/
{
    va_list args;

    va_start( args, num );
    HandleRcMsg( num, &args );
}

static void FileOrder( char rc_buff[], int which_file )
/*****************************************************/
{
    switch( which_file ) {
        case 1:
            Msg_Do_Put_Args( rc_buff, &MsgArgInfo, "s", LocFile );
            break;
        case 2:
            Msg_Do_Put_Args( rc_buff, &MsgArgInfo, "s", LocMem );
            break;
        case 3:
            Msg_Do_Put_Args( rc_buff, &MsgArgInfo, "12", LocFile, LocMem );
            break;
        case 4:
            Msg_Do_Put_Args( rc_buff, &MsgArgInfo, "d", LocRec );
            break;
        case 5:
            Msg_Do_Put_Args( rc_buff, &MsgArgInfo, "sd", LocFile, LocRec );
            break;
        case 6:
            Msg_Do_Put_Args( rc_buff, &MsgArgInfo, "sd", LocMem, LocRec );
            break;
        case 7:
            Msg_Do_Put_Args( rc_buff, &MsgArgInfo, "12d", LocFile, LocMem,
                        LocRec );
            break;
    }
}

extern void WLPrtBanner( void )
/*****************************/
// print the banner, if it hasn't already been printed.
{
    char *  msg;

    if( !BannerPrinted ) {
        msg = MsgStrings[ PRODUCT ];
        WriteInfoStdOut( msg, BANNER, NULL );
        msg = MsgStrings[ COPYRIGHT ];
        WriteInfoStdOut( msg, BANNER, NULL );
        msg = MsgStrings[ TRADEMARK ];
        WriteInfoStdOut( msg, BANNER, NULL );
        msg = MsgStrings[ TRADEMARK2 ];
        WriteInfoStdOut( msg, BANNER, NULL );
        BannerPrinted = TRUE;
    }
}

extern bool SkipSymbol( symbol * sym )
/************************************/
{
    if( sym->info & SYM_STATIC && !(MapFlags & MAP_STATICS) ) return TRUE;
#if defined(__WATCOMC__)
    { int art;

    art = __is_mangled_internal( sym->name, 0 ); // KLUDGE: it doesn't need len
    return !(MapFlags & MAP_ARTIFICIAL) && art == __MANGLED_INTERNAL;
    }
#else
    return FALSE;
#endif
}

extern int SymAlphaCompare( const void *a, const void *b )
/********************************************************/
{
    symbol *    left;
    symbol *    right;
    const char *leftname;
    const char *rightname;
    unsigned    leftsize;
    unsigned    rightsize;
    int         result;

    left = *((symbol **) a);
    right = *((symbol **) b);
#if defined(__WATCOMC__)
    if( !(LinkFlags & DONT_UNMANGLE) ) {
        __unmangled_name( left->name, 0, &leftname, &leftsize );
        __unmangled_name( right->name, 0, &rightname, &rightsize );
    } else
#endif
    {
        leftname = left->name;
        rightname = right->name;
        leftsize = strlen( leftname );
        rightsize = strlen( rightname );
    }
    if( leftsize < rightsize ) {
        result = memicmp( leftname, rightname, leftsize );
        if( result == 0 ) result = -1;  // since leftsize < rightsize;
    } else {
        result = memicmp( leftname, rightname, rightsize );
        if( result == 0 ) {
            if( leftsize > rightsize ) {
                result = 1;
            }
        }
    }
    return result;
}