inifile.cpp

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

	int pos = FindIndex(indexname);
	if(pos == -1)
	{
		AddIndex(indexname);
		pos = FindIndex(indexname);
		int nextIndexPos = NextIndexPos(pos);
		pos = NextLinePos(pos);
		while(m_pData[pos]!='[' || m_pData[pos]!=' ' || m_pData[pos]!='\t' || m_pData[pos]!=';')
		{
			if(pos>=nextIndexPos)
				break;
			pos = NextLinePos(pos);
		}
		AddData(pos, dataname, szValue);
		return true;
	}

	int valuePos = FindDataName(indexname, dataname);
	if(valuePos == -1)
	{
		int nextIndexPos = NextIndexPos(pos);
		pos = NextLinePos(pos);
		while(m_pData[pos]!='[' && m_pData[pos]!=' ' && m_pData[pos]!='\t' && m_pData[pos]!=';' && m_pData[pos]!='\r')
		{
			if(pos>=nextIndexPos)
				break;
			pos = NextLinePos(pos);
		}
		AddData(pos, dataname, szValue);
		return true;
	}

	ModifyData(valuePos, dataname, szValue);
	return true;
}

//Read binary data & return bytes
int CIniFile::ReadBinary(const char *indexname, const char *dataname, unsigned char *pData, 
						 const unsigned nBytes)
{
	if(pData==NULL || nBytes==0)
	{
#ifdef _INILOG_
		WriteLog(INFO_ERROR, "pData==NULL or nBytes==0 in [CIniFile::ReadBinary]");
#endif // _INILOG_
		
		m_Return = RET_FAILED;
		return 0;
	}

	char * szValue = ReadString(indexname, dataname);
	if(szValue==NULL)
	{
		m_Return = RET_FAILED;
		return 0;
	}

	unsigned nLen = strlen(szValue);
	if(nLen==0 || nLen%2 != 0)
	{
		free(szValue);
#ifdef _INILOG_
		WriteLog(INFO_ERROR, "Read Binary Error in [CIniFile::ReadBinary]");
#endif // _INILOG_
		
		m_Return = RET_FAILED;
		return 0;
	}
	for(unsigned i=0; i<nLen; i+=2)
	{
		(pData)[i/2] = (unsigned char)
		(((szValue[i+1] - 'A') << 4) + (szValue[i] - 'A'));
	}

	free(szValue);
	m_Return = RET_SUCCEED;
	return nLen/2;
}

//Write Binary Data
bool CIniFile::WriteBinary(const char *indexname, const char *dataname, 
						   const unsigned char *pData, const unsigned nBytes)
{
	//convert to string and write out
	char *lpsz = new char[nBytes*2+1];
	for(unsigned char i=0; i<nBytes; i++)
	{
		lpsz[i*2] = (char)((pData[i] & 0x0F) + 'A');
		lpsz[i*2+1] = (char)(((pData[i] >> 4) & 0x0F) + 'A');
	}
	lpsz[i*2] = 0;
	bool bResult = true;
	bResult = WriteString(indexname, dataname, lpsz);
	delete [] lpsz;

	return bResult;
}

//Read POINT value
POINT CIniFile::ReadPoint(const char *indexname, const char *dataname)
{
	POINT pt = { 0, 0 };
	char *szValue = ReadString(indexname, dataname);
	char *szEnd = NULL;
	if(szValue==NULL)
	{
		m_Return = RET_FAILED;
		return pt;
	}

	pt.x = strtol(szValue, &szEnd, 10);
	if(*(szEnd+1) != 0)
	{
		pt.y = strtol(szEnd+1, &szEnd, 10);
	}
	free(szValue);
	m_Return = RET_SUCCEED;
	return pt;
}

//Write POINT value
bool CIniFile::WritePoint(const char *indexname, const char *dataname, const POINT &pt)
{
	char value[32];
	sprintf(value, "%d,%d", pt.x, pt.y);
	return WriteString(indexname, dataname, value);
}

//Read RECT value
RECT CIniFile::ReadRect(const char *indexname, const char *dataname)
{
	RECT rc = { 0, 0, 0, 0 };
	char *szValue = ReadString(indexname, dataname);
	char *szEnd = NULL;
	if(szValue==NULL)
	{
		m_Return = RET_FAILED;
		return rc;
	}

	rc.left = strtol(szValue, &szEnd, 10);
	if(*(szEnd+1) != 0)
	{
		rc.top = strtol(szEnd+1, &szEnd, 10);
	}
	if(*(szEnd+1) != 0)
	{
		rc.right = strtol(szEnd+1, &szEnd, 10);
	}
	if(*(szEnd+1) != 0)
	{
		rc.bottom = strtol(szEnd+1, &szEnd, 10);
	}

	free(szValue);
	m_Return = RET_SUCCEED;
	return rc;
}

//Write RECT value
bool CIniFile::WriteRect(const char *indexname, const char *dataname, const RECT &rc)
{
	char value[64];
	sprintf(value, "%d,%d,%d,%d", rc.left, rc.top, rc.right, rc.bottom);
	return WriteString(indexname, dataname, value);
}

//Read Vec2D value
Vec2D CIniFile::ReadVec2D(const char *indexname, const char *dataname, 
						  const Vec2D &vec /* = Vec2D(0.0f, 0.0f) */)
{
	char *szValue = ReadString(indexname, dataname);
	char *szEnd = NULL;
	if(szValue==NULL)
	{
		m_Return = RET_FAILED;
		return vec;
	}

	Vec2D Retvec(0.0f, 0.0f);
	Retvec.x = (float)strtod(szValue, &szEnd);
	if(*(szEnd+1) != 0)
	{
		Retvec.y = (float)strtod(szEnd+1, &szEnd);
	}

	free(szValue);
	m_Return = RET_SUCCEED;
	return Retvec;
}

//Write Vec2D value
bool CIniFile::WriteVec2D(const char *indexname, const char *dataname, const Vec2D &vec)
{
	char value[64];
	sprintf(value, "%f,%f", vec.x, vec.y);
	return WriteString(indexname, dataname, value);
}

//Read Vec3D value
Vec3D CIniFile::ReadVec3D(const char *indexname, const char *dataname, 
						  const Vec3D &vec /* = Vec3D(0.0f, 0.0f, 0.0f) */)
{
	char *szValue = ReadString(indexname, dataname);
	char *szEnd = NULL;
	if(szValue==NULL)
	{
		m_Return = RET_FAILED;
		return vec;
	}

	Vec3D Retvec(0.0f, 0.0f, 0.0f);
	Retvec.x = (float)strtod(szValue, &szEnd);
	if(*(szEnd+1) != 0)
	{
		Retvec.y = (float)strtod(szEnd+1, &szEnd);
	}
	if(*(szEnd+1) != 0)
	{
		Retvec.z = (float)strtod(szEnd+1, &szEnd);
	}

	free(szValue);
	m_Return = RET_SUCCEED;
	return Retvec;
}

//Write Vec3D value
bool CIniFile::WriteVec3D(const char *indexname, const char *dataname, const Vec3D &vec)
{
	char value[128];
	sprintf(value, "%f,%f,%f", vec.x, vec.y, vec.z);
	return WriteString(indexname, dataname, value);
}

//Add a new index
bool CIniFile::AddIndex(const char *indexname)
{
	if(indexname==NULL)
		return false;
	
	char szIndex[256];
	memset(szIndex, 0, 256);
	int pos = FindIndex(indexname);

	if(pos == -1)//Add new one
	{
		sprintf(szIndex,"\r\n[%s]\r\n",indexname);
		m_pData=(char *)realloc(m_pData, m_nDataLen+strlen(szIndex));
		memcpy(&m_pData[m_nDataLen], szIndex, strlen(szIndex));
	    m_nDataLen += strlen(szIndex);

		CreateIndex();
		return true;
	}
	
	return false;	//Don't need to add
}

//Add a data record(name=value)
bool CIniFile::AddData(const int &pos, const char *dataname, const char *szValue)
{
	if(dataname==NULL || szValue==NULL)
		return false;

	char *szFomat;
	unsigned valueLen = strlen(szValue);
	szFomat = new char[valueLen + 256];
	memset(szFomat, 0, valueLen+256);
	sprintf(szFomat, "%s=%s\r\n", dataname, szValue);
	valueLen = strlen(szFomat);

	char *szTemp=new char[m_nDataLen-pos];
	memcpy(szTemp, &m_pData[pos], m_nDataLen-pos);

	m_pData=(char *)realloc(m_pData, m_nDataLen+valueLen);
	if(m_pData==NULL)
	{
		return false;
	}
	
	memcpy(&m_pData[pos+valueLen], szTemp, m_nDataLen-pos);
	memcpy(&m_pData[pos], szFomat, valueLen);
	m_nDataLen += valueLen;

	delete [] szFomat;
	szFomat = NULL;
	delete [] szTemp;
	szTemp = NULL;
	
	return true;
}

//Modify a data record, change its value
bool CIniFile::ModifyData(const int &pos, const char *dataname, const char *szValue)
{
	if(dataname==NULL || szValue==NULL)
		return false;
	
	char *szOldValue = GetString(pos);
	unsigned valueEndPos = pos + strlen(szOldValue);
	unsigned newLen=strlen(szValue);
	unsigned oldLen=strlen(szOldValue);

	free(szOldValue);
	szOldValue = NULL;

	char *szTemp=new char[m_nDataLen-valueEndPos];
	memcpy(szTemp, &m_pData[valueEndPos], m_nDataLen-valueEndPos);

	m_pData=(char *)realloc(m_pData, m_nDataLen+newLen-oldLen);

	memcpy(&m_pData[pos+newLen], szTemp, m_nDataLen-valueEndPos);
	memcpy(&m_pData[pos], szValue, newLen);
	m_nDataLen += newLen-oldLen;

	delete [] szTemp;
	szTemp = NULL;

	return true;
}

//-------------------------------------------------------
// below add on 2006_11_08
//-------------------------------------------------------
int CIniFile::GetContinueData(const char *indexname) const
{
	int num = 0;
	int pos = FindIndex(indexname);
	pos = NextLinePos(pos);
	while(1)
	{									
		if(m_pData[pos] == '\r' || m_pData[pos] == EOF  || m_pData[pos] == ' ' || m_pData[pos] == '[' ||
		   m_pData[pos] ==  '/' || m_pData[pos] == '\t' || m_pData[pos] == '\n')
		{
			return num;
		}
		else
		{
			num++;
			pos = NextLinePos(pos);
			if(pos >= m_nDataLen)	
				return num;
		}
	}
}

int	CIniFile::ReadInt(const char *indexname, const int linenum, const int value /* = 0 */)
{
	char szBuffer[256];
	if(ReadString(indexname, linenum, szBuffer))
	{
		m_Return = RET_SUCCEED;
		return atoi(szBuffer);
	}
	else
	{
		m_Return = RET_FAILED;
		return value;
	}
}

int CIniFile::ReadString(const char *indexname, const int linenum, char *buf)
{
	int pos = FindIndex(indexname);
	if(pos==-1)
	{
		m_Return = RET_FAILED;
		buf[0] = 0;
		return 0;
	}

	int nextIndexPos = NextIndexPos(pos);

	pos = NextLinePos(pos);
	for(int i=0; i<linenum; i++)
	{
		if(pos<nextIndexPos)
		{
			pos = NextLinePos(pos);
		}
		else
		{
			m_Return = RET_FAILED;
			buf[0] = 0;
			return 0;
		}
	}

	while(pos<m_nDataLen)
	{
		if(m_pData[pos] == '=')
		{
			pos++;
			char *pString = CutStringBack(CutStringFront(GetString(pos)));
			strcpy(buf, pString);
			free(pString);
			m_Return = RET_SUCCEED;
			return (int)strlen(buf);
		}
		if(m_pData[pos] == '\r')
		{
			m_Return = RET_FAILED;
			buf[0] = 0;
			return 0;
		}
		pos++;
	}

	m_Return = RET_FAILED;
	buf[0] = 0;
	return 0;
}

//需要释放
char *CIniFile::ReadDataName(const char *indexname, const int linenum) const
{
	int pos = FindIndex(indexname);
	if(pos == -1)
	{
		return NULL;
	}

	int nextIndexPos = NextIndexPos(pos);

	pos = NextLinePos(pos);
	for(int i=0; i<linenum; i++)
	{
		if(pos<nextIndexPos)
		{
			pos = NextLinePos(pos);
		}
		else
		{
			return NULL;
		}
	}

	return	CutStringBack(GetString(pos));
}

//-------------------------------------------------------
// add on 2007_3_10(Get next index's position)
//-------------------------------------------------------
int CIniFile::NextIndexPos(const int &pos) const
{
	int nextIndexPos = 0;
	for(int i=0; i<m_IndexNum; i++)
	{
		if(m_Index[i]>pos)
		{
			break;
		}
	}
	if(i >= m_IndexNum) //No next index
	{
		nextIndexPos = m_nDataLen;
	}
	else
	{
		nextIndexPos = m_Index[i];
	}

	return nextIndexPos;
}



#pragma warning(default:4267)
//file end LIYUAXNI 2006.7.26