inifile.cpp

一个自己写的游戏引擎,用DirectX 写成

//--------------------------------------------------
//  Desc: The Implementation of CIniFile class
//  Author: artsylee/2006.7.24
//  Update: 2006.10.29
//--------------------------------------------------

#include "../stdafx.h"
#include <windows.h>
#include <stdio.h>
#include "IniFile.h"

#pragma warning(disable:4267)
//--------------------------------------------------
// 是否需要Log输出
//--------------------------------------------------
#define _INILOG_

#ifdef _INILOG_
#include "Log.h"
#endif // _INILOG_

CIniFile::CIniFile(void)
{
	m_Index = NULL;
	m_pData = NULL;
	m_IndexNum = 0;
	m_nDataLen = 0;
	m_Return = RET_FAILED;
}

CIniFile::CIniFile(const char *pFileName)
{
	m_Index = NULL;
	m_pData = NULL;
	m_IndexNum = 0;
	m_nDataLen = 0;
	m_Return = RET_FAILED;
	Open(pFileName);
}

CIniFile::~CIniFile(void)
{
	if(m_IndexNum!=0 && m_Index!=NULL)
	{
		delete [] m_Index;
		m_Index = NULL;
	}
	if(m_nDataLen!=0 && m_pData!=NULL)
	{
		delete [] m_pData;
		m_pData = NULL;
	}
}

//Open an INI file
bool CIniFile::Open(const char *pFileName)
{
	if(pFileName==NULL)
	{
#ifdef _INILOG_
		WriteLog(INFO_ERROR, "pFileName=NULL! [CIniFile::Open]");
#endif // _INILOG_
		return false;
	}
	strcpy(m_FileName, pFileName);

	if(m_pData!=NULL)
	{
		delete [] m_pData;
		m_pData = NULL;
	}
	FILE *fp;
	fp=fopen(pFileName, "rb");
	if(fp==NULL)
	{
#ifdef _INILOG_
		WriteLog(INFO_ERROR, "Can't open Ini file [%s] !",pFileName);
#endif // _INILOG_
		return false;
	}
	fseek(fp, 0, SEEK_END);
	m_nDataLen = ftell(fp);
    fseek(fp, 0, SEEK_SET);
	
	m_pData=new char[m_nDataLen];
	fread(m_pData, m_nDataLen, 1, fp);
	fclose(fp);

	//Create index
	CreateIndex();

	return true;
}

//Create index
void CIniFile::CreateIndex(void)
{
	m_IndexNum = 0;
	int i;
	for(i=0; i<m_nDataLen; i++)
	{
		if(m_pData[i]=='[' && ((i>0 && m_pData[i-1]=='\n') || i==0))
			m_IndexNum++;
	}
	if(m_IndexNum==0)
	{
		return;
	}
	if(m_Index!=NULL)
	{
		delete [] m_Index;
		m_Index = NULL;
	}
	m_Index = new int[m_IndexNum];
	int nIndex = 0;
	for(i=0; i<m_nDataLen; i++)
	{
		if(m_pData[i]=='[' && ((i>0 && m_pData[i-1]=='\n') || i==0))
		{
			m_Index[nIndex] = i + 1; 
			nIndex++;
		}
	}
}

int CIniFile::GetIndexNum(void) const
{
	return m_IndexNum;
}

char* CIniFile::GetIndex(const int &indexnum, char *buf) const
{
	if(indexnum<0 || indexnum>=m_IndexNum)
	{
#ifdef _INILOG_
		WriteLog(INFO_NORMAL, "IndexNum is out of range, [CIniFile::GetIndex] !");
#endif // _INILOG_
		buf[0] = 0;
		return NULL;
	}

	char *szIndex = GetString(m_Index[indexnum]);
	strcpy(buf, szIndex);
	free(szIndex);
	szIndex = NULL;
	return buf;
}

//Save file
bool CIniFile::Save(const char *pFileName/* =NULL */)
{
	if(pFileName==NULL)
		pFileName = m_FileName;

	FILE *fp;
	fp=fopen(pFileName, "wb");
	if(fp==NULL)
	{
#ifdef _INILOG_
		WriteLog(INFO_ERROR, "Can't save file [%s] !",pFileName);
#endif // _INILOG_
		
		return false;
	}
	fwrite(m_pData, m_nDataLen, 1, fp);
	fclose(fp);

	return true;
}

//Get string by position
//String end with ';',return,'=' or ']' "//"
//(Attention: Must release memory when call this function)
char *CIniFile::GetString(int *position) const
{
	char szTemp;
	char *szGet;
	int pos = (*position);
	int m = 0;

	int NewLine = NextLinePos((*position));
	szGet = (char *)malloc(NewLine-(*position)+1);
	memset(szGet, 0, NewLine-(*position)+1);

	for(int i=0; i<NewLine-(*position); i++)
	{
		szTemp = m_pData[pos];
		if(szTemp==';' || szTemp=='\r' || szTemp==']' || szTemp=='=' ||
		  (szTemp=='/' && m_pData[pos+1]=='/'))
		{
			(*position) = pos + 1;
			return szGet;
		}
		szGet[m] = szTemp;
		m++;
		pos++;
	}
	(*position) = pos + 1;
	return szGet;
}

//Get string by position,See above
char *CIniFile::GetString(const int &position) const
{
	int pos = position;
	return GetString(&pos);
}

char *CIniFile::CutStringFront(char *pString) const
{
	if(pString == NULL)
		return NULL;

	unsigned szLen = strlen(pString);
	if(!szLen || (pString[0]!=' ' && pString[0]!= '\t'))
		return pString;

	char *pTemp = new char[szLen + 1];
	strcpy(pTemp, pString);
	for(unsigned i=0; i<szLen; i++)
	{
		if(pString[i]!=' ' && pString[i]!= '\t')
			break;
	}
	strcpy(pString, pTemp + i);
	delete [] pTemp;
	return pString;
}

char *CIniFile::CutStringBack(char *pString) const
{
	if(pString == NULL)
		return NULL;

	unsigned szLen = strlen(pString);
	if(!szLen || (pString[szLen-1]!=' ' && pString[szLen-1]!= '\t'))
		return pString;

	for(unsigned i=szLen-1; i>=0; i--)
	{
		if(pString[i]!=' ' && pString[i]!= '\t')
			break;
	}
	pString[i + 1] = '\0';
	return pString;
}

//Get next line's position
int CIniFile::NextLinePos(const int &oldposition) const
{
	for(int i=oldposition; i<m_nDataLen; i++)
	{
		if(m_pData[i]=='\n')
			return i+1;
	}
	return i;
}

//Find the index & return its position
int CIniFile::FindIndex(const char *indexname) const
{
	if(indexname==NULL)
	{
#ifdef _INILOG_
		WriteLog(INFO_NORMAL, "Index is NULL, [CIniFile::FindIndex] !");
#endif // _INILOG_
		
		return -1;
	}
	
	for(int i=0; i<m_IndexNum; i++)
	{
		char *szIndex = GetString(m_Index[i]);
		if(strcmp(indexname, szIndex)==NULL)
		{
			free(szIndex);
			szIndex = NULL;
			
			return m_Index[i];
		}
		free(szIndex);
		szIndex = NULL;
	}

	return -1;  //Can't find the index
}

//Find the data name & return the end of data name's position
int CIniFile::FindDataName(const char *indexname, const char *dataname) const
{
	if(indexname==NULL || dataname==NULL)
		return -1;

	int pos = FindIndex(indexname);
	if(pos==-1)
		return -1; //Can't find index

	int nextIndexPos = NextIndexPos(pos);

	while(true)
	{
		pos = NextLinePos(pos);
		char *name = GetString(&pos);
		CutStringBack(name);
		if(strcmp(dataname, name)==0)
		{
			free(name);
			name = NULL;
			return pos;
		}

		free(name);
		name = NULL;
		if(pos >= nextIndexPos) return -1;
	}
	return -1;         //Can't find data name
}

//Read a bool value
bool CIniFile::ReadBOOL(const char *indexname, const char *dataname, const bool bValue /* = false */)
{
	char *szValue = ReadString(indexname, dataname);
	if(szValue==NULL)
	{
		m_Return = RET_FAILED;
		return bValue;
	}
	m_Return = RET_SUCCEED;
	_strlwr(szValue);
	if((strcmp(szValue, "false")==0) || (strcmp(szValue, "0")==0))
	{
		free(szValue);
		return false;
	}
	else
	{
		free(szValue);
		return true;
	}
}

//Write a bool value
bool CIniFile::WriteBOOL(const char *indexname, const char *dataname, const bool bValue)
{
	char szTemp[20];
	if(bValue)
	{
		strcpy(szTemp, "true");
	}
	else
	{
		strcpy(szTemp, "false");
	}
	return WriteString(indexname, dataname, szTemp);
}

//Read an Integer
int CIniFile::ReadInt(const char *indexname, const char *dataname, const int value /* = 0 */)
{
	char *szValue = ReadString(indexname, dataname);
	if(szValue==NULL)
	{
		m_Return = RET_FAILED;
		return value;
	}
	int GetValue = atoi(szValue);
	free(szValue);
	szValue = NULL;
	
	m_Return = RET_SUCCEED;
	return GetValue;
}

//Write an Integer
bool CIniFile::WriteInt(const char *indexname, const char *dataname, const int value)
{
	char szValue[32];
	sprintf(szValue, "%d", value);

	return WriteString(indexname, dataname, szValue);
}

unsigned CIniFile::ReadDWORD(const char *indexname, const char *dataname, const unsigned value /* = 0 */)
{
	char *szValue = ReadString(indexname, dataname);
	if(szValue==NULL)
	{
		m_Return = RET_FAILED;
		return value;
	}
	m_Return = RET_SUCCEED;
	unsigned GetValue = strtoul(szValue, 0, 0);
	free(szValue);
	szValue = NULL;

	return GetValue;
}

bool CIniFile::WriteDWORD(const char *indexname, const char *dataname, const unsigned value)
{
	char szValue[32];
	sprintf(szValue, "%x", value);

	return WriteString(indexname, dataname, szValue);
}

//Read a float value
float CIniFile::ReadFloat(const char *indexname, const char *dataname, const float fvalue /* = 0.0f */)
{
	char *szValue = ReadString(indexname, dataname);
	if(szValue==NULL)
	{
		m_Return = RET_FAILED;
		return fvalue;
	}
	m_Return = RET_SUCCEED;
	char *p = NULL;
	float fv = (float)strtod(szValue, &p);
	free(szValue);
	return fv;
}

//Write a float value
bool CIniFile::WriteFloat(const char *indexname, const char *dataname, const float fvalue)
{
	char value[20];
	sprintf(value, "%f", fvalue);
	return WriteString(indexname, dataname, value);
}

//Read a String
//Must free memory when call
char *CIniFile::ReadString(const char *indexname, const char *dataname)
{
	int pos = FindDataName(indexname, dataname);
	if(pos==-1)
	{
#ifdef _INILOG_
	//	WriteLog(INFO_WARNING, "Can't find Index[%s] or Dataname[%s]",
	//		indexname, dataname);
#endif // _INILOG_

		m_Return = RET_FAILED;
		return NULL;
	}
	m_Return = RET_SUCCEED;
	return CutStringBack(CutStringFront(GetString(pos)));
}

//Read a String
char *CIniFile::ReadString(const char *indexname, const char *dataname, char *buf, const char *szValue /* = "" */)
{
	int pos = FindDataName(indexname, dataname);
	if(pos==-1)
	{
		m_Return = RET_FAILED;
		strcpy(buf, szValue);
		return buf;
	}
	m_Return = RET_SUCCEED;
	char *pString = CutStringBack(CutStringFront(GetString(pos)));
	strcpy(buf, pString);
	free(pString);

	return buf;
}

//Write a String
bool CIniFile::WriteString(const char *indexname, const char *dataname, const char *szValue)
{
	if(indexname==NULL || dataname==NULL || szValue==NULL)
		return false;