HuntnGather – Diff between revs 19 and 22

Subversion Repositories:

?pathlinks?

Rev 19 – Rev 23 – Go to most recent revision – Details – Blame – Last modification – View Log

 #include <sys/syslimits.h>
 #include <proto/dos.h>
+#include <proto/exec.h>
+#if defined ___AsyncIO___
+#include <asyncio.h>
-#include <proto/exec.h>
+#endif
 #include "StringStack.h"
 #if !defined ___HAVE_GETOPT___
 #include "getopt.h"
 #endif
-#define PROGRAM_VERSION "1.7.2"
+#define PROGRAM_VERSION "1.7.3"
 #if !defined FALSE
 #define FALSE 0;
+#endif
 #endif
 #define ASYNC_BUF 8192
 #define MAX_MEM 262144
 #define NAME_BUF 32
 #define PATH_BUF 128
 /*
+	*
 	* Sorts a database file lexicographically.
 	*/
 void SortDatabase(char *dbFile) {
+#if defined ___AsyncIO___
+	struct AsyncFile *fp;
+	LONG c;
+#else
 	FILE *fp;
+	char c;
+#endif
 	char *name = NULL;
 	char *path = NULL;
 	char **database;
-	char c;
 	int i;
 	int side;
 	unsigned int line;
 	int name_size;
 	int path_size;
+	// Open database file for reading.
+#if defined ___AsyncIO___
+	if((fp = OpenAsync(dbFile, MODE_READ, ASYNC_BUF)) == NULL) {
-	// Open database file for reading.
+#else
+	if((fp = fopen(dbFile, "r")) == NULL) {
-	if((fp = fopen(dbFile, "r")) == NULL) {
+#endif
 		fprintf(stderr, "Unable to open gather database for reading.\n");
 		return;
+	}
 	database = malloc(sizeof(*database));
 	name_size = NAME_BUF;
 	name = malloc(name_size * sizeof(*name));
+	path_size = PATH_BUF;
-	path_size = PATH_BUF;
+	path = malloc(path_size * sizeof(*path));
 	path = malloc(path_size * sizeof(*path));
 	line = 0;
 	side = 0;
 	i = 0;
+	if(verbose) {
+		fprintf(stdout, "Sorting database: '%s'\n", dbFile);
-	if(verbose) {
+	}
-		fprintf(stdout, "Sorting database: '%s'\n", dbFile);
+#if defined ___AsyncIO___
+	while(run && (c = ReadCharAsync(fp)) != -1) {
 #else
 	while(run && fscanf(fp, "%c", &c) == 1) {
-	while(run && fscanf(fp, "%c", &c) == 1) {
+#endif
 #if defined ___AmigaOS___
 		// Check if CTRL+C was pressed and abort the program.
 						//path = realloc(path, (i + 1 + 1) * sizeof(char));
 						path[i] = c;
 						path[i + 1] = '\0';
 						break;
 					default:
-						fprintf(stderr, "Database corrupted.\n");
+						fprintf(stderr, "Database corrupted: %d\n", side);
 						break;
+				}
 				++i;
 				break;
+		}
+	}
+#if defined ___AsyncIO___
+	CloseAsync(fp);
 #else
+	fclose(fp);
-	fclose(fp);
+#endif
 	// Sort the database.
+	qsort(database, line, sizeof(char *), compare);
+	// Write the database lines back to the database.
-	qsort(database, line, sizeof(char *), compare);
+#if defined ___AsyncIO___
+	if((fp = OpenAsync(dbFile, MODE_READ|MODE_WRITE, ASYNC_BUF)) == NULL) {
 #else
-	// Write the database lines back to the database.
+	if((fp = fopen(dbFile, "w+")) == NULL) {
-	if((fp = fopen(dbFile, "w+")) == NULL) {
+#endif
 		fprintf(stderr, "Unable to open gather database for writing.\n");
+		return;
+	}
+	for(i = 0; i < line; ++i) {
-		return;
+#if defined ___AsyncIO___
+		WriteAsync(fp, database[i], (LONG)(strlen(database[i]) * sizeof(char)));
 		WriteAsync(fp, "\n", 1 * sizeof(char));
+#else
+		fprintf(fp, "%s\n", database[i]);
+#endif
 	for(i = 0; i < line; ++i) {
+#if defined ___AsyncIO___
+	CloseAsync(fp);
-		fprintf(fp, "%s\n", database[i]);
+#else
 	fclose(fp);
 #endif
 	free(database);
-	fclose(fp);
+	free(database);
+}
+/*
+	*
 	* Updates a database file "dbFile".
+	*/
-/*
+void UpdateDatabase(char *dbFile, stringStack *dirStack, stats *stats) {
 #if defined ___AsyncIO___
-	* Updates a database file "dbFile".
+	struct AsyncFile *fp;
-	*/
+#else
-void UpdateDatabase(char *dbFile, stringStack *dirStack, stats *stats) {
+	FILE *fp;
-	FILE *fp;
+#endif
+	DIR *dir;
+	struct dirent *dirEntry;
+	struct stat dirStat;
-	DIR *dir;
+	unsigned int size;
+	char *path;
-	struct dirent *dirEntry;
+	char *subPath;
 	struct stat dirStat;
-	unsigned int size;
+#if defined ___AsyncIO___
-	char *path;
+	if((fp = OpenAsync(dbFile, MODE_READ|MODE_WRITE, ASYNC_BUF)) == NULL) {
 #if defined ___NOCASE_FS___
 			strupr(dirEntry->d_name);
+#endif
+#if defined ___AsyncIO___
+			WriteAsync(fp, dirEntry->d_name, (LONG)(strlen(dirEntry->d_name) * sizeof(char)));
+			WriteAsync(fp, "\t", 1 * sizeof(char));
+			WriteAsync(fp, subPath, (LONG)(strlen(subPath) * sizeof(char)));
-#endif
+			WriteAsync(fp, "\n", 1 * sizeof(char));
+#else
 	 		fprintf(fp, "%s\t%s\n", dirEntry->d_name, subPath);
 #endif
 	 		++stats->files;
 	if(verbose) {
 		fprintf(stdout, "\n");
+	}
+#if defined ___AsyncIO___
 	CloseAsync(fp);
+#else
 	fclose(fp);
-	fclose(fp);
+#endif
 /*
+	*
 	* Counts the lines in a database file "dbFile".
 	*/
 int CountDatabaseLines(char *dbFile) {
+#if defined ___AsyncIO___
+	struct AsyncFile *fp;
+	LONG c;
+#else
 	FILE *fp;
-	int lines;
 	char c;
+#endif
+	int lines;
+#if defined ___AsyncIO___
+	if((fp = OpenAsync(dbFile, MODE_READ, ASYNC_BUF)) == NULL) {
 #else
+	if((fp = fopen(dbFile, "r")) == NULL) {
-	if((fp = fopen(dbFile, "r")) == NULL) {
+#endif
-		fprintf(stderr, "Unable to open gather database for reading.\n");
-		fclose(fp);
+		fprintf(stderr, "Unable to open gather database for reading.\n");
 		return 0;
+	}
+	lines = 0;
+#if defined ___AsyncIO___
 	while((c = ReadCharAsync(fp)) != -1) {
+#else
-	lines = 0;
+	while(fscanf(fp, "%c", &c) == 1) {
-	while(fscanf(fp, "%c", &c) == 1) {
+#endif
 		switch(c) {
 			case '\n':
 				++lines;
 				break;
+		}
+	}
 #if defined ___AsyncIO___
+	CloseAsync(fp);
 #else
 	fclose(fp);
-	fclose(fp);
+#endif
 /*
+	*
 	* Writes lines from the database "dbFile" to temporary filenames "tmpNames".
 	*/
 void WriteTempFiles(char *dbFile, char **tmpNames, int tmpFiles, int tmpLines, int total) {
+#if defined ___AsyncIO___
+	struct AsyncFile *fp, *tp;
+	LONG c;
+#else
 	FILE *fp, *tp;
 	char c;
+#endif
 	int lines;
 	int linesWritten;
+#if defined ___AsyncIO___
+	if((fp = OpenAsync(dbFile, MODE_READ, ASYNC_BUF)) == NULL) {
 #else
+	if((fp = fopen(dbFile, "r")) == NULL) {
-	if((fp = fopen(dbFile, "r")) == NULL) {
+#endif
 		fprintf(stderr, "Unable to open gather database for reading.\n");
 		return;
+	}
+#if defined ___AsyncIO___
 	if((tp = OpenAsync(tmpNames[--tmpFiles], MODE_READ|MODE_WRITE, ASYNC_BUF)) == NULL) {
+#else
 	if((tp = fopen(tmpNames[--tmpFiles], "w+")) == NULL) {
-	if((tp = fopen(tmpNames[--tmpFiles], "w+")) == NULL) {
-		fprintf(stderr, "Unable to open temporary file '%s' for writing.\n", tmpNames[tmpFiles]);
+#endif
-		fclose(fp);
+		fprintf(stderr, "Unable to open temporary file '%s' for writing.\n", tmpNames[tmpFiles]);
 		return;
+	}
 	if(verbose) {
 		fprintf(stdout, "Writing to temporary files.\r");
+	}
+	linesWritten = 0;
 	lines = 0;
+#if defined ___AsyncIO___
 	while(run && (c = ReadCharAsync(fp)) != -1) {
-	linesWritten = 0;
+#else
-	lines = 0;
+	while(run && fscanf(fp, "%c", &c) == 1) {
-	while(run && fscanf(fp, "%c", &c) == 1) {
+#endif
 #if defined ___AmigaOS___
 				if(verbose) {
 					fprintf(stdout, "Writing to temporary files: %d%%.\r", (int)(((float)linesWritten / total) * 100.0));
+				}
+				// Write the newline character back.
+#if defined ___AsyncIO___
+				if(WriteCharAsync(tp, (UBYTE)c) != 1) {
-				// Write the newline character back.
+#else
+				if(fprintf(tp, "%c", c) != 1) {
-				if(fprintf(tp, "%c", c) != 1) {
+#endif
+					fprintf(stderr, "Unable to write to temporary file '%s'.\n", tmpNames[tmpFiles]);
+#if defined ___AsyncIO___
+					CloseAsync(tp);
+					CloseAsync(fp);
-					fprintf(stderr, "Unable to write to temporary file '%s'.\n", tmpNames[tmpFiles]);
+#else
 					fclose(tp);
+					fclose(fp);
-					fclose(fp);
+#endif
 					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) {
 						break;
+					}
+					// Close the previous temporary file and write to the next temporary file.
+#if defined ___AsyncIO___
+					CloseAsync(tp);
 					if((tp = OpenAsync(tmpNames[--tmpFiles], MODE_READ|MODE_WRITE, ASYNC_BUF)) == NULL) {
-					// Close the previous temporary file and write to the next temporary file.
+#else
+					fclose(tp);
-					fclose(tp);
+					if((tp = fopen(tmpNames[--tmpFiles], "w+")) == NULL) {
+#endif
+						fprintf(stderr, "Unable to open temporary file '%s' for writing.\n", tmpNames[tmpFiles]);
+#if defined ___AsyncIO___
+						CloseAsync(tp);
-					if((tp = fopen(tmpNames[--tmpFiles], "w+")) == NULL) {
+						CloseAsync(fp);
-						fprintf(stderr, "Unable to open temporary file '%s' for writing.\n", tmpNames[tmpFiles]);
+#else
+						fclose(tp);
-						fclose(tp);
+						fclose(fp);
-						fclose(fp);
+#endif
+					}
 					lines = 0;
 					break;
+				}
+				break;
+			default:
+#if defined ___AsyncIO___
-				break;
+				if(WriteCharAsync(tp, (UBYTE)c) != 1) {
+#else
-			default:
+				if(fprintf(tp, "%c", c) != 1) {
+#endif
+					fprintf(stderr, "Unable to write to temporary file '%s'.\n", tmpNames[tmpFiles]);
+#if defined ___AsyncIO___
+					CloseAsync(tp);
-				if(fprintf(tp, "%c", c) != 1) {
+					CloseAsync(fp);
-					fprintf(stderr, "Unable to write to temporary file '%s'.\n", tmpNames[tmpFiles]);
+#else
+					fclose(tp);
-					fclose(tp);
+					fclose(fp);
-					fclose(fp);
+#endif
 					return;
+				}
 				break;
+		}
+	}
+	fprintf(stdout, "\n");
 #if defined ___AsyncIO___
 	CloseAsync(tp);
+	CloseAsync(fp);
-	fprintf(stdout, "\n");
+#else
 	fclose(tp);
-	fclose(tp);
+	fclose(fp);
-	fclose(fp);
+#endif
+}
+/*
+	*
+	* Skips a line in a database file "fp".
+	*/
 #if defined ___AsyncIO___
-/*
+void SkipDatabaseLine(struct AsyncFile *fp) {
-	*
-	* Skips a line in a database file "fp".
+	LONG c;
+	while((c = ReadCharAsync(fp)) != -1) {
+#else
-	*/
+void SkipDatabaseLine(FILE *fp) {
-void SkipDatabaseLine(FILE *fp) {
+	char c;
-	char c;
+	while(fscanf(fp, "%c", &c) == 1) {
 #endif
-	while(fscanf(fp, "%c", &c) == 1) {
-		if(c == '\n') {
-			break;
+		switch(c) {
 			case '\n':
 				return;
+		}
 	return;
+}
+/*
+	*
 	* Reads a line from the database file "fp".
 	*/
+#if defined ___AsyncIO___
-/*
+char *ReadDatabaseLine(struct AsyncFile *fp) {
 	LONG c;
-	* Reads a line from the database file "fp".
+#else
-	*/
+char *ReadDatabaseLine(FILE *fp) {
-char *ReadDatabaseLine(FILE *fp) {
+	char c;
-	char c;
+#endif
+	char *line;
+	int line_size;
+	int i;
 	char *line;
+	line_size = LINE_BUF;
-	int line_size;
+	line = malloc(line_size * sizeof(*line));
 	int i;
 	i = 0;
-	line_size = LINE_BUF;
+#if defined ___AsyncIO___
-	line = malloc(line_size * sizeof(*line));
+	while(run && (c = ReadCharAsync(fp)) != -1) {
 #else
-	i = 0;
+	while(run && fscanf(fp, "%c", &c) == 1) {
-	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;
+		}
+#endif
+		switch(c) {
-		// Check if CTRL+C was pressed and abort the program.
+			case '\n':
+				// Rewind the file by the number of read characters.
-		if(SetSignal(0L, SIGBREAKF_CTRL_C) & SIGBREAKF_CTRL_C) {
+#if defined ___AsyncIO___
-			run = FALSE;
+				if(SeekAsync(fp, -(i + 1), MODE_CURRENT) == -1) {
 					fprintf(stderr, "Could not seek in file.\n");
-#endif
+					return NULL;
 		switch(c) {
 /*
+	*
 	* Merges temporary files "tmpNames" into a database "dbFile".
 	*/
 void MergeDatabase(char *dbFile, char **tmpNames, int files, int lines) {
+#if defined ___AsyncIO___
+	struct AsyncFile *fp;
+	struct AsyncFile **tp;
+#else
 	FILE *fp;
 	FILE **tp;
+#endif
 	int i;
 	int j;
 	char *tmp;
 	char *min;
 	int count;
+#if defined ___AsyncIO___
+	if((fp = OpenAsync(dbFile, MODE_READ|MODE_WRITE, ASYNC_BUF)) == NULL) {
 #else
+	if((fp = fopen(dbFile, "w+")) == NULL) {
-	if((fp = fopen(dbFile, "w+")) == NULL) {
+#endif
 		fprintf(stderr, "Unable to open gather database for writing.\n");
 		return;
+	}
 	// Allocate as many file pointers as temporary files.
 	tp = malloc(files * sizeof(*tp));
+	// Open all temporary files for reading.
+	for(i = 0; i < files; ++i) {
 #if defined ___AsyncIO___
+		if((tp[i] = OpenAsync(tmpNames[i], MODE_READ, ASYNC_BUF)) == NULL) {
-	// Open all temporary files for reading.
+#else
-	for(i = 0; i < files; ++i) {
+		if((tp[i] = fopen(tmpNames[i], "r")) == NULL) {
-		if((tp[i] = fopen(tmpNames[i], "r")) == NULL) {
+#endif
 			fprintf(stderr, "Unable to open temporary file '%s' for reading.\n", tmpNames[i]);
+			// Close all temporary files.
+			--i;
+			while(i >= 0) {
-			// Close all temporary files.
+#if defined ___AsyncIO___
+				CloseAsync(tp[i]);
-			--i;
+#else
-			while(i >= 0) {
+				fclose(tp[i]);
-				fclose(tp[i]);
+#endif
+			}
 		// Forward the file where the smallest line was found.
 		SkipDatabaseLine(tp[j]);
 		// Write the smallest line.
+		if(min != NULL) {
+#if defined ___AsyncIO___
+			WriteAsync(fp, min, (LONG)(strlen(min) * sizeof(char)));
+			WriteAsync(fp, "\n", 1 * sizeof(char));
-		if(min != NULL) {
+#else
+			fprintf(fp, "%s\n", min);
-			fprintf(fp, "%s\n", min);
+#endif
 			free(min);
+		}
+	}
 	// Write out any remaining contents from the temporary files.
 	for(i = 0; i < files; ++i) {
 		tmp = ReadDatabaseLine(tp[i]);
 		if(tmp == NULL) {
+			continue;
+		}
+#if defined ___AsyncIO___
+		WriteAsync(fp, tmp, (LONG)(strlen(tmp) * sizeof(char)));
-			continue;
+		WriteAsync(fp, "\n", 1 * sizeof(char));
+#else
 		fprintf(fp, "%s\n", tmp);
-		fprintf(fp, "%s\n", tmp);
+#endif
 		free(tmp);
+	}
+	// Close and delete all temporary files.
+	for(i = 0; i < files; ++i) {
 #if defined ___AsyncIO___
+		CloseAsync(tp[i]);
-	// Close and delete all temporary files.
+#else
-	for(i = 0; i < files; ++i) {
+		fclose(tp[i]);
-		fclose(tp[i]);
+#endif
 		// Delete temporary file.
 		remove(tmpNames[i]);
+	}
+	if(verbose) {
+		fprintf(stdout, "\n");
+	}
-	if(verbose) {
+#if defined ___AsyncIO___
-		fprintf(stdout, "\n");
+	CloseAsync(fp);
 #else
 	fclose(fp);