home *** CD-ROM | disk | FTP | other *** search
/ Liren Large Software Subsidy 10 / 10.iso / l / l440 / 2.ddi / CHAP5 / DOSSWAP.C < prev    next >
Encoding:
C/C++ Source or Header  |  1991-01-21  |  5.7 KB  |  185 lines
  1. /* DOSSWAP.C - Functions to manage DOS swap areas */
  2.  
  3. #include <stdlib.h>
  4. #include <dos.h>
  5. #include <memory.h>
  6. #include "tsr.h"
  7.  
  8. #define GET_DOSSWAP3       0x5d06
  9. #define GET_DOSSWAP4       0x5d0b
  10.  
  11. #define SWAP_LIST_LIMIT    20     
  12.  
  13. struct  swap_list    /* format of DOS 4+ SDA list */
  14. {
  15.     void    far*    swap_ptr;
  16.             int     swap_size;
  17. };
  18.  
  19. /* variables for 3.x swap work */
  20. static   char  far *  swap_ptr;  /* pointer to dos swap area */
  21. static   char  far *  swap_save; /* pointer to our local save area */
  22. static   int   swap_size_indos;
  23. static   int   swap_size_always;
  24. static   int   size;
  25.  
  26. /* variables for 4.x swap work */
  27. static int swap_count;      /* count of swappable areas */
  28. static struct swap_list swp_list[SWAP_LIST_LIMIT]; /*list of swap areas*/
  29. static char far *swp_save[SWAP_LIST_LIMIT];   /* out save area */
  30. static int swp_flag[SWAP_LIST_LIMIT];   /* flags if has been swapped */
  31.  
  32. static int dos_level;    /* for level dependent code */
  33. int dos_critical;       /* in critical section, can't swap */
  34.  
  35. /*****
  36. Function: InitDosSwap
  37. Initialize pointers and sizes of DOS swap area. Return zero if success
  38. *****/
  39. int InitDosSwap(void)
  40. { 
  41.     union  REGS regs;
  42.     struct SREGS segregs;
  43.  
  44.     if ((_osmajor == 3) && (_osminor >= 10))
  45.         dos_level = 3;
  46.     else if (_osmajor >= 4)
  47.         dos_level = 4;
  48.     else
  49.         dos_level = 0;
  50.     
  51.     if (dos_level == 3)    /* use 215D06 */
  52.     {
  53.         regs.x.ax = GET_DOSSWAP3;   
  54.         intdosx(®s,®s,&segregs);
  55.         /* pointer to swap area is returned in DS:SI */
  56.         FP_SEG(swap_ptr) = segregs.ds;
  57.         FP_OFF(swap_ptr) = regs.x.si;
  58.    
  59.         swap_size_indos = regs.x.cx;
  60.         swap_size_always= regs.x.dx;
  61.  
  62.         size = 0;  /* initialize for later */
  63.         return ((swap_save = malloc(swap_size_indos)) == 0);
  64.     }
  65. /*
  66.     NOTE: Next line changed from version in UNDOCUMENTED DOS, p. 322
  67.     (first printing), where we tested DOS version number with == and
  68.     thereby lose the opportunity to run in DOS 5. This was just the
  69.     sort of thing we had warned against in Chapter 2 of the book!
  70. */
  71.     else if (dos_level >= 4)  /* use 5d0b */
  72.     {
  73.         struct swap_list far *ptr;
  74.         int far *iptr;
  75.         int i;
  76.         regs.x.ax = GET_DOSSWAP4;   
  77.         intdosx(®s,®s,&segregs);
  78.         /* pointer to swap list is returned in DS:SI */
  79.         FP_SEG(iptr) = segregs.ds;
  80.         FP_OFF(iptr) = regs.x.si;
  81.         swap_count = *iptr;                   /* get size of list */
  82.         iptr++;
  83.         ptr = (struct swap_list far *) iptr;  /* create point to list */
  84.  
  85.         if (swap_count > SWAP_LIST_LIMIT)     /* too many data areas */
  86.             return 2;
  87.  
  88.         /* get pointers and sizes of data areas */
  89.         for (i = 0; i < swap_count; i++)
  90.         {
  91.             swp_list[i].swap_ptr = ptr->swap_ptr;
  92.             swp_list[i].swap_size= ptr->swap_size;
  93.             if (! (swp_save[i] = malloc(swp_list[i].swap_size & 0x7fff)))
  94.                 return 3;   /* out of memory */
  95.             swp_flag[i] = 0;
  96.             ptr++;   /* point to next entry in the list */
  97.         }
  98.         return 0;
  99.     }
  100.     else
  101.         return 1;   /* unsupported DOS */
  102. }
  103.  
  104. /*****
  105. Function: SaveDosSwap
  106. This function will save the dos swap area to a local buffer
  107. It returns zero on success, non-zero meaning can't swap 
  108. *****/ 
  109. int SaveDosSwap(void)
  110. {
  111.     if (dos_level == 3)
  112.     {
  113.         if (swap_ptr && !dos_critical)   
  114.         {
  115.             /* if INDOS flag is zero, use smaller swap size */
  116.             size = (*indos_ptr) ? swap_size_indos : swap_size_always;
  117.               
  118.             movedata(FP_SEG(swap_ptr),  FP_OFF(swap_ptr), 
  119.                      FP_SEG(swap_save), FP_OFF(swap_save),
  120.                      size);
  121.         }
  122.         else       /* can't swap it */
  123.             return 1;
  124.     }
  125.     else if (dos_level == 4)
  126.     {
  127.         /* loop through pointer list and swap appropriate items */
  128.         int i;
  129.         for (i = 0; i < swap_count; i++)
  130.         {
  131.             if (swp_list[i].swap_size & 0x8000)  /* swap always */
  132.             {
  133.                 movedata(FP_SEG(swp_list[i].swap_ptr), 
  134.                          FP_OFF(swp_list[i].swap_ptr),
  135.                          FP_SEG(swp_save[i]),          
  136.                          FP_OFF(swp_save[i]),
  137.                          swp_list[i].swap_size & 0x7fff);
  138.             }
  139.             else if (*indos_ptr)     /* swap only if dos busy */
  140.             {
  141.                 movedata(FP_SEG(swp_list[i].swap_ptr), 
  142.                          FP_OFF(swp_list[i].swap_ptr),
  143.                          FP_SEG(swp_save[i]),          
  144.                          FP_OFF(swp_save[i]),
  145.                          swp_list[i].swap_size);
  146.             }
  147.         }
  148.     }
  149.     else 
  150.         return 1;
  151.    
  152.     return 0;
  153. }
  154.  
  155. /*****
  156. Function: RestoreDosSwap
  157. This function will restore a previously swapped dos data area
  158. *****/
  159. void RestoreDosSwap(void)
  160. {
  161.     if (dos_level == 3)
  162.     {
  163.         /* make sure its already saved and we have a good ptr */
  164.         if (size && swap_ptr)
  165.         {
  166.             movedata(FP_SEG(swap_save), FP_OFF(swap_save), 
  167.                      FP_SEG(swap_ptr),  FP_OFF(swap_ptr), size);
  168.             size = 0;
  169.         }
  170.     }
  171.     else if (dos_level == 4)
  172.     {
  173.         int i;
  174.         for (i = 0; i < swap_count; i++)
  175.         {
  176.             movedata(FP_SEG(swp_save[i]),          
  177.                      FP_OFF(swp_save[i]),
  178.                      FP_SEG(swp_list[i].swap_ptr), 
  179.                      FP_OFF(swp_list[i].swap_ptr),
  180.                      swp_list[i].swap_size);
  181.            swp_flag[i] = 0;   /* clear flag */
  182.         }
  183.     }
  184. }   
  185.