home *** CD-ROM | disk | FTP | other *** search
/ For Beginners & Professional Hackers / cd.iso / docum / dos-ref.doc / examples / chap5.arj / DOSSWAP.C < prev    next >
Encoding:
C/C++ Source or Header  |  1991-07-31  |  5.4 KB  |  179 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.     else if (dos_level == 4)  /* use 5d0b */
  66.     {
  67.         struct swap_list far *ptr;
  68.         int far *iptr;
  69.         int i;
  70.         regs.x.ax = GET_DOSSWAP3;             // was 4   
  71.         intdosx(®s,®s,&segregs);
  72.         /* pointer to swap list is returned in DS:SI */
  73.         FP_SEG(iptr) = segregs.ds;
  74.         FP_OFF(iptr) = regs.x.si;
  75.         swap_count = *iptr;                   /* get size of list */
  76.         iptr++;
  77.         ptr = (struct swap_list far *) iptr;  /* create point to list */
  78.  
  79.         if (swap_count > SWAP_LIST_LIMIT)     /* too many data areas */
  80.             return 2;
  81.  
  82.         /* get pointers and sizes of data areas */
  83.         for (i = 0; i < swap_count; i++)
  84.         {
  85.             swp_list[i].swap_ptr = ptr->swap_ptr;
  86.             swp_list[i].swap_size= ptr->swap_size;
  87.             if (! (swp_save[i] = malloc(swp_list[i].swap_size & 0x7fff)))
  88.                 return 3;   /* out of memory */
  89.             swp_flag[i] = 0;
  90.             ptr++;   /* point to next entry in the list */
  91.         }
  92.         return 0;
  93.     }
  94.     else
  95.         return 1;   /* unsupported DOS */
  96. }
  97.  
  98. /*****
  99. Function: SaveDosSwap
  100. This function will save the dos swap area to a local buffer
  101. It returns zero on success, non-zero meaning can't swap 
  102. *****/ 
  103. int SaveDosSwap(void)
  104. {
  105.     if (dos_level == 3)
  106.     {
  107.         if (swap_ptr && !dos_critical)   
  108.         {
  109.             /* if INDOS flag is zero, use smaller swap size */
  110.             size = (*indos_ptr) ? swap_size_indos : swap_size_always;
  111.               
  112.             movedata(FP_SEG(swap_ptr),  FP_OFF(swap_ptr), 
  113.                      FP_SEG(swap_save), FP_OFF(swap_save),
  114.                      size);
  115.         }
  116.         else       /* can't swap it */
  117.             return 1;
  118.     }
  119.     else if (dos_level == 4)
  120.     {
  121.         /* loop through pointer list and swap appropriate items */
  122.         int i;
  123.         for (i = 0; i < swap_count; i++)
  124.         {
  125.             if (swp_list[i].swap_size & 0x8000)  /* swap always */
  126.             {
  127.                 movedata(FP_SEG(swp_list[i].swap_ptr), 
  128.                          FP_OFF(swp_list[i].swap_ptr),
  129.                          FP_SEG(swp_save[i]),          
  130.                          FP_OFF(swp_save[i]),
  131.                          swp_list[i].swap_size & 0x7fff);
  132.             }
  133.             else if (*indos_ptr)     /* swap only if dos busy */
  134.             {
  135.                 movedata(FP_SEG(swp_list[i].swap_ptr), 
  136.                          FP_OFF(swp_list[i].swap_ptr),
  137.                          FP_SEG(swp_save[i]),          
  138.                          FP_OFF(swp_save[i]),
  139.                          swp_list[i].swap_size);
  140.             }
  141.         }
  142.     }
  143.     else 
  144.         return 1;
  145.    
  146.     return 0;
  147. }
  148.  
  149. /*****
  150. Function: RestoreDosSwap
  151. This function will restore a previously swapped dos data area
  152. *****/
  153. void RestoreDosSwap(void)
  154. {
  155.     if (dos_level == 3)
  156.     {
  157.         /* make sure its already saved and we have a good ptr */
  158.         if (size && swap_ptr)
  159.         {
  160.             movedata(FP_SEG(swap_save), FP_OFF(swap_save), 
  161.                      FP_SEG(swap_ptr),  FP_OFF(swap_ptr), size);
  162.             size = 0;
  163.         }
  164.     }
  165.     else if (dos_level == 4)
  166.     {
  167.         int i;
  168.         for (i = 0; i < swap_count; i++)
  169.         {
  170.             movedata(FP_SEG(swp_save[i]),          
  171.                      FP_OFF(swp_save[i]),
  172.                      FP_SEG(swp_list[i].swap_ptr), 
  173.                      FP_OFF(swp_list[i].swap_ptr),
  174.                      swp_list[i].swap_size);
  175.            swp_flag[i] = 0;   /* clear flag */
  176.         }
  177.     }
  178. }   
  179.