HuntnGather – Diff between revs 29 and 30

Subversion Repositories:

?pathlinks?

Rev 29 – Rev 31 – Go to most recent revision – Details – Blame – Last modification – View Log

 		UnLock(lock);
 		return NULL;
+	}
 	UnLock(lock);
 #else
-	abs = realpath(path, NULL);
+	//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;
+	}
 #if defined ___AsyncIO___
 	if(SeekAsync(fp, 0, MODE_END) == -1) {
 #else
-	if(fseek(fp, 0L, SEEK_END) == 0) {
+	if(fseek(fp, 0L, SEEK_END) != 0) {
 #endif
 		fprintf(stderr, "Seek in file %s failed.\n", dbFile);
 #if defined ___AsyncIO___
    	CloseAsync(fp);
 		fprintf(stderr, "Unable to open '%s' for reading.\n", dbFile);
 		return -1;
+	}
+	lines = 0;
+	if(verbose) {
+		fprintf(stdout, "Lines in '%s' so far: %d\r", dbFile, lines);
+	}
 	lines = 0;
 #if defined ___AsyncIO___
 	while(run && (c = ReadCharAsync(fp)) != -1) {
 #else
 	while(run && fscanf(fp, "%c", &c) == 1) {
+		}
 #endif
 		switch(c) {
 			case '\n':
 				++lines;
+				if(verbose) {
+					fprintf(stdout, "Lines in '%s' so far: %d\r", dbFile, lines);
+				}
 				break;
+		}
+	}
 #if defined ___AsyncIO___
 	CloseAsync(fp);
 #else
 	fclose(fp);
+#endif
+	if(verbose) {
+		fprintf(stdout, "\n");
 #endif
 	return lines;
+}
 					fprintf(stderr, "Could not seek in file.\n");
 					free(line);
 					return NULL;
+				}
 #else
-				fseek(fp, -(i + 1), SEEK_CUR);
+				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;
 	FILE *ap;
 	FILE *bp;
 	char c;
 #endif
 	// Open database file for writing.
 #if defined ___AsyncIO___
 	if((ap = OpenAsync(a, MODE_READ, ASYNC_BUF)) == NULL) {
 #else
 	// Open temporary file for reading.
 #if defined ___AsyncIO___
 	if((bp = OpenAsync(b, MODE_WRITE, ASYNC_BUF)) == NULL) {
 #else
-	if((bp = fopen(b, "w+")) == NULL) {
+	if((bp = fopen(b, "w")) == NULL) {
 #endif
 		fprintf(stderr, "Unable to open file '%s' for writing.\n", b);
 #else
 	while(run && fscanf(ap, "%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) {
+   		if(SetSignal(0L, SIGBREAKF_CTRL_C) & SIGBREAKF_CTRL_C) {
 			run = FALSE;
 			continue;
+		}
 #endif
 #if defined ___AsyncIO___
 #if defined ___AsyncIO___
 	struct AsyncFile *fp;
 #else
 	FILE *fp;
 #endif
-	int i;
+	unsigned int i;
 	char *rem;
 	// Write the database lines back to the database.
 #if defined ___AsyncIO___
 	rem = NULL;
 	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) {
+   		if(SetSignal(0L, SIGBREAKF_CTRL_C) & SIGBREAKF_CTRL_C) {
 			run = FALSE;
 			continue;
+		}
 			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(entry);
 		free(line);
+	}
+	*
 	* Sorts a database file lexicographically.
 	*/
 void SortDatabase(char *dbFile) {
 	dbArray *array;
+	int i;
 	if(verbose) {
 		fprintf(stdout, "Sorting '%s'...\n", dbFile);
 	qsort(array->database, array->count, sizeof(char *), QsortCompare);
 	// Write back the database to the database file.
+	WriteLinesToFile(dbFile, array->database, array->count);
+    // Deallocate all the lines.
+    for(i = 0; i < array->count; ++i) {
+       free(array->database[i]);
 	WriteLinesToFile(dbFile, array->database, array->count);
 	free(array);
+}
 	int i;
 	char *path;
 	char *sub;
 	// Initialize metrics.
- 	if((stats = malloc(sizeof(stats))) == NULL) {
+ 	if((stats = malloc(sizeof(*stats))) == NULL) {
  		fprintf(stderr, "Memory allocation failure.\n");
  		return NULL;
+ 	}
  	stats->dirs = 0;
  	stats->files = 0;
 #if defined ___AsyncIO___
 	if((fp = OpenAsync(dbFile, MODE_APPEND, ASYNC_BUF)) == NULL) {
 #else
-	if((fp = fopen(dbFile, "r+")) == NULL) {
+	if((fp = fopen(dbFile, "a")) == NULL) {
 #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
+		fprintf(stderr, "Unable to open '%s' for writing.\n", dbFile);
 		return stats;
+	}
 			fprintf(stderr, "Could not lock path '%s' for reading.\n", path);
 			free(path);
 			continue;
+		}
-		if((FIBp = (struct FileInfoBlock *) AllocDosObject(DOS_FIB, NULL)) == NULL) {
+		if((FIBp = AllocDosObject(DOS_FIB, NULL)) == NULL) {
 			fprintf(stderr, "Path '%s' info block allocation failure.\n", path);
 			UnLock(lockp);
 			free(path);
 			continue;
 		while(run && ExNext(lockp, FIBp)) {
 			// Check if CTRL+C was pressed and abort the program.
 			if(SetSignal(0L, SIGBREAKF_CTRL_C) & SIGBREAKF_CTRL_C) {
+				run = FALSE;
+				FreeDosObject(DOS_FIB, FIBp);
+				UnLock(lockp);
-				run = FALSE;
+				free(path);
-				continue;
+				break;
+			}
 #else
 #endif
 			switch(path[strlen(path) - 1]) {
 				case '/':
 	 			case ':': // This is a drive path.
 #if defined ___AmigaOS___
-					if((sub = malloc(sizeof(path) + sizeof(FIBp->fib_FileName) + 1)) == NULL) {
+					if((sub = malloc(strlen(path) + strlen(FIBp->fib_FileName) + 1)) == NULL) {
 #else
-	 				if((sub = malloc(sizeof(path) + sizeof(entry->d_name) + 1)) == NULL) {
+	 				if((sub = malloc(strlen(path) + strlen(entry->d_name) + 1)) == NULL) {
 #endif
 	 					fprintf(stderr, "Memory allocation failure.\n");
 #if defined ___AmigaOS___
 						FreeDosObject(DOS_FIB, FIBp);
 						UnLock(lockp);
 	 				sprintf(sub, "%s%s", path, entry->d_name);
 #endif
 	 				break;
 	 			default:
 #if defined ___AmigaOS___
-					if((sub = malloc(sizeof(path) + sizeof(FIBp->fib_FileName) + 1 + 1)) == NULL) {
+					if((sub = malloc(strlen(path) + strlen(FIBp->fib_FileName) + 1 + 1)) == NULL) {
 #else
-	 				if((sub = malloc(sizeof(path) + sizeof(entry->d_name) + 1 + 1)) == NULL) {
+	 				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);
 						UnLock(lockp);
 	 				sprintf(sub, "%s/%s", path, entry->d_name);
 #endif
 	 				break;
+			}
 #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 = (struct FileInfoBlock *) AllocDosObject(DOS_FIB, NULL)) == NULL) {
+			if((FIBq = AllocDosObject(DOS_FIB, NULL)) == NULL) {
 				fprintf(stderr, "Path '%s' info block allocation failure.\n", sub);
 				UnLock(lockq);
 				free(sub);
 #if defined ___AmigaOS___
 			FreeDosObject(DOS_FIB, FIBq);
 			UnLock(lockq);
 #endif
+	 		++stats->files;
+	 		if(verbose) {
+	 			fprintf(stdout,
+	 				"Gathered %d directories and %d files.\r",
+	 				stats->dirs,
+	 				stats->files);
+	 		}
 #if defined ___NOCASE_FS___
 #if defined ___AmigaOS___
 			strupr(FIBp->fib_FileName);
 #else
 			strupr(entry->d_name);
 #endif
+#endif
 #endif
 	 		// Write to database file.
 #if defined ___AsyncIO___
 #if defined ___AmigaOS___
 			WriteAsync(fp, FIBp->fib_FileName, (LONG)strlen(FIBp->fib_FileName));
 			fprintf(fp, "%s\t%s\n", FIBp->fib_FileName, sub);
 #else
 	 		fprintf(fp, "%s\t%s\n", entry->d_name, sub);
 #endif
 #endif
-	 		++stats->files;
-	 		if(verbose) {
-	 			fprintf(stdout,
-	 				"Gathered %d directories and %d files.\r",
-	 				stats->dirs,
-	 				stats->files);
-	 		}
 	 		free(sub);
+	 	}
 #if defined ___AmigaOS___
 		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) {
+		if((paths[count] = malloc((strlen(path) + 1) * sizeof(*paths[count]))) == NULL) {
 			fprintf(stderr, "Memory allocation failure.");
 			return 1;
+		}