HuntnGather – Blame information for rev 27

Subversion Repositories:
Rev:
Rev Author Line No. Line
1 office 1 ///////////////////////////////////////////////////////////////////////////
2 // Copyright (C) 2021 Wizardry and Steamworks - License: MIT //
3 ///////////////////////////////////////////////////////////////////////////
4  
5 #include <stdio.h>
6 #include <stdlib.h>
7 #include <string.h>
8 #include <dirent.h>
27 office 9 #if !defined ___AmigaOS___
1 office 10 #include <signal.h>
27 office 11 #endif
1 office 12  
13 #include <sys/types.h>
14 #include <sys/stat.h>
19 office 15 #include <sys/syslimits.h>
1 office 16  
26 office 17 #if defined ___AmigaOS___
1 office 18 #include <proto/dos.h>
19 #include <proto/exec.h>
26 office 20 #include <proto/locale.h>
21 #endif
1 office 22  
22 office 23 #if defined ___AsyncIO___
24 #include <asyncio.h>
25 #endif
26  
1 office 27 #include "StringStack.h"
28  
5 office 29 #if !defined ___HAVE_GETOPT___
1 office 30 #include "getopt.h"
31 #endif
32  
26 office 33 #define PROGRAM_VERSION "1.7.4"
19 office 34  
5 office 35 #if defined ___AmigaOS___
36 /*************************************************************************/
37 /* Version string used for querrying the program version. */
38 /*************************************************************************/
39 TEXT version_string[] =
19 office 40 "\0$VER: Gather " PROGRAM_VERSION " "__DATE__" by Wizardry and Steamworks";
5 office 41 #endif
1 office 42  
43 #if !defined TRUE
44 #define TRUE 1;
45 #endif
46  
47 #if !defined FALSE
48 #define FALSE 0;
49 #endif
50  
22 office 51 #define ASYNC_BUF 8192
2 office 52 #define MAX_MEM 262144
11 office 53 #define LINE_BUF 256
2 office 54 #define DEFAULT_DATABASE_FILE "S:gather.db"
1 office 55  
56 typedef struct {
57 unsigned int dirs;
58 unsigned int files;
59 } stats;
60  
26 office 61 typedef struct {
62 char *name;
63 char *path;
64 } dbEntry;
1 office 65  
26 office 66 typedef struct {
67 char **database;
68 unsigned int count;
69 } dbArray;
70  
71 enum MODE {
72 NONE,
73 GATHER,
74 REMOVE,
75 CREATE
76 } operation;
77  
78 unsigned int run = TRUE;
79 unsigned int verbose = TRUE;
80 unsigned int maxmem = MAX_MEM;
81 // Define global locale for string compare.
82 #if defined ___AmigaOS___
83 struct Locale *locale;
84 #endif
85  
1 office 86 void SignalHandler(int sig) {
87 // Toggle the run flag to stop execution.
88 run = FALSE;
89 }
90  
26 office 91 /*
92 *
93 * Used for sorting database lines.
94 */
95 int QsortCompare(const void *a, const void *b) {
1 office 96 const char **p = (const char **)a;
97 const char **q = (const char **)b;
26 office 98 #if defined ___AmigaOS___
99 return StrnCmp(locale, (STRPTR)*p, (STRPTR)*q, -1, SC_ASCII);
100 #else
27 office 101 return strcmp(*p, *q);
26 office 102 #endif
1 office 103 }
104  
105 /*
106 *
26 office 107 * Gets the absolute path to file by name.
1 office 108 */
26 office 109 char *PathToAbsolute(char *path) {
110 char *abs;
111 #if defined ___AmigaOS___
112 BPTR lock;
113 #endif
114  
115 #if defined ___AmigaOS___
116 if((abs = malloc(PATH_MAX * sizeof(*abs))) == NULL) {
117 fprintf(stderr, "Memory allocation failure.\n");
118 return NULL;
119 }
120 if((lock = Lock(path, SHARED_LOCK)) == 0) {
121 fprintf(stderr, "Lock on %s failed.\n", path);
122 return NULL;
123 }
124 if(NameFromLock(lock, abs, PATH_MAX) == FALSE) {
125 fprintf(stderr, "Lock on %s failed.\n", path);
126 UnLock(lock);
127 return NULL;
128 }
129 UnLock(lock);
130 #else
131 abs = realpath(path, NULL);
132 #endif
133  
134 return abs;
135 }
136  
137 /*
138 *
139 * Compares path parts for equality.
140 */
141 #if defined ___AmigaOS___
142 BOOL PathCompare(char *path, char *look) {
143 #else
144 int PathCompare(char *path, char *look) {
145 #endif
146 char *a;
147 char *b;
148  
149 for(a = path, b = look; *a != '\0' && *b != '\0'; ++a, ++b) {
150 if(*b != '\0' && *a != *b) {
151 return FALSE;
152 }
153 }
154  
155 return *b == '\0';
156 }
157  
158 /*
159 *
160 * Gets the size of a file by name.
161 */
162 int GetFileSize(char *dbFile) {
22 office 163 #if defined ___AsyncIO___
164 struct AsyncFile *fp;
26 office 165 LONG size;
22 office 166 #else
1 office 167 FILE *fp;
26 office 168 int size;
22 office 169 #endif
1 office 170  
22 office 171 #if defined ___AsyncIO___
172 if((fp = OpenAsync(dbFile, MODE_READ, ASYNC_BUF)) == NULL) {
173 #else
1 office 174 if((fp = fopen(dbFile, "r")) == NULL) {
22 office 175 #endif
24 office 176 fprintf(stderr, "Unable to open '%s' for reading.\n", dbFile);
26 office 177 return -1;
1 office 178 }
179  
26 office 180 #if defined ___AsyncIO___
181 if(SeekAsync(fp, 0, MODE_END) == -1) {
182 #else
183 if(fseek(fp, 0L, SEEK_END) == 0) {
184 #endif
185 fprintf(stderr, "Seek in file %s failed.\n", dbFile);
186 #if defined ___AsyncIO___
187 CloseAsync(fp);
188 #else
189 fclose(fp);
190 #endif
191 return -1;
192 }
193 #if defined ___AsyncIO___
194 if((size = SeekAsync(fp, 0, MODE_CURRENT)) == -1) {
195 fprintf(stderr, "Seek in file %s failed.\n", dbFile);
196 CloseAsync(fp);
197 return -1;
198 }
199 #else
200 size = ftell(fp);
201 #endif
22 office 202  
26 office 203 #if defined ___AsyncIO___
204 CloseAsync(fp);
205 #else
206 fclose(fp);
207 #endif
1 office 208  
26 office 209 return size;
210 }
211  
212 /*
213 *
214 * Counts the lines of a file.
215 */
216 int CountFileLines(char *dbFile) {
217 #if defined ___AsyncIO___
218 struct AsyncFile *fp;
219 LONG c;
220 #else
221 FILE *fp;
222 char c;
223 #endif
224 int lines;
225  
226 #if defined ___AsyncIO___
227 if((fp = OpenAsync(dbFile, MODE_READ, ASYNC_BUF)) == NULL) {
228 #else
229 if((fp = fopen(dbFile, "r")) == NULL) {
230 #endif
231 fprintf(stderr, "Unable to open '%s' for reading.\n", dbFile);
232 return -1;
1 office 233 }
24 office 234  
26 office 235 lines = 0;
22 office 236 #if defined ___AsyncIO___
237 while(run && (c = ReadCharAsync(fp)) != -1) {
238 #else
1 office 239 while(run && fscanf(fp, "%c", &c) == 1) {
22 office 240 #endif
1 office 241 #if defined ___AmigaOS___
242 // Check if CTRL+C was pressed and abort the program.
26 office 243 if(SetSignal(0L, SIGBREAKF_CTRL_C) & SIGBREAKF_CTRL_C) {
1 office 244 run = FALSE;
245 continue;
246 }
247 #endif
248 switch(c) {
249 case '\n':
26 office 250 ++lines;
1 office 251 break;
252 }
253 }
254  
22 office 255 #if defined ___AsyncIO___
256 CloseAsync(fp);
257 #else
1 office 258 fclose(fp);
22 office 259 #endif
1 office 260  
26 office 261 return lines;
262 }
1 office 263  
26 office 264 /*
265 *
266 * Creates a temporary file and returns its name.
267 */
268 char *CreateTemporaryFile(void) {
269 char *name;
270  
271 name = tmpnam(NULL);
272  
273 return name;
274 }
275  
276 /*
277 *
278 * Create multiple temporary files and return their names.
279 */
280 char **CreateTemporaryFiles(int files) {
281 char **tmpNames;
282 int count;
283  
284 if((tmpNames = malloc(files * sizeof(*tmpNames))) == NULL) {
285 fprintf(stderr, "Memory allocation failure.\n");
286 return NULL;
287 }
288  
289 if(verbose) {
290 fprintf(stdout, "Creating temporary files...\r");
291 }
292  
293 count = files;
294 while(run && --count > -1) {
295 #if defined ___AmigaOS___
296 // Check if CTRL+C was pressed and abort the program.
297 if(SetSignal(0L, SIGBREAKF_CTRL_C) & SIGBREAKF_CTRL_C) {
298 run = FALSE;
299 continue;
300 }
301 #endif
302 tmpNames[count] = CreateTemporaryFile();
303  
304 if(verbose) {
305 fprintf(stdout, "Creating temporary files: %d%%\r", 100 - (int)(((float)count / files) * 100.0));
306 }
307 }
308  
309 if(verbose) {
310 fprintf(stdout, "\n");
311 }
312  
313 return tmpNames;
314 }
315  
316  
317 /*
318 *
319 * Skips a line in a file.
320 */
22 office 321 #if defined ___AsyncIO___
26 office 322 void SkipLine(struct AsyncFile *fp) {
323 LONG c;
324 while(run && (c = ReadCharAsync(fp)) != -1) {
22 office 325 #else
26 office 326 void SkipLine(FILE *fp) {
327 char c;
328 while(run && fscanf(fp, "%c", &c) == 1) {
22 office 329 #endif
23 office 330 #if defined ___AmigaOS___
331 // Check if CTRL+C was pressed and abort the program.
26 office 332 if(SetSignal(0L, SIGBREAKF_CTRL_C) & SIGBREAKF_CTRL_C) {
23 office 333 run = FALSE;
334 continue;
335 }
336 #endif
26 office 337 switch(c) {
338 case '\n':
339 return;
340 }
341 }
342 }
343  
344 /*
345 *
346 * Peeks at a line from a file.
347 */
22 office 348 #if defined ___AsyncIO___
26 office 349 char *PeekLine(struct AsyncFile *fp) {
350 LONG c;
22 office 351 #else
26 office 352 char *PeekLine(FILE *fp) {
353 char c;
22 office 354 #endif
26 office 355 char *line;
356 unsigned int size;
357 int i;
358  
359 size = LINE_BUF;
360 if((line = malloc(size * sizeof(*line))) == NULL) {
361 fprintf(stderr, "Memory allocation failure.\n");
362 return NULL;
1 office 363 }
364  
26 office 365 i = 0;
22 office 366 #if defined ___AsyncIO___
26 office 367 while(run && (c = ReadCharAsync(fp)) != -1) {
22 office 368 #else
26 office 369 while(run && fscanf(fp, "%c", &c) == 1) {
22 office 370 #endif
26 office 371 #if defined ___AmigaOS___
372 // Check if CTRL+C was pressed and abort the program.
373 if(SetSignal(0L, SIGBREAKF_CTRL_C) & SIGBREAKF_CTRL_C) {
374 run = FALSE;
375 continue;
376 }
377 #endif
378 switch(c) {
379 case '\n':
380 // Rewind the file by the number of read characters.
381 #if defined ___AsyncIO___
382 if(SeekAsync(fp, -(i + 1), MODE_CURRENT) == -1) {
383 fprintf(stderr, "Could not seek in file.\n");
384 free(line);
385 return NULL;
386 }
387 #else
388 fseek(fp, -(i + 1), SEEK_CUR);
389 #endif
390 return line;
391 default:
392 if(strlen(line) == size) {
393 size = size * 1.5;
394 line = realloc(line, size * sizeof(*line));
395 }
396 line[i] = c;
397 line[i + 1] = '\0';
398 break;
399 }
400 ++i;
401 }
22 office 402  
26 office 403 return NULL;
1 office 404 }
405  
406 /*
407 *
26 office 408 * Read a line from a file.
1 office 409 */
22 office 410 #if defined ___AsyncIO___
26 office 411 char *ReadLine(struct AsyncFile *fp) {
412 LONG c;
22 office 413 #else
26 office 414 char *ReadLine(FILE *fp) {
415 char c;
22 office 416 #endif
26 office 417 char *line;
1 office 418 unsigned int size;
26 office 419 unsigned int i;
1 office 420  
26 office 421 size = LINE_BUF;
422 if((line = malloc(size * sizeof(*line))) == NULL) {
423 fprintf(stderr, "Memory allication failure.\n");
424 return NULL;
425 }
426  
427 i = 0;
22 office 428 #if defined ___AsyncIO___
26 office 429 while(run && (c = ReadCharAsync(fp)) != -1) {
22 office 430 #else
26 office 431 while(run && fscanf(fp, "%c", &c) == 1) {
22 office 432 #endif
1 office 433 #if defined ___AmigaOS___
434 // Check if CTRL+C was pressed and abort the program.
435 if(SetSignal(0L, SIGBREAKF_CTRL_C) & SIGBREAKF_CTRL_C) {
436 run = FALSE;
23 office 437 continue;
1 office 438 }
439 #endif
26 office 440 switch(c) {
441 case '\n':
442 return line;
443 default:
444 if(strlen(line) == size) {
445 size = size * 1.5;
446 line = realloc(line, size * sizeof(*line));
447 }
448 line[i] = c;
449 line[i + 1] = '\0';
450 break;
1 office 451 }
26 office 452 ++i;
453 }
1 office 454  
26 office 455 return NULL;
456 }
1 office 457  
26 office 458 /*
459 *
460 * Delete a file.
461 */
1 office 462 #if defined ___AmigaOS___
26 office 463 BOOL RemoveFile(char *name) {
464 return DeleteFile(name);
465 #else
466 int RemoveFile(char *name) {
467 return remove(name) == 0;
1 office 468 #endif
26 office 469 }
1 office 470  
26 office 471 /*
472 *
473 * Deletes files.
474 */
475 void RemoveFiles(char **names, int count) {
476 unsigned int i;
477 for(i = 0; i < count; ++i) {
478 if(RemoveFile(names[i]) == FALSE) {
479 fprintf(stderr, "Unable to remove %s...\n", names[i]);
480 continue;
481 }
482 fprintf(stderr, "Removing file: %s\n", names[i]);
483 }
484 }
1 office 485  
26 office 486 /*
487 *
488 * Copies a file to another file by name.
489 */
490 void CopyFile(char *a, char *b) {
491 #if defined ___AsyncIO___
492 struct AsyncFile *ap;
493 struct AsyncFile *bp;
494 LONG c;
495 #else
496 FILE *ap;
497 FILE *bp;
498 char c;
499 #endif
1 office 500  
501  
26 office 502 // Open database file for writing.
503 #if defined ___AsyncIO___
504 if((ap = OpenAsync(a, MODE_READ, ASYNC_BUF)) == NULL) {
505 #else
506 if((ap = fopen(a, "r")) == NULL) {
507 #endif
508 fprintf(stderr, "Unable to open '%s' for reading.\n", a);
509 return;
510 }
15 office 511  
26 office 512 // Open temporary file for reading.
513 #if defined ___AsyncIO___
514 if((bp = OpenAsync(b, MODE_WRITE, ASYNC_BUF)) == NULL) {
515 #else
516 if((bp = fopen(b, "w+")) == NULL) {
15 office 517 #endif
26 office 518 fprintf(stderr, "Unable to open file '%s' for writing.\n", b);
15 office 519  
26 office 520 // Close database file.
22 office 521 #if defined ___AsyncIO___
26 office 522 CloseAsync(ap);
22 office 523 #else
26 office 524 fclose(ap);
22 office 525 #endif
1 office 526  
26 office 527 return;
1 office 528 }
529  
26 office 530 #if defined ___AsyncIO___
531 while(run && (c = ReadCharAsync(ap)) != -1) {
532 #else
533 while(run && fscanf(ap, "%c", &c) == 1) {
534 #endif
535 #if defined ___AmigaOS___
536 // Check if CTRL+C was pressed and abort the program.
537 if(SetSignal(0L, SIGBREAKF_CTRL_C) & SIGBREAKF_CTRL_C) {
538 run = FALSE;
539 continue;
540 }
541 #endif
542 #if defined ___AsyncIO___
543 if(WriteCharAsync(bp, (UBYTE)c) != 1) {
544 #else
545 if(fprintf(bp, "%c", c) != 1) {
546 #endif
547 fprintf(stderr, "Unable to write to '%s'.\n", b);
548 break;
549 }
1 office 550 }
551  
22 office 552 #if defined ___AsyncIO___
26 office 553 CloseAsync(ap);
554 CloseAsync(bp);
22 office 555 #else
26 office 556 fclose(ap);
557 fclose(bp);
22 office 558 #endif
1 office 559 }
560  
561 /*
562 *
26 office 563 * Write lines to a file.
1 office 564 */
26 office 565 void WriteLinesToFile(char *dbFile, char **lines, unsigned int count) {
23 office 566 #if defined ___AsyncIO___
567 struct AsyncFile *fp;
568 #else
1 office 569 FILE *fp;
23 office 570 #endif
26 office 571 int i;
572 char *rem;
1 office 573  
26 office 574 // Write the database lines back to the database.
23 office 575 #if defined ___AsyncIO___
26 office 576 if((fp = OpenAsync(dbFile, MODE_WRITE, ASYNC_BUF)) == NULL) {
23 office 577 #else
26 office 578 if((fp = fopen(dbFile, "w")) == NULL) {
23 office 579 #endif
26 office 580 fprintf(stderr, "Unable to open '%s' for writing.\n", dbFile);
581 return;
1 office 582 }
583  
26 office 584 rem = NULL;
585 for(i = 0; i < count; ++i) {
586 #if defined ___AmigaOS___
587 // Check if CTRL+C was pressed and abort the program.
588 if(SetSignal(0L, SIGBREAKF_CTRL_C) & SIGBREAKF_CTRL_C) {
589 run = FALSE;
590 continue;
591 }
592 #endif
593  
594 if(rem != NULL) {
595 #if defined ___AmigaOS___
596 if(StrnCmp(locale, lines[i], rem, -1, SC_ASCII) == 0) {
597 #else
27 office 598 if(strcmp(lines[i], rem) == 0) {
26 office 599 #endif
600 continue;
601 }
602 }
603  
23 office 604 #if defined ___AsyncIO___
26 office 605 WriteAsync(fp, lines[i], (LONG)strlen(lines[i]));
606 WriteAsync(fp, "\n", 1);
23 office 607 #else
26 office 608 fprintf(fp, "%s\n", lines[i]);
23 office 609 #endif
1 office 610  
26 office 611 if(rem != NULL) {
612 free(rem);
613 }
614  
615 rem = malloc(strlen(lines[i]) + 1);
616 sprintf(rem, "%s", lines[i]);
617 }
618  
23 office 619 #if defined ___AsyncIO___
26 office 620 CloseAsync(fp);
23 office 621 #else
1 office 622 fclose(fp);
23 office 623 #endif
26 office 624 }
23 office 625  
26 office 626 /*
627 *
628 * Create a database entry from a line of text.
629 */
630 dbEntry* CreateDataseEntry(char *line) {
631 dbEntry *entry;
632 char *ptr;
633 unsigned int side;
634 unsigned int i;
635 unsigned int j;
636  
637 if((entry = malloc(1 * sizeof(*entry))) == NULL) {
638 fprintf(stderr, "Memory allocation failure.\n");
639 return NULL;
640 }
641  
642 if((entry->name = malloc(strlen(line) * sizeof(*entry->name))) == NULL) {
643 fprintf(stderr, "Memory allocation failure.\n");
644 return NULL;
645 }
646  
647 if((entry->path = malloc(strlen(line) * sizeof(*entry->path))) == NULL) {
648 fprintf(stderr, "Memory allocation failure.\n");
649 return NULL;
650 }
651  
652 for(ptr = line, side = 0, i = 0, j = 0; run && *ptr != '\0'; ++ptr) {
653 #if defined ___AmigaOS___
654 // Check if CTRL+C was pressed and abort the program.
655 if(SetSignal(0L, SIGBREAKF_CTRL_C) & SIGBREAKF_CTRL_C) {
656 run = FALSE;
657 continue;
658 }
659 #endif
660 switch(*ptr) {
661 case '\t':
662 entry->name[i] = '\0';
663 ++side;
664 break;
665 case '\n':
666 entry->path[j] = '\0';
667 return entry;
668 default:
669 switch(side) {
670 case 0:
671 entry->name[i++] = *ptr;
672 break;
673 case 1:
674 entry->path[j++] = *ptr;
675 break;
676 }
677 break;
678 }
679 }
680  
681 return entry;
1 office 682 }
683  
684 /*
685 *
26 office 686 *
1 office 687 */
26 office 688 dbArray *GetDatabaseArray(char *dbFile) {
22 office 689 #if defined ___AsyncIO___
690 struct AsyncFile *fp;
691 #else
1 office 692 FILE *fp;
22 office 693 #endif
26 office 694 dbArray *array;
695 dbEntry *entry;
696 char *line;
697 unsigned int count;
1 office 698  
26 office 699 if((array = malloc(1 * sizeof(*array))) == NULL) {
700 fprintf(stderr, "Memory allocation failure.\n");
701 return NULL;
702 }
703  
704 // Open database file for reading.
22 office 705 #if defined ___AsyncIO___
706 if((fp = OpenAsync(dbFile, MODE_READ, ASYNC_BUF)) == NULL) {
707 #else
1 office 708 if((fp = fopen(dbFile, "r")) == NULL) {
22 office 709 #endif
24 office 710 fprintf(stderr, "Unable to open '%s' for reading.\n", dbFile);
26 office 711 return NULL;
1 office 712 }
713  
26 office 714 count = 0;
715 while(run && (line = ReadLine(fp)) != NULL) {
23 office 716 #if defined ___AmigaOS___
717 // Check if CTRL+C was pressed and abort the program.
26 office 718 if(SetSignal(0L, SIGBREAKF_CTRL_C) & SIGBREAKF_CTRL_C) {
23 office 719 run = FALSE;
720 continue;
721 }
722 #endif
26 office 723 if((entry = CreateDataseEntry(line)) == NULL) {
724 fprintf(stderr, "Unable to create database entry.\n");
725 #if defined ___AsyncIO___
726 CloseAsync(fp);
727 #else
728 fclose(fp);
729 #endif
730 return NULL;
1 office 731 }
26 office 732  
733 // Load up the name and path into the database variable.
734 array->database = realloc(array->database, (count + 1) * sizeof(*array->database));
735 if((array->database[count] = malloc((strlen(entry->name) + strlen(entry->path) + 1 + 1) * sizeof(*array->database[count]))) == NULL) {
736 fprintf(stderr, "Memory allocation failure.\n");
737 free(entry);
738 free(line);
739 #if defined ___AsyncIO___
740 CloseAsync(fp);
741 #else
742 fclose(fp);
743 #endif
744 return NULL;
745 }
746 sprintf(array->database[count], "%s\t%s", entry->name, entry->path);
747 ++count;
748  
749 free(entry);
750 free(line);
1 office 751 }
752  
22 office 753 #if defined ___AsyncIO___
754 CloseAsync(fp);
755 #else
1 office 756 fclose(fp);
22 office 757 #endif
1 office 758  
26 office 759 array->count = count;
760 return array;
1 office 761 }
762  
763 /*
764 *
26 office 765 * Sorts a database file lexicographically.
1 office 766 */
26 office 767 void SortDatabase(char *dbFile) {
768 dbArray *array;
1 office 769  
26 office 770 if(verbose) {
771 fprintf(stdout, "Sorting '%s'...\n", dbFile);
772 }
1 office 773  
26 office 774 // Retrieve the database as an array.
775 if((array = GetDatabaseArray(dbFile)) == NULL) {
776 fprintf(stderr, "Unable to read '%s' as a database file.\n", dbFile);
777 return;
778 }
779  
780 // Sort the database.
781 qsort(array->database, array->count, sizeof(char *), QsortCompare);
782  
783 // Write back the database to the database file.
784 WriteLinesToFile(dbFile, array->database, array->count);
785  
786 free(array);
787 }
788  
789 /*
790 *
791 * Updates a database file "dbFile".
792 */
793 stats *CollectFiles(char *dbFile, char **paths, unsigned int count) {
794 #if defined ___AsyncIO___
795 struct AsyncFile *fp;
796 #else
797 FILE *fp;
798 #endif
799 stringStack *stack;
800 stats *stats;
801 DIR *dir;
802 struct dirent *entry;
803 struct stat dirStat;
804 int i;
805 char *path;
806 char *subPath;
807  
808 // Initialize metrics.
809 if((stats = malloc(sizeof(stats))) == NULL) {
810 fprintf(stderr, "Memory allocation failure.\n");
811 return NULL;
812 }
813  
814 stats->dirs = 0;
815 stats->files = 0;
816  
817 #if defined ___AsyncIO___
818 if((fp = OpenAsync(dbFile, MODE_APPEND, ASYNC_BUF)) == NULL) {
819 #else
820 if((fp = fopen(dbFile, "r+")) == NULL) {
821 #endif
822 fprintf(stderr, "Unable to open '%s' for writing.\n", dbFile);
823 return stats;
824 }
825  
826 // Seek to the end of the database.
827 #if defined ___AsyncIO___
828 if(SeekAsync(fp, 0, MODE_END) == -1) {
829 #else
830 if(fseek(fp, 0, SEEK_END) == 0) {
831 #endif
832 fprintf(stderr, "Unable to seek in '%s' for appending.\n", dbFile);
833 #if defined ___AsyncIO___
834 CloseAsync(fp);
835 #else
836 fclose(fp);
837 #endif
838 return stats;
839 }
840  
1 office 841 if(verbose) {
26 office 842 fprintf(stdout, "Collecting files...\r");
1 office 843 }
844  
26 office 845 // Push the first path onto the stack.
846 stack = stringStackCreate(count);
847 for(i = 0; run && i < count; ++i) {
848 stringStackPush(stack, paths[i]);
849 }
850  
851 while(run && !stringStackIsEmpty(stack)) {
1 office 852 #if defined ___AmigaOS___
853 // Check if CTRL+C was pressed and abort the program.
854 if(SetSignal(0L, SIGBREAKF_CTRL_C) & SIGBREAKF_CTRL_C) {
855 run = FALSE;
23 office 856 continue;
1 office 857 }
858 #endif
26 office 859 if((path = stringStackPop(stack)) == NULL) {
860 break;
861 }
1 office 862  
26 office 863 if((dir = opendir(path)) == NULL) {
864 fprintf(stderr, "Unable to open '%s' for reading.\n", path);
865 break;
866 }
24 office 867  
26 office 868 while(run && (entry = readdir(dir)) != NULL) {
869 #if defined ___AmigaOS___
870 // Check if CTRL+C was pressed and abort the program.
871 if(SetSignal(0L, SIGBREAKF_CTRL_C) & SIGBREAKF_CTRL_C) {
872 run = FALSE;
873 continue;
874 }
875 #endif
876 switch(path[strlen(path) - 1]) {
877 case '/':
878 case ':': // This is a drive path.
27 office 879 if((subPath = malloc(sizeof(path) + sizeof(entry->d_name) + 1)) == NULL) {
26 office 880 fprintf(stderr, "Memory allocation failure.\n");
881 closedir(dir);
882 free(path);
883 stringStackDestroy(stack);
884 #if defined ___AsyncIO___
885 CloseAsync(fp);
886 #else
887 fclose(fp);
888 #endif
889 return NULL;
890 }
891 sprintf(subPath, "%s%s", path, entry->d_name);
892 break;
893 default:
27 office 894 if((subPath = malloc(sizeof(path) + sizeof(entry->d_name) + 1 + 1)) == NULL) {
26 office 895 fprintf(stderr, "Memory allocation failure.\n");
896 closedir(dir);
897 free(path);
898 stringStackDestroy(stack);
899 #if defined ___AsyncIO___
900 CloseAsync(fp);
901 #else
902 fclose(fp);
903 #endif
904 return NULL;
905 }
906 sprintf(subPath, "%s/%s", path, entry->d_name);
907 break;
908 }
909 stat(subPath, &dirStat);
910 if(S_ISDIR(dirStat.st_mode)) {
911 stringStackPush(stack, subPath);
912  
913 ++stats->dirs;
914  
915 if(verbose) {
916 fprintf(stdout,
917 "Gathered %d directories and %d files.\r",
918 stats->dirs,
919 stats->files);
920 }
921  
922 free(subPath);
923 continue;
924 }
925  
926 #if defined ___NOCASE_FS___
927 strupr(entry->d_name);
928 #endif
929 // Write to database file.
930 #if defined ___AsyncIO___
931 WriteAsync(fp, entry->d_name, (LONG)strlen(entry->d_name));
932 WriteAsync(fp, "\t", 1);
933 WriteAsync(fp, subPath, (LONG)strlen(subPath));
934 WriteAsync(fp, "\n", 1);
935 #else
936 fprintf(fp, "%s\t%s\n", entry->d_name, subPath);
937 #endif
938 ++stats->files;
939  
940 if(verbose) {
941 fprintf(stdout,
942 "Gathered %d directories and %d files.\r",
943 stats->dirs,
944 stats->files);
945 }
946  
947 free(subPath);
948 }
949  
950 closedir(dir);
951 free(path);
1 office 952 }
953  
954 if(verbose) {
955 fprintf(stdout, "\n");
956 }
957  
26 office 958 stringStackDestroy(stack);
959  
960 #if defined ___AsyncIO___
961 CloseAsync(fp);
962 #else
963 fclose(fp);
964 #endif
965  
966 return stats;
967  
1 office 968 }
969  
970 /*
971 *
972 * Writes lines from the database "dbFile" to temporary filenames "tmpNames".
973 */
23 office 974 void WriteTemporaryFiles(char *dbFile, char **tmpNames, int tmpFiles, int tmpLines, int total) {
22 office 975 #if defined ___AsyncIO___
976 struct AsyncFile *fp, *tp;
977 LONG c;
978 #else
1 office 979 FILE *fp, *tp;
980 char c;
22 office 981 #endif
1 office 982 int lines;
26 office 983 int write;
1 office 984  
22 office 985 #if defined ___AsyncIO___
986 if((fp = OpenAsync(dbFile, MODE_READ, ASYNC_BUF)) == NULL) {
987 #else
1 office 988 if((fp = fopen(dbFile, "r")) == NULL) {
22 office 989 #endif
24 office 990 fprintf(stderr, "Unable to open '%s' for reading.\n", dbFile);
1 office 991 return;
992 }
993  
22 office 994 #if defined ___AsyncIO___
23 office 995 if((tp = OpenAsync(tmpNames[--tmpFiles], MODE_WRITE, ASYNC_BUF)) == NULL) {
22 office 996 #else
23 office 997 if((tp = fopen(tmpNames[--tmpFiles], "w")) == NULL) {
22 office 998 #endif
24 office 999 fprintf(stderr, "Unable to open '%s' for writing.\n", tmpNames[tmpFiles]);
1000 #if defined ___AsyncIO___
1001 CloseAsync(fp);
1002 #else
1003 fclose(fp);
1004 #endif
1 office 1005 return;
1006 }
1007  
1008 if(verbose) {
24 office 1009 fprintf(stdout, "Writing to temporary files...\r");
1 office 1010 }
1011  
26 office 1012 write = 0;
1 office 1013 lines = 0;
22 office 1014 #if defined ___AsyncIO___
1015 while(run && (c = ReadCharAsync(fp)) != -1) {
1016 #else
1 office 1017 while(run && fscanf(fp, "%c", &c) == 1) {
22 office 1018 #endif
1 office 1019 #if defined ___AmigaOS___
1020 // Check if CTRL+C was pressed and abort the program.
1021 if(SetSignal(0L, SIGBREAKF_CTRL_C) & SIGBREAKF_CTRL_C) {
1022 run = FALSE;
23 office 1023 continue;
1 office 1024 }
1025 #endif
1026 switch(c) {
1027 case '\n':
1028 // Increment the total written lines.
26 office 1029 ++write;
1 office 1030  
1031 if(verbose) {
26 office 1032 fprintf(stdout, "Writing to temporary files: %d%%.\r", (int)(((float)write / total) * 100.0));
1 office 1033 }
1034  
1035 // Write the newline character back.
22 office 1036 #if defined ___AsyncIO___
1037 if(WriteCharAsync(tp, (UBYTE)c) != 1) {
1038 #else
1 office 1039 if(fprintf(tp, "%c", c) != 1) {
22 office 1040 #endif
24 office 1041 fprintf(stderr, "Unable to write to '%s'.\n", tmpNames[tmpFiles]);
22 office 1042 #if defined ___AsyncIO___
1043 CloseAsync(tp);
1044 CloseAsync(fp);
1045 #else
19 office 1046 fclose(tp);
1 office 1047 fclose(fp);
22 office 1048 #endif
1 office 1049 return;
1050 }
1051 // Switch to the next temporary file.
1052 if(++lines >= tmpLines) {
1053 // If there are no temporary files left then run till the end.
1054 if(tmpFiles - 1 < 0) {
1055 break;
1056 }
1057  
1058 // Close the previous temporary file and write to the next temporary file.
22 office 1059 #if defined ___AsyncIO___
1060 CloseAsync(tp);
23 office 1061 if((tp = OpenAsync(tmpNames[--tmpFiles], MODE_WRITE, ASYNC_BUF)) == NULL) {
22 office 1062 #else
1 office 1063 fclose(tp);
23 office 1064 if((tp = fopen(tmpNames[--tmpFiles], "w")) == NULL) {
22 office 1065 #endif
24 office 1066 fprintf(stderr, "Unable to open '%s' for writing.\n", tmpNames[tmpFiles]);
22 office 1067 #if defined ___AsyncIO___
1068 CloseAsync(fp);
1069 #else
1 office 1070 fclose(fp);
22 office 1071 #endif
24 office 1072 return;
1 office 1073 }
1074 lines = 0;
1075 break;
1076 }
1077 break;
1078 default:
22 office 1079 #if defined ___AsyncIO___
1080 if(WriteCharAsync(tp, (UBYTE)c) != 1) {
1081 #else
1 office 1082 if(fprintf(tp, "%c", c) != 1) {
22 office 1083 #endif
24 office 1084 fprintf(stderr, "Unable to write to '%s'.\n", tmpNames[tmpFiles]);
22 office 1085 #if defined ___AsyncIO___
1086 CloseAsync(tp);
1087 CloseAsync(fp);
1088 #else
1 office 1089 fclose(tp);
1090 fclose(fp);
22 office 1091 #endif
1 office 1092 return;
1093 }
1094 break;
1095 }
1096 }
1097  
24 office 1098 if(verbose) {
1099 fprintf(stdout, "\n");
1100 }
1 office 1101  
22 office 1102 #if defined ___AsyncIO___
1103 CloseAsync(tp);
1104 CloseAsync(fp);
1105 #else
1 office 1106 fclose(tp);
1107 fclose(fp);
22 office 1108 #endif
1 office 1109 }
1110  
1111 /*
1112 *
1113 * Merges temporary files "tmpNames" into a database "dbFile".
1114 */
24 office 1115 void MergeTemporaryFiles(char *dbFile, char **tmpNames, int files, int lines) {
22 office 1116 #if defined ___AsyncIO___
1117 struct AsyncFile *fp;
1118 struct AsyncFile **tp;
1119 #else
1 office 1120 FILE *fp;
1121 FILE **tp;
22 office 1122 #endif
1 office 1123 int i;
14 office 1124 int j;
1 office 1125 char *tmp;
26 office 1126 char *rem;
14 office 1127 char *min;
1 office 1128 int count;
1129  
22 office 1130 #if defined ___AsyncIO___
23 office 1131 if((fp = OpenAsync(dbFile, MODE_WRITE, ASYNC_BUF)) == NULL) {
22 office 1132 #else
23 office 1133 if((fp = fopen(dbFile, "w")) == NULL) {
22 office 1134 #endif
24 office 1135 fprintf(stderr, "Unable to open '%s' for writing.\n", dbFile);
1 office 1136 return;
1137 }
1138  
1139 // Allocate as many file pointers as temporary files.
26 office 1140 if((tp = malloc(files * sizeof(*tp))) == NULL) {
1141 fprintf(stderr, "Memory allocation failure.\n");
1142 #if defined ___AsyncIO___
1143 CloseAsync(fp);
1144 #else
1145 fclose(fp);
1146 #endif
1147 return;
1148 }
1 office 1149  
1150 // Open all temporary files for reading.
1151 for(i = 0; i < files; ++i) {
22 office 1152 #if defined ___AsyncIO___
1153 if((tp[i] = OpenAsync(tmpNames[i], MODE_READ, ASYNC_BUF)) == NULL) {
1154 #else
1 office 1155 if((tp[i] = fopen(tmpNames[i], "r")) == NULL) {
22 office 1156 #endif
24 office 1157 fprintf(stderr, "Unable to open '%s' for reading.\n", tmpNames[i]);
1 office 1158 // Close all temporary files.
24 office 1159 while(--i > -1) {
22 office 1160 #if defined ___AsyncIO___
1161 CloseAsync(tp[i]);
1162 #else
1 office 1163 fclose(tp[i]);
22 office 1164 #endif
1 office 1165 }
24 office 1166 #if defined ___AsyncIO___
1167 CloseAsync(fp);
1168 #else
1169 fclose(fp);
1170 #endif
1 office 1171 return;
1172 }
1173 }
1174  
1175 if(verbose) {
24 office 1176 fprintf(stdout, "Merging all files...\r");
1 office 1177 }
1178  
26 office 1179 rem = NULL;
1 office 1180 count = lines;
14 office 1181 j = 0;
1 office 1182 while(run && --count > -1) {
1183 #if defined ___AmigaOS___
1184 // Check if CTRL+C was pressed and abort the program.
1185 if(SetSignal(0L, SIGBREAKF_CTRL_C) & SIGBREAKF_CTRL_C) {
1186 run = FALSE;
23 office 1187 continue;
1 office 1188 }
1189 #endif
1190 // Find the smallest line in all temporary files.
1191 if(verbose) {
24 office 1192 fprintf(stdout, "Merging all files: %d%%.\r", 100 - (int)(((float)count / lines) * 100.0));
1 office 1193 }
1194  
14 office 1195 min = NULL;
1 office 1196 for(i = 0; i < files; ++i) {
26 office 1197 tmp = PeekLine(tp[i]);
1 office 1198 if(tmp == NULL) {
1199 continue;
1200 }
26 office 1201 #if defined ___AmigaOS___
1202 if(min == NULL || StrnCmp(locale, tmp, min, -1, SC_ASCII) < 0) {
1203 #else
27 office 1204 if(min == NULL || strcmp(tmp, min) < 0) {
26 office 1205 #endif
14 office 1206 if(min != NULL) {
2 office 1207 // Free previous instance.
14 office 1208 free(min);
2 office 1209 }
26 office 1210 if((min = malloc((strlen(tmp) + 1) * sizeof(*min))) == NULL) {
1211 fprintf(stderr, "Memory allication failure.\n");
1212 free(tmp);
1213 if(min != NULL) {
1214 free(min);
1215 }
1216 if(rem != NULL) {
1217 free(rem);
1218 }
1219 #if defined ___AsyncIO___
1220 CloseAsync(fp);
1221 #else
1222 fclose(fp);
1223 #endif
1224 return;
1225 }
14 office 1226 sprintf(min, "%s", tmp);
1 office 1227 // Remember the index of the file where the smallest entry has been found.
14 office 1228 j = i;
1 office 1229 }
1230 free(tmp);
1231 }
1232  
1233 // Forward the file where the smallest line was found.
23 office 1234 SkipLine(tp[j]);
1 office 1235  
1236 // Write the smallest line.
14 office 1237 if(min != NULL) {
26 office 1238 // If current minimum line is identical to previous minimum line then skip to remove duplicates.
1239 if(rem != NULL) {
1240 #if defined ___AmigaOS___
1241 if(StrnCmp(locale, min, rem, -1, SC_ASCII) == 0) {
1242 #else
27 office 1243 if(strcmp(min, rem) == 0 {
26 office 1244 #endif
1245 free(min);
1246 continue;
1247 }
1248 }
1249  
22 office 1250 #if defined ___AsyncIO___
26 office 1251 WriteAsync(fp, min, (LONG)strlen(min));
1252 WriteAsync(fp, "\n", 1);
22 office 1253 #else
14 office 1254 fprintf(fp, "%s\n", min);
22 office 1255 #endif
26 office 1256  
1257 if(rem != NULL) {
1258 free(rem);
1259 }
1260  
1261 if((rem = malloc((strlen(min) + 1) * sizeof(*rem))) == NULL) {
1262 fprintf(stderr, "Memory allocation failure.\n");
1263 free(min);
1264 #if defined ___AsyncIO___
1265 CloseAsync(fp);
1266 #else
1267 fclose(fp);
1268 #endif
1269 return;
1270 }
1271  
1272 sprintf(rem, "%s", min);
14 office 1273 free(min);
1 office 1274 }
1275 }
1276  
26 office 1277 if(rem != NULL) {
1278 free(rem);
1279 }
1280  
1 office 1281 // Write out any remaining contents from the temporary files.
24 office 1282 for(i = 0; run && i < files; ++i) {
1283 #if defined ___AmigaOS___
1284 // Check if CTRL+C was pressed and abort the program.
1285 if(SetSignal(0L, SIGBREAKF_CTRL_C) & SIGBREAKF_CTRL_C) {
1286 run = FALSE;
1287 continue;
1288 }
1289 #endif
23 office 1290 tmp = ReadLine(tp[i]);
1 office 1291 if(tmp == NULL) {
1292 continue;
1293 }
22 office 1294 #if defined ___AsyncIO___
26 office 1295 WriteAsync(fp, tmp, (LONG)strlen(tmp));
1296 WriteAsync(fp, "\n", 1);
22 office 1297 #else
1 office 1298 fprintf(fp, "%s\n", tmp);
22 office 1299 #endif
14 office 1300 free(tmp);
1 office 1301 }
1302  
24 office 1303 // Close all temporary files.
1 office 1304 for(i = 0; i < files; ++i) {
22 office 1305 #if defined ___AsyncIO___
1306 CloseAsync(tp[i]);
1307 #else
1 office 1308 fclose(tp[i]);
22 office 1309 #endif
1 office 1310 }
1311  
1312 if(verbose) {
1313 fprintf(stdout, "\n");
1314 }
1315  
22 office 1316 #if defined ___AsyncIO___
1317 CloseAsync(fp);
1318 #else
1 office 1319 fclose(fp);
22 office 1320 #endif
1 office 1321 }
1322  
1323 /*
26 office 1324 *
1325 * Filter the paths inside the database with provided paths.
1326 */
1327 void FilterDatabasePaths(char *dbFile, char *tmpName, char **paths, unsigned int count) {
1328 #if defined ___AsyncIO___
1329 struct AsyncFile *fp;
1330 struct AsyncFile *tp;
1331 #else
1332 FILE *fp;
1333 FILE *tp;
1334 #endif
1335 char *line;
1336 int i;
1337 dbEntry *entry;
24 office 1338  
26 office 1339 // Open database file for reading.
1340 #if defined ___AsyncIO___
1341 if((fp = OpenAsync(dbFile, MODE_READ, ASYNC_BUF)) == NULL) {
1342 #else
1343 if((fp = fopen(dbFile, "r")) == NULL) {
1344 #endif
1345 fprintf(stderr, "Unable to open '%s' for reading.\n", dbFile);
1346 return;
24 office 1347 }
1348  
26 office 1349 // Open temporary file for writing.
1350 #if defined ___AsyncIO___
1351 if((tp = OpenAsync(tmpName, MODE_WRITE, ASYNC_BUF)) == NULL) {
1352 #else
1353 if((tp = fopen(tmpName, "w")) == NULL) {
1354 #endif
1355 fprintf(stderr, "Unable to open '%s' for writing.\n", tmpName);
24 office 1356  
26 office 1357 // Close database file.
1358 #if defined ___AsyncIO___
1359 CloseAsync(fp);
1360 #else
1361 fclose(fp);
1362 #endif
1363  
1364 return;
24 office 1365 }
26 office 1366  
1367 while(run && (line = ReadLine(fp)) != NULL) {
1368 #if defined ___AmigaOS___
1369 // Check if CTRL+C was pressed and abort the program.
1370 if(SetSignal(0L, SIGBREAKF_CTRL_C) & SIGBREAKF_CTRL_C) {
1371 run = FALSE;
1372 continue;
1373 }
1374 #endif
1375 if((entry = CreateDataseEntry(line)) == NULL) {
1376 fprintf(stderr, "Unable to create database entry.\n");
1377 continue;
1378 }
1379 for(i = 0; i < count; ++i) {
1380 if(PathCompare(entry->path, paths[i]) == TRUE) {
1381 continue;
1382 }
1383 #if defined ___AsyncIO___
1384 WriteAsync(tp, line, (LONG)strlen(line));
1385 WriteAsync(tp, "\n", 1);
1386 #else
1387 fprintf(tp, "%s\n", line);
1388 #endif
1389 break;
1390 }
1391  
1392 free(entry);
1393 free(line);
1394 }
1395  
1396  
1397 #if defined ___AsyncIO___
1398 CloseAsync(fp);
1399 CloseAsync(tp);
1400 #else
1401 fclose(fp);
1402 fclose(tp);
1403 #endif
24 office 1404 }
1405  
1406 /*
1407 *
1 office 1408 * Indexes a "path" by creating a database "dbFile".
1409 */
26 office 1410 void GatherDatabaseFiles(char *dbFile, char **paths, unsigned int count) {
1411 stats *stats;
1 office 1412 char **tmpNames;
26 office 1413 int dbSize;
1414 int dbLines;
1415 int tmpFiles;
1416 int tmpLines;
1 office 1417 int i;
1418  
26 office 1419 // Generate the database file from the supplied paths.
1420 if((stats = CollectFiles(dbFile, paths, count)) == NULL) {
1421 fprintf(stderr, "Collecting files failed.\n");
1422 return;
1423 }
1424 free(stats);
1 office 1425  
26 office 1426 // Compute the amount of temporary files needed.
23 office 1427 dbSize = GetFileSize(dbFile);
26 office 1428 if(dbSize == -1) {
1429 fprintf(stderr, "File size for '%s' failed.\n", dbFile);
1430 return;
1431 }
1432 tmpFiles = dbSize / maxmem;
1 office 1433  
26 office 1434 /* In case no temporary files are required,
1435 * just sort the database and terminate.
1436 */
2 office 1437 if(tmpFiles <= 1) {
1 office 1438 SortDatabase(dbFile);
1439 return;
1440 }
1441  
26 office 1442 // Get the database metrics.
1443 dbLines = CountFileLines(dbFile);
1444 if(dbLines == -1) {
1445 fprintf(stderr, "Counting lines of '%s' failed.\n", dbFile);
1446 }
1 office 1447 tmpLines = dbLines / tmpFiles;
1448  
1449 // Create temporary files.
23 office 1450 if((tmpNames = CreateTemporaryFiles(tmpFiles)) == NULL) {
1 office 1451 fprintf(stderr, "Unable to create temporary files.\n");
1452 return;
1453 }
1454  
24 office 1455 // Write "tmpLines" to temporary files in "tmpNames" from "dbFile".
23 office 1456 WriteTemporaryFiles(dbFile, tmpNames, tmpFiles, tmpLines, dbLines);
1 office 1457  
1458 // Sort the temporary files.
24 office 1459 for(i = 0; run && i < tmpFiles; ++i) {
1 office 1460 SortDatabase(tmpNames[i]);
1461 }
1462  
24 office 1463 // Merge all the temporary files to the database file.
1464 MergeTemporaryFiles(dbFile, tmpNames, tmpFiles, dbLines);
1465  
1466 // Remove all temporary files.
26 office 1467 RemoveFiles(tmpNames, tmpFiles);
1468  
1469 free(tmpNames);
1 office 1470 }
1471  
26 office 1472 void RemoveDatabaseFiles(char *dbFile, char **paths, unsigned int count) {
1473 char *tmpName;
1474  
1475 // Create a temporary file to hold the changes.
1476 if((tmpName = CreateTemporaryFile()) == NULL) {
1477 fprintf(stderr, "Unable to create temporary file.\n");
1478 return;
1479 }
1480  
1481 // Filter the database of the provided paths.
1482 FilterDatabasePaths(dbFile, tmpName, paths, count);
1483  
1484 // Overwrite the database file with the filtered paths.
1485 CopyFile(tmpName, dbFile);
1486  
1487 // Remove temporary file.
1488 RemoveFile(tmpName);
1489 }
1490  
11 office 1491 void usage(char *name) {
1492 fprintf(stdout, "Hunt & Gather - %s, a file index generating tool. \n", name);
19 office 1493 fprintf(stdout, "Version: %s \n", PROGRAM_VERSION);
11 office 1494 fprintf(stdout, " \n");
26 office 1495 fprintf(stdout, "SYNTAX: %s [-q] <-a|-r|-c> <PATH PATH PATH...> \n", name);
1496 fprintf(stdout, " \n");
1497 fprintf(stdout, "Required: \n");
27 office 1498 fprintf(stdout, " -a [PATH...] Add files. \n");
1499 fprintf(stdout, " -c [PATH...] Create from scratch. \n");
26 office 1500 fprintf(stdout, " -r [PATH...] Remove files. \n");
1501 fprintf(stdout, " \n");
1502 fprintf(stdout, "Optional: \n");
1503 fprintf(stdout, " -d [FIILE] Where to store the database. \n");
1504 fprintf(stdout, " -m BYTES Memory to use (default: %d). \n", maxmem);
11 office 1505 fprintf(stdout, " -q Do not print out any messages. \n");
26 office 1506 fprintf(stdout, " \n");
11 office 1507 fprintf(stdout, "DATABASE is a path to where the indexed results will be \n");
1508 fprintf(stdout, "stored for searching with the Hunt tool. \n");
1509 fprintf(stdout, " \n");
1510 fprintf(stdout, "(c) 2021 Wizardry and Steamworks, MIT. \n");
1511 }
1512  
1 office 1513 /*
1514 *
1515 * Main entry point.
1516 */
1517 int main(int argc, char **argv) {
1518 int option;
26 office 1519 unsigned int i;
1520 unsigned int count;
2 office 1521 char *dbFile;
19 office 1522 char *path;
26 office 1523 char **paths;
10 office 1524 struct stat dirStat;
1 office 1525  
1526 // Bind handler to SIGINT.
26 office 1527 #if !defined ___AmigaOS___
1 office 1528 signal(SIGINT, SignalHandler);
26 office 1529 #endif
1 office 1530  
2 office 1531 dbFile = DEFAULT_DATABASE_FILE;
26 office 1532 while((option = getopt(argc, argv, "hqdm:arc")) != -1) {
1 office 1533 switch(option) {
26 office 1534 case 'a':
1535 operation = GATHER;
1536 break;
1537 case 'r':
1538 operation = REMOVE;
1539 break;
1540 case 'c':
1541 operation = CREATE;
1542 break;
1543 case 'm':
1544 maxmem = strtoul(optarg, NULL, 10);
1545 break;
2 office 1546 case 'd':
1547 dbFile = optarg;
1548 break;
1 office 1549 case 'q':
1550 verbose = FALSE;
1551 break;
1552 case 'h':
11 office 1553 usage(argv[0]);
2 office 1554 return 0;
1 office 1555 case '?':
1556 fprintf(stderr, "Invalid option %ct.\n", optopt);
1557 return 1;
1558 }
1559 }
1560  
26 office 1561 if(operation == NONE) {
1562 usage(argv[0]);
1563 return 1;
1564 }
10 office 1565  
1566 if(optind >= argc) {
11 office 1567 usage(argv[0]);
1 office 1568 return 1;
1569 }
1570  
26 office 1571 // Go through all supplied arguments and add paths to search.
1572 if((paths = malloc((argc - optind) * sizeof(*paths))) == NULL) {
1573 fprintf(stderr, "Memory allocation failure.\n");
1 office 1574 return 1;
1575 }
26 office 1576 for(i = optind, count = 0; i < argc; ++i, ++count) {
1577 if((path = PathToAbsolute(argv[optind])) == NULL) {
1578 fprintf(stderr, "Absolute path for '%s' failed to resolve.\n", argv[optind]);
1579 continue;
1580 }
1 office 1581  
26 office 1582 // Check that the path is a directory.
1583 stat(path, &dirStat);
1584 if(!S_ISDIR(dirStat.st_mode)) {
1585 fprintf(stderr, "Path '%s' is not a directory.\n", argv[optind]);
1586 free(path);
1587 return 1;
1588 }
1589  
1590 if(verbose) {
1591 fprintf(stdout, "Will process path: '%s'\n", path);
1592 }
1593  
1594 // Add the path to the array of paths.
1595 if((paths[count] = malloc(strlen(path) * sizeof(*paths[count]))) == NULL) {
1596 fprintf(stderr, "Memory allocation failure.");
1597 return 1;
1598 }
1599 sprintf(paths[count], "%s", path);
1600 free(path);
1601 }
1602  
2 office 1603 if(verbose) {
26 office 1604 fprintf(stdout, "Gathering to: '%s'\n", dbFile);
2 office 1605 }
1606  
26 office 1607 #if defined ___AmigaOS___
1608 locale = OpenLocale(NULL);
1609 #endif
1610  
1 office 1611 // Gather.
26 office 1612 switch(operation) {
1613 case CREATE:
1614 if(verbose) {
1615 fprintf(stdout, "Removing '%s' and creating a new database.\n", dbFile);
1616 }
1617 RemoveFile(dbFile);
1618 case GATHER:
1619 if(verbose) {
1620 fprintf(stdout, "Gathering files to database...\n");
1621 }
1622 GatherDatabaseFiles(dbFile, paths, count);
1623 break;
1624 case REMOVE:
1625 if(verbose) {
1626 fprintf(stdout, "Removing files from database...\n");
1627 }
1628 RemoveDatabaseFiles(dbFile, paths, count);
1629 break;
1630 default:
1631 break;
1632 }
1 office 1633  
26 office 1634 #if defined ___AmigaOS___
1635 CloseLocale(locale);
1636 #endif
19 office 1637  
26 office 1638 free(paths);
1639  
1640 return 0;
1 office 1641 }