wdesym.c

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

        ok = ( lnode != NULL );
    }

    if( ok ) {
        ok = WRRemoveLangNodeFromDir( rinfo->info->dir, &tnode,
                                      &rnode, &lnode );
    }

    return( ok );
}

static char *WdeFindDLGInclude( WdeResInfo *rinfo )
{
    WResTypeNode        *tnode;
    WResResNode         *rnode;
    WResLangNode        *lnode;
    WResLangType        lang;
    char                *include;
    Bool                ok;

    include = NULL;
    ok = ( rinfo != NULL );

    if( ok ) {
        tnode = WRFindTypeNode( rinfo->info->dir, (uint_16)RT_RCDATA, NULL );
        ok = ( tnode != NULL );
    }

    if( ok ) {
        rnode = WRFindResNode( tnode, 0, "DLGINCLUDE" );
        ok = ( rnode != NULL );
    }

    if( ok ) {
        lang.lang    = DEF_LANG;
        lang.sublang = DEF_SUBLANG;
        lnode = WRFindLangNodeFromLangType( rnode, &lang );
        ok = ( lnode != NULL );
    }

    if( ok ) {
        include = (char *)WRCopyResData( rinfo->info, lnode );
    }

    return( include );
}

char *WdeCreateSymName( char *fname )
{
    char        fn_path[_MAX_PATH];
    char        fn_drive[_MAX_DRIVE];
    char        fn_dir[_MAX_DIR];
    char        fn_name[_MAX_FNAME];

    if( fname == NULL ) {
        return( NULL );
    }

    _splitpath( fname, fn_drive, fn_dir, fn_name, NULL );
    _makepath( fn_path, fn_drive, fn_dir, fn_name, "h" );

    return( WdeStrDup( fn_path ) );
}

Bool WdeFindAndLoadSymbols( WdeResInfo *rinfo )
{
    char        fn_path[_MAX_PATH];
    char        fn_drive[_MAX_DRIVE];
    char        fn_dir[_MAX_DIR];
    char        fn_name[_MAX_FNAME];
    char        *include;
    Bool        prompt;
    Bool        ret;

    include = NULL;

    if( !rinfo || !rinfo->info->file_name ) {
        return ( FALSE );
    }

    include = WdeFindDLGInclude( rinfo );
    if( include && !WdeFileExists( include ) ) {
        WdeMemFree( include );
        include = NULL;
    }

    if( include == NULL ) {
        _splitpath( rinfo->info->file_name, fn_drive, fn_dir, fn_name, NULL );
        _makepath( fn_path, fn_drive, fn_dir, fn_name, "h" );
        prompt = TRUE;
    } else {
        strcpy( fn_path, include );
        WdeMemFree( include );
        include = NULL;
        prompt = FALSE;
    }

    ret = TRUE;

    if( WdeFileExists( fn_path ) ) {
        include = WdeLoadSymbols( &(rinfo->hash_table), fn_path, prompt );
        ret = ( include != NULL );
        if( ret ) {
            if( rinfo->sym_name != NULL ) {
                WdeMemFree( rinfo->sym_name );
            }
            rinfo->sym_name = include;
            WdeSetResModified( rinfo, TRUE );
        }
    }

    return( ret );
}

static jmp_buf SymEnv;

char *WdeLoadSymbols( WdeHashTable **table, char *file_name, Bool prompt )
{
    char                *name;
    int                 c;
    unsigned            flags;
    char                *inc_path;
    WdeGetFileStruct    gf;
    Bool                ret;
    Bool                ok;
    Bool                pop_env;
    unsigned            pp_count;
    unsigned            busy_count;
    char                busy_str[2];

    pop_env = FALSE;
    name = NULL;

    ok = ( table != NULL );

    if( ok ) {
        WdeSetStatusText( NULL, " ", FALSE );
        WdeSetStatusByID( WDE_LOADINGSYMBOLS, -1 );
    }

    if( ok ) {
        if( !file_name || prompt ) {
            gf.file_name = file_name;
            gf.title     = WdeLoadHeaderTitle;
            gf.filter    = WdeSymSaveFilter;
            name = WdeGetOpenFileName( &gf );
        } else {
            name = WdeStrDup( file_name );
        }
        ok = ( name != NULL );
    }

    WdeSetWaitCursor( TRUE );

    if( ok ) {
        if( WdeGetOption( WdeOptIgnoreInc ) ) {
            flags = PPFLAG_IGNORE_INCLUDE;
        } else {
            flags = 0;
        }
        inc_path = WdeGetIncPathOption();

        ret = setjmp( SymEnv );
        if( ret ) {
            ok = FALSE;
            PP_Fini();
        } else {
            ok = ( pop_env = WdePushEnv( &SymEnv ) );
        }
    }

    if( ok ) {
        ok = !PP_Init( name, flags, inc_path );
        if( !ok ) {
            WdeWriteTrail("WdeLoadSymbols: Unable to open header file!" );
            WdeDisplayErrorMsg( WDE_NOLOADHEADERFILE );
        }
    }

    if( ok ) {
        pp_count = 0;
        busy_count = 0;
        busy_str[1] = '\0';
        do {
            pp_count++;
            c = PP_Char();
            if( pp_count == MAX_PP_CHARS ) {
                busy_count++;
                busy_str[0] = WdeBusyChars[busy_count%4];
                WdeSetStatusText( NULL, busy_str, TRUE );
                pp_count = 0;
            }
        } while( c != EOF );
        if( *table == NULL ) {
            *table = WdeInitHashTable();
        }
        WdeAddSymbols( *table );
        WdeMakeHashTableClean( *table );
        WdeSetStatusText( NULL, " ", TRUE );
        PP_Fini();
    }

    if( pop_env ) {
        WdePopEnv( &SymEnv );
    }

    if( !ok ) {
        if( name ) {
            WdeMemFree( name );
            name = NULL;
        }
    }

    WdeSetWaitCursor( FALSE );

    WdeSetStatusReadyText( );

    return( name );
}

Bool WdeWriteSymbols( WdeHashTable *table, char **file_name, Bool prompt )
{
    char             *name;
    WdeGetFileStruct  gf;

    if( !table || !file_name ) {
        return ( FALSE );
    }

    if( WRIsDefaultHashTable( table ) ) {
        return( TRUE );
    }

    WdeSetStatusText( NULL, "", FALSE );
    WdeSetStatusByID( WDE_WRITINGSYMBOLS, -1 );

    if( prompt || !*file_name ) {
        gf.file_name = *file_name;
        gf.title     = WdeWriteHeaderTitle;
        gf.filter    = WdeSymSaveFilter;
        name = WdeGetSaveFileName( &gf );
        if( !name ) {
            return ( FALSE );
        }
        if( *file_name != NULL ) {
            WdeMemFree( *file_name );
        }
        *file_name = name;
    } else {
        name = *file_name;
    }

    if( WdeWriteSymbolsToFile( table, name ) ) {
        WdeMakeHashTableClean( table );
    }

    WdeSetStatusReadyText( );

    return( TRUE );
}

void WdeAddSymbols( WdeHashTable *table )
{
    int                 hash;
    MACRO_ENTRY         *me;
    char                *endptr;
    PPVALUE             val;
    WdeHashValue        value;
    void                *vp;
    Bool                dup;
    unsigned            add_count;
    unsigned            busy_count;
    char                busy_str[2];

    if ( table == NULL ) {
        WdeWriteTrail ( "WdeAddSymbols: unexpected NULL hash table.");
        return;
    }

    dup = TRUE;
    add_count = 0;
    busy_count = 0;
    busy_str[1] = '\0';

    for( hash = 0; hash < HASH_SIZE; hash++ ) {
        for( me = PPHashTable[hash]; me; me = me->next ) {
            if( me->parmcount == 0  &&  me->replacement_list != NULL ) {
                if( PPEvalExpr( me->replacement_list, &endptr, &val ) ) {
                    if( *endptr == '\0' ) {
                        if( val.type == PPTYPE_SIGNED ) {
                            value = (WdeHashValue) val.val.ivalue;
                        } else {
                            value = (WdeHashValue) val.val.uvalue;
                        }
                        vp = (void *)
                            WdeAddHashEntry ( table, me->name, value, &dup );
                        add_count++;
                        if( add_count == MAX_SYM_ADDS ) {
                            busy_count++;
                            busy_str[0] = WdeBusyChars[busy_count%4];
                            WdeSetStatusText( NULL, busy_str, TRUE );
                            add_count = 0;
                        }
                    }
                }
            }
        }
    }
}