Subversion Repositories SvarDOS

Rev

Rev 538 | Rev 990 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
421 mateuszvis 1
/* This file is part of the SvarCOM project and is published under the terms
2
 * of the MIT license.
3
 *
4
 * Copyright (C) 2021 Mateusz Viste
5
 *
6
 * Permission is hereby granted, free of charge, to any person obtaining a
7
 * copy of this software and associated documentation files (the "Software"),
8
 * to deal in the Software without restriction, including without limitation
9
 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
10
 * and/or sell copies of the Software, and to permit persons to whom the
11
 * Software is furnished to do so, subject to the following conditions:
12
 *
13
 * The above copyright notice and this permission notice shall be included in
14
 * all copies or substantial portions of the Software.
15
 *
16
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
19
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
21
 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
22
 * DEALINGS IN THE SOFTWARE.
23
 */
24
 
368 mateuszvis 25
/*
26
 * dir
27
 *
28
 * Displays a list of files and subdirectories in a directory.
29
 *
30
 * DIR [drive:][path][filename] [/P] [/W] [/A[:]attributes] [/O[[:]sortorder]] [/S] [/B] [/L]
31
 *
32
 * /P Pauses after each screenful of information.
33
 * /W Uses wide list format.
34
 *
35
 * /A Displays file with specified attributes:
36
 *     D Directories           R Read-only files     H Hidden files
37
 *     A Ready for archiving   S System files        - prefix meaning "not"
38
 *
39
 * /O List files in sorted order:
40
 *     N by name            S by size              E by extension
41
 *     D by date            G group dirs first     - prefix to reverse order
42
 *
43
 * /S Displays files in specified directory and all subdirectories.
44
 * /B Uses bare format (no heading information or summary)
45
 * /L Uses lowercases
46
 */
47
 
396 mateuszvis 48
/* NOTE: /A attributes are matched in an exclusive way, ie. only files with
49
 *       the specified attributes are matched. This is different from how DOS
50
 *       itself matches attributes hence DIR cannot rely on the attributes
51
 *       filter within FindFirst.
52
 *
53
 * NOTE: Multiple /A are not supported - only the last one is significant.
54
 */
55
 
420 mateuszvis 56
#define WCOLWIDTH 15  /* width of a column in wide mode output */
57
 
424 mateuszvis 58
 
59
/* fills freebytes with free bytes for drv (A=0, B=1, etc)
60
 * returns DOS ERR code on failure */
61
static unsigned short cmd_dir_df(unsigned long *freebytes, unsigned char drv) {
62
  unsigned short res = 0;
63
  unsigned short sects_per_clust = 0, avail_clusts = 0, bytes_per_sect = 0;
64
 
65
  _asm {
66
    push ax
67
    push bx
68
    push cx
69
    push dx
70
 
71
    mov ah, 0x36  /* DOS 2+ -- Get Disk Free Space */
72
    mov dl, [drv] /* A=1, B=2, etc (0 = DEFAULT DRIVE) */
73
    inc dl
74
    int 0x21      /* AX=sects_per_clust, BX=avail_clusts, CX=bytes_per_sect, DX=tot_clusters */
75
    cmp ax, 0xffff /* AX=0xffff on error (invalid drive) */
76
    jne COMPUTEDF
77
    mov [res], 0x0f /* fill res with DOS error code 15 ("invalid drive") */
78
    jmp DONE
79
 
80
    COMPUTEDF:
81
    /* freebytes = AX * BX * CX */
82
    mov [sects_per_clust], ax
83
    mov [avail_clusts], bx
84
    mov [bytes_per_sect], cx
85
 
86
    DONE:
87
    pop dx
88
    pop cx
89
    pop bx
90
    pop ax
91
  }
92
 
93
  /* multiple steps to avoid uint16 overflow */
94
  *freebytes = sects_per_clust;
95
  *freebytes *= avail_clusts;
96
  *freebytes *= bytes_per_sect;
97
 
98
  return(res);
99
}
100
 
101
 
528 mateuszvis 102
static void dir_pagination(unsigned short *availrows) {
103
  *availrows -= 1;
104
  if (*availrows == 0) {
105
    press_any_key();
106
    *availrows = screen_getheight() - 1;
107
  }
108
}
109
 
110
 
542 mateuszvis 111
/* parse an attr list like "Ar-hS" and fill bitfield into attrfilter_may and attrfilter_must.
112
 * /AHS   -> adds S and H to mandatory attribs ("must")
113
 * /A-S   -> removes S from allowed attribs ("may")
114
 * returns non-zero on error. */
115
static int dir_parse_attr_list(const char *arg, unsigned char *attrfilter_may, unsigned char *attrfilter_must) {
116
  for (; *arg != 0; arg++) {
117
    unsigned char curattr;
118
    char not;
119
    if (*arg == '-') {
120
      not = 1;
121
      arg++;
122
    } else {
123
      not = 0;
124
    }
125
    switch (*arg) {
126
      case 'd':
127
      case 'D':
128
        curattr = DOS_ATTR_DIR;
129
        break;
130
      case 'r':
131
      case 'R':
132
        curattr = DOS_ATTR_RO;
133
        break;
134
      case 'a':
135
      case 'A':
136
        curattr = DOS_ATTR_ARC;
137
        break;
138
      case 'h':
139
      case 'H':
140
        curattr = DOS_ATTR_HID;
141
        break;
142
      case 's':
143
      case 'S':
144
        curattr = DOS_ATTR_SYS;
145
        break;
146
      default:
147
        return(-1);
148
    }
149
    /* update res bitfield */
150
    if (not) {
151
      *attrfilter_may &= ~curattr;
152
    } else {
153
      *attrfilter_must |= curattr;
154
    }
155
  }
156
  return(0);
157
}
158
 
159
 
160
#define DIR_ATTR_DEFAULT (DOS_ATTR_RO | DOS_ATTR_DIR | DOS_ATTR_ARC)
161
 
533 mateuszvis 162
static enum cmd_result cmd_dir(struct cmd_funcparam *p) {
393 mateuszvis 163
  const char *filespecptr = NULL;
388 mateuszvis 164
  struct DTA *dta = (void *)0x80; /* set DTA to its default location at 80h in PSP */
417 mateuszvis 165
  unsigned short i;
396 mateuszvis 166
  unsigned short availrows;  /* counter of available rows on display (used for /P) */
420 mateuszvis 167
  unsigned short wcols = screen_getwidth() / WCOLWIDTH; /* number of columns in wide mode */
168
  unsigned char wcolcount;
501 mateuszvis 169
  struct nls_patterns *nls = (void *)(p->BUFFER + (p->BUFFERSZ / 2));
170
  char *buff2 = p->BUFFER + (p->BUFFERSZ / 2) + sizeof(*nls);
424 mateuszvis 171
  unsigned long summary_fcount = 0;
172
  unsigned long summary_totsz = 0;
173
  unsigned char drv = 0;
542 mateuszvis 174
  unsigned char attrfilter_may = DIR_ATTR_DEFAULT;
175
  unsigned char attrfilter_must = 0;
420 mateuszvis 176
 
396 mateuszvis 177
  #define DIR_FLAG_PAUSE  1
178
  #define DIR_FLAG_RECUR  4
420 mateuszvis 179
  #define DIR_FLAG_LCASE  8
396 mateuszvis 180
  unsigned char flags = 0;
368 mateuszvis 181
 
420 mateuszvis 182
  #define DIR_OUTPUT_NORM 1
183
  #define DIR_OUTPUT_WIDE 2
184
  #define DIR_OUTPUT_BARE 3
185
  unsigned char format = DIR_OUTPUT_NORM;
186
 
390 mateuszvis 187
  if (cmd_ishlp(p)) {
396 mateuszvis 188
    outputnl("Displays a list of files and subdirectories in a directory");
189
    outputnl("");
190
    outputnl("DIR [drive:][path][filename] [/P] [/W] [/A[:]attributes] [/O[[:]sortorder]] [/S] [/B] [/L]");
191
    outputnl("");
192
    outputnl("/P Pauses after each screenful of information");
193
    outputnl("/W Uses wide list format");
194
    outputnl("");
195
    outputnl("/A Displays files with specified attributes:");
196
    outputnl("    D Directories            R Read-only files        H Hidden files");
197
    outputnl("    A Ready for archiving    S System files           - prefix meaning \"not\"");
198
    outputnl("");
199
    outputnl("/O List files in sorted order:");
200
    outputnl("    N by name                S by size                E by extension");
201
    outputnl("    D by date                G group dirs first       - prefix to reverse order");
202
    outputnl("");
203
    outputnl("/S Displays files in specified directory and all subdirectories");
204
    outputnl("/B Uses bare format (no heading information or summary)");
205
    outputnl("/L Uses lowercases");
533 mateuszvis 206
    return(CMD_OK);
390 mateuszvis 207
  }
208
 
420 mateuszvis 209
  i = nls_getpatterns(nls);
538 mateuszvis 210
  if (i != 0) nls_outputnl_doserr(i);
420 mateuszvis 211
 
393 mateuszvis 212
  /* parse command line */
213
  for (i = 0; i < p->argc; i++) {
214
    if (p->argv[i][0] == '/') {
542 mateuszvis 215
      const char *arg = p->argv[i] + 1;
396 mateuszvis 216
      char neg = 0;
217
      /* detect negations and get actual argument */
542 mateuszvis 218
      if (*arg == '-') {
219
        neg = 1;
220
        arg++;
221
      }
396 mateuszvis 222
      /* */
542 mateuszvis 223
      switch (*arg) {
396 mateuszvis 224
        case 'a':
225
        case 'A':
542 mateuszvis 226
          arg++;
227
          /* preset defaults */
228
          attrfilter_may = DIR_ATTR_DEFAULT;
229
          attrfilter_must = 0;
230
          /* /-A only allowed without further parameters (used to cancel possible previous /Asmth) */
231
          if (neg) {
232
            if (*arg != 0) {
233
              nls_outputnl_err(0, 2); /* invalid switch */
234
              return(CMD_FAIL);
235
            }
236
          } else {
237
            /* start with "allow everything" */
238
            attrfilter_may = (DOS_ATTR_ARC | DOS_ATTR_DIR | DOS_ATTR_HID | DOS_ATTR_SYS | DOS_ATTR_RO);
239
            if (dir_parse_attr_list(arg, &attrfilter_may, &attrfilter_must) != 0) {
240
              nls_outputnl_err(0, 3); /* invalid parameter format */
241
              return(CMD_FAIL);
242
            }
243
          }
396 mateuszvis 244
          break;
399 mateuszvis 245
        case 'b':
246
        case 'B':
420 mateuszvis 247
          format = DIR_OUTPUT_BARE;
399 mateuszvis 248
          break;
421 mateuszvis 249
        case 'l':
250
        case 'L':
251
          flags |= DIR_FLAG_LCASE;
420 mateuszvis 252
          break;
421 mateuszvis 253
        case 'o':
254
        case 'O':
255
          /* TODO */
256
          outputnl("/O NOT IMPLEMENTED YET");
533 mateuszvis 257
          return(CMD_FAIL);
421 mateuszvis 258
          break;
396 mateuszvis 259
        case 'p':
260
        case 'P':
261
          flags |= DIR_FLAG_PAUSE;
262
          if (neg) flags &= (0xff ^ DIR_FLAG_PAUSE);
263
          break;
421 mateuszvis 264
        case 's':
265
        case 'S':
266
          /* TODO */
267
          outputnl("/S NOT IMPLEMENTED YET");
533 mateuszvis 268
          return(CMD_FAIL);
420 mateuszvis 269
          break;
421 mateuszvis 270
        case 'w':
271
        case 'W':
272
          format = DIR_OUTPUT_WIDE;
273
          break;
393 mateuszvis 274
        default:
542 mateuszvis 275
          nls_outputnl_err(0, 2); /* invalid switch */
533 mateuszvis 276
          return(CMD_FAIL);
393 mateuszvis 277
      }
278
    } else {  /* filespec */
279
      if (filespecptr != NULL) {
542 mateuszvis 280
        nls_outputnl_err(0, 4); /* too many parameters */
533 mateuszvis 281
        return(CMD_FAIL);
393 mateuszvis 282
      }
283
      filespecptr = p->argv[i];
284
    }
285
  }
368 mateuszvis 286
 
393 mateuszvis 287
  if (filespecptr == NULL) filespecptr = ".";
288
 
528 mateuszvis 289
  availrows = screen_getheight() - 2;
290
 
417 mateuszvis 291
  /* special case: "DIR drive:" (truename() fails on "C:" under MS-DOS 6.0) */
292
  if ((filespecptr[0] != 0) && (filespecptr[1] == ':') && (filespecptr[2] == 0)) {
293
    if ((filespecptr[0] >= 'a') && (filespecptr[0] <= 'z')) {
294
      p->BUFFER[0] = filespecptr[0] - ('a' - 1);
295
    } else {
296
      p->BUFFER[0] = filespecptr[0] - ('A' - 1);
399 mateuszvis 297
    }
417 mateuszvis 298
    i = curpathfordrv(p->BUFFER, p->BUFFER[0]);
299
  } else {
300
    i = file_truename(filespecptr, p->BUFFER);
399 mateuszvis 301
  }
417 mateuszvis 302
  if (i != 0) {
538 mateuszvis 303
    nls_outputnl_doserr(i);
533 mateuszvis 304
    return(CMD_FAIL);
417 mateuszvis 305
  }
393 mateuszvis 306
 
420 mateuszvis 307
  if (format != DIR_OUTPUT_BARE) {
424 mateuszvis 308
    drv = p->BUFFER[0];
399 mateuszvis 309
    if (drv >= 'a') {
310
      drv -= 'a';
311
    } else {
312
      drv -= 'A';
313
    }
403 mateuszvis 314
    cmd_vol_internal(drv, buff2);
315
    sprintf(buff2, "Directory of %s", p->BUFFER);
399 mateuszvis 316
    /* trim at first '?', if any */
403 mateuszvis 317
    for (i = 0; buff2[i] != 0; i++) if (buff2[i] == '?') buff2[i] = 0;
318
    outputnl(buff2);
399 mateuszvis 319
    outputnl("");
528 mateuszvis 320
    availrows -= 3;
399 mateuszvis 321
  }
322
 
417 mateuszvis 323
  /* if dir: append a backslash (also get its len) */
324
  i = path_appendbkslash_if_dir(p->BUFFER);
393 mateuszvis 325
 
417 mateuszvis 326
  /* if ends with a \ then append ????????.??? */
327
  if (p->BUFFER[i - 1] == '\\') strcat(p->BUFFER, "????????.???");
393 mateuszvis 328
 
542 mateuszvis 329
  /* ask DOS for list of files, but only with allowed attribs */
330
  i = findfirst(dta, p->BUFFER, attrfilter_may);
417 mateuszvis 331
  if (i != 0) {
538 mateuszvis 332
    nls_outputnl_doserr(i);
533 mateuszvis 333
    return(CMD_FAIL);
417 mateuszvis 334
  }
335
 
420 mateuszvis 336
  wcolcount = 0; /* may be used for columns counting with wide mode */
396 mateuszvis 337
 
420 mateuszvis 338
  do {
542 mateuszvis 339
    /* if mandatory attribs are requested, filter them now */
340
    if ((attrfilter_must & dta->attr) != attrfilter_must) continue;
341
 
342
    /* if file contains attributes that are not allowed -> skip */
343
    if ((~attrfilter_may & dta->attr) != 0) continue;
344
 
345
    /* turn string lcase (/L) */
420 mateuszvis 346
    if (flags & DIR_FLAG_LCASE) _strlwr(dta->fname); /* OpenWatcom extension, probably does not care about NLS so results may be odd with non-A-Z characters... */
368 mateuszvis 347
 
424 mateuszvis 348
    summary_fcount++;
349
    if ((dta->attr & DOS_ATTR_DIR) == 0) summary_totsz += dta->size;
350
 
420 mateuszvis 351
    switch (format) {
352
      case DIR_OUTPUT_NORM:
353
        /* print fname-space-extension (unless it's "." or "..", then print as-is) */
354
        if (dta->fname[0] == '.') {
355
          output(dta->fname);
356
          i = strlen(dta->fname);
357
          while (i++ < 12) output(" ");
358
        } else {
359
          file_fname2fcb(buff2, dta->fname);
360
          memmove(buff2 + 9, buff2 + 8, 4);
361
          buff2[8] = ' ';
362
          output(buff2);
363
        }
364
        output(" ");
365
        /* either <DIR> or right aligned 10-chars byte size */
366
        memset(buff2, ' ', 10);
367
        if (dta->attr & DOS_ATTR_DIR) {
368
          strcpy(buff2 + 10, "<DIR>");
369
        } else {
370
          _ultoa(dta->size, buff2 + 10, 10); /* OpenWatcom extension */
371
        }
372
        output(buff2 + strlen(buff2) - 10);
373
        /* two spaces and NLS DATE */
374
        buff2[0] = ' ';
375
        buff2[1] = ' ';
376
        nls_format_date(buff2 + 2, dta->date_yr + 1980, dta->date_mo, dta->date_dy, nls);
377
        output(buff2);
378
 
379
        /* one space and NLS TIME */
426 mateuszvis 380
        nls_format_time(buff2 + 1, dta->time_hour, dta->time_min, 0xff, nls);
420 mateuszvis 381
        outputnl(buff2);
382
        break;
383
 
384
      case DIR_OUTPUT_WIDE: /* display in columns of 12 chars per item */
385
        i = strlen(dta->fname);
386
        if (dta->attr & DOS_ATTR_DIR) {
387
          i += 2;
388
          output("[");
389
          output(dta->fname);
390
          output("]");
391
        } else {
392
          output(dta->fname);
393
        }
394
        while (i++ < WCOLWIDTH) output(" ");
395
        if (++wcolcount == wcols) {
396
          wcolcount = 0;
397
          outputnl("");
528 mateuszvis 398
        } else {
399
          availrows++; /* wide mode is the only one that does not write one line per file */
420 mateuszvis 400
        }
401
        break;
402
 
403
      case DIR_OUTPUT_BARE:
404
        outputnl(dta->fname);
405
        break;
396 mateuszvis 406
    }
368 mateuszvis 407
 
528 mateuszvis 408
    if (flags & DIR_FLAG_PAUSE) dir_pagination(&availrows);
420 mateuszvis 409
 
410
  } while (findnext(dta) == 0);
411
 
528 mateuszvis 412
  if (wcolcount != 0) {
413
    outputnl(""); /* in wide mode make sure to end on a clear row */
414
    if (flags & DIR_FLAG_PAUSE) dir_pagination(&availrows);
415
  }
420 mateuszvis 416
 
424 mateuszvis 417
  /* print out summary (unless bare output mode) */
418
  if (format != DIR_OUTPUT_BARE) {
419
    unsigned short alignpos;
420
    /* x file(s) */
421
    memset(buff2, ' ', 13); /* 13 is the max len of a 32 bit number with thousand separators (4'000'000'000) */
422
    i = nls_format_number(buff2 + 13, summary_fcount, nls);
423
    alignpos = sprintf(buff2 + 13 + i, " %s ", "file(s)");
424
    output(buff2 + i);
425
    /* xxxx bytes */
426
    i = nls_format_number(buff2 + 13, summary_totsz, nls);
427
    output(buff2 + i);
428
    output(" ");
429
    outputnl("bytes");
528 mateuszvis 430
    if (flags & DIR_FLAG_PAUSE) dir_pagination(&availrows);
424 mateuszvis 431
    /* xxxx bytes free */
432
    i = cmd_dir_df(&summary_totsz, drv);
538 mateuszvis 433
    if (i != 0) nls_outputnl_doserr(i);
424 mateuszvis 434
    alignpos += 13 + 13;
435
    memset(buff2, ' ', alignpos); /* align the freebytes value to same column as totbytes */
436
    i = nls_format_number(buff2 + alignpos, summary_totsz, nls);
437
    output(buff2 + i);
438
    output(" ");
439
    outputnl("bytes free");
528 mateuszvis 440
    if (flags & DIR_FLAG_PAUSE) dir_pagination(&availrows);
424 mateuszvis 441
  }
442
 
533 mateuszvis 443
  return(CMD_OK);
368 mateuszvis 444
}