-/* Catacomb Apocalypse Source Code
- * Copyright (C) 1993-2014 Flat Rock Software
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License along
- * with this program; if not, write to the Free Software Foundation, Inc.,
- * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
- */
-
-// NEWMM.C
-
-/*
-=============================================================================
-
- ID software memory manager
- --------------------------
-
-Primary coder: John Carmack
-
-RELIES ON
----------
-Quit (char *error) function
-
-
-WORK TO DO
-----------
-MM_SizePtr to change the size of a given pointer
-
-Multiple purge levels utilized
-
-EMS / XMS unmanaged routines
-
-=============================================================================
-*/
-/*
-
-Open Watcom port by sparky4
-
-*/
-#include "src/lib/16_mm.h"
-
-/*
-=============================================================================
-
- GLOBAL VARIABLES
-
-=============================================================================
-*/
-
-void (* beforesort) (void);
-void (* aftersort) (void);
-void (* XMSaddr) (void); // far pointer to XMS driver
-
-/*
-=============================================================================
-
- LOCAL VARIABLES
-
-=============================================================================
-*/
-
-static char *ParmStringsexmm[] = {"noems","noxms",""};
-
-/*
-======================
-=
-= MML_CheckForEMS
-=
-= Routine from p36 of Extending DOS
-=
-=======================
-*/
-
-boolean MML_CheckForEMS(void)
-{
- boolean emmcfems;
- static char emmname[] = "EMMXXXX0"; //fix by andrius4669
-// mov dx,OFFSET emmname
- __asm {
- //LEA DX, emmname //fix by andrius4669
- mov dx,OFFSET emmname //fix by andrius4669
- mov ax,0x3d00
- int 0x21 // try to open EMMXXXX0 device
- jc error
-
- mov bx,ax
- mov ax,0x4400
-
- int 0x21 // get device info
- jc error
-
- and dx,0x80
- jz error
-
- mov ax,0x4407
-
- int 0x21 // get status
- jc error
- or al,al
- jz error
-
- mov ah,0x3e
- int 0x21 // close handle
- jc error
- //
- // EMS is good
- //
- mov emmcfems,1
- jmp End
- error:
- //
- // EMS is bad
- //
- mov emmcfems,0
- End:
- }
- return(emmcfems);
-}
-
-
-/*
-======================
-=
-= MML_SetupEMS
-=
-=======================
-*/
-
-unsigned MML_SetupEMS(mminfo_t *mm)
-{
- char str[80],str2[10];
- unsigned 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
- {
- 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
-
- mov ah,EMS_GETFRAME
- int EMS_INT // find the page frame address
- or ah,ah
- jnz error
- mov [EMSpageframe],bx
-
- mov ah,EMS_GETPAGES
- int EMS_INT // find out how much EMS is there
- or ah,ah
- jnz error
- mov [totalEMSpages],dx
- 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
-
-getpages:
- mov [EMSpagesmapped],bx
- mov ah,EMS_ALLOCPAGES // allocate up to 64k of EMS
- int EMS_INT
- or ah,ah
- jnz error
- mov [EMShandle],dx
- jmp End
-error:
- mov errorflag,1
- jmp End
-noEMS:
-End:
- }
- if(errorflag==true)
- {
- err = CPURegs.h.ah;
- strcpy(str,"MML_SetupEMS: EMS error 0x");
- itoa(err,str2,16);
- strcpy(str,str2);
- 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;
-}
-
-
-/*
-======================
-=
-= MML_ShutdownEMS
-=
-=======================
-*/
-
-void MML_ShutdownEMS(mminfo_t *mm)
-{
- boolean errorflag=false;
- unsigned EMShandle=mm->EMShandle;
-
- if(!EMShandle)
- return;
- __asm
- {
- mov ah,EMS_FREEPAGES
- mov dx,[EMShandle]
- int EMS_INT
- or ah,ah
- jz ok
- mov errorflag,1
- ok:
- }
- if(errorflag==true) printf("MML_ShutdownEMS: Error freeing EMS!"); //++++ add something
-}
-
-/*
-====================
-=
-= MM_MapEMS
-=
-= Maps the 64k of EMS used by memory manager into the page frame
-= for general use. This only needs to be called if you are keeping
-= other things in EMS.
-=
-====================
-*/
-
-unsigned MM_MapEMS(mminfo_t *mm)
-{
- char str[80],str2[10];
- unsigned err, EMShandle;
- boolean errorflag=false;
- int i;
- union REGS CPURegs;
- EMShandle=mm->EMShandle;
-
- for (i=0;i<4/*mm->EMSpagesmapped*/;i++)
- {
- __asm
- {
- mov ah,EMS_MAPPAGE
- mov bx,[i] // logical page
- mov al,bl // physical page
- mov dx,[EMShandle] // handle
- int EMS_INT
- or ah,ah
- jnz error
- jmp End
- error:
- mov errorflag,1
- End:
- }
- if(errorflag==true)
- {
- err = CPURegs.h.ah;
- strcpy(str,"MM_MapEMS: EMS error 0x");
- itoa(err,str2,16);
- strcpy(str,str2);
- //printf("%s\n",str);
- printf("FACK! %u\n", err);
- return err;
- }
- }
- return 0;
-}
-
-/*
-SUB EMS.MapXPages (PhysicalStart, LogicalStart, NumPages, Handle)\r
-\r
- 'Maps up to 4 logical EMS pages to physical pages in the page frame, where:\r
- '\r
- 'PhysicalStart = Physical page first logical page is mapped to\r
- 'LogicalStart = First logical page to map\r
- 'NumPages = Number of pages to map (1 to 4)\r
- 'Handle = EMS handle logical pages are allocated to\r
-\r
- 'Create a buffer containing the page information\r
- FOR x = 0 TO NumPages - 1\r
- MapInfo$ = MapInfo$ + MKI$(LogicalStart + x) + MKI$(PhysicalStart + x)\r
- NEXT\r
-\r
- Regs.ax = &H5000 'Map the pages in the buffer\r
- Regs.cx = NumPages 'to the pageframe\r
- Regs.dx = Handle\r
- Regs.ds = VARSEG(MapInfo$)\r
- Regs.si = SADD(MapInfo$)\r
- InterruptX &H67, Regs, Regs\r
- EMS.Error = (Regs.ax AND &HFF00&) \ &H100 'Store the status code\r
-\r
-END SUB
-*/
-void MM_MapXEMS(mminfo_t *mm)
-{
-
-}
-
-//==========================================================================
-
-/*
-======================
-=
-= MML_CheckForXMS
-=
-= Check for XMM driver
-=
-=======================
-*/
-
-boolean MML_CheckForXMS(mminfo_t *mm)
-{
- boolean errorflag=false;
- mm->numUMBs = 0;
-
- __asm
- {
- mov ax,0x4300
- int 0x2f // query status of installed diver
- cmp al,0x80
- je good
- mov errorflag,1
- good:
- }
- if(errorflag==true) return false;
- else return true;
-}
-
-
-/*
-======================
-=
-= MML_SetupXMS
-=
-= Try to allocate all upper memory block
-=
-=======================
-*/
-
-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
-
- 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
-
- cmp bl,0xb0 // error: smaller UMB is available
- jne done;
-
- mov ah,XMS_ALLOCUMB
- call [DWORD PTR XMSaddr] // DX holds largest available UMB
- or ax,ax
- jz done // another error...
-
-gotone:
- mov [base],bx
- mov [size],dx
-done:
- }
- 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;
-}
-
-
-/*
-======================
-=
-= MML_ShutdownXMS
-=
-======================
-*/
-
-void MML_ShutdownXMS(mminfo_t *mm)
-{
- int i;
- unsigned base;
-
- for (i=0;i<mm->numUMBs;i++)
- {
- base = mm->UMBbase[i];
- __asm
- {
- mov ah,XMS_FREEUMB
- mov dx,[base]
- call [DWORD PTR XMSaddr]
- }
- }
-}
-
-//==========================================================================
-
-/*
-======================
-=
-= MML_UseSpace
-=
-= Marks a range of paragraphs as usable by the memory manager
-= This is used to mark space for the near heap, far heap, ems page frame,
-= and upper memory blocks
-=
-======================
-*/
-
-void MML_UseSpace(/*d*/word segstart, dword seglength, mminfo_t *mm)
-{
- mmblocktype huge *scan,huge *last;
- word segm;
- dword oldend;
- dword extra;
-
- 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)
- {
- 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);
-
-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
- MM_FreeBlock(scan, mm);
- scan = last;
- }
- else
- scan->length = segstart-scan->start; // shorten block
-
-// segm--;
-
- if(extra > 0)
- {
- MM_GetNewBlock(mm);
- mm->mmnew->next = scan->next;
- scan->next = mm->mmnew;
- mm->mmnew->start = segstart+seglength;
- mm->mmnew->length = extra;
- mm->mmnew->attributes = LOCKBIT;
- }//else if(segm>0) goto segu;
-
-}
-
-//==========================================================================
-
-/*
-====================
-=
-= MML_ClearBlock
-=
-= We are out of blocks, so free a purgable block
-=
-====================
-*/
-
-void MML_ClearBlock(mminfo_t *mm)
-{
- mmblocktype huge *scan,huge *last;
-
- scan = mm->mmhead->next;
-
- while(scan)
- {
- if(!(scan->attributes&LOCKBIT) && (scan->attributes&PURGEBITS))
- {
- MM_FreePtr(scan->useptr, mm);
- return;
- }
- scan = scan->next;
- }
-
- printf("MM_ClearBlock: No purgable blocks!\n");
-}
-
-
-//==========================================================================
-
-/*
-===================
-=
-= MM_Startup
-=
-= Grabs all space from turbo with malloc/farmalloc
-= Allocates bufferseg misc buffer
-=
-===================
-*/
-
-void MM_Startup(mminfo_t *mm, mminfotype *mmi)
-{
- int i;
- dword length;
- void huge *start;
- unsigned segstart,seglength,endfree;
-
- if(mm->mmstarted)
- MM_Shutdown(mm);
-
- mm->mmstarted = true;
- mm->bombonerror = true;
-//
-// set up the linked list (everything in the free list;
-//
- mm->mmhead = NULL;
- mm->mmfree = &(mm->mmblocks[0]);
- for(i=0;i<MAXBLOCKS-1;i++)
- {
- mm->mmblocks[i].next = &(mm->mmblocks[i+1]);
- }
- mm->mmblocks[i].next = NULL;
-
-//
-// locked block of all memory until we punch out free space
-//
- 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;
-
-// farlen=_bios_memsize()*1024;
-
-//
-// get all available near conventional memory segments
-//
-//---- length=coreleft();
- _nheapgrow();
- length=_memavl();
- 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, mm);
- mmi->nearheap = length;
- //printf("near heap ok!\n");
-
-//
-// get all available far conventional memory segments
-//
-//---- length=farcoreleft();
- _fheapgrow();
- length=_memavl();
- start = mm->farheap = halloc(length, sizeof(byte));
- //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, mm);
- mmi->farheap = length;
- mmi->mainmem = mmi->nearheap + mmi->farheap;
- //printf("far heap ok!\n");
-
-
-//
-// detect EMS and allocate up to 64K at page frame
-//
- printf("EMS!\n\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)
- goto emsskip; // param NOEMS
- }
- printf("\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"); //bug!
- if(MML_CheckForEMS())
- {
-printf("EMS1\n");
- MML_SetupEMS(mm); // allocate space
-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!
- //TODO: EMS4! AND EMS 3.2 MASSIVE DATA HANDLMENT!
- MML_UseSpace(mm->EMSpageframe,(MAPPAGES)*0x4000lu, mm);
-printf("EMS3\n");
- MM_MapEMS(mm); // map in used pages
-printf("EMS4\n");
- mmi->EMSmem = (MAPPAGES)*0x4000lu;
- }
-
-//
-// detect XMS and get upper memory blocks
-//
-emsskip:
- mmi->XMSmem = 0;
- for(i = 1;i < __argc;i++)
- {
- if(US_CheckParm(__argv[i],ParmStringsexmm) == 0)
- goto xmsskip; // param NOXMS
- }
- printf("\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"); //bug!
- if(MML_CheckForXMS(mm))
- {
- printf("XMS!\n");
- //MML_SetupXMS(mm, mmi); // allocate as many UMBs as possible
- }
-
-//
-// allocate the misc buffer
-//
-xmsskip:
- mm->mmrover = mm->mmhead; // start looking for space after low block
-
- MM_GetPtr(&(mm->bufferseg),BUFFERSIZE, mm, mmi);
-}
-
-//==========================================================================
-
-/*
-====================
-=
-= MM_Shutdown
-=
-= Frees all conventional, EMS, and XMS allocated
-=
-====================
-*/
-
-void MM_Shutdown(mminfo_t *mm)
-{
- if(!(mm->mmstarted))
- return;
-
- _ffree(mm->farheap);
- printf("far freed\n");
- free(mm->nearheap);
- printf("near freed\n");
- //hfree(mm->hugeheap);
- //printf("huge freed\n");
- if(MML_CheckForEMS()){ MML_ShutdownEMS(mm); printf("EMS freed\n"); }
- if(MML_CheckForXMS(mm)){ MML_ShutdownXMS(mm); printf("XMS freed\n"); }
-}
-
-//==========================================================================
-
-/*
-====================
-=
-= MM_GetPtr
-=
-= Allocates an unlocked, unpurgable block
-=
-====================
-*/
-
-void MM_GetPtr(memptr *baseptr,dword size, mminfo_t *mm, mminfotype *mmi)
-{
- 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
-
- 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++)
- {
- //
- // first search: try to allocate right after the rover, then on up
- // second search: search from the head pointer up to the rover
- // third search: compress memory, then scan from start
- if(search == 1 && mm->mmrover == mm->mmhead)
- search++;
-
- switch(search)
- {
- case 0:
- lastscan = mm->mmrover;
- scan = mm->mmrover->next;
- endscan = NULL;
- break;
- case 1:
- lastscan = mm->mmhead;
- scan = mm->mmhead->next;
- endscan = mm->mmrover;
- break;
- case 2:
- MM_SortMem(mm);
- lastscan = mm->mmhead;
- scan = 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 = mm->mmnew;
- mm->mmnew->start = *(unsigned *)baseptr = startseg;
- mm->mmnew->next = scan;
- while(purge != scan)
- { // free the purgable block
- next = purge->next;
- MM_FreeBlock(purge, mm);
- purge = next; // purge another if not at scan
- }
- mm->mmrover = 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 (mm->bombonerror)
- printf(OUT_OF_MEM_MSG,(size-mmi->nearheap));
- else
- mm->mmerror = true;
-}
-
-//==========================================================================
-
-/*
-====================
-=
-= MM_FreePtr
-=
-= Allocates an unlocked, unpurgable block
-=
-====================
-*/
-
-void MM_FreePtr(memptr *baseptr, mminfo_t *mm)
-{
- mmblocktype huge *scan,huge *last;
-
- last = mm->mmhead;
- scan = last->next;
-
- if(baseptr == mm->mmrover->useptr) // removed the last allocated block
- mm->mmrover = mm->mmhead;
-
- while(scan->useptr != baseptr && scan)
- {
- last = scan;
- scan = scan->next;
- }
-
- if(!scan)
- {
- printf("MM_FreePtr: Block not found!");
- return;
- }
-
- last->next = scan->next;
-
- MM_FreeBlock(scan, mm);
-}
-//==========================================================================
-
-/*
-=====================
-=
-= MM_SetPurge
-=
-= Sets the purge level for a block (locked blocks cannot be made purgable)
-=
-=====================
-*/
-
-void MM_SetPurge(memptr *baseptr, int purge, mminfo_t *mm)
-{
- mmblocktype huge *start;
-
- start = mm->mmrover;
-
- do
- {
- if(mm->mmrover->useptr == baseptr)
- break;
-
- mm->mmrover = mm->mmrover->next;
-
- if(!mm->mmrover)
- mm->mmrover = mm->mmhead;
- else if(mm->mmrover == start)
- {
- printf("MM_SetPurge: Block not found!");
- return;
- }
-
- } while(1);
-
- mm->mmrover->attributes &= ~PURGEBITS;
- mm->mmrover->attributes |= purge;
-}
-
-//==========================================================================
-
-/*
-=====================
-=
-= MM_SetLock
-=
-= Locks / unlocks the block
-=
-=====================
-*/
-
-void MM_SetLock(memptr *baseptr, boolean locked, mminfo_t *mm)
-{
- mmblocktype huge *start;
-
- start = mm->mmrover;
-
- do
- {
- if(mm->mmrover->useptr == baseptr)
- break;
-
- mm->mmrover = mm->mmrover->next;
-
- if(!mm->mmrover)
- mm->mmrover = mm->mmhead;
- else if(mm->mmrover == start)
- {
- printf("MM_SetLock: Block not found!");
- return;
- }
-
- } while(1);
-
- mm->mmrover->attributes &= ~LOCKBIT;
- mm->mmrover->attributes |= locked*LOCKBIT;
-}
-
-//==========================================================================
-
-/*
-=====================
-=
-= MM_SortMem
-=
-= Throws out all purgable stuff and compresses movable blocks
-=
-=====================
-*/
-
-void MM_SortMem(mminfo_t *mm)
-{
- mmblocktype huge *scan,huge *last,huge *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 = 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;
- MM_FreeBlock(scan, mm);
- 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
- }
-
- mm->mmrover = mm->mmhead;
-
- if(aftersort)
- aftersort();
-
-// VW_ColorBorder (oldborder);
-
-/*++++ if(playing)
- MM_SetLock(&(memptr)audiosegs[playing],false);*/
-}
-
-
-//==========================================================================
-
-//****#if 0
-/*
-=====================
-=
-= MM_ShowMemory
-=
-=====================
-*/
-
-void MM_ShowMemory(page_t *page, mminfo_t *mm)
-{
- mmblocktype huge *scan;
- unsigned color,temp;
- long end,owner;
- word chx,chy;
- char scratch[160],str[16];
-
-//**** VW_SetDefaultColors();
-//**** VW_SetLineWidth(40);
-//++++mh temp = bufferofs;
-//++++mh bufferofs = 0;
-//**** VW_SetScreen (0,0);
-
- scan = mm->mmhead;
-
- end = -1;
-
-CA_OpenDebug ();
-
- chx=0;
- chy=0;
-
- while(scan)
- {
- if(scan->attributes & PURGEBITS)
- color = 5; // dark purple = purgable
- else
- color = 9; // medium blue = non purgable
- if(scan->attributes & LOCKBIT)
- color = 12; // red = locked
- if(scan->start<=end)
- {
- //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;
- //modexhlin(page, scan->start, (unsigned)end, chy, color);
- modexClearRegion(page, scan->start, (unsigned)end, 4, 4, color);
-//++++ VW_Hlin(scan->start,(unsigned)end,0,color);
-
-//++++ VW_Plot(scan->start,0,15);
- //modexprint(page, scan->start, chy, 1, 47, 0, ((byte *)scan->start));
- modexClearRegion(page, scan->start, chy, 4, 4, 15);
- if(scan->next->start > end+1)
-//++++ VW_Hlin(end+1,scan->next->start,0,0); // black = free
- modexClearRegion(page, scan->next->start, end+1, 4, 4, 2);
- //modexhlin(page, end+1,scan->next->start, chy, 0);
-
-//****#if 0
-printf("\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"); //bug!
-strcpy(scratch,"Seg:");
-ultoa (scan->start,str,16);
-strcat (scratch,str);
-strcat (scratch,"\tSize:");
-ltoa ((dword)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));
-//modexprint(page, chx, chy, 1, 0, 24, &scratch);
-chy+=4;
-//fprintf(stdout, "%s", scratch);
-//****#endif
-
- scan = scan->next;
- }
-
-CA_CloseDebug ();
-
-//++++mh IN_Ack();
-//**** VW_SetLineWidth(64);
-//++++mh bufferofs = temp;
-}
-//****#endif
-
+/* Project 16 Source Code~\r
+ * Copyright (C) 2012-2017 sparky4 & pngwen & andrius4669 & joncampbell123 & yakui-lover\r
+ *\r
+ * This file is part of Project 16.\r
+ *\r
+ * Project 16 is free software; you can redistribute it and/or modify\r
+ * it under the terms of the GNU General Public License as published by\r
+ * the Free Software Foundation; either version 3 of the License, or\r
+ * (at your option) any later version.\r
+ *\r
+ * Project 16 is distributed in the hope that it will be useful,\r
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of\r
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\r
+ * GNU General Public License for more details.\r
+ *\r
+ * You should have received a copy of the GNU General Public License\r
+ * along with this program. If not, see <http://www.gnu.org/licenses/>, or\r
+ * write to the Free Software Foundation, Inc., 51 Franklin Street,\r
+ * Fifth Floor, Boston, MA 02110-1301 USA.\r
+ *\r
+ */\r
+\r
+// NEWMM.C\r
+\r
+/*\r
+=============================================================================\r
+\r
+ ID software memory manager\r
+ --------------------------\r
+\r
+Primary coder: John Carmack\r
+\r
+RELIES ON\r
+---------\r
+Quit (global_game_variables_t *gvar, char *error) function\r
+\r
+\r
+WORK TO DO\r
+----------\r
+MM_SizePtr to change the size of a given pointer\r
+\r
+Multiple purge levels utilized\r
+\r
+EMS / XMS unmanaged routines\r
+\r
+=============================================================================\r
+*/\r
+/*\r
+\r
+Open Watcom port by sparky4\r
+\r
+*/\r
+#include "src/lib/16_mm.h"\r
+#include "src/lib/16_ca.h"\r
+#include <malloc.h>\r
+#pragma hdrstop\r
+\r
+#pragma warn -pro\r
+#pragma warn -use\r
+\r
+/*\r
+=============================================================================\r
+\r
+ LOCAL INFO\r
+\r
+=============================================================================\r
+*/\r
+\r
+#define LOCKBIT 0x80 // if set in attributes, block cannot be moved\r
+#define PURGEBITS 3 // 0-3 level, 0= unpurgable, 3= purge first\r
+#define PURGEMASK 0xfffc\r
+#define BASEATTRIBUTES 0 // unlocked, non purgable\r
+\r
+//#define MAXUMBS 10\r
+\r
+/*typedef struct mmblockstruct\r
+{\r
+ unsigned start,length;\r
+ unsigned attributes;\r
+ memptr *useptr; // pointer to the segment start\r
+ struct mmblockstruct far *next;\r
+} mmblocktype;*/\r
+\r
+\r
+//#define GETNEWBLOCK {if(!(mmnew=mmfree))Quit("MM_GETNEWBLOCK: No free blocks!") ;mmfree=mmfree->next;}\r
+//\r
+\r
+#define GETNEWBLOCK {if(!gvar->mm.mmfree)MML_ClearBlock(gvar);gvar->mm.mmnew=gvar->mm.mmfree;gvar->mm.mmfree=gvar->mm.mmfree->next;}\r
+\r
+#define FREEBLOCK(x) {*x->useptr=NULL;x->next=gvar->mm.mmfree;gvar->mm.mmfree=x;}\r
+\r
+/*\r
+=============================================================================\r
+\r
+ GLOBAL VARIABLES\r
+\r
+=============================================================================\r
+*/\r
+\r
+/*mminfotype mminfo;\r
+memptr bufferseg;\r
+boolean mmerror;*/\r
+\r
+void (* beforesort) (void);\r
+void (* aftersort) (void);\r
+\r
+/*\r
+=============================================================================\r
+\r
+ LOCAL VARIABLES\r
+\r
+=============================================================================\r
+*/\r
+\r
+/*boolean mmstarted;\r
+\r
+void far *farheap;\r
+void *nearheap;\r
+\r
+mmblocktype far mmblocks[MAXBLOCKS]\r
+ ,far *mmhead,far *mmfree,far *mmrover,far *mmnew;\r
+\r
+boolean bombonerror;*/\r
+\r
+//unsigned totalEMSpages,freeEMSpages,EMSpageframe,EMSpagesmapped,EMShandle;\r
+\r
+void (* XMSaddr) (void); // far pointer to XMS driver\r
+\r
+/*unsigned numUMBs,UMBbase[MAXUMBS];*/\r
+\r
+//==========================================================================\r
+\r
+//\r
+// local prototypes\r
+//\r
+\r
+boolean MML_CheckForEMS (void);\r
+void MML_ShutdownEMS (void);\r
+void MM_MapEMS (void);\r
+boolean MML_CheckForXMS (void);\r
+void MML_ShutdownXMS (void);\r
+//void MML_UseSpace (unsigned segstart, unsigned seglength);\r
+//void MML_ClearBlock (void);\r
+\r
+//==========================================================================\r
+#ifndef __16_PM__\r
+#if 0\r
+static char *ParmStringsexmm[] = {"noems","noxms",""};\r
+#endif\r
+#endif\r
+/*\r
+======================\r
+=\r
+= MML_CheckForEMS\r
+=\r
+= Routine from p36 of Extending DOS\r
+=\r
+=======================\r
+*/\r
+\r
+boolean MML_CheckForEMS(void)\r
+{\r
+ boolean emmcfems = false;\r
+ word EMSPageFrame = 0;\r
+ byte err=0, str[64];\r
+ static char emmname[] = "EMMXXXX0"; //fix by andrius4669\r
+ __asm {\r
+ mov dx,OFFSET emmname //fix by andrius4669\r
+ mov ax,0x3d00\r
+ int EMM_INT // try to open EMMXXXX0 device\r
+ jc error\r
+\r
+ mov bx,ax\r
+ mov ax,0x4400\r
+\r
+ int EMM_INT // get device info\r
+ jc error\r
+\r
+ and dx,0x80\r
+ jz error\r
+\r
+ mov ax,0x4407\r
+\r
+ int EMM_INT // get status\r
+ jc error\r
+ or al,al\r
+ jz error\r
+\r
+ mov ah,0x3e\r
+ int EMM_INT // close handle\r
+ jc error\r
+\r
+ //\r
+ // pageframe check\r
+ //\r
+ mov ah,EMS_GETFRAME\r
+ int EMS_INT // find the page frame address\r
+ or ah,ah\r
+ jnz error\r
+ mov [EMSPageFrame],bx\r
+\r
+ //\r
+ // EMS is good\r
+ //\r
+ mov emmcfems,1\r
+ jmp End\r
+#ifdef __BORLANDC__\r
+ }\r
+#endif\r
+ error:\r
+#ifdef __BORLANDC__\r
+ __asm {\r
+#endif\r
+ //\r
+ // EMS is bad\r
+ //\r
+ mov err,ah\r
+ mov emmcfems,0\r
+#ifdef __BORLANDC__\r
+ }\r
+#endif\r
+ End:\r
+#ifdef __WATCOMC__\r
+ }\r
+#endif\r
+\r
+ //\r
+ // Pageframe switch to determine if there is one!\r
+ //\r
+ if(!EMSPageFrame)\r
+ {\r
+ emmcfems = false;\r
+#if defined(__DEBUG_PM__) || defined(__DEBUG_MM__)\r
+ printf("MML_CheckForEMS: EMS error No Pageframe!\nAddress detected to be %04x\n", EMSPageFrame);\r
+#endif\r
+ }else if(!emmcfems)// if there is an error and page frame is not 0000\r
+ {\r
+ strcpy(str,"MML_CheckForEMS: EMS error ");\r
+ MM_EMSerr(str, err);\r
+ printf("%s\n",str);\r
+ }\r
+\r
+ return(emmcfems);\r
+}\r
+\r
+#ifndef __16_PM__\r
+#if 0\r
+/*\r
+======================\r
+=\r
+= MML_SetupEMS\r
+=\r
+=======================\r
+*/\r
+\r
+byte MML_SetupEMS(global_game_variables_t *gvar)\r
+{\r
+ byte str[160];\r
+ byte err;\r
+ boolean errorflag=false;\r
+\r
+ unsigned int EMSVer = 0;\r
+ //byte EMS_status;\r
+ unsigned totalEMSpages,freeEMSpages,EMSPageFrame,EMSpagesmapped,EMSHandle;\r
+ totalEMSpages = freeEMSpages = EMSPageFrame = EMSpagesmapped = 0;\r
+\r
+ __asm {\r
+ mov ah,EMS_STATUS\r
+ int EMS_INT // make sure EMS hardware is present\r
+ or ah,ah\r
+ //mov [EMS_status],ah\r
+ jnz error\r
+\r
+ mov ah,EMS_VERSION\r
+ int EMS_INT\r
+ or ah,ah\r
+ jnz error\r
+ mov [EMSVer],ax // set EMSVer\r
+ cmp al,0x32 // only work on ems 3.2 or greater\r
+ jb error\r
+\r
+ mov ah,EMS_GETFRAME\r
+ int EMS_INT // find the page frame address\r
+ or ah,ah\r
+ jnz error\r
+ mov [EMSPageFrame],bx\r
+\r
+ mov ah,EMS_GETPAGES\r
+ int EMS_INT // find out how much EMS is there\r
+ or ah,ah\r
+ jnz error\r
+ mov [totalEMSpages],dx\r
+ mov [freeEMSpages],bx\r
+ or bx,bx\r
+ jz noEMS // no EMS at all to allocate\r
+ //EXPAND DONG!!!!\r
+ cmp [EMSVer],0x40\r
+ jb low\r
+ cmp bx,[freeEMSpages]\r
+ jle getpages\r
+ mov bx,[freeEMSpages]\r
+ jmp getpages\r
+#ifdef __BORLANDC__\r
+ }\r
+#endif\r
+ low:\r
+#ifdef __BORLANDC__\r
+ __asm {\r
+#endif\r
+ cmp bx,4\r
+ jle getpages // there is only 1,2,3,or 4 pages\r
+ mov bx,4 // we can't use more than 4 pages\r
+#ifdef __BORLANDC__\r
+ }\r
+#endif\r
+ getpages:\r
+#ifdef __BORLANDC__\r
+ __asm {\r
+#endif\r
+ mov [EMSpagesmapped],bx\r
+ mov ah,EMS_ALLOCPAGES // allocate up to 64k of EMS\r
+ int EMS_INT\r
+ or ah,ah\r
+ jnz error\r
+ mov [EMSHandle],dx\r
+ jmp End\r
+#ifdef __BORLANDC__\r
+ }\r
+#endif\r
+ error:\r
+#ifdef __BORLANDC__\r
+ __asm {\r
+#endif\r
+ mov err,ah\r
+ mov errorflag,1\r
+ jmp End\r
+#ifdef __BORLANDC__\r
+ }\r
+#endif\r
+noEMS:\r
+End:\r
+#ifdef __WATCOMC__\r
+ }\r
+#endif\r
+ if(errorflag==true)\r
+ {\r
+ strcpy(str,"MM_SetupEMS: EMS error ");\r
+ MM_EMSerr(str, err);\r
+ printf("%s\n",str);\r
+ return err;\r
+ }\r
+ gvar->mm.totalEMSpages=totalEMSpages;\r
+ gvar->mm.freeEMSpages=freeEMSpages;\r
+ gvar->mm.EMSPageFrame=EMSPageFrame;\r
+ gvar->mm.EMSpagesmapped=EMSpagesmapped;\r
+ gvar->mm.EMSHandle=EMSHandle;\r
+ gvar->mm.EMSVer=EMSVer;\r
+ return 0;\r
+}\r
+\r
+\r
+/*\r
+======================\r
+=\r
+= MML_ShutdownEMS\r
+=\r
+=======================\r
+*/\r
+\r
+void MML_ShutdownEMS(global_game_variables_t *gvar)\r
+{\r
+ boolean errorflag=false;\r
+ unsigned EMSHandle=gvar->mm.EMSHandle;\r
+\r
+ if(!EMSHandle)\r
+ return;\r
+ __asm {\r
+ mov ah,EMS_FREEPAGES\r
+ mov dx,[EMSHandle]\r
+ int EMS_INT\r
+ or ah,ah\r
+ jz ok\r
+ mov errorflag,1\r
+#ifdef __BORLANDC__\r
+ }\r
+#endif\r
+ ok:\r
+#ifdef __WATCOMC__\r
+ }\r
+#endif\r
+ if(errorflag==true)\r
+ Quit (gvar, "MML_ShutdownEMS: Error freeing EMS!\n"); //++++ add something\r
+}\r
+\r
+/*\r
+====================\r
+=\r
+= MM_MapEMS\r
+=\r
+= Maps the 64k of EMS used by memory manager into the page frame\r
+= for general use. This only needs to be called if you are keeping\r
+= other things in EMS.\r
+=\r
+====================\r
+*/\r
+\r
+byte MM_MapEMS(global_game_variables_t *gvar)\r
+{\r
+ byte str[160];\r
+ unsigned EMSHandle;\r
+ byte err;\r
+ boolean errorflag=false;\r
+ int i;\r
+ EMSHandle=gvar->mm.EMSHandle;\r
+\r
+ for (i=0;i<4/*MAPPAGES*/;i++)\r
+ {\r
+ __asm {\r
+ mov ah,EMS_MAPPAGE\r
+ mov bx,[i] // logical page\r
+ mov al,bl // physical page\r
+ mov dx,[EMSHandle] // handle\r
+ int EMS_INT\r
+ or ah,ah\r
+ jnz error\r
+ jmp End\r
+#ifdef __BORLANDC__\r
+ }\r
+#endif\r
+ error:\r
+#ifdef __BORLANDC__\r
+ __asm {\r
+#endif\r
+ mov err,ah\r
+ mov errorflag,1\r
+#ifdef __BORLANDC__\r
+ }\r
+#endif\r
+ End:\r
+#ifdef __WATCOMC__\r
+ }\r
+#endif\r
+ if(errorflag==true)\r
+ {\r
+ strcpy(str,"MM_MapEMS: EMS error ");\r
+ MM_EMSerr(str, err);\r
+ printf("%s\n",str);\r
+ return err;\r
+ }\r
+ }\r
+ gvar->mmi.EMSmem = (i)*0x4000lu;\r
+ return 0;\r
+}\r
+\r
+byte MM_MapXEMS(global_game_variables_t *gvar)\r
+{\r
+//SUB EMS.MapXPages (PhysicalStart, LogicalStart, NumPages, Handle)\r
+\r
+ //Maps up to 4 logical EMS pages to physical pages in the page frame, where:\r
+ //PhysicalStart = Physical page first logical page is mapped to\r
+ //LogicalStart = First logical page to map\r
+ //NumPages = Number of pages to map (1 to 4)\r
+ //Handle = EMS handle logical pages are allocated to\r
+\r
+ /*//Create a buffer containing the page information\r
+// FOR x = 0 TO NumPages - 1\r
+// MapInfo$ = MapInfo$ + MKI$(LogicalStart + x) + MKI$(PhysicalStart + x)\r
+// NEXT*/\r
+\r
+// Regs.ax = 0x5000 //Map the pages in the buffer\r
+// Regs.cx = NumPages //to the pageframe\r
+// Regs.dx = Handle\r
+// Regs.ds = VARSEG(MapInfo$)\r
+// Regs.si = SADD(MapInfo$)\r
+// InterruptX 0x67, Regs, Regs\r
+// EMS.Error = (Regs.ax AND 0xFF00&) \ 0x100 //Store the status code\r
+\r
+//END SUB\r
+ byte str[160];\r
+ byte err;\r
+ word EMSHandle;\r
+ boolean errorflag=false;\r
+ int i;\r
+ EMSHandle=gvar->mm.EMSHandle;\r
+\r
+ if(gvar->mm.EMSVer<0x40)\r
+ return 5;\r
+\r
+ for (i=0;i<MAPPAGES;i++)\r
+ {\r
+ __asm {\r
+ mov ah,EMS_MAPXPAGE\r
+ mov cx,[i] // logical page\r
+ mov al,bl // physical page\r
+ mov dx,[EMSHandle] // handle\r
+ int EMS_INT\r
+ or ah,ah\r
+ jnz error\r
+ jmp End\r
+#ifdef __BORLANDC__\r
+ }\r
+#endif\r
+ error:\r
+#ifdef __BORLANDC__\r
+ __asm {\r
+#endif\r
+ mov err,ah\r
+ mov errorflag,1\r
+#ifdef __BORLANDC__\r
+ }\r
+#endif\r
+ End:\r
+#ifdef __WATCOMC__\r
+ }\r
+#endif\r
+ if(errorflag==true)\r
+ {\r
+ //strcpy(str,"MM_MapXEMS: EMS error 0x");\r
+ strcpy(str,"MM_MapXEMS: EMS error ");\r
+ //itoa(err,str2,16);\r
+ MM_EMSerr(str, err);\r
+ printf("%s\n",str);\r
+ //printf("%s%x\n",str, err);\r
+ //printf("FACK! %x\n", err);\r
+ return err;\r
+ }\r
+ }\r
+ gvar->mmi.EMSmem = (i)*0x4000lu;\r
+ return 0;\r
+}\r
+#endif\r
+#endif\r
+//==========================================================================\r
+\r
+/*\r
+======================\r
+=\r
+= MML_CheckForXMS\r
+=\r
+= Check for XMM driver\r
+=\r
+=======================\r
+*/\r
+\r
+boolean MML_CheckForXMS(void)\r
+{\r
+ //numUMBs = 0;\r
+ boolean errorflag=false;\r
+\r
+ __asm {\r
+ mov ax,0x4300\r
+ int 0x2f // query status of installed diver\r
+ cmp al,0x80\r
+ je good\r
+ mov errorflag,1\r
+#ifdef __BORLANDC__\r
+ }\r
+#endif\r
+ good:\r
+#ifdef __WATCOMC__\r
+ }\r
+#endif\r
+ if(errorflag==true) return false;\r
+ else return true;\r
+}\r
+\r
+#ifndef __16_PM__\r
+#if 0\r
+/*\r
+======================\r
+=\r
+= MML_SetupXMS\r
+=\r
+= Try to allocate all upper memory block\r
+=\r
+=======================\r
+*/\r
+\r
+void MML_SetupXMS(global_game_variables_t *gvar)\r
+{\r
+ word base,size;\r
+\r
+\r
+ __asm {\r
+ mov ax,0x4310\r
+ int 0x2f\r
+ mov [WORD PTR XMSaddr],bx\r
+ mov [WORD PTR XMSaddr+2],es // function pointer to XMS driver\r
+ }\r
+getmemory:\r
+ __asm {\r
+ mov ah,XMS_ALLOCUMB\r
+ mov dx,0xffff // try for largest block possible\r
+ //mov ax,dx // Set available Kbytes.\r
+ call [DWORD PTR XMSaddr]\r
+ or ax,ax\r
+ jnz gotone\r
+\r
+ cmp bl,0xb0 // error: smaller UMB is available\r
+ jne done;\r
+\r
+ mov ah,XMS_ALLOCUMB\r
+ call [DWORD PTR XMSaddr] // DX holds largest available UMB\r
+ or ax,ax\r
+ jz done // another error...\r
+#ifdef __BORLANDC__\r
+ }\r
+#endif\r
+ gotone:\r
+#ifdef __BORLANDC__\r
+ __asm {\r
+#endif\r
+ mov [base],bx\r
+ mov [size],dx\r
+#ifdef __BORLANDC__\r
+ }\r
+#endif\r
+ done:\r
+#ifdef __WATCOMC__\r
+ }\r
+#endif\r
+// printf("base=%u ", base); printf("size=%u\n", size);\r
+ MML_UseSpace(base,size, gvar);\r
+ gvar->mmi.XMSmem += size*16;\r
+ gvar->mm.UMBbase[gvar->mm.numUMBs] = base;\r
+ gvar->mm.numUMBs++;\r
+ if(gvar->mm.numUMBs < MAXUMBS)\r
+ goto getmemory;\r
+}\r
+\r
+\r
+/*\r
+======================\r
+=\r
+= MML_ShutdownXMS\r
+=\r
+======================\r
+*/\r
+\r
+void MML_ShutdownXMS(global_game_variables_t *gvar)\r
+{\r
+ int i;\r
+ unsigned base;\r
+\r
+ for (i=0;i<gvar->mm.numUMBs;i++)\r
+ {\r
+ base = gvar->mm.UMBbase[i];\r
+ __asm {\r
+ mov ah,XMS_FREEUMB\r
+ mov dx,[base]\r
+ call [DWORD PTR XMSaddr]\r
+ }\r
+ }\r
+}\r
+#endif\r
+#endif\r
+//==========================================================================\r
+\r
+/*\r
+======================\r
+=\r
+= MML_UseSpace\r
+=\r
+= Marks a range of paragraphs as usable by the memory manager\r
+= This is used to mark space for the near heap, far heap, ems page frame,\r
+= and upper memory blocks\r
+=\r
+======================\r
+*/\r
+\r
+/*\r
+ extra = oldend - (segstart+seglength);\r
+\r
+ segmlen=extra;\r
+\r
+ //++++emsver stuff!\r
+ if(segm>1)/// || extra>=0x10000lu)\r
+ //if(extra>0xfffflu)\r
+ {\r
+ scan->blob=segm;\r
+\r
+ //MML_UseSpace(segstart, seglength, gvar);\r
+\r
+ printf("MML_UseSpace: Segment spans two blocks!\n");\r
+ //}\r
+ printf("segm=%u ", segm);\r
+ printf("ex=%lu ", extra);\r
+ printf("old=%u ", oldend);\r
+ printf("start+seglen=%lu\n", segstart+seglength);\r
+ printf("segsta=%x ", segstart);\r
+ printf("len=%lu ", scan->length);\r
+ printf("seglen=%lu ", seglength);\r
+ printf("segmlen=%lu\n", segmlen);\r
+ }\r
+//++++todo: linked list of segment!\r
+*/\r
+void MML_UseSpace (unsigned segstart, unsigned seglength, global_game_variables_t *gvar)\r
+{\r
+ mmblocktype far *scan,far *last;\r
+ unsigned oldend;\r
+ sdword extra;\r
+ //word segm=1;\r
+\r
+ scan = last = gvar->mm.mmhead;\r
+ gvar->mm.mmrover = gvar->mm.mmhead; // reset rover to start of memory\r
+\r
+//\r
+// search for the block that contains the range of segments\r
+//\r
+ while (scan->start+scan->length < segstart)\r
+ {\r
+ last = scan;\r
+ scan = scan->next;\r
+ }\r
+\r
+//\r
+// find out how many blocks it spans!\r
+//\r
+ /*for(;seglength>=0x10000;seglength-=0xFFFF)\r
+ {\r
+ //printf(" seglen=%lu\n", segmlen);\r
+ segm++;\r
+ }*/\r
+\r
+//\r
+// take the given range out of the block\r
+//\r
+ oldend = scan->start + scan->length;\r
+ extra = oldend - (segstart+seglength);\r
+ if (extra < 0)\r
+#ifdef __DEBUG_MM__\r
+ {\r
+ printf("========================================\n");\r
+ printf("start=%x ", scan->start);\r
+ printf("old=%u ", oldend);\r
+ printf("start+seglen=%lu\n", segstart+seglength);\r
+ printf("segsta=%x ", segstart);\r
+ printf("len=%lu ", scan->length);\r
+ printf("seglen=%lu ", seglength);\r
+ printf("\n");\r
+ printf("MML_UseSpace: Segment spans two blocks! %d\n", extra);\r
+ printf("========================================\n");\r
+ //return;\r
+ }\r
+#else\r
+ Quit (gvar, "MML_UseSpace: Segment spans two blocks!");\r
+#endif\r
+\r
+ if (segstart == scan->start)\r
+ {\r
+ last->next = scan->next; // unlink block\r
+ FREEBLOCK(scan);\r
+ scan = last;\r
+ }\r
+ else\r
+ scan->length = segstart-scan->start; // shorten block\r
+\r
+ if (extra > 0)\r
+ {\r
+ GETNEWBLOCK;\r
+ gvar->mm.mmnew->useptr = NULL;\r
+\r
+ gvar->mm.mmnew->next = scan->next;\r
+ scan->next = gvar->mm.mmnew;\r
+ gvar->mm.mmnew->start = segstart+seglength;\r
+ gvar->mm.mmnew->length = extra;\r
+ gvar->mm.mmnew->attributes = LOCKBIT;\r
+ }//else if(segm>0) goto segu;\r
+\r
+}\r
+\r
+//==========================================================================\r
+\r
+/*\r
+====================\r
+=\r
+= MML_ClearBlock\r
+=\r
+= We are out of blocks, so free a purgable block\r
+=\r
+====================\r
+*/\r
+\r
+void MML_ClearBlock (global_game_variables_t *gvar)\r
+{\r
+ mmblocktype far *scan;//,far *last;\r
+\r
+ scan = gvar->mm.mmhead->next;\r
+\r
+ while(scan)\r
+ {\r
+ if(!(scan->attributes&LOCKBIT) && (scan->attributes&PURGEBITS) )\r
+ {\r
+ MM_FreePtr (scan->useptr, gvar);\r
+ return;\r
+ }\r
+ scan = scan->next;\r
+ }\r
+\r
+ Quit (gvar, "MM_ClearBlock: No purgable blocks!\n");\r
+}\r
+\r
+\r
+//==========================================================================\r
+\r
+/*\r
+===================\r
+=\r
+= MM_Reset\r
+=\r
+===================\r
+*/\r
+\r
+void MM_Reset (global_game_variables_t *gvar)\r
+{\r
+// //has to be 16\r
+// if(sizeof(mmblocktype)!=16)\r
+// return;\r
+\r
+#ifdef __BORLANDC__\r
+ strcpy(gvar->handle.datadumpfilename, "mmdump.16b");\r
+#endif\r
+#ifdef __WATCOMC__\r
+ strcpy(gvar->handle.datadumpfilename, "mmdump.16w");\r
+#endif\r
+\r
+#ifdef __BORLANDC__\r
+ strcpy(gvar->handle.heapdumpfilename, "heap.16b");\r
+#endif\r
+#ifdef __WATCOMC__\r
+ strcpy(gvar->handle.heapdumpfilename, "heap.16w");\r
+#endif\r
+}\r
+\r
+\r
+//==========================================================================\r
+\r
+/*\r
+===================\r
+=\r
+= MM_Startup\r
+=\r
+= Grabs all space from turbo with malloc/farmalloc\r
+= Allocates bufferseg misc buffer\r
+=\r
+===================\r
+*/\r
+\r
+void MM_Startup (global_game_variables_t *gvar)\r
+{\r
+ int i;\r
+ unsigned long length;\r
+ void far *start;\r
+ unsigned segstart,seglength;//,endfree;\r
+\r
+ if(gvar->mm.mmstarted)\r
+ MM_Shutdown (gvar);\r
+\r
+ MM_Reset (gvar);\r
+ gvar->mm.mmstarted = true;\r
+ gvar->mm.bombonerror = true;\r
+//\r
+// set up the linked list (everything in the free list;\r
+//\r
+ gvar->mm.mmhead = NULL;\r
+ gvar->mm.mmfree = &(gvar->mm.mmblocks[0]);\r
+ for (i=0;i<MAXBLOCKS-1;i++)\r
+ gvar->mm.mmblocks[i].next = &(gvar->mm.mmblocks[i+1]);\r
+ gvar->mm.mmblocks[i].next = NULL;\r
+\r
+//\r
+// locked block of all memory until we punch out free space\r
+//\r
+ GETNEWBLOCK;\r
+ gvar->mm.mmhead = gvar->mm.mmnew; // this will allways be the first node\r
+ gvar->mm.mmnew->start = 0;\r
+ gvar->mm.mmnew->length = 0xffff;\r
+ gvar->mm.mmnew->attributes = LOCKBIT;\r
+ gvar->mm.mmnew->next = NULL;\r
+ gvar->mm.mmrover = gvar->mm.mmhead;\r
+\r
+\r
+//\r
+// get all available near conventional memory segments\r
+//\r
+ length=(word)coreleft();\r
+ start = (void far *)(gvar->mm.nearheap = _nmalloc(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, gvar);\r
+ gvar->mmi.nearheap = length;\r
+ //0000printf("near: start=%Fp segstart=%x seglen=%lu len=%lu\n", start, segstart, (dword)seglength, length);\r
+//\r
+// get all available far conventional memory segments\r
+//\r
+ length=farcoreleft();\r
+ start = gvar->mm.farheap = farmalloc(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, gvar);\r
+ gvar->mmi.farheap = length;\r
+ gvar->mmi.mainmem = gvar->mmi.nearheap + gvar->mmi.farheap;\r
+ //0000printf("far: start=%Fp segstart=%x seglen=%lu len=%lu\n", start, segstart, (dword)seglength, length);\r
+#if !defined(__16_PM__)// && defined(__WATCOMC__)\r
+#if 0\r
+ if(!dbg_debugpm) {\r
+//\r
+// detect EMS and allocate up to 64K at page frame\r
+//\r
+ gvar->mmi.EMSmem = 0;\r
+//goto emsskip; //0000\r
+ for(i = 1;i < _argc;i++)\r
+ {\r
+ if(US_CheckParm(_argv[i],ParmStringsexmm) == 0)\r
+ goto emsskip; // param NOEMS\r
+ }\r
+ if(MML_CheckForEMS())\r
+ {\r
+ MML_SetupEMS(gvar); // allocate space\r
+ //16_PM: EMS4! AND EMS 3.2 MASSIVE DATA HANDLMENT!\r
+ MML_UseSpace(gvar->mm.EMSPageFrame,(MAPPAGES)*0x4000lu, gvar);\r
+ //if(gvar->pm.emm.EMSVer<0x40)\r
+ MM_MapEMS(gvar); // map in used pages\r
+ //else\r
+ //MM_MapXEMS(gvar); // map in used pages\r
+ }\r
+\r
+//\r
+// detect XMS and get upper memory blocks\r
+//\r
+emsskip:\r
+ gvar->mmi.XMSmem = 0;\r
+goto xmsskip;//0000\r
+ for(i = 1;i < _argc;i++)\r
+ {\r
+ if(US_CheckParm( _argv[i],ParmStringsexmm) == 0)\r
+ goto xmsskip; // param NOXMS\r
+ }\r
+ if(MML_CheckForXMS())\r
+ {\r
+ MML_SetupXMS(gvar); // allocate as many UMBs as possible\r
+ }\r
+\r
+ }\r
+xmsskip:\r
+#endif\r
+#endif\r
+//\r
+// allocate the misc buffer\r
+//\r
+ gvar->mm.mmrover = gvar->mm.mmhead; // start looking for space after low block\r
+\r
+ MM_GetPtr (&(gvar->mm.bufferseg),BUFFERSIZE, gvar);\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 (global_game_variables_t *gvar)\r
+{\r
+ if(!(gvar->mm.mmstarted))\r
+ return;\r
+\r
+ _ffree(gvar->mm.farheap);// printf(" far freed\n");\r
+ _nfree(gvar->mm.nearheap);// printf(" near freed\n");\r
+#ifndef __16_PM__\r
+#if 0\r
+#ifdef __DEBUG__\r
+ if(!dbg_debugpm) {\r
+#endif\r
+ if(MML_CheckForEMS()){ MML_ShutdownEMS(gvar); }//printf(" EMS freed\n"); }\r
+ if(MML_CheckForXMS()){ MML_ShutdownXMS(gvar); }//printf(" XMS freed\n"); }\r
+#ifdef __DEBUG__\r
+ }\r
+#endif\r
+#endif\r
+#endif\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, global_game_variables_t *gvar)\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
+ GETNEWBLOCK; // fill in start and next after a spot is found\r
+ gvar->mm.mmnew->length = needed;\r
+ gvar->mm.mmnew->useptr = baseptr;\r
+ gvar->mm.mmnew->attributes = BASEATTRIBUTES;\r
+ //if(gvar->mm.mmnew->useptr==NULL){\r
+#ifdef __DEBUG_MM__\r
+ if(dbg_debugmm>0){\r
+ printf("===============================================================================\n");\r
+ printf(" MM_GetPtr\n");\r
+ printf("===============================================================================\n");\r
+ //%04x\r
+// printf(" baseptr=%Fp ", baseptr); printf("useptr=%Fp\n", gvar->mm.mmnew->useptr);\r
+// //printf(" *baseptr=%Fp ", *baseptr); printf("*useptr=%Fp\n", *(gvar->mm.mmnew->useptr));\r
+// printf(" &baseptr=%Fp ", &baseptr); printf("&useptr=%Fp\n", &(gvar->mm.mmnew->useptr));\r
+\r
+ printf(" baseptr=%04x ", baseptr); printf("useptr=%04x\n", gvar->mm.mmnew->useptr);\r
+ //printf(" *baseptr=%04x ", *baseptr); printf("*useptr=%04x\n", *(gvar->mm.mmnew->useptr));\r
+ printf(" &baseptr=%04u ", &baseptr); printf("&useptr=%04u\n", &(gvar->mm.mmnew->useptr));\r
+\r
+ printf(" size is %lu\n", size);\r
+ }\r
+#endif\r
+ //Quit (gvar, "gvar->mm.mmnew->useptr==NULL"); }\r
+\r
+//tryagain:\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 && gvar->mm.mmrover == gvar->mm.mmhead)\r
+ search++;\r
+\r
+ switch (search)\r
+ {\r
+ case 0:\r
+ lastscan = gvar->mm.mmrover;\r
+ scan = gvar->mm.mmrover->next;\r
+ endscan = NULL;\r
+ break;\r
+ case 1:\r
+ lastscan = gvar->mm.mmhead;\r
+ scan = gvar->mm.mmhead->next;\r
+ endscan = gvar->mm.mmrover;\r
+ break;\r
+ case 2:\r
+ MM_SortMem (gvar);\r
+ lastscan = gvar->mm.mmhead;\r
+ scan = gvar->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 = gvar->mm.mmnew;\r
+ gvar->mm.mmnew->start = *(unsigned *)baseptr = startseg;\r
+ gvar->mm.mmnew->next = scan;\r
+ while ( purge != scan)\r
+ { // free the purgable block\r
+ next = purge->next;\r
+ FREEBLOCK(purge);\r
+ purge = next; // purge another if not at scan\r
+ }\r
+ gvar->mm.mmrover = gvar->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 (gvar->mm.bombonerror)\r
+ {\r
+#ifdef __WATCOMC__\r
+ //heapdump();\r
+#endif\r
+ printf(OUT_OF_MEM_MSG,(size-gvar->mmi.nearheap));\r
+ Quit (gvar, "for stability reasons the program will shut down! wwww\n");\r
+ }\r
+ else\r
+ gvar->mm.mmerror = true;\r
+}\r
+\r
+//==========================================================================\r
+\r
+/*\r
+====================\r
+=\r
+= MM_FreePtr\r
+=\r
+= Deallocates an unlocked, purgable block\r
+=\r
+====================\r
+*/\r
+\r
+void MM_FreePtr (memptr *baseptr, global_game_variables_t *gvar)\r
+{\r
+ mmblocktype far *scan,far *last;\r
+\r
+ last = gvar->mm.mmhead;\r
+ scan = last->next;\r
+\r
+ if (baseptr == gvar->mm.mmrover->useptr) // removed the last allocated block\r
+ gvar->mm.mmrover = gvar->mm.mmhead;\r
+\r
+ while (scan->useptr != baseptr && scan)\r
+ {\r
+ last = scan;\r
+ scan = scan->next;\r
+ }\r
+\r
+ if (!scan)\r
+ Quit (gvar, "MM_FreePtr: Block not found!");\r
+\r
+ last->next = scan->next;\r
+\r
+ FREEBLOCK(scan);\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, global_game_variables_t *gvar)\r
+{\r
+ mmblocktype far *start;\r
+\r
+ start = gvar->mm.mmrover;\r
+\r
+ do\r
+ {\r
+ if (gvar->mm.mmrover->useptr == baseptr)\r
+ break;\r
+\r
+ gvar->mm.mmrover = gvar->mm.mmrover->next;\r
+\r
+ if (!gvar->mm.mmrover)\r
+ gvar->mm.mmrover = gvar->mm.mmhead;\r
+ else if (gvar->mm.mmrover == start)\r
+ Quit (gvar, "MM_SetPurge: Block not found!");\r
+\r
+ } while (1);\r
+\r
+ gvar->mm.mmrover->attributes &= ~PURGEBITS;\r
+ gvar->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, global_game_variables_t *gvar)\r
+{\r
+ mmblocktype far *start;\r
+\r
+ start = gvar->mm.mmrover;\r
+\r
+ do\r
+ {\r
+ if (gvar->mm.mmrover->useptr == baseptr)\r
+ break;\r
+\r
+ gvar->mm.mmrover = gvar->mm.mmrover->next;\r
+\r
+ if (!gvar->mm.mmrover)\r
+ gvar->mm.mmrover = gvar->mm.mmhead;\r
+ else if (gvar->mm.mmrover == start)\r
+ Quit (gvar, "MM_SetLock: Block not found!");\r
+\r
+ } while(1);\r
+\r
+ gvar->mm.mmrover->attributes &= ~LOCKBIT;\r
+ gvar->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 (global_game_variables_t *gvar)\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(MEMPTRCONV audiosegs[playing],true);\r
+ }\r
+\r
+\r
+ SD_StopSound();*/\r
+#ifdef __WATCOMC__\r
+ oldborder = gvar->video.bordercolor;\r
+ gvar->video.bordercolor = VL_modexPalOverscan(gvar->video.palette, 4);\r
+#endif\r
+\r
+ if (beforesort)\r
+ beforesort();\r
+\r
+ scan = gvar->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
+ FREEBLOCK(scan); //MM_FreeBlock(scan, gvar);\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
+ gvar->mm.mmrover = gvar->mm.mmhead;\r
+\r
+ if (aftersort)\r
+ aftersort();\r
+\r
+ VL_ColorBorder (oldborder, &gvar->video);\r
+\r
+/*++++ if(playing)\r
+ MM_SetLock((memptr *)&audiosegs[playing],false);*/\r
+}\r
+\r
+//==========================================================================\r
+\r
+#ifdef __BORLANDC__\r
+extern char global_temp_status_text[512];\r
+extern char global_temp_status_text2[512];\r
+#endif\r
+#ifdef __WATCOMC__\r
+//#define MMSMPANVID\r
+#define MMSMSCANINFO\r
+#endif\r
+\r
+/*\r
+=====================\r
+=\r
+= MM_ShowMemory\r
+=\r
+=====================\r
+*/\r
+\r
+\r
+void MM_ShowMemory (global_game_variables_t *gvar)\r
+{\r
+ mmblocktype far *scan;\r
+ unsigned color,temp,x,y ,w,width;\r
+ sdword end,owner;\r
+ byte scratch[160],scratch0[4096],str[16];\r
+#ifdef MMSMSCANINFO\r
+ mmshowmemoryinfo_t scaninfo[MAXBLOCKS];\r
+ byte scratch1[4];\r
+ unsigned xpos,ypos, oldq,q,maxq;\r
+ boolean done,restarted;\r
+ ScanCode scancode;\r
+#endif\r
+\r
+ if(!gvar->video.page[0].width) gvar->video.page[0].sw = gvar->video.page[0].width = 320; //to prevent division by 0\r
+//-- VL_SetLineWidth(40, gvar);\r
+ //temp = gvar->video.ofs.bufferofs;\r
+ //gvar->video.ofs.bufferofs = gvar->video.ofs.displayofs;\r
+ temp = BDOFSCONV gvar->video.BOFS;\r
+ gvar->video.BOFS = gvar->video.DOFS;\r
+#ifdef MMSMSCANINFO\r
+ oldq = 0; restarted = false;\r
+reset:\r
+ q = 0;\r
+#endif\r
+ scan = gvar->mm.mmhead;\r
+\r
+ end = -1; w = 0;\r
+\r
+ width = gvar->video.page[0].width;\r
+\r
+ CA_OpenDebug (gvar);\r
+ while (scan)\r
+ {\r
+#ifdef MMSMSCANINFO\r
+ scaninfo[q].scan = scan;\r
+#endif\r
+ strcpy(scratch, AARESET);\r
+ if(scan->attributes & PURGEBITS)\r
+ {\r
+ color = 6; // dark purple = purgable\r
+ strcpy(scratch0, AAMAGENTA); // dark purple = purgable\r
+ }else{\r
+ color = 2; // medium blue = non purgable\r
+ strcpy(scratch0, AABLUE); // medium blue = non purgable\r
+ }\r
+ if(scan->attributes & LOCKBIT)\r
+ {\r
+ color = 1; // red = locked\r
+ strcpy(scratch0, AARED); // red = locked\r
+ }\r
+ if (scan->start<=end)\r
+ {\r
+ printf("\nend==%d\n\n", end);\r
+ strcat(scratch, "MM_ShowMemory: Memory block order currupted!\n");\r
+ strcat(scratch, "End's Size: "); ultoa (end,str,10); strcat (scratch,str);\r
+ strcat(scratch, "\nscan->start's Size: "); ultoa (scan->start,str,10); strcat (scratch,str);\r
+ write(gvar->handle.debughandle,scratch,strlen(scratch));\r
+ Quit (gvar, "MM_ShowMemory: Memory block order currupted!");\r
+ }\r
+ end = scan->length-1;\r
+ y = scan->start/width;\r
+ x = scan->start%width;\r
+#ifdef MMSMSCANINFO\r
+ if(restarted){\r
+ y += gvar->video.page[0].dy;\r
+ x += gvar->video.page[0].dx;\r
+ }\r
+#if 0\r
+ else{\r
+ scaninfo[q].y = y;\r
+ scaninfo[q].x = x;\r
+ }\r
+#endif\r
+#endif\r
+ VW_Hlin(x,x+end,y,color,gvar);\r
+ VL_Plot(x,y,5,gvar);\r
+//++==++==optional strcat(scratch0, AARESET); strcat(scratch0, AAGREY); strcat(scratch0,"_");\r
+ for(w=(scan->start)/80;w<=end/80;w++)\r
+ {\r
+//printf("+ %u %lu\n", w, scan->length);\r
+ strcat(scratch0, "+");\r
+ }\r
+\r
+ if (scan->next && scan->next->start > end+1)\r
+ {\r
+ VW_Hlin(x+end+1,x+(scan->next->start-scan->start),y,3,gvar); // black = free//now green\r
+ strcat(scratch0, AARESET);\r
+//++==++==optional strcat(scratch0, "\n");\r
+ strcat(scratch0,AAGREEN);\r
+ for(w=(end+1)/80;w<=((scan->next->start-scan->start)/80);w++)\r
+ {\r
+//printf("0 %x %u %lu\n", scan->next->start, w, scan->length);\r
+ strcat(scratch0,"0");\r
+ }\r
+ //printf("==================\n");\r
+ //printf("w=%u start=%04x next=%04x end=%lu\n", w/80, scan->start, (scan->next->start), end+1);\r
+ //printf("==================\n");\r
+ strcat(scratch0, "\n");\r
+ }\r
+#if 0\r
+ else {//if(scan->next->start <= scan->start){\r
+ scan->next->start=scan->start+0x1000;\r
+ strcat(scratch0, AARESET);\r
+ strcat(scratch0, "\n");\r
+ strcat(scratch0,AAGREEN);\r
+ for(w=(end+1);w<=(0x1000/80);w++)\r
+ {\r
+ //printf("0 %x %x %u\n", scan->start, w);\r
+ strcat(scratch0,"0");\r
+ }\r
+ printf("================\n");\r
+ printf("w=%x start=%x next=%x end=%u\n", w, scan->start, (scan->next->start), end+1);\r
+ printf("================\n");\r
+ getch();\r
+ }\r
+#endif\r
+ strcat(scratch0, AARESET);\r
+ //strcat(scratch0,"\n");\r
+ strcat(scratch,"Seg:");\r
+ ultoa (scan->start,str,16);\r
+ strcat (scratch,str);\r
+// strcat(scratch, AABLACK); strcat(scratch,"\t"); strcat(scratch, AARESET);\r
+ strcat (scratch,"\tSize:");\r
+ ultoa ((unsigned)scan->length,str,10);\r
+ strcat (scratch,str);\r
+// strcat(scratch, AABLACK); strcat(scratch,"\t"); strcat(scratch, AARESET);\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(gvar->handle.debughandle,scratch,strlen(scratch));\r
+ write(gvar->handle.debughandle,scratch0,strlen(scratch0));\r
+//0000fprintf(stdout, "\n[%s]", scratch);\r
+//0000fprintf(stdout, "[\n%s\n]", scratch0);\r
+//0000fprintf(stdout, "[%u]\n", q);\r
+\r
+ scan = scan->next;\r
+#ifdef MMSMSCANINFO\r
+ q++;\r
+#endif\r
+//0000if(q==1 && gvar->video.VL_Started && color!=6) IN_Ack(gvar);\r
+ }\r
+\r
+ CA_CloseDebug (gvar);\r
+\r
+#if 0\r
+//def MMSMPANVID\r
+ {\r
+ int dx,dy,odx,ody;\r
+ odx = gvar->video.page[0].dx;\r
+ ody = gvar->video.page[0].dy;\r
+ dx = dy = 0;\r
+ while(!gvar->in.inst->Keyboard[sc_Escape] && !gvar->in.inst->Keyboard[sc_Space])\r
+ {\r
+ if(gvar->in.inst->Keyboard[sc_UpArrow])\r
+ {\r
+ if(dy>0)\r
+ dy--;\r
+ }\r
+ else if(gvar->in.inst->Keyboard[sc_DownArrow])\r
+ {\r
+ if(dy<gvar->video.page[0].height-gvar->video.page[0].sh)\r
+ dy++;\r
+ }\r
+ if(gvar->in.inst->Keyboard[sc_LeftArrow])\r
+ {\r
+ if(dx>0)\r
+ dx--;\r
+ }\r
+ else if(gvar->in.inst->Keyboard[sc_RightArrow])\r
+ {\r
+ if(dx<gvar->video.page[0].width-gvar->video.page[0].sw)\r
+ dx++;\r
+ }\r
+\r
+ modexPanPage(&gvar->video.page[0], dx, dy);\r
+ VL_ShowPage(&gvar->video.page[0], 1, 1);\r
+ }\r
+\r
+ gvar->video.page[0].dx = odx;\r
+ gvar->video.page[0].dy = ody;\r
+ }\r
+#endif\r
+#ifdef MMSMSCANINFO\r
+//#define MMSMSCANINFOXYPOSNEW\r
+//{\r
+ maxq = q;\r
+ if(restarted) q = oldq;\r
+ else q = 0;\r
+ restarted = false;\r
+\r
+ IN_Ack(gvar);\r
+// VL_ClearVideo (8);\r
+ for (done = false;!done;)\r
+ {\r
+ if(scaninfo[q].scan->attributes & PURGEBITS)\r
+ {\r
+ color = 6; // dark purple = purgable\r
+ strcpy(scratch1, AAMAGENTA); // dark purple = purgable\r
+ //printf("%s", AAMAGENTA);\r
+ }else{\r
+ color = 2; // medium blue = non purgable\r
+ strcpy(scratch1, AABLUE); // medium blue = non purgable\r
+ //printf("%s", AABLUE);\r
+ }\r
+ if(scaninfo[q].scan->attributes & LOCKBIT)\r
+ {\r
+ color = 1; // red = locked\r
+ strcpy(scratch1, AARED); // red = locked\r
+ //printf("%s", AARED);\r
+ }\r
+ end = scaninfo[q].scan->length-1;\r
+//modexprint(page, x, y, t, tlsw, color, bgcolor, vidsw, const byte *str);\r
+#define MMSMPRINTMEMINFO modexprint(&(gvar->video.page[0]), xpos, ypos, 1, 1, color, 8, gvar->video.VL_Started, global_temp_status_text); ypos+=8;\r
+#ifdef __WATCOMC__\r
+ if(gvar->video.VL_Started)\r
+ {\r
+ VL_ShowPage(&gvar->video.page[0], 1, 0);\r
+ modexClearRegion(&gvar->video.page[0], 0, 0, gvar->video.page[0].width, gvar->video.page[0].height, 8);\r
+ }else\r
+#endif\r
+ clrscr();\r
+ sprintf(global_temp_status_text, "block #%04u", q); MMSMPRINTMEMINFO\r
+// sprintf(global_temp_status_text, "%Fp", scaninfo[q].scan->useptr); MMSMPRINTMEMINFO\r
+ sprintf(global_temp_status_text, "start: %04x", (unsigned)scaninfo[q].scan->start); MMSMPRINTMEMINFO\r
+ sprintf(global_temp_status_text, "useptr: %04x", (unsigned)scaninfo[q].scan->useptr); MMSMPRINTMEMINFO\r
+ sprintf(global_temp_status_text, "size: %05u", (unsigned)scaninfo[q].scan->length); MMSMPRINTMEMINFO\r
+ if (scaninfo[q].scan->next && scaninfo[q].scan->next->start > end+1)\r
+ {\r
+ sprintf(global_temp_status_text, "free: %05u", (unsigned)(scaninfo[q].scan->next->start-scaninfo[q].scan->start)); MMSMPRINTMEMINFO\r
+ }else ypos+=8;\r
+ if(gvar->video.VL_Started)\r
+ {\r
+ y = scaninfo[q].scan->start/width;\r
+ x = scaninfo[q].scan->start%width;\r
+#ifndef MMSMSCANINFOXYPOSNEW\r
+ y = ypos;\r
+ x = xpos;\r
+#else\r
+ //y = scaninfo[q].y;\r
+ //x = scaninfo[q].x;\r
+ y += gvar->video.page[0].dy;\r
+ x += gvar->video.page[0].dx;\r
+#endif\r
+ VW_Hlin(x,x+end,y,color,gvar);\r
+ VL_Plot(x,y,5,gvar);\r
+ }\r
+ else\r
+ {\r
+ printf("%s", scratch1);\r
+ printf("%s", AAGREY); printf("_");\r
+ if(scaninfo[q].scan->length<64000)\r
+ for(w=(scaninfo[q].scan->start)/80;w<=end/80;w++)\r
+ {\r
+ //strcat(scratch1, "+");\r
+ printf("+");\r
+ }\r
+ }\r
+\r
+\r
+ if (scaninfo[q].scan->next && scaninfo[q].scan->next->start > end+1) if(!gvar->video.VL_Started)\r
+ {\r
+ //strcat(scratch1, AARESET);\r
+ printf("%s", AARESET);\r
+ //strcat(scratch1,AAGREEN);\r
+ printf("%s", AAGREEN);\r
+ for(w=(end+1)/80;w<=((scaninfo[q].scan->next->start-scaninfo[q].scan->start)/80);w++)\r
+ {\r
+ //strcat(scratch1,"0");\r
+ printf("0");\r
+ }\r
+ }else VW_Hlin(x+end+1,x+(scaninfo[q].scan->next->start-scaninfo[q].scan->start),y,3,gvar); // black = free//now green\r
+\r
+\r
+ if(gvar->video.VL_Started)\r
+ {\r
+ //if (scan->next && scan->next->start > end+1) free\r
+ xpos = gvar->video.page[0].dx;\r
+ ypos = gvar->video.page[0].dy;//(gvar->video.page[0].sh-(32));//8*4\r
+ }\r
+ else\r
+ {\r
+ //printf("%s\n", scratch1);\r
+ printf("%s", AARESET);\r
+ printf("\n");\r
+ }\r
+\r
+\r
+ while (!(scancode = gvar->in.inst->LastScan)){}\r
+\r
+ IN_ClearKey(scancode);\r
+ switch (scancode)\r
+ {\r
+ case sc_LeftArrow:\r
+ if(q>0) q--;\r
+ else q = maxq;\r
+ break;\r
+ case sc_RightArrow:\r
+ if(q<maxq) q++;\r
+ else q = 0;\r
+ break;\r
+ case sc_UpArrow:\r
+ if(q>10) q-=10;\r
+ else q = maxq;\r
+ break;\r
+ case sc_DownArrow:\r
+ if(q<maxq+10) q+=10;\r
+ else q = 0;\r
+ break;\r
+ case sc_Space:\r
+// scan = gvar->mm.mmhead;\r
+// x = gvar->video.page[0].dx;\r
+// y = gvar->video.page[0].dy;//(gvar->video.page[0].sh-(32));//8*4\r
+ oldq = q;\r
+ restarted = true;\r
+ goto reset;\r
+ break;\r
+ case sc_Escape:\r
+ done = true;\r
+ break;\r
+ }\r
+ }\r
+//}\r
+// MM_ShowMemoryDetail (x, y, w, q, end, &scaninfo, gvar);\r
+#endif\r
+\r
+\r
+//?? if(gvar->video.VL_Started) IN_Ack(gvar);\r
+\r
+ gvar->video.BOFS = (byte __far *)temp;\r
+}\r
+\r
+#if 0\r
+//def MMSMSCANINFO\r
+void MM_ShowMemoryDetail (unsigned x, unsigned y, unsigned w, unsigned q, sdword end, mmshowmemoryinfo_t *scaninfo, global_game_variables_t *gvar)\r
+ {\r
+ byte scratch1[4];\r
+ unsigned maxq = q;\r
+ boolean done;\r
+ ScanCode scancode;\r
+ int xpos,ypos;\r
+ word ccolor = 3;\r
+ IN_Ack(gvar);\r
+// VL_ClearVideo (8);\r
+ for (q = 0,done = false;!done;)\r
+ {\r
+ if(scaninfo[q].scan->attributes & PURGEBITS)\r
+ {\r
+ ccolor = 6; // dark purple = purgable\r
+ strcpy(scratch1, AAMAGENTA); // dark purple = purgable\r
+ //printf("%s", AAMAGENTA);\r
+ }else{\r
+ ccolor = 2; // medium blue = non purgable\r
+ strcpy(scratch1, AABLUE); // medium blue = non purgable\r
+ //printf("%s", AABLUE);\r
+ }\r
+ if(scaninfo[q].scan->attributes & LOCKBIT)\r
+ {\r
+ ccolor = 1; // red = locked\r
+ strcpy(scratch1, AARED); // red = locked\r
+ //printf("%s", AARED);\r
+ }\r
+ end = scaninfo[q].scan->length-1;\r
+//modexprint(page, x, y, t, tlsw, color, bgcolor, vidsw, const byte *str);\r
+#define MMSMPRINTMEMINFO modexprint(&(gvar->video.page[0]), xpos, ypos, 1, 1, ccolor, 8, gvar->video.VL_Started, global_temp_status_text); ypos+=8;\r
+#ifdef __WATCOMC__\r
+ if(gvar->video.VL_Started)\r
+ {\r
+ VL_ShowPage(&gvar->video.page[0], 1, 0);\r
+ modexClearRegion(&gvar->video.page[0], 0, 0, gvar->video.page[0].width, gvar->video.page[0].height, 8);\r
+ }else\r
+#endif\r
+ clrscr();\r
+ sprintf(global_temp_status_text, "block #%04u", q); MMSMPRINTMEMINFO\r
+// sprintf(global_temp_status_text, "%Fp", scaninfo[q].scan->useptr); MMSMPRINTMEMINFO\r
+ sprintf(global_temp_status_text, "start: %04x", (unsigned)scaninfo[q].scan->start); MMSMPRINTMEMINFO\r
+ sprintf(global_temp_status_text, "useptr: %04x", (unsigned)scaninfo[q].scan->useptr); MMSMPRINTMEMINFO\r
+ sprintf(global_temp_status_text, "size: %05u", (unsigned)scaninfo[q].scan->length); MMSMPRINTMEMINFO\r
+ if (scaninfo[q].scan->next && scaninfo[q].scan->next->start > end+1)\r
+ {\r
+ sprintf(global_temp_status_text, "free: %05u", (unsigned)(scaninfo[q].scan->next->start-scaninfo[q].scan->start)); MMSMPRINTMEMINFO\r
+ }\r
+ if(gvar->video.VL_Started)\r
+ {\r
+ y = ypos;//scaninfo[q].scan->start/width;\r
+ x = xpos;//scaninfo[q].scan->start%width;\r
+ VW_Hlin(x,x+end,y,ccolor,gvar);\r
+ VL_Plot(x,y,5,gvar);\r
+ }\r
+ else\r
+ {\r
+ printf("%s", scratch1);\r
+ printf("%s", AAGREY); printf("_");\r
+ if(scaninfo[q].scan->length<64000)\r
+ for(w=(scaninfo[q].scan->start)/80;w<=end/80;w++)\r
+ {\r
+ //strcat(scratch1, "+");\r
+ printf("+");\r
+ }\r
+ }\r
+\r
+\r
+ if (scaninfo[q].scan->next && scaninfo[q].scan->next->start > end+1) if(!gvar->video.VL_Started)\r
+ {\r
+ //strcat(scratch1, AARESET);\r
+ printf("%s", AARESET);\r
+ //strcat(scratch1,AAGREEN);\r
+ printf("%s", AAGREEN);\r
+ for(w=(end+1)/80;w<=((scaninfo[q].scan->next->start-scaninfo[q].scan->start)/80);w++)\r
+ {\r
+ //strcat(scratch1,"0");\r
+ printf("0");\r
+ }\r
+ }else VW_Hlin(x+end+1,x+(scaninfo[q].scan->next->start-scaninfo[q].scan->start),y,3,gvar); // black = free//now green\r
+\r
+\r
+ if(gvar->video.VL_Started)\r
+ {\r
+ //if (scan->next && scan->next->start > end+1) free\r
+ xpos = gvar->video.page[0].dx;\r
+ ypos = gvar->video.page[0].dy;//(gvar->video.page[0].sh-(32));//8*4\r
+ }\r
+ else\r
+ {\r
+ //printf("%s\n", scratch1);\r
+ printf("%s", AARESET);\r
+ printf("\n");\r
+ }\r
+//0000printf("%s", AABLACK); fprintf(stdout, "q=%u maxq=%u\n", q, maxq); printf("%s", AARESET);\r
+//fprintf(stdout, ""); //this is a HAX to make it decrement and increment properly when it is at 0 and qmax\r
+ while (!(scancode = gvar->in.inst->LastScan)){}\r
+\r
+ IN_ClearKey(scancode);\r
+ switch (scancode)\r
+ {\r
+ case sc_LeftArrow:\r
+ if(q>0) q--;\r
+ else q = maxq;\r
+ break;\r
+ case sc_RightArrow:\r
+ if(q<maxq) q++;\r
+ else q = 0;\r
+ break;\r
+ case sc_UpArrow:\r
+ if(q>10) q-=10;\r
+ else q = maxq;\r
+ break;\r
+ case sc_DownArrow:\r
+ if(q<maxq+10) q+=10;\r
+ else q = 0;\r
+ break;\r
+ case sc_Escape:\r
+ done = true;\r
+ break;\r
+ }\r
+ }\r
+ }\r
+#endif\r
+\r