src/lib/16_mm.c

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