home *** CD-ROM | disk | FTP | other *** search
/ norge.freeshell.org (192.94.73.8) / 192.94.73.8.tar / 192.94.73.8 / pub / computers / pcjr / arc / PAKUTL12.LZH / DIRFN.C < prev    next >
Text File  |  1988-08-20  |  5KB  |  191 lines
  1. /*
  2.     DIRFN.C:    DOS disk directory functions for MSC 4.0
  3.  
  4.     Copyright 1987,1988 Michael J. Housky
  5.     Released to the public domain: Aug 20, 1988 by Michael J. Housky
  6. */
  7.  
  8. /* ***temp*** are these really necessary?
  9. #include <ctype.h>
  10. #include <direct.h>
  11. #include <errno.h>
  12. #include <string.h>
  13. */
  14. #include <stdio.h>        /* only used for NULL definition */
  15. #include <dos.h>
  16. #include <stdlib.h>
  17.  
  18. #include "dirfn.h"
  19.  
  20. /* ------------    Macros: */
  21.  
  22. #if !defined(STATIC)    /* debug switch to make locals public for symdeb */
  23. #define STATIC static
  24. #else
  25. #undef STATIC
  26. #define STATIC /* static */
  27. #endif
  28.  
  29.  
  30. /*.PA*/
  31. /*
  32.     cur_dta:    Return current DTA address.
  33.  
  34. Input:
  35.     (none)
  36.  
  37. Return:
  38.     Return far pointer to current DTA.
  39.  
  40. */
  41.  
  42. char far *cur_dta();
  43.  
  44. char far *cur_dta( )
  45. {
  46.     union REGS    regs;        /* registers for DOS call */
  47.     struct SREGS
  48.         sregs;        /* segment registers */
  49.     char    far *pd;    /* pointer to DTA */
  50.  
  51.     regs.h.ah = 0x2F;            /* function = Get DTA */
  52.     intdosx( ®s, ®s, &sregs );
  53.     FP_SEG(pd) = sregs.es;        /* get seg part of DTA */
  54.     FP_OFF(pd) = regs.x.bx;        /* get offset of DTA */
  55.     return pd;                /* return far DTA pointer */
  56.  
  57. } /* cur_dta */
  58.  
  59.  
  60. /*.PA*/
  61. /*
  62.     set_dta:    Set DOS Disk Transfer Address.
  63.  
  64. Input:
  65.     pdta    = far pointer to DTA.
  66.  
  67. Return:
  68.     Return far pointer to current DTA.
  69.  
  70. */
  71.  
  72. void set_dta( char far * );
  73.  
  74. void set_dta( pdta )
  75.     char    far *pdta;    /* pointer to new DTA */
  76. {
  77.     union REGS    regs;        /* registers for DOS call */
  78.     struct SREGS
  79.         sregs;        /* segment registers */
  80.     char    far *pd;    /* pointer to DTA */
  81.  
  82.     regs.h.ah = 0x1A;            /* function = Set DTA */
  83.     regs.x.dx = FP_OFF(pdta);        /* set DS:DX = DTA address */
  84.     sregs.ds  = FP_SEG(pdta);
  85.     intdosx( ®s, ®s, &sregs );
  86.     return; 
  87.  
  88. } /* set_dta */
  89.  
  90.  
  91. /*.PA*/
  92. /*
  93.     dir_sscan:    Start a directory scan.
  94.  
  95. Input:
  96.     pdta:    Pointer to directory search DTA, or NULL to have
  97.          the area malloc'ed.
  98.     fn:    Filespec to match, includes d:path if desired.
  99.     attr:    Attribute to match, zero for normal search.
  100. Output:
  101.     Starts directory scan, if good filespec and any match.
  102.     
  103. Return:
  104.     Result is pointer to DTA, containing first file found, or NULL
  105.     if and error was encountered. (No file found, bad disk or path,
  106.     etc.)
  107. */
  108.  
  109. FIND_DTA *dir_sscan( pdta, fn, attr )
  110.     FIND_DTA    *pdta;        /* pointer to caller's DTA struct, or NULL */
  111.     char    *fn;        /* drive:path\filename to match */
  112.     int        attr;        /* attribute bits to match */
  113. {
  114.     union REGS    regs;        /* registers for DOS call */
  115.     struct SREGS
  116.         sregs;        /* segment registers */
  117.     FIND_DTA    *pd,        /* pointer to find file DTA */
  118.         far *fpd;    /* far pointer to Find file DTA */
  119.     char    far *ffn;    /* far pointer to fname */
  120.     char    far *old_dta;    /* save area for current DTA */
  121.  
  122.     if ( pdta==NULL )
  123.     {
  124.  
  125.     pd = (FIND_DTA*) malloc( sizeof(FIND_DTA) );
  126.     if ( pd==NULL )
  127.         return pd;
  128.     }
  129.     else
  130.     pd = pdta;
  131.     fpd = (FIND_DTA far *) pd;        /* make far DTA pointer */
  132.     ffn = (char far *) fn;        /* make far fname pointer */
  133.  
  134.     old_dta = cur_dta();
  135.     set_dta( (char far *) fpd );
  136.  
  137.     regs.h.ah = 0x4E;            /* function = Find first */
  138.     regs.x.cx = attr;            /* CX = attribute */
  139.     regs.x.dx = FP_OFF(ffn);        /* ds:dx = fname pointer */
  140.     sregs.ds  = FP_SEG(ffn);
  141.     intdosx( ®s, ®s, &sregs );
  142.     set_dta( old_dta );            /* restore old DTA */
  143.     if ( regs.x.cflag )            /* test for error */
  144.     {
  145.     if ( pdta==NULL )        /* was DTA malloc'ed? */
  146.         free( (char*) pd );        /*  free it if so */
  147.     return NULL;            /* return NULL in any case */
  148.     }
  149.     return pd;                /* good result, return DTA pointer */
  150.  
  151. } /* dir_sscan */
  152.  
  153.  
  154. /*.PA*/
  155. /*
  156.     dir_cscan:    Continue a directory scan.
  157.  
  158. Input:
  159.     pdta    = Pointer to DTA established by prior dir_sscan call.
  160.  
  161. Return:
  162.     Return (pdta) if next file found, and *pdta contains description
  163.     of file.
  164.     Return NULL if error encountered. (No more matching files, etc.)
  165. */
  166.  
  167. FIND_DTA *dir_cscan( pdta )
  168.     FIND_DTA    *pdta;        /* pointer to caller's DTA struct, or NULL */
  169. {
  170.     union REGS    regs;        /* registers for DOS call */
  171.     struct SREGS
  172.         sregs;        /* segment registers */
  173.     FIND_DTA    
  174.         far *fpd;    /* far pointer to Find file DTA */
  175.     char    far *old_dta;    /* save area for current DTA */
  176.  
  177.     fpd = (FIND_DTA far *) pdta;    /* make far DTA pointer */
  178.  
  179.     old_dta = cur_dta();
  180.     set_dta( (char far *)fpd );
  181.  
  182.     regs.h.ah = 0x4F;            /* function = Find next */
  183.     intdosx( ®s, ®s, &sregs );
  184.     set_dta( old_dta );            /* restore old DTA */
  185.     if ( regs.x.cflag )            /* test for error */
  186.     return NULL;            /*  return NULL if so */
  187.     return pdta;            /* good result, return DTA pointer */
  188.  
  189. } /* dir_cscan */
  190.  
  191.