WebSVN – SvarDOS – Diff – /svarcom/trunk/cmd/dir.c


/* This file is part of the SvarCOM project and is published under the terms
 * of the MIT license.
 *
 * Copyright (C) 2021-2024 Mateusz Viste
 *
 * Permission is hereby granted, free of charge, to any person obtaining a
 * copy of this software and associated documentation files (the "Software"),
 * to deal in the Software without restriction, including without limitation
 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
 * and/or sell copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 * DEALINGS IN THE SOFTWARE.
 */
 
/*
 * dir
 *
 * Displays a list of files and subdirectories in a directory.
 *
 * DIR [drive:][path][filename] [/P] [/W] [/A[:]attributes] [/O[[:]sortorder]] [/S] [/B] [/L]
 *
 * /P Pauses after each screenful of information.
 * /W Uses wide list format.
 *
 * /A Displays file with specified attributes:
 *     D Directories           R Read-only files     H Hidden files
 *     A Ready for archiving   S System files        - prefix meaning "not"
 *
 * /O List files in sorted order:
 *     N by name            S by size              E by extension
 *     D by date            G group dirs first     - prefix to reverse order
 *
 * /S Displays files in specified directory and all subdirectories.
 * /B Uses bare format (no heading information or summary)
 * /L Uses lowercases
 */
 
/* NOTE: /A attributes are matched in an exclusive way, ie. only files with
 *       the specified attributes are matched. This is different from how DOS
 *       itself matches attributes hence DIR cannot rely on the attributes
 *       filter within FindFirst.
 *
 * NOTE: Multiple /A are not supported - only the last one is significant.
 */
 
#define WCOLWIDTH 15  /* width of a column in wide mode output */
 
 
/* a "tiny" DTA is a DTA that is stripped from bytes that are not needed for
 * DIR operations */
_Packed struct TINYDTA {
/*  char reserved[21];
  unsigned char attr; */
  unsigned short time_sec2:5;
  unsigned short time_min:6;
  unsigned short time_hour:5;
  unsigned short date_dy:5;
  unsigned short date_mo:4;
  unsigned short date_yr:7;
  unsigned long size;
/*  char fname[13]; */
  char fname[12];
};
 
 
/* fills freebytes with free bytes for drv (A=0, B=1, etc)
 * returns DOS ERR code on failure */
static unsigned short cmd_dir_df(unsigned long *freebytes, unsigned char drv) {
  unsigned short res = 0;
  unsigned short sects_per_clust = 0, avail_clusts = 0, bytes_per_sect = 0;
 
  _asm {
    push ax
    push bx
    push cx
    push dx
 
    mov ah, 0x36  /* DOS 2+ -- Get Disk Free Space */
    mov dl, [drv] /* A=1, B=2, etc (0 = DEFAULT DRIVE) */
    inc dl
    int 0x21      /* AX=sects_per_clust, BX=avail_clusts, CX=bytes_per_sect, DX=tot_clusters */
    cmp ax, 0xffff /* AX=0xffff on error (invalid drive) */
    jne COMPUTEDF
    mov [res], 0x0f /* fill res with DOS error code 15 ("invalid drive") */
    jmp DONE
 
    COMPUTEDF:
    /* freebytes = AX * BX * CX */
    mov [sects_per_clust], ax
    mov [avail_clusts], bx
    mov [bytes_per_sect], cx
 
    DONE:
    pop dx
    pop cx
    pop bx
    pop ax
  }
 
  /* multiple steps to avoid uint16 overflow */
  *freebytes = sects_per_clust;
  *freebytes *= avail_clusts;
  *freebytes *= bytes_per_sect;
 
  return(res);
}
 
 
static void dir_pagination(unsigned short *availrows) {
  *availrows -= 1;
  if (*availrows == 0) {
    press_any_key();
    *availrows = screen_getheight() - 1;
  }
}
 
 
/* parse an attr list like "Ar-hS" and fill bitfield into attrfilter_may and attrfilter_must.
 * /AHS   -> adds S and H to mandatory attribs ("must")
 * /A-S   -> removes S from allowed attribs ("may")
 * returns non-zero on error. */
static int dir_parse_attr_list(const char *arg, unsigned char *attrfilter_may, unsigned char *attrfilter_must) {
  for (; *arg != 0; arg++) {
    unsigned char curattr;
    char not;
    if (*arg == '-') {
      not = 1;
      arg++;
    } else {
      not = 0;
    }
    switch (*arg) {
      case 'd':
      case 'D':
        curattr = DOS_ATTR_DIR;
        break;
      case 'r':
      case 'R':
        curattr = DOS_ATTR_RO;
        break;
      case 'a':
      case 'A':
        curattr = DOS_ATTR_ARC;
        break;
      case 'h':
      case 'H':
        curattr = DOS_ATTR_HID;
        break;
      case 's':
      case 'S':
        curattr = DOS_ATTR_SYS;
        break;
      default:
        return(-1);
    }
    /* update res bitfield */
    if (not) {
      *attrfilter_may &= ~curattr;
    } else {
      *attrfilter_must |= curattr;
    }
  }
  return(0);
}
 
 
/* compare attributes in a DTA node to mandatory and optional attributes. returns 1 on match, 0 otherwise */
static int filter_attribs(const struct DTA *dta, unsigned char attrfilter_must, unsigned char attrfilter_may) {
  /* if mandatory attribs are requested, filter them now */
  if ((attrfilter_must & dta->attr) != attrfilter_must) return(0);
 
  /* if file contains attributes that are not allowed -> skip */
  if ((~attrfilter_may & dta->attr) != 0) return(0);
 
  return(1);
}
 
 
static struct {
  struct TINYDTA far *dtabuf_root;
  char order[8]; /* GNESD values (ucase = lower first ; lcase = higher first) */
} glob_sortcmp_dat;
 
 
/* translates an order string like "GNE-S" into values fed into the order[]
 * table of glob_sortcmp_dat. returns 0 on success, non-zero otherwise. */
static int dir_process_order_directive(const char *ordstring) {
  const char *gnesd = "gnesd"; /* must be lower case */
  int ordi, orderi = 0, i;
 
  /* tabula rasa */
  glob_sortcmp_dat.order[0] = 0;
 
  /* /O alone is a short hand for /OGN */
  if (*ordstring == 0) {
    glob_sortcmp_dat.order[0] = 'G';
    glob_sortcmp_dat.order[1] = 'N';
    glob_sortcmp_dat.order[2] = 0;
  }
 
  /* stupid MSDOS compatibility ("DIR /O:GNE") */
  if (*ordstring == ':') ordstring++;
 
  /* parsing */
  for (ordi = 0; ordstring[ordi] != 0; ordi++) {
    if (ordstring[ordi] == '-') {
      if ((ordstring[ordi + 1] == '-') || (ordstring[ordi + 1] == 0)) return(-1);
      continue;
    }
    if (orderi == sizeof(glob_sortcmp_dat.order)) return(-1);
 
    for (i = 0; gnesd[i] != 0; i++) {
      if ((ordstring[ordi] | 32) == gnesd[i]) { /* | 32 is lcase-ing the char */
        if ((ordi > 0) && (ordstring[ordi - 1] == '-')) {
          glob_sortcmp_dat.order[orderi] = gnesd[i];
        } else {
          glob_sortcmp_dat.order[orderi] = gnesd[i] ^ 32;
        }
        orderi++;
        break;
      }
    }
    if (gnesd[i] == 0) return(-1);
  }
 
  return(0);
}
 
 
static int sortcmp(const void *dtaid1, const void *dtaid2) {
  struct TINYDTA far *dta1 = &(glob_sortcmp_dat.dtabuf_root[*((unsigned short *)dtaid1)]);
  struct TINYDTA far *dta2 = &(glob_sortcmp_dat.dtabuf_root[*((unsigned short *)dtaid2)]);
  char *ordconf = glob_sortcmp_dat.order;
 
  /* debug stuff
  {
    int i;
    printf("%lu vs %lu | ", dta1->size, dta2->size);
    for (i = 0; dta1->fname[i] != 0; i++) printf("%c", dta1->fname[i]);
    printf(" vs ");
    for (i = 0; dta2->fname[i] != 0; i++) printf("%c", dta2->fname[i]);
    printf("\n");
  } */
 
  for (;;) {
    int r = -1;
    if (*ordconf & 32) r = 1;
 
    switch (*ordconf | 32) {
      case 'g': /* sort by type (directories first, then files) */
        if ((dta1->time_sec2 & DOS_ATTR_DIR) > (dta2->time_sec2 & DOS_ATTR_DIR)) return(0 - r);
        if ((dta1->time_sec2 & DOS_ATTR_DIR) < (dta2->time_sec2 & DOS_ATTR_DIR)) return(r);
        break;
      case ' ': /* default (last resort) sort: by name */
      case 'e': /* sort by extension */
      case 'n': /* sort by filename */
      {
        const char far *f1 = dta1->fname;
        const char far *f2 = dta2->fname;
        int i, limit = 12;
        /* special handling for '.' and '..' entries */
        if ((f1[0] == '.') && (f2[0] != '.')) return(0 - r);
        if ((f2[0] == '.') && (f1[0] != '.')) return(r);
 
        if ((*ordconf | 32) == 'e') {
          /* fast-forward to extension or end of filename */
          while ((*f1 != 0) && (*f1 != '.')) f1++;
          while ((*f2 != 0) && (*f2 != '.')) f2++;
          limit = 4; /* TINYDTA structs are not nul-terminated */
        }
        /* cmp */
        for (i = 0; i < limit; i++) {
          if ((*f1 | 32) < (*f2 | 32)) return(0 - r);
          if ((*f1 | 32) > (*f2 | 32)) return(r);
          if (*f1 == 0) break;
          f1++;
          f2++;
        }
      }
        break;
      case 's': /* sort by size */
        if (dta1->size > dta2->size) return(r);
        if (dta1->size < dta2->size) return(0 - r);
        break;
      case 'd': /* sort by date */
        if (dta1->date_yr < dta2->date_yr) return(0 - r);
        if (dta1->date_yr > dta2->date_yr) return(r);
        if (dta1->date_mo < dta2->date_mo) return(0 - r);
        if (dta1->date_mo > dta2->date_mo) return(r);
        if (dta1->date_dy < dta2->date_dy) return(0 - r);
        if (dta1->date_dy > dta2->date_dy) return(r);
        if (dta1->time_hour < dta2->time_hour) return(0 - r);
        if (dta1->time_hour > dta2->time_hour) return(r);
        if (dta1->time_min < dta2->time_min) return(0 - r);
        if (dta1->time_min > dta2->time_min) return(r);
        break;
    }
 
    if (*ordconf == 0) break;
    ordconf++;
  }
 
  return(0);
}
 
 
#define DIR_ATTR_DEFAULT (DOS_ATTR_RO | DOS_ATTR_DIR | DOS_ATTR_ARC)
 
struct dirrequest {
  unsigned char attrfilter_may;
  unsigned char attrfilter_must;
  const char *filespecptr;
 
  #define DIR_FLAG_PAUSE  1
  #define DIR_FLAG_RECUR  4
  #define DIR_FLAG_LCASE  8
  #define DIR_FLAG_SORT  16
  unsigned char flags;
 
  #define DIR_OUTPUT_NORM 1
  #define DIR_OUTPUT_WIDE 2
  #define DIR_OUTPUT_BARE 3
  unsigned char format;
};
 
 
static int dir_parse_cmdline(struct dirrequest *req, const char **argv) {
  for (; *argv != NULL; argv++) {
    if (*argv[0] == '/') {
      const char *arg = *argv + 1;
      char neg = 0;
      /* detect negations and get actual argument */
      if (*arg == '-') {
        neg = 1;
        arg++;
      }
      /* */
      switch (*arg) {
        case 'a':
        case 'A':
          arg++;
          /* preset defaults */
          req->attrfilter_may = DIR_ATTR_DEFAULT;
          req->attrfilter_must = 0;
          /* /-A only allowed without further parameters (used to cancel possible previous /Asmth) */
          if (neg) {
            if (*arg != 0) {
              nls_outputnl_err(0, 2); /* invalid switch */
              return(-1);
            }
          } else {
            /* skip colon if present */
            if (*arg == ':') arg++;
            /* start with "allow everything" */
            req->attrfilter_may = (DOS_ATTR_ARC | DOS_ATTR_DIR | DOS_ATTR_HID | DOS_ATTR_SYS | DOS_ATTR_RO);
            if (dir_parse_attr_list(arg, &(req->attrfilter_may), &(req->attrfilter_must)) != 0) {
              nls_outputnl_err(0, 3); /* invalid parameter format */
              return(-1);
            }
          }
          break;
        case 'b':
        case 'B':
          req->format = DIR_OUTPUT_BARE;
          break;
        case 'l':
        case 'L':
          req->flags |= DIR_FLAG_LCASE;
          break;
        case 'o':
        case 'O':
          if (neg) {
            req->flags &= (0xff ^ DIR_FLAG_SORT);
            break;
          }
          if (dir_process_order_directive(arg+1) != 0) {
            nls_output_err(0, 3); /* invalid parameter format */
            output(": ");
            outputnl(arg);
            return(-1);
          }
          req->flags |= DIR_FLAG_SORT;
          break;
        case 'p':
        case 'P':
          req->flags |= DIR_FLAG_PAUSE;
          if (neg) req->flags &= (0xff ^ DIR_FLAG_PAUSE);
          break;
        case 's':
        case 'S':
          /* TODO */
          outputnl("/S NOT IMPLEMENTED YET");
          return(-1);
          break;
        case 'w':
        case 'W':
          req->format = DIR_OUTPUT_WIDE;
          break;
        default:
          nls_outputnl_err(0, 2); /* invalid switch */
          return(-1);
      }
    } else {  /* filespec */
      if (req->filespecptr != NULL) {
        nls_outputnl_err(0, 4); /* too many parameters */
        return(-1);
      }
      req->filespecptr = *argv;
    }
  }
 
  return(0);
}
 
 
static enum cmd_result cmd_dir(struct cmd_funcparam *p) {
  struct DTA *dta = (void *)0x80; /* set DTA to its default location at 80h in PSP */
  struct TINYDTA far *dtabuf = NULL; /* used to buffer results when sorting is enabled */
  unsigned short dtabufcount = 0;
  unsigned short i;
  unsigned short availrows;  /* counter of available rows on display (used for /P) */
  unsigned short screenw = screen_getwidth();
  unsigned short wcols = screenw / WCOLWIDTH; /* number of columns in wide mode */
  unsigned char wcolcount;
  struct {
    struct nls_patterns nls;
    char buff64[64];
    char path[128];
    unsigned short orderidx[65535 / sizeof(struct TINYDTA)];
  } *buf = (void *)(p->BUFFER);
  unsigned long summary_fcount = 0;
  unsigned long summary_totsz = 0;
  unsigned char drv = 0;
  struct dirrequest req;
 
  /* make sure there's no risk of buffer overflow */
  if (sizeof(buf) > p->BUFFERSZ) {
    outputnl("INTERNAL MEM ERROR IN " __FILE__);
    return(CMD_FAIL);
  }
 
  bzero(&glob_sortcmp_dat, sizeof(glob_sortcmp_dat));
 
  if (cmd_ishlp(p)) {
    nls_outputnl(37,0); /* "Displays a list of files and subdirectories in a directory" */
    outputnl("");
    nls_outputnl(37,1); /* "DIR [drive:][path][filename] [/P] [/W] [/A[:]attributes] [/O[[:]sortorder]] [/S] [/B] [/L]" */
    outputnl("");
    nls_outputnl(37,2); /* "/P Pauses after each screenful of information" */
    nls_outputnl(37,3); /* "/W Uses wide list format" */
    outputnl("");
    nls_outputnl(37,4); /* "/A Displays files with specified attributes:" */
    nls_outputnl(37,5); /* "    D Directories            R Read-only files        H Hidden files" */
    nls_outputnl(37,6); /* "    A Ready for archiving    S System files           - prefix meaning "not"" */
    outputnl("");
    nls_outputnl(37,7); /* "/O List files in sorted order:" */
    nls_outputnl(37,8); /* "    N by name                S by size                E by extension" */
    nls_outputnl(37,9); /* "    D by date                G group dirs first       - prefix to reverse order" */
    outputnl("");
    nls_outputnl(37,10); /* "/S Displays files in specified directory and all subdirectories" */
    nls_outputnl(37,11); /* "/B Uses bare format (no heading information or summary)" */
    nls_outputnl(37,12); /* "/L Uses lowercases" */
    return(CMD_OK);
  }
 
  i = nls_getpatterns(&(buf->nls));
  if (i != 0) nls_outputnl_doserr(i);
 
  /* disable usage of thousands separator on narrow screens */
  if (screenw < 80) buf->nls.thousep[0] = 0;
 
  /*** PARSING COMMAND LINE STARTS *******************************************/
 
  /* init req with some defaults */
  bzero(&req, sizeof(req));
  req.attrfilter_may = DIR_ATTR_DEFAULT;
  req.format = DIR_OUTPUT_NORM;
 
  /* process DIRCMD first (so it can be overidden by user's cmdline) */
  {
  const char far *dircmd = env_lookup_val(p->env_seg, "DIRCMD");
  if (dircmd != NULL) {
    const char *argvptrs[32];
    cmd_explode(buf->buff64, dircmd, argvptrs);
    if ((dir_parse_cmdline(&req, argvptrs) != 0) || (req.filespecptr != NULL)) {
      nls_output(255, 10);/* bad environment */
      output(" - ");
      outputnl("DIRCMD");
      return(CMD_FAIL);
    }
  }
  }
 
  /* parse user's command line */
  if (dir_parse_cmdline(&req, p->argv) != 0) return(CMD_FAIL);
 
  /* if no filespec provided, then it's about the current directory */
  if (req.filespecptr == NULL) req.filespecptr = ".";
 
  /*** PARSING COMMAND LINE DONE *********************************************/
 
 
  availrows = screen_getheight() - 2;
 
  /* special case: "DIR drive:" (truename() fails on "C:" under MS-DOS 6.0) */
  if ((req.filespecptr[0] != 0) && (req.filespecptr[1] == ':') && (req.filespecptr[2] == 0)) {
    if ((req.filespecptr[0] >= 'a') && (req.filespecptr[0] <= 'z')) {
      buf->path[0] = req.filespecptr[0] - ('a' - 1);
    } else {
      buf->path[0] = req.filespecptr[0] - ('A' - 1);
    }
    i = curpathfordrv(buf->path, buf->path[0]);
  } else {
    i = file_truename(req.filespecptr, buf->path);
  }
  if (i != 0) {
    nls_outputnl_doserr(i);
    return(CMD_FAIL);
  }
 
  if (req.format != DIR_OUTPUT_BARE) {
    drv = buf->path[0];
    if (drv >= 'a') {
      drv -= 'a';
    } else {
      drv -= 'A';
    }
    cmd_vol_internal(drv, buf->buff64);
    sprintf(buf->buff64, svarlang_str(37,20)/*"Directory of %s"*/, buf->path);
    /* trim at first '?', if any */
    for (i = 0; buf->buff64[i] != 0; i++) if (buf->buff64[i] == '?') buf->buff64[i] = 0;
    outputnl(buf->buff64);
    outputnl("");
    availrows -= 3;
  }
 
  /* if dir: append a backslash (also get its len) */
  i = path_appendbkslash_if_dir(buf->path);
 
  /* if ends with a \ then append ????????.??? */
  if (buf->path[i - 1] == '\\') strcat(buf->path, "????????.???");
 
  /* ask DOS for list of files, but only with allowed attribs */
  i = findfirst(dta, buf->path, req.attrfilter_may);
  if (i != 0) {
    nls_outputnl_doserr(i);
    return(CMD_FAIL);
  }
 
  /* if sorting is involved, then let's buffer all results (and sort them) */
  if (req.flags & DIR_FLAG_SORT) {
    /* allocate a memory buffer - try several sizes until one succeeds */
    const unsigned short memsz[] = {65500, 32000, 16000, 8000, 4000, 2000, 1000, 0};
    unsigned short max_dta_bufcount = 0;
    for (i = 0; memsz[i] != 0; i++) {
      dtabuf = _fmalloc(memsz[i]);
      if (dtabuf != NULL) break;
    }
 
    if (dtabuf == NULL) {
      nls_outputnl_doserr(8); /* out of memory */
      return(CMD_FAIL);
    }
 
    /* remember the address so I can free it afterwards */
    glob_sortcmp_dat.dtabuf_root = dtabuf;
 
    /* compute the amount of DTAs I can buffer */
    max_dta_bufcount = memsz[i] / sizeof(struct TINYDTA);
    /* printf("max_dta_bufcount = %u\n", max_dta_bufcount); */
 
    do {
      /* filter out files with uninteresting attributes */
      if (filter_attribs(dta, req.attrfilter_must, req.attrfilter_may) == 0) continue;
 
      /* normalize "size" of directories to zero because kernel returns garbage
       * sizes for directories which might confuse the sorting routine later */
      if (dta->attr & DOS_ATTR_DIR) dta->size = 0;
 
      _fmemcpy(&(dtabuf[dtabufcount]), ((char *)dta) + 22, sizeof(struct TINYDTA));
 
      /* save attribs in sec field, otherwise zero it (this field is not
       * displayed and dropping the attr field saves 2 bytes per entry) */
      dtabuf[dtabufcount++].time_sec2 = (dta->attr & 31);
 
      /* do I have any space left? */
      if (dtabufcount == max_dta_bufcount) {
        //TODO some kind of user notification might be nice here
        //outputnl("TOO MANY ENTRIES FOR SORTING! LIST IS UNSORTED");
        break;
      }
 
    } while (findnext(dta) == 0);
 
    /* sort the list - the tricky part is that my array is a far address while
     * qsort works only with near pointers, so I have to use an ugly (and
     * global) auxiliary table */
    for (i = 0; i < dtabufcount; i++) buf->orderidx[i] = i;
    qsort(buf->orderidx, dtabufcount, 2, &sortcmp);
 
    /* preload first entry (last from orderidx, since entries are sorted in reverse) */
    dtabufcount--;
    _fmemcpy(((unsigned char *)dta) + 22, &(dtabuf[buf->orderidx[dtabufcount]]), sizeof(struct TINYDTA));
    dta->attr = dtabuf[buf->orderidx[dtabufcount]].time_sec2; /* restore attr from the abused time_sec2 field */
  }
 
  wcolcount = 0; /* may be used for columns counting with wide mode */
 
  for (;;) {
 
    /* filter out attributes (skip if entry comes from buffer, then it was already veted) */
    if (filter_attribs(dta, req.attrfilter_must, req.attrfilter_may) == 0) continue;
 
    /* turn string lcase (/L) */
    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... */
 
    summary_fcount++;
    if ((dta->attr & DOS_ATTR_DIR) == 0) summary_totsz += dta->size;
 
    switch (req.format) {
      case DIR_OUTPUT_NORM:
        /* print fname-space-extension (unless it's "." or "..", then print as-is) */
        if (dta->fname[0] == '.') {
          output(dta->fname);
          i = strlen(dta->fname);
          while (i++ < 12) output(" ");
        } else {
          file_fname2fcb(buf->buff64, dta->fname);
          memmove(buf->buff64 + 9, buf->buff64 + 8, 4);
          buf->buff64[8] = ' ';
          output(buf->buff64);
        }
        output(" ");
        /* either <DIR> or right aligned 10-chars byte size */
        memset(buf->buff64, ' ', 10);
        if (dta->attr & DOS_ATTR_DIR) {
          strcpy(buf->buff64 + 10, svarlang_str(37,21));
        } else {
          nls_format_number(buf->buff64 + 10, dta->size, &(buf->nls));
        }
        output(buf->buff64 + strlen(buf->buff64) - 10);
        /* two spaces and NLS DATE */
        buf->buff64[0] = ' ';
        buf->buff64[1] = ' ';
        if (screenw >= 80) {
          nls_format_date(buf->buff64 + 2, dta->date_yr + 1980, dta->date_mo, dta->date_dy, &(buf->nls));
        } else {
          nls_format_date(buf->buff64 + 2, (dta->date_yr + 80) % 100, dta->date_mo, dta->date_dy, &(buf->nls));
        }
        output(buf->buff64);
 
        /* one space and NLS TIME */
        nls_format_time(buf->buff64 + 1, dta->time_hour, dta->time_min, 0xff, &(buf->nls));
        outputnl(buf->buff64);
        break;
 
      case DIR_OUTPUT_WIDE: /* display in columns of 12 chars per item */
        i = strlen(dta->fname);
        if (dta->attr & DOS_ATTR_DIR) {
          i += 2;
          output("[");
          output(dta->fname);
          output("]");
        } else {
          output(dta->fname);
        }
        while (i++ < WCOLWIDTH) output(" ");
        if (++wcolcount == wcols) {
          wcolcount = 0;
          outputnl("");
        } else {
          availrows++; /* wide mode is the only one that does not write one line per file */
        }
        break;
 
      case DIR_OUTPUT_BARE:
        outputnl(dta->fname);
        break;
    }
 
    if (req.flags & DIR_FLAG_PAUSE) dir_pagination(&availrows);
 
    /* take next entry, either from buf or disk */
    if (dtabufcount > 0) {
      dtabufcount--;
      _fmemcpy(((unsigned char *)dta) + 22, &(dtabuf[buf->orderidx[dtabufcount]]), sizeof(struct TINYDTA));
      dta->attr = dtabuf[buf->orderidx[dtabufcount]].time_sec2; /* restore attr from the abused time_sec2 field */
    } else {
      if (findnext(dta) != 0) break;
    }
 
  }
 
  if (wcolcount != 0) {
    outputnl(""); /* in wide mode make sure to end on a clear row */
    if (req.flags & DIR_FLAG_PAUSE) dir_pagination(&availrows);
  }
 
  /* print out summary (unless bare output mode) */
  if (req.format != DIR_OUTPUT_BARE) {
    unsigned short alignpos;
    unsigned char uint32maxlen = 13; /* 13 is the max len of a 32 bit number with thousand separators (4'000'000'000) */
    if (screenw < 80) uint32maxlen = 10;
    /* x file(s) */
    memset(buf->buff64, ' ', uint32maxlen);
    i = nls_format_number(buf->buff64 + uint32maxlen, summary_fcount, &(buf->nls));
    alignpos = sprintf(buf->buff64 + uint32maxlen + i, " %s ", svarlang_str(37,22)/*"file(s)"*/);
    output(buf->buff64 + i);
    /* xxxx bytes */
    i = nls_format_number(buf->buff64 + uint32maxlen, summary_totsz, &(buf->nls));
    output(buf->buff64 + i + 1);
    output(" ");
    nls_outputnl(37,23); /* "bytes" */
    if (req.flags & DIR_FLAG_PAUSE) dir_pagination(&availrows);
    /* xxxx bytes free */
    i = cmd_dir_df(&summary_totsz, drv);
    if (i != 0) nls_outputnl_doserr(i);
    alignpos += uint32maxlen * 2;
    memset(buf->buff64, ' ', alignpos); /* align the freebytes value to same column as totbytes */
    i = nls_format_number(buf->buff64 + alignpos, summary_totsz, &(buf->nls));
    output(buf->buff64 + i + 1);
    output(" ");
    nls_outputnl(37,24); /* "bytes free" */
    if (req.flags & DIR_FLAG_PAUSE) dir_pagination(&availrows);
  }
 
  /* free the buffer memory (if used) */
  if (glob_sortcmp_dat.dtabuf_root != NULL) _ffree(glob_sortcmp_dat.dtabuf_root);
 
  return(CMD_OK);
}
 

Rev 1725	Rev 1726
1	`/* This file is part of the SvarCOM project and is published under the terms`	1	`/* This file is part of the SvarCOM project and is published under the terms`
2	`* of the MIT license.`	2	`* of the MIT license.`
3	`*`	3	`*`
4	`* Copyright (C) 2021-2024 Mateusz Viste`	4	`* Copyright (C) 2021-2024 Mateusz Viste`
5	`*`	5	`*`
6	`* Permission is hereby granted, free of charge, to any person obtaining a`	6	`* Permission is hereby granted, free of charge, to any person obtaining a`
7	`* copy of this software and associated documentation files (the "Software"),`	7	`* copy of this software and associated documentation files (the "Software"),`
8	`* to deal in the Software without restriction, including without limitation`	8	`* to deal in the Software without restriction, including without limitation`
9	`* the rights to use, copy, modify, merge, publish, distribute, sublicense,`	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`	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:`	11	`* Software is furnished to do so, subject to the following conditions:`
12	`*`	12	`*`
13	`* The above copyright notice and this permission notice shall be included in`	13	`* The above copyright notice and this permission notice shall be included in`
14	`* all copies or substantial portions of the Software.`	14	`* all copies or substantial portions of the Software.`
15	`*`	15	`*`
16	`* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR`	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,`	17	`* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,`
18	`* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE`	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`	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`	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`	21	`* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER`
22	`* DEALINGS IN THE SOFTWARE.`	22	`* DEALINGS IN THE SOFTWARE.`
23	`*/`	23	`*/`
24		24
25	`/*`	25	`/*`
26	`* dir`	26	`* dir`
27	`*`	27	`*`
28	`* Displays a list of files and subdirectories in a directory.`	28	`* Displays a list of files and subdirectories in a directory.`
29	`*`	29	`*`
30	`* DIR [drive:][path][filename] [/P] [/W] [/A[:]attributes] [/O[[:]sortorder]] [/S] [/B] [/L]`	30	`* DIR [drive:][path][filename] [/P] [/W] [/A[:]attributes] [/O[[:]sortorder]] [/S] [/B] [/L]`
31	`*`	31	`*`
32	`* /P Pauses after each screenful of information.`	32	`* /P Pauses after each screenful of information.`
33	`* /W Uses wide list format.`	33	`* /W Uses wide list format.`
34	`*`	34	`*`
35	`* /A Displays file with specified attributes:`	35	`* /A Displays file with specified attributes:`
36	`* D Directories R Read-only files H Hidden files`	36	`* D Directories R Read-only files H Hidden files`
37	`* A Ready for archiving S System files - prefix meaning "not"`	37	`* A Ready for archiving S System files - prefix meaning "not"`
38	`*`	38	`*`
39	`* /O List files in sorted order:`	39	`* /O List files in sorted order:`
40	`* N by name S by size E by extension`	40	`* N by name S by size E by extension`
41	`* D by date G group dirs first - prefix to reverse order`	41	`* D by date G group dirs first - prefix to reverse order`
42	`*`	42	`*`
43	`* /S Displays files in specified directory and all subdirectories.`	43	`* /S Displays files in specified directory and all subdirectories.`
44	`* /B Uses bare format (no heading information or summary)`	44	`* /B Uses bare format (no heading information or summary)`
45	`* /L Uses lowercases`	45	`* /L Uses lowercases`
46	`*/`	46	`*/`
47		47
48	`/* NOTE: /A attributes are matched in an exclusive way, ie. only files with`	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`	49	`* the specified attributes are matched. This is different from how DOS`
50	`* itself matches attributes hence DIR cannot rely on the attributes`	50	`* itself matches attributes hence DIR cannot rely on the attributes`
51	`* filter within FindFirst.`	51	`* filter within FindFirst.`
52	`*`	52	`*`
53	`* NOTE: Multiple /A are not supported - only the last one is significant.`	53	`* NOTE: Multiple /A are not supported - only the last one is significant.`
54	`*/`	54	`*/`
55		55
56	`#define WCOLWIDTH 15 /* width of a column in wide mode output */`	56	`#define WCOLWIDTH 15 /* width of a column in wide mode output */`
57		57
58		58
59	`/* a "tiny" DTA is a DTA that is stripped from bytes that are not needed for`	59	`/* a "tiny" DTA is a DTA that is stripped from bytes that are not needed for`
60	`* DIR operations */`	60	`* DIR operations */`
61	`_Packed struct TINYDTA {`	61	`_Packed struct TINYDTA {`
62	`/* char reserved[21];`	62	`/* char reserved[21];`
63	`unsigned char attr; */`	63	`unsigned char attr; */`
64	`unsigned short time_sec2:5;`	64	`unsigned short time_sec2:5;`
65	`unsigned short time_min:6;`	65	`unsigned short time_min:6;`
66	`unsigned short time_hour:5;`	66	`unsigned short time_hour:5;`
67	`unsigned short date_dy:5;`	67	`unsigned short date_dy:5;`
68	`unsigned short date_mo:4;`	68	`unsigned short date_mo:4;`
69	`unsigned short date_yr:7;`	69	`unsigned short date_yr:7;`
70	`unsigned long size;`	70	`unsigned long size;`
71	`/* char fname[13]; */`	71	`/* char fname[13]; */`
72	`char fname[12];`	72	`char fname[12];`
73	`};`	73	`};`
74		74
75		75
76	`/* fills freebytes with free bytes for drv (A=0, B=1, etc)`	76	`/* fills freebytes with free bytes for drv (A=0, B=1, etc)`
77	`* returns DOS ERR code on failure */`	77	`* returns DOS ERR code on failure */`
78	`static unsigned short cmd_dir_df(unsigned long *freebytes, unsigned char drv) {`	78	`static unsigned short cmd_dir_df(unsigned long *freebytes, unsigned char drv) {`
79	`unsigned short res = 0;`	79	`unsigned short res = 0;`
80	`unsigned short sects_per_clust = 0, avail_clusts = 0, bytes_per_sect = 0;`	80	`unsigned short sects_per_clust = 0, avail_clusts = 0, bytes_per_sect = 0;`
81		81
82	`_asm {`	82	`_asm {`
83	`push ax`	83	`push ax`
84	`push bx`	84	`push bx`
85	`push cx`	85	`push cx`
86	`push dx`	86	`push dx`
87		87
88	`mov ah, 0x36 /* DOS 2+ -- Get Disk Free Space */`	88	`mov ah, 0x36 /* DOS 2+ -- Get Disk Free Space */`
89	`mov dl, [drv] /* A=1, B=2, etc (0 = DEFAULT DRIVE) */`	89	`mov dl, [drv] /* A=1, B=2, etc (0 = DEFAULT DRIVE) */`
90	`inc dl`	90	`inc dl`
91	`int 0x21 /* AX=sects_per_clust, BX=avail_clusts, CX=bytes_per_sect, DX=tot_clusters */`	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) */`	92	`cmp ax, 0xffff /* AX=0xffff on error (invalid drive) */`
93	`jne COMPUTEDF`	93	`jne COMPUTEDF`
94	`mov [res], 0x0f /* fill res with DOS error code 15 ("invalid drive") */`	94	`mov [res], 0x0f /* fill res with DOS error code 15 ("invalid drive") */`
95	`jmp DONE`	95	`jmp DONE`
96		96
97	`COMPUTEDF:`	97	`COMPUTEDF:`
98	`/* freebytes = AX * BX * CX */`	98	`/* freebytes = AX * BX * CX */`
99	`mov [sects_per_clust], ax`	99	`mov [sects_per_clust], ax`
100	`mov [avail_clusts], bx`	100	`mov [avail_clusts], bx`
101	`mov [bytes_per_sect], cx`	101	`mov [bytes_per_sect], cx`
102		102
103	`DONE:`	103	`DONE:`
104	`pop dx`	104	`pop dx`
105	`pop cx`	105	`pop cx`
106	`pop bx`	106	`pop bx`
107	`pop ax`	107	`pop ax`
108	`}`	108	`}`
109		109
110	`/* multiple steps to avoid uint16 overflow */`	110	`/* multiple steps to avoid uint16 overflow */`
111	`*freebytes = sects_per_clust;`	111	`*freebytes = sects_per_clust;`
112	`freebytes = avail_clusts;`	112	`freebytes = avail_clusts;`
113	`freebytes = bytes_per_sect;`	113	`freebytes = bytes_per_sect;`
114		114
115	`return(res);`	115	`return(res);`
116	`}`	116	`}`
117		117
118		118
119	`static void dir_pagination(unsigned short *availrows) {`	119	`static void dir_pagination(unsigned short *availrows) {`
120	`*availrows -= 1;`	120	`*availrows -= 1;`
121	`if (*availrows == 0) {`	121	`if (*availrows == 0) {`
122	`press_any_key();`	122	`press_any_key();`
123	`*availrows = screen_getheight() - 1;`	123	`*availrows = screen_getheight() - 1;`
124	`}`	124	`}`
125	`}`	125	`}`
126		126
127		127
128	`/* parse an attr list like "Ar-hS" and fill bitfield into attrfilter_may and attrfilter_must.`	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")`	129	`* /AHS -> adds S and H to mandatory attribs ("must")`
130	`* /A-S -> removes S from allowed attribs ("may")`	130	`* /A-S -> removes S from allowed attribs ("may")`
131	`* returns non-zero on error. */`	131	`* returns non-zero on error. */`
132	`static int dir_parse_attr_list(const char arg, unsigned char attrfilter_may, unsigned char *attrfilter_must) {`	132	`static int dir_parse_attr_list(const char arg, unsigned char attrfilter_may, unsigned char *attrfilter_must) {`
133	`for (; *arg != 0; arg++) {`	133	`for (; *arg != 0; arg++) {`
134	`unsigned char curattr;`	134	`unsigned char curattr;`
135	`char not;`	135	`char not;`
136	`if (*arg == '-') {`	136	`if (*arg == '-') {`
137	`not = 1;`	137	`not = 1;`
138	`arg++;`	138	`arg++;`
139	`} else {`	139	`} else {`
140	`not = 0;`	140	`not = 0;`
141	`}`	141	`}`
142	`switch (*arg) {`	142	`switch (*arg) {`
143	`case 'd':`	143	`case 'd':`
144	`case 'D':`	144	`case 'D':`
145	`curattr = DOS_ATTR_DIR;`	145	`curattr = DOS_ATTR_DIR;`
146	`break;`	146	`break;`
147	`case 'r':`	147	`case 'r':`
148	`case 'R':`	148	`case 'R':`
149	`curattr = DOS_ATTR_RO;`	149	`curattr = DOS_ATTR_RO;`
150	`break;`	150	`break;`
151	`case 'a':`	151	`case 'a':`
152	`case 'A':`	152	`case 'A':`
153	`curattr = DOS_ATTR_ARC;`	153	`curattr = DOS_ATTR_ARC;`
154	`break;`	154	`break;`
155	`case 'h':`	155	`case 'h':`
156	`case 'H':`	156	`case 'H':`
157	`curattr = DOS_ATTR_HID;`	157	`curattr = DOS_ATTR_HID;`
158	`break;`	158	`break;`
159	`case 's':`	159	`case 's':`
160	`case 'S':`	160	`case 'S':`
161	`curattr = DOS_ATTR_SYS;`	161	`curattr = DOS_ATTR_SYS;`
162	`break;`	162	`break;`
163	`default:`	163	`default:`
164	`return(-1);`	164	`return(-1);`
165	`}`	165	`}`
166	`/* update res bitfield */`	166	`/* update res bitfield */`
167	`if (not) {`	167	`if (not) {`
168	`*attrfilter_may &= ~curattr;`	168	`*attrfilter_may &= ~curattr;`
169	`} else {`	169	`} else {`
170	`*attrfilter_must \|= curattr;`	170	`*attrfilter_must \|= curattr;`
171	`}`	171	`}`
172	`}`	172	`}`
173	`return(0);`	173	`return(0);`
174	`}`	174	`}`
175		175
176		176
177	`/* compare attributes in a DTA node to mandatory and optional attributes. returns 1 on match, 0 otherwise */`	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) {`	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 */`	179	`/* if mandatory attribs are requested, filter them now */`
180	`if ((attrfilter_must & dta->attr) != attrfilter_must) return(0);`	180	`if ((attrfilter_must & dta->attr) != attrfilter_must) return(0);`
181		181
182	`/* if file contains attributes that are not allowed -> skip */`	182	`/* if file contains attributes that are not allowed -> skip */`
183	`if ((~attrfilter_may & dta->attr) != 0) return(0);`	183	`if ((~attrfilter_may & dta->attr) != 0) return(0);`
184		184
185	`return(1);`	185	`return(1);`
186	`}`	186	`}`
187		187
188		188
189	`static struct {`	189	`static struct {`
190	`struct TINYDTA far *dtabuf_root;`	190	`struct TINYDTA far *dtabuf_root;`
191	`char order[8]; /* GNESD values (ucase = lower first ; lcase = higher first) */`	191	`char order[8]; /* GNESD values (ucase = lower first ; lcase = higher first) */`
192	`} glob_sortcmp_dat;`	192	`} glob_sortcmp_dat;`
193		193
194		194
195	`/* translates an order string like "GNE-S" into values fed into the order[]`	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. */`	196	`* table of glob_sortcmp_dat. returns 0 on success, non-zero otherwise. */`
197	`static int dir_process_order_directive(const char *ordstring) {`	197	`static int dir_process_order_directive(const char *ordstring) {`
198	`const char gnesd = "gnesd"; / must be lower case */`	198	`const char gnesd = "gnesd"; / must be lower case */`
199	`int ordi, orderi = 0, i;`	199	`int ordi, orderi = 0, i;`
200		200
201	`/* tabula rasa */`	201	`/* tabula rasa */`
202	`glob_sortcmp_dat.order[0] = 0;`	202	`glob_sortcmp_dat.order[0] = 0;`
203		203
204	`/* /O alone is a short hand for /OGN */`	204	`/* /O alone is a short hand for /OGN */`
205	`if (*ordstring == 0) {`	205	`if (*ordstring == 0) {`
206	`glob_sortcmp_dat.order[0] = 'G';`	206	`glob_sortcmp_dat.order[0] = 'G';`
207	`glob_sortcmp_dat.order[1] = 'N';`	207	`glob_sortcmp_dat.order[1] = 'N';`
208	`glob_sortcmp_dat.order[2] = 0;`	208	`glob_sortcmp_dat.order[2] = 0;`
209	`}`	209	`}`
210		210
-		211	`/* stupid MSDOS compatibility ("DIR /O:GNE") */`
-		212	`if (*ordstring == ':') ordstring++;`
-		213
211	`/* parsing */`	214	`/* parsing */`
212	`for (ordi = 0; ordstring[ordi] != 0; ordi++) {`	215	`for (ordi = 0; ordstring[ordi] != 0; ordi++) {`
213	`if (ordstring[ordi] == '-') {`	216	`if (ordstring[ordi] == '-') {`
214	`if ((ordstring[ordi + 1] == '-') \|\| (ordstring[ordi + 1] == 0)) return(-1);`	217	`if ((ordstring[ordi + 1] == '-') \|\| (ordstring[ordi + 1] == 0)) return(-1);`
215	`continue;`	218	`continue;`
216	`}`	219	`}`
217	`if (orderi == sizeof(glob_sortcmp_dat.order)) return(-1);`	220	`if (orderi == sizeof(glob_sortcmp_dat.order)) return(-1);`
218		221
219	`for (i = 0; gnesd[i] != 0; i++) {`	222	`for (i = 0; gnesd[i] != 0; i++) {`
220	`if ((ordstring[ordi] \| 32) == gnesd[i]) { /* \| 32 is lcase-ing the char */`	223	`if ((ordstring[ordi] \| 32) == gnesd[i]) { /* \| 32 is lcase-ing the char */`
221	`if ((ordi > 0) && (ordstring[ordi - 1] == '-')) {`	224	`if ((ordi > 0) && (ordstring[ordi - 1] == '-')) {`
222	`glob_sortcmp_dat.order[orderi] = gnesd[i];`	225	`glob_sortcmp_dat.order[orderi] = gnesd[i];`
223	`} else {`	226	`} else {`
224	`glob_sortcmp_dat.order[orderi] = gnesd[i] ^ 32;`	227	`glob_sortcmp_dat.order[orderi] = gnesd[i] ^ 32;`
225	`}`	228	`}`
226	`orderi++;`	229	`orderi++;`
227	`break;`	230	`break;`
228	`}`	231	`}`
229	`}`	232	`}`
230	`if (gnesd[i] == 0) return(-1);`	233	`if (gnesd[i] == 0) return(-1);`
231	`}`	234	`}`
232		235
233	`return(0);`	236	`return(0);`
234	`}`	237	`}`
235		238
236		239
237	`static int sortcmp(const void dtaid1, const void dtaid2) {`	240	`static int sortcmp(const void dtaid1, const void dtaid2) {`
238	`struct TINYDTA far dta1 = &(glob_sortcmp_dat.dtabuf_root[((unsigned short *)dtaid1)]);`	241	`struct TINYDTA far dta1 = &(glob_sortcmp_dat.dtabuf_root[((unsigned short *)dtaid1)]);`
239	`struct TINYDTA far dta2 = &(glob_sortcmp_dat.dtabuf_root[((unsigned short *)dtaid2)]);`	242	`struct TINYDTA far dta2 = &(glob_sortcmp_dat.dtabuf_root[((unsigned short *)dtaid2)]);`
240	`char *ordconf = glob_sortcmp_dat.order;`	243	`char *ordconf = glob_sortcmp_dat.order;`
241		244
242	`/* debug stuff`	245	`/* debug stuff`
243	`{`	246	`{`
244	`int i;`	247	`int i;`
245	`printf("%lu vs %lu \| ", dta1->size, dta2->size);`	248	`printf("%lu vs %lu \| ", dta1->size, dta2->size);`
246	`for (i = 0; dta1->fname[i] != 0; i++) printf("%c", dta1->fname[i]);`	249	`for (i = 0; dta1->fname[i] != 0; i++) printf("%c", dta1->fname[i]);`
247	`printf(" vs ");`	250	`printf(" vs ");`
248	`for (i = 0; dta2->fname[i] != 0; i++) printf("%c", dta2->fname[i]);`	251	`for (i = 0; dta2->fname[i] != 0; i++) printf("%c", dta2->fname[i]);`
249	`printf("\n");`	252	`printf("\n");`
250	`} */`	253	`} */`
251		254
252	`for (;;) {`	255	`for (;;) {`
253	`int r = -1;`	256	`int r = -1;`
254	`if (*ordconf & 32) r = 1;`	257	`if (*ordconf & 32) r = 1;`
255		258
256	`switch (*ordconf \| 32) {`	259	`switch (*ordconf \| 32) {`
257	`case 'g': /* sort by type (directories first, then files) */`	260	`case 'g': /* sort by type (directories first, then files) */`
258	`if ((dta1->time_sec2 & DOS_ATTR_DIR) > (dta2->time_sec2 & DOS_ATTR_DIR)) return(0 - r);`	261	`if ((dta1->time_sec2 & DOS_ATTR_DIR) > (dta2->time_sec2 & DOS_ATTR_DIR)) return(0 - r);`
259	`if ((dta1->time_sec2 & DOS_ATTR_DIR) < (dta2->time_sec2 & DOS_ATTR_DIR)) return(r);`	262	`if ((dta1->time_sec2 & DOS_ATTR_DIR) < (dta2->time_sec2 & DOS_ATTR_DIR)) return(r);`
260	`break;`	263	`break;`
261	`case ' ': /* default (last resort) sort: by name */`	264	`case ' ': /* default (last resort) sort: by name */`
262	`case 'e': /* sort by extension */`	265	`case 'e': /* sort by extension */`
263	`case 'n': /* sort by filename */`	266	`case 'n': /* sort by filename */`
264	`{`	267	`{`
265	`const char far *f1 = dta1->fname;`	268	`const char far *f1 = dta1->fname;`
266	`const char far *f2 = dta2->fname;`	269	`const char far *f2 = dta2->fname;`
267	`int i, limit = 12;`	270	`int i, limit = 12;`
268	`/* special handling for '.' and '..' entries */`	271	`/* special handling for '.' and '..' entries */`
269	`if ((f1[0] == '.') && (f2[0] != '.')) return(0 - r);`	272	`if ((f1[0] == '.') && (f2[0] != '.')) return(0 - r);`
270	`if ((f2[0] == '.') && (f1[0] != '.')) return(r);`	273	`if ((f2[0] == '.') && (f1[0] != '.')) return(r);`
271		274
272	`if ((*ordconf \| 32) == 'e') {`	275	`if ((*ordconf \| 32) == 'e') {`
273	`/* fast-forward to extension or end of filename */`	276	`/* fast-forward to extension or end of filename */`
274	`while ((f1 != 0) && (f1 != '.')) f1++;`	277	`while ((f1 != 0) && (f1 != '.')) f1++;`
275	`while ((f2 != 0) && (f2 != '.')) f2++;`	278	`while ((f2 != 0) && (f2 != '.')) f2++;`
276	`limit = 4; /* TINYDTA structs are not nul-terminated */`	279	`limit = 4; /* TINYDTA structs are not nul-terminated */`
277	`}`	280	`}`
278	`/* cmp */`	281	`/* cmp */`
279	`for (i = 0; i < limit; i++) {`	282	`for (i = 0; i < limit; i++) {`
280	`if ((f1 \| 32) < (f2 \| 32)) return(0 - r);`	283	`if ((f1 \| 32) < (f2 \| 32)) return(0 - r);`
281	`if ((f1 \| 32) > (f2 \| 32)) return(r);`	284	`if ((f1 \| 32) > (f2 \| 32)) return(r);`
282	`if (*f1 == 0) break;`	285	`if (*f1 == 0) break;`
283	`f1++;`	286	`f1++;`
284	`f2++;`	287	`f2++;`
285	`}`	288	`}`
286	`}`	289	`}`
287	`break;`	290	`break;`
288	`case 's': /* sort by size */`	291	`case 's': /* sort by size */`
289	`if (dta1->size > dta2->size) return(r);`	292	`if (dta1->size > dta2->size) return(r);`
290	`if (dta1->size < dta2->size) return(0 - r);`	293	`if (dta1->size < dta2->size) return(0 - r);`
291	`break;`	294	`break;`
292	`case 'd': /* sort by date */`	295	`case 'd': /* sort by date */`
293	`if (dta1->date_yr < dta2->date_yr) return(0 - r);`	296	`if (dta1->date_yr < dta2->date_yr) return(0 - r);`
294	`if (dta1->date_yr > dta2->date_yr) return(r);`	297	`if (dta1->date_yr > dta2->date_yr) return(r);`
295	`if (dta1->date_mo < dta2->date_mo) return(0 - r);`	298	`if (dta1->date_mo < dta2->date_mo) return(0 - r);`
296	`if (dta1->date_mo > dta2->date_mo) return(r);`	299	`if (dta1->date_mo > dta2->date_mo) return(r);`
297	`if (dta1->date_dy < dta2->date_dy) return(0 - r);`	300	`if (dta1->date_dy < dta2->date_dy) return(0 - r);`
298	`if (dta1->date_dy > dta2->date_dy) return(r);`	301	`if (dta1->date_dy > dta2->date_dy) return(r);`
299	`if (dta1->time_hour < dta2->time_hour) return(0 - r);`	302	`if (dta1->time_hour < dta2->time_hour) return(0 - r);`
300	`if (dta1->time_hour > dta2->time_hour) return(r);`	303	`if (dta1->time_hour > dta2->time_hour) return(r);`
301	`if (dta1->time_min < dta2->time_min) return(0 - r);`	304	`if (dta1->time_min < dta2->time_min) return(0 - r);`
302	`if (dta1->time_min > dta2->time_min) return(r);`	305	`if (dta1->time_min > dta2->time_min) return(r);`
303	`break;`	306	`break;`
304	`}`	307	`}`
305		308
306	`if (*ordconf == 0) break;`	309	`if (*ordconf == 0) break;`
307	`ordconf++;`	310	`ordconf++;`
308	`}`	311	`}`
309		312
310	`return(0);`	313	`return(0);`
311	`}`	314	`}`
312		315
313		316
314	`#define DIR_ATTR_DEFAULT (DOS_ATTR_RO \| DOS_ATTR_DIR \| DOS_ATTR_ARC)`	317	`#define DIR_ATTR_DEFAULT (DOS_ATTR_RO \| DOS_ATTR_DIR \| DOS_ATTR_ARC)`
315		318
316	`struct dirrequest {`	319	`struct dirrequest {`
317	`unsigned char attrfilter_may;`	320	`unsigned char attrfilter_may;`
318	`unsigned char attrfilter_must;`	321	`unsigned char attrfilter_must;`
319	`const char *filespecptr;`	322	`const char *filespecptr;`
320		323
321	`#define DIR_FLAG_PAUSE 1`	324	`#define DIR_FLAG_PAUSE 1`
322	`#define DIR_FLAG_RECUR 4`	325	`#define DIR_FLAG_RECUR 4`
323	`#define DIR_FLAG_LCASE 8`	326	`#define DIR_FLAG_LCASE 8`
324	`#define DIR_FLAG_SORT 16`	327	`#define DIR_FLAG_SORT 16`
325	`unsigned char flags;`	328	`unsigned char flags;`
326		329
327	`#define DIR_OUTPUT_NORM 1`	330	`#define DIR_OUTPUT_NORM 1`
328	`#define DIR_OUTPUT_WIDE 2`	331	`#define DIR_OUTPUT_WIDE 2`
329	`#define DIR_OUTPUT_BARE 3`	332	`#define DIR_OUTPUT_BARE 3`
330	`unsigned char format;`	333	`unsigned char format;`
331	`};`	334	`};`
332		335
333		336
334	`static int dir_parse_cmdline(struct dirrequest req, const char *argv) {`	337	`static int dir_parse_cmdline(struct dirrequest req, const char *argv) {`
335	`for (; *argv != NULL; argv++) {`	338	`for (; *argv != NULL; argv++) {`
336	`if (*argv[0] == '/') {`	339	`if (*argv[0] == '/') {`
337	`const char arg = argv + 1;`	340	`const char arg = argv + 1;`
338	`char neg = 0;`	341	`char neg = 0;`
339	`/* detect negations and get actual argument */`	342	`/* detect negations and get actual argument */`
340	`if (*arg == '-') {`	343	`if (*arg == '-') {`
341	`neg = 1;`	344	`neg = 1;`
342	`arg++;`	345	`arg++;`
343	`}`	346	`}`
344	`/* */`	347	`/* */`
345	`switch (*arg) {`	348	`switch (*arg) {`
346	`case 'a':`	349	`case 'a':`
347	`case 'A':`	350	`case 'A':`
348	`arg++;`	351	`arg++;`
349	`/* preset defaults */`	352	`/* preset defaults */`
350	`req->attrfilter_may = DIR_ATTR_DEFAULT;`	353	`req->attrfilter_may = DIR_ATTR_DEFAULT;`
351	`req->attrfilter_must = 0;`	354	`req->attrfilter_must = 0;`
352	`/* /-A only allowed without further parameters (used to cancel possible previous /Asmth) */`	355	`/* /-A only allowed without further parameters (used to cancel possible previous /Asmth) */`
353	`if (neg) {`	356	`if (neg) {`
354	`if (*arg != 0) {`	357	`if (*arg != 0) {`
355	`nls_outputnl_err(0, 2); /* invalid switch */`	358	`nls_outputnl_err(0, 2); /* invalid switch */`
356	`return(-1);`	359	`return(-1);`
357	`}`	360	`}`
358	`} else {`	361	`} else {`
359	`/* skip colon if present */`	362	`/* skip colon if present */`
360	`if (*arg == ':') arg++;`	363	`if (*arg == ':') arg++;`
361	`/* start with "allow everything" */`	364	`/* start with "allow everything" */`
362	`req->attrfilter_may = (DOS_ATTR_ARC \| DOS_ATTR_DIR \| DOS_ATTR_HID \| DOS_ATTR_SYS \| DOS_ATTR_RO);`	365	`req->attrfilter_may = (DOS_ATTR_ARC \| DOS_ATTR_DIR \| DOS_ATTR_HID \| DOS_ATTR_SYS \| DOS_ATTR_RO);`
363	`if (dir_parse_attr_list(arg, &(req->attrfilter_may), &(req->attrfilter_must)) != 0) {`	366	`if (dir_parse_attr_list(arg, &(req->attrfilter_may), &(req->attrfilter_must)) != 0) {`
364	`nls_outputnl_err(0, 3); /* invalid parameter format */`	367	`nls_outputnl_err(0, 3); /* invalid parameter format */`
365	`return(-1);`	368	`return(-1);`
366	`}`	369	`}`
367	`}`	370	`}`
368	`break;`	371	`break;`
369	`case 'b':`	372	`case 'b':`
370	`case 'B':`	373	`case 'B':`
371	`req->format = DIR_OUTPUT_BARE;`	374	`req->format = DIR_OUTPUT_BARE;`
372	`break;`	375	`break;`
373	`case 'l':`	376	`case 'l':`
374	`case 'L':`	377	`case 'L':`
375	`req->flags \|= DIR_FLAG_LCASE;`	378	`req->flags \|= DIR_FLAG_LCASE;`
376	`break;`	379	`break;`
377	`case 'o':`	380	`case 'o':`
378	`case 'O':`	381	`case 'O':`
379	`if (neg) {`	382	`if (neg) {`
380	`req->flags &= (0xff ^ DIR_FLAG_SORT);`	383	`req->flags &= (0xff ^ DIR_FLAG_SORT);`
381	`break;`	384	`break;`
382	`}`	385	`}`
383	`if (dir_process_order_directive(arg+1) != 0) {`	386	`if (dir_process_order_directive(arg+1) != 0) {`
384	`nls_output_err(0, 3); /* invalid parameter format */`	387	`nls_output_err(0, 3); /* invalid parameter format */`
385	`output(": ");`	388	`output(": ");`
386	`outputnl(arg);`	389	`outputnl(arg);`
387	`return(-1);`	390	`return(-1);`
388	`}`	391	`}`
389	`req->flags \|= DIR_FLAG_SORT;`	392	`req->flags \|= DIR_FLAG_SORT;`
390	`break;`	393	`break;`
391	`case 'p':`	394	`case 'p':`
392	`case 'P':`	395	`case 'P':`
393	`req->flags \|= DIR_FLAG_PAUSE;`	396	`req->flags \|= DIR_FLAG_PAUSE;`
394	`if (neg) req->flags &= (0xff ^ DIR_FLAG_PAUSE);`	397	`if (neg) req->flags &= (0xff ^ DIR_FLAG_PAUSE);`
395	`break;`	398	`break;`
396	`case 's':`	399	`case 's':`
397	`case 'S':`	400	`case 'S':`
398	`/* TODO */`	401	`/* TODO */`
399	`outputnl("/S NOT IMPLEMENTED YET");`	402	`outputnl("/S NOT IMPLEMENTED YET");`
400	`return(-1);`	403	`return(-1);`
401	`break;`	404	`break;`
402	`case 'w':`	405	`case 'w':`
403	`case 'W':`	406	`case 'W':`
404	`req->format = DIR_OUTPUT_WIDE;`	407	`req->format = DIR_OUTPUT_WIDE;`
405	`break;`	408	`break;`
406	`default:`	409	`default:`
407	`nls_outputnl_err(0, 2); /* invalid switch */`	410	`nls_outputnl_err(0, 2); /* invalid switch */`
408	`return(-1);`	411	`return(-1);`
409	`}`	412	`}`
410	`} else { /* filespec */`	413	`} else { /* filespec */`
411	`if (req->filespecptr != NULL) {`	414	`if (req->filespecptr != NULL) {`
412	`nls_outputnl_err(0, 4); /* too many parameters */`	415	`nls_outputnl_err(0, 4); /* too many parameters */`
413	`return(-1);`	416	`return(-1);`
414	`}`	417	`}`
415	`req->filespecptr = *argv;`	418	`req->filespecptr = *argv;`
416	`}`	419	`}`
417	`}`	420	`}`
418		421
419	`return(0);`	422	`return(0);`
420	`}`	423	`}`
421		424
422		425
423	`static enum cmd_result cmd_dir(struct cmd_funcparam *p) {`	426	`static enum cmd_result cmd_dir(struct cmd_funcparam *p) {`
424	`struct DTA dta = (void )0x80; /* set DTA to its default location at 80h in PSP */`	427	`struct DTA dta = (void )0x80; /* set DTA to its default location at 80h in PSP */`
425	`struct TINYDTA far dtabuf = NULL; / used to buffer results when sorting is enabled */`	428	`struct TINYDTA far dtabuf = NULL; / used to buffer results when sorting is enabled */`
426	`unsigned short dtabufcount = 0;`	429	`unsigned short dtabufcount = 0;`
427	`unsigned short i;`	430	`unsigned short i;`
428	`unsigned short availrows; /* counter of available rows on display (used for /P) */`	431	`unsigned short availrows; /* counter of available rows on display (used for /P) */`
429	`unsigned short screenw = screen_getwidth();`	432	`unsigned short screenw = screen_getwidth();`
430	`unsigned short wcols = screenw / WCOLWIDTH; /* number of columns in wide mode */`	433	`unsigned short wcols = screenw / WCOLWIDTH; /* number of columns in wide mode */`
431	`unsigned char wcolcount;`	434	`unsigned char wcolcount;`
432	`struct {`	435	`struct {`
433	`struct nls_patterns nls;`	436	`struct nls_patterns nls;`
434	`char buff64[64];`	437	`char buff64[64];`
435	`char path[128];`	438	`char path[128];`
436	`unsigned short orderidx[65535 / sizeof(struct TINYDTA)];`	439	`unsigned short orderidx[65535 / sizeof(struct TINYDTA)];`
437	`} buf = (void )(p->BUFFER);`	440	`} buf = (void )(p->BUFFER);`
438	`unsigned long summary_fcount = 0;`	441	`unsigned long summary_fcount = 0;`
439	`unsigned long summary_totsz = 0;`	442	`unsigned long summary_totsz = 0;`
440	`unsigned char drv = 0;`	443	`unsigned char drv = 0;`
441	`struct dirrequest req;`	444	`struct dirrequest req;`
442		445
443	`/* make sure there's no risk of buffer overflow */`	446	`/* make sure there's no risk of buffer overflow */`
444	`if (sizeof(buf) > p->BUFFERSZ) {`	447	`if (sizeof(buf) > p->BUFFERSZ) {`
445	`outputnl("INTERNAL MEM ERROR IN " __FILE__);`	448	`outputnl("INTERNAL MEM ERROR IN " __FILE__);`
446	`return(CMD_FAIL);`	449	`return(CMD_FAIL);`
447	`}`	450	`}`
448		451
449	`bzero(&glob_sortcmp_dat, sizeof(glob_sortcmp_dat));`	452	`bzero(&glob_sortcmp_dat, sizeof(glob_sortcmp_dat));`
450		453
451	`if (cmd_ishlp(p)) {`	454	`if (cmd_ishlp(p)) {`
452	`nls_outputnl(37,0); /* "Displays a list of files and subdirectories in a directory" */`	455	`nls_outputnl(37,0); /* "Displays a list of files and subdirectories in a directory" */`
453	`outputnl("");`	456	`outputnl("");`
454	`nls_outputnl(37,1); /* "DIR [drive:][path][filename] [/P] [/W] [/A[:]attributes] [/O[[:]sortorder]] [/S] [/B] [/L]" */`	457	`nls_outputnl(37,1); /* "DIR [drive:][path][filename] [/P] [/W] [/A[:]attributes] [/O[[:]sortorder]] [/S] [/B] [/L]" */`
455	`outputnl("");`	458	`outputnl("");`
456	`nls_outputnl(37,2); /* "/P Pauses after each screenful of information" */`	459	`nls_outputnl(37,2); /* "/P Pauses after each screenful of information" */`
457	`nls_outputnl(37,3); /* "/W Uses wide list format" */`	460	`nls_outputnl(37,3); /* "/W Uses wide list format" */`
458	`outputnl("");`	461	`outputnl("");`
459	`nls_outputnl(37,4); /* "/A Displays files with specified attributes:" */`	462	`nls_outputnl(37,4); /* "/A Displays files with specified attributes:" */`
460	`nls_outputnl(37,5); /* " D Directories R Read-only files H Hidden files" */`	463	`nls_outputnl(37,5); /* " D Directories R Read-only files H Hidden files" */`
461	`nls_outputnl(37,6); /* " A Ready for archiving S System files - prefix meaning "not"" */`	464	`nls_outputnl(37,6); /* " A Ready for archiving S System files - prefix meaning "not"" */`
462	`outputnl("");`	465	`outputnl("");`
463	`nls_outputnl(37,7); /* "/O List files in sorted order:" */`	466	`nls_outputnl(37,7); /* "/O List files in sorted order:" */`
464	`nls_outputnl(37,8); /* " N by name S by size E by extension" */`	467	`nls_outputnl(37,8); /* " N by name S by size E by extension" */`
465	`nls_outputnl(37,9); /* " D by date G group dirs first - prefix to reverse order" */`	468	`nls_outputnl(37,9); /* " D by date G group dirs first - prefix to reverse order" */`
466	`outputnl("");`	469	`outputnl("");`
467	`nls_outputnl(37,10); /* "/S Displays files in specified directory and all subdirectories" */`	470	`nls_outputnl(37,10); /* "/S Displays files in specified directory and all subdirectories" */`
468	`nls_outputnl(37,11); /* "/B Uses bare format (no heading information or summary)" */`	471	`nls_outputnl(37,11); /* "/B Uses bare format (no heading information or summary)" */`
469	`nls_outputnl(37,12); /* "/L Uses lowercases" */`	472	`nls_outputnl(37,12); /* "/L Uses lowercases" */`
470	`return(CMD_OK);`	473	`return(CMD_OK);`
471	`}`	474	`}`
472		475
473	`i = nls_getpatterns(&(buf->nls));`	476	`i = nls_getpatterns(&(buf->nls));`
474	`if (i != 0) nls_outputnl_doserr(i);`	477	`if (i != 0) nls_outputnl_doserr(i);`
475		478
476	`/* disable usage of thousands separator on narrow screens */`	479	`/* disable usage of thousands separator on narrow screens */`
477	`if (screenw < 80) buf->nls.thousep[0] = 0;`	480	`if (screenw < 80) buf->nls.thousep[0] = 0;`
478		481
479	`/* PARSING COMMAND LINE STARTS *****************************************/`	482	`/* PARSING COMMAND LINE STARTS *****************************************/`
480		483
481	`/* init req with some defaults */`	484	`/* init req with some defaults */`
482	`bzero(&req, sizeof(req));`	485	`bzero(&req, sizeof(req));`
483	`req.attrfilter_may = DIR_ATTR_DEFAULT;`	486	`req.attrfilter_may = DIR_ATTR_DEFAULT;`
484	`req.format = DIR_OUTPUT_NORM;`	487	`req.format = DIR_OUTPUT_NORM;`
485		488
486	`/* process DIRCMD first (so it can be overidden by user's cmdline) */`	489	`/* process DIRCMD first (so it can be overidden by user's cmdline) */`
487	`{`	490	`{`
488	`const char far *dircmd = env_lookup_val(p->env_seg, "DIRCMD");`	491	`const char far *dircmd = env_lookup_val(p->env_seg, "DIRCMD");`
489	`if (dircmd != NULL) {`	492	`if (dircmd != NULL) {`
490	`const char *argvptrs[32];`	493	`const char *argvptrs[32];`
491	`cmd_explode(buf->buff64, dircmd, argvptrs);`	494	`cmd_explode(buf->buff64, dircmd, argvptrs);`
492	`if ((dir_parse_cmdline(&req, argvptrs) != 0) \|\| (req.filespecptr != NULL)) {`	495	`if ((dir_parse_cmdline(&req, argvptrs) != 0) \|\| (req.filespecptr != NULL)) {`
493	`nls_output(255, 10);/* bad environment */`	496	`nls_output(255, 10);/* bad environment */`
494	`output(" - ");`	497	`output(" - ");`
495	`outputnl("DIRCMD");`	498	`outputnl("DIRCMD");`
496	`return(CMD_FAIL);`	499	`return(CMD_FAIL);`
497	`}`	500	`}`

Subversion Repositories SvarDOS

(root)/svarcom/trunk/cmd/dir.c – Rev 1725 → 1726