wrrdwnt.c

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

    }

    return ( ok );
}

int WRHandleWinNTTypeEntry ( WResFileID file, WResDir *dir,
                             resource_dir_entry *rd_entry, int is_name )
{
    WResID  *type;
    int      ok;

    /* verify the id_name */
    if( ( ( rd_entry->id_name & PE_RESOURCE_MASK_ON ) && !is_name ) ||
        ( !( rd_entry->id_name & PE_RESOURCE_MASK_ON ) && is_name ) ) {
        WRDisplayErrorMsg( WR_BADIDDISCARDTYPE );
        return( FALSE );
    }

    if( is_name ) {
        type = WRGetUniCodeWResID
            ( file, PE_RESOURCE_MASK & rd_entry->id_name );
    } else {
        type = WResIDFromNum( rd_entry->id_name );
    }

    ok = ( type != NULL );

    if( ok ) {
        /* verify that entry_rva is a subdir */
        ok = ( ( rd_entry->entry_rva & PE_RESOURCE_MASK_ON ) != 0 );
        if( !ok ) {
            WRDisplayErrorMsg( WR_BADRVADISCARDTYPE );
        }
    }

    if( ok ) {
        ok = WRHandleWinNTNameDir
            ( file, dir, type, rd_entry->entry_rva & PE_RESOURCE_MASK );
    }

    if( type ) {
        WResIDFree ( type );
    }

    return( ok );
}

int WRHandleWinNTNameDir ( WResFileID file, WResDir *dir,
                           WResID *type, uint_32 rva )
{
    resource_dir_header  rd_hdr;
    resource_dir_entry  *rd_entry;
    uint_32              offset;
    int                  ok, i;

    offset = WR_MAP_RES_RVA(rva);

    ok = WRReadResourceHeader ( file, offset, &rd_hdr, &rd_entry );

    if ( ok ) {
        for ( i=0; i<rd_hdr.num_name_entries; i++ ) {
            WRHandleWinNTNameEntry ( file, dir, type, &(rd_entry[i]), TRUE );
        }
        for ( i=rd_hdr.num_name_entries;
              i<(rd_hdr.num_name_entries + rd_hdr.num_id_entries); i++ ) {
            WRHandleWinNTNameEntry ( file, dir, type, &(rd_entry[i]), FALSE );
        }
        WRMemFree ( rd_entry );
    }

    return ( ok );
}

int WRHandleWinNTNameEntry ( WResFileID file, WResDir *dir, WResID *type,
                             resource_dir_entry *rd_entry, int is_name )
{
    WResLangType    def_lang;
    resource_entry  res_entry;
    uint_32         offset;
    WResID         *name;
    int             add_now;
    int             ok;

    def_lang.lang    = DEF_LANG;
    def_lang.sublang = DEF_SUBLANG;

    /* verify the id_name */
    if ( ( ( rd_entry->id_name & PE_RESOURCE_MASK_ON ) && !is_name ) ||
         ( !( rd_entry->id_name & PE_RESOURCE_MASK_ON ) && is_name ) ) {
        WRDisplayErrorMsg( WR_BADIDDISCARDNAME );
        return ( FALSE );
    }

    if ( is_name ) {
        name = WRGetUniCodeWResID
            ( file, PE_RESOURCE_MASK & rd_entry->id_name );
    } else {
        name = WResIDFromNum ( rd_entry->id_name );
    }

    ok = ( name != NULL );

    if ( ok ) {
        /* is the entry_rva is a subdir */
        if ( rd_entry->entry_rva & PE_RESOURCE_MASK_ON ) {
            add_now = FALSE;
            ok = WRHandleWinNTLangIDDir
                ( file, dir, type, name,
                  rd_entry->entry_rva & PE_RESOURCE_MASK );
        } else {
            /* will this to happen often ???? */
            add_now = TRUE;
            offset = WR_MAP_RES_RVA(rd_entry->entry_rva);
            ok = WRReadResourceEntry ( file, offset, &res_entry );
        }
    }

    if ( ok ) {
        if ( add_now ) {
            offset = WR_MAP_RES_RVA(res_entry.data_rva);
            ok = !WResAddResource ( type, name, 0, offset, res_entry.size,
                                    *dir, &def_lang, NULL );
        }
    }

    if ( name ) {
        WResIDFree ( name );
    }

    return ( ok );
}

int WRHandleWinNTLangIDDir ( WResFileID file, WResDir *dir,
                             WResID *type, WResID *name, uint_32 rva )
{
    resource_dir_header  rd_hdr;
    resource_dir_entry  *rd_entry;
    uint_32              offset;
    int                  ok;
    int                  i;

    offset = WR_MAP_RES_RVA(rva);

    ok = WRReadResourceHeader ( file, offset, &rd_hdr, &rd_entry );

    if ( ok ) {
        for ( i=0; i<rd_hdr.num_name_entries; i++ ) {
            WRHandleWinNTLangIDEntry( file, dir, type, name, &(rd_entry[i]) );
        }
        for ( i=rd_hdr.num_name_entries;
              i<(rd_hdr.num_name_entries + rd_hdr.num_id_entries); i++ ) {
            WRHandleWinNTLangIDEntry( file, dir, type, name, &(rd_entry[i]) );
        }
        /* until more info is available only look for the first id entry */
        WRMemFree ( rd_entry );
    }

    return ( ok );
}

int WRHandleWinNTLangIDEntry ( WResFileID file, WResDir *dir, WResID *type,
                               WResID *name, resource_dir_entry *rd_entry )
{
    WResLangType    lang;
    resource_entry  res_entry;
    uint_32         offset;
    int             ok;

    ok = ( name != NULL );

    if( ok ) {
        /* is the entry_rva is a subdir */
        if( rd_entry->entry_rva & PE_RESOURCE_MASK_ON ) {
            WRDisplayErrorMsg( WR_BADLANGDISCARDNAME );
            ok = FALSE;
        } else {
            offset = WR_MAP_RES_RVA(rd_entry->entry_rva);
            ok = WRReadResourceEntry( file, offset, &res_entry );
        }
    }

    if( ok ) {
        offset = WR_MAP_DATA_RVA(res_entry.data_rva);
        lang.lang    = HIWORD(rd_entry->id_name);
        lang.sublang = LOWORD(rd_entry->id_name);
        ok = !WResAddResource ( type, name, 0, offset, res_entry.size,
                                *dir, &lang, NULL );
    }

    return ( ok );
}

int WRReadResourceHeader ( WResFileID file_handle, uint_32 offset,
                            resource_dir_header *rd_hdr,
                            resource_dir_entry **rd_entry )
{
    int ok;
    int  rde_size;

    *rd_entry = NULL;

    /* if offset is zero don't perform the seek
     * to beginning of resource directory */
    ok = ( !offset || ( ResSeek ( file_handle, offset, SEEK_SET ) != -1 ) );

    /* read the resource directory header */
    if ( ok ) {
        ok = ( read ( file_handle, rd_hdr, sizeof(resource_dir_header) ) ==
               sizeof(resource_dir_header) );
    }

    if ( ok ) {
        rde_size = sizeof(resource_dir_entry) *
                   ( rd_hdr->num_name_entries + rd_hdr->num_id_entries );
        *rd_entry = (resource_dir_entry *) WRMemAlloc ( rde_size );
        ok = ( *rd_entry != NULL );
    }

    if ( ok ) {
        ok = ( read ( file_handle, *rd_entry, rde_size ) == rde_size );
    }

    if ( !ok && *rd_entry ) {
        WRMemFree ( *rd_entry );
    }

    return ( ok );
}

WResID *WRGetUniCodeWResID ( WResFileID file_handle, uint_32 rva )
{
    uint_32  old_pos;
    uint_32  offset;
    uint_16  len;
    int     ok;
    char    *unistr;
    WResID  *id;
    int      i;

    offset = WR_MAP_RES_RVA(rva);

    unistr = NULL;

    /* seek to the location of the unicode string */
    ok = ( ( old_pos = ResSeek ( file_handle, offset, SEEK_SET ) ) != -1 );

    /* read the unicode string */
    if ( ok ) {
        ResReadUint16( &len, file_handle);
        len *= 2;
        unistr = (char *) WRMemAlloc ( len + 2 );
        ok = ( unistr != NULL );
    }

    if ( ok ) {
        unistr[len]   = 0;
        unistr[len+1] = 0;
        ok = ( read ( file_handle, unistr, len ) == len );
    }

    if ( ok ) {
        for ( i=0; i<(len+2); i+=2 ) {
            unistr[i/2] = unistr[i];
        }
        ok = ( ( id = WResIDFromStr ( unistr ) ) != NULL );
    }

#if 0
    if ( old_pos != -1 ) {
        ok = ( ( ResSeek ( file_handle, old_pos, SEEK_SET ) ) != -1 ) && ok;
    }
#endif

    if ( unistr ) {
        WRMemFree ( unistr );
    }

    if ( ok ) {
        return ( id );
    } else {
        return ( NULL );
    }
}

int WRReadResourceEntry ( WResFileID file, uint_32 offset,
                           resource_entry *res_entry )
{
    int ok;

    /* if offset is zero don't perform the seek
     * to beginning of resource directory */
    ok = ( !offset || ( ResSeek ( file, offset, SEEK_SET ) != -1 ) );

    /* read the resource entry */
    if ( ok ) {
        ok = ( read ( file, res_entry, sizeof(resource_entry) ) ==
               sizeof(resource_entry) );
    }

    return ( ok );
}