/*
* direction-independent translation
*/
static Elf_Data*
elf32_xlate(Elf_Data *dst, const Elf_Data *src, unsigned encode, int tof) {
size_t ssize, dsize, count;
Elf_Type type;
int sv, dv;
xlator op;
if (!src || !dst) {
return NULL;
}
if (!src->d_buf || !dst->d_buf) {
seterr(ERROR_NULLBUF);
return NULL;
}
if (!valid_encoding(encode)) {
seterr(ERROR_UNKNOWN_ENCODING);
return NULL;
}
sv = src->d_version;
dv = dst->d_version;
if (!valid_version(sv) || !valid_version(dv)) {
seterr(ERROR_UNKNOWN_VERSION);
return NULL;
}
type = src->d_type;
if (!valid_type(type)) {
seterr(ERROR_UNKNOWN_TYPE);
return NULL;
}
ssize = _fmsize(ELFCLASS32, sv, type, 1 - tof);
dsize = _fmsize(ELFCLASS32, dv, type, tof);
op = translator(sv, dv, encode, type, tof);
if (!ssize || !dsize || !op) {
seterr(ERROR_UNKNOWN_TYPE);
return NULL;
}
count = src->d_size / ssize;
if (dst->d_size < count * dsize) {
seterr(ERROR_DST2SMALL);
return NULL;
}
if (count) {
(*op)(dst->d_buf, src->d_buf, count);
}
dst->d_size = count * dsize;
dst->d_type = type;
return dst;
}
void main()
{
char *buf;
char __far *buf2;
buf = (char *) malloc( 80 );
printf( "Size of buffer is %u\n", _msize(buf) );
if( _expand( buf, 100 ) == NULL ) {
printf( "Unable to expand buffer\n" );
}
printf( "New size of buffer is %u\n", _msize(buf) );
buf2 = (char __far *) _fmalloc( 2000 );
printf( "Size of far buffer is %u\n", _fmsize(buf2) );
if( _fexpand( buf2, 8000 ) == NULL ) {
printf( "Unable to expand far buffer\n" );
}
printf( "New size of far buffer is %u\n",
_fmsize(buf2) );
}
HMEM BMRealloc ( HMEM hv, UINT cb ) {
#ifdef BMHANDLES // {
LPV lpv;
UINT cbOld;
CVEnterCritSection(icsBm);
lpv = LpvFromHmem ( hv );
assert ( LPV );
cbOld = _fmsize ( LPV );
if ( cbOld != cb ) {
LPV lpvNew = _fmalloc ( cb );
if ( LPV && lpvNew) {
_fmemcpy ( lpvNew, lpv, min ( cb, cbOld ) );
_ffree ( LPV );
LpvFromHmem ( hv ) = lpvNew;
}
else {
hv = hmemNull;
}
}
CVLeaveCritSection(icsBm);
return hv;
#else // } else !BMHANDLES {
return (HMEM) _frealloc((VOID FAR *)hv, cb);
#endif // }
}
