exelxobj.c

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

    uint_32             old_pages;
    uint_32             offset;
    uint_32             length;
    uint_32             lx_off;
    os2_flat_header     *old_head;
    os2_flat_header     *new_head;

    lx_off = new->WinHeadOffset;
    old_head = &old->u.LXInfo.OS2Head;
    new_head = &new->u.LXInfo.OS2Head;

    /* Leave room for object table, object page table and resource
     * table to be written later
     */
    offset = sizeof( os2_flat_header )
           + new_head->num_objects * sizeof( object_record )
           + new_head->num_pages * sizeof( lx_map_entry )
           + new_head->num_rsrcs * sizeof( flat_res_table );
    seek_rc = RcSeek( new->Handle, lx_off + offset, SEEK_SET );
    if( seek_rc == -1 )
        return( RS_WRITE_ERROR );

    new_head->signature    = old_head->signature;
    new_head->byte_order   = old_head->byte_order;
    new_head->word_order   = old_head->word_order;
    new_head->level        = old_head->level;
    new_head->cpu_type     = old_head->cpu_type;
    new_head->os_type      = old_head->os_type;
    new_head->version      = old_head->version;
    new_head->flags        = old_head->flags;
    new_head->start_obj    = old_head->start_obj;
    new_head->eip          = old_head->eip;
    new_head->stack_obj    = old_head->stack_obj;
    new_head->esp          = old_head->esp;
    new_head->page_size    = old_head->page_size;
    new_head->l.page_shift = old_head->l.page_shift;
    new_head->autodata_obj = old_head->autodata_obj;
    new_head->heapsize     = old_head->heapsize;
    new_head->stacksize    = old_head->stacksize;

    new_head->objtab_off   = sizeof( os2_flat_header );
    new_head->objmap_off   = new_head->objtab_off
                           + new_head->num_objects * sizeof( object_record );
    new_head->rsrc_off     = new_head->objmap_off
                           + new_head->num_pages * sizeof( lx_map_entry );

    // copy resident names table if provided
    if( old_head->entry_off > old_head->resname_off ) {
        new_head->resname_off  = new_head->rsrc_off
                               + new_head->num_rsrcs * sizeof( flat_res_table );
        seek_rc = RcSeek( old->Handle, lx_off + old_head->resname_off, SEEK_SET );
        if( seek_rc == -1 )
            return( RS_READ_ERROR );

        length = old_head->entry_off - old_head->resname_off;
        ret = CopyExeData( old->Handle, new->Handle, length );
        if( ret != RS_OK )
            return( ret );
    } else {
        new_head->resname_off = 0;
        length = 0;
    }
    offset += length;

    // copy entry table if provided
    if( old_head->entry_off ) {
        new_head->entry_off = offset;
        if( old_head->moddir_off )
            length = old_head->moddir_off - old_head->entry_off;
        else
            length = old_head->fixpage_off - old_head->entry_off;

        seek_rc = RcSeek( old->Handle, lx_off + old_head->entry_off, SEEK_SET );
        if( seek_rc == -1 )
            return( RS_READ_ERROR );

        ret = CopyExeData( old->Handle, new->Handle, length );
        if( ret != RS_OK )
            return( ret );
    } else {
        new_head->entry_off = 0;
        length = 0;
    }
    offset += length;

    // now we can determine loader section size
    new_head->loader_size  = offset - sizeof( os2_flat_header );
    new_head->loader_cksum = 0;

    // copy fixup section if provided
    if( old_head->fixup_size ) {
        int_32      delta;
        uint_32     last_fix_pg;
        uint_32     new_fixpg_length;
        uint_32     old_fixpg_length;
        int         i;

        // the fixup page table must be extended if resource pages were added
        old_pages = new_head->num_pages - new->u.LXInfo.Res.num_pages;
        length = sizeof( uint_32 ) * old_pages;
        seek_rc = RcSeek( old->Handle, lx_off + old_head->fixpage_off, SEEK_SET );
        if( seek_rc == -1 )
            return( RS_READ_ERROR );

        ret = CopyExeData( old->Handle, new->Handle, length );
        if( ret != RS_OK )
            return( ret );

        // read the last entry of fixup page table
        ret = RcRead( old->Handle, &last_fix_pg, sizeof( last_fix_pg ) );
        if( ret != sizeof( last_fix_pg ) )
            return( RS_READ_ERROR );

        // replicate for each added page (plus one for final entry)
        for( i = 0; i < new->u.LXInfo.Res.num_pages + 1; i++ ) {
            ret = RcWrite( new->Handle, &last_fix_pg, sizeof( last_fix_pg ) );
            if( ret != sizeof( last_fix_pg ) )
                return( RS_READ_ERROR );
        }

        // calculate new fixup table size
        old_fixpg_length = (old_head->num_pages + 1) * sizeof( uint_32 );
        new_fixpg_length = (new_head->num_pages + 1) * sizeof( uint_32 );
        new_head->fixup_size   = old_head->fixup_size
                               - old_fixpg_length + new_fixpg_length;
        new_head->fixup_cksum  = 0;

        delta = offset - old_head->fixpage_off;
        new_head->fixpage_off  = old_head->fixpage_off + delta;

        delta = delta - old_fixpg_length + new_fixpg_length;
        new_head->fixrec_off   = old_head->fixrec_off + delta;
        new_head->impmod_off   = old_head->impmod_off + delta;
        new_head->num_impmods  = old_head->num_impmods;
        new_head->impproc_off  = old_head->impproc_off + delta;

        // copy the rest of fixup section
        offset += new_fixpg_length;
        length = old_head->fixup_size - old_fixpg_length;
        seek_rc = RcSeek( old->Handle, lx_off + old_head->fixpage_off
                                     + old_fixpg_length, SEEK_SET );
        if( seek_rc == -1 )
            return( RS_READ_ERROR );

        ret = CopyExeData( old->Handle, new->Handle, length );
        if( ret != RS_OK )
            return( ret );
    } else {
        new_head->fixup_size   = 0;
        new_head->fixup_cksum  = 0;
        new_head->fixpage_off  = 0;
        new_head->fixrec_off   = 0;
        new_head->impmod_off   = 0;
        new_head->num_impmods  = 0;
        new_head->impproc_off  = 0;
        length = 0;
    }
    offset += length;

    return( RS_OK );
}


extern int CopyLXExeObjects( void )
/*********************************/
{
    ExeFileInfo     *old;
    ExeFileInfo     *tmp;
    object_record   *old_obj;
    object_record   *tmp_obj;
    int             num_objs;
    RcStatus        status;

    old = &Pass2Info.OldFile;
    tmp = &Pass2Info.TmpFile;

    if( readObjectAndPageTable( old ) ) {
        return( TRUE );
    }
    num_objs = copyObjectAndPageTable( old, tmp );
    if( num_objs == -1 ) {
        return( TRUE );
    }

    /* At this point we finally know how big all the tables in executable
     * header will be and can start copying data to the new executable;
     * resources will be written and the headers finalized later.
     */
    if( copyHeaderSections( old, tmp ) ) {
        return( TRUE );
    }

    old_obj = old->u.LXInfo.Objects;
    tmp_obj = tmp->u.LXInfo.Objects;
    for( ; num_objs > 0; num_objs--, old_obj++, tmp_obj++ ) {
        status = copyOneObject( old, old_obj, tmp, tmp_obj );
        switch( status ) {
        case RS_WRITE_ERROR:
            RcError( ERR_WRITTING_FILE, tmp->name, strerror( errno ) );
            return( TRUE );
        case RS_READ_ERROR:
            RcError( ERR_READING_EXE, old->name, strerror( errno ) );
            return( TRUE );
        case RS_READ_INCMPLT:
            RcError( ERR_UNEXPECTED_EOF, old->name );
            return( TRUE );
        default:
            break;
        }
        CheckDebugOffset( old );
        CheckDebugOffset( tmp );
    }

    return( FALSE );
} /* CopyLXExeObjects */