- mm->mmblocks[i].next = &(mm->mmblocks[i+1]);
- }\r
- mm->mmblocks[i].next = NULL;\r
-\r
-//\r
-// locked block of all memory until we punch out free space\r
-//\r
- //GETNEWBLOCK;
- MM_GetNewBlock(mm);\r
- mm->mmhead = mm->mmnew; // this will allways be the first node\r
- mm->mmnew->start = 0;\r
- mm->mmnew->length = 0xffff;\r
- mm->mmnew->attributes = LOCKBIT;\r
- mm->mmnew->next = NULL;\r
- mm->mmrover = mm->mmhead;\r
-\r
-\r
-//\r
-// get all available near conventional memory segments\r
-//\r
-//---- length=coreleft();
- _nheapgrow();\r
- length=_memavl();\r
- start = (void far *)(mm->nearheap = malloc(length));\r
-\r
- length -= 16-(FP_OFF(start)&15);\r
- length -= SAVENEARHEAP;\r
- seglength = length / 16; // now in paragraphs\r
- segstart = FP_SEG(start)+(FP_OFF(start)+15)/16;\r
- MML_UseSpace(segstart,seglength, mm);\r
- mmi->nearheap = length;\r
-\r
-//\r
-// get all available far conventional memory segments\r
-//\r
-//---- length=farcoreleft();
- _fheapgrow();\r
- length=_memavl();\r
- start = mm->farheap = _fmalloc(length);\r
- length -= 16-(FP_OFF(start)&15);\r
- length -= SAVEFARHEAP;\r
- seglength = length / 16; // now in paragraphs\r
- segstart = FP_SEG(start)+(FP_OFF(start)+15)/16;\r
- MML_UseSpace(segstart,seglength, mm);\r
- mmi->farheap = length;\r
- mmi->mainmem = mmi->nearheap + mmi->farheap;\r
-\r
-\r
-//\r
-// detect EMS and allocate up to 64K at page frame\r
-//\r
- mmi->EMSmem = 0;\r
- for(i = 1;i < __argc;i++)\r
- {\r
- if(US_CheckParm(__argv[i],ParmStringsexmm) == 0)\r
- goto emsskip; // param NOEMS\r
- }\r
-\r
- if(MML_CheckForEMS())\r
- {\r
- printf("EMS1\n");\r
- MML_SetupEMS(mm); // allocate space\r
- printf("EMS2\n");
-printf("segstart=%x\n", segstart);
-printf("mm->EMSpageframe=%x\n", mm->EMSpageframe);
- MML_UseSpace(mm->EMSpageframe,mm->EMSpagesmapped*0x400, mm);\r
- printf("EMS3\n");\r
- MM_MapEMS(mm); // map in used pages\r
- printf("EMS4\n");\r
- mmi->EMSmem = mm->EMSpagesmapped*0x4000l;\r
- }\r
-\r
-//\r
-// detect XMS and get upper memory blocks\r
-//\r
-emsskip:\r
- mmi->XMSmem = 0;\r
- for(i = 1;i < __argc;i++)\r
- {\r
- if ( US_CheckParm(__argv[i],ParmStringsexmm) == 0)\r
- goto xmsskip; // param NOXMS\r
- }\r
-\r
- if(MML_CheckForXMS(mm))\r
- {\r
- printf("XMS!\n");\r
- MML_SetupXMS(mm, mmi); // allocate as many UMBs as possible\r
- }\r
-\r
-//\r
-// allocate the misc buffer\r
-//\r
-xmsskip:\r
- mm->mmrover = mm->mmhead; // start looking for space after low block\r
-\r
- MM_GetPtr(&(mm->bufferseg),BUFFERSIZE, mm, mmi);\r
-}\r
-\r
-//==========================================================================\r
-\r
-/*\r
-====================\r
-=\r
-= MM_Shutdown\r
-=\r
-= Frees all conventional, EMS, and XMS allocated\r
-=\r
-====================\r
-*/\r
-\r
-void MM_Shutdown(mminfo_t *mm)\r
-{\r
- if(!(mm->mmstarted))\r
- return;\r
-\r
- _ffree(mm->farheap);
- printf("far freed\n");\r
- free(mm->nearheap);
- printf("near freed\n");\r
- //hfree(mm->hugeheap);
- //printf("huge freed\n");\r
- MML_ShutdownEMS(mm);
- printf("EMS freed\n");\r
- MML_ShutdownXMS(mm);
- printf("XMS freed\n");\r
-}\r
-\r
-//==========================================================================\r
-\r
-/*\r
-====================\r
-=\r
-= MM_GetPtr\r
-=\r
-= Allocates an unlocked, unpurgable block\r
-=\r
-====================\r
-*/\r
-\r
-void MM_GetPtr(memptr *baseptr,dword size, mminfo_t *mm, mminfotype *mmi)\r
-{\r
- mmblocktype far *scan,far *lastscan,far *endscan\r
- ,far *purge,far *next;\r
- int search;\r
- unsigned needed,startseg;\r
-\r
- needed = (size+15)/16; // convert size from bytes to paragraphs\r
-\r
- MM_GetNewBlock(mm); // fill in start and next after a spot is found\r
- mm->mmnew->length = needed;\r
- mm->mmnew->useptr = baseptr;\r
- mm->mmnew->attributes = BASEATTRIBUTES;\r
-\r
- for(search = 0; search<3; search++)\r
- {\r
- //\r
- // first search: try to allocate right after the rover, then on up\r
- // second search: search from the head pointer up to the rover\r
- // third search: compress memory, then scan from start\r
- if(search == 1 && mm->mmrover == mm->mmhead)\r
- search++;\r
-\r
- switch(search)\r
- {\r
- case 0:\r
- lastscan = mm->mmrover;\r
- scan = mm->mmrover->next;\r
- endscan = NULL;\r
- break;\r
- case 1:\r
- lastscan = mm->mmhead;\r
- scan = mm->mmhead->next;\r
- endscan = mm->mmrover;\r
- break;\r
- case 2:\r
- MM_SortMem(mm);\r
- lastscan = mm->mmhead;\r
- scan = mm->mmhead->next;\r
- endscan = NULL;\r
- break;\r
- }\r
-\r
- startseg = lastscan->start + lastscan->length;\r
-\r
- while(scan != endscan)\r
- {\r
- if(scan->start - startseg >= needed)\r
- {\r
- //\r
- // got enough space between the end of lastscan and\r
- // the start of scan, so throw out anything in the middle\r
- // and allocate the new block\r
- //\r
- purge = lastscan->next;\r
- lastscan->next = mm->mmnew;\r
- mm->mmnew->start = *(unsigned *)baseptr = startseg;\r
- mm->mmnew->next = scan;\r
- while(purge != scan)\r
- { // free the purgable block\r
- next = purge->next;\r
- MM_FreeBlock(purge, mm);\r
- purge = next; // purge another if not at scan\r
- }\r
- mm->mmrover = mm->mmnew;\r
- return; // good allocation!\r
- }\r
-\r
- //\r
- // if this block is purge level zero or locked, skip past it\r
- //\r
- if((scan->attributes & LOCKBIT)\r
- || !(scan->attributes & PURGEBITS) )\r
- {\r
- lastscan = scan;\r
- startseg = lastscan->start + lastscan->length;\r
- }\r
-\r
-\r
- scan=scan->next; // look at next line\r
- }\r
- }\r
-\r
- if (mm->bombonerror)\r
- printf(OUT_OF_MEM_MSG,(size-mmi->nearheap));\r
- else\r
- mm->mmerror = true;\r
-}\r
-\r
-//==========================================================================\r
-\r
-/*\r
-====================\r
-=\r
-= MM_FreePtr\r
-=\r
-= Allocates an unlocked, unpurgable block\r
-=\r
-====================\r
-*/\r
-\r
-void MM_FreePtr(memptr *baseptr, mminfo_t *mm)\r
-{\r
- mmblocktype far *scan,far *last;\r
-\r
- last = mm->mmhead;\r
- scan = last->next;\r
-\r
- if(baseptr == mm->mmrover->useptr) // removed the last allocated block\r
- mm->mmrover = mm->mmhead;\r
-\r
- while(scan->useptr != baseptr && scan)\r
- {\r
- last = scan;\r
- scan = scan->next;\r
- }\r
-\r
- if(!scan)\r
- {\r
- printf("MM_FreePtr: Block not found!");\r
- return;\r
- }\r
-\r
- last->next = scan->next;\r
-\r
- MM_FreeBlock(scan, mm);\r
-}\r
-//==========================================================================\r
-\r
-/*\r
-=====================\r
-=\r
-= MM_SetPurge\r
-=\r
-= Sets the purge level for a block (locked blocks cannot be made purgable)\r
-=\r
-=====================\r
-*/\r
-\r
-void MM_SetPurge(memptr *baseptr, int purge, mminfo_t *mm)\r
-{\r
- mmblocktype far *start;\r
-\r
- start = mm->mmrover;\r
-\r
- do\r
- {\r
- if(mm->mmrover->useptr == baseptr)\r
- break;\r
-\r
- mm->mmrover = mm->mmrover->next;\r
-\r
- if(!mm->mmrover)\r
- mm->mmrover = mm->mmhead;\r
- else if(mm->mmrover == start)\r
- {\r
- printf("MM_SetPurge: Block not found!");\r
- return;\r
- }\r
-\r
- } while(1);\r
-\r
- mm->mmrover->attributes &= ~PURGEBITS;\r
- mm->mmrover->attributes |= purge;\r
-}\r
-\r
-//==========================================================================\r
-\r
-/*\r
-=====================\r
-=\r
-= MM_SetLock\r
-=\r
-= Locks / unlocks the block\r
-=\r
-=====================\r
-*/\r
-\r
-void MM_SetLock(memptr *baseptr, boolean locked, mminfo_t *mm)\r
-{\r
- mmblocktype far *start;\r
-\r
- start = mm->mmrover;\r
-\r
- do\r
- {\r
- if(mm->mmrover->useptr == baseptr)\r
- break;\r
-\r
- mm->mmrover = mm->mmrover->next;\r
-\r
- if(!mm->mmrover)\r
- mm->mmrover = mm->mmhead;\r
- else if(mm->mmrover == start)\r
- {\r
- printf("MM_SetLock: Block not found!");\r
- return;\r
- }\r
-\r
- } while(1);\r
-\r
- mm->mmrover->attributes &= ~LOCKBIT;\r
- mm->mmrover->attributes |= locked*LOCKBIT;\r
-}\r
-\r
-//==========================================================================\r
-\r
-/*\r
-=====================\r
-=\r
-= MM_SortMem\r
-=\r
-= Throws out all purgable stuff and compresses movable blocks\r
-=\r
-=====================\r
-*/\r
-\r
-void MM_SortMem(mminfo_t *mm)\r
-{\r
- mmblocktype far *scan,far *last,far *next;\r
- unsigned start,length,source,dest,oldborder;\r
- int playing;\r
-\r
- //\r
- // lock down a currently playing sound\r
- //\r
-/*++++ playing = SD_SoundPlaying ();\r
- if (playing)\r
- {\r
- switch (SoundMode)\r
- {\r
- case sdm_PC:\r
- playing += STARTPCSOUNDS;\r
- break;\r
- case sdm_AdLib:\r
- playing += STARTADLIBSOUNDS;\r
- break;\r
- }\r
- MM_SetLock(&(memptr)audiosegs[playing],true);\r
- }\r
-\r
-\r
- SD_StopSound();*/\r
-// oldborder = bordercolor;\r
-// VW_ColorBorder (15);\r
-\r
- if(beforesort)\r
- beforesort();\r
-\r
- scan = mm->mmhead;\r
-\r
- last = NULL; // shut up compiler warning\r
-\r
- while(scan)\r
- {\r
- if(scan->attributes & LOCKBIT)\r
- {\r
- //\r
- // block is locked, so try to pile later blocks right after it\r
- //\r
- start = scan->start + scan->length;\r
- }\r
- else\r
- {\r
- if(scan->attributes & PURGEBITS)\r
- {\r
- //\r
- // throw out the purgable block\r
- //\r
- next = scan->next;\r
- MM_FreeBlock(scan, mm);\r
- last->next = next;\r
- scan = next;\r
- continue;\r
- }\r
- else\r
- {\r
- //\r
- // push the non purgable block on top of the last moved block\r
- //\r
- if(scan->start != start)\r
- {\r
- length = scan->length;\r
- source = scan->start;\r
- dest = start;\r
- while(length > 0xf00)\r
- {\r
- movedata(source,0,dest,0,0xf00*16);\r
- length -= 0xf00;\r
- source += 0xf00;\r
- dest += 0xf00;\r
- }\r
- movedata(source,0,dest,0,length*16);\r
-\r
- scan->start = start;\r
- *(unsigned *)scan->useptr = start;\r
- }\r
- start = scan->start + scan->length;\r
- }\r
- }\r
-\r
- last = scan;\r
- scan = scan->next; // go to next block\r
- }\r
-\r
- mm->mmrover = mm->mmhead;\r
-\r
- if(aftersort)\r
- aftersort();\r
-\r
-// VW_ColorBorder (oldborder);\r
-\r
-/*++++ if (playing)\r
- MM_SetLock(&(memptr)audiosegs[playing],false);*/\r
-}\r
-\r
-\r
-//==========================================================================\r
-\r
-//****#if 0\r
-/*\r
-=====================\r
-=\r
-= MM_ShowMemory\r
-=\r
-=====================\r
-*/\r
-\r
-void MM_ShowMemory(mminfo_t *mm)\r
-{\r
- mmblocktype far *scan;\r
- unsigned color,temp;//, i;\r
- long end,owner;\r
- char scratch[80],str[10];\r
-\r
-//**** VW_SetDefaultColors();\r
-//**** VW_SetLineWidth(40);\r
-//++++mh temp = bufferofs;\r
-//++++mh bufferofs = 0;\r
-//**** VW_SetScreen (0,0);\r
-\r
- scan = mm->mmhead;\r
-\r
- end = -1;\r
-\r
-//CA_OpenDebug ();\r
-\r
- while (scan)\r
- {\r
- if (scan->attributes & PURGEBITS)\r
- color = 5; // dark purple = purgable\r
- else\r
- color = 9; // medium blue = non purgable\r
- if(scan->attributes & LOCKBIT)\r
- color = 12; // red = locked\r
- if(scan->start<=end)\r
- {\r
- printf("MM_ShowMemory: Memory block order currupted!");\r
- return;\r
- }\r
- end = scan->start+scan->length-1;\r
-//++++ VW_Hlin(scan->start,(unsigned)end,0,color);\r
-//++++ VW_Plot(scan->start,0,15);\r
- if(scan->next->start > end+1)\r
-//++++ VW_Hlin(end+1,scan->next->start,0,0); // black = free\r
-\r
-//****#if 0\r
-printf("Location:");\r
-printf("%Fp\t", scan->start);\r
-strcpy (scratch,"Size:");\r
-ltoa ((long)scan->length*16,str,10);\r
-strcat (scratch,str);\r
-strcat (scratch,"\tOwner:0x");\r
-owner = (unsigned)scan->useptr;\r
-ultoa (owner,str,16);\r
-strcat (scratch,str);\r
-strcat (scratch,"\n");\r
-//++++write (debughandle,scratch,strlen(scratch));\r
-fprintf(stdout, "%s", scratch);\r
-//****#endif\r
-\r
- scan = scan->next;\r
- }\r
-\r
-//CA_CloseDebug ();\r
-\r
-//++++mh IN_Ack();\r
-//**** VW_SetLineWidth(64);\r
-//++++mh bufferofs = temp;\r
-}\r
-//****#endif\r
-\r
-//==========================================================================\r
-\r
-\r
-/*\r
-======================\r
-=\r
-= MM_UnusedMemory\r
-=\r
-= Returns the total free space without purging\r
-=\r
-======================\r
-*/\r
-\r
-dword MM_UnusedMemory(mminfo_t *mm)\r
-{\r
- unsigned free;\r
- mmblocktype far *scan;\r
-\r
- free = 0;\r
- scan = mm->mmhead;\r
-\r
- while(scan->next)\r
- {\r
- free += scan->next->start - (scan->start + scan->length);\r
- scan = scan->next;\r
- }\r
-\r
- return free*16l;\r
-// return free;\r
-}\r
-\r
-//==========================================================================\r
-\r
-\r
-/*\r
-======================\r
-=\r
-= MM_TotalFree\r
-=\r
-= Returns the total free space with purging\r
-=\r
-======================\r
-*/\r
-\r
-dword MM_TotalFree(mminfo_t *mm)\r
-{\r
- unsigned free;\r
- mmblocktype far *scan;\r
-\r
- free = 0;\r
- scan = mm->mmhead;\r
-\r
- while(scan->next)\r
- {\r
- if((scan->attributes&PURGEBITS) && !(scan->attributes&LOCKBIT))\r
- free += scan->length;\r
- free += scan->next->start - (scan->start + scan->length);\r
- scan = scan->next;\r
- }\r
-\r
- return free*16l;\r
-// return free;\r
-}\r
-\r
-//==========================================================================\r
-\r
-/*\r
-=====================\r
-=\r
-= MM_Report\r
-=\r
-=====================\r
-*/\r
-\r
-void MM_Report(mminfo_t *mm, mminfotype *mmi)\r
-{\r
- printf("EMM %x available\n", mm->EMSVer);\r
- printf("totalEMSpages=%u\n", mm->totalEMSpages);\r
- printf("freeEMSpages=%u\n", mm->freeEMSpages);\r
- printf("EMSpageframe=%Fp\n", mm->EMSpageframe);\r
- printf("near=%lu\n", mmi->nearheap);\r
- printf("far=%lu\n", mmi->farheap);\r
- printf("EMSmem=%lu\n", mmi->EMSmem);\r
- printf("XMSmem=%lu\n", mmi->XMSmem);\r
- printf("mainmem=%lu\n", mmi->mainmem);\r
- printf("UnusedMemory=%lu\n", MM_UnusedMemory(mm));\r
- printf("TotalFree=%lu\n", MM_TotalFree(mm));\r
-// printf("\n");\r
-// printf("UnusedMemory=%lu kb\n", MM_UnusedMemory()/10248);\r
-// printf("TotalFree=%lu kb\n", MM_TotalFree()/10248);\r
-}\r
-\r
-//==========================================================================\r
-\r
-/*\r
-=====================\r
-=\r
-= MM_EMSVer\r
-=\r
-=====================\r
-\r
-\r
-int MM_EMSVer(void)\r
-{\r
- int EMSver;\r
- __asm\r
- {\r
- mov ah,EMS_VERSION\r
- int EMS_INT\r
- mov EMSver,ax\r
- }\r
- return(EMSver);\r
-}*/\r
-\r
-//==========================================================================\r
-\r
-/*\r
-=====================\r
-=\r
-= MM_BombOnError\r
-=\r
-=====================\r
-*/\r
-\r
-void MM_BombOnError(boolean bomb, mminfo_t *mm)\r
-{\r
- mm->bombonerror = bomb;\r
-}\r
-
-void MM_GetNewBlock(mminfo_t *mm)
+ 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
+//
+ 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.mmnew->useptr = peeonself;
+ gvar->mm.mmrover = gvar->mm.mmhead;
+
+ //printf(" %x\n", peeonself);
+ //printf(" %x\n", *peeonself);
+//
+// get all available near conventional memory segments
+//
+#ifdef __WATCOMC__
+ _nheapgrow();
+ length=(dword)_memavl();//(dword)GetFreeSize();
+ //huge start = (void huge *)(gvar->mm.nearheap = _nmalloc(length));
+ start = (void far *)(gvar->mm.nearheap = _nmalloc(length));
+#endif
+#ifdef __BORLANDC__
+ length=coreleft();
+ //huge start = (void huge *)(gvar->mm.nearheap = malloc(length));
+ 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, gvar);
+ gvar->mmi.nearheap = length;
+ //printf("start=%Fp segstart=%x seglen=%lu len=%lu\n", start, segstart, seglength, length);
+
+//
+// get all available far conventional memory segments
+//
+ //printf("_FARCORELEFT %lu\n", _FCORELEFT);
+#ifdef __WATCOMC__
+ _fheapgrow();
+ length=_FCORELEFT;//_fcoreleft();//(dword)GetFarFreeSize();//0xffffUL*4UL;
+#endif
+#ifdef __BORLANDC__
+ printf("farcoreleft() %lu\n", farcoreleft());
+ printf("(farcoreleft()+32)-_FCORELEFT %d\n", (sword)((farcoreleft()+32)-_FCORELEFT));
+ length=farcoreleft();//_fcoreleft();//(dword)GetFarFreeSize();//0xffffUL*4UL;
+#endif
+ 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, gvar);
+ gvar->mmi.farheap = length;
+ //printf("start=%Fp segstart=%x seglen=%lu len=%lu\n", start, segstart, seglength, length);
+
+ gvar->mmi.mainmem = gvar->mmi.nearheap + gvar->mmi.farheap;
+
+#ifndef __16_PM__
+ if(!dbg_debugpm) {
+//
+// detect EMS and allocate up to 64K at page frame
+//
+ gvar->mmi.EMSmem = 0;
+//goto emsskip; //0000
+ for(i = 1;i < _argc;i++)
+ {
+ if(US_CheckParm(_argv[i],ParmStringsexmm) == 0)
+ goto emsskip; // param NOEMS
+ }
+ if(MML_CheckForEMS())
+ {
+ 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(gvar); // map in used pages
+ }
+
+//
+// detect XMS and get upper memory blocks
+//
+emsskip:
+ gvar->mmi.XMSmem = 0;
+goto xmsskip;//0000
+ for(i = 1;i < _argc;i++)
+ {
+ if(US_CheckParm( _argv[i],ParmStringsexmm) == 0)
+ goto xmsskip; // param NOXMS
+ }
+ if(MML_CheckForXMS())
+ {
+ MML_SetupXMS(gvar); // allocate as many UMBs as possible
+ }
+
+ }
+xmsskip:
+#endif
+//
+// allocate the misc buffer
+//
+ gvar->mm.mmrover = gvar->mm.mmhead; // start looking for space after low block
+
+ MM_GetPtr(&(gvar->mm.bufferseg),BUFFERSIZE, gvar);
+}
+
+//==========================================================================
+
+/*
+====================
+=
+= MM_Shutdown
+=
+= Frees all conventional, EMS, and XMS allocated
+=
+====================
+*/
+
+void MM_Shutdown(global_game_variables_t *gvar)
+{
+ if(!(gvar->mm.mmstarted))
+ return;
+
+ _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
+}
+
+//==========================================================================
+
+/*
+====================
+=
+= MM_GetPtr
+=
+= Allocates an unlocked, unpurgable block
+=
+====================
+*/
+
+void MM_GetPtr (memptr *baseptr, dword size, global_game_variables_t *gvar)
+{
+ //huge 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
+
+ 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__
+ 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
+ //exit(-5); }
+ gvar->mm.mmnew->attributes = BASEATTRIBUTES;
+
+//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 && gvar->mm.mmrover == gvar->mm.mmhead)
+ search++;
+
+ switch (search)
+ {
+ case 0:
+ lastscan = gvar->mm.mmrover;
+ scan = gvar->mm.mmrover->next;
+ endscan = NULL;
+ break;
+ case 1:
+ lastscan = gvar->mm.mmhead;
+ scan = gvar->mm.mmhead->next;
+ endscan = gvar->mm.mmrover;
+ break;
+ case 2:
+ MM_SortMem (gvar);
+ lastscan = gvar->mm.mmhead;
+ scan = gvar->mm.mmhead->next;
+ endscan = NULL;
+ break;
+ }
+
+ startseg = lastscan->start + lastscan->length;
+
+ while (scan != endscan)
+ {
+ if (scan->start - startseg >= needed)
+ {
+ //
+ // got enough space between the end of lastscan and
+ // the start of scan, so throw out anything in the middle
+ // and allocate the new block
+ //
+ purge = lastscan->next;
+ 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;
+ FREEBLOCK(purge);
+ purge = next; // purge another if not at scan
+ }
+ 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)
+ || !(scan->attributes & PURGEBITS) )
+ {
+ lastscan = scan;
+ startseg = lastscan->start + lastscan->length;
+ }
+
+
+ scan=scan->next; // look at next line
+ }
+ }
+
+ if (gvar->mm.bombonerror)
+ {
+#ifdef __WATCOMC__
+ //heapdump();
+#endif
+ printf(OUT_OF_MEM_MSG,(size-gvar->mmi.nearheap));
+ printf("for stability reasons the program will shut down! wwww\n");
+ MM_Shutdown(gvar);
+ exit(-1);
+ }
+ else
+ gvar->mm.mmerror = true;
+}
+
+//==========================================================================
+
+/*
+====================
+=
+= MM_FreePtr
+=
+= Allocates an unlocked, unpurgable block
+=
+====================
+*/
+
+void MM_FreePtr(memptr *baseptr, global_game_variables_t *gvar)
+{
+ //huge mmblocktype huge *scan,huge *last;
+ mmblocktype far *scan,far *last;
+
+ last = gvar->mm.mmhead;
+ scan = last->next;
+
+ if(baseptr == gvar->mm.mmrover->useptr) // removed the last allocated block
+ gvar->mm.mmrover = gvar->mm.mmhead;
+
+ while(scan->useptr != baseptr && scan)
+ {
+ last = scan;
+ scan = scan->next;
+ }
+
+ if(!scan)
+ {
+ printf("MM_FreePtr: Block not found!\n");
+ return;
+ }
+
+ last->next = scan->next;
+
+ FREEBLOCK(scan);
+}
+//==========================================================================
+
+/*
+=====================
+=
+= MM_SetPurge
+=
+= Sets the purge level for a block (locked blocks cannot be made purgable)
+=
+=====================
+*/
+
+
+void MM_SetPurge(memptr *baseptr, int purge, global_game_variables_t *gvar)
+{
+ //huge mmblocktype huge *start;
+ mmblocktype far *start;
+
+ start = gvar->mm.mmrover;
+
+ do
+ {
+ if(gvar->mm.mmrover->useptr == baseptr)
+ break;
+
+ gvar->mm.mmrover = gvar->mm.mmrover->next;
+
+ if(!gvar->mm.mmrover)
+ gvar->mm.mmrover = gvar->mm.mmhead;
+ else if(gvar->mm.mmrover == start)
+ {
+ Quit("MM_SetPurge: Block not found!");
+ //return;
+ }
+
+ } while(1);
+
+ gvar->mm.mmrover->attributes &= ~PURGEBITS;
+ gvar->mm.mmrover->attributes |= purge;
+}
+
+//==========================================================================
+
+/*
+=====================
+=
+= MM_SetLock
+=
+= Locks / unlocks the block
+=
+=====================
+*/
+
+void MM_SetLock(memptr *baseptr, boolean locked, global_game_variables_t *gvar)
+{
+ //huge mmblocktype huge *start;
+ mmblocktype far *start;
+
+ start = gvar->mm.mmrover;
+
+ do
+ {
+ if(gvar->mm.mmrover->useptr == baseptr)
+ break;
+
+ gvar->mm.mmrover = gvar->mm.mmrover->next;
+
+ if(!gvar->mm.mmrover)
+ gvar->mm.mmrover = gvar->mm.mmhead;
+ else if(gvar->mm.mmrover == start)
+ {
+ Quit("MM_SetLock: Block not found!");
+ //return;
+ }
+
+ } while(1);
+
+ gvar->mm.mmrover->attributes &= ~LOCKBIT;
+ gvar->mm.mmrover->attributes |= locked*LOCKBIT;
+}
+
+//==========================================================================
+
+/*
+=====================
+=
+= MM_SortMem
+=
+= Throws out all purgable stuff and compresses movable blocks
+=
+=====================
+*/
+
+void MM_SortMem(global_game_variables_t *gvar)
+{
+ //huge mmblocktype huge *scan,huge *last,huge *next;
+ mmblocktype far *scan,far *last,far *next;
+ unsigned start,length,source,dest,oldborder;
+ int playing;
+
+ //
+ // lock down a currently playing sound
+ //
+/*++++ playing = SD_SoundPlaying ();
+ if(playing)
+ {
+ switch (SoundMode)
+ {
+ case sdm_PC:
+ playing += STARTPCSOUNDS;
+ break;
+ case sdm_AdLib:
+ playing += STARTADLIBSOUNDS;
+ break;
+ }
+ MM_SetLock(&(memptr)audiosegs[playing],true);
+ }
+
+
+ SD_StopSound();*/
+// oldborder = bordercolor;
+// VW_ColorBorder (15);
+
+ if(beforesort)
+ beforesort();
+
+ scan = gvar->mm.mmhead;
+
+ last = NULL; // shut up compiler warning
+
+ while(scan)
+ {
+ if(scan->attributes & LOCKBIT)
+ {
+ //
+ // block is locked, so try to pile later blocks right after it
+ //
+ start = scan->start + scan->length;
+ }
+ else
+ {
+ if(scan->attributes & PURGEBITS)
+ {
+ //
+ // throw out the purgable block
+ //
+ next = scan->next;
+ FREEBLOCK(scan);
+ //MM_FreeBlock(scan, gvar);
+ last->next = next;
+ scan = next;
+ continue;
+ }
+ else
+ {
+ //
+ // push the non purgable block on top of the last moved block
+ //
+ if(scan->start != start)
+ {
+ length = scan->length;
+ source = scan->start;
+ dest = start;
+ while(length > 0xf00)
+ {
+ movedata(source,0,dest,0,0xf00*16);
+ length -= 0xf00;
+ source += 0xf00;
+ dest += 0xf00;
+ }
+ movedata(source,0,dest,0,length*16);
+
+ scan->start = start;
+ *(unsigned *)scan->useptr = start;
+ }
+ start = scan->start + scan->length;
+ }
+ }
+
+ last = scan;
+ scan = scan->next; // go to next block
+ }
+
+ gvar->mm.mmrover = gvar->mm.mmhead;
+
+ if(aftersort)
+ aftersort();
+
+// VW_ColorBorder (oldborder);
+
+/*++++ if(playing)
+ MM_SetLock(&(memptr)audiosegs[playing],false);*/
+}
+
+//==========================================================================
+
+/*
+=====================
+=
+= MM_ShowMemory
+=
+=====================
+*/
+
+void MM_ShowMemory(global_game_variables_t *gvar)
+{
+ //huge mmblocktype huge *scan;
+ mmblocktype far *scan;
+ word temp;
+ sdword end,owner;
+ //word chx,chy;
+ word w;
+ //dword wwww;
+ byte scratch[160],scratch0[4096],scratch1[160],str[16];
+ //byte d = '#';
+//**** VW_SetDefaultColors();
+//**** VW_SetLineWidth(40);
+//++++mh temp = bufferofs;
+//++++mh bufferofs = 0;
+//**** VW_SetScreen (0,0);
+ scan = gvar->mm.mmhead;
+ end = -1;
+
+ CA_OpenDebug (gvar);
+ w=0;
+ while(scan)
+ {
+ strcpy(scratch, AARESET);
+ if(scan->attributes & PURGEBITS)
+ strcpy(scratch0, AAMAGENTA); // dark purple = purgable
+ else
+ strcpy(scratch0, AABLUE); // medium blue = non purgable
+ if(scan->attributes & LOCKBIT)
+ strcpy(scratch0, AARED); // red = locked
+ if(scan->start<=end)
+ {
+ 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");
+ break;
+ }
+ 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);
+//++++ 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);
+ //}
+ //modexhlin(page, end+1,scan->next->start, chy, 0);
+/* y = scan->start/320;
+ x = scan->start%320;
+ VW_Hlin(x,x+end,y,color);
+ 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);
+
+ scan = scan->next;
+ }
+ /*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;
+}
+
+//==========================================================================
+
+/*
+=====================
+=
+= MM_DumpData
+=
+=====================
+*/
+
+void MM_DumpData(global_game_variables_t *gvar)
+{
+ //huge mmblocktype huge *scan,huge *best;
+ mmblocktype far *scan,far *best;
+ long lowest,oldlowest;
+ word owner;
+ byte lock,purge;
+ FILE *dumpfile;
+
+ free(gvar->mm.nearheap);
+#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;
+ }
+
+ lowest = -1;
+ do
+ {
+ oldlowest = lowest;
+ lowest = 0xffff;
+
+ scan = gvar->mm.mmhead;
+ while (scan)
+ {
+ owner = (unsigned)scan->useptr;
+
+ if (owner && owner<lowest && owner > oldlowest)
+ {
+ best = scan;
+ lowest = owner;
+ }
+
+ scan = scan->next;
+ }
+
+ if (lowest != 0xffff)
+ {
+ if (best->attributes & PURGEBITS)
+ purge = 'P';
+ else
+ purge = '-';
+ if (best->attributes & LOCKBIT)
+ lock = 'L';
+ else
+ lock = '-';
+ fprintf (dumpfile,"0x%p (%c%c) = %u\n"
+ ,(unsigned)lowest,lock,purge,best->length);
+ }
+
+ } while (lowest != 0xffff);
+
+ fclose(dumpfile);
+ printf("MMDUMP.16 created.\n");
+}
+
+//==========================================================================
+
+
+/*
+======================
+=
+= MM_UnusedMemory
+=
+= Returns the total free space without purging
+=
+======================
+*/
+
+dword MM_UnusedMemory(global_game_variables_t *gvar)
+{
+ dword free;
+ //huge mmblocktype huge *scan;
+ mmblocktype far *scan;
+
+ free = 0;
+ scan = gvar->mm.mmhead;
+
+ while(scan->next)
+ {
+ free += scan->next->start - (scan->start + scan->length);
+ scan = scan->next;
+ }
+
+ return free*16lu;
+// return free;
+}
+
+//==========================================================================
+
+
+/*
+======================
+=
+= MM_TotalFree
+=
+= Returns the total free space with purging
+=
+======================
+*/
+
+dword MM_TotalFree(global_game_variables_t *gvar)
+{
+ dword free;
+ //huge mmblocktype huge *scan;
+ mmblocktype far *scan;
+
+ free = 0;
+ scan = gvar->mm.mmhead;
+
+ while(scan->next)
+ {
+ if((scan->attributes&PURGEBITS) && !(scan->attributes&LOCKBIT))
+ free += scan->length;
+ free += scan->next->start - (scan->start + scan->length);
+ scan = scan->next;
+ }
+
+ return free*16lu;
+// return free;
+}
+
+//==========================================================================
+
+/*
+=====================
+=
+= MM_Report
+=
+=====================
+*/
+
+void MM_Report_(global_game_variables_t *gvar)
+{
+ printf("========================================\n");
+ printf(" MM_Report_\n");
+ printf("========================================\n");
+ if(MML_CheckForEMS())
+ {
+ 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);
+ }
+ 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);
+}
+
+//==========================================================================
+
+/*
+=====================
+=
+= MM_EMSerr
+=
+=====================
+*/
+
+void MM_EMSerr(byte *stri, byte err)
+{
+ //Returns a text string describing the error code in EMS.Error.
+ switch(err)
+ {
+ case 0x0:
+ strcat(stri, "successful");
+ break;
+ case 0x80:
+ strcat(stri, "internal error");
+ break;
+ case 0x81:
+ strcat(stri, "hardware malfunction");
+ break;
+ case 0x82:
+ strcat(stri, "busy .. retry later");
+ break;
+ case 0x83:
+ strcat(stri, "invalid handle");
+ break;
+ case 0x84:
+ strcat(stri, "undefined function requested by application");
+ break;
+ case 0x85:
+ strcat(stri, "no more handles available");
+ break;
+ case 0x86:
+ strcat(stri, "error in save or restore of mapping context");
+ break;
+ case 0x87:
+ strcat(stri, "insufficient memory pages in system");
+ break;
+ case 0x88:
+ strcat(stri, "insufficient memory pages available");
+ break;
+ case 0x89:
+ strcat(stri, "zero pages requested");
+ break;
+ case 0x8A:
+ strcat(stri, "invalid logical page number encountered");
+ break;
+ case 0x8B:
+ strcat(stri, "invalid physical page number encountered");
+ break;
+ case 0x8C:
+ strcat(stri, "page-mapping hardware state save area is full");
+ break;
+ case 0x8D:
+ strcat(stri, "save of mapping context failed");
+ break;
+ case 0x8E:
+ strcat(stri, "restore of mapping context failed");
+ break;
+ case 0x8F:
+ strcat(stri, "undefined subfunction");
+ break;
+ case 0x90:
+ strcat(stri, "undefined attribute type");
+ break;
+ case 0x91:
+ strcat(stri, "feature not supported");
+ break;
+ case 0x92:
+ strcat(stri, "successful, but a portion of the source region has been overwritten");
+ break;
+ case 0x93:
+ strcat(stri, "length of source or destination region exceeds length of region allocated to either source or destination handle");
+ break;
+ case 0x94:
+ strcat(stri, "conventional and expanded memory regions overlap");
+ break;
+ case 0x95:
+ strcat(stri, "offset within logical page exceeds size of logical page");
+ break;
+ case 0x96:
+ strcat(stri, "region length exceeds 1 MB");
+ break;
+ case 0x97:
+ strcat(stri, "source and destination EMS regions have same handle and overlap");
+ break;
+ case 0x98:
+ strcat(stri, "memory source or destination type undefined");
+ break;
+ case 0x9A:
+ strcat(stri, "specified alternate map register or DMA register set not supported");
+ break;
+ case 0x9B:
+ strcat(stri, "all alternate map register or DMA register sets currently allocated");
+ break;
+ case 0x9C:
+ strcat(stri, "alternate map register or DMA register sets not supported");
+ break;
+ case 0x9D:
+ strcat(stri, "undefined or unallocated alternate map register or DMA register set");
+ break;
+ case 0x9E:
+ strcat(stri, "dedicated DMA channels not supported");
+ break;
+ case 0x9F:
+ strcat(stri, "specified dedicated DMA channel not supported");
+ break;
+ case 0xA0:
+ strcat(stri, "no such handle name");
+ break;
+ case 0xA1:
+ strcat(stri, "a handle found had no name, or duplicate handle name");
+ break;
+ case 0xA2:
+ strcat(stri, "attempted to wrap around 1M conventional address space");
+ break;
+ case 0xA3:
+ strcat(stri, "source array corrupted");
+ break;
+ case 0xA4:
+ strcat(stri, "operating system denied access");
+ break;
+ default:
+ strcat(stri, "undefined error");
+ }
+}
+
+//==========================================================================
+
+/*
+=====================
+=
+= MM_BombOnError
+=
+=====================
+*/
+
+void MM_BombOnError(boolean bomb, global_game_variables_t *gvar)
+{
+ gvar->mm.bombonerror = bomb;
+}
+
+/*void MM_GetNewBlock(global_game_variables_t *gvar)