Subversion Repositories or1k

/************************************************************************/

/*      Copyright (C) 1986-1991 Phar Lap Software, Inc.                 */

/*      Unpublished - rights reserved under the Copyright Laws of the   */

/*      United States.  Use, duplication, or disclosure by the          */

/*      Government is subject to restrictions as set forth in           */

/*      subparagraph (c)(1)(ii) of the Rights in Technical Data and     */

/*      Computer Software clause at 252.227-7013.                       */

/*      Phar Lap Software, Inc., 60 Aberdeen Ave., Cambridge, MA 02138  */

/************************************************************************/

/* REALCOPY.C:  copy real mode code to conventional memory */

/*

 * The routine in this file allocates conventional memory and copies

 * real mode code to it.

 */

#include <stdio.h>

#include <pltypes.h>

#include <pharlap.h>

realcopy(start_offs, end_offs, real_basep, prot_basep, rmem_adrp)

ULONG   start_offs;

ULONG   end_offs;

REALPTR *real_basep;

FARPTR  *prot_basep;

USHORT  *rmem_adrp;

/*

Description:

        This routine allocates conventional memory for the specified block

        of code (which must be within the first 64K of the protected mode

        program segment) and copies the code to it.

        The caller should free up the conventional memory block when it

        is done with the conventional memory.

        NOTE THIS ROUTINE REQUIRES 386|DOS-EXTENDER 3.0 OR LATER.

Calling arguments:

        start_offs      start of real mode code in program segment

        end_offs        1 byte past end of real mode code in program segment

        real_basep      returned;  real mode ptr to use as a base for the

                                real mode code (eg, to get the real mode FAR

                                addr of a function foo(), take

                                real_basep + (ULONG) foo).

                                This pointer is constructed such that

                                offsets within the real mode segment are

                                the same as the link-time offsets in the

                                protected mode program segment

        prot_basep      returned;  prot mode ptr to use as a base for getting

                                to the conventional memory, also constructed

                                so that adding the prot mode offset of a

                                function or variable to the base gets you a

                                ptr to the function or variable in the

                                conventional memory block.

        rmem_adrp       returned;  real mode para addr of allocated

                                conventional memory block, to be used to free

                                up the conventional memory when done.  DO NOT

                                USE THIS TO CONSTRUCT A REAL MODE PTR, USE

                                REAL_BASEP INSTEAD SO THAT OFFSETS WORK OUT

                                CORRECTLY.

Returned values:

        TRUE            if error

        FALSE           if success

*/

{

        ULONG   rm_base;        /* base real mode para addr for accessing */

                                        /* allocated conventional memory */

        UCHAR   *sp;            /* source pointer for copy */

        FARPTR  dp;             /* destination pointer for copy */

        ULONG   len;            /* number of bytes to copy */

        ULONG   temp;

        USHORT  stemp;

/*

 * First check for valid inputs

 */

        if (start_offs >= end_offs || end_offs > 0x10000)

        {

                return TRUE;

        }

/*

 * Round start_offs down to a paragraph (16-byte) boundary so we can set up

 * the real mode pointer easily.

 */

        start_offs &= ~15;

/*

 * Allocate the conventional memory for our real mode code.  Remember to

 * round byte count UP to 16-byte paragraph size.  We alloc it

 * above the DOS data buffer so both the DOS data buffer and the appl

 * conventional mem block can still be resized.

 *

 * First just try to alloc it;  if we can't get it, shrink the appl mem

 * block down to the minimum, try to alloc the memory again, then grow the

 * appl mem block back to the maximum.  (Don't try to shrink the DOS data

 * buffer to free conventional memory;  it wouldn't be good for this routine

 * to have the possible side effect of making file I/O run slower.)

 */

        len = ((end_offs - start_offs) + 15) >> 4;

        if (_dx_real_above(len, rmem_adrp, &stemp) != _DOSE_NONE)

        {

                if (_dx_cmem_usage(0, FALSE, &temp, &temp) != _DOSE_NONE)

                {

                        return TRUE;

                }

                if (_dx_real_above(len, rmem_adrp, &stemp) != _DOSE_NONE)

                        *rmem_adrp = 0;

                if (_dx_cmem_usage(0, TRUE, &temp, &temp) != _DOSE_NONE)

                {

                        if (*rmem_adrp != 0)

                                _dx_real_free(*rmem_adrp);

                        return TRUE;

                }

                if (*rmem_adrp == 0)

                {

                        return TRUE;

                }

        }

/*

 * Construct real mode & protected mode pointers to access the allocated

 * memory.  Note we know start_offs is aligned on a paragraph (16-byte)

 * boundary, because we rounded it down.

 *

 * We make the offsets come out rights by backing off the real mode selector

 * by start_offs.

 */

        rm_base = ((ULONG) *rmem_adrp) - (start_offs >> 4);

        RP_SET(*real_basep, 0, rm_base);

        FP_SET(*prot_basep, rm_base << 4, SS_DOSMEM);

/*

 * Copy the real mode code to the allocated memory

 */

        sp = (UCHAR *) start_offs;

        dp = *prot_basep + start_offs;

        len = end_offs - start_offs;

        while (len-- > 0)

                *dp++ = *sp++;

        return FALSE;

}