]> 4ch.mooo.com Git - 16.git/blob - 16/ID_MM.C
added the vgmtools scource
[16.git] / 16 / ID_MM.C
1 /* Catacomb Armageddon Source Code\r
2  * Copyright (C) 1993-2014 Flat Rock Software\r
3  *\r
4  * This program is free software; you can redistribute it and/or modify\r
5  * it under the terms of the GNU General Public License as published by\r
6  * the Free Software Foundation; either version 2 of the License, or\r
7  * (at your option) any later version.\r
8  *\r
9  * This program is distributed in the hope that it will be useful,\r
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of\r
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\r
12  * GNU General Public License for more details.\r
13  *\r
14  * You should have received a copy of the GNU General Public License along\r
15  * with this program; if not, write to the Free Software Foundation, Inc.,\r
16  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.\r
17  */\r
18 \r
19 // NEWMM.C\r
20 \r
21 /*\r
22 =============================================================================\r
23 \r
24                         ID software memory manager\r
25                         --------------------------\r
26 \r
27 Primary coder: John Carmack\r
28 \r
29 RELIES ON\r
30 ---------\r
31 Quit (char *error) function\r
32 \r
33 \r
34 WORK TO DO\r
35 ----------\r
36 MM_SizePtr to change the size of a given pointer\r
37 \r
38 Multiple purge levels utilized\r
39 \r
40 EMS / XMS unmanaged routines\r
41 \r
42 =============================================================================\r
43 */\r
44 \r
45 #include "ID_HEADS.H"\r
46 #pragma hdrstop\r
47 \r
48 #pragma warn -pro\r
49 #pragma warn -use\r
50 \r
51 \r
52 #if 0           // 1 == Debug/Dev  ;  0 == Production/final\r
53 \r
54 #define OUT_OF_MEM_MSG  "MM_GetPtr: Out of memory!\nYou were short :%ld bytes"\r
55 \r
56 #else\r
57 \r
58 \r
59 #define OUT_OF_MEM_MSG  "\n"                                                                          \\r
60                                                                 "You need more memory to run CATACOMB ARMAGEDDON.  Read the INSTRUCTION\n"   \\r
61                                                                 "section of the START program for tips on getting more memory.\n"\r
62 #endif\r
63 \r
64 \r
65 /*\r
66 =============================================================================\r
67 \r
68                                                         LOCAL INFO\r
69 \r
70 =============================================================================\r
71 */\r
72 \r
73 #define LOCKBIT         0x80    // if set in attributes, block cannot be moved\r
74 #define PURGEBITS       3               // 0-3 level, 0= unpurgable, 3= purge first\r
75 #define PURGEMASK       0xfffc\r
76 #define BASEATTRIBUTES  0       // unlocked, non purgable\r
77 \r
78 #define MAXUMBS         10\r
79 \r
80 typedef struct mmblockstruct\r
81 {\r
82         unsigned        start,length;\r
83         unsigned        attributes;\r
84         memptr          *useptr;        // pointer to the segment start\r
85         struct mmblockstruct far *next;\r
86 } mmblocktype;\r
87 \r
88 \r
89 //#define GETNEWBLOCK {if(!(mmnew=mmfree))Quit("MM_GETNEWBLOCK: No free blocks!")\\r
90 //      ;mmfree=mmfree->next;}\r
91 \r
92 #define GETNEWBLOCK {if(!mmfree)MML_ClearBlock();mmnew=mmfree;mmfree=mmfree->next;}\r
93 \r
94 #define FREEBLOCK(x) {*x->useptr=NULL;x->next=mmfree;mmfree=x;}\r
95 \r
96 /*\r
97 =============================================================================\r
98 \r
99                                                  GLOBAL VARIABLES\r
100 \r
101 =============================================================================\r
102 */\r
103 \r
104 mminfotype      mminfo;\r
105 memptr          bufferseg;\r
106 boolean         mmerror;\r
107 \r
108 void            (* beforesort) (void);\r
109 void            (* aftersort) (void);\r
110 \r
111 /*\r
112 =============================================================================\r
113 \r
114                                                  LOCAL VARIABLES\r
115 \r
116 =============================================================================\r
117 */\r
118 \r
119 boolean         mmstarted;\r
120 \r
121 void far        *farheap;\r
122 void            *nearheap;\r
123 \r
124 mmblocktype     far mmblocks[MAXBLOCKS]\r
125                         ,far *mmhead,far *mmfree,far *mmrover,far *mmnew;\r
126 \r
127 boolean         bombonerror;\r
128 \r
129 unsigned        totalEMSpages,freeEMSpages,EMSpageframe,EMSpagesmapped,EMShandle;\r
130 \r
131 void            (* XMSaddr) (void);             // far pointer to XMS driver\r
132 \r
133 unsigned        numUMBs,UMBbase[MAXUMBS];\r
134 \r
135 //==========================================================================\r
136 \r
137 //\r
138 // local prototypes\r
139 //\r
140 \r
141 boolean         MML_CheckForEMS (void);\r
142 void            MML_ShutdownEMS (void);\r
143 void            MM_MapEMS (void);\r
144 boolean         MML_CheckForXMS (void);\r
145 void            MML_ShutdownXMS (void);\r
146 void            MML_UseSpace (unsigned segstart, unsigned seglength);\r
147 void            MML_ClearBlock (void);\r
148 \r
149 //==========================================================================\r
150 \r
151 /*\r
152 ======================\r
153 =\r
154 = MML_CheckForEMS\r
155 =\r
156 = Routine from p36 of Extending DOS\r
157 =\r
158 =======================\r
159 */\r
160 \r
161 char    emmname[9] = "EMMXXXX0";\r
162 \r
163 boolean MML_CheckForEMS (void)\r
164 {\r
165 asm     mov     dx,OFFSET emmname[0]\r
166 asm     mov     ax,0x3d00\r
167 asm     int     0x21            // try to open EMMXXXX0 device\r
168 asm     jc      error\r
169 \r
170 asm     mov     bx,ax\r
171 asm     mov     ax,0x4400\r
172 \r
173 asm     int     0x21            // get device info\r
174 asm     jc      error\r
175 \r
176 asm     and     dx,0x80\r
177 asm     jz      error\r
178 \r
179 asm     mov     ax,0x4407\r
180 \r
181 asm     int     0x21            // get status\r
182 asm     jc      error\r
183 asm     or      al,al\r
184 asm     jz      error\r
185 \r
186 asm     mov     ah,0x3e\r
187 asm     int     0x21            // close handle\r
188 asm     jc      error\r
189 \r
190 //\r
191 // EMS is good\r
192 //\r
193   return true;\r
194 \r
195 error:\r
196 //\r
197 // EMS is bad\r
198 //\r
199   return false;\r
200 }\r
201 \r
202 \r
203 /*\r
204 ======================\r
205 =\r
206 = MML_SetupEMS\r
207 =\r
208 =======================\r
209 */\r
210 \r
211 void MML_SetupEMS (void)\r
212 {\r
213         char    str[80],str2[10];\r
214         unsigned        error;\r
215 \r
216         totalEMSpages = freeEMSpages = EMSpageframe = EMSpagesmapped = 0;\r
217 \r
218 asm {\r
219         mov     ah,EMS_STATUS\r
220         int     EMS_INT                                         // make sure EMS hardware is present\r
221         or      ah,ah\r
222         jnz     error\r
223 \r
224         mov     ah,EMS_VERSION\r
225         int     EMS_INT\r
226         or      ah,ah\r
227         jnz     error\r
228         cmp     al,0x32                                         // only work on ems 3.2 or greater\r
229         jb      error\r
230 \r
231         mov     ah,EMS_GETFRAME\r
232         int     EMS_INT                                         // find the page frame address\r
233         or      ah,ah\r
234         jnz     error\r
235         mov     [EMSpageframe],bx\r
236 \r
237         mov     ah,EMS_GETPAGES\r
238         int     EMS_INT                                         // find out how much EMS is there\r
239         or      ah,ah\r
240         jnz     error\r
241         mov     [totalEMSpages],dx\r
242         mov     [freeEMSpages],bx\r
243         or      bx,bx\r
244         jz      noEMS                                           // no EMS at all to allocate\r
245 \r
246         cmp     bx,4\r
247         jle     getpages                                        // there is only 1,2,3,or 4 pages\r
248         mov     bx,4                                            // we can't use more than 4 pages\r
249         }\r
250 \r
251 getpages:\r
252 asm {\r
253         mov     [EMSpagesmapped],bx\r
254         mov     ah,EMS_ALLOCPAGES                       // allocate up to 64k of EMS\r
255         int     EMS_INT\r
256         or      ah,ah\r
257         jnz     error\r
258         mov     [EMShandle],dx\r
259         }\r
260         return;\r
261 \r
262 error:\r
263         error = _AH;\r
264         strcpy (str,"MML_SetupEMS: EMS error 0x");\r
265         itoa(error,str2,16);\r
266         strcpy (str,str2);\r
267         Quit (str);\r
268 \r
269 noEMS:\r
270 ;\r
271 }\r
272 \r
273 \r
274 /*\r
275 ======================\r
276 =\r
277 = MML_ShutdownEMS\r
278 =\r
279 =======================\r
280 */\r
281 \r
282 void MML_ShutdownEMS (void)\r
283 {\r
284         if (!EMShandle)\r
285                 return;\r
286 \r
287 asm     {\r
288         mov     ah,EMS_FREEPAGES\r
289         mov     dx,[EMShandle]\r
290         int     EMS_INT\r
291         or      ah,ah\r
292         jz      ok\r
293         }\r
294 \r
295         Quit ("MML_ShutdownEMS: Error freeing EMS!");\r
296 \r
297 ok:\r
298 ;\r
299 }\r
300 \r
301 /*\r
302 ====================\r
303 =\r
304 = MM_MapEMS\r
305 =\r
306 = Maps the 64k of EMS used by memory manager into the page frame\r
307 = for general use.  This only needs to be called if you are keeping\r
308 = other things in EMS.\r
309 =\r
310 ====================\r
311 */\r
312 \r
313 void MM_MapEMS (void)\r
314 {\r
315         char    str[80],str2[10];\r
316         unsigned        error;\r
317         int     i;\r
318 \r
319         for (i=0;i<EMSpagesmapped;i++)\r
320         {\r
321         asm     {\r
322                 mov     ah,EMS_MAPPAGE\r
323                 mov     bx,[i]                  // logical page\r
324                 mov     al,bl                   // physical page\r
325                 mov     dx,[EMShandle]  // handle\r
326                 int     EMS_INT\r
327                 or      ah,ah\r
328                 jnz     error\r
329                 }\r
330         }\r
331 \r
332         return;\r
333 \r
334 error:\r
335         error = _AH;\r
336         strcpy (str,"MM_MapEMS: EMS error 0x");\r
337         itoa(error,str2,16);\r
338         strcpy (str,str2);\r
339         Quit (str);\r
340 }\r
341 \r
342 //==========================================================================\r
343 \r
344 /*\r
345 ======================\r
346 =\r
347 = MML_CheckForXMS\r
348 =\r
349 = Check for XMM driver\r
350 =\r
351 =======================\r
352 */\r
353 \r
354 boolean MML_CheckForXMS (void)\r
355 {\r
356         numUMBs = 0;\r
357 \r
358 asm {\r
359         mov     ax,0x4300\r
360         int     0x2f                            // query status of installed diver\r
361         cmp     al,0x80\r
362         je      good\r
363         }\r
364         return false;\r
365 good:\r
366         return true;\r
367 }\r
368 \r
369 \r
370 /*\r
371 ======================\r
372 =\r
373 = MML_SetupXMS\r
374 =\r
375 = Try to allocate all upper memory block\r
376 =\r
377 =======================\r
378 */\r
379 \r
380 void MML_SetupXMS (void)\r
381 {\r
382         unsigned        base,size;\r
383 \r
384 asm     {\r
385         mov     ax,0x4310\r
386         int     0x2f\r
387         mov     [WORD PTR XMSaddr],bx\r
388         mov     [WORD PTR XMSaddr+2],es         // function pointer to XMS driver\r
389         }\r
390 \r
391 getmemory:\r
392 asm     {\r
393         mov     ah,XMS_ALLOCUMB\r
394         mov     dx,0xffff                                       // try for largest block possible\r
395         call    [DWORD PTR XMSaddr]\r
396         or      ax,ax\r
397         jnz     gotone\r
398 \r
399         cmp     bl,0xb0                                         // error: smaller UMB is available\r
400         jne     done;\r
401 \r
402         mov     ah,XMS_ALLOCUMB\r
403         call    [DWORD PTR XMSaddr]             // DX holds largest available UMB\r
404         or      ax,ax\r
405         jz      done                                            // another error...\r
406         }\r
407 \r
408 gotone:\r
409 asm     {\r
410         mov     [base],bx\r
411         mov     [size],dx\r
412         }\r
413         MML_UseSpace (base,size);\r
414         mminfo.XMSmem += size*16;\r
415         UMBbase[numUMBs] = base;\r
416         numUMBs++;\r
417         if (numUMBs < MAXUMBS)\r
418                 goto getmemory;\r
419 \r
420 done:;\r
421 }\r
422 \r
423 \r
424 /*\r
425 ======================\r
426 =\r
427 = MML_ShutdownXMS\r
428 =\r
429 ======================\r
430 */\r
431 \r
432 void MML_ShutdownXMS (void)\r
433 {\r
434         int     i;\r
435         unsigned        base;\r
436 \r
437         for (i=0;i<numUMBs;i++)\r
438         {\r
439                 base = UMBbase[i];\r
440 \r
441 asm     mov     ah,XMS_FREEUMB\r
442 asm     mov     dx,[base]\r
443 asm     call    [DWORD PTR XMSaddr]\r
444         }\r
445 }\r
446 \r
447 //==========================================================================\r
448 \r
449 /*\r
450 ======================\r
451 =\r
452 = MML_UseSpace\r
453 =\r
454 = Marks a range of paragraphs as usable by the memory manager\r
455 = This is used to mark space for the near heap, far heap, ems page frame,\r
456 = and upper memory blocks\r
457 =\r
458 ======================\r
459 */\r
460 \r
461 void MML_UseSpace (unsigned segstart, unsigned seglength)\r
462 {\r
463         mmblocktype far *scan,far *last;\r
464         unsigned        oldend;\r
465         long            extra;\r
466 \r
467         scan = last = mmhead;\r
468         mmrover = mmhead;               // reset rover to start of memory\r
469 \r
470 //\r
471 // search for the block that contains the range of segments\r
472 //\r
473         while (scan->start+scan->length < segstart)\r
474         {\r
475                 last = scan;\r
476                 scan = scan->next;\r
477         }\r
478 \r
479 //\r
480 // take the given range out of the block\r
481 //\r
482         oldend = scan->start + scan->length;\r
483         extra = oldend - (segstart+seglength);\r
484         if (extra < 0)\r
485                 Quit ("MML_UseSpace: Segment spans two blocks!");\r
486 \r
487         if (segstart == scan->start)\r
488         {\r
489                 last->next = scan->next;                        // unlink block\r
490                 FREEBLOCK(scan);\r
491                 scan = last;\r
492         }\r
493         else\r
494                 scan->length = segstart-scan->start;    // shorten block\r
495 \r
496         if (extra > 0)\r
497         {\r
498                 GETNEWBLOCK;\r
499                 mmnew->next = scan->next;\r
500                 scan->next = mmnew;\r
501                 mmnew->start = segstart+seglength;\r
502                 mmnew->length = extra;\r
503                 mmnew->attributes = LOCKBIT;\r
504         }\r
505 \r
506 }\r
507 \r
508 //==========================================================================\r
509 \r
510 /*\r
511 ====================\r
512 =\r
513 = MML_ClearBlock\r
514 =\r
515 = We are out of blocks, so free a purgable block\r
516 =\r
517 ====================\r
518 */\r
519 \r
520 void MML_ClearBlock (void)\r
521 {\r
522         mmblocktype far *scan,far *last;\r
523 \r
524         scan = mmhead->next;\r
525 \r
526         while (scan)\r
527         {\r
528                 if (!(scan->attributes&LOCKBIT) && (scan->attributes&PURGEBITS) )\r
529                 {\r
530                         MM_FreePtr(scan->useptr);\r
531                         return;\r
532                 }\r
533                 scan = scan->next;\r
534         }\r
535 \r
536         Quit ("MM_ClearBlock: No purgable blocks!");\r
537 }\r
538 \r
539 \r
540 //==========================================================================\r
541 \r
542 /*\r
543 ===================\r
544 =\r
545 = MM_Startup\r
546 =\r
547 = Grabs all space from turbo with malloc/farmalloc\r
548 = Allocates bufferseg misc buffer\r
549 =\r
550 ===================\r
551 */\r
552 \r
553 static  char *ParmStrings[] = {"noems","noxms",""};\r
554 \r
555 void MM_Startup (void)\r
556 {\r
557         int i;\r
558         unsigned        long length;\r
559         void far        *start;\r
560         unsigned        segstart,seglength,endfree;\r
561 \r
562         if (mmstarted)\r
563                 MM_Shutdown ();\r
564 \r
565 \r
566         mmstarted = true;\r
567         bombonerror = true;\r
568 //\r
569 // set up the linked list (everything in the free list;\r
570 //\r
571         mmhead = NULL;\r
572         mmfree = &mmblocks[0];\r
573         for (i=0;i<MAXBLOCKS-1;i++)\r
574                 mmblocks[i].next = &mmblocks[i+1];\r
575         mmblocks[i].next = NULL;\r
576 \r
577 //\r
578 // locked block of all memory until we punch out free space\r
579 //\r
580         GETNEWBLOCK;\r
581         mmhead = mmnew;                         // this will allways be the first node\r
582         mmnew->start = 0;\r
583         mmnew->length = 0xffff;\r
584         mmnew->attributes = LOCKBIT;\r
585         mmnew->next = NULL;\r
586         mmrover = mmhead;\r
587 \r
588 \r
589 //\r
590 // get all available near conventional memory segments\r
591 //\r
592         length=coreleft();\r
593         start = (void far *)(nearheap = malloc(length));\r
594 \r
595         length -= 16-(FP_OFF(start)&15);\r
596         length -= SAVENEARHEAP;\r
597         seglength = length / 16;                        // now in paragraphs\r
598         segstart = FP_SEG(start)+(FP_OFF(start)+15)/16;\r
599         MML_UseSpace (segstart,seglength);\r
600         mminfo.nearheap = length;\r
601 \r
602 //\r
603 // get all available far conventional memory segments\r
604 //\r
605         length=farcoreleft();\r
606         start = farheap = farmalloc(length);\r
607         length -= 16-(FP_OFF(start)&15);\r
608         length -= SAVEFARHEAP;\r
609         seglength = length / 16;                        // now in paragraphs\r
610         segstart = FP_SEG(start)+(FP_OFF(start)+15)/16;\r
611         MML_UseSpace (segstart,seglength);\r
612         mminfo.farheap = length;\r
613         mminfo.mainmem = mminfo.nearheap + mminfo.farheap;\r
614 \r
615 \r
616 //\r
617 // detect EMS and allocate up to 64K at page frame\r
618 //\r
619         mminfo.EMSmem = 0;\r
620         for (i = 1;i < _argc;i++)\r
621         {\r
622                 if ( US_CheckParm(_argv[i],ParmStrings) == 0)\r
623                         goto emsskip;                           // param NOEMS\r
624         }\r
625 \r
626         if (MML_CheckForEMS())\r
627         {\r
628                 MML_SetupEMS();                                 // allocate space\r
629                 MML_UseSpace (EMSpageframe,EMSpagesmapped*0x400);\r
630                 MM_MapEMS();                                    // map in used pages\r
631                 mminfo.EMSmem = EMSpagesmapped*0x4000l;\r
632         }\r
633 \r
634 //\r
635 // detect XMS and get upper memory blocks\r
636 //\r
637 emsskip:\r
638         mminfo.XMSmem = 0;\r
639         for (i = 1;i < _argc;i++)\r
640         {\r
641                 if ( US_CheckParm(_argv[i],ParmStrings) == 0)\r
642                         goto xmsskip;                           // param NOXMS\r
643         }\r
644 \r
645         if (MML_CheckForXMS())\r
646                 MML_SetupXMS();                                 // allocate as many UMBs as possible\r
647 \r
648 //\r
649 // allocate the misc buffer\r
650 //\r
651 xmsskip:\r
652         mmrover = mmhead;               // start looking for space after low block\r
653 \r
654         MM_GetPtr (&bufferseg,BUFFERSIZE);\r
655 }\r
656 \r
657 //==========================================================================\r
658 \r
659 /*\r
660 ====================\r
661 =\r
662 = MM_Shutdown\r
663 =\r
664 = Frees all conventional, EMS, and XMS allocated\r
665 =\r
666 ====================\r
667 */\r
668 \r
669 void MM_Shutdown (void)\r
670 {\r
671   if (!mmstarted)\r
672         return;\r
673 \r
674   farfree (farheap);\r
675   free (nearheap);\r
676   MML_ShutdownEMS ();\r
677   MML_ShutdownXMS ();\r
678 }\r
679 \r
680 //==========================================================================\r
681 \r
682 /*\r
683 ====================\r
684 =\r
685 = MM_GetPtr\r
686 =\r
687 = Allocates an unlocked, unpurgable block\r
688 =\r
689 ====================\r
690 */\r
691 \r
692 void MM_GetPtr (memptr *baseptr,unsigned long size)\r
693 {\r
694         mmblocktype far *scan,far *lastscan,far *endscan\r
695                                 ,far *purge,far *next;\r
696         int                     search;\r
697         unsigned        needed,startseg;\r
698 \r
699         needed = (size+15)/16;          // convert size from bytes to paragraphs\r
700 \r
701         GETNEWBLOCK;                            // fill in start and next after a spot is found\r
702         mmnew->length = needed;\r
703         mmnew->useptr = baseptr;\r
704         mmnew->attributes = BASEATTRIBUTES;\r
705 \r
706         for (search = 0; search<3; search++)\r
707         {\r
708         //\r
709         // first search:        try to allocate right after the rover, then on up\r
710         // second search:       search from the head pointer up to the rover\r
711         // third search:        compress memory, then scan from start\r
712                 if (search == 1 && mmrover == mmhead)\r
713                         search++;\r
714 \r
715                 switch (search)\r
716                 {\r
717                 case 0:\r
718                         lastscan = mmrover;\r
719                         scan = mmrover->next;\r
720                         endscan = NULL;\r
721                         break;\r
722                 case 1:\r
723                         lastscan = mmhead;\r
724                         scan = mmhead->next;\r
725                         endscan = mmrover;\r
726                         break;\r
727                 case 2:\r
728                         MM_SortMem ();\r
729                         lastscan = mmhead;\r
730                         scan = mmhead->next;\r
731                         endscan = NULL;\r
732                         break;\r
733                 }\r
734 \r
735                 startseg = lastscan->start + lastscan->length;\r
736 \r
737                 while (scan != endscan)\r
738                 {\r
739                         if (scan->start - startseg >= needed)\r
740                         {\r
741                         //\r
742                         // got enough space between the end of lastscan and\r
743                         // the start of scan, so throw out anything in the middle\r
744                         // and allocate the new block\r
745                         //\r
746                                 purge = lastscan->next;\r
747                                 lastscan->next = mmnew;\r
748                                 mmnew->start = *(unsigned *)baseptr = startseg;\r
749                                 mmnew->next = scan;\r
750                                 while ( purge != scan)\r
751                                 {       // free the purgable block\r
752                                         next = purge->next;\r
753                                         FREEBLOCK(purge);\r
754                                         purge = next;           // purge another if not at scan\r
755                                 }\r
756                                 mmrover = mmnew;\r
757                                 return; // good allocation!\r
758                         }\r
759 \r
760                         //\r
761                         // if this block is purge level zero or locked, skip past it\r
762                         //\r
763                         if ( (scan->attributes & LOCKBIT)\r
764                                 || !(scan->attributes & PURGEBITS) )\r
765                         {\r
766                                 lastscan = scan;\r
767                                 startseg = lastscan->start + lastscan->length;\r
768                         }\r
769 \r
770 \r
771                         scan=scan->next;                // look at next line\r
772                 }\r
773         }\r
774 \r
775         if (bombonerror)\r
776                 Quit (OUT_OF_MEM_MSG,(size-mminfo.nearheap));\r
777         else\r
778                 mmerror = true;\r
779 }\r
780 \r
781 //==========================================================================\r
782 \r
783 /*\r
784 ====================\r
785 =\r
786 = MM_FreePtr\r
787 =\r
788 = Allocates an unlocked, unpurgable block\r
789 =\r
790 ====================\r
791 */\r
792 \r
793 void MM_FreePtr (memptr *baseptr)\r
794 {\r
795         mmblocktype far *scan,far *last;\r
796 \r
797         last = mmhead;\r
798         scan = last->next;\r
799 \r
800         if (baseptr == mmrover->useptr) // removed the last allocated block\r
801                 mmrover = mmhead;\r
802 \r
803         while (scan->useptr != baseptr && scan)\r
804         {\r
805                 last = scan;\r
806                 scan = scan->next;\r
807         }\r
808 \r
809         if (!scan)\r
810                 Quit ("MM_FreePtr: Block not found!");\r
811 \r
812         last->next = scan->next;\r
813 \r
814         FREEBLOCK(scan);\r
815 }\r
816 //==========================================================================\r
817 \r
818 /*\r
819 =====================\r
820 =\r
821 = MM_SetPurge\r
822 =\r
823 = Sets the purge level for a block (locked blocks cannot be made purgable)\r
824 =\r
825 =====================\r
826 */\r
827 \r
828 void MM_SetPurge (memptr *baseptr, int purge)\r
829 {\r
830         mmblocktype far *start;\r
831 \r
832         start = mmrover;\r
833 \r
834         do\r
835         {\r
836                 if (mmrover->useptr == baseptr)\r
837                         break;\r
838 \r
839                 mmrover = mmrover->next;\r
840 \r
841                 if (!mmrover)\r
842                         mmrover = mmhead;\r
843                 else if (mmrover == start)\r
844                         Quit ("MM_SetPurge: Block not found!");\r
845 \r
846         } while (1);\r
847 \r
848         mmrover->attributes &= ~PURGEBITS;\r
849         mmrover->attributes |= purge;\r
850 }\r
851 \r
852 //==========================================================================\r
853 \r
854 /*\r
855 =====================\r
856 =\r
857 = MM_SetLock\r
858 =\r
859 = Locks / unlocks the block\r
860 =\r
861 =====================\r
862 */\r
863 \r
864 void MM_SetLock (memptr *baseptr, boolean locked)\r
865 {\r
866         mmblocktype far *start;\r
867 \r
868         start = mmrover;\r
869 \r
870         do\r
871         {\r
872                 if (mmrover->useptr == baseptr)\r
873                         break;\r
874 \r
875                 mmrover = mmrover->next;\r
876 \r
877                 if (!mmrover)\r
878                         mmrover = mmhead;\r
879                 else if (mmrover == start)\r
880                         Quit ("MM_SetLock: Block not found!");\r
881 \r
882         } while (1);\r
883 \r
884         mmrover->attributes &= ~LOCKBIT;\r
885         mmrover->attributes |= locked*LOCKBIT;\r
886 }\r
887 \r
888 //==========================================================================\r
889 \r
890 /*\r
891 =====================\r
892 =\r
893 = MM_SortMem\r
894 =\r
895 = Throws out all purgable stuff and compresses movable blocks\r
896 =\r
897 =====================\r
898 */\r
899 \r
900 void MM_SortMem (void)\r
901 {\r
902         mmblocktype far *scan,far *last,far *next;\r
903         unsigned        start,length,source,dest,oldborder;\r
904         int                     playing;\r
905 \r
906         //\r
907         // lock down a currently playing sound\r
908         //\r
909         playing = SD_SoundPlaying ();\r
910         if (playing)\r
911         {\r
912                 switch (SoundMode)\r
913                 {\r
914                 case sdm_PC:\r
915                         playing += STARTPCSOUNDS;\r
916                         break;\r
917                 case sdm_AdLib:\r
918                         playing += STARTADLIBSOUNDS;\r
919                         break;\r
920                 }\r
921                 MM_SetLock(&(memptr)audiosegs[playing],true);\r
922         }\r
923 \r
924 \r
925         SD_StopSound();\r
926 //      oldborder = bordercolor;\r
927 //      VW_ColorBorder (15);\r
928 \r
929         if (beforesort)\r
930                 beforesort();\r
931 \r
932         scan = mmhead;\r
933 \r
934         last = NULL;            // shut up compiler warning\r
935 \r
936         while (scan)\r
937         {\r
938                 if (scan->attributes & LOCKBIT)\r
939                 {\r
940                 //\r
941                 // block is locked, so try to pile later blocks right after it\r
942                 //\r
943                         start = scan->start + scan->length;\r
944                 }\r
945                 else\r
946                 {\r
947                         if (scan->attributes & PURGEBITS)\r
948                         {\r
949                         //\r
950                         // throw out the purgable block\r
951                         //\r
952                                 next = scan->next;\r
953                                 FREEBLOCK(scan);\r
954                                 last->next = next;\r
955                                 scan = next;\r
956                                 continue;\r
957                         }\r
958                         else\r
959                         {\r
960                         //\r
961                         // push the non purgable block on top of the last moved block\r
962                         //\r
963                                 if (scan->start != start)\r
964                                 {\r
965                                         length = scan->length;\r
966                                         source = scan->start;\r
967                                         dest = start;\r
968                                         while (length > 0xf00)\r
969                                         {\r
970                                                 movedata(source,0,dest,0,0xf00*16);\r
971                                                 length -= 0xf00;\r
972                                                 source += 0xf00;\r
973                                                 dest += 0xf00;\r
974                                         }\r
975                                         movedata(source,0,dest,0,length*16);\r
976 \r
977                                         scan->start = start;\r
978                                         *(unsigned *)scan->useptr = start;\r
979                                 }\r
980                                 start = scan->start + scan->length;\r
981                         }\r
982                 }\r
983 \r
984                 last = scan;\r
985                 scan = scan->next;              // go to next block\r
986         }\r
987 \r
988         mmrover = mmhead;\r
989 \r
990         if (aftersort)\r
991                 aftersort();\r
992 \r
993 //      VW_ColorBorder (oldborder);\r
994 \r
995         if (playing)\r
996                 MM_SetLock(&(memptr)audiosegs[playing],false);\r
997 }\r
998 \r
999 \r
1000 //==========================================================================\r
1001 \r
1002 #if 0\r
1003 /*\r
1004 =====================\r
1005 =\r
1006 = MM_ShowMemory\r
1007 =\r
1008 =====================\r
1009 */\r
1010 \r
1011 void MM_ShowMemory (void)\r
1012 {\r
1013         mmblocktype far *scan;\r
1014         unsigned color,temp;\r
1015         long    end,owner;\r
1016         char    scratch[80],str[10];\r
1017 \r
1018         VW_SetDefaultColors();\r
1019         VW_SetLineWidth(40);\r
1020         temp = bufferofs;\r
1021         bufferofs = 0;\r
1022         VW_SetScreen (0,0);\r
1023 \r
1024         scan = mmhead;\r
1025 \r
1026         end = -1;\r
1027 \r
1028 //CA_OpenDebug ();\r
1029 \r
1030         while (scan)\r
1031         {\r
1032                 if (scan->attributes & PURGEBITS)\r
1033                         color = 5;              // dark purple = purgable\r
1034                 else\r
1035                         color = 9;              // medium blue = non purgable\r
1036                 if (scan->attributes & LOCKBIT)\r
1037                         color = 12;             // red = locked\r
1038                 if (scan->start<=end)\r
1039                         Quit ("MM_ShowMemory: Memory block order currupted!");\r
1040                 end = scan->start+scan->length-1;\r
1041                 VW_Hlin(scan->start,(unsigned)end,0,color);\r
1042                 VW_Plot(scan->start,0,15);\r
1043                 if (scan->next->start > end+1)\r
1044                         VW_Hlin(end+1,scan->next->start,0,0);   // black = free\r
1045 \r
1046 #if 0\r
1047 strcpy (scratch,"Size:");\r
1048 ltoa ((long)scan->length*16,str,10);\r
1049 strcat (scratch,str);\r
1050 strcat (scratch,"\tOwner:0x");\r
1051 owner = (unsigned)scan->useptr;\r
1052 ultoa (owner,str,16);\r
1053 strcat (scratch,str);\r
1054 strcat (scratch,"\n");\r
1055 write (debughandle,scratch,strlen(scratch));\r
1056 #endif\r
1057 \r
1058                 scan = scan->next;\r
1059         }\r
1060 \r
1061 //CA_CloseDebug ();\r
1062 \r
1063         IN_Ack();\r
1064         VW_SetLineWidth(64);\r
1065         bufferofs = temp;\r
1066 }\r
1067 #endif\r
1068 \r
1069 //==========================================================================\r
1070 \r
1071 \r
1072 /*\r
1073 ======================\r
1074 =\r
1075 = MM_UnusedMemory\r
1076 =\r
1077 = Returns the total free space without purging\r
1078 =\r
1079 ======================\r
1080 */\r
1081 \r
1082 long MM_UnusedMemory (void)\r
1083 {\r
1084         unsigned free;\r
1085         mmblocktype far *scan;\r
1086 \r
1087         free = 0;\r
1088         scan = mmhead;\r
1089 \r
1090         while (scan->next)\r
1091         {\r
1092                 free += scan->next->start - (scan->start + scan->length);\r
1093                 scan = scan->next;\r
1094         }\r
1095 \r
1096         return free*16l;\r
1097 }\r
1098 \r
1099 //==========================================================================\r
1100 \r
1101 \r
1102 /*\r
1103 ======================\r
1104 =\r
1105 = MM_TotalFree\r
1106 =\r
1107 = Returns the total free space with purging\r
1108 =\r
1109 ======================\r
1110 */\r
1111 \r
1112 long MM_TotalFree (void)\r
1113 {\r
1114         unsigned free;\r
1115         mmblocktype far *scan;\r
1116 \r
1117         free = 0;\r
1118         scan = mmhead;\r
1119 \r
1120         while (scan->next)\r
1121         {\r
1122                 if ((scan->attributes&PURGEBITS) && !(scan->attributes&LOCKBIT))\r
1123                         free += scan->length;\r
1124                 free += scan->next->start - (scan->start + scan->length);\r
1125                 scan = scan->next;\r
1126         }\r
1127 \r
1128         return free*16l;\r
1129 }\r
1130 \r
1131 //==========================================================================\r
1132 \r
1133 /*\r
1134 =====================\r
1135 =\r
1136 = MM_BombOnError\r
1137 =\r
1138 =====================\r
1139 */\r
1140 \r
1141 void MM_BombOnError (boolean bomb)\r
1142 {\r
1143         bombonerror = bomb;\r
1144 }\r
1145 \r
1146 \r