X-Git-Url: http://4ch.mooo.com/gitweb/?a=blobdiff_plain;f=src%2Flib%2F16_mm.c;h=df1dd7f7fef2222f312f848279042e4963efa9be;hb=330b72f5c3a57ed0a17636059df12e0195a5c3cd;hp=44426a063dad58a3c37655f5b31697522bbb090e;hpb=866232d8ee296189ab972a4c99c140dbe32c3353;p=16.git diff --git a/src/lib/16_mm.c b/src/lib/16_mm.c old mode 100644 new mode 100755 index 44426a06..df1dd7f7 --- a/src/lib/16_mm.c +++ b/src/lib/16_mm.c @@ -1,4 +1,4 @@ -/* Catacomb Armageddon Source Code +/* Catacomb Apocalypse Source Code * Copyright (C) 1993-2014 Flat Rock Software * * This program is free software; you can redistribute it and/or modify @@ -41,36 +41,17 @@ EMS / XMS unmanaged routines ============================================================================= */ - -#include "src/lib/16_mm.h" - /* -============================================================================= - LOCAL INFO +Open Watcom port by sparky4 -============================================================================= */ +#include "src/lib/16_mm.h" +#include "src/lib/16_ca.h" +#pragma hdrstop -#define LOCKBIT 0x80 // if set in attributes, block cannot be moved -#define PURGEBITS 3 // 0-3 level, 0= unpurgable, 3= purge first -#define PURGEMASK 0xfffc -#define BASEATTRIBUTES 0 // unlocked, non purgable - -#define MAXUMBS 10 - -typedef struct mmblockstruct -{ - unsigned start,length; - unsigned attributes; - memptr *useptr; // pointer to the segment start - struct mmblockstruct far *next; -} mmblocktype; - - -//#define GETNEWBLOCK {if(!(mmnew=mmfree))Quit("MM_GETNEWBLOCK: No free blocks!");mmfree=mmfree->next;} -#define GETNEWBLOCK {if(!mmfree)MML_ClearBlock();mmnew=mmfree;mmfree=mmfree->next;} -#define FREEBLOCK(x) {*x->useptr=NULL;x->next=mmfree;mmfree=x;} +#pragma warn -pro +#pragma warn -use /* ============================================================================= @@ -80,12 +61,9 @@ typedef struct mmblockstruct ============================================================================= */ -mminfotype mminfo; -memptr bufferseg; -boolean mmerror; - void (* beforesort) (void); void (* aftersort) (void); +void (* XMSaddr) (void); // far pointer to XMS driver /* ============================================================================= @@ -94,25 +72,9 @@ void (* aftersort) (void); ============================================================================= */ - -boolean mmstarted; - -void huge *hugeheap; -void far *farheap; -void *nearheap; - -mmblocktype far mmblocks[MAXBLOCKS] - ,far *mmhead,far *mmfree,far *mmrover,far *mmnew; - -boolean bombonerror; - -unsigned totalEMSpages,freeEMSpages,EMSpageframe,EMSpagesmapped,EMShandle; - -void (* XMSaddr) (void); // far pointer to XMS driver - -unsigned numUMBs,UMBbase[MAXUMBS]; - - +#ifndef __16_PM__ +static char *ParmStringsexmm[] = {"noems","noxms",""}; +#endif /* ====================== = @@ -123,13 +85,12 @@ unsigned numUMBs,UMBbase[MAXUMBS]; ======================= */ -boolean MML_CheckForEMS (void) +boolean MML_CheckForEMS(void) { - boolean emmcfems; - char emmname[] = "EMMXXXX0"; -// mov dx,OFFSET emmname + boolean emmcfems=0; + static char emmname[] = "EMMXXXX0"; //fix by andrius4669 __asm { - LEA DX, emmname //fix by andrius4669 + mov dx,OFFSET emmname //fix by andrius4669 mov ax,0x3d00 int 0x21 // try to open EMMXXXX0 device jc error @@ -158,17 +119,28 @@ boolean MML_CheckForEMS (void) // mov emmcfems,1 jmp End +#ifdef __BORLANDC__ + } +#endif error: +#ifdef __BORLANDC__ + __asm { +#endif // // EMS is bad // mov emmcfems,0 +#ifdef __BORLANDC__ + } +#endif End: +#ifdef __WATCOMC__ } +#endif return(emmcfems); } - +#ifndef __16_PM__ /* ====================== = @@ -177,26 +149,29 @@ boolean MML_CheckForEMS (void) ======================= */ -void MML_SetupEMS (void) +byte MML_SetupEMS(global_game_variables_t *gvar) { - char str[80],str2[10]; - unsigned err; + byte str[160]; + byte err; boolean errorflag=false; - union REGS CPURegs; - totalEMSpages = freeEMSpages = EMSpageframe = EMSpagesmapped = 0; + unsigned int EMSVer = 0; + //byte EMS_status; + 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 + //mov [EMS_status],ah jnz error mov ah,EMS_VERSION int EMS_INT or ah,ah jnz error + mov [EMSVer],ax // set EMSVer cmp al,0x32 // only work on ems 3.2 or greater jb error @@ -204,7 +179,7 @@ void MML_SetupEMS (void) 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 @@ -214,33 +189,69 @@ void MML_SetupEMS (void) mov [freeEMSpages],bx or bx,bx jz noEMS // no EMS at all to allocate - + //EXPAND DONG!!!! + cmp [EMSVer],0x40 + jb low + cmp bx,[freeEMSpages] + jle getpages + mov bx,[freeEMSpages] + jmp getpages +#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,"MML_SetupEMS: EMS error 0x"); - itoa(err,str2,16); - strcpy(str,str2); + strcpy(str,"MM_SetupEMS: EMS error "); + MM_EMSerr(str, err); printf("%s\n",str); + return err; } + 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; } @@ -252,22 +263,29 @@ End: ======================= */ -void MML_ShutdownEMS (void) +void MML_ShutdownEMS(global_game_variables_t *gvar) { boolean errorflag=false; - if (!EMShandle) + unsigned EMSHandle=gvar->mm.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!"); //++++ add something +#endif + if(errorflag==true) + Quit("MML_ShutdownEMS: Error freeing EMS!\n"); //++++ add something } /* @@ -282,42 +300,131 @@ void MML_ShutdownEMS (void) ==================== */ -void MM_MapEMS (void) +byte MM_MapEMS(global_game_variables_t *gvar) { - char str[80],str2[10]; - unsigned err; + byte str[160]; + unsigned EMSHandle; + byte err; boolean errorflag=false; int i; - union REGS CPURegs; + EMSHandle=gvar->mm.EMSHandle; - for (i=0;immi.EMSmem = (i)*0x4000lu; + return 0; } +byte MM_MapXEMS(global_game_variables_t *gvar) +{ +//SUB EMS.MapXPages (PhysicalStart, LogicalStart, NumPages, Handle) + + //Maps up to 4 logical EMS pages to physical pages in the page frame, where: + //PhysicalStart = Physical page first logical page is mapped to + //LogicalStart = First logical page to map + //NumPages = Number of pages to map (1 to 4) + //Handle = EMS handle logical pages are allocated to + + /*//Create a buffer containing the page information +// FOR x = 0 TO NumPages - 1 +// MapInfo$ = MapInfo$ + MKI$(LogicalStart + x) + MKI$(PhysicalStart + x) +// NEXT*/ + +// Regs.ax = 0x5000 //Map the pages in the buffer +// Regs.cx = NumPages //to the pageframe +// Regs.dx = Handle +// Regs.ds = VARSEG(MapInfo$) +// Regs.si = SADD(MapInfo$) +// InterruptX 0x67, Regs, Regs +// EMS.Error = (Regs.ax AND 0xFF00&) \ 0x100 //Store the status code + +//END SUB + byte str[160]; + byte err; + word EMSHandle; + boolean errorflag=false; + int i; + EMSHandle=gvar->mm.EMSHandle; + + if(gvar->mm.EMSVer<0x40) + return 5; + + for (i=0;immi.EMSmem = (i)*0x4000lu; + return 0; +} +#endif //========================================================================== /* @@ -330,25 +437,29 @@ void MM_MapEMS (void) ======================= */ -boolean MML_CheckForXMS (void) +boolean MML_CheckForXMS(void) { + //numUMBs = 0; boolean errorflag=false; - 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__ /* ====================== = @@ -359,22 +470,22 @@ boolean MML_CheckForXMS (void) ======================= */ -void MML_SetupXMS (void) +void MML_SetupXMS(global_game_variables_t *gvar) { - unsigned base,size; + word base,size; - __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 - { + __asm { mov ah,XMS_ALLOCUMB mov dx,0xffff // try for largest block possible + //mov ax,dx // Set available Kbytes. call [DWORD PTR XMSaddr] or ax,ax jnz gotone @@ -386,17 +497,28 @@ getmemory: 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__ + } +#endif + done: +#ifdef __WATCOMC__ } - MML_UseSpace (base,size); - mminfo.XMSmem += size*16; - UMBbase[numUMBs] = base; - numUMBs++; - if (numUMBs < MAXUMBS) +#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; } @@ -409,23 +531,22 @@ done: ====================== */ -void MML_ShutdownXMS (void) +void MML_ShutdownXMS(global_game_variables_t *gvar) { int i; unsigned base; - for (i=0;imm.numUMBs;i++) { - base = UMBbase[i]; - __asm - { + base = gvar->mm.UMBbase[i]; + __asm { mov ah,XMS_FREEUMB mov dx,[base] call [DWORD PTR XMSaddr] } } } - +#endif //========================================================================== /* @@ -440,14 +561,85 @@ void MML_ShutdownXMS (void) ====================== */ -void MML_UseSpace (unsigned segstart, unsigned seglength) +/*void MML_UseSpace(word segstart, dword seglength, global_game_variables_t *gvar) +{ + //huge mmblocktype huge *scan,huge *last; + word segm=1; + word oldend; + dword segmlen; + dword extra; + + 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) + { + last = scan; + scan = scan->next; + } + +// +// take the given range out of the block +// + oldend = scan->start + scan->length; + 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! + if(segstart == scan->start) + { + last->next = scan->next; // unlink block + FREEBLOCK(scan); + scan = last; + } + else + scan->length = segstart-scan->start; // shorten block + + if(extra > 0) + { + 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_UseSpace(word segstart, dword seglength, global_game_variables_t *gvar) { mmblocktype far *scan,far *last; - unsigned oldend; - long extra; + word oldend; + sdword extra; + //word segm=1; - scan = last = mmhead; - mmrover = 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 @@ -458,17 +650,34 @@ void MML_UseSpace (unsigned segstart, unsigned seglength) scan = scan->next; } +// +// find out how many blocks it spans! +// + /*for(;seglength>=0x10000;seglength-=0xFFFF) + { + //printf(" seglen=%lu\n", segmlen); + segm++; + }*/ + // // take the given range out of the block // oldend = scan->start + scan->length; - extra = oldend - (segstart+seglength); + extra = oldend - (segstart+((unsigned)seglength)); if (extra < 0) { - printf("MML_UseSpace: Segment spans two blocks!"); - return; + 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) { @@ -482,11 +691,13 @@ void MML_UseSpace (unsigned segstart, unsigned seglength) if (extra > 0) { GETNEWBLOCK; - mmnew->next = scan->next; - scan->next = mmnew; - mmnew->start = segstart+seglength; - mmnew->length = extra; - mmnew->attributes = LOCKBIT; + 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; } } @@ -503,23 +714,24 @@ void MML_UseSpace (unsigned segstart, unsigned seglength) ==================== */ -void MML_ClearBlock (void) +void MML_ClearBlock(global_game_variables_t *gvar) { - mmblocktype far *scan,far *last; + //huge mmblocktype huge *scan,huge *last; + mmblocktype __far *scan;//,far *last; - scan = mmhead->next; + scan = gvar->mm.mmhead->next; - while (scan) + while(scan) { - if (!(scan->attributes&LOCKBIT) && (scan->attributes&PURGEBITS) ) + if(!(scan->attributes&LOCKBIT) && (scan->attributes&PURGEBITS)) { - MM_FreePtr(scan->useptr); + MM_FreePtr(scan->useptr, gvar); return; } scan = scan->next; } - printf("MM_ClearBlock: No purgable blocks!"); + printf("MM_ClearBlock: No purgable blocks!\n"); } @@ -536,110 +748,140 @@ void MML_ClearBlock (void) =================== */ -static char *ParmStringsexmm[] = {"noems","noxms",""}; - -void MM_Startup (void) +void MM_Startup(global_game_variables_t *gvar) { int i; - dword length; - void far *start; - unsigned segstart,seglength,endfree; + //dword length,seglength; + dword length; word seglength; + //huge void huge *start; + void far *start; + word segstart;//,endfree; + //memptr *peeonself; - if (mmstarted) - MM_Shutdown (); + if(gvar->mm.mmstarted) + MM_Shutdown(gvar); + gvar->mm.mmstarted = true; + gvar->mm.bombonerror = true; - mmstarted = true; - bombonerror = true; // // set up the linked list (everything in the free list; // - mmhead = NULL; - mmfree = &mmblocks[0]; - for (i=0;imm.mmhead = NULL; + gvar->mm.mmfree = &(gvar->mm.mmblocks[0]); + for(i=0;imm.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; - mmhead = mmnew; // this will allways be the first node - mmnew->start = 0; - mmnew->length = 0xffff; - mmnew->attributes = LOCKBIT; - mmnew->next = NULL; - mmrover = mmhead; - - + 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 // -//---- length=coreleft(); - length=_memavl(); - start = (void far *)(nearheap = malloc(length)); - +#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); - mminfo.nearheap = length; + 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 // -//---- length=farcoreleft(); - length=_memmax(); - start = farheap = _fmalloc(length); + //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); - mminfo.farheap = length; - mminfo.mainmem = mminfo.nearheap + mminfo.farheap; + 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 // - mminfo.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 } - - if (MML_CheckForEMS()) + if(MML_CheckForEMS()) { - MML_SetupEMS(); // allocate space - MML_UseSpace (EMSpageframe,EMSpagesmapped*0x400); - MM_MapEMS(); // map in used pages - mminfo.EMSmem = EMSpagesmapped*0x4000l; + 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: - mminfo.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 } + if(MML_CheckForXMS()) + { + MML_SetupXMS(gvar); // allocate as many UMBs as possible + } - if (MML_CheckForXMS()) - MML_SetupXMS(); // allocate as many UMBs as possible - + } +xmsskip: +#endif // // allocate the misc buffer // -xmsskip: - mmrover = mmhead; // start looking for space after low block + gvar->mm.mmrover = gvar->mm.mmhead; // start looking for space after low block - MM_GetPtr (&bufferseg,BUFFERSIZE); + MM_GetPtr(&(gvar->mm.bufferseg),BUFFERSIZE, gvar); } //========================================================================== @@ -654,16 +896,28 @@ xmsskip: ==================== */ -void MM_Shutdown (void) +void MM_Shutdown(global_game_variables_t *gvar) { - if (!mmstarted) - return; - - _ffree (farheap); - free (nearheap); - hfree(hugeheap); - MML_ShutdownEMS (); - MML_ShutdownXMS (); + 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 } //========================================================================== @@ -678,45 +932,55 @@ void MM_Shutdown (void) ==================== */ -void MM_GetPtr (memptr *baseptr,dword size) +void MM_GetPtr (memptr *baseptr, dword size, global_game_variables_t *gvar) { - mmblocktype far *scan,far *lastscan,far *endscan - ,far *purge,far *next; + //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 - mmnew->length = needed; - mmnew->useptr = baseptr; - mmnew->attributes = BASEATTRIBUTES; + 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 && mmrover == mmhead) + if (search == 1 && gvar->mm.mmrover == gvar->mm.mmhead) search++; switch (search) { case 0: - lastscan = mmrover; - scan = mmrover->next; + lastscan = gvar->mm.mmrover; + scan = gvar->mm.mmrover->next; endscan = NULL; break; case 1: - lastscan = mmhead; - scan = mmhead->next; - endscan = mmrover; + lastscan = gvar->mm.mmhead; + scan = gvar->mm.mmhead->next; + endscan = gvar->mm.mmrover; break; case 2: - MM_SortMem (); - lastscan = mmhead; - scan = mmhead->next; + MM_SortMem (gvar); + lastscan = gvar->mm.mmhead; + scan = gvar->mm.mmhead->next; endscan = NULL; break; } @@ -733,16 +997,16 @@ void MM_GetPtr (memptr *baseptr,dword size) // and allocate the new block // purge = lastscan->next; - lastscan->next = mmnew; - mmnew->start = *(unsigned *)baseptr = startseg; - mmnew->next = 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; FREEBLOCK(purge); purge = next; // purge another if not at scan } - mmrover = mmnew; + gvar->mm.mmrover = gvar->mm.mmnew; return; // good allocation! } @@ -761,10 +1025,18 @@ void MM_GetPtr (memptr *baseptr,dword size) } } - if (bombonerror) - printf(OUT_OF_MEM_MSG,(size-mminfo.nearheap)); + 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 - mmerror = true; + gvar->mm.mmerror = true; } //========================================================================== @@ -779,25 +1051,26 @@ void MM_GetPtr (memptr *baseptr,dword size) ==================== */ -void MM_FreePtr (memptr *baseptr) +void MM_FreePtr(memptr *baseptr, global_game_variables_t *gvar) { + //huge mmblocktype huge *scan,huge *last; mmblocktype far *scan,far *last; - last = mmhead; + last = gvar->mm.mmhead; scan = last->next; - if (baseptr == mmrover->useptr) // removed the last allocated block - mmrover = mmhead; + if(baseptr == gvar->mm.mmrover->useptr) // removed the last allocated block + gvar->mm.mmrover = gvar->mm.mmhead; - while (scan->useptr != baseptr && scan) + while(scan->useptr != baseptr && scan) { last = scan; scan = scan->next; } - if (!scan) + if(!scan) { - printf("MM_FreePtr: Block not found!"); + printf("MM_FreePtr: Block not found!\n"); return; } @@ -817,31 +1090,33 @@ void MM_FreePtr (memptr *baseptr) ===================== */ -void MM_SetPurge (memptr *baseptr, int purge) + +void MM_SetPurge(memptr *baseptr, int purge, global_game_variables_t *gvar) { + //huge mmblocktype huge *start; mmblocktype far *start; - start = mmrover; + start = gvar->mm.mmrover; do { - if (mmrover->useptr == baseptr) + if(gvar->mm.mmrover->useptr == baseptr) break; - mmrover = mmrover->next; + gvar->mm.mmrover = gvar->mm.mmrover->next; - if (!mmrover) - mmrover = mmhead; - else if (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("MM_SetPurge: Block not found!"); + //return; } - } while (1); + } while(1); - mmrover->attributes &= ~PURGEBITS; - mmrover->attributes |= purge; + gvar->mm.mmrover->attributes &= ~PURGEBITS; + gvar->mm.mmrover->attributes |= purge; } //========================================================================== @@ -856,31 +1131,32 @@ void MM_SetPurge (memptr *baseptr, int purge) ===================== */ -void MM_SetLock (memptr *baseptr, boolean locked) +void MM_SetLock(memptr *baseptr, boolean locked, global_game_variables_t *gvar) { + //huge mmblocktype huge *start; mmblocktype far *start; - start = mmrover; + start = gvar->mm.mmrover; do { - if (mmrover->useptr == baseptr) + if(gvar->mm.mmrover->useptr == baseptr) break; - mmrover = mmrover->next; + gvar->mm.mmrover = gvar->mm.mmrover->next; - if (!mmrover) - mmrover = mmhead; - else if (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("MM_SetLock: Block not found!"); + //return; } - } while (1); + } while(1); - mmrover->attributes &= ~LOCKBIT; - mmrover->attributes |= locked*LOCKBIT; + gvar->mm.mmrover->attributes &= ~LOCKBIT; + gvar->mm.mmrover->attributes |= locked*LOCKBIT; } //========================================================================== @@ -895,17 +1171,18 @@ void MM_SetLock (memptr *baseptr, boolean locked) ===================== */ -void MM_SortMem (void) +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; + unsigned start,length,source,dest;//++++,oldborder; + //++++int playing; // // lock down a currently playing sound // /*++++ playing = SD_SoundPlaying (); - if (playing) + if(playing) { switch (SoundMode) { @@ -924,16 +1201,16 @@ void MM_SortMem (void) // oldborder = bordercolor; // VW_ColorBorder (15); - if (beforesort) + if(beforesort) beforesort(); - scan = mmhead; + scan = gvar->mm.mmhead; last = NULL; // shut up compiler warning - while (scan) + while(scan) { - if (scan->attributes & LOCKBIT) + if(scan->attributes & LOCKBIT) { // // block is locked, so try to pile later blocks right after it @@ -942,13 +1219,14 @@ void MM_SortMem (void) } else { - if (scan->attributes & PURGEBITS) + if(scan->attributes & PURGEBITS) { // // throw out the purgable block // next = scan->next; FREEBLOCK(scan); + //MM_FreeBlock(scan, gvar); last->next = next; scan = next; continue; @@ -958,12 +1236,12 @@ void MM_SortMem (void) // // push the non purgable block on top of the last moved block // - if (scan->start != start) + if(scan->start != start) { length = scan->length; source = scan->start; dest = start; - while (length > 0xf00) + while(length > 0xf00) { movedata(source,0,dest,0,0xf00*16); length -= 0xf00; @@ -983,22 +1261,19 @@ void MM_SortMem (void) scan = scan->next; // go to next block } - mmrover = mmhead; + gvar->mm.mmrover = gvar->mm.mmhead; - if (aftersort) + if(aftersort) aftersort(); // VW_ColorBorder (oldborder); -/*++++ if (playing) +/*++++ if(playing) MM_SetLock(&(memptr)audiosegs[playing],false);*/ } - //========================================================================== -//**** -#if 0 /* ===================== = @@ -1007,67 +1282,229 @@ void MM_SortMem (void) ===================== */ -void MM_ShowMemory (void) +void MM_ShowMemory(global_game_variables_t *gvar) { + //huge mmblocktype huge *scan; mmblocktype far *scan; - unsigned color,temp; - long end,owner; - char scratch[80],str[10]; - -//**** VW_SetDefaultColors(); -//**** VW_SetLineWidth(40); - temp = bufferofs; - bufferofs = 0; -//**** VW_SetScreen (0,0); - - scan = mmhead; - + //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 = gvar->mm.mmhead; end = -1; -//CA_OpenDebug (); - - while (scan) + CA_OpenDebug (gvar); + w=0; + while(scan) { - if (scan->attributes & PURGEBITS) - color = 5; // dark purple = purgable + strcpy(scratch, AARESET); + if(scan->attributes & PURGEBITS) + strcpy(scratch0, AAMAGENTA); // dark purple = purgable else - color = 9; // medium blue = non purgable - if (scan->attributes & LOCKBIT) - color = 12; // red = locked - if (scan->start<=end) + strcpy(scratch0, AABLUE); // medium blue = non purgable + if(scan->attributes & LOCKBIT) + strcpy(scratch0, AARED); // red = locked + if(scan->start<=end) { - printf("MM_ShowMemory: Memory block order currupted!"); - return; + 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; -//**** VW_Hlin(scan->start,(unsigned)end,0,color); -//**** VW_Plot(scan->start,0,15); -//**** if (scan->next->start > end+1) -//**** VW_Hlin(end+1,scan->next->start,0,0); // black = free - -//****#if 0 -strcpy (scratch,"Size:"); -ltoa ((long)scan->length*16,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)); -//****#endif + 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; } - -//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); - bufferofs = temp; +//++++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 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"); +} //========================================================================== @@ -1082,21 +1519,23 @@ strcat (scratch,"\n"); ====================== */ -long MM_UnusedMemory (void) +dword MM_UnusedMemory(global_game_variables_t *gvar) { - unsigned free; + dword free; + //huge mmblocktype huge *scan; mmblocktype far *scan; free = 0; - scan = mmhead; + scan = gvar->mm.mmhead; - while (scan->next) + while(scan->next) { free += scan->next->start - (scan->start + scan->length); scan = scan->next; } - return free*16l; + return free*16lu; +// return free; } //========================================================================== @@ -1112,23 +1551,25 @@ long MM_UnusedMemory (void) ====================== */ -long MM_TotalFree (void) +dword MM_TotalFree(global_game_variables_t *gvar) { - unsigned free; + dword free; + //huge mmblocktype huge *scan; mmblocktype far *scan; free = 0; - scan = mmhead; + scan = gvar->mm.mmhead; - while (scan->next) + while(scan->next) { - if ((scan->attributes&PURGEBITS) && !(scan->attributes&LOCKBIT)) + if((scan->attributes&PURGEBITS) && !(scan->attributes&LOCKBIT)) free += scan->length; free += scan->next->start - (scan->start + scan->length); scan = scan->next; } - return free*16l; + return free*16lu; +// return free; } //========================================================================== @@ -1136,48 +1577,239 @@ long MM_TotalFree (void) /* ===================== = -= MM_BombOnError += MM_Report = ===================== */ -void MM_BombOnError (boolean bomb) +void MM_Report_(global_game_variables_t *gvar) { - bombonerror = bomb; + 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); } -/////////////////////////////////////////////////////////////////////////// -// -// US_CheckParm() - checks to see if a string matches one of a set of -// strings. The check is case insensitive. The routine returns the -// index of the string that matched, or -1 if no matches were found -// -/////////////////////////////////////////////////////////////////////////// -int -US_CheckParm(char *parm,char **strings) +//========================================================================== + +/* +===================== += += MM_EMSerr += +===================== +*/ + +void MM_EMSerr(byte *stri, byte err) { - char cp,cs, - *p,*s; - int i; + //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"); + } +} - while (!isalpha(*parm)) // Skip non-alphas - parm++; +//========================================================================== + +/* +===================== += += MM_BombOnError += +===================== +*/ - for (i = 0;*strings && **strings;i++) +void MM_BombOnError(boolean bomb, global_game_variables_t *gvar) +{ + gvar->mm.bombonerror = bomb; +} + +/*void MM_GetNewBlock(global_game_variables_t *gvar) +{ + 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)) { - for (s = *strings++,p = parm,cs = cp = 0;cs == cp;) - { - cs = *s++; - if (!cs) - return(i); - cp = *p++; - - if (isupper(cs)) - cs = tolower(cs); - if (isupper(cp)) - cp = tolower(cp); - } + printf("MM_GETNEWBLOCK: No free blocks!\n"); + return; + } + gvar->mm.mmfree=gvar->mm.mmfree->next; +} + +void MM_FreeBlock(mmblocktype *x, global_game_variables_t *gvar) +{ + x->useptr=NULL; + 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) +{ + __asm { + push ds + mov ax,ds + inc ax + mov ds,ax } - return(-1); } +void MM_segude(void) +{ + __asm { + pop ds + } +}*/ + +/* +pull data from far and put it into ds var +mov ax,es:si +mov x,ax +*/ +/* +ss stack segment +sp top of stack +bp bottem of stack +*/