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