Subversion Repositories SvarDOS

Rev

Rev 1725 | Rev 1739 | 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
 *
1716 mateusz.vi 4
 * Copyright (C) 2021-2024 Mateusz Viste
421 mateuszvis 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
 
1716 mateusz.vi 59
/* a "tiny" DTA is a DTA that is stripped from bytes that are not needed for
60
 * DIR operations */
61
_Packed struct TINYDTA {
62
/*  char reserved[21];
63
  unsigned char attr; */
64
  unsigned short time_sec2:5;
65
  unsigned short time_min:6;
66
  unsigned short time_hour:5;
67
  unsigned short date_dy:5;
68
  unsigned short date_mo:4;
69
  unsigned short date_yr:7;
70
  unsigned long size;
71
/*  char fname[13]; */
72
  char fname[12];
73
};
74
 
75
 
424 mateuszvis 76
/* fills freebytes with free bytes for drv (A=0, B=1, etc)
77
 * returns DOS ERR code on failure */
78
static unsigned short cmd_dir_df(unsigned long *freebytes, unsigned char drv) {
79
  unsigned short res = 0;
80
  unsigned short sects_per_clust = 0, avail_clusts = 0, bytes_per_sect = 0;
81
 
82
  _asm {
83
    push ax
84
    push bx
85
    push cx
86
    push dx
87
 
88
    mov ah, 0x36  /* DOS 2+ -- Get Disk Free Space */
89
    mov dl, [drv] /* A=1, B=2, etc (0 = DEFAULT DRIVE) */
90
    inc dl
91
    int 0x21      /* AX=sects_per_clust, BX=avail_clusts, CX=bytes_per_sect, DX=tot_clusters */
92
    cmp ax, 0xffff /* AX=0xffff on error (invalid drive) */
93
    jne COMPUTEDF
94
    mov [res], 0x0f /* fill res with DOS error code 15 ("invalid drive") */
95
    jmp DONE
96
 
97
    COMPUTEDF:
98
    /* freebytes = AX * BX * CX */
99
    mov [sects_per_clust], ax
100
    mov [avail_clusts], bx
101
    mov [bytes_per_sect], cx
102
 
103
    DONE:
104
    pop dx
105
    pop cx
106
    pop bx
107
    pop ax
108
  }
109
 
110
  /* multiple steps to avoid uint16 overflow */
111
  *freebytes = sects_per_clust;
112
  *freebytes *= avail_clusts;
113
  *freebytes *= bytes_per_sect;
114
 
115
  return(res);
116
}
117
 
118
 
528 mateuszvis 119
static void dir_pagination(unsigned short *availrows) {
120
  *availrows -= 1;
121
  if (*availrows == 0) {
122
    press_any_key();
123
    *availrows = screen_getheight() - 1;
124
  }
125
}
126
 
127
 
542 mateuszvis 128
/* parse an attr list like "Ar-hS" and fill bitfield into attrfilter_may and attrfilter_must.
129
 * /AHS   -> adds S and H to mandatory attribs ("must")
130
 * /A-S   -> removes S from allowed attribs ("may")
131
 * returns non-zero on error. */
132
static int dir_parse_attr_list(const char *arg, unsigned char *attrfilter_may, unsigned char *attrfilter_must) {
133
  for (; *arg != 0; arg++) {
134
    unsigned char curattr;
135
    char not;
136
    if (*arg == '-') {
137
      not = 1;
138
      arg++;
139
    } else {
140
      not = 0;
141
    }
142
    switch (*arg) {
143
      case 'd':
144
      case 'D':
145
        curattr = DOS_ATTR_DIR;
146
        break;
147
      case 'r':
148
      case 'R':
149
        curattr = DOS_ATTR_RO;
150
        break;
151
      case 'a':
152
      case 'A':
153
        curattr = DOS_ATTR_ARC;
154
        break;
155
      case 'h':
156
      case 'H':
157
        curattr = DOS_ATTR_HID;
158
        break;
159
      case 's':
160
      case 'S':
161
        curattr = DOS_ATTR_SYS;
162
        break;
163
      default:
164
        return(-1);
165
    }
166
    /* update res bitfield */
167
    if (not) {
168
      *attrfilter_may &= ~curattr;
169
    } else {
170
      *attrfilter_must |= curattr;
171
    }
172
  }
173
  return(0);
174
}
175
 
176
 
1716 mateusz.vi 177
/* compare attributes in a DTA node to mandatory and optional attributes. returns 1 on match, 0 otherwise */
178
static int filter_attribs(const struct DTA *dta, unsigned char attrfilter_must, unsigned char attrfilter_may) {
179
  /* if mandatory attribs are requested, filter them now */
180
  if ((attrfilter_must & dta->attr) != attrfilter_must) return(0);
181
 
182
  /* if file contains attributes that are not allowed -> skip */
183
  if ((~attrfilter_may & dta->attr) != 0) return(0);
184
 
185
  return(1);
186
}
187
 
188
 
1719 mateusz.vi 189
static struct {
190
  struct TINYDTA far *dtabuf_root;
191
  char order[8]; /* GNESD values (ucase = lower first ; lcase = higher first) */
192
} glob_sortcmp_dat;
1716 mateusz.vi 193
 
1719 mateusz.vi 194
 
195
/* translates an order string like "GNE-S" into values fed into the order[]
196
 * table of glob_sortcmp_dat. returns 0 on success, non-zero otherwise. */
1724 mateusz.vi 197
static int dir_process_order_directive(const char *ordstring) {
1719 mateusz.vi 198
  const char *gnesd = "gnesd"; /* must be lower case */
199
  int ordi, orderi = 0, i;
200
 
201
  /* tabula rasa */
202
  glob_sortcmp_dat.order[0] = 0;
203
 
1721 mateusz.vi 204
  /* /O alone is a short hand for /OGN */
205
  if (*ordstring == 0) {
206
    glob_sortcmp_dat.order[0] = 'G';
207
    glob_sortcmp_dat.order[1] = 'N';
208
    glob_sortcmp_dat.order[2] = 0;
209
  }
210
 
1726 mateusz.vi 211
  /* stupid MSDOS compatibility ("DIR /O:GNE") */
212
  if (*ordstring == ':') ordstring++;
213
 
1719 mateusz.vi 214
  /* parsing */
215
  for (ordi = 0; ordstring[ordi] != 0; ordi++) {
216
    if (ordstring[ordi] == '-') {
217
      if ((ordstring[ordi + 1] == '-') || (ordstring[ordi + 1] == 0)) return(-1);
218
      continue;
219
    }
220
    if (orderi == sizeof(glob_sortcmp_dat.order)) return(-1);
221
 
222
    for (i = 0; gnesd[i] != 0; i++) {
223
      if ((ordstring[ordi] | 32) == gnesd[i]) { /* | 32 is lcase-ing the char */
224
        if ((ordi > 0) && (ordstring[ordi - 1] == '-')) {
225
          glob_sortcmp_dat.order[orderi] = gnesd[i];
226
        } else {
227
          glob_sortcmp_dat.order[orderi] = gnesd[i] ^ 32;
228
        }
229
        orderi++;
230
        break;
231
      }
232
    }
233
    if (gnesd[i] == 0) return(-1);
234
  }
235
 
236
  return(0);
237
}
238
 
239
 
240
static int sortcmp(const void *dtaid1, const void *dtaid2) {
241
  struct TINYDTA far *dta1 = &(glob_sortcmp_dat.dtabuf_root[*((unsigned short *)dtaid1)]);
242
  struct TINYDTA far *dta2 = &(glob_sortcmp_dat.dtabuf_root[*((unsigned short *)dtaid2)]);
243
  char *ordconf = glob_sortcmp_dat.order;
244
 
245
  /* debug stuff
246
  {
247
    int i;
248
    printf("%lu vs %lu | ", dta1->size, dta2->size);
249
    for (i = 0; dta1->fname[i] != 0; i++) printf("%c", dta1->fname[i]);
250
    printf(" vs ");
251
    for (i = 0; dta2->fname[i] != 0; i++) printf("%c", dta2->fname[i]);
252
    printf("\n");
253
  } */
254
 
255
  for (;;) {
256
    int r = -1;
257
    if (*ordconf & 32) r = 1;
258
 
259
    switch (*ordconf | 32) {
260
      case 'g': /* sort by type (directories first, then files) */
261
        if ((dta1->time_sec2 & DOS_ATTR_DIR) > (dta2->time_sec2 & DOS_ATTR_DIR)) return(0 - r);
262
        if ((dta1->time_sec2 & DOS_ATTR_DIR) < (dta2->time_sec2 & DOS_ATTR_DIR)) return(r);
263
        break;
264
      case ' ': /* default (last resort) sort: by name */
265
      case 'e': /* sort by extension */
266
      case 'n': /* sort by filename */
267
      {
268
        const char far *f1 = dta1->fname;
269
        const char far *f2 = dta2->fname;
270
        int i, limit = 12;
271
        /* special handling for '.' and '..' entries */
272
        if ((f1[0] == '.') && (f2[0] != '.')) return(0 - r);
273
        if ((f2[0] == '.') && (f1[0] != '.')) return(r);
274
 
275
        if ((*ordconf | 32) == 'e') {
276
          /* fast-forward to extension or end of filename */
277
          while ((*f1 != 0) && (*f1 != '.')) f1++;
278
          while ((*f2 != 0) && (*f2 != '.')) f2++;
279
          limit = 4; /* TINYDTA structs are not nul-terminated */
280
        }
281
        /* cmp */
282
        for (i = 0; i < limit; i++) {
283
          if ((*f1 | 32) < (*f2 | 32)) return(0 - r);
284
          if ((*f1 | 32) > (*f2 | 32)) return(r);
285
          if (*f1 == 0) break;
286
          f1++;
287
          f2++;
288
        }
289
      }
290
        break;
291
      case 's': /* sort by size */
292
        if (dta1->size > dta2->size) return(r);
293
        if (dta1->size < dta2->size) return(0 - r);
294
        break;
295
      case 'd': /* sort by date */
296
        if (dta1->date_yr < dta2->date_yr) return(0 - r);
297
        if (dta1->date_yr > dta2->date_yr) return(r);
298
        if (dta1->date_mo < dta2->date_mo) return(0 - r);
299
        if (dta1->date_mo > dta2->date_mo) return(r);
300
        if (dta1->date_dy < dta2->date_dy) return(0 - r);
301
        if (dta1->date_dy > dta2->date_dy) return(r);
302
        if (dta1->time_hour < dta2->time_hour) return(0 - r);
303
        if (dta1->time_hour > dta2->time_hour) return(r);
304
        if (dta1->time_min < dta2->time_min) return(0 - r);
305
        if (dta1->time_min > dta2->time_min) return(r);
306
        break;
307
    }
308
 
309
    if (*ordconf == 0) break;
310
    ordconf++;
311
  }
312
 
313
  return(0);
314
}
315
 
316
 
542 mateuszvis 317
#define DIR_ATTR_DEFAULT (DOS_ATTR_RO | DOS_ATTR_DIR | DOS_ATTR_ARC)
318
 
1724 mateusz.vi 319
struct dirrequest {
320
  unsigned char attrfilter_may;
321
  unsigned char attrfilter_must;
322
  const char *filespecptr;
420 mateuszvis 323
 
396 mateuszvis 324
  #define DIR_FLAG_PAUSE  1
325
  #define DIR_FLAG_RECUR  4
420 mateuszvis 326
  #define DIR_FLAG_LCASE  8
1719 mateusz.vi 327
  #define DIR_FLAG_SORT  16
1724 mateusz.vi 328
  unsigned char flags;
368 mateuszvis 329
 
420 mateuszvis 330
  #define DIR_OUTPUT_NORM 1
331
  #define DIR_OUTPUT_WIDE 2
332
  #define DIR_OUTPUT_BARE 3
1724 mateusz.vi 333
  unsigned char format;
334
};
420 mateuszvis 335
 
1719 mateusz.vi 336
 
1724 mateusz.vi 337
static int dir_parse_cmdline(struct dirrequest *req, const char **argv) {
338
  for (; *argv != NULL; argv++) {
339
    if (*argv[0] == '/') {
340
      const char *arg = *argv + 1;
396 mateuszvis 341
      char neg = 0;
342
      /* detect negations and get actual argument */
542 mateuszvis 343
      if (*arg == '-') {
344
        neg = 1;
345
        arg++;
346
      }
396 mateuszvis 347
      /* */
542 mateuszvis 348
      switch (*arg) {
396 mateuszvis 349
        case 'a':
350
        case 'A':
542 mateuszvis 351
          arg++;
352
          /* preset defaults */
1724 mateusz.vi 353
          req->attrfilter_may = DIR_ATTR_DEFAULT;
354
          req->attrfilter_must = 0;
542 mateuszvis 355
          /* /-A only allowed without further parameters (used to cancel possible previous /Asmth) */
356
          if (neg) {
357
            if (*arg != 0) {
358
              nls_outputnl_err(0, 2); /* invalid switch */
1724 mateusz.vi 359
              return(-1);
542 mateuszvis 360
            }
361
          } else {
1085 mateusz.vi 362
            /* skip colon if present */
363
            if (*arg == ':') arg++;
542 mateuszvis 364
            /* start with "allow everything" */
1724 mateusz.vi 365
            req->attrfilter_may = (DOS_ATTR_ARC | DOS_ATTR_DIR | DOS_ATTR_HID | DOS_ATTR_SYS | DOS_ATTR_RO);
366
            if (dir_parse_attr_list(arg, &(req->attrfilter_may), &(req->attrfilter_must)) != 0) {
542 mateuszvis 367
              nls_outputnl_err(0, 3); /* invalid parameter format */
1724 mateusz.vi 368
              return(-1);
542 mateuszvis 369
            }
370
          }
396 mateuszvis 371
          break;
399 mateuszvis 372
        case 'b':
373
        case 'B':
1724 mateusz.vi 374
          req->format = DIR_OUTPUT_BARE;
399 mateuszvis 375
          break;
421 mateuszvis 376
        case 'l':
377
        case 'L':
1724 mateusz.vi 378
          req->flags |= DIR_FLAG_LCASE;
420 mateuszvis 379
          break;
421 mateuszvis 380
        case 'o':
381
        case 'O':
1720 mateusz.vi 382
          if (neg) {
1724 mateusz.vi 383
            req->flags &= (0xff ^ DIR_FLAG_SORT);
1720 mateusz.vi 384
            break;
385
          }
1724 mateusz.vi 386
          if (dir_process_order_directive(arg+1) != 0) {
1719 mateusz.vi 387
            nls_output_err(0, 3); /* invalid parameter format */
388
            output(": ");
389
            outputnl(arg);
1724 mateusz.vi 390
            return(-1);
1719 mateusz.vi 391
          }
1724 mateusz.vi 392
          req->flags |= DIR_FLAG_SORT;
421 mateuszvis 393
          break;
396 mateuszvis 394
        case 'p':
395
        case 'P':
1724 mateusz.vi 396
          req->flags |= DIR_FLAG_PAUSE;
397
          if (neg) req->flags &= (0xff ^ DIR_FLAG_PAUSE);
396 mateuszvis 398
          break;
421 mateuszvis 399
        case 's':
400
        case 'S':
401
          /* TODO */
402
          outputnl("/S NOT IMPLEMENTED YET");
1724 mateusz.vi 403
          return(-1);
420 mateuszvis 404
          break;
421 mateuszvis 405
        case 'w':
406
        case 'W':
1724 mateusz.vi 407
          req->format = DIR_OUTPUT_WIDE;
421 mateuszvis 408
          break;
393 mateuszvis 409
        default:
542 mateuszvis 410
          nls_outputnl_err(0, 2); /* invalid switch */
1724 mateusz.vi 411
          return(-1);
393 mateuszvis 412
      }
413
    } else {  /* filespec */
1724 mateusz.vi 414
      if (req->filespecptr != NULL) {
542 mateuszvis 415
        nls_outputnl_err(0, 4); /* too many parameters */
1724 mateusz.vi 416
        return(-1);
393 mateuszvis 417
      }
1724 mateusz.vi 418
      req->filespecptr = *argv;
393 mateuszvis 419
    }
420
  }
368 mateuszvis 421
 
1724 mateusz.vi 422
  return(0);
423
}
393 mateuszvis 424
 
1724 mateusz.vi 425
 
426
static enum cmd_result cmd_dir(struct cmd_funcparam *p) {
427
  struct DTA *dta = (void *)0x80; /* set DTA to its default location at 80h in PSP */
428
  struct TINYDTA far *dtabuf = NULL; /* used to buffer results when sorting is enabled */
429
  unsigned short dtabufcount = 0;
430
  unsigned short i;
431
  unsigned short availrows;  /* counter of available rows on display (used for /P) */
432
  unsigned short screenw = screen_getwidth();
433
  unsigned short wcols = screenw / WCOLWIDTH; /* number of columns in wide mode */
434
  unsigned char wcolcount;
435
  struct {
436
    struct nls_patterns nls;
437
    char buff64[64];
438
    char path[128];
439
    unsigned short orderidx[65535 / sizeof(struct TINYDTA)];
440
  } *buf = (void *)(p->BUFFER);
441
  unsigned long summary_fcount = 0;
442
  unsigned long summary_totsz = 0;
443
  unsigned char drv = 0;
444
  struct dirrequest req;
445
 
446
  /* make sure there's no risk of buffer overflow */
447
  if (sizeof(buf) > p->BUFFERSZ) {
448
    outputnl("INTERNAL MEM ERROR IN " __FILE__);
449
    return(CMD_FAIL);
450
  }
451
 
452
  bzero(&glob_sortcmp_dat, sizeof(glob_sortcmp_dat));
453
 
454
  if (cmd_ishlp(p)) {
455
    nls_outputnl(37,0); /* "Displays a list of files and subdirectories in a directory" */
456
    outputnl("");
457
    nls_outputnl(37,1); /* "DIR [drive:][path][filename] [/P] [/W] [/A[:]attributes] [/O[[:]sortorder]] [/S] [/B] [/L]" */
458
    outputnl("");
459
    nls_outputnl(37,2); /* "/P Pauses after each screenful of information" */
460
    nls_outputnl(37,3); /* "/W Uses wide list format" */
461
    outputnl("");
462
    nls_outputnl(37,4); /* "/A Displays files with specified attributes:" */
463
    nls_outputnl(37,5); /* "    D Directories            R Read-only files        H Hidden files" */
464
    nls_outputnl(37,6); /* "    A Ready for archiving    S System files           - prefix meaning "not"" */
465
    outputnl("");
466
    nls_outputnl(37,7); /* "/O List files in sorted order:" */
467
    nls_outputnl(37,8); /* "    N by name                S by size                E by extension" */
468
    nls_outputnl(37,9); /* "    D by date                G group dirs first       - prefix to reverse order" */
469
    outputnl("");
470
    nls_outputnl(37,10); /* "/S Displays files in specified directory and all subdirectories" */
471
    nls_outputnl(37,11); /* "/B Uses bare format (no heading information or summary)" */
472
    nls_outputnl(37,12); /* "/L Uses lowercases" */
473
    return(CMD_OK);
474
  }
475
 
476
  i = nls_getpatterns(&(buf->nls));
477
  if (i != 0) nls_outputnl_doserr(i);
478
 
479
  /* disable usage of thousands separator on narrow screens */
480
  if (screenw < 80) buf->nls.thousep[0] = 0;
481
 
1725 mateusz.vi 482
  /*** PARSING COMMAND LINE STARTS *******************************************/
483
 
484
  /* init req with some defaults */
485
  bzero(&req, sizeof(req));
486
  req.attrfilter_may = DIR_ATTR_DEFAULT;
487
  req.format = DIR_OUTPUT_NORM;
488
 
489
  /* process DIRCMD first (so it can be overidden by user's cmdline) */
490
  {
491
  const char far *dircmd = env_lookup_val(p->env_seg, "DIRCMD");
492
  if (dircmd != NULL) {
493
    const char *argvptrs[32];
494
    cmd_explode(buf->buff64, dircmd, argvptrs);
495
    if ((dir_parse_cmdline(&req, argvptrs) != 0) || (req.filespecptr != NULL)) {
496
      nls_output(255, 10);/* bad environment */
497
      output(" - ");
498
      outputnl("DIRCMD");
499
      return(CMD_FAIL);
500
    }
501
  }
502
  }
503
 
504
  /* parse user's command line */
1724 mateusz.vi 505
  if (dir_parse_cmdline(&req, p->argv) != 0) return(CMD_FAIL);
506
 
1725 mateusz.vi 507
  /* if no filespec provided, then it's about the current directory */
508
  if (req.filespecptr == NULL) req.filespecptr = ".";
509
 
510
  /*** PARSING COMMAND LINE DONE *********************************************/
511
 
512
 
528 mateuszvis 513
  availrows = screen_getheight() - 2;
514
 
417 mateuszvis 515
  /* special case: "DIR drive:" (truename() fails on "C:" under MS-DOS 6.0) */
1724 mateusz.vi 516
  if ((req.filespecptr[0] != 0) && (req.filespecptr[1] == ':') && (req.filespecptr[2] == 0)) {
517
    if ((req.filespecptr[0] >= 'a') && (req.filespecptr[0] <= 'z')) {
518
      buf->path[0] = req.filespecptr[0] - ('a' - 1);
417 mateuszvis 519
    } else {
1724 mateusz.vi 520
      buf->path[0] = req.filespecptr[0] - ('A' - 1);
399 mateuszvis 521
    }
1717 mateusz.vi 522
    i = curpathfordrv(buf->path, buf->path[0]);
417 mateuszvis 523
  } else {
1724 mateusz.vi 524
    i = file_truename(req.filespecptr, buf->path);
399 mateuszvis 525
  }
417 mateuszvis 526
  if (i != 0) {
538 mateuszvis 527
    nls_outputnl_doserr(i);
533 mateuszvis 528
    return(CMD_FAIL);
417 mateuszvis 529
  }
393 mateuszvis 530
 
1724 mateusz.vi 531
  if (req.format != DIR_OUTPUT_BARE) {
1717 mateusz.vi 532
    drv = buf->path[0];
399 mateuszvis 533
    if (drv >= 'a') {
534
      drv -= 'a';
535
    } else {
536
      drv -= 'A';
537
    }
1717 mateusz.vi 538
    cmd_vol_internal(drv, buf->buff64);
539
    sprintf(buf->buff64, svarlang_str(37,20)/*"Directory of %s"*/, buf->path);
399 mateuszvis 540
    /* trim at first '?', if any */
1717 mateusz.vi 541
    for (i = 0; buf->buff64[i] != 0; i++) if (buf->buff64[i] == '?') buf->buff64[i] = 0;
542
    outputnl(buf->buff64);
399 mateuszvis 543
    outputnl("");
528 mateuszvis 544
    availrows -= 3;
399 mateuszvis 545
  }
546
 
417 mateuszvis 547
  /* if dir: append a backslash (also get its len) */
1717 mateusz.vi 548
  i = path_appendbkslash_if_dir(buf->path);
393 mateuszvis 549
 
417 mateuszvis 550
  /* if ends with a \ then append ????????.??? */
1717 mateusz.vi 551
  if (buf->path[i - 1] == '\\') strcat(buf->path, "????????.???");
393 mateuszvis 552
 
542 mateuszvis 553
  /* ask DOS for list of files, but only with allowed attribs */
1724 mateusz.vi 554
  i = findfirst(dta, buf->path, req.attrfilter_may);
417 mateuszvis 555
  if (i != 0) {
538 mateuszvis 556
    nls_outputnl_doserr(i);
533 mateuszvis 557
    return(CMD_FAIL);
417 mateuszvis 558
  }
559
 
1716 mateusz.vi 560
  /* if sorting is involved, then let's buffer all results (and sort them) */
1724 mateusz.vi 561
  if (req.flags & DIR_FLAG_SORT) {
1716 mateusz.vi 562
    /* allocate a memory buffer - try several sizes until one succeeds */
1717 mateusz.vi 563
    const unsigned short memsz[] = {65500, 32000, 16000, 8000, 4000, 2000, 1000, 0};
1716 mateusz.vi 564
    unsigned short max_dta_bufcount = 0;
565
    for (i = 0; memsz[i] != 0; i++) {
566
      dtabuf = _fmalloc(memsz[i]);
567
      if (dtabuf != NULL) break;
568
    }
569
 
570
    if (dtabuf == NULL) {
571
      nls_outputnl_doserr(8); /* out of memory */
572
      return(CMD_FAIL);
573
    }
574
 
575
    /* remember the address so I can free it afterwards */
1719 mateusz.vi 576
    glob_sortcmp_dat.dtabuf_root = dtabuf;
1716 mateusz.vi 577
 
578
    /* compute the amount of DTAs I can buffer */
1717 mateusz.vi 579
    max_dta_bufcount = memsz[i] / sizeof(struct TINYDTA);
1719 mateusz.vi 580
    /* printf("max_dta_bufcount = %u\n", max_dta_bufcount); */
1716 mateusz.vi 581
 
582
    do {
583
      /* filter out files with uninteresting attributes */
1724 mateusz.vi 584
      if (filter_attribs(dta, req.attrfilter_must, req.attrfilter_may) == 0) continue;
1716 mateusz.vi 585
 
1719 mateusz.vi 586
      /* normalize "size" of directories to zero because kernel returns garbage
587
       * sizes for directories which might confuse the sorting routine later */
588
      if (dta->attr & DOS_ATTR_DIR) dta->size = 0;
589
 
1716 mateusz.vi 590
      _fmemcpy(&(dtabuf[dtabufcount]), ((char *)dta) + 22, sizeof(struct TINYDTA));
591
 
592
      /* save attribs in sec field, otherwise zero it (this field is not
593
       * displayed and dropping the attr field saves 2 bytes per entry) */
594
      dtabuf[dtabufcount++].time_sec2 = (dta->attr & 31);
595
 
596
      /* do I have any space left? */
597
      if (dtabufcount == max_dta_bufcount) {
1719 mateusz.vi 598
        //TODO some kind of user notification might be nice here
1716 mateusz.vi 599
        //outputnl("TOO MANY ENTRIES FOR SORTING! LIST IS UNSORTED");
600
        break;
601
      }
602
 
603
    } while (findnext(dta) == 0);
604
 
605
    /* sort the list - the tricky part is that my array is a far address while
1719 mateusz.vi 606
     * qsort works only with near pointers, so I have to use an ugly (and
607
     * global) auxiliary table */
608
    for (i = 0; i < dtabufcount; i++) buf->orderidx[i] = i;
609
    qsort(buf->orderidx, dtabufcount, 2, &sortcmp);
1716 mateusz.vi 610
 
1719 mateusz.vi 611
    /* preload first entry (last from orderidx, since entries are sorted in reverse) */
1716 mateusz.vi 612
    dtabufcount--;
1719 mateusz.vi 613
    _fmemcpy(((unsigned char *)dta) + 22, &(dtabuf[buf->orderidx[dtabufcount]]), sizeof(struct TINYDTA));
614
    dta->attr = dtabuf[buf->orderidx[dtabufcount]].time_sec2; /* restore attr from the abused time_sec2 field */
1716 mateusz.vi 615
  }
616
 
420 mateuszvis 617
  wcolcount = 0; /* may be used for columns counting with wide mode */
396 mateuszvis 618
 
1716 mateusz.vi 619
  for (;;) {
542 mateuszvis 620
 
1716 mateusz.vi 621
    /* filter out attributes (skip if entry comes from buffer, then it was already veted) */
1724 mateusz.vi 622
    if (filter_attribs(dta, req.attrfilter_must, req.attrfilter_may) == 0) continue;
542 mateuszvis 623
 
624
    /* turn string lcase (/L) */
1724 mateusz.vi 625
    if (req.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 626
 
424 mateuszvis 627
    summary_fcount++;
628
    if ((dta->attr & DOS_ATTR_DIR) == 0) summary_totsz += dta->size;
629
 
1724 mateusz.vi 630
    switch (req.format) {
420 mateuszvis 631
      case DIR_OUTPUT_NORM:
632
        /* print fname-space-extension (unless it's "." or "..", then print as-is) */
633
        if (dta->fname[0] == '.') {
634
          output(dta->fname);
635
          i = strlen(dta->fname);
636
          while (i++ < 12) output(" ");
637
        } else {
1717 mateusz.vi 638
          file_fname2fcb(buf->buff64, dta->fname);
639
          memmove(buf->buff64 + 9, buf->buff64 + 8, 4);
640
          buf->buff64[8] = ' ';
641
          output(buf->buff64);
420 mateuszvis 642
        }
643
        output(" ");
644
        /* either <DIR> or right aligned 10-chars byte size */
1717 mateusz.vi 645
        memset(buf->buff64, ' ', 10);
420 mateuszvis 646
        if (dta->attr & DOS_ATTR_DIR) {
1717 mateusz.vi 647
          strcpy(buf->buff64 + 10, svarlang_str(37,21));
420 mateuszvis 648
        } else {
1717 mateusz.vi 649
          nls_format_number(buf->buff64 + 10, dta->size, &(buf->nls));
420 mateuszvis 650
        }
1717 mateusz.vi 651
        output(buf->buff64 + strlen(buf->buff64) - 10);
420 mateuszvis 652
        /* two spaces and NLS DATE */
1717 mateusz.vi 653
        buf->buff64[0] = ' ';
654
        buf->buff64[1] = ' ';
1141 mateusz.vi 655
        if (screenw >= 80) {
1717 mateusz.vi 656
          nls_format_date(buf->buff64 + 2, dta->date_yr + 1980, dta->date_mo, dta->date_dy, &(buf->nls));
1141 mateusz.vi 657
        } else {
1717 mateusz.vi 658
          nls_format_date(buf->buff64 + 2, (dta->date_yr + 80) % 100, dta->date_mo, dta->date_dy, &(buf->nls));
1141 mateusz.vi 659
        }
1717 mateusz.vi 660
        output(buf->buff64);
420 mateuszvis 661
 
662
        /* one space and NLS TIME */
1717 mateusz.vi 663
        nls_format_time(buf->buff64 + 1, dta->time_hour, dta->time_min, 0xff, &(buf->nls));
664
        outputnl(buf->buff64);
420 mateuszvis 665
        break;
666
 
667
      case DIR_OUTPUT_WIDE: /* display in columns of 12 chars per item */
668
        i = strlen(dta->fname);
669
        if (dta->attr & DOS_ATTR_DIR) {
670
          i += 2;
671
          output("[");
672
          output(dta->fname);
673
          output("]");
674
        } else {
675
          output(dta->fname);
676
        }
677
        while (i++ < WCOLWIDTH) output(" ");
678
        if (++wcolcount == wcols) {
679
          wcolcount = 0;
680
          outputnl("");
528 mateuszvis 681
        } else {
682
          availrows++; /* wide mode is the only one that does not write one line per file */
420 mateuszvis 683
        }
684
        break;
685
 
686
      case DIR_OUTPUT_BARE:
687
        outputnl(dta->fname);
688
        break;
396 mateuszvis 689
    }
368 mateuszvis 690
 
1724 mateusz.vi 691
    if (req.flags & DIR_FLAG_PAUSE) dir_pagination(&availrows);
420 mateuszvis 692
 
1716 mateusz.vi 693
    /* take next entry, either from buf or disk */
694
    if (dtabufcount > 0) {
695
      dtabufcount--;
1719 mateusz.vi 696
      _fmemcpy(((unsigned char *)dta) + 22, &(dtabuf[buf->orderidx[dtabufcount]]), sizeof(struct TINYDTA));
697
      dta->attr = dtabuf[buf->orderidx[dtabufcount]].time_sec2; /* restore attr from the abused time_sec2 field */
1716 mateusz.vi 698
    } else {
699
      if (findnext(dta) != 0) break;
700
    }
420 mateuszvis 701
 
1716 mateusz.vi 702
  }
703
 
528 mateuszvis 704
  if (wcolcount != 0) {
705
    outputnl(""); /* in wide mode make sure to end on a clear row */
1724 mateusz.vi 706
    if (req.flags & DIR_FLAG_PAUSE) dir_pagination(&availrows);
528 mateuszvis 707
  }
420 mateuszvis 708
 
424 mateuszvis 709
  /* print out summary (unless bare output mode) */
1724 mateusz.vi 710
  if (req.format != DIR_OUTPUT_BARE) {
424 mateuszvis 711
    unsigned short alignpos;
1141 mateusz.vi 712
    unsigned char uint32maxlen = 13; /* 13 is the max len of a 32 bit number with thousand separators (4'000'000'000) */
713
    if (screenw < 80) uint32maxlen = 10;
424 mateuszvis 714
    /* x file(s) */
1717 mateusz.vi 715
    memset(buf->buff64, ' ', uint32maxlen);
716
    i = nls_format_number(buf->buff64 + uint32maxlen, summary_fcount, &(buf->nls));
717
    alignpos = sprintf(buf->buff64 + uint32maxlen + i, " %s ", svarlang_str(37,22)/*"file(s)"*/);
718
    output(buf->buff64 + i);
424 mateuszvis 719
    /* xxxx bytes */
1717 mateusz.vi 720
    i = nls_format_number(buf->buff64 + uint32maxlen, summary_totsz, &(buf->nls));
721
    output(buf->buff64 + i + 1);
424 mateuszvis 722
    output(" ");
990 mateusz.vi 723
    nls_outputnl(37,23); /* "bytes" */
1724 mateusz.vi 724
    if (req.flags & DIR_FLAG_PAUSE) dir_pagination(&availrows);
424 mateuszvis 725
    /* xxxx bytes free */
726
    i = cmd_dir_df(&summary_totsz, drv);
538 mateuszvis 727
    if (i != 0) nls_outputnl_doserr(i);
1141 mateusz.vi 728
    alignpos += uint32maxlen * 2;
1717 mateusz.vi 729
    memset(buf->buff64, ' ', alignpos); /* align the freebytes value to same column as totbytes */
730
    i = nls_format_number(buf->buff64 + alignpos, summary_totsz, &(buf->nls));
731
    output(buf->buff64 + i + 1);
424 mateuszvis 732
    output(" ");
990 mateusz.vi 733
    nls_outputnl(37,24); /* "bytes free" */
1724 mateusz.vi 734
    if (req.flags & DIR_FLAG_PAUSE) dir_pagination(&availrows);
424 mateuszvis 735
  }
736
 
1716 mateusz.vi 737
  /* free the buffer memory (if used) */
1719 mateusz.vi 738
  if (glob_sortcmp_dat.dtabuf_root != NULL) _ffree(glob_sortcmp_dat.dtabuf_root);
1716 mateusz.vi 739
 
533 mateuszvis 740
  return(CMD_OK);
368 mateuszvis 741
}