RELIES ON
---------
-Quit (char *error) function
+Quit (global_game_variables_t *gvar, char *error) function
WORK TO DO
*/
#include "src/lib/16_mm.h"
+#include "src/lib/16_ca.h"
+#include <malloc.h>
#pragma hdrstop
#pragma warn -pro
=============================================================================
*/
-
+#ifndef __16_PM__
static char *ParmStringsexmm[] = {"noems","noxms",""};
-
+#endif
/*
======================
=
boolean MML_CheckForEMS(void)
{
- boolean emmcfems;
+ boolean emmcfems = false;
+ word EMSPageFrame = 0;
+ byte err=0, str[64];
static char emmname[] = "EMMXXXX0"; //fix by andrius4669
-// mov dx,OFFSET emmname
__asm {
- //LEA DX, emmname //fix by andrius4669
mov dx,OFFSET emmname //fix by andrius4669
mov ax,0x3d00
- int 0x21 // try to open EMMXXXX0 device
+ int EMM_INT // try to open EMMXXXX0 device
jc error
mov bx,ax
mov ax,0x4400
- int 0x21 // get device info
+ int EMM_INT // get device info
jc error
and dx,0x80
mov ax,0x4407
- int 0x21 // get status
+ int EMM_INT // get status
jc error
or al,al
jz error
mov ah,0x3e
- int 0x21 // close handle
+ int EMM_INT // close handle
jc error
+
+ //
+ // pageframe check
+ //
+ mov ah,EMS_GETFRAME
+ int EMS_INT // find the page frame address
+ or ah,ah
+ jnz error
+ mov [EMSPageFrame],bx
+
//
// EMS is good
//
- mov emmcfems,1
- jmp End
+ mov emmcfems,1
+ jmp End
+#ifdef __BORLANDC__
+ }
+#endif
error:
+#ifdef __BORLANDC__
+ __asm {
+#endif
//
// EMS is bad
//
- mov emmcfems,0
+ mov err,ah
+ mov emmcfems,0
+#ifdef __BORLANDC__
+ }
+#endif
End:
+#ifdef __WATCOMC__
+ }
+#endif
+
+ //
+ // Pageframe switch to determine if there is one!
+ //
+ if(!EMSPageFrame)
+ {
+ emmcfems = false;
+#if defined(__DEBUG_PM__) || defined(__DEBUG_MM__)
+ printf("MML_CheckForEMS: EMS error No Pageframe!\nAddress detected to be %04x\n", EMSPageFrame);
+#endif
+ }else if(!emmcfems)// if there is an error and page frame is not 0000
+ {
+ strcpy(str,"MML_CheckForEMS: EMS error ");
+ MM_EMSerr(str, err);
+ printf("%s\n",str);
}
+
return(emmcfems);
}
-
+#ifndef __16_PM__
/*
======================
=
=======================
*/
-byte MML_SetupEMS(mminfo_t *mm)
+byte MML_SetupEMS(global_game_variables_t *gvar)
{
byte str[160];
byte err;
unsigned int EMSVer = 0;
//byte EMS_status;
- unsigned totalEMSpages,freeEMSpages,EMSpageframe,EMSpagesmapped,EMShandle;
- totalEMSpages = freeEMSpages = EMSpageframe = EMSpagesmapped = 0;
+ unsigned totalEMSpages,freeEMSpages,EMSPageFrame,EMSpagesmapped,EMSHandle;
+ totalEMSpages = freeEMSpages = EMSPageFrame = EMSpagesmapped = 0;
- __asm
- {
+ __asm {
mov ah,EMS_STATUS
int EMS_INT // make sure EMS hardware is present
or ah,ah
int EMS_INT // find the page frame address
or ah,ah
jnz error
- mov [EMSpageframe],bx
+ mov [EMSPageFrame],bx
mov ah,EMS_GETPAGES
int EMS_INT // find out how much EMS is there
jle getpages
mov bx,[freeEMSpages]
jmp getpages
-
-low:
+#ifdef __BORLANDC__
+ }
+#endif
+ low:
+#ifdef __BORLANDC__
+ __asm {
+#endif
cmp bx,4
jle getpages // there is only 1,2,3,or 4 pages
mov bx,4 // we can't use more than 4 pages
-
-getpages:
+#ifdef __BORLANDC__
+ }
+#endif
+ getpages:
+#ifdef __BORLANDC__
+ __asm {
+#endif
mov [EMSpagesmapped],bx
mov ah,EMS_ALLOCPAGES // allocate up to 64k of EMS
int EMS_INT
or ah,ah
jnz error
- mov [EMShandle],dx
+ mov [EMSHandle],dx
jmp End
-error:
+#ifdef __BORLANDC__
+ }
+#endif
+ error:
+#ifdef __BORLANDC__
+ __asm {
+#endif
mov err,ah
mov errorflag,1
jmp End
+#ifdef __BORLANDC__
+ }
+#endif
noEMS:
End:
+#ifdef __WATCOMC__
}
+#endif
if(errorflag==true)
{
- //err = CPURegs.h.ah;
strcpy(str,"MM_SetupEMS: EMS error ");
- //itoa(err,str2,16);
- MM_EMSerr(&str, err);
+ MM_EMSerr(str, err);
printf("%s\n",str);
return err;
}
- mm->totalEMSpages=totalEMSpages;
- mm->freeEMSpages=freeEMSpages;
- mm->EMSpageframe=EMSpageframe;
- mm->EMSpagesmapped=EMSpagesmapped;
- mm->EMShandle=EMShandle;
- mm->EMSVer=EMSVer;
+ gvar->mm.totalEMSpages=totalEMSpages;
+ gvar->mm.freeEMSpages=freeEMSpages;
+ gvar->mm.EMSPageFrame=EMSPageFrame;
+ gvar->mm.EMSpagesmapped=EMSpagesmapped;
+ gvar->mm.EMSHandle=EMSHandle;
+ gvar->mm.EMSVer=EMSVer;
return 0;
}
=======================
*/
-void MML_ShutdownEMS(mminfo_t *mm)
+void MML_ShutdownEMS(global_game_variables_t *gvar)
{
boolean errorflag=false;
- unsigned EMShandle=mm->EMShandle;
+ unsigned EMSHandle=gvar->mm.EMSHandle;
- if(!EMShandle)
+ if(!EMSHandle)
return;
- __asm
- {
+ __asm {
mov ah,EMS_FREEPAGES
- mov dx,[EMShandle]
+ mov dx,[EMSHandle]
int EMS_INT
or ah,ah
jz ok
mov errorflag,1
+#ifdef __BORLANDC__
+ }
+#endif
ok:
+#ifdef __WATCOMC__
}
- if(errorflag==true) printf("MML_ShutdownEMS: Error freeing EMS!\n"); //++++ add something
+#endif
+ if(errorflag==true)
+ Quit (gvar, "MML_ShutdownEMS: Error freeing EMS!\n"); //++++ add something
}
/*
====================
*/
-byte MM_MapEMS(mminfo_t *mm, mminfotype *mmi)
+byte MM_MapEMS(global_game_variables_t *gvar)
{
byte str[160];
- unsigned EMShandle;
+ unsigned EMSHandle;
byte err;
boolean errorflag=false;
int i;
- EMShandle=mm->EMShandle;
+ EMSHandle=gvar->mm.EMSHandle;
for (i=0;i<4/*MAPPAGES*/;i++)
{
- __asm
- {
+ __asm {
mov ah,EMS_MAPPAGE
mov bx,[i] // logical page
mov al,bl // physical page
- mov dx,[EMShandle] // handle
+ mov dx,[EMSHandle] // handle
int EMS_INT
or ah,ah
jnz error
jmp End
+#ifdef __BORLANDC__
+ }
+#endif
error:
+#ifdef __BORLANDC__
+ __asm {
+#endif
mov err,ah
mov errorflag,1
+#ifdef __BORLANDC__
+ }
+#endif
End:
+#ifdef __WATCOMC__
}
+#endif
if(errorflag==true)
{
- //err = CPURegs.h.ah;
strcpy(str,"MM_MapEMS: EMS error ");
- //itoa(err,str2,16);
MM_EMSerr(str, err);
printf("%s\n",str);
- //printf("FACK! %x\n", err);
return err;
}
}
- mmi->EMSmem = (i)*0x4000lu;
+ gvar->mmi.EMSmem = (i)*0x4000lu;
return 0;
}
-byte MM_MapXEMS(mminfo_t *mm, mminfotype *mmi)
+byte MM_MapXEMS(global_game_variables_t *gvar)
{
//SUB EMS.MapXPages (PhysicalStart, LogicalStart, NumPages, Handle)
//END SUB
byte str[160];
byte err;
- word EMShandle;
+ word EMSHandle;
boolean errorflag=false;
int i;
- EMShandle=mm->EMShandle;
+ EMSHandle=gvar->mm.EMSHandle;
- if(mm->EMSVer<0x40)
+ if(gvar->mm.EMSVer<0x40)
return 5;
for (i=0;i<MAPPAGES;i++)
{
- __asm
- {
+ __asm {
mov ah,EMS_MAPXPAGE
mov cx,[i] // logical page
mov al,bl // physical page
- mov dx,[EMShandle] // handle
+ mov dx,[EMSHandle] // handle
int EMS_INT
or ah,ah
jnz error
jmp End
+#ifdef __BORLANDC__
+ }
+#endif
error:
+#ifdef __BORLANDC__
+ __asm {
+#endif
mov err,ah
mov errorflag,1
+#ifdef __BORLANDC__
+ }
+#endif
End:
+#ifdef __WATCOMC__
}
+#endif
if(errorflag==true)
{
- //err = CPURegs.h.ah;
//strcpy(str,"MM_MapXEMS: EMS error 0x");
strcpy(str,"MM_MapXEMS: EMS error ");
//itoa(err,str2,16);
- MM_EMSerr(&str, err);
+ MM_EMSerr(str, err);
printf("%s\n",str);
//printf("%s%x\n",str, err);
//printf("FACK! %x\n", err);
return err;
}
}
- mmi->EMSmem = (i)*0x4000lu;
+ gvar->mmi.EMSmem = (i)*0x4000lu;
return 0;
}
-
+#endif
//==========================================================================
/*
=======================
*/
-boolean MML_CheckForXMS(mminfo_t *mm)
+boolean MML_CheckForXMS(void)
{
+ //numUMBs = 0;
boolean errorflag=false;
- mm->numUMBs = 0;
- __asm
- {
+ __asm {
mov ax,0x4300
int 0x2f // query status of installed diver
cmp al,0x80
je good
mov errorflag,1
+#ifdef __BORLANDC__
+ }
+#endif
good:
+#ifdef __WATCOMC__
}
+#endif
if(errorflag==true) return false;
else return true;
}
-
+#ifndef __16_PM__
/*
======================
=
=======================
*/
-void MML_SetupXMS(mminfo_t *mm, mminfotype *mmi)
+void MML_SetupXMS(global_game_variables_t *gvar)
{
- unsigned base,size;
+ word base,size;
-getmemory:
- __asm
- {
+
+ __asm {
mov ax,0x4310
int 0x2f
mov [WORD PTR XMSaddr],bx
mov [WORD PTR XMSaddr+2],es // function pointer to XMS driver
-
+ }
+getmemory:
+ __asm {
mov ah,XMS_ALLOCUMB
mov dx,0xffff // try for largest block possible
//mov ax,dx // Set available Kbytes.
call [DWORD PTR XMSaddr] // DX holds largest available UMB
or ax,ax
jz done // another error...
-
-gotone:
+#ifdef __BORLANDC__
+ }
+#endif
+ gotone:
+#ifdef __BORLANDC__
+ __asm {
+#endif
mov [base],bx
mov [size],dx
-done:
+#ifdef __BORLANDC__
}
- printf("base=%u ", base); printf("size=%u\n", size);
- MML_UseSpace(base,size, mm);
- mmi->XMSmem += size*16;
- mm->UMBbase[mm->numUMBs] = base;
- mm->numUMBs++;
- if(mm->numUMBs < MAXUMBS)
+#endif
+ done:
+#ifdef __WATCOMC__
+ }
+#endif
+// printf("base=%u ", base); printf("size=%u\n", size);
+ MML_UseSpace(base,size, gvar);
+ gvar->mmi.XMSmem += size*16;
+ gvar->mm.UMBbase[gvar->mm.numUMBs] = base;
+ gvar->mm.numUMBs++;
+ if(gvar->mm.numUMBs < MAXUMBS)
goto getmemory;
}
======================
*/
-void MML_ShutdownXMS(mminfo_t *mm)
+void MML_ShutdownXMS(global_game_variables_t *gvar)
{
int i;
unsigned base;
- for (i=0;i<mm->numUMBs;i++)
+ for (i=0;i<gvar->mm.numUMBs;i++)
{
- base = mm->UMBbase[i];
- __asm
- {
+ base = gvar->mm.UMBbase[i];
+ __asm {
mov ah,XMS_FREEUMB
mov dx,[base]
call [DWORD PTR XMSaddr]
}
}
}
-
+#endif
//==========================================================================
/*
======================
*/
-void MML_UseSpace(/*d*/word segstart, dword seglength, mminfo_t *mm)
+/*
+ extra = oldend - (segstart+seglength);
+
+ segmlen=extra;
+
+ //++++emsver stuff!
+ if(segm>1)/// || extra>=0x10000lu)
+ //if(extra>0xfffflu)
+ {
+ scan->blob=segm;
+
+ //MML_UseSpace(segstart, seglength, gvar);
+
+ printf("MML_UseSpace: Segment spans two blocks!\n");
+ //}
+ printf("segm=%u ", segm);
+ printf("ex=%lu ", extra);
+ printf("old=%u ", oldend);
+ printf("start+seglen=%lu\n", segstart+seglength);
+ printf("segsta=%x ", segstart);
+ printf("len=%lu ", scan->length);
+ printf("seglen=%lu ", seglength);
+ printf("segmlen=%lu\n", segmlen);
+ }
+//++++todo: linked list of segment!
+*/
+void MML_UseSpace(word segstart, dword seglength, global_game_variables_t *gvar)
{
- mmblocktype huge *scan,huge *last;
- word segm;
- dword oldend;
- dword extra;
+ mmblocktype far *scan,far *last;
+ word oldend;
+ sdword extra;
+ //word segm=1;
- scan = last = mm->mmhead;
- mm->mmrover = mm->mmhead; // reset rover to start of memory
+ scan = last = gvar->mm.mmhead;
+ gvar->mm.mmrover = gvar->mm.mmhead; // reset rover to start of memory
//
// search for the block that contains the range of segments
//
- while(scan->start+scan->length < segstart)
+ while (scan->start+scan->length < segstart)
{
last = scan;
scan = scan->next;
}
- //find out how many blocks it spans!
- if(seglength>0xffffu)
- {
-// segm=seglength/0x4000u;
- segm=seglength/0xffffu;
- }
- else segm=1;
-
- //++++emsver stuff!
- if(segm>1/*extra>0xfffflu*/)
+//
+// find out how many blocks it spans!
+//
+ /*for(;seglength>=0x10000;seglength-=0xFFFF)
{
- /*__asm
- {
- push ds
- mov ax,ds
- inc ax
- mov ds,ax
- }*/
-
-
-//MML_UseSpace(?segstart?, ?length?, mm);
-
- /*__asm
- {
- pop ds
- }*/
- //printf("MML_UseSpace: Segment spans two blocks!\n");
- }
+ //printf(" seglen=%lu\n", segmlen);
+ segm++;
+ }*/
//
// take the given range out of the block
//
oldend = scan->start + scan->length;
- extra = oldend - (segstart+seglength);
-/*
-printf("segm=%u ", segm);
-printf("ex=%lu ", extra);
-printf("start+seglen=%lu ", segstart+seglength);
-printf("len=%u ", scan->length);
-printf("segsta=%x ", segstart);
-printf("seglen=%lu\n", seglength);
-*/
-//segu:
-//++++todo: linked list of segment!
-//printf("segm=%lu\n", segm);
- if(segstart == scan->start)
+ extra = oldend - (segstart+((unsigned)seglength));
+ if (extra < 0)
+ {
+ printf("========================================\n");
+ printf("start=%x ", scan->start);
+ printf("old=%u ", oldend);
+ printf("start+seglen=%lu\n", segstart+seglength);
+ printf("segsta=%x ", segstart);
+ printf("len=%lu ", scan->length);
+ printf("seglen=%lu ", seglength);
+ printf("\n");
+ printf("MML_UseSpace: Segment spans two blocks! %d\n", extra);
+ printf("========================================\n");
+ //return;
+ }
+
+ if (segstart == scan->start)
{
last->next = scan->next; // unlink block
- MM_FreeBlock(scan, mm);
+ FREEBLOCK(scan);
scan = last;
}
else
scan->length = segstart-scan->start; // shorten block
-// segm--;
-
- if(extra > 0)
+ if (extra > 0)
{
- MM_GetNewBlock(mm);
- mm->mmnew->next = scan->next;
- scan->next = mm->mmnew;
- mm->mmnew->start = segstart+seglength;
- mm->mmnew->length = extra;
- mm->mmnew->attributes = LOCKBIT;
+ GETNEWBLOCK;
+ gvar->mm.mmnew->useptr = NULL;
+
+ gvar->mm.mmnew->next = scan->next;
+ scan->next = gvar->mm.mmnew;
+ gvar->mm.mmnew->start = segstart+seglength;
+ gvar->mm.mmnew->length = extra;
+ gvar->mm.mmnew->attributes = LOCKBIT;
}//else if(segm>0) goto segu;
}
====================
*/
-void MML_ClearBlock(mminfo_t *mm)
+void MML_ClearBlock(global_game_variables_t *gvar)
{
- mmblocktype huge *scan,huge *last;
+ mmblocktype far *scan;//,far *last;
- scan = mm->mmhead->next;
+ scan = gvar->mm.mmhead->next;
while(scan)
{
if(!(scan->attributes&LOCKBIT) && (scan->attributes&PURGEBITS))
{
- MM_FreePtr(scan->useptr, mm);
+ MM_FreePtr(scan->useptr, gvar);
return;
}
scan = scan->next;
===================
*/
-void MM_Startup(mminfo_t *mm, mminfotype *mmi)
+void MM_Startup(global_game_variables_t *gvar)
{
int i;
- dword length,seglength;
- //dword length; word seglength;
- void huge *start;
+ //dword length,seglength;
+ dword length; word seglength;
+ void far *start;
word segstart;//,endfree;
- if(mm->mmstarted)
- MM_Shutdown(mm);
+ if(gvar->mm.mmstarted)
+ MM_Shutdown(gvar);
- mm->mmstarted = true;
- mm->bombonerror = true;
+ gvar->mm.mmstarted = true;
+ gvar->mm.bombonerror = true;
//
// set up the linked list (everything in the free list;
//
- //printf(" linked list making!\n");
- mm->mmhead = NULL;
- mm->mmfree = &(mm->mmblocks[0]);
+ gvar->mm.mmhead = NULL;
+ gvar->mm.mmfree = &(gvar->mm.mmblocks[0]);
for(i=0;i<MAXBLOCKS-1;i++)
- {
- mm->mmblocks[i].next = &(mm->mmblocks[i+1]);
- }
- mm->mmblocks[i].next = NULL;
+ gvar->mm.mmblocks[i].next = &(gvar->mm.mmblocks[i+1]);
+ gvar->mm.mmblocks[i].next = NULL;
//
// locked block of all memory until we punch out free space
//
- //printf(" newblock making!\n");
- MM_GetNewBlock(mm);
- mm->mmhead = mm->mmnew; // this will allways be the first node
- mm->mmnew->start = 0;
- mm->mmnew->length = 0xffff;
- mm->mmnew->attributes = LOCKBIT;
- mm->mmnew->next = NULL;
- mm->mmrover = mm->mmhead;
+ GETNEWBLOCK;
+ gvar->mm.mmhead = gvar->mm.mmnew; // this will allways be the first node
+ gvar->mm.mmnew->start = 0;
+ gvar->mm.mmnew->length = 0xffff;
+ gvar->mm.mmnew->attributes = LOCKBIT;
+ gvar->mm.mmnew->next = NULL;
+ gvar->mm.mmrover = gvar->mm.mmhead;
//
// get all available near conventional memory segments
//
-//---- length=coreleft();
- printf(" nearheap making!\n");
- _heapgrow();
- length=_memmax();//(dword)GetFreeSize();
- start = (void huge *)(mm->nearheap = malloc(length));
+#ifdef __WATCOMC__
+ _nheapgrow();
+#endif
+ length=(word)_memavl();//(word)coreleft();
+ //start = gvar->mm.nearheap = _fmalloc(length);
+#ifdef __WATCOMC__
+ start = (void __far *)(gvar->mm.nearheap = _nmalloc(length));
+#endif
+#ifdef __BORLANDC__
+ start = (void far *)(gvar->mm.nearheap = malloc(length));
+#endif
+
length -= 16-(FP_OFF(start)&15);
length -= SAVENEARHEAP;
seglength = length / 16; // now in paragraphs
segstart = FP_SEG(start)+(FP_OFF(start)+15)/16;
- MML_UseSpace(segstart,seglength, mm);
- mmi->nearheap = length;
- printf("start=%FP segstart=%X seglen=%lu len=%lu\n", start, segstart, seglength, length);
- printf(" near heap ok!\n");
+ MML_UseSpace(segstart,seglength, gvar);
+ gvar->mmi.nearheap = length;
+ //0000printf("near: start=%Fp segstart=%x seglen=%lu len=%lu\n", start, segstart, (dword)seglength, length);
//
// get all available far conventional memory segments
//
-//---- length=farcoreleft();
- printf(" farheap making!\n");
+#ifdef __WATCOMC__
_fheapgrow();
- length=(dword)GetFarFreeSize();//0xffffUL*4UL;
- //start = mm->farheap = halloc(length, 1);
- start = mm->farheap = _fmalloc(length);
+#endif
+#ifdef __BORLANDC__
+// printf("farcoreleft() %lu\n", farcoreleft());
+// printf("(farcoreleft()+32)-_FCORELEFT %d\n", (sword)((farcoreleft()+32)-_FCORELEFT));
+#endif
+ length=_FCORELEFT;
+ start = gvar->mm.farheap = _fmalloc(length);//start = gvar->mm.farheap = halloc(length, 1);
+
length -= 16-(FP_OFF(start)&15);
length -= SAVEFARHEAP;
seglength = length / 16; // now in paragraphs
segstart = FP_SEG(start)+(FP_OFF(start)+15)/16;
- MML_UseSpace(segstart,seglength, mm);
- mmi->farheap = length;
- printf("start=%FP segstart=%X seglen=%lu len=%lu\n", start, segstart, seglength, length);
- printf(" far heap ok!\n");
+ MML_UseSpace(segstart,seglength, gvar);
+ gvar->mmi.farheap = length;
+ //0000printf("far: start=%Fp segstart=%x seglen=%lu len=%lu\n", start, segstart, (dword)seglength, length);
- mmi->mainmem = mmi->nearheap + mmi->farheap;
-
- getch();
+ gvar->mmi.mainmem = gvar->mmi.nearheap + gvar->mmi.farheap;
+#if !defined(__16_PM__)// && defined(__WATCOMC__)
+ if(!dbg_debugpm) {
//
// detect EMS and allocate up to 64K at page frame
//
-printf(" EMS1\n");
-printf("\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"); //bug!
- mmi->EMSmem = 0;
- for(i = 1;i < __argc;i++)
+ gvar->mmi.EMSmem = 0;
+//goto emsskip; //0000
+ for(i = 1;i < _argc;i++)
{
- if(US_CheckParm(__argv[i],ParmStringsexmm) == 0)
+ if(US_CheckParm(_argv[i],ParmStringsexmm) == 0)
goto emsskip; // param NOEMS
}
-printf("\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"); //bug!
if(MML_CheckForEMS())
{
-printf(" EMS2\n");
-printf("\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"); //bug!
- MML_SetupEMS(mm); // allocate space
-printf(" EMS3\n");
-printf("\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"); //bug!
- //TODO: EMS4! AND EMS 3.2 MASSIVE DATA HANDLMENT!
- MML_UseSpace(mm->EMSpageframe,(MAPPAGES)*0x4000lu, mm);
-printf("\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"); //bug!
-printf(" EMS4\n");
- //if(mm->EMSVer<0x40)
- MM_MapEMS(mm, mmi); // map in used pages
+ MML_SetupEMS(gvar); // allocate space
+ //16_PM: EMS4! AND EMS 3.2 MASSIVE DATA HANDLMENT!
+ MML_UseSpace(gvar->mm.EMSPageFrame,(MAPPAGES)*0x4000lu, gvar);
+ //if(gvar->pm.emm.EMSVer<0x40)
+ MM_MapEMS(gvar); // map in used pages
//else
- //MM_MapXEMS(mm, mmi); // map in used pages
+ //MM_MapXEMS(gvar); // map in used pages
}
//
// detect XMS and get upper memory blocks
//
emsskip:
- mmi->XMSmem = 0;
- for(i = 1;i < __argc;i++)
+ gvar->mmi.XMSmem = 0;
+goto xmsskip;//0000
+ for(i = 1;i < _argc;i++)
{
- if(US_CheckParm(__argv[i],ParmStringsexmm) == 0)
+ if(US_CheckParm( _argv[i],ParmStringsexmm) == 0)
goto xmsskip; // param NOXMS
}
-printf("\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"); //bug!
- if(MML_CheckForXMS(mm))
+ if(MML_CheckForXMS())
{
-printf("\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"); //bug!
-printf(" XMS!\n");
- MML_SetupXMS(mm, mmi); // allocate as many UMBs as possible
+ MML_SetupXMS(gvar); // allocate as many UMBs as possible
}
+ }
+xmsskip:
+#endif
//
// allocate the misc buffer
//
-xmsskip:
- mm->mmrover = mm->mmhead; // start looking for space after low block
+ gvar->mm.mmrover = gvar->mm.mmhead; // start looking for space after low block
- MM_GetPtr(&(mm->bufferseg),BUFFERSIZE, mm, mmi);
+ MM_GetPtr(&(gvar->mm.bufferseg),BUFFERSIZE, gvar);
}
//==========================================================================
====================
*/
-void MM_Shutdown(mminfo_t *mm)
+void MM_Shutdown(global_game_variables_t *gvar)
{
- if(!(mm->mmstarted))
+ if(!(gvar->mm.mmstarted))
return;
- _ffree(mm->farheap); printf(" far freed\n");
- free(mm->nearheap); printf(" near freed\n");
- if(MML_CheckForEMS()){ MML_ShutdownEMS(mm); printf(" EMS freed\n"); }
- if(MML_CheckForXMS(mm)){ MML_ShutdownXMS(mm); printf(" XMS freed\n"); }
+ _ffree(gvar->mm.farheap);// printf(" far freed\n");
+#ifdef __WATCOMC__
+ _nfree(gvar->mm.nearheap);// printf(" near freed\n");
+#endif
+#ifdef __BORLANDC__
+ free(gvar->mm.nearheap);// printf(" near freed\n");
+#endif
+#ifndef __16_PM__
+#ifdef __DEBUG__
+ if(!dbg_debugpm) {
+#endif
+ if(MML_CheckForEMS()){ MML_ShutdownEMS(gvar); }//printf(" EMS freed\n"); }
+ if(MML_CheckForXMS()){ MML_ShutdownXMS(gvar); }//printf(" XMS freed\n"); }
+#ifdef __DEBUG__
+ }
+#endif
+#endif
}
//==========================================================================
====================
*/
-void MM_GetPtr(memptr *baseptr,dword size, mminfo_t *mm, mminfotype *mmi)
+void MM_GetPtr (memptr *baseptr, dword size, global_game_variables_t *gvar)
{
- mmblocktype huge *scan,huge *lastscan,huge *endscan,huge *purge,huge *next;
+ mmblocktype far *scan,far *lastscan,far *endscan,far *purge,far *next;
int search;
unsigned needed,startseg;
needed = (size+15)/16; // convert size from bytes to paragraphs
- MM_GetNewBlock(mm); // fill in start and next after a spot is found
- mm->mmnew->length = needed;
- mm->mmnew->useptr = baseptr;
- mm->mmnew->attributes = BASEATTRIBUTES;
+ GETNEWBLOCK; // fill in start and next after a spot is found
+ gvar->mm.mmnew->length = needed;
+ gvar->mm.mmnew->useptr = baseptr;
+ //if(gvar->mm.mmnew->useptr==NULL){
+#ifdef __DEBUG_MM__
+ if(dbg_debugmm>0){
+ printf("MM_GetPtr\n");
+ //%04x
+ printf(" baseptr=%Fp ", baseptr); printf("useptr=%Fp\n", gvar->mm.mmnew->useptr);
+ printf(" *baseptr=%Fp ", *baseptr); printf("*useptr=%Fp\n", *(gvar->mm.mmnew->useptr));
+ printf(" &baseptr=%Fp ", &baseptr); printf("&useptr=%Fp\n", &(gvar->mm.mmnew->useptr));
+ }
+#endif
+ //Quit(gvar, "gvar->mm.mmnew->useptr==NULL"); }
+ gvar->mm.mmnew->attributes = BASEATTRIBUTES;
- for(search = 0; search<3; search++)
+//tryagain:
+ for (search = 0; search<3; search++)
{
//
// first search: try to allocate right after the rover, then on up
// second search: search from the head pointer up to the rover
// third search: compress memory, then scan from start
- if(search == 1 && mm->mmrover == mm->mmhead)
+ if (search == 1 && gvar->mm.mmrover == gvar->mm.mmhead)
search++;
- switch(search)
+ switch (search)
{
case 0:
- lastscan = mm->mmrover;
- scan = mm->mmrover->next;
+ lastscan = gvar->mm.mmrover;
+ scan = gvar->mm.mmrover->next;
endscan = NULL;
break;
case 1:
- lastscan = mm->mmhead;
- scan = mm->mmhead->next;
- endscan = mm->mmrover;
+ lastscan = gvar->mm.mmhead;
+ scan = gvar->mm.mmhead->next;
+ endscan = gvar->mm.mmrover;
break;
case 2:
- MM_SortMem(mm);
- lastscan = mm->mmhead;
- scan = mm->mmhead->next;
+ MM_SortMem (gvar);
+ lastscan = gvar->mm.mmhead;
+ scan = gvar->mm.mmhead->next;
endscan = NULL;
break;
}
startseg = lastscan->start + lastscan->length;
- while(scan != endscan)
+ while (scan != endscan)
{
- if(scan->start - startseg >= needed)
+ if (scan->start - startseg >= needed)
{
//
// got enough space between the end of lastscan and
// and allocate the new block
//
purge = lastscan->next;
- lastscan->next = mm->mmnew;
- mm->mmnew->start = *(unsigned *)baseptr = startseg;
- mm->mmnew->next = scan;
- while(purge != scan)
+ lastscan->next = gvar->mm.mmnew;
+ gvar->mm.mmnew->start = *(unsigned *)baseptr = startseg;
+ gvar->mm.mmnew->next = scan;
+ while ( purge != scan)
{ // free the purgable block
next = purge->next;
- MM_FreeBlock(purge, mm);
+ FREEBLOCK(purge);
purge = next; // purge another if not at scan
}
- mm->mmrover = mm->mmnew;
+ gvar->mm.mmrover = gvar->mm.mmnew;
return; // good allocation!
}
//
// if this block is purge level zero or locked, skip past it
//
- if((scan->attributes & LOCKBIT)
+ if ( (scan->attributes & LOCKBIT)
|| !(scan->attributes & PURGEBITS) )
{
lastscan = scan;
}
}
- if (mm->bombonerror)
+ if (gvar->mm.bombonerror)
{
- printf(OUT_OF_MEM_MSG,(size-mmi->nearheap));
- exit(-5);
+#ifdef __WATCOMC__
+ //heapdump();
+#endif
+ printf(OUT_OF_MEM_MSG,(size-gvar->mmi.nearheap));
+ Quit(gvar, "for stability reasons the program will shut down! wwww\n");
}
else
- mm->mmerror = true;
+ gvar->mm.mmerror = true;
}
//==========================================================================
====================
*/
-void MM_FreePtr(memptr *baseptr, mminfo_t *mm)
+void MM_FreePtr(memptr *baseptr, global_game_variables_t *gvar)
{
- mmblocktype huge *scan,huge *last;
+ mmblocktype far *scan,far *last;
- last = mm->mmhead;
+ last = gvar->mm.mmhead;
scan = last->next;
- if(baseptr == mm->mmrover->useptr) // removed the last allocated block
- mm->mmrover = mm->mmhead;
+ if(baseptr == gvar->mm.mmrover->useptr) // removed the last allocated block
+ gvar->mm.mmrover = gvar->mm.mmhead;
while(scan->useptr != baseptr && scan)
{
if(!scan)
{
- printf("MM_FreePtr: Block not found!\n");
- return;
+ Quit(gvar, "MM_FreePtr: Block not found!\n");
+ //printf("MM_FreePtr: Block not found!\n"); return;
}
last->next = scan->next;
- MM_FreeBlock(scan, mm);
+ FREEBLOCK(scan);
}
//==========================================================================
=====================
*/
-void MM_SetPurge(memptr *baseptr, int purge, mminfo_t *mm)
+
+void MM_SetPurge(memptr *baseptr, int purge, global_game_variables_t *gvar)
{
- mmblocktype huge *start;
+ mmblocktype far *start;
- start = mm->mmrover;
+ start = gvar->mm.mmrover;
do
{
- if(mm->mmrover->useptr == baseptr)
+ if(gvar->mm.mmrover->useptr == baseptr)
break;
- mm->mmrover = mm->mmrover->next;
+ gvar->mm.mmrover = gvar->mm.mmrover->next;
- if(!mm->mmrover)
- mm->mmrover = mm->mmhead;
- else if(mm->mmrover == start)
+ if(!gvar->mm.mmrover)
+ gvar->mm.mmrover = gvar->mm.mmhead;
+ else if(gvar->mm.mmrover == start)
{
- printf("MM_SetPurge: Block not found!");
- return;
+ Quit (gvar, "MM_SetPurge: Block not found!");
+ //return;
}
} while(1);
- mm->mmrover->attributes &= ~PURGEBITS;
- mm->mmrover->attributes |= purge;
+ gvar->mm.mmrover->attributes &= ~PURGEBITS;
+ gvar->mm.mmrover->attributes |= purge;
}
//==========================================================================
=====================
*/
-void MM_SetLock(memptr *baseptr, boolean locked, mminfo_t *mm)
+void MM_SetLock(memptr *baseptr, boolean locked, global_game_variables_t *gvar)
{
- mmblocktype huge *start;
+ mmblocktype far *start;
- start = mm->mmrover;
+ start = gvar->mm.mmrover;
do
{
- if(mm->mmrover->useptr == baseptr)
+ if(gvar->mm.mmrover->useptr == baseptr)
break;
- mm->mmrover = mm->mmrover->next;
+ gvar->mm.mmrover = gvar->mm.mmrover->next;
- if(!mm->mmrover)
- mm->mmrover = mm->mmhead;
- else if(mm->mmrover == start)
+ if(!gvar->mm.mmrover)
+ gvar->mm.mmrover = gvar->mm.mmhead;
+ else if(gvar->mm.mmrover == start)
{
- printf("MM_SetLock: Block not found!");
- return;
+ Quit (gvar, "MM_SetLock: Block not found!");
+ //return;
}
} while(1);
- mm->mmrover->attributes &= ~LOCKBIT;
- mm->mmrover->attributes |= locked*LOCKBIT;
+ gvar->mm.mmrover->attributes &= ~LOCKBIT;
+ gvar->mm.mmrover->attributes |= locked*LOCKBIT;
}
//==========================================================================
=====================
*/
-void MM_SortMem(mminfo_t *mm)
+void MM_SortMem(global_game_variables_t *gvar)
{
- mmblocktype huge *scan,huge *last,huge *next;
- unsigned start,length,source,dest,oldborder;
- int playing;
+ mmblocktype far *scan,far *last,far *next;
+ unsigned start,length,source,dest;//++++,oldborder;
+ //++++int playing;
//
// lock down a currently playing sound
if(beforesort)
beforesort();
- scan = mm->mmhead;
+ scan = gvar->mm.mmhead;
last = NULL; // shut up compiler warning
// throw out the purgable block
//
next = scan->next;
- MM_FreeBlock(scan, mm);
+ FREEBLOCK(scan);
+ //MM_FreeBlock(scan, gvar);
last->next = next;
scan = next;
continue;
scan = scan->next; // go to next block
}
- mm->mmrover = mm->mmhead;
+ gvar->mm.mmrover = gvar->mm.mmhead;
if(aftersort)
aftersort();
MM_SetLock(&(memptr)audiosegs[playing],false);*/
}
-
//==========================================================================
-//****#if 0
/*
=====================
=
=====================
*/
-void MM_ShowMemory(/*page_t *page, */mminfo_t *mm)
+void MM_ShowMemory(global_game_variables_t *gvar)
{
- mmblocktype huge *scan;
- word color,temp;
- long end,owner;
- word chx,chy;
- byte scratch[160],str[16];
-
-//**** VW_SetDefaultColors();
-//**** VW_SetLineWidth(40);
+ mmblocktype far *scan;
+ //word temp;
+ sdword end,owner;
+ //word chx,chy;
+ word w;
+ //dword wwww;
+ byte scratch[160],scratch0[4096],str[16];//[[[[scratch1[160],
+ //byte d = '#';
+//[[[[ VW_SetDefaultColors();
+//[[[[ VW_SetLineWidth(40);
//++++mh temp = bufferofs;
//++++mh bufferofs = 0;
-//**** VW_SetScreen (0,0);
-
- scan = mm->mmhead;
-
+//[[[[ VW_SetScreen (0,0);
+ scan = gvar->mm.mmhead;
end = -1;
-CA_OpenDebug ();
-
- chx=0;
- chy=0;
-
+ CA_OpenDebug (gvar);
+ w=0;
while(scan)
{
+ strcpy(scratch, AARESET);
if(scan->attributes & PURGEBITS)
- color = 5; // dark purple = purgable
+ strcpy(scratch0, AAMAGENTA); // dark purple = purgable
else
- color = 9; // medium blue = non purgable
+ strcpy(scratch0, AABLUE); // medium blue = non purgable
if(scan->attributes & LOCKBIT)
- color = 12; // red = locked
+ strcpy(scratch0, AARED); // red = locked
if(scan->start<=end)
{
- //printf(");
- write(debughandle,"\nMM_ShowMemory: Memory block order currupted!\n",strlen("\nMM_ShowMemory: Memory block order currupted!\n"));
+ printf("\nend==%d\n\n", end);
+ strcat(scratch, "MM_ShowMemory: Memory block order currupted!\n");
+ strcat(scratch, "End's Size: ");
+ ultoa (end,str,10);
+ strcat (scratch,str);
+ strcat(scratch, "\nscan->start's Size: ");
+ ultoa (scan->start,str,10);
+ strcat (scratch,str);
+ write(gvar->handle.debughandle,scratch,strlen(scratch));
//modexprint(&page, chx, chy, 1, 0, 24, "\nMM_ShowMemory: Memory block order currupted!\n");
- return;
+ break;
}
- end = scan->start+scan->length-1;
- chy = scan->start/320;
- chx = scan->start%320;
+ end = scan->start+(scan->length)-1;
+//++++ chy = scan->start/320;
+//++++ chx = scan->start%320;
//modexhlin(page, scan->start, (unsigned)end, chy, color);
//for(chx=scan->start;chx+4>=(word)end;chx+=4)
//{
//++++ modexClearRegion(page, chx, chy, 4, 4, color);
//}
-
//++++ VW_Hlin(scan->start,(unsigned)end,0,color);
-
+ for(w=(scan->start)/80;w<=end/80;w++)
+ {
+ //printf("+ %u %lu\n", w, scan->length);
+ strcat(scratch0, "+");
+ }
+ //++==++==optional strcat(scratch0, AARESET); strcat(scratch0, AAGREY); strcat(scratch0,"_");
//++++ VW_Plot(scan->start,0,15);
//++++ modexClearRegion(page, chx, chy, 4, 4, 15);
- if(scan->next->start > end+1)
//++++ VW_Hlin(end+1,scan->next->start,0,0); // black = free
+
+ //wwww=(dword)(scan->next->start)-(dword)scan->start;
+ //wwww=(dword)scan->start+(dword)(scan->next->start);
+ if (scan->next && scan->next->start >= end+1)
+ {
+ strcat(scratch0, AARESET);
+ //++==++==optional strcat(scratch0, "\n");
+ strcat(scratch0,AAGREEN);
+ for(w=(end+1)/80;w<=((scan->next->start-scan->start)/80);w++)
+ //for(w=(wwww)/80;w<=((end+1)/80);w++)
+ //for(w=(end+1)/80;w<=((wwww)/80);w++)
+ {
+ //printf("0 %x %u %lu\n", scan->next->start, w, scan->length);
+ strcat(scratch0,"0");
+ }
+ //printf("==================\n");
+ //printf("w=%u wwww=%lu start=%04x next=%04x end=%lu\n", w/80, wwww/80, scan->start, (scan->next->start), end+1);
+ //printf("==================\n");
+ strcat(scratch0, "\n");
+ //getch();
+ }/*else {//if(scan->next->start <= scan->start){
+ scan->next->start=scan->start+0x1000;
+ wwww=(dword)(scan->next->start)-(dword)scan->start;
+ strcat(scratch0, AARESET);
+ strcat(scratch0, "\n");
+ strcat(scratch0,AAGREEN);
+ for(w=(end+1);w<=(0x1000/80);w++)
+ {
+ //printf("0 %x %x %u\n", scan->start, w);
+ strcat(scratch0,"0");
+ }
+ printf("================\n");
+ printf("w=%x start=%x next=%x end=%u %lu\n", w, scan->start, (scan->next->start), end+1, wwww);
+ printf("================\n");
+ getch();
+ }*/
+ strcat(scratch0, AARESET);
+ //strcat(scratch0,"\n");
//for(chx=scan->next->start;chx+4>=(word)end+1;chx+=4)
//{
-//++++ chx+=scan->next->start;
-//++++ modexClearRegion(page, chx, chy, 4, 4, 2);
+// chx+=scan->next->start;
+// modexClearRegion(page, chx, chy, 4, 4, 2);
//}
//modexhlin(page, end+1,scan->next->start, chy, 0);
-
-/*
- end = scan->length-1;
- y = scan->start/320;
+/* y = scan->start/320;
x = scan->start%320;
VW_Hlin(x,x+end,y,color);
- VW_Plot(x,y,15);
- if (scan->next && scan->next->start > end+1)
- VW_Hlin(x+end+1,x+(scan->next->start-scan->start),y,0); // black = free
-*/
-
-//****#if 0
-printf("\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"); //bug!
-strcpy(scratch,"Seg:");
-ultoa (scan->start,str,16);
-strcat (scratch,str);
-strcat (scratch,"\tSize:");
-ultoa ((dword)scan->length,str,10);
-strcat (scratch,str);
-strcat (scratch,"\tOwner:0x");
-owner = (unsigned)scan->useptr;
-ultoa (owner,str,16);
-strcat (scratch,str);
-strcat (scratch,"\n");
-write(debughandle,scratch,strlen(scratch));
+ VW_Plot(x,y,15);*/
+//++++ VW_Hlin(x+end+1,x+(scan->next->start-scan->start),y,0); // black = free
+ strcat(scratch,"Seg:");
+ ultoa (scan->start,str,16);
+ strcat (scratch,str);
+ strcat (scratch,"\tSize:");
+ ultoa ((unsigned)scan->length,str,10);
+ strcat (scratch,str);
+ strcat (scratch,"\tOwner:0x");
+ owner = (unsigned)scan->useptr;
+ ultoa (owner,str,16);
+ strcat (scratch,str);
+ strcat (scratch,"\n");
+ write(gvar->handle.debughandle,scratch,strlen(scratch));
+ write(gvar->handle.debughandle,scratch0,strlen(scratch0));
//modexprint(page, chx, chy, 1, 0, 24, &scratch);
//++++chy+=4;
//fprintf(stdout, "%s", scratch);
-//****#endif
scan = scan->next;
}
-
-CA_CloseDebug ();
+ /*strcpy(scratch1, AARESET);
+ strcat(scratch1, "========================================\n");
+ strcat(scratch1, "near= ");
+ ultoa (*(gvar->mm.nearheap),str,10);
+ strcat (scratch1,str);
+ strcat(scratch1, " far= ");
+ ultoa (*(gvar->mm.farheap),str,10);
+ strcat (scratch1,str);
+ strcat(scratch1, "\n");
+ //strcat(scratch1, "&near= %Fp ", &(gvar->mm.nearheap));
+ //strcat(scratch1, "&far= %Fp", &(gvar->mm.farheap));
+ //strcat(scratch1, "\n");
+ strcat(scratch1, "========================================\n");
+ write(gvar->handle.debughandle,scratch1,strlen(scratch1));*/
+
+
+ CA_CloseDebug (gvar);
//++++mh IN_Ack();
//**** VW_SetLineWidth(64);
//++++mh bufferofs = temp;
}
-//****#endif
//==========================================================================
=====================
*/
-void MM_DumpData(mminfo_t *mm)
+void MM_DumpData(global_game_variables_t *gvar)
{
mmblocktype far *scan,far *best;
long lowest,oldlowest;
byte lock,purge;
FILE *dumpfile;
-
- //++++free(mm->nearheap);
- dumpfile = fopen ("mmdump.16","w");
+#ifdef __WATCOMC__
+ _nfree(gvar->mm.nearheap);
+#endif
+#ifdef __BORLANDC__
+ free(gvar->mm.nearheap);
+#endif
+#ifdef __BORLANDC__
+ dumpfile = fopen ("mmdump.16b","w");
+#endif
+#ifdef __WATCOMC__
+ dumpfile = fopen ("mmdump.16w","w");
+#endif
if (!dumpfile){
printf("MM_DumpData: Couldn't open MMDUMP.16!\n");
return;
oldlowest = lowest;
lowest = 0xffff;
- scan = mm->mmhead;
+ scan = gvar->mm.mmhead;
while (scan)
{
- owner = (word)scan->useptr;
+ owner = (unsigned)scan->useptr;
if (owner && owner<lowest && owner > oldlowest)
{
else
lock = '-';
fprintf (dumpfile,"0x%p (%c%c) = %u\n"
- ,(word)lowest,lock,purge,best->length);
+ ,(unsigned)lowest,lock,purge,best->length);
}
} while (lowest != 0xffff);
======================
*/
-dword MM_UnusedMemory(mminfo_t *mm)
+dword MM_UnusedMemory(global_game_variables_t *gvar)
{
dword free;
- mmblocktype huge *scan;
+ mmblocktype far *scan;
free = 0;
- scan = mm->mmhead;
+ scan = gvar->mm.mmhead;
while(scan->next)
{
scan = scan->next;
}
-// return free*16l;
- return free;
+ return free*16lu;
+// return free;
}
//==========================================================================
======================
*/
-dword MM_TotalFree(mminfo_t *mm)
+dword MM_TotalFree(global_game_variables_t *gvar)
{
dword free;
- mmblocktype huge *scan;
+ mmblocktype far *scan;
free = 0;
- scan = mm->mmhead;
+ scan = gvar->mm.mmhead;
while(scan->next)
{
scan = scan->next;
}
-// return free*16l;
- return free;
+ return free*16lu;
+// return free;
}
//==========================================================================
=====================
*/
-void MM_Report(/*page_t *page, */mminfo_t *mm, mminfotype *mmi)
+void MM_Report_(global_game_variables_t *gvar)
{
+ printf("========================================\n");
+ printf(" MM_Report_\n");
+ printf("========================================\n");
if(MML_CheckForEMS())
{
- printf("EMM v%x.%x available\n", mm->EMSVer>>4,mm->EMSVer&0x0F);
- printf("totalEMSpages=%u\n", mm->totalEMSpages);
- printf("freeEMSpages=%u\n", mm->freeEMSpages);
- printf("EMSpageframe=%x\n", mm->EMSpageframe);
+ printf(" %cLIMEMS %u\n", 0xC9, gvar->pm.emm.EMSPresent);
+ printf(" %c%cEMM v%x.%x available\n", 0xC7, 0xC4, gvar->pm.emm.EMSVer>>4,gvar->pm.emm.EMSVer&0x0F);
+ printf(" %c%ctotalEMSpages: %u ", 0xC7, 0xC4, gvar->pm.emm.totalEMSpages); printf("freeEMSpages: %u\n", gvar->pm.emm.freeEMSpages);
+ printf(" %c%cEMSPageFrame: %04x\n", 0xC7, 0xC4, gvar->pm.emm.EMSPageFrame);
+ printf(" %c%cEMSmem: %lu\n", 0xD3, 0xC4, gvar->mmi.EMSmem);
+ }
+ if(MML_CheckForXMS())
+ {
+ printf(" %cXMS %u\n", 0xC9, gvar->pm.xmm.XMSPresent);
+ printf(" %c%cXMS v%x.%x available\n", 0xC7, 0xC4, XMSVer>>8,XMSVer&0x0F);
+ printf(" %c%cXMSDriver: %Fp\n", 0xC7, 0xC4, XMSDriver);
+ printf(" %c%cXMSHandle: %04x\n", 0xC7, 0xC4, gvar->pm.xmm.XMSHandle);
+ printf(" %c%cXMSmem: %lu\n", 0xD3, 0xC4, gvar->mmi.XMSmem);
}
- if(MML_CheckForXMS(mm)) printf("XMSaddr=%X\n", *XMSaddr);
- printf("near=%lu\n", mmi->nearheap);
- printf("far=%lu\n", mmi->farheap);
- printf("EMSmem=%lu\n", mmi->EMSmem);
- printf("XMSmem=%lu\n", mmi->XMSmem);
- printf("mainmem=%lu\n", mmi->mainmem);
- printf("UnusedMemory=%lu\n", MM_UnusedMemory(mm));
- printf("TotalFree=%lu\n", MM_TotalFree(mm));
- //mmi->nearheap+mmi->farheap+
- printf("TotalUsed=%lu\n", mmi->mainmem+mmi->EMSmem+mmi->XMSmem);//+);
-// printf("\n");
-// printf("UnusedMemory=%lu kb\n", MM_UnusedMemory()/10248);
-// printf("TotalFree=%lu kb\n", MM_TotalFree()/10248);
+ printf(" %cConv. %u\n", 0xC9, gvar->pm.mm.MainPresent); DebugMemory_(gvar, 0);
+ //printf("mainmem: %lu\n", gvar->mmi.mainmem);
+ //printf("Total convmem: %lu ", gvar->mmi.mainmem); printf("TotalFree: %lu ", MM_TotalFree(gvar)+gvar->mmi.EMSmem+gvar->mmi.XMSmem+gvar->mmi.XMSmem); printf("TotalUsed: %lu\n", gvar->mmi.mainmem);
+ //printf(" UnusedMemory: %lu\n", MM_UnusedMemory(gvar));
+ printf("nearheap: %lu ", gvar->mmi.nearheap); printf("farheap: %lu\n", gvar->mmi.farheap);
}
//==========================================================================
=====================
*/
-void MM_BombOnError(boolean bomb, mminfo_t *mm)
+void MM_BombOnError(boolean bomb, global_game_variables_t *gvar)
{
- mm->bombonerror = bomb;
+ gvar->mm.bombonerror = bomb;
}
-void MM_GetNewBlock(mminfo_t *mm)
+/*void MM_GetNewBlock(global_game_variables_t *gvar)
{
- if(!mm->mmfree)
- MML_ClearBlock(mm);
- mm->mmnew=mm->mmfree;
- mm->mmfree=mm->mmfree->next;
- /*if(!(mm->mmnew=mm->mmfree))
+ if(!gvar->mm.mmfree)
+ MML_ClearBlock(gvar);
+ gvar->mm.mmnew=gvar->mm.mmfree;
+ gvar->mm.mmfree=gvar->mm.mmfree->next;
+ if(!(gvar->mm.mmnew=gvar->mm.mmfree))
{
- printf("MM_GETNEWBLOCK: No free blocks!");
+ printf("MM_GETNEWBLOCK: No free blocks!\n");
return;
}
- mm->mmfree=mm->mmfree->next;*/
+ gvar->mm.mmfree=gvar->mm.mmfree->next;
}
-void MM_FreeBlock(mmblocktype *x, mminfo_t *mm)
+void MM_FreeBlock(mmblocktype *x, global_game_variables_t *gvar)
{
x->useptr=NULL;
- x->next=mm->mmfree;
- mm->mmfree=x;
+ x->next=gvar->mm.mmfree;
+ gvar->mm.mmfree=x;
+}*/
+
+void xms_call(byte v, global_game_variables_t *gvar)
+{
+ dword XMSDriver = gvar->pm.xmm.XMSDriver;
+ __asm {
+ mov ah,[v]
+ call [DWORD PTR XMSDriver]
+ }
}
-void MM_seguin(void)
+/*void MM_seguin(void)
{
__asm {
push ds
__asm {
pop ds
}
-}
+}*/
/*
pull data from far and put it into ds var