membase.c

DOS 源代码 系列之 command 源码

   sprintf (temp2, "(%ldK)", toK (c_used));
   sprintf (temp3, "(%ldK)", toK (t_free));
   mprintf (SumLineMsg, SumFormat, TtlConvMsg,
                 &t_ttl, temp1, &c_used, temp2, &t_free, temp3);
   mprintf (NewLineMsg, "");

   /* if ems is install or no NOEMS, then display the handles */
   if (EMSInstalled() && (DataLevel == 2)) {
       HandleName[0] = NUL;	      /* initialize the array	      */

       mprintf (NewLineMsg,   "");

       segread(&SegRegs);

       SegRegs.es = SegRegs.ds;

       for (HandleIndex = 0; HandleIndex < EMSMaxHandles; HandleIndex++)
       {

	   InRegs.x.ax = EMSGetHandleName;     /* get handle name */
	   InRegs.x.dx = HandleIndex;	       /* handle in question */
	   InRegs.x.di = (unsigned int) HandleName;    /* point to handle name */
	   int86x(EMS, &InRegs, &OutRegs, &SegRegs);

	   HandleName[8] = NUL; 	       /* make sure terminated w/nul */

	   if (OutRegs.h.ah != EMSCODE_83)
	   {
	       InRegs.x.ax = EMSGetHandlePages;  /* get pages assoc w/this handle */
	       InRegs.x.dx = HandleIndex;
	       int86x(EMS, &InRegs, &OutRegs, &SegRegs);
	       HandleMem = OutRegs.x.bx;
	       HandleMem *= (long) (16l*1024l);

	       if (!TitlesPrinted)
	       {
		   mprintf (Title3Msg,	 "");
		   mprintf (Title4Msg,	 "");
		   TitlesPrinted = TRUE;
	       }

	       if (HandleName[0] == NUL)
		   strcpy(HandleName,"        ");

	       mprintf (HandleMsg, "%4d%8c%6lx", &HandleIndex, HandleName, &HandleMem);
	   }
       }  /* end   for (HandleIndex = 0; HandleIndex < EMSMaxHandles;HandleIndex++) */

       mprintf (NewLineMsg,   "");
   }

   /* Always print the ems total and free values from int 67/42 */
   if (mem_table.ems_ttl != 0) {
       /* print the total and free ems lines */
       sprintf (temp1, "(%ldK)", toK (mem_table.ems_ttl));
       sprintf (temp2, "%8.8s", temp1);
       NoCR = 1;
       mprintf (SpaceOverMsg, "");
       mprintf (TtlEms,  "%10ld%8c", &mem_table.ems_ttl, temp2);

       sprintf (temp1, "(%ldK)", toK (mem_table.ems_free));
       sprintf (temp2, "%8.8s", temp1);
       NoCR = 1;
       mprintf (SpaceOverMsg, "");
       mprintf (fPooled ? FreeEMSPool : FreeEms,  "%10ld%8c", &mem_table.ems_free, temp2);
   }


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

   if (fPooled) {

       mprintf (NewLineMsg,   "");

       NoCR = 1;
       mprintf (SpaceOverMsg, "");
       mprintf (PoolMsg1, "");

       NoCR = 1;
       mprintf (SpaceOverMsg, "");
       mprintf (PoolMsg2, "");

       mprintf (NewLineMsg, "");
   }


   if (DataLevel == 2)
      {
      sprintf (temp1, "(%ldK)", toK (mem_table.int_15h));
      sprintf (temp2, "%8.8s", temp1);
      NoCR = 1;  mprintf (SpaceOverMsg, "");
      mprintf (Int15MemoryMsg, "%10ld%8c", &mem_table.int_15h, temp2);
      }

   mem_table.conv_large -= 16;  /* They can't use the header area */
   sprintf (temp1, "(%ldK)", toK (mem_table.conv_large));
   sprintf (temp2, "%8.8s", temp1);
   NoCR = 1;  mprintf (SpaceOverMsg, "");
   mprintf (LargeExMsg,  "%10ld%8c", &mem_table.conv_large, temp2);

   sprintf (temp1, "(%ldK)", toK (mem_table.umb_large));
   sprintf (temp2, "%8.8s", temp1);
   NoCR = 1;  mprintf (SpaceOverMsg, "");
   mprintf (LargeUMBMsg, "%10ld%8c", &mem_table.umb_large, temp2);

   NoCR = 1;  mprintf (SpaceOverMsg, "");
   switch (mem_table.hma)
      {
      case -2:	break;
      case -1:  mprintf (HMANotAvlMsg, "");  break;
      case  0:  mprintf (HMAAvlMsg,    "");  break;
      case  1:  mprintf (HMADOSMsg,    "");  break;
      default:  mprintf (ROMDOSMsg,    "");  break;
      }

   if (DataLevel == 2)
      {
      used = 0;  /* Okay, a second use for this thing... */
      if (mem_table.xmsMvers != 0)
         {
	 mprintf (NewLineMsg, "");
	 sprintf (temp1, "%d.%02d", mem_table.xmsMvers, mem_table.xmsmvers);
	 sprintf (temp2, "%d.%02d", mem_table.xmsMdrvr, mem_table.xmsmdrvr);
	 mprintf (XMSVersionMsg, "%5c%5c", temp1, temp2);
	 used = 1;
	 }
      if (mem_table.emsMvers != 0)
         {
	 if (! used)  mprintf (NewLineMsg, "");
	 sprintf (temp1, "%d.%02d", mem_table.emsMvers, mem_table.emsmvers);
	 mprintf (EMSVersionMsg, "%5c", temp1);
	 }
      }

   return;
}

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

char *OwnerOf    (ArenaPtr)
struct ARENA far *ArenaPtr;
{
   char        far *StringPtr;
   char	           *o;
   unsigned    far *EnvironmentSegmentPtr;
   unsigned         PspSegment;
   int	            i, fPrintable;

    o = &OwnerName[0];
   *o = NUL;
   strcpy (o, UnOwned);

   PspSegment = ArenaPtr->Owner;

   if (PspSegment == 0)
      sprintf(o,Ibmdos);
   else
      if (PspSegment == 8)
	 sprintf (o, Ibmbio);
      else
	 {
	 FP_SEG(ArenaPtr) = PspSegment-1;   /* Arena is 16 bytes before PSP */
	 StringPtr = (char far *) &(ArenaPtr -> OwnerName[0]);

	 /* M002 BEGIN
	  * Chars below 0x20 (Space) and char 0x7f are not printable in US
	  * and European Code pages.  The following code checks for them and
	  * does not print such names.  - Nagara 11/20/90
	  */

	 fPrintable = TRUE;

#ifndef DBCS
	 for (i = 0; i < 8;i++,StringPtr++)
	    {
	    if ((*StringPtr < 0x20) | (*StringPtr == 0x7f))
	       {  
		      /* unprintable char ? */	
	       if (*StringPtr)  fPrintable = FALSE;	
	       break;
	       }
	    }
#endif

	 if (fPrintable)
	    {
	    StringPtr = (char far *) &(ArenaPtr->OwnerName[0]);
	    for (i = 0; i < 8;i++)
	       *o++ = *StringPtr++;
	    *o = NUL;
	    }
	 /* M002 END */

	 }

   if (UseArgvZero)  GetFromArgvZero (PspSegment, EnvironmentSegmentPtr);

   return (&OwnerName[0]);
}

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

void GetFromArgvZero (PspSegment, EnvironmentSegmentPtr)
unsigned              PspSegment;
unsigned                     far *EnvironmentSegmentPtr;
{
   char	    far *StringPtr;
   char	        *OutputPtr;
   unsigned far *WordPtr;

   OutputPtr = &OwnerName[0];

   if (UseArgvZero)
      {
      if (PspSegment < FP_SEG(ArenaHeadPtr))
	 {
	 if (*OutputPtr == NUL)  sprintf (OutputPtr,Ibmdos);
	 }
      else
	 {
	 FP_SEG(EnvironmentSegmentPtr) = PspSegment;
	 FP_OFF(EnvironmentSegmentPtr) = 44;

	      /*  FP_SEG(StringPtr) = *EnvironmentSegmentPtr; */

	 FP_SEG(StringPtr) = FP_SEG(EnvironmentSegmentPtr);
	 FP_OFF(StringPtr) = 0;

	 while ((*StringPtr != NUL) || (*(StringPtr+1) != NUL))  StringPtr++;

	 StringPtr += 2;
	 WordPtr    = (unsigned far *)StringPtr;

	 if (*WordPtr == 1)
	    {
	    StringPtr += 2;
	    while (*StringPtr != NUL)
	       *OutputPtr++ = *StringPtr++;
	    *OutputPtr++ = NUL;

	    while (OutputPtr > &OwnerName[0])
	       {
	       if (*OutputPtr == (char) '.')
	          *OutputPtr = NUL;
	       if ((*OutputPtr == (char) '\\') || (*OutputPtr == (char) ':'))
		  {
		  OutputPtr++;
		  break;
		  }
	       OutputPtr--;
	       }
	    }
	 }
      }

   strcpy (&OwnerName[0], OutputPtr);

   return;
}

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

char *TypeOf     (Header)
struct ARENA far *Header;
{
   char	        *t;
   unsigned      PspSegment;
   unsigned far *EnvironmentSegmentPtr;
   unsigned int  Message_Number;
   char far     *Message_Buf;
   unsigned int  i;

   t = &TypeText[0];
   *t = NUL;

   Message_Number = 0xff;
   if (Header->Owner == 8)  Message_Number = StackMsg;
   if (Header->Owner == 0)  Message_Number = FreeMsg;

   PspSegment = Header -> Owner;
   if (PspSegment < FP_SEG(ArenaHeadPtr))
      {
      if (Message_Number == 0xff)  Message_Number = BlankMsg;
      }
   else
      {
      FP_SEG(EnvironmentSegmentPtr) = PspSegment;
      FP_OFF(EnvironmentSegmentPtr) = 44;

      if (PspSegment == FP_SEG(Header)+1)
	 Message_Number = ProgramMsg;
      else
         if (*EnvironmentSegmentPtr == FP_SEG(Header)+1)
	    Message_Number = EnvironMsg;
	 else
	    Message_Number = DataMsg;
      }

   InRegs.x.ax = Message_Number;
   InRegs.h.dh = Utility_Msg_Class;
   sysgetmsg(&InRegs,&SegRegs,&OutRegs);

   FP_OFF(Message_Buf)    = OutRegs.x.si;
   FP_SEG(Message_Buf)    = SegRegs.ds;

   i = 0;
   while (*Message_Buf != NUL)
      TypeText[i++] = *Message_Buf++;
   TypeText[i++] = NUL;

   return(t);
}

/************************************************************************/
/* DisplayClassification						*/
/*	Main display proc for /C switch 				*/
/*									*/	
/* ENTRY:	none							*/
/*									*/	
/* EXIT:	none 							*/
/*									*/
/*									*/
/* CAVEATS:								*/
/*	Arenas owned by MEM are marked as FREE				*/	
/*									*/	
/*	display memory break up for conventional and upper memory	*/
/*									*/	
/************************************************************************/

void DisplayClassification()
{

   int               i, msgtype, dd;
   unsigned long     memsize;
   char             *nameptr;
   char              temp1[12], temp2[12], temp3[12];
   struct ARENA far *ArenaPtr;

   mprintf (NewLineMsg,    "");
   mprintf (CTtlTitleMsg,  "");
   mprintf (NewLineMsg,    "");
   mprintf (CTtlNameMsg,   "");
   mprintf (CTtlUScoreMsg, "");

   for (i = 0; i < mem_table.noof_progs; i++)
      {
      if (mem_table.files[i].psp_addr  < 1)  continue; /* Display FREE last */
      if (mem_table.files[i].psp_addr == 7)
         {
         if ((dd = mem_table.files[i].driveridx) == MAX_DDRIVER_REP)
            {
	    continue;
	    }
	 }

      msgtype = 0;
      if (mem_table.files[i].psp_addr == 8)
	 {
	 msgtype = (mem_table.files[i].umb_ttl) ? SystemMsg : IbmdosMsg;
	 }

      memsize = mem_table.files[i].conv_ttl + mem_table.files[i].umb_ttl;
      sprintf (temp1, "(%ldK)", toK (mem_table.files[i].conv_ttl));
      sprintf (temp2, "(%ldK)", toK (mem_table.files[i].umb_ttl));
      sprintf (temp3, "(%ldK)", toK (memsize));

      if (msgtype)
         {
	 mprintf (MainCLineMsg, "%-8m%8ld%7c%8ld%7c%8ld%7c", msgtype,
	      &memsize, temp3, &mem_table.files[i].conv_ttl, temp1,
	                        &mem_table.files[i].umb_ttl, temp2);
	 }
      else
	 {
	 if (mem_table.files[i].psp_addr == 7)
	    {
	    nameptr = ddrivername[dd];
	    }
	 else
	    {
	    FP_SEG(ArenaPtr) = mem_table.files[i].psp_addr -1;
	    FP_OFF(ArenaPtr) = 0;
	    nameptr = OwnerOf(ArenaPtr);
            }

	 mprintf (MainCLineMsg, "%-8c%8ld%7c%8ld%7c%8ld%7c", nameptr,
	      &memsize, temp3, &mem_table.files[i].conv_ttl, temp1,
	                        &mem_table.files[i].umb_ttl, temp2);
	 }
      }

   for (i = 0; i < mem_table.noof_progs; i++)  /* There should be only 1 */
      {