ddetrack.c

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

 *                      STRING TRACKING STUFF
 * ######################################################################## */

/*
 * AddStringInfo - add information about a new string to the list of
 *                 strings displayed in the string tracking window
 */
static StringInfo *AddStringInfo( MONHSZSTRUCT *info, DDETrackInfo *listinfo )
{
    StringInfo          **str;
    StringInfo          *ret;

    str = GetNextPos( listinfo );
    ret = MemAlloc( sizeof( StringInfo ) );
    *str = ret;
    ret->hsz = info->hsz;
    ret->cnt = 1;
    ret->str = NULL;
#ifdef __NT__
    /* in NT 3.1 ret->str is a UNICODE string otherwise it is ASCII */
    {
        WORD            *ptr;
        DWORD           len;
        DWORD           ver;

        ver = GetVersion();
        if( ( ver & 0xFF ) == 3 && ( ver & 0xFF00 ) <= 0x0A00 ) {
            len = 0;
            ptr = (WORD *)info->str;
            while( *ptr != 0 ) {
                ptr ++;
                len ++;
            }
            ret->str = MemAlloc( len + 1 );
            wsprintf( ret->str, "%ls",info->str );
        }
    }
#endif
    if( ret->str == NULL ) {
        ret->str = MemAlloc( strlen( info->str ) + 1 );
        strcpy( ret->str, info->str );
    }
    return( ret );
}

/*
 * GetStringInfo - check if information about a string is already
 *                 displayed in the strings tracking window
 */
static StringInfo **GetStringInfo( HSZ hsz, DDETrackInfo *info ) {

    WORD                i;
    StringInfo          **str;

    str = info->data;
    for( i=0; i < info->cnt; i++ ) {
        if( str[i] != NULL && str[i]->hsz == hsz ) {
            return( str + i );
        }
    }
    return( NULL );
}

static int SortStrByText( const void *_str1, const void *_str2 ) {
    StringInfo * const *str1 = _str1;
    StringInfo * const *str2 = _str2;

    if( *str1 == NULL ) return( 1 );
    if( *str2 == NULL ) return( -1 );
    return( stricmp( (*str1)->str, (*str2)->str ) );
}

static int SortStrByCnt( const void *_str1, const void *_str2 ) {
    StringInfo * const *str1 = _str1;
    StringInfo * const *str2 = _str2;

    if( *str1 == NULL ) return( 1 );
    if( *str2 == NULL ) return( -1 );
    return( (*str1)->cnt - (*str2)->cnt  );
}

static int SortStrByHSZ( const void *_str1, const void *_str2 ) {
    StringInfo * const *str1 = _str1;
    StringInfo * const *str2 = _str2;

    if( *str1 == NULL ) return( 1 );
    if( *str2 == NULL ) return( -1 );
    return( (char *)( (*str1)->hsz ) - (char *)( (*str2)->hsz ) );
}

/*
 * RedispStrTrk - sort then redisplay information in the string tracking
 *                      window
 */
static void RedispStrTrk( DDETrackInfo *info ) {

    int         (*fn)(const void *, const void *);
    StringInfo  **items;
    unsigned    i;
    char        buf[80];

    SendMessage( info->list.box, LB_RESETCONTENT, 0, 0L );
    switch( info->sorttype ) {
    case PUSH_STR_TEXT:
        fn = SortStrByText;
        break;
    case PUSH_STR_CNT:
        fn = SortStrByCnt;
        break;
    case PUSH_STR_HDL:
        fn = SortStrByHSZ;
        break;
    }
    qsort( info->data, info->cnt, sizeof( StringInfo * ), fn );
    items = (StringInfo **)(info->data);
    for( i=0; i < info->cnt; i++ ) {
        if( items[i] == NULL ) break;
        sprintf( buf, "%0*lX    %4d    %s", HSZ_FMT_LEN, items[i]->hsz,
                    items[i]->cnt, items[i]->str );
        SendMessage( info->list.box, LB_ADDSTRING, 0, (DWORD)buf );
    }
}

/*
 * FreeStringItem - free memory allocated to a string item
 */

static void FreeStringItem( StringInfo *info ) {
    MemFree( info->str );
    MemFree( info );
}

/*
 * TrackStringMsg - update the strings tracking window
 */
void TrackStringMsg( MONHSZSTRUCT *info ) {

    DDETrackInfo        *listinfo;
    StringInfo          **pos;
    StringInfo          *str;

    listinfo = (DDETrackInfo *)
        GetWindowLong( Tracking[ DDEMENU_TRK_STR - DDE_TRK_FIRST ].hwnd, 0 );
    pos = GetStringInfo( info->hsz, listinfo );
    if( pos == NULL ) {
        str = NULL;
    } else {
        str = *pos;
    }
    switch( info->fsAction ) {
    case MH_CREATE:
    case MH_KEEP:
        if( str != NULL ) {
            str->cnt ++;
        } else {
            str = AddStringInfo( info, listinfo );
        }
        break;
    case MH_CLEANUP:
    case MH_DELETE:
        if( str != NULL ) {
            if( str->cnt > 0 ) str->cnt --;
            if( str->cnt == 0 ) {
                FreeStringItem( str );
                *pos = NULL;
            }
        }
        break;
    }
    RedispStrTrk( listinfo );
}

/*
 * DoStrSort - handle a change in the sort type of the
 *              string tracking window
 */

static BOOL DoStrSort( WORD type, DDETrackInfo *info ) {

    switch( type ) {
    case PUSH_STR_HDL:
    case PUSH_STR_CNT:
    case PUSH_STR_TEXT:
        info->sorttype = type;
        RedispStrTrk( info );
        break;
    default:
        return( FALSE );
    }
    return( TRUE );
}

/* #########################################################################
 *                      LINK TRACKING STUFF
 * #########################################################################*/

static int SortLinkByClient( LinkInfo **lnk1, LinkInfo **lnk2 ) {
    if( *lnk1 == NULL ) return( 1 );
    if( *lnk2 == NULL ) return( -1 );
    return( (char *)( (*lnk1)->client ) - (char *)( (*lnk2)->client ) );
}

static int SortLinkByServer( LinkInfo **lnk1, LinkInfo **lnk2 ) {
    if( *lnk1 == NULL ) return( 1 );
    if( *lnk2 == NULL ) return( -1 );
    return( (char *)( (*lnk1)->server ) - (char *)( (*lnk2)->server ) );
}

static int SortLinkByService( LinkInfo **lnk1, LinkInfo **lnk2 ) {
    if( *lnk1 == NULL ) return( 1 );
    if( *lnk2 == NULL ) return( -1 );
    return( stricmp( (*lnk1)->service, (*lnk2)->service ) );
}

static int SortLinkByTopic( LinkInfo **lnk1, LinkInfo **lnk2 ) {
    if( *lnk1 == NULL ) return( 1 );
    if( *lnk2 == NULL ) return( -1 );
    return( stricmp( (*lnk1)->topic, (*lnk2)->topic ) );
}

static int SortLinkByItem( LinkInfo **lnk1, LinkInfo **lnk2 ) {
    if( *lnk1 == NULL ) return( 1 );
    if( *lnk2 == NULL ) return( -1 );
    return( stricmp( (*lnk1)->item, (*lnk2)->item ) );
}

static int SortLinkByType( LinkInfo **lnk1, LinkInfo **lnk2 ) {
    if( *lnk1 == NULL ) return( 1 );
    if( *lnk2 == NULL ) return( -1 );
    return( stricmp( (*lnk1)->type, (*lnk2)->type ) );
}

static int SortLinkByFormat( LinkInfo **lnk1, LinkInfo **lnk2 ) {
    if( *lnk1 == NULL ) return( 1 );
    if( *lnk2 == NULL ) return( -1 );
    return( stricmp( (*lnk1)->format, (*lnk2)->format ) );
}

/*
 * RedispLinkTrk - sort then redisplay information in the link tracking
 *                      window (if islink is true) or refresh the
 *                      conversation tracking window (otherwise)
 */
static void RedispLinkTrk( DDETrackInfo *info, BOOL islink ) {

    void        *fn;
    unsigned    i;
    char        buf[100];
    LinkInfo    **items;

    SendMessage( info->list.box, LB_RESETCONTENT, 0, 0L );
    switch( info->sorttype ) {
    case PUSH_CLIENT:
         fn = SortLinkByClient;
         break;
    case PUSH_SERVER:
         fn = SortLinkByServer;
         break;
    case PUSH_SERVICE:
         fn = SortLinkByService;
         break;
    case PUSH_TOPIC:
         fn = SortLinkByTopic;
         break;
    case PUSH_TYPE:
         fn = SortLinkByType;
         break;
    case PUSH_ITEM:
         fn = SortLinkByItem;
         break;
    case PUSH_FORMAT:
         fn = SortLinkByFormat;
         break;
    }
    qsort( info->data, info->cnt, sizeof( LinkInfo * ), fn );
    items = (LinkInfo **)(info->data);
    for( i=0; i < info->cnt; i++ ) {
        if( items[i] == NULL ) break;
        if( islink ) {
            sprintf( buf, "%08lX %08lX %-4s %-10s %-10s %-10s %-18s",
                    items[i]->client, items[i]->server,
                    items[i]->type, items[i]->service, items[i]->topic,
                    items[i]->item, items[i]->format );
        } else {
            sprintf( buf, "%08lX %08lX %-20s %-s", items[i]->client,
                     items[i]->server, items[i]->service, items[i]->topic );
        }
        SendMessage( info->list.box, LB_ADDSTRING, 0, (DWORD)buf );
    }
}


/*
 * FreeLinkInfo - free memory holding information about a link
 */

void FreeLinkInfo( LinkInfo *info ) {

    MemFree( info->service );
    MemFree( info->topic );
    if( info->item != NULL ) MemFree( info->item );
    if( info->type != NULL ) FreeRCString( info->type );
    MemFree( info );
}

/*
 * FindLinkInfo - find the location of information about a given link
 *                if the link is already recorded
 */

static LinkInfo **FindLinkInfo( DDETrackInfo *info, MONLINKSTRUCT *find ) {

    unsigned    i;
    LinkInfo    *cur;
    char        *service;
    char        *topic;
    char        *item;

    service = HSZToString( find->hszSvc );
    topic = HSZToString( find->hszTopic );
    item = HSZToString( find->hszItem );
    for( i=0; i < info->cnt; i++ ) {
        cur = info->data[i];
        if( cur == NULL ) break;
        if( cur->client == find->hConvClient
            && cur->server == find->hConvServer
            && !stricmp( service, cur->service )
            && !stricmp( topic, cur->topic )
            && !stricmp( item, cur->item ) ) return( info->data + i );
    }
    MemFree( service );
    MemFree( topic );