void media_track_info::fix_sample_table( trak & track )
{
if( _heapchk() != _HEAPOK )
{
cout << "heap corrupted." << endl;
assert( false );
}
// fix stts, decoding time to sample
fix_stts(track);
// fix ctts, composition time to sample box
fix_ctts(track);
// fix stsc, sample to chunk
fix_stsc(track);
// fix stss, sync sample box
fix_stss(track);
fix_stsz(track);
//// FIX STSC, STCO
//throw std::exception( "to fix stsz, stco" );
if( _heapchk() != _HEAPOK )
{
cout << "heap corrupted." << endl;
assert( false );
}
}
main()
{
int i;
dynatab_t *pt[NTABS];
for (i=0;i<NTABS;i++) {
pt[i] = dynatab_create(sizeof(int));
if (!pt[i]) {
printf("create: test failed\n");
exit(1);
}
if (dynatab_subscript(pt[i], 1) != NULL) {
printf("subcript1: test failed\n");
exit(1);
}
}
for (i=0;i<NTABS;i++) {
int h;
h = _heapchk();
if (h != _HEAPOK) {
printf("heapchk: test failed\n");
exit(1);
}
test1(pt[i]);
}
for (i=0;i<NTABS;i++)
dynatab_destroy(pt[i]);
printf("test okay\n");
return 0;
}
bool KeyValues::LoadFromFile(IFileSystem *filesystem, const char *resourceName, const char *pathID)
{
assert(filesystem);
assert(IsX360() || (IsPC() && _heapchk() == _HEAPOK));
FileHandle_t f = filesystem->Open(resourceName, "rb", pathID);
if (!f)
return false;
s_LastFileLoadingFrom = (char *)resourceName;
int fileSize = filesystem->Size(f);
char *buffer = (char *)MemAllocScratch(fileSize + 1);
Assert(buffer);
bool bRetOK = (filesystem->Read(buffer, fileSize, f) != 0);
filesystem->Close(f);
if (bRetOK)
{
buffer[fileSize] = 0;
bRetOK = LoadFromBuffer(resourceName, buffer, filesystem);
}
MemFreeScratch();
return bRetOK;
}
HIDDEN void TSTRACEValidateHeaps()
{
#ifdef DEBUG_HEAP
if ( _heapchk() != _HEAPOK )
{
CkmError("***** HEAP DAMAGE DETECTED *****");
LOG(CallTrace, "Error: ***** HEAP DAMAGE DETECTED *****");
DebugBreak();
}
#endif
#ifdef DEBUG_PROCESS_HEAP
tsByteString buffer;
DWORD heapCount;
buffer.resize (sizeof(HANDLE));
heapCount = GetProcessHeaps(1, (PHANDLE)buffer.rawData());
if ( heapCount > 1 )
{
buffer.resize(sizeof(HANDLE) * heapCount);
heapCount = GetProcessHeaps(heapCount, (PHANDLE)buffer.rawData());
}
for (int ii = 0; ii < heapCount; ii++)
{
if ( !HeapValidate(((PHANDLE)buffer.rawData())[ii], 0, NULL) )
{
CkmError("***** PROCESS HEAP DAMAGE DETECTED *****");
LOG(CallTrace, "Error: ***** PROCESS HEAP DAMAGE DETECTED *****");
// DebugBreak();
}
}
#endif // DEBUG_PROCESS_HEAP
}
/*
* @implemented
*/
int _heapset(unsigned int unFill)
{
if (_heapchk() == -1)
return -1;
return 0;
}
int CDbgMemAlloc::heapchk()
{
#ifdef WIN32
return _heapchk();
#else
printf("XXX: CDbgMemAlloc::heapchk() not portd to FreeBSD in file %s\n", __FILE__);
return 0;
#endif
}
bool heap_ok( const char *msg )
{
bool rc = true;
int heap_status = _heapchk( );
if( heap_status != _HEAPOK && heap_status != _HEAPEMPTY ) {
std::cout << "!!! HEAP CONSISTENCY FAILURE: " << msg << "\n";
rc = false;
}
return( rc );
}
/*----------------------------------------------------------------------------
* HeapCheck()
*----------------------------------------------------------------------------
* Check heap status
*----------------------------------------------------------------------------
*/
void HeapCheck (void)
{
int heapStatus;
/* Check heap status */
heapStatus = _heapchk();
if ((heapStatus == _HEAPOK) || (heapStatus == _HEAPEMPTY))
return;
EAS_ReportX(_EAS_SEVERITY_FATAL, "Heap corrupt\n" );
}
void checkHeap()
{
#ifdef _MSC_VER
static a_int32_t count( 0 );
if( ( ++count % 10000 ) == 0 && _heapchk() != _HEAPOK )
{
LBERROR << disableFlush << "Abort: heap corruption detected"<< std::endl
<< " Set breakpoint in " << __FILE__ << ':' << __LINE__ + 1
<< " to debug" << std::endl << enableFlush;
}
#else
#endif
}
FLAC__StreamDecoderWriteStatus mwrite
(const FLAC__SeekableStreamDecoder *decoder,
const FLAC__Frame *frame, const FLAC__int32 * const buffer[], void *client_data)
{
Mdata *mdata = client_data;
unsigned i,j;
size_t newend;
if (!mdata) { return FLAC__STREAM_DECODER_WRITE_STATUS_ABORT;}
newend = frame->header.blocksize*frame->header.channels*(frame->header.bits_per_sample/8);
if (mdata->bufend < newend) {
if (mdata->buffer) {
free(mdata->buffer);
mdata->buffer = 0;
} /* endif */
mdata->bufend=newend;
} /* endif */
if (!mdata->buffer) {
mdata->buffer = malloc(mdata->bufend);
if (!mdata->buffer) { return FLAC__STREAM_DECODER_WRITE_STATUS_ABORT;}
} /* endif */
#ifdef DEBUG
fprintf(file,"callback write %ld\n",newend);
fprintf(file,"size_t: %ld\n",sizeof(size_t));
fprintf(file,"heap: %d\n",_heapchk());
#endif
mdata->bufsize=0;
for(i=0;i<frame->header.blocksize;i++) {
for(j=0;j<frame->header.channels;j++) {
mdata->buffer[mdata->bufsize] = (buffer[j][i] & 0xFF);
if (mdata->bits_per_sample <= 8) {
mdata->buffer[mdata->bufsize]+=1<<(mdata->bits_per_sample-1);
}
mdata->bufsize++;
if (mdata->bits_per_sample > 8) {
mdata->buffer[mdata->bufsize] = ((buffer[j][i] & 0xFF00) >> 8);
mdata->bufsize++;
} /* endif */
if (mdata->bits_per_sample > 16) {
mdata->buffer[mdata->bufsize] = ((buffer[j][i] & 0xFF0000) >> 8);
mdata->bufsize++;
} /* endif */
if (mdata->bits_per_sample > 24) {
mdata->buffer[mdata->bufsize] = ((buffer[j][i] & 0xFF000000) >> 8);
mdata->bufsize++;
} /* endif */
void SampleScene01::Render(Dx11Context* context, Dx11Camera* camera, Dx11Lens* lens)
{
wchar_t buf[32];
wsprintf(buf, L"カウント: %d", left);
float w = text->SetText(context, buf);
EffectGUIStandardInfo info = {0, 0, 0.125f * w, 0.125f,
1.0f, 0.5f, 0, 0}; // 完全不透明（1.0f), 色半反転(0,5f)
effect->Update(context, text, &info);
if(_heapchk()!=_HEAPOK) {
DebugBreak();
}
osd_fps->Render(context, camera, lens);
}
void TestHeap(void)
{
WORD msgId;
char *outStr;
switch (_heapchk())
{
case _HEAPBADBEGIN: outStr= "HEAPBADBEGIN"; msgId= MSG_HEAP_BADBEGIN; break;
case _HEAPBADNODE : outStr= "HEAPBADNODE"; msgId= MSG_HEAP_BADNODE; break;
case _HEAPBADPTR : outStr= "HEAPBADPTR"; msgId= MSG_HEAP_BADPTR; break;
case _HEAPEMPTY : outStr= "HEAPEMPTY"; msgId= MSG_HEAP_EMPTY; break;
case _HEAPOK : outStr= "HEAPOK"; msgId= MSG_HEAP_OK; break;
case _HEAPEND : outStr= "HEAPEND"; msgId= MSG_HEAP_END; break;
default : outStr= "UNKNOWNMESSAGE"; msgId= MSG_HEAP_UNKNOWN;
}
if (heapMsg)
WriteMessageToPow(msgId, NULL, NULL);
}
void ObjMeshGPUDeformer::heap_check_()
{
int heapstatus = _heapchk();
switch( heapstatus )
{
case _HEAPOK:
printf(" OK - heap is fine\n" );
break;
case _HEAPEMPTY:
printf(" OK - heap is empty\n" );
break;
case _HEAPBADBEGIN:
printf( "ERROR - bad start of heap\n" );
break;
case _HEAPBADNODE:
printf( "ERROR - bad node in heap\n" );
break;
}
}
// ================================================================================================
// FUNCTION : wiMemory_RecordHeap()
// ------------------------------------------------------------------------------------------------
// ================================================================================================
wiStatus wiMemory_RecordHeap(void)
{
#ifdef WIN32
char filename[256]; FILE *F;
int heapstatus, numLoops = 0;
_HEAPINFO hinfo;
STATUS(wiProcess_WaitForMutex(&TraceMemoryMutex));
sprintf(filename, "HeapImage%u.txt",wiProcess_ThreadIndex());
printf("filename = %s\n",filename);
F = fopen(filename, "wt");
if (!F) return STATUS(WI_ERROR);
heapstatus = _heapchk();
fprintf(F,"wiMemory_RecordHeap()\n");
fprintf(F,"_HEAP_MAXREQ = %u\n",_HEAP_MAXREQ);
fprintf(F,"heapstatus = %d (OK=%d, EMPTY=%d, BAD START=%d, BAD NODE = %d)\n",heapstatus, _HEAPOK, _HEAPEMPTY, _HEAPBADBEGIN, _HEAPBADNODE);
hinfo._pentry = NULL;
while((heapstatus = _heapwalk(&hinfo)) == _HEAPOK)
{
fprintf(F,"%6s block at %Fp of size %4.4X\n",
(hinfo._useflag == _USEDENTRY ? "USED" : "FREE"), hinfo._pentry, hinfo._size);
numLoops++;
}
switch(heapstatus)
{
case _HEAPEMPTY : fprintf(F,"OK - empty heap\n"); break;
case _HEAPEND : fprintf(F,"OK - end of heap\n"); break;
case _HEAPBADPTR : fprintf(F,"ERROR - bad pointer to heap\n"); break;
case _HEAPBADBEGIN: fprintf(F,"ERROR - bad start of heap\n"); break;
case _HEAPBADNODE : fprintf(F,"ERROR - bad node in heap\n"); break;
}
fclose(F);
STATUS(wiProcess_ReleaseMutex(&TraceMemoryMutex));
#endif
return WI_SUCCESS;
}
//! Runs consistency checks on the heap.
//! This is enabled in release builds, unlike _CrtCheckMemory.
Value* heapcheck_cf(Value**, int count)
{
check_arg_count(heapcheck, 0, count);
int heap_status = _heapchk();
/* I'll use these later
switch (heap_status)
{
case _HEAPOK:
break;
case _HEAPEMPTY:
break;
case _HEAPBADPTR:
break;
case _HEAPBADNODE:
break;
case _HEAPBADBEGIN:
break;
}
*/
return (heap_status == _HEAPOK) ? &true_value : &false_value;
}
bool CHalfLife2::KVLoadFromFile(KeyValues *kv, IBaseFileSystem *filesystem, const char *resourceName, const char *pathID)
{
#if defined METAMOD_PLAPI_VERSION
if (g_SMAPI->GetSourceEngineBuild() == SOURCE_ENGINE_ORIGINAL)
#else
if (strcasecmp(g_SourceMod.GetGameFolderName(), "ship") == 0)
#endif
{
Assert(filesystem);
#ifdef _MSC_VER
Assert(_heapchk() == _HEAPOK);
#endif
FileHandle_t f = filesystem->Open(resourceName, "rb", pathID);
if (!f)
return false;
// load file into a null-terminated buffer
int fileSize = filesystem->Size(f);
char *buffer = (char *)MemAllocScratch(fileSize + 1);
Assert(buffer);
filesystem->Read(buffer, fileSize, f); // read into local buffer
buffer[fileSize] = 0; // null terminate file as EOF
filesystem->Close( f ); // close file after reading
bool retOK = kv->LoadFromBuffer( resourceName, buffer, filesystem );
MemFreeScratch();
return retOK;
}
else
{
return kv->LoadFromFile(filesystem, resourceName, pathID);
}
}
/* Returns non-zero value if heap is corrupted. Declare in the main program,
permit any other module to use it. Todo- place in a "general" functions
source file and include only front end header. */
int check_heap() {
int rc = 0;
#ifdef __DOS__
switch(_heapchk()) {
case _HEAPOK:
printf("OK - heap is good\n");
break;
case _HEAPEMPTY:
printf("OK - heap is empty\n");
break;
case _HEAPBADBEGIN:
printf("ERROR - heap is damaged\n");
rc = -1;
break;
case _HEAPBADNODE:
printf("ERROR - bad node in heap\n");
rc = -1;
break;
}
#endif
return rc;
}
// ================================================================================================
// FUNCTION : wiMemory_Check()
// ------------------------------------------------------------------------------------------------
// ================================================================================================
wiStatus wiMemory_Check(char *Filename, int Line)
{
STATUS( wiProcess_WaitForMutex(&TraceMemoryMutex) );
{
wiMemory_traceMem_t *item = traceMemList;
unsigned long total = 0;
wiUtil_WriteLogFile("wiMemory_Check() called from %s line %d in thread %d\n",
Filename, Line, wiProcess_ThreadIndex() );
if (traceMemList)
{
while (item)
{
XSTATUS( wiMemory_CheckTraceBlock(item) )
total += item->size;
item = item->next;
}
wiUtil_WriteLogFile(" Total Allocated Memory: %d bytes\n",total);
}
#ifdef WIN32
{
int heapstatus = _heapchk();
switch (heapstatus)
{
case _HEAPOK : wiUtil_WriteLogFile(" HEAP CHECK: OK - heap is okay\n"); break;
case _HEAPEMPTY : wiUtil_WriteLogFile(" HEAP CHECK: OK - heap is empty\n"); break;
case _HEAPBADBEGIN: wiUtil_WriteLogFile(" HEAP CHECK: ERROR - bad start of heap\n"); break;
case _HEAPBADNODE : wiUtil_WriteLogFile(" HEAP CHECK: ERROR - bad node in heap\n"); break;
default : wiUtil_WriteLogFile(" HEAP CHECK: UNKNOWN STATUS %d\n",heapstatus);
}
}
#endif
}
STATUS( wiProcess_ReleaseMutex(&TraceMemoryMutex) );
return WI_SUCCESS;
}
//=================================================================================================
void eve::mem::check_heap(void)
{
#if defined(EVE_MEMORY_CHECK)
#if defined(EVE_OS_WIN)
int32_t heapstatus = _heapchk();
switch (heapstatus)
{
case _HEAPEMPTY:
break;
case _HEAPOK:
break;
case _HEAPBADBEGIN:
eve::mess::log_error(__FUNCTION__, "Memory Heap Error: Bad Begin.");
eve::core::failure();
break;
case _HEAPBADNODE:
eve::mess::log_error(__FUNCTION__, "Memory Heap Error: Bad Node.");
eve::core::failure();
break;
default:
eve::mess::log_error(__FUNCTION__, "Memory Heap Unknown Error.");
eve::core::failure();
break;
}
#else
// Do nothing.
#endif
#endif
}
static void my_heapchk()
{
int heapstatus = _heapchk();
assert(_HEAPOK == heapstatus);
}
int __cdecl _heapset (
unsigned int _fill
)
{
return _heapchk();
}
FxBool txConvert( Gu3dfInfo *info, GrTextureFormat_t srcFormat,
int srcWidth, int srcHeight,
const void *srcImage, FxU32 flags,
const void *palNcc )
{
TxMip srcMip;
TxMip trueColorMip;
TxMip outputMip;
TxMip tmpMip;
/*
* Make a txMip out of the passed data.
*/
memset( &srcMip, 0, sizeof( srcMip ) );
srcMip.format = srcFormat;
srcMip.width = srcWidth;
srcMip.height = srcHeight;
srcMip.depth = 1;
if( palNcc )
{
switch( srcFormat )
{
case GR_TEXFMT_YIQ_422:
case GR_TEXFMT_AYIQ_8422:
txNccToPal( srcMip.pal, palNcc);
break;
case GR_TEXFMT_P_8:
memcpy( srcMip.pal, palNcc, sizeof( FxU32 ) * 256 );
break;
}
}
srcMip.data[0] = ( void * )srcImage;
/*
* Set up a txMip to put a true color version of the texture in.
*/
memset( &trueColorMip, 0, sizeof( trueColorMip ) );
trueColorMip.format = GR_TEXFMT_ARGB_8888;
trueColorMip.width = srcWidth;
trueColorMip.height = srcHeight;
/*
* Set the depth to the mipmapped depth to allocate the image.
*/
#ifdef GLIDE3
trueColorMip.depth = info->header.large_lod - info->header.small_lod + 1;
#else
trueColorMip.depth = info->header.small_lod - info->header.large_lod + 1;
#endif
if( !txMipAlloc( &trueColorMip ) )
return FXFALSE;
/*
* Set to one level only since we only want to dequant the first
* level.
*/
trueColorMip.depth = 1;
/*
* Convert from the input format to truecolor.
*/
txMipDequantize( &trueColorMip, &srcMip );
/*
* We realy have more than one level, so. . .
*/
#ifdef GLIDE3
trueColorMip.depth = info->header.large_lod - info->header.small_lod + 1;
#else
trueColorMip.depth = info->header.small_lod - info->header.large_lod + 1;
#endif
/*
* WARNING! I do not free srcMip.data[0] since it is passed in by the users.
*/
/*
* Resample the true color version of the input image to
* the passed in size. . . . this should be a valid
* size for the hardware to handle.
*/
tmpMip = trueColorMip;
tmpMip.width = info->header.width;
tmpMip.height = info->header.height;
txMipAlloc( &tmpMip );
if( ( flags & TX_CLAMP_MASK ) == TX_CLAMP_DISABLE )
{
txMipResample( &tmpMip, &trueColorMip );
}
else
{
txMipClamp( &tmpMip, &trueColorMip );
#if 0
txMipView( &tmpMip, "blah", FXTRUE, 0 );
#endif
}
#if 0
if( _heapchk() != _HEAPOK )
txPanic( "_heapchk failed" );
#endif
txFree( trueColorMip.data[0] );
trueColorMip = tmpMip;
/*
* Generate mipmap levels.
*/
#ifdef GLIDE3
trueColorMip.depth = info->header.large_lod - info->header.small_lod + 1;
#else
trueColorMip.depth = info->header.small_lod - info->header.large_lod + 1;
#endif
txMipMipmap( &trueColorMip );
#if 0
txMipView( &trueColorMip, "blah", FXTRUE, 0 );
#endif
/*
* Convert from true color to the output color format.
*/
memset( &outputMip, 0, sizeof( outputMip ) );
outputMip.format = info->header.format;
outputMip.width = info->header.width;
outputMip.height = info->header.height;
outputMip.depth = trueColorMip.depth;
outputMip.data[0] = info->data;
#if 0
txMipAlloc( &outputMip );
#else
txMipSetMipPointers( &outputMip );
#endif
if( ( flags & TX_TARGET_PALNCC_MASK ) == TX_TARGET_PALNCC_SOURCE )
{
txMipTrueToFixedPal( &outputMip, &trueColorMip, palNcc,
flags & TX_FIXED_PAL_QUANT_MASK );
}
else
{
txMipQuantize( &outputMip, &trueColorMip, outputMip.format,
flags & TX_DITHER_MASK, flags & TX_COMPRESSION_MASK );
}
info->data = outputMip.data[0];
if( ( info->header.format == GR_TEXFMT_YIQ_422 ) ||
( info->header.format == GR_TEXFMT_AYIQ_8422 ) )
{
txPalToNcc( &info->table.nccTable, outputMip.pal );
}
if( info->header.format == GR_TEXFMT_P_8 || info->header.format == GR_TEXFMT_AP_88 )
{
memcpy( info->table.palette.data, outputMip.pal, sizeof( FxU32 ) * 256 );
}
txFree( trueColorMip.data[0] );
return FXTRUE;
}
void SaveHeapLog()
{
FILE *f;
_HEAPINFO hi;
char block[129],*ad;
block[128]=0;
int code;
HANDLE heaps[200];
DWORD n;
PROCESS_HEAP_ENTRY phe;
f=fopen(WriteDir+SLASH+"heap.log","wb");
SetLastError(0);
n=GetProcessHeaps(200,heaps);
heaps[n]=GetProcessHeap();n++;
fprintf(f,"There are %i heaps for Steem\r\n",n);
for (DWORD i=0;i<n;i++){
code=HeapValidate(heaps[i],0,NULL);
if (code){
fprintf(f,"Heap %u okay\r\n",i);
}else{
fprintf(f,"Heap %u has an error in it!\r\n",i);
}
HeapLock(heaps[i]);
phe.lpData=NULL;
while (HeapWalk(heaps[i],&phe)){
fprintf(f,"%s%X\r\n","Bad node, address=",(unsigned long)(phe.lpData));
ad=((char*)phe.lpData)-64;
for (int n=0;n<128;n++){
block[n]=*(ad++);
if (block[n]==0) block[n]='\\';
if (block[n]==10) block[n]='\\';
if (block[n]==13) block[n]='\\';
}
fprintf(f,"%s\r\n",block);
}
HeapUnlock(heaps[i]);
if (phe.lpData==NULL) DisplayLastError();
}
fprintf(f,"\r\n\r\n");
code=_heapchk();
if (code==_HEAPOK){
fprintf(f,"%s\r\n","Heap okay, walking:");
}else if (code==_HEAPBADNODE){
fprintf(f,"%s\r\n","Heap has bad node! Walking anyway:");
}
hi._pentry=NULL;
for(;;){
code=_rtl_heapwalk(&hi);
if (code==_HEAPEND) break;
if (code==_HEAPBADNODE){
fprintf(f,"%s%X\r\n","Bad node, address=",(unsigned long)(hi.__pentry));
ad=((char*)hi._pentry)-64;
for (int n=0;n<128;n++){
block[n]=*(ad++);
if (block[n]==0) block[n]='\\';
if (block[n]==10) block[n]='\\';
if (block[n]==13) block[n]='\\';
}
fprintf(f,"%s\r\n",block);
}else if (code==_HEAPOK){
fprintf(f,"%s%X\r\n","Good node, address=",(unsigned long)(hi.__pentry));
}
}
fclose(f);
}
int
readSyms(void)
{
int i;
int count = 0;
int firstSym = 0; /* First symbol this module */
byte b, c, type;
word w, len;
codeLNAMES = NONE; /* Invalidate indexes for code segment */
codeSEGDEF = NONE; /* Else won't be assigned */
offset = 0; /* For diagnostics, really */
if ((keys = (HASHENTRY *)malloc(SYMALLOC * sizeof(HASHENTRY))) == 0)
{
printf("Could not malloc the initial %d entries for keys[]\n");
exit(10);
}
if ((leData = (byte *)malloc(0xFF80)) == 0)
{
printf("Could not malloc 64k bytes for LEDATA\n");
exit(10);
}
#if 0
switch(_heapchk())
{
case _HEAPBADBEGIN:
printf("Bad begin\n");
break;
case _HEAPBADNODE:
printf("Bad node\n");
break;
case _HEAPEMPTY:
printf("Bad empty\n");
break;
case _HEAPOK:
printf("Heap OK\n");
break;
}
#endif
while (!feof(f))
{
type = readByte();
len = readWord();
/* Note: uncommenting the following generates a *lot* of output */
/*printf("Offset %05lX: type %02X len %d\n", offset-3, type, len);/**/
switch (type)
{
case 0x96: /* LNAMES */
while (len > 1)
{
readString();
++lnum;
if (strcmp(buf, "CODE") == 0)
{
/* This is the class name we're looking for */
codeLNAMES= lnum;
}
len -= strlen(buf)+1;
}
b = readByte(); /* Checksum */
break;
case 0x98: /* Segment definition */
b = readByte(); /* Segment attributes */
if ((b & 0xE0) == 0)
{
/* Alignment field is zero. Frame and offset follow */
readWord();
readByte();
}
w = readWord(); /* Segment length */
b = readByte(); /* Segment name index */
++segnum;
b = readByte(); /* Class name index */
if ((b == codeLNAMES) && (codeSEGDEF == NONE))
{
/* This is the segment defining the code class */
codeSEGDEF = segnum;
}
b = readByte(); /* Overlay index */
b = readByte(); /* Checksum */
break;
case 0x90: /* PUBDEF: public symbols */
b = readByte(); /* Base group */
c = readByte(); /* Base segment */
len -= 2;
if (c == 0)
{
w = readWord();
len -= 2;
}
while (len > 1)
{
readString();
w = readWord(); /* Offset */
b = readByte(); /* Type index */
if (c == codeSEGDEF)
{
byte *p;
allocSym(count);
p = buf;
if (buf[0] == '_') /* Leading underscore? */
{
p++; /* Yes, remove it*/
}
i = MIN(SYMLEN-1, strlen(p));
memcpy(keys[count].name, p, i);
keys[count].name[i] = '\0';
keys[count].offset = w;
/*printf("%04X: %s is sym #%d\n", w, keys[count].name, count);/**/
count++;
}
len -= strlen(buf) + 1 + 2 + 1;
}
b = readByte(); /* Checksum */
break;
case 0xA0: /* LEDATA */
{
b = readByte(); /* Segment index */
w = readWord(); /* Offset */
len -= 3;
/*printf("LEDATA seg %d off %02X len %Xh, looking for %d\n", b, w, len-1, codeSEGDEF);/**/
if (b != codeSEGDEF)
{
readNN(len); /* Skip the data */
break; /* Next record */
}
if (fread(&leData[w], 1, len-1, f) != len-1)
{
printf("Could not read LEDATA length %d\n", len-1);
exit(2);
}
offset += len-1;
maxLeData = MAX(maxLeData, w+len-1);
readByte(); /* Checksum */
break;
}
default:
readNN(len); /* Just skip the lot */
if (type == 0x8A) /* Mod end */
{
/* Now find all the patterns for public code symbols that
we have found */
for (i=firstSym; i < count; i++)
{
word off = keys[i].offset;
if (off == (word)-1)
{
continue; /* Ignore if already done */
}
if (keys[i].offset > maxLeData)
{
printf(
"Warning: no LEDATA for symbol #%d %s "
"(offset %04X, max %04X)\n",
i, keys[i].name, off, maxLeData);
/* To make things consistant, we set the pattern for
this symbol to nulls */
memset(&keys[i].pat, 0, PATLEN);
continue;
}
/* Copy to temp buffer so don't overrun later patterns.
(e.g. when chopping a short pattern).
Beware of short patterns! */
if (off+PATLEN <= maxLeData)
{
/* Available pattern is >= PATLEN */
memcpy(buf, &leData[off], PATLEN);
}
else
{
/* Short! Only copy what is available (and malloced!) */
memcpy(buf, &leData[off], maxLeData-off);
/* Set rest to zeroes */
memset(&buf[maxLeData-off], 0, PATLEN-(maxLeData-off));
}
fixWildCards(buf);
/* Save into the hash entry. */
memcpy(keys[i].pat, buf, PATLEN);
keys[i].offset = (word)-1; /* Flag it as done */
/*printf("Saved pattern for %s\n", keys[i].name);/**/
}
while (readByte() == 0);
readNN(-1); /* Unget the last byte (= type) */
lnum = 0; /* Reset index into lnames */
segnum = 0; /* Reset index into snames */
firstSym = count; /* Remember index of first sym this mod */
codeLNAMES = NONE; /* Invalidate indexes for code segment */
codeSEGDEF = NONE;
memset(leData, 0, maxLeData); /* Clear out old junk */
maxLeData = 0; /* No data read this module */
}
else if (type == 0xF1)
{
/* Library end record */
return count;
}
}
}
free(leData);
free(keys);
return count;
}
int EBuffer::ShowPosition() {
int CLine, NLines;
int CAct, NAct;
int CColumn, NColumns;
int CCharPos, NChars;
#ifdef HEAPWALK
unsigned long MemUsed = 0, MemFree = 0, BlkUsed = 0, BlkFree = 0, BigFree = 0, BigUsed = 0;
#endif
if (!View)
return 0;
CLine = CP.Row + 1;
NLines = VCount;
CAct = VToR(CP.Row) + 1;
NAct = RCount;
CColumn = CP.Col + 1;
NColumns = LineLen(CP.Row);
CCharPos = CharOffset(VLine(CP.Row), CP.Col) + 1;
NChars = VLine(CP.Row)->Count;
#ifdef HEAPWALK
if (_heapchk() != _HEAPOK) {
MemUsed = -1;
} else {
_HEAPINFO hi;
hi._pentry = NULL;
while (_heapwalk(&hi) == _HEAPOK) {
if (hi._useflag == _USEDENTRY) {
BlkUsed++;
MemUsed += hi._size;
if (hi._size > BigUsed)
BigUsed = hi._size;
//fprintf(stderr, "USED %d\n", hi._size);
} else {
BlkFree++;
MemFree += hi._size;
if (hi._size > BigFree)
BigFree = hi._size;
//fprintf(stderr, "FREE %d\n", hi._size);
}
}
}
#endif
int NN = -1;
if (US.UndoPtr > 0)
NN = US.Top[US.UndoPtr - 1];
Msg(S_INFO,
#ifdef HEAPWALK
"M%ld,%ld B%ld,%ld S%ld,%ld"
#endif
"L%d/%d G%d/%d/%d A%d/%d C%d/%d P%d/%d "
"U%d/%d/%d "
"H%d/%d/%d",
#ifdef HEAPWALK
MemUsed, MemFree, BlkUsed, BlkFree, BigUsed, BigFree,
#endif
CLine, NLines,
RGap, RCount, RAllocated,
CAct, NAct,
CColumn, NColumns,
CCharPos, NChars,
US.UndoPtr, US.Num, NN,
StartHilit, MinRedraw, MaxRedraw);
return 1;
}
