membase.c

DOS 源代码 系列之 command 源码

 * Now that we've added memory for each device driver, add whatever's left.
 *
 */

	    AddMem_to_Table (8, Org_IOaddr, umb_numb, Org_IOsize);
	    }
	 }
      else
         {

 /****************************************************************************/
 /* If not BIOS table, it is a program like MEM, etc.			    */
 /* calculate the size of the block occupied by the program and display prog */
 /* name and size                                                            */
 /****************************************************************************/

	 Out_Var1 = AddressOf((char far *)ThisArenaPtr);
	 Out_Var2 = ((long) (ThisArenaPtr -> Paragraphs)) * 16l;
	 strcpy(Out_Str1,OwnerOf(ThisArenaPtr));
	 strcpy(Out_Str2,TypeOf(ThisArenaPtr));
	 gpszDevDriver = Out_Str1;

	 /* We don't want to include mem's environment space into the
	  * computations. Since this environment space is allocated to
	  * running other programs, it really isn't part of free memory.
	  */

	  FP_SEG(EnvironmentSegmentPtr) = ThisArenaPtr->Owner;
	  FP_OFF(EnvironmentSegmentPtr) = 44;

	  if (!((_psp == ThisArenaPtr->Owner) &&
		(*EnvironmentSegmentPtr == FP_SEG(ThisArenaPtr)+1) ))
	     if (AddMem_to_Table (ThisArenaPtr->Owner,Out_Var1,umb_numb,Out_Var2))
		return(1);

	 DoMainLine_a (ThisArenaPtr->Owner, &Out_Var1, Out_Str1,
	               &Out_Var2, Out_Str2, &umb_numb); 
	 }

      if (ThisArenaPtr->Signature == (char)'Z')
         break;

      FP_SEG(ThisArenaPtr) += ThisArenaPtr->Paragraphs + 1;
      }

   if (DataLevel == 4)
      {
      if (! modulesize)
         {
         mprintf (ModNoneMsg, "%-c", ModName);
	 }
      else
         {
	 mprintf (ModBarMsg, "");
	 sprintf (temp, "(%ldK)", toK(modulesize));
	 mprintf (ModSumMsg, "%8ld%7c", &modulesize, temp);
	 }
      }

   if (DataLevel == 3)
      {
      mprintf (NewLineMsg, "");
      sprintf (temp, "(%ldK)", toK(modulesize));
      mprintf (FreeSumMsg, "%7ld%7c", &modulesize, temp);

      DisplayFree();
      }

   return(0);
}

void
DisplayFree ()
{
   char  temp1[30], temp2[30], temp3[30];
   long  i;

   mprintf (NewLineMsg, "");
   if (mem_table.umbs[0].umb_ttl == 0L)
      {
      mprintf (NoUMBAvailMsg, "");
      return;
      }

   mprintf (FreeUpperMsg,   "");
   mprintf (NewLineMsg,     "");
   mprintf (FreeUTitleMsg,  "");
   mprintf (FreeUUScoreMsg, "");

   for (i = 1; i < MAX_CLDATA_INDEX; i++)
      {
      if (mem_table.umbs[i-1].umb_ttl == 0L)  break;

      sprintf (temp1, "(%ldK)", toK (mem_table.umbs[i-1].umb_large));
      sprintf (temp2, "(%ldK)", toK (mem_table.umbs[i-1].umb_free));
      sprintf (temp3, "(%ldK)", toK (mem_table.umbs[i-1].umb_ttl));

      mprintf (MainFULineMsg, "%3ld%7ld%6c%7ld%6c%7ld%6c", &i,
               &mem_table.umbs[i-1].umb_large, temp1,
               &mem_table.umbs[i-1].umb_free,  temp2,
               &mem_table.umbs[i-1].umb_ttl,   temp3);
      }
}

/*---------------------------------------------------------------------------*/

char *GetDeviceDriver    (ThisDeviceDriver)
struct DEVICEHEADER far  *ThisDeviceDriver;
{
   static char  LocalDeviceName[16];
   int          i;

   if (((ThisDeviceDriver->Attributes) & 0x8000 ) != 0)
      {
      for (i = 0; i < 8; i++)  LocalDeviceName[i] = ThisDeviceDriver->Name[i];
      LocalDeviceName[8] = NUL;
      }
   else
      {
      if ((int)ThisDeviceDriver->Name[0] == 1)
         {
	 sprintf (&LocalDeviceName[0], SingleDrive, 'A'+BlockDeviceNumber);
         }
      else
         {
         sprintf (&LocalDeviceName[0], MultipleDrives, 'A'+BlockDeviceNumber,
	       'A'+BlockDeviceNumber + ((int)ThisDeviceDriver->Name[0]) -1);
         }

      BlockDeviceNumber += (int)(ThisDeviceDriver->Name[0]);
      }

   return LocalDeviceName;
}

/*---------------------------------------------------------------------------*/

void GetSummary()
{
   long    extra;
   long    total_mem;

   char	far *CarvedPtr;
   struct PSP_STRUC
      {
      unsigned int	int_20;
      unsigned int	top_of_memory;
      };
   struct PSP_STRUC far *PSPptr;

   /* Adjust for XBDA size */
   /* XBDA size should be added to total mem size reported by INT 12 */
   /* IFF XBDA is placed just at the end of conv.mem */
   /* IF EMM386 or QEMM is loaded, XBDA gets relocated to EMM driver mem */
   /* and int 12 reports correct size of memory in this case */
   InRegs.x.bx = 0;
   InRegs.x.ax = 0xc100;
   int86x(0x15, &InRegs, &OutRegs, &SegRegs);
   if (OutRegs.x.cflag == 0)
      {
      if (mem_table.conv_ttl == (unsigned long)((long)SegRegs.es) * 16l)
         {
	 FP_SEG(CarvedPtr) = SegRegs.es;
	 FP_OFF(CarvedPtr) = 0;
	 mem_table.conv_ttl += ((unsigned long int)(*CarvedPtr) * 1024l);
	 }
      }

   InRegs.h.ah = GET_PSP;
   intdos(&InRegs,&OutRegs);

   FP_SEG(PSPptr) = OutRegs.x.bx;
   FP_OFF(PSPptr) = 0;

	       /* Get total memory in system */

   int86 (MEMORY_DET,&InRegs,&OutRegs);

   mem_table.conv_ttl = (unsigned long int) OutRegs.x.ax * 1024l;
   mem_table.rom_ttl  = 0L;

   GetExtraMemory();  /* Get XMS/EMS information */

   if (mem_table.umb_ttl || mem_table.xms_ttl)
      {
      total_mem = mem_table.conv_ttl + mem_table.umb_ttl + mem_table.xms_ttl;

      if ((extra = ONEMEG - (total_mem % ONEMEG)) <= K384)
	 {
	 mem_table.rom_ttl = extra;
	 }
      }
}

void DispMEMSummary()
{
   char      temp1[40], temp2[40], temp3[40];
   char      far *fpBytes;
   long      used, t_used, t_ttl, t_free, c_used;
   int	     fPooled;

   // EMS is 'pooled' with XMS if this is a recent enough version of
   // EMM386 (fIsPooled) and the min and max EMS pool sizes are different.

   fPooled = fIsPooled() && (MaxMin[0] != MaxMin[1]) && EMSInstalled();

   mprintf (NewLineMsg,  "");
   mprintf (MemSumm1Msg, "");
   mprintf (MemSumm2Msg, "");

   t_used = c_used = 0L;

   used = mem_table.conv_ttl - mem_table.conv_free;
   t_used += used;
   sprintf (temp1, "%ldK", toK (mem_table.conv_ttl));
   sprintf (temp2, "%ldK", toK (used));
   sprintf (temp3, "%ldK", toK (mem_table.conv_free));
   mprintf (MemLineMsg, MemFormat, ConvMsg, temp1, temp2, temp3);

   used = mem_table.umb_ttl - mem_table.umb_free;
   t_used += used;
   sprintf (temp1, "%ldK", toK (mem_table.umb_ttl));
   sprintf (temp2, "%ldK", toK (used));
   sprintf (temp3, "%ldK", toK (mem_table.umb_free));
   mprintf (MemLineMsg, MemFormat, UpperMsg, temp1, temp2, temp3);

   c_used = t_used;
   used = mem_table.rom_ttl;
   t_used += used;
   sprintf (temp1, "%ldK", toK (mem_table.rom_ttl));
   sprintf (temp2, "%ldK", toK (mem_table.rom_ttl));
   sprintf (temp3, "%ldK", toK (0L));
   mprintf (MemLineMsg, MemFormat, AdaptMsg, temp1, temp2, temp3);

   used = mem_table.xms_ttl - mem_table.xms_free;
   t_used += used;
   sprintf (temp1, "%ldK", toK (mem_table.xms_ttl));
   sprintf (temp2, "%ldK", toK (used));
   sprintf (temp3, "%ldK", toK (mem_table.xms_free));
   if (fPooled)
      mprintf (MemLineMsg, MemFormat, XMSMsgPool, temp1, temp2, temp3);
   else
      mprintf (MemLineMsg, MemFormat, XMSMsg, temp1, temp2, temp3);

   mprintf (MemSumm2Msg, "");

   t_ttl  = mem_table.conv_ttl  + mem_table.umb_ttl  + mem_table.rom_ttl +
	    + mem_table.xms_ttl;
   t_free = mem_table.conv_free + mem_table.umb_free +
	    + mem_table.xms_free ;
   sprintf (temp1, "%ldK", toK (t_ttl));
   sprintf (temp2, "%ldK", toK (t_used));
   sprintf (temp3, "%ldK", toK (t_free));
   mprintf (MemLineMsg, MemFormat, TotalMsg, temp1, temp2, temp3);

   mprintf (NewLineMsg, "");
   t_ttl  = mem_table.conv_ttl  + mem_table.umb_ttl;
   t_free = mem_table.conv_free + mem_table.umb_free;
   sprintf (temp1, "%ldK", toK (t_ttl));
   sprintf (temp2, "%ldK", toK (c_used));
   sprintf (temp3, "%ldK", toK (t_free));
   mprintf (MemLineMsg, MemFormat, TtlConvMsg, temp1, temp2, temp3);

   mem_table.conv_large -= 16;  /* They can't use the header area */

   mprintf (NewLineMsg, "");

   /* Always print the ems total and free values from int 67/42 */
   if (mem_table.ems_ttl != 0) {
       sprintf (temp1, "%ldK", toK (mem_table.ems_ttl));
       sprintf (temp2, "(%ld bytes)  ", mem_table.ems_ttl);
       mprintf (TtlEms, "%6c%17c", temp1, temp2);

       sprintf (temp1, "%ldK", toK (mem_table.ems_free));
       sprintf (temp2, "(%ld bytes)  ", mem_table.ems_free);
       mprintf (fPooled ? FreeEMSPool : FreeEms, "%6c%17c", temp1, temp2);
       mprintf (NewLineMsg, "");
   }

   /* If EMS and XMS are shared, display the available EMS may vary disclaimer.
    */

   if (fPooled) {
      mprintf (PoolMsg1, "");
      mprintf (PoolMsg2, "");
      mprintf (NewLineMsg, "");
   }

   InRegs.x.ax = Bites;
   InRegs.h.dh = Utility_Msg_Class;
   sysgetmsg(&InRegs,&SegRegs,&OutRegs);
   FP_OFF(fpBytes) = OutRegs.x.si;
   FP_SEG(fpBytes) = SegRegs.ds;

   sprintf (temp1, "%ldK", toK (mem_table.conv_large));
   sprintf (temp2, "(%ld %s)  ", mem_table.conv_large, fpBytes);
   mprintf (LargeExMsg,  "%6c%17c", temp1, temp2);
   sprintf (temp1, "%ldK", toK (mem_table.umb_large));
   sprintf (temp2, "(%ld %s)  ", mem_table.umb_large, fpBytes);
   mprintf (LargeUMBMsg, "%6c%17c", temp1, temp2);

   switch (mem_table.hma)
      {
      case -2:	break;		 /* HMA doesn't exist, don't print anything */
      case -1:	mprintf (HMANotAvlMsg, "");  break; /* exists, but used */
      case  0:	mprintf (HMAAvlMsg,    "");  break; /* exists and free */
      case  1:	mprintf (HMADOSMsg,    "");  break; /* in use by MSDOS */
      default:	mprintf (ROMDOSMsg,    "");  break; /* in use by ROM DOS */
      }

   return;
}

void DisplaySummary()
{
   unsigned long int HandleMem; 	 /* memory associated w/handle */
   char  TitlesPrinted = FALSE; 	 /* flag for printing titles */

   char  temp1[40], temp2[40], temp3[40];
   long  used, t_used, t_ttl, t_free, c_used;
   int   fPooled;

   // EMS is 'pooled' with XMS if this is a recent enough version of
   // EMM386 (fIsPooled) and the min and max EMS pool sizes are different.

   fPooled = fIsPooled() && (MaxMin[0] != MaxMin[1]) && EMSInstalled();

   mprintf (NewLineMsg,   "");
   mprintf (MemSumMsg,    "");
   mprintf (NewLineMsg,   "");
   mprintf (SumTitleMsg,  "");
   mprintf (SumUScoreMsg, "");

   t_used = c_used = 0L;

   used = mem_table.conv_ttl - mem_table.conv_free;
   t_used += used;
   sprintf (temp1, "(%ldK)", toK (mem_table.conv_ttl));
   sprintf (temp2, "(%ldK)", toK (used));
   sprintf (temp3, "(%ldK)", toK (mem_table.conv_free));
   mprintf (SumLineMsg, SumFormat, ConvMsg,
            &mem_table.conv_ttl, temp1, &used, temp2,
            &mem_table.conv_free, temp3);

   used = mem_table.umb_ttl - mem_table.umb_free;
   t_used += used;
   sprintf (temp1, "(%ldK)", toK (mem_table.umb_ttl));
   sprintf (temp2, "(%ldK)", toK (used));
   sprintf (temp3, "(%ldK)", toK (mem_table.umb_free));
   mprintf (SumLineMsg, SumFormat, UpperMsg,
            &mem_table.umb_ttl, temp1, &used, temp2,
            &mem_table.umb_free, temp3);

   c_used = t_used;

   t_used += mem_table.rom_ttl;
   used = 0L;
   sprintf (temp1, "(%ldK)", toK (mem_table.rom_ttl));
   sprintf (temp2, "(%ldK)", toK (mem_table.rom_ttl));
   sprintf (temp3, "(%ldK)", toK (0L));
   mprintf (SumLineMsg, SumFormat, AdaptMsg,
            &mem_table.rom_ttl, temp1, &mem_table.rom_ttl, temp2,
            &used, temp3);

   used = mem_table.xms_ttl - mem_table.xms_free;
   t_used += used;
   sprintf (temp1, "(%ldK)", toK (mem_table.xms_ttl));
   sprintf (temp2, "(%ldK)", toK (used));
   sprintf (temp3, "(%ldK)", toK (mem_table.xms_free));
   if (fPooled)
      mprintf (SumLineMsg, SumFormat, XMSMsgPool,
	       &mem_table.xms_ttl, temp1, &used, temp2,
	       &mem_table.xms_free, temp3);
   else
      mprintf (SumLineMsg, SumFormat, XMSMsg,
	       &mem_table.xms_ttl, temp1, &used, temp2,
	       &mem_table.xms_free, temp3);

   mprintf (SumUScoreMsg, "");

   t_ttl  = mem_table.conv_ttl  + mem_table.umb_ttl  + mem_table.rom_ttl +
	    + mem_table.xms_ttl;
   t_free = mem_table.conv_free + mem_table.umb_free +
	    + mem_table.xms_free ;
   sprintf (temp1, "(%ldK)", toK (t_ttl));
   sprintf (temp2, "(%ldK)", toK (t_used));
   sprintf (temp3, "(%ldK)", toK (t_free));
   mprintf (SumLineMsg, SumFormat, TotalMsg,
                 &t_ttl, temp1, &t_used, temp2, &t_free, temp3);

   mprintf (NewLineMsg, "");
   t_ttl  = mem_table.conv_ttl  + mem_table.umb_ttl;
   t_free = mem_table.conv_free + mem_table.umb_free;
   sprintf (temp1, "(%ldK)", toK (t_ttl));