X-Git-Url: https://git.donarmstrong.com/?a=blobdiff_plain;f=mothurout.cpp;h=6ecb86f94e5533165551ed5ae571f0c51f3c9ff9;hb=36a6b02cf7f09d2bc34376b588944a9ca73429c5;hp=c2ef698db8ed4d9c0769fcd4295a27a886c65bfc;hpb=4160a27002f4a3ca436fcd62eca0366b09f8e901;p=mothur.git

diff --git a/mothurout.cpp b/mothurout.cpp
index c2ef698..6ecb86f 100644
--- a/mothurout.cpp
+++ b/mothurout.cpp
@@ -40,6 +40,7 @@ void MothurOut::printCurrentFiles()  {
 		if (taxonomyfile != "")		{  mothurOut("taxonomy=" + taxonomyfile); mothurOutEndLine();		}
 		if (treefile != "")			{  mothurOut("tree=" + treefile); mothurOutEndLine();				}
 		if (flowfile != "")			{  mothurOut("flow=" + flowfile); mothurOutEndLine();				}
+        if (biomfile != "")			{  mothurOut("biom=" + biomfile); mothurOutEndLine();				}
 		if (processors != "1")		{  mothurOut("processors=" + processors); mothurOutEndLine();		}
 		
 	}
@@ -73,6 +74,7 @@ bool MothurOut::hasCurrentFiles()  {
 		if (taxonomyfile != "")		{  return true;			}
 		if (treefile != "")			{  return true;			}
 		if (flowfile != "")			{  return true;			}
+        if (biomfile != "")			{  return true;			}
 		if (processors != "1")		{  return true;			}
 		
 		return hasCurrent;
@@ -107,6 +109,7 @@ void MothurOut::clearCurrentFiles()  {
 		accnosfile = "";
 		taxonomyfile = "";	
 		flowfile = "";
+        biomfile = "";
 		processors = "1";
 	}
 	catch(exception& e) {
@@ -114,6 +117,81 @@ void MothurOut::clearCurrentFiles()  {
 		exit(1);
 	}
 }
+/***********************************************************************/
+string MothurOut::findProgramPath(string programName){
+	try { 
+		
+		string envPath = getenv("PATH");
+		string pPath = "";
+		
+		//delimiting path char
+		char delim;
+#if defined (__APPLE__) || (__MACH__) || (linux) || (__linux) || (__linux__) || (__unix__) || (__unix)
+        delim = ':';
+#else
+        delim = ';';
+#endif
+		
+		//break apart path variable by ':'
+		vector<string> dirs;
+		splitAtChar(envPath, dirs, delim);
+		
+        if (debug) { mothurOut("[DEBUG]: dir's in path: \n"); }
+        
+		//get path related to mothur
+		for (int i = 0; i < dirs.size(); i++) {
+            
+            if (debug) { mothurOut("[DEBUG]: " + dirs[i] + "\n"); }
+            
+			//to lower so we can find it
+			string tempLower = "";
+			for (int j = 0; j < dirs[i].length(); j++) {  tempLower += tolower(dirs[i][j]);  }
+			
+			//is this mothurs path?
+			if (tempLower.find(programName) != -1) {  pPath = dirs[i]; break;  }
+		}
+        
+		if (debug) { mothurOut("[DEBUG]: programPath = " + pPath + "\n"); }
+        
+		if (pPath != "") {
+			//add programName so it looks like what argv would look like
+#if defined (__APPLE__) || (__MACH__) || (linux) || (__linux) || (__linux__) || (__unix__) || (__unix)
+            pPath += "/" + programName;
+#else
+            pPath += "\\" + programName;
+#endif
+		}else {
+			//okay programName is not in the path, so the folder programName is in must be in the path
+			//lets find out which one
+			
+			//get path related to the program
+			for (int i = 0; i < dirs.size(); i++) {
+                
+                if (debug) { mothurOut("[DEBUG]: looking in " + dirs[i] + " for " + programName + " \n"); }
+                
+				//is this the programs path?
+				ifstream in;
+				string tempIn = dirs[i];
+#if defined (__APPLE__) || (__MACH__) || (linux) || (__linux) || (__linux__) || (__unix__) || (__unix)
+                tempIn += "/" + programName;
+#else
+                tempIn += "\\" + programName;
+#endif
+				openInputFile(tempIn, in, "");
+				
+				//if this file exists
+				if (in) { in.close(); pPath = tempIn; if (debug) { mothurOut("[DEBUG]: found it, programPath = " + pPath + "\n"); } break;   }
+			}
+		}
+		
+		return pPath;
+		
+	}
+	catch(exception& e) {
+		errorOut(e, "MothurOut", "findProgramPath");
+		exit(1);
+	}
+}
 /*********************************************************************************************/
 void MothurOut::setFileName(string filename)  {
 	try {
@@ -143,7 +221,7 @@ void MothurOut::setDefaultPath(string pathname)  {
 	
 		//add / to name if needed
 		string lastChar = pathname.substr(pathname.length()-1);
-		#if defined (__APPLE__) || (__MACH__) || (linux) || (__linux)
+		#if defined (__APPLE__) || (__MACH__) || (linux) || (__linux) || (__linux__) || (__unix__) || (__unix)
 			if (lastChar != "/") { pathname += "/"; }
 		#else
 			if (lastChar != "\\") { pathname += "\\"; }	
@@ -212,8 +290,8 @@ void MothurOut::mothurOut(string output) {
 			if (pid == 0) { //only one process should output to screen
 		#endif
 		
-		cout << output;
 		out << output;
+        logger() << output;
 		
 		#ifdef USE_MPI
 			}
@@ -234,8 +312,8 @@ void MothurOut::mothurOutEndLine() {
 			if (pid == 0) { //only one process should output to screen
 		#endif
 		
-		cout << endl;
 		out << endl;
+        logger() << endl;
 		
 		#ifdef USE_MPI
 			}
@@ -247,6 +325,55 @@ void MothurOut::mothurOutEndLine() {
 	}
 }
 /*********************************************************************************************/
+void MothurOut::mothurOut(string output, ofstream& outputFile) {
+	try {
+		
+#ifdef USE_MPI
+		int pid;
+		MPI_Comm_rank(MPI_COMM_WORLD, &pid); 
+		
+		if (pid == 0) { //only one process should output to screen
+#endif
+			
+			
+			out << output;
+			outputFile << output;
+            logger() << output;
+			
+#ifdef USE_MPI
+		}
+#endif
+        
+	}
+	catch(exception& e) {
+		errorOut(e, "MothurOut", "MothurOut");
+		exit(1);
+	}
+}
+/*********************************************************************************************/
+void MothurOut::mothurOutEndLine(ofstream& outputFile) {
+	try {
+#ifdef USE_MPI
+		int pid;
+		MPI_Comm_rank(MPI_COMM_WORLD, &pid); 
+		
+		if (pid == 0) { //only one process should output to screen
+#endif
+			
+			out << endl;
+			outputFile << endl;
+            logger() << endl;
+			
+#ifdef USE_MPI
+		}
+#endif
+	}
+	catch(exception& e) {
+		errorOut(e, "MothurOut", "MothurOutEndLine");
+		exit(1);
+	}
+}
+/*********************************************************************************************/
 void MothurOut::mothurOutJustToLog(string output) {
 	try {
 		#ifdef USE_MPI
@@ -285,7 +412,7 @@ void MothurOut::errorOut(exception& e, string object, string function) {
 //
 // On failure, returns 0.0, 0.0
 int MothurOut::mem_usage(double& vm_usage, double& resident_set) {
-  #if defined (__APPLE__) || (__MACH__) || (linux) || (__linux)
+  #if defined (__APPLE__) || (__MACH__) || (linux) || (__linux) || (__linux__) || (__unix__) || (__unix)
   
 	   vm_usage     = 0.0;
 	   resident_set = 0.0;
@@ -387,7 +514,7 @@ void MothurOut::gobble(istream& f){
 		
 		char d;
 		while(isspace(d=f.get()))		{ ;}
-		f.putback(d);
+		if(!f.eof()) { f.putback(d); }
 	}
 	catch(exception& e) {
 		errorOut(e, "MothurOut", "gobble");
@@ -399,7 +526,7 @@ void MothurOut::gobble(istringstream& f){
 	try {
 		char d;
 		while(isspace(d=f.get()))		{;}
-		f.putback(d);
+		if(!f.eof()) { f.putback(d); }
 	}
 	catch(exception& e) {
 		errorOut(e, "MothurOut", "gobble");
@@ -457,7 +584,7 @@ string MothurOut::getline(ifstream& fileHandle) {
 }
 /***********************************************************************/
 
-#if defined (__APPLE__) || (__MACH__) || (linux) || (__linux)
+#if defined (__APPLE__) || (__MACH__) || (linux) || (__linux) || (__linux__) || (__unix__) || (__unix)
 #ifdef USE_COMPRESSION
 inline bool endsWith(string s, const char * suffix){
   size_t suffixLength = strlen(suffix);
@@ -471,7 +598,7 @@ string MothurOut::getRootName(string longName){
 	
 		string rootName = longName;
 
-#if defined (__APPLE__) || (__MACH__) || (linux) || (__linux)
+#if defined (__APPLE__) || (__MACH__) || (linux) || (__linux) || (__linux__) || (__unix__) || (__unix)
 #ifdef USE_COMPRESSION
     if (endsWith(rootName, ".gz") || endsWith(rootName, ".bz2")) {
       int pos = rootName.find_last_of('.');
@@ -515,6 +642,21 @@ string MothurOut::getSimpleName(string longName){
 
 /***********************************************************************/
 
+int MothurOut::getRandomIndex(int highest){
+	try {
+		
+		int random = (int) ((float)(highest+1) * (float)(rand()) / ((float)RAND_MAX+1.0));
+		
+		return random;
+	}
+	catch(exception& e) {
+		errorOut(e, "MothurOut", "getRandomIndex");
+		exit(1);
+	}	
+	
+}
+/**********************************************************************/
+
 string MothurOut::getPathName(string longName){
 	try {
 		string rootPathName = longName;
@@ -534,6 +676,48 @@ string MothurOut::getPathName(string longName){
 }
 /***********************************************************************/
 
+bool MothurOut::dirCheck(string& dirName){
+	try {
+        
+        string tag = "";
+        #ifdef USE_MPI
+            int pid; 
+            MPI_Comm_rank(MPI_COMM_WORLD, &pid); //find out who we are
+		
+            tag = toString(pid);
+        #endif
+
+        //add / to name if needed
+        string lastChar = dirName.substr(dirName.length()-1);
+        #if defined (__APPLE__) || (__MACH__) || (linux) || (__linux) || (__linux__) || (__unix__) || (__unix)
+        if (lastChar != "/") { dirName += "/"; }
+        #else
+        if (lastChar != "\\") { dirName += "\\"; }	
+        #endif
+
+        //test to make sure directory exists
+        dirName = getFullPathName(dirName);
+        string outTemp = dirName + tag + "temp";
+        ofstream out;
+        out.open(outTemp.c_str(), ios::trunc);
+        if(!out) {
+            mothurOut(dirName + " directory does not exist or is not writable."); mothurOutEndLine(); 
+        }else{
+            out.close();
+            mothurRemove(outTemp);
+            return true;
+        }
+        
+        return false;
+    }
+	catch(exception& e) {
+		errorOut(e, "MothurOut", "dirCheck");
+		exit(1);
+	}	
+    
+}
+/***********************************************************************/
+
 string MothurOut::hasPath(string longName){
 	try {
 		string path = "";
@@ -557,7 +741,7 @@ string MothurOut::hasPath(string longName){
 
 string MothurOut::getExtension(string longName){
 	try {
-		string extension = longName;
+		string extension = "";
 		
 		if(longName.find_last_of('.') != longName.npos){
 			int pos = longName.find_last_of('.');
@@ -611,7 +795,7 @@ string MothurOut::getFullPathName(string fileName){
 				
 		string cwd;
 		//get current working directory 
-		#if defined (__APPLE__) || (__MACH__) || (linux) || (__linux)	
+		#if defined (__APPLE__) || (__MACH__) || (linux) || (__linux) || (__linux__) || (__unix__) || (__unix)	
 			
 			if (path.find("~") != -1) { //go to home directory
 				string homeDir;
@@ -664,7 +848,7 @@ string MothurOut::getFullPathName(string fileName){
 					}else if (path[(pos-1)] == '/') { //you want the current working dir ./
 						path = path.substr(0, pos);
 					}else if (pos == 1) { break;  //you are at the end
-					}else { cout << "cannot resolve path for " <<  fileName << endl; return fileName; }
+					}else { mothurOut("cannot resolve path for " +  fileName + "\n"); return fileName; }
 				}
 			
 				for (int i = index; i >= 0; i--) {
@@ -710,7 +894,7 @@ string MothurOut::getFullPathName(string fileName){
 					}else if (path[(pos-1)] == '\\') { //you want the current working dir ./
 						path = path.substr(0, pos);
 					}else if (pos == 1) { break;  //you are at the end
-					}else { cout << "cannot resolve path for " <<  fileName << endl; return fileName; }
+					}else { mothurOut("cannot resolve path for " +  fileName + "\n"); return fileName; }
 				}
 			
 				for (int i = index; i >= 0; i--) {
@@ -734,7 +918,7 @@ int MothurOut::openInputFile(string fileName, ifstream& fileHandle, string m){
 	try {
 			//get full path name
 			string completeFileName = getFullPathName(fileName);
-#if defined (__APPLE__) || (__MACH__) || (linux) || (__linux)
+#if defined (__APPLE__) || (__MACH__) || (linux) || (__linux) || (__linux__) || (__unix__) || (__unix)
 #ifdef USE_COMPRESSION
       // check for gzipped or bzipped file
       if (endsWith(completeFileName, ".gz") || endsWith(completeFileName, ".bz2")) {
@@ -749,7 +933,7 @@ int MothurOut::openInputFile(string fileName, ifstream& fileHandle, string m){
           cerr << "Decompressing " << completeFileName << " via temporary named pipe " << tempName << "\n";
           system(command.c_str());
           cerr << "Done decompressing " << completeFileName << "\n";
-          remove(tempName.c_str());
+          mothurRemove(tempName);
           exit(EXIT_SUCCESS);
         } else {
           cerr << "waiting on child process " << fork_result << "\n";
@@ -780,7 +964,7 @@ int MothurOut::openInputFile(string fileName, ifstream& fileHandle){
 
 		//get full path name
 		string completeFileName = getFullPathName(fileName);
-#if defined (__APPLE__) || (__MACH__) || (linux) || (__linux)
+#if defined (__APPLE__) || (__MACH__) || (linux) || (__linux) || (__linux__) || (__unix__) || (__unix)
 #ifdef USE_COMPRESSION
   // check for gzipped or bzipped file
   if (endsWith(completeFileName, ".gz") || endsWith(completeFileName, ".bz2")) {
@@ -795,7 +979,7 @@ int MothurOut::openInputFile(string fileName, ifstream& fileHandle){
       cerr << "Decompressing " << completeFileName << " via temporary named pipe " << tempName << "\n";
       system(command.c_str());
       cerr << "Done decompressing " << completeFileName << "\n";
-      remove(tempName.c_str());
+      mothurRemove(tempName);
       exit(EXIT_SUCCESS);
     } else {
       cerr << "waiting on child process " << fork_result << "\n";
@@ -829,10 +1013,10 @@ int MothurOut::renameFile(string oldName, string newName){
 	try {
 		ifstream inTest;
 		int exist = openInputFile(newName, inTest, "");
+		inTest.close();
 		
-	#if defined (__APPLE__) || (__MACH__) || (linux) || (__linux)		
+	#if defined (__APPLE__) || (__MACH__) || (linux) || (__linux) || (__linux__) || (__unix__) || (__unix)		
 		if (exist == 0) { //you could open it so you want to delete it
-			inTest.close();
 			string command = "rm " + newName;
 			system(command.c_str());
 		}
@@ -840,7 +1024,7 @@ int MothurOut::renameFile(string oldName, string newName){
 		string command = "mv " + oldName + " " + newName;
 		system(command.c_str());
 	#else
-		remove(newName.c_str());
+		mothurRemove(newName);
 		int renameOk = rename(oldName.c_str(), newName.c_str());
 	#endif
 		return 0;
@@ -858,7 +1042,7 @@ int MothurOut::openOutputFile(string fileName, ofstream& fileHandle){
 	try { 
 	
 		string completeFileName = getFullPathName(fileName);
-#if defined (__APPLE__) || (__MACH__) || (linux) || (__linux)
+#if defined (__APPLE__) || (__MACH__) || (linux) || (__linux) || (__linux__) || (__unix__) || (__unix)
 #ifdef USE_COMPRESSION
     // check for gzipped file
     if (endsWith(completeFileName, ".gz") || endsWith(completeFileName, ".bz2")) {
@@ -896,7 +1080,7 @@ int MothurOut::openOutputFile(string fileName, ofstream& fileHandle){
 }
 
 /**************************************************************************************************/
-void MothurOut::appendFiles(string temp, string filename) {
+int MothurOut::appendFiles(string temp, string filename) {
 	try{
 		ofstream output;
 		ifstream input;
@@ -906,15 +1090,19 @@ void MothurOut::appendFiles(string temp, string filename) {
 		int ableToOpen = openInputFile(temp, input, "no error");
 		//int ableToOpen = openInputFile(temp, input);
 		
+		int numLines = 0;
 		if (ableToOpen == 0) { //you opened it
-			while(char c = input.get()){
+			while(!input.eof()){
+                char c = input.get();
 				if(input.eof())		{	break;			}
-				else				{	output << c;	}
+				else				{	output << c;	if (c == '\n') {numLines++;} }
 			}
 			input.close();
 		}
 		
 		output.close();
+		
+		return numLines;
 	}
 	catch(exception& e) {
 		errorOut(e, "MothurOut", "appendFiles");
@@ -931,7 +1119,7 @@ string MothurOut::sortFile(string distFile, string outputDir){
 
 		
 		//if you can, use the unix sort since its been optimized for years
-		#if defined (__APPLE__) || (__MACH__) || (linux) || (__linux)
+		#if defined (__APPLE__) || (__MACH__) || (linux) || (__linux) || (__linux__) || (__unix__) || (__unix)
 			string command = "sort -n -k +3 " + distFile + " -o " + outfile;
 			system(command.c_str());
 		#else //you are stuck with my best attempt...
@@ -976,8 +1164,8 @@ string MothurOut::sortFile(string distFile, string outputDir){
 			output.close();
 		
 			//remove temp files
-			remove(tempDistFile.c_str());
-			remove(tempOutfile.c_str());
+			mothurRemove(tempDistFile);
+			mothurRemove(tempOutfile);
 		#endif
 		
 		return outfile;
@@ -988,19 +1176,27 @@ string MothurOut::sortFile(string distFile, string outputDir){
 	}	
 }
 /**************************************************************************************************/
-vector<unsigned long int> MothurOut::setFilePosFasta(string filename, int& num) {
+vector<unsigned long long> MothurOut::setFilePosFasta(string filename, int& num) {
 	try {
-			vector<unsigned long int> positions;
+			vector<unsigned long long> positions;
 			ifstream inFASTA;
-			openInputFile(filename, inFASTA);
+			//openInputFile(filename, inFASTA);
+			inFASTA.open(filename.c_str(), ios::binary);
 						
 			string input;
+			unsigned long long count = 0;
 			while(!inFASTA.eof()){
-				input = getline(inFASTA); 
-				if (input.length() != 0) {
-					if(input[0] == '>'){	unsigned long int pos = inFASTA.tellg(); positions.push_back(pos - input.length() - 1);	}
+				//input = getline(inFASTA); 
+				//cout << input << '\t' << inFASTA.tellg() << endl;
+				//if (input.length() != 0) {
+				//	if(input[0] == '>'){	unsigned long int pos = inFASTA.tellg(); positions.push_back(pos - input.length() - 1);	 cout << (pos - input.length() - 1) << endl; }
+				//}
+				//gobble(inFASTA); //has to be here since windows line endings are 2 characters and mess up the positions
+				char c = inFASTA.get(); count++;
+				if (c == '>') {
+					positions.push_back(count-1);
+					//cout << count << endl;
 				}
-				gobble(inFASTA); //has to be here since windows line endings are 2 characters and mess up the positions
 			}
 			inFASTA.close();
 		
@@ -1018,7 +1214,7 @@ vector<unsigned long int> MothurOut::setFilePosFasta(string filename, int& num)
 				fclose (pFile);
 			}*/
 			
-			unsigned long int size = positions[(positions.size()-1)];
+			unsigned long long size = positions[(positions.size()-1)];
 			ifstream in;
 			openInputFile(filename, in);
 			
@@ -1031,6 +1227,7 @@ vector<unsigned long int> MothurOut::setFilePosFasta(string filename, int& num)
 			in.close();
 		
 			positions.push_back(size);
+			positions[0] = 0;
 		
 			return positions;
 	}
@@ -1040,31 +1237,51 @@ vector<unsigned long int> MothurOut::setFilePosFasta(string filename, int& num)
 	}
 }
 /**************************************************************************************************/
-vector<unsigned long int> MothurOut::setFilePosEachLine(string filename, int& num) {
+vector<unsigned long long> MothurOut::setFilePosEachLine(string filename, int& num) {
 	try {
 			filename = getFullPathName(filename);
 			
-			vector<unsigned long int> positions;
+			vector<unsigned long long> positions;
 			ifstream in;
-			openInputFile(filename, in);
-				
+			//openInputFile(filename, in);
+			in.open(filename.c_str(), ios::binary);
+		
 			string input;
+			unsigned long long count = 0;
+			positions.push_back(0);
+		
 			while(!in.eof()){
-				unsigned long int lastpos = in.tellg();
-				input = getline(in); 
-				if (input.length() != 0) {
-					unsigned long int pos = in.tellg(); 
-					if (pos != -1) { positions.push_back(pos - input.length() - 1);	}
-					else {  positions.push_back(lastpos);  }
+				//unsigned long long lastpos = in.tellg();
+				//input = getline(in); 
+				//if (input.length() != 0) {
+					//unsigned long long pos = in.tellg(); 
+					//if (pos != -1) { positions.push_back(pos - input.length() - 1);	}
+					//else {  positions.push_back(lastpos);  }
+				//}
+				//gobble(in); //has to be here since windows line endings are 2 characters and mess up the positions
+				
+				
+				//getline counting reads
+				char d = in.get(); count++;
+				while ((d != '\n') && (d != '\r') && (d != '\f') && (d != in.eof()))	{
+					//get next character
+					d = in.get(); 
+					count++;
 				}
-				gobble(in); //has to be here since windows line endings are 2 characters and mess up the positions
+				
+				if (!in.eof()) {
+					d=in.get(); count++;
+					while(isspace(d) && (d != in.eof()))		{ d=in.get(); count++;}
+				}
+				positions.push_back(count-1);
+				//cout << count-1 << endl;
 			}
 			in.close();
 		
-			num = positions.size();
+			num = positions.size()-1;
 		
 			FILE * pFile;
-			unsigned long int size;
+			unsigned long long size;
 			
 			//get num bytes in file
 			pFile = fopen (filename.c_str(),"rb");
@@ -1075,7 +1292,7 @@ vector<unsigned long int> MothurOut::setFilePosEachLine(string filename, int& nu
 				fclose (pFile);
 			}
 		
-			positions.push_back(size);
+			positions[(positions.size()-1)] = size;
 		
 			return positions;
 	}
@@ -1086,17 +1303,16 @@ vector<unsigned long int> MothurOut::setFilePosEachLine(string filename, int& nu
 }
 /**************************************************************************************************/
 
-vector<unsigned long int> MothurOut::divideFile(string filename, int& proc) {
+vector<unsigned long long> MothurOut::divideFile(string filename, int& proc) {
 	try{
-	
-		vector<unsigned long int> filePos;
+		vector<unsigned long long> filePos;
 		filePos.push_back(0);
 		
 		FILE * pFile;
-		unsigned long int size;
+		unsigned long long size;
 		
 		filename = getFullPathName(filename);
-		
+	
 		//get num bytes in file
 		pFile = fopen (filename.c_str(),"rb");
 		if (pFile==NULL) perror ("Error opening file");
@@ -1105,9 +1321,11 @@ vector<unsigned long int> MothurOut::divideFile(string filename, int& proc) {
 			size=ftell (pFile);
 			fclose (pFile);
 		}
-	
+		
+	#if defined (__APPLE__) || (__MACH__) || (linux) || (__linux) || (__linux__) || (__unix__) || (__unix)
+				
 		//estimate file breaks
-		unsigned long int chunkSize = 0;
+		unsigned long long chunkSize = 0;
 		chunkSize = size / proc;
 
 		//file to small to divide by processors
@@ -1115,21 +1333,24 @@ vector<unsigned long int> MothurOut::divideFile(string filename, int& proc) {
 	
 		//for each process seekg to closest file break and search for next '>' char. make that the filebreak
 		for (int i = 0; i < proc; i++) {
-			unsigned long int spot = (i+1) * chunkSize;
+			unsigned long long spot = (i+1) * chunkSize;
 			
 			ifstream in;
 			openInputFile(filename, in);
 			in.seekg(spot);
 			
 			//look for next '>'
-			unsigned long int newSpot = spot;
+			unsigned long long newSpot = spot;
 			while (!in.eof()) {
 			   char c = in.get();
+				
 			   if (c == '>') {   in.putback(c); newSpot = in.tellg(); break;  }
+			   else if (int(c) == -1) { break; }
+				
 			}
 		
 			//there was not another sequence before the end of the file
-			unsigned long int sanityPos = in.tellg();
+			unsigned long long sanityPos = in.tellg();
 
 			if (sanityPos == -1) {	break;  }
 			else {  filePos.push_back(newSpot);  }
@@ -1139,14 +1360,18 @@ vector<unsigned long int> MothurOut::divideFile(string filename, int& proc) {
 		
 		//save end pos
 		filePos.push_back(size);
-
+		
 		//sanity check filePos
 		for (int i = 0; i < (filePos.size()-1); i++) {
 			if (filePos[(i+1)] <= filePos[i]) {  filePos.erase(filePos.begin()+(i+1)); i--; }
 		}
 
 		proc = (filePos.size() - 1);
-		
+#else
+		mothurOut("[ERROR]: Windows version should not be calling the divideFile function."); mothurOutEndLine();
+		proc=1;
+		filePos.push_back(size);
+#endif
 		return filePos;
 	}
 	catch(exception& e) {
@@ -1154,7 +1379,43 @@ vector<unsigned long int> MothurOut::divideFile(string filename, int& proc) {
 		exit(1);
 	}
 }
-
+/**************************************************************************************************/
+int MothurOut::divideFile(string filename, int& proc, vector<string>& files) {
+	try{
+		
+		vector<unsigned long long> filePos = divideFile(filename, proc);
+		
+		for (int i = 0; i < (filePos.size()-1); i++) {
+			
+			//read file chunk
+			ifstream in;
+			openInputFile(filename, in);
+			in.seekg(filePos[i]);
+			unsigned long long size = filePos[(i+1)] - filePos[i];
+			char* chunk = new char[size];
+			in.read(chunk, size);
+			in.close();
+			
+			//open new file
+			string fileChunkName = filename + "." + toString(i) + ".tmp";
+			ofstream out; 
+			openOutputFile(fileChunkName, out);
+			
+			out << chunk << endl;
+			out.close();
+			delete[] chunk;
+			
+			//save name
+			files.push_back(fileChunkName);
+		}
+				
+		return 0;
+	}
+	catch(exception& e) {
+		errorOut(e, "MothurOut", "divideFile");
+		exit(1);
+	}
+}
 /***********************************************************************/
 
 bool MothurOut::isTrue(string f){
@@ -1194,6 +1455,61 @@ float MothurOut::ceilDist(float dist, int precision){
 	}
 }
 /**********************************************************************************************************************/
+int MothurOut::readNames(string namefile, map<string, string>& nameMap) { 
+	try {
+		
+		//open input file
+		ifstream in;
+		openInputFile(namefile, in);
+		
+		while (!in.eof()) {
+			if (control_pressed) { break; }
+			
+			string firstCol, secondCol;
+			in >> firstCol >> secondCol; gobble(in);
+			
+			nameMap[firstCol] = secondCol;
+		}
+		in.close();
+		
+		return nameMap.size();
+		
+	}
+	catch(exception& e) {
+		errorOut(e, "MothurOut", "readNames");
+		exit(1);
+	}
+}
+/**********************************************************************************************************************/
+int MothurOut::readNames(string namefile, map<string, vector<string> >& nameMap) { 
+	try {
+		
+		//open input file
+		ifstream in;
+		openInputFile(namefile, in);
+		
+		while (!in.eof()) {
+			if (control_pressed) { break; }
+			
+			string firstCol, secondCol;
+			in >> firstCol >> secondCol; gobble(in);
+			
+			vector<string> temp;
+			splitAtComma(secondCol, temp);
+			
+			nameMap[firstCol] = temp;
+		}
+		in.close();
+		
+		return nameMap.size();
+		
+	}
+	catch(exception& e) {
+		errorOut(e, "MothurOut", "readNames");
+		exit(1);
+	}
+}
+/**********************************************************************************************************************/
 map<string, int> MothurOut::readNames(string namefile) { 
 	try {
 		
@@ -1207,7 +1523,8 @@ map<string, int> MothurOut::readNames(string namefile) {
 			if (control_pressed) { break; }
 			
 			string firstCol, secondCol;
-			in >> firstCol >> secondCol; gobble(in);
+			in >> firstCol;  gobble(in);
+            in >> secondCol; gobble(in);
 			
 			int num = getNumNames(secondCol);
 			
@@ -1282,7 +1599,123 @@ int MothurOut::getNumNames(string names){
 		exit(1);
 	}
 }
+/***********************************************************************/
 
+int MothurOut::getNumChar(string line, char c){
+	try {
+		int count = 0;
+		
+		if(line != ""){
+			for(int i=0;i<line.size();i++){
+				if(line[i] == c){
+					count++;
+				}
+			}
+		}
+		
+		return count;
+	}
+	catch(exception& e) {
+		errorOut(e, "MothurOut", "getNumChar");
+		exit(1);
+	}
+}
+/***********************************************************************/
+int MothurOut::mothurRemove(string filename){
+	try {
+		filename = getFullPathName(filename);
+		int error = remove(filename.c_str());
+		//if (error != 0) { 
+		//	if (errno != ENOENT) { //ENOENT == file does not exist
+		//		string message = "Error deleting file " + filename;
+		//		perror(message.c_str()); 
+		//	}
+		//}
+		return error;
+	}
+	catch(exception& e) {
+		errorOut(e, "MothurOut", "mothurRemove");
+		exit(1);
+	}
+}
+/***********************************************************************/
+bool MothurOut::mothurConvert(string item, int& num){
+	try {
+		bool error = false;
+		
+		if (isNumeric1(item)) {
+			convert(item, num);
+		}else {
+			num = 0;
+			error = true;
+			mothurOut("[ERROR]: cannot convert " + item + " to an integer."); mothurOutEndLine();
+			commandInputsConvertError = true;
+		}
+		
+		return error;
+	}
+	catch(exception& e) {
+		errorOut(e, "MothurOut", "mothurConvert");
+		exit(1);
+	}
+}
+/***********************************************************************/
+bool MothurOut::isNumeric1(string stringToCheck){
+	try {
+		bool numeric = false;
+		
+		if(stringToCheck.find_first_not_of("0123456789.-") == string::npos) { numeric = true; }
+			
+		return numeric;
+	}
+	catch(exception& e) {
+		errorOut(e, "MothurOut", "isNumeric1");
+		exit(1);
+	}
+	
+}
+/***********************************************************************/
+bool MothurOut::mothurConvert(string item, float& num){
+	try {
+		bool error = false;
+		
+		if (isNumeric1(item)) {
+			convert(item, num);
+		}else {
+			num = 0;
+			error = true;
+			mothurOut("[ERROR]: cannot convert " + item + " to a float."); mothurOutEndLine();
+			commandInputsConvertError = true;
+		}
+		
+		return error;
+	}
+	catch(exception& e) {
+		errorOut(e, "MothurOut", "mothurConvert");
+		exit(1);
+	}
+}
+/***********************************************************************/
+bool MothurOut::mothurConvert(string item, double& num){
+	try {
+		bool error = false;
+		
+		if (isNumeric1(item)) {
+			convert(item, num);
+		}else {
+			num = 0;
+			error = true;
+			mothurOut("[ERROR]: cannot convert " + item + " to a double."); mothurOutEndLine();
+			commandInputsConvertError = true;
+		}
+		
+		return error;
+	}
+	catch(exception& e) {
+		errorOut(e, "MothurOut", "mothurConvert");
+		exit(1);
+	}
+}
 /**************************************************************************************************/
 
 vector<vector<double> > MothurOut::binomial(int maxOrder){
@@ -1571,6 +2004,26 @@ void MothurOut::splitAtDash(string& estim, set<int>& container) {
 		exit(1);
 	}	
 }
+/***********************************************************************/
+string MothurOut::makeList(vector<string>& names) {
+	try {
+		string list = "";
+        
+        if (names.size() == 0) { return list; }
+		
+        for (int i = 0; i < names.size()-1; i++) { list += names[i] + ",";  }
+        
+        //get last name
+        list += names[names.size()-1];
+        
+        return list;
+    }
+	catch(exception& e) {
+		errorOut(e, "MothurOut", "makeList");
+		exit(1);
+	}	
+}
+
 /***********************************************************************/
 //This function parses the a string and puts peices in a vector
 void MothurOut::splitAtComma(string& estim, vector<string>& container) {
@@ -1608,6 +2061,25 @@ void MothurOut::splitAtComma(string& estim, vector<string>& container) {
 		exit(1);
 	}	
 }
+/***********************************************************************/
+//This function splits up the various option parameters
+void MothurOut::splitAtChar(string& prefix, string& suffix, char c){
+	try {
+		prefix = suffix.substr(0,suffix.find_first_of(c));
+		if ((suffix.find_first_of(c)+2) <= suffix.length()) {  //checks to make sure you don't have comma at end of string
+			suffix = suffix.substr(suffix.find_first_of(c)+1, suffix.length());
+			string space = " ";
+			while(suffix.at(0) == ' ')
+				suffix = suffix.substr(1, suffix.length());
+		}
+        
+	}
+	catch(exception& e) {
+		errorOut(e, "MothurOut", "splitAtComma");
+		exit(1);
+	}	
+}
+
 /***********************************************************************/
 
 //This function splits up the various option parameters
@@ -1824,6 +2296,46 @@ bool MothurOut::isContainingOnlyDigits(string input) {
 	}
 }
 /**************************************************************************************************/
+int MothurOut::removeConfidences(string& tax) {
+	try {
+		
+		string taxon;
+		string newTax = "";
+		
+		while (tax.find_first_of(';') != -1) {
+			
+			if (control_pressed) { return 0; }
+			
+			//get taxon
+			taxon = tax.substr(0,tax.find_first_of(';'));
+	
+			int pos = taxon.find_last_of('(');
+			if (pos != -1) {
+				//is it a number?
+				int pos2 = taxon.find_last_of(')');
+				if (pos2 != -1) {
+					string confidenceScore = taxon.substr(pos+1, (pos2-(pos+1)));
+					if (isNumeric1(confidenceScore)) {
+						taxon = taxon.substr(0, pos); //rip off confidence 
+					}
+				}
+			}
+			taxon += ";";
+			
+			tax = tax.substr(tax.find_first_of(';')+1, tax.length());
+			newTax += taxon;
+		}
+		
+		tax = newTax;
+		
+		return 0;
+	}
+	catch(exception& e) {
+		errorOut(e, "MothurOut", "removeConfidences");
+		exit(1);
+	}
+}
+/**************************************************************************************************/