log.c

开放源码的编译器open watcom 1.6.0版的源代码

/****************************************************************************
*
*                            Open Watcom Project
*
*    Portions Copyright (c) 1983-2002 Sybase, Inc. All Rights Reserved.
*
*  ========================================================================
*
*    This file contains Original Code and/or Modifications of Original
*    Code as defined in and that are subject to the Sybase Open Watcom
*    Public License version 1.0 (the 'License'). You may not use this file
*    except in compliance with the License. BY USING THIS FILE YOU AGREE TO
*    ALL TERMS AND CONDITIONS OF THE LICENSE. A copy of the License is
*    provided with the Original Code and Modifications, and is also
*    available at www.sybase.com/developer/opensource.
*
*    The Original Code and all software distributed under the License are
*    distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
*    EXPRESS OR IMPLIED, AND SYBASE AND ALL CONTRIBUTORS HEREBY DISCLAIM
*    ALL SUCH WARRANTIES, INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF
*    MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR
*    NON-INFRINGEMENT. Please see the License for the specific language
*    governing rights and limitations under the License.
*
*  ========================================================================
*
* Description:  WHEN YOU FIGURE OUT WHAT THIS FILE DOES, PLEASE
*               DESCRIBE IT HERE!
*
****************************************************************************/


#include <windows.h>
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <stdarg.h>
#include <string.h>
#include <io.h>
#include <ctype.h>
#include <sys/stat.h>
#include "drwatcom.h"
#include "srchmsg.h"
#include "intdlg.h"
#include "log.h"
#include "memdmp.h"
#include "mem.h"
#include "jdlg.h"
#include "regcrt.h"
#include "malloc.h"
#include "mad.h"
#include "madcli.h"
#include "madrtn.h"

#define IsNT( x )       ( !( x & 0x80000000 ) )
#define GetMinVer( x )  ( ( x & 0x0000FF00 ) >> 8 )
#define GetMajVer( x )  ( x & 0x000000FF )
#define INDENT          5
#define BUF_SIZE        _MAX_PATH

typedef struct {
    HANDLE              prochdl;
    MemListData         list;
}SelMemDlgInfo;

typedef FILE    *LogFP;


static BOOL     ignoreLogChecks;
static BOOL     notesAdded;
static LogFP    logFileHdl;
static char     *logLine = { "==============================================="
                             "========================\n" };

static msglist ProcessorNames[] = {
    PROCESSOR_INTEL_386,                "80386",
    PROCESSOR_INTEL_486,                "80486",
    PROCESSOR_INTEL_PENTIUM,            "80586",
#if 0
    PROCESSOR_INTEL_860,                "860",
    PROCESSOR_MIPS_R2000,               "MIPS R2000",
    PROCESSOR_MIPS_R3000,               "MIPS R3000",
    PROCESSOR_MIPS_R4000,               "MIPS R4000",
#endif
    PROCESSOR_ALPHA_21064,              "ALPHA 21064",
    0,                                  NULL
};

msglist Actions[] = {
    INT_CHAIN_TO_NEXT,                  (char *)STR_FAULT_PASSED_ON,
    INT_TERMINATE,                      (char *)STR_PROCESS_TERMINATED,
    INT_RESTART,                        (char *)STR_INSTR_RESTARTED,
    0,                                  (char *)-1
};

/*
 * CheckLogSize
 */
void CheckLogSize( void ) {

    struct stat         st;
    char                buf[100];
    int                 ret;

    /* if the user has already said they don't want to delete a large log
     * file don't keep asking */
    if( ignoreLogChecks ) return;
    if( stat( LogData.logname, &st ) == -1 ) return;
    if( st.st_size > LogData.max_flen ) {
        RCsprintf( buf, STR_DEL_BIG_LOG_FILE, st.st_size );
        ret = MessageBox( NULL, buf, AppName,
                          MB_YESNO | MB_SETFOREGROUND | MB_ICONQUESTION );
        if( ret == IDYES ) {
            remove( LogData.logname );
        } else {
            ignoreLogChecks = TRUE;
        }
    }
}

/*
 * startLogFile - start log for this session
 */
static BOOL startLogFile( void )
{
    logFileHdl = fopen( LogData.logname, "a" );
    if( logFileHdl != NULL ) {
        fseek( logFileHdl, 0, SEEK_END );
        return( FALSE );
    } else {
        return( TRUE );
    }
}

/*
 * finishLogFile - close up log file
 */
static void finishLogFile( void )
{
    fclose( logFileHdl );
}

static void logPrintf( DWORD id, ... ) {

    va_list     al;

    va_start( al, id );
    RCvfprintf( logFileHdl, id, al );
    va_end( al );
}

static void logStrPrintf( char *str, ... ) {

    va_list     al;

    va_start( al, str );
    vfprintf( logFileHdl, str, al );
    va_end( al );
}


/***************************************************************************
 * Functions below this point should not know what a LogFP is.
 ***************************************************************************/

/*
 * NotePrint
 */
void NotePrint( char *str ) {
    if( !notesAdded ) {
        logPrintf( STR_USER_NOTES );
        notesAdded = TRUE;
    }
    logStrPrintf( "     %s\n", str );
}

/*
 * logSysInfo - record basic system info
 */
static void logSysInfo( ExceptDlgInfo *faultinfo )
{
    char        *str;
    time_t      tod;
    DWORD       ver;
    SYSTEM_INFO sysinfo;
    char        name[ MAX_COMPUTERNAME_LENGTH + 1 ];
    DWORD       bufsize;

    tod = time( NULL );
    str = ctime( &tod );
    if( faultinfo != NULL ) {
        logPrintf( STR_FAULT_FOUND_ON_X, AppName, str );
    } else {
        logPrintf( STR_LOG_TAKEN_ON_X, AppName, str );
    }

    bufsize = sizeof( name );
    GetComputerName( name, &bufsize );
    logPrintf( STR_COMPUTER_NAME, name );

    bufsize = sizeof( name );
    GetUserName( name, &bufsize );
    logPrintf( STR_USER_NAME, name );

    ver = GetVersion();
#ifdef CHICAGO          // TEMPORARY FIX UNTIL WE CAN CHECK FOR WIN 95
    logPrintf( STR_OPERATING_SYSTEM, "Windows 95" );
#else
    logPrintf( STR_OPERATING_SYSTEM, IsNT( ver ) ? "Windows NT":"Win32s" );
#endif
    logPrintf( STR_OS_VERSION, (int)GetMajVer( ver ), (int)GetMinVer( ver ) );
    GetSystemInfo( &sysinfo );

    str = SrchMsg( sysinfo.dwProcessorType, ProcessorNames, NULL );
    if( str == NULL ) {
        str = AllocRCString( STR_UNKNOWN );
        logPrintf( STR_PROCESSOR_TYPE, str );
        FreeRCString( str );
    } else {
        logPrintf( STR_PROCESSOR_TYPE, str );
    }
    logPrintf( STR_NUM_PROCESSORS, sysinfo.dwNumberOfProcessors );
}

/*
 * logDisasm - log some disassembly
 */
static void logDisasm( ExceptDlgInfo *info ) {
    int         i;
    address     addr;
    address     flagaddr;
    char        str[256];

    SetDisasmInfo( info->procinfo->prochdl, info->module );

    GetCurrAddr( &flagaddr, info->regs );
    addr = flagaddr;
    InstructionBackward( LogData.asm_bkup, &addr );

    for( i = 0; i <= LogData.asm_cnt; i++ ) {
        if( MADAddrComp( &addr, &flagaddr, MAF_FULL ) == 0 ) {
            logStrPrintf( "--->" );
        } else {
            logStrPrintf( "    " );
        }

        Disassemble( &addr, str, TRUE, 255 );
        logStrPrintf( "%s\n", str );
    }

} /* logDisasm */

/*
 * logStack
 */

static void logStack( ExceptDlgInfo *info ) {
    unsigned_16     *data;
    int             i;
    int             j;
    address         sp;
    DWORD           linecnt;
    DWORD           bytesread;
    mad_type_info   host;
    mad_type_info   mti;
    void            *item;
    char            buf[BUF_SIZE];
    unsigned        max;
    unsigned        word_size;

#define MIN_SIZE    sizeof( unsigned_16 )

    MADRegSpecialGet( MSR_SP, info->regs, &( sp.mach ) );
    MADTypeInfoForHost( MTK_ADDRESS, sizeof( address ), &host );
    MADTypeInfo( MADTypeDefault( MTK_ADDRESS, MAF_FULL, NULL, &sp ), &mti );
    item = alloca( ( mti.b.bits / BITS_PER_BYTE ) + 1 );
#ifdef __AXP__
    word_size = 8;
#else
    word_size = 4;
#endif
    data = alloca( word_size * 4 );
    logPrintf( STR_STACK_DATA );
    for( linecnt=0; linecnt < 20; linecnt ++ ) {
        bytesread = MADCliReadMem( sp, word_size * 4, data );
        MADTypeConvert( &host, &sp, &mti, item, 0 );
        max = BUF_SIZE - 1;
        MADTypeToString( 16, &mti, item, &max, buf );
        logStrPrintf( "%s - ", buf );
        for( i = 0; i < bytesread / MIN_SIZE; i += word_size / MIN_SIZE ) {
            for( j = word_size / MIN_SIZE - 1; j >= 0; j-- ) {
                logStrPrintf( "%04hX", data[i+j]);
            }
            logStrPrintf( " " );
            MADAddrAdd( &sp, word_size, MAF_FULL );
        }
        logStrPrintf( "\n" );
    }
}


#define PAGE_WIDTH 75
static walk_result logRegisterSet( const mad_reg_set_data *reg_set, void *_regs)
{
    mad_registers          *regs = _regs;
    int                     i;
    int                     j;
    int                     num_columns;
    int                     num_regs;
    RegStringCreateData     *reg_create;
    char                    *reg_name;
    char                    *set_level;
    unsigned                len;

    len = MADCliString( MADRegSetName( reg_set ), 0, NULL );
    reg_name = alloca( len + 2 );
    MADCliString( MADRegSetName( reg_set ), len + 1, reg_name );
    len = MADRegSetLevel( reg_set, 0, NULL );
    if( len == 0 ){
        logStrPrintf( "\n%s\n\n", reg_name );
    } else {
        set_level = alloca( len + 2 );
        MADRegSetLevel( reg_set, len + 1, set_level );
        logStrPrintf( "\n%s (%s)\n\n", reg_name, set_level );