summaryrefslogblamecommitdiffstats
path: root/lib/inifile/iniFile.cpp
blob: da523e7833d3822f14672e2b2758c8646fff2602 (plain) (tree)
1
2
3
4
5
6
7
8
9
10
11
12
13
14













                                                                                             
                                    




                                                                                              
                  







                    
                           
     
                                   


              
                                                                                               

      

                    



 
                          
                                 
 

 



 
                                                                                
 


                                                                       


                                            

                                           
                                                               





                                                                            
                                                                                      












                                                                           
 
                                





                                                                                       
                                                  



                                    
                                                 
                 
                                                              





                                       
 

                                                                                        
                                      
                 
                                                                                              


                                     
                                                                          


                                 

                                    



                                    
                                                                                               
                                                        
                                         
                                 

                                                                                             





                                      


                                                                    







                                                      
                                                                                 


                                    
                                                                                       




                                          
 
                  
                              
         
                             
         


                                  
                                                       

                    





 
                                                          
 


                                                                       
 
                                                                



                             
 
                                 

                                                                        


                                                          
                            


                            
 
                                 
                                                            



                                                          
                                                                                                




                                                                              
                                                                                       





                                                                                                        
 
                    





 
                                                      
 

                                                             


                                                           
                                     


                    





 
                                                                           
 
                                                        


                            
 

                                                                               


                                                                           
                                            


                    





 
                                                 
 


                                                





 
                                                   
 
                                      






                                    





 
                                                 
 
                                     
         
                                                     

                 





 
                                                         
 
                                     



                          
                                             





 
                                                                        
 
                                                                                    



                                                  





 
                                                                                
 
                                     



                          
                                            





 
                                                                                  
 
                                                                                    



                                                    





 
                                                                                                                     
 
                                     



                           
                                                         





                                     
 
                                                       




















                                                                                          
 
                    





 
                                                                                                                
 


                                                          





 
                                                                                                                   
 


                                                          





 
                                                                                                
 

                               
 



                                                  





 
                                                                                              
 
                                                                                    



                                                   





 
                                                                                                              
 
                                     



                                
 
                                                       



                                
 
                                           





 
                                                                                                     


                                     
                                                                





 
                                                                                                           
 


                                                                







                                                                                                           
                                     
                          




                                                       
                                                       
                            













                                                                                                        


                                                                   









                                                                                                  
                                                                   





 
                                                                  
 
                                                                                    

                                                         

                                                                                      

                                                         




                            



 
                                                                              
 
                                     



                             
 
                                                       



                             
 
                                               

 
 
 
 
 
                                                 
 
                                     




                             
                                                               




                                                             

 




                          
 


                         

 



 
                                                        
 

                                                         

 



 
                                                             
 
                                             



                                           

 



 
                                                 
 
                                             
         
                                                                              



                                               

 



 
                                                      
 
                                     



                                                   

 



 
                                                              
 
                                     
                          
         
                         

                                                

 



 
                                                                      
 
                                     




                                                                                      

 



 
                                                                              
 
                                     



                             
                                             

 



 
                                                                           
 
                                                                                         



                                                       

 



 
                                                                                   
 
                                     



                          
                                                    

 



 
                                                                     
 
                                                                                         
         
                                                                                          



                                                           

 



 
                                                                             
 
                                     



                             
                                                       

 



 
                                                 
 
                                     




                                             

 



 
                                                         
 
                                     



                             
                                             

 



 
                                                    
 



                                 
                       





                                         
 



 
// IniFile.cpp:  Implementation of the CIniFile class.
// Written by:   Adam Clauss
// Email: cabadam@houston.rr.com
// You may use this class/code as you wish in your programs.  Feel free to distribute it, and
// email suggested changes to me.
//
// Rewritten by: Shane Hill
// Date:         21/08/2001
// Email:        Shane.Hill@dsto.defence.gov.au
// Reason:       Remove dependancy on MFC. Code should compile on any
//               platform.
//////////////////////////////////////////////////////////////////////

/*
!! MODIFIED BY FAKETRUTH and xoft !!
*/

#include "Globals.h"  // NOTE: MSVC stupidness requires this to be the same across all modules

// C++ Includes
#include <fstream>

// C Includes
#include <ctype.h>

// Local Includes
#include "iniFile.h"

#if defined(WIN32)
	#define iniEOL endl
#else
	#define iniEOL '\r' << endl
#endif

#ifndef _WIN32
	#define sscanf_s(buffer, stringbuffer, ...) (sscanf(buffer, stringbuffer, __VA_ARGS__))
#endif

using namespace std;





cIniFile::cIniFile(void) :
	m_IsCaseInsensitive(true)
{
}





bool cIniFile::ReadFile(const AString & a_FileName, bool a_AllowExampleRedirect)
{
	// Normally you would use ifstream, but the SGI CC compiler has
	// a few bugs with ifstream. So ... fstream used.
	fstream f;
	AString   line;
	AString   keyname, valuename, value;
	AString::size_type pLeft, pRight;
	bool IsFromExampleRedirect = false;
	
	f.open((FILE_IO_PREFIX + a_FileName).c_str(), ios::in);
	if (f.fail())
	{
		f.clear();
		if (a_AllowExampleRedirect)
		{
			// Retry with the .example.ini file instead of .ini:
			AString ExPath(a_FileName.substr(0, a_FileName.length() - 4));
			ExPath.append(".example.ini");
			f.open((FILE_IO_PREFIX + ExPath).c_str(), ios::in);
			if (f.fail())
			{
				return false;
			}
			IsFromExampleRedirect = true;
		}
		else
		{
			return false;
		}
	}

	while (getline(f, line))
	{
		// To be compatible with Win32, check for existence of '\r'.
		// Win32 files have the '\r' and Unix files don't at the end of a line.
		// Note that the '\r' will be written to INI files from
		// Unix so that the created INI file can be read under Win32
		// without change.
		size_t lineLength = line.length();
		if (lineLength == 0)
		{
			continue;
		}
		if (line[lineLength - 1] == '\r')
		{
			line = line.substr(0, lineLength - 1);
		}

		if (line.length() == 0)
		{
			continue;
		}

		// Check that the user hasn't opened a binary file by checking the first
		// character of each line!
		if (!isprint(line[0]))
		{
			printf("%s: Binary-check failed on char %d\n", __FUNCTION__, line[0]);
			f.close();
			return false;
		}
		if ((pLeft = line.find_first_of(";#[=")) == AString::npos)
		{
			continue;
		}

		switch (line[pLeft])
		{
			case '[':
			{
				if (
					((pRight = line.find_last_of("]")) != AString::npos) &&
					(pRight > pLeft)
					)
				{
					keyname = line.substr(pLeft + 1, pRight - pLeft - 1);
					AddKeyName(keyname);
				}
				break;
			}

			case '=':
			{
				valuename = line.substr(0, pLeft);
				value = line.substr(pLeft + 1);
				SetValue(keyname, valuename, value);
				break;
			}

			case ';':
			case '#':
			{
				if (names.size() == 0)
				{
					AddHeaderComment(line.substr(pLeft + 1));
				}
				else
				{
					AddKeyComment(keyname, line.substr(pLeft + 1));
				}
				break;
			}
		}  // switch (line[pLeft])
	}  // while (getline())

	f.close();
	if (names.size() == 0)
	{
		return false;
	}
	
	if (IsFromExampleRedirect)
	{
		WriteFile(FILE_IO_PREFIX + a_FileName);
	}
	return true;
}





bool cIniFile::WriteFile(const AString & a_FileName) const
{
	// Normally you would use ofstream, but the SGI CC compiler has
	// a few bugs with ofstream. So ... fstream used.
	fstream f;

	f.open((FILE_IO_PREFIX + a_FileName).c_str(), ios::out);
	if (f.fail())
	{
		return false;
	}

	// Write header comments.
	size_t NumComments = comments.size();
	for (size_t commentID = 0; commentID < NumComments; ++commentID)
	{
		f << ';' << comments[commentID] << iniEOL;
	}
	if (NumComments > 0)
	{
		f << iniEOL;
	}

	// Write keys and values.
	for (size_t keyID = 0; keyID < keys.size(); ++keyID)
	{
		f << '[' << names[keyID] << ']' << iniEOL;
		
		// Comments.
		for (size_t commentID = 0; commentID < keys[keyID].comments.size(); ++commentID)
		{
			f << ';' << keys[keyID].comments[commentID] << iniEOL;
		}
		
		// Values.
		for (size_t valueID = 0; valueID < keys[keyID].names.size(); ++valueID)
		{
			f << keys[keyID].names[valueID] << '=' << keys[keyID].values[valueID] << iniEOL;
		}
		f << iniEOL;
	}
	f.close();

	return true;
}





int cIniFile::FindKey(const AString & a_KeyName) const
{
	AString CaseKeyName = CheckCase(a_KeyName);
	for (size_t keyID = 0; keyID < names.size(); ++keyID)
	{
		if (CheckCase(names[keyID]) == CaseKeyName)
		{
			return keyID;
		}
	}
	return noID;
}





int cIniFile::FindValue(const int keyID, const AString & a_ValueName) const
{
	if (!keys.size() || (keyID >= (int)keys.size()))
	{
		return noID;
	}

	AString CaseValueName = CheckCase(a_ValueName);
	for (size_t valueID = 0; valueID < keys[keyID].names.size(); ++valueID)
	{
		if (CheckCase(keys[keyID].names[valueID]) == CaseValueName)
		{
			return int(valueID);
		}
	}
	return noID;
}





int cIniFile::AddKeyName(const AString & keyname)
{
	names.resize(names.size() + 1, keyname);
	keys.resize(keys.size() + 1);
	return names.size() - 1;
}





AString cIniFile::GetKeyName(const int keyID) const
{
	if (keyID < (int)names.size())
	{
		return names[keyID];
	}
	else
	{
		return "";
	}
}





int cIniFile::GetNumValues(const int keyID) const
{
	if (keyID < (int)keys.size())
	{
		return (int)keys[keyID].names.size();
	}
	return 0;
}





int cIniFile::GetNumValues(const AString & keyname) const
{
	int keyID = FindKey(keyname);
	if (keyID == noID)
	{
		return 0;
	}
	return (int)keys[keyID].names.size();
}





AString cIniFile::GetValueName(const int keyID, const int valueID) const
{
	if ((keyID < (int)keys.size()) && (valueID < (int)keys[keyID].names.size()))
	{
		return keys[keyID].names[valueID];
	}
	return "";
}





AString cIniFile::GetValueName(const AString & keyname, const int valueID) const
{
	int keyID = FindKey(keyname);
	if (keyID == noID)
	{
		return "";
	}
	return GetValueName(keyID, valueID);
}





bool cIniFile::SetValue(const int keyID, const int valueID, const AString & value)
{
	if ((keyID < (int)keys.size()) && (valueID < (int)keys[keyID].names.size()))
	{
		keys[keyID].values[valueID] = value;
	}
	return false;
}





bool cIniFile::SetValue(const AString & keyname, const AString & valuename, const AString & value, bool const create)
{
	int keyID = FindKey(keyname);
	if (keyID == noID)
	{
		if (create)
		{
			keyID = int(AddKeyName(keyname));
		}
		else
		{
			return false;
		}
	}

	int valueID = FindValue(int(keyID), valuename);
	if (valueID == noID)
	{
		if (!create)
		{
			return false;
		}
		keys[keyID].names.resize(keys[keyID].names.size() + 1, valuename);
		keys[keyID].values.resize(keys[keyID].values.size() + 1, value);
	}
	else
	{
		if (!create)
		{
			keys[keyID].values[valueID] = value;
		}
		else
		{
			keys[keyID].names.resize(keys[keyID].names.size() + 1, valuename);
			keys[keyID].values.resize(keys[keyID].values.size() + 1, value);
		}
	}

	return true;
}





bool cIniFile::SetValueI(const AString & keyname, const AString & valuename, const int value, bool const create)
{
	AString Data;
	Printf(Data, "%d", value);
	return SetValue(keyname, valuename, Data, create);
}





bool cIniFile::SetValueF(const AString & keyname, const AString & valuename, double const value, bool const create)
{
	AString Data;
	Printf(Data, "%f", value);
	return SetValue(keyname, valuename, Data, create);
}





bool cIniFile::SetValueV(const AString & keyname, const AString & valuename, char * format, ...)
{
	va_list args;
	va_start(args, format);

	AString Data;
	AppendVPrintf(Data, format, args);
	va_end(args);
	return SetValue(keyname, valuename, Data);
}





AString cIniFile::GetValue(const int keyID, const int valueID, const AString & defValue) const
{
	if ((keyID < (int)keys.size()) && (valueID < (int)keys[keyID].names.size()))
	{
		return keys[keyID].values[valueID];
	}
	return defValue;
}





AString cIniFile::GetValue(const AString & keyname, const AString & valuename, const AString & defValue) const
{
	int keyID = FindKey(keyname);
	if (keyID == noID)
	{
		return defValue;
	}

	int valueID = FindValue(int(keyID), valuename);
	if (valueID == noID)
	{
		return defValue;
	}

	return keys[keyID].values[valueID];
}





int cIniFile::GetValueI(const AString & keyname, const AString & valuename, const int defValue) const
{
	AString Data;
	Printf(Data, "%d", defValue);
	return atoi(GetValue(keyname, valuename, Data).c_str());
}





double cIniFile::GetValueF(const AString & keyname, const AString & valuename, double const defValue) const
{
	AString Data;
	Printf(Data, "%f", defValue);
	return atof(GetValue(keyname, valuename, Data).c_str());
}





AString cIniFile::GetValueSet(const AString & keyname, const AString & valuename, const AString & defValue)
{
	int keyID = FindKey(keyname);
	if (keyID == noID)
	{
		SetValue(keyname, valuename, defValue);
		return defValue;
	}

	int valueID = FindValue(int(keyID), valuename);
	if (valueID == noID)
	{
		SetValue(keyname, valuename, defValue);
		return defValue;
	}

	return keys[keyID].values[valueID];
}





double cIniFile::GetValueSetF(const AString & keyname, const AString & valuename, const double defValue)
{
	AString Data;
	Printf(Data, "%f", defValue);
	return atof(GetValueSet(keyname, valuename, Data).c_str());
}





int cIniFile::GetValueSetI(const AString & keyname, const AString & valuename, const int defValue)
{
	AString Data;
	Printf(Data, "%d", defValue);
	return atoi(GetValueSet(keyname, valuename, Data).c_str());
}





bool cIniFile::DeleteValueByID(const int keyID, const int valueID)
{
	if ((keyID < (int)keys.size()) && (valueID < (int)keys[keyID].names.size()))
	{
		// This looks strange, but is neccessary.
		vector<AString>::iterator npos = keys[keyID].names.begin() + valueID;
		vector<AString>::iterator vpos = keys[keyID].values.begin() + valueID;
		keys[keyID].names.erase(npos, npos + 1);
		keys[keyID].values.erase(vpos, vpos + 1);
		return true;
	}
	return false;
}





bool cIniFile::DeleteValue(const AString & keyname, const AString & valuename)
{
	int keyID = FindKey(keyname);
	if (keyID == noID)
	{
		return false;
	}

	int valueID = FindValue(int(keyID), valuename);
	if (valueID == noID)
	{
		return false;
	}

	return DeleteValueByID(keyID, valueID);
}





bool cIniFile::DeleteKey(const AString & keyname)
{
	int keyID = FindKey(keyname);
	if (keyID == noID)
	{
		return false;
	}

	vector<AString>::iterator npos = names.begin() + keyID;
	vector<key>::iterator    kpos = keys.begin() + keyID;
	names.erase(npos, npos + 1);
	keys.erase(kpos, kpos + 1);

	return true;
}





void cIniFile::Clear(void)
{
	names.clear();
	keys.clear();
	comments.clear();
}





void cIniFile::AddHeaderComment(const AString & comment)
{
	comments.push_back(comment);
	// comments.resize(comments.size() + 1, comment);
}





AString cIniFile::GetHeaderComment(const int commentID) const
{
	if (commentID < (int)comments.size())
	{
		return comments[commentID];
	}
	return "";
}





bool cIniFile::DeleteHeaderComment(int commentID)
{
	if (commentID < (int)comments.size())
	{
		vector<AString>::iterator cpos = comments.begin() + commentID;
		comments.erase(cpos, cpos + 1);
		return true;
	}
	return false;
}





int cIniFile::GetNumKeyComments(const int keyID) const
{
	if (keyID < (int)keys.size())
	{
		return keys[keyID].comments.size();
	}
	return 0;
}





int cIniFile::GetNumKeyComments(const AString & keyname) const
{
	int keyID = FindKey(keyname);
	if (keyID == noID)
	{
		return 0;
	}
	return (int)keys[keyID].comments.size();
}





bool cIniFile::AddKeyComment(const int keyID, const AString & comment)
{
	if (keyID < (int)keys.size())
	{
		keys[keyID].comments.resize(keys[keyID].comments.size() + 1, comment);
		return true;
	}
	return false;
}





bool cIniFile::AddKeyComment(const AString & keyname, const AString & comment)
{
	int keyID = FindKey(keyname);
	if (keyID == noID)
	{
		return false;
	}
	return AddKeyComment(keyID, comment);
}





AString cIniFile::GetKeyComment(const int keyID, const int commentID) const
{
	if ((keyID < (int)keys.size()) && (commentID < (int)keys[keyID].comments.size()))
	{
		return keys[keyID].comments[commentID];
	}
	return "";
}





AString cIniFile::GetKeyComment(const AString & keyname, const int commentID) const
{
	int keyID = FindKey(keyname);
	if (keyID == noID)
	{
		return "";
	}
	return GetKeyComment(int(keyID), commentID);
}





bool cIniFile::DeleteKeyComment(const int keyID, const int commentID)
{
	if ((keyID < (int)keys.size()) && (commentID < (int)keys[keyID].comments.size()))
	{
		vector<AString>::iterator cpos = keys[keyID].comments.begin() + commentID;
		keys[keyID].comments.erase(cpos, cpos + 1);
		return true;
	}
	return false;
}





bool cIniFile::DeleteKeyComment(const AString & keyname, const int commentID)
{
	int keyID = FindKey(keyname);
	if (keyID == noID)
	{
		return false;
	}
	return DeleteKeyComment(int(keyID), commentID);
}





bool cIniFile::DeleteKeyComments(const int keyID)
{
	if (keyID < (int)keys.size())
	{
		keys[keyID].comments.clear();
		return true;
	}
	return false;
}





bool cIniFile::DeleteKeyComments(const AString & keyname)
{
	int keyID = FindKey(keyname);
	if (keyID == noID)
	{
		return false;
	}
	return DeleteKeyComments(int(keyID));
}





AString cIniFile::CheckCase(const AString & s) const
{
	if (!m_IsCaseInsensitive)
	{
		return s;
	}
	AString res(s);
	size_t len = res.length();
	for (size_t i = 0; i < len; i++)
	{
		res[i] = tolower(res[i]);
	}
	return res;
}