home *** CD-ROM | disk | FTP | other *** search
/ Turbo Toolbox / Turbo_Toolbox.iso / dtx9203 / ctrick / mi.c < prev    next >
Encoding:
C/C++ Source or Header  |  1992-04-14  |  6.9 KB  |  354 lines
  1. /* ------------------------------------------------------ */
  2. /*                     MI.C                               */
  3. /*                Memory Information                      */
  4. /*        (c) 1992 Michael Winter & DMV-Verlag            */
  5. /* ------------------------------------------------------ */
  6.  
  7. #include <stdio.h>
  8. #include <bios.h>
  9. #include <stdlib.h>
  10. #include "mytools.h"
  11.  
  12. far * xmm;
  13. unsigned xmmerror;
  14.  
  15. /* --- Funktions-Prototypen ----------------------------- */
  16.  
  17. int main(void);
  18. bool is_at(void);
  19. unsigned get_free_ext(void);
  20. unsigned char read_cmos(int adresse);
  21. bool exist_emm(void);
  22. unsigned ems_total(void);
  23. unsigned ems_avail(void);
  24. bool exist_xmm(void);
  25. far * get_entry(void);
  26. bool xmm_init(void);
  27. void get_xmm_version(unsigned *xmmversion,
  28.                      unsigned *driverversion,
  29.                      unsigned *hmaindicator);
  30. unsigned hma_avail( void );
  31. unsigned get_max_xms(void);
  32. unsigned get_free_xms(void);
  33. bool dr_dos();
  34. bool doskey();
  35. bool taskswitch();
  36.  
  37. /* --- Funktionen --------------------------------------- */
  38.  
  39. int main(void)
  40. {
  41.   unsigned  totram, freeram,
  42.             totems, freeems,
  43.             totext, freeext,
  44.             totxms, freexms,
  45.             xmmver, xmmdrvver, hma,
  46.             freehma;
  47.  
  48.   bool ms_dos;
  49.  
  50.   if ( dr_dos() )
  51.     ms_dos = 0;
  52.   else
  53.     ms_dos = 1;
  54.  
  55.   totems = ems_total();
  56.   freeems = ems_avail();
  57.  
  58.   totram = _bios_memsize();
  59.   freeram = ((((unsigned long) totram * 1024) -
  60.                (unsigned long)(_psp * 16)) / 1024);
  61.  
  62.   if (is_at())
  63.   {
  64.     totext = (256 * read_cmos(24) + read_cmos(23));
  65.     freeext = get_free_ext();
  66.     if (xmm_init())
  67.     {
  68.       totxms = get_free_xms();
  69.       freexms = get_max_xms();
  70.     }
  71.     else
  72.     {
  73.       totxms = 0;
  74.       freexms = 0;
  75.     }
  76.   }
  77.   else
  78.   {
  79.     totext = 0;
  80.     freeext = 0;
  81.     totxms = 0;
  82.     freexms = 0;
  83.   }
  84.   printf("\nMI - ");
  85.   printf("Memory Information ");
  86.   printf("(c) 1992 Michael Winter & DMV-Verlag\n");
  87.   printf("\nBetriebssystem  : ");
  88.   if ( ms_dos )
  89.     printf("MS-/PC-DOS");
  90.   else
  91.     printf("DR-DOS");
  92.   printf(" %d.%d\n", _osmajor, _osminor);
  93.   printf("\nArbeitsspeicher : %d KBytes", totram);
  94.   printf("\nDavon frei      : %d KBytes\n", freeram);
  95.   printf("\nExpanded Memory : %d KBytes", totems);
  96.   printf("\nDavon frei      : %d KBytes\n", freeems);
  97.   printf("\nExtended Memory : %d KBytes", totext);
  98.   printf("\nDavon frei      : %d KBytes für Zugriff mit ");
  99.   printf("Int 15H\n", freeext);
  100.   printf("\nXMS Memory      : %d KBytes frei", totxms);
  101.   printf("\nGrößter Block   : %d KBytes\n", freexms);
  102.   if (exist_xmm())
  103.   {
  104.     get_xmm_version(&xmmver, &xmmdrvver, &hma);
  105.     printf("\nSpezifikation : %X.%X     ");
  106.     printf("Treiberversion : %X.%X     ",
  107.            hi(xmmver),    lo(xmmver),
  108.            hi(xmmdrvver), lo(xmmdrvver));
  109.     if (hma == 1)
  110.     {
  111.       printf("HMA : existiert\n\n");
  112.       printf("                ");
  113.       printf("65520 Bytes gesamt in der HMA\n");
  114.       if ( (_osmajor >= 5) && ms_dos )
  115.       {
  116.         freehma = hma_avail();
  117.         if ( freehma > 0 )
  118.         {
  119.           printf("                ");
  120.           printf("Das DOS befindet sich in der HMA,\n");
  121.           printf("                ");
  122.           printf("noch %d Bytes verfügbar in der HMA\n",
  123.                  freehma );
  124.         }
  125.       }
  126.     }
  127.     else
  128.       printf("HMA : nicht vorhanden\n");
  129.   }
  130.   if ( doskey() )
  131.     printf("\nDOSKEY ist installiert");
  132.   if ( taskswitch() )
  133.     printf("\nProgrammumschaltung ist aktiviert");
  134.  
  135.   exit(0);
  136. }
  137.  
  138. bool is_at(void)
  139. {
  140.   if ( (byte) peekb(0xF000, 0xFFFE) == 0xFC )
  141.     return 1;
  142.   else
  143.     return 0;
  144. }
  145.  
  146. unsigned get_free_ext(void)
  147. {
  148.   union REGS regs;
  149.  
  150.   regs.h.ah = 0x88;
  151.   int86(0x15, ®s, ®s);
  152.   return regs.x.ax;
  153. }
  154.  
  155. unsigned char read_cmos(int adresse)
  156. {
  157.   outp(0x70, adresse);
  158.   return(inp(0x71));
  159. }
  160.  
  161. bool exist_emm(void)
  162. {
  163.   static char emm_name[] = {'E','M','M','X',
  164.                             'X','X','X','0'};
  165.   union REGS regs;
  166.   struct SREGS sregs;
  167.   char i;
  168.   unsigned char *emm_inspect;
  169.  
  170.   regs.x.ax =0x3567;
  171.  
  172.   intdosx(®s, ®s, &sregs);
  173.  
  174.   emm_inspect = (unsigned char *) MK_FP(sregs.es, 10);
  175.  
  176.   for (i=0; i<sizeof emm_name &&
  177.             *(emm_inspect++)==emm_name[i++];);
  178.     return( i == sizeof emm_name);
  179. }
  180.  
  181. unsigned ems_total(void)
  182. {
  183.   union REGS regs;
  184.  
  185.   if (exist_emm())
  186.   {
  187.     regs.h.ah = 0x42;
  188.     int86(0x67, ®s, ®s);
  189.     return (regs.x.dx * 16384);
  190.   }
  191.   else
  192.     return 0;
  193. }
  194.  
  195. unsigned ems_avail(void)
  196. {
  197.   union REGS regs;
  198.  
  199.   if (exist_emm())
  200.   {
  201.     regs.h.ah = 0x42;
  202.     int86(0x67, ®s, ®s);
  203.     return(regs.x.bx * 16384);
  204.   }
  205.   else
  206.     return 0;
  207. }
  208.  
  209. /* --- existiert XMM ? ---------------------------------- */
  210.  
  211. bool exist_xmm(void)
  212. {
  213.   _asm
  214.   {
  215.     mov ax, 0x4300;
  216.     int 0x2F;
  217.     and ax, 0x80;
  218.     jz  Exit;
  219.     mov ax, 1;
  220.   Exit:
  221.   }
  222. }
  223.  
  224. /* --- Entrypoint ermitteln ----------------------------- */
  225.  
  226. far * get_entry(void)
  227. {
  228.   if (exist_xmm())
  229.     _asm
  230.     {
  231.       mov ax, 0x4310;
  232.       int 0x2F;
  233.       mov dx, es;
  234.       mov ax, bx;
  235.     }
  236.   else
  237.     _asm
  238.     {
  239.       mov dx, 0;
  240.       mov ax, 0;
  241.     }
  242. }
  243.  
  244. /* --- XMM-Variablen für Zugriff Initialisieren --------- */
  245.  
  246. bool xmm_init(void)
  247. {
  248.   if (exist_xmm())
  249.   {
  250.     xmm = get_entry();
  251.     return 1;
  252.   }
  253.   else
  254.     return 0;
  255. }
  256.  
  257. void get_xmm_version(unsigned *xmmversion,
  258.                      unsigned *driverversion,
  259.                      unsigned *hmaindicator)
  260. {
  261.   unsigned a, b, d;
  262.  
  263.   _asm
  264.   {
  265.     mov ax, 0;
  266.     call xmm;
  267.     mov a, ax;
  268.     mov b, bx;
  269.     mov d, dx;
  270.     mov xmmerror, bl;
  271.   }
  272.   *xmmversion = a;
  273.   *driverversion = b;
  274.   *hmaindicator = d;
  275. }
  276.  
  277. unsigned hma_avail( void )
  278. {
  279.   unsigned s;
  280.  
  281.   _asm
  282.   {
  283.     mov ax, 0x4A01;
  284.     int 0x2F;
  285.     mov s, bx;
  286.   }
  287.  
  288.   return s;
  289. }
  290.  
  291. /* --- größter freier Block ----------------------------- */
  292.  
  293. unsigned get_max_xms(void)
  294. {
  295.   _asm
  296.   {
  297.     mov ah, 0x08;
  298.     call xmm;
  299.     mov ax, dx;
  300.   }
  301. }
  302.  
  303. /* --- freier XMS - Speicher ---------------------------- */
  304.  
  305. unsigned get_free_xms(void)
  306. {
  307.   _asm
  308.   {
  309.     mov ah, 0x08;
  310.     call xmm;
  311.   }
  312. }
  313.  
  314. /* --- DR-DOS oder MS-/PC-DOS --------------------------- */
  315.  
  316. bool dr_dos()
  317. {
  318.   union REGS regs;
  319.  
  320.   regs.x.ax = 0x4452;
  321.   intdos( ®s, ®s );
  322.   return !regs.x.cflag;
  323. }
  324.  
  325. bool doskey()
  326. {
  327.   union REGS regs;
  328.  
  329.   regs.x.ax = 0x4800;
  330.   int86( 0x2F, ®s, ®s );
  331.   if ( regs.h.al != 0 )
  332.     return 1;
  333.   else
  334.     return 0;
  335. }
  336.  
  337. bool taskswitch()
  338. {
  339.   union REGS regs;
  340.   struct SREGS sregs;
  341.  
  342.   regs.x.ax = 0x4B02;
  343.   regs.x.bx = 0x0000;
  344.   sregs.es = 0x0000;
  345.   regs.x.di = 0x0000;
  346.   int86x( 0x2F, ®s, ®s, &sregs );
  347.   if ( (sregs.es == 0x0000) && (regs.x.di == 0x0000) )
  348.     return 0;
  349.   else
  350.     return 1;
  351. }
  352. /* ------------------------------------------------------ */
  353. /*                Ende von MI.C                           */
  354.