HuntnGather – Diff between revs 32 and 33

Subversion Repositories:

?pathlinks?

Rev 32 – Rev 37 – Go to most recent revision – Details – Blame – Last modification – View Log

 #if defined ___AmigaOS___
 #include <proto/dos.h>
 #include <proto/exec.h>
+#include <proto/locale.h>
-#include <proto/locale.h>
+#include <clib/utility_protos.h>
 #endif
 #if defined ___AsyncIO___
 #include <asyncio.h>
 #endif
 #if !defined ___HAVE_GETOPT___
+#include "/shared/getopt.h"
-#include "getopt.h"
+#endif
 #endif
 #include "StringStack.h"
 /*************************************************************************/
 TEXT version_string[] =
 	"\0$VER: Gather " PROGRAM_VERSION " "__DATE__" by Wizardry and Steamworks";
 #endif
-#if !defined TRUE
-#define TRUE 1;
-#endif
-#if !defined FALSE
-#define FALSE 0;
-#endif
-#define ASYNC_BUF 8192
+int PROGRAM_RUN = TRUE;
-#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;
+int PROGRAM_VERBOSE = TRUE;
-	unsigned int count;
-} dbArray;
-enum MODE {
-	NONE,
-	GATHER,
-	REMOVE,
-	CREATE
-} operation;
-unsigned int run = TRUE;
-unsigned int verbose = TRUE;
+int maxmem = MAX_MEM;
 unsigned int maxmem = MAX_MEM;
 // Define global locale for string compare.
 #if defined ___AmigaOS___
 struct Locale *locale;
 #endif
 void SignalHandler(int sig) {
-	// Toggle the run flag to stop execution.
+	/* Toggle the run flag to stop execution. */
-	run = FALSE;
+	PROGRAM_RUN = FALSE;
+}
 #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);
-	if((abs = malloc((strlen(path) + 1) * sizeof(*abs))) == NULL) {
-		fprintf(stderr, "Memory allocation failure.\n");
-		return NULL;
-	}
-	sprintf(abs, "%s", path);
-#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';
-}
-/*
-	*
-	* Gets the size of a file by name.
+	* Sorts a database file lexicographically.
 	*/
-int GetFileSize(char *dbFile) {
+void SortDatabase(char *dbFile, int lines) {
 #if defined ___AsyncIO___
-	struct AsyncFile *fp;
-	LONG size;
+	struct AsyncFile *fp;
 #else
-	FILE *fp;
-	int size;
+	FILE *fp;
+#endif
+	char **database;
+	dbEntry *entry;
+	char *line = NULL;
+	char *rem;
+	int count;
+	int i;
 #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);
+		fprintf(stderr, "Could not open file '%s' for reading.\n", dbFile);
+		return;
+	}
 		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
-		return -1;
-	}
-#if defined ___AsyncIO___
+	if((database = malloc(lines * sizeof(*database))) == NULL) {
-	if((size = SeekAsync(fp, 0, MODE_CURRENT)) == -1) {
-		fprintf(stderr, "Seek in file %s failed.\n", dbFile);
-		CloseAsync(fp);
-		return -1;
-	}
-#else
-	size = ftell(fp);
-#endif
-#if defined ___AsyncIO___
-   CloseAsync(fp);
-#else
-	fclose(fp);
-#endif
-	return size;
-}
-/*
-	*
-	* Counts the lines of a file.
-	*/
-int CountFileLines(char *dbFile) {
-#if defined ___AsyncIO___
+		fprintf(stderr, "Memory allocation failure.\n");
-	struct AsyncFile *fp;
+#if defined ___AsyncIO___
-	LONG c;
-#else
-	FILE *fp;
-	char c;
-#endif
-	int lines;
-#if defined ___AsyncIO___
-	if((fp = OpenAsync(dbFile, MODE_READ, ASYNC_BUF)) == NULL) {
+		CloseAsync(fp);
-#else
-	if((fp = fopen(dbFile, "r")) == NULL) {
+#else
-#endif
+		fclose(fp);
-		fprintf(stderr, "Unable to open '%s' for reading.\n", dbFile);
-		return -1;
+#endif
-	}
+		return;
+	}
-	lines = 0;
-	if(verbose) {
+	if(PROGRAM_VERBOSE) {
-		fprintf(stdout, "Lines in '%s' so far: %d\r", dbFile, lines);
-	}
-#if defined ___AsyncIO___
+		fprintf(stdout, "Reading lines from file '%s' to array...\n", dbFile);
 	while(run && (c = ReadCharAsync(fp)) != -1) {
-#else
-	while(run && fscanf(fp, "%c", &c) == 1) {
+	count = 0;
-#endif
+	while(PROGRAM_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(SetSignal(0L, SIGBREAKF_CTRL_C) & SIGBREAKF_CTRL_C) {
-		switch(c) {
+			PROGRAM_RUN = FALSE;
-			case '\n':
-				++lines;
+			continue;
-				if(verbose) {
-					fprintf(stdout, "Lines in '%s' so far: %d\r", dbFile, lines);
+		}
-				break;
+#endif
 		if((entry = CreateDatabaseEntry(line)) == NULL) {
-	}
+			fprintf(stderr, "Unable to create database entry.\n");
-#if defined ___AsyncIO___
-	CloseAsync(fp);
-#else
-	fclose(fp);
-#endif
-	if(verbose) {
-		fprintf(stdout, "\n");
-	}
-	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(verbose) {
-		fprintf(stdout, "Creating temporary files...\r");
-	}
-	count = files;
-	while(run && --count > -1) {
-#if defined ___AmigaOS___
-		// Check if CTRL+C was pressed and abort the program.
+			free(line);
-		if(SetSignal(0L, SIGBREAKF_CTRL_C) & SIGBREAKF_CTRL_C) {
-			run = FALSE;
-			continue;
+#if defined ___AsyncIO___
-		}
-#endif
+			CloseAsync(fp);
-		tmpNames[count] = CreateTemporaryFile();
-		if(verbose) {
-			fprintf(stdout, "Creating temporary files: %d%%\r", 100 - (int)(((float)count / files) * 100.0));
-		}
+#else
+			fclose(fp);
-	}
+#endif
-	if(verbose) {
-		fprintf(stdout, "\n");
-	}
+			return;
-	return tmpNames;
+		}
-}
 		if((database[count] = malloc((strlen(entry->name) + strlen(entry->path) + 1 + 1) * sizeof(*database[count]))) == NULL) {
+			fprintf(stderr, "Memory allocation failure.\n");
-/*
-	*
-	* Skips a line in a file.
+			free(entry->name);
-	*/
-#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) {
+			free(entry->path);
-#endif
-#if defined ___AmigaOS___
+			free(entry);
-		// Check if CTRL+C was pressed and abort the program.
-		if(SetSignal(0L, SIGBREAKF_CTRL_C) & SIGBREAKF_CTRL_C) {
-			run = FALSE;
+			free(line);
-			continue;
+#if defined ___AsyncIO___
-		}
-#endif
-		switch(c) {
-			case '\n':
-				return;
-		}
-	}
-}
-/*
-	*
-	* Peeks at a line from a file.
-	*/
-#if defined ___AsyncIO___
-char *PeekLine(struct AsyncFile *fp) {
-	LONG c;
-#else
-char *PeekLine(FILE *fp) {
-	char c;
-#endif
-	char *line = NULL;
+			CloseAsync(fp);
-	char *real = NULL;
+#else
-	unsigned int size;
-	int i;
+			fclose(fp);
-	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
-#endif
+			return;
-		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;
-				}
-#else
-				if(fseek(fp, -(i + 1), SEEK_CUR) != 0) {
-					fprintf(stderr, "Could not seek in file.\n");
-					free(line);
-					return NULL;
-				}
-#endif
-				return line;
-			default:
-				if(strlen(line) == size) {
-					size = size * 1.5;
-					real = realloc(line, size * sizeof(*line));
-					if(real == NULL) {
-						fprintf(stderr, "Memory reallocation failure.\n");
-						free(line);
-						return NULL;
-					}
-					line = real;
-				line[i] = c;
+		sprintf(database[count], "%s\t%s", entry->name, entry->path);
-				line[i + 1] = '\0';
-				break;
-		}
-		++i;
-	}
-	if(line != NULL) {
-		free(line);
-	}
-	return NULL;
-}
-/*
-	*
-	* Read 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 = NULL;
-	char *real = NULL;
-	unsigned int size;
-	unsigned int i;
-	size = LINE_BUF;
-	if((line = malloc(size * sizeof(*line))) == NULL) {
-		fprintf(stderr, "Memory allication 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':
-				return line;
-			default:
-				if(strlen(line) == size) {
-					size = size * 1.5;
-					real = realloc(line, size * sizeof(*line));
-					if(real == NULL) {
-						fprintf(stderr, "Memory reallocation failure.\n");
-						free(line);
-						return NULL;
 		++count;
 					line = real;
 		// Free the database entry.
-				line[i] = c;
-				line[i + 1] = '\0';
-				break;
-		}
-		++i;
-	}
-	if(line != NULL) {
-		free(line);
-	}
-	return NULL;
-}
-/*
-  *
-  * Delete a file.
-  */
-#if defined ___AmigaOS___
-BOOL RemoveFile(char *name) {
-	return DeleteFile(name);
-#else
-int RemoveFile(char *name) {
-	return remove(name) == 0;
-#endif
-}
-/*
-	*
-	* Deletes files.
-	*/
-void RemoveFiles(char **names, int count) {
-	unsigned int i;
-	for(i = 0; i < count; ++i) {
-		if(RemoveFile(names[i]) == FALSE) {
-			fprintf(stderr, "Unable to remove %s...\n", names[i]);
-			continue;
+		free(entry->name);
-		}
-		fprintf(stderr, "Removing file: %s\n", names[i]);
+		free(entry->path);
-	}
 		free(entry);
-/*
-	*
-	* Copies a file to another file by name.
+		free(line);
-	*/
-void CopyFile(char *a, char *b) {
+	}
-#if defined ___AsyncIO___
-	struct AsyncFile *ap;
-	struct AsyncFile *bp;
-	LONG c;
-#else
-	FILE *ap;
-	FILE *bp;
+	if(line != NULL) {
-	char c;
+		free(line);
-#endif
-	// 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((bp = fopen(b, "w")) == NULL) {
-#endif
-		fprintf(stderr, "Unable to open file '%s' for writing.\n", b);
-		// Close database file.
-#if defined ___AsyncIO___
-		CloseAsync(ap);
-#else
-		fclose(ap);
-#endif
-		return;
-	}
-#if defined ___AsyncIO___
-	while(run && (c = ReadCharAsync(ap)) != -1) {
-#else
-	while(run && fscanf(ap, "%c", &c) == 1) {
+#if defined ___AsyncIO___
-#endif
-#if defined ___AmigaOS___
-		// Check if CTRL+C was pressed and abort the program.
+	CloseAsync(fp);
-   		if(SetSignal(0L, SIGBREAKF_CTRL_C) & SIGBREAKF_CTRL_C) {
-			run = FALSE;
-			continue;
-		}
-#endif
-#if defined ___AsyncIO___
-		if(WriteCharAsync(bp, (UBYTE)c) != 1) {
-#else
-		if(fprintf(bp, "%c", c) != 1) {
-#endif
-			fprintf(stderr, "Unable to write to '%s'.\n", b);
-			break;
-		}
-	}
-#if defined ___AsyncIO___
-	CloseAsync(ap);
-	CloseAsync(bp);
-#else
-	fclose(ap);
-	fclose(bp);
-#endif
 #else
 	fclose(fp);
-/*
+#endif
-	* Write lines to a file.
+	if(PROGRAM_VERBOSE) {
-	*/
+		fprintf(stdout, "Sorting %d lines in '%s'...\n", count, dbFile);
-void WriteLinesToFile(char *dbFile, char **lines, unsigned int count) {
+	}
 #if defined ___AsyncIO___
-	struct AsyncFile *fp;
+	// Sort the database.
-#else
+	qsort(database, (unsigned int)count, sizeof(char *), QsortCompare);
-	FILE *fp;
-#endif
+	if(PROGRAM_VERBOSE) {
-	unsigned int i;
+		fprintf(stdout, "Writing %d sorted lines to '%s'...\n", count, dbFile);
 	char *rem;
 	// Write the database lines back to the database.
 #if defined ___AsyncIO___
 	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);
+		fprintf(stderr, "Could not open file '%s' for writing.\n", dbFile);
 		return;
+	}
 	rem = NULL;
-	for(i = 0; i < count; ++i) {
+	for(i = 0; PROGRAM_RUN && 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;
+			PROGRAM_RUN = FALSE;
 			continue;
+		}
 #endif
 		if(rem != NULL) {
 #if defined ___AmigaOS___
-			if(StrnCmp(locale, lines[i], rem, -1, SC_ASCII) == 0) {
+			if(StrnCmp(locale, database[i], rem, -1, SC_ASCII) == 0) {
 #else
-			if(strcmp(lines[i], rem) == 0) {
+			if(strcmp(database[i], rem) == 0) {
 #endif
 				continue;
 #if defined ___AsyncIO___
 	CloseAsync(fp);
 #else
 	fclose(fp);
 #endif
-}
-/*
-	*
-	* Create a database entry from a line of text.
-	*/
-dbEntry* CreateDatabaseEntry(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) + 1) * sizeof(*entry->name))) == NULL) {
-		fprintf(stderr, "Memory allocation failure.\n");
-		return NULL;
-	}
-	if((entry->path = malloc((strlen(line) + 1) * sizeof(*entry->path))) == NULL) {
-		fprintf(stderr, "Memory allocation failure.\n");
-		return NULL;
-	}
-	for(ptr = line, side = 0, i = 0, j = 0; run && *ptr != '\0'; ++ptr) {
-#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(*ptr) {
-			case '\t':
-				entry->name[i] = '\0';
-				++side;
-				break;
-			case '\n':
-				entry->path[j] = '\0';
-				return entry;
-			default:
-				switch(side) {
-					case 0:
-						entry->name[i++] = *ptr;
-						break;
-					case 1:
-						entry->path[j++] = *ptr;
-						break;
-				}
-				break;
-		}
-	}
-	return entry;
-}
-/*
-	*
-	*
-	*/
-dbArray *GetDatabaseArray(char *dbFile) {
-#if defined ___AsyncIO___
-	struct AsyncFile *fp;
-#else
-	FILE *fp;
-#endif
-	dbArray *array;
-	char **real = NULL;
-	dbEntry *entry;
-	char *line = NULL;
-	unsigned int count;
-	// 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 NULL;
-	}
-	if((array = malloc(1 * sizeof(*array))) == NULL) {
+	if(PROGRAM_VERBOSE) {
-		fprintf(stderr, "Memory allocation failure.\n");
-#if defined ___AsyncIO___
-		CloseAsync(fp);
-#else
-		fclose(fp);
-#endif
-		return NULL;
+		fprintf(stdout, "Disposing %d lines of file '%s'...\n", count, dbFile);
-	}
-	count = 0;
-	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 = CreateDatabaseEntry(line)) == NULL) {
-			fprintf(stderr, "Unable to create database entry.\n");
-			free(line);
-#if defined ___AsyncIO___
-			CloseAsync(fp);
-#else
-			fclose(fp);
-#endif
-			return NULL;
-		}
-		// Load up the name and path into the database variable.
-		real = realloc(array->database, (count + 1) * sizeof(*array->database));
-		if(real == NULL) {
-			fprintf(stderr, "Memory reallocation failure.\n");
-			free(entry->name);
-			free(entry->path);
-			free(entry);
-			free(line);
-#if defined ___AsyncIO___
-			CloseAsync(fp);
-#else
-			fclose(fp);
-#endif
-			return NULL;
-		}
-		array->database = real;
-		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->name);
-			free(entry->path);
-			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 the database entry.
-		free(entry->name);
-		free(entry->path);
-		free(entry);
-		free(line);
-	}
+	// Free up database.
-	if(line != NULL) {
+	for(i = 0; i < count; ++i) {
-		free(line);
-	}
-#if defined ___AsyncIO___
-	CloseAsync(fp);
-#else
-	fclose(fp);
-#endif
-	array->count = count;
-	return array;
-}
-/*
-	*
-	* Sorts a database file lexicographically.
-	*/
-void SortDatabase(char *dbFile) {
-	dbArray *array;
-	int i;
-	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;
-	}
-	// 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(database[i]);
-    // Deallocate all the lines.
-    for(i = 0; i < array->count; ++i) {
-       free(array->database[i]);
+	}
-	free(array);
+    free(database);
+}
 /*
+	*
 	* Updates a database file "dbFile".
 	*/
-stats *CollectFiles(char *dbFile, char **paths, unsigned int count) {
+dbStats *CollectFiles(char *dbFile, char **paths, int count) {
 #if defined ___AsyncIO___
 	struct AsyncFile *fp;
 #else
 	FILE *fp;
 #endif
 #if defined ___AmigaOS___
-	struct FileInfoBlock *FIBp, *FIBq;
+	struct FileInfoBlock *FIB;
-	BPTR lockp, lockq;
+	BPTR lock;
 #else
 	DIR *dir;
 	struct dirent *entry;
 	struct stat dirStat;
 #endif
 	stringStack *stack;
-	stats *stats = NULL;
+	dbStats *stats = NULL;
 	int i;
 	char *path;
 	char *sub;
 #if defined ___AsyncIO___
 	if((fp = OpenAsync(dbFile, MODE_APPEND, ASYNC_BUF)) == NULL) {
 #else
 	if((fp = fopen(dbFile, "a")) == NULL) {
 #endif
-		fprintf(stderr, "Unable to open '%s' for writing.\n", dbFile);
+		fprintf(stderr, "Could not open file '%s' for writing.\n", dbFile);
 		return NULL;
+	}
  		return NULL;
+ 	}
  	stats->dirs = 0;
+ 	stats->files = 0;
+ 	stats->lines = 0;
- 	stats->files = 0;
+ 	stats->size = 0;
 	// Push the first path onto the stack.
-	stack = stringStackCreate(count);
+	stack = stringStackCreate((unsigned int)count);
-	for(i = 0; run && i < count; ++i) {
+	for(i = 0; PROGRAM_RUN && i < count; ++i) {
 		stringStackPush(stack, paths[i]);
+	}
-	while(run && !stringStackIsEmpty(stack)) {
+	while(PROGRAM_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;
+			PROGRAM_RUN = FALSE;
 			continue;
+		}
 #endif
 		if((path = stringStackPop(stack)) == NULL) {
 			break;
+		}
 #if defined ___AmigaOS___
-		if((lockp = Lock(path, ACCESS_READ)) == NULL) {
+		if((lock = Lock(path, ACCESS_READ)) == NULL) {
 			fprintf(stderr, "Could not lock path '%s' for reading.\n", path);
 			free(path);
 			continue;
+		}
-		if((FIBp = AllocDosObject(DOS_FIB, NULL)) == NULL) {
+		if((FIB = AllocDosObject(DOS_FIB, NULL)) == NULL) {
-			fprintf(stderr, "Path '%s' info block allocation failure.\n", path);
+			fprintf(stderr, "File information block for path '%s' could not be allocated.\n", path);
-			UnLock(lockp);
+			UnLock(lock);
 			free(path);
 			continue;
+		}
-		if(Examine(lockp, FIBp) == FALSE) {
+		if(Examine(lock, FIB) == FALSE) {
 			fprintf(stderr, "Path '%s' could not be examined.\n", path);
-			FreeDosObject(DOS_FIB, FIBp);
+			FreeDosObject(DOS_FIB, FIB);
-			UnLock(lockp);
+			UnLock(lock);
 			free(path);
 			continue;
+		}
-		while(run && ExNext(lockp, FIBp)) {
+		while(PROGRAM_RUN && ExNext(lock, FIB)) {
 			// Check if CTRL+C was pressed and abort the program.
 			if(SetSignal(0L, SIGBREAKF_CTRL_C) & SIGBREAKF_CTRL_C) {
-				run = FALSE;
+				PROGRAM_RUN = FALSE;
 				continue;
 			}
 #else
 		if((dir = opendir(path)) == NULL) {
-			fprintf(stderr, "Unable to open '%s' for reading.\n", path);
+			fprintf(stderr, "Directory '%s' could not be opened.\n", path);
 			free(path);
 			continue;
+		}
-		while(run && (entry = readdir(dir)) != NULL) {
+		while(PROGRAM_RUN && (entry = readdir(dir)) != NULL) {
 #endif
 			switch(path[strlen(path) - 1]) {
 				case '/':
 	 			case ':': // This is a drive path.
 #if defined ___AmigaOS___
-					if((sub = malloc(strlen(path) + strlen(FIBp->fib_FileName) + 1)) == NULL) {
+					if((sub = malloc(strlen(path) + strlen(FIB->fib_FileName) + 1)) == NULL) {
 #else
 	 				if((sub = malloc(strlen(path) + strlen(entry->d_name) + 1)) == NULL) {
 #endif
 						fclose(fp);
 #endif
 	 					return NULL;
+	 				}
 #if defined ___AmigaOS___
-					sprintf(sub, "%s%s", path, FIBp->fib_FileName);
+					sprintf(sub, "%s%s", path, FIB->fib_FileName);
 #else
 	 				sprintf(sub, "%s%s", path, entry->d_name);
 #endif
 	 				break;
 	 			default:
 #if defined ___AmigaOS___
-					if((sub = malloc(strlen(path) + strlen(FIBp->fib_FileName) + 1 + 1)) == NULL) {
+					if((sub = malloc(strlen(path) + strlen(FIB->fib_FileName) + 1 + 1)) == NULL) {
 #else
 	 				if((sub = malloc(strlen(path) + strlen(entry->d_name) + 1 + 1)) == NULL) {
 #endif
 	 					fprintf(stderr, "Memory allocation failure.\n");
 #if defined ___AmigaOS___
-						FreeDosObject(DOS_FIB, FIBp);
+						FreeDosObject(DOS_FIB, FIB);
-						UnLock(lockp);
+						UnLock(lock);
 #else
 	 					closedir(dir);
 #endif
 	 					free(path);
 	 					stringStackDestroy(stack);
 						fclose(fp);
 #endif
 	 					return NULL;
+	 				}
 #if defined ___AmigaOS___
-					sprintf(sub, "%s/%s", path, FIBp->fib_FileName);
+					sprintf(sub, "%s/%s", path, FIB->fib_FileName);
 #else
 	 				sprintf(sub, "%s/%s", path, entry->d_name);
 #endif
 	 				break;
+			}
+			switch(GetFsType(sub)) {
+				case UNKNOWN:
+					free(sub);
+					continue;
+				case REGULAR:
-#if defined ___AmigaOS___
-			if((lockq = Lock(sub, ACCESS_READ)) == NULL) {
-				fprintf(stderr, "Could not lock path '%s' for reading.\n", sub);
-				free(sub);
-				continue;
-			}
-			if((FIBq = AllocDosObject(DOS_FIB, NULL)) == NULL) {
-				fprintf(stderr, "Path '%s' info block allocation failure.\n", sub);
-				UnLock(lockq);
-				free(sub);
-				continue;
-			}
-			if(Examine(lockq, FIBq) == FALSE) {
-				fprintf(stderr, "Path '%s' could not be examined.\n", sub);
-				FreeDosObject(DOS_FIB, FIBq);
-				UnLock(lockq);
-				free(sub);
-				continue;
-			}
-			if(FIBq->fib_DirEntryType > 0) {
-#else
-			stat(sub, &dirStat);
-			if(S_ISDIR(dirStat.st_mode)) {
-#endif
-	 			stringStackPush(stack, sub);
-	 			++stats->dirs;
+					++stats->files;
-	 			if(verbose) {
+	 				if(PROGRAM_VERBOSE) {
-	 				fprintf(stdout,
+	 					fprintf(stdout,
 	 					"Gathered %d directories and %d files.\r",
 	 					stats->dirs,
-	 					stats->files);
-	 			}
-#if defined ___AmigaOS___
+	 					stats->files);
-				FreeDosObject(DOS_FIB, FIBq);
-				UnLock(lockq);
+	 				}
-#endif
+					break;
-	 			free(sub);
-	 			continue;
-	 		}
+				case DIRECTORY:
-#if defined ___AmigaOS___
+	 				stringStackPush(stack, sub);
+	 				++stats->dirs;
-			FreeDosObject(DOS_FIB, FIBq);
+	 				if(PROGRAM_VERBOSE) {
+	 					fprintf(stdout,
-			UnLock(lockq);
+	 						"Gathered %d directories and %d files.\r",
-#endif
-	 		++stats->files;
+	 						stats->dirs,
-	 		if(verbose) {
+	 						stats->files);
 	 			fprintf(stdout,
 	 				"Gathered %d directories and %d files.\r",
-	 				stats->dirs,
+	 				free(sub);
-	 				stats->files);
+	 				continue;
-	 		}
+			}
 #if defined ___NOCASE_FS___
-#if defined ___AmigaOS___
-			strupr(FIBp->fib_FileName);
+#if defined ___AmigaOS___
-#else
+			StrUpr(FIB->fib_FileName);
-			strupr(entry->d_name);
+#else
-#endif
+			StrUpr(entry->d_name);
+#endif
 #endif
+	 		// Write to database file.
 #if defined ___AsyncIO___
-	 		// Write to database file.
+#if defined ___AmigaOS___
+			WriteAsync(fp, FIB->fib_FileName, (LONG)strlen(FIB->fib_FileName));
-#if defined ___AsyncIO___
+			stats->size = stats->size + strlen(FIB->fib_FileName);
+#else
-#if defined ___AmigaOS___
+			WriteAsync(fp, entry->d_name, (LONG)strlen(entry->d_name));
+			stats->size = stats->size + strlen(entry->d_name);
-			WriteAsync(fp, FIBp->fib_FileName, (LONG)strlen(FIBp->fib_FileName));
+#endif
-#else
+			WriteAsync(fp, "\t", 1);
-			WriteAsync(fp, entry->d_name, (LONG)strlen(entry->d_name));
+			++stats->size;
+			WriteAsync(fp, sub, (LONG)strlen(sub));
-#endif
+			stats->size = stats->size + strlen(sub);
-			WriteAsync(fp, "\t", 1);
+			WriteAsync(fp, "\n", 1);
+			++stats->size;
-			WriteAsync(fp, sub, (LONG)strlen(sub));
+#else
-			WriteAsync(fp, "\n", 1);
+#if defined ___AmigaOS___
+			fprintf(fp, "%s\t%s\n", FIB->fib_FileName, sub);
+			stats->size = stats->size + strlen(FIB->fib_FileName) + strlen(sub) + 1 + 1 + 1;
+#else
-#else
+	 		fprintf(fp, "%s\t%s\n", entry->d_name, sub);
-#if defined ___AmigaOS___
+	 		stats->size = stats->size + strlen(entry->d_name) + strlen(sub) + 1 + 1 + 1;
-			fprintf(fp, "%s\t%s\n", FIBp->fib_FileName, sub);
+#endif
-#else
+#endif
-	 		fprintf(fp, "%s\t%s\n", entry->d_name, sub);
-#endif
+			++stats->lines;
 #endif
 	 		free(sub);
+	 	}
 #if defined ___AmigaOS___
-		FreeDosObject(DOS_FIB, FIBp);
+		FreeDosObject(DOS_FIB, FIB);
-		UnLock(lockp);
+		UnLock(lock);
 #else
 #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);
+		fprintf(stderr, "Could not open file '%s' for reading.\n", dbFile);
 		return;
+	}
 #if defined ___AsyncIO___
 	if((tp = OpenAsync(tmpNames[--tmpFiles], MODE_WRITE, ASYNC_BUF)) == NULL) {
 #else
 	if((tp = fopen(tmpNames[--tmpFiles], "w")) == NULL) {
 #endif
-		fprintf(stderr, "Unable to open '%s' for writing.\n", tmpNames[tmpFiles]);
+		fprintf(stderr, "Could not open file '%s' for writing.\n", tmpNames[tmpFiles]);
 #if defined ___AsyncIO___
 		CloseAsync(fp);
 #else
 		fclose(fp);
 #endif
 		return;
 	}
-	if(verbose) {
+	if(PROGRAM_VERBOSE) {
 		fprintf(stdout, "Writing to temporary files...\r");
+	}
 	write = 0;
 	lines = 0;
 #if defined ___AsyncIO___
-	while(run && (c = ReadCharAsync(fp)) != -1) {
+	while(PROGRAM_RUN && (c = ReadCharAsync(fp)) != -1) {
 #else
-	while(run && fscanf(fp, "%c", &c) == 1) {
+	while(PROGRAM_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;
+			PROGRAM_RUN = FALSE;
 			continue;
+		}
 #endif
 		switch(c) {
 			case '\n':
 				// Increment the total written lines.
 				++write;
-				if(verbose) {
+				if(PROGRAM_VERBOSE) {
 					if((tp = OpenAsync(tmpNames[--tmpFiles], MODE_WRITE, ASYNC_BUF)) == NULL) {
 #else
 					fclose(tp);
 					if((tp = fopen(tmpNames[--tmpFiles], "w")) == NULL) {
 #endif
-						fprintf(stderr, "Unable to open '%s' for writing.\n", tmpNames[tmpFiles]);
+						fprintf(stderr, "Could not open '%s' for writing.\n", tmpNames[tmpFiles]);
 #if defined ___AsyncIO___
 						CloseAsync(fp);
 #else
 						fclose(fp);
 #endif
 #if defined ___AsyncIO___
 				if(WriteCharAsync(tp, (UBYTE)c) != 1) {
 #else
 				if(fprintf(tp, "%c", c) != 1) {
 #endif
-					fprintf(stderr, "Unable to write to '%s'.\n", tmpNames[tmpFiles]);
+					fprintf(stderr, "Could not write to file '%s'.\n", tmpNames[tmpFiles]);
 #if defined ___AsyncIO___
 					CloseAsync(tp);
 					CloseAsync(fp);
 #else
 					fclose(tp);
+				}
 				break;
+		}
+	}
-	if(verbose) {
+	if(PROGRAM_VERBOSE) {
 		fprintf(stdout, "\n");
+	}
 	struct AsyncFile **tp;
 #else
 	FILE *fp;
 	FILE **tp;
 #endif
-	unsigned int i;
+	int i;
-	unsigned int j;
+	int j;
 	char *tmp;
 	char *rem;
 	char *min;
 	int count;
 #if defined ___AsyncIO___
 	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);
+		fprintf(stderr, "Could not open file '%s' for writing.\n", dbFile);
 		return;
+	}
 #if defined ___AsyncIO___
 		if((tp[i] = OpenAsync(tmpNames[i], MODE_READ, ASYNC_BUF)) == NULL) {
 #else
 		if((tp[i] = fopen(tmpNames[i], "r")) == NULL) {
 #endif
-			fprintf(stderr, "Unable to open '%s' for reading.\n", tmpNames[i]);
+			fprintf(stderr, "Could not open file '%s' for reading.\n", tmpNames[i]);
 			// Close all temporary files.
 			while(--i > -1) {
 #if defined ___AsyncIO___
 				CloseAsync(tp[i]);
 #else
 #endif
 			return;
+		}
+	}
-	if(verbose) {
+	if(PROGRAM_VERBOSE) {
 		fprintf(stdout, "Merging all files...\r");
+	}
 	rem = NULL;
 	count = lines;
 	j = 0;
-	while(run && --count > -1) {
+	while(PROGRAM_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;
+			PROGRAM_RUN = FALSE;
 			continue;
+		}
 #endif
 		// Find the smallest line in all temporary files.
-		if(verbose) {
+		if(PROGRAM_VERBOSE) {
 			fprintf(stdout, "Merging all files: %d%%.\r", 100 - (int)(((float)count / lines) * 100.0));
+		}
 				if(min != NULL) {
 					// Free previous instance.
 					free(min);
+				}
 				if((min = malloc((strlen(tmp) + 1) * sizeof(*min))) == NULL) {
-					fprintf(stderr, "Memory allication failure.\n");
+					fprintf(stderr, "Memory allocation failure.\n");
 					free(tmp);
 					if(min != NULL) {
 						free(min);
+					}
 					if(rem != NULL) {
 	if(rem != NULL) {
 		free(rem);
+	}
 	// Write out any remaining contents from the temporary files.
-	for(i = 0; run && i < files; ++i) {
+	for(i = 0; PROGRAM_RUN && i < files; ++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;
+			PROGRAM_RUN = FALSE;
 			continue;
+		}
 #endif
 		tmp = ReadLine(tp[i]);
 #else
 		fclose(tp[i]);
 #endif
+	}
-	if(verbose) {
-		fprintf(stdout, "\n");
-	}
 #if defined ___AsyncIO___
 	CloseAsync(fp);
 #else
 	fclose(fp);
+#endif
+	if(PROGRAM_VERBOSE) {
+		fprintf(stdout, "\n");
 #endif
+}
 /*
+  *
   * Filter the paths inside the database with provided paths.
   */
-void FilterDatabasePaths(char *dbFile, char *tmpName, char **paths, unsigned int count) {
+void FilterDatabasePaths(char *dbFile, char *tmpName, char **paths, int count) {
 #if defined ___AsyncIO___
 	struct AsyncFile *fp;
 	struct AsyncFile *tp;
 #else
 	FILE *fp;
 	FILE *tp;
 #endif
 	char *line;
-	unsigned int lines;
+	int lines;
 	int i;
 	dbEntry *entry;
 	// 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);
+		fprintf(stderr, "Could not open file '%s' for reading.\n", dbFile);
 		return;
+	}
 	// 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);
+		fprintf(stderr, "Copuld not open file '%s' for writing.\n", tmpName);
 #endif
 		return;
 	}
-	if(verbose) {
+	if(PROGRAM_VERBOSE) {
 		fprintf(stdout, "Removing lines...\r");
 	}
 	lines = 0;
-	while(run && (line = ReadLine(fp)) != NULL) {
+	while(PROGRAM_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;
+			PROGRAM_RUN = FALSE;
 			continue;
+		}
+		}
 		for(i = 0; i < count; ++i) {
 			if(PathCompare(entry->path, paths[i]) == TRUE) {
 				++lines;
-				if(verbose) {
+				if(PROGRAM_VERBOSE) {
-					fprintf(stdout, "Removing lines: %d\r", lines);
+					fprintf(stdout, "Removing lines: %d.\r", lines);
+				}
 				continue;
+			}
 #if defined ___AsyncIO___
 		free(entry);
 		free(line);
-	}
-	if(verbose) {
-		fprintf(stdout, "\n");
-	}
+	}
 #if defined ___AsyncIO___
 	CloseAsync(fp);
 	CloseAsync(tp);
 #else
 	fclose(fp);
+	fclose(tp);
+#endif
+	if(PROGRAM_VERBOSE) {
-	fclose(tp);
+		fprintf(stdout, "\n");
 #endif
+}
 /*
 	*
 	* Indexes a "path" by creating a database "dbFile".
 	*/
-void GatherDatabaseFiles(char *dbFile, char **paths, unsigned int count) {
-	stats *stats;
-	char **tmpNames;
+void GatherDatabaseFiles(char *dbFile, char **paths, int count) {
-	int dbSize;
+	dbStats *stats;
-	int dbLines;
+	char **tmpNames;
 	int tmpFiles;
 	int tmpLines;
 	int i;
 	// Generate the database file from the supplied paths.
-	if((stats = CollectFiles(dbFile, paths, count)) == NULL) {
-		fprintf(stderr, "Collecting files failed.\n");
+	if((stats = CollectFiles(dbFile, paths, count)) == NULL) {
-		return;
-	}
-	free(stats);
-	// Compute the amount of temporary files needed.
-	dbSize = GetFileSize(dbFile);
+		fprintf(stderr, "Collecting files failed.\n");
-	if(dbSize == -1) {
+		return;
 		fprintf(stderr, "File size for '%s' failed.\n", dbFile);
 		return;
-	}
+	// Calculate the total number of temporary files required.
-	tmpFiles = dbSize / maxmem;
+	tmpFiles = stats->size / maxmem;
 	/* In case no temporary files are required,
-	 * just sort the database and terminate.
-	 */
-	if(tmpFiles <= 1) {
-		SortDatabase(dbFile);
+	 * just sort the database and terminate.
-		return;
-	}
+	 */
 	if(tmpFiles < 2) {
-	// Get the database metrics.
+		SortDatabase(dbFile, stats->lines);
-	dbLines = CountFileLines(dbFile);
+		return;
 	if(dbLines == -1) {
 		fprintf(stderr, "Counting lines of '%s' failed.\n", dbFile);
 	// Calculate the number of lines per temporary file.
-	tmpLines = dbLines / tmpFiles;
+	tmpLines = stats->lines / tmpFiles;
 	// Create temporary files.
+	if((tmpNames = CreateTemporaryFiles(tmpFiles)) == NULL) {
-	if((tmpNames = CreateTemporaryFiles(tmpFiles)) == NULL) {
+		fprintf(stderr, "Unable to create temporary files.\n");
-		fprintf(stderr, "Unable to create temporary files.\n");
+		return;
 		return;
-	}
 	// Write "tmpLines" to temporary files in "tmpNames" from "dbFile".
-	// Write "tmpLines" to temporary files in "tmpNames" from "dbFile".
+	WriteTemporaryFiles(dbFile, tmpNames, tmpFiles, tmpLines, stats->lines);
 	WriteTemporaryFiles(dbFile, tmpNames, tmpFiles, tmpLines, dbLines);
 	// Sort the temporary files.
+	for(i = 0; i < tmpFiles; ++i) {
+		tmpLines = CountFileLines(tmpNames[i]);
+		SortDatabase(tmpNames[i], tmpLines);
 	// Sort the temporary files.
-	for(i = 0; i < tmpFiles; ++i) {
-		SortDatabase(tmpNames[i]);
+	// Merge all the temporary files to the database file.
 	MergeTemporaryFiles(dbFile, tmpNames, tmpFiles, stats->lines);
-	// Merge all the temporary files to the database file.
+	// Remove all temporary files.
 /*
+	*
 	* Main entry point.
 	*/
 int main(int argc, char **argv) {
-#if defined ___AmigaOS___
-	struct FileInfoBlock *FIB;
-	BPTR lock;
-#else
-	struct stat dirStat;
-#endif
 	int option;
-	unsigned int i;
+	int i;
-	unsigned int count;
+	int count;
 	char *dbFile;
 	char *path;
 	char **paths;
+	OPERATION operation = NONE;
 	// Bind handler to SIGINT.
 #if !defined ___AmigaOS___
  	signal(SIGINT, SignalHandler);
 				break;
 			case 'd':
 				dbFile = optarg;
 				break;
 			case 'q':
-				verbose = FALSE;
+				PROGRAM_VERBOSE = FALSE;
 				break;
 			case 'h':
 				usage(argv[0]);
 				return 0;
 			case '?':
 		if((path = PathToAbsolute(argv[i])) == NULL) {
 			fprintf(stderr, "Absolute path for '%s' failed to resolve.\n", argv[optind]);
 			continue;
+		}
-		// Check that the path is a directory.
-#if defined ___AmigaOS___
-		if((lock = Lock(path, ACCESS_READ)) == NULL) {
-			fprintf(stderr, "Path '%s' is not accessible.\n", path);
-			free(path);
-			continue;
-		}
-		if((FIB = AllocDosObject(DOS_FIB, NULL)) == NULL) {
-			fprintf(stderr, "Path '%s' file information block not accessible.\n", path);
+		switch(GetFsType(path)) {
-			UnLock(lock);
+			case UNKNOWN:
-			free(path);
-			continue;
-		}
-		if(Examine(lock, FIB) == FALSE) {
+			case REGULAR:
-			fprintf(stderr, "Path '%s' information unexaminable.\n", path);
-			UnLock(lock);
-			FreeDosObject(DOS_FIB, FIB);
+				fprintf(stderr, "Path '%s' is not a directory.\n", path);
-			free(path);
+				free(path);
-			continue;
-		}
-		if(FIB->fib_DirEntryType < 0) {
-#else
-		stat(path, &dirStat);
-		if(!S_ISDIR(dirStat.st_mode)) {
-#endif
-			fprintf(stderr, "Path '%s' is not a directory.\n", argv[optind]);
-#if defined ___AmigaOS___
+				continue;
-			UnLock(lock);
-			FreeDosObject(DOS_FIB, FIB);
-#endif
+				break;
-			free(path);
+			case DIRECTORY:
-			return 1;
+				break;
 		}
-		if(verbose) {
+		if(PROGRAM_VERBOSE) {
 			fprintf(stdout, "Will process path: '%s'\n", path);
+		}
+		}
 		sprintf(paths[count], "%s", path);
-		++count;
-#if defined ___AmigaOS___
-		UnLock(lock);
-		FreeDosObject(DOS_FIB, FIB);
+		++count;
 #endif
 		free(path);
+	}
 	if(count == 0) {
 		fprintf(stderr, "No valid paths are available.\n");
 		free(paths);
 		return 1;
+	}
-	if(verbose) {
+	if(PROGRAM_VERBOSE) {
    		fprintf(stdout, "Gathering to: '%s'\n", dbFile);
+	}
 #if defined ___AmigaOS___
 	locale = OpenLocale(NULL);
 #endif
  	switch(operation) {
  		case CREATE:
- 			if(verbose) {
+ 			if(PROGRAM_VERBOSE) {
  				fprintf(stdout, "Removing '%s' and creating a new database.\n", dbFile);
+ 			}
  			if(RemoveFile(dbFile) == FALSE) {
  				fprintf(stderr, "File '%s' could not be removed.\n", dbFile);
  				break;
+ 			}
  		case GATHER:
- 			if(verbose) {
+ 			if(PROGRAM_VERBOSE) {
  				fprintf(stdout, "Gathering files to database...\n");
+ 			}
  			GatherDatabaseFiles(dbFile, paths, count);
  			break;
 	CloseLocale(locale);
 #endif
- 	free(paths);
-#if defined MWDEBUG
- 	/* Generate a memory usage report */
- 	MWReport("At end of main()", MWR_FULL);
-#endif
+ 	free(paths);