HuntnGather – Diff between revs 37 and 38

Subversion Repositories:

?pathlinks?

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

 ///////////////////////////////////////////////////////////////////////////
 #include <stdio.h>
 #include <stdlib.h>
+#include <string.h>
-#include <string.h>
+#include <math.h>
 #if !defined ___AmigaOS___
 #include <dirent.h>
 #include <sys/stat.h>
 #include <signal.h>
 #else
 	FILE *fp;
 #endif
 	char **database;
 	dbEntry *entry;
-	char *line = NULL;
+	dbLine *line;
 	char *rem;
 	int count;
 	int i;
 			continue;
+		}
 #endif
 		if((entry = CreateDatabaseEntry(line)) == NULL) {
 			fprintf(stderr, "Unable to create database entry.\n");
+			free(line->string);
 			free(line);
+			line = NULL;
 #if defined ___AsyncIO___
 			CloseAsync(fp);
 #else
 			fclose(fp);
 #endif
 			return;
+		}
 		if((database[count] = malloc((strlen(entry->name) + strlen(entry->path) + 1 + 1) * sizeof(*database[count]))) == NULL) {
+			fprintf(stderr, "Memory allocation failure.\n");
-			fprintf(stderr, "Memory allocation failure.\n");
+			// Free database entry.
 			free(entry->name);
 			free(entry->path);
+			free(entry);
+			entry = NULL;
+			// Free the line.
-			free(entry);
+			free(line->string);
+			free(line);
+			line = NULL;
 			free(line);
 #if defined ___AsyncIO___
 			CloseAsync(fp);
 #else
 			fclose(fp);
 		// Free the database entry.
 		free(entry->name);
 		free(entry->path);
+		free(entry);
+		entry = NULL;
-		free(entry);
+		// Free the line.
-		free(line);
-	}
+		free(line->string);
-	if(line != NULL) {
+		free(line);
-		free(line);
+		line = NULL;
+	}
 		fprintf(fp, "%s\n", database[i]);
 #endif
 		if(rem != NULL) {
+			free(rem);
-			free(rem);
+			rem = NULL;
+		}
 		rem = malloc((strlen(database[i]) + 1) * sizeof(*rem));
 		sprintf(rem, "%s", database[i]);
+	}
 	if(rem != NULL) {
-	if(rem != NULL) {
+		free(rem);
-		free(rem);
+		rem = NULL;
+	}
+	}
 	// Free up database.
 	for(i = 0; i < count; ++i) {
+		free(database[i]);
-		free(database[i]);
+		database[i] = NULL;
+	}
     free(database);
+}
 /*
 	*
 	* Updates a database file "dbFile".
 	*/
-dbStats *CollectFiles(char *dbFile, char **paths, int count) {
+dbStats *CollectFiles(char *dbFile, VECTOR *paths) {
 #if defined ___AsyncIO___
 	struct AsyncFile *fp;
 	struct FileInfoBlock *FIB;
 	BPTR lock;
 #else
 	DIR *dir;
 	struct dirent *entry;
-	struct stat dirStat;
 #endif
 	stringStack *stack;
 	dbStats *stats = NULL;
 	int i;
 	char *path;
  	stats->files = 0;
  	stats->lines = 0;
  	stats->size = 0;
 	// Push the first path onto the stack.
-	stack = stringStackCreate((unsigned int)count);
+	stack = stringStackCreate((unsigned int)paths->length);
-	for(i = 0; PROGRAM_RUN && i < count; ++i) {
+	for(i = 0; PROGRAM_RUN && i < paths->length; ++i) {
-		stringStackPush(stack, paths[i]);
+		stringStackPush(stack, paths->array[i]);
+	}
 	while(PROGRAM_RUN && !stringStackIsEmpty(stack)) {
 #if defined ___AmigaOS___
 		if((lock = Lock(path, ACCESS_READ)) == NULL) {
 			fprintf(stderr, "Could not lock path '%s' for reading.\n", path);
+			free(path);
-			free(path);
+			path = NULL;
 			continue;
+		}
 		if((FIB = AllocDosObject(DOS_FIB, NULL)) == NULL) {
 			fprintf(stderr, "File information block for path '%s' could not be allocated.\n", path);
+			UnLock(lock);
-			UnLock(lock);
+			free(path);
-			free(path);
+			path = NULL;
 			continue;
+		}
+		if(Examine(lock, FIB) == FALSE) {
-		if(Examine(lock, FIB) == FALSE) {
+			fprintf(stderr, "Path '%s' could not be examined.\n", path);
-			fprintf(stderr, "Path '%s' could not be examined.\n", path);
+			FreeDosObject(DOS_FIB, FIB);
+			FIB = NULL;
-			FreeDosObject(DOS_FIB, FIB);
+			UnLock(lock);
-			UnLock(lock);
+			free(path);
-			free(path);
+			path = NULL;
 			continue;
 #else
 		if((dir = opendir(path)) == NULL) {
 			fprintf(stderr, "Directory '%s' could not be opened.\n", path);
+			free(path);
-			free(path);
+			path = NULL;
 			continue;
+		}
 	 				if((sub = malloc(strlen(path) + strlen(entry->d_name) + 1)) == NULL) {
 #endif
 	 					fprintf(stderr, "Memory allocation failure.\n");
 #if defined ___AmigaOS___
 						FreeDosObject(DOS_FIB, FIB);
+						FIB = NULL;
 						UnLock(lock);
 #else
 	 					closedir(dir);
 #endif
 	 					free(path);
+	 					path = NULL;
 	 					stringStackDestroy(stack);
 #if defined ___AsyncIO___
 						CloseAsync(fp);
 #else
 						fclose(fp);
 	 				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, FIB);
+						FIB = NULL;
 						UnLock(lock);
 #else
 	 					closedir(dir);
 #endif
 	 					free(path);
+	 					path = NULL;
 	 					stringStackDestroy(stack);
 #if defined ___AsyncIO___
 						CloseAsync(fp);
 #else
 						fclose(fp);
+			}
 			switch(GetFsType(sub)) {
 				case UNKNOWN:
+					free(sub);
-					free(sub);
+					sub = NULL;
 					continue;
 				case REGULAR:
 					++stats->files;
 	 				if(PROGRAM_VERBOSE) {
 	 					fprintf(stdout,
-	 					"Gathered %d directories and %d files.\r",
+	 					"Gathered '%d' directories and '%d' files.\r",
 	 					stats->dirs,
 	 					stats->files);
+	 				}
 	 				++stats->dirs;
 	 				if(PROGRAM_VERBOSE) {
 	 					fprintf(stdout,
-	 						"Gathered %d directories and %d files.\r",
+	 						"Gathered '%d' directories and '%d' files.\r",
 	 						stats->dirs,
 	 						stats->files);
+	 				}
 	 				free(sub);
-	 				free(sub);
+	 				sub = NULL;
 	 				continue;
 #endif
 			++stats->lines;
 	 		free(sub);
-	 		free(sub);
+	 		sub = NULL;
+	 	}
 #if defined ___AmigaOS___
-#if defined ___AmigaOS___
+		FreeDosObject(DOS_FIB, FIB);
-		FreeDosObject(DOS_FIB, FIB);
+		FIB = NULL;
 		UnLock(lock);
 #else
+	 	closedir(dir);
-	 	closedir(dir);
+#endif
-#endif
+		free(path);
-		free(path);
+		path = NULL;
+	}
 /*
+	*
 	* Writes lines from the database "dbFile" to temporary filenames "tmpNames".
 	*/
-void WriteTemporaryFiles(char *dbFile, char **tmpNames, int tmpFiles, int tmpLines, int total) {
+void WriteTemporaryFiles(char *dbFile, VECTOR *tmpNames, int tmpLines, int total) {
 #if defined ___AsyncIO___
 	struct AsyncFile *fp, *tp;
 	LONG c;
 #else
 	FILE *fp, *tp;
 	char c;
 #endif
 	int lines;
+	int write;
-	int write;
+	int files;
 #if defined ___AsyncIO___
 	if((fp = OpenAsync(dbFile, MODE_READ, ASYNC_BUF)) == NULL) {
 #else
 	if((fp = fopen(dbFile, "r")) == NULL) {
 #endif
 		fprintf(stderr, "Could not open file '%s' for reading.\n", dbFile);
+		return;
 		return;
-	}
 	files = tmpNames->length;
 #if defined ___AsyncIO___
-	if((tp = OpenAsync(tmpNames[--tmpFiles], MODE_WRITE, ASYNC_BUF)) == NULL) {
+	if((tp = OpenAsync(tmpNames->array[--files], MODE_WRITE, ASYNC_BUF)) == NULL) {
 #else
-	if((tp = fopen(tmpNames[--tmpFiles], "w")) == NULL) {
+	if((tp = fopen(tmpNames->array[--files], "w")) == NULL) {
 #endif
-		fprintf(stderr, "Could not open file '%s' for writing.\n", tmpNames[tmpFiles]);
+		fprintf(stderr, "Could not open file '%s' for writing.\n", (char *)tmpNames->array[files]);
 #if defined ___AsyncIO___
 		CloseAsync(fp);
 #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, "Unable to write to '%s'.\n", (char *)tmpNames->array[files]);
 #if defined ___AsyncIO___
 					CloseAsync(tp);
 					CloseAsync(fp);
 #else
 					fclose(tp);
 					return;
+				}
 				// Switch to the next temporary file.
 				if(++lines >= tmpLines) {
 					// If there are no temporary files left then run till the end.
-					if(tmpFiles - 1 < 0) {
+					if(files - 1 < 0) {
 						break;
+					}
 					// Close the previous temporary file and write to the next temporary file.
 #if defined ___AsyncIO___
 					CloseAsync(tp);
-					if((tp = OpenAsync(tmpNames[--tmpFiles], MODE_WRITE, ASYNC_BUF)) == NULL) {
+					if((tp = OpenAsync(tmpNames->array[--files], MODE_WRITE, ASYNC_BUF)) == NULL) {
 #else
 					fclose(tp);
-					if((tp = fopen(tmpNames[--tmpFiles], "w")) == NULL) {
+					if((tp = fopen(tmpNames->array[--files], "w")) == NULL) {
 #endif
-						fprintf(stderr, "Could not open '%s' for writing.\n", tmpNames[tmpFiles]);
+						fprintf(stderr, "Could not open '%s' for writing.\n", (char *)tmpNames->array[files]);
 #if defined ___AsyncIO___
 						CloseAsync(fp);
 #else
 						fclose(fp);
 #if defined ___AsyncIO___
 				if(WriteCharAsync(tp, (UBYTE)c) != 1) {
 #else
 				if(fprintf(tp, "%c", c) != 1) {
 #endif
-					fprintf(stderr, "Could not write to file '%s'.\n", tmpNames[tmpFiles]);
+					fprintf(stderr, "Could not write to file '%s'.\n", (char *)tmpNames->array[files]);
 #if defined ___AsyncIO___
 					CloseAsync(tp);
 					CloseAsync(fp);
 #else
 					fclose(tp);
 /*
+	*
 	* Merges temporary files "tmpNames" into a database "dbFile".
 	*/
-void MergeTemporaryFiles(char *dbFile, char **tmpNames, int files, int lines) {
+void MergeTemporaryFiles(char *dbFile, VECTOR *tmpNames, int lines) {
 #if defined ___AsyncIO___
 	struct AsyncFile *fp;
 	struct AsyncFile **tp;
 #else
 	FILE *fp;
 	FILE **tp;
 #endif
 	int i;
 	int j;
-	char *tmp;
+	dbLine *tmp;
 	char *rem;
 	char *min;
 	int count;
 		fprintf(stderr, "Could not open file '%s' for writing.\n", dbFile);
 		return;
+	}
 	// Allocate as many file pointers as temporary files.
-	if((tp = malloc(files * sizeof(*tp))) == NULL) {
+	if((tp = malloc(tmpNames->length * sizeof(*tp))) == NULL) {
 		fprintf(stderr, "Memory allocation failure.\n");
 #if defined ___AsyncIO___
 		CloseAsync(fp);
 #else
 		fclose(fp);
 #endif
 		return;
+	}
 	// Open all temporary files for reading.
-	for(i = 0; i < files; ++i) {
+	for(i = 0; i < tmpNames->length; ++i) {
 #if defined ___AsyncIO___
-		if((tp[i] = OpenAsync(tmpNames[i], MODE_READ, ASYNC_BUF)) == NULL) {
+		if((tp[i] = OpenAsync(tmpNames->array[i], MODE_READ, ASYNC_BUF)) == NULL) {
 #else
-		if((tp[i] = fopen(tmpNames[i], "r")) == NULL) {
+		if((tp[i] = fopen(tmpNames->array[i], "r")) == NULL) {
 #endif
-			fprintf(stderr, "Could not open file '%s' for reading.\n", tmpNames[i]);
+			fprintf(stderr, "Could not open file '%s' for reading.\n", tmpNames->array[i]);
 			// Close all temporary files.
 			while(--i > -1) {
 #if defined ___AsyncIO___
 		if(PROGRAM_VERBOSE) {
 			fprintf(stdout, "Merging all files: %d%%.\r", 100 - (int)(((float)count / lines) * 100.0));
+		}
 		min = NULL;
-		for(i = 0; i < files; ++i) {
+		for(i = 0; i < tmpNames->length; ++i) {
 			tmp = PeekLine(tp[i]);
 			if(tmp == NULL) {
 				continue;
+			}
 #if defined ___AmigaOS___
-			if(min == NULL || StrnCmp(locale, tmp, min, -1, SC_ASCII) < 0) {
+			if(min == NULL || StrnCmp(locale, tmp->string, min, -1, SC_ASCII) < 0) {
 #else
-			if(min == NULL || strcmp(tmp, min) < 0) {
+			if(min == NULL || strcmp(tmp->string, min) < 0) {
 #endif
 				if(min != NULL) {
 					// Free previous instance.
+					free(min);
-					free(min);
+					min = NULL;
 				}
-				if((min = malloc((strlen(tmp) + 1) * sizeof(*min))) == NULL) {
+				if((min = malloc((strlen(tmp->string) + 1) * sizeof(*min))) == NULL) {
+					fprintf(stderr, "Memory allocation failure.\n");
-					fprintf(stderr, "Memory allocation failure.\n");
+					free(tmp->string);
+					free(tmp);
+					tmp = NULL;
 					free(tmp);
 					if(min != NULL) {
+						free(min);
-						free(min);
+						min = NULL;
+					}
 					if(rem != NULL) {
+						free(rem);
-						free(rem);
+						rem = NULL;
+					}
 #if defined ___AsyncIO___
 					CloseAsync(fp);
 #else
 					fclose(fp);
 #endif
 					return;
 				}
-				sprintf(min, "%s", tmp);
+				sprintf(min, "%s", tmp->string);
 				// Remember the index of the file where the smallest entry has been found.
 				j = i;
+			}
 			free(tmp->string);
+			free(tmp);
-			free(tmp);
+			tmp = NULL;
+		}
 				if(StrnCmp(locale, min, rem, -1, SC_ASCII) == 0) {
 #else
 				if(strcmp(min, rem) == 0) {
 #endif
 					free(min);
+					min = NULL;
 					continue;
+				}
+			}
 			fprintf(fp, "%s\n", min);
 #endif
 			if(rem != NULL) {
+				free(rem);
-				free(rem);
+				rem = NULL;
+			}
+			if((rem = malloc((strlen(min) + 1) * sizeof(*rem))) == NULL) {
-			if((rem = malloc((strlen(min) + 1) * sizeof(*rem))) == NULL) {
+				fprintf(stderr, "Memory allocation failure.\n");
+				free(min);
-				fprintf(stderr, "Memory allocation failure.\n");
+				min = NULL;
 				free(min);
 #if defined ___AsyncIO___
 				CloseAsync(fp);
 #else
 				fclose(fp);
 #endif
+				return;
 				return;
 			// Rememb er the last minimal line.
+			sprintf(rem, "%s", min);
-			sprintf(rem, "%s", min);
+			free(min);
-			free(min);
+			min = NULL;
+		}
+	}
 	if(rem != NULL) {
-	if(rem != NULL) {
+		free(rem);
-		free(rem);
+		rem = NULL;
+	}
 	// Write out any remaining contents from the temporary files.
-	for(i = 0; PROGRAM_RUN && i < files; ++i) {
+	for(i = 0; PROGRAM_RUN && i < tmpNames->length; ++i) {
 		tmp = ReadLine(tp[i]);
 		if(tmp == NULL) {
 			continue;
+		}
 #if defined ___AsyncIO___
-		WriteAsync(fp, tmp, (LONG)strlen(tmp));
+		WriteAsync(fp, tmp->string, (LONG)strlen(tmp->string));
 		WriteAsync(fp, "\n", 1);
 #else
-		fprintf(fp, "%s\n", tmp);
+		fprintf(fp, "%s\n", tmp->string);
 #endif
+		free(tmp->string);
 		free(tmp);
+		tmp = NULL;
+	}
 	// Close all temporary files.
-	for(i = 0; i < files; ++i) {
+	for(i = 0; i < tmpNames->length; ++i) {
 #if defined ___AsyncIO___
 		CloseAsync(tp[i]);
 #else
 		fclose(tp[i]);
 /*
+  *
   * Filter the paths inside the database with provided paths.
   */
-void FilterDatabasePaths(char *dbFile, char *tmpName, char **paths, int count) {
+void FilterDatabasePaths(char *dbFile, char *tmpName, VECTOR *paths) {
 #if defined ___AsyncIO___
 	struct AsyncFile *fp;
 	struct AsyncFile *tp;
 #else
 	FILE *fp;
 	FILE *tp;
 #endif
+	dbLine *line;
-	char *line;
+	dbEntry *entry;
 	int lines;
-	int i;
-	dbEntry *entry;
+	int i;
 	// Open database file for reading.
 #if defined ___AsyncIO___
    	if(SetSignal(0L, SIGBREAKF_CTRL_C) & SIGBREAKF_CTRL_C) {
 			PROGRAM_RUN = FALSE;
 			continue;
+		}
 #endif
 		if((entry = CreateDatabaseEntry(line)) == NULL) {
 			fprintf(stderr, "Unable to create database entry.\n");
+			free(line->string);
 			free(line);
+			line = NULL;
 			continue;
+		}
-		for(i = 0; i < count; ++i) {
+		for(i = 0; i < paths->length; ++i) {
-			if(PathCompare(entry->path, paths[i]) == TRUE) {
+			if(PathCompare(entry->path, paths->array[i]) == TRUE) {
 				++lines;
 				if(PROGRAM_VERBOSE) {
 					fprintf(stdout, "Removing lines: %d.\r", lines);
+				}
 				continue;
+			}
 #if defined ___AsyncIO___
-			WriteAsync(tp, line, (LONG)strlen(line));
+			WriteAsync(tp, line->string, (LONG)strlen(line->string));
 			WriteAsync(tp, "\n", 1);
 #else
-			fprintf(tp, "%s\n", line);
+			fprintf(tp, "%s\n", line->string);
 #endif
 			break;
-		}
+		}
 		// Free up database entry.
 		free(entry->name);
+		free(entry->path);
+		free(entry);
+		entry = NULL;
 		free(entry->path);
+		// Free up line.
-		free(entry);
+		free(line->string);
 		free(line);
-		free(line);
+		line = NULL;
+	}
 /*
+	*
 	* Indexes a "path" by creating a database "dbFile".
 	*/
-void GatherDatabaseFiles(char *dbFile, char **paths, int count) {
+void GatherDatabaseFiles(char *dbFile, VECTOR *paths) {
 	dbStats *stats;
-	char **tmpNames;
+	VECTOR *tmpNames;
 	int tmpFiles;
 	int tmpLines;
 	int i;
 	// Generate the database file from the supplied paths.
-	if((stats = CollectFiles(dbFile, paths, count)) == NULL) {
+	if((stats = CollectFiles(dbFile, paths)) == NULL) {
 		fprintf(stderr, "Collecting files failed.\n");
 		return;
 		SortDatabase(dbFile, stats->lines);
 		return;
+	}
 	// Calculate the number of lines per temporary file.
-	tmpLines = stats->lines / tmpFiles;
+	tmpLines = ceil(((double)stats->lines) / ((double)tmpFiles));
 	// Create temporary files.
 	if((tmpNames = CreateTemporaryFiles(tmpFiles)) == NULL) {
 		fprintf(stderr, "Unable to create temporary files.\n");
 		return;
 	}
 	// Write "tmpLines" to temporary files in "tmpNames" from "dbFile".
-	WriteTemporaryFiles(dbFile, tmpNames, tmpFiles, tmpLines, stats->lines);
+	WriteTemporaryFiles(dbFile, tmpNames, tmpLines, stats->lines);
 	// Sort the temporary files.
-	for(i = 0; i < tmpFiles; ++i) {
+	// Sort the temporary files.
-		// Twice the number of computed lines required should cover the last file.
+	for(i = 0; i < tmpNames->length; ++i) {
-		SortDatabase(tmpNames[i], 2 * tmpLines);
+		SortDatabase(tmpNames->array[i], tmpLines);
+	}
 	// Merge all the temporary files to the database file.
+	MergeTemporaryFiles(dbFile, tmpNames, stats->lines);
 	MergeTemporaryFiles(dbFile, tmpNames, tmpFiles, stats->lines);
 	// Remove all temporary files.
+	RemoveFiles(tmpNames, tmpFiles);
 	// Remove all temporary files.
-	RemoveFiles(tmpNames, tmpFiles);
+	// Free temporary file names.
 	free(tmpNames);
-	// Free temporary file names.
+	tmpNames = NULL;
 	free(tmpNames);
 	// Free statistics.
-	// Free statistics.
+	free(stats);
-	free(stats);
+	stats = NULL;
+}
-void RemoveDatabaseFiles(char *dbFile, char **paths, int count) {
+void RemoveDatabaseFiles(char *dbFile, VECTOR *paths) {
 	char *tmpName;
 	* Main entry point.
 	*/
 int main(int argc, char **argv) {
 	int option;
 	int i;
-	int count;
 	char *dbFile;
 	char *path;
-	char **paths;
+	VECTOR *paths;
 	OPERATION operation = NONE;
 	// Bind handler to SIGINT.
 #if !defined ___AmigaOS___
 	if(optind >= argc) {
 		usage(argv[0]);
 		return 5;
+	}
+	// Build the path vector.
+	if((paths = malloc(1 * sizeof(*paths))) == NULL) {
+		fprintf(stderr, "Memory allocation failure.\n");
+		return 20;
+	}
 	// Go through all supplied arguments and add paths to search.
-	if((paths = malloc((argc - optind) * sizeof(*paths))) == NULL) {
+	if((paths->array = malloc((argc - optind) * sizeof(*paths))) == NULL) {
 		fprintf(stderr, "Memory allocation failure.\n");
 		return 20;
-	}
+	}
 	count = 0;
-	for(i = optind, count = 0; i < argc; ++i) {
+	for(i = optind, paths->length = 0; i < argc; ++i) {
 		if((path = PathToAbsolute(argv[i])) == NULL) {
 			fprintf(stderr, "Absolute path for '%s' failed to resolve.\n", argv[optind]);
 			continue;
+		}
 		switch(GetFsType(path)) {
 			case UNKNOWN:
+			case REGULAR:
-			case REGULAR:
+				fprintf(stderr, "Path '%s' is not a directory.\n", path);
-				fprintf(stderr, "Path '%s' is not a directory.\n", path);
 				free(path);
-				continue;
+				path = NULL;
-				break;
+				continue;
 			case DIRECTORY:
 				break;
+		}
 		if(PROGRAM_VERBOSE) {
 			fprintf(stdout, "Will process path: '%s'\n", path);
+		}
 		// Add the path to the array of paths.
-		if((paths[count] = malloc((strlen(path) + 1) * sizeof(*paths[count]))) == NULL) {
+		if((paths->array[paths->length] = malloc((strlen(path) + 1) * sizeof(*paths->array[paths->length]))) == NULL) {
 			fprintf(stderr, "Memory allocation failure.");
+			return 20;
 			return 20;
-		}
 		sprintf(paths->array[paths->length], "%s", path);
+		++paths->length;
 		sprintf(paths[count], "%s", path);
+		free(path);
-		++count;
+		path = NULL;
 		free(path);
  			RemoveFile(dbFile);
  		case GATHER:
  			if(PROGRAM_VERBOSE) {
  				fprintf(stdout, "Gathering files to database...\n");
+ 			}
- 			GatherDatabaseFiles(dbFile, paths, count);
+ 			GatherDatabaseFiles(dbFile, paths);
  			break;
  		case REMOVE:
  			if(PROGRAM_VERBOSE) {
  				fprintf(stdout, "Removing files from database...\n");
+ 			}
- 			RemoveDatabaseFiles(dbFile, paths, count);
+ 			RemoveDatabaseFiles(dbFile, paths);
  			break;
  		default:
  			fprintf(stderr, "Unknown operation.\n");
 			#if defined ___AmigaOS___
 				CloseLocale(locale);
 			#endif
+ 			free(paths);
- 			free(paths);
+ 			paths = NULL;
  			return 5;
+ 	}
 #if defined ___AmigaOS___
 	CloseLocale(locale);
 #endif
  	free(paths);