HuntnGather – Diff between revs 24 and 26

Subversion Repositories:

?pathlinks?

Rev 24 – Rev 27 – Go to most recent revision – Details – Blame – Last modification – View Log

 #include <sys/types.h>
 #include <sys/stat.h>
+#include <sys/syslimits.h>
 #include <sys/syslimits.h>
 #if defined ___AmigaOS___
+#include <proto/dos.h>
+#include <proto/exec.h>
-#include <proto/dos.h>
+#include <proto/locale.h>
-#include <proto/exec.h>
+#endif
 #if !defined ___HAVE_GETOPT___
 #include "getopt.h"
 #endif
-#define PROGRAM_VERSION "1.7.3"
+#define PROGRAM_VERSION "1.7.4"
 #if defined ___AmigaOS___
 #define FALSE 0;
 #endif
 #define ASYNC_BUF 8192
-#define MAX_MEM 262144
-#define NAME_BUF 32
-#define PATH_BUF 128
+#define MAX_MEM 262144
 #define LINE_BUF 256
 #define DEFAULT_DATABASE_FILE "S:gather.db"
 typedef struct {
 	unsigned int dirs;
+	unsigned int files;
+} stats;
+typedef struct {
+	char *name;
+	char *path;
+} dbEntry;
+typedef struct {
+	char **database;
+	unsigned int count;
+} dbArray;
+enum MODE {
+	NONE,
+	GATHER,
+	REMOVE,
-	unsigned int files;
+	CREATE
-} stats;
+} operation;
+unsigned int run = TRUE;
+unsigned int verbose = TRUE;
+unsigned int maxmem = MAX_MEM;
+// Define global locale for string compare.
 #if defined ___AmigaOS___
-int run = TRUE;
+struct Locale *locale;
-int verbose = TRUE;
+#endif
+void SignalHandler(int sig) {
+	// Toggle the run flag to stop execution.
+	run = FALSE;
+}
-void SignalHandler(int sig) {
-	// Toggle the run flag to stop execution.
+/*
 	run = FALSE;
+	* Used for sorting database lines.
+	*/
+int QsortCompare(const void *a, const void *b) {
 	const char **p = (const char **)a;
+	const char **q = (const char **)b;
 #if defined ___AmigaOS___
-int compare(const void *a, const void *b) {
+	return StrnCmp(locale, (STRPTR)*p, (STRPTR)*q, -1, SC_ASCII);
-	const char **p = (const char **)a;
+#else
-	const char **q = (const char **)b;
+	return strncmp(*p, *q, strlen(*p));
-	return strncmp(*p, *q, strlen(*p));
+#endif
+}
+/*
+	*
+	* Gets the absolute path to file by name.
+	*/
+char *PathToAbsolute(char *path) {
+	char *abs;
+#if defined ___AmigaOS___
+	BPTR lock;
+#endif
+#if defined ___AmigaOS___
+	if((abs = malloc(PATH_MAX * sizeof(*abs))) == NULL) {
+		fprintf(stderr, "Memory allocation failure.\n");
+		return NULL;
+	}
+	if((lock = Lock(path, SHARED_LOCK)) == 0) {
+		fprintf(stderr, "Lock on %s failed.\n", path);
+		return NULL;
+	}
+	if(NameFromLock(lock, abs, PATH_MAX) == FALSE) {
+		fprintf(stderr, "Lock on %s failed.\n", path);
+		UnLock(lock);
+		return NULL;
+	}
+	UnLock(lock);
+#else
+	abs = realpath(path, NULL);
+#endif
+	return abs;
+}
+/*
+	*
+	* Compares path parts for equality.
+	*/
+#if defined ___AmigaOS___
+BOOL PathCompare(char *path, char *look) {
+#else
+int PathCompare(char *path, char *look) {
+#endif
+	char *a;
+	char *b;
+	for(a = path, b = look; *a != '\0' && *b != '\0'; ++a, ++b) {
+		if(*b != '\0' && *a != *b) {
+			return FALSE;
+		}
+	}
+	return *b == '\0';
 }
 /*
 	*
-	* Sorts a database file lexicographically.
+	* Gets the size of a file by name.
 	*/
-void SortDatabase(char *dbFile) {
+int GetFileSize(char *dbFile) {
 #if defined ___AsyncIO___
-	struct AsyncFile *fp;
-	LONG c;
-#else
-	FILE *fp;
-	char c;
-#endif
-	char *name = NULL;
-	char *path = NULL;
-	char **database;
-	int i;
+	struct AsyncFile *fp;
-	int side;
+	LONG size;
-	unsigned int line;
+#else
-	int name_size;
+	FILE *fp;
-	int path_size;
+	int size;
 #endif
-	// Open database file for reading.
+#if defined ___AsyncIO___
+	if((fp = OpenAsync(dbFile, MODE_READ, ASYNC_BUF)) == NULL) {
+#else
+	if((fp = fopen(dbFile, "r")) == NULL) {
+#endif
+		fprintf(stderr, "Unable to open '%s' for reading.\n", dbFile);
+		return -1;
+	}
+#if defined ___AsyncIO___
+	if(SeekAsync(fp, 0, MODE_END) == -1) {
+#else
+	if(fseek(fp, 0L, SEEK_END) == 0) {
+#endif
+		fprintf(stderr, "Seek in file %s failed.\n", dbFile);
+#if defined ___AsyncIO___
+   	CloseAsync(fp);
+#else
+		fclose(fp);
+#endif
-#if defined ___AsyncIO___
+		return -1;
+	}
+#if defined ___AsyncIO___
+	if((size = SeekAsync(fp, 0, MODE_CURRENT)) == -1) {
-	if((fp = OpenAsync(dbFile, MODE_READ, ASYNC_BUF)) == NULL) {
+		fprintf(stderr, "Seek in file %s failed.\n", dbFile);
-#else
+		CloseAsync(fp);
-	if((fp = fopen(dbFile, "r")) == NULL) {
+		return -1;
-#endif
+	}
-		fprintf(stderr, "Unable to open '%s' for reading.\n", dbFile);
+#else
-		return;
-	}
+	size = ftell(fp);
+#endif
+#if defined ___AsyncIO___
+   CloseAsync(fp);
+#else
+	fclose(fp);
+#endif
+	return size;
+}
+/*
+	*
-	database = malloc(sizeof(*database));
+	* Counts the lines of a file.
+	*/
+int CountFileLines(char *dbFile) {
+#if defined ___AsyncIO___
+	struct AsyncFile *fp;
+	LONG c;
+#else
-	name_size = NAME_BUF;
+	FILE *fp;
+	char c;
-	name = malloc(name_size * sizeof(*name));
+#endif
+	int lines;
 	path_size = PATH_BUF;
-	path = malloc(path_size * sizeof(*path));
+#if defined ___AsyncIO___
 	if((fp = OpenAsync(dbFile, MODE_READ, ASYNC_BUF)) == NULL) {
-	line = 0;
+#else
-	side = 0;
+	if((fp = fopen(dbFile, "r")) == NULL) {
-	i = 0;
+#endif
 		fprintf(stderr, "Unable to open '%s' for reading.\n", dbFile);
-	if(verbose) {
+		return -1;
 		fprintf(stdout, "Sorting '%s'\n", dbFile);
 	lines = 0;
 #if defined ___AsyncIO___
 	while(run && (c = ReadCharAsync(fp)) != -1) {
 #else
-	while(run && fscanf(fp, "%c", &c) == 1) {
-#endif
-#if defined ___AmigaOS___
-		// Check if CTRL+C was pressed and abort the program.
-   	if(SetSignal(0L, SIGBREAKF_CTRL_C) & SIGBREAKF_CTRL_C) {
+	while(run && fscanf(fp, "%c", &c) == 1) {
-			run = FALSE;
-			continue;
-		}
-#endif
-		switch(c) {
-			case '\n':
-				// Load up the name and path into the database variable.
-				database = realloc(database, (line + 1) * sizeof(*database));
-				database[line] = malloc((strlen(name) + strlen(path) + 1 + 1) * sizeof(*database[line]));
-				sprintf(database[line], "%s\t%s", name, path);
-				++line;
-				free(name);
-				name_size = NAME_BUF;
-				name = malloc(name_size * sizeof(*name));
-				--side;
-				i = 0;
-				break;
-			case '\t':
-				free(path);
-				path_size = PATH_BUF;
-				path = malloc(path_size * sizeof(*path));
-				++side;
-				i = 0;
-				break;
-			default:
-				switch(side) {
-					case 0:
-					   if(strlen(name) == name_size) {
-					   	name_size = name_size * 1.5;
-					   	name = realloc(name, name_size * sizeof(*name));
-					   }
-						//name = realloc(name, (i + 1 + 1) * sizeof(char));
-						name[i] = c;
-						name[i + 1] = '\0';
-						break;
-					case 1:
-						if(strlen(path) == path_size) {
-							path_size = path_size * 1.5;
-							path = realloc(path, path_size * sizeof(*path));
+#endif
 #if defined ___AmigaOS___
-						//path = realloc(path, (i + 1 + 1) * sizeof(char));
+		// Check if CTRL+C was pressed and abort the program.
-						path[i] = c;
+		if(SetSignal(0L, SIGBREAKF_CTRL_C) & SIGBREAKF_CTRL_C) {
-						path[i + 1] = '\0';
+			run = FALSE;
-						break;
+			continue;
 					default:
-						fprintf(stderr, "File '%s' is corrupted.\n", dbFile);
+#endif
-						break;
+		switch(c) {
-				}
+			case '\n':
+				++lines;
+				break;
-				++i;
+		}
+	}
+#if defined ___AsyncIO___
+	CloseAsync(fp);
-				break;
+#else
+	fclose(fp);
+#endif
+	return lines;
+}
+/*
+	*
+	* Creates a temporary file and returns its name.
+	*/
+char *CreateTemporaryFile(void) {
+	char *name;
-		}
+	name = tmpnam(NULL);
+	return name;
+}
+/*
-	}
+	*
+	* Create multiple temporary files and return their names.
+	*/
+char **CreateTemporaryFiles(int files) {
+	char **tmpNames;
+	int count;
+	if((tmpNames = malloc(files * sizeof(*tmpNames))) == NULL) {
+		fprintf(stderr, "Memory allocation failure.\n");
+		return NULL;
 #if defined ___AsyncIO___
+	if(verbose) {
+		fprintf(stdout, "Creating temporary files...\r");
-	CloseAsync(fp);
+	}
-#else
-	fclose(fp);
+	count = files;
+	while(run && --count > -1) {
+#if defined ___AmigaOS___
+		// Check if CTRL+C was pressed and abort the program.
+		if(SetSignal(0L, SIGBREAKF_CTRL_C) & SIGBREAKF_CTRL_C) {
+			run = FALSE;
+			continue;
+		}
+#endif
+		tmpNames[count] = CreateTemporaryFile();
-#endif
+		if(verbose) {
+			fprintf(stdout, "Creating temporary files: %d%%\r", 100 - (int)(((float)count / files) * 100.0));
+		}
+	}
+	if(verbose) {
+		fprintf(stdout, "\n");
+	}
+	return tmpNames;
+}
 	// Sort the database.
-	qsort(database, line, sizeof(char *), compare);
+/*
+	*
-	// Write the database lines back to the database.
+	* Skips a line in a file.
-#if defined ___AsyncIO___
+	*/
-	if((fp = OpenAsync(dbFile, MODE_WRITE, ASYNC_BUF)) == NULL) {
+#if defined ___AsyncIO___
+void SkipLine(struct AsyncFile *fp) {
+	LONG c;
+	while(run && (c = ReadCharAsync(fp)) != -1) {
+#else
+void SkipLine(FILE *fp) {
+	char c;
+	while(run && fscanf(fp, "%c", &c) == 1) {
+#endif
+#if defined ___AmigaOS___
+		// Check if CTRL+C was pressed and abort the program.
+		if(SetSignal(0L, SIGBREAKF_CTRL_C) & SIGBREAKF_CTRL_C) {
-#else
+			run = FALSE;
-	if((fp = fopen(dbFile, "w")) == NULL) {
+			continue;
-#endif
+		}
-		fprintf(stderr, "Unable to open '%s' for writing.\n", dbFile);
+#endif
-		return;
+		switch(c) {
+			case '\n':
 				return;
+		}
+	}
+}
+/*
+	*
+	* Peeks at a line from a file.
+	*/
 #if defined ___AsyncIO___
+char *PeekLine(struct AsyncFile *fp) {
-	for(i = 0; i < line; ++i) {
+	LONG c;
-#if defined ___AmigaOS___
+#else
-		// Check if CTRL+C was pressed and abort the program.
+char *PeekLine(FILE *fp) {
-   	if(SetSignal(0L, SIGBREAKF_CTRL_C) & SIGBREAKF_CTRL_C) {
+	char c;
-			run = FALSE;
+#endif
+	char *line;
+	unsigned int size;
+	int i;
+	size = LINE_BUF;
+	if((line = malloc(size * sizeof(*line))) == NULL) {
+		fprintf(stderr, "Memory allocation failure.\n");
+		return NULL;
+	}
+	i = 0;
+#if defined ___AsyncIO___
+	while(run && (c = ReadCharAsync(fp)) != -1) {
+#else
+	while(run && fscanf(fp, "%c", &c) == 1) {
+#endif
+#if defined ___AmigaOS___
+		// Check if CTRL+C was pressed and abort the program.
+		if(SetSignal(0L, SIGBREAKF_CTRL_C) & SIGBREAKF_CTRL_C) {
+			run = FALSE;
+			continue;
+		}
+#endif
+		switch(c) {
+			case '\n':
+				// Rewind the file by the number of read characters.
+#if defined ___AsyncIO___
+				if(SeekAsync(fp, -(i + 1), MODE_CURRENT) == -1) {
+					fprintf(stderr, "Could not seek in file.\n");
+					free(line);
+					return NULL;
-			continue;
+				}
 #else
-#endif
+				fseek(fp, -(i + 1), SEEK_CUR);
-#if defined ___AsyncIO___
+#endif
-		WriteAsync(fp, database[i], (LONG)(strlen(database[i]) * sizeof(char)));
+				return line;
-		WriteAsync(fp, "\n", 1 * sizeof(char));
+			default:
-#else
-		fprintf(fp, "%s\n", database[i]);
+				if(strlen(line) == size) {
-#endif
+					size = size * 1.5;
+					line = realloc(line, size * sizeof(*line));
+				}
+				line[i] = c;
+				line[i + 1] = '\0';
-#if defined ___AsyncIO___
+				break;
-	CloseAsync(fp);
+		}
-#else
-	fclose(fp);
-#endif
+		++i;
-	free(database);
+	}
+	return NULL;
+}
+/*
+	*
+	* Read a line from a file.
 	*/
+#if defined ___AsyncIO___
-/*
+char *ReadLine(struct AsyncFile *fp) {
-	*
+	LONG c;
-	* Updates a database file "dbFile".
+#else
-	*/
-void CollectFiles(char *dbFile, stringStack *dirStack, stats *stats) {
-#if defined ___AsyncIO___
-	struct AsyncFile *fp;
-#else
-	FILE *fp;
-#endif
-	DIR *dir;
-	struct dirent *dirEntry;
-	struct stat dirStat;
+char *ReadLine(FILE *fp) {
-	unsigned int size;
+	char c;
-	char *path;
+#endif
-	char *subPath;
+	char *line;
 	unsigned int size;
-#if defined ___AsyncIO___
+	unsigned int i;
 	if((fp = OpenAsync(dbFile, MODE_WRITE, ASYNC_BUF)) == NULL) {
+	size = LINE_BUF;
+	if((line = malloc(size * sizeof(*line))) == NULL) {
+		fprintf(stderr, "Memory allication failure.\n");
+		return NULL;
-#else
+	}
+	i = 0;
+#if defined ___AsyncIO___
+	while(run && (c = ReadCharAsync(fp)) != -1) {
+#else
-	if((fp = fopen(dbFile, "w")) == NULL) {
+	while(run && fscanf(fp, "%c", &c) == 1) {
 #endif
+#if defined ___AmigaOS___
+		// Check if CTRL+C was pressed and abort the program.
-		fprintf(stderr, "Unable to open '%s' for writing.\n", dbFile);
-		return;
-	}
+		if(SetSignal(0L, SIGBREAKF_CTRL_C) & SIGBREAKF_CTRL_C) {
+			run = FALSE;
+			continue;
+		}
-	if(verbose) {
+#endif
+		switch(c) {
-		fprintf(stdout, "Collecting files...\r");
+			case '\n':
-	}
+				return line;
-	while(run && !stringStackIsEmpty(dirStack)) {
-#if defined ___AmigaOS___
+			default:
-		// Check if CTRL+C was pressed and abort the program.
+				if(strlen(line) == size) {
+					size = size * 1.5;
+					line = realloc(line, size * sizeof(*line));
 		if(SetSignal(0L, SIGBREAKF_CTRL_C) & SIGBREAKF_CTRL_C) {
-			run = FALSE;
-			continue;
-		}
-#endif
-		if((path = stringStackPop(dirStack)) == NULL) {
-			return;
-		}
-		if((dir = opendir(path)) == NULL) {
-			fprintf(stderr, "Unable to open '%s' for reading.\n", path);
-			return;
-		}
-		while(run && (dirEntry = readdir(dir)) != NULL) {
-#if defined ___AmigaOS___
-			// Check if CTRL+C was pressed and abort the program.
+				line[i] = c;
-			if(SetSignal(0L, SIGBREAKF_CTRL_C) & SIGBREAKF_CTRL_C) {
+				line[i + 1] = '\0';
+				break;
-				run = FALSE;
+		}
+		++i;
+	}
-				continue;
+	return NULL;
+}
-			}
-#endif
+/*
+  *
-			size = sizeof(path) + sizeof(dirEntry->d_name) + 1;
+  * Delete a file.
-			switch(path[strlen(path) - 1]) {
+  */
+#if defined ___AmigaOS___
+BOOL RemoveFile(char *name) {
+	return DeleteFile(name);
+#else
+int RemoveFile(char *name) {
+	return remove(name) == 0;
+#endif
-				case '/':
+}
-	 			case ':': // This is a drive path.
+/*
-	 				subPath = malloc(size);
+	*
+	* Deletes files.
+	*/
+void RemoveFiles(char **names, int count) {
+	unsigned int i;
-	 				sprintf(subPath, "%s%s", path, dirEntry->d_name);
+	for(i = 0; i < count; ++i) {
-	 				break;
+		if(RemoveFile(names[i]) == FALSE) {
+			fprintf(stderr, "Unable to remove %s...\n", names[i]);
+			continue;
-	 			default:
+		}
-	 				subPath = malloc(size + 1);
+		fprintf(stderr, "Removing file: %s\n", names[i]);
+	}
+}
+/*
 	 				sprintf(subPath, "%s/%s", path, dirEntry->d_name);
-	 				break;
-			}
-			stat(subPath, &dirStat);
-			if(S_ISDIR(dirStat.st_mode)) {
+	* Copies a file to another file by name.
-	 			stringStackPush(dirStack, subPath);
+	*/
+void CopyFile(char *a, char *b) {
-	 			++stats->dirs;
+#if defined ___AsyncIO___
-	 			if(verbose) {
-	 				fprintf(stdout,
-	 					"Gathered %d directories and %d files.\r",
-	 					stats->dirs,
+	struct AsyncFile *ap;
-	 					stats->files);
-	 			}
+	struct AsyncFile *bp;
+	LONG c;
-	 			free(subPath);
+#else
-	 			continue;
+	FILE *ap;
+	FILE *bp;
+	char c;
-	 		}
+#endif
 	 		// Write to database file.
+	// Open database file for writing.
+#if defined ___AsyncIO___
+	if((ap = OpenAsync(a, MODE_READ, ASYNC_BUF)) == NULL) {
+#else
+	if((ap = fopen(a, "r")) == NULL) {
+#endif
+		fprintf(stderr, "Unable to open '%s' for reading.\n", a);
+		return;
+	}
+	// Open temporary file for reading.
+#if defined ___AsyncIO___
+	if((bp = OpenAsync(b, MODE_WRITE, ASYNC_BUF)) == NULL) {
+#else
-#if defined ___NOCASE_FS___
+	if((bp = fopen(b, "w+")) == NULL) {
+#endif
+		fprintf(stderr, "Unable to open file '%s' for writing.\n", b);
+		// Close database file.
-			strupr(dirEntry->d_name);
+#if defined ___AsyncIO___
-#endif
+		CloseAsync(ap);
+#else
+		fclose(ap);
-#if defined ___AsyncIO___
+#endif
-			WriteAsync(fp, dirEntry->d_name, (LONG)(strlen(dirEntry->d_name) * sizeof(char)));
+		return;
 			WriteAsync(fp, "\t", 1 * sizeof(char));
-			WriteAsync(fp, subPath, (LONG)(strlen(subPath) * sizeof(char)));
 			WriteAsync(fp, "\n", 1 * sizeof(char));
-#else
+#if defined ___AsyncIO___
-	 		fprintf(fp, "%s\t%s\n", dirEntry->d_name, subPath);
+	while(run && (c = ReadCharAsync(ap)) != -1) {
-#endif
+#else
-	 		++stats->files;
+	while(run && fscanf(ap, "%c", &c) == 1) {
+#endif
-	 		if(verbose) {
+#if defined ___AmigaOS___
-	 			fprintf(stdout,
+		// Check if CTRL+C was pressed and abort the program.
-	 				"Gathered %d directories and %d files.\r",
-	 				stats->dirs,
+   	if(SetSignal(0L, SIGBREAKF_CTRL_C) & SIGBREAKF_CTRL_C) {
-	 				stats->files);
+			run = FALSE;
-	 		}
 			continue;
+		}
+#endif
+#if defined ___AsyncIO___
-	 		free(subPath);
+		if(WriteCharAsync(bp, (UBYTE)c) != 1) {
-	 	}
+#else
 		if(fprintf(bp, "%c", c) != 1) {
-	 	closedir(dir);
+#endif
-		free(path);
+			fprintf(stderr, "Unable to write to '%s'.\n", b);
-	}
+			break;
+		}
 	if(verbose) {
+#if defined ___AsyncIO___
+	CloseAsync(ap);
+	CloseAsync(bp);
+#else
+	fclose(ap);
+	fclose(bp);
+#endif
+}
+/*
+	*
+	* Write lines to a file.
+	*/
+void WriteLinesToFile(char *dbFile, char **lines, unsigned int count) {
+#if defined ___AsyncIO___
+	struct AsyncFile *fp;
+#else
+	FILE *fp;
+#endif
-		fprintf(stdout, "\n");
+	int i;
-	}
+	char *rem;
-#if defined ___AsyncIO___
+	// Write the database lines back to the database.
-	CloseAsync(fp);
+#if defined ___AsyncIO___
-#else
-	fclose(fp);
+	if((fp = OpenAsync(dbFile, MODE_WRITE, ASYNC_BUF)) == NULL) {
+#else
+	if((fp = fopen(dbFile, "w")) == NULL) {
+#endif
+		fprintf(stderr, "Unable to open '%s' for writing.\n", dbFile);
+		return;
+	}
+	rem = NULL;
-#endif
+	for(i = 0; i < count; ++i) {
+#if defined ___AmigaOS___
 		// Check if CTRL+C was pressed and abort the program.
    	if(SetSignal(0L, SIGBREAKF_CTRL_C) & SIGBREAKF_CTRL_C) {
-/*
+			run = FALSE;
+			continue;
+		}
+#endif
+		if(rem != NULL) {
+#if defined ___AmigaOS___
+			if(StrnCmp(locale, lines[i], rem, -1, SC_ASCII) == 0) {
+#else
+			if(strncmp(lines[i], rem, strlen(rem)) == 0) {
+#endif
+				continue;
+			}
+		}
+#if defined ___AsyncIO___
+		WriteAsync(fp, lines[i], (LONG)strlen(lines[i]));
+		WriteAsync(fp, "\n", 1);
+#else
+		fprintf(fp, "%s\n", lines[i]);
+#endif
+		if(rem != NULL) {
+			free(rem);
+		}
+		rem = malloc(strlen(lines[i]) + 1);
+		sprintf(rem, "%s", lines[i]);
+	}
+#if defined ___AsyncIO___
+	CloseAsync(fp);
+#else
+	fclose(fp);
+#endif
+}
+/*
+	*
+	* Create a database entry from a line of text.
+	*/
+dbEntry* CreateDataseEntry(char *line) {
+	dbEntry *entry;
+	char *ptr;
+	unsigned int side;
+	unsigned int i;
+	unsigned int j;
+	if((entry = malloc(1 * sizeof(*entry))) == NULL) {
+		fprintf(stderr, "Memory allocation failure.\n");
+		return NULL;
+	}
+	if((entry->name = malloc(strlen(line) * sizeof(*entry->name))) == NULL) {
+		fprintf(stderr, "Memory allocation failure.\n");
+		return NULL;
+	}
-	*
-	* Gets the size of a file "dbFle".
+	if((entry->path = malloc(strlen(line) * sizeof(*entry->path))) == NULL) {
-	*/
+		fprintf(stderr, "Memory allocation failure.\n");
-int GetFileSize(char *dbFile) {
+		return NULL;
-#if defined ___AsyncIO___
+	}
 	struct AsyncFile *fp;
-	LONG size;
+	for(ptr = line, side = 0, i = 0, j = 0; run && *ptr != '\0'; ++ptr) {
-#else
+#if defined ___AmigaOS___
-	FILE *fp;
+		// Check if CTRL+C was pressed and abort the program.
-	int size;
-#endif
+   	if(SetSignal(0L, SIGBREAKF_CTRL_C) & SIGBREAKF_CTRL_C) {
 			run = FALSE;
-#if defined ___AsyncIO___
-	if((fp = OpenAsync(dbFile, MODE_READ, ASYNC_BUF)) == NULL) {
+			continue;
+		}
+#endif
-#else
+		switch(*ptr) {
+			case '\t':
+				entry->name[i] = '\0';
+				++side;
+				break;
+			case '\n':
+				entry->path[j] = '\0';
+				return entry;
-	if((fp = fopen(dbFile, "r")) == NULL) {
+			default:
-#endif
+				switch(side) {
-		fprintf(stderr, "Unable to open '%s' for reading.\n", dbFile);
+					case 0:
-		return 0;
+						entry->name[i++] = *ptr;
 						break;
 					case 1:
-#if defined ___AsyncIO___
+						entry->path[j++] = *ptr;
-	SeekAsync(fp, 0, MODE_END);
+						break;
-	size = SeekAsync(fp, 0, MODE_CURRENT);
+				}
-#else
-	fseek(fp, 0L, SEEK_END);
+				break;
-	size = ftell(fp);
-#endif
 #if defined ___AsyncIO___
    CloseAsync(fp);
-#else
-	fclose(fp);
+	return entry;
 #endif
-	return size;
+/*
+	*
+	*
+	*/
-}
+dbArray *GetDatabaseArray(char *dbFile) {
+#if defined ___AsyncIO___
+	struct AsyncFile *fp;
+#else
+	FILE *fp;
+#endif
+	dbArray *array;
+	dbEntry *entry;
+	char *line;
+	unsigned int count;
+	if((array = malloc(1 * sizeof(*array))) == NULL) {
-/*
+		fprintf(stderr, "Memory allocation failure.\n");
+		return NULL;
+	}
-	*
+	// Open database file for reading.
+#if defined ___AsyncIO___
+	if((fp = OpenAsync(dbFile, MODE_READ, ASYNC_BUF)) == NULL) {
-	* Counts the lines of a file.
+#else
+	if((fp = fopen(dbFile, "r")) == NULL) {
+#endif
+		fprintf(stderr, "Unable to open '%s' for reading.\n", dbFile);
+		return NULL;
+	}
 	*/
-int CountFileLines(char *dbFile) {
+	count = 0;
-#if defined ___AsyncIO___
+	while(run && (line = ReadLine(fp)) != NULL) {
-	struct AsyncFile *fp;
+#if defined ___AmigaOS___
-	LONG c;
+		// Check if CTRL+C was pressed and abort the program.
-#else
+   	if(SetSignal(0L, SIGBREAKF_CTRL_C) & SIGBREAKF_CTRL_C) {
+			run = FALSE;
-	FILE *fp;
+			continue;
 	char c;
 #endif
-	int lines;
+		if((entry = CreateDataseEntry(line)) == NULL) {
+			fprintf(stderr, "Unable to create database entry.\n");
 #if defined ___AsyncIO___
+			CloseAsync(fp);
+#else
+			fclose(fp);
+#endif
+			return NULL;
+		}
+		// Load up the name and path into the database variable.
-	if((fp = OpenAsync(dbFile, MODE_READ, ASYNC_BUF)) == NULL) {
+		array->database = realloc(array->database, (count + 1) * sizeof(*array->database));
+		if((array->database[count] = malloc((strlen(entry->name) + strlen(entry->path) + 1 + 1) * sizeof(*array->database[count]))) == NULL) {
+			fprintf(stderr, "Memory allocation failure.\n");
+			free(entry);
+			free(line);
+#if defined ___AsyncIO___
+			CloseAsync(fp);
+#else
+			fclose(fp);
+#endif
+			return NULL;
+		}
+		sprintf(array->database[count], "%s\t%s", entry->name, entry->path);
+		++count;
+		free(entry);
+		free(line);
+	}
+#if defined ___AsyncIO___
+	CloseAsync(fp);
+#else
+	fclose(fp);
+#endif
-#else
+	array->count = count;
+	return array;
+}
+/*
-	if((fp = fopen(dbFile, "r")) == NULL) {
+	*
+	* Sorts a database file lexicographically.
+	*/
+void SortDatabase(char *dbFile) {
+	dbArray *array;
+	if(verbose) {
+		fprintf(stdout, "Sorting '%s'...\n", dbFile);
+	}
+	// Retrieve the database as an array.
+	if((array = GetDatabaseArray(dbFile)) == NULL) {
+		fprintf(stderr, "Unable to read '%s' as a database file.\n", dbFile);
+		return;
+	}
-#endif
+	// Sort the database.
+	qsort(array->database, array->count, sizeof(char *), QsortCompare);
+	// Write back the database to the database file.
+	WriteLinesToFile(dbFile, array->database, array->count);
+	free(array);
+}
+/*
+	*
+	* Updates a database file "dbFile".
+	*/
+stats *CollectFiles(char *dbFile, char **paths, unsigned int count) {
+#if defined ___AsyncIO___
+	struct AsyncFile *fp;
+#else
+	FILE *fp;
+#endif
-		fprintf(stderr, "Unable to open '%s' for reading.\n", dbFile);
+	stringStack *stack;
-		return 0;
+	stats *stats;
 	DIR *dir;
+	struct dirent *entry;
+	struct stat dirStat;
-	lines = 0;
+	unsigned int size;
+	int i;
+	char *path;
+	char *subPath;
-#if defined ___AsyncIO___
+	// Initialize metrics.
-	while(run && (c = ReadCharAsync(fp)) != -1) {
+ 	if((stats = malloc(sizeof(stats))) == NULL) {
-#else
+ 		fprintf(stderr, "Memory allocation failure.\n");
-	while(run && fscanf(fp, "%c", &c) == 1) {
+ 		return NULL;
 #endif
 #if defined ___AmigaOS___
-		// Check if CTRL+C was pressed and abort the program.
+ 	stats->dirs = 0;
-		if(SetSignal(0L, SIGBREAKF_CTRL_C) & SIGBREAKF_CTRL_C) {
+ 	stats->files = 0;
-			run = FALSE;
+#if defined ___AsyncIO___
-			continue;
-		}
-#endif
+	if((fp = OpenAsync(dbFile, MODE_APPEND, ASYNC_BUF)) == NULL) {
-		switch(c) {
+#else
+	if((fp = fopen(dbFile, "r+")) == NULL) {
-			case '\n':
+#endif
+		fprintf(stderr, "Unable to open '%s' for writing.\n", dbFile);
+		return stats;
+	}
+	// Seek to the end of the database.
+#if defined ___AsyncIO___
+	if(SeekAsync(fp, 0, MODE_END) == -1) {
+#else
+	if(fseek(fp, 0, SEEK_END) == 0) {
+#endif
+		fprintf(stderr, "Unable to seek in '%s' for appending.\n", dbFile);
+#if defined ___AsyncIO___
+		CloseAsync(fp);
+#else
+		fclose(fp);
+#endif
+		return stats;
+	}
+	if(verbose) {
+		fprintf(stdout, "Collecting files...\r");
+	}
+	// Push the first path onto the stack.
+	stack = stringStackCreate(count);
+	for(i = 0; run && i < count; ++i) {
+		stringStackPush(stack, paths[i]);
+	}
+	while(run && !stringStackIsEmpty(stack)) {
+#if defined ___AmigaOS___
+		// Check if CTRL+C was pressed and abort the program.
+		if(SetSignal(0L, SIGBREAKF_CTRL_C) & SIGBREAKF_CTRL_C) {
+			run = FALSE;
+			continue;
+		}
+#endif
+		if((path = stringStackPop(stack)) == NULL) {
+			break;
+		}
+		if((dir = opendir(path)) == NULL) {
+			fprintf(stderr, "Unable to open '%s' for reading.\n", path);
+			break;
+		}
+		while(run && (entry = readdir(dir)) != NULL) {
+#if defined ___AmigaOS___
+			// Check if CTRL+C was pressed and abort the program.
+			if(SetSignal(0L, SIGBREAKF_CTRL_C) & SIGBREAKF_CTRL_C) {
+				run = FALSE;
+				continue;
+			}
+#endif
+			size = sizeof(path) + sizeof(entry->d_name) + 1;
+			switch(path[strlen(path) - 1]) {
+				case '/':
+	 			case ':': // This is a drive path.
+	 				if((subPath = malloc(size)) == NULL) {
+	 					fprintf(stderr, "Memory allocation failure.\n");
+	 					closedir(dir);
+	 					free(path);
+	 					stringStackDestroy(stack);
+#if defined ___AsyncIO___
+						CloseAsync(fp);
+#else
+						fclose(fp);
+#endif
+	 					return NULL;
+	 				}
+	 				sprintf(subPath, "%s%s", path, entry->d_name);
+	 				break;
+	 			default:
+	 				if((subPath = malloc(size + 1)) == NULL) {
+	 					fprintf(stderr, "Memory allocation failure.\n");
+	 					closedir(dir);
+	 					free(path);
+	 					stringStackDestroy(stack);
+#if defined ___AsyncIO___
+						CloseAsync(fp);
+#else
+						fclose(fp);
+#endif
+	 					return NULL;
+	 				}
+	 				sprintf(subPath, "%s/%s", path, entry->d_name);
-				++lines;
+	 				break;
 				break;
 			stat(subPath, &dirStat);
 			if(S_ISDIR(dirStat.st_mode)) {
+	 			stringStackPush(stack, subPath);
+	 			++stats->dirs;
+	 			if(verbose) {
+	 				fprintf(stdout,
+	 					"Gathered %d directories and %d files.\r",
+	 					stats->dirs,
+	 					stats->files);
+	 			}
 #if defined ___AsyncIO___
-	CloseAsync(fp);
+	 			free(subPath);
-#else
+	 			continue;
 	fclose(fp);
 #else
 	FILE *fp, *tp;
 	char c;
 #endif
 	int lines;
-	int linesWritten;
+	int write;
 #if defined ___AsyncIO___
 	if((fp = OpenAsync(dbFile, MODE_READ, ASYNC_BUF)) == NULL) {
 #else
 	if(verbose) {
 		fprintf(stdout, "Writing to temporary files...\r");
 	}
-	linesWritten = 0;
+	write = 0;
 	lines = 0;
 #if defined ___AsyncIO___
 	while(run && (c = ReadCharAsync(fp)) != -1) {
+		}
 #endif
 		switch(c) {
 			case '\n':
 				// Increment the total written lines.
-				++linesWritten;
+				++write;
 				if(verbose) {
-					fprintf(stdout, "Writing to temporary files: %d%%.\r", (int)(((float)linesWritten / total) * 100.0));
+					fprintf(stdout, "Writing to temporary files: %d%%.\r", (int)(((float)write / total) * 100.0));
+				}
 				// Write the newline character back.
 #endif
+}
 /*
-	*
-	* Skips a line in a file.
-	*/
-#if defined ___AsyncIO___
-void SkipLine(struct AsyncFile *fp) {
-	LONG c;
-	while(run && (c = ReadCharAsync(fp)) != -1) {
-#else
-void SkipDatabaseLine(FILE *fp) {
-	char c;
-	while(run && fscanf(fp, "%c", &c) == 1) {
-#endif
-#if defined ___AmigaOS___
-		// Check if CTRL+C was pressed and abort the program.
-		if(SetSignal(0L, SIGBREAKF_CTRL_C) & SIGBREAKF_CTRL_C) {
-			run = FALSE;
-			continue;
-		}
-#endif
-		switch(c) {
-			case '\n':
-				return;
-		}
-	}
-}
-/*
-	*
-	* Reads a line from a file.
-	*/
-#if defined ___AsyncIO___
-char *ReadLine(struct AsyncFile *fp) {
-	LONG c;
-#else
-char *ReadLine(FILE *fp) {
-	char c;
-#endif
-	char *line;
-	int line_size;
-	int i;
-	line_size = LINE_BUF;
-	line = malloc(line_size * sizeof(*line));
-	i = 0;
-#if defined ___AsyncIO___
-	while(run && (c = ReadCharAsync(fp)) != -1) {
-#else
-	while(run && fscanf(fp, "%c", &c) == 1) {
-#endif
-#if defined ___AmigaOS___
-		// Check if CTRL+C was pressed and abort the program.
-		if(SetSignal(0L, SIGBREAKF_CTRL_C) & SIGBREAKF_CTRL_C) {
-			run = FALSE;
-			continue;
-		}
-#endif
-		switch(c) {
-			case '\n':
-				// Rewind the file by the number of read characters.
-#if defined ___AsyncIO___
-				if(SeekAsync(fp, -(i + 1), MODE_CURRENT) == -1) {
-					fprintf(stderr, "Could not seek in file.\n");
-					return NULL;
-				}
-#else
-				fseek(fp, -(i + 1), SEEK_CUR);
-#endif
-				return line;
-			default:
-				if(strlen(line) == line_size) {
-					line_size = line_size * 1.5;
-					line = realloc(line, line_size * sizeof(*line));
-				}
-				//line = realloc(line, (chars + 1 + 1) * sizeof(char));
-				line[i] = c;
-				line[i + 1] = '\0';
-				break;
-		}
-		++i;
-	}
-	return NULL;
-}
-/*
+	*
 	* Merges temporary files "tmpNames" into a database "dbFile".
 	*/
 void MergeTemporaryFiles(char *dbFile, char **tmpNames, int files, int lines) {
 #if defined ___AsyncIO___
 	FILE **tp;
 #endif
 	int i;
 	int j;
 	char *tmp;
+	char *rem;
 	char *min;
 	int count;
 #if defined ___AsyncIO___
 		fprintf(stderr, "Unable to open '%s' for writing.\n", dbFile);
 		return;
+	}
 	// Allocate as many file pointers as temporary files.
+	if((tp = malloc(files * sizeof(*tp))) == NULL) {
+		fprintf(stderr, "Memory allocation failure.\n");
+#if defined ___AsyncIO___
+		CloseAsync(fp);
+#else
+		fclose(fp);
+#endif
+		return;
 	tp = malloc(files * sizeof(*tp));
 	// Open all temporary files for reading.
 	for(i = 0; i < files; ++i) {
 	if(verbose) {
 		fprintf(stdout, "Merging all files...\r");
+	}
 	rem = NULL;
 	count = lines;
 	j = 0;
 	while(run && --count > -1) {
 			fprintf(stdout, "Merging all files: %d%%.\r", 100 - (int)(((float)count / lines) * 100.0));
+		}
 		min = NULL;
 		for(i = 0; i < files; ++i) {
-			tmp = ReadLine(tp[i]);
+			tmp = PeekLine(tp[i]);
 			if(tmp == NULL) {
 				continue;
+			}
+#if defined ___AmigaOS___
+			if(min == NULL || StrnCmp(locale, tmp, min, -1, SC_ASCII) < 0) {
 #else
+			if(min == NULL || strncmp(tmp, min, strlen(tmp)) < 0) {
-			if(min == NULL || strncmp(tmp, min, strlen(tmp)) < 0) {
+#endif
 				if(min != NULL) {
 					// Free previous instance.
 					free(min);
 				}
+				if((min = malloc((strlen(tmp) + 1) * sizeof(*min))) == NULL) {
+					fprintf(stderr, "Memory allication failure.\n");
+					free(tmp);
+					if(min != NULL) {
+						free(min);
+					}
+					if(rem != NULL) {
+						free(rem);
+					}
+#if defined ___AsyncIO___
+					CloseAsync(fp);
+#else
+					fclose(fp);
+#endif
+					return;
 				min = malloc((strlen(tmp) + 1) * sizeof(*min));
 				sprintf(min, "%s", tmp);
 				// Remember the index of the file where the smallest entry has been found.
-				j = i;
-				free(tmp);
-				continue;
+				j = i;
+			}
 			free(tmp);
+		}
 		// Forward the file where the smallest line was found.
 		SkipLine(tp[j]);
+		// Write the smallest line.
+		if(min != NULL) {
+			// If current minimum line is identical to previous minimum line then skip to remove duplicates.
+			if(rem != NULL) {
+#if defined ___AmigaOS___
+				if(StrnCmp(locale, min, rem, -1, SC_ASCII) == 0) {
+#else
+				if(strncmp(min, rem, strlen(rem)) == 0 {
+#endif
+					free(min);
+					continue;
+				}
-		// Write the smallest line.
+			}
-		if(min != NULL) {
 #if defined ___AsyncIO___
-			WriteAsync(fp, min, (LONG)(strlen(min) * sizeof(char)));
+			WriteAsync(fp, min, (LONG)strlen(min));
-			WriteAsync(fp, "\n", 1 * sizeof(char));
+			WriteAsync(fp, "\n", 1);
+#else
+			fprintf(fp, "%s\n", min);
+#endif
+			if(rem != NULL) {
+				free(rem);
+			}
+			if((rem = malloc((strlen(min) + 1) * sizeof(*rem))) == NULL) {
+				fprintf(stderr, "Memory allocation failure.\n");
+				free(min);
+#if defined ___AsyncIO___
+				CloseAsync(fp);
+#else
+				fclose(fp);
+#endif
+				return;
 #else
 			fprintf(fp, "%s\n", min);
-#endif
+			sprintf(rem, "%s", min);
+			free(min);
+		}
+	}
-			free(min);
+	if(rem != NULL) {
 		free(rem);
+	}
 	// Write out any remaining contents from the temporary files.
 		tmp = ReadLine(tp[i]);
 		if(tmp == NULL) {
 			continue;
+		}
 #if defined ___AsyncIO___
-		WriteAsync(fp, tmp, (LONG)(strlen(tmp) * sizeof(char)));
+		WriteAsync(fp, tmp, (LONG)strlen(tmp));
-		WriteAsync(fp, "\n", 1 * sizeof(char));
+		WriteAsync(fp, "\n", 1);
 #else
 		fprintf(fp, "%s\n", tmp);
 #endif
 		free(tmp);
+	}
 	fclose(fp);
 #endif
+}
 /*
-	*
+  *
-	* Deletes temporary files.
+  * Filter the paths inside the database with provided paths.
-	*/
+  */
+void FilterDatabasePaths(char *dbFile, char *tmpName, char **paths, unsigned int count) {
+#if defined ___AsyncIO___
-void DeleteTemporaryFiles(char **tmpNames, int tmpFiles) {
+	struct AsyncFile *fp;
+	struct AsyncFile *tp;
+#else
+	FILE *fp;
+	FILE *tp;
+#endif
+	char *line;
+	int i;
+	dbEntry *entry;
+	// Open database file for reading.
-	int i = tmpFiles;
+#if defined ___AsyncIO___
+	if((fp = OpenAsync(dbFile, MODE_READ, ASYNC_BUF)) == NULL) {
+#else
+	if((fp = fopen(dbFile, "r")) == NULL) {
+#endif
-	if(verbose) {
+		fprintf(stderr, "Unable to open '%s' for reading.\n", dbFile);
+		return;
+	}
-		fprintf(stdout, "Deleting temporary files...\r");
+	// Open temporary file for writing.
-	}
+#if defined ___AsyncIO___
+	if((tp = OpenAsync(tmpName, MODE_WRITE, ASYNC_BUF)) == NULL) {
+#else
+	if((tp = fopen(tmpName, "w")) == NULL) {
+#endif
+		fprintf(stderr, "Unable to open '%s' for writing.\n", tmpName);
-	do {
+		// Close database file.
+#if defined ___AsyncIO___
+		CloseAsync(fp);
+#else
+		fclose(fp);
+#endif
+		return;
+	}
+	while(run && (line = ReadLine(fp)) != NULL) {
+#if defined ___AmigaOS___
+		// Check if CTRL+C was pressed and abort the program.
+   	if(SetSignal(0L, SIGBREAKF_CTRL_C) & SIGBREAKF_CTRL_C) {
+			run = FALSE;
+			continue;
+		}
+#endif
+		if((entry = CreateDataseEntry(line)) == NULL) {
+			fprintf(stderr, "Unable to create database entry.\n");
+			continue;
+		}
+		for(i = 0; i < count; ++i) {
+			if(PathCompare(entry->path, paths[i]) == TRUE) {
-		remove(tmpNames[i]);
+				continue;
+			}
+#if defined ___AsyncIO___
+			WriteAsync(tp, line, (LONG)strlen(line));
+			WriteAsync(tp, "\n", 1);
+#else
+			fprintf(tp, "%s\n", line);
+#endif
+			break;
 	} while(--i > -1);
+		free(entry);
+		free(line);
+	}
+#if defined ___AsyncIO___
+	CloseAsync(fp);
+	CloseAsync(tp);
 #else
-	if(verbose) {
+	fclose(fp);
-		fprintf(stdout, "\n");
+	fclose(tp);
 #endif
+}
-/*
-	*
+/*
 	* Indexes a "path" by creating a database "dbFile".
+	* Indexes a "path" by creating a database "dbFile".
+	*/
+void GatherDatabaseFiles(char *dbFile, char **paths, unsigned int count) {
-	*/
+	stats *stats;
-void Gather(char *dbFile, char *path) {
+	char **tmpNames;
-	stringStack *stack = stringStackCreate(1);
-	stats *stats = malloc(sizeof(stats));
-	char **tmpNames;
-	int dbSize, dbLines, tmpFiles, tmpLines;
-	int i;
+	int dbSize;
+	int dbLines;
- 	// Initialize metrics.
- 	stats->dirs = 0;
+	int tmpFiles;
- 	stats->files = 0;
+	int tmpLines;
+	int i;
-	// Push the first path onto the stack.
-	stringStackPush(stack, path);
-	// Generate the database file.
+	// Generate the database file from the supplied paths.
+	if((stats = CollectFiles(dbFile, paths, count)) == NULL) {
+		fprintf(stderr, "Collecting files failed.\n");
+		return;
+	}
+	free(stats);
-	CollectFiles(dbFile, stack, stats);
+	// Compute the amount of temporary files needed.
-	// Get the database metrics.
+	dbSize = GetFileSize(dbFile);
+	if(dbSize == -1) {
-	dbSize = GetFileSize(dbFile);
+		fprintf(stderr, "File size for '%s' failed.\n", dbFile);
-	dbLines = CountFileLines(dbFile);
+		return;
+	}
-	// Compute the amount of temporary files needed.
+	tmpFiles = dbSize / maxmem;
+	/* In case no temporary files are required,
+	 * just sort the database and terminate.
+	 */
+	if(tmpFiles <= 1) {
-	tmpFiles = dbSize / MAX_MEM;
+		SortDatabase(dbFile);
 		return;
    // In case no temporary files are required,
 	// just sort the database and terminate.
 	// Merge all the temporary files to the database file.
 	MergeTemporaryFiles(dbFile, tmpNames, tmpFiles, dbLines);
+	// Remove all temporary files.
+	RemoveFiles(tmpNames, tmpFiles);
+	free(tmpNames);
+}
+void RemoveDatabaseFiles(char *dbFile, char **paths, unsigned int count) {
+	char *tmpName;
+	// Create a temporary file to hold the changes.
+	if((tmpName = CreateTemporaryFile()) == NULL) {
+		fprintf(stderr, "Unable to create temporary file.\n");
+		return;
+	}
+	// Filter the database of the provided paths.
+	FilterDatabasePaths(dbFile, tmpName, paths, count);
+	// Overwrite the database file with the filtered paths.
+	CopyFile(tmpName, dbFile);
-	// Remove all temporary files.
+	// Remove temporary file.
-	DeleteTemporaryFiles(tmpNames, tmpFiles);
+	RemoveFile(tmpName);
+}
-void usage(char *name) {
-	fprintf(stdout, "Hunt & Gather - %s, a file index generating tool.        \n", name);
-	fprintf(stdout, "Version: %s                                              \n", PROGRAM_VERSION);
+void usage(char *name) {
+	fprintf(stdout, "Hunt & Gather - %s, a file index generating tool.        \n", name);
+	fprintf(stdout, "Version: %s                                              \n", PROGRAM_VERSION);
+	fprintf(stdout, "                                                         \n");
+	fprintf(stdout, "SYNTAX: %s [-q] <-a|-r|-c> <PATH PATH PATH...>           \n", name);
+	fprintf(stdout, "                                                         \n");
+	fprintf(stdout, "Required:                                                \n");
+	fprintf(stdout, "    -a [PATH...]   Add files (default).                  \n");
+	fprintf(stdout, "    -c [PATH...]   Create database from scratch.         \n");
+	fprintf(stdout, "    -r [PATH...]   Remove files.                         \n");
+	fprintf(stdout, "                                                         \n");
-   fprintf(stdout, "                                                         \n");
+	fprintf(stdout, "Optional:                                                \n");
-	fprintf(stdout, "SYNTAX: %s [-q] DATABASE                                 \n", name);
+	fprintf(stdout, "    -d [FIILE]     Where to store the database.          \n");
-	fprintf(stdout, "                                                         \n");
+	fprintf(stdout, "    -m BYTES       Memory to use (default: %d).          \n", maxmem);
 	fprintf(stdout, "    -q             Do not print out any messages.        \n");
-   fprintf(stdout, "                                                         \n");
+	fprintf(stdout, "                                                         \n");
 	fprintf(stdout, "DATABASE is a path to where the indexed results will be  \n");
 	fprintf(stdout, "stored for searching with the Hunt tool.                 \n");
+	*
 	* Main entry point.
 	*/
 int main(int argc, char **argv) {
 	int option;
+	unsigned int i;
+	unsigned int count;
 	char *dbFile;
 	char *path;
+	char **paths;
 	struct stat dirStat;
-#if defined ___AmigaOS___
-	BPTR lock;
-#endif
+	// Bind handler to SIGINT.
-	// Bind handler to SIGINT.
+#if !defined ___AmigaOS___
+ 	signal(SIGINT, SignalHandler);
- 	signal(SIGINT, SignalHandler);
+#endif
 	dbFile = DEFAULT_DATABASE_FILE;
+	while((option = getopt(argc, argv, "hqdm:arc")) != -1) {
+		switch(option) {
+			case 'a':
+				operation = GATHER;
+				break;
+			case 'r':
+				operation = REMOVE;
+				break;
+			case 'c':
+				operation = CREATE;
+				break;
+			case 'm':
-	while((option = getopt(argc, argv, "hqd:")) != -1) {
+				maxmem = strtoul(optarg, NULL, 10);
-		switch(option) {
+				break;
 			case 'd':
 				dbFile = optarg;
 				break;
 				fprintf(stderr, "Invalid option %ct.\n", optopt);
 				return 1;
+		}
+	}
+	if(operation == NONE) {
+		usage(argv[0]);
+		return 1;
+	}
 	if(optind >= argc) {
 		usage(argv[0]);
-		return 1;
-	}
+		return 1;
-#if defined ___AmigaOS___
-	path = malloc(PATH_MAX * sizeof(*path));
-	lock = Lock(argv[optind], SHARED_LOCK);
-	NameFromLock(lock, path, PATH_MAX);
+	}
-	UnLock(lock);
-#else
-	path = realpath(argv[optind], NULL);
-#endif
-   stat(path, &dirStat);
+	// Go through all supplied arguments and add paths to search.
-	if(!S_ISDIR(dirStat.st_mode)) {
+	if((paths = malloc((argc - optind) * sizeof(*paths))) == NULL) {
+		fprintf(stderr, "Memory allocation failure.\n");
+		return 1;
+	}
+	for(i = optind, count = 0; i < argc; ++i, ++count) {
+		if((path = PathToAbsolute(argv[optind])) == NULL) {
+			fprintf(stderr, "Absolute path for '%s' failed to resolve.\n", argv[optind]);
+			continue;
+		}
+		// Check that the path is a directory.
+		stat(path, &dirStat);
+		if(!S_ISDIR(dirStat.st_mode)) {
+			fprintf(stderr, "Path '%s' is not a directory.\n", argv[optind]);
+			free(path);
+			return 1;
+		}
+		if(verbose) {
+			fprintf(stdout, "Will process path: '%s'\n", path);
+		}
+		// Add the path to the array of paths.
+		if((paths[count] = malloc(strlen(path) * sizeof(*paths[count]))) == NULL) {
+			fprintf(stderr, "Memory allocation failure.");
+			return 1;
+		}
-		fprintf(stderr, "Path '%s' is not a directory.\n", argv[optind]);
+		sprintf(paths[count], "%s", path);
-		return 1;
+		free(path);
+	}
+	if(verbose) {
+   		fprintf(stdout, "Gathering to: '%s'\n", dbFile);
+	}
+#if defined ___AmigaOS___
+	locale = OpenLocale(NULL);
+#endif
+ 	// Gather.
-	if(verbose) {
+ 	switch(operation) {
+ 		case CREATE:
+ 			if(verbose) {
+ 				fprintf(stdout, "Removing '%s' and creating a new database.\n", dbFile);
+ 			}
+ 			RemoveFile(dbFile);
+ 		case GATHER:
+ 			if(verbose) {
+ 				fprintf(stdout, "Gathering files to database...\n");
+ 			}
+ 			GatherDatabaseFiles(dbFile, paths, count);
+ 			break;
+ 		case REMOVE:
+ 			if(verbose) {
+ 				fprintf(stdout, "Removing files from database...\n");
+ 			}
+ 			RemoveDatabaseFiles(dbFile, paths, count);
+ 			break;
+ 		default:
+ 			break;
-   	fprintf(stdout, "Gathering to %s\n", dbFile);
+ 	}
-	}
 #if defined ___AmigaOS___