unsigned __GrowSeg( unsigned short seg, unsigned int amount )
{
unsigned n; /* number of paragraphs desired */
unsigned int old_heaplen;
unsigned int old_heap_paras;
struct heapblk _WCFAR *p;
struct freelist _WCFAR *pfree;
struct freelist _WCFAR *pnew;
tag _WCFAR *last_tag;
if( !__heap_enabled ) return( 0 );
p = (struct heapblk _WCFAR *)MK_FP( seg, 0 );
old_heaplen = p->heaplen;
if( old_heaplen != 0 ) { /* if not already 64K */
amount += TAG_SIZE; /* 25-feb-91 */
if( amount < TAG_SIZE ) amount = ~0;
if( amount < _amblksiz ) amount = _amblksiz;
n = ( amount + 0x0f ) >> 4;
if( n == 0 ) n = PARAS_IN_64K; /* 23-may-89 */
old_heap_paras = old_heaplen >> 4;
n += old_heap_paras;
/*
We shouldn't extend segments to 64k if we are not going to
use the space for this allocation. In protected-mode
environments, it should be possible to extend segments
later on when we know we can use the space.
*/
#if defined(__QNX__)
if( n > PARAS_IN_64K ) return( 0 );
#elif defined(__OS2__) || defined(__WINDOWS_286__)
if( n > PARAS_IN_64K ) {
if( _osmode != DOS_MODE ) {
/* protected-mode */
return( 0 );
} else {
n = PARAS_IN_64K;
}
}
#else
if( n > PARAS_IN_64K ) n = PARAS_IN_64K;
#endif
#if defined(__OS2__)
if( DosReallocSeg( n << 4, seg ) != 0 ) return( 0 );
#elif defined(__QNX__)
if( qnx_segment_realloc( seg, ((long)n) << 4 ) == -1 ) return( 0 );
#elif defined(__WINDOWS_286__)
if( old_heap_paras < (PARAS_IN_64K-2) && n == PARAS_IN_64K ) {
n = PARAS_IN_64K - 2;
} else if( n > ( PARAS_IN_64K - 2 ) ) {
/*
in Standard mode, GlobalRealloc may change selectors
if size > 65519 (64k-17)! (p. 4-246 Windows Ref) AFS 23-apr-91
*/
return( 0 );
}
{
HANDLE hmem;
hmem = (HANDLE)GlobalHandle( seg );
if( hmem == NULL ) {
return( 0 );
}
if( GlobalReAlloc( hmem, ((long)n) << 4,
__win_realloc_flags) == NULL ){
return( 0 );
}
}
#else
if( TINY_ERROR( TinySetBlock( n, seg ) ) ) return( 0 );
#endif
p->heaplen = n << 4; /* put in new heap length */
pfree = MK_FP( seg, p->freehead.prev );
if( FP_OFF(pfree) + pfree->len != old_heaplen - TAG_SIZE*2 ) {
/* last free entry not at end of the heap */
/* add a new free entry to end of list */
pnew = MK_FP( seg, old_heaplen - TAG_SIZE*2 );
pnew->prev = FP_OFF(pfree);
pnew->next = pfree->next;
pfree->next = FP_OFF(pnew);
p->freehead.prev = FP_OFF(pnew);
p->numfree++;
pfree = pnew;
}
pfree->len = p->heaplen - FP_OFF(pfree) - TAG_SIZE*2;
if( pfree->len > p->largest_blk ) p->largest_blk = pfree->len;
last_tag = MK_FP( seg, p->heaplen - TAG_SIZE*2 );
*last_tag = END_TAG;
last_tag[1] = 0; /* link to next piece of near heap */
return( 1 ); /* indicate segment was grown */
}
AFILE *makefp(DEBFILE *pdf, ULONG mid, ULONG instaddr, UCHAR *fname)
{
uchar *cp = NULL;
uint segbase;
uchar *srcbuf;
uint Nlines;
uint Tlines;
SEL srcsel;
SEL offsel;
ushort srcseglen;
ushort *offtab;
AFILE *fp;
int ftype;
int OffsetTableBufSize;
char FileNameBuffer[CCHMAXPATH];
char FileSpecBuffer[CCHMAXPATH];
UCHAR FileNameLength;
LNOTAB *pLnoTabEntry;
int sfi;
MODULE *pModule;
CSECT *pCsect;
UCHAR *pFileName;
UCHAR *fn;
BOOL found;
ULONG junk;
int lno;
if( fname )
{
/***************************************************************************/
/* - if fname is specified, then the view is to be build using the source */
/* file name supplied by the user as in the case of getfile. */
/* - we need to find an sfi to associate with the file. */
/* - build a length-prefixed z-string from the supplied name. */
/***************************************************************************/
fn = strrchr(fname, '\\');
fn = (fn) ? (fn + 1) : fname ;
pFileName = Talloc( strlen(fn) + 2 );
*pFileName = (UCHAR)strlen(fn);
strcpy( pFileName+1, fn );
found = FALSE;
for( sfi=mid=0, pdf = pnode->ExeStruct; pdf != NULL; pdf=pdf->next )
{
mid = MapSourceFileToMidSfi( pFileName, &sfi, pdf );
if( mid && sfi )
{
found = TRUE;
memset(FileNameBuffer, 0, sizeof(FileNameBuffer) );
strcpy(FileNameBuffer+1, fname );
FileNameBuffer[0] = (UCHAR)strlen(fname);
break;
}
}
Tfree( pFileName );
if( found == FALSE )
return(NULL);
instaddr = DBMapLno(mid, 0, sfi, &junk , pdf );
DBMapInstAddr(instaddr, &pLnoTabEntry, pdf);
lno = 0;
if( pLnoTabEntry )
lno = pLnoTabEntry->lno;
}
else
{
/***************************************************************************/
/* - we're going to build the view from an instruction address. */
/***************************************************************************/
if ( pdf->SrcOrAsm == SOURCE_LEVEL )
{
mid = DBMapInstAddr(instaddr, &pLnoTabEntry, pdf);
lno = sfi = 0;
if( pLnoTabEntry )
{
lno = pLnoTabEntry->lno;
sfi = pLnoTabEntry->sfi;
}
if( (pLnoTabEntry != NULL) && (sfi != 0) )
{
memset(FileNameBuffer, 0, sizeof(FileNameBuffer) );
cp = GetFileName( mid, sfi );
if( cp )
strcpy(FileNameBuffer, cp);
}
}
}
if(ftype)
{
findsrc(FileNameBuffer+1,FileSpecBuffer+1,sizeof(FileSpecBuffer) );
FileSpecBuffer[0] = (UCHAR)strlen(FileSpecBuffer+1);
memcpy(FileNameBuffer,FileSpecBuffer,sizeof(FileSpecBuffer));
}
FileNameLength = FileNameBuffer[0];
fp = (AFILE*) Talloc(SizeOfAFILE(FileNameLength));
memcpy( fp->filename, FileNameBuffer, FileNameLength+1);
/****************************************************************************/
/* - allocate 64k for the source buffer. */
/* - allocate 20k for the offset buffer. */
/* - load source file into a buffer and define: */
/* - srcsel = source buffer selector. */
/* - offsel = offset buffer selector. */
/* - 0 = number of lines to skip at the beginning of the file. */
/* - srcseglen = source buffer bytes actually used by the load. */
/* - Nlines = number of source lines in the buffer. */
/* - Tlines = number of source lines in the entire file. */
/* - reallocate the source buffer to size really needed. */
/****************************************************************************/
Nlines = srcsel = offsel = 0;
if( !DosAllocSeg(0,(PSEL)&srcsel,0) &&
!DosAllocSeg(20*1024,(PSEL)&offsel, 0) )
{
LoadSource( fp->filename+1, (UCHAR *)Sel2Flat(srcsel),
(USHORT *)Sel2Flat(offsel), 0, &srcseglen, &Nlines, &Tlines);
if( Nlines )
DosReallocSeg(srcseglen, srcsel);
}
/****************************************************************************/
/* - now, define the view structure. */
/****************************************************************************/
fp->shower = showA;
fp->pdf = pdf;
fp->mid = mid;
fp->sfi = sfi;
fp->mseg = segbase;
fp->Tlines = Tlines; /* number of lines in file. */
fp->Nlines = Nlines; /* number of lines in source buffer. */
fp->Nbias = 0; /* number of lines skipped in source.*/
fp->topline = 1; /* init to 1st line in the file. */
fp->csrline = lno; /* " " */
fp->hotline = lno; /* " " */
fp->hotaddr = instaddr;
fp->skipcols = 0; /* columns skipped on left. */
fp->Nshown = 0;
fp->topoff = instaddr;
fp->csr.row = 0;
fp->csr.col = 0;
fp->csr.mode = CSR_NORMAL;
fp->sview = NOSRC; /* assume no source disassembler view*/
fp->flags = ASM_VIEW_NEW;
if( Nlines )
{
srcbuf = (uchar*)Sel2Flat(srcsel);
fp->source = srcbuf;
/**************************************************************************/
/* Allocate the offtab[] buffer to hold Nlines + 1 offsets. We add the 1 */
/* so that we can make the offset table indices line up with the */
/* source line numbers. */
/**************************************************************************/
OffsetTableBufSize = (Nlines+1)*sizeof(USHORT);
offtab = (USHORT*) Talloc(OffsetTableBufSize);
memcpy(offtab + 1, (uchar*)Sel2Flat(offsel), Nlines*sizeof(USHORT) );
fp->offtab = offtab;
fp->flags = 0; /* clear asm flag. */
if( Tlines > Nlines ) /* does compressed source exceed 64k?*/
fp->flags |= AF_HUGE; /* mark afile with huge file flag */
fp->shower = showC; /* display source */
fp->sview = MIXEDN; /* assume no source disassembler view*/
/*
Flag all text lines for which a (line #, offset) pair exists.
*/
pModule = GetModuleWithAddr( instaddr, pdf );
if( pModule )
{
for(pCsect = pModule->pCsects; pCsect != NULL; pCsect=pCsect->next )
{
int NumEntries;
NumEntries = pCsect->NumEntries;
pLnoTabEntry = pCsect->pLnoTab;
if( (pLnoTabEntry != NULL) && ( NumEntries > 0 ) )
{
for( ; NumEntries; pLnoTabEntry++, NumEntries-- )
{
if( pLnoTabEntry->sfi == sfi )
{
int lno;
lno = pLnoTabEntry->lno;
if( (lno != 0) && (lno <= Nlines) )
{
*(srcbuf + offtab[lno] - 1) |= LINE_OK;
}
}
}
}
}
}
MarkLineBRKs( fp ); /* mark the active breakpoints */
}
if( offsel ) /* if there was an offset segment */
DosFreeSeg(offsel); /* allocated then free it up */
if( !Nlines && srcsel ) /* if there was no source then */
DosFreeSeg(srcsel); /* free up the temp source buffer */
return( fp );
}
