HuntnGather – Blame information for rev 29

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>
29 office 8 #if !defined ___AmigaOS___
1 office 9 #include <dirent.h>
29 office 10 #include <sys/stat.h>
1 office 11 #include <signal.h>
27 office 12 #endif
1 office 13  
14 #include <sys/types.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
28 office 799 #if defined ___AmigaOS___
800 struct FileInfoBlock *FIBp, *FIBq;
801 BPTR lockp, lockq;
802 #else
26 office 803 DIR *dir;
804 struct dirent *entry;
29 office 805 struct stat dirStat;
28 office 806 #endif
807 stringStack *stack;
808 stats *stats;
26 office 809 int i;
810 char *path;
28 office 811 char *sub;
26 office 812  
813 // Initialize metrics.
814 if((stats = malloc(sizeof(stats))) == NULL) {
815 fprintf(stderr, "Memory allocation failure.\n");
816 return NULL;
817 }
818  
819 stats->dirs = 0;
820 stats->files = 0;
821  
822 #if defined ___AsyncIO___
823 if((fp = OpenAsync(dbFile, MODE_APPEND, ASYNC_BUF)) == NULL) {
824 #else
825 if((fp = fopen(dbFile, "r+")) == NULL) {
826 #endif
827 fprintf(stderr, "Unable to open '%s' for writing.\n", dbFile);
828 return stats;
829 }
830  
831 // Seek to the end of the database.
832 #if defined ___AsyncIO___
833 if(SeekAsync(fp, 0, MODE_END) == -1) {
834 #else
835 if(fseek(fp, 0, SEEK_END) == 0) {
836 #endif
837 fprintf(stderr, "Unable to seek in '%s' for appending.\n", dbFile);
838 #if defined ___AsyncIO___
839 CloseAsync(fp);
840 #else
841 fclose(fp);
842 #endif
843 return stats;
844 }
845  
1 office 846 if(verbose) {
26 office 847 fprintf(stdout, "Collecting files...\r");
1 office 848 }
849  
26 office 850 // Push the first path onto the stack.
851 stack = stringStackCreate(count);
852 for(i = 0; run && i < count; ++i) {
853 stringStackPush(stack, paths[i]);
854 }
855  
856 while(run && !stringStackIsEmpty(stack)) {
1 office 857 #if defined ___AmigaOS___
858 // Check if CTRL+C was pressed and abort the program.
859 if(SetSignal(0L, SIGBREAKF_CTRL_C) & SIGBREAKF_CTRL_C) {
860 run = FALSE;
23 office 861 continue;
1 office 862 }
863 #endif
26 office 864 if((path = stringStackPop(stack)) == NULL) {
865 break;
866 }
1 office 867  
28 office 868 #if defined ___AmigaOS___
869 if((lockp = Lock(path, ACCESS_READ)) == NULL) {
870 fprintf(stderr, "Could not lock path '%s' for reading.\n", path);
871 free(path);
872 continue;
26 office 873 }
24 office 874  
28 office 875 if((FIBp = (struct FileInfoBlock *) AllocDosObject(DOS_FIB, NULL)) == NULL) {
876 fprintf(stderr, "Path '%s' info block allocation failure.\n", path);
877 UnLock(lockp);
878 free(path);
879 continue;
880 }
881  
882 if(Examine(lockp, FIBp) == FALSE) {
883 fprintf(stderr, "Path '%s' could not be examined.\n", path);
884 FreeDosObject(DOS_FIB, FIBp);
885 UnLock(lockp);
886 free(path);
887 continue;
888 }
889  
890 while(run && ExNext(lockp, FIBp)) {
26 office 891 // Check if CTRL+C was pressed and abort the program.
892 if(SetSignal(0L, SIGBREAKF_CTRL_C) & SIGBREAKF_CTRL_C) {
893 run = FALSE;
894 continue;
895 }
28 office 896 #else
897  
898 if((dir = opendir(path)) == NULL) {
899 fprintf(stderr, "Unable to open '%s' for reading.\n", path);
900 free(path);
901 continue;
902 }
903  
904 while(run && (entry = readdir(dir)) != NULL) {
26 office 905 #endif
906 switch(path[strlen(path) - 1]) {
907 case '/':
908 case ':': // This is a drive path.
28 office 909 #if defined ___AmigaOS___
910 if((sub = malloc(sizeof(path) + sizeof(FIBp->fib_FileName) + 1)) == NULL) {
911 #else
912 if((sub = malloc(sizeof(path) + sizeof(entry->d_name) + 1)) == NULL) {
913 #endif
26 office 914 fprintf(stderr, "Memory allocation failure.\n");
28 office 915 #if defined ___AmigaOS___
916 FreeDosObject(DOS_FIB, FIBp);
917 UnLock(lockp);
918 #else
26 office 919 closedir(dir);
28 office 920 #endif
26 office 921 free(path);
922 stringStackDestroy(stack);
923 #if defined ___AsyncIO___
924 CloseAsync(fp);
925 #else
926 fclose(fp);
927 #endif
928 return NULL;
929 }
28 office 930 #if defined ___AmigaOS___
931 sprintf(sub, "%s%s", path, FIBp->fib_FileName);
932 #else
933 sprintf(sub, "%s%s", path, entry->d_name);
934 #endif
26 office 935 break;
936 default:
28 office 937 #if defined ___AmigaOS___
938 if((sub = malloc(sizeof(path) + sizeof(FIBp->fib_FileName) + 1 + 1)) == NULL) {
939 #else
940 if((sub = malloc(sizeof(path) + sizeof(entry->d_name) + 1 + 1)) == NULL) {
941 #endif
26 office 942 fprintf(stderr, "Memory allocation failure.\n");
28 office 943 #if defined ___AmigaOS___
944 FreeDosObject(DOS_FIB, FIBp);
945 UnLock(lockp);
946 #else
26 office 947 closedir(dir);
28 office 948 #endif
26 office 949 free(path);
950 stringStackDestroy(stack);
951 #if defined ___AsyncIO___
952 CloseAsync(fp);
953 #else
954 fclose(fp);
955 #endif
956 return NULL;
957 }
28 office 958 #if defined ___AmigaOS___
959 sprintf(sub, "%s/%s", path, FIBp->fib_FileName);
960 #else
961 sprintf(sub, "%s/%s", path, entry->d_name);
962 #endif
26 office 963 break;
964 }
28 office 965  
966 #if defined ___AmigaOS___
967 if((lockq = Lock(sub, ACCESS_READ)) == NULL) {
968 fprintf(stderr, "Could not lock path '%s' for reading.\n", sub);
969 free(sub);
970 continue;
971 }
972  
973 if((FIBq = (struct FileInfoBlock *) AllocDosObject(DOS_FIB, NULL)) == NULL) {
974 fprintf(stderr, "Path '%s' info block allocation failure.\n", sub);
975 UnLock(lockq);
976 free(sub);
977 continue;
978 }
979  
980 if(Examine(lockq, FIBq) == FALSE) {
981 fprintf(stderr, "Path '%s' could not be examined.\n", sub);
982 FreeDosObject(DOS_FIB, FIBq);
983 UnLock(lockq);
984 free(sub);
985 continue;
986 }
987  
988 if(FIBq->fib_DirEntryType > 0) {
989 #else
990 stat(sub, &dirStat);
26 office 991 if(S_ISDIR(dirStat.st_mode)) {
28 office 992 #endif
993 stringStackPush(stack, sub);
26 office 994  
995 ++stats->dirs;
996  
997 if(verbose) {
998 fprintf(stdout,
999 "Gathered %d directories and %d files.\r",
1000 stats->dirs,
1001 stats->files);
1002 }
1003  
28 office 1004 #if defined ___AmigaOS___
1005 FreeDosObject(DOS_FIB, FIBq);
1006 UnLock(lockq);
1007 #endif
1008 free(sub);
26 office 1009 continue;
1010 }
1011  
28 office 1012 #if defined ___AmigaOS___
1013 FreeDosObject(DOS_FIB, FIBq);
1014 UnLock(lockq);
1015 #endif
1016  
26 office 1017 #if defined ___NOCASE_FS___
28 office 1018 #if defined ___AmigaOS___
1019 strupr(FIBp->fib_FileName);
1020 #else
26 office 1021 strupr(entry->d_name);
1022 #endif
28 office 1023 #endif
26 office 1024 // Write to database file.
1025 #if defined ___AsyncIO___
28 office 1026 #if defined ___AmigaOS___
1027 WriteAsync(fp, FIBp->fib_FileName, (LONG)strlen(FIBp->fib_FileName));
1028 #else
26 office 1029 WriteAsync(fp, entry->d_name, (LONG)strlen(entry->d_name));
28 office 1030 #endif
26 office 1031 WriteAsync(fp, "\t", 1);
28 office 1032 WriteAsync(fp, sub, (LONG)strlen(sub));
26 office 1033 WriteAsync(fp, "\n", 1);
1034 #else
28 office 1035 #if defined ___AmigaOS___
1036 fprintf(fp, "%s\t%s\n", FIBp->fib_FileName, sub);
1037 #else
1038 fprintf(fp, "%s\t%s\n", entry->d_name, sub);
26 office 1039 #endif
28 office 1040 #endif
26 office 1041 ++stats->files;
1042  
1043 if(verbose) {
1044 fprintf(stdout,
1045 "Gathered %d directories and %d files.\r",
1046 stats->dirs,
1047 stats->files);
1048 }
1049  
28 office 1050 free(sub);
26 office 1051 }
1052  
28 office 1053 #if defined ___AmigaOS___
1054 FreeDosObject(DOS_FIB, FIBp);
1055 UnLock(lockp);
1056 #else
26 office 1057 closedir(dir);
28 office 1058 #endif
26 office 1059 free(path);
1 office 1060 }
1061  
1062 if(verbose) {
1063 fprintf(stdout, "\n");
1064 }
1065  
26 office 1066 stringStackDestroy(stack);
1067  
1068 #if defined ___AsyncIO___
1069 CloseAsync(fp);
1070 #else
1071 fclose(fp);
1072 #endif
1073  
1074 return stats;
1075  
1 office 1076 }
1077  
1078 /*
1079 *
1080 * Writes lines from the database "dbFile" to temporary filenames "tmpNames".
1081 */
23 office 1082 void WriteTemporaryFiles(char *dbFile, char **tmpNames, int tmpFiles, int tmpLines, int total) {
22 office 1083 #if defined ___AsyncIO___
1084 struct AsyncFile *fp, *tp;
1085 LONG c;
1086 #else
1 office 1087 FILE *fp, *tp;
1088 char c;
22 office 1089 #endif
1 office 1090 int lines;
26 office 1091 int write;
1 office 1092  
22 office 1093 #if defined ___AsyncIO___
1094 if((fp = OpenAsync(dbFile, MODE_READ, ASYNC_BUF)) == NULL) {
1095 #else
1 office 1096 if((fp = fopen(dbFile, "r")) == NULL) {
22 office 1097 #endif
24 office 1098 fprintf(stderr, "Unable to open '%s' for reading.\n", dbFile);
1 office 1099 return;
1100 }
1101  
22 office 1102 #if defined ___AsyncIO___
23 office 1103 if((tp = OpenAsync(tmpNames[--tmpFiles], MODE_WRITE, ASYNC_BUF)) == NULL) {
22 office 1104 #else
23 office 1105 if((tp = fopen(tmpNames[--tmpFiles], "w")) == NULL) {
22 office 1106 #endif
24 office 1107 fprintf(stderr, "Unable to open '%s' for writing.\n", tmpNames[tmpFiles]);
1108 #if defined ___AsyncIO___
1109 CloseAsync(fp);
1110 #else
1111 fclose(fp);
1112 #endif
1 office 1113 return;
1114 }
1115  
1116 if(verbose) {
24 office 1117 fprintf(stdout, "Writing to temporary files...\r");
1 office 1118 }
1119  
26 office 1120 write = 0;
1 office 1121 lines = 0;
22 office 1122 #if defined ___AsyncIO___
1123 while(run && (c = ReadCharAsync(fp)) != -1) {
1124 #else
1 office 1125 while(run && fscanf(fp, "%c", &c) == 1) {
22 office 1126 #endif
1 office 1127 #if defined ___AmigaOS___
1128 // Check if CTRL+C was pressed and abort the program.
1129 if(SetSignal(0L, SIGBREAKF_CTRL_C) & SIGBREAKF_CTRL_C) {
1130 run = FALSE;
23 office 1131 continue;
1 office 1132 }
1133 #endif
1134 switch(c) {
1135 case '\n':
1136 // Increment the total written lines.
26 office 1137 ++write;
1 office 1138  
1139 if(verbose) {
26 office 1140 fprintf(stdout, "Writing to temporary files: %d%%.\r", (int)(((float)write / total) * 100.0));
1 office 1141 }
1142  
1143 // Write the newline character back.
22 office 1144 #if defined ___AsyncIO___
1145 if(WriteCharAsync(tp, (UBYTE)c) != 1) {
1146 #else
1 office 1147 if(fprintf(tp, "%c", c) != 1) {
22 office 1148 #endif
24 office 1149 fprintf(stderr, "Unable to write to '%s'.\n", tmpNames[tmpFiles]);
22 office 1150 #if defined ___AsyncIO___
1151 CloseAsync(tp);
1152 CloseAsync(fp);
1153 #else
19 office 1154 fclose(tp);
1 office 1155 fclose(fp);
22 office 1156 #endif
1 office 1157 return;
1158 }
1159 // Switch to the next temporary file.
1160 if(++lines >= tmpLines) {
1161 // If there are no temporary files left then run till the end.
1162 if(tmpFiles - 1 < 0) {
1163 break;
1164 }
1165  
1166 // Close the previous temporary file and write to the next temporary file.
22 office 1167 #if defined ___AsyncIO___
1168 CloseAsync(tp);
23 office 1169 if((tp = OpenAsync(tmpNames[--tmpFiles], MODE_WRITE, ASYNC_BUF)) == NULL) {
22 office 1170 #else
1 office 1171 fclose(tp);
23 office 1172 if((tp = fopen(tmpNames[--tmpFiles], "w")) == NULL) {
22 office 1173 #endif
24 office 1174 fprintf(stderr, "Unable to open '%s' for writing.\n", tmpNames[tmpFiles]);
22 office 1175 #if defined ___AsyncIO___
1176 CloseAsync(fp);
1177 #else
1 office 1178 fclose(fp);
22 office 1179 #endif
24 office 1180 return;
1 office 1181 }
1182 lines = 0;
1183 break;
1184 }
1185 break;
1186 default:
22 office 1187 #if defined ___AsyncIO___
1188 if(WriteCharAsync(tp, (UBYTE)c) != 1) {
1189 #else
1 office 1190 if(fprintf(tp, "%c", c) != 1) {
22 office 1191 #endif
24 office 1192 fprintf(stderr, "Unable to write to '%s'.\n", tmpNames[tmpFiles]);
22 office 1193 #if defined ___AsyncIO___
1194 CloseAsync(tp);
1195 CloseAsync(fp);
1196 #else
1 office 1197 fclose(tp);
1198 fclose(fp);
22 office 1199 #endif
1 office 1200 return;
1201 }
1202 break;
1203 }
1204 }
1205  
24 office 1206 if(verbose) {
1207 fprintf(stdout, "\n");
1208 }
1 office 1209  
22 office 1210 #if defined ___AsyncIO___
1211 CloseAsync(tp);
1212 CloseAsync(fp);
1213 #else
1 office 1214 fclose(tp);
1215 fclose(fp);
22 office 1216 #endif
1 office 1217 }
1218  
1219 /*
1220 *
1221 * Merges temporary files "tmpNames" into a database "dbFile".
1222 */
24 office 1223 void MergeTemporaryFiles(char *dbFile, char **tmpNames, int files, int lines) {
22 office 1224 #if defined ___AsyncIO___
1225 struct AsyncFile *fp;
1226 struct AsyncFile **tp;
1227 #else
1 office 1228 FILE *fp;
1229 FILE **tp;
22 office 1230 #endif
1 office 1231 int i;
14 office 1232 int j;
1 office 1233 char *tmp;
26 office 1234 char *rem;
14 office 1235 char *min;
1 office 1236 int count;
1237  
22 office 1238 #if defined ___AsyncIO___
23 office 1239 if((fp = OpenAsync(dbFile, MODE_WRITE, ASYNC_BUF)) == NULL) {
22 office 1240 #else
23 office 1241 if((fp = fopen(dbFile, "w")) == NULL) {
22 office 1242 #endif
24 office 1243 fprintf(stderr, "Unable to open '%s' for writing.\n", dbFile);
1 office 1244 return;
1245 }
1246  
1247 // Allocate as many file pointers as temporary files.
26 office 1248 if((tp = malloc(files * sizeof(*tp))) == NULL) {
1249 fprintf(stderr, "Memory allocation failure.\n");
1250 #if defined ___AsyncIO___
1251 CloseAsync(fp);
1252 #else
1253 fclose(fp);
1254 #endif
1255 return;
1256 }
1 office 1257  
1258 // Open all temporary files for reading.
1259 for(i = 0; i < files; ++i) {
22 office 1260 #if defined ___AsyncIO___
1261 if((tp[i] = OpenAsync(tmpNames[i], MODE_READ, ASYNC_BUF)) == NULL) {
1262 #else
1 office 1263 if((tp[i] = fopen(tmpNames[i], "r")) == NULL) {
22 office 1264 #endif
24 office 1265 fprintf(stderr, "Unable to open '%s' for reading.\n", tmpNames[i]);
1 office 1266 // Close all temporary files.
24 office 1267 while(--i > -1) {
22 office 1268 #if defined ___AsyncIO___
1269 CloseAsync(tp[i]);
1270 #else
1 office 1271 fclose(tp[i]);
22 office 1272 #endif
1 office 1273 }
24 office 1274 #if defined ___AsyncIO___
1275 CloseAsync(fp);
1276 #else
1277 fclose(fp);
1278 #endif
1 office 1279 return;
1280 }
1281 }
1282  
1283 if(verbose) {
24 office 1284 fprintf(stdout, "Merging all files...\r");
1 office 1285 }
1286  
26 office 1287 rem = NULL;
1 office 1288 count = lines;
14 office 1289 j = 0;
1 office 1290 while(run && --count > -1) {
1291 #if defined ___AmigaOS___
1292 // Check if CTRL+C was pressed and abort the program.
1293 if(SetSignal(0L, SIGBREAKF_CTRL_C) & SIGBREAKF_CTRL_C) {
1294 run = FALSE;
23 office 1295 continue;
1 office 1296 }
1297 #endif
1298 // Find the smallest line in all temporary files.
1299 if(verbose) {
24 office 1300 fprintf(stdout, "Merging all files: %d%%.\r", 100 - (int)(((float)count / lines) * 100.0));
1 office 1301 }
1302  
14 office 1303 min = NULL;
1 office 1304 for(i = 0; i < files; ++i) {
26 office 1305 tmp = PeekLine(tp[i]);
1 office 1306 if(tmp == NULL) {
1307 continue;
1308 }
26 office 1309 #if defined ___AmigaOS___
1310 if(min == NULL || StrnCmp(locale, tmp, min, -1, SC_ASCII) < 0) {
1311 #else
27 office 1312 if(min == NULL || strcmp(tmp, min) < 0) {
26 office 1313 #endif
14 office 1314 if(min != NULL) {
2 office 1315 // Free previous instance.
14 office 1316 free(min);
2 office 1317 }
26 office 1318 if((min = malloc((strlen(tmp) + 1) * sizeof(*min))) == NULL) {
1319 fprintf(stderr, "Memory allication failure.\n");
1320 free(tmp);
1321 if(min != NULL) {
1322 free(min);
1323 }
1324 if(rem != NULL) {
1325 free(rem);
1326 }
1327 #if defined ___AsyncIO___
1328 CloseAsync(fp);
1329 #else
1330 fclose(fp);
1331 #endif
1332 return;
1333 }
14 office 1334 sprintf(min, "%s", tmp);
1 office 1335 // Remember the index of the file where the smallest entry has been found.
14 office 1336 j = i;
1 office 1337 }
1338 free(tmp);
1339 }
1340  
1341 // Forward the file where the smallest line was found.
23 office 1342 SkipLine(tp[j]);
1 office 1343  
1344 // Write the smallest line.
14 office 1345 if(min != NULL) {
26 office 1346 // If current minimum line is identical to previous minimum line then skip to remove duplicates.
1347 if(rem != NULL) {
1348 #if defined ___AmigaOS___
1349 if(StrnCmp(locale, min, rem, -1, SC_ASCII) == 0) {
1350 #else
28 office 1351 if(strcmp(min, rem) == 0) {
26 office 1352 #endif
1353 free(min);
1354 continue;
1355 }
1356 }
1357  
22 office 1358 #if defined ___AsyncIO___
26 office 1359 WriteAsync(fp, min, (LONG)strlen(min));
1360 WriteAsync(fp, "\n", 1);
22 office 1361 #else
14 office 1362 fprintf(fp, "%s\n", min);
22 office 1363 #endif
26 office 1364  
1365 if(rem != NULL) {
1366 free(rem);
1367 }
1368  
1369 if((rem = malloc((strlen(min) + 1) * sizeof(*rem))) == NULL) {
1370 fprintf(stderr, "Memory allocation failure.\n");
1371 free(min);
1372 #if defined ___AsyncIO___
1373 CloseAsync(fp);
1374 #else
1375 fclose(fp);
1376 #endif
1377 return;
1378 }
1379  
1380 sprintf(rem, "%s", min);
14 office 1381 free(min);
1 office 1382 }
1383 }
1384  
26 office 1385 if(rem != NULL) {
1386 free(rem);
1387 }
1388  
1 office 1389 // Write out any remaining contents from the temporary files.
24 office 1390 for(i = 0; run && i < files; ++i) {
1391 #if defined ___AmigaOS___
1392 // Check if CTRL+C was pressed and abort the program.
1393 if(SetSignal(0L, SIGBREAKF_CTRL_C) & SIGBREAKF_CTRL_C) {
1394 run = FALSE;
1395 continue;
1396 }
1397 #endif
23 office 1398 tmp = ReadLine(tp[i]);
1 office 1399 if(tmp == NULL) {
1400 continue;
1401 }
22 office 1402 #if defined ___AsyncIO___
26 office 1403 WriteAsync(fp, tmp, (LONG)strlen(tmp));
1404 WriteAsync(fp, "\n", 1);
22 office 1405 #else
1 office 1406 fprintf(fp, "%s\n", tmp);
22 office 1407 #endif
14 office 1408 free(tmp);
1 office 1409 }
1410  
24 office 1411 // Close all temporary files.
1 office 1412 for(i = 0; i < files; ++i) {
22 office 1413 #if defined ___AsyncIO___
1414 CloseAsync(tp[i]);
1415 #else
1 office 1416 fclose(tp[i]);
22 office 1417 #endif
1 office 1418 }
1419  
1420 if(verbose) {
1421 fprintf(stdout, "\n");
1422 }
1423  
22 office 1424 #if defined ___AsyncIO___
1425 CloseAsync(fp);
1426 #else
1 office 1427 fclose(fp);
22 office 1428 #endif
1 office 1429 }
1430  
1431 /*
26 office 1432 *
1433 * Filter the paths inside the database with provided paths.
1434 */
1435 void FilterDatabasePaths(char *dbFile, char *tmpName, char **paths, unsigned int count) {
1436 #if defined ___AsyncIO___
1437 struct AsyncFile *fp;
1438 struct AsyncFile *tp;
1439 #else
1440 FILE *fp;
1441 FILE *tp;
1442 #endif
1443 char *line;
1444 int i;
1445 dbEntry *entry;
24 office 1446  
26 office 1447 // Open database file for reading.
1448 #if defined ___AsyncIO___
1449 if((fp = OpenAsync(dbFile, MODE_READ, ASYNC_BUF)) == NULL) {
1450 #else
1451 if((fp = fopen(dbFile, "r")) == NULL) {
1452 #endif
1453 fprintf(stderr, "Unable to open '%s' for reading.\n", dbFile);
1454 return;
24 office 1455 }
1456  
26 office 1457 // Open temporary file for writing.
1458 #if defined ___AsyncIO___
1459 if((tp = OpenAsync(tmpName, MODE_WRITE, ASYNC_BUF)) == NULL) {
1460 #else
1461 if((tp = fopen(tmpName, "w")) == NULL) {
1462 #endif
1463 fprintf(stderr, "Unable to open '%s' for writing.\n", tmpName);
24 office 1464  
26 office 1465 // Close database file.
1466 #if defined ___AsyncIO___
1467 CloseAsync(fp);
1468 #else
1469 fclose(fp);
1470 #endif
1471  
1472 return;
24 office 1473 }
26 office 1474  
1475 while(run && (line = ReadLine(fp)) != NULL) {
1476 #if defined ___AmigaOS___
1477 // Check if CTRL+C was pressed and abort the program.
1478 if(SetSignal(0L, SIGBREAKF_CTRL_C) & SIGBREAKF_CTRL_C) {
1479 run = FALSE;
1480 continue;
1481 }
1482 #endif
1483 if((entry = CreateDataseEntry(line)) == NULL) {
1484 fprintf(stderr, "Unable to create database entry.\n");
1485 continue;
1486 }
1487 for(i = 0; i < count; ++i) {
1488 if(PathCompare(entry->path, paths[i]) == TRUE) {
1489 continue;
1490 }
1491 #if defined ___AsyncIO___
1492 WriteAsync(tp, line, (LONG)strlen(line));
1493 WriteAsync(tp, "\n", 1);
1494 #else
1495 fprintf(tp, "%s\n", line);
1496 #endif
1497 break;
1498 }
1499  
1500 free(entry);
1501 free(line);
1502 }
1503  
1504  
1505 #if defined ___AsyncIO___
1506 CloseAsync(fp);
1507 CloseAsync(tp);
1508 #else
1509 fclose(fp);
1510 fclose(tp);
1511 #endif
24 office 1512 }
1513  
1514 /*
1515 *
1 office 1516 * Indexes a "path" by creating a database "dbFile".
1517 */
26 office 1518 void GatherDatabaseFiles(char *dbFile, char **paths, unsigned int count) {
1519 stats *stats;
1 office 1520 char **tmpNames;
26 office 1521 int dbSize;
1522 int dbLines;
1523 int tmpFiles;
1524 int tmpLines;
1 office 1525 int i;
1526  
26 office 1527 // Generate the database file from the supplied paths.
1528 if((stats = CollectFiles(dbFile, paths, count)) == NULL) {
1529 fprintf(stderr, "Collecting files failed.\n");
1530 return;
1531 }
1532 free(stats);
1 office 1533  
26 office 1534 // Compute the amount of temporary files needed.
23 office 1535 dbSize = GetFileSize(dbFile);
26 office 1536 if(dbSize == -1) {
1537 fprintf(stderr, "File size for '%s' failed.\n", dbFile);
1538 return;
1539 }
1540 tmpFiles = dbSize / maxmem;
1 office 1541  
26 office 1542 /* In case no temporary files are required,
1543 * just sort the database and terminate.
1544 */
2 office 1545 if(tmpFiles <= 1) {
1 office 1546 SortDatabase(dbFile);
1547 return;
1548 }
1549  
26 office 1550 // Get the database metrics.
1551 dbLines = CountFileLines(dbFile);
1552 if(dbLines == -1) {
1553 fprintf(stderr, "Counting lines of '%s' failed.\n", dbFile);
1554 }
1 office 1555 tmpLines = dbLines / tmpFiles;
1556  
1557 // Create temporary files.
23 office 1558 if((tmpNames = CreateTemporaryFiles(tmpFiles)) == NULL) {
1 office 1559 fprintf(stderr, "Unable to create temporary files.\n");
1560 return;
1561 }
1562  
24 office 1563 // Write "tmpLines" to temporary files in "tmpNames" from "dbFile".
23 office 1564 WriteTemporaryFiles(dbFile, tmpNames, tmpFiles, tmpLines, dbLines);
1 office 1565  
1566 // Sort the temporary files.
24 office 1567 for(i = 0; run && i < tmpFiles; ++i) {
1 office 1568 SortDatabase(tmpNames[i]);
1569 }
1570  
24 office 1571 // Merge all the temporary files to the database file.
1572 MergeTemporaryFiles(dbFile, tmpNames, tmpFiles, dbLines);
1573  
1574 // Remove all temporary files.
26 office 1575 RemoveFiles(tmpNames, tmpFiles);
1576  
1577 free(tmpNames);
1 office 1578 }
1579  
26 office 1580 void RemoveDatabaseFiles(char *dbFile, char **paths, unsigned int count) {
1581 char *tmpName;
1582  
1583 // Create a temporary file to hold the changes.
1584 if((tmpName = CreateTemporaryFile()) == NULL) {
1585 fprintf(stderr, "Unable to create temporary file.\n");
1586 return;
1587 }
1588  
1589 // Filter the database of the provided paths.
1590 FilterDatabasePaths(dbFile, tmpName, paths, count);
1591  
1592 // Overwrite the database file with the filtered paths.
1593 CopyFile(tmpName, dbFile);
1594  
1595 // Remove temporary file.
1596 RemoveFile(tmpName);
1597 }
1598  
11 office 1599 void usage(char *name) {
1600 fprintf(stdout, "Hunt & Gather - %s, a file index generating tool. \n", name);
19 office 1601 fprintf(stdout, "Version: %s \n", PROGRAM_VERSION);
11 office 1602 fprintf(stdout, " \n");
26 office 1603 fprintf(stdout, "SYNTAX: %s [-q] <-a|-r|-c> <PATH PATH PATH...> \n", name);
1604 fprintf(stdout, " \n");
1605 fprintf(stdout, "Required: \n");
27 office 1606 fprintf(stdout, " -a [PATH...] Add files. \n");
1607 fprintf(stdout, " -c [PATH...] Create from scratch. \n");
26 office 1608 fprintf(stdout, " -r [PATH...] Remove files. \n");
1609 fprintf(stdout, " \n");
1610 fprintf(stdout, "Optional: \n");
1611 fprintf(stdout, " -d [FIILE] Where to store the database. \n");
1612 fprintf(stdout, " -m BYTES Memory to use (default: %d). \n", maxmem);
11 office 1613 fprintf(stdout, " -q Do not print out any messages. \n");
26 office 1614 fprintf(stdout, " \n");
11 office 1615 fprintf(stdout, "DATABASE is a path to where the indexed results will be \n");
1616 fprintf(stdout, "stored for searching with the Hunt tool. \n");
1617 fprintf(stdout, " \n");
1618 fprintf(stdout, "(c) 2021 Wizardry and Steamworks, MIT. \n");
1619 }
1620  
1 office 1621 /*
1622 *
1623 * Main entry point.
1624 */
1625 int main(int argc, char **argv) {
28 office 1626 #if defined ___AmigaOS___
1627 struct FileInfoBlock *FIB;
1628 BPTR lock;
1629 #else
1630 struct stat dirStat;
1631 #endif
1 office 1632 int option;
26 office 1633 unsigned int i;
1634 unsigned int count;
2 office 1635 char *dbFile;
19 office 1636 char *path;
26 office 1637 char **paths;
1 office 1638  
1639 // Bind handler to SIGINT.
26 office 1640 #if !defined ___AmigaOS___
1 office 1641 signal(SIGINT, SignalHandler);
26 office 1642 #endif
1 office 1643  
2 office 1644 dbFile = DEFAULT_DATABASE_FILE;
26 office 1645 while((option = getopt(argc, argv, "hqdm:arc")) != -1) {
1 office 1646 switch(option) {
26 office 1647 case 'a':
1648 operation = GATHER;
1649 break;
1650 case 'r':
1651 operation = REMOVE;
1652 break;
1653 case 'c':
1654 operation = CREATE;
1655 break;
1656 case 'm':
1657 maxmem = strtoul(optarg, NULL, 10);
1658 break;
2 office 1659 case 'd':
1660 dbFile = optarg;
1661 break;
1 office 1662 case 'q':
1663 verbose = FALSE;
1664 break;
1665 case 'h':
11 office 1666 usage(argv[0]);
2 office 1667 return 0;
1 office 1668 case '?':
1669 fprintf(stderr, "Invalid option %ct.\n", optopt);
1670 return 1;
1671 }
1672 }
1673  
26 office 1674 if(operation == NONE) {
1675 usage(argv[0]);
1676 return 1;
1677 }
10 office 1678  
1679 if(optind >= argc) {
11 office 1680 usage(argv[0]);
1 office 1681 return 1;
1682 }
1683  
26 office 1684 // Go through all supplied arguments and add paths to search.
1685 if((paths = malloc((argc - optind) * sizeof(*paths))) == NULL) {
1686 fprintf(stderr, "Memory allocation failure.\n");
1 office 1687 return 1;
1688 }
26 office 1689 for(i = optind, count = 0; i < argc; ++i, ++count) {
28 office 1690 if((path = PathToAbsolute(argv[i])) == NULL) {
26 office 1691 fprintf(stderr, "Absolute path for '%s' failed to resolve.\n", argv[optind]);
1692 continue;
1693 }
1 office 1694  
26 office 1695 // Check that the path is a directory.
28 office 1696 #if defined ___AmigaOS___
1697 if((lock = Lock(path, ACCESS_READ)) == NULL) {
1698 fprintf(stderr, "Path '%s' is not accessible.\n", path);
1699 free(path);
1700 continue;
1701 }
1702  
1703 if((FIB = AllocDosObject(DOS_FIB, NULL)) == NULL) {
1704 fprintf(stderr, "Path '%s' file information block not accessible.\n", path);
1705 UnLock(lock);
1706 free(path);
1707 continue;
1708 }
1709  
1710 if(Examine(lock, FIB) == FALSE) {
1711 fprintf(stderr, "Path '%s' information unexaminable.\n", path);
1712 UnLock(lock);
1713 FreeDosObject(DOS_FIB, FIB);
1714 free(path);
1715 continue;
1716 }
1717  
1718 if(FIB->fib_DirEntryType < 0) {
1719 #else
26 office 1720 stat(path, &dirStat);
1721 if(!S_ISDIR(dirStat.st_mode)) {
28 office 1722 #endif
26 office 1723 fprintf(stderr, "Path '%s' is not a directory.\n", argv[optind]);
28 office 1724 #if defined ___AmigaOS___
1725 UnLock(lock);
1726 FreeDosObject(DOS_FIB, FIB);
1727 #endif
26 office 1728 free(path);
1729 return 1;
1730 }
1731  
1732 if(verbose) {
1733 fprintf(stdout, "Will process path: '%s'\n", path);
1734 }
1735  
1736 // Add the path to the array of paths.
1737 if((paths[count] = malloc(strlen(path) * sizeof(*paths[count]))) == NULL) {
1738 fprintf(stderr, "Memory allocation failure.");
1739 return 1;
1740 }
28 office 1741  
26 office 1742 sprintf(paths[count], "%s", path);
28 office 1743  
1744 #if defined ___AmigaOS___
1745 UnLock(lock);
1746 FreeDosObject(DOS_FIB, FIB);
1747 #endif
26 office 1748 free(path);
28 office 1749  
26 office 1750 }
1751  
2 office 1752 if(verbose) {
26 office 1753 fprintf(stdout, "Gathering to: '%s'\n", dbFile);
2 office 1754 }
1755  
26 office 1756 #if defined ___AmigaOS___
1757 locale = OpenLocale(NULL);
1758 #endif
1759  
1 office 1760 // Gather.
26 office 1761 switch(operation) {
1762 case CREATE:
1763 if(verbose) {
1764 fprintf(stdout, "Removing '%s' and creating a new database.\n", dbFile);
1765 }
1766 RemoveFile(dbFile);
1767 case GATHER:
1768 if(verbose) {
1769 fprintf(stdout, "Gathering files to database...\n");
1770 }
1771 GatherDatabaseFiles(dbFile, paths, count);
1772 break;
1773 case REMOVE:
1774 if(verbose) {
1775 fprintf(stdout, "Removing files from database...\n");
1776 }
1777 RemoveDatabaseFiles(dbFile, paths, count);
1778 break;
1779 default:
1780 break;
1781 }
1 office 1782  
26 office 1783 #if defined ___AmigaOS___
1784 CloseLocale(locale);
1785 #endif
19 office 1786  
26 office 1787 free(paths);
1788  
1789 return 0;
1 office 1790 }