src/lib/16_mm.c

   1 /* Catacomb Apocalypse Source Code
   2  * Copyright (C) 1993-2014 Flat Rock Software
   3  *
   4  * This program is free software; you can redistribute it and/or modify
   5  * it under the terms of the GNU General Public License as published by
   6  * the Free Software Foundation; either version 2 of the License, or
   7  * (at your option) any later version.
   8  *
   9  * This program is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License along
  15  * with this program; if not, write to the Free Software Foundation, Inc.,
  16  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  17  */
  18
  19 // NEWMM.C
  20
  21 /*
  22 =============================================================================
  23
  24                         ID software memory manager
  25                         --------------------------
  26
  27 Primary coder: John Carmack
  28
  29 RELIES ON
  30 ---------
  31 Quit (global_game_variables_t *gvar, char *error) function
  32
  33
  34 WORK TO DO
  35 ----------
  36 MM_SizePtr to change the size of a given pointer
  37
  38 Multiple purge levels utilized
  39
  40 EMS / XMS unmanaged routines
  41
  42 =============================================================================
  43 */
  44 /*
  45
  46 Open Watcom port by sparky4
  47
  48 */
  49 #include "src/lib/16_mm.h"
  50 #include "src/lib/16_ca.h"
  51 #include <malloc.h>
  52 #pragma hdrstop
  53
  54 #pragma warn -pro
  55 #pragma warn -use
  56
  57 /*
  58 =============================================================================
  59
  60                                                  GLOBAL VARIABLES
  61
  62 =============================================================================
  63 */
  64
  65 void            (* beforesort) (void);
  66 void            (* aftersort) (void);
  67 void            (* XMSaddr) (void);             // far pointer to XMS driver
  68
  69 /*
  70 =============================================================================
  71
  72                                                  LOCAL VARIABLES
  73
  74 =============================================================================
  75 */
  76 #ifndef __16_PM__
  77 static  char *ParmStringsexmm[] = {"noems","noxms",""};
  78 #endif
  79 /*
  80 ======================
  81 =
  82 = MML_CheckForEMS
  83 =
  84 = Routine from p36 of Extending DOS
  85 =
  86 =======================
  87 */
  88
  89 boolean MML_CheckForEMS(void)
  90 {
  91         boolean emmcfems = false;
  92         word            EMSPageFrame = 0;
  93         byte    err=0, str[64];
  94         static char     emmname[] = "EMMXXXX0"; //fix by andrius4669
  95         __asm {
  96                 mov     dx,OFFSET emmname       //fix by andrius4669
  97                 mov     ax,0x3d00
  98                 int     EMM_INT         // try to open EMMXXXX0 device
  99                 jc      error
 100
 101                 mov     bx,ax
 102                 mov     ax,0x4400
 103
 104                 int     EMM_INT         // get device info
 105                 jc      error
 106
 107                 and     dx,0x80
 108                 jz      error
 109
 110                 mov     ax,0x4407
 111
 112                 int     EMM_INT         // get status
 113                 jc      error
 114                 or      al,al
 115                 jz      error
 116
 117                 mov     ah,0x3e
 118                 int     EMM_INT         // close handle
 119                 jc      error
 120
 121                 //
 122                 // pageframe check
 123                 //
 124                 mov     ah,EMS_GETFRAME
 125                 int     EMS_INT                 // find the page frame address
 126                 or      ah,ah
 127                 jnz     error
 128                 mov     [EMSPageFrame],bx
 129
 130                 //
 131                 // EMS is good
 132                 //
 133                 mov     emmcfems,1
 134                 jmp     End
 135 #ifdef __BORLANDC__
 136         }
 137 #endif
 138                 error:
 139 #ifdef __BORLANDC__
 140         __asm {
 141 #endif
 142                 //
 143                 // EMS is bad
 144                 //
 145                 mov     err,ah
 146                 mov     emmcfems,0
 147 #ifdef __BORLANDC__
 148         }
 149 #endif
 150                 End:
 151 #ifdef __WATCOMC__
 152         }
 153 #endif
 154
 155         //
 156         // Pageframe switch to determine if there is one!
 157         //
 158         if(!EMSPageFrame)
 159         {
 160                 emmcfems = false;
 161 #if defined(__DEBUG_PM__) || defined(__DEBUG_MM__)
 162                 printf("MML_CheckForEMS: EMS error No Pageframe!\nAddress detected to be %04x\n", EMSPageFrame);
 163 #endif
 164         }else   if(!emmcfems)// if there is an error and page frame is not 0000
 165         {
 166                 strcpy(str,"MML_CheckForEMS: EMS error ");
 167                 MM_EMSerr(str, err);
 168                 printf("%s\n",str);
 169         }
 170
 171         return(emmcfems);
 172 }
 173
 174 #ifndef __16_PM__
 175 /*
 176 ======================
 177 =
 178 = MML_SetupEMS
 179 =
 180 =======================
 181 */
 182
 183 byte MML_SetupEMS(global_game_variables_t *gvar)
 184 {
 185         byte    str[160];
 186         byte    err;
 187         boolean errorflag=false;
 188
 189         unsigned int EMSVer = 0;
 190         //byte  EMS_status;
 191         unsigned        totalEMSpages,freeEMSpages,EMSPageFrame,EMSpagesmapped,EMSHandle;
 192         totalEMSpages = freeEMSpages = EMSPageFrame = EMSpagesmapped = 0;
 193
 194         __asm {
 195                 mov     ah,EMS_STATUS
 196                 int     EMS_INT                                         // make sure EMS hardware is present
 197                 or      ah,ah
 198                 //mov   [EMS_status],ah
 199                 jnz     error
 200
 201                 mov     ah,EMS_VERSION
 202                 int     EMS_INT
 203                 or      ah,ah
 204                 jnz     error
 205                 mov     [EMSVer],ax                             //      set EMSVer
 206                 cmp     al,0x32                                         // only work on ems 3.2 or greater
 207                 jb      error
 208
 209                 mov     ah,EMS_GETFRAME
 210                 int     EMS_INT                                         // find the page frame address
 211                 or      ah,ah
 212                 jnz     error
 213                 mov     [EMSPageFrame],bx
 214
 215                 mov     ah,EMS_GETPAGES
 216                 int     EMS_INT                                         // find out how much EMS is there
 217                 or      ah,ah
 218                 jnz     error
 219                 mov     [totalEMSpages],dx
 220                 mov     [freeEMSpages],bx
 221                 or      bx,bx
 222                 jz      noEMS                                           // no EMS at all to allocate
 223                                                                                         //EXPAND DONG!!!!
 224                 cmp     [EMSVer],0x40
 225                 jb      low
 226                 cmp     bx,[freeEMSpages]
 227                 jle     getpages
 228                 mov     bx,[freeEMSpages]
 229                 jmp     getpages
 230 #ifdef __BORLANDC__
 231         }
 232 #endif
 233         low:
 234 #ifdef __BORLANDC__
 235         __asm {
 236 #endif
 237                 cmp     bx,4
 238                 jle     getpages                                        // there is only 1,2,3,or 4 pages
 239                 mov     bx,4                                            // we can't use more than 4 pages
 240 #ifdef __BORLANDC__
 241         }
 242 #endif
 243         getpages:
 244 #ifdef __BORLANDC__
 245         __asm {
 246 #endif
 247                 mov     [EMSpagesmapped],bx
 248                 mov     ah,EMS_ALLOCPAGES                       // allocate up to 64k of EMS
 249                 int     EMS_INT
 250                 or      ah,ah
 251                 jnz     error
 252                 mov     [EMSHandle],dx
 253                 jmp End
 254 #ifdef __BORLANDC__
 255         }
 256 #endif
 257         error:
 258 #ifdef __BORLANDC__
 259         __asm {
 260 #endif
 261                 mov     err,ah
 262                 mov     errorflag,1
 263                 jmp End
 264 #ifdef __BORLANDC__
 265         }
 266 #endif
 267 noEMS:
 268 End:
 269 #ifdef __WATCOMC__
 270         }
 271 #endif
 272         if(errorflag==true)
 273         {
 274                 strcpy(str,"MM_SetupEMS: EMS error ");
 275                 MM_EMSerr(str, err);
 276                 printf("%s\n",str);
 277                 return err;
 278         }
 279         gvar->mm.totalEMSpages=totalEMSpages;
 280         gvar->mm.freeEMSpages=freeEMSpages;
 281         gvar->mm.EMSPageFrame=EMSPageFrame;
 282         gvar->mm.EMSpagesmapped=EMSpagesmapped;
 283         gvar->mm.EMSHandle=EMSHandle;
 284         gvar->mm.EMSVer=EMSVer;
 285         return 0;
 286 }
 287
 288
 289 /*
 290 ======================
 291 =
 292 = MML_ShutdownEMS
 293 =
 294 =======================
 295 */
 296
 297 void MML_ShutdownEMS(global_game_variables_t *gvar)
 298 {
 299         boolean errorflag=false;
 300         unsigned EMSHandle=gvar->mm.EMSHandle;
 301
 302         if(!EMSHandle)
 303                 return;
 304         __asm {
 305                 mov     ah,EMS_FREEPAGES
 306                 mov     dx,[EMSHandle]
 307                 int     EMS_INT
 308                 or      ah,ah
 309                 jz      ok
 310                 mov     errorflag,1
 311 #ifdef __BORLANDC__
 312         }
 313 #endif
 314                 ok:
 315 #ifdef __WATCOMC__
 316         }
 317 #endif
 318         if(errorflag==true)
 319                 Quit (gvar, "MML_ShutdownEMS: Error freeing EMS!\n");   //++++ add something
 320 }
 321
 322 /*
 323 ====================
 324 =
 325 = MM_MapEMS
 326 =
 327 = Maps the 64k of EMS used by memory manager into the page frame
 328 = for general use.  This only needs to be called if you are keeping
 329 = other things in EMS.
 330 =
 331 ====================
 332 */
 333
 334 byte MM_MapEMS(global_game_variables_t *gvar)
 335 {
 336         byte    str[160];
 337         unsigned        EMSHandle;
 338         byte err;
 339         boolean errorflag=false;
 340         int     i;
 341         EMSHandle=gvar->mm.EMSHandle;
 342
 343         for (i=0;i<4/*MAPPAGES*/;i++)
 344         {
 345                 __asm {
 346                         mov     ah,EMS_MAPPAGE
 347                         mov     bx,[i]                  // logical page
 348                         mov     al,bl                   // physical page
 349                         mov     dx,[EMSHandle]  // handle
 350                         int     EMS_INT
 351                         or      ah,ah
 352                         jnz     error
 353                         jmp End
 354 #ifdef __BORLANDC__
 355                 }
 356 #endif
 357                         error:
 358 #ifdef __BORLANDC__
 359                 __asm {
 360 #endif
 361                         mov     err,ah
 362                         mov     errorflag,1
 363 #ifdef __BORLANDC__
 364                 }
 365 #endif
 366                         End:
 367 #ifdef __WATCOMC__
 368                 }
 369 #endif
 370                 if(errorflag==true)
 371                 {
 372                         strcpy(str,"MM_MapEMS: EMS error ");
 373                         MM_EMSerr(str, err);
 374                         printf("%s\n",str);
 375                         return err;
 376                 }
 377         }
 378         gvar->mmi.EMSmem = (i)*0x4000lu;
 379         return 0;
 380 }
 381
 382 byte MM_MapXEMS(global_game_variables_t *gvar)
 383 {
 384 //SUB EMS.MapXPages (PhysicalStart, LogicalStart, NumPages, Handle)
 385
 386         //Maps up to 4 logical EMS pages to physical pages in the page frame, where:
 387         //PhysicalStart = Physical page first logical page is mapped to
 388         //LogicalStart  = First logical page to map
 389         //NumPages      = Number of pages to map (1 to 4)
 390         //Handle        = EMS handle logical pages are allocated to
 391
 392   /*//Create a buffer containing the page information
 393 //  FOR x = 0 TO NumPages - 1
 394 //    MapInfo$ = MapInfo$ + MKI$(LogicalStart + x) + MKI$(PhysicalStart + x)
 395 //  NEXT*/
 396
 397 //  Regs.ax = 0x5000                           //Map the pages in the buffer
 398 //  Regs.cx = NumPages                         //to the pageframe
 399 //  Regs.dx = Handle
 400 //  Regs.ds = VARSEG(MapInfo$)
 401 //  Regs.si = SADD(MapInfo$)
 402 //  InterruptX 0x67, Regs, Regs
 403 //      EMS.Error = (Regs.ax AND 0xFF00&) \ 0x100  //Store the status code
 404
 405 //END SUB
 406         byte    str[160];
 407         byte err;
 408         word    EMSHandle;
 409         boolean errorflag=false;
 410         int     i;
 411         EMSHandle=gvar->mm.EMSHandle;
 412
 413         if(gvar->mm.EMSVer<0x40)
 414                 return 5;
 415
 416         for (i=0;i<MAPPAGES;i++)
 417         {
 418                 __asm {
 419                         mov     ah,EMS_MAPXPAGE
 420                         mov     cx,[i]                  // logical page
 421                         mov     al,bl                   // physical page
 422                         mov     dx,[EMSHandle]  // handle
 423                         int     EMS_INT
 424                         or      ah,ah
 425                         jnz     error
 426                         jmp End
 427 #ifdef __BORLANDC__
 428                 }
 429 #endif
 430                         error:
 431 #ifdef __BORLANDC__
 432                 __asm {
 433 #endif
 434                         mov     err,ah
 435                         mov     errorflag,1
 436 #ifdef __BORLANDC__
 437                 }
 438 #endif
 439                         End:
 440 #ifdef __WATCOMC__
 441                 }
 442 #endif
 443                 if(errorflag==true)
 444                 {
 445                         //strcpy(str,"MM_MapXEMS: EMS error 0x");
 446                         strcpy(str,"MM_MapXEMS: EMS error ");
 447                         //itoa(err,str2,16);
 448                         MM_EMSerr(str, err);
 449                         printf("%s\n",str);
 450                         //printf("%s%x\n",str, err);
 451                         //printf("FACK! %x\n", err);
 452                         return err;
 453                 }
 454         }
 455         gvar->mmi.EMSmem = (i)*0x4000lu;
 456         return 0;
 457 }
 458 #endif
 459 //==========================================================================
 460
 461 /*
 462 ======================
 463 =
 464 = MML_CheckForXMS
 465 =
 466 = Check for XMM driver
 467 =
 468 =======================
 469 */
 470
 471 boolean MML_CheckForXMS(void)
 472 {
 473         //numUMBs = 0;
 474         boolean errorflag=false;
 475
 476         __asm {
 477                 mov     ax,0x4300
 478                 int     0x2f                            // query status of installed diver
 479                 cmp     al,0x80
 480                 je      good
 481                 mov     errorflag,1
 482 #ifdef __BORLANDC__
 483         }
 484 #endif
 485                 good:
 486 #ifdef __WATCOMC__
 487         }
 488 #endif
 489         if(errorflag==true) return false;
 490         else return true;
 491 }
 492
 493 #ifndef __16_PM__
 494 /*
 495 ======================
 496 =
 497 = MML_SetupXMS
 498 =
 499 = Try to allocate all upper memory block
 500 =
 501 =======================
 502 */
 503
 504 void MML_SetupXMS(global_game_variables_t *gvar)
 505 {
 506         word    base,size;
 507
 508
 509         __asm {
 510                 mov     ax,0x4310
 511                 int     0x2f
 512                 mov     [WORD PTR XMSaddr],bx
 513                 mov     [WORD PTR XMSaddr+2],es         // function pointer to XMS driver
 514         }
 515 getmemory:
 516         __asm {
 517                 mov     ah,XMS_ALLOCUMB
 518                 mov     dx,0xffff                                       // try for largest block possible
 519                 //mov     ax,dx                                         // Set available Kbytes.
 520                 call    [DWORD PTR XMSaddr]
 521                 or      ax,ax
 522                 jnz     gotone
 523
 524                 cmp     bl,0xb0                                         // error: smaller UMB is available
 525                 jne     done;
 526
 527                 mov     ah,XMS_ALLOCUMB
 528                 call    [DWORD PTR XMSaddr]             // DX holds largest available UMB
 529                 or      ax,ax
 530                 jz      done                                            // another error...
 531 #ifdef __BORLANDC__
 532         }
 533 #endif
 534                 gotone:
 535 #ifdef __BORLANDC__
 536         __asm {
 537 #endif
 538                 mov     [base],bx
 539                 mov     [size],dx
 540 #ifdef __BORLANDC__
 541         }
 542 #endif
 543                 done:
 544 #ifdef __WATCOMC__
 545         }
 546 #endif
 547 //      printf("base=%u ", base); printf("size=%u\n", size);
 548         MML_UseSpace(base,size, gvar);
 549         gvar->mmi.XMSmem += size*16;
 550         gvar->mm.UMBbase[gvar->mm.numUMBs] = base;
 551         gvar->mm.numUMBs++;
 552         if(gvar->mm.numUMBs < MAXUMBS)
 553                 goto getmemory;
 554 }
 555
 556
 557 /*
 558 ======================
 559 =
 560 = MML_ShutdownXMS
 561 =
 562 ======================
 563 */
 564
 565 void MML_ShutdownXMS(global_game_variables_t *gvar)
 566 {
 567         int     i;
 568         unsigned        base;
 569
 570         for (i=0;i<gvar->mm.numUMBs;i++)
 571         {
 572                 base = gvar->mm.UMBbase[i];
 573                 __asm {
 574                         mov     ah,XMS_FREEUMB
 575                         mov     dx,[base]
 576                         call    [DWORD PTR XMSaddr]
 577                 }
 578         }
 579 }
 580 #endif
 581 //==========================================================================
 582
 583 /*
 584 ======================
 585 =
 586 = MML_UseSpace
 587 =
 588 = Marks a range of paragraphs as usable by the memory manager
 589 = This is used to mark space for the near heap, far heap, ems page frame,
 590 = and upper memory blocks
 591 =
 592 ======================
 593 */
 594
 595 /*
 596         extra = oldend - (segstart+seglength);
 597
 598         segmlen=extra;
 599
 600         //++++emsver stuff!
 601         if(segm>1)/// || extra>=0x10000lu)
 602         //if(extra>0xfffflu)
 603         {
 604                 scan->blob=segm;
 605
 606                 //MML_UseSpace(segstart, seglength, gvar);
 607
 608                 printf("MML_UseSpace: Segment spans two blocks!\n");
 609         //}
 610         printf("segm=%u         ", segm);
 611         printf("ex=%lu  ", extra);
 612         printf("old=%u  ", oldend);
 613         printf("start+seglen=%lu\n", segstart+seglength);
 614         printf("segsta=%x       ", segstart);
 615         printf("len=%lu ", scan->length);
 616         printf("seglen=%lu      ", seglength);
 617         printf("segmlen=%lu\n", segmlen);
 618         }
 619 //++++todo: linked list of segment!
 620 */
 621 void MML_UseSpace(word segstart, dword seglength, global_game_variables_t *gvar)
 622 {
 623         mmblocktype far *scan,far *last;
 624         word    oldend;
 625         sdword          extra;
 626         //word segm=1;
 627
 628         scan = last = gvar->mm.mmhead;
 629         gvar->mm.mmrover = gvar->mm.mmhead;             // reset rover to start of memory
 630
 631 //
 632 // search for the block that contains the range of segments
 633 //
 634         while (scan->start+scan->length < segstart)
 635         {
 636                 last = scan;
 637                 scan = scan->next;
 638         }
 639
 640 //
 641 // find out how many blocks it spans!
 642 //
 643         /*for(;seglength>=0x10000;seglength-=0xFFFF)
 644         {
 645                 //printf("      seglen=%lu\n", segmlen);
 646                 segm++;
 647         }*/
 648
 649 //
 650 // take the given range out of the block
 651 //
 652         oldend = scan->start + scan->length;
 653         extra = oldend - (segstart+((unsigned)seglength));
 654         if (extra < 0)
 655         {
 656                 printf("========================================\n");
 657                 printf("start=%x        ", scan->start);
 658                 printf("old=%u  ", oldend);
 659                 printf("start+seglen=%lu\n", segstart+seglength);
 660                 printf("segsta=%x       ", segstart);
 661                 printf("len=%lu ", scan->length);
 662                 printf("seglen=%lu      ", seglength);
 663                 printf("\n");
 664                 printf("MML_UseSpace: Segment spans two blocks! %d\n", extra);
 665                 printf("========================================\n");
 666                 //return;
 667         }
 668
 669         if (segstart == scan->start)
 670         {
 671                 last->next = scan->next;                        // unlink block
 672                 FREEBLOCK(scan);
 673                 scan = last;
 674         }
 675         else
 676                 scan->length = segstart-scan->start;    // shorten block
 677
 678         if (extra > 0)
 679         {
 680                 GETNEWBLOCK;
 681                 gvar->mm.mmnew->useptr = NULL;
 682
 683                 gvar->mm.mmnew->next = scan->next;
 684                 scan->next = gvar->mm.mmnew;
 685                 gvar->mm.mmnew->start = segstart+seglength;
 686                 gvar->mm.mmnew->length = extra;
 687                 gvar->mm.mmnew->attributes = LOCKBIT;
 688         }//else if(segm>0) goto segu;
 689
 690 }
 691
 692 //==========================================================================
 693
 694 /*
 695 ====================
 696 =
 697 = MML_ClearBlock
 698 =
 699 = We are out of blocks, so free a purgable block
 700 =
 701 ====================
 702 */
 703
 704 void MML_ClearBlock(global_game_variables_t *gvar)
 705 {
 706         mmblocktype far *scan;//,far *last;
 707
 708         scan = gvar->mm.mmhead->next;
 709
 710         while(scan)
 711         {
 712                 if(!(scan->attributes&LOCKBIT) && (scan->attributes&PURGEBITS))
 713                 {
 714                         MM_FreePtr(scan->useptr, gvar);
 715                         return;
 716                 }
 717                 scan = scan->next;
 718         }
 719
 720         printf("MM_ClearBlock: No purgable blocks!\n");
 721 }
 722
 723
 724 //==========================================================================
 725
 726 /*
 727 ===================
 728 =
 729 = MM_Startup
 730 =
 731 = Grabs all space from turbo with malloc/farmalloc
 732 = Allocates bufferseg misc buffer
 733 =
 734 ===================
 735 */
 736
 737 void MM_Startup(global_game_variables_t *gvar)
 738 {
 739         int i;
 740         //dword length,seglength;
 741         dword length; word seglength;
 742         void far        *start;
 743         word    segstart;//,endfree;
 744
 745         if(gvar->mm.mmstarted)
 746                 MM_Shutdown(gvar);
 747
 748         gvar->mm.mmstarted = true;
 749         gvar->mm.bombonerror = true;
 750
 751 //
 752 // set up the linked list (everything in the free list;
 753 //
 754         gvar->mm.mmhead = NULL;
 755         gvar->mm.mmfree = &(gvar->mm.mmblocks[0]);
 756         for(i=0;i<MAXBLOCKS-1;i++)
 757                 gvar->mm.mmblocks[i].next = &(gvar->mm.mmblocks[i+1]);
 758         gvar->mm.mmblocks[i].next = NULL;
 759
 760 //
 761 // locked block of all memory until we punch out free space
 762 //
 763         GETNEWBLOCK;
 764         gvar->mm.mmhead = gvar->mm.mmnew;                               // this will allways be the first node
 765         gvar->mm.mmnew->start = 0;
 766         gvar->mm.mmnew->length = 0xffff;
 767         gvar->mm.mmnew->attributes = LOCKBIT;
 768         gvar->mm.mmnew->next = NULL;
 769         gvar->mm.mmrover = gvar->mm.mmhead;
 770
 771 //
 772 // get all available near conventional memory segments
 773 //
 774 #ifdef __WATCOMC__
 775         _nheapgrow();
 776 #endif
 777         length=(word)_memavl();//(word)coreleft();
 778         //start = gvar->mm.nearheap = _fmalloc(length);
 779 #ifdef __WATCOMC__
 780         start = (void __far *)(gvar->mm.nearheap = _nmalloc(length));
 781 #endif
 782 #ifdef __BORLANDC__
 783         start = (void far *)(gvar->mm.nearheap = malloc(length));
 784 #endif
 785
 786         length -= 16-(FP_OFF(start)&15);
 787         length -= SAVENEARHEAP;
 788         seglength = length / 16;                        // now in paragraphs
 789         segstart = FP_SEG(start)+(FP_OFF(start)+15)/16;
 790         MML_UseSpace(segstart,seglength, gvar);
 791         gvar->mmi.nearheap = length;
 792         //0000printf("near:     start=%Fp       segstart=%x     seglen=%lu      len=%lu\n", start, segstart, (dword)seglength, length);
 793
 794 //
 795 // get all available far conventional memory segments
 796 //
 797 #ifdef __WATCOMC__
 798         _fheapgrow();
 799 #endif
 800 #ifdef __BORLANDC__
 801 //      printf("farcoreleft()                           %lu\n", farcoreleft());
 802 //      printf("(farcoreleft()+32)-_FCORELEFT   %d\n", (sword)((farcoreleft()+32)-_FCORELEFT));
 803 #endif
 804         length=_FCORELEFT;
 805         start = gvar->mm.farheap = _fmalloc(length);//start = gvar->mm.farheap = halloc(length, 1);
 806
 807         length -= 16-(FP_OFF(start)&15);
 808         length -= SAVEFARHEAP;
 809         seglength = length / 16;                        // now in paragraphs
 810         segstart = FP_SEG(start)+(FP_OFF(start)+15)/16;
 811         MML_UseSpace(segstart,seglength, gvar);
 812         gvar->mmi.farheap = length;
 813         //0000printf("far:      start=%Fp       segstart=%x     seglen=%lu      len=%lu\n", start, segstart, (dword)seglength, length);
 814
 815         gvar->mmi.mainmem = gvar->mmi.nearheap + gvar->mmi.farheap;
 816
 817 #if !defined(__16_PM__)// && defined(__WATCOMC__)
 818         if(!dbg_debugpm) {
 819 //
 820 // detect EMS and allocate up to 64K at page frame
 821 //
 822         gvar->mmi.EMSmem = 0;
 823 //goto emsskip; //0000
 824         for(i = 1;i < _argc;i++)
 825         {
 826                 if(US_CheckParm(_argv[i],ParmStringsexmm) == 0)
 827                         goto emsskip;                           // param NOEMS
 828         }
 829         if(MML_CheckForEMS())
 830         {
 831                 MML_SetupEMS(gvar);                                     // allocate space
 832                 //16_PM: EMS4! AND EMS 3.2 MASSIVE DATA HANDLMENT!
 833                 MML_UseSpace(gvar->mm.EMSPageFrame,(MAPPAGES)*0x4000lu, gvar);
 834                 //if(gvar->pm.emm.EMSVer<0x40)
 835                         MM_MapEMS(gvar);                                        // map in used pages
 836                 //else
 837                         //MM_MapXEMS(gvar);                                     // map in used pages
 838         }
 839
 840 //
 841 // detect XMS and get upper memory blocks
 842 //
 843 emsskip:
 844         gvar->mmi.XMSmem = 0;
 845 goto xmsskip;//0000
 846         for(i = 1;i < _argc;i++)
 847         {
 848                 if(US_CheckParm( _argv[i],ParmStringsexmm) == 0)
 849                         goto xmsskip;                           // param NOXMS
 850         }
 851         if(MML_CheckForXMS())
 852         {
 853                 MML_SetupXMS(gvar);                                     // allocate as many UMBs as possible
 854         }
 855
 856         }
 857 xmsskip:
 858 #endif
 859 //
 860 // allocate the misc buffer
 861 //
 862         gvar->mm.mmrover = gvar->mm.mmhead;             // start looking for space after low block
 863
 864         MM_GetPtr(&(gvar->mm.bufferseg),BUFFERSIZE, gvar);
 865 }
 866
 867 //==========================================================================
 868
 869 /*
 870 ====================
 871 =
 872 = MM_Shutdown
 873 =
 874 = Frees all conventional, EMS, and XMS allocated
 875 =
 876 ====================
 877 */
 878
 879 void MM_Shutdown(global_game_variables_t *gvar)
 880 {
 881         if(!(gvar->mm.mmstarted))
 882                 return;
 883
 884         _ffree(gvar->mm.farheap);//     printf("                far freed\n");
 885 #ifdef __WATCOMC__
 886         _nfree(gvar->mm.nearheap);//    printf("                near freed\n");
 887 #endif
 888 #ifdef __BORLANDC__
 889         free(gvar->mm.nearheap);//      printf("                near freed\n");
 890 #endif
 891 #ifndef __16_PM__
 892 #ifdef __DEBUG__
 893         if(!dbg_debugpm) {
 894 #endif
 895         if(MML_CheckForEMS()){ MML_ShutdownEMS(gvar); }//printf("               EMS freed\n"); }
 896         if(MML_CheckForXMS()){ MML_ShutdownXMS(gvar); }//printf("               XMS freed\n"); }
 897 #ifdef __DEBUG__
 898         }
 899 #endif
 900 #endif
 901 }
 902
 903 //==========================================================================
 904
 905 /*
 906 ====================
 907 =
 908 = MM_GetPtr
 909 =
 910 = Allocates an unlocked, unpurgable block
 911 =
 912 ====================
 913 */
 914
 915 void MM_GetPtr (memptr *baseptr, dword size, global_game_variables_t *gvar)
 916 {
 917         mmblocktype far *scan,far *lastscan,far *endscan,far *purge,far *next;
 918         int                     search;
 919         unsigned        needed,startseg;
 920
 921         needed = (size+15)/16;          // convert size from bytes to paragraphs
 922
 923         GETNEWBLOCK;                            // fill in start and next after a spot is found
 924         gvar->mm.mmnew->length = needed;
 925         gvar->mm.mmnew->useptr = baseptr;
 926         //if(gvar->mm.mmnew->useptr==NULL){
 927 #ifdef __DEBUG_MM__
 928         if(dbg_debugmm>0){
 929                 printf("MM_GetPtr\n");
 930                 //%04x
 931                 printf("        baseptr=%Fp     ", baseptr); printf("useptr=%Fp\n", gvar->mm.mmnew->useptr);
 932                 printf("        *baseptr=%Fp    ", *baseptr); printf("*useptr=%Fp\n", *(gvar->mm.mmnew->useptr));
 933                 printf("        &baseptr=%Fp    ", &baseptr); printf("&useptr=%Fp\n", &(gvar->mm.mmnew->useptr));
 934         }
 935 #endif
 936         //Quit(gvar, "gvar->mm.mmnew->useptr==NULL"); }
 937         gvar->mm.mmnew->attributes = BASEATTRIBUTES;
 938
 939 //tryagain:
 940         for (search = 0; search<3; search++)
 941         {
 942         //
 943         // first search:        try to allocate right after the rover, then on up
 944         // second search:       search from the head pointer up to the rover
 945         // third search:        compress memory, then scan from start
 946                 if (search == 1 && gvar->mm.mmrover == gvar->mm.mmhead)
 947                         search++;
 948
 949                 switch (search)
 950                 {
 951                 case 0:
 952                         lastscan = gvar->mm.mmrover;
 953                         scan = gvar->mm.mmrover->next;
 954                         endscan = NULL;
 955                         break;
 956                 case 1:
 957                         lastscan = gvar->mm.mmhead;
 958                         scan = gvar->mm.mmhead->next;
 959                         endscan = gvar->mm.mmrover;
 960                         break;
 961                 case 2:
 962                         MM_SortMem (gvar);
 963                         lastscan = gvar->mm.mmhead;
 964                         scan = gvar->mm.mmhead->next;
 965                         endscan = NULL;
 966                         break;
 967                 }
 968
 969                 startseg = lastscan->start + lastscan->length;
 970
 971                 while (scan != endscan)
 972                 {
 973                         if (scan->start - startseg >= needed)
 974                         {
 975                         //
 976                         // got enough space between the end of lastscan and
 977                         // the start of scan, so throw out anything in the middle
 978                         // and allocate the new block
 979                         //
 980                                 purge = lastscan->next;
 981                                 lastscan->next = gvar->mm.mmnew;
 982                                 gvar->mm.mmnew->start = *(unsigned *)baseptr = startseg;
 983                                 gvar->mm.mmnew->next = scan;
 984                                 while ( purge != scan)
 985                                 {       // free the purgable block
 986                                         next = purge->next;
 987                                         FREEBLOCK(purge);
 988                                         purge = next;           // purge another if not at scan
 989                                 }
 990                                 gvar->mm.mmrover = gvar->mm.mmnew;
 991                                 return; // good allocation!
 992                         }
 993
 994                         //
 995                         // if this block is purge level zero or locked, skip past it
 996                         //
 997                         if ( (scan->attributes & LOCKBIT)
 998                                 || !(scan->attributes & PURGEBITS) )
 999                         {
1000                                 lastscan = scan;
1001                                 startseg = lastscan->start + lastscan->length;
1002                         }
1003
1004
1005                         scan=scan->next;                // look at next line
1006                 }
1007         }
1008
1009         if (gvar->mm.bombonerror)
1010         {
1011 #ifdef __WATCOMC__
1012                 //heapdump();
1013 #endif
1014                 printf(OUT_OF_MEM_MSG,(size-gvar->mmi.nearheap));
1015                 Quit(gvar, "for stability reasons the program will shut down! wwww\n");
1016         }
1017         else
1018                 gvar->mm.mmerror = true;
1019 }
1020
1021 //==========================================================================
1022
1023 /*
1024 ====================
1025 =
1026 = MM_FreePtr
1027 =
1028 = Allocates an unlocked, unpurgable block
1029 =
1030 ====================
1031 */
1032
1033 void MM_FreePtr(memptr *baseptr, global_game_variables_t *gvar)
1034 {
1035         mmblocktype far *scan,far *last;
1036
1037         last = gvar->mm.mmhead;
1038         scan = last->next;
1039
1040         if(baseptr == gvar->mm.mmrover->useptr) // removed the last allocated block
1041                 gvar->mm.mmrover = gvar->mm.mmhead;
1042
1043         while(scan->useptr != baseptr && scan)
1044         {
1045                 last = scan;
1046                 scan = scan->next;
1047         }
1048
1049         if(!scan)
1050         {
1051                 Quit(gvar, "MM_FreePtr: Block not found!\n");
1052                 //printf("MM_FreePtr: Block not found!\n"); return;
1053         }
1054
1055         last->next = scan->next;
1056
1057         FREEBLOCK(scan);
1058 }
1059 //==========================================================================
1060
1061 /*
1062 =====================
1063 =
1064 = MM_SetPurge
1065 =
1066 = Sets the purge level for a block (locked blocks cannot be made purgable)
1067 =
1068 =====================
1069 */
1070
1071
1072 void MM_SetPurge(memptr *baseptr, int purge, global_game_variables_t *gvar)
1073 {
1074         mmblocktype far *start;
1075
1076         start = gvar->mm.mmrover;
1077
1078         do
1079         {
1080                 if(gvar->mm.mmrover->useptr == baseptr)
1081                         break;
1082
1083                 gvar->mm.mmrover = gvar->mm.mmrover->next;
1084
1085                 if(!gvar->mm.mmrover)
1086                         gvar->mm.mmrover = gvar->mm.mmhead;
1087                 else if(gvar->mm.mmrover == start)
1088                 {
1089                         Quit (gvar, "MM_SetPurge: Block not found!");
1090                         //return;
1091                 }
1092
1093         } while(1);
1094
1095         gvar->mm.mmrover->attributes &= ~PURGEBITS;
1096         gvar->mm.mmrover->attributes |= purge;
1097 }
1098
1099 //==========================================================================
1100
1101 /*
1102 =====================
1103 =
1104 = MM_SetLock
1105 =
1106 = Locks / unlocks the block
1107 =
1108 =====================
1109 */
1110
1111 void MM_SetLock(memptr *baseptr, boolean locked, global_game_variables_t *gvar)
1112 {
1113         mmblocktype far *start;
1114
1115         start = gvar->mm.mmrover;
1116
1117         do
1118         {
1119                 if(gvar->mm.mmrover->useptr == baseptr)
1120                         break;
1121
1122                 gvar->mm.mmrover = gvar->mm.mmrover->next;
1123
1124                 if(!gvar->mm.mmrover)
1125                         gvar->mm.mmrover = gvar->mm.mmhead;
1126                 else if(gvar->mm.mmrover == start)
1127                 {
1128                         Quit (gvar, "MM_SetLock: Block not found!");
1129                         //return;
1130                 }
1131
1132         } while(1);
1133
1134         gvar->mm.mmrover->attributes &= ~LOCKBIT;
1135         gvar->mm.mmrover->attributes |= locked*LOCKBIT;
1136 }
1137
1138 //==========================================================================
1139
1140 /*
1141 =====================
1142 =
1143 = MM_SortMem
1144 =
1145 = Throws out all purgable stuff and compresses movable blocks
1146 =
1147 =====================
1148 */
1149
1150 void MM_SortMem(global_game_variables_t *gvar)
1151 {
1152         mmblocktype far *scan,far *last,far *next;
1153         unsigned        start,length,source,dest,oldborder;
1154         //++++int                       playing;
1155
1156         //
1157         // lock down a currently playing sound
1158         //
1159 /*++++  playing = SD_SoundPlaying ();
1160         if(playing)
1161         {
1162                 switch (SoundMode)
1163                 {
1164                 case sdm_PC:
1165                         playing += STARTPCSOUNDS;
1166                         break;
1167                 case sdm_AdLib:
1168                         playing += STARTADLIBSOUNDS;
1169                         break;
1170                 }
1171                 MM_SetLock((memptr *)&audiosegs[playing],true);
1172         }
1173
1174
1175         SD_StopSound();*/
1176         oldborder = gvar->video.bordercolor;
1177         gvar->video.bordercolor = modexPalOverscan(15);
1178
1179         if(beforesort)
1180                 beforesort();
1181
1182         scan = gvar->mm.mmhead;
1183
1184         last = NULL;            // shut up compiler warning
1185
1186         while(scan)
1187         {
1188                 if(scan->attributes & LOCKBIT)
1189                 {
1190                 //
1191                 // block is locked, so try to pile later blocks right after it
1192                 //
1193                         start = scan->start + scan->length;
1194                 }
1195                 else
1196                 {
1197                         if(scan->attributes & PURGEBITS)
1198                         {
1199                         //
1200                         // throw out the purgable block
1201                         //
1202                                 next = scan->next;
1203                                 FREEBLOCK(scan);
1204                                 //MM_FreeBlock(scan, gvar);
1205                                 last->next = next;
1206                                 scan = next;
1207                                 continue;
1208                         }
1209                         else
1210                         {
1211                         //
1212                         // push the non purgable block on top of the last moved block
1213                         //
1214                                 if(scan->start != start)
1215                                 {
1216                                         length = scan->length;
1217                                         source = scan->start;
1218                                         dest = start;
1219                                         while(length > 0xf00)
1220                                         {
1221                                                 movedata(source,0,dest,0,0xf00*16);
1222                                                 length -= 0xf00;
1223                                                 source += 0xf00;
1224                                                 dest += 0xf00;
1225                                         }
1226                                         movedata(source,0,dest,0,length*16);
1227
1228                                         scan->start = start;
1229                                         *(unsigned *)scan->useptr = start;
1230                                 }
1231                                 start = scan->start + scan->length;
1232                         }
1233                 }
1234
1235                 last = scan;
1236                 scan = scan->next;              // go to next block
1237         }
1238
1239         gvar->mm.mmrover = gvar->mm.mmhead;
1240
1241         if(aftersort)
1242                 aftersort();
1243
1244 //      VW_ColorBorder (oldborder);
1245
1246 /*++++  if(playing)
1247                 MM_SetLock((memptr *)&audiosegs[playing],false);*/
1248 }
1249
1250 //==========================================================================
1251
1252 /*
1253 =====================
1254 =
1255 = MM_ShowMemory
1256 =
1257 =====================
1258 */
1259
1260 //#define MMSMSORTNEWTYPE
1261
1262 void MM_ShowMemory(global_game_variables_t *gvar)
1263 {
1264         mmblocktype far *scan;
1265         unsigned color,temp,x,y,w;
1266         sdword  end,owner;
1267         byte    scratch[160],scratch0[4096],str[16];
1268
1269         VL_SetLineWidth(40, &gvar->video.ofs);
1270         temp = gvar->video.ofs.bufferofs;
1271         gvar->video.ofs.bufferofs = gvar->video.ofs.displayofs;
1272         scan = gvar->mm.mmhead;
1273
1274         end = -1; w = 0;
1275
1276         CA_OpenDebug (gvar);
1277         while (scan)
1278         {
1279                 strcpy(scratch, AARESET);
1280                 if(scan->attributes & PURGEBITS)
1281                 {
1282                         color = 5;              // dark purple = purgable
1283                         strcpy(scratch0, AAMAGENTA);            // dark purple = purgable
1284                 }else{
1285                         color = 9;              // medium blue = non purgable
1286                         strcpy(scratch0, AABLUE);               // medium blue = non purgable
1287                 }
1288                 if(scan->attributes & LOCKBIT)
1289                 {
1290                         color = 12;             // red = locked
1291                         strcpy(scratch0, AARED);                // red = locked
1292                 }
1293                 if(scan->start<=end)
1294                 {
1295                         printf("\nend==%d\n\n", end);
1296                         strcat(scratch, "MM_ShowMemory: Memory block order currupted!\n");
1297                         strcat(scratch, "End's Size: ");
1298                         ultoa (end,str,10);
1299                         strcat (scratch,str);
1300                         strcat(scratch, "\nscan->start's Size: ");
1301                         ultoa (scan->start,str,10);
1302                         strcat (scratch,str);
1303                         write(gvar->handle.debughandle,scratch,strlen(scratch));
1304                         Quit (gvar, "MM_ShowMemory: Memory block order currupted!");
1305                 }
1306 #ifndef MMSMSORTNEWTYPE
1307                 end = scan->length-1;
1308 #else
1309                 end = scan->start+(scan->length)-1;
1310 #endif
1311                 y = scan->start/320;
1312                 x = scan->start%320;
1313                 VW_Hlin(x,x+end,y,color, &gvar->video.ofs);
1314                 VL_Plot(x,y,15, &gvar->video.ofs);
1315                 for(w=(scan->start)/80;w<=end/80;w++)
1316                 {
1317                         //printf("+     %u      %lu\n", w, scan->length);
1318                         strcat(scratch0, "+");
1319                 }
1320 //++==++==optional              strcat(scratch0, AARESET); strcat(scratch0, AAGREY); strcat(scratch0,"_");
1321 #ifdef MMSMSORTNEWTYPE
1322                 if (scan->next && scan->next->start > end+1)
1323 #else
1324                 if (scan->next && scan->next->start >= end+1)
1325 #endif
1326                 {
1327                         VW_Hlin(x+end+1,x+(scan->next->start-scan->start),y,0, &gvar->video.ofs);       // black = free
1328                         strcat(scratch0, AARESET);
1329 //++==++==optional                      strcat(scratch0, "\n");
1330                         strcat(scratch0,AAGREEN);
1331                         for(w=(end+1)/80;w<=((scan->next->start-scan->start)/80);w++)
1332                         {
1333                                 //printf("0     %x      %u      %lu\n", scan->next->start, w, scan->length);
1334                                 strcat(scratch0,"0");
1335                         }
1336                         //printf("==================\n");
1337                         //printf("w=%u  start=%04x      next=%04x       end=%lu\n", w/80, scan->start, (scan->next->start), end+1);
1338                         //printf("==================\n");
1339                         strcat(scratch0, "\n");
1340                 }
1341 #if 0
1342                 else {//if(scan->next->start <= scan->start){
1343                         scan->next->start=scan->start+0x1000;
1344                         strcat(scratch0, AARESET);
1345                         strcat(scratch0, "\n");
1346                         strcat(scratch0,AAGREEN);
1347                         for(w=(end+1);w<=(0x1000/80);w++)
1348                         {
1349                                 //printf("0     %x      %x      %u\n", scan->start, w);
1350                                 strcat(scratch0,"0");
1351                         }
1352                         printf("================\n");
1353                         printf("w=%x    start=%x        next=%x end=%u\n", w, scan->start, (scan->next->start), end+1);
1354                         printf("================\n");
1355                         getch();
1356                 }
1357 #endif
1358                 strcat(scratch0, AARESET);
1359                 //strcat(scratch0,"\n");
1360                 strcat(scratch,"Seg:");
1361                 ultoa (scan->start,str,16);
1362                 strcat (scratch,str);
1363                 strcat (scratch,"\tSize:");
1364                 ultoa ((unsigned)scan->length,str,10);
1365                 strcat (scratch,str);
1366                 strcat (scratch,"\tOwner:0x");
1367                 owner = (unsigned)scan->useptr;
1368                 ultoa (owner,str,16);
1369                 strcat (scratch,str);
1370                 strcat (scratch,"\n");
1371                 write(gvar->handle.debughandle,scratch,strlen(scratch));
1372                 write(gvar->handle.debughandle,scratch0,strlen(scratch0));
1373 //fprintf(stdout, "%s", scratch);
1374
1375                 scan = scan->next;
1376         }
1377
1378         CA_CloseDebug (gvar);
1379
1380         IN_Ack(gvar);
1381 //****  VW_SetLineWidth(64);
1382         gvar->video.ofs.bufferofs = temp;
1383 }
1384
1385
1386
1387 //==========================================================================
1388
1389 /*
1390 =====================
1391 =
1392 = MM_DumpData
1393 =
1394 =====================
1395 */
1396
1397 void MM_DumpData(global_game_variables_t *gvar)
1398 {
1399         mmblocktype far *scan,far *best;
1400         long    lowest,oldlowest;
1401         word    owner;
1402         byte    lock,purge;
1403         FILE    *dumpfile;
1404
1405 #ifdef __WATCOMC__
1406         _nfree(gvar->mm.nearheap);
1407 #endif
1408 #ifdef __BORLANDC__
1409         free(gvar->mm.nearheap);
1410 #endif
1411 #ifdef __BORLANDC__
1412                 dumpfile = fopen ("mmdump.16b","w");
1413 #endif
1414 #ifdef __WATCOMC__
1415                 dumpfile = fopen ("mmdump.16w","w");
1416 #endif
1417         if (!dumpfile){
1418                 printf("MM_DumpData: Couldn't open MMDUMP.16!\n");
1419                 return;
1420         }
1421
1422         lowest = -1;
1423         do
1424         {
1425                 oldlowest = lowest;
1426                 lowest = 0xffff;
1427
1428                 scan = gvar->mm.mmhead;
1429                 while (scan)
1430                 {
1431                         owner = (unsigned)scan->useptr;
1432
1433                         if (owner && owner<lowest && owner > oldlowest)
1434                         {
1435                                 best = scan;
1436                                 lowest = owner;
1437                         }
1438
1439                         scan = scan->next;
1440                 }
1441
1442                 if (lowest != 0xffff)
1443                 {
1444                         if (best->attributes & PURGEBITS)
1445                                 purge = 'P';
1446                         else
1447                                 purge = '-';
1448                         if (best->attributes & LOCKBIT)
1449                                 lock = 'L';
1450                         else
1451                                 lock = '-';
1452                         fprintf (dumpfile,"0x%p (%c%c) = %u\n"
1453                         ,(unsigned)lowest,lock,purge,best->length);
1454                 }
1455
1456         } while (lowest != 0xffff);
1457
1458         fclose(dumpfile);
1459         printf("MMDUMP.16 created.\n");
1460 }
1461
1462 //==========================================================================
1463
1464
1465 /*
1466 ======================
1467 =
1468 = MM_UnusedMemory
1469 =
1470 = Returns the total free space without purging
1471 =
1472 ======================
1473 */
1474
1475 dword MM_UnusedMemory(global_game_variables_t *gvar)
1476 {
1477         dword free;
1478         mmblocktype far *scan;
1479
1480         free = 0;
1481         scan = gvar->mm.mmhead;
1482
1483         while(scan->next)
1484         {
1485                 free += scan->next->start - (scan->start + scan->length);
1486                 scan = scan->next;
1487         }
1488
1489         return free*16lu;
1490 //      return free;
1491 }
1492
1493 //==========================================================================
1494
1495
1496 /*
1497 ======================
1498 =
1499 = MM_TotalFree
1500 =
1501 = Returns the total free space with purging
1502 =
1503 ======================
1504 */
1505
1506 dword MM_TotalFree(global_game_variables_t *gvar)
1507 {
1508         dword free;
1509         mmblocktype far *scan;
1510
1511         free = 0;
1512         scan = gvar->mm.mmhead;
1513
1514         while(scan->next)
1515         {
1516                 if((scan->attributes&PURGEBITS) && !(scan->attributes&LOCKBIT))
1517                         free += scan->length;
1518                 free += scan->next->start - (scan->start + scan->length);
1519                 scan = scan->next;
1520         }
1521
1522         return free*16lu;
1523 //      return free;
1524 }
1525
1526 //==========================================================================
1527
1528 /*
1529 =====================
1530 =
1531 = MM_Report
1532 =
1533 =====================
1534 */
1535
1536 void MM_Report_(global_game_variables_t *gvar)
1537 {
1538         printf("========================================\n");
1539         printf("                MM_Report_\n");
1540         printf("========================================\n");
1541         if(MML_CheckForEMS())
1542         {
1543                 printf("        %cLIMEMS        %u\n", 0xC9, gvar->pm.emm.EMSPresent);
1544                 printf("        %c%cEMM v%x.%x available\n", 0xC7, 0xC4, gvar->pm.emm.EMSVer>>4,gvar->pm.emm.EMSVer&0x0F);
1545                 printf("        %c%ctotalEMSpages:      %u      ", 0xC7, 0xC4, gvar->pm.emm.totalEMSpages); printf("freeEMSpages:       %u\n", gvar->pm.emm.freeEMSpages);
1546                 printf("        %c%cEMSPageFrame:       %04x\n", 0xC7, 0xC4, gvar->pm.emm.EMSPageFrame);
1547                 printf("        %c%cEMSmem:     %lu or %luk\n", 0xD3, 0xC4, gvar->mmi.EMSmem, gvar->mmi.EMSmem/1204);
1548         }
1549         if(MML_CheckForXMS())
1550         {
1551                 printf("        %cXMS   %u\n", 0xC9, gvar->pm.xmm.XMSPresent);
1552                 printf("        %c%cXMS v%x.%x available\n", 0xC7, 0xC4, XMSVer>>8,XMSVer&0x0F);
1553                 printf("        %c%cXMSDriver:  %Fp\n", 0xC7, 0xC4, XMSDriver);
1554                 printf("        %c%cXMSHandle:  %04x\n", 0xC7, 0xC4, gvar->pm.xmm.XMSHandle);
1555                 printf("        %c%cXMSmem:     %lu or %lukb\n", 0xD3, 0xC4, gvar->mmi.XMSmem, gvar->mmi.XMSmem/1024);
1556         }
1557         printf("        %cConv. %u\n", 0xC9, gvar->pm.mm.MainPresent); DebugMemory_(gvar, 0);
1558         //printf("mainmem:      %lu\n", gvar->mmi.mainmem);
1559         //printf("Total convmem:        %lu     ", gvar->mmi.mainmem); printf("TotalFree:       %lu     ", MM_TotalFree(gvar)+gvar->mmi.EMSmem+gvar->mmi.XMSmem+gvar->mmi.XMSmem); printf("TotalUsed:   %lu\n", gvar->mmi.mainmem);
1560         //printf("                      UnusedMemory:   %lu\n", MM_UnusedMemory(gvar));
1561         printf("nearheap:       %lu             ", gvar->mmi.nearheap); printf("farheap:        %lu\n", gvar->mmi.farheap);
1562 }
1563
1564 //==========================================================================
1565
1566 /*
1567 =====================
1568 =
1569 = MM_EMSerr
1570 =
1571 =====================
1572 */
1573
1574 void MM_EMSerr(byte *stri, byte err)
1575 {
1576         //Returns a text string describing the error code in EMS.Error.
1577         switch(err)
1578         {
1579                 case 0x0:
1580                         strcat(stri, "successful");
1581                 break;
1582                 case 0x80:
1583                         strcat(stri, "internal error");
1584                 break;
1585                 case 0x81:
1586                         strcat(stri, "hardware malfunction");
1587                 break;
1588                 case 0x82:
1589                         strcat(stri, "busy .. retry later");
1590                 break;
1591                 case 0x83:
1592                         strcat(stri, "invalid handle");
1593                 break;
1594                 case 0x84:
1595                         strcat(stri, "undefined function requested by application");
1596                 break;
1597                 case 0x85:
1598                         strcat(stri, "no more handles available");
1599                 break;
1600                 case 0x86:
1601                         strcat(stri, "error in save or restore of mapping context");
1602                 break;
1603                 case 0x87:
1604                         strcat(stri, "insufficient memory pages in system");
1605                 break;
1606                 case 0x88:
1607                         strcat(stri, "insufficient memory pages available");
1608                 break;
1609                 case 0x89:
1610                         strcat(stri, "zero pages requested");
1611                 break;
1612                 case 0x8A:
1613                         strcat(stri, "invalid logical page number encountered");
1614                 break;
1615                 case 0x8B:
1616                         strcat(stri, "invalid physical page number encountered");
1617                 break;
1618                 case 0x8C:
1619                         strcat(stri, "page-mapping hardware state save area is full");
1620                 break;
1621                 case 0x8D:
1622                         strcat(stri, "save of mapping context failed");
1623                 break;
1624                 case 0x8E:
1625                         strcat(stri, "restore of mapping context failed");
1626                 break;
1627                 case 0x8F:
1628                         strcat(stri, "undefined subfunction");
1629                 break;
1630                 case 0x90:
1631                         strcat(stri, "undefined attribute type");
1632                 break;
1633                 case 0x91:
1634                         strcat(stri, "feature not supported");
1635                 break;
1636                 case 0x92:
1637                         strcat(stri, "successful, but a portion of the source region has been overwritten");
1638                 break;
1639                 case 0x93:
1640                         strcat(stri, "length of source or destination region exceeds length of region allocated to either source or destination handle");
1641                 break;
1642                 case 0x94:
1643                         strcat(stri, "conventional and expanded memory regions overlap");
1644                 break;
1645                 case 0x95:
1646                         strcat(stri, "offset within logical page exceeds size of logical page");
1647                 break;
1648                 case 0x96:
1649                         strcat(stri, "region length exceeds 1 MB");
1650                 break;
1651                 case 0x97:
1652                         strcat(stri, "source and destination EMS regions have same handle and overlap");
1653                 break;
1654                 case 0x98:
1655                         strcat(stri, "memory source or destination type undefined");
1656                 break;
1657                 case 0x9A:
1658                         strcat(stri, "specified alternate map register or DMA register set not supported");
1659                 break;
1660                 case 0x9B:
1661                         strcat(stri, "all alternate map register or DMA register sets currently allocated");
1662                 break;
1663                 case 0x9C:
1664                         strcat(stri, "alternate map register or DMA register sets not supported");
1665                 break;
1666                 case 0x9D:
1667                         strcat(stri, "undefined or unallocated alternate map register or DMA register set");
1668                 break;
1669                 case 0x9E:
1670                         strcat(stri, "dedicated DMA channels not supported");
1671                 break;
1672                 case 0x9F:
1673                         strcat(stri, "specified dedicated DMA channel not supported");
1674                 break;
1675                 case 0xA0:
1676                         strcat(stri, "no such handle name");
1677                 break;
1678                 case 0xA1:
1679                         strcat(stri, "a handle found had no name, or duplicate handle name");
1680                 break;
1681                 case 0xA2:
1682                         strcat(stri, "attempted to wrap around 1M conventional address space");
1683                 break;
1684                 case 0xA3:
1685                         strcat(stri, "source array corrupted");
1686                 break;
1687                 case 0xA4:
1688                         strcat(stri, "operating system denied access");
1689                 break;
1690                 default:
1691                         strcat(stri, "undefined error");
1692         }
1693 }
1694
1695 //==========================================================================
1696
1697 /*
1698 =====================
1699 =
1700 = MM_BombOnError
1701 =
1702 =====================
1703 */
1704
1705 void MM_BombOnError(boolean bomb, global_game_variables_t *gvar)
1706 {
1707         gvar->mm.bombonerror = bomb;
1708 }
1709
1710 #if 0
1711 void MM_GetNewBlock(global_game_variables_t *gvar)
1712 {
1713         if(!gvar->mm.mmfree)
1714                 MML_ClearBlock(gvar);
1715         gvar->mm.mmnew=gvar->mm.mmfree;
1716         gvar->mm.mmfree=gvar->mm.mmfree->next;
1717         if(!(gvar->mm.mmnew=gvar->mm.mmfree))
1718         {
1719                 printf("MM_GETNEWBLOCK: No free blocks!\n");
1720                 return;
1721         }
1722         gvar->mm.mmfree=gvar->mm.mmfree->next;
1723 }
1724
1725 void MM_FreeBlock(mmblocktype *x, global_game_variables_t *gvar)
1726 {
1727         x->useptr=NULL;
1728         x->next=gvar->mm.mmfree;
1729         gvar->mm.mmfree=x;
1730 }
1731 #endif
1732
1733 void xms_call(byte v, global_game_variables_t *gvar)
1734 {
1735         dword XMSDriver = gvar->pm.xmm.XMSDriver;
1736         __asm {
1737                 mov     ah,[v]
1738                 call [DWORD PTR XMSDriver]
1739         }
1740 }
1741
1742 /*void MM_seguin(void)
1743 {
1744         __asm {
1745                 push    ds
1746                 mov     ax,ds
1747                 inc             ax
1748                 mov     ds,ax
1749         }
1750 }
1751
1752 void MM_segude(void)
1753 {
1754         __asm {
1755                 pop ds
1756         }
1757 }*/
1758
1759 /*
1760 pull data from far and put it into ds var
1761 mov ax,es:si
1762 mov x,ax
1763 */
1764 /*
1765 ss stack segment
1766 sp top of stack
1767 bp bottem of stack
1768 */