X-Git-Url: http://4ch.mooo.com/gitweb/?a=blobdiff_plain;f=src%2Flib%2F16_mm.c;h=38754e10cbbae0f570cec38df1908ae75bc09c69;hb=96e05db3b16f8e7ea67df81250163e0b590c4195;hp=1ea85feffb8ace9a09defe7613f84d2bcfe09bcd;hpb=2bc6e98511fbe156f4ec68b1b7dbc7c8c03f866f;p=16.git diff --git a/src/lib/16_mm.c b/src/lib/16_mm.c index 1ea85fef..38754e10 100644 --- 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,8 +41,38 @@ EMS / XMS unmanaged routines ============================================================================= */ +/* + +Open Watcom port by sparky4 +*/ #include "src/lib/16_mm.h" +#pragma hdrstop + +#pragma warn -pro +#pragma warn -use + +/* +============================================================================= + + GLOBAL VARIABLES + +============================================================================= +*/ + +void (* beforesort) (void); +void (* aftersort) (void); +void (* XMSaddr) (void); // far pointer to XMS driver + +/* +============================================================================= + + LOCAL VARIABLES + +============================================================================= +*/ + +static char *ParmStringsexmm[] = {"noems","noxms",""}; /* ====================== @@ -54,13 +84,14 @@ EMS / XMS unmanaged routines ======================= */ -boolean MML_CheckForEMS (void) +boolean MML_CheckForEMS(void) { boolean emmcfems; - char emmname[] = "EMMXXXX0"; + static char emmname[] = "EMMXXXX0"; //fix by andrius4669 // mov dx,OFFSET emmname __asm { - LEA DX, emmname //fix by andrius4669 + //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 @@ -108,13 +139,15 @@ boolean MML_CheckForEMS (void) ======================= */ -void MML_SetupEMS (void) +byte MML_SetupEMS(mminfo_t *mm) { - char str[80],str2[10]; - unsigned err; + byte str[160]; + byte err; boolean errorflag=false; - union REGS CPURegs; + unsigned int EMSVer = 0; + //byte EMS_status; + unsigned totalEMSpages,freeEMSpages,EMSpageframe,EMSpagesmapped,EMShandle; totalEMSpages = freeEMSpages = EMSpageframe = EMSpagesmapped = 0; __asm @@ -122,12 +155,14 @@ void MML_SetupEMS (void) 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 @@ -145,7 +180,15 @@ 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 + +low: 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 @@ -159,6 +202,7 @@ getpages: mov [EMShandle],dx jmp End error: + mov err,ah mov errorflag,1 jmp End noEMS: @@ -166,12 +210,20 @@ End: } if(errorflag==true) { - err = CPURegs.h.ah; - strcpy(str,"MML_SetupEMS: EMS error 0x"); - itoa(err,str2,16); - strcpy(str,str2); + //err = CPURegs.h.ah; + strcpy(str,"MM_SetupEMS: EMS error "); + //itoa(err,str2,16); + 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; + return 0; } @@ -183,10 +235,12 @@ End: ======================= */ -void MML_ShutdownEMS (void) +void MML_ShutdownEMS(mminfo_t *mm) { boolean errorflag=false; - if (!EMShandle) + unsigned EMShandle=mm->EMShandle; + + if(!EMShandle) return; __asm { @@ -198,7 +252,7 @@ void MML_ShutdownEMS (void) mov errorflag,1 ok: } - if(errorflag==true) printf("MML_ShutdownEMS: Error freeing EMS!"); //++++ add something + if(errorflag==true) printf("MML_ShutdownEMS: Error freeing EMS!\n"); //++++ add something } /* @@ -213,15 +267,16 @@ void MML_ShutdownEMS (void) ==================== */ -void MM_MapEMS (void) +byte MM_MapEMS(mminfo_t *mm, mminfotype *mmi) { - char str[80],str2[10]; - unsigned err; + byte str[160]; + unsigned EMShandle; + byte err; boolean errorflag=false; int i; - union REGS CPURegs; + EMShandle=mm->EMShandle; - for (i=0;iEMSmem = (i)*0x4000lu; + return 0; +} + +byte MM_MapXEMS(mminfo_t *mm, mminfotype *mmi) +{ +//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=mm->EMShandle; + + if(mm->EMSVer<0x40) + return 5; + + for (i=0;iEMSmem = (i)*0x4000lu; + return 0; } //========================================================================== @@ -261,10 +388,10 @@ void MM_MapEMS (void) ======================= */ -boolean MML_CheckForXMS (void) +boolean MML_CheckForXMS(mminfo_t *mm) { boolean errorflag=false; - numUMBs = 0; + mm->numUMBs = 0; __asm { @@ -290,22 +417,21 @@ boolean MML_CheckForXMS (void) ======================= */ -void MML_SetupXMS (void) +void MML_SetupXMS(mminfo_t *mm, mminfotype *mmi) { unsigned base,size; +getmemory: __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] or ax,ax jnz gotone @@ -323,11 +449,12 @@ gotone: mov [size],dx done: } - MML_UseSpace (base,size); - mminfo.XMSmem += size*16; - UMBbase[numUMBs] = base; - numUMBs++; - if (numUMBs < MAXUMBS) + 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) goto getmemory; } @@ -340,14 +467,14 @@ done: ====================== */ -void MML_ShutdownXMS (void) +void MML_ShutdownXMS(mminfo_t *mm) { int i; unsigned base; - for (i=0;inumUMBs;i++) { - base = UMBbase[i]; + base = mm->UMBbase[i]; __asm { mov ah,XMS_FREEUMB @@ -371,54 +498,90 @@ void MML_ShutdownXMS (void) ====================== */ -void MML_UseSpace (unsigned segstart, unsigned seglength) +void MML_UseSpace(/*d*/word segstart, dword seglength, mminfo_t *mm) { - mmblocktype far *scan,far *last; - unsigned oldend; - long extra; + mmblocktype huge *scan,huge *last; + word segm; + dword oldend; + dword extra; - scan = last = mmhead; - mmrover = mmhead; // reset rover to start of memory + scan = last = mm->mmhead; + mm->mmrover = 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*/) + { + /*__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"); + } + // // take the given range out of the block // oldend = scan->start + scan->length; extra = oldend - (segstart+seglength); - if (extra < 0) - { - printf("MML_UseSpace: Segment spans two blocks!"); - return; - } - - - if (segstart == scan->start) +/* +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) { last->next = scan->next; // unlink block - FREEBLOCK(scan); + MM_FreeBlock(scan, mm); scan = last; } else scan->length = segstart-scan->start; // shorten block - if (extra > 0) +// segm--; + + if(extra > 0) { - GETNEWBLOCK; - mmnew->next = scan->next; - scan->next = mmnew; - mmnew->start = segstart+seglength; - mmnew->length = extra; - mmnew->attributes = LOCKBIT; - } + 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; + }//else if(segm>0) goto segu; } @@ -434,23 +597,23 @@ void MML_UseSpace (unsigned segstart, unsigned seglength) ==================== */ -void MML_ClearBlock (void) +void MML_ClearBlock(mminfo_t *mm) { - mmblocktype far *scan,far *last; + mmblocktype huge *scan,huge *last; - scan = mmhead->next; + scan = 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, mm); return; } scan = scan->next; } - printf("MM_ClearBlock: No purgable blocks!"); + printf("MM_ClearBlock: No purgable blocks!\n"); } @@ -467,112 +630,137 @@ void MML_ClearBlock (void) =================== */ -void MM_Startup (void) +void MM_Startup(mminfo_t *mm, mminfotype *mmi) { int i; - dword length; - void far *start; - unsigned segstart,seglength,endfree; + dword length,seglength; + //dword length; word seglength; + void huge *start; + word segstart;//,endfree; - if (mmstarted) - MM_Shutdown (); + if(mm->mmstarted) + MM_Shutdown(mm); + mm->mmstarted = true; + 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;immhead = NULL; + mm->mmfree = &(mm->mmblocks[0]); + for(i=0;immblocks[i].next = &(mm->mmblocks[i+1]); + } + 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; - + //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; // // get all available near conventional memory segments // //---- length=coreleft(); - length=_memavl(); - start = (void far *)(nearheap = malloc(length)); - + printf(" nearheap making!\n"); + _heapgrow(); + length=_memmax();//(dword)GetFreeSize(); + start = (void huge *)(mm->nearheap = malloc(length)); 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, mm); + mmi->nearheap = length; + printf("start=%FP segstart=%X seglen=%lu len=%lu\n", start, segstart, seglength, length); + printf(" near heap ok!\n"); // // get all available far conventional memory segments // //---- length=farcoreleft(); - length=_memmax(); - start = farheap = _fmalloc(length); + printf(" farheap making!\n"); + _fheapgrow(); + length=(dword)GetFarFreeSize();//0xffffUL*4UL; + //start = mm->farheap = halloc(length, 1); + start = mm->farheap = _fmalloc(length); 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, mm); + mmi->farheap = length; + printf("start=%FP segstart=%X seglen=%lu len=%lu\n", start, segstart, seglength, length); + printf(" far heap ok!\n"); + + mmi->mainmem = mmi->nearheap + mmi->farheap; + getch(); // // detect EMS and allocate up to 64K at page frame // - mminfo.EMSmem = 0; - for (i = 1;i < __argc;i++) +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++) { - if ( US_CheckParm(__argv[i],ParmStringsexmm) == 0) + if(US_CheckParm(__argv[i],ParmStringsexmm) == 0) goto emsskip; // param NOEMS } - - if (MML_CheckForEMS()) +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("EMS!\n"); - MML_SetupEMS(); // allocate space - MML_UseSpace (EMSpageframe,EMSpagesmapped*0x400); - MM_MapEMS(); // map in used pages - mminfo.EMSmem = EMSpagesmapped*0x4000l; +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 + //else + //MM_MapXEMS(mm, mmi); // map in used pages } // // detect XMS and get upper memory blocks // emsskip: - mminfo.XMSmem = 0; - for (i = 1;i < __argc;i++) + mmi->XMSmem = 0; + 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()) +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)) { - printf("XMS!\n"); - MML_SetupXMS(); // allocate as many UMBs as possible +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 } // // allocate the misc buffer // xmsskip: - mmrover = mmhead; // start looking for space after low block + mm->mmrover = mm->mmhead; // start looking for space after low block - MM_GetPtr (&bufferseg,BUFFERSIZE); + MM_GetPtr(&(mm->bufferseg),BUFFERSIZE, mm, mmi); } //========================================================================== @@ -587,16 +775,15 @@ xmsskip: ==================== */ -void MM_Shutdown (void) +void MM_Shutdown(mminfo_t *mm) { - if (!mmstarted) - return; - - _ffree (farheap); - free (nearheap); - hfree(hugeheap); - MML_ShutdownEMS (); - MML_ShutdownXMS (); + if(!(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"); } } //========================================================================== @@ -611,54 +798,53 @@ void MM_Shutdown (void) ==================== */ -void MM_GetPtr (memptr *baseptr,dword size) +void MM_GetPtr(memptr *baseptr,dword size, mminfo_t *mm, mminfotype *mmi) { - mmblocktype far *scan,far *lastscan,far *endscan - ,far *purge,far *next; + mmblocktype huge *scan,huge *lastscan,huge *endscan,huge *purge,huge *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; + 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; - for (search = 0; search<3; search++) + 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 && mm->mmrover == mm->mmhead) search++; - switch (search) + switch(search) { case 0: - lastscan = mmrover; - scan = mmrover->next; + lastscan = mm->mmrover; + scan = mm->mmrover->next; endscan = NULL; break; case 1: - lastscan = mmhead; - scan = mmhead->next; - endscan = mmrover; + lastscan = mm->mmhead; + scan = mm->mmhead->next; + endscan = mm->mmrover; break; case 2: - MM_SortMem (); - lastscan = mmhead; - scan = mmhead->next; + MM_SortMem(mm); + lastscan = mm->mmhead; + scan = 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 @@ -666,23 +852,23 @@ 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; - while ( purge != scan) + lastscan->next = mm->mmnew; + mm->mmnew->start = *(unsigned *)baseptr = startseg; + mm->mmnew->next = scan; + while(purge != scan) { // free the purgable block next = purge->next; - FREEBLOCK(purge); + MM_FreeBlock(purge, mm); purge = next; // purge another if not at scan } - mmrover = mmnew; + mm->mmrover = 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; @@ -694,10 +880,13 @@ void MM_GetPtr (memptr *baseptr,dword size) } } - if (bombonerror) - printf(OUT_OF_MEM_MSG,(size-mminfo.nearheap)); + if (mm->bombonerror) + { + printf(OUT_OF_MEM_MSG,(size-mmi->nearheap)); + exit(-5); + } else - mmerror = true; + mm->mmerror = true; } //========================================================================== @@ -712,31 +901,31 @@ void MM_GetPtr (memptr *baseptr,dword size) ==================== */ -void MM_FreePtr (memptr *baseptr) +void MM_FreePtr(memptr *baseptr, mminfo_t *mm) { - mmblocktype far *scan,far *last; + mmblocktype huge *scan,huge *last; - last = mmhead; + last = mm->mmhead; scan = last->next; - if (baseptr == mmrover->useptr) // removed the last allocated block - mmrover = mmhead; + if(baseptr == mm->mmrover->useptr) // removed the last allocated block + mm->mmrover = 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; } last->next = scan->next; - FREEBLOCK(scan); + MM_FreeBlock(scan, mm); } //========================================================================== @@ -750,31 +939,31 @@ void MM_FreePtr (memptr *baseptr) ===================== */ -void MM_SetPurge (memptr *baseptr, int purge) +void MM_SetPurge(memptr *baseptr, int purge, mminfo_t *mm) { - mmblocktype far *start; + mmblocktype huge *start; - start = mmrover; + start = mm->mmrover; do { - if (mmrover->useptr == baseptr) + if(mm->mmrover->useptr == baseptr) break; - mmrover = mmrover->next; + mm->mmrover = mm->mmrover->next; - if (!mmrover) - mmrover = mmhead; - else if (mmrover == start) + if(!mm->mmrover) + mm->mmrover = mm->mmhead; + else if(mm->mmrover == start) { printf("MM_SetPurge: Block not found!"); return; } - } while (1); + } while(1); - mmrover->attributes &= ~PURGEBITS; - mmrover->attributes |= purge; + mm->mmrover->attributes &= ~PURGEBITS; + mm->mmrover->attributes |= purge; } //========================================================================== @@ -789,31 +978,31 @@ void MM_SetPurge (memptr *baseptr, int purge) ===================== */ -void MM_SetLock (memptr *baseptr, boolean locked) +void MM_SetLock(memptr *baseptr, boolean locked, mminfo_t *mm) { - mmblocktype far *start; + mmblocktype huge *start; - start = mmrover; + start = mm->mmrover; do { - if (mmrover->useptr == baseptr) + if(mm->mmrover->useptr == baseptr) break; - mmrover = mmrover->next; + mm->mmrover = mm->mmrover->next; - if (!mmrover) - mmrover = mmhead; - else if (mmrover == start) + if(!mm->mmrover) + mm->mmrover = mm->mmhead; + else if(mm->mmrover == start) { printf("MM_SetLock: Block not found!"); return; } - } while (1); + } while(1); - mmrover->attributes &= ~LOCKBIT; - mmrover->attributes |= locked*LOCKBIT; + mm->mmrover->attributes &= ~LOCKBIT; + mm->mmrover->attributes |= locked*LOCKBIT; } //========================================================================== @@ -828,9 +1017,9 @@ void MM_SetLock (memptr *baseptr, boolean locked) ===================== */ -void MM_SortMem (void) +void MM_SortMem(mminfo_t *mm) { - mmblocktype far *scan,far *last,far *next; + mmblocktype huge *scan,huge *last,huge *next; unsigned start,length,source,dest,oldborder; int playing; @@ -838,7 +1027,7 @@ void MM_SortMem (void) // lock down a currently playing sound // /*++++ playing = SD_SoundPlaying (); - if (playing) + if(playing) { switch (SoundMode) { @@ -857,16 +1046,16 @@ void MM_SortMem (void) // oldborder = bordercolor; // VW_ColorBorder (15); - if (beforesort) + if(beforesort) beforesort(); - scan = mmhead; + scan = 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 @@ -875,13 +1064,13 @@ 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, mm); last->next = next; scan = next; continue; @@ -891,12 +1080,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; @@ -916,14 +1105,14 @@ void MM_SortMem (void) scan = scan->next; // go to next block } - mmrover = mmhead; + mm->mmrover = mm->mmhead; - if (aftersort) + if(aftersort) aftersort(); // VW_ColorBorder (oldborder); -/*++++ if (playing) +/*++++ if(playing) MM_SetLock(&(memptr)audiosegs[playing],false);*/ } @@ -939,12 +1128,13 @@ void MM_SortMem (void) ===================== */ -void MM_ShowMemory (void) +void MM_ShowMemory(/*page_t *page, */mminfo_t *mm) { - mmblocktype far *scan; - unsigned color,temp;//, i; + mmblocktype huge *scan; + word color,temp; long end,owner; - char scratch[80],str[10]; + word chx,chy; + byte scratch[160],str[16]; //**** VW_SetDefaultColors(); //**** VW_SetLineWidth(40); @@ -952,50 +1142,85 @@ void MM_ShowMemory (void) //++++mh bufferofs = 0; //**** VW_SetScreen (0,0); - scan = mmhead; + scan = mm->mmhead; end = -1; -//CA_OpenDebug (); +CA_OpenDebug (); + + chx=0; + chy=0; - while (scan) + while(scan) { - if (scan->attributes & PURGEBITS) + if(scan->attributes & PURGEBITS) color = 5; // dark purple = purgable else color = 9; // medium blue = non purgable - if (scan->attributes & LOCKBIT) + if(scan->attributes & LOCKBIT) color = 12; // red = locked - if (scan->start<=end) + if(scan->start<=end) { - printf("MM_ShowMemory: Memory block order currupted!"); + //printf("); + write(debughandle,"\nMM_ShowMemory: Memory block order currupted!\n",strlen("\nMM_ShowMemory: Memory block order currupted!\n")); + //modexprint(&page, chx, chy, 1, 0, 24, "\nMM_ShowMemory: Memory block order currupted!\n"); return; } 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); + //++++ VW_Plot(scan->start,0,15); - if (scan->next->start > end+1) +//++++ modexClearRegion(page, chx, chy, 4, 4, 15); + if(scan->next->start > end+1) //++++ VW_Hlin(end+1,scan->next->start,0,0); // black = free + //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); + +/* + end = scan->length-1; + 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("Location:"); -printf("%Fp\t", scan->start); -strcpy (scratch,"Size:"); -ltoa ((long)scan->length*16,str,10); +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)); -fprintf(stdout, "%s", scratch); +write(debughandle,scratch,strlen(scratch)); +//modexprint(page, chx, chy, 1, 0, 24, &scratch); +//++++chy+=4; +//fprintf(stdout, "%s", scratch); //****#endif scan = scan->next; } -//CA_CloseDebug (); +CA_CloseDebug (); //++++mh IN_Ack(); //**** VW_SetLineWidth(64); @@ -1005,6 +1230,72 @@ fprintf(stdout, "%s", scratch); //========================================================================== +/* +===================== += += MM_DumpData += +===================== +*/ + +void MM_DumpData(mminfo_t *mm) +{ + mmblocktype far *scan,far *best; + long lowest,oldlowest; + word owner; + byte lock,purge; + FILE *dumpfile; + + + //++++free(mm->nearheap); + dumpfile = fopen ("mmdump.16","w"); + if (!dumpfile){ + printf("MM_DumpData: Couldn't open MMDUMP.16!\n"); + return; + } + + lowest = -1; + do + { + oldlowest = lowest; + lowest = 0xffff; + + scan = mm->mmhead; + while (scan) + { + owner = (word)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" + ,(word)lowest,lock,purge,best->length); + } + + } while (lowest != 0xffff); + + fclose(dumpfile); + printf("MMDUMP.16 created.\n"); +} + +//========================================================================== + /* ====================== @@ -1016,21 +1307,22 @@ fprintf(stdout, "%s", scratch); ====================== */ -long MM_UnusedMemory (void) +dword MM_UnusedMemory(mminfo_t *mm) { - unsigned free; - mmblocktype far *scan; + dword free; + mmblocktype huge *scan; free = 0; - scan = mmhead; + scan = mm->mmhead; - while (scan->next) + while(scan->next) { free += scan->next->start - (scan->start + scan->length); scan = scan->next; } - return free*16l; +// return free*16l; + return free; } //========================================================================== @@ -1046,23 +1338,24 @@ long MM_UnusedMemory (void) ====================== */ -long MM_TotalFree (void) +dword MM_TotalFree(mminfo_t *mm) { - unsigned free; - mmblocktype far *scan; + dword free; + mmblocktype huge *scan; free = 0; - scan = mmhead; + scan = 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*16l; + return free; } //========================================================================== @@ -1070,48 +1363,226 @@ long MM_TotalFree (void) /* ===================== = -= MM_BombOnError += MM_Report = ===================== */ -void MM_BombOnError (boolean bomb) +void MM_Report(/*page_t *page, */mminfo_t *mm, mminfotype *mmi) { - bombonerror = bomb; + 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); + } + 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); } -/////////////////////////////////////////////////////////////////////////// -// -// 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 += +===================== +*/ + +void MM_BombOnError(boolean bomb, mminfo_t *mm) +{ + mm->bombonerror = bomb; +} - for (i = 0;*strings && **strings;i++) +void MM_GetNewBlock(mminfo_t *mm) +{ + if(!mm->mmfree) + MML_ClearBlock(mm); + mm->mmnew=mm->mmfree; + mm->mmfree=mm->mmfree->next; + /*if(!(mm->mmnew=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!"); + return; } - return(-1); + mm->mmfree=mm->mmfree->next;*/ } +void MM_FreeBlock(mmblocktype *x, mminfo_t *mm) +{ + x->useptr=NULL; + x->next=mm->mmfree; + mm->mmfree=x; +} + +void MM_seguin(void) +{ + __asm { + push ds + mov ax,ds + inc ax + mov ds,ax + } +} + +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 +*/