iec103/Profile_Hash.cpp

/*****************************************************************************
 *
 *	Copyright (C) 1999-2001 SCADA Technology Control Co., Ltd. All rights reserved.
 *
 *	配置文件处理与哈希索引处理的有关的头文件
 *
 *	m.j.y		2001/12/07
 *
 * 
 * 
 *	$Name:  $
 *
 *	$Revision: 1.2 $
 *
 *	$Date: 2006/08/04 03:37:33 $
 *	
 *	$State: Exp $
 *
 *	$Log: Profile_Hash.cpp,v $
 *	Revision 1.2  2006/08/04 03:37:33  zhuzhenhua
 *	no message
 *	
 *	Revision 1.1.2.1  2006/07/28 07:54:02  zhuzhenhua
 *	no message
 *	
 *	Revision 1.5  2003/07/14 02:22:38  scada
 *	使用def文件导出函数,而不是使用SCADA_API.
 *	
 *	Revision 1.4  2003/01/02 03:14:50  scada
 *	trim  substitution line
 *	
 *	Revision 1.3  2002/12/04 07:47:09  scada
 *	for NT
 *	
 *	Revision 1.2  2002/09/24 05:58:34  harold
 *	take acount __OS_SOLARIS__ where __OS__ occur, set errno to 0 before use it
 *	
 *	Revision 1.1.1.1  2002/08/21 07:16:39  harold
 *	temporarily import
 *	
 *	Revision 1.21  2002/06/03 10:06:27  mhorse
 *	更改了AddNode函数
 *	
 *	Revision 1.20  2002/03/20 03:40:21  harold
 *	no message
 *	
 *	Revision 1.1.1.1  2002/03/15 13:43:21  harold
 *	no message
 *	
 *	Revision 1.1.1.1  2002/03/15 08:17:11  harold
 *	no message
 *	
 *	Revision 1.19  2002/03/06 01:27:52  harold
 *	*** empty log message ***
 *	
 *	Revision 1.18  2002/02/25 07:30:21  harold
 *	no message
 *	
 *	Revision 1.17  2002/01/25 09:11:19  harold
 *	no message
 *	
 *	Revision 1.16  2002/01/23 02:38:06  harold
 *	test_function
 *	
 *	Revision 1.15  2002/01/22 08:51:42  harold
 *	modify2002-01-22-16:46
 *	
 *	Revision 1.14  2002/01/21 06:15:49  harold
 *	修改了函数返回值及参数
 *	
 *	Revision 1.13  2002/01/21 05:55:25  mhorse
 *	修改了函数返回值及参数
 *	
 *	Revision 1.11  2002/01/18 12:57:15  harold
 *	revise errno
 *	
 *	Revision 1.10  1997/03/29 12:48:33  harold
 *	revise bug in read/write/listsec function
 *	
 *	Revision 1.9  2002/01/18 01:09:33  harold
 *	revise bugs in write/close/listsec function
 *	
 *	Revision 1.8  2002/01/09 11:37:11  harold
 *	no message
 *	
 *	
 *	Revision 1.2  2001/12/19 02:19:22  mhorse
 *	第2次修改
 *	
 *	Revision 1.1.1.1  2001/12/18 06:42:11  mhorse
 *	马健莹第一次把配置文件读写库模块加入CVS(2001/12/18)
 *	
 *
 ******************************************************************************/

#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include  <sys/stat.h>
#ifdef OS_WINDOWS
#include <winsock2.h>
#include <windows.h>
#include <io.h>
#else
//#include <curses.h>
#include <sys/types.h>
//#include <global_errno.h>
//	#include <sys/uswitch.h>
#include <errno.h>
#include <string.h>
#include <ctype.h>
#endif
#include "Profile_Hash.h"
#include "confrw_errno.h"
//#include "util.h"
#include "common.h"
#include "basefunc.h"

//定义句柄记录数组
static SProfileHanleInfo g_pHandleIndex[MAX_PROFILEHANDLE_NUM];

//句柄记录数组是否经过初始化 PGCTRUE-已经被初始化
static PGCBOOL g_bHandleInit = PGCFALSE;

//定义行注释符
#define MARK_pgcchar_NUM		2
static pgcchar gs_szMarkpgcchar[MARK_pgcchar_NUM] = {';', '#'};

//行结尾字符为\n,不包括\r
//#define LINE_EXCLUDE_0A


// 函数名	    : UpperCase
// 函数说明	    : 将小写转为大写
// 返回值说明	: pgcchar -- 转换后的字符
// 参数说明     : cCh -- 源字符
pgcchar* UpperCase(pgcchar *szSource)
{
    pgcchar* pcTemp = szSource, *pcFirst = szSource;
	
    if (pcTemp == NULL)
		return NULL;
	
	while (*pcTemp != '\0')
	{
		if ((*pcTemp >= 'a') && (*pcTemp <= 'z'))
			*pcTemp = (pgcchar)(*pcTemp - ('a' - 'A')) ;
		pcTemp++;
	}
  	
	return pcFirst;
}


/*
*	哈希函数
*/
//	给出关键字, 求同义词序号
static u32	fnhash_index_of(const void * pKey, u32 hash_size);

//	求关键字
static void * fnhash_key_of(const SItemInCache * pindex);

//	比较关键字
static int fnhash_compare(const void * pKey1, const void * pKey2);



/*
*	根据已知的历史数据库索引数组, 为其建立一个哈希表.
*
*	参数
*		pindex	--	索引数组的指针
*		count	--	pindex索引数组中索引的个数, pindex[0] -- pindex[count - 1]为
*					索引
*		pphash_of_index	--	将pindex所指向的数组哈希化, 这样, 在随后的索引搜索
*							时, 使用该哈希索引.
*	
*	返回值
*		SUCCESS	--	成功
*		其它	--	失败代码
*		
*/
#define	INDEX_HASH_TABLE_SIZE_FACTOR			20
pgc32 profile_build_hash_index ( SItemInCache * pindex, 
								pgc32 count,
								TChainHash<SItemInCache> ** pphash_of_index )
{
	pgc32 i = 0;
	TChainHash<SItemInCache> * phash_table = NULL;
	
	phash_table = new TChainHash<SItemInCache>(count * INDEX_HASH_TABLE_SIZE_FACTOR,
												fnhash_index_of,
												fnhash_key_of,
												fnhash_compare,
												NULL/*fnhash_create_item*/,
												NULL/*fnhash_free_item*/,
												NULL/*fnhash_copy_item*/,
												NULL/*fnhash_alloc*/,
												NULL/*fnhash_dealloc*/);
	if (phash_table == NULL)
		return ERROR_MEMORY_ALLOC;
	
	for(i = 0; i < count; i++)
		phash_table->insertItem(pindex + i);
	
	*pphash_of_index = phash_table;
	
	return SUCCESS;
}



/*
*	在索引区中搜索
*
*	参数
*		pindex_base	--	被哈希化的索引数组的指针
*		phash_of_index	--	索引数组的哈希表
*		szSecName	--	被查询的段名
*		szItemName	-	被查询的项目名
*
*	返回值
*		索引在索引数组中的序号	--	成功的查找到指定的配置项目的索引
*		-1	--	失败
*/
pgc32 profile_search_sequence ( SItemInCache **pindex_base,
							   TChainHash<SItemInCache> *phash_of_index,
							   const pgcchar *szSecName,
							   const pgcchar *szItemName)
{
	SItemInCache  *p = NULL, index;
	
    memset(&index, 0, sizeof(SItemInCache));
	if (szSecName != NULL)
	{
		//以下执行大小写转换
#ifdef OS_WINDOWS
		lstrcpyn((LPWSTR)index.szSecName, (LPCWSTR)szSecName, MAX_CHAR_LINE);
		//	strupr(index.szSecName);
#else
		strncpy(index.szSecName, szSecName, MAX_CHAR_LINE - 1);
		//  UpperCase(index.szSecName);
#endif
	}
	if (szItemName != NULL)
	{
#ifdef OS_WINDOWS
    	lstrcpyn((LPWSTR)index.szItemName, (LPCWSTR)szItemName, MAX_CHAR_LINE);
	//	strupr(index.szItemName);
#else
	strncpy(index.szItemName, szItemName, MAX_CHAR_LINE - 1);
     // UpperCase(index.szItemName);
#endif
	}
	p = phash_of_index->searchItem((void *)&index);
	if(NULL == p)
		return -1;
	*pindex_base = p;
	return 0;
}




/*
*	哈希函数
*/
//	给出关键字, 求同义词序号
static u32	fnhash_index_of(const void * pKey, u32 hash_size)
{
	long index = 0;
	u_char *pbString = NULL;
	int iX = 0, iY = 0, i = 0;
	
	SItemInCache * pindex = (SItemInCache *)pKey, sindex;

	memcpy(&sindex, pindex, sizeof(SItemInCache));
	//以下执行大小写转换
#ifndef OS_WINDOWS
	strupr(sindex.szSecName);
	strupr(sindex.szItemName);
#else
	UpperCase(sindex.szSecName);
	UpperCase(sindex.szItemName);
#endif
	
	//哈希转换
	pbString = (u_char*)sindex.szSecName;
	for (i = 0; i < MAX_CHAR_LINE; i++)
	{
		iX = iX + pbString[i];
	}
	iX = iX % MAX_SEC_NUM;
	
	pbString = (u_char*)sindex.szItemName;
	for ( i = 0; i < MAX_CHAR_LINE; i++)
	{
		iY = iY + pbString[i];
	}
	iY = iY % MAX_ITEM_NUM;
	
	index = iX * MAX_ITEM_NUM + iY;
	
	return (u32)(index % hash_size);
}



//	求关键字
static void * fnhash_key_of(const SItemInCache * pindex)
{
	return (void *)(pindex);
}



//	比较关键字
static int fnhash_compare(const void * pKey1, const void * pKey2)
{
	SItemInCache * pindex1 = (SItemInCache *)pKey1;
	SItemInCache * pindex2 = (SItemInCache *)pKey2;
	
	if (pKey1 == NULL)
		return 1;
//#ifdef OS_WINDOWS
	if (pKey2 == NULL)
	{
		if (_stricmp(pindex1->szSecName, pindex2->szSecName) == 0)
			return 0;
		else
			return 1;
	}
	else
	{
		if ((_stricmp(pindex1->szSecName, pindex2->szSecName) == 0)
			&& (_stricmp(pindex1->szItemName, pindex2->szItemName) == 0))
			return 0;
		else
			return 1;
	}
/*#else
	if (pKey2 == NULL)
	{
		
		if (strcasecmp(pindex1->szSecName, pindex2->szSecName) == 0)
			return 0;
		else
			return 1;
	}
	else
	{
		if ((strcasecmp(pindex1->szSecName, pindex2->szSecName) == 0)
			&& (strcasecmp(pindex1->szItemName, pindex2->szItemName) == 0))
			return 0;
		else
			return 1;
	}
#endif*/
}




//判断某行是否被注释
PGCBOOL LineIsMark(pgcchar *szLine)
{
	for (pgc32 i = 0; i < MARK_pgcchar_NUM; i++)
		if (*szLine == gs_szMarkpgcchar[i])
			return PGCTRUE;
		return PGCFALSE;
}


//寻找段尾
pgcchar* FindSecTail(pgcchar *szString)
{
	pgcchar *szStart = NULL, *szTemp = NULL;

	if ((szStart = strchr(szString, '\n')) == NULL)
	{
		return NULL;
	}
	
	while (szStart != NULL)
	{
	   szStart = strchr(szStart, '[');
	   if ((szStart != NULL) && (*(szStart - 1) == '\n'))
          break;
	   if (szStart != NULL) szStart++;
	}

	if (szStart != NULL)
	{
		szTemp = szStart;
		while ((*szTemp != '\n') && (*szTemp != '\0'))
		{
			if (*szTemp == ']')
				return szStart;
			szTemp ++;
		}
	}
	
	return NULL;
}


//提取段名
PGCBOOL DigSecName(const pgcchar *szString, pgcchar *szRevBuffer, pgc32 iBufferLength)
{
	pgcchar *szStart = NULL, *szTemp = NULL;
	PGCBOOL bSecNameExist = PGCFALSE;
	pgc32 iLength = iBufferLength - 1;
	
	if ((szStart = (pgcchar *)strchr((const char*)szString, '[')) != NULL)
	{
		szTemp = szStart;
		while ((*szTemp != '\n') && (*szTemp != '\0'))
		{
			if (*szTemp == ']')
			{
				bSecNameExist = PGCTRUE;
				break;
			}
			szTemp ++;
		}
		
		if (bSecNameExist)
		{
			iLength = (pgc32)(szTemp - szStart) - 1;
			if (iLength >= iBufferLength)
				iLength = iBufferLength - 1;
            for (pgc32 i = 0; i < iLength; i++)
				szRevBuffer[i] = *(szStart + 1 + i);
			szRevBuffer[iLength] = '\0';
			/*			
			#ifndef __unix__
			strupr(szRevBuffer);
			#else
			UpperCase(szRevBuffer);
			#endif
			*/		
			return PGCTRUE;
		}
	}
	return PGCFALSE;
}


//提取项目名及项目值
PGCBOOL DigItemContent( pgcchar *szString, pgcchar *szItemName, pgcchar *szItemVal, pgc32 iBufferLength)
{
	pgcchar *pcBeval = NULL, *pcTemp = NULL, szTemp[MAX_CHAR_LINE];
	pgc32 iCount = 0, i = 0;
	
	
	if ((pcBeval = strchr(szString, '=')) == NULL)
		return PGCFALSE;
    
	//获取项目名
	pcTemp = szString;
    while ((pcTemp < pcBeval) && (iCount < (MAX_CHAR_LINE - 1)))
	{
		szTemp[iCount] = *pcTemp;
		pcTemp++;
		iCount++;
	}
	szTemp[iCount] = '\0';
	
	//删除前面多余空格
	for ( i = 0; i < MAX_CHAR_LINE; i++)
	{
        if (szTemp[i] != ' ')
		{
			for (pgc32 j = i; j < MAX_CHAR_LINE; j++)
			{
				szTemp[j - i] = szTemp[j];
			}// end for
			break;
		}// end if
	}// end for
	
	//删除后面多余空格
	for (i = iCount - 1; i >= 0; i--)
	{
        if (szTemp[i] != ' ')
			break;
		szTemp[i] = '\0';
	}// end for
/*#ifndef __unix__
	strupr(szTemp);
#else
	UpperCase(szTemp);
#endif*/
	strcpy(szItemName, szTemp);
	
	//获取项目值
	memset(szTemp, 0, MAX_CHAR_LINE);
#ifdef OS_WINDOWS
	lstrcpyn((LPWSTR)szTemp, (LPCWSTR)pcBeval + 1, MAX_CHAR_LINE);
#else
	strncpy(szTemp ,pcBeval + 1, MAX_CHAR_LINE - 1);
#endif
	//删除前面多余空格
	for (i = 0; i < MAX_CHAR_LINE; i++)
	{
        if (szTemp[i] != ' ')
		{
			for (pgc32 j = i; j < MAX_CHAR_LINE; j++)
			{
				szTemp[j - i] = szTemp[j];
			}// end for
			break;
		}// end if
	}// end for
	
	//删除后面多余空格
	for ( i = (pgc32)strlen(szTemp) - 1 ; i >= 0; i--)
	{
        if (szTemp[i] != ' ')
			break;
		szTemp[i] = '\0';
	}// end for
	strcpy(szItemVal, szTemp);
	
	return PGCTRUE;
}


// 函数名	    : InsertNode
// 函数说明	    : 在指定的段添加新项目
// 返回值说明	: PGCBOOL --
// 参数说明     : psHead --
// 参数说明     : iPos --
// 参数说明     : psCacheEntry --
// 参数说明     : iSecPos --
PGCBOOL InsertNode(SItemSequence * &psHead, pgc32 iPos, SItemInCache *psCacheEntry, pgc32 iSecPos)
{
	SItemSequence *psTemp = NULL, *psNewNode = NULL, *psPrior = NULL;
	
	if ((psHead == NULL) || (psCacheEntry == NULL))
		return PGCFALSE;
	psNewNode = new SItemSequence[1];
	psNewNode->iPos = iPos;
    psNewNode->NextNode = NULL;
	
	psTemp = psHead;
	while (psTemp != NULL)
	{
		if (psTemp->iPos == iSecPos)
			break;
		psTemp = psTemp->NextNode;
	}
	while (psTemp != NULL)
	{
		psPrior = psTemp;
		psTemp = psTemp->NextNode;
		if ((psTemp == NULL) || psCacheEntry[psTemp->iPos].bIsSecName)
		{
			psPrior->NextNode = psNewNode;
			psNewNode->NextNode = psTemp;
			return PGCTRUE;
		}
	}
	delete []psNewNode;
	return PGCFALSE;
}



// 函数名	    : DisableSec
// 函数说明	    : 使指定的段及其下属的各个项目无效
// 返回值说明	: PGCBOOL --
// 参数说明     : psHead --
// 参数说明     : iSecPos --
// 参数说明     : psCacheEntry --
PGCBOOL DisableSec(SItemSequence * &psHead, pgc32 iSecPos, SItemInCache *psCacheEntry)
{
	SItemSequence *psTemp = NULL;
	
	if (psHead == NULL) 
		return PGCFALSE;
	
	psTemp = psHead;
	while (psTemp != NULL)
	{
		if (psTemp->iPos == iSecPos)
			break;
		psTemp = psTemp->NextNode;
	}
	while (psTemp != NULL)
	{
		psCacheEntry[psTemp->iPos].valid = PGCFALSE;
		psTemp = psTemp->NextNode;
		if ((psTemp == NULL) || (psCacheEntry[psTemp->iPos].bIsSecName))
		{
			return PGCTRUE;
		}
	}
	return PGCFALSE;
}



//添加一个节点到顺序链表尾部
PGCBOOL AddNode(SItemSequence * &psHead, SItemSequence * &pCurSeq, pgc32 iPos)
{
	SItemSequence *psNewNode = NULL;
	
	psNewNode = new SItemSequence[1];
	psNewNode->iPos = iPos;
	psNewNode->NextNode = NULL;
	
	if (psHead == NULL)
	{
		psHead = psNewNode;
		pCurSeq = psHead;	
	}
	else
	{
		if (pCurSeq)
		{
		    pCurSeq->NextNode = psNewNode;
		    pCurSeq = psNewNode;
		}
	}
	
	return PGCTRUE;
}


void ReleaseProfileCache(HPROFILE hProfile)
{
	FILE *fstream = NULL;
	TChainHash<SItemInCache> *pHashTable = NULL;
	SItemSequence *pSequence = NULL, *psPrior = NULL;
    SItemInCache *psCacheEntry = NULL;
	SMemoChain *psMemo = NULL, *psMemoPrior = NULL;
	pgc32 iCurItemCount = 0;
	
	fstream = g_pHandleIndex[hProfile].fstream ;
	if (fstream != NULL)
		fclose(fstream);
	
	pHashTable = g_pHandleIndex[hProfile].pHashTable;
	if (pHashTable != NULL)
		delete pHashTable;
	
	pSequence = g_pHandleIndex[hProfile].pSequence;
	//删除该链表的所有节点
	while (pSequence != NULL)
	{
		psPrior = pSequence;
		pSequence = pSequence->NextNode;
		delete []psPrior;
	}
	
	
	iCurItemCount = g_pHandleIndex[hProfile].CurUseItems;
	psCacheEntry = g_pHandleIndex[hProfile].pCacheEntry;
	//首先释放注释节点
	if (psCacheEntry != NULL)
	{
		for (pgc32 i = 0; i < iCurItemCount; i++)
		{
			psMemo = psCacheEntry[i].memo;
			while (psMemo != NULL)
			{
				psMemoPrior = psMemo;
				psMemo = psMemo->NextNode;
				delete []psMemoPrior->szMemo;
				delete []psMemoPrior;
			}
		}
		free(psCacheEntry);
	}
	
	return;
}


//调整缓冲区大小
pgcu32 AdjustCache(HPROFILE hCacher, pgc32 iNewItem)
{
	pgc32 iOldSize = g_pHandleIndex[hCacher].CurItemCount, iNewSize = 0;
	pgc32 iOldUse = g_pHandleIndex[hCacher].CurUseItems;
	SItemInCache *pCacheEntry = NULL;
	
	if ((g_pHandleIndex[hCacher].CurUseItems + iNewItem ) >= iOldSize)
	{
		
		iNewSize = iOldSize + RESIZE_ITEM_NUM;
		pCacheEntry = (SItemInCache*)malloc(iNewSize * sizeof(SItemInCache));
		if (pCacheEntry == NULL)
			return ERROR_MEMORY_ALLOC;
		memset(pCacheEntry, 0, iNewSize * sizeof(SItemInCache));
		memmove(pCacheEntry, g_pHandleIndex[hCacher].pCacheEntry, iOldSize * sizeof(SItemInCache));
		free(g_pHandleIndex[hCacher].pCacheEntry);
		g_pHandleIndex[hCacher].CurItemCount = iNewSize;
		g_pHandleIndex[hCacher].pCacheEntry = pCacheEntry;
		
		//分离哈希表的所有数据项
		g_pHandleIndex[hCacher].pHashTable->detachItems();
		for (pgc32 i = 0; i < iOldUse; i++)
			g_pHandleIndex[hCacher].pHashTable->insertItem(pCacheEntry + i);
		return SUCCESS;
	}
	return ERROR_FAIL;      
}



// 函数名	    : get_file_lastMTime
// 函数说明	    : 获取文件上一次被修改的时间
// 返回值说明	: void --
// 参数说明     : pszfname --
// 参数说明     : pt --
pgc32 get_file_lastMTime(char * pszfname, timeval *pt)
{
	int ret = 0;

	struct stat buf;

	memset((void *)&buf, 0, sizeof(buf));
	
	ret = stat(pszfname, &buf);
	if(-1 == ret)
		return ERROR_FAIL;

    pt->tv_sec = buf.st_mtime;
	pt->tv_usec = 0;
	return SUCCESS;
}



//将缓冲的数据重新写成文件
pgc32 ReWriteProfile(HPROFILE hProfile)
{
	pgc32 iSize = 0;
	pgcchar *pcFileBuffer = NULL, *pcTemp = NULL;
	pgcchar *pcHead = NULL;
	PGCBOOL bSecExist = PGCFALSE;
	SItemSequence * psSeq =  g_pHandleIndex[hProfile].pSequence ;
	SItemInCache *psCacheEntry = g_pHandleIndex[hProfile].pCacheEntry, *psTemp = NULL;
	SMemoChain *psMemo = NULL;
	FILE *stream = /*g_pHandleIndex[hProfile].fstream*/0;
	iSize = (g_pHandleIndex[hProfile].CurLines + 2) * (MAX_CHAR_LINE + 2);
	
    if (( pcHead = (pgcchar*)malloc(iSize)) != NULL)
	{
		pcFileBuffer = pcHead;
		memset(pcFileBuffer, 0, iSize);
        while (psSeq != NULL)
		{
			psTemp = psCacheEntry + psSeq->iPos;
			if (psTemp->valid)
			{
				//有注释吗？
				psMemo = psTemp->memo;
				while (psMemo != NULL)
				{
					//写一行注释
					pcTemp = psMemo->szMemo;
					while (*pcTemp != '\0')
					{
						*pcFileBuffer = *pcTemp;
						pcFileBuffer++;
						pcTemp++;
					}
#ifdef LINE_EXCLUDE_0A
					*pcFileBuffer = '\n';
					pcFileBuffer += 1;
#else
					*pcFileBuffer = '\r';
					*(pcFileBuffer + 1) = '\n';
					pcFileBuffer += 2;
#endif
					psMemo = psMemo->NextNode;
				}
				
				//是段吗？
				if (psTemp->bIsSecName)
				{
					if (bSecExist)
					{
#ifdef LINE_EXCLUDE_0A
						*pcFileBuffer = '\n';
						pcFileBuffer += 1;
#else
						*pcFileBuffer = '\r';
						*(pcFileBuffer + 1) = '\n';
						pcFileBuffer += 2;
#endif
					}
					else
						bSecExist = PGCTRUE;
					
					*pcFileBuffer = '[';
					pcFileBuffer++;
					pcTemp = psTemp->szSecName;
					while (*pcTemp != '\0')
					{
						*pcFileBuffer = *pcTemp;
						pcFileBuffer++;
						pcTemp++;
					}
					*pcFileBuffer = ']';
#ifdef LINE_EXCLUDE_0A
					*(pcFileBuffer + 1) = '\n';
					pcFileBuffer += 2;
#else
					*(pcFileBuffer + 1) = '\r';
					*(pcFileBuffer + 2) = '\n';
					pcFileBuffer += 3;
#endif
					
				}
				else
				{
					pcTemp = psTemp->szItemName;
					while (*pcTemp != '\0')
					{
						*pcFileBuffer = *pcTemp;
						pcFileBuffer++;
						pcTemp++;
					}
					*pcFileBuffer = '=';
					pcFileBuffer++;
					pcTemp = psTemp->szItemVal;
					while (*pcTemp != '\0')
					{
						*pcFileBuffer = *pcTemp;
						pcFileBuffer++;
						pcTemp++;
					}
#ifdef LINE_EXCLUDE_0A
					*pcFileBuffer = '\n';
					pcFileBuffer += 1;
#else
					*pcFileBuffer = '\r';
					*(pcFileBuffer + 1) = '\n';
					pcFileBuffer += 2;
#endif
				}// end else
			}// end if "valid"
			psSeq = psSeq->NextNode;
		}// end while
		
		//2002/03/05 杨小波++++++++++++++++++++++++++++++++++++++++++++
#if	0
		pgcu32 numwritten = (pgcu32)pcFileBuffer - (pgcu32)pcHead ;
#endif
		pgcu32 numwritten = (pgcu32)(pcFileBuffer - pcHead) ;
		//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++


#ifdef OS_WINDOWS
		//windows下打开文件
		/*if ((stream = fopen(g_pHandleIndex[hProfile].szPathName, "w+b")) == NULL)
		{
			free(pcHead);
			return ERROR_FOPEN;
		}*/
#else
		//unix下打开文件
		/*PGCBOOL bOpenOK = PGCFALSE;
		do
		{
			errno = 0;
			if ((stream = fopen(g_pHandleIndex[hProfile].szPathName, "w+b")) != NULL)
			{
				bOpenOK = PGCTRUE;
				break;
			}
		}
		while (errno == EINTR);
		
		if (!bOpenOK)
		{
			free(pcHead);
			return ERROR_FOPEN;
		}*/
		//ghConfig = DSOpenFile("g_pHandleIndex[hProfile].szPathName");

#endif
	
		fseek(stream, 0, SEEK_SET);
		//函数fwrite在写数据到文件时，如遇字符NULL，会产生错误，从而使文件无法定位结尾
		pgc32 numwritted  = (pgc32)fwrite(pcHead, sizeof( pgcchar ), numwritten , stream );
		free(pcHead);
		fclose(stream);
		//记录下修改文件的时间
		get_file_lastMTime(g_pHandleIndex[hProfile].szPathName, &g_pHandleIndex[hProfile].tLastModify);
        if (numwritted != numwritten)
		{
			return ERROR_FWRITE;
		}
		return SUCCESS;

	}// end if
	return ERROR_FAIL;
}


int timeval_compare(timeval * ptv1, timeval * ptv2)
{
	int del_sec = ptv1->tv_sec - ptv2->tv_sec;
	int del_usec = ptv1->tv_usec - ptv2->tv_usec;

	return (del_sec != 0) ? del_sec : del_usec;
}


// 函数名	    : ReCreateCache
// 函数说明	    : 当有当前进程以外的进程修改配置文件后，需要调用此函数重建配置文件缓冲
// 返回值说明	: void --
// 参数说明     : hProfile --
void ReCreateCache(HPROFILE hProfile)
{
  timeval tLastModify, *ptRecModify = NULL;
  pgcchar *szProfileName = g_pHandleIndex[hProfile].szPathName;
  ptRecModify = &g_pHandleIndex[hProfile].tLastModify;
  if (szProfileName == 0) 
	  return;

  if (get_file_lastMTime(szProfileName, &tLastModify) == SUCCESS)
  {
	if (timeval_compare(&tLastModify, ptRecModify) > 0)
	{
		ReleaseProfileCache(hProfile);
		ProcessCreateCache(hProfile);
	}
  }
  return;
}


pgc32 ProcessCreateCache(HPROFILE hProfile)
{
	pgcchar *pcFileBuffer = NULL, *pcTemp = NULL, *pcStart = NULL, *pcEnd = NULL;
	pgcchar *pcNextLine = NULL, *pcTemp1 = NULL ;
	pgcchar szSecName[MAX_CHAR_LINE], CurItemName[MAX_CHAR_LINE], CurItemVal[MAX_CHAR_LINE];
	SItemInCache *psTemp = NULL;
	SMemoChain *psMemoTep = NULL, *psMemo = NULL;
	TChainHash<SItemInCache> * phash_table = NULL;
	PGCBOOL bSecNameExist = PGCFALSE;
	FILE *fstream = NULL;
	long lFileLength = 0;
	SItemInCache *psCacheEntry = NULL, *psCacheTep = NULL;
	pgc32 iCount = 0, iPos = 0, iCurSec = 0, iCurItem = 0, iCurItemCount = 0;
	//iCurLineType:当前行类型 0－不能确定 ；1－注释行； 2－段名 ；3－项目内容，4－空行
	pgc32 iCurLineType = 0, iLines = 0, i = 0;
	pgcchar szProfileName[MAX_PATH_NUM];

	memset(szProfileName, 0, MAX_PATH_NUM);
	//保存文件全路径名
#ifdef OS_WINDOWS
	lstrcpyn((LPWSTR)szProfileName, (LPWSTR)g_pHandleIndex[hProfile].szPathName, MAX_PATH_NUM);
#else
	strncpy(szProfileName, g_pHandleIndex[hProfile].szPathName, MAX_PATH_NUM - 1);
#endif

	memset(&g_pHandleIndex[hProfile], 0, sizeof(SProfileHanleInfo));
//#ifdef OS_WINDOWS
		//windows下打开文件
		if ((fstream = fopen(szProfileName, "r+b")) == NULL)
		{
			return ERROR_FOPEN;
		}
/*#else
		//unix下打开文件
		PGCBOOL bOpenOK = PGCFALSE;
		do
		{
			errno = 0;
			if ((fstream = fopen(szProfileName, "r+b")) != NULL)
			{
				bOpenOK = PGCTRUE;
				break;
			}
		}
		while (errno == EINTR);
		
		if (!bOpenOK)
			return ERROR_FOPEN;
#endif*/
	
		if (fseek(fstream, 0, SEEK_END) != 0)
		{
			fclose(fstream);
			return 0;
		}
		
		//获取文件长度
		lFileLength = ftell(fstream);
		pcTemp = new pgcchar[lFileLength + 1];
		if (pcTemp == NULL)
		{
			fclose(fstream);
			return 0;
		}
		memset(pcTemp, 0, lFileLength + 1);
		if (fseek(fstream, 0, SEEK_SET) != 0)
		{
			fclose(fstream);
			return 0;
		}
		//将文件读入缓冲
		if ((iCount = (pgc32)fread(pcTemp, sizeof( pgcchar ), lFileLength, fstream)) != lFileLength)
		{
			fclose(fstream);
			return ERROR_FREAD;
		}
		
		
		
		//格式化流（去除每一行前面的多余空格）
		pcStart = pcTemp;
		pcEnd = pcTemp + iCount;
		while ((pcStart != NULL) && (pcStart < pcEnd))
		{
			if (*pcStart == ' ')
			{
				*pcStart = 0;
				pcStart ++;
			} 
			else
			{
				if (*pcStart == '\n') 
					pcStart ++;
				else
				{
					if ((pcStart = strchr(pcStart, '\n')) == NULL) break;
					pcStart ++;
				}
			}
		}// end while
		
		
		
		//格式化流（去除每一行结束标志"\r\n"中的"\r"标志,仅保留"\n"标志）
		pcStart = pcTemp;
		while ((pcStart != NULL) && (pcStart < pcEnd))
		{
			if ((*pcStart == '\r') && (*(pcStart + 1) == '\n'))
			{
				*pcStart = 0;
				pcStart +=2;
			}
			else
				pcStart++;
		}// end while
		
		
		
		//统计行数
		pcStart = pcTemp;
		while ((pcStart != NULL) && (pcStart < pcEnd))
		{
			if (*pcStart == '\n')
			{
				iLines++;
			}
			pcStart++;
		}// end while
		iLines++;
		g_pHandleIndex[hProfile].CurLines = iLines;
		
		//重建文件缓冲
		pcFileBuffer = new pgcchar[iCount + 1];
		memset(pcFileBuffer, 0, iCount + 1);
		for ( i = 0; i < iCount; i++)
		{
			if (pcTemp[i] != 0)
			{
				pcFileBuffer[iPos] = pcTemp[i];
				iPos++;
			}
		}
		delete []pcTemp;
		
		
		
		//分配配置项缓冲
		psCacheEntry = (SItemInCache *)malloc(INITCACHE_ITEM_NUM * sizeof(SItemInCache));
		if (psCacheEntry == NULL)
		{
			if (pcFileBuffer != NULL)
				delete []pcFileBuffer;
			fclose(fstream);
			return ERROR_MEMORY_ALLOC;
		}
		memset(psCacheEntry, 0, INITCACHE_ITEM_NUM * sizeof(SItemInCache));
		iCurItemCount = INITCACHE_ITEM_NUM;
		g_pHandleIndex[hProfile].fstream = fstream;
		g_pHandleIndex[hProfile].pHashTable = NULL;
		g_pHandleIndex[hProfile].pSequence = NULL;
		g_pHandleIndex[hProfile].pCurSeq = NULL;
		g_pHandleIndex[hProfile].CurItemCount = iCurItemCount;
		g_pHandleIndex[hProfile].pCacheEntry = psCacheEntry;
		
		//提取各段
		pcStart = pcFileBuffer;
		pcEnd = NULL;
		while ((pcStart != NULL) && (pcStart < (pcFileBuffer + iPos)))
		{
			//寻找段尾
			pcEnd = FindSecTail(pcStart + 1);
			
			if (pcEnd != NULL)
				*(pcEnd - 1) = '\0';
			
			//检查行类型
			while (pcStart != NULL)
			{
				//确定下一行的位置
				if ((pcNextLine = strchr(pcStart, '\n')) != NULL)
				{
					//如果为空行
					if (pcStart == pcNextLine)
						iCurLineType = 4;
					*pcNextLine = '\0';
					pcNextLine++;
				}
				
				if (iCurLineType != 4)
				{
					//检查当前行是否为注释行
					if (LineIsMark(pcStart))
					{
						iCurLineType = 1;
					}
					else
					{
						pcTemp = strchr(pcStart, '[');
						pcTemp1 = strchr(pcStart, ']');
						//如果当前行是段名，则提取段名
						if ( pcTemp && pcTemp1 && (pcTemp1 > pcTemp))
						{
							DigSecName(pcStart, szSecName, MAX_CHAR_LINE);
							iCurLineType = 2;
						}
						else
						{
							pcTemp = strchr(pcStart, '=');
							//如果当前行是项目记录，则提取项目名及项目值
							if (pcTemp != NULL)
							{
								DigItemContent(pcStart, CurItemName, CurItemVal, MAX_CHAR_LINE);
								iCurLineType = 3;
							}
							else
								iCurLineType = 0;
						}
					}// end else
				}
				
				switch (iCurLineType)
				{
					//如果是注释行,或空行
				case 1:
				case 4:
					//将注释行添加入节点
					psMemoTep = psMemo;
					if (psMemoTep != NULL)
					{
						while (psMemoTep->NextNode != NULL)
						{
							psMemoTep = psMemoTep->NextNode;
						}// end while
						psMemoTep->NextNode = new SMemoChain[1];
						if (iCurLineType == 1)
						{
							psMemoTep->NextNode->szMemo = new pgcchar[strlen(pcStart) + 1];
							strcpy(psMemoTep->NextNode->szMemo, pcStart);
						}
						else if (iCurLineType == 4)
						{
#ifdef LINE_EXCLUDE_0A
							psMemoTep->NextNode->szMemo = new pgcchar[2];
							psMemoTep->NextNode->szMemo[0] = '\0';
							psMemoTep->NextNode->szMemo[1] = '\0';
#else
							psMemoTep->NextNode->szMemo = new pgcchar[3];
							psMemoTep->NextNode->szMemo[0] = '\0';
							psMemoTep->NextNode->szMemo[1] = '\n';
							psMemoTep->NextNode->szMemo[2] = '\0';
#endif
						}
						psMemoTep->NextNode->NextNode = NULL;
					}// end if
					else
					{
						psMemo = new SMemoChain[1];
						if (iCurLineType == 1)
						{
							psMemo->szMemo = new pgcchar[strlen(pcStart) + 1];
							strcpy(psMemo->szMemo, pcStart);
						}
						else if (iCurLineType == 4)
						{
#ifdef LINE_EXCLUDE_0A
							psMemo->szMemo = new pgcchar[2];
							psMemo->szMemo[0] = '\0';
							psMemo->szMemo[1] = '\0';
#else
							psMemo->szMemo = new pgcchar[3];
							psMemo->szMemo[0] = '\0';
							psMemo->szMemo[1] = '\n';
							psMemo->szMemo[2] = '\0';
#endif
						}
						psMemo->NextNode = NULL;
					}// end else
					
					break;
					
					//如果是段名
				case 2:
					psTemp = &psCacheEntry[iCurItem];
					strcpy(psTemp->szSecName, szSecName);
					psTemp->valid = PGCTRUE;
					psTemp->bIsSecName = PGCTRUE;
					psTemp->memo = psMemo;
					
					AddNode(g_pHandleIndex[hProfile].pSequence, g_pHandleIndex[hProfile].pCurSeq, iCurItem);
					bSecNameExist = PGCTRUE;
					iCurItem ++; 
					psMemo = NULL;
					break;
					//如果是项目赋值
				case 3:
					if (bSecNameExist)
					{
						psTemp = &psCacheEntry[iCurItem];
						strcpy(psTemp->szSecName, szSecName);
						strcpy(psTemp->szItemName, CurItemName);
						strcpy(psTemp->szItemVal, CurItemVal);
						psTemp->valid = PGCTRUE;
						psTemp->bIsSecName = PGCFALSE;
						psTemp->memo = psMemo;
						
						AddNode(g_pHandleIndex[hProfile].pSequence, g_pHandleIndex[hProfile].pCurSeq, iCurItem);
						iCurItem ++; 
						psMemo = NULL;
					}//end if
					break;
					//default:
				}// end switch
				
				iCurLineType = 0;

				//如果原先的缓冲区太小，则递增缓冲区
				if (iCurItem >= iCurItemCount) 
				{
					psCacheTep = (SItemInCache*)malloc((iCurItemCount + RESIZE_ITEM_NUM) * sizeof(SItemInCache));
					if (psCacheTep == NULL)
					{
						ReleaseProfileCache(hProfile);
						return ERROR_MEMORY_ALLOC;
					}
					memset(psCacheTep, 0, (iCurItemCount + RESIZE_ITEM_NUM) * sizeof(SItemInCache));
					memmove(psCacheTep, psCacheEntry, sizeof(SItemInCache) * iCurItemCount);
					free(psCacheEntry);
					psCacheEntry = psCacheTep;
					iCurItemCount = iCurItemCount + RESIZE_ITEM_NUM;
					g_pHandleIndex[hProfile].CurItemCount = iCurItemCount;
					g_pHandleIndex[hProfile].pCacheEntry = psCacheEntry;
				}// end if
				
				pcStart = pcNextLine;
	  }// end while
	  bSecNameExist = PGCFALSE;
	  pcStart = pcEnd;
  }// end while
  
  if (pcFileBuffer != NULL)
	  delete []pcFileBuffer;
  
  pgc32 iRev = -1;
  
  //创建哈希表
  iRev = profile_build_hash_index(psCacheEntry, iCurItem , &phash_table);
  if (iRev != SUCCESS)
  {
	  ReleaseProfileCache(hProfile);
	  return  ERROR_CONF_CREATEHASH ;
  }
  
  g_pHandleIndex[hProfile].pHashTable = phash_table;
  g_pHandleIndex[hProfile].CurUseItems = iCurItem ;
  g_pHandleIndex[hProfile].CurSecNum = iCurSec;
  
  fstream =	g_pHandleIndex[hProfile].fstream;
  g_pHandleIndex[hProfile].fstream = 0;
  fclose(fstream);
  	//保存文件全路径名
#ifdef OS_WINDOWS
	lstrcpyn((LPWSTR)g_pHandleIndex[hProfile].szPathName, (LPCWSTR)szProfileName, MAX_PATH_NUM);
#else
	strncpy(g_pHandleIndex[hProfile].szPathName, szProfileName, MAX_PATH_NUM - 1);
#endif
  //记录下修改文件的时间
  get_file_lastMTime(szProfileName, &g_pHandleIndex[hProfile].tLastModify);

  return SUCCESS;
}





//以下为应用接口
//-----------------------------------------------------------------------------------------

// 函数名	    : create_profile_cache
// 函数说明	    : 建立配置文件缓冲
// 返回值说明	: HPROFILE -- 成功则返回SUCCESS,失败则返回具体的执行失败的代码

//             返回值                               说明
//			   SUCCESS						成功建立配置文件缓冲
//		ERROR_CONF_NOHANDLE		建立配置文件缓冲失败，原因：没有空闲的配置文件缓冲句柄分配给当前配置文件缓冲
//			ERROR_FOPEN                      打开文件失败
//			ERROR_FREAD                      读文件失败
//       ERROR_CONF_CREATEHASH               建立哈希表失败
//		   ERROR_MEMORY_ALLOC          申请分配指定大小的内存失败
//      ERROR_CONF_NULL_HANDEPTR       输入了一个空的句柄指针作参数

// 参数说明     : szProfileName --[in] 配置文件全路径名
// 参数说明     : phfile --[out]如果函数执行成功，则返回一个句柄
int create_profile_cache(pgcchar *szProfileName, int *phfile)
{
	HPROFILE hCurCacher = 0;

	if (szProfileName == NULL)
		return ERROR_FOPEN ;

	if (phfile == NULL)
		return ERROR_CONF_NULL_HANDEPTR;

	//检查句柄数组是否经过初始化
	if (!g_bHandleInit)
	{
		memset(g_pHandleIndex, 0, MAX_PROFILEHANDLE_NUM * sizeof(SProfileHanleInfo));
		g_bHandleInit = PGCTRUE;
	}
	
	//为当前缓冲寻找一个空闲句柄
	for (int i = 1; i < MAX_PROFILEHANDLE_NUM; i++)
		if (g_pHandleIndex[i].pCacheEntry == NULL)
		{
			hCurCacher = i;
			break;
		}
		
		if ( hCurCacher < 1)
		{
			return ERROR_CONF_NOHANDLE;
		}

		//保存文件全路径名
#ifdef OS_WINDOWS
		lstrcpyn((LPWSTR)g_pHandleIndex[hCurCacher].szPathName, (LPWSTR)szProfileName, MAX_PATH_NUM);
#else
		strncpy(g_pHandleIndex[hCurCacher].szPathName, szProfileName, MAX_PATH_NUM - 1);
#endif
		pgc32 iExeRev = 0;
		if ((iExeRev = ProcessCreateCache(hCurCacher)) != SUCCESS)
			return iExeRev;
 
        *phfile = hCurCacher;
		return SUCCESS;
}



// 函数名	    : CloseProfileHandle
// 函数说明	    : 关闭配置文件缓冲
// 函数逻辑     : 根据在该配置文件缓冲句柄中记录的信息，释放资源
// 返回值说明	: int -- 成功则返回SUCCESS,失败则返回具体的执行失败的代码

//             返回值                               说明
//			   SUCCESS						成功关闭配置文件缓冲
//		ERROR_CONF_INVALIDHANDLE		输入了非法的配置文件缓冲句柄

// 参数说明     : hProfile --[in]配置文件缓冲句柄
int close_profile_handle(HPROFILE hProfile)
{
	if ((hProfile < 1) || (hProfile >= MAX_PROFILEHANDLE_NUM))
		return ERROR_CONF_INVALIDHANDLE;

	ReleaseProfileCache(hProfile);

	memset(&g_pHandleIndex[hProfile], 0, sizeof(SProfileHanleInfo));

	return SUCCESS;
}


// 函数名	    : GetPgcProfileString
// 函数说明	    : 根据段名，项目名获取项目值
// 函数逻辑     : 调用者通过参数lpAppName， lpKeyName传入要取出的项目值所在的段名和项目名，
//                如果指定的段及项目名存在，函数将取出的项目值拷贝到以lpReturnedString为首地址的
//                目标缓冲中(目标缓冲的长度通过指针pdwSize传入)，随后函数会将取出的项目值
//                的长度(包括'\0'字符)写入地址指针pdwSize中； 如果指定的段及项目名不存在，则执行缺省拷贝，即将
//                lpDefault 所指向的字符串拷贝到目标缓冲区lpReturnedString中; 如果目标缓冲区的首地址
//				  lpReturnedString为空或传入的目标缓冲的长度小于1，那么函数不会将任何字符串拷贝到
//                目标缓冲，但是仍会将取出的项目值的长度(包括'\0'字符)写入到指针pdwSize所指向的地址中。  
//                    
//								             
// 返回值说明	: int --  成功则返回SUCCESS,失败则返回具体的执行失败的代码

//             返回值                               说明
//			 SUCCESS			   如果指定的段及项目名存在，函数将取出的项目值拷贝到以lpReturnedString为首地址的
//								   目标缓冲中，如果取出的项目值的长度小于或等于目标缓冲区的长度，那么整个项目值将
//		    			           被完全拷贝到目标缓冲中，此时函数返回SUCCESS

//		 ERROR_CONF_REVBUFFER      如果指定的段及项目名存在,但是取出的项目值的长度大于目标缓冲
//					               区的长度, 那么取出的项目值将被截断为和目标缓冲区一样的大小，然后再拷贝到目标缓
//								   区，此时函数返回ERROR_CONF_REVBUFFER

//
//		 SUCCESS_CONF_DEFCOPY      如果指定的段及项目名不存在，并且lpDefault指针不为空，则函数将lpDefault
//								   所指向的字符串拷贝到目标缓冲区lpReturnedString，如果lpDefault指向的字符串
//								   的长度大于目标缓冲区的长度，那么只从lpDefault开始拷贝 [目标缓冲区的长度 － 1]
//                                 个字符到缓冲中。

//		ERROR_CONF_INVALIDHANDLE   输入了非法的配置文件缓冲句柄

//			 ERROR_FAIL            函数执行失败，即未拷贝任何字符到目标缓冲区
 
// 参数说明     : lpAppName --[in]段名
// 参数说明     : lpKeyName --[in]项目名
// 参数说明     : lpDefault --[in] 当获取指定的项目值失败时，将该缓冲区的字符串写入lpReturnedString目标缓冲
// 参数说明     : lpReturnedString --[out] 目标缓冲区，用来存放取出的项目值
// 参数说明     : pdwSize -- [in][out]指向缓冲区的长度的指针，同时在调用结束后，将取出的项目字符串的长度(包括'\0'字符)写入该地址
// 参数说明     : hProfile --[in] 配置文件缓冲句柄
int get_pgcprofile_string(
							 const pgcchar * lpAppName,        // points to section name
							 const pgcchar * lpKeyName,         // point to key name
							 const pgcchar * lpDefault,         // point to default string
							 pgcchar * lpReturnedString,   // point to destination buffer
							 pgcu32 * pdwSize,               // point to size of destination buffer
							 HPROFILE hProfile     // point to initialization filename
							 )
{
	SItemInCache *psTemp = NULL;
	TChainHash<SItemInCache> *phash_table = NULL;
	pgcu32 dwBuffer = 0, dwCount = 0, dwNeed = 0;
	//bRevBuffer - PGCTRUE表示接收缓冲区足够大
	PGCBOOL bRevBuffer = PGCTRUE;
	
	if ((hProfile < 1) || (hProfile >= MAX_PROFILEHANDLE_NUM))
		return ERROR_CONF_INVALIDHANDLE;
	
	if ((lpAppName == NULL) || ( lpKeyName == NULL))
		return ERROR_FAIL;

	ReCreateCache(hProfile);

	phash_table = g_pHandleIndex[hProfile].pHashTable;
	if (phash_table == NULL)
		return ERROR_CONF_INVALIDHANDLE;
	
	profile_search_sequence(&psTemp, phash_table, lpAppName, lpKeyName);
	if ((psTemp != NULL) && (psTemp->valid) && (pdwSize != NULL))
	{
		dwBuffer = (pgcu32)strlen(psTemp->szItemVal) + 1;
		dwNeed = dwBuffer;
		if (dwBuffer > *pdwSize)
		{
			dwBuffer = *pdwSize;
			bRevBuffer = PGCFALSE;
		}
		if ((lpReturnedString != NULL) && (dwBuffer > 0))
		{
			for (dwCount = 0; dwCount < dwBuffer - 1; dwCount++)
				lpReturnedString[dwCount] = psTemp->szItemVal[dwCount];
			
			lpReturnedString[dwCount] = '\0';
		}
	}
	else
	{
		//执行缺省拷贝
		if ((lpDefault != NULL) && (pdwSize != NULL))
		{
			dwBuffer = (pgcu32)strlen(lpDefault) + 1;
			dwNeed = dwBuffer;
			if (dwBuffer > *pdwSize)
			{
				dwBuffer = *pdwSize;
				bRevBuffer = PGCFALSE;
			}
			if ((dwBuffer > 0) && (lpReturnedString != NULL))
			{
				//2002/03/05 杨小波++++++++++++++++++++++++++++++++++++++++++++
#if	0
				for (pgcu32 dwCount = 0; dwCount < dwBuffer - 1; dwCount++)
#endif			
				for (dwCount = 0; dwCount < dwBuffer - 1; dwCount++)
				//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
					lpReturnedString[dwCount] = lpDefault[dwCount];

				lpReturnedString[dwCount] = '\0';
			}
		}
		else
			dwBuffer = 0;
	}
	*pdwSize = dwNeed;

	if (dwBuffer == 0)
		return ERROR_FAIL;
	
	if (!bRevBuffer) 
		return	ERROR_CONF_REVBUFFER;
	
	return SUCCESS;
}



// 函数名	    : WritePgcProfileString
// 函数说明	    : 根据段名，项目名写项目值
// 函数逻辑     : 调用者通过参数lpAppName， lpKeyName传入要写入的项目值所在的段名和项目名，
//                如果指定的段及项目名存在，函数将把lpString所指向的以空字符结尾的字符串拷贝到
//				  以该段名，项目名对应的项目值缓冲中，然后再把整个配置文件缓冲的内容写入到文件中,
//				  并返回SUCCESS;如果指定的段及项目名不存在，函数会根据参数bInsertItem的值决定是否将输入的段名以及
//                项目名添加到配置文件中，如果bInsertItem为真，则添加该段名和项目名，然后写入项目值，
//                并返回SUCCESS; 如果bInsertItem为假，函数返回ERROR_FAIL。

// 返回值说明	: int -- 成功则返回SUCCESS,失败则返回具体的执行失败的代码

//            返回值                               说明
//			 SUCCESS			   如果指定的段及项目名存在，函数将把lpString所指向的以空字符结尾的字符串拷贝到
//								   以该段名，项目名对应的项目值缓冲中，然后再把整个配置文件缓冲的内容写入到文件中,
//					    		   并返回SUCCESS
//         ERROR_FWRITE            写文件错误
//		ERROR_CONF_INVALIDHANDLE   输入了非法的配置文件缓冲句柄
// ERROR_CONF_INPUTSTRING_TOOLARGE 输入的段名，项目名，项目值的字符串长度超长
//			 ERROR_FAIL            函数执行失败，即未将任何字符写到配置文件缓冲区以及文件
 
// 参数说明     : lpAppName[in] -- 段名
// 参数说明     : lpKeyName[in] -- 项目名
// 参数说明     : lpString[in] -- 要写入的字符串
// 参数说明     : hProfile[in] -- 配置文件缓冲句柄
// 参数说明     : bInsertItem[in] -- 当指定的段名或项目名不存在时，是否添加该段或项目；PGCTRUE-添加；PGCFALSE-不添加（缺省）
int write_pgcprofile_string(
							   const pgcchar *  lpAppName,  // point to section name
							   const pgcchar *  lpKeyName,  // point to key name
							   const pgcchar *  lpString,   // point to string to add
							   HPROFILE hProfile,     // handle to Profile Cache
							   PGCBOOL bInsertItem       
							   )
{
	SItemInCache *psTemp = NULL, *psCacheEntry = NULL, *psSec = NULL;
	TChainHash<SItemInCache> *phash_table = NULL;
	pgc32 iBuffer = 0, iCurItem = 0, iSecPos = 0, i = 0, iWriteSuccess = 0;
	PGCBOOL bSecExist = PGCFALSE;
	PGCBOOL bTrunc = PGCFALSE ;/*写入的字符串是否被截断*/
	
	//输入句柄合法性检查
	if ((hProfile < 1) || (hProfile >= MAX_PROFILEHANDLE_NUM))
		return ERROR_CONF_INVALIDHANDLE;
	
	//输入段名及项目名合法性检查
	if ((lpAppName == NULL) || ( lpKeyName == NULL))
		return ERROR_FAIL;

	//判断输入字符串是否超长
	if (strlen(lpAppName) >= MAX_CHAR_LINE) 
		bTrunc = PGCTRUE;
	if (strlen(lpKeyName) >= MAX_CHAR_LINE) 
		bTrunc = PGCTRUE;
	if ( (lpString != NULL) && (strlen(lpString) >= MAX_CHAR_LINE))
		bTrunc = PGCTRUE;
    if (bTrunc)
		return ERROR_CONF_INPUTSTRING_TOOLARGE;

	//如果配置文件被其它进程修改,则重构缓冲
	ReCreateCache(hProfile);

	//哈希表合法性检查
	phash_table = g_pHandleIndex[hProfile].pHashTable;
	if (phash_table == NULL)
		return ERROR_CONF_INVALIDHANDLE;
	
	psCacheEntry = g_pHandleIndex[hProfile].pCacheEntry;
	
    psTemp = NULL;
	profile_search_sequence(&psTemp, phash_table, lpAppName, lpKeyName);
	if ((psTemp == NULL) && (bInsertItem))
	{
		//检查该段名是否已经存在
		profile_search_sequence(&psSec, phash_table, lpAppName, NULL);
		if (psSec != NULL)
		{
			pgcu32 a1, a2;

			//2002/03/05 杨小波++++++++++++++++++++++++++++++++++++++++++++
#if	0
			a1 = (pgcu32)psSec - (pgcu32)psCacheEntry;
#endif
			a1 = (pgcu32)(psSec - psCacheEntry);
			//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

			a2 = (pgcu32)sizeof(SItemInCache);
			iSecPos = a1  / a2;
			bSecExist = PGCTRUE;
			psSec->valid = PGCTRUE;
		}
		
		//重构缓冲区大小
        AdjustCache(hProfile, 2);
		psCacheEntry = g_pHandleIndex[hProfile].pCacheEntry;
		iCurItem = g_pHandleIndex[hProfile].CurUseItems;
		
		//应该插入新段名吗？
		if (!bSecExist)
		{
			psTemp = &psCacheEntry[iCurItem];
#ifdef OS_WINDOWS
			lstrcpyn((LPWSTR)psTemp->szSecName, (LPCWSTR)lpAppName, MAX_CHAR_LINE);	
#else
			memset(psTemp->szSecName, 0, MAX_CHAR_LINE);
			strncpy(psTemp->szSecName, lpAppName, MAX_CHAR_LINE - 1);
		
#endif	
			psTemp->valid = PGCTRUE;
			psTemp->bIsSecName = PGCTRUE;
			psTemp->memo = NULL;
			
			phash_table->insertItem(psTemp);
			AddNode(g_pHandleIndex[hProfile].pSequence, g_pHandleIndex[hProfile].pCurSeq, iCurItem);
			iSecPos = iCurItem;
			iCurItem++;
			g_pHandleIndex[hProfile].CurLines++;
		}
		//插入新项目名及项目值
		psTemp = &psCacheEntry[iCurItem];
		
#ifdef OS_WINDOWS
		lstrcpyn((LPWSTR)psTemp->szSecName, (LPCWSTR)lpAppName, MAX_CHAR_LINE);
		lstrcpyn((LPWSTR)psTemp->szItemName, (LPCWSTR)lpKeyName, MAX_CHAR_LINE);
		lstrcpyn((LPWSTR)psTemp->szItemVal, (LPCWSTR)lpString, MAX_CHAR_LINE);
#else
        memset(psTemp, 0, sizeof(SItemInCache));
		strncpy(psTemp->szSecName, lpAppName, MAX_CHAR_LINE - 1);
		strncpy(psTemp->szItemName, lpKeyName, MAX_CHAR_LINE - 1);
		strncpy(psTemp->szItemVal, lpString, MAX_CHAR_LINE - 1);
#endif
		
		psTemp->valid = PGCTRUE;
		psTemp->bIsSecName = PGCFALSE;
		psTemp->memo = NULL;
		
		
		phash_table->insertItem(psTemp);
		InsertNode(g_pHandleIndex[hProfile].pSequence, iCurItem, psCacheEntry, iSecPos);
		iCurItem++;
		
		g_pHandleIndex[hProfile].CurUseItems = iCurItem;
		g_pHandleIndex[hProfile].CurLines++;
		
		iBuffer = (pgc32)strlen(psTemp->szItemVal);
		psTemp = NULL;
		if ((iWriteSuccess = ReWriteProfile(hProfile)) != SUCCESS)
			return iWriteSuccess;
	}
		
	if ((psTemp == NULL) && (!bInsertItem))
		return ERROR_CONF_NOTEXIST;

	//如果指定段的项目存在则
	if ((psTemp != NULL) && (lpString != NULL))
	{
		if ((psTemp->valid) || (bInsertItem))
		{
			iBuffer = (pgc32)strlen(lpString);
			if (iBuffer >= MAX_CHAR_LINE)
				iBuffer = MAX_CHAR_LINE - 1;
			for (i = 0; i < iBuffer; i++)
				psTemp->szItemVal[i] = lpString[i];
			psTemp->szItemVal[i] = '\0';
			
			psTemp->valid = PGCTRUE;
			if ((iWriteSuccess = ReWriteProfile(hProfile)) != SUCCESS)
				return iWriteSuccess;
		}
	}
	return SUCCESS;
}



// 函数名	    : GetPgcProfileSectionNames
// 函数说明	    : 获取配置文件的所有段名
// 函数逻辑     ：将从配置文件中获取的段名按在文件中出现的先后次序写到pdwSize所指向的地址空间，
//				  每个段名以一个空字符作为结束标志，在最后一个段名的结尾处再多加一个空字符
//				  作为所有段名的结束标志，即内存格式为 ：段名1\0段名2\0......最后一个段名\0\0

// 返回值说明	: int -- 成功则返回SUCCESS,失败则返回具体的执行失败的代码
// 参数说明     : LPTSTR lpszReturnBuffer --[out] 写入缓冲区
// 参数说明     : pgcu32 *pdwSize -- [in][out]写入缓冲区的按字节长度
// 参数说明     : pgcu32 *nSecNum --[out]将获取的段总数写入该地址
// 参数说明     : hProfile-- [in] handle to Profile Cache
int get_pgcprofile_secnames(   pgcchar * lpszReturnBuffer,  // address of return buffer
							   pgcu32 * pdwSize,            // size of return buffer
							   pgcu32 *nSecNum,
							   HPROFILE hProfile      //  handle to Profile Cache
							)
{
	pgc32 iCount  =  g_pHandleIndex[hProfile].CurUseItems , iSecNum = 0, i = -1;
	pgcu32 dwWrite = 0, dwSize = 0, dwNeed = 0;
	SItemInCache *psCacheEntry = g_pHandleIndex[hProfile].pCacheEntry;
	pgcchar *szSec = NULL;
	
	if ((hProfile < 1) || (hProfile >= MAX_PROFILEHANDLE_NUM))
		return ERROR_CONF_INVALIDHANDLE;

	ReCreateCache(hProfile);

	if ((pdwSize != NULL) && (*pdwSize > 2))
		dwSize = *pdwSize - 2;
	
	if ((dwSize > 2) && (lpszReturnBuffer != NULL))
	{
		for (i = 0; i < iCount; i++)
		{
			if ((psCacheEntry[i].bIsSecName) && (psCacheEntry[i].valid))
			{
				szSec = psCacheEntry[i].szSecName;
				dwNeed = dwNeed + (pgcu32)strlen(szSec) + 1;
				iSecNum++;
				while ((dwWrite < dwSize ) && (*szSec != '\0'))
				{
					*lpszReturnBuffer = *szSec;
					dwWrite++;
					lpszReturnBuffer++;
					szSec++;
				}	
				*lpszReturnBuffer = '\0';
				lpszReturnBuffer++;
				dwWrite++;
				if (dwWrite >= dwSize)
					break;
			}// endif
		}// end for
		*lpszReturnBuffer = '\0';
	}
	//求所有段名的字符个数总和以及段个数
	for (pgc32 iStart = i + 1; iStart < iCount; iStart++)
	{
		if ((psCacheEntry[iStart].bIsSecName) && (psCacheEntry[iStart].valid))
		{
			iSecNum++;
			szSec = psCacheEntry[iStart].szSecName;
			if (szSec != NULL)
			{
				dwNeed = dwNeed + (pgcu32)strlen(szSec) + 1;
			}
		}
	}
	if (pdwSize)
		*pdwSize = dwNeed;
	if (nSecNum)
		*nSecNum = iSecNum;

	return SUCCESS;
}



// 函数名	    : del_pgcprofile_key
// 函数说明	    : 删除指定的项目
// 函数逻辑     ：在缓冲中删除指定的项目，以及该项目上方的注释，然后以覆盖方式重写文件。
                
// 返回值说明	: int -- 成功则返回SUCCESS,失败则返回具体的执行失败的代码
// 参数说明     : lpAppName --[in] 段名
// 参数说明     : lpKeyName -- [in]项目名
// 参数说明     : HPROFILE hProfile －-[in]配置文件的缓冲句柄
int del_pgcprofile_key( const pgcchar * lpAppName,    // point to section name
						  const pgcchar * lpKeyName,     // point to key name
						  HPROFILE hProfile        // point to initialization filename
						  )
{
	SItemInCache *psTemp = NULL;
	TChainHash<SItemInCache> *phash_table = NULL;
	pgc32 iWriteSuccess = 0;
	
	if ((hProfile < 1) || (hProfile >= MAX_PROFILEHANDLE_NUM))
		return ERROR_CONF_INVALIDHANDLE;
	
	if ((lpAppName == NULL) || ( lpKeyName == NULL))
		return ERROR_FAIL;

	ReCreateCache(hProfile);

	phash_table = g_pHandleIndex[hProfile].pHashTable;
	if (phash_table == NULL)
		return ERROR_CONF_INVALIDHANDLE;
	
	profile_search_sequence(&psTemp, phash_table, lpAppName, lpKeyName);
	if (psTemp != NULL)
	{
		psTemp->valid = PGCFALSE;
		if ((iWriteSuccess = ReWriteProfile(hProfile)) != SUCCESS)
			return iWriteSuccess;
		return SUCCESS;
	}
    return ERROR_CONF_NOTEXIST;	
}




// 函数名	    : del_pgcprofile_sec
// 函数说明	    : 删除指定的段
// 函数逻辑     ：在缓冲中删除指定的段，以及该段上方的注释，然后以覆盖方式重写文件；
//                在删除一个段的同时，该段下属的所有项目（包括项目上方的注释）将被删除
				  
// 返回值说明	: int -- 成功则返回SUCCESS,失败则返回具体的执行失败的代码
// 参数说明     : lpAppName --[in] 段名
// 参数说明     : HPROFILE hProfile －-[in]配置文件的缓冲句柄
int del_pgcprofile_sec( const pgcchar * lpAppName,   
						  HPROFILE hProfile       
						  )
{
	SItemInCache *psSec = NULL, *psCacheEntry = NULL;
	TChainHash<SItemInCache> *phash_table = NULL;
	pgc32 iSecPos = 0;
	
	if ((hProfile < 1) || (hProfile >= MAX_PROFILEHANDLE_NUM))
		return ERROR_CONF_INVALIDHANDLE;
	
	if (lpAppName == NULL)
		return ERROR_FAIL;

	psCacheEntry = g_pHandleIndex[hProfile].pCacheEntry;
	if (psCacheEntry == NULL)
		return ERROR_CONF_INVALIDHANDLE;

	ReCreateCache(hProfile);

	phash_table = g_pHandleIndex[hProfile].pHashTable;
	if (phash_table == NULL)
		return ERROR_CONF_INVALIDHANDLE;
	
	profile_search_sequence(&psSec, phash_table, lpAppName, NULL);
	if (psSec != NULL)
	{
		pgcu32 a1, a2;

		//2002/03/05 杨小波++++++++++++++++++++++++++++++++++++++++++++
#if	0
		a1 = (pgcu32)psSec - (pgcu32)psCacheEntry;
#endif
		a1 = (pgcu32)(psSec - psCacheEntry);
		//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

		a2 = (pgcu32)sizeof(SItemInCache);
		iSecPos = a1  / a2;
		if (DisableSec(g_pHandleIndex[hProfile].pSequence, iSecPos, psCacheEntry))
		{
			return ReWriteProfile(hProfile);
		}
	}
    return ERROR_CONF_NOTEXIST;		
}