workbench/c/List.c

   1 /*
   2     Copyright © 1995-2014, The AROS Development Team. All rights reserved.
   3     $Id$
   4
   5     List the contents of a directory.
   6 */
   7 /*****************************************************************************
   8
   9     NAME
  10
  11         List
  12
  13     FORMAT
  14
  15         List [(dir | pattern | filename)] [ PAT (pattern)] [KEYS] [DATES]
  16              [NODATES] [TO (name)] [SUB (string)] [SINCE (date)] [UPTO (date)]
  17              [QUICK] [BLOCK] [NOHEAD] [FILES] [DIRS] [LFORMAT (string)] [ALL]
  18
  19     TEMPLATE
  20
  21         DIR/M,P=PAT/K,KEYS/S,DATES/S,NODATES/S,TO/K,SUB/K,SINCE/K,UPTO/K,QUICK/S,BLOCK/S,NOHEAD/S,FILES/S,DIRS/S,LFORMAT/K,ALL/S
  22
  23     LOCATION
  24
  25         C:
  26
  27     FUNCTION
  28
  29         Lists detailed information about the files and directories in the
  30         current directory or in the directory specified by DIR.
  31
  32         The information for each file or directory is presented on a separate
  33         line, containing the following information:
  34
  35         name
  36         size (in bytes)
  37         protection bits
  38         date and time
  39
  40     INPUTS
  41
  42         DIR           --  The directory to list. If left out, the current
  43                           directory will be listed.
  44         PAT           --  Display only files matching 'string'
  45         KEYS          --  Display the block number of each file or directory
  46         DATES         --  Always display the full modification date of files
  47                           and directories instead of a day name.
  48         NODATES       --  Don't display dates
  49         TO (name)     --  Write the listing to a file instead of stdout
  50         SUB (string)  --  Display only files, a substring of which matches
  51                           the substring 'string'
  52         SINCE (date)  --  Display only files newer than 'date'
  53         UPTO (date)   --  Display only files older than 'date'
  54         QUICK         --  Display only the names of files
  55         BLOCK         --  File sizes are in blocks of 512 bytes
  56         NOHEAD        --  Don't print any header information
  57         FILES         --  Display files only
  58         DIRS          --  Display directories only
  59         LFORMAT       --  Specify the list output in printf-style
  60         ALL           --  List the contents of directories recursively
  61
  62         The following attributes of the LFORMAT strings are available
  63
  64         %A  --  file attributes
  65         %B  --  size of file in blocks rather than bytes
  66         %C  --  file comment
  67         %D  --  modification date
  68         %E  --  file extension
  69         %F  --  volume name
  70         %K  --  file key block number
  71         %L  --  size of file in bytes
  72         %M  --  file name without extension
  73         %N  --  file name
  74         %P  --  file path
  75         %S  --  superceded by %N and %P; obsolete
  76         %T  --  modification time
  77
  78     RESULT
  79
  80         Standard DOS return codes.
  81
  82     EXAMPLE
  83
  84         1> List C:
  85         Directory "C:" on Wednesday 12-Dec-99
  86         AddBuffers                  444 --p-rwed 02-Sep-99 11:51:31
  87         Assign                     3220 --p-rwed 02-Sep-99 11:51:31
  88         Avail                       728 --p-rwed 02-Sep-99 11:51:31
  89         Copy                       3652 --p-rwed 02-Sep-99 11:51:31
  90         Delete                     1972 --p-rwed 02-Sep-99 11:51:31
  91         Execute                    4432 --p-rwed 02-Sep-99 11:51:31
  92         List                       5108 --p-rwed 02-Sep-99 11:51:31
  93         Installer                109956 ----rwed 02-Sep-99 11:51:31
  94         Which                      1068 --p-rwed 02-Sep-99 11:51:31
  95         9 files - 274 blocks used
  96
  97     BUGS
  98
  99     SEE ALSO
 100
 101         Dir
 102
 103     INTERNALS
 104
 105 ******************************************************************************/
 106
 107 #define  DEBUG  0
 108 #include <aros/debug.h>
 109
 110 #include <clib/macros.h>
 111 #include <exec/memory.h>
 112 #include <proto/exec.h>
 113 #include <dos/datetime.h>
 114 #include <dos/dos.h>
 115 #include <dos/exall.h>
 116 #include <dos/dosasl.h>
 117 #include <dos/datetime.h>
 118 #include <proto/dos.h>
 119 #include <proto/alib.h>
 120 #include <proto/utility.h>
 121 #include <utility/tagitem.h>
 122
 123 const TEXT version[] = "$VER: List 41.12 (3.4.2014)\n";
 124
 125 #define ARG_TEMPLATE "DIR/M,P=PAT/K,KEYS/S,DATES/S,NODATES/S,TO/K,SUB/K,SINCE/K,UPTO/K,QUICK/S,BLOCK/S,NOHEAD/S,FILES/S,DIRS/S,LFORMAT/K,ALL/S"
 126
 127 struct DirNode
 128 {
 129     struct MinNode  node;
 130     char           *dirname;
 131 };
 132
 133
 134 typedef struct _Statistics
 135 {
 136     ULONG nFiles;
 137     ULONG nDirs;
 138     UQUAD nBlocks;
 139 } Statistics;
 140
 141
 142 enum
 143 {
 144     ARG_DIR = 0,
 145     ARG_PAT,
 146     ARG_KEYS,
 147     ARG_DATES,
 148     ARG_NODATES,
 149     ARG_TO,
 150     ARG_SUB,
 151     ARG_SINCE,
 152     ARG_UPTO,
 153     ARG_QUICK,
 154     ARG_BLOCK,
 155     ARG_NOHEAD,
 156     ARG_FILES,
 157     ARG_DIRS,
 158     ARG_LFORMAT,
 159     ARG_ALL,
 160     NOOFARGS
 161 };
 162
 163 #define  MAX_PATH_LEN  1024
 164
 165 #define  BLOCKSIZE  512
 166
 167 int printDirHeader(STRPTR dirname, BOOL noHead)
 168 {
 169     struct DateTime dt;
 170
 171     char  datestr[LEN_DATSTRING];
 172     char  dow[LEN_DATSTRING];
 173
 174     if (!noHead)
 175     {
 176         DateStamp((struct DateStamp *)&dt);
 177         dt.dat_Format = FORMAT_DEF;
 178         dt.dat_Flags = 0;
 179         dt.dat_StrDay = dow;
 180         dt.dat_StrDate = datestr;
 181         dt.dat_StrTime = NULL;
 182         DateToStr(&dt);
 183
 184         Printf("Directory \"%s\" on %s %s:\n", dirname, dow, datestr);
 185     }
 186
 187     return RETURN_OK;
 188 }
 189
 190
 191 /* Possible printf-type switches
 192
 193         %A  --  file attributes
 194         %B  --  size of file in blocks rather than bytes
 195         %C  --  file comment
 196         %D  --  file date
 197         %E  --  file extension
 198         %F  --  volume name
 199         %K  --  file key block number
 200         %L  --  size of file in bytes
 201         %M  --  file name without extension
 202         %N  --  file name
 203         %P  --  file path
 204         %S  --  file name or file path
 205         %T  --  file time
 206 */
 207
 208 struct lfstruct
 209 {
 210     struct AnchorPath *ap;
 211     BOOL               isdir;
 212     STRPTR             date;
 213     STRPTR             time;
 214     STRPTR             flags;
 215     STRPTR             filename;
 216     STRPTR             comment;
 217     UQUAD              size;
 218     ULONG              key;
 219 };
 220
 221
 222 #define  roundUp(x, bSize) ((x + bSize - 1)/bSize)
 223
 224 int printLformat(STRPTR format, struct lfstruct *lf)
 225 {
 226     STRPTR filename       = FilePart(lf->filename);
 227     STRPTR temp           = format;
 228     LONG   substitutePath = 0;
 229     char c;
 230
 231     /*
 232         Whether the path or the filename is substituted for an occurrence
 233         of %S depends on how many occurrences are in the LFORMAT line, and
 234         their order, as follows:
 235
 236         Occurrences of %S   1st         2nd         3rd         4th
 237         1                   filename
 238         2                   path        filename
 239         3                   path        filename    filename
 240         4                   path        filename    path        filename
 241     */
 242
 243     while ( ( substitutePath < 4 ) && ( '\0' != (c = *temp++) ) )
 244     {
 245         if ( '%' == c )
 246             if ( 'S' == ToUpper(*temp++) )
 247                 substitutePath++;
 248     }
 249     if ( substitutePath == 3 )
 250         substitutePath = 2;
 251
 252     while ('\0' != (c = *format++))
 253     {
 254         if ('%' == c)
 255         {
 256             switch (ToUpper(*format++))
 257             {
 258                 /* File comment */
 259             case 'C':
 260                 Printf(lf->comment);
 261                 break;
 262
 263                 /* Modification date */
 264             case 'D':
 265                 Printf(lf->date);
 266                 break;
 267
 268                 /* Modification time */
 269             case 'T':
 270                 Printf(lf->time);
 271                 break;
 272
 273                 /* File size in blocks of BLOCKSIZE bytes */
 274             case 'B':
 275                 if (lf->isdir)
 276                 {
 277                     Printf("Dir");
 278                 }
 279                 else
 280                 {
 281                     ULONG tmp = roundUp(lf->size, BLOCKSIZE);
 282
 283                     /* File is 0 bytes? */
 284                     if (tmp == 0)
 285                     {
 286                         Printf("empty");
 287                     }
 288                     else
 289                     {
 290                         Printf("%lu", tmp);
 291                     }
 292                 }
 293
 294                 break;
 295
 296                 /* Path incl. volume name*/
 297             case 'F':
 298                 {
 299                     UBYTE buf[256];
 300
 301                     if (NameFromLock(lf->ap->ap_Current->an_Lock, buf, 256))
 302                     {
 303                         int len;
 304
 305                         Printf(buf);
 306
 307                         len = strlen(buf);
 308                         if ((len > 0) && (buf[len - 1] != ':') && (buf[len - 1] != '/'))
 309                         {
 310                             Printf("/");
 311                         }
 312                     }
 313                 }
 314
 315                 break;
 316
 317                 /* File attributes (flags) */
 318             case 'A':
 319                 Printf(lf->flags);
 320                 break;
 321
 322                 /* Disk block key */
 323             case 'K':
 324                 Printf("[%lu]", lf->key);
 325                 break;
 326
 327                 /* File size */
 328             case 'L':
 329                 if (lf->isdir)
 330                 {
 331                     Printf("Dir");
 332                 }
 333                 else
 334                 {
 335                     if (lf->size == 0)
 336                     {
 337                         Printf("empty");
 338                     }
 339                     else
 340                     {
 341                         UQUAD filesize = lf->size;
 342
 343                         char buf[256];
 344                         buf[255] = '\0';
 345                         int fill, i;
 346
 347                         char *bufpos = &buf[254];
 348
 349                         do
 350                         {
 351                             bufpos[0] = '0' + (filesize % 10);
 352                             filesize /= 10;
 353                             bufpos--;
 354                         } while (filesize);
 355
 356                         fill = 13 - (&buf[254] - bufpos);
 357                         for (i = 0; i < fill; i++)
 358                         {
 359                             Printf(" ");
 360                         }
 361                         Printf("%s ", &bufpos[1]);
 362                     }
 363                 }
 364
 365                 break;
 366
 367                 /* File name without extension */
 368             case 'M':
 369                 {
 370                     STRPTR lastPoint = strrchr(filename, '.');
 371
 372                     if (lastPoint != NULL)
 373                     {
 374                         *lastPoint = 0;
 375                     }
 376
 377                     Printf(filename);
 378
 379                     /* Resurrect filename in case we should print it once
 380                        more */
 381                     if (lastPoint != NULL)
 382                     {
 383                         *lastPoint = '.';
 384                     }
 385                 }
 386
 387                 break;
 388
 389                 /* Filename or Path name */
 390             case 'S':
 391                 D(bug("[List] substitutePath = %d\n", substitutePath));
 392                 if ( (--substitutePath == 3) || (substitutePath == 1) )
 393                 {
 394                     STRPTR end = FilePart(lf->filename);
 395                     UBYTE  token = *end;
 396
 397                     *end = '\0';
 398
 399                     Printf(lf->filename);
 400
 401                     /* Restore pathname */
 402                     *end = token;
 403
 404                     break;
 405                 }
 406                 /* Fall through */
 407             case 'N':
 408                 Printf(filename);
 409                 break;
 410
 411                 /* File extension */
 412             case 'E':
 413                 {
 414                     STRPTR extension = strrchr(filename, '.');
 415
 416                     if (extension != NULL)
 417                     {
 418                         Printf(extension);
 419                     }
 420                 }
 421
 422                 break;
 423
 424                 /* Path name, but without volume */
 425             case 'P':
 426                 {
 427                     STRPTR end = FilePart(lf->filename);
 428                     UBYTE  token = *end;
 429
 430                     *end = 0;
 431
 432                     Printf(lf->filename);
 433
 434                     /* Restore pathname */
 435                     *end = token;
 436                 }
 437
 438                 break;
 439
 440             case 0:
 441                 return 0;
 442                 break;
 443
 444             default:
 445                 Printf("%%%lc", *format);
 446                 break;
 447             }
 448         }
 449         else
 450         {
 451             Printf("%lc", c);
 452         }
 453     }
 454
 455     return 0;
 456 }
 457
 458
 459 int printFileData(struct AnchorPath *ap,
 460                   BOOL showFiles, BOOL showDirs, STRPTR parsedPattern,
 461                   ULONG *files, ULONG *dirs, ULONG *nBlocks, STRPTR lFormat,
 462                   BOOL quick, BOOL dates, BOOL noDates, BOOL block,
 463                   struct DateStamp *sinceDate, struct DateStamp *uptoDate,
 464                   BOOL doSince, BOOL doUpto, STRPTR subpatternStr,
 465                   BOOL keys)
 466 {
 467     STRPTR             filename = ap->ap_Buf;
 468     BOOL               isDir = (ap->ap_Info.fib_DirEntryType >= 0);
 469     struct DateStamp  *ds = &ap->ap_Info.fib_Date;
 470     ULONG              protection = ap->ap_Info.fib_Protection;
 471     UQUAD              size = ap->ap_Info.fib_Size;
 472     STRPTR             filenote = ap->ap_Info.fib_Comment;
 473     ULONG              diskKey = ap->ap_Info.fib_DiskKey;
 474
 475     int error = 0;
 476
 477     UBYTE date[LEN_DATSTRING];
 478     UBYTE time[LEN_DATSTRING];
 479     UBYTE flags[8];
 480
 481     struct DateTime dt;
 482
 483 #if defined(ACTION_GET_FILE_SIZE64)
 484     if (ap->ap_Info.fib_Size >= 0x7FFFFFFF)
 485     {
 486         BPTR flock = BNULL;
 487         flock = Lock(filename, ACCESS_READ);
 488
 489         if (flock)
 490         {
 491             UQUAD *size_ptr = (UQUAD *)DoPkt(((struct FileLock *)flock)->fl_Task, ACTION_GET_FILE_SIZE64, (IPTR)flock, 0, 0, 0, 0);
 492             if (size_ptr)
 493             {
 494                 size = *size_ptr;
 495             }
 496             UnLock(flock);
 497         }
 498     }
 499 #endif
 500     /* Do the file match the time interval we are looking for?
 501        (ARG_SINCE and ARG_UPTO) -- any combination of these may be
 502        specified */
 503     if ((doSince && (CompareDates(sinceDate, ds) < 0)) ||
 504         (doUpto && (CompareDates(uptoDate, ds) > 0)))
 505     {
 506         return 0;
 507     }
 508
 509     /* Does the filename match a certain pattern? (ARG_PAT) */
 510     if (parsedPattern != NULL &&
 511         !MatchPatternNoCase(parsedPattern, FilePart(filename)))
 512     {
 513         return 0;
 514     }
 515
 516     /* Does a substring of the filename match a certain pattern? (ARG_SUB) */
 517     if (subpatternStr != NULL &&
 518         !MatchPatternNoCase(subpatternStr, FilePart(filename)))
 519     {
 520         return 0;
 521     }
 522
 523     CopyMem(ds, &dt.dat_Stamp, sizeof(struct DateStamp));
 524     dt.dat_Format  = FORMAT_DOS;
 525     if (dates)
 526         dt.dat_Flags = 0;
 527     else
 528         dt.dat_Flags = DTF_SUBST;
 529     dt.dat_StrDay  = NULL;
 530     dt.dat_StrDate = date;
 531     dt.dat_StrTime = time;
 532     DateToStr(&dt);
 533
 534     /* Convert the protection bits to a string */
 535     flags[0] = protection & FIBF_SCRIPT  ? 's' : '-';
 536     flags[1] = protection & FIBF_PURE    ? 'p' : '-';
 537     flags[2] = protection & FIBF_ARCHIVE ? 'a' : '-';
 538
 539     /* The following flags are high-active! */
 540     flags[3] = protection & FIBF_READ    ? '-' : 'r';
 541     flags[4] = protection & FIBF_WRITE   ? '-' : 'w';
 542     flags[5] = protection & FIBF_EXECUTE ? '-' : 'e';
 543     flags[6] = protection & FIBF_DELETE  ? '-' : 'd';
 544     flags[7] = 0x00;
 545
 546     if (isDir)
 547     {
 548         if (showDirs)
 549         {
 550             ++*dirs;
 551             ++*nBlocks; /* dir entry uses 1 block on AROS, 2 on OS31) */
 552
 553             if (lFormat != NULL)
 554             {
 555                 struct lfstruct lf = { ap, isDir, date, time, flags, filename,
 556                                        filenote, size, diskKey};
 557
 558                 printLformat(lFormat, &lf);
 559                 Printf("\n");
 560             }
 561             else
 562             {
 563                 D(bug("Found file %s\n", filename));
 564
 565                 Printf("%-25s ", FilePart(filename));
 566
 567                 if (!quick)
 568                 {
 569                     Printf("        <Dir> %7s ", flags);
 570                 }
 571
 572                 if (!noDates && (!quick || dates))
 573                 {
 574                     Printf("%-11s %s", date, time);
 575                 }
 576
 577                 Printf("\n");
 578             }
 579         }
 580     }
 581     else if (showFiles)
 582     {
 583         ++*files;
 584         *nBlocks += roundUp(size, BLOCKSIZE);
 585
 586         if (lFormat != NULL)
 587         {
 588             struct lfstruct lf = { ap, isDir, date, time, flags, filename,
 589                                    filenote, size, diskKey };
 590
 591             printLformat(lFormat, &lf);
 592             Printf("\n");
 593         }
 594         else
 595         {
 596             Printf("%-25s ", FilePart(filename));
 597
 598             if (!quick)
 599             {
 600                 if(keys)
 601                 {
 602                     char key[16];
 603                     int  fill;
 604                     int  i;     /* Loop variable */
 605
 606                     __sprintf(key, "%lu", (unsigned long)diskKey);
 607                     fill = 7 - strlen(key) - 2;
 608
 609                     for (i = 0; i < fill; i++)
 610                     {
 611                         Printf(" ");
 612                     }
 613
 614                     Printf("[%lu] ", diskKey);
 615                 }
 616                 else
 617                 {
 618                     if (0 != size)
 619                     {
 620                         UQUAD filesize = block ? roundUp(size, BLOCKSIZE) : size;
 621
 622                         char buf[256];
 623                         buf[255] = '\0';
 624                         int fill, i;
 625
 626                         char *bufpos = &buf[254];
 627
 628                         do
 629                         {
 630                             bufpos[0] = '0' + (filesize % 10);
 631                             filesize /= 10;
 632                             bufpos--;
 633                         } while (filesize);
 634
 635                         fill = 13 - (&buf[254] - bufpos);
 636                         for (i = 0; i < fill; i++)
 637                         {
 638                             Printf(" ");
 639                         }
 640                         Printf("%s ", &bufpos[1]);
 641                     }
 642                     else
 643                     {
 644                         Printf("  empty ");
 645                     }
 646                 }
 647
 648                 Printf("%7s ", flags);
 649             }
 650
 651             if (!noDates && (!quick || dates))
 652             {
 653                 Printf("%-11s %s", date, time);
 654             }
 655
 656             if (!quick && (*filenote != 0))
 657             {
 658                 Printf("\n: %s", filenote);
 659             }
 660
 661             Printf("\n");
 662         }
 663     }
 664
 665     return error;
 666 }
 667
 668
 669 /* Print directory summary information */
 670 void printSummary(CONST_STRPTR dirname, int files, int dirs, int nBlocks,
 671                     BOOL noHead, BOOL PrintEmpty)
 672 {
 673
 674     if (noHead) return;
 675
 676     if (files || dirs)
 677     {
 678
 679         if (files > 1)
 680             Printf("%ld files", files);
 681         else if (files > 0)
 682             PutStr("1 file");
 683
 684         if( files && (dirs || nBlocks) ) PutStr(" - ");
 685
 686         if (dirs > 1)
 687             Printf("%ld directories", dirs);
 688         else if (dirs > 0)
 689             PutStr("1 directory");
 690
 691         if( dirs && nBlocks ) PutStr(" - ");
 692
 693         if (nBlocks > 1)
 694             Printf("%ld blocks used\n", nBlocks);
 695         else if (nBlocks > 0)
 696             PutStr("1 block used\n");
 697         else PutStr("\n");
 698
 699     }
 700     else if (PrintEmpty)
 701         Printf("Directory \"%s\" is empty\n", dirname);
 702 }
 703
 704
 705 int listFile(CONST_STRPTR filename, BOOL showFiles, BOOL showDirs,
 706              STRPTR parsedPattern, BOOL noHead, STRPTR lFormat, BOOL quick,
 707              BOOL dates, BOOL noDates, BOOL block, struct DateStamp *sinceDate,
 708              struct DateStamp *uptoDate, BOOL doSince, BOOL doUpto,
 709              STRPTR subpatternStr, BOOL all, BOOL keys, Statistics *stats)
 710 {
 711     struct AnchorPath *ap;
 712     struct List DirList, FreeDirNodeList;
 713     struct DirNode *dirnode, *prev_dirnode = NULL;
 714
 715     ULONG  files = 0;
 716     ULONG  dirs = 0;
 717     ULONG  nBlocks = 0;
 718     LONG  error;
 719
 720     NewList(&DirList);
 721     NewList(&FreeDirNodeList);
 722
 723     do
 724     {
 725         ap = AllocVec(sizeof(struct AnchorPath) + MAX_PATH_LEN, MEMF_CLEAR);
 726
 727         if (ap == NULL)
 728         {
 729             return 0;
 730         }
 731
 732         ap->ap_Strlen = MAX_PATH_LEN;
 733
 734         error = MatchFirst(filename, ap);
 735
 736         /* Explicitly named directory and not a pattern? --> enter dir */
 737
 738         if (0 == error)
 739         {
 740             if (!(ap->ap_Flags & APF_ITSWILD))
 741             {
 742                 if (ap->ap_Info.fib_DirEntryType >= 0)
 743                 {
 744                     //error = printDirHeader(filename, noHead);
 745                     ap->ap_Flags |= APF_DODIR;
 746
 747                     if (0 == error)
 748                     {
 749                         error = MatchNext(ap);
 750                     }
 751                 }
 752             }
 753         }
 754
 755         if (0 == error)
 756         {
 757             BOOL first = TRUE;
 758
 759             ap->ap_BreakBits = SIGBREAKF_CTRL_C;
 760             if (FilePart(ap->ap_Buf) == ap->ap_Buf)
 761             {
 762                 ap->ap_Flags &= ~APF_DirChanged;
 763             }
 764
 765             do
 766             {
 767                 /*
 768                 ** There's something to show.
 769                 */
 770                 if (!(ap->ap_Flags & APF_DIDDIR))
 771                 {
 772                     if (ap->ap_Flags & APF_DirChanged)
 773                     {
 774                         STRPTR p;
 775                         UBYTE c;
 776
 777                         if (!first) printSummary(filename, files, dirs, nBlocks, noHead, TRUE);
 778
 779                         /* Update global statistics for (possible) ALL option */
 780                         stats->nFiles += files;
 781                         stats->nDirs += dirs;
 782                         stats->nBlocks += nBlocks;
 783
 784                         files = 0;
 785                         dirs = 0;
 786                         nBlocks = 0;
 787
 788                         p = PathPart(ap->ap_Buf);
 789                         c = *p;
 790                         *p = 0;
 791
 792                         error = printDirHeader(ap->ap_Buf, noHead);
 793
 794                         *p = c;
 795
 796                     }
 797
 798                     error = printFileData(ap,
 799                                           showFiles,
 800                                           showDirs,
 801                                           parsedPattern,
 802                                           &files,
 803                                           &dirs,
 804                                           &nBlocks,
 805                                           lFormat,
 806                                           quick,
 807                                           dates,
 808                                           noDates,
 809                                           block,
 810                                           sinceDate,
 811                                           uptoDate,
 812                                           doSince,
 813                                           doUpto,
 814                                           subpatternStr,
 815                                           keys);
 816
 817                     if (all && (ap->ap_Info.fib_DirEntryType >= 0))
 818                     {
 819                         if ((dirnode = AllocMem(sizeof(struct DirNode), MEMF_ANY)))
 820                         {
 821                             if ((dirnode->dirname = StrDup(ap->ap_Buf)))
 822                             {
 823                                 Insert(&DirList, (struct Node *)dirnode,
 824                                        (struct Node *)prev_dirnode);
 825
 826                                 prev_dirnode = dirnode;
 827                             }
 828                             else
 829                             {
 830                                 FreeMem(dirnode, sizeof(struct DirNode));
 831                             }
 832                         }
 833                     }
 834                 }
 835
 836                 error = MatchNext(ap);
 837
 838                 first = FALSE;
 839
 840             } while (0 == error);
 841         }
 842
 843         MatchEnd(ap);
 844
 845         FreeVec(ap);
 846
 847         if (error == ERROR_BREAK)
 848         {
 849             PrintFault(error, NULL);
 850         }
 851
 852         if (error == ERROR_NO_MORE_ENTRIES)
 853         {
 854             error = 0;
 855         }
 856
 857         if ((error == 0) || (error == ERROR_BREAK))
 858         {
 859             BOOL printEmpty = !(ap->ap_Flags & APF_ITSWILD);
 860             printSummary(filename, files, dirs, nBlocks, noHead, printEmpty);
 861         }
 862
 863         /* Update global statistics for (possible) ALL option */
 864         stats->nFiles += files;
 865         stats->nDirs += dirs;
 866         stats->nBlocks += nBlocks;
 867
 868         files = 0;
 869         dirs = 0;
 870         nBlocks = 0;
 871
 872
 873         if (error) break;
 874
 875         dirnode = (struct DirNode *)RemHead(&DirList);
 876
 877         if (dirnode != NULL)
 878         {
 879             filename = dirnode->dirname;
 880
 881             prev_dirnode = NULL;
 882
 883             /* do not free() dirnode, as we reference dirnode->dirname! */
 884
 885             AddTail(&FreeDirNodeList, (struct Node *)dirnode);
 886         }
 887     } while (dirnode);
 888
 889     while ((dirnode = (struct DirNode *)RemHead(&FreeDirNodeList)))
 890     {
 891         FreeVec(dirnode->dirname);
 892         FreeMem(dirnode, sizeof(struct DirNode));
 893     }
 894
 895     return error;
 896 }
 897
 898
 899 int __nocommandline;
 900
 901 int main(void)
 902 {
 903     IPTR args[NOOFARGS] =
 904     {
 905         (IPTR) NULL,    // ARG_DIR
 906         (IPTR) NULL,    // ARG_PAT
 907                FALSE,   // ARG_KEYS
 908                FALSE,   // ARG_DATES
 909                FALSE,   // ARG_NODATES
 910         (IPTR) NULL,    // ARG_TO
 911         (IPTR) NULL,    // ARG_SUB
 912         (IPTR) NULL,    // ARG_SINCE
 913         (IPTR) NULL,    // ARG_UPTO
 914                FALSE,   // ARG_QUICK
 915                FALSE,   // ARG_BLOCK
 916                FALSE,   // ARG_NOHEAD
 917                FALSE,   // ARG_FILES
 918                FALSE,   // ARG_DIRS
 919                FALSE,   // ARG_LFORMAT
 920                FALSE    // ARG_ALL
 921     };
 922     static CONST_STRPTR default_directories[] = {(CONST_STRPTR)"", 0};
 923     struct RDArgs *rda;
 924
 925     LONG     result = RETURN_OK;
 926     LONG     error = 0;
 927     STRPTR   parsedPattern = NULL;
 928     STRPTR   subpatternStr = NULL;
 929     BPTR     oldOutput = BNULL;
 930
 931     Statistics stats = { 0, 0, 0 };
 932
 933     rda = ReadArgs(ARG_TEMPLATE, args, NULL);
 934
 935     if (rda != NULL)
 936     {
 937         CONST_STRPTR *directories = (CONST_STRPTR *)args[ARG_DIR];
 938         STRPTR  lFormat = (STRPTR)args[ARG_LFORMAT];
 939         STRPTR  pattern = (STRPTR)args[ARG_PAT];
 940         STRPTR  toFile = (STRPTR)args[ARG_TO];
 941         STRPTR  subStr = (STRPTR)args[ARG_SUB];
 942         STRPTR  since = (STRPTR)args[ARG_SINCE];
 943         STRPTR  upto = (STRPTR)args[ARG_UPTO];
 944         BOOL    files = (BOOL)args[ARG_FILES];
 945         BOOL    dirs  = (BOOL)args[ARG_DIRS];
 946         BOOL    noDates = (BOOL)args[ARG_NODATES];
 947         BOOL    dates = (BOOL)args[ARG_DATES];
 948         BOOL    quick = (BOOL)args[ARG_QUICK];
 949         BOOL    noHead = (BOOL)args[ARG_NOHEAD];
 950         BOOL    block = (BOOL)args[ARG_BLOCK];
 951         BOOL    all = (BOOL)args[ARG_ALL];
 952         BOOL    keys = (BOOL)args[ARG_KEYS];
 953
 954         struct DateTime  sinceDatetime;
 955         struct DateTime  uptoDatetime;
 956
 957         ULONG   i;              /* Loop variable */
 958
 959         if (since != NULL)
 960         {
 961             sinceDatetime.dat_StrDate = since;
 962             sinceDatetime.dat_StrTime = NULL;
 963             sinceDatetime.dat_Format = FORMAT_DEF;
 964             sinceDatetime.dat_Flags = 0;
 965             if (StrToDate(&sinceDatetime) == DOSFALSE)
 966             {
 967                 FreeArgs(rda);
 968                 Printf("*** Illegal 'SINCE' parameter\n");
 969
 970                 return RETURN_FAIL;
 971             }
 972             sinceDatetime.dat_Stamp.ds_Minute = 0;
 973             sinceDatetime.dat_Stamp.ds_Tick = 0;
 974         }
 975
 976         if (upto != NULL)
 977         {
 978             uptoDatetime.dat_StrDate = upto;
 979             uptoDatetime.dat_StrTime = NULL;
 980             uptoDatetime.dat_Format = FORMAT_DEF;
 981             uptoDatetime.dat_Flags = 0;
 982
 983             if (StrToDate(&uptoDatetime) == DOSFALSE)
 984             {
 985                 FreeArgs(rda);
 986                 Printf("*** Illegal 'UPTO' parameter\n");
 987
 988                 return RETURN_FAIL;
 989             }
 990             uptoDatetime.dat_Stamp.ds_Minute = 1439;
 991             uptoDatetime.dat_Stamp.ds_Tick = 2999;
 992         }
 993
 994         if (subStr != NULL)
 995         {
 996             STRPTR  subStrWithPat;
 997             ULONG   length = (strlen(subStr) + sizeof("#?#?"))*2 + 2;
 998
 999             subStrWithPat = AllocVec(length, MEMF_ANY);
1000
1001             if (subStrWithPat == NULL)
1002             {
1003                 error = IoErr();
1004                 FreeArgs(rda);
1005                 PrintFault(error, "List");
1006
1007                 return RETURN_FAIL;
1008             }
1009
1010             strcpy(subStrWithPat, "#?");
1011             strcat(subStrWithPat, subStr);
1012             strcat(subStrWithPat, "#?");
1013
1014             subpatternStr = AllocVec(length, MEMF_ANY);
1015
1016             if (subpatternStr == NULL ||
1017                 ParsePatternNoCase(subStrWithPat, subpatternStr, length) == -1)
1018             {
1019                 error = IoErr();
1020                 FreeVec(subStrWithPat);
1021                 FreeArgs(rda);
1022                 PrintFault(error, "List");
1023
1024                 return RETURN_FAIL;
1025             }
1026
1027             FreeVec(subStrWithPat);
1028         }
1029
1030
1031         if (pattern != NULL)
1032         {
1033             ULONG length = strlen(pattern)*2 + 2;
1034
1035             parsedPattern = AllocVec(length, MEMF_ANY);
1036
1037             if (parsedPattern == NULL ||
1038                 ParsePatternNoCase(pattern, parsedPattern, length) == -1)
1039             {
1040                 FreeVec(subpatternStr);
1041                 FreeArgs(rda);
1042
1043                 return RETURN_FAIL;
1044             }
1045         }
1046
1047         if (toFile != NULL)
1048         {
1049             BPTR file = Open(toFile, MODE_NEWFILE);
1050
1051             if (file == BNULL)
1052             {
1053                 error = IoErr();
1054                 FreeVec(subpatternStr);
1055                 FreeVec(parsedPattern);
1056                 FreeArgs(rda);
1057                 PrintFault(error, "List");
1058
1059                 return RETURN_FAIL;
1060             }
1061             oldOutput = SelectOutput(file);
1062         }
1063
1064         if (!files && !dirs)
1065         {
1066             files = TRUE;
1067             dirs = TRUE;
1068         }
1069
1070 /*      if (!dates && !noDates)
1071         {
1072             dates = TRUE;
1073         }*/
1074
1075         if (lFormat)
1076         {
1077             noHead = TRUE;
1078         }
1079
1080         if ((directories == NULL) || (*directories == NULL))
1081         {
1082             directories = default_directories;
1083         }
1084
1085         for (i = 0; directories[i] != NULL; i++)
1086         {
1087             error = listFile(directories[i], files, dirs, parsedPattern,
1088                              noHead, lFormat, quick, dates, noDates,
1089                              block, &sinceDatetime.dat_Stamp,
1090                              &uptoDatetime.dat_Stamp, since != NULL,
1091                              upto != NULL, subpatternStr, all, keys,
1092                              &stats);
1093
1094             if (error != 0)
1095             {
1096                 break;
1097             }
1098
1099 //          Printf("\n");
1100         }
1101
1102         FreeArgs(rda);
1103     }
1104     else
1105     {
1106         error = IoErr();
1107     }
1108
1109     if ((BOOL)args[ARG_NOHEAD] == FALSE &&
1110         (BOOL)args[ARG_LFORMAT] == FALSE &&
1111         (BOOL)args[ARG_ALL] &&
1112         (stats.nFiles || stats.nDirs))
1113     {
1114         Printf("\nTOTAL: %ld files - %ld directories - %ld blocks used\n",
1115                stats.nFiles, stats.nDirs, stats.nBlocks);
1116     }
1117
1118
1119     if (error != 0)
1120     {
1121         if (error == ERROR_BREAK)
1122         {
1123             result = RETURN_WARN;
1124         }
1125         else
1126         {
1127             PrintFault(error, "List");
1128             result = RETURN_FAIL;
1129         }
1130     }
1131
1132     if (parsedPattern != NULL)
1133     {
1134         FreeVec(parsedPattern);
1135     }
1136
1137     if (subpatternStr != NULL)
1138     {
1139         FreeVec(subpatternStr);
1140     }
1141
1142     if (oldOutput != BNULL)
1143     {
1144         Close(SelectOutput(oldOutput));
1145     }
1146
1147     return result;
1148 }