home *** CD-ROM | disk | FTP | other *** search
/ Lion Share / lionsharecd.iso / utils_mz / v10n11.zip / DPMIMEM.C < prev    next >
Text File  |  1991-05-10  |  4KB  |  155 lines
  1. /*
  2. DPMIMEM.C -- Demonstrates DPMI and Windows 3.0 DOS extender
  3.  
  4. Microsoft C: cl -AS dpmimem.c
  5. Turbo C:     tcc -ms dpmimem.c
  6.  
  7. Copyright (c) 1991 Ziff Communications Co.
  8.     PC Magazine * Andrew Schulman
  9. */
  10.  
  11. #ifdef __TURBOC__
  12. #pragma inline
  13. #define _asm                    asm
  14. #define _dos_allocmem(x,y)      (allocmem(x, y) != -1)
  15. #else
  16. #define MK_FP(seg, ofs) \
  17.     ((void far *) (((unsigned long) (seg) << 16) | (ofs)))
  18. #endif
  19.  
  20. #include <stdlib.h>
  21. #include <stdarg.h>
  22. #include <stdio.h>
  23. #include <time.h>
  24. #include <dos.h>
  25.  
  26. typedef enum { FALSE, TRUE } BOOL;
  27.  
  28. /* Call MS-DOS Terminate Process with Return Code function
  29.    (INT 21h AH=4Ch), in either real or protected mode */
  30. void dos_exit(unsigned err)
  31. { 
  32.     _asm mov al, err
  33.     _asm mov ah, 4Ch
  34.     _asm int 21h
  35. }
  36.  
  37. /* Call Windows Release Time-Slice function (INT 2Fh AX=1680h) */
  38. void win_yield(void)
  39. {
  40.     _asm mov ax, 1680h
  41.     _asm int 2Fh
  42. }
  43.  
  44. /* Call the Windows Enhanced Mode Install Check function
  45.    (INT 2Fh AX=1600h) */
  46. BOOL win_3enh(void)
  47. {
  48.     unsigned char vers;
  49.     _asm mov ax, 1600h
  50.     _asm int 2Fh
  51.     _asm mov vers, al
  52.     return (vers && (! (vers == 0x80 || vers == 1 || vers == 0xFF)));
  53. }
  54.  
  55. void fail(char *s)       { puts(s); dos_exit(1); }
  56.  
  57. /* Call the DPMI Mode Detection function (INT 2Fh AX=1686h) to
  58.    see if we are *already* running in protected mode under DPMI */
  59. BOOL dpmi_present(void)
  60. {
  61.     unsigned _ax;
  62.     _asm mov ax, 1686h
  63.     _asm int 2Fh
  64.     _asm mov _ax, ax
  65.     return (! _ax);
  66. }
  67.  
  68. /* Call the DPMI function for Obtaining the Real to Protected
  69.    Mode Switch Entry Point (INT 2Fh AX=1687h), to determine if
  70.    DPMI is available and, if so, switch into protected mode by
  71.    calling the Switch Entry Point */
  72. BOOL dpmi_init(void)
  73. {
  74.     unsigned rds, rcs;
  75.     void (far *dpmi)();
  76.     unsigned hostdata_seg, hostdata_para, dpmi_flags;
  77.     _asm mov ax, 1687h           // test for DPMI presence
  78.     _asm int 2Fh
  79.     _asm and ax, ax
  80.     _asm jnz nodpmi              // if (AX == 0) DPMI is present
  81.     _asm mov dpmi_flags, bx
  82.     _asm mov hostdata_para, si   // paras for DPMI host private data
  83.     _asm mov dpmi, di
  84.     _asm mov dpmi+2, es          // DPMI protected-mode switch entry point
  85.     _asm jmp short gotdpmi
  86. nodpmi:
  87.     return FALSE;
  88. gotdpmi:
  89.     if (_dos_allocmem(hostdata_para, &hostdata_seg) != 0)
  90.         fail("can't allocate memory");
  91.     
  92.     dpmi_flags &= ~1;   /* this is a 16-bit protected-mode program */
  93.     
  94.     _asm mov rds, ds
  95.     _asm mov rcs, cs
  96.     printf("DS=%04X CS=%04X in real mode\n", rds, rcs);
  97.     
  98.     /* enter protected mode */
  99.     _asm mov ax, hostdata_seg
  100.     _asm mov es, ax
  101.     _asm mov ax, dpmi_flags
  102.     (*dpmi)();
  103.  
  104.     /* now in protected mode */
  105.     _asm mov rds, ds
  106.     _asm mov rcs, cs
  107.     printf("DS=%04X CS=%04X in protected mode\n", rds, rcs);
  108.         
  109.     return TRUE;
  110. }
  111.  
  112. /* Call the MS-DOS Allocate Memory Block function (INT 21h AH=48h),
  113.    via the compiler's library function. The Windows DOS extender
  114.    provides INT 21h AH=48h in protected mode. */
  115. void far *my_malloc(unsigned bytes)
  116. {
  117.     unsigned seg;
  118.     return (_dos_allocmem(bytes >> 4, &seg)) ? 0 : MK_FP(seg, 0) ;
  119. }
  120.  
  121. #define SIZE        20480
  122.  
  123. main()
  124. {
  125.     unsigned long bytes = 0;
  126.     char far *fp;
  127.     time_t t1, t2;
  128.     
  129.     if (! dpmi_present())
  130.         if (! dpmi_init())
  131.             fail("This program requires DPMI");   
  132.         
  133.     /* now in protected mode */
  134.     
  135.     if (! win_3enh())
  136.         puts("Running under DPMI, but not under Windows 3.x enhanced mode");
  137.  
  138.     /* allocation loop */
  139.     time(&t1);
  140.     while (fp = my_malloc(SIZE))
  141.     {
  142.         *fp = 'x';
  143.         fp[SIZE-1] = 'y';
  144.         bytes += SIZE;
  145.         win_yield();
  146.     }
  147.     time(&t2);
  148.     
  149.     printf("Allocated %lu bytes in %lu seconds\n", bytes, t2 - t1);
  150.     printf("Press ENTER to release memory...");
  151.     fflush(stdout);
  152.     getchar();
  153.     dos_exit(0);
  154. }
  155.