wrrdw16.c

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

{
    WRNameInfo    name_info;
    uint_32       offset_32;
    uint_32       length_32;
    WResResNode  *rnode;
    WResLangNode *lnode;

    rnode = (WResResNode *) WRMemAlloc ( sizeof(WResResNode) );
    if ( rnode == NULL ) {
        return ( NULL );
    }

    lnode = (WResLangNode *) WRMemAlloc ( sizeof(WResLangNode) );
    if ( lnode == NULL ) {
        WRMemFree ( rnode );
        return ( NULL );
    }

    if( read( file, &name_info, sizeof(WRNameInfo) ) != sizeof(WRNameInfo) ) {
        return( NULL );
    }

    rnode->Next               = NULL;
    rnode->Prev               = NULL;
    rnode->Head               = lnode;
    rnode->Tail               = lnode;
    rnode->Info.NumResources  = 1;
    if ( name_info.id & 0x8000 ) {
        rnode->Info.ResName.IsName = FALSE;
    } else {
        rnode->Info.ResName.IsName = TRUE;
    }
    rnode->Info.ResName.ID.Num = ( name_info.id & 0x7fff );

    lnode->Next              = NULL;
    lnode->Prev              = NULL;
    lnode->data              = NULL;
    lnode->Info.MemoryFlags  = name_info.flags;
    offset_32                = (uint_32) name_info.offset;
    length_32                = (uint_32) name_info.length;
    lnode->Info.Offset       = (uint_32) (offset_32 << align);
    lnode->Info.Length       = (uint_32) (length_32 << align);
    lnode->Info.lang.lang    = DEF_LANG;
    lnode->Info.lang.sublang = DEF_SUBLANG;

    return ( rnode );
}

int WRReadResourceNames ( WResDir dir, WResFileID file_handle,
                            uint_32 name_offset )
{
    uint_8         name_len;
    char          *name;
    int           end_of_names;

    end_of_names = FALSE;

    ResReadUint8( &name_len, file_handle );

    while ( !end_of_names ) {
        if ( name_len == 0 ) {
            ResReadUint8( &name_len, file_handle);
            if ( name_len == 0 ) {
                end_of_names = TRUE;
            } else {
                name_offset++;
            }
        } else {
            name = (char *) WRMemAlloc ( name_len + 1 );
            if ( read ( file_handle, name, name_len ) != name_len ) {
                return ( FALSE );
            }
            name[name_len] = 0;
            WRSetResName ( dir, name_offset, name );
            WRMemFree ( name );
            name_offset = name_offset + name_len + 1;
            ResReadUint8 ( &name_len, file_handle );
        }
    }

    return ( TRUE );
}

int WRSetResName ( WResDir dir, uint_32 offset, char *name )
{
    WResTypeNode *type_node;
    WResResNode  *res_node;
    int          found_one;

    found_one = FALSE;
    type_node = dir->Head;
    while ( type_node != NULL ) {
        if ( ( type_node->Info.TypeName.IsName ) &&
             ( type_node->Info.TypeName.ID.Num == offset ) ) {
            type_node = WRRenameWResTypeNode ( dir, type_node, name );
            if ( type_node == NULL ) {
                return ( FALSE );
            } else {
                found_one = TRUE;
            }
        }
        res_node = type_node->Head;
        while ( res_node != NULL ) {
            if ( ( res_node->Info.ResName.IsName ) &&
                 ( res_node->Info.ResName.ID.Num == offset ) ) {
                res_node = WRRenameWResResNode (type_node, res_node, name);
                if ( res_node == NULL) {
                    return ( FALSE );
                } else {
                    found_one = TRUE;
                }
            }
            if ( res_node == type_node->Tail ) {
                break;
            }
            res_node = res_node->Next;
        }
        if ( type_node == dir->Tail ) {
            break;
        }
        type_node = type_node->Next;
    }

    return ( found_one );
}

WResTypeNode *WRRenameWResTypeNode ( WResDir       dir,
                                      WResTypeNode *type_node,
                                      char         *name )
{
    WResTypeNode *new_type_node;
    int           len;

    len = strlen ( name );
    new_type_node = (WResTypeNode *) WRMemAlloc (sizeof(WResTypeNode)+len-1);
    if ( new_type_node == NULL ) {
        return ( NULL );
    }
    if ( dir->Head == type_node ) {
        dir->Head = new_type_node;
    }
    if ( dir->Tail == type_node ) {
        dir->Tail = new_type_node;
    }
    new_type_node->Next = type_node->Next;
    new_type_node->Prev = type_node->Prev;
    new_type_node->Head = type_node->Head;
    new_type_node->Tail = type_node->Tail;
    new_type_node->Info.NumResources = type_node->Info.NumResources;
    new_type_node->Info.TypeName.IsName = TRUE;
    new_type_node->Info.TypeName.ID.Name.NumChars = len;
    memcpy ( new_type_node->Info.TypeName.ID.Name.Name, name, len );
    if ( type_node->Prev != NULL ) {
        type_node->Prev->Next = new_type_node;
    }
    if ( type_node->Next != NULL ) {
        type_node->Next->Prev = new_type_node;
    }
    WRMemFree ( type_node );
    return ( new_type_node );
}

WResResNode *WRRenameWResResNode ( WResTypeNode *type_node,
                                    WResResNode  *res_node,
                                    char         *name )
{
    WResResNode *new_res_node;
    int          len;

    len = strlen ( name );
    new_res_node = (WResResNode *)
                       WRMemAlloc (sizeof(WResResNode) + max(0,len-1) );
    if ( new_res_node == NULL ) {
        return ( NULL );
    }
    if ( type_node->Head == res_node ) {
        type_node->Head = new_res_node;
    }
    if ( type_node->Tail == res_node ) {
        type_node->Tail = new_res_node;
    }
    new_res_node->Head = res_node->Head;
    new_res_node->Tail = res_node->Tail;
    new_res_node->Next = res_node->Next;
    new_res_node->Prev = res_node->Prev;
    new_res_node->Info.ResName.IsName = TRUE;
    new_res_node->Info.ResName.ID.Name.NumChars = len;
    memcpy ( new_res_node->Info.ResName.ID.Name.Name, name, len );
    if ( res_node->Prev != NULL ) {
        res_node->Prev->Next = new_res_node;
    }
    if ( res_node->Next != NULL ) {
        res_node->Next->Prev = new_res_node;
    }
    WRMemFree ( res_node );
    return ( new_res_node );
}

uint_32 WRReadNameTable ( WResDir dir, WResFileID file_handle,
                           uint_8 **name_table,
                           uint_32 num_leftover, uint_8 *leftover )
{
    static WResTypeNode *type_node;
    static WResResNode  *res_node;
    static uint_32       res_len;
    static uint_32       res_offset;
    static uint_32       num_read;
    uint_32              len;

    if ( dir != NULL ) {
        type_node = WRFindTypeNode( dir, (uint_16)WR_RT_NAMETABLE, NULL );
        if ( type_node != NULL ) {
            res_node = type_node->Head;
            /* If there are two name tables we ignore all but the first */
            res_len    = res_node->Head->Info.Length;
            res_offset = res_node->Head->Info.Offset;
            if ( ResSeek( file_handle, res_offset, SEEK_SET ) ==-1 ) {
                return ( FALSE );
            }
        } else {
            res_len = 0;
        }
        num_read = 0;
    }

    if ( num_read == res_len ) {
        return ( 0 );
    }

    *name_table = NULL;

    if ( (num_read + NAME_TABLE_MAX) < res_len ) {
        len = NAME_TABLE_MAX;
    } else {
        len = res_len - num_read;
    }

    num_read += len;

    /* If there was data left over but we have a NULL pointer to the
     * leftover data then we are in a very bad situation.
     * What we shall do is skip the left over data.
     * If the seek to skip the data fails then we are totally SNAFU
     * and must abort the reading of the name resource!!
     */
    if ( num_leftover && !leftover ) {
        if (ResSeek( file_handle, num_leftover, SEEK_CUR ) == -1) {
            return ( 0 );
        }
        num_read += num_leftover;
        num_leftover = 0;
    }

    *name_table = (uint_8 *) WRMemAlloc ( len + num_leftover );
    if ( *name_table ==  NULL ) {
        return ( FALSE );
    }

    if ( num_leftover ) {
        memcpy ( *name_table, leftover, num_leftover );
    }

    if ( read ( file_handle, *name_table + num_leftover, len ) != len ) {
        /* hmmmm... the read failed */
    }

    return ( len + num_leftover );
}

uint_32 WRUseNameTable ( WResDir dir, uint_8 *name_table, uint_32 len,
                          uint_8 **leftover )
{
    WRNameTableEntry *entry;
    uint_32            name_pos;
    uint_32            num_leftover;

    name_pos = 0;
    num_leftover = 0;
    while (name_pos < len ) {
        entry = ( WRNameTableEntry *) (name_table+name_pos);
        if ( !entry->length ) {
            break;
        }
        if ( (name_pos + entry->length ) > len ) {
            num_leftover = len - name_pos;
            *leftover = (uint_8 *) WRMemAlloc ( num_leftover );
            if ( *leftover ) {
                memcpy ( *leftover, entry, num_leftover );
            } else {
                /* leftover alloc failed! */
            }
            break;
        }
        WRSetResNameFromNameTable ( dir, entry );
        name_pos += entry->length;
    }

    return ( num_leftover );
}

int WRSetResNameFromNameTable ( WResDir dir, WRNameTableEntry *entry )
{
    WResTypeNode *type_node;
    WResResNode  *res_node;

    type_node = dir->Head;
    while ( type_node != NULL ) {
        if ( ( !type_node->Info.TypeName.IsName ) &&
             ( type_node->Info.TypeName.ID.Num == entry->type ) ) {
            res_node = type_node->Head;
            while ( res_node != NULL ) {
                if ( ( !res_node->Info.ResName.IsName ) &&
                     ( res_node->Info.ResName.ID.Num ==
                           (entry->id & 0x7fff) ) ) {
                    if ( WRRenameWResResNode ( type_node, res_node,
                                                entry->name ) == NULL ) {
                        return ( FALSE );
                    } else {
                        return ( TRUE );
                    }
                }
                if ( res_node == type_node->Tail ) {
                    break;
                }
                res_node = res_node->Next;
            }
        }
        if ( type_node == dir->Tail ) {
            break;
        }
        type_node = type_node->Next;
    }

    return ( FALSE );
}