dmake/msdos/dirlib.c

   1 /*
   2             DIRLIB for MS-DOS
   3             -----------------
   4
   5 Enclosed is an implementation of the `dirlib' package for MS-DOS.
   6 The implementation is targeted for MS-C, although any reasonably
   7 competent C compiler should manage.  The package consists of:
   8
   9     dir.h       the header file
  10     dir.c       the functions
  11     testdir.c   a q&d test program
  12
  13 The package tries to view directory naming in a Un*x light; in particular,
  14 directories such as '/.' and '/..' (as well as `.' and `..' if your
  15 current directory is root) are understood.   Indefinite paths like
  16 `/../.././../..' will correctly refer to the root (of the particular disk).
  17 Names such as `a:////./../' are okay too.
  18
  19 I've tried to be as sensible about DTA's as possible, since you never
  20 know who will be using one; they are set before use, and reset afterwards.
  21
  22 There is some cruft in the package, namely the way `seekdir' and
  23 `telldir' are done.  The code was derived from a little experimentation,
  24 and may not work after a certain point (although I believe the 2.x version
  25 to be solid).  Caveat utilitor.
  26
  27 Documentation for the package is available in the public domain; the
  28 package's functionality was derived from this documentation.
  29
  30 Bug reports and comments are welcome.  Enjoy!
  31
  32                 - Matt
  33
  34 -------
  35 UUCP:   {ucbvax,ihnp4,randvax,trwrb!trwspp,ism780}!ucla-cs!matt
  36 ARPA:   matt@LOCUS.UCLA.EDU
  37 Ph: (213) 825-2756
  38
  39 --------
  40 Modified for use in dmake by Dennis Vadura.  Mostly just clean up and an
  41 effort to make correctly typed objects are passed to functions in find.c.
  42 Also deleted all dos version 2.0 specific code.  It is not required any
  43 more.
  44 */
  45
  46 /*
  47  * revision history:
  48  *
  49  *  VER MM/DD/YY    COMMENTS
  50  *  ----    --------    --------
  51  *  0.99    02/24/86    Beta release to INTERNET
  52  */
  53
  54 #include <stdlib.h>
  55 #include <ctype.h>
  56 #include <errno.h>
  57 #include <string.h>
  58 #include <dos.h>
  59
  60 #include "dirent.h"
  61
  62 extern int find_err;
  63
  64
  65 static char *
  66 getdcwd(drive)
  67 int drive;
  68 {
  69    union REGS r;
  70    struct SREGS s;
  71    static char xcwd[64];
  72    char far *cwd = xcwd;
  73
  74    r.h.ah = 0x47;
  75    r.h.dl = drive;
  76    r.x.si = FP_OFF(cwd);
  77    s.ds = FP_SEG(cwd);
  78    intdosx(&r, &r, &s);
  79    find_err = r.x.ax;
  80    if (r.x.cflag)
  81       return (char *) 0;
  82    return xcwd;
  83 }
  84
  85
  86
  87 /*
  88  * opendir
  89  */
  90
  91 #define SUFFIX  "\\*.*"
  92 #define SLASH   "\\"
  93 #define streq(a,b)  (strcmp(a,b)==0)
  94
  95 DIR *
  96 opendir(name)
  97 char *name;
  98 {
  99    register DIR *nd;
 100    char *cwd;
 101    char drive[3];
 102    int atroot = 0;
 103    int rooted = 0;
 104
 105    /*
 106    * hack off drive designator if present
 107    */
 108
 109    if (name[1] == ':') {
 110       cwd = getdcwd(toupper(name[0]) - 'A' + 1);
 111       drive[0] = name[0]; drive[1] = ':'; drive[2] = '\0';
 112       name += 2;
 113    }
 114    else {
 115       cwd = getdcwd(0);
 116       drive[0] = '\0';
 117    }
 118
 119    /* is the name 'rooted'? */
 120    if ((*name == '/') || (*name == '\\')) ++rooted;
 121
 122    /* see if we are at the root directory for this device */
 123    if (!*cwd) ++atroot;
 124
 125    /*
 126    * MSDOS '/' doesn't have a '.' or '..'
 127    * also, double '/' sequences don't make sense.
 128    * many ported programs expect them to work, so we fix it up...
 129    */
 130
 131    /* chop off leading . and .. if at root */
 132    if (atroot && (*name == '.')) {
 133       switch (*++name) {
 134      case '\0':
 135      case '/':
 136      case '\\':
 137         break;
 138
 139      case '.':
 140         switch (*++name) {
 141            case '\0':
 142            case '/':
 143            case '\\':
 144             break;
 145            default:
 146             --name;
 147             --name;
 148         }
 149         break;
 150
 151      default:
 152         --name;
 153       }
 154    }
 155
 156    /* chop off leading /'s, /.'s and /..'s to make naming sensible */
 157    while (*name && ((*name == '/') || (*name == '\\'))) {
 158       if (*++name == '.') {
 159      switch (*++name) {
 160         case '\0':
 161         case '/':
 162         case '\\':
 163            break;
 164
 165         case '.':
 166            switch (*++name) {
 167           case '\0':
 168           case '/':
 169           case '\\':
 170               break;
 171
 172          default:
 173               --name;
 174               --name;
 175            }
 176            break;
 177
 178         default:
 179            --name;
 180      }
 181       }
 182    }
 183
 184
 185    /*
 186    * name should now look like: path/path/path
 187    * we must now construct name based on whether or not it
 188    * was 'rooted' (started with a /)
 189    */
 190
 191    if (rooted) cwd = "";
 192
 193    /* construct DIR */
 194    if (!(nd = (DIR *)malloc(
 195       sizeof(DIR)+strlen(drive)+strlen(cwd)+strlen(SLASH)+
 196       strlen(name)+strlen(SUFFIX))))
 197       return (DIR *) 0;
 198
 199    /* create long name */
 200    strcpy(nd->dd_name, drive);
 201    if (*cwd) {
 202       strcat(nd->dd_name, SLASH);
 203       strcat(nd->dd_name, cwd);
 204    }
 205    if (*name) {
 206       strcat(nd->dd_name, SLASH);
 207       strcat(nd->dd_name, name);
 208    }
 209    strcat(nd->dd_name, SUFFIX);
 210
 211    /* search */
 212    if (!findfirst(&nd->dd_name[0], &nd->dd_dta)) {
 213       free((char *)nd);
 214       errno = ENOENT;
 215       return (DIR *) 0;
 216    }
 217    nd->dd_stat = 0;
 218    return nd;
 219 }
 220
 221
 222 struct dirent *
 223 readdir(dirp)
 224 DIR *dirp;
 225 {
 226    static struct dirent dir;
 227
 228    if (dirp->dd_stat)
 229       return (struct dirent *) 0;
 230
 231    /* format structure */
 232    dir.d_ino = 0; /* not valid for DOS */
 233    dir.d_reclen = 0;
 234    strcpy(dir.d_name, dirp->dd_dta.name);
 235    dir.d_namlen = strlen(dir.d_name);
 236    strlwr(dir.d_name); /* DOSism */
 237
 238    /* read ahead */
 239    if (findnext(&dirp->dd_dta) != NULL)
 240       dirp->dd_stat = 0;
 241    else
 242       dirp->dd_stat = find_err;
 243
 244    return &dir;
 245 }
 246
 247
 248 void
 249 closedir(dirp)
 250 DIR *dirp;
 251 {
 252    free((char *)dirp);
 253 }
 254
 255
 256 void
 257 seekdir(dirp, pos)
 258 DIR *dirp;
 259 long pos;
 260 {
 261    /*
 262    * check against DOS limits
 263    */
 264
 265    if ((pos < 0) || (pos > 4095)) {
 266       dirp->dd_stat = 1;
 267       return;
 268    }
 269
 270    *(short *)&dirp->dd_dta.fcb[13] = pos + 1;
 271
 272    /* read ahead */
 273    if (findnext(&dirp->dd_dta))
 274       dirp->dd_stat = 0;
 275    else
 276       dirp->dd_stat = find_err;
 277 }
 278
 279
 280 long
 281 telldir(dirp)
 282 DIR *dirp;
 283 {
 284    return (long) (*(short *)&dirp->dd_dta.fcb[13] - 2);
 285 }